[nihav.git] / nihav-mpeg / src / codecs / aac / info.rs

use nihav_core::codecs::{DecoderResult, DecoderError};
use nihav_core::io::bitreader::*;
use std::fmt;

#[allow(non_camel_case_types)]
#[derive(Clone,Copy,PartialEq)]
pub enum M4AType {
    None,
    Main,
    LC,
    SSR,
    LTP,
    SBR,
    Scalable,
    TwinVQ,
    CELP,
    HVXC,
    TTSI,
    MainSynth,
    WavetableSynth,
    GeneralMIDI,
    Algorithmic,
    ER_AAC_LC,
    ER_AAC_LTP,
    ER_AAC_Scalable,
    ER_TwinVQ,
    ER_BSAC,
    ER_AAC_LD,
    ER_CELP,
    ER_HVXC,
    ER_HILN,
    ER_Parametric,
    SSC,
    PS,
    MPEGSurround,
    Layer1,
    Layer2,
    Layer3,
    DST,
    ALS,
    SLS,
    SLSNonCore,
    ER_AAC_ELD,
    SMRSimple,
    SMRMain,
    Reserved,
    Unknown,
}

const M4A_TYPES: &[M4AType] = &[
    M4AType::None,              M4AType::Main,      M4AType::LC,            M4AType::SSR,
    M4AType::LTP,               M4AType::SBR,       M4AType::Scalable,      M4AType::TwinVQ,
    M4AType::CELP,              M4AType::HVXC,      M4AType::Reserved,      M4AType::Reserved,
    M4AType::TTSI,              M4AType::MainSynth, M4AType::WavetableSynth, M4AType::GeneralMIDI,
    M4AType::Algorithmic,       M4AType::ER_AAC_LC, M4AType::Reserved,      M4AType::ER_AAC_LTP,
    M4AType::ER_AAC_Scalable,   M4AType::ER_TwinVQ, M4AType::ER_BSAC,       M4AType::ER_AAC_LD,
    M4AType::ER_CELP,           M4AType::ER_HVXC,   M4AType::ER_HILN,       M4AType::ER_Parametric,
    M4AType::SSC,               M4AType::PS,        M4AType::MPEGSurround,  M4AType::Reserved /*escape*/,
    M4AType::Layer1,            M4AType::Layer2,    M4AType::Layer3,        M4AType::DST,
    M4AType::ALS,               M4AType::SLS,       M4AType::SLSNonCore,    M4AType::ER_AAC_ELD,
    M4AType::SMRSimple,         M4AType::SMRMain,
];
const M4A_TYPE_NAMES: &[&str] = &[
    "None", "AAC Main", "AAC LC", "AAC SSR", "AAC LTP", "SBR", "AAC Scalable", "TwinVQ", "CELP", "HVXC",
    /*"(reserved10)", "(reserved11)", */ "TTSI",
    "Main synthetic", "Wavetable synthesis", "General MIDI", "Algorithmic Synthesis and Audio FX",
    "ER AAC LC", /*"(reserved18)",*/ "ER AAC LTP", "ER AAC Scalable", "ER TwinVQ", "ER BSAC", "ER AAC LD",
    "ER CELP", "ER HVXC", "ER HILN", "ER Parametric", "SSC", "PS", "MPEG Surround", /*"(escape)",*/
    "Layer-1", "Layer-2", "Layer-3", "DST", "ALS", "SLS", "SLS non-core", "ER AAC ELD", "SMR Simple", "SMR Main",
    "(reserved)", "(unknown)",
];

impl fmt::Display for M4AType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", M4A_TYPE_NAMES[*self as usize])
    }
}

const AAC_SAMPLE_RATES: [u32; 16] = [
    96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
    16000, 12000, 11025,  8000,  7350, 0, 0, 0
];

const AAC_CHANNELS: [usize; 8] = [ 0, 1, 2, 3, 4, 5, 6, 8 ];

pub struct M4AInfo {
    pub otype:          M4AType,
    pub srate:          u32,
    pub channels:       usize,
    pub samples:        usize,
    pub sbr_ps_info:    Option<(u32, usize)>,
    pub sbr_present:    bool,
    pub ps_present:     bool,
}

