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.
43764 Commits
32 Branches
2.4GB
Tree: c19830aa2c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c19830aa2c'
${ noResults }
FFmpeg/libavcodec/dvbsubdec.c

1462 lines
40KB
Raw Blame History 

  1. /*

  2.  * DVB subtitle decoding

  3.  * Copyright (c) 2005 Ian Caulfield

  4.  *

  5.  * This file is part of Libav.

  6.  *

  7.  * Libav 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.  * Libav 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 Libav; 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. 

  28. #define DVBSUB_PAGE_SEGMENT     0x10

  29. #define DVBSUB_REGION_SEGMENT   0x11

  30. #define DVBSUB_CLUT_SEGMENT     0x12

  31. #define DVBSUB_OBJECT_SEGMENT   0x13

  32. #define DVBSUB_DISPLAYDEFINITION_SEGMENT 0x14

  33. #define DVBSUB_DISPLAY_SEGMENT  0x80

  34. 

  35. #define cm (ff_crop_tab + MAX_NEG_CROP)

  36. 

  37. #ifdef DEBUG

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

  39. {

  40.     int x, y, v;

  41.     FILE *f;

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

  43.     char command[1024];

  44. 

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

  46. 

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

  48.     if (!f) {

  49.         perror(fname);

  50.         return;

  51.     }

  52.     fprintf(f, "P6\n"

  53.             "%d %d\n"

  54.             "%d\n",

  55.             w, h, 255);

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

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

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

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

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

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

  62.         }

  63.     }

  64.     fclose(f);

  65. 

  66. 

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

  68. 

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

  70.     if (!f) {

  71.         perror(fname2);

  72.         return;

  73.     }

  74.     fprintf(f, "P5\n"

  75.             "%d %d\n"

  76.             "%d\n",

  77.             w, h, 255);

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

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

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

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

  82.         }

  83.     }

  84.     fclose(f);

  85. 

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

  87.     system(command);

  88. 

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

  90.     system(command);

  91. }

  92. #endif

  93. 

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

  95. 

  96. typedef struct DVBSubCLUT {

  97.     int id;

  98. 

  99.     uint32_t clut4[4];

  100.     uint32_t clut16[16];

  101.     uint32_t clut256[256];

  102. 

  103.     struct DVBSubCLUT *next;

  104. } DVBSubCLUT;

  105. 

  106. static DVBSubCLUT default_clut;

  107. 

  108. typedef struct DVBSubObjectDisplay {

  109.     int object_id;

  110.     int region_id;

  111. 

  112.     int x_pos;

  113.     int y_pos;

  114. 

  115.     int fgcolor;

  116.     int bgcolor;

  117. 

  118.     struct DVBSubObjectDisplay *region_list_next;

  119.     struct DVBSubObjectDisplay *object_list_next;

  120. } DVBSubObjectDisplay;

  121. 

  122. typedef struct DVBSubObject {

  123.     int id;

  124. 

  125.     int type;

  126. 

  127.     DVBSubObjectDisplay *display_list;

  128. 

  129.     struct DVBSubObject *next;

  130. } DVBSubObject;

  131. 

  132. typedef struct DVBSubRegionDisplay {

  133.     int region_id;

  134. 

  135.     int x_pos;

  136.     int y_pos;

  137. 

  138.     struct DVBSubRegionDisplay *next;

  139. } DVBSubRegionDisplay;

  140. 

  141. typedef struct DVBSubRegion {

  142.     int id;

  143. 

  144.     int width;

  145.     int height;

  146.     int depth;

  147. 

  148.     int clut;

  149.     int bgcolor;

  150. 

  151.     uint8_t *pbuf;

  152.     int buf_size;

  153. 

  154.     DVBSubObjectDisplay *display_list;

  155. 

  156.     struct DVBSubRegion *next;

  157. } DVBSubRegion;

  158. 

  159. typedef struct DVBSubDisplayDefinition {

  160.     int version;

  161. 

  162.     int x;

  163.     int y;

  164.     int width;

  165.     int height;

  166. } DVBSubDisplayDefinition;

  167. 

  168. typedef struct DVBSubContext {

  169.     int composition_id;

  170.     int ancillary_id;

  171. 

  172.     int time_out;

  173.     DVBSubRegion *region_list;

  174.     DVBSubCLUT   *clut_list;

  175.     DVBSubObject *object_list;

  176. 

  177.     int display_list_size;

  178.     DVBSubRegionDisplay *display_list;

  179.     DVBSubDisplayDefinition *display_definition;

  180. } DVBSubContext;

  181. 

  182. 

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

  184. {

  185.     DVBSubObject *ptr = ctx->object_list;

  186. 

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

  188.         ptr = ptr->next;

  189.     }

  190. 

  191.     return ptr;

  192. }

  193. 

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

  195. {

  196.     DVBSubCLUT *ptr = ctx->clut_list;

  197. 

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

  199.         ptr = ptr->next;

  200.     }

  201. 

  202.     return ptr;

  203. }

  204. 

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

  206. {

  207.     DVBSubRegion *ptr = ctx->region_list;

  208. 

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

  210.         ptr = ptr->next;

  211.     }

  212. 

  213.     return ptr;

  214. }

  215. 

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

  217. {

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

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

  220. 

  221.     while (region->display_list) {

  222.         display = region->display_list;

  223. 

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

  225. 

  226.         if (object) {

  227.             obj_disp_ptr = &object->display_list;

  228.             obj_disp = *obj_disp_ptr;

  229. 

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

  231.                 obj_disp_ptr = &obj_disp->object_list_next;

  232.                 obj_disp = *obj_disp_ptr;

  233.             }

  234. 

  235.             if (obj_disp) {

  236.                 *obj_disp_ptr = obj_disp->object_list_next;

  237. 

  238.                 if (!object->display_list) {

  239.                     obj2_ptr = &ctx->object_list;

  240.                     obj2 = *obj2_ptr;

  241. 

  242.                     while (obj2 != object) {

  243.                         assert(obj2);

  244.                         obj2_ptr = &obj2->next;

  245.                         obj2 = *obj2_ptr;

  246.                     }

  247. 

  248.                     *obj2_ptr = obj2->next;

  249. 

  250.                     av_free(obj2);

  251.                 }

  252.             }

  253.         }

  254. 

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

  256. 

  257.         av_free(display);

  258.     }

  259. 

  260. }

  261. 

  262. static void delete_state(DVBSubContext *ctx)

  263. {

  264.     DVBSubRegion *region;

  265.     DVBSubCLUT *clut;

  266. 

  267.     while (ctx->region_list) {

  268.         region = ctx->region_list;

  269. 

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

  271. 

  272.         delete_region_display_list(ctx, region);

  273.         av_free(region->pbuf);

  274.         av_free(region);

  275.     }

  276. 

  277.     while (ctx->clut_list) {

  278.         clut = ctx->clut_list;

  279. 

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

  281. 

  282.         av_free(clut);

  283.     }

  284. 

  285.     av_freep(&ctx->display_definition);

  286. 

  287.     /* Should already be null */

  288.     if (ctx->object_list)

  289.         av_log(NULL, AV_LOG_ERROR, "Memory deallocation error!\n");

  290. }

  291. 

  292. static av_cold int dvbsub_init_decoder(AVCodecContext *avctx)

  293. {

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

  295.     DVBSubContext *ctx = avctx->priv_data;

  296. 

  297.     if (!avctx->extradata || avctx->extradata_size != 4) {

  298.         av_log(avctx, AV_LOG_WARNING, "Invalid extradata, subtitle streams may be combined!\n");

  299.         ctx->composition_id = -1;

  300.         ctx->ancillary_id   = -1;

  301.     } else {

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

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

  304.     }

  305. 

  306.     default_clut.id = -1;

  307.     default_clut.next = NULL;

  308. 

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

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

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

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

  313. 

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

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

  316.         if (i < 8) {

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

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

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

  320.         } else {

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

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

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

  324.         }

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

  326.     }

  327. 

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

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

  330.         if (i < 8) {

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

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

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

  334.             a = 63;

  335.         } else {

  336.             switch (i & 0x88) {

  337.             case 0x00:

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

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

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

  341.                 a = 255;

  342.                 break;

  343.             case 0x08:

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

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

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

  347.                 a = 127;

  348.                 break;

  349.             case 0x80:

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

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

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

  353.                 a = 255;

  354.                 break;

  355.             case 0x88:

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

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

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

  359.                 a = 255;

  360.                 break;

  361.             }

  362.         }

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

  364.     }

  365. 

  366.     return 0;

  367. }

  368. 

  369. static av_cold int dvbsub_close_decoder(AVCodecContext *avctx)

  370. {

  371.     DVBSubContext *ctx = avctx->priv_data;

  372.     DVBSubRegionDisplay *display;

  373. 

  374.     delete_state(ctx);

  375. 

  376.     while (ctx->display_list) {

  377.         display = ctx->display_list;

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

  379. 

  380.         av_free(display);

  381.     }

  382. 

  383.     return 0;

  384. }

  385. 

  386. static int dvbsub_read_2bit_string(uint8_t *destbuf, int dbuf_len,

  387.                                    const uint8_t **srcbuf, int buf_size,

  388.                                    int non_mod, uint8_t *map_table)

  389. {

  390.     GetBitContext gb;

  391. 

  392.     int bits;

  393.     int run_length;

  394.     int pixels_read = 0;

  395. 

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

  397. 

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

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

  400. 

  401.         if (bits) {

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

  403.                 if (map_table)

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

  405.                 else

  406.                     *destbuf++ = bits;

  407.             }

  408.             pixels_read++;

  409.         } else {

  410.             bits = get_bits1(&gb);

  411.             if (bits == 1) {

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

  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 {

  426.                 bits = get_bits1(&gb);

  427.                 if (bits == 0) {

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

  429.                     if (bits == 2) {

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

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

  432. 

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

  434.                             pixels_read += run_length;

  435.                         else {

  436.                             if (map_table)

  437.                                 bits = map_table[bits];

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

  439.                                 *destbuf++ = bits;

  440.                                 pixels_read++;

  441.                             }

  442.                         }

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

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

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

  446. 

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

  448.                             pixels_read += run_length;

  449.                         else {

  450.                             if (map_table)

  451.                                 bits = map_table[bits];

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

  453.                                 *destbuf++ = bits;

  454.                                 pixels_read++;

  455.                             }

  456.                         }

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

  458.                         pixels_read += 2;

  459.                         if (map_table)

  460.                             bits = map_table[0];

  461.                         else

  462.                             bits = 0;

  463.                         if (pixels_read <= dbuf_len) {

  464.                             *destbuf++ = bits;

  465.                             *destbuf++ = bits;

  466.                         }

  467.                     } else {

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

  469.                         return pixels_read;

  470.                     }

  471.                 } else {

  472.                     if (map_table)

  473.                         bits = map_table[0];

  474.                     else

  475.                         bits = 0;

  476.                     *destbuf++ = bits;

  477.                     pixels_read++;

  478.                 }

  479.             }

  480.         }

  481.     }

  482. 

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

  484.         av_log(NULL, AV_LOG_ERROR, "DVBSub error: line overflow\n");

  485. 

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

  487. 

  488.     return pixels_read;

  489. }

  490. 

  491. static int dvbsub_read_4bit_string(uint8_t *destbuf, int dbuf_len,

  492.                                    const uint8_t **srcbuf, int buf_size,

  493.                                    int non_mod, uint8_t *map_table)

  494. {

  495.     GetBitContext gb;

  496. 

  497.     int bits;

  498.     int run_length;

  499.     int pixels_read = 0;

  500. 

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

  502. 

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

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

  505. 

  506.         if (bits) {

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

  508.                 if (map_table)

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

  510.                 else

  511.                     *destbuf++ = bits;

  512.             }

  513.             pixels_read++;

  514.         } else {

  515.             bits = get_bits1(&gb);

  516.             if (bits == 0) {

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

  518. 

  519.                 if (run_length == 0) {

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

  521.                     return pixels_read;

  522.                 }

  523. 

  524.                 run_length += 2;

  525. 

  526.                 if (map_table)

  527.                     bits = map_table[0];

  528.                 else

  529.                     bits = 0;

  530. 

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

  532.                     *destbuf++ = bits;

  533.                     pixels_read++;

  534.                 }

  535.             } else {

  536.                 bits = get_bits1(&gb);

  537.                 if (bits == 0) {

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

  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 {

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

  553.                     if (bits == 2) {

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

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

  556. 

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

  558.                             pixels_read += run_length;

  559.                         else {

  560.                             if (map_table)

  561.                                 bits = map_table[bits];

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

  563.                                 *destbuf++ = bits;

  564.                                 pixels_read++;

  565.                             }

  566.                         }

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

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

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

  570. 

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

  572.                             pixels_read += run_length;

  573.                         else {

  574.                             if (map_table)

  575.                                 bits = map_table[bits];

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

  577.                                 *destbuf++ = bits;

  578.                                 pixels_read++;

  579.                             }

  580.                         }

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

  582.                         pixels_read += 2;

  583.                         if (map_table)

  584.                             bits = map_table[0];

  585.                         else

  586.                             bits = 0;

  587.                         if (pixels_read <= dbuf_len) {

  588.                             *destbuf++ = bits;

  589.                             *destbuf++ = bits;

  590.                         }

  591.                     } else {

  592.                         if (map_table)

  593.                             bits = map_table[0];

  594.                         else

  595.                             bits = 0;

  596.                         *destbuf++ = bits;

  597.                         pixels_read ++;

  598.                     }

  599.                 }

  600.             }

  601.         }

  602.     }

  603. 

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

  605.         av_log(NULL, AV_LOG_ERROR, "DVBSub error: line overflow\n");

  606. 

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

  608. 

  609.     return pixels_read;

  610. }

  611. 

  612. static int dvbsub_read_8bit_string(uint8_t *destbuf, int dbuf_len,

  613.                                     const uint8_t **srcbuf, int buf_size,

  614.                                     int non_mod, uint8_t *map_table)

  615. {

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

  617.     int bits;

  618.     int run_length;

  619.     int pixels_read = 0;

  620. 

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

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

  623. 

  624.         if (bits) {

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

  626.                 if (map_table)

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

  628.                 else

  629.                     *destbuf++ = bits;

  630.             }

  631.             pixels_read++;

  632.         } else {

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

  634.             run_length = bits & 0x7f;

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

  636.                 if (run_length == 0) {

  637.                     return pixels_read;

  638.                 }

  639.             } else {

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

  641. 

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

  643.                     pixels_read += run_length;

  644.             }

  645.             if (map_table)

  646.                 bits = map_table[0];

  647.             else

  648.                 bits = 0;

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

  650.                 *destbuf++ = bits;

  651.                 pixels_read++;

  652.             }

  653.         }

  654.     }

  655. 

  656.     if (*(*srcbuf)++)

  657.         av_log(NULL, AV_LOG_ERROR, "DVBSub error: line overflow\n");

  658. 

  659.     return pixels_read;

  660. }

  661. 

  662. 

  663. 

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

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

  666. {

  667.     DVBSubContext *ctx = avctx->priv_data;

  668. 

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

  670.     const uint8_t *buf_end = buf + buf_size;

  671.     uint8_t *pbuf;

  672.     int x_pos, y_pos;

  673.     int i;

  674. 

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

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

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

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

  679.     uint8_t *map_table;

  680. 

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

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

  683. 

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

  685.         if (i % 16 == 0)

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

  687. 

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

  689.         if (i % 16 == 15)

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

  691.     }

  692. 

  693.     if (i % 16)

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

  695. 

  696.     if (region == 0)

  697.         return;

  698. 

  699.     pbuf = region->pbuf;

  700. 

  701.     x_pos = display->x_pos;

  702.     y_pos = display->y_pos;

  703. 

  704.     if ((y_pos & 1) != top_bottom)

  705.         y_pos++;

  706. 

  707.     while (buf < buf_end) {

  708.         if (x_pos > region->width || y_pos > region->height) {

  709.             av_log(avctx, AV_LOG_ERROR, "Invalid object location!\n");

  710.             return;

  711.         }

  712. 

  713.         switch (*buf++) {

  714.         case 0x10:

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

  716.                 map_table = map2to8;

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

  718.                 map_table = map2to4;

  719.             else

  720.                 map_table = NULL;

  721. 

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

  723.                                                 region->width - x_pos, &buf, buf_end - buf,

  724.                                                 non_mod, map_table);

  725.             break;

  726.         case 0x11:

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

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

  729.                 return;

  730.             }

  731. 

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

  733.                 map_table = map4to8;

  734.             else

  735.                 map_table = NULL;

  736. 

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

  738.                                                 region->width - x_pos, &buf, buf_end - buf,

  739.                                                 non_mod, map_table);

  740.             break;

  741.         case 0x12:

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

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

  744.                 return;

  745.             }

  746. 

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

  748.                                                 region->width - x_pos, &buf, buf_end - buf,

  749.                                                 non_mod, NULL);

  750.             break;

  751. 

  752.         case 0x20:

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

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

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

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

  757.             break;

  758.         case 0x21:

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

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

  761.             break;

  762.         case 0x22:

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

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

  765.             break;

  766. 

  767.         case 0xf0:

  768.             x_pos = display->x_pos;

  769.             y_pos += 2;

  770.             break;

  771.         default:

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

  773.         }

  774.     }

  775. 

  776. }

  777. 

  778. static int dvbsub_parse_object_segment(AVCodecContext *avctx,

  779.                                        const uint8_t *buf, int buf_size)

  780. {

  781.     DVBSubContext *ctx = avctx->priv_data;

  782. 

  783.     const uint8_t *buf_end = buf + buf_size;

  784.     const uint8_t *block;

  785.     int object_id;

  786.     DVBSubObject *object;

  787.     DVBSubObjectDisplay *display;

  788.     int top_field_len, bottom_field_len;

  789. 

  790.     int coding_method, non_modifying_color;

  791. 

  792.     object_id = AV_RB16(buf);

  793.     buf += 2;

  794. 

  795.     object = get_object(ctx, object_id);

  796. 

  797.     if (!object)

  798.         return AVERROR_INVALIDDATA;

  799. 

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

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

  802. 

  803.     if (coding_method == 0) {

  804.         top_field_len = AV_RB16(buf);

  805.         buf += 2;

  806.         bottom_field_len = AV_RB16(buf);

  807.         buf += 2;

  808. 

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

  810.             av_log(avctx, AV_LOG_ERROR, "Field data size too large\n");

  811.             return AVERROR_INVALIDDATA;

  812.         }

  813. 

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

  815.             block = buf;

  816. 

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

  818.                                             non_modifying_color);

  819. 

  820.             if (bottom_field_len > 0)

  821.                 block = buf + top_field_len;

  822.             else

  823.                 bottom_field_len = top_field_len;

  824. 

  825.             dvbsub_parse_pixel_data_block(avctx, display, block, bottom_field_len, 1,

  826.                                             non_modifying_color);

  827.         }

  828. 

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

  830. 

  831.     } else {

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

  833.     }

  834. 

  835.     return 0;

  836. }

  837. 

  838. static int dvbsub_parse_clut_segment(AVCodecContext *avctx,

  839.                                      const uint8_t *buf, int buf_size)

  840. {

  841.     DVBSubContext *ctx = avctx->priv_data;

  842. 

  843.     const uint8_t *buf_end = buf + buf_size;

  844.     int i, clut_id;

  845.     DVBSubCLUT *clut;

  846.     int entry_id, depth , full_range;

  847.     int y, cr, cb, alpha;

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

  849. 

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

  851. 

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

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

  854.         if (i % 16 == 15)

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

  856.     }

  857. 

  858.     if (i % 16)

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

  860. 

  861.     clut_id = *buf++;

  862.     buf += 1;

  863. 

  864.     clut = get_clut(ctx, clut_id);

  865. 

  866.     if (!clut) {

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

  868.         if (!clut)

  869.             return AVERROR(ENOMEM);

  870. 

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

  872. 

  873.         clut->id = clut_id;

  874. 

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

  876.         ctx->clut_list = clut;

  877.     }

  878. 

  879.     while (buf + 4 < buf_end) {

  880.         entry_id = *buf++;

  881. 

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

  883. 

  884.         if (depth == 0) {

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

  886.             return AVERROR_INVALIDDATA;

  887.         }

  888. 

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

  890. 

  891.         if (full_range) {

  892.             y = *buf++;

  893.             cr = *buf++;

  894.             cb = *buf++;

  895.             alpha = *buf++;

  896.         } else {

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

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

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

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

  901. 

  902.             buf += 2;

  903.         }

  904. 

  905.         if (y == 0)

  906.             alpha = 0xff;

  907. 

  908.         YUV_TO_RGB1_CCIR(cb, cr);

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

  910. 

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

  912. 

  913.         if (depth & 0x80)

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

  915.         if (depth & 0x40)

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

  917.         if (depth & 0x20)

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

  919.     }

  920. 

  921.     return 0;

  922. }

  923. 

  924. 

  925. static int dvbsub_parse_region_segment(AVCodecContext *avctx,

  926.                                        const uint8_t *buf, int buf_size)

  927. {

  928.     DVBSubContext *ctx = avctx->priv_data;

  929. 

  930.     const uint8_t *buf_end = buf + buf_size;

  931.     int region_id, object_id;

  932.     DVBSubRegion *region;

  933.     DVBSubObject *object;

  934.     DVBSubObjectDisplay *display;

  935.     int fill;

  936. 

  937.     if (buf_size < 10)

  938.         return AVERROR_INVALIDDATA;

  939. 

  940.     region_id = *buf++;

  941. 

  942.     region = get_region(ctx, region_id);

  943. 

  944.     if (!region) {

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

  946.         if (!region)

  947.             return AVERROR(ENOMEM);

  948. 

  949.         region->id = region_id;

  950. 

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

  952.         ctx->region_list = region;

  953.     }

  954. 

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

  956. 

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

  958.     buf += 2;

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

  960.     buf += 2;

  961. 

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

  963.         av_free(region->pbuf);

  964. 

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

  966. 

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

  968.         if (!region->pbuf)

  969.             return AVERROR(ENOMEM);

  970. 

  971.         fill = 1;

  972.     }

  973. 

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

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

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

  977.         region->depth= 4;

  978.     }

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

  980. 

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

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

  983.     else {

  984.         buf += 1;

  985. 

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

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

  988.         else

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

  990.     }

  991. 

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

  993. 

  994.     if (fill) {

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

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

  997.     }

  998. 

  999.     delete_region_display_list(ctx, region);

  1000. 

  1001.     while (buf + 5 < buf_end) {

  1002.         object_id = AV_RB16(buf);

  1003.         buf += 2;

  1004. 

  1005.         object = get_object(ctx, object_id);

  1006. 

  1007.         if (!object) {

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

  1009.             if (!object)

  1010.                 return AVERROR(ENOMEM);

  1011. 

  1012.             object->id = object_id;

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

  1014.             ctx->object_list = object;

  1015.         }

  1016. 

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

  1018. 

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

  1020.         if (!display)

  1021.             return AVERROR(ENOMEM);

  1022. 

  1023.         display->object_id = object_id;

  1024.         display->region_id = region_id;

  1025. 

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

  1027.         buf += 2;

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

  1029.         buf += 2;

  1030. 

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

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

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

  1034.         }

  1035. 

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

  1037.         region->display_list = display;

  1038. 

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

  1040.         object->display_list = display;

  1041.     }

  1042. 

  1043.     return 0;

  1044. }

  1045. 

  1046. static int dvbsub_parse_page_segment(AVCodecContext *avctx,

  1047.                                      const uint8_t *buf, int buf_size)

  1048. {

  1049.     DVBSubContext *ctx = avctx->priv_data;

  1050.     DVBSubRegionDisplay *display;

  1051.     DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;

  1052. 

  1053.     const uint8_t *buf_end = buf + buf_size;

  1054.     int region_id;

  1055.     int page_state;

  1056. 

  1057.     if (buf_size < 1)

  1058.         return AVERROR_INVALIDDATA;

  1059. 

  1060.     ctx->time_out = *buf++;

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

  1062. 

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

  1064. 

  1065.     if (page_state == 2) {

  1066.         delete_state(ctx);

  1067.     }

  1068. 

  1069.     tmp_display_list = ctx->display_list;

  1070.     ctx->display_list = NULL;

  1071.     ctx->display_list_size = 0;

  1072. 

  1073.     while (buf + 5 < buf_end) {

  1074.         region_id = *buf++;

  1075.         buf += 1;

  1076. 

  1077.         display = tmp_display_list;

  1078.         tmp_ptr = &tmp_display_list;

  1079. 

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

  1081.             tmp_ptr = &display->next;

  1082.             display = display->next;

  1083.         }

  1084. 

  1085.         if (!display) {

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

  1087.             if (!display)

  1088.                 return AVERROR(ENOMEM);

  1089.         }

  1090. 

  1091.         display->region_id = region_id;

  1092. 

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

  1094.         buf += 2;

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

  1096.         buf += 2;

  1097. 

  1098.         *tmp_ptr = display->next;

  1099. 

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

  1101.         ctx->display_list = display;

  1102.         ctx->display_list_size++;

  1103. 

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

  1105.     }

  1106. 

  1107.     while (tmp_display_list) {

  1108.         display = tmp_display_list;

  1109. 

  1110.         tmp_display_list = display->next;

  1111. 

  1112.         av_free(display);

  1113.     }

  1114. 

  1115.     return 0;

  1116. }

  1117. 

  1118. 

  1119. #ifdef DEBUG

  1120. static int save_display_set(DVBSubContext *ctx)

  1121. {

  1122.     DVBSubRegion *region;

  1123.     DVBSubRegionDisplay *display;

  1124.     DVBSubCLUT *clut;

  1125.     uint32_t *clut_table;

  1126.     int x_pos, y_pos, width, height;

  1127.     int x, y, y_off, x_off;

  1128.     uint32_t *pbuf;

  1129.     char filename[32];

  1130.     static int fileno_index = 0;

  1131. 

  1132.     x_pos = -1;

  1133.     y_pos = -1;

  1134.     width = 0;

  1135.     height = 0;

  1136. 

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

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

  1139. 

  1140.         if (x_pos == -1) {

  1141.             x_pos = display->x_pos;

  1142.             y_pos = display->y_pos;

  1143.             width = region->width;

  1144.             height = region->height;

  1145.         } else {

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

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

  1148.                 x_pos = display->x_pos;

  1149.             }

  1150. 

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

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

  1153.                 y_pos = display->y_pos;

  1154.             }

  1155. 

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

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

  1158.             }

  1159. 

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

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

  1162.             }

  1163.         }

  1164.     }

  1165. 

  1166.     if (x_pos >= 0) {

  1167. 

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

  1169.         if (!pbuf)

  1170.             return AVERROR(ENOMEM);

  1171. 

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

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

  1174. 

  1175.             x_off = display->x_pos - x_pos;

  1176.             y_off = display->y_pos - y_pos;

  1177. 

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

  1179. 

  1180.             if (clut == 0)

  1181.                 clut = &default_clut;

  1182. 

  1183.             switch (region->depth) {

  1184.             case 2:

  1185.                 clut_table = clut->clut4;

  1186.                 break;

  1187.             case 8:

  1188.                 clut_table = clut->clut256;

  1189.                 break;

  1190.             case 4:

  1191.             default:

  1192.                 clut_table = clut->clut16;

  1193.                 break;

  1194.             }

  1195. 

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

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

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

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

  1200.                 }

  1201.             }

  1202. 

  1203.         }

  1204. 

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

  1206. 

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

  1208. 

  1209.         av_free(pbuf);

  1210.     }

  1211. 

  1212.     fileno_index++;

  1213.     return 0;

  1214. }

  1215. #endif

  1216. 

  1217. static int dvbsub_parse_display_definition_segment(AVCodecContext *avctx,

  1218.                                                    const uint8_t *buf,

  1219.                                                    int buf_size)

  1220. {

  1221.     DVBSubContext *ctx = avctx->priv_data;

  1222.     DVBSubDisplayDefinition *display_def = ctx->display_definition;

  1223.     int dds_version, info_byte;

  1224. 

  1225.     if (buf_size < 5)

  1226.         return AVERROR_INVALIDDATA;

  1227. 

  1228.     info_byte   = bytestream_get_byte(&buf);

  1229.     dds_version = info_byte >> 4;

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

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

  1232. 

  1233.     if (!display_def) {

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

  1235.         if (!display_def)

  1236.             return AVERROR(ENOMEM);

  1237.         ctx->display_definition = display_def;

  1238.     }

  1239. 

  1240.     display_def->version = dds_version;

  1241.     display_def->x       = 0;

  1242.     display_def->y       = 0;

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

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

  1245. 

  1246.     if (buf_size < 13)

  1247.         return AVERROR_INVALIDDATA;

  1248. 

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

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

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

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

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

  1254.     }

  1255. 

  1256.     return 0;

  1257. }

  1258. 

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

  1260.                                       int buf_size, AVSubtitle *sub)

  1261. {

  1262.     DVBSubContext *ctx = avctx->priv_data;

  1263.     DVBSubDisplayDefinition *display_def = ctx->display_definition;

  1264. 

  1265.     DVBSubRegion *region;

  1266.     DVBSubRegionDisplay *display;

  1267.     AVSubtitleRect *rect;

  1268.     DVBSubCLUT *clut;

  1269.     uint32_t *clut_table;

  1270.     int i;

  1271.     int offset_x=0, offset_y=0;

  1272. 

  1273.     sub->rects = NULL;

  1274.     sub->start_display_time = 0;

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

  1276.     sub->format = 0;

  1277. 

  1278.     if (display_def) {

  1279.         offset_x = display_def->x;

  1280.         offset_y = display_def->y;

  1281.     }

  1282. 

  1283.     sub->num_rects = ctx->display_list_size;

  1284.     if (sub->num_rects <= 0)

  1285.         return AVERROR_INVALIDDATA;

  1286. 

  1287.     sub->rects = av_mallocz_array(sub->num_rects * sub->num_rects,

  1288.                                   sizeof(*sub->rects));

  1289.     if (!sub->rects)

  1290.         return AVERROR(ENOMEM);

  1291. 

  1292.     i = 0;

  1293. 

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

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

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

  1297. 

  1298.         if (!region)

  1299.             continue;

  1300. 

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

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

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

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

  1305.         rect->nb_colors = 16;

  1306.         rect->type      = SUBTITLE_BITMAP;

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

  1308. 

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

  1310. 

  1311.         if (!clut)

  1312.             clut = &default_clut;

  1313. 

  1314.         switch (region->depth) {

  1315.         case 2:

  1316.             clut_table = clut->clut4;

  1317.             break;

  1318.         case 8:

  1319.             clut_table = clut->clut256;

  1320.             break;

  1321.         case 4:

  1322.         default:

  1323.             clut_table = clut->clut16;

  1324.             break;

  1325.         }

  1326. 

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

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

  1329.             av_free(sub->rects);

  1330.             return AVERROR(ENOMEM);

  1331.         }

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

  1333. 

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

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

  1336.             av_free(rect->data[1]);

  1337.             av_free(sub->rects);

  1338.             return AVERROR(ENOMEM);

  1339.         }

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

  1341. 

  1342. #if FF_API_AVPICTURE

  1343. FF_DISABLE_DEPRECATION_WARNINGS

  1344. {

  1345.         int j;

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

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

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

  1349.         }

  1350. }

  1351. FF_ENABLE_DEPRECATION_WARNINGS

  1352. #endif

  1353. 

  1354.         i++;

  1355.     }

  1356. 

  1357.     sub->num_rects = i;

  1358. 

  1359. #ifdef DEBUG

  1360.     save_display_set(ctx);

  1361. #endif

  1362. 

  1363.     return 1;

  1364. }

  1365. 

  1366. static int dvbsub_decode(AVCodecContext *avctx,

  1367.                          void *data, int *data_size,

  1368.                          AVPacket *avpkt)

  1369. {

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

  1371.     int buf_size = avpkt->size;

  1372.     DVBSubContext *ctx = avctx->priv_data;

  1373.     AVSubtitle *sub = data;

  1374.     const uint8_t *p, *p_end;

  1375.     int segment_type;

  1376.     int page_id;

  1377.     int segment_length;

  1378.     int i;

  1379. 

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

  1381. 

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

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

  1384.         if (i % 16 == 15)

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

  1386.     }

  1387. 

  1388.     if (i % 16)

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

  1390. 

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

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

  1393.         return AVERROR_INVALIDDATA;

  1394.     }

  1395. 

  1396.     p = buf;

  1397.     p_end = buf + buf_size;

  1398. 

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

  1400.         p += 1;

  1401.         segment_type = *p++;

  1402.         page_id = AV_RB16(p);

  1403.         p += 2;

  1404.         segment_length = AV_RB16(p);

  1405.         p += 2;

  1406. 

  1407.         if (p_end - p < segment_length) {

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

  1409.             return -1;

  1410.         }

  1411. 

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

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

  1414.             int ret = 0;

  1415.             switch (segment_type) {

  1416.             case DVBSUB_PAGE_SEGMENT:

  1417.                 ret = dvbsub_parse_page_segment(avctx, p, segment_length);

  1418.                 break;

  1419.             case DVBSUB_REGION_SEGMENT:

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

  1421.                 break;

  1422.             case DVBSUB_CLUT_SEGMENT:

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

  1424.                 break;

  1425.             case DVBSUB_OBJECT_SEGMENT:

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

  1427.                 break;

  1428.             case DVBSUB_DISPLAYDEFINITION_SEGMENT:

  1429.                 ret = dvbsub_parse_display_definition_segment(avctx, p,

  1430.                                                               segment_length);

  1431.                 break;

  1432.             case DVBSUB_DISPLAY_SEGMENT:

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

  1434.                 *data_size = ret;

  1435.                 break;

  1436.             default:

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

  1438.                         segment_type, page_id, segment_length);

  1439.                 break;

  1440.             }

  1441.             if (ret < 0)

  1442.                 return ret;

  1443.         }

  1444. 

  1445.         p += segment_length;

  1446.     }

  1447. 

  1448.     return p - buf;

  1449. }

  1450. 

  1451. 

  1452. AVCodec ff_dvbsub_decoder = {

  1453.     .name           = "dvbsub",

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

  1455.     .type           = AVMEDIA_TYPE_SUBTITLE,

  1456.     .id             = AV_CODEC_ID_DVB_SUBTITLE,

  1457.     .priv_data_size = sizeof(DVBSubContext),

  1458.     .init           = dvbsub_init_decoder,

  1459.     .close          = dvbsub_close_decoder,

  1460.     .decode         = dvbsub_decode,

  1461. };