开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 查看源码
dvbsub.c
资源名称：vlc-0.8.1.tar.gz　[点击查看]
上传用户：riyaled888
上传日期：2009-03-27
资源大小：7338k
文件大小：54k
源码类别：

多媒体

开发平台：

MultiPlatform

dvbsub.c：源码内容
  1. /*****************************************************************************
  2.  * dvbsub.c : DVB subtitles decoder
  3.  *            DVB subtitles encoder (developed for Anevia, www.anevia.com)
  4.  *****************************************************************************
  5.  * Copyright (C) 2003 ANEVIA
  6.  * Copyright (C) 2003-2004 VideoLAN
  7.  * $Id: dvbsub.c 9027 2004-10-21 13:20:54Z gbazin $
  8.  *
  9.  * Authors: Gildas Bazin <gbazin@videolan.org>
  10.  *          Damien LUCAS <damien.lucas@anevia.com>
  11.  *          Laurent Aimar <fenrir@via.ecp.fr>
  12.  *
  13.  * This program is free software; you can redistribute it and/or modify
  14.  * it under the terms of the GNU General Public License as published by
  15.  * the Free Software Foundation; either version 2 of the License, or
  16.  * (at your option) any later version.
  17.  *
  18.  * This program is distributed in the hope that it will be useful,
  19.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21.  * GNU General Public License for more details.
  22.  *
  23.  * You should have received a copy of the GNU General Public License
  24.  * along with this program; if not, write to the Free Software
  25.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  26.  *****************************************************************************/
  27. /*****************************************************************************
  28.  * Preamble
  29.  *****************************************************************************/
  30. #include <vlc/vlc.h>
  31. #include <vlc/vout.h>
  32. #include <vlc/decoder.h>
  33. #include <vlc/sout.h>
  35. #include "vlc_bits.h"
  37. //#define DEBUG_DVBSUB 1
  39. /*****************************************************************************
  40.  * Module descriptor.
  41.  *****************************************************************************/
  42. static int  Open ( vlc_object_t * );
  43. static void Close( vlc_object_t * );
  44. static subpicture_t *Decode( decoder_t *, block_t ** );
  46. static int OpenEncoder  ( vlc_object_t * );
  47. static void CloseEncoder( vlc_object_t * );
  48. static block_t *Encode  ( encoder_t *, subpicture_t * );
  50. vlc_module_begin();
  51.     set_description( _("DVB subtitles decoder") );
  52.     set_capability( "decoder", 50 );
  53.     set_callbacks( Open, Close );
  55. #   define ENC_CFG_PREFIX "sout-dvbsub-"
  56.     add_submodule();
  57.     set_description( _("DVB subtitles encoder") );
  58.     set_capability( "encoder", 100 );
  59.     set_callbacks( OpenEncoder, CloseEncoder );
  60. vlc_module_end();
  62. static const char *ppsz_enc_options[] = { NULL };
  64. /****************************************************************************
  65.  * Local structures
  66.  ****************************************************************************
  67.  * Those structures refer closely to the ETSI 300 743 Object model
  68.  ****************************************************************************/
  70. /* The object definition gives the position of the object in a region */
  71. typedef struct dvbsub_objectdef_s
  72. {
  73.     int i_id;
  74.     int i_type;
  75.     int i_x;
  76.     int i_y;
  77.     int i_fg_pc;
  78.     int i_bg_pc;
  80. } dvbsub_objectdef_t;
  82. /* The entry in the palette CLUT */
  83. typedef struct
  84. {
  85.     uint8_t                 Y;
  86.     uint8_t                 Cr;
  87.     uint8_t                 Cb;
  88.     uint8_t                 T;
  90. } dvbsub_color_t;
  92. /* */
  93. typedef struct dvbsub_clut_s
  94. {
  95.     uint8_t                 i_id;
  96.     uint8_t                 i_version;
  97.     dvbsub_color_t          c_2b[4];
  98.     dvbsub_color_t          c_4b[16];
  99.     dvbsub_color_t          c_8b[256];
  101.     struct dvbsub_clut_s    *p_next;
  103. } dvbsub_clut_t;
  105. /* The Region is an aera on the image
  106.  * with a list of the object definitions associated and a CLUT */
  107. typedef struct dvbsub_region_s
  108. {
  109.     int i_id;
  110.     int i_version;
  111.     int i_x;
  112.     int i_y;
  113.     int i_width;
  114.     int i_height;
  115.     int i_level_comp;
  116.     int i_depth;
  117.     int i_clut;
  119.     uint8_t *p_pixbuf;
  121.     int                    i_object_defs;
  122.     dvbsub_objectdef_t     *p_object_defs;
  124.     struct dvbsub_region_s *p_next;
  126. } dvbsub_region_t;
  128. /* The object definition gives the position of the object in a region */
  129. typedef struct dvbsub_regiondef_s
  130. {
  131.     int i_id;
  132.     int i_x;
  133.     int i_y;
  135. } dvbsub_regiondef_t;
  137. /* The page defines the list of regions */
  138. typedef struct
  139. {
  140.     int i_id;
  141.     int i_timeout;
  142.     int i_state;
  143.     int i_version;
  145.     int                i_region_defs;
  146.     dvbsub_regiondef_t *p_region_defs;
  148. } dvbsub_page_t;
  150. struct decoder_sys_t
  151. {
  152.     bs_t            bs;
  154.     /* Decoder internal data */
  155.     int             i_id;
  156.     int             i_ancillary_id;
  157.     mtime_t         i_pts;
  159.     dvbsub_page_t   *p_page;
  160.     dvbsub_region_t *p_regions;
  161.     dvbsub_clut_t   *p_cluts;
  162.     dvbsub_clut_t   default_clut;
  163. };
  166. // List of different SEGMENT TYPES
  167. // According to EN 300-743, table 2
  168. #define DVBSUB_ST_PAGE_COMPOSITION      0x10
  169. #define DVBSUB_ST_REGION_COMPOSITION    0x11
  170. #define DVBSUB_ST_CLUT_DEFINITION       0x12
  171. #define DVBSUB_ST_OBJECT_DATA           0x13
  172. #define DVBSUB_ST_ENDOFDISPLAY          0x80
  173. #define DVBSUB_ST_STUFFING              0xff
  174. // List of different OBJECT TYPES
  175. // According to EN 300-743, table 6
  176. #define DVBSUB_OT_BASIC_BITMAP          0x00
  177. #define DVBSUB_OT_BASIC_CHAR            0x01
  178. #define DVBSUB_OT_COMPOSITE_STRING      0x02
  179. // Pixel DATA TYPES
  180. // According to EN 300-743, table 9
  181. #define DVBSUB_DT_2BP_CODE_STRING       0x10
  182. #define DVBSUB_DT_4BP_CODE_STRING       0x11
  183. #define DVBSUB_DT_8BP_CODE_STRING       0x12
  184. #define DVBSUB_DT_24_TABLE_DATA         0x20
  185. #define DVBSUB_DT_28_TABLE_DATA         0x21
  186. #define DVBSUB_DT_48_TABLE_DATA         0x22
  187. #define DVBSUB_DT_END_LINE              0xf0
  188. // List of different Page Composition Segment state
  189. // According to EN 300-743, 7.2.1 table 3
  190. #define DVBSUB_PCS_STATE_ACQUISITION    0x01
  191. #define DVBSUB_PCS_STATE_CHANGE         0x10
  193. /*****************************************************************************
  194.  * Local prototypes
  195.  *****************************************************************************/
  196. static void decode_segment( decoder_t *, bs_t * );
  197. static void decode_page_composition( decoder_t *, bs_t * );
  198. static void decode_region_composition( decoder_t *, bs_t * );
  199. static void decode_object( decoder_t *, bs_t * );
  200. static void decode_clut( decoder_t *, bs_t * );
  201. static void free_all( decoder_t * );
  203. static void default_clut_init( decoder_t * );
  205. static subpicture_t *render( decoder_t * );
  207. /*****************************************************************************
  208.  * Open: probe the decoder and return score
  209.  *****************************************************************************
  210.  * Tries to launch a decoder and return score so that the interface is able
  211.  * to chose.
  212.  *****************************************************************************/
  213. static int Open( vlc_object_t *p_this )
  214. {
  215.     decoder_t     *p_dec = (decoder_t *) p_this;
  216.     decoder_sys_t *p_sys;
  218.     if( p_dec->fmt_in.i_codec != VLC_FOURCC('d','v','b','s') )
  219.     {
  220.         return VLC_EGENERIC;
  221.     }
  223.     p_dec->pf_decode_sub = Decode;
  224.     p_sys = p_dec->p_sys = malloc( sizeof(decoder_sys_t) );
  225.     memset( p_sys, 0, sizeof(decoder_sys_t) );
  227.     p_sys->i_pts          = 0;
  228.     p_sys->i_id           = p_dec->fmt_in.subs.dvb.i_id & 0xFFFF;
  229.     p_sys->i_ancillary_id = p_dec->fmt_in.subs.dvb.i_id >> 16;
  230.     p_sys->p_regions      = NULL;
  231.     p_sys->p_cluts        = NULL;
  232.     p_sys->p_page         = NULL;
  234.     es_format_Init( &p_dec->fmt_out, SPU_ES, VLC_FOURCC( 'd','v','b','s' ) );
  236.     default_clut_init( p_dec );
  238.     return VLC_SUCCESS;
  239. }
  241. /*****************************************************************************
  242.  * Close:
  243.  *****************************************************************************/
  244. static void Close( vlc_object_t *p_this )
  245. {
  246.     decoder_t     *p_dec = (decoder_t*) p_this;
  247.     decoder_sys_t *p_sys = p_dec->p_sys;
  249.     free_all( p_dec );
  250.     free( p_sys );
  251. }
  253. /*****************************************************************************
  254.  * Decode:
  255.  *****************************************************************************/
  256. static subpicture_t *Decode( decoder_t *p_dec, block_t **pp_block )
  257. {
  258.     decoder_sys_t *p_sys = p_dec->p_sys;
  259.     block_t       *p_block;
  260.     subpicture_t  *p_spu = NULL;
  262.     if( pp_block == NULL || *pp_block == NULL ) return NULL;
  263.     p_block = *pp_block;
  264.     *pp_block = NULL;
  266.     p_sys->i_pts = p_block->i_pts;
  267.     if( p_sys->i_pts <= 0 )
  268.     {
  269. #ifdef DEBUG_DVBSUB
  270.         /* Some DVB channels send stuffing segments in non-dated packets so
  271.          * don't complain too loudly. */
  272.         msg_Warn( p_dec, "non dated subtitle" );
  273. #endif
  274.         block_Release( p_block );
  275.         return NULL;
  276.     }
  278.     bs_init( &p_sys->bs, p_block->p_buffer, p_block->i_buffer );
  280.     if( bs_read( &p_sys->bs, 8 ) != 0x20 ) /* Data identifier */
  281.     {
  282.         msg_Dbg( p_dec, "invalid data identifier" );
  283.         block_Release( p_block );
  284.         return NULL;
  285.     }
  287.     if( bs_read( &p_sys->bs, 8 ) ) /* Subtitle stream id */
  288.     {
  289.         msg_Dbg( p_dec, "invalid subtitle stream id" );
  290.         block_Release( p_block );
  291.         return NULL;
  292.     }
  294. #ifdef DEBUG_DVBSUB
  295.     msg_Dbg( p_dec, "subtitle packet received: "I64Fd, p_sys->i_pts );
  296. #endif
  298.     while( bs_show( &p_sys->bs, 8 ) == 0x0f ) /* Sync byte */
  299.     {
  300.         decode_segment( p_dec, &p_sys->bs );
  301.     }
  303.     if( bs_read( &p_sys->bs, 8 ) != 0xff ) /* End marker */
  304.     {
  305.         msg_Warn( p_dec, "end marker not found (corrupted subtitle ?)" );
  306.         block_Release( p_block );
  307.         return NULL;
  308.     }
  310.     /* Check if the page is to be displayed */
  311.     if( p_sys->p_page ) p_spu = render( p_dec );
  313.     block_Release( p_block );
  315.     return p_spu;
  316. }
  318. /* following functions are local */
  320. /*****************************************************************************
  321.  * default_clut_init: default clut as defined in EN 300-743 section 10
  322.  *****************************************************************************/
  323. static void default_clut_init( decoder_t *p_dec )
  324. {
  325.     decoder_sys_t *p_sys = p_dec->p_sys;
  326.     uint8_t i;
  328. #define RGB_TO_Y(r, g, b) ((int16_t) 77 * r + 150 * g + 29 * b) / 256;
  329. #define RGB_TO_U(r, g, b) ((int16_t) -44 * r - 87 * g + 131 * b) / 256;
  330. #define RGB_TO_V(r, g, b) ((int16_t) 131 * r - 110 * g - 21 * b) / 256;
  332.     /* 4 entries CLUT */
  333.     for( i = 0; i < 4; i++ )
  334.     {
  335.         uint8_t R = 0, G = 0, B = 0, T = 0;
  337.         if( !(i & 0x2) && !(i & 0x1) ) T = 0xFF;
  338.         else if( !(i & 0x2) && (i & 0x1) ) R = G = B = 0xFF;
  339.         else if( (i & 0x2) && !(i & 0x1) ) R = G = B = 0;
  340.         else R = G = B = 0x7F;
  342.         p_sys->default_clut.c_2b[i].Y = RGB_TO_Y(R,G,B);
  343.         p_sys->default_clut.c_2b[i].Cr = RGB_TO_U(R,G,B);
  344.         p_sys->default_clut.c_2b[i].Cb = RGB_TO_V(R,G,B);
  345.         p_sys->default_clut.c_2b[i].T = T;
  346.     }
  348.     /* 16 entries CLUT */
  349.     for( i = 0; i < 16; i++ )
  350.     {
  351.         uint8_t R = 0, G = 0, B = 0, T = 0;
  353.         if( !(i & 0x8) )
  354.         {
  355.             if( !(i & 0x4) && !(i & 0x2) && !(i & 0x1) )
  356.             {
  357.                 T = 0xFF;
  358.             }
  359.             else
  360.             {
  361.                 R = (i & 0x1) ? 0xFF : 0;
  362.                 G = (i & 0x2) ? 0xFF : 0;
  363.                 B = (i & 0x4) ? 0xFF : 0;
  364.             }
  365.         }
  366.         else
  367.         {
  368.             R = (i & 0x1) ? 0x7F : 0;
  369.             G = (i & 0x2) ? 0x7F : 0;
  370.             B = (i & 0x4) ? 0x7F : 0;
  371.         }
  373.         p_sys->default_clut.c_4b[i].Y = RGB_TO_Y(R,G,B);
  374.         p_sys->default_clut.c_4b[i].Cr = RGB_TO_U(R,G,B);
  375.         p_sys->default_clut.c_4b[i].Cb = RGB_TO_V(R,G,B);
  376.         p_sys->default_clut.c_4b[i].T = T;
  377.     }
  379.     /* 256 entries CLUT (TODO) */
  380.     memset( p_sys->default_clut.c_8b, 0xFF, 256 * sizeof(dvbsub_color_t) );
  381. }
  383. static void decode_segment( decoder_t *p_dec, bs_t *s )
  384. {
  385.     decoder_sys_t *p_sys = p_dec->p_sys;
  386.     int i_type;
  387.     int i_page_id;
  388.     int i_size;
  390.     /* sync_byte (already checked) */
  391.     bs_skip( s, 8 );
  393.     /* segment type */
  394.     i_type = bs_read( s, 8 );
  396.     /* page id */
  397.     i_page_id = bs_read( s, 16 );
  399.     /* segment size */
  400.     i_size = bs_show( s, 16 );
  402.     if( i_page_id != p_sys->i_id && i_page_id != p_sys->i_ancillary_id )
  403.     {
  404. #ifdef DEBUG_DVBSUB
  405.         msg_Dbg( p_dec, "subtitle skipped (page id: %i, %i)",
  406.                  i_page_id, p_sys->i_id );
  407. #endif
  408.         bs_skip( s,  8 * ( 2 + i_size ) );
  409.         return;
  410.     }
  412. #ifdef DEBUG_DVBSUB
  413.     if( i_page_id == p_sys->i_id )
  414.         msg_Dbg( p_dec, "segment (id: %i)", i_page_id );
  415.     else
  416.         msg_Dbg( p_dec, "ancillary segment (id: %i)", i_page_id );
  417. #endif
  419.     switch( i_type )
  420.     {
  421.     case DVBSUB_ST_PAGE_COMPOSITION:
  422. #ifdef DEBUG_DVBSUB
  423.         msg_Dbg( p_dec, "decode_page_composition" );
  424. #endif
  425.         decode_page_composition( p_dec, s );
  426.         break;
  428.     case DVBSUB_ST_REGION_COMPOSITION:
  429. #ifdef DEBUG_DVBSUB
  430.         msg_Dbg( p_dec, "decode_region_composition" );
  431. #endif
  432.         decode_region_composition( p_dec, s );
  433.         break;
  435.     case DVBSUB_ST_CLUT_DEFINITION:
  436. #ifdef DEBUG_DVBSUB
  437.         msg_Dbg( p_dec, "decode_clut" );
  438. #endif
  439.         decode_clut( p_dec, s );
  440.         break;
  442.     case DVBSUB_ST_OBJECT_DATA:
  443. #ifdef DEBUG_DVBSUB
  444.         msg_Dbg( p_dec, "decode_object" );
  445. #endif
  446.         decode_object( p_dec, s );
  447.         break;
  449.     case DVBSUB_ST_ENDOFDISPLAY:
  450. #ifdef DEBUG_DVBSUB
  451.         msg_Dbg( p_dec, "end of display" );
  452. #endif
  453.         bs_skip( s,  8 * ( 2 + i_size ) );
  454.         break;
  456.     case DVBSUB_ST_STUFFING:
  457. #ifdef DEBUG_DVBSUB
  458.         msg_Dbg( p_dec, "skip stuffing" );
  459. #endif
  460.         bs_skip( s,  8 * ( 2 + i_size ) );
  461.         break;
  463.     default:
  464.         msg_Warn( p_dec, "unsupported segment type: (%04x)", i_type );
  465.         bs_skip( s,  8 * ( 2 + i_size ) );
  466.         break;
  467.     }
  468. }
  470. static void decode_clut( decoder_t *p_dec, bs_t *s )
  471. {
  472.     decoder_sys_t *p_sys = p_dec->p_sys;
  473.     uint16_t      i_segment_length;
  474.     uint16_t      i_processed_length;
  475.     dvbsub_clut_t *p_clut, *p_next;
  476.     int           i_id, i_version;
  478.     i_segment_length = bs_read( s, 16 );
  479.     i_id             = bs_read( s, 8 );
  480.     i_version        = bs_read( s, 4 );
  482.     /* Check if we already have this clut */
  483.     for( p_clut = p_sys->p_cluts; p_clut != NULL; p_clut = p_clut->p_next )
  484.     {
  485.         if( p_clut->i_id == i_id ) break;
  486.     }
  488.     /* Check version number */
  489.     if( p_clut && p_clut->i_version == i_version )
  490.     {
  491.         /* Nothing to do */
  492.         bs_skip( s, 8 * i_segment_length - 12 );
  493.         return;
  494.     }
  496.     if( !p_clut )
  497.     {
  498. #ifdef DEBUG_DVBSUB
  499.         msg_Dbg( p_dec, "new clut: %i", i_id );
  500. #endif
  501.         p_clut = malloc( sizeof(dvbsub_clut_t) );
  502.         p_clut->p_next = p_sys->p_cluts;
  503.         p_sys->p_cluts = p_clut;
  504.     }
  506.     /* Initialize to default clut */
  507.     p_next = p_clut->p_next;
  508.     *p_clut = p_sys->default_clut;
  509.     p_clut->p_next = p_next;
  511.     /* We don't have this version of the CLUT: Parse it */
  512.     p_clut->i_version = i_version;
  513.     p_clut->i_id = i_id;
  514.     bs_skip( s, 4 ); /* Reserved bits */
  515.     i_processed_length = 2;
  516.     while( i_processed_length < i_segment_length )
  517.     {
  518.         uint8_t y, cb, cr, t;
  519.         uint8_t i_id;
  520.         uint8_t i_type;
  522.         i_id = bs_read( s, 8 );
  523.         i_type = bs_read( s, 3 );
  525.         bs_skip( s, 4 );
  527.         if( bs_read( s, 1 ) )
  528.         {
  529.             y  = bs_read( s, 8 );
  530.             cr = bs_read( s, 8 );
  531.             cb = bs_read( s, 8 );
  532.             t  = bs_read( s, 8 );
  533.             i_processed_length += 6;
  534.         }
  535.         else
  536.         {
  537.             y  = bs_read( s, 6 ) << 2;
  538.             cr = bs_read( s, 4 ) << 4;
  539.             cb = bs_read( s, 4 ) << 4;
  540.             t  = bs_read( s, 2 ) << 6;
  541.             i_processed_length += 4;
  542.         }
  544.         /* We are not entirely compliant here as full transparency is indicated
  545.          * with a luma value of zero, not a transparency value of 0xff
  546.          * (full transparency would actually be 0xff + 1). */
  548.         if( y == 0 )
  549.         {
  550.             cr = cb = 0;
  551.             t  = 0xff;
  552.         }
  554.         /* According to EN 300-743 section 7.2.3 note 1, type should
  555.          * not have more than 1 bit set to one, but some streams don't
  556.          * respect this note. */
  558.         if( i_type & 0x04)
  559.         {
  560.             p_clut->c_2b[i_id].Y = y;
  561.             p_clut->c_2b[i_id].Cr = cr;
  562.             p_clut->c_2b[i_id].Cb = cb;
  563.             p_clut->c_2b[i_id].T = t;
  564.         }
  565.         if( i_type & 0x02)
  566.         {
  567.             p_clut->c_4b[i_id].Y = y;
  568.             p_clut->c_4b[i_id].Cr = cr;
  569.             p_clut->c_4b[i_id].Cb = cb;
  570.             p_clut->c_4b[i_id].T = t;
  571.         }
  572.         if( i_type & 0x01)
  573.         {
  574.             p_clut->c_8b[i_id].Y = y;
  575.             p_clut->c_8b[i_id].Cr = cr;
  576.             p_clut->c_8b[i_id].Cb = cb;
  577.             p_clut->c_8b[i_id].T = t;
  578.         }
  579.     }
  580. }
  582. static void decode_page_composition( decoder_t *p_dec, bs_t *s )
  583. {
  584.     decoder_sys_t *p_sys = p_dec->p_sys;
  585.     int i_version, i_state, i_segment_length, i_timeout, i;
  587.     /* A page is composed by 0 or more region */
  589.     i_segment_length = bs_read( s, 16 );
  590.     i_timeout = bs_read( s, 8 );
  591.     i_version = bs_read( s, 4 );
  592.     i_state = bs_read( s, 2 );
  593.     bs_skip( s, 2 ); /* Reserved */
  595.     if( i_state == DVBSUB_PCS_STATE_CHANGE )
  596.     {
  597.         /* End of an epoch, reset decoder buffer */
  598. #ifdef DEBUG_DVBSUB
  599.         msg_Dbg( p_dec, "page composition mode change" );
  600. #endif
  601.         free_all( p_dec );
  602.     }
  603.     else if( !p_sys->p_page && i_state != DVBSUB_PCS_STATE_ACQUISITION &&
  604.              i_state != DVBSUB_PCS_STATE_CHANGE )
  605.     {
  606.         /* Not a full PCS, we need to wait for one */
  607.         msg_Dbg( p_dec, "didn't receive an acquisition page yet" );
  609. #if 0 /* Try to start decoding even without an acquisition page */
  610.         bs_skip( s,  8 * (i_segment_length - 2) );
  611.         return;
  612. #endif
  613.     }
  615. #ifdef DEBUG_DVBSUB
  616.     if( i_state == DVBSUB_PCS_STATE_ACQUISITION )
  617.         msg_Dbg( p_dec, "acquisition page composition" );
  618. #endif
  620.     /* Check version number */
  621.     if( p_sys->p_page && p_sys->p_page->i_version == i_version )
  622.     {
  623.         bs_skip( s,  8 * (i_segment_length - 2) );
  624.         return;
  625.     }
  626.     else if( p_sys->p_page )
  627.     {
  628.         if( p_sys->p_page->i_region_defs )
  629.             free( p_sys->p_page->p_region_defs );
  630.         p_sys->p_page->i_region_defs = 0;
  631.     }
  633.     if( !p_sys->p_page )
  634.     {
  635. #ifdef DEBUG_DVBSUB
  636.         msg_Dbg( p_dec, "new page" );
  637. #endif
  638.         /* Allocate a new page */
  639.         p_sys->p_page = malloc( sizeof(dvbsub_page_t) );
  640.     }
  642.     p_sys->p_page->i_version = i_version;
  643.     p_sys->p_page->i_timeout = i_timeout;
  645.     /* Number of regions */
  646.     p_sys->p_page->i_region_defs = (i_segment_length - 2) / 6;
  648.     if( p_sys->p_page->i_region_defs == 0 ) return;
  650.     p_sys->p_page->p_region_defs =
  651.         malloc( p_sys->p_page->i_region_defs * sizeof(dvbsub_region_t) );
  652.     for( i = 0; i < p_sys->p_page->i_region_defs; i++ )
  653.     {
  654.         p_sys->p_page->p_region_defs[i].i_id = bs_read( s, 8 );
  655.         bs_skip( s, 8 ); /* Reserved */
  656.         p_sys->p_page->p_region_defs[i].i_x = bs_read( s, 16 );
  657.         p_sys->p_page->p_region_defs[i].i_y = bs_read( s, 16 );
  659. #ifdef DEBUG_DVBSUB
  660.         msg_Dbg( p_dec, "page_composition, region %i (%i,%i)",
  661.                  i, p_sys->p_page->p_region_defs[i].i_x,
  662.                  p_sys->p_page->p_region_defs[i].i_y );
  663. #endif
  664.     }
  665. }
  667. static void decode_region_composition( decoder_t *p_dec, bs_t *s )
  668. {
  669.     decoder_sys_t *p_sys = p_dec->p_sys;
  670.     dvbsub_region_t *p_region, **pp_region = &p_sys->p_regions;
  671.     int i_segment_length, i_processed_length, i_id, i_version;
  672.     int i_width, i_height, i_level_comp, i_depth, i_clut;
  673.     int i_8_bg, i_4_bg, i_2_bg;
  674.     vlc_bool_t b_fill;
  676.     i_segment_length = bs_read( s, 16 );
  677.     i_id = bs_read( s, 8 );
  678.     i_version = bs_read( s, 4 );
  680.     /* Check if we already have this region */
  681.     for( p_region = p_sys->p_regions; p_region != NULL;
  682.          p_region = p_region->p_next )
  683.     {
  684.         pp_region = &p_region->p_next;
  685.         if( p_region->i_id == i_id ) break;
  686.     }
  688.     /* Check version number */
  689.     if( p_region && p_region->i_version == i_version )
  690.     {
  691.         bs_skip( s, 8 * (i_segment_length - 1) - 4 );
  692.         return;
  693.     }
  695.     if( !p_region )
  696.     {
  697. #ifdef DEBUG_DVBSUB
  698.         msg_Dbg( p_dec, "new region: %i", i_id );
  699. #endif
  700.         p_region = *pp_region = malloc( sizeof(dvbsub_region_t) );
  701.         memset( p_region, 0, sizeof(dvbsub_region_t) );
  702.         p_region->p_object_defs = NULL;
  703.         p_region->p_pixbuf = NULL;
  704.         p_region->p_next = NULL;
  705.     }
  707.     /* Region attributes */
  708.     p_region->i_id = i_id;
  709.     p_region->i_version = i_version;
  710.     b_fill = bs_read( s, 1 );
  711.     bs_skip( s, 3 ); /* Reserved */
  713.     i_width = bs_read( s, 16 );
  714.     i_height = bs_read( s, 16 );
  715.     i_level_comp = bs_read( s, 3 );
  716.     i_depth = bs_read( s, 3 );
  717.     bs_skip( s, 2 ); /* Reserved */
  718.     i_clut = bs_read( s, 8 );
  720.     i_8_bg = bs_read( s, 8 );
  721.     i_4_bg = bs_read( s, 4 );
  722.     i_2_bg = bs_read( s, 2 );
  723.     bs_skip( s, 2 ); /* Reserved */
  724.     p_region->i_object_defs    = 0;
  726.     /* Extra sanity checks */
  727.     if( p_region->i_width != i_width || p_region->i_height != i_height )
  728.     {
  729.         if( p_region->p_pixbuf )
  730.         {
  731.             msg_Dbg( p_dec, "region size changed (not allowed)" );
  732.             free( p_region->p_pixbuf );
  733.         }
  735.         p_region->p_pixbuf = malloc( i_height * i_width );
  736.         p_region->i_depth = 0;
  737.         b_fill = VLC_TRUE;
  738.     }
  739.     if( p_region->i_depth && (p_region->i_depth != i_depth ||
  740.         p_region->i_level_comp != i_level_comp || p_region->i_clut != i_clut) )
  741.     {
  742.         msg_Dbg( p_dec, "region parameters changed (not allowed)" );
  743.     }
  745.     /* Erase background of region */
  746.     if( b_fill )
  747.     {
  748.         int i_background = (p_region->i_depth == 1) ? i_2_bg :
  749.             (p_region->i_depth == 2) ? i_4_bg : i_8_bg;
  750.         memset( p_region->p_pixbuf, i_background, i_width * i_height );
  751.     }
  753.     p_region->i_width = i_width;
  754.     p_region->i_height = i_height;
  755.     p_region->i_level_comp = i_level_comp;
  756.     p_region->i_depth = i_depth;
  757.     p_region->i_clut = i_clut;
  759.     /* List of objects in the region */
  760.     i_processed_length = 10;
  761.     while( i_processed_length < i_segment_length )
  762.     {
  763.         dvbsub_objectdef_t *p_obj;
  765.         /* We create a new object */
  766.         p_region->i_object_defs++;
  767.         p_region->p_object_defs =
  768.             realloc( p_region->p_object_defs,
  769.                      sizeof(dvbsub_objectdef_t) * p_region->i_object_defs );
  771.         /* We parse object properties */
  772.         p_obj = &p_region->p_object_defs[p_region->i_object_defs - 1];
  773.         p_obj->i_id         = bs_read( s, 16 );
  774.         p_obj->i_type       = bs_read( s, 2 );
  775.         bs_skip( s, 2 ); /* Provider */
  776.         p_obj->i_x          = bs_read( s, 12 );
  777.         bs_skip( s, 4 ); /* Reserved */
  778.         p_obj->i_y          = bs_read( s, 12 );
  780.         i_processed_length += 6;
  782.         if( p_obj->i_type == DVBSUB_OT_BASIC_CHAR ||
  783.             p_obj->i_type == DVBSUB_OT_COMPOSITE_STRING )
  784.         {
  785.             p_obj->i_fg_pc =  bs_read( s, 8 );
  786.             p_obj->i_bg_pc =  bs_read( s, 8 );
  787.             i_processed_length += 2;
  788.         }
  789.     }
  790. }
  792. static void dvbsub_render_pdata( decoder_t *, dvbsub_region_t *, int, int,
  793.                                  uint8_t *, int );
  794. static void dvbsub_pdata2bpp( bs_t *, uint8_t *, int, int * );
  795. static void dvbsub_pdata4bpp( bs_t *, uint8_t *, int, int * );
  796. static void dvbsub_pdata8bpp( bs_t *, uint8_t *, int, int * );
  798. static void decode_object( decoder_t *p_dec, bs_t *s )
  799. {
  800.     decoder_sys_t *p_sys = p_dec->p_sys;
  801.     dvbsub_region_t *p_region;
  802.     int i_segment_length, i_coding_method, i_version, i_id, i;
  803.     vlc_bool_t b_non_modify_color;
  805.     i_segment_length = bs_read( s, 16 );
  806.     i_id             = bs_read( s, 16 );
  807.     i_version        = bs_read( s, 4 );
  808.     i_coding_method  = bs_read( s, 2 );
  810.     if( i_coding_method )
  811.     {
  812.         /* TODO: DVB subtitling as characters */
  813.         msg_Dbg( p_dec, "DVB subtitling as characters is not handled!" );
  814.         bs_skip( s, 8 * (i_segment_length - 2) - 6 );
  815.         return;
  816.     }
  818.     /* Check if the object needs to be rendered in at least one
  819.      * of the regions */
  820.     for( p_region = p_sys->p_regions; p_region != NULL;
  821.          p_region = p_region->p_next )
  822.     {
  823.         for( i = 0; i < p_region->i_object_defs; i++ )
  824.             if( p_region->p_object_defs[i].i_id == i_id ) break;
  826.         if( i != p_region->i_object_defs ) break;
  827.     }
  828.     if( !p_region )
  829.     {
  830.         bs_skip( s, 8 * (i_segment_length - 2) - 6 );
  831.         return;
  832.     }
  834. #ifdef DEBUG_DVBSUB
  835.     msg_Dbg( p_dec, "new object: %i", i_id );
  836. #endif
  838.     b_non_modify_color = bs_read( s, 1 );
  839.     bs_skip( s, 1 ); /* Reserved */
  841.     if( i_coding_method == 0x00 )
  842.     {
  843.         int i_topfield, i_bottomfield;
  844.         uint8_t *p_topfield, *p_bottomfield;
  846.         i_topfield    = bs_read( s, 16 );
  847.         i_bottomfield = bs_read( s, 16 );
  848.         p_topfield    = s->p_start + bs_pos( s ) / 8;
  849.         p_bottomfield = p_topfield + i_topfield;
  851.         bs_skip( s, 8 * (i_segment_length - 7) );
  853.         /* Sanity check */
  854.         if( i_segment_length < i_topfield + i_bottomfield + 7 ||
  855.             p_topfield + i_topfield + i_bottomfield > s->p_end )
  856.         {
  857.             msg_Dbg( p_dec, "corrupted object data" );
  858.             return;
  859.         }
  861.         for( p_region = p_sys->p_regions; p_region != NULL;
  862.              p_region = p_region->p_next )
  863.         {
  864.             for( i = 0; i < p_region->i_object_defs; i++ )
  865.             {
  866.                 if( p_region->p_object_defs[i].i_id != i_id ) continue;
  868.                 dvbsub_render_pdata( p_dec, p_region,
  869.                                      p_region->p_object_defs[i].i_x,
  870.                                      p_region->p_object_defs[i].i_y,
  871.                                      p_topfield, i_topfield );
  873.                 if( i_bottomfield )
  874.                 {
  875.                     dvbsub_render_pdata( p_dec, p_region,
  876.                                          p_region->p_object_defs[i].i_x,
  877.                                          p_region->p_object_defs[i].i_y + 1,
  878.                                          p_bottomfield, i_bottomfield );
  879.                 }
  880.                 else
  881.                 {
  882.                     /* Duplicate the top field */
  883.                     dvbsub_render_pdata( p_dec, p_region,
  884.                                          p_region->p_object_defs[i].i_x,
  885.                                          p_region->p_object_defs[i].i_y + 1,
  886.                                          p_topfield, i_topfield );
  887.                 }
  888.             }
  889.         }
  890.     }
  891.     else
  892.     {
  893.         /* TODO: DVB subtitling as characters */
  894.     }
  896. #ifdef DEBUG_DVBSUB
  897.     msg_Dbg( p_dec, "end object: %i", i_id );
  898. #endif
  899. }
  901. static void dvbsub_render_pdata( decoder_t *p_dec, dvbsub_region_t *p_region,
  902.                                  int i_x, int i_y,
  903.                                  uint8_t *p_field, int i_field )
  904. {
  905.     uint8_t *p_pixbuf;
  906.     int i_offset = 0;
  907.     bs_t bs;
  909.     /* Sanity check */
  910.     if( !p_region->p_pixbuf )
  911.     {
  912.         msg_Err( p_dec, "region %i has no pixel buffer!", p_region->i_id );
  913.         return;
  914.     }
  915.     if( i_y < 0 || i_x < 0 || i_y >= p_region->i_height ||
  916.         i_x >= p_region->i_width )
  917.     {
  918.         msg_Dbg( p_dec, "invalid offset (%i,%i)", i_x, i_y );
  919.         return;
  920.     }
  922.     p_pixbuf = p_region->p_pixbuf + i_y * p_region->i_width;
  923.     bs_init( &bs, p_field, i_field );
  925.     while( !bs_eof( &bs ) )
  926.     {
  927.         /* Sanity check */
  928.         if( i_y >= p_region->i_height ) return;
  930.         switch( bs_read( &bs, 8 ) )
  931.         {
  932.         case 0x10:
  933.             dvbsub_pdata2bpp( &bs, p_pixbuf + i_x, p_region->i_width - i_x,
  934.                               &i_offset );
  935.             break;
  937.         case 0x11:
  938.             dvbsub_pdata4bpp( &bs, p_pixbuf + i_x, p_region->i_width - i_x,
  939.                               &i_offset );
  940.             break;
  942.         case 0x12:
  943.             dvbsub_pdata8bpp( &bs, p_pixbuf + i_x, p_region->i_width - i_x,
  944.                               &i_offset );
  945.             break;
  947.         case 0x20:
  948.         case 0x21:
  949.         case 0x22:
  950.             /* We don't use map tables */
  951.             break;
  953.         case 0xf0: /* End of line code */
  954.             p_pixbuf += 2*p_region->i_width;
  955.             i_offset = 0; i_y += 2;
  956.             break;
  957.         }
  958.     }
  959. }
  961. static void dvbsub_pdata2bpp( bs_t *s, uint8_t *p, int i_width, int *pi_off )
  962. {
  963.     vlc_bool_t b_stop = 0;
  965.     while( !b_stop && !bs_eof( s ) )
  966.     {
  967.         int i_count = 0, i_color = 0;
  969.         if( (i_color = bs_read( s, 2 )) != 0x00 )
  970.         {
  971.             i_count = 1;
  972.         }
  973.         else
  974.         {
  975.             if( bs_read( s, 1 ) == 0x01 )         // Switch1
  976.             {
  977.                 i_count = 3 + bs_read( s, 3 );
  978.                 i_color = bs_read( s, 2 );
  979.             }
  980.             else
  981.             {
  982.                 if( bs_read( s, 1 ) == 0x00 )     //Switch2
  983.                 {
  984.                     switch( bs_read( s, 2 ) )     //Switch3
  985.                     {
  986.                     case 0x00:
  987.                         b_stop = 1;
  988.                         break;
  989.                     case 0x01:
  990.                         i_count = 2;
  991.                         break;
  992.                     case 0x02:
  993.                         i_count =  12 + bs_read( s, 4 );
  994.                         i_color = bs_read( s, 2 );
  995.                         break;
  996.                     case 0x03:
  997.                         i_count =  29 + bs_read( s, 8 );
  998.                         i_color = bs_read( s, 2 );
  999.                         break;
  1000.                     default:
  1001.                         break;
  1002.                     }
  1003.                 }
  1004.                 else
  1005.                 {
  1006.                     /* 1 pixel color 0 */
  1007.                     i_count = 1;
  1008.                 }
  1009.             }
  1010.         }
  1012.         if( !i_count ) continue;
  1014.         /* Sanity check */
  1015.         if( i_count + *pi_off > i_width ) break;
  1017.         if( i_count == 1 ) p[*pi_off] = i_color;
  1018.         else memset( p + *pi_off, i_color, i_count );
  1020.         (*pi_off) += i_count;
  1021.     }
  1023.     bs_align( s );
  1024. }
  1026. static void dvbsub_pdata4bpp( bs_t *s, uint8_t *p, int i_width, int *pi_off )
  1027. {
  1028.     vlc_bool_t b_stop = 0;
  1030.     while( !b_stop && !bs_eof( s ) )
  1031.     {
  1032.         int i_count = 0, i_color = 0;
  1034.         if( (i_color = bs_read( s, 4 )) != 0x00 )
  1035.         {
  1036.             /* Add 1 pixel */
  1037.             i_count = 1;
  1038.         }
  1039.         else
  1040.         {
  1041.             if( bs_read( s, 1 ) == 0x00 )           // Switch1
  1042.             {
  1043.                 if( bs_show( s, 3 ) != 0x00 )
  1044.                 {
  1045.                     i_count = 2 + bs_read( s, 3 );
  1046.                 }
  1047.                 else
  1048.                 {
  1049.                     bs_skip( s, 3 );
  1050.                     b_stop = 1;
  1051.                 }
  1052.             }
  1053.             else
  1054.             {
  1055.                 if( bs_read( s, 1 ) == 0x00)        //Switch2
  1056.                 {
  1057.                     i_count =  4 + bs_read( s, 2 );
  1058.                     i_color = bs_read( s, 4 );
  1059.                 }
  1060.                 else
  1061.                 {
  1062.                     switch ( bs_read( s, 2 ) )     //Switch3
  1063.                     {
  1064.                     case 0x0:
  1065.                         i_count = 1;
  1066.                         break;
  1067.                     case 0x1:
  1068.                         i_count = 2;
  1069.                         break;
  1070.                     case 0x2:
  1071.                         i_count = 9 + bs_read( s, 4 );
  1072.                         i_color = bs_read( s, 4 );
  1073.                         break;
  1074.                     case 0x3:
  1075.                         i_count= 25 + bs_read( s, 8 );
  1076.                         i_color = bs_read( s, 4 );
  1077.                         break;
  1078.                     }
  1079.                 }
  1080.             }
  1081.         }
  1083.         if( !i_count ) continue;
  1085.         /* Sanity check */
  1086.         if( i_count + *pi_off > i_width ) break;
  1088.         if( i_count == 1 ) p[*pi_off] = i_color;
  1089.         else memset( p + *pi_off, i_color, i_count );
  1091.         (*pi_off) += i_count;
  1092.     }
  1094.     bs_align( s );
  1095. }
  1097. static void dvbsub_pdata8bpp( bs_t *s, uint8_t *p, int i_width, int *pi_off )
  1098. {
  1099.     vlc_bool_t b_stop = 0;
  1101.     while( !b_stop && !bs_eof( s ) )
  1102.     {
  1103.         int i_count = 0, i_color = 0;
  1105.         if( (i_color = bs_read( s, 8 )) != 0x00 )
  1106.         {
  1107.             /* Add 1 pixel */
  1108.             i_count = 1;
  1109.         }
  1110.         else
  1111.         {
  1112.             if( bs_read( s, 1 ) == 0x00 )           // Switch1
  1113.             {
  1114.                 if( bs_show( s, 7 ) != 0x00 )
  1115.                 {
  1116.                     i_count = bs_read( s, 7 );
  1117.                 }
  1118.                 else
  1119.                 {
  1120.                     bs_skip( s, 7 );
  1121.                     b_stop = 1;
  1122.                 }
  1123.             }
  1124.             else
  1125.             {
  1126.                 i_count = bs_read( s, 7 );
  1127.                 i_color = bs_read( s, 8 );
  1128.             }
  1129.         }
  1131.         if( !i_count ) continue;
  1133.         /* Sanity check */
  1134.         if( i_count + *pi_off > i_width ) break;
  1136.         if( i_count == 1 ) p[*pi_off] = i_color;
  1137.         else memset( p + *pi_off, i_color, i_count );
  1139.         (*pi_off) += i_count;
  1140.     }
  1142.     bs_align( s );
  1143. }
  1145. static void free_all( decoder_t *p_dec )
  1146. {
  1147.     decoder_sys_t *p_sys = p_dec->p_sys;
  1148.     dvbsub_region_t *p_reg, *p_reg_next;
  1149.     dvbsub_clut_t *p_clut, *p_clut_next;
  1151.     for( p_clut = p_sys->p_cluts; p_clut != NULL; p_clut = p_clut_next )
  1152.     {
  1153.         p_clut_next = p_clut->p_next;
  1154.         free( p_clut );
  1155.     }
  1156.     p_sys->p_cluts = NULL;
  1158.     for( p_reg = p_sys->p_regions; p_reg != NULL; p_reg = p_reg_next )
  1159.     {
  1160.         p_reg_next = p_reg->p_next;
  1161.         if( p_reg->i_object_defs ) free( p_reg->p_object_defs );
  1162.         if( p_reg->p_pixbuf ) free( p_reg->p_pixbuf );
  1163.         free( p_reg );
  1164.     }
  1165.     p_sys->p_regions = NULL;
  1167.     if( p_sys->p_page )
  1168.     {
  1169.         if( p_sys->p_page->i_region_defs )
  1170.             free( p_sys->p_page->p_region_defs );
  1171.         free( p_sys->p_page );
  1172.     }
  1173.     p_sys->p_page = NULL;
  1174. }
  1176. static subpicture_t *render( decoder_t *p_dec )
  1177. {
  1178.     decoder_sys_t *p_sys = p_dec->p_sys;
  1179.     subpicture_t *p_spu;
  1180.     subpicture_region_t **pp_spu_region;
  1181.     int i, j, i_timeout = 0;
  1183.     /* Allocate the subpicture internal data. */
  1184.     p_spu = p_dec->pf_spu_buffer_new( p_dec );
  1185.     if( !p_spu ) return NULL;
  1187.     pp_spu_region = &p_spu->p_region;
  1189.     /* Loop on region definitions */
  1190. #ifdef DEBUG_DVBSUB
  1191.     if( p_sys->p_page )
  1192.         msg_Dbg( p_dec, "rendering %i regions", p_sys->p_page->i_region_defs );
  1193. #endif
  1195.     for( i = 0; p_sys->p_page && i < p_sys->p_page->i_region_defs; i++ )
  1196.     {
  1197.         dvbsub_region_t     *p_region;
  1198.         dvbsub_regiondef_t  *p_regiondef;
  1199.         dvbsub_clut_t       *p_clut;
  1200.         dvbsub_color_t      *p_color;
  1201.         subpicture_region_t *p_spu_region;
  1202.         uint8_t *p_src, *p_dst;
  1203.         video_format_t fmt;
  1204.         int i_pitch;
  1206.         i_timeout = p_sys->p_page->i_timeout;
  1208.         p_regiondef = &p_sys->p_page->p_region_defs[i];
  1210. #ifdef DEBUG_DVBSUB
  1211.         msg_Dbg( p_dec, "rendering region %i (%i,%i)", i,
  1212.                  p_regiondef->i_x, p_regiondef->i_y );
  1213. #endif
  1215.         /* Find associated region */
  1216.         for( p_region = p_sys->p_regions; p_region != NULL;
  1217.              p_region = p_region->p_next )
  1218.         {
  1219.             if( p_regiondef->i_id == p_region->i_id ) break;
  1220.         }
  1222.         if( !p_region )
  1223.         {
  1224.             msg_Dbg( p_dec, "region %i not found", p_regiondef->i_id );
  1225.             continue;
  1226.         }
  1228.         /* Find associated CLUT */
  1229.         for( p_clut = p_sys->p_cluts; p_clut != NULL; p_clut = p_clut->p_next )
  1230.         {
  1231.             if( p_region->i_clut == p_clut->i_id ) break;
  1232.         }
  1233.         if( !p_clut )
  1234.         {
  1235.             msg_Dbg( p_dec, "clut %i not found", p_region->i_clut );
  1236.             continue;
  1237.         }
  1239.         /* Create new SPU region */
  1240.         memset( &fmt, 0, sizeof(video_format_t) );
  1241.         fmt.i_chroma = VLC_FOURCC('Y','U','V','P');
  1242.         fmt.i_aspect = VOUT_ASPECT_FACTOR;
  1243.         fmt.i_width = fmt.i_visible_width = p_region->i_width;
  1244.         fmt.i_height = fmt.i_visible_height = p_region->i_height;
  1245.         fmt.i_x_offset = fmt.i_y_offset = 0;
  1246.         p_spu_region = p_spu->pf_create_region( VLC_OBJECT(p_dec), &fmt );
  1247.         if( !p_region )
  1248.         {
  1249.             msg_Err( p_dec, "cannot allocate SPU region" );
  1250.             continue;
  1251.         }
  1252.         p_spu_region->i_x = p_regiondef->i_x;
  1253.         p_spu_region->i_y = p_regiondef->i_y;
  1254.         *pp_spu_region = p_spu_region;
  1255.         pp_spu_region = &p_spu_region->p_next;
  1257.         /* Build palette */
  1258.         fmt.p_palette->i_entries = p_region->i_depth == 1 ? 4 :
  1259.             p_region->i_depth == 2 ? 16 : 256;
  1260.         p_color = (p_region->i_depth == 1) ? p_clut->c_2b :
  1261.             (p_region->i_depth == 2) ? p_clut->c_4b : p_clut->c_8b;
  1262.         for( j = 0; j < fmt.p_palette->i_entries; j++ )
  1263.         {
  1264.             fmt.p_palette->palette[j][0] = p_color[j].Y;
  1265.             fmt.p_palette->palette[j][1] = p_color[j].Cr;
  1266.             fmt.p_palette->palette[j][2] = p_color[j].Cb;
  1267.             fmt.p_palette->palette[j][3] = 0xff - p_color[j].T;
  1268.         }
  1270.         p_src = p_region->p_pixbuf;
  1271.         p_dst = p_spu_region->picture.Y_PIXELS;
  1272.         i_pitch = p_spu_region->picture.Y_PITCH;
  1274.         /* Copy pixel buffer */
  1275.         for( j = 0; j < p_region->i_height; j++ )
  1276.         {
  1277.             memcpy( p_dst, p_src, p_region->i_width );
  1278.             p_src += p_region->i_width;
  1279.             p_dst += i_pitch;
  1280.         }
  1281.     }
  1283.     /* Set the pf_render callback */
  1284.     p_spu->i_start = p_sys->i_pts;
  1285.     p_spu->i_stop = p_spu->i_start + i_timeout * 1000000;
  1286.     p_spu->b_ephemer = VLC_TRUE;
  1288.     return p_spu;
  1289. }
  1291. /*****************************************************************************
  1292.  * encoder_sys_t : encoder descriptor
  1293.  *****************************************************************************/
  1294. typedef struct encoder_region_t
  1295. {
  1296.     int i_width;
  1297.     int i_height;
  1299. } encoder_region_t;
  1301. struct encoder_sys_t
  1302. {
  1303.     unsigned int i_page_ver;
  1304.     unsigned int i_region_ver;
  1305.     unsigned int i_clut_ver;
  1307.     int i_regions;
  1308.     encoder_region_t *p_regions;
  1310.     mtime_t i_pts;
  1311. };
  1313. static void encode_page_composition( encoder_t *, bs_t *, subpicture_t * );
  1314. static void encode_clut( encoder_t *, bs_t *, subpicture_t * );
  1315. static void encode_region_composition( encoder_t *, bs_t *, subpicture_t * );
  1316. static void encode_object( encoder_t *, bs_t *, subpicture_t * );
  1318. /*****************************************************************************
  1319.  * OpenEncoder: probe the encoder and return score
  1320.  *****************************************************************************/
  1321. static int OpenEncoder( vlc_object_t *p_this )
  1322. {
  1323.     encoder_t *p_enc = (encoder_t *)p_this;
  1324.     encoder_sys_t *p_sys;
  1326.     if( p_enc->fmt_out.i_codec != VLC_FOURCC('d','v','b','s') &&
  1327.         !p_enc->b_force )
  1328.     {
  1329.         return VLC_EGENERIC;
  1330.     }
  1332.     /* Allocate the memory needed to store the decoder's structure */
  1333.     if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
  1334.     {
  1335.         msg_Err( p_enc, "out of memory" );
  1336.         return VLC_EGENERIC;
  1337.     }
  1338.     p_enc->p_sys = p_sys;
  1340.     p_enc->pf_encode_sub = Encode;
  1341.     p_enc->fmt_out.i_codec = VLC_FOURCC('d','v','b','s');
  1342.     p_enc->fmt_out.subs.dvb.i_id  = 1 << 16 | 1;
  1344.     sout_CfgParse( p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg );
  1346.     p_sys->i_page_ver = 0;
  1347.     p_sys->i_region_ver = 0;
  1348.     p_sys->i_clut_ver = 0;
  1349.     p_sys->i_regions = 0;
  1350.     p_sys->p_regions = 0;
  1352.     return VLC_SUCCESS;
  1353. }
  1355. /****************************************************************************
  1356.  * Encode: the whole thing
  1357.  ****************************************************************************/
  1358. static block_t *Encode( encoder_t *p_enc, subpicture_t *p_subpic )
  1359. {
  1360.     bs_t bits, *s = &bits;
  1361.     block_t *p_block;
  1363.     if( !p_subpic || !p_subpic->p_region ) return 0;
  1365.     msg_Dbg( p_enc, "encoding subpicture" );
  1367.     p_block = block_New( p_enc, 64000 );
  1368.     bs_init( s, p_block->p_buffer, p_block->i_buffer );
  1370.     bs_write( s, 8, 0x20 ); /* Data identifier */
  1371.     bs_write( s, 8, 0x0 ); /* Subtitle stream id */
  1373.     encode_page_composition( p_enc, s, p_subpic );
  1374.     encode_region_composition( p_enc, s, p_subpic );
  1375.     encode_clut( p_enc, s, p_subpic );
  1376.     encode_object( p_enc, s, p_subpic );
  1378.     /* End of display */
  1379.     bs_write( s, 8, 0x0f ); /* Sync byte */
  1380.     bs_write( s, 8, DVBSUB_ST_ENDOFDISPLAY ); /* Segment type */
  1381.     bs_write( s, 16, 1 ); /* Page id */
  1382.     bs_write( s, 16, 0 ); /* Segment length */
  1384.     bs_write( s, 8, 0xff ); /* End marker */
  1385.     p_block->i_buffer = bs_pos( s ) / 8;
  1386.     p_block->i_pts = p_block->i_dts = p_subpic->i_start;
  1387.     if( !p_subpic->b_ephemer && p_subpic->i_stop > p_subpic->i_start )
  1388.     {
  1389.         block_t *p_block_stop;
  1391.         p_block->i_length = p_subpic->i_stop - p_subpic->i_start;
  1393.         /* Send another (empty) subtitle to signal the end of display */
  1394.         p_block_stop = block_New( p_enc, 64000 );
  1395.         bs_init( s, p_block_stop->p_buffer, p_block_stop->i_buffer );
  1396.         bs_write( s, 8, 0x20 ); /* Data identifier */
  1397.         bs_write( s, 8, 0x0 ); /* Subtitle stream id */
  1398.         encode_page_composition( p_enc, s, 0 );
  1399.         bs_write( s, 8, 0x0f ); /* Sync byte */
  1400.         bs_write( s, 8, DVBSUB_ST_ENDOFDISPLAY ); /* Segment type */
  1401.         bs_write( s, 16, 1 ); /* Page id */
  1402.         bs_write( s, 16, 0 ); /* Segment length */
  1403.         bs_write( s, 8, 0xff ); /* End marker */
  1404.         p_block_stop->i_buffer = bs_pos( s ) / 8;
  1405.         p_block_stop->i_pts = p_block_stop->i_dts = p_subpic->i_stop;
  1406.         block_ChainAppend( &p_block, p_block_stop );
  1407.         p_block_stop->i_length = 100000;//p_subpic->i_stop - p_subpic->i_start;
  1408.     }
  1410.     msg_Dbg( p_enc, "subpicture encoded properly" );
  1412.     return p_block;
  1413. }
  1415. /*****************************************************************************
  1416.  * CloseEncoder: encoder destruction
  1417.  *****************************************************************************/
  1418. static void CloseEncoder( vlc_object_t *p_this )
  1419. {
  1420.     encoder_t *p_enc = (encoder_t *)p_this;
  1421.     encoder_sys_t *p_sys = p_enc->p_sys;
  1423.     if( p_sys->i_regions ) free( p_sys->p_regions );
  1424.     free( p_sys );
  1425. }
  1427. static void encode_page_composition( encoder_t *p_enc, bs_t *s,
  1428.                                      subpicture_t *p_subpic )
  1429. {
  1430.     encoder_sys_t *p_sys = p_enc->p_sys;
  1431.     subpicture_region_t *p_region;
  1432.     vlc_bool_t b_mode_change = VLC_FALSE;
  1433.     int i_regions, i_timeout;
  1435.     bs_write( s, 8, 0x0f ); /* Sync byte */
  1436.     bs_write( s, 8, DVBSUB_ST_PAGE_COMPOSITION ); /* Segment type */
  1437.     bs_write( s, 16, 1 ); /* Page id */
  1439.     for( i_regions = 0, p_region = p_subpic ? p_subpic->p_region : 0;
  1440.          p_region; p_region = p_region->p_next, i_regions++ )
  1441.     {
  1442.         if( i_regions >= p_sys->i_regions )
  1443.         {
  1444.             encoder_region_t region;
  1445.             region.i_width = region.i_height = 0;
  1446.             p_sys->p_regions =
  1447.                 realloc( p_sys->p_regions, sizeof(encoder_region_t) *
  1448.                          (p_sys->i_regions + 1) );
  1449.             p_sys->p_regions[p_sys->i_regions++] = region;
  1450.         }
  1452.         if( p_sys->p_regions[i_regions].i_width <
  1453.             (int)p_region->fmt.i_visible_width )
  1454.         {
  1455.             b_mode_change = VLC_TRUE;
  1456.             msg_Dbg( p_enc, "region %i width change: %i -> %i",
  1457.                      i_regions, p_sys->p_regions[i_regions].i_width,
  1458.                      p_region->fmt.i_visible_width );
  1459.             p_sys->p_regions[i_regions].i_width =
  1460.                 p_region->fmt.i_visible_width;
  1461.         }
  1462.         if( p_sys->p_regions[i_regions].i_height <
  1463.             (int)p_region->fmt.i_visible_height )
  1464.         {
  1465.             b_mode_change = VLC_TRUE;
  1466.             msg_Dbg( p_enc, "region %i height change: %i -> %i",
  1467.                      i_regions, p_sys->p_regions[i_regions].i_height,
  1468.                      p_region->fmt.i_visible_height );
  1469.             p_sys->p_regions[i_regions].i_height =
  1470.                 p_region->fmt.i_visible_height;
  1471.         }
  1472.     }
  1474.     bs_write( s, 16, i_regions * 6 + 2 ); /* Segment length */
  1476.     i_timeout = 0;
  1477.     if( p_subpic && !p_subpic->b_ephemer &&
  1478.         p_subpic->i_stop > p_subpic->i_start )
  1479.     {
  1480.         i_timeout = (p_subpic->i_stop - p_subpic->i_start) / 1000000;
  1481.     }
  1483.     bs_write( s, 8, i_timeout + 15 ); /* Timeout */
  1484.     bs_write( s, 4, p_sys->i_page_ver++ );
  1485.     bs_write( s, 2, b_mode_change ?
  1486.               DVBSUB_PCS_STATE_CHANGE : DVBSUB_PCS_STATE_ACQUISITION );
  1487.     bs_write( s, 2, 0 ); /* Reserved */
  1489.     for( i_regions = 0, p_region = p_subpic ? p_subpic->p_region : 0;
  1490.          p_region; p_region = p_region->p_next, i_regions++ )
  1491.     {
  1492.         bs_write( s, 8, i_regions );
  1493.         bs_write( s, 8, 0 ); /* Reserved */
  1494.         bs_write( s, 16, p_region->i_x );
  1495.         bs_write( s, 16, p_region->i_y );
  1496.     }
  1497. }
  1499. static void encode_clut( encoder_t *p_enc, bs_t *s, subpicture_t *p_subpic )
  1500. {
  1501.     encoder_sys_t *p_sys = p_enc->p_sys;
  1502.     subpicture_region_t *p_region = p_subpic->p_region;
  1503.     video_palette_t *p_pal;
  1504.     int i;
  1506.     /* Sanity check */
  1507.     if( !p_region || !p_region->fmt.p_palette ||
  1508.         p_region->fmt.i_chroma != VLC_FOURCC('Y','U','V','P') ) return;
  1510.     bs_write( s, 8, 0x0f ); /* Sync byte */
  1511.     bs_write( s, 8, DVBSUB_ST_CLUT_DEFINITION ); /* Segment type */
  1512.     bs_write( s, 16, 1 ); /* Page id */
  1514.     p_pal = p_region->fmt.p_palette;
  1516.     bs_write( s, 16, p_pal->i_entries * 6 + 2 ); /* Segment length */
  1517.     bs_write( s, 8, 1 ); /* Clut id */
  1518.     bs_write( s, 4, p_sys->i_clut_ver++ );
  1519.     bs_write( s, 4, 0 ); /* Reserved */
  1521.     for( i = 0; i < p_pal->i_entries; i++ )
  1522.     {
  1523.         bs_write( s, 8, i ); /* Clut entry id */
  1524.         bs_write( s, 1, p_pal->i_entries == 4 );   /* 2bit/entry flag */
  1525.         bs_write( s, 1, p_pal->i_entries == 16 );  /* 4bit/entry flag */
  1526.         bs_write( s, 1, p_pal->i_entries == 256 ); /* 8bit/entry flag */
  1527.         bs_write( s, 4, 0 ); /* Reserved */
  1528.         bs_write( s, 1, 1 ); /* Full range flag */
  1529.         bs_write( s, 8, p_pal->palette[i][3] ?  /* Y value */
  1530.                   (p_pal->palette[i][0] ? p_pal->palette[i][0] : 16) : 0 );
  1531.         bs_write( s, 8, p_pal->palette[i][1] ); /* Cr value */
  1532.         bs_write( s, 8, p_pal->palette[i][2] ); /* Cb value */
  1533.         bs_write( s, 8, 0xff - p_pal->palette[i][3] ); /* T value */
  1534.     }
  1535. }
  1537. static void encode_region_composition( encoder_t *p_enc, bs_t *s,
  1538.                                        subpicture_t *p_subpic )
  1539. {
  1540.     encoder_sys_t *p_sys = p_enc->p_sys;
  1541.     subpicture_region_t *p_region;
  1542.     int i_region, i_bg;
  1544.     for( i_region = 0, p_region = p_subpic->p_region; p_region;
  1545.          p_region = p_region->p_next, i_region++ )
  1546.     {
  1547.         video_palette_t *p_pal = p_region->fmt.p_palette;
  1548.         int i_depth = p_pal->i_entries == 4 ? 0x1 :
  1549.             p_pal->i_entries == 16 ? 0x2 : 0x3;
  1551.         for( i_bg = 0; i_bg < p_pal->i_entries; i_bg++ )
  1552.         {
  1553.             if( !p_pal->palette[i_bg][3] ) break;
  1554.         }
  1556.         bs_write( s, 8, 0x0f ); /* Sync byte */
  1557.         bs_write( s, 8, DVBSUB_ST_REGION_COMPOSITION ); /* Segment type */
  1558.         bs_write( s, 16, 1 ); /* Page id */
  1560.         bs_write( s, 16, 10 + 6 ); /* Segment length */
  1561.         bs_write( s, 8, i_region );
  1562.         bs_write( s, 4, p_sys->i_region_ver++ );
  1564.         /* Region attributes */
  1565.         bs_write( s, 1, i_bg < p_pal->i_entries ); /* Fill */
  1566.         bs_write( s, 3, 0 ); /* Reserved */
  1567.         bs_write( s, 16, p_sys->p_regions[i_region].i_width );
  1568.         bs_write( s, 16, p_sys->p_regions[i_region].i_height );
  1569.         bs_write( s, 3, i_depth );  /* Region level of compatibility */
  1570.         bs_write( s, 3, i_depth  ); /* Region depth */
  1571.         bs_write( s, 2, 0 ); /* Reserved */
  1572.         bs_write( s, 8, 1 ); /* Clut id */
  1573.         bs_write( s, 8, i_bg ); /* region 8bit pixel code */
  1574.         bs_write( s, 4, i_bg ); /* region 4bit pixel code */
  1575.         bs_write( s, 2, i_bg ); /* region 2bit pixel code */
  1576.         bs_write( s, 2, 0 ); /* Reserved */
  1578.         /* In our implementation we only have 1 object per region */
  1579.         bs_write( s, 16, i_region );
  1580.         bs_write( s, 2, DVBSUB_OT_BASIC_BITMAP );
  1581.         bs_write( s, 2, 0 ); /* object provider flag */
  1582.         bs_write( s, 12, 0 ); /* object horizontal position */
  1583.         bs_write( s, 4, 0 ); /* Reserved */
  1584.         bs_write( s, 12, 0 ); /* object vertical position */
  1585.     }
  1586. }
  1588. static void encode_pixel_data( encoder_t *p_enc, bs_t *s,
  1589.                                subpicture_region_t *p_region,
  1590.                                vlc_bool_t b_top );
  1592. static void encode_object( encoder_t *p_enc, bs_t *s, subpicture_t *p_subpic )
  1593. {
  1594.     encoder_sys_t   *p_sys = p_enc->p_sys;
  1595.     subpicture_region_t *p_region;
  1596.     int i_region;
  1598.     int i_length_pos, i_update_pos, i_pixel_data_pos;
  1600.     for( i_region = 0, p_region = p_subpic->p_region; p_region;
  1601.          p_region = p_region->p_next, i_region++ )
  1602.     {
  1603.         bs_write( s, 8, 0x0f ); /* Sync byte */
  1604.         bs_write( s, 8, DVBSUB_ST_OBJECT_DATA ); /* Segment type */
  1605.         bs_write( s, 16, 1 ); /* Page id */
  1607.         i_length_pos = bs_pos( s );
  1608.         bs_write( s, 16, 0 ); /* Segment length */
  1609.         bs_write( s, 16, i_region ); /* Object id */
  1610.         bs_write( s, 4, p_sys->i_region_ver++ );
  1611.         bs_write( s, 2, 0 ); /* object coding method */
  1613.         bs_write( s, 1, 0 ); /* non modifying color flag */
  1614.         bs_write( s, 1, 0 ); /* Reserved */
  1616.         i_update_pos = bs_pos( s );
  1617.         bs_write( s, 16, 0 ); /* topfield data block length */
  1618.         bs_write( s, 16, 0 ); /* bottomfield data block length */
  1620.         /* Top field */
  1621.         i_pixel_data_pos = bs_pos( s );
  1622.         encode_pixel_data( p_enc, s, p_region, VLC_TRUE );
  1623.         i_pixel_data_pos = ( bs_pos( s ) - i_pixel_data_pos ) / 8;
  1624.         SetWBE( &s->p_start[i_update_pos/8], i_pixel_data_pos );
  1626.         /* Bottom field */
  1627.         i_pixel_data_pos = bs_pos( s );
  1628.         encode_pixel_data( p_enc, s, p_region, VLC_FALSE );
  1629.         i_pixel_data_pos = ( bs_pos( s ) - i_pixel_data_pos ) / 8;
  1630.         SetWBE( &s->p_start[i_update_pos/8+2], i_pixel_data_pos );
  1632.         /* Stuffing for word alignment */
  1633.         bs_align_0( s );
  1634.         if( bs_pos( s ) % 16 ) bs_write( s, 8, 0 );
  1636.         /* Update segment length */
  1637.         SetWBE( &s->p_start[i_length_pos/8], (bs_pos(s) - i_length_pos)/8 -2 );
  1638.     }
  1639. }
  1641. static void encode_pixel_line_2bp( encoder_t *p_enc, bs_t *s,
  1642.                                    subpicture_region_t *p_region,
  1643.                                    int i_line );
  1644. static void encode_pixel_line_4bp( encoder_t *p_enc, bs_t *s,
  1645.                                    subpicture_region_t *p_region,
  1646.                                    int i_line );
  1647. static void encode_pixel_data( encoder_t *p_enc, bs_t *s,
  1648.                                subpicture_region_t *p_region,
  1649.                                vlc_bool_t b_top )
  1650. {
  1651.     unsigned int i_line;
  1653.     /* Sanity check */
  1654.     if( p_region->fmt.i_chroma != VLC_FOURCC('Y','U','V','P') ) return;
  1656.     /* Encode line by line */
  1657.     for( i_line = !b_top; i_line < p_region->fmt.i_visible_height;
  1658.          i_line += 2 )
  1659.     {
  1660.         switch( p_region->fmt.p_palette->i_entries )
  1661.         {
  1662.         case 4:
  1663.             bs_write( s, 8, 0x10 ); /* 2 bit/pixel code string */
  1664.             encode_pixel_line_2bp( p_enc, s, p_region, i_line );
  1665.             break;
  1667.         case 16:
  1668.             bs_write( s, 8, 0x11 ); /* 4 bit/pixel code string */
  1669.             encode_pixel_line_4bp( p_enc, s, p_region, i_line );
  1670.             break;
  1672.         default:
  1673.             msg_Err( p_enc, "subpicture palette (%i) not handled",
  1674.                      p_region->fmt.p_palette->i_entries );
  1675.             break;
  1676.         }
  1678.         bs_write( s, 8, 0xf0 ); /* End of object line code */
  1679.     }
  1680. }
  1682. static void encode_pixel_line_2bp( encoder_t *p_enc, bs_t *s,
  1683.                                    subpicture_region_t *p_region,
  1684.                                    int i_line )
  1685. {
  1686.     unsigned int i, i_length = 0;
  1687.     int i_pitch = p_region->picture.p->i_pitch;
  1688.     uint8_t *p_data = &p_region->picture.p->p_pixels[ i_pitch * i_line ];
  1689.     int i_last_pixel = p_data[0];
  1691.     for( i = 0; i <= p_region->fmt.i_visible_width; i++ )
  1692.     {
  1693.         if( i != p_region->fmt.i_visible_width &&
  1694.             p_data[i] == i_last_pixel && i_length != 284 )
  1695.         {
  1696.             i_length++;
  1697.             continue;
  1698.         }
  1700.         if( i_length == 1 || i_length == 11 || i_length == 28 )
  1701.         {
  1702.             /* 2bit/pixel code */
  1703.             if( i_last_pixel ) bs_write( s, 2, i_last_pixel );
  1704.             else
  1705.             {
  1706.                 bs_write( s, 2, 0 );
  1707.                 bs_write( s, 1, 0 );
  1708.                 bs_write( s, 1, 1 ); /* pseudo color 0 */
  1709.             }
  1710.             i_length--;
  1711.         }
  1713.         if( i_length == 2 )
  1714.         {
  1715.             if( i_last_pixel )
  1716.             {
  1717.                 bs_write( s, 2, i_last_pixel );
  1718.                 bs_write( s, 2, i_last_pixel );
  1719.             }
  1720.             else
  1721.             {
  1722.                 bs_write( s, 2, 0 );
  1723.                 bs_write( s, 1, 0 );
  1724.                 bs_write( s, 1, 0 );
  1725.                 bs_write( s, 2, 1 ); /* 2 * pseudo color 0 */
  1726.             }
  1727.         }
  1728.         else if( i_length > 2 )
  1729.         {
  1730.             bs_write( s, 2, 0 );
  1731.             if( i_length <= 10 )
  1732.             {
  1733.                 bs_write( s, 1, 1 );
  1734.                 bs_write( s, 3, i_length - 3 );
  1735.                 bs_write( s, 2, i_last_pixel );
  1736.             }
  1737.             else
  1738.             {
  1739.                 bs_write( s, 1, 0 );
  1740.                 bs_write( s, 1, 0 );
  1742.                 if( i_length <= 27 )
  1743.                 {
  1744.                     bs_write( s, 2, 2 );
  1745.                     bs_write( s, 4, i_length - 12 );
  1746.                     bs_write( s, 2, i_last_pixel );
  1747.                 }
  1748.                 else
  1749.                 {
  1750.                     bs_write( s, 2, 3 );
  1751.                     bs_write( s, 8, i_length - 29 );
  1752.                     bs_write( s, 2, i_last_pixel );
  1753.                 }
  1754.             }
  1755.         }
  1757.         if( i == p_region->fmt.i_visible_width ) break;
  1759.         i_last_pixel = p_data[i];
  1760.         i_length = 1;
  1761.     }
  1763.     /* Stop */
  1764.     bs_write( s, 2, 0 );
  1765.     bs_write( s, 1, 0 );
  1766.     bs_write( s, 1, 0 );
  1767.     bs_write( s, 2, 0 );
  1769.     /* Stuffing */
  1770.     bs_align_0( s );
  1771. }
  1773. static void encode_pixel_line_4bp( encoder_t *p_enc, bs_t *s,
  1774.                                    subpicture_region_t *p_region,
  1775.                                    int i_line )
  1776. {
  1777.     unsigned int i, i_length = 0;
  1778.     int i_pitch = p_region->picture.p->i_pitch;
  1779.     uint8_t *p_data = &p_region->picture.p->p_pixels[ i_pitch * i_line ];
  1780.     int i_last_pixel = p_data[0];
  1782.     for( i = 0; i <= p_region->fmt.i_visible_width; i++ )
  1783.     {
  1784.         if( i != p_region->fmt.i_visible_width &&
  1785.             p_data[i] == i_last_pixel && i_length != 1 )
  1786.         {
  1787.             i_length++;
  1788.             continue;
  1789.         }
  1791.         if( i_length == 1 )
  1792.         {
  1793.             /* 4bit/pixel code */
  1794.             if( i_last_pixel ) bs_write( s, 4, i_last_pixel );
  1795.             else
  1796.             {
  1797.                 bs_write( s, 4, 0 );
  1798.                 bs_write( s, 1, 1 );
  1799.                 bs_write( s, 1, 1 );
  1800.                 bs_write( s, 2, 0 ); /* pseudo color 0 */
  1801.             }
  1802.         }
  1804.         if( i == p_region->fmt.i_visible_width ) break;
  1806.         i_last_pixel = p_data[i];
  1807.         i_length = 1;
  1808.     }
  1810.     /* Stop */
  1811.     bs_write( s, 8, 0 );
  1813.     /* Stuffing */
  1814.     bs_align_0( s );
  1815. }