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