blob: 7c27d69ce27e2f0358b4e7f4eab11f118117a140
1 | /* |
2 | * DVB subtitle decoding |
3 | * Copyright (c) 2005 Ian Caulfield |
4 | * |
5 | * This file is part of FFmpeg. |
6 | * |
7 | * FFmpeg is free software; you can redistribute it and/or |
8 | * modify it under the terms of the GNU Lesser General Public |
9 | * License as published by the Free Software Foundation; either |
10 | * version 2.1 of the License, or (at your option) any later version. |
11 | * |
12 | * FFmpeg is distributed in the hope that it will be useful, |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
15 | * Lesser General Public License for more details. |
16 | * |
17 | * You should have received a copy of the GNU Lesser General Public |
18 | * License along with FFmpeg; if not, write to the Free Software |
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
20 | */ |
21 | |
22 | #include "avcodec.h" |
23 | #include "get_bits.h" |
24 | #include "bytestream.h" |
25 | #include "internal.h" |
26 | #include "libavutil/colorspace.h" |
27 | #include "libavutil/opt.h" |
28 | |
29 | #define DVBSUB_PAGE_SEGMENT 0x10 |
30 | #define DVBSUB_REGION_SEGMENT 0x11 |
31 | #define DVBSUB_CLUT_SEGMENT 0x12 |
32 | #define DVBSUB_OBJECT_SEGMENT 0x13 |
33 | #define DVBSUB_DISPLAYDEFINITION_SEGMENT 0x14 |
34 | #define DVBSUB_DISPLAY_SEGMENT 0x80 |
35 | |
36 | #define cm (ff_crop_tab + MAX_NEG_CROP) |
37 | |
38 | #ifdef DEBUG |
39 | static void png_save(const char *filename, uint32_t *bitmap, int w, int h) |
40 | { |
41 | int x, y, v; |
42 | FILE *f; |
43 | char fname[40], fname2[40]; |
44 | char command[1024]; |
45 | |
46 | snprintf(fname, sizeof(fname), "%s.ppm", filename); |
47 | |
48 | f = fopen(fname, "w"); |
49 | if (!f) { |
50 | perror(fname); |
51 | return; |
52 | } |
53 | fprintf(f, "P6\n" |
54 | "%d %d\n" |
55 | "%d\n", |
56 | w, h, 255); |
57 | for(y = 0; y < h; y++) { |
58 | for(x = 0; x < w; x++) { |
59 | v = bitmap[y * w + x]; |
60 | putc((v >> 16) & 0xff, f); |
61 | putc((v >> 8) & 0xff, f); |
62 | putc((v >> 0) & 0xff, f); |
63 | } |
64 | } |
65 | fclose(f); |
66 | |
67 | |
68 | snprintf(fname2, sizeof(fname2), "%s-a.pgm", filename); |
69 | |
70 | f = fopen(fname2, "w"); |
71 | if (!f) { |
72 | perror(fname2); |
73 | return; |
74 | } |
75 | fprintf(f, "P5\n" |
76 | "%d %d\n" |
77 | "%d\n", |
78 | w, h, 255); |
79 | for(y = 0; y < h; y++) { |
80 | for(x = 0; x < w; x++) { |
81 | v = bitmap[y * w + x]; |
82 | putc((v >> 24) & 0xff, f); |
83 | } |
84 | } |
85 | fclose(f); |
86 | |
87 | snprintf(command, sizeof(command), "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename); |
88 | system(command); |
89 | |
90 | snprintf(command, sizeof(command), "rm %s %s", fname, fname2); |
91 | system(command); |
92 | } |
93 | #endif |
94 | |
95 | #define RGBA(r,g,b,a) (((unsigned)(a) << 24) | ((r) << 16) | ((g) << 8) | (b)) |
96 | |
97 | typedef struct DVBSubCLUT { |
98 | int id; |
99 | int version; |
100 | |
101 | uint32_t clut4[4]; |
102 | uint32_t clut16[16]; |
103 | uint32_t clut256[256]; |
104 | |
105 | struct DVBSubCLUT *next; |
106 | } DVBSubCLUT; |
107 | |
108 | static DVBSubCLUT default_clut; |
109 | |
110 | typedef struct DVBSubObjectDisplay { |
111 | int object_id; |
112 | int region_id; |
113 | |
114 | int x_pos; |
115 | int y_pos; |
116 | |
117 | int fgcolor; |
118 | int bgcolor; |
119 | |
120 | struct DVBSubObjectDisplay *region_list_next; |
121 | struct DVBSubObjectDisplay *object_list_next; |
122 | } DVBSubObjectDisplay; |
123 | |
124 | typedef struct DVBSubObject { |
125 | int id; |
126 | int version; |
127 | |
128 | int type; |
129 | |
130 | DVBSubObjectDisplay *display_list; |
131 | |
132 | struct DVBSubObject *next; |
133 | } DVBSubObject; |
134 | |
135 | typedef struct DVBSubRegionDisplay { |
136 | int region_id; |
137 | |
138 | int x_pos; |
139 | int y_pos; |
140 | |
141 | struct DVBSubRegionDisplay *next; |
142 | } DVBSubRegionDisplay; |
143 | |
144 | typedef struct DVBSubRegion { |
145 | int id; |
146 | int version; |
147 | |
148 | int width; |
149 | int height; |
150 | int depth; |
151 | |
152 | int clut; |
153 | int bgcolor; |
154 | |
155 | uint8_t *pbuf; |
156 | int buf_size; |
157 | int dirty; |
158 | |
159 | DVBSubObjectDisplay *display_list; |
160 | |
161 | struct DVBSubRegion *next; |
162 | } DVBSubRegion; |
163 | |
164 | typedef struct DVBSubDisplayDefinition { |
165 | int version; |
166 | |
167 | int x; |
168 | int y; |
169 | int width; |
170 | int height; |
171 | } DVBSubDisplayDefinition; |
172 | |
173 | typedef struct DVBSubContext { |
174 | AVClass *class; |
175 | int composition_id; |
176 | int ancillary_id; |
177 | |
178 | int version; |
179 | int time_out; |
180 | int compute_edt; /**< if 1 end display time calculated using pts |
181 | if 0 (Default) calculated using time out */ |
182 | int compute_clut; |
183 | int substream; |
184 | int64_t prev_start; |
185 | DVBSubRegion *region_list; |
186 | DVBSubCLUT *clut_list; |
187 | DVBSubObject *object_list; |
188 | |
189 | DVBSubRegionDisplay *display_list; |
190 | DVBSubDisplayDefinition *display_definition; |
191 | } DVBSubContext; |
192 | |
193 | |
194 | static DVBSubObject* get_object(DVBSubContext *ctx, int object_id) |
195 | { |
196 | DVBSubObject *ptr = ctx->object_list; |
197 | |
198 | while (ptr && ptr->id != object_id) { |
199 | ptr = ptr->next; |
200 | } |
201 | |
202 | return ptr; |
203 | } |
204 | |
205 | static DVBSubCLUT* get_clut(DVBSubContext *ctx, int clut_id) |
206 | { |
207 | DVBSubCLUT *ptr = ctx->clut_list; |
208 | |
209 | while (ptr && ptr->id != clut_id) { |
210 | ptr = ptr->next; |
211 | } |
212 | |
213 | return ptr; |
214 | } |
215 | |
216 | static DVBSubRegion* get_region(DVBSubContext *ctx, int region_id) |
217 | { |
218 | DVBSubRegion *ptr = ctx->region_list; |
219 | |
220 | while (ptr && ptr->id != region_id) { |
221 | ptr = ptr->next; |
222 | } |
223 | |
224 | return ptr; |
225 | } |
226 | |
227 | static void delete_region_display_list(DVBSubContext *ctx, DVBSubRegion *region) |
228 | { |
229 | DVBSubObject *object, *obj2, **obj2_ptr; |
230 | DVBSubObjectDisplay *display, *obj_disp, **obj_disp_ptr; |
231 | |
232 | while (region->display_list) { |
233 | display = region->display_list; |
234 | |
235 | object = get_object(ctx, display->object_id); |
236 | |
237 | if (object) { |
238 | obj_disp_ptr = &object->display_list; |
239 | obj_disp = *obj_disp_ptr; |
240 | |
241 | while (obj_disp && obj_disp != display) { |
242 | obj_disp_ptr = &obj_disp->object_list_next; |
243 | obj_disp = *obj_disp_ptr; |
244 | } |
245 | |
246 | if (obj_disp) { |
247 | *obj_disp_ptr = obj_disp->object_list_next; |
248 | |
249 | if (!object->display_list) { |
250 | obj2_ptr = &ctx->object_list; |
251 | obj2 = *obj2_ptr; |
252 | |
253 | while (obj2 != object) { |
254 | av_assert0(obj2); |
255 | obj2_ptr = &obj2->next; |
256 | obj2 = *obj2_ptr; |
257 | } |
258 | |
259 | *obj2_ptr = obj2->next; |
260 | |
261 | av_freep(&obj2); |
262 | } |
263 | } |
264 | } |
265 | |
266 | region->display_list = display->region_list_next; |
267 | |
268 | av_freep(&display); |
269 | } |
270 | |
271 | } |
272 | |
273 | static void delete_cluts(DVBSubContext *ctx) |
274 | { |
275 | while (ctx->clut_list) { |
276 | DVBSubCLUT *clut = ctx->clut_list; |
277 | |
278 | ctx->clut_list = clut->next; |
279 | |
280 | av_freep(&clut); |
281 | } |
282 | } |
283 | |
284 | static void delete_objects(DVBSubContext *ctx) |
285 | { |
286 | while (ctx->object_list) { |
287 | DVBSubObject *object = ctx->object_list; |
288 | |
289 | ctx->object_list = object->next; |
290 | |
291 | av_freep(&object); |
292 | } |
293 | } |
294 | |
295 | static void delete_regions(DVBSubContext *ctx) |
296 | { |
297 | while (ctx->region_list) { |
298 | DVBSubRegion *region = ctx->region_list; |
299 | |
300 | ctx->region_list = region->next; |
301 | |
302 | delete_region_display_list(ctx, region); |
303 | |
304 | av_freep(®ion->pbuf); |
305 | av_freep(®ion); |
306 | } |
307 | } |
308 | |
309 | static av_cold int dvbsub_init_decoder(AVCodecContext *avctx) |
310 | { |
311 | int i, r, g, b, a = 0; |
312 | DVBSubContext *ctx = avctx->priv_data; |
313 | |
314 | if (ctx->substream < 0) { |
315 | ctx->composition_id = -1; |
316 | ctx->ancillary_id = -1; |
317 | } else if (!avctx->extradata || (avctx->extradata_size < 4) || ((avctx->extradata_size % 5 != 0) && (avctx->extradata_size != 4))) { |
318 | av_log(avctx, AV_LOG_WARNING, "Invalid DVB subtitles stream extradata!\n"); |
319 | ctx->composition_id = -1; |
320 | ctx->ancillary_id = -1; |
321 | } else { |
322 | if (avctx->extradata_size > 5*ctx->substream + 2) { |
323 | ctx->composition_id = AV_RB16(avctx->extradata + 5*ctx->substream); |
324 | ctx->ancillary_id = AV_RB16(avctx->extradata + 5*ctx->substream + 2); |
325 | } else { |
326 | av_log(avctx, AV_LOG_WARNING, "Selected DVB subtitles sub-stream %d is not available\n", ctx->substream); |
327 | ctx->composition_id = AV_RB16(avctx->extradata); |
328 | ctx->ancillary_id = AV_RB16(avctx->extradata + 2); |
329 | } |
330 | } |
331 | |
332 | ctx->version = -1; |
333 | ctx->prev_start = AV_NOPTS_VALUE; |
334 | |
335 | default_clut.id = -1; |
336 | default_clut.next = NULL; |
337 | |
338 | default_clut.clut4[0] = RGBA( 0, 0, 0, 0); |
339 | default_clut.clut4[1] = RGBA(255, 255, 255, 255); |
340 | default_clut.clut4[2] = RGBA( 0, 0, 0, 255); |
341 | default_clut.clut4[3] = RGBA(127, 127, 127, 255); |
342 | |
343 | default_clut.clut16[0] = RGBA( 0, 0, 0, 0); |
344 | for (i = 1; i < 16; i++) { |
345 | if (i < 8) { |
346 | r = (i & 1) ? 255 : 0; |
347 | g = (i & 2) ? 255 : 0; |
348 | b = (i & 4) ? 255 : 0; |
349 | } else { |
350 | r = (i & 1) ? 127 : 0; |
351 | g = (i & 2) ? 127 : 0; |
352 | b = (i & 4) ? 127 : 0; |
353 | } |
354 | default_clut.clut16[i] = RGBA(r, g, b, 255); |
355 | } |
356 | |
357 | default_clut.clut256[0] = RGBA( 0, 0, 0, 0); |
358 | for (i = 1; i < 256; i++) { |
359 | if (i < 8) { |
360 | r = (i & 1) ? 255 : 0; |
361 | g = (i & 2) ? 255 : 0; |
362 | b = (i & 4) ? 255 : 0; |
363 | a = 63; |
364 | } else { |
365 | switch (i & 0x88) { |
366 | case 0x00: |
367 | r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0); |
368 | g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0); |
369 | b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0); |
370 | a = 255; |
371 | break; |
372 | case 0x08: |
373 | r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0); |
374 | g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0); |
375 | b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0); |
376 | a = 127; |
377 | break; |
378 | case 0x80: |
379 | r = 127 + ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0); |
380 | g = 127 + ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0); |
381 | b = 127 + ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0); |
382 | a = 255; |
383 | break; |
384 | case 0x88: |
385 | r = ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0); |
386 | g = ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0); |
387 | b = ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0); |
388 | a = 255; |
389 | break; |
390 | } |
391 | } |
392 | default_clut.clut256[i] = RGBA(r, g, b, a); |
393 | } |
394 | |
395 | return 0; |
396 | } |
397 | |
398 | static av_cold int dvbsub_close_decoder(AVCodecContext *avctx) |
399 | { |
400 | DVBSubContext *ctx = avctx->priv_data; |
401 | DVBSubRegionDisplay *display; |
402 | |
403 | delete_regions(ctx); |
404 | |
405 | delete_objects(ctx); |
406 | |
407 | delete_cluts(ctx); |
408 | |
409 | av_freep(&ctx->display_definition); |
410 | |
411 | while (ctx->display_list) { |
412 | display = ctx->display_list; |
413 | ctx->display_list = display->next; |
414 | |
415 | av_freep(&display); |
416 | } |
417 | |
418 | return 0; |
419 | } |
420 | |
421 | static int dvbsub_read_2bit_string(AVCodecContext *avctx, |
422 | uint8_t *destbuf, int dbuf_len, |
423 | const uint8_t **srcbuf, int buf_size, |
424 | int non_mod, uint8_t *map_table, int x_pos) |
425 | { |
426 | GetBitContext gb; |
427 | |
428 | int bits; |
429 | int run_length; |
430 | int pixels_read = x_pos; |
431 | |
432 | init_get_bits(&gb, *srcbuf, buf_size << 3); |
433 | |
434 | destbuf += x_pos; |
435 | |
436 | while (get_bits_count(&gb) < buf_size << 3 && pixels_read < dbuf_len) { |
437 | bits = get_bits(&gb, 2); |
438 | |
439 | if (bits) { |
440 | if (non_mod != 1 || bits != 1) { |
441 | if (map_table) |
442 | *destbuf++ = map_table[bits]; |
443 | else |
444 | *destbuf++ = bits; |
445 | } |
446 | pixels_read++; |
447 | } else { |
448 | bits = get_bits1(&gb); |
449 | if (bits == 1) { |
450 | run_length = get_bits(&gb, 3) + 3; |
451 | bits = get_bits(&gb, 2); |
452 | |
453 | if (non_mod == 1 && bits == 1) |
454 | pixels_read += run_length; |
455 | else { |
456 | if (map_table) |
457 | bits = map_table[bits]; |
458 | while (run_length-- > 0 && pixels_read < dbuf_len) { |
459 | *destbuf++ = bits; |
460 | pixels_read++; |
461 | } |
462 | } |
463 | } else { |
464 | bits = get_bits1(&gb); |
465 | if (bits == 0) { |
466 | bits = get_bits(&gb, 2); |
467 | if (bits == 2) { |
468 | run_length = get_bits(&gb, 4) + 12; |
469 | bits = get_bits(&gb, 2); |
470 | |
471 | if (non_mod == 1 && bits == 1) |
472 | pixels_read += run_length; |
473 | else { |
474 | if (map_table) |
475 | bits = map_table[bits]; |
476 | while (run_length-- > 0 && pixels_read < dbuf_len) { |
477 | *destbuf++ = bits; |
478 | pixels_read++; |
479 | } |
480 | } |
481 | } else if (bits == 3) { |
482 | run_length = get_bits(&gb, 8) + 29; |
483 | bits = get_bits(&gb, 2); |
484 | |
485 | if (non_mod == 1 && bits == 1) |
486 | pixels_read += run_length; |
487 | else { |
488 | if (map_table) |
489 | bits = map_table[bits]; |
490 | while (run_length-- > 0 && pixels_read < dbuf_len) { |
491 | *destbuf++ = bits; |
492 | pixels_read++; |
493 | } |
494 | } |
495 | } else if (bits == 1) { |
496 | if (map_table) |
497 | bits = map_table[0]; |
498 | else |
499 | bits = 0; |
500 | run_length = 2; |
501 | while (run_length-- > 0 && pixels_read < dbuf_len) { |
502 | *destbuf++ = bits; |
503 | pixels_read++; |
504 | } |
505 | } else { |
506 | (*srcbuf) += (get_bits_count(&gb) + 7) >> 3; |
507 | return pixels_read; |
508 | } |
509 | } else { |
510 | if (map_table) |
511 | bits = map_table[0]; |
512 | else |
513 | bits = 0; |
514 | *destbuf++ = bits; |
515 | pixels_read++; |
516 | } |
517 | } |
518 | } |
519 | } |
520 | |
521 | if (get_bits(&gb, 6)) |
522 | av_log(avctx, AV_LOG_ERROR, "line overflow\n"); |
523 | |
524 | (*srcbuf) += (get_bits_count(&gb) + 7) >> 3; |
525 | |
526 | return pixels_read; |
527 | } |
528 | |
529 | static int dvbsub_read_4bit_string(AVCodecContext *avctx, uint8_t *destbuf, int dbuf_len, |
530 | const uint8_t **srcbuf, int buf_size, |
531 | int non_mod, uint8_t *map_table, int x_pos) |
532 | { |
533 | GetBitContext gb; |
534 | |
535 | int bits; |
536 | int run_length; |
537 | int pixels_read = x_pos; |
538 | |
539 | init_get_bits(&gb, *srcbuf, buf_size << 3); |
540 | |
541 | destbuf += x_pos; |
542 | |
543 | while (get_bits_count(&gb) < buf_size << 3 && pixels_read < dbuf_len) { |
544 | bits = get_bits(&gb, 4); |
545 | |
546 | if (bits) { |
547 | if (non_mod != 1 || bits != 1) { |
548 | if (map_table) |
549 | *destbuf++ = map_table[bits]; |
550 | else |
551 | *destbuf++ = bits; |
552 | } |
553 | pixels_read++; |
554 | } else { |
555 | bits = get_bits1(&gb); |
556 | if (bits == 0) { |
557 | run_length = get_bits(&gb, 3); |
558 | |
559 | if (run_length == 0) { |
560 | (*srcbuf) += (get_bits_count(&gb) + 7) >> 3; |
561 | return pixels_read; |
562 | } |
563 | |
564 | run_length += 2; |
565 | |
566 | if (map_table) |
567 | bits = map_table[0]; |
568 | else |
569 | bits = 0; |
570 | |
571 | while (run_length-- > 0 && pixels_read < dbuf_len) { |
572 | *destbuf++ = bits; |
573 | pixels_read++; |
574 | } |
575 | } else { |
576 | bits = get_bits1(&gb); |
577 | if (bits == 0) { |
578 | run_length = get_bits(&gb, 2) + 4; |
579 | bits = get_bits(&gb, 4); |
580 | |
581 | if (non_mod == 1 && bits == 1) |
582 | pixels_read += run_length; |
583 | else { |
584 | if (map_table) |
585 | bits = map_table[bits]; |
586 | while (run_length-- > 0 && pixels_read < dbuf_len) { |
587 | *destbuf++ = bits; |
588 | pixels_read++; |
589 | } |
590 | } |
591 | } else { |
592 | bits = get_bits(&gb, 2); |
593 | if (bits == 2) { |
594 | run_length = get_bits(&gb, 4) + 9; |
595 | bits = get_bits(&gb, 4); |
596 | |
597 | if (non_mod == 1 && bits == 1) |
598 | pixels_read += run_length; |
599 | else { |
600 | if (map_table) |
601 | bits = map_table[bits]; |
602 | while (run_length-- > 0 && pixels_read < dbuf_len) { |
603 | *destbuf++ = bits; |
604 | pixels_read++; |
605 | } |
606 | } |
607 | } else if (bits == 3) { |
608 | run_length = get_bits(&gb, 8) + 25; |
609 | bits = get_bits(&gb, 4); |
610 | |
611 | if (non_mod == 1 && bits == 1) |
612 | pixels_read += run_length; |
613 | else { |
614 | if (map_table) |
615 | bits = map_table[bits]; |
616 | while (run_length-- > 0 && pixels_read < dbuf_len) { |
617 | *destbuf++ = bits; |
618 | pixels_read++; |
619 | } |
620 | } |
621 | } else if (bits == 1) { |
622 | if (map_table) |
623 | bits = map_table[0]; |
624 | else |
625 | bits = 0; |
626 | run_length = 2; |
627 | while (run_length-- > 0 && pixels_read < dbuf_len) { |
628 | *destbuf++ = bits; |
629 | pixels_read++; |
630 | } |
631 | } else { |
632 | if (map_table) |
633 | bits = map_table[0]; |
634 | else |
635 | bits = 0; |
636 | *destbuf++ = bits; |
637 | pixels_read ++; |
638 | } |
639 | } |
640 | } |
641 | } |
642 | } |
643 | |
644 | if (get_bits(&gb, 8)) |
645 | av_log(avctx, AV_LOG_ERROR, "line overflow\n"); |
646 | |
647 | (*srcbuf) += (get_bits_count(&gb) + 7) >> 3; |
648 | |
649 | return pixels_read; |
650 | } |
651 | |
652 | static int dvbsub_read_8bit_string(AVCodecContext *avctx, |
653 | uint8_t *destbuf, int dbuf_len, |
654 | const uint8_t **srcbuf, int buf_size, |
655 | int non_mod, uint8_t *map_table, int x_pos) |
656 | { |
657 | const uint8_t *sbuf_end = (*srcbuf) + buf_size; |
658 | int bits; |
659 | int run_length; |
660 | int pixels_read = x_pos; |
661 | |
662 | destbuf += x_pos; |
663 | |
664 | while (*srcbuf < sbuf_end && pixels_read < dbuf_len) { |
665 | bits = *(*srcbuf)++; |
666 | |
667 | if (bits) { |
668 | if (non_mod != 1 || bits != 1) { |
669 | if (map_table) |
670 | *destbuf++ = map_table[bits]; |
671 | else |
672 | *destbuf++ = bits; |
673 | } |
674 | pixels_read++; |
675 | } else { |
676 | bits = *(*srcbuf)++; |
677 | run_length = bits & 0x7f; |
678 | if ((bits & 0x80) == 0) { |
679 | if (run_length == 0) { |
680 | return pixels_read; |
681 | } |
682 | |
683 | bits = 0; |
684 | } else { |
685 | bits = *(*srcbuf)++; |
686 | } |
687 | if (non_mod == 1 && bits == 1) |
688 | pixels_read += run_length; |
689 | else { |
690 | if (map_table) |
691 | bits = map_table[bits]; |
692 | while (run_length-- > 0 && pixels_read < dbuf_len) { |
693 | *destbuf++ = bits; |
694 | pixels_read++; |
695 | } |
696 | } |
697 | } |
698 | } |
699 | |
700 | if (*(*srcbuf)++) |
701 | av_log(avctx, AV_LOG_ERROR, "line overflow\n"); |
702 | |
703 | return pixels_read; |
704 | } |
705 | |
706 | static void compute_default_clut(AVSubtitleRect *rect, int w, int h) |
707 | { |
708 | uint8_t list[256] = {0}; |
709 | uint8_t list_inv[256]; |
710 | int counttab[256] = {0}; |
711 | int count, i, x, y; |
712 | |
713 | #define V(x,y) rect->data[0][(x) + (y)*rect->linesize[0]] |
714 | for (y = 0; y<h; y++) { |
715 | for (x = 0; x<w; x++) { |
716 | int v = V(x,y) + 1; |
717 | int vl = x ? V(x-1,y) + 1 : 0; |
718 | int vr = x+1<w ? V(x+1,y) + 1 : 0; |
719 | int vt = y ? V(x,y-1) + 1 : 0; |
720 | int vb = y+1<h ? V(x,y+1) + 1 : 0; |
721 | counttab[v-1] += !!((v!=vl) + (v!=vr) + (v!=vt) + (v!=vb)); |
722 | } |
723 | } |
724 | #define L(x,y) list[ rect->data[0][(x) + (y)*rect->linesize[0]] ] |
725 | |
726 | for (i = 0; i<256; i++) { |
727 | int scoretab[256] = {0}; |
728 | int bestscore = 0; |
729 | int bestv = 0; |
730 | for (y = 0; y<h; y++) { |
731 | for (x = 0; x<w; x++) { |
732 | int v = rect->data[0][x + y*rect->linesize[0]]; |
733 | int l_m = list[v]; |
734 | int l_l = x ? L(x-1, y) : 1; |
735 | int l_r = x+1<w ? L(x+1, y) : 1; |
736 | int l_t = y ? L(x, y-1) : 1; |
737 | int l_b = y+1<h ? L(x, y+1) : 1; |
738 | int score; |
739 | if (l_m) |
740 | continue; |
741 | scoretab[v] += l_l + l_r + l_t + l_b; |
742 | score = 1024LL*scoretab[v] / counttab[v]; |
743 | if (score > bestscore) { |
744 | bestscore = score; |
745 | bestv = v; |
746 | } |
747 | } |
748 | } |
749 | if (!bestscore) |
750 | break; |
751 | list [ bestv ] = 1; |
752 | list_inv[ i ] = bestv; |
753 | } |
754 | |
755 | count = FFMAX(i - 1, 1); |
756 | for (i--; i>=0; i--) { |
757 | int v = i*255/count; |
758 | AV_WN32(rect->data[1] + 4*list_inv[i], RGBA(v/2,v,v/2,v)); |
759 | } |
760 | } |
761 | |
762 | |
763 | static int save_subtitle_set(AVCodecContext *avctx, AVSubtitle *sub, int *got_output) |
764 | { |
765 | DVBSubContext *ctx = avctx->priv_data; |
766 | DVBSubRegionDisplay *display; |
767 | DVBSubDisplayDefinition *display_def = ctx->display_definition; |
768 | DVBSubRegion *region; |
769 | AVSubtitleRect *rect; |
770 | DVBSubCLUT *clut; |
771 | uint32_t *clut_table; |
772 | int i; |
773 | int offset_x=0, offset_y=0; |
774 | int ret = 0; |
775 | |
776 | |
777 | if (display_def) { |
778 | offset_x = display_def->x; |
779 | offset_y = display_def->y; |
780 | } |
781 | |
782 | /* Not touching AVSubtitles again*/ |
783 | if(sub->num_rects) { |
784 | avpriv_request_sample(ctx, "Different Version of Segment asked Twice"); |
785 | return AVERROR_PATCHWELCOME; |
786 | } |
787 | for (display = ctx->display_list; display; display = display->next) { |
788 | region = get_region(ctx, display->region_id); |
789 | if (region && region->dirty) |
790 | sub->num_rects++; |
791 | } |
792 | |
793 | if(ctx->compute_edt == 0) { |
794 | sub->end_display_time = ctx->time_out * 1000; |
795 | *got_output = 1; |
796 | } else if (ctx->prev_start != AV_NOPTS_VALUE) { |
797 | sub->end_display_time = av_rescale_q((sub->pts - ctx->prev_start ), AV_TIME_BASE_Q, (AVRational){ 1, 1000 }) - 1; |
798 | *got_output = 1; |
799 | } |
800 | if (sub->num_rects > 0) { |
801 | |
802 | sub->rects = av_mallocz_array(sizeof(*sub->rects), sub->num_rects); |
803 | if (!sub->rects) { |
804 | ret = AVERROR(ENOMEM); |
805 | goto fail; |
806 | } |
807 | |
808 | for(i=0; i<sub->num_rects; i++) |
809 | sub->rects[i] = av_mallocz(sizeof(*sub->rects[i])); |
810 | |
811 | i = 0; |
812 | |
813 | for (display = ctx->display_list; display; display = display->next) { |
814 | region = get_region(ctx, display->region_id); |
815 | |
816 | if (!region) |
817 | continue; |
818 | |
819 | if (!region->dirty) |
820 | continue; |
821 | |
822 | rect = sub->rects[i]; |
823 | rect->x = display->x_pos + offset_x; |
824 | rect->y = display->y_pos + offset_y; |
825 | rect->w = region->width; |
826 | rect->h = region->height; |
827 | rect->nb_colors = (1 << region->depth); |
828 | rect->type = SUBTITLE_BITMAP; |
829 | rect->linesize[0] = region->width; |
830 | |
831 | clut = get_clut(ctx, region->clut); |
832 | |
833 | if (!clut) |
834 | clut = &default_clut; |
835 | |
836 | switch (region->depth) { |
837 | case 2: |
838 | clut_table = clut->clut4; |
839 | break; |
840 | case 8: |
841 | clut_table = clut->clut256; |
842 | break; |
843 | case 4: |
844 | default: |
845 | clut_table = clut->clut16; |
846 | break; |
847 | } |
848 | |
849 | rect->data[1] = av_mallocz(AVPALETTE_SIZE); |
850 | if (!rect->data[1]) { |
851 | ret = AVERROR(ENOMEM); |
852 | goto fail; |
853 | } |
854 | memcpy(rect->data[1], clut_table, (1 << region->depth) * sizeof(uint32_t)); |
855 | |
856 | rect->data[0] = av_malloc(region->buf_size); |
857 | if (!rect->data[0]) { |
858 | ret = AVERROR(ENOMEM); |
859 | goto fail; |
860 | } |
861 | |
862 | memcpy(rect->data[0], region->pbuf, region->buf_size); |
863 | |
864 | if ((clut == &default_clut && ctx->compute_clut == -1) || ctx->compute_clut == 1) |
865 | compute_default_clut(rect, rect->w, rect->h); |
866 | |
867 | #if FF_API_AVPICTURE |
868 | FF_DISABLE_DEPRECATION_WARNINGS |
869 | { |
870 | int j; |
871 | for (j = 0; j < 4; j++) { |
872 | rect->pict.data[j] = rect->data[j]; |
873 | rect->pict.linesize[j] = rect->linesize[j]; |
874 | } |
875 | } |
876 | FF_ENABLE_DEPRECATION_WARNINGS |
877 | #endif |
878 | |
879 | i++; |
880 | } |
881 | } |
882 | |
883 | return 0; |
884 | fail: |
885 | if (sub->rects) { |
886 | for(i=0; i<sub->num_rects; i++) { |
887 | rect = sub->rects[i]; |
888 | if (rect) { |
889 | av_freep(&rect->data[0]); |
890 | av_freep(&rect->data[1]); |
891 | } |
892 | av_freep(&sub->rects[i]); |
893 | } |
894 | av_freep(&sub->rects); |
895 | } |
896 | sub->num_rects = 0; |
897 | return ret; |
898 | } |
899 | |
900 | static void dvbsub_parse_pixel_data_block(AVCodecContext *avctx, DVBSubObjectDisplay *display, |
901 | const uint8_t *buf, int buf_size, int top_bottom, int non_mod) |
902 | { |
903 | DVBSubContext *ctx = avctx->priv_data; |
904 | |
905 | DVBSubRegion *region = get_region(ctx, display->region_id); |
906 | const uint8_t *buf_end = buf + buf_size; |
907 | uint8_t *pbuf; |
908 | int x_pos, y_pos; |
909 | int i; |
910 | |
911 | uint8_t map2to4[] = { 0x0, 0x7, 0x8, 0xf}; |
912 | uint8_t map2to8[] = {0x00, 0x77, 0x88, 0xff}; |
913 | uint8_t map4to8[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, |
914 | 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}; |
915 | uint8_t *map_table; |
916 | |
917 | #if 0 |
918 | ff_dlog(avctx, "DVB pixel block size %d, %s field:\n", buf_size, |
919 | top_bottom ? "bottom" : "top"); |
920 | |
921 | for (i = 0; i < buf_size; i++) { |
922 | if (i % 16 == 0) |
923 | ff_dlog(avctx, "0x%8p: ", buf+i); |
924 | |
925 | ff_dlog(avctx, "%02x ", buf[i]); |
926 | if (i % 16 == 15) |
927 | ff_dlog(avctx, "\n"); |
928 | } |
929 | |
930 | if (i % 16) |
931 | ff_dlog(avctx, "\n"); |
932 | #endif |
933 | |
934 | if (!region) |
935 | return; |
936 | |
937 | pbuf = region->pbuf; |
938 | region->dirty = 1; |
939 | |
940 | x_pos = display->x_pos; |
941 | y_pos = display->y_pos; |
942 | |
943 | y_pos += top_bottom; |
944 | |
945 | while (buf < buf_end) { |
946 | if ((*buf!=0xf0 && x_pos >= region->width) || y_pos >= region->height) { |
947 | av_log(avctx, AV_LOG_ERROR, "Invalid object location! %d-%d %d-%d %02x\n", x_pos, region->width, y_pos, region->height, *buf); |
948 | return; |
949 | } |
950 | |
951 | switch (*buf++) { |
952 | case 0x10: |
953 | if (region->depth == 8) |
954 | map_table = map2to8; |
955 | else if (region->depth == 4) |
956 | map_table = map2to4; |
957 | else |
958 | map_table = NULL; |
959 | |
960 | x_pos = dvbsub_read_2bit_string(avctx, pbuf + (y_pos * region->width), |
961 | region->width, &buf, buf_end - buf, |
962 | non_mod, map_table, x_pos); |
963 | break; |
964 | case 0x11: |
965 | if (region->depth < 4) { |
966 | av_log(avctx, AV_LOG_ERROR, "4-bit pixel string in %d-bit region!\n", region->depth); |
967 | return; |
968 | } |
969 | |
970 | if (region->depth == 8) |
971 | map_table = map4to8; |
972 | else |
973 | map_table = NULL; |
974 | |
975 | x_pos = dvbsub_read_4bit_string(avctx, pbuf + (y_pos * region->width), |
976 | region->width, &buf, buf_end - buf, |
977 | non_mod, map_table, x_pos); |
978 | break; |
979 | case 0x12: |
980 | if (region->depth < 8) { |
981 | av_log(avctx, AV_LOG_ERROR, "8-bit pixel string in %d-bit region!\n", region->depth); |
982 | return; |
983 | } |
984 | |
985 | x_pos = dvbsub_read_8bit_string(avctx, pbuf + (y_pos * region->width), |
986 | region->width, &buf, buf_end - buf, |
987 | non_mod, NULL, x_pos); |
988 | break; |
989 | |
990 | case 0x20: |
991 | map2to4[0] = (*buf) >> 4; |
992 | map2to4[1] = (*buf++) & 0xf; |
993 | map2to4[2] = (*buf) >> 4; |
994 | map2to4[3] = (*buf++) & 0xf; |
995 | break; |
996 | case 0x21: |
997 | for (i = 0; i < 4; i++) |
998 | map2to8[i] = *buf++; |
999 | break; |
1000 | case 0x22: |
1001 | for (i = 0; i < 16; i++) |
1002 | map4to8[i] = *buf++; |
1003 | break; |
1004 | |
1005 | case 0xf0: |
1006 | x_pos = display->x_pos; |
1007 | y_pos += 2; |
1008 | break; |
1009 | default: |
1010 | av_log(avctx, AV_LOG_INFO, "Unknown/unsupported pixel block 0x%x\n", *(buf-1)); |
1011 | } |
1012 | } |
1013 | |
1014 | } |
1015 | |
1016 | static int dvbsub_parse_object_segment(AVCodecContext *avctx, |
1017 | const uint8_t *buf, int buf_size) |
1018 | { |
1019 | DVBSubContext *ctx = avctx->priv_data; |
1020 | |
1021 | const uint8_t *buf_end = buf + buf_size; |
1022 | int object_id; |
1023 | DVBSubObject *object; |
1024 | DVBSubObjectDisplay *display; |
1025 | int top_field_len, bottom_field_len; |
1026 | |
1027 | int coding_method, non_modifying_color; |
1028 | |
1029 | object_id = AV_RB16(buf); |
1030 | buf += 2; |
1031 | |
1032 | object = get_object(ctx, object_id); |
1033 | |
1034 | if (!object) |
1035 | return AVERROR_INVALIDDATA; |
1036 | |
1037 | coding_method = ((*buf) >> 2) & 3; |
1038 | non_modifying_color = ((*buf++) >> 1) & 1; |
1039 | |
1040 | if (coding_method == 0) { |
1041 | top_field_len = AV_RB16(buf); |
1042 | buf += 2; |
1043 | bottom_field_len = AV_RB16(buf); |
1044 | buf += 2; |
1045 | |
1046 | if (buf + top_field_len + bottom_field_len > buf_end) { |
1047 | av_log(avctx, AV_LOG_ERROR, "Field data size %d+%d too large\n", top_field_len, bottom_field_len); |
1048 | return AVERROR_INVALIDDATA; |
1049 | } |
1050 | |
1051 | for (display = object->display_list; display; display = display->object_list_next) { |
1052 | const uint8_t *block = buf; |
1053 | int bfl = bottom_field_len; |
1054 | |
1055 | dvbsub_parse_pixel_data_block(avctx, display, block, top_field_len, 0, |
1056 | non_modifying_color); |
1057 | |
1058 | if (bottom_field_len > 0) |
1059 | block = buf + top_field_len; |
1060 | else |
1061 | bfl = top_field_len; |
1062 | |
1063 | dvbsub_parse_pixel_data_block(avctx, display, block, bfl, 1, |
1064 | non_modifying_color); |
1065 | } |
1066 | |
1067 | /* } else if (coding_method == 1) {*/ |
1068 | |
1069 | } else { |
1070 | av_log(avctx, AV_LOG_ERROR, "Unknown object coding %d\n", coding_method); |
1071 | } |
1072 | |
1073 | return 0; |
1074 | } |
1075 | |
1076 | static int dvbsub_parse_clut_segment(AVCodecContext *avctx, |
1077 | const uint8_t *buf, int buf_size) |
1078 | { |
1079 | DVBSubContext *ctx = avctx->priv_data; |
1080 | |
1081 | const uint8_t *buf_end = buf + buf_size; |
1082 | int i, clut_id; |
1083 | int version; |
1084 | DVBSubCLUT *clut; |
1085 | int entry_id, depth , full_range; |
1086 | int y, cr, cb, alpha; |
1087 | int r, g, b, r_add, g_add, b_add; |
1088 | |
1089 | ff_dlog(avctx, "DVB clut packet:\n"); |
1090 | |
1091 | for (i=0; i < buf_size; i++) { |
1092 | ff_dlog(avctx, "%02x ", buf[i]); |
1093 | if (i % 16 == 15) |
1094 | ff_dlog(avctx, "\n"); |
1095 | } |
1096 | |
1097 | if (i % 16) |
1098 | ff_dlog(avctx, "\n"); |
1099 | |
1100 | clut_id = *buf++; |
1101 | version = ((*buf)>>4)&15; |
1102 | buf += 1; |
1103 | |
1104 | clut = get_clut(ctx, clut_id); |
1105 | |
1106 | if (!clut) { |
1107 | clut = av_malloc(sizeof(DVBSubCLUT)); |
1108 | if (!clut) |
1109 | return AVERROR(ENOMEM); |
1110 | |
1111 | memcpy(clut, &default_clut, sizeof(DVBSubCLUT)); |
1112 | |
1113 | clut->id = clut_id; |
1114 | clut->version = -1; |
1115 | |
1116 | clut->next = ctx->clut_list; |
1117 | ctx->clut_list = clut; |
1118 | } |
1119 | |
1120 | if (clut->version != version) { |
1121 | |
1122 | clut->version = version; |
1123 | |
1124 | while (buf + 4 < buf_end) { |
1125 | entry_id = *buf++; |
1126 | |
1127 | depth = (*buf) & 0xe0; |
1128 | |
1129 | if (depth == 0) { |
1130 | av_log(avctx, AV_LOG_ERROR, "Invalid clut depth 0x%x!\n", *buf); |
1131 | } |
1132 | |
1133 | full_range = (*buf++) & 1; |
1134 | |
1135 | if (full_range) { |
1136 | y = *buf++; |
1137 | cr = *buf++; |
1138 | cb = *buf++; |
1139 | alpha = *buf++; |
1140 | } else { |
1141 | y = buf[0] & 0xfc; |
1142 | cr = (((buf[0] & 3) << 2) | ((buf[1] >> 6) & 3)) << 4; |
1143 | cb = (buf[1] << 2) & 0xf0; |
1144 | alpha = (buf[1] << 6) & 0xc0; |
1145 | |
1146 | buf += 2; |
1147 | } |
1148 | |
1149 | if (y == 0) |
1150 | alpha = 0xff; |
1151 | |
1152 | YUV_TO_RGB1_CCIR(cb, cr); |
1153 | YUV_TO_RGB2_CCIR(r, g, b, y); |
1154 | |
1155 | ff_dlog(avctx, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha); |
1156 | if (!!(depth & 0x80) + !!(depth & 0x40) + !!(depth & 0x20) > 1) { |
1157 | ff_dlog(avctx, "More than one bit level marked: %x\n", depth); |
1158 | if (avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL) |
1159 | return AVERROR_INVALIDDATA; |
1160 | } |
1161 | |
1162 | if (depth & 0x80) |
1163 | clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha); |
1164 | else if (depth & 0x40) |
1165 | clut->clut16[entry_id] = RGBA(r,g,b,255 - alpha); |
1166 | else if (depth & 0x20) |
1167 | clut->clut256[entry_id] = RGBA(r,g,b,255 - alpha); |
1168 | } |
1169 | } |
1170 | |
1171 | return 0; |
1172 | } |
1173 | |
1174 | |
1175 | static int dvbsub_parse_region_segment(AVCodecContext *avctx, |
1176 | const uint8_t *buf, int buf_size) |
1177 | { |
1178 | DVBSubContext *ctx = avctx->priv_data; |
1179 | |
1180 | const uint8_t *buf_end = buf + buf_size; |
1181 | int region_id, object_id; |
1182 | int av_unused version; |
1183 | DVBSubRegion *region; |
1184 | DVBSubObject *object; |
1185 | DVBSubObjectDisplay *display; |
1186 | int fill; |
1187 | |
1188 | if (buf_size < 10) |
1189 | return AVERROR_INVALIDDATA; |
1190 | |
1191 | region_id = *buf++; |
1192 | |
1193 | region = get_region(ctx, region_id); |
1194 | |
1195 | if (!region) { |
1196 | region = av_mallocz(sizeof(DVBSubRegion)); |
1197 | if (!region) |
1198 | return AVERROR(ENOMEM); |
1199 | |
1200 | region->id = region_id; |
1201 | region->version = -1; |
1202 | |
1203 | region->next = ctx->region_list; |
1204 | ctx->region_list = region; |
1205 | } |
1206 | |
1207 | version = ((*buf)>>4) & 15; |
1208 | fill = ((*buf++) >> 3) & 1; |
1209 | |
1210 | region->width = AV_RB16(buf); |
1211 | buf += 2; |
1212 | region->height = AV_RB16(buf); |
1213 | buf += 2; |
1214 | |
1215 | if (region->width * region->height != region->buf_size) { |
1216 | av_free(region->pbuf); |
1217 | |
1218 | region->buf_size = region->width * region->height; |
1219 | |
1220 | region->pbuf = av_malloc(region->buf_size); |
1221 | if (!region->pbuf) { |
1222 | region->buf_size = |
1223 | region->width = |
1224 | region->height = 0; |
1225 | return AVERROR(ENOMEM); |
1226 | } |
1227 | |
1228 | fill = 1; |
1229 | region->dirty = 0; |
1230 | } |
1231 | |
1232 | region->depth = 1 << (((*buf++) >> 2) & 7); |
1233 | if(region->depth<2 || region->depth>8){ |
1234 | av_log(avctx, AV_LOG_ERROR, "region depth %d is invalid\n", region->depth); |
1235 | region->depth= 4; |
1236 | } |
1237 | region->clut = *buf++; |
1238 | |
1239 | if (region->depth == 8) { |
1240 | region->bgcolor = *buf++; |
1241 | buf += 1; |
1242 | } else { |
1243 | buf += 1; |
1244 | |
1245 | if (region->depth == 4) |
1246 | region->bgcolor = (((*buf++) >> 4) & 15); |
1247 | else |
1248 | region->bgcolor = (((*buf++) >> 2) & 3); |
1249 | } |
1250 | |
1251 | ff_dlog(avctx, "Region %d, (%dx%d)\n", region_id, region->width, region->height); |
1252 | |
1253 | if (fill) { |
1254 | memset(region->pbuf, region->bgcolor, region->buf_size); |
1255 | ff_dlog(avctx, "Fill region (%d)\n", region->bgcolor); |
1256 | } |
1257 | |
1258 | delete_region_display_list(ctx, region); |
1259 | |
1260 | while (buf + 5 < buf_end) { |
1261 | object_id = AV_RB16(buf); |
1262 | buf += 2; |
1263 | |
1264 | object = get_object(ctx, object_id); |
1265 | |
1266 | if (!object) { |
1267 | object = av_mallocz(sizeof(DVBSubObject)); |
1268 | if (!object) |
1269 | return AVERROR(ENOMEM); |
1270 | |
1271 | object->id = object_id; |
1272 | object->next = ctx->object_list; |
1273 | ctx->object_list = object; |
1274 | } |
1275 | |
1276 | object->type = (*buf) >> 6; |
1277 | |
1278 | display = av_mallocz(sizeof(DVBSubObjectDisplay)); |
1279 | if (!display) |
1280 | return AVERROR(ENOMEM); |
1281 | |
1282 | display->object_id = object_id; |
1283 | display->region_id = region_id; |
1284 | |
1285 | display->x_pos = AV_RB16(buf) & 0xfff; |
1286 | buf += 2; |
1287 | display->y_pos = AV_RB16(buf) & 0xfff; |
1288 | buf += 2; |
1289 | |
1290 | if ((object->type == 1 || object->type == 2) && buf+1 < buf_end) { |
1291 | display->fgcolor = *buf++; |
1292 | display->bgcolor = *buf++; |
1293 | } |
1294 | |
1295 | display->region_list_next = region->display_list; |
1296 | region->display_list = display; |
1297 | |
1298 | display->object_list_next = object->display_list; |
1299 | object->display_list = display; |
1300 | } |
1301 | |
1302 | return 0; |
1303 | } |
1304 | |
1305 | static int dvbsub_parse_page_segment(AVCodecContext *avctx, |
1306 | const uint8_t *buf, int buf_size, AVSubtitle *sub, int *got_output) |
1307 | { |
1308 | DVBSubContext *ctx = avctx->priv_data; |
1309 | DVBSubRegionDisplay *display; |
1310 | DVBSubRegionDisplay *tmp_display_list, **tmp_ptr; |
1311 | |
1312 | const uint8_t *buf_end = buf + buf_size; |
1313 | int region_id; |
1314 | int page_state; |
1315 | int timeout; |
1316 | int version; |
1317 | |
1318 | if (buf_size < 1) |
1319 | return AVERROR_INVALIDDATA; |
1320 | |
1321 | timeout = *buf++; |
1322 | version = ((*buf)>>4) & 15; |
1323 | page_state = ((*buf++) >> 2) & 3; |
1324 | |
1325 | if (ctx->version == version) { |
1326 | return 0; |
1327 | } |
1328 | |
1329 | ctx->time_out = timeout; |
1330 | ctx->version = version; |
1331 | |
1332 | ff_dlog(avctx, "Page time out %ds, state %d\n", ctx->time_out, page_state); |
1333 | |
1334 | if(ctx->compute_edt == 1) |
1335 | save_subtitle_set(avctx, sub, got_output); |
1336 | |
1337 | if (page_state == 1 || page_state == 2) { |
1338 | delete_regions(ctx); |
1339 | delete_objects(ctx); |
1340 | delete_cluts(ctx); |
1341 | } |
1342 | |
1343 | tmp_display_list = ctx->display_list; |
1344 | ctx->display_list = NULL; |
1345 | |
1346 | while (buf + 5 < buf_end) { |
1347 | region_id = *buf++; |
1348 | buf += 1; |
1349 | |
1350 | display = tmp_display_list; |
1351 | tmp_ptr = &tmp_display_list; |
1352 | |
1353 | while (display && display->region_id != region_id) { |
1354 | tmp_ptr = &display->next; |
1355 | display = display->next; |
1356 | } |
1357 | |
1358 | if (!display) { |
1359 | display = av_mallocz(sizeof(DVBSubRegionDisplay)); |
1360 | if (!display) |
1361 | return AVERROR(ENOMEM); |
1362 | } |
1363 | |
1364 | display->region_id = region_id; |
1365 | |
1366 | display->x_pos = AV_RB16(buf); |
1367 | buf += 2; |
1368 | display->y_pos = AV_RB16(buf); |
1369 | buf += 2; |
1370 | |
1371 | *tmp_ptr = display->next; |
1372 | |
1373 | display->next = ctx->display_list; |
1374 | ctx->display_list = display; |
1375 | |
1376 | ff_dlog(avctx, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos); |
1377 | } |
1378 | |
1379 | while (tmp_display_list) { |
1380 | display = tmp_display_list; |
1381 | |
1382 | tmp_display_list = display->next; |
1383 | |
1384 | av_freep(&display); |
1385 | } |
1386 | |
1387 | return 0; |
1388 | } |
1389 | |
1390 | |
1391 | #ifdef DEBUG |
1392 | static int save_display_set(DVBSubContext *ctx) |
1393 | { |
1394 | DVBSubRegion *region; |
1395 | DVBSubRegionDisplay *display; |
1396 | DVBSubCLUT *clut; |
1397 | uint32_t *clut_table; |
1398 | int x_pos, y_pos, width, height; |
1399 | int x, y, y_off, x_off; |
1400 | uint32_t *pbuf; |
1401 | char filename[32]; |
1402 | static int fileno_index = 0; |
1403 | |
1404 | x_pos = -1; |
1405 | y_pos = -1; |
1406 | width = 0; |
1407 | height = 0; |
1408 | |
1409 | for (display = ctx->display_list; display; display = display->next) { |
1410 | region = get_region(ctx, display->region_id); |
1411 | |
1412 | if (!region) |
1413 | return -1; |
1414 | |
1415 | if (x_pos == -1) { |
1416 | x_pos = display->x_pos; |
1417 | y_pos = display->y_pos; |
1418 | width = region->width; |
1419 | height = region->height; |
1420 | } else { |
1421 | if (display->x_pos < x_pos) { |
1422 | width += (x_pos - display->x_pos); |
1423 | x_pos = display->x_pos; |
1424 | } |
1425 | |
1426 | if (display->y_pos < y_pos) { |
1427 | height += (y_pos - display->y_pos); |
1428 | y_pos = display->y_pos; |
1429 | } |
1430 | |
1431 | if (display->x_pos + region->width > x_pos + width) { |
1432 | width = display->x_pos + region->width - x_pos; |
1433 | } |
1434 | |
1435 | if (display->y_pos + region->height > y_pos + height) { |
1436 | height = display->y_pos + region->height - y_pos; |
1437 | } |
1438 | } |
1439 | } |
1440 | |
1441 | if (x_pos >= 0) { |
1442 | |
1443 | pbuf = av_malloc(width * height * 4); |
1444 | if (!pbuf) |
1445 | return -1; |
1446 | |
1447 | for (display = ctx->display_list; display; display = display->next) { |
1448 | region = get_region(ctx, display->region_id); |
1449 | |
1450 | if (!region) |
1451 | return -1; |
1452 | |
1453 | x_off = display->x_pos - x_pos; |
1454 | y_off = display->y_pos - y_pos; |
1455 | |
1456 | clut = get_clut(ctx, region->clut); |
1457 | |
1458 | if (!clut) |
1459 | clut = &default_clut; |
1460 | |
1461 | switch (region->depth) { |
1462 | case 2: |
1463 | clut_table = clut->clut4; |
1464 | break; |
1465 | case 8: |
1466 | clut_table = clut->clut256; |
1467 | break; |
1468 | case 4: |
1469 | default: |
1470 | clut_table = clut->clut16; |
1471 | break; |
1472 | } |
1473 | |
1474 | for (y = 0; y < region->height; y++) { |
1475 | for (x = 0; x < region->width; x++) { |
1476 | pbuf[((y + y_off) * width) + x_off + x] = |
1477 | clut_table[region->pbuf[y * region->width + x]]; |
1478 | } |
1479 | } |
1480 | |
1481 | } |
1482 | |
1483 | snprintf(filename, sizeof(filename), "dvbs.%d", fileno_index); |
1484 | |
1485 | png_save(filename, pbuf, width, height); |
1486 | |
1487 | av_freep(&pbuf); |
1488 | } |
1489 | |
1490 | fileno_index++; |
1491 | return 0; |
1492 | } |
1493 | #endif |
1494 | |
1495 | static int dvbsub_parse_display_definition_segment(AVCodecContext *avctx, |
1496 | const uint8_t *buf, |
1497 | int buf_size) |
1498 | { |
1499 | DVBSubContext *ctx = avctx->priv_data; |
1500 | DVBSubDisplayDefinition *display_def = ctx->display_definition; |
1501 | int dds_version, info_byte; |
1502 | |
1503 | if (buf_size < 5) |
1504 | return AVERROR_INVALIDDATA; |
1505 | |
1506 | info_byte = bytestream_get_byte(&buf); |
1507 | dds_version = info_byte >> 4; |
1508 | if (display_def && display_def->version == dds_version) |
1509 | return 0; // already have this display definition version |
1510 | |
1511 | if (!display_def) { |
1512 | display_def = av_mallocz(sizeof(*display_def)); |
1513 | if (!display_def) |
1514 | return AVERROR(ENOMEM); |
1515 | ctx->display_definition = display_def; |
1516 | } |
1517 | |
1518 | display_def->version = dds_version; |
1519 | display_def->x = 0; |
1520 | display_def->y = 0; |
1521 | display_def->width = bytestream_get_be16(&buf) + 1; |
1522 | display_def->height = bytestream_get_be16(&buf) + 1; |
1523 | if (!avctx->width || !avctx->height) { |
1524 | avctx->width = display_def->width; |
1525 | avctx->height = display_def->height; |
1526 | } |
1527 | |
1528 | if (info_byte & 1<<3) { // display_window_flag |
1529 | if (buf_size < 13) |
1530 | return AVERROR_INVALIDDATA; |
1531 | |
1532 | display_def->x = bytestream_get_be16(&buf); |
1533 | display_def->width = bytestream_get_be16(&buf) - display_def->x + 1; |
1534 | display_def->y = bytestream_get_be16(&buf); |
1535 | display_def->height = bytestream_get_be16(&buf) - display_def->y + 1; |
1536 | } |
1537 | |
1538 | return 0; |
1539 | } |
1540 | |
1541 | static int dvbsub_display_end_segment(AVCodecContext *avctx, const uint8_t *buf, |
1542 | int buf_size, AVSubtitle *sub,int *got_output) |
1543 | { |
1544 | DVBSubContext *ctx = avctx->priv_data; |
1545 | |
1546 | if(ctx->compute_edt == 0) |
1547 | save_subtitle_set(avctx, sub, got_output); |
1548 | #ifdef DEBUG |
1549 | save_display_set(ctx); |
1550 | #endif |
1551 | return 0; |
1552 | } |
1553 | |
1554 | static int dvbsub_decode(AVCodecContext *avctx, |
1555 | void *data, int *data_size, |
1556 | AVPacket *avpkt) |
1557 | { |
1558 | const uint8_t *buf = avpkt->data; |
1559 | int buf_size = avpkt->size; |
1560 | DVBSubContext *ctx = avctx->priv_data; |
1561 | AVSubtitle *sub = data; |
1562 | const uint8_t *p, *p_end; |
1563 | int segment_type; |
1564 | int page_id; |
1565 | int segment_length; |
1566 | int i; |
1567 | int ret = 0; |
1568 | int got_segment = 0; |
1569 | int got_dds = 0; |
1570 | |
1571 | ff_dlog(avctx, "DVB sub packet:\n"); |
1572 | |
1573 | for (i=0; i < buf_size; i++) { |
1574 | ff_dlog(avctx, "%02x ", buf[i]); |
1575 | if (i % 16 == 15) |
1576 | ff_dlog(avctx, "\n"); |
1577 | } |
1578 | |
1579 | if (i % 16) |
1580 | ff_dlog(avctx, "\n"); |
1581 | |
1582 | if (buf_size <= 6 || *buf != 0x0f) { |
1583 | ff_dlog(avctx, "incomplete or broken packet"); |
1584 | return AVERROR_INVALIDDATA; |
1585 | } |
1586 | |
1587 | p = buf; |
1588 | p_end = buf + buf_size; |
1589 | |
1590 | while (p_end - p >= 6 && *p == 0x0f) { |
1591 | p += 1; |
1592 | segment_type = *p++; |
1593 | page_id = AV_RB16(p); |
1594 | p += 2; |
1595 | segment_length = AV_RB16(p); |
1596 | p += 2; |
1597 | |
1598 | if (avctx->debug & FF_DEBUG_STARTCODE) { |
1599 | av_log(avctx, AV_LOG_DEBUG, "segment_type:%d page_id:%d segment_length:%d\n", segment_type, page_id, segment_length); |
1600 | } |
1601 | |
1602 | if (p_end - p < segment_length) { |
1603 | ff_dlog(avctx, "incomplete or broken packet"); |
1604 | ret = -1; |
1605 | goto end; |
1606 | } |
1607 | |
1608 | if (page_id == ctx->composition_id || page_id == ctx->ancillary_id || |
1609 | ctx->composition_id == -1 || ctx->ancillary_id == -1) { |
1610 | int ret = 0; |
1611 | switch (segment_type) { |
1612 | case DVBSUB_PAGE_SEGMENT: |
1613 | ret = dvbsub_parse_page_segment(avctx, p, segment_length, sub, data_size); |
1614 | got_segment |= 1; |
1615 | break; |
1616 | case DVBSUB_REGION_SEGMENT: |
1617 | ret = dvbsub_parse_region_segment(avctx, p, segment_length); |
1618 | got_segment |= 2; |
1619 | break; |
1620 | case DVBSUB_CLUT_SEGMENT: |
1621 | ret = dvbsub_parse_clut_segment(avctx, p, segment_length); |
1622 | if (ret < 0) goto end; |
1623 | got_segment |= 4; |
1624 | break; |
1625 | case DVBSUB_OBJECT_SEGMENT: |
1626 | ret = dvbsub_parse_object_segment(avctx, p, segment_length); |
1627 | got_segment |= 8; |
1628 | break; |
1629 | case DVBSUB_DISPLAYDEFINITION_SEGMENT: |
1630 | ret = dvbsub_parse_display_definition_segment(avctx, p, |
1631 | segment_length); |
1632 | got_dds = 1; |
1633 | break; |
1634 | case DVBSUB_DISPLAY_SEGMENT: |
1635 | ret = dvbsub_display_end_segment(avctx, p, segment_length, sub, data_size); |
1636 | if (got_segment == 15 && !got_dds && !avctx->width && !avctx->height) { |
1637 | // Default from ETSI EN 300 743 V1.3.1 (7.2.1) |
1638 | avctx->width = 720; |
1639 | avctx->height = 576; |
1640 | } |
1641 | got_segment |= 16; |
1642 | break; |
1643 | default: |
1644 | ff_dlog(avctx, "Subtitling segment type 0x%x, page id %d, length %d\n", |
1645 | segment_type, page_id, segment_length); |
1646 | break; |
1647 | } |
1648 | if (ret < 0) |
1649 | goto end; |
1650 | } |
1651 | |
1652 | p += segment_length; |
1653 | } |
1654 | // Some streams do not send a display segment but if we have all the other |
1655 | // segments then we need no further data. |
1656 | if (got_segment == 15) { |
1657 | av_log(avctx, AV_LOG_DEBUG, "Missing display_end_segment, emulating\n"); |
1658 | dvbsub_display_end_segment(avctx, p, 0, sub, data_size); |
1659 | } |
1660 | |
1661 | end: |
1662 | if(ret < 0) { |
1663 | *data_size = 0; |
1664 | avsubtitle_free(sub); |
1665 | return ret; |
1666 | } else { |
1667 | if(ctx->compute_edt == 1 ) |
1668 | FFSWAP(int64_t, ctx->prev_start, sub->pts); |
1669 | } |
1670 | |
1671 | return p - buf; |
1672 | } |
1673 | |
1674 | #define DS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_SUBTITLE_PARAM |
1675 | static const AVOption options[] = { |
1676 | {"compute_edt", "compute end of time using pts or timeout", offsetof(DVBSubContext, compute_edt), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DS}, |
1677 | {"compute_clut", "compute clut when not available(-1) or always(1) or never(0)", offsetof(DVBSubContext, compute_clut), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, DS}, |
1678 | {"dvb_substream", "", offsetof(DVBSubContext, substream), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, DS}, |
1679 | {NULL} |
1680 | }; |
1681 | static const AVClass dvbsubdec_class = { |
1682 | .class_name = "DVB Sub Decoder", |
1683 | .item_name = av_default_item_name, |
1684 | .option = options, |
1685 | .version = LIBAVUTIL_VERSION_INT, |
1686 | }; |
1687 | |
1688 | AVCodec ff_dvbsub_decoder = { |
1689 | .name = "dvbsub", |
1690 | .long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"), |
1691 | .type = AVMEDIA_TYPE_SUBTITLE, |
1692 | .id = AV_CODEC_ID_DVB_SUBTITLE, |
1693 | .priv_data_size = sizeof(DVBSubContext), |
1694 | .init = dvbsub_init_decoder, |
1695 | .close = dvbsub_close_decoder, |
1696 | .decode = dvbsub_decode, |
1697 | .priv_class = &dvbsubdec_class, |
1698 | }; |
1699 |