AndroidVideoEncodeAccelerator is born!

media/base/android/media_codec_bridge_unittest.cc

 // Copyright (c) 2013 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 <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "media/base/android/media_codec_bridge.h"
@@ skipping 100 matching lines @@
 void DecodeMediaFrame(
     VideoCodecBridge* media_codec, const uint8* data, size_t data_size,
     const base::TimeDelta input_presentation_timestamp,
     const base::TimeDelta initial_timestamp_lower_bound) {
   base::TimeDelta input_pts = input_presentation_timestamp;
   base::TimeDelta timestamp = initial_timestamp_lower_bound;
   base::TimeDelta new_timestamp;
   for (int i = 0; i < 10; ++i) {
     int input_buf_index = -1;
     MediaCodecStatus status =
-        media_codec->DequeueInputBuffer(InfiniteTimeOut(), &input_buf_index);
+        media_codec->DequeueInputBuffer(InfiniteTimeOut(), &input_buf_index, 0);
     ASSERT_EQ(MEDIA_CODEC_OK, status);
 
     media_codec->QueueInputBuffer(
         input_buf_index, data, data_size, input_presentation_timestamp);
 
     size_t unused_offset = 0;
     size_t size = 0;
     bool eos = false;
     int output_buf_index = -1;
     status = media_codec->DequeueOutputBuffer(InfiniteTimeOut(),
         &output_buf_index, &unused_offset, &size, &new_timestamp, &eos);
 
     if (status == MEDIA_CODEC_OK && output_buf_index > 0)
       media_codec->ReleaseOutputBuffer(output_buf_index, false);
     // Output time stamp should not be smaller than old timestamp.
     ASSERT_TRUE(new_timestamp >= timestamp);
     input_pts += base::TimeDelta::FromMicroseconds(33000);
     timestamp = new_timestamp;
   }
 }
 
 TEST(MediaCodecBridgeTest, Initialize) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   scoped_ptr<media::MediaCodecBridge> media_codec;
-  media_codec.reset(VideoCodecBridge::Create(kCodecH264, false));
+  media_codec.reset(VideoCodecBridge::Create(kCodecH264, false, false));
 }
 
 TEST(MediaCodecBridgeTest, DoNormal) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   scoped_ptr<media::AudioCodecBridge> media_codec;
   media_codec.reset(AudioCodecBridge::Create(kCodecMP3));
 
   ASSERT_TRUE(media_codec->Start(kCodecMP3, 44100, 2, NULL, 0, false, NULL));
 
   int input_buf_index = -1;
   MediaCodecStatus status =
-      media_codec->DequeueInputBuffer(InfiniteTimeOut(), &input_buf_index);
+      media_codec->DequeueInputBuffer(InfiniteTimeOut(), &input_buf_index, 0);
   ASSERT_EQ(MEDIA_CODEC_OK, status);
   ASSERT_GE(input_buf_index, 0);
 
   int64 input_pts = kPresentationTimeBase;
-  media_codec->QueueInputBuffer(
-      input_buf_index, test_mp3, sizeof(test_mp3),
-      base::TimeDelta::FromMicroseconds(++input_pts));
+  media_codec->QueueInputBuffer(input_buf_index,
+                                test_mp3,
+                                sizeof(test_mp3),
+                                base::TimeDelta::FromMicroseconds(++input_pts),
+                                0);
 
   status = media_codec->DequeueInputBuffer(InfiniteTimeOut(), &input_buf_index);
   media_codec->QueueInputBuffer(
       input_buf_index, test_mp3, sizeof(test_mp3),
       base::TimeDelta::FromMicroseconds(++input_pts));
 
   status = media_codec->DequeueInputBuffer(InfiniteTimeOut(), &input_buf_index);
   media_codec->QueueEOS(input_buf_index);
 
   input_pts = kPresentationTimeBase;
@@ skipping 55 matching lines @@
   very_large_header[large_size - 1] = 0xfe;
   EXPECT_FALSE(media_codec->Start(
       kCodecVorbis, 44100, 2, very_large_header, 0x80000000, false, NULL));
   delete[] very_large_header;
 }
 
 TEST(MediaCodecBridgeTest, PresentationTimestampsDoNotDecrease) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   scoped_ptr<VideoCodecBridge> media_codec;
-  media_codec.reset(VideoCodecBridge::Create(kCodecVP8, false));
+  media_codec.reset(VideoCodecBridge::Create(kCodecVP8, false, false));
   EXPECT_TRUE(media_codec->Start(
       kCodecVP8, gfx::Size(320, 240), NULL, NULL));
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("vp8-I-frame-320x240");
   DecodeMediaFrame(
       media_codec.get(), buffer->data(), buffer->data_size(),
       base::TimeDelta(), base::TimeDelta());
 
   // Simulate a seek to 10 seconds, and each chunk has 2 I-frames.
   std::vector<uint8> chunk(buffer->data(),
                            buffer->data() + buffer->data_size());
   chunk.insert(chunk.end(), buffer->data(),
                buffer->data() + buffer->data_size());
   media_codec->Reset();
   DecodeMediaFrame(media_codec.get(), &chunk[0], chunk.size(),
                    base::TimeDelta::FromMicroseconds(10000000),
                    base::TimeDelta::FromMicroseconds(9900000));
 
   // Simulate a seek to 5 seconds.
   media_codec->Reset();
   DecodeMediaFrame(media_codec.get(), &chunk[0], chunk.size(),
                    base::TimeDelta::FromMicroseconds(5000000),
                    base::TimeDelta::FromMicroseconds(4900000));
 }
 
 TEST(MediaCodecBridgeTest, CreateUnsupportedCodec) {
   EXPECT_EQ(NULL, AudioCodecBridge::Create(kUnknownAudioCodec));
-  EXPECT_EQ(NULL, VideoCodecBridge::Create(kUnknownVideoCodec, false));
+  EXPECT_EQ(NULL, VideoCodecBridge::Create(kUnknownVideoCodec, false, false));
 }
 
 }  // namespace media