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