Add accelerated video decoder interface, VP8 and H.264 implementations and hook up to V4L2SVDA.

content/common/gpu/media/video_decode_accelerator_unittest.cc

 // Copyright (c) 2012 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/GLES2,GLX/GL} or
 //   Win/EGL.
 // - 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
@@ skipping 185 matching lines @@
   CS_RESETTING = 5,
   CS_RESET = 6,
   CS_ERROR = 7,
   CS_DESTROYED = 8,
   CS_MAX,  // Must be last entry.
 };
 
 // A helper class used to manage the lifetime of a Texture.
 class TextureRef : public base::RefCounted<TextureRef> {
  public:
-  TextureRef(const base::Closure& no_longer_needed_cb)
-      : no_longer_needed_cb_(no_longer_needed_cb) {}
+  TextureRef(uint32 texture_id, const base::Closure& no_longer_needed_cb)
+      : texture_id_(texture_id), no_longer_needed_cb_(no_longer_needed_cb) {}
+
+  int32 texture_id() const { return texture_id_; }
 
  private:
   friend class base::RefCounted<TextureRef>;
   ~TextureRef();
+
+  uint32 texture_id_;
   base::Closure no_longer_needed_cb_;
 };
 
 TextureRef::~TextureRef() {
   base::ResetAndReturn(&no_longer_needed_cb_).Run();
 }
 
 // Client that can accept callbacks from a VideoDecodeAccelerator and is used by
 // the TESTs below.
 class GLRenderingVDAClient
@@ skipping 129 matching lines @@
   // DismissPictureBuffer(). The keys in the map are the IDs of the
   // corresponding picture buffers, and the values are TextureRefs to the
   // textures.
   TextureRefMap active_textures_;
 
   // A map of the textures that are still pending in the renderer.
   // We check this to ensure all frames are rendered before entering the
   // CS_RESET_State.
   TextureRefMap pending_textures_;
 
