diff options
| -rw-r--r-- | contrib/ffmpeg/A01-multi-object-pgs.patch | 671 |
1 files changed, 671 insertions, 0 deletions
diff --git a/contrib/ffmpeg/A01-multi-object-pgs.patch b/contrib/ffmpeg/A01-multi-object-pgs.patch new file mode 100644 index 000000000..1a177aee0 --- /dev/null +++ b/contrib/ffmpeg/A01-multi-object-pgs.patch @@ -0,0 +1,671 @@ +From 638cb29d7579ad76ea358ee30ab5e6069ee796c3 Mon Sep 17 00:00:00 2001 +From: John Stebbins <[email protected]> +Date: Thu, 12 Jun 2014 15:24:26 -0700 +Subject: [PATCH] pgssubdec: handle more complex PGS scenarios + +Add ability to handle multiple palettes and objects simultaneously. +Each simultaneous object is given its own AVSubtitleRect. +Note that there can be up to 64 currently valid objects, but only +2 at any one time can be "presented". +--- + libavcodec/pgssubdec.c | 424 ++++++++++++++++++++++++++++++++++--------------- + 1 file changed, 294 insertions(+), 130 deletions(-) + +diff --git a/libavcodec/pgssubdec.c b/libavcodec/pgssubdec.c +index 4f175a3..1cafd9f 100644 +--- a/libavcodec/pgssubdec.c ++++ b/libavcodec/pgssubdec.c +@@ -33,38 +33,104 @@ + #include "libavutil/imgutils.h" + + #define RGBA(r,g,b,a) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b)) ++#define MAX_EPOCH_PALETTES 8 // Max 8 allowed per PGS epoch ++#define MAX_EPOCH_OBJECTS 64 // Max 64 allowed per PGS epoch ++#define MAX_OBJECT_REFS 2 // Max objects per display set + + enum SegmentType { + PALETTE_SEGMENT = 0x14, +- PICTURE_SEGMENT = 0x15, ++ OBJECT_SEGMENT = 0x15, + PRESENTATION_SEGMENT = 0x16, + WINDOW_SEGMENT = 0x17, + DISPLAY_SEGMENT = 0x80, + }; + ++typedef struct PGSSubObjectRef { ++ int id; ++ int window_id; ++ uint8_t composition_flag; ++ int x; ++ int y; ++ int crop_x; ++ int crop_y; ++ int crop_w; ++ int crop_h; ++} PGSSubObjectRef; ++ + typedef struct PGSSubPresentation { +- int x; +- int y; + int id_number; +- int object_number; +- uint8_t composition_flag; ++ int palette_id; ++ int object_count; ++ PGSSubObjectRef objects[MAX_OBJECT_REFS]; + int64_t pts; + } PGSSubPresentation; + +-typedef struct PGSSubPicture { ++typedef struct PGSSubObject { ++ int id; + int w; + int h; + uint8_t *rle; + unsigned int rle_buffer_size, rle_data_len; + unsigned int rle_remaining_len; +-} PGSSubPicture; ++} PGSSubObject; ++ ++typedef struct PGSSubObjects { ++ int count; ++ PGSSubObject object[MAX_EPOCH_OBJECTS]; ++} PGSSubObjects; ++ ++typedef struct PGSSubPalette { ++ int id; ++ uint32_t clut[256]; ++} PGSSubPalette; ++ ++typedef struct PGSSubPalettes { ++ int count; ++ PGSSubPalette palette[MAX_EPOCH_PALETTES]; ++} PGSSubPalettes; + + typedef struct PGSSubContext { + PGSSubPresentation presentation; +- uint32_t clut[256]; +- PGSSubPicture picture; ++ PGSSubPalettes palettes; ++ PGSSubObjects objects; + } PGSSubContext; + ++static void flush_cache(AVCodecContext *avctx) ++{ ++ PGSSubContext *ctx = avctx->priv_data; ++ int i; ++ ++ for (i = 0; i < ctx->objects.count; i++) { ++ av_freep(&ctx->objects.object[i].rle); ++ ctx->objects.object[i].rle_buffer_size = 0; ++ ctx->objects.object[i].rle_remaining_len = 0; ++ } ++ ctx->objects.count = 0; ++ ctx->palettes.count = 0; ++} ++ ++static PGSSubObject * find_object(int id, PGSSubObjects *objects) ++{ ++ int i; ++ ++ for (i = 0; i < objects->count; i++) { ++ if (objects->object[i].id == id) ++ return &objects->object[i]; ++ } ++ return NULL; ++} ++ ++static PGSSubPalette * find_palette(int id, PGSSubPalettes *palettes) ++{ ++ int i; ++ ++ for (i = 0; i < palettes->count; i++) { ++ if (palettes->palette[i].id == id) ++ return &palettes->palette[i]; ++ } ++ return NULL; ++} ++ + static av_cold int init_decoder(AVCodecContext *avctx) + { + avctx->pix_fmt = AV_PIX_FMT_PAL8; +@@ -74,10 +140,7 @@ static av_cold int init_decoder(AVCodecContext *avctx) + + static av_cold int close_decoder(AVCodecContext *avctx) + { +- PGSSubContext *ctx = avctx->priv_data; +- +- av_freep(&ctx->picture.rle); +- ctx->picture.rle_buffer_size = 0; ++ flush_cache(avctx); + + return 0; + } +@@ -92,7 +155,7 @@ static av_cold int close_decoder(AVCodecContext *avctx) + * @param buf pointer to the RLE data to process + * @param buf_size size of the RLE data to process + */ +-static int decode_rle(AVCodecContext *avctx, AVSubtitle *sub, ++static int decode_rle(AVCodecContext *avctx, AVSubtitleRect *rect, + const uint8_t *buf, unsigned int buf_size) + { + const uint8_t *rle_bitmap_end; +@@ -100,15 +163,15 @@ static int decode_rle(AVCodecContext *avctx, AVSubtitle *sub, + + rle_bitmap_end = buf + buf_size; + +- sub->rects[0]->pict.data[0] = av_malloc(sub->rects[0]->w * sub->rects[0]->h); ++ rect->pict.data[0] = av_malloc(rect->w * rect->h); + +- if (!sub->rects[0]->pict.data[0]) +- return -1; ++ if (!rect->pict.data[0]) ++ return AVERROR(ENOMEM); + + pixel_count = 0; + line_count = 0; + +- while (buf < rle_bitmap_end && line_count < sub->rects[0]->h) { ++ while (buf < rle_bitmap_end && line_count < rect->h) { + uint8_t flags, color; + int run; + +@@ -123,27 +186,31 @@ static int decode_rle(AVCodecContext *avctx, AVSubtitle *sub, + color = flags & 0x80 ? bytestream_get_byte(&buf) : 0; + } + +- if (run > 0 && pixel_count + run <= sub->rects[0]->w * sub->rects[0]->h) { +- memset(sub->rects[0]->pict.data[0] + pixel_count, color, run); ++ if (run > 0 && pixel_count + run <= rect->w * rect->h) { ++ memset(rect->pict.data[0] + pixel_count, color, run); + pixel_count += run; + } else if (!run) { + /* + * New Line. Check if correct pixels decoded, if not display warning + * and adjust bitmap pointer to correct new line position. + */ +- if (pixel_count % sub->rects[0]->w > 0) ++ if (pixel_count % rect->w > 0) { + av_log(avctx, AV_LOG_ERROR, "Decoded %d pixels, when line should be %d pixels\n", +- pixel_count % sub->rects[0]->w, sub->rects[0]->w); ++ pixel_count % rect->w, rect->w); ++ if (avctx->err_recognition & AV_EF_EXPLODE) { ++ return AVERROR_INVALIDDATA; ++ } ++ } + line_count++; + } + } + +- if (pixel_count < sub->rects[0]->w * sub->rects[0]->h) { ++ if (pixel_count < rect->w * rect->h) { + av_log(avctx, AV_LOG_ERROR, "Insufficient RLE data for subtitle\n"); +- return -1; ++ return AVERROR_INVALIDDATA; + } + +- av_dlog(avctx, "Pixel Count = %d, Area = %d\n", pixel_count, sub->rects[0]->w * sub->rects[0]->h); ++ av_dlog(avctx, "Pixel Count = %d, Area = %d\n", pixel_count, rect->w * rect->h); + + return 0; + } +@@ -157,40 +224,52 @@ static int decode_rle(AVCodecContext *avctx, AVSubtitle *sub, + * @param avctx contains the current codec context + * @param buf pointer to the packet to process + * @param buf_size size of packet to process +- * @todo TODO: Enable support for RLE data over multiple packets + */ +-static int parse_picture_segment(AVCodecContext *avctx, ++static int parse_object_segment(AVCodecContext *avctx, + const uint8_t *buf, int buf_size) + { + PGSSubContext *ctx = avctx->priv_data; ++ PGSSubObject *object; + + uint8_t sequence_desc; + unsigned int rle_bitmap_len, width, height; ++ int id; + + if (buf_size <= 4) +- return -1; ++ return AVERROR_INVALIDDATA; + buf_size -= 4; + +- /* skip 3 unknown bytes: Object ID (2 bytes), Version Number */ +- buf += 3; ++ id = bytestream_get_be16(&buf); ++ object = find_object(id, &ctx->objects); ++ if (!object) { ++ if (ctx->objects.count >= MAX_EPOCH_OBJECTS) { ++ av_log(avctx, AV_LOG_ERROR, "Too many objects in epoch\n"); ++ return AVERROR_INVALIDDATA; ++ } ++ object = &ctx->objects.object[ctx->objects.count++]; ++ object->id = id; ++ } ++ ++ /* skip object version number */ ++ buf += 1; + + /* Read the Sequence Description to determine if start of RLE data or appended to previous RLE */ + sequence_desc = bytestream_get_byte(&buf); + + if (!(sequence_desc & 0x80)) { + /* Additional RLE data */ +- if (buf_size > ctx->picture.rle_remaining_len) +- return -1; ++ if (buf_size > object->rle_remaining_len) ++ return AVERROR_INVALIDDATA; + +- memcpy(ctx->picture.rle + ctx->picture.rle_data_len, buf, buf_size); +- ctx->picture.rle_data_len += buf_size; +- ctx->picture.rle_remaining_len -= buf_size; ++ memcpy(object->rle + object->rle_data_len, buf, buf_size); ++ object->rle_data_len += buf_size; ++ object->rle_remaining_len -= buf_size; + + return 0; + } + + if (buf_size <= 7) +- return -1; ++ return AVERROR_INVALIDDATA; + buf_size -= 7; + + /* Decode rle bitmap length, stored size includes width/height data */ +@@ -203,20 +282,20 @@ static int parse_picture_segment(AVCodecContext *avctx, + /* Make sure the bitmap is not too large */ + if (avctx->width < width || avctx->height < height) { + av_log(avctx, AV_LOG_ERROR, "Bitmap dimensions larger than video.\n"); +- return -1; ++ return AVERROR_INVALIDDATA; + } + +- ctx->picture.w = width; +- ctx->picture.h = height; ++ object->w = width; ++ object->h = height; + +- av_fast_malloc(&ctx->picture.rle, &ctx->picture.rle_buffer_size, rle_bitmap_len); ++ av_fast_malloc(&object->rle, &object->rle_buffer_size, rle_bitmap_len); + +- if (!ctx->picture.rle) +- return -1; ++ if (!object->rle) ++ return AVERROR(ENOMEM); + +- memcpy(ctx->picture.rle, buf, buf_size); +- ctx->picture.rle_data_len = buf_size; +- ctx->picture.rle_remaining_len = rle_bitmap_len - buf_size; ++ memcpy(object->rle, buf, buf_size); ++ object->rle_data_len = buf_size; ++ object->rle_remaining_len = rle_bitmap_len - buf_size; + + return 0; + } +@@ -231,19 +310,32 @@ static int parse_picture_segment(AVCodecContext *avctx, + * @param buf pointer to the packet to process + * @param buf_size size of packet to process + */ +-static void parse_palette_segment(AVCodecContext *avctx, ++static int parse_palette_segment(AVCodecContext *avctx, + const uint8_t *buf, int buf_size) + { + PGSSubContext *ctx = avctx->priv_data; ++ PGSSubPalette *palette; + + const uint8_t *buf_end = buf + buf_size; + const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; + int color_id; + int y, cb, cr, alpha; + int r, g, b, r_add, g_add, b_add; ++ int id; ++ ++ id = bytestream_get_byte(&buf); ++ palette = find_palette(id, &ctx->palettes); ++ if (!palette) { ++ if (ctx->palettes.count >= MAX_EPOCH_PALETTES) { ++ av_log(avctx, AV_LOG_ERROR, "Too many palettes in epoch\n"); ++ return AVERROR_INVALIDDATA; ++ } ++ palette = &ctx->palettes.palette[ctx->palettes.count++]; ++ palette->id = id; ++ } + +- /* Skip two null bytes */ +- buf += 2; ++ /* Skip palette version */ ++ buf += 1; + + while (buf < buf_end) { + color_id = bytestream_get_byte(&buf); +@@ -258,8 +350,9 @@ static void parse_palette_segment(AVCodecContext *avctx, + av_dlog(avctx, "Color %d := (%d,%d,%d,%d)\n", color_id, r, g, b, alpha); + + /* Store color in palette */ +- ctx->clut[color_id] = RGBA(r,g,b,alpha); ++ palette->clut[color_id] = RGBA(r,g,b,alpha); + } ++ return 0; + } + + /** +@@ -272,7 +365,6 @@ static void parse_palette_segment(AVCodecContext *avctx, + * @param buf pointer to the packet to process + * @param buf_size size of packet to process + * @todo TODO: Implement cropping +- * @todo TODO: Implement forcing of subtitles + */ + static int parse_presentation_segment(AVCodecContext *avctx, + const uint8_t *buf, int buf_size, +@@ -280,8 +372,9 @@ static int parse_presentation_segment(AVCodecContext *avctx, + { + PGSSubContext *ctx = avctx->priv_data; + +- int x, y, ret; ++ int i, state, ret; + ++ // Video descriptor + int w = bytestream_get_be16(&buf); + int h = bytestream_get_be16(&buf); + +@@ -293,49 +386,75 @@ static int parse_presentation_segment(AVCodecContext *avctx, + if (ret < 0) + return ret; + +- /* Skip 1 bytes of unknown, frame rate? */ ++ /* Skip 1 bytes of unknown, frame rate */ + buf++; + ++ // Composition descriptor + ctx->presentation.id_number = bytestream_get_be16(&buf); +- + /* +- * Skip 3 bytes of unknown: +- * state +- * palette_update_flag (0x80), +- * palette_id_to_use, ++ * state is a 2 bit field that defines pgs epoch boundaries ++ * 00 - Normal, previously defined objects and palettes are still valid ++ * 01 - Acquisition point, previous objects and palettes can be released ++ * 10 - Epoch start, previous objects and palettes can be released ++ * 11 - Epoch continue, previous objects and palettes can be released ++ * ++ * reserved 6 bits discarded + */ +- buf += 3; +- +- ctx->presentation.object_number = bytestream_get_byte(&buf); +- ctx->presentation.composition_flag = 0; +- if (!ctx->presentation.object_number) +- return 0; ++ state = bytestream_get_byte(&buf) >> 6; ++ if (state != 0) { ++ flush_cache(avctx); ++ } + + /* +- * Skip 3 bytes of unknown: +- * object_id_ref (2 bytes), +- * window_id_ref, ++ * skip palette_update_flag (0x80), + */ +- buf += 3; +- ctx->presentation.composition_flag = bytestream_get_byte(&buf); +- +- x = bytestream_get_be16(&buf); +- y = bytestream_get_be16(&buf); +- +- /* TODO If cropping, cropping_x, cropping_y, cropping_width, cropping_height (all 2 bytes).*/ ++ buf += 1; ++ ctx->presentation.palette_id = bytestream_get_byte(&buf); ++ ctx->presentation.object_count = bytestream_get_byte(&buf); ++ if (ctx->presentation.object_count > MAX_OBJECT_REFS) { ++ av_log(avctx, AV_LOG_ERROR, ++ "Invalid number of presentation objects %d\n", ++ ctx->presentation.object_count); ++ ctx->presentation.object_count = 2; ++ if (avctx->err_recognition & AV_EF_EXPLODE) { ++ return AVERROR_INVALIDDATA; ++ } ++ } + +- av_dlog(avctx, "Subtitle Placement x=%d, y=%d\n", x, y); ++ for (i = 0; i < ctx->presentation.object_count; i++) ++ { ++ ctx->presentation.objects[i].id = bytestream_get_be16(&buf); ++ ctx->presentation.objects[i].window_id = bytestream_get_byte(&buf); ++ ctx->presentation.objects[i].composition_flag = bytestream_get_byte(&buf); ++ ++ ctx->presentation.objects[i].x = bytestream_get_be16(&buf); ++ ctx->presentation.objects[i].y = bytestream_get_be16(&buf); ++ ++ // If cropping ++ if (ctx->presentation.objects[i].composition_flag & 0x80) { ++ ctx->presentation.objects[i].crop_x = bytestream_get_be16(&buf); ++ ctx->presentation.objects[i].crop_y = bytestream_get_be16(&buf); ++ ctx->presentation.objects[i].crop_w = bytestream_get_be16(&buf); ++ ctx->presentation.objects[i].crop_h = bytestream_get_be16(&buf); ++ } + +- if (x > avctx->width || y > avctx->height) { +- av_log(avctx, AV_LOG_ERROR, "Subtitle out of video bounds. x = %d, y = %d, video width = %d, video height = %d.\n", +- x, y, avctx->width, avctx->height); +- x = 0; y = 0; ++ av_dlog(avctx, "Subtitle Placement x=%d, y=%d\n", ++ ctx->presentation.objects[i].x, ctx->presentation.objects[i].y); ++ ++ if (ctx->presentation.objects[i].x > avctx->width || ++ ctx->presentation.objects[i].y > avctx->height) { ++ av_log(avctx, AV_LOG_ERROR, "Subtitle out of video bounds. x = %d, y = %d, video width = %d, video height = %d.\n", ++ ctx->presentation.objects[i].x, ++ ctx->presentation.objects[i].y, ++ avctx->width, avctx->height); ++ ctx->presentation.objects[i].x = 0; ++ ctx->presentation.objects[i].y = 0; ++ if (avctx->err_recognition & AV_EF_EXPLODE) { ++ return AVERROR_INVALIDDATA; ++ } ++ } + } + +- /* Fill in dimensions */ +- ctx->presentation.x = x; +- ctx->presentation.y = y; +- + return 0; + } + +@@ -348,64 +467,105 @@ static int parse_presentation_segment(AVCodecContext *avctx, + * @param data pointer to the data pertaining the subtitle to display + * @param buf pointer to the packet to process + * @param buf_size size of packet to process +- * @todo TODO: Fix start time, relies on correct PTS, currently too late +- * +- * @todo TODO: Fix end time, normally cleared by a second display +- * @todo segment, which is currently ignored as it clears +- * @todo the subtitle too early. + */ + static int display_end_segment(AVCodecContext *avctx, void *data, + const uint8_t *buf, int buf_size) + { + AVSubtitle *sub = data; + PGSSubContext *ctx = avctx->priv_data; +- +- /* +- * The end display time is a timeout value and is only reached +- * if the next subtitle is later then timeout or subtitle has +- * not been cleared by a subsequent empty display command. +- */ ++ PGSSubPalette *palette; ++ int i, ret; + + memset(sub, 0, sizeof(*sub)); + sub->pts = ctx->presentation.pts; +- +- // Blank if last object_number was 0. +- // Note that this may be wrong for more complex subtitles. +- if (!ctx->presentation.object_number) +- return 1; + sub->start_display_time = 0; +- sub->end_display_time = 20000; ++ // There is no explicit end time for PGS subtitles. The end time ++ // is defined by the start of the next sub which may contain no ++ // objects (i.e. clears the previous sub) ++ sub->end_display_time = UINT32_MAX; + sub->format = 0; + +- sub->rects = av_mallocz(sizeof(*sub->rects)); +- sub->rects[0] = av_mallocz(sizeof(*sub->rects[0])); +- sub->num_rects = 1; +- +- if (ctx->presentation.composition_flag & 0x40) +- sub->rects[0]->flags |= AV_SUBTITLE_FLAG_FORCED; ++ // Blank if last object_count was 0. ++ if (!ctx->presentation.object_count) ++ return 1; ++ sub->rects = av_mallocz(sizeof(*sub->rects) * ctx->presentation.object_count); ++ if (!sub->rects) { ++ return AVERROR(ENOMEM); ++ } ++ palette = find_palette(ctx->presentation.palette_id, &ctx->palettes); ++ if (!palette) { ++ // Missing palette. Should only happen with damaged streams. ++ av_log(avctx, AV_LOG_ERROR, "Invalid palette id %d\n", ++ ctx->presentation.palette_id); ++ avsubtitle_free(sub); ++ return AVERROR_INVALIDDATA; ++ } ++ for (i = 0; i < ctx->presentation.object_count; i++) { ++ PGSSubObject *object; + +- sub->rects[0]->x = ctx->presentation.x; +- sub->rects[0]->y = ctx->presentation.y; +- sub->rects[0]->w = ctx->picture.w; +- sub->rects[0]->h = ctx->picture.h; +- sub->rects[0]->type = SUBTITLE_BITMAP; ++ sub->rects[i] = av_mallocz(sizeof(*sub->rects[0])); ++ if (!sub->rects[i]) { ++ avsubtitle_free(sub); ++ return AVERROR(ENOMEM); ++ } ++ sub->num_rects++; ++ sub->rects[i]->type = SUBTITLE_BITMAP; ++ ++ /* Process bitmap */ ++ object = find_object(ctx->presentation.objects[i].id, &ctx->objects); ++ if (!object) { ++ // Missing object. Should only happen with damaged streams. ++ av_log(avctx, AV_LOG_ERROR, "Invalid object id %d\n", ++ ctx->presentation.objects[i].id); ++ if (avctx->err_recognition & AV_EF_EXPLODE) { ++ avsubtitle_free(sub); ++ return AVERROR_INVALIDDATA; ++ } ++ // Leaves rect empty with 0 width and height. ++ continue; ++ } ++ if (ctx->presentation.objects[i].composition_flag & 0x40) ++ sub->rects[i]->flags |= AV_SUBTITLE_FLAG_FORCED; ++ ++ sub->rects[i]->x = ctx->presentation.objects[i].x; ++ sub->rects[i]->y = ctx->presentation.objects[i].y; ++ sub->rects[i]->w = object->w; ++ sub->rects[i]->h = object->h; ++ ++ sub->rects[i]->pict.linesize[0] = object->w; ++ ++ if (object->rle) { ++ if (object->rle_remaining_len) { ++ av_log(avctx, AV_LOG_ERROR, "RLE data length %u is %u bytes shorter than expected\n", ++ object->rle_data_len, object->rle_remaining_len); ++ if (avctx->err_recognition & AV_EF_EXPLODE) { ++ avsubtitle_free(sub); ++ return AVERROR_INVALIDDATA; ++ } ++ } ++ ret = decode_rle(avctx, sub->rects[i], object->rle, object->rle_data_len); ++ if (ret < 0) { ++ if ((avctx->err_recognition & AV_EF_EXPLODE) || ++ ret == AVERROR(ENOMEM)) { ++ avsubtitle_free(sub); ++ return ret; ++ } ++ sub->rects[i]->w = 0; ++ sub->rects[i]->h = 0; ++ continue; ++ } ++ } ++ /* Allocate memory for colors */ ++ sub->rects[i]->nb_colors = 256; ++ sub->rects[i]->pict.data[1] = av_mallocz(AVPALETTE_SIZE); ++ if (!sub->rects[i]->pict.data[1]) { ++ avsubtitle_free(sub); ++ return AVERROR(ENOMEM); ++ } + +- /* Process bitmap */ +- sub->rects[0]->pict.linesize[0] = ctx->picture.w; ++ memcpy(sub->rects[i]->pict.data[1], palette->clut, sub->rects[i]->nb_colors * sizeof(uint32_t)); + +- if (ctx->picture.rle) { +- if (ctx->picture.rle_remaining_len) +- av_log(avctx, AV_LOG_ERROR, "RLE data length %u is %u bytes shorter than expected\n", +- ctx->picture.rle_data_len, ctx->picture.rle_remaining_len); +- if(decode_rle(avctx, sub, ctx->picture.rle, ctx->picture.rle_data_len) < 0) +- return 0; + } +- /* Allocate memory for colors */ +- sub->rects[0]->nb_colors = 256; +- sub->rects[0]->pict.data[1] = av_mallocz(AVPALETTE_SIZE); +- +- memcpy(sub->rects[0]->pict.data[1], ctx->clut, sub->rects[0]->nb_colors * sizeof(uint32_t)); +- + return 1; + } + +@@ -449,17 +609,16 @@ static int decode(AVCodecContext *avctx, void *data, int *data_size, + if (segment_type != DISPLAY_SEGMENT && segment_length > buf_end - buf) + break; + ++ ret = 0; + switch (segment_type) { + case PALETTE_SEGMENT: +- parse_palette_segment(avctx, buf, segment_length); ++ ret = parse_palette_segment(avctx, buf, segment_length); + break; +- case PICTURE_SEGMENT: +- parse_picture_segment(avctx, buf, segment_length); ++ case OBJECT_SEGMENT: ++ ret = parse_object_segment(avctx, buf, segment_length); + break; + case PRESENTATION_SEGMENT: + ret = parse_presentation_segment(avctx, buf, segment_length, avpkt->pts); +- if (ret < 0) +- return ret; + break; + case WINDOW_SEGMENT: + /* +@@ -472,13 +631,18 @@ static int decode(AVCodecContext *avctx, void *data, int *data_size, + */ + break; + case DISPLAY_SEGMENT: +- *data_size = display_end_segment(avctx, data, buf, segment_length); ++ ret = display_end_segment(avctx, data, buf, segment_length); ++ if (ret >= 0) ++ *data_size = ret; + break; + default: + av_log(avctx, AV_LOG_ERROR, "Unknown subtitle segment type 0x%x, length %d\n", + segment_type, segment_length); ++ ret = AVERROR_INVALIDDATA; + break; + } ++ if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) ++ return ret; + + buf += segment_length; + } +-- +1.9.3 + |