1 /*****************************************************************************
2 * cvd.c : CVD Subtitle decoder
3 *****************************************************************************
4 * Copyright (C) 2003, 2004 the VideoLAN team
7 * Authors: Rocky Bernstein
8 * Gildas Bazin <gbazin@videolan.org>
9 * Julio Sanchez Fernandez (http://subhandler.sourceforge.net)
10 * Laurent Aimar <fenrir@via.ecp.fr>
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
25 *****************************************************************************/
27 /*****************************************************************************
29 *****************************************************************************/
32 #include <vlc_codec.h>
36 #define DEBUG_CVDSUB 1
38 /*****************************************************************************
40 *****************************************************************************/
41 static int DecoderOpen ( vlc_object_t * );
42 static int PacketizerOpen( vlc_object_t * );
43 static void DecoderClose ( vlc_object_t * );
46 set_description( _("CVD subtitle decoder") );
47 set_capability( "decoder", 50 );
48 set_callbacks( DecoderOpen, DecoderClose );
51 set_description( _("Chaoji VCD subtitle packetizer") );
52 set_capability( "packetizer", 50 );
53 set_callbacks( PacketizerOpen, DecoderClose );
56 /*****************************************************************************
58 *****************************************************************************/
59 static subpicture_t *Decode( decoder_t *, block_t ** );
60 static block_t *Packetize ( decoder_t *, block_t ** );
61 static block_t *Reassemble ( decoder_t *, block_t * );
62 static void ParseMetaInfo ( decoder_t *, block_t * );
63 static void ParseHeader ( decoder_t *, block_t * );
64 static subpicture_t *DecodePacket( decoder_t *, block_t * );
65 static void RenderImage( decoder_t *, block_t *, subpicture_region_t * );
67 #define SUBTITLE_BLOCK_EMPTY 0
68 #define SUBTITLE_BLOCK_PARTIAL 1
69 #define SUBTITLE_BLOCK_COMPLETE 2
75 int i_state; /* data-gathering state for this subtitle */
77 block_t *p_spu; /* Bytes of the packet. */
79 int i_spu_size; /* goal for subtitle_data_pos while gathering,
80 size of used subtitle_data later */
82 uint16_t i_image_offset; /* offset from subtitle_data to compressed
84 int i_image_length; /* size of the compressed image data */
85 int first_field_offset; /* offset of even raster lines */
86 int second_field_offset; /* offset of odd raster lines */
87 int metadata_offset; /* offset to data describing the image */
88 int metadata_length; /* length of metadata */
90 mtime_t i_duration; /* how long to display the image, 0 stands
91 for "until next subtitle" */
93 uint16_t i_x_start, i_y_start; /* position of top leftmost pixel of
94 image when displayed */
95 uint16_t i_width, i_height; /* dimensions in pixels of image */
97 uint8_t p_palette[4][4]; /* Palette of colors used in subtitle */
98 uint8_t p_palette_highlight[4][4];
101 /*****************************************************************************
102 * DecoderOpen: open/initialize the cvdsub decoder.
103 *****************************************************************************/
104 static int DecoderOpen( vlc_object_t *p_this )
106 decoder_t *p_dec = (decoder_t*)p_this;
107 decoder_sys_t *p_sys;
109 if( p_dec->fmt_in.i_codec != VLC_FOURCC( 'c','v','d',' ' ) )
114 p_dec->p_sys = p_sys = malloc( sizeof( decoder_sys_t ) );
116 p_sys->b_packetizer = VLC_FALSE;
118 p_sys->i_state = SUBTITLE_BLOCK_EMPTY;
121 es_format_Init( &p_dec->fmt_out, SPU_ES, VLC_FOURCC( 'c','v','d',' ' ) );
123 p_dec->pf_decode_sub = Decode;
124 p_dec->pf_packetize = Packetize;
129 /*****************************************************************************
130 * PacketizerOpen: open/initialize the cvdsub packetizer.
131 *****************************************************************************/
132 static int PacketizerOpen( vlc_object_t *p_this )
134 decoder_t *p_dec = (decoder_t*)p_this;
136 if( DecoderOpen( p_this ) != VLC_SUCCESS ) return VLC_EGENERIC;
138 p_dec->p_sys->b_packetizer = VLC_TRUE;
143 /*****************************************************************************
144 * DecoderClose: closes the cvdsub decoder/packetizer.
145 *****************************************************************************/
146 void DecoderClose( vlc_object_t *p_this )
148 decoder_t *p_dec = (decoder_t*)p_this;
149 decoder_sys_t *p_sys = p_dec->p_sys;
151 if( p_sys->p_spu ) block_ChainRelease( p_sys->p_spu );
155 /*****************************************************************************
157 *****************************************************************************/
158 static subpicture_t *Decode( decoder_t *p_dec, block_t **pp_block )
160 block_t *p_block, *p_spu;
162 if( pp_block == NULL || *pp_block == NULL ) return NULL;
167 if( !(p_spu = Reassemble( p_dec, p_block )) ) return NULL;
169 /* Parse and decode */
170 return DecodePacket( p_dec, p_spu );
173 /*****************************************************************************
175 *****************************************************************************/
176 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
178 block_t *p_block, *p_spu;
180 if( pp_block == NULL || *pp_block == NULL ) return NULL;
185 if( !(p_spu = Reassemble( p_dec, p_block )) ) return NULL;
187 p_spu->i_dts = p_spu->i_pts;
194 /*****************************************************************************
197 Data for single screen subtitle may come in several non-contiguous
198 packets of a stream. This routine is called when the next packet in
199 the stream comes in. The job of this routine is to parse the header,
200 if this is the beginning, and combine the packets into one complete
203 If everything is complete, we will return a block. Otherwise return
206 *****************************************************************************/
207 #define SPU_HEADER_LEN 1
209 static block_t *Reassemble( decoder_t *p_dec, block_t *p_block )
211 decoder_sys_t *p_sys = p_dec->p_sys;
214 if( p_block->i_buffer < SPU_HEADER_LEN )
216 msg_Dbg( p_dec, "invalid packet header (size %d < %d)" ,
217 p_block->i_buffer, SPU_HEADER_LEN );
218 block_Release( p_block );
222 p_buffer = p_block->p_buffer;
224 /* From the scant data on the format, there is only only way known
225 * to detect the first packet in a subtitle. The first packet
226 * seems to have a valid PTS while later packets for the same
228 if( p_sys->i_state == SUBTITLE_BLOCK_EMPTY && p_block->i_pts == 0 )
230 msg_Warn( p_dec, "first packet expected but no PTS present");
234 p_block->p_buffer += SPU_HEADER_LEN;
235 p_block->i_buffer -= SPU_HEADER_LEN;
237 /* First packet in the subtitle block */
238 if( p_sys->i_state == SUBTITLE_BLOCK_EMPTY ) ParseHeader( p_dec, p_block );
240 block_ChainAppend( &p_sys->p_spu, p_block );
241 p_sys->p_spu = block_ChainGather( p_sys->p_spu );
243 if( p_sys->p_spu->i_buffer >= p_sys->i_spu_size )
245 block_t *p_spu = p_sys->p_spu;
247 if( p_spu->i_buffer != p_sys->i_spu_size )
249 msg_Warn( p_dec, "SPU packets size=%d should be %d",
250 p_spu->i_buffer, p_sys->i_spu_size );
253 msg_Dbg( p_dec, "subtitle packet complete, size=%d", p_spu->i_buffer);
255 ParseMetaInfo( p_dec, p_spu );
257 p_sys->i_state = SUBTITLE_BLOCK_EMPTY;
263 /* Not last block in subtitle, so wait for another. */
264 p_sys->i_state = SUBTITLE_BLOCK_PARTIAL;
271 We do not have information on the subtitle format used on CVD's
272 except the submux sample code and a couple of samples of dubious
273 origin. Thus, this is the result of reading some code whose
274 correctness is not known and some experimentation.
276 CVD subtitles are different in several ways from SVCD OGT subtitles.
277 Image comes first and metadata is at the end. So that the metadata
278 can be found easily, the subtitle packet starts with two bytes
279 (everything is big-endian again) that give the total size of the
280 subtitle data and the offset to the metadata - i.e. size of the
281 image data plus the four bytes at the beginning.
283 Image data comes interlaced is run-length encoded. Each field is a
284 four-bit nibble. Each nibble contains a two-bit repeat count and a
285 two-bit color number so that up to three pixels can be described in
286 four bits. The function of a 0 repeat count is unknown; it might be
287 used for RLE extension. However when the full nibble is zero, the
288 rest of the line is filled with the color value in the next nibble.
289 It is unknown what happens if the color value is greater than three.
290 The rest seems to use a 4-entries palette. It is not impossible
291 that the fill-line complete case above is not as described and the
292 zero repeat count means fill line. The sample code never produces
293 this, so it may be untested.
296 static void ParseHeader( decoder_t *p_dec, block_t *p_block )
298 decoder_sys_t *p_sys = p_dec->p_sys;
299 uint8_t *p = p_block->p_buffer;
301 p_sys->i_spu_size = (p[0] << 8) + p[1] + 4; p += 2;
303 /* FIXME: check data sanity */
304 p_sys->metadata_offset = (p[0] << 8) + p[1]; p +=2;
305 p_sys->metadata_length = p_sys->i_spu_size - p_sys->metadata_offset;
307 p_sys->i_image_offset = 4;
308 p_sys->i_image_length = p_sys->metadata_offset - p_sys->i_image_offset;
311 msg_Dbg( p_dec, "total size: %d image size: %d",
312 p_sys->i_spu_size, p_sys->i_image_length );
317 We parse the metadata information here.
319 Although metadata information does not have to come in a fixed field
320 order, every metadata field consists of a tag byte followed by
321 parameters. In all cases known, the size including tag byte is
322 exactly four bytes in length.
325 #define ExtractXY(x, y) x = ((p[1]&0x0f)<<6) + (p[2]>>2); \
326 y = ((p[2]&0x03)<<8) + p[3];
328 static void ParseMetaInfo( decoder_t *p_dec, block_t *p_spu )
330 /* Last packet in subtitle block. */
332 decoder_sys_t *p_sys = p_dec->p_sys;
333 uint8_t *p = p_spu->p_buffer + p_sys->metadata_offset;
334 uint8_t *p_end = p + p_sys->metadata_length;
336 for( ; p < p_end; p += 4 )
340 case 0x04: /* subtitle duration in 1/90000ths of a second */
341 p_sys->i_duration = (p[1]<<16) + (p[2]<<8) + p[3];
344 msg_Dbg( p_dec, "subtitle display duration %lu secs",
345 (long unsigned int)(p_sys->i_duration / 90000) );
347 p_sys->i_duration *= 100 / 9;
350 case 0x0c: /* unknown */
352 msg_Dbg( p_dec, "subtitle command unknown 0x%0x 0x%0x 0x%0x 0x%0x",
353 (int)p[0], (int)p[1], (int)p[2], (int)p[3] );
357 case 0x17: /* coordinates of subtitle upper left x, y position */
358 ExtractXY(p_sys->i_x_start, p_sys->i_y_start);
361 msg_Dbg( p_dec, "start position (%d,%d)",
362 p_sys->i_x_start, p_sys->i_y_start );
366 case 0x1f: /* coordinates of subtitle bottom right x, y position */
370 ExtractXY(lastx, lasty);
371 p_sys->i_width = lastx - p_sys->i_x_start + 1;
372 p_sys->i_height = lasty - p_sys->i_y_start + 1;
375 msg_Dbg( p_dec, "end position (%d,%d), w x h: %dx%d",
376 lastx, lasty, p_sys->i_width, p_sys->i_height );
386 uint8_t v = p[0] - 0x24;
389 /* Primary Palette */
390 msg_Dbg( p_dec, "primary palette %d (y,u,v): (0x%0x,0x%0x,0x%0x)",
391 (int)v, (int)p[1], (int)p[2], (int)p[3] );
394 p_sys->p_palette[v][0] = p[1]; /* Y */
395 p_sys->p_palette[v][1] = p[3]; /* Cr / V */
396 p_sys->p_palette[v][2] = p[2]; /* Cb / U */
405 uint8_t v = p[0] - 0x2c;
408 msg_Dbg( p_dec,"highlight palette %d (y,u,v): (0x%0x,0x%0x,0x%0x)",
409 (int)v, (int)p[1], (int)p[2], (int)p[3] );
412 /* Highlight Palette */
413 p_sys->p_palette_highlight[v][0] = p[1]; /* Y */
414 p_sys->p_palette_highlight[v][1] = p[3]; /* Cr / V */
415 p_sys->p_palette_highlight[v][2] = p[2]; /* Cb / U */
420 /* transparency for primary palette */
421 p_sys->p_palette[0][3] = (p[3] & 0x0f) << 4;
422 p_sys->p_palette[1][3] = (p[3] >> 4) << 4;
423 p_sys->p_palette[2][3] = (p[2] & 0x0f) << 4;
424 p_sys->p_palette[3][3] = (p[2] >> 4) << 4;
427 msg_Dbg( p_dec, "transparency for primary palette 0..3: "
428 "0x%0x 0x%0x 0x%0x 0x%0x",
429 (int)p_sys->p_palette[0][3], (int)p_sys->p_palette[1][3],
430 (int)p_sys->p_palette[2][3], (int)p_sys->p_palette[3][3]);
435 /* transparency for highlight palette */
436 p_sys->p_palette_highlight[0][3] = (p[2] & 0x0f) << 4;
437 p_sys->p_palette_highlight[1][3] = (p[2] >> 4) << 4;
438 p_sys->p_palette_highlight[2][3] = (p[1] & 0x0f) << 4;
439 p_sys->p_palette_highlight[3][3] = (p[1] >> 4) << 4;
442 msg_Dbg( p_dec, "transparency for highlight palette 0..3: "
443 "0x%0x 0x%0x 0x%0x 0x%0x",
444 (int)p_sys->p_palette_highlight[0][3],
445 (int)p_sys->p_palette_highlight[1][3],
446 (int)p_sys->p_palette_highlight[2][3],
447 (int)p_sys->p_palette_highlight[3][3] );
452 /* offset to start of even rows of interlaced image, we correct
453 * to make it relative to i_image_offset (usually 4) */
454 p_sys->first_field_offset =
455 (p[2] << 8) + p[3] - p_sys->i_image_offset;
457 msg_Dbg( p_dec, "1st_field_offset %d", p_sys->first_field_offset );
462 /* offset to start of odd rows of interlaced image, we correct
463 * to make it relative to i_image_offset (usually 4) */
464 p_sys->second_field_offset =
465 (p[2] << 8) + p[3] - p_sys->i_image_offset;
467 msg_Dbg( p_dec, "2nd_field_offset %d", p_sys->second_field_offset);
473 msg_Warn( p_dec, "unknown sequence in control header "
474 "0x%0x 0x%0x 0x%0x 0x%0x", p[0], p[1], p[2], p[3]);
480 /*****************************************************************************
481 * DecodePacket: parse and decode an SPU packet
482 *****************************************************************************
483 * This function parses and decodes an SPU packet and, if valid, returns a
485 *****************************************************************************/
486 static subpicture_t *DecodePacket( decoder_t *p_dec, block_t *p_data )
488 decoder_sys_t *p_sys = p_dec->p_sys;
490 subpicture_region_t *p_region;
494 /* Allocate the subpicture internal data. */
495 p_spu = p_dec->pf_spu_buffer_new( p_dec );
496 if( !p_spu ) return NULL;
498 p_spu->b_pausable = VLC_TRUE;
500 p_spu->i_x = p_sys->i_x_start;
501 p_spu->i_x = p_spu->i_x * 3 / 4; /* FIXME: use aspect ratio for x? */
502 p_spu->i_y = p_sys->i_y_start;
503 p_spu->i_start = p_data->i_pts;
504 p_spu->i_stop = p_data->i_pts + p_sys->i_duration;
505 p_spu->b_ephemer = VLC_TRUE;
507 /* Create new SPU region */
508 memset( &fmt, 0, sizeof(video_format_t) );
509 fmt.i_chroma = VLC_FOURCC('Y','U','V','P');
510 fmt.i_aspect = VOUT_ASPECT_FACTOR;
511 fmt.i_width = fmt.i_visible_width = p_sys->i_width;
512 fmt.i_height = fmt.i_visible_height = p_sys->i_height;
513 fmt.i_x_offset = fmt.i_y_offset = 0;
514 p_region = p_spu->pf_create_region( VLC_OBJECT(p_dec), &fmt );
517 msg_Err( p_dec, "cannot allocate SPU region" );
521 p_spu->p_region = p_region;
522 p_region->i_x = p_region->i_y = 0;
525 fmt.p_palette->i_entries = 4;
526 for( i = 0; i < fmt.p_palette->i_entries; i++ )
528 fmt.p_palette->palette[i][0] = p_sys->p_palette[i][0];
529 fmt.p_palette->palette[i][1] = p_sys->p_palette[i][1];
530 fmt.p_palette->palette[i][2] = p_sys->p_palette[i][2];
531 fmt.p_palette->palette[i][3] = p_sys->p_palette[i][3];
534 RenderImage( p_dec, p_data, p_region );
539 /*****************************************************************************
540 * ParseImage: parse and render the image part of the subtitle
541 *****************************************************************************
542 This part parses the subtitle graphical data and renders it.
544 Image data comes interlaced and is run-length encoded (RLE). Each
545 field is a four-bit nibbles that is further subdivided in a two-bit
546 repeat count and a two-bit color number - up to three pixels can be
547 described in four bits. What a 0 repeat count means is unknown. It
548 might be used for RLE extension. There is a special case of a 0
549 repeat count though. When the full nibble is zero, the rest of the
550 line is filled with the color value in the next nibble. It is
551 unknown what happens if the color value is greater than three. The
552 rest seems to use a 4-entries palette. It is not impossible that the
553 fill-line complete case above is not as described and the zero repeat
554 count means fill line. The sample code never produces this, so it
557 However we'll transform this so that that the RLE is expanded and
558 interlacing will also be removed. On output each pixel entry will by
559 a 4-bit alpha (filling 8 bits), and 8-bit y, u, and v entry.
561 *****************************************************************************/
562 static void RenderImage( decoder_t *p_dec, block_t *p_data,
563 subpicture_region_t *p_region )
565 decoder_sys_t *p_sys = p_dec->p_sys;
566 uint8_t *p_dest = p_region->picture.Y_PIXELS;
567 int i_field; /* The subtitles are interlaced */
568 int i_row, i_column; /* scanline row/column number */
569 uint8_t i_color, i_count;
572 bs_init( &bs, p_data->p_buffer + p_sys->i_image_offset,
573 p_data->i_buffer - p_sys->i_image_offset );
575 for( i_field = 0; i_field < 2; i_field++ )
577 for( i_row = i_field; i_row < p_sys->i_height; i_row += 2 )
579 for( i_column = 0; i_column < p_sys->i_width; i_column++ )
581 uint8_t i_val = bs_read( &bs, 4 );
585 /* Fill the rest of the line with next color */
586 i_color = bs_read( &bs, 4 );
588 memset( &p_dest[i_row * p_region->picture.Y_PITCH +
590 p_sys->i_width - i_column );
591 i_column = p_sys->i_width;
596 /* Normal case: get color and repeat count */
597 i_count = (i_val >> 2);
598 i_color = i_val & 0x3;
600 i_count = __MIN( i_count, p_sys->i_width - i_column );
602 memset( &p_dest[i_row * p_region->picture.Y_PITCH +
603 i_column], i_color, i_count );
604 i_column += i_count - 1;