2 * DVB subtitle decoding
3 * Copyright (c) 2005 Ian Caulfield
5 * This file is part of FFmpeg.
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.
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.
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
24 #include "bytestream.h"
25 #include "libavutil/colorspace.h"
26 #include "libavutil/opt.h"
28 #define DVBSUB_PAGE_SEGMENT 0x10
29 #define DVBSUB_REGION_SEGMENT 0x11
30 #define DVBSUB_CLUT_SEGMENT 0x12
31 #define DVBSUB_OBJECT_SEGMENT 0x13
32 #define DVBSUB_DISPLAYDEFINITION_SEGMENT 0x14
33 #define DVBSUB_DISPLAY_SEGMENT 0x80
35 #define cm (ff_crop_tab + MAX_NEG_CROP)
39 static void png_save(const char *filename
, uint8_t *bitmap
, int w
, int h
,
40 uint32_t *rgba_palette
)
44 char fname
[40], fname2
[40];
47 snprintf(fname
, 40, "%s.ppm", filename
);
49 f
= fopen(fname
, "w");
58 for(y
= 0; y
< h
; y
++) {
59 for(x
= 0; x
< w
; x
++) {
60 v
= rgba_palette
[bitmap
[y
* w
+ x
]];
61 putc((v
>> 16) & 0xff, f
);
62 putc((v
>> 8) & 0xff, f
);
63 putc((v
>> 0) & 0xff, f
);
69 snprintf(fname2
, 40, "%s-a.pgm", filename
);
71 f
= fopen(fname2
, "w");
80 for(y
= 0; y
< h
; y
++) {
81 for(x
= 0; x
< w
; x
++) {
82 v
= rgba_palette
[bitmap
[y
* w
+ x
]];
83 putc((v
>> 24) & 0xff, f
);
88 snprintf(command
, 1024, "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2
, fname
, filename
);
91 snprintf(command
, 1024, "rm %s %s", fname
, fname2
);
96 static void png_save2(const char *filename
, uint32_t *bitmap
, int w
, int h
)
100 char fname
[40], fname2
[40];
103 snprintf(fname
, sizeof(fname
), "%s.ppm", filename
);
105 f
= fopen(fname
, "w");
114 for(y
= 0; y
< h
; y
++) {
115 for(x
= 0; x
< w
; x
++) {
116 v
= bitmap
[y
* w
+ x
];
117 putc((v
>> 16) & 0xff, f
);
118 putc((v
>> 8) & 0xff, f
);
119 putc((v
>> 0) & 0xff, f
);
125 snprintf(fname2
, sizeof(fname2
), "%s-a.pgm", filename
);
127 f
= fopen(fname2
, "w");
136 for(y
= 0; y
< h
; y
++) {
137 for(x
= 0; x
< w
; x
++) {
138 v
= bitmap
[y
* w
+ x
];
139 putc((v
>> 24) & 0xff, f
);
144 snprintf(command
, sizeof(command
), "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2
, fname
, filename
);
147 snprintf(command
, sizeof(command
), "rm %s %s", fname
, fname2
);
152 #define RGBA(r,g,b,a) (((unsigned)(a) << 24) | ((r) << 16) | ((g) << 8) | (b))
154 typedef struct DVBSubCLUT
{
160 uint32_t clut256
[256];
162 struct DVBSubCLUT
*next
;
165 static DVBSubCLUT default_clut
;
167 typedef struct DVBSubObjectDisplay
{
177 struct DVBSubObjectDisplay
*region_list_next
;
178 struct DVBSubObjectDisplay
*object_list_next
;
179 } DVBSubObjectDisplay
;
181 typedef struct DVBSubObject
{
187 DVBSubObjectDisplay
*display_list
;
189 struct DVBSubObject
*next
;
192 typedef struct DVBSubRegionDisplay
{
198 struct DVBSubRegionDisplay
*next
;
199 } DVBSubRegionDisplay
;
201 typedef struct DVBSubRegion
{
216 DVBSubObjectDisplay
*display_list
;
218 struct DVBSubRegion
*next
;
221 typedef struct DVBSubDisplayDefinition
{
228 } DVBSubDisplayDefinition
;
230 typedef struct DVBSubContext
{
237 int compute_edt
; /**< if 1 end display time calculated using pts
238 if 0 (Default) calculated using time out */
240 DVBSubRegion
*region_list
;
241 DVBSubCLUT
*clut_list
;
242 DVBSubObject
*object_list
;
244 DVBSubRegionDisplay
*display_list
;
245 DVBSubDisplayDefinition
*display_definition
;
249 static DVBSubObject
* get_object(DVBSubContext
*ctx
, int object_id
)
251 DVBSubObject
*ptr
= ctx
->object_list
;
253 while (ptr
&& ptr
->id
!= object_id
) {
260 static DVBSubCLUT
* get_clut(DVBSubContext
*ctx
, int clut_id
)
262 DVBSubCLUT
*ptr
= ctx
->clut_list
;
264 while (ptr
&& ptr
->id
!= clut_id
) {
271 static DVBSubRegion
* get_region(DVBSubContext
*ctx
, int region_id
)
273 DVBSubRegion
*ptr
= ctx
->region_list
;
275 while (ptr
&& ptr
->id
!= region_id
) {
282 static void delete_region_display_list(DVBSubContext
*ctx
, DVBSubRegion
*region
)
284 DVBSubObject
*object
, *obj2
, **obj2_ptr
;
285 DVBSubObjectDisplay
*display
, *obj_disp
, **obj_disp_ptr
;
287 while (region
->display_list
) {
288 display
= region
->display_list
;
290 object
= get_object(ctx
, display
->object_id
);
293 obj_disp_ptr
= &object
->display_list
;
294 obj_disp
= *obj_disp_ptr
;
296 while (obj_disp
&& obj_disp
!= display
) {
297 obj_disp_ptr
= &obj_disp
->object_list_next
;
298 obj_disp
= *obj_disp_ptr
;
302 *obj_disp_ptr
= obj_disp
->object_list_next
;
304 if (!object
->display_list
) {
305 obj2_ptr
= &ctx
->object_list
;
308 while (obj2
!= object
) {
310 obj2_ptr
= &obj2
->next
;
314 *obj2_ptr
= obj2
->next
;
321 region
->display_list
= display
->region_list_next
;
328 static void delete_cluts(DVBSubContext
*ctx
)
332 while (ctx
->clut_list
) {
333 clut
= ctx
->clut_list
;
335 ctx
->clut_list
= clut
->next
;
341 static void delete_objects(DVBSubContext
*ctx
)
343 DVBSubObject
*object
;
345 while (ctx
->object_list
) {
346 object
= ctx
->object_list
;
348 ctx
->object_list
= object
->next
;
354 static void delete_regions(DVBSubContext
*ctx
)
356 DVBSubRegion
*region
;
358 while (ctx
->region_list
) {
359 region
= ctx
->region_list
;
361 ctx
->region_list
= region
->next
;
363 delete_region_display_list(ctx
, region
);
365 av_free(region
->pbuf
);
370 static av_cold
int dvbsub_init_decoder(AVCodecContext
*avctx
)
372 int i
, r
, g
, b
, a
= 0;
373 DVBSubContext
*ctx
= avctx
->priv_data
;
375 if (!avctx
->extradata
|| (avctx
->extradata_size
< 4) || ((avctx
->extradata_size
% 5 != 0) && (avctx
->extradata_size
!= 4))) {
376 av_log(avctx
, AV_LOG_WARNING
, "Invalid DVB subtitles stream extradata!\n");
377 ctx
->composition_id
= -1;
378 ctx
->ancillary_id
= -1;
380 if (avctx
->extradata_size
> 5) {
381 av_log(avctx
, AV_LOG_WARNING
, "Decoding first DVB subtitles sub-stream\n");
384 ctx
->composition_id
= AV_RB16(avctx
->extradata
);
385 ctx
->ancillary_id
= AV_RB16(avctx
->extradata
+ 2);
389 ctx
->prev_start
= AV_NOPTS_VALUE
;
391 default_clut
.id
= -1;
392 default_clut
.next
= NULL
;
394 default_clut
.clut4
[0] = RGBA( 0, 0, 0, 0);
395 default_clut
.clut4
[1] = RGBA(255, 255, 255, 255);
396 default_clut
.clut4
[2] = RGBA( 0, 0, 0, 255);
397 default_clut
.clut4
[3] = RGBA(127, 127, 127, 255);
399 default_clut
.clut16
[0] = RGBA( 0, 0, 0, 0);
400 for (i
= 1; i
< 16; i
++) {
402 r
= (i
& 1) ? 255 : 0;
403 g
= (i
& 2) ? 255 : 0;
404 b
= (i
& 4) ? 255 : 0;
406 r
= (i
& 1) ? 127 : 0;
407 g
= (i
& 2) ? 127 : 0;
408 b
= (i
& 4) ? 127 : 0;
410 default_clut
.clut16
[i
] = RGBA(r
, g
, b
, 255);
413 default_clut
.clut256
[0] = RGBA( 0, 0, 0, 0);
414 for (i
= 1; i
< 256; i
++) {
416 r
= (i
& 1) ? 255 : 0;
417 g
= (i
& 2) ? 255 : 0;
418 b
= (i
& 4) ? 255 : 0;
423 r
= ((i
& 1) ? 85 : 0) + ((i
& 0x10) ? 170 : 0);
424 g
= ((i
& 2) ? 85 : 0) + ((i
& 0x20) ? 170 : 0);
425 b
= ((i
& 4) ? 85 : 0) + ((i
& 0x40) ? 170 : 0);
429 r
= ((i
& 1) ? 85 : 0) + ((i
& 0x10) ? 170 : 0);
430 g
= ((i
& 2) ? 85 : 0) + ((i
& 0x20) ? 170 : 0);
431 b
= ((i
& 4) ? 85 : 0) + ((i
& 0x40) ? 170 : 0);
435 r
= 127 + ((i
& 1) ? 43 : 0) + ((i
& 0x10) ? 85 : 0);
436 g
= 127 + ((i
& 2) ? 43 : 0) + ((i
& 0x20) ? 85 : 0);
437 b
= 127 + ((i
& 4) ? 43 : 0) + ((i
& 0x40) ? 85 : 0);
441 r
= ((i
& 1) ? 43 : 0) + ((i
& 0x10) ? 85 : 0);
442 g
= ((i
& 2) ? 43 : 0) + ((i
& 0x20) ? 85 : 0);
443 b
= ((i
& 4) ? 43 : 0) + ((i
& 0x40) ? 85 : 0);
448 default_clut
.clut256
[i
] = RGBA(r
, g
, b
, a
);
454 static av_cold
int dvbsub_close_decoder(AVCodecContext
*avctx
)
456 DVBSubContext
*ctx
= avctx
->priv_data
;
457 DVBSubRegionDisplay
*display
;
465 av_freep(&ctx
->display_definition
);
467 while (ctx
->display_list
) {
468 display
= ctx
->display_list
;
469 ctx
->display_list
= display
->next
;
477 static int dvbsub_read_2bit_string(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
)
485 int pixels_read
= x_pos
;
487 init_get_bits(&gb
, *srcbuf
, buf_size
<< 3);
491 while (get_bits_count(&gb
) < buf_size
<< 3 && pixels_read
< dbuf_len
) {
492 bits
= get_bits(&gb
, 2);
495 if (non_mod
!= 1 || bits
!= 1) {
497 *destbuf
++ = map_table
[bits
];
503 bits
= get_bits1(&gb
);
505 run_length
= get_bits(&gb
, 3) + 3;
506 bits
= get_bits(&gb
, 2);
508 if (non_mod
== 1 && bits
== 1)
509 pixels_read
+= run_length
;
512 bits
= map_table
[bits
];
513 while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
519 bits
= get_bits1(&gb
);
521 bits
= get_bits(&gb
, 2);
523 run_length
= get_bits(&gb
, 4) + 12;
524 bits
= get_bits(&gb
, 2);
526 if (non_mod
== 1 && bits
== 1)
527 pixels_read
+= run_length
;
530 bits
= map_table
[bits
];
531 while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
536 } else if (bits
== 3) {
537 run_length
= get_bits(&gb
, 8) + 29;
538 bits
= get_bits(&gb
, 2);
540 if (non_mod
== 1 && bits
== 1)
541 pixels_read
+= run_length
;
544 bits
= map_table
[bits
];
545 while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
550 } else if (bits
== 1) {
556 while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
561 (*srcbuf
) += (get_bits_count(&gb
) + 7) >> 3;
576 if (get_bits(&gb
, 6))
577 av_log(0, AV_LOG_ERROR
, "DVBSub error: line overflow\n");
579 (*srcbuf
) += (get_bits_count(&gb
) + 7) >> 3;
584 static int dvbsub_read_4bit_string(uint8_t *destbuf
, int dbuf_len
,
585 const uint8_t **srcbuf
, int buf_size
,
586 int non_mod
, uint8_t *map_table
, int x_pos
)
592 int pixels_read
= x_pos
;
594 init_get_bits(&gb
, *srcbuf
, buf_size
<< 3);
598 while (get_bits_count(&gb
) < buf_size
<< 3 && pixels_read
< dbuf_len
) {
599 bits
= get_bits(&gb
, 4);
602 if (non_mod
!= 1 || bits
!= 1) {
604 *destbuf
++ = map_table
[bits
];
610 bits
= get_bits1(&gb
);
612 run_length
= get_bits(&gb
, 3);
614 if (run_length
== 0) {
615 (*srcbuf
) += (get_bits_count(&gb
) + 7) >> 3;
626 while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
631 bits
= get_bits1(&gb
);
633 run_length
= get_bits(&gb
, 2) + 4;
634 bits
= get_bits(&gb
, 4);
636 if (non_mod
== 1 && bits
== 1)
637 pixels_read
+= run_length
;
640 bits
= map_table
[bits
];
641 while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
647 bits
= get_bits(&gb
, 2);
649 run_length
= get_bits(&gb
, 4) + 9;
650 bits
= get_bits(&gb
, 4);
652 if (non_mod
== 1 && bits
== 1)
653 pixels_read
+= run_length
;
656 bits
= map_table
[bits
];
657 while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
662 } else if (bits
== 3) {
663 run_length
= get_bits(&gb
, 8) + 25;
664 bits
= get_bits(&gb
, 4);
666 if (non_mod
== 1 && bits
== 1)
667 pixels_read
+= run_length
;
670 bits
= map_table
[bits
];
671 while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
676 } else if (bits
== 1) {
682 while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
699 if (get_bits(&gb
, 8))
700 av_log(0, AV_LOG_ERROR
, "DVBSub error: line overflow\n");
702 (*srcbuf
) += (get_bits_count(&gb
) + 7) >> 3;
707 static int dvbsub_read_8bit_string(uint8_t *destbuf
, int dbuf_len
,
708 const uint8_t **srcbuf
, int buf_size
,
709 int non_mod
, uint8_t *map_table
, int x_pos
)
711 const uint8_t *sbuf_end
= (*srcbuf
) + buf_size
;
714 int pixels_read
= x_pos
;
718 while (*srcbuf
< sbuf_end
&& pixels_read
< dbuf_len
) {
722 if (non_mod
!= 1 || bits
!= 1) {
724 *destbuf
++ = map_table
[bits
];
731 run_length
= bits
& 0x7f;
732 if ((bits
& 0x80) == 0) {
733 if (run_length
== 0) {
741 while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
748 if (non_mod
== 1 && bits
== 1)
749 pixels_read
+= run_length
;
751 bits
= map_table
[bits
];
752 else while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
761 av_log(0, AV_LOG_ERROR
, "DVBSub error: line overflow\n");
766 static void save_subtitle_set(AVCodecContext
*avctx
, AVSubtitle
*sub
, int *got_output
)
768 DVBSubContext
*ctx
= avctx
->priv_data
;
769 DVBSubRegionDisplay
*display
;
770 DVBSubDisplayDefinition
*display_def
= ctx
->display_definition
;
771 DVBSubRegion
*region
;
772 AVSubtitleRect
*rect
;
774 uint32_t *clut_table
;
776 int offset_x
=0, offset_y
=0;
780 offset_x
= display_def
->x
;
781 offset_y
= display_def
->y
;
784 /* Not touching AVSubtitles again*/
786 avpriv_request_sample(ctx
, "Different Version of Segment asked Twice\n");
789 for (display
= ctx
->display_list
; display
; display
= display
->next
) {
790 region
= get_region(ctx
, display
->region_id
);
791 if (region
&& region
->dirty
)
795 if(ctx
->compute_edt
== 0) {
796 sub
->end_display_time
= ctx
->time_out
* 1000;
798 } else if (ctx
->prev_start
!= AV_NOPTS_VALUE
) {
799 sub
->end_display_time
= av_rescale_q((sub
->pts
- ctx
->prev_start
), AV_TIME_BASE_Q
, (AVRational
){ 1, 1000 }) - 1;
802 if (sub
->num_rects
> 0) {
804 sub
->rects
= av_mallocz_array(sizeof(*sub
->rects
), sub
->num_rects
);
805 for(i
=0; i
<sub
->num_rects
; i
++)
806 sub
->rects
[i
] = av_mallocz(sizeof(*sub
->rects
[i
]));
810 for (display
= ctx
->display_list
; display
; display
= display
->next
) {
811 region
= get_region(ctx
, display
->region_id
);
819 rect
= sub
->rects
[i
];
820 rect
->x
= display
->x_pos
+ offset_x
;
821 rect
->y
= display
->y_pos
+ offset_y
;
822 rect
->w
= region
->width
;
823 rect
->h
= region
->height
;
824 rect
->nb_colors
= (1 << region
->depth
);
825 rect
->type
= SUBTITLE_BITMAP
;
826 rect
->pict
.linesize
[0] = region
->width
;
828 clut
= get_clut(ctx
, region
->clut
);
831 clut
= &default_clut
;
833 switch (region
->depth
) {
835 clut_table
= clut
->clut4
;
838 clut_table
= clut
->clut256
;
842 clut_table
= clut
->clut16
;
846 rect
->pict
.data
[1] = av_mallocz(AVPALETTE_SIZE
);
847 memcpy(rect
->pict
.data
[1], clut_table
, (1 << region
->depth
) * sizeof(uint32_t));
849 rect
->pict
.data
[0] = av_malloc(region
->buf_size
);
850 memcpy(rect
->pict
.data
[0], region
->pbuf
, region
->buf_size
);
857 static void dvbsub_parse_pixel_data_block(AVCodecContext
*avctx
, DVBSubObjectDisplay
*display
,
858 const uint8_t *buf
, int buf_size
, int top_bottom
, int non_mod
)
860 DVBSubContext
*ctx
= avctx
->priv_data
;
862 DVBSubRegion
*region
= get_region(ctx
, display
->region_id
);
863 const uint8_t *buf_end
= buf
+ buf_size
;
868 uint8_t map2to4
[] = { 0x0, 0x7, 0x8, 0xf};
869 uint8_t map2to8
[] = {0x00, 0x77, 0x88, 0xff};
870 uint8_t map4to8
[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
871 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
875 av_dlog(avctx
, "DVB pixel block size %d, %s field:\n", buf_size
,
876 top_bottom
? "bottom" : "top");
878 for (i
= 0; i
< buf_size
; i
++) {
880 av_dlog(avctx
, "0x%8p: ", buf
+i
);
882 av_dlog(avctx
, "%02x ", buf
[i
]);
884 av_dlog(avctx
, "\n");
888 av_dlog(avctx
, "\n");
897 x_pos
= display
->x_pos
;
898 y_pos
= display
->y_pos
;
902 while (buf
< buf_end
) {
903 if ((*buf
!=0xf0 && x_pos
>= region
->width
) || y_pos
>= region
->height
) {
904 av_log(avctx
, AV_LOG_ERROR
, "Invalid object location! %d-%d %d-%d %02x\n", x_pos
, region
->width
, y_pos
, region
->height
, *buf
);
910 if (region
->depth
== 8)
912 else if (region
->depth
== 4)
917 x_pos
= dvbsub_read_2bit_string(pbuf
+ (y_pos
* region
->width
),
918 region
->width
, &buf
, buf_end
- buf
,
919 non_mod
, map_table
, x_pos
);
922 if (region
->depth
< 4) {
923 av_log(avctx
, AV_LOG_ERROR
, "4-bit pixel string in %d-bit region!\n", region
->depth
);
927 if (region
->depth
== 8)
932 x_pos
= dvbsub_read_4bit_string(pbuf
+ (y_pos
* region
->width
),
933 region
->width
, &buf
, buf_end
- buf
,
934 non_mod
, map_table
, x_pos
);
937 if (region
->depth
< 8) {
938 av_log(avctx
, AV_LOG_ERROR
, "8-bit pixel string in %d-bit region!\n", region
->depth
);
942 x_pos
= dvbsub_read_8bit_string(pbuf
+ (y_pos
* region
->width
),
943 region
->width
, &buf
, buf_end
- buf
,
944 non_mod
, NULL
, x_pos
);
948 map2to4
[0] = (*buf
) >> 4;
949 map2to4
[1] = (*buf
++) & 0xf;
950 map2to4
[2] = (*buf
) >> 4;
951 map2to4
[3] = (*buf
++) & 0xf;
954 for (i
= 0; i
< 4; i
++)
958 for (i
= 0; i
< 16; i
++)
963 x_pos
= display
->x_pos
;
967 av_log(avctx
, AV_LOG_INFO
, "Unknown/unsupported pixel block 0x%x\n", *(buf
-1));
973 static void dvbsub_parse_object_segment(AVCodecContext
*avctx
,
974 const uint8_t *buf
, int buf_size
)
976 DVBSubContext
*ctx
= avctx
->priv_data
;
978 const uint8_t *buf_end
= buf
+ buf_size
;
980 DVBSubObject
*object
;
981 DVBSubObjectDisplay
*display
;
982 int top_field_len
, bottom_field_len
;
984 int coding_method
, non_modifying_color
;
986 object_id
= AV_RB16(buf
);
989 object
= get_object(ctx
, object_id
);
994 coding_method
= ((*buf
) >> 2) & 3;
995 non_modifying_color
= ((*buf
++) >> 1) & 1;
997 if (coding_method
== 0) {
998 top_field_len
= AV_RB16(buf
);
1000 bottom_field_len
= AV_RB16(buf
);
1003 if (buf
+ top_field_len
+ bottom_field_len
> buf_end
) {
1004 av_log(avctx
, AV_LOG_ERROR
, "Field data size too large\n");
1008 for (display
= object
->display_list
; display
; display
= display
->object_list_next
) {
1009 const uint8_t *block
= buf
;
1010 int bfl
= bottom_field_len
;
1012 dvbsub_parse_pixel_data_block(avctx
, display
, block
, top_field_len
, 0,
1013 non_modifying_color
);
1015 if (bottom_field_len
> 0)
1016 block
= buf
+ top_field_len
;
1018 bfl
= top_field_len
;
1020 dvbsub_parse_pixel_data_block(avctx
, display
, block
, bfl
, 1,
1021 non_modifying_color
);
1024 /* } else if (coding_method == 1) {*/
1027 av_log(avctx
, AV_LOG_ERROR
, "Unknown object coding %d\n", coding_method
);
1032 static int dvbsub_parse_clut_segment(AVCodecContext
*avctx
,
1033 const uint8_t *buf
, int buf_size
)
1035 DVBSubContext
*ctx
= avctx
->priv_data
;
1037 const uint8_t *buf_end
= buf
+ buf_size
;
1041 int entry_id
, depth
, full_range
;
1042 int y
, cr
, cb
, alpha
;
1043 int r
, g
, b
, r_add
, g_add
, b_add
;
1045 av_dlog(avctx
, "DVB clut packet:\n");
1047 for (i
=0; i
< buf_size
; i
++) {
1048 av_dlog(avctx
, "%02x ", buf
[i
]);
1050 av_dlog(avctx
, "\n");
1054 av_dlog(avctx
, "\n");
1057 version
= ((*buf
)>>4)&15;
1060 clut
= get_clut(ctx
, clut_id
);
1063 clut
= av_malloc(sizeof(DVBSubCLUT
));
1065 memcpy(clut
, &default_clut
, sizeof(DVBSubCLUT
));
1070 clut
->next
= ctx
->clut_list
;
1071 ctx
->clut_list
= clut
;
1074 if (clut
->version
!= version
) {
1076 clut
->version
= version
;
1078 while (buf
+ 4 < buf_end
) {
1081 depth
= (*buf
) & 0xe0;
1084 av_log(avctx
, AV_LOG_ERROR
, "Invalid clut depth 0x%x!\n", *buf
);
1088 full_range
= (*buf
++) & 1;
1097 cr
= (((buf
[0] & 3) << 2) | ((buf
[1] >> 6) & 3)) << 4;
1098 cb
= (buf
[1] << 2) & 0xf0;
1099 alpha
= (buf
[1] << 6) & 0xc0;
1107 YUV_TO_RGB1_CCIR(cb
, cr
);
1108 YUV_TO_RGB2_CCIR(r
, g
, b
, y
);
1110 av_dlog(avctx
, "clut %d := (%d,%d,%d,%d)\n", entry_id
, r
, g
, b
, alpha
);
1111 if (!!(depth
& 0x80) + !!(depth
& 0x40) + !!(depth
& 0x20) > 1) {
1112 av_dlog(avctx
, "More than one bit level marked: %x\n", depth
);
1113 if (avctx
->strict_std_compliance
> FF_COMPLIANCE_NORMAL
)
1114 return AVERROR_INVALIDDATA
;
1118 clut
->clut4
[entry_id
] = RGBA(r
,g
,b
,255 - alpha
);
1119 else if (depth
& 0x40)
1120 clut
->clut16
[entry_id
] = RGBA(r
,g
,b
,255 - alpha
);
1121 else if (depth
& 0x20)
1122 clut
->clut256
[entry_id
] = RGBA(r
,g
,b
,255 - alpha
);
1129 static void dvbsub_parse_region_segment(AVCodecContext
*avctx
,
1130 const uint8_t *buf
, int buf_size
)
1132 DVBSubContext
*ctx
= avctx
->priv_data
;
1134 const uint8_t *buf_end
= buf
+ buf_size
;
1135 int region_id
, object_id
;
1136 int av_unused version
;
1137 DVBSubRegion
*region
;
1138 DVBSubObject
*object
;
1139 DVBSubObjectDisplay
*display
;
1147 region
= get_region(ctx
, region_id
);
1150 region
= av_mallocz(sizeof(DVBSubRegion
));
1152 region
->id
= region_id
;
1153 region
->version
= -1;
1155 region
->next
= ctx
->region_list
;
1156 ctx
->region_list
= region
;
1159 version
= ((*buf
)>>4) & 15;
1160 fill
= ((*buf
++) >> 3) & 1;
1162 region
->width
= AV_RB16(buf
);
1164 region
->height
= AV_RB16(buf
);
1167 if (region
->width
* region
->height
!= region
->buf_size
) {
1168 av_free(region
->pbuf
);
1170 region
->buf_size
= region
->width
* region
->height
;
1172 region
->pbuf
= av_malloc(region
->buf_size
);
1178 region
->depth
= 1 << (((*buf
++) >> 2) & 7);
1179 if(region
->depth
<2 || region
->depth
>8){
1180 av_log(avctx
, AV_LOG_ERROR
, "region depth %d is invalid\n", region
->depth
);
1183 region
->clut
= *buf
++;
1185 if (region
->depth
== 8) {
1186 region
->bgcolor
= *buf
++;
1191 if (region
->depth
== 4)
1192 region
->bgcolor
= (((*buf
++) >> 4) & 15);
1194 region
->bgcolor
= (((*buf
++) >> 2) & 3);
1197 av_dlog(avctx
, "Region %d, (%dx%d)\n", region_id
, region
->width
, region
->height
);
1200 memset(region
->pbuf
, region
->bgcolor
, region
->buf_size
);
1201 av_dlog(avctx
, "Fill region (%d)\n", region
->bgcolor
);
1204 delete_region_display_list(ctx
, region
);
1206 while (buf
+ 5 < buf_end
) {
1207 object_id
= AV_RB16(buf
);
1210 object
= get_object(ctx
, object_id
);
1213 object
= av_mallocz(sizeof(DVBSubObject
));
1215 object
->id
= object_id
;
1216 object
->next
= ctx
->object_list
;
1217 ctx
->object_list
= object
;
1220 object
->type
= (*buf
) >> 6;
1222 display
= av_mallocz(sizeof(DVBSubObjectDisplay
));
1224 display
->object_id
= object_id
;
1225 display
->region_id
= region_id
;
1227 display
->x_pos
= AV_RB16(buf
) & 0xfff;
1229 display
->y_pos
= AV_RB16(buf
) & 0xfff;
1232 if ((object
->type
== 1 || object
->type
== 2) && buf
+1 < buf_end
) {
1233 display
->fgcolor
= *buf
++;
1234 display
->bgcolor
= *buf
++;
1237 display
->region_list_next
= region
->display_list
;
1238 region
->display_list
= display
;
1240 display
->object_list_next
= object
->display_list
;
1241 object
->display_list
= display
;
1245 static void dvbsub_parse_page_segment(AVCodecContext
*avctx
,
1246 const uint8_t *buf
, int buf_size
, AVSubtitle
*sub
, int *got_output
)
1248 DVBSubContext
*ctx
= avctx
->priv_data
;
1249 DVBSubRegionDisplay
*display
;
1250 DVBSubRegionDisplay
*tmp_display_list
, **tmp_ptr
;
1252 const uint8_t *buf_end
= buf
+ buf_size
;
1262 version
= ((*buf
)>>4) & 15;
1263 page_state
= ((*buf
++) >> 2) & 3;
1265 if (ctx
->version
== version
) {
1269 ctx
->time_out
= timeout
;
1270 ctx
->version
= version
;
1272 av_dlog(avctx
, "Page time out %ds, state %d\n", ctx
->time_out
, page_state
);
1274 if(ctx
->compute_edt
== 1)
1275 save_subtitle_set(avctx
, sub
, got_output
);
1277 if (page_state
== 1 || page_state
== 2) {
1278 delete_regions(ctx
);
1279 delete_objects(ctx
);
1283 tmp_display_list
= ctx
->display_list
;
1284 ctx
->display_list
= NULL
;
1286 while (buf
+ 5 < buf_end
) {
1290 display
= tmp_display_list
;
1291 tmp_ptr
= &tmp_display_list
;
1293 while (display
&& display
->region_id
!= region_id
) {
1294 tmp_ptr
= &display
->next
;
1295 display
= display
->next
;
1299 display
= av_mallocz(sizeof(DVBSubRegionDisplay
));
1301 display
->region_id
= region_id
;
1303 display
->x_pos
= AV_RB16(buf
);
1305 display
->y_pos
= AV_RB16(buf
);
1308 *tmp_ptr
= display
->next
;
1310 display
->next
= ctx
->display_list
;
1311 ctx
->display_list
= display
;
1313 av_dlog(avctx
, "Region %d, (%d,%d)\n", region_id
, display
->x_pos
, display
->y_pos
);
1316 while (tmp_display_list
) {
1317 display
= tmp_display_list
;
1319 tmp_display_list
= display
->next
;
1328 static void save_display_set(DVBSubContext
*ctx
)
1330 DVBSubRegion
*region
;
1331 DVBSubRegionDisplay
*display
;
1333 uint32_t *clut_table
;
1334 int x_pos
, y_pos
, width
, height
;
1335 int x
, y
, y_off
, x_off
;
1338 static int fileno_index
= 0;
1345 for (display
= ctx
->display_list
; display
; display
= display
->next
) {
1346 region
= get_region(ctx
, display
->region_id
);
1349 x_pos
= display
->x_pos
;
1350 y_pos
= display
->y_pos
;
1351 width
= region
->width
;
1352 height
= region
->height
;
1354 if (display
->x_pos
< x_pos
) {
1355 width
+= (x_pos
- display
->x_pos
);
1356 x_pos
= display
->x_pos
;
1359 if (display
->y_pos
< y_pos
) {
1360 height
+= (y_pos
- display
->y_pos
);
1361 y_pos
= display
->y_pos
;
1364 if (display
->x_pos
+ region
->width
> x_pos
+ width
) {
1365 width
= display
->x_pos
+ region
->width
- x_pos
;
1368 if (display
->y_pos
+ region
->height
> y_pos
+ height
) {
1369 height
= display
->y_pos
+ region
->height
- y_pos
;
1376 pbuf
= av_malloc(width
* height
* 4);
1378 for (display
= ctx
->display_list
; display
; display
= display
->next
) {
1379 region
= get_region(ctx
, display
->region_id
);
1381 x_off
= display
->x_pos
- x_pos
;
1382 y_off
= display
->y_pos
- y_pos
;
1384 clut
= get_clut(ctx
, region
->clut
);
1387 clut
= &default_clut
;
1389 switch (region
->depth
) {
1391 clut_table
= clut
->clut4
;
1394 clut_table
= clut
->clut256
;
1398 clut_table
= clut
->clut16
;
1402 for (y
= 0; y
< region
->height
; y
++) {
1403 for (x
= 0; x
< region
->width
; x
++) {
1404 pbuf
[((y
+ y_off
) * width
) + x_off
+ x
] =
1405 clut_table
[region
->pbuf
[y
* region
->width
+ x
]];
1411 snprintf(filename
, sizeof(filename
), "dvbs.%d", fileno_index
);
1413 png_save2(filename
, pbuf
, width
, height
);
1422 static void dvbsub_parse_display_definition_segment(AVCodecContext
*avctx
,
1426 DVBSubContext
*ctx
= avctx
->priv_data
;
1427 DVBSubDisplayDefinition
*display_def
= ctx
->display_definition
;
1428 int dds_version
, info_byte
;
1433 info_byte
= bytestream_get_byte(&buf
);
1434 dds_version
= info_byte
>> 4;
1435 if (display_def
&& display_def
->version
== dds_version
)
1436 return; // already have this display definition version
1439 display_def
= av_mallocz(sizeof(*display_def
));
1440 ctx
->display_definition
= display_def
;
1445 display_def
->version
= dds_version
;
1448 display_def
->width
= bytestream_get_be16(&buf
) + 1;
1449 display_def
->height
= bytestream_get_be16(&buf
) + 1;
1450 if (!avctx
->width
|| !avctx
->height
) {
1451 avctx
->width
= display_def
->width
;
1452 avctx
->height
= display_def
->height
;
1458 if (info_byte
& 1<<3) { // display_window_flag
1459 display_def
->x
= bytestream_get_be16(&buf
);
1460 display_def
->width
= bytestream_get_be16(&buf
) - display_def
->x
+ 1;
1461 display_def
->y
= bytestream_get_be16(&buf
);
1462 display_def
->height
= bytestream_get_be16(&buf
) - display_def
->y
+ 1;
1466 static void dvbsub_display_end_segment(AVCodecContext
*avctx
, const uint8_t *buf
,
1467 int buf_size
, AVSubtitle
*sub
,int *got_output
)
1469 DVBSubContext
*ctx
= avctx
->priv_data
;
1471 if(ctx
->compute_edt
== 0)
1472 save_subtitle_set(avctx
, sub
, got_output
);
1474 save_display_set(ctx
);
1479 static int dvbsub_decode(AVCodecContext
*avctx
,
1480 void *data
, int *data_size
,
1483 const uint8_t *buf
= avpkt
->data
;
1484 int buf_size
= avpkt
->size
;
1485 DVBSubContext
*ctx
= avctx
->priv_data
;
1486 AVSubtitle
*sub
= data
;
1487 const uint8_t *p
, *p_end
;
1493 int got_segment
= 0;
1495 av_dlog(avctx
, "DVB sub packet:\n");
1497 for (i
=0; i
< buf_size
; i
++) {
1498 av_dlog(avctx
, "%02x ", buf
[i
]);
1500 av_dlog(avctx
, "\n");
1504 av_dlog(avctx
, "\n");
1506 if (buf_size
<= 6 || *buf
!= 0x0f) {
1507 av_dlog(avctx
, "incomplete or broken packet");
1512 p_end
= buf
+ buf_size
;
1514 while (p_end
- p
>= 6 && *p
== 0x0f) {
1516 segment_type
= *p
++;
1517 page_id
= AV_RB16(p
);
1519 segment_length
= AV_RB16(p
);
1522 if (avctx
->debug
& FF_DEBUG_STARTCODE
) {
1523 av_log(avctx
, AV_LOG_DEBUG
, "segment_type:%d page_id:%d segment_length:%d\n", segment_type
, page_id
, segment_length
);
1526 if (p_end
- p
< segment_length
) {
1527 av_dlog(avctx
, "incomplete or broken packet");
1532 if (page_id
== ctx
->composition_id
|| page_id
== ctx
->ancillary_id
||
1533 ctx
->composition_id
== -1 || ctx
->ancillary_id
== -1) {
1534 switch (segment_type
) {
1535 case DVBSUB_PAGE_SEGMENT
:
1536 dvbsub_parse_page_segment(avctx
, p
, segment_length
, sub
, data_size
);
1539 case DVBSUB_REGION_SEGMENT
:
1540 dvbsub_parse_region_segment(avctx
, p
, segment_length
);
1543 case DVBSUB_CLUT_SEGMENT
:
1544 ret
= dvbsub_parse_clut_segment(avctx
, p
, segment_length
);
1545 if (ret
< 0) goto end
;
1548 case DVBSUB_OBJECT_SEGMENT
:
1549 dvbsub_parse_object_segment(avctx
, p
, segment_length
);
1552 case DVBSUB_DISPLAYDEFINITION_SEGMENT
:
1553 dvbsub_parse_display_definition_segment(avctx
, p
, segment_length
);
1555 case DVBSUB_DISPLAY_SEGMENT
:
1556 dvbsub_display_end_segment(avctx
, p
, segment_length
, sub
, data_size
);
1560 av_dlog(avctx
, "Subtitling segment type 0x%x, page id %d, length %d\n",
1561 segment_type
, page_id
, segment_length
);
1566 p
+= segment_length
;
1568 // Some streams do not send a display segment but if we have all the other
1569 // segments then we need no further data.
1570 if (got_segment
== 15) {
1571 av_log(avctx
, AV_LOG_DEBUG
, "Missing display_end_segment, emulating\n");
1572 dvbsub_display_end_segment(avctx
, p
, 0, sub
, data_size
);
1578 avsubtitle_free(sub
);
1581 if(ctx
->compute_edt
== 1 )
1582 FFSWAP(int64_t, ctx
->prev_start
, sub
->pts
);
1588 #define DS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_SUBTITLE_PARAM
1589 static const AVOption options
[] = {
1590 {"compute_edt", "compute end of time using pts or timeout", offsetof(DVBSubContext
, compute_edt
), FF_OPT_TYPE_INT
, {.i64
= 0}, 0, 1, DS
},
1593 static const AVClass dvbsubdec_class
= {
1594 .class_name
= "DVB Sub Decoder",
1595 .item_name
= av_default_item_name
,
1597 .version
= LIBAVUTIL_VERSION_INT
,
1600 AVCodec ff_dvbsub_decoder
= {
1602 .long_name
= NULL_IF_CONFIG_SMALL("DVB subtitles"),
1603 .type
= AVMEDIA_TYPE_SUBTITLE
,
1604 .id
= AV_CODEC_ID_DVB_SUBTITLE
,
1605 .priv_data_size
= sizeof(DVBSubContext
),
1606 .init
= dvbsub_init_decoder
,
1607 .close
= dvbsub_close_decoder
,
1608 .decode
= dvbsub_decode
,
1609 .priv_class
= &dvbsubdec_class
,