Support external buffer import in VDA interface and add a V4L2SVDA impl.

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 366 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);
+      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 10 matching lines @@
                            reset_bitstream_buffer_id_)) {
       decode_complete_callback_->Decoded(decoded_image);
     }
   }
 }
 
 scoped_refptr<media::VideoFrame> RTCVideoDecoder::CreateVideoFrame(
     const media::Picture& picture,
     const media::PictureBuffer& pb,
     uint32_t timestamp,
-    const gfx::Rect& visible_rect) {
+    const gfx::Rect& visible_rect,
+    media::VideoPixelFormat pixel_format) {
   DCHECK(decoder_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 is actually a YUV format, but is labelled
-  // as ARGB. This prevents the compositor from messing with it, since the
-  // underlying platform can handle the former format natively. Make sure the
+  // 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.
   scoped_refptr<media::VideoFrame> frame = media::VideoFrame::WrapNativeTexture(
-      media::PIXEL_FORMAT_ARGB,
-      gpu::MailboxHolder(pb.texture_mailbox(0), gpu::SyncToken(),
-                         decoder_texture_target_),
+      pixel_format, gpu::MailboxHolder(pb.texture_mailbox(0), gpu::SyncToken(),
+                                       decoder_texture_target_),
       media::BindToCurrentLoop(base::Bind(
           &RTCVideoDecoder::ReleaseMailbox, weak_factory_.GetWeakPtr(),
           factories_, picture.picture_buffer_id(), pb.texture_ids()[0])),
       pb.size(), visible_rect, visible_rect.size(), timestamp_ms);
   if (frame && picture.allow_overlay()) {
     frame->metadata()->SetBoolean(media::VideoFrameMetadata::ALLOW_OVERLAY,
                                   true);
   }
   return frame;
 }
@@ skipping 410 matching lines @@
 
 void RTCVideoDecoder::TryResetVDAErrorCounter_Locked() {
   lock_.AssertAcquired();
 
   if (vda_error_counter_ == 0)
     return;
   vda_error_counter_ = 0;
 }
 
 }  // namespace content