Added FakeGlVideoDecodeEngine to exercise the IPC protocol for hardware video decoding

media/mf/test/mft_h264_decoder_unittest.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
@@ skipping 107 matching lines @@
   virtual void OnUninitializeComplete() {
     uninit_count_++;
   }
   virtual void OnFlushComplete() {
     flush_count_++;
   }
   virtual void OnSeekComplete() {}
   virtual void OnError() {}
   virtual void OnFormatChange(VideoStreamInfo stream_info) {
     format_change_count_++;
-    info_.stream_info_ = stream_info;
+    info_.stream_info = stream_info;
   }
   virtual void ProduceVideoSample(scoped_refptr<Buffer> buffer) {
     if (reader_.get() && decoder_) {
       empty_buffer_callback_count_++;
       scoped_refptr<DataBuffer> input;
       reader_->ReadCallback(&input);
       decoder_->ConsumeVideoSample(input);
     }
   }
   virtual void ConsumeVideoFrame(scoped_refptr<VideoFrame> frame) {
@@ skipping 26 matching lines @@
 }
 
 TEST_F(MftH264DecoderTest, DecoderUninitializedAtFirst) {
   scoped_ptr<MftH264Decoder> decoder(new MftH264Decoder(true));
   ASSERT_TRUE(decoder.get());
   EXPECT_EQ(MftH264Decoder::kUninitialized, decoder->state());
 }
 
 TEST_F(MftH264DecoderTest, DecoderInitMissingArgs) {
   VideoCodecConfig config;
-  config.width_ = 800;
-  config.height_ = 600;
+  config.width = 800;
+  config.height = 600;
   scoped_ptr<MftH264Decoder> decoder(new MftH264Decoder(false));
   ASSERT_TRUE(decoder.get());
   decoder->Initialize(NULL, NULL, config);
   EXPECT_EQ(MftH264Decoder::kUninitialized, decoder->state());
 }
 
 TEST_F(MftH264DecoderTest, DecoderInitNoDxva) {
   MessageLoop loop;
   SimpleMftH264DecoderHandler handler;
   VideoCodecConfig config;
-  config.width_ = 800;
-  config.height_ = 600;
+  config.width = 800;
+  config.height = 600;
   scoped_ptr<MftH264Decoder> decoder(new MftH264Decoder(false));
   ASSERT_TRUE(decoder.get());
   decoder->Initialize(&loop, &handler, config);
   EXPECT_EQ(1, handler.init_count_);
   EXPECT_EQ(MftH264Decoder::kNormal, decoder->state());
   decoder->Uninitialize();
 }
 
 TEST_F(MftH264DecoderTest, DecoderInitDxva) {
   MessageLoop loop;
   SimpleMftH264DecoderHandler handler;
   VideoCodecConfig config;
-  config.width_ = 800;
-  config.height_ = 600;
+  config.width = 800;
+  config.height = 600;
   scoped_ptr<MftH264Decoder> decoder(new MftH264Decoder(true));
   ASSERT_TRUE(decoder.get());
   decoder->Initialize(&loop, &handler, config);
   EXPECT_EQ(1, handler.init_count_);
   EXPECT_EQ(MftH264Decoder::kNormal, decoder->state());
   decoder->Uninitialize();
 }
 
 TEST_F(MftH264DecoderTest, DecoderUninit) {
   MessageLoop loop;
   SimpleMftH264DecoderHandler handler;
   VideoCodecConfig config;
-  config.width_ = 800;
-  config.height_ = 600;
+  config.width = 800;
+  config.height = 600;
   scoped_ptr<MftH264Decoder> decoder(new MftH264Decoder(false));
   ASSERT_TRUE(decoder.get());
   decoder->Initialize(&loop, &handler, config);
   EXPECT_EQ(MftH264Decoder::kNormal, decoder->state());
   decoder->Uninitialize();
   EXPECT_EQ(1, handler.uninit_count_);
   EXPECT_EQ(MftH264Decoder::kUninitialized, decoder->state());
 }
 
 TEST_F(MftH264DecoderTest, UninitBeforeInit) {
   MessageLoop loop;
   SimpleMftH264DecoderHandler handler;
   VideoCodecConfig config;
-  config.width_ = 800;
-  config.height_ = 600;
+  config.width = 800;
+  config.height = 600;
   scoped_ptr<MftH264Decoder> decoder(new MftH264Decoder(false));
   ASSERT_TRUE(decoder.get());
   decoder->Uninitialize();
   EXPECT_EQ(0, handler.uninit_count_);
 }
 
 TEST_F(MftH264DecoderTest, InitWithNegativeDimensions) {
   MessageLoop loop;
   SimpleMftH264DecoderHandler handler;
   VideoCodecConfig config;
-  config.width_ = -123;
-  config.height_ = -456;
+  config.width = -123;
+  config.height = -456;
   scoped_ptr<MftH264Decoder> decoder(new MftH264Decoder(false));
   ASSERT_TRUE(decoder.get());
   decoder->Initialize(&loop, &handler, config);
   EXPECT_EQ(MftH264Decoder::kNormal, decoder->state());
-  EXPECT_EQ(kDecoderMaxWidth, handler.info_.stream_info_.surface_width_);
-  EXPECT_EQ(kDecoderMaxHeight, handler.info_.stream_info_.surface_height_);
+  EXPECT_EQ(kDecoderMaxWidth, handler.info_.stream_info.surface_width);
+  EXPECT_EQ(kDecoderMaxHeight, handler.info_.stream_info.surface_height);
   decoder->Uninitialize();
 }
 
 TEST_F(MftH264DecoderTest, InitWithTooHighDimensions) {
   MessageLoop loop;
   SimpleMftH264DecoderHandler handler;
   VideoCodecConfig config;
-  config.width_ = kDecoderMaxWidth + 1;
-  config.height_ = kDecoderMaxHeight + 1;
+  config.width = kDecoderMaxWidth + 1;
+  config.height = kDecoderMaxHeight + 1;
   scoped_ptr<MftH264Decoder> decoder(new MftH264Decoder(false));
   ASSERT_TRUE(decoder.get());
   decoder->Initialize(&loop, &handler, config);
   EXPECT_EQ(MftH264Decoder::kNormal, decoder->state());
-  EXPECT_EQ(kDecoderMaxWidth, handler.info_.stream_info_.surface_width_);
-  EXPECT_EQ(kDecoderMaxHeight, handler.info_.stream_info_.surface_height_);
+  EXPECT_EQ(kDecoderMaxWidth, handler.info_.stream_info.surface_width);
+  EXPECT_EQ(kDecoderMaxHeight, handler.info_.stream_info.surface_height);
   decoder->Uninitialize();
 }
 
 TEST_F(MftH264DecoderTest, DrainOnEmptyBuffer) {
   MessageLoop loop;
   SimpleMftH264DecoderHandler handler;
   VideoCodecConfig config;
-  config.width_ = 1024;
-  config.height_ = 768;
+  config.width = 1024;
+  config.height = 768;
   scoped_ptr<MftH264Decoder> decoder(new MftH264Decoder(false));
   ASSERT_TRUE(decoder.get());
   decoder->Initialize(&loop, &handler, config);
   EXPECT_EQ(MftH264Decoder::kNormal, decoder->state());
   scoped_refptr<Buffer> buffer(new DataBuffer(0));
 
   // Decoder should switch to drain mode because of this NULL buffer, and then
   // switch to kStopped when it says it needs more input during drain mode.
   decoder->ConsumeVideoSample(buffer);
   EXPECT_EQ(MftH264Decoder::kStopped, decoder->state());
 
   // Should have called back with one empty frame.
   EXPECT_EQ(1, handler.fill_buffer_callback_count_);
   ASSERT_TRUE(handler.current_frame_.get());
   EXPECT_EQ(VideoFrame::EMPTY, handler.current_frame_->format());
   decoder->Uninitialize();
 }
 
 TEST_F(MftH264DecoderTest, NoOutputOnGarbageInput) {
   // 100 samples of garbage.
   const int kNumFrames = 100;
   scoped_refptr<FakeMftReader> reader(new FakeMftReader(kNumFrames));
   ASSERT_TRUE(reader.get());
 
   MessageLoop loop;
   SimpleMftH264DecoderHandler handler;
   VideoCodecConfig config;
-  config.width_ = 1024;
-  config.height_ = 768;
+  config.width = 1024;
+  config.height = 768;
   scoped_ptr<MftH264Decoder> decoder(new MftH264Decoder(false));
   ASSERT_TRUE(decoder.get());
   decoder->Initialize(&loop, &handler, config);
   EXPECT_EQ(MftH264Decoder::kNormal, decoder->state());
   handler.SetReader(reader);
   handler.SetDecoder(decoder.get());
   while (MftH264Decoder::kStopped != decoder->state()) {
     scoped_refptr<VideoFrame> frame;
     decoder->ProduceVideoFrame(frame);
   }
 
   // Output callback should only be invoked once - the empty frame to indicate
   // end of stream.
   EXPECT_EQ(1, handler.fill_buffer_callback_count_);
   ASSERT_TRUE(handler.current_frame_.get());
   EXPECT_EQ(VideoFrame::EMPTY, handler.current_frame_->format());
 
   // One extra count because of the end of stream NULL sample.
   EXPECT_EQ(kNumFrames, handler.empty_buffer_callback_count_ - 1);
   decoder->Uninitialize();
 }
 
 TEST_F(MftH264DecoderTest, FlushAtStart) {
   MessageLoop loop;
   SimpleMftH264DecoderHandler handler;
   VideoCodecConfig config;
-  config.width_ = 1024;
-  config.height_ = 768;
+  config.width = 1024;
+  config.height = 768;
   scoped_ptr<MftH264Decoder> decoder(new MftH264Decoder(false));
   ASSERT_TRUE(decoder.get());
   decoder->Initialize(&loop, &handler, config);
   EXPECT_EQ(MftH264Decoder::kNormal, decoder->state());
   decoder->Flush();
 
   // Flush should succeed even if input/output are empty.
   EXPECT_EQ(1, handler.flush_count_);
   decoder->Uninitialize();
 }
 
 TEST_F(MftH264DecoderTest, NoFlushAtStopped) {
   scoped_refptr<BaseMftReader> reader(new FakeMftReader());
   ASSERT_TRUE(reader.get());
 
   MessageLoop loop;
   SimpleMftH264DecoderHandler handler;
   VideoCodecConfig config;
-  config.width_ = 1024;
-  config.height_ = 768;
+  config.width = 1024;
+  config.height = 768;
   scoped_ptr<MftH264Decoder> decoder(new MftH264Decoder(false));
   ASSERT_TRUE(decoder.get());
   decoder->Initialize(&loop, &handler, config);
   EXPECT_EQ(MftH264Decoder::kNormal, decoder->state());
   handler.SetReader(reader);
   handler.SetDecoder(decoder.get());
   while (MftH264Decoder::kStopped != decoder->state()) {
     scoped_refptr<VideoFrame> frame;
     decoder->ProduceVideoFrame(frame);
   }
@@ skipping 21 matching lines @@
   ASSERT_TRUE(file_util::PathExists(path));
   ASSERT_TRUE(reader->InitReader(WideToASCII(path.value())));
   int actual_width;
   int actual_height;
   ASSERT_TRUE(reader->GetWidth(&actual_width));
   ASSERT_TRUE(reader->GetHeight(&actual_height));
 
   MessageLoop loop;
   SimpleMftH264DecoderHandler handler;
   VideoCodecConfig config;
-  config.width_ = 1;
-  config.height_ = 1;
+  config.width = 1;
+  config.height = 1;
   scoped_ptr<MftH264Decoder> decoder(new MftH264Decoder(dxva));
   ASSERT_TRUE(decoder.get());
   decoder->Initialize(&loop, &handler, config);
   EXPECT_EQ(MftH264Decoder::kNormal, decoder->state());
   handler.SetReader(reader);
   handler.SetDecoder(decoder.get());
   while (MftH264Decoder::kStopped != decoder->state()) {
     scoped_refptr<VideoFrame> frame;
     decoder->ProduceVideoFrame(frame);
   }
 
   // We expect a format change when decoder receives enough data to determine
   // the actual frame width/height.
   EXPECT_GT(handler.format_change_count_, 0);
-  EXPECT_EQ(actual_width, handler.info_.stream_info_.surface_width_);
-  EXPECT_EQ(actual_height, handler.info_.stream_info_.surface_height_);
+  EXPECT_EQ(actual_width, handler.info_.stream_info.surface_width);
+  EXPECT_EQ(actual_height, handler.info_.stream_info.surface_height);
   EXPECT_GE(handler.empty_buffer_callback_count_, num_frames);
   EXPECT_EQ(num_frames, handler.fill_buffer_callback_count_ - 1);
   decoder->Uninitialize();
 }
 
 TEST_F(MftH264DecoderTest, DecodeValidVideoDxva) {
   DecodeValidVideo("bear.1280x720.mp4", 82, true);
 }
 
 TEST_F(MftH264DecoderTest, DecodeValidVideoNoDxva) {
   DecodeValidVideo("bear.1280x720.mp4", 82, false);
 }
 
 }  // namespace media