starboard/shared/starboard/player/decoded_audio_test_internal.cc - cobalt - Git at Google

 // Copyright 2023 The Cobalt Authors. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "starboard/shared/starboard/player/decoded_audio_internal.h"

 #include <cmath>
 #include <utility>

 #include "starboard/common/log.h"
 #include "starboard/shared/starboard/media/media_util.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace starboard {
 namespace shared {
 namespace starboard {
 namespace player {
 namespace {

 using ::starboard::shared::starboard::media::GetBytesPerSample;

 constexpr int kChannels = 2;
 constexpr SbTime kTimestamp = kSbTimeSecond;
 constexpr int kSizeInBytes = 4192;
 constexpr int kSampleRate = 22050;

 constexpr double kPi = 3.1415926535897932384626;

 constexpr SbMediaAudioSampleType kSampleTypes[] = {
     kSbMediaAudioSampleTypeInt16Deprecated, kSbMediaAudioSampleTypeFloat32};
 constexpr SbMediaAudioFrameStorageType kStorageTypes[] = {
     kSbMediaAudioFrameStorageTypeInterleaved,
     kSbMediaAudioFrameStorageTypePlanar};

 // The following two functions fill `data` with audio samples of a sine wave
 // starting from `initial_angle`.  `stride` is the number of samples per group.
 // For example:
 // 1. When `stride` is one, all samples filled with be continuous.
 // 2. When `stride` is 2, filling `data` and `data + 1` fills an interleaved
 //    stereo audio buffer with samples.
 void Fill(int16_t* data,
           double initial_angle,
           double angle_step,
           int count,
           int stride) {
   SB_DCHECK(data);

   auto current_angel = initial_angle;
   for (int i = 0; i < count; ++i) {
     *data = static_cast<int16_t>(sin(current_angel) * 32767);
     current_angel += angle_step;
     data += stride;
   }
 }

 void Fill(float* data,
           double initial_angle,
           double angle_step,
           int count,
           int stride) {
   SB_DCHECK(data);

   auto current_angel = initial_angle;
   for (int i = 0; i < count; ++i) {
     *data = static_cast<float>(sin(current_angel));
     current_angel += angle_step;
     data += stride;
   }
 }

 // The following two functions verify `data` with audio samples against a sine
 // wave starting from `initial_angle`.  `stride` is the number of samples per
 // group.  For example:
 // 1. When `stride` is one, all samples will be treated as continuous.
 // 2. When `stride` is 2, verifying against `data` and `data + 1` verifies an
 //    interleaved stereo audio buffer.
 void Verify(const int16_t* data,
             double initial_angle,
             double angle_step,
             int count,
             int stride) {
   SB_DCHECK(data);

   auto current_angel = initial_angle;
   for (int i = 0; i < count; ++i) {
     const auto current_value = static_cast<int16_t>(sin(current_angel) * 32767);
     // Using `ASSERT_NEAR()` to allow for small value drifting due to
     // conversions between sample types.
     ASSERT_NEAR(static_cast<double>(*data), static_cast<double>(current_value),
                 2.0 / 32767);
     current_angel += angle_step;
     data += stride;
   }
 }

 void Verify(const float* data,
             double initial_angle,
             double angle_step,
             int count,
             int stride) {
   SB_DCHECK(data);

   auto current_angel = initial_angle;
   for (int i = 0; i < count; ++i) {
     const auto current_value = static_cast<float>(sin(current_angel));
     // Using `ASSERT_NEAR()` to allow for small value drifting due to
     // conversions between sample types.
     ASSERT_NEAR(static_cast<double>(*data), static_cast<double>(current_value),
                 2.0 / 32767);
     current_angel += angle_step;
     data += stride;
   }
 }

 // Fill `decoded_audio` with sine wave samples, with phase shift of Pi/2 on each
 // channel.
 void Fill(scoped_refptr<DecodedAudio>* decoded_audio) {
   SB_DCHECK(decoded_audio);
   SB_DCHECK(*decoded_audio);

   bool is_int16 =
       (*decoded_audio)->sample_type() == kSbMediaAudioSampleTypeInt16Deprecated;
   bool is_interleaved = (*decoded_audio)->storage_type() ==
                         kSbMediaAudioFrameStorageTypeInterleaved;

   for (int i = 0; i < (*decoded_audio)->channels(); ++i) {
     if (is_int16 && is_interleaved) {
       Fill((*decoded_audio)->data_as_int16() + i, kPi / 2 * i, kPi / 180,
            (*decoded_audio)->frames(), (*decoded_audio)->channels());
     } else if (!is_int16 && is_interleaved) {
       Fill((*decoded_audio)->data_as_float32() + i, kPi / 2 * i, kPi / 180,
            (*decoded_audio)->frames(), (*decoded_audio)->channels());
     } else if (is_int16 && !is_interleaved) {
       Fill((*decoded_audio)->data_as_int16() + (*decoded_audio)->frames() * i,
            kPi / 2 * i, kPi / 180, (*decoded_audio)->frames(), 1);
     } else if (!is_int16 && !is_interleaved) {
       Fill((*decoded_audio)->data_as_float32() + (*decoded_audio)->frames() * i,
            kPi / 2 * i, kPi / 180, (*decoded_audio)->frames(), 1);
     }
   }
 }

 // verify `decoded_audio` against sine wave samples, with phase shift of Pi/2 on
 // each channel.
 void Verify(const scoped_refptr<DecodedAudio>& decoded_audio) {
   SB_DCHECK(decoded_audio);

   bool is_int16 =
       decoded_audio->sample_type() == kSbMediaAudioSampleTypeInt16Deprecated;
   bool is_interleaved =
       decoded_audio->storage_type() == kSbMediaAudioFrameStorageTypeInterleaved;

   for (int i = 0; i < decoded_audio->channels(); ++i) {
     if (is_int16 && is_interleaved) {
       ASSERT_NO_FATAL_FAILURE(
           Verify(decoded_audio->data_as_int16() + i, kPi / 2 * i, kPi / 180,
                  decoded_audio->frames(), decoded_audio->channels()));
     } else if (!is_int16 && is_interleaved) {
       ASSERT_NO_FATAL_FAILURE(
           Verify(decoded_audio->data_as_float32() + i, kPi / 2 * i, kPi / 180,
                  decoded_audio->frames(), decoded_audio->channels()));
     } else if (is_int16 && !is_interleaved) {
       ASSERT_NO_FATAL_FAILURE(
           Verify(decoded_audio->data_as_int16() + decoded_audio->frames() * i,
                  kPi / 2 * i, kPi / 180, decoded_audio->frames(), 1));
     } else if (!is_int16 && !is_interleaved) {
       ASSERT_NO_FATAL_FAILURE(
           Verify(decoded_audio->data_as_float32() + decoded_audio->frames() * i,
                  kPi / 2 * i, kPi / 180, decoded_audio->frames(), 1));
     }
   }
 }

 TEST(DecodedAudioTest, DefaultCtor) {
   scoped_refptr<DecodedAudio> decoded_audio(new DecodedAudio);
   EXPECT_TRUE(decoded_audio->is_end_of_stream());
 }

 TEST(DecodedAudioTest, CtorWithSize) {
   for (auto sample_type : kSampleTypes) {
     for (auto storage_type : kStorageTypes) {
       scoped_refptr<DecodedAudio> decoded_audio(new DecodedAudio(
           kChannels, sample_type, storage_type, kTimestamp, kSizeInBytes));

       EXPECT_FALSE(decoded_audio->is_end_of_stream());
       EXPECT_EQ(decoded_audio->channels(), kChannels);
       EXPECT_EQ(decoded_audio->sample_type(), sample_type);
       EXPECT_EQ(decoded_audio->storage_type(), storage_type);
       EXPECT_EQ(decoded_audio->size_in_bytes(), kSizeInBytes);
       EXPECT_EQ(decoded_audio->frames(),
                 kSizeInBytes / GetBytesPerSample(decoded_audio->sample_type()) /
                     kChannels);

       Fill(&decoded_audio);
       Verify(decoded_audio);
     }
   }
 }

 TEST(DecodedAudioTest, AdjustForSeekTime) {
   for (int channels = 1; channels <= 6; ++channels) {
     for (auto sample_type : kSampleTypes) {
       scoped_refptr<DecodedAudio> original_decoded_audio(new DecodedAudio(
           kChannels, sample_type, kSbMediaAudioFrameStorageTypeInterleaved,
           kTimestamp, kSizeInBytes));
       Fill(&original_decoded_audio);

       scoped_refptr<DecodedAudio> adjusted_decoded_audio =
           original_decoded_audio->Clone();

       // Adjust to the beginning of `adjusted_decoded_audio` should be a no-op.
       adjusted_decoded_audio->AdjustForSeekTime(
           kSampleRate, adjusted_decoded_audio->timestamp());
       ASSERT_EQ(*original_decoded_audio, *adjusted_decoded_audio);

       // Adjust to an invalid timestamp before the time range of
       // `adjusted_decoded_audio`, it's a no-op.
       adjusted_decoded_audio->AdjustForSeekTime(
           kSampleRate, adjusted_decoded_audio->timestamp() - kSbTimeSecond / 2);
       ASSERT_EQ(*original_decoded_audio, *adjusted_decoded_audio);

       // Adjust to an invalid timestamp after the time range of
       // `adjusted_decoded_audio`, it's also a no-op.
       adjusted_decoded_audio->AdjustForSeekTime(
           kSampleRate,
           adjusted_decoded_audio->timestamp() + kSbTimeSecond * 100);
       ASSERT_EQ(*original_decoded_audio, *adjusted_decoded_audio);

       const SbTime duration = media::AudioFramesToDuration(
           adjusted_decoded_audio->frames(), kSampleRate);
       const SbTime duration_of_one_frame =
           media::AudioFramesToDuration(1, kSampleRate) + 1;
       for (int i = 1; i < 10; ++i) {
         adjusted_decoded_audio = original_decoded_audio->Clone();
         // Adjust to the middle of `adjusted_decoded_audio`.
         SbTime seek_time =
             adjusted_decoded_audio->timestamp() + duration * i / 10;
         adjusted_decoded_audio->AdjustForSeekTime(kSampleRate, seek_time);
         ASSERT_NEAR(adjusted_decoded_audio->frames(),
                     original_decoded_audio->frames() * (10 - i) / 10, 1);

         ASSERT_LE(adjusted_decoded_audio->timestamp(), seek_time);
         ASSERT_NEAR(adjusted_decoded_audio->timestamp(), seek_time,
                     duration_of_one_frame);

         auto offset_in_bytes = original_decoded_audio->size_in_bytes() -
                                adjusted_decoded_audio->size_in_bytes();
         ASSERT_TRUE(memcmp(adjusted_decoded_audio->data(),
                            original_decoded_audio->data() + offset_in_bytes,
                            adjusted_decoded_audio->size_in_bytes()) == 0);
       }
     }
   }
 }

 TEST(DecodedAudioTest, AdjustForDiscardedDurations) {
   for (int channels = 1; channels <= 6; ++channels) {
     for (auto sample_type : kSampleTypes) {
       scoped_refptr<DecodedAudio> original_decoded_audio(new DecodedAudio(
           kChannels, sample_type, kSbMediaAudioFrameStorageTypeInterleaved,
           kTimestamp, kSizeInBytes));
       Fill(&original_decoded_audio);

       scoped_refptr<DecodedAudio> adjusted_decoded_audio =
           original_decoded_audio->Clone();

       adjusted_decoded_audio->AdjustForDiscardedDurations(kSampleRate, 0, 0);
       ASSERT_EQ(*original_decoded_audio, *adjusted_decoded_audio);

       auto duration_of_decoded_audio = media::AudioFramesToDuration(
           original_decoded_audio->frames(), kSampleRate);
       auto quarter_duration = duration_of_decoded_audio / 4;
       auto duration_of_one_frame =
           media::AudioFramesToDuration(1, kSampleRate) + 1;
       adjusted_decoded_audio->AdjustForDiscardedDurations(
           kSampleRate, quarter_duration, quarter_duration);
       ASSERT_NEAR(adjusted_decoded_audio->frames(),
                   original_decoded_audio->frames() / 2, 2);
       ASSERT_NEAR(adjusted_decoded_audio->timestamp(),
                   original_decoded_audio->timestamp() + quarter_duration,
                   duration_of_one_frame * 2);

       adjusted_decoded_audio = original_decoded_audio->Clone();
       // Adjust more frames than it has from front
       adjusted_decoded_audio->AdjustForDiscardedDurations(
           kSampleRate, duration_of_decoded_audio * 2, 0);
       ASSERT_EQ(adjusted_decoded_audio->frames(), 0);
       ASSERT_NEAR(
           adjusted_decoded_audio->timestamp(),
           original_decoded_audio->timestamp() + duration_of_decoded_audio,
           duration_of_one_frame * 2);

       adjusted_decoded_audio = original_decoded_audio->Clone();
       // Adjust more frames than it has from back
       adjusted_decoded_audio->AdjustForDiscardedDurations(
           kSampleRate, 0, duration_of_decoded_audio * 2);
       ASSERT_EQ(adjusted_decoded_audio->frames(), 0);
       ASSERT_EQ(adjusted_decoded_audio->timestamp(),
                 original_decoded_audio->timestamp());
     }
   }
 }

 TEST(DecodedAudioTest, SwitchFormatTo) {
   for (auto original_sample_type : kSampleTypes) {
     for (auto original_storage_type : kStorageTypes) {
       scoped_refptr<DecodedAudio> original_decoded_audio(
           new DecodedAudio(kChannels, original_sample_type,
                            original_storage_type, kTimestamp, kSizeInBytes));

       Fill(&original_decoded_audio);

       for (auto new_sample_type : kSampleTypes) {
         for (auto new_storage_type : kStorageTypes) {
           if (!original_decoded_audio->IsFormat(new_sample_type,
                                                 new_storage_type)) {
             scoped_refptr<DecodedAudio> new_decoded_audio =
                 original_decoded_audio->SwitchFormatTo(new_sample_type,
                                                        new_storage_type);

             EXPECT_FALSE(new_decoded_audio->is_end_of_stream());
             EXPECT_EQ(new_decoded_audio->channels(),
                       original_decoded_audio->channels());
             EXPECT_EQ(new_decoded_audio->timestamp(),
                       original_decoded_audio->timestamp());
             EXPECT_EQ(new_decoded_audio->frames(),
                       original_decoded_audio->frames());
             EXPECT_TRUE(
                 new_decoded_audio->IsFormat(new_sample_type, new_storage_type));

             ASSERT_NO_FATAL_FAILURE(Verify(new_decoded_audio));
           }
         }
       }
     }
   }
 }

 TEST(DecodedAudioTest, Clone) {
   for (auto sample_type : kSampleTypes) {
     scoped_refptr<DecodedAudio> decoded_audio(new DecodedAudio(
         kChannels, sample_type, kSbMediaAudioFrameStorageTypeInterleaved,
         kTimestamp, kSizeInBytes));
     Fill(&decoded_audio);
     auto copy = decoded_audio->Clone();
     ASSERT_EQ(*copy, *decoded_audio);
     ASSERT_GT(decoded_audio->size_in_bytes(), 0);
     decoded_audio->data()[0] = ~decoded_audio->data()[0];
     ASSERT_NE(*copy, *decoded_audio);
   }
 }

 }  // namespace
 }  // namespace player
 }  // namespace starboard
 }  // namespace shared
 }  // namespace starboard
	// Copyright 2023 The Cobalt Authors. All Rights Reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "starboard/shared/starboard/player/decoded_audio_internal.h"

	#include <cmath>
	#include <utility>

	#include "starboard/common/log.h"
	#include "starboard/shared/starboard/media/media_util.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace starboard {
	namespace shared {
	namespace starboard {
	namespace player {
	namespace {

	using ::starboard::shared::starboard::media::GetBytesPerSample;

	constexpr int kChannels = 2;
	constexpr SbTime kTimestamp = kSbTimeSecond;
	constexpr int kSizeInBytes = 4192;
	constexpr int kSampleRate = 22050;

	constexpr double kPi = 3.1415926535897932384626;

	constexpr SbMediaAudioSampleType kSampleTypes[] = {
	kSbMediaAudioSampleTypeInt16Deprecated, kSbMediaAudioSampleTypeFloat32};
	constexpr SbMediaAudioFrameStorageType kStorageTypes[] = {
	kSbMediaAudioFrameStorageTypeInterleaved,
	kSbMediaAudioFrameStorageTypePlanar};

	// The following two functions fill `data` with audio samples of a sine wave
	// starting from `initial_angle`. `stride` is the number of samples per group.
	// For example:
	// 1. When `stride` is one, all samples filled with be continuous.
	// 2. When `stride` is 2, filling `data` and `data + 1` fills an interleaved
	// stereo audio buffer with samples.
	void Fill(int16_t* data,
	double initial_angle,
	double angle_step,
	int count,
	int stride) {
	SB_DCHECK(data);

	auto current_angel = initial_angle;
	for (int i = 0; i < count; ++i) {
	data = static_cast<int16_t>(sin(current_angel) 32767);
	current_angel += angle_step;
	data += stride;
	}
	}

	void Fill(float* data,
	double initial_angle,
	double angle_step,
	int count,
	int stride) {
	SB_DCHECK(data);

	auto current_angel = initial_angle;
	for (int i = 0; i < count; ++i) {
	*data = static_cast<float>(sin(current_angel));
	current_angel += angle_step;
	data += stride;
	}
	}

	// The following two functions verify `data` with audio samples against a sine
	// wave starting from `initial_angle`. `stride` is the number of samples per
	// group. For example:
	// 1. When `stride` is one, all samples will be treated as continuous.
	// 2. When `stride` is 2, verifying against `data` and `data + 1` verifies an
	// interleaved stereo audio buffer.
	void Verify(const int16_t* data,
	double initial_angle,
	double angle_step,
	int count,
	int stride) {
	SB_DCHECK(data);

	auto current_angel = initial_angle;
	for (int i = 0; i < count; ++i) {
	const auto current_value = static_cast<int16_t>(sin(current_angel) * 32767);
	// Using `ASSERT_NEAR()` to allow for small value drifting due to
	// conversions between sample types.
	ASSERT_NEAR(static_cast<double>(*data), static_cast<double>(current_value),
	2.0 / 32767);
	current_angel += angle_step;
	data += stride;
	}
	}

	void Verify(const float* data,
	double initial_angle,
	double angle_step,
	int count,
	int stride) {
	SB_DCHECK(data);

	auto current_angel = initial_angle;
	for (int i = 0; i < count; ++i) {
	const auto current_value = static_cast<float>(sin(current_angel));
	// Using `ASSERT_NEAR()` to allow for small value drifting due to
	// conversions between sample types.
	ASSERT_NEAR(static_cast<double>(*data), static_cast<double>(current_value),
	2.0 / 32767);
	current_angel += angle_step;
	data += stride;
	}
	}

	// Fill `decoded_audio` with sine wave samples, with phase shift of Pi/2 on each
	// channel.
	void Fill(scoped_refptr<DecodedAudio>* decoded_audio) {
	SB_DCHECK(decoded_audio);
	SB_DCHECK(*decoded_audio);

	bool is_int16 =
	(*decoded_audio)->sample_type() == kSbMediaAudioSampleTypeInt16Deprecated;
	bool is_interleaved = (*decoded_audio)->storage_type() ==
	kSbMediaAudioFrameStorageTypeInterleaved;

	for (int i = 0; i < (*decoded_audio)->channels(); ++i) {
	if (is_int16 && is_interleaved) {
	Fill((decoded_audio)->data_as_int16() + i, kPi / 2 i, kPi / 180,
	(decoded_audio)->frames(), (decoded_audio)->channels());
	} else if (!is_int16 && is_interleaved) {
	Fill((decoded_audio)->data_as_float32() + i, kPi / 2 i, kPi / 180,
	(decoded_audio)->frames(), (decoded_audio)->channels());
	} else if (is_int16 && !is_interleaved) {
	Fill((decoded_audio)->data_as_int16() + (decoded_audio)->frames() * i,
	kPi / 2 * i, kPi / 180, (*decoded_audio)->frames(), 1);
	} else if (!is_int16 && !is_interleaved) {
	Fill((decoded_audio)->data_as_float32() + (decoded_audio)->frames() * i,
	kPi / 2 * i, kPi / 180, (*decoded_audio)->frames(), 1);
	}
	}
	}

	// verify `decoded_audio` against sine wave samples, with phase shift of Pi/2 on
	// each channel.
	void Verify(const scoped_refptr<DecodedAudio>& decoded_audio) {
	SB_DCHECK(decoded_audio);

	bool is_int16 =
	decoded_audio->sample_type() == kSbMediaAudioSampleTypeInt16Deprecated;
	bool is_interleaved =
	decoded_audio->storage_type() == kSbMediaAudioFrameStorageTypeInterleaved;

	for (int i = 0; i < decoded_audio->channels(); ++i) {
	if (is_int16 && is_interleaved) {
	ASSERT_NO_FATAL_FAILURE(
	Verify(decoded_audio->data_as_int16() + i, kPi / 2 * i, kPi / 180,
	decoded_audio->frames(), decoded_audio->channels()));
	} else if (!is_int16 && is_interleaved) {
	ASSERT_NO_FATAL_FAILURE(
	Verify(decoded_audio->data_as_float32() + i, kPi / 2 * i, kPi / 180,
	decoded_audio->frames(), decoded_audio->channels()));
	} else if (is_int16 && !is_interleaved) {
	ASSERT_NO_FATAL_FAILURE(
	Verify(decoded_audio->data_as_int16() + decoded_audio->frames() * i,
	kPi / 2 * i, kPi / 180, decoded_audio->frames(), 1));
	} else if (!is_int16 && !is_interleaved) {
	ASSERT_NO_FATAL_FAILURE(
	Verify(decoded_audio->data_as_float32() + decoded_audio->frames() * i,
	kPi / 2 * i, kPi / 180, decoded_audio->frames(), 1));
	}
	}
	}

	TEST(DecodedAudioTest, DefaultCtor) {
	scoped_refptr<DecodedAudio> decoded_audio(new DecodedAudio);
	EXPECT_TRUE(decoded_audio->is_end_of_stream());
	}

	TEST(DecodedAudioTest, CtorWithSize) {
	for (auto sample_type : kSampleTypes) {
	for (auto storage_type : kStorageTypes) {
	scoped_refptr<DecodedAudio> decoded_audio(new DecodedAudio(
	kChannels, sample_type, storage_type, kTimestamp, kSizeInBytes));

	EXPECT_FALSE(decoded_audio->is_end_of_stream());
	EXPECT_EQ(decoded_audio->channels(), kChannels);
	EXPECT_EQ(decoded_audio->sample_type(), sample_type);
	EXPECT_EQ(decoded_audio->storage_type(), storage_type);
	EXPECT_EQ(decoded_audio->size_in_bytes(), kSizeInBytes);
	EXPECT_EQ(decoded_audio->frames(),
	kSizeInBytes / GetBytesPerSample(decoded_audio->sample_type()) /
	kChannels);

	Fill(&decoded_audio);
	Verify(decoded_audio);
	}
	}
	}

	TEST(DecodedAudioTest, AdjustForSeekTime) {
	for (int channels = 1; channels <= 6; ++channels) {
	for (auto sample_type : kSampleTypes) {
	scoped_refptr<DecodedAudio> original_decoded_audio(new DecodedAudio(
	kChannels, sample_type, kSbMediaAudioFrameStorageTypeInterleaved,
	kTimestamp, kSizeInBytes));
	Fill(&original_decoded_audio);

	scoped_refptr<DecodedAudio> adjusted_decoded_audio =
	original_decoded_audio->Clone();

	// Adjust to the beginning of `adjusted_decoded_audio` should be a no-op.
	adjusted_decoded_audio->AdjustForSeekTime(
	kSampleRate, adjusted_decoded_audio->timestamp());
	ASSERT_EQ(original_decoded_audio, adjusted_decoded_audio);

	// Adjust to an invalid timestamp before the time range of
	// `adjusted_decoded_audio`, it's a no-op.
	adjusted_decoded_audio->AdjustForSeekTime(
	kSampleRate, adjusted_decoded_audio->timestamp() - kSbTimeSecond / 2);
	ASSERT_EQ(original_decoded_audio, adjusted_decoded_audio);

	// Adjust to an invalid timestamp after the time range of
	// `adjusted_decoded_audio`, it's also a no-op.
	adjusted_decoded_audio->AdjustForSeekTime(
	kSampleRate,
	adjusted_decoded_audio->timestamp() + kSbTimeSecond * 100);
	ASSERT_EQ(original_decoded_audio, adjusted_decoded_audio);

	const SbTime duration = media::AudioFramesToDuration(
	adjusted_decoded_audio->frames(), kSampleRate);
	const SbTime duration_of_one_frame =
	media::AudioFramesToDuration(1, kSampleRate) + 1;
	for (int i = 1; i < 10; ++i) {
	adjusted_decoded_audio = original_decoded_audio->Clone();
	// Adjust to the middle of `adjusted_decoded_audio`.
	SbTime seek_time =
	adjusted_decoded_audio->timestamp() + duration * i / 10;
	adjusted_decoded_audio->AdjustForSeekTime(kSampleRate, seek_time);
	ASSERT_NEAR(adjusted_decoded_audio->frames(),
	original_decoded_audio->frames() * (10 - i) / 10, 1);

	ASSERT_LE(adjusted_decoded_audio->timestamp(), seek_time);
	ASSERT_NEAR(adjusted_decoded_audio->timestamp(), seek_time,
	duration_of_one_frame);

	auto offset_in_bytes = original_decoded_audio->size_in_bytes() -
	adjusted_decoded_audio->size_in_bytes();
	ASSERT_TRUE(memcmp(adjusted_decoded_audio->data(),
	original_decoded_audio->data() + offset_in_bytes,
	adjusted_decoded_audio->size_in_bytes()) == 0);
	}
	}
	}
	}

	TEST(DecodedAudioTest, AdjustForDiscardedDurations) {
	for (int channels = 1; channels <= 6; ++channels) {
	for (auto sample_type : kSampleTypes) {
	scoped_refptr<DecodedAudio> original_decoded_audio(new DecodedAudio(
	kChannels, sample_type, kSbMediaAudioFrameStorageTypeInterleaved,
	kTimestamp, kSizeInBytes));
	Fill(&original_decoded_audio);

	scoped_refptr<DecodedAudio> adjusted_decoded_audio =
	original_decoded_audio->Clone();

	adjusted_decoded_audio->AdjustForDiscardedDurations(kSampleRate, 0, 0);
	ASSERT_EQ(original_decoded_audio, adjusted_decoded_audio);

	auto duration_of_decoded_audio = media::AudioFramesToDuration(
	original_decoded_audio->frames(), kSampleRate);
	auto quarter_duration = duration_of_decoded_audio / 4;
	auto duration_of_one_frame =
	media::AudioFramesToDuration(1, kSampleRate) + 1;
	adjusted_decoded_audio->AdjustForDiscardedDurations(
	kSampleRate, quarter_duration, quarter_duration);
	ASSERT_NEAR(adjusted_decoded_audio->frames(),
	original_decoded_audio->frames() / 2, 2);
	ASSERT_NEAR(adjusted_decoded_audio->timestamp(),
	original_decoded_audio->timestamp() + quarter_duration,
	duration_of_one_frame * 2);

	adjusted_decoded_audio = original_decoded_audio->Clone();
	// Adjust more frames than it has from front
	adjusted_decoded_audio->AdjustForDiscardedDurations(
	kSampleRate, duration_of_decoded_audio * 2, 0);
	ASSERT_EQ(adjusted_decoded_audio->frames(), 0);
	ASSERT_NEAR(
	adjusted_decoded_audio->timestamp(),
	original_decoded_audio->timestamp() + duration_of_decoded_audio,
	duration_of_one_frame * 2);

	adjusted_decoded_audio = original_decoded_audio->Clone();
	// Adjust more frames than it has from back
	adjusted_decoded_audio->AdjustForDiscardedDurations(
	kSampleRate, 0, duration_of_decoded_audio * 2);
	ASSERT_EQ(adjusted_decoded_audio->frames(), 0);
	ASSERT_EQ(adjusted_decoded_audio->timestamp(),
	original_decoded_audio->timestamp());
	}
	}
	}

	TEST(DecodedAudioTest, SwitchFormatTo) {
	for (auto original_sample_type : kSampleTypes) {
	for (auto original_storage_type : kStorageTypes) {
	scoped_refptr<DecodedAudio> original_decoded_audio(
	new DecodedAudio(kChannels, original_sample_type,
	original_storage_type, kTimestamp, kSizeInBytes));

	Fill(&original_decoded_audio);

	for (auto new_sample_type : kSampleTypes) {
	for (auto new_storage_type : kStorageTypes) {
	if (!original_decoded_audio->IsFormat(new_sample_type,
	new_storage_type)) {
	scoped_refptr<DecodedAudio> new_decoded_audio =
	original_decoded_audio->SwitchFormatTo(new_sample_type,
	new_storage_type);

	EXPECT_FALSE(new_decoded_audio->is_end_of_stream());
	EXPECT_EQ(new_decoded_audio->channels(),
	original_decoded_audio->channels());
	EXPECT_EQ(new_decoded_audio->timestamp(),
	original_decoded_audio->timestamp());
	EXPECT_EQ(new_decoded_audio->frames(),
	original_decoded_audio->frames());
	EXPECT_TRUE(
	new_decoded_audio->IsFormat(new_sample_type, new_storage_type));

	ASSERT_NO_FATAL_FAILURE(Verify(new_decoded_audio));
	}
	}
	}
	}
	}
	}

	TEST(DecodedAudioTest, Clone) {
	for (auto sample_type : kSampleTypes) {
	scoped_refptr<DecodedAudio> decoded_audio(new DecodedAudio(
	kChannels, sample_type, kSbMediaAudioFrameStorageTypeInterleaved,
	kTimestamp, kSizeInBytes));
	Fill(&decoded_audio);
	auto copy = decoded_audio->Clone();
	ASSERT_EQ(copy, decoded_audio);
	ASSERT_GT(decoded_audio->size_in_bytes(), 0);
	decoded_audio->data()[0] = ~decoded_audio->data()[0];
	ASSERT_NE(copy, decoded_audio);
	}
	}

	} // namespace
	} // namespace player
	} // namespace starboard
	} // namespace shared
	} // namespace starboard