impl M4AInfo {
    pub fn new() -> Self {
        Self {
            otype:          M4AType::None,
            srate:          0,
            channels:       0,
            samples:        0,
            sbr_ps_info:    Option::None,
            sbr_present:    false,
            ps_present:     false,
        }
    }
    fn read_object_type(br: &mut BitReader) -> DecoderResult<M4AType> {
        let otypeidx;
        if br.peek(5) == 31 {
                                                          br.skip(5)?;
            otypeidx                                    = (br.read(6)? as usize) + 32;
        } else {
            otypeidx                                    = br.read(5)? as usize;
        }
        if otypeidx >= M4A_TYPES.len() {
            Ok(M4AType::Unknown)
        } else {
            Ok(M4A_TYPES[otypeidx])
        }
    }
    fn read_sampling_frequency(br: &mut BitReader) -> DecoderResult<u32> {
        if br.peek(4) == 15 {
            let srate                                   = br.read(24)?;
            Ok(srate)
        } else {
            let srate_idx                               = br.read(4)? as usize;
            Ok(AAC_SAMPLE_RATES[srate_idx])
        }
    }
    fn read_channel_config(br: &mut BitReader) -> DecoderResult<usize> {
        let chidx                                       = br.read(4)? as usize;
        if chidx < AAC_CHANNELS.len() {
            Ok(AAC_CHANNELS[chidx])
        } else {
            Ok(chidx)
        }
    }
    pub fn read(&mut self, src: &[u8]) -> DecoderResult<()> {
        let mut br = BitReader::new(src, BitReaderMode::BE);
        self.otype = Self::read_object_type(&mut br)?;
        self.srate = Self::read_sampling_frequency(&mut br)?;
        validate!(self.srate > 0);
        self.channels = Self::read_channel_config(&mut br)?;

        if (self.otype == M4AType::SBR) || (self.otype == M4AType::PS) {
            let ext_srate = Self::read_sampling_frequency(&mut br)?;
            self.otype = Self::read_object_type(&mut br)?;
            let ext_chans;
            if self.otype == M4AType::ER_BSAC {
                ext_chans = Self::read_channel_config(&mut br)?;
            } else {
                ext_chans = 0;
            }
            self.sbr_ps_info = Some((ext_srate, ext_chans));
        }

        match self.otype {
            M4AType::Main | M4AType::LC | M4AType::SSR | M4AType::Scalable | M4AType::TwinVQ |
            M4AType::ER_AAC_LC | M4AType::ER_AAC_LTP | M4AType::ER_AAC_Scalable | M4AType::ER_TwinVQ |
            M4AType::ER_BSAC | M4AType::ER_AAC_LD => {
                // GASpecificConfig
                    let short_frame                     = br.read_bool()?;
                    self.samples = if short_frame { 960 } else { 1024 };
                    let depends_on_core                 = br.read_bool()?;
                    if depends_on_core {
                        let _delay                      = br.read(14)?;
                    }
                    let extension_flag                  = br.read_bool()?;
                    if self.channels == 0 {
                        let (channels, sf_code) = skimp_through_program_config_element(&mut br)?;
                        validate!(channels > 0);
                        self.channels = channels;
                        validate!(AAC_SAMPLE_RATES[sf_code] != 0);
                        self.srate = AAC_SAMPLE_RATES[sf_code];
                    }
                    if (self.otype == M4AType::Scalable) || (self.otype == M4AType::ER_AAC_Scalable) {
                        let _layer                      = br.read(3)?;
                    }
                    if extension_flag {
                        if self.otype == M4AType::ER_BSAC {
                            let _num_subframes          = br.read(5)? as usize;
                            let _layer_length           = br.read(11)?;
                        }
                        if (self.otype == M4AType::ER_AAC_LC) ||
                           (self.otype == M4AType::ER_AAC_LTP) ||
                           (self.otype == M4AType::ER_AAC_Scalable) ||
                           (self.otype == M4AType::ER_AAC_LD) {
                            let _section_data_resilience    = br.read_bool()?;
                            let _scalefactors_resilience    = br.read_bool()?;
                            let _spectral_data_resilience   = br.read_bool()?;
                        }
                        let extension_flag3             = br.read_bool()?;
                        if extension_flag3 {
                            unimplemented!("version3 extensions");
                        }
                    }
                },
            M4AType::CELP => { unimplemented!("CELP config"); },
            M4AType::HVXC => { unimplemented!("HVXC config"); },
            M4AType::TTSI => { unimplemented!("TTS config"); },
            M4AType::MainSynth | M4AType::WavetableSynth | M4AType::GeneralMIDI | M4AType::Algorithmic => { unimplemented!("structured audio config"); },
            M4AType::ER_CELP => { unimplemented!("ER CELP config"); },
            M4AType::ER_HVXC => { unimplemented!("ER HVXC config"); },
            M4AType::ER_HILN | M4AType::ER_Parametric => { unimplemented!("parametric config"); },
            M4AType::SSC => { unimplemented!("SSC config"); },
            M4AType::MPEGSurround => {
                                                        br.skip(1)?; // sacPayloadEmbedding
                    unimplemented!("MPEG Surround config");
                },
            M4AType::Layer1 | M4AType::Layer2 | M4AType::Layer3 => { unimplemented!("MPEG Layer 1/2/3 config"); },
            M4AType::DST => { unimplemented!("DST config"); },
            M4AType::ALS => {
                                                        br.skip(5)?; // fillBits
                    unimplemented!("ALS config");
                },
            M4AType::SLS | M4AType::SLSNonCore => { unimplemented!("SLS config"); },
            M4AType::ER_AAC_ELD => { unimplemented!("ELD config"); },
            M4AType::SMRSimple | M4AType::SMRMain => { unimplemented!("symbolic music config"); },
            _ => {},
        };
        match self.otype {
            M4AType::ER_AAC_LC | M4AType::ER_AAC_LTP | M4AType::ER_AAC_Scalable | M4AType::ER_TwinVQ |
            M4AType::ER_BSAC | M4AType::ER_AAC_LD | M4AType::ER_CELP | M4AType::ER_HVXC |
            M4AType::ER_HILN | M4AType::ER_Parametric | M4AType::ER_AAC_ELD => {
                    let ep_config                       = br.read(2)?;
                    if (ep_config == 2) || (ep_config == 3) {
                        unimplemented!("error protection config");
                    }
                    if ep_config == 3 {
                        let direct_mapping              = br.read_bool()?;
                        validate!(direct_mapping);
                    }
                },
            _ => {},
        };
        if self.sbr_ps_info.is_some() && (br.left() >= 16) {
            let sync                                    = br.read(11)?;
            if sync == 0x2B7 {
                let ext_otype = Self::read_object_type(&mut br)?;
                if ext_otype == M4AType::SBR {
                    self.sbr_present                    = br.read_bool()?;
                    if self.sbr_present {
                        let _ext_srate = Self::read_sampling_frequency(&mut br)?;
                        if br.left() >= 12 {
                            let sync                    = br.read(11)?;
                            if sync == 0x548 {
                                self.ps_present         = br.read_bool()?;
                            }
                        }
                    }
                }
                if ext_otype == M4AType::PS {
                    self.sbr_present                    = br.read_bool()?;
                    if self.sbr_present {
                        let _ext_srate = Self::read_sampling_frequency(&mut br)?;
                    }
                    let _ext_channels = br.read(4)?;
                }
            }
        }

        Ok(())
    }
}

