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