1 /*
2 * Copyright (c) 2023, Alliance for Open Media. All rights reserved
3 *
4 * This source code is subject to the terms of the BSD 3-Clause Clear License
5 * and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear
6 * License was not distributed with this source code in the LICENSE file, you
7 * can obtain it at www.aomedia.org/license/software-license/bsd-3-c-c. If the
8 * Alliance for Open Media Patent License 1.0 was not distributed with this
9 * source code in the PATENTS file, you can obtain it at
10 * www.aomedia.org/license/patent.
11 */
12 #include "iamf/obu/decoder_config/aac_decoder_config.h"
13
14 #include <cstdint>
15 #include <vector>
16
17 #include "absl/status/status.h"
18 #include "absl/status/status_matchers.h"
19 #include "absl/types/span.h"
20 #include "gmock/gmock.h"
21 #include "gtest/gtest.h"
22 #include "iamf/common/read_bit_buffer.h"
23 #include "iamf/common/utils/tests/test_utils.h"
24 #include "iamf/common/write_bit_buffer.h"
25
26 namespace iamf_tools {
27 namespace {
28
29 using ::absl_testing::IsOk;
30
31 using SampleFrequencyIndex = AudioSpecificConfig::SampleFrequencyIndex;
32
33 constexpr int16_t kAudioRollDistance = -1;
34 constexpr int16_t kInvalidAudioRollDistance = 0;
35
36 // Despite being represented in 4-bits the AAC Sampling Frequency Index 64000 is
37 // serialized across a byte boundary.
38 constexpr uint8_t kUpperByteSerializedSamplingFrequencyIndex64000 =
39 (static_cast<uint8_t>(SampleFrequencyIndex::k64000) & 0x0e) >> 1;
40 constexpr uint8_t kLowerByteSerializedSamplingFrequencyIndex64000 =
41 (static_cast<uint8_t>(SampleFrequencyIndex::k64000) & 0x01) << 7;
42
43 // Despite being represented in 4-bits the AAC Sampling Frequency Index 24000 is
44 // serialized across a byte boundary.
45 constexpr uint8_t kUpperByteSerializedSamplingFrequencyIndex24000 =
46 (static_cast<uint8_t>(SampleFrequencyIndex::k24000) & 0x0e) >> 1;
47 constexpr uint8_t kLowerByteSerializedSamplingFrequencyIndex24000 =
48 (static_cast<uint8_t>(SampleFrequencyIndex::k24000) & 0x01) << 7;
49
50 constexpr uint8_t kUpperByteSerializedSamplingFrequencyIndexEscape =
51 (static_cast<uint8_t>(SampleFrequencyIndex::kEscapeValue) & 0x0e) >> 1;
52 constexpr uint8_t kLowerByteSerializedSamplingFrequencyIndexEscape =
53 (static_cast<uint8_t>(SampleFrequencyIndex::kEscapeValue) & 0x01) << 7;
54
55 // A 7-bit mask representing `channel_configuration`, and all three fields in
56 // the GA specific config.
57 constexpr uint8_t kChannelConfigurationAndGaSpecificConfigMask =
58 AudioSpecificConfig::kChannelConfiguration << 3 | // 4 bits.
59 AudioSpecificConfig::GaSpecificConfig::kFrameLengthFlag << 2 | // 1 bit.
60 AudioSpecificConfig::GaSpecificConfig::kDependsOnCoreCoder << 1 | // 1 bit.
61 AudioSpecificConfig::GaSpecificConfig::kExtensionFlag << 0; // 1 bit.
62
63 constexpr uint8_t kStreamTypeUpstreamReserved =
64 AacDecoderConfig::kStreamType << 2 | AacDecoderConfig::kUpstream << 1 |
65 AacDecoderConfig::kReserved << 0;
66
TEST(GetRequiredAudioRollDistance,ReturnsFixedValue)67 TEST(GetRequiredAudioRollDistance, ReturnsFixedValue) {
68 EXPECT_EQ(AacDecoderConfig::GetRequiredAudioRollDistance(),
69 kAudioRollDistance);
70 }
71
GetAacDecoderConfig()72 AacDecoderConfig GetAacDecoderConfig() {
73 return AacDecoderConfig{
74 .buffer_size_db_ = 0,
75 .max_bitrate_ = 0,
76 .average_bit_rate_ = 0,
77 .decoder_specific_info_ =
78 {.audio_specific_config = {.sample_frequency_index_ =
79 SampleFrequencyIndex::k64000}},
80 };
81 }
82
TEST(AacDecoderConfig,ValidateWithCommonValues)83 TEST(AacDecoderConfig, ValidateWithCommonValues) {
84 EXPECT_THAT(GetAacDecoderConfig().Validate(), IsOk());
85 }
86
TEST(AacDecoderConfig,ValidateWithManyVaryingValues)87 TEST(AacDecoderConfig, ValidateWithManyVaryingValues) {
88 auto aac_decoder_config = GetAacDecoderConfig();
89 aac_decoder_config.buffer_size_db_ = 1;
90 aac_decoder_config.max_bitrate_ = 1;
91 aac_decoder_config.average_bit_rate_ = 1;
92 aac_decoder_config.decoder_specific_info_.audio_specific_config
93 .sample_frequency_index_ = SampleFrequencyIndex::kEscapeValue;
94 aac_decoder_config.decoder_specific_info_.audio_specific_config
95 .sampling_frequency_ = 48;
96
97 EXPECT_THAT(GetAacDecoderConfig().Validate(), IsOk());
98 }
99
TEST(AacDecoderConfig,ValidatesDecoderConfigDescriptorTag)100 TEST(AacDecoderConfig, ValidatesDecoderConfigDescriptorTag) {
101 constexpr uint8_t kInvalidDecoderConfigDescriptorTag = 0;
102 auto aac_decoder_config = GetAacDecoderConfig();
103 aac_decoder_config.decoder_config_descriptor_tag_ =
104 kInvalidDecoderConfigDescriptorTag;
105
106 EXPECT_FALSE(aac_decoder_config.Validate().ok());
107 }
108
TEST(AacDecoderConfig,ValidatesObjectTypeIndication)109 TEST(AacDecoderConfig, ValidatesObjectTypeIndication) {
110 constexpr uint8_t kInvalidObjectTypeIndication = 0;
111 auto aac_decoder_config = GetAacDecoderConfig();
112 aac_decoder_config.object_type_indication_ = kInvalidObjectTypeIndication;
113
114 EXPECT_FALSE(aac_decoder_config.Validate().ok());
115 }
116
TEST(AacDecoderConfig,ValidatesStreamType)117 TEST(AacDecoderConfig, ValidatesStreamType) {
118 constexpr uint8_t kInvalidStreamType = 0;
119 auto aac_decoder_config = GetAacDecoderConfig();
120 aac_decoder_config.stream_type_ = kInvalidStreamType;
121
122 EXPECT_FALSE(aac_decoder_config.Validate().ok());
123 }
124
TEST(AacDecoderConfig,ValidatesUpstream)125 TEST(AacDecoderConfig, ValidatesUpstream) {
126 constexpr bool kInvalidUpstream = true;
127 auto aac_decoder_config = GetAacDecoderConfig();
128 aac_decoder_config.upstream_ = kInvalidUpstream;
129
130 EXPECT_FALSE(aac_decoder_config.Validate().ok());
131 }
132
TEST(AacDecoderConfig,ValidatesReserved)133 TEST(AacDecoderConfig, ValidatesReserved) {
134 constexpr bool kInvalidReserved = false;
135 auto aac_decoder_config = GetAacDecoderConfig();
136 aac_decoder_config.reserved_ = kInvalidReserved;
137
138 EXPECT_FALSE(aac_decoder_config.Validate().ok());
139 }
140
TEST(AacDecoderConfig,ValidatesDecoderSpecificInfoTag)141 TEST(AacDecoderConfig, ValidatesDecoderSpecificInfoTag) {
142 constexpr uint8_t kInvalidDecoderSpecificInfoTag = 0;
143 auto aac_decoder_config = GetAacDecoderConfig();
144 aac_decoder_config.decoder_specific_info_.decoder_specific_info_tag =
145 kInvalidDecoderSpecificInfoTag;
146
147 EXPECT_FALSE(aac_decoder_config.Validate().ok());
148 }
149
TEST(AacDecoderConfig,ValidatesAudioObjectType)150 TEST(AacDecoderConfig, ValidatesAudioObjectType) {
151 constexpr uint8_t kInvalidAudioObjectType = 0;
152 auto aac_decoder_config = GetAacDecoderConfig();
153 aac_decoder_config.decoder_specific_info_.audio_specific_config
154 .audio_object_type_ = kInvalidAudioObjectType;
155
156 EXPECT_FALSE(aac_decoder_config.Validate().ok());
157 }
158
TEST(AacDecoderConfig,ValidatesChannelConfiguration)159 TEST(AacDecoderConfig, ValidatesChannelConfiguration) {
160 constexpr uint8_t kInvalidChannelConfiguration = 0;
161 auto aac_decoder_config = GetAacDecoderConfig();
162 aac_decoder_config.decoder_specific_info_.audio_specific_config
163 .channel_configuration_ = kInvalidChannelConfiguration;
164
165 EXPECT_FALSE(aac_decoder_config.Validate().ok());
166 }
167
TEST(AacDecoderConfig,ValidatesFrameLengthFlag)168 TEST(AacDecoderConfig, ValidatesFrameLengthFlag) {
169 constexpr bool kInvalidFrameLengthFlag = true;
170 auto aac_decoder_config = GetAacDecoderConfig();
171 aac_decoder_config.decoder_specific_info_.audio_specific_config
172 .ga_specific_config_.frame_length_flag = kInvalidFrameLengthFlag;
173
174 EXPECT_FALSE(aac_decoder_config.Validate().ok());
175 }
176
TEST(AacDecoderConfig,ValidatesDepenedsOnCoreCoder)177 TEST(AacDecoderConfig, ValidatesDepenedsOnCoreCoder) {
178 constexpr bool kInvalidDependsOnCoreCoder = true;
179 auto aac_decoder_config = GetAacDecoderConfig();
180 aac_decoder_config.decoder_specific_info_.audio_specific_config
181 .ga_specific_config_.depends_on_core_coder = kInvalidDependsOnCoreCoder;
182
183 EXPECT_FALSE(aac_decoder_config.Validate().ok());
184 }
185
TEST(AacDecoderConfig,ValidatesExtensionFlag)186 TEST(AacDecoderConfig, ValidatesExtensionFlag) {
187 constexpr bool kInvalidExtensionFlag = true;
188 auto aac_decoder_config = GetAacDecoderConfig();
189 aac_decoder_config.decoder_specific_info_.audio_specific_config
190 .ga_specific_config_.extension_flag = kInvalidExtensionFlag;
191
192 EXPECT_FALSE(aac_decoder_config.Validate().ok());
193 }
194
TEST(AudioSpecificConfig,ReadsWithImplicitSampleFrequency64000)195 TEST(AudioSpecificConfig, ReadsWithImplicitSampleFrequency64000) {
196 std::vector<uint8_t> data = {
197 // `audio_object_type`, upper 3 bits of `sample_frequency_index`.
198 AudioSpecificConfig::kAudioObjectType << 3 |
199 kUpperByteSerializedSamplingFrequencyIndex64000,
200 // lower bit of `sample_frequency_index`,
201 // `channel_configuration`, `frame_length_flag`,
202 // `depends_on_core_coder`, `extension_flag`.
203 kLowerByteSerializedSamplingFrequencyIndex64000 |
204 kChannelConfigurationAndGaSpecificConfigMask};
205 AudioSpecificConfig audio_specific_config;
206 auto rb =
207 MemoryBasedReadBitBuffer::CreateFromSpan(1024, absl::MakeConstSpan(data));
208
209 EXPECT_THAT(audio_specific_config.Read(*rb), IsOk());
210
211 EXPECT_EQ(audio_specific_config.audio_object_type_,
212 AudioSpecificConfig::kAudioObjectType);
213 EXPECT_EQ(audio_specific_config.sample_frequency_index_,
214 SampleFrequencyIndex::k64000);
215 EXPECT_EQ(audio_specific_config.channel_configuration_,
216 AudioSpecificConfig::kChannelConfiguration);
217 EXPECT_EQ(audio_specific_config.ga_specific_config_.frame_length_flag,
218 AudioSpecificConfig::GaSpecificConfig::kFrameLengthFlag);
219 EXPECT_EQ(audio_specific_config.ga_specific_config_.depends_on_core_coder,
220 AudioSpecificConfig::GaSpecificConfig::kDependsOnCoreCoder);
221 EXPECT_EQ(audio_specific_config.ga_specific_config_.extension_flag,
222 AudioSpecificConfig::GaSpecificConfig::kExtensionFlag);
223 }
224
TEST(AudioSpecificConfig,ReadsWithImplicitSampleFrequency24000)225 TEST(AudioSpecificConfig, ReadsWithImplicitSampleFrequency24000) {
226 const std::vector<uint8_t> data = {
227 // `audio_object_type`, upper 3 bits of `sample_frequency_index`.
228 AudioSpecificConfig::kAudioObjectType << 3 |
229 kUpperByteSerializedSamplingFrequencyIndex24000,
230 // lower bit of `sample_frequency_index`,
231 // `channel_configuration`, `frame_length_flag`,
232 // `depends_on_core_coder`, `extension_flag`.
233 kLowerByteSerializedSamplingFrequencyIndex24000 |
234 kChannelConfigurationAndGaSpecificConfigMask};
235 AudioSpecificConfig audio_specific_config;
236 auto rb = MemoryBasedReadBitBuffer::CreateFromSpan(1024, data);
237
238 EXPECT_THAT(audio_specific_config.Read(*rb), IsOk());
239
240 EXPECT_EQ(audio_specific_config.sample_frequency_index_,
241 SampleFrequencyIndex::k24000);
242 }
243
TEST(AudioSpecificConfig,ReadsWithExplicitSampleFrequency)244 TEST(AudioSpecificConfig, ReadsWithExplicitSampleFrequency) {
245 constexpr uint32_t kSampleFrequency = 48000;
246 std::vector<uint8_t> data = {
247 // `audio_object_type`, upper 3 bits of `sample_frequency_index`.
248 AudioSpecificConfig::kAudioObjectType << 3 |
249 kUpperByteSerializedSamplingFrequencyIndexEscape,
250 // lower bit of `sample_frequency_index`, upper 7 bits of
251 // `sampling_rate`.
252 kLowerByteSerializedSamplingFrequencyIndexEscape |
253 ((kSampleFrequency & 0xe00000) >> 17),
254 // Next 16 bits of `sampling_rate`.
255 ((kSampleFrequency & 0x1fe00) >> 9), ((kSampleFrequency & 0x1fe) >> 1),
256 // Upper bit of `sampling_rate`, `channel_configuration`,
257 // `frame_length_flag`, `depends_on_core_coder`, `extension_flag`.
258 ((kSampleFrequency & 1)) | kChannelConfigurationAndGaSpecificConfigMask};
259 AudioSpecificConfig audio_specific_config;
260 auto rb =
261 MemoryBasedReadBitBuffer::CreateFromSpan(1024, absl::MakeConstSpan(data));
262
263 EXPECT_THAT(audio_specific_config.Read(*rb), IsOk());
264
265 EXPECT_EQ(audio_specific_config.sample_frequency_index_,
266 SampleFrequencyIndex::kEscapeValue);
267 EXPECT_EQ(audio_specific_config.sampling_frequency_, kSampleFrequency);
268 }
269
TEST(AacDecoderConfig,ReadAndValidateReadsAllFields)270 TEST(AacDecoderConfig, ReadAndValidateReadsAllFields) {
271 std::vector<uint8_t> data = {
272 // `decoder_config_descriptor_tag`
273 AacDecoderConfig::kDecoderConfigDescriptorTag,
274 // ISO 14496:1 expandable size field.
275 17,
276 // `object_type_indication`.
277 AacDecoderConfig::kObjectTypeIndication,
278 // `stream_type`, `upstream`, `reserved`.
279 kStreamTypeUpstreamReserved,
280 // `buffer_size_db`.
281 0, 0, 0,
282 // `max_bitrate`.
283 0, 0, 0, 0,
284 // `average_bit_rate`.
285 0, 0, 0, 0,
286 // `decoder_specific_info_tag`
287 AacDecoderConfig::DecoderSpecificInfo::kDecoderSpecificInfoTag,
288 // ISO 14496:1 expandable size field.
289 2,
290 // `audio_object_type`, upper 3 bits of `sample_frequency_index`.
291 AudioSpecificConfig::kAudioObjectType << 3 |
292 kUpperByteSerializedSamplingFrequencyIndex64000,
293 // lower bit of `sample_frequency_index`,
294 // `channel_configuration`, `frame_length_flag`,
295 // `depends_on_core_coder`, `extension_flag`.
296 kLowerByteSerializedSamplingFrequencyIndex64000 |
297 kChannelConfigurationAndGaSpecificConfigMask};
298 AacDecoderConfig decoder_config;
299 auto rb =
300 MemoryBasedReadBitBuffer::CreateFromSpan(1024, absl::MakeConstSpan(data));
301
302 EXPECT_THAT(decoder_config.ReadAndValidate(kAudioRollDistance, *rb), IsOk());
303
304 EXPECT_EQ(decoder_config.decoder_config_descriptor_tag_,
305 AacDecoderConfig::kDecoderConfigDescriptorTag);
306 EXPECT_EQ(decoder_config.object_type_indication_,
307 AacDecoderConfig::kObjectTypeIndication);
308 EXPECT_EQ(decoder_config.stream_type_, AacDecoderConfig::kStreamType);
309 EXPECT_EQ(decoder_config.upstream_, AacDecoderConfig::kUpstream);
310 EXPECT_EQ(decoder_config.buffer_size_db_, 0);
311 EXPECT_EQ(decoder_config.max_bitrate_, 0);
312 EXPECT_EQ(decoder_config.average_bit_rate_, 0);
313 EXPECT_EQ(decoder_config.decoder_specific_info_.decoder_specific_info_tag,
314 AacDecoderConfig::DecoderSpecificInfo::kDecoderSpecificInfoTag);
315 EXPECT_TRUE(decoder_config.decoder_specific_info_
316 .decoder_specific_info_extension.empty());
317 EXPECT_TRUE(decoder_config.decoder_config_extension_.empty());
318 uint32_t sample_frequency;
319 EXPECT_THAT(decoder_config.GetOutputSampleRate(sample_frequency), IsOk());
320 EXPECT_EQ(sample_frequency, 64000);
321 }
322
TEST(AacDecoderConfig,ReadAndValidateWithExplicitSampleFrequency)323 TEST(AacDecoderConfig, ReadAndValidateWithExplicitSampleFrequency) {
324 std::vector<uint8_t> data = {
325 // `decoder_config_descriptor_tag`
326 AacDecoderConfig::kDecoderConfigDescriptorTag,
327 // ISO 14496:1 expandable size field.
328 20,
329 // `object_type_indication`.
330 AacDecoderConfig::kObjectTypeIndication,
331 // `stream_type`, `upstream`, `reserved`.
332 kStreamTypeUpstreamReserved,
333 // `buffer_size_db`.
334 0, 0, 0,
335 // `max_bitrate`.
336 0, 0, 0, 0,
337 // `average_bit_rate`.
338 0, 0, 0, 0,
339 // `decoder_specific_info_tag`
340 AacDecoderConfig::DecoderSpecificInfo::kDecoderSpecificInfoTag,
341 // ISO 14496:1 expandable size field.
342 5,
343 // `audio_object_type`, upper 3 bits of `sample_frequency_index`.
344 AudioSpecificConfig::kAudioObjectType << 3 |
345 kUpperByteSerializedSamplingFrequencyIndexEscape,
346 // lower bit of `sample_frequency_index`, upper 7 bits of
347 // `sampling_rate`.
348 kLowerByteSerializedSamplingFrequencyIndexEscape |
349 ((48000 & 0xe00000) >> 17),
350 // Next 16 bits of `sampling_rate`.
351 ((48000 & 0x1fe00) >> 9), ((48000 & 0x1fe) >> 1),
352 // Upper bit of `sampling_rate`, `channel_configuration`,
353 // `frame_length_flag`, `depends_on_core_coder`, `extension_flag`.
354 ((48000 & 1)) | kChannelConfigurationAndGaSpecificConfigMask};
355 AacDecoderConfig decoder_config;
356 auto rb =
357 MemoryBasedReadBitBuffer::CreateFromSpan(1024, absl::MakeConstSpan(data));
358
359 EXPECT_THAT(decoder_config.ReadAndValidate(kAudioRollDistance, *rb), IsOk());
360
361 uint32_t sample_frequency;
362 EXPECT_THAT(decoder_config.GetOutputSampleRate(sample_frequency), IsOk());
363 EXPECT_EQ(sample_frequency, 48000);
364 }
365
TEST(AacDecoderConfig,FailsIfDecoderConfigDescriptorExpandableSizeIsTooSmall)366 TEST(AacDecoderConfig, FailsIfDecoderConfigDescriptorExpandableSizeIsTooSmall) {
367 std::vector<uint8_t> data = {
368 // `decoder_config_descriptor_tag`
369 AacDecoderConfig::kDecoderConfigDescriptorTag,
370 // ISO 14496:1 expandable size field.
371 16,
372 // `object_type_indication`.
373 AacDecoderConfig::kObjectTypeIndication,
374 // `stream_type`, `upstream`, `reserved`.
375 kStreamTypeUpstreamReserved,
376 // `buffer_size_db`.
377 0, 0, 0,
378 // `max_bitrate`.
379 0, 0, 0, 0,
380 // `average_bit_rate`.
381 0, 0, 0, 0,
382 // `decoder_specific_info_tag`
383 AacDecoderConfig::DecoderSpecificInfo::kDecoderSpecificInfoTag,
384 // ISO 14496:1 expandable size field.
385 3,
386 // `audio_object_type`, upper 3 bits of `sample_frequency_index`.
387 AudioSpecificConfig::kAudioObjectType << 3 |
388 kUpperByteSerializedSamplingFrequencyIndex64000,
389 // lower bit of `sample_frequency_index`,
390 // `channel_configuration`, `frame_length_flag`,
391 // `depends_on_core_coder`, `extension_flag`.
392 kLowerByteSerializedSamplingFrequencyIndex64000 |
393 kChannelConfigurationAndGaSpecificConfigMask};
394 AacDecoderConfig decoder_config;
395 auto rb =
396 MemoryBasedReadBitBuffer::CreateFromSpan(1024, absl::MakeConstSpan(data));
397
398 EXPECT_FALSE(decoder_config.ReadAndValidate(kAudioRollDistance, *rb).ok());
399 }
400
TEST(AacDecoderConfig,ReadExtensions)401 TEST(AacDecoderConfig, ReadExtensions) {
402 std::vector<uint8_t> data = {
403 // `decoder_config_descriptor_tag`
404 AacDecoderConfig::kDecoderConfigDescriptorTag,
405 // ISO 14496:1 expandable size field.
406 23,
407 // `object_type_indication`.
408 AacDecoderConfig::kObjectTypeIndication,
409 // `stream_type`, `upstream`, `reserved`.
410 kStreamTypeUpstreamReserved,
411 // `buffer_size_db`.
412 0, 0, 0,
413 // `max_bitrate`.
414 0, 0, 0, 0,
415 // `average_bit_rate`.
416 0, 0, 0, 0,
417 // `decoder_specific_info_tag`
418 AacDecoderConfig::DecoderSpecificInfo::kDecoderSpecificInfoTag,
419 // ISO 14496:1 expandable size field.
420 5,
421 // `audio_object_type`, upper 3 bits of `sample_frequency_index`.
422 AudioSpecificConfig::kAudioObjectType << 3 |
423 kUpperByteSerializedSamplingFrequencyIndex64000,
424 // lower bit of `sample_frequency_index`,
425 // `channel_configuration`, `frame_length_flag`,
426 // `depends_on_core_coder`, `extension_flag`.
427 kLowerByteSerializedSamplingFrequencyIndex64000 |
428 kChannelConfigurationAndGaSpecificConfigMask,
429 'd', 'e', 'f', 'a', 'b', 'c'};
430 AacDecoderConfig decoder_config;
431 auto rb =
432 MemoryBasedReadBitBuffer::CreateFromSpan(1024, absl::MakeConstSpan(data));
433
434 EXPECT_THAT(decoder_config.ReadAndValidate(kAudioRollDistance, *rb), IsOk());
435
436 EXPECT_EQ(
437 decoder_config.decoder_specific_info_.decoder_specific_info_extension,
438 std::vector<uint8_t>({'d', 'e', 'f'}));
439 EXPECT_EQ(decoder_config.decoder_config_extension_,
440 std::vector<uint8_t>({'a', 'b', 'c'}));
441 }
442
TEST(AacDecoderConfig,ValidatesAudioRollDistance)443 TEST(AacDecoderConfig, ValidatesAudioRollDistance) {
444 std::vector<uint8_t> data = {
445 // `decoder_config_descriptor_tag`
446 AacDecoderConfig::kDecoderConfigDescriptorTag,
447 // ISO 14496:1 expandable size field.
448 17,
449 // `object_type_indication`.
450 AacDecoderConfig::kObjectTypeIndication,
451 // `stream_type`, `upstream`, `reserved`.
452 kStreamTypeUpstreamReserved,
453 // `buffer_size_db`.
454 0, 0, 0,
455 // `max_bitrate`.
456 0, 0, 0, 0,
457 // `average_bit_rate`.
458 0, 0, 0, 0,
459 // `decoder_specific_info_tag`
460 AacDecoderConfig::DecoderSpecificInfo::kDecoderSpecificInfoTag,
461 // ISO 14496:1 expandable size field.
462 2,
463 // `audio_object_type`, upper 3 bits of `sample_frequency_index`.
464 AudioSpecificConfig::kAudioObjectType << 3 |
465 kUpperByteSerializedSamplingFrequencyIndex64000,
466 // lower bit of `sample_frequency_index`,
467 // `channel_configuration`, `frame_length_flag`,
468 // `depends_on_core_coder`, `extension_flag`.
469 kLowerByteSerializedSamplingFrequencyIndex64000 |
470 kChannelConfigurationAndGaSpecificConfigMask};
471 AacDecoderConfig decoder_config;
472 auto rb =
473 MemoryBasedReadBitBuffer::CreateFromSpan(1024, absl::MakeConstSpan(data));
474
475 EXPECT_FALSE(
476 decoder_config.ReadAndValidate(kInvalidAudioRollDistance, *rb).ok());
477 }
478
479 class AacTest : public testing::Test {
480 public:
AacTest()481 AacTest() : aac_decoder_config_(GetAacDecoderConfig()) {}
482
483 ~AacTest() = default;
484
485 protected:
TestWriteAudioSpecificConfig()486 void TestWriteAudioSpecificConfig() {
487 WriteBitBuffer wb(expected_audio_specific_config_.size());
488
489 EXPECT_EQ(aac_decoder_config_.decoder_specific_info_.audio_specific_config
490 .ValidateAndWrite(wb)
491 .ok(),
492 expected_write_is_ok_);
493
494 if (expected_write_is_ok_) {
495 ValidateWriteResults(wb, expected_audio_specific_config_);
496 }
497 }
498
TestWriteDecoderConfig()499 void TestWriteDecoderConfig() {
500 WriteBitBuffer wb(expected_decoder_config_payload_.size());
501
502 EXPECT_EQ(
503 aac_decoder_config_.ValidateAndWrite(audio_roll_distance_, wb).ok(),
504 expected_write_is_ok_);
505
506 if (expected_write_is_ok_) {
507 ValidateWriteResults(wb, expected_decoder_config_payload_);
508 }
509 }
510
511 // `audio_roll_distance_` would typically come from the associated Codec
512 // Config OBU. The IAMF specification REQUIRES this be -1.
513 int16_t audio_roll_distance_ = -1;
514
515 AacDecoderConfig aac_decoder_config_;
516
517 bool expected_write_is_ok_ = true;
518 std::vector<uint8_t> expected_decoder_config_payload_;
519 std::vector<uint8_t> expected_audio_specific_config_;
520 };
521
TEST_F(AacTest,DefaultWriteDecoderConfig)522 TEST_F(AacTest, DefaultWriteDecoderConfig) {
523 expected_decoder_config_payload_ = {
524 // Start `DecoderConfigDescriptor`.
525 // `decoder_config_descriptor_tag`
526 AacDecoderConfig::kDecoderConfigDescriptorTag,
527 // ISO 14496:1 expandable size field.
528 17,
529 // `object_type_indication`.
530 AacDecoderConfig::kObjectTypeIndication,
531 // `stream_type`, `upstream`, `reserved`.
532 kStreamTypeUpstreamReserved,
533 // `buffer_size_db`.
534 0, 0, 0,
535 // `max_bitrate`.
536 0, 0, 0, 0,
537 // `average_bit_rate`.
538 0, 0, 0, 0,
539 // Start `DecoderSpecificInfo`.
540 // `decoder_specific_info_tag`
541 AacDecoderConfig::DecoderSpecificInfo::kDecoderSpecificInfoTag,
542 // ISO 14496:1 expandable size field.
543 2,
544 // `audio_object_type`, upper 3 bits of `sample_frequency_index`.
545 AudioSpecificConfig::kAudioObjectType << 3 |
546 kUpperByteSerializedSamplingFrequencyIndex64000,
547 // lower bit of `sample_frequency_index`,
548 // `channel_configuration`, `frame_length_flag`,
549 // `depends_on_core_coder`, `extension_flag`.
550 kLowerByteSerializedSamplingFrequencyIndex64000 |
551 kChannelConfigurationAndGaSpecificConfigMask};
552 TestWriteDecoderConfig();
553 }
554
TEST_F(AacTest,WritesWithExtension)555 TEST_F(AacTest, WritesWithExtension) {
556 aac_decoder_config_.decoder_config_extension_ = {'a', 'b', 'c'};
557 aac_decoder_config_.decoder_specific_info_.decoder_specific_info_extension = {
558 'c', 'd', 'e'};
559 expected_decoder_config_payload_ = {
560 // Start `DecoderConfigDescriptor`.
561 // `decoder_config_descriptor_tag`
562 AacDecoderConfig::kDecoderConfigDescriptorTag,
563 // ISO 14496:1 expandable size field.
564 23,
565 // `object_type_indication`.
566 AacDecoderConfig::kObjectTypeIndication,
567 // `stream_type`, `upstream`, `reserved`.
568 kStreamTypeUpstreamReserved,
569 // `buffer_size_db`.
570 0, 0, 0,
571 // `max_bitrate`.
572 0, 0, 0, 0,
573 // `average_bit_rate`.
574 0, 0, 0, 0,
575 // Start `DecoderSpecificInfo`.
576 // `decoder_specific_info_tag`
577 AacDecoderConfig::DecoderSpecificInfo::kDecoderSpecificInfoTag,
578 // ISO 14496:1 expandable size field.
579 5,
580 // `audio_object_type`, upper 3 bits of `sample_frequency_index`.
581 AudioSpecificConfig::kAudioObjectType << 3 |
582 kUpperByteSerializedSamplingFrequencyIndex64000,
583 // lower bit of `sample_frequency_index`,
584 // `channel_configuration`, `frame_length_flag`,
585 // `depends_on_core_coder`, `extension_flag`.
586 kLowerByteSerializedSamplingFrequencyIndex64000 |
587 kChannelConfigurationAndGaSpecificConfigMask,
588 'c', 'd', 'e', 'a', 'b', 'c'};
589 TestWriteDecoderConfig();
590 }
591
TEST_F(AacTest,DefaultWriteAudioSpecificConfig)592 TEST_F(AacTest, DefaultWriteAudioSpecificConfig) {
593 expected_audio_specific_config_ = {
594 // `audio_object_type`, upper 3 bits of `sample_frequency_index`.
595 2 << 3 | kUpperByteSerializedSamplingFrequencyIndex64000,
596 // lower bit of `sample_frequency_index`,
597 // `channel_configuration`, `frame_length_flag`,
598 // `depends_on_core_coder`, `extension_flag`.
599 kLowerByteSerializedSamplingFrequencyIndex64000 |
600 kChannelConfigurationAndGaSpecificConfigMask};
601 TestWriteAudioSpecificConfig();
602 }
603
TEST_F(AacTest,ExplicitSampleRate)604 TEST_F(AacTest, ExplicitSampleRate) {
605 aac_decoder_config_.decoder_specific_info_.audio_specific_config
606 .sample_frequency_index_ = SampleFrequencyIndex::kEscapeValue;
607 aac_decoder_config_.decoder_specific_info_.audio_specific_config
608 .sampling_frequency_ = 48000;
609
610 expected_decoder_config_payload_ = {
611 // `decoder_config_descriptor_tag`
612 AacDecoderConfig::kDecoderConfigDescriptorTag,
613 // ISO 14496:1 expandable size field.
614 20,
615 // `object_type_indication`.
616 AacDecoderConfig::kObjectTypeIndication,
617 // `stream_type`, `upstream`, `reserved`.
618 kStreamTypeUpstreamReserved,
619 // `buffer_size_db`.
620 0, 0, 0,
621 // `max_bitrate`.
622 0, 0, 0, 0,
623 // `average_bit_rate`.
624 0, 0, 0, 0,
625 // `decoder_specific_info_tag`
626 AacDecoderConfig::DecoderSpecificInfo::kDecoderSpecificInfoTag,
627 // ISO 14496:1 expandable size field.
628 5,
629 // `audio_object_type`, upper 3 bits of `sample_frequency_index`.
630 AudioSpecificConfig::kAudioObjectType << 3 |
631 kUpperByteSerializedSamplingFrequencyIndexEscape,
632 // lower bit of `sample_frequency_index`, upper 7 bits of
633 // `sampling_rate`.
634 kLowerByteSerializedSamplingFrequencyIndexEscape |
635 ((48000 & 0xe00000) >> 17),
636 // Next 16 bits of `sampling_rate`.
637 ((48000 & 0x1fe00) >> 9), ((48000 & 0x1fe) >> 1),
638 // Upper bit of `sampling_rate`, `channel_configuration`,
639 // `frame_length_flag`, `depends_on_core_coder`, `extension_flag`.
640 ((48000 & 1)) | kChannelConfigurationAndGaSpecificConfigMask};
641 TestWriteDecoderConfig();
642 uint32_t sample_frequency;
643 EXPECT_THAT(aac_decoder_config_.GetOutputSampleRate(sample_frequency),
644 IsOk());
645 EXPECT_EQ(sample_frequency, 48000);
646 }
647
TEST_F(AacTest,ExplicitSampleRateAudioSpecificConfig)648 TEST_F(AacTest, ExplicitSampleRateAudioSpecificConfig) {
649 aac_decoder_config_.decoder_specific_info_.audio_specific_config
650 .sample_frequency_index_ = SampleFrequencyIndex::kEscapeValue;
651 aac_decoder_config_.decoder_specific_info_.audio_specific_config
652 .sampling_frequency_ = 48000;
653
654 expected_audio_specific_config_ = {
655 // `audio_object_type`, upper 3 bits of `sample_frequency_index`.
656 2 << 3 | kUpperByteSerializedSamplingFrequencyIndexEscape,
657 // lower bit of `sample_frequency_index`, upper 7 bits of
658 // `sampling_rate`.
659 kLowerByteSerializedSamplingFrequencyIndexEscape |
660 ((48000 & 0xe00000) >> 17),
661 // Next 16 bits of `sampling_rate`.
662 ((48000 & 0x1fe00) >> 9), ((48000 & 0x1fe) >> 1),
663 // Upper bit of `sampling_rate`, `channel_configuration`,
664 // `frame_length_flag`, `depends_on_core_coder`, `extension_flag`.
665 ((48000 & 1)) | kChannelConfigurationAndGaSpecificConfigMask};
666 TestWriteAudioSpecificConfig();
667 }
668
TEST_F(AacTest,IllegalAudioRollDistanceMustBeNegativeOne)669 TEST_F(AacTest, IllegalAudioRollDistanceMustBeNegativeOne) {
670 audio_roll_distance_ = 1;
671 expected_write_is_ok_ = false;
672 TestWriteDecoderConfig();
673 }
674
TEST_F(AacTest,MaxBufferSizeDb)675 TEST_F(AacTest, MaxBufferSizeDb) {
676 aac_decoder_config_.buffer_size_db_ = (1 << 24) - 1;
677
678 expected_decoder_config_payload_ = {
679 // `decoder_config_descriptor_tag`
680 AacDecoderConfig::kDecoderConfigDescriptorTag,
681 // ISO 14496:1 expandable size field.
682 17,
683 // `object_type_indication`.
684 AacDecoderConfig::kObjectTypeIndication,
685 // `stream_type`, `upstream`, `reserved`.
686 kStreamTypeUpstreamReserved,
687 // `buffer_size_db`.
688 0xff, 0xff, 0xff,
689 // `max_bitrate`.
690 0, 0, 0, 0,
691 // `average_bit_rate`.
692 0, 0, 0, 0,
693 // `decoder_specific_info_tag`
694 AacDecoderConfig::DecoderSpecificInfo::kDecoderSpecificInfoTag,
695 // ISO 14496:1 expandable size field.
696 2,
697 // `audio_object_type`, upper 3 bits of `sample_frequency_index`.
698 AudioSpecificConfig::kAudioObjectType << 3 |
699 kUpperByteSerializedSamplingFrequencyIndex64000,
700 // lower bit of `sample_frequency_index`,
701 // `channel_configuration`, `frame_length_flag`,
702 // `depends_on_core_coder`, `extension_flag`.
703 kLowerByteSerializedSamplingFrequencyIndex64000 |
704 kChannelConfigurationAndGaSpecificConfigMask};
705 TestWriteDecoderConfig();
706 }
707
TEST_F(AacTest,OverflowBufferSizeDbOver24Bits)708 TEST_F(AacTest, OverflowBufferSizeDbOver24Bits) {
709 // The spec defines this field as 24 bits. However it is represented in a
710 // field that is 32 bits. Any value that cannot be represented in 24 bits
711 // should fail.
712 aac_decoder_config_.buffer_size_db_ = (1 << 24);
713 expected_write_is_ok_ = false;
714 TestWriteDecoderConfig();
715 }
716
TEST_F(AacTest,GetImplicitSampleRate64000)717 TEST_F(AacTest, GetImplicitSampleRate64000) {
718 aac_decoder_config_.decoder_specific_info_.audio_specific_config
719 .sample_frequency_index_ = SampleFrequencyIndex::k64000;
720
721 uint32_t output_sample_rate;
722 EXPECT_THAT(aac_decoder_config_.GetOutputSampleRate(output_sample_rate),
723 IsOk());
724
725 EXPECT_EQ(output_sample_rate, 64000);
726 }
727
TEST_F(AacTest,GetImplicitSampleRate24000)728 TEST_F(AacTest, GetImplicitSampleRate24000) {
729 aac_decoder_config_.decoder_specific_info_.audio_specific_config
730 .sample_frequency_index_ = SampleFrequencyIndex::k24000;
731
732 uint32_t output_sample_rate;
733 EXPECT_THAT(aac_decoder_config_.GetOutputSampleRate(output_sample_rate),
734 IsOk());
735
736 EXPECT_EQ(output_sample_rate, 24000);
737 }
738
TEST_F(AacTest,GetExplicitSampleRate)739 TEST_F(AacTest, GetExplicitSampleRate) {
740 aac_decoder_config_.decoder_specific_info_.audio_specific_config
741 .sample_frequency_index_ = SampleFrequencyIndex::kEscapeValue;
742 aac_decoder_config_.decoder_specific_info_.audio_specific_config
743 .sampling_frequency_ = 1234;
744
745 uint32_t output_sample_rate;
746 EXPECT_THAT(aac_decoder_config_.GetOutputSampleRate(output_sample_rate),
747 IsOk());
748 EXPECT_EQ(output_sample_rate, 1234);
749 }
750
TEST_F(AacTest,InvalidReservedSampleRate)751 TEST_F(AacTest, InvalidReservedSampleRate) {
752 aac_decoder_config_.decoder_specific_info_.audio_specific_config
753 .sample_frequency_index_ = SampleFrequencyIndex::kReservedA;
754
755 uint32_t undetermined_output_sample_rate;
756 EXPECT_FALSE(
757 aac_decoder_config_.GetOutputSampleRate(undetermined_output_sample_rate)
758 .ok());
759 }
760
761 } // namespace
762 } // namespace iamf_tools
763