Add |texture_target_| and |pixel_format_| to media::PictureBuffer

content/renderer/media/gpu/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/gpu/rtc_video_decoder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 50 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 228 matching lines @@
                                             const gfx::Size& size,
                                             uint32_t texture_target) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   DVLOG(3) << "ProvidePictureBuffers. texture_target=" << texture_target;
 
   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_)) {
+  const uint32_t texture_count = buffer_count * textures_per_buffer;
+  if (!factories_->CreateTextures(texture_count, size, &texture_ids,
+                                  &texture_mailboxes, texture_target)) {
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
-
-  pixel_format_ = format;
-  const uint32_t texture_count = buffer_count * textures_per_buffer;
-  if (!factories_->CreateTextures(texture_count, size, &texture_ids,
-                                  &texture_mailboxes,
-                                  decoder_texture_target_)) {
-    NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
-    return;
-  }
   DCHECK_EQ(texture_count, texture_ids.size());
   DCHECK_EQ(texture_count, texture_mailboxes.size());
 
   std::vector<media::PictureBuffer> picture_buffers;
   for (size_t buffer_index = 0; buffer_index < buffer_count; ++buffer_index) {
     media::PictureBuffer::TextureIds ids;
     std::vector<gpu::Mailbox> mailboxes;
     for (size_t texture_index = 0; texture_index < textures_per_buffer;
          ++texture_index) {
       const size_t texture_id =
           texture_index + textures_per_buffer * buffer_index;
       ids.push_back(texture_ids[texture_id]);
       mailboxes.push_back(texture_mailboxes[texture_id]);
     }
 
-    picture_buffers.push_back(
-        media::PictureBuffer(next_picture_buffer_id_++, size, ids, mailboxes));
+    picture_buffers.push_back(media::PictureBuffer(next_picture_buffer_id_++,
+                                                   size, ids, mailboxes,
+                                                   texture_target, format));
     const bool inserted =
         assigned_picture_buffers_
             .insert(std::make_pair(picture_buffers.back().id(),
                                    picture_buffers.back()))
             .second;
     DCHECK(inserted);
   }
   vda_->AssignPictureBuffers(picture_buffers);
 }
 
@@ skipping 41 matching lines @@
 
   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;
   }
 
   scoped_refptr<media::VideoFrame> frame =
-      CreateVideoFrame(picture, pb, timestamp, visible_rect, pixel_format_);
+      CreateVideoFrame(picture, pb, timestamp, visible_rect, pb.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.client_texture_ids()))
                       .second;
   DCHECK(inserted);
 
@@ skipping 15 matching lines @@
     vda_error_counter_ = 0;
   }
 }
 
 scoped_refptr<media::VideoFrame> RTCVideoDecoder::CreateVideoFrame(
     const media::Picture& picture,
     const media::PictureBuffer& pb,
     uint32_t timestamp,
     const gfx::Rect& visible_rect,
     media::VideoPixelFormat pixel_format) {
-  DCHECK(decoder_texture_target_);
+  DCHECK(pb.texture_target());
   // Convert timestamp from 90KHz to ms.
   base::TimeDelta timestamp_ms = base::TimeDelta::FromInternalValue(
       base::checked_cast<uint64_t>(timestamp) * 1000 / 90);
   // TODO(mcasas): The incoming data may actually be in a YUV format, but may be
   // labelled as ARGB. This may or may not be reported by VDA, depending on
   // whether it provides an implementation of VDA::GetOutputFormat().
   // This prevents the compositor from messing with it, since the underlying
   // platform can handle the former format natively. Make sure the
   // correct format is used and everyone down the line understands it.
   gpu::MailboxHolder holders[media::VideoFrame::kMaxPlanes];
   for (size_t i = 0; i < pb.client_texture_ids().size(); ++i) {
     holders[i].mailbox = pb.texture_mailbox(i);
-    holders[i].texture_target = decoder_texture_target_;
+    holders[i].texture_target = pb.texture_target();
   }
   scoped_refptr<media::VideoFrame> frame =
       media::VideoFrame::WrapNativeTextures(
           pixel_format, holders,
           media::BindToCurrentLoop(
               base::Bind(&RTCVideoDecoder::ReleaseMailbox,
                          weak_factory_.GetWeakPtr(), factories_,
                          picture.picture_buffer_id(), pb.client_texture_ids())),
           pb.size(), visible_rect, visible_rect.size(), timestamp_ms);
   if (frame && picture.allow_overlay()) {
@@ skipping 425 matching lines @@
 }
 
 void RTCVideoDecoder::ClearPendingBuffers() {
   // Delete WebRTC input buffers.
   for (const auto& pending_buffer : pending_buffers_)
     delete[] pending_buffer.first._buffer;
   pending_buffers_.clear();
 }
 
 }  // namespace content