Add metadata to media::VideoFrame and plumb it through IPC/MediaStream.

content/renderer/pepper/pepper_media_stream_video_track_host.cc

 // Copyright 2014 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/pepper/pepper_media_stream_video_track_host.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 79 matching lines @@
                                      PP_VideoFrame_Format plugin) {
   return plugin != PP_VIDEOFRAME_FORMAT_UNKNOWN ? plugin : source;
 }
 
 void ConvertFromMediaVideoFrame(const scoped_refptr<media::VideoFrame>& src,
                                 PP_VideoFrame_Format dst_format,
                                 const gfx::Size& dst_size,
                                 uint8_t* dst) {
   CHECK(src->format() == VideoFrame::YV12 || src->format() == VideoFrame::I420);
   if (dst_format == PP_VIDEOFRAME_FORMAT_BGRA) {
-    if (src->coded_size() == dst_size) {
-      libyuv::I420ToARGB(src->data(VideoFrame::kYPlane),
+    if (src->visible_rect().size() == dst_size) {
+      libyuv::I420ToARGB(src->visible_data(VideoFrame::kYPlane),
                          src->stride(VideoFrame::kYPlane),
-                         src->data(VideoFrame::kUPlane),
+                         src->visible_data(VideoFrame::kUPlane),
                          src->stride(VideoFrame::kUPlane),
-                         src->data(VideoFrame::kVPlane),
+                         src->visible_data(VideoFrame::kVPlane),
                          src->stride(VideoFrame::kVPlane),
                          dst,
                          dst_size.width() * 4,
                          dst_size.width(),
                          dst_size.height());
     } else {
-      media::ScaleYUVToRGB32(src->data(VideoFrame::kYPlane),
-                             src->data(VideoFrame::kUPlane),
-                             src->data(VideoFrame::kVPlane),
+      media::ScaleYUVToRGB32(src->visible_data(VideoFrame::kYPlane),
+                             src->visible_data(VideoFrame::kUPlane),
+                             src->visible_data(VideoFrame::kVPlane),
                              dst,
-                             src->coded_size().width(),
-                             src->coded_size().height(),
+                             src->visible_rect().width(),
+                             src->visible_rect().height(),
                              dst_size.width(),
                              dst_size.height(),
                              src->stride(VideoFrame::kYPlane),
                              src->stride(VideoFrame::kUPlane),
                              dst_size.width() * 4,
                              media::YV12,
                              media::ROTATE_0,
                              media::FILTER_BILINEAR);
     }
   } else if (dst_format == PP_VIDEOFRAME_FORMAT_YV12 ||
              dst_format == PP_VIDEOFRAME_FORMAT_I420) {
     static const size_t kPlanesOrder[][3] = {
         {VideoFrame::kYPlane, VideoFrame::kVPlane,
          VideoFrame::kUPlane},  // YV12
         {VideoFrame::kYPlane, VideoFrame::kUPlane,
          VideoFrame::kVPlane},  // I420
     };
     const int plane_order = (dst_format == PP_VIDEOFRAME_FORMAT_YV12) ? 0 : 1;
     int dst_width = dst_size.width();
     int dst_height = dst_size.height();
-    libyuv::ScalePlane(src->data(kPlanesOrder[plane_order][0]),
+    libyuv::ScalePlane(src->visible_data(kPlanesOrder[plane_order][0]),
                        src->stride(kPlanesOrder[plane_order][0]),
-                       src->coded_size().width(),
-                       src->coded_size().height(),
+                       src->visible_rect().width(),
+                       src->visible_rect().height(),
                        dst,
                        dst_width,
                        dst_width,
                        dst_height,
                        kFilterMode);
     dst += dst_width * dst_height;
-    const int src_halfwidth = (src->coded_size().width() + 1) >> 1;
-    const int src_halfheight = (src->coded_size().height() + 1) >> 1;
+    const int src_halfwidth = (src->visible_rect().width() + 1) >> 1;
+    const int src_halfheight = (src->visible_rect().height() + 1) >> 1;
     const int dst_halfwidth = (dst_width + 1) >> 1;
     const int dst_halfheight = (dst_height + 1) >> 1;
-    libyuv::ScalePlane(src->data(kPlanesOrder[plane_order][1]),
+    libyuv::ScalePlane(src->visible_data(kPlanesOrder[plane_order][1]),
                        src->stride(kPlanesOrder[plane_order][1]),
                        src_halfwidth,
                        src_halfheight,
                        dst,
                        dst_halfwidth,
                        dst_halfwidth,
                        dst_halfheight,
                        kFilterMode);
     dst += dst_halfwidth * dst_halfheight;
-    libyuv::ScalePlane(src->data(kPlanesOrder[plane_order][2]),
+    libyuv::ScalePlane(src->visible_data(kPlanesOrder[plane_order][2]),
                        src->stride(kPlanesOrder[plane_order][2]),
                        src_halfwidth,
                        src_halfheight,
                        dst,
                        dst_halfwidth,
                        dst_halfwidth,
                        dst_halfheight,
                        kFilterMode);
   } else {
     NOTREACHED();
   }
 }
 
 }  // namespace
 
 namespace content {
 
 // Internal class used for delivering video frames on the IO-thread to
 // the MediaStreamVideoSource implementation.
 class PepperMediaStreamVideoTrackHost::FrameDeliverer
     : public base::RefCountedThreadSafe<FrameDeliverer> {
  public:
   FrameDeliverer(
       const scoped_refptr<base::MessageLoopProxy>& io_message_loop_proxy,
       const VideoCaptureDeliverFrameCB& new_frame_callback);
 
-  void DeliverVideoFrame(const scoped_refptr<media::VideoFrame>& frame,
-                         const media::VideoCaptureFormat& format);
+  void DeliverVideoFrame(const scoped_refptr<media::VideoFrame>& frame);
 
  private:
   friend class base::RefCountedThreadSafe<FrameDeliverer>;
   virtual ~FrameDeliverer();
 
-  void DeliverFrameOnIO(const scoped_refptr<media::VideoFrame>& frame,
-                        const media::VideoCaptureFormat& format);
+  void DeliverFrameOnIO(const scoped_refptr<media::VideoFrame>& frame);
 
   scoped_refptr<base::MessageLoopProxy> io_message_loop_;
   VideoCaptureDeliverFrameCB new_frame_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(FrameDeliverer);
 };
 
 PepperMediaStreamVideoTrackHost::FrameDeliverer::FrameDeliverer(
     const scoped_refptr<base::MessageLoopProxy>& io_message_loop_proxy,
     const VideoCaptureDeliverFrameCB& new_frame_callback)
     : io_message_loop_(io_message_loop_proxy),
       new_frame_callback_(new_frame_callback) {
 }
 
 PepperMediaStreamVideoTrackHost::FrameDeliverer::~FrameDeliverer() {
 }
 
 void PepperMediaStreamVideoTrackHost::FrameDeliverer::DeliverVideoFrame(
-    const scoped_refptr<media::VideoFrame>& frame,
-    const media::VideoCaptureFormat& format) {
+    const scoped_refptr<media::VideoFrame>& frame) {
   io_message_loop_->PostTask(
       FROM_HERE,
-      base::Bind(&FrameDeliverer::DeliverFrameOnIO,
-                 this, frame, format));
+      base::Bind(&FrameDeliverer::DeliverFrameOnIO, this, frame));
 }
 
 void PepperMediaStreamVideoTrackHost::FrameDeliverer::DeliverFrameOnIO(
-     const scoped_refptr<media::VideoFrame>& frame,
-     const media::VideoCaptureFormat& format) {
+     const scoped_refptr<media::VideoFrame>& frame) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   // The time when this frame is generated is unknown so give a null value to
   // |estimated_capture_time|.
-  new_frame_callback_.Run(frame, format, base::TimeTicks());
+  new_frame_callback_.Run(frame, base::TimeTicks());
 }
 
 PepperMediaStreamVideoTrackHost::PepperMediaStreamVideoTrackHost(
     RendererPpapiHost* host,
     PP_Instance instance,
     PP_Resource resource,
     const blink::WebMediaStreamTrack& track)
     : PepperMediaStreamTrackHostBase(host, instance, resource),
       track_(track),
       connected_(false),
@@ skipping 121 matching lines @@
         plugin_frame_size_,
         y_stride,
         uv_stride,
         uv_stride,
         y_data,
         u_data,
         v_data,
         base::TimeDelta::FromMilliseconds(ts_ms),
         base::Closure());
 
-    frame_deliverer_->DeliverVideoFrame(
-        frame,
-        media::VideoCaptureFormat(plugin_frame_size_,
-                                  kDefaultOutputFrameRate,
-                                  ToPixelFormat(plugin_frame_format_)));
+    frame_deliverer_->DeliverVideoFrame(frame);
   }
 
   // Makes the frame available again for plugin.
   SendEnqueueBufferMessageToPlugin(index);
   return PP_OK;
 }
 
 void PepperMediaStreamVideoTrackHost::OnVideoFrame(
     const scoped_refptr<VideoFrame>& frame,
-    const media::VideoCaptureFormat& format,
     const base::TimeTicks& estimated_capture_time) {
   DCHECK(frame.get());
   // TODO(penghuang): Check |frame->end_of_stream()| and close the track.
   PP_VideoFrame_Format ppformat = ToPpapiFormat(frame->format());
   if (ppformat == PP_VIDEOFRAME_FORMAT_UNKNOWN)
     return;
 
   if (source_frame_size_.IsEmpty()) {
-    source_frame_size_ = frame->coded_size();
+    source_frame_size_ = frame->visible_rect().size();
     source_frame_format_ = ppformat;
     InitBuffers();
   }
 
   int32_t index = buffer_manager()->DequeueBuffer();
   // Drop frames if the underlying buffer is full.
   if (index < 0) {
     DVLOG(1) << "A frame is dropped.";
     return;
   }
@@ skipping 133 matching lines @@
 }
 
 void PepperMediaStreamVideoTrackHost::OnTrackStarted(
     MediaStreamSource* source,
     MediaStreamRequestResult result,
     const blink::WebString& result_name) {
   DVLOG(3) << "OnTrackStarted result: " << result;
 }
 
 }  // namespace content