LCOV - code coverage report
Current view: top level - libavcodec - pgssubdec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 278 0.0 %
Date: 2017-12-14 08:27:08 Functions: 0 11 0.0 %

          Line data    Source code
       1             : /*
       2             :  * PGS subtitle decoder
       3             :  * Copyright (c) 2009 Stephen Backway
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public
       9             :  * License as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : /**
      23             :  * @file
      24             :  * PGS subtitle decoder
      25             :  */
      26             : 
      27             : #include "avcodec.h"
      28             : #include "bytestream.h"
      29             : #include "internal.h"
      30             : #include "mathops.h"
      31             : 
      32             : #include "libavutil/colorspace.h"
      33             : #include "libavutil/imgutils.h"
      34             : #include "libavutil/opt.h"
      35             : 
      36             : #define RGBA(r,g,b,a) (((unsigned)(a) << 24) | ((r) << 16) | ((g) << 8) | (b))
      37             : #define MAX_EPOCH_PALETTES 8   // Max 8 allowed per PGS epoch
      38             : #define MAX_EPOCH_OBJECTS  64  // Max 64 allowed per PGS epoch
      39             : #define MAX_OBJECT_REFS    2   // Max objects per display set
      40             : 
      41             : enum SegmentType {
      42             :     PALETTE_SEGMENT      = 0x14,
      43             :     OBJECT_SEGMENT       = 0x15,
      44             :     PRESENTATION_SEGMENT = 0x16,
      45             :     WINDOW_SEGMENT       = 0x17,
      46             :     DISPLAY_SEGMENT      = 0x80,
      47             : };
      48             : 
      49             : typedef struct PGSSubObjectRef {
      50             :     int     id;
      51             :     int     window_id;
      52             :     uint8_t composition_flag;
      53             :     int     x;
      54             :     int     y;
      55             :     int     crop_x;
      56             :     int     crop_y;
      57             :     int     crop_w;
      58             :     int     crop_h;
      59             : } PGSSubObjectRef;
      60             : 
      61             : typedef struct PGSSubPresentation {
      62             :     int id_number;
      63             :     int palette_id;
      64             :     int object_count;
      65             :     PGSSubObjectRef objects[MAX_OBJECT_REFS];
      66             :     int64_t pts;
      67             : } PGSSubPresentation;
      68             : 
      69             : typedef struct PGSSubObject {
      70             :     int          id;
      71             :     int          w;
      72             :     int          h;
      73             :     uint8_t      *rle;
      74             :     unsigned int rle_buffer_size, rle_data_len;
      75             :     unsigned int rle_remaining_len;
      76             : } PGSSubObject;
      77             : 
      78             : typedef struct PGSSubObjects {
      79             :     int          count;
      80             :     PGSSubObject object[MAX_EPOCH_OBJECTS];
      81             : } PGSSubObjects;
      82             : 
      83             : typedef struct PGSSubPalette {
      84             :     int         id;
      85             :     uint32_t    clut[256];
      86             : } PGSSubPalette;
      87             : 
      88             : typedef struct PGSSubPalettes {
      89             :     int           count;
      90             :     PGSSubPalette palette[MAX_EPOCH_PALETTES];
      91             : } PGSSubPalettes;
      92             : 
      93             : typedef struct PGSSubContext {
      94             :     AVClass *class;
      95             :     PGSSubPresentation presentation;
      96             :     PGSSubPalettes     palettes;
      97             :     PGSSubObjects      objects;
      98             :     int forced_subs_only;
      99             : } PGSSubContext;
     100             : 
     101           0 : static void flush_cache(AVCodecContext *avctx)
     102             : {
     103           0 :     PGSSubContext *ctx = avctx->priv_data;
     104             :     int i;
     105             : 
     106           0 :     for (i = 0; i < ctx->objects.count; i++) {
     107           0 :         av_freep(&ctx->objects.object[i].rle);
     108           0 :         ctx->objects.object[i].rle_buffer_size  = 0;
     109           0 :         ctx->objects.object[i].rle_remaining_len  = 0;
     110             :     }
     111           0 :     ctx->objects.count = 0;
     112           0 :     ctx->palettes.count = 0;
     113           0 : }
     114             : 
     115           0 : static PGSSubObject * find_object(int id, PGSSubObjects *objects)
     116             : {
     117             :     int i;
     118             : 
     119           0 :     for (i = 0; i < objects->count; i++) {
     120           0 :         if (objects->object[i].id == id)
     121           0 :             return &objects->object[i];
     122             :     }
     123           0 :     return NULL;
     124             : }
     125             : 
     126           0 : static PGSSubPalette * find_palette(int id, PGSSubPalettes *palettes)
     127             : {
     128             :     int i;
     129             : 
     130           0 :     for (i = 0; i < palettes->count; i++) {
     131           0 :         if (palettes->palette[i].id == id)
     132           0 :             return &palettes->palette[i];
     133             :     }
     134           0 :     return NULL;
     135             : }
     136             : 
     137           0 : static av_cold int init_decoder(AVCodecContext *avctx)
     138             : {
     139           0 :     avctx->pix_fmt     = AV_PIX_FMT_PAL8;
     140             : 
     141           0 :     return 0;
     142             : }
     143             : 
     144           0 : static av_cold int close_decoder(AVCodecContext *avctx)
     145             : {
     146           0 :     flush_cache(avctx);
     147             : 
     148           0 :     return 0;
     149             : }
     150             : 
     151             : /**
     152             :  * Decode the RLE data.
     153             :  *
     154             :  * The subtitle is stored as a Run Length Encoded image.
     155             :  *
     156             :  * @param avctx contains the current codec context
     157             :  * @param sub pointer to the processed subtitle data
     158             :  * @param buf pointer to the RLE data to process
     159             :  * @param buf_size size of the RLE data to process
     160             :  */
     161           0 : static int decode_rle(AVCodecContext *avctx, AVSubtitleRect *rect,
     162             :                       const uint8_t *buf, unsigned int buf_size)
     163             : {
     164             :     const uint8_t *rle_bitmap_end;
     165             :     int pixel_count, line_count;
     166             : 
     167           0 :     rle_bitmap_end = buf + buf_size;
     168             : 
     169           0 :     rect->data[0] = av_malloc_array(rect->w, rect->h);
     170             : 
     171           0 :     if (!rect->data[0])
     172           0 :         return AVERROR(ENOMEM);
     173             : 
     174           0 :     pixel_count = 0;
     175           0 :     line_count  = 0;
     176             : 
     177           0 :     while (buf < rle_bitmap_end && line_count < rect->h) {
     178             :         uint8_t flags, color;
     179             :         int run;
     180             : 
     181           0 :         color = bytestream_get_byte(&buf);
     182           0 :         run   = 1;
     183             : 
     184           0 :         if (color == 0x00) {
     185           0 :             flags = bytestream_get_byte(&buf);
     186           0 :             run   = flags & 0x3f;
     187           0 :             if (flags & 0x40)
     188           0 :                 run = (run << 8) + bytestream_get_byte(&buf);
     189           0 :             color = flags & 0x80 ? bytestream_get_byte(&buf) : 0;
     190             :         }
     191             : 
     192           0 :         if (run > 0 && pixel_count + run <= rect->w * rect->h) {
     193           0 :             memset(rect->data[0] + pixel_count, color, run);
     194           0 :             pixel_count += run;
     195           0 :         } else if (!run) {
     196             :             /*
     197             :              * New Line. Check if correct pixels decoded, if not display warning
     198             :              * and adjust bitmap pointer to correct new line position.
     199             :              */
     200           0 :             if (pixel_count % rect->w > 0) {
     201           0 :                 av_log(avctx, AV_LOG_ERROR, "Decoded %d pixels, when line should be %d pixels\n",
     202           0 :                        pixel_count % rect->w, rect->w);
     203           0 :                 if (avctx->err_recognition & AV_EF_EXPLODE) {
     204           0 :                     return AVERROR_INVALIDDATA;
     205             :                 }
     206             :             }
     207           0 :             line_count++;
     208             :         }
     209             :     }
     210             : 
     211           0 :     if (pixel_count < rect->w * rect->h) {
     212           0 :         av_log(avctx, AV_LOG_ERROR, "Insufficient RLE data for subtitle\n");
     213           0 :         return AVERROR_INVALIDDATA;
     214             :     }
     215             : 
     216             :     ff_dlog(avctx, "Pixel Count = %d, Area = %d\n", pixel_count, rect->w * rect->h);
     217             : 
     218           0 :     return 0;
     219             : }
     220             : 
     221             : /**
     222             :  * Parse the picture segment packet.
     223             :  *
     224             :  * The picture segment contains details on the sequence id,
     225             :  * width, height and Run Length Encoded (RLE) bitmap data.
     226             :  *
     227             :  * @param avctx contains the current codec context
     228             :  * @param buf pointer to the packet to process
     229             :  * @param buf_size size of packet to process
     230             :  */
     231           0 : static int parse_object_segment(AVCodecContext *avctx,
     232             :                                   const uint8_t *buf, int buf_size)
     233             : {
     234           0 :     PGSSubContext *ctx = avctx->priv_data;
     235             :     PGSSubObject *object;
     236             : 
     237             :     uint8_t sequence_desc;
     238             :     unsigned int rle_bitmap_len, width, height;
     239             :     int id;
     240             : 
     241           0 :     if (buf_size <= 4)
     242           0 :         return AVERROR_INVALIDDATA;
     243           0 :     buf_size -= 4;
     244             : 
     245           0 :     id = bytestream_get_be16(&buf);
     246           0 :     object = find_object(id, &ctx->objects);
     247           0 :     if (!object) {
     248           0 :         if (ctx->objects.count >= MAX_EPOCH_OBJECTS) {
     249           0 :             av_log(avctx, AV_LOG_ERROR, "Too many objects in epoch\n");
     250           0 :             return AVERROR_INVALIDDATA;
     251             :         }
     252           0 :         object = &ctx->objects.object[ctx->objects.count++];
     253           0 :         object->id = id;
     254             :     }
     255             : 
     256             :     /* skip object version number */
     257           0 :     buf += 1;
     258             : 
     259             :     /* Read the Sequence Description to determine if start of RLE data or appended to previous RLE */
     260           0 :     sequence_desc = bytestream_get_byte(&buf);
     261             : 
     262           0 :     if (!(sequence_desc & 0x80)) {
     263             :         /* Additional RLE data */
     264           0 :         if (buf_size > object->rle_remaining_len)
     265           0 :             return AVERROR_INVALIDDATA;
     266             : 
     267           0 :         memcpy(object->rle + object->rle_data_len, buf, buf_size);
     268           0 :         object->rle_data_len += buf_size;
     269           0 :         object->rle_remaining_len -= buf_size;
     270             : 
     271           0 :         return 0;
     272             :     }
     273             : 
     274           0 :     if (buf_size <= 7)
     275           0 :         return AVERROR_INVALIDDATA;
     276           0 :     buf_size -= 7;
     277             : 
     278             :     /* Decode rle bitmap length, stored size includes width/height data */
     279           0 :     rle_bitmap_len = bytestream_get_be24(&buf) - 2*2;
     280             : 
     281           0 :     if (buf_size > rle_bitmap_len) {
     282           0 :         av_log(avctx, AV_LOG_ERROR,
     283             :                "Buffer dimension %d larger than the expected RLE data %d\n",
     284             :                buf_size, rle_bitmap_len);
     285           0 :         return AVERROR_INVALIDDATA;
     286             :     }
     287             : 
     288             :     /* Get bitmap dimensions from data */
     289           0 :     width  = bytestream_get_be16(&buf);
     290           0 :     height = bytestream_get_be16(&buf);
     291             : 
     292             :     /* Make sure the bitmap is not too large */
     293           0 :     if (avctx->width < width || avctx->height < height || !width || !height) {
     294           0 :         av_log(avctx, AV_LOG_ERROR, "Bitmap dimensions (%dx%d) invalid.\n", width, height);
     295           0 :         return AVERROR_INVALIDDATA;
     296             :     }
     297             : 
     298           0 :     object->w = width;
     299           0 :     object->h = height;
     300             : 
     301           0 :     av_fast_padded_malloc(&object->rle, &object->rle_buffer_size, rle_bitmap_len);
     302             : 
     303           0 :     if (!object->rle) {
     304           0 :         object->rle_data_len = 0;
     305           0 :         object->rle_remaining_len = 0;
     306           0 :         return AVERROR(ENOMEM);
     307             :     }
     308             : 
     309           0 :     memcpy(object->rle, buf, buf_size);
     310           0 :     object->rle_data_len = buf_size;
     311           0 :     object->rle_remaining_len = rle_bitmap_len - buf_size;
     312             : 
     313           0 :     return 0;
     314             : }
     315             : 
     316             : /**
     317             :  * Parse the palette segment packet.
     318             :  *
     319             :  * The palette segment contains details of the palette,
     320             :  * a maximum of 256 colors can be defined.
     321             :  *
     322             :  * @param avctx contains the current codec context
     323             :  * @param buf pointer to the packet to process
     324             :  * @param buf_size size of packet to process
     325             :  */
     326           0 : static int parse_palette_segment(AVCodecContext *avctx,
     327             :                                   const uint8_t *buf, int buf_size)
     328             : {
     329           0 :     PGSSubContext *ctx = avctx->priv_data;
     330             :     PGSSubPalette *palette;
     331             : 
     332           0 :     const uint8_t *buf_end = buf + buf_size;
     333           0 :     const uint8_t *cm      = ff_crop_tab + MAX_NEG_CROP;
     334             :     int color_id;
     335             :     int y, cb, cr, alpha;
     336             :     int r, g, b, r_add, g_add, b_add;
     337             :     int id;
     338             : 
     339           0 :     id  = bytestream_get_byte(&buf);
     340           0 :     palette = find_palette(id, &ctx->palettes);
     341           0 :     if (!palette) {
     342           0 :         if (ctx->palettes.count >= MAX_EPOCH_PALETTES) {
     343           0 :             av_log(avctx, AV_LOG_ERROR, "Too many palettes in epoch\n");
     344           0 :             return AVERROR_INVALIDDATA;
     345             :         }
     346           0 :         palette = &ctx->palettes.palette[ctx->palettes.count++];
     347           0 :         palette->id  = id;
     348             :     }
     349             : 
     350             :     /* Skip palette version */
     351           0 :     buf += 1;
     352             : 
     353           0 :     while (buf < buf_end) {
     354           0 :         color_id  = bytestream_get_byte(&buf);
     355           0 :         y         = bytestream_get_byte(&buf);
     356           0 :         cr        = bytestream_get_byte(&buf);
     357           0 :         cb        = bytestream_get_byte(&buf);
     358           0 :         alpha     = bytestream_get_byte(&buf);
     359             : 
     360             :         /* Default to BT.709 colorspace. In case of <= 576 height use BT.601 */
     361           0 :         if (avctx->height <= 0 || avctx->height > 576) {
     362           0 :             YUV_TO_RGB1_CCIR_BT709(cb, cr);
     363             :         } else {
     364           0 :             YUV_TO_RGB1_CCIR(cb, cr);
     365             :         }
     366             : 
     367           0 :         YUV_TO_RGB2_CCIR(r, g, b, y);
     368             : 
     369             :         ff_dlog(avctx, "Color %d := (%d,%d,%d,%d)\n", color_id, r, g, b, alpha);
     370             : 
     371             :         /* Store color in palette */
     372           0 :         palette->clut[color_id] = RGBA(r,g,b,alpha);
     373             :     }
     374           0 :     return 0;
     375             : }
     376             : 
     377             : /**
     378             :  * Parse the presentation segment packet.
     379             :  *
     380             :  * The presentation segment contains details on the video
     381             :  * width, video height, x & y subtitle position.
     382             :  *
     383             :  * @param avctx contains the current codec context
     384             :  * @param buf pointer to the packet to process
     385             :  * @param buf_size size of packet to process
     386             :  * @todo TODO: Implement cropping
     387             :  */
     388           0 : static int parse_presentation_segment(AVCodecContext *avctx,
     389             :                                       const uint8_t *buf, int buf_size,
     390             :                                       int64_t pts)
     391             : {
     392           0 :     PGSSubContext *ctx = avctx->priv_data;
     393             :     int i, state, ret;
     394           0 :     const uint8_t *buf_end = buf + buf_size;
     395             : 
     396             :     // Video descriptor
     397           0 :     int w = bytestream_get_be16(&buf);
     398           0 :     int h = bytestream_get_be16(&buf);
     399             : 
     400           0 :     ctx->presentation.pts = pts;
     401             : 
     402             :     ff_dlog(avctx, "Video Dimensions %dx%d\n",
     403             :             w, h);
     404           0 :     ret = ff_set_dimensions(avctx, w, h);
     405           0 :     if (ret < 0)
     406           0 :         return ret;
     407             : 
     408             :     /* Skip 1 bytes of unknown, frame rate */
     409           0 :     buf++;
     410             : 
     411             :     // Composition descriptor
     412           0 :     ctx->presentation.id_number = bytestream_get_be16(&buf);
     413             :     /*
     414             :      * state is a 2 bit field that defines pgs epoch boundaries
     415             :      * 00 - Normal, previously defined objects and palettes are still valid
     416             :      * 01 - Acquisition point, previous objects and palettes can be released
     417             :      * 10 - Epoch start, previous objects and palettes can be released
     418             :      * 11 - Epoch continue, previous objects and palettes can be released
     419             :      *
     420             :      * reserved 6 bits discarded
     421             :      */
     422           0 :     state = bytestream_get_byte(&buf) >> 6;
     423           0 :     if (state != 0) {
     424           0 :         flush_cache(avctx);
     425             :     }
     426             : 
     427             :     /*
     428             :      * skip palette_update_flag (0x80),
     429             :      */
     430           0 :     buf += 1;
     431           0 :     ctx->presentation.palette_id = bytestream_get_byte(&buf);
     432           0 :     ctx->presentation.object_count = bytestream_get_byte(&buf);
     433           0 :     if (ctx->presentation.object_count > MAX_OBJECT_REFS) {
     434           0 :         av_log(avctx, AV_LOG_ERROR,
     435             :                "Invalid number of presentation objects %d\n",
     436             :                ctx->presentation.object_count);
     437           0 :         ctx->presentation.object_count = 2;
     438           0 :         if (avctx->err_recognition & AV_EF_EXPLODE) {
     439           0 :             return AVERROR_INVALIDDATA;
     440             :         }
     441             :     }
     442             : 
     443             : 
     444           0 :     for (i = 0; i < ctx->presentation.object_count; i++)
     445             :     {
     446             : 
     447           0 :         if (buf_end - buf < 8) {
     448           0 :             av_log(avctx, AV_LOG_ERROR, "Insufficent space for object\n");
     449           0 :             ctx->presentation.object_count = i;
     450           0 :             return AVERROR_INVALIDDATA;
     451             :         }
     452             : 
     453           0 :         ctx->presentation.objects[i].id = bytestream_get_be16(&buf);
     454           0 :         ctx->presentation.objects[i].window_id = bytestream_get_byte(&buf);
     455           0 :         ctx->presentation.objects[i].composition_flag = bytestream_get_byte(&buf);
     456             : 
     457           0 :         ctx->presentation.objects[i].x = bytestream_get_be16(&buf);
     458           0 :         ctx->presentation.objects[i].y = bytestream_get_be16(&buf);
     459             : 
     460             :         // If cropping
     461           0 :         if (ctx->presentation.objects[i].composition_flag & 0x80) {
     462           0 :             ctx->presentation.objects[i].crop_x = bytestream_get_be16(&buf);
     463           0 :             ctx->presentation.objects[i].crop_y = bytestream_get_be16(&buf);
     464           0 :             ctx->presentation.objects[i].crop_w = bytestream_get_be16(&buf);
     465           0 :             ctx->presentation.objects[i].crop_h = bytestream_get_be16(&buf);
     466             :         }
     467             : 
     468             :         ff_dlog(avctx, "Subtitle Placement x=%d, y=%d\n",
     469             :                 ctx->presentation.objects[i].x, ctx->presentation.objects[i].y);
     470             : 
     471           0 :         if (ctx->presentation.objects[i].x > avctx->width ||
     472           0 :             ctx->presentation.objects[i].y > avctx->height) {
     473           0 :             av_log(avctx, AV_LOG_ERROR, "Subtitle out of video bounds. x = %d, y = %d, video width = %d, video height = %d.\n",
     474             :                    ctx->presentation.objects[i].x,
     475             :                    ctx->presentation.objects[i].y,
     476             :                     avctx->width, avctx->height);
     477           0 :             ctx->presentation.objects[i].x = 0;
     478           0 :             ctx->presentation.objects[i].y = 0;
     479           0 :             if (avctx->err_recognition & AV_EF_EXPLODE) {
     480           0 :                 return AVERROR_INVALIDDATA;
     481             :             }
     482             :         }
     483             :     }
     484             : 
     485           0 :     return 0;
     486             : }
     487             : 
     488             : /**
     489             :  * Parse the display segment packet.
     490             :  *
     491             :  * The display segment controls the updating of the display.
     492             :  *
     493             :  * @param avctx contains the current codec context
     494             :  * @param data pointer to the data pertaining the subtitle to display
     495             :  * @param buf pointer to the packet to process
     496             :  * @param buf_size size of packet to process
     497             :  */
     498           0 : static int display_end_segment(AVCodecContext *avctx, void *data,
     499             :                                const uint8_t *buf, int buf_size)
     500             : {
     501           0 :     AVSubtitle    *sub = data;
     502           0 :     PGSSubContext *ctx = avctx->priv_data;
     503             :     int64_t pts;
     504             :     PGSSubPalette *palette;
     505             :     int i, ret;
     506             : 
     507           0 :     pts = ctx->presentation.pts != AV_NOPTS_VALUE ? ctx->presentation.pts : sub->pts;
     508           0 :     memset(sub, 0, sizeof(*sub));
     509           0 :     sub->pts = pts;
     510           0 :     ctx->presentation.pts = AV_NOPTS_VALUE;
     511           0 :     sub->start_display_time = 0;
     512             :     // There is no explicit end time for PGS subtitles.  The end time
     513             :     // is defined by the start of the next sub which may contain no
     514             :     // objects (i.e. clears the previous sub)
     515           0 :     sub->end_display_time   = UINT32_MAX;
     516           0 :     sub->format             = 0;
     517             : 
     518             :     // Blank if last object_count was 0.
     519           0 :     if (!ctx->presentation.object_count)
     520           0 :         return 1;
     521           0 :     sub->rects = av_mallocz_array(ctx->presentation.object_count, sizeof(*sub->rects));
     522           0 :     if (!sub->rects) {
     523           0 :         return AVERROR(ENOMEM);
     524             :     }
     525           0 :     palette = find_palette(ctx->presentation.palette_id, &ctx->palettes);
     526           0 :     if (!palette) {
     527             :         // Missing palette.  Should only happen with damaged streams.
     528           0 :         av_log(avctx, AV_LOG_ERROR, "Invalid palette id %d\n",
     529             :                ctx->presentation.palette_id);
     530           0 :         avsubtitle_free(sub);
     531           0 :         return AVERROR_INVALIDDATA;
     532             :     }
     533           0 :     for (i = 0; i < ctx->presentation.object_count; i++) {
     534             :         PGSSubObject *object;
     535             : 
     536           0 :         sub->rects[i]  = av_mallocz(sizeof(*sub->rects[0]));
     537           0 :         if (!sub->rects[i]) {
     538           0 :             avsubtitle_free(sub);
     539           0 :             return AVERROR(ENOMEM);
     540             :         }
     541           0 :         sub->num_rects++;
     542           0 :         sub->rects[i]->type = SUBTITLE_BITMAP;
     543             : 
     544             :         /* Process bitmap */
     545           0 :         object = find_object(ctx->presentation.objects[i].id, &ctx->objects);
     546           0 :         if (!object) {
     547             :             // Missing object.  Should only happen with damaged streams.
     548           0 :             av_log(avctx, AV_LOG_ERROR, "Invalid object id %d\n",
     549             :                    ctx->presentation.objects[i].id);
     550           0 :             if (avctx->err_recognition & AV_EF_EXPLODE) {
     551           0 :                 avsubtitle_free(sub);
     552           0 :                 return AVERROR_INVALIDDATA;
     553             :             }
     554             :             // Leaves rect empty with 0 width and height.
     555           0 :             continue;
     556             :         }
     557           0 :         if (ctx->presentation.objects[i].composition_flag & 0x40)
     558           0 :             sub->rects[i]->flags |= AV_SUBTITLE_FLAG_FORCED;
     559             : 
     560           0 :         sub->rects[i]->x    = ctx->presentation.objects[i].x;
     561           0 :         sub->rects[i]->y    = ctx->presentation.objects[i].y;
     562             : 
     563           0 :         if (object->rle) {
     564           0 :             sub->rects[i]->w    = object->w;
     565           0 :             sub->rects[i]->h    = object->h;
     566             : 
     567           0 :             sub->rects[i]->linesize[0] = object->w;
     568             : 
     569           0 :             if (object->rle_remaining_len) {
     570           0 :                 av_log(avctx, AV_LOG_ERROR, "RLE data length %u is %u bytes shorter than expected\n",
     571             :                        object->rle_data_len, object->rle_remaining_len);
     572           0 :                 if (avctx->err_recognition & AV_EF_EXPLODE) {
     573           0 :                     avsubtitle_free(sub);
     574           0 :                     return AVERROR_INVALIDDATA;
     575             :                 }
     576             :             }
     577           0 :             ret = decode_rle(avctx, sub->rects[i], object->rle, object->rle_data_len);
     578           0 :             if (ret < 0) {
     579           0 :                 if ((avctx->err_recognition & AV_EF_EXPLODE) ||
     580             :                     ret == AVERROR(ENOMEM)) {
     581           0 :                     avsubtitle_free(sub);
     582           0 :                     return ret;
     583             :                 }
     584           0 :                 sub->rects[i]->w = 0;
     585           0 :                 sub->rects[i]->h = 0;
     586           0 :                 continue;
     587             :             }
     588             :         }
     589             :         /* Allocate memory for colors */
     590           0 :         sub->rects[i]->nb_colors    = 256;
     591           0 :         sub->rects[i]->data[1] = av_mallocz(AVPALETTE_SIZE);
     592           0 :         if (!sub->rects[i]->data[1]) {
     593           0 :             avsubtitle_free(sub);
     594           0 :             return AVERROR(ENOMEM);
     595             :         }
     596             : 
     597           0 :         if (!ctx->forced_subs_only || ctx->presentation.objects[i].composition_flag & 0x40)
     598           0 :         memcpy(sub->rects[i]->data[1], palette->clut, sub->rects[i]->nb_colors * sizeof(uint32_t));
     599             : 
     600             : #if FF_API_AVPICTURE
     601             : FF_DISABLE_DEPRECATION_WARNINGS
     602             : {
     603             :         AVSubtitleRect *rect;
     604             :         int j;
     605           0 :         rect = sub->rects[i];
     606           0 :         for (j = 0; j < 4; j++) {
     607           0 :             rect->pict.data[j] = rect->data[j];
     608           0 :             rect->pict.linesize[j] = rect->linesize[j];
     609             :         }
     610             : }
     611             : FF_ENABLE_DEPRECATION_WARNINGS
     612             : #endif
     613             :     }
     614           0 :     return 1;
     615             : }
     616             : 
     617           0 : static int decode(AVCodecContext *avctx, void *data, int *data_size,
     618             :                   AVPacket *avpkt)
     619             : {
     620           0 :     const uint8_t *buf = avpkt->data;
     621           0 :     int buf_size       = avpkt->size;
     622             : 
     623             :     const uint8_t *buf_end;
     624             :     uint8_t       segment_type;
     625             :     int           segment_length;
     626             :     int i, ret;
     627             : 
     628             :     ff_dlog(avctx, "PGS sub packet:\n");
     629             : 
     630           0 :     for (i = 0; i < buf_size; i++) {
     631             :         ff_dlog(avctx, "%02x ", buf[i]);
     632           0 :         if (i % 16 == 15)
     633             :             ff_dlog(avctx, "\n");
     634             :     }
     635             : 
     636           0 :     if (i & 15)
     637             :         ff_dlog(avctx, "\n");
     638             : 
     639           0 :     *data_size = 0;
     640             : 
     641             :     /* Ensure that we have received at a least a segment code and segment length */
     642           0 :     if (buf_size < 3)
     643           0 :         return -1;
     644             : 
     645           0 :     buf_end = buf + buf_size;
     646             : 
     647             :     /* Step through buffer to identify segments */
     648           0 :     while (buf < buf_end) {
     649           0 :         segment_type   = bytestream_get_byte(&buf);
     650           0 :         segment_length = bytestream_get_be16(&buf);
     651             : 
     652             :         ff_dlog(avctx, "Segment Length %d, Segment Type %x\n", segment_length, segment_type);
     653             : 
     654           0 :         if (segment_type != DISPLAY_SEGMENT && segment_length > buf_end - buf)
     655           0 :             break;
     656             : 
     657           0 :         ret = 0;
     658           0 :         switch (segment_type) {
     659           0 :         case PALETTE_SEGMENT:
     660           0 :             ret = parse_palette_segment(avctx, buf, segment_length);
     661           0 :             break;
     662           0 :         case OBJECT_SEGMENT:
     663           0 :             ret = parse_object_segment(avctx, buf, segment_length);
     664           0 :             break;
     665           0 :         case PRESENTATION_SEGMENT:
     666           0 :             ret = parse_presentation_segment(avctx, buf, segment_length, ((AVSubtitle*)(data))->pts);
     667           0 :             break;
     668           0 :         case WINDOW_SEGMENT:
     669             :             /*
     670             :              * Window Segment Structure (No new information provided):
     671             :              *     2 bytes: Unknown,
     672             :              *     2 bytes: X position of subtitle,
     673             :              *     2 bytes: Y position of subtitle,
     674             :              *     2 bytes: Width of subtitle,
     675             :              *     2 bytes: Height of subtitle.
     676             :              */
     677           0 :             break;
     678           0 :         case DISPLAY_SEGMENT:
     679           0 :             ret = display_end_segment(avctx, data, buf, segment_length);
     680           0 :             if (ret >= 0)
     681           0 :                 *data_size = ret;
     682           0 :             break;
     683           0 :         default:
     684           0 :             av_log(avctx, AV_LOG_ERROR, "Unknown subtitle segment type 0x%x, length %d\n",
     685             :                    segment_type, segment_length);
     686           0 :             ret = AVERROR_INVALIDDATA;
     687           0 :             break;
     688             :         }
     689           0 :         if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
     690           0 :             return ret;
     691             : 
     692           0 :         buf += segment_length;
     693             :     }
     694             : 
     695           0 :     return buf_size;
     696             : }
     697             : 
     698             : #define OFFSET(x) offsetof(PGSSubContext, x)
     699             : #define SD AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_DECODING_PARAM
     700             : static const AVOption options[] = {
     701             :     {"forced_subs_only", "Only show forced subtitles", OFFSET(forced_subs_only), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, SD},
     702             :     { NULL },
     703             : };
     704             : 
     705             : static const AVClass pgsdec_class = {
     706             :     .class_name = "PGS subtitle decoder",
     707             :     .item_name  = av_default_item_name,
     708             :     .option     = options,
     709             :     .version    = LIBAVUTIL_VERSION_INT,
     710             : };
     711             : 
     712             : AVCodec ff_pgssub_decoder = {
     713             :     .name           = "pgssub",
     714             :     .long_name      = NULL_IF_CONFIG_SMALL("HDMV Presentation Graphic Stream subtitles"),
     715             :     .type           = AVMEDIA_TYPE_SUBTITLE,
     716             :     .id             = AV_CODEC_ID_HDMV_PGS_SUBTITLE,
     717             :     .priv_data_size = sizeof(PGSSubContext),
     718             :     .init           = init_decoder,
     719             :     .close          = close_decoder,
     720             :     .decode         = decode,
     721             :     .priv_class     = &pgsdec_class,
     722             : };

Generated by: LCOV version 1.13