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