git.sesse.net Git - vlc/blob - modules/packetizer/mpeg4audio.c

   1 /*****************************************************************************
   2  * mpeg4audio.c: parse and packetize an MPEG 4 audio stream
   3  *****************************************************************************
   4  * Copyright (C) 2001, 2002, 2006 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *          Gildas Bazin <gbazin@netcourrier.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28
  29 #ifdef HAVE_CONFIG_H
  30 # include "config.h"
  31 #endif
  32
  33 #include <vlc/vlc.h>
  34 #include <vlc_plugin.h>
  35 #include <vlc_aout.h>
  36 #include <vlc_codec.h>
  37 #include <vlc_block.h>
  38 #include <vlc_sout.h>
  39 #include <vlc_codecs.h>
  40 #include <vlc_input.h>
  41 #include <vlc_bits.h>
  42
  43 #include "vlc_block_helper.h"
  44
  45 /* AAC Config in ES:
  46  *
  47  * AudioObjectType          5 bits
  48  * samplingFrequencyIndex   4 bits
  49  * if (samplingFrequencyIndex == 0xF)
  50  *  samplingFrequency   24 bits
  51  * channelConfiguration     4 bits
  52  * GA_SpecificConfig
  53  *  FrameLengthFlag         1 bit 1024 or 960
  54  *  DependsOnCoreCoder      1 bit (always 0)
  55  *  ExtensionFlag           1 bit (always 0)
  56  */
  57
  58 /*****************************************************************************
  59  * decoder_sys_t : decoder descriptor
  60  *****************************************************************************/
  61 typedef struct
  62 {
  63     int i_object_type;
  64     int i_samplerate;
  65     int i_channel;
  66     int i_sbr;          // 0: no sbr, 1: sbr, -1: unknown
  67
  68     struct
  69     {
  70         int i_object_type;
  71         int i_samplerate;
  72     } extension;
  73
  74     /* GASpecific */
  75     int i_frame_length;   // 1024 or 960
  76
  77 } mpeg4_cfg_t;
  78
  79 #define LATM_MAX_EXTRA_SIZE 64
  80 typedef struct
  81 {
  82     int i_program;
  83     int i_layer;
  84
  85     int i_frame_length_type;
  86     int i_frame_length;         // type 1
  87     int i_frame_length_index;   // type 3 4 5 6 7
  88
  89     mpeg4_cfg_t cfg;
  90
  91     /* Raw configuration */
  92     int     i_extra;
  93     uint8_t extra[LATM_MAX_EXTRA_SIZE];
  94
  95 } latm_stream_t;
  96
  97 #define LATM_MAX_LAYER (8)
  98 #define LATM_MAX_PROGRAM (16)
  99 typedef struct
 100 {
 101     int b_same_time_framing;
 102     int i_sub_frames;
 103     int i_programs;
 104
 105     int pi_layers[LATM_MAX_PROGRAM];
 106
 107     int pi_stream[LATM_MAX_PROGRAM][LATM_MAX_LAYER];
 108
 109     int i_streams;
 110     latm_stream_t stream[LATM_MAX_PROGRAM*LATM_MAX_LAYER];
 111
 112     int i_other_data;
 113     int i_crc;  /* -1 if not set */
 114 } latm_mux_t;
 115
 116 struct decoder_sys_t
 117 {
 118     /*
 119      * Input properties
 120      */
 121     int i_state;
 122     int i_type;
 123
 124     block_bytestream_t bytestream;
 125
 126     /*
 127      * Common properties
 128      */
 129     audio_date_t end_date;
 130     mtime_t i_pts;
 131
 132     int i_frame_size;
 133     unsigned int i_channels;
 134     unsigned int i_rate, i_frame_length, i_header_size;
 135
 136     int i_input_rate;
 137
 138     /* LOAS */
 139     bool b_latm_cfg;
 140     latm_mux_t latm;
 141 };
 142
 143 enum {
 144     STATE_NOSYNC,
 145     STATE_SYNC,
 146     STATE_HEADER,
 147     STATE_NEXT_SYNC,
 148     STATE_GET_DATA,
 149     STATE_SEND_DATA
 150 };
 151
 152 enum {
 153     TYPE_NONE,
 154     TYPE_RAW,
 155     TYPE_ADTS,
 156     TYPE_LOAS
 157 };
 158
 159 static const int pi_sample_rates[16] =
 160 {
 161     96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
 162     16000, 12000, 11025, 8000,  7350,  0,     0,     0
 163 };
 164
 165 #define ADTS_HEADER_SIZE 9
 166 #define LOAS_HEADER_SIZE 3
 167
 168 /****************************************************************************
 169  * Local prototypes
 170  ****************************************************************************/
 171 static int  OpenPacketizer( vlc_object_t * );
 172 static void ClosePacketizer( vlc_object_t * );
 173
 174 static block_t *PacketizeRawBlock    ( decoder_t *, block_t ** );
 175 static block_t *PacketizeStreamBlock( decoder_t *, block_t ** );
 176
 177 /*****************************************************************************
 178  * Module descriptor
 179  *****************************************************************************/
 180 vlc_module_begin();
 181     set_category( CAT_SOUT );
 182     set_subcategory( SUBCAT_SOUT_PACKETIZER );
 183     set_description( _("MPEG4 audio packetizer") );
 184     set_capability( "packetizer", 50 );
 185     set_callbacks( OpenPacketizer, ClosePacketizer );
 186 vlc_module_end();
 187
 188 /*****************************************************************************
 189  * OpenPacketizer: probe the packetizer and return score
 190  *****************************************************************************/
 191 static int OpenPacketizer( vlc_object_t *p_this )
 192 {
 193     decoder_t *p_dec = (decoder_t*)p_this;
 194     decoder_sys_t *p_sys;
 195
 196     if( p_dec->fmt_in.i_codec != VLC_FOURCC( 'm', 'p', '4', 'a' ) )
 197     {
 198         return VLC_EGENERIC;
 199     }
 200
 201     /* Allocate the memory needed to store the decoder's structure */
 202     if( ( p_dec->p_sys = p_sys =
 203           (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
 204     {
 205         msg_Err( p_dec, "out of memory" );
 206         return VLC_EGENERIC;
 207     }
 208
 209     /* Misc init */
 210     p_sys->i_state = STATE_NOSYNC;
 211     aout_DateSet( &p_sys->end_date, 0 );
 212     p_sys->bytestream = block_BytestreamInit();
 213     p_sys->i_input_rate = INPUT_RATE_DEFAULT;
 214     p_sys->b_latm_cfg = false;
 215
 216     /* Set output properties */
 217     p_dec->fmt_out.i_cat = AUDIO_ES;
 218     p_dec->fmt_out.i_codec = VLC_FOURCC('m','p','4','a');
 219
 220     msg_Dbg( p_dec, "running MPEG4 audio packetizer" );
 221
 222     if( p_dec->fmt_in.i_extra > 0 )
 223     {
 224         uint8_t *p_config = (uint8_t*)p_dec->fmt_in.p_extra;
 225         int     i_index;
 226
 227         i_index = ( ( p_config[0] << 1 ) | ( p_config[1] >> 7 ) ) & 0x0f;
 228         if( i_index != 0x0f )
 229         {
 230             p_dec->fmt_out.audio.i_rate = pi_sample_rates[i_index];
 231             p_dec->fmt_out.audio.i_frame_length =
 232                 (( p_config[1] >> 2 ) & 0x01) ? 960 : 1024;
 233         }
 234         else
 235         {
 236             p_dec->fmt_out.audio.i_rate = ( ( p_config[1] & 0x7f ) << 17 ) |
 237                 ( p_config[2] << 9 ) | ( p_config[3] << 1 ) |
 238                 ( p_config[4] >> 7 );
 239             p_dec->fmt_out.audio.i_frame_length =
 240                 (( p_config[4] >> 2 ) & 0x01) ? 960 : 1024;
 241         }
 242
 243         p_dec->fmt_out.audio.i_channels =
 244             (p_config[i_index == 0x0f ? 4 : 1] >> 3) & 0x0f;
 245
 246         msg_Dbg( p_dec, "AAC %dHz %d samples/frame",
 247                  p_dec->fmt_out.audio.i_rate,
 248                  p_dec->fmt_out.audio.i_frame_length );
 249
 250         aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
 251
 252         p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
 253         p_dec->fmt_out.p_extra = malloc( p_dec->fmt_in.i_extra );
 254         if( !p_dec->fmt_out.p_extra )
 255         {
 256             p_dec->fmt_out.i_extra = 0;
 257             return VLC_ENOMEM;
 258         }
 259         memcpy( p_dec->fmt_out.p_extra, p_dec->fmt_in.p_extra,
 260                 p_dec->fmt_in.i_extra );
 261
 262         /* Set callback */
 263         p_dec->pf_packetize = PacketizeRawBlock;
 264         p_sys->i_type = TYPE_RAW;
 265     }
 266     else
 267     {
 268         msg_Dbg( p_dec, "no decoder specific info, must be an ADTS or LOAS stream" );
 269
 270         aout_DateInit( &p_sys->end_date, p_dec->fmt_in.audio.i_rate );
 271
 272         /* We will try to create a AAC Config from adts/loas */
 273         p_dec->fmt_out.i_extra = 0;
 274         p_dec->fmt_out.p_extra = NULL;
 275
 276         /* Set callback */
 277         p_dec->pf_packetize = PacketizeStreamBlock;
 278         p_sys->i_type = TYPE_NONE;
 279     }
 280
 281     return VLC_SUCCESS;
 282 }
 283
 284 /****************************************************************************
 285  * PacketizeRawBlock: the whole thing
 286  ****************************************************************************
 287  * This function must be fed with complete frames.
 288  ****************************************************************************/
 289 static block_t *PacketizeRawBlock( decoder_t *p_dec, block_t **pp_block )
 290 {
 291     decoder_sys_t *p_sys = p_dec->p_sys;
 292     block_t *p_block;
 293
 294     if( !pp_block || !*pp_block ) return NULL;
 295
 296     if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
 297     {
 298         //aout_DateSet( &p_sys->end_date, 0 );
 299         block_Release( *pp_block );
 300         return NULL;
 301     }
 302
 303     p_block = *pp_block;
 304     *pp_block = NULL; /* Don't reuse this block */
 305
 306     if( !aout_DateGet( &p_sys->end_date ) && !p_block->i_pts )
 307     {
 308         /* We've just started the stream, wait for the first PTS. */
 309         block_Release( p_block );
 310         return NULL;
 311     }
 312     else if( p_block->i_pts != 0 &&
 313              p_block->i_pts != aout_DateGet( &p_sys->end_date ) )
 314     {
 315         aout_DateSet( &p_sys->end_date, p_block->i_pts );
 316     }
 317
 318     p_block->i_pts = p_block->i_dts = aout_DateGet( &p_sys->end_date );
 319
 320     p_block->i_length = aout_DateIncrement( &p_sys->end_date,
 321         p_dec->fmt_out.audio.i_frame_length * p_sys->i_input_rate / INPUT_RATE_DEFAULT ) - p_block->i_pts;
 322
 323     return p_block;
 324 }
 325
 326 /****************************************************************************
 327  * ADTS helpers
 328  ****************************************************************************/
 329 static int ADTSSyncInfo( decoder_t * p_dec, const uint8_t * p_buf,
 330                          unsigned int * pi_channels,
 331                          unsigned int * pi_sample_rate,
 332                          unsigned int * pi_frame_length,
 333                          unsigned int * pi_header_size )
 334 {
 335     int i_profile, i_sample_rate_idx, i_frame_size;
 336     bool b_crc;
 337
 338     /* Fixed header between frames */
 339     //int i_id = ( (p_buf[1] >> 3) & 0x01) ? 2 : 4; /* MPEG-2 or 4 */
 340     b_crc = !(p_buf[1] & 0x01);
 341     i_profile = p_buf[2] >> 6;
 342     i_sample_rate_idx = (p_buf[2] >> 2) & 0x0f;
 343     *pi_sample_rate = pi_sample_rates[i_sample_rate_idx];
 344     //private_bit = (p_buf[2] >> 1) & 0x01;
 345     *pi_channels = ((p_buf[2] & 0x01) << 2) | ((p_buf[3] >> 6) & 0x03);
 346     //original_copy = (p_buf[3] >> 5) & 0x01;
 347     //home = (p_buf[3] >> 4) & 0x01;
 348
 349     /* Variable header */
 350     //copyright_id_bit = (p_buf[3] >> 3) & 0x01;
 351     //copyright_id_start = (p_buf[3] >> 2) & 0x01;
 352     i_frame_size = ((p_buf[3] & 0x03) << 11) | (p_buf[4] << 3) |
 353                    ((p_buf[5] >> 5) /*& 0x7*/);
 354     //uint16_t buffer_fullness = ((p_buf[5] & 0x1f) << 6) | (p_buf[6] >> 2);
 355     unsigned short i_raw_blocks_in_frame = p_buf[6] & 0x03;
 356
 357     if( !*pi_sample_rate || !*pi_channels || !i_frame_size )
 358     {
 359         msg_Warn( p_dec, "Invalid ADTS header" );
 360         return 0;
 361     }
 362
 363     *pi_frame_length = 1024;
 364
 365     if( i_raw_blocks_in_frame == 0 )
 366     {
 367         if( b_crc )
 368         {
 369             msg_Warn( p_dec, "ADTS CRC not supported" );
 370             //uint16_t crc = (p_buf[7] << 8) | p_buf[8];
 371         }
 372     }
 373     else
 374     {
 375         msg_Err( p_dec, "Multiple blocks per frame in ADTS not supported" );
 376         return 0;
 377 #if 0
 378         int i;
 379         const uint8_t *p_pos = p_buf + 7;
 380         uint16_t crc_block;
 381         uint16_t i_block_pos[3];
 382         if( b_crc )
 383         {
 384             for( i = 0 ; i < i_raw_blocks_in_frame ; i++ )
 385             {   /* the 1st block's position is known ... */
 386                 i_block_pos[i] = (*p_pos << 8) | *(p_pos+1);
 387                 p_pos += 2;
 388             }
 389             crc_block = (*p_pos << 8) | *(p_pos+1);
 390             p_pos += 2;
 391         }
 392         for( i = 0 ; i <= i_raw_blocks_in_frame ; i++ )
 393         {
 394             //read 1 block
 395             if( b_crc )
 396             {
 397                 msg_Err( p_dec, "ADTS CRC not supported" );
 398                 //uint16_t crc = (*p_pos << 8) | *(p_pos+1);
 399                 //p_pos += 2;
 400             }
 401         }
 402 #endif
 403     }
 404
 405
 406     /* Build the decoder specific info header */
 407     if( !p_dec->fmt_out.i_extra )
 408     {
 409         p_dec->fmt_out.p_extra = malloc( 2 );
 410         if( !p_dec->fmt_out.p_extra )
 411         {
 412             p_dec->fmt_out.i_extra = 0;
 413             return 0;
 414         }
 415         p_dec->fmt_out.i_extra = 2;
 416         ((uint8_t *)p_dec->fmt_out.p_extra)[0] =
 417             (i_profile + 1) << 3 | (i_sample_rate_idx >> 1);
 418         ((uint8_t *)p_dec->fmt_out.p_extra)[1] =
 419             ((i_sample_rate_idx & 0x01) << 7) | (*pi_channels <<3);
 420     }
 421
 422     /* ADTS header length */
 423     *pi_header_size = b_crc ? 9 : 7;
 424
 425     return i_frame_size - *pi_header_size;
 426 }
 427
 428 /****************************************************************************
 429  * LOAS helpers
 430  ****************************************************************************/
 431 static int LOASSyncInfo( uint8_t p_header[LOAS_HEADER_SIZE], unsigned int *pi_header_size )
 432 {
 433     *pi_header_size = 3;
 434     return ( ( p_header[1] & 0x1f ) << 8 ) + p_header[2];
 435 }
 436
 437 static int Mpeg4GAProgramConfigElement( bs_t *s )
 438 {
 439     /* TODO compute channels count ? */
 440     int i_tag = bs_read( s, 4 );
 441     if( i_tag != 0x05 )
 442         return -1;
 443     bs_skip( s, 2 + 4 ); // object type + sampling index
 444     int i_num_front = bs_read( s, 4 );
 445     int i_num_side = bs_read( s, 4 );
 446     int i_num_back = bs_read( s, 4 );
 447     int i_num_lfe = bs_read( s, 2 );
 448     int i_num_assoc_data = bs_read( s, 3 );
 449     int i_num_valid_cc = bs_read( s, 4 );
 450
 451     if( bs_read1(s) )
 452         bs_skip( s, 4 ); // mono downmix
 453     if( bs_read1(s) )
 454         bs_skip( s, 4 ); // stereo downmix
 455     if( bs_read1(s) )
 456         bs_skip( s, 2+1 ); // matrix downmix + pseudo_surround
 457
 458     bs_skip( s, i_num_front * (1+4) );
 459     bs_skip( s, i_num_side * (1+4) );
 460     bs_skip( s, i_num_back * (1+4) );
 461     bs_skip( s, i_num_lfe * (4) );
 462     bs_skip( s, i_num_assoc_data * (4) );
 463     bs_skip( s, i_num_valid_cc * (5) );
 464     bs_align( s );
 465     int i_comment = bs_read( s, 8 );
 466     bs_skip( s, i_comment * 8 );
 467     return 0;
 468 }
 469
 470 static int Mpeg4GASpecificConfig( mpeg4_cfg_t *p_cfg, bs_t *s )
 471 {
 472     p_cfg->i_frame_length = bs_read1(s) ? 960 : 1024;
 473
 474     if( bs_read1( s ) )     // depend on core coder
 475         bs_skip( s, 14 );   // core coder delay
 476
 477     int i_extension_flag = bs_read1( s );
 478     if( p_cfg->i_channel == 0 )
 479     {
 480         Mpeg4GAProgramConfigElement( s );
 481     }
 482     if( p_cfg->i_object_type == 6 || p_cfg->i_object_type == 20 )
 483         bs_skip( s, 3 );    // layer
 484
 485     if( i_extension_flag )
 486     {
 487         if( p_cfg->i_object_type == 22 )
 488         {
 489             bs_skip( s, 5 + 11 );   // numOfSubFrame + layer length
 490         }
 491         if( p_cfg->i_object_type == 17 || p_cfg->i_object_type == 19 ||
 492             p_cfg->i_object_type == 20 || p_cfg->i_object_type == 23 )
 493         {
 494             bs_skip( s, 1+1+1 );    // ER data : section scale spectral */
 495         }
 496         if( bs_read1( s ) )     // extension 3
 497             fprintf( stderr, "Mpeg4GASpecificConfig: error 1\n" );
 498     }
 499     return 0;
 500 }
 501
 502 static int Mpeg4ReadAudioObjectType( bs_t *s )
 503 {
 504     int i_type = bs_read( s, 5 );
 505     if( i_type == 0x1f )
 506         i_type += bs_read( s, 6 );
 507     return i_type;
 508 }
 509
 510 static int Mpeg4ReadAudioSamplerate( bs_t *s )
 511 {
 512     int i_index = bs_read( s, 4 );
 513     if( i_index != 0x0f )
 514         return pi_sample_rates[i_index];
 515     return bs_read( s, 24 );
 516 }
 517
 518 static int Mpeg4ReadAudioSpecificInfo( mpeg4_cfg_t *p_cfg, int *pi_extra, uint8_t *p_extra, bs_t *s, int i_max_size )
 519 {
 520 #if 0
 521     static const char *ppsz_otype[] = {
 522         "NULL",
 523         "AAC Main", "AAC LC", "AAC SSR", "AAC LTP", "SBR", "AAC Scalable",
 524         "TwinVQ",
 525         "CELP", "HVXC",
 526         "Reserved", "Reserved",
 527         "TTSI",
 528         "Main Synthetic", "Wavetables Synthesis", "General MIDI",
 529         "Algorithmic Synthesis and Audio FX",
 530         "ER AAC LC",
 531         "Reserved",
 532         "ER AAC LTP", "ER AAC Scalable", "ER TwinVQ", "ER BSAC", "ER AAC LD",
 533         "ER CELP", "ER HVXC", "ER HILN", "ER Parametric",
 534         "SSC",
 535         "Reserved", "Reserved", "Escape",
 536         "Layer 1", "Layer 2", "Layer 3",
 537         "DST",
 538     };
 539 #endif
 540     const int i_pos_start = bs_pos( s );
 541     bs_t s_sav = *s;
 542     int i_bits;
 543     int i;
 544
 545     memset( p_cfg, 0, sizeof(*p_cfg) );
 546     *pi_extra = 0;
 547
 548     p_cfg->i_object_type = Mpeg4ReadAudioObjectType( s );
 549     p_cfg->i_samplerate = Mpeg4ReadAudioSamplerate( s );
 550
 551     p_cfg->i_channel = bs_read( s, 4 );
 552     if( p_cfg->i_channel == 7 )
 553         p_cfg->i_channel = 8; // 7.1
 554     else if( p_cfg->i_channel >= 8 )
 555         p_cfg->i_channel = -1;
 556
 557     p_cfg->i_sbr = -1;
 558     p_cfg->extension.i_object_type = 0;
 559     p_cfg->extension.i_samplerate = 0;
 560     if( p_cfg->i_object_type == 5 )
 561     {
 562         p_cfg->i_sbr = 1;
 563         p_cfg->extension.i_object_type = p_cfg->i_object_type;
 564         p_cfg->extension.i_samplerate = Mpeg4ReadAudioSamplerate( s );
 565
 566         p_cfg->i_object_type = Mpeg4ReadAudioObjectType( s );
 567     }
 568
 569     switch( p_cfg->i_object_type )
 570     {
 571     case 1: case 2: case 3: case 4:
 572     case 6: case 7:
 573     case 17: case 19: case 20: case 21: case 22: case 23:
 574         Mpeg4GASpecificConfig( p_cfg, s );
 575         break;
 576     case 8:
 577         // CelpSpecificConfig();
 578         break;
 579     case 9:
 580         // HvxcSpecificConfig();
 581         break;
 582     case 12:
 583         // TTSSSpecificConfig();
 584         break;
 585     case 13: case 14: case 15: case 16:
 586         // StructuredAudioSpecificConfig();
 587         break;
 588     case 24:
 589         // ERCelpSpecificConfig();
 590         break;
 591     case 25:
 592         // ERHvxcSpecificConfig();
 593         break;
 594     case 26: case 27:
 595         // ParametricSpecificConfig();
 596         break;
 597     case 28:
 598         // SSCSpecificConfig();
 599         break;
 600     case 32: case 33: case 34:
 601         // MPEG_1_2_SpecificConfig();
 602         break;
 603     case 35:
 604         // DSTSpecificConfig();
 605         break;
 606     default:
 607         // error
 608         break;
 609     }
 610     switch( p_cfg->i_object_type )
 611     {
 612     case 17: case 19: case 20: case 21: case 22: case 23:
 613     case 24: case 25: case 26: case 27:
 614     {
 615         int epConfig = bs_read( s, 2 );
 616         if( epConfig == 2 || epConfig == 3 )
 617         {
 618             //ErrorProtectionSpecificConfig();
 619         }
 620         if( epConfig == 3 )
 621         {
 622             int directMapping = bs_read1( s );
 623             if( directMapping )
 624             {
 625                 // tbd ...
 626             }
 627         }
 628         break;
 629     }
 630     default:
 631         break;
 632     }
 633
 634     if( p_cfg->extension.i_object_type != 5 && i_max_size > 0 && i_max_size - (bs_pos(s) - i_pos_start) >= 16 &&
 635         bs_read( s, 11 ) == 0x2b7 )
 636     {
 637         p_cfg->extension.i_object_type = Mpeg4ReadAudioObjectType( s );
 638         if( p_cfg->extension.i_object_type == 5 )
 639         {
 640             p_cfg->i_sbr  = bs_read1( s );
 641             if( p_cfg->i_sbr == 1 )
 642                 p_cfg->extension.i_samplerate = Mpeg4ReadAudioSamplerate( s );
 643         }
 644     }
 645
 646     //fprintf( stderr, "Mpeg4ReadAudioSpecificInfo: t=%s(%d)f=%d c=%d sbr=%d\n",
 647     //         ppsz_otype[p_cfg->i_object_type], p_cfg->i_object_type, p_cfg->i_samplerate, p_cfg->i_channel, p_cfg->i_sbr );
 648
 649     i_bits = bs_pos(s) - i_pos_start;
 650
 651     *pi_extra = ( i_bits + 7 ) / 8;
 652     for( i = 0; i < __MIN( LATM_MAX_EXTRA_SIZE, *pi_extra ); i++ )
 653     {
 654         const int i_read = __MIN( 8, i_bits - 8*i );
 655         p_extra[i] = bs_read( &s_sav, i_read ) << (8-i_read);
 656     }
 657     return i_bits;
 658 }
 659
 660 static int LatmGetValue( bs_t *s )
 661 {
 662     int i_bytes = bs_read( s, 2 );
 663     int v = 0;
 664     int i;
 665     for( i = 0; i < i_bytes; i++ )
 666         v = (v << 8) + bs_read( s, 8 );
 667
 668     return v;
 669 }
 670
 671 static int LatmReadStreamMuxConfiguration( latm_mux_t *m, bs_t *s )
 672 {
 673     int i_mux_version;
 674     int i_mux_versionA;
 675     int i_program;
 676
 677     i_mux_version = bs_read( s, 1 );
 678     i_mux_versionA = 0;
 679     if( i_mux_version )
 680         i_mux_versionA = bs_read( s, 1 );
 681
 682     if( i_mux_versionA != 0 ) /* support only A=0 */
 683         return -1;
 684
 685     memset( m, 0, sizeof(*m) );
 686
 687     if( i_mux_versionA == 0 )
 688     {
 689         if( i_mux_version == 1 )
 690         {
 691             LatmGetValue(s); /* taraBufferFullness */
 692         }
 693     }
 694
 695     m->b_same_time_framing = bs_read1( s );
 696     m->i_sub_frames = 1 + bs_read( s, 6 );
 697     m->i_programs = 1 + bs_read( s, 4 );
 698
 699     for( i_program = 0; i_program < m->i_programs; i_program++ )
 700     {
 701         int i_layer;
 702
 703         m->pi_layers[i_program] = 1+bs_read( s, 3 );
 704
 705         for( i_layer = 0; i_layer < m->pi_layers[i_program]; i_layer++ )
 706         {
 707             latm_stream_t *st = &m->stream[m->i_streams];
 708             bool b_previous_cfg;
 709
 710             m->pi_stream[i_program][i_layer] = m->i_streams;
 711             st->i_program = i_program;
 712             st->i_layer = i_layer;
 713
 714             b_previous_cfg = false;
 715             if( i_program != 0 || i_layer != 0 )
 716                 b_previous_cfg = bs_read1( s );
 717
 718             if( b_previous_cfg )
 719             {
 720                 assert( m->i_streams > 0 );
 721                 st->cfg = m->stream[m->i_streams-1].cfg;
 722             }
 723             else
 724             {
 725                 int i_cfg_size = 0;
 726                 if( i_mux_version == 1 )
 727                     i_cfg_size = LatmGetValue(s);
 728                 i_cfg_size -= Mpeg4ReadAudioSpecificInfo( &st->cfg, &st->i_extra, st->extra, s, i_cfg_size );
 729                 if( i_cfg_size > 0 )
 730                     bs_skip( s, i_cfg_size );
 731             }
 732
 733             st->i_frame_length_type = bs_read( s, 3 );
 734             switch( st->i_frame_length_type )
 735             {
 736             case 0:
 737             {
 738                 bs_skip( s, 8 ); /* latmBufferFullnes */
 739                 if( !m->b_same_time_framing )
 740                 {
 741                     if( st->cfg.i_object_type == 6 || st->cfg.i_object_type == 20 ||
 742                         st->cfg.i_object_type == 8 || st->cfg.i_object_type == 24 )
 743                     {
 744                         bs_skip( s, 6 ); /* eFrameOffset */
 745                     }
 746                 }
 747                 break;
 748             }
 749             case 1:
 750                 st->i_frame_length = bs_read( s, 9 );
 751                 break;
 752             case 3: case 4: case 5:
 753                 st->i_frame_length_index = bs_read( s, 6 ); // celp
 754                 break;
 755             case 6: case 7:
 756                 st->i_frame_length_index = bs_read( s, 1 ); // hvxc
 757             default:
 758                 break;
 759             }
 760             /* Next stream */
 761             m->i_streams++;
 762         }
 763     }
 764
 765     /* other data */
 766     if( bs_read1( s ) )
 767     {
 768         if( i_mux_version == 1 )
 769         {
 770             m->i_other_data = LatmGetValue( s );
 771         }
 772         else
 773         {
 774             int b_continue;
 775             do {
 776                 b_continue = bs_read1(s);
 777                 m->i_other_data = (m->i_other_data << 8) + bs_read( s, 8 );
 778             } while( b_continue );
 779         }
 780     }
 781
 782     /* crc */
 783     m->i_crc = -1;
 784     if( bs_read1( s ) )
 785         m->i_crc = bs_read( s, 8 );
 786
 787     return 0;
 788 }
 789
 790 static int LOASParse( decoder_t *p_dec, uint8_t *p_buffer, int i_buffer )
 791 {
 792     decoder_sys_t *p_sys = p_dec->p_sys;
 793     bs_t s;
 794     int i_sub;
 795     int i_accumulated = 0;
 796
 797     bs_init( &s, p_buffer, i_buffer );
 798
 799     /* Read the stream mux configuration if present */
 800     if( !bs_read1( &s ) )
 801     {
 802         if( !LatmReadStreamMuxConfiguration( &p_sys->latm, &s ) &&
 803             p_sys->latm.i_streams > 0 )
 804         {
 805             const latm_stream_t *st = &p_sys->latm.stream[0];
 806
 807             p_sys->i_channels = st->cfg.i_channel;
 808             p_sys->i_rate = st->cfg.i_samplerate;
 809             p_sys->i_frame_length = st->cfg.i_frame_length;
 810
 811             /* FIXME And if it changes ? */
 812             if( !p_dec->fmt_out.i_extra && st->i_extra > 0 )
 813             {
 814                 p_dec->fmt_out.i_extra = st->i_extra;
 815                 p_dec->fmt_out.p_extra = malloc( st->i_extra );
 816                 if( !p_dec->fmt_out.p_extra )
 817                 {
 818                     p_dec->fmt_out.i_extra = 0;
 819                     return 0;
 820                 }
 821                 memcpy( p_dec->fmt_out.p_extra, st->extra, st->i_extra );
 822             }
 823
 824             p_sys->b_latm_cfg = true;
 825         }
 826     }
 827     /* Wait for the configuration */
 828     if( !p_sys->b_latm_cfg )
 829         return 0;
 830
 831     /* FIXME do we need to split the subframe into independant packet ? */
 832     if( p_sys->latm.i_sub_frames > 1 )
 833         msg_Err( p_dec, "latm sub frames not yet supported, please send a sample" );
 834
 835     for( i_sub = 0; i_sub < p_sys->latm.i_sub_frames; i_sub++ )
 836     {
 837         int pi_payload[LATM_MAX_PROGRAM][LATM_MAX_LAYER];
 838         if( p_sys->latm.b_same_time_framing )
 839         {
 840             int i_program;
 841             /* Payload length */
 842             for( i_program = 0; i_program < p_sys->latm.i_programs; i_program++ )
 843             {
 844                 int i_layer;
 845                 for( i_layer = 0; i_layer < p_sys->latm.pi_layers[i_program]; i_layer++ )
 846                 {
 847                     latm_stream_t *st = &p_sys->latm.stream[p_sys->latm.pi_stream[i_program][i_layer]];
 848                     if( st->i_frame_length_type == 0 )
 849                     {
 850                         int i_payload = 0;
 851                         for( ;; )
 852                         {
 853                             int i_tmp = bs_read( &s, 8 );
 854                             i_payload += i_tmp;
 855                             if( i_tmp != 255 )
 856                                 break;
 857                         }
 858                         pi_payload[i_program][i_layer] = i_payload;
 859                     }
 860                     else if( st->i_frame_length_type == 1 )
 861                     {
 862                         pi_payload[i_program][i_layer] = st->i_frame_length / 8; /* XXX not correct */
 863                     }
 864                     else if( ( st->i_frame_length_type == 3 ) ||
 865                              ( st->i_frame_length_type == 5 ) ||
 866                              ( st->i_frame_length_type == 7 ) )
 867                     {
 868                         bs_skip( &s, 2 ); // muxSlotLengthCoded
 869                         pi_payload[i_program][i_layer] = 0; /* TODO */
 870                     }
 871                     else
 872                     {
 873                         pi_payload[i_program][i_layer] = 0; /* TODO */
 874                     }
 875                 }
 876             }
 877             /* Payload Data */
 878             for( i_program = 0; i_program < p_sys->latm.i_programs; i_program++ )
 879             {
 880                 int i_layer;
 881                 int i;
 882                 for( i_layer = 0; i_layer < p_sys->latm.pi_layers[i_program]; i_layer++ )
 883                 {
 884                     /* XXX we only extract 1 stream */
 885                     if( i_program != 0 || i_layer != 0 )
 886                         break;
 887
 888                     if( pi_payload[i_program][i_layer] <= 0 )
 889                         continue;
 890
 891                     /* FIXME that's slow (and a bit ugly to write in place) */
 892                     for( i = 0; i < pi_payload[i_program][i_layer]; i++ )
 893                         p_buffer[i_accumulated++] = bs_read( &s, 8 );
 894                 }
 895             }
 896         }
 897         else
 898         {
 899             const int i_chunks = bs_read( &s, 4 );
 900             int pi_program[16];
 901             int pi_layer[16];
 902             int i_chunk;
 903
 904             msg_Err( p_dec, "latm without same time frameing not yet supported, please send a sample" );
 905
 906             for( i_chunk = 0; i_chunk < i_chunks; i_chunk++ )
 907             {
 908                 const int streamIndex = bs_read( &s, 4 );
 909                 latm_stream_t *st = &p_sys->latm.stream[streamIndex];
 910                 const int i_program = st->i_program;
 911                 const int i_layer = st->i_layer;
 912
 913                 pi_program[i_chunk] = i_program;
 914                 pi_layer[i_chunk] = i_layer;
 915
 916                 if( st->i_frame_length_type == 0 )
 917                 {
 918                     int i_payload = 0;
 919                     for( ;; )
 920                     {
 921                         int i_tmp = bs_read( &s, 8 );
 922                         i_payload += i_tmp;
 923                         if( i_tmp != 255 )
 924                             break;
 925                     }
 926                     pi_payload[i_program][i_layer] = i_payload;
 927                     bs_skip( &s, 1 ); // auEndFlag
 928                 }
 929                 else if( st->i_frame_length_type == 1 )
 930                 {
 931                     pi_payload[i_program][i_layer] = st->i_frame_length / 8; /* XXX not correct */
 932                 }
 933                 else if( ( st->i_frame_length_type == 3 ) ||
 934                          ( st->i_frame_length_type == 5 ) ||
 935                          ( st->i_frame_length_type == 7 ) )
 936                 {
 937                     bs_read( &s, 2 ); // muxSlotLengthCoded
 938                 }
 939                 else
 940                 {
 941                 }
 942             }
 943             for( i_chunk = 0; i_chunk < i_chunks; i_chunk++ )
 944             {
 945                 //const int i_program = pi_program[i_chunk];
 946                 //const int i_layer = pi_layer[i_chunk];
 947
 948                 /* TODO ? Payload */
 949             }
 950         }
 951     }
 952
 953     if( p_sys->latm.i_other_data > 0 )
 954     {
 955         /* Other data XXX we just ignore them */
 956     }
 957     bs_align( &s );
 958
 959     return i_accumulated;
 960 }
 961
 962 /****************************************************************************
 963  * PacketizeStreamBlock: ADTS/LOAS packetizer
 964  ****************************************************************************/
 965 static void SetupOutput( decoder_t *p_dec, block_t *p_block );
 966 static block_t *PacketizeStreamBlock( decoder_t *p_dec, block_t **pp_block )
 967 {
 968     decoder_sys_t *p_sys = p_dec->p_sys;
 969     uint8_t p_header[ADTS_HEADER_SIZE + LOAS_HEADER_SIZE];
 970     block_t *p_out_buffer;
 971     uint8_t *p_buf;
 972
 973     if( !pp_block || !*pp_block ) return NULL;
 974
 975     if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
 976     {
 977         if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
 978         {
 979             p_sys->i_state = STATE_NOSYNC;
 980             block_BytestreamFlush( &p_sys->bytestream );
 981         }
 982         //aout_DateSet( &p_sys->end_date, 0 );
 983         block_Release( *pp_block );
 984         return NULL;
 985     }
 986
 987     if( !aout_DateGet( &p_sys->end_date ) && !(*pp_block)->i_pts )
 988     {
 989         /* We've just started the stream, wait for the first PTS. */
 990         block_Release( *pp_block );
 991         return NULL;
 992     }
 993
 994     if( (*pp_block)->i_rate > 0 )
 995         p_sys->i_input_rate = (*pp_block)->i_rate;
 996
 997     block_BytestreamPush( &p_sys->bytestream, *pp_block );
 998
 999     for( ;; )
1000     {
1001         switch( p_sys->i_state )
1002         {
1003
1004         case STATE_NOSYNC:
1005             while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
1006                    == VLC_SUCCESS )
1007             {
1008                 /* Look for sync word - should be 0xfff(adts) or 0x2b7(loas) */
1009                 if( p_header[0] == 0xff && (p_header[1] & 0xf6) == 0xf0 )
1010                 {
1011                     if( p_sys->i_type != TYPE_ADTS )
1012                         msg_Dbg( p_dec, "detected ADTS format" );
1013
1014                     p_sys->i_state = STATE_SYNC;
1015                     p_sys->i_type = TYPE_ADTS;
1016                     break;
1017                 }
1018                 else if( p_header[0] == 0x56 && (p_header[1] & 0xe0) == 0xe0 )
1019                 {
1020                     if( p_sys->i_type != TYPE_LOAS )
1021                         msg_Dbg( p_dec, "detected LOAS format" );
1022
1023                     p_sys->i_state = STATE_SYNC;
1024                     p_sys->i_type = TYPE_LOAS;
1025                     break;
1026                 }
1027                 block_SkipByte( &p_sys->bytestream );
1028             }
1029             if( p_sys->i_state != STATE_SYNC )
1030             {
1031                 block_BytestreamFlush( &p_sys->bytestream );
1032
1033                 /* Need more data */
1034                 return NULL;
1035             }
1036
1037         case STATE_SYNC:
1038             /* New frame, set the Presentation Time Stamp */
1039             p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
1040             if( p_sys->i_pts != 0 &&
1041                 p_sys->i_pts != aout_DateGet( &p_sys->end_date ) )
1042             {
1043                 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
1044             }
1045             p_sys->i_state = STATE_HEADER;
1046             break;
1047
1048         case STATE_HEADER:
1049             if( p_sys->i_type == TYPE_ADTS )
1050             {
1051                 /* Get ADTS frame header (ADTS_HEADER_SIZE bytes) */
1052                 if( block_PeekBytes( &p_sys->bytestream, p_header,
1053                                      ADTS_HEADER_SIZE ) != VLC_SUCCESS )
1054                 {
1055                     /* Need more data */
1056                     return NULL;
1057                 }
1058
1059                 /* Check if frame is valid and get frame info */
1060                 p_sys->i_frame_size = ADTSSyncInfo( p_dec, p_header,
1061                                                     &p_sys->i_channels,
1062                                                     &p_sys->i_rate,
1063                                                     &p_sys->i_frame_length,
1064                                                     &p_sys->i_header_size );
1065             }
1066             else
1067             {
1068                 assert( p_sys->i_type == TYPE_LOAS );
1069                 /* Get LOAS frame header (LOAS_HEADER_SIZE bytes) */
1070                 if( block_PeekBytes( &p_sys->bytestream, p_header,
1071                                      LOAS_HEADER_SIZE ) != VLC_SUCCESS )
1072                 {
1073                     /* Need more data */
1074                     return NULL;
1075                 }
1076
1077                 /* Check if frame is valid and get frame info */
1078                 p_sys->i_frame_size = LOASSyncInfo( p_header, &p_sys->i_header_size );
1079             }
1080
1081             if( p_sys->i_frame_size <= 0 )
1082             {
1083                 msg_Dbg( p_dec, "emulated sync word" );
1084                 block_SkipByte( &p_sys->bytestream );
1085                 p_sys->i_state = STATE_NOSYNC;
1086                 break;
1087             }
1088
1089             p_sys->i_state = STATE_NEXT_SYNC;
1090
1091         case STATE_NEXT_SYNC:
1092             /* TODO: If p_block == NULL, flush the buffer without checking the
1093              * next sync word */
1094             if( p_sys->bytestream.p_block == NULL )
1095             {
1096                 p_sys->i_state = STATE_NOSYNC;
1097                 block_BytestreamFlush( &p_sys->bytestream );
1098                 return NULL;
1099             }
1100
1101             /* Check if next expected frame contains the sync word */
1102             if( block_PeekOffsetBytes( &p_sys->bytestream, p_sys->i_frame_size
1103                                        + p_sys->i_header_size, p_header, 2 )
1104                 != VLC_SUCCESS )
1105             {
1106                 /* Need more data */
1107                 return NULL;
1108             }
1109
1110             assert( (p_sys->i_type == TYPE_ADTS) || (p_sys->i_type == TYPE_LOAS) );
1111             if( ( ( p_sys->i_type == TYPE_ADTS ) &&
1112                   ( p_header[0] != 0xff || (p_header[1] & 0xf6) != 0xf0 ) ) ||
1113                 ( ( p_sys->i_type == TYPE_LOAS ) &&
1114                   ( p_header[0] != 0x56 || (p_header[1] & 0xe0) != 0xe0 ) ) )
1115             {
1116                 msg_Dbg( p_dec, "emulated sync word "
1117                          "(no sync on following frame)" );
1118                 p_sys->i_state = STATE_NOSYNC;
1119                 block_SkipByte( &p_sys->bytestream );
1120                 break;
1121             }
1122
1123             p_sys->i_state = STATE_SEND_DATA;
1124             break;
1125
1126         case STATE_GET_DATA:
1127             /* Make sure we have enough data.
1128              * (Not useful if we went through NEXT_SYNC) */
1129             if( block_WaitBytes( &p_sys->bytestream, p_sys->i_frame_size +
1130                                  p_sys->i_header_size) != VLC_SUCCESS )
1131             {
1132                 /* Need more data */
1133                 return NULL;
1134             }
1135             p_sys->i_state = STATE_SEND_DATA;
1136
1137         case STATE_SEND_DATA:
1138             /* When we reach this point we already know we have enough
1139              * data available. */
1140
1141             p_out_buffer = block_New( p_dec, p_sys->i_frame_size );
1142             if( !p_out_buffer )
1143             {
1144                 //p_dec->b_error = true;
1145                 return NULL;
1146             }
1147             p_buf = p_out_buffer->p_buffer;
1148
1149             /* Skip the ADTS/LOAS header */
1150             block_SkipBytes( &p_sys->bytestream, p_sys->i_header_size );
1151
1152             if( p_sys->i_type == TYPE_ADTS )
1153             {
1154                 /* Copy the whole frame into the buffer */
1155                 block_GetBytes( &p_sys->bytestream, p_buf, p_sys->i_frame_size );
1156             }
1157             else
1158             {
1159                 assert( p_sys->i_type == TYPE_LOAS );
1160                 /* Copy the whole frame into the buffer and parse/extract it */
1161                 block_GetBytes( &p_sys->bytestream, p_buf, p_sys->i_frame_size );
1162                 p_out_buffer->i_buffer = LOASParse( p_dec, p_buf, p_sys->i_frame_size );
1163                 if( p_out_buffer->i_buffer <= 0 )
1164                 {
1165                     if( !p_sys->b_latm_cfg )
1166                         msg_Warn( p_dec, "waiting for header" );
1167
1168                     block_Release( p_out_buffer );
1169                     p_out_buffer = NULL;
1170                     p_sys->i_state = STATE_NOSYNC;
1171                     break;
1172                 }
1173             }
1174             SetupOutput( p_dec, p_out_buffer );
1175             /* Make sure we don't reuse the same pts twice */
1176             if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
1177                 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = 0;
1178
1179             /* So p_block doesn't get re-added several times */
1180             *pp_block = block_BytestreamPop( &p_sys->bytestream );
1181
1182             p_sys->i_state = STATE_NOSYNC;
1183
1184             return p_out_buffer;
1185         }
1186     }
1187
1188     return NULL;
1189 }
1190
1191 /*****************************************************************************
1192  * SetupBuffer:
1193  *****************************************************************************/
1194 static void SetupOutput( decoder_t *p_dec, block_t *p_block )
1195 {
1196     decoder_sys_t *p_sys = p_dec->p_sys;
1197
1198     if( p_dec->fmt_out.audio.i_rate != p_sys->i_rate )
1199     {
1200         msg_Info( p_dec, "AAC channels: %d samplerate: %d",
1201                   p_sys->i_channels, p_sys->i_rate );
1202
1203         aout_DateInit( &p_sys->end_date, p_sys->i_rate );
1204         aout_DateSet( &p_sys->end_date, p_sys->i_pts );
1205     }
1206
1207     p_dec->fmt_out.audio.i_rate     = p_sys->i_rate;
1208     p_dec->fmt_out.audio.i_channels = p_sys->i_channels;
1209     p_dec->fmt_out.audio.i_bytes_per_frame = p_sys->i_frame_size;
1210     p_dec->fmt_out.audio.i_frame_length = p_sys->i_frame_length;
1211
1212 #if 0
1213     p_dec->fmt_out.audio.i_original_channels = p_sys->i_channels_conf;
1214     p_dec->fmt_out.audio.i_physical_channels =
1215         p_sys->i_channels_conf & AOUT_CHAN_PHYSMASK;
1216 #endif
1217
1218     p_block->i_pts = p_block->i_dts = aout_DateGet( &p_sys->end_date );
1219
1220     p_block->i_length = aout_DateIncrement( &p_sys->end_date,
1221                             p_sys->i_frame_length * p_sys->i_input_rate / INPUT_RATE_DEFAULT ) -
1222                                 p_block->i_pts;
1223 }
1224
1225 /*****************************************************************************
1226  * ClosePacketizer: clean up the packetizer
1227  *****************************************************************************/
1228 static void ClosePacketizer( vlc_object_t *p_this )
1229 {
1230     decoder_t *p_dec = (decoder_t *)p_this;
1231     decoder_sys_t *p_sys = p_dec->p_sys;
1232
1233     block_BytestreamRelease( &p_sys->bytestream );
1234
1235     free( p_dec->p_sys );
1236 }