2 * DVB subtitle decoding
3 * Copyright (c) 2005 Ian Caulfield
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; 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"
27 #define DVBSUB_PAGE_SEGMENT 0x10
28 #define DVBSUB_REGION_SEGMENT 0x11
29 #define DVBSUB_CLUT_SEGMENT 0x12
30 #define DVBSUB_OBJECT_SEGMENT 0x13
31 #define DVBSUB_DISPLAYDEFINITION_SEGMENT 0x14
32 #define DVBSUB_DISPLAY_SEGMENT 0x80
34 #define cm (ff_crop_tab + MAX_NEG_CROP)
38 static void png_save(const char *filename, uint8_t *bitmap, int w, int h,
39 uint32_t *rgba_palette)
43 char fname[40], fname2[40];
46 snprintf(fname, 40, "%s.ppm", filename);
48 f = fopen(fname, "w");
57 for(y = 0; y < h; y++) {
58 for(x = 0; x < w; x++) {
59 v = rgba_palette[bitmap[y * w + x]];
60 putc((v >> 16) & 0xff, f);
61 putc((v >> 8) & 0xff, f);
62 putc((v >> 0) & 0xff, f);
68 snprintf(fname2, 40, "%s-a.pgm", filename);
70 f = fopen(fname2, "w");
79 for(y = 0; y < h; y++) {
80 for(x = 0; x < w; x++) {
81 v = rgba_palette[bitmap[y * w + x]];
82 putc((v >> 24) & 0xff, f);
87 snprintf(command, 1024, "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
90 snprintf(command, 1024, "rm %s %s", fname, fname2);
95 static void png_save2(const char *filename, uint32_t *bitmap, int w, int h)
99 char fname[40], fname2[40];
102 snprintf(fname, sizeof(fname), "%s.ppm", filename);
104 f = fopen(fname, "w");
113 for(y = 0; y < h; y++) {
114 for(x = 0; x < w; x++) {
115 v = bitmap[y * w + x];
116 putc((v >> 16) & 0xff, f);
117 putc((v >> 8) & 0xff, f);
118 putc((v >> 0) & 0xff, f);
124 snprintf(fname2, sizeof(fname2), "%s-a.pgm", filename);
126 f = fopen(fname2, "w");
135 for(y = 0; y < h; y++) {
136 for(x = 0; x < w; x++) {
137 v = bitmap[y * w + x];
138 putc((v >> 24) & 0xff, f);
143 snprintf(command, sizeof(command), "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
146 snprintf(command, sizeof(command), "rm %s %s", fname, fname2);
151 #define RGBA(r,g,b,a) (((unsigned)(a) << 24) | ((r) << 16) | ((g) << 8) | (b))
153 typedef struct DVBSubCLUT {
158 uint32_t clut256[256];
160 struct DVBSubCLUT *next;
163 static DVBSubCLUT default_clut;
165 typedef struct DVBSubObjectDisplay {
175 struct DVBSubObjectDisplay *region_list_next;
176 struct DVBSubObjectDisplay *object_list_next;
177 } DVBSubObjectDisplay;
179 typedef struct DVBSubObject {
184 DVBSubObjectDisplay *display_list;
186 struct DVBSubObject *next;
189 typedef struct DVBSubRegionDisplay {
195 struct DVBSubRegionDisplay *next;
196 } DVBSubRegionDisplay;
198 typedef struct DVBSubRegion {
211 DVBSubObjectDisplay *display_list;
213 struct DVBSubRegion *next;
216 typedef struct DVBSubDisplayDefinition {
223 } DVBSubDisplayDefinition;
225 typedef struct DVBSubContext {
230 DVBSubRegion *region_list;
231 DVBSubCLUT *clut_list;
232 DVBSubObject *object_list;
234 int display_list_size;
235 DVBSubRegionDisplay *display_list;
236 DVBSubDisplayDefinition *display_definition;
240 static DVBSubObject* get_object(DVBSubContext *ctx, int object_id)
242 DVBSubObject *ptr = ctx->object_list;
244 while (ptr && ptr->id != object_id) {
251 static DVBSubCLUT* get_clut(DVBSubContext *ctx, int clut_id)
253 DVBSubCLUT *ptr = ctx->clut_list;
255 while (ptr && ptr->id != clut_id) {
262 static DVBSubRegion* get_region(DVBSubContext *ctx, int region_id)
264 DVBSubRegion *ptr = ctx->region_list;
266 while (ptr && ptr->id != region_id) {
273 static void delete_region_display_list(DVBSubContext *ctx, DVBSubRegion *region)
275 DVBSubObject *object, *obj2, **obj2_ptr;
276 DVBSubObjectDisplay *display, *obj_disp, **obj_disp_ptr;
278 while (region->display_list) {
279 display = region->display_list;
281 object = get_object(ctx, display->object_id);
284 obj_disp_ptr = &object->display_list;
285 obj_disp = *obj_disp_ptr;
287 while (obj_disp && obj_disp != display) {
288 obj_disp_ptr = &obj_disp->object_list_next;
289 obj_disp = *obj_disp_ptr;
293 *obj_disp_ptr = obj_disp->object_list_next;
295 if (!object->display_list) {
296 obj2_ptr = &ctx->object_list;
299 while (obj2 != object) {
301 obj2_ptr = &obj2->next;
305 *obj2_ptr = obj2->next;
312 region->display_list = display->region_list_next;
319 static void delete_state(DVBSubContext *ctx)
321 DVBSubRegion *region;
324 while (ctx->region_list) {
325 region = ctx->region_list;
327 ctx->region_list = region->next;
329 delete_region_display_list(ctx, region);
330 av_free(region->pbuf);
334 while (ctx->clut_list) {
335 clut = ctx->clut_list;
337 ctx->clut_list = clut->next;
342 av_freep(&ctx->display_definition);
344 /* Should already be null */
345 if (ctx->object_list)
346 av_log(0, AV_LOG_ERROR, "Memory deallocation error!\n");
349 static av_cold int dvbsub_init_decoder(AVCodecContext *avctx)
351 int i, r, g, b, a = 0;
352 DVBSubContext *ctx = avctx->priv_data;
354 if (!avctx->extradata || avctx->extradata_size != 4) {
355 av_log(avctx, AV_LOG_WARNING, "Invalid extradata, subtitle streams may be combined!\n");
356 ctx->composition_id = -1;
357 ctx->ancillary_id = -1;
359 ctx->composition_id = AV_RB16(avctx->extradata);
360 ctx->ancillary_id = AV_RB16(avctx->extradata + 2);
363 default_clut.id = -1;
364 default_clut.next = NULL;
366 default_clut.clut4[0] = RGBA( 0, 0, 0, 0);
367 default_clut.clut4[1] = RGBA(255, 255, 255, 255);
368 default_clut.clut4[2] = RGBA( 0, 0, 0, 255);
369 default_clut.clut4[3] = RGBA(127, 127, 127, 255);
371 default_clut.clut16[0] = RGBA( 0, 0, 0, 0);
372 for (i = 1; i < 16; i++) {
374 r = (i & 1) ? 255 : 0;
375 g = (i & 2) ? 255 : 0;
376 b = (i & 4) ? 255 : 0;
378 r = (i & 1) ? 127 : 0;
379 g = (i & 2) ? 127 : 0;
380 b = (i & 4) ? 127 : 0;
382 default_clut.clut16[i] = RGBA(r, g, b, 255);
385 default_clut.clut256[0] = RGBA( 0, 0, 0, 0);
386 for (i = 1; i < 256; i++) {
388 r = (i & 1) ? 255 : 0;
389 g = (i & 2) ? 255 : 0;
390 b = (i & 4) ? 255 : 0;
395 r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
396 g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
397 b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
401 r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
402 g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
403 b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
407 r = 127 + ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
408 g = 127 + ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
409 b = 127 + ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
413 r = ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
414 g = ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
415 b = ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
420 default_clut.clut256[i] = RGBA(r, g, b, a);
426 static av_cold int dvbsub_close_decoder(AVCodecContext *avctx)
428 DVBSubContext *ctx = avctx->priv_data;
429 DVBSubRegionDisplay *display;
433 while (ctx->display_list) {
434 display = ctx->display_list;
435 ctx->display_list = display->next;
443 static int dvbsub_read_2bit_string(uint8_t *destbuf, int dbuf_len,
444 const uint8_t **srcbuf, int buf_size,
445 int non_mod, uint8_t *map_table)
453 init_get_bits(&gb, *srcbuf, buf_size << 3);
455 while (get_bits_count(&gb) < buf_size << 3 && pixels_read < dbuf_len) {
456 bits = get_bits(&gb, 2);
459 if (non_mod != 1 || bits != 1) {
461 *destbuf++ = map_table[bits];
467 bits = get_bits1(&gb);
469 run_length = get_bits(&gb, 3) + 3;
470 bits = get_bits(&gb, 2);
472 if (non_mod == 1 && bits == 1)
473 pixels_read += run_length;
476 bits = map_table[bits];
477 while (run_length-- > 0 && pixels_read < dbuf_len) {
483 bits = get_bits1(&gb);
485 bits = get_bits(&gb, 2);
487 run_length = get_bits(&gb, 4) + 12;
488 bits = get_bits(&gb, 2);
490 if (non_mod == 1 && bits == 1)
491 pixels_read += run_length;
494 bits = map_table[bits];
495 while (run_length-- > 0 && pixels_read < dbuf_len) {
500 } else if (bits == 3) {
501 run_length = get_bits(&gb, 8) + 29;
502 bits = get_bits(&gb, 2);
504 if (non_mod == 1 && bits == 1)
505 pixels_read += run_length;
508 bits = map_table[bits];
509 while (run_length-- > 0 && pixels_read < dbuf_len) {
514 } else if (bits == 1) {
520 if (pixels_read <= dbuf_len) {
525 (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
540 if (get_bits(&gb, 6))
541 av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
543 (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
548 static int dvbsub_read_4bit_string(uint8_t *destbuf, int dbuf_len,
549 const uint8_t **srcbuf, int buf_size,
550 int non_mod, uint8_t *map_table)
558 init_get_bits(&gb, *srcbuf, buf_size << 3);
560 while (get_bits_count(&gb) < buf_size << 3 && pixels_read < dbuf_len) {
561 bits = get_bits(&gb, 4);
564 if (non_mod != 1 || bits != 1) {
566 *destbuf++ = map_table[bits];
572 bits = get_bits1(&gb);
574 run_length = get_bits(&gb, 3);
576 if (run_length == 0) {
577 (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
588 while (run_length-- > 0 && pixels_read < dbuf_len) {
593 bits = get_bits1(&gb);
595 run_length = get_bits(&gb, 2) + 4;
596 bits = get_bits(&gb, 4);
598 if (non_mod == 1 && bits == 1)
599 pixels_read += run_length;
602 bits = map_table[bits];
603 while (run_length-- > 0 && pixels_read < dbuf_len) {
609 bits = get_bits(&gb, 2);
611 run_length = get_bits(&gb, 4) + 9;
612 bits = get_bits(&gb, 4);
614 if (non_mod == 1 && bits == 1)
615 pixels_read += run_length;
618 bits = map_table[bits];
619 while (run_length-- > 0 && pixels_read < dbuf_len) {
624 } else if (bits == 3) {
625 run_length = get_bits(&gb, 8) + 25;
626 bits = get_bits(&gb, 4);
628 if (non_mod == 1 && bits == 1)
629 pixels_read += run_length;
632 bits = map_table[bits];
633 while (run_length-- > 0 && pixels_read < dbuf_len) {
638 } else if (bits == 1) {
644 if (pixels_read <= dbuf_len) {
661 if (get_bits(&gb, 8))
662 av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
664 (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
669 static int dvbsub_read_8bit_string(uint8_t *destbuf, int dbuf_len,
670 const uint8_t **srcbuf, int buf_size,
671 int non_mod, uint8_t *map_table)
673 const uint8_t *sbuf_end = (*srcbuf) + buf_size;
678 while (*srcbuf < sbuf_end && pixels_read < dbuf_len) {
682 if (non_mod != 1 || bits != 1) {
684 *destbuf++ = map_table[bits];
691 run_length = bits & 0x7f;
692 if ((bits & 0x80) == 0) {
693 if (run_length == 0) {
699 if (non_mod == 1 && bits == 1)
700 pixels_read += run_length;
706 while (run_length-- > 0 && pixels_read < dbuf_len) {
714 av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
721 static void dvbsub_parse_pixel_data_block(AVCodecContext *avctx, DVBSubObjectDisplay *display,
722 const uint8_t *buf, int buf_size, int top_bottom, int non_mod)
724 DVBSubContext *ctx = avctx->priv_data;
726 DVBSubRegion *region = get_region(ctx, display->region_id);
727 const uint8_t *buf_end = buf + buf_size;
732 uint8_t map2to4[] = { 0x0, 0x7, 0x8, 0xf};
733 uint8_t map2to8[] = {0x00, 0x77, 0x88, 0xff};
734 uint8_t map4to8[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
735 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
738 av_dlog(avctx, "DVB pixel block size %d, %s field:\n", buf_size,
739 top_bottom ? "bottom" : "top");
741 for (i = 0; i < buf_size; i++) {
743 av_dlog(avctx, "0x%8p: ", buf+i);
745 av_dlog(avctx, "%02x ", buf[i]);
747 av_dlog(avctx, "\n");
751 av_dlog(avctx, "\n");
758 x_pos = display->x_pos;
759 y_pos = display->y_pos;
761 if ((y_pos & 1) != top_bottom)
764 while (buf < buf_end) {
765 if (x_pos > region->width || y_pos > region->height) {
766 av_log(avctx, AV_LOG_ERROR, "Invalid object location!\n");
772 if (region->depth == 8)
774 else if (region->depth == 4)
779 x_pos += dvbsub_read_2bit_string(pbuf + (y_pos * region->width) + x_pos,
780 region->width - x_pos, &buf, buf_end - buf,
784 if (region->depth < 4) {
785 av_log(avctx, AV_LOG_ERROR, "4-bit pixel string in %d-bit region!\n", region->depth);
789 if (region->depth == 8)
794 x_pos += dvbsub_read_4bit_string(pbuf + (y_pos * region->width) + x_pos,
795 region->width - x_pos, &buf, buf_end - buf,
799 if (region->depth < 8) {
800 av_log(avctx, AV_LOG_ERROR, "8-bit pixel string in %d-bit region!\n", region->depth);
804 x_pos += dvbsub_read_8bit_string(pbuf + (y_pos * region->width) + x_pos,
805 region->width - x_pos, &buf, buf_end - buf,
810 map2to4[0] = (*buf) >> 4;
811 map2to4[1] = (*buf++) & 0xf;
812 map2to4[2] = (*buf) >> 4;
813 map2to4[3] = (*buf++) & 0xf;
816 for (i = 0; i < 4; i++)
820 for (i = 0; i < 16; i++)
825 x_pos = display->x_pos;
829 av_log(avctx, AV_LOG_INFO, "Unknown/unsupported pixel block 0x%x\n", *(buf-1));
835 static int dvbsub_parse_object_segment(AVCodecContext *avctx,
836 const uint8_t *buf, int buf_size)
838 DVBSubContext *ctx = avctx->priv_data;
840 const uint8_t *buf_end = buf + buf_size;
841 const uint8_t *block;
843 DVBSubObject *object;
844 DVBSubObjectDisplay *display;
845 int top_field_len, bottom_field_len;
847 int coding_method, non_modifying_color;
849 object_id = AV_RB16(buf);
852 object = get_object(ctx, object_id);
855 return AVERROR_INVALIDDATA;
857 coding_method = ((*buf) >> 2) & 3;
858 non_modifying_color = ((*buf++) >> 1) & 1;
860 if (coding_method == 0) {
861 top_field_len = AV_RB16(buf);
863 bottom_field_len = AV_RB16(buf);
866 if (buf + top_field_len + bottom_field_len > buf_end) {
867 av_log(avctx, AV_LOG_ERROR, "Field data size too large\n");
868 return AVERROR_INVALIDDATA;
871 for (display = object->display_list; display; display = display->object_list_next) {
874 dvbsub_parse_pixel_data_block(avctx, display, block, top_field_len, 0,
875 non_modifying_color);
877 if (bottom_field_len > 0)
878 block = buf + top_field_len;
880 bottom_field_len = top_field_len;
882 dvbsub_parse_pixel_data_block(avctx, display, block, bottom_field_len, 1,
883 non_modifying_color);
886 /* } else if (coding_method == 1) {*/
889 av_log(avctx, AV_LOG_ERROR, "Unknown object coding %d\n", coding_method);
895 static int dvbsub_parse_clut_segment(AVCodecContext *avctx,
896 const uint8_t *buf, int buf_size)
898 DVBSubContext *ctx = avctx->priv_data;
900 const uint8_t *buf_end = buf + buf_size;
903 int entry_id, depth , full_range;
904 int y, cr, cb, alpha;
905 int r, g, b, r_add, g_add, b_add;
907 av_dlog(avctx, "DVB clut packet:\n");
909 for (i=0; i < buf_size; i++) {
910 av_dlog(avctx, "%02x ", buf[i]);
912 av_dlog(avctx, "\n");
916 av_dlog(avctx, "\n");
921 clut = get_clut(ctx, clut_id);
924 clut = av_malloc(sizeof(DVBSubCLUT));
926 return AVERROR(ENOMEM);
928 memcpy(clut, &default_clut, sizeof(DVBSubCLUT));
932 clut->next = ctx->clut_list;
933 ctx->clut_list = clut;
936 while (buf + 4 < buf_end) {
939 depth = (*buf) & 0xe0;
942 av_log(avctx, AV_LOG_ERROR, "Invalid clut depth 0x%x!\n", *buf);
943 return AVERROR_INVALIDDATA;
946 full_range = (*buf++) & 1;
955 cr = (((buf[0] & 3) << 2) | ((buf[1] >> 6) & 3)) << 4;
956 cb = (buf[1] << 2) & 0xf0;
957 alpha = (buf[1] << 6) & 0xc0;
965 YUV_TO_RGB1_CCIR(cb, cr);
966 YUV_TO_RGB2_CCIR(r, g, b, y);
968 av_dlog(avctx, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);
971 clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha);
973 clut->clut16[entry_id] = RGBA(r,g,b,255 - alpha);
975 clut->clut256[entry_id] = RGBA(r,g,b,255 - alpha);
982 static int dvbsub_parse_region_segment(AVCodecContext *avctx,
983 const uint8_t *buf, int buf_size)
985 DVBSubContext *ctx = avctx->priv_data;
987 const uint8_t *buf_end = buf + buf_size;
988 int region_id, object_id;
989 DVBSubRegion *region;
990 DVBSubObject *object;
991 DVBSubObjectDisplay *display;
995 return AVERROR_INVALIDDATA;
999 region = get_region(ctx, region_id);
1002 region = av_mallocz(sizeof(DVBSubRegion));
1004 return AVERROR(ENOMEM);
1006 region->id = region_id;
1008 region->next = ctx->region_list;
1009 ctx->region_list = region;
1012 fill = ((*buf++) >> 3) & 1;
1014 region->width = AV_RB16(buf);
1016 region->height = AV_RB16(buf);
1019 if (region->width * region->height != region->buf_size) {
1020 av_free(region->pbuf);
1022 region->buf_size = region->width * region->height;
1024 region->pbuf = av_malloc(region->buf_size);
1026 return AVERROR(ENOMEM);
1031 region->depth = 1 << (((*buf++) >> 2) & 7);
1032 if(region->depth<2 || region->depth>8){
1033 av_log(avctx, AV_LOG_ERROR, "region depth %d is invalid\n", region->depth);
1036 region->clut = *buf++;
1038 if (region->depth == 8)
1039 region->bgcolor = *buf++;
1043 if (region->depth == 4)
1044 region->bgcolor = (((*buf++) >> 4) & 15);
1046 region->bgcolor = (((*buf++) >> 2) & 3);
1049 av_dlog(avctx, "Region %d, (%dx%d)\n", region_id, region->width, region->height);
1052 memset(region->pbuf, region->bgcolor, region->buf_size);
1053 av_dlog(avctx, "Fill region (%d)\n", region->bgcolor);
1056 delete_region_display_list(ctx, region);
1058 while (buf + 5 < buf_end) {
1059 object_id = AV_RB16(buf);
1062 object = get_object(ctx, object_id);
1065 object = av_mallocz(sizeof(DVBSubObject));
1067 return AVERROR(ENOMEM);
1069 object->id = object_id;
1070 object->next = ctx->object_list;
1071 ctx->object_list = object;
1074 object->type = (*buf) >> 6;
1076 display = av_mallocz(sizeof(DVBSubObjectDisplay));
1078 return AVERROR(ENOMEM);
1080 display->object_id = object_id;
1081 display->region_id = region_id;
1083 display->x_pos = AV_RB16(buf) & 0xfff;
1085 display->y_pos = AV_RB16(buf) & 0xfff;
1088 if ((object->type == 1 || object->type == 2) && buf+1 < buf_end) {
1089 display->fgcolor = *buf++;
1090 display->bgcolor = *buf++;
1093 display->region_list_next = region->display_list;
1094 region->display_list = display;
1096 display->object_list_next = object->display_list;
1097 object->display_list = display;
1103 static int dvbsub_parse_page_segment(AVCodecContext *avctx,
1104 const uint8_t *buf, int buf_size)
1106 DVBSubContext *ctx = avctx->priv_data;
1107 DVBSubRegionDisplay *display;
1108 DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;
1110 const uint8_t *buf_end = buf + buf_size;
1115 return AVERROR_INVALIDDATA;
1117 ctx->time_out = *buf++;
1118 page_state = ((*buf++) >> 2) & 3;
1120 av_dlog(avctx, "Page time out %ds, state %d\n", ctx->time_out, page_state);
1122 if (page_state == 2) {
1126 tmp_display_list = ctx->display_list;
1127 ctx->display_list = NULL;
1128 ctx->display_list_size = 0;
1130 while (buf + 5 < buf_end) {
1134 display = tmp_display_list;
1135 tmp_ptr = &tmp_display_list;
1137 while (display && display->region_id != region_id) {
1138 tmp_ptr = &display->next;
1139 display = display->next;
1143 display = av_mallocz(sizeof(DVBSubRegionDisplay));
1145 return AVERROR(ENOMEM);
1148 display->region_id = region_id;
1150 display->x_pos = AV_RB16(buf);
1152 display->y_pos = AV_RB16(buf);
1155 *tmp_ptr = display->next;
1157 display->next = ctx->display_list;
1158 ctx->display_list = display;
1159 ctx->display_list_size++;
1161 av_dlog(avctx, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
1164 while (tmp_display_list) {
1165 display = tmp_display_list;
1167 tmp_display_list = display->next;
1177 static void save_display_set(DVBSubContext *ctx)
1179 DVBSubRegion *region;
1180 DVBSubRegionDisplay *display;
1182 uint32_t *clut_table;
1183 int x_pos, y_pos, width, height;
1184 int x, y, y_off, x_off;
1187 static int fileno_index = 0;
1194 for (display = ctx->display_list; display; display = display->next) {
1195 region = get_region(ctx, display->region_id);
1198 x_pos = display->x_pos;
1199 y_pos = display->y_pos;
1200 width = region->width;
1201 height = region->height;
1203 if (display->x_pos < x_pos) {
1204 width += (x_pos - display->x_pos);
1205 x_pos = display->x_pos;
1208 if (display->y_pos < y_pos) {
1209 height += (y_pos - display->y_pos);
1210 y_pos = display->y_pos;
1213 if (display->x_pos + region->width > x_pos + width) {
1214 width = display->x_pos + region->width - x_pos;
1217 if (display->y_pos + region->height > y_pos + height) {
1218 height = display->y_pos + region->height - y_pos;
1225 pbuf = av_malloc(width * height * 4);
1227 return AVERROR(ENOMEM);
1229 for (display = ctx->display_list; display; display = display->next) {
1230 region = get_region(ctx, display->region_id);
1232 x_off = display->x_pos - x_pos;
1233 y_off = display->y_pos - y_pos;
1235 clut = get_clut(ctx, region->clut);
1238 clut = &default_clut;
1240 switch (region->depth) {
1242 clut_table = clut->clut4;
1245 clut_table = clut->clut256;
1249 clut_table = clut->clut16;
1253 for (y = 0; y < region->height; y++) {
1254 for (x = 0; x < region->width; x++) {
1255 pbuf[((y + y_off) * width) + x_off + x] =
1256 clut_table[region->pbuf[y * region->width + x]];
1262 snprintf(filename, sizeof(filename), "dvbs.%d", fileno_index);
1264 png_save2(filename, pbuf, width, height);
1273 static int dvbsub_parse_display_definition_segment(AVCodecContext *avctx,
1277 DVBSubContext *ctx = avctx->priv_data;
1278 DVBSubDisplayDefinition *display_def = ctx->display_definition;
1279 int dds_version, info_byte;
1282 return AVERROR_INVALIDDATA;
1284 info_byte = bytestream_get_byte(&buf);
1285 dds_version = info_byte >> 4;
1286 if (display_def && display_def->version == dds_version)
1287 return 0; // already have this display definition version
1290 display_def = av_mallocz(sizeof(*display_def));
1292 return AVERROR(ENOMEM);
1293 ctx->display_definition = display_def;
1296 display_def->version = dds_version;
1299 display_def->width = bytestream_get_be16(&buf) + 1;
1300 display_def->height = bytestream_get_be16(&buf) + 1;
1303 return AVERROR_INVALIDDATA;
1305 if (info_byte & 1<<3) { // display_window_flag
1306 display_def->x = bytestream_get_be16(&buf);
1307 display_def->y = bytestream_get_be16(&buf);
1308 display_def->width = bytestream_get_be16(&buf) - display_def->x + 1;
1309 display_def->height = bytestream_get_be16(&buf) - display_def->y + 1;
1315 static int dvbsub_display_end_segment(AVCodecContext *avctx, const uint8_t *buf,
1316 int buf_size, AVSubtitle *sub)
1318 DVBSubContext *ctx = avctx->priv_data;
1319 DVBSubDisplayDefinition *display_def = ctx->display_definition;
1321 DVBSubRegion *region;
1322 DVBSubRegionDisplay *display;
1323 AVSubtitleRect *rect;
1325 uint32_t *clut_table;
1327 int offset_x=0, offset_y=0;
1330 sub->start_display_time = 0;
1331 sub->end_display_time = ctx->time_out * 1000;
1335 offset_x = display_def->x;
1336 offset_y = display_def->y;
1339 sub->num_rects = ctx->display_list_size;
1340 if (sub->num_rects <= 0)
1341 return AVERROR_INVALIDDATA;
1343 sub->rects = av_mallocz_array(sub->num_rects * sub->num_rects,
1344 sizeof(*sub->rects));
1346 return AVERROR(ENOMEM);
1350 for (display = ctx->display_list; display; display = display->next) {
1351 region = get_region(ctx, display->region_id);
1352 rect = sub->rects[i];
1357 rect->x = display->x_pos + offset_x;
1358 rect->y = display->y_pos + offset_y;
1359 rect->w = region->width;
1360 rect->h = region->height;
1361 rect->nb_colors = 16;
1362 rect->type = SUBTITLE_BITMAP;
1363 rect->pict.linesize[0] = region->width;
1365 clut = get_clut(ctx, region->clut);
1368 clut = &default_clut;
1370 switch (region->depth) {
1372 clut_table = clut->clut4;
1375 clut_table = clut->clut256;
1379 clut_table = clut->clut16;
1383 rect->pict.data[1] = av_mallocz(AVPALETTE_SIZE);
1384 if (!rect->pict.data[1]) {
1385 av_free(sub->rects);
1386 return AVERROR(ENOMEM);
1388 memcpy(rect->pict.data[1], clut_table, (1 << region->depth) * sizeof(uint32_t));
1390 rect->pict.data[0] = av_malloc(region->buf_size);
1391 if (!rect->pict.data[0]) {
1392 av_free(rect->pict.data[1]);
1393 av_free(sub->rects);
1394 return AVERROR(ENOMEM);
1396 memcpy(rect->pict.data[0], region->pbuf, region->buf_size);
1404 save_display_set(ctx);
1410 static int dvbsub_decode(AVCodecContext *avctx,
1411 void *data, int *data_size,
1414 const uint8_t *buf = avpkt->data;
1415 int buf_size = avpkt->size;
1416 DVBSubContext *ctx = avctx->priv_data;
1417 AVSubtitle *sub = data;
1418 const uint8_t *p, *p_end;
1424 av_dlog(avctx, "DVB sub packet:\n");
1426 for (i=0; i < buf_size; i++) {
1427 av_dlog(avctx, "%02x ", buf[i]);
1429 av_dlog(avctx, "\n");
1433 av_dlog(avctx, "\n");
1435 if (buf_size <= 6 || *buf != 0x0f) {
1436 av_dlog(avctx, "incomplete or broken packet");
1437 return AVERROR_INVALIDDATA;
1441 p_end = buf + buf_size;
1443 while (p_end - p >= 6 && *p == 0x0f) {
1445 segment_type = *p++;
1446 page_id = AV_RB16(p);
1448 segment_length = AV_RB16(p);
1451 if (p_end - p < segment_length) {
1452 av_dlog(avctx, "incomplete or broken packet");
1456 if (page_id == ctx->composition_id || page_id == ctx->ancillary_id ||
1457 ctx->composition_id == -1 || ctx->ancillary_id == -1) {
1459 switch (segment_type) {
1460 case DVBSUB_PAGE_SEGMENT:
1461 ret = dvbsub_parse_page_segment(avctx, p, segment_length);
1463 case DVBSUB_REGION_SEGMENT:
1464 ret = dvbsub_parse_region_segment(avctx, p, segment_length);
1466 case DVBSUB_CLUT_SEGMENT:
1467 ret = dvbsub_parse_clut_segment(avctx, p, segment_length);
1469 case DVBSUB_OBJECT_SEGMENT:
1470 ret = dvbsub_parse_object_segment(avctx, p, segment_length);
1472 case DVBSUB_DISPLAYDEFINITION_SEGMENT:
1473 ret = dvbsub_parse_display_definition_segment(avctx, p,
1476 case DVBSUB_DISPLAY_SEGMENT:
1477 ret = dvbsub_display_end_segment(avctx, p, segment_length, sub);
1481 av_dlog(avctx, "Subtitling segment type 0x%x, page id %d, length %d\n",
1482 segment_type, page_id, segment_length);
1489 p += segment_length;
1496 AVCodec ff_dvbsub_decoder = {
1498 .long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"),
1499 .type = AVMEDIA_TYPE_SUBTITLE,
1500 .id = AV_CODEC_ID_DVB_SUBTITLE,
1501 .priv_data_size = sizeof(DVBSubContext),
1502 .init = dvbsub_init_decoder,
1503 .close = dvbsub_close_decoder,
1504 .decode = dvbsub_decode,