Renamed playlist "playlist-current" to "item-current".
[vlc.git] / modules / packetizer / mlp.c
1 /*****************************************************************************
2  * mlp.c: packetize MLP/TrueHD audio
3  *****************************************************************************
4  * Copyright (C) 2008 Laurent Aimar
5  * $Id$
6  *
7  * Authors: Laurent Aimar < fenrir _AT videolan _DOT_ org >
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #ifdef HAVE_CONFIG_H
28 # include "config.h"
29 #endif
30
31 #include <vlc_common.h>
32 #include <vlc_plugin.h>
33 #include <vlc_codec.h>
34 #include <vlc_aout.h>
35 #include <vlc_block_helper.h>
36 #include <vlc_bits.h>
37 #include <assert.h>
38
39 /*****************************************************************************
40  * Module descriptor
41  *****************************************************************************/
42 static int  Open ( vlc_object_t * );
43 static void Close( vlc_object_t * );
44
45 vlc_module_begin ()
46     set_category( CAT_SOUT )
47     set_subcategory( SUBCAT_SOUT_PACKETIZER )
48     set_description( N_("MLP/TrueHD parser") )
49     set_capability( "packetizer", 50 )
50     set_callbacks( Open, Close )
51 vlc_module_end ()
52
53 /*****************************************************************************
54  *
55  *****************************************************************************/
56 typedef struct
57 {
58     int i_type;
59     int i_rate;
60     int i_channels;
61     int i_channels_conf;
62     int i_samples;
63
64     bool b_vbr;
65     int  i_bitrate;
66
67     int  i_substreams;
68
69 } mlp_header_t;
70
71 struct decoder_sys_t
72 {
73     /*
74      * Input properties
75      */
76     int i_state;
77
78     block_bytestream_t bytestream;
79
80     /*
81      * Common properties
82      */
83     audio_date_t   end_date;
84
85     mtime_t i_pts;
86     int i_frame_size;
87
88     bool         b_mlp;
89     mlp_header_t mlp;
90 };
91
92 enum {
93
94     STATE_NOSYNC,
95     STATE_SYNC,
96     STATE_HEADER,
97     STATE_NEXT_SYNC,
98     STATE_GET_DATA,
99     STATE_SEND_DATA
100 };
101
102 #define MLP_MAX_SUBSTREAMS (16)
103 #define MLP_HEADER_SYNC (28)
104 #define MLP_HEADER_SIZE (4 + MLP_HEADER_SYNC + 4 * MLP_MAX_SUBSTREAMS)
105
106 static const uint8_t pu_start_code[3] = { 0xf8, 0x72, 0x6f };
107
108 /****************************************************************************
109  * Local prototypes
110  ****************************************************************************/
111 static block_t *Packetize( decoder_t *, block_t **pp_block );
112 static int SyncInfo( const uint8_t *p_hdr, bool *pb_mlp, mlp_header_t *p_mlp );
113 static int SyncInfoDolby( const uint8_t *p_buf );
114
115 /*****************************************************************************
116  * Open: probe the decoder/packetizer and return score
117  *****************************************************************************/
118 static int Open( vlc_object_t *p_this )
119 {
120     decoder_t *p_dec = (decoder_t*)p_this;
121     decoder_sys_t *p_sys;
122
123     if( p_dec->fmt_in.i_codec != VLC_FOURCC('m','l','p',' ') )
124         return VLC_EGENERIC;
125
126     /* */
127     p_dec->p_sys = p_sys = malloc( sizeof(*p_sys) );
128     if( !p_sys )
129         return VLC_ENOMEM;
130
131     /* */
132     p_sys->i_state = STATE_NOSYNC;
133     aout_DateSet( &p_sys->end_date, 0 );
134
135     p_sys->bytestream = block_BytestreamInit();
136     p_sys->b_mlp = false;
137
138     /* Set output properties */
139     p_dec->fmt_out.i_cat = AUDIO_ES;
140     p_dec->fmt_out.i_codec = VLC_FOURCC('m','l','p',' ');
141     p_dec->fmt_out.audio.i_rate = 0;
142
143     /* Set callback */
144     p_dec->pf_packetize = Packetize;
145     return VLC_SUCCESS;
146 }
147
148 /****************************************************************************
149  * Packetize:
150  ****************************************************************************/
151 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
152 {
153     decoder_sys_t *p_sys = p_dec->p_sys;
154     uint8_t p_header[MLP_HEADER_SIZE];
155     block_t *p_out_buffer;
156
157     /* */
158     if( !pp_block || !*pp_block )
159         return NULL;
160
161     /* */
162     if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
163     {
164         if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
165         {
166             p_sys->b_mlp = false;
167             p_sys->i_state = STATE_NOSYNC;
168             block_BytestreamEmpty( &p_sys->bytestream );
169         }
170         aout_DateSet( &p_sys->end_date, 0 );
171         block_Release( *pp_block );
172         return NULL;
173     }
174
175     if( !aout_DateGet( &p_sys->end_date ) && !(*pp_block)->i_pts )
176     {
177         /* We've just started the stream, wait for the first PTS. */
178         block_Release( *pp_block );
179         return NULL;
180     }
181
182     block_BytestreamPush( &p_sys->bytestream, *pp_block );
183
184     for( ;; )
185     {
186         switch( p_sys->i_state )
187         {
188         case STATE_NOSYNC:
189             while( !block_PeekBytes( &p_sys->bytestream, p_header, MLP_HEADER_SIZE ) )
190             {
191                 if( SyncInfo( p_header, &p_sys->b_mlp, &p_sys->mlp ) > 0 )
192                 {
193                     p_sys->i_state = STATE_SYNC;
194                     break;
195                 }
196                 else if( SyncInfoDolby( p_header ) > 0 )
197                 {
198                     p_sys->i_state = STATE_SYNC;
199                     break;
200                 }
201                 block_SkipByte( &p_sys->bytestream );
202             }
203             if( p_sys->i_state != STATE_SYNC )
204             {
205                 block_BytestreamFlush( &p_sys->bytestream );
206
207                 /* Need more data */
208                 return NULL;
209             }
210
211         case STATE_SYNC:
212             /* New frame, set the Presentation Time Stamp */
213             p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
214             if( p_sys->i_pts != 0 &&
215                 p_sys->i_pts != aout_DateGet( &p_sys->end_date ) )
216             {
217                 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
218             }
219             p_sys->i_state = STATE_HEADER;
220
221         case STATE_HEADER:
222             /* Get a MLP header */
223             if( block_PeekBytes( &p_sys->bytestream, p_header, MLP_HEADER_SIZE ) )
224             {
225                 /* Need more data */
226                 return NULL;
227             }
228
229             /* Check if frame is valid and get frame info */
230             p_sys->i_frame_size = SyncInfoDolby( p_header );
231             if( p_sys->i_frame_size <= 0 )
232                 p_sys->i_frame_size = SyncInfo( p_header, &p_sys->b_mlp, &p_sys->mlp );
233             if( p_sys->i_frame_size <= 0 )
234             {
235                 msg_Dbg( p_dec, "emulated sync word" );
236                 block_SkipByte( &p_sys->bytestream );
237                 p_sys->b_mlp = false;
238                 p_sys->i_state = STATE_NOSYNC;
239                 break;
240             }
241             p_sys->i_state = STATE_NEXT_SYNC;
242
243         case STATE_NEXT_SYNC:
244             /* TODO: If pp_block == NULL, flush the buffer without checking the
245              * next sync word */
246
247             /* Check if next expected frame contains the sync word */
248             if( block_PeekOffsetBytes( &p_sys->bytestream,
249                                        p_sys->i_frame_size, p_header, MLP_HEADER_SIZE ) )
250             {
251                 /* Need more data */
252                 return NULL;
253             }
254
255             bool b_mlp = p_sys->b_mlp;
256             mlp_header_t mlp = p_sys->mlp;
257             if( SyncInfo( p_header, &b_mlp, &mlp ) <= 0 && SyncInfoDolby( p_header ) <= 0 )
258             {
259                 msg_Dbg( p_dec, "emulated sync word "
260                          "(no sync on following frame)" );
261                 p_sys->b_mlp = false;
262                 p_sys->i_state = STATE_NOSYNC;
263                 block_SkipByte( &p_sys->bytestream );
264                 break;
265             }
266             p_sys->i_state = STATE_SEND_DATA;
267             break;
268
269         case STATE_GET_DATA:
270             /* Make sure we have enough data.
271              * (Not useful if we went through NEXT_SYNC) */
272             if( block_WaitBytes( &p_sys->bytestream, p_sys->i_frame_size ) )
273             {
274                 /* Need more data */
275                 return NULL;
276             }
277             p_sys->i_state = STATE_SEND_DATA;
278
279         case STATE_SEND_DATA:
280             /* When we reach this point we already know we have enough
281              * data available. */
282             p_out_buffer = block_New( p_dec, p_sys->i_frame_size );
283             if( !p_out_buffer )
284                 return NULL;
285
286             /* Copy the whole frame into the buffer */
287             block_GetBytes( &p_sys->bytestream,
288                             p_out_buffer->p_buffer, p_out_buffer->i_buffer );
289
290             /* Just ignore (E)AC3 frames */
291             if( SyncInfoDolby( p_out_buffer->p_buffer ) > 0 )
292             {
293                 block_Release( p_out_buffer );
294                 p_sys->i_state = STATE_NOSYNC;
295                 break;
296             }
297
298             /* Setup output */
299             if( p_dec->fmt_out.audio.i_rate != p_sys->mlp.i_rate )
300             {
301                 msg_Info( p_dec, "MLP channels: %d samplerate: %d",
302                           p_sys->mlp.i_channels, p_sys->mlp.i_rate );
303
304                 aout_DateInit( &p_sys->end_date, p_sys->mlp.i_rate );
305                 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
306             }
307
308             p_dec->fmt_out.audio.i_rate     = p_sys->mlp.i_rate;
309             p_dec->fmt_out.audio.i_channels = p_sys->mlp.i_channels;
310             p_dec->fmt_out.audio.i_original_channels = p_sys->mlp.i_channels_conf;
311             p_dec->fmt_out.audio.i_physical_channels = p_sys->mlp.i_channels_conf & AOUT_CHAN_PHYSMASK;
312
313             p_out_buffer->i_pts = p_out_buffer->i_dts = aout_DateGet( &p_sys->end_date );
314
315             p_out_buffer->i_length =
316                 aout_DateIncrement( &p_sys->end_date, p_sys->mlp.i_samples ) - p_out_buffer->i_pts;
317
318             /* Make sure we don't reuse the same pts twice */
319             if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
320                 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = 0;
321
322             /* So p_block doesn't get re-added several times */
323             *pp_block = block_BytestreamPop( &p_sys->bytestream );
324
325             p_sys->i_state = STATE_NOSYNC;
326
327             return p_out_buffer;
328         }
329     }
330
331     return NULL;
332 }
333
334 /*****************************************************************************
335  * Close:
336  *****************************************************************************/
337 static void Close( vlc_object_t *p_this )
338 {
339     decoder_t *p_dec = (decoder_t*)p_this;
340     decoder_sys_t *p_sys = p_dec->p_sys;
341
342     block_BytestreamRelease( &p_sys->bytestream );
343
344     free( p_sys );
345 }
346
347 /**
348  * It parse MLP sync info.
349  *
350  * TODO handle CRC (at offset 26)
351   */
352
353 static int TrueHdChannels( int i_map )
354 {
355     static const uint8_t pu_thd[13] =
356     {
357          2, 1, 1, 2, 2, 2, 2, 1, 1, 2, 2, 1, 1
358     };
359     int i_count = 0;
360
361     for( int i = 0; i < 13; i++ )
362     {
363         if( i_map & (1<<i) )
364             i_count += pu_thd[i];
365     }
366     return i_count;
367 }
368
369 static int MlpParse( mlp_header_t *p_mlp, const uint8_t p_hdr[MLP_HEADER_SYNC] )
370 {
371     bs_t s;
372
373     assert( !memcmp( p_hdr, pu_start_code, 3 ) );
374
375     /* TODO Checksum ? */
376
377     /* */
378     bs_init( &s, &p_hdr[3], MLP_HEADER_SYNC - 3 );
379
380     /* Stream type */
381     p_mlp->i_type = bs_read( &s, 8 );
382     int i_rate_idx1;
383
384     if( p_mlp->i_type == 0xbb )        /* MLP */
385     {
386         static const unsigned pu_channels[32] = {
387             1, 2, 3, 4, 3, 4, 5, 3, 4, 5, 4, 5, 6, 4, 5, 4,
388             5, 6, 5, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
389         };
390
391         bs_skip( &s, 4 + 4 );
392
393         i_rate_idx1 = bs_read( &s, 4 );
394         const int i_rate_idx2 = bs_read( &s, 4 );
395
396         bs_skip( &s, 11 );
397
398         const int i_channel_idx = bs_read( &s, 5 );
399         p_mlp->i_channels = pu_channels[i_channel_idx];
400     }
401     else if( p_mlp->i_type == 0xba )   /* True HD */
402     {
403         i_rate_idx1 = bs_read( &s, 4 );
404
405         bs_skip( &s, 8 );
406
407         const int i_channel1 = bs_read( &s, 5 );
408
409         bs_skip( &s, 2 );
410
411         const int i_channel2 = bs_read( &s, 13 );
412         if( i_channel2 )
413             p_mlp->i_channels = TrueHdChannels( i_channel2 );
414         else
415             p_mlp->i_channels = TrueHdChannels( i_channel1 );
416     }
417     else
418     {
419         return VLC_EGENERIC;
420     }
421
422     if( i_rate_idx1 == 0x0f )
423         p_mlp->i_rate = 0;
424     else
425         p_mlp->i_rate = ( ( i_rate_idx1 & 0x8 ) ? 44100 : 48000 ) << (i_rate_idx1 & 0x7);
426     p_mlp->i_channels_conf = 0; /* TODO ? */
427
428     p_mlp->i_samples = 40 << ( i_rate_idx1 & 0x07 );
429
430     bs_skip( &s, 48 );
431
432     p_mlp->b_vbr = bs_read( &s, 1 );
433     p_mlp->i_bitrate = ( bs_read( &s, 15 ) * p_mlp->i_rate + 8) / 16;
434
435     p_mlp->i_substreams = bs_read( &s, 4 );
436     bs_skip( &s, 4 + 11 * 8 );
437
438     //fprintf( stderr, "i_samples = %d channels:%d rate:%d bitsrate=%d substreams=%d\n",
439     //        p_mlp->i_samples, p_mlp->i_channels, p_mlp->i_rate, p_mlp->i_bitrate, p_mlp->i_substreams );
440     return VLC_SUCCESS;
441 }
442
443 static int SyncInfo( const uint8_t *p_hdr, bool *pb_mlp, mlp_header_t *p_mlp )
444 {
445     /* Check major sync presence */
446     const bool b_has_sync = !memcmp( &p_hdr[4], pu_start_code, 3 );
447
448     /* Wait for a major sync */
449     if( !b_has_sync && !*pb_mlp )
450         return 0;
451
452     /* Parse major sync if present */
453     if( b_has_sync )
454     {
455         *pb_mlp = !MlpParse( p_mlp, &p_hdr[4] );
456
457         if( !*pb_mlp )
458             return 0;
459     }
460
461     /* Check parity TODO even with major sync */
462     if( 1 )
463     {
464         int i_tmp = 0 ^ p_hdr[0] ^ p_hdr[1] ^ p_hdr[2] ^ p_hdr[3];
465         const uint8_t *p = &p_hdr[4 + ( b_has_sync ? 28 : 0 )];
466
467         for( int i = 0; i < p_mlp->i_substreams; i++ )
468         {
469             i_tmp ^= *p++;
470             i_tmp ^= *p++;
471             if( p[-2] & 0x80 )
472             {
473                 i_tmp ^= *p++;
474                 i_tmp ^= *p++;
475             }
476         }
477         i_tmp = ( i_tmp >> 4 ) ^ i_tmp;
478
479         if( ( i_tmp & 0x0f ) != 0x0f )
480             return 0;
481     }
482
483     /* */
484     const int i_word = ( ( p_hdr[0] << 8 ) | p_hdr[1] ) & 0xfff;
485     return i_word * 2;
486 }
487
488 /**
489  * It returns the size of an AC3 frame (or 0 if invalid)
490  */
491 static int GetAc3Size( const uint8_t *p_buf )
492 {
493     static const int pi_rate[] = { 32,  40,  48,  56,  64,  80,  96, 112,
494                                 128, 160, 192, 224, 256, 320, 384, 448,
495                                 512, 576, 640 };
496     /* */
497     const int i_frmsizecod = p_buf[4] & 63;
498     if( i_frmsizecod >= 38 )
499         return 0;
500
501     const int bitrate = pi_rate[i_frmsizecod >> 1];
502
503     switch( p_buf[4] & 0xc0 )
504     {
505     case 0:
506         return 4 * bitrate;
507     case 0x40:
508         return 2 * (320 * bitrate / 147 + (i_frmsizecod & 1));
509     case 0x80:
510         return 6 * bitrate;
511     default:
512         return 0;
513     }
514 }
515
516 /**
517  * It return the size of a EAC3 frame (or 0 if invalid)
518  */
519 static int GetEac3Size( const uint8_t *p_buf )
520 {
521     int i_frame_size;
522     int i_bytes;
523
524     i_frame_size = ( ( p_buf[2] << 8 ) | p_buf[3] ) & 0x7ff;
525     if( i_frame_size < 2 )
526         return 0;
527     i_bytes = 2 * ( i_frame_size + 1 );
528
529     return i_bytes;
530 }
531
532 /**
533  * It returns the size of an AC3/EAC3 frame (or 0 if invalid)
534  */
535 static int SyncInfoDolby( const uint8_t *p_buf )
536 {
537     int bsid;
538
539     /* Check synword */
540     if( p_buf[0] != 0x0b || p_buf[1] != 0x77 )
541         return 0;
542
543     /* Check bsid */
544     bsid = p_buf[5] >> 3;
545     if( bsid > 16 )
546         return 0;
547
548     if( bsid <= 10 )
549         return GetAc3Size( p_buf );
550     else
551         return GetEac3Size( p_buf );
552 }
553