1 /*****************************************************************************
2 * mpeg4audio.c: parse and packetize an MPEG 4 audio stream
3 *****************************************************************************
4 * Copyright (C) 2001, 2002, 2006 VLC authors and VideoLAN
7 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8 * Gildas Bazin <gbazin@netcourrier.com>
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU Lesser General Public License as published by
12 * the Free Software Foundation; either version 2.1 of the License, or
13 * (at your option) any later version.
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 Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this program; if not, write to the Free Software Foundation,
22 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 *****************************************************************************/
25 /*****************************************************************************
27 *****************************************************************************/
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
35 #include <vlc_codec.h>
36 #include <vlc_block.h>
39 #include <vlc_block_helper.h>
40 #include "packetizer_helper.h"
46 * AudioObjectType 5 bits
47 * samplingFrequencyIndex 4 bits
48 * if (samplingFrequencyIndex == 0xF)
49 * samplingFrequency 24 bits
50 * channelConfiguration 4 bits
52 * FrameLengthFlag 1 bit 1024 or 960
53 * DependsOnCoreCoder 1 bit (always 0)
54 * ExtensionFlag 1 bit (always 0)
57 /*****************************************************************************
58 * decoder_sys_t : decoder descriptor
59 *****************************************************************************/
65 int i_sbr; // 0: no sbr, 1: sbr, -1: unknown
66 int i_ps; // 0: no ps, 1: ps, -1: unknown
75 int i_frame_length; // 1024 or 960
79 #define LATM_MAX_EXTRA_SIZE 64
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
91 /* Raw configuration */
93 uint8_t extra[LATM_MAX_EXTRA_SIZE];
97 #define LATM_MAX_LAYER (8)
98 #define LATM_MAX_PROGRAM (16)
101 int b_same_time_framing;
105 int pi_layers[LATM_MAX_PROGRAM];
107 int pi_stream[LATM_MAX_PROGRAM][LATM_MAX_LAYER];
110 latm_stream_t stream[LATM_MAX_PROGRAM*LATM_MAX_LAYER];
113 int i_crc; /* -1 if not set */
124 block_bytestream_t bytestream;
133 unsigned int i_channels;
134 unsigned int i_rate, i_frame_length, i_header_size;
150 static const int pi_sample_rates[16] =
152 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
153 16000, 12000, 11025, 8000, 7350, 0, 0, 0
156 #define ADTS_HEADER_SIZE 9
157 #define LOAS_HEADER_SIZE 3
159 /****************************************************************************
161 ****************************************************************************/
162 static int OpenPacketizer( vlc_object_t * );
163 static void ClosePacketizer( vlc_object_t * );
165 static block_t *PacketizeRawBlock ( decoder_t *, block_t ** );
166 static block_t *PacketizeStreamBlock( decoder_t *, block_t ** );
168 /*****************************************************************************
170 *****************************************************************************/
172 set_category( CAT_SOUT )
173 set_subcategory( SUBCAT_SOUT_PACKETIZER )
174 set_description( N_("MPEG4 audio packetizer") )
175 set_capability( "packetizer", 50 )
176 set_callbacks( OpenPacketizer, ClosePacketizer )
179 /*****************************************************************************
180 * OpenPacketizer: probe the packetizer and return score
181 *****************************************************************************/
182 static int OpenPacketizer( vlc_object_t *p_this )
184 decoder_t *p_dec = (decoder_t*)p_this;
185 decoder_sys_t *p_sys;
187 if( p_dec->fmt_in.i_codec != VLC_CODEC_MP4A )
192 /* Allocate the memory needed to store the decoder's structure */
193 if( ( p_dec->p_sys = p_sys =
194 (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
198 p_sys->i_state = STATE_NOSYNC;
199 date_Set( &p_sys->end_date, 0 );
200 block_BytestreamInit( &p_sys->bytestream );
201 p_sys->b_latm_cfg = false;
203 /* Set output properties */
204 p_dec->fmt_out.i_cat = AUDIO_ES;
205 p_dec->fmt_out.i_codec = VLC_CODEC_MP4A;
207 msg_Dbg( p_dec, "running MPEG4 audio packetizer" );
209 if( p_dec->fmt_in.i_extra > 0 )
211 uint8_t *p_config = (uint8_t*)p_dec->fmt_in.p_extra;
214 i_index = ( ( p_config[0] << 1 ) | ( p_config[1] >> 7 ) ) & 0x0f;
215 if( i_index != 0x0f )
217 p_dec->fmt_out.audio.i_rate = pi_sample_rates[i_index];
218 p_dec->fmt_out.audio.i_frame_length =
219 (( p_config[1] >> 2 ) & 0x01) ? 960 : 1024;
223 p_dec->fmt_out.audio.i_rate = ( ( p_config[1] & 0x7f ) << 17 ) |
224 ( p_config[2] << 9 ) | ( p_config[3] << 1 ) |
225 ( p_config[4] >> 7 );
226 p_dec->fmt_out.audio.i_frame_length =
227 (( p_config[4] >> 2 ) & 0x01) ? 960 : 1024;
230 p_dec->fmt_out.audio.i_channels =
231 (p_config[i_index == 0x0f ? 4 : 1] >> 3) & 0x0f;
233 msg_Dbg( p_dec, "AAC %dHz %d samples/frame",
234 p_dec->fmt_out.audio.i_rate,
235 p_dec->fmt_out.audio.i_frame_length );
237 date_Init( &p_sys->end_date, p_dec->fmt_out.audio.i_rate, 1 );
239 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
240 p_dec->fmt_out.p_extra = malloc( p_dec->fmt_in.i_extra );
241 if( !p_dec->fmt_out.p_extra )
243 p_dec->fmt_out.i_extra = 0;
246 memcpy( p_dec->fmt_out.p_extra, p_dec->fmt_in.p_extra,
247 p_dec->fmt_in.i_extra );
250 p_dec->pf_packetize = PacketizeRawBlock;
251 p_sys->i_type = TYPE_RAW;
255 msg_Dbg( p_dec, "no decoder specific info, must be an ADTS or LOAS stream" );
257 date_Init( &p_sys->end_date, p_dec->fmt_in.audio.i_rate, 1 );
259 /* We will try to create a AAC Config from adts/loas */
260 p_dec->fmt_out.i_extra = 0;
261 p_dec->fmt_out.p_extra = NULL;
264 p_dec->pf_packetize = PacketizeStreamBlock;
265 p_sys->i_type = TYPE_NONE;
271 /****************************************************************************
272 * PacketizeRawBlock: the whole thing
273 ****************************************************************************
274 * This function must be fed with complete frames.
275 ****************************************************************************/
276 static block_t *PacketizeRawBlock( decoder_t *p_dec, block_t **pp_block )
278 decoder_sys_t *p_sys = p_dec->p_sys;
281 if( !pp_block || !*pp_block ) return NULL;
283 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
285 date_Set( &p_sys->end_date, 0 );
286 block_Release( *pp_block );
291 *pp_block = NULL; /* Don't reuse this block */
293 if( !date_Get( &p_sys->end_date ) && p_block->i_pts <= VLC_TS_INVALID )
295 /* We've just started the stream, wait for the first PTS. */
296 block_Release( p_block );
299 else if( p_block->i_pts > VLC_TS_INVALID &&
300 p_block->i_pts != date_Get( &p_sys->end_date ) )
302 date_Set( &p_sys->end_date, p_block->i_pts );
305 p_block->i_pts = p_block->i_dts = date_Get( &p_sys->end_date );
307 p_block->i_length = date_Increment( &p_sys->end_date,
308 p_dec->fmt_out.audio.i_frame_length ) - p_block->i_pts;
313 /****************************************************************************
315 ****************************************************************************/
316 static int ADTSSyncInfo( decoder_t * p_dec, const uint8_t * p_buf,
317 unsigned int * pi_channels,
318 unsigned int * pi_sample_rate,
319 unsigned int * pi_frame_length,
320 unsigned int * pi_header_size )
322 int i_profile, i_sample_rate_idx, i_frame_size;
325 /* Fixed header between frames */
326 //int i_id = ( (p_buf[1] >> 3) & 0x01) ? 2 : 4; /* MPEG-2 or 4 */
327 b_crc = !(p_buf[1] & 0x01);
328 i_profile = p_buf[2] >> 6;
329 i_sample_rate_idx = (p_buf[2] >> 2) & 0x0f;
330 *pi_sample_rate = pi_sample_rates[i_sample_rate_idx];
331 //private_bit = (p_buf[2] >> 1) & 0x01;
332 *pi_channels = ((p_buf[2] & 0x01) << 2) | ((p_buf[3] >> 6) & 0x03);
333 if (*pi_channels == 0) /* workaround broken streams */
335 //original_copy = (p_buf[3] >> 5) & 0x01;
336 //home = (p_buf[3] >> 4) & 0x01;
338 /* Variable header */
339 //copyright_id_bit = (p_buf[3] >> 3) & 0x01;
340 //copyright_id_start = (p_buf[3] >> 2) & 0x01;
341 i_frame_size = ((p_buf[3] & 0x03) << 11) | (p_buf[4] << 3) |
342 ((p_buf[5] >> 5) /*& 0x7*/);
343 //uint16_t buffer_fullness = ((p_buf[5] & 0x1f) << 6) | (p_buf[6] >> 2);
344 unsigned short i_raw_blocks_in_frame = p_buf[6] & 0x03;
346 if( !*pi_sample_rate || !i_frame_size )
348 msg_Warn( p_dec, "Invalid ADTS header" );
352 *pi_frame_length = 1024;
354 if( i_raw_blocks_in_frame == 0 )
358 msg_Warn( p_dec, "ADTS CRC not supported" );
359 //uint16_t crc = (p_buf[7] << 8) | p_buf[8];
364 msg_Err( p_dec, "Multiple blocks per frame in ADTS not supported" );
368 const uint8_t *p_pos = p_buf + 7;
370 uint16_t i_block_pos[3];
373 for( i = 0 ; i < i_raw_blocks_in_frame ; i++ )
374 { /* the 1st block's position is known ... */
375 i_block_pos[i] = (*p_pos << 8) | *(p_pos+1);
378 crc_block = (*p_pos << 8) | *(p_pos+1);
381 for( i = 0 ; i <= i_raw_blocks_in_frame ; i++ )
386 msg_Err( p_dec, "ADTS CRC not supported" );
387 //uint16_t crc = (*p_pos << 8) | *(p_pos+1);
395 /* Build the decoder specific info header */
396 if( !p_dec->fmt_out.i_extra )
398 p_dec->fmt_out.p_extra = malloc( 2 );
399 if( !p_dec->fmt_out.p_extra )
401 p_dec->fmt_out.i_extra = 0;
404 p_dec->fmt_out.i_extra = 2;
405 ((uint8_t *)p_dec->fmt_out.p_extra)[0] =
406 (i_profile + 1) << 3 | (i_sample_rate_idx >> 1);
407 ((uint8_t *)p_dec->fmt_out.p_extra)[1] =
408 ((i_sample_rate_idx & 0x01) << 7) | (*pi_channels <<3);
411 /* ADTS header length */
412 *pi_header_size = b_crc ? 9 : 7;
414 return i_frame_size - *pi_header_size;
417 /****************************************************************************
419 ****************************************************************************/
420 static int LOASSyncInfo( uint8_t p_header[LOAS_HEADER_SIZE], unsigned int *pi_header_size )
423 return ( ( p_header[1] & 0x1f ) << 8 ) + p_header[2];
426 static int Mpeg4GAProgramConfigElement( bs_t *s )
428 /* TODO compute channels count ? */
429 int i_tag = bs_read( s, 4 );
432 bs_skip( s, 2 + 4 ); // object type + sampling index
433 int i_num_front = bs_read( s, 4 );
434 int i_num_side = bs_read( s, 4 );
435 int i_num_back = bs_read( s, 4 );
436 int i_num_lfe = bs_read( s, 2 );
437 int i_num_assoc_data = bs_read( s, 3 );
438 int i_num_valid_cc = bs_read( s, 4 );
441 bs_skip( s, 4 ); // mono downmix
443 bs_skip( s, 4 ); // stereo downmix
445 bs_skip( s, 2+1 ); // matrix downmix + pseudo_surround
447 bs_skip( s, i_num_front * (1+4) );
448 bs_skip( s, i_num_side * (1+4) );
449 bs_skip( s, i_num_back * (1+4) );
450 bs_skip( s, i_num_lfe * (4) );
451 bs_skip( s, i_num_assoc_data * (4) );
452 bs_skip( s, i_num_valid_cc * (5) );
454 int i_comment = bs_read( s, 8 );
455 bs_skip( s, i_comment * 8 );
459 static int Mpeg4GASpecificConfig( mpeg4_cfg_t *p_cfg, bs_t *s )
461 p_cfg->i_frame_length = bs_read1(s) ? 960 : 1024;
463 if( bs_read1( s ) ) // depend on core coder
464 bs_skip( s, 14 ); // core coder delay
466 int i_extension_flag = bs_read1( s );
467 if( p_cfg->i_channel == 0 )
469 Mpeg4GAProgramConfigElement( s );
471 if( p_cfg->i_object_type == 6 || p_cfg->i_object_type == 20 )
472 bs_skip( s, 3 ); // layer
474 if( i_extension_flag )
476 if( p_cfg->i_object_type == 22 )
478 bs_skip( s, 5 + 11 ); // numOfSubFrame + layer length
480 if( p_cfg->i_object_type == 17 || p_cfg->i_object_type == 19 ||
481 p_cfg->i_object_type == 20 || p_cfg->i_object_type == 23 )
483 bs_skip( s, 1+1+1 ); // ER data : section scale spectral */
485 if( bs_read1( s ) ) // extension 3
486 fprintf( stderr, "Mpeg4GASpecificConfig: error 1\n" );
491 static int Mpeg4ReadAudioObjectType( bs_t *s )
493 int i_type = bs_read( s, 5 );
495 i_type = 32 + bs_read( s, 6 );
499 static int Mpeg4ReadAudioSamplerate( bs_t *s )
501 int i_index = bs_read( s, 4 );
502 if( i_index != 0x0f )
503 return pi_sample_rates[i_index];
504 return bs_read( s, 24 );
507 static int Mpeg4ReadAudioSpecificInfo( mpeg4_cfg_t *p_cfg, int *pi_extra, uint8_t *p_extra, bs_t *s, int i_max_size )
510 static const char *ppsz_otype[] = {
512 "AAC Main", "AAC LC", "AAC SSR", "AAC LTP", "SBR", "AAC Scalable",
515 "Reserved", "Reserved",
517 "Main Synthetic", "Wavetables Synthesis", "General MIDI",
518 "Algorithmic Synthesis and Audio FX",
521 "ER AAC LTP", "ER AAC Scalable", "ER TwinVQ", "ER BSAC", "ER AAC LD",
522 "ER CELP", "ER HVXC", "ER HILN", "ER Parametric",
524 "PS", "Reserved", "Escape",
525 "Layer 1", "Layer 2", "Layer 3",
529 const int i_pos_start = bs_pos( s );
534 memset( p_cfg, 0, sizeof(*p_cfg) );
537 p_cfg->i_object_type = Mpeg4ReadAudioObjectType( s );
538 p_cfg->i_samplerate = Mpeg4ReadAudioSamplerate( s );
540 p_cfg->i_channel = bs_read( s, 4 );
541 if( p_cfg->i_channel == 7 )
542 p_cfg->i_channel = 8; // 7.1
543 else if( p_cfg->i_channel >= 8 )
544 p_cfg->i_channel = -1;
548 p_cfg->extension.i_object_type = 0;
549 p_cfg->extension.i_samplerate = 0;
550 if( p_cfg->i_object_type == 5 || p_cfg->i_object_type == 29 )
553 if( p_cfg->i_object_type == 29 )
555 p_cfg->extension.i_object_type = 5;
556 p_cfg->extension.i_samplerate = Mpeg4ReadAudioSamplerate( s );
558 p_cfg->i_object_type = Mpeg4ReadAudioObjectType( s );
561 switch( p_cfg->i_object_type )
563 case 1: case 2: case 3: case 4:
565 case 17: case 19: case 20: case 21: case 22: case 23:
566 Mpeg4GASpecificConfig( p_cfg, s );
569 // CelpSpecificConfig();
572 // HvxcSpecificConfig();
575 // TTSSSpecificConfig();
577 case 13: case 14: case 15: case 16:
578 // StructuredAudioSpecificConfig();
581 // ERCelpSpecificConfig();
584 // ERHvxcSpecificConfig();
587 // ParametricSpecificConfig();
590 // SSCSpecificConfig();
592 case 32: case 33: case 34:
593 // MPEG_1_2_SpecificConfig();
596 // DSTSpecificConfig();
599 // ALSSpecificConfig();
605 switch( p_cfg->i_object_type )
607 case 17: case 19: case 20: case 21: case 22: case 23:
608 case 24: case 25: case 26: case 27:
610 int epConfig = bs_read( s, 2 );
611 if( epConfig == 2 || epConfig == 3 )
613 //ErrorProtectionSpecificConfig();
617 int directMapping = bs_read1( s );
629 if( p_cfg->extension.i_object_type != 5 && i_max_size > 0 && i_max_size - (bs_pos(s) - i_pos_start) >= 16 &&
630 bs_read( s, 11 ) == 0x2b7 )
632 p_cfg->extension.i_object_type = Mpeg4ReadAudioObjectType( s );
633 if( p_cfg->extension.i_object_type == 5 )
635 p_cfg->i_sbr = bs_read1( s );
636 if( p_cfg->i_sbr == 1 )
638 p_cfg->extension.i_samplerate = Mpeg4ReadAudioSamplerate( s );
639 if( i_max_size > 0 && i_max_size - (bs_pos(s) - i_pos_start) >= 12 && bs_read( s, 11 ) == 0x548 )
641 p_cfg->i_ps = bs_read1( s );
647 //fprintf( stderr, "Mpeg4ReadAudioSpecificInfo: t=%s(%d)f=%d c=%d sbr=%d\n",
648 // ppsz_otype[p_cfg->i_object_type], p_cfg->i_object_type, p_cfg->i_samplerate, p_cfg->i_channel, p_cfg->i_sbr );
650 i_bits = bs_pos(s) - i_pos_start;
652 *pi_extra = __MIN( ( i_bits + 7 ) / 8, LATM_MAX_EXTRA_SIZE );
653 for( i = 0; i < *pi_extra; i++ )
655 const int i_read = __MIN( 8, i_bits - 8*i );
656 p_extra[i] = bs_read( &s_sav, i_read ) << (8-i_read);
661 static int LatmGetValue( bs_t *s )
663 int i_bytes = bs_read( s, 2 );
666 for( i = 0; i < i_bytes; i++ )
667 v = (v << 8) + bs_read( s, 8 );
672 static int LatmReadStreamMuxConfiguration( latm_mux_t *m, bs_t *s )
678 i_mux_version = bs_read( s, 1 );
681 i_mux_versionA = bs_read( s, 1 );
683 if( i_mux_versionA != 0 ) /* support only A=0 */
686 memset( m, 0, sizeof(*m) );
688 if( i_mux_versionA == 0 )
690 if( i_mux_version == 1 )
692 LatmGetValue(s); /* taraBufferFullness */
696 m->b_same_time_framing = bs_read1( s );
697 m->i_sub_frames = 1 + bs_read( s, 6 );
698 m->i_programs = 1 + bs_read( s, 4 );
700 for( i_program = 0; i_program < m->i_programs; i_program++ )
704 m->pi_layers[i_program] = 1+bs_read( s, 3 );
706 for( i_layer = 0; i_layer < m->pi_layers[i_program]; i_layer++ )
708 latm_stream_t *st = &m->stream[m->i_streams];
711 m->pi_stream[i_program][i_layer] = m->i_streams;
712 st->i_program = i_program;
713 st->i_layer = i_layer;
715 b_previous_cfg = false;
716 if( i_program != 0 || i_layer != 0 )
717 b_previous_cfg = bs_read1( s );
721 assert( m->i_streams > 0 );
722 st->cfg = m->stream[m->i_streams-1].cfg;
727 if( i_mux_version == 1 )
728 i_cfg_size = LatmGetValue(s);
729 i_cfg_size -= Mpeg4ReadAudioSpecificInfo( &st->cfg, &st->i_extra, st->extra, s, i_cfg_size );
731 bs_skip( s, i_cfg_size );
734 st->i_frame_length_type = bs_read( s, 3 );
735 switch( st->i_frame_length_type )
739 bs_skip( s, 8 ); /* latmBufferFullnes */
740 if( !m->b_same_time_framing )
742 if( st->cfg.i_object_type == 6 || st->cfg.i_object_type == 20 ||
743 st->cfg.i_object_type == 8 || st->cfg.i_object_type == 24 )
745 bs_skip( s, 6 ); /* eFrameOffset */
751 st->i_frame_length = bs_read( s, 9 );
753 case 3: case 4: case 5:
754 st->i_frame_length_index = bs_read( s, 6 ); // celp
757 st->i_frame_length_index = bs_read( s, 1 ); // hvxc
769 if( i_mux_version == 1 )
771 m->i_other_data = LatmGetValue( s );
777 b_continue = bs_read1(s);
778 m->i_other_data = (m->i_other_data << 8) + bs_read( s, 8 );
779 } while( b_continue );
786 m->i_crc = bs_read( s, 8 );
791 static int LOASParse( decoder_t *p_dec, uint8_t *p_buffer, int i_buffer )
793 decoder_sys_t *p_sys = p_dec->p_sys;
796 int i_accumulated = 0;
798 bs_init( &s, p_buffer, i_buffer );
800 /* Read the stream mux configuration if present */
801 if( !bs_read1( &s ) )
803 if( !LatmReadStreamMuxConfiguration( &p_sys->latm, &s ) &&
804 p_sys->latm.i_streams > 0 )
806 const latm_stream_t *st = &p_sys->latm.stream[0];
808 p_sys->i_channels = st->cfg.i_channel;
809 p_sys->i_rate = st->cfg.i_samplerate;
810 p_sys->i_frame_length = st->cfg.i_frame_length;
812 if ( p_sys->i_channels > 0 && p_sys->i_rate > 0 &&
813 p_sys->i_frame_length > 0 )
815 /* FIXME And if it changes ? */
816 if( !p_dec->fmt_out.i_extra && st->i_extra > 0 )
818 p_dec->fmt_out.i_extra = st->i_extra;
819 p_dec->fmt_out.p_extra = malloc( st->i_extra );
820 if( !p_dec->fmt_out.p_extra )
822 p_dec->fmt_out.i_extra = 0;
825 memcpy( p_dec->fmt_out.p_extra, st->extra, st->i_extra );
827 p_sys->b_latm_cfg = true;
831 /* Wait for the configuration */
832 if( !p_sys->b_latm_cfg )
835 /* FIXME do we need to split the subframe into independent packet ? */
836 if( p_sys->latm.i_sub_frames > 1 )
837 msg_Err( p_dec, "latm sub frames not yet supported, please send a sample" );
839 for( i_sub = 0; i_sub < p_sys->latm.i_sub_frames; i_sub++ )
841 int pi_payload[LATM_MAX_PROGRAM][LATM_MAX_LAYER];
842 if( p_sys->latm.b_same_time_framing )
846 for( i_program = 0; i_program < p_sys->latm.i_programs; i_program++ )
849 for( i_layer = 0; i_layer < p_sys->latm.pi_layers[i_program]; i_layer++ )
851 latm_stream_t *st = &p_sys->latm.stream[p_sys->latm.pi_stream[i_program][i_layer]];
852 if( st->i_frame_length_type == 0 )
857 int i_tmp = bs_read( &s, 8 );
862 pi_payload[i_program][i_layer] = i_payload;
864 else if( st->i_frame_length_type == 1 )
866 pi_payload[i_program][i_layer] = st->i_frame_length / 8; /* XXX not correct */
868 else if( ( st->i_frame_length_type == 3 ) ||
869 ( st->i_frame_length_type == 5 ) ||
870 ( st->i_frame_length_type == 7 ) )
872 bs_skip( &s, 2 ); // muxSlotLengthCoded
873 pi_payload[i_program][i_layer] = 0; /* TODO */
877 pi_payload[i_program][i_layer] = 0; /* TODO */
882 for( i_program = 0; i_program < p_sys->latm.i_programs; i_program++ )
886 for( i_layer = 0; i_layer < p_sys->latm.pi_layers[i_program]; i_layer++ )
888 /* XXX we only extract 1 stream */
889 if( i_program != 0 || i_layer != 0 )
892 if( pi_payload[i_program][i_layer] <= 0 )
895 /* FIXME that's slow (and a bit ugly to write in place) */
896 for( i = 0; i < pi_payload[i_program][i_layer]; i++ )
897 p_buffer[i_accumulated++] = bs_read( &s, 8 );
903 const int i_chunks = bs_read( &s, 4 );
908 msg_Err( p_dec, "latm without same time frameing not yet supported, please send a sample" );
910 for( i_chunk = 0; i_chunk < i_chunks; i_chunk++ )
912 const int streamIndex = bs_read( &s, 4 );
913 latm_stream_t *st = &p_sys->latm.stream[streamIndex];
914 const int i_program = st->i_program;
915 const int i_layer = st->i_layer;
917 pi_program[i_chunk] = i_program;
918 pi_layer[i_chunk] = i_layer;
920 if( st->i_frame_length_type == 0 )
925 int i_tmp = bs_read( &s, 8 );
930 pi_payload[i_program][i_layer] = i_payload;
931 bs_skip( &s, 1 ); // auEndFlag
933 else if( st->i_frame_length_type == 1 )
935 pi_payload[i_program][i_layer] = st->i_frame_length / 8; /* XXX not correct */
937 else if( ( st->i_frame_length_type == 3 ) ||
938 ( st->i_frame_length_type == 5 ) ||
939 ( st->i_frame_length_type == 7 ) )
941 bs_read( &s, 2 ); // muxSlotLengthCoded
947 for( i_chunk = 0; i_chunk < i_chunks; i_chunk++ )
949 //const int i_program = pi_program[i_chunk];
950 //const int i_layer = pi_layer[i_chunk];
957 if( p_sys->latm.i_other_data > 0 )
959 /* Other data XXX we just ignore them */
963 return i_accumulated;
966 /****************************************************************************
967 * PacketizeStreamBlock: ADTS/LOAS packetizer
968 ****************************************************************************/
969 static void SetupOutput( decoder_t *p_dec, block_t *p_block );
970 static block_t *PacketizeStreamBlock( decoder_t *p_dec, block_t **pp_block )
972 decoder_sys_t *p_sys = p_dec->p_sys;
973 uint8_t p_header[ADTS_HEADER_SIZE + LOAS_HEADER_SIZE];
974 block_t *p_out_buffer;
977 if( !pp_block || !*pp_block ) return NULL;
979 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
981 if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
983 p_sys->i_state = STATE_NOSYNC;
984 block_BytestreamEmpty( &p_sys->bytestream );
986 date_Set( &p_sys->end_date, 0 );
987 block_Release( *pp_block );
991 if( !date_Get( &p_sys->end_date ) && (*pp_block)->i_pts <= VLC_TS_INVALID )
993 /* We've just started the stream, wait for the first PTS. */
994 block_Release( *pp_block );
998 block_BytestreamPush( &p_sys->bytestream, *pp_block );
1002 switch( p_sys->i_state )
1006 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
1009 /* Look for sync word - should be 0xfff(adts) or 0x2b7(loas) */
1010 if( p_header[0] == 0xff && (p_header[1] & 0xf6) == 0xf0 )
1012 if( p_sys->i_type != TYPE_ADTS )
1013 msg_Dbg( p_dec, "detected ADTS format" );
1015 p_sys->i_state = STATE_SYNC;
1016 p_sys->i_type = TYPE_ADTS;
1019 else if( p_header[0] == 0x56 && (p_header[1] & 0xe0) == 0xe0 )
1021 if( p_sys->i_type != TYPE_LOAS )
1022 msg_Dbg( p_dec, "detected LOAS format" );
1024 p_sys->i_state = STATE_SYNC;
1025 p_sys->i_type = TYPE_LOAS;
1028 block_SkipByte( &p_sys->bytestream );
1030 if( p_sys->i_state != STATE_SYNC )
1032 block_BytestreamFlush( &p_sys->bytestream );
1034 /* Need more data */
1039 /* New frame, set the Presentation Time Stamp */
1040 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
1041 if( p_sys->i_pts > VLC_TS_INVALID &&
1042 p_sys->i_pts != date_Get( &p_sys->end_date ) )
1044 date_Set( &p_sys->end_date, p_sys->i_pts );
1046 p_sys->i_state = STATE_HEADER;
1050 if( p_sys->i_type == TYPE_ADTS )
1052 /* Get ADTS frame header (ADTS_HEADER_SIZE bytes) */
1053 if( block_PeekBytes( &p_sys->bytestream, p_header,
1054 ADTS_HEADER_SIZE ) != VLC_SUCCESS )
1056 /* Need more data */
1060 /* Check if frame is valid and get frame info */
1061 p_sys->i_frame_size = ADTSSyncInfo( p_dec, p_header,
1064 &p_sys->i_frame_length,
1065 &p_sys->i_header_size );
1069 assert( p_sys->i_type == TYPE_LOAS );
1070 /* Get LOAS frame header (LOAS_HEADER_SIZE bytes) */
1071 if( block_PeekBytes( &p_sys->bytestream, p_header,
1072 LOAS_HEADER_SIZE ) != VLC_SUCCESS )
1074 /* Need more data */
1078 /* Check if frame is valid and get frame info */
1079 p_sys->i_frame_size = LOASSyncInfo( p_header, &p_sys->i_header_size );
1082 if( p_sys->i_frame_size <= 0 )
1084 msg_Dbg( p_dec, "emulated sync word" );
1085 block_SkipByte( &p_sys->bytestream );
1086 p_sys->i_state = STATE_NOSYNC;
1090 p_sys->i_state = STATE_NEXT_SYNC;
1092 case STATE_NEXT_SYNC:
1093 /* TODO: If p_block == NULL, flush the buffer without checking the
1095 if( p_sys->bytestream.p_block == NULL )
1097 p_sys->i_state = STATE_NOSYNC;
1098 block_BytestreamFlush( &p_sys->bytestream );
1102 /* Check if next expected frame contains the sync word */
1103 if( block_PeekOffsetBytes( &p_sys->bytestream, p_sys->i_frame_size
1104 + p_sys->i_header_size, p_header, 2 )
1107 /* Need more data */
1111 assert( (p_sys->i_type == TYPE_ADTS) || (p_sys->i_type == TYPE_LOAS) );
1112 if( ( ( p_sys->i_type == TYPE_ADTS ) &&
1113 ( p_header[0] != 0xff || (p_header[1] & 0xf6) != 0xf0 ) ) ||
1114 ( ( p_sys->i_type == TYPE_LOAS ) &&
1115 ( p_header[0] != 0x56 || (p_header[1] & 0xe0) != 0xe0 ) ) )
1117 msg_Dbg( p_dec, "emulated sync word "
1118 "(no sync on following frame)" );
1119 p_sys->i_state = STATE_NOSYNC;
1120 block_SkipByte( &p_sys->bytestream );
1124 p_sys->i_state = STATE_SEND_DATA;
1127 case STATE_GET_DATA:
1128 /* Make sure we have enough data.
1129 * (Not useful if we went through NEXT_SYNC) */
1130 if( block_WaitBytes( &p_sys->bytestream, p_sys->i_frame_size +
1131 p_sys->i_header_size) != VLC_SUCCESS )
1133 /* Need more data */
1136 p_sys->i_state = STATE_SEND_DATA;
1138 case STATE_SEND_DATA:
1139 /* When we reach this point we already know we have enough
1140 * data available. */
1142 p_out_buffer = block_Alloc( p_sys->i_frame_size );
1145 //p_dec->b_error = true;
1148 p_buf = p_out_buffer->p_buffer;
1150 /* Skip the ADTS/LOAS header */
1151 block_SkipBytes( &p_sys->bytestream, p_sys->i_header_size );
1153 if( p_sys->i_type == TYPE_ADTS )
1155 /* Copy the whole frame into the buffer */
1156 block_GetBytes( &p_sys->bytestream, p_buf, p_sys->i_frame_size );
1160 assert( p_sys->i_type == TYPE_LOAS );
1161 /* Copy the whole frame into the buffer and parse/extract it */
1162 block_GetBytes( &p_sys->bytestream, p_buf, p_sys->i_frame_size );
1163 p_out_buffer->i_buffer = LOASParse( p_dec, p_buf, p_sys->i_frame_size );
1164 if( p_out_buffer->i_buffer <= 0 )
1166 if( !p_sys->b_latm_cfg )
1167 msg_Warn( p_dec, "waiting for header" );
1169 block_Release( p_out_buffer );
1170 p_out_buffer = NULL;
1171 p_sys->i_state = STATE_NOSYNC;
1175 SetupOutput( p_dec, p_out_buffer );
1176 /* Make sure we don't reuse the same pts twice */
1177 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
1178 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = VLC_TS_INVALID;
1180 /* So p_block doesn't get re-added several times */
1181 *pp_block = block_BytestreamPop( &p_sys->bytestream );
1183 p_sys->i_state = STATE_NOSYNC;
1185 return p_out_buffer;
1192 /*****************************************************************************
1194 *****************************************************************************/
1195 static void SetupOutput( decoder_t *p_dec, block_t *p_block )
1197 decoder_sys_t *p_sys = p_dec->p_sys;
1199 if( p_dec->fmt_out.audio.i_rate != p_sys->i_rate )
1201 msg_Info( p_dec, "AAC channels: %d samplerate: %d",
1202 p_sys->i_channels, p_sys->i_rate );
1204 const mtime_t i_end_date = date_Get( &p_sys->end_date );
1205 date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
1206 date_Set( &p_sys->end_date, i_end_date );
1209 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
1210 p_dec->fmt_out.audio.i_channels = p_sys->i_channels;
1211 p_dec->fmt_out.audio.i_bytes_per_frame = p_sys->i_frame_size;
1212 p_dec->fmt_out.audio.i_frame_length = p_sys->i_frame_length;
1215 p_dec->fmt_out.audio.i_original_channels = p_sys->i_channels_conf;
1216 p_dec->fmt_out.audio.i_physical_channels = p_sys->i_channels_conf;
1219 p_block->i_pts = p_block->i_dts = date_Get( &p_sys->end_date );
1222 date_Increment( &p_sys->end_date, p_sys->i_frame_length ) - p_block->i_pts;
1225 /*****************************************************************************
1226 * ClosePacketizer: clean up the packetizer
1227 *****************************************************************************/
1228 static void ClosePacketizer( vlc_object_t *p_this )
1230 decoder_t *p_dec = (decoder_t *)p_this;
1231 decoder_sys_t *p_sys = p_dec->p_sys;
1233 block_BytestreamRelease( &p_sys->bytestream );
1235 free( p_dec->p_sys );