Define AudioBuffer and VideoFrame for mojo

media/mojo/services/media_type_converters_unittest.cc

Index: media/mojo/services/media_type_converters_unittest.cc
diff --git a/media/mojo/services/media_type_converters_unittest.cc b/media/mojo/services/media_type_converters_unittest.cc
index 38559f3c6be6ef50997628739fd93fbb031bcebd..3987dd225582a486f1c00275be27b2827772792a 100644
--- a/media/mojo/services/media_type_converters_unittest.cc
+++ b/media/mojo/services/media_type_converters_unittest.cc
@@ -4,14 +4,83 @@
 
 #include "media/mojo/services/media_type_converters.h"
 
+#include "media/base/audio_buffer.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/cdm_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media_util.h"
+#include "media/base/sample_format.h"
+#include "media/base/test_helpers.h"
+#include "media/base/video_frame.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
+void CompareBytes(uint8* original_data, uint8* result_data, size_t length) {

[xhwang, 2015/11/23 22:22:19]

Can we just use memcmp? Since all bytes should match, probably we don't care at
which byte it start to differ?

[xhwang, 2015/11/23 22:22:19]

move these to an anonymous namespace

[jrummell, 2015/11/24 02:37:53]

Done.

[jrummell, 2015/11/24 02:37:53]

Done.

+  EXPECT_GT(length, 0u);
+  for (size_t i = 0; i < length; ++i) {
+    EXPECT_EQ(*original_data++, *result_data++) << "Failed at " << i << " of "
+                                                << length;
+  }
+}
+
+void CompareAudioBuffers(SampleFormat sample_format,
+                         const scoped_refptr<AudioBuffer>& original,
+                         const scoped_refptr<AudioBuffer>& result) {
+  EXPECT_EQ(original->frame_count(), result->frame_count());
+  EXPECT_EQ(original->timestamp(), result->timestamp());
+  EXPECT_EQ(original->duration(), result->duration());
+  EXPECT_EQ(original->sample_rate(), result->sample_rate());
+  EXPECT_EQ(original->channel_count(), result->channel_count());
+  EXPECT_EQ(original->channel_layout(), result->channel_layout());
+  EXPECT_EQ(original->end_of_stream(), result->end_of_stream());
+
+  // Compare bytes in buffer.
+  int bytes_per_channel =
+      original->frame_count() * SampleFormatToBytesPerChannel(sample_format);
+  if (sample_format == kSampleFormatPlanarF32 ||
+      sample_format == kSampleFormatPlanarS16 ||
+      sample_format == kSampleFormatPlanarS32) {

[xhwang, 2015/11/23 22:22:19]

Seems like we should have a function IsPlanar(SampleFormat) in samplr_format.h

[jrummell, 2015/11/24 02:37:53]

Done.

+    for (int i = 0; i < original->channel_count(); ++i) {
+      CompareBytes(original->channel_data()[i], result->channel_data()[i],
+                   bytes_per_channel);
+    }
+    return;
+  }
+
+  DCHECK(sample_format == kSampleFormatU8 ||
+         sample_format == kSampleFormatS16 ||
+         sample_format == kSampleFormatS32 || sample_format == kSampleFormatF32)
+      << sample_format;
+  CompareBytes(original->channel_data()[0], result->channel_data()[0],
+               bytes_per_channel * original->channel_count());
+}
+
+void ComparePlane(size_t plane,

[xhwang, 2015/11/23 22:22:19]

how about CompareVideoPlane?

[jrummell, 2015/11/24 02:37:53]

Done.

+                  const scoped_refptr<VideoFrame>& original,
+                  const scoped_refptr<VideoFrame>& result) {
+  EXPECT_EQ(original->stride(plane), result->stride(plane));
+  EXPECT_EQ(original->row_bytes(plane), result->row_bytes(plane));
+  EXPECT_EQ(original->rows(plane), result->rows(plane));
+  CompareBytes(original->data(plane), result->data(plane),
+               original->rows(plane) * original->row_bytes(plane));
+}
+
+void CompareVideoFrames(const scoped_refptr<VideoFrame>& original,
+                        const scoped_refptr<VideoFrame>& result) {

[xhwang, 2015/11/23 22:22:19]

To be more generic, can you extend this to support EOS frames as well? 

[jrummell, 2015/11/24 02:37:53]

Not sure it is that beneficial since we only check one field, but done anyway.

+  EXPECT_EQ(original->format(), result->format());
+  EXPECT_EQ(original->coded_size().height(), result->coded_size().height());
+  EXPECT_EQ(original->coded_size().width(), result->coded_size().width());
+  EXPECT_EQ(original->visible_rect().height(), result->visible_rect().height());
+  EXPECT_EQ(original->visible_rect().width(), result->visible_rect().width());
+  EXPECT_EQ(original->natural_size().height(), result->natural_size().height());
+  EXPECT_EQ(original->natural_size().width(), result->natural_size().width());
+
+  ComparePlane(media::VideoFrame::kYPlane, original, result);
+  ComparePlane(media::VideoFrame::kUPlane, original, result);
+  ComparePlane(media::VideoFrame::kVPlane, original, result);
+}
+
 TEST(MediaTypeConvertersTest, ConvertDecoderBuffer_Normal) {
   const uint8 kData[] = "hello, world";
   const uint8 kSideData[] = "sideshow bob";
@@ -172,4 +241,89 @@ TEST(MediaTypeConvertersTest, ConvertCdmConfig) {
   EXPECT_EQ(config.use_hw_secure_codecs, result.use_hw_secure_codecs);
 }
 
+TEST(MediaTypeConvertersTest, ConvertAudioBuffer_EOS) {
+  // Original.
+  scoped_refptr<AudioBuffer> buffer(AudioBuffer::CreateEOSBuffer());
+
+  // Convert to and back.
+  interfaces::AudioBufferPtr ptr(interfaces::AudioBuffer::From(buffer));
+  scoped_refptr<AudioBuffer> result(ptr.To<scoped_refptr<AudioBuffer>>());
+
+  // Compare.
+  EXPECT_TRUE(result->end_of_stream());
+}
+
+TEST(MediaTypeConvertersTest, ConvertAudioBuffer_MONO) {
+  // Original.
+  const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_MONO;
+  const int kSampleRate = 48000;
+  scoped_refptr<AudioBuffer> buffer = MakeAudioBuffer<uint8>(
+      kSampleFormatU8, kChannelLayout,
+      ChannelLayoutToChannelCount(kChannelLayout), kSampleRate, 1, 1,
+      kSampleRate / 100, base::TimeDelta());
+
+  // Convert to and back.
+  interfaces::AudioBufferPtr ptr(interfaces::AudioBuffer::From(buffer));
+  scoped_refptr<AudioBuffer> result(ptr.To<scoped_refptr<AudioBuffer>>());
+
+  // Compare.
+  CompareAudioBuffers(kSampleFormatU8, buffer, result);
+}
+
+TEST(MediaTypeConvertersTest, ConvertAudioBuffer_FLOAT) {
+  // Original.
+  const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_4_0;
+  const int kSampleRate = 48000;
+  const base::TimeDelta start_time = base::TimeDelta::FromSecondsD(1000.0);
+  scoped_refptr<AudioBuffer> buffer = MakeAudioBuffer<float>(
+      kSampleFormatPlanarF32, kChannelLayout,
+      ChannelLayoutToChannelCount(kChannelLayout), kSampleRate, 0.0f, 1.0f,
+      kSampleRate / 10, start_time);
+  // Convert to and back.
+  interfaces::AudioBufferPtr ptr(interfaces::AudioBuffer::From(buffer));
+  scoped_refptr<AudioBuffer> result(ptr.To<scoped_refptr<AudioBuffer>>());
+
+  // Compare.
+  CompareAudioBuffers(kSampleFormatPlanarF32, buffer, result);
+}
+
+TEST(MediaTypeConvertersTest, ConvertVideoFrame_EOS) {
+  // Original.
+  scoped_refptr<VideoFrame> buffer(VideoFrame::CreateEOSFrame());
+
+  // Convert to and back.
+  interfaces::VideoFramePtr ptr(interfaces::VideoFrame::From(buffer));
+  scoped_refptr<VideoFrame> result(ptr.To<scoped_refptr<VideoFrame>>());
+
+  // Compare.
+  EXPECT_TRUE(
+      result->metadata()->IsTrue(media::VideoFrameMetadata::END_OF_STREAM));

[xhwang, 2015/11/23 22:22:19]

+dalecurtis

Wondering why we don't have a simple call VideoFrame::is_end_of_stream()?

https://code.google.com/p/chromium/codesearch#search/&q=VideoFrameMetadata::E...

+}
+
+TEST(MediaTypeConvertersTest, ConvertVideoFrame_BlackFrame) {
+  // Original.
+  scoped_refptr<VideoFrame> buffer(
+      VideoFrame::CreateBlackFrame(gfx::Size(100, 100)));
+
+  // Convert to and back.
+  interfaces::VideoFramePtr ptr(interfaces::VideoFrame::From(buffer));
+  scoped_refptr<VideoFrame> result(ptr.To<scoped_refptr<VideoFrame>>());
+
+  // Compare.
+  CompareVideoFrames(buffer, result);
+}
+
+TEST(MediaTypeConvertersTest, ConvertVideoFrame_ColorFrame) {
+  // Original.
+  scoped_refptr<VideoFrame> buffer(VideoFrame::CreateColorFrame(
+      gfx::Size(50, 100), 255, 128, 128, base::TimeDelta::FromSeconds(26)));
+
+  // Convert to and back.
+  interfaces::VideoFramePtr ptr(interfaces::VideoFrame::From(buffer));
+  scoped_refptr<VideoFrame> result(ptr.To<scoped_refptr<VideoFrame>>());
+
+  // Compare.
+  CompareVideoFrames(buffer, result);
+}
+
 }  // namespace media