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

1711 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/imgutils.h"

  28. #include "libavutil/opt.h"

  29. 

  30. #define DVBSUB_PAGE_SEGMENT     0x10

  31. #define DVBSUB_REGION_SEGMENT   0x11

  32. #define DVBSUB_CLUT_SEGMENT     0x12

  33. #define DVBSUB_OBJECT_SEGMENT   0x13

  34. #define DVBSUB_DISPLAYDEFINITION_SEGMENT 0x14

  35. #define DVBSUB_DISPLAY_SEGMENT  0x80

  36. 

  37. #define cm (ff_crop_tab + MAX_NEG_CROP)

  38. 

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

  40. 

  41. typedef struct DVBSubCLUT {

  42.     int id;

  43.     int version;

  44. 

  45.     uint32_t clut4[4];

  46.     uint32_t clut16[16];

  47.     uint32_t clut256[256];

  48. 

  49.     struct DVBSubCLUT *next;

  50. } DVBSubCLUT;

  51. 

  52. static DVBSubCLUT default_clut;

  53. 

  54. typedef struct DVBSubObjectDisplay {

  55.     int object_id;

  56.     int region_id;

  57. 

  58.     int x_pos;

  59.     int y_pos;

  60. 

  61.     int fgcolor;

  62.     int bgcolor;

  63. 

  64.     struct DVBSubObjectDisplay *region_list_next;

  65.     struct DVBSubObjectDisplay *object_list_next;

  66. } DVBSubObjectDisplay;

  67. 

  68. typedef struct DVBSubObject {

  69.     int id;

  70.     int version;

  71. 

  72.     int type;

  73. 

  74.     DVBSubObjectDisplay *display_list;

  75. 

  76.     struct DVBSubObject *next;

  77. } DVBSubObject;

  78. 

  79. typedef struct DVBSubRegionDisplay {

  80.     int region_id;

  81. 

  82.     int x_pos;

  83.     int y_pos;

  84. 

  85.     struct DVBSubRegionDisplay *next;

  86. } DVBSubRegionDisplay;

  87. 

  88. typedef struct DVBSubRegion {

  89.     int id;

  90.     int version;

  91. 

  92.     int width;

  93.     int height;

  94.     int depth;

  95. 

  96.     int clut;

  97.     int bgcolor;

  98. 

  99.     uint8_t *pbuf;

  100.     int buf_size;

  101.     int dirty;

  102. 

  103.     DVBSubObjectDisplay *display_list;

  104. 

  105.     struct DVBSubRegion *next;

  106. } DVBSubRegion;

  107. 

  108. typedef struct DVBSubDisplayDefinition {

  109.     int version;

  110. 

  111.     int x;

  112.     int y;

  113.     int width;

  114.     int height;

  115. } DVBSubDisplayDefinition;

  116. 

  117. typedef struct DVBSubContext {

  118.     AVClass *class;

  119.     int composition_id;

  120.     int ancillary_id;

  121. 

  122.     int version;

  123.     int time_out;

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

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

  126.     int compute_clut;

  127.     int substream;

  128.     int64_t prev_start;

  129.     DVBSubRegion *region_list;

  130.     DVBSubCLUT   *clut_list;

  131.     DVBSubObject *object_list;

  132. 

  133.     DVBSubRegionDisplay *display_list;

  134.     DVBSubDisplayDefinition *display_definition;

  135. } DVBSubContext;

  136. 

  137. 

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

  139. {

  140.     DVBSubObject *ptr = ctx->object_list;

  141. 

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

  143.         ptr = ptr->next;

  144.     }

  145. 

  146.     return ptr;

  147. }

  148. 

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

  150. {

  151.     DVBSubCLUT *ptr = ctx->clut_list;

  152. 

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

  154.         ptr = ptr->next;

  155.     }

  156. 

  157.     return ptr;

  158. }

  159. 

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

  161. {

  162.     DVBSubRegion *ptr = ctx->region_list;

  163. 

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

  165.         ptr = ptr->next;

  166.     }

  167. 

  168.     return ptr;

  169. }

  170. 

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

  172. {

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

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

  175. 

  176.     while (region->display_list) {

  177.         display = region->display_list;

  178. 

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

  180. 

  181.         if (object) {

  182.             obj_disp_ptr = &object->display_list;

  183.             obj_disp = *obj_disp_ptr;

  184. 

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

  186.                 obj_disp_ptr = &obj_disp->object_list_next;

  187.                 obj_disp = *obj_disp_ptr;

  188.             }

  189. 

  190.             if (obj_disp) {

  191.                 *obj_disp_ptr = obj_disp->object_list_next;

  192. 

  193.                 if (!object->display_list) {

  194.                     obj2_ptr = &ctx->object_list;

  195.                     obj2 = *obj2_ptr;

  196. 

  197.                     while (obj2 != object) {

  198.                         av_assert0(obj2);

  199.                         obj2_ptr = &obj2->next;

  200.                         obj2 = *obj2_ptr;

  201.                     }

  202. 

  203.                     *obj2_ptr = obj2->next;

  204. 

  205.                     av_freep(&obj2);

  206.                 }

  207.             }

  208.         }

  209. 

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

  211. 

  212.         av_freep(&display);

  213.     }

  214. 

  215. }

  216. 

  217. static void delete_cluts(DVBSubContext *ctx)

  218. {

  219.     while (ctx->clut_list) {

  220.         DVBSubCLUT *clut = ctx->clut_list;

  221. 

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

  223. 

  224.         av_freep(&clut);

  225.     }

  226. }

  227. 

  228. static void delete_objects(DVBSubContext *ctx)

  229. {

  230.     while (ctx->object_list) {

  231.         DVBSubObject *object = ctx->object_list;

  232. 

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

  234. 

  235.         av_freep(&object);

  236.     }

  237. }

  238. 

  239. static void delete_regions(DVBSubContext *ctx)

  240. {

  241.     while (ctx->region_list) {

  242.         DVBSubRegion *region = ctx->region_list;

  243. 

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

  245. 

  246.         delete_region_display_list(ctx, region);

  247. 

  248.         av_freep(&region->pbuf);

  249.         av_freep(&region);

  250.     }

  251. }

  252. 

  253. static av_cold int dvbsub_init_decoder(AVCodecContext *avctx)

  254. {

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

  256.     DVBSubContext *ctx = avctx->priv_data;

  257. 

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

  259.         ctx->composition_id = -1;

  260.         ctx->ancillary_id   = -1;

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

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

  263.         ctx->composition_id = -1;

  264.         ctx->ancillary_id   = -1;

  265.     } else {

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

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

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

  269.         } else {

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

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

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

  273.         }

  274.     }

  275. 

  276.     ctx->version = -1;

  277.     ctx->prev_start = AV_NOPTS_VALUE;

  278. 

  279.     default_clut.id = -1;

  280.     default_clut.next = NULL;

  281. 

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

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

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

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

  286. 

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

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

  289.         if (i < 8) {

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

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

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

  293.         } else {

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

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

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

  297.         }

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

  299.     }

  300. 

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

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

  303.         if (i < 8) {

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

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

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

  307.             a = 63;

  308.         } else {

  309.             switch (i & 0x88) {

  310.             case 0x00:

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

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

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

  314.                 a = 255;

  315.                 break;

  316.             case 0x08:

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

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

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

  320.                 a = 127;

  321.                 break;

  322.             case 0x80:

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

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

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

  326.                 a = 255;

  327.                 break;

  328.             case 0x88:

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

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

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

  332.                 a = 255;

  333.                 break;

  334.             }

  335.         }

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

  337.     }

  338. 

  339.     return 0;

  340. }

  341. 

  342. static av_cold int dvbsub_close_decoder(AVCodecContext *avctx)

  343. {

  344.     DVBSubContext *ctx = avctx->priv_data;

  345.     DVBSubRegionDisplay *display;

  346. 

  347.     delete_regions(ctx);

  348. 

  349.     delete_objects(ctx);

  350. 

  351.     delete_cluts(ctx);

  352. 

  353.     av_freep(&ctx->display_definition);

  354. 

  355.     while (ctx->display_list) {

  356.         display = ctx->display_list;

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

  358. 

  359.         av_freep(&display);

  360.     }

  361. 

  362.     return 0;

  363. }

  364. 

  365. static int dvbsub_read_2bit_string(AVCodecContext *avctx,

  366.                                    uint8_t *destbuf, int dbuf_len,

  367.                                    const uint8_t **srcbuf, int buf_size,

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

  369. {

  370.     GetBitContext gb;

  371. 

  372.     int bits;

  373.     int run_length;

  374.     int pixels_read = x_pos;

  375. 

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

  377. 

  378.     destbuf += x_pos;

  379. 

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

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

  382. 

  383.         if (bits) {

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

  385.                 if (map_table)

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

  387.                 else

  388.                     *destbuf++ = bits;

  389.             }

  390.             pixels_read++;

  391.         } else {

  392.             bits = get_bits1(&gb);

  393.             if (bits == 1) {

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

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

  396. 

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

  398.                     pixels_read += run_length;

  399.                 else {

  400.                     if (map_table)

  401.                         bits = map_table[bits];

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

  403.                         *destbuf++ = bits;

  404.                         pixels_read++;

  405.                     }

  406.                 }

  407.             } else {

  408.                 bits = get_bits1(&gb);

  409.                 if (bits == 0) {

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

  411.                     if (bits == 2) {

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

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

  414. 

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

  416.                             pixels_read += run_length;

  417.                         else {

  418.                             if (map_table)

  419.                                 bits = map_table[bits];

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

  421.                                 *destbuf++ = bits;

  422.                                 pixels_read++;

  423.                             }

  424.                         }

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

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

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

  428. 

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

  430.                             pixels_read += run_length;

  431.                         else {

  432.                             if (map_table)

  433.                                 bits = map_table[bits];

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

  435.                                 *destbuf++ = bits;

  436.                                 pixels_read++;

  437.                             }

  438.                         }

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

  440.                         if (map_table)

  441.                             bits = map_table[0];

  442.                         else

  443.                             bits = 0;

  444.                         run_length = 2;

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

  446.                             *destbuf++ = bits;

  447.                             pixels_read++;

  448.                         }

  449.                     } else {

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

  451.                         return pixels_read;

  452.                     }

  453.                 } else {

  454.                     if (map_table)

  455.                         bits = map_table[0];

  456.                     else

  457.                         bits = 0;

  458.                     *destbuf++ = bits;

  459.                     pixels_read++;

  460.                 }

  461.             }

  462.         }

  463.     }

  464. 

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

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

  467. 

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

  469. 

  470.     return pixels_read;

  471. }

  472. 

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

  474.                                    const uint8_t **srcbuf, int buf_size,

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

  476. {

  477.     GetBitContext gb;

  478. 

  479.     int bits;

  480.     int run_length;

  481.     int pixels_read = x_pos;

  482. 

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

  484. 

  485.     destbuf += x_pos;

  486. 

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

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

  489. 

  490.         if (bits) {

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

  492.                 if (map_table)

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

  494.                 else

  495.                     *destbuf++ = bits;

  496.             }

  497.             pixels_read++;

  498.         } else {

  499.             bits = get_bits1(&gb);

  500.             if (bits == 0) {

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

  502. 

  503.                 if (run_length == 0) {

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

  505.                     return pixels_read;

  506.                 }

  507. 

  508.                 run_length += 2;

  509. 

  510.                 if (map_table)

  511.                     bits = map_table[0];

  512.                 else

  513.                     bits = 0;

  514. 

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

  516.                     *destbuf++ = bits;

  517.                     pixels_read++;

  518.                 }

  519.             } else {

  520.                 bits = get_bits1(&gb);

  521.                 if (bits == 0) {

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

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

  524. 

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

  526.                         pixels_read += run_length;

  527.                     else {

  528.                         if (map_table)

  529.                             bits = map_table[bits];

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

  531.                             *destbuf++ = bits;

  532.                             pixels_read++;

  533.                         }

  534.                     }

  535.                 } else {

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

  537.                     if (bits == 2) {

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

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

  540. 

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

  542.                             pixels_read += run_length;

  543.                         else {

  544.                             if (map_table)

  545.                                 bits = map_table[bits];

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

  547.                                 *destbuf++ = bits;

  548.                                 pixels_read++;

  549.                             }

  550.                         }

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

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

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

  554. 

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

  556.                             pixels_read += run_length;

  557.                         else {

  558.                             if (map_table)

  559.                                 bits = map_table[bits];

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

  561.                                 *destbuf++ = bits;

  562.                                 pixels_read++;

  563.                             }

  564.                         }

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

  566.                         if (map_table)

  567.                             bits = map_table[0];

  568.                         else

  569.                             bits = 0;

  570.                         run_length = 2;

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

  572.                             *destbuf++ = bits;

  573.                             pixels_read++;

  574.                         }

  575.                     } else {

  576.                         if (map_table)

  577.                             bits = map_table[0];

  578.                         else

  579.                             bits = 0;

  580.                         *destbuf++ = bits;

  581.                         pixels_read ++;

  582.                     }

  583.                 }

  584.             }

  585.         }

  586.     }

  587. 

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

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

  590. 

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

  592. 

  593.     return pixels_read;

  594. }

  595. 

  596. static int dvbsub_read_8bit_string(AVCodecContext *avctx,

  597.                                    uint8_t *destbuf, int dbuf_len,

  598.                                     const uint8_t **srcbuf, int buf_size,

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

  600. {

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

  602.     int bits;

  603.     int run_length;

  604.     int pixels_read = x_pos;

  605. 

  606.     destbuf += x_pos;

  607. 

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

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

  610. 

  611.         if (bits) {

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

  613.                 if (map_table)

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

  615.                 else

  616.                     *destbuf++ = bits;

  617.             }

  618.             pixels_read++;

  619.         } else {

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

  621.             run_length = bits & 0x7f;

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

  623.                 if (run_length == 0) {

  624.                     return pixels_read;

  625.                 }

  626. 

  627.                 bits = 0;

  628.             } else {

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

  630.             }

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

  632.                 pixels_read += run_length;

  633.             else {

  634.                 if (map_table)

  635.                     bits = map_table[bits];

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

  637.                     *destbuf++ = bits;

  638.                     pixels_read++;

  639.                 }

  640.             }

  641.         }

  642.     }

  643. 

  644.     if (*(*srcbuf)++)

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

  646. 

  647.     return pixels_read;

  648. }

  649. 

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

  651. {

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

  653.     uint8_t list_inv[256];

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

  655.     int count, i, x, y;

  656. 

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

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

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

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

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

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

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

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

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

  666.         }

  667.     }

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

  669. 

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

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

  672.         int bestscore = 0;

  673.         int bestv = 0;

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

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

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

  677.                 int l_m = list[v];

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

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

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

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

  682.                 int score;

  683.                 if (l_m)

  684.                     continue;

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

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

  687.                 if (score > bestscore) {

  688.                     bestscore = score;

  689.                     bestv = v;

  690.                 }

  691.             }

  692.         }

  693.         if (!bestscore)

  694.             break;

  695.         list    [ bestv ] = 1;

  696.         list_inv[     i ] = bestv;

  697.     }

  698. 

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

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

  701.         int v = i*255/count;

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

  703.     }

  704. }

  705. 

  706. 

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

  708. {

  709.     DVBSubContext *ctx = avctx->priv_data;

  710.     DVBSubRegionDisplay *display;

  711.     DVBSubDisplayDefinition *display_def = ctx->display_definition;

  712.     DVBSubRegion *region;

  713.     AVSubtitleRect *rect;

  714.     DVBSubCLUT *clut;

  715.     uint32_t *clut_table;

  716.     int i;

  717.     int offset_x=0, offset_y=0;

  718.     int ret = 0;

  719. 

  720. 

  721.     if (display_def) {

  722.         offset_x = display_def->x;

  723.         offset_y = display_def->y;

  724.     }

  725. 

  726.     /* Not touching AVSubtitles again*/

  727.     if(sub->num_rects) {

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

  729.         return AVERROR_PATCHWELCOME;

  730.     }

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

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

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

  734.             sub->num_rects++;

  735.     }

  736. 

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

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

  739.         *got_output = 1;

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

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

  742.         *got_output = 1;

  743.     }

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

  745. 

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

  747.         if (!sub->rects) {

  748.             ret = AVERROR(ENOMEM);

  749.             goto fail;

  750.         }

  751. 

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

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

  754. 

  755.         i = 0;

  756. 

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

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

  759. 

  760.             if (!region)

  761.                 continue;

  762. 

  763.             if (!region->dirty)

  764.                 continue;

  765. 

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

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

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

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

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

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

  772.             rect->type      = SUBTITLE_BITMAP;

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

  774. 

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

  776. 

  777.             if (!clut)

  778.                 clut = &default_clut;

  779. 

  780.             switch (region->depth) {

  781.             case 2:

  782.                 clut_table = clut->clut4;

  783.                 break;

  784.             case 8:

  785.                 clut_table = clut->clut256;

  786.                 break;

  787.             case 4:

  788.             default:

  789.                 clut_table = clut->clut16;

  790.                 break;

  791.             }

  792. 

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

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

  795.                 ret = AVERROR(ENOMEM);

  796.                 goto fail;

  797.             }

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

  799. 

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

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

  802.                 ret = AVERROR(ENOMEM);

  803.                 goto fail;

  804.             }

  805. 

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

  807. 

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

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

  810. 

  811. #if FF_API_AVPICTURE

  812. FF_DISABLE_DEPRECATION_WARNINGS

  813. {

  814.             int j;

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

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

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

  818.             }

  819. }

  820. FF_ENABLE_DEPRECATION_WARNINGS

  821. #endif

  822. 

  823.             i++;

  824.         }

  825.     }

  826. 

  827.     return 0;

  828. fail:

  829.     if (sub->rects) {

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

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

  832.             if (rect) {

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

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

  835.             }

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

  837.         }

  838.         av_freep(&sub->rects);

  839.     }

  840.     sub->num_rects = 0;

  841.     return ret;

  842. }

  843. 

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

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

  846. {

  847.     DVBSubContext *ctx = avctx->priv_data;

  848. 

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

  850.     const uint8_t *buf_end = buf + buf_size;

  851.     uint8_t *pbuf;

  852.     int x_pos, y_pos;

  853.     int i;

  854. 

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

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

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

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

  859.     uint8_t *map_table;

  860. 

  861. #if 0

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

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

  864. 

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

  866.         if (i % 16 == 0)

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

  868. 

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

  870.         if (i % 16 == 15)

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

  872.     }

  873. 

  874.     if (i % 16)

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

  876. #endif

  877. 

  878.     if (!region)

  879.         return;

  880. 

  881.     pbuf = region->pbuf;

  882.     region->dirty = 1;

  883. 

  884.     x_pos = display->x_pos;

  885.     y_pos = display->y_pos;

  886. 

  887.     y_pos += top_bottom;

  888. 

  889.     while (buf < buf_end) {

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

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

  892.             return;

  893.         }

  894. 

  895.         switch (*buf++) {

  896.         case 0x10:

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

  898.                 map_table = map2to8;

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

  900.                 map_table = map2to4;

  901.             else

  902.                 map_table = NULL;

  903. 

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

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

  906.                                             non_mod, map_table, x_pos);

  907.             break;

  908.         case 0x11:

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

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

  911.                 return;

  912.             }

  913. 

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

  915.                 map_table = map4to8;

  916.             else

  917.                 map_table = NULL;

  918. 

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

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

  921.                                             non_mod, map_table, x_pos);

  922.             break;

  923.         case 0x12:

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

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

  926.                 return;

  927.             }

  928. 

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

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

  931.                                             non_mod, NULL, x_pos);

  932.             break;

  933. 

  934.         case 0x20:

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

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

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

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

  939.             break;

  940.         case 0x21:

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

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

  943.             break;

  944.         case 0x22:

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

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

  947.             break;

  948. 

  949.         case 0xf0:

  950.             x_pos = display->x_pos;

  951.             y_pos += 2;

  952.             break;

  953.         default:

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

  955.         }

  956.     }

  957. 

  958. }

  959. 

  960. static int dvbsub_parse_object_segment(AVCodecContext *avctx,

  961.                                        const uint8_t *buf, int buf_size)

  962. {

  963.     DVBSubContext *ctx = avctx->priv_data;

  964. 

  965.     const uint8_t *buf_end = buf + buf_size;

  966.     int object_id;

  967.     DVBSubObject *object;

  968.     DVBSubObjectDisplay *display;

  969.     int top_field_len, bottom_field_len;

  970. 

  971.     int coding_method, non_modifying_color;

  972. 

  973.     object_id = AV_RB16(buf);

  974.     buf += 2;

  975. 

  976.     object = get_object(ctx, object_id);

  977. 

  978.     if (!object)

  979.         return AVERROR_INVALIDDATA;

  980. 

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

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

  983. 

  984.     if (coding_method == 0) {

  985.         top_field_len = AV_RB16(buf);

  986.         buf += 2;

  987.         bottom_field_len = AV_RB16(buf);

  988.         buf += 2;

  989. 

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

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

  992.             return AVERROR_INVALIDDATA;

  993.         }

  994. 

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

  996.             const uint8_t *block = buf;

  997.             int bfl = bottom_field_len;

  998. 

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

  1000.                                             non_modifying_color);

  1001. 

  1002.             if (bottom_field_len > 0)

  1003.                 block = buf + top_field_len;

  1004.             else

  1005.                 bfl = top_field_len;

  1006. 

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

  1008.                                             non_modifying_color);

  1009.         }

  1010. 

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

  1012. 

  1013.     } else {

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

  1015.     }

  1016. 

  1017.     return 0;

  1018. }

  1019. 

  1020. static int dvbsub_parse_clut_segment(AVCodecContext *avctx,

  1021.                                      const uint8_t *buf, int buf_size)

  1022. {

  1023.     DVBSubContext *ctx = avctx->priv_data;

  1024. 

  1025.     const uint8_t *buf_end = buf + buf_size;

  1026.     int i, clut_id;

  1027.     int version;

  1028.     DVBSubCLUT *clut;

  1029.     int entry_id, depth , full_range;

  1030.     int y, cr, cb, alpha;

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

  1032. 

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

  1034. 

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

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

  1037.         if (i % 16 == 15)

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

  1039.     }

  1040. 

  1041.     if (i % 16)

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

  1043. 

  1044.     clut_id = *buf++;

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

  1046.     buf += 1;

  1047. 

  1048.     clut = get_clut(ctx, clut_id);

  1049. 

  1050.     if (!clut) {

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

  1052.         if (!clut)

  1053.             return AVERROR(ENOMEM);

  1054. 

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

  1056. 

  1057.         clut->id = clut_id;

  1058.         clut->version = -1;

  1059. 

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

  1061.         ctx->clut_list = clut;

  1062.     }

  1063. 

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

  1065. 

  1066.     clut->version = version;

  1067. 

  1068.     while (buf + 4 < buf_end) {

  1069.         entry_id = *buf++;

  1070. 

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

  1072. 

  1073.         if (depth == 0) {

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

  1075.         }

  1076. 

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

  1078. 

  1079.         if (full_range) {

  1080.             y = *buf++;

  1081.             cr = *buf++;

  1082.             cb = *buf++;

  1083.             alpha = *buf++;

  1084.         } else {

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

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

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

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

  1089. 

  1090.             buf += 2;

  1091.         }

  1092. 

  1093.         if (y == 0)

  1094.             alpha = 0xff;

  1095. 

  1096.         YUV_TO_RGB1_CCIR(cb, cr);

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

  1098. 

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

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

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

  1102.             if (avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL)

  1103.                 return AVERROR_INVALIDDATA;

  1104.         }

  1105. 

  1106.         if (depth & 0x80 && entry_id < 4)

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

  1108.         else if (depth & 0x40 && entry_id < 16)

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

  1110.         else if (depth & 0x20)

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

  1112.     }

  1113.     }

  1114. 

  1115.     return 0;

  1116. }

  1117. 

  1118. 

  1119. static int dvbsub_parse_region_segment(AVCodecContext *avctx,

  1120.                                        const uint8_t *buf, int buf_size)

  1121. {

  1122.     DVBSubContext *ctx = avctx->priv_data;

  1123. 

  1124.     const uint8_t *buf_end = buf + buf_size;

  1125.     int region_id, object_id;

  1126.     int av_unused version;

  1127.     DVBSubRegion *region;

  1128.     DVBSubObject *object;

  1129.     DVBSubObjectDisplay *display;

  1130.     int fill;

  1131.     int ret;

  1132. 

  1133.     if (buf_size < 10)

  1134.         return AVERROR_INVALIDDATA;

  1135. 

  1136.     region_id = *buf++;

  1137. 

  1138.     region = get_region(ctx, region_id);

  1139. 

  1140.     if (!region) {

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

  1142.         if (!region)

  1143.             return AVERROR(ENOMEM);

  1144. 

  1145.         region->id = region_id;

  1146.         region->version = -1;

  1147. 

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

  1149.         ctx->region_list = region;

  1150.     }

  1151. 

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

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

  1154. 

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

  1156.     buf += 2;

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

  1158.     buf += 2;

  1159. 

  1160.     ret = av_image_check_size(region->width, region->height, 0, avctx);

  1161.     if (ret < 0) {

  1162.         region->width= region->height= 0;

  1163.         return ret;

  1164.     }

  1165. 

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

  1167.         av_free(region->pbuf);

  1168. 

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

  1170. 

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

  1172.         if (!region->pbuf) {

  1173.             region->buf_size =

  1174.             region->width =

  1175.             region->height = 0;

  1176.             return AVERROR(ENOMEM);

  1177.         }

  1178. 

  1179.         fill = 1;

  1180.         region->dirty = 0;

  1181.     }

  1182. 

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

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

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

  1186.         region->depth= 4;

  1187.     }

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

  1189. 

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

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

  1192.         buf += 1;

  1193.     } else {

  1194.         buf += 1;

  1195. 

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

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

  1198.         else

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

  1200.     }

  1201. 

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

  1203. 

  1204.     if (fill) {

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

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

  1207.     }

  1208. 

  1209.     delete_region_display_list(ctx, region);

  1210. 

  1211.     while (buf + 5 < buf_end) {

  1212.         object_id = AV_RB16(buf);

  1213.         buf += 2;

  1214. 

  1215.         object = get_object(ctx, object_id);

  1216. 

  1217.         if (!object) {

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

  1219.             if (!object)

  1220.                 return AVERROR(ENOMEM);

  1221. 

  1222.             object->id = object_id;

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

  1224.             ctx->object_list = object;

  1225.         }

  1226. 

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

  1228. 

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

  1230.         if (!display)

  1231.             return AVERROR(ENOMEM);

  1232. 

  1233.         display->object_id = object_id;

  1234.         display->region_id = region_id;

  1235. 

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

  1237.         buf += 2;

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

  1239.         buf += 2;

  1240. 

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

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

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

  1244.         }

  1245. 

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

  1247.         region->display_list = display;

  1248. 

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

  1250.         object->display_list = display;

  1251.     }

  1252. 

  1253.     return 0;

  1254. }

  1255. 

  1256. static int dvbsub_parse_page_segment(AVCodecContext *avctx,

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

  1258. {

  1259.     DVBSubContext *ctx = avctx->priv_data;

  1260.     DVBSubRegionDisplay *display;

  1261.     DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;

  1262. 

  1263.     const uint8_t *buf_end = buf + buf_size;

  1264.     int region_id;

  1265.     int page_state;

  1266.     int timeout;

  1267.     int version;

  1268. 

  1269.     if (buf_size < 1)

  1270.         return AVERROR_INVALIDDATA;

  1271. 

  1272.     timeout = *buf++;

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

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

  1275. 

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

  1277.         return 0;

  1278.     }

  1279. 

  1280.     ctx->time_out = timeout;

  1281.     ctx->version = version;

  1282. 

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

  1284. 

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

  1286.         save_subtitle_set(avctx, sub, got_output);

  1287. 

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

  1289.         delete_regions(ctx);

  1290.         delete_objects(ctx);

  1291.         delete_cluts(ctx);

  1292.     }

  1293. 

  1294.     tmp_display_list = ctx->display_list;

  1295.     ctx->display_list = NULL;

  1296. 

  1297.     while (buf + 5 < buf_end) {

  1298.         region_id = *buf++;

  1299.         buf += 1;

  1300. 

  1301.         display = tmp_display_list;

  1302.         tmp_ptr = &tmp_display_list;

  1303. 

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

  1305.             tmp_ptr = &display->next;

  1306.             display = display->next;

  1307.         }

  1308. 

  1309.         if (!display) {

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

  1311.             if (!display)

  1312.                 return AVERROR(ENOMEM);

  1313.         }

  1314. 

  1315.         display->region_id = region_id;

  1316. 

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

  1318.         buf += 2;

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

  1320.         buf += 2;

  1321. 

  1322.         *tmp_ptr = display->next;

  1323. 

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

  1325.         ctx->display_list = display;

  1326. 

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

  1328.     }

  1329. 

  1330.     while (tmp_display_list) {

  1331.         display = tmp_display_list;

  1332. 

  1333.         tmp_display_list = display->next;

  1334. 

  1335.         av_freep(&display);

  1336.     }

  1337. 

  1338.     return 0;

  1339. }

  1340. 

  1341. 

  1342. #ifdef DEBUG

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

  1344. {

  1345.     int x, y, v;

  1346.     FILE *f;

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

  1348.     char command[1024];

  1349. 

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

  1351. 

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

  1353.     if (!f) {

  1354.         perror(fname);

  1355.         return;

  1356.     }

  1357.     fprintf(f, "P6\n"

  1358.             "%d %d\n"

  1359.             "%d\n",

  1360.             w, h, 255);

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

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

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

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

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

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

  1367.         }

  1368.     }

  1369.     fclose(f);

  1370. 

  1371. 

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

  1373. 

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

  1375.     if (!f) {

  1376.         perror(fname2);

  1377.         return;

  1378.     }

  1379.     fprintf(f, "P5\n"

  1380.             "%d %d\n"

  1381.             "%d\n",

  1382.             w, h, 255);

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

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

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

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

  1387.         }

  1388.     }

  1389.     fclose(f);

  1390. 

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

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

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

  1394.         return;

  1395.     }

  1396. 

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

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

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

  1400.         return;

  1401.     }

  1402. }

  1403. 

  1404. static int save_display_set(DVBSubContext *ctx)

  1405. {

  1406.     DVBSubRegion *region;

  1407.     DVBSubRegionDisplay *display;

  1408.     DVBSubCLUT *clut;

  1409.     uint32_t *clut_table;

  1410.     int x_pos, y_pos, width, height;

  1411.     int x, y, y_off, x_off;

  1412.     uint32_t *pbuf;

  1413.     char filename[32];

  1414.     static int fileno_index = 0;

  1415. 

  1416.     x_pos = -1;

  1417.     y_pos = -1;

  1418.     width = 0;

  1419.     height = 0;

  1420. 

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

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

  1423. 

  1424.         if (!region)

  1425.             return -1;

  1426. 

  1427.         if (x_pos == -1) {

  1428.             x_pos = display->x_pos;

  1429.             y_pos = display->y_pos;

  1430.             width = region->width;

  1431.             height = region->height;

  1432.         } else {

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

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

  1435.                 x_pos = display->x_pos;

  1436.             }

  1437. 

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

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

  1440.                 y_pos = display->y_pos;

  1441.             }

  1442. 

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

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

  1445.             }

  1446. 

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

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

  1449.             }

  1450.         }

  1451.     }

  1452. 

  1453.     if (x_pos >= 0) {

  1454. 

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

  1456.         if (!pbuf)

  1457.             return -1;

  1458. 

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

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

  1461. 

  1462.             if (!region)

  1463.                 return -1;

  1464. 

  1465.             x_off = display->x_pos - x_pos;

  1466.             y_off = display->y_pos - y_pos;

  1467. 

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

  1469. 

  1470.             if (!clut)

  1471.                 clut = &default_clut;

  1472. 

  1473.             switch (region->depth) {

  1474.             case 2:

  1475.                 clut_table = clut->clut4;

  1476.                 break;

  1477.             case 8:

  1478.                 clut_table = clut->clut256;

  1479.                 break;

  1480.             case 4:

  1481.             default:

  1482.                 clut_table = clut->clut16;

  1483.                 break;

  1484.             }

  1485. 

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

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

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

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

  1490.                 }

  1491.             }

  1492. 

  1493.         }

  1494. 

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

  1496. 

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

  1498. 

  1499.         av_freep(&pbuf);

  1500.     }

  1501. 

  1502.     fileno_index++;

  1503.     return 0;

  1504. }

  1505. #endif /* DEBUG */

  1506. 

  1507. static int dvbsub_parse_display_definition_segment(AVCodecContext *avctx,

  1508.                                                    const uint8_t *buf,

  1509.                                                    int buf_size)

  1510. {

  1511.     DVBSubContext *ctx = avctx->priv_data;

  1512.     DVBSubDisplayDefinition *display_def = ctx->display_definition;

  1513.     int dds_version, info_byte;

  1514. 

  1515.     if (buf_size < 5)

  1516.         return AVERROR_INVALIDDATA;

  1517. 

  1518.     info_byte   = bytestream_get_byte(&buf);

  1519.     dds_version = info_byte >> 4;

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

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

  1522. 

  1523.     if (!display_def) {

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

  1525.         if (!display_def)

  1526.             return AVERROR(ENOMEM);

  1527.         ctx->display_definition = display_def;

  1528.     }

  1529. 

  1530.     display_def->version = dds_version;

  1531.     display_def->x       = 0;

  1532.     display_def->y       = 0;

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

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

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

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

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

  1538.     }

  1539. 

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

  1541.         if (buf_size < 13)

  1542.             return AVERROR_INVALIDDATA;

  1543. 

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

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

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

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

  1548.     }

  1549. 

  1550.     return 0;

  1551. }

  1552. 

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

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

  1555. {

  1556.     DVBSubContext *ctx = avctx->priv_data;

  1557. 

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

  1559.         save_subtitle_set(avctx, sub, got_output);

  1560. #ifdef DEBUG

  1561.     save_display_set(ctx);

  1562. #endif

  1563.     return 0;

  1564. }

  1565. 

  1566. static int dvbsub_decode(AVCodecContext *avctx,

  1567.                          void *data, int *data_size,

  1568.                          AVPacket *avpkt)

  1569. {

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

  1571.     int buf_size = avpkt->size;

  1572.     DVBSubContext *ctx = avctx->priv_data;

  1573.     AVSubtitle *sub = data;

  1574.     const uint8_t *p, *p_end;

  1575.     int segment_type;

  1576.     int page_id;

  1577.     int segment_length;

  1578.     int i;

  1579.     int ret = 0;

  1580.     int got_segment = 0;

  1581.     int got_dds = 0;

  1582. 

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

  1584. 

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

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

  1587.         if (i % 16 == 15)

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

  1589.     }

  1590. 

  1591.     if (i % 16)

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

  1593. 

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

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

  1596.         return AVERROR_INVALIDDATA;

  1597.     }

  1598. 

  1599.     p = buf;

  1600.     p_end = buf + buf_size;

  1601. 

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

  1603.         p += 1;

  1604.         segment_type = *p++;

  1605.         page_id = AV_RB16(p);

  1606.         p += 2;

  1607.         segment_length = AV_RB16(p);

  1608.         p += 2;

  1609. 

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

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

  1612.         }

  1613. 

  1614.         if (p_end - p < segment_length) {

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

  1616.             ret = -1;

  1617.             goto end;

  1618.         }

  1619. 

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

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

  1622.             int ret = 0;

  1623.             switch (segment_type) {

  1624.             case DVBSUB_PAGE_SEGMENT:

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

  1626.                 got_segment |= 1;

  1627.                 break;

  1628.             case DVBSUB_REGION_SEGMENT:

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

  1630.                 got_segment |= 2;

  1631.                 break;

  1632.             case DVBSUB_CLUT_SEGMENT:

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

  1634.                 if (ret < 0) goto end;

  1635.                 got_segment |= 4;

  1636.                 break;

  1637.             case DVBSUB_OBJECT_SEGMENT:

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

  1639.                 got_segment |= 8;

  1640.                 break;

  1641.             case DVBSUB_DISPLAYDEFINITION_SEGMENT:

  1642.                 ret = dvbsub_parse_display_definition_segment(avctx, p,

  1643.                                                               segment_length);

  1644.                 got_dds = 1;

  1645.                 break;

  1646.             case DVBSUB_DISPLAY_SEGMENT:

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

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

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

  1650.                     avctx->width  = 720;

  1651.                     avctx->height = 576;

  1652.                 }

  1653.                 got_segment |= 16;

  1654.                 break;

  1655.             default:

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

  1657.                         segment_type, page_id, segment_length);

  1658.                 break;

  1659.             }

  1660.             if (ret < 0)

  1661.                 goto end;

  1662.         }

  1663. 

  1664.         p += segment_length;

  1665.     }

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

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

  1668.     if (got_segment == 15) {

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

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

  1671.     }

  1672. 

  1673. end:

  1674.     if(ret < 0) {

  1675.         *data_size = 0;

  1676.         avsubtitle_free(sub);

  1677.         return ret;

  1678.     } else {

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

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

  1681.     }

  1682. 

  1683.     return p - buf;

  1684. }

  1685. 

  1686. #define DS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_SUBTITLE_PARAM

  1687. static const AVOption options[] = {

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

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

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

  1691.     {NULL}

  1692. };

  1693. static const AVClass dvbsubdec_class = {

  1694.     .class_name = "DVB Sub Decoder",

  1695.     .item_name  = av_default_item_name,

  1696.     .option     = options,

  1697.     .version    = LIBAVUTIL_VERSION_INT,

  1698. };

  1699. 

  1700. AVCodec ff_dvbsub_decoder = {

  1701.     .name           = "dvbsub",

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

  1703.     .type           = AVMEDIA_TYPE_SUBTITLE,

  1704.     .id             = AV_CODEC_ID_DVB_SUBTITLE,

  1705.     .priv_data_size = sizeof(DVBSubContext),

  1706.     .init           = dvbsub_init_decoder,

  1707.     .close          = dvbsub_close_decoder,

  1708.     .decode         = dvbsub_decode,

  1709.     .priv_class     = &dvbsubdec_class,

  1710. };