pub fn skimp_through_program_config_element(br: &mut BitReader) -> DecoderResult<(usize, usize)> {
    let _id                             = br.read(4)?;
    let _object_type                    = br.read(2)?;
    let sampling_frequency_index        = br.read(4)? as usize;
    let num_front_channel_elements      = br.read(4)? as usize;
    let num_side_channel_elements       = br.read(4)? as usize;
    let num_back_channel_elements       = br.read(4)? as usize;
    let num_lfe_channel_elements        = br.read(2)? as usize;
    let num_assoc_data_elements         = br.read(3)? as usize;
    let num_valid_cc_elements           = br.read(4)? as usize;
    let mono_mixdown_present            = br.read_bool()?;
    if mono_mixdown_present {
        let _mono_mixdown_element_number = br.read(4)?;
    }
    let stereo_mixdown_present           = br.read_bool()?;
    if stereo_mixdown_present {
        let _stereo_mixdown_element_number = br.read(4)?;
    }
    let matrix_mixdown_idx_present      = br.read_bool()?;
    if matrix_mixdown_idx_present {
        let _matrix_mixdown_idx         = br.read(2)?;
        let _pseudo_surround_enable     = br.read_bool()?;
    }
    for _i in 0..num_front_channel_elements {
        let _front_element_is_cpe       = br.read_bool()?;
        let _front_element_tag_select   = br.read(4)?;
    }
    for _i in 0..num_side_channel_elements {
        let _side_element_is_cpe        = br.read_bool()?;
        let _side_element_tag_select    = br.read(4)?;
    }
    for _i in 0..num_back_channel_elements {
        let _back_element_is_cpe        = br.read_bool()?;
        let _back_element_tag_select    = br.read(4)?;
    }
    for _i in 0..num_lfe_channel_elements {
        let _lfe_element_tag_select     = br.read(4)?;
    }
    for _i in 0..num_assoc_data_elements {
        let _assoc_data_element_tag_select = br.read(4)?;
    }
    for _i in 0..num_valid_cc_elements {
        let _cc_element_is_ind_sw       = br.read_bool()?;
        let _valid_cc_element_tag_select = br.read(4)?;
    }
                                          br.align();
    let comment_field_bytes             = br.read(8)?;
                                          br.skip(comment_field_bytes * 8)?;

    Ok((num_front_channel_elements +
        num_side_channel_elements +
        num_back_channel_elements +
        num_lfe_channel_elements, sampling_frequency_index))
}

