2 Skeleton of function spudec_process_controll() is from xine sources.
4 LGB,... (yeah, try to improve it and insert your name here! ;-)
7 implement fragments reassembly, RLE decoding.
8 read brightness from the IFO.
10 For information on SPU format see <URL:http://sam.zoy.org/doc/dvd/subtitles/>
11 and <URL:http://members.aol.com/mpucoder/DVD/spu.html>
24 #include "libvo/video_out.h"
26 #include "libavutil/avutil.h"
27 #include "libswscale/swscale.h"
29 /* Valid values for spu_aamode:
30 0: none (fastest, most ugly)
33 3: bilinear (similiar to vobsub, fast and not too bad)
34 4: uses swscaler gaussian (this is the only one that looks good)
38 int spu_alignment
= -1;
39 float spu_gaussvar
= 1.0;
42 typedef struct packet_t packet_t
;
44 unsigned char *packet
;
45 unsigned int palette
[4];
46 unsigned int alpha
[4];
47 unsigned int control_start
; /* index of start of control data */
48 unsigned int current_nibble
[2]; /* next data nibble (4 bits) to be
49 processed (for RLE decoding) for
51 int deinterlace_oddness
; /* 0 or 1, index into current_nibble */
52 unsigned int start_col
, end_col
;
53 unsigned int start_row
, end_row
;
54 unsigned int width
, height
, stride
;
55 unsigned int start_pts
, end_pts
;
62 unsigned int global_palette
[16];
63 unsigned int orig_frame_width
, orig_frame_height
;
64 unsigned char* packet
;
65 size_t packet_reserve
; /* size of the memory pointed to by packet */
66 unsigned int packet_offset
; /* end of the currently assembled fragment */
67 unsigned int packet_size
; /* size of the packet once all fragments are assembled */
68 int packet_pts
; /* PTS for this packet */
69 unsigned int palette
[4];
70 unsigned int alpha
[4];
71 unsigned int cuspal
[4];
74 unsigned int start_pts
, end_pts
;
75 unsigned int start_col
, end_col
;
76 unsigned int start_row
, end_row
;
77 unsigned int width
, height
, stride
;
78 size_t image_size
; /* Size of the image buffer */
79 unsigned char *image
; /* Grayscale value */
80 unsigned char *aimage
; /* Alpha value */
81 unsigned int scaled_frame_width
, scaled_frame_height
;
82 unsigned int scaled_start_col
, scaled_start_row
;
83 unsigned int scaled_width
, scaled_height
, scaled_stride
;
84 size_t scaled_image_size
;
85 unsigned char *scaled_image
;
86 unsigned char *scaled_aimage
;
87 int auto_palette
; /* 1 if we lack a palette and must use an heuristic. */
88 int font_start_level
; /* Darkest value used for the computed font */
91 unsigned int forced_subs_only
; /* flag: 0=display all subtitle, !0 display only forced subtitles */
92 unsigned int is_forced_sub
; /* true if current subtitle is a forced subtitle */
95 static void spudec_queue_packet(spudec_handle_t
*this, packet_t
*packet
)
97 if (this->queue_head
== NULL
)
98 this->queue_head
= packet
;
100 this->queue_tail
->next
= packet
;
101 this->queue_tail
= packet
;
104 static packet_t
*spudec_dequeue_packet(spudec_handle_t
*this)
106 packet_t
*retval
= this->queue_head
;
108 this->queue_head
= retval
->next
;
109 if (this->queue_head
== NULL
)
110 this->queue_tail
= NULL
;
115 static void spudec_free_packet(packet_t
*packet
)
117 if (packet
->packet
!= NULL
)
118 free(packet
->packet
);
122 static inline unsigned int get_be16(const unsigned char *p
)
124 return (p
[0] << 8) + p
[1];
127 static inline unsigned int get_be24(const unsigned char *p
)
129 return (get_be16(p
) << 8) + p
[2];
132 static void next_line(packet_t
*packet
)
134 if (packet
->current_nibble
[packet
->deinterlace_oddness
] % 2)
135 packet
->current_nibble
[packet
->deinterlace_oddness
]++;
136 packet
->deinterlace_oddness
= (packet
->deinterlace_oddness
+ 1) % 2;
139 static inline unsigned char get_nibble(packet_t
*packet
)
142 unsigned int *nibblep
= packet
->current_nibble
+ packet
->deinterlace_oddness
;
143 if (*nibblep
/ 2 >= packet
->control_start
) {
144 mp_msg(MSGT_SPUDEC
,MSGL_WARN
, "SPUdec: ERROR: get_nibble past end of packet\n");
147 nib
= packet
->packet
[*nibblep
/ 2];
156 static inline int mkalpha(int i
)
158 /* In mplayer's alpha planes, 0 is transparent, then 1 is nearly
159 opaque upto 255 which is transparent */
166 return (0xf - i
) << 4;
170 /* Cut the sub to visible part */
171 static inline void spudec_cut_image(spudec_handle_t
*this)
174 unsigned int first_y
, last_y
;
175 unsigned char *image
;
176 unsigned char *aimage
;
178 if (this->stride
== 0 || this->height
== 0) {
182 for (fy
= 0; fy
< this->image_size
&& !this->aimage
[fy
]; fy
++);
183 for (ly
= this->stride
* this->height
-1; ly
&& !this->aimage
[ly
]; ly
--);
184 first_y
= fy
/ this->stride
;
185 last_y
= ly
/ this->stride
;
186 //printf("first_y: %d, last_y: %d\n", first_y, last_y);
187 this->start_row
+= first_y
;
189 // Some subtitles trigger this condition
190 if (last_y
+ 1 > first_y
) {
191 this->height
= last_y
- first_y
+1;
194 this->image_size
= 0;
198 // printf("new h %d new start %d (sz %d st %d)---\n\n", this->height, this->start_row, this->image_size, this->stride);
200 image
= malloc(2 * this->stride
* this->height
);
202 this->image_size
= this->stride
* this->height
;
203 aimage
= image
+ this->image_size
;
204 memcpy(image
, this->image
+ this->stride
* first_y
, this->image_size
);
205 memcpy(aimage
, this->aimage
+ this->stride
* first_y
, this->image_size
);
208 this->aimage
= aimage
;
210 mp_msg(MSGT_SPUDEC
, MSGL_FATAL
, "Fatal: update_spu: malloc requested %d bytes\n", 2 * this->stride
* this->height
);
214 static void spudec_process_data(spudec_handle_t
*this, packet_t
*packet
)
216 unsigned int cmap
[4], alpha
[4];
217 unsigned int i
, x
, y
;
219 this->scaled_frame_width
= 0;
220 this->scaled_frame_height
= 0;
221 this->start_col
= packet
->start_col
;
222 this->end_col
= packet
->end_col
;
223 this->start_row
= packet
->start_row
;
224 this->end_row
= packet
->end_row
;
225 this->height
= packet
->height
;
226 this->width
= packet
->width
;
227 this->stride
= packet
->stride
;
228 for (i
= 0; i
< 4; ++i
) {
229 alpha
[i
] = mkalpha(packet
->alpha
[i
]);
230 if (this->custom
&& (this->cuspal
[i
] >> 31) != 0)
234 else if (this->custom
){
235 cmap
[i
] = ((this->cuspal
[i
] >> 16) & 0xff);
236 if (cmap
[i
] + alpha
[i
] > 255)
237 cmap
[i
] = 256 - alpha
[i
];
240 cmap
[i
] = ((this->global_palette
[packet
->palette
[i
]] >> 16) & 0xff);
241 if (cmap
[i
] + alpha
[i
] > 255)
242 cmap
[i
] = 256 - alpha
[i
];
246 if (this->image_size
< this->stride
* this->height
) {
247 if (this->image
!= NULL
) {
249 this->image_size
= 0;
251 this->image
= malloc(2 * this->stride
* this->height
);
253 this->image_size
= this->stride
* this->height
;
254 this->aimage
= this->image
+ this->image_size
;
257 if (this->image
== NULL
)
260 /* Kludge: draw_alpha needs width multiple of 8. */
261 if (this->width
< this->stride
)
262 for (y
= 0; y
< this->height
; ++y
) {
263 memset(this->aimage
+ y
* this->stride
+ this->width
, 0, this->stride
- this->width
);
264 /* FIXME: Why is this one needed? */
265 memset(this->image
+ y
* this->stride
+ this->width
, 0, this->stride
- this->width
);
268 i
= packet
->current_nibble
[1];
271 while (packet
->current_nibble
[0] < i
272 && packet
->current_nibble
[1] / 2 < packet
->control_start
273 && y
< this->height
) {
274 unsigned int len
, color
;
275 unsigned int rle
= 0;
276 rle
= get_nibble(packet
);
278 rle
= (rle
<< 4) | get_nibble(packet
);
280 rle
= (rle
<< 4) | get_nibble(packet
);
282 rle
= (rle
<< 4) | get_nibble(packet
);
284 rle
|= ((this->width
- x
) << 2);
288 color
= 3 - (rle
& 0x3);
290 if (len
> this->width
- x
|| len
== 0)
291 len
= this->width
- x
;
292 /* FIXME have to use palette and alpha map*/
293 memset(this->image
+ y
* this->stride
+ x
, cmap
[color
], len
);
294 memset(this->aimage
+ y
* this->stride
+ x
, alpha
[color
], len
);
296 if (x
>= this->width
) {
302 spudec_cut_image(this);
307 This function tries to create a usable palette.
308 It determines how many non-transparent colors are used, and assigns different
309 gray scale values to each color.
310 I tested it with four streams and even got something readable. Half of the
311 times I got black characters with white around and half the reverse.
313 static void compute_palette(spudec_handle_t
*this, packet_t
*packet
)
315 int used
[16],i
,cused
,start
,step
,color
;
317 memset(used
, 0, sizeof(used
));
319 if (packet
->alpha
[i
]) /* !Transparent? */
320 used
[packet
->palette
[i
]] = 1;
321 for (cused
=0, i
=0; i
<16; i
++)
322 if (used
[i
]) cused
++;
328 start
= this->font_start_level
;
329 step
= (0xF0-this->font_start_level
)/(cused
-1);
331 memset(used
, 0, sizeof(used
));
332 for (i
=0; i
<4; i
++) {
333 color
= packet
->palette
[i
];
334 if (packet
->alpha
[i
] && !used
[color
]) { /* not assigned? */
336 this->global_palette
[color
] = start
<<16;
342 static void spudec_process_control(spudec_handle_t
*this, int pts100
)
344 int a
,b
; /* Temporary vars */
345 unsigned int date
, type
;
347 unsigned int start_off
= 0;
348 unsigned int next_off
;
349 unsigned int start_pts
= 0;
350 unsigned int end_pts
= 0;
351 unsigned int current_nibble
[2] = {0, 0};
352 unsigned int control_start
;
353 unsigned int display
= 0;
354 unsigned int start_col
= 0;
355 unsigned int end_col
= 0;
356 unsigned int start_row
= 0;
357 unsigned int end_row
= 0;
358 unsigned int width
= 0;
359 unsigned int height
= 0;
360 unsigned int stride
= 0;
362 control_start
= get_be16(this->packet
+ 2);
363 next_off
= control_start
;
364 while (start_off
!= next_off
) {
365 start_off
= next_off
;
366 date
= get_be16(this->packet
+ start_off
) * 1024;
367 next_off
= get_be16(this->packet
+ start_off
+ 2);
368 mp_msg(MSGT_SPUDEC
,MSGL_DBG2
, "date=%d\n", date
);
370 for (type
= this->packet
[off
++]; type
!= 0xff; type
= this->packet
[off
++]) {
371 mp_msg(MSGT_SPUDEC
,MSGL_DBG2
, "cmd=%d ",type
);
374 /* Menu ID, 1 byte */
375 mp_msg(MSGT_SPUDEC
,MSGL_DBG2
,"Menu ID\n");
376 /* shouldn't a Menu ID type force display start? */
377 start_pts
= pts100
< 0 && -pts100
>= date
? 0 : pts100
+ date
;
380 this->is_forced_sub
=~0; // current subtitle is forced
384 mp_msg(MSGT_SPUDEC
,MSGL_DBG2
,"Start display!\n");
385 start_pts
= pts100
< 0 && -pts100
>= date
? 0 : pts100
+ date
;
388 this->is_forced_sub
=0;
392 mp_msg(MSGT_SPUDEC
,MSGL_DBG2
,"Stop display!\n");
393 end_pts
= pts100
< 0 && -pts100
>= date
? 0 : pts100
+ date
;
397 this->palette
[0] = this->packet
[off
] >> 4;
398 this->palette
[1] = this->packet
[off
] & 0xf;
399 this->palette
[2] = this->packet
[off
+ 1] >> 4;
400 this->palette
[3] = this->packet
[off
+ 1] & 0xf;
401 mp_msg(MSGT_SPUDEC
,MSGL_DBG2
,"Palette %d, %d, %d, %d\n",
402 this->palette
[0], this->palette
[1], this->palette
[2], this->palette
[3]);
407 this->alpha
[0] = this->packet
[off
] >> 4;
408 this->alpha
[1] = this->packet
[off
] & 0xf;
409 this->alpha
[2] = this->packet
[off
+ 1] >> 4;
410 this->alpha
[3] = this->packet
[off
+ 1] & 0xf;
411 mp_msg(MSGT_SPUDEC
,MSGL_DBG2
,"Alpha %d, %d, %d, %d\n",
412 this->alpha
[0], this->alpha
[1], this->alpha
[2], this->alpha
[3]);
417 a
= get_be24(this->packet
+ off
);
418 b
= get_be24(this->packet
+ off
+ 3);
421 width
= (end_col
< start_col
) ? 0 : end_col
- start_col
+ 1;
422 stride
= (width
+ 7) & ~7; /* Kludge: draw_alpha needs width multiple of 8 */
425 height
= (end_row
< start_row
) ? 0 : end_row
- start_row
/* + 1 */;
426 mp_msg(MSGT_SPUDEC
,MSGL_DBG2
,"Coords col: %d - %d row: %d - %d (%dx%d)\n",
427 start_col
, end_col
, start_row
, end_row
,
433 current_nibble
[0] = 2 * get_be16(this->packet
+ off
);
434 current_nibble
[1] = 2 * get_be16(this->packet
+ off
+ 2);
435 mp_msg(MSGT_SPUDEC
,MSGL_DBG2
,"Graphic offset 1: %d offset 2: %d\n",
436 current_nibble
[0] / 2, current_nibble
[1] / 2);
440 /* All done, bye-bye */
441 mp_msg(MSGT_SPUDEC
,MSGL_DBG2
,"Done!\n");
445 mp_msg(MSGT_SPUDEC
,MSGL_WARN
,"spudec: Error determining control type 0x%02x. Skipping %d bytes.\n",
446 type
, next_off
- off
);
453 if (end_pts
== UINT_MAX
&& start_off
!= next_off
) {
454 end_pts
= get_be16(this->packet
+ next_off
) * 1024;
455 end_pts
= 1 - pts100
>= end_pts
? 0 : pts100
+ end_pts
- 1;
458 packet_t
*packet
= calloc(1, sizeof(packet_t
));
460 packet
->start_pts
= start_pts
;
461 packet
->end_pts
= end_pts
;
462 packet
->current_nibble
[0] = current_nibble
[0];
463 packet
->current_nibble
[1] = current_nibble
[1];
464 packet
->start_row
= start_row
;
465 packet
->end_row
= end_row
;
466 packet
->start_col
= start_col
;
467 packet
->end_col
= end_col
;
468 packet
->width
= width
;
469 packet
->height
= height
;
470 packet
->stride
= stride
;
471 packet
->control_start
= control_start
;
472 for (i
=0; i
<4; i
++) {
473 packet
->alpha
[i
] = this->alpha
[i
];
474 packet
->palette
[i
] = this->palette
[i
];
476 packet
->packet
= malloc(this->packet_size
);
477 memcpy(packet
->packet
, this->packet
, this->packet_size
);
478 spudec_queue_packet(this, packet
);
483 static void spudec_decode(spudec_handle_t
*this, int pts100
)
486 spudec_process_control(this, pts100
);
487 else if (pts100
>= 0) {
488 static vo_mpegpes_t packet
= { NULL
, 0, 0x20, 0 };
489 static vo_mpegpes_t
*pkg
=&packet
;
490 packet
.data
= this->packet
;
491 packet
.size
= this->packet_size
;
492 packet
.timestamp
= pts100
;
493 vo_draw_frame(this->hw_spu
, (uint8_t**)&pkg
);
497 int spudec_changed(void * this)
499 spudec_handle_t
* spu
= (spudec_handle_t
*)this;
500 return spu
->spu_changed
|| spu
->now_pts
> spu
->end_pts
;
503 void spudec_assemble(void *this, unsigned char *packet
, unsigned int len
, int pts100
)
505 spudec_handle_t
*spu
= (spudec_handle_t
*)this;
506 // spudec_heartbeat(this, pts100);
508 mp_msg(MSGT_SPUDEC
,MSGL_WARN
,"SPUasm: packet too short\n");
512 if ((spu
->packet_pts
+ 10000) < pts100
) {
513 // [cb] too long since last fragment: force new packet
514 spu
->packet_offset
= 0;
517 spu
->packet_pts
= pts100
;
518 if (spu
->packet_offset
== 0) {
519 unsigned int len2
= get_be16(packet
);
520 // Start new fragment
521 if (spu
->packet_reserve
< len2
) {
522 if (spu
->packet
!= NULL
)
524 spu
->packet
= malloc(len2
);
525 spu
->packet_reserve
= spu
->packet
!= NULL
? len2
: 0;
527 if (spu
->packet
!= NULL
) {
528 spu
->packet_size
= len2
;
530 mp_msg(MSGT_SPUDEC
,MSGL_WARN
,"SPUasm: invalid frag len / len2: %d / %d \n", len
, len2
);
533 memcpy(spu
->packet
, packet
, len
);
534 spu
->packet_offset
= len
;
535 spu
->packet_pts
= pts100
;
538 // Continue current fragment
539 if (spu
->packet_size
< spu
->packet_offset
+ len
){
540 mp_msg(MSGT_SPUDEC
,MSGL_WARN
,"SPUasm: invalid fragment\n");
541 spu
->packet_size
= spu
->packet_offset
= 0;
544 memcpy(spu
->packet
+ spu
->packet_offset
, packet
, len
);
545 spu
->packet_offset
+= len
;
549 // check if we have a complete packet (unfortunatelly packet_size is bad
551 // [cb] packet_size is padded to be even -> may be one byte too long
552 if ((spu
->packet_offset
== spu
->packet_size
) ||
553 ((spu
->packet_offset
+ 1) == spu
->packet_size
)){
555 while(x
+4<=spu
->packet_offset
){
556 y
=get_be16(spu
->packet
+x
+2); // next control pointer
557 mp_msg(MSGT_SPUDEC
,MSGL_DBG2
,"SPUtest: x=%d y=%d off=%d size=%d\n",x
,y
,spu
->packet_offset
,spu
->packet_size
);
558 if(x
>=4 && x
==y
){ // if it points to self - we're done!
560 mp_msg(MSGT_SPUDEC
,MSGL_DBG2
,"SPUgot: off=%d size=%d \n",spu
->packet_offset
,spu
->packet_size
);
561 spudec_decode(spu
, pts100
);
562 spu
->packet_offset
= 0;
565 if(y
<=x
|| y
>=spu
->packet_size
){ // invalid?
566 mp_msg(MSGT_SPUDEC
,MSGL_WARN
,"SPUtest: broken packet!!!!! y=%d < x=%d\n",y
,x
);
567 spu
->packet_size
= spu
->packet_offset
= 0;
572 // [cb] packet is done; start new packet
573 spu
->packet_offset
= 0;
576 if (spu
->packet_offset
== spu
->packet_size
) {
577 spudec_decode(spu
, pts100
);
578 spu
->packet_offset
= 0;
583 void spudec_reset(void *this) // called after seek
585 spudec_handle_t
*spu
= (spudec_handle_t
*)this;
586 while (spu
->queue_head
)
587 spudec_free_packet(spudec_dequeue_packet(spu
));
590 spu
->packet_size
= spu
->packet_offset
= 0;
593 void spudec_heartbeat(void *this, unsigned int pts100
)
595 spudec_handle_t
*spu
= (spudec_handle_t
*) this;
596 spu
->now_pts
= pts100
;
598 while (spu
->queue_head
!= NULL
&& pts100
>= spu
->queue_head
->start_pts
) {
599 packet_t
*packet
= spudec_dequeue_packet(spu
);
600 spu
->start_pts
= packet
->start_pts
;
601 spu
->end_pts
= packet
->end_pts
;
602 if (spu
->auto_palette
)
603 compute_palette(spu
, packet
);
604 spudec_process_data(spu
, packet
);
605 spudec_free_packet(packet
);
606 spu
->spu_changed
= 1;
610 int spudec_visible(void *this){
611 spudec_handle_t
*spu
= (spudec_handle_t
*)this;
612 int ret
=(spu
->start_pts
<= spu
->now_pts
&&
613 spu
->now_pts
< spu
->end_pts
&&
615 // printf("spu visible: %d \n",ret);
619 void spudec_set_forced_subs_only(void * const this, const unsigned int flag
)
622 ((spudec_handle_t
*)this)->forced_subs_only
=flag
;
623 mp_msg(MSGT_SPUDEC
,MSGL_DBG2
,"SPU: Display only forced subs now %s\n", flag
? "enabled": "disabled");
627 void spudec_draw(void *this, void (*draw_alpha
)(int x0
,int y0
, int w
,int h
, unsigned char* src
, unsigned char *srca
, int stride
))
629 spudec_handle_t
*spu
= (spudec_handle_t
*)this;
630 if (spu
->start_pts
<= spu
->now_pts
&& spu
->now_pts
< spu
->end_pts
&& spu
->image
)
632 draw_alpha(spu
->start_col
, spu
->start_row
, spu
->width
, spu
->height
,
633 spu
->image
, spu
->aimage
, spu
->stride
);
634 spu
->spu_changed
= 0;
638 /* calc the bbox for spudec subs */
639 void spudec_calc_bbox(void *me
, unsigned int dxs
, unsigned int dys
, unsigned int* bbox
)
641 spudec_handle_t
*spu
;
642 spu
= (spudec_handle_t
*)me
;
643 if (spu
->orig_frame_width
== 0 || spu
->orig_frame_height
== 0
644 || (spu
->orig_frame_width
== dxs
&& spu
->orig_frame_height
== dys
)) {
645 bbox
[0] = spu
->start_col
;
646 bbox
[1] = spu
->start_col
+ spu
->width
;
647 bbox
[2] = spu
->start_row
;
648 bbox
[3] = spu
->start_row
+ spu
->height
;
650 else if (spu
->scaled_frame_width
!= dxs
|| spu
->scaled_frame_height
!= dys
) {
651 unsigned int scalex
= 0x100 * dxs
/ spu
->orig_frame_width
;
652 unsigned int scaley
= 0x100 * dys
/ spu
->orig_frame_height
;
653 bbox
[0] = spu
->start_col
* scalex
/ 0x100;
654 bbox
[1] = spu
->start_col
* scalex
/ 0x100 + spu
->width
* scalex
/ 0x100;
655 switch (spu_alignment
) {
657 bbox
[3] = dys
*sub_pos
/100 + spu
->height
* scaley
/ 0x100;
658 if (bbox
[3] > dys
) bbox
[3] = dys
;
659 bbox
[2] = bbox
[3] - spu
->height
* scaley
/ 0x100;
663 bbox
[2] = dys
*sub_pos
/100 - spu
->height
* scaley
/ 0x200;
664 bbox
[3] = bbox
[2] + spu
->height
;
666 bbox
[3] = dys
*sub_pos
/100 + spu
->height
* scaley
/ 0x200;
667 if (bbox
[3] > dys
) bbox
[3] = dys
;
668 bbox
[2] = bbox
[3] - spu
->height
* scaley
/ 0x100;
672 bbox
[2] = dys
*sub_pos
/100 - spu
->height
* scaley
/ 0x100;
673 bbox
[3] = bbox
[2] + spu
->height
;
676 bbox
[2] = spu
->start_row
* scaley
/ 0x100;
677 bbox
[3] = spu
->start_row
* scaley
/ 0x100 + spu
->height
* scaley
/ 0x100;
682 /* transform mplayer's alpha value into an opacity value that is linear */
683 static inline int canon_alpha(int alpha
)
685 return alpha
? 256 - alpha
: 0;
695 static void scale_table(unsigned int start_src
, unsigned int start_tar
, unsigned int end_src
, unsigned int end_tar
, scale_pixel
* table
)
698 unsigned int delta_src
= end_src
- start_src
;
699 unsigned int delta_tar
= end_tar
- start_tar
;
702 if (delta_src
== 0 || delta_tar
== 0) {
705 src_step
= (delta_src
<< 16) / delta_tar
>>1;
706 for (t
= 0; t
<=delta_tar
; src
+= (src_step
<< 1), t
++){
707 table
[t
].position
= FFMIN(src
>> 16, end_src
- 1);
708 table
[t
].right_down
= src
& 0xffff;
709 table
[t
].left_up
= 0x10000 - table
[t
].right_down
;
713 /* bilinear scale, similar to vobsub's code */
714 static void scale_image(int x
, int y
, scale_pixel
* table_x
, scale_pixel
* table_y
, spudec_handle_t
* spu
)
718 unsigned int scale
[4];
719 int base
= table_y
[y
].position
* spu
->stride
+ table_x
[x
].position
;
720 int scaled
= y
* spu
->scaled_stride
+ x
;
721 alpha
[0] = canon_alpha(spu
->aimage
[base
]);
722 alpha
[1] = canon_alpha(spu
->aimage
[base
+ 1]);
723 alpha
[2] = canon_alpha(spu
->aimage
[base
+ spu
->stride
]);
724 alpha
[3] = canon_alpha(spu
->aimage
[base
+ spu
->stride
+ 1]);
725 color
[0] = spu
->image
[base
];
726 color
[1] = spu
->image
[base
+ 1];
727 color
[2] = spu
->image
[base
+ spu
->stride
];
728 color
[3] = spu
->image
[base
+ spu
->stride
+ 1];
729 scale
[0] = (table_x
[x
].left_up
* table_y
[y
].left_up
>> 16) * alpha
[0];
730 if (table_y
[y
].left_up
== 0x10000) // necessary to avoid overflow-case
731 scale
[0] = table_x
[x
].left_up
* alpha
[0];
732 scale
[1] = (table_x
[x
].right_down
* table_y
[y
].left_up
>>16) * alpha
[1];
733 scale
[2] = (table_x
[x
].left_up
* table_y
[y
].right_down
>> 16) * alpha
[2];
734 scale
[3] = (table_x
[x
].right_down
* table_y
[y
].right_down
>> 16) * alpha
[3];
735 spu
->scaled_image
[scaled
] = (color
[0] * scale
[0] + color
[1] * scale
[1] + color
[2] * scale
[2] + color
[3] * scale
[3])>>24;
736 spu
->scaled_aimage
[scaled
] = (scale
[0] + scale
[1] + scale
[2] + scale
[3]) >> 16;
737 if (spu
->scaled_aimage
[scaled
]){
738 spu
->scaled_aimage
[scaled
] = 256 - spu
->scaled_aimage
[scaled
];
739 if(spu
->scaled_aimage
[scaled
] + spu
->scaled_image
[scaled
] > 255)
740 spu
->scaled_image
[scaled
] = 256 - spu
->scaled_aimage
[scaled
];
744 void sws_spu_image(unsigned char *d1
, unsigned char *d2
, int dw
, int dh
, int ds
,
745 unsigned char *s1
, unsigned char *s2
, int sw
, int sh
, int ss
)
747 struct SwsContext
*ctx
;
748 static SwsFilter filter
;
749 static int firsttime
= 1;
753 if (!firsttime
&& oldvar
!= spu_gaussvar
) sws_freeVec(filter
.lumH
);
755 filter
.lumH
= filter
.lumV
=
756 filter
.chrH
= filter
.chrV
= sws_getGaussianVec(spu_gaussvar
, 3.0);
757 sws_normalizeVec(filter
.lumH
, 1.0);
759 oldvar
= spu_gaussvar
;
762 ctx
=sws_getContext(sw
, sh
, PIX_FMT_GRAY8
, dw
, dh
, PIX_FMT_GRAY8
, SWS_GAUSS
, &filter
, NULL
, NULL
);
763 sws_scale(ctx
,&s1
,&ss
,0,sh
,&d1
,&ds
);
764 for (i
=ss
*sh
-1; i
>=0; i
--) if (!s2
[i
]) s2
[i
] = 255; //else s2[i] = 1;
765 sws_scale(ctx
,&s2
,&ss
,0,sh
,&d2
,&ds
);
766 for (i
=ds
*dh
-1; i
>=0; i
--) if (d2
[i
]==0) d2
[i
] = 1; else if (d2
[i
]==255) d2
[i
] = 0;
767 sws_freeContext(ctx
);
770 void spudec_draw_scaled(void *me
, unsigned int dxs
, unsigned int dys
, void (*draw_alpha
)(void *ctx
, int x0
,int y0
, int w
,int h
, unsigned char* src
, unsigned char *srca
, int stride
), void *ctx
)
772 spudec_handle_t
*spu
= (spudec_handle_t
*)me
;
773 scale_pixel
*table_x
;
774 scale_pixel
*table_y
;
776 if (spu
->start_pts
<= spu
->now_pts
&& spu
->now_pts
< spu
->end_pts
) {
778 // check if only forced subtitles are requested
779 if( (spu
->forced_subs_only
) && !(spu
->is_forced_sub
) ){
783 if (!(spu_aamode
&16) && (spu
->orig_frame_width
== 0 || spu
->orig_frame_height
== 0
784 || (spu
->orig_frame_width
== dxs
&& spu
->orig_frame_height
== dys
))) {
787 draw_alpha(ctx
, spu
->start_col
, spu
->start_row
, spu
->width
, spu
->height
,
788 spu
->image
, spu
->aimage
, spu
->stride
);
789 spu
->spu_changed
= 0;
793 if (spu
->scaled_frame_width
!= dxs
|| spu
->scaled_frame_height
!= dys
) { /* Resizing is needed */
794 /* scaled_x = scalex * x / 0x100
795 scaled_y = scaley * y / 0x100
796 order of operations is important because of rounding. */
797 unsigned int scalex
= 0x100 * dxs
/ spu
->orig_frame_width
;
798 unsigned int scaley
= 0x100 * dys
/ spu
->orig_frame_height
;
799 spu
->scaled_start_col
= spu
->start_col
* scalex
/ 0x100;
800 spu
->scaled_start_row
= spu
->start_row
* scaley
/ 0x100;
801 spu
->scaled_width
= spu
->width
* scalex
/ 0x100;
802 spu
->scaled_height
= spu
->height
* scaley
/ 0x100;
803 /* Kludge: draw_alpha needs width multiple of 8 */
804 spu
->scaled_stride
= (spu
->scaled_width
+ 7) & ~7;
805 if (spu
->scaled_image_size
< spu
->scaled_stride
* spu
->scaled_height
) {
806 if (spu
->scaled_image
) {
807 free(spu
->scaled_image
);
808 spu
->scaled_image_size
= 0;
810 spu
->scaled_image
= malloc(2 * spu
->scaled_stride
* spu
->scaled_height
);
811 if (spu
->scaled_image
) {
812 spu
->scaled_image_size
= spu
->scaled_stride
* spu
->scaled_height
;
813 spu
->scaled_aimage
= spu
->scaled_image
+ spu
->scaled_image_size
;
816 if (spu
->scaled_image
) {
818 if (spu
->scaled_width
<= 1 || spu
->scaled_height
<= 1) {
821 switch(spu_aamode
&15) {
823 sws_spu_image(spu
->scaled_image
, spu
->scaled_aimage
,
824 spu
->scaled_width
, spu
->scaled_height
, spu
->scaled_stride
,
825 spu
->image
, spu
->aimage
, spu
->width
, spu
->height
, spu
->stride
);
828 table_x
= calloc(spu
->scaled_width
, sizeof(scale_pixel
));
829 table_y
= calloc(spu
->scaled_height
, sizeof(scale_pixel
));
830 if (!table_x
|| !table_y
) {
831 mp_msg(MSGT_SPUDEC
, MSGL_FATAL
, "Fatal: spudec_draw_scaled: calloc failed\n");
833 scale_table(0, 0, spu
->width
- 1, spu
->scaled_width
- 1, table_x
);
834 scale_table(0, 0, spu
->height
- 1, spu
->scaled_height
- 1, table_y
);
835 for (y
= 0; y
< spu
->scaled_height
; y
++)
836 for (x
= 0; x
< spu
->scaled_width
; x
++)
837 scale_image(x
, y
, table_x
, table_y
, spu
);
842 /* no antialiasing */
843 for (y
= 0; y
< spu
->scaled_height
; ++y
) {
844 int unscaled_y
= y
* 0x100 / scaley
;
845 int strides
= spu
->stride
* unscaled_y
;
846 int scaled_strides
= spu
->scaled_stride
* y
;
847 for (x
= 0; x
< spu
->scaled_width
; ++x
) {
848 int unscaled_x
= x
* 0x100 / scalex
;
849 spu
->scaled_image
[scaled_strides
+ x
] = spu
->image
[strides
+ unscaled_x
];
850 spu
->scaled_aimage
[scaled_strides
+ x
] = spu
->aimage
[strides
+ unscaled_x
];
856 /* Intermediate antialiasing. */
857 for (y
= 0; y
< spu
->scaled_height
; ++y
) {
858 const unsigned int unscaled_top
= y
* spu
->orig_frame_height
/ dys
;
859 unsigned int unscaled_bottom
= (y
+ 1) * spu
->orig_frame_height
/ dys
;
860 if (unscaled_bottom
>= spu
->height
)
861 unscaled_bottom
= spu
->height
- 1;
862 for (x
= 0; x
< spu
->scaled_width
; ++x
) {
863 const unsigned int unscaled_left
= x
* spu
->orig_frame_width
/ dxs
;
864 unsigned int unscaled_right
= (x
+ 1) * spu
->orig_frame_width
/ dxs
;
865 unsigned int color
= 0;
866 unsigned int alpha
= 0;
867 unsigned int walkx
, walky
;
868 unsigned int base
, tmp
;
869 if (unscaled_right
>= spu
->width
)
870 unscaled_right
= spu
->width
- 1;
871 for (walky
= unscaled_top
; walky
<= unscaled_bottom
; ++walky
)
872 for (walkx
= unscaled_left
; walkx
<= unscaled_right
; ++walkx
) {
873 base
= walky
* spu
->stride
+ walkx
;
874 tmp
= canon_alpha(spu
->aimage
[base
]);
876 color
+= tmp
* spu
->image
[base
];
878 base
= y
* spu
->scaled_stride
+ x
;
879 spu
->scaled_image
[base
] = alpha
? color
/ alpha
: 0;
880 spu
->scaled_aimage
[base
] =
881 alpha
* (1 + unscaled_bottom
- unscaled_top
) * (1 + unscaled_right
- unscaled_left
);
882 /* spu->scaled_aimage[base] =
883 alpha * dxs * dys / spu->orig_frame_width / spu->orig_frame_height; */
884 if (spu
->scaled_aimage
[base
]) {
885 spu
->scaled_aimage
[base
] = 256 - spu
->scaled_aimage
[base
];
886 if (spu
->scaled_aimage
[base
] + spu
->scaled_image
[base
] > 255)
887 spu
->scaled_image
[base
] = 256 - spu
->scaled_aimage
[base
];
895 /* Best antialiasing. Very slow. */
896 /* Any pixel (x, y) represents pixels from the original
897 rectangular region comprised between the columns
898 unscaled_y and unscaled_y + 0x100 / scaley and the rows
899 unscaled_x and unscaled_x + 0x100 / scalex
901 The original rectangular region that the scaled pixel
902 represents is cut in 9 rectangular areas like this:
904 +---+-----------------+---+
906 +---+-----------------+---+
910 +---+-----------------+---+
912 +---+-----------------+---+
914 The width of the left column is at most one pixel and
915 it is never null and its right column is at a pixel
916 boundary. The height of the top row is at most one
917 pixel it is never null and its bottom row is at a
918 pixel boundary. The width and height of region 5 are
919 integral values. The width of the right column is
920 what remains and is less than one pixel. The height
921 of the bottom row is what remains and is less than
924 The row above 1, 2, 3 is unscaled_y. The row between
925 1, 2, 3 and 4, 5, 6 is top_low_row. The row between 4,
926 5, 6 and 7, 8, 9 is (unsigned int)unscaled_y_bottom.
927 The row beneath 7, 8, 9 is unscaled_y_bottom.
929 The column left of 1, 4, 7 is unscaled_x. The column
930 between 1, 4, 7 and 2, 5, 8 is left_right_column. The
931 column between 2, 5, 8 and 3, 6, 9 is (unsigned
932 int)unscaled_x_right. The column right of 3, 6, 9 is
934 const double inv_scalex
= (double) 0x100 / scalex
;
935 const double inv_scaley
= (double) 0x100 / scaley
;
936 for (y
= 0; y
< spu
->scaled_height
; ++y
) {
937 const double unscaled_y
= y
* inv_scaley
;
938 const double unscaled_y_bottom
= unscaled_y
+ inv_scaley
;
939 const unsigned int top_low_row
= FFMIN(unscaled_y_bottom
, unscaled_y
+ 1.0);
940 const double top
= top_low_row
- unscaled_y
;
941 const unsigned int height
= unscaled_y_bottom
> top_low_row
942 ? (unsigned int) unscaled_y_bottom
- top_low_row
944 const double bottom
= unscaled_y_bottom
> top_low_row
945 ? unscaled_y_bottom
- floor(unscaled_y_bottom
)
947 for (x
= 0; x
< spu
->scaled_width
; ++x
) {
948 const double unscaled_x
= x
* inv_scalex
;
949 const double unscaled_x_right
= unscaled_x
+ inv_scalex
;
950 const unsigned int left_right_column
= FFMIN(unscaled_x_right
, unscaled_x
+ 1.0);
951 const double left
= left_right_column
- unscaled_x
;
952 const unsigned int width
= unscaled_x_right
> left_right_column
953 ? (unsigned int) unscaled_x_right
- left_right_column
955 const double right
= unscaled_x_right
> left_right_column
956 ? unscaled_x_right
- floor(unscaled_x_right
)
962 /* Now use these informations to compute a good alpha,
963 and lightness. The sum is on each of the 9
964 region's surface and alpha and lightness.
966 transformed alpha = sum(surface * alpha) / sum(surface)
967 transformed color = sum(surface * alpha * color) / sum(surface * alpha)
969 /* 1: top left part */
970 base
= spu
->stride
* (unsigned int) unscaled_y
;
971 tmp
= left
* top
* canon_alpha(spu
->aimage
[base
+ (unsigned int) unscaled_x
]);
973 color
+= tmp
* spu
->image
[base
+ (unsigned int) unscaled_x
];
974 /* 2: top center part */
977 for (walkx
= left_right_column
; walkx
< (unsigned int) unscaled_x_right
; ++walkx
) {
978 base
= spu
->stride
* (unsigned int) unscaled_y
+ walkx
;
979 tmp
= /* 1.0 * */ top
* canon_alpha(spu
->aimage
[base
]);
981 color
+= tmp
* spu
->image
[base
];
984 /* 3: top right part */
986 base
= spu
->stride
* (unsigned int) unscaled_y
+ (unsigned int) unscaled_x_right
;
987 tmp
= right
* top
* canon_alpha(spu
->aimage
[base
]);
989 color
+= tmp
* spu
->image
[base
];
991 /* 4: center left part */
994 for (walky
= top_low_row
; walky
< (unsigned int) unscaled_y_bottom
; ++walky
) {
995 base
= spu
->stride
* walky
+ (unsigned int) unscaled_x
;
996 tmp
= left
/* * 1.0 */ * canon_alpha(spu
->aimage
[base
]);
998 color
+= tmp
* spu
->image
[base
];
1001 /* 5: center part */
1002 if (width
> 0 && height
> 0) {
1004 for (walky
= top_low_row
; walky
< (unsigned int) unscaled_y_bottom
; ++walky
) {
1006 base
= spu
->stride
* walky
;
1007 for (walkx
= left_right_column
; walkx
< (unsigned int) unscaled_x_right
; ++walkx
) {
1008 tmp
= /* 1.0 * 1.0 * */ canon_alpha(spu
->aimage
[base
+ walkx
]);
1010 color
+= tmp
* spu
->image
[base
+ walkx
];
1014 /* 6: center right part */
1015 if (right
> 0.0 && height
> 0) {
1017 for (walky
= top_low_row
; walky
< (unsigned int) unscaled_y_bottom
; ++walky
) {
1018 base
= spu
->stride
* walky
+ (unsigned int) unscaled_x_right
;
1019 tmp
= right
/* * 1.0 */ * canon_alpha(spu
->aimage
[base
]);
1021 color
+= tmp
* spu
->image
[base
];
1024 /* 7: bottom left part */
1026 base
= spu
->stride
* (unsigned int) unscaled_y_bottom
+ (unsigned int) unscaled_x
;
1027 tmp
= left
* bottom
* canon_alpha(spu
->aimage
[base
]);
1029 color
+= tmp
* spu
->image
[base
];
1031 /* 8: bottom center part */
1032 if (width
> 0 && bottom
> 0.0) {
1034 base
= spu
->stride
* (unsigned int) unscaled_y_bottom
;
1035 for (walkx
= left_right_column
; walkx
< (unsigned int) unscaled_x_right
; ++walkx
) {
1036 tmp
= /* 1.0 * */ bottom
* canon_alpha(spu
->aimage
[base
+ walkx
]);
1038 color
+= tmp
* spu
->image
[base
+ walkx
];
1041 /* 9: bottom right part */
1042 if (right
> 0.0 && bottom
> 0.0) {
1043 base
= spu
->stride
* (unsigned int) unscaled_y_bottom
+ (unsigned int) unscaled_x_right
;
1044 tmp
= right
* bottom
* canon_alpha(spu
->aimage
[base
]);
1046 color
+= tmp
* spu
->image
[base
];
1048 /* Finally mix these transparency and brightness information suitably */
1049 base
= spu
->scaled_stride
* y
+ x
;
1050 spu
->scaled_image
[base
] = alpha
> 0 ? color
/ alpha
: 0;
1051 spu
->scaled_aimage
[base
] = alpha
* scalex
* scaley
/ 0x10000;
1052 if (spu
->scaled_aimage
[base
]) {
1053 spu
->scaled_aimage
[base
] = 256 - spu
->scaled_aimage
[base
];
1054 if (spu
->scaled_aimage
[base
] + spu
->scaled_image
[base
] > 255)
1055 spu
->scaled_image
[base
] = 256 - spu
->scaled_aimage
[base
];
1062 /* Kludge: draw_alpha needs width multiple of 8. */
1063 if (spu
->scaled_width
< spu
->scaled_stride
)
1064 for (y
= 0; y
< spu
->scaled_height
; ++y
) {
1065 memset(spu
->scaled_aimage
+ y
* spu
->scaled_stride
+ spu
->scaled_width
, 0,
1066 spu
->scaled_stride
- spu
->scaled_width
);
1068 spu
->scaled_frame_width
= dxs
;
1069 spu
->scaled_frame_height
= dys
;
1072 if (spu
->scaled_image
){
1073 switch (spu_alignment
) {
1075 spu
->scaled_start_row
= dys
*sub_pos
/100;
1076 if (spu
->scaled_start_row
+ spu
->scaled_height
> dys
)
1077 spu
->scaled_start_row
= dys
- spu
->scaled_height
;
1080 spu
->scaled_start_row
= dys
*sub_pos
/100 - spu
->scaled_height
/2;
1081 if (sub_pos
>= 50 && spu
->scaled_start_row
+ spu
->scaled_height
> dys
)
1082 spu
->scaled_start_row
= dys
- spu
->scaled_height
;
1085 spu
->scaled_start_row
= dys
*sub_pos
/100 - spu
->scaled_height
;
1088 draw_alpha(ctx
, spu
->scaled_start_col
, spu
->scaled_start_row
, spu
->scaled_width
, spu
->scaled_height
,
1089 spu
->scaled_image
, spu
->scaled_aimage
, spu
->scaled_stride
);
1090 spu
->spu_changed
= 0;
1096 mp_msg(MSGT_SPUDEC
,MSGL_DBG2
,"SPU not displayed: start_pts=%d end_pts=%d now_pts=%d\n",
1097 spu
->start_pts
, spu
->end_pts
, spu
->now_pts
);
1101 void spudec_update_palette(void * this, unsigned int *palette
)
1103 spudec_handle_t
*spu
= (spudec_handle_t
*) this;
1104 if (spu
&& palette
) {
1105 memcpy(spu
->global_palette
, palette
, sizeof(spu
->global_palette
));
1107 vo_control(spu
->hw_spu
, VOCTRL_SET_SPU_PALETTE
, spu
->global_palette
);
1111 void spudec_set_font_factor(void * this, double factor
)
1113 spudec_handle_t
*spu
= (spudec_handle_t
*) this;
1114 spu
->font_start_level
= (int)(0xF0-(0xE0*factor
));
1117 void *spudec_new_scaled(unsigned int *palette
, unsigned int frame_width
, unsigned int frame_height
)
1119 return spudec_new_scaled_vobsub(palette
, NULL
, 0, frame_width
, frame_height
);
1122 /* get palette custom color, width, height from .idx file */
1123 void *spudec_new_scaled_vobsub(unsigned int *palette
, unsigned int *cuspal
, unsigned int custom
, unsigned int frame_width
, unsigned int frame_height
)
1125 spudec_handle_t
*this = calloc(1, sizeof(spudec_handle_t
));
1127 //(fprintf(stderr,"VobSub Custom Palette: %d,%d,%d,%d", this->cuspal[0], this->cuspal[1], this->cuspal[2],this->cuspal[3]);
1128 this->packet
= NULL
;
1130 this->scaled_image
= NULL
;
1131 /* XXX Although the video frame is some size, the SPU frame is
1132 always maximum size i.e. 720 wide and 576 or 480 high */
1133 this->orig_frame_width
= 720;
1134 this->orig_frame_height
= (frame_height
== 480 || frame_height
== 240) ? 480 : 576;
1135 this->custom
= custom
;
1137 this->auto_palette
= 1;
1139 memcpy(this->global_palette
, palette
, sizeof(this->global_palette
));
1140 this->auto_palette
= 0;
1142 this->custom
= custom
;
1143 if (custom
&& cuspal
) {
1144 memcpy(this->cuspal
, cuspal
, sizeof(this->cuspal
));
1145 this->auto_palette
= 0;
1147 // forced subtitles default: show all subtitles
1148 this->forced_subs_only
=0;
1149 this->is_forced_sub
=0;
1152 mp_msg(MSGT_SPUDEC
,MSGL_FATAL
, "FATAL: spudec_init: calloc");
1156 void *spudec_new(unsigned int *palette
)
1158 return spudec_new_scaled(palette
, 0, 0);
1161 void spudec_free(void *this)
1163 spudec_handle_t
*spu
= (spudec_handle_t
*)this;
1165 while (spu
->queue_head
)
1166 spudec_free_packet(spudec_dequeue_packet(spu
));
1169 if (spu
->scaled_image
)
1170 free(spu
->scaled_image
);
1177 void spudec_set_hw_spu(void *this, struct vo
*hw_spu
)
1179 spudec_handle_t
*spu
= (spudec_handle_t
*)this;
1182 spu
->hw_spu
= hw_spu
;
1183 vo_control(hw_spu
, VOCTRL_SET_SPU_PALETTE
, spu
->global_palette
);