Changed subpicture_region_t->picture into a picture_t *
[vlc.git] / modules / codec / svcdsub.c
1 /*****************************************************************************
2  * svcdsub.c : Overlay Graphics Text (SVCD subtitles) decoder
3  *****************************************************************************
4  * Copyright (C) 2003, 2004 the VideoLAN team
5  * $Id$
6  *
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>
11  *
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.
16  *
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.
21  *
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  *****************************************************************************/
26
27 /*****************************************************************************
28  * Preamble
29  *****************************************************************************/
30 #ifdef HAVE_CONFIG_H
31 # include "config.h"
32 #endif
33
34 #include <vlc_common.h>
35 #include <vlc_plugin.h>
36 #include <vlc_codec.h>
37 #include <vlc_osd.h>
38 #include "vlc_bits.h"
39
40 /*****************************************************************************
41  * Module descriptor.
42  *****************************************************************************/
43 static int  DecoderOpen   ( vlc_object_t * );
44 static int  PacketizerOpen( vlc_object_t * );
45 static void DecoderClose  ( vlc_object_t * );
46
47 #define DEBUG_TEXT N_("Enable debug")
48
49 #define DEBUG_LONGTEXT  \
50     N_("This integer when viewed in binary is a debugging mask\n" \
51     "calls                 1\n" \
52     "packet assembly info  2\n" )
53
54 vlc_module_begin();
55     set_description( N_("Philips OGT (SVCD subtitle) decoder") );
56     set_shortname( N_("SVCD subtitles") );
57     set_category( CAT_INPUT );
58     set_subcategory( SUBCAT_INPUT_SCODEC );
59     set_capability( "decoder", 50 );
60     set_callbacks( DecoderOpen, DecoderClose );
61
62     add_integer ( MODULE_STRING "-debug", 0, NULL,
63                   DEBUG_TEXT, DEBUG_LONGTEXT, true );
64
65     add_submodule();
66     set_description( N_("Philips OGT (SVCD subtitle) packetizer") );
67     set_capability( "packetizer", 50 );
68     set_callbacks( PacketizerOpen, DecoderClose );
69 vlc_module_end();
70
71 /*****************************************************************************
72  * Local prototypes
73  *****************************************************************************/
74 static subpicture_t *Decode( decoder_t *, block_t ** );
75 static block_t *Packetize  ( decoder_t *, block_t ** );
76 static block_t *Reassemble ( decoder_t *, block_t * );
77 static void ParseHeader( decoder_t *, block_t * );
78 static subpicture_t *DecodePacket( decoder_t *, block_t * );
79 static void SVCDSubRenderImage( decoder_t *, block_t *, subpicture_region_t * );
80
81 #define DECODE_DBG_CALL        1 /* calls */
82 #define DECODE_DBG_PACKET      2 /* packet assembly info */
83
84 #define GETINT16(p) ( (p[0] <<  8) +   p[1] )  ; p +=2;
85
86 #define GETINT32(p) ( (p[0] << 24) +  (p[1] << 16) +    \
87                       (p[2] <<  8) +  (p[3]) ) ; p += 4;
88
89 typedef enum  {
90   SUBTITLE_BLOCK_EMPTY    = 0,
91   SUBTITLE_BLOCK_PARTIAL  = 1,
92   SUBTITLE_BLOCK_COMPLETE = 2
93 } packet_state_t;
94
95 #ifndef DECODE_DEBUG
96 #define DECODE_DEBUG 1
97 #endif
98 #if DECODE_DEBUG
99 #define dbg_print(mask, s, args...) \
100    if (p_sys && p_sys->i_debug & mask) \
101      msg_Dbg(p_dec, "%s: "s, __func__ , ##args)
102 #else
103 #define dbg_print(mask, s, args...)
104 #endif
105
106 struct decoder_sys_t
107 {
108   int      i_debug;       /* debugging mask */
109
110   packet_state_t i_state; /* data-gathering state for this subtitle */
111
112   block_t  *p_spu;        /* Bytes of the packet. */
113
114   uint16_t i_image;       /* image number in the subtitle stream */
115   uint8_t  i_packet;      /* packet number for above image number */
116
117   size_t   i_spu_size;     /* goal for subtitle_data_pos while gathering,
118                              size of used subtitle_data later */
119
120   uint16_t i_image_offset;      /* offset from subtitle_data to compressed
121                                    image data */
122   size_t i_image_length;           /* size of the compressed image data */
123   size_t second_field_offset;      /* offset of odd raster lines */
124   size_t metadata_offset;          /* offset to data describing the image */
125   size_t metadata_length;          /* length of metadata */
126
127   mtime_t i_duration;   /* how long to display the image, 0 stands
128                            for "until next subtitle" */
129
130   uint16_t i_x_start, i_y_start; /* position of top leftmost pixel of
131                                     image when displayed */
132   uint16_t i_width, i_height;    /* dimensions in pixels of image */
133
134   uint8_t p_palette[4][4];       /* Palette of colors used in subtitle */
135 };
136
137 /*****************************************************************************
138  * DecoderOpen: open/initialize the svcdsub decoder.
139  *****************************************************************************/
140 static int DecoderOpen( vlc_object_t *p_this )
141 {
142     decoder_t     *p_dec = (decoder_t*)p_this;
143     decoder_sys_t *p_sys;
144
145     if( p_dec->fmt_in.i_codec != VLC_FOURCC( 'o','g','t',' ' ) )
146     {
147         return VLC_EGENERIC;
148     }
149
150     p_dec->p_sys = p_sys = calloc( 1, sizeof( decoder_sys_t ) );
151     if( p_sys == NULL )
152         return VLC_ENOMEM;
153
154     p_sys->i_debug       = config_GetInt( p_this, MODULE_STRING "-debug" );
155
156     p_sys->i_image       = -1;
157
158     p_sys->i_state = SUBTITLE_BLOCK_EMPTY;
159     p_sys->p_spu   = NULL;
160
161     es_format_Init( &p_dec->fmt_out, SPU_ES, VLC_FOURCC( 'o','g','t',' ' ) );
162
163     p_dec->pf_decode_sub = Decode;
164     p_dec->pf_packetize  = Packetize;
165
166     dbg_print( (DECODE_DBG_CALL) , "");
167     return VLC_SUCCESS;
168 }
169
170 /*****************************************************************************
171  * PacketizerOpen: open/initialize the svcdsub packetizer.
172  *****************************************************************************/
173 static int PacketizerOpen( vlc_object_t *p_this )
174 {
175     if( DecoderOpen( p_this ) != VLC_SUCCESS ) return VLC_EGENERIC;
176
177     return VLC_SUCCESS;
178 }
179
180 /*****************************************************************************
181  * DecoderClose: closes the svcdsub decoder/packetizer.
182  *****************************************************************************/
183 void DecoderClose( vlc_object_t *p_this )
184 {
185     decoder_t     *p_dec = (decoder_t*)p_this;
186     decoder_sys_t *p_sys = p_dec->p_sys;
187
188     if( p_sys->p_spu ) block_ChainRelease( p_sys->p_spu );
189     free( p_sys );
190 }
191
192 /*****************************************************************************
193  * Decode:
194  *****************************************************************************/
195 static subpicture_t *Decode( decoder_t *p_dec, block_t **pp_block )
196 {
197     block_t *p_block, *p_spu;
198     decoder_sys_t *p_sys = p_dec->p_sys;
199
200     dbg_print( (DECODE_DBG_CALL) , "");
201
202     if( pp_block == NULL || *pp_block == NULL ) return NULL;
203
204     p_block = *pp_block;
205     *pp_block = NULL;
206
207     if( !(p_spu = Reassemble( p_dec, p_block )) ) return NULL;
208
209     /* Parse and decode */
210     return DecodePacket( p_dec, p_spu );
211 }
212
213 /*****************************************************************************
214  * Packetize:
215  *****************************************************************************/
216 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
217 {
218     block_t *p_block, *p_spu;
219
220     if( pp_block == NULL || *pp_block == NULL ) return NULL;
221
222     p_block = *pp_block;
223     *pp_block = NULL;
224
225     if( !(p_spu = Reassemble( p_dec, p_block )) ) return NULL;
226
227     p_spu->i_dts = p_spu->i_pts;
228     p_spu->i_length = 0;
229
230     return p_spu;
231 }
232
233 /*****************************************************************************
234  Reassemble:
235
236  The data for single screen subtitle may come in one of many
237  non-contiguous packets of a stream. This routine is called when the
238  next packet in the stream comes in. The job of this routine is to
239  parse the header, if this is the beginning, and combine the packets
240  into one complete subtitle unit.
241
242  If everything is complete, we will return a block. Otherwise return
243  NULL.
244
245
246  The format of the beginning of the subtitle packet that is used here.
247
248    size    description
249    -------------------------------------------
250    byte    subtitle channel (0..7) in bits 0-3
251    byte    subtitle packet number of this subtitle image 0-N,
252            if the subtitle packet is complete, the top bit of the byte is 1.
253    uint16  subtitle image number
254
255  *****************************************************************************/
256 #define SPU_HEADER_LEN 5
257
258 static block_t *Reassemble( decoder_t *p_dec, block_t *p_block )
259 {
260     decoder_sys_t *p_sys = p_dec->p_sys;
261     uint8_t *p_buffer;
262     uint16_t i_expected_image;
263     uint8_t  i_packet, i_expected_packet;
264
265     if( p_block->i_buffer < SPU_HEADER_LEN )
266     {
267         msg_Dbg( p_dec, "invalid packet header (size %zu < %u)" ,
268                  p_block->i_buffer, SPU_HEADER_LEN );
269         block_Release( p_block );
270         return NULL;
271     }
272
273     p_buffer = p_block->p_buffer;
274
275     /* Attach to our input thread and see if subtitle is selected. */
276     {
277         vlc_object_t * p_input;
278         vlc_value_t val;
279
280         p_input = vlc_object_find( p_dec, VLC_OBJECT_INPUT, FIND_PARENT );
281
282         if( !p_input ) return NULL;
283
284         if( var_Get( p_input, "sub-track", &val ) )
285         {
286             vlc_object_release( p_input );
287             return NULL;
288         }
289
290         vlc_object_release( p_input );
291         dbg_print( (DECODE_DBG_PACKET),
292                    "val.i_int %x p_buffer[i] %x", val.i_int, p_buffer[1]);
293
294         /* The dummy ES that the menu selection uses has an 0x70 at
295            the head which we need to strip off. */
296         if( val.i_int == -1 || (val.i_int & 0x03) != p_buffer[1] )
297         {
298             dbg_print( DECODE_DBG_PACKET, "subtitle not for us.\n");
299             return NULL;
300         }
301     }
302
303     if( p_sys->i_state == SUBTITLE_BLOCK_EMPTY )
304     {
305         i_expected_image  = p_sys->i_image + 1;
306         i_expected_packet = 0;
307     }
308     else
309     {
310         i_expected_image  = p_sys->i_image;
311         i_expected_packet = p_sys->i_packet + 1;
312     }
313
314     p_buffer += 2;
315
316     if( *p_buffer & 0x80 )
317     {
318         p_sys->i_state = SUBTITLE_BLOCK_COMPLETE;
319         i_packet       = *p_buffer++ & 0x7F;
320     }
321     else
322     {
323         p_sys->i_state = SUBTITLE_BLOCK_PARTIAL;
324         i_packet       = *p_buffer++;
325     }
326
327     p_sys->i_image = GETINT16(p_buffer);
328
329     if( p_sys->i_image != i_expected_image )
330     {
331         msg_Warn( p_dec, "expected subtitle image %u but found %u",
332                   i_expected_image, p_sys->i_image );
333     }
334
335     if( i_packet != i_expected_packet )
336     {
337         msg_Warn( p_dec, "expected subtitle image packet %u but found %u",
338                   i_expected_packet, i_packet );
339     }
340
341     p_block->p_buffer += SPU_HEADER_LEN;
342     p_block->i_buffer -= SPU_HEADER_LEN;
343
344     p_sys->i_packet = i_packet;
345     /* First packet in the subtitle block */
346     if( !p_sys->i_packet ) ParseHeader( p_dec, p_block );
347
348     block_ChainAppend( &p_sys->p_spu, p_block );
349
350     if( p_sys->i_state == SUBTITLE_BLOCK_COMPLETE )
351     {
352         block_t *p_spu = block_ChainGather( p_sys->p_spu );
353
354         if( p_spu->i_buffer != p_sys->i_spu_size )
355         {
356             msg_Warn( p_dec, "subtitle packets size=%zu should be %zu",
357                       p_spu->i_buffer, p_sys->i_spu_size );
358         }
359
360     dbg_print( (DECODE_DBG_PACKET),
361                  "subtitle packet complete, size=%zu", p_spu->i_buffer );
362
363         p_sys->i_state = SUBTITLE_BLOCK_EMPTY;
364         p_sys->p_spu = 0;
365         return p_spu;
366     }
367
368     return NULL;
369 }
370
371 /******************************************************************************
372   The format is roughly as follows (everything is big-endian):
373  
374    size     description
375    -------------------------------------------
376    byte     subtitle channel (0..7) in bits 0-3
377    byte     subtitle packet number of this subtitle image 0-N,
378             if the subtitle packet is complete, the top bit of the byte is 1.
379    u_int16  subtitle image number
380    u_int16  length in bytes of the rest
381    byte     option flags, unknown meaning except bit 3 (0x08) indicates
382             presence of the duration field
383    byte     unknown
384    u_int32  duration in 1/90000ths of a second (optional), start time
385             is as indicated by the PTS in the PES header
386    u_int32  xpos
387    u_int32  ypos
388    u_int32  width (must be even)
389    u_int32  height (must be even)
390    byte[16] palette, 4 palette entries, each contains values for
391             Y, U, V and transparency, 0 standing for transparent
392    byte     command,
393             cmd>>6==1 indicates shift
394             (cmd>>4)&3 is direction from, (0=top,1=left,2=right,3=bottom)
395    u_int32  shift duration in 1/90000ths of a second
396    u_int16  offset of odd-numbered scanlines - subtitle images are
397             given in interlace order
398    byte[]   limited RLE image data in interlace order (0,2,4... 1,3,5) with
399             2-bits per palette number
400 ******************************************************************************/
401 static void ParseHeader( decoder_t *p_dec, block_t *p_block )
402 {
403     decoder_sys_t *p_sys = p_dec->p_sys;
404     uint8_t *p = p_block->p_buffer;
405     uint8_t i_options, i_options2, i_cmd, i_cmd_arg;
406     int i;
407
408     p_sys->i_spu_size = GETINT16(p);
409     i_options  = *p++;
410     i_options2 = *p++;
411
412     if( i_options & 0x08 ) { p_sys->i_duration = GETINT32(p); }
413     else p_sys->i_duration = 0; /* Ephemer subtitle */
414     p_sys->i_duration *= 100 / 9;
415
416     p_sys->i_x_start = GETINT16(p);
417     p_sys->i_y_start = GETINT16(p);
418     p_sys->i_width   = GETINT16(p);
419     p_sys->i_height  = GETINT16(p);
420
421     for( i = 0; i < 4; i++ )
422     {
423         p_sys->p_palette[i][0] = *p++; /* Y */
424         p_sys->p_palette[i][2] = *p++; /* Cr / V */
425         p_sys->p_palette[i][1] = *p++; /* Cb / U */
426         p_sys->p_palette[i][3] = *p++; /* T */
427     }
428
429     i_cmd = *p++;
430     /* We do not really know this, FIXME */
431     if( i_cmd ) {i_cmd_arg = GETINT32(p);}
432
433     /* Actually, this is measured against a different origin, so we have to
434      * adjust it */
435     p_sys->second_field_offset = GETINT16(p);
436     p_sys->i_image_offset  = p - p_block->p_buffer;
437     p_sys->i_image_length  = p_sys->i_spu_size - p_sys->i_image_offset;
438     p_sys->metadata_length = p_sys->i_image_offset;
439
440   if (p_sys && p_sys->i_debug & DECODE_DBG_PACKET)
441   {
442       msg_Dbg( p_dec, "x-start: %d, y-start: %d, width: %d, height %d, "
443            "spu size: %zu, duration: %"PRIu64" (d:%zu p:%"PRIu16")",
444            p_sys->i_x_start, p_sys->i_y_start,
445            p_sys->i_width, p_sys->i_height,
446            p_sys->i_spu_size, p_sys->i_duration,
447            p_sys->i_image_length, p_sys->i_image_offset);
448  
449       for( i = 0; i < 4; i++ )
450       {
451           msg_Dbg( p_dec, "palette[%d]= T: %2x, Y: %2x, u: %2x, v: %2x", i,
452            p_sys->p_palette[i][3], p_sys->p_palette[i][0],
453            p_sys->p_palette[i][1], p_sys->p_palette[i][2] );
454       }
455   }
456 }
457
458 /*****************************************************************************
459  * DecodePacket: parse and decode an subtitle packet
460  *****************************************************************************
461  * This function parses and decodes an SPU packet and, if valid, returns a
462  * subpicture.
463  *****************************************************************************/
464 static subpicture_t *DecodePacket( decoder_t *p_dec, block_t *p_data )
465 {
466     decoder_sys_t *p_sys = p_dec->p_sys;
467     subpicture_t  *p_spu;
468     subpicture_region_t *p_region;
469     video_format_t fmt;
470     int i;
471
472     /* Allocate the subpicture internal data. */
473     p_spu = p_dec->pf_spu_buffer_new( p_dec );
474     if( !p_spu ) return NULL;
475
476     p_spu->i_start = p_data->i_pts;
477     p_spu->i_stop  = p_data->i_pts + p_sys->i_duration;
478     p_spu->b_ephemer = true;
479
480     /* Create new subtitle region */
481     memset( &fmt, 0, sizeof(video_format_t) );
482     fmt.i_chroma = VLC_FOURCC('Y','U','V','P');
483
484     /**
485        The video on which the subtitle sits, is scaled, probably
486        4:3. However subtitle bitmaps assume an 1:1 aspect ratio.
487
488        FIXME: We should get the video aspect ratio from somewhere.
489        Two candidates are the video and the other possibility would be
490        the access module.
491     */
492     fmt.i_aspect = VOUT_ASPECT_FACTOR;
493
494     fmt.i_width = fmt.i_visible_width = p_sys->i_width;
495     fmt.i_height = fmt.i_visible_height = p_sys->i_height;
496     fmt.i_x_offset = fmt.i_y_offset = 0;
497     p_region = p_spu->pf_create_region( VLC_OBJECT(p_dec), &fmt );
498     if( !p_region )
499     {
500         msg_Err( p_dec, "cannot allocate SVCD subtitle region" );
501         //goto error;
502     }
503
504     p_region->fmt.i_aspect = VOUT_ASPECT_FACTOR;
505  
506     p_spu->p_region = p_region;
507     p_region->i_x = p_sys->i_x_start;
508     p_region->i_y = p_sys->i_y_start;
509
510     /* Build palette */
511     fmt.p_palette->i_entries = 4;
512     for( i = 0; i < fmt.p_palette->i_entries; i++ )
513     {
514         fmt.p_palette->palette[i][0] = p_sys->p_palette[i][0];
515         fmt.p_palette->palette[i][1] = p_sys->p_palette[i][1];
516         fmt.p_palette->palette[i][2] = p_sys->p_palette[i][2];
517         fmt.p_palette->palette[i][3] = p_sys->p_palette[i][3];
518     }
519
520     SVCDSubRenderImage( p_dec, p_data, p_region );
521
522     return p_spu;
523 }
524
525 /*****************************************************************************
526  * SVCDSubRenderImage: reorders bytes of image data in subpicture region.
527  *****************************************************************************
528
529  The image is encoded using two bits per pixel that select a palette
530  entry except that value 0 starts a limited run-length encoding for
531  color 0.  When 0 is seen, the next two bits encode one less than the
532  number of pixels, so we can encode run lengths from 1 to 4. These get
533  filled with the color in palette entry 0.
534
535  The encoding of each line is padded to a whole number of bytes.  The
536  first field is padded to an even byte length and the complete subtitle
537  is padded to a 4-byte multiple that always include one zero byte at
538  the end.
539
540  However we'll transform this so that that the RLE is expanded and
541  interlacing will also be removed.
542  *****************************************************************************/
543 static void SVCDSubRenderImage( decoder_t *p_dec, block_t *p_data,
544                 subpicture_region_t *p_region )
545 {
546     decoder_sys_t *p_sys = p_dec->p_sys;
547     uint8_t *p_dest = p_region->p_picture->Y_PIXELS;
548     int i_field;            /* The subtitles are interlaced */
549     int i_row, i_column;    /* scanline row/column number */
550     uint8_t i_color, i_count;
551     bs_t bs;
552
553     bs_init( &bs, p_data->p_buffer + p_sys->i_image_offset,
554              p_data->i_buffer - p_sys->i_image_offset );
555
556     for( i_field = 0; i_field < 2; i_field++ )
557     {
558         for( i_row = i_field; i_row < p_sys->i_height; i_row += 2 )
559         {
560             for( i_column = 0; i_column < p_sys->i_width; i_column++ )
561             {
562                 i_color = bs_read( &bs, 2 );
563                 if( i_color == 0 && (i_count = bs_read( &bs, 2 )) )
564                 {
565                     i_count = __MIN( i_count, p_sys->i_width - i_column );
566                     memset( &p_dest[i_row * p_region->p_picture->Y_PITCH +
567                                     i_column], 0, i_count + 1 );
568                     i_column += i_count;
569                     continue;
570                 }
571
572                 p_dest[i_row * p_region->p_picture->Y_PITCH + i_column] = i_color;
573             }
574
575             bs_align( &bs );
576         }
577
578         /* odd field */
579         bs_init( &bs, p_data->p_buffer + p_sys->i_image_offset +
580                  p_sys->second_field_offset,
581                  p_data->i_buffer - p_sys->i_image_offset -
582                  p_sys->second_field_offset );
583     }
584 }