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.
85274 Commits
32 Branches
283MB
Tree: b02027c79d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b02027c79d'
${ noResults }
FFmpeg/libavcodec/dvbsubdec.c

1703 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. #define RGBA(r,g,b,a) (((unsigned)(a) << 24) | ((r) << 16) | ((g) << 8) | (b))

  39. 

  40. typedef struct DVBSubCLUT {

  41.     int id;

  42.     int version;

  43. 

  44.     uint32_t clut4[4];

  45.     uint32_t clut16[16];

  46.     uint32_t clut256[256];

  47. 

  48.     struct DVBSubCLUT *next;

  49. } DVBSubCLUT;

  50. 

  51. static DVBSubCLUT default_clut;

  52. 

  53. typedef struct DVBSubObjectDisplay {

  54.     int object_id;

  55.     int region_id;

  56. 

  57.     int x_pos;

  58.     int y_pos;

  59. 

  60.     int fgcolor;

  61.     int bgcolor;

  62. 

  63.     struct DVBSubObjectDisplay *region_list_next;

  64.     struct DVBSubObjectDisplay *object_list_next;

  65. } DVBSubObjectDisplay;

  66. 

  67. typedef struct DVBSubObject {

  68.     int id;

  69.     int version;

  70. 

  71.     int type;

  72. 

  73.     DVBSubObjectDisplay *display_list;

  74. 

  75.     struct DVBSubObject *next;

  76. } DVBSubObject;

  77. 

  78. typedef struct DVBSubRegionDisplay {

  79.     int region_id;

  80. 

  81.     int x_pos;

  82.     int y_pos;

  83. 

  84.     struct DVBSubRegionDisplay *next;

  85. } DVBSubRegionDisplay;

  86. 

  87. typedef struct DVBSubRegion {

  88.     int id;

  89.     int version;

  90. 

  91.     int width;

  92.     int height;

  93.     int depth;

  94. 

  95.     int clut;

  96.     int bgcolor;

  97. 

  98.     uint8_t *pbuf;

  99.     int buf_size;

  100.     int dirty;

  101. 

  102.     DVBSubObjectDisplay *display_list;

  103. 

  104.     struct DVBSubRegion *next;

  105. } DVBSubRegion;

  106. 

  107. typedef struct DVBSubDisplayDefinition {

  108.     int version;

  109. 

  110.     int x;

  111.     int y;

  112.     int width;

  113.     int height;

  114. } DVBSubDisplayDefinition;

  115. 

  116. typedef struct DVBSubContext {

  117.     AVClass *class;

  118.     int composition_id;

  119.     int ancillary_id;

  120. 

  121.     int version;

  122.     int time_out;

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

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

  125.     int compute_clut;

  126.     int substream;

  127.     int64_t prev_start;

  128.     DVBSubRegion *region_list;

  129.     DVBSubCLUT   *clut_list;

  130.     DVBSubObject *object_list;

  131. 

  132.     DVBSubRegionDisplay *display_list;

  133.     DVBSubDisplayDefinition *display_definition;

  134. } DVBSubContext;

  135. 

  136. 

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

  138. {

  139.     DVBSubObject *ptr = ctx->object_list;

  140. 

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

  142.         ptr = ptr->next;

  143.     }

  144. 

  145.     return ptr;

  146. }

  147. 

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

  149. {

  150.     DVBSubCLUT *ptr = ctx->clut_list;

  151. 

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

  153.         ptr = ptr->next;

  154.     }

  155. 

  156.     return ptr;

  157. }

  158. 

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

  160. {

  161.     DVBSubRegion *ptr = ctx->region_list;

  162. 

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

  164.         ptr = ptr->next;

  165.     }

  166. 

  167.     return ptr;

  168. }

  169. 

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

  171. {

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

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

  174. 

  175.     while (region->display_list) {

  176.         display = region->display_list;

  177. 

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

  179. 

  180.         if (object) {

  181.             obj_disp_ptr = &object->display_list;

  182.             obj_disp = *obj_disp_ptr;

  183. 

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

  185.                 obj_disp_ptr = &obj_disp->object_list_next;

  186.                 obj_disp = *obj_disp_ptr;

  187.             }

  188. 

  189.             if (obj_disp) {

  190.                 *obj_disp_ptr = obj_disp->object_list_next;

  191. 

  192.                 if (!object->display_list) {

  193.                     obj2_ptr = &ctx->object_list;

  194.                     obj2 = *obj2_ptr;

  195. 

  196.                     while (obj2 != object) {

  197.                         av_assert0(obj2);

  198.                         obj2_ptr = &obj2->next;

  199.                         obj2 = *obj2_ptr;

  200.                     }

  201. 

  202.                     *obj2_ptr = obj2->next;

  203. 

  204.                     av_freep(&obj2);

  205.                 }

  206.             }

  207.         }

  208. 

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

  210. 

  211.         av_freep(&display);

  212.     }

  213. 

  214. }

  215. 

  216. static void delete_cluts(DVBSubContext *ctx)

  217. {

  218.     while (ctx->clut_list) {

  219.         DVBSubCLUT *clut = ctx->clut_list;

  220. 

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

  222. 

  223.         av_freep(&clut);

  224.     }

  225. }

  226. 

  227. static void delete_objects(DVBSubContext *ctx)

  228. {

  229.     while (ctx->object_list) {

  230.         DVBSubObject *object = ctx->object_list;

  231. 

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

  233. 

  234.         av_freep(&object);

  235.     }

  236. }

  237. 

  238. static void delete_regions(DVBSubContext *ctx)

  239. {

  240.     while (ctx->region_list) {

  241.         DVBSubRegion *region = ctx->region_list;

  242. 

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

  244. 

  245.         delete_region_display_list(ctx, region);

  246. 

  247.         av_freep(&region->pbuf);

  248.         av_freep(&region);

  249.     }

  250. }

  251. 

  252. static av_cold int dvbsub_init_decoder(AVCodecContext *avctx)

  253. {

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

  255.     DVBSubContext *ctx = avctx->priv_data;

  256. 

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

  258.         ctx->composition_id = -1;

  259.         ctx->ancillary_id   = -1;

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

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

  262.         ctx->composition_id = -1;

  263.         ctx->ancillary_id   = -1;

  264.     } else {

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

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

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

  268.         } else {

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

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

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

  272.         }

  273.     }

  274. 

  275.     ctx->version = -1;

  276.     ctx->prev_start = AV_NOPTS_VALUE;

  277. 

  278.     default_clut.id = -1;

  279.     default_clut.next = NULL;

  280. 

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

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

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

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

  285. 

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

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

  288.         if (i < 8) {

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

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

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

  292.         } else {

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

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

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

  296.         }

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

  298.     }

  299. 

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

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

  302.         if (i < 8) {

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

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

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

  306.             a = 63;

  307.         } else {

  308.             switch (i & 0x88) {

  309.             case 0x00:

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

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

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

  313.                 a = 255;

  314.                 break;

  315.             case 0x08:

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

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

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

  319.                 a = 127;

  320.                 break;

  321.             case 0x80:

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

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

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

  325.                 a = 255;

  326.                 break;

  327.             case 0x88:

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

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

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

  331.                 a = 255;

  332.                 break;

  333.             }

  334.         }

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

  336.     }

  337. 

  338.     return 0;

  339. }

  340. 

  341. static av_cold int dvbsub_close_decoder(AVCodecContext *avctx)

  342. {

  343.     DVBSubContext *ctx = avctx->priv_data;

  344.     DVBSubRegionDisplay *display;

  345. 

  346.     delete_regions(ctx);

  347. 

  348.     delete_objects(ctx);

  349. 

  350.     delete_cluts(ctx);

  351. 

  352.     av_freep(&ctx->display_definition);

  353. 

  354.     while (ctx->display_list) {

  355.         display = ctx->display_list;

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

  357. 

  358.         av_freep(&display);

  359.     }

  360. 

  361.     return 0;

  362. }

  363. 

  364. static int dvbsub_read_2bit_string(AVCodecContext *avctx,

  365.                                    uint8_t *destbuf, int dbuf_len,

  366.                                    const uint8_t **srcbuf, int buf_size,

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

  368. {

  369.     GetBitContext gb;

  370. 

  371.     int bits;

  372.     int run_length;

  373.     int pixels_read = x_pos;

  374. 

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

  376. 

  377.     destbuf += x_pos;

  378. 

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

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

  381. 

  382.         if (bits) {

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

  384.                 if (map_table)

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

  386.                 else

  387.                     *destbuf++ = bits;

  388.             }

  389.             pixels_read++;

  390.         } else {

  391.             bits = get_bits1(&gb);

  392.             if (bits == 1) {

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

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

  395. 

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

  397.                     pixels_read += run_length;

  398.                 else {

  399.                     if (map_table)

  400.                         bits = map_table[bits];

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

  402.                         *destbuf++ = bits;

  403.                         pixels_read++;

  404.                     }

  405.                 }

  406.             } else {

  407.                 bits = get_bits1(&gb);

  408.                 if (bits == 0) {

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

  410.                     if (bits == 2) {

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

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

  413. 

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

  415.                             pixels_read += run_length;

  416.                         else {

  417.                             if (map_table)

  418.                                 bits = map_table[bits];

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

  420.                                 *destbuf++ = bits;

  421.                                 pixels_read++;

  422.                             }

  423.                         }

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

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

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

  427. 

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

  429.                             pixels_read += run_length;

  430.                         else {

  431.                             if (map_table)

  432.                                 bits = map_table[bits];

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

  434.                                 *destbuf++ = bits;

  435.                                 pixels_read++;

  436.                             }

  437.                         }

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

  439.                         if (map_table)

  440.                             bits = map_table[0];

  441.                         else

  442.                             bits = 0;

  443.                         run_length = 2;

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

  445.                             *destbuf++ = bits;

  446.                             pixels_read++;

  447.                         }

  448.                     } else {

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

  450.                         return pixels_read;

  451.                     }

  452.                 } else {

  453.                     if (map_table)

  454.                         bits = map_table[0];

  455.                     else

  456.                         bits = 0;

  457.                     *destbuf++ = bits;

  458.                     pixels_read++;

  459.                 }

  460.             }

  461.         }

  462.     }

  463. 

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

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

  466. 

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

  468. 

  469.     return pixels_read;

  470. }

  471. 

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

  473.                                    const uint8_t **srcbuf, int buf_size,

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

  475. {

  476.     GetBitContext gb;

  477. 

  478.     int bits;

  479.     int run_length;

  480.     int pixels_read = x_pos;

  481. 

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

  483. 

  484.     destbuf += x_pos;

  485. 

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

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

  488. 

  489.         if (bits) {

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

  491.                 if (map_table)

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

  493.                 else

  494.                     *destbuf++ = bits;

  495.             }

  496.             pixels_read++;

  497.         } else {

  498.             bits = get_bits1(&gb);

  499.             if (bits == 0) {

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

  501. 

  502.                 if (run_length == 0) {

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

  504.                     return pixels_read;

  505.                 }

  506. 

  507.                 run_length += 2;

  508. 

  509.                 if (map_table)

  510.                     bits = map_table[0];

  511.                 else

  512.                     bits = 0;

  513. 

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

  515.                     *destbuf++ = bits;

  516.                     pixels_read++;

  517.                 }

  518.             } else {

  519.                 bits = get_bits1(&gb);

  520.                 if (bits == 0) {

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

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

  523. 

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

  525.                         pixels_read += run_length;

  526.                     else {

  527.                         if (map_table)

  528.                             bits = map_table[bits];

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

  530.                             *destbuf++ = bits;

  531.                             pixels_read++;

  532.                         }

  533.                     }

  534.                 } else {

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

  536.                     if (bits == 2) {

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

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

  539. 

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

  541.                             pixels_read += run_length;

  542.                         else {

  543.                             if (map_table)

  544.                                 bits = map_table[bits];

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

  546.                                 *destbuf++ = bits;

  547.                                 pixels_read++;

  548.                             }

  549.                         }

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

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

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

  553. 

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

  555.                             pixels_read += run_length;

  556.                         else {

  557.                             if (map_table)

  558.                                 bits = map_table[bits];

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

  560.                                 *destbuf++ = bits;

  561.                                 pixels_read++;

  562.                             }

  563.                         }

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

  565.                         if (map_table)

  566.                             bits = map_table[0];

  567.                         else

  568.                             bits = 0;

  569.                         run_length = 2;

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

  571.                             *destbuf++ = bits;

  572.                             pixels_read++;

  573.                         }

  574.                     } else {

  575.                         if (map_table)

  576.                             bits = map_table[0];

  577.                         else

  578.                             bits = 0;

  579.                         *destbuf++ = bits;

  580.                         pixels_read ++;

  581.                     }

  582.                 }

  583.             }

  584.         }

  585.     }

  586. 

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

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

  589. 

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

  591. 

  592.     return pixels_read;

  593. }

  594. 

  595. static int dvbsub_read_8bit_string(AVCodecContext *avctx,

  596.                                    uint8_t *destbuf, int dbuf_len,

  597.                                     const uint8_t **srcbuf, int buf_size,

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

  599. {

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

  601.     int bits;

  602.     int run_length;

  603.     int pixels_read = x_pos;

  604. 

  605.     destbuf += x_pos;

  606. 

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

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

  609. 

  610.         if (bits) {

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

  612.                 if (map_table)

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

  614.                 else

  615.                     *destbuf++ = bits;

  616.             }

  617.             pixels_read++;

  618.         } else {

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

  620.             run_length = bits & 0x7f;

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

  622.                 if (run_length == 0) {

  623.                     return pixels_read;

  624.                 }

  625. 

  626.                 bits = 0;

  627.             } else {

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

  629.             }

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

  631.                 pixels_read += run_length;

  632.             else {

  633.                 if (map_table)

  634.                     bits = map_table[bits];

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

  636.                     *destbuf++ = bits;

  637.                     pixels_read++;

  638.                 }

  639.             }

  640.         }

  641.     }

  642. 

  643.     if (*(*srcbuf)++)

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

  645. 

  646.     return pixels_read;

  647. }

  648. 

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

  650. {

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

  652.     uint8_t list_inv[256];

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

  654.     int count, i, x, y;

  655. 

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

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

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

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

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

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

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

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

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

  665.         }

  666.     }

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

  668. 

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

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

  671.         int bestscore = 0;

  672.         int bestv = 0;

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

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

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

  676.                 int l_m = list[v];

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

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

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

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

  681.                 int score;

  682.                 if (l_m)

  683.                     continue;

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

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

  686.                 if (score > bestscore) {

  687.                     bestscore = score;

  688.                     bestv = v;

  689.                 }

  690.             }

  691.         }

  692.         if (!bestscore)

  693.             break;

  694.         list    [ bestv ] = 1;

  695.         list_inv[     i ] = bestv;

  696.     }

  697. 

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

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

  700.         int v = i*255/count;

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

  702.     }

  703. }

  704. 

  705. 

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

  707. {

  708.     DVBSubContext *ctx = avctx->priv_data;

  709.     DVBSubRegionDisplay *display;

  710.     DVBSubDisplayDefinition *display_def = ctx->display_definition;

  711.     DVBSubRegion *region;

  712.     AVSubtitleRect *rect;

  713.     DVBSubCLUT *clut;

  714.     uint32_t *clut_table;

  715.     int i;

  716.     int offset_x=0, offset_y=0;

  717.     int ret = 0;

  718. 

  719. 

  720.     if (display_def) {

  721.         offset_x = display_def->x;

  722.         offset_y = display_def->y;

  723.     }

  724. 

  725.     /* Not touching AVSubtitles again*/

  726.     if(sub->num_rects) {

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

  728.         return AVERROR_PATCHWELCOME;

  729.     }

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

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

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

  733.             sub->num_rects++;

  734.     }

  735. 

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

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

  738.         *got_output = 1;

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

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

  741.         *got_output = 1;

  742.     }

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

  744. 

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

  746.         if (!sub->rects) {

  747.             ret = AVERROR(ENOMEM);

  748.             goto fail;

  749.         }

  750. 

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

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

  753. 

  754.         i = 0;

  755. 

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

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

  758. 

  759.             if (!region)

  760.                 continue;

  761. 

  762.             if (!region->dirty)

  763.                 continue;

  764. 

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

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

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

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

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

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

  771.             rect->type      = SUBTITLE_BITMAP;

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

  773. 

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

  775. 

  776.             if (!clut)

  777.                 clut = &default_clut;

  778. 

  779.             switch (region->depth) {

  780.             case 2:

  781.                 clut_table = clut->clut4;

  782.                 break;

  783.             case 8:

  784.                 clut_table = clut->clut256;

  785.                 break;

  786.             case 4:

  787.             default:

  788.                 clut_table = clut->clut16;

  789.                 break;

  790.             }

  791. 

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

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

  794.                 ret = AVERROR(ENOMEM);

  795.                 goto fail;

  796.             }

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

  798. 

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

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

  801.                 ret = AVERROR(ENOMEM);

  802.                 goto fail;

  803.             }

  804. 

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

  806. 

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

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

  809. 

  810. #if FF_API_AVPICTURE

  811. FF_DISABLE_DEPRECATION_WARNINGS

  812. {

  813.             int j;

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

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

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

  817.             }

  818. }

  819. FF_ENABLE_DEPRECATION_WARNINGS

  820. #endif

  821. 

  822.             i++;

  823.         }

  824.     }

  825. 

  826.     return 0;

  827. fail:

  828.     if (sub->rects) {

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

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

  831.             if (rect) {

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

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

  834.             }

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

  836.         }

  837.         av_freep(&sub->rects);

  838.     }

  839.     sub->num_rects = 0;

  840.     return ret;

  841. }

  842. 

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

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

  845. {

  846.     DVBSubContext *ctx = avctx->priv_data;

  847. 

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

  849.     const uint8_t *buf_end = buf + buf_size;

  850.     uint8_t *pbuf;

  851.     int x_pos, y_pos;

  852.     int i;

  853. 

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

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

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

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

  858.     uint8_t *map_table;

  859. 

  860. #if 0

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

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

  863. 

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

  865.         if (i % 16 == 0)

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

  867. 

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

  869.         if (i % 16 == 15)

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

  871.     }

  872. 

  873.     if (i % 16)

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

  875. #endif

  876. 

  877.     if (!region)

  878.         return;

  879. 

  880.     pbuf = region->pbuf;

  881.     region->dirty = 1;

  882. 

  883.     x_pos = display->x_pos;

  884.     y_pos = display->y_pos;

  885. 

  886.     y_pos += top_bottom;

  887. 

  888.     while (buf < buf_end) {

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

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

  891.             return;

  892.         }

  893. 

  894.         switch (*buf++) {

  895.         case 0x10:

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

  897.                 map_table = map2to8;

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

  899.                 map_table = map2to4;

  900.             else

  901.                 map_table = NULL;

  902. 

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

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

  905.                                             non_mod, map_table, x_pos);

  906.             break;

  907.         case 0x11:

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

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

  910.                 return;

  911.             }

  912. 

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

  914.                 map_table = map4to8;

  915.             else

  916.                 map_table = NULL;

  917. 

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

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

  920.                                             non_mod, map_table, x_pos);

  921.             break;

  922.         case 0x12:

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

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

  925.                 return;

  926.             }

  927. 

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

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

  930.                                             non_mod, NULL, x_pos);

  931.             break;

  932. 

  933.         case 0x20:

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

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

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

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

  938.             break;

  939.         case 0x21:

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

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

  942.             break;

  943.         case 0x22:

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

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

  946.             break;

  947. 

  948.         case 0xf0:

  949.             x_pos = display->x_pos;

  950.             y_pos += 2;

  951.             break;

  952.         default:

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

  954.         }

  955.     }

  956. 

  957. }

  958. 

  959. static int dvbsub_parse_object_segment(AVCodecContext *avctx,

  960.                                        const uint8_t *buf, int buf_size)

  961. {

  962.     DVBSubContext *ctx = avctx->priv_data;

  963. 

  964.     const uint8_t *buf_end = buf + buf_size;

  965.     int object_id;

  966.     DVBSubObject *object;

  967.     DVBSubObjectDisplay *display;

  968.     int top_field_len, bottom_field_len;

  969. 

  970.     int coding_method, non_modifying_color;

  971. 

  972.     object_id = AV_RB16(buf);

  973.     buf += 2;

  974. 

  975.     object = get_object(ctx, object_id);

  976. 

  977.     if (!object)

  978.         return AVERROR_INVALIDDATA;

  979. 

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

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

  982. 

  983.     if (coding_method == 0) {

  984.         top_field_len = AV_RB16(buf);

  985.         buf += 2;

  986.         bottom_field_len = AV_RB16(buf);

  987.         buf += 2;

  988. 

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

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

  991.             return AVERROR_INVALIDDATA;

  992.         }

  993. 

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

  995.             const uint8_t *block = buf;

  996.             int bfl = bottom_field_len;

  997. 

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

  999.                                             non_modifying_color);

  1000. 

  1001.             if (bottom_field_len > 0)

  1002.                 block = buf + top_field_len;

  1003.             else

  1004.                 bfl = top_field_len;

  1005. 

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

  1007.                                             non_modifying_color);

  1008.         }

  1009. 

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

  1011. 

  1012.     } else {

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

  1014.     }

  1015. 

  1016.     return 0;

  1017. }

  1018. 

  1019. static int dvbsub_parse_clut_segment(AVCodecContext *avctx,

  1020.                                      const uint8_t *buf, int buf_size)

  1021. {

  1022.     DVBSubContext *ctx = avctx->priv_data;

  1023. 

  1024.     const uint8_t *buf_end = buf + buf_size;

  1025.     int i, clut_id;

  1026.     int version;

  1027.     DVBSubCLUT *clut;

  1028.     int entry_id, depth , full_range;

  1029.     int y, cr, cb, alpha;

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

  1031. 

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

  1033. 

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

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

  1036.         if (i % 16 == 15)

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

  1038.     }

  1039. 

  1040.     if (i % 16)

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

  1042. 

  1043.     clut_id = *buf++;

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

  1045.     buf += 1;

  1046. 

  1047.     clut = get_clut(ctx, clut_id);

  1048. 

  1049.     if (!clut) {

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

  1051.         if (!clut)

  1052.             return AVERROR(ENOMEM);

  1053. 

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

  1055. 

  1056.         clut->id = clut_id;

  1057.         clut->version = -1;

  1058. 

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

  1060.         ctx->clut_list = clut;

  1061.     }

  1062. 

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

  1064. 

  1065.     clut->version = version;

  1066. 

  1067.     while (buf + 4 < buf_end) {

  1068.         entry_id = *buf++;

  1069. 

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

  1071. 

  1072.         if (depth == 0) {

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

  1074.         }

  1075. 

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

  1077. 

  1078.         if (full_range) {

  1079.             y = *buf++;

  1080.             cr = *buf++;

  1081.             cb = *buf++;

  1082.             alpha = *buf++;

  1083.         } else {

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

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

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

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

  1088. 

  1089.             buf += 2;

  1090.         }

  1091. 

  1092.         if (y == 0)

  1093.             alpha = 0xff;

  1094. 

  1095.         YUV_TO_RGB1_CCIR(cb, cr);

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

  1097. 

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

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

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

  1101.             if (avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL)

  1102.                 return AVERROR_INVALIDDATA;

  1103.         }

  1104. 

  1105.         if (depth & 0x80)

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

  1107.         else if (depth & 0x40)

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

  1109.         else if (depth & 0x20)

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

  1111.     }

  1112.     }

  1113. 

  1114.     return 0;

  1115. }

  1116. 

  1117. 

  1118. static int dvbsub_parse_region_segment(AVCodecContext *avctx,

  1119.                                        const uint8_t *buf, int buf_size)

  1120. {

  1121.     DVBSubContext *ctx = avctx->priv_data;

  1122. 

  1123.     const uint8_t *buf_end = buf + buf_size;

  1124.     int region_id, object_id;

  1125.     int av_unused version;

  1126.     DVBSubRegion *region;

  1127.     DVBSubObject *object;

  1128.     DVBSubObjectDisplay *display;

  1129.     int fill;

  1130. 

  1131.     if (buf_size < 10)

  1132.         return AVERROR_INVALIDDATA;

  1133. 

  1134.     region_id = *buf++;

  1135. 

  1136.     region = get_region(ctx, region_id);

  1137. 

  1138.     if (!region) {

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

  1140.         if (!region)

  1141.             return AVERROR(ENOMEM);

  1142. 

  1143.         region->id = region_id;

  1144.         region->version = -1;

  1145. 

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

  1147.         ctx->region_list = region;

  1148.     }

  1149. 

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

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

  1152. 

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

  1154.     buf += 2;

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

  1156.     buf += 2;

  1157. 

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

  1159.         av_free(region->pbuf);

  1160. 

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

  1162. 

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

  1164.         if (!region->pbuf) {

  1165.             region->buf_size =

  1166.             region->width =

  1167.             region->height = 0;

  1168.             return AVERROR(ENOMEM);

  1169.         }

  1170. 

  1171.         fill = 1;

  1172.         region->dirty = 0;

  1173.     }

  1174. 

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

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

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

  1178.         region->depth= 4;

  1179.     }

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

  1181. 

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

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

  1184.         buf += 1;

  1185.     } else {

  1186.         buf += 1;

  1187. 

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

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

  1190.         else

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

  1192.     }

  1193. 

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

  1195. 

  1196.     if (fill) {

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

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

  1199.     }

  1200. 

  1201.     delete_region_display_list(ctx, region);

  1202. 

  1203.     while (buf + 5 < buf_end) {

  1204.         object_id = AV_RB16(buf);

  1205.         buf += 2;

  1206. 

  1207.         object = get_object(ctx, object_id);

  1208. 

  1209.         if (!object) {

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

  1211.             if (!object)

  1212.                 return AVERROR(ENOMEM);

  1213. 

  1214.             object->id = object_id;

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

  1216.             ctx->object_list = object;

  1217.         }

  1218. 

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

  1220. 

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

  1222.         if (!display)

  1223.             return AVERROR(ENOMEM);

  1224. 

  1225.         display->object_id = object_id;

  1226.         display->region_id = region_id;

  1227. 

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

  1229.         buf += 2;

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

  1231.         buf += 2;

  1232. 

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

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

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

  1236.         }

  1237. 

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

  1239.         region->display_list = display;

  1240. 

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

  1242.         object->display_list = display;

  1243.     }

  1244. 

  1245.     return 0;

  1246. }

  1247. 

  1248. static int dvbsub_parse_page_segment(AVCodecContext *avctx,

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

  1250. {

  1251.     DVBSubContext *ctx = avctx->priv_data;

  1252.     DVBSubRegionDisplay *display;

  1253.     DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;

  1254. 

  1255.     const uint8_t *buf_end = buf + buf_size;

  1256.     int region_id;

  1257.     int page_state;

  1258.     int timeout;

  1259.     int version;

  1260. 

  1261.     if (buf_size < 1)

  1262.         return AVERROR_INVALIDDATA;

  1263. 

  1264.     timeout = *buf++;

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

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

  1267. 

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

  1269.         return 0;

  1270.     }

  1271. 

  1272.     ctx->time_out = timeout;

  1273.     ctx->version = version;

  1274. 

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

  1276. 

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

  1278.         save_subtitle_set(avctx, sub, got_output);

  1279. 

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

  1281.         delete_regions(ctx);

  1282.         delete_objects(ctx);

  1283.         delete_cluts(ctx);

  1284.     }

  1285. 

  1286.     tmp_display_list = ctx->display_list;

  1287.     ctx->display_list = NULL;

  1288. 

  1289.     while (buf + 5 < buf_end) {

  1290.         region_id = *buf++;

  1291.         buf += 1;

  1292. 

  1293.         display = tmp_display_list;

  1294.         tmp_ptr = &tmp_display_list;

  1295. 

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

  1297.             tmp_ptr = &display->next;

  1298.             display = display->next;

  1299.         }

  1300. 

  1301.         if (!display) {

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

  1303.             if (!display)

  1304.                 return AVERROR(ENOMEM);

  1305.         }

  1306. 

  1307.         display->region_id = region_id;

  1308. 

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

  1310.         buf += 2;

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

  1312.         buf += 2;

  1313. 

  1314.         *tmp_ptr = display->next;

  1315. 

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

  1317.         ctx->display_list = display;

  1318. 

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

  1320.     }

  1321. 

  1322.     while (tmp_display_list) {

  1323.         display = tmp_display_list;

  1324. 

  1325.         tmp_display_list = display->next;

  1326. 

  1327.         av_freep(&display);

  1328.     }

  1329. 

  1330.     return 0;

  1331. }

  1332. 

  1333. 

  1334. #ifdef DEBUG

  1335. static void png_save(DVBSubContext *ctx, const char *filename, uint32_t *bitmap, int w, int h)

  1336. {

  1337.     int x, y, v;

  1338.     FILE *f;

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

  1340.     char command[1024];

  1341. 

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

  1343. 

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

  1345.     if (!f) {

  1346.         perror(fname);

  1347.         return;

  1348.     }

  1349.     fprintf(f, "P6\n"

  1350.             "%d %d\n"

  1351.             "%d\n",

  1352.             w, h, 255);

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

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

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

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

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

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

  1359.         }

  1360.     }

  1361.     fclose(f);

  1362. 

  1363. 

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

  1365. 

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

  1367.     if (!f) {

  1368.         perror(fname2);

  1369.         return;

  1370.     }

  1371.     fprintf(f, "P5\n"

  1372.             "%d %d\n"

  1373.             "%d\n",

  1374.             w, h, 255);

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

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

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

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

  1379.         }

  1380.     }

  1381.     fclose(f);

  1382. 

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

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

  1385.         av_log(ctx, AV_LOG_ERROR, "Error running pnmtopng\n");

  1386.         return;

  1387.     }

  1388. 

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

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

  1391.         av_log(ctx, AV_LOG_ERROR, "Error removing %s and %s\n", fname, fname2);

  1392.         return;

  1393.     }

  1394. }

  1395. 

  1396. static int save_display_set(DVBSubContext *ctx)

  1397. {

  1398.     DVBSubRegion *region;

  1399.     DVBSubRegionDisplay *display;

  1400.     DVBSubCLUT *clut;

  1401.     uint32_t *clut_table;

  1402.     int x_pos, y_pos, width, height;

  1403.     int x, y, y_off, x_off;

  1404.     uint32_t *pbuf;

  1405.     char filename[32];

  1406.     static int fileno_index = 0;

  1407. 

  1408.     x_pos = -1;

  1409.     y_pos = -1;

  1410.     width = 0;

  1411.     height = 0;

  1412. 

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

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

  1415. 

  1416.         if (!region)

  1417.             return -1;

  1418. 

  1419.         if (x_pos == -1) {

  1420.             x_pos = display->x_pos;

  1421.             y_pos = display->y_pos;

  1422.             width = region->width;

  1423.             height = region->height;

  1424.         } else {

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

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

  1427.                 x_pos = display->x_pos;

  1428.             }

  1429. 

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

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

  1432.                 y_pos = display->y_pos;

  1433.             }

  1434. 

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

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

  1437.             }

  1438. 

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

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

  1441.             }

  1442.         }

  1443.     }

  1444. 

  1445.     if (x_pos >= 0) {

  1446. 

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

  1448.         if (!pbuf)

  1449.             return -1;

  1450. 

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

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

  1453. 

  1454.             if (!region)

  1455.                 return -1;

  1456. 

  1457.             x_off = display->x_pos - x_pos;

  1458.             y_off = display->y_pos - y_pos;

  1459. 

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

  1461. 

  1462.             if (!clut)

  1463.                 clut = &default_clut;

  1464. 

  1465.             switch (region->depth) {

  1466.             case 2:

  1467.                 clut_table = clut->clut4;

  1468.                 break;

  1469.             case 8:

  1470.                 clut_table = clut->clut256;

  1471.                 break;

  1472.             case 4:

  1473.             default:

  1474.                 clut_table = clut->clut16;

  1475.                 break;

  1476.             }

  1477. 

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

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

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

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

  1482.                 }

  1483.             }

  1484. 

  1485.         }

  1486. 

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

  1488. 

  1489.         png_save(ctx, filename, pbuf, width, height);

  1490. 

  1491.         av_freep(&pbuf);

  1492.     }

  1493. 

  1494.     fileno_index++;

  1495.     return 0;

  1496. }

  1497. #endif /* DEBUG */

  1498. 

  1499. static int dvbsub_parse_display_definition_segment(AVCodecContext *avctx,

  1500.                                                    const uint8_t *buf,

  1501.                                                    int buf_size)

  1502. {

  1503.     DVBSubContext *ctx = avctx->priv_data;

  1504.     DVBSubDisplayDefinition *display_def = ctx->display_definition;

  1505.     int dds_version, info_byte;

  1506. 

  1507.     if (buf_size < 5)

  1508.         return AVERROR_INVALIDDATA;

  1509. 

  1510.     info_byte   = bytestream_get_byte(&buf);

  1511.     dds_version = info_byte >> 4;

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

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

  1514. 

  1515.     if (!display_def) {

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

  1517.         if (!display_def)

  1518.             return AVERROR(ENOMEM);

  1519.         ctx->display_definition = display_def;

  1520.     }

  1521. 

  1522.     display_def->version = dds_version;

  1523.     display_def->x       = 0;

  1524.     display_def->y       = 0;

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

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

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

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

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

  1530.     }

  1531. 

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

  1533.         if (buf_size < 13)

  1534.             return AVERROR_INVALIDDATA;

  1535. 

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

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

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

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

  1540.     }

  1541. 

  1542.     return 0;

  1543. }

  1544. 

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

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

  1547. {

  1548.     DVBSubContext *ctx = avctx->priv_data;

  1549. 

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

  1551.         save_subtitle_set(avctx, sub, got_output);

  1552. #ifdef DEBUG

  1553.     save_display_set(ctx);

  1554. #endif

  1555.     return 0;

  1556. }

  1557. 

  1558. static int dvbsub_decode(AVCodecContext *avctx,

  1559.                          void *data, int *data_size,

  1560.                          AVPacket *avpkt)

  1561. {

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

  1563.     int buf_size = avpkt->size;

  1564.     DVBSubContext *ctx = avctx->priv_data;

  1565.     AVSubtitle *sub = data;

  1566.     const uint8_t *p, *p_end;

  1567.     int segment_type;

  1568.     int page_id;

  1569.     int segment_length;

  1570.     int i;

  1571.     int ret = 0;

  1572.     int got_segment = 0;

  1573.     int got_dds = 0;

  1574. 

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

  1576. 

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

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

  1579.         if (i % 16 == 15)

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

  1581.     }

  1582. 

  1583.     if (i % 16)

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

  1585. 

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

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

  1588.         return AVERROR_INVALIDDATA;

  1589.     }

  1590. 

  1591.     p = buf;

  1592.     p_end = buf + buf_size;

  1593. 

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

  1595.         p += 1;

  1596.         segment_type = *p++;

  1597.         page_id = AV_RB16(p);

  1598.         p += 2;

  1599.         segment_length = AV_RB16(p);

  1600.         p += 2;

  1601. 

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

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

  1604.         }

  1605. 

  1606.         if (p_end - p < segment_length) {

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

  1608.             ret = -1;

  1609.             goto end;

  1610.         }

  1611. 

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

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

  1614.             int ret = 0;

  1615.             switch (segment_type) {

  1616.             case DVBSUB_PAGE_SEGMENT:

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

  1618.                 got_segment |= 1;

  1619.                 break;

  1620.             case DVBSUB_REGION_SEGMENT:

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

  1622.                 got_segment |= 2;

  1623.                 break;

  1624.             case DVBSUB_CLUT_SEGMENT:

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

  1626.                 if (ret < 0) goto end;

  1627.                 got_segment |= 4;

  1628.                 break;

  1629.             case DVBSUB_OBJECT_SEGMENT:

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

  1631.                 got_segment |= 8;

  1632.                 break;

  1633.             case DVBSUB_DISPLAYDEFINITION_SEGMENT:

  1634.                 ret = dvbsub_parse_display_definition_segment(avctx, p,

  1635.                                                               segment_length);

  1636.                 got_dds = 1;

  1637.                 break;

  1638.             case DVBSUB_DISPLAY_SEGMENT:

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

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

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

  1642.                     avctx->width  = 720;

  1643.                     avctx->height = 576;

  1644.                 }

  1645.                 got_segment |= 16;

  1646.                 break;

  1647.             default:

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

  1649.                         segment_type, page_id, segment_length);

  1650.                 break;

  1651.             }

  1652.             if (ret < 0)

  1653.                 goto end;

  1654.         }

  1655. 

  1656.         p += segment_length;

  1657.     }

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

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

  1660.     if (got_segment == 15) {

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

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

  1663.     }

  1664. 

  1665. end:

  1666.     if(ret < 0) {

  1667.         *data_size = 0;

  1668.         avsubtitle_free(sub);

  1669.         return ret;

  1670.     } else {

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

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

  1673.     }

  1674. 

  1675.     return p - buf;

  1676. }

  1677. 

  1678. #define DS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_SUBTITLE_PARAM

  1679. static const AVOption options[] = {

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

  1681.     {"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},

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

  1683.     {NULL}

  1684. };

  1685. static const AVClass dvbsubdec_class = {

  1686.     .class_name = "DVB Sub Decoder",

  1687.     .item_name  = av_default_item_name,

  1688.     .option     = options,

  1689.     .version    = LIBAVUTIL_VERSION_INT,

  1690. };

  1691. 

  1692. AVCodec ff_dvbsub_decoder = {

  1693.     .name           = "dvbsub",

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

  1695.     .type           = AVMEDIA_TYPE_SUBTITLE,

  1696.     .id             = AV_CODEC_ID_DVB_SUBTITLE,

  1697.     .priv_data_size = sizeof(DVBSubContext),

  1698.     .init           = dvbsub_init_decoder,

  1699.     .close          = dvbsub_close_decoder,

  1700.     .decode         = dvbsub_decode,

  1701.     .priv_class     = &dvbsubdec_class,

  1702. };