// Copyright 2022 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. | |
#ifndef STARBOARD_SHARED_UWP_AUDIO_RENDERER_PASSTHROUGH_H_ | |
#define STARBOARD_SHARED_UWP_AUDIO_RENDERER_PASSTHROUGH_H_ | |
#include <functional> | |
#include <queue> | |
#include "starboard/atomic.h" | |
#include "starboard/common/mutex.h" | |
#include "starboard/common/ref_counted.h" | |
#include "starboard/media.h" | |
#include "starboard/shared/internal_only.h" | |
#include "starboard/shared/starboard/media/media_util.h" | |
#include "starboard/shared/starboard/player/decoded_audio_internal.h" | |
#include "starboard/shared/starboard/player/filter/audio_decoder_internal.h" | |
#include "starboard/shared/starboard/player/filter/audio_renderer_internal.h" | |
#include "starboard/shared/starboard/player/filter/media_time_provider.h" | |
#include "starboard/shared/starboard/player/input_buffer_internal.h" | |
#include "starboard/shared/starboard/player/job_queue.h" | |
#include "starboard/shared/uwp/wasapi_audio_sink.h" | |
#include "starboard/time.h" | |
#include "starboard/types.h" | |
namespace starboard { | |
namespace shared { | |
namespace uwp { | |
using ::starboard::shared::starboard::player::DecodedAudio; | |
using ::starboard::shared::starboard::player::JobQueue; | |
using ::starboard::shared::starboard::player::filter::AudioDecoder; | |
using ::starboard::shared::starboard::player::filter::AudioRenderer; | |
using ::starboard::shared::starboard::player::filter::MediaTimeProvider; | |
class AudioRendererPassthrough : public AudioRenderer, | |
public MediaTimeProvider, | |
private JobQueue::JobOwner { | |
public: | |
typedef starboard::media::AudioStreamInfo AudioStreamInfo; | |
AudioRendererPassthrough(scoped_ptr<AudioDecoder> audio_decoder, | |
const AudioStreamInfo& audio_stream_info); | |
~AudioRendererPassthrough() override; | |
void Initialize(const ErrorCB& error_cb, | |
const PrerolledCB& prerolled_cb, | |
const EndedCB& ended_cb) override; | |
void WriteSamples(const InputBuffers& input_buffers) override; | |
void WriteEndOfStream() override; | |
void SetVolume(double volume) override; | |
bool IsEndOfStreamWritten() const override; | |
bool IsEndOfStreamPlayed() const override; | |
bool CanAcceptMoreData() const override; | |
// MediaTimeProvider methods | |
void Play() override; | |
void Pause() override; | |
void SetPlaybackRate(double playback_rate) override; | |
void Seek(SbTime seek_to_time) override; | |
SbTime GetCurrentMediaTime(bool* is_playing, | |
bool* is_eos_played, | |
bool* is_underflow, | |
double* playback_rate) override; | |
private: | |
void OnDecoderConsumed(); | |
void OnDecoderOutput(); | |
void ProcessAudioBuffers(); | |
bool TryToWriteAudioBufferToSink(scoped_refptr<DecodedAudio> decoded_audio); | |
// After end of stream is written, stop the audio sink after it finishes audio | |
// output. | |
void TryToEndStream(); | |
// Calculates the playback time elapsed since the last time the timestamp was | |
// queried using WASAPIAudioSink::GetCurrentPlaybackTime(). | |
SbTime CalculateElapsedPlaybackTime(uint64_t update_time); | |
// Calculates the final output timestamp of a DecodedAudio. | |
SbTime CalculateLastOutputTime(scoped_refptr<DecodedAudio>& decoded_audio); | |
const int kMaxDecodedAudios = 16; | |
// About 250 ms of (E)AC3 audio. | |
const int kNumPrerollDecodedAudios = 8; | |
ErrorCB error_cb_; | |
PrerolledCB prerolled_cb_; | |
EndedCB ended_cb_; | |
Mutex mutex_; | |
bool paused_ = true; | |
bool seeking_ = false; | |
double playback_rate_ = 1.0; | |
SbTime seeking_to_time_ = 0; | |
atomic_bool end_of_stream_written_{false}; | |
atomic_bool end_of_stream_played_{false}; | |
// Use DecodedAudio to store decrypted and formatted encoded audio data. | |
std::queue<scoped_refptr<DecodedAudio>> pending_inputs_; | |
atomic_bool can_accept_more_data_; | |
JobQueue::JobToken process_audio_buffers_job_token_; | |
std::function<void()> process_audio_buffers_job_; | |
int64_t total_frames_sent_to_sink_ = 0; | |
int total_buffers_sent_to_sink_ = 0; | |
const int channels_; | |
const SbMediaAudioCodec codec_ = kSbMediaAudioCodecNone; | |
scoped_ptr<AudioDecoder> decoder_; | |
scoped_ptr<WASAPIAudioSink> sink_; | |
// |iec_sample_rate_| is the sample rate of the stream when stored in an IEC | |
// 61937 format. This may be different from the decoded sample rate. | |
const int iec_sample_rate_; | |
// Used to calculate the media time in GetCurrentMediaTime(). | |
LARGE_INTEGER performance_frequency_; | |
}; | |
} // namespace uwp | |
} // namespace shared | |
} // namespace starboard | |
#endif // STARBOARD_SHARED_UWP_AUDIO_RENDERER_PASSTHROUGH_H_ |