Plumb decoded video pixel format from GPU process to renderer.

media/filters/gpu_video_decoder.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.
 
 #include "media/filters/gpu_video_decoder.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 59 matching lines @@
 
 GpuVideoDecoder::BufferData::~BufferData() {}
 
 GpuVideoDecoder::GpuVideoDecoder(GpuVideoAcceleratorFactories* factories,
                                  const RequestSurfaceCB& request_surface_cb)
     : needs_bitstream_conversion_(false),
       factories_(factories),
       state_(kNormal),
       request_surface_cb_(request_surface_cb),
       decoder_texture_target_(0),
+      pixel_format_(PIXEL_FORMAT_UNKNOWN),
       next_picture_buffer_id_(0),
       next_bitstream_buffer_id_(0),
       available_pictures_(0),
       needs_all_picture_buffers_to_decode_(false),
       supports_deferred_initialization_(false),
       weak_factory_(this) {
   DCHECK(factories_);
 }
 
 void GpuVideoDecoder::Reset(const base::Closure& closure)  {
@@ skipping 345 matching lines @@
          (!needs_all_picture_buffers_to_decode_ && available_pictures_ > 0) ||
          available_pictures_ ==
              static_cast<int>(assigned_picture_buffers_.size());
 }
 
 int GpuVideoDecoder::GetMaxDecodeRequests() const {
   return kMaxInFlightDecodes;
 }
 
 void GpuVideoDecoder::ProvidePictureBuffers(uint32_t count,
+                                            VideoPixelFormat format,
                                             uint32_t textures_per_buffer,
                                             const gfx::Size& size,
                                             uint32_t texture_target) {
   DVLOG(3) << "ProvidePictureBuffers(" << count << ", "
            << size.width() << "x" << size.height() << ")";
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
   std::vector<uint32_t> texture_ids;
   std::vector<gpu::Mailbox> texture_mailboxes;
   decoder_texture_target_ = texture_target;
@@ skipping 22 matching lines @@
 
     picture_buffers.push_back(
         PictureBuffer(next_picture_buffer_id_++, size, ids, mailboxes));
     bool inserted = assigned_picture_buffers_.insert(std::make_pair(
         picture_buffers.back().id(), picture_buffers.back())).second;
     DCHECK(inserted);
   }
 
   available_pictures_ += count;
 
+  pixel_format_ = format;

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

We may have more than one set of buffers with different formats if PPB() is
called more than once (that's why we do += count to available_pictures_ above).
I'm wondering if we should store format information in PictureBuffer itself...

[liberato (no reviews please), 2016/05/18 14:49:27]

+1. the renderer factory memorizes RGBA right now, i think.  would be better to
choose what the PB actually requests.

https://code.google.com/p/chromium/codesearch#chromium/src/content/renderer/m...

+
+  if (pixel_format_ == PIXEL_FORMAT_UNKNOWN) {
+    pixel_format_ =
+        IsOpaque(config_.format()) ? PIXEL_FORMAT_XRGB : PIXEL_FORMAT_ARGB;
+  }
+
   vda_->AssignPictureBuffers(picture_buffers);
 }
 
 void GpuVideoDecoder::DismissPictureBuffer(int32_t id) {
   DVLOG(3) << "DismissPictureBuffer(" << id << ")";
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
   PictureBufferMap::iterator it = assigned_picture_buffers_.find(id);
   if (it == assigned_picture_buffers_.end()) {
     NOTREACHED() << "Missing picture buffer: " << id;
@@ skipping 52 matching lines @@
     visible_rect = picture.visible_rect();
   }
   if (!gfx::Rect(pb.size()).Contains(visible_rect)) {
     LOG(WARNING) << "Visible size " << visible_rect.ToString()
                  << " is larger than coded size " << pb.size().ToString();
     visible_rect = gfx::Rect(pb.size());
   }
 
   DCHECK(decoder_texture_target_);
 
-  VideoPixelFormat pixel_format = vda_->GetOutputFormat();
-  if (pixel_format == PIXEL_FORMAT_UNKNOWN) {
-    pixel_format =
-        IsOpaque(config_.format()) ? PIXEL_FORMAT_XRGB : PIXEL_FORMAT_ARGB;
-  }
-
   gpu::MailboxHolder mailbox_holders[VideoFrame::kMaxPlanes];
   for (size_t i = 0; i < pb.texture_ids().size(); ++i) {
     mailbox_holders[i] = gpu::MailboxHolder(
         pb.texture_mailbox(i), gpu::SyncToken(), decoder_texture_target_);
   }
 
   scoped_refptr<VideoFrame> frame(VideoFrame::WrapNativeTextures(
-      pixel_format, mailbox_holders,
+      pixel_format_, mailbox_holders,
       base::Bind(&ReleaseMailboxTrampoline, factories_->GetTaskRunner(),
                  base::Bind(&GpuVideoDecoder::ReleaseMailbox,
                             weak_factory_.GetWeakPtr(), factories_,
                             picture.picture_buffer_id(), pb.texture_ids())),
       pb.size(), visible_rect, natural_size, timestamp));
   if (!frame) {
     DLOG(ERROR) << "Create frame failed for: " << picture.picture_buffer_id();
     NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
@@ skipping 205 matching lines @@
   }
   return false;
 }
 
 void GpuVideoDecoder::DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent()
     const {
   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
 }  // namespace media