Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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. static void flush_cache(AVCodecContext *avctx)
  102. {
  103.     PGSSubContext *ctx = avctx->priv_data;
  104.     int i;
  105.  
  106.     for (i = 0; i < ctx->objects.count; i++) {
  107.         av_freep(&ctx->objects.object[i].rle);
  108.         ctx->objects.object[i].rle_buffer_size  = 0;
  109.         ctx->objects.object[i].rle_remaining_len  = 0;
  110.     }
  111.     ctx->objects.count = 0;
  112.     ctx->palettes.count = 0;
  113. }
  114.  
  115. static PGSSubObject * find_object(int id, PGSSubObjects *objects)
  116. {
  117.     int i;
  118.  
  119.     for (i = 0; i < objects->count; i++) {
  120.         if (objects->object[i].id == id)
  121.             return &objects->object[i];
  122.     }
  123.     return NULL;
  124. }
  125.  
  126. static PGSSubPalette * find_palette(int id, PGSSubPalettes *palettes)
  127. {
  128.     int i;
  129.  
  130.     for (i = 0; i < palettes->count; i++) {
  131.         if (palettes->palette[i].id == id)
  132.             return &palettes->palette[i];
  133.     }
  134.     return NULL;
  135. }
  136.  
  137. static av_cold int init_decoder(AVCodecContext *avctx)
  138. {
  139.     avctx->pix_fmt     = AV_PIX_FMT_PAL8;
  140.  
  141.     return 0;
  142. }
  143.  
  144. static av_cold int close_decoder(AVCodecContext *avctx)
  145. {
  146.     flush_cache(avctx);
  147.  
  148.     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. 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.     rle_bitmap_end = buf + buf_size;
  168.  
  169.     rect->pict.data[0] = av_malloc_array(rect->w, rect->h);
  170.  
  171.     if (!rect->pict.data[0])
  172.         return AVERROR(ENOMEM);
  173.  
  174.     pixel_count = 0;
  175.     line_count  = 0;
  176.  
  177.     while (buf < rle_bitmap_end && line_count < rect->h) {
  178.         uint8_t flags, color;
  179.         int run;
  180.  
  181.         color = bytestream_get_byte(&buf);
  182.         run   = 1;
  183.  
  184.         if (color == 0x00) {
  185.             flags = bytestream_get_byte(&buf);
  186.             run   = flags & 0x3f;
  187.             if (flags & 0x40)
  188.                 run = (run << 8) + bytestream_get_byte(&buf);
  189.             color = flags & 0x80 ? bytestream_get_byte(&buf) : 0;
  190.         }
  191.  
  192.         if (run > 0 && pixel_count + run <= rect->w * rect->h) {
  193.             memset(rect->pict.data[0] + pixel_count, color, run);
  194.             pixel_count += run;
  195.         } 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.             if (pixel_count % rect->w > 0) {
  201.                 av_log(avctx, AV_LOG_ERROR, "Decoded %d pixels, when line should be %d pixels\n",
  202.                        pixel_count % rect->w, rect->w);
  203.                 if (avctx->err_recognition & AV_EF_EXPLODE) {
  204.                     return AVERROR_INVALIDDATA;
  205.                 }
  206.             }
  207.             line_count++;
  208.         }
  209.     }
  210.  
  211.     if (pixel_count < rect->w * rect->h) {
  212.         av_log(avctx, AV_LOG_ERROR, "Insufficient RLE data for subtitle\n");
  213.         return AVERROR_INVALIDDATA;
  214.     }
  215.  
  216.     ff_dlog(avctx, "Pixel Count = %d, Area = %d\n", pixel_count, rect->w * rect->h);
  217.  
  218.     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. static int parse_object_segment(AVCodecContext *avctx,
  232.                                   const uint8_t *buf, int buf_size)
  233. {
  234.     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.     if (buf_size <= 4)
  242.         return AVERROR_INVALIDDATA;
  243.     buf_size -= 4;
  244.  
  245.     id = bytestream_get_be16(&buf);
  246.     object = find_object(id, &ctx->objects);
  247.     if (!object) {
  248.         if (ctx->objects.count >= MAX_EPOCH_OBJECTS) {
  249.             av_log(avctx, AV_LOG_ERROR, "Too many objects in epoch\n");
  250.             return AVERROR_INVALIDDATA;
  251.         }
  252.         object = &ctx->objects.object[ctx->objects.count++];
  253.         object->id = id;
  254.     }
  255.  
  256.     /* skip object version number */
  257.     buf += 1;
  258.  
  259.     /* Read the Sequence Description to determine if start of RLE data or appended to previous RLE */
  260.     sequence_desc = bytestream_get_byte(&buf);
  261.  
  262.     if (!(sequence_desc & 0x80)) {
  263.         /* Additional RLE data */
  264.         if (buf_size > object->rle_remaining_len)
  265.             return AVERROR_INVALIDDATA;
  266.  
  267.         memcpy(object->rle + object->rle_data_len, buf, buf_size);
  268.         object->rle_data_len += buf_size;
  269.         object->rle_remaining_len -= buf_size;
  270.  
  271.         return 0;
  272.     }
  273.  
  274.     if (buf_size <= 7)
  275.         return AVERROR_INVALIDDATA;
  276.     buf_size -= 7;
  277.  
  278.     /* Decode rle bitmap length, stored size includes width/height data */
  279.     rle_bitmap_len = bytestream_get_be24(&buf) - 2*2;
  280.  
  281.     if (buf_size > rle_bitmap_len) {
  282.         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.         return AVERROR_INVALIDDATA;
  286.     }
  287.  
  288.     /* Get bitmap dimensions from data */
  289.     width  = bytestream_get_be16(&buf);
  290.     height = bytestream_get_be16(&buf);
  291.  
  292.     /* Make sure the bitmap is not too large */
  293.     if (avctx->width < width || avctx->height < height) {
  294.         av_log(avctx, AV_LOG_ERROR, "Bitmap dimensions larger than video.\n");
  295.         return AVERROR_INVALIDDATA;
  296.     }
  297.  
  298.     object->w = width;
  299.     object->h = height;
  300.  
  301.     av_fast_padded_malloc(&object->rle, &object->rle_buffer_size, rle_bitmap_len);
  302.  
  303.     if (!object->rle)
  304.         return AVERROR(ENOMEM);
  305.  
  306.     memcpy(object->rle, buf, buf_size);
  307.     object->rle_data_len = buf_size;
  308.     object->rle_remaining_len = rle_bitmap_len - buf_size;
  309.  
  310.     return 0;
  311. }
  312.  
  313. /**
  314.  * Parse the palette segment packet.
  315.  *
  316.  * The palette segment contains details of the palette,
  317.  * a maximum of 256 colors can be defined.
  318.  *
  319.  * @param avctx contains the current codec context
  320.  * @param buf pointer to the packet to process
  321.  * @param buf_size size of packet to process
  322.  */
  323. static int parse_palette_segment(AVCodecContext *avctx,
  324.                                   const uint8_t *buf, int buf_size)
  325. {
  326.     PGSSubContext *ctx = avctx->priv_data;
  327.     PGSSubPalette *palette;
  328.  
  329.     const uint8_t *buf_end = buf + buf_size;
  330.     const uint8_t *cm      = ff_crop_tab + MAX_NEG_CROP;
  331.     int color_id;
  332.     int y, cb, cr, alpha;
  333.     int r, g, b, r_add, g_add, b_add;
  334.     int id;
  335.  
  336.     id  = bytestream_get_byte(&buf);
  337.     palette = find_palette(id, &ctx->palettes);
  338.     if (!palette) {
  339.         if (ctx->palettes.count >= MAX_EPOCH_PALETTES) {
  340.             av_log(avctx, AV_LOG_ERROR, "Too many palettes in epoch\n");
  341.             return AVERROR_INVALIDDATA;
  342.         }
  343.         palette = &ctx->palettes.palette[ctx->palettes.count++];
  344.         palette->id  = id;
  345.     }
  346.  
  347.     /* Skip palette version */
  348.     buf += 1;
  349.  
  350.     while (buf < buf_end) {
  351.         color_id  = bytestream_get_byte(&buf);
  352.         y         = bytestream_get_byte(&buf);
  353.         cr        = bytestream_get_byte(&buf);
  354.         cb        = bytestream_get_byte(&buf);
  355.         alpha     = bytestream_get_byte(&buf);
  356.  
  357.         YUV_TO_RGB1(cb, cr);
  358.         YUV_TO_RGB2(r, g, b, y);
  359.  
  360.         ff_dlog(avctx, "Color %d := (%d,%d,%d,%d)\n", color_id, r, g, b, alpha);
  361.  
  362.         /* Store color in palette */
  363.         palette->clut[color_id] = RGBA(r,g,b,alpha);
  364.     }
  365.     return 0;
  366. }
  367.  
  368. /**
  369.  * Parse the presentation segment packet.
  370.  *
  371.  * The presentation segment contains details on the video
  372.  * width, video height, x & y subtitle position.
  373.  *
  374.  * @param avctx contains the current codec context
  375.  * @param buf pointer to the packet to process
  376.  * @param buf_size size of packet to process
  377.  * @todo TODO: Implement cropping
  378.  */
  379. static int parse_presentation_segment(AVCodecContext *avctx,
  380.                                       const uint8_t *buf, int buf_size,
  381.                                       int64_t pts)
  382. {
  383.     PGSSubContext *ctx = avctx->priv_data;
  384.     int i, state, ret;
  385.     const uint8_t *buf_end = buf + buf_size;
  386.  
  387.     // Video descriptor
  388.     int w = bytestream_get_be16(&buf);
  389.     int h = bytestream_get_be16(&buf);
  390.  
  391.     ctx->presentation.pts = pts;
  392.  
  393.     ff_dlog(avctx, "Video Dimensions %dx%d\n",
  394.             w, h);
  395.     ret = ff_set_dimensions(avctx, w, h);
  396.     if (ret < 0)
  397.         return ret;
  398.  
  399.     /* Skip 1 bytes of unknown, frame rate */
  400.     buf++;
  401.  
  402.     // Composition descriptor
  403.     ctx->presentation.id_number = bytestream_get_be16(&buf);
  404.     /*
  405.      * state is a 2 bit field that defines pgs epoch boundaries
  406.      * 00 - Normal, previously defined objects and palettes are still valid
  407.      * 01 - Acquisition point, previous objects and palettes can be released
  408.      * 10 - Epoch start, previous objects and palettes can be released
  409.      * 11 - Epoch continue, previous objects and palettes can be released
  410.      *
  411.      * reserved 6 bits discarded
  412.      */
  413.     state = bytestream_get_byte(&buf) >> 6;
  414.     if (state != 0) {
  415.         flush_cache(avctx);
  416.     }
  417.  
  418.     /*
  419.      * skip palette_update_flag (0x80),
  420.      */
  421.     buf += 1;
  422.     ctx->presentation.palette_id = bytestream_get_byte(&buf);
  423.     ctx->presentation.object_count = bytestream_get_byte(&buf);
  424.     if (ctx->presentation.object_count > MAX_OBJECT_REFS) {
  425.         av_log(avctx, AV_LOG_ERROR,
  426.                "Invalid number of presentation objects %d\n",
  427.                ctx->presentation.object_count);
  428.         ctx->presentation.object_count = 2;
  429.         if (avctx->err_recognition & AV_EF_EXPLODE) {
  430.             return AVERROR_INVALIDDATA;
  431.         }
  432.     }
  433.  
  434.  
  435.     for (i = 0; i < ctx->presentation.object_count; i++)
  436.     {
  437.  
  438.         if (buf_end - buf < 8) {
  439.             av_log(avctx, AV_LOG_ERROR, "Insufficent space for object\n");
  440.             ctx->presentation.object_count = i;
  441.             return AVERROR_INVALIDDATA;
  442.         }
  443.  
  444.         ctx->presentation.objects[i].id = bytestream_get_be16(&buf);
  445.         ctx->presentation.objects[i].window_id = bytestream_get_byte(&buf);
  446.         ctx->presentation.objects[i].composition_flag = bytestream_get_byte(&buf);
  447.  
  448.         ctx->presentation.objects[i].x = bytestream_get_be16(&buf);
  449.         ctx->presentation.objects[i].y = bytestream_get_be16(&buf);
  450.  
  451.         // If cropping
  452.         if (ctx->presentation.objects[i].composition_flag & 0x80) {
  453.             ctx->presentation.objects[i].crop_x = bytestream_get_be16(&buf);
  454.             ctx->presentation.objects[i].crop_y = bytestream_get_be16(&buf);
  455.             ctx->presentation.objects[i].crop_w = bytestream_get_be16(&buf);
  456.             ctx->presentation.objects[i].crop_h = bytestream_get_be16(&buf);
  457.         }
  458.  
  459.         ff_dlog(avctx, "Subtitle Placement x=%d, y=%d\n",
  460.                 ctx->presentation.objects[i].x, ctx->presentation.objects[i].y);
  461.  
  462.         if (ctx->presentation.objects[i].x > avctx->width ||
  463.             ctx->presentation.objects[i].y > avctx->height) {
  464.             av_log(avctx, AV_LOG_ERROR, "Subtitle out of video bounds. x = %d, y = %d, video width = %d, video height = %d.\n",
  465.                    ctx->presentation.objects[i].x,
  466.                    ctx->presentation.objects[i].y,
  467.                     avctx->width, avctx->height);
  468.             ctx->presentation.objects[i].x = 0;
  469.             ctx->presentation.objects[i].y = 0;
  470.             if (avctx->err_recognition & AV_EF_EXPLODE) {
  471.                 return AVERROR_INVALIDDATA;
  472.             }
  473.         }
  474.     }
  475.  
  476.     return 0;
  477. }
  478.  
  479. /**
  480.  * Parse the display segment packet.
  481.  *
  482.  * The display segment controls the updating of the display.
  483.  *
  484.  * @param avctx contains the current codec context
  485.  * @param data pointer to the data pertaining the subtitle to display
  486.  * @param buf pointer to the packet to process
  487.  * @param buf_size size of packet to process
  488.  */
  489. static int display_end_segment(AVCodecContext *avctx, void *data,
  490.                                const uint8_t *buf, int buf_size)
  491. {
  492.     AVSubtitle    *sub = data;
  493.     PGSSubContext *ctx = avctx->priv_data;
  494.     int64_t pts;
  495.     PGSSubPalette *palette;
  496.     int i, ret;
  497.  
  498.     pts = ctx->presentation.pts != AV_NOPTS_VALUE ? ctx->presentation.pts : sub->pts;
  499.     memset(sub, 0, sizeof(*sub));
  500.     sub->pts = pts;
  501.     ctx->presentation.pts = AV_NOPTS_VALUE;
  502.     sub->start_display_time = 0;
  503.     // There is no explicit end time for PGS subtitles.  The end time
  504.     // is defined by the start of the next sub which may contain no
  505.     // objects (i.e. clears the previous sub)
  506.     sub->end_display_time   = UINT32_MAX;
  507.     sub->format             = 0;
  508.  
  509.     // Blank if last object_count was 0.
  510.     if (!ctx->presentation.object_count)
  511.         return 1;
  512.     sub->rects = av_mallocz_array(ctx->presentation.object_count, sizeof(*sub->rects));
  513.     if (!sub->rects) {
  514.         return AVERROR(ENOMEM);
  515.     }
  516.     palette = find_palette(ctx->presentation.palette_id, &ctx->palettes);
  517.     if (!palette) {
  518.         // Missing palette.  Should only happen with damaged streams.
  519.         av_log(avctx, AV_LOG_ERROR, "Invalid palette id %d\n",
  520.                ctx->presentation.palette_id);
  521.         avsubtitle_free(sub);
  522.         return AVERROR_INVALIDDATA;
  523.     }
  524.     for (i = 0; i < ctx->presentation.object_count; i++) {
  525.         PGSSubObject *object;
  526.  
  527.         sub->rects[i]  = av_mallocz(sizeof(*sub->rects[0]));
  528.         if (!sub->rects[i]) {
  529.             avsubtitle_free(sub);
  530.             return AVERROR(ENOMEM);
  531.         }
  532.         sub->num_rects++;
  533.         sub->rects[i]->type = SUBTITLE_BITMAP;
  534.  
  535.         /* Process bitmap */
  536.         object = find_object(ctx->presentation.objects[i].id, &ctx->objects);
  537.         if (!object) {
  538.             // Missing object.  Should only happen with damaged streams.
  539.             av_log(avctx, AV_LOG_ERROR, "Invalid object id %d\n",
  540.                    ctx->presentation.objects[i].id);
  541.             if (avctx->err_recognition & AV_EF_EXPLODE) {
  542.                 avsubtitle_free(sub);
  543.                 return AVERROR_INVALIDDATA;
  544.             }
  545.             // Leaves rect empty with 0 width and height.
  546.             continue;
  547.         }
  548.         if (ctx->presentation.objects[i].composition_flag & 0x40)
  549.             sub->rects[i]->flags |= AV_SUBTITLE_FLAG_FORCED;
  550.  
  551.         sub->rects[i]->x    = ctx->presentation.objects[i].x;
  552.         sub->rects[i]->y    = ctx->presentation.objects[i].y;
  553.         sub->rects[i]->w    = object->w;
  554.         sub->rects[i]->h    = object->h;
  555.  
  556.         sub->rects[i]->pict.linesize[0] = object->w;
  557.  
  558.         if (object->rle) {
  559.             if (object->rle_remaining_len) {
  560.                 av_log(avctx, AV_LOG_ERROR, "RLE data length %u is %u bytes shorter than expected\n",
  561.                        object->rle_data_len, object->rle_remaining_len);
  562.                 if (avctx->err_recognition & AV_EF_EXPLODE) {
  563.                     avsubtitle_free(sub);
  564.                     return AVERROR_INVALIDDATA;
  565.                 }
  566.             }
  567.             ret = decode_rle(avctx, sub->rects[i], object->rle, object->rle_data_len);
  568.             if (ret < 0) {
  569.                 if ((avctx->err_recognition & AV_EF_EXPLODE) ||
  570.                     ret == AVERROR(ENOMEM)) {
  571.                     avsubtitle_free(sub);
  572.                     return ret;
  573.                 }
  574.                 sub->rects[i]->w = 0;
  575.                 sub->rects[i]->h = 0;
  576.                 continue;
  577.             }
  578.         }
  579.         /* Allocate memory for colors */
  580.         sub->rects[i]->nb_colors    = 256;
  581.         sub->rects[i]->pict.data[1] = av_mallocz(AVPALETTE_SIZE);
  582.         if (!sub->rects[i]->pict.data[1]) {
  583.             avsubtitle_free(sub);
  584.             return AVERROR(ENOMEM);
  585.         }
  586.  
  587.         if (!ctx->forced_subs_only || ctx->presentation.objects[i].composition_flag & 0x40)
  588.         memcpy(sub->rects[i]->pict.data[1], palette->clut, sub->rects[i]->nb_colors * sizeof(uint32_t));
  589.  
  590.     }
  591.     return 1;
  592. }
  593.  
  594. static int decode(AVCodecContext *avctx, void *data, int *data_size,
  595.                   AVPacket *avpkt)
  596. {
  597.     const uint8_t *buf = avpkt->data;
  598.     int buf_size       = avpkt->size;
  599.  
  600.     const uint8_t *buf_end;
  601.     uint8_t       segment_type;
  602.     int           segment_length;
  603.     int i, ret;
  604.  
  605.     ff_dlog(avctx, "PGS sub packet:\n");
  606.  
  607.     for (i = 0; i < buf_size; i++) {
  608.         ff_dlog(avctx, "%02x ", buf[i]);
  609.         if (i % 16 == 15)
  610.             ff_dlog(avctx, "\n");
  611.     }
  612.  
  613.     if (i & 15)
  614.         ff_dlog(avctx, "\n");
  615.  
  616.     *data_size = 0;
  617.  
  618.     /* Ensure that we have received at a least a segment code and segment length */
  619.     if (buf_size < 3)
  620.         return -1;
  621.  
  622.     buf_end = buf + buf_size;
  623.  
  624.     /* Step through buffer to identify segments */
  625.     while (buf < buf_end) {
  626.         segment_type   = bytestream_get_byte(&buf);
  627.         segment_length = bytestream_get_be16(&buf);
  628.  
  629.         ff_dlog(avctx, "Segment Length %d, Segment Type %x\n", segment_length, segment_type);
  630.  
  631.         if (segment_type != DISPLAY_SEGMENT && segment_length > buf_end - buf)
  632.             break;
  633.  
  634.         ret = 0;
  635.         switch (segment_type) {
  636.         case PALETTE_SEGMENT:
  637.             ret = parse_palette_segment(avctx, buf, segment_length);
  638.             break;
  639.         case OBJECT_SEGMENT:
  640.             ret = parse_object_segment(avctx, buf, segment_length);
  641.             break;
  642.         case PRESENTATION_SEGMENT:
  643.             ret = parse_presentation_segment(avctx, buf, segment_length, ((AVSubtitle*)(data))->pts);
  644.             break;
  645.         case WINDOW_SEGMENT:
  646.             /*
  647.              * Window Segment Structure (No new information provided):
  648.              *     2 bytes: Unknown,
  649.              *     2 bytes: X position of subtitle,
  650.              *     2 bytes: Y position of subtitle,
  651.              *     2 bytes: Width of subtitle,
  652.              *     2 bytes: Height of subtitle.
  653.              */
  654.             break;
  655.         case DISPLAY_SEGMENT:
  656.             ret = display_end_segment(avctx, data, buf, segment_length);
  657.             if (ret >= 0)
  658.                 *data_size = ret;
  659.             break;
  660.         default:
  661.             av_log(avctx, AV_LOG_ERROR, "Unknown subtitle segment type 0x%x, length %d\n",
  662.                    segment_type, segment_length);
  663.             ret = AVERROR_INVALIDDATA;
  664.             break;
  665.         }
  666.         if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
  667.             return ret;
  668.  
  669.         buf += segment_length;
  670.     }
  671.  
  672.     return buf_size;
  673. }
  674.  
  675. #define OFFSET(x) offsetof(PGSSubContext, x)
  676. #define SD AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_DECODING_PARAM
  677. static const AVOption options[] = {
  678.     {"forced_subs_only", "Only show forced subtitles", OFFSET(forced_subs_only), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, SD},
  679.     { NULL },
  680. };
  681.  
  682. static const AVClass pgsdec_class = {
  683.     .class_name = "PGS subtitle decoder",
  684.     .item_name  = av_default_item_name,
  685.     .option     = options,
  686.     .version    = LIBAVUTIL_VERSION_INT,
  687. };
  688.  
  689. AVCodec ff_pgssub_decoder = {
  690.     .name           = "pgssub",
  691.     .long_name      = NULL_IF_CONFIG_SMALL("HDMV Presentation Graphic Stream subtitles"),
  692.     .type           = AVMEDIA_TYPE_SUBTITLE,
  693.     .id             = AV_CODEC_ID_HDMV_PGS_SUBTITLE,
  694.     .priv_data_size = sizeof(PGSSubContext),
  695.     .init           = init_decoder,
  696.     .close          = close_decoder,
  697.     .decode         = decode,
  698.     .priv_class     = &pgsdec_class,
  699. };
  700.