[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])
    }
}

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

pub 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)?;
                                                          (br.read(6)? as usize) + 32
            } else {
                                                          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 {
                    Self::read_channel_config(&mut br)?
                } else { 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	pub 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	pub 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 = if br.peek(5) == 31 {
	110	br.skip(5)?;
	111	(br.read(6)? as usize) + 32
	112	} else {
	113	br.read(5)? as usize
	114	};
	115	if otypeidx >= M4A_TYPES.len() {
	116	Ok(M4AType::Unknown)
	117	} else {
	118	Ok(M4A_TYPES[otypeidx])
	119	}
	120	}
	121	fn read_sampling_frequency(br: &mut BitReader) -> DecoderResult<u32> {
	122	if br.peek(4) == 15 {
	123	let srate = br.read(24)?;
	124	Ok(srate)
	125	} else {
	126	let srate_idx = br.read(4)? as usize;
	127	Ok(AAC_SAMPLE_RATES[srate_idx])
	128	}
	129	}
	130	fn read_channel_config(br: &mut BitReader) -> DecoderResult<usize> {
	131	let chidx = br.read(4)? as usize;
	132	if chidx < AAC_CHANNELS.len() {
	133	Ok(AAC_CHANNELS[chidx])
	134	} else {
	135	Ok(chidx)
	136	}
	137	}
	138	pub fn read(&mut self, src: &[u8]) -> DecoderResult<()> {
	139	let mut br = BitReader::new(src, BitReaderMode::BE);
	140	self.otype = Self::read_object_type(&mut br)?;
	141	self.srate = Self::read_sampling_frequency(&mut br)?;
	142	validate!(self.srate > 0);
	143	self.channels = Self::read_channel_config(&mut br)?;
	144
	145	if (self.otype == M4AType::SBR) \|\| (self.otype == M4AType::PS) {
	146	let ext_srate = Self::read_sampling_frequency(&mut br)?;
	147	self.otype = Self::read_object_type(&mut br)?;
	148	let ext_chans = if self.otype == M4AType::ER_BSAC {
	149	Self::read_channel_config(&mut br)?
	150	} else { 0 };
	151	self.sbr_ps_info = Some((ext_srate, ext_chans));
	152	}
	153
	154	match self.otype {
	155	M4AType::Main \| M4AType::LC \| M4AType::SSR \| M4AType::Scalable \| M4AType::TwinVQ \|
	156	M4AType::ER_AAC_LC \| M4AType::ER_AAC_LTP \| M4AType::ER_AAC_Scalable \| M4AType::ER_TwinVQ \|
	157	M4AType::ER_BSAC \| M4AType::ER_AAC_LD => {
	158	// GASpecificConfig
	159	let short_frame = br.read_bool()?;
	160	self.samples = if short_frame { 960 } else { 1024 };
	161	let depends_on_core = br.read_bool()?;
	162	if depends_on_core {
	163	let _delay = br.read(14)?;
	164	}
	165	let extension_flag = br.read_bool()?;
	166	if self.channels == 0 {
	167	let (channels, sf_code) = skimp_through_program_config_element(&mut br)?;
	168	validate!(channels > 0);
	169	self.channels = channels;
	170	validate!(AAC_SAMPLE_RATES[sf_code] != 0);
	171	self.srate = AAC_SAMPLE_RATES[sf_code];
	172	}
	173	if (self.otype == M4AType::Scalable) \|\| (self.otype == M4AType::ER_AAC_Scalable) {
	174	let _layer = br.read(3)?;
	175	}
	176	if extension_flag {
	177	if self.otype == M4AType::ER_BSAC {
	178	let _num_subframes = br.read(5)? as usize;
	179	let _layer_length = br.read(11)?;
	180	}
	181	if (self.otype == M4AType::ER_AAC_LC) \|\|
	182	(self.otype == M4AType::ER_AAC_LTP) \|\|
	183	(self.otype == M4AType::ER_AAC_Scalable) \|\|
	184	(self.otype == M4AType::ER_AAC_LD) {
	185	let _section_data_resilience = br.read_bool()?;
	186	let _scalefactors_resilience = br.read_bool()?;
	187	let _spectral_data_resilience = br.read_bool()?;
	188	}
	189	let extension_flag3 = br.read_bool()?;
	190	if extension_flag3 {
	191	unimplemented!("version3 extensions");
	192	}
	193	}
	194	},
	195	M4AType::CELP => { unimplemented!("CELP config"); },
	196	M4AType::HVXC => { unimplemented!("HVXC config"); },
	197	M4AType::TTSI => { unimplemented!("TTS config"); },
	198	M4AType::MainSynth \| M4AType::WavetableSynth \| M4AType::GeneralMIDI \| M4AType::Algorithmic => { unimplemented!("structured audio config"); },
	199	M4AType::ER_CELP => { unimplemented!("ER CELP config"); },
	200	M4AType::ER_HVXC => { unimplemented!("ER HVXC config"); },
	201	M4AType::ER_HILN \| M4AType::ER_Parametric => { unimplemented!("parametric config"); },
	202	M4AType::SSC => { unimplemented!("SSC config"); },
	203	M4AType::MPEGSurround => {
	204	br.skip(1)?; // sacPayloadEmbedding
	205	unimplemented!("MPEG Surround config");
	206	},
	207	M4AType::Layer1 \| M4AType::Layer2 \| M4AType::Layer3 => { unimplemented!("MPEG Layer 1/2/3 config"); },
	208	M4AType::DST => { unimplemented!("DST config"); },
	209	M4AType::ALS => {
	210	br.skip(5)?; // fillBits
	211	unimplemented!("ALS config");
	212	},
	213	M4AType::SLS \| M4AType::SLSNonCore => { unimplemented!("SLS config"); },
	214	M4AType::ER_AAC_ELD => { unimplemented!("ELD config"); },
	215	M4AType::SMRSimple \| M4AType::SMRMain => { unimplemented!("symbolic music config"); },
	216	_ => {},
	217	};
	218	match self.otype {
	219	M4AType::ER_AAC_LC \| M4AType::ER_AAC_LTP \| M4AType::ER_AAC_Scalable \| M4AType::ER_TwinVQ \|
	220	M4AType::ER_BSAC \| M4AType::ER_AAC_LD \| M4AType::ER_CELP \| M4AType::ER_HVXC \|
	221	M4AType::ER_HILN \| M4AType::ER_Parametric \| M4AType::ER_AAC_ELD => {
	222	let ep_config = br.read(2)?;
	223	if (ep_config == 2) \|\| (ep_config == 3) {
	224	unimplemented!("error protection config");
	225	}
	226	if ep_config == 3 {
	227	let direct_mapping = br.read_bool()?;
	228	validate!(direct_mapping);
	229	}
	230	},
	231	_ => {},
	232	};
	233	if self.sbr_ps_info.is_some() && (br.left() >= 16) {
	234	let sync = br.read(11)?;
	235	if sync == 0x2B7 {
	236	let ext_otype = Self::read_object_type(&mut br)?;
	237	if ext_otype == M4AType::SBR {
	238	self.sbr_present = br.read_bool()?;
	239	if self.sbr_present {
	240	let _ext_srate = Self::read_sampling_frequency(&mut br)?;
	241	if br.left() >= 12 {
	242	let sync = br.read(11)?;
	243	if sync == 0x548 {
	244	self.ps_present = br.read_bool()?;
	245	}
	246	}
	247	}
	248	}
	249	if ext_otype == M4AType::PS {
	250	self.sbr_present = br.read_bool()?;
	251	if self.sbr_present {
	252	let _ext_srate = Self::read_sampling_frequency(&mut br)?;
	253	}
	254	let _ext_channels = br.read(4)?;
	255	}
	256	}
	257	}
	258
	259	Ok(())
	260	}
	261	}
	262
	263	pub fn skimp_through_program_config_element(br: &mut BitReader) -> DecoderResult<(usize, usize)> {
	264	let _id = br.read(4)?;
	265	let _object_type = br.read(2)?;
	266	let sampling_frequency_index = br.read(4)? as usize;
	267	let num_front_channel_elements = br.read(4)? as usize;
	268	let num_side_channel_elements = br.read(4)? as usize;
	269	let num_back_channel_elements = br.read(4)? as usize;
	270	let num_lfe_channel_elements = br.read(2)? as usize;
	271	let num_assoc_data_elements = br.read(3)? as usize;
	272	let num_valid_cc_elements = br.read(4)? as usize;
	273	let mono_mixdown_present = br.read_bool()?;
	274	if mono_mixdown_present {
	275	let _mono_mixdown_element_number = br.read(4)?;
	276	}
	277	let stereo_mixdown_present = br.read_bool()?;
	278	if stereo_mixdown_present {
	279	let _stereo_mixdown_element_number = br.read(4)?;
	280	}
	281	let matrix_mixdown_idx_present = br.read_bool()?;
	282	if matrix_mixdown_idx_present {
	283	let _matrix_mixdown_idx = br.read(2)?;
	284	let _pseudo_surround_enable = br.read_bool()?;
	285	}
	286	for _i in 0..num_front_channel_elements {
	287	let _front_element_is_cpe = br.read_bool()?;
	288	let _front_element_tag_select = br.read(4)?;
	289	}
	290	for _i in 0..num_side_channel_elements {
	291	let _side_element_is_cpe = br.read_bool()?;
	292	let _side_element_tag_select = br.read(4)?;
	293	}
	294	for _i in 0..num_back_channel_elements {
	295	let _back_element_is_cpe = br.read_bool()?;
	296	let _back_element_tag_select = br.read(4)?;
	297	}
	298	for _i in 0..num_lfe_channel_elements {
	299	let _lfe_element_tag_select = br.read(4)?;
	300	}
	301	for _i in 0..num_assoc_data_elements {
	302	let _assoc_data_element_tag_select = br.read(4)?;
	303	}
	304	for _i in 0..num_valid_cc_elements {
	305	let _cc_element_is_ind_sw = br.read_bool()?;
	306	let _valid_cc_element_tag_select = br.read(4)?;
	307	}
	308	br.align();
	309	let comment_field_bytes = br.read(8)?;
	310	br.skip(comment_field_bytes * 8)?;
	311
	312	Ok((num_front_channel_elements +
	313	num_side_channel_elements +
	314	num_back_channel_elements +
	315	num_lfe_channel_elements, sampling_frequency_index))
	316	}
	317
	318	impl fmt::Display for M4AInfo {
	319	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	320	write!(f, "MPEG 4 Audio {}, {} Hz, {} channels, {} samples per frame",
	321	self.otype, self.srate, self.channels, self.samples)
	322	}
	323	}
	324