Properly parse AudioSpecificConfig for audioObjectType 5 and 29.

Assumptions were made that ignored if BSAC extension existed (such as HE-AAC with explicit (out of band) SBR signaling.

The full syntax of the AudioSpecificConfig as per ISO14496-3-2009 isn't done, left missing are sync extensions (see 1.6.2.1). Not sure if those exists in the wild. We would still successfully parsed those files however and leave the decoders handling it.

(BMO 1509875)

Fixes #168

Author: Jean-Yves Avenard

mp4parse/src/lib.rs

@@ -293,6 +293,7 @@ pub enum SampleEntry {
 pub struct ES_Descriptor {
     pub audio_codec: CodecType,
     pub audio_object_type: Option<u16>,
+    pub extended_audio_object_type: Option<u16>,
     pub audio_sample_rate: Option<u32>,
     pub audio_channel_count: Option<u16>,
     pub codec_esds: Vec<u8>,
@@ -1520,6 +1521,17 @@ fn find_descriptor(data: &[u8], esds: &mut ES_Descriptor) -> Result<()> {
     Ok(())
 }
 
+fn get_audio_object_type(bit_reader: &mut BitReader) -> Result<u16> {
+    let mut audio_object_type: u16 = ReadInto::read(bit_reader, 5)?;
+
+    // Extend audio object type, for example, HE-AAC.
+    if audio_object_type == 31 {
+        let audio_object_type_ext: u16 = ReadInto::read(bit_reader, 6)?;
+        audio_object_type = 32 + audio_object_type_ext;
+    }
+    Ok(audio_object_type)
+}
+
 fn read_ds_descriptor(data: &[u8], esds: &mut ES_Descriptor) -> Result<()> {
     let frequency_table =
         vec![(0x0, 96000), (0x1, 88200), (0x2, 64000), (0x3, 48000),
@@ -1529,13 +1541,7 @@ fn read_ds_descriptor(data: &[u8], esds: &mut ES_Descriptor) -> Result<()> {
 
     let bit_reader = &mut BitReader::new(data);
 
-    let mut audio_object_type: u16 = ReadInto::read(bit_reader, 5)?;
-
-    // Extend audio object type, for example, HE-AAC.
-    if audio_object_type == 31 {
-        let audio_object_type_ext: u16 = ReadInto::read(bit_reader, 6)?;
-        audio_object_type = 32 + audio_object_type_ext;
-    }
+    let mut audio_object_type = get_audio_object_type(bit_reader)?;
 
     let sample_index: u32 = ReadInto::read(bit_reader, 4)?;
 
@@ -1550,60 +1556,124 @@ fn read_ds_descriptor(data: &[u8], esds: &mut ES_Descriptor) -> Result<()> {
         },
     };
 
-    let mut channel_counts: u16 = ReadInto::read(bit_reader, 4)?;
-
-    // parsing GASpecificConfig
-    bit_reader.skip(1)?;        // frameLengthFlag
-    let depend_on_core_order: u8 = ReadInto::read(bit_reader, 1)?;
-    if depend_on_core_order > 0 {
-        bit_reader.skip(14)?;   // codeCoderDelay
-    }
-    bit_reader.skip(1)?;        // extensionFlag
-
-    // When channel_counts is 0, we need to parse the program_config_element
-    // to calculate the channel counts.
-    if channel_counts == 0 {
-        debug!("Parsing program_config_element for channel counts");
-
-        bit_reader.skip(4)?;    // element_instance_tag
-        bit_reader.skip(2)?;    // object_type
-        bit_reader.skip(4)?;    // sampling_frequency_index
-        let num_front_channel: u8 = ReadInto::read(bit_reader, 4)?;
-        let num_side_channel: u8 = ReadInto::read(bit_reader, 4)?;
-        let num_back_channel:u8 = ReadInto::read(bit_reader, 4)?;
-        let num_lfe_channel: u8 = ReadInto::read(bit_reader, 2)?;
-        bit_reader.skip(3)?;    // num_assoc_data
-        bit_reader.skip(4)?;    // num_valid_cc
-
-        let mono_mixdown_present: bool = ReadInto::read(bit_reader, 1)?;
-        if mono_mixdown_present {
-            bit_reader.skip(4)?;    // mono_mixdown_element_number
-        }
+    let channel_configuration: u16 = ReadInto::read(bit_reader, 4)?;
 
-        let stereo_mixdown_present: bool = ReadInto::read(bit_reader, 1)?;
-        if stereo_mixdown_present {
-            bit_reader.skip(4)?;    // stereo_mixdown_element_number
-        }
+    let extended_audio_object_type = match audio_object_type {
+        5 | 29 => Some(5),
+        _ => None,
+    };
 
-        let matrix_mixdown_idx_present: bool = ReadInto::read(bit_reader, 1)?;
-        if matrix_mixdown_idx_present {
-            bit_reader.skip(2)?;    // matrix_mixdown_idx
-            bit_reader.skip(1)?;    // pseudo_surround_enable
-        }
+    if audio_object_type == 5 || audio_object_type == 29 {
+        // We have an explicit signaling for BSAC extension, should the decoder
+        // decode the BSAC extension (all Gecko's AAC decoders do), then this is
+        // what the stream will actually look like once decoded.
+        let _extended_sample_index = ReadInto::read(bit_reader, 4)?;
+        let _extended_sample_frequency: Option<u32> = match _extended_sample_index {
+            0x0F => Some(ReadInto::read(bit_reader, 24)?),
+            _ => frequency_table.iter().find(|item| item.0 == sample_index).map(|x| x.1)
+        };
+        audio_object_type = get_audio_object_type(bit_reader)?;
+        let _extended_channel_configuration = match audio_object_type {
+            22 => ReadInto::read(bit_reader, 4)?,
+            _ => channel_configuration
+        };
+    };
 
-        channel_counts += read_surround_channel_count(bit_reader, num_front_channel)?;
-        channel_counts += read_surround_channel_count(bit_reader, num_side_channel)?;
-        channel_counts += read_surround_channel_count(bit_reader, num_back_channel)?;
-        channel_counts += read_surround_channel_count(bit_reader, num_lfe_channel)?;
-    }
+    match audio_object_type {
+        1 ... 4 | 6 | 7 | 17 | 19 ... 23 => {
+            if sample_frequency.is_none() {
+                return Err(Error::Unsupported("unknown frequency"));
+            }
 
-    esds.audio_object_type = Some(audio_object_type);
-    esds.audio_sample_rate = sample_frequency;
-    esds.audio_channel_count = Some(channel_counts);
-    assert!(esds.decoder_specific_data.is_empty());
-    esds.decoder_specific_data.extend_from_slice(data);
+            // parsing GASpecificConfig
+
+            // If the sampling rate is not one of the rates listed in the right
+            // column in Table 4.82, the sampling frequency dependent tables
+            // (code tables, scale factor band tables etc.) must be deduced in
+            // order for the bitstream payload to be parsed. Since a given
+            // sampling frequency is associated with only one sampling frequency
+            // table, and since maximum flexibility is desired in the range of
+            // possible sampling frequencies, the following table shall be used
+            // to associate an implied sampling frequency with the desired
+            // sampling frequency dependent tables.
+            let sample_frequency_value = match sample_frequency.unwrap() {
+                0 ... 9390 => 8000,
+                9391 ... 11501 => 11025,
+                11502 ... 13855 => 12000,
+                13856 ... 18782 => 16000,
+                18783 ... 23003 => 22050,
+                23004 ... 27712 => 24000,
+                27713 ... 37565 => 32000,
+                37566 ... 46008 => 44100,
+                46009 ... 55425 => 48000,
+                55426 ... 75131 => 64000,
+                75132 ... 92016 => 88200,
+                _ => 96000
+            };
 
-    Ok(())
+            bit_reader.skip(1)?;        // frameLengthFlag
+            let depend_on_core_order: u8 = ReadInto::read(bit_reader, 1)?;
+            if depend_on_core_order > 0 {
+                bit_reader.skip(14)?;   // codeCoderDelay
+            }
+            bit_reader.skip(1)?;        // extensionFlag
+
+            let channel_counts = match channel_configuration {
+                0 => {
+                    debug!("Parsing program_config_element for channel counts");
+
+                    bit_reader.skip(4)?;    // element_instance_tag
+                    bit_reader.skip(2)?;    // object_type
+                    bit_reader.skip(4)?;    // sampling_frequency_index
+                    let num_front_channel: u8 = ReadInto::read(bit_reader, 4)?;
+                    let num_side_channel: u8 = ReadInto::read(bit_reader, 4)?;
+                    let num_back_channel:u8 = ReadInto::read(bit_reader, 4)?;
+                    let num_lfe_channel: u8 = ReadInto::read(bit_reader, 2)?;
+                    bit_reader.skip(3)?;    // num_assoc_data
+                    bit_reader.skip(4)?;    // num_valid_cc
+
+                    let mono_mixdown_present: bool = ReadInto::read(bit_reader, 1)?;
+                    if mono_mixdown_present {
+                        bit_reader.skip(4)?;    // mono_mixdown_element_number
+                    }
+
+                    let stereo_mixdown_present: bool = ReadInto::read(bit_reader, 1)?;
+                    if stereo_mixdown_present {
+                        bit_reader.skip(4)?;    // stereo_mixdown_element_number
+                    }
+
+                    let matrix_mixdown_idx_present: bool = ReadInto::read(bit_reader, 1)?;
+                    if matrix_mixdown_idx_present {
+                        bit_reader.skip(2)?;    // matrix_mixdown_idx
+                        bit_reader.skip(1)?;    // pseudo_surround_enable
+                    }
+                    let mut _channel_counts = 0;
+                    _channel_counts += read_surround_channel_count(bit_reader, num_front_channel)?;
+                    _channel_counts += read_surround_channel_count(bit_reader, num_side_channel)?;
+                    _channel_counts += read_surround_channel_count(bit_reader, num_back_channel)?;
+                    _channel_counts += read_surround_channel_count(bit_reader, num_lfe_channel)?;
+                    _channel_counts
+                },
+                1 ... 7 => channel_configuration,
+                // Amendment 4 of the AAC standard in 2013 below
+                11 => 7, // 6.1 Amendment 4 of the AAC standard in 2013
+                12 | 14 => 8, // 7.1 (a/d) of ITU BS.2159
+                _ => {
+                    return Err(Error::Unsupported("invalid channel configuration"));
+                }
+            };
+
+            esds.audio_object_type = Some(audio_object_type);
+            esds.extended_audio_object_type = extended_audio_object_type;
+            esds.audio_sample_rate = Some(sample_frequency_value);
+            esds.audio_channel_count = Some(channel_counts);
+            assert!(esds.decoder_specific_data.is_empty());
+            esds.decoder_specific_data.extend_from_slice(data);
+
+            Ok(())
+        },
+        _ => Err(Error::Unsupported("unknown aac audio object type"))
+    }
 }
 
 fn read_surround_channel_count(bit_reader: &mut BitReader, channels: u8) -> Result<u16> {

mp4parse_capi/src/lib.rs

@@ -205,6 +205,7 @@ pub struct Mp4parseTrackAudioSampleInfo {
     pub bit_depth: u16,
     pub sample_rate: u32,
     pub profile: u16,
+    pub extended_profile: u16,
     pub codec_specific_config: Mp4parseByteData,
     pub extra_data: Mp4parseByteData,
     pub protected_data: Mp4parseSinfInfo,
@@ -600,6 +601,10 @@ pub unsafe extern fn mp4parse_get_track_audio_info(parser: *mut Mp4parseParser,
                 if let Some(profile) = esds.audio_object_type {
                     sample_info.profile = profile;
                 }
+                sample_info.extended_profile = match esds.extended_audio_object_type {
+                    Some(extended_profile) => extended_profile,
+                    _ => sample_info.profile
+                };
             }
             AudioCodecSpecific::FLACSpecificBox(ref flac) => {
                 // Return the STREAMINFO metadata block in the codec_specific.