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
)
330 while (ctx
->clut_list
) {
331 DVBSubCLUT
*clut
= ctx
->clut_list
;
333 ctx
->clut_list
= clut
->next
;
339 static void delete_objects(DVBSubContext
*ctx
)
341 while (ctx
->object_list
) {
342 DVBSubObject
*object
= ctx
->object_list
;
344 ctx
->object_list
= object
->next
;
350 static void delete_regions(DVBSubContext
*ctx
)
352 while (ctx
->region_list
) {
353 DVBSubRegion
*region
= ctx
->region_list
;
355 ctx
->region_list
= region
->next
;
357 delete_region_display_list(ctx
, region
);
359 av_freep(®ion
->pbuf
);
364 static av_cold
int dvbsub_init_decoder(AVCodecContext
*avctx
)
366 int i
, r
, g
, b
, a
= 0;
367 DVBSubContext
*ctx
= avctx
->priv_data
;
369 if (!avctx
->extradata
|| (avctx
->extradata_size
< 4) || ((avctx
->extradata_size
% 5 != 0) && (avctx
->extradata_size
!= 4))) {
370 av_log(avctx
, AV_LOG_WARNING
, "Invalid DVB subtitles stream extradata!\n");
371 ctx
->composition_id
= -1;
372 ctx
->ancillary_id
= -1;
374 if (avctx
->extradata_size
> 5) {
375 av_log(avctx
, AV_LOG_WARNING
, "Decoding first DVB subtitles sub-stream\n");
378 ctx
->composition_id
= AV_RB16(avctx
->extradata
);
379 ctx
->ancillary_id
= AV_RB16(avctx
->extradata
+ 2);
383 ctx
->prev_start
= AV_NOPTS_VALUE
;
385 default_clut
.id
= -1;
386 default_clut
.next
= NULL
;
388 default_clut
.clut4
[0] = RGBA( 0, 0, 0, 0);
389 default_clut
.clut4
[1] = RGBA(255, 255, 255, 255);
390 default_clut
.clut4
[2] = RGBA( 0, 0, 0, 255);
391 default_clut
.clut4
[3] = RGBA(127, 127, 127, 255);
393 default_clut
.clut16
[0] = RGBA( 0, 0, 0, 0);
394 for (i
= 1; i
< 16; i
++) {
396 r
= (i
& 1) ? 255 : 0;
397 g
= (i
& 2) ? 255 : 0;
398 b
= (i
& 4) ? 255 : 0;
400 r
= (i
& 1) ? 127 : 0;
401 g
= (i
& 2) ? 127 : 0;
402 b
= (i
& 4) ? 127 : 0;
404 default_clut
.clut16
[i
] = RGBA(r
, g
, b
, 255);
407 default_clut
.clut256
[0] = RGBA( 0, 0, 0, 0);
408 for (i
= 1; i
< 256; i
++) {
410 r
= (i
& 1) ? 255 : 0;
411 g
= (i
& 2) ? 255 : 0;
412 b
= (i
& 4) ? 255 : 0;
417 r
= ((i
& 1) ? 85 : 0) + ((i
& 0x10) ? 170 : 0);
418 g
= ((i
& 2) ? 85 : 0) + ((i
& 0x20) ? 170 : 0);
419 b
= ((i
& 4) ? 85 : 0) + ((i
& 0x40) ? 170 : 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
= 127 + ((i
& 1) ? 43 : 0) + ((i
& 0x10) ? 85 : 0);
430 g
= 127 + ((i
& 2) ? 43 : 0) + ((i
& 0x20) ? 85 : 0);
431 b
= 127 + ((i
& 4) ? 43 : 0) + ((i
& 0x40) ? 85 : 0);
435 r
= ((i
& 1) ? 43 : 0) + ((i
& 0x10) ? 85 : 0);
436 g
= ((i
& 2) ? 43 : 0) + ((i
& 0x20) ? 85 : 0);
437 b
= ((i
& 4) ? 43 : 0) + ((i
& 0x40) ? 85 : 0);
442 default_clut
.clut256
[i
] = RGBA(r
, g
, b
, a
);
448 static av_cold
int dvbsub_close_decoder(AVCodecContext
*avctx
)
450 DVBSubContext
*ctx
= avctx
->priv_data
;
451 DVBSubRegionDisplay
*display
;
459 av_freep(&ctx
->display_definition
);
461 while (ctx
->display_list
) {
462 display
= ctx
->display_list
;
463 ctx
->display_list
= display
->next
;
471 static int dvbsub_read_2bit_string(uint8_t *destbuf
, int dbuf_len
,
472 const uint8_t **srcbuf
, int buf_size
,
473 int non_mod
, uint8_t *map_table
, int x_pos
)
479 int pixels_read
= x_pos
;
481 init_get_bits(&gb
, *srcbuf
, buf_size
<< 3);
485 while (get_bits_count(&gb
) < buf_size
<< 3 && pixels_read
< dbuf_len
) {
486 bits
= get_bits(&gb
, 2);
489 if (non_mod
!= 1 || bits
!= 1) {
491 *destbuf
++ = map_table
[bits
];
497 bits
= get_bits1(&gb
);
499 run_length
= get_bits(&gb
, 3) + 3;
500 bits
= get_bits(&gb
, 2);
502 if (non_mod
== 1 && bits
== 1)
503 pixels_read
+= run_length
;
506 bits
= map_table
[bits
];
507 while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
513 bits
= get_bits1(&gb
);
515 bits
= get_bits(&gb
, 2);
517 run_length
= get_bits(&gb
, 4) + 12;
518 bits
= get_bits(&gb
, 2);
520 if (non_mod
== 1 && bits
== 1)
521 pixels_read
+= run_length
;
524 bits
= map_table
[bits
];
525 while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
530 } else if (bits
== 3) {
531 run_length
= get_bits(&gb
, 8) + 29;
532 bits
= get_bits(&gb
, 2);
534 if (non_mod
== 1 && bits
== 1)
535 pixels_read
+= run_length
;
538 bits
= map_table
[bits
];
539 while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
544 } else if (bits
== 1) {
550 while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
555 (*srcbuf
) += (get_bits_count(&gb
) + 7) >> 3;
570 if (get_bits(&gb
, 6))
571 av_log(0, AV_LOG_ERROR
, "DVBSub error: line overflow\n");
573 (*srcbuf
) += (get_bits_count(&gb
) + 7) >> 3;
578 static int dvbsub_read_4bit_string(uint8_t *destbuf
, int dbuf_len
,
579 const uint8_t **srcbuf
, int buf_size
,
580 int non_mod
, uint8_t *map_table
, int x_pos
)
586 int pixels_read
= x_pos
;
588 init_get_bits(&gb
, *srcbuf
, buf_size
<< 3);
592 while (get_bits_count(&gb
) < buf_size
<< 3 && pixels_read
< dbuf_len
) {
593 bits
= get_bits(&gb
, 4);
596 if (non_mod
!= 1 || bits
!= 1) {
598 *destbuf
++ = map_table
[bits
];
604 bits
= get_bits1(&gb
);
606 run_length
= get_bits(&gb
, 3);
608 if (run_length
== 0) {
609 (*srcbuf
) += (get_bits_count(&gb
) + 7) >> 3;
620 while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
625 bits
= get_bits1(&gb
);
627 run_length
= get_bits(&gb
, 2) + 4;
628 bits
= get_bits(&gb
, 4);
630 if (non_mod
== 1 && bits
== 1)
631 pixels_read
+= run_length
;
634 bits
= map_table
[bits
];
635 while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
641 bits
= get_bits(&gb
, 2);
643 run_length
= get_bits(&gb
, 4) + 9;
644 bits
= get_bits(&gb
, 4);
646 if (non_mod
== 1 && bits
== 1)
647 pixels_read
+= run_length
;
650 bits
= map_table
[bits
];
651 while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
656 } else if (bits
== 3) {
657 run_length
= get_bits(&gb
, 8) + 25;
658 bits
= get_bits(&gb
, 4);
660 if (non_mod
== 1 && bits
== 1)
661 pixels_read
+= run_length
;
664 bits
= map_table
[bits
];
665 while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
670 } else if (bits
== 1) {
676 while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
693 if (get_bits(&gb
, 8))
694 av_log(0, AV_LOG_ERROR
, "DVBSub error: line overflow\n");
696 (*srcbuf
) += (get_bits_count(&gb
) + 7) >> 3;
701 static int dvbsub_read_8bit_string(uint8_t *destbuf
, int dbuf_len
,
702 const uint8_t **srcbuf
, int buf_size
,
703 int non_mod
, uint8_t *map_table
, int x_pos
)
705 const uint8_t *sbuf_end
= (*srcbuf
) + buf_size
;
708 int pixels_read
= x_pos
;
712 while (*srcbuf
< sbuf_end
&& pixels_read
< dbuf_len
) {
716 if (non_mod
!= 1 || bits
!= 1) {
718 *destbuf
++ = map_table
[bits
];
725 run_length
= bits
& 0x7f;
726 if ((bits
& 0x80) == 0) {
727 if (run_length
== 0) {
735 if (non_mod
== 1 && bits
== 1)
736 pixels_read
+= run_length
;
739 bits
= map_table
[bits
];
740 while (run_length
-- > 0 && pixels_read
< dbuf_len
) {
749 av_log(0, AV_LOG_ERROR
, "DVBSub error: line overflow\n");
754 static int save_subtitle_set(AVCodecContext
*avctx
, AVSubtitle
*sub
, int *got_output
)
756 DVBSubContext
*ctx
= avctx
->priv_data
;
757 DVBSubRegionDisplay
*display
;
758 DVBSubDisplayDefinition
*display_def
= ctx
->display_definition
;
759 DVBSubRegion
*region
;
760 AVSubtitleRect
*rect
;
762 uint32_t *clut_table
;
764 int offset_x
=0, offset_y
=0;
769 offset_x
= display_def
->x
;
770 offset_y
= display_def
->y
;
773 /* Not touching AVSubtitles again*/
775 avpriv_request_sample(ctx
, "Different Version of Segment asked Twice\n");
776 return AVERROR_PATCHWELCOME
;
778 for (display
= ctx
->display_list
; display
; display
= display
->next
) {
779 region
= get_region(ctx
, display
->region_id
);
780 if (region
&& region
->dirty
)
784 if(ctx
->compute_edt
== 0) {
785 sub
->end_display_time
= ctx
->time_out
* 1000;
787 } else if (ctx
->prev_start
!= AV_NOPTS_VALUE
) {
788 sub
->end_display_time
= av_rescale_q((sub
->pts
- ctx
->prev_start
), AV_TIME_BASE_Q
, (AVRational
){ 1, 1000 }) - 1;
791 if (sub
->num_rects
> 0) {
793 sub
->rects
= av_mallocz_array(sizeof(*sub
->rects
), sub
->num_rects
);
795 ret
= AVERROR(ENOMEM
);
799 for(i
=0; i
<sub
->num_rects
; i
++)
800 sub
->rects
[i
] = av_mallocz(sizeof(*sub
->rects
[i
]));
804 for (display
= ctx
->display_list
; display
; display
= display
->next
) {
805 region
= get_region(ctx
, display
->region_id
);
813 rect
= sub
->rects
[i
];
814 rect
->x
= display
->x_pos
+ offset_x
;
815 rect
->y
= display
->y_pos
+ offset_y
;
816 rect
->w
= region
->width
;
817 rect
->h
= region
->height
;
818 rect
->nb_colors
= (1 << region
->depth
);
819 rect
->type
= SUBTITLE_BITMAP
;
820 rect
->pict
.linesize
[0] = region
->width
;
822 clut
= get_clut(ctx
, region
->clut
);
825 clut
= &default_clut
;
827 switch (region
->depth
) {
829 clut_table
= clut
->clut4
;
832 clut_table
= clut
->clut256
;
836 clut_table
= clut
->clut16
;
840 rect
->pict
.data
[1] = av_mallocz(AVPALETTE_SIZE
);
841 if (!rect
->pict
.data
[1]) {
842 ret
= AVERROR(ENOMEM
);
845 memcpy(rect
->pict
.data
[1], clut_table
, (1 << region
->depth
) * sizeof(uint32_t));
847 rect
->pict
.data
[0] = av_malloc(region
->buf_size
);
848 if (!rect
->pict
.data
[0]) {
849 ret
= AVERROR(ENOMEM
);
853 memcpy(rect
->pict
.data
[0], region
->pbuf
, region
->buf_size
);
862 for(i
=0; i
<sub
->num_rects
; i
++) {
863 rect
= sub
->rects
[i
];
865 av_freep(&rect
->pict
.data
[0]);
866 av_freep(&rect
->pict
.data
[1]);
868 av_freep(&sub
->rects
[i
]);
870 av_freep(&sub
->rects
);
876 static void dvbsub_parse_pixel_data_block(AVCodecContext
*avctx
, DVBSubObjectDisplay
*display
,
877 const uint8_t *buf
, int buf_size
, int top_bottom
, int non_mod
)
879 DVBSubContext
*ctx
= avctx
->priv_data
;
881 DVBSubRegion
*region
= get_region(ctx
, display
->region_id
);
882 const uint8_t *buf_end
= buf
+ buf_size
;
887 uint8_t map2to4
[] = { 0x0, 0x7, 0x8, 0xf};
888 uint8_t map2to8
[] = {0x00, 0x77, 0x88, 0xff};
889 uint8_t map4to8
[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
890 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
894 av_dlog(avctx
, "DVB pixel block size %d, %s field:\n", buf_size
,
895 top_bottom
? "bottom" : "top");
897 for (i
= 0; i
< buf_size
; i
++) {
899 av_dlog(avctx
, "0x%8p: ", buf
+i
);
901 av_dlog(avctx
, "%02x ", buf
[i
]);
903 av_dlog(avctx
, "\n");
907 av_dlog(avctx
, "\n");
916 x_pos
= display
->x_pos
;
917 y_pos
= display
->y_pos
;
921 while (buf
< buf_end
) {
922 if ((*buf
!=0xf0 && x_pos
>= region
->width
) || y_pos
>= region
->height
) {
923 av_log(avctx
, AV_LOG_ERROR
, "Invalid object location! %d-%d %d-%d %02x\n", x_pos
, region
->width
, y_pos
, region
->height
, *buf
);
929 if (region
->depth
== 8)
931 else if (region
->depth
== 4)
936 x_pos
= dvbsub_read_2bit_string(pbuf
+ (y_pos
* region
->width
),
937 region
->width
, &buf
, buf_end
- buf
,
938 non_mod
, map_table
, x_pos
);
941 if (region
->depth
< 4) {
942 av_log(avctx
, AV_LOG_ERROR
, "4-bit pixel string in %d-bit region!\n", region
->depth
);
946 if (region
->depth
== 8)
951 x_pos
= dvbsub_read_4bit_string(pbuf
+ (y_pos
* region
->width
),
952 region
->width
, &buf
, buf_end
- buf
,
953 non_mod
, map_table
, x_pos
);
956 if (region
->depth
< 8) {
957 av_log(avctx
, AV_LOG_ERROR
, "8-bit pixel string in %d-bit region!\n", region
->depth
);
961 x_pos
= dvbsub_read_8bit_string(pbuf
+ (y_pos
* region
->width
),
962 region
->width
, &buf
, buf_end
- buf
,
963 non_mod
, NULL
, x_pos
);
967 map2to4
[0] = (*buf
) >> 4;
968 map2to4
[1] = (*buf
++) & 0xf;
969 map2to4
[2] = (*buf
) >> 4;
970 map2to4
[3] = (*buf
++) & 0xf;
973 for (i
= 0; i
< 4; i
++)
977 for (i
= 0; i
< 16; i
++)
982 x_pos
= display
->x_pos
;
986 av_log(avctx
, AV_LOG_INFO
, "Unknown/unsupported pixel block 0x%x\n", *(buf
-1));
992 static void dvbsub_parse_object_segment(AVCodecContext
*avctx
,
993 const uint8_t *buf
, int buf_size
)
995 DVBSubContext
*ctx
= avctx
->priv_data
;
997 const uint8_t *buf_end
= buf
+ buf_size
;
999 DVBSubObject
*object
;
1000 DVBSubObjectDisplay
*display
;
1001 int top_field_len
, bottom_field_len
;
1003 int coding_method
, non_modifying_color
;
1005 object_id
= AV_RB16(buf
);
1008 object
= get_object(ctx
, object_id
);
1013 coding_method
= ((*buf
) >> 2) & 3;
1014 non_modifying_color
= ((*buf
++) >> 1) & 1;
1016 if (coding_method
== 0) {
1017 top_field_len
= AV_RB16(buf
);
1019 bottom_field_len
= AV_RB16(buf
);
1022 if (buf
+ top_field_len
+ bottom_field_len
> buf_end
) {
1023 av_log(avctx
, AV_LOG_ERROR
, "Field data size too large\n");
1027 for (display
= object
->display_list
; display
; display
= display
->object_list_next
) {
1028 const uint8_t *block
= buf
;
1029 int bfl
= bottom_field_len
;
1031 dvbsub_parse_pixel_data_block(avctx
, display
, block
, top_field_len
, 0,
1032 non_modifying_color
);
1034 if (bottom_field_len
> 0)
1035 block
= buf
+ top_field_len
;
1037 bfl
= top_field_len
;
1039 dvbsub_parse_pixel_data_block(avctx
, display
, block
, bfl
, 1,
1040 non_modifying_color
);
1043 /* } else if (coding_method == 1) {*/
1046 av_log(avctx
, AV_LOG_ERROR
, "Unknown object coding %d\n", coding_method
);
1051 static int dvbsub_parse_clut_segment(AVCodecContext
*avctx
,
1052 const uint8_t *buf
, int buf_size
)
1054 DVBSubContext
*ctx
= avctx
->priv_data
;
1056 const uint8_t *buf_end
= buf
+ buf_size
;
1060 int entry_id
, depth
, full_range
;
1061 int y
, cr
, cb
, alpha
;
1062 int r
, g
, b
, r_add
, g_add
, b_add
;
1064 av_dlog(avctx
, "DVB clut packet:\n");
1066 for (i
=0; i
< buf_size
; i
++) {
1067 av_dlog(avctx
, "%02x ", buf
[i
]);
1069 av_dlog(avctx
, "\n");
1073 av_dlog(avctx
, "\n");
1076 version
= ((*buf
)>>4)&15;
1079 clut
= get_clut(ctx
, clut_id
);
1082 clut
= av_malloc(sizeof(DVBSubCLUT
));
1084 memcpy(clut
, &default_clut
, sizeof(DVBSubCLUT
));
1089 clut
->next
= ctx
->clut_list
;
1090 ctx
->clut_list
= clut
;
1093 if (clut
->version
!= version
) {
1095 clut
->version
= version
;
1097 while (buf
+ 4 < buf_end
) {
1100 depth
= (*buf
) & 0xe0;
1103 av_log(avctx
, AV_LOG_ERROR
, "Invalid clut depth 0x%x!\n", *buf
);
1107 full_range
= (*buf
++) & 1;
1116 cr
= (((buf
[0] & 3) << 2) | ((buf
[1] >> 6) & 3)) << 4;
1117 cb
= (buf
[1] << 2) & 0xf0;
1118 alpha
= (buf
[1] << 6) & 0xc0;
1126 YUV_TO_RGB1_CCIR(cb
, cr
);
1127 YUV_TO_RGB2_CCIR(r
, g
, b
, y
);
1129 av_dlog(avctx
, "clut %d := (%d,%d,%d,%d)\n", entry_id
, r
, g
, b
, alpha
);
1130 if (!!(depth
& 0x80) + !!(depth
& 0x40) + !!(depth
& 0x20) > 1) {
1131 av_dlog(avctx
, "More than one bit level marked: %x\n", depth
);
1132 if (avctx
->strict_std_compliance
> FF_COMPLIANCE_NORMAL
)
1133 return AVERROR_INVALIDDATA
;
1137 clut
->clut4
[entry_id
] = RGBA(r
,g
,b
,255 - alpha
);
1138 else if (depth
& 0x40)
1139 clut
->clut16
[entry_id
] = RGBA(r
,g
,b
,255 - alpha
);
1140 else if (depth
& 0x20)
1141 clut
->clut256
[entry_id
] = RGBA(r
,g
,b
,255 - alpha
);
1148 static void dvbsub_parse_region_segment(AVCodecContext
*avctx
,
1149 const uint8_t *buf
, int buf_size
)
1151 DVBSubContext
*ctx
= avctx
->priv_data
;
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
;
1166 region
= get_region(ctx
, region_id
);
1169 region
= av_mallocz(sizeof(DVBSubRegion
));
1171 region
->id
= region_id
;
1172 region
->version
= -1;
1174 region
->next
= ctx
->region_list
;
1175 ctx
->region_list
= region
;
1178 version
= ((*buf
)>>4) & 15;
1179 fill
= ((*buf
++) >> 3) & 1;
1181 region
->width
= AV_RB16(buf
);
1183 region
->height
= AV_RB16(buf
);
1186 if (region
->width
* region
->height
!= region
->buf_size
) {
1187 av_free(region
->pbuf
);
1189 region
->buf_size
= region
->width
* region
->height
;
1191 region
->pbuf
= av_malloc(region
->buf_size
);
1197 region
->depth
= 1 << (((*buf
++) >> 2) & 7);
1198 if(region
->depth
<2 || region
->depth
>8){
1199 av_log(avctx
, AV_LOG_ERROR
, "region depth %d is invalid\n", region
->depth
);
1202 region
->clut
= *buf
++;
1204 if (region
->depth
== 8) {
1205 region
->bgcolor
= *buf
++;
1210 if (region
->depth
== 4)
1211 region
->bgcolor
= (((*buf
++) >> 4) & 15);
1213 region
->bgcolor
= (((*buf
++) >> 2) & 3);
1216 av_dlog(avctx
, "Region %d, (%dx%d)\n", region_id
, region
->width
, region
->height
);
1219 memset(region
->pbuf
, region
->bgcolor
, region
->buf_size
);
1220 av_dlog(avctx
, "Fill region (%d)\n", region
->bgcolor
);
1223 delete_region_display_list(ctx
, region
);
1225 while (buf
+ 5 < buf_end
) {
1226 object_id
= AV_RB16(buf
);
1229 object
= get_object(ctx
, object_id
);
1232 object
= av_mallocz(sizeof(DVBSubObject
));
1234 object
->id
= object_id
;
1235 object
->next
= ctx
->object_list
;
1236 ctx
->object_list
= object
;
1239 object
->type
= (*buf
) >> 6;
1241 display
= av_mallocz(sizeof(DVBSubObjectDisplay
));
1243 display
->object_id
= object_id
;
1244 display
->region_id
= region_id
;
1246 display
->x_pos
= AV_RB16(buf
) & 0xfff;
1248 display
->y_pos
= AV_RB16(buf
) & 0xfff;
1251 if ((object
->type
== 1 || object
->type
== 2) && buf
+1 < buf_end
) {
1252 display
->fgcolor
= *buf
++;
1253 display
->bgcolor
= *buf
++;
1256 display
->region_list_next
= region
->display_list
;
1257 region
->display_list
= display
;
1259 display
->object_list_next
= object
->display_list
;
1260 object
->display_list
= display
;
1264 static void dvbsub_parse_page_segment(AVCodecContext
*avctx
,
1265 const uint8_t *buf
, int buf_size
, AVSubtitle
*sub
, int *got_output
)
1267 DVBSubContext
*ctx
= avctx
->priv_data
;
1268 DVBSubRegionDisplay
*display
;
1269 DVBSubRegionDisplay
*tmp_display_list
, **tmp_ptr
;
1271 const uint8_t *buf_end
= buf
+ buf_size
;
1281 version
= ((*buf
)>>4) & 15;
1282 page_state
= ((*buf
++) >> 2) & 3;
1284 if (ctx
->version
== version
) {
1288 ctx
->time_out
= timeout
;
1289 ctx
->version
= version
;
1291 av_dlog(avctx
, "Page time out %ds, state %d\n", ctx
->time_out
, page_state
);
1293 if(ctx
->compute_edt
== 1)
1294 save_subtitle_set(avctx
, sub
, got_output
);
1296 if (page_state
== 1 || page_state
== 2) {
1297 delete_regions(ctx
);
1298 delete_objects(ctx
);
1302 tmp_display_list
= ctx
->display_list
;
1303 ctx
->display_list
= NULL
;
1305 while (buf
+ 5 < buf_end
) {
1309 display
= tmp_display_list
;
1310 tmp_ptr
= &tmp_display_list
;
1312 while (display
&& display
->region_id
!= region_id
) {
1313 tmp_ptr
= &display
->next
;
1314 display
= display
->next
;
1318 display
= av_mallocz(sizeof(DVBSubRegionDisplay
));
1320 display
->region_id
= region_id
;
1322 display
->x_pos
= AV_RB16(buf
);
1324 display
->y_pos
= AV_RB16(buf
);
1327 *tmp_ptr
= display
->next
;
1329 display
->next
= ctx
->display_list
;
1330 ctx
->display_list
= display
;
1332 av_dlog(avctx
, "Region %d, (%d,%d)\n", region_id
, display
->x_pos
, display
->y_pos
);
1335 while (tmp_display_list
) {
1336 display
= tmp_display_list
;
1338 tmp_display_list
= display
->next
;
1347 static void save_display_set(DVBSubContext
*ctx
)
1349 DVBSubRegion
*region
;
1350 DVBSubRegionDisplay
*display
;
1352 uint32_t *clut_table
;
1353 int x_pos
, y_pos
, width
, height
;
1354 int x
, y
, y_off
, x_off
;
1357 static int fileno_index
= 0;
1364 for (display
= ctx
->display_list
; display
; display
= display
->next
) {
1365 region
= get_region(ctx
, display
->region_id
);
1368 x_pos
= display
->x_pos
;
1369 y_pos
= display
->y_pos
;
1370 width
= region
->width
;
1371 height
= region
->height
;
1373 if (display
->x_pos
< x_pos
) {
1374 width
+= (x_pos
- display
->x_pos
);
1375 x_pos
= display
->x_pos
;
1378 if (display
->y_pos
< y_pos
) {
1379 height
+= (y_pos
- display
->y_pos
);
1380 y_pos
= display
->y_pos
;
1383 if (display
->x_pos
+ region
->width
> x_pos
+ width
) {
1384 width
= display
->x_pos
+ region
->width
- x_pos
;
1387 if (display
->y_pos
+ region
->height
> y_pos
+ height
) {
1388 height
= display
->y_pos
+ region
->height
- y_pos
;
1395 pbuf
= av_malloc(width
* height
* 4);
1397 for (display
= ctx
->display_list
; display
; display
= display
->next
) {
1398 region
= get_region(ctx
, display
->region_id
);
1400 x_off
= display
->x_pos
- x_pos
;
1401 y_off
= display
->y_pos
- y_pos
;
1403 clut
= get_clut(ctx
, region
->clut
);
1406 clut
= &default_clut
;
1408 switch (region
->depth
) {
1410 clut_table
= clut
->clut4
;
1413 clut_table
= clut
->clut256
;
1417 clut_table
= clut
->clut16
;
1421 for (y
= 0; y
< region
->height
; y
++) {
1422 for (x
= 0; x
< region
->width
; x
++) {
1423 pbuf
[((y
+ y_off
) * width
) + x_off
+ x
] =
1424 clut_table
[region
->pbuf
[y
* region
->width
+ x
]];
1430 snprintf(filename
, sizeof(filename
), "dvbs.%d", fileno_index
);
1432 png_save2(filename
, pbuf
, width
, height
);
1441 static void dvbsub_parse_display_definition_segment(AVCodecContext
*avctx
,
1445 DVBSubContext
*ctx
= avctx
->priv_data
;
1446 DVBSubDisplayDefinition
*display_def
= ctx
->display_definition
;
1447 int dds_version
, info_byte
;
1452 info_byte
= bytestream_get_byte(&buf
);
1453 dds_version
= info_byte
>> 4;
1454 if (display_def
&& display_def
->version
== dds_version
)
1455 return; // already have this display definition version
1458 display_def
= av_mallocz(sizeof(*display_def
));
1459 ctx
->display_definition
= display_def
;
1464 display_def
->version
= dds_version
;
1467 display_def
->width
= bytestream_get_be16(&buf
) + 1;
1468 display_def
->height
= bytestream_get_be16(&buf
) + 1;
1469 if (!avctx
->width
|| !avctx
->height
) {
1470 avctx
->width
= display_def
->width
;
1471 avctx
->height
= display_def
->height
;
1477 if (info_byte
& 1<<3) { // display_window_flag
1478 display_def
->x
= bytestream_get_be16(&buf
);
1479 display_def
->width
= bytestream_get_be16(&buf
) - display_def
->x
+ 1;
1480 display_def
->y
= bytestream_get_be16(&buf
);
1481 display_def
->height
= bytestream_get_be16(&buf
) - display_def
->y
+ 1;
1485 static void dvbsub_display_end_segment(AVCodecContext
*avctx
, const uint8_t *buf
,
1486 int buf_size
, AVSubtitle
*sub
,int *got_output
)
1488 DVBSubContext
*ctx
= avctx
->priv_data
;
1490 if(ctx
->compute_edt
== 0)
1491 save_subtitle_set(avctx
, sub
, got_output
);
1493 save_display_set(ctx
);
1498 static int dvbsub_decode(AVCodecContext
*avctx
,
1499 void *data
, int *data_size
,
1502 const uint8_t *buf
= avpkt
->data
;
1503 int buf_size
= avpkt
->size
;
1504 DVBSubContext
*ctx
= avctx
->priv_data
;
1505 AVSubtitle
*sub
= data
;
1506 const uint8_t *p
, *p_end
;
1512 int got_segment
= 0;
1514 av_dlog(avctx
, "DVB sub packet:\n");
1516 for (i
=0; i
< buf_size
; i
++) {
1517 av_dlog(avctx
, "%02x ", buf
[i
]);
1519 av_dlog(avctx
, "\n");
1523 av_dlog(avctx
, "\n");
1525 if (buf_size
<= 6 || *buf
!= 0x0f) {
1526 av_dlog(avctx
, "incomplete or broken packet");
1531 p_end
= buf
+ buf_size
;
1533 while (p_end
- p
>= 6 && *p
== 0x0f) {
1535 segment_type
= *p
++;
1536 page_id
= AV_RB16(p
);
1538 segment_length
= AV_RB16(p
);
1541 if (avctx
->debug
& FF_DEBUG_STARTCODE
) {
1542 av_log(avctx
, AV_LOG_DEBUG
, "segment_type:%d page_id:%d segment_length:%d\n", segment_type
, page_id
, segment_length
);
1545 if (p_end
- p
< segment_length
) {
1546 av_dlog(avctx
, "incomplete or broken packet");
1551 if (page_id
== ctx
->composition_id
|| page_id
== ctx
->ancillary_id
||
1552 ctx
->composition_id
== -1 || ctx
->ancillary_id
== -1) {
1553 switch (segment_type
) {
1554 case DVBSUB_PAGE_SEGMENT
:
1555 dvbsub_parse_page_segment(avctx
, p
, segment_length
, sub
, data_size
);
1558 case DVBSUB_REGION_SEGMENT
:
1559 dvbsub_parse_region_segment(avctx
, p
, segment_length
);
1562 case DVBSUB_CLUT_SEGMENT
:
1563 ret
= dvbsub_parse_clut_segment(avctx
, p
, segment_length
);
1564 if (ret
< 0) goto end
;
1567 case DVBSUB_OBJECT_SEGMENT
:
1568 dvbsub_parse_object_segment(avctx
, p
, segment_length
);
1571 case DVBSUB_DISPLAYDEFINITION_SEGMENT
:
1572 dvbsub_parse_display_definition_segment(avctx
, p
, segment_length
);
1574 case DVBSUB_DISPLAY_SEGMENT
:
1575 dvbsub_display_end_segment(avctx
, p
, segment_length
, sub
, data_size
);
1579 av_dlog(avctx
, "Subtitling segment type 0x%x, page id %d, length %d\n",
1580 segment_type
, page_id
, segment_length
);
1585 p
+= segment_length
;
1587 // Some streams do not send a display segment but if we have all the other
1588 // segments then we need no further data.
1589 if (got_segment
== 15) {
1590 av_log(avctx
, AV_LOG_DEBUG
, "Missing display_end_segment, emulating\n");
1591 dvbsub_display_end_segment(avctx
, p
, 0, sub
, data_size
);
1597 avsubtitle_free(sub
);
1600 if(ctx
->compute_edt
== 1 )
1601 FFSWAP(int64_t, ctx
->prev_start
, sub
->pts
);
1607 #define DS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_SUBTITLE_PARAM
1608 static const AVOption options
[] = {
1609 {"compute_edt", "compute end of time using pts or timeout", offsetof(DVBSubContext
, compute_edt
), FF_OPT_TYPE_INT
, {.i64
= 0}, 0, 1, DS
},
1612 static const AVClass dvbsubdec_class
= {
1613 .class_name
= "DVB Sub Decoder",
1614 .item_name
= av_default_item_name
,
1616 .version
= LIBAVUTIL_VERSION_INT
,
1619 AVCodec ff_dvbsub_decoder
= {
1621 .long_name
= NULL_IF_CONFIG_SMALL("DVB subtitles"),
1622 .type
= AVMEDIA_TYPE_SUBTITLE
,
1623 .id
= AV_CODEC_ID_DVB_SUBTITLE
,
1624 .priv_data_size
= sizeof(DVBSubContext
),
1625 .init
= dvbsub_init_decoder
,
1626 .close
= dvbsub_close_decoder
,
1627 .decode
= dvbsub_decode
,
1628 .priv_class
= &dvbsubdec_class
,