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/opus_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 using ::absl_testing::IsOkAndHolds;
31
32 class OpusTest : public testing::Test {
33 public:
OpusTest()34 OpusTest() : opus_decoder_config_({.version_ = 1, .pre_skip_ = 0}) {}
35 ~OpusTest() = default;
36
37 protected:
TestWriteDecoderConfig()38 void TestWriteDecoderConfig() {
39 WriteBitBuffer wb(expected_decoder_config_payload_.size());
40
41 // `num_samples_per_frame` and `audio_roll_distance` would typically come
42 // from the associated Codec Config OBU. Choose arbitrary legal values as
43 // default.
44 static constexpr uint32_t kNumSamplesPerFrame = 960;
45 static constexpr int16_t kAudioRollDistance = -4;
46
47 EXPECT_EQ(opus_decoder_config_
48 .ValidateAndWrite(kNumSamplesPerFrame, kAudioRollDistance, wb)
49 .code(),
50 expected_write_status_code_);
51
52 if (expected_write_status_code_ == absl::StatusCode::kOk) {
53 ValidateWriteResults(wb, expected_decoder_config_payload_);
54 }
55 }
56
57 OpusDecoderConfig opus_decoder_config_;
58
59 absl::StatusCode expected_write_status_code_ = absl::StatusCode::kOk;
60 std::vector<uint8_t> expected_decoder_config_payload_;
61 };
62
TEST(OpusDecoderConfig,IamfFixedFieldsAreDefault)63 TEST(OpusDecoderConfig, IamfFixedFieldsAreDefault) {
64 OpusDecoderConfig decoder_config;
65 // The IAMF spec REQUIRES fixed fields for all Opus Decoder Configs. Verify
66 // the default constructor configures these to the fixed values.
67 EXPECT_EQ(decoder_config.output_channel_count_,
68 OpusDecoderConfig::kOutputChannelCount);
69 EXPECT_EQ(decoder_config.output_gain_, OpusDecoderConfig::kOutputGain);
70 EXPECT_EQ(decoder_config.mapping_family_, OpusDecoderConfig::kMappingFamily);
71 }
72
TEST_F(OpusTest,WriteDefault)73 TEST_F(OpusTest, WriteDefault) {
74 expected_decoder_config_payload_ = {// `version`.
75 1,
76 // `output_channel_count`.
77 OpusDecoderConfig::kOutputChannelCount,
78 // `pre_skip`.
79 0, 0,
80 // `input_sample_rate`.
81 0, 0, 0, 0,
82 // `output_gain`.
83 0, 0,
84 // `mapping_family`.
85 OpusDecoderConfig::kMappingFamily};
86 TestWriteDecoderConfig();
87 }
88
TEST_F(OpusTest,VaryAllLegalFields)89 TEST_F(OpusTest, VaryAllLegalFields) {
90 opus_decoder_config_ = {
91 .version_ = 2, .pre_skip_ = 3, .input_sample_rate_ = 4};
92 expected_decoder_config_payload_ = {// `version`.
93 2,
94 // `output_channel_count`.
95 OpusDecoderConfig::kOutputChannelCount,
96 // `pre_skip`.
97 0, 3,
98 // `input_sample_rate`.
99 0, 0, 0, 4,
100 // `output_gain`.
101 0, 0,
102 // `mapping_family`.
103 OpusDecoderConfig::kMappingFamily};
104 TestWriteDecoderConfig();
105 }
106
TEST_F(OpusTest,MaxAllLegalFields)107 TEST_F(OpusTest, MaxAllLegalFields) {
108 opus_decoder_config_ = {
109 .version_ = 15, .pre_skip_ = 0xffff, .input_sample_rate_ = 0xffffffff};
110 expected_decoder_config_payload_ = {// `version`.
111 15,
112 // `output_channel_count`.
113 OpusDecoderConfig::kOutputChannelCount,
114 // `pre_skip`.
115 0xff, 0xff,
116 // `input_sample_rate`.
117 0xff, 0xff, 0xff, 0xff,
118 // `output_gain`.
119 0, 0,
120 // `mapping_family`.
121 OpusDecoderConfig::kMappingFamily};
122 TestWriteDecoderConfig();
123 }
124
TEST_F(OpusTest,MinorVersion)125 TEST_F(OpusTest, MinorVersion) {
126 opus_decoder_config_.version_ = 2;
127 expected_decoder_config_payload_ = {// `version`.
128 2,
129 // `output_channel_count`.
130 OpusDecoderConfig::kOutputChannelCount,
131 // `pre_skip`.
132 0, 0,
133 // `input_sample_rate`.
134 0, 0, 0, 0,
135 // `output_gain`.
136 0, 0,
137 // `mapping_family`.
138 OpusDecoderConfig::kMappingFamily};
139 TestWriteDecoderConfig();
140 }
141
TEST_F(OpusTest,IllegalVersionZero)142 TEST_F(OpusTest, IllegalVersionZero) {
143 opus_decoder_config_.version_ = 0;
144 expected_write_status_code_ = absl::StatusCode::kInvalidArgument;
145 TestWriteDecoderConfig();
146 }
147
TEST_F(OpusTest,IllegalVersionFuture)148 TEST_F(OpusTest, IllegalVersionFuture) {
149 opus_decoder_config_.version_ = 16;
150 expected_write_status_code_ = absl::StatusCode::kUnimplemented;
151 TestWriteDecoderConfig();
152 }
153
TEST_F(OpusTest,IllegalVersionMax)154 TEST_F(OpusTest, IllegalVersionMax) {
155 opus_decoder_config_.version_ = 255;
156 expected_write_status_code_ = absl::StatusCode::kUnimplemented;
157 TestWriteDecoderConfig();
158 }
159
TEST_F(OpusTest,IllegalChannelCountZero)160 TEST_F(OpusTest, IllegalChannelCountZero) {
161 opus_decoder_config_.output_channel_count_ = 0;
162 expected_write_status_code_ = absl::StatusCode::kInvalidArgument;
163 TestWriteDecoderConfig();
164 }
165
TEST_F(OpusTest,IllegalChannelCountEdgeBelow)166 TEST_F(OpusTest, IllegalChannelCountEdgeBelow) {
167 opus_decoder_config_.output_channel_count_ = 1;
168 expected_write_status_code_ = absl::StatusCode::kInvalidArgument;
169 TestWriteDecoderConfig();
170 }
171
TEST_F(OpusTest,IllegalChannelCountEdgeAbove)172 TEST_F(OpusTest, IllegalChannelCountEdgeAbove) {
173 opus_decoder_config_.output_channel_count_ = 3;
174 expected_write_status_code_ = absl::StatusCode::kInvalidArgument;
175 TestWriteDecoderConfig();
176 }
177
TEST_F(OpusTest,WritePreSkip)178 TEST_F(OpusTest, WritePreSkip) {
179 opus_decoder_config_.pre_skip_ = 1;
180 expected_decoder_config_payload_ = {// `version`.
181 1,
182 // `output_channel_count`.
183 OpusDecoderConfig::kOutputChannelCount,
184 // `pre_skip`.
185 0, 1,
186 // `input_sample_rate`.
187 0, 0, 0, 0,
188 // `output_gain`.
189 0, 0,
190 // `mapping_family`.
191 OpusDecoderConfig::kMappingFamily};
192 TestWriteDecoderConfig();
193 }
194
TEST_F(OpusTest,WritePreSkip312)195 TEST_F(OpusTest, WritePreSkip312) {
196 opus_decoder_config_.pre_skip_ = 312;
197 expected_decoder_config_payload_ = {// `version`.
198 1,
199 // `output_channel_count`.
200 OpusDecoderConfig::kOutputChannelCount,
201 // `pre_skip`.
202 0x01, 0x38,
203 // `input_sample_rate`.
204 0, 0, 0, 0,
205 // `output_gain`.
206 0, 0,
207 // `mapping_family`.
208 OpusDecoderConfig::kMappingFamily};
209 TestWriteDecoderConfig();
210 }
211
TEST_F(OpusTest,WriteSampleRate48kHz)212 TEST_F(OpusTest, WriteSampleRate48kHz) {
213 opus_decoder_config_.input_sample_rate_ = 48000;
214 expected_decoder_config_payload_ = {// `version`.
215 1,
216 // `output_channel_count`.
217 OpusDecoderConfig::kOutputChannelCount,
218 // `pre_skip`.
219 0, 0,
220 // `input_sample_rate`.
221 0, 0, 0xbb, 0x80,
222 // `output_gain`.
223 0, 0,
224 // `mapping_family`.
225 OpusDecoderConfig::kMappingFamily};
226 TestWriteDecoderConfig();
227 }
228
TEST_F(OpusTest,WriteSampleRate192kHz)229 TEST_F(OpusTest, WriteSampleRate192kHz) {
230 opus_decoder_config_.input_sample_rate_ = 192000;
231 expected_decoder_config_payload_ = {// `version`.
232 1,
233 // `output_channel_count`.
234 OpusDecoderConfig::kOutputChannelCount,
235 // `pre_skip`.
236 0, 0,
237 // `input_sample_rate`.
238 0, 0x2, 0xee, 0x00,
239 // `output_gain`.
240 0, 0,
241 // `mapping_family`.
242 OpusDecoderConfig::kMappingFamily};
243 TestWriteDecoderConfig();
244 }
245
TEST_F(OpusTest,GetInputSampleRateZero)246 TEST_F(OpusTest, GetInputSampleRateZero) {
247 opus_decoder_config_.input_sample_rate_ = 0;
248 EXPECT_EQ(opus_decoder_config_.GetInputSampleRate(), 0);
249 }
250
TEST_F(OpusTest,GetInputSampleRate96kHz)251 TEST_F(OpusTest, GetInputSampleRate96kHz) {
252 opus_decoder_config_.input_sample_rate_ = 96000;
253 EXPECT_EQ(opus_decoder_config_.GetInputSampleRate(), 96000);
254 }
255
TEST_F(OpusTest,AlwaysReturns48kHz)256 TEST_F(OpusTest, AlwaysReturns48kHz) {
257 EXPECT_EQ(opus_decoder_config_.GetOutputSampleRate(), 48000);
258 }
259
TEST(GetBitDepthToMeasureLoudness,AlwaysReturns32)260 TEST(GetBitDepthToMeasureLoudness, AlwaysReturns32) {
261 EXPECT_EQ(OpusDecoderConfig::GetBitDepthToMeasureLoudness(), 32);
262 }
263
TEST_F(OpusTest,IllegalOutputGainNotZero)264 TEST_F(OpusTest, IllegalOutputGainNotZero) {
265 opus_decoder_config_.output_gain_ = 1;
266 expected_write_status_code_ = absl::StatusCode::kInvalidArgument;
267 TestWriteDecoderConfig();
268 }
269
TEST_F(OpusTest,IllegalMappingFamilyNotZero)270 TEST_F(OpusTest, IllegalMappingFamilyNotZero) {
271 opus_decoder_config_.mapping_family_ = 1;
272 expected_write_status_code_ = absl::StatusCode::kInvalidArgument;
273 TestWriteDecoderConfig();
274 }
275
276 // --- Begin ReadAndValidate Tests ---
277
TEST(ReadAndValidate,VaryAllLegalFields)278 TEST(ReadAndValidate, VaryAllLegalFields) {
279 OpusDecoderConfig opus_decoder_config;
280 uint32_t num_samples_per_frame = 960;
281 int16_t audio_roll_distance = -4;
282 std::vector<uint8_t> source = {// `version`.
283 2,
284 // `output_channel_count`.
285 OpusDecoderConfig::kOutputChannelCount,
286 // `pre_skip`.
287 0, 3,
288 // `input_sample_rate`.
289 0, 0, 0, 4,
290 // `output_gain`.
291 0, 0,
292 // `mapping_family`.
293 OpusDecoderConfig::kMappingFamily};
294 auto read_buffer = MemoryBasedReadBitBuffer::CreateFromSpan(
295 1024, absl::MakeConstSpan(source));
296 EXPECT_THAT(opus_decoder_config.ReadAndValidate(
297 num_samples_per_frame, audio_roll_distance, *read_buffer),
298 IsOk());
299
300 EXPECT_EQ(opus_decoder_config.version_, 2);
301 EXPECT_EQ(opus_decoder_config.pre_skip_, 3);
302 EXPECT_EQ(opus_decoder_config.input_sample_rate_, 4);
303 }
304
TEST(ReadAndValidate,MaxAllLegalFields)305 TEST(ReadAndValidate, MaxAllLegalFields) {
306 OpusDecoderConfig opus_decoder_config;
307 uint32_t num_samples_per_frame = 960;
308 int16_t audio_roll_distance = -4;
309 std::vector<uint8_t> source = {// `version`.
310 15,
311 // `output_channel_count`.
312 OpusDecoderConfig::kOutputChannelCount,
313 // `pre_skip`.
314 0xff, 0xff,
315 // `input_sample_rate`.
316 0xff, 0xff, 0xff, 0xff,
317 // `output_gain`.
318 0, 0,
319 // `mapping_family`.
320 OpusDecoderConfig::kMappingFamily};
321 auto read_buffer = MemoryBasedReadBitBuffer::CreateFromSpan(
322 1024, absl::MakeConstSpan(source));
323 EXPECT_THAT(opus_decoder_config.ReadAndValidate(
324 num_samples_per_frame, audio_roll_distance, *read_buffer),
325 IsOk());
326
327 EXPECT_EQ(opus_decoder_config.version_, 15);
328 EXPECT_EQ(opus_decoder_config.pre_skip_, 0xffff);
329 EXPECT_EQ(opus_decoder_config.input_sample_rate_, 0xffffffff);
330 }
331
TEST(ReadAndValidate,MinorVersion)332 TEST(ReadAndValidate, MinorVersion) {
333 OpusDecoderConfig opus_decoder_config;
334 uint32_t num_samples_per_frame = 960;
335 int16_t audio_roll_distance = -4;
336 std::vector<uint8_t> source = {// `version`.
337 2,
338 // `output_channel_count`.
339 OpusDecoderConfig::kOutputChannelCount,
340 // `pre_skip`.
341 0, 0,
342 // `input_sample_rate`.
343 0, 0, 0, 0,
344 // `output_gain`.
345 0, 0,
346 // `mapping_family`.
347 OpusDecoderConfig::kMappingFamily};
348 auto read_buffer = MemoryBasedReadBitBuffer::CreateFromSpan(
349 1024, absl::MakeConstSpan(source));
350 EXPECT_THAT(opus_decoder_config.ReadAndValidate(
351 num_samples_per_frame, audio_roll_distance, *read_buffer),
352 IsOk());
353
354 EXPECT_EQ(opus_decoder_config.version_, 2);
355 }
356
TEST(ReadAndValidate,IllegalVersionZero)357 TEST(ReadAndValidate, IllegalVersionZero) {
358 OpusDecoderConfig opus_decoder_config;
359 uint32_t num_samples_per_frame = 960;
360 int16_t audio_roll_distance = -4;
361 std::vector<uint8_t> source = {// `version`.
362 0,
363 // `output_channel_count`.
364 OpusDecoderConfig::kOutputChannelCount,
365 // `pre_skip`.
366 0, 0,
367 // `input_sample_rate`.
368 0, 0, 0, 0,
369 // `output_gain`.
370 0, 0,
371 // `mapping_family`.
372 OpusDecoderConfig::kMappingFamily};
373 auto read_buffer = MemoryBasedReadBitBuffer::CreateFromSpan(
374 1024, absl::MakeConstSpan(source));
375 EXPECT_FALSE(opus_decoder_config
376 .ReadAndValidate(num_samples_per_frame, audio_roll_distance,
377 *read_buffer)
378 .ok());
379 }
380
TEST(ReadAndValidate,IllegalVersionFuture)381 TEST(ReadAndValidate, IllegalVersionFuture) {
382 OpusDecoderConfig opus_decoder_config;
383 uint32_t num_samples_per_frame = 960;
384 int16_t audio_roll_distance = -4;
385 std::vector<uint8_t> source = {// `version`.
386 16,
387 // `output_channel_count`.
388 OpusDecoderConfig::kOutputChannelCount,
389 // `pre_skip`.
390 0, 0,
391 // `input_sample_rate`.
392 0, 0, 0, 0,
393 // `output_gain`.
394 0, 0,
395 // `mapping_family`.
396 OpusDecoderConfig::kMappingFamily};
397 auto read_buffer = MemoryBasedReadBitBuffer::CreateFromSpan(
398 1024, absl::MakeConstSpan(source));
399 EXPECT_FALSE(opus_decoder_config
400 .ReadAndValidate(num_samples_per_frame, audio_roll_distance,
401 *read_buffer)
402 .ok());
403 }
404
TEST(ReadAndValidate,IllegalVersionmax)405 TEST(ReadAndValidate, IllegalVersionmax) {
406 OpusDecoderConfig opus_decoder_config;
407 uint32_t num_samples_per_frame = 960;
408 int16_t audio_roll_distance = -4;
409 std::vector<uint8_t> source = {// `version`.
410 255,
411 // `output_channel_count`.
412 OpusDecoderConfig::kOutputChannelCount,
413 // `pre_skip`.
414 0, 0,
415 // `input_sample_rate`.
416 0, 0, 0, 0,
417 // `output_gain`.
418 0, 0,
419 // `mapping_family`.
420 OpusDecoderConfig::kMappingFamily};
421 auto read_buffer = MemoryBasedReadBitBuffer::CreateFromSpan(
422 1024, absl::MakeConstSpan(source));
423 EXPECT_FALSE(opus_decoder_config
424 .ReadAndValidate(num_samples_per_frame, audio_roll_distance,
425 *read_buffer)
426 .ok());
427 }
428
TEST(ReadAndValidate,IllegalChannelCountZero)429 TEST(ReadAndValidate, IllegalChannelCountZero) {
430 OpusDecoderConfig opus_decoder_config;
431 uint32_t num_samples_per_frame = 960;
432 int16_t audio_roll_distance = -4;
433 std::vector<uint8_t> source = {// `version`.
434 2,
435 // `output_channel_count`.
436 0,
437 // `pre_skip`.
438 0, 0,
439 // `input_sample_rate`.
440 0, 0, 0, 0,
441 // `output_gain`.
442 0, 0,
443 // `mapping_family`.
444 OpusDecoderConfig::kMappingFamily};
445 auto read_buffer = MemoryBasedReadBitBuffer::CreateFromSpan(
446 1024, absl::MakeConstSpan(source));
447 EXPECT_FALSE(opus_decoder_config
448 .ReadAndValidate(num_samples_per_frame, audio_roll_distance,
449 *read_buffer)
450 .ok());
451 }
452
TEST(ReadAndValidate,ReadPreSkip312)453 TEST(ReadAndValidate, ReadPreSkip312) {
454 OpusDecoderConfig opus_decoder_config;
455 uint32_t num_samples_per_frame = 960;
456 int16_t audio_roll_distance = -4;
457 std::vector<uint8_t> source = {// `version`.
458 1,
459 // `output_channel_count`.
460 OpusDecoderConfig::kOutputChannelCount,
461 // `pre_skip`.
462 0x01, 0x38,
463 // `input_sample_rate`.
464 0, 0, 0, 0,
465 // `output_gain`.
466 0, 0,
467 // `mapping_family`.
468 OpusDecoderConfig::kMappingFamily};
469 auto read_buffer = MemoryBasedReadBitBuffer::CreateFromSpan(
470 1024, absl::MakeConstSpan(source));
471 EXPECT_THAT(opus_decoder_config.ReadAndValidate(
472 num_samples_per_frame, audio_roll_distance, *read_buffer),
473 IsOk());
474
475 EXPECT_EQ(opus_decoder_config.version_, 1);
476 EXPECT_EQ(opus_decoder_config.pre_skip_, 312);
477 }
478
TEST(ReadAndValidate,ReadSampleRate48kHz)479 TEST(ReadAndValidate, ReadSampleRate48kHz) {
480 OpusDecoderConfig opus_decoder_config;
481 uint32_t num_samples_per_frame = 960;
482 int16_t audio_roll_distance = -4;
483 std::vector<uint8_t> source = {// `version`.
484 1,
485 // `output_channel_count`.
486 OpusDecoderConfig::kOutputChannelCount,
487 // `pre_skip`.
488 0, 0,
489 // `input_sample_rate`.
490 0, 0, 0xbb, 0x80,
491 // `output_gain`.
492 0, 0,
493 // `mapping_family`.
494 OpusDecoderConfig::kMappingFamily};
495 auto read_buffer = MemoryBasedReadBitBuffer::CreateFromSpan(
496 1024, absl::MakeConstSpan(source));
497 EXPECT_THAT(opus_decoder_config.ReadAndValidate(
498 num_samples_per_frame, audio_roll_distance, *read_buffer),
499 IsOk());
500
501 EXPECT_EQ(opus_decoder_config.version_, 1);
502 EXPECT_EQ(opus_decoder_config.input_sample_rate_, 48000);
503 }
504
TEST(ReadAndValidate,ReadSampleRate192kHz)505 TEST(ReadAndValidate, ReadSampleRate192kHz) {
506 OpusDecoderConfig opus_decoder_config;
507 uint32_t num_samples_per_frame = 960;
508 int16_t audio_roll_distance = -4;
509 std::vector<uint8_t> source = {// `version`.
510 1,
511 // `output_channel_count`.
512 OpusDecoderConfig::kOutputChannelCount,
513 // `pre_skip`.
514 0, 0,
515 // `input_sample_rate`.
516 0, 0x2, 0xee, 0x00,
517 // `output_gain`.
518 0, 0,
519 // `mapping_family`.
520 OpusDecoderConfig::kMappingFamily};
521 auto read_buffer = MemoryBasedReadBitBuffer::CreateFromSpan(
522 1024, absl::MakeConstSpan(source));
523 EXPECT_THAT(opus_decoder_config.ReadAndValidate(
524 num_samples_per_frame, audio_roll_distance, *read_buffer),
525 IsOk());
526
527 EXPECT_EQ(opus_decoder_config.version_, 1);
528 EXPECT_EQ(opus_decoder_config.input_sample_rate_, 192000);
529 }
530
531 struct GetRequiredAudioRollDistanceTestCase {
532 uint32_t num_samples_per_frame;
533 int16_t expected_audio_roll_distance;
534 };
535
536 class GetRequiredAudioRollDistanceTest
537 : public testing::TestWithParam<GetRequiredAudioRollDistanceTestCase> {};
538
TEST_P(GetRequiredAudioRollDistanceTest,ValidAudioRollDistance)539 TEST_P(GetRequiredAudioRollDistanceTest, ValidAudioRollDistance) {
540 EXPECT_THAT(OpusDecoderConfig::GetRequiredAudioRollDistance(
541 GetParam().num_samples_per_frame),
542 IsOkAndHolds(GetParam().expected_audio_roll_distance));
543 }
544
545 INSTANTIATE_TEST_SUITE_P(
546 Legal, GetRequiredAudioRollDistanceTest,
547 testing::ValuesIn<GetRequiredAudioRollDistanceTestCase>({
548 {1, -3840},
549 {2, -1920},
550 {3, -1280},
551 {7, -549},
552 {240, -16},
553 {959, -5},
554 {960, -4},
555 {1280, -3},
556 {1920, -2},
557 {3840, -1},
558 {0xffffffff, -1},
559 }));
560
TEST(GetRequiredAudioRollDistance,IsInvalidWhenNumSamplesPerFrameIsZero)561 TEST(GetRequiredAudioRollDistance, IsInvalidWhenNumSamplesPerFrameIsZero) {
562 constexpr uint32_t kInvalidNumSamplesPerFrame = 0;
563 EXPECT_FALSE(OpusDecoderConfig::GetRequiredAudioRollDistance(
564 kInvalidNumSamplesPerFrame)
565 .ok());
566 }
567
TEST(ValidateAndWrite,ValidatesAudioRollDistance)568 TEST(ValidateAndWrite, ValidatesAudioRollDistance) {
569 constexpr OpusDecoderConfig opus_decoder_config_ = {
570 .version_ = 1, .pre_skip_ = 312, .input_sample_rate_ = 0};
571 constexpr uint32_t kNumSamplesPerFrame = 960;
572 constexpr int16_t kAudioRollDistance = -4;
573 constexpr int16_t kInvalidAudioRollDistance = -5;
574 WriteBitBuffer ignored_wb(128);
575
576 EXPECT_THAT(opus_decoder_config_.ValidateAndWrite(
577 kNumSamplesPerFrame, kAudioRollDistance, ignored_wb),
578 IsOk());
579 EXPECT_FALSE(opus_decoder_config_
580 .ValidateAndWrite(kNumSamplesPerFrame,
581 kInvalidAudioRollDistance, ignored_wb)
582 .ok());
583 }
584
585 } // namespace
586 } // namespace iamf_tools
587