impl fmt::Display for M4AInfo {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "MPEG 4 Audio {}, {} Hz, {} channels, {} samples per frame",
               self.otype, self.srate, self.channels, self.samples)
    }
}
Commit	Line	Data
	1	use nihav_core::codecs::{DecoderResult, DecoderError};
	2	use nihav_core::io::bitreader::*;
	3	use std::fmt;
	4
	5	#[allow(non_camel_case_types)]
	6	#[derive(Clone,Copy,PartialEq)]
	7	pub enum M4AType {
	8	None,
	9	Main,
	10	LC,
	11	SSR,
	12	LTP,
	13	SBR,
	14	Scalable,
	15	TwinVQ,
	16	CELP,
	17	HVXC,
	18	TTSI,
	19	MainSynth,
	20	WavetableSynth,
	21	GeneralMIDI,
	22	Algorithmic,
	23	ER_AAC_LC,
	24	ER_AAC_LTP,
	25	ER_AAC_Scalable,
	26	ER_TwinVQ,
	27	ER_BSAC,
	28	ER_AAC_LD,
	29	ER_CELP,
	30	ER_HVXC,
	31	ER_HILN,
	32	ER_Parametric,
	33	SSC,
	34	PS,
	35	MPEGSurround,
	36	Layer1,
	37	Layer2,
	38	Layer3,
	39	DST,
	40	ALS,
	41	SLS,
	42	SLSNonCore,
	43	ER_AAC_ELD,
	44	SMRSimple,
	45	SMRMain,
	46	Reserved,
	47	Unknown,
	48	}
	49
	50	const M4A_TYPES: &[M4AType] = &[
	51	M4AType::None, M4AType::Main, M4AType::LC, M4AType::SSR,
	52	M4AType::LTP, M4AType::SBR, M4AType::Scalable, M4AType::TwinVQ,
	53	M4AType::CELP, M4AType::HVXC, M4AType::Reserved, M4AType::Reserved,
	54	M4AType::TTSI, M4AType::MainSynth, M4AType::WavetableSynth, M4AType::GeneralMIDI,
	55	M4AType::Algorithmic, M4AType::ER_AAC_LC, M4AType::Reserved, M4AType::ER_AAC_LTP,
	56	M4AType::ER_AAC_Scalable, M4AType::ER_TwinVQ, M4AType::ER_BSAC, M4AType::ER_AAC_LD,
	57	M4AType::ER_CELP, M4AType::ER_HVXC, M4AType::ER_HILN, M4AType::ER_Parametric,
	58	M4AType::SSC, M4AType::PS, M4AType::MPEGSurround, M4AType::Reserved /escape/,
	59	M4AType::Layer1, M4AType::Layer2, M4AType::Layer3, M4AType::DST,
	60	M4AType::ALS, M4AType::SLS, M4AType::SLSNonCore, M4AType::ER_AAC_ELD,
	61	M4AType::SMRSimple, M4AType::SMRMain,
	62	];
	63	const M4A_TYPE_NAMES: &[&str] = &[
	64	"None", "AAC Main", "AAC LC", "AAC SSR", "AAC LTP", "SBR", "AAC Scalable", "TwinVQ", "CELP", "HVXC",
	65	/"(reserved10)", "(reserved11)", / "TTSI",
	66	"Main synthetic", "Wavetable synthesis", "General MIDI", "Algorithmic Synthesis and Audio FX",
	67	"ER AAC LC", /"(reserved18)",/ "ER AAC LTP", "ER AAC Scalable", "ER TwinVQ", "ER BSAC", "ER AAC LD",
	68	"ER CELP", "ER HVXC", "ER HILN", "ER Parametric", "SSC", "PS", "MPEG Surround", /"(escape)",/
	69	"Layer-1", "Layer-2", "Layer-3", "DST", "ALS", "SLS", "SLS non-core", "ER AAC ELD", "SMR Simple", "SMR Main",
	70	"(reserved)", "(unknown)",
	71	];
	72
	73	impl fmt::Display for M4AType {
	74	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	75	write!(f, "{}", M4A_TYPE_NAMES[*self as usize])
	76	}
	77	}
	78
	79	const AAC_SAMPLE_RATES: [u32; 16] = [
	80	96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
	81	16000, 12000, 11025, 8000, 7350, 0, 0, 0
	82	];
	83
	84	const AAC_CHANNELS: [usize; 8] = [ 0, 1, 2, 3, 4, 5, 6, 8 ];
	85
	86	pub struct M4AInfo {
	87	pub otype: M4AType,
	88	pub srate: u32,
	89	pub channels: usize,
	90	pub samples: usize,
	91	pub sbr_ps_info: Option<(u32, usize)>,
	92	pub sbr_present: bool,
	93	pub ps_present: bool,
	94	}
	95
	96	impl M4AInfo {
	97	pub fn new() -> Self {
	98	Self {
	99	otype: M4AType::None,
	100	srate: 0,
	101	channels: 0,
	102	samples: 0,
	103	sbr_ps_info: Option::None,
	104	sbr_present: false,
	105	ps_present: false,
	106	}
	107	}
	108	fn read_object_type(br: &mut BitReader) -> DecoderResult<M4AType> {
	109	let otypeidx;
	110	if br.peek(5) == 31 {
	111	br.skip(5)?;
	112	otypeidx = (br.read(6)? as usize) + 32;
	113	} else {
	114	otypeidx = br.read(5)? as usize;
	115	}
	116	if otypeidx >= M4A_TYPES.len() {
	117	Ok(M4AType::Unknown)
	118	} else {
	119	Ok(M4A_TYPES[otypeidx])
	120	}
	121	}
	122	fn read_sampling_frequency(br: &mut BitReader) -> DecoderResult<u32> {
	123	if br.peek(4) == 15 {
	124	let srate = br.read(24)?;
	125	Ok(srate)
	126	} else {
	127	let srate_idx = br.read(4)? as usize;
	128	Ok(AAC_SAMPLE_RATES[srate_idx])
	129	}
	130	}
	131	fn read_channel_config(br: &mut BitReader) -> DecoderResult<usize> {
	132	let chidx = br.read(4)? as usize;
	133	if chidx < AAC_CHANNELS.len() {
	134	Ok(AAC_CHANNELS[chidx])
	135	} else {
	136	Ok(chidx)
	137	}
	138	}
	139	pub fn read(&mut self, src: &[u8]) -> DecoderResult<()> {
	140	let mut br = BitReader::new(src, BitReaderMode::BE);
	141	self.otype = Self::read_object_type(&mut br)?;
	142	self.srate = Self::read_sampling_frequency(&mut br)?;
	143	validate!(self.srate > 0);
	144	self.channels = Self::read_channel_config(&mut br)?;
	145
	146	if (self.otype == M4AType::SBR) \|\| (self.otype == M4AType::PS) {
	147	let ext_srate = Self::read_sampling_frequency(&mut br)?;
	148	self.otype = Self::read_object_type(&mut br)?;
	149	let ext_chans;
	150	if self.otype == M4AType::ER_BSAC {
	151	ext_chans = Self::read_channel_config(&mut br)?;
	152	} else {
	153	ext_chans = 0;
	154	}
	155	self.sbr_ps_info = Some((ext_srate, ext_chans));
	156	}
	157
	158	match self.otype {
	159	M4AType::Main \| M4AType::LC \| M4AType::SSR \| M4AType::Scalable \| M4AType::TwinVQ \|
	160	M4AType::ER_AAC_LC \| M4AType::ER_AAC_LTP \| M4AType::ER_AAC_Scalable \| M4AType::ER_TwinVQ \|
	161	M4AType::ER_BSAC \| M4AType::ER_AAC_LD => {
	162	// GASpecificConfig
	163	let short_frame = br.read_bool()?;
	164	self.samples = if short_frame { 960 } else { 1024 };
	165	let depends_on_core = br.read_bool()?;
	166	if depends_on_core {
	167	let _delay = br.read(14)?;
	168	}
	169	let extension_flag = br.read_bool()?;
	170	if self.channels == 0 {
	171	let (channels, sf_code) = skimp_through_program_config_element(&mut br)?;
	172	validate!(channels > 0);
	173	self.channels = channels;
	174	validate!(AAC_SAMPLE_RATES[sf_code] != 0);
	175	self.srate = AAC_SAMPLE_RATES[sf_code];
	176	}
	177	if (self.otype == M4AType::Scalable) \|\| (self.otype == M4AType::ER_AAC_Scalable) {
	178	let _layer = br.read(3)?;
	179	}
	180	if extension_flag {
	181	if self.otype == M4AType::ER_BSAC {
	182	let _num_subframes = br.read(5)? as usize;
	183	let _layer_length = br.read(11)?;
	184	}
	185	if (self.otype == M4AType::ER_AAC_LC) \|\|
	186	(self.otype == M4AType::ER_AAC_LTP) \|\|
	187	(self.otype == M4AType::ER_AAC_Scalable) \|\|
	188	(self.otype == M4AType::ER_AAC_LD) {
	189	let _section_data_resilience = br.read_bool()?;
	190	let _scalefactors_resilience = br.read_bool()?;
	191	let _spectral_data_resilience = br.read_bool()?;
	192	}
	193	let extension_flag3 = br.read_bool()?;
	194	if extension_flag3 {
	195	unimplemented!("version3 extensions");
	196	}
	197	}
	198	},
	199	M4AType::CELP => { unimplemented!("CELP config"); },
	200	M4AType::HVXC => { unimplemented!("HVXC config"); },
	201	M4AType::TTSI => { unimplemented!("TTS config"); },
	202	M4AType::MainSynth \| M4AType::WavetableSynth \| M4AType::GeneralMIDI \| M4AType::Algorithmic => { unimplemented!("structured audio config"); },
	203	M4AType::ER_CELP => { unimplemented!("ER CELP config"); },
	204	M4AType::ER_HVXC => { unimplemented!("ER HVXC config"); },
	205	M4AType::ER_HILN \| M4AType::ER_Parametric => { unimplemented!("parametric config"); },
	206	M4AType::SSC => { unimplemented!("SSC config"); },
	207	M4AType::MPEGSurround => {
	208	br.skip(1)?; // sacPayloadEmbedding
	209	unimplemented!("MPEG Surround config");
	210	},
	211	M4AType::Layer1 \| M4AType::Layer2 \| M4AType::Layer3 => { unimplemented!("MPEG Layer 1/2/3 config"); },
	212	M4AType::DST => { unimplemented!("DST config"); },
	213	M4AType::ALS => {
	214	br.skip(5)?; // fillBits
	215	unimplemented!("ALS config");
	216	},
	217	M4AType::SLS \| M4AType::SLSNonCore => { unimplemented!("SLS config"); },
	218	M4AType::ER_AAC_ELD => { unimplemented!("ELD config"); },
	219	M4AType::SMRSimple \| M4AType::SMRMain => { unimplemented!("symbolic music config"); },
	220	_ => {},
	221	};
	222	match self.otype {
	223	M4AType::ER_AAC_LC \| M4AType::ER_AAC_LTP \| M4AType::ER_AAC_Scalable \| M4AType::ER_TwinVQ \|
	224	M4AType::ER_BSAC \| M4AType::ER_AAC_LD \| M4AType::ER_CELP \| M4AType::ER_HVXC \|
	225	M4AType::ER_HILN \| M4AType::ER_Parametric \| M4AType::ER_AAC_ELD => {
	226	let ep_config = br.read(2)?;
	227	if (ep_config == 2) \|\| (ep_config == 3) {
	228	unimplemented!("error protection config");
	229	}
	230	if ep_config == 3 {
	231	let direct_mapping = br.read_bool()?;
	232	validate!(direct_mapping);
	233	}
	234	},
	235	_ => {},
	236	};
	237	if self.sbr_ps_info.is_some() && (br.left() >= 16) {
	238	let sync = br.read(11)?;
	239	if sync == 0x2B7 {
	240	let ext_otype = Self::read_object_type(&mut br)?;
	241	if ext_otype == M4AType::SBR {
	242	self.sbr_present = br.read_bool()?;
	243	if self.sbr_present {
	244	let _ext_srate = Self::read_sampling_frequency(&mut br)?;
	245	if br.left() >= 12 {
	246	let sync = br.read(11)?;
	247	if sync == 0x548 {
	248	self.ps_present = br.read_bool()?;
	249	}
	250	}
	251	}
	252	}
	253	if ext_otype == M4AType::PS {
	254	self.sbr_present = br.read_bool()?;
	255	if self.sbr_present {
	256	let _ext_srate = Self::read_sampling_frequency(&mut br)?;
	257	}
	258	let _ext_channels = br.read(4)?;
	259	}
	260	}
	261	}
	262
	263	Ok(())
	264	}
	265	}
	266
	267	pub fn skimp_through_program_config_element(br: &mut BitReader) -> DecoderResult<(usize, usize)> {
	268	let _id = br.read(4)?;
	269	let _object_type = br.read(2)?;
	270	let sampling_frequency_index = br.read(4)? as usize;
	271	let num_front_channel_elements = br.read(4)? as usize;
	272	let num_side_channel_elements = br.read(4)? as usize;
	273	let num_back_channel_elements = br.read(4)? as usize;
	274	let num_lfe_channel_elements = br.read(2)? as usize;
	275	let num_assoc_data_elements = br.read(3)? as usize;
	276	let num_valid_cc_elements = br.read(4)? as usize;
	277	let mono_mixdown_present = br.read_bool()?;
	278	if mono_mixdown_present {
	279	let _mono_mixdown_element_number = br.read(4)?;
	280	}
	281	let stereo_mixdown_present = br.read_bool()?;
	282	if stereo_mixdown_present {
	283	let _stereo_mixdown_element_number = br.read(4)?;
	284	}
	285	let matrix_mixdown_idx_present = br.read_bool()?;
	286	if matrix_mixdown_idx_present {
	287	let _matrix_mixdown_idx = br.read(2)?;
	288	let _pseudo_surround_enable = br.read_bool()?;
	289	}
	290	for _i in 0..num_front_channel_elements {
	291	let _front_element_is_cpe = br.read_bool()?;
	292	let _front_element_tag_select = br.read(4)?;
	293	}
	294	for _i in 0..num_side_channel_elements {
	295	let _side_element_is_cpe = br.read_bool()?;
	296	let _side_element_tag_select = br.read(4)?;
	297	}
	298	for _i in 0..num_back_channel_elements {
	299	let _back_element_is_cpe = br.read_bool()?;
	300	let _back_element_tag_select = br.read(4)?;
	301	}
	302	for _i in 0..num_lfe_channel_elements {
	303	let _lfe_element_tag_select = br.read(4)?;
	304	}
	305	for _i in 0..num_assoc_data_elements {
	306	let _assoc_data_element_tag_select = br.read(4)?;
	307	}
	308	for _i in 0..num_valid_cc_elements {
	309	let _cc_element_is_ind_sw = br.read_bool()?;
	310	let _valid_cc_element_tag_select = br.read(4)?;
	311	}
	312	br.align();
	313	let comment_field_bytes = br.read(8)?;
	314	br.skip(comment_field_bytes * 8)?;
	315
	316	Ok((num_front_channel_elements +
	317	num_side_channel_elements +
	318	num_back_channel_elements +
	319	num_lfe_channel_elements, sampling_frequency_index))
	320	}
	321
	322	impl fmt::Display for M4AInfo {
	323	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	324	write!(f, "MPEG 4 Audio {}, {} Hz, {} channels, {} samples per frame",
	325	self.otype, self.srate, self.channels, self.samples)
	326	}
	327	}
	328