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