Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * DVB subtitle decoding
  3.  * Copyright (c) 2005 Ian Caulfield
  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. #include "avcodec.h"
  23. #include "get_bits.h"
  24. #include "bytestream.h"
  25. #include "internal.h"
  26. #include "libavutil/colorspace.h"
  27. #include "libavutil/opt.h"
  28.  
  29. #define DVBSUB_PAGE_SEGMENT     0x10
  30. #define DVBSUB_REGION_SEGMENT   0x11
  31. #define DVBSUB_CLUT_SEGMENT     0x12
  32. #define DVBSUB_OBJECT_SEGMENT   0x13
  33. #define DVBSUB_DISPLAYDEFINITION_SEGMENT 0x14
  34. #define DVBSUB_DISPLAY_SEGMENT  0x80
  35.  
  36. #define cm (ff_crop_tab + MAX_NEG_CROP)
  37.  
  38. #ifdef DEBUG
  39. #if 0
  40. static void png_save(const char *filename, uint8_t *bitmap, int w, int h,
  41.                      uint32_t *rgba_palette)
  42. {
  43.     int x, y, v;
  44.     FILE *f;
  45.     char fname[40], fname2[40];
  46.     char command[1024];
  47.  
  48.     snprintf(fname, 40, "%s.ppm", filename);
  49.  
  50.     f = fopen(fname, "w");
  51.     if (!f) {
  52.         perror(fname);
  53.         return;
  54.     }
  55.     fprintf(f, "P6\n"
  56.             "%d %d\n"
  57.             "%d\n",
  58.             w, h, 255);
  59.     for(y = 0; y < h; y++) {
  60.         for(x = 0; x < w; x++) {
  61.             v = rgba_palette[bitmap[y * w + x]];
  62.             putc((v >> 16) & 0xff, f);
  63.             putc((v >> 8) & 0xff, f);
  64.             putc((v >> 0) & 0xff, f);
  65.         }
  66.     }
  67.     fclose(f);
  68.  
  69.  
  70.     snprintf(fname2, 40, "%s-a.pgm", filename);
  71.  
  72.     f = fopen(fname2, "w");
  73.     if (!f) {
  74.         perror(fname2);
  75.         return;
  76.     }
  77.     fprintf(f, "P5\n"
  78.             "%d %d\n"
  79.             "%d\n",
  80.             w, h, 255);
  81.     for(y = 0; y < h; y++) {
  82.         for(x = 0; x < w; x++) {
  83.             v = rgba_palette[bitmap[y * w + x]];
  84.             putc((v >> 24) & 0xff, f);
  85.         }
  86.     }
  87.     fclose(f);
  88.  
  89.     snprintf(command, 1024, "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
  90.     system(command);
  91.  
  92.     snprintf(command, 1024, "rm %s %s", fname, fname2);
  93.     system(command);
  94. }
  95. #endif
  96.  
  97. static void png_save2(const char *filename, uint32_t *bitmap, int w, int h)
  98. {
  99.     int x, y, v;
  100.     FILE *f;
  101.     char fname[40], fname2[40];
  102.     char command[1024];
  103.  
  104.     snprintf(fname, sizeof(fname), "%s.ppm", filename);
  105.  
  106.     f = fopen(fname, "w");
  107.     if (!f) {
  108.         perror(fname);
  109.         return;
  110.     }
  111.     fprintf(f, "P6\n"
  112.             "%d %d\n"
  113.             "%d\n",
  114.             w, h, 255);
  115.     for(y = 0; y < h; y++) {
  116.         for(x = 0; x < w; x++) {
  117.             v = bitmap[y * w + x];
  118.             putc((v >> 16) & 0xff, f);
  119.             putc((v >> 8) & 0xff, f);
  120.             putc((v >> 0) & 0xff, f);
  121.         }
  122.     }
  123.     fclose(f);
  124.  
  125.  
  126.     snprintf(fname2, sizeof(fname2), "%s-a.pgm", filename);
  127.  
  128.     f = fopen(fname2, "w");
  129.     if (!f) {
  130.         perror(fname2);
  131.         return;
  132.     }
  133.     fprintf(f, "P5\n"
  134.             "%d %d\n"
  135.             "%d\n",
  136.             w, h, 255);
  137.     for(y = 0; y < h; y++) {
  138.         for(x = 0; x < w; x++) {
  139.             v = bitmap[y * w + x];
  140.             putc((v >> 24) & 0xff, f);
  141.         }
  142.     }
  143.     fclose(f);
  144.  
  145.     snprintf(command, sizeof(command), "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
  146.     system(command);
  147.  
  148.     snprintf(command, sizeof(command), "rm %s %s", fname, fname2);
  149.     system(command);
  150. }
  151. #endif
  152.  
  153. #define RGBA(r,g,b,a) (((unsigned)(a) << 24) | ((r) << 16) | ((g) << 8) | (b))
  154.  
  155. typedef struct DVBSubCLUT {
  156.     int id;
  157.     int version;
  158.  
  159.     uint32_t clut4[4];
  160.     uint32_t clut16[16];
  161.     uint32_t clut256[256];
  162.  
  163.     struct DVBSubCLUT *next;
  164. } DVBSubCLUT;
  165.  
  166. static DVBSubCLUT default_clut;
  167.  
  168. typedef struct DVBSubObjectDisplay {
  169.     int object_id;
  170.     int region_id;
  171.  
  172.     int x_pos;
  173.     int y_pos;
  174.  
  175.     int fgcolor;
  176.     int bgcolor;
  177.  
  178.     struct DVBSubObjectDisplay *region_list_next;
  179.     struct DVBSubObjectDisplay *object_list_next;
  180. } DVBSubObjectDisplay;
  181.  
  182. typedef struct DVBSubObject {
  183.     int id;
  184.     int version;
  185.  
  186.     int type;
  187.  
  188.     DVBSubObjectDisplay *display_list;
  189.  
  190.     struct DVBSubObject *next;
  191. } DVBSubObject;
  192.  
  193. typedef struct DVBSubRegionDisplay {
  194.     int region_id;
  195.  
  196.     int x_pos;
  197.     int y_pos;
  198.  
  199.     struct DVBSubRegionDisplay *next;
  200. } DVBSubRegionDisplay;
  201.  
  202. typedef struct DVBSubRegion {
  203.     int id;
  204.     int version;
  205.  
  206.     int width;
  207.     int height;
  208.     int depth;
  209.  
  210.     int clut;
  211.     int bgcolor;
  212.  
  213.     uint8_t *pbuf;
  214.     int buf_size;
  215.     int dirty;
  216.  
  217.     DVBSubObjectDisplay *display_list;
  218.  
  219.     struct DVBSubRegion *next;
  220. } DVBSubRegion;
  221.  
  222. typedef struct DVBSubDisplayDefinition {
  223.     int version;
  224.  
  225.     int x;
  226.     int y;
  227.     int width;
  228.     int height;
  229. } DVBSubDisplayDefinition;
  230.  
  231. typedef struct DVBSubContext {
  232.     AVClass *class;
  233.     int composition_id;
  234.     int ancillary_id;
  235.  
  236.     int version;
  237.     int time_out;
  238.     int compute_edt; /**< if 1 end display time calculated using pts
  239.                           if 0 (Default) calculated using time out */
  240.     int compute_clut;
  241.     int substream;
  242.     int64_t prev_start;
  243.     DVBSubRegion *region_list;
  244.     DVBSubCLUT   *clut_list;
  245.     DVBSubObject *object_list;
  246.  
  247.     DVBSubRegionDisplay *display_list;
  248.     DVBSubDisplayDefinition *display_definition;
  249. } DVBSubContext;
  250.  
  251.  
  252. static DVBSubObject* get_object(DVBSubContext *ctx, int object_id)
  253. {
  254.     DVBSubObject *ptr = ctx->object_list;
  255.  
  256.     while (ptr && ptr->id != object_id) {
  257.         ptr = ptr->next;
  258.     }
  259.  
  260.     return ptr;
  261. }
  262.  
  263. static DVBSubCLUT* get_clut(DVBSubContext *ctx, int clut_id)
  264. {
  265.     DVBSubCLUT *ptr = ctx->clut_list;
  266.  
  267.     while (ptr && ptr->id != clut_id) {
  268.         ptr = ptr->next;
  269.     }
  270.  
  271.     return ptr;
  272. }
  273.  
  274. static DVBSubRegion* get_region(DVBSubContext *ctx, int region_id)
  275. {
  276.     DVBSubRegion *ptr = ctx->region_list;
  277.  
  278.     while (ptr && ptr->id != region_id) {
  279.         ptr = ptr->next;
  280.     }
  281.  
  282.     return ptr;
  283. }
  284.  
  285. static void delete_region_display_list(DVBSubContext *ctx, DVBSubRegion *region)
  286. {
  287.     DVBSubObject *object, *obj2, **obj2_ptr;
  288.     DVBSubObjectDisplay *display, *obj_disp, **obj_disp_ptr;
  289.  
  290.     while (region->display_list) {
  291.         display = region->display_list;
  292.  
  293.         object = get_object(ctx, display->object_id);
  294.  
  295.         if (object) {
  296.             obj_disp_ptr = &object->display_list;
  297.             obj_disp = *obj_disp_ptr;
  298.  
  299.             while (obj_disp && obj_disp != display) {
  300.                 obj_disp_ptr = &obj_disp->object_list_next;
  301.                 obj_disp = *obj_disp_ptr;
  302.             }
  303.  
  304.             if (obj_disp) {
  305.                 *obj_disp_ptr = obj_disp->object_list_next;
  306.  
  307.                 if (!object->display_list) {
  308.                     obj2_ptr = &ctx->object_list;
  309.                     obj2 = *obj2_ptr;
  310.  
  311.                     while (obj2 != object) {
  312.                         av_assert0(obj2);
  313.                         obj2_ptr = &obj2->next;
  314.                         obj2 = *obj2_ptr;
  315.                     }
  316.  
  317.                     *obj2_ptr = obj2->next;
  318.  
  319.                     av_freep(&obj2);
  320.                 }
  321.             }
  322.         }
  323.  
  324.         region->display_list = display->region_list_next;
  325.  
  326.         av_freep(&display);
  327.     }
  328.  
  329. }
  330.  
  331. static void delete_cluts(DVBSubContext *ctx)
  332. {
  333.     while (ctx->clut_list) {
  334.         DVBSubCLUT *clut = ctx->clut_list;
  335.  
  336.         ctx->clut_list = clut->next;
  337.  
  338.         av_freep(&clut);
  339.     }
  340. }
  341.  
  342. static void delete_objects(DVBSubContext *ctx)
  343. {
  344.     while (ctx->object_list) {
  345.         DVBSubObject *object = ctx->object_list;
  346.  
  347.         ctx->object_list = object->next;
  348.  
  349.         av_freep(&object);
  350.     }
  351. }
  352.  
  353. static void delete_regions(DVBSubContext *ctx)
  354. {
  355.     while (ctx->region_list) {
  356.         DVBSubRegion *region = ctx->region_list;
  357.  
  358.         ctx->region_list = region->next;
  359.  
  360.         delete_region_display_list(ctx, region);
  361.  
  362.         av_freep(&region->pbuf);
  363.         av_freep(&region);
  364.     }
  365. }
  366.  
  367. static av_cold int dvbsub_init_decoder(AVCodecContext *avctx)
  368. {
  369.     int i, r, g, b, a = 0;
  370.     DVBSubContext *ctx = avctx->priv_data;
  371.  
  372.     if (ctx->substream < 0) {
  373.         ctx->composition_id = -1;
  374.         ctx->ancillary_id   = -1;
  375.     } else if (!avctx->extradata || (avctx->extradata_size < 4) || ((avctx->extradata_size % 5 != 0) && (avctx->extradata_size != 4))) {
  376.         av_log(avctx, AV_LOG_WARNING, "Invalid DVB subtitles stream extradata!\n");
  377.         ctx->composition_id = -1;
  378.         ctx->ancillary_id   = -1;
  379.     } else {
  380.         if (avctx->extradata_size > 5*ctx->substream + 2) {
  381.             ctx->composition_id = AV_RB16(avctx->extradata + 5*ctx->substream);
  382.             ctx->ancillary_id   = AV_RB16(avctx->extradata + 5*ctx->substream + 2);
  383.         } else {
  384.             av_log(avctx, AV_LOG_WARNING, "Selected DVB subtitles sub-stream %d is not available\n", ctx->substream);
  385.             ctx->composition_id = AV_RB16(avctx->extradata);
  386.             ctx->ancillary_id   = AV_RB16(avctx->extradata + 2);
  387.         }
  388.     }
  389.  
  390.     ctx->version = -1;
  391.     ctx->prev_start = AV_NOPTS_VALUE;
  392.  
  393.     default_clut.id = -1;
  394.     default_clut.next = NULL;
  395.  
  396.     default_clut.clut4[0] = RGBA(  0,   0,   0,   0);
  397.     default_clut.clut4[1] = RGBA(255, 255, 255, 255);
  398.     default_clut.clut4[2] = RGBA(  0,   0,   0, 255);
  399.     default_clut.clut4[3] = RGBA(127, 127, 127, 255);
  400.  
  401.     default_clut.clut16[0] = RGBA(  0,   0,   0,   0);
  402.     for (i = 1; i < 16; i++) {
  403.         if (i < 8) {
  404.             r = (i & 1) ? 255 : 0;
  405.             g = (i & 2) ? 255 : 0;
  406.             b = (i & 4) ? 255 : 0;
  407.         } else {
  408.             r = (i & 1) ? 127 : 0;
  409.             g = (i & 2) ? 127 : 0;
  410.             b = (i & 4) ? 127 : 0;
  411.         }
  412.         default_clut.clut16[i] = RGBA(r, g, b, 255);
  413.     }
  414.  
  415.     default_clut.clut256[0] = RGBA(  0,   0,   0,   0);
  416.     for (i = 1; i < 256; i++) {
  417.         if (i < 8) {
  418.             r = (i & 1) ? 255 : 0;
  419.             g = (i & 2) ? 255 : 0;
  420.             b = (i & 4) ? 255 : 0;
  421.             a = 63;
  422.         } else {
  423.             switch (i & 0x88) {
  424.             case 0x00:
  425.                 r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
  426.                 g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
  427.                 b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
  428.                 a = 255;
  429.                 break;
  430.             case 0x08:
  431.                 r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
  432.                 g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
  433.                 b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
  434.                 a = 127;
  435.                 break;
  436.             case 0x80:
  437.                 r = 127 + ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
  438.                 g = 127 + ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
  439.                 b = 127 + ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
  440.                 a = 255;
  441.                 break;
  442.             case 0x88:
  443.                 r = ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
  444.                 g = ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
  445.                 b = ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
  446.                 a = 255;
  447.                 break;
  448.             }
  449.         }
  450.         default_clut.clut256[i] = RGBA(r, g, b, a);
  451.     }
  452.  
  453.     return 0;
  454. }
  455.  
  456. static av_cold int dvbsub_close_decoder(AVCodecContext *avctx)
  457. {
  458.     DVBSubContext *ctx = avctx->priv_data;
  459.     DVBSubRegionDisplay *display;
  460.  
  461.     delete_regions(ctx);
  462.  
  463.     delete_objects(ctx);
  464.  
  465.     delete_cluts(ctx);
  466.  
  467.     av_freep(&ctx->display_definition);
  468.  
  469.     while (ctx->display_list) {
  470.         display = ctx->display_list;
  471.         ctx->display_list = display->next;
  472.  
  473.         av_freep(&display);
  474.     }
  475.  
  476.     return 0;
  477. }
  478.  
  479. static int dvbsub_read_2bit_string(AVCodecContext *avctx,
  480.                                    uint8_t *destbuf, int dbuf_len,
  481.                                    const uint8_t **srcbuf, int buf_size,
  482.                                    int non_mod, uint8_t *map_table, int x_pos)
  483. {
  484.     GetBitContext gb;
  485.  
  486.     int bits;
  487.     int run_length;
  488.     int pixels_read = x_pos;
  489.  
  490.     init_get_bits(&gb, *srcbuf, buf_size << 3);
  491.  
  492.     destbuf += x_pos;
  493.  
  494.     while (get_bits_count(&gb) < buf_size << 3 && pixels_read < dbuf_len) {
  495.         bits = get_bits(&gb, 2);
  496.  
  497.         if (bits) {
  498.             if (non_mod != 1 || bits != 1) {
  499.                 if (map_table)
  500.                     *destbuf++ = map_table[bits];
  501.                 else
  502.                     *destbuf++ = bits;
  503.             }
  504.             pixels_read++;
  505.         } else {
  506.             bits = get_bits1(&gb);
  507.             if (bits == 1) {
  508.                 run_length = get_bits(&gb, 3) + 3;
  509.                 bits = get_bits(&gb, 2);
  510.  
  511.                 if (non_mod == 1 && bits == 1)
  512.                     pixels_read += run_length;
  513.                 else {
  514.                     if (map_table)
  515.                         bits = map_table[bits];
  516.                     while (run_length-- > 0 && pixels_read < dbuf_len) {
  517.                         *destbuf++ = bits;
  518.                         pixels_read++;
  519.                     }
  520.                 }
  521.             } else {
  522.                 bits = get_bits1(&gb);
  523.                 if (bits == 0) {
  524.                     bits = get_bits(&gb, 2);
  525.                     if (bits == 2) {
  526.                         run_length = get_bits(&gb, 4) + 12;
  527.                         bits = get_bits(&gb, 2);
  528.  
  529.                         if (non_mod == 1 && bits == 1)
  530.                             pixels_read += run_length;
  531.                         else {
  532.                             if (map_table)
  533.                                 bits = map_table[bits];
  534.                             while (run_length-- > 0 && pixels_read < dbuf_len) {
  535.                                 *destbuf++ = bits;
  536.                                 pixels_read++;
  537.                             }
  538.                         }
  539.                     } else if (bits == 3) {
  540.                         run_length = get_bits(&gb, 8) + 29;
  541.                         bits = get_bits(&gb, 2);
  542.  
  543.                         if (non_mod == 1 && bits == 1)
  544.                             pixels_read += run_length;
  545.                         else {
  546.                             if (map_table)
  547.                                 bits = map_table[bits];
  548.                             while (run_length-- > 0 && pixels_read < dbuf_len) {
  549.                                 *destbuf++ = bits;
  550.                                 pixels_read++;
  551.                             }
  552.                         }
  553.                     } else if (bits == 1) {
  554.                         if (map_table)
  555.                             bits = map_table[0];
  556.                         else
  557.                             bits = 0;
  558.                         run_length = 2;
  559.                         while (run_length-- > 0 && pixels_read < dbuf_len) {
  560.                             *destbuf++ = bits;
  561.                             pixels_read++;
  562.                         }
  563.                     } else {
  564.                         (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
  565.                         return pixels_read;
  566.                     }
  567.                 } else {
  568.                     if (map_table)
  569.                         bits = map_table[0];
  570.                     else
  571.                         bits = 0;
  572.                     *destbuf++ = bits;
  573.                     pixels_read++;
  574.                 }
  575.             }
  576.         }
  577.     }
  578.  
  579.     if (get_bits(&gb, 6))
  580.         av_log(avctx, AV_LOG_ERROR, "line overflow\n");
  581.  
  582.     (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
  583.  
  584.     return pixels_read;
  585. }
  586.  
  587. static int dvbsub_read_4bit_string(AVCodecContext *avctx, uint8_t *destbuf, int dbuf_len,
  588.                                    const uint8_t **srcbuf, int buf_size,
  589.                                    int non_mod, uint8_t *map_table, int x_pos)
  590. {
  591.     GetBitContext gb;
  592.  
  593.     int bits;
  594.     int run_length;
  595.     int pixels_read = x_pos;
  596.  
  597.     init_get_bits(&gb, *srcbuf, buf_size << 3);
  598.  
  599.     destbuf += x_pos;
  600.  
  601.     while (get_bits_count(&gb) < buf_size << 3 && pixels_read < dbuf_len) {
  602.         bits = get_bits(&gb, 4);
  603.  
  604.         if (bits) {
  605.             if (non_mod != 1 || bits != 1) {
  606.                 if (map_table)
  607.                     *destbuf++ = map_table[bits];
  608.                 else
  609.                     *destbuf++ = bits;
  610.             }
  611.             pixels_read++;
  612.         } else {
  613.             bits = get_bits1(&gb);
  614.             if (bits == 0) {
  615.                 run_length = get_bits(&gb, 3);
  616.  
  617.                 if (run_length == 0) {
  618.                     (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
  619.                     return pixels_read;
  620.                 }
  621.  
  622.                 run_length += 2;
  623.  
  624.                 if (map_table)
  625.                     bits = map_table[0];
  626.                 else
  627.                     bits = 0;
  628.  
  629.                 while (run_length-- > 0 && pixels_read < dbuf_len) {
  630.                     *destbuf++ = bits;
  631.                     pixels_read++;
  632.                 }
  633.             } else {
  634.                 bits = get_bits1(&gb);
  635.                 if (bits == 0) {
  636.                     run_length = get_bits(&gb, 2) + 4;
  637.                     bits = get_bits(&gb, 4);
  638.  
  639.                     if (non_mod == 1 && bits == 1)
  640.                         pixels_read += run_length;
  641.                     else {
  642.                         if (map_table)
  643.                             bits = map_table[bits];
  644.                         while (run_length-- > 0 && pixels_read < dbuf_len) {
  645.                             *destbuf++ = bits;
  646.                             pixels_read++;
  647.                         }
  648.                     }
  649.                 } else {
  650.                     bits = get_bits(&gb, 2);
  651.                     if (bits == 2) {
  652.                         run_length = get_bits(&gb, 4) + 9;
  653.                         bits = get_bits(&gb, 4);
  654.  
  655.                         if (non_mod == 1 && bits == 1)
  656.                             pixels_read += run_length;
  657.                         else {
  658.                             if (map_table)
  659.                                 bits = map_table[bits];
  660.                             while (run_length-- > 0 && pixels_read < dbuf_len) {
  661.                                 *destbuf++ = bits;
  662.                                 pixels_read++;
  663.                             }
  664.                         }
  665.                     } else if (bits == 3) {
  666.                         run_length = get_bits(&gb, 8) + 25;
  667.                         bits = get_bits(&gb, 4);
  668.  
  669.                         if (non_mod == 1 && bits == 1)
  670.                             pixels_read += run_length;
  671.                         else {
  672.                             if (map_table)
  673.                                 bits = map_table[bits];
  674.                             while (run_length-- > 0 && pixels_read < dbuf_len) {
  675.                                 *destbuf++ = bits;
  676.                                 pixels_read++;
  677.                             }
  678.                         }
  679.                     } else if (bits == 1) {
  680.                         if (map_table)
  681.                             bits = map_table[0];
  682.                         else
  683.                             bits = 0;
  684.                         run_length = 2;
  685.                         while (run_length-- > 0 && pixels_read < dbuf_len) {
  686.                             *destbuf++ = bits;
  687.                             pixels_read++;
  688.                         }
  689.                     } else {
  690.                         if (map_table)
  691.                             bits = map_table[0];
  692.                         else
  693.                             bits = 0;
  694.                         *destbuf++ = bits;
  695.                         pixels_read ++;
  696.                     }
  697.                 }
  698.             }
  699.         }
  700.     }
  701.  
  702.     if (get_bits(&gb, 8))
  703.         av_log(avctx, AV_LOG_ERROR, "line overflow\n");
  704.  
  705.     (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
  706.  
  707.     return pixels_read;
  708. }
  709.  
  710. static int dvbsub_read_8bit_string(AVCodecContext *avctx,
  711.                                    uint8_t *destbuf, int dbuf_len,
  712.                                     const uint8_t **srcbuf, int buf_size,
  713.                                     int non_mod, uint8_t *map_table, int x_pos)
  714. {
  715.     const uint8_t *sbuf_end = (*srcbuf) + buf_size;
  716.     int bits;
  717.     int run_length;
  718.     int pixels_read = x_pos;
  719.  
  720.     destbuf += x_pos;
  721.  
  722.     while (*srcbuf < sbuf_end && pixels_read < dbuf_len) {
  723.         bits = *(*srcbuf)++;
  724.  
  725.         if (bits) {
  726.             if (non_mod != 1 || bits != 1) {
  727.                 if (map_table)
  728.                     *destbuf++ = map_table[bits];
  729.                 else
  730.                     *destbuf++ = bits;
  731.             }
  732.             pixels_read++;
  733.         } else {
  734.             bits = *(*srcbuf)++;
  735.             run_length = bits & 0x7f;
  736.             if ((bits & 0x80) == 0) {
  737.                 if (run_length == 0) {
  738.                     return pixels_read;
  739.                 }
  740.  
  741.                 bits = 0;
  742.             } else {
  743.                 bits = *(*srcbuf)++;
  744.             }
  745.             if (non_mod == 1 && bits == 1)
  746.                 pixels_read += run_length;
  747.             else {
  748.                 if (map_table)
  749.                     bits = map_table[bits];
  750.                 while (run_length-- > 0 && pixels_read < dbuf_len) {
  751.                     *destbuf++ = bits;
  752.                     pixels_read++;
  753.                 }
  754.             }
  755.         }
  756.     }
  757.  
  758.     if (*(*srcbuf)++)
  759.         av_log(avctx, AV_LOG_ERROR, "line overflow\n");
  760.  
  761.     return pixels_read;
  762. }
  763.  
  764. static void compute_default_clut(AVPicture *frame, int w, int h)
  765. {
  766.     uint8_t list[256] = {0};
  767.     uint8_t list_inv[256];
  768.     int counttab[256] = {0};
  769.     int count, i, x, y;
  770.  
  771. #define V(x,y) frame->data[0][(x) + (y)*frame->linesize[0]]
  772.     for (y = 0; y<h; y++) {
  773.         for (x = 0; x<w; x++) {
  774.             int v = V(x,y) + 1;
  775.             int vl = x     ? V(x-1,y) + 1 : 0;
  776.             int vr = x+1<w ? V(x+1,y) + 1 : 0;
  777.             int vt = y     ? V(x,y-1) + 1 : 0;
  778.             int vb = y+1<h ? V(x,y+1) + 1 : 0;
  779.             counttab[v-1] += !!((v!=vl) + (v!=vr) + (v!=vt) + (v!=vb));
  780.         }
  781.     }
  782. #define L(x,y) list[ frame->data[0][(x) + (y)*frame->linesize[0]] ]
  783.  
  784.     for (i = 0; i<256; i++) {
  785.         int scoretab[256] = {0};
  786.         int bestscore = 0;
  787.         int bestv = 0;
  788.         for (y = 0; y<h; y++) {
  789.             for (x = 0; x<w; x++) {
  790.                 int v = frame->data[0][x + y*frame->linesize[0]];
  791.                 int l_m = list[v];
  792.                 int l_l = x     ? L(x-1, y) : 1;
  793.                 int l_r = x+1<w ? L(x+1, y) : 1;
  794.                 int l_t = y     ? L(x, y-1) : 1;
  795.                 int l_b = y+1<h ? L(x, y+1) : 1;
  796.                 int score;
  797.                 if (l_m)
  798.                     continue;
  799.                 scoretab[v] += l_l + l_r + l_t + l_b;
  800.                 score = 1024LL*scoretab[v] / counttab[v];
  801.                 if (score > bestscore) {
  802.                     bestscore = score;
  803.                     bestv = v;
  804.                 }
  805.             }
  806.         }
  807.         if (!bestscore)
  808.             break;
  809.         list    [ bestv ] = 1;
  810.         list_inv[     i ] = bestv;
  811.     }
  812.  
  813.     count = i - 1;
  814.     for (i--; i>=0; i--) {
  815.         int v = i*255/count;
  816.         AV_WN32(frame->data[1] + 4*list_inv[i], RGBA(v/2,v,v/2,v));
  817.     }
  818. }
  819.  
  820.  
  821. static int save_subtitle_set(AVCodecContext *avctx, AVSubtitle *sub, int *got_output)
  822. {
  823.     DVBSubContext *ctx = avctx->priv_data;
  824.     DVBSubRegionDisplay *display;
  825.     DVBSubDisplayDefinition *display_def = ctx->display_definition;
  826.     DVBSubRegion *region;
  827.     AVSubtitleRect *rect;
  828.     DVBSubCLUT *clut;
  829.     uint32_t *clut_table;
  830.     int i;
  831.     int offset_x=0, offset_y=0;
  832.     int ret = 0;
  833.  
  834.  
  835.     if (display_def) {
  836.         offset_x = display_def->x;
  837.         offset_y = display_def->y;
  838.     }
  839.  
  840.     /* Not touching AVSubtitles again*/
  841.     if(sub->num_rects) {
  842.         avpriv_request_sample(ctx, "Different Version of Segment asked Twice");
  843.         return AVERROR_PATCHWELCOME;
  844.     }
  845.     for (display = ctx->display_list; display; display = display->next) {
  846.         region = get_region(ctx, display->region_id);
  847.         if (region && region->dirty)
  848.             sub->num_rects++;
  849.     }
  850.  
  851.     if(ctx->compute_edt == 0) {
  852.         sub->end_display_time = ctx->time_out * 1000;
  853.         *got_output = 1;
  854.     } else if (ctx->prev_start != AV_NOPTS_VALUE) {
  855.         sub->end_display_time = av_rescale_q((sub->pts - ctx->prev_start ), AV_TIME_BASE_Q, (AVRational){ 1, 1000 }) - 1;
  856.         *got_output = 1;
  857.     }
  858.     if (sub->num_rects > 0) {
  859.  
  860.         sub->rects = av_mallocz_array(sizeof(*sub->rects), sub->num_rects);
  861.         if (!sub->rects) {
  862.             ret = AVERROR(ENOMEM);
  863.             goto fail;
  864.         }
  865.  
  866.         for(i=0; i<sub->num_rects; i++)
  867.             sub->rects[i] = av_mallocz(sizeof(*sub->rects[i]));
  868.  
  869.         i = 0;
  870.  
  871.         for (display = ctx->display_list; display; display = display->next) {
  872.             region = get_region(ctx, display->region_id);
  873.  
  874.             if (!region)
  875.                 continue;
  876.  
  877.             if (!region->dirty)
  878.                 continue;
  879.  
  880.             rect = sub->rects[i];
  881.             rect->x = display->x_pos + offset_x;
  882.             rect->y = display->y_pos + offset_y;
  883.             rect->w = region->width;
  884.             rect->h = region->height;
  885.             rect->nb_colors = (1 << region->depth);
  886.             rect->type      = SUBTITLE_BITMAP;
  887.             rect->pict.linesize[0] = region->width;
  888.  
  889.             clut = get_clut(ctx, region->clut);
  890.  
  891.             if (!clut)
  892.                 clut = &default_clut;
  893.  
  894.             switch (region->depth) {
  895.             case 2:
  896.                 clut_table = clut->clut4;
  897.                 break;
  898.             case 8:
  899.                 clut_table = clut->clut256;
  900.                 break;
  901.             case 4:
  902.             default:
  903.                 clut_table = clut->clut16;
  904.                 break;
  905.             }
  906.  
  907.             rect->pict.data[1] = av_mallocz(AVPALETTE_SIZE);
  908.             if (!rect->pict.data[1]) {
  909.                 ret = AVERROR(ENOMEM);
  910.                 goto fail;
  911.             }
  912.             memcpy(rect->pict.data[1], clut_table, (1 << region->depth) * sizeof(uint32_t));
  913.  
  914.             rect->pict.data[0] = av_malloc(region->buf_size);
  915.             if (!rect->pict.data[0]) {
  916.                 ret = AVERROR(ENOMEM);
  917.                 goto fail;
  918.             }
  919.  
  920.             memcpy(rect->pict.data[0], region->pbuf, region->buf_size);
  921.  
  922.             if ((clut == &default_clut && ctx->compute_clut == -1) || ctx->compute_clut == 1)
  923.                 compute_default_clut(&rect->pict, rect->w, rect->h);
  924.  
  925.             i++;
  926.         }
  927.     }
  928.  
  929.     return 0;
  930. fail:
  931.     if (sub->rects) {
  932.         for(i=0; i<sub->num_rects; i++) {
  933.             rect = sub->rects[i];
  934.             if (rect) {
  935.                 av_freep(&rect->pict.data[0]);
  936.                 av_freep(&rect->pict.data[1]);
  937.             }
  938.             av_freep(&sub->rects[i]);
  939.         }
  940.         av_freep(&sub->rects);
  941.     }
  942.     sub->num_rects = 0;
  943.     return ret;
  944. }
  945.  
  946. static void dvbsub_parse_pixel_data_block(AVCodecContext *avctx, DVBSubObjectDisplay *display,
  947.                                           const uint8_t *buf, int buf_size, int top_bottom, int non_mod)
  948. {
  949.     DVBSubContext *ctx = avctx->priv_data;
  950.  
  951.     DVBSubRegion *region = get_region(ctx, display->region_id);
  952.     const uint8_t *buf_end = buf + buf_size;
  953.     uint8_t *pbuf;
  954.     int x_pos, y_pos;
  955.     int i;
  956.  
  957.     uint8_t map2to4[] = { 0x0,  0x7,  0x8,  0xf};
  958.     uint8_t map2to8[] = {0x00, 0x77, 0x88, 0xff};
  959.     uint8_t map4to8[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
  960.                          0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
  961.     uint8_t *map_table;
  962.  
  963. #if 0
  964.     ff_dlog(avctx, "DVB pixel block size %d, %s field:\n", buf_size,
  965.             top_bottom ? "bottom" : "top");
  966.  
  967.     for (i = 0; i < buf_size; i++) {
  968.         if (i % 16 == 0)
  969.             ff_dlog(avctx, "0x%8p: ", buf+i);
  970.  
  971.         ff_dlog(avctx, "%02x ", buf[i]);
  972.         if (i % 16 == 15)
  973.             ff_dlog(avctx, "\n");
  974.     }
  975.  
  976.     if (i % 16)
  977.         ff_dlog(avctx, "\n");
  978. #endif
  979.  
  980.     if (!region)
  981.         return;
  982.  
  983.     pbuf = region->pbuf;
  984.     region->dirty = 1;
  985.  
  986.     x_pos = display->x_pos;
  987.     y_pos = display->y_pos;
  988.  
  989.     y_pos += top_bottom;
  990.  
  991.     while (buf < buf_end) {
  992.         if ((*buf!=0xf0 && x_pos >= region->width) || y_pos >= region->height) {
  993.             av_log(avctx, AV_LOG_ERROR, "Invalid object location! %d-%d %d-%d %02x\n", x_pos, region->width, y_pos, region->height, *buf);
  994.             return;
  995.         }
  996.  
  997.         switch (*buf++) {
  998.         case 0x10:
  999.             if (region->depth == 8)
  1000.                 map_table = map2to8;
  1001.             else if (region->depth == 4)
  1002.                 map_table = map2to4;
  1003.             else
  1004.                 map_table = NULL;
  1005.  
  1006.             x_pos = dvbsub_read_2bit_string(avctx, pbuf + (y_pos * region->width),
  1007.                                             region->width, &buf, buf_end - buf,
  1008.                                             non_mod, map_table, x_pos);
  1009.             break;
  1010.         case 0x11:
  1011.             if (region->depth < 4) {
  1012.                 av_log(avctx, AV_LOG_ERROR, "4-bit pixel string in %d-bit region!\n", region->depth);
  1013.                 return;
  1014.             }
  1015.  
  1016.             if (region->depth == 8)
  1017.                 map_table = map4to8;
  1018.             else
  1019.                 map_table = NULL;
  1020.  
  1021.             x_pos = dvbsub_read_4bit_string(avctx, pbuf + (y_pos * region->width),
  1022.                                             region->width, &buf, buf_end - buf,
  1023.                                             non_mod, map_table, x_pos);
  1024.             break;
  1025.         case 0x12:
  1026.             if (region->depth < 8) {
  1027.                 av_log(avctx, AV_LOG_ERROR, "8-bit pixel string in %d-bit region!\n", region->depth);
  1028.                 return;
  1029.             }
  1030.  
  1031.             x_pos = dvbsub_read_8bit_string(avctx, pbuf + (y_pos * region->width),
  1032.                                             region->width, &buf, buf_end - buf,
  1033.                                             non_mod, NULL, x_pos);
  1034.             break;
  1035.  
  1036.         case 0x20:
  1037.             map2to4[0] = (*buf) >> 4;
  1038.             map2to4[1] = (*buf++) & 0xf;
  1039.             map2to4[2] = (*buf) >> 4;
  1040.             map2to4[3] = (*buf++) & 0xf;
  1041.             break;
  1042.         case 0x21:
  1043.             for (i = 0; i < 4; i++)
  1044.                 map2to8[i] = *buf++;
  1045.             break;
  1046.         case 0x22:
  1047.             for (i = 0; i < 16; i++)
  1048.                 map4to8[i] = *buf++;
  1049.             break;
  1050.  
  1051.         case 0xf0:
  1052.             x_pos = display->x_pos;
  1053.             y_pos += 2;
  1054.             break;
  1055.         default:
  1056.             av_log(avctx, AV_LOG_INFO, "Unknown/unsupported pixel block 0x%x\n", *(buf-1));
  1057.         }
  1058.     }
  1059.  
  1060. }
  1061.  
  1062. static int dvbsub_parse_object_segment(AVCodecContext *avctx,
  1063.                                        const uint8_t *buf, int buf_size)
  1064. {
  1065.     DVBSubContext *ctx = avctx->priv_data;
  1066.  
  1067.     const uint8_t *buf_end = buf + buf_size;
  1068.     int object_id;
  1069.     DVBSubObject *object;
  1070.     DVBSubObjectDisplay *display;
  1071.     int top_field_len, bottom_field_len;
  1072.  
  1073.     int coding_method, non_modifying_color;
  1074.  
  1075.     object_id = AV_RB16(buf);
  1076.     buf += 2;
  1077.  
  1078.     object = get_object(ctx, object_id);
  1079.  
  1080.     if (!object)
  1081.         return AVERROR_INVALIDDATA;
  1082.  
  1083.     coding_method = ((*buf) >> 2) & 3;
  1084.     non_modifying_color = ((*buf++) >> 1) & 1;
  1085.  
  1086.     if (coding_method == 0) {
  1087.         top_field_len = AV_RB16(buf);
  1088.         buf += 2;
  1089.         bottom_field_len = AV_RB16(buf);
  1090.         buf += 2;
  1091.  
  1092.         if (buf + top_field_len + bottom_field_len > buf_end) {
  1093.             av_log(avctx, AV_LOG_ERROR, "Field data size %d+%d too large\n", top_field_len, bottom_field_len);
  1094.             return AVERROR_INVALIDDATA;
  1095.         }
  1096.  
  1097.         for (display = object->display_list; display; display = display->object_list_next) {
  1098.             const uint8_t *block = buf;
  1099.             int bfl = bottom_field_len;
  1100.  
  1101.             dvbsub_parse_pixel_data_block(avctx, display, block, top_field_len, 0,
  1102.                                             non_modifying_color);
  1103.  
  1104.             if (bottom_field_len > 0)
  1105.                 block = buf + top_field_len;
  1106.             else
  1107.                 bfl = top_field_len;
  1108.  
  1109.             dvbsub_parse_pixel_data_block(avctx, display, block, bfl, 1,
  1110.                                             non_modifying_color);
  1111.         }
  1112.  
  1113. /*  } else if (coding_method == 1) {*/
  1114.  
  1115.     } else {
  1116.         av_log(avctx, AV_LOG_ERROR, "Unknown object coding %d\n", coding_method);
  1117.     }
  1118.  
  1119.     return 0;
  1120. }
  1121.  
  1122. static int dvbsub_parse_clut_segment(AVCodecContext *avctx,
  1123.                                      const uint8_t *buf, int buf_size)
  1124. {
  1125.     DVBSubContext *ctx = avctx->priv_data;
  1126.  
  1127.     const uint8_t *buf_end = buf + buf_size;
  1128.     int i, clut_id;
  1129.     int version;
  1130.     DVBSubCLUT *clut;
  1131.     int entry_id, depth , full_range;
  1132.     int y, cr, cb, alpha;
  1133.     int r, g, b, r_add, g_add, b_add;
  1134.  
  1135.     ff_dlog(avctx, "DVB clut packet:\n");
  1136.  
  1137.     for (i=0; i < buf_size; i++) {
  1138.         ff_dlog(avctx, "%02x ", buf[i]);
  1139.         if (i % 16 == 15)
  1140.             ff_dlog(avctx, "\n");
  1141.     }
  1142.  
  1143.     if (i % 16)
  1144.         ff_dlog(avctx, "\n");
  1145.  
  1146.     clut_id = *buf++;
  1147.     version = ((*buf)>>4)&15;
  1148.     buf += 1;
  1149.  
  1150.     clut = get_clut(ctx, clut_id);
  1151.  
  1152.     if (!clut) {
  1153.         clut = av_malloc(sizeof(DVBSubCLUT));
  1154.         if (!clut)
  1155.             return AVERROR(ENOMEM);
  1156.  
  1157.         memcpy(clut, &default_clut, sizeof(DVBSubCLUT));
  1158.  
  1159.         clut->id = clut_id;
  1160.         clut->version = -1;
  1161.  
  1162.         clut->next = ctx->clut_list;
  1163.         ctx->clut_list = clut;
  1164.     }
  1165.  
  1166.     if (clut->version != version) {
  1167.  
  1168.     clut->version = version;
  1169.  
  1170.     while (buf + 4 < buf_end) {
  1171.         entry_id = *buf++;
  1172.  
  1173.         depth = (*buf) & 0xe0;
  1174.  
  1175.         if (depth == 0) {
  1176.             av_log(avctx, AV_LOG_ERROR, "Invalid clut depth 0x%x!\n", *buf);
  1177.         }
  1178.  
  1179.         full_range = (*buf++) & 1;
  1180.  
  1181.         if (full_range) {
  1182.             y = *buf++;
  1183.             cr = *buf++;
  1184.             cb = *buf++;
  1185.             alpha = *buf++;
  1186.         } else {
  1187.             y = buf[0] & 0xfc;
  1188.             cr = (((buf[0] & 3) << 2) | ((buf[1] >> 6) & 3)) << 4;
  1189.             cb = (buf[1] << 2) & 0xf0;
  1190.             alpha = (buf[1] << 6) & 0xc0;
  1191.  
  1192.             buf += 2;
  1193.         }
  1194.  
  1195.         if (y == 0)
  1196.             alpha = 0xff;
  1197.  
  1198.         YUV_TO_RGB1_CCIR(cb, cr);
  1199.         YUV_TO_RGB2_CCIR(r, g, b, y);
  1200.  
  1201.         ff_dlog(avctx, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);
  1202.         if (!!(depth & 0x80) + !!(depth & 0x40) + !!(depth & 0x20) > 1) {
  1203.             ff_dlog(avctx, "More than one bit level marked: %x\n", depth);
  1204.             if (avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL)
  1205.                 return AVERROR_INVALIDDATA;
  1206.         }
  1207.  
  1208.         if (depth & 0x80)
  1209.             clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha);
  1210.         else if (depth & 0x40)
  1211.             clut->clut16[entry_id] = RGBA(r,g,b,255 - alpha);
  1212.         else if (depth & 0x20)
  1213.             clut->clut256[entry_id] = RGBA(r,g,b,255 - alpha);
  1214.     }
  1215.     }
  1216.  
  1217.     return 0;
  1218. }
  1219.  
  1220.  
  1221. static int dvbsub_parse_region_segment(AVCodecContext *avctx,
  1222.                                        const uint8_t *buf, int buf_size)
  1223. {
  1224.     DVBSubContext *ctx = avctx->priv_data;
  1225.  
  1226.     const uint8_t *buf_end = buf + buf_size;
  1227.     int region_id, object_id;
  1228.     int av_unused version;
  1229.     DVBSubRegion *region;
  1230.     DVBSubObject *object;
  1231.     DVBSubObjectDisplay *display;
  1232.     int fill;
  1233.  
  1234.     if (buf_size < 10)
  1235.         return AVERROR_INVALIDDATA;
  1236.  
  1237.     region_id = *buf++;
  1238.  
  1239.     region = get_region(ctx, region_id);
  1240.  
  1241.     if (!region) {
  1242.         region = av_mallocz(sizeof(DVBSubRegion));
  1243.         if (!region)
  1244.             return AVERROR(ENOMEM);
  1245.  
  1246.         region->id = region_id;
  1247.         region->version = -1;
  1248.  
  1249.         region->next = ctx->region_list;
  1250.         ctx->region_list = region;
  1251.     }
  1252.  
  1253.     version = ((*buf)>>4) & 15;
  1254.     fill = ((*buf++) >> 3) & 1;
  1255.  
  1256.     region->width = AV_RB16(buf);
  1257.     buf += 2;
  1258.     region->height = AV_RB16(buf);
  1259.     buf += 2;
  1260.  
  1261.     if (region->width * region->height != region->buf_size) {
  1262.         av_free(region->pbuf);
  1263.  
  1264.         region->buf_size = region->width * region->height;
  1265.  
  1266.         region->pbuf = av_malloc(region->buf_size);
  1267.         if (!region->pbuf) {
  1268.             region->buf_size =
  1269.             region->width =
  1270.             region->height = 0;
  1271.             return AVERROR(ENOMEM);
  1272.         }
  1273.  
  1274.         fill = 1;
  1275.         region->dirty = 0;
  1276.     }
  1277.  
  1278.     region->depth = 1 << (((*buf++) >> 2) & 7);
  1279.     if(region->depth<2 || region->depth>8){
  1280.         av_log(avctx, AV_LOG_ERROR, "region depth %d is invalid\n", region->depth);
  1281.         region->depth= 4;
  1282.     }
  1283.     region->clut = *buf++;
  1284.  
  1285.     if (region->depth == 8) {
  1286.         region->bgcolor = *buf++;
  1287.         buf += 1;
  1288.     } else {
  1289.         buf += 1;
  1290.  
  1291.         if (region->depth == 4)
  1292.             region->bgcolor = (((*buf++) >> 4) & 15);
  1293.         else
  1294.             region->bgcolor = (((*buf++) >> 2) & 3);
  1295.     }
  1296.  
  1297.     ff_dlog(avctx, "Region %d, (%dx%d)\n", region_id, region->width, region->height);
  1298.  
  1299.     if (fill) {
  1300.         memset(region->pbuf, region->bgcolor, region->buf_size);
  1301.         ff_dlog(avctx, "Fill region (%d)\n", region->bgcolor);
  1302.     }
  1303.  
  1304.     delete_region_display_list(ctx, region);
  1305.  
  1306.     while (buf + 5 < buf_end) {
  1307.         object_id = AV_RB16(buf);
  1308.         buf += 2;
  1309.  
  1310.         object = get_object(ctx, object_id);
  1311.  
  1312.         if (!object) {
  1313.             object = av_mallocz(sizeof(DVBSubObject));
  1314.             if (!object)
  1315.                 return AVERROR(ENOMEM);
  1316.  
  1317.             object->id = object_id;
  1318.             object->next = ctx->object_list;
  1319.             ctx->object_list = object;
  1320.         }
  1321.  
  1322.         object->type = (*buf) >> 6;
  1323.  
  1324.         display = av_mallocz(sizeof(DVBSubObjectDisplay));
  1325.         if (!display)
  1326.             return AVERROR(ENOMEM);
  1327.  
  1328.         display->object_id = object_id;
  1329.         display->region_id = region_id;
  1330.  
  1331.         display->x_pos = AV_RB16(buf) & 0xfff;
  1332.         buf += 2;
  1333.         display->y_pos = AV_RB16(buf) & 0xfff;
  1334.         buf += 2;
  1335.  
  1336.         if ((object->type == 1 || object->type == 2) && buf+1 < buf_end) {
  1337.             display->fgcolor = *buf++;
  1338.             display->bgcolor = *buf++;
  1339.         }
  1340.  
  1341.         display->region_list_next = region->display_list;
  1342.         region->display_list = display;
  1343.  
  1344.         display->object_list_next = object->display_list;
  1345.         object->display_list = display;
  1346.     }
  1347.  
  1348.     return 0;
  1349. }
  1350.  
  1351. static int dvbsub_parse_page_segment(AVCodecContext *avctx,
  1352.                                      const uint8_t *buf, int buf_size, AVSubtitle *sub, int *got_output)
  1353. {
  1354.     DVBSubContext *ctx = avctx->priv_data;
  1355.     DVBSubRegionDisplay *display;
  1356.     DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;
  1357.  
  1358.     const uint8_t *buf_end = buf + buf_size;
  1359.     int region_id;
  1360.     int page_state;
  1361.     int timeout;
  1362.     int version;
  1363.  
  1364.     if (buf_size < 1)
  1365.         return AVERROR_INVALIDDATA;
  1366.  
  1367.     timeout = *buf++;
  1368.     version = ((*buf)>>4) & 15;
  1369.     page_state = ((*buf++) >> 2) & 3;
  1370.  
  1371.     if (ctx->version == version) {
  1372.         return 0;
  1373.     }
  1374.  
  1375.     ctx->time_out = timeout;
  1376.     ctx->version = version;
  1377.  
  1378.     ff_dlog(avctx, "Page time out %ds, state %d\n", ctx->time_out, page_state);
  1379.  
  1380.     if(ctx->compute_edt == 1)
  1381.         save_subtitle_set(avctx, sub, got_output);
  1382.  
  1383.     if (page_state == 1 || page_state == 2) {
  1384.         delete_regions(ctx);
  1385.         delete_objects(ctx);
  1386.         delete_cluts(ctx);
  1387.     }
  1388.  
  1389.     tmp_display_list = ctx->display_list;
  1390.     ctx->display_list = NULL;
  1391.  
  1392.     while (buf + 5 < buf_end) {
  1393.         region_id = *buf++;
  1394.         buf += 1;
  1395.  
  1396.         display = tmp_display_list;
  1397.         tmp_ptr = &tmp_display_list;
  1398.  
  1399.         while (display && display->region_id != region_id) {
  1400.             tmp_ptr = &display->next;
  1401.             display = display->next;
  1402.         }
  1403.  
  1404.         if (!display) {
  1405.             display = av_mallocz(sizeof(DVBSubRegionDisplay));
  1406.             if (!display)
  1407.                 return AVERROR(ENOMEM);
  1408.         }
  1409.  
  1410.         display->region_id = region_id;
  1411.  
  1412.         display->x_pos = AV_RB16(buf);
  1413.         buf += 2;
  1414.         display->y_pos = AV_RB16(buf);
  1415.         buf += 2;
  1416.  
  1417.         *tmp_ptr = display->next;
  1418.  
  1419.         display->next = ctx->display_list;
  1420.         ctx->display_list = display;
  1421.  
  1422.         ff_dlog(avctx, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
  1423.     }
  1424.  
  1425.     while (tmp_display_list) {
  1426.         display = tmp_display_list;
  1427.  
  1428.         tmp_display_list = display->next;
  1429.  
  1430.         av_freep(&display);
  1431.     }
  1432.  
  1433.     return 0;
  1434. }
  1435.  
  1436.  
  1437. #ifdef DEBUG
  1438. static void save_display_set(DVBSubContext *ctx)
  1439. {
  1440.     DVBSubRegion *region;
  1441.     DVBSubRegionDisplay *display;
  1442.     DVBSubCLUT *clut;
  1443.     uint32_t *clut_table;
  1444.     int x_pos, y_pos, width, height;
  1445.     int x, y, y_off, x_off;
  1446.     uint32_t *pbuf;
  1447.     char filename[32];
  1448.     static int fileno_index = 0;
  1449.  
  1450.     x_pos = -1;
  1451.     y_pos = -1;
  1452.     width = 0;
  1453.     height = 0;
  1454.  
  1455.     for (display = ctx->display_list; display; display = display->next) {
  1456.         region = get_region(ctx, display->region_id);
  1457.  
  1458.         if (!region)
  1459.             return;
  1460.  
  1461.         if (x_pos == -1) {
  1462.             x_pos = display->x_pos;
  1463.             y_pos = display->y_pos;
  1464.             width = region->width;
  1465.             height = region->height;
  1466.         } else {
  1467.             if (display->x_pos < x_pos) {
  1468.                 width += (x_pos - display->x_pos);
  1469.                 x_pos = display->x_pos;
  1470.             }
  1471.  
  1472.             if (display->y_pos < y_pos) {
  1473.                 height += (y_pos - display->y_pos);
  1474.                 y_pos = display->y_pos;
  1475.             }
  1476.  
  1477.             if (display->x_pos + region->width > x_pos + width) {
  1478.                 width = display->x_pos + region->width - x_pos;
  1479.             }
  1480.  
  1481.             if (display->y_pos + region->height > y_pos + height) {
  1482.                 height = display->y_pos + region->height - y_pos;
  1483.             }
  1484.         }
  1485.     }
  1486.  
  1487.     if (x_pos >= 0) {
  1488.  
  1489.         pbuf = av_malloc(width * height * 4);
  1490.         if (!pbuf)
  1491.             return;
  1492.  
  1493.         for (display = ctx->display_list; display; display = display->next) {
  1494.             region = get_region(ctx, display->region_id);
  1495.  
  1496.             if (!region)
  1497.                 return;
  1498.  
  1499.             x_off = display->x_pos - x_pos;
  1500.             y_off = display->y_pos - y_pos;
  1501.  
  1502.             clut = get_clut(ctx, region->clut);
  1503.  
  1504.             if (!clut)
  1505.                 clut = &default_clut;
  1506.  
  1507.             switch (region->depth) {
  1508.             case 2:
  1509.                 clut_table = clut->clut4;
  1510.                 break;
  1511.             case 8:
  1512.                 clut_table = clut->clut256;
  1513.                 break;
  1514.             case 4:
  1515.             default:
  1516.                 clut_table = clut->clut16;
  1517.                 break;
  1518.             }
  1519.  
  1520.             for (y = 0; y < region->height; y++) {
  1521.                 for (x = 0; x < region->width; x++) {
  1522.                     pbuf[((y + y_off) * width) + x_off + x] =
  1523.                         clut_table[region->pbuf[y * region->width + x]];
  1524.                 }
  1525.             }
  1526.  
  1527.         }
  1528.  
  1529.         snprintf(filename, sizeof(filename), "dvbs.%d", fileno_index);
  1530.  
  1531.         png_save2(filename, pbuf, width, height);
  1532.  
  1533.         av_freep(&pbuf);
  1534.     }
  1535.  
  1536.     fileno_index++;
  1537. }
  1538. #endif
  1539.  
  1540. static int dvbsub_parse_display_definition_segment(AVCodecContext *avctx,
  1541.                                                    const uint8_t *buf,
  1542.                                                    int buf_size)
  1543. {
  1544.     DVBSubContext *ctx = avctx->priv_data;
  1545.     DVBSubDisplayDefinition *display_def = ctx->display_definition;
  1546.     int dds_version, info_byte;
  1547.  
  1548.     if (buf_size < 5)
  1549.         return AVERROR_INVALIDDATA;
  1550.  
  1551.     info_byte   = bytestream_get_byte(&buf);
  1552.     dds_version = info_byte >> 4;
  1553.     if (display_def && display_def->version == dds_version)
  1554.         return 0; // already have this display definition version
  1555.  
  1556.     if (!display_def) {
  1557.         display_def             = av_mallocz(sizeof(*display_def));
  1558.         if (!display_def)
  1559.             return AVERROR(ENOMEM);
  1560.         ctx->display_definition = display_def;
  1561.     }
  1562.  
  1563.     display_def->version = dds_version;
  1564.     display_def->x       = 0;
  1565.     display_def->y       = 0;
  1566.     display_def->width   = bytestream_get_be16(&buf) + 1;
  1567.     display_def->height  = bytestream_get_be16(&buf) + 1;
  1568.     if (!avctx->width || !avctx->height) {
  1569.         avctx->width  = display_def->width;
  1570.         avctx->height = display_def->height;
  1571.     }
  1572.  
  1573.     if (info_byte & 1<<3) { // display_window_flag
  1574.         if (buf_size < 13)
  1575.             return AVERROR_INVALIDDATA;
  1576.  
  1577.         display_def->x = bytestream_get_be16(&buf);
  1578.         display_def->width  = bytestream_get_be16(&buf) - display_def->x + 1;
  1579.         display_def->y = bytestream_get_be16(&buf);
  1580.         display_def->height = bytestream_get_be16(&buf) - display_def->y + 1;
  1581.     }
  1582.  
  1583.     return 0;
  1584. }
  1585.  
  1586. static int dvbsub_display_end_segment(AVCodecContext *avctx, const uint8_t *buf,
  1587.                                       int buf_size, AVSubtitle *sub,int *got_output)
  1588. {
  1589.     DVBSubContext *ctx = avctx->priv_data;
  1590.  
  1591.     if(ctx->compute_edt == 0)
  1592.         save_subtitle_set(avctx, sub, got_output);
  1593. #ifdef DEBUG
  1594.     save_display_set(ctx);
  1595. #endif
  1596.     return 0;
  1597. }
  1598.  
  1599. static int dvbsub_decode(AVCodecContext *avctx,
  1600.                          void *data, int *data_size,
  1601.                          AVPacket *avpkt)
  1602. {
  1603.     const uint8_t *buf = avpkt->data;
  1604.     int buf_size = avpkt->size;
  1605.     DVBSubContext *ctx = avctx->priv_data;
  1606.     AVSubtitle *sub = data;
  1607.     const uint8_t *p, *p_end;
  1608.     int segment_type;
  1609.     int page_id;
  1610.     int segment_length;
  1611.     int i;
  1612.     int ret = 0;
  1613.     int got_segment = 0;
  1614.     int got_dds = 0;
  1615.  
  1616.     ff_dlog(avctx, "DVB sub packet:\n");
  1617.  
  1618.     for (i=0; i < buf_size; i++) {
  1619.         ff_dlog(avctx, "%02x ", buf[i]);
  1620.         if (i % 16 == 15)
  1621.             ff_dlog(avctx, "\n");
  1622.     }
  1623.  
  1624.     if (i % 16)
  1625.         ff_dlog(avctx, "\n");
  1626.  
  1627.     if (buf_size <= 6 || *buf != 0x0f) {
  1628.         ff_dlog(avctx, "incomplete or broken packet");
  1629.         return AVERROR_INVALIDDATA;
  1630.     }
  1631.  
  1632.     p = buf;
  1633.     p_end = buf + buf_size;
  1634.  
  1635.     while (p_end - p >= 6 && *p == 0x0f) {
  1636.         p += 1;
  1637.         segment_type = *p++;
  1638.         page_id = AV_RB16(p);
  1639.         p += 2;
  1640.         segment_length = AV_RB16(p);
  1641.         p += 2;
  1642.  
  1643.         if (avctx->debug & FF_DEBUG_STARTCODE) {
  1644.             av_log(avctx, AV_LOG_DEBUG, "segment_type:%d page_id:%d segment_length:%d\n", segment_type, page_id, segment_length);
  1645.         }
  1646.  
  1647.         if (p_end - p < segment_length) {
  1648.             ff_dlog(avctx, "incomplete or broken packet");
  1649.             ret = -1;
  1650.             goto end;
  1651.         }
  1652.  
  1653.         if (page_id == ctx->composition_id || page_id == ctx->ancillary_id ||
  1654.             ctx->composition_id == -1 || ctx->ancillary_id == -1) {
  1655.             int ret = 0;
  1656.             switch (segment_type) {
  1657.             case DVBSUB_PAGE_SEGMENT:
  1658.                 ret = dvbsub_parse_page_segment(avctx, p, segment_length, sub, data_size);
  1659.                 got_segment |= 1;
  1660.                 break;
  1661.             case DVBSUB_REGION_SEGMENT:
  1662.                 ret = dvbsub_parse_region_segment(avctx, p, segment_length);
  1663.                 got_segment |= 2;
  1664.                 break;
  1665.             case DVBSUB_CLUT_SEGMENT:
  1666.                 ret = dvbsub_parse_clut_segment(avctx, p, segment_length);
  1667.                 if (ret < 0) goto end;
  1668.                 got_segment |= 4;
  1669.                 break;
  1670.             case DVBSUB_OBJECT_SEGMENT:
  1671.                 ret = dvbsub_parse_object_segment(avctx, p, segment_length);
  1672.                 got_segment |= 8;
  1673.                 break;
  1674.             case DVBSUB_DISPLAYDEFINITION_SEGMENT:
  1675.                 ret = dvbsub_parse_display_definition_segment(avctx, p,
  1676.                                                               segment_length);
  1677.                 got_dds = 1;
  1678.                 break;
  1679.             case DVBSUB_DISPLAY_SEGMENT:
  1680.                 ret = dvbsub_display_end_segment(avctx, p, segment_length, sub, data_size);
  1681.                 if (got_segment == 15 && !got_dds && !avctx->width && !avctx->height) {
  1682.                     // Default from ETSI EN 300 743 V1.3.1 (7.2.1)
  1683.                     avctx->width  = 720;
  1684.                     avctx->height = 576;
  1685.                 }
  1686.                 got_segment |= 16;
  1687.                 break;
  1688.             default:
  1689.                 ff_dlog(avctx, "Subtitling segment type 0x%x, page id %d, length %d\n",
  1690.                         segment_type, page_id, segment_length);
  1691.                 break;
  1692.             }
  1693.             if (ret < 0)
  1694.                 goto end;
  1695.         }
  1696.  
  1697.         p += segment_length;
  1698.     }
  1699.     // Some streams do not send a display segment but if we have all the other
  1700.     // segments then we need no further data.
  1701.     if (got_segment == 15) {
  1702.         av_log(avctx, AV_LOG_DEBUG, "Missing display_end_segment, emulating\n");
  1703.         dvbsub_display_end_segment(avctx, p, 0, sub, data_size);
  1704.     }
  1705.  
  1706. end:
  1707.     if(ret < 0) {
  1708.         *data_size = 0;
  1709.         avsubtitle_free(sub);
  1710.         return ret;
  1711.     } else {
  1712.         if(ctx->compute_edt == 1 )
  1713.             FFSWAP(int64_t, ctx->prev_start, sub->pts);
  1714.     }
  1715.  
  1716.     return p - buf;
  1717. }
  1718.  
  1719. #define DS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_SUBTITLE_PARAM
  1720. static const AVOption options[] = {
  1721.     {"compute_edt", "compute end of time using pts or timeout", offsetof(DVBSubContext, compute_edt), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, DS},
  1722.     {"compute_clut", "compute clut when not available(-1) or always(1) or never(0)", offsetof(DVBSubContext, compute_clut), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, DS},
  1723.     {"dvb_substream", "", offsetof(DVBSubContext, substream), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, DS},
  1724.     {NULL}
  1725. };
  1726. static const AVClass dvbsubdec_class = {
  1727.     .class_name = "DVB Sub Decoder",
  1728.     .item_name  = av_default_item_name,
  1729.     .option     = options,
  1730.     .version    = LIBAVUTIL_VERSION_INT,
  1731. };
  1732.  
  1733. AVCodec ff_dvbsub_decoder = {
  1734.     .name           = "dvbsub",
  1735.     .long_name      = NULL_IF_CONFIG_SMALL("DVB subtitles"),
  1736.     .type           = AVMEDIA_TYPE_SUBTITLE,
  1737.     .id             = AV_CODEC_ID_DVB_SUBTITLE,
  1738.     .priv_data_size = sizeof(DVBSubContext),
  1739.     .init           = dvbsub_init_decoder,
  1740.     .close          = dvbsub_close_decoder,
  1741.     .decode         = dvbsub_decode,
  1742.     .priv_class     = &dvbsubdec_class,
  1743. };
  1744.