[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 {
                        unimplemented!("program config element");
                    }
                    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(())
    }
}

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
999c25f7 KS	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	unimplemented!("program config element");
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	impl fmt::Display for M4AInfo {
264	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
265	write!(f, "MPEG 4 Audio {}, {} Hz, {} channels, {} samples per frame",
266	self.otype, self.srate, self.channels, self.samples)
267	}
268	}
269