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