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 *****************************************************************************/
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
36 #include <vlc_codec.h>
37 #include <vlc_block.h>
40 #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
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;
159 static const int pi_sample_rates[16] =
161 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
162 16000, 12000, 11025, 8000, 7350, 0, 0, 0
165 #define ADTS_HEADER_SIZE 9
166 #define LOAS_HEADER_SIZE 3
168 /****************************************************************************
170 ****************************************************************************/
171 static int OpenPacketizer( vlc_object_t * );
172 static void ClosePacketizer( vlc_object_t * );
174 static block_t *PacketizeRawBlock ( decoder_t *, block_t ** );
175 static block_t *PacketizeStreamBlock( decoder_t *, block_t ** );
177 /*****************************************************************************
179 *****************************************************************************/
181 set_category( CAT_SOUT )
182 set_subcategory( SUBCAT_SOUT_PACKETIZER )
183 set_description( N_("MPEG4 audio packetizer") )
184 set_capability( "packetizer", 50 )
185 set_callbacks( OpenPacketizer, ClosePacketizer )
188 /*****************************************************************************
189 * OpenPacketizer: probe the packetizer and return score
190 *****************************************************************************/
191 static int OpenPacketizer( vlc_object_t *p_this )
193 decoder_t *p_dec = (decoder_t*)p_this;
194 decoder_sys_t *p_sys;
196 if( p_dec->fmt_in.i_codec != VLC_CODEC_MP4A )
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 )
207 p_sys->i_state = STATE_NOSYNC;
208 date_Set( &p_sys->end_date, 0 );
209 p_sys->bytestream = block_BytestreamInit();
210 p_sys->b_latm_cfg = false;
212 /* Set output properties */
213 p_dec->fmt_out.i_cat = AUDIO_ES;
214 p_dec->fmt_out.i_codec = VLC_CODEC_MP4A;
216 msg_Dbg( p_dec, "running MPEG4 audio packetizer" );
218 if( p_dec->fmt_in.i_extra > 0 )
220 uint8_t *p_config = (uint8_t*)p_dec->fmt_in.p_extra;
223 i_index = ( ( p_config[0] << 1 ) | ( p_config[1] >> 7 ) ) & 0x0f;
224 if( i_index != 0x0f )
226 p_dec->fmt_out.audio.i_rate = pi_sample_rates[i_index];
227 p_dec->fmt_out.audio.i_frame_length =
228 (( p_config[1] >> 2 ) & 0x01) ? 960 : 1024;
232 p_dec->fmt_out.audio.i_rate = ( ( p_config[1] & 0x7f ) << 17 ) |
233 ( p_config[2] << 9 ) | ( p_config[3] << 1 ) |
234 ( p_config[4] >> 7 );
235 p_dec->fmt_out.audio.i_frame_length =
236 (( p_config[4] >> 2 ) & 0x01) ? 960 : 1024;
239 p_dec->fmt_out.audio.i_channels =
240 (p_config[i_index == 0x0f ? 4 : 1] >> 3) & 0x0f;
242 msg_Dbg( p_dec, "AAC %dHz %d samples/frame",
243 p_dec->fmt_out.audio.i_rate,
244 p_dec->fmt_out.audio.i_frame_length );
246 date_Init( &p_sys->end_date, p_dec->fmt_out.audio.i_rate, 1 );
248 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
249 p_dec->fmt_out.p_extra = malloc( p_dec->fmt_in.i_extra );
250 if( !p_dec->fmt_out.p_extra )
252 p_dec->fmt_out.i_extra = 0;
255 memcpy( p_dec->fmt_out.p_extra, p_dec->fmt_in.p_extra,
256 p_dec->fmt_in.i_extra );
259 p_dec->pf_packetize = PacketizeRawBlock;
260 p_sys->i_type = TYPE_RAW;
264 msg_Dbg( p_dec, "no decoder specific info, must be an ADTS or LOAS stream" );
266 date_Init( &p_sys->end_date, p_dec->fmt_in.audio.i_rate, 1 );
268 /* We will try to create a AAC Config from adts/loas */
269 p_dec->fmt_out.i_extra = 0;
270 p_dec->fmt_out.p_extra = NULL;
273 p_dec->pf_packetize = PacketizeStreamBlock;
274 p_sys->i_type = TYPE_NONE;
280 /****************************************************************************
281 * PacketizeRawBlock: the whole thing
282 ****************************************************************************
283 * This function must be fed with complete frames.
284 ****************************************************************************/
285 static block_t *PacketizeRawBlock( decoder_t *p_dec, block_t **pp_block )
287 decoder_sys_t *p_sys = p_dec->p_sys;
290 if( !pp_block || !*pp_block ) return NULL;
292 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
294 date_Set( &p_sys->end_date, 0 );
295 block_Release( *pp_block );
300 *pp_block = NULL; /* Don't reuse this block */
302 if( !date_Get( &p_sys->end_date ) && p_block->i_pts <= VLC_TS_INVALID )
304 /* We've just started the stream, wait for the first PTS. */
305 block_Release( p_block );
308 else if( p_block->i_pts > VLC_TS_INVALID &&
309 p_block->i_pts != date_Get( &p_sys->end_date ) )
311 date_Set( &p_sys->end_date, p_block->i_pts );
314 p_block->i_pts = p_block->i_dts = date_Get( &p_sys->end_date );
316 p_block->i_length = date_Increment( &p_sys->end_date,
317 p_dec->fmt_out.audio.i_frame_length ) - p_block->i_pts;
322 /****************************************************************************
324 ****************************************************************************/
325 static int ADTSSyncInfo( decoder_t * p_dec, const uint8_t * p_buf,
326 unsigned int * pi_channels,
327 unsigned int * pi_sample_rate,
328 unsigned int * pi_frame_length,
329 unsigned int * pi_header_size )
331 int i_profile, i_sample_rate_idx, i_frame_size;
334 /* Fixed header between frames */
335 //int i_id = ( (p_buf[1] >> 3) & 0x01) ? 2 : 4; /* MPEG-2 or 4 */
336 b_crc = !(p_buf[1] & 0x01);
337 i_profile = p_buf[2] >> 6;
338 i_sample_rate_idx = (p_buf[2] >> 2) & 0x0f;
339 *pi_sample_rate = pi_sample_rates[i_sample_rate_idx];
340 //private_bit = (p_buf[2] >> 1) & 0x01;
341 *pi_channels = ((p_buf[2] & 0x01) << 2) | ((p_buf[3] >> 6) & 0x03);
342 //original_copy = (p_buf[3] >> 5) & 0x01;
343 //home = (p_buf[3] >> 4) & 0x01;
345 /* Variable header */
346 //copyright_id_bit = (p_buf[3] >> 3) & 0x01;
347 //copyright_id_start = (p_buf[3] >> 2) & 0x01;
348 i_frame_size = ((p_buf[3] & 0x03) << 11) | (p_buf[4] << 3) |
349 ((p_buf[5] >> 5) /*& 0x7*/);
350 //uint16_t buffer_fullness = ((p_buf[5] & 0x1f) << 6) | (p_buf[6] >> 2);
351 unsigned short i_raw_blocks_in_frame = p_buf[6] & 0x03;
353 if( !*pi_sample_rate || !*pi_channels || !i_frame_size )
355 msg_Warn( p_dec, "Invalid ADTS header" );
359 *pi_frame_length = 1024;
361 if( i_raw_blocks_in_frame == 0 )
365 msg_Warn( p_dec, "ADTS CRC not supported" );
366 //uint16_t crc = (p_buf[7] << 8) | p_buf[8];
371 msg_Err( p_dec, "Multiple blocks per frame in ADTS not supported" );
375 const uint8_t *p_pos = p_buf + 7;
377 uint16_t i_block_pos[3];
380 for( i = 0 ; i < i_raw_blocks_in_frame ; i++ )
381 { /* the 1st block's position is known ... */
382 i_block_pos[i] = (*p_pos << 8) | *(p_pos+1);
385 crc_block = (*p_pos << 8) | *(p_pos+1);
388 for( i = 0 ; i <= i_raw_blocks_in_frame ; i++ )
393 msg_Err( p_dec, "ADTS CRC not supported" );
394 //uint16_t crc = (*p_pos << 8) | *(p_pos+1);
402 /* Build the decoder specific info header */
403 if( !p_dec->fmt_out.i_extra )
405 p_dec->fmt_out.p_extra = malloc( 2 );
406 if( !p_dec->fmt_out.p_extra )
408 p_dec->fmt_out.i_extra = 0;
411 p_dec->fmt_out.i_extra = 2;
412 ((uint8_t *)p_dec->fmt_out.p_extra)[0] =
413 (i_profile + 1) << 3 | (i_sample_rate_idx >> 1);
414 ((uint8_t *)p_dec->fmt_out.p_extra)[1] =
415 ((i_sample_rate_idx & 0x01) << 7) | (*pi_channels <<3);
418 /* ADTS header length */
419 *pi_header_size = b_crc ? 9 : 7;
421 return i_frame_size - *pi_header_size;
424 /****************************************************************************
426 ****************************************************************************/
427 static int LOASSyncInfo( uint8_t p_header[LOAS_HEADER_SIZE], unsigned int *pi_header_size )
430 return ( ( p_header[1] & 0x1f ) << 8 ) + p_header[2];
433 static int Mpeg4GAProgramConfigElement( bs_t *s )
435 /* TODO compute channels count ? */
436 int i_tag = bs_read( s, 4 );
439 bs_skip( s, 2 + 4 ); // object type + sampling index
440 int i_num_front = bs_read( s, 4 );
441 int i_num_side = bs_read( s, 4 );
442 int i_num_back = bs_read( s, 4 );
443 int i_num_lfe = bs_read( s, 2 );
444 int i_num_assoc_data = bs_read( s, 3 );
445 int i_num_valid_cc = bs_read( s, 4 );
448 bs_skip( s, 4 ); // mono downmix
450 bs_skip( s, 4 ); // stereo downmix
452 bs_skip( s, 2+1 ); // matrix downmix + pseudo_surround
454 bs_skip( s, i_num_front * (1+4) );
455 bs_skip( s, i_num_side * (1+4) );
456 bs_skip( s, i_num_back * (1+4) );
457 bs_skip( s, i_num_lfe * (4) );
458 bs_skip( s, i_num_assoc_data * (4) );
459 bs_skip( s, i_num_valid_cc * (5) );
461 int i_comment = bs_read( s, 8 );
462 bs_skip( s, i_comment * 8 );
466 static int Mpeg4GASpecificConfig( mpeg4_cfg_t *p_cfg, bs_t *s )
468 p_cfg->i_frame_length = bs_read1(s) ? 960 : 1024;
470 if( bs_read1( s ) ) // depend on core coder
471 bs_skip( s, 14 ); // core coder delay
473 int i_extension_flag = bs_read1( s );
474 if( p_cfg->i_channel == 0 )
476 Mpeg4GAProgramConfigElement( s );
478 if( p_cfg->i_object_type == 6 || p_cfg->i_object_type == 20 )
479 bs_skip( s, 3 ); // layer
481 if( i_extension_flag )
483 if( p_cfg->i_object_type == 22 )
485 bs_skip( s, 5 + 11 ); // numOfSubFrame + layer length
487 if( p_cfg->i_object_type == 17 || p_cfg->i_object_type == 19 ||
488 p_cfg->i_object_type == 20 || p_cfg->i_object_type == 23 )
490 bs_skip( s, 1+1+1 ); // ER data : section scale spectral */
492 if( bs_read1( s ) ) // extension 3
493 fprintf( stderr, "Mpeg4GASpecificConfig: error 1\n" );
498 static int Mpeg4ReadAudioObjectType( bs_t *s )
500 int i_type = bs_read( s, 5 );
502 i_type = 32 + bs_read( s, 6 );
506 static int Mpeg4ReadAudioSamplerate( bs_t *s )
508 int i_index = bs_read( s, 4 );
509 if( i_index != 0x0f )
510 return pi_sample_rates[i_index];
511 return bs_read( s, 24 );
514 static int Mpeg4ReadAudioSpecificInfo( mpeg4_cfg_t *p_cfg, int *pi_extra, uint8_t *p_extra, bs_t *s, int i_max_size )
517 static const char *ppsz_otype[] = {
519 "AAC Main", "AAC LC", "AAC SSR", "AAC LTP", "SBR", "AAC Scalable",
522 "Reserved", "Reserved",
524 "Main Synthetic", "Wavetables Synthesis", "General MIDI",
525 "Algorithmic Synthesis and Audio FX",
528 "ER AAC LTP", "ER AAC Scalable", "ER TwinVQ", "ER BSAC", "ER AAC LD",
529 "ER CELP", "ER HVXC", "ER HILN", "ER Parametric",
531 "PS", "Reserved", "Escape",
532 "Layer 1", "Layer 2", "Layer 3",
536 const int i_pos_start = bs_pos( s );
541 memset( p_cfg, 0, sizeof(*p_cfg) );
544 p_cfg->i_object_type = Mpeg4ReadAudioObjectType( s );
545 p_cfg->i_samplerate = Mpeg4ReadAudioSamplerate( s );
547 p_cfg->i_channel = bs_read( s, 4 );
548 if( p_cfg->i_channel == 7 )
549 p_cfg->i_channel = 8; // 7.1
550 else if( p_cfg->i_channel >= 8 )
551 p_cfg->i_channel = -1;
555 p_cfg->extension.i_object_type = 0;
556 p_cfg->extension.i_samplerate = 0;
557 if( p_cfg->i_object_type == 5 || p_cfg->i_object_type == 29 )
560 if( p_cfg->i_object_type == 29 )
562 p_cfg->extension.i_object_type = 5;
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();
606 // ALSSpecificConfig();
612 switch( p_cfg->i_object_type )
614 case 17: case 19: case 20: case 21: case 22: case 23:
615 case 24: case 25: case 26: case 27:
617 int epConfig = bs_read( s, 2 );
618 if( epConfig == 2 || epConfig == 3 )
620 //ErrorProtectionSpecificConfig();
624 int directMapping = bs_read1( s );
636 if( p_cfg->extension.i_object_type != 5 && i_max_size > 0 && i_max_size - (bs_pos(s) - i_pos_start) >= 16 &&
637 bs_read( s, 11 ) == 0x2b7 )
639 p_cfg->extension.i_object_type = Mpeg4ReadAudioObjectType( s );
640 if( p_cfg->extension.i_object_type == 5 )
642 p_cfg->i_sbr = bs_read1( s );
643 if( p_cfg->i_sbr == 1 )
645 p_cfg->extension.i_samplerate = Mpeg4ReadAudioSamplerate( s );
646 if( i_max_size > 0 && i_max_size - (bs_pos(s) - i_pos_start) >= 12 && bs_read( s, 11 ) == 0x548 )
648 p_cfg->i_ps = bs_read1( s );
654 //fprintf( stderr, "Mpeg4ReadAudioSpecificInfo: t=%s(%d)f=%d c=%d sbr=%d\n",
655 // ppsz_otype[p_cfg->i_object_type], p_cfg->i_object_type, p_cfg->i_samplerate, p_cfg->i_channel, p_cfg->i_sbr );
657 i_bits = bs_pos(s) - i_pos_start;
659 *pi_extra = __MIN( ( i_bits + 7 ) / 8, LATM_MAX_EXTRA_SIZE );
660 for( i = 0; i < *pi_extra; i++ )
662 const int i_read = __MIN( 8, i_bits - 8*i );
663 p_extra[i] = bs_read( &s_sav, i_read ) << (8-i_read);
668 static int LatmGetValue( bs_t *s )
670 int i_bytes = bs_read( s, 2 );
673 for( i = 0; i < i_bytes; i++ )
674 v = (v << 8) + bs_read( s, 8 );
679 static int LatmReadStreamMuxConfiguration( latm_mux_t *m, bs_t *s )
685 i_mux_version = bs_read( s, 1 );
688 i_mux_versionA = bs_read( s, 1 );
690 if( i_mux_versionA != 0 ) /* support only A=0 */
693 memset( m, 0, sizeof(*m) );
695 if( i_mux_versionA == 0 )
697 if( i_mux_version == 1 )
699 LatmGetValue(s); /* taraBufferFullness */
703 m->b_same_time_framing = bs_read1( s );
704 m->i_sub_frames = 1 + bs_read( s, 6 );
705 m->i_programs = 1 + bs_read( s, 4 );
707 for( i_program = 0; i_program < m->i_programs; i_program++ )
711 m->pi_layers[i_program] = 1+bs_read( s, 3 );
713 for( i_layer = 0; i_layer < m->pi_layers[i_program]; i_layer++ )
715 latm_stream_t *st = &m->stream[m->i_streams];
718 m->pi_stream[i_program][i_layer] = m->i_streams;
719 st->i_program = i_program;
720 st->i_layer = i_layer;
722 b_previous_cfg = false;
723 if( i_program != 0 || i_layer != 0 )
724 b_previous_cfg = bs_read1( s );
728 assert( m->i_streams > 0 );
729 st->cfg = m->stream[m->i_streams-1].cfg;
734 if( i_mux_version == 1 )
735 i_cfg_size = LatmGetValue(s);
736 i_cfg_size -= Mpeg4ReadAudioSpecificInfo( &st->cfg, &st->i_extra, st->extra, s, i_cfg_size );
738 bs_skip( s, i_cfg_size );
741 st->i_frame_length_type = bs_read( s, 3 );
742 switch( st->i_frame_length_type )
746 bs_skip( s, 8 ); /* latmBufferFullnes */
747 if( !m->b_same_time_framing )
749 if( st->cfg.i_object_type == 6 || st->cfg.i_object_type == 20 ||
750 st->cfg.i_object_type == 8 || st->cfg.i_object_type == 24 )
752 bs_skip( s, 6 ); /* eFrameOffset */
758 st->i_frame_length = bs_read( s, 9 );
760 case 3: case 4: case 5:
761 st->i_frame_length_index = bs_read( s, 6 ); // celp
764 st->i_frame_length_index = bs_read( s, 1 ); // hvxc
776 if( i_mux_version == 1 )
778 m->i_other_data = LatmGetValue( s );
784 b_continue = bs_read1(s);
785 m->i_other_data = (m->i_other_data << 8) + bs_read( s, 8 );
786 } while( b_continue );
793 m->i_crc = bs_read( s, 8 );
798 static int LOASParse( decoder_t *p_dec, uint8_t *p_buffer, int i_buffer )
800 decoder_sys_t *p_sys = p_dec->p_sys;
803 int i_accumulated = 0;
805 bs_init( &s, p_buffer, i_buffer );
807 /* Read the stream mux configuration if present */
808 if( !bs_read1( &s ) )
810 if( !LatmReadStreamMuxConfiguration( &p_sys->latm, &s ) &&
811 p_sys->latm.i_streams > 0 )
813 const latm_stream_t *st = &p_sys->latm.stream[0];
815 p_sys->i_channels = st->cfg.i_channel;
816 p_sys->i_rate = st->cfg.i_samplerate;
817 p_sys->i_frame_length = st->cfg.i_frame_length;
819 /* FIXME And if it changes ? */
820 if( !p_dec->fmt_out.i_extra && st->i_extra > 0 )
822 p_dec->fmt_out.i_extra = st->i_extra;
823 p_dec->fmt_out.p_extra = malloc( st->i_extra );
824 if( !p_dec->fmt_out.p_extra )
826 p_dec->fmt_out.i_extra = 0;
829 memcpy( p_dec->fmt_out.p_extra, st->extra, st->i_extra );
832 p_sys->b_latm_cfg = true;
835 /* Wait for the configuration */
836 if( !p_sys->b_latm_cfg )
839 /* FIXME do we need to split the subframe into independent packet ? */
840 if( p_sys->latm.i_sub_frames > 1 )
841 msg_Err( p_dec, "latm sub frames not yet supported, please send a sample" );
843 for( i_sub = 0; i_sub < p_sys->latm.i_sub_frames; i_sub++ )
845 int pi_payload[LATM_MAX_PROGRAM][LATM_MAX_LAYER];
846 if( p_sys->latm.b_same_time_framing )
850 for( i_program = 0; i_program < p_sys->latm.i_programs; i_program++ )
853 for( i_layer = 0; i_layer < p_sys->latm.pi_layers[i_program]; i_layer++ )
855 latm_stream_t *st = &p_sys->latm.stream[p_sys->latm.pi_stream[i_program][i_layer]];
856 if( st->i_frame_length_type == 0 )
861 int i_tmp = bs_read( &s, 8 );
866 pi_payload[i_program][i_layer] = i_payload;
868 else if( st->i_frame_length_type == 1 )
870 pi_payload[i_program][i_layer] = st->i_frame_length / 8; /* XXX not correct */
872 else if( ( st->i_frame_length_type == 3 ) ||
873 ( st->i_frame_length_type == 5 ) ||
874 ( st->i_frame_length_type == 7 ) )
876 bs_skip( &s, 2 ); // muxSlotLengthCoded
877 pi_payload[i_program][i_layer] = 0; /* TODO */
881 pi_payload[i_program][i_layer] = 0; /* TODO */
886 for( i_program = 0; i_program < p_sys->latm.i_programs; i_program++ )
890 for( i_layer = 0; i_layer < p_sys->latm.pi_layers[i_program]; i_layer++ )
892 /* XXX we only extract 1 stream */
893 if( i_program != 0 || i_layer != 0 )
896 if( pi_payload[i_program][i_layer] <= 0 )
899 /* FIXME that's slow (and a bit ugly to write in place) */
900 for( i = 0; i < pi_payload[i_program][i_layer]; i++ )
901 p_buffer[i_accumulated++] = bs_read( &s, 8 );
907 const int i_chunks = bs_read( &s, 4 );
912 msg_Err( p_dec, "latm without same time frameing not yet supported, please send a sample" );
914 for( i_chunk = 0; i_chunk < i_chunks; i_chunk++ )
916 const int streamIndex = bs_read( &s, 4 );
917 latm_stream_t *st = &p_sys->latm.stream[streamIndex];
918 const int i_program = st->i_program;
919 const int i_layer = st->i_layer;
921 pi_program[i_chunk] = i_program;
922 pi_layer[i_chunk] = i_layer;
924 if( st->i_frame_length_type == 0 )
929 int i_tmp = bs_read( &s, 8 );
934 pi_payload[i_program][i_layer] = i_payload;
935 bs_skip( &s, 1 ); // auEndFlag
937 else if( st->i_frame_length_type == 1 )
939 pi_payload[i_program][i_layer] = st->i_frame_length / 8; /* XXX not correct */
941 else if( ( st->i_frame_length_type == 3 ) ||
942 ( st->i_frame_length_type == 5 ) ||
943 ( st->i_frame_length_type == 7 ) )
945 bs_read( &s, 2 ); // muxSlotLengthCoded
951 for( i_chunk = 0; i_chunk < i_chunks; i_chunk++ )
953 //const int i_program = pi_program[i_chunk];
954 //const int i_layer = pi_layer[i_chunk];
961 if( p_sys->latm.i_other_data > 0 )
963 /* Other data XXX we just ignore them */
967 return i_accumulated;
970 /****************************************************************************
971 * PacketizeStreamBlock: ADTS/LOAS packetizer
972 ****************************************************************************/
973 static void SetupOutput( decoder_t *p_dec, block_t *p_block );
974 static block_t *PacketizeStreamBlock( decoder_t *p_dec, block_t **pp_block )
976 decoder_sys_t *p_sys = p_dec->p_sys;
977 uint8_t p_header[ADTS_HEADER_SIZE + LOAS_HEADER_SIZE];
978 block_t *p_out_buffer;
981 if( !pp_block || !*pp_block ) return NULL;
983 if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
985 if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
987 p_sys->i_state = STATE_NOSYNC;
988 block_BytestreamEmpty( &p_sys->bytestream );
990 date_Set( &p_sys->end_date, 0 );
991 block_Release( *pp_block );
995 if( !date_Get( &p_sys->end_date ) && (*pp_block)->i_pts <= VLC_TS_INVALID )
997 /* We've just started the stream, wait for the first PTS. */
998 block_Release( *pp_block );
1002 block_BytestreamPush( &p_sys->bytestream, *pp_block );
1006 switch( p_sys->i_state )
1010 while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
1013 /* Look for sync word - should be 0xfff(adts) or 0x2b7(loas) */
1014 if( p_header[0] == 0xff && (p_header[1] & 0xf6) == 0xf0 )
1016 if( p_sys->i_type != TYPE_ADTS )
1017 msg_Dbg( p_dec, "detected ADTS format" );
1019 p_sys->i_state = STATE_SYNC;
1020 p_sys->i_type = TYPE_ADTS;
1023 else if( p_header[0] == 0x56 && (p_header[1] & 0xe0) == 0xe0 )
1025 if( p_sys->i_type != TYPE_LOAS )
1026 msg_Dbg( p_dec, "detected LOAS format" );
1028 p_sys->i_state = STATE_SYNC;
1029 p_sys->i_type = TYPE_LOAS;
1032 block_SkipByte( &p_sys->bytestream );
1034 if( p_sys->i_state != STATE_SYNC )
1036 block_BytestreamFlush( &p_sys->bytestream );
1038 /* Need more data */
1043 /* New frame, set the Presentation Time Stamp */
1044 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
1045 if( p_sys->i_pts > VLC_TS_INVALID &&
1046 p_sys->i_pts != date_Get( &p_sys->end_date ) )
1048 date_Set( &p_sys->end_date, p_sys->i_pts );
1050 p_sys->i_state = STATE_HEADER;
1054 if( p_sys->i_type == TYPE_ADTS )
1056 /* Get ADTS frame header (ADTS_HEADER_SIZE bytes) */
1057 if( block_PeekBytes( &p_sys->bytestream, p_header,
1058 ADTS_HEADER_SIZE ) != VLC_SUCCESS )
1060 /* Need more data */
1064 /* Check if frame is valid and get frame info */
1065 p_sys->i_frame_size = ADTSSyncInfo( p_dec, p_header,
1068 &p_sys->i_frame_length,
1069 &p_sys->i_header_size );
1073 assert( p_sys->i_type == TYPE_LOAS );
1074 /* Get LOAS frame header (LOAS_HEADER_SIZE bytes) */
1075 if( block_PeekBytes( &p_sys->bytestream, p_header,
1076 LOAS_HEADER_SIZE ) != VLC_SUCCESS )
1078 /* Need more data */
1082 /* Check if frame is valid and get frame info */
1083 p_sys->i_frame_size = LOASSyncInfo( p_header, &p_sys->i_header_size );
1086 if( p_sys->i_frame_size <= 0 )
1088 msg_Dbg( p_dec, "emulated sync word" );
1089 block_SkipByte( &p_sys->bytestream );
1090 p_sys->i_state = STATE_NOSYNC;
1094 p_sys->i_state = STATE_NEXT_SYNC;
1096 case STATE_NEXT_SYNC:
1097 /* TODO: If p_block == NULL, flush the buffer without checking the
1099 if( p_sys->bytestream.p_block == NULL )
1101 p_sys->i_state = STATE_NOSYNC;
1102 block_BytestreamFlush( &p_sys->bytestream );
1106 /* Check if next expected frame contains the sync word */
1107 if( block_PeekOffsetBytes( &p_sys->bytestream, p_sys->i_frame_size
1108 + p_sys->i_header_size, p_header, 2 )
1111 /* Need more data */
1115 assert( (p_sys->i_type == TYPE_ADTS) || (p_sys->i_type == TYPE_LOAS) );
1116 if( ( ( p_sys->i_type == TYPE_ADTS ) &&
1117 ( p_header[0] != 0xff || (p_header[1] & 0xf6) != 0xf0 ) ) ||
1118 ( ( p_sys->i_type == TYPE_LOAS ) &&
1119 ( p_header[0] != 0x56 || (p_header[1] & 0xe0) != 0xe0 ) ) )
1121 msg_Dbg( p_dec, "emulated sync word "
1122 "(no sync on following frame)" );
1123 p_sys->i_state = STATE_NOSYNC;
1124 block_SkipByte( &p_sys->bytestream );
1128 p_sys->i_state = STATE_SEND_DATA;
1131 case STATE_GET_DATA:
1132 /* Make sure we have enough data.
1133 * (Not useful if we went through NEXT_SYNC) */
1134 if( block_WaitBytes( &p_sys->bytestream, p_sys->i_frame_size +
1135 p_sys->i_header_size) != VLC_SUCCESS )
1137 /* Need more data */
1140 p_sys->i_state = STATE_SEND_DATA;
1142 case STATE_SEND_DATA:
1143 /* When we reach this point we already know we have enough
1144 * data available. */
1146 p_out_buffer = block_New( p_dec, p_sys->i_frame_size );
1149 //p_dec->b_error = true;
1152 p_buf = p_out_buffer->p_buffer;
1154 /* Skip the ADTS/LOAS header */
1155 block_SkipBytes( &p_sys->bytestream, p_sys->i_header_size );
1157 if( p_sys->i_type == TYPE_ADTS )
1159 /* Copy the whole frame into the buffer */
1160 block_GetBytes( &p_sys->bytestream, p_buf, p_sys->i_frame_size );
1164 assert( p_sys->i_type == TYPE_LOAS );
1165 /* Copy the whole frame into the buffer and parse/extract it */
1166 block_GetBytes( &p_sys->bytestream, p_buf, p_sys->i_frame_size );
1167 p_out_buffer->i_buffer = LOASParse( p_dec, p_buf, p_sys->i_frame_size );
1168 if( p_out_buffer->i_buffer <= 0 )
1170 if( !p_sys->b_latm_cfg )
1171 msg_Warn( p_dec, "waiting for header" );
1173 block_Release( p_out_buffer );
1174 p_out_buffer = NULL;
1175 p_sys->i_state = STATE_NOSYNC;
1179 SetupOutput( p_dec, p_out_buffer );
1180 /* Make sure we don't reuse the same pts twice */
1181 if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
1182 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = VLC_TS_INVALID;
1184 /* So p_block doesn't get re-added several times */
1185 *pp_block = block_BytestreamPop( &p_sys->bytestream );
1187 p_sys->i_state = STATE_NOSYNC;
1189 return p_out_buffer;
1196 /*****************************************************************************
1198 *****************************************************************************/
1199 static void SetupOutput( decoder_t *p_dec, block_t *p_block )
1201 decoder_sys_t *p_sys = p_dec->p_sys;
1203 if( p_dec->fmt_out.audio.i_rate != p_sys->i_rate )
1205 msg_Info( p_dec, "AAC channels: %d samplerate: %d",
1206 p_sys->i_channels, p_sys->i_rate );
1208 const mtime_t i_end_date = date_Get( &p_sys->end_date );
1209 date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
1210 date_Set( &p_sys->end_date, i_end_date );
1213 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
1214 p_dec->fmt_out.audio.i_channels = p_sys->i_channels;
1215 p_dec->fmt_out.audio.i_bytes_per_frame = p_sys->i_frame_size;
1216 p_dec->fmt_out.audio.i_frame_length = p_sys->i_frame_length;
1219 p_dec->fmt_out.audio.i_original_channels = p_sys->i_channels_conf;
1220 p_dec->fmt_out.audio.i_physical_channels =
1221 p_sys->i_channels_conf & AOUT_CHAN_PHYSMASK;
1224 p_block->i_pts = p_block->i_dts = date_Get( &p_sys->end_date );
1227 date_Increment( &p_sys->end_date, p_sys->i_frame_length ) - p_block->i_pts;
1230 /*****************************************************************************
1231 * ClosePacketizer: clean up the packetizer
1232 *****************************************************************************/
1233 static void ClosePacketizer( vlc_object_t *p_this )
1235 decoder_t *p_dec = (decoder_t *)p_this;
1236 decoder_sys_t *p_sys = p_dec->p_sys;
1238 block_BytestreamRelease( &p_sys->bytestream );
1240 free( p_dec->p_sys );