modules/codec/aes3.c

   1 /*****************************************************************************
   2  * aes3.c: aes3 decoder/packetizer module
   3  *****************************************************************************
   4  * Copyright (C) 2008 VLC authors and VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Laurent Aimar <fenrir@videolan.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU Lesser General Public License as published by
  11  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this program; if not, write to the Free Software Foundation,
  21  * 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 <assert.h>
  35
  36 /*****************************************************************************
  37  * Module descriptor
  38  *****************************************************************************/
  39 static int  OpenDecoder   ( vlc_object_t * );
  40 static int  OpenPacketizer( vlc_object_t * );
  41 static void Close         ( vlc_object_t * );
  42
  43 vlc_module_begin ()
  44
  45     set_category( CAT_INPUT )
  46     set_subcategory( SUBCAT_INPUT_ACODEC )
  47     set_description( N_("AES3/SMPTE 302M audio decoder") )
  48     set_capability( "audio decoder", 100 )
  49     set_callbacks( OpenDecoder, Close )
  50
  51     add_submodule ()
  52     set_description( N_("AES3/SMPTE 302M audio packetizer") )
  53     set_capability( "packetizer", 100 )
  54     set_callbacks( OpenPacketizer, Close )
  55
  56 vlc_module_end ()
  57
  58 /*****************************************************************************
  59  * decoder_sys_t : aes3 decoder descriptor
  60  *****************************************************************************/
  61 struct decoder_sys_t
  62 {
  63     /*
  64      * Output properties
  65      */
  66     date_t end_date;
  67 };
  68
  69 #define AES3_HEADER_LEN 4
  70
  71 /*****************************************************************************
  72  * Local prototypes
  73  *****************************************************************************/
  74 static int Open( decoder_t *p_dec, bool b_packetizer );
  75
  76 static block_t *Parse( decoder_t *p_dec, int *pi_frame_length, int *pi_bits,
  77                        block_t *p_block, bool b_packetizer );
  78
  79 /*****************************************************************************
  80  * OpenDecoder:
  81  *****************************************************************************/
  82 static int OpenDecoder( vlc_object_t *p_this )
  83 {
  84     decoder_t *p_dec = (decoder_t*)p_this;
  85
  86     return Open( p_dec, false );
  87 }
  88
  89 /*****************************************************************************
  90  * OpenPacketizer:
  91  *****************************************************************************/
  92 static int OpenPacketizer( vlc_object_t *p_this )
  93 {
  94     decoder_t *p_dec = (decoder_t*)p_this;
  95
  96     return Open( p_dec, true );
  97 }
  98
  99 /*****************************************************************************
 100  * Close : aes3 decoder destruction
 101  *****************************************************************************/
 102 static void Close( vlc_object_t *p_this )
 103 {
 104     decoder_t *p_dec = (decoder_t*)p_this;
 105     free( p_dec->p_sys );
 106 }
 107
 108 static const uint8_t reverse[256] = {
 109     0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x10, 0x90, 0x50, 0xd0,
 110     0x30, 0xb0, 0x70, 0xf0, 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
 111     0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, 0x04, 0x84, 0x44, 0xc4,
 112     0x24, 0xa4, 0x64, 0xe4, 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
 113     0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, 0x1c, 0x9c, 0x5c, 0xdc,
 114     0x3c, 0xbc, 0x7c, 0xfc, 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
 115     0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2, 0x0a, 0x8a, 0x4a, 0xca,
 116     0x2a, 0xaa, 0x6a, 0xea, 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
 117     0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x16, 0x96, 0x56, 0xd6,
 118     0x36, 0xb6, 0x76, 0xf6, 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
 119     0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, 0x01, 0x81, 0x41, 0xc1,
 120     0x21, 0xa1, 0x61, 0xe1, 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
 121     0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 0x19, 0x99, 0x59, 0xd9,
 122     0x39, 0xb9, 0x79, 0xf9, 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
 123     0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5, 0x0d, 0x8d, 0x4d, 0xcd,
 124     0x2d, 0xad, 0x6d, 0xed, 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
 125     0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, 0x13, 0x93, 0x53, 0xd3,
 126     0x33, 0xb3, 0x73, 0xf3, 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
 127     0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb, 0x07, 0x87, 0x47, 0xc7,
 128     0x27, 0xa7, 0x67, 0xe7, 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
 129     0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 0x1f, 0x9f, 0x5f, 0xdf,
 130     0x3f, 0xbf, 0x7f, 0xff
 131 };
 132
 133 /*****************************************************************************
 134  * Decode: decodes an aes3 frame.
 135  ****************************************************************************
 136  * Beware, this function must be fed with complete frames (PES packet).
 137  *****************************************************************************/
 138 static int Decode( decoder_t *p_dec, block_t *p_block )
 139 {
 140     decoder_sys_t *p_sys = p_dec->p_sys;
 141     block_t       *p_aout_buffer;
 142     int            i_frame_length, i_bits;
 143
 144     p_block = Parse( p_dec, &i_frame_length, &i_bits, p_block, false );
 145     if( !p_block )
 146         return VLCDEC_SUCCESS;
 147
 148     if( decoder_UpdateAudioFormat( p_dec ) )
 149     {
 150         p_aout_buffer = NULL;
 151         goto exit;
 152     }
 153
 154     p_aout_buffer = decoder_NewAudioBuffer( p_dec, i_frame_length );
 155     if( p_aout_buffer == NULL )
 156         goto exit;
 157
 158     p_aout_buffer->i_pts = date_Get( &p_sys->end_date );
 159     p_aout_buffer->i_length = date_Increment( &p_sys->end_date,
 160                                       i_frame_length ) - p_aout_buffer->i_pts;
 161
 162     p_block->i_buffer -= AES3_HEADER_LEN;
 163     p_block->p_buffer += AES3_HEADER_LEN;
 164
 165     if( i_bits == 24 )
 166     {
 167         uint32_t *p_out = (uint32_t *)p_aout_buffer->p_buffer;
 168
 169         while( p_block->i_buffer / 7 )
 170         {
 171             *(p_out++) =  (reverse[p_block->p_buffer[0]] <<  8)
 172                         | (reverse[p_block->p_buffer[1]] << 16)
 173                         | (reverse[p_block->p_buffer[2]] << 24);
 174             *(p_out++) = ((reverse[p_block->p_buffer[3]] <<  4)
 175                         | (reverse[p_block->p_buffer[4]] << 12)
 176                         | (reverse[p_block->p_buffer[5]] << 20)
 177                         | (reverse[p_block->p_buffer[6]] << 28)) & 0xFFFFFF00;
 178
 179             p_block->i_buffer -= 7;
 180             p_block->p_buffer += 7;
 181         }
 182
 183     }
 184     else if( i_bits == 20 )
 185     {
 186         uint32_t *p_out = (uint32_t *)p_aout_buffer->p_buffer;
 187
 188         while( p_block->i_buffer / 6 )
 189         {
 190             *(p_out++) = (reverse[p_block->p_buffer[0]] << 12)
 191                        | (reverse[p_block->p_buffer[1]] << 20)
 192                        | (reverse[p_block->p_buffer[2]] << 28);
 193             *(p_out++) = (reverse[p_block->p_buffer[3]] << 12)
 194                        | (reverse[p_block->p_buffer[4]] << 20)
 195                        | (reverse[p_block->p_buffer[5]] << 28);
 196
 197             p_block->i_buffer -= 6;
 198             p_block->p_buffer += 6;
 199         }
 200     }
 201     else
 202     {
 203         uint16_t *p_out = (uint16_t *)p_aout_buffer->p_buffer;
 204
 205         assert( i_bits == 16 );
 206
 207         while( p_block->i_buffer / 5 )
 208         {
 209             *(p_out++) =  reverse[p_block->p_buffer[0]]
 210                         |(reverse[p_block->p_buffer[1]] <<  8);
 211             *(p_out++) = (reverse[p_block->p_buffer[2]] >>  4)
 212                        | (reverse[p_block->p_buffer[3]] <<  4)
 213                        | (reverse[p_block->p_buffer[4]] << 12);
 214
 215             p_block->i_buffer -= 5;
 216             p_block->p_buffer += 5;
 217         }
 218     }
 219
 220 exit:
 221     block_Release( p_block );
 222     if( p_aout_buffer != NULL )
 223         decoder_QueueAudio( p_dec, p_aout_buffer );
 224     return VLCDEC_SUCCESS;
 225 }
 226
 227 /*****************************************************************************
 228  * Flush:
 229  *****************************************************************************/
 230 static void Flush( decoder_t *p_dec )
 231 {
 232     decoder_sys_t *p_sys = p_dec->p_sys;
 233
 234     date_Set( &p_sys->end_date, 0 );
 235 }
 236
 237 /*****************************************************************************
 238  * Packetize: packetizes an aes3 frame.
 239  ****************************************************************************
 240  * Beware, this function must be fed with complete frames (PES packet).
 241  *****************************************************************************/
 242 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
 243 {
 244     decoder_sys_t *p_sys = p_dec->p_sys;
 245     block_t       *p_block;
 246     int           i_frame_length, i_bits;
 247
 248     if( !pp_block ) /* No Drain */
 249         return NULL;
 250     p_block = *pp_block;
 251     *pp_block = NULL; /* So the packet doesn't get re-sent */
 252
 253     p_block = Parse( p_dec, &i_frame_length, &i_bits, p_block, true );
 254     if( !p_block )
 255         return NULL;
 256
 257     p_block->i_pts = p_block->i_dts = date_Get( &p_sys->end_date );
 258     p_block->i_length = date_Increment( &p_sys->end_date, i_frame_length ) - p_block->i_pts;
 259
 260     /* Just pass on the incoming frame */
 261     return p_block;
 262 }
 263
 264 /*****************************************************************************
 265  *
 266  ****************************************************************************/
 267 static int Open( decoder_t *p_dec, bool b_packetizer )
 268 {
 269     decoder_sys_t *p_sys;
 270
 271     if( p_dec->fmt_in.i_codec != VLC_CODEC_302M )
 272         return VLC_EGENERIC;
 273
 274     /* Allocate the memory needed to store the decoder's structure */
 275     p_dec->p_sys = p_sys = malloc( sizeof(decoder_sys_t) );
 276
 277     if( unlikely( !p_sys ) )
 278         return VLC_EGENERIC;
 279
 280     /* Misc init */
 281     date_Init( &p_sys->end_date, 48000, 1 );
 282     date_Set( &p_sys->end_date, 0 );
 283
 284     /* Set output properties */
 285     p_dec->fmt_out.audio.i_rate = 48000;
 286
 287     /* Set callback */
 288     if( b_packetizer )
 289     {
 290         p_dec->fmt_out.i_codec = VLC_CODEC_302M;
 291
 292         p_dec->pf_decode       = NULL;
 293         p_dec->pf_packetize    = Packetize;
 294     }
 295     else
 296     {
 297         p_dec->fmt_out.i_codec = VLC_CODEC_S16N;
 298         p_dec->fmt_out.audio.i_bitspersample = 16;
 299
 300         p_dec->pf_decode    = Decode;
 301         p_dec->pf_packetize = NULL;
 302     }
 303     p_dec->pf_flush            = Flush;
 304     return VLC_SUCCESS;
 305 }
 306
 307 static const unsigned int pi_original_channels[4] = {
 308     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
 309     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT |
 310         AOUT_CHAN_CENTER | AOUT_CHAN_LFE,
 311     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT |
 312         AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT |
 313         AOUT_CHAN_CENTER | AOUT_CHAN_LFE,
 314     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT |
 315         AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT |
 316         AOUT_CHAN_MIDDLELEFT | AOUT_CHAN_MIDDLERIGHT |
 317         AOUT_CHAN_CENTER | AOUT_CHAN_LFE,
 318 };
 319
 320 static block_t * Parse( decoder_t *p_dec, int *pi_frame_length, int *pi_bits,
 321                         block_t *p_block, bool b_packetizer )
 322 {
 323     decoder_sys_t *p_sys = p_dec->p_sys;
 324     uint32_t h;
 325     unsigned int i_size;
 326     int i_channels;
 327     int i_bits;
 328
 329     if( !p_block ) /* No drain */
 330         return NULL;
 331
 332     if( p_block->i_flags & (BLOCK_FLAG_CORRUPTED|BLOCK_FLAG_DISCONTINUITY) )
 333     {
 334         Flush( p_dec );
 335         if( p_block->i_flags & BLOCK_FLAG_CORRUPTED )
 336         {
 337             block_Release( p_block );
 338             return NULL;
 339         }
 340     }
 341
 342     /* Date management */
 343     if( p_block->i_pts > VLC_TS_INVALID &&
 344         p_block->i_pts != date_Get( &p_sys->end_date ) )
 345     {
 346         date_Set( &p_sys->end_date, p_block->i_pts );
 347     }
 348
 349     if( !date_Get( &p_sys->end_date ) )
 350     {
 351         /* We've just started the stream, wait for the first PTS. */
 352         block_Release( p_block );
 353         return NULL;
 354     }
 355
 356     if( p_block->i_buffer <= AES3_HEADER_LEN )
 357     {
 358         msg_Err(p_dec, "frame is too short");
 359         block_Release( p_block );
 360         return NULL;
 361     }
 362
 363     /*
 364      * AES3 header :
 365      * size:            16
 366      * number channels   2
 367      * channel_id        8
 368      * bits per samples  2
 369      * alignments        4
 370      */
 371
 372     h = GetDWBE( p_block->p_buffer );
 373     i_size = (h >> 16) & 0xffff;
 374     i_channels = 2 + 2*( (h >> 14) & 0x03 );
 375     i_bits = 16 + 4*( (h >> 4)&0x03 );
 376
 377     if( AES3_HEADER_LEN + i_size != p_block->i_buffer || i_bits > 24 )
 378     {
 379         msg_Err(p_dec, "frame has invalid header");
 380         block_Release( p_block );
 381         return NULL;
 382     }
 383
 384     /* Set output properties */
 385     if( b_packetizer )
 386     {
 387         p_dec->fmt_out.audio.i_bitspersample = i_bits;
 388     }
 389     else
 390     {
 391         p_dec->fmt_out.i_codec = i_bits == 16 ? VLC_CODEC_S16N : VLC_CODEC_S32N;
 392         p_dec->fmt_out.audio.i_bitspersample = i_bits == 16 ? 16 : 32;
 393     }
 394
 395     p_dec->fmt_out.audio.i_channels = i_channels;
 396     p_dec->fmt_out.audio.i_physical_channels = pi_original_channels[i_channels/2-1];
 397
 398     *pi_frame_length = (p_block->i_buffer - AES3_HEADER_LEN) / ( (4+i_bits) * i_channels / 8 );
 399     *pi_bits = i_bits;
 400     return p_block;
 401 }