e57184b8ec2202eee3a303017469941dcebbea93
[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.4 2003/12/30 04:43: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 are different in severl ways from SVCD OGT subtitles.
55   First, the image comes first and the metadata is at the end.  So
56   that the metadata can be found easily, the subtitle packet starts
57   with two bytes (everything is big-endian again) that give the total
58   size of the subtitle data and the offset to the metadata - i.e. size
59   of the image data plus the four bytes at the beginning.
60  
61   Image data comes interlaced is run-length encoded.  Each field is a
62   four-bit nibble. Each nibble contains a two-bit repeat count and a
63   two-bit color number so that up to three pixels can be described in
64   four bits.  The function of a 0 repeat count is unknown; it might be
65   used for RLE extension.  However when the full nibble is zero, the
66   rest of the line is filled with the color value in the next nibble.
67   It is unknown what happens if the color value is greater than three.
68   The rest seems to use a 4-entries palette.  It is not impossible
69   that the fill-line complete case above is not as described and the
70   zero repeat count means fill line.  The sample code never produces
71   this, so it may be untested.
72  
73   The metadata section does not follow a fixed pattern, every
74   metadata item consists of a tag byte followed by parameters. In all
75   cases known, the block (including the tag byte) is exactly four
76   bytes in length.  Read the code for the rest.
77 */
78
79 void E_(ParseHeader)( decoder_t *p_dec, uint8_t *p_buffer, block_t *p_block )
80 {
81   decoder_sys_t *p_sys = p_dec->p_sys;
82   u_int8_t *p = p_buffer+1;
83
84   dbg_print( (DECODE_DBG_CALL|DECODE_DBG_PACKET), 
85              "header: 0x%02x 0x%02x 0x%02x 0x%02x, 0x%02x, 0x%02x, size: %i",
86              p_buffer[0], p_buffer[1], p_buffer[2], p_buffer[3],
87              p_buffer[4], p_buffer[5],
88              p_block->i_buffer);
89   
90   dbg_print( (DECODE_DBG_CALL|DECODE_DBG_EXT) , "");
91
92   p_sys->i_pts    = p_block->i_pts;
93   p_sys->i_spu_size = (p[0] << 8) + p[1] + 4; p += 2;
94
95   /* FIXME: check data sanity */
96   p_sys->metadata_offset = GETINT16(p);
97   p_sys->metadata_length = p_sys->i_spu_size - p_sys->metadata_offset;
98
99   p_sys->comp_image_offset = 4;
100   p_sys->comp_image_length = p_sys->metadata_offset - p_sys->comp_image_offset;
101   
102   dbg_print(DECODE_DBG_PACKET, "total size: %d  image size: %d\n",
103             p_sys->i_spu_size, p_sys->comp_image_length);
104
105 }
106
107
108 /*****************************************************************************
109  * ParsePacket: parse an SPU packet and send it to the video output
110  *****************************************************************************
111  * This function parses the SPU packet and, if valid, sends it to the
112  * video output.
113  *****************************************************************************/
114 void 
115 E_(ParsePacket)( decoder_t *p_dec)
116 {
117     decoder_sys_t *p_sys = p_dec->p_sys;
118
119     subpicture_t  *p_spu;
120
121     dbg_print( (DECODE_DBG_CALL|DECODE_DBG_EXT) , "");
122
123     /* Allocate the subpicture internal data. */
124     p_spu = vout_CreateSubPicture( p_sys->p_vout, MEMORY_SUBPICTURE );
125     if( p_spu == NULL )
126     {
127         return;
128     }
129
130     /* In ParseImage we expand the run-length encoded color 0's; also
131        we expand pixels and remove the color palette. This should
132        facilitate scaling and antialiasing and speed up rendering.
133     */
134     p_spu->p_sys = malloc( sizeof( subpicture_sys_t ) 
135                            + PIXEL_SIZE * (p_sys->i_width * p_sys->i_height) );
136
137     /* Fill the p_spu structure */
138     vlc_mutex_init( p_dec, &p_spu->p_sys->lock );
139
140     p_spu->pf_render  = VCDSubRender;
141     p_spu->pf_destroy = VCDSubDestroySPU;
142     p_spu->p_sys->p_data = (uint8_t*)p_spu->p_sys + sizeof( subpicture_sys_t );
143
144     p_spu->p_sys->i_x_end        = p_sys->i_x_start + p_sys->i_width - 1;
145     p_spu->p_sys->i_y_end        = p_sys->i_y_start + p_sys->i_height - 1;
146
147     /* FIXME: use aspect ratio for x? */
148     p_spu->i_x        = p_sys->i_x_start * 3 / 4; 
149     p_spu->i_y        = p_sys->i_y_start;
150     p_spu->i_width    = p_sys->i_width;
151     p_spu->i_height   = p_sys->i_height;
152
153     p_spu->i_start    = p_sys->i_pts;
154     p_spu->i_stop     = p_sys->i_pts + (p_sys->i_duration * 5);
155     
156     p_spu->p_sys->b_crop  = VLC_FALSE;
157     p_spu->p_sys->i_debug = p_sys->i_debug;
158
159     /* Get display time now. If we do it later, we may miss the PTS. */
160     p_spu->p_sys->i_pts = p_sys->i_pts;
161
162     /* Attach to our input thread */
163     p_spu->p_sys->p_input = vlc_object_find( p_dec,
164                                              VLC_OBJECT_INPUT, FIND_PARENT );
165
166     /* We try to display it */
167     if( ParseImage( p_dec, p_spu ) )
168     {
169         /* There was a parse error, delete the subpicture */
170         vout_DestroySubPicture( p_sys->p_vout, p_spu );
171         return;
172     }
173
174     /* SPU is finished - we can ask the video output to display it */
175     vout_DisplaySubPicture( p_sys->p_vout, p_spu );
176
177 }
178
179 #define advance_color_byte_pointer                                      \
180   p++;                                                                  \
181   i_nibble_field = 2;                                                   \
182   /*                                                                    \
183    * This is wrong, it may exceed maxp if it is the last, check         \
184    * should be moved to use location or the algorithm changed to        \
185    * that in vob2sub                                                    \
186   */                                                                    \
187   if (p >= maxp) {                                                      \
188     msg_Warn( p_dec,                                                    \
189               "broken subtitle - overflow while decoding "              \
190               " padding (%d,%d,%d)\n",                                  \
191               i_field, i_row, i_column );                               \
192     return VLC_EGENERIC;                                                \
193   }                                                                     
194
195 #define CVD_FIELD_BITS (4)
196 #define CVD_FIELD_MASK  ((1<<CVD_FIELD_BITS) - 1) 
197
198 /* Get the next field - a 2-bit palette index and a run count.  To do
199    this we use byte image pointer p, and i_nibble_field which
200    indicates where we are in the byte.
201 */
202 static inline uint8_t
203 ExtractField(uint8_t *p, uint8_t i_nibble_field) 
204 {
205   return ( ( *p >> (CVD_FIELD_BITS*(i_nibble_field-1)) ) & CVD_FIELD_MASK );
206 }
207
208 /*****************************************************************************
209  * ParseImage: parse the image part of the subtitle
210  *****************************************************************************
211  This part parses the subtitle graphical data and stores it in a more
212  convenient structure for later rendering. 
213
214  Image data comes interlaced and is run-length encoded (RLE). Each
215  field is a four-bit nibbles that is further subdivided in a two-bit
216  repeat count and a two-bit color number - up to three pixels can be
217  described in four bits.  What a 0 repeat count means is unknown.  It
218  might be used for RLE extension.  There is a special case of a 0
219  repeat count though.  When the full nibble is zero, the rest of the
220  line is filled with the color value in the next nibble.  It is
221  unknown what happens if the color value is greater than three.  The
222  rest seems to use a 4-entries palette.  It is not impossible that the
223  fill-line complete case above is not as described and the zero repeat
224  count means fill line.  The sample code never produces this, so it
225  may be untested.
226
227  However we'll transform this so that that the RLE is expanded and
228  interlacing will also be removed. On output each pixel entry will by 
229  a 4-bit alpha (filling 8 bits), and 8-bit y, u, and v entry.
230
231  *****************************************************************************/
232 static int 
233 ParseImage( decoder_t *p_dec, subpicture_t * p_spu )
234 {
235     decoder_sys_t *p_sys = p_dec->p_sys;
236
237     uint8_t i_field;       /* The subtitles are interlaced, are we on an
238                               even or odd scanline?  */
239     unsigned int i_row;    /* scanline row number */
240     unsigned int i_column; /* scanline column number */
241
242     unsigned int i_width  = p_sys->i_width;
243     unsigned int i_height = p_sys->i_height;
244
245     uint8_t *p_dest = (uint8_t *)p_spu->p_sys->p_data;
246
247     uint8_t i_nibble_field;    /* The 2-bit pixels remaining in byte of *p.
248                                   Has value 0..2. */
249     vlc_bool_t b_filling;      /* Filling i_color to the of the line. */
250     uint8_t i_pending = 0;     /* number of pixels to fill with 
251                                   color zero 0..3 */
252     ogt_color_t i_color=0;     /* current pixel color: 0..3 */
253     uint8_t *p = p_sys->subtitle_data  + p_sys->comp_image_offset;
254     uint8_t *maxp = p + p_sys->comp_image_length;
255
256     dbg_print( (DECODE_DBG_CALL) , "width x height: %dx%d",
257                i_width, i_height);
258
259     if (p_sys && p_sys->i_debug & DECODE_DBG_IMAGE)     
260       printf("\n");
261
262     i_pending = 0;
263
264     for ( i_field=0; i_field < 2; i_field++ ) {
265       i_nibble_field = 2;  /* 4-bit pieces available in *p */
266
267       for ( i_row=i_field; i_row < i_height; i_row += 2 ) {
268         b_filling   = VLC_FALSE;
269         for ( i_column=0; i_column<i_width; i_column++ ) {
270           if ( i_pending ) {
271             /* We are in the middle of a RLE expansion, just decrement and 
272                fall through with current color value */
273             i_pending--;
274           } else if ( b_filling ) {
275             /* We are just filling to the end of line with one color, just
276                reuse current color value */
277           } else {
278             uint8_t i_val = ExtractField(p, i_nibble_field--);
279             if ( i_nibble_field == 0 ) {
280               advance_color_byte_pointer;
281             }
282             if ( i_val == 0 ) {
283               /* fill the rest of the line with next color */
284               i_color = ExtractField( p, i_nibble_field-- );
285               if ( i_nibble_field == 0 ) {
286                 p++;
287                 i_nibble_field=2;
288                 /*
289                   This is wrong, it may exceed maxp if it is the
290                   last, check should be moved to use location or the
291                   algorithm changed to that in vob2sub
292                 */
293                 if (p >= maxp) {
294                   msg_Warn( p_dec, 
295                             "broken subtitle - overflow while decoding "
296                             " filling (%d,%d,%d)", 
297                               i_field, i_row, i_column);
298                   /* return VLC_EGENERIC; */
299                 }
300               }
301               b_filling = VLC_TRUE;
302             } else {
303               /* Normal case: get color and repeat count, 
304                  this iteration will  output the first (or only) 
305                  instance */
306               i_pending = (i_val >> 2);
307               i_color = i_val & 0x3;
308               /* This time counts against the total */
309               i_pending--;
310             }
311           }
312           /* Color is 0-3. */
313           p_dest[i_row*i_width+i_column] = i_color;
314           
315           if (p_sys && p_sys->i_debug & DECODE_DBG_IMAGE)       
316             printf("%1d", i_color);
317           
318         }
319         
320         if ( i_nibble_field == 1 ) {
321           advance_color_byte_pointer;
322         }
323
324         if (p_sys && p_sys->i_debug & DECODE_DBG_IMAGE) 
325           printf("\n");
326       }
327     }
328
329     /* Dump out image not interlaced... */
330     if (p_sys && p_sys->i_debug & DECODE_DBG_IMAGE) {
331       uint8_t *p = p_dest;
332       printf("-------------------------------------\n++");
333       for ( i_row=0; i_row < i_height; i_row ++ ) {
334         for ( i_column=0; i_column<i_width; i_column++ ) {
335           printf("%1d", *p++ & 0x03);
336         }
337         printf("\n++");
338       }
339       printf("\n-------------------------------------\n");
340     }
341
342     VCDInlinePalette( p_dest, p_sys, i_height, i_width );
343
344     /* The video is automatically scaled. However subtitle bitmaps
345        assume a 1:1 aspect ratio. So we need to scale to compensate for
346        or undo the effects of video output scaling. 
347     */
348     /* FIXME do the right scaling depending on vout. It may not be 4:3 */
349     VCDSubScaleX( p_dec, p_spu, 3, 4 );
350
351     /* To be finished...*/
352     return VLC_SUCCESS;
353
354 }
355