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