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(*clut_table));
817 
818  rect->data[0] = av_malloc(region->buf_size);
819  if (!rect->data[0]) {
820  ret = AVERROR(ENOMEM);
821  goto fail;
822  }
823 
824  memcpy(rect->data[0], region->pbuf, region->buf_size);
825 
826  if ((clut == &default_clut && ctx->compute_clut == -1) || ctx->compute_clut == 1) {
827  if (!region->has_computed_clut) {
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  } else if (coding_method == 1) {
1036  avpriv_report_missing_feature(avctx, "coded as a string of characters");
1037  return AVERROR_PATCHWELCOME;
1038  } else if (coding_method == 2) {
1039  avpriv_report_missing_feature(avctx, "progressive coding of pixels");
1040  return AVERROR_PATCHWELCOME;
1041  } else {
1042  av_log(avctx, AV_LOG_ERROR, "Unknown object coding %d\n", coding_method);
1043  return AVERROR_INVALIDDATA;
1044  }
1045 
1046  return 0;
1047 }
1048 
1050  const uint8_t *buf, int buf_size)
1051 {
1052  DVBSubContext *ctx = avctx->priv_data;
1053 
1054  const uint8_t *buf_end = buf + buf_size;
1055  int i, clut_id;
1056  int version;
1057  DVBSubCLUT *clut;
1058  int entry_id, depth , full_range;
1059  int y, cr, cb, alpha;
1060  int r, g, b, r_add, g_add, b_add;
1061 
1062  ff_dlog(avctx, "DVB clut packet:\n");
1063 
1064  for (i=0; i < buf_size; i++) {
1065  ff_dlog(avctx, "%02x ", buf[i]);
1066  if (i % 16 == 15)
1067  ff_dlog(avctx, "\n");
1068  }
1069 
1070  if (i % 16)
1071  ff_dlog(avctx, "\n");
1072 
1073  clut_id = *buf++;
1074  version = ((*buf)>>4)&15;
1075  buf += 1;
1076 
1077  clut = get_clut(ctx, clut_id);
1078 
1079  if (!clut) {
1080  clut = av_malloc(sizeof(*clut));
1081  if (!clut)
1082  return AVERROR(ENOMEM);
1083 
1084  memcpy(clut, &default_clut, sizeof(*clut));
1085 
1086  clut->id = clut_id;
1087  clut->version = -1;
1088 
1089  clut->next = ctx->clut_list;
1090  ctx->clut_list = clut;
1091  }
1092 
1093  if (clut->version != version) {
1094 
1095  clut->version = version;
1096 
1097  while (buf + 4 < buf_end) {
1098  entry_id = *buf++;
1099 
1100  depth = (*buf) & 0xe0;
1101 
1102  if (depth == 0) {
1103  av_log(avctx, AV_LOG_ERROR, "Invalid clut depth 0x%x!\n", *buf);
1104  }
1105 
1106  full_range = (*buf++) & 1;
1107 
1108  if (full_range) {
1109  y = *buf++;
1110  cr = *buf++;
1111  cb = *buf++;
1112  alpha = *buf++;
1113  } else {
1114  y = buf[0] & 0xfc;
1115  cr = (((buf[0] & 3) << 2) | ((buf[1] >> 6) & 3)) << 4;
1116  cb = (buf[1] << 2) & 0xf0;
1117  alpha = (buf[1] << 6) & 0xc0;
1118 
1119  buf += 2;
1120  }
1121 
1122  if (y == 0)
1123  alpha = 0xff;
1124 
1125  YUV_TO_RGB1_CCIR(cb, cr);
1126  YUV_TO_RGB2_CCIR(r, g, b, y);
1127 
1128  ff_dlog(avctx, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);
1129  if (!!(depth & 0x80) + !!(depth & 0x40) + !!(depth & 0x20) > 1) {
1130  ff_dlog(avctx, "More than one bit level marked: %x\n", depth);
1132  return AVERROR_INVALIDDATA;
1133  }
1134 
1135  if (depth & 0x80 && entry_id < 4)
1136  clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha);
1137  else if (depth & 0x40 && entry_id < 16)
1138  clut->clut16[entry_id] = RGBA(r,g,b,255 - alpha);
1139  else if (depth & 0x20)
1140  clut->clut256[entry_id] = RGBA(r,g,b,255 - alpha);
1141  }
1142  }
1143 
1144  return 0;
1145 }
1146 
1147 
1149  const uint8_t *buf, int buf_size)
1150 {
1151  DVBSubContext *ctx = avctx->priv_data;
1152 
1153  const uint8_t *buf_end = buf + buf_size;
1154  int region_id, object_id;
1155  int av_unused version;
1156  DVBSubRegion *region;
1157  DVBSubObject *object;
1158  DVBSubObjectDisplay *display;
1159  int fill;
1160  int ret;
1161 
1162  if (buf_size < 10)
1163  return AVERROR_INVALIDDATA;
1164 
1165  region_id = *buf++;
1166 
1167  region = get_region(ctx, region_id);
1168 
1169  if (!region) {
1170  region = av_mallocz(sizeof(*region));
1171  if (!region)
1172  return AVERROR(ENOMEM);
1173 
1174  region->id = region_id;
1175  region->version = -1;
1176 
1177  region->next = ctx->region_list;
1178  ctx->region_list = region;
1179  }
1180 
1181  version = ((*buf)>>4) & 15;
1182  fill = ((*buf++) >> 3) & 1;
1183 
1184  region->width = AV_RB16(buf);
1185  buf += 2;
1186  region->height = AV_RB16(buf);
1187  buf += 2;
1188 
1189  ret = av_image_check_size2(region->width, region->height, avctx->max_pixels, AV_PIX_FMT_PAL8, 0, avctx);
1190  if (ret >= 0 && region->width * region->height * 2 > 320 * 1024 * 8) {
1191  ret = AVERROR_INVALIDDATA;
1192  av_log(avctx, AV_LOG_ERROR, "Pixel buffer memory constraint violated\n");
1193  }
1194  if (ret < 0) {
1195  region->width= region->height= 0;
1196  return ret;
1197  }
1198 
1199  if (region->width * region->height != region->buf_size) {
1200  av_free(region->pbuf);
1201 
1202  region->buf_size = region->width * region->height;
1203 
1204  region->pbuf = av_malloc(region->buf_size);
1205  if (!region->pbuf) {
1206  region->buf_size =
1207  region->width =
1208  region->height = 0;
1209  return AVERROR(ENOMEM);
1210  }
1211 
1212  fill = 1;
1213  region->dirty = 0;
1214  }
1215 
1216  region->depth = 1 << (((*buf++) >> 2) & 7);
1217  if (region->depth < 2 || region->depth > 8) {
1218  av_log(avctx, AV_LOG_ERROR, "region depth %d is invalid\n", region->depth);
1219  region->depth= 4;
1220  }
1221  region->clut = *buf++;
1222 
1223  if (region->depth == 8) {
1224  region->bgcolor = *buf++;
1225  buf += 1;
1226  } else {
1227  buf += 1;
1228 
1229  if (region->depth == 4)
1230  region->bgcolor = (((*buf++) >> 4) & 15);
1231  else
1232  region->bgcolor = (((*buf++) >> 2) & 3);
1233  }
1234 
1235  ff_dlog(avctx, "Region %d, (%dx%d)\n", region_id, region->width, region->height);
1236 
1237  if (fill) {
1238  memset(region->pbuf, region->bgcolor, region->buf_size);
1239  ff_dlog(avctx, "Fill region (%d)\n", region->bgcolor);
1240  }
1241 
1242  delete_region_display_list(ctx, region);
1243 
1244  while (buf + 5 < buf_end) {
1245  object_id = AV_RB16(buf);
1246  buf += 2;
1247 
1248  object = get_object(ctx, object_id);
1249 
1250  if (!object) {
1251  object = av_mallocz(sizeof(*object));
1252  if (!object)
1253  return AVERROR(ENOMEM);
1254 
1255  object->id = object_id;
1256  object->next = ctx->object_list;
1257  ctx->object_list = object;
1258  }
1259 
1260  object->type = (*buf) >> 6;
1261 
1262  display = av_mallocz(sizeof(*display));
1263  if (!display)
1264  return AVERROR(ENOMEM);
1265 
1266  display->object_id = object_id;
1267  display->region_id = region_id;
1268 
1269  display->x_pos = AV_RB16(buf) & 0xfff;
1270  buf += 2;
1271  display->y_pos = AV_RB16(buf) & 0xfff;
1272  buf += 2;
1273 
1274  if (display->x_pos >= region->width ||
1275  display->y_pos >= region->height) {
1276  av_log(avctx, AV_LOG_ERROR, "Object outside region\n");
1277  av_free(display);
1278  return AVERROR_INVALIDDATA;
1279  }
1280 
1281  if ((object->type == 1 || object->type == 2) && buf+1 < buf_end) {
1282  display->fgcolor = *buf++;
1283  display->bgcolor = *buf++;
1284  }
1285 
1286  display->region_list_next = region->display_list;
1287  region->display_list = display;
1288 
1289  display->object_list_next = object->display_list;
1290  object->display_list = display;
1291  }
1292 
1293  return 0;
1294 }
1295 
1297  const uint8_t *buf, int buf_size, AVSubtitle *sub, int *got_output)
1298 {
1299  DVBSubContext *ctx = avctx->priv_data;
1300  DVBSubRegionDisplay *display;
1301  DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;
1302 
1303  const uint8_t *buf_end = buf + buf_size;
1304  int region_id;
1305  int page_state;
1306  int timeout;
1307  int version;
1308 
1309  if (buf_size < 1)
1310  return AVERROR_INVALIDDATA;
1311 
1312  timeout = *buf++;
1313  version = ((*buf)>>4) & 15;
1314  page_state = ((*buf++) >> 2) & 3;
1315 
1316  if (ctx->version == version) {
1317  return 0;
1318  }
1319 
1320  ctx->time_out = timeout;
1321  ctx->version = version;
1322 
1323  ff_dlog(avctx, "Page time out %ds, state %d\n", ctx->time_out, page_state);
1324 
1325  if (ctx->compute_edt == 1)
1326  save_subtitle_set(avctx, sub, got_output);
1327 
1328  if (page_state == 1 || page_state == 2) {
1329  delete_regions(ctx);
1330  delete_objects(ctx);
1331  delete_cluts(ctx);
1332  }
1333 
1334  tmp_display_list = ctx->display_list;
1335  ctx->display_list = NULL;
1336 
1337  while (buf + 5 < buf_end) {
1338  region_id = *buf++;
1339  buf += 1;
1340 
1341  display = ctx->display_list;
1342  while (display && display->region_id != region_id) {
1343  display = display->next;
1344  }
1345  if (display) {
1346  av_log(avctx, AV_LOG_ERROR, "duplicate region\n");
1347  break;
1348  }
1349 
1350  display = tmp_display_list;
1351  tmp_ptr = &tmp_display_list;
1352 
1353  while (display && display->region_id != region_id) {
1354  tmp_ptr = &display->next;
1355  display = display->next;
1356  }
1357 
1358  if (!display) {
1359  display = av_mallocz(sizeof(*display));
1360  if (!display)
1361  return AVERROR(ENOMEM);
1362  }
1363 
1364  display->region_id = region_id;
1365 
1366  display->x_pos = AV_RB16(buf);
1367  buf += 2;
1368  display->y_pos = AV_RB16(buf);
1369  buf += 2;
1370 
1371  *tmp_ptr = display->next;
1372 
1373  display->next = ctx->display_list;
1374  ctx->display_list = display;
1375 
1376  ff_dlog(avctx, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
1377  }
1378 
1379  while (tmp_display_list) {
1380  display = tmp_display_list;
1381 
1382  tmp_display_list = display->next;
1383 
1384  av_freep(&display);
1385  }
1386 
1387  return 0;
1388 }
1389 
1390 
1391 #ifdef DEBUG
1392 static void png_save(DVBSubContext *ctx, const char *filename, uint32_t *bitmap, int w, int h)
1393 {
1394  int x, y, v;
1395  FILE *f;
1396  char fname[40], fname2[40];
1397  char command[1024];
1398 
1399  snprintf(fname, sizeof(fname), "%s.ppm", filename);
1400 
1401  f = fopen(fname, "w");
1402  if (!f) {
1403  perror(fname);
1404  return;
1405  }
1406  fprintf(f, "P6\n"
1407  "%d %d\n"
1408  "%d\n",
1409  w, h, 255);
1410  for(y = 0; y < h; y++) {
1411  for(x = 0; x < w; x++) {
1412  v = bitmap[y * w + x];
1413  putc((v >> 16) & 0xff, f);
1414  putc((v >> 8) & 0xff, f);
1415  putc((v >> 0) & 0xff, f);
1416  }
1417  }
1418  fclose(f);
1419 
1420 
1421  snprintf(fname2, sizeof(fname2), "%s-a.pgm", filename);
1422 
1423  f = fopen(fname2, "w");
1424  if (!f) {
1425  perror(fname2);
1426  return;
1427  }
1428  fprintf(f, "P5\n"
1429  "%d %d\n"
1430  "%d\n",
1431  w, h, 255);
1432  for(y = 0; y < h; y++) {
1433  for(x = 0; x < w; x++) {
1434  v = bitmap[y * w + x];
1435  putc((v >> 24) & 0xff, f);
1436  }
1437  }
1438  fclose(f);
1439 
1440  snprintf(command, sizeof(command), "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
1441  if (system(command) != 0) {
1442  av_log(ctx, AV_LOG_ERROR, "Error running pnmtopng\n");
1443  return;
1444  }
1445 
1446  snprintf(command, sizeof(command), "rm %s %s", fname, fname2);
1447  if (system(command) != 0) {
1448  av_log(ctx, AV_LOG_ERROR, "Error removing %s and %s\n", fname, fname2);
1449  return;
1450  }
1451 }
1452 
1453 static int save_display_set(DVBSubContext *ctx)
1454 {
1455  DVBSubRegion *region;
1456  DVBSubRegionDisplay *display;
1457  DVBSubCLUT *clut;
1458  uint32_t *clut_table;
1459  int x_pos, y_pos, width, height;
1460  int x, y, y_off, x_off;
1461  uint32_t *pbuf;
1462  char filename[32];
1463  static int fileno_index = 0;
1464 
1465  x_pos = -1;
1466  y_pos = -1;
1467  width = 0;
1468  height = 0;
1469 
1470  for (display = ctx->display_list; display; display = display->next) {
1471  region = get_region(ctx, display->region_id);
1472 
1473  if (!region)
1474  return -1;
1475 
1476  if (x_pos == -1) {
1477  x_pos = display->x_pos;
1478  y_pos = display->y_pos;
1479  width = region->width;
1480  height = region->height;
1481  } else {
1482  if (display->x_pos < x_pos) {
1483  width += (x_pos - display->x_pos);
1484  x_pos = display->x_pos;
1485  }
1486 
1487  if (display->y_pos < y_pos) {
1488  height += (y_pos - display->y_pos);
1489  y_pos = display->y_pos;
1490  }
1491 
1492  if (display->x_pos + region->width > x_pos + width) {
1493  width = display->x_pos + region->width - x_pos;
1494  }
1495 
1496  if (display->y_pos + region->height > y_pos + height) {
1497  height = display->y_pos + region->height - y_pos;
1498  }
1499  }
1500  }
1501 
1502  if (x_pos >= 0) {
1503 
1504  pbuf = av_malloc(width * height * 4);
1505  if (!pbuf)
1506  return -1;
1507 
1508  for (display = ctx->display_list; display; display = display->next) {
1509  region = get_region(ctx, display->region_id);
1510 
1511  if (!region)
1512  return -1;
1513 
1514  x_off = display->x_pos - x_pos;
1515  y_off = display->y_pos - y_pos;
1516 
1517  clut = get_clut(ctx, region->clut);
1518 
1519  if (!clut)
1520  clut = &default_clut;
1521 
1522  switch (region->depth) {
1523  case 2:
1524  clut_table = clut->clut4;
1525  break;
1526  case 8:
1527  clut_table = clut->clut256;
1528  break;
1529  case 4:
1530  default:
1531  clut_table = clut->clut16;
1532  break;
1533  }
1534 
1535  for (y = 0; y < region->height; y++) {
1536  for (x = 0; x < region->width; x++) {
1537  pbuf[((y + y_off) * width) + x_off + x] =
1538  clut_table[region->pbuf[y * region->width + x]];
1539  }
1540  }
1541 
1542  }
1543 
1544  snprintf(filename, sizeof(filename), "dvbs.%d", fileno_index);
1545 
1546  png_save(ctx, filename, pbuf, width, height);
1547 
1548  av_freep(&pbuf);
1549  }
1550 
1551  fileno_index++;
1552  return 0;
1553 }
1554 #endif /* DEBUG */
1555 
1557  const uint8_t *buf,
1558  int buf_size)
1559 {
1560  DVBSubContext *ctx = avctx->priv_data;
1561  DVBSubDisplayDefinition *display_def = ctx->display_definition;
1562  int dds_version, info_byte;
1563 
1564  if (buf_size < 5)
1565  return AVERROR_INVALIDDATA;
1566 
1567  info_byte = bytestream_get_byte(&buf);
1568  dds_version = info_byte >> 4;
1569  if (display_def && display_def->version == dds_version)
1570  return 0; // already have this display definition version
1571 
1572  if (!display_def) {
1573  display_def = av_mallocz(sizeof(*display_def));
1574  if (!display_def)
1575  return AVERROR(ENOMEM);
1576  ctx->display_definition = display_def;
1577  }
1578 
1579  display_def->version = dds_version;
1580  display_def->x = 0;
1581  display_def->y = 0;
1582  display_def->width = bytestream_get_be16(&buf) + 1;
1583  display_def->height = bytestream_get_be16(&buf) + 1;
1584  if (!avctx->width || !avctx->height) {
1585  int ret = ff_set_dimensions(avctx, display_def->width, display_def->height);
1586  if (ret < 0)
1587  return ret;
1588  }
1589 
1590  if (info_byte & 1<<3) { // display_window_flag
1591  if (buf_size < 13)
1592  return AVERROR_INVALIDDATA;
1593 
1594  display_def->x = bytestream_get_be16(&buf);
1595  display_def->width = bytestream_get_be16(&buf) - display_def->x + 1;
1596  display_def->y = bytestream_get_be16(&buf);
1597  display_def->height = bytestream_get_be16(&buf) - display_def->y + 1;
1598  }
1599 
1600  return 0;
1601 }
1602 
1603 static int dvbsub_display_end_segment(AVCodecContext *avctx, const uint8_t *buf,
1604  int buf_size, AVSubtitle *sub,int *got_output)
1605 {
1606  DVBSubContext *ctx = avctx->priv_data;
1607 
1608  if (ctx->compute_edt == 0)
1609  save_subtitle_set(avctx, sub, got_output);
1610 #ifdef DEBUG
1611  save_display_set(ctx);
1612 #endif
1613  return 0;
1614 }
1615 
1616 static int dvbsub_decode(AVCodecContext *avctx,
1617  void *data, int *got_sub_ptr,
1618  AVPacket *avpkt)
1619 {
1620  const uint8_t *buf = avpkt->data;
1621  int buf_size = avpkt->size;
1622  DVBSubContext *ctx = avctx->priv_data;
1623  AVSubtitle *sub = data;
1624  const uint8_t *p, *p_end;
1625  int segment_type;
1626  int page_id;
1627  int segment_length;
1628  int i;
1629  int ret = 0;
1630  int got_segment = 0;
1631  int got_dds = 0;
1632 
1633  ff_dlog(avctx, "DVB sub packet:\n");
1634 
1635  for (i=0; i < buf_size; i++) {
1636  ff_dlog(avctx, "%02x ", buf[i]);
1637  if (i % 16 == 15)
1638  ff_dlog(avctx, "\n");
1639  }
1640 
1641  if (i % 16)
1642  ff_dlog(avctx, "\n");
1643 
1644  if (buf_size <= 6 || *buf != 0x0f) {
1645  ff_dlog(avctx, "incomplete or broken packet");
1646  return AVERROR_INVALIDDATA;
1647  }
1648 
1649  p = buf;
1650  p_end = buf + buf_size;
1651 
1652  while (p_end - p >= 6 && *p == 0x0f) {
1653  p += 1;
1654  segment_type = *p++;
1655  page_id = AV_RB16(p);
1656  p += 2;
1657  segment_length = AV_RB16(p);
1658  p += 2;
1659 
1660  if (avctx->debug & FF_DEBUG_STARTCODE) {
1661  av_log(avctx, AV_LOG_DEBUG, "segment_type:%d page_id:%d segment_length:%d\n", segment_type, page_id, segment_length);
1662  }
1663 
1664  if (p_end - p < segment_length) {
1665  ff_dlog(avctx, "incomplete or broken packet");
1666  ret = -1;
1667  goto end;
1668  }
1669 
1670  if (page_id == ctx->composition_id || page_id == ctx->ancillary_id ||
1671  ctx->composition_id == -1 || ctx->ancillary_id == -1) {
1672  int ret = 0;
1673  switch (segment_type) {
1674  case DVBSUB_PAGE_SEGMENT:
1675  ret = dvbsub_parse_page_segment(avctx, p, segment_length, sub, got_sub_ptr);
1676  got_segment |= 1;
1677  break;
1678  case DVBSUB_REGION_SEGMENT:
1679  ret = dvbsub_parse_region_segment(avctx, p, segment_length);
1680  got_segment |= 2;
1681  break;
1682  case DVBSUB_CLUT_SEGMENT:
1683  ret = dvbsub_parse_clut_segment(avctx, p, segment_length);
1684  if (ret < 0) goto end;
1685  got_segment |= 4;
1686  break;
1687  case DVBSUB_OBJECT_SEGMENT:
1688  ret = dvbsub_parse_object_segment(avctx, p, segment_length);
1689  got_segment |= 8;
1690  break;
1693  segment_length);
1694  got_dds = 1;
1695  break;
1697  ret = dvbsub_display_end_segment(avctx, p, segment_length, sub, got_sub_ptr);
1698  if (got_segment == 15 && !got_dds && !avctx->width && !avctx->height) {
1699  // Default from ETSI EN 300 743 V1.3.1 (7.2.1)
1700  avctx->width = 720;
1701  avctx->height = 576;
1702  }
1703  got_segment |= 16;
1704  break;
1705  default:
1706  ff_dlog(avctx, "Subtitling segment type 0x%x, page id %d, length %d\n",
1707  segment_type, page_id, segment_length);
1708  break;
1709  }
1710  if (ret < 0)
1711  goto end;
1712  }
1713 
1714  p += segment_length;
1715  }
1716  // Some streams do not send a display segment but if we have all the other
1717  // segments then we need no further data.
1718  if (got_segment == 15) {
1719  av_log(avctx, AV_LOG_DEBUG, "Missing display_end_segment, emulating\n");
1720  dvbsub_display_end_segment(avctx, p, 0, sub, got_sub_ptr);
1721  }
1722 
1723 end:
1724  if (ret < 0) {
1725  *got_sub_ptr = 0;
1726  avsubtitle_free(sub);
1727  return ret;
1728  } else {
1729  if (ctx->compute_edt == 1)
1730  FFSWAP(int64_t, ctx->prev_start, sub->pts);
1731  }
1732 
1733  return p - buf;
1734 }
1735 
1736 #define DS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_SUBTITLE_PARAM
1737 #define OFFSET(x) offsetof(DVBSubContext, x)
1738 static const AVOption options[] = {
1739  {"compute_edt", "compute end of time using pts or timeout", OFFSET(compute_edt), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DS},
1740  {"compute_clut", "compute clut when not available(-1) or always(1) or never(0)", OFFSET(compute_clut), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, DS},
1741  {"dvb_substream", "", OFFSET(substream), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, DS},
1742  {NULL}
1743 };
1744 static const AVClass dvbsubdec_class = {
1745  .class_name = "DVB Sub Decoder",
1746  .item_name = av_default_item_name,
1747  .option = options,
1748  .version = LIBAVUTIL_VERSION_INT,
1749 };
1750 
1752  .name = "dvbsub",
1753  .long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"),
1754  .type = AVMEDIA_TYPE_SUBTITLE,
1756  .priv_data_size = sizeof(DVBSubContext),
1758  .close = dvbsub_close_decoder,
1759  .decode = dvbsub_decode,
1760  .priv_class = &dvbsubdec_class,
1761 };
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:2660
static DVBSubRegion * get_region(DVBSubContext *ctx, int region_id)
Definition: dvbsubdec.c:164
AVOption.
Definition: opt.h:248
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:200
#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:106
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:2664
int size
Definition: packet.h:364
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
#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:2698
#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:237
static int dvbsub_parse_page_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size, AVSubtitle *sub, int *got_output)
Definition: dvbsubdec.c:1296
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:91
AVCodec.
Definition: codec.h:190
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
attribute_deprecated AVPicture pict
Definition: avcodec.h:2671
static int dvbsub_decode(AVCodecContext *avctx, void *data, int *got_sub_ptr, AVPacket *avpkt)
Definition: dvbsubdec.c:1616
#define OFFSET(x)
Definition: dvbsubdec.c:1737
AVSubtitleRect ** rects
Definition: avcodec.h:2699
int w
width of pict, undefined when pict is not set
Definition: avcodec.h:2662
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:215
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:88
bool full_range
#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:92
attribute_deprecated int linesize[AV_NUM_DATA_POINTERS]
number of bytes per line
Definition: avcodec.h:2631
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
static const AVClass dvbsubdec_class
Definition: dvbsubdec.c:1744
#define height
uint8_t * data
Definition: packet.h:363
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:2663
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:194
Various defines for YUV<->RGB conversion.
int y
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:2661
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:153
const char * r
Definition: vf_curves.c:114
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
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:1556
const char * name
Name of the codec implementation.
Definition: codec.h:197
uint8_t bits
Definition: vp3data.h:202
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:2256
GLsizei count
Definition: opengl_enc.c:108
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:123
uint32_t end_display_time
Definition: avcodec.h:2697
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:2700
struct DVBSubObject * next
Definition: dvbsubdec.c:76
AVCodec ff_dvbsub_decoder
Definition: dvbsubdec.c:1751
A bitmap, pict will be set.
Definition: avcodec.h:2642
int linesize[4]
Definition: avcodec.h:2678
#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:699
static int dvbsub_parse_clut_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: dvbsubdec.c:1049
#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:2629
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:2677
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define DS
Definition: dvbsubdec.c:1736
#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:205
#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:1611
static const int16_t alpha[]
Definition: ilbcdata.h:55
main external API structure.
Definition: avcodec.h:526
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:1603
static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Definition: vf_drawtext.c:871
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: utils.c:1114
DVBSubCLUT * clut_list
Definition: dvbsubdec.c:134
static DVBSubObject * get_object(DVBSubContext *ctx, int object_id)
Definition: dvbsubdec.c:142
int extradata_size
Definition: avcodec.h:628
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:1592
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
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
static const AVOption options[]
Definition: dvbsubdec.c:1738
#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
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...
Definition: imgutils.c:288
void * priv_data
Definition: avcodec.h:553
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:663
#define av_free(p)
#define FF_DEBUG_STARTCODE
Definition: avcodec.h:1625
#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 float sub(float src0, float src1)
static int dvbsub_parse_region_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: dvbsubdec.c:1148
#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:216
enum AVSubtitleType type
Definition: avcodec.h:2680
static av_cold int dvbsub_close_decoder(AVCodecContext *avctx)
Definition: dvbsubdec.c:346
This structure stores compressed data.
Definition: packet.h:340
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:1589
int i
Definition: input.c:407
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define av_unused
Definition: attributes.h:131
int has_computed_clut
Definition: dvbsubdec.c:100
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190