Subversion Repositories Kolibri OS

Rev

Go to most recent revision | 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. #include "avcodec.h"
  22. #include "dsputil.h"
  23. #include "get_bits.h"
  24. #include "bytestream.h"
  25. #include "libavutil/colorspace.h"
  26.  
  27. #define DVBSUB_PAGE_SEGMENT     0x10
  28. #define DVBSUB_REGION_SEGMENT   0x11
  29. #define DVBSUB_CLUT_SEGMENT     0x12
  30. #define DVBSUB_OBJECT_SEGMENT   0x13
  31. #define DVBSUB_DISPLAYDEFINITION_SEGMENT 0x14
  32. #define DVBSUB_DISPLAY_SEGMENT  0x80
  33.  
  34. #define cm (ff_cropTbl + MAX_NEG_CROP)
  35.  
  36. #ifdef DEBUG
  37. #undef fprintf
  38. #undef perror
  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.     int composition_id;
  233.     int ancillary_id;
  234.  
  235.     int version;
  236.     int time_out;
  237.     DVBSubRegion *region_list;
  238.     DVBSubCLUT   *clut_list;
  239.     DVBSubObject *object_list;
  240.  
  241.     int display_list_size;
  242.     DVBSubRegionDisplay *display_list;
  243.     DVBSubDisplayDefinition *display_definition;
  244. } DVBSubContext;
  245.  
  246.  
  247. static DVBSubObject* get_object(DVBSubContext *ctx, int object_id)
  248. {
  249.     DVBSubObject *ptr = ctx->object_list;
  250.  
  251.     while (ptr && ptr->id != object_id) {
  252.         ptr = ptr->next;
  253.     }
  254.  
  255.     return ptr;
  256. }
  257.  
  258. static DVBSubCLUT* get_clut(DVBSubContext *ctx, int clut_id)
  259. {
  260.     DVBSubCLUT *ptr = ctx->clut_list;
  261.  
  262.     while (ptr && ptr->id != clut_id) {
  263.         ptr = ptr->next;
  264.     }
  265.  
  266.     return ptr;
  267. }
  268.  
  269. static DVBSubRegion* get_region(DVBSubContext *ctx, int region_id)
  270. {
  271.     DVBSubRegion *ptr = ctx->region_list;
  272.  
  273.     while (ptr && ptr->id != region_id) {
  274.         ptr = ptr->next;
  275.     }
  276.  
  277.     return ptr;
  278. }
  279.  
  280. static void delete_region_display_list(DVBSubContext *ctx, DVBSubRegion *region)
  281. {
  282.     DVBSubObject *object, *obj2, **obj2_ptr;
  283.     DVBSubObjectDisplay *display, *obj_disp, **obj_disp_ptr;
  284.  
  285.     while (region->display_list) {
  286.         display = region->display_list;
  287.  
  288.         object = get_object(ctx, display->object_id);
  289.  
  290.         if (object) {
  291.             obj_disp_ptr = &object->display_list;
  292.             obj_disp = *obj_disp_ptr;
  293.  
  294.             while (obj_disp && obj_disp != display) {
  295.                 obj_disp_ptr = &obj_disp->object_list_next;
  296.                 obj_disp = *obj_disp_ptr;
  297.             }
  298.  
  299.             if (obj_disp) {
  300.                 *obj_disp_ptr = obj_disp->object_list_next;
  301.  
  302.                 if (!object->display_list) {
  303.                     obj2_ptr = &ctx->object_list;
  304.                     obj2 = *obj2_ptr;
  305.  
  306.                     while (obj2 != object) {
  307.                         assert(obj2);
  308.                         obj2_ptr = &obj2->next;
  309.                         obj2 = *obj2_ptr;
  310.                     }
  311.  
  312.                     *obj2_ptr = obj2->next;
  313.  
  314.                     av_free(obj2);
  315.                 }
  316.             }
  317.         }
  318.  
  319.         region->display_list = display->region_list_next;
  320.  
  321.         av_free(display);
  322.     }
  323.  
  324. }
  325.  
  326. static void delete_cluts(DVBSubContext *ctx)
  327. {
  328.     DVBSubCLUT *clut;
  329.  
  330.     while (ctx->clut_list) {
  331.         clut = ctx->clut_list;
  332.  
  333.         ctx->clut_list = clut->next;
  334.  
  335.         av_free(clut);
  336.     }
  337. }
  338.  
  339. static void delete_objects(DVBSubContext *ctx)
  340. {
  341.     DVBSubObject *object;
  342.  
  343.     while (ctx->object_list) {
  344.         object = ctx->object_list;
  345.  
  346.         ctx->object_list = object->next;
  347.  
  348.         av_free(object);
  349.     }
  350. }
  351.  
  352. static void delete_regions(DVBSubContext *ctx)
  353. {
  354.     DVBSubRegion *region;
  355.  
  356.     while (ctx->region_list) {
  357.         region = ctx->region_list;
  358.  
  359.         ctx->region_list = region->next;
  360.  
  361.         delete_region_display_list(ctx, region);
  362.  
  363.         av_free(region->pbuf);
  364.         av_free(region);
  365.     }
  366. }
  367.  
  368. static av_cold int dvbsub_init_decoder(AVCodecContext *avctx)
  369. {
  370.     int i, r, g, b, a = 0;
  371.     DVBSubContext *ctx = avctx->priv_data;
  372.  
  373.     if (!avctx->extradata || avctx->extradata_size != 4) {
  374.         av_log(avctx, AV_LOG_WARNING, "Invalid extradata, subtitle streams may be combined!\n");
  375.         ctx->composition_id = -1;
  376.         ctx->ancillary_id   = -1;
  377.     } else {
  378.         ctx->composition_id = AV_RB16(avctx->extradata);
  379.         ctx->ancillary_id   = AV_RB16(avctx->extradata + 2);
  380.     }
  381.  
  382.     ctx->version = -1;
  383.  
  384.     default_clut.id = -1;
  385.     default_clut.next = NULL;
  386.  
  387.     default_clut.clut4[0] = RGBA(  0,   0,   0,   0);
  388.     default_clut.clut4[1] = RGBA(255, 255, 255, 255);
  389.     default_clut.clut4[2] = RGBA(  0,   0,   0, 255);
  390.     default_clut.clut4[3] = RGBA(127, 127, 127, 255);
  391.  
  392.     default_clut.clut16[0] = RGBA(  0,   0,   0,   0);
  393.     for (i = 1; i < 16; i++) {
  394.         if (i < 8) {
  395.             r = (i & 1) ? 255 : 0;
  396.             g = (i & 2) ? 255 : 0;
  397.             b = (i & 4) ? 255 : 0;
  398.         } else {
  399.             r = (i & 1) ? 127 : 0;
  400.             g = (i & 2) ? 127 : 0;
  401.             b = (i & 4) ? 127 : 0;
  402.         }
  403.         default_clut.clut16[i] = RGBA(r, g, b, 255);
  404.     }
  405.  
  406.     default_clut.clut256[0] = RGBA(  0,   0,   0,   0);
  407.     for (i = 1; i < 256; i++) {
  408.         if (i < 8) {
  409.             r = (i & 1) ? 255 : 0;
  410.             g = (i & 2) ? 255 : 0;
  411.             b = (i & 4) ? 255 : 0;
  412.             a = 63;
  413.         } else {
  414.             switch (i & 0x88) {
  415.             case 0x00:
  416.                 r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
  417.                 g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
  418.                 b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
  419.                 a = 255;
  420.                 break;
  421.             case 0x08:
  422.                 r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
  423.                 g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
  424.                 b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
  425.                 a = 127;
  426.                 break;
  427.             case 0x80:
  428.                 r = 127 + ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
  429.                 g = 127 + ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
  430.                 b = 127 + ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
  431.                 a = 255;
  432.                 break;
  433.             case 0x88:
  434.                 r = ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
  435.                 g = ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
  436.                 b = ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
  437.                 a = 255;
  438.                 break;
  439.             }
  440.         }
  441.         default_clut.clut256[i] = RGBA(r, g, b, a);
  442.     }
  443.  
  444.     return 0;
  445. }
  446.  
  447. static av_cold int dvbsub_close_decoder(AVCodecContext *avctx)
  448. {
  449.     DVBSubContext *ctx = avctx->priv_data;
  450.     DVBSubRegionDisplay *display;
  451.  
  452.     delete_regions(ctx);
  453.  
  454.     delete_objects(ctx);
  455.  
  456.     delete_cluts(ctx);
  457.  
  458.     av_freep(&ctx->display_definition);
  459.  
  460.     while (ctx->display_list) {
  461.         display = ctx->display_list;
  462.         ctx->display_list = display->next;
  463.  
  464.         av_free(display);
  465.     }
  466.  
  467.     return 0;
  468. }
  469.  
  470. static int dvbsub_read_2bit_string(uint8_t *destbuf, int dbuf_len,
  471.                                    const uint8_t **srcbuf, int buf_size,
  472.                                    int non_mod, uint8_t *map_table, int x_pos)
  473. {
  474.     GetBitContext gb;
  475.  
  476.     int bits;
  477.     int run_length;
  478.     int pixels_read = x_pos;
  479.  
  480.     init_get_bits(&gb, *srcbuf, buf_size << 3);
  481.  
  482.     destbuf += x_pos;
  483.  
  484.     while (get_bits_count(&gb) < buf_size << 3 && pixels_read < dbuf_len) {
  485.         bits = get_bits(&gb, 2);
  486.  
  487.         if (bits) {
  488.             if (non_mod != 1 || bits != 1) {
  489.                 if (map_table)
  490.                     *destbuf++ = map_table[bits];
  491.                 else
  492.                     *destbuf++ = bits;
  493.             }
  494.             pixels_read++;
  495.         } else {
  496.             bits = get_bits1(&gb);
  497.             if (bits == 1) {
  498.                 run_length = get_bits(&gb, 3) + 3;
  499.                 bits = get_bits(&gb, 2);
  500.  
  501.                 if (non_mod == 1 && bits == 1)
  502.                     pixels_read += run_length;
  503.                 else {
  504.                     if (map_table)
  505.                         bits = map_table[bits];
  506.                     while (run_length-- > 0 && pixels_read < dbuf_len) {
  507.                         *destbuf++ = bits;
  508.                         pixels_read++;
  509.                     }
  510.                 }
  511.             } else {
  512.                 bits = get_bits1(&gb);
  513.                 if (bits == 0) {
  514.                     bits = get_bits(&gb, 2);
  515.                     if (bits == 2) {
  516.                         run_length = get_bits(&gb, 4) + 12;
  517.                         bits = get_bits(&gb, 2);
  518.  
  519.                         if (non_mod == 1 && bits == 1)
  520.                             pixels_read += run_length;
  521.                         else {
  522.                             if (map_table)
  523.                                 bits = map_table[bits];
  524.                             while (run_length-- > 0 && pixels_read < dbuf_len) {
  525.                                 *destbuf++ = bits;
  526.                                 pixels_read++;
  527.                             }
  528.                         }
  529.                     } else if (bits == 3) {
  530.                         run_length = get_bits(&gb, 8) + 29;
  531.                         bits = get_bits(&gb, 2);
  532.  
  533.                         if (non_mod == 1 && bits == 1)
  534.                             pixels_read += run_length;
  535.                         else {
  536.                             if (map_table)
  537.                                 bits = map_table[bits];
  538.                             while (run_length-- > 0 && pixels_read < dbuf_len) {
  539.                                 *destbuf++ = bits;
  540.                                 pixels_read++;
  541.                             }
  542.                         }
  543.                     } else if (bits == 1) {
  544.                         if (map_table)
  545.                             bits = map_table[0];
  546.                         else
  547.                             bits = 0;
  548.                         run_length = 2;
  549.                         while (run_length-- > 0 && pixels_read < dbuf_len) {
  550.                             *destbuf++ = bits;
  551.                             pixels_read++;
  552.                         }
  553.                     } else {
  554.                         (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
  555.                         return pixels_read;
  556.                     }
  557.                 } else {
  558.                     if (map_table)
  559.                         bits = map_table[0];
  560.                     else
  561.                         bits = 0;
  562.                     *destbuf++ = bits;
  563.                     pixels_read++;
  564.                 }
  565.             }
  566.         }
  567.     }
  568.  
  569.     if (get_bits(&gb, 6))
  570.         av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
  571.  
  572.     (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
  573.  
  574.     return pixels_read;
  575. }
  576.  
  577. static int dvbsub_read_4bit_string(uint8_t *destbuf, int dbuf_len,
  578.                                    const uint8_t **srcbuf, int buf_size,
  579.                                    int non_mod, uint8_t *map_table, int x_pos)
  580. {
  581.     GetBitContext gb;
  582.  
  583.     int bits;
  584.     int run_length;
  585.     int pixels_read = x_pos;
  586.  
  587.     init_get_bits(&gb, *srcbuf, buf_size << 3);
  588.  
  589.     destbuf += x_pos;
  590.  
  591.     while (get_bits_count(&gb) < buf_size << 3 && pixels_read < dbuf_len) {
  592.         bits = get_bits(&gb, 4);
  593.  
  594.         if (bits) {
  595.             if (non_mod != 1 || bits != 1) {
  596.                 if (map_table)
  597.                     *destbuf++ = map_table[bits];
  598.                 else
  599.                     *destbuf++ = bits;
  600.             }
  601.             pixels_read++;
  602.         } else {
  603.             bits = get_bits1(&gb);
  604.             if (bits == 0) {
  605.                 run_length = get_bits(&gb, 3);
  606.  
  607.                 if (run_length == 0) {
  608.                     (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
  609.                     return pixels_read;
  610.                 }
  611.  
  612.                 run_length += 2;
  613.  
  614.                 if (map_table)
  615.                     bits = map_table[0];
  616.                 else
  617.                     bits = 0;
  618.  
  619.                 while (run_length-- > 0 && pixels_read < dbuf_len) {
  620.                     *destbuf++ = bits;
  621.                     pixels_read++;
  622.                 }
  623.             } else {
  624.                 bits = get_bits1(&gb);
  625.                 if (bits == 0) {
  626.                     run_length = get_bits(&gb, 2) + 4;
  627.                     bits = get_bits(&gb, 4);
  628.  
  629.                     if (non_mod == 1 && bits == 1)
  630.                         pixels_read += run_length;
  631.                     else {
  632.                         if (map_table)
  633.                             bits = map_table[bits];
  634.                         while (run_length-- > 0 && pixels_read < dbuf_len) {
  635.                             *destbuf++ = bits;
  636.                             pixels_read++;
  637.                         }
  638.                     }
  639.                 } else {
  640.                     bits = get_bits(&gb, 2);
  641.                     if (bits == 2) {
  642.                         run_length = get_bits(&gb, 4) + 9;
  643.                         bits = get_bits(&gb, 4);
  644.  
  645.                         if (non_mod == 1 && bits == 1)
  646.                             pixels_read += run_length;
  647.                         else {
  648.                             if (map_table)
  649.                                 bits = map_table[bits];
  650.                             while (run_length-- > 0 && pixels_read < dbuf_len) {
  651.                                 *destbuf++ = bits;
  652.                                 pixels_read++;
  653.                             }
  654.                         }
  655.                     } else if (bits == 3) {
  656.                         run_length = get_bits(&gb, 8) + 25;
  657.                         bits = get_bits(&gb, 4);
  658.  
  659.                         if (non_mod == 1 && bits == 1)
  660.                             pixels_read += run_length;
  661.                         else {
  662.                             if (map_table)
  663.                                 bits = map_table[bits];
  664.                             while (run_length-- > 0 && pixels_read < dbuf_len) {
  665.                                 *destbuf++ = bits;
  666.                                 pixels_read++;
  667.                             }
  668.                         }
  669.                     } else if (bits == 1) {
  670.                         if (map_table)
  671.                             bits = map_table[0];
  672.                         else
  673.                             bits = 0;
  674.                         run_length = 2;
  675.                         while (run_length-- > 0 && pixels_read < dbuf_len) {
  676.                             *destbuf++ = bits;
  677.                             pixels_read++;
  678.                         }
  679.                     } else {
  680.                         if (map_table)
  681.                             bits = map_table[0];
  682.                         else
  683.                             bits = 0;
  684.                         *destbuf++ = bits;
  685.                         pixels_read ++;
  686.                     }
  687.                 }
  688.             }
  689.         }
  690.     }
  691.  
  692.     if (get_bits(&gb, 8))
  693.         av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
  694.  
  695.     (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
  696.  
  697.     return pixels_read;
  698. }
  699.  
  700. static int dvbsub_read_8bit_string(uint8_t *destbuf, int dbuf_len,
  701.                                     const uint8_t **srcbuf, int buf_size,
  702.                                     int non_mod, uint8_t *map_table, int x_pos)
  703. {
  704.     const uint8_t *sbuf_end = (*srcbuf) + buf_size;
  705.     int bits;
  706.     int run_length;
  707.     int pixels_read = x_pos;
  708.  
  709.     destbuf += x_pos;
  710.  
  711.     while (*srcbuf < sbuf_end && pixels_read < dbuf_len) {
  712.         bits = *(*srcbuf)++;
  713.  
  714.         if (bits) {
  715.             if (non_mod != 1 || bits != 1) {
  716.                 if (map_table)
  717.                     *destbuf++ = map_table[bits];
  718.                 else
  719.                     *destbuf++ = bits;
  720.             }
  721.             pixels_read++;
  722.         } else {
  723.             bits = *(*srcbuf)++;
  724.             run_length = bits & 0x7f;
  725.             if ((bits & 0x80) == 0) {
  726.                 if (run_length == 0) {
  727.                     return pixels_read;
  728.                 }
  729.  
  730.                 if (map_table)
  731.                     bits = map_table[0];
  732.                 else
  733.                     bits = 0;
  734.                 while (run_length-- > 0 && pixels_read < dbuf_len) {
  735.                     *destbuf++ = bits;
  736.                     pixels_read++;
  737.                 }
  738.             } else {
  739.                 bits = *(*srcbuf)++;
  740.  
  741.                 if (non_mod == 1 && bits == 1)
  742.                     pixels_read += run_length;
  743.                 if (map_table)
  744.                     bits = map_table[bits];
  745.                 else while (run_length-- > 0 && pixels_read < dbuf_len) {
  746.                     *destbuf++ = bits;
  747.                     pixels_read++;
  748.                 }
  749.             }
  750.         }
  751.     }
  752.  
  753.     if (*(*srcbuf)++)
  754.         av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
  755.  
  756.     return pixels_read;
  757. }
  758.  
  759.  
  760.  
  761. static void dvbsub_parse_pixel_data_block(AVCodecContext *avctx, DVBSubObjectDisplay *display,
  762.                                           const uint8_t *buf, int buf_size, int top_bottom, int non_mod)
  763. {
  764.     DVBSubContext *ctx = avctx->priv_data;
  765.  
  766.     DVBSubRegion *region = get_region(ctx, display->region_id);
  767.     const uint8_t *buf_end = buf + buf_size;
  768.     uint8_t *pbuf;
  769.     int x_pos, y_pos;
  770.     int i;
  771.  
  772.     uint8_t map2to4[] = { 0x0,  0x7,  0x8,  0xf};
  773.     uint8_t map2to8[] = {0x00, 0x77, 0x88, 0xff};
  774.     uint8_t map4to8[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
  775.                          0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
  776.     uint8_t *map_table;
  777.  
  778. #if 0
  779.     av_dlog(avctx, "DVB pixel block size %d, %s field:\n", buf_size,
  780.             top_bottom ? "bottom" : "top");
  781.  
  782.     for (i = 0; i < buf_size; i++) {
  783.         if (i % 16 == 0)
  784.             av_dlog(avctx, "0x%8p: ", buf+i);
  785.  
  786.         av_dlog(avctx, "%02x ", buf[i]);
  787.         if (i % 16 == 15)
  788.             av_dlog(avctx, "\n");
  789.     }
  790.  
  791.     if (i % 16)
  792.         av_dlog(avctx, "\n");
  793. #endif
  794.  
  795.     if (region == 0)
  796.         return;
  797.  
  798.     pbuf = region->pbuf;
  799.     region->dirty = 1;
  800.  
  801.     x_pos = display->x_pos;
  802.     y_pos = display->y_pos;
  803.  
  804.     y_pos += top_bottom;
  805.  
  806.     while (buf < buf_end) {
  807.         if ((*buf!=0xf0 && x_pos >= region->width) || y_pos >= region->height) {
  808.             av_log(avctx, AV_LOG_ERROR, "Invalid object location! %d-%d %d-%d %02x\n", x_pos, region->width, y_pos, region->height, *buf);
  809.             return;
  810.         }
  811.  
  812.         switch (*buf++) {
  813.         case 0x10:
  814.             if (region->depth == 8)
  815.                 map_table = map2to8;
  816.             else if (region->depth == 4)
  817.                 map_table = map2to4;
  818.             else
  819.                 map_table = NULL;
  820.  
  821.             x_pos = dvbsub_read_2bit_string(pbuf + (y_pos * region->width),
  822.                                             region->width, &buf, buf_end - buf,
  823.                                             non_mod, map_table, x_pos);
  824.             break;
  825.         case 0x11:
  826.             if (region->depth < 4) {
  827.                 av_log(avctx, AV_LOG_ERROR, "4-bit pixel string in %d-bit region!\n", region->depth);
  828.                 return;
  829.             }
  830.  
  831.             if (region->depth == 8)
  832.                 map_table = map4to8;
  833.             else
  834.                 map_table = NULL;
  835.  
  836.             x_pos = dvbsub_read_4bit_string(pbuf + (y_pos * region->width),
  837.                                             region->width, &buf, buf_end - buf,
  838.                                             non_mod, map_table, x_pos);
  839.             break;
  840.         case 0x12:
  841.             if (region->depth < 8) {
  842.                 av_log(avctx, AV_LOG_ERROR, "8-bit pixel string in %d-bit region!\n", region->depth);
  843.                 return;
  844.             }
  845.  
  846.             x_pos = dvbsub_read_8bit_string(pbuf + (y_pos * region->width),
  847.                                             region->width, &buf, buf_end - buf,
  848.                                             non_mod, NULL, x_pos);
  849.             break;
  850.  
  851.         case 0x20:
  852.             map2to4[0] = (*buf) >> 4;
  853.             map2to4[1] = (*buf++) & 0xf;
  854.             map2to4[2] = (*buf) >> 4;
  855.             map2to4[3] = (*buf++) & 0xf;
  856.             break;
  857.         case 0x21:
  858.             for (i = 0; i < 4; i++)
  859.                 map2to8[i] = *buf++;
  860.             break;
  861.         case 0x22:
  862.             for (i = 0; i < 16; i++)
  863.                 map4to8[i] = *buf++;
  864.             break;
  865.  
  866.         case 0xf0:
  867.             x_pos = display->x_pos;
  868.             y_pos += 2;
  869.             break;
  870.         default:
  871.             av_log(avctx, AV_LOG_INFO, "Unknown/unsupported pixel block 0x%x\n", *(buf-1));
  872.         }
  873.     }
  874.  
  875. }
  876.  
  877. static void dvbsub_parse_object_segment(AVCodecContext *avctx,
  878.                                         const uint8_t *buf, int buf_size)
  879. {
  880.     DVBSubContext *ctx = avctx->priv_data;
  881.  
  882.     const uint8_t *buf_end = buf + buf_size;
  883.     int object_id;
  884.     DVBSubObject *object;
  885.     DVBSubObjectDisplay *display;
  886.     int top_field_len, bottom_field_len;
  887.  
  888.     int coding_method, non_modifying_color;
  889.  
  890.     object_id = AV_RB16(buf);
  891.     buf += 2;
  892.  
  893.     object = get_object(ctx, object_id);
  894.  
  895.     if (!object)
  896.         return;
  897.  
  898.     coding_method = ((*buf) >> 2) & 3;
  899.     non_modifying_color = ((*buf++) >> 1) & 1;
  900.  
  901.     if (coding_method == 0) {
  902.         top_field_len = AV_RB16(buf);
  903.         buf += 2;
  904.         bottom_field_len = AV_RB16(buf);
  905.         buf += 2;
  906.  
  907.         if (buf + top_field_len + bottom_field_len > buf_end) {
  908.             av_log(avctx, AV_LOG_ERROR, "Field data size too large\n");
  909.             return;
  910.         }
  911.  
  912.         for (display = object->display_list; display; display = display->object_list_next) {
  913.             const uint8_t *block = buf;
  914.             int bfl = bottom_field_len;
  915.  
  916.             dvbsub_parse_pixel_data_block(avctx, display, block, top_field_len, 0,
  917.                                             non_modifying_color);
  918.  
  919.             if (bottom_field_len > 0)
  920.                 block = buf + top_field_len;
  921.             else
  922.                 bfl = top_field_len;
  923.  
  924.             dvbsub_parse_pixel_data_block(avctx, display, block, bfl, 1,
  925.                                             non_modifying_color);
  926.         }
  927.  
  928. /*  } else if (coding_method == 1) {*/
  929.  
  930.     } else {
  931.         av_log(avctx, AV_LOG_ERROR, "Unknown object coding %d\n", coding_method);
  932.     }
  933.  
  934. }
  935.  
  936. static int dvbsub_parse_clut_segment(AVCodecContext *avctx,
  937.                                         const uint8_t *buf, int buf_size)
  938. {
  939.     DVBSubContext *ctx = avctx->priv_data;
  940.  
  941.     const uint8_t *buf_end = buf + buf_size;
  942.     int i, clut_id;
  943.     int version;
  944.     DVBSubCLUT *clut;
  945.     int entry_id, depth , full_range;
  946.     int y, cr, cb, alpha;
  947.     int r, g, b, r_add, g_add, b_add;
  948.  
  949.     av_dlog(avctx, "DVB clut packet:\n");
  950.  
  951.     for (i=0; i < buf_size; i++) {
  952.         av_dlog(avctx, "%02x ", buf[i]);
  953.         if (i % 16 == 15)
  954.             av_dlog(avctx, "\n");
  955.     }
  956.  
  957.     if (i % 16)
  958.         av_dlog(avctx, "\n");
  959.  
  960.     clut_id = *buf++;
  961.     version = ((*buf)>>4)&15;
  962.     buf += 1;
  963.  
  964.     clut = get_clut(ctx, clut_id);
  965.  
  966.     if (!clut) {
  967.         clut = av_malloc(sizeof(DVBSubCLUT));
  968.  
  969.         memcpy(clut, &default_clut, sizeof(DVBSubCLUT));
  970.  
  971.         clut->id = clut_id;
  972.         clut->version = -1;
  973.  
  974.         clut->next = ctx->clut_list;
  975.         ctx->clut_list = clut;
  976.     }
  977.  
  978.     if (clut->version != version) {
  979.  
  980.     clut->version = version;
  981.  
  982.     while (buf + 4 < buf_end) {
  983.         entry_id = *buf++;
  984.  
  985.         depth = (*buf) & 0xe0;
  986.  
  987.         if (depth == 0) {
  988.             av_log(avctx, AV_LOG_ERROR, "Invalid clut depth 0x%x!\n", *buf);
  989.             return 0;
  990.         }
  991.  
  992.         full_range = (*buf++) & 1;
  993.  
  994.         if (full_range) {
  995.             y = *buf++;
  996.             cr = *buf++;
  997.             cb = *buf++;
  998.             alpha = *buf++;
  999.         } else {
  1000.             y = buf[0] & 0xfc;
  1001.             cr = (((buf[0] & 3) << 2) | ((buf[1] >> 6) & 3)) << 4;
  1002.             cb = (buf[1] << 2) & 0xf0;
  1003.             alpha = (buf[1] << 6) & 0xc0;
  1004.  
  1005.             buf += 2;
  1006.         }
  1007.  
  1008.         if (y == 0)
  1009.             alpha = 0xff;
  1010.  
  1011.         YUV_TO_RGB1_CCIR(cb, cr);
  1012.         YUV_TO_RGB2_CCIR(r, g, b, y);
  1013.  
  1014.         av_dlog(avctx, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);
  1015.         if (!!(depth & 0x80) + !!(depth & 0x40) + !!(depth & 0x20) > 1) {
  1016.             av_dlog(avctx, "More than one bit level marked: %x\n", depth);
  1017.             if (avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL)
  1018.                 return AVERROR_INVALIDDATA;
  1019.         }
  1020.  
  1021.         if (depth & 0x80)
  1022.             clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha);
  1023.         else if (depth & 0x40)
  1024.             clut->clut16[entry_id] = RGBA(r,g,b,255 - alpha);
  1025.         else if (depth & 0x20)
  1026.             clut->clut256[entry_id] = RGBA(r,g,b,255 - alpha);
  1027.     }
  1028.     }
  1029.     return 0;
  1030. }
  1031.  
  1032.  
  1033. static void dvbsub_parse_region_segment(AVCodecContext *avctx,
  1034.                                         const uint8_t *buf, int buf_size)
  1035. {
  1036.     DVBSubContext *ctx = avctx->priv_data;
  1037.  
  1038.     const uint8_t *buf_end = buf + buf_size;
  1039.     int region_id, object_id;
  1040.     int av_unused version;
  1041.     DVBSubRegion *region;
  1042.     DVBSubObject *object;
  1043.     DVBSubObjectDisplay *display;
  1044.     int fill;
  1045.  
  1046.     if (buf_size < 10)
  1047.         return;
  1048.  
  1049.     region_id = *buf++;
  1050.  
  1051.     region = get_region(ctx, region_id);
  1052.  
  1053.     if (!region) {
  1054.         region = av_mallocz(sizeof(DVBSubRegion));
  1055.  
  1056.         region->id = region_id;
  1057.         region->version = -1;
  1058.  
  1059.         region->next = ctx->region_list;
  1060.         ctx->region_list = region;
  1061.     }
  1062.  
  1063.     version = ((*buf)>>4) & 15;
  1064.     fill = ((*buf++) >> 3) & 1;
  1065.  
  1066.     region->width = AV_RB16(buf);
  1067.     buf += 2;
  1068.     region->height = AV_RB16(buf);
  1069.     buf += 2;
  1070.  
  1071.     if (region->width * region->height != region->buf_size) {
  1072.         av_free(region->pbuf);
  1073.  
  1074.         region->buf_size = region->width * region->height;
  1075.  
  1076.         region->pbuf = av_malloc(region->buf_size);
  1077.  
  1078.         fill = 1;
  1079.         region->dirty = 0;
  1080.     }
  1081.  
  1082.     region->depth = 1 << (((*buf++) >> 2) & 7);
  1083.     if(region->depth<2 || region->depth>8){
  1084.         av_log(avctx, AV_LOG_ERROR, "region depth %d is invalid\n", region->depth);
  1085.         region->depth= 4;
  1086.     }
  1087.     region->clut = *buf++;
  1088.  
  1089.     if (region->depth == 8) {
  1090.         region->bgcolor = *buf++;
  1091.         buf += 1;
  1092.     } else {
  1093.         buf += 1;
  1094.  
  1095.         if (region->depth == 4)
  1096.             region->bgcolor = (((*buf++) >> 4) & 15);
  1097.         else
  1098.             region->bgcolor = (((*buf++) >> 2) & 3);
  1099.     }
  1100.  
  1101.     av_dlog(avctx, "Region %d, (%dx%d)\n", region_id, region->width, region->height);
  1102.  
  1103.     if (fill) {
  1104.         memset(region->pbuf, region->bgcolor, region->buf_size);
  1105.         av_dlog(avctx, "Fill region (%d)\n", region->bgcolor);
  1106.     }
  1107.  
  1108.     delete_region_display_list(ctx, region);
  1109.  
  1110.     while (buf + 5 < buf_end) {
  1111.         object_id = AV_RB16(buf);
  1112.         buf += 2;
  1113.  
  1114.         object = get_object(ctx, object_id);
  1115.  
  1116.         if (!object) {
  1117.             object = av_mallocz(sizeof(DVBSubObject));
  1118.  
  1119.             object->id = object_id;
  1120.             object->next = ctx->object_list;
  1121.             ctx->object_list = object;
  1122.         }
  1123.  
  1124.         object->type = (*buf) >> 6;
  1125.  
  1126.         display = av_mallocz(sizeof(DVBSubObjectDisplay));
  1127.  
  1128.         display->object_id = object_id;
  1129.         display->region_id = region_id;
  1130.  
  1131.         display->x_pos = AV_RB16(buf) & 0xfff;
  1132.         buf += 2;
  1133.         display->y_pos = AV_RB16(buf) & 0xfff;
  1134.         buf += 2;
  1135.  
  1136.         if ((object->type == 1 || object->type == 2) && buf+1 < buf_end) {
  1137.             display->fgcolor = *buf++;
  1138.             display->bgcolor = *buf++;
  1139.         }
  1140.  
  1141.         display->region_list_next = region->display_list;
  1142.         region->display_list = display;
  1143.  
  1144.         display->object_list_next = object->display_list;
  1145.         object->display_list = display;
  1146.     }
  1147. }
  1148.  
  1149. static void dvbsub_parse_page_segment(AVCodecContext *avctx,
  1150.                                         const uint8_t *buf, int buf_size)
  1151. {
  1152.     DVBSubContext *ctx = avctx->priv_data;
  1153.     DVBSubRegionDisplay *display;
  1154.     DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;
  1155.  
  1156.     const uint8_t *buf_end = buf + buf_size;
  1157.     int region_id;
  1158.     int page_state;
  1159.     int timeout;
  1160.     int version;
  1161.  
  1162.     if (buf_size < 1)
  1163.         return;
  1164.  
  1165.     timeout = *buf++;
  1166.     version = ((*buf)>>4) & 15;
  1167.     page_state = ((*buf++) >> 2) & 3;
  1168.  
  1169.     if (ctx->version != version) {
  1170.  
  1171.     ctx->time_out = timeout;
  1172.     ctx->version = version;
  1173.  
  1174.     av_dlog(avctx, "Page time out %ds, state %d\n", ctx->time_out, page_state);
  1175.  
  1176.     if (page_state == 1 || page_state == 2) {
  1177.         delete_regions(ctx);
  1178.         delete_objects(ctx);
  1179.         delete_cluts(ctx);
  1180.     }
  1181.  
  1182.     tmp_display_list = ctx->display_list;
  1183.     ctx->display_list = NULL;
  1184.     ctx->display_list_size = 0;
  1185.  
  1186.     while (buf + 5 < buf_end) {
  1187.         region_id = *buf++;
  1188.         buf += 1;
  1189.  
  1190.         display = tmp_display_list;
  1191.         tmp_ptr = &tmp_display_list;
  1192.  
  1193.         while (display && display->region_id != region_id) {
  1194.             tmp_ptr = &display->next;
  1195.             display = display->next;
  1196.         }
  1197.  
  1198.         if (!display)
  1199.             display = av_mallocz(sizeof(DVBSubRegionDisplay));
  1200.  
  1201.         display->region_id = region_id;
  1202.  
  1203.         display->x_pos = AV_RB16(buf);
  1204.         buf += 2;
  1205.         display->y_pos = AV_RB16(buf);
  1206.         buf += 2;
  1207.  
  1208.         *tmp_ptr = display->next;
  1209.  
  1210.         display->next = ctx->display_list;
  1211.         ctx->display_list = display;
  1212.         ctx->display_list_size++;
  1213.  
  1214.         av_dlog(avctx, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
  1215.     }
  1216.  
  1217.     while (tmp_display_list) {
  1218.         display = tmp_display_list;
  1219.  
  1220.         tmp_display_list = display->next;
  1221.  
  1222.         av_free(display);
  1223.     }
  1224.     }
  1225.  
  1226. }
  1227.  
  1228.  
  1229. #ifdef DEBUG
  1230. static void save_display_set(DVBSubContext *ctx)
  1231. {
  1232.     DVBSubRegion *region;
  1233.     DVBSubRegionDisplay *display;
  1234.     DVBSubCLUT *clut;
  1235.     uint32_t *clut_table;
  1236.     int x_pos, y_pos, width, height;
  1237.     int x, y, y_off, x_off;
  1238.     uint32_t *pbuf;
  1239.     char filename[32];
  1240.     static int fileno_index = 0;
  1241.  
  1242.     x_pos = -1;
  1243.     y_pos = -1;
  1244.     width = 0;
  1245.     height = 0;
  1246.  
  1247.     for (display = ctx->display_list; display; display = display->next) {
  1248.         region = get_region(ctx, display->region_id);
  1249.  
  1250.         if (x_pos == -1) {
  1251.             x_pos = display->x_pos;
  1252.             y_pos = display->y_pos;
  1253.             width = region->width;
  1254.             height = region->height;
  1255.         } else {
  1256.             if (display->x_pos < x_pos) {
  1257.                 width += (x_pos - display->x_pos);
  1258.                 x_pos = display->x_pos;
  1259.             }
  1260.  
  1261.             if (display->y_pos < y_pos) {
  1262.                 height += (y_pos - display->y_pos);
  1263.                 y_pos = display->y_pos;
  1264.             }
  1265.  
  1266.             if (display->x_pos + region->width > x_pos + width) {
  1267.                 width = display->x_pos + region->width - x_pos;
  1268.             }
  1269.  
  1270.             if (display->y_pos + region->height > y_pos + height) {
  1271.                 height = display->y_pos + region->height - y_pos;
  1272.             }
  1273.         }
  1274.     }
  1275.  
  1276.     if (x_pos >= 0) {
  1277.  
  1278.         pbuf = av_malloc(width * height * 4);
  1279.  
  1280.         for (display = ctx->display_list; display; display = display->next) {
  1281.             region = get_region(ctx, display->region_id);
  1282.  
  1283.             x_off = display->x_pos - x_pos;
  1284.             y_off = display->y_pos - y_pos;
  1285.  
  1286.             clut = get_clut(ctx, region->clut);
  1287.  
  1288.             if (clut == 0)
  1289.                 clut = &default_clut;
  1290.  
  1291.             switch (region->depth) {
  1292.             case 2:
  1293.                 clut_table = clut->clut4;
  1294.                 break;
  1295.             case 8:
  1296.                 clut_table = clut->clut256;
  1297.                 break;
  1298.             case 4:
  1299.             default:
  1300.                 clut_table = clut->clut16;
  1301.                 break;
  1302.             }
  1303.  
  1304.             for (y = 0; y < region->height; y++) {
  1305.                 for (x = 0; x < region->width; x++) {
  1306.                     pbuf[((y + y_off) * width) + x_off + x] =
  1307.                         clut_table[region->pbuf[y * region->width + x]];
  1308.                 }
  1309.             }
  1310.  
  1311.         }
  1312.  
  1313.         snprintf(filename, sizeof(filename), "dvbs.%d", fileno_index);
  1314.  
  1315.         png_save2(filename, pbuf, width, height);
  1316.  
  1317.         av_free(pbuf);
  1318.     }
  1319.  
  1320.     fileno_index++;
  1321. }
  1322. #endif
  1323.  
  1324. static void dvbsub_parse_display_definition_segment(AVCodecContext *avctx,
  1325.                                                     const uint8_t *buf,
  1326.                                                     int buf_size)
  1327. {
  1328.     DVBSubContext *ctx = avctx->priv_data;
  1329.     DVBSubDisplayDefinition *display_def = ctx->display_definition;
  1330.     int dds_version, info_byte;
  1331.  
  1332.     if (buf_size < 5)
  1333.         return;
  1334.  
  1335.     info_byte   = bytestream_get_byte(&buf);
  1336.     dds_version = info_byte >> 4;
  1337.     if (display_def && display_def->version == dds_version)
  1338.         return; // already have this display definition version
  1339.  
  1340.     if (!display_def) {
  1341.         display_def             = av_mallocz(sizeof(*display_def));
  1342.         ctx->display_definition = display_def;
  1343.     }
  1344.     if (!display_def)
  1345.         return;
  1346.  
  1347.     display_def->version = dds_version;
  1348.     display_def->x       = 0;
  1349.     display_def->y       = 0;
  1350.     display_def->width   = bytestream_get_be16(&buf) + 1;
  1351.     display_def->height  = bytestream_get_be16(&buf) + 1;
  1352.     if (!avctx->width || !avctx->height) {
  1353.         avctx->width  = display_def->width;
  1354.         avctx->height = display_def->height;
  1355.     }
  1356.  
  1357.     if (buf_size < 13)
  1358.         return;
  1359.  
  1360.     if (info_byte & 1<<3) { // display_window_flag
  1361.         display_def->x = bytestream_get_be16(&buf);
  1362.         display_def->y = bytestream_get_be16(&buf);
  1363.         display_def->width  = bytestream_get_be16(&buf) - display_def->x + 1;
  1364.         display_def->height = bytestream_get_be16(&buf) - display_def->y + 1;
  1365.     }
  1366. }
  1367.  
  1368. static int dvbsub_display_end_segment(AVCodecContext *avctx, const uint8_t *buf,
  1369.                                         int buf_size, AVSubtitle *sub)
  1370. {
  1371.     DVBSubContext *ctx = avctx->priv_data;
  1372.     DVBSubDisplayDefinition *display_def = ctx->display_definition;
  1373.  
  1374.     DVBSubRegion *region;
  1375.     DVBSubRegionDisplay *display;
  1376.     AVSubtitleRect *rect;
  1377.     DVBSubCLUT *clut;
  1378.     uint32_t *clut_table;
  1379.     int i;
  1380.     int offset_x=0, offset_y=0;
  1381.  
  1382.     sub->end_display_time = ctx->time_out * 1000;
  1383.  
  1384.     if (display_def) {
  1385.         offset_x = display_def->x;
  1386.         offset_y = display_def->y;
  1387.     }
  1388.  
  1389.     sub->num_rects = ctx->display_list_size;
  1390.  
  1391.     if (sub->num_rects > 0){
  1392.         sub->rects = av_mallocz(sizeof(*sub->rects) * sub->num_rects);
  1393.         for(i=0; i<sub->num_rects; i++)
  1394.             sub->rects[i] = av_mallocz(sizeof(*sub->rects[i]));
  1395.  
  1396.     i = 0;
  1397.  
  1398.     for (display = ctx->display_list; display; display = display->next) {
  1399.         region = get_region(ctx, display->region_id);
  1400.  
  1401.         if (!region)
  1402.             continue;
  1403.  
  1404.         if (!region->dirty)
  1405.             continue;
  1406.  
  1407.         rect = sub->rects[i];
  1408.         rect->x = display->x_pos + offset_x;
  1409.         rect->y = display->y_pos + offset_y;
  1410.         rect->w = region->width;
  1411.         rect->h = region->height;
  1412.         rect->nb_colors = (1 << region->depth);
  1413.         rect->type      = SUBTITLE_BITMAP;
  1414.         rect->pict.linesize[0] = region->width;
  1415.  
  1416.         clut = get_clut(ctx, region->clut);
  1417.  
  1418.         if (!clut)
  1419.             clut = &default_clut;
  1420.  
  1421.         switch (region->depth) {
  1422.         case 2:
  1423.             clut_table = clut->clut4;
  1424.             break;
  1425.         case 8:
  1426.             clut_table = clut->clut256;
  1427.             break;
  1428.         case 4:
  1429.         default:
  1430.             clut_table = clut->clut16;
  1431.             break;
  1432.         }
  1433.  
  1434.         rect->pict.data[1] = av_mallocz(AVPALETTE_SIZE);
  1435.         memcpy(rect->pict.data[1], clut_table, (1 << region->depth) * sizeof(uint32_t));
  1436.  
  1437.         rect->pict.data[0] = av_malloc(region->buf_size);
  1438.         memcpy(rect->pict.data[0], region->pbuf, region->buf_size);
  1439.  
  1440.         i++;
  1441.     }
  1442.  
  1443.     sub->num_rects = i;
  1444.     }
  1445. #ifdef DEBUG
  1446.     save_display_set(ctx);
  1447. #endif
  1448.  
  1449.     return 1;
  1450. }
  1451.  
  1452. static int dvbsub_decode(AVCodecContext *avctx,
  1453.                          void *data, int *data_size,
  1454.                          AVPacket *avpkt)
  1455. {
  1456.     const uint8_t *buf = avpkt->data;
  1457.     int buf_size = avpkt->size;
  1458.     DVBSubContext *ctx = avctx->priv_data;
  1459.     AVSubtitle *sub = data;
  1460.     const uint8_t *p, *p_end;
  1461.     int segment_type;
  1462.     int page_id;
  1463.     int segment_length;
  1464.     int i;
  1465.     int ret;
  1466.     int got_segment = 0;
  1467.  
  1468.     av_dlog(avctx, "DVB sub packet:\n");
  1469.  
  1470.     for (i=0; i < buf_size; i++) {
  1471.         av_dlog(avctx, "%02x ", buf[i]);
  1472.         if (i % 16 == 15)
  1473.             av_dlog(avctx, "\n");
  1474.     }
  1475.  
  1476.     if (i % 16)
  1477.         av_dlog(avctx, "\n");
  1478.  
  1479.     if (buf_size <= 6 || *buf != 0x0f) {
  1480.         av_dlog(avctx, "incomplete or broken packet");
  1481.         return -1;
  1482.     }
  1483.  
  1484.     p = buf;
  1485.     p_end = buf + buf_size;
  1486.  
  1487.     while (p_end - p >= 6 && *p == 0x0f) {
  1488.         p += 1;
  1489.         segment_type = *p++;
  1490.         page_id = AV_RB16(p);
  1491.         p += 2;
  1492.         segment_length = AV_RB16(p);
  1493.         p += 2;
  1494.  
  1495.         if (p_end - p < segment_length) {
  1496.             av_dlog(avctx, "incomplete or broken packet");
  1497.             return -1;
  1498.         }
  1499.  
  1500.         if (page_id == ctx->composition_id || page_id == ctx->ancillary_id ||
  1501.             ctx->composition_id == -1 || ctx->ancillary_id == -1) {
  1502.             switch (segment_type) {
  1503.             case DVBSUB_PAGE_SEGMENT:
  1504.                 dvbsub_parse_page_segment(avctx, p, segment_length);
  1505.                 got_segment |= 1;
  1506.                 break;
  1507.             case DVBSUB_REGION_SEGMENT:
  1508.                 dvbsub_parse_region_segment(avctx, p, segment_length);
  1509.                 got_segment |= 2;
  1510.                 break;
  1511.             case DVBSUB_CLUT_SEGMENT:
  1512.                 ret = dvbsub_parse_clut_segment(avctx, p, segment_length);
  1513.                 if (ret < 0) return ret;
  1514.                 got_segment |= 4;
  1515.                 break;
  1516.             case DVBSUB_OBJECT_SEGMENT:
  1517.                 dvbsub_parse_object_segment(avctx, p, segment_length);
  1518.                 got_segment |= 8;
  1519.                 break;
  1520.             case DVBSUB_DISPLAYDEFINITION_SEGMENT:
  1521.                 dvbsub_parse_display_definition_segment(avctx, p, segment_length);
  1522.                 break;
  1523.             case DVBSUB_DISPLAY_SEGMENT:
  1524.                 *data_size = dvbsub_display_end_segment(avctx, p, segment_length, sub);
  1525.                 got_segment |= 16;
  1526.                 break;
  1527.             default:
  1528.                 av_dlog(avctx, "Subtitling segment type 0x%x, page id %d, length %d\n",
  1529.                         segment_type, page_id, segment_length);
  1530.                 break;
  1531.             }
  1532.         }
  1533.  
  1534.         p += segment_length;
  1535.     }
  1536.     // Some streams do not send a display segment but if we have all the other
  1537.     // segments then we need no further data.
  1538.     if (got_segment == 15 && sub)
  1539.         *data_size = dvbsub_display_end_segment(avctx, p, 0, sub);
  1540.  
  1541.     return p - buf;
  1542. }
  1543.  
  1544.  
  1545. AVCodec ff_dvbsub_decoder = {
  1546.     .name           = "dvbsub",
  1547.     .long_name      = NULL_IF_CONFIG_SMALL("DVB subtitles"),
  1548.     .type           = AVMEDIA_TYPE_SUBTITLE,
  1549.     .id             = AV_CODEC_ID_DVB_SUBTITLE,
  1550.     .priv_data_size = sizeof(DVBSubContext),
  1551.     .init           = dvbsub_init_decoder,
  1552.     .close          = dvbsub_close_decoder,
  1553.     .decode         = dvbsub_decode,
  1554. };
  1555.