FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
dvbsubdec.c
Go to the documentation of this file.
1 /*
2  * DVB subtitle decoding
3  * Copyright (c) 2005 Ian Caulfield
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "avcodec.h"
23 #include "get_bits.h"
24 #include "bytestream.h"
25 #include "internal.h"
26 #include "libavutil/colorspace.h"
27 #include "libavutil/imgutils.h"
28 #include "libavutil/opt.h"
29 
30 #define DVBSUB_PAGE_SEGMENT 0x10
31 #define DVBSUB_REGION_SEGMENT 0x11
32 #define DVBSUB_CLUT_SEGMENT 0x12
33 #define DVBSUB_OBJECT_SEGMENT 0x13
34 #define DVBSUB_DISPLAYDEFINITION_SEGMENT 0x14
35 #define DVBSUB_DISPLAY_SEGMENT 0x80
36 
37 #define cm (ff_crop_tab + MAX_NEG_CROP)
38 
39 #define RGBA(r,g,b,a) (((unsigned)(a) << 24) | ((r) << 16) | ((g) << 8) | (b))
40 
41 typedef struct DVBSubCLUT {
42  int id;
43  int version;
44 
45  uint32_t clut4[4];
46  uint32_t clut16[16];
47  uint32_t clut256[256];
48 
49  struct DVBSubCLUT *next;
50 } DVBSubCLUT;
51 
53 
54 typedef struct DVBSubObjectDisplay {
55  int object_id;
56  int region_id;
57 
58  int x_pos;
59  int y_pos;
60 
61  int fgcolor;
62  int bgcolor;
63 
67 
68 typedef struct DVBSubObject {
69  int id;
70  int version;
71 
72  int type;
73 
75 
76  struct DVBSubObject *next;
77 } DVBSubObject;
78 
79 typedef struct DVBSubRegionDisplay {
80  int region_id;
81 
82  int x_pos;
83  int y_pos;
84 
87 
88 typedef struct DVBSubRegion {
89  int id;
90  int version;
91 
92  int width;
93  int height;
94  int depth;
95 
96  int clut;
97  int bgcolor;
98 
101 
103  int buf_size;
104  int dirty;
105 
107 
109 } DVBSubRegion;
110 
111 typedef struct DVBSubDisplayDefinition {
112  int version;
113 
114  int x;
115  int y;
116  int width;
117  int height;
119 
120 typedef struct DVBSubContext {
121  AVClass *class;
124 
125  int version;
126  int time_out;
127  int compute_edt; /**< if 1 end display time calculated using pts
128  if 0 (Default) calculated using time out */
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 
250  delete_region_display_list(ctx, region);
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;
284  default_clut.next = NULL;
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 
351  delete_regions(ctx);
352 
353  delete_objects(ctx);
354 
355  delete_cluts(ctx);
356 
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(uint32_t));
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) {
828  compute_default_clut(ctx, region->computed_clut, rect, rect->w, rect->h);
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 
1036 /* } else if (coding_method == 1) {*/
1037 
1038  } else {
1039  av_log(avctx, AV_LOG_ERROR, "Unknown object coding %d\n", coding_method);
1040  }
1041 
1042  return 0;
1043 }
1044 
1046  const uint8_t *buf, int buf_size)
1047 {
1048  DVBSubContext *ctx = avctx->priv_data;
1049 
1050  const uint8_t *buf_end = buf + buf_size;
1051  int i, clut_id;
1052  int version;
1053  DVBSubCLUT *clut;
1054  int entry_id, depth , full_range;
1055  int y, cr, cb, alpha;
1056  int r, g, b, r_add, g_add, b_add;
1057 
1058  ff_dlog(avctx, "DVB clut packet:\n");
1059 
1060  for (i=0; i < buf_size; i++) {
1061  ff_dlog(avctx, "%02x ", buf[i]);
1062  if (i % 16 == 15)
1063  ff_dlog(avctx, "\n");
1064  }
1065 
1066  if (i % 16)
1067  ff_dlog(avctx, "\n");
1068 
1069  clut_id = *buf++;
1070  version = ((*buf)>>4)&15;
1071  buf += 1;
1072 
1073  clut = get_clut(ctx, clut_id);
1074 
1075  if (!clut) {
1076  clut = av_malloc(sizeof(DVBSubCLUT));
1077  if (!clut)
1078  return AVERROR(ENOMEM);
1079 
1080  memcpy(clut, &default_clut, sizeof(DVBSubCLUT));
1081 
1082  clut->id = clut_id;
1083  clut->version = -1;
1084 
1085  clut->next = ctx->clut_list;
1086  ctx->clut_list = clut;
1087  }
1088 
1089  if (clut->version != version) {
1090 
1091  clut->version = version;
1092 
1093  while (buf + 4 < buf_end) {
1094  entry_id = *buf++;
1095 
1096  depth = (*buf) & 0xe0;
1097 
1098  if (depth == 0) {
1099  av_log(avctx, AV_LOG_ERROR, "Invalid clut depth 0x%x!\n", *buf);
1100  }
1101 
1102  full_range = (*buf++) & 1;
1103 
1104  if (full_range) {
1105  y = *buf++;
1106  cr = *buf++;
1107  cb = *buf++;
1108  alpha = *buf++;
1109  } else {
1110  y = buf[0] & 0xfc;
1111  cr = (((buf[0] & 3) << 2) | ((buf[1] >> 6) & 3)) << 4;
1112  cb = (buf[1] << 2) & 0xf0;
1113  alpha = (buf[1] << 6) & 0xc0;
1114 
1115  buf += 2;
1116  }
1117 
1118  if (y == 0)
1119  alpha = 0xff;
1120 
1121  YUV_TO_RGB1_CCIR(cb, cr);
1122  YUV_TO_RGB2_CCIR(r, g, b, y);
1123 
1124  ff_dlog(avctx, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);
1125  if (!!(depth & 0x80) + !!(depth & 0x40) + !!(depth & 0x20) > 1) {
1126  ff_dlog(avctx, "More than one bit level marked: %x\n", depth);
1128  return AVERROR_INVALIDDATA;
1129  }
1130 
1131  if (depth & 0x80 && entry_id < 4)
1132  clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha);
1133  else if (depth & 0x40 && entry_id < 16)
1134  clut->clut16[entry_id] = RGBA(r,g,b,255 - alpha);
1135  else if (depth & 0x20)
1136  clut->clut256[entry_id] = RGBA(r,g,b,255 - alpha);
1137  }
1138  }
1139 
1140  return 0;
1141 }
1142 
1143 
1145  const uint8_t *buf, int buf_size)
1146 {
1147  DVBSubContext *ctx = avctx->priv_data;
1148 
1149  const uint8_t *buf_end = buf + buf_size;
1150  int region_id, object_id;
1151  int av_unused version;
1152  DVBSubRegion *region;
1153  DVBSubObject *object;
1154  DVBSubObjectDisplay *display;
1155  int fill;
1156  int ret;
1157 
1158  if (buf_size < 10)
1159  return AVERROR_INVALIDDATA;
1160 
1161  region_id = *buf++;
1162 
1163  region = get_region(ctx, region_id);
1164 
1165  if (!region) {
1166  region = av_mallocz(sizeof(DVBSubRegion));
1167  if (!region)
1168  return AVERROR(ENOMEM);
1169 
1170  region->id = region_id;
1171  region->version = -1;
1172 
1173  region->next = ctx->region_list;
1174  ctx->region_list = region;
1175  }
1176 
1177  version = ((*buf)>>4) & 15;
1178  fill = ((*buf++) >> 3) & 1;
1179 
1180  region->width = AV_RB16(buf);
1181  buf += 2;
1182  region->height = AV_RB16(buf);
1183  buf += 2;
1184 
1185  ret = av_image_check_size2(region->width, region->height, avctx->max_pixels, AV_PIX_FMT_PAL8, 0, avctx);
1186  if (ret >= 0 && region->width * region->height * 2 > 320 * 1024 * 8) {
1187  ret = AVERROR_INVALIDDATA;
1188  av_log(avctx, AV_LOG_ERROR, "Pixel buffer memory constraint violated\n");
1189  }
1190  if (ret < 0) {
1191  region->width= region->height= 0;
1192  return ret;
1193  }
1194 
1195  if (region->width * region->height != region->buf_size) {
1196  av_free(region->pbuf);
1197 
1198  region->buf_size = region->width * region->height;
1199 
1200  region->pbuf = av_malloc(region->buf_size);
1201  if (!region->pbuf) {
1202  region->buf_size =
1203  region->width =
1204  region->height = 0;
1205  return AVERROR(ENOMEM);
1206  }
1207 
1208  fill = 1;
1209  region->dirty = 0;
1210  }
1211 
1212  region->depth = 1 << (((*buf++) >> 2) & 7);
1213  if(region->depth<2 || region->depth>8){
1214  av_log(avctx, AV_LOG_ERROR, "region depth %d is invalid\n", region->depth);
1215  region->depth= 4;
1216  }
1217  region->clut = *buf++;
1218 
1219  if (region->depth == 8) {
1220  region->bgcolor = *buf++;
1221  buf += 1;
1222  } else {
1223  buf += 1;
1224 
1225  if (region->depth == 4)
1226  region->bgcolor = (((*buf++) >> 4) & 15);
1227  else
1228  region->bgcolor = (((*buf++) >> 2) & 3);
1229  }
1230 
1231  ff_dlog(avctx, "Region %d, (%dx%d)\n", region_id, region->width, region->height);
1232 
1233  if (fill) {
1234  memset(region->pbuf, region->bgcolor, region->buf_size);
1235  ff_dlog(avctx, "Fill region (%d)\n", region->bgcolor);
1236  }
1237 
1238  delete_region_display_list(ctx, region);
1239 
1240  while (buf + 5 < buf_end) {
1241  object_id = AV_RB16(buf);
1242  buf += 2;
1243 
1244  object = get_object(ctx, object_id);
1245 
1246  if (!object) {
1247  object = av_mallocz(sizeof(DVBSubObject));
1248  if (!object)
1249  return AVERROR(ENOMEM);
1250 
1251  object->id = object_id;
1252  object->next = ctx->object_list;
1253  ctx->object_list = object;
1254  }
1255 
1256  object->type = (*buf) >> 6;
1257 
1258  display = av_mallocz(sizeof(DVBSubObjectDisplay));
1259  if (!display)
1260  return AVERROR(ENOMEM);
1261 
1262  display->object_id = object_id;
1263  display->region_id = region_id;
1264 
1265  display->x_pos = AV_RB16(buf) & 0xfff;
1266  buf += 2;
1267  display->y_pos = AV_RB16(buf) & 0xfff;
1268  buf += 2;
1269 
1270  if ((object->type == 1 || object->type == 2) && buf+1 < buf_end) {
1271  display->fgcolor = *buf++;
1272  display->bgcolor = *buf++;
1273  }
1274 
1275  display->region_list_next = region->display_list;
1276  region->display_list = display;
1277 
1278  display->object_list_next = object->display_list;
1279  object->display_list = display;
1280  }
1281 
1282  return 0;
1283 }
1284 
1286  const uint8_t *buf, int buf_size, AVSubtitle *sub, int *got_output)
1287 {
1288  DVBSubContext *ctx = avctx->priv_data;
1289  DVBSubRegionDisplay *display;
1290  DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;
1291 
1292  const uint8_t *buf_end = buf + buf_size;
1293  int region_id;
1294  int page_state;
1295  int timeout;
1296  int version;
1297 
1298  if (buf_size < 1)
1299  return AVERROR_INVALIDDATA;
1300 
1301  timeout = *buf++;
1302  version = ((*buf)>>4) & 15;
1303  page_state = ((*buf++) >> 2) & 3;
1304 
1305  if (ctx->version == version) {
1306  return 0;
1307  }
1308 
1309  ctx->time_out = timeout;
1310  ctx->version = version;
1311 
1312  ff_dlog(avctx, "Page time out %ds, state %d\n", ctx->time_out, page_state);
1313 
1314  if(ctx->compute_edt == 1)
1315  save_subtitle_set(avctx, sub, got_output);
1316 
1317  if (page_state == 1 || page_state == 2) {
1318  delete_regions(ctx);
1319  delete_objects(ctx);
1320  delete_cluts(ctx);
1321  }
1322 
1323  tmp_display_list = ctx->display_list;
1324  ctx->display_list = NULL;
1325 
1326  while (buf + 5 < buf_end) {
1327  region_id = *buf++;
1328  buf += 1;
1329 
1330  display = ctx->display_list;
1331  while (display && display->region_id != region_id) {
1332  display = display->next;
1333  }
1334  if (display) {
1335  av_log(avctx, AV_LOG_ERROR, "duplicate region\n");
1336  break;
1337  }
1338 
1339  display = tmp_display_list;
1340  tmp_ptr = &tmp_display_list;
1341 
1342  while (display && display->region_id != region_id) {
1343  tmp_ptr = &display->next;
1344  display = display->next;
1345  }
1346 
1347  if (!display) {
1348  display = av_mallocz(sizeof(DVBSubRegionDisplay));
1349  if (!display)
1350  return AVERROR(ENOMEM);
1351  }
1352 
1353  display->region_id = region_id;
1354 
1355  display->x_pos = AV_RB16(buf);
1356  buf += 2;
1357  display->y_pos = AV_RB16(buf);
1358  buf += 2;
1359 
1360  *tmp_ptr = display->next;
1361 
1362  display->next = ctx->display_list;
1363  ctx->display_list = display;
1364 
1365  ff_dlog(avctx, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
1366  }
1367 
1368  while (tmp_display_list) {
1369  display = tmp_display_list;
1370 
1371  tmp_display_list = display->next;
1372 
1373  av_freep(&display);
1374  }
1375 
1376  return 0;
1377 }
1378 
1379 
1380 #ifdef DEBUG
1381 static void png_save(DVBSubContext *ctx, const char *filename, uint32_t *bitmap, int w, int h)
1382 {
1383  int x, y, v;
1384  FILE *f;
1385  char fname[40], fname2[40];
1386  char command[1024];
1387 
1388  snprintf(fname, sizeof(fname), "%s.ppm", filename);
1389 
1390  f = fopen(fname, "w");
1391  if (!f) {
1392  perror(fname);
1393  return;
1394  }
1395  fprintf(f, "P6\n"
1396  "%d %d\n"
1397  "%d\n",
1398  w, h, 255);
1399  for(y = 0; y < h; y++) {
1400  for(x = 0; x < w; x++) {
1401  v = bitmap[y * w + x];
1402  putc((v >> 16) & 0xff, f);
1403  putc((v >> 8) & 0xff, f);
1404  putc((v >> 0) & 0xff, f);
1405  }
1406  }
1407  fclose(f);
1408 
1409 
1410  snprintf(fname2, sizeof(fname2), "%s-a.pgm", filename);
1411 
1412  f = fopen(fname2, "w");
1413  if (!f) {
1414  perror(fname2);
1415  return;
1416  }
1417  fprintf(f, "P5\n"
1418  "%d %d\n"
1419  "%d\n",
1420  w, h, 255);
1421  for(y = 0; y < h; y++) {
1422  for(x = 0; x < w; x++) {
1423  v = bitmap[y * w + x];
1424  putc((v >> 24) & 0xff, f);
1425  }
1426  }
1427  fclose(f);
1428 
1429  snprintf(command, sizeof(command), "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
1430  if (system(command) != 0) {
1431  av_log(ctx, AV_LOG_ERROR, "Error running pnmtopng\n");
1432  return;
1433  }
1434 
1435  snprintf(command, sizeof(command), "rm %s %s", fname, fname2);
1436  if (system(command) != 0) {
1437  av_log(ctx, AV_LOG_ERROR, "Error removing %s and %s\n", fname, fname2);
1438  return;
1439  }
1440 }
1441 
1442 static int save_display_set(DVBSubContext *ctx)
1443 {
1444  DVBSubRegion *region;
1445  DVBSubRegionDisplay *display;
1446  DVBSubCLUT *clut;
1447  uint32_t *clut_table;
1448  int x_pos, y_pos, width, height;
1449  int x, y, y_off, x_off;
1450  uint32_t *pbuf;
1451  char filename[32];
1452  static int fileno_index = 0;
1453 
1454  x_pos = -1;
1455  y_pos = -1;
1456  width = 0;
1457  height = 0;
1458 
1459  for (display = ctx->display_list; display; display = display->next) {
1460  region = get_region(ctx, display->region_id);
1461 
1462  if (!region)
1463  return -1;
1464 
1465  if (x_pos == -1) {
1466  x_pos = display->x_pos;
1467  y_pos = display->y_pos;
1468  width = region->width;
1469  height = region->height;
1470  } else {
1471  if (display->x_pos < x_pos) {
1472  width += (x_pos - display->x_pos);
1473  x_pos = display->x_pos;
1474  }
1475 
1476  if (display->y_pos < y_pos) {
1477  height += (y_pos - display->y_pos);
1478  y_pos = display->y_pos;
1479  }
1480 
1481  if (display->x_pos + region->width > x_pos + width) {
1482  width = display->x_pos + region->width - x_pos;
1483  }
1484 
1485  if (display->y_pos + region->height > y_pos + height) {
1486  height = display->y_pos + region->height - y_pos;
1487  }
1488  }
1489  }
1490 
1491  if (x_pos >= 0) {
1492 
1493  pbuf = av_malloc(width * height * 4);
1494  if (!pbuf)
1495  return -1;
1496 
1497  for (display = ctx->display_list; display; display = display->next) {
1498  region = get_region(ctx, display->region_id);
1499 
1500  if (!region)
1501  return -1;
1502 
1503  x_off = display->x_pos - x_pos;
1504  y_off = display->y_pos - y_pos;
1505 
1506  clut = get_clut(ctx, region->clut);
1507 
1508  if (!clut)
1509  clut = &default_clut;
1510 
1511  switch (region->depth) {
1512  case 2:
1513  clut_table = clut->clut4;
1514  break;
1515  case 8:
1516  clut_table = clut->clut256;
1517  break;
1518  case 4:
1519  default:
1520  clut_table = clut->clut16;
1521  break;
1522  }
1523 
1524  for (y = 0; y < region->height; y++) {
1525  for (x = 0; x < region->width; x++) {
1526  pbuf[((y + y_off) * width) + x_off + x] =
1527  clut_table[region->pbuf[y * region->width + x]];
1528  }
1529  }
1530 
1531  }
1532 
1533  snprintf(filename, sizeof(filename), "dvbs.%d", fileno_index);
1534 
1535  png_save(ctx, filename, pbuf, width, height);
1536 
1537  av_freep(&pbuf);
1538  }
1539 
1540  fileno_index++;
1541  return 0;
1542 }
1543 #endif /* DEBUG */
1544 
1546  const uint8_t *buf,
1547  int buf_size)
1548 {
1549  DVBSubContext *ctx = avctx->priv_data;
1550  DVBSubDisplayDefinition *display_def = ctx->display_definition;
1551  int dds_version, info_byte;
1552 
1553  if (buf_size < 5)
1554  return AVERROR_INVALIDDATA;
1555 
1556  info_byte = bytestream_get_byte(&buf);
1557  dds_version = info_byte >> 4;
1558  if (display_def && display_def->version == dds_version)
1559  return 0; // already have this display definition version
1560 
1561  if (!display_def) {
1562  display_def = av_mallocz(sizeof(*display_def));
1563  if (!display_def)
1564  return AVERROR(ENOMEM);
1565  ctx->display_definition = display_def;
1566  }
1567 
1568  display_def->version = dds_version;
1569  display_def->x = 0;
1570  display_def->y = 0;
1571  display_def->width = bytestream_get_be16(&buf) + 1;
1572  display_def->height = bytestream_get_be16(&buf) + 1;
1573  if (!avctx->width || !avctx->height) {
1574  avctx->width = display_def->width;
1575  avctx->height = display_def->height;
1576  }
1577 
1578  if (info_byte & 1<<3) { // display_window_flag
1579  if (buf_size < 13)
1580  return AVERROR_INVALIDDATA;
1581 
1582  display_def->x = bytestream_get_be16(&buf);
1583  display_def->width = bytestream_get_be16(&buf) - display_def->x + 1;
1584  display_def->y = bytestream_get_be16(&buf);
1585  display_def->height = bytestream_get_be16(&buf) - display_def->y + 1;
1586  }
1587 
1588  return 0;
1589 }
1590 
1592  int buf_size, AVSubtitle *sub,int *got_output)
1593 {
1594  DVBSubContext *ctx = avctx->priv_data;
1595 
1596  if(ctx->compute_edt == 0)
1597  save_subtitle_set(avctx, sub, got_output);
1598 #ifdef DEBUG
1599  save_display_set(ctx);
1600 #endif
1601  return 0;
1602 }
1603 
1604 static int dvbsub_decode(AVCodecContext *avctx,
1605  void *data, int *data_size,
1606  AVPacket *avpkt)
1607 {
1608  const uint8_t *buf = avpkt->data;
1609  int buf_size = avpkt->size;
1610  DVBSubContext *ctx = avctx->priv_data;
1611  AVSubtitle *sub = data;
1612  const uint8_t *p, *p_end;
1613  int segment_type;
1614  int page_id;
1615  int segment_length;
1616  int i;
1617  int ret = 0;
1618  int got_segment = 0;
1619  int got_dds = 0;
1620 
1621  ff_dlog(avctx, "DVB sub packet:\n");
1622 
1623  for (i=0; i < buf_size; i++) {
1624  ff_dlog(avctx, "%02x ", buf[i]);
1625  if (i % 16 == 15)
1626  ff_dlog(avctx, "\n");
1627  }
1628 
1629  if (i % 16)
1630  ff_dlog(avctx, "\n");
1631 
1632  if (buf_size <= 6 || *buf != 0x0f) {
1633  ff_dlog(avctx, "incomplete or broken packet");
1634  return AVERROR_INVALIDDATA;
1635  }
1636 
1637  p = buf;
1638  p_end = buf + buf_size;
1639 
1640  while (p_end - p >= 6 && *p == 0x0f) {
1641  p += 1;
1642  segment_type = *p++;
1643  page_id = AV_RB16(p);
1644  p += 2;
1645  segment_length = AV_RB16(p);
1646  p += 2;
1647 
1648  if (avctx->debug & FF_DEBUG_STARTCODE) {
1649  av_log(avctx, AV_LOG_DEBUG, "segment_type:%d page_id:%d segment_length:%d\n", segment_type, page_id, segment_length);
1650  }
1651 
1652  if (p_end - p < segment_length) {
1653  ff_dlog(avctx, "incomplete or broken packet");
1654  ret = -1;
1655  goto end;
1656  }
1657 
1658  if (page_id == ctx->composition_id || page_id == ctx->ancillary_id ||
1659  ctx->composition_id == -1 || ctx->ancillary_id == -1) {
1660  int ret = 0;
1661  switch (segment_type) {
1662  case DVBSUB_PAGE_SEGMENT:
1663  ret = dvbsub_parse_page_segment(avctx, p, segment_length, sub, data_size);
1664  got_segment |= 1;
1665  break;
1666  case DVBSUB_REGION_SEGMENT:
1667  ret = dvbsub_parse_region_segment(avctx, p, segment_length);
1668  got_segment |= 2;
1669  break;
1670  case DVBSUB_CLUT_SEGMENT:
1671  ret = dvbsub_parse_clut_segment(avctx, p, segment_length);
1672  if (ret < 0) goto end;
1673  got_segment |= 4;
1674  break;
1675  case DVBSUB_OBJECT_SEGMENT:
1676  ret = dvbsub_parse_object_segment(avctx, p, segment_length);
1677  got_segment |= 8;
1678  break;
1681  segment_length);
1682  got_dds = 1;
1683  break;
1685  ret = dvbsub_display_end_segment(avctx, p, segment_length, sub, data_size);
1686  if (got_segment == 15 && !got_dds && !avctx->width && !avctx->height) {
1687  // Default from ETSI EN 300 743 V1.3.1 (7.2.1)
1688  avctx->width = 720;
1689  avctx->height = 576;
1690  }
1691  got_segment |= 16;
1692  break;
1693  default:
1694  ff_dlog(avctx, "Subtitling segment type 0x%x, page id %d, length %d\n",
1695  segment_type, page_id, segment_length);
1696  break;
1697  }
1698  if (ret < 0)
1699  goto end;
1700  }
1701 
1702  p += segment_length;
1703  }
1704  // Some streams do not send a display segment but if we have all the other
1705  // segments then we need no further data.
1706  if (got_segment == 15) {
1707  av_log(avctx, AV_LOG_DEBUG, "Missing display_end_segment, emulating\n");
1708  dvbsub_display_end_segment(avctx, p, 0, sub, data_size);
1709  }
1710 
1711 end:
1712  if(ret < 0) {
1713  *data_size = 0;
1714  avsubtitle_free(sub);
1715  return ret;
1716  } else {
1717  if(ctx->compute_edt == 1 )
1718  FFSWAP(int64_t, ctx->prev_start, sub->pts);
1719  }
1720 
1721  return p - buf;
1722 }
1723 
1724 #define DS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_SUBTITLE_PARAM
1725 static const AVOption options[] = {
1726  {"compute_edt", "compute end of time using pts or timeout", offsetof(DVBSubContext, compute_edt), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DS},
1727  {"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},
1728  {"dvb_substream", "", offsetof(DVBSubContext, substream), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, DS},
1729  {NULL}
1730 };
1731 static const AVClass dvbsubdec_class = {
1732  .class_name = "DVB Sub Decoder",
1733  .item_name = av_default_item_name,
1734  .option = options,
1735  .version = LIBAVUTIL_VERSION_INT,
1736 };
1737 
1739  .name = "dvbsub",
1740  .long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"),
1741  .type = AVMEDIA_TYPE_SUBTITLE,
1743  .priv_data_size = sizeof(DVBSubContext),
1745  .close = dvbsub_close_decoder,
1746  .decode = dvbsub_decode,
1747  .priv_class = &dvbsubdec_class,
1748 };
int version
Definition: dvbsubdec.c:43
#define NULL
Definition: coverity.c:32
static DVBSubCLUT * get_clut(DVBSubContext *ctx, int clut_id)
Definition: dvbsubdec.c:153
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static float alpha(float a)
static int dvbsub_read_8bit_string(AVCodecContext *avctx, uint8_t *destbuf, int dbuf_len, const uint8_t **srcbuf, int buf_size, int non_mod, uint8_t *map_table, int x_pos)
Definition: dvbsubdec.c:600
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 DVBSubRegion * get_region(DVBSubContext *ctx, int region_id)
Definition: dvbsubdec.c:164
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
DVBSubRegionDisplay * display_list
Definition: dvbsubdec.c:137
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:381
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
const char * g
Definition: vf_curves.c:112
int64_t prev_start
Definition: dvbsubdec.c:132
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int size
Definition: avcodec.h:1445
const char * b
Definition: vf_curves.c:113
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
#define V(x, y)
unsigned num_rects
Definition: avcodec.h:3879
#define RGBA(r, g, b, a)
Definition: dvbsubdec.c:39
int version
Definition: avisynth_c.h:766
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
static int dvbsub_parse_page_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size, AVSubtitle *sub, int *got_output)
Definition: dvbsubdec.c:1285
#define xf(width, name, var, subs,...)
Definition: cbs_vp9.c:342
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:3423
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:112
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
static int dvbsub_read_4bit_string(AVCodecContext *avctx, uint8_t *destbuf, int dbuf_len, const uint8_t **srcbuf, int buf_size, int non_mod, uint8_t *map_table, int x_pos)
Definition: dvbsubdec.c:477
static void delete_cluts(DVBSubContext *ctx)
Definition: dvbsubdec.c:221
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
AVOptions.
#define f(width, name)
Definition: cbs_vp9.c:255
#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:1633
static const AVClass dvbsubdec_class
Definition: dvbsubdec.c:1731
#define height
uint8_t * data
Definition: avcodec.h:1444
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
#define ff_dlog(a,...)
bitstream reader API header.
DVBSubRegion * region_list
Definition: dvbsubdec.c:133
#define av_log(a,...)
static void delete_regions(DVBSubContext *ctx)
Definition: dvbsubdec.c:243
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
#define DVBSUB_DISPLAYDEFINITION_SEGMENT
Definition: dvbsubdec.c:34
struct DVBSubRegion * next
Definition: dvbsubdec.c:108
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
Various defines for YUV<->RGB conversion.
#define AVERROR(e)
Definition: error.h:43
int compute_clut
Definition: dvbsubdec.c:129
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
const char * r
Definition: vf_curves.c:111
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
static DVBSubCLUT default_clut
Definition: dvbsubdec.c:52
uint16_t width
Definition: gdv.c:47
static int dvbsub_parse_display_definition_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: dvbsubdec.c:1545
const char * name
Name of the codec implementation.
Definition: avcodec.h:3430
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:3242
GLsizei count
Definition: opengl_enc.c:109
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:117
uint32_t end_display_time
Definition: avcodec.h:3878
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:3881
struct DVBSubObject * next
Definition: dvbsubdec.c:76
AVCodec ff_dvbsub_decoder
Definition: dvbsubdec.c:1738
A bitmap, pict will be set.
Definition: avcodec.h:3823
int linesize[4]
Definition: avcodec.h:3859
int composition_id
Definition: dvbsubdec.c:122
DVBSubObjectDisplay * display_list
Definition: dvbsubdec.c:106
struct DVBSubObjectDisplay * region_list_next
Definition: dvbsubdec.c:64
int width
picture width / height.
Definition: avcodec.h:1705
static int dvbsub_parse_clut_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: dvbsubdec.c:1045
#define YUV_TO_RGB2_CCIR(r, g, b, y1)
Definition: colorspace.h:55
uint8_t w
Definition: llviddspenc.c:38
static void compute_default_clut(DVBSubContext *ctx, uint8_t *clut, AVSubtitleRect *rect, int w, int h)
Definition: dvbsubdec.c:654
AVFormatContext * ctx
Definition: movenc.c:48
struct DVBSubCLUT * next
Definition: dvbsubdec.c:49
static int save_subtitle_set(AVCodecContext *avctx, AVSubtitle *sub, int *got_output)
Definition: dvbsubdec.c:720
uint32_t clut16[16]
Definition: dvbsubdec.c:46
DVBSubObjectDisplay * display_list
Definition: dvbsubdec.c:74
static void delete_objects(DVBSubContext *ctx)
Definition: dvbsubdec.c:232
DVBSubDisplayDefinition * display_definition
Definition: dvbsubdec.c:138
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define DS
Definition: dvbsubdec.c:1724
#define YUV_TO_RGB1_CCIR(cb1, cr1)
Definition: colorspace.h:34
int clut_count2[257][256]
Definition: dvbsubdec.c:130
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
#define DVBSUB_CLUT_SEGMENT
Definition: dvbsubdec.c:32
Libavcodec external API header.
uint8_t * pbuf
Definition: dvbsubdec.c:102
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
uint32_t clut256[256]
Definition: dvbsubdec.c:47
int debug
debug
Definition: avcodec.h:2613
main external API structure.
Definition: avcodec.h:1532
static int dvbsub_display_end_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size, AVSubtitle *sub, int *got_output)
Definition: dvbsubdec.c:1591
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:1050
int x
Definition: f_ebur128.c:91
DVBSubCLUT * clut_list
Definition: dvbsubdec.c:134
static DVBSubObject * get_object(DVBSubContext *ctx, int object_id)
Definition: dvbsubdec.c:142
void * buf
Definition: avisynth_c.h:690
int extradata_size
Definition: avcodec.h:1634
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:487
static void delete_region_display_list(DVBSubContext *ctx, DVBSubRegion *region)
Definition: dvbsubdec.c:175
Describe the class of an AVClass context structure.
Definition: log.h:67
Definition: f_ebur128.c:91
#define DVBSUB_DISPLAY_SEGMENT
Definition: dvbsubdec.c:35
struct DVBSubRegionDisplay * next
Definition: dvbsubdec.c:85
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:2594
Rational number (pair of numerator and denominator).
Definition: rational.h:58
struct DVBSubObjectDisplay * object_list_next
Definition: dvbsubdec.c:65
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:615
int h
Definition: f_ebur128.c:91
#define snprintf
Definition: snprintf.h:34
#define DVBSUB_PAGE_SEGMENT
Definition: dvbsubdec.c:30
uint32_t clut4[4]
Definition: dvbsubdec.c:45
static av_cold int dvbsub_init_decoder(AVCodecContext *avctx)
Definition: dvbsubdec.c:257
static const AVOption options[]
Definition: dvbsubdec.c:1725
#define DVBSUB_REGION_SEGMENT
Definition: dvbsubdec.c:31
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
int
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
int ancillary_id
Definition: dvbsubdec.c:123
#define AV_WN32(p, v)
Definition: intreadwrite.h:376
int w
Definition: f_ebur128.c:91
static int dvbsub_decode(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt)
Definition: dvbsubdec.c:1604
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...
Definition: imgutils.c:253
void * priv_data
Definition: avcodec.h:1559
#define av_free(p)
#define FF_DEBUG_STARTCODE
Definition: avcodec.h:2627
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
static int dvbsub_parse_object_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: dvbsubdec.c:985
DVBSubObject * object_list
Definition: dvbsubdec.c:135
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
#define av_freep(p)
static int dvbsub_parse_region_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: dvbsubdec.c:1144
#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:127
#define DVBSUB_OBJECT_SEGMENT
Definition: dvbsubdec.c:33
uint8_t computed_clut[4 *256]
Definition: dvbsubdec.c:99
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:113
static av_cold int dvbsub_close_decoder(AVCodecContext *avctx)
Definition: dvbsubdec.c:346
This structure stores compressed data.
Definition: avcodec.h:1421
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:2591
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define av_unused
Definition: attributes.h:125
int has_computed_clut
Definition: dvbsubdec.c:100
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191