Plumb decoded video pixel format from GPU process to renderer.

media/gpu/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 404 matching lines @@
                        bool suppress_rendering,
                        int delay_reuse_after_frame_num,
                        int decode_calls_per_second,
                        bool render_as_thumbnails);
   ~GLRenderingVDAClient() override;
   void CreateAndStartDecoder();
 
   // VideoDecodeAccelerator::Client implementation.
   // The heart of the Client.
   void ProvidePictureBuffers(uint32_t requested_num_of_buffers,
+                             VideoPixelFormat format,
                              uint32_t textures_per_buffer,
                              const gfx::Size& dimensions,
                              uint32_t texture_target) override;
   void DismissPictureBuffer(int32_t picture_buffer_id) override;
   void PictureReady(const media::Picture& picture) override;
   // Simple state changes.
   void NotifyEndOfBitstreamBuffer(int32_t bitstream_buffer_id) override;
   void NotifyFlushDone() override;
   void NotifyResetDone() override;
   void NotifyError(VideoDecodeAccelerator::Error error) override;
@@ skipping 199 matching lines @@
   weak_vda_ptr_factory_.reset(
       new base::WeakPtrFactory<VideoDecodeAccelerator>(decoder_.get()));
   weak_vda_ = weak_vda_ptr_factory_->GetWeakPtr();
 
   SetState(CS_DECODER_SET);
   FinishInitialization();
 }
 
 void GLRenderingVDAClient::ProvidePictureBuffers(
     uint32_t requested_num_of_buffers,
+    VideoPixelFormat pixel_format,
     uint32_t textures_per_buffer,
     const gfx::Size& dimensions,
     uint32_t texture_target) {
   if (decoder_deleted())
     return;
   LOG_ASSERT(textures_per_buffer == 1u);
   std::vector<media::PictureBuffer> buffers;
 
   requested_num_of_buffers += kExtraPictureBuffers;

[Pawel Osciak, 2016/05/26 08:54:07]

We should refuse format change here as well.

 
   texture_target_ = texture_target;
   for (uint32_t i = 0; i < requested_num_of_buffers; ++i) {
     uint32_t texture_id;
     base::WaitableEvent done(false, false);
     rendering_helper_->CreateTexture(texture_target_, &texture_id, dimensions,
                                      &done);
     done.Wait();
 
     scoped_refptr<TextureRef> texture_ref;
     base::Closure delete_texture_cb =
         base::Bind(&RenderingHelper::DeleteTexture,
                    base::Unretained(rendering_helper_), texture_id);
 
     if (g_test_import) {
-      media::VideoPixelFormat pixel_format = decoder_->GetOutputFormat();
       if (pixel_format == media::PIXEL_FORMAT_UNKNOWN)
         pixel_format = media::PIXEL_FORMAT_ARGB;
       texture_ref = TextureRef::CreatePreallocated(
           texture_id, delete_texture_cb, pixel_format, dimensions);
     } else {
       texture_ref = TextureRef::Create(texture_id, delete_texture_cb);
     }
 
     LOG_ASSERT(texture_ref);
 
@@ skipping 1057 matching lines @@
   media::VaapiWrapper::PreSandboxInitialization();
 #endif
 
   media::g_env =
       reinterpret_cast<media::VideoDecodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new media::VideoDecodeAcceleratorTestEnvironment()));
 
   return RUN_ALL_TESTS();
 }