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 
166 
167 typedef struct DVBSubObjectDisplay {
170 
171  int x_pos;
172  int y_pos;
173 
174  int fgcolor;
175  int bgcolor;
176 
180 
181 typedef struct DVBSubObject {
182  int id;
183  int version;
184 
185  int type;
186 
188 
190 } DVBSubObject;
191 
192 typedef struct DVBSubRegionDisplay {
194 
195  int x_pos;
196  int y_pos;
197 
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 
213  int buf_size;
214  int dirty;
215 
217 
219 } DVBSubRegion;
220 
221 typedef struct DVBSubDisplayDefinition {
222  int version;
223 
224  int x;
225  int y;
226  int width;
227  int height;
229 
230 typedef struct DVBSubContext {
231  AVClass *class;
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;
243 
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 
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 
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 
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 
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 
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 
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;
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 
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 
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;
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;
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 }
1052 
1054  const uint8_t *buf, int buf_size)
1055 {
1056  DVBSubContext *ctx = avctx->priv_data;
1057 
1058  const uint8_t *buf_end = buf + buf_size;
1059  int i, clut_id;
1060  int version;
1061  DVBSubCLUT *clut;
1062  int entry_id, depth , full_range;
1063  int y, cr, cb, alpha;
1064  int r, g, b, r_add, g_add, b_add;
1065 
1066  av_dlog(avctx, "DVB clut packet:\n");
1067 
1068  for (i=0; i < buf_size; i++) {
1069  av_dlog(avctx, "%02x ", buf[i]);
1070  if (i % 16 == 15)
1071  av_dlog(avctx, "\n");
1072  }
1073 
1074  if (i % 16)
1075  av_dlog(avctx, "\n");
1076 
1077  clut_id = *buf++;
1078  version = ((*buf)>>4)&15;
1079  buf += 1;
1080 
1081  clut = get_clut(ctx, clut_id);
1082 
1083  if (!clut) {
1084  clut = av_malloc(sizeof(DVBSubCLUT));
1085 
1086  memcpy(clut, &default_clut, sizeof(DVBSubCLUT));
1087 
1088  clut->id = clut_id;
1089  clut->version = -1;
1090 
1091  clut->next = ctx->clut_list;
1092  ctx->clut_list = clut;
1093  }
1094 
1095  if (clut->version != version) {
1096 
1097  clut->version = version;
1098 
1099  while (buf + 4 < buf_end) {
1100  entry_id = *buf++;
1101 
1102  depth = (*buf) & 0xe0;
1103 
1104  if (depth == 0) {
1105  av_log(avctx, AV_LOG_ERROR, "Invalid clut depth 0x%x!\n", *buf);
1106  return 0;
1107  }
1108 
1109  full_range = (*buf++) & 1;
1110 
1111  if (full_range) {
1112  y = *buf++;
1113  cr = *buf++;
1114  cb = *buf++;
1115  alpha = *buf++;
1116  } else {
1117  y = buf[0] & 0xfc;
1118  cr = (((buf[0] & 3) << 2) | ((buf[1] >> 6) & 3)) << 4;
1119  cb = (buf[1] << 2) & 0xf0;
1120  alpha = (buf[1] << 6) & 0xc0;
1121 
1122  buf += 2;
1123  }
1124 
1125  if (y == 0)
1126  alpha = 0xff;
1127 
1128  YUV_TO_RGB1_CCIR(cb, cr);
1129  YUV_TO_RGB2_CCIR(r, g, b, y);
1130 
1131  av_dlog(avctx, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);
1132  if (!!(depth & 0x80) + !!(depth & 0x40) + !!(depth & 0x20) > 1) {
1133  av_dlog(avctx, "More than one bit level marked: %x\n", depth);
1135  return AVERROR_INVALIDDATA;
1136  }
1137 
1138  if (depth & 0x80)
1139  clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha);
1140  else if (depth & 0x40)
1141  clut->clut16[entry_id] = RGBA(r,g,b,255 - alpha);
1142  else if (depth & 0x20)
1143  clut->clut256[entry_id] = RGBA(r,g,b,255 - alpha);
1144  }
1145  }
1146  return 0;
1147 }
1148 
1149 
1151  const uint8_t *buf, int buf_size)
1152 {
1153  DVBSubContext *ctx = avctx->priv_data;
1154 
1155  const uint8_t *buf_end = buf + buf_size;
1156  int region_id, object_id;
1157  int av_unused version;
1158  DVBSubRegion *region;
1159  DVBSubObject *object;
1160  DVBSubObjectDisplay *display;
1161  int fill;
1162 
1163  if (buf_size < 10)
1164  return;
1165 
1166  region_id = *buf++;
1167 
1168  region = get_region(ctx, region_id);
1169 
1170  if (!region) {
1171  region = av_mallocz(sizeof(DVBSubRegion));
1172 
1173  region->id = region_id;
1174  region->version = -1;
1175 
1176  region->next = ctx->region_list;
1177  ctx->region_list = region;
1178  }
1179 
1180  version = ((*buf)>>4) & 15;
1181  fill = ((*buf++) >> 3) & 1;
1182 
1183  region->width = AV_RB16(buf);
1184  buf += 2;
1185  region->height = AV_RB16(buf);
1186  buf += 2;
1187 
1188  if (region->width * region->height != region->buf_size) {
1189  av_free(region->pbuf);
1190 
1191  region->buf_size = region->width * region->height;
1192 
1193  region->pbuf = av_malloc(region->buf_size);
1194 
1195  fill = 1;
1196  region->dirty = 0;
1197  }
1198 
1199  region->depth = 1 << (((*buf++) >> 2) & 7);
1200  if(region->depth<2 || region->depth>8){
1201  av_log(avctx, AV_LOG_ERROR, "region depth %d is invalid\n", region->depth);
1202  region->depth= 4;
1203  }
1204  region->clut = *buf++;
1205 
1206  if (region->depth == 8) {
1207  region->bgcolor = *buf++;
1208  buf += 1;
1209  } else {
1210  buf += 1;
1211 
1212  if (region->depth == 4)
1213  region->bgcolor = (((*buf++) >> 4) & 15);
1214  else
1215  region->bgcolor = (((*buf++) >> 2) & 3);
1216  }
1217 
1218  av_dlog(avctx, "Region %d, (%dx%d)\n", region_id, region->width, region->height);
1219 
1220  if (fill) {
1221  memset(region->pbuf, region->bgcolor, region->buf_size);
1222  av_dlog(avctx, "Fill region (%d)\n", region->bgcolor);
1223  }
1224 
1225  delete_region_display_list(ctx, region);
1226 
1227  while (buf + 5 < buf_end) {
1228  object_id = AV_RB16(buf);
1229  buf += 2;
1230 
1231  object = get_object(ctx, object_id);
1232 
1233  if (!object) {
1234  object = av_mallocz(sizeof(DVBSubObject));
1235 
1236  object->id = object_id;
1237  object->next = ctx->object_list;
1238  ctx->object_list = object;
1239  }
1240 
1241  object->type = (*buf) >> 6;
1242 
1243  display = av_mallocz(sizeof(DVBSubObjectDisplay));
1244 
1245  display->object_id = object_id;
1246  display->region_id = region_id;
1247 
1248  display->x_pos = AV_RB16(buf) & 0xfff;
1249  buf += 2;
1250  display->y_pos = AV_RB16(buf) & 0xfff;
1251  buf += 2;
1252 
1253  if ((object->type == 1 || object->type == 2) && buf+1 < buf_end) {
1254  display->fgcolor = *buf++;
1255  display->bgcolor = *buf++;
1256  }
1257 
1258  display->region_list_next = region->display_list;
1259  region->display_list = display;
1260 
1261  display->object_list_next = object->display_list;
1262  object->display_list = display;
1263  }
1264 }
1265 
1267  const uint8_t *buf, int buf_size, AVSubtitle *sub, int *got_output)
1268 {
1269  DVBSubContext *ctx = avctx->priv_data;
1270  DVBSubRegionDisplay *display;
1271  DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;
1272 
1273  const uint8_t *buf_end = buf + buf_size;
1274  int region_id;
1275  int page_state;
1276  int timeout;
1277  int version;
1278 
1279  if (buf_size < 1)
1280  return;
1281 
1282  timeout = *buf++;
1283  version = ((*buf)>>4) & 15;
1284  page_state = ((*buf++) >> 2) & 3;
1285 
1286  if (ctx->version == version) {
1287  return;
1288  }
1289 
1290  ctx->time_out = timeout;
1291  ctx->version = version;
1292 
1293  av_dlog(avctx, "Page time out %ds, state %d\n", ctx->time_out, page_state);
1294 
1295  if(ctx->compute_edt == 1)
1296  save_subtitle_set(avctx, sub, got_output);
1297 
1298  if (page_state == 1 || page_state == 2) {
1299  delete_regions(ctx);
1300  delete_objects(ctx);
1301  delete_cluts(ctx);
1302  }
1303 
1304  tmp_display_list = ctx->display_list;
1305  ctx->display_list = NULL;
1306 
1307  while (buf + 5 < buf_end) {
1308  region_id = *buf++;
1309  buf += 1;
1310 
1311  display = tmp_display_list;
1312  tmp_ptr = &tmp_display_list;
1313 
1314  while (display && display->region_id != region_id) {
1315  tmp_ptr = &display->next;
1316  display = display->next;
1317  }
1318 
1319  if (!display)
1320  display = av_mallocz(sizeof(DVBSubRegionDisplay));
1321 
1322  display->region_id = region_id;
1323 
1324  display->x_pos = AV_RB16(buf);
1325  buf += 2;
1326  display->y_pos = AV_RB16(buf);
1327  buf += 2;
1328 
1329  *tmp_ptr = display->next;
1330 
1331  display->next = ctx->display_list;
1332  ctx->display_list = display;
1333 
1334  av_dlog(avctx, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
1335  }
1336 
1337  while (tmp_display_list) {
1338  display = tmp_display_list;
1339 
1340  tmp_display_list = display->next;
1341 
1342  av_freep(&display);
1343  }
1344 
1345 }
1346 
1347 
1348 #ifdef DEBUG
1349 static void save_display_set(DVBSubContext *ctx)
1350 {
1351  DVBSubRegion *region;
1352  DVBSubRegionDisplay *display;
1353  DVBSubCLUT *clut;
1354  uint32_t *clut_table;
1355  int x_pos, y_pos, width, height;
1356  int x, y, y_off, x_off;
1357  uint32_t *pbuf;
1358  char filename[32];
1359  static int fileno_index = 0;
1360 
1361  x_pos = -1;
1362  y_pos = -1;
1363  width = 0;
1364  height = 0;
1365 
1366  for (display = ctx->display_list; display; display = display->next) {
1367  region = get_region(ctx, display->region_id);
1368 
1369  if (x_pos == -1) {
1370  x_pos = display->x_pos;
1371  y_pos = display->y_pos;
1372  width = region->width;
1373  height = region->height;
1374  } else {
1375  if (display->x_pos < x_pos) {
1376  width += (x_pos - display->x_pos);
1377  x_pos = display->x_pos;
1378  }
1379 
1380  if (display->y_pos < y_pos) {
1381  height += (y_pos - display->y_pos);
1382  y_pos = display->y_pos;
1383  }
1384 
1385  if (display->x_pos + region->width > x_pos + width) {
1386  width = display->x_pos + region->width - x_pos;
1387  }
1388 
1389  if (display->y_pos + region->height > y_pos + height) {
1390  height = display->y_pos + region->height - y_pos;
1391  }
1392  }
1393  }
1394 
1395  if (x_pos >= 0) {
1396 
1397  pbuf = av_malloc(width * height * 4);
1398 
1399  for (display = ctx->display_list; display; display = display->next) {
1400  region = get_region(ctx, display->region_id);
1401 
1402  x_off = display->x_pos - x_pos;
1403  y_off = display->y_pos - y_pos;
1404 
1405  clut = get_clut(ctx, region->clut);
1406 
1407  if (!clut)
1408  clut = &default_clut;
1409 
1410  switch (region->depth) {
1411  case 2:
1412  clut_table = clut->clut4;
1413  break;
1414  case 8:
1415  clut_table = clut->clut256;
1416  break;
1417  case 4:
1418  default:
1419  clut_table = clut->clut16;
1420  break;
1421  }
1422 
1423  for (y = 0; y < region->height; y++) {
1424  for (x = 0; x < region->width; x++) {
1425  pbuf[((y + y_off) * width) + x_off + x] =
1426  clut_table[region->pbuf[y * region->width + x]];
1427  }
1428  }
1429 
1430  }
1431 
1432  snprintf(filename, sizeof(filename), "dvbs.%d", fileno_index);
1433 
1434  png_save2(filename, pbuf, width, height);
1435 
1436  av_freep(&pbuf);
1437  }
1438 
1439  fileno_index++;
1440 }
1441 #endif
1442 
1444  const uint8_t *buf,
1445  int buf_size)
1446 {
1447  DVBSubContext *ctx = avctx->priv_data;
1448  DVBSubDisplayDefinition *display_def = ctx->display_definition;
1449  int dds_version, info_byte;
1450 
1451  if (buf_size < 5)
1452  return;
1453 
1454  info_byte = bytestream_get_byte(&buf);
1455  dds_version = info_byte >> 4;
1456  if (display_def && display_def->version == dds_version)
1457  return; // already have this display definition version
1458 
1459  if (!display_def) {
1460  display_def = av_mallocz(sizeof(*display_def));
1461  ctx->display_definition = display_def;
1462  }
1463  if (!display_def)
1464  return;
1465 
1466  display_def->version = dds_version;
1467  display_def->x = 0;
1468  display_def->y = 0;
1469  display_def->width = bytestream_get_be16(&buf) + 1;
1470  display_def->height = bytestream_get_be16(&buf) + 1;
1471  if (!avctx->width || !avctx->height) {
1472  avctx->width = display_def->width;
1473  avctx->height = display_def->height;
1474  }
1475 
1476  if (buf_size < 13)
1477  return;
1478 
1479  if (info_byte & 1<<3) { // display_window_flag
1480  display_def->x = bytestream_get_be16(&buf);
1481  display_def->width = bytestream_get_be16(&buf) - display_def->x + 1;
1482  display_def->y = bytestream_get_be16(&buf);
1483  display_def->height = bytestream_get_be16(&buf) - display_def->y + 1;
1484  }
1485 }
1486 
1488  int buf_size, AVSubtitle *sub,int *got_output)
1489 {
1490  DVBSubContext *ctx = avctx->priv_data;
1491 
1492  if(ctx->compute_edt == 0)
1493  save_subtitle_set(avctx, sub, got_output);
1494 #ifdef DEBUG
1495  save_display_set(ctx);
1496 #endif
1497 
1498 }
1499 
1500 static int dvbsub_decode(AVCodecContext *avctx,
1501  void *data, int *data_size,
1502  AVPacket *avpkt)
1503 {
1504  const uint8_t *buf = avpkt->data;
1505  int buf_size = avpkt->size;
1506  DVBSubContext *ctx = avctx->priv_data;
1507  AVSubtitle *sub = data;
1508  const uint8_t *p, *p_end;
1509  int segment_type;
1510  int page_id;
1511  int segment_length;
1512  int i;
1513  int ret = 0;
1514  int got_segment = 0;
1515 
1516  av_dlog(avctx, "DVB sub packet:\n");
1517 
1518  for (i=0; i < buf_size; i++) {
1519  av_dlog(avctx, "%02x ", buf[i]);
1520  if (i % 16 == 15)
1521  av_dlog(avctx, "\n");
1522  }
1523 
1524  if (i % 16)
1525  av_dlog(avctx, "\n");
1526 
1527  if (buf_size <= 6 || *buf != 0x0f) {
1528  av_dlog(avctx, "incomplete or broken packet");
1529  return -1;
1530  }
1531 
1532  p = buf;
1533  p_end = buf + buf_size;
1534 
1535  while (p_end - p >= 6 && *p == 0x0f) {
1536  p += 1;
1537  segment_type = *p++;
1538  page_id = AV_RB16(p);
1539  p += 2;
1540  segment_length = AV_RB16(p);
1541  p += 2;
1542 
1543  if (avctx->debug & FF_DEBUG_STARTCODE) {
1544  av_log(avctx, AV_LOG_DEBUG, "segment_type:%d page_id:%d segment_length:%d\n", segment_type, page_id, segment_length);
1545  }
1546 
1547  if (p_end - p < segment_length) {
1548  av_dlog(avctx, "incomplete or broken packet");
1549  ret = -1;
1550  goto end;
1551  }
1552 
1553  if (page_id == ctx->composition_id || page_id == ctx->ancillary_id ||
1554  ctx->composition_id == -1 || ctx->ancillary_id == -1) {
1555  switch (segment_type) {
1556  case DVBSUB_PAGE_SEGMENT:
1557  dvbsub_parse_page_segment(avctx, p, segment_length, sub, data_size);
1558  got_segment |= 1;
1559  break;
1560  case DVBSUB_REGION_SEGMENT:
1561  dvbsub_parse_region_segment(avctx, p, segment_length);
1562  got_segment |= 2;
1563  break;
1564  case DVBSUB_CLUT_SEGMENT:
1565  ret = dvbsub_parse_clut_segment(avctx, p, segment_length);
1566  if (ret < 0) goto end;
1567  got_segment |= 4;
1568  break;
1569  case DVBSUB_OBJECT_SEGMENT:
1570  dvbsub_parse_object_segment(avctx, p, segment_length);
1571  got_segment |= 8;
1572  break;
1574  dvbsub_parse_display_definition_segment(avctx, p, segment_length);
1575  break;
1577  dvbsub_display_end_segment(avctx, p, segment_length, sub, data_size);
1578  got_segment |= 16;
1579  break;
1580  default:
1581  av_dlog(avctx, "Subtitling segment type 0x%x, page id %d, length %d\n",
1582  segment_type, page_id, segment_length);
1583  break;
1584  }
1585  }
1586 
1587  p += segment_length;
1588  }
1589  // Some streams do not send a display segment but if we have all the other
1590  // segments then we need no further data.
1591  if (got_segment == 15) {
1592  av_log(avctx, AV_LOG_DEBUG, "Missing display_end_segment, emulating\n");
1593  dvbsub_display_end_segment(avctx, p, 0, sub, data_size);
1594  }
1595 
1596 end:
1597  if(ret < 0) {
1598  *data_size = 0;
1599  avsubtitle_free(sub);
1600  return ret;
1601  } else {
1602  if(ctx->compute_edt == 1 )
1603  FFSWAP(int64_t, ctx->prev_start, sub->pts);
1604  }
1605 
1606  return p - buf;
1607 }
1608 
1609 #define DS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_SUBTITLE_PARAM
1610 static const AVOption options[] = {
1611  {"compute_edt", "compute end of time using pts or timeout", offsetof(DVBSubContext, compute_edt), FF_OPT_TYPE_INT, {.i64 = 0}, 0, 1, DS},
1612  {NULL}
1613 };
1614 static const AVClass dvbsubdec_class = {
1615  .class_name = "DVB Sub Decoder",
1616  .item_name = av_default_item_name,
1617  .option = options,
1618  .version = LIBAVUTIL_VERSION_INT,
1619 };
1620 
1622  .name = "dvbsub",
1623  .long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"),
1624  .type = AVMEDIA_TYPE_SUBTITLE,
1626  .priv_data_size = sizeof(DVBSubContext),
1629  .decode = dvbsub_decode,
1630  .priv_class = &dvbsubdec_class,
1631 };