First cut at CVD subtitle unit assembly and initial parsing.
[vlc.git] / modules / codec / ogt / cvd_parse.c
1 /*****************************************************************************
2  * parse.c: Philips OGT (SVCD subtitle) packet parser
3  *****************************************************************************
4  * Copyright (C) 2003 VideoLAN
5  * $Id: cvd_parse.c,v 1.2 2003/12/28 11:26:52 rocky Exp $
6  *
7  * Authors: Rocky Bernstein 
8  *   based on code from: 
9  *       Julio Sanchez Fernandez (http://subhandler.sourceforge.net)
10  *       Sam Hocevar <sam@zoy.org>
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 /*****************************************************************************
29  * Preamble
30  *****************************************************************************/
31 #include <vlc/vlc.h>
32 #include <vlc/vout.h>
33 #include <vlc/decoder.h>
34
35 #include "subtitle.h"
36 #include "render.h"
37 #include "cvd.h"
38 #include "common.h"
39
40 /* An image color is a two-bit palette entry: 0..3 */ 
41 typedef uint8_t ogt_color_t;
42
43 /*****************************************************************************
44  * Local prototypes.
45  *****************************************************************************/
46 static int  ParseImage         ( decoder_t *, subpicture_t * );
47
48 /*
49  * We do not have information on the subtitle format used on CVD's
50  * except the submux sample code and a couple of samples of dubious
51  * origin. Thus, this is the result of reading some code whose
52  * correctness is not known and some experimentation.
53  * 
54  * CVD subtitles present several differences compared to SVCD OGT
55  * subtitles.  Firstly, the image comes first and the metadata is at
56  * the end.  So that the metadata can be found easily, the subtitle
57  * begins with two two-byte (everything is big-endian again) that
58  * describe, the total size of the subtitle data and the offset to the
59  * metadata (size of the image data plus the four bytes at the
60  * beginning.
61  *
62  * Image data comes interlaced and uses RLE.  Coding is based in
63  * four-bit nibbles that are further subdivided in a two-bit repeat
64  * count and a two-bit color number so that up to three pixels can be
65  * describe with a total of four bits.  The function of a 0 repeat
66  * count is unknown.  It might be used for RLE extension.  There is a
67  * special case, though.  When the full nibble is zero, the rest of
68  * the line is filled with the color value in the next nibble.  It is
69  * unknown what happens if the color value is greater than three.  The
70  * rest seems to use a 4-entries palette.  It is not impossible that
71  * the fill-line complete case above is not as described and the zero
72  * repeat count means fill line.  The sample code never produces this,
73  * so it may be untested.
74  *
75  * The metadata section does not follow a fixed pattern, every
76  * metadata item consists of a tag byte followed by parameters. In all
77  * cases known, the block (including the tag byte) is exactly four
78  * bytes in length.  Read the code for the rest.
79  */
80
81 /* FIXME: do we really need p_buffer and p? 
82    Can't all of thes _offset's and _lengths's get removed? 
83 */
84 void E_(ParseHeader)( decoder_t *p_dec, uint8_t *p_buffer, block_t *p_block )
85 {
86   decoder_sys_t *p_sys = p_dec->p_sys;
87   u_int8_t *p = p_buffer+1;
88
89   dbg_print( (DECODE_DBG_CALL|DECODE_DBG_PACKET), 
90              "header: 0x%02x 0x%02x 0x%02x 0x%02x, 0x%02x, 0x%02x, size: %i",
91              p_buffer[0], p_buffer[1], p_buffer[2], p_buffer[3],
92              p_buffer[4], p_buffer[5],
93              p_block->i_buffer);
94   
95   dbg_print( (DECODE_DBG_CALL|DECODE_DBG_EXT) , "");
96
97   p_sys->i_pts    = p_block->i_pts;
98   p_sys->i_spu_size = (p[0] << 8) + p[1] + 4; p += 2;
99
100   /* FIXME: check data sanity */
101   p_sys->metadata_offset = GETINT16(p);
102   p_sys->metadata_length = p_sys->i_spu_size - p_sys->metadata_offset;
103
104   p_sys->comp_image_offset = 4;
105   p_sys->comp_image_length = p_sys->metadata_offset - p_sys->comp_image_offset;
106   
107   dbg_print(DECODE_DBG_PACKET, "total size: %d  image size: %d\n",
108             p_sys->i_spu_size, p_sys->comp_image_length);
109
110 }
111
112
113 /*****************************************************************************
114  * ParsePacket: parse an SPU packet and send it to the video output
115  *****************************************************************************
116  * This function parses the SPU packet and, if valid, sends it to the
117  * video output.
118  *****************************************************************************/
119 void 
120 E_(ParsePacket)( decoder_t *p_dec)
121 {
122     decoder_sys_t *p_sys = p_dec->p_sys;
123
124     subpicture_t  *p_spu;
125
126     dbg_print( (DECODE_DBG_CALL|DECODE_DBG_EXT) , "");
127
128     /* Allocate the subpicture internal data. */
129     p_spu = vout_CreateSubPicture( p_sys->p_vout, MEMORY_SUBPICTURE );
130     if( p_spu == NULL )
131     {
132         return;
133     }
134
135     /* In ParseImage we expand the run-length encoded color 0's; also
136        we expand pixels and remove the color palette. This should
137        facilitate scaling and antialiasing and speed up rendering.
138     */
139     p_spu->p_sys = malloc( sizeof( subpicture_sys_t ) 
140                            + PIXEL_SIZE * (p_sys->i_width * p_sys->i_height) );
141
142     /* Fill the p_spu structure */
143     vlc_mutex_init( p_dec, &p_spu->p_sys->lock );
144
145     p_spu->pf_render  = VCDSubRender;
146     p_spu->pf_destroy = VCDSubDestroySPU;
147     p_spu->p_sys->p_data = (uint8_t*)p_spu->p_sys + sizeof( subpicture_sys_t );
148
149     p_spu->p_sys->i_x_end        = p_sys->i_x_start + p_sys->i_width - 1;
150     p_spu->p_sys->i_y_end        = p_sys->i_y_start + p_sys->i_height - 1;
151
152     /* FIXME: use aspect ratio for x? */
153     p_spu->i_x        = p_sys->i_x_start * 3 / 4; 
154     p_spu->i_y        = p_sys->i_y_start;
155     p_spu->i_width    = p_sys->i_width;
156     p_spu->i_height   = p_sys->i_height;
157
158     p_spu->i_start    = p_sys->i_pts;
159     p_spu->i_stop     = p_sys->i_pts + (p_sys->i_duration * 10);
160     
161     p_spu->p_sys->b_crop  = VLC_FALSE;
162     p_spu->p_sys->i_debug = p_sys->i_debug;
163
164     /* Get display time now. If we do it later, we may miss the PTS. */
165     p_spu->p_sys->i_pts = p_sys->i_pts;
166
167     /* Attach to our input thread */
168     p_spu->p_sys->p_input = vlc_object_find( p_dec,
169                                              VLC_OBJECT_INPUT, FIND_PARENT );
170
171     /* We try to display it */
172     if( ParseImage( p_dec, p_spu ) )
173     {
174         /* There was a parse error, delete the subpicture */
175         vout_DestroySubPicture( p_sys->p_vout, p_spu );
176         return;
177     }
178
179     /* SPU is finished - we can ask the video output to display it */
180     vout_DisplaySubPicture( p_sys->p_vout, p_spu );
181
182 }
183
184 /* Advance pointer to image pointer, update internal i_remaining counter
185    and check that we haven't goine too far  in the image data. */
186 #define advance_color_pointer_byte                                      \
187   p++;                                                                  \
188   i_remaining=4;                                                        \
189   if (p >= maxp) {                                                      \
190     msg_Warn( p_dec,                                                    \
191               "broken subtitle - tried to access beyond end "           \
192               "in image extraction");                                   \
193     return VLC_EGENERIC;                                                \
194   }                                                                     \
195
196 #define advance_color_pointer                                           \
197   i_remaining--;                                                        \
198   if ( i_remaining == 0 ) {                                             \
199     advance_color_pointer_byte;                                         \
200   }                                                                     
201
202 /* Get the next field - either a palette index or a RLE count for
203    color 0.  To do this we use byte image pointer p, and i_remaining
204    which indicates where we are in the byte.
205 */
206 static inline ogt_color_t 
207 ExtractField(uint8_t *p, unsigned int i_remaining) 
208 {
209   return ( ( *p >> 2*(i_remaining-1) ) & 0x3 );
210 }
211
212 /*****************************************************************************
213  * ParseImage: parse the image part of the subtitle
214  *****************************************************************************
215  This part parses the subtitle graphical data and stores it in a more
216  convenient structure for later rendering. 
217
218  The image is encoded using two bits per pixel that select a palette
219  entry except that value 0 starts a limited run-length encoding for
220  color 0.  When 0 is seen, the next two bits encode one less than the
221  number of pixels, so we can encode run lengths from 1 to 4. These get
222  filled with the color in palette entry 0.
223
224  The encoding of each line is padded to a whole number of bytes.  The
225  first field is padded to an even byte length and the complete subtitle
226  is padded to a 4-byte multiple that always include one zero byte at
227  the end.
228
229  However we'll transform this so that that the RLE is expanded and
230  interlacing will also be removed. On output each pixel entry will by 
231  an 8-bit alpha, y, u, and v entry.
232
233  *****************************************************************************/
234 static int 
235 ParseImage( decoder_t *p_dec, subpicture_t * p_spu )
236 {
237     decoder_sys_t *p_sys = p_dec->p_sys;
238
239     dbg_print( (DECODE_DBG_CALL) , "");
240     /* To be finished...*/
241     return VLC_EGENERIC;
242
243 }
244