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

1474 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. #include "avcodec.h"

  22. #include "dsputil.h"

  23. #include "get_bits.h"

  24. #include "bytestream.h"

  25. #include "libavutil/colorspace.h"

  26. 

  27. #define DVBSUB_PAGE_SEGMENT     0x10

  28. #define DVBSUB_REGION_SEGMENT   0x11

  29. #define DVBSUB_CLUT_SEGMENT     0x12

  30. #define DVBSUB_OBJECT_SEGMENT   0x13

  31. #define DVBSUB_DISPLAYDEFINITION_SEGMENT 0x14

  32. #define DVBSUB_DISPLAY_SEGMENT  0x80

  33. 

  34. #define cm (ff_crop_tab + MAX_NEG_CROP)

  35. 

  36. #ifdef DEBUG

  37. #if 0

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

  39.                      uint32_t *rgba_palette)

  40. {

  41.     int x, y, v;

  42.     FILE *f;

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

  44.     char command[1024];

  45. 

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

  47. 

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

  49.     if (!f) {

  50.         perror(fname);

  51.         return;

  52.     }

  53.     fprintf(f, "P6\n"

  54.             "%d %d\n"

  55.             "%d\n",

  56.             w, h, 255);

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

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

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

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

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

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

  63.         }

  64.     }

  65.     fclose(f);

  66. 

  67. 

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

  69. 

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

  71.     if (!f) {

  72.         perror(fname2);

  73.         return;

  74.     }

  75.     fprintf(f, "P5\n"

  76.             "%d %d\n"

  77.             "%d\n",

  78.             w, h, 255);

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

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

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

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

  83.         }

  84.     }

  85.     fclose(f);

  86. 

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

  88.     system(command);

  89. 

  90.     snprintf(command, 1024, "rm %s %s", fname, fname2);

  91.     system(command);

  92. }

  93. #endif

  94. 

  95. static void png_save2(const char *filename, uint32_t *bitmap, int w, int h)

  96. {

  97.     int x, y, v;

  98.     FILE *f;

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

  100.     char command[1024];

  101. 

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

  103. 

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

  105.     if (!f) {

  106.         perror(fname);

  107.         return;

  108.     }

  109.     fprintf(f, "P6\n"

  110.             "%d %d\n"

  111.             "%d\n",

  112.             w, h, 255);

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

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

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

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

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

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

  119.         }

  120.     }

  121.     fclose(f);

  122. 

  123. 

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

  125. 

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

  127.     if (!f) {

  128.         perror(fname2);

  129.         return;

  130.     }

  131.     fprintf(f, "P5\n"

  132.             "%d %d\n"

  133.             "%d\n",

  134.             w, h, 255);

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

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

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

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

  139.         }

  140.     }

  141.     fclose(f);

  142. 

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

  144.     system(command);

  145. 

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

  147.     system(command);

  148. }

  149. #endif

  150. 

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

  152. 

  153. typedef struct DVBSubCLUT {

  154.     int id;

  155. 

  156.     uint32_t clut4[4];

  157.     uint32_t clut16[16];

  158.     uint32_t clut256[256];

  159. 

  160.     struct DVBSubCLUT *next;

  161. } DVBSubCLUT;

  162. 

  163. static DVBSubCLUT default_clut;

  164. 

  165. typedef struct DVBSubObjectDisplay {

  166.     int object_id;

  167.     int region_id;

  168. 

  169.     int x_pos;

  170.     int y_pos;

  171. 

  172.     int fgcolor;

  173.     int bgcolor;

  174. 

  175.     struct DVBSubObjectDisplay *region_list_next;

  176.     struct DVBSubObjectDisplay *object_list_next;

  177. } DVBSubObjectDisplay;

  178. 

  179. typedef struct DVBSubObject {

  180.     int id;

  181. 

  182.     int type;

  183. 

  184.     DVBSubObjectDisplay *display_list;

  185. 

  186.     struct DVBSubObject *next;

  187. } DVBSubObject;

  188. 

  189. typedef struct DVBSubRegionDisplay {

  190.     int region_id;

  191. 

  192.     int x_pos;

  193.     int y_pos;

  194. 

  195.     struct DVBSubRegionDisplay *next;

  196. } DVBSubRegionDisplay;

  197. 

  198. typedef struct DVBSubRegion {

  199.     int id;

  200. 

  201.     int width;

  202.     int height;

  203.     int depth;

  204. 

  205.     int clut;

  206.     int bgcolor;

  207. 

  208.     uint8_t *pbuf;

  209.     int buf_size;

  210. 

  211.     DVBSubObjectDisplay *display_list;

  212. 

  213.     struct DVBSubRegion *next;

  214. } DVBSubRegion;

  215. 

  216. typedef struct DVBSubDisplayDefinition {

  217.     int version;

  218. 

  219.     int x;

  220.     int y;

  221.     int width;

  222.     int height;

  223. } DVBSubDisplayDefinition;

  224. 

  225. typedef struct DVBSubContext {

  226.     int composition_id;

  227.     int ancillary_id;

  228. 

  229.     int time_out;

  230.     DVBSubRegion *region_list;

  231.     DVBSubCLUT   *clut_list;

  232.     DVBSubObject *object_list;

  233. 

  234.     int display_list_size;

  235.     DVBSubRegionDisplay *display_list;

  236.     DVBSubDisplayDefinition *display_definition;

  237. } DVBSubContext;

  238. 

  239. 

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

  241. {

  242.     DVBSubObject *ptr = ctx->object_list;

  243. 

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

  245.         ptr = ptr->next;

  246.     }

  247. 

  248.     return ptr;

  249. }

  250. 

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

  252. {

  253.     DVBSubCLUT *ptr = ctx->clut_list;

  254. 

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

  256.         ptr = ptr->next;

  257.     }

  258. 

  259.     return ptr;

  260. }

  261. 

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

  263. {

  264.     DVBSubRegion *ptr = ctx->region_list;

  265. 

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

  267.         ptr = ptr->next;

  268.     }

  269. 

  270.     return ptr;

  271. }

  272. 

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

  274. {

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

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

  277. 

  278.     while (region->display_list) {

  279.         display = region->display_list;

  280. 

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

  282. 

  283.         if (object) {

  284.             obj_disp_ptr = &object->display_list;

  285.             obj_disp = *obj_disp_ptr;

  286. 

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

  288.                 obj_disp_ptr = &obj_disp->object_list_next;

  289.                 obj_disp = *obj_disp_ptr;

  290.             }

  291. 

  292.             if (obj_disp) {

  293.                 *obj_disp_ptr = obj_disp->object_list_next;

  294. 

  295.                 if (!object->display_list) {

  296.                     obj2_ptr = &ctx->object_list;

  297.                     obj2 = *obj2_ptr;

  298. 

  299.                     while (obj2 != object) {

  300.                         assert(obj2);

  301.                         obj2_ptr = &obj2->next;

  302.                         obj2 = *obj2_ptr;

  303.                     }

  304. 

  305.                     *obj2_ptr = obj2->next;

  306. 

  307.                     av_free(obj2);

  308.                 }

  309.             }

  310.         }

  311. 

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

  313. 

  314.         av_free(display);

  315.     }

  316. 

  317. }

  318. 

  319. static void delete_state(DVBSubContext *ctx)

  320. {

  321.     DVBSubRegion *region;

  322.     DVBSubCLUT *clut;

  323. 

  324.     while (ctx->region_list) {

  325.         region = ctx->region_list;

  326. 

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

  328. 

  329.         delete_region_display_list(ctx, region);

  330.         av_free(region->pbuf);

  331.         av_free(region);

  332.     }

  333. 

  334.     while (ctx->clut_list) {

  335.         clut = ctx->clut_list;

  336. 

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

  338. 

  339.         av_free(clut);

  340.     }

  341. 

  342.     av_freep(&ctx->display_definition);

  343. 

  344.     /* Should already be null */

  345.     if (ctx->object_list)

  346.         av_log(0, AV_LOG_ERROR, "Memory deallocation error!\n");

  347. }

  348. 

  349. static av_cold int dvbsub_init_decoder(AVCodecContext *avctx)

  350. {

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

  352.     DVBSubContext *ctx = avctx->priv_data;

  353. 

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

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

  356.         ctx->composition_id = -1;

  357.         ctx->ancillary_id   = -1;

  358.     } else {

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

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

  361.     }

  362. 

  363.     default_clut.id = -1;

  364.     default_clut.next = NULL;

  365. 

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

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

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

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

  370. 

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

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

  373.         if (i < 8) {

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

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

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

  377.         } else {

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

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

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

  381.         }

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

  383.     }

  384. 

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

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

  387.         if (i < 8) {

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

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

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

  391.             a = 63;

  392.         } else {

  393.             switch (i & 0x88) {

  394.             case 0x00:

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

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

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

  398.                 a = 255;

  399.                 break;

  400.             case 0x08:

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

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

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

  404.                 a = 127;

  405.                 break;

  406.             case 0x80:

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

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

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

  410.                 a = 255;

  411.                 break;

  412.             case 0x88:

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

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

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

  416.                 a = 255;

  417.                 break;

  418.             }

  419.         }

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

  421.     }

  422. 

  423.     return 0;

  424. }

  425. 

  426. static av_cold int dvbsub_close_decoder(AVCodecContext *avctx)

  427. {

  428.     DVBSubContext *ctx = avctx->priv_data;

  429.     DVBSubRegionDisplay *display;

  430. 

  431.     delete_state(ctx);

  432. 

  433.     while (ctx->display_list) {

  434.         display = ctx->display_list;

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

  436. 

  437.         av_free(display);

  438.     }

  439. 

  440.     return 0;

  441. }

  442. 

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

  444.                                    const uint8_t **srcbuf, int buf_size,

  445.                                    int non_mod, uint8_t *map_table)

  446. {

  447.     GetBitContext gb;

  448. 

  449.     int bits;

  450.     int run_length;

  451.     int pixels_read = 0;

  452. 

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

  454. 

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

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

  457. 

  458.         if (bits) {

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

  460.                 if (map_table)

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

  462.                 else

  463.                     *destbuf++ = bits;

  464.             }

  465.             pixels_read++;

  466.         } else {

  467.             bits = get_bits1(&gb);

  468.             if (bits == 1) {

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

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

  471. 

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

  473.                     pixels_read += run_length;

  474.                 else {

  475.                     if (map_table)

  476.                         bits = map_table[bits];

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

  478.                         *destbuf++ = bits;

  479.                         pixels_read++;

  480.                     }

  481.                 }

  482.             } else {

  483.                 bits = get_bits1(&gb);

  484.                 if (bits == 0) {

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

  486.                     if (bits == 2) {

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

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

  489. 

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

  491.                             pixels_read += run_length;

  492.                         else {

  493.                             if (map_table)

  494.                                 bits = map_table[bits];

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

  496.                                 *destbuf++ = bits;

  497.                                 pixels_read++;

  498.                             }

  499.                         }

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

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

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

  503. 

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

  505.                             pixels_read += run_length;

  506.                         else {

  507.                             if (map_table)

  508.                                 bits = map_table[bits];

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

  510.                                 *destbuf++ = bits;

  511.                                 pixels_read++;

  512.                             }

  513.                         }

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

  515.                         pixels_read += 2;

  516.                         if (map_table)

  517.                             bits = map_table[0];

  518.                         else

  519.                             bits = 0;

  520.                         if (pixels_read <= dbuf_len) {

  521.                             *destbuf++ = bits;

  522.                             *destbuf++ = bits;

  523.                         }

  524.                     } else {

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

  526.                         return pixels_read;

  527.                     }

  528.                 } else {

  529.                     if (map_table)

  530.                         bits = map_table[0];

  531.                     else

  532.                         bits = 0;

  533.                     *destbuf++ = bits;

  534.                     pixels_read++;

  535.                 }

  536.             }

  537.         }

  538.     }

  539. 

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

  541.         av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");

  542. 

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

  544. 

  545.     return pixels_read;

  546. }

  547. 

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

  549.                                    const uint8_t **srcbuf, int buf_size,

  550.                                    int non_mod, uint8_t *map_table)

  551. {

  552.     GetBitContext gb;

  553. 

  554.     int bits;

  555.     int run_length;

  556.     int pixels_read = 0;

  557. 

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

  559. 

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

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

  562. 

  563.         if (bits) {

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

  565.                 if (map_table)

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

  567.                 else

  568.                     *destbuf++ = bits;

  569.             }

  570.             pixels_read++;

  571.         } else {

  572.             bits = get_bits1(&gb);

  573.             if (bits == 0) {

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

  575. 

  576.                 if (run_length == 0) {

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

  578.                     return pixels_read;

  579.                 }

  580. 

  581.                 run_length += 2;

  582. 

  583.                 if (map_table)

  584.                     bits = map_table[0];

  585.                 else

  586.                     bits = 0;

  587. 

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

  589.                     *destbuf++ = bits;

  590.                     pixels_read++;

  591.                 }

  592.             } else {

  593.                 bits = get_bits1(&gb);

  594.                 if (bits == 0) {

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

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

  597. 

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

  599.                         pixels_read += run_length;

  600.                     else {

  601.                         if (map_table)

  602.                             bits = map_table[bits];

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

  604.                             *destbuf++ = bits;

  605.                             pixels_read++;

  606.                         }

  607.                     }

  608.                 } else {

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

  610.                     if (bits == 2) {

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

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

  613. 

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

  615.                             pixels_read += run_length;

  616.                         else {

  617.                             if (map_table)

  618.                                 bits = map_table[bits];

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

  620.                                 *destbuf++ = bits;

  621.                                 pixels_read++;

  622.                             }

  623.                         }

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

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

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

  627. 

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

  629.                             pixels_read += run_length;

  630.                         else {

  631.                             if (map_table)

  632.                                 bits = map_table[bits];

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

  634.                                 *destbuf++ = bits;

  635.                                 pixels_read++;

  636.                             }

  637.                         }

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

  639.                         pixels_read += 2;

  640.                         if (map_table)

  641.                             bits = map_table[0];

  642.                         else

  643.                             bits = 0;

  644.                         if (pixels_read <= dbuf_len) {

  645.                             *destbuf++ = bits;

  646.                             *destbuf++ = bits;

  647.                         }

  648.                     } else {

  649.                         if (map_table)

  650.                             bits = map_table[0];

  651.                         else

  652.                             bits = 0;

  653.                         *destbuf++ = bits;

  654.                         pixels_read ++;

  655.                     }

  656.                 }

  657.             }

  658.         }

  659.     }

  660. 

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

  662.         av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");

  663. 

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

  665. 

  666.     return pixels_read;

  667. }

  668. 

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

  670.                                     const uint8_t **srcbuf, int buf_size,

  671.                                     int non_mod, uint8_t *map_table)

  672. {

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

  674.     int bits;

  675.     int run_length;

  676.     int pixels_read = 0;

  677. 

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

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

  680. 

  681.         if (bits) {

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

  683.                 if (map_table)

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

  685.                 else

  686.                     *destbuf++ = bits;

  687.             }

  688.             pixels_read++;

  689.         } else {

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

  691.             run_length = bits & 0x7f;

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

  693.                 if (run_length == 0) {

  694.                     return pixels_read;

  695.                 }

  696. 

  697.                 if (map_table)

  698.                     bits = map_table[0];

  699.                 else

  700.                     bits = 0;

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

  702.                     *destbuf++ = bits;

  703.                     pixels_read++;

  704.                 }

  705.             } else {

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

  707. 

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

  709.                     pixels_read += run_length;

  710.                 if (map_table)

  711.                     bits = map_table[bits];

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

  713.                     *destbuf++ = bits;

  714.                     pixels_read++;

  715.                 }

  716.             }

  717.         }

  718.     }

  719. 

  720.     if (*(*srcbuf)++)

  721.         av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");

  722. 

  723.     return pixels_read;

  724. }

  725. 

  726. 

  727. 

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

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

  730. {

  731.     DVBSubContext *ctx = avctx->priv_data;

  732. 

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

  734.     const uint8_t *buf_end = buf + buf_size;

  735.     uint8_t *pbuf;

  736.     int x_pos, y_pos;

  737.     int i;

  738. 

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

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

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

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

  743.     uint8_t *map_table;

  744. 

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

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

  747. 

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

  749.         if (i % 16 == 0)

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

  751. 

  752.         av_dlog(avctx, "%02x ", buf[i]);

  753.         if (i % 16 == 15)

  754.             av_dlog(avctx, "\n");

  755.     }

  756. 

  757.     if (i % 16)

  758.         av_dlog(avctx, "\n");

  759. 

  760.     if (region == 0)

  761.         return;

  762. 

  763.     pbuf = region->pbuf;

  764. 

  765.     x_pos = display->x_pos;

  766.     y_pos = display->y_pos;

  767. 

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

  769.         y_pos++;

  770. 

  771.     while (buf < buf_end) {

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

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

  774.             return;

  775.         }

  776. 

  777.         switch (*buf++) {

  778.         case 0x10:

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

  780.                 map_table = map2to8;

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

  782.                 map_table = map2to4;

  783.             else

  784.                 map_table = NULL;

  785. 

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

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

  788.                                                 non_mod, map_table);

  789.             break;

  790.         case 0x11:

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

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

  793.                 return;

  794.             }

  795. 

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

  797.                 map_table = map4to8;

  798.             else

  799.                 map_table = NULL;

  800. 

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

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

  803.                                                 non_mod, map_table);

  804.             break;

  805.         case 0x12:

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

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

  808.                 return;

  809.             }

  810. 

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

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

  813.                                                 non_mod, NULL);

  814.             break;

  815. 

  816.         case 0x20:

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

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

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

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

  821.             break;

  822.         case 0x21:

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

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

  825.             break;

  826.         case 0x22:

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

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

  829.             break;

  830. 

  831.         case 0xf0:

  832.             x_pos = display->x_pos;

  833.             y_pos += 2;

  834.             break;

  835.         default:

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

  837.         }

  838.     }

  839. 

  840. }

  841. 

  842. static void dvbsub_parse_object_segment(AVCodecContext *avctx,

  843.                                         const uint8_t *buf, int buf_size)

  844. {

  845.     DVBSubContext *ctx = avctx->priv_data;

  846. 

  847.     const uint8_t *buf_end = buf + buf_size;

  848.     const uint8_t *block;

  849.     int object_id;

  850.     DVBSubObject *object;

  851.     DVBSubObjectDisplay *display;

  852.     int top_field_len, bottom_field_len;

  853. 

  854.     int coding_method, non_modifying_color;

  855. 

  856.     object_id = AV_RB16(buf);

  857.     buf += 2;

  858. 

  859.     object = get_object(ctx, object_id);

  860. 

  861.     if (!object)

  862.         return;

  863. 

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

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

  866. 

  867.     if (coding_method == 0) {

  868.         top_field_len = AV_RB16(buf);

  869.         buf += 2;

  870.         bottom_field_len = AV_RB16(buf);

  871.         buf += 2;

  872. 

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

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

  875.             return;

  876.         }

  877. 

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

  879.             block = buf;

  880. 

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

  882.                                             non_modifying_color);

  883. 

  884.             if (bottom_field_len > 0)

  885.                 block = buf + top_field_len;

  886.             else

  887.                 bottom_field_len = top_field_len;

  888. 

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

  890.                                             non_modifying_color);

  891.         }

  892. 

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

  894. 

  895.     } else {

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

  897.     }

  898. 

  899. }

  900. 

  901. static void dvbsub_parse_clut_segment(AVCodecContext *avctx,

  902.                                         const uint8_t *buf, int buf_size)

  903. {

  904.     DVBSubContext *ctx = avctx->priv_data;

  905. 

  906.     const uint8_t *buf_end = buf + buf_size;

  907.     int i, clut_id;

  908.     DVBSubCLUT *clut;

  909.     int entry_id, depth , full_range;

  910.     int y, cr, cb, alpha;

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

  912. 

  913.     av_dlog(avctx, "DVB clut packet:\n");

  914. 

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

  916.         av_dlog(avctx, "%02x ", buf[i]);

  917.         if (i % 16 == 15)

  918.             av_dlog(avctx, "\n");

  919.     }

  920. 

  921.     if (i % 16)

  922.         av_dlog(avctx, "\n");

  923. 

  924.     clut_id = *buf++;

  925.     buf += 1;

  926. 

  927.     clut = get_clut(ctx, clut_id);

  928. 

  929.     if (!clut) {

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

  931. 

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

  933. 

  934.         clut->id = clut_id;

  935. 

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

  937.         ctx->clut_list = clut;

  938.     }

  939. 

  940.     while (buf + 4 < buf_end) {

  941.         entry_id = *buf++;

  942. 

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

  944. 

  945.         if (depth == 0) {

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

  947.             return;

  948.         }

  949. 

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

  951. 

  952.         if (full_range) {

  953.             y = *buf++;

  954.             cr = *buf++;

  955.             cb = *buf++;

  956.             alpha = *buf++;

  957.         } else {

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

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

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

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

  962. 

  963.             buf += 2;

  964.         }

  965. 

  966.         if (y == 0)

  967.             alpha = 0xff;

  968. 

  969.         YUV_TO_RGB1_CCIR(cb, cr);

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

  971. 

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

  973. 

  974.         if (depth & 0x80)

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

  976.         if (depth & 0x40)

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

  978.         if (depth & 0x20)

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

  980.     }

  981. }

  982. 

  983. 

  984. static void dvbsub_parse_region_segment(AVCodecContext *avctx,

  985.                                         const uint8_t *buf, int buf_size)

  986. {

  987.     DVBSubContext *ctx = avctx->priv_data;

  988. 

  989.     const uint8_t *buf_end = buf + buf_size;

  990.     int region_id, object_id;

  991.     DVBSubRegion *region;

  992.     DVBSubObject *object;

  993.     DVBSubObjectDisplay *display;

  994.     int fill;

  995. 

  996.     if (buf_size < 10)

  997.         return;

  998. 

  999.     region_id = *buf++;

  1000. 

  1001.     region = get_region(ctx, region_id);

  1002. 

  1003.     if (!region) {

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

  1005. 

  1006.         region->id = region_id;

  1007. 

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

  1009.         ctx->region_list = region;

  1010.     }

  1011. 

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

  1013. 

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

  1015.     buf += 2;

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

  1017.     buf += 2;

  1018. 

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

  1020.         av_free(region->pbuf);

  1021. 

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

  1023. 

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

  1025. 

  1026.         fill = 1;

  1027.     }

  1028. 

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

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

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

  1032.         region->depth= 4;

  1033.     }

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

  1035. 

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

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

  1038.     else {

  1039.         buf += 1;

  1040. 

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

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

  1043.         else

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

  1045.     }

  1046. 

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

  1048. 

  1049.     if (fill) {

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

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

  1052.     }

  1053. 

  1054.     delete_region_display_list(ctx, region);

  1055. 

  1056.     while (buf + 5 < buf_end) {

  1057.         object_id = AV_RB16(buf);

  1058.         buf += 2;

  1059. 

  1060.         object = get_object(ctx, object_id);

  1061. 

  1062.         if (!object) {

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

  1064. 

  1065.             object->id = object_id;

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

  1067.             ctx->object_list = object;

  1068.         }

  1069. 

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

  1071. 

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

  1073. 

  1074.         display->object_id = object_id;

  1075.         display->region_id = region_id;

  1076. 

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

  1078.         buf += 2;

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

  1080.         buf += 2;

  1081. 

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

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

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

  1085.         }

  1086. 

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

  1088.         region->display_list = display;

  1089. 

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

  1091.         object->display_list = display;

  1092.     }

  1093. }

  1094. 

  1095. static void dvbsub_parse_page_segment(AVCodecContext *avctx,

  1096.                                         const uint8_t *buf, int buf_size)

  1097. {

  1098.     DVBSubContext *ctx = avctx->priv_data;

  1099.     DVBSubRegionDisplay *display;

  1100.     DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;

  1101. 

  1102.     const uint8_t *buf_end = buf + buf_size;

  1103.     int region_id;

  1104.     int page_state;

  1105. 

  1106.     if (buf_size < 1)

  1107.         return;

  1108. 

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

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

  1111. 

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

  1113. 

  1114.     if (page_state == 2) {

  1115.         delete_state(ctx);

  1116.     }

  1117. 

  1118.     tmp_display_list = ctx->display_list;

  1119.     ctx->display_list = NULL;

  1120.     ctx->display_list_size = 0;

  1121. 

  1122.     while (buf + 5 < buf_end) {

  1123.         region_id = *buf++;

  1124.         buf += 1;

  1125. 

  1126.         display = tmp_display_list;

  1127.         tmp_ptr = &tmp_display_list;

  1128. 

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

  1130.             tmp_ptr = &display->next;

  1131.             display = display->next;

  1132.         }

  1133. 

  1134.         if (!display)

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

  1136. 

  1137.         display->region_id = region_id;

  1138. 

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

  1140.         buf += 2;

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

  1142.         buf += 2;

  1143. 

  1144.         *tmp_ptr = display->next;

  1145. 

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

  1147.         ctx->display_list = display;

  1148.         ctx->display_list_size++;

  1149. 

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

  1151.     }

  1152. 

  1153.     while (tmp_display_list) {

  1154.         display = tmp_display_list;

  1155. 

  1156.         tmp_display_list = display->next;

  1157. 

  1158.         av_free(display);

  1159.     }

  1160. 

  1161. }

  1162. 

  1163. 

  1164. #ifdef DEBUG

  1165. static void save_display_set(DVBSubContext *ctx)

  1166. {

  1167.     DVBSubRegion *region;

  1168.     DVBSubRegionDisplay *display;

  1169.     DVBSubCLUT *clut;

  1170.     uint32_t *clut_table;

  1171.     int x_pos, y_pos, width, height;

  1172.     int x, y, y_off, x_off;

  1173.     uint32_t *pbuf;

  1174.     char filename[32];

  1175.     static int fileno_index = 0;

  1176. 

  1177.     x_pos = -1;

  1178.     y_pos = -1;

  1179.     width = 0;

  1180.     height = 0;

  1181. 

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

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

  1184. 

  1185.         if (x_pos == -1) {

  1186.             x_pos = display->x_pos;

  1187.             y_pos = display->y_pos;

  1188.             width = region->width;

  1189.             height = region->height;

  1190.         } else {

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

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

  1193.                 x_pos = display->x_pos;

  1194.             }

  1195. 

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

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

  1198.                 y_pos = display->y_pos;

  1199.             }

  1200. 

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

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

  1203.             }

  1204. 

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

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

  1207.             }

  1208.         }

  1209.     }

  1210. 

  1211.     if (x_pos >= 0) {

  1212. 

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

  1214. 

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

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

  1217. 

  1218.             x_off = display->x_pos - x_pos;

  1219.             y_off = display->y_pos - y_pos;

  1220. 

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

  1222. 

  1223.             if (clut == 0)

  1224.                 clut = &default_clut;

  1225. 

  1226.             switch (region->depth) {

  1227.             case 2:

  1228.                 clut_table = clut->clut4;

  1229.                 break;

  1230.             case 8:

  1231.                 clut_table = clut->clut256;

  1232.                 break;

  1233.             case 4:

  1234.             default:

  1235.                 clut_table = clut->clut16;

  1236.                 break;

  1237.             }

  1238. 

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

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

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

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

  1243.                 }

  1244.             }

  1245. 

  1246.         }

  1247. 

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

  1249. 

  1250.         png_save2(filename, pbuf, width, height);

  1251. 

  1252.         av_free(pbuf);

  1253.     }

  1254. 

  1255.     fileno_index++;

  1256. }

  1257. #endif

  1258. 

  1259. static void dvbsub_parse_display_definition_segment(AVCodecContext *avctx,

  1260.                                                     const uint8_t *buf,

  1261.                                                     int buf_size)

  1262. {

  1263.     DVBSubContext *ctx = avctx->priv_data;

  1264.     DVBSubDisplayDefinition *display_def = ctx->display_definition;

  1265.     int dds_version, info_byte;

  1266. 

  1267.     if (buf_size < 5)

  1268.         return;

  1269. 

  1270.     info_byte   = bytestream_get_byte(&buf);

  1271.     dds_version = info_byte >> 4;

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

  1273.         return; // already have this display definition version

  1274. 

  1275.     if (!display_def) {

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

  1277.         ctx->display_definition = display_def;

  1278.     }

  1279.     if (!display_def)

  1280.         return;

  1281. 

  1282.     display_def->version = dds_version;

  1283.     display_def->x       = 0;

  1284.     display_def->y       = 0;

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

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

  1287. 

  1288.     if (buf_size < 13)

  1289.         return;

  1290. 

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

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

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

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

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

  1296.     }

  1297. }

  1298. 

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

  1300.                                         int buf_size, AVSubtitle *sub)

  1301. {

  1302.     DVBSubContext *ctx = avctx->priv_data;

  1303.     DVBSubDisplayDefinition *display_def = ctx->display_definition;

  1304. 

  1305.     DVBSubRegion *region;

  1306.     DVBSubRegionDisplay *display;

  1307.     AVSubtitleRect *rect;

  1308.     DVBSubCLUT *clut;

  1309.     uint32_t *clut_table;

  1310.     int i;

  1311.     int offset_x=0, offset_y=0;

  1312. 

  1313.     sub->rects = NULL;

  1314.     sub->start_display_time = 0;

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

  1316.     sub->format = 0;

  1317. 

  1318.     if (display_def) {

  1319.         offset_x = display_def->x;

  1320.         offset_y = display_def->y;

  1321.     }

  1322. 

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

  1324. 

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

  1326.         sub->rects = av_mallocz(sizeof(*sub->rects) * sub->num_rects);

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

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

  1329.     }

  1330. 

  1331.     i = 0;

  1332. 

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

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

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

  1336. 

  1337.         if (!region)

  1338.             continue;

  1339. 

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

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

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

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

  1344.         rect->nb_colors = 16;

  1345.         rect->type      = SUBTITLE_BITMAP;

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

  1347. 

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

  1349. 

  1350.         if (!clut)

  1351.             clut = &default_clut;

  1352. 

  1353.         switch (region->depth) {

  1354.         case 2:

  1355.             clut_table = clut->clut4;

  1356.             break;

  1357.         case 8:

  1358.             clut_table = clut->clut256;

  1359.             break;

  1360.         case 4:

  1361.         default:

  1362.             clut_table = clut->clut16;

  1363.             break;

  1364.         }

  1365. 

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

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

  1368. 

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

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

  1371. 

  1372.         i++;

  1373.     }

  1374. 

  1375.     sub->num_rects = i;

  1376. 

  1377. #ifdef DEBUG

  1378.     save_display_set(ctx);

  1379. #endif

  1380. 

  1381.     return 1;

  1382. }

  1383. 

  1384. static int dvbsub_decode(AVCodecContext *avctx,

  1385.                          void *data, int *data_size,

  1386.                          AVPacket *avpkt)

  1387. {

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

  1389.     int buf_size = avpkt->size;

  1390.     DVBSubContext *ctx = avctx->priv_data;

  1391.     AVSubtitle *sub = data;

  1392.     const uint8_t *p, *p_end;

  1393.     int segment_type;

  1394.     int page_id;

  1395.     int segment_length;

  1396.     int i;

  1397. 

  1398.     av_dlog(avctx, "DVB sub packet:\n");

  1399. 

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

  1401.         av_dlog(avctx, "%02x ", buf[i]);

  1402.         if (i % 16 == 15)

  1403.             av_dlog(avctx, "\n");

  1404.     }

  1405. 

  1406.     if (i % 16)

  1407.         av_dlog(avctx, "\n");

  1408. 

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

  1410.         av_dlog(avctx, "incomplete or broken packet");

  1411.         return -1;

  1412.     }

  1413. 

  1414.     p = buf;

  1415.     p_end = buf + buf_size;

  1416. 

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

  1418.         p += 1;

  1419.         segment_type = *p++;

  1420.         page_id = AV_RB16(p);

  1421.         p += 2;

  1422.         segment_length = AV_RB16(p);

  1423.         p += 2;

  1424. 

  1425.         if (p_end - p < segment_length) {

  1426.             av_dlog(avctx, "incomplete or broken packet");

  1427.             return -1;

  1428.         }

  1429. 

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

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

  1432.             switch (segment_type) {

  1433.             case DVBSUB_PAGE_SEGMENT:

  1434.                 dvbsub_parse_page_segment(avctx, p, segment_length);

  1435.                 break;

  1436.             case DVBSUB_REGION_SEGMENT:

  1437.                 dvbsub_parse_region_segment(avctx, p, segment_length);

  1438.                 break;

  1439.             case DVBSUB_CLUT_SEGMENT:

  1440.                 dvbsub_parse_clut_segment(avctx, p, segment_length);

  1441.                 break;

  1442.             case DVBSUB_OBJECT_SEGMENT:

  1443.                 dvbsub_parse_object_segment(avctx, p, segment_length);

  1444.                 break;

  1445.             case DVBSUB_DISPLAYDEFINITION_SEGMENT:

  1446.                 dvbsub_parse_display_definition_segment(avctx, p, segment_length);

  1447.             case DVBSUB_DISPLAY_SEGMENT:

  1448.                 *data_size = dvbsub_display_end_segment(avctx, p, segment_length, sub);

  1449.                 break;

  1450.             default:

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

  1452.                         segment_type, page_id, segment_length);

  1453.                 break;

  1454.             }

  1455.         }

  1456. 

  1457.         p += segment_length;

  1458.     }

  1459. 

  1460.     return p - buf;

  1461. }

  1462. 

  1463. 

  1464. AVCodec ff_dvbsub_decoder = {

  1465.     .name           = "dvbsub",

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

  1467.     .type           = AVMEDIA_TYPE_SUBTITLE,

  1468.     .id             = AV_CODEC_ID_DVB_SUBTITLE,

  1469.     .priv_data_size = sizeof(DVBSubContext),

  1470.     .init           = dvbsub_init_decoder,

  1471.     .close          = dvbsub_close_decoder,

  1472.     .decode         = dvbsub_decode,

  1473. };