Plumb decoded video pixel format from GPU process to renderer.

media/video/video_decode_accelerator.h

 // 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.
 
 #ifndef MEDIA_VIDEO_VIDEO_DECODE_ACCELERATOR_H_
 #define MEDIA_VIDEO_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 143 matching lines @@
     // supported by the VDA (see Capabilities), and it is supported by the
     // client (see Config::is_deferred_initialization_allowed), and the initial
     // call to VDA::Initialize returns true.
     // The default implementation is a NOTREACHED, since deferred initialization
     // is not supported by default.
     virtual void NotifyInitializationComplete(bool success);
 
     // Callback to tell client how many and what size of buffers to provide.
     // Note that the actual count provided through AssignPictureBuffers() can be
     // larger than the value requested.
+    // If format is PIXEL_FORMAT_UNKNOWN, picture buffers can be treated as

[Pawel Osciak, 2016/05/18 07:32:32]

I'm wondering if perhaps this would reflect the current state better:

|format| indicates what format the decoded frames will be produced in by the
VDA, or PIXEL_FORMAT_UNKNOWN if the underlying platform handles this
transparently.

+    // either XRGB or ARGB.
     virtual void ProvidePictureBuffers(uint32_t requested_num_of_buffers,
+                                       VideoPixelFormat format,
                                        uint32_t textures_per_buffer,
                                        const gfx::Size& dimensions,
                                        uint32_t texture_target) = 0;
 
     // Callback to dismiss picture buffer that was assigned earlier.
     virtual void DismissPictureBuffer(int32_t picture_buffer_id) = 0;
 
     // Callback to deliver decoded pictures ready to be displayed.
     virtual void PictureReady(const Picture& picture) = 0;
 
@@ skipping 139 matching lines @@
   // to run decode operations without GL context, which helps reduce latency and
   // offloads the GPU Child thread.
   virtual bool TryToSetupDecodeOnSeparateThread(
       const base::WeakPtr<Client>& decode_client,
       const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner);
 
   // Windows creates a BGRA texture.
   // TODO(dshwang): after moving to D3D11, remove this. crbug.com/438691
   virtual GLenum GetSurfaceInternalFormat() const;
 
-  // In IMPORT OutputMode, if supported by the VDA, return the format that it
-  // requires for imported picture buffers.
-  virtual VideoPixelFormat GetOutputFormat() const;
-
  protected:
   // Do not delete directly; use Destroy() or own it with a scoped_ptr, which
   // will Destroy() it properly by default.
   virtual ~VideoDecodeAccelerator();
 };
 
 }  // namespace media
 
 namespace std {
 
 // Specialize std::default_delete so that
 // std::unique_ptr<VideoDecodeAccelerator> uses "Destroy()" instead of trying to
 // use the destructor.
 template <>
 struct MEDIA_EXPORT default_delete<media::VideoDecodeAccelerator> {
   void operator()(media::VideoDecodeAccelerator* vda) const;
 };
 
 }  // namespace std
 
 #endif  // MEDIA_VIDEO_VIDEO_DECODE_ACCELERATOR_H_