falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
85166 Commits
32 Branches
979MB
Tree: 9f7ba0ac9d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9f7ba0ac9d'
${ noResults }
FFmpeg/libavcodec/dvbsubdec.c

1705 lines
48KB
Raw Blame History 

  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. static void png_save(const char *filename, uint32_t *bitmap, int w, int h)

  40. {

  41.     int x, y, v;

  42.     FILE *f;

  43.     char fname[40], fname2[40];

  44.     char command[1024];

  45. 

  46.     snprintf(fname, sizeof(fname), "%s.ppm", filename);

  47. 

  48.     f = fopen(fname, "w");

  49.     if (!f) {

  50.         perror(fname);

  51.         return;

  52.     }

  53.     fprintf(f, "P6\n"

  54.             "%d %d\n"

  55.             "%d\n",

  56.             w, h, 255);

  57.     for(y = 0; y < h; y++) {

  58.         for(x = 0; x < w; x++) {

  59.             v = bitmap[y * w + x];

  60.             putc((v >> 16) & 0xff, f);

  61.             putc((v >> 8) & 0xff, f);

  62.             putc((v >> 0) & 0xff, f);

  63.         }

  64.     }

  65.     fclose(f);

  66. 

  67. 

  68.     snprintf(fname2, sizeof(fname2), "%s-a.pgm", filename);

  69. 

  70.     f = fopen(fname2, "w");

  71.     if (!f) {

  72.         perror(fname2);

  73.         return;

  74.     }

  75.     fprintf(f, "P5\n"

  76.             "%d %d\n"

  77.             "%d\n",

  78.             w, h, 255);

  79.     for(y = 0; y < h; y++) {

  80.         for(x = 0; x < w; x++) {

  81.             v = bitmap[y * w + x];

  82.             putc((v >> 24) & 0xff, f);

  83.         }

  84.     }

  85.     fclose(f);

  86. 

  87.     snprintf(command, sizeof(command), "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);

  88.     if (system(command) != 0) {

  89.         fprintf(stderr, "Error running pnmtopng\n");

  90.         return;

  91.     }

  92. 

  93.     snprintf(command, sizeof(command), "rm %s %s", fname, fname2);

  94.     if (system(command) != 0) {

  95.         fprintf(stderr, "Error removing %s and %s\n", fname, fname2);

  96.         return;

  97.     }

  98. }

  99. #endif

  100. 

  101. #define RGBA(r,g,b,a) (((unsigned)(a) << 24) | ((r) << 16) | ((g) << 8) | (b))

  102. 

  103. typedef struct DVBSubCLUT {

  104.     int id;

  105.     int version;

  106. 

  107.     uint32_t clut4[4];

  108.     uint32_t clut16[16];

  109.     uint32_t clut256[256];

  110. 

  111.     struct DVBSubCLUT *next;

  112. } DVBSubCLUT;

  113. 

  114. static DVBSubCLUT default_clut;

  115. 

  116. typedef struct DVBSubObjectDisplay {

  117.     int object_id;

  118.     int region_id;

  119. 

  120.     int x_pos;

  121.     int y_pos;

  122. 

  123.     int fgcolor;

  124.     int bgcolor;

  125. 

  126.     struct DVBSubObjectDisplay *region_list_next;

  127.     struct DVBSubObjectDisplay *object_list_next;

  128. } DVBSubObjectDisplay;

  129. 

  130. typedef struct DVBSubObject {

  131.     int id;

  132.     int version;

  133. 

  134.     int type;

  135. 

  136.     DVBSubObjectDisplay *display_list;

  137. 

  138.     struct DVBSubObject *next;

  139. } DVBSubObject;

  140. 

  141. typedef struct DVBSubRegionDisplay {

  142.     int region_id;

  143. 

  144.     int x_pos;

  145.     int y_pos;

  146. 

  147.     struct DVBSubRegionDisplay *next;

  148. } DVBSubRegionDisplay;

  149. 

  150. typedef struct DVBSubRegion {

  151.     int id;

  152.     int version;

  153. 

  154.     int width;

  155.     int height;

  156.     int depth;

  157. 

  158.     int clut;

  159.     int bgcolor;

  160. 

  161.     uint8_t *pbuf;

  162.     int buf_size;

  163.     int dirty;

  164. 

  165.     DVBSubObjectDisplay *display_list;

  166. 

  167.     struct DVBSubRegion *next;

  168. } DVBSubRegion;

  169. 

  170. typedef struct DVBSubDisplayDefinition {

  171.     int version;

  172. 

  173.     int x;

  174.     int y;

  175.     int width;

  176.     int height;

  177. } DVBSubDisplayDefinition;

  178. 

  179. typedef struct DVBSubContext {

  180.     AVClass *class;

  181.     int composition_id;

  182.     int ancillary_id;

  183. 

  184.     int version;

  185.     int time_out;

  186.     int compute_edt; /**< if 1 end display time calculated using pts

  187.                           if 0 (Default) calculated using time out */

  188.     int compute_clut;

  189.     int substream;

  190.     int64_t prev_start;

  191.     DVBSubRegion *region_list;

  192.     DVBSubCLUT   *clut_list;

  193.     DVBSubObject *object_list;

  194. 

  195.     DVBSubRegionDisplay *display_list;

  196.     DVBSubDisplayDefinition *display_definition;

  197. } DVBSubContext;

  198. 

  199. 

  200. static DVBSubObject* get_object(DVBSubContext *ctx, int object_id)

  201. {

  202.     DVBSubObject *ptr = ctx->object_list;

  203. 

  204.     while (ptr && ptr->id != object_id) {

  205.         ptr = ptr->next;

  206.     }

  207. 

  208.     return ptr;

  209. }

  210. 

  211. static DVBSubCLUT* get_clut(DVBSubContext *ctx, int clut_id)

  212. {

  213.     DVBSubCLUT *ptr = ctx->clut_list;

  214. 

  215.     while (ptr && ptr->id != clut_id) {

  216.         ptr = ptr->next;

  217.     }

  218. 

  219.     return ptr;

  220. }

  221. 

  222. static DVBSubRegion* get_region(DVBSubContext *ctx, int region_id)

  223. {

  224.     DVBSubRegion *ptr = ctx->region_list;

  225. 

  226.     while (ptr && ptr->id != region_id) {

  227.         ptr = ptr->next;

  228.     }

  229. 

  230.     return ptr;

  231. }

  232. 

  233. static void delete_region_display_list(DVBSubContext *ctx, DVBSubRegion *region)

  234. {

  235.     DVBSubObject *object, *obj2, **obj2_ptr;

  236.     DVBSubObjectDisplay *display, *obj_disp, **obj_disp_ptr;

  237. 

  238.     while (region->display_list) {

  239.         display = region->display_list;

  240. 

  241.         object = get_object(ctx, display->object_id);

  242. 

  243.         if (object) {

  244.             obj_disp_ptr = &object->display_list;

  245.             obj_disp = *obj_disp_ptr;

  246. 

  247.             while (obj_disp && obj_disp != display) {

  248.                 obj_disp_ptr = &obj_disp->object_list_next;

  249.                 obj_disp = *obj_disp_ptr;

  250.             }

  251. 

  252.             if (obj_disp) {

  253.                 *obj_disp_ptr = obj_disp->object_list_next;

  254. 

  255.                 if (!object->display_list) {

  256.                     obj2_ptr = &ctx->object_list;

  257.                     obj2 = *obj2_ptr;

  258. 

  259.                     while (obj2 != object) {

  260.                         av_assert0(obj2);

  261.                         obj2_ptr = &obj2->next;

  262.                         obj2 = *obj2_ptr;

  263.                     }

  264. 

  265.                     *obj2_ptr = obj2->next;

  266. 

  267.                     av_freep(&obj2);

  268.                 }

  269.             }

  270.         }

  271. 

  272.         region->display_list = display->region_list_next;

  273. 

  274.         av_freep(&display);

  275.     }

  276. 

  277. }

  278. 

  279. static void delete_cluts(DVBSubContext *ctx)

  280. {

  281.     while (ctx->clut_list) {

  282.         DVBSubCLUT *clut = ctx->clut_list;

  283. 

  284.         ctx->clut_list = clut->next;

  285. 

  286.         av_freep(&clut);

  287.     }

  288. }

  289. 

  290. static void delete_objects(DVBSubContext *ctx)

  291. {

  292.     while (ctx->object_list) {

  293.         DVBSubObject *object = ctx->object_list;

  294. 

  295.         ctx->object_list = object->next;

  296. 

  297.         av_freep(&object);

  298.     }

  299. }

  300. 

  301. static void delete_regions(DVBSubContext *ctx)

  302. {

  303.     while (ctx->region_list) {

  304.         DVBSubRegion *region = ctx->region_list;

  305. 

  306.         ctx->region_list = region->next;

  307. 

  308.         delete_region_display_list(ctx, region);

  309. 

  310.         av_freep(&region->pbuf);

  311.         av_freep(&region);

  312.     }

  313. }

  314. 

  315. static av_cold int dvbsub_init_decoder(AVCodecContext *avctx)

  316. {

  317.     int i, r, g, b, a = 0;

  318.     DVBSubContext *ctx = avctx->priv_data;

  319. 

  320.     if (ctx->substream < 0) {

  321.         ctx->composition_id = -1;

  322.         ctx->ancillary_id   = -1;

  323.     } else if (!avctx->extradata || (avctx->extradata_size < 4) || ((avctx->extradata_size % 5 != 0) && (avctx->extradata_size != 4))) {

  324.         av_log(avctx, AV_LOG_WARNING, "Invalid DVB subtitles stream extradata!\n");

  325.         ctx->composition_id = -1;

  326.         ctx->ancillary_id   = -1;

  327.     } else {

  328.         if (avctx->extradata_size > 5*ctx->substream + 2) {

  329.             ctx->composition_id = AV_RB16(avctx->extradata + 5*ctx->substream);

  330.             ctx->ancillary_id   = AV_RB16(avctx->extradata + 5*ctx->substream + 2);

  331.         } else {

  332.             av_log(avctx, AV_LOG_WARNING, "Selected DVB subtitles sub-stream %d is not available\n", ctx->substream);

  333.             ctx->composition_id = AV_RB16(avctx->extradata);

  334.             ctx->ancillary_id   = AV_RB16(avctx->extradata + 2);

  335.         }

  336.     }

  337. 

  338.     ctx->version = -1;

  339.     ctx->prev_start = AV_NOPTS_VALUE;

  340. 

  341.     default_clut.id = -1;

  342.     default_clut.next = NULL;

  343. 

  344.     default_clut.clut4[0] = RGBA(  0,   0,   0,   0);

  345.     default_clut.clut4[1] = RGBA(255, 255, 255, 255);

  346.     default_clut.clut4[2] = RGBA(  0,   0,   0, 255);

  347.     default_clut.clut4[3] = RGBA(127, 127, 127, 255);

  348. 

  349.     default_clut.clut16[0] = RGBA(  0,   0,   0,   0);

  350.     for (i = 1; i < 16; i++) {

  351.         if (i < 8) {

  352.             r = (i & 1) ? 255 : 0;

  353.             g = (i & 2) ? 255 : 0;

  354.             b = (i & 4) ? 255 : 0;

  355.         } else {

  356.             r = (i & 1) ? 127 : 0;

  357.             g = (i & 2) ? 127 : 0;

  358.             b = (i & 4) ? 127 : 0;

  359.         }

  360.         default_clut.clut16[i] = RGBA(r, g, b, 255);

  361.     }

  362. 

  363.     default_clut.clut256[0] = RGBA(  0,   0,   0,   0);

  364.     for (i = 1; i < 256; i++) {

  365.         if (i < 8) {

  366.             r = (i & 1) ? 255 : 0;

  367.             g = (i & 2) ? 255 : 0;

  368.             b = (i & 4) ? 255 : 0;

  369.             a = 63;

  370.         } else {

  371.             switch (i & 0x88) {

  372.             case 0x00:

  373.                 r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);

  374.                 g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);

  375.                 b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);

  376.                 a = 255;

  377.                 break;

  378.             case 0x08:

  379.                 r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);

  380.                 g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);

  381.                 b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);

  382.                 a = 127;

  383.                 break;

  384.             case 0x80:

  385.                 r = 127 + ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);

  386.                 g = 127 + ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);

  387.                 b = 127 + ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);

  388.                 a = 255;

  389.                 break;

  390.             case 0x88:

  391.                 r = ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);

  392.                 g = ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);

  393.                 b = ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);

  394.                 a = 255;

  395.                 break;

  396.             }

  397.         }

  398.         default_clut.clut256[i] = RGBA(r, g, b, a);

  399.     }

  400. 

  401.     return 0;

  402. }

  403. 

  404. static av_cold int dvbsub_close_decoder(AVCodecContext *avctx)

  405. {

  406.     DVBSubContext *ctx = avctx->priv_data;

  407.     DVBSubRegionDisplay *display;

  408. 

  409.     delete_regions(ctx);

  410. 

  411.     delete_objects(ctx);

  412. 

  413.     delete_cluts(ctx);

  414. 

  415.     av_freep(&ctx->display_definition);

  416. 

  417.     while (ctx->display_list) {

  418.         display = ctx->display_list;

  419.         ctx->display_list = display->next;

  420. 

  421.         av_freep(&display);

  422.     }

  423. 

  424.     return 0;

  425. }

  426. 

  427. static int dvbsub_read_2bit_string(AVCodecContext *avctx,

  428.                                    uint8_t *destbuf, int dbuf_len,

  429.                                    const uint8_t **srcbuf, int buf_size,

  430.                                    int non_mod, uint8_t *map_table, int x_pos)

  431. {

  432.     GetBitContext gb;

  433. 

  434.     int bits;

  435.     int run_length;

  436.     int pixels_read = x_pos;

  437. 

  438.     init_get_bits(&gb, *srcbuf, buf_size << 3);

  439. 

  440.     destbuf += x_pos;

  441. 

  442.     while (get_bits_count(&gb) < buf_size << 3 && pixels_read < dbuf_len) {

  443.         bits = get_bits(&gb, 2);

  444. 

  445.         if (bits) {

  446.             if (non_mod != 1 || bits != 1) {

  447.                 if (map_table)

  448.                     *destbuf++ = map_table[bits];

  449.                 else

  450.                     *destbuf++ = bits;

  451.             }

  452.             pixels_read++;

  453.         } else {

  454.             bits = get_bits1(&gb);

  455.             if (bits == 1) {

  456.                 run_length = get_bits(&gb, 3) + 3;

  457.                 bits = get_bits(&gb, 2);

  458. 

  459.                 if (non_mod == 1 && bits == 1)

  460.                     pixels_read += run_length;

  461.                 else {

  462.                     if (map_table)

  463.                         bits = map_table[bits];

  464.                     while (run_length-- > 0 && pixels_read < dbuf_len) {

  465.                         *destbuf++ = bits;

  466.                         pixels_read++;

  467.                     }

  468.                 }

  469.             } else {

  470.                 bits = get_bits1(&gb);

  471.                 if (bits == 0) {

  472.                     bits = get_bits(&gb, 2);

  473.                     if (bits == 2) {

  474.                         run_length = get_bits(&gb, 4) + 12;

  475.                         bits = get_bits(&gb, 2);

  476. 

  477.                         if (non_mod == 1 && bits == 1)

  478.                             pixels_read += run_length;

  479.                         else {

  480.                             if (map_table)

  481.                                 bits = map_table[bits];

  482.                             while (run_length-- > 0 && pixels_read < dbuf_len) {

  483.                                 *destbuf++ = bits;

  484.                                 pixels_read++;

  485.                             }

  486.                         }

  487.                     } else if (bits == 3) {

  488.                         run_length = get_bits(&gb, 8) + 29;

  489.                         bits = get_bits(&gb, 2);

  490. 

  491.                         if (non_mod == 1 && bits == 1)

  492.                             pixels_read += run_length;

  493.                         else {

  494.                             if (map_table)

  495.                                 bits = map_table[bits];

  496.                             while (run_length-- > 0 && pixels_read < dbuf_len) {

  497.                                 *destbuf++ = bits;

  498.                                 pixels_read++;

  499.                             }

  500.                         }

  501.                     } else if (bits == 1) {

  502.                         if (map_table)

  503.                             bits = map_table[0];

  504.                         else

  505.                             bits = 0;

  506.                         run_length = 2;

  507.                         while (run_length-- > 0 && pixels_read < dbuf_len) {

  508.                             *destbuf++ = bits;

  509.                             pixels_read++;

  510.                         }

  511.                     } else {

  512.                         (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;

  513.                         return pixels_read;

  514.                     }

  515.                 } else {

  516.                     if (map_table)

  517.                         bits = map_table[0];

  518.                     else

  519.                         bits = 0;

  520.                     *destbuf++ = bits;

  521.                     pixels_read++;

  522.                 }

  523.             }

  524.         }

  525.     }

  526. 

  527.     if (get_bits(&gb, 6))

  528.         av_log(avctx, AV_LOG_ERROR, "line overflow\n");

  529. 

  530.     (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;

  531. 

  532.     return pixels_read;

  533. }

  534. 

  535. static int dvbsub_read_4bit_string(AVCodecContext *avctx, uint8_t *destbuf, int dbuf_len,

  536.                                    const uint8_t **srcbuf, int buf_size,

  537.                                    int non_mod, uint8_t *map_table, int x_pos)

  538. {

  539.     GetBitContext gb;

  540. 

  541.     int bits;

  542.     int run_length;

  543.     int pixels_read = x_pos;

  544. 

  545.     init_get_bits(&gb, *srcbuf, buf_size << 3);

  546. 

  547.     destbuf += x_pos;

  548. 

  549.     while (get_bits_count(&gb) < buf_size << 3 && pixels_read < dbuf_len) {

  550.         bits = get_bits(&gb, 4);

  551. 

  552.         if (bits) {

  553.             if (non_mod != 1 || bits != 1) {

  554.                 if (map_table)

  555.                     *destbuf++ = map_table[bits];

  556.                 else

  557.                     *destbuf++ = bits;

  558.             }

  559.             pixels_read++;

  560.         } else {

  561.             bits = get_bits1(&gb);

  562.             if (bits == 0) {

  563.                 run_length = get_bits(&gb, 3);

  564. 

  565.                 if (run_length == 0) {

  566.                     (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;

  567.                     return pixels_read;

  568.                 }

  569. 

  570.                 run_length += 2;

  571. 

  572.                 if (map_table)

  573.                     bits = map_table[0];

  574.                 else

  575.                     bits = 0;

  576. 

  577.                 while (run_length-- > 0 && pixels_read < dbuf_len) {

  578.                     *destbuf++ = bits;

  579.                     pixels_read++;

  580.                 }

  581.             } else {

  582.                 bits = get_bits1(&gb);

  583.                 if (bits == 0) {

  584.                     run_length = get_bits(&gb, 2) + 4;

  585.                     bits = get_bits(&gb, 4);

  586. 

  587.                     if (non_mod == 1 && bits == 1)

  588.                         pixels_read += run_length;

  589.                     else {

  590.                         if (map_table)

  591.                             bits = map_table[bits];

  592.                         while (run_length-- > 0 && pixels_read < dbuf_len) {

  593.                             *destbuf++ = bits;

  594.                             pixels_read++;

  595.                         }

  596.                     }

  597.                 } else {

  598.                     bits = get_bits(&gb, 2);

  599.                     if (bits == 2) {

  600.                         run_length = get_bits(&gb, 4) + 9;

  601.                         bits = get_bits(&gb, 4);

  602. 

  603.                         if (non_mod == 1 && bits == 1)

  604.                             pixels_read += run_length;

  605.                         else {

  606.                             if (map_table)

  607.                                 bits = map_table[bits];

  608.                             while (run_length-- > 0 && pixels_read < dbuf_len) {

  609.                                 *destbuf++ = bits;

  610.                                 pixels_read++;

  611.                             }

  612.                         }

  613.                     } else if (bits == 3) {

  614.                         run_length = get_bits(&gb, 8) + 25;

  615.                         bits = get_bits(&gb, 4);

  616. 

  617.                         if (non_mod == 1 && bits == 1)

  618.                             pixels_read += run_length;

  619.                         else {

  620.                             if (map_table)

  621.                                 bits = map_table[bits];

  622.                             while (run_length-- > 0 && pixels_read < dbuf_len) {

  623.                                 *destbuf++ = bits;

  624.                                 pixels_read++;

  625.                             }

  626.                         }

  627.                     } else if (bits == 1) {

  628.                         if (map_table)

  629.                             bits = map_table[0];

  630.                         else

  631.                             bits = 0;

  632.                         run_length = 2;

  633.                         while (run_length-- > 0 && pixels_read < dbuf_len) {

  634.                             *destbuf++ = bits;

  635.                             pixels_read++;

  636.                         }

  637.                     } else {

  638.                         if (map_table)

  639.                             bits = map_table[0];

  640.                         else

  641.                             bits = 0;

  642.                         *destbuf++ = bits;

  643.                         pixels_read ++;

  644.                     }

  645.                 }

  646.             }

  647.         }

  648.     }

  649. 

  650.     if (get_bits(&gb, 8))

  651.         av_log(avctx, AV_LOG_ERROR, "line overflow\n");

  652. 

  653.     (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;

  654. 

  655.     return pixels_read;

  656. }

  657. 

  658. static int dvbsub_read_8bit_string(AVCodecContext *avctx,

  659.                                    uint8_t *destbuf, int dbuf_len,

  660.                                     const uint8_t **srcbuf, int buf_size,

  661.                                     int non_mod, uint8_t *map_table, int x_pos)

  662. {

  663.     const uint8_t *sbuf_end = (*srcbuf) + buf_size;

  664.     int bits;

  665.     int run_length;

  666.     int pixels_read = x_pos;

  667. 

  668.     destbuf += x_pos;

  669. 

  670.     while (*srcbuf < sbuf_end && pixels_read < dbuf_len) {

  671.         bits = *(*srcbuf)++;

  672. 

  673.         if (bits) {

  674.             if (non_mod != 1 || bits != 1) {

  675.                 if (map_table)

  676.                     *destbuf++ = map_table[bits];

  677.                 else

  678.                     *destbuf++ = bits;

  679.             }

  680.             pixels_read++;

  681.         } else {

  682.             bits = *(*srcbuf)++;

  683.             run_length = bits & 0x7f;

  684.             if ((bits & 0x80) == 0) {

  685.                 if (run_length == 0) {

  686.                     return pixels_read;

  687.                 }

  688. 

  689.                 bits = 0;

  690.             } else {

  691.                 bits = *(*srcbuf)++;

  692.             }

  693.             if (non_mod == 1 && bits == 1)

  694.                 pixels_read += run_length;

  695.             else {

  696.                 if (map_table)

  697.                     bits = map_table[bits];

  698.                 while (run_length-- > 0 && pixels_read < dbuf_len) {

  699.                     *destbuf++ = bits;

  700.                     pixels_read++;

  701.                 }

  702.             }

  703.         }

  704.     }

  705. 

  706.     if (*(*srcbuf)++)

  707.         av_log(avctx, AV_LOG_ERROR, "line overflow\n");

  708. 

  709.     return pixels_read;

  710. }

  711. 

  712. static void compute_default_clut(AVSubtitleRect *rect, int w, int h)

  713. {

  714.     uint8_t list[256] = {0};

  715.     uint8_t list_inv[256];

  716.     int counttab[256] = {0};

  717.     int count, i, x, y;

  718. 

  719. #define V(x,y) rect->data[0][(x) + (y)*rect->linesize[0]]

  720.     for (y = 0; y<h; y++) {

  721.         for (x = 0; x<w; x++) {

  722.             int v = V(x,y) + 1;

  723.             int vl = x     ? V(x-1,y) + 1 : 0;

  724.             int vr = x+1<w ? V(x+1,y) + 1 : 0;

  725.             int vt = y     ? V(x,y-1) + 1 : 0;

  726.             int vb = y+1<h ? V(x,y+1) + 1 : 0;

  727.             counttab[v-1] += !!((v!=vl) + (v!=vr) + (v!=vt) + (v!=vb));

  728.         }

  729.     }

  730. #define L(x,y) list[ rect->data[0][(x) + (y)*rect->linesize[0]] ]

  731. 

  732.     for (i = 0; i<256; i++) {

  733.         int scoretab[256] = {0};

  734.         int bestscore = 0;

  735.         int bestv = 0;

  736.         for (y = 0; y<h; y++) {

  737.             for (x = 0; x<w; x++) {

  738.                 int v = rect->data[0][x + y*rect->linesize[0]];

  739.                 int l_m = list[v];

  740.                 int l_l = x     ? L(x-1, y) : 1;

  741.                 int l_r = x+1<w ? L(x+1, y) : 1;

  742.                 int l_t = y     ? L(x, y-1) : 1;

  743.                 int l_b = y+1<h ? L(x, y+1) : 1;

  744.                 int score;

  745.                 if (l_m)

  746.                     continue;

  747.                 scoretab[v] += l_l + l_r + l_t + l_b;

  748.                 score = 1024LL*scoretab[v] / counttab[v];

  749.                 if (score > bestscore) {

  750.                     bestscore = score;

  751.                     bestv = v;

  752.                 }

  753.             }

  754.         }

  755.         if (!bestscore)

  756.             break;

  757.         list    [ bestv ] = 1;

  758.         list_inv[     i ] = bestv;

  759.     }

  760. 

  761.     count = FFMAX(i - 1, 1);

  762.     for (i--; i>=0; i--) {

  763.         int v = i*255/count;

  764.         AV_WN32(rect->data[1] + 4*list_inv[i], RGBA(v/2,v,v/2,v));

  765.     }

  766. }

  767. 

  768. 

  769. static int save_subtitle_set(AVCodecContext *avctx, AVSubtitle *sub, int *got_output)

  770. {

  771.     DVBSubContext *ctx = avctx->priv_data;

  772.     DVBSubRegionDisplay *display;

  773.     DVBSubDisplayDefinition *display_def = ctx->display_definition;

  774.     DVBSubRegion *region;

  775.     AVSubtitleRect *rect;

  776.     DVBSubCLUT *clut;

  777.     uint32_t *clut_table;

  778.     int i;

  779.     int offset_x=0, offset_y=0;

  780.     int ret = 0;

  781. 

  782. 

  783.     if (display_def) {

  784.         offset_x = display_def->x;

  785.         offset_y = display_def->y;

  786.     }

  787. 

  788.     /* Not touching AVSubtitles again*/

  789.     if(sub->num_rects) {

  790.         avpriv_request_sample(ctx, "Different Version of Segment asked Twice");

  791.         return AVERROR_PATCHWELCOME;

  792.     }

  793.     for (display = ctx->display_list; display; display = display->next) {

  794.         region = get_region(ctx, display->region_id);

  795.         if (region && region->dirty)

  796.             sub->num_rects++;

  797.     }

  798. 

  799.     if(ctx->compute_edt == 0) {

  800.         sub->end_display_time = ctx->time_out * 1000;

  801.         *got_output = 1;

  802.     } else if (ctx->prev_start != AV_NOPTS_VALUE) {

  803.         sub->end_display_time = av_rescale_q((sub->pts - ctx->prev_start ), AV_TIME_BASE_Q, (AVRational){ 1, 1000 }) - 1;

  804.         *got_output = 1;

  805.     }

  806.     if (sub->num_rects > 0) {

  807. 

  808.         sub->rects = av_mallocz_array(sizeof(*sub->rects), sub->num_rects);

  809.         if (!sub->rects) {

  810.             ret = AVERROR(ENOMEM);

  811.             goto fail;

  812.         }

  813. 

  814.         for(i=0; i<sub->num_rects; i++)

  815.             sub->rects[i] = av_mallocz(sizeof(*sub->rects[i]));

  816. 

  817.         i = 0;

  818. 

  819.         for (display = ctx->display_list; display; display = display->next) {

  820.             region = get_region(ctx, display->region_id);

  821. 

  822.             if (!region)

  823.                 continue;

  824. 

  825.             if (!region->dirty)

  826.                 continue;

  827. 

  828.             rect = sub->rects[i];

  829.             rect->x = display->x_pos + offset_x;

  830.             rect->y = display->y_pos + offset_y;

  831.             rect->w = region->width;

  832.             rect->h = region->height;

  833.             rect->nb_colors = (1 << region->depth);

  834.             rect->type      = SUBTITLE_BITMAP;

  835.             rect->linesize[0] = region->width;

  836. 

  837.             clut = get_clut(ctx, region->clut);

  838. 

  839.             if (!clut)

  840.                 clut = &default_clut;

  841. 

  842.             switch (region->depth) {

  843.             case 2:

  844.                 clut_table = clut->clut4;

  845.                 break;

  846.             case 8:

  847.                 clut_table = clut->clut256;

  848.                 break;

  849.             case 4:

  850.             default:

  851.                 clut_table = clut->clut16;

  852.                 break;

  853.             }

  854. 

  855.             rect->data[1] = av_mallocz(AVPALETTE_SIZE);

  856.             if (!rect->data[1]) {

  857.                 ret = AVERROR(ENOMEM);

  858.                 goto fail;

  859.             }

  860.             memcpy(rect->data[1], clut_table, (1 << region->depth) * sizeof(uint32_t));

  861. 

  862.             rect->data[0] = av_malloc(region->buf_size);

  863.             if (!rect->data[0]) {

  864.                 ret = AVERROR(ENOMEM);

  865.                 goto fail;

  866.             }

  867. 

  868.             memcpy(rect->data[0], region->pbuf, region->buf_size);

  869. 

  870.             if ((clut == &default_clut && ctx->compute_clut == -1) || ctx->compute_clut == 1)

  871.                 compute_default_clut(rect, rect->w, rect->h);

  872. 

  873. #if FF_API_AVPICTURE

  874. FF_DISABLE_DEPRECATION_WARNINGS

  875. {

  876.             int j;

  877.             for (j = 0; j < 4; j++) {

  878.                 rect->pict.data[j] = rect->data[j];

  879.                 rect->pict.linesize[j] = rect->linesize[j];

  880.             }

  881. }

  882. FF_ENABLE_DEPRECATION_WARNINGS

  883. #endif

  884. 

  885.             i++;

  886.         }

  887.     }

  888. 

  889.     return 0;

  890. fail:

  891.     if (sub->rects) {

  892.         for(i=0; i<sub->num_rects; i++) {

  893.             rect = sub->rects[i];

  894.             if (rect) {

  895.                 av_freep(&rect->data[0]);

  896.                 av_freep(&rect->data[1]);

  897.             }

  898.             av_freep(&sub->rects[i]);

  899.         }

  900.         av_freep(&sub->rects);

  901.     }

  902.     sub->num_rects = 0;

  903.     return ret;

  904. }

  905. 

  906. static void dvbsub_parse_pixel_data_block(AVCodecContext *avctx, DVBSubObjectDisplay *display,

  907.                                           const uint8_t *buf, int buf_size, int top_bottom, int non_mod)

  908. {

  909.     DVBSubContext *ctx = avctx->priv_data;

  910. 

  911.     DVBSubRegion *region = get_region(ctx, display->region_id);

  912.     const uint8_t *buf_end = buf + buf_size;

  913.     uint8_t *pbuf;

  914.     int x_pos, y_pos;

  915.     int i;

  916. 

  917.     uint8_t map2to4[] = { 0x0,  0x7,  0x8,  0xf};

  918.     uint8_t map2to8[] = {0x00, 0x77, 0x88, 0xff};

  919.     uint8_t map4to8[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,

  920.                          0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};

  921.     uint8_t *map_table;

  922. 

  923. #if 0

  924.     ff_dlog(avctx, "DVB pixel block size %d, %s field:\n", buf_size,

  925.             top_bottom ? "bottom" : "top");

  926. 

  927.     for (i = 0; i < buf_size; i++) {

  928.         if (i % 16 == 0)

  929.             ff_dlog(avctx, "0x%8p: ", buf+i);

  930. 

  931.         ff_dlog(avctx, "%02x ", buf[i]);

  932.         if (i % 16 == 15)

  933.             ff_dlog(avctx, "\n");

  934.     }

  935. 

  936.     if (i % 16)

  937.         ff_dlog(avctx, "\n");

  938. #endif

  939. 

  940.     if (!region)

  941.         return;

  942. 

  943.     pbuf = region->pbuf;

  944.     region->dirty = 1;

  945. 

  946.     x_pos = display->x_pos;

  947.     y_pos = display->y_pos;

  948. 

  949.     y_pos += top_bottom;

  950. 

  951.     while (buf < buf_end) {

  952.         if ((*buf!=0xf0 && x_pos >= region->width) || y_pos >= region->height) {

  953.             av_log(avctx, AV_LOG_ERROR, "Invalid object location! %d-%d %d-%d %02x\n", x_pos, region->width, y_pos, region->height, *buf);

  954.             return;

  955.         }

  956. 

  957.         switch (*buf++) {

  958.         case 0x10:

  959.             if (region->depth == 8)

  960.                 map_table = map2to8;

  961.             else if (region->depth == 4)

  962.                 map_table = map2to4;

  963.             else

  964.                 map_table = NULL;

  965. 

  966.             x_pos = dvbsub_read_2bit_string(avctx, pbuf + (y_pos * region->width),

  967.                                             region->width, &buf, buf_end - buf,

  968.                                             non_mod, map_table, x_pos);

  969.             break;

  970.         case 0x11:

  971.             if (region->depth < 4) {

  972.                 av_log(avctx, AV_LOG_ERROR, "4-bit pixel string in %d-bit region!\n", region->depth);

  973.                 return;

  974.             }

  975. 

  976.             if (region->depth == 8)

  977.                 map_table = map4to8;

  978.             else

  979.                 map_table = NULL;

  980. 

  981.             x_pos = dvbsub_read_4bit_string(avctx, pbuf + (y_pos * region->width),

  982.                                             region->width, &buf, buf_end - buf,

  983.                                             non_mod, map_table, x_pos);

  984.             break;

  985.         case 0x12:

  986.             if (region->depth < 8) {

  987.                 av_log(avctx, AV_LOG_ERROR, "8-bit pixel string in %d-bit region!\n", region->depth);

  988.                 return;

  989.             }

  990. 

  991.             x_pos = dvbsub_read_8bit_string(avctx, pbuf + (y_pos * region->width),

  992.                                             region->width, &buf, buf_end - buf,

  993.                                             non_mod, NULL, x_pos);

  994.             break;

  995. 

  996.         case 0x20:

  997.             map2to4[0] = (*buf) >> 4;

  998.             map2to4[1] = (*buf++) & 0xf;

  999.             map2to4[2] = (*buf) >> 4;

  1000.             map2to4[3] = (*buf++) & 0xf;

  1001.             break;

  1002.         case 0x21:

  1003.             for (i = 0; i < 4; i++)

  1004.                 map2to8[i] = *buf++;

  1005.             break;

  1006.         case 0x22:

  1007.             for (i = 0; i < 16; i++)

  1008.                 map4to8[i] = *buf++;

  1009.             break;

  1010. 

  1011.         case 0xf0:

  1012.             x_pos = display->x_pos;

  1013.             y_pos += 2;

  1014.             break;

  1015.         default:

  1016.             av_log(avctx, AV_LOG_INFO, "Unknown/unsupported pixel block 0x%x\n", *(buf-1));

  1017.         }

  1018.     }

  1019. 

  1020. }

  1021. 

  1022. static int dvbsub_parse_object_segment(AVCodecContext *avctx,

  1023.                                        const uint8_t *buf, int buf_size)

  1024. {

  1025.     DVBSubContext *ctx = avctx->priv_data;

  1026. 

  1027.     const uint8_t *buf_end = buf + buf_size;

  1028.     int object_id;

  1029.     DVBSubObject *object;

  1030.     DVBSubObjectDisplay *display;

  1031.     int top_field_len, bottom_field_len;

  1032. 

  1033.     int coding_method, non_modifying_color;

  1034. 

  1035.     object_id = AV_RB16(buf);

  1036.     buf += 2;

  1037. 

  1038.     object = get_object(ctx, object_id);

  1039. 

  1040.     if (!object)

  1041.         return AVERROR_INVALIDDATA;

  1042. 

  1043.     coding_method = ((*buf) >> 2) & 3;

  1044.     non_modifying_color = ((*buf++) >> 1) & 1;

  1045. 

  1046.     if (coding_method == 0) {

  1047.         top_field_len = AV_RB16(buf);

  1048.         buf += 2;

  1049.         bottom_field_len = AV_RB16(buf);

  1050.         buf += 2;

  1051. 

  1052.         if (buf + top_field_len + bottom_field_len > buf_end) {

  1053.             av_log(avctx, AV_LOG_ERROR, "Field data size %d+%d too large\n", top_field_len, bottom_field_len);

  1054.             return AVERROR_INVALIDDATA;

  1055.         }

  1056. 

  1057.         for (display = object->display_list; display; display = display->object_list_next) {

  1058.             const uint8_t *block = buf;

  1059.             int bfl = bottom_field_len;

  1060. 

  1061.             dvbsub_parse_pixel_data_block(avctx, display, block, top_field_len, 0,

  1062.                                             non_modifying_color);

  1063. 

  1064.             if (bottom_field_len > 0)

  1065.                 block = buf + top_field_len;

  1066.             else

  1067.                 bfl = top_field_len;

  1068. 

  1069.             dvbsub_parse_pixel_data_block(avctx, display, block, bfl, 1,

  1070.                                             non_modifying_color);

  1071.         }

  1072. 

  1073. /*  } else if (coding_method == 1) {*/

  1074. 

  1075.     } else {

  1076.         av_log(avctx, AV_LOG_ERROR, "Unknown object coding %d\n", coding_method);

  1077.     }

  1078. 

  1079.     return 0;

  1080. }

  1081. 

  1082. static int dvbsub_parse_clut_segment(AVCodecContext *avctx,

  1083.                                      const uint8_t *buf, int buf_size)

  1084. {

  1085.     DVBSubContext *ctx = avctx->priv_data;

  1086. 

  1087.     const uint8_t *buf_end = buf + buf_size;

  1088.     int i, clut_id;

  1089.     int version;

  1090.     DVBSubCLUT *clut;

  1091.     int entry_id, depth , full_range;

  1092.     int y, cr, cb, alpha;

  1093.     int r, g, b, r_add, g_add, b_add;

  1094. 

  1095.     ff_dlog(avctx, "DVB clut packet:\n");

  1096. 

  1097.     for (i=0; i < buf_size; i++) {

  1098.         ff_dlog(avctx, "%02x ", buf[i]);

  1099.         if (i % 16 == 15)

  1100.             ff_dlog(avctx, "\n");

  1101.     }

  1102. 

  1103.     if (i % 16)

  1104.         ff_dlog(avctx, "\n");

  1105. 

  1106.     clut_id = *buf++;

  1107.     version = ((*buf)>>4)&15;

  1108.     buf += 1;

  1109. 

  1110.     clut = get_clut(ctx, clut_id);

  1111. 

  1112.     if (!clut) {

  1113.         clut = av_malloc(sizeof(DVBSubCLUT));

  1114.         if (!clut)

  1115.             return AVERROR(ENOMEM);

  1116. 

  1117.         memcpy(clut, &default_clut, sizeof(DVBSubCLUT));

  1118. 

  1119.         clut->id = clut_id;

  1120.         clut->version = -1;

  1121. 

  1122.         clut->next = ctx->clut_list;

  1123.         ctx->clut_list = clut;

  1124.     }

  1125. 

  1126.     if (clut->version != version) {

  1127. 

  1128.     clut->version = version;

  1129. 

  1130.     while (buf + 4 < buf_end) {

  1131.         entry_id = *buf++;

  1132. 

  1133.         depth = (*buf) & 0xe0;

  1134. 

  1135.         if (depth == 0) {

  1136.             av_log(avctx, AV_LOG_ERROR, "Invalid clut depth 0x%x!\n", *buf);

  1137.         }

  1138. 

  1139.         full_range = (*buf++) & 1;

  1140. 

  1141.         if (full_range) {

  1142.             y = *buf++;

  1143.             cr = *buf++;

  1144.             cb = *buf++;

  1145.             alpha = *buf++;

  1146.         } else {

  1147.             y = buf[0] & 0xfc;

  1148.             cr = (((buf[0] & 3) << 2) | ((buf[1] >> 6) & 3)) << 4;

  1149.             cb = (buf[1] << 2) & 0xf0;

  1150.             alpha = (buf[1] << 6) & 0xc0;

  1151. 

  1152.             buf += 2;

  1153.         }

  1154. 

  1155.         if (y == 0)

  1156.             alpha = 0xff;

  1157. 

  1158.         YUV_TO_RGB1_CCIR(cb, cr);

  1159.         YUV_TO_RGB2_CCIR(r, g, b, y);

  1160. 

  1161.         ff_dlog(avctx, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);

  1162.         if (!!(depth & 0x80) + !!(depth & 0x40) + !!(depth & 0x20) > 1) {

  1163.             ff_dlog(avctx, "More than one bit level marked: %x\n", depth);

  1164.             if (avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL)

  1165.                 return AVERROR_INVALIDDATA;

  1166.         }

  1167. 

  1168.         if (depth & 0x80)

  1169.             clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha);

  1170.         else if (depth & 0x40)

  1171.             clut->clut16[entry_id] = RGBA(r,g,b,255 - alpha);

  1172.         else if (depth & 0x20)

  1173.             clut->clut256[entry_id] = RGBA(r,g,b,255 - alpha);

  1174.     }

  1175.     }

  1176. 

  1177.     return 0;

  1178. }

  1179. 

  1180. 

  1181. static int dvbsub_parse_region_segment(AVCodecContext *avctx,

  1182.                                        const uint8_t *buf, int buf_size)

  1183. {

  1184.     DVBSubContext *ctx = avctx->priv_data;

  1185. 

  1186.     const uint8_t *buf_end = buf + buf_size;

  1187.     int region_id, object_id;

  1188.     int av_unused version;

  1189.     DVBSubRegion *region;

  1190.     DVBSubObject *object;

  1191.     DVBSubObjectDisplay *display;

  1192.     int fill;

  1193. 

  1194.     if (buf_size < 10)

  1195.         return AVERROR_INVALIDDATA;

  1196. 

  1197.     region_id = *buf++;

  1198. 

  1199.     region = get_region(ctx, region_id);

  1200. 

  1201.     if (!region) {

  1202.         region = av_mallocz(sizeof(DVBSubRegion));

  1203.         if (!region)

  1204.             return AVERROR(ENOMEM);

  1205. 

  1206.         region->id = region_id;

  1207.         region->version = -1;

  1208. 

  1209.         region->next = ctx->region_list;

  1210.         ctx->region_list = region;

  1211.     }

  1212. 

  1213.     version = ((*buf)>>4) & 15;

  1214.     fill = ((*buf++) >> 3) & 1;

  1215. 

  1216.     region->width = AV_RB16(buf);

  1217.     buf += 2;

  1218.     region->height = AV_RB16(buf);

  1219.     buf += 2;

  1220. 

  1221.     if (region->width * region->height != region->buf_size) {

  1222.         av_free(region->pbuf);

  1223. 

  1224.         region->buf_size = region->width * region->height;

  1225. 

  1226.         region->pbuf = av_malloc(region->buf_size);

  1227.         if (!region->pbuf) {

  1228.             region->buf_size =

  1229.             region->width =

  1230.             region->height = 0;

  1231.             return AVERROR(ENOMEM);

  1232.         }

  1233. 

  1234.         fill = 1;

  1235.         region->dirty = 0;

  1236.     }

  1237. 

  1238.     region->depth = 1 << (((*buf++) >> 2) & 7);

  1239.     if(region->depth<2 || region->depth>8){

  1240.         av_log(avctx, AV_LOG_ERROR, "region depth %d is invalid\n", region->depth);

  1241.         region->depth= 4;

  1242.     }

  1243.     region->clut = *buf++;

  1244. 

  1245.     if (region->depth == 8) {

  1246.         region->bgcolor = *buf++;

  1247.         buf += 1;

  1248.     } else {

  1249.         buf += 1;

  1250. 

  1251.         if (region->depth == 4)

  1252.             region->bgcolor = (((*buf++) >> 4) & 15);

  1253.         else

  1254.             region->bgcolor = (((*buf++) >> 2) & 3);

  1255.     }

  1256. 

  1257.     ff_dlog(avctx, "Region %d, (%dx%d)\n", region_id, region->width, region->height);

  1258. 

  1259.     if (fill) {

  1260.         memset(region->pbuf, region->bgcolor, region->buf_size);

  1261.         ff_dlog(avctx, "Fill region (%d)\n", region->bgcolor);

  1262.     }

  1263. 

  1264.     delete_region_display_list(ctx, region);

  1265. 

  1266.     while (buf + 5 < buf_end) {

  1267.         object_id = AV_RB16(buf);

  1268.         buf += 2;

  1269. 

  1270.         object = get_object(ctx, object_id);

  1271. 

  1272.         if (!object) {

  1273.             object = av_mallocz(sizeof(DVBSubObject));

  1274.             if (!object)

  1275.                 return AVERROR(ENOMEM);

  1276. 

  1277.             object->id = object_id;

  1278.             object->next = ctx->object_list;

  1279.             ctx->object_list = object;

  1280.         }

  1281. 

  1282.         object->type = (*buf) >> 6;

  1283. 

  1284.         display = av_mallocz(sizeof(DVBSubObjectDisplay));

  1285.         if (!display)

  1286.             return AVERROR(ENOMEM);

  1287. 

  1288.         display->object_id = object_id;

  1289.         display->region_id = region_id;

  1290. 

  1291.         display->x_pos = AV_RB16(buf) & 0xfff;

  1292.         buf += 2;

  1293.         display->y_pos = AV_RB16(buf) & 0xfff;

  1294.         buf += 2;

  1295. 

  1296.         if ((object->type == 1 || object->type == 2) && buf+1 < buf_end) {

  1297.             display->fgcolor = *buf++;

  1298.             display->bgcolor = *buf++;

  1299.         }

  1300. 

  1301.         display->region_list_next = region->display_list;

  1302.         region->display_list = display;

  1303. 

  1304.         display->object_list_next = object->display_list;

  1305.         object->display_list = display;

  1306.     }

  1307. 

  1308.     return 0;

  1309. }

  1310. 

  1311. static int dvbsub_parse_page_segment(AVCodecContext *avctx,

  1312.                                      const uint8_t *buf, int buf_size, AVSubtitle *sub, int *got_output)

  1313. {

  1314.     DVBSubContext *ctx = avctx->priv_data;

  1315.     DVBSubRegionDisplay *display;

  1316.     DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;

  1317. 

  1318.     const uint8_t *buf_end = buf + buf_size;

  1319.     int region_id;

  1320.     int page_state;

  1321.     int timeout;

  1322.     int version;

  1323. 

  1324.     if (buf_size < 1)

  1325.         return AVERROR_INVALIDDATA;

  1326. 

  1327.     timeout = *buf++;

  1328.     version = ((*buf)>>4) & 15;

  1329.     page_state = ((*buf++) >> 2) & 3;

  1330. 

  1331.     if (ctx->version == version) {

  1332.         return 0;

  1333.     }

  1334. 

  1335.     ctx->time_out = timeout;

  1336.     ctx->version = version;

  1337. 

  1338.     ff_dlog(avctx, "Page time out %ds, state %d\n", ctx->time_out, page_state);

  1339. 

  1340.     if(ctx->compute_edt == 1)

  1341.         save_subtitle_set(avctx, sub, got_output);

  1342. 

  1343.     if (page_state == 1 || page_state == 2) {

  1344.         delete_regions(ctx);

  1345.         delete_objects(ctx);

  1346.         delete_cluts(ctx);

  1347.     }

  1348. 

  1349.     tmp_display_list = ctx->display_list;

  1350.     ctx->display_list = NULL;

  1351. 

  1352.     while (buf + 5 < buf_end) {

  1353.         region_id = *buf++;

  1354.         buf += 1;

  1355. 

  1356.         display = tmp_display_list;

  1357.         tmp_ptr = &tmp_display_list;

  1358. 

  1359.         while (display && display->region_id != region_id) {

  1360.             tmp_ptr = &display->next;

  1361.             display = display->next;

  1362.         }

  1363. 

  1364.         if (!display) {

  1365.             display = av_mallocz(sizeof(DVBSubRegionDisplay));

  1366.             if (!display)

  1367.                 return AVERROR(ENOMEM);

  1368.         }

  1369. 

  1370.         display->region_id = region_id;

  1371. 

  1372.         display->x_pos = AV_RB16(buf);

  1373.         buf += 2;

  1374.         display->y_pos = AV_RB16(buf);

  1375.         buf += 2;

  1376. 

  1377.         *tmp_ptr = display->next;

  1378. 

  1379.         display->next = ctx->display_list;

  1380.         ctx->display_list = display;

  1381. 

  1382.         ff_dlog(avctx, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);

  1383.     }

  1384. 

  1385.     while (tmp_display_list) {

  1386.         display = tmp_display_list;

  1387. 

  1388.         tmp_display_list = display->next;

  1389. 

  1390.         av_freep(&display);

  1391.     }

  1392. 

  1393.     return 0;

  1394. }

  1395. 

  1396. 

  1397. #ifdef DEBUG

  1398. static int save_display_set(DVBSubContext *ctx)

  1399. {

  1400.     DVBSubRegion *region;

  1401.     DVBSubRegionDisplay *display;

  1402.     DVBSubCLUT *clut;

  1403.     uint32_t *clut_table;

  1404.     int x_pos, y_pos, width, height;

  1405.     int x, y, y_off, x_off;

  1406.     uint32_t *pbuf;

  1407.     char filename[32];

  1408.     static int fileno_index = 0;

  1409. 

  1410.     x_pos = -1;

  1411.     y_pos = -1;

  1412.     width = 0;

  1413.     height = 0;

  1414. 

  1415.     for (display = ctx->display_list; display; display = display->next) {

  1416.         region = get_region(ctx, display->region_id);

  1417. 

  1418.         if (!region)

  1419.             return -1;

  1420. 

  1421.         if (x_pos == -1) {

  1422.             x_pos = display->x_pos;

  1423.             y_pos = display->y_pos;

  1424.             width = region->width;

  1425.             height = region->height;

  1426.         } else {

  1427.             if (display->x_pos < x_pos) {

  1428.                 width += (x_pos - display->x_pos);

  1429.                 x_pos = display->x_pos;

  1430.             }

  1431. 

  1432.             if (display->y_pos < y_pos) {

  1433.                 height += (y_pos - display->y_pos);

  1434.                 y_pos = display->y_pos;

  1435.             }

  1436. 

  1437.             if (display->x_pos + region->width > x_pos + width) {

  1438.                 width = display->x_pos + region->width - x_pos;

  1439.             }

  1440. 

  1441.             if (display->y_pos + region->height > y_pos + height) {

  1442.                 height = display->y_pos + region->height - y_pos;

  1443.             }

  1444.         }

  1445.     }

  1446. 

  1447.     if (x_pos >= 0) {

  1448. 

  1449.         pbuf = av_malloc(width * height * 4);

  1450.         if (!pbuf)

  1451.             return -1;

  1452. 

  1453.         for (display = ctx->display_list; display; display = display->next) {

  1454.             region = get_region(ctx, display->region_id);

  1455. 

  1456.             if (!region)

  1457.                 return -1;

  1458. 

  1459.             x_off = display->x_pos - x_pos;

  1460.             y_off = display->y_pos - y_pos;

  1461. 

  1462.             clut = get_clut(ctx, region->clut);

  1463. 

  1464.             if (!clut)

  1465.                 clut = &default_clut;

  1466. 

  1467.             switch (region->depth) {

  1468.             case 2:

  1469.                 clut_table = clut->clut4;

  1470.                 break;

  1471.             case 8:

  1472.                 clut_table = clut->clut256;

  1473.                 break;

  1474.             case 4:

  1475.             default:

  1476.                 clut_table = clut->clut16;

  1477.                 break;

  1478.             }

  1479. 

  1480.             for (y = 0; y < region->height; y++) {

  1481.                 for (x = 0; x < region->width; x++) {

  1482.                     pbuf[((y + y_off) * width) + x_off + x] =

  1483.                         clut_table[region->pbuf[y * region->width + x]];

  1484.                 }

  1485.             }

  1486. 

  1487.         }

  1488. 

  1489.         snprintf(filename, sizeof(filename), "dvbs.%d", fileno_index);

  1490. 

  1491.         png_save(filename, pbuf, width, height);

  1492. 

  1493.         av_freep(&pbuf);

  1494.     }

  1495. 

  1496.     fileno_index++;

  1497.     return 0;

  1498. }

  1499. #endif

  1500. 

  1501. static int dvbsub_parse_display_definition_segment(AVCodecContext *avctx,

  1502.                                                    const uint8_t *buf,

  1503.                                                    int buf_size)

  1504. {

  1505.     DVBSubContext *ctx = avctx->priv_data;

  1506.     DVBSubDisplayDefinition *display_def = ctx->display_definition;

  1507.     int dds_version, info_byte;

  1508. 

  1509.     if (buf_size < 5)

  1510.         return AVERROR_INVALIDDATA;

  1511. 

  1512.     info_byte   = bytestream_get_byte(&buf);

  1513.     dds_version = info_byte >> 4;

  1514.     if (display_def && display_def->version == dds_version)

  1515.         return 0; // already have this display definition version

  1516. 

  1517.     if (!display_def) {

  1518.         display_def             = av_mallocz(sizeof(*display_def));

  1519.         if (!display_def)

  1520.             return AVERROR(ENOMEM);

  1521.         ctx->display_definition = display_def;

  1522.     }

  1523. 

  1524.     display_def->version = dds_version;

  1525.     display_def->x       = 0;

  1526.     display_def->y       = 0;

  1527.     display_def->width   = bytestream_get_be16(&buf) + 1;

  1528.     display_def->height  = bytestream_get_be16(&buf) + 1;

  1529.     if (!avctx->width || !avctx->height) {

  1530.         avctx->width  = display_def->width;

  1531.         avctx->height = display_def->height;

  1532.     }

  1533. 

  1534.     if (info_byte & 1<<3) { // display_window_flag

  1535.         if (buf_size < 13)

  1536.             return AVERROR_INVALIDDATA;

  1537. 

  1538.         display_def->x = bytestream_get_be16(&buf);

  1539.         display_def->width  = bytestream_get_be16(&buf) - display_def->x + 1;

  1540.         display_def->y = bytestream_get_be16(&buf);

  1541.         display_def->height = bytestream_get_be16(&buf) - display_def->y + 1;

  1542.     }

  1543. 

  1544.     return 0;

  1545. }

  1546. 

  1547. static int dvbsub_display_end_segment(AVCodecContext *avctx, const uint8_t *buf,

  1548.                                       int buf_size, AVSubtitle *sub,int *got_output)

  1549. {

  1550.     DVBSubContext *ctx = avctx->priv_data;

  1551. 

  1552.     if(ctx->compute_edt == 0)

  1553.         save_subtitle_set(avctx, sub, got_output);

  1554. #ifdef DEBUG

  1555.     save_display_set(ctx);

  1556. #endif

  1557.     return 0;

  1558. }

  1559. 

  1560. static int dvbsub_decode(AVCodecContext *avctx,

  1561.                          void *data, int *data_size,

  1562.                          AVPacket *avpkt)

  1563. {

  1564.     const uint8_t *buf = avpkt->data;

  1565.     int buf_size = avpkt->size;

  1566.     DVBSubContext *ctx = avctx->priv_data;

  1567.     AVSubtitle *sub = data;

  1568.     const uint8_t *p, *p_end;

  1569.     int segment_type;

  1570.     int page_id;

  1571.     int segment_length;

  1572.     int i;

  1573.     int ret = 0;

  1574.     int got_segment = 0;

  1575.     int got_dds = 0;

  1576. 

  1577.     ff_dlog(avctx, "DVB sub packet:\n");

  1578. 

  1579.     for (i=0; i < buf_size; i++) {

  1580.         ff_dlog(avctx, "%02x ", buf[i]);

  1581.         if (i % 16 == 15)

  1582.             ff_dlog(avctx, "\n");

  1583.     }

  1584. 

  1585.     if (i % 16)

  1586.         ff_dlog(avctx, "\n");

  1587. 

  1588.     if (buf_size <= 6 || *buf != 0x0f) {

  1589.         ff_dlog(avctx, "incomplete or broken packet");

  1590.         return AVERROR_INVALIDDATA;

  1591.     }

  1592. 

  1593.     p = buf;

  1594.     p_end = buf + buf_size;

  1595. 

  1596.     while (p_end - p >= 6 && *p == 0x0f) {

  1597.         p += 1;

  1598.         segment_type = *p++;

  1599.         page_id = AV_RB16(p);

  1600.         p += 2;

  1601.         segment_length = AV_RB16(p);

  1602.         p += 2;

  1603. 

  1604.         if (avctx->debug & FF_DEBUG_STARTCODE) {

  1605.             av_log(avctx, AV_LOG_DEBUG, "segment_type:%d page_id:%d segment_length:%d\n", segment_type, page_id, segment_length);

  1606.         }

  1607. 

  1608.         if (p_end - p < segment_length) {

  1609.             ff_dlog(avctx, "incomplete or broken packet");

  1610.             ret = -1;

  1611.             goto end;

  1612.         }

  1613. 

  1614.         if (page_id == ctx->composition_id || page_id == ctx->ancillary_id ||

  1615.             ctx->composition_id == -1 || ctx->ancillary_id == -1) {

  1616.             int ret = 0;

  1617.             switch (segment_type) {

  1618.             case DVBSUB_PAGE_SEGMENT:

  1619.                 ret = dvbsub_parse_page_segment(avctx, p, segment_length, sub, data_size);

  1620.                 got_segment |= 1;

  1621.                 break;

  1622.             case DVBSUB_REGION_SEGMENT:

  1623.                 ret = dvbsub_parse_region_segment(avctx, p, segment_length);

  1624.                 got_segment |= 2;

  1625.                 break;

  1626.             case DVBSUB_CLUT_SEGMENT:

  1627.                 ret = dvbsub_parse_clut_segment(avctx, p, segment_length);

  1628.                 if (ret < 0) goto end;

  1629.                 got_segment |= 4;

  1630.                 break;

  1631.             case DVBSUB_OBJECT_SEGMENT:

  1632.                 ret = dvbsub_parse_object_segment(avctx, p, segment_length);

  1633.                 got_segment |= 8;

  1634.                 break;

  1635.             case DVBSUB_DISPLAYDEFINITION_SEGMENT:

  1636.                 ret = dvbsub_parse_display_definition_segment(avctx, p,

  1637.                                                               segment_length);

  1638.                 got_dds = 1;

  1639.                 break;

  1640.             case DVBSUB_DISPLAY_SEGMENT:

  1641.                 ret = dvbsub_display_end_segment(avctx, p, segment_length, sub, data_size);

  1642.                 if (got_segment == 15 && !got_dds && !avctx->width && !avctx->height) {

  1643.                     // Default from ETSI EN 300 743 V1.3.1 (7.2.1)

  1644.                     avctx->width  = 720;

  1645.                     avctx->height = 576;

  1646.                 }

  1647.                 got_segment |= 16;

  1648.                 break;

  1649.             default:

  1650.                 ff_dlog(avctx, "Subtitling segment type 0x%x, page id %d, length %d\n",

  1651.                         segment_type, page_id, segment_length);

  1652.                 break;

  1653.             }

  1654.             if (ret < 0)

  1655.                 goto end;

  1656.         }

  1657. 

  1658.         p += segment_length;

  1659.     }

  1660.     // Some streams do not send a display segment but if we have all the other

  1661.     // segments then we need no further data.

  1662.     if (got_segment == 15) {

  1663.         av_log(avctx, AV_LOG_DEBUG, "Missing display_end_segment, emulating\n");

  1664.         dvbsub_display_end_segment(avctx, p, 0, sub, data_size);

  1665.     }

  1666. 

  1667. end:

  1668.     if(ret < 0) {

  1669.         *data_size = 0;

  1670.         avsubtitle_free(sub);

  1671.         return ret;

  1672.     } else {

  1673.         if(ctx->compute_edt == 1 )

  1674.             FFSWAP(int64_t, ctx->prev_start, sub->pts);

  1675.     }

  1676. 

  1677.     return p - buf;

  1678. }

  1679. 

  1680. #define DS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_SUBTITLE_PARAM

  1681. static const AVOption options[] = {

  1682.     {"compute_edt", "compute end of time using pts or timeout", offsetof(DVBSubContext, compute_edt), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DS},

  1683.     {"compute_clut", "compute clut when not available(-1) or always(1) or never(0)", offsetof(DVBSubContext, compute_clut), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, DS},

  1684.     {"dvb_substream", "", offsetof(DVBSubContext, substream), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, DS},

  1685.     {NULL}

  1686. };

  1687. static const AVClass dvbsubdec_class = {

  1688.     .class_name = "DVB Sub Decoder",

  1689.     .item_name  = av_default_item_name,

  1690.     .option     = options,

  1691.     .version    = LIBAVUTIL_VERSION_INT,

  1692. };

  1693. 

  1694. AVCodec ff_dvbsub_decoder = {

  1695.     .name           = "dvbsub",

  1696.     .long_name      = NULL_IF_CONFIG_SMALL("DVB subtitles"),

  1697.     .type           = AVMEDIA_TYPE_SUBTITLE,

  1698.     .id             = AV_CODEC_ID_DVB_SUBTITLE,

  1699.     .priv_data_size = sizeof(DVBSubContext),

  1700.     .init           = dvbsub_init_decoder,

  1701.     .close          = dvbsub_close_decoder,

  1702.     .decode         = dvbsub_decode,

  1703.     .priv_class     = &dvbsubdec_class,

  1704. };