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