Libav
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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 #include "avcodec.h"
22 #include "dsputil.h"
23 #include "get_bits.h"
24 #include "bytestream.h"
25 #include "libavutil/colorspace.h"
26 
27 #define DVBSUB_PAGE_SEGMENT 0x10
28 #define DVBSUB_REGION_SEGMENT 0x11
29 #define DVBSUB_CLUT_SEGMENT 0x12
30 #define DVBSUB_OBJECT_SEGMENT 0x13
31 #define DVBSUB_DISPLAYDEFINITION_SEGMENT 0x14
32 #define DVBSUB_DISPLAY_SEGMENT 0x80
33 
34 #define cm (ff_cropTbl + MAX_NEG_CROP)
35 
36 #ifdef DEBUG
37 #if 0
38 static void png_save(const char *filename, uint8_t *bitmap, int w, int h,
39  uint32_t *rgba_palette)
40 {
41  int x, y, v;
42  FILE *f;
43  char fname[40], fname2[40];
44  char command[1024];
45 
46  snprintf(fname, 40, "%s.ppm", filename);
47 
48  f = fopen(fname, "w");
49  if (!f) {
50  perror(fname);
51  return;
52  }
53  fprintf(f, "P6\n"
54  "%d %d\n"
55  "%d\n",
56  w, h, 255);
57  for(y = 0; y < h; y++) {
58  for(x = 0; x < w; x++) {
59  v = rgba_palette[bitmap[y * w + x]];
60  putc((v >> 16) & 0xff, f);
61  putc((v >> 8) & 0xff, f);
62  putc((v >> 0) & 0xff, f);
63  }
64  }
65  fclose(f);
66 
67 
68  snprintf(fname2, 40, "%s-a.pgm", filename);
69 
70  f = fopen(fname2, "w");
71  if (!f) {
72  perror(fname2);
73  return;
74  }
75  fprintf(f, "P5\n"
76  "%d %d\n"
77  "%d\n",
78  w, h, 255);
79  for(y = 0; y < h; y++) {
80  for(x = 0; x < w; x++) {
81  v = rgba_palette[bitmap[y * w + x]];
82  putc((v >> 24) & 0xff, f);
83  }
84  }
85  fclose(f);
86 
87  snprintf(command, 1024, "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
88  system(command);
89 
90  snprintf(command, 1024, "rm %s %s", fname, fname2);
91  system(command);
92 }
93 #endif
94 
95 static void png_save2(const char *filename, uint32_t *bitmap, int w, int h)
96 {
97  int x, y, v;
98  FILE *f;
99  char fname[40], fname2[40];
100  char command[1024];
101 
102  snprintf(fname, sizeof(fname), "%s.ppm", filename);
103 
104  f = fopen(fname, "w");
105  if (!f) {
106  perror(fname);
107  return;
108  }
109  fprintf(f, "P6\n"
110  "%d %d\n"
111  "%d\n",
112  w, h, 255);
113  for(y = 0; y < h; y++) {
114  for(x = 0; x < w; x++) {
115  v = bitmap[y * w + x];
116  putc((v >> 16) & 0xff, f);
117  putc((v >> 8) & 0xff, f);
118  putc((v >> 0) & 0xff, f);
119  }
120  }
121  fclose(f);
122 
123 
124  snprintf(fname2, sizeof(fname2), "%s-a.pgm", filename);
125 
126  f = fopen(fname2, "w");
127  if (!f) {
128  perror(fname2);
129  return;
130  }
131  fprintf(f, "P5\n"
132  "%d %d\n"
133  "%d\n",
134  w, h, 255);
135  for(y = 0; y < h; y++) {
136  for(x = 0; x < w; x++) {
137  v = bitmap[y * w + x];
138  putc((v >> 24) & 0xff, f);
139  }
140  }
141  fclose(f);
142 
143  snprintf(command, sizeof(command), "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
144  system(command);
145 
146  snprintf(command, sizeof(command), "rm %s %s", fname, fname2);
147  system(command);
148 }
149 #endif
150 
151 #define RGBA(r,g,b,a) (((unsigned)(a) << 24) | ((r) << 16) | ((g) << 8) | (b))
152 
153 typedef struct DVBSubCLUT {
154  int id;
155 
156  uint32_t clut4[4];
157  uint32_t clut16[16];
158  uint32_t clut256[256];
159 
160  struct DVBSubCLUT *next;
161 } DVBSubCLUT;
162 
164 
165 typedef struct DVBSubObjectDisplay {
168 
169  int x_pos;
170  int y_pos;
171 
172  int fgcolor;
173  int bgcolor;
174 
178 
179 typedef struct DVBSubObject {
180  int id;
181 
182  int type;
183 
185 
187 } DVBSubObject;
188 
189 typedef struct DVBSubRegionDisplay {
191 
192  int x_pos;
193  int y_pos;
194 
197 
198 typedef struct DVBSubRegion {
199  int id;
200 
201  int width;
202  int height;
203  int depth;
204 
205  int clut;
206  int bgcolor;
207 
209  int buf_size;
210 
212 
214 } DVBSubRegion;
215 
216 typedef struct DVBSubDisplayDefinition {
217  int version;
218 
219  int x;
220  int y;
221  int width;
222  int height;
224 
225 typedef struct DVBSubContext {
228 
229  int time_out;
233 
237 } DVBSubContext;
238 
239 
240 static DVBSubObject* get_object(DVBSubContext *ctx, int object_id)
241 {
242  DVBSubObject *ptr = ctx->object_list;
243 
244  while (ptr && ptr->id != object_id) {
245  ptr = ptr->next;
246  }
247 
248  return ptr;
249 }
250 
251 static DVBSubCLUT* get_clut(DVBSubContext *ctx, int clut_id)
252 {
253  DVBSubCLUT *ptr = ctx->clut_list;
254 
255  while (ptr && ptr->id != clut_id) {
256  ptr = ptr->next;
257  }
258 
259  return ptr;
260 }
261 
262 static DVBSubRegion* get_region(DVBSubContext *ctx, int region_id)
263 {
264  DVBSubRegion *ptr = ctx->region_list;
265 
266  while (ptr && ptr->id != region_id) {
267  ptr = ptr->next;
268  }
269 
270  return ptr;
271 }
272 
274 {
275  DVBSubObject *object, *obj2, **obj2_ptr;
276  DVBSubObjectDisplay *display, *obj_disp, **obj_disp_ptr;
277 
278  while (region->display_list) {
279  display = region->display_list;
280 
281  object = get_object(ctx, display->object_id);
282 
283  if (object) {
284  obj_disp_ptr = &object->display_list;
285  obj_disp = *obj_disp_ptr;
286 
287  while (obj_disp && obj_disp != display) {
288  obj_disp_ptr = &obj_disp->object_list_next;
289  obj_disp = *obj_disp_ptr;
290  }
291 
292  if (obj_disp) {
293  *obj_disp_ptr = obj_disp->object_list_next;
294 
295  if (!object->display_list) {
296  obj2_ptr = &ctx->object_list;
297  obj2 = *obj2_ptr;
298 
299  while (obj2 != object) {
300  assert(obj2);
301  obj2_ptr = &obj2->next;
302  obj2 = *obj2_ptr;
303  }
304 
305  *obj2_ptr = obj2->next;
306 
307  av_free(obj2);
308  }
309  }
310  }
311 
312  region->display_list = display->region_list_next;
313 
314  av_free(display);
315  }
316 
317 }
318 
319 static void delete_state(DVBSubContext *ctx)
320 {
321  DVBSubRegion *region;
322  DVBSubCLUT *clut;
323 
324  while (ctx->region_list) {
325  region = ctx->region_list;
326 
327  ctx->region_list = region->next;
328 
329  delete_region_display_list(ctx, region);
330  av_free(region->pbuf);
331  av_free(region);
332  }
333 
334  while (ctx->clut_list) {
335  clut = ctx->clut_list;
336 
337  ctx->clut_list = clut->next;
338 
339  av_free(clut);
340  }
341 
343 
344  /* Should already be null */
345  if (ctx->object_list)
346  av_log(0, AV_LOG_ERROR, "Memory deallocation error!\n");
347 }
348 
350 {
351  int i, r, g, b, a = 0;
352  DVBSubContext *ctx = avctx->priv_data;
353 
354  if (!avctx->extradata || avctx->extradata_size != 4) {
355  av_log(avctx, AV_LOG_WARNING, "Invalid extradata, subtitle streams may be combined!\n");
356  ctx->composition_id = -1;
357  ctx->ancillary_id = -1;
358  } else {
359  ctx->composition_id = AV_RB16(avctx->extradata);
360  ctx->ancillary_id = AV_RB16(avctx->extradata + 2);
361  }
362 
363  default_clut.id = -1;
364  default_clut.next = NULL;
365 
366  default_clut.clut4[0] = RGBA( 0, 0, 0, 0);
367  default_clut.clut4[1] = RGBA(255, 255, 255, 255);
368  default_clut.clut4[2] = RGBA( 0, 0, 0, 255);
369  default_clut.clut4[3] = RGBA(127, 127, 127, 255);
370 
371  default_clut.clut16[0] = RGBA( 0, 0, 0, 0);
372  for (i = 1; i < 16; i++) {
373  if (i < 8) {
374  r = (i & 1) ? 255 : 0;
375  g = (i & 2) ? 255 : 0;
376  b = (i & 4) ? 255 : 0;
377  } else {
378  r = (i & 1) ? 127 : 0;
379  g = (i & 2) ? 127 : 0;
380  b = (i & 4) ? 127 : 0;
381  }
382  default_clut.clut16[i] = RGBA(r, g, b, 255);
383  }
384 
385  default_clut.clut256[0] = RGBA( 0, 0, 0, 0);
386  for (i = 1; i < 256; i++) {
387  if (i < 8) {
388  r = (i & 1) ? 255 : 0;
389  g = (i & 2) ? 255 : 0;
390  b = (i & 4) ? 255 : 0;
391  a = 63;
392  } else {
393  switch (i & 0x88) {
394  case 0x00:
395  r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
396  g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
397  b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
398  a = 255;
399  break;
400  case 0x08:
401  r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
402  g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
403  b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
404  a = 127;
405  break;
406  case 0x80:
407  r = 127 + ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
408  g = 127 + ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
409  b = 127 + ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
410  a = 255;
411  break;
412  case 0x88:
413  r = ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
414  g = ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
415  b = ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
416  a = 255;
417  break;
418  }
419  }
420  default_clut.clut256[i] = RGBA(r, g, b, a);
421  }
422 
423  return 0;
424 }
425 
427 {
428  DVBSubContext *ctx = avctx->priv_data;
429  DVBSubRegionDisplay *display;
430 
431  delete_state(ctx);
432 
433  while (ctx->display_list) {
434  display = ctx->display_list;
435  ctx->display_list = display->next;
436 
437  av_free(display);
438  }
439 
440  return 0;
441 }
442 
443 static int dvbsub_read_2bit_string(uint8_t *destbuf, int dbuf_len,
444  const uint8_t **srcbuf, int buf_size,
445  int non_mod, uint8_t *map_table)
446 {
447  GetBitContext gb;
448 
449  int bits;
450  int run_length;
451  int pixels_read = 0;
452 
453  init_get_bits(&gb, *srcbuf, buf_size << 3);
454 
455  while (get_bits_count(&gb) < buf_size << 3 && pixels_read < dbuf_len) {
456  bits = get_bits(&gb, 2);
457 
458  if (bits) {
459  if (non_mod != 1 || bits != 1) {
460  if (map_table)
461  *destbuf++ = map_table[bits];
462  else
463  *destbuf++ = bits;
464  }
465  pixels_read++;
466  } else {
467  bits = get_bits1(&gb);
468  if (bits == 1) {
469  run_length = get_bits(&gb, 3) + 3;
470  bits = get_bits(&gb, 2);
471 
472  if (non_mod == 1 && bits == 1)
473  pixels_read += run_length;
474  else {
475  if (map_table)
476  bits = map_table[bits];
477  while (run_length-- > 0 && pixels_read < dbuf_len) {
478  *destbuf++ = bits;
479  pixels_read++;
480  }
481  }
482  } else {
483  bits = get_bits1(&gb);
484  if (bits == 0) {
485  bits = get_bits(&gb, 2);
486  if (bits == 2) {
487  run_length = get_bits(&gb, 4) + 12;
488  bits = get_bits(&gb, 2);
489 
490  if (non_mod == 1 && bits == 1)
491  pixels_read += run_length;
492  else {
493  if (map_table)
494  bits = map_table[bits];
495  while (run_length-- > 0 && pixels_read < dbuf_len) {
496  *destbuf++ = bits;
497  pixels_read++;
498  }
499  }
500  } else if (bits == 3) {
501  run_length = get_bits(&gb, 8) + 29;
502  bits = get_bits(&gb, 2);
503 
504  if (non_mod == 1 && bits == 1)
505  pixels_read += run_length;
506  else {
507  if (map_table)
508  bits = map_table[bits];
509  while (run_length-- > 0 && pixels_read < dbuf_len) {
510  *destbuf++ = bits;
511  pixels_read++;
512  }
513  }
514  } else if (bits == 1) {
515  pixels_read += 2;
516  if (map_table)
517  bits = map_table[0];
518  else
519  bits = 0;
520  if (pixels_read <= dbuf_len) {
521  *destbuf++ = bits;
522  *destbuf++ = bits;
523  }
524  } else {
525  (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
526  return pixels_read;
527  }
528  } else {
529  if (map_table)
530  bits = map_table[0];
531  else
532  bits = 0;
533  *destbuf++ = bits;
534  pixels_read++;
535  }
536  }
537  }
538  }
539 
540  if (get_bits(&gb, 6))
541  av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
542 
543  (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
544 
545  return pixels_read;
546 }
547 
548 static int dvbsub_read_4bit_string(uint8_t *destbuf, int dbuf_len,
549  const uint8_t **srcbuf, int buf_size,
550  int non_mod, uint8_t *map_table)
551 {
552  GetBitContext gb;
553 
554  int bits;
555  int run_length;
556  int pixels_read = 0;
557 
558  init_get_bits(&gb, *srcbuf, buf_size << 3);
559 
560  while (get_bits_count(&gb) < buf_size << 3 && pixels_read < dbuf_len) {
561  bits = get_bits(&gb, 4);
562 
563  if (bits) {
564  if (non_mod != 1 || bits != 1) {
565  if (map_table)
566  *destbuf++ = map_table[bits];
567  else
568  *destbuf++ = bits;
569  }
570  pixels_read++;
571  } else {
572  bits = get_bits1(&gb);
573  if (bits == 0) {
574  run_length = get_bits(&gb, 3);
575 
576  if (run_length == 0) {
577  (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
578  return pixels_read;
579  }
580 
581  run_length += 2;
582 
583  if (map_table)
584  bits = map_table[0];
585  else
586  bits = 0;
587 
588  while (run_length-- > 0 && pixels_read < dbuf_len) {
589  *destbuf++ = bits;
590  pixels_read++;
591  }
592  } else {
593  bits = get_bits1(&gb);
594  if (bits == 0) {
595  run_length = get_bits(&gb, 2) + 4;
596  bits = get_bits(&gb, 4);
597 
598  if (non_mod == 1 && bits == 1)
599  pixels_read += run_length;
600  else {
601  if (map_table)
602  bits = map_table[bits];
603  while (run_length-- > 0 && pixels_read < dbuf_len) {
604  *destbuf++ = bits;
605  pixels_read++;
606  }
607  }
608  } else {
609  bits = get_bits(&gb, 2);
610  if (bits == 2) {
611  run_length = get_bits(&gb, 4) + 9;
612  bits = get_bits(&gb, 4);
613 
614  if (non_mod == 1 && bits == 1)
615  pixels_read += run_length;
616  else {
617  if (map_table)
618  bits = map_table[bits];
619  while (run_length-- > 0 && pixels_read < dbuf_len) {
620  *destbuf++ = bits;
621  pixels_read++;
622  }
623  }
624  } else if (bits == 3) {
625  run_length = get_bits(&gb, 8) + 25;
626  bits = get_bits(&gb, 4);
627 
628  if (non_mod == 1 && bits == 1)
629  pixels_read += run_length;
630  else {
631  if (map_table)
632  bits = map_table[bits];
633  while (run_length-- > 0 && pixels_read < dbuf_len) {
634  *destbuf++ = bits;
635  pixels_read++;
636  }
637  }
638  } else if (bits == 1) {
639  pixels_read += 2;
640  if (map_table)
641  bits = map_table[0];
642  else
643  bits = 0;
644  if (pixels_read <= dbuf_len) {
645  *destbuf++ = bits;
646  *destbuf++ = bits;
647  }
648  } else {
649  if (map_table)
650  bits = map_table[0];
651  else
652  bits = 0;
653  *destbuf++ = bits;
654  pixels_read ++;
655  }
656  }
657  }
658  }
659  }
660 
661  if (get_bits(&gb, 8))
662  av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
663 
664  (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
665 
666  return pixels_read;
667 }
668 
669 static int dvbsub_read_8bit_string(uint8_t *destbuf, int dbuf_len,
670  const uint8_t **srcbuf, int buf_size,
671  int non_mod, uint8_t *map_table)
672 {
673  const uint8_t *sbuf_end = (*srcbuf) + buf_size;
674  int bits;
675  int run_length;
676  int pixels_read = 0;
677 
678  while (*srcbuf < sbuf_end && pixels_read < dbuf_len) {
679  bits = *(*srcbuf)++;
680 
681  if (bits) {
682  if (non_mod != 1 || bits != 1) {
683  if (map_table)
684  *destbuf++ = map_table[bits];
685  else
686  *destbuf++ = bits;
687  }
688  pixels_read++;
689  } else {
690  bits = *(*srcbuf)++;
691  run_length = bits & 0x7f;
692  if ((bits & 0x80) == 0) {
693  if (run_length == 0) {
694  return pixels_read;
695  }
696 
697  if (map_table)
698  bits = map_table[0];
699  else
700  bits = 0;
701  while (run_length-- > 0 && pixels_read < dbuf_len) {
702  *destbuf++ = bits;
703  pixels_read++;
704  }
705  } else {
706  bits = *(*srcbuf)++;
707 
708  if (non_mod == 1 && bits == 1)
709  pixels_read += run_length;
710  if (map_table)
711  bits = map_table[bits];
712  else while (run_length-- > 0 && pixels_read < dbuf_len) {
713  *destbuf++ = bits;
714  pixels_read++;
715  }
716  }
717  }
718  }
719 
720  if (*(*srcbuf)++)
721  av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
722 
723  return pixels_read;
724 }
725 
726 
727 
729  const uint8_t *buf, int buf_size, int top_bottom, int non_mod)
730 {
731  DVBSubContext *ctx = avctx->priv_data;
732 
733  DVBSubRegion *region = get_region(ctx, display->region_id);
734  const uint8_t *buf_end = buf + buf_size;
735  uint8_t *pbuf;
736  int x_pos, y_pos;
737  int i;
738 
739  uint8_t map2to4[] = { 0x0, 0x7, 0x8, 0xf};
740  uint8_t map2to8[] = {0x00, 0x77, 0x88, 0xff};
741  uint8_t map4to8[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
742  0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
743  uint8_t *map_table;
744 
745  av_dlog(avctx, "DVB pixel block size %d, %s field:\n", buf_size,
746  top_bottom ? "bottom" : "top");
747 
748  for (i = 0; i < buf_size; i++) {
749  if (i % 16 == 0)
750  av_dlog(avctx, "0x%8p: ", buf+i);
751 
752  av_dlog(avctx, "%02x ", buf[i]);
753  if (i % 16 == 15)
754  av_dlog(avctx, "\n");
755  }
756 
757  if (i % 16)
758  av_dlog(avctx, "\n");
759 
760  if (region == 0)
761  return;
762 
763  pbuf = region->pbuf;
764 
765  x_pos = display->x_pos;
766  y_pos = display->y_pos;
767 
768  if ((y_pos & 1) != top_bottom)
769  y_pos++;
770 
771  while (buf < buf_end) {
772  if (x_pos > region->width || y_pos > region->height) {
773  av_log(avctx, AV_LOG_ERROR, "Invalid object location!\n");
774  return;
775  }
776 
777  switch (*buf++) {
778  case 0x10:
779  if (region->depth == 8)
780  map_table = map2to8;
781  else if (region->depth == 4)
782  map_table = map2to4;
783  else
784  map_table = NULL;
785 
786  x_pos += dvbsub_read_2bit_string(pbuf + (y_pos * region->width) + x_pos,
787  region->width - x_pos, &buf, buf_end - buf,
788  non_mod, map_table);
789  break;
790  case 0x11:
791  if (region->depth < 4) {
792  av_log(avctx, AV_LOG_ERROR, "4-bit pixel string in %d-bit region!\n", region->depth);
793  return;
794  }
795 
796  if (region->depth == 8)
797  map_table = map4to8;
798  else
799  map_table = NULL;
800 
801  x_pos += dvbsub_read_4bit_string(pbuf + (y_pos * region->width) + x_pos,
802  region->width - x_pos, &buf, buf_end - buf,
803  non_mod, map_table);
804  break;
805  case 0x12:
806  if (region->depth < 8) {
807  av_log(avctx, AV_LOG_ERROR, "8-bit pixel string in %d-bit region!\n", region->depth);
808  return;
809  }
810 
811  x_pos += dvbsub_read_8bit_string(pbuf + (y_pos * region->width) + x_pos,
812  region->width - x_pos, &buf, buf_end - buf,
813  non_mod, NULL);
814  break;
815 
816  case 0x20:
817  map2to4[0] = (*buf) >> 4;
818  map2to4[1] = (*buf++) & 0xf;
819  map2to4[2] = (*buf) >> 4;
820  map2to4[3] = (*buf++) & 0xf;
821  break;
822  case 0x21:
823  for (i = 0; i < 4; i++)
824  map2to8[i] = *buf++;
825  break;
826  case 0x22:
827  for (i = 0; i < 16; i++)
828  map4to8[i] = *buf++;
829  break;
830 
831  case 0xf0:
832  x_pos = display->x_pos;
833  y_pos += 2;
834  break;
835  default:
836  av_log(avctx, AV_LOG_INFO, "Unknown/unsupported pixel block 0x%x\n", *(buf-1));
837  }
838  }
839 
840 }
841 
843  const uint8_t *buf, int buf_size)
844 {
845  DVBSubContext *ctx = avctx->priv_data;
846 
847  const uint8_t *buf_end = buf + buf_size;
848  const uint8_t *block;
849  int object_id;
850  DVBSubObject *object;
851  DVBSubObjectDisplay *display;
852  int top_field_len, bottom_field_len;
853 
854  int coding_method, non_modifying_color;
855 
856  object_id = AV_RB16(buf);
857  buf += 2;
858 
859  object = get_object(ctx, object_id);
860 
861  if (!object)
862  return;
863 
864  coding_method = ((*buf) >> 2) & 3;
865  non_modifying_color = ((*buf++) >> 1) & 1;
866 
867  if (coding_method == 0) {
868  top_field_len = AV_RB16(buf);
869  buf += 2;
870  bottom_field_len = AV_RB16(buf);
871  buf += 2;
872 
873  if (buf + top_field_len + bottom_field_len > buf_end) {
874  av_log(avctx, AV_LOG_ERROR, "Field data size too large\n");
875  return;
876  }
877 
878  for (display = object->display_list; display; display = display->object_list_next) {
879  block = buf;
880 
881  dvbsub_parse_pixel_data_block(avctx, display, block, top_field_len, 0,
882  non_modifying_color);
883 
884  if (bottom_field_len > 0)
885  block = buf + top_field_len;
886  else
887  bottom_field_len = top_field_len;
888 
889  dvbsub_parse_pixel_data_block(avctx, display, block, bottom_field_len, 1,
890  non_modifying_color);
891  }
892 
893 /* } else if (coding_method == 1) {*/
894 
895  } else {
896  av_log(avctx, AV_LOG_ERROR, "Unknown object coding %d\n", coding_method);
897  }
898 
899 }
900 
902  const uint8_t *buf, int buf_size)
903 {
904  DVBSubContext *ctx = avctx->priv_data;
905 
906  const uint8_t *buf_end = buf + buf_size;
907  int i, clut_id;
908  DVBSubCLUT *clut;
909  int entry_id, depth , full_range;
910  int y, cr, cb, alpha;
911  int r, g, b, r_add, g_add, b_add;
912 
913  av_dlog(avctx, "DVB clut packet:\n");
914 
915  for (i=0; i < buf_size; i++) {
916  av_dlog(avctx, "%02x ", buf[i]);
917  if (i % 16 == 15)
918  av_dlog(avctx, "\n");
919  }
920 
921  if (i % 16)
922  av_dlog(avctx, "\n");
923 
924  clut_id = *buf++;
925  buf += 1;
926 
927  clut = get_clut(ctx, clut_id);
928 
929  if (!clut) {
930  clut = av_malloc(sizeof(DVBSubCLUT));
931 
932  memcpy(clut, &default_clut, sizeof(DVBSubCLUT));
933 
934  clut->id = clut_id;
935 
936  clut->next = ctx->clut_list;
937  ctx->clut_list = clut;
938  }
939 
940  while (buf + 4 < buf_end) {
941  entry_id = *buf++;
942 
943  depth = (*buf) & 0xe0;
944 
945  if (depth == 0) {
946  av_log(avctx, AV_LOG_ERROR, "Invalid clut depth 0x%x!\n", *buf);
947  return;
948  }
949 
950  full_range = (*buf++) & 1;
951 
952  if (full_range) {
953  y = *buf++;
954  cr = *buf++;
955  cb = *buf++;
956  alpha = *buf++;
957  } else {
958  y = buf[0] & 0xfc;
959  cr = (((buf[0] & 3) << 2) | ((buf[1] >> 6) & 3)) << 4;
960  cb = (buf[1] << 2) & 0xf0;
961  alpha = (buf[1] << 6) & 0xc0;
962 
963  buf += 2;
964  }
965 
966  if (y == 0)
967  alpha = 0xff;
968 
969  YUV_TO_RGB1_CCIR(cb, cr);
970  YUV_TO_RGB2_CCIR(r, g, b, y);
971 
972  av_dlog(avctx, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);
973 
974  if (depth & 0x80)
975  clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha);
976  if (depth & 0x40)
977  clut->clut16[entry_id] = RGBA(r,g,b,255 - alpha);
978  if (depth & 0x20)
979  clut->clut256[entry_id] = RGBA(r,g,b,255 - alpha);
980  }
981 }
982 
983 
985  const uint8_t *buf, int buf_size)
986 {
987  DVBSubContext *ctx = avctx->priv_data;
988 
989  const uint8_t *buf_end = buf + buf_size;
990  int region_id, object_id;
991  DVBSubRegion *region;
992  DVBSubObject *object;
993  DVBSubObjectDisplay *display;
994  int fill;
995 
996  if (buf_size < 10)
997  return;
998 
999  region_id = *buf++;
1000 
1001  region = get_region(ctx, region_id);
1002 
1003  if (!region) {
1004  region = av_mallocz(sizeof(DVBSubRegion));
1005 
1006  region->id = region_id;
1007 
1008  region->next = ctx->region_list;
1009  ctx->region_list = region;
1010  }
1011 
1012  fill = ((*buf++) >> 3) & 1;
1013 
1014  region->width = AV_RB16(buf);
1015  buf += 2;
1016  region->height = AV_RB16(buf);
1017  buf += 2;
1018 
1019  if (region->width * region->height != region->buf_size) {
1020  av_free(region->pbuf);
1021 
1022  region->buf_size = region->width * region->height;
1023 
1024  region->pbuf = av_malloc(region->buf_size);
1025 
1026  fill = 1;
1027  }
1028 
1029  region->depth = 1 << (((*buf++) >> 2) & 7);
1030  if(region->depth<2 || region->depth>8){
1031  av_log(avctx, AV_LOG_ERROR, "region depth %d is invalid\n", region->depth);
1032  region->depth= 4;
1033  }
1034  region->clut = *buf++;
1035 
1036  if (region->depth == 8)
1037  region->bgcolor = *buf++;
1038  else {
1039  buf += 1;
1040 
1041  if (region->depth == 4)
1042  region->bgcolor = (((*buf++) >> 4) & 15);
1043  else
1044  region->bgcolor = (((*buf++) >> 2) & 3);
1045  }
1046 
1047  av_dlog(avctx, "Region %d, (%dx%d)\n", region_id, region->width, region->height);
1048 
1049  if (fill) {
1050  memset(region->pbuf, region->bgcolor, region->buf_size);
1051  av_dlog(avctx, "Fill region (%d)\n", region->bgcolor);
1052  }
1053 
1054  delete_region_display_list(ctx, region);
1055 
1056  while (buf + 5 < buf_end) {
1057  object_id = AV_RB16(buf);
1058  buf += 2;
1059 
1060  object = get_object(ctx, object_id);
1061 
1062  if (!object) {
1063  object = av_mallocz(sizeof(DVBSubObject));
1064 
1065  object->id = object_id;
1066  object->next = ctx->object_list;
1067  ctx->object_list = object;
1068  }
1069 
1070  object->type = (*buf) >> 6;
1071 
1072  display = av_mallocz(sizeof(DVBSubObjectDisplay));
1073 
1074  display->object_id = object_id;
1075  display->region_id = region_id;
1076 
1077  display->x_pos = AV_RB16(buf) & 0xfff;
1078  buf += 2;
1079  display->y_pos = AV_RB16(buf) & 0xfff;
1080  buf += 2;
1081 
1082  if ((object->type == 1 || object->type == 2) && buf+1 < buf_end) {
1083  display->fgcolor = *buf++;
1084  display->bgcolor = *buf++;
1085  }
1086 
1087  display->region_list_next = region->display_list;
1088  region->display_list = display;
1089 
1090  display->object_list_next = object->display_list;
1091  object->display_list = display;
1092  }
1093 }
1094 
1096  const uint8_t *buf, int buf_size)
1097 {
1098  DVBSubContext *ctx = avctx->priv_data;
1099  DVBSubRegionDisplay *display;
1100  DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;
1101 
1102  const uint8_t *buf_end = buf + buf_size;
1103  int region_id;
1104  int page_state;
1105 
1106  if (buf_size < 1)
1107  return;
1108 
1109  ctx->time_out = *buf++;
1110  page_state = ((*buf++) >> 2) & 3;
1111 
1112  av_dlog(avctx, "Page time out %ds, state %d\n", ctx->time_out, page_state);
1113 
1114  if (page_state == 2) {
1115  delete_state(ctx);
1116  }
1117 
1118  tmp_display_list = ctx->display_list;
1119  ctx->display_list = NULL;
1120  ctx->display_list_size = 0;
1121 
1122  while (buf + 5 < buf_end) {
1123  region_id = *buf++;
1124  buf += 1;
1125 
1126  display = tmp_display_list;
1127  tmp_ptr = &tmp_display_list;
1128 
1129  while (display && display->region_id != region_id) {
1130  tmp_ptr = &display->next;
1131  display = display->next;
1132  }
1133 
1134  if (!display)
1135  display = av_mallocz(sizeof(DVBSubRegionDisplay));
1136 
1137  display->region_id = region_id;
1138 
1139  display->x_pos = AV_RB16(buf);
1140  buf += 2;
1141  display->y_pos = AV_RB16(buf);
1142  buf += 2;
1143 
1144  *tmp_ptr = display->next;
1145 
1146  display->next = ctx->display_list;
1147  ctx->display_list = display;
1148  ctx->display_list_size++;
1149 
1150  av_dlog(avctx, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
1151  }
1152 
1153  while (tmp_display_list) {
1154  display = tmp_display_list;
1155 
1156  tmp_display_list = display->next;
1157 
1158  av_free(display);
1159  }
1160 
1161 }
1162 
1163 
1164 #ifdef DEBUG
1165 static void save_display_set(DVBSubContext *ctx)
1166 {
1167  DVBSubRegion *region;
1168  DVBSubRegionDisplay *display;
1169  DVBSubCLUT *clut;
1170  uint32_t *clut_table;
1171  int x_pos, y_pos, width, height;
1172  int x, y, y_off, x_off;
1173  uint32_t *pbuf;
1174  char filename[32];
1175  static int fileno_index = 0;
1176 
1177  x_pos = -1;
1178  y_pos = -1;
1179  width = 0;
1180  height = 0;
1181 
1182  for (display = ctx->display_list; display; display = display->next) {
1183  region = get_region(ctx, display->region_id);
1184 
1185  if (x_pos == -1) {
1186  x_pos = display->x_pos;
1187  y_pos = display->y_pos;
1188  width = region->width;
1189  height = region->height;
1190  } else {
1191  if (display->x_pos < x_pos) {
1192  width += (x_pos - display->x_pos);
1193  x_pos = display->x_pos;
1194  }
1195 
1196  if (display->y_pos < y_pos) {
1197  height += (y_pos - display->y_pos);
1198  y_pos = display->y_pos;
1199  }
1200 
1201  if (display->x_pos + region->width > x_pos + width) {
1202  width = display->x_pos + region->width - x_pos;
1203  }
1204 
1205  if (display->y_pos + region->height > y_pos + height) {
1206  height = display->y_pos + region->height - y_pos;
1207  }
1208  }
1209  }
1210 
1211  if (x_pos >= 0) {
1212 
1213  pbuf = av_malloc(width * height * 4);
1214 
1215  for (display = ctx->display_list; display; display = display->next) {
1216  region = get_region(ctx, display->region_id);
1217 
1218  x_off = display->x_pos - x_pos;
1219  y_off = display->y_pos - y_pos;
1220 
1221  clut = get_clut(ctx, region->clut);
1222 
1223  if (clut == 0)
1224  clut = &default_clut;
1225 
1226  switch (region->depth) {
1227  case 2:
1228  clut_table = clut->clut4;
1229  break;
1230  case 8:
1231  clut_table = clut->clut256;
1232  break;
1233  case 4:
1234  default:
1235  clut_table = clut->clut16;
1236  break;
1237  }
1238 
1239  for (y = 0; y < region->height; y++) {
1240  for (x = 0; x < region->width; x++) {
1241  pbuf[((y + y_off) * width) + x_off + x] =
1242  clut_table[region->pbuf[y * region->width + x]];
1243  }
1244  }
1245 
1246  }
1247 
1248  snprintf(filename, sizeof(filename), "dvbs.%d", fileno_index);
1249 
1250  png_save2(filename, pbuf, width, height);
1251 
1252  av_free(pbuf);
1253  }
1254 
1255  fileno_index++;
1256 }
1257 #endif
1258 
1260  const uint8_t *buf,
1261  int buf_size)
1262 {
1263  DVBSubContext *ctx = avctx->priv_data;
1264  DVBSubDisplayDefinition *display_def = ctx->display_definition;
1265  int dds_version, info_byte;
1266 
1267  if (buf_size < 5)
1268  return;
1269 
1270  info_byte = bytestream_get_byte(&buf);
1271  dds_version = info_byte >> 4;
1272  if (display_def && display_def->version == dds_version)
1273  return; // already have this display definition version
1274 
1275  if (!display_def) {
1276  display_def = av_mallocz(sizeof(*display_def));
1277  ctx->display_definition = display_def;
1278  }
1279  if (!display_def)
1280  return;
1281 
1282  display_def->version = dds_version;
1283  display_def->x = 0;
1284  display_def->y = 0;
1285  display_def->width = bytestream_get_be16(&buf) + 1;
1286  display_def->height = bytestream_get_be16(&buf) + 1;
1287 
1288  if (buf_size < 13)
1289  return;
1290 
1291  if (info_byte & 1<<3) { // display_window_flag
1292  display_def->x = bytestream_get_be16(&buf);
1293  display_def->y = bytestream_get_be16(&buf);
1294  display_def->width = bytestream_get_be16(&buf) - display_def->x + 1;
1295  display_def->height = bytestream_get_be16(&buf) - display_def->y + 1;
1296  }
1297 }
1298 
1299 static int dvbsub_display_end_segment(AVCodecContext *avctx, const uint8_t *buf,
1300  int buf_size, AVSubtitle *sub)
1301 {
1302  DVBSubContext *ctx = avctx->priv_data;
1303  DVBSubDisplayDefinition *display_def = ctx->display_definition;
1304 
1305  DVBSubRegion *region;
1306  DVBSubRegionDisplay *display;
1307  AVSubtitleRect *rect;
1308  DVBSubCLUT *clut;
1309  uint32_t *clut_table;
1310  int i;
1311  int offset_x=0, offset_y=0;
1312 
1313  sub->rects = NULL;
1314  sub->start_display_time = 0;
1315  sub->end_display_time = ctx->time_out * 1000;
1316  sub->format = 0;
1317 
1318  if (display_def) {
1319  offset_x = display_def->x;
1320  offset_y = display_def->y;
1321  }
1322 
1323  sub->num_rects = ctx->display_list_size;
1324 
1325  if (sub->num_rects > 0){
1326  sub->rects = av_mallocz(sizeof(*sub->rects) * sub->num_rects);
1327  for(i=0; i<sub->num_rects; i++)
1328  sub->rects[i] = av_mallocz(sizeof(*sub->rects[i]));
1329  }
1330 
1331  i = 0;
1332 
1333  for (display = ctx->display_list; display; display = display->next) {
1334  region = get_region(ctx, display->region_id);
1335  rect = sub->rects[i];
1336 
1337  if (!region)
1338  continue;
1339 
1340  rect->x = display->x_pos + offset_x;
1341  rect->y = display->y_pos + offset_y;
1342  rect->w = region->width;
1343  rect->h = region->height;
1344  rect->nb_colors = 16;
1345  rect->type = SUBTITLE_BITMAP;
1346  rect->pict.linesize[0] = region->width;
1347 
1348  clut = get_clut(ctx, region->clut);
1349 
1350  if (!clut)
1351  clut = &default_clut;
1352 
1353  switch (region->depth) {
1354  case 2:
1355  clut_table = clut->clut4;
1356  break;
1357  case 8:
1358  clut_table = clut->clut256;
1359  break;
1360  case 4:
1361  default:
1362  clut_table = clut->clut16;
1363  break;
1364  }
1365 
1366  rect->pict.data[1] = av_mallocz(AVPALETTE_SIZE);
1367  memcpy(rect->pict.data[1], clut_table, (1 << region->depth) * sizeof(uint32_t));
1368 
1369  rect->pict.data[0] = av_malloc(region->buf_size);
1370  memcpy(rect->pict.data[0], region->pbuf, region->buf_size);
1371 
1372  i++;
1373  }
1374 
1375  sub->num_rects = i;
1376 
1377 #ifdef DEBUG
1378  save_display_set(ctx);
1379 #endif
1380 
1381  return 1;
1382 }
1383 
1384 static int dvbsub_decode(AVCodecContext *avctx,
1385  void *data, int *data_size,
1386  AVPacket *avpkt)
1387 {
1388  const uint8_t *buf = avpkt->data;
1389  int buf_size = avpkt->size;
1390  DVBSubContext *ctx = avctx->priv_data;
1391  AVSubtitle *sub = data;
1392  const uint8_t *p, *p_end;
1393  int segment_type;
1394  int page_id;
1395  int segment_length;
1396  int i;
1397 
1398  av_dlog(avctx, "DVB sub packet:\n");
1399 
1400  for (i=0; i < buf_size; i++) {
1401  av_dlog(avctx, "%02x ", buf[i]);
1402  if (i % 16 == 15)
1403  av_dlog(avctx, "\n");
1404  }
1405 
1406  if (i % 16)
1407  av_dlog(avctx, "\n");
1408 
1409  if (buf_size <= 6 || *buf != 0x0f) {
1410  av_dlog(avctx, "incomplete or broken packet");
1411  return -1;
1412  }
1413 
1414  p = buf;
1415  p_end = buf + buf_size;
1416 
1417  while (p_end - p >= 6 && *p == 0x0f) {
1418  p += 1;
1419  segment_type = *p++;
1420  page_id = AV_RB16(p);
1421  p += 2;
1422  segment_length = AV_RB16(p);
1423  p += 2;
1424 
1425  if (p_end - p < segment_length) {
1426  av_dlog(avctx, "incomplete or broken packet");
1427  return -1;
1428  }
1429 
1430  if (page_id == ctx->composition_id || page_id == ctx->ancillary_id ||
1431  ctx->composition_id == -1 || ctx->ancillary_id == -1) {
1432  switch (segment_type) {
1433  case DVBSUB_PAGE_SEGMENT:
1434  dvbsub_parse_page_segment(avctx, p, segment_length);
1435  break;
1436  case DVBSUB_REGION_SEGMENT:
1437  dvbsub_parse_region_segment(avctx, p, segment_length);
1438  break;
1439  case DVBSUB_CLUT_SEGMENT:
1440  dvbsub_parse_clut_segment(avctx, p, segment_length);
1441  break;
1442  case DVBSUB_OBJECT_SEGMENT:
1443  dvbsub_parse_object_segment(avctx, p, segment_length);
1444  break;
1446  dvbsub_parse_display_definition_segment(avctx, p, segment_length);
1448  *data_size = dvbsub_display_end_segment(avctx, p, segment_length, sub);
1449  break;
1450  default:
1451  av_dlog(avctx, "Subtitling segment type 0x%x, page id %d, length %d\n",
1452  segment_type, page_id, segment_length);
1453  break;
1454  }
1455  }
1456 
1457  p += segment_length;
1458  }
1459 
1460  return p - buf;
1461 }
1462 
1463 
1465  .name = "dvbsub",
1466  .long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"),
1467  .type = AVMEDIA_TYPE_SUBTITLE,
1469  .priv_data_size = sizeof(DVBSubContext),
1472  .decode = dvbsub_decode,
1473 };
#define AVPALETTE_SIZE
Definition: avcodec.h:2959
static DVBSubCLUT * get_clut(DVBSubContext *ctx, int clut_id)
Definition: dvbsubdec.c:251
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:62
static void dvbsub_parse_clut_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: dvbsubdec.c:901
int linesize[AV_NUM_DATA_POINTERS]
number of bytes per line
Definition: avcodec.h:2952
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:728
int x
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:2983
static DVBSubRegion * get_region(DVBSubContext *ctx, int region_id)
Definition: dvbsubdec.c:262
static int dvbsub_display_end_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size, AVSubtitle *sub)
Definition: dvbsubdec.c:1299
DVBSubRegionDisplay * display_list
Definition: dvbsubdec.c:235
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:240
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:129
#define YUV_TO_RGB1_CCIR(cb1, cr1)
Definition: colorspace.h:34
static void dvbsub_parse_region_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: dvbsubdec.c:984
int nb_colors
number of colors in pict, undefined when pict is not set
Definition: avcodec.h:2987
int size
Definition: avcodec.h:974
Various defines for YUV<->RGB conversion.
unsigned num_rects
Definition: avcodec.h:3011
#define RGBA(r, g, b, a)
Definition: dvbsubdec.c:151
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
static void dvbsub_parse_page_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: dvbsubdec.c:1095
AVCodec.
Definition: avcodec.h:2755
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
AVSubtitleRect ** rects
Definition: avcodec.h:3012
int w
width of pict, undefined when pict is not set
Definition: avcodec.h:2985
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:269
uint8_t bits
Definition: crc.c:216
uint8_t
#define av_cold
Definition: attributes.h:66
uint8_t * data[AV_NUM_DATA_POINTERS]
Definition: avcodec.h:2951
#define b
Definition: input.c:52
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1162
const char data[16]
Definition: mxf.c:66
uint8_t * data
Definition: avcodec.h:973
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:194
static int dvbsub_read_2bit_string(uint8_t *destbuf, int dbuf_len, const uint8_t **srcbuf, int buf_size, int non_mod, uint8_t *map_table)
Definition: dvbsubdec.c:443
bitstream reader API header.
static void delete_state(DVBSubContext *ctx)
Definition: dvbsubdec.c:319
int h
height of pict, undefined when pict is not set
Definition: avcodec.h:2986
DVBSubRegion * region_list
Definition: dvbsubdec.c:230
#define r
Definition: input.c:51
#define DVBSUB_DISPLAYDEFINITION_SEGMENT
Definition: dvbsubdec.c:31
struct DVBSubRegion * next
Definition: dvbsubdec.c:213
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:186
int y
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:2984
#define AV_RB16
Definition: intreadwrite.h:53
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:142
g
Definition: yuv2rgb.c:535
static DVBSubCLUT default_clut
Definition: dvbsubdec.c:163
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:148
const char * name
Name of the codec implementation.
Definition: avcodec.h:2762
uint32_t end_display_time
Definition: avcodec.h:3010
static void dvbsub_parse_display_definition_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: dvbsubdec.c:1259
struct DVBSubObject * next
Definition: dvbsubdec.c:186
AVCodec ff_dvbsub_decoder
Definition: dvbsubdec.c:1464
A bitmap, pict will be set.
Definition: avcodec.h:2965
AVPicture pict
data+linesize for the bitmap of this subtitle.
Definition: avcodec.h:2993
int composition_id
Definition: dvbsubdec.c:226
DVBSubObjectDisplay * display_list
Definition: dvbsubdec.c:211
struct DVBSubObjectDisplay * region_list_next
Definition: dvbsubdec.c:175
struct DVBSubCLUT * next
Definition: dvbsubdec.c:160
uint16_t format
Definition: avcodec.h:3008
uint32_t clut16[16]
Definition: dvbsubdec.c:157
DVBSubObjectDisplay * display_list
Definition: dvbsubdec.c:184
DVBSubDisplayDefinition * display_definition
Definition: dvbsubdec.c:236
NULL
Definition: eval.c:55
static int width
Definition: utils.c:156
#define AV_LOG_INFO
Standard information.
Definition: log.h:134
#define DVBSUB_CLUT_SEGMENT
Definition: dvbsubdec.c:29
Libavcodec external API header.
uint8_t * pbuf
Definition: dvbsubdec.c:208
uint32_t clut256[256]
Definition: dvbsubdec.c:158
main external API structure.
Definition: avcodec.h:1054
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:489
DVBSubCLUT * clut_list
Definition: dvbsubdec.c:231
static DVBSubObject * get_object(DVBSubContext *ctx, int object_id)
Definition: dvbsubdec.c:240
int extradata_size
Definition: avcodec.h:1163
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:271
static void delete_region_display_list(DVBSubContext *ctx, DVBSubRegion *region)
Definition: dvbsubdec.c:273
#define DVBSUB_DISPLAY_SEGMENT
Definition: dvbsubdec.c:32
struct DVBSubRegionDisplay * next
Definition: dvbsubdec.c:195
#define YUV_TO_RGB2_CCIR(r, g, b, y1)
Definition: colorspace.h:44
struct DVBSubObjectDisplay * object_list_next
Definition: dvbsubdec.c:176
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:375
#define DVBSUB_PAGE_SEGMENT
Definition: dvbsubdec.c:27
uint32_t clut4[4]
Definition: dvbsubdec.c:156
static av_cold int dvbsub_init_decoder(AVCodecContext *avctx)
Definition: dvbsubdec.c:349
#define DVBSUB_REGION_SEGMENT
Definition: dvbsubdec.c:28
int height
Definition: gxfenc.c:72
int ancillary_id
Definition: dvbsubdec.c:227
uint32_t start_display_time
Definition: avcodec.h:3009
static int dvbsub_decode(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt)
Definition: dvbsubdec.c:1384
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:498
DSP utils.
void * priv_data
Definition: avcodec.h:1090
static int dvbsub_read_4bit_string(uint8_t *destbuf, int dbuf_len, const uint8_t **srcbuf, int buf_size, int non_mod, uint8_t *map_table)
Definition: dvbsubdec.c:548
static void dvbsub_parse_object_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: dvbsubdec.c:842
DVBSubObject * object_list
Definition: dvbsubdec.c:232
static int dvbsub_read_8bit_string(uint8_t *destbuf, int dbuf_len, const uint8_t **srcbuf, int buf_size, int non_mod, uint8_t *map_table)
Definition: dvbsubdec.c:669
#define DVBSUB_OBJECT_SEGMENT
Definition: dvbsubdec.c:30
enum AVSubtitleType type
Definition: avcodec.h:2994
static av_cold int dvbsub_close_decoder(AVCodecContext *avctx)
Definition: dvbsubdec.c:426
This structure stores compressed data.
Definition: avcodec.h:950
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:205
int display_list_size
Definition: dvbsubdec.c:234
static int16_t block[64]
Definition: dct-test.c:170