starboard: Flatten various audio and decoder namespaces (#7156)

[go/cobalt-flatten-starboard-namespace](http://go/cobalt-flatten-starboard-namespace)

#7132 uniquely named various audio and video decoders. Now we put those
decoders in the flattened namespace and we don't need decoder-specific
namespaces

This PR also did some refactoring of replacing new with `make_unique`.

#vibe-coded

Bug: 441955897

Author: kjyoun

starboard/android/shared/audio_decoder.h

@@ -36,10 +36,9 @@
 
 namespace starboard::android::shared {
 
-class MediaCodecAudioDecoder
-    : public ::starboard::shared::starboard::player::filter::AudioDecoder,
-      public MediaCodecDecoder::Host,
-      private JobQueue::JobOwner {
+class MediaCodecAudioDecoder : public AudioDecoder,
+                               public MediaCodecDecoder::Host,
+                               private JobQueue::JobOwner {
  public:
   typedef ::starboard::shared::starboard::media::AudioStreamInfo
       AudioStreamInfo;

starboard/android/shared/audio_decoder_passthrough.h

@@ -34,8 +34,7 @@ namespace starboard::android::shared {
 // in, without actually decoding the input audio.  It can be used in situations
 // (like passthrough playbacks) where an AudioDecoder has to be used, but is
 // expected to not alter the input and pass it to the renderer as is.
-class AudioDecoderPassthrough
-    : public ::starboard::shared::starboard::player::filter::AudioDecoder {
+class AudioDecoderPassthrough : public AudioDecoder {
  public:
   explicit AudioDecoderPassthrough(int samples_per_second)
       : samples_per_second_(samples_per_second) {}

starboard/android/shared/audio_renderer_passthrough.h

@@ -102,8 +102,7 @@ class AudioRendererPassthrough
   // TODO: Revisit to encapsulate the AudioDecoder as a SbDrmSystemPrivate
   //       instead.  This would need to turn SbDrmSystemPrivate::Decrypt() into
   //       asynchronous, which comes with extra risks.
-  std::unique_ptr<::starboard::shared::starboard::player::filter::AudioDecoder>
-      decoder_;
+  std::unique_ptr<AudioDecoder> decoder_;
 
   // The following three variables are set in Initialize().
   ErrorCB error_cb_;

starboard/android/shared/player_components_factory.cc

@@ -163,19 +163,14 @@ class PlayerComponentsPassthrough
 class PlayerComponentsFactory : public starboard::shared::starboard::player::
                                     filter::PlayerComponents::Factory {
   typedef starboard::shared::starboard::media::MimeType MimeType;
-  typedef starboard::shared::opus::OpusAudioDecoder OpusAudioDecoder;
   typedef starboard::shared::starboard::player::filter::AdaptiveAudioDecoder
       AdaptiveAudioDecoder;
-  typedef starboard::shared::starboard::player::filter::AudioDecoder
-      AudioDecoder;
   typedef starboard::shared::starboard::player::filter::AudioRendererSink
       AudioRendererSink;
   typedef starboard::shared::starboard::player::filter::AudioRendererSinkImpl
       AudioRendererSinkImpl;
   typedef starboard::shared::starboard::player::filter::PlayerComponents
       PlayerComponents;
-  typedef starboard::shared::starboard::player::filter::VideoDecoder
-      VideoDecoder;
   typedef starboard::shared::starboard::player::filter::VideoRenderAlgorithm
       VideoRenderAlgorithm;
   typedef starboard::shared::starboard::player::filter::VideoRendererSink

starboard/android/shared/video_decoder.h

@@ -44,11 +44,10 @@
 
 namespace starboard::android::shared {
 
-class MediaCodecVideoDecoder
-    : public ::starboard::shared::starboard::player::filter::VideoDecoder,
-      public MediaCodecDecoder::Host,
-      private JobQueue::JobOwner,
-      private VideoSurfaceHolder {
+class MediaCodecVideoDecoder : public VideoDecoder,
+                               public MediaCodecDecoder::Host,
+                               private JobQueue::JobOwner,
+                               private VideoSurfaceHolder {
  public:
   typedef ::starboard::shared::starboard::media::VideoStreamInfo
       VideoStreamInfo;

starboard/linux/shared/media_is_video_supported.cc

@@ -28,8 +28,6 @@ namespace shared {
 namespace starboard {
 namespace media {
 
-using ::starboard::shared::de265::is_de265_supported;
-
 bool MediaIsVideoSupported(SbMediaVideoCodec video_codec,
                            const MimeType* mime_type,
                            int profile,

starboard/linux/shared/player_components_factory.cc

@@ -50,8 +50,6 @@ namespace filter {
 
 namespace {
 
-using ::starboard::shared::openh264::is_openh264_supported;
-
 class PlayerComponentsFactory : public PlayerComponents::Factory {
  public:
   bool CreateSubComponents(
@@ -68,34 +66,30 @@ class PlayerComponentsFactory : public PlayerComponents::Factory {
       SB_DCHECK(audio_decoder);
       SB_DCHECK(audio_renderer_sink);
 
-      typedef ::starboard::shared::opus::OpusAudioDecoder OpusAudioDecoder;
-      typedef ::starboard::shared::libfdkaac::FdkAacAudioDecoder
-          FdkAacAudioDecoder;
-
       auto decoder_creator =
           [](const media::AudioStreamInfo& audio_stream_info,
              SbDrmSystem drm_system) -> std::unique_ptr<AudioDecoder> {
         if (audio_stream_info.codec == kSbMediaAudioCodecOpus) {
-          std::unique_ptr<OpusAudioDecoder> audio_decoder_impl(
-              new OpusAudioDecoder(audio_stream_info));
-          if (audio_decoder_impl->is_valid()) {
-            return std::unique_ptr<AudioDecoder>(std::move(audio_decoder_impl));
+          auto opus_audio_decoder =
+              std::make_unique<OpusAudioDecoder>(audio_stream_info);
+          if (opus_audio_decoder->is_valid()) {
+            return opus_audio_decoder;
           } else {
             SB_LOG(ERROR) << "Failed to create audio decoder for codec "
                           << GetMediaAudioCodecName(audio_stream_info.codec);
           }
         } else if (audio_stream_info.codec == kSbMediaAudioCodecAac &&
                    audio_stream_info.number_of_channels <=
                        FdkAacAudioDecoder::kMaxChannels &&
-                   libfdkaac::LibfdkaacHandle::GetHandle()->IsLoaded()) {
+                   LibfdkaacHandle::GetHandle()->IsLoaded()) {
           SB_LOG(INFO) << "Playing audio using FdkAacAudioDecoder.";
-          return std::unique_ptr<AudioDecoder>(new FdkAacAudioDecoder());
+          return std::make_unique<FdkAacAudioDecoder>();
         } else {
-          std::unique_ptr<FfmpegAudioDecoder> audio_decoder_impl(
+          std::unique_ptr<FfmpegAudioDecoder> ffmpeg_audio_decoder(
               FfmpegAudioDecoder::Create(audio_stream_info));
-          if (audio_decoder_impl && audio_decoder_impl->is_valid()) {
+          if (ffmpeg_audio_decoder && ffmpeg_audio_decoder->is_valid()) {
             SB_LOG(INFO) << "Playing audio using FfmpegAudioDecoder";
-            return std::unique_ptr<AudioDecoder>(std::move(audio_decoder_impl));
+            return ffmpeg_audio_decoder;
           } else {
             SB_LOG(ERROR) << "Failed to create audio decoder for codec "
                           << GetMediaAudioCodecName(audio_stream_info.codec);
@@ -104,18 +98,13 @@ class PlayerComponentsFactory : public PlayerComponents::Factory {
         return nullptr;
       };
 
-      audio_decoder->reset(new AdaptiveAudioDecoder(
+      *audio_decoder = std::make_unique<AdaptiveAudioDecoder>(
           creation_parameters.audio_stream_info(),
-          creation_parameters.drm_system(), decoder_creator));
-      audio_renderer_sink->reset(new AudioRendererSinkImpl);
+          creation_parameters.drm_system(), decoder_creator);
+      *audio_renderer_sink = std::make_unique<AudioRendererSinkImpl>();
     }
 
     if (creation_parameters.video_codec() != kSbMediaVideoCodecNone) {
-      using ::starboard::shared::de265::De265VideoDecoder;
-      using ::starboard::shared::libdav1d::Dav1dVideoDecoder;
-      using ::starboard::shared::openh264::OpenH264VideoDecoder;
-      using ::starboard::shared::vpx::VpxVideoDecoder;
-
       const int64_t kVideoSinkRenderIntervalUsec = 10'000;
 
       SB_DCHECK(video_decoder);
@@ -190,8 +179,7 @@ class PlayerComponentsFactory : public PlayerComponents::Factory {
 
 // static
 std::unique_ptr<PlayerComponents::Factory> PlayerComponents::Factory::Create() {
-  return std::unique_ptr<PlayerComponents::Factory>(
-      new PlayerComponentsFactory);
+  return std::make_unique<PlayerComponentsFactory>();
 }
 
 // static

starboard/raspi/shared/open_max/video_decoder.h

@@ -36,9 +36,7 @@
 
 namespace starboard {
 
-class OpenMaxVideoDecoder
-    : public ::starboard::shared::starboard::player::filter::VideoDecoder,
-      private JobQueue::JobOwner {
+class OpenMaxVideoDecoder : public VideoDecoder, private JobQueue::JobOwner {
  public:
   explicit OpenMaxVideoDecoder(SbMediaVideoCodec video_codec);
   ~OpenMaxVideoDecoder() override;

starboard/raspi/shared/player_components_factory.cc

@@ -53,8 +53,6 @@ class PlayerComponentsFactory : public PlayerComponents::Factory {
       auto decoder_creator =
           [](const media::AudioStreamInfo& audio_stream_info,
              SbDrmSystem drm_system) -> std::unique_ptr<AudioDecoder> {
-        using ::starboard::shared::opus::OpusAudioDecoder;
-
         if (audio_stream_info.codec == kSbMediaAudioCodecOpus) {
           auto opus_audio_decoder =
               std::make_unique<OpusAudioDecoder>(audio_stream_info);
@@ -97,8 +95,7 @@ class PlayerComponentsFactory : public PlayerComponents::Factory {
 
 // static
 std::unique_ptr<PlayerComponents::Factory> PlayerComponents::Factory::Create() {
-  return std::unique_ptr<PlayerComponents::Factory>(
-      new PlayerComponentsFactory);
+  return std::make_unique<PlayerComponentsFactory>();
 }
 
 // static

starboard/shared/ffmpeg/ffmpeg_audio_decoder.h

@@ -22,8 +22,7 @@
 
 namespace starboard {
 
-class FfmpegAudioDecoder
-    : public shared::starboard::player::filter::AudioDecoder {
+class FfmpegAudioDecoder : public AudioDecoder {
  public:
   typedef shared::starboard::media::AudioStreamInfo AudioStreamInfo;