Mercurial > mplayer.hg
annotate sub/spudec.c @ 34814:41441963cf8a
Add some dv video fourcc's found by Piotr Bandurski.
author | cehoyos |
---|---|
date | Tue, 15 May 2012 18:27:56 +0000 |
parents | a0b10e46f7e6 |
children | 135b1ef31668 |
rev | line source |
---|---|
32456 | 1 /* |
2 * Skeleton of function spudec_process_controll() is from xine sources. | |
3 * Further works: | |
4 * LGB,... (yeah, try to improve it and insert your name here! ;-) | |
5 * | |
6 * Kim Minh Kaplan | |
7 * implement fragments reassembly, RLE decoding. | |
8 * read brightness from the IFO. | |
9 * | |
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> | |
12 * | |
13 * This file is part of MPlayer. | |
14 * | |
15 * MPlayer is free software; you can redistribute it and/or modify | |
16 * it under the terms of the GNU General Public License as published by | |
17 * the Free Software Foundation; either version 2 of the License, or | |
18 * (at your option) any later version. | |
19 * | |
20 * MPlayer is distributed in the hope that it will be useful, | |
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
23 * GNU General Public License for more details. | |
24 * | |
25 * You should have received a copy of the GNU General Public License along | |
26 * with MPlayer; if not, write to the Free Software Foundation, Inc., | |
27 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. | |
28 */ | |
29 | |
30 #include "config.h" | |
31 #include "mp_msg.h" | |
32 | |
33 #include <errno.h> | |
34 #include <limits.h> | |
35 #include <stdio.h> | |
36 #include <stdlib.h> | |
37 #include <unistd.h> | |
38 #include <string.h> | |
39 #include <math.h> | |
32467 | 40 #include "sub.h" |
32456 | 41 #include "libvo/video_out.h" |
32464
22888a8cb312
Do not use a path for including files in the same directory.
reimar
parents:
32459
diff
changeset
|
42 #include "spudec.h" |
22888a8cb312
Do not use a path for including files in the same directory.
reimar
parents:
32459
diff
changeset
|
43 #include "vobsub.h" |
32456 | 44 #include "libavutil/avutil.h" |
45 #include "libavutil/intreadwrite.h" | |
46 #include "libswscale/swscale.h" | |
47 | |
48 /* Valid values for spu_aamode: | |
49 0: none (fastest, most ugly) | |
50 1: approximate | |
51 2: full (slowest) | |
52 3: bilinear (similiar to vobsub, fast and not too bad) | |
53 4: uses swscaler gaussian (this is the only one that looks good) | |
54 */ | |
55 | |
56 int spu_aamode = 3; | |
57 int spu_alignment = -1; | |
58 float spu_gaussvar = 1.0; | |
59 | |
34784 | 60 typedef struct spu_packet_t packet_t; |
61 struct spu_packet_t { | |
32456 | 62 int is_decoded; |
63 unsigned char *packet; | |
64 int data_len; | |
65 unsigned int palette[4]; | |
66 unsigned int alpha[4]; | |
67 unsigned int control_start; /* index of start of control data */ | |
68 unsigned int current_nibble[2]; /* next data nibble (4 bits) to be | |
69 processed (for RLE decoding) for | |
70 even and odd lines */ | |
71 int deinterlace_oddness; /* 0 or 1, index into current_nibble */ | |
72 unsigned int start_col; | |
73 unsigned int start_row; | |
74 unsigned int width, height, stride; | |
75 unsigned int start_pts, end_pts; | |
76 packet_t *next; | |
77 }; | |
78 | |
79 struct palette_crop_cache { | |
80 int valid; | |
81 uint32_t palette; | |
82 int sx, sy, ex, ey; | |
83 int result; | |
84 }; | |
85 | |
86 typedef struct { | |
87 packet_t *queue_head; | |
88 packet_t *queue_tail; | |
89 unsigned int global_palette[16]; | |
90 unsigned int orig_frame_width, orig_frame_height; | |
91 unsigned char* packet; | |
92 size_t packet_reserve; /* size of the memory pointed to by packet */ | |
93 unsigned int packet_offset; /* end of the currently assembled fragment */ | |
94 unsigned int packet_size; /* size of the packet once all fragments are assembled */ | |
95 int packet_pts; /* PTS for this packet */ | |
96 unsigned int palette[4]; | |
97 unsigned int alpha[4]; | |
98 unsigned int cuspal[4]; | |
99 unsigned int custom; | |
100 unsigned int now_pts; | |
101 unsigned int start_pts, end_pts; | |
102 unsigned int start_col; | |
103 unsigned int start_row; | |
104 unsigned int width, height, stride; | |
105 size_t image_size; /* Size of the image buffer */ | |
106 unsigned char *image; /* Grayscale value */ | |
107 unsigned char *aimage; /* Alpha value */ | |
108 unsigned int pal_start_col, pal_start_row; | |
109 unsigned int pal_width, pal_height; | |
110 unsigned char *pal_image; /* palette entry value */ | |
111 unsigned int scaled_frame_width, scaled_frame_height; | |
112 unsigned int scaled_start_col, scaled_start_row; | |
113 unsigned int scaled_width, scaled_height, scaled_stride; | |
114 size_t scaled_image_size; | |
115 unsigned char *scaled_image; | |
116 unsigned char *scaled_aimage; | |
117 int auto_palette; /* 1 if we lack a palette and must use an heuristic. */ | |
118 int font_start_level; /* Darkest value used for the computed font */ | |
119 const vo_functions_t *hw_spu; | |
120 int spu_changed; | |
121 unsigned int forced_subs_only; /* flag: 0=display all subtitle, !0 display only forced subtitles */ | |
122 unsigned int is_forced_sub; /* true if current subtitle is a forced subtitle */ | |
123 | |
124 struct palette_crop_cache palette_crop_cache; | |
125 } spudec_handle_t; | |
126 | |
127 static void spudec_queue_packet(spudec_handle_t *this, packet_t *packet) | |
128 { | |
129 if (this->queue_head == NULL) | |
130 this->queue_head = packet; | |
131 else | |
132 this->queue_tail->next = packet; | |
133 this->queue_tail = packet; | |
134 } | |
135 | |
136 static packet_t *spudec_dequeue_packet(spudec_handle_t *this) | |
137 { | |
138 packet_t *retval = this->queue_head; | |
139 | |
140 this->queue_head = retval->next; | |
141 if (this->queue_head == NULL) | |
142 this->queue_tail = NULL; | |
143 | |
144 return retval; | |
145 } | |
146 | |
147 static void spudec_free_packet(packet_t *packet) | |
148 { | |
32511
b39155e98ac3
Remove some useless NULL pointer checks before invoking free() on the pointer.
diego
parents:
32467
diff
changeset
|
149 free(packet->packet); |
32456 | 150 free(packet); |
151 } | |
152 | |
153 static inline unsigned int get_be16(const unsigned char *p) | |
154 { | |
155 return (p[0] << 8) + p[1]; | |
156 } | |
157 | |
158 static inline unsigned int get_be24(const unsigned char *p) | |
159 { | |
160 return (get_be16(p) << 8) + p[2]; | |
161 } | |
162 | |
163 static void next_line(packet_t *packet) | |
164 { | |
165 if (packet->current_nibble[packet->deinterlace_oddness] % 2) | |
166 packet->current_nibble[packet->deinterlace_oddness]++; | |
167 packet->deinterlace_oddness = (packet->deinterlace_oddness + 1) % 2; | |
168 } | |
169 | |
170 static inline unsigned char get_nibble(packet_t *packet) | |
171 { | |
172 unsigned char nib; | |
173 unsigned int *nibblep = packet->current_nibble + packet->deinterlace_oddness; | |
174 if (*nibblep / 2 >= packet->control_start) { | |
175 mp_msg(MSGT_SPUDEC,MSGL_WARN, "SPUdec: ERROR: get_nibble past end of packet\n"); | |
176 return 0; | |
177 } | |
178 nib = packet->packet[*nibblep / 2]; | |
179 if (*nibblep % 2) | |
180 nib &= 0xf; | |
181 else | |
182 nib >>= 4; | |
183 ++*nibblep; | |
184 return nib; | |
185 } | |
186 | |
187 /* Cut the sub to visible part */ | |
188 static inline void spudec_cut_image(spudec_handle_t *this) | |
189 { | |
190 unsigned int fy, ly; | |
191 unsigned int first_y, last_y; | |
192 | |
193 if (this->stride == 0 || this->height == 0) { | |
194 return; | |
195 } | |
196 | |
197 for (fy = 0; fy < this->image_size && !this->aimage[fy]; fy++); | |
198 for (ly = this->stride * this->height-1; ly && !this->aimage[ly]; ly--); | |
199 first_y = fy / this->stride; | |
200 last_y = ly / this->stride; | |
201 //printf("first_y: %d, last_y: %d\n", first_y, last_y); | |
202 this->start_row += first_y; | |
203 | |
204 // Some subtitles trigger this condition | |
205 if (last_y + 1 > first_y ) { | |
206 this->height = last_y - first_y +1; | |
207 } else { | |
208 this->height = 0; | |
209 return; | |
210 } | |
211 | |
212 // printf("new h %d new start %d (sz %d st %d)---\n\n", this->height, this->start_row, this->image_size, this->stride); | |
213 | |
214 if (first_y > 0) { | |
215 memmove(this->image, this->image + this->stride * first_y, this->stride * this->height); | |
216 memmove(this->aimage, this->aimage + this->stride * first_y, this->stride * this->height); | |
217 } | |
218 } | |
219 | |
220 | |
221 static int spudec_alloc_image(spudec_handle_t *this, int stride, int height) | |
222 { | |
223 if (this->width > stride) // just a safeguard | |
224 this->width = stride; | |
225 this->stride = stride; | |
226 this->height = height; | |
227 if (this->image_size < this->stride * this->height) { | |
228 if (this->image != NULL) { | |
229 free(this->image); | |
230 free(this->pal_image); | |
231 this->image_size = 0; | |
232 this->pal_width = this->pal_height = 0; | |
233 } | |
234 this->image = malloc(2 * this->stride * this->height); | |
235 if (this->image) { | |
236 this->image_size = this->stride * this->height; | |
237 this->aimage = this->image + this->image_size; | |
238 // use stride here as well to simplify reallocation checks | |
239 this->pal_image = malloc(this->stride * this->height); | |
240 } | |
241 } | |
242 return this->image != NULL; | |
243 } | |
244 | |
245 /** | |
246 * \param pal palette in MPlayer-style gray-alpha values, i.e. | |
247 * alpha == 0 means transparent, 1 fully opaque, | |
248 * gray value <= 256 - alpha. | |
249 */ | |
250 static void pal2gray_alpha(const uint16_t *pal, | |
251 const uint8_t *src, int src_stride, | |
252 uint8_t *dst, uint8_t *dsta, | |
253 int dst_stride, int w, int h) | |
254 { | |
255 int x, y; | |
256 for (y = 0; y < h; y++) { | |
257 for (x = 0; x < w; x++) { | |
258 uint16_t pixel = pal[src[x]]; | |
259 *dst++ = pixel; | |
260 *dsta++ = pixel >> 8; | |
261 } | |
262 for (; x < dst_stride; x++) | |
263 *dsta++ = *dst++ = 0; | |
264 src += src_stride; | |
265 } | |
266 } | |
267 | |
268 static int apply_palette_crop(spudec_handle_t *this, | |
269 unsigned crop_x, unsigned crop_y, | |
270 unsigned crop_w, unsigned crop_h) | |
271 { | |
272 int i; | |
273 uint8_t *src; | |
274 uint16_t pal[4]; | |
275 unsigned stride = (crop_w + 7) & ~7; | |
34778
48310248f892
Ensure that the highlight disappears when switching
reimar
parents:
33143
diff
changeset
|
276 int ret = 1; |
32456 | 277 if (crop_x > this->pal_width || crop_y > this->pal_height || |
278 crop_w > this->pal_width - crop_x || crop_h > this->pal_width - crop_y || | |
279 crop_w > 0x8000 || crop_h > 0x8000 || | |
280 stride * crop_h > this->image_size) { | |
34778
48310248f892
Ensure that the highlight disappears when switching
reimar
parents:
33143
diff
changeset
|
281 // this might be an actual error or just signal that |
48310248f892
Ensure that the highlight disappears when switching
reimar
parents:
33143
diff
changeset
|
282 // the highlight should be removed. |
48310248f892
Ensure that the highlight disappears when switching
reimar
parents:
33143
diff
changeset
|
283 this->width = 0; |
48310248f892
Ensure that the highlight disappears when switching
reimar
parents:
33143
diff
changeset
|
284 this->height = 0; |
48310248f892
Ensure that the highlight disappears when switching
reimar
parents:
33143
diff
changeset
|
285 ret = 0; |
48310248f892
Ensure that the highlight disappears when switching
reimar
parents:
33143
diff
changeset
|
286 goto out; |
32456 | 287 } |
288 for (i = 0; i < 4; ++i) { | |
289 int color; | |
290 int alpha = this->alpha[i]; | |
291 // extend 4 -> 8 bit | |
292 alpha |= alpha << 4; | |
293 if (this->custom && (this->cuspal[i] >> 31) != 0) | |
294 alpha = 0; | |
295 color = this->custom ? this->cuspal[i] : | |
296 this->global_palette[this->palette[i]]; | |
297 color = (color >> 16) & 0xff; | |
298 // convert to MPlayer-style gray/alpha palette | |
299 color = FFMIN(color, alpha); | |
300 pal[i] = (-alpha << 8) | color; | |
301 } | |
302 src = this->pal_image + crop_y * this->pal_width + crop_x; | |
303 pal2gray_alpha(pal, src, this->pal_width, | |
304 this->image, this->aimage, stride, | |
305 crop_w, crop_h); | |
306 this->width = crop_w; | |
307 this->height = crop_h; | |
308 this->stride = stride; | |
309 this->start_col = this->pal_start_col + crop_x; | |
310 this->start_row = this->pal_start_row + crop_y; | |
311 spudec_cut_image(this); | |
312 | |
34778
48310248f892
Ensure that the highlight disappears when switching
reimar
parents:
33143
diff
changeset
|
313 out: |
32456 | 314 // reset scaled image |
315 this->scaled_frame_width = 0; | |
316 this->scaled_frame_height = 0; | |
317 this->palette_crop_cache.valid = 0; | |
318 return 1; | |
319 } | |
320 | |
321 int spudec_apply_palette_crop(void *this, uint32_t palette, | |
322 int sx, int sy, int ex, int ey) | |
323 { | |
324 spudec_handle_t *spu = this; | |
325 struct palette_crop_cache *c = &spu->palette_crop_cache; | |
326 if (c->valid && c->palette == palette && | |
327 c->sx == sx && c->sy == sy && c->ex == ex && c->ey == ey) | |
328 return c->result; | |
329 spu->palette[0] = (palette >> 28) & 0xf; | |
330 spu->palette[1] = (palette >> 24) & 0xf; | |
331 spu->palette[2] = (palette >> 20) & 0xf; | |
332 spu->palette[3] = (palette >> 16) & 0xf; | |
333 spu->alpha[0] = (palette >> 12) & 0xf; | |
334 spu->alpha[1] = (palette >> 8) & 0xf; | |
335 spu->alpha[2] = (palette >> 4) & 0xf; | |
336 spu->alpha[3] = palette & 0xf; | |
337 spu->spu_changed = 1; | |
338 c->result = apply_palette_crop(spu, | |
339 sx - spu->pal_start_col, sy - spu->pal_start_row, | |
340 ex - sx, ey - sy); | |
341 c->palette = palette; | |
342 c->sx = sx; c->sy = sy; | |
343 c->ex = ex; c->ey = ey; | |
344 c->valid = 1; | |
345 return c->result; | |
346 } | |
347 | |
348 static void spudec_process_data(spudec_handle_t *this, packet_t *packet) | |
349 { | |
350 unsigned int i, x, y; | |
351 uint8_t *dst; | |
352 | |
353 if (!spudec_alloc_image(this, packet->stride, packet->height)) | |
354 return; | |
355 | |
356 this->pal_start_col = packet->start_col; | |
357 this->pal_start_row = packet->start_row; | |
358 this->pal_height = packet->height; | |
359 this->pal_width = packet->width; | |
360 this->stride = packet->stride; | |
361 memcpy(this->palette, packet->palette, sizeof(this->palette)); | |
362 memcpy(this->alpha, packet->alpha, sizeof(this->alpha)); | |
363 | |
364 i = packet->current_nibble[1]; | |
365 x = 0; | |
366 y = 0; | |
367 dst = this->pal_image; | |
368 while (packet->current_nibble[0] < i | |
369 && packet->current_nibble[1] / 2 < packet->control_start | |
370 && y < this->pal_height) { | |
371 unsigned int len, color; | |
372 unsigned int rle = 0; | |
373 rle = get_nibble(packet); | |
374 if (rle < 0x04) { | |
375 if (rle == 0) { | |
376 rle = (rle << 4) | get_nibble(packet); | |
377 if (rle < 0x04) | |
378 rle = (rle << 4) | get_nibble(packet); | |
379 } | |
380 rle = (rle << 4) | get_nibble(packet); | |
381 } | |
382 color = 3 - (rle & 0x3); | |
383 len = rle >> 2; | |
384 x += len; | |
385 if (len == 0 || x >= this->pal_width) { | |
386 len += this->pal_width - x; | |
387 next_line(packet); | |
388 x = 0; | |
389 ++y; | |
390 } | |
391 memset(dst, color, len); | |
392 dst += len; | |
393 } | |
394 apply_palette_crop(this, 0, 0, this->pal_width, this->pal_height); | |
395 } | |
396 | |
397 | |
398 /* | |
399 This function tries to create a usable palette. | |
400 It determines how many non-transparent colors are used, and assigns different | |
401 gray scale values to each color. | |
402 I tested it with four streams and even got something readable. Half of the | |
403 times I got black characters with white around and half the reverse. | |
404 */ | |
405 static void compute_palette(spudec_handle_t *this, packet_t *packet) | |
406 { | |
407 int used[16],i,cused,start,step,color; | |
408 | |
409 memset(used, 0, sizeof(used)); | |
410 for (i=0; i<4; i++) | |
411 if (packet->alpha[i]) /* !Transparent? */ | |
412 used[packet->palette[i]] = 1; | |
413 for (cused=0, i=0; i<16; i++) | |
414 if (used[i]) cused++; | |
415 if (!cused) return; | |
416 if (cused == 1) { | |
417 start = 0x80; | |
418 step = 0; | |
419 } else { | |
420 start = this->font_start_level; | |
421 step = (0xF0-this->font_start_level)/(cused-1); | |
422 } | |
423 memset(used, 0, sizeof(used)); | |
424 for (i=0; i<4; i++) { | |
425 color = packet->palette[i]; | |
426 if (packet->alpha[i] && !used[color]) { /* not assigned? */ | |
427 used[color] = 1; | |
428 this->global_palette[color] = start<<16; | |
429 start += step; | |
430 } | |
431 } | |
432 } | |
433 | |
434 static void spudec_process_control(spudec_handle_t *this, int pts100) | |
435 { | |
436 int a,b,c,d; /* Temporary vars */ | |
437 unsigned int date, type; | |
438 unsigned int off; | |
439 unsigned int start_off = 0; | |
440 unsigned int next_off; | |
441 unsigned int start_pts = 0; | |
442 unsigned int end_pts = 0; | |
443 unsigned int current_nibble[2] = {0, 0}; | |
444 unsigned int control_start; | |
445 unsigned int display = 0; | |
446 unsigned int start_col = 0; | |
447 unsigned int end_col = 0; | |
448 unsigned int start_row = 0; | |
449 unsigned int end_row = 0; | |
450 unsigned int width = 0; | |
451 unsigned int height = 0; | |
452 unsigned int stride = 0; | |
453 | |
454 control_start = get_be16(this->packet + 2); | |
455 next_off = control_start; | |
456 while (start_off != next_off) { | |
457 start_off = next_off; | |
458 date = get_be16(this->packet + start_off) * 1024; | |
459 next_off = get_be16(this->packet + start_off + 2); | |
460 mp_msg(MSGT_SPUDEC,MSGL_DBG2, "date=%d\n", date); | |
461 off = start_off + 4; | |
462 for (type = this->packet[off++]; type != 0xff; type = this->packet[off++]) { | |
463 mp_msg(MSGT_SPUDEC,MSGL_DBG2, "cmd=%d ",type); | |
464 switch(type) { | |
465 case 0x00: | |
466 /* Menu ID, 1 byte */ | |
467 mp_msg(MSGT_SPUDEC,MSGL_DBG2,"Menu ID\n"); | |
468 /* shouldn't a Menu ID type force display start? */ | |
469 start_pts = pts100 < 0 && -pts100 >= date ? 0 : pts100 + date; | |
470 end_pts = UINT_MAX; | |
471 display = 1; | |
472 this->is_forced_sub=~0; // current subtitle is forced | |
473 break; | |
474 case 0x01: | |
475 /* Start display */ | |
476 mp_msg(MSGT_SPUDEC,MSGL_DBG2,"Start display!\n"); | |
477 start_pts = pts100 < 0 && -pts100 >= date ? 0 : pts100 + date; | |
478 end_pts = UINT_MAX; | |
479 display = 1; | |
480 this->is_forced_sub=0; | |
481 break; | |
482 case 0x02: | |
483 /* Stop display */ | |
484 mp_msg(MSGT_SPUDEC,MSGL_DBG2,"Stop display!\n"); | |
485 end_pts = pts100 < 0 && -pts100 >= date ? 0 : pts100 + date; | |
486 break; | |
487 case 0x03: | |
488 /* Palette */ | |
489 this->palette[0] = this->packet[off] >> 4; | |
490 this->palette[1] = this->packet[off] & 0xf; | |
491 this->palette[2] = this->packet[off + 1] >> 4; | |
492 this->palette[3] = this->packet[off + 1] & 0xf; | |
493 mp_msg(MSGT_SPUDEC,MSGL_DBG2,"Palette %d, %d, %d, %d\n", | |
494 this->palette[0], this->palette[1], this->palette[2], this->palette[3]); | |
495 off+=2; | |
496 break; | |
497 case 0x04: | |
498 /* Alpha */ | |
499 a = this->packet[off] >> 4; | |
500 b = this->packet[off] & 0xf; | |
501 c = this->packet[off + 1] >> 4; | |
502 d = this->packet[off + 1] & 0xf; | |
503 // Note: some DVDs change these values to create a fade-in/fade-out effect | |
504 // We can not handle this, so just keep the highest value during the display time. | |
505 if (display) { | |
506 a = FFMAX(a, this->alpha[0]); | |
507 b = FFMAX(b, this->alpha[1]); | |
508 c = FFMAX(c, this->alpha[2]); | |
509 d = FFMAX(d, this->alpha[3]); | |
510 } | |
511 this->alpha[0] = a; | |
512 this->alpha[1] = b; | |
513 this->alpha[2] = c; | |
514 this->alpha[3] = d; | |
515 mp_msg(MSGT_SPUDEC,MSGL_DBG2,"Alpha %d, %d, %d, %d\n", | |
516 this->alpha[0], this->alpha[1], this->alpha[2], this->alpha[3]); | |
517 off+=2; | |
518 break; | |
519 case 0x05: | |
520 /* Co-ords */ | |
521 a = get_be24(this->packet + off); | |
522 b = get_be24(this->packet + off + 3); | |
523 start_col = a >> 12; | |
524 end_col = a & 0xfff; | |
525 width = (end_col < start_col) ? 0 : end_col - start_col + 1; | |
526 stride = (width + 7) & ~7; /* Kludge: draw_alpha needs width multiple of 8 */ | |
527 start_row = b >> 12; | |
528 end_row = b & 0xfff; | |
529 height = (end_row < start_row) ? 0 : end_row - start_row /* + 1 */; | |
530 mp_msg(MSGT_SPUDEC,MSGL_DBG2,"Coords col: %d - %d row: %d - %d (%dx%d)\n", | |
531 start_col, end_col, start_row, end_row, | |
532 width, height); | |
533 off+=6; | |
534 break; | |
535 case 0x06: | |
536 /* Graphic lines */ | |
537 current_nibble[0] = 2 * get_be16(this->packet + off); | |
538 current_nibble[1] = 2 * get_be16(this->packet + off + 2); | |
539 mp_msg(MSGT_SPUDEC,MSGL_DBG2,"Graphic offset 1: %d offset 2: %d\n", | |
540 current_nibble[0] / 2, current_nibble[1] / 2); | |
541 off+=4; | |
542 break; | |
543 case 0xff: | |
544 /* All done, bye-bye */ | |
545 mp_msg(MSGT_SPUDEC,MSGL_DBG2,"Done!\n"); | |
546 return; | |
547 // break; | |
548 default: | |
549 mp_msg(MSGT_SPUDEC,MSGL_WARN,"spudec: Error determining control type 0x%02x. Skipping %d bytes.\n", | |
550 type, next_off - off); | |
551 goto next_control; | |
552 } | |
553 } | |
554 next_control: | |
555 if (!display) | |
556 continue; | |
557 if (end_pts == UINT_MAX && start_off != next_off) { | |
558 end_pts = get_be16(this->packet + next_off) * 1024; | |
559 end_pts = 1 - pts100 >= end_pts ? 0 : pts100 + end_pts - 1; | |
560 } | |
561 if (end_pts > 0) { | |
562 packet_t *packet = calloc(1, sizeof(packet_t)); | |
563 int i; | |
564 packet->start_pts = start_pts; | |
565 packet->end_pts = end_pts; | |
566 packet->current_nibble[0] = current_nibble[0]; | |
567 packet->current_nibble[1] = current_nibble[1]; | |
568 packet->start_row = start_row; | |
569 packet->start_col = start_col; | |
570 packet->width = width; | |
571 packet->height = height; | |
572 packet->stride = stride; | |
573 packet->control_start = control_start; | |
574 for (i=0; i<4; i++) { | |
575 packet->alpha[i] = this->alpha[i]; | |
576 packet->palette[i] = this->palette[i]; | |
577 } | |
578 packet->packet = malloc(this->packet_size); | |
579 memcpy(packet->packet, this->packet, this->packet_size); | |
580 spudec_queue_packet(this, packet); | |
581 } | |
582 } | |
583 } | |
584 | |
585 static void spudec_decode(spudec_handle_t *this, int pts100) | |
586 { | |
587 if (!this->hw_spu) | |
588 spudec_process_control(this, pts100); | |
589 else if (pts100 >= 0) { | |
590 static vo_mpegpes_t packet = { NULL, 0, 0x20, 0 }; | |
591 static vo_mpegpes_t *pkg=&packet; | |
592 packet.data = this->packet; | |
593 packet.size = this->packet_size; | |
594 packet.timestamp = pts100; | |
595 this->hw_spu->draw_frame((uint8_t**)&pkg); | |
596 } | |
597 } | |
598 | |
599 int spudec_changed(void * this) | |
600 { | |
601 spudec_handle_t * spu = this; | |
602 return spu->spu_changed || spu->now_pts > spu->end_pts; | |
603 } | |
604 | |
605 void spudec_assemble(void *this, unsigned char *packet, unsigned int len, int pts100) | |
606 { | |
607 spudec_handle_t *spu = this; | |
608 // spudec_heartbeat(this, pts100); | |
609 if (len < 2) { | |
610 mp_msg(MSGT_SPUDEC,MSGL_WARN,"SPUasm: packet too short\n"); | |
611 return; | |
612 } | |
613 spu->packet_pts = pts100; | |
614 if (spu->packet_offset == 0) { | |
615 unsigned int len2 = get_be16(packet); | |
616 // Start new fragment | |
617 if (spu->packet_reserve < len2) { | |
32511
b39155e98ac3
Remove some useless NULL pointer checks before invoking free() on the pointer.
diego
parents:
32467
diff
changeset
|
618 free(spu->packet); |
32456 | 619 spu->packet = malloc(len2); |
620 spu->packet_reserve = spu->packet != NULL ? len2 : 0; | |
621 } | |
622 if (spu->packet != NULL) { | |
623 spu->packet_size = len2; | |
624 if (len > len2) { | |
625 mp_msg(MSGT_SPUDEC,MSGL_WARN,"SPUasm: invalid frag len / len2: %d / %d \n", len, len2); | |
626 return; | |
627 } | |
628 memcpy(spu->packet, packet, len); | |
629 spu->packet_offset = len; | |
630 spu->packet_pts = pts100; | |
631 } | |
632 } else { | |
633 // Continue current fragment | |
634 if (spu->packet_size < spu->packet_offset + len){ | |
635 mp_msg(MSGT_SPUDEC,MSGL_WARN,"SPUasm: invalid fragment\n"); | |
636 spu->packet_size = spu->packet_offset = 0; | |
637 return; | |
638 } else { | |
639 memcpy(spu->packet + spu->packet_offset, packet, len); | |
640 spu->packet_offset += len; | |
641 } | |
642 } | |
643 #if 1 | |
644 // check if we have a complete packet (unfortunatelly packet_size is bad | |
645 // for some disks) | |
646 // [cb] packet_size is padded to be even -> may be one byte too long | |
647 if ((spu->packet_offset == spu->packet_size) || | |
648 ((spu->packet_offset + 1) == spu->packet_size)){ | |
649 unsigned int x=0,y; | |
650 while(x+4<=spu->packet_offset){ | |
651 y=get_be16(spu->packet+x+2); // next control pointer | |
652 mp_msg(MSGT_SPUDEC,MSGL_DBG2,"SPUtest: x=%d y=%d off=%d size=%d\n",x,y,spu->packet_offset,spu->packet_size); | |
653 if(x>=4 && x==y){ // if it points to self - we're done! | |
654 // we got it! | |
655 mp_msg(MSGT_SPUDEC,MSGL_DBG2,"SPUgot: off=%d size=%d \n",spu->packet_offset,spu->packet_size); | |
656 spudec_decode(spu, pts100); | |
657 spu->packet_offset = 0; | |
658 break; | |
659 } | |
660 if(y<=x || y>=spu->packet_size){ // invalid? | |
661 mp_msg(MSGT_SPUDEC,MSGL_WARN,"SPUtest: broken packet!!!!! y=%d < x=%d\n",y,x); | |
662 spu->packet_size = spu->packet_offset = 0; | |
663 break; | |
664 } | |
665 x=y; | |
666 } | |
667 // [cb] packet is done; start new packet | |
668 spu->packet_offset = 0; | |
669 } | |
670 #else | |
671 if (spu->packet_offset == spu->packet_size) { | |
672 spudec_decode(spu, pts100); | |
673 spu->packet_offset = 0; | |
674 } | |
675 #endif | |
676 } | |
677 | |
678 void spudec_reset(void *this) // called after seek | |
679 { | |
680 spudec_handle_t *spu = this; | |
681 while (spu->queue_head) | |
682 spudec_free_packet(spudec_dequeue_packet(spu)); | |
683 spu->now_pts = 0; | |
684 spu->end_pts = 0; | |
685 spu->packet_size = spu->packet_offset = 0; | |
686 } | |
687 | |
688 void spudec_heartbeat(void *this, unsigned int pts100) | |
689 { | |
690 spudec_handle_t *spu = this; | |
691 spu->now_pts = pts100; | |
692 | |
693 // TODO: detect and handle broken timestamps (e.g. due to wrapping) | |
694 while (spu->queue_head != NULL && pts100 >= spu->queue_head->start_pts) { | |
695 packet_t *packet = spudec_dequeue_packet(spu); | |
696 spu->start_pts = packet->start_pts; | |
697 spu->end_pts = packet->end_pts; | |
698 if (packet->is_decoded) { | |
699 free(spu->image); | |
700 spu->image_size = packet->data_len; | |
701 spu->image = packet->packet; | |
702 spu->aimage = packet->packet + packet->stride * packet->height; | |
703 packet->packet = NULL; | |
704 spu->width = packet->width; | |
705 spu->height = packet->height; | |
706 spu->stride = packet->stride; | |
707 spu->start_col = packet->start_col; | |
708 spu->start_row = packet->start_row; | |
709 | |
710 // reset scaled image | |
711 spu->scaled_frame_width = 0; | |
712 spu->scaled_frame_height = 0; | |
713 } else { | |
714 if (spu->auto_palette) | |
715 compute_palette(spu, packet); | |
716 spudec_process_data(spu, packet); | |
717 } | |
718 spudec_free_packet(packet); | |
719 spu->spu_changed = 1; | |
720 } | |
721 } | |
722 | |
723 int spudec_visible(void *this){ | |
724 spudec_handle_t *spu = this; | |
725 int ret=(spu->start_pts <= spu->now_pts && | |
726 spu->now_pts < spu->end_pts && | |
727 spu->height > 0); | |
728 // printf("spu visible: %d \n",ret); | |
729 return ret; | |
730 } | |
731 | |
732 void spudec_set_forced_subs_only(void * const this, const unsigned int flag) | |
733 { | |
734 if(this){ | |
735 ((spudec_handle_t *)this)->forced_subs_only=flag; | |
736 mp_msg(MSGT_SPUDEC,MSGL_DBG2,"SPU: Display only forced subs now %s\n", flag ? "enabled": "disabled"); | |
737 } | |
738 } | |
739 | |
740 void spudec_draw(void *this, void (*draw_alpha)(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride)) | |
741 { | |
742 spudec_handle_t *spu = this; | |
743 if (spudec_visible(spu)) | |
744 { | |
745 draw_alpha(spu->start_col, spu->start_row, spu->width, spu->height, | |
746 spu->image, spu->aimage, spu->stride); | |
747 spu->spu_changed = 0; | |
748 } | |
749 } | |
750 | |
751 /* calc the bbox for spudec subs */ | |
752 void spudec_calc_bbox(void *me, unsigned int dxs, unsigned int dys, unsigned int* bbox) | |
753 { | |
754 spudec_handle_t *spu = me; | |
755 if (spu->orig_frame_width == 0 || spu->orig_frame_height == 0 | |
756 || (spu->orig_frame_width == dxs && spu->orig_frame_height == dys)) { | |
757 // unscaled | |
758 bbox[0] = spu->start_col; | |
759 bbox[1] = spu->start_col + spu->width; | |
760 bbox[2] = spu->start_row; | |
761 bbox[3] = spu->start_row + spu->height; | |
762 } | |
763 else { | |
764 // scaled | |
765 unsigned int scalex = 0x100 * dxs / spu->orig_frame_width; | |
766 unsigned int scaley = 0x100 * dys / spu->orig_frame_height; | |
767 bbox[0] = spu->start_col * scalex / 0x100; | |
768 bbox[1] = spu->start_col * scalex / 0x100 + spu->width * scalex / 0x100; | |
769 switch (spu_alignment) { | |
770 case 0: | |
771 bbox[3] = dys*sub_pos/100 + spu->height * scaley / 0x100; | |
772 if (bbox[3] > dys) bbox[3] = dys; | |
773 bbox[2] = bbox[3] - spu->height * scaley / 0x100; | |
774 break; | |
775 case 1: | |
776 if (sub_pos < 50) { | |
777 bbox[2] = dys*sub_pos/100 - spu->height * scaley / 0x200; | |
778 bbox[3] = bbox[2] + spu->height; | |
779 } else { | |
780 bbox[3] = dys*sub_pos/100 + spu->height * scaley / 0x200; | |
781 if (bbox[3] > dys) bbox[3] = dys; | |
782 bbox[2] = bbox[3] - spu->height * scaley / 0x100; | |
783 } | |
784 break; | |
785 case 2: | |
786 bbox[2] = dys*sub_pos/100 - spu->height * scaley / 0x100; | |
787 bbox[3] = bbox[2] + spu->height; | |
788 break; | |
789 default: /* -1 */ | |
790 bbox[2] = spu->start_row * scaley / 0x100; | |
791 bbox[3] = spu->start_row * scaley / 0x100 + spu->height * scaley / 0x100; | |
792 break; | |
793 } | |
794 } | |
795 } | |
796 /* transform mplayer's alpha value into an opacity value that is linear */ | |
797 static inline int canon_alpha(int alpha) | |
798 { | |
799 return (uint8_t)-alpha; | |
800 } | |
801 | |
802 typedef struct { | |
803 unsigned position; | |
804 unsigned left_up; | |
805 unsigned right_down; | |
806 }scale_pixel; | |
807 | |
808 | |
809 static void scale_table(unsigned int start_src, unsigned int start_tar, unsigned int end_src, unsigned int end_tar, scale_pixel * table) | |
810 { | |
811 unsigned int t; | |
812 unsigned int delta_src = end_src - start_src; | |
813 unsigned int delta_tar = end_tar - start_tar; | |
814 int src = 0; | |
815 int src_step; | |
816 if (delta_src == 0 || delta_tar == 0) { | |
817 return; | |
818 } | |
819 src_step = (delta_src << 16) / delta_tar >>1; | |
820 for (t = 0; t<=delta_tar; src += (src_step << 1), t++){ | |
821 table[t].position= FFMIN(src >> 16, end_src - 1); | |
822 table[t].right_down = src & 0xffff; | |
823 table[t].left_up = 0x10000 - table[t].right_down; | |
824 } | |
825 } | |
826 | |
827 /* bilinear scale, similar to vobsub's code */ | |
828 static void scale_image(int x, int y, scale_pixel* table_x, scale_pixel* table_y, spudec_handle_t * spu) | |
829 { | |
830 int alpha[4]; | |
831 int color[4]; | |
832 unsigned int scale[4]; | |
833 int base = table_y[y].position * spu->stride + table_x[x].position; | |
834 int scaled = y * spu->scaled_stride + x; | |
835 alpha[0] = canon_alpha(spu->aimage[base]); | |
836 alpha[1] = canon_alpha(spu->aimage[base + 1]); | |
837 alpha[2] = canon_alpha(spu->aimage[base + spu->stride]); | |
838 alpha[3] = canon_alpha(spu->aimage[base + spu->stride + 1]); | |
839 color[0] = spu->image[base]; | |
840 color[1] = spu->image[base + 1]; | |
841 color[2] = spu->image[base + spu->stride]; | |
842 color[3] = spu->image[base + spu->stride + 1]; | |
843 scale[0] = (table_x[x].left_up * table_y[y].left_up >> 16) * alpha[0]; | |
844 if (table_y[y].left_up == 0x10000) // necessary to avoid overflow-case | |
845 scale[0] = table_x[x].left_up * alpha[0]; | |
846 scale[1] = (table_x[x].right_down * table_y[y].left_up >>16) * alpha[1]; | |
847 scale[2] = (table_x[x].left_up * table_y[y].right_down >> 16) * alpha[2]; | |
848 scale[3] = (table_x[x].right_down * table_y[y].right_down >> 16) * alpha[3]; | |
849 spu->scaled_image[scaled] = (color[0] * scale[0] + color[1] * scale[1] + color[2] * scale[2] + color[3] * scale[3])>>24; | |
850 spu->scaled_aimage[scaled] = (scale[0] + scale[1] + scale[2] + scale[3]) >> 16; | |
851 if (spu->scaled_aimage[scaled]){ | |
852 // ensure that MPlayer's simplified alpha-blending can not overflow | |
853 spu->scaled_image[scaled] = FFMIN(spu->scaled_image[scaled], spu->scaled_aimage[scaled]); | |
854 // convert to MPlayer-style alpha | |
855 spu->scaled_aimage[scaled] = -spu->scaled_aimage[scaled]; | |
856 } | |
857 } | |
858 | |
859 static void sws_spu_image(unsigned char *d1, unsigned char *d2, int dw, int dh, | |
860 int ds, const unsigned char* s1, unsigned char* s2, | |
861 int sw, int sh, int ss) | |
862 { | |
863 struct SwsContext *ctx; | |
864 static SwsFilter filter; | |
865 static int firsttime = 1; | |
866 static float oldvar; | |
867 int i; | |
868 | |
869 if (!firsttime && oldvar != spu_gaussvar) sws_freeVec(filter.lumH); | |
870 if (firsttime) { | |
871 filter.lumH = filter.lumV = | |
872 filter.chrH = filter.chrV = sws_getGaussianVec(spu_gaussvar, 3.0); | |
873 sws_normalizeVec(filter.lumH, 1.0); | |
874 firsttime = 0; | |
875 oldvar = spu_gaussvar; | |
876 } | |
877 | |
878 ctx=sws_getContext(sw, sh, PIX_FMT_GRAY8, dw, dh, PIX_FMT_GRAY8, SWS_GAUSS, &filter, NULL, NULL); | |
879 sws_scale(ctx,&s1,&ss,0,sh,&d1,&ds); | |
34786 | 880 for (i=ss*sh-1; i>=0; i--) s2[i] = -s2[i]; |
32456 | 881 sws_scale(ctx,&s2,&ss,0,sh,&d2,&ds); |
34786 | 882 for (i=ds*dh-1; i>=0; i--) d2[i] = -d2[i]; |
32456 | 883 sws_freeContext(ctx); |
884 } | |
885 | |
886 void spudec_draw_scaled(void *me, unsigned int dxs, unsigned int dys, void (*draw_alpha)(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride)) | |
887 { | |
888 spudec_handle_t *spu = me; | |
889 scale_pixel *table_x; | |
890 scale_pixel *table_y; | |
891 | |
892 if (spudec_visible(spu)) { | |
893 | |
894 // check if only forced subtitles are requested | |
895 if( (spu->forced_subs_only) && !(spu->is_forced_sub) ){ | |
896 return; | |
897 } | |
898 | |
899 if (!(spu_aamode&16) && (spu->orig_frame_width == 0 || spu->orig_frame_height == 0 | |
900 || (spu->orig_frame_width == dxs && spu->orig_frame_height == dys))) { | |
901 spudec_draw(spu, draw_alpha); | |
902 } | |
903 else { | |
904 if (spu->scaled_frame_width != dxs || spu->scaled_frame_height != dys) { /* Resizing is needed */ | |
905 /* scaled_x = scalex * x / 0x100 | |
906 scaled_y = scaley * y / 0x100 | |
907 order of operations is important because of rounding. */ | |
908 unsigned int scalex = 0x100 * dxs / spu->orig_frame_width; | |
909 unsigned int scaley = 0x100 * dys / spu->orig_frame_height; | |
910 spu->scaled_start_col = spu->start_col * scalex / 0x100; | |
911 spu->scaled_start_row = spu->start_row * scaley / 0x100; | |
912 spu->scaled_width = spu->width * scalex / 0x100; | |
913 spu->scaled_height = spu->height * scaley / 0x100; | |
914 /* Kludge: draw_alpha needs width multiple of 8 */ | |
915 spu->scaled_stride = (spu->scaled_width + 7) & ~7; | |
916 if (spu->scaled_image_size < spu->scaled_stride * spu->scaled_height) { | |
917 if (spu->scaled_image) { | |
918 free(spu->scaled_image); | |
919 spu->scaled_image_size = 0; | |
920 } | |
921 spu->scaled_image = malloc(2 * spu->scaled_stride * spu->scaled_height); | |
922 if (spu->scaled_image) { | |
923 spu->scaled_image_size = spu->scaled_stride * spu->scaled_height; | |
924 spu->scaled_aimage = spu->scaled_image + spu->scaled_image_size; | |
925 } | |
926 } | |
927 if (spu->scaled_image) { | |
928 unsigned int x, y; | |
33143
1cad23803d94
Fix artefacts at right border of scaled bitmap subtitles by clearing the
reimar
parents:
32511
diff
changeset
|
929 // needs to be 0-initialized because draw_alpha draws always a |
1cad23803d94
Fix artefacts at right border of scaled bitmap subtitles by clearing the
reimar
parents:
32511
diff
changeset
|
930 // multiple of 8 pixels. TODO: optimize |
1cad23803d94
Fix artefacts at right border of scaled bitmap subtitles by clearing the
reimar
parents:
32511
diff
changeset
|
931 if (spu->scaled_width & 7) |
1cad23803d94
Fix artefacts at right border of scaled bitmap subtitles by clearing the
reimar
parents:
32511
diff
changeset
|
932 memset(spu->scaled_image, 0, 2 * spu->scaled_image_size); |
32456 | 933 if (spu->scaled_width <= 1 || spu->scaled_height <= 1) { |
934 goto nothing_to_do; | |
935 } | |
936 switch(spu_aamode&15) { | |
937 case 4: | |
938 sws_spu_image(spu->scaled_image, spu->scaled_aimage, | |
939 spu->scaled_width, spu->scaled_height, spu->scaled_stride, | |
940 spu->image, spu->aimage, spu->width, spu->height, spu->stride); | |
941 break; | |
942 case 3: | |
943 table_x = calloc(spu->scaled_width, sizeof(scale_pixel)); | |
944 table_y = calloc(spu->scaled_height, sizeof(scale_pixel)); | |
945 if (!table_x || !table_y) { | |
946 mp_msg(MSGT_SPUDEC, MSGL_FATAL, "Fatal: spudec_draw_scaled: calloc failed\n"); | |
947 } | |
948 scale_table(0, 0, spu->width - 1, spu->scaled_width - 1, table_x); | |
949 scale_table(0, 0, spu->height - 1, spu->scaled_height - 1, table_y); | |
950 for (y = 0; y < spu->scaled_height; y++) | |
951 for (x = 0; x < spu->scaled_width; x++) | |
952 scale_image(x, y, table_x, table_y, spu); | |
953 free(table_x); | |
954 free(table_y); | |
955 break; | |
956 case 0: | |
957 /* no antialiasing */ | |
958 for (y = 0; y < spu->scaled_height; ++y) { | |
959 int unscaled_y = y * 0x100 / scaley; | |
960 int strides = spu->stride * unscaled_y; | |
961 int scaled_strides = spu->scaled_stride * y; | |
962 for (x = 0; x < spu->scaled_width; ++x) { | |
963 int unscaled_x = x * 0x100 / scalex; | |
964 spu->scaled_image[scaled_strides + x] = spu->image[strides + unscaled_x]; | |
965 spu->scaled_aimage[scaled_strides + x] = spu->aimage[strides + unscaled_x]; | |
966 } | |
967 } | |
968 break; | |
969 case 1: | |
970 { | |
971 /* Intermediate antialiasing. */ | |
972 for (y = 0; y < spu->scaled_height; ++y) { | |
973 const unsigned int unscaled_top = y * spu->orig_frame_height / dys; | |
974 unsigned int unscaled_bottom = (y + 1) * spu->orig_frame_height / dys; | |
975 if (unscaled_bottom >= spu->height) | |
976 unscaled_bottom = spu->height - 1; | |
977 for (x = 0; x < spu->scaled_width; ++x) { | |
978 const unsigned int unscaled_left = x * spu->orig_frame_width / dxs; | |
979 unsigned int unscaled_right = (x + 1) * spu->orig_frame_width / dxs; | |
980 unsigned int color = 0; | |
981 unsigned int alpha = 0; | |
982 unsigned int walkx, walky; | |
983 unsigned int base, tmp; | |
984 if (unscaled_right >= spu->width) | |
985 unscaled_right = spu->width - 1; | |
986 for (walky = unscaled_top; walky <= unscaled_bottom; ++walky) | |
987 for (walkx = unscaled_left; walkx <= unscaled_right; ++walkx) { | |
988 base = walky * spu->stride + walkx; | |
989 tmp = canon_alpha(spu->aimage[base]); | |
990 alpha += tmp; | |
991 color += tmp * spu->image[base]; | |
992 } | |
993 base = y * spu->scaled_stride + x; | |
994 spu->scaled_image[base] = alpha ? color / alpha : 0; | |
995 spu->scaled_aimage[base] = | |
996 alpha * (1 + unscaled_bottom - unscaled_top) * (1 + unscaled_right - unscaled_left); | |
997 /* spu->scaled_aimage[base] = | |
998 alpha * dxs * dys / spu->orig_frame_width / spu->orig_frame_height; */ | |
999 if (spu->scaled_aimage[base]) { | |
1000 spu->scaled_aimage[base] = 256 - spu->scaled_aimage[base]; | |
1001 if (spu->scaled_aimage[base] + spu->scaled_image[base] > 255) | |
1002 spu->scaled_image[base] = 256 - spu->scaled_aimage[base]; | |
1003 } | |
1004 } | |
1005 } | |
1006 } | |
1007 break; | |
1008 case 2: | |
1009 { | |
1010 /* Best antialiasing. Very slow. */ | |
1011 /* Any pixel (x, y) represents pixels from the original | |
1012 rectangular region comprised between the columns | |
1013 unscaled_y and unscaled_y + 0x100 / scaley and the rows | |
1014 unscaled_x and unscaled_x + 0x100 / scalex | |
1015 | |
1016 The original rectangular region that the scaled pixel | |
1017 represents is cut in 9 rectangular areas like this: | |
1018 | |
1019 +---+-----------------+---+ | |
1020 | 1 | 2 | 3 | | |
1021 +---+-----------------+---+ | |
1022 | | | | | |
1023 | 4 | 5 | 6 | | |
1024 | | | | | |
1025 +---+-----------------+---+ | |
1026 | 7 | 8 | 9 | | |
1027 +---+-----------------+---+ | |
1028 | |
1029 The width of the left column is at most one pixel and | |
1030 it is never null and its right column is at a pixel | |
1031 boundary. The height of the top row is at most one | |
1032 pixel it is never null and its bottom row is at a | |
1033 pixel boundary. The width and height of region 5 are | |
1034 integral values. The width of the right column is | |
1035 what remains and is less than one pixel. The height | |
1036 of the bottom row is what remains and is less than | |
1037 one pixel. | |
1038 | |
1039 The row above 1, 2, 3 is unscaled_y. The row between | |
1040 1, 2, 3 and 4, 5, 6 is top_low_row. The row between 4, | |
1041 5, 6 and 7, 8, 9 is (unsigned int)unscaled_y_bottom. | |
1042 The row beneath 7, 8, 9 is unscaled_y_bottom. | |
1043 | |
1044 The column left of 1, 4, 7 is unscaled_x. The column | |
1045 between 1, 4, 7 and 2, 5, 8 is left_right_column. The | |
1046 column between 2, 5, 8 and 3, 6, 9 is (unsigned | |
1047 int)unscaled_x_right. The column right of 3, 6, 9 is | |
1048 unscaled_x_right. */ | |
1049 const double inv_scalex = (double) 0x100 / scalex; | |
1050 const double inv_scaley = (double) 0x100 / scaley; | |
1051 for (y = 0; y < spu->scaled_height; ++y) { | |
1052 const double unscaled_y = y * inv_scaley; | |
1053 const double unscaled_y_bottom = unscaled_y + inv_scaley; | |
1054 const unsigned int top_low_row = FFMIN(unscaled_y_bottom, unscaled_y + 1.0); | |
1055 const double top = top_low_row - unscaled_y; | |
1056 const unsigned int height = unscaled_y_bottom > top_low_row | |
1057 ? (unsigned int) unscaled_y_bottom - top_low_row | |
1058 : 0; | |
1059 const double bottom = unscaled_y_bottom > top_low_row | |
1060 ? unscaled_y_bottom - floor(unscaled_y_bottom) | |
1061 : 0.0; | |
1062 for (x = 0; x < spu->scaled_width; ++x) { | |
1063 const double unscaled_x = x * inv_scalex; | |
1064 const double unscaled_x_right = unscaled_x + inv_scalex; | |
1065 const unsigned int left_right_column = FFMIN(unscaled_x_right, unscaled_x + 1.0); | |
1066 const double left = left_right_column - unscaled_x; | |
1067 const unsigned int width = unscaled_x_right > left_right_column | |
1068 ? (unsigned int) unscaled_x_right - left_right_column | |
1069 : 0; | |
1070 const double right = unscaled_x_right > left_right_column | |
1071 ? unscaled_x_right - floor(unscaled_x_right) | |
1072 : 0.0; | |
1073 double color = 0.0; | |
1074 double alpha = 0.0; | |
1075 double tmp; | |
1076 unsigned int base; | |
1077 /* Now use these informations to compute a good alpha, | |
1078 and lightness. The sum is on each of the 9 | |
1079 region's surface and alpha and lightness. | |
1080 | |
1081 transformed alpha = sum(surface * alpha) / sum(surface) | |
1082 transformed color = sum(surface * alpha * color) / sum(surface * alpha) | |
1083 */ | |
1084 /* 1: top left part */ | |
1085 base = spu->stride * (unsigned int) unscaled_y; | |
1086 tmp = left * top * canon_alpha(spu->aimage[base + (unsigned int) unscaled_x]); | |
1087 alpha += tmp; | |
1088 color += tmp * spu->image[base + (unsigned int) unscaled_x]; | |
1089 /* 2: top center part */ | |
1090 if (width > 0) { | |
1091 unsigned int walkx; | |
1092 for (walkx = left_right_column; walkx < (unsigned int) unscaled_x_right; ++walkx) { | |
1093 base = spu->stride * (unsigned int) unscaled_y + walkx; | |
1094 tmp = /* 1.0 * */ top * canon_alpha(spu->aimage[base]); | |
1095 alpha += tmp; | |
1096 color += tmp * spu->image[base]; | |
1097 } | |
1098 } | |
1099 /* 3: top right part */ | |
1100 if (right > 0.0) { | |
1101 base = spu->stride * (unsigned int) unscaled_y + (unsigned int) unscaled_x_right; | |
1102 tmp = right * top * canon_alpha(spu->aimage[base]); | |
1103 alpha += tmp; | |
1104 color += tmp * spu->image[base]; | |
1105 } | |
1106 /* 4: center left part */ | |
1107 if (height > 0) { | |
1108 unsigned int walky; | |
1109 for (walky = top_low_row; walky < (unsigned int) unscaled_y_bottom; ++walky) { | |
1110 base = spu->stride * walky + (unsigned int) unscaled_x; | |
1111 tmp = left /* * 1.0 */ * canon_alpha(spu->aimage[base]); | |
1112 alpha += tmp; | |
1113 color += tmp * spu->image[base]; | |
1114 } | |
1115 } | |
1116 /* 5: center part */ | |
1117 if (width > 0 && height > 0) { | |
1118 unsigned int walky; | |
1119 for (walky = top_low_row; walky < (unsigned int) unscaled_y_bottom; ++walky) { | |
1120 unsigned int walkx; | |
1121 base = spu->stride * walky; | |
1122 for (walkx = left_right_column; walkx < (unsigned int) unscaled_x_right; ++walkx) { | |
1123 tmp = /* 1.0 * 1.0 * */ canon_alpha(spu->aimage[base + walkx]); | |
1124 alpha += tmp; | |
1125 color += tmp * spu->image[base + walkx]; | |
1126 } | |
1127 } | |
1128 } | |
1129 /* 6: center right part */ | |
1130 if (right > 0.0 && height > 0) { | |
1131 unsigned int walky; | |
1132 for (walky = top_low_row; walky < (unsigned int) unscaled_y_bottom; ++walky) { | |
1133 base = spu->stride * walky + (unsigned int) unscaled_x_right; | |
1134 tmp = right /* * 1.0 */ * canon_alpha(spu->aimage[base]); | |
1135 alpha += tmp; | |
1136 color += tmp * spu->image[base]; | |
1137 } | |
1138 } | |
1139 /* 7: bottom left part */ | |
1140 if (bottom > 0.0) { | |
1141 base = spu->stride * (unsigned int) unscaled_y_bottom + (unsigned int) unscaled_x; | |
1142 tmp = left * bottom * canon_alpha(spu->aimage[base]); | |
1143 alpha += tmp; | |
1144 color += tmp * spu->image[base]; | |
1145 } | |
1146 /* 8: bottom center part */ | |
1147 if (width > 0 && bottom > 0.0) { | |
1148 unsigned int walkx; | |
1149 base = spu->stride * (unsigned int) unscaled_y_bottom; | |
1150 for (walkx = left_right_column; walkx < (unsigned int) unscaled_x_right; ++walkx) { | |
1151 tmp = /* 1.0 * */ bottom * canon_alpha(spu->aimage[base + walkx]); | |
1152 alpha += tmp; | |
1153 color += tmp * spu->image[base + walkx]; | |
1154 } | |
1155 } | |
1156 /* 9: bottom right part */ | |
1157 if (right > 0.0 && bottom > 0.0) { | |
1158 base = spu->stride * (unsigned int) unscaled_y_bottom + (unsigned int) unscaled_x_right; | |
1159 tmp = right * bottom * canon_alpha(spu->aimage[base]); | |
1160 alpha += tmp; | |
1161 color += tmp * spu->image[base]; | |
1162 } | |
1163 /* Finally mix these transparency and brightness information suitably */ | |
1164 base = spu->scaled_stride * y + x; | |
1165 spu->scaled_image[base] = alpha > 0 ? color / alpha : 0; | |
1166 spu->scaled_aimage[base] = alpha * scalex * scaley / 0x10000; | |
1167 if (spu->scaled_aimage[base]) { | |
1168 spu->scaled_aimage[base] = 256 - spu->scaled_aimage[base]; | |
1169 if (spu->scaled_aimage[base] + spu->scaled_image[base] > 255) | |
1170 spu->scaled_image[base] = 256 - spu->scaled_aimage[base]; | |
1171 } | |
1172 } | |
1173 } | |
1174 } | |
1175 } | |
1176 nothing_to_do: | |
1177 /* Kludge: draw_alpha needs width multiple of 8. */ | |
1178 if (spu->scaled_width < spu->scaled_stride) | |
1179 for (y = 0; y < spu->scaled_height; ++y) { | |
1180 memset(spu->scaled_aimage + y * spu->scaled_stride + spu->scaled_width, 0, | |
1181 spu->scaled_stride - spu->scaled_width); | |
1182 } | |
1183 spu->scaled_frame_width = dxs; | |
1184 spu->scaled_frame_height = dys; | |
1185 } | |
1186 } | |
1187 if (spu->scaled_image){ | |
1188 switch (spu_alignment) { | |
1189 case 0: | |
1190 spu->scaled_start_row = dys*sub_pos/100; | |
1191 if (spu->scaled_start_row + spu->scaled_height > dys) | |
1192 spu->scaled_start_row = dys - spu->scaled_height; | |
1193 break; | |
1194 case 1: | |
1195 spu->scaled_start_row = dys*sub_pos/100 - spu->scaled_height/2; | |
1196 if (sub_pos >= 50 && spu->scaled_start_row + spu->scaled_height > dys) | |
1197 spu->scaled_start_row = dys - spu->scaled_height; | |
1198 break; | |
1199 case 2: | |
1200 spu->scaled_start_row = dys*sub_pos/100 - spu->scaled_height; | |
1201 break; | |
1202 } | |
1203 draw_alpha(spu->scaled_start_col, spu->scaled_start_row, spu->scaled_width, spu->scaled_height, | |
1204 spu->scaled_image, spu->scaled_aimage, spu->scaled_stride); | |
1205 spu->spu_changed = 0; | |
1206 } | |
1207 } | |
1208 } | |
1209 else | |
1210 { | |
1211 mp_msg(MSGT_SPUDEC,MSGL_DBG2,"SPU not displayed: start_pts=%d end_pts=%d now_pts=%d\n", | |
1212 spu->start_pts, spu->end_pts, spu->now_pts); | |
1213 } | |
1214 } | |
1215 | |
1216 void spudec_update_palette(void * this, unsigned int *palette) | |
1217 { | |
1218 spudec_handle_t *spu = this; | |
1219 if (spu && palette) { | |
1220 memcpy(spu->global_palette, palette, sizeof(spu->global_palette)); | |
1221 if(spu->hw_spu) | |
1222 spu->hw_spu->control(VOCTRL_SET_SPU_PALETTE,spu->global_palette); | |
1223 } | |
1224 } | |
1225 | |
1226 void spudec_set_font_factor(void * this, double factor) | |
1227 { | |
1228 spudec_handle_t *spu = this; | |
1229 spu->font_start_level = (int)(0xF0-(0xE0*factor)); | |
1230 } | |
1231 | |
1232 static void spudec_parse_extradata(spudec_handle_t *this, | |
1233 uint8_t *extradata, int extradata_len) | |
1234 { | |
1235 uint8_t *buffer, *ptr; | |
1236 unsigned int *pal = this->global_palette, *cuspal = this->cuspal; | |
1237 unsigned int tridx; | |
1238 int i; | |
1239 | |
1240 if (extradata_len == 16*4) { | |
1241 for (i=0; i<16; i++) | |
1242 pal[i] = AV_RB32(extradata + i*4); | |
1243 this->auto_palette = 0; | |
1244 return; | |
1245 } | |
1246 | |
1247 if (!(ptr = buffer = malloc(extradata_len+1))) | |
1248 return; | |
1249 memcpy(buffer, extradata, extradata_len); | |
1250 buffer[extradata_len] = 0; | |
1251 | |
1252 do { | |
1253 if (*ptr == '#') | |
1254 continue; | |
1255 if (!strncmp(ptr, "size: ", 6)) | |
1256 sscanf(ptr + 6, "%dx%d", &this->orig_frame_width, &this->orig_frame_height); | |
1257 if (!strncmp(ptr, "palette: ", 9) && | |
1258 sscanf(ptr + 9, "%x, %x, %x, %x, %x, %x, %x, %x, " | |
1259 "%x, %x, %x, %x, %x, %x, %x, %x", | |
1260 &pal[ 0], &pal[ 1], &pal[ 2], &pal[ 3], | |
1261 &pal[ 4], &pal[ 5], &pal[ 6], &pal[ 7], | |
1262 &pal[ 8], &pal[ 9], &pal[10], &pal[11], | |
1263 &pal[12], &pal[13], &pal[14], &pal[15]) == 16) { | |
1264 for (i=0; i<16; i++) | |
1265 pal[i] = vobsub_palette_to_yuv(pal[i]); | |
1266 this->auto_palette = 0; | |
1267 } | |
1268 if (!strncasecmp(ptr, "forced subs: on", 15)) | |
1269 this->forced_subs_only = 1; | |
1270 if (!strncmp(ptr, "custom colors: ON, tridx: ", 26) && | |
1271 sscanf(ptr + 26, "%x, colors: %x, %x, %x, %x", | |
1272 &tridx, cuspal+0, cuspal+1, cuspal+2, cuspal+3) == 5) { | |
1273 for (i=0; i<4; i++) { | |
1274 cuspal[i] = vobsub_rgb_to_yuv(cuspal[i]); | |
1275 if (tridx & (1 << (12-4*i))) | |
1276 cuspal[i] |= 1 << 31; | |
1277 } | |
1278 this->custom = 1; | |
1279 } | |
1280 } while ((ptr=strchr(ptr,'\n')) && *++ptr); | |
1281 | |
1282 free(buffer); | |
1283 } | |
1284 | |
1285 void *spudec_new_scaled(unsigned int *palette, unsigned int frame_width, unsigned int frame_height, uint8_t *extradata, int extradata_len) | |
1286 { | |
1287 spudec_handle_t *this = calloc(1, sizeof(spudec_handle_t)); | |
1288 if (this){ | |
1289 this->orig_frame_height = frame_height; | |
1290 this->orig_frame_width = frame_width; | |
1291 // set up palette: | |
1292 if (palette) | |
1293 memcpy(this->global_palette, palette, sizeof(this->global_palette)); | |
1294 else | |
1295 this->auto_palette = 1; | |
1296 if (extradata) | |
1297 spudec_parse_extradata(this, extradata, extradata_len); | |
1298 /* XXX Although the video frame is some size, the SPU frame is | |
1299 always maximum size i.e. 720 wide and 576 or 480 high */ | |
1300 // For HD files in MKV the VobSub resolution can be higher though, | |
1301 // see largeres_vobsub.mkv | |
1302 if (this->orig_frame_width <= 720 && this->orig_frame_height <= 576) { | |
1303 this->orig_frame_width = 720; | |
1304 if (this->orig_frame_height == 480 || this->orig_frame_height == 240) | |
1305 this->orig_frame_height = 480; | |
1306 else | |
1307 this->orig_frame_height = 576; | |
1308 } | |
1309 } | |
1310 else | |
1311 mp_msg(MSGT_SPUDEC,MSGL_FATAL, "FATAL: spudec_init: calloc"); | |
1312 return this; | |
1313 } | |
1314 | |
1315 void *spudec_new(unsigned int *palette) | |
1316 { | |
1317 return spudec_new_scaled(palette, 0, 0, NULL, 0); | |
1318 } | |
1319 | |
1320 void spudec_free(void *this) | |
1321 { | |
1322 spudec_handle_t *spu = this; | |
1323 if (spu) { | |
1324 while (spu->queue_head) | |
1325 spudec_free_packet(spudec_dequeue_packet(spu)); | |
1326 free(spu->packet); | |
1327 spu->packet = NULL; | |
1328 free(spu->scaled_image); | |
1329 spu->scaled_image = NULL; | |
1330 free(spu->image); | |
1331 spu->image = NULL; | |
1332 spu->aimage = NULL; | |
1333 free(spu->pal_image); | |
1334 spu->pal_image = NULL; | |
1335 spu->image_size = 0; | |
1336 spu->pal_width = spu->pal_height = 0; | |
1337 free(spu); | |
1338 } | |
1339 } | |
1340 | |
1341 void spudec_set_hw_spu(void *this, const vo_functions_t *hw_spu) | |
1342 { | |
1343 spudec_handle_t *spu = this; | |
1344 if (!spu) | |
1345 return; | |
1346 spu->hw_spu = hw_spu; | |
1347 hw_spu->control(VOCTRL_SET_SPU_PALETTE,spu->global_palette); | |
1348 } | |
1349 | |
1350 #define MP_NOPTS_VALUE (-1LL<<63) //both int64_t and double should be able to represent this exactly | |
1351 | |
34784 | 1352 packet_t *spudec_packet_create(int x, int y, int w, int h) |
32456 | 1353 { |
1354 packet_t *packet; | |
1355 int stride = (w + 7) & ~7; | |
1356 if ((unsigned)w >= 0x8000 || (unsigned)h > 0x4000) | |
34784 | 1357 return NULL; |
32456 | 1358 packet = calloc(1, sizeof(packet_t)); |
1359 packet->is_decoded = 1; | |
1360 packet->width = w; | |
1361 packet->height = h; | |
1362 packet->stride = stride; | |
1363 packet->start_col = x; | |
1364 packet->start_row = y; | |
1365 packet->data_len = 2 * stride * h; | |
1366 if (packet->data_len) { // size 0 is a special "clear" packet | |
34784 | 1367 packet->packet = malloc(packet->data_len); |
1368 if (!packet->packet) { | |
1369 free(packet); | |
1370 packet = NULL; | |
1371 } | |
32456 | 1372 } |
34784 | 1373 return packet; |
1374 } | |
1375 | |
1376 void spudec_packet_clear(packet_t *packet) | |
1377 { | |
1378 /* clear alpha and value, as value is premultiplied */ | |
1379 memset(packet->packet, 0, packet->data_len); | |
1380 } | |
1381 | |
1382 void spudec_packet_fill(packet_t *packet, | |
1383 const uint8_t *pal_img, int pal_stride, | |
1384 const void *palette, | |
1385 int x, int y, int w, int h) | |
1386 { | |
1387 const uint32_t *pal = palette; | |
1388 uint8_t *img = packet->packet + x + y * packet->stride; | |
1389 uint8_t *aimg = img + packet->stride * packet->height; | |
1390 int i; | |
1391 uint16_t g8a8_pal[256]; | |
1392 | |
1393 for (i = 0; i < 256; i++) { | |
1394 uint32_t pixel = pal[i]; | |
1395 int alpha = pixel >> 24; | |
1396 int gray = (((pixel & 0x000000ff) >> 0) + | |
1397 ((pixel & 0x0000ff00) >> 7) + | |
1398 ((pixel & 0x00ff0000) >> 16)) >> 2; | |
1399 gray = FFMIN(gray, alpha); | |
1400 g8a8_pal[i] = (-alpha << 8) | gray; | |
1401 } | |
1402 pal2gray_alpha(g8a8_pal, pal_img, pal_stride, | |
1403 img, aimg, packet->stride, w, h); | |
1404 } | |
1405 | |
1406 void spudec_packet_send(void *spu, packet_t *packet, double pts, double endpts) | |
1407 { | |
32456 | 1408 packet->start_pts = 0; |
1409 packet->end_pts = 0x7fffffff; | |
1410 if (pts != MP_NOPTS_VALUE) | |
1411 packet->start_pts = pts * 90000; | |
1412 if (endpts != MP_NOPTS_VALUE) | |
1413 packet->end_pts = endpts * 90000; | |
1414 spudec_queue_packet(spu, packet); | |
1415 } | |
34784 | 1416 |
1417 /** | |
1418 * palette must contain at least 256 32-bit entries, otherwise crashes | |
1419 * are possible | |
1420 */ | |
1421 void spudec_set_paletted(void *spu, const uint8_t *pal_img, int pal_stride, | |
1422 const void *palette, | |
1423 int x, int y, int w, int h, | |
1424 double pts, double endpts) | |
1425 { | |
1426 packet_t *packet = spudec_packet_create(x, y, w, h); | |
1427 if (!packet) | |
1428 return; | |
1429 if (packet->data_len) // size 0 is a special "clear" packet | |
1430 spudec_packet_fill(packet, pal_img, pal_stride, palette, 0, 0, w, h); | |
1431 spudec_packet_send(spu, packet, pts, endpts); | |
1432 } |