Skip to content

Commit

Permalink
Media scoped_ptr/scoped_array switch
Browse files Browse the repository at this point in the history 
Note this is a draft, depends on youtube#1163

b/291356560
  • Loading branch information
@kaidokert
kaidokert committed Aug 6, 2023
1 parent 65fe06f commit 9d51f35
Show file tree
Hide file tree
Showing 73 changed files with 386 additions and 363 deletions.
6 changes: 4 additions & 2 deletions starboard/android/shared/player_components_factory.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -12,6 +12,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.

#include <memory>

#include "starboard/android/shared/player_components_factory.h"

#include "starboard/android/shared/drm_system.h"
Expand All @@ -23,8 +25,8 @@ namespace player {
namespace filter {

// static
scoped_ptr<PlayerComponents::Factory> PlayerComponents::Factory::Create() {
return make_scoped_ptr<PlayerComponents::Factory>(
std::unique_ptr<PlayerComponents::Factory> PlayerComponents::Factory::Create() {
return std::unique_ptr<PlayerComponents::Factory>(
new android::shared::PlayerComponentsFactory);
}

Expand Down
80 changes: 42 additions & 38 deletions starboard/android/shared/player_components_factory.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -15,7 +15,9 @@
#ifndef STARBOARD_ANDROID_SHARED_PLAYER_COMPONENTS_FACTORY_H_
#define STARBOARD_ANDROID_SHARED_PLAYER_COMPONENTS_FACTORY_H_

#include <memory>
#include <string>
#include <utility>
#include <vector>

#include "starboard/android/shared/audio_decoder.h"
Expand All @@ -31,7 +33,6 @@
#include "starboard/common/log.h"
#include "starboard/common/media.h"
#include "starboard/common/ref_counted.h"
#include "starboard/common/scoped_ptr.h"
#include "starboard/media.h"
#include "starboard/shared/opus/opus_audio_decoder.h"
#include "starboard/shared/starboard/media/media_util.h"
Expand Down Expand Up @@ -149,10 +150,10 @@ class PlayerComponentsPassthrough
: public starboard::shared::starboard::player::filter::PlayerComponents {
public:
PlayerComponentsPassthrough(
scoped_ptr<AudioRendererPassthrough> audio_renderer,
scoped_ptr<VideoRenderer> video_renderer)
: audio_renderer_(audio_renderer.Pass()),
video_renderer_(video_renderer.Pass()) {}
std::unique_ptr<AudioRendererPassthrough> audio_renderer,
std::unique_ptr<VideoRenderer> video_renderer)
: audio_renderer_(std::move(audio_renderer)),
video_renderer_(std::move(video_renderer)) {}

private:
// PlayerComponents methods
Expand All @@ -162,8 +163,8 @@ class PlayerComponentsPassthrough
AudioRenderer* GetAudioRenderer() override { return audio_renderer_.get(); }
VideoRenderer* GetVideoRenderer() override { return video_renderer_.get(); }

scoped_ptr<AudioRendererPassthrough> audio_renderer_;
scoped_ptr<VideoRenderer> video_renderer_;
std::unique_ptr<AudioRendererPassthrough> audio_renderer_;
std::unique_ptr<VideoRenderer> video_renderer_;
};

// TODO: Invesigate if the implementation of member functions should be moved
Expand Down Expand Up @@ -198,7 +199,7 @@ class PlayerComponentsFactory : public starboard::shared::starboard::player::
return (value + alignment - 1) / alignment * alignment;
}

scoped_ptr<PlayerComponents> CreateComponents(
std::unique_ptr<PlayerComponents> CreateComponents(
const CreationParameters& creation_parameters,
std::string* error_message) override {
SB_DCHECK(error_message);
Expand All @@ -217,7 +218,7 @@ class PlayerComponentsFactory : public starboard::shared::starboard::player::
if (!audio_mime_type.is_valid() ||
!audio_mime_type.ValidateBoolParameter("enableaudiodevicecallback") ||
!audio_mime_type.ValidateBoolParameter("audiopassthrough")) {
return scoped_ptr<PlayerComponents>();
return std::unique_ptr<PlayerComponents>();
}

enable_audio_device_callback =
Expand All @@ -228,21 +229,22 @@ class PlayerComponentsFactory : public starboard::shared::starboard::player::
if (!audio_mime_type.GetParamBoolValue("audiopassthrough", true)) {
SB_LOG(INFO) << "Mime attribute \"audiopassthrough\" is set to: "
"false. Passthrough is disabled.";
return scoped_ptr<PlayerComponents>();
return std::unique_ptr<PlayerComponents>();
}
}

SB_LOG(INFO) << "Creating passthrough components.";
// TODO: Enable tunnel mode for passthrough
scoped_ptr<AudioRendererPassthrough> audio_renderer;
std::unique_ptr<AudioRendererPassthrough> audio_renderer;
audio_renderer.reset(new AudioRendererPassthrough(
creation_parameters.audio_stream_info(),
creation_parameters.drm_system(), enable_audio_device_callback));
if (!audio_renderer->is_valid()) {
return scoped_ptr<PlayerComponents>();
return std::unique_ptr<PlayerComponents>();
}

scoped_ptr<::starboard::shared::starboard::player::filter::VideoRenderer>
std::unique_ptr<
::starboard::shared::starboard::player::filter::VideoRenderer>
video_renderer;
if (creation_parameters.video_codec() != kSbMediaVideoCodecNone) {
constexpr int kTunnelModeAudioSessionId = -1;
Expand All @@ -255,15 +257,15 @@ class PlayerComponentsFactory : public starboard::shared::starboard::player::
if (!video_mime_type.is_valid() ||
!video_mime_type.ValidateBoolParameter(
"forceimprovedsupportcheck")) {
return scoped_ptr<PlayerComponents>();
return std::unique_ptr<PlayerComponents>();
}
force_improved_support_check = video_mime_type.GetParamBoolValue(
"forceimprovedsupportcheck", true);
SB_LOG_IF(INFO, !force_improved_support_check)
<< "Improved support check is disabled for queries under 4K.";
}

scoped_ptr<VideoDecoder> video_decoder =
std::unique_ptr<VideoDecoder> video_decoder =
CreateVideoDecoder(creation_parameters, kTunnelModeAudioSessionId,
kForceSecurePipelineUnderTunnelMode,
force_improved_support_check, error_message);
Expand All @@ -275,23 +277,23 @@ class PlayerComponentsFactory : public starboard::shared::starboard::player::
auto media_time_provider = audio_renderer.get();

video_renderer.reset(new VideoRendererImpl(
scoped_ptr<VideoDecoderBase>(video_decoder.Pass()),
media_time_provider, video_render_algorithm.Pass(),
std::unique_ptr<VideoDecoderBase>(std::move(video_decoder)),
media_time_provider, std::move(video_render_algorithm),
video_renderer_sink));
} else {
return scoped_ptr<PlayerComponents>();
return std::unique_ptr<PlayerComponents>();
}
}
return scoped_ptr<PlayerComponents>(new PlayerComponentsPassthrough(
audio_renderer.Pass(), video_renderer.Pass()));
return std::unique_ptr<PlayerComponents>(new PlayerComponentsPassthrough(
std::move(audio_renderer), std::move(video_renderer)));
}

bool CreateSubComponents(
const CreationParameters& creation_parameters,
scoped_ptr<AudioDecoderBase>* audio_decoder,
scoped_ptr<AudioRendererSink>* audio_renderer_sink,
scoped_ptr<VideoDecoderBase>* video_decoder,
scoped_ptr<VideoRenderAlgorithmBase>* video_render_algorithm,
std::unique_ptr<AudioDecoderBase>* audio_decoder,
std::unique_ptr<AudioRendererSink>* audio_renderer_sink,
std::unique_ptr<VideoDecoderBase>* video_decoder,
std::unique_ptr<VideoRenderAlgorithmBase>* video_render_algorithm,
scoped_refptr<VideoRendererSink>* video_renderer_sink,
std::string* error_message) override {
SB_DCHECK(error_message);
Expand Down Expand Up @@ -395,23 +397,25 @@ class PlayerComponentsFactory : public starboard::shared::starboard::player::
audio_stream_info.codec == kSbMediaAudioCodecOpus &&
!SbDrmSystemIsValid(drm_system) && !kForcePlatformOpusDecoder;
if (use_libopus_decoder) {
scoped_ptr<OpusAudioDecoder> audio_decoder_impl(
std::unique_ptr<OpusAudioDecoder> audio_decoder_impl(
new OpusAudioDecoder(audio_stream_info));
if (audio_decoder_impl->is_valid()) {
return audio_decoder_impl.PassAs<AudioDecoderBase>();
return std::unique_ptr<AudioDecoderBase>(
std::move(audio_decoder_impl));
}
} else if (audio_stream_info.codec == kSbMediaAudioCodecAac ||
audio_stream_info.codec == kSbMediaAudioCodecOpus) {
scoped_ptr<AudioDecoder> audio_decoder_impl(
std::unique_ptr<AudioDecoder> audio_decoder_impl(
new AudioDecoder(audio_stream_info, drm_system));
if (audio_decoder_impl->is_valid()) {
return audio_decoder_impl.PassAs<AudioDecoderBase>();
return std::unique_ptr<AudioDecoderBase>(
std::move(audio_decoder_impl));
}
} else {
SB_LOG(ERROR) << "Unsupported audio codec "
<< audio_stream_info.codec;
}
return scoped_ptr<AudioDecoderBase>();
return std::unique_ptr<AudioDecoderBase>();
};

audio_decoder->reset(new AdaptiveAudioDecoder(
Expand Down Expand Up @@ -452,7 +456,7 @@ class PlayerComponentsFactory : public starboard::shared::starboard::player::
force_secure_pipeline_under_tunnel_mode = false;
}

scoped_ptr<VideoDecoder> video_decoder_impl =
std::unique_ptr<VideoDecoder> video_decoder_impl =
CreateVideoDecoder(creation_parameters, tunnel_mode_audio_session_id,
force_secure_pipeline_under_tunnel_mode,
force_improved_support_check, error_message);
Expand Down Expand Up @@ -495,7 +499,7 @@ class PlayerComponentsFactory : public starboard::shared::starboard::player::
*max_cached_frames = AlignUp(*max_cached_frames, kAudioSinkFramesAlignment);
}

scoped_ptr<VideoDecoder> CreateVideoDecoder(
std::unique_ptr<VideoDecoder> CreateVideoDecoder(
const CreationParameters& creation_parameters,
int tunnel_mode_audio_session_id,
bool force_secure_pipeline_under_tunnel_mode,
Expand All @@ -514,7 +518,7 @@ class PlayerComponentsFactory : public starboard::shared::starboard::player::
force_big_endian_hdr_metadata = hdr_info_endianness == "big";
}

scoped_ptr<VideoDecoder> video_decoder(new VideoDecoder(
std::unique_ptr<VideoDecoder> video_decoder(new VideoDecoder(
creation_parameters.video_stream_info(),
creation_parameters.drm_system(), creation_parameters.output_mode(),
creation_parameters.decode_target_graphics_context_provider(),
Expand All @@ -524,11 +528,11 @@ class PlayerComponentsFactory : public starboard::shared::starboard::player::
force_improved_support_check, error_message));
if (creation_parameters.video_codec() == kSbMediaVideoCodecAv1 ||
video_decoder->is_decoder_created()) {
return video_decoder.Pass();
return video_decoder;
}
*error_message =
"Failed to create video decoder with error: " + *error_message;
return scoped_ptr<VideoDecoder>();
return std::unique_ptr<VideoDecoder>();
}

bool IsTunnelModeSupported(const CreationParameters& creation_parameters,
Expand Down Expand Up @@ -621,11 +625,11 @@ class PlayerComponentsFactory : public starboard::shared::starboard::player::
return tunnel_mode_audio_session_id;
}

scoped_ptr<AudioRendererSink> TryToCreateTunnelModeAudioRendererSink(
std::unique_ptr<AudioRendererSink> TryToCreateTunnelModeAudioRendererSink(
int tunnel_mode_audio_session_id,
const CreationParameters& creation_parameters,
bool enable_audio_device_callback) {
scoped_ptr<AudioRendererSink> audio_sink(new AudioRendererSinkAndroid(
std::unique_ptr<AudioRendererSink> audio_sink(new AudioRendererSinkAndroid(
enable_audio_device_callback, true, tunnel_mode_audio_session_id));
// We need to double check if the audio sink can actually be created.
int max_cached_frames, min_frames_per_append;
Expand All @@ -645,7 +649,7 @@ class PlayerComponentsFactory : public starboard::shared::starboard::player::
max_cached_frames, &callback_stub);
if (audio_sink->HasStarted() && !callback_stub.error_occurred()) {
audio_sink->Stop();
return audio_sink.Pass();
return audio_sink;
}
SB_LOG(WARNING)
<< "AudioTrack does not support tunnel mode with sample rate:"
Expand All @@ -654,7 +658,7 @@ class PlayerComponentsFactory : public starboard::shared::starboard::player::
<< creation_parameters.audio_stream_info().number_of_channels
<< ", audio format:" << creation_parameters.audio_codec()
<< ", and audio buffer frames:" << max_cached_frames;
return scoped_ptr<AudioRendererSink>();
return std::unique_ptr<AudioRendererSink>();
}
};

Expand Down
4 changes: 2 additions & 2 deletions starboard/android/shared/player_create.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -205,11 +205,11 @@ SbPlayer SbPlayerCreate(SbWindow window,
}
}

starboard::scoped_ptr<PlayerWorker::Handler> handler(
std::unique_ptr<PlayerWorker::Handler> handler(
new FilterBasedPlayerWorkerHandler(creation_param, provider));
SbPlayer player = SbPlayerPrivate::CreateInstance(
audio_codec, video_codec, sample_deallocate_func, decoder_status_func,
player_status_func, player_error_func, context, handler.Pass());
player_status_func, player_error_func, context, std::move(handler));

if (creation_param->output_mode != kSbPlayerOutputModeDecodeToTexture) {
// TODO: accomplish this through more direct means.
Expand Down
6 changes: 3 additions & 3 deletions starboard/android/shared/video_decoder.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -415,13 +415,13 @@ scoped_refptr<VideoDecoder::VideoRendererSink> VideoDecoder::GetSink() {
return sink_;
}

scoped_ptr<VideoDecoder::VideoRenderAlgorithm>
std::unique_ptr<VideoDecoder::VideoRenderAlgorithm>
VideoDecoder::GetRenderAlgorithm() {
if (tunnel_mode_audio_session_id_ == -1) {
return scoped_ptr<VideoRenderAlgorithm>(
return std::unique_ptr<VideoRenderAlgorithm>(
new android::shared::VideoRenderAlgorithm(this));
}
return scoped_ptr<VideoRenderAlgorithm>(
return std::unique_ptr<VideoRenderAlgorithm>(
new VideoRenderAlgorithmTunneled(video_frame_tracker_.get()));
}

Expand Down
8 changes: 4 additions & 4 deletions starboard/android/shared/video_decoder.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -75,7 +75,7 @@ class VideoDecoder
~VideoDecoder() override;

scoped_refptr<VideoRendererSink> GetSink();
scoped_ptr<VideoRenderAlgorithm> GetRenderAlgorithm();
std::unique_ptr<VideoRenderAlgorithm> GetRenderAlgorithm();

void Initialize(const DecoderStatusCB& decoder_status_cb,
const ErrorCB& error_cb) override;
Expand Down Expand Up @@ -157,8 +157,8 @@ class VideoDecoder
// On some platforms tunnel mode is only supported in the secure pipeline. So
// we create a dummy drm system to force the video playing in secure pipeline
// to enable tunnel mode.
scoped_ptr<DrmSystem> drm_system_to_enforce_tunnel_mode_;
scoped_ptr<VideoFrameTracker> video_frame_tracker_;
std::unique_ptr<DrmSystem> drm_system_to_enforce_tunnel_mode_;
std::unique_ptr<VideoFrameTracker> video_frame_tracker_;
// Preroll in tunnel mode is handled in this class instead of in the renderer.
atomic_bool tunnel_mode_prerolling_{true};
atomic_bool tunnel_mode_frame_rendered_;
Expand All @@ -185,7 +185,7 @@ class VideoDecoder
// The last enqueued |SbMediaColorMetadata|.
optional<SbMediaColorMetadata> color_metadata_;

scoped_ptr<MediaDecoder> media_decoder_;
std::unique_ptr<MediaDecoder> media_decoder_;

atomic_int32_t number_of_frames_being_decoded_;
scoped_refptr<Sink> sink_;
Expand Down
Loading

0 comments on commit 9d51f35

Please sign in to comment.