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