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