blob: 72b069b939eb14e966dcaf488014e63fa8eea458 [file] [log] [blame]
// 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.
#ifndef STARBOARD_NPLB_PLAYER_TEST_FIXTURE_H_
#define STARBOARD_NPLB_PLAYER_TEST_FIXTURE_H_
#include <atomic>
#include <deque>
#include <set>
#include <string>
#include <vector>
#include "starboard/common/queue.h"
#include "starboard/common/scoped_ptr.h"
#include "starboard/drm.h"
#include "starboard/nplb/player_test_util.h"
#include "starboard/player.h"
#include "starboard/shared/starboard/player/video_dmp_reader.h"
#include "starboard/shared/starboard/thread_checker.h"
#include "starboard/testing/fake_graphics_context_provider.h"
namespace starboard {
namespace nplb {
class SbPlayerTestFixture {
public:
// A simple encapsulation of grouped samples.
class GroupedSamplesIterator;
class GroupedSamples {
public:
struct AudioSamplesDescriptor {
int start_index = 0;
int samples_count = 0;
SbTime timestamp_offset = 0;
SbTime discarded_duration_from_front = 0;
SbTime discarded_duration_from_back = 0;
bool is_end_of_stream = false;
};
struct VideoSamplesDescriptor {
int start_index = 0;
int samples_count = 0;
bool is_end_of_stream = false;
};
GroupedSamples& AddAudioSamples(int start_index, int number_of_samples);
GroupedSamples& AddAudioSamples(int start_index,
int number_of_samples,
SbTime timestamp_offset,
SbTime discarded_duration_from_front,
SbTime discarded_duration_from_back);
GroupedSamples& AddAudioEOS();
GroupedSamples& AddVideoSamples(int start_index, int number_of_samples);
GroupedSamples& AddVideoEOS();
friend class GroupedSamplesIterator;
private:
std::vector<AudioSamplesDescriptor> audio_samples_;
std::vector<VideoSamplesDescriptor> video_samples_;
};
SbPlayerTestFixture(
const SbPlayerTestConfig& config,
testing::FakeGraphicsContextProvider* fake_graphics_context_provider);
~SbPlayerTestFixture();
void Seek(const SbTime time);
// Write audio and video samples. It waits for
// |kSbPlayerDecoderStateNeedsData| internally. When writing EOS are
// requested, the function will write EOS after all samples of the same type
// are written.
void Write(const GroupedSamples& grouped_samples);
// Wait until kSbPlayerStatePresenting received.
void WaitForPlayerPresenting();
// Wait until kSbPlayerStateEndOfStream received.
void WaitForPlayerEndOfStream();
SbTime GetCurrentMediaTime() const;
void SetAudioWriteDuration(SbTime duration);
SbPlayer GetPlayer() const { return player_; }
bool HasAudio() const { return audio_dmp_reader_; }
bool HasVideo() const { return video_dmp_reader_; }
SbTime GetAudioSampleTimestamp(int index) const;
int ConvertDurationToAudioBufferCount(SbTime duration) const;
int ConvertDurationToVideoBufferCount(SbTime duration) const;
private:
static constexpr SbTime kDefaultWaitForPlayerStateTimeout = 5 * kSbTimeSecond;
static constexpr SbTime kDefaultWaitForCallbackEventTimeout =
15 * kSbTimeMillisecond;
typedef shared::starboard::player::video_dmp::VideoDmpReader VideoDmpReader;
typedef enum CallbackEventType {
kEmptyEvent,
kDecoderStateEvent,
kPlayerStateEvent,
} CallbackEventType;
struct CallbackEvent {
CallbackEvent();
CallbackEvent(SbPlayer player,
SbMediaType type,
SbPlayerDecoderState state,
int ticket);
CallbackEvent(SbPlayer player, SbPlayerState state, int ticket);
CallbackEventType event_type;
SbPlayer player = kSbPlayerInvalid;
SbMediaType media_type;
SbPlayerDecoderState decoder_state;
SbPlayerState player_state;
int ticket = SB_PLAYER_INITIAL_TICKET;
};
static void DecoderStatusCallback(SbPlayer player,
void* context,
SbMediaType type,
SbPlayerDecoderState state,
int ticket);
static void PlayerStatusCallback(SbPlayer player,
void* context,
SbPlayerState state,
int ticket);
static void ErrorCallback(SbPlayer player,
void* context,
SbPlayerError error,
const char* message);
// Callback methods from the underlying player. Note that callbacks may be
// invoked on underlying player's thread.
void OnDecoderState(SbPlayer player,
SbMediaType media_type,
SbPlayerDecoderState state,
int ticket);
void OnPlayerState(SbPlayer player, SbPlayerState state, int ticket);
void OnError(SbPlayer player, SbPlayerError error, const char* message);
void Initialize();
void TearDown();
bool CanWriteMoreAudioData();
bool CanWriteMoreVideoData();
void WriteAudioSamples(int start_index,
int samples_to_write,
SbTime timestamp_offset,
SbTime discarded_duration_from_front,
SbTime discarded_duration_from_back);
void WriteVideoSamples(int start_index, int samples_to_write);
void WriteEndOfStream(SbMediaType media_type);
// Checks if there are pending callback events and, if so, logs the received
// state update in the appropriate tracking container:
// * |can_accept_more_*_data_| for SbPlayerDecoderState updates.
// * |player_state_set_| for SbPlayerState updates.
// Executes a blocking wait for any new CallbackEvents to be enqueued.
void WaitAndProcessNextEvent(
SbTime timeout = kDefaultWaitForCallbackEventTimeout);
// Waits for |kSbPlayerDecoderStateNeedsData| to be sent.
void WaitForDecoderStateNeedsData(
const SbTime timeout = kDefaultWaitForCallbackEventTimeout);
// Waits for desired player state update to be sent.
void WaitForPlayerState(
const SbPlayerState desired_state,
const SbTime timeout = kDefaultWaitForPlayerStateTimeout);
// When the |output_mode| is decoding to texture, then this method is used to
// advance the decoded frames.
void GetDecodeTargetWhenSupported();
// Determine if the the current event is valid based on previously received
// player state updates, or other inputs to the player.
void AssertPlayerStateIsValid(SbPlayerState state) const;
bool HasReceivedPlayerState(SbPlayerState state) const {
return player_state_set_.find(state) != player_state_set_.end();
}
shared::starboard::ThreadChecker thread_checker_;
const SbPlayerOutputMode output_mode_;
std::string key_system_;
std::string max_video_capabilities_;
scoped_ptr<VideoDmpReader> audio_dmp_reader_;
scoped_ptr<VideoDmpReader> video_dmp_reader_;
testing::FakeGraphicsContextProvider* fake_graphics_context_provider_;
SbPlayer player_ = kSbPlayerInvalid;
SbDrmSystem drm_system_ = kSbDrmSystemInvalid;
// Queue of events from the underlying player.
Queue<CallbackEvent> callback_event_queue_;
// States of if decoder can accept more inputs.
bool can_accept_more_audio_data_ = false;
bool can_accept_more_video_data_ = false;
// The duration of how far past the current playback position we will write
// audio samples.
SbTime audio_write_duration_ = 0;
SbTime last_written_audio_timestamp_ = 0;
// Set of received player state updates from the underlying player. This is
// used to check that the state updates occur in a valid order during normal
// playback.
std::set<SbPlayerState> player_state_set_;
bool destroy_player_called_ = false;
bool audio_end_of_stream_written_ = false;
bool video_end_of_stream_written_ = false;
std::atomic_bool error_occurred_{false};
int ticket_ = SB_PLAYER_INITIAL_TICKET;
};
} // namespace nplb
} // namespace starboard
#endif // STARBOARD_NPLB_PLAYER_TEST_FIXTURE_H_