media: scaffolding and plumbing for MojoRenderer{Impl, Service}

media/mojo/services/media_type_converters.cc

Index: media/mojo/services/media_type_converters.cc
diff --git a/media/mojo/services/media_type_converters.cc b/media/mojo/services/media_type_converters.cc
index a6b0fad9723b33dcc965a92217a18bcfa00c0d21..2a39b53a3264bc5b3c562d8482b982a3406f8251 100644
--- a/media/mojo/services/media_type_converters.cc
+++ b/media/mojo/services/media_type_converters.cc
@@ -5,19 +5,124 @@
 #include "media/mojo/services/media_type_converters.h"
 
 #include "base/macros.h"
+#include "media/base/audio_decoder_config.h"
 #include "media/base/buffering_state.h"
 #include "media/base/decoder_buffer.h"
+#include "media/base/demuxer_stream.h"
+#include "media/mojo/interfaces/demuxer_stream.mojom.h"
 #include "mojo/public/cpp/system/data_pipe.h"
 
 namespace mojo {
 
-#define ASSERT_ENUM_VALUES_EQUAL(value)                              \
-  COMPILE_ASSERT(media::BUFFERING_##value ==                         \
-      static_cast<media::BufferingState>(BUFFERING_STATE_##value),   \
-          value##_enum_value_matches)
+#define ASSERT_ENUM_EQ(media_enum, media_prefix, mojo_prefix, value)     \
+  COMPILE_ASSERT(media::media_prefix##value ==                           \
+                     static_cast<media::media_enum>(mojo_prefix##value), \
+                 value##_enum_value_differs)
 
-ASSERT_ENUM_VALUES_EQUAL(HAVE_NOTHING);
-ASSERT_ENUM_VALUES_EQUAL(HAVE_ENOUGH);
+// BufferingState.
+ASSERT_ENUM_EQ(BufferingState, BUFFERING_, BUFFERING_STATE_, HAVE_NOTHING);
+ASSERT_ENUM_EQ(BufferingState, BUFFERING_, BUFFERING_STATE_, HAVE_ENOUGH);
+
+// AudioCodec.
+COMPILE_ASSERT(media::kUnknownAudioCodec ==
+                   static_cast<media::AudioCodec>(AUDIO_CODEC_UNKNOWN),
+               kUnknownAudioCodec_enum_value_differs);
+ASSERT_ENUM_EQ(AudioCodec, kCodec, AUDIO_CODEC_, AAC);
+ASSERT_ENUM_EQ(AudioCodec, kCodec, AUDIO_CODEC_, MP3);
+ASSERT_ENUM_EQ(AudioCodec, kCodec, AUDIO_CODEC_, PCM);
+ASSERT_ENUM_EQ(AudioCodec, kCodec, AUDIO_CODEC_, Vorbis);
+ASSERT_ENUM_EQ(AudioCodec, kCodec, AUDIO_CODEC_, FLAC);
+ASSERT_ENUM_EQ(AudioCodec, kCodec, AUDIO_CODEC_, AMR_NB);
+ASSERT_ENUM_EQ(AudioCodec, kCodec, AUDIO_CODEC_, PCM_MULAW);
+ASSERT_ENUM_EQ(AudioCodec, kCodec, AUDIO_CODEC_, GSM_MS);
+ASSERT_ENUM_EQ(AudioCodec, kCodec, AUDIO_CODEC_, PCM_S16BE);
+ASSERT_ENUM_EQ(AudioCodec, kCodec, AUDIO_CODEC_, PCM_S24BE);
+ASSERT_ENUM_EQ(AudioCodec, kCodec, AUDIO_CODEC_, Opus);
+ASSERT_ENUM_EQ(AudioCodec, kCodec, AUDIO_CODEC_, PCM_ALAW);
+COMPILE_ASSERT(media::kAudioCodecMax ==
+                   static_cast<media::AudioCodec>(AUDIO_CODEC_MAX),
+               kAudioCodecMax_enum_value_differs);
+
+// ChannelLayout.
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _NONE);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _UNSUPPORTED);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _MONO);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _STEREO);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _2_1);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _SURROUND);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _4_0);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _2_2);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _QUAD);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _5_0);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _5_1);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _5_0_BACK);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _5_1_BACK);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _7_0);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _7_1);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _7_1_WIDE);
+ASSERT_ENUM_EQ(ChannelLayout,
+               CHANNEL_LAYOUT,
+               CHANNEL_LAYOUT_k,
+               _STEREO_DOWNMIX);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _2POINT1);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _3_1);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _4_1);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _6_0);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _6_0_FRONT);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _HEXAGONAL);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _6_1);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _6_1_BACK);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _6_1_FRONT);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _7_0_FRONT);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _7_1_WIDE_BACK);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _OCTAGONAL);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _DISCRETE);
+ASSERT_ENUM_EQ(ChannelLayout,
+               CHANNEL_LAYOUT,
+               CHANNEL_LAYOUT_k,
+               _STEREO_AND_KEYBOARD_MIC);
+ASSERT_ENUM_EQ(ChannelLayout, CHANNEL_LAYOUT, CHANNEL_LAYOUT_k, _MAX);
+
+// SampleFormat.
+COMPILE_ASSERT(media::kUnknownSampleFormat ==
+                   static_cast<media::SampleFormat>(SAMPLE_FORMAT_UNKNOWN),
+               kUnknownSampleFormat_enum_value_differs);
+ASSERT_ENUM_EQ(SampleFormat, kSampleFormat, SAMPLE_FORMAT_, U8);
+ASSERT_ENUM_EQ(SampleFormat, kSampleFormat, SAMPLE_FORMAT_, S16);
+ASSERT_ENUM_EQ(SampleFormat, kSampleFormat, SAMPLE_FORMAT_, S32);
+ASSERT_ENUM_EQ(SampleFormat, kSampleFormat, SAMPLE_FORMAT_, F32);
+ASSERT_ENUM_EQ(SampleFormat, kSampleFormat, SAMPLE_FORMAT_, PlanarS16);
+ASSERT_ENUM_EQ(SampleFormat, kSampleFormat, SAMPLE_FORMAT_, PlanarF32);
+ASSERT_ENUM_EQ(SampleFormat, kSampleFormat, SAMPLE_FORMAT_, Max);
+
+// DemuxerStream Type.
+COMPILE_ASSERT(media::DemuxerStream::UNKNOWN ==
+                   static_cast<media::DemuxerStream::Type>(
+                       mojo::DemuxerStream::TYPE_UNKNOWN),
+               DemuxerStream_Type_enum_value_differs);
+COMPILE_ASSERT(media::DemuxerStream::AUDIO ==
+                   static_cast<media::DemuxerStream::Type>(
+                       mojo::DemuxerStream::TYPE_AUDIO),
+               DemuxerStream_Type_enum_value_differs);
+// Update this if new media::DemuxerStream::Type values are introduced.
+COMPILE_ASSERT(media::DemuxerStream::NUM_TYPES ==
+                   static_cast<media::DemuxerStream::Type>(
+                       mojo::DemuxerStream::TYPE_LAST_TYPE + 3),
+               DemuxerStream_Type_enum_value_differs);
+
+// DemuxerStream Status.
+COMPILE_ASSERT(media::DemuxerStream::kOk ==
+                   static_cast<media::DemuxerStream::Status>(
+                       mojo::DemuxerStream::STATUS_OK),
+               DemuxerStream_Status_enum_value_differs);
+COMPILE_ASSERT(media::DemuxerStream::kAborted ==
+                   static_cast<media::DemuxerStream::Status>(
+                       mojo::DemuxerStream::STATUS_ABORTED),
+               DemuxerStream_Status_enum_value_differs);
+COMPILE_ASSERT(media::DemuxerStream::kConfigChanged ==
+                   static_cast<media::DemuxerStream::Status>(
+                       mojo::DemuxerStream::STATUS_CONFIG_CHANGED),
+               DemuxerStream_Status_enum_value_differs);
 
 // static
 MediaDecoderBufferPtr TypeConverter<MediaDecoderBufferPtr,
@@ -83,7 +188,7 @@ scoped_refptr<media::DecoderBuffer>  TypeConverter<
   if (input->side_data_size) {
     buffer = media::DecoderBuffer::CopyFrom(data.get(),
                                             num_bytes,
-                                            input->side_data.storage().data(),
+                                            &input->side_data.front(),
                                             input->side_data_size);
   } else {
     buffer = media::DecoderBuffer::CopyFrom(data.get(), num_bytes);
@@ -102,4 +207,43 @@ scoped_refptr<media::DecoderBuffer>  TypeConverter<
   return buffer;
 }
 
+// static
+AudioDecoderConfigPtr
+TypeConverter<AudioDecoderConfigPtr, media::AudioDecoderConfig>::Convert(
+    const media::AudioDecoderConfig& input) {
+  mojo::AudioDecoderConfigPtr config(mojo::AudioDecoderConfig::New());
+  config->codec = static_cast<mojo::AudioCodec>(input.codec());
+  config->sample_format =
+      static_cast<mojo::SampleFormat>(input.sample_format());
+  config->channel_layout =
+      static_cast<mojo::ChannelLayout>(input.channel_layout());
+  config->samples_per_second = input.samples_per_second();
+  if (input.extra_data()) {
+    std::vector<uint8> data(input.extra_data(),
+                            input.extra_data() + input.extra_data_size());
+    config->extra_data.Swap(&data);
+  }
+  config->seek_preroll_usec = input.seek_preroll().InMicroseconds();
+  config->codec_delay = input.codec_delay();
+  return config.Pass();
+}
+
+// static
+media::AudioDecoderConfig
+TypeConverter<media::AudioDecoderConfig, AudioDecoderConfigPtr>::Convert(
+    const AudioDecoderConfigPtr& input) {
+  media::AudioDecoderConfig config;
+  config.Initialize(static_cast<media::AudioCodec>(input->codec),
+                    static_cast<media::SampleFormat>(input->sample_format),
+                    static_cast<media::ChannelLayout>(input->channel_layout),
+                    input->samples_per_second,
+                    &input->extra_data.front(),
+                    input->extra_data.size(),
+                    false,
+                    false,
+                    base::TimeDelta::FromMicroseconds(input->seek_preroll_usec),
+                    input->codec_delay);
+  return config;
+}
+
 }  // namespace mojo