FFmpeg
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 
99  uint8_t computed_clut[4*256];
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 (display->x_pos >= region->width ||
1271  display->y_pos >= region->height) {
1272  av_log(avctx, AV_LOG_ERROR, "Object outside region\n");
1273  av_free(display);
1274  return AVERROR_INVALIDDATA;
1275  }
1276 
1277  if ((object->type == 1 || object->type == 2) && buf+1 < buf_end) {
1278  display->fgcolor = *buf++;
1279  display->bgcolor = *buf++;
1280  }
1281 
1282  display->region_list_next = region->display_list;
1283  region->display_list = display;
1284 
1285  display->object_list_next = object->display_list;
1286  object->display_list = display;
1287  }
1288 
1289  return 0;
1290 }
1291 
1293  const uint8_t *buf, int buf_size, AVSubtitle *sub, int *got_output)
1294 {
1295  DVBSubContext *ctx = avctx->priv_data;
1296  DVBSubRegionDisplay *display;
1297  DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;
1298 
1299  const uint8_t *buf_end = buf + buf_size;
1300  int region_id;
1301  int page_state;
1302  int timeout;
1303  int version;
1304 
1305  if (buf_size < 1)
1306  return AVERROR_INVALIDDATA;
1307 
1308  timeout = *buf++;
1309  version = ((*buf)>>4) & 15;
1310  page_state = ((*buf++) >> 2) & 3;
1311 
1312  if (ctx->version == version) {
1313  return 0;
1314  }
1315 
1316  ctx->time_out = timeout;
1317  ctx->version = version;
1318 
1319  ff_dlog(avctx, "Page time out %ds, state %d\n", ctx->time_out, page_state);
1320 
1321  if(ctx->compute_edt == 1)
1322  save_subtitle_set(avctx, sub, got_output);
1323 
1324  if (page_state == 1 || page_state == 2) {
1325  delete_regions(ctx);
1326  delete_objects(ctx);
1327  delete_cluts(ctx);
1328  }
1329 
1330  tmp_display_list = ctx->display_list;
1331  ctx->display_list = NULL;
1332 
1333  while (buf + 5 < buf_end) {
1334  region_id = *buf++;
1335  buf += 1;
1336 
1337  display = ctx->display_list;
1338  while (display && display->region_id != region_id) {
1339  display = display->next;
1340  }
1341  if (display) {
1342  av_log(avctx, AV_LOG_ERROR, "duplicate region\n");
1343  break;
1344  }
1345 
1346  display = tmp_display_list;
1347  tmp_ptr = &tmp_display_list;
1348 
1349  while (display && display->region_id != region_id) {
1350  tmp_ptr = &display->next;
1351  display = display->next;
1352  }
1353 
1354  if (!display) {
1355  display = av_mallocz(sizeof(DVBSubRegionDisplay));
1356  if (!display)
1357  return AVERROR(ENOMEM);
1358  }
1359 
1360  display->region_id = region_id;
1361 
1362  display->x_pos = AV_RB16(buf);
1363  buf += 2;
1364  display->y_pos = AV_RB16(buf);
1365  buf += 2;
1366 
1367  *tmp_ptr = display->next;
1368 
1369  display->next = ctx->display_list;
1370  ctx->display_list = display;
1371 
1372  ff_dlog(avctx, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
1373  }
1374 
1375  while (tmp_display_list) {
1376  display = tmp_display_list;
1377 
1378  tmp_display_list = display->next;
1379 
1380  av_freep(&display);
1381  }
1382 
1383  return 0;
1384 }
1385 
1386 
1387 #ifdef DEBUG
1388 static void png_save(DVBSubContext *ctx, const char *filename, uint32_t *bitmap, int w, int h)
1389 {
1390  int x, y, v;
1391  FILE *f;
1392  char fname[40], fname2[40];
1393  char command[1024];
1394 
1395  snprintf(fname, sizeof(fname), "%s.ppm", filename);
1396 
1397  f = fopen(fname, "w");
1398  if (!f) {
1399  perror(fname);
1400  return;
1401  }
1402  fprintf(f, "P6\n"
1403  "%d %d\n"
1404  "%d\n",
1405  w, h, 255);
1406  for(y = 0; y < h; y++) {
1407  for(x = 0; x < w; x++) {
1408  v = bitmap[y * w + x];
1409  putc((v >> 16) & 0xff, f);
1410  putc((v >> 8) & 0xff, f);
1411  putc((v >> 0) & 0xff, f);
1412  }
1413  }
1414  fclose(f);
1415 
1416 
1417  snprintf(fname2, sizeof(fname2), "%s-a.pgm", filename);
1418 
1419  f = fopen(fname2, "w");
1420  if (!f) {
1421  perror(fname2);
1422  return;
1423  }
1424  fprintf(f, "P5\n"
1425  "%d %d\n"
1426  "%d\n",
1427  w, h, 255);
1428  for(y = 0; y < h; y++) {
1429  for(x = 0; x < w; x++) {
1430  v = bitmap[y * w + x];
1431  putc((v >> 24) & 0xff, f);
1432  }
1433  }
1434  fclose(f);
1435 
1436  snprintf(command, sizeof(command), "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
1437  if (system(command) != 0) {
1438  av_log(ctx, AV_LOG_ERROR, "Error running pnmtopng\n");
1439  return;
1440  }
1441 
1442  snprintf(command, sizeof(command), "rm %s %s", fname, fname2);
1443  if (system(command) != 0) {
1444  av_log(ctx, AV_LOG_ERROR, "Error removing %s and %s\n", fname, fname2);
1445  return;
1446  }
1447 }
1448 
1449 static int save_display_set(DVBSubContext *ctx)
1450 {
1451  DVBSubRegion *region;
1452  DVBSubRegionDisplay *display;
1453  DVBSubCLUT *clut;
1454  uint32_t *clut_table;
1455  int x_pos, y_pos, width, height;
1456  int x, y, y_off, x_off;
1457  uint32_t *pbuf;
1458  char filename[32];
1459  static int fileno_index = 0;
1460 
1461  x_pos = -1;
1462  y_pos = -1;
1463  width = 0;
1464  height = 0;
1465 
1466  for (display = ctx->display_list; display; display = display->next) {
1467  region = get_region(ctx, display->region_id);
1468 
1469  if (!region)
1470  return -1;
1471 
1472  if (x_pos == -1) {
1473  x_pos = display->x_pos;
1474  y_pos = display->y_pos;
1475  width = region->width;
1476  height = region->height;
1477  } else {
1478  if (display->x_pos < x_pos) {
1479  width += (x_pos - display->x_pos);
1480  x_pos = display->x_pos;
1481  }
1482 
1483  if (display->y_pos < y_pos) {
1484  height += (y_pos - display->y_pos);
1485  y_pos = display->y_pos;
1486  }
1487 
1488  if (display->x_pos + region->width > x_pos + width) {
1489  width = display->x_pos + region->width - x_pos;
1490  }
1491 
1492  if (display->y_pos + region->height > y_pos + height) {
1493  height = display->y_pos + region->height - y_pos;
1494  }
1495  }
1496  }
1497 
1498  if (x_pos >= 0) {
1499 
1500  pbuf = av_malloc(width * height * 4);
1501  if (!pbuf)
1502  return -1;
1503 
1504  for (display = ctx->display_list; display; display = display->next) {
1505  region = get_region(ctx, display->region_id);
1506 
1507  if (!region)
1508  return -1;
1509 
1510  x_off = display->x_pos - x_pos;
1511  y_off = display->y_pos - y_pos;
1512 
1513  clut = get_clut(ctx, region->clut);
1514 
1515  if (!clut)
1516  clut = &default_clut;
1517 
1518  switch (region->depth) {
1519  case 2:
1520  clut_table = clut->clut4;
1521  break;
1522  case 8:
1523  clut_table = clut->clut256;
1524  break;
1525  case 4:
1526  default:
1527  clut_table = clut->clut16;
1528  break;
1529  }
1530 
1531  for (y = 0; y < region->height; y++) {
1532  for (x = 0; x < region->width; x++) {
1533  pbuf[((y + y_off) * width) + x_off + x] =
1534  clut_table[region->pbuf[y * region->width + x]];
1535  }
1536  }
1537 
1538  }
1539 
1540  snprintf(filename, sizeof(filename), "dvbs.%d", fileno_index);
1541 
1542  png_save(ctx, filename, pbuf, width, height);
1543 
1544  av_freep(&pbuf);
1545  }
1546 
1547  fileno_index++;
1548  return 0;
1549 }
1550 #endif /* DEBUG */
1551 
1553  const uint8_t *buf,
1554  int buf_size)
1555 {
1556  DVBSubContext *ctx = avctx->priv_data;
1557  DVBSubDisplayDefinition *display_def = ctx->display_definition;
1558  int dds_version, info_byte;
1559 
1560  if (buf_size < 5)
1561  return AVERROR_INVALIDDATA;
1562 
1563  info_byte = bytestream_get_byte(&buf);
1564  dds_version = info_byte >> 4;
1565  if (display_def && display_def->version == dds_version)
1566  return 0; // already have this display definition version
1567 
1568  if (!display_def) {
1569  display_def = av_mallocz(sizeof(*display_def));
1570  if (!display_def)
1571  return AVERROR(ENOMEM);
1572  ctx->display_definition = display_def;
1573  }
1574 
1575  display_def->version = dds_version;
1576  display_def->x = 0;
1577  display_def->y = 0;
1578  display_def->width = bytestream_get_be16(&buf) + 1;
1579  display_def->height = bytestream_get_be16(&buf) + 1;
1580  if (!avctx->width || !avctx->height) {
1581  int ret = ff_set_dimensions(avctx, display_def->width, display_def->height);
1582  if (ret < 0)
1583  return ret;
1584  }
1585 
1586  if (info_byte & 1<<3) { // display_window_flag
1587  if (buf_size < 13)
1588  return AVERROR_INVALIDDATA;
1589 
1590  display_def->x = bytestream_get_be16(&buf);
1591  display_def->width = bytestream_get_be16(&buf) - display_def->x + 1;
1592  display_def->y = bytestream_get_be16(&buf);
1593  display_def->height = bytestream_get_be16(&buf) - display_def->y + 1;
1594  }
1595 
1596  return 0;
1597 }
1598 
1600  int buf_size, AVSubtitle *sub,int *got_output)
1601 {
1602  DVBSubContext *ctx = avctx->priv_data;
1603 
1604  if(ctx->compute_edt == 0)
1605  save_subtitle_set(avctx, sub, got_output);
1606 #ifdef DEBUG
1607  save_display_set(ctx);
1608 #endif
1609  return 0;
1610 }
1611 
1612 static int dvbsub_decode(AVCodecContext *avctx,
1613  void *data, int *data_size,
1614  AVPacket *avpkt)
1615 {
1616  const uint8_t *buf = avpkt->data;
1617  int buf_size = avpkt->size;
1618  DVBSubContext *ctx = avctx->priv_data;
1619  AVSubtitle *sub = data;
1620  const uint8_t *p, *p_end;
1621  int segment_type;
1622  int page_id;
1623  int segment_length;
1624  int i;
1625  int ret = 0;
1626  int got_segment = 0;
1627  int got_dds = 0;
1628 
1629  ff_dlog(avctx, "DVB sub packet:\n");
1630 
1631  for (i=0; i < buf_size; i++) {
1632  ff_dlog(avctx, "%02x ", buf[i]);
1633  if (i % 16 == 15)
1634  ff_dlog(avctx, "\n");
1635  }
1636 
1637  if (i % 16)
1638  ff_dlog(avctx, "\n");
1639 
1640  if (buf_size <= 6 || *buf != 0x0f) {
1641  ff_dlog(avctx, "incomplete or broken packet");
1642  return AVERROR_INVALIDDATA;
1643  }
1644 
1645  p = buf;
1646  p_end = buf + buf_size;
1647 
1648  while (p_end - p >= 6 && *p == 0x0f) {
1649  p += 1;
1650  segment_type = *p++;
1651  page_id = AV_RB16(p);
1652  p += 2;
1653  segment_length = AV_RB16(p);
1654  p += 2;
1655 
1656  if (avctx->debug & FF_DEBUG_STARTCODE) {
1657  av_log(avctx, AV_LOG_DEBUG, "segment_type:%d page_id:%d segment_length:%d\n", segment_type, page_id, segment_length);
1658  }
1659 
1660  if (p_end - p < segment_length) {
1661  ff_dlog(avctx, "incomplete or broken packet");
1662  ret = -1;
1663  goto end;
1664  }
1665 
1666  if (page_id == ctx->composition_id || page_id == ctx->ancillary_id ||
1667  ctx->composition_id == -1 || ctx->ancillary_id == -1) {
1668  int ret = 0;
1669  switch (segment_type) {
1670  case DVBSUB_PAGE_SEGMENT:
1671  ret = dvbsub_parse_page_segment(avctx, p, segment_length, sub, data_size);
1672  got_segment |= 1;
1673  break;
1674  case DVBSUB_REGION_SEGMENT:
1675  ret = dvbsub_parse_region_segment(avctx, p, segment_length);
1676  got_segment |= 2;
1677  break;
1678  case DVBSUB_CLUT_SEGMENT:
1679  ret = dvbsub_parse_clut_segment(avctx, p, segment_length);
1680  if (ret < 0) goto end;
1681  got_segment |= 4;
1682  break;
1683  case DVBSUB_OBJECT_SEGMENT:
1684  ret = dvbsub_parse_object_segment(avctx, p, segment_length);
1685  got_segment |= 8;
1686  break;
1689  segment_length);
1690  got_dds = 1;
1691  break;
1693  ret = dvbsub_display_end_segment(avctx, p, segment_length, sub, data_size);
1694  if (got_segment == 15 && !got_dds && !avctx->width && !avctx->height) {
1695  // Default from ETSI EN 300 743 V1.3.1 (7.2.1)
1696  avctx->width = 720;
1697  avctx->height = 576;
1698  }
1699  got_segment |= 16;
1700  break;
1701  default:
1702  ff_dlog(avctx, "Subtitling segment type 0x%x, page id %d, length %d\n",
1703  segment_type, page_id, segment_length);
1704  break;
1705  }
1706  if (ret < 0)
1707  goto end;
1708  }
1709 
1710  p += segment_length;
1711  }
1712  // Some streams do not send a display segment but if we have all the other
1713  // segments then we need no further data.
1714  if (got_segment == 15) {
1715  av_log(avctx, AV_LOG_DEBUG, "Missing display_end_segment, emulating\n");
1716  dvbsub_display_end_segment(avctx, p, 0, sub, data_size);
1717  }
1718 
1719 end:
1720  if(ret < 0) {
1721  *data_size = 0;
1722  avsubtitle_free(sub);
1723  return ret;
1724  } else {
1725  if(ctx->compute_edt == 1 )
1726  FFSWAP(int64_t, ctx->prev_start, sub->pts);
1727  }
1728 
1729  return p - buf;
1730 }
1731 
1732 #define DS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_SUBTITLE_PARAM
1733 static const AVOption options[] = {
1734  {"compute_edt", "compute end of time using pts or timeout", offsetof(DVBSubContext, compute_edt), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DS},
1735  {"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},
1736  {"dvb_substream", "", offsetof(DVBSubContext, substream), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, DS},
1737  {NULL}
1738 };
1739 static const AVClass dvbsubdec_class = {
1740  .class_name = "DVB Sub Decoder",
1741  .item_name = av_default_item_name,
1742  .option = options,
1743  .version = LIBAVUTIL_VERSION_INT,
1744 };
1745 
1747  .name = "dvbsub",
1748  .long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"),
1749  .type = AVMEDIA_TYPE_SUBTITLE,
1751  .priv_data_size = sizeof(DVBSubContext),
1753  .close = dvbsub_close_decoder,
1754  .decode = dvbsub_decode,
1755  .priv_class = &dvbsubdec_class,
1756 };
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 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
int x
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:3899
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:100
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:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
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:104
const char * g
Definition: vf_curves.c:115
int64_t prev_start
Definition: dvbsubdec.c:132
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
#define avpriv_request_sample(...)
int nb_colors
number of colors in pict, undefined when pict is not set
Definition: avcodec.h:3903
int size
Definition: avcodec.h:1478
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
#define V(x, y)
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
unsigned num_rects
Definition: avcodec.h:3937
#define RGBA(r, g, b, a)
Definition: dvbsubdec.c:39
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:1292
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:3481
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
attribute_deprecated AVPicture pict
Definition: avcodec.h:3910
AVSubtitleRect ** rects
Definition: avcodec.h:3938
int w
width of pict, undefined when pict is not set
Definition: avcodec.h:3901
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
The exact code depends on how similar the blocks are and how related they are to the block
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
attribute_deprecated int linesize[AV_NUM_DATA_POINTERS]
number of bytes per line
Definition: avcodec.h:3870
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1666
static const AVClass dvbsubdec_class
Definition: dvbsubdec.c:1739
#define height
uint8_t * data
Definition: avcodec.h:1477
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
#define ff_dlog(a,...)
bitstream reader API header.
int h
height of pict, undefined when pict is not set
Definition: avcodec.h:3902
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 i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
Various defines for YUV<->RGB conversion.
int y
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:3900
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:114
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
static DVBSubCLUT default_clut
Definition: dvbsubdec.c:52
static int dvbsub_parse_display_definition_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: dvbsubdec.c:1552
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
uint8_t bits
Definition: vp3data.h:202
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:3292
GLsizei count
Definition: opengl_enc.c:108
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:120
uint32_t end_display_time
Definition: avcodec.h:3936
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:3939
struct DVBSubObject * next
Definition: dvbsubdec.c:76
AVCodec ff_dvbsub_decoder
Definition: dvbsubdec.c:1746
A bitmap, pict will be set.
Definition: avcodec.h:3881
int linesize[4]
Definition: avcodec.h:3917
#define b
Definition: input.c:41
int composition_id
Definition: dvbsubdec.c:122
DVBSubObjectDisplay * display_list
Definition: dvbsubdec.c:106
struct DVBSubObjectDisplay * region_list_next
Definition: dvbsubdec.c:64
#define width
int width
picture width / height.
Definition: avcodec.h:1738
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
attribute_deprecated uint8_t * data[AV_NUM_DATA_POINTERS]
pointers to the image data planes
Definition: avcodec.h:3868
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
uint8_t * data[4]
data+linesize for the bitmap of this subtitle.
Definition: avcodec.h:3916
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define DS
Definition: dvbsubdec.c:1732
#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:2650
static const int16_t alpha[]
Definition: ilbcdata.h:55
main external API structure.
Definition: avcodec.h:1565
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
static int dvbsub_display_end_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size, AVSubtitle *sub, int *got_output)
Definition: dvbsubdec.c:1599
static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Definition: vf_drawtext.c:869
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: utils.c:1062
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:766
int extradata_size
Definition: avcodec.h:1667
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
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:2631
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:659
#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:1733
#define DVBSUB_REGION_SEGMENT
Definition: dvbsubdec.c:31
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
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
static int dvbsub_decode(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt)
Definition: dvbsubdec.c:1612
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:1592
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:664
#define av_free(p)
#define FF_DEBUG_STARTCODE
Definition: avcodec.h:2664
#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
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:113
enum AVSubtitleType type
Definition: avcodec.h:3919
static av_cold int dvbsub_close_decoder(AVCodecContext *avctx)
Definition: dvbsubdec.c:346
This structure stores compressed data.
Definition: avcodec.h:1454
FFmpeg currently uses a custom build system
Definition: build_system.txt:1
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:2628
#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