Plumb decoded video pixel format from GPU process to renderer.

content/renderer/media/rtc_video_decoder.cc

 // Copyright 2013 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 "content/renderer/media/rtc_video_decoder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 48 matching lines @@
 RTCVideoDecoder::BufferData::BufferData() {}
 
 RTCVideoDecoder::BufferData::~BufferData() {}
 
 RTCVideoDecoder::RTCVideoDecoder(webrtc::VideoCodecType type,
                                  media::GpuVideoAcceleratorFactories* factories)
     : vda_error_counter_(0),
       video_codec_type_(type),
       factories_(factories),
       decoder_texture_target_(0),
+      pixel_format_(media::PIXEL_FORMAT_UNKNOWN),
       next_picture_buffer_id_(0),
       state_(UNINITIALIZED),
       decode_complete_callback_(nullptr),
       num_shm_buffers_(0),
       next_bitstream_buffer_id_(0),
       reset_bitstream_buffer_id_(ID_INVALID),
       weak_factory_(this) {
   DCHECK(!factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
@@ skipping 225 matching lines @@
     state_ = RESETTING;
     factories_->GetTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&RTCVideoDecoder::ResetInternal,
                    weak_factory_.GetWeakPtr()));
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 void RTCVideoDecoder::ProvidePictureBuffers(uint32_t count,
+                                            media::VideoPixelFormat format,
                                             uint32_t textures_per_buffer,
                                             const gfx::Size& size,
                                             uint32_t texture_target) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   DVLOG(3) << "ProvidePictureBuffers. texture_target=" << texture_target;
   DCHECK_EQ(1u, textures_per_buffer);
 
   if (!vda_)
     return;
 
@@ skipping 17 matching lines @@
     ids.push_back(texture_ids[i]);
     std::vector<gpu::Mailbox> mailboxes;
     mailboxes.push_back(texture_mailboxes[i]);
 
     picture_buffers.push_back(
         media::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);
   }
+
+  pixel_format_ = format;
+  if (pixel_format_ == media::PIXEL_FORMAT_UNKNOWN)
+    pixel_format_ = media::PIXEL_FORMAT_ARGB;

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

We should probably refuse format change in this class as well.

   vda_->AssignPictureBuffers(picture_buffers);
 }
 
 void RTCVideoDecoder::DismissPictureBuffer(int32_t id) {
   DVLOG(3) << "DismissPictureBuffer. id=" << id;
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
   std::map<int32_t, media::PictureBuffer>::iterator it =
       assigned_picture_buffers_.find(id);
   if (it == assigned_picture_buffers_.end()) {
@@ skipping 32 matching lines @@
     visible_rect = picture.visible_rect();
 
   const media::PictureBuffer& pb = it->second;
   if (visible_rect.IsEmpty() || !gfx::Rect(pb.size()).Contains(visible_rect)) {
     LOG(ERROR) << "Invalid picture size: " << visible_rect.ToString()
                << " should fit in " << pb.size().ToString();
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
 
-  media::VideoPixelFormat pixel_format = vda_->GetOutputFormat();
-  if (pixel_format == media::PIXEL_FORMAT_UNKNOWN)
-    pixel_format = media::PIXEL_FORMAT_ARGB;
-
   scoped_refptr<media::VideoFrame> frame =
-      CreateVideoFrame(picture, pb, timestamp, visible_rect, pixel_format);
+      CreateVideoFrame(picture, pb, timestamp, visible_rect, pixel_format_);
   if (!frame) {
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
   bool inserted = picture_buffers_at_display_
                       .insert(std::make_pair(picture.picture_buffer_id(),
                                              pb.texture_ids()[0]))
                       .second;
   DCHECK(inserted);
 
@@ skipping 458 matching lines @@
 
 void RTCVideoDecoder::TryResetVDAErrorCounter_Locked() {
   lock_.AssertAcquired();
 
   if (vda_error_counter_ == 0)
     return;
   vda_error_counter_ = 0;
 }
 
 }  // namespace content