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

 // Copyright 2017 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 <algorithm>
 #include <cstring>
 #include <utility>

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

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

 namespace {

 using ::starboard::shared::starboard::media::AudioDurationToFrames;
 using ::starboard::shared::starboard::media::AudioFramesToDuration;
 using ::starboard::shared::starboard::media::GetBytesPerSample;

 void ConvertSample(const int16_t* source, float* destination) {
   *destination = static_cast<float>(*source) / 32768.f;
 }

 void ConvertSample(const float* source, int16_t* destination) {
   float sample = std::max(*source, -1.f);
   sample = std::min(sample, 1.f);
   *destination = static_cast<int16_t>(sample * 32767.f);
 }

 }  // namespace

 DecodedAudio::DecodedAudio()
     : channels_(0),
       sample_type_(kSbMediaAudioSampleTypeInt16Deprecated),
       storage_type_(kSbMediaAudioFrameStorageTypeInterleaved),
       timestamp_(0),
       offset_in_bytes_(0),
       size_in_bytes_(0) {}

 DecodedAudio::DecodedAudio(int channels,
                            SbMediaAudioSampleType sample_type,
                            SbMediaAudioFrameStorageType storage_type,
                            SbTime timestamp,
                            int size_in_bytes)
     : channels_(channels),
       sample_type_(sample_type),
       storage_type_(storage_type),
       timestamp_(timestamp),
       storage_(size_in_bytes),
       offset_in_bytes_(0),
       size_in_bytes_(size_in_bytes) {
   SB_DCHECK(channels_ > 0);
   SB_DCHECK(size_in_bytes_ >= 0);
   // TODO(b/275199195): Enable the SB_DCHECK below.
   // SB_DCHECK(size_in_bytes_ % (GetBytesPerSample(sample_type_) * channels_) ==
   //           0);
 }

 int DecodedAudio::frames() const {
   int bytes_per_sample = GetBytesPerSample(sample_type_);
   SB_DCHECK(size_in_bytes_ % (bytes_per_sample * channels_) == 0);
   return static_cast<int>(size_in_bytes_ / bytes_per_sample / channels_);
 }

 bool DecodedAudio::IsFormat(SbMediaAudioSampleType sample_type,
                             SbMediaAudioFrameStorageType storage_type) const {
   return sample_type_ == sample_type && storage_type_ == storage_type;
 }

 void DecodedAudio::ShrinkTo(int new_size_in_bytes) {
   SB_DCHECK(new_size_in_bytes <= size_in_bytes_);
   size_in_bytes_ = new_size_in_bytes;
 }

 void DecodedAudio::AdjustForSeekTime(int sample_rate, SbTime seeking_to_time) {
   SB_DCHECK(!is_end_of_stream());
   SB_DCHECK(sample_rate != 0);

   int frames_to_skip =
       media::AudioDurationToFrames(seeking_to_time - timestamp(), sample_rate);

   if (sample_rate == 0 || frames_to_skip < 0 || frames_to_skip >= frames()) {
     SB_LOG(WARNING) << "AdjustForSeekTime failed for seeking_to_time: "
                     << seeking_to_time << ", sample_rate: " << sample_rate
                     << ", timestamp: " << timestamp() << ", and there are "
                     << frames() << " frames in the DecodedAudio object.";
     return;
   }

   const auto bytes_per_sample = GetBytesPerSample(sample_type_);
   const auto bytes_per_frame = bytes_per_sample * channels();

   if (storage_type_ == kSbMediaAudioFrameStorageTypeInterleaved) {
     offset_in_bytes_ += frames_to_skip * bytes_per_frame;
     size_in_bytes_ -= frames_to_skip * bytes_per_frame;
     timestamp_ += media::AudioFramesToDuration(frames_to_skip, sample_rate);
     return;
   }

   SB_DCHECK(storage_type_ == kSbMediaAudioFrameStorageTypePlanar);

   Buffer new_storage(size_in_bytes_ - frames_to_skip * bytes_per_frame);
   const auto new_frames = frames() - frames_to_skip;

   const uint8_t* source_addr = data();
   uint8_t* dest_addr = new_storage.data();
   for (int channel = 0; channel < channels(); ++channel) {
     memcpy(dest_addr, source_addr + bytes_per_sample * frames_to_skip,
            new_frames * bytes_per_frame);
     source_addr += frames() * bytes_per_sample;
     dest_addr += new_frames * bytes_per_sample;
   }

   storage_ = std::move(new_storage);
   timestamp_ += media::AudioFramesToDuration(frames_to_skip, sample_rate);
   offset_in_bytes_ = 0;
   size_in_bytes_ = new_frames * bytes_per_frame;
 }

 void DecodedAudio::AdjustForDiscardedDurations(
     int sample_rate,
     SbTime discarded_duration_from_front,
     SbTime discarded_duration_from_back) {
   SB_DCHECK(discarded_duration_from_front >= 0);
   SB_DCHECK(discarded_duration_from_back >= 0);
   SB_DCHECK(storage_type() == kSbMediaAudioFrameStorageTypeInterleaved);

   const auto bytes_per_frame = GetBytesPerSample(sample_type()) * channels_;
   auto discarded_frames_from_front =
       AudioDurationToFrames(discarded_duration_from_front, sample_rate);

   discarded_frames_from_front = std::min(discarded_frames_from_front, frames());
   offset_in_bytes_ += bytes_per_frame * discarded_frames_from_front;
   size_in_bytes_ -= bytes_per_frame * discarded_frames_from_front;
   timestamp_ +=
       media::AudioFramesToDuration(discarded_frames_from_front, sample_rate);

   auto discarded_frames_from_back =
       AudioDurationToFrames(discarded_duration_from_back, sample_rate);
   discarded_frames_from_back = std::min(discarded_frames_from_back, frames());
   size_in_bytes_ -= bytes_per_frame * discarded_frames_from_back;
 }

 scoped_refptr<DecodedAudio> DecodedAudio::SwitchFormatTo(
     SbMediaAudioSampleType new_sample_type,
     SbMediaAudioFrameStorageType new_storage_type) const {
   // The caller should call IsFormat() to check before calling SwitchFormatTo(),
   // as SwitchFormatTo() always copies the whole buffer and is not optimal.
   SB_DCHECK(new_sample_type != sample_type_ ||
             new_storage_type != storage_type_);

   if (new_storage_type == storage_type_) {
     return SwitchSampleTypeTo(new_sample_type);
   }

   if (new_sample_type == sample_type_) {
     return SwitchStorageTypeTo(new_storage_type);
   }

   // Both sample types and storage types are different, use the slowest way.
   int new_size =
       media::GetBytesPerSample(new_sample_type) * frames() * channels();
   scoped_refptr<DecodedAudio> new_decoded_audio = new DecodedAudio(
       channels(), new_sample_type, new_storage_type, timestamp(), new_size);

 #define InterleavedSampleAddr(start_addr, channel, frame) \
   (start_addr + (frame * channels() + channel))
 #define PlanarSampleAddr(start_addr, channel, frame) \
   (start_addr + (channel * frames() + frame))
 #define GetSampleAddr(StorageType, start_addr, channel, frame) \
   (StorageType##SampleAddr(start_addr, channel, frame))
 #define SwitchTo(OldSampleType, OldStorageType, NewSampleType, NewStorageType) \
   do {                                                                         \
     const OldSampleType* old_samples =                                         \
         reinterpret_cast<const OldSampleType*>(this->data());                  \
     NewSampleType* new_samples =                                               \
         reinterpret_cast<NewSampleType*>(new_decoded_audio->data());           \
                                                                                \
     for (int channel = 0; channel < channels(); ++channel) {                   \
       for (int frame = 0; frame < frames(); ++frame) {                         \
         const OldSampleType* old_sample =                                      \
             GetSampleAddr(OldStorageType, old_samples, channel, frame);        \
         NewSampleType* new_sample =                                            \
             GetSampleAddr(NewStorageType, new_samples, channel, frame);        \
         ConvertSample(old_sample, new_sample);                                 \
       }                                                                        \
     }                                                                          \
   } while (false)

   if (sample_type_ == kSbMediaAudioSampleTypeInt16Deprecated &&
       storage_type_ == kSbMediaAudioFrameStorageTypeInterleaved &&
       new_sample_type == kSbMediaAudioSampleTypeFloat32 &&
       new_storage_type == kSbMediaAudioFrameStorageTypePlanar) {
     SwitchTo(int16_t, Interleaved, float, Planar);
   } else if (sample_type_ == kSbMediaAudioSampleTypeInt16Deprecated &&
              storage_type_ == kSbMediaAudioFrameStorageTypePlanar &&
              new_sample_type == kSbMediaAudioSampleTypeFloat32 &&
              new_storage_type == kSbMediaAudioFrameStorageTypeInterleaved) {
     SwitchTo(int16_t, Planar, float, Interleaved);
   } else if (sample_type_ == kSbMediaAudioSampleTypeFloat32 &&
              storage_type_ == kSbMediaAudioFrameStorageTypeInterleaved &&
              new_sample_type == kSbMediaAudioSampleTypeInt16Deprecated &&
              new_storage_type == kSbMediaAudioFrameStorageTypePlanar) {
     SwitchTo(float, Interleaved, int16_t, Planar);
   } else if (sample_type_ == kSbMediaAudioSampleTypeFloat32 &&
              storage_type_ == kSbMediaAudioFrameStorageTypePlanar &&
              new_sample_type == kSbMediaAudioSampleTypeInt16Deprecated &&
              new_storage_type == kSbMediaAudioFrameStorageTypeInterleaved) {
     SwitchTo(float, Planar, int16_t, Interleaved);
   } else {
     SB_NOTREACHED();
   }

   return new_decoded_audio;
 }

 scoped_refptr<DecodedAudio> DecodedAudio::Clone() const {
   scoped_refptr<DecodedAudio> copy = new DecodedAudio(
       channels(), sample_type(), storage_type(), timestamp(), size_in_bytes());

   memcpy(copy->data(), data(), size_in_bytes());

   return copy;
 }

 scoped_refptr<DecodedAudio> DecodedAudio::SwitchSampleTypeTo(
     SbMediaAudioSampleType new_sample_type) const {
   int new_size =
       media::GetBytesPerSample(new_sample_type) * frames() * channels();
   scoped_refptr<DecodedAudio> new_decoded_audio = new DecodedAudio(
       channels(), new_sample_type, storage_type(), timestamp(), new_size);

   if (sample_type_ == kSbMediaAudioSampleTypeInt16Deprecated &&
       new_sample_type == kSbMediaAudioSampleTypeFloat32) {
     const int16_t* old_samples = reinterpret_cast<const int16_t*>(this->data());
     float* new_samples = reinterpret_cast<float*>(new_decoded_audio->data());

     for (int i = 0; i < frames() * channels(); ++i) {
       ConvertSample(old_samples + i, new_samples + i);
     }
   } else if (sample_type_ == kSbMediaAudioSampleTypeFloat32 &&
              new_sample_type == kSbMediaAudioSampleTypeInt16Deprecated) {
     const float* old_samples = reinterpret_cast<const float*>(this->data());
     int16_t* new_samples =
         reinterpret_cast<int16_t*>(new_decoded_audio->data());

     for (int i = 0; i < frames() * channels(); ++i) {
       ConvertSample(old_samples + i, new_samples + i);
     }
   }

   return new_decoded_audio;
 }

 scoped_refptr<DecodedAudio> DecodedAudio::SwitchStorageTypeTo(
     SbMediaAudioFrameStorageType new_storage_type) const {
   scoped_refptr<DecodedAudio> new_decoded_audio =
       new DecodedAudio(channels(), sample_type(), new_storage_type, timestamp(),
                        size_in_bytes());
   int bytes_per_sample = media::GetBytesPerSample(sample_type());
   const uint8_t* old_samples = this->data();
   uint8_t* new_samples = new_decoded_audio->data();

   if (storage_type_ == kSbMediaAudioFrameStorageTypeInterleaved &&
       new_storage_type == kSbMediaAudioFrameStorageTypePlanar) {
     for (int channel = 0; channel < channels(); ++channel) {
       for (int frame = 0; frame < frames(); ++frame) {
         const uint8_t* old_sample =
             old_samples + (frame * channels() + channel) * bytes_per_sample;
         uint8_t* new_sample =
             new_samples + (channel * frames() + frame) * bytes_per_sample;
         memcpy(new_sample, old_sample, bytes_per_sample);
       }
     }
   } else if (storage_type_ == kSbMediaAudioFrameStorageTypePlanar &&
              new_storage_type == kSbMediaAudioFrameStorageTypeInterleaved) {
     for (int channel = 0; channel < channels(); ++channel) {
       for (int frame = 0; frame < frames(); ++frame) {
         const uint8_t* old_sample =
             old_samples + (channel * frames() + frame) * bytes_per_sample;
         uint8_t* new_sample =
             new_samples + (frame * channels() + channel) * bytes_per_sample;
         memcpy(new_sample, old_sample, bytes_per_sample);
       }
     }
   }

   return new_decoded_audio;
 }

 bool operator==(const DecodedAudio& left, const DecodedAudio& right) {
   if (left.is_end_of_stream() && right.is_end_of_stream()) {
     return true;
   }
   if (left.is_end_of_stream() || right.is_end_of_stream()) {
     return false;
   }

   return left.timestamp() == right.timestamp() &&
          left.channels() == right.channels() &&
          left.sample_type() == right.sample_type() &&
          left.storage_type() == right.storage_type() &&
          left.size_in_bytes() == right.size_in_bytes() &&
          memcmp(left.data(), right.data(), right.size_in_bytes()) == 0;
 }

 bool operator!=(const DecodedAudio& left, const DecodedAudio& right) {
   return !(left == right);
 }

 std::ostream& operator<<(std::ostream& os, const DecodedAudio& decoded_audio) {
   if (decoded_audio.is_end_of_stream()) {
     return os << "(eos)";
   }
   return os << "timestamp: " << decoded_audio.timestamp()
             << ", channels: " << decoded_audio.channels() << ", sample type: "
             << GetMediaAudioSampleTypeName(decoded_audio.sample_type())
             << ", storage type: "
             << GetMediaAudioStorageTypeName(decoded_audio.storage_type())
             << ", frames: " << decoded_audio.frames();
 }

 }  // namespace player
 }  // namespace starboard
 }  // namespace shared
 }  // namespace starboard
	// Copyright 2017 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 <algorithm>
	#include <cstring>
	#include <utility>

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

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

	namespace {

	using ::starboard::shared::starboard::media::AudioDurationToFrames;
	using ::starboard::shared::starboard::media::AudioFramesToDuration;
	using ::starboard::shared::starboard::media::GetBytesPerSample;

	void ConvertSample(const int16_t* source, float* destination) {
	destination = static_cast<float>(source) / 32768.f;
	}

	void ConvertSample(const float* source, int16_t* destination) {
	float sample = std::max(*source, -1.f);
	sample = std::min(sample, 1.f);
	destination = static_cast<int16_t>(sample 32767.f);
	}

	} // namespace

	DecodedAudio::DecodedAudio()
	: channels_(0),
	sample_type_(kSbMediaAudioSampleTypeInt16Deprecated),
	storage_type_(kSbMediaAudioFrameStorageTypeInterleaved),
	timestamp_(0),
	offset_in_bytes_(0),
	size_in_bytes_(0) {}

	DecodedAudio::DecodedAudio(int channels,
	SbMediaAudioSampleType sample_type,
	SbMediaAudioFrameStorageType storage_type,
	SbTime timestamp,
	int size_in_bytes)
	: channels_(channels),
	sample_type_(sample_type),
	storage_type_(storage_type),
	timestamp_(timestamp),
	storage_(size_in_bytes),
	offset_in_bytes_(0),
	size_in_bytes_(size_in_bytes) {
	SB_DCHECK(channels_ > 0);
	SB_DCHECK(size_in_bytes_ >= 0);
	// TODO(b/275199195): Enable the SB_DCHECK below.
	// SB_DCHECK(size_in_bytes_ % (GetBytesPerSample(sample_type_) * channels_) ==
	// 0);
	}

	int DecodedAudio::frames() const {
	int bytes_per_sample = GetBytesPerSample(sample_type_);
	SB_DCHECK(size_in_bytes_ % (bytes_per_sample * channels_) == 0);
	return static_cast<int>(size_in_bytes_ / bytes_per_sample / channels_);
	}

	bool DecodedAudio::IsFormat(SbMediaAudioSampleType sample_type,
	SbMediaAudioFrameStorageType storage_type) const {
	return sample_type_ == sample_type && storage_type_ == storage_type;
	}

	void DecodedAudio::ShrinkTo(int new_size_in_bytes) {
	SB_DCHECK(new_size_in_bytes <= size_in_bytes_);
	size_in_bytes_ = new_size_in_bytes;
	}

	void DecodedAudio::AdjustForSeekTime(int sample_rate, SbTime seeking_to_time) {
	SB_DCHECK(!is_end_of_stream());
	SB_DCHECK(sample_rate != 0);

	int frames_to_skip =
	media::AudioDurationToFrames(seeking_to_time - timestamp(), sample_rate);

	if (sample_rate == 0 \|\| frames_to_skip < 0 \|\| frames_to_skip >= frames()) {
	SB_LOG(WARNING) << "AdjustForSeekTime failed for seeking_to_time: "
	<< seeking_to_time << ", sample_rate: " << sample_rate
	<< ", timestamp: " << timestamp() << ", and there are "
	<< frames() << " frames in the DecodedAudio object.";
	return;
	}

	const auto bytes_per_sample = GetBytesPerSample(sample_type_);
	const auto bytes_per_frame = bytes_per_sample * channels();

	if (storage_type_ == kSbMediaAudioFrameStorageTypeInterleaved) {
	offset_in_bytes_ += frames_to_skip * bytes_per_frame;
	size_in_bytes_ -= frames_to_skip * bytes_per_frame;
	timestamp_ += media::AudioFramesToDuration(frames_to_skip, sample_rate);
	return;
	}

	SB_DCHECK(storage_type_ == kSbMediaAudioFrameStorageTypePlanar);

	Buffer new_storage(size_in_bytes_ - frames_to_skip * bytes_per_frame);
	const auto new_frames = frames() - frames_to_skip;

	const uint8_t* source_addr = data();
	uint8_t* dest_addr = new_storage.data();
	for (int channel = 0; channel < channels(); ++channel) {
	memcpy(dest_addr, source_addr + bytes_per_sample * frames_to_skip,
	new_frames * bytes_per_frame);
	source_addr += frames() * bytes_per_sample;
	dest_addr += new_frames * bytes_per_sample;
	}

	storage_ = std::move(new_storage);
	timestamp_ += media::AudioFramesToDuration(frames_to_skip, sample_rate);
	offset_in_bytes_ = 0;
	size_in_bytes_ = new_frames * bytes_per_frame;
	}

	void DecodedAudio::AdjustForDiscardedDurations(
	int sample_rate,
	SbTime discarded_duration_from_front,
	SbTime discarded_duration_from_back) {
	SB_DCHECK(discarded_duration_from_front >= 0);
	SB_DCHECK(discarded_duration_from_back >= 0);
	SB_DCHECK(storage_type() == kSbMediaAudioFrameStorageTypeInterleaved);

	const auto bytes_per_frame = GetBytesPerSample(sample_type()) * channels_;
	auto discarded_frames_from_front =
	AudioDurationToFrames(discarded_duration_from_front, sample_rate);

	discarded_frames_from_front = std::min(discarded_frames_from_front, frames());
	offset_in_bytes_ += bytes_per_frame * discarded_frames_from_front;
	size_in_bytes_ -= bytes_per_frame * discarded_frames_from_front;
	timestamp_ +=
	media::AudioFramesToDuration(discarded_frames_from_front, sample_rate);

	auto discarded_frames_from_back =
	AudioDurationToFrames(discarded_duration_from_back, sample_rate);
	discarded_frames_from_back = std::min(discarded_frames_from_back, frames());
	size_in_bytes_ -= bytes_per_frame * discarded_frames_from_back;
	}

	scoped_refptr<DecodedAudio> DecodedAudio::SwitchFormatTo(
	SbMediaAudioSampleType new_sample_type,
	SbMediaAudioFrameStorageType new_storage_type) const {
	// The caller should call IsFormat() to check before calling SwitchFormatTo(),
	// as SwitchFormatTo() always copies the whole buffer and is not optimal.
	SB_DCHECK(new_sample_type != sample_type_ \|\|
	new_storage_type != storage_type_);

	if (new_storage_type == storage_type_) {
	return SwitchSampleTypeTo(new_sample_type);
	}

	if (new_sample_type == sample_type_) {
	return SwitchStorageTypeTo(new_storage_type);
	}

	// Both sample types and storage types are different, use the slowest way.
	int new_size =
	media::GetBytesPerSample(new_sample_type) * frames() * channels();
	scoped_refptr<DecodedAudio> new_decoded_audio = new DecodedAudio(
	channels(), new_sample_type, new_storage_type, timestamp(), new_size);

	#define InterleavedSampleAddr(start_addr, channel, frame) \
	(start_addr + (frame * channels() + channel))
	#define PlanarSampleAddr(start_addr, channel, frame) \
	(start_addr + (channel * frames() + frame))
	#define GetSampleAddr(StorageType, start_addr, channel, frame) \
	(StorageType##SampleAddr(start_addr, channel, frame))
	#define SwitchTo(OldSampleType, OldStorageType, NewSampleType, NewStorageType) \
	do { \
	const OldSampleType* old_samples = \
	reinterpret_cast<const OldSampleType*>(this->data()); \
	NewSampleType* new_samples = \
	reinterpret_cast<NewSampleType*>(new_decoded_audio->data()); \
	\
	for (int channel = 0; channel < channels(); ++channel) { \
	for (int frame = 0; frame < frames(); ++frame) { \
	const OldSampleType* old_sample = \
	GetSampleAddr(OldStorageType, old_samples, channel, frame); \
	NewSampleType* new_sample = \
	GetSampleAddr(NewStorageType, new_samples, channel, frame); \
	ConvertSample(old_sample, new_sample); \
	} \
	} \
	} while (false)

	if (sample_type_ == kSbMediaAudioSampleTypeInt16Deprecated &&
	storage_type_ == kSbMediaAudioFrameStorageTypeInterleaved &&
	new_sample_type == kSbMediaAudioSampleTypeFloat32 &&
	new_storage_type == kSbMediaAudioFrameStorageTypePlanar) {
	SwitchTo(int16_t, Interleaved, float, Planar);
	} else if (sample_type_ == kSbMediaAudioSampleTypeInt16Deprecated &&
	storage_type_ == kSbMediaAudioFrameStorageTypePlanar &&
	new_sample_type == kSbMediaAudioSampleTypeFloat32 &&
	new_storage_type == kSbMediaAudioFrameStorageTypeInterleaved) {
	SwitchTo(int16_t, Planar, float, Interleaved);
	} else if (sample_type_ == kSbMediaAudioSampleTypeFloat32 &&
	storage_type_ == kSbMediaAudioFrameStorageTypeInterleaved &&
	new_sample_type == kSbMediaAudioSampleTypeInt16Deprecated &&
	new_storage_type == kSbMediaAudioFrameStorageTypePlanar) {
	SwitchTo(float, Interleaved, int16_t, Planar);
	} else if (sample_type_ == kSbMediaAudioSampleTypeFloat32 &&
	storage_type_ == kSbMediaAudioFrameStorageTypePlanar &&
	new_sample_type == kSbMediaAudioSampleTypeInt16Deprecated &&
	new_storage_type == kSbMediaAudioFrameStorageTypeInterleaved) {
	SwitchTo(float, Planar, int16_t, Interleaved);
	} else {
	SB_NOTREACHED();
	}

	return new_decoded_audio;
	}

	scoped_refptr<DecodedAudio> DecodedAudio::Clone() const {
	scoped_refptr<DecodedAudio> copy = new DecodedAudio(
	channels(), sample_type(), storage_type(), timestamp(), size_in_bytes());

	memcpy(copy->data(), data(), size_in_bytes());

	return copy;
	}

	scoped_refptr<DecodedAudio> DecodedAudio::SwitchSampleTypeTo(
	SbMediaAudioSampleType new_sample_type) const {
	int new_size =
	media::GetBytesPerSample(new_sample_type) * frames() * channels();
	scoped_refptr<DecodedAudio> new_decoded_audio = new DecodedAudio(
	channels(), new_sample_type, storage_type(), timestamp(), new_size);

	if (sample_type_ == kSbMediaAudioSampleTypeInt16Deprecated &&
	new_sample_type == kSbMediaAudioSampleTypeFloat32) {
	const int16_t* old_samples = reinterpret_cast<const int16_t*>(this->data());
	float* new_samples = reinterpret_cast<float*>(new_decoded_audio->data());

	for (int i = 0; i < frames() * channels(); ++i) {
	ConvertSample(old_samples + i, new_samples + i);
	}
	} else if (sample_type_ == kSbMediaAudioSampleTypeFloat32 &&
	new_sample_type == kSbMediaAudioSampleTypeInt16Deprecated) {
	const float* old_samples = reinterpret_cast<const float*>(this->data());
	int16_t* new_samples =
	reinterpret_cast<int16_t*>(new_decoded_audio->data());

	for (int i = 0; i < frames() * channels(); ++i) {
	ConvertSample(old_samples + i, new_samples + i);
	}
	}

	return new_decoded_audio;
	}

	scoped_refptr<DecodedAudio> DecodedAudio::SwitchStorageTypeTo(
	SbMediaAudioFrameStorageType new_storage_type) const {
	scoped_refptr<DecodedAudio> new_decoded_audio =
	new DecodedAudio(channels(), sample_type(), new_storage_type, timestamp(),
	size_in_bytes());
	int bytes_per_sample = media::GetBytesPerSample(sample_type());
	const uint8_t* old_samples = this->data();
	uint8_t* new_samples = new_decoded_audio->data();

	if (storage_type_ == kSbMediaAudioFrameStorageTypeInterleaved &&
	new_storage_type == kSbMediaAudioFrameStorageTypePlanar) {
	for (int channel = 0; channel < channels(); ++channel) {
	for (int frame = 0; frame < frames(); ++frame) {
	const uint8_t* old_sample =
	old_samples + (frame * channels() + channel) * bytes_per_sample;
	uint8_t* new_sample =
	new_samples + (channel * frames() + frame) * bytes_per_sample;
	memcpy(new_sample, old_sample, bytes_per_sample);
	}
	}
	} else if (storage_type_ == kSbMediaAudioFrameStorageTypePlanar &&
	new_storage_type == kSbMediaAudioFrameStorageTypeInterleaved) {
	for (int channel = 0; channel < channels(); ++channel) {
	for (int frame = 0; frame < frames(); ++frame) {
	const uint8_t* old_sample =
	old_samples + (channel * frames() + frame) * bytes_per_sample;
	uint8_t* new_sample =
	new_samples + (frame * channels() + channel) * bytes_per_sample;
	memcpy(new_sample, old_sample, bytes_per_sample);
	}
	}
	}

	return new_decoded_audio;
	}

	bool operator==(const DecodedAudio& left, const DecodedAudio& right) {
	if (left.is_end_of_stream() && right.is_end_of_stream()) {
	return true;
	}
	if (left.is_end_of_stream() \|\| right.is_end_of_stream()) {
	return false;
	}

	return left.timestamp() == right.timestamp() &&
	left.channels() == right.channels() &&
	left.sample_type() == right.sample_type() &&
	left.storage_type() == right.storage_type() &&
	left.size_in_bytes() == right.size_in_bytes() &&
	memcmp(left.data(), right.data(), right.size_in_bytes()) == 0;
	}

	bool operator!=(const DecodedAudio& left, const DecodedAudio& right) {
	return !(left == right);
	}

	std::ostream& operator<<(std::ostream& os, const DecodedAudio& decoded_audio) {
	if (decoded_audio.is_end_of_stream()) {
	return os << "(eos)";
	}
	return os << "timestamp: " << decoded_audio.timestamp()
	<< ", channels: " << decoded_audio.channels() << ", sample type: "
	<< GetMediaAudioSampleTypeName(decoded_audio.sample_type())
	<< ", storage type: "
	<< GetMediaAudioStorageTypeName(decoded_audio.storage_type())
	<< ", frames: " << decoded_audio.frames();
	}

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