1 /*****************************************************************************
2 * mpeg4audio.c: parse and packetize an MPEG 4 audio stream
3 *****************************************************************************
4 * Copyright (C) 2001, 2002, 2006 the VideoLAN team
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
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.
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.
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 *****************************************************************************/
25 /*****************************************************************************
27 *****************************************************************************/
35 #include <vlc_codec.h>
36 #include <vlc_block.h>
38 #include <vlc_codecs.h>
39 #include <vlc_input.h>
42 #include "vlc_block_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
74 int i_frame_length; // 1024 or 960
78 #define LATM_MAX_EXTRA_SIZE 64
84 int i_frame_length_type;
85 int i_frame_length; // type 1
86 int i_frame_length_index; // type 3 4 5 6 7
90 /* Raw configuration */
92 uint8_t extra[LATM_MAX_EXTRA_SIZE];
96 #define LATM_MAX_LAYER (8)
97 #define LATM_MAX_PROGRAM (16)
100 int b_same_time_framing;
104 int pi_layers[LATM_MAX_PROGRAM];
106 int pi_stream[LATM_MAX_PROGRAM][LATM_MAX_LAYER];
109 latm_stream_t stream[LATM_MAX_PROGRAM*LATM_MAX_LAYER];
112 int i_crc; /* -1 if not set */
123 block_bytestream_t bytestream;
128 audio_date_t end_date;
132 unsigned int i_channels;
133 unsigned int i_rate, i_frame_length, i_header_size;
138 vlc_bool_t b_latm_cfg;
158 static const int pi_sample_rates[16] =
160 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
161 16000, 12000, 11025, 8000, 7350, 0, 0, 0
164 #define ADTS_HEADER_SIZE 9
165 #define LOAS_HEADER_SIZE 3
167 /****************************************************************************
169 ****************************************************************************/
170 static int OpenPacketizer( vlc_object_t * );
171 static void ClosePacketizer( vlc_object_t * );
173 static block_t *PacketizeRawBlock ( decoder_t *, block_t ** );
174 static block_t *PacketizeStreamBlock( decoder_t *, block_t ** );
176 /*****************************************************************************
178 *****************************************************************************/
180 set_category( CAT_SOUT );
181 set_subcategory( SUBCAT_SOUT_PACKETIZER );
182 set_description( _("MPEG4 audio packetizer") );
183 set_capability( "packetizer", 50 );
184 set_callbacks( OpenPacketizer, ClosePacketizer );
187 /*****************************************************************************
188 * OpenPacketizer: probe the packetizer and return score
189 *****************************************************************************/
190 static int OpenPacketizer( vlc_object_t *p_this )
192 decoder_t *p_dec = (decoder_t*)p_this;
193 decoder_sys_t *p_sys;
195 if( p_dec->fmt_in.i_codec != VLC_FOURCC( 'm', 'p', '4', 'a' ) )
200 /* Allocate the memory needed to store the decoder's structure */
201 if( ( p_dec->p_sys = p_sys =
202 (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
204 msg_Err( p_dec, "out of memory" );
209 p_sys->i_state = STATE_NOSYNC;
210 aout_DateSet( &p_sys->end_date, 0 );
211 p_sys->bytestream = block_BytestreamInit();
212 p_sys->i_input_rate = INPUT_RATE_DEFAULT;
213 p_sys->b_latm_cfg = VLC_FALSE;
215 /* Set output properties */
216 p_dec->fmt_out.i_cat = AUDIO_ES;
217 p_dec->fmt_out.i_codec = VLC_FOURCC('m','p','4','a');
219 msg_Dbg( p_dec, "running MPEG4 audio packetizer" );
221 if( p_dec->fmt_in.i_extra > 0 )
223 uint8_t *p_config = (uint8_t*)p_dec->fmt_in.p_extra;
226 i_index = ( ( p_config[0] << 1 ) | ( p_config[1] >> 7 ) ) & 0x0f;
227 if( i_index != 0x0f )
229 p_dec->fmt_out.audio.i_rate = pi_sample_rates[i_index];
230 p_dec->fmt_out.audio.i_frame_length =
231 (( p_config[1] >> 2 ) & 0x01) ? 960 : 1024;
235 p_dec->fmt_out.audio.i_rate = ( ( p_config[1] & 0x7f ) << 17 ) |
236 ( p_config[2] << 9 ) | ( p_config[3] << 1 ) |
237 ( p_config[4] >> 7 );
238 p_dec->fmt_out.audio.i_frame_length =
239 (( p_config[4] >> 2 ) & 0x01) ? 960 : 1024;
242 p_dec->fmt_out.audio.i_channels =
243 (p_config[i_index == 0x0f ? 4 : 1] >> 3) & 0x0f;
245 msg_Dbg( p_dec, "AAC %dHz %d samples/frame",
246 p_dec->fmt_out.audio.i_rate,
247 p_dec->fmt_out.audio.i_frame_length );
249 aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
251 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
252 p_dec->fmt_out.p_extra = malloc( p_dec->fmt_in.i_extra );
253 if( !p_dec->fmt_out.p_extra )
255 p_dec->fmt_out.i_extra = 0;
258 memcpy( p_dec->fmt_out.p_extra, p_dec->fmt_in.p_extra,
259 p_dec->fmt_in.i_extra );
262 p_dec->pf_packetize = PacketizeRawBlock;
263 p_sys->i_type = TYPE_RAW;
267 msg_Dbg( p_dec, "no decoder specific info, must be an ADTS or LOAS stream" );
269 aout_DateInit( &p_sys->end_date, p_dec->fmt_in.audio.i_rate );
271 /* We will try to create a AAC Config from adts/loas */
272 p_dec->fmt_out.i_extra = 0;
273 p_dec->fmt_out.p_extra = NULL;
276 p_dec->pf_packetize = PacketizeStreamBlock;
277 p_sys->i_type = TYPE_NONE;
283 /****************************************************************************
284 * PacketizeRawBlock: the whole thing
285 ****************************************************************************
286 * This function must be fed with complete frames.
287 ****************************************************************************/
288 static block_t *PacketizeRawBlock( decoder_t *p_dec, block_t **pp_block )
290 decoder_sys_t *p_sys = p_dec->p_sys;
293 if( !pp_block || !*pp_block ) return NULL;
295 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
297 //aout_DateSet( &p_sys->end_date, 0 );
298 block_Release( *pp_block );
303 *pp_block = NULL; /* Don't reuse this block */
305 if( !aout_DateGet( &p_sys->end_date ) && !p_block->i_pts )
307 /* We've just started the stream, wait for the first PTS. */
308 block_Release( p_block );
311 else if( p_block->i_pts != 0 &&
312 p_block->i_pts != aout_DateGet( &p_sys->end_date ) )
314 aout_DateSet( &p_sys->end_date, p_block->i_pts );
317 p_block->i_pts = p_block->i_dts = aout_DateGet( &p_sys->end_date );
319 p_block->i_length = aout_DateIncrement( &p_sys->end_date,
320 p_dec->fmt_out.audio.i_frame_length * p_sys->i_input_rate / INPUT_RATE_DEFAULT ) - p_block->i_pts;
325 /****************************************************************************
327 ****************************************************************************/
328 static int ADTSSyncInfo( decoder_t * p_dec, const byte_t * p_buf,
329 unsigned int * pi_channels,
330 unsigned int * pi_sample_rate,
331 unsigned int * pi_frame_length,
332 unsigned int * pi_header_size )
334 int i_profile, i_sample_rate_idx, i_frame_size;
337 /* Fixed header between frames */
338 //int i_id = ( (p_buf[1] >> 3) & 0x01) ? 2 : 4; /* MPEG-2 or 4 */
339 b_crc = !(p_buf[1] & 0x01);
340 i_profile = p_buf[2] >> 6;
341 i_sample_rate_idx = (p_buf[2] >> 2) & 0x0f;
342 *pi_sample_rate = pi_sample_rates[i_sample_rate_idx];
343 //private_bit = (p_buf[2] >> 1) & 0x01;
344 *pi_channels = ((p_buf[2] & 0x01) << 2) | ((p_buf[3] >> 6) & 0x03);
345 //original_copy = (p_buf[3] >> 5) & 0x01;
346 //home = (p_buf[3] >> 4) & 0x01;
348 /* Variable header */
349 //copyright_id_bit = (p_buf[3] >> 3) & 0x01;
350 //copyright_id_start = (p_buf[3] >> 2) & 0x01;
351 i_frame_size = ((p_buf[3] & 0x03) << 11) | (p_buf[4] << 3) |
352 ((p_buf[5] >> 5) /*& 0x7*/);
353 //uint16_t buffer_fullness = ((p_buf[5] & 0x1f) << 6) | (p_buf[6] >> 2);
354 unsigned short i_raw_blocks_in_frame = p_buf[6] & 0x03;
356 if( !*pi_sample_rate || !*pi_channels || !i_frame_size )
358 msg_Warn( p_dec, "Invalid ADTS header" );
362 *pi_frame_length = 1024;
364 if( i_raw_blocks_in_frame == 0 )
368 msg_Warn( p_dec, "ADTS CRC not supported" );
369 //uint16_t crc = (p_buf[7] << 8) | p_buf[8];
374 msg_Err( p_dec, "Multiple blocks per frame in ADTS not supported" );
378 const uint8_t *p_pos = p_buf + 7;
380 uint16_t i_block_pos[3];
383 for( i = 0 ; i < i_raw_blocks_in_frame ; i++ )
384 { /* the 1st block's position is known ... */
385 i_block_pos[i] = (*p_pos << 8) | *(p_pos+1);
388 crc_block = (*p_pos << 8) | *(p_pos+1);
391 for( i = 0 ; i <= i_raw_blocks_in_frame ; i++ )
396 msg_Err( p_dec, "ADTS CRC not supported" );
397 //uint16_t crc = (*p_pos << 8) | *(p_pos+1);
405 /* Build the decoder specific info header */
406 if( !p_dec->fmt_out.i_extra )
408 p_dec->fmt_out.p_extra = malloc( 2 );
409 if( !p_dec->fmt_out.p_extra )
411 p_dec->fmt_out.i_extra = 0;
414 p_dec->fmt_out.i_extra = 2;
415 ((uint8_t *)p_dec->fmt_out.p_extra)[0] =
416 (i_profile + 1) << 3 | (i_sample_rate_idx >> 1);
417 ((uint8_t *)p_dec->fmt_out.p_extra)[1] =
418 ((i_sample_rate_idx & 0x01) << 7) | (*pi_channels <<3);
421 /* ADTS header length */
422 *pi_header_size = b_crc ? 9 : 7;
424 return i_frame_size - *pi_header_size;
427 /****************************************************************************
429 ****************************************************************************/
430 static int LOASSyncInfo( uint8_t p_header[LOAS_HEADER_SIZE], unsigned int *pi_header_size )
433 return ( ( p_header[1] & 0x1f ) << 8 ) + p_header[2];
436 static int Mpeg4GAProgramConfigElement( bs_t *s )
438 /* TODO compute channels count ? */
439 int i_tag = bs_read( s, 4 );
442 bs_skip( s, 2 + 4 ); // object type + sampling index
443 int i_num_front = bs_read( s, 4 );
444 int i_num_side = bs_read( s, 4 );
445 int i_num_back = bs_read( s, 4 );
446 int i_num_lfe = bs_read( s, 2 );
447 int i_num_assoc_data = bs_read( s, 3 );
448 int i_num_valid_cc = bs_read( s, 4 );
451 bs_skip( s, 4 ); // mono downmix
453 bs_skip( s, 4 ); // stereo downmix
455 bs_skip( s, 2+1 ); // matrix downmix + pseudo_surround
457 bs_skip( s, i_num_front * (1+4) );
458 bs_skip( s, i_num_side * (1+4) );
459 bs_skip( s, i_num_back * (1+4) );
460 bs_skip( s, i_num_lfe * (4) );
461 bs_skip( s, i_num_assoc_data * (4) );
462 bs_skip( s, i_num_valid_cc * (5) );
464 int i_comment = bs_read( s, 8 );
465 bs_skip( s, i_comment * 8 );
469 static int Mpeg4GASpecificConfig( mpeg4_cfg_t *p_cfg, bs_t *s )
471 p_cfg->i_frame_length = bs_read1(s) ? 960 : 1024;
473 if( bs_read1( s ) ) // depend on core coder
474 bs_skip( s, 14 ); // core coder delay
476 int i_extension_flag = bs_read1( s );
477 if( p_cfg->i_channel == 0 )
479 Mpeg4GAProgramConfigElement( s );
481 if( p_cfg->i_object_type == 6 || p_cfg->i_object_type == 20 )
482 bs_skip( s, 3 ); // layer
484 if( i_extension_flag )
486 if( p_cfg->i_object_type == 22 )
488 bs_skip( s, 5 + 11 ); // numOfSubFrame + layer length
490 if( p_cfg->i_object_type == 17 || p_cfg->i_object_type == 19 ||
491 p_cfg->i_object_type == 20 || p_cfg->i_object_type == 23 )
493 bs_skip( s, 1+1+1 ); // ER data : section scale spectral */
495 if( bs_read1( s ) ) // extension 3
496 fprintf( stderr, "Mpeg4GASpecificConfig: error 1\n" );
501 static int Mpeg4ReadAudioObjectType( bs_t *s )
503 int i_type = bs_read( s, 5 );
505 i_type += bs_read( s, 6 );
509 static int Mpeg4ReadAudioSamplerate( bs_t *s )
511 int i_index = bs_read( s, 4 );
512 if( i_index != 0x0f )
513 return pi_sample_rates[i_index];
514 return bs_read( s, 24 );
517 static int Mpeg4ReadAudioSpecificInfo( mpeg4_cfg_t *p_cfg, int *pi_extra, uint8_t *p_extra, bs_t *s, int i_max_size )
520 static const char *ppsz_otype[] = {
522 "AAC Main", "AAC LC", "AAC SSR", "AAC LTP", "SBR", "AAC Scalable",
525 "Reserved", "Reserved",
527 "Main Synthetic", "Wavetables Synthesis", "General MIDI",
528 "Algorithmic Synthesis and Audio FX",
531 "ER AAC LTP", "ER AAC Scalable", "ER TwinVQ", "ER BSAC", "ER AAC LD",
532 "ER CELP", "ER HVXC", "ER HILN", "ER Parametric",
534 "Reserved", "Reserved", "Escape",
535 "Layer 1", "Layer 2", "Layer 3",
539 const int i_pos_start = bs_pos( s );
544 memset( p_cfg, 0, sizeof(*p_cfg) );
547 p_cfg->i_object_type = Mpeg4ReadAudioObjectType( s );
548 p_cfg->i_samplerate = Mpeg4ReadAudioSamplerate( s );
550 p_cfg->i_channel = bs_read( s, 4 );
551 if( p_cfg->i_channel == 7 )
552 p_cfg->i_channel = 8; // 7.1
553 else if( p_cfg->i_channel >= 8 )
554 p_cfg->i_channel = -1;
557 p_cfg->extension.i_object_type = 0;
558 p_cfg->extension.i_samplerate = 0;
559 if( p_cfg->i_object_type == 5 )
562 p_cfg->extension.i_object_type = p_cfg->i_object_type;
563 p_cfg->extension.i_samplerate = Mpeg4ReadAudioSamplerate( s );
565 p_cfg->i_object_type = Mpeg4ReadAudioObjectType( s );
568 switch( p_cfg->i_object_type )
570 case 1: case 2: case 3: case 4:
572 case 17: case 19: case 20: case 21: case 22: case 23:
573 Mpeg4GASpecificConfig( p_cfg, s );
576 // CelpSpecificConfig();
579 // HvxcSpecificConfig();
582 // TTSSSpecificConfig();
584 case 13: case 14: case 15: case 16:
585 // StructuredAudioSpecificConfig();
588 // ERCelpSpecificConfig();
591 // ERHvxcSpecificConfig();
594 // ParametricSpecificConfig();
597 // SSCSpecificConfig();
599 case 32: case 33: case 34:
600 // MPEG_1_2_SpecificConfig();
603 // DSTSpecificConfig();
609 switch( p_cfg->i_object_type )
611 case 17: case 19: case 20: case 21: case 22: case 23:
612 case 24: case 25: case 26: case 27:
614 int epConfig = bs_read( s, 2 );
615 if( epConfig == 2 || epConfig == 3 )
617 //ErrorProtectionSpecificConfig();
621 int directMapping = bs_read1( s );
633 if( p_cfg->extension.i_object_type != 5 && i_max_size > 0 && i_max_size - (bs_pos(s) - i_pos_start) >= 16 &&
634 bs_read( s, 11 ) == 0x2b7 )
636 p_cfg->extension.i_object_type = Mpeg4ReadAudioObjectType( s );
637 if( p_cfg->extension.i_object_type == 5 )
639 p_cfg->i_sbr = bs_read1( s );
640 if( p_cfg->i_sbr == 1 )
641 p_cfg->extension.i_samplerate = Mpeg4ReadAudioSamplerate( s );
645 //fprintf( stderr, "Mpeg4ReadAudioSpecificInfo: t=%s(%d)f=%d c=%d sbr=%d\n",
646 // 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 i_bits = bs_pos(s) - i_pos_start;
650 *pi_extra = ( i_bits + 7 ) / 8;
651 for( i = 0; i < __MIN( LATM_MAX_EXTRA_SIZE, *pi_extra ); i++ )
653 const int i_read = __MIN( 8, i_bits - 8*i );
654 p_extra[i] = bs_read( &s_sav, i_read ) << (8-i_read);
659 static int LatmGetValue( bs_t *s )
661 int i_bytes = bs_read( s, 2 );
664 for( i = 0; i < i_bytes; i++ )
665 v = (v << 8) + bs_read( s, 8 );
670 static int LatmReadStreamMuxConfiguration( latm_mux_t *m, bs_t *s )
676 i_mux_version = bs_read( s, 1 );
679 i_mux_versionA = bs_read( s, 1 );
681 if( i_mux_versionA != 0 ) /* support only A=0 */
684 memset( m, 0, sizeof(*m) );
686 if( i_mux_versionA == 0 )
688 if( i_mux_version == 1 )
690 LatmGetValue(s); /* taraBufferFullness */
694 m->b_same_time_framing = bs_read1( s );
695 m->i_sub_frames = 1 + bs_read( s, 6 );
696 m->i_programs = 1 + bs_read( s, 4 );
698 for( i_program = 0; i_program < m->i_programs; i_program++ )
702 m->pi_layers[i_program] = 1+bs_read( s, 3 );
704 for( i_layer = 0; i_layer < m->pi_layers[i_program]; i_layer++ )
706 latm_stream_t *st = &m->stream[m->i_streams];
707 vlc_bool_t b_previous_cfg;
709 m->pi_stream[i_program][i_layer] = m->i_streams;
710 st->i_program = i_program;
711 st->i_layer = i_layer;
713 b_previous_cfg = VLC_FALSE;
714 if( i_program != 0 || i_layer != 0 )
715 b_previous_cfg = bs_read1( s );
719 assert( m->i_streams > 0 );
720 st->cfg = m->stream[m->i_streams-1].cfg;
725 if( i_mux_version == 1 )
726 i_cfg_size = LatmGetValue(s);
727 i_cfg_size -= Mpeg4ReadAudioSpecificInfo( &st->cfg, &st->i_extra, st->extra, s, i_cfg_size );
729 bs_skip( s, i_cfg_size );
732 st->i_frame_length_type = bs_read( s, 3 );
733 switch( st->i_frame_length_type )
737 bs_skip( s, 8 ); /* latmBufferFullnes */
738 if( !m->b_same_time_framing )
740 if( st->cfg.i_object_type == 6 || st->cfg.i_object_type == 20 ||
741 st->cfg.i_object_type == 8 || st->cfg.i_object_type == 24 )
743 bs_skip( s, 6 ); /* eFrameOffset */
749 st->i_frame_length = bs_read( s, 9 );
751 case 3: case 4: case 5:
752 st->i_frame_length_index = bs_read( s, 6 ); // celp
755 st->i_frame_length_index = bs_read( s, 1 ); // hvxc
767 if( i_mux_version == 1 )
769 m->i_other_data = LatmGetValue( s );
775 b_continue = bs_read1(s);
776 m->i_other_data = (m->i_other_data << 8) + bs_read( s, 8 );
777 } while( b_continue );
784 m->i_crc = bs_read( s, 8 );
789 static int LOASParse( decoder_t *p_dec, uint8_t *p_buffer, int i_buffer )
791 decoder_sys_t *p_sys = p_dec->p_sys;
794 int i_accumulated = 0;
796 bs_init( &s, p_buffer, i_buffer );
798 /* Read the stream mux configuration if present */
799 if( !bs_read1( &s ) )
801 if( !LatmReadStreamMuxConfiguration( &p_sys->latm, &s ) &&
802 p_sys->latm.i_streams > 0 )
804 const latm_stream_t *st = &p_sys->latm.stream[0];
806 p_sys->i_channels = st->cfg.i_channel;
807 p_sys->i_rate = st->cfg.i_samplerate;
808 p_sys->i_frame_length = st->cfg.i_frame_length;
810 /* FIXME And if it changes ? */
811 if( !p_dec->fmt_out.i_extra && st->i_extra > 0 )
813 p_dec->fmt_out.i_extra = st->i_extra;
814 p_dec->fmt_out.p_extra = malloc( st->i_extra );
815 if( !p_dec->fmt_out.p_extra )
817 p_dec->fmt_out.i_extra = 0;
820 memcpy( p_dec->fmt_out.p_extra, st->extra, st->i_extra );
823 p_sys->b_latm_cfg = VLC_TRUE;
826 /* Wait for the configuration */
827 if( !p_sys->b_latm_cfg )
830 /* FIXME do we need to split the subframe into independant packet ? */
831 if( p_sys->latm.i_sub_frames > 1 )
832 msg_Err( p_dec, "latm sub frames not yet supported, please send a sample" );
834 for( i_sub = 0; i_sub < p_sys->latm.i_sub_frames; i_sub++ )
836 int pi_payload[LATM_MAX_PROGRAM][LATM_MAX_LAYER];
837 if( p_sys->latm.b_same_time_framing )
841 for( i_program = 0; i_program < p_sys->latm.i_programs; i_program++ )
844 for( i_layer = 0; i_layer < p_sys->latm.pi_layers[i_program]; i_layer++ )
846 latm_stream_t *st = &p_sys->latm.stream[p_sys->latm.pi_stream[i_program][i_layer]];
847 if( st->i_frame_length_type == 0 )
852 int i_tmp = bs_read( &s, 8 );
857 pi_payload[i_program][i_layer] = i_payload;
859 else if( st->i_frame_length_type == 1 )
861 pi_payload[i_program][i_layer] = st->i_frame_length / 8; /* XXX not correct */
863 else if( ( st->i_frame_length_type == 3 ) ||
864 ( st->i_frame_length_type == 5 ) ||
865 ( st->i_frame_length_type == 7 ) )
867 bs_skip( &s, 2 ); // muxSlotLengthCoded
868 pi_payload[i_program][i_layer] = 0; /* TODO */
872 pi_payload[i_program][i_layer] = 0; /* TODO */
877 for( i_program = 0; i_program < p_sys->latm.i_programs; i_program++ )
881 for( i_layer = 0; i_layer < p_sys->latm.pi_layers[i_program]; i_layer++ )
883 /* XXX we only extract 1 stream */
884 if( i_program != 0 || i_layer != 0 )
887 if( pi_payload[i_program][i_layer] <= 0 )
890 /* FIXME that's slow (and a bit ugly to write in place) */
891 for( i = 0; i < pi_payload[i_program][i_layer]; i++ )
892 p_buffer[i_accumulated++] = bs_read( &s, 8 );
898 const int i_chunks = bs_read( &s, 4 );
903 msg_Err( p_dec, "latm without same time frameing not yet supported, please send a sample" );
905 for( i_chunk = 0; i_chunk < i_chunks; i_chunk++ )
907 const int streamIndex = bs_read( &s, 4 );
908 latm_stream_t *st = &p_sys->latm.stream[streamIndex];
909 const int i_program = st->i_program;
910 const int i_layer = st->i_layer;
912 pi_program[i_chunk] = i_program;
913 pi_layer[i_chunk] = i_layer;
915 if( st->i_frame_length_type == 0 )
920 int i_tmp = bs_read( &s, 8 );
925 pi_payload[i_program][i_layer] = i_payload;
926 bs_skip( &s, 1 ); // auEndFlag
928 else if( st->i_frame_length_type == 1 )
930 pi_payload[i_program][i_layer] = st->i_frame_length / 8; /* XXX not correct */
932 else if( ( st->i_frame_length_type == 3 ) ||
933 ( st->i_frame_length_type == 5 ) ||
934 ( st->i_frame_length_type == 7 ) )
936 bs_read( &s, 2 ); // muxSlotLengthCoded
942 for( i_chunk = 0; i_chunk < i_chunks; i_chunk++ )
944 //const int i_program = pi_program[i_chunk];
945 //const int i_layer = pi_layer[i_chunk];
952 if( p_sys->latm.i_other_data > 0 )
954 /* Other data XXX we just ignore them */
958 return i_accumulated;
961 /****************************************************************************
962 * PacketizeStreamBlock: ADTS/LOAS packetizer
963 ****************************************************************************/
964 static void SetupOutput( decoder_t *p_dec, block_t *p_block );
965 static block_t *PacketizeStreamBlock( decoder_t *p_dec, block_t **pp_block )
967 decoder_sys_t *p_sys = p_dec->p_sys;
968 uint8_t p_header[ADTS_HEADER_SIZE + LOAS_HEADER_SIZE];
969 block_t *p_out_buffer;
972 if( !pp_block || !*pp_block ) return NULL;
974 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
976 if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
978 p_sys->i_state = STATE_NOSYNC;
979 block_BytestreamFlush( &p_sys->bytestream );
981 //aout_DateSet( &p_sys->end_date, 0 );
982 block_Release( *pp_block );
986 if( !aout_DateGet( &p_sys->end_date ) && !(*pp_block)->i_pts )
988 /* We've just started the stream, wait for the first PTS. */
989 block_Release( *pp_block );
993 if( (*pp_block)->i_rate > 0 )
994 p_sys->i_input_rate = (*pp_block)->i_rate;
996 block_BytestreamPush( &p_sys->bytestream, *pp_block );
1000 switch( p_sys->i_state )
1004 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
1007 /* Look for sync word - should be 0xfff(adts) or 0x2b7(loas) */
1008 if( p_header[0] == 0xff && (p_header[1] & 0xf6) == 0xf0 )
1010 if( p_sys->i_type != TYPE_ADTS )
1011 msg_Dbg( p_dec, "detected ADTS format" );
1013 p_sys->i_state = STATE_SYNC;
1014 p_sys->i_type = TYPE_ADTS;
1017 else if( p_header[0] == 0x56 && (p_header[1] & 0xe0) == 0xe0 )
1019 if( p_sys->i_type != TYPE_LOAS )
1020 msg_Dbg( p_dec, "detected LOAS format" );
1022 p_sys->i_state = STATE_SYNC;
1023 p_sys->i_type = TYPE_LOAS;
1026 block_SkipByte( &p_sys->bytestream );
1028 if( p_sys->i_state != STATE_SYNC )
1030 block_BytestreamFlush( &p_sys->bytestream );
1032 /* Need more data */
1037 /* New frame, set the Presentation Time Stamp */
1038 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
1039 if( p_sys->i_pts != 0 &&
1040 p_sys->i_pts != aout_DateGet( &p_sys->end_date ) )
1042 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
1044 p_sys->i_state = STATE_HEADER;
1048 if( p_sys->i_type == TYPE_ADTS )
1050 /* Get ADTS frame header (ADTS_HEADER_SIZE bytes) */
1051 if( block_PeekBytes( &p_sys->bytestream, p_header,
1052 ADTS_HEADER_SIZE ) != VLC_SUCCESS )
1054 /* Need more data */
1058 /* Check if frame is valid and get frame info */
1059 p_sys->i_frame_size = ADTSSyncInfo( p_dec, p_header,
1062 &p_sys->i_frame_length,
1063 &p_sys->i_header_size );
1067 assert( p_sys->i_type == TYPE_LOAS );
1068 /* Get LOAS frame header (LOAS_HEADER_SIZE bytes) */
1069 if( block_PeekBytes( &p_sys->bytestream, p_header,
1070 LOAS_HEADER_SIZE ) != VLC_SUCCESS )
1072 /* Need more data */
1076 /* Check if frame is valid and get frame info */
1077 p_sys->i_frame_size = LOASSyncInfo( p_header, &p_sys->i_header_size );
1080 if( p_sys->i_frame_size <= 0 )
1082 msg_Dbg( p_dec, "emulated sync word" );
1083 block_SkipByte( &p_sys->bytestream );
1084 p_sys->i_state = STATE_NOSYNC;
1088 p_sys->i_state = STATE_NEXT_SYNC;
1090 case STATE_NEXT_SYNC:
1091 /* TODO: If p_block == NULL, flush the buffer without checking the
1093 if( p_sys->bytestream.p_block == NULL )
1095 p_sys->i_state = STATE_NOSYNC;
1096 block_BytestreamFlush( &p_sys->bytestream );
1100 /* Check if next expected frame contains the sync word */
1101 if( block_PeekOffsetBytes( &p_sys->bytestream, p_sys->i_frame_size
1102 + p_sys->i_header_size, p_header, 2 )
1105 /* Need more data */
1109 assert( (p_sys->i_type == TYPE_ADTS) || (p_sys->i_type == TYPE_LOAS) );
1110 if( ( ( p_sys->i_type == TYPE_ADTS ) &&
1111 ( p_header[0] != 0xff || (p_header[1] & 0xf6) != 0xf0 ) ) ||
1112 ( ( p_sys->i_type == TYPE_LOAS ) &&
1113 ( p_header[0] != 0x56 || (p_header[1] & 0xe0) != 0xe0 ) ) )
1115 msg_Dbg( p_dec, "emulated sync word "
1116 "(no sync on following frame)" );
1117 p_sys->i_state = STATE_NOSYNC;
1118 block_SkipByte( &p_sys->bytestream );
1122 p_sys->i_state = STATE_SEND_DATA;
1125 case STATE_GET_DATA:
1126 /* Make sure we have enough data.
1127 * (Not useful if we went through NEXT_SYNC) */
1128 if( block_WaitBytes( &p_sys->bytestream, p_sys->i_frame_size +
1129 p_sys->i_header_size) != VLC_SUCCESS )
1131 /* Need more data */
1134 p_sys->i_state = STATE_SEND_DATA;
1136 case STATE_SEND_DATA:
1137 /* When we reach this point we already know we have enough
1138 * data available. */
1140 p_out_buffer = block_New( p_dec, p_sys->i_frame_size );
1143 //p_dec->b_error = VLC_TRUE;
1146 p_buf = p_out_buffer->p_buffer;
1148 /* Skip the ADTS/LOAS header */
1149 block_SkipBytes( &p_sys->bytestream, p_sys->i_header_size );
1151 if( p_sys->i_type == TYPE_ADTS )
1153 /* Copy the whole frame into the buffer */
1154 block_GetBytes( &p_sys->bytestream, p_buf, p_sys->i_frame_size );
1158 assert( p_sys->i_type == TYPE_LOAS );
1159 /* Copy the whole frame into the buffer and parse/extract it */
1160 block_GetBytes( &p_sys->bytestream, p_buf, p_sys->i_frame_size );
1161 p_out_buffer->i_buffer = LOASParse( p_dec, p_buf, p_sys->i_frame_size );
1162 if( p_out_buffer->i_buffer <= 0 )
1164 if( !p_sys->b_latm_cfg )
1165 msg_Warn( p_dec, "waiting for header" );
1167 block_Release( p_out_buffer );
1168 p_out_buffer = NULL;
1169 p_sys->i_state = STATE_NOSYNC;
1173 SetupOutput( p_dec, p_out_buffer );
1174 /* Make sure we don't reuse the same pts twice */
1175 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
1176 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = 0;
1178 /* So p_block doesn't get re-added several times */
1179 *pp_block = block_BytestreamPop( &p_sys->bytestream );
1181 p_sys->i_state = STATE_NOSYNC;
1183 return p_out_buffer;
1190 /*****************************************************************************
1192 *****************************************************************************/
1193 static void SetupOutput( decoder_t *p_dec, block_t *p_block )
1195 decoder_sys_t *p_sys = p_dec->p_sys;
1197 if( p_dec->fmt_out.audio.i_rate != p_sys->i_rate )
1199 msg_Info( p_dec, "AAC channels: %d samplerate: %d",
1200 p_sys->i_channels, p_sys->i_rate );
1202 aout_DateInit( &p_sys->end_date, p_sys->i_rate );
1203 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
1206 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
1207 p_dec->fmt_out.audio.i_channels = p_sys->i_channels;
1208 p_dec->fmt_out.audio.i_bytes_per_frame = p_sys->i_frame_size;
1209 p_dec->fmt_out.audio.i_frame_length = p_sys->i_frame_length;
1212 p_dec->fmt_out.audio.i_original_channels = p_sys->i_channels_conf;
1213 p_dec->fmt_out.audio.i_physical_channels =
1214 p_sys->i_channels_conf & AOUT_CHAN_PHYSMASK;
1217 p_block->i_pts = p_block->i_dts = aout_DateGet( &p_sys->end_date );
1219 p_block->i_length = aout_DateIncrement( &p_sys->end_date,
1220 p_sys->i_frame_length * p_sys->i_input_rate / INPUT_RATE_DEFAULT ) -
1224 /*****************************************************************************
1225 * ClosePacketizer: clean up the packetizer
1226 *****************************************************************************/
1227 static void ClosePacketizer( vlc_object_t *p_this )
1229 decoder_t *p_dec = (decoder_t *)p_this;
1230 decoder_sys_t *p_sys = p_dec->p_sys;
1232 block_BytestreamRelease( &p_sys->bytestream );
1234 free( p_dec->p_sys );