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

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

  38. 

  39. typedef struct DVBSubCLUT {

  40.     int id;

  41. 

  42.     uint32_t clut4[4];

  43.     uint32_t clut16[16];

  44.     uint32_t clut256[256];

  45. 

  46.     struct DVBSubCLUT *next;

  47. } DVBSubCLUT;

  48. 

  49. static DVBSubCLUT default_clut;

  50. 

  51. typedef struct DVBSubObjectDisplay {

  52.     int object_id;

  53.     int region_id;

  54. 

  55.     int x_pos;

  56.     int y_pos;

  57. 

  58.     int fgcolor;

  59.     int bgcolor;

  60. 

  61.     struct DVBSubObjectDisplay *region_list_next;

  62.     struct DVBSubObjectDisplay *object_list_next;

  63. } DVBSubObjectDisplay;

  64. 

  65. typedef struct DVBSubObject {

  66.     int id;

  67. 

  68.     int type;

  69. 

  70.     DVBSubObjectDisplay *display_list;

  71. 

  72.     struct DVBSubObject *next;

  73. } DVBSubObject;

  74. 

  75. typedef struct DVBSubRegionDisplay {

  76.     int region_id;

  77. 

  78.     int x_pos;

  79.     int y_pos;

  80. 

  81.     struct DVBSubRegionDisplay *next;

  82. } DVBSubRegionDisplay;

  83. 

  84. typedef struct DVBSubRegion {

  85.     int id;

  86. 

  87.     int width;

  88.     int height;

  89.     int depth;

  90. 

  91.     int clut;

  92.     int bgcolor;

  93. 

  94.     uint8_t *pbuf;

  95.     int buf_size;

  96. 

  97.     DVBSubObjectDisplay *display_list;

  98. 

  99.     struct DVBSubRegion *next;

  100. } DVBSubRegion;

  101. 

  102. typedef struct DVBSubDisplayDefinition {

  103.     int version;

  104. 

  105.     int x;

  106.     int y;

  107.     int width;

  108.     int height;

  109. } DVBSubDisplayDefinition;

  110. 

  111. typedef struct DVBSubContext {

  112.     int composition_id;

  113.     int ancillary_id;

  114. 

  115.     int time_out;

  116.     DVBSubRegion *region_list;

  117.     DVBSubCLUT   *clut_list;

  118.     DVBSubObject *object_list;

  119. 

  120.     int display_list_size;

  121.     DVBSubRegionDisplay *display_list;

  122.     DVBSubDisplayDefinition *display_definition;

  123. } DVBSubContext;

  124. 

  125. 

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

  127. {

  128.     DVBSubObject *ptr = ctx->object_list;

  129. 

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

  131.         ptr = ptr->next;

  132.     }

  133. 

  134.     return ptr;

  135. }

  136. 

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

  138. {

  139.     DVBSubCLUT *ptr = ctx->clut_list;

  140. 

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

  142.         ptr = ptr->next;

  143.     }

  144. 

  145.     return ptr;

  146. }

  147. 

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

  149. {

  150.     DVBSubRegion *ptr = ctx->region_list;

  151. 

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

  153.         ptr = ptr->next;

  154.     }

  155. 

  156.     return ptr;

  157. }

  158. 

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

  160. {

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

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

  163. 

  164.     while (region->display_list) {

  165.         display = region->display_list;

  166. 

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

  168. 

  169.         if (object) {

  170.             obj_disp_ptr = &object->display_list;

  171.             obj_disp = *obj_disp_ptr;

  172. 

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

  174.                 obj_disp_ptr = &obj_disp->object_list_next;

  175.                 obj_disp = *obj_disp_ptr;

  176.             }

  177. 

  178.             if (obj_disp) {

  179.                 *obj_disp_ptr = obj_disp->object_list_next;

  180. 

  181.                 if (!object->display_list) {

  182.                     obj2_ptr = &ctx->object_list;

  183.                     obj2 = *obj2_ptr;

  184. 

  185.                     while (obj2 != object) {

  186.                         assert(obj2);

  187.                         obj2_ptr = &obj2->next;

  188.                         obj2 = *obj2_ptr;

  189.                     }

  190. 

  191.                     *obj2_ptr = obj2->next;

  192. 

  193.                     av_free(obj2);

  194.                 }

  195.             }

  196.         }

  197. 

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

  199. 

  200.         av_free(display);

  201.     }

  202. 

  203. }

  204. 

  205. static void delete_state(DVBSubContext *ctx)

  206. {

  207.     DVBSubRegion *region;

  208.     DVBSubCLUT *clut;

  209. 

  210.     while (ctx->region_list) {

  211.         region = ctx->region_list;

  212. 

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

  214. 

  215.         delete_region_display_list(ctx, region);

  216.         av_free(region->pbuf);

  217.         av_free(region);

  218.     }

  219. 

  220.     while (ctx->clut_list) {

  221.         clut = ctx->clut_list;

  222. 

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

  224. 

  225.         av_free(clut);

  226.     }

  227. 

  228.     av_freep(&ctx->display_definition);

  229. 

  230.     /* Should already be null */

  231.     if (ctx->object_list)

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

  233. }

  234. 

  235. static av_cold int dvbsub_init_decoder(AVCodecContext *avctx)

  236. {

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

  238.     DVBSubContext *ctx = avctx->priv_data;

  239. 

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

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

  242.         ctx->composition_id = -1;

  243.         ctx->ancillary_id   = -1;

  244.     } else {

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

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

  247.     }

  248. 

  249.     default_clut.id = -1;

  250.     default_clut.next = NULL;

  251. 

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

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

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

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

  256. 

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

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

  259.         if (i < 8) {

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

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

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

  263.         } else {

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

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

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

  267.         }

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

  269.     }

  270. 

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

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

  273.         if (i < 8) {

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

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

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

  277.             a = 63;

  278.         } else {

  279.             switch (i & 0x88) {

  280.             case 0x00:

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

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

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

  284.                 a = 255;

  285.                 break;

  286.             case 0x08:

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

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

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

  290.                 a = 127;

  291.                 break;

  292.             case 0x80:

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

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

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

  296.                 a = 255;

  297.                 break;

  298.             case 0x88:

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

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

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

  302.                 a = 255;

  303.                 break;

  304.             }

  305.         }

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

  307.     }

  308. 

  309.     return 0;

  310. }

  311. 

  312. static av_cold int dvbsub_close_decoder(AVCodecContext *avctx)

  313. {

  314.     DVBSubContext *ctx = avctx->priv_data;

  315.     DVBSubRegionDisplay *display;

  316. 

  317.     delete_state(ctx);

  318. 

  319.     while (ctx->display_list) {

  320.         display = ctx->display_list;

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

  322. 

  323.         av_free(display);

  324.     }

  325. 

  326.     return 0;

  327. }

  328. 

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

  330.                                    const uint8_t **srcbuf, int buf_size,

  331.                                    int non_mod, uint8_t *map_table)

  332. {

  333.     BitstreamContext bc;

  334. 

  335.     int bits;

  336.     int run_length;

  337.     int pixels_read = 0;

  338. 

  339.     bitstream_init8(&bc, *srcbuf, buf_size);

  340. 

  341.     while (bitstream_tell(&bc) < buf_size << 3 && pixels_read < dbuf_len) {

  342.         bits = bitstream_read(&bc, 2);

  343. 

  344.         if (bits) {

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

  346.                 if (map_table)

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

  348.                 else

  349.                     *destbuf++ = bits;

  350.             }

  351.             pixels_read++;

  352.         } else {

  353.             bits = bitstream_read_bit(&bc);

  354.             if (bits == 1) {

  355.                 run_length = bitstream_read(&bc, 3) + 3;

  356.                 bits       = bitstream_read(&bc, 2);

  357. 

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

  359.                     pixels_read += run_length;

  360.                 else {

  361.                     if (map_table)

  362.                         bits = map_table[bits];

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

  364.                         *destbuf++ = bits;

  365.                         pixels_read++;

  366.                     }

  367.                 }

  368.             } else {

  369.                 bits = bitstream_read_bit(&bc);

  370.                 if (bits == 0) {

  371.                     bits = bitstream_read(&bc, 2);

  372.                     if (bits == 2) {

  373.                         run_length = bitstream_read(&bc, 4) + 12;

  374.                         bits       = bitstream_read(&bc, 2);

  375. 

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

  377.                             pixels_read += run_length;

  378.                         else {

  379.                             if (map_table)

  380.                                 bits = map_table[bits];

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

  382.                                 *destbuf++ = bits;

  383.                                 pixels_read++;

  384.                             }

  385.                         }

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

  387.                         run_length = bitstream_read(&bc, 8) + 29;

  388.                         bits = bitstream_read(&bc, 2);

  389. 

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

  391.                             pixels_read += run_length;

  392.                         else {

  393.                             if (map_table)

  394.                                 bits = map_table[bits];

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

  396.                                 *destbuf++ = bits;

  397.                                 pixels_read++;

  398.                             }

  399.                         }

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

  401.                         pixels_read += 2;

  402.                         if (map_table)

  403.                             bits = map_table[0];

  404.                         else

  405.                             bits = 0;

  406.                         if (pixels_read <= dbuf_len) {

  407.                             *destbuf++ = bits;

  408.                             *destbuf++ = bits;

  409.                         }

  410.                     } else {

  411.                         *srcbuf += (bitstream_tell(&bc) + 7) >> 3;

  412.                         return pixels_read;

  413.                     }

  414.                 } else {

  415.                     if (map_table)

  416.                         bits = map_table[0];

  417.                     else

  418.                         bits = 0;

  419.                     *destbuf++ = bits;

  420.                     pixels_read++;

  421.                 }

  422.             }

  423.         }

  424.     }

  425. 

  426.     if (bitstream_read(&bc, 6))

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

  428. 

  429.     *srcbuf += (bitstream_tell(&bc) + 7) >> 3;

  430. 

  431.     return pixels_read;

  432. }

  433. 

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

  435.                                    const uint8_t **srcbuf, int buf_size,

  436.                                    int non_mod, uint8_t *map_table)

  437. {

  438.     BitstreamContext bc;

  439. 

  440.     int bits;

  441.     int run_length;

  442.     int pixels_read = 0;

  443. 

  444.     bitstream_init8(&bc, *srcbuf, buf_size);

  445. 

  446.     while (bitstream_tell(&bc) < buf_size << 3 && pixels_read < dbuf_len) {

  447.         bits = bitstream_read(&bc, 4);

  448. 

  449.         if (bits) {

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

  451.                 if (map_table)

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

  453.                 else

  454.                     *destbuf++ = bits;

  455.             }

  456.             pixels_read++;

  457.         } else {

  458.             bits = bitstream_read_bit(&bc);

  459.             if (bits == 0) {

  460.                 run_length = bitstream_read(&bc, 3);

  461. 

  462.                 if (run_length == 0) {

  463.                     *srcbuf += (bitstream_tell(&bc) + 7) >> 3;

  464.                     return pixels_read;

  465.                 }

  466. 

  467.                 run_length += 2;

  468. 

  469.                 if (map_table)

  470.                     bits = map_table[0];

  471.                 else

  472.                     bits = 0;

  473. 

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

  475.                     *destbuf++ = bits;

  476.                     pixels_read++;

  477.                 }

  478.             } else {

  479.                 bits = bitstream_read_bit(&bc);

  480.                 if (bits == 0) {

  481.                     run_length = bitstream_read(&bc, 2) + 4;

  482.                     bits       = bitstream_read(&bc, 4);

  483. 

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

  485.                         pixels_read += run_length;

  486.                     else {

  487.                         if (map_table)

  488.                             bits = map_table[bits];

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

  490.                             *destbuf++ = bits;

  491.                             pixels_read++;

  492.                         }

  493.                     }

  494.                 } else {

  495.                     bits = bitstream_read(&bc, 2);

  496.                     if (bits == 2) {

  497.                         run_length = bitstream_read(&bc, 4) + 9;

  498.                         bits       = bitstream_read(&bc, 4);

  499. 

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

  501.                             pixels_read += run_length;

  502.                         else {

  503.                             if (map_table)

  504.                                 bits = map_table[bits];

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

  506.                                 *destbuf++ = bits;

  507.                                 pixels_read++;

  508.                             }

  509.                         }

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

  511.                         run_length = bitstream_read(&bc, 8) + 25;

  512.                         bits = bitstream_read(&bc, 4);

  513. 

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

  515.                             pixels_read += run_length;

  516.                         else {

  517.                             if (map_table)

  518.                                 bits = map_table[bits];

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

  520.                                 *destbuf++ = bits;

  521.                                 pixels_read++;

  522.                             }

  523.                         }

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

  525.                         pixels_read += 2;

  526.                         if (map_table)

  527.                             bits = map_table[0];

  528.                         else

  529.                             bits = 0;

  530.                         if (pixels_read <= dbuf_len) {

  531.                             *destbuf++ = bits;

  532.                             *destbuf++ = bits;

  533.                         }

  534.                     } else {

  535.                         if (map_table)

  536.                             bits = map_table[0];

  537.                         else

  538.                             bits = 0;

  539.                         *destbuf++ = bits;

  540.                         pixels_read ++;

  541.                     }

  542.                 }

  543.             }

  544.         }

  545.     }

  546. 

  547.     if (bitstream_read(&bc, 8))

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

  549. 

  550.     *srcbuf += (bitstream_tell(&bc) + 7) >> 3;

  551. 

  552.     return pixels_read;

  553. }

  554. 

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

  556.                                     const uint8_t **srcbuf, int buf_size,

  557.                                     int non_mod, uint8_t *map_table)

  558. {

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

  560.     int bits;

  561.     int run_length;

  562.     int pixels_read = 0;

  563. 

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

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

  566. 

  567.         if (bits) {

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

  569.                 if (map_table)

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

  571.                 else

  572.                     *destbuf++ = bits;

  573.             }

  574.             pixels_read++;

  575.         } else {

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

  577.             run_length = bits & 0x7f;

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

  579.                 if (run_length == 0) {

  580.                     return pixels_read;

  581.                 }

  582.             } else {

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

  584. 

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

  586.                     pixels_read += run_length;

  587.             }

  588.             if (map_table)

  589.                 bits = map_table[0];

  590.             else

  591.                 bits = 0;

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

  593.                 *destbuf++ = bits;

  594.                 pixels_read++;

  595.             }

  596.         }

  597.     }

  598. 

  599.     if (*(*srcbuf)++)

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

  601. 

  602.     return pixels_read;

  603. }

  604. 

  605. 

  606. 

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

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

  609. {

  610.     DVBSubContext *ctx = avctx->priv_data;

  611. 

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

  613.     const uint8_t *buf_end = buf + buf_size;

  614.     uint8_t *pbuf;

  615.     int x_pos, y_pos;

  616.     int i;

  617. 

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

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

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

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

  622.     uint8_t *map_table;

  623. 

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

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

  626. 

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

  628.         if (i % 16 == 0)

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

  630. 

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

  632.         if (i % 16 == 15)

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

  634.     }

  635. 

  636.     if (i % 16)

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

  638. 

  639.     if (region == 0)

  640.         return;

  641. 

  642.     pbuf = region->pbuf;

  643. 

  644.     x_pos = display->x_pos;

  645.     y_pos = display->y_pos;

  646. 

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

  648.         y_pos++;

  649. 

  650.     while (buf < buf_end) {

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

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

  653.             return;

  654.         }

  655. 

  656.         switch (*buf++) {

  657.         case 0x10:

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

  659.                 map_table = map2to8;

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

  661.                 map_table = map2to4;

  662.             else

  663.                 map_table = NULL;

  664. 

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

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

  667.                                                 non_mod, map_table);

  668.             break;

  669.         case 0x11:

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

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

  672.                 return;

  673.             }

  674. 

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

  676.                 map_table = map4to8;

  677.             else

  678.                 map_table = NULL;

  679. 

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

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

  682.                                                 non_mod, map_table);

  683.             break;

  684.         case 0x12:

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

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

  687.                 return;

  688.             }

  689. 

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

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

  692.                                                 non_mod, NULL);

  693.             break;

  694. 

  695.         case 0x20:

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

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

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

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

  700.             break;

  701.         case 0x21:

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

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

  704.             break;

  705.         case 0x22:

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

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

  708.             break;

  709. 

  710.         case 0xf0:

  711.             x_pos = display->x_pos;

  712.             y_pos += 2;

  713.             break;

  714.         default:

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

  716.         }

  717.     }

  718. 

  719. }

  720. 

  721. static int dvbsub_parse_object_segment(AVCodecContext *avctx,

  722.                                        const uint8_t *buf, int buf_size)

  723. {

  724.     DVBSubContext *ctx = avctx->priv_data;

  725. 

  726.     const uint8_t *buf_end = buf + buf_size;

  727.     const uint8_t *block;

  728.     int object_id;

  729.     DVBSubObject *object;

  730.     DVBSubObjectDisplay *display;

  731.     int top_field_len, bottom_field_len;

  732. 

  733.     int coding_method, non_modifying_color;

  734. 

  735.     object_id = AV_RB16(buf);

  736.     buf += 2;

  737. 

  738.     object = get_object(ctx, object_id);

  739. 

  740.     if (!object)

  741.         return AVERROR_INVALIDDATA;

  742. 

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

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

  745. 

  746.     if (coding_method == 0) {

  747.         top_field_len = AV_RB16(buf);

  748.         buf += 2;

  749.         bottom_field_len = AV_RB16(buf);

  750.         buf += 2;

  751. 

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

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

  754.             return AVERROR_INVALIDDATA;

  755.         }

  756. 

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

  758.             block = buf;

  759. 

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

  761.                                             non_modifying_color);

  762. 

  763.             if (bottom_field_len > 0)

  764.                 block = buf + top_field_len;

  765.             else

  766.                 bottom_field_len = top_field_len;

  767. 

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

  769.                                             non_modifying_color);

  770.         }

  771. 

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

  773. 

  774.     } else {

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

  776.     }

  777. 

  778.     return 0;

  779. }

  780. 

  781. static int dvbsub_parse_clut_segment(AVCodecContext *avctx,

  782.                                      const uint8_t *buf, int buf_size)

  783. {

  784.     DVBSubContext *ctx = avctx->priv_data;

  785. 

  786.     const uint8_t *buf_end = buf + buf_size;

  787.     int i, clut_id;

  788.     DVBSubCLUT *clut;

  789.     int entry_id, depth , full_range;

  790.     int y, cr, cb, alpha;

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

  792. 

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

  794. 

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

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

  797.         if (i % 16 == 15)

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

  799.     }

  800. 

  801.     if (i % 16)

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

  803. 

  804.     clut_id = *buf++;

  805.     buf += 1;

  806. 

  807.     clut = get_clut(ctx, clut_id);

  808. 

  809.     if (!clut) {

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

  811.         if (!clut)

  812.             return AVERROR(ENOMEM);

  813. 

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

  815. 

  816.         clut->id = clut_id;

  817. 

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

  819.         ctx->clut_list = clut;

  820.     }

  821. 

  822.     while (buf + 4 < buf_end) {

  823.         entry_id = *buf++;

  824. 

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

  826. 

  827.         if (depth == 0) {

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

  829.             return AVERROR_INVALIDDATA;

  830.         }

  831. 

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

  833. 

  834.         if (full_range) {

  835.             y = *buf++;

  836.             cr = *buf++;

  837.             cb = *buf++;

  838.             alpha = *buf++;

  839.         } else {

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

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

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

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

  844. 

  845.             buf += 2;

  846.         }

  847. 

  848.         if (y == 0)

  849.             alpha = 0xff;

  850. 

  851.         YUV_TO_RGB1_CCIR(cb, cr);

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

  853. 

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

  855. 

  856.         if (depth & 0x80)

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

  858.         if (depth & 0x40)

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

  860.         if (depth & 0x20)

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

  862.     }

  863. 

  864.     return 0;

  865. }

  866. 

  867. 

  868. static int dvbsub_parse_region_segment(AVCodecContext *avctx,

  869.                                        const uint8_t *buf, int buf_size)

  870. {

  871.     DVBSubContext *ctx = avctx->priv_data;

  872. 

  873.     const uint8_t *buf_end = buf + buf_size;

  874.     int region_id, object_id;

  875.     DVBSubRegion *region;

  876.     DVBSubObject *object;

  877.     DVBSubObjectDisplay *display;

  878.     int fill;

  879. 

  880.     if (buf_size < 10)

  881.         return AVERROR_INVALIDDATA;

  882. 

  883.     region_id = *buf++;

  884. 

  885.     region = get_region(ctx, region_id);

  886. 

  887.     if (!region) {

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

  889.         if (!region)

  890.             return AVERROR(ENOMEM);

  891. 

  892.         region->id = region_id;

  893. 

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

  895.         ctx->region_list = region;

  896.     }

  897. 

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

  899. 

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

  901.     buf += 2;

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

  903.     buf += 2;

  904. 

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

  906.         av_free(region->pbuf);

  907. 

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

  909. 

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

  911.         if (!region->pbuf)

  912.             return AVERROR(ENOMEM);

  913. 

  914.         fill = 1;

  915.     }

  916. 

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

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

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

  920.         region->depth= 4;

  921.     }

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

  923. 

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

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

  926.     else {

  927.         buf += 1;

  928. 

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

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

  931.         else

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

  933.     }

  934. 

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

  936. 

  937.     if (fill) {

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

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

  940.     }

  941. 

  942.     delete_region_display_list(ctx, region);

  943. 

  944.     while (buf + 5 < buf_end) {

  945.         object_id = AV_RB16(buf);

  946.         buf += 2;

  947. 

  948.         object = get_object(ctx, object_id);

  949. 

  950.         if (!object) {

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

  952.             if (!object)

  953.                 return AVERROR(ENOMEM);

  954. 

  955.             object->id = object_id;

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

  957.             ctx->object_list = object;

  958.         }

  959. 

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

  961. 

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

  963.         if (!display)

  964.             return AVERROR(ENOMEM);

  965. 

  966.         display->object_id = object_id;

  967.         display->region_id = region_id;

  968. 

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

  970.         buf += 2;

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

  972.         buf += 2;

  973. 

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

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

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

  977.         }

  978. 

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

  980.         region->display_list = display;

  981. 

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

  983.         object->display_list = display;

  984.     }

  985. 

  986.     return 0;

  987. }

  988. 

  989. static int dvbsub_parse_page_segment(AVCodecContext *avctx,

  990.                                      const uint8_t *buf, int buf_size)

  991. {

  992.     DVBSubContext *ctx = avctx->priv_data;

  993.     DVBSubRegionDisplay *display;

  994.     DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;

  995. 

  996.     const uint8_t *buf_end = buf + buf_size;

  997.     int region_id;

  998.     int page_state;

  999. 

  1000.     if (buf_size < 1)

  1001.         return AVERROR_INVALIDDATA;

  1002. 

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

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

  1005. 

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

  1007. 

  1008.     if (page_state == 2) {

  1009.         delete_state(ctx);

  1010.     }

  1011. 

  1012.     tmp_display_list = ctx->display_list;

  1013.     ctx->display_list = NULL;

  1014.     ctx->display_list_size = 0;

  1015. 

  1016.     while (buf + 5 < buf_end) {

  1017.         region_id = *buf++;

  1018.         buf += 1;

  1019. 

  1020.         display = tmp_display_list;

  1021.         tmp_ptr = &tmp_display_list;

  1022. 

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

  1024.             tmp_ptr = &display->next;

  1025.             display = display->next;

  1026.         }

  1027. 

  1028.         if (!display) {

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

  1030.             if (!display)

  1031.                 return AVERROR(ENOMEM);

  1032.         }

  1033. 

  1034.         display->region_id = region_id;

  1035. 

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

  1037.         buf += 2;

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

  1039.         buf += 2;

  1040. 

  1041.         *tmp_ptr = display->next;

  1042. 

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

  1044.         ctx->display_list = display;

  1045.         ctx->display_list_size++;

  1046. 

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

  1048.     }

  1049. 

  1050.     while (tmp_display_list) {

  1051.         display = tmp_display_list;

  1052. 

  1053.         tmp_display_list = display->next;

  1054. 

  1055.         av_free(display);

  1056.     }

  1057. 

  1058.     return 0;

  1059. }

  1060. 

  1061. 

  1062. #ifdef DEBUG

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

  1064. {

  1065.     int x, y, v;

  1066.     FILE *f;

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

  1068.     char command[1024];

  1069. 

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

  1071. 

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

  1073.     if (!f) {

  1074.         perror(fname);

  1075.         return;

  1076.     }

  1077.     fprintf(f, "P6\n"

  1078.             "%d %d\n"

  1079.             "%d\n",

  1080.             w, h, 255);

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

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

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

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

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

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

  1087.         }

  1088.     }

  1089.     fclose(f);

  1090. 

  1091. 

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

  1093. 

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

  1095.     if (!f) {

  1096.         perror(fname2);

  1097.         return;

  1098.     }

  1099.     fprintf(f, "P5\n"

  1100.             "%d %d\n"

  1101.             "%d\n",

  1102.             w, h, 255);

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

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

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

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

  1107.         }

  1108.     }

  1109.     fclose(f);

  1110. 

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

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

  1113.         printf("Error running pnmtopng\n");

  1114.         return;

  1115.     }

  1116. 

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

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

  1119.         printf("Error removing %s and %s\n", fname, fname2);

  1120.         return;

  1121.     }

  1122. }

  1123. 

  1124. static int save_display_set(DVBSubContext *ctx)

  1125. {

  1126.     DVBSubRegion *region;

  1127.     DVBSubRegionDisplay *display;

  1128.     DVBSubCLUT *clut;

  1129.     uint32_t *clut_table;

  1130.     int x_pos, y_pos, width, height;

  1131.     int x, y, y_off, x_off;

  1132.     uint32_t *pbuf;

  1133.     char filename[32];

  1134.     static int fileno_index = 0;

  1135. 

  1136.     x_pos = -1;

  1137.     y_pos = -1;

  1138.     width = 0;

  1139.     height = 0;

  1140. 

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

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

  1143. 

  1144.         if (x_pos == -1) {

  1145.             x_pos = display->x_pos;

  1146.             y_pos = display->y_pos;

  1147.             width = region->width;

  1148.             height = region->height;

  1149.         } else {

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

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

  1152.                 x_pos = display->x_pos;

  1153.             }

  1154. 

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

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

  1157.                 y_pos = display->y_pos;

  1158.             }

  1159. 

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

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

  1162.             }

  1163. 

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

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

  1166.             }

  1167.         }

  1168.     }

  1169. 

  1170.     if (x_pos >= 0) {

  1171. 

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

  1173.         if (!pbuf)

  1174.             return AVERROR(ENOMEM);

  1175. 

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

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

  1178. 

  1179.             x_off = display->x_pos - x_pos;

  1180.             y_off = display->y_pos - y_pos;

  1181. 

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

  1183. 

  1184.             if (clut == 0)

  1185.                 clut = &default_clut;

  1186. 

  1187.             switch (region->depth) {

  1188.             case 2:

  1189.                 clut_table = clut->clut4;

  1190.                 break;

  1191.             case 8:

  1192.                 clut_table = clut->clut256;

  1193.                 break;

  1194.             case 4:

  1195.             default:

  1196.                 clut_table = clut->clut16;

  1197.                 break;

  1198.             }

  1199. 

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

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

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

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

  1204.                 }

  1205.             }

  1206. 

  1207.         }

  1208. 

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

  1210. 

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

  1212. 

  1213.         av_free(pbuf);

  1214.     }

  1215. 

  1216.     fileno_index++;

  1217.     return 0;

  1218. }

  1219. #endif /* DEBUG */

  1220. 

  1221. static int dvbsub_parse_display_definition_segment(AVCodecContext *avctx,

  1222.                                                    const uint8_t *buf,

  1223.                                                    int buf_size)

  1224. {

  1225.     DVBSubContext *ctx = avctx->priv_data;

  1226.     DVBSubDisplayDefinition *display_def = ctx->display_definition;

  1227.     int dds_version, info_byte;

  1228. 

  1229.     if (buf_size < 5)

  1230.         return AVERROR_INVALIDDATA;

  1231. 

  1232.     info_byte   = bytestream_get_byte(&buf);

  1233.     dds_version = info_byte >> 4;

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

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

  1236. 

  1237.     if (!display_def) {

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

  1239.         if (!display_def)

  1240.             return AVERROR(ENOMEM);

  1241.         ctx->display_definition = display_def;

  1242.     }

  1243. 

  1244.     display_def->version = dds_version;

  1245.     display_def->x       = 0;

  1246.     display_def->y       = 0;

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

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

  1249. 

  1250.     if (buf_size < 13)

  1251.         return AVERROR_INVALIDDATA;

  1252. 

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

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

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

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

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

  1258.     }

  1259. 

  1260.     return 0;

  1261. }

  1262. 

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

  1264.                                       int buf_size, AVSubtitle *sub)

  1265. {

  1266.     DVBSubContext *ctx = avctx->priv_data;

  1267.     DVBSubDisplayDefinition *display_def = ctx->display_definition;

  1268. 

  1269.     DVBSubRegion *region;

  1270.     DVBSubRegionDisplay *display;

  1271.     AVSubtitleRect *rect;

  1272.     DVBSubCLUT *clut;

  1273.     uint32_t *clut_table;

  1274.     int i;

  1275.     int offset_x=0, offset_y=0;

  1276. 

  1277.     sub->rects = NULL;

  1278.     sub->start_display_time = 0;

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

  1280.     sub->format = 0;

  1281. 

  1282.     if (display_def) {

  1283.         offset_x = display_def->x;

  1284.         offset_y = display_def->y;

  1285.     }

  1286. 

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

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

  1289.         return AVERROR_INVALIDDATA;

  1290. 

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

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

  1293.     if (!sub->rects)

  1294.         return AVERROR(ENOMEM);

  1295. 

  1296.     i = 0;

  1297. 

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

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

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

  1301. 

  1302.         if (!region)

  1303.             continue;

  1304. 

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

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

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

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

  1309.         rect->nb_colors = 16;

  1310.         rect->type      = SUBTITLE_BITMAP;

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

  1312. 

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

  1314. 

  1315.         if (!clut)

  1316.             clut = &default_clut;

  1317. 

  1318.         switch (region->depth) {

  1319.         case 2:

  1320.             clut_table = clut->clut4;

  1321.             break;

  1322.         case 8:

  1323.             clut_table = clut->clut256;

  1324.             break;

  1325.         case 4:

  1326.         default:

  1327.             clut_table = clut->clut16;

  1328.             break;

  1329.         }

  1330. 

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

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

  1333.             av_free(sub->rects);

  1334.             return AVERROR(ENOMEM);

  1335.         }

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

  1337. 

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

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

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

  1341.             av_free(sub->rects);

  1342.             return AVERROR(ENOMEM);

  1343.         }

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

  1345. 

  1346. #if FF_API_AVPICTURE

  1347. FF_DISABLE_DEPRECATION_WARNINGS

  1348. {

  1349.         int j;

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

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

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

  1353.         }

  1354. }

  1355. FF_ENABLE_DEPRECATION_WARNINGS

  1356. #endif

  1357. 

  1358.         i++;

  1359.     }

  1360. 

  1361.     sub->num_rects = i;

  1362. 

  1363. #ifdef DEBUG

  1364.     save_display_set(ctx);

  1365. #endif

  1366. 

  1367.     return 1;

  1368. }

  1369. 

  1370. static int dvbsub_decode(AVCodecContext *avctx,

  1371.                          void *data, int *data_size,

  1372.                          AVPacket *avpkt)

  1373. {

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

  1375.     int buf_size = avpkt->size;

  1376.     DVBSubContext *ctx = avctx->priv_data;

  1377.     AVSubtitle *sub = data;

  1378.     const uint8_t *p, *p_end;

  1379.     int segment_type;

  1380.     int page_id;

  1381.     int segment_length;

  1382.     int i;

  1383. 

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

  1385. 

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

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

  1388.         if (i % 16 == 15)

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

  1390.     }

  1391. 

  1392.     if (i % 16)

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

  1394. 

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

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

  1397.         return AVERROR_INVALIDDATA;

  1398.     }

  1399. 

  1400.     p = buf;

  1401.     p_end = buf + buf_size;

  1402. 

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

  1404.         p += 1;

  1405.         segment_type = *p++;

  1406.         page_id = AV_RB16(p);

  1407.         p += 2;

  1408.         segment_length = AV_RB16(p);

  1409.         p += 2;

  1410. 

  1411.         if (p_end - p < segment_length) {

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

  1413.             return -1;

  1414.         }

  1415. 

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

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

  1418.             int ret = 0;

  1419.             switch (segment_type) {

  1420.             case DVBSUB_PAGE_SEGMENT:

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

  1422.                 break;

  1423.             case DVBSUB_REGION_SEGMENT:

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

  1425.                 break;

  1426.             case DVBSUB_CLUT_SEGMENT:

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

  1428.                 break;

  1429.             case DVBSUB_OBJECT_SEGMENT:

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

  1431.                 break;

  1432.             case DVBSUB_DISPLAYDEFINITION_SEGMENT:

  1433.                 ret = dvbsub_parse_display_definition_segment(avctx, p,

  1434.                                                               segment_length);

  1435.                 break;

  1436.             case DVBSUB_DISPLAY_SEGMENT:

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

  1438.                 *data_size = ret;

  1439.                 break;

  1440.             default:

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

  1442.                         segment_type, page_id, segment_length);

  1443.                 break;

  1444.             }

  1445.             if (ret < 0)

  1446.                 return ret;

  1447.         }

  1448. 

  1449.         p += segment_length;

  1450.     }

  1451. 

  1452.     return p - buf;

  1453. }

  1454. 

  1455. 

  1456. AVCodec ff_dvbsub_decoder = {

  1457.     .name           = "dvbsub",

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

  1459.     .type           = AVMEDIA_TYPE_SUBTITLE,

  1460.     .id             = AV_CODEC_ID_DVB_SUBTITLE,

  1461.     .priv_data_size = sizeof(DVBSubContext),

  1462.     .init           = dvbsub_init_decoder,

  1463.     .close          = dvbsub_close_decoder,

  1464.     .decode         = dvbsub_decode,

  1465. };