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;
 
   std::vector<uint32_t> texture_ids;
   std::vector<gpu::Mailbox> texture_mailboxes;
   decoder_texture_target_ = texture_target;
+
+  if (format == media::PIXEL_FORMAT_UNKNOWN)
+    format = media::PIXEL_FORMAT_ARGB;
+
+  if ((pixel_format_ != media::PIXEL_FORMAT_UNKNOWN) &&
+      (format != pixel_format_)) {
+    NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
+    return;
+  }
+
+  pixel_format_ = format;
   if (!factories_->CreateTextures(count,
                                   size,
                                   &texture_ids,
                                   &texture_mailboxes,
                                   decoder_texture_target_)) {
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
   DCHECK_EQ(count, texture_ids.size());
   DCHECK_EQ(count, texture_mailboxes.size());
@@ skipping 56 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