+  int32 next_picture_buffer_id_;
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(GLRenderingVDAClient);
 };
 
 GLRenderingVDAClient::GLRenderingVDAClient(
     size_t window_id,
     RenderingHelper* rendering_helper,
     ClientStateNotification<ClientState>* note,
     const std::string& encoded_data,
     int num_in_flight_decodes,
     int num_play_throughs,
@@ skipping 20 matching lines @@
       delete_decoder_state_(delete_decoder_state),
       state_(CS_CREATED),
       num_skipped_fragments_(0),
       num_queued_fragments_(0),
       num_decoded_frames_(0),
       num_done_bitstream_buffers_(0),
       texture_target_(0),
       suppress_rendering_(suppress_rendering),
       delay_reuse_after_frame_num_(delay_reuse_after_frame_num),
       decode_calls_per_second_(decode_calls_per_second),
-      render_as_thumbnails_(render_as_thumbnails) {
+      render_as_thumbnails_(render_as_thumbnails),
+      next_picture_buffer_id_(1) {
   CHECK_GT(num_in_flight_decodes, 0);
   CHECK_GT(num_play_throughs, 0);
   // |num_in_flight_decodes_| is unsupported if |decode_calls_per_second_| > 0.
   if (decode_calls_per_second_ > 0)
     CHECK_EQ(1, num_in_flight_decodes_);
 
   // Default to H264 baseline if no profile provided.
   profile_ = (profile != media::VIDEO_CODEC_PROFILE_UNKNOWN
                   ? profile
                   : media::H264PROFILE_BASELINE);
@@ skipping 16 matching lines @@
         new DXVAVideoDecodeAccelerator(base::Bind(&DoNothingReturnTrue)));
 #endif
   return decoder.Pass();
 }
 
 scoped_ptr<media::VideoDecodeAccelerator>
 GLRenderingVDAClient::CreateV4L2VDA() {
   scoped_ptr<media::VideoDecodeAccelerator> decoder;
 #if defined(OS_CHROMEOS) && (defined(ARCH_CPU_ARMEL) || \
     (defined(USE_OZONE) && defined(USE_V4L2_CODEC)))
-  scoped_ptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
+  scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
   if (device.get()) {
     base::WeakPtr<VideoDecodeAccelerator::Client> weak_client = AsWeakPtr();
     decoder.reset(new V4L2VideoDecodeAccelerator(
         static_cast<EGLDisplay>(rendering_helper_->GetGLDisplay()),
         static_cast<EGLContext>(rendering_helper_->GetGLContextHandle()),
         weak_client,
         base::Bind(&DoNothingReturnTrue),
-        device.Pass(),
+        device,
         base::MessageLoopProxy::current()));
   }
 #endif
   return decoder.Pass();
 }
 
 scoped_ptr<media::VideoDecodeAccelerator>
 GLRenderingVDAClient::CreateVaapiVDA() {
   scoped_ptr<media::VideoDecodeAccelerator> decoder;
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
@@ skipping 41 matching lines @@
   std::vector<media::PictureBuffer> buffers;
 
   texture_target_ = texture_target;
   for (uint32 i = 0; i < requested_num_of_buffers; ++i) {
     uint32 texture_id;
     base::WaitableEvent done(false, false);
     rendering_helper_->CreateTexture(
         texture_target_, &texture_id, dimensions, &done);
     done.Wait();
 
-    // Use the texture_id as the picture's id.
-    int32 id = static_cast<int32>(texture_id);
-    CHECK(
-        active_textures_.insert(std::make_pair(
-                                    id, new TextureRef(base::Bind(
-                                            &RenderingHelper::DeleteTexture,
+    int32 picture_buffer_id = next_picture_buffer_id_++;
+    CHECK(active_textures_
+              .insert(std::make_pair(
+                  picture_buffer_id,
+                  new TextureRef(texture_id,
+                                 base::Bind(&RenderingHelper::DeleteTexture,
                                             base::Unretained(rendering_helper_),
-                                            texture_id)))).second);
+                                            texture_id))))
+              .second);
 
-    buffers.push_back(media::PictureBuffer(id, dimensions, texture_id));
+    buffers.push_back(
+        media::PictureBuffer(picture_buffer_id, dimensions, texture_id));
   }
   decoder_->AssignPictureBuffers(buffers);
 }
 
 void GLRenderingVDAClient::DismissPictureBuffer(int32 picture_buffer_id) {
   CHECK_EQ(1U, active_textures_.erase(picture_buffer_id));
 }
 
 void GLRenderingVDAClient::PictureReady(const media::Picture& picture) {
   // We shouldn't be getting pictures delivered after Reset has completed.
@@ skipping 25 matching lines @@
     // Re-start decoding from the beginning of the stream to avoid needing to
     // know how to find I-frames and so on in this test.
     encoded_data_next_pos_to_decode_ = 0;
   }
 
   TextureRefMap::iterator texture_it =
       active_textures_.find(picture.picture_buffer_id());
   ASSERT_NE(active_textures_.end(), texture_it);
 
   scoped_refptr<VideoFrameTexture> video_frame = new VideoFrameTexture(
-      texture_target_,
-      static_cast<uint32>(texture_it->first),  // the texture id
+      texture_target_, texture_it->second->texture_id(),
       base::Bind(&GLRenderingVDAClient::ReturnPicture, AsWeakPtr(),
                  picture.picture_buffer_id()));
   ASSERT_TRUE(pending_textures_.insert(*texture_it).second);
 
   if (render_as_thumbnails_) {
     rendering_helper_->RenderThumbnail(video_frame->texture_target(),
                                        video_frame->texture_id());
   } else if (!suppress_rendering_) {
     rendering_helper_->QueueVideoFrame(window_id_, video_frame);
   }
@@ skipping 939 matching lines @@
     if (it->first == "ozone-platform" || it->first == "ozone-use-surfaceless")
       continue;
     LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
   }
 
   base::ShadowingAtExitManager at_exit_manager;
   content::RenderingHelper::InitializeOneOff();
 
   return RUN_ALL_TESTS();
 }