<video> decode in hardware!

content/common/gpu/media/omx_video_decode_accelerator_unittest.cc

 // Copyright (c) 2011 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.
 //
 // The bulk of this file is support code; sorry about that.  Here's an overview
 // to hopefully help readers of this code:
 // - RenderingHelper is charged with interacting with X11, EGL, and GLES2.
 // - ClientState is an enum for the state of the decode client used by the test.
 // - ClientStateNotification is a barrier abstraction that allows the test code
 //   to be written sequentially and wait for the decode client to see certain
@@ skipping 558 matching lines @@
 
 void EglRenderingVDAClient::CreateDecoder() {
   CHECK(decoder_deleted());
   decoder_ = new OmxVideoDecodeAccelerator(this);
   decoder_->SetEglState(egl_display(), egl_context());
   SetState(CS_DECODER_SET);
   if (decoder_deleted())
     return;
 
   // Configure the decoder.
-  media::VideoDecodeAccelerator::Profile profile =
-      media::VideoDecodeAccelerator::H264PROFILE_BASELINE;
+  media::VideoDecodeAccelerator::Profile profile = media::H264PROFILE_BASELINE;
   if (profile_ != -1)
     profile = static_cast<media::VideoDecodeAccelerator::Profile>(profile_);
   CHECK(decoder_->Initialize(profile));
 }
 
 void EglRenderingVDAClient::ProvidePictureBuffers(
     uint32 requested_num_of_buffers,
     const gfx::Size& dimensions) {
   if (decoder_deleted())
     return;
@@ skipping 205 matching lines @@
 static void AssertWaitForStateOrDeleted(ClientStateNotification* note,
                                         EglRenderingVDAClient* client,
                                         ClientState expected_state) {
   ClientState state = note->Wait();
   if (state == expected_state) return;
   ASSERT_TRUE(client->decoder_deleted())
       << "Decoder not deleted but Wait() returned " << state
       << ", instead of " << expected_state;
 }
 
-// We assert the exact number of concurrent decoders we expect to succeed and
-// that one more than that fails initialization.
-enum { kMaxSupportedNumConcurrentDecoders = 3 };
+// We assert a minimal number of concurrent decoders we expect to succeed.
+// Different platforms can support more concurrent decoders, so we don't assert
+// failure above this.
+enum { kMinSupportedNumConcurrentDecoders = 3 };
 
 // Test the most straightforward case possible: data is decoded from a single
 // chunk and rendered to the screen.
 TEST_P(OmxVideoDecodeAcceleratorTest, TestSimpleDecode) {
   // Can be useful for debugging VLOGs from OVDA.
   // logging::SetMinLogLevel(-1);
 
   // Required for Thread to work.  Not used otherwise.
   base::ShadowingAtExitManager at_exit_manager;
 
@@ skipping 63 matching lines @@
   // Then wait for all the decodes to finish.
   bool saw_init_failure = false;
   for (size_t i = 0; i < num_concurrent_decoders; ++i) {
     ClientStateNotification* note = notes[i];
     ClientState state = note->Wait();
     if (state != CS_INITIALIZED) {
       saw_init_failure = true;
       // We expect initialization to fail only when more than the supported
       // number of decoders is instantiated.  Assert here that something else
       // didn't trigger failure.
-      ASSERT_GT(num_concurrent_decoders, kMaxSupportedNumConcurrentDecoders);
+      ASSERT_GT(num_concurrent_decoders, kMinSupportedNumConcurrentDecoders);
       continue;
     }
     ASSERT_EQ(state, CS_INITIALIZED);
     // InitializeDone kicks off decoding inside the client, so we just need to
     // wait for Flush.
     ASSERT_NO_FATAL_FAILURE(
         AssertWaitForStateOrDeleted(note, clients[i], CS_FLUSHING));
     ASSERT_NO_FATAL_FAILURE(
         AssertWaitForStateOrDeleted(note, clients[i], CS_FLUSHED));
     // FlushDone requests Reset().
     ASSERT_NO_FATAL_FAILURE(
         AssertWaitForStateOrDeleted(note, clients[i], CS_RESETTING));
     ASSERT_NO_FATAL_FAILURE(
         AssertWaitForStateOrDeleted(note, clients[i], CS_RESET));
     // ResetDone requests Destroy().
     ASSERT_NO_FATAL_FAILURE(
         AssertWaitForStateOrDeleted(note, clients[i], CS_DESTROYED));
   }
-  ASSERT_EQ(saw_init_failure,
-            num_concurrent_decoders > kMaxSupportedNumConcurrentDecoders)
-      << num_concurrent_decoders;
   // Finally assert that decoding went as expected.
   for (size_t i = 0; i < num_concurrent_decoders && !saw_init_failure; ++i) {
     // We can only make performance/correctness assertions if the decoder was
     // allowed to finish.
     if (delete_decoder_state < CS_FLUSHED)
       continue;
     EglRenderingVDAClient* client = clients[i];
     if (num_frames > 0)
       EXPECT_EQ(client->num_decoded_frames(), num_frames);
     if (num_NALUs > 0 && reset_after_frame_num < 0) {
@@ skipping 66 matching lines @@
         // http://code.google.com/p/chrome-os-partner/issues/detail?id=4378 is
         // fixed.
         MakeTuple(15, 1, 1, END_OF_STREAM_RESET, CS_RESET)));
 
 // Find out how many concurrent decoders can go before we exhaust system
 // resources.
 INSTANTIATE_TEST_CASE_P(
     ResourceExhaustion, OmxVideoDecodeAcceleratorTest,
     ::testing::Values(
         // +0 hack below to promote enum to int.
-        MakeTuple(1, kMaxSupportedNumConcurrentDecoders + 0, 1,
+        MakeTuple(1, kMinSupportedNumConcurrentDecoders + 0, 1,
                   END_OF_STREAM_RESET, CS_RESET),
-        MakeTuple(1, kMaxSupportedNumConcurrentDecoders + 1, 1,
+        MakeTuple(1, kMinSupportedNumConcurrentDecoders + 1, 1,
                   END_OF_STREAM_RESET, CS_RESET)));
 
 // TODO(fischman, vrk): add more tests!  In particular:

[scherkus (not reviewing), 2011/12/06 00:27:44]

!!!!!!

[Ami GONE FROM CHROMIUM, 2011/12/07 00:03:04]

Seriously?  Have you /seen/ the amount of tests already present?

 // - Test life-cycle: Seek/Stop/Pause/Play/RePlay for a single decoder.
 // - Test alternate configurations
 // - Test failure conditions.
 // - Test frame size changes mid-stream
 
 }  // namespace
 
 int main(int argc, char **argv) {
   testing::InitGoogleTest(&argc, argv);  // Removes gtest-specific args.
   CommandLine cmd_line(argc, argv);  // Must run after InitGoogleTest.
   CommandLine::SwitchMap switches = cmd_line.GetSwitches();
   for (CommandLine::SwitchMap::const_iterator it = switches.begin();
        it != switches.end(); ++it) {
     if (it->first == "test_video_data") {
       test_video_data = it->second.c_str();
       continue;
     }
     LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
   }
 
   return RUN_ALL_TESTS();
 }