Cast: Switching recevier to use media::VideoFrame

This is a follow up on a previous cl that switched Cast sender to use VideoFrame.

Review URL: https://codereview.chromium.org/82593005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@238536 0039d316-1c4b-4281-b951-d872f2087c98

media/cast/DEPS

 include_rules = [
    "+crypto",
+   "+media",
    "+net",
   "+third_party/webrtc",
   "+third_party/libyuv",

media/cast/cast.gyp

@@ -107,10 +107,11 @@
             '<(DEPTH)/',
           ],
           'dependencies': [
+            'cast_config',
             '<(DEPTH)/ui/gfx/gfx.gyp:gfx',
             '<(DEPTH)/net/net.gyp:net_test_support',
-            'cast_config',
             '<(DEPTH)/media/cast/cast_sender.gyp:*',
+            '<(DEPTH)/media/media.gyp:media',
             '<(DEPTH)/testing/gtest.gyp:gtest',
             '<(DEPTH)/third_party/opus/opus.gyp:opus',
             '<(DEPTH)/media/cast/test/transport/transport.gyp:cast_transport',
@@ -127,10 +128,11 @@
             '<(DEPTH)/',
           ],
           'dependencies': [
+            'cast_config',
             '<(DEPTH)/ui/gfx/gfx.gyp:gfx',
             '<(DEPTH)/net/net.gyp:net_test_support',
-            'cast_config',
             '<(DEPTH)/media/cast/cast_receiver.gyp:*',
+            '<(DEPTH)/media/media.gyp:media',
             '<(DEPTH)/testing/gtest.gyp:gtest',
             '<(DEPTH)/media/cast/test/transport/transport.gyp:cast_transport',
             '<(DEPTH)/media/cast/test/utility/utility.gyp:cast_test_utility',

media/cast/cast_config.h

@@ -140,24 +140,6 @@ struct VideoReceiverConfig {
   std::string aes_iv_mask;  // Binary string of size kAesKeySize.
 };
 
-// DEPRECATED: Do not use in new code.  Please migrate existing code to use
-// media::VideoFrame.
-struct I420VideoPlane {
-  int stride;
-  int length;
-  uint8* data;
-};
-
-// DEPRECATED: Do not use in new code.  Please migrate existing code to use
-// media::VideoFrame.
-struct I420VideoFrame {
-  int width;
-  int height;
-  I420VideoPlane y_plane;
-  I420VideoPlane u_plane;
-  I420VideoPlane v_plane;
-};
-
 struct EncodedVideoFrame {
   EncodedVideoFrame();
   ~EncodedVideoFrame();

media/cast/cast_receiver.h

@@ -16,6 +16,10 @@
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 
+namespace media {
+class VideoFrame;
+}
+
 namespace media {
 namespace cast {
 // Callback in which the raw audio frame and play-out time will be returned
@@ -29,7 +33,8 @@ typedef base::Callback<void(scoped_ptr<EncodedAudioFrame>,
 
 // Callback in which the raw frame and render time will be returned once
 // decoding is complete.
-typedef base::Callback<void(scoped_ptr<I420VideoFrame>, const base::TimeTicks&)>
+typedef base::Callback<void(const scoped_refptr<media::VideoFrame>& video_frame,
+                            const base::TimeTicks&)>
     VideoFrameDecodedCallback;
 
 // Callback in which the encoded video frame and render time will be returned.

media/cast/test/encode_decode_test.cc

@@ -43,14 +43,16 @@ class EncodeDecodeTestFrameCallback :
     PopulateVideoFrame(original_frame_.get(), start_value);
   }
 
-  void DecodeComplete(scoped_ptr<I420VideoFrame> decoded_frame,
+  void DecodeComplete(const scoped_refptr<media::VideoFrame>& decoded_frame,
                       const base::TimeTicks& render_time) {
     ++num_called_;
     // Compare resolution.
-    EXPECT_EQ(original_frame_->coded_size().width(), decoded_frame->width);
-    EXPECT_EQ(original_frame_->coded_size().height(), decoded_frame->height);
+    EXPECT_EQ(original_frame_->coded_size().width(),
+              decoded_frame->coded_size().width());
+    EXPECT_EQ(original_frame_->coded_size().height(),
+              decoded_frame->coded_size().height());
     // Compare data.
-    EXPECT_GT(I420PSNR(*(original_frame_.get()), *(decoded_frame.get())), 40.0);
+    EXPECT_GT(I420PSNR(original_frame_, decoded_frame), 40.0);
   }
 
   int num_called() const {

media/cast/test/end2end_unittest.cc

@@ -273,7 +273,7 @@ class TestReceiverVideoCallback :
     expected_frame_.push_back(expected_video_frame);
   }
 
-  void CheckVideoFrame(scoped_ptr<I420VideoFrame> video_frame,
+  void CheckVideoFrame(const scoped_refptr<media::VideoFrame>& video_frame,
                        const base::TimeTicks& render_time) {
     ++num_called_;
 
@@ -290,8 +290,8 @@ class TestReceiverVideoCallback :
         << "time_since_capture - upper_bound == "
         << (time_since_capture - upper_bound).InMicroseconds() << " usec";
     EXPECT_LE(expected_video_frame.capture_time, render_time);
-    EXPECT_EQ(expected_video_frame.width, video_frame->width);
-    EXPECT_EQ(expected_video_frame.height, video_frame->height);
+    EXPECT_EQ(expected_video_frame.width, video_frame->coded_size().width());
+    EXPECT_EQ(expected_video_frame.height, video_frame->coded_size().height());
 
     gfx::Size size(expected_video_frame.width, expected_video_frame.height);
     scoped_refptr<media::VideoFrame> expected_I420_frame =
@@ -299,8 +299,7 @@ class TestReceiverVideoCallback :
         VideoFrame::I420, size, gfx::Rect(size), size, base::TimeDelta());
     PopulateVideoFrame(expected_I420_frame, expected_video_frame.start_value);
 
-    double psnr = I420PSNR(*(expected_I420_frame.get()), *(video_frame.get()));
-    EXPECT_GE(psnr, kVideoAcceptedPSNR);
+    EXPECT_GE(I420PSNR(expected_I420_frame, video_frame), kVideoAcceptedPSNR);
   }
 
   int number_times_called() { return num_called_;}

media/cast/test/linux_output_window.cc

@@ -5,7 +5,9 @@
 #include "media/cast/test/linux_output_window.h"
 
 #include "base/logging.h"
+#include "media/base/video_frame.h"
 #include "third_party/libyuv/include/libyuv/convert.h"
+#include "ui/gfx/size.h"
 
 namespace media {
 namespace cast {
@@ -108,22 +110,23 @@ void LinuxOutputWindow::CreateWindow(int x_pos,
   XSync(display_, false);
 }
 
-void LinuxOutputWindow::RenderFrame(const I420VideoFrame& video_frame) {
-  libyuv::I420ToARGB(video_frame.y_plane.data,
-                     video_frame.y_plane.stride,
-                     video_frame.u_plane.data,
-                     video_frame.u_plane.stride,
-                     video_frame.v_plane.data,
-                     video_frame.v_plane.stride,
+void LinuxOutputWindow::RenderFrame(
+    const scoped_refptr<media::VideoFrame>& video_frame) {
+  libyuv::I420ToARGB(video_frame->data(VideoFrame::kYPlane),
+                     video_frame->stride(VideoFrame::kYPlane),
+                     video_frame->data(VideoFrame::kUPlane),
+                     video_frame->stride(VideoFrame::kUPlane),
+                     video_frame->data(VideoFrame::kVPlane),
+                     video_frame->stride(VideoFrame::kVPlane),
                      render_buffer_,
-                     video_frame.width * 4,  // Stride.
-                     video_frame.width,
-                     video_frame.height);
+                     video_frame->coded_size().width() * 4,  // Stride.
+                     video_frame->coded_size().width(),
+                     video_frame->coded_size().height());
 
   // Place image in window.
   XShmPutImage(display_, window_, gc_, image_, 0, 0, 0, 0,
-               video_frame.width,
-               video_frame.height, true);
+               video_frame->coded_size().width(),
+               video_frame->coded_size().height(), true);
 
   // Very important for the image to update properly!
   XSync(display_, false);

media/cast/test/linux_output_window.h

@@ -11,7 +11,15 @@
 #include <sys/shm.h>
 #include <X11/extensions/XShm.h>
 
-#include "media/cast/cast_config.h"
+#include <string>
+
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+
+namespace media {
+class VideoFrame;
+}
+
 
 namespace media {
 namespace cast {
@@ -26,7 +34,7 @@ class LinuxOutputWindow {
                     const std::string& name);
   virtual ~LinuxOutputWindow();
 
-  void RenderFrame(const I420VideoFrame& video_frame);
+  void RenderFrame(const scoped_refptr<media::VideoFrame>& video_frame);
 
  private:
   void CreateWindow(int x_pos,

media/cast/test/receiver.cc

@@ -15,6 +15,7 @@
 #include "base/message_loop/message_loop.h"
 #include "base/threading/thread.h"
 #include "base/time/default_tick_clock.h"
+#include "media/base/video_frame.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/cast_receiver.h"
@@ -157,10 +158,10 @@ class ReceiveProcess : public base::RefCountedThreadSafe<ReceiveProcess> {
  private:
   friend class base::RefCountedThreadSafe<ReceiveProcess>;
 
-  void DisplayFrame(scoped_ptr<I420VideoFrame> frame,
+  void DisplayFrame(const scoped_refptr<media::VideoFrame>& video_frame,
       const base::TimeTicks& render_time) {
 #ifdef OS_LINUX
-    render_.RenderFrame(*frame);
+    render_.RenderFrame(video_frame);
 #endif // OS_LINUX
     // Print out the delta between frames.
     if (!last_render_time_.is_null()){

media/cast/test/transport/transport.cc

@@ -10,8 +10,8 @@
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
-#include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/rand_callback.h"
 #include "net/base/test_completion_callback.h"
@@ -35,7 +35,7 @@ void CreateUDPAddress(std::string ip_str, int port, net::IPEndPoint* address) {
 class LocalUdpTransportData
     : public base::RefCountedThreadSafe<LocalUdpTransportData> {
  public:
-  LocalUdpTransportData(net::DatagramServerSocket* udp_socket,
+  LocalUdpTransportData(net::UDPServerSocket* udp_socket,
                         scoped_refptr<base::TaskRunner> io_thread_proxy)
     : udp_socket_(udp_socket),
       buffer_(new net::IOBufferWithSize(kMaxPacketSize)),
@@ -93,7 +93,7 @@ class LocalUdpTransportData
  private:
   friend class base::RefCountedThreadSafe<LocalUdpTransportData>;
 
-  net::DatagramServerSocket* udp_socket_;
+  net::UDPServerSocket* udp_socket_;
   net::IPEndPoint bind_address_;
   PacketReceiver* packet_receiver_;
   scoped_refptr<net::IOBufferWithSize> buffer_;
@@ -105,7 +105,7 @@ class LocalUdpTransportData
 class LocalPacketSender : public PacketSender,
                           public base::RefCountedThreadSafe<LocalPacketSender> {
  public:
-  LocalPacketSender(net::DatagramServerSocket* udp_socket,
+  LocalPacketSender(net::UDPServerSocket* udp_socket,
                     scoped_refptr<base::TaskRunner> io_thread_proxy)
       : udp_socket_(udp_socket),
         send_address_(),
@@ -162,7 +162,7 @@ class LocalPacketSender : public PacketSender,
  private:
   friend class base::RefCountedThreadSafe<LocalPacketSender>;
 
-  net::DatagramServerSocket* udp_socket_;  // Not owned by this class.
+  net::UDPServerSocket* udp_socket_;  // Not owned by this class.
   net::IPEndPoint send_address_;
   int loss_limit_;
   scoped_refptr<base::TaskRunner> io_thread_proxy_;

media/cast/test/transport/transport.h

@@ -9,7 +9,6 @@
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 #include "net/udp/udp_server_socket.h"
-#include "net/udp/udp_socket.h"
 
 
 namespace media {
@@ -42,7 +41,7 @@ class Transport {
   void StopReceiving();
 
  private:
-  scoped_ptr<net::DatagramServerSocket> udp_socket_;
+  scoped_ptr<net::UDPServerSocket> udp_socket_;
   scoped_refptr<LocalPacketSender> packet_sender_;
   scoped_refptr<LocalUdpTransportData> local_udp_transport_data_;
   scoped_refptr<base::TaskRunner> io_thread_proxy_;

media/cast/test/video_utility.cc

@@ -5,7 +5,6 @@
 #include <math.h>
 #include <cstdio>
 
-#include "media/base/video_frame.h"
 #include "media/cast/test/video_utility.h"
 #include "third_party/libyuv/include/libyuv/compare.h"
 #include "ui/gfx/size.h"
@@ -13,30 +12,19 @@
 namespace media {
 namespace cast {
 
-double I420PSNR(const I420VideoFrame& frame1, const I420VideoFrame& frame2) {
-  // Frames should have equal resolution.
-  if (frame1.width != frame2.width || frame1.height != frame2.height) return -1;
-  return libyuv::I420Psnr(frame1.y_plane.data, frame1.y_plane.stride,
-                          frame1.u_plane.data, frame1.u_plane.stride,
-                          frame1.v_plane.data, frame1.v_plane.stride,
-                          frame2.y_plane.data, frame2.y_plane.stride,
-                          frame2.u_plane.data, frame2.u_plane.stride,
-                          frame2.v_plane.data, frame2.v_plane.stride,
-                          frame1.width, frame1.height);
-}
-
-double I420PSNR(const VideoFrame& frame1, const I420VideoFrame& frame2) {
-  if (frame1.coded_size().width() != frame2.width ||
-      frame1.coded_size().height() != frame2.height) return -1;
+double I420PSNR(const scoped_refptr<media::VideoFrame>& frame1,
+                const scoped_refptr<media::VideoFrame>& frame2) {
+  if (frame1->coded_size().width() != frame2->coded_size().width() ||
+      frame1->coded_size().height() != frame2->coded_size().height()) return -1;
 
   return libyuv::I420Psnr(
-      frame1.data(VideoFrame::kYPlane), frame1.stride(VideoFrame::kYPlane),
-      frame1.data(VideoFrame::kUPlane), frame1.stride(VideoFrame::kUPlane),
-      frame1.data(VideoFrame::kVPlane), frame1.stride(VideoFrame::kVPlane),
-      frame2.y_plane.data, frame2.y_plane.stride,
-      frame2.u_plane.data, frame2.u_plane.stride,
-      frame2.v_plane.data, frame2.v_plane.stride,
-      frame2.width, frame2.height);
+      frame1->data(VideoFrame::kYPlane), frame1->stride(VideoFrame::kYPlane),
+      frame1->data(VideoFrame::kUPlane), frame1->stride(VideoFrame::kUPlane),
+      frame1->data(VideoFrame::kVPlane), frame1->stride(VideoFrame::kVPlane),
+      frame2->data(VideoFrame::kYPlane), frame2->stride(VideoFrame::kYPlane),
+      frame2->data(VideoFrame::kUPlane), frame2->stride(VideoFrame::kUPlane),
+      frame2->data(VideoFrame::kVPlane), frame2->stride(VideoFrame::kVPlane),
+      frame1->coded_size().width(), frame1->coded_size().height());
 }
 
 void PopulateVideoFrame(VideoFrame* frame, int start_value) {
@@ -64,37 +52,6 @@ void PopulateVideoFrame(VideoFrame* frame, int start_value) {
   }
 }
 
-void PopulateVideoFrame(I420VideoFrame* frame, int start_value) {
-  int half_width = (frame->width + 1) / 2;
-  int half_height = (frame->height + 1) / 2;
-  frame->y_plane.stride = frame->width;
-  frame->y_plane.length = frame->width * frame->height;
-  frame->y_plane.data = new uint8[frame->y_plane.length];
-
-  frame->u_plane.stride = half_width;
-  frame->u_plane.length = half_width * half_height;
-  frame->u_plane.data = new uint8[frame->u_plane.length];
-
-  frame->v_plane.stride = half_width;
-  frame->v_plane.length = half_width * half_height;
-  frame->v_plane.data = new uint8[frame->v_plane.length];
-
-  // Set Y.
-  for (int i = 0; i < frame->y_plane.length; ++i) {
-    frame->y_plane.data[i] = static_cast<uint8>(start_value + i);
-  }
-
-  // Set U.
-  for (int i = 0; i < frame->u_plane.length; ++i) {
-    frame->u_plane.data[i] = static_cast<uint8>(start_value + i);
-  }
-
-  // Set V.
-  for (int i = 0; i < frame->v_plane.length; ++i) {
-    frame->v_plane.data[i] = static_cast<uint8>(start_value + i);
-  }
-}
-
 bool PopulateVideoFrameFromFile(VideoFrame* frame, FILE* video_file) {
   int width = frame->coded_size().width();
   int height = frame->coded_size().height();

media/cast/test/video_utility.h

@@ -5,23 +5,18 @@
 // Utility functions for video testing.
 
 #include "media/base/video_frame.h"
-#include "media/cast/cast_config.h"
 
 namespace media {
 namespace cast {
 
 // Compute and return PSNR between two frames.
-double I420PSNR(const I420VideoFrame& frame1, const I420VideoFrame& frame2);
-
-// Temporary function to handle the transition
-// from I420VideoFrame->media::VideoFrame.
-double I420PSNR(const VideoFrame& frame1, const I420VideoFrame& frame2);
+double I420PSNR(const scoped_refptr<media::VideoFrame>& frame1,
+                const scoped_refptr<media::VideoFrame>& frame2);
 
 // Populate a video frame with values starting with the given start value.
 // Width, height and stride should be set in advance.
 // Memory is allocated within the function.
 void PopulateVideoFrame(VideoFrame* frame, int start_value);
-void PopulateVideoFrame(I420VideoFrame* frame, int start_value);
 
 // Populate a video frame from a file.
 // Returns true if frame was populated, false if not (EOF).

media/cast/video_receiver/codecs/vp8/vp8_decoder.cc

@@ -7,7 +7,10 @@
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
+#include "media/base/video_frame.h"
+#include "media/base/video_util.h"
 #include "third_party/libvpx/source/libvpx/vpx/vp8dx.h"
+#include "ui/gfx/size.h"
 
 namespace media {
 namespace cast {
@@ -68,31 +71,23 @@ bool Vp8Decoder::Decode(const EncodedVideoFrame* encoded_frame,
     return false;
   }
 
-  scoped_ptr<I420VideoFrame> decoded_frame(new I420VideoFrame());
-
-  // The img is only valid until the next call to vpx_codec_decode.
-  // Populate the decoded image.
-  decoded_frame->width = img->d_w;
-  decoded_frame->height = img->d_h;
-
-  decoded_frame->y_plane.stride = img->stride[VPX_PLANE_Y];
-  decoded_frame->y_plane.length = img->stride[VPX_PLANE_Y] * img->d_h;
-  decoded_frame->y_plane.data = new uint8[decoded_frame->y_plane.length];
-  memcpy(decoded_frame->y_plane.data, img->planes[VPX_PLANE_Y],
-         decoded_frame->y_plane.length);
-
-  decoded_frame->u_plane.stride = img->stride[VPX_PLANE_U];
-  decoded_frame->u_plane.length = img->stride[VPX_PLANE_U] * (img->d_h + 1) / 2;
-  decoded_frame->u_plane.data = new uint8[decoded_frame->u_plane.length];
-  memcpy(decoded_frame->u_plane.data, img->planes[VPX_PLANE_U],
-         decoded_frame->u_plane.length);
-
-  decoded_frame->v_plane.stride = img->stride[VPX_PLANE_V];
-  decoded_frame->v_plane.length = img->stride[VPX_PLANE_V] * (img->d_h + 1) / 2;
-  decoded_frame->v_plane.data = new uint8[decoded_frame->v_plane.length];
-
-  memcpy(decoded_frame->v_plane.data, img->planes[VPX_PLANE_V],
-         decoded_frame->v_plane.length);
+  gfx::Size visible_size(img->d_w, img->d_h);
+  gfx::Size full_size(img->stride[VPX_PLANE_Y], img->d_h);
+  DCHECK(VideoFrame::IsValidConfig(VideoFrame::I420, visible_size,
+                                   gfx::Rect(visible_size), full_size));
+  // Temp timing setting - will sort out timing in a follow up cl.
+  scoped_refptr<VideoFrame> decoded_frame =
+      VideoFrame::CreateFrame(VideoFrame::I420, visible_size,
+      gfx::Rect(visible_size), full_size, base::TimeDelta());
+
+  // Copy each plane individually (need to account for stride).
+  // TODO(mikhal): Eliminate copy once http://crbug.com/321856 is resolved.
+  CopyPlane(VideoFrame::kYPlane, img->planes[VPX_PLANE_Y],
+            img->stride[VPX_PLANE_Y], img->d_h, decoded_frame.get());
+  CopyPlane(VideoFrame::kUPlane, img->planes[VPX_PLANE_U],
+            img->stride[VPX_PLANE_U], (img->d_h + 1) / 2, decoded_frame.get());
+  CopyPlane(VideoFrame::kVPlane, img->planes[VPX_PLANE_V],
+            img->stride[VPX_PLANE_V], (img->d_h + 1) / 2, decoded_frame.get());
 
   // Log:: Decoding complete (should be called from the main thread).
   cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE, base::Bind(
@@ -101,8 +96,7 @@ bool Vp8Decoder::Decode(const EncodedVideoFrame* encoded_frame,
   VLOG(1) << "Decoded frame " << frame_id_int;
   // Frame decoded - return frame to the user via callback.
   cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
-      base::Bind(frame_decoded_cb, base::Passed(&decoded_frame),
-                 render_time));
+      base::Bind(frame_decoded_cb, decoded_frame, render_time));
 
   return true;
 }

media/cast/video_receiver/codecs/vp8/vp8_decoder.h

@@ -14,6 +14,7 @@
 
 typedef struct vpx_codec_ctx vpx_dec_ctx_t;
 
+// TODO(mikhal): Look into reusing VpxVideoDecoder.
 namespace media {
 namespace cast {
 

media/cast/video_receiver/video_decoder.h

@@ -14,6 +14,7 @@ namespace media {
 namespace cast {
 
 class Vp8Decoder;
+class VideoFrame;
 
 // This class is not thread safe; it's only called from the cast video decoder
 // thread.

media/cast/video_receiver/video_decoder_unittest.cc

@@ -29,7 +29,7 @@ class DecodeTestFrameCallback :
  public:
   DecodeTestFrameCallback() {}
 
-  void DecodeComplete(scoped_ptr<I420VideoFrame> decoded_frame,
+  void DecodeComplete(const scoped_refptr<media::VideoFrame>& decoded_frame,
                       const base::TimeTicks& render_time) {}
  protected:
   virtual ~DecodeTestFrameCallback() {}

media/cast/video_receiver/video_receiver_unittest.cc

@@ -30,8 +30,8 @@ class TestVideoReceiverCallback :
       : num_called_(0) {}
 
   // TODO(mikhal): Set and check expectations.
-  void DecodeComplete(scoped_ptr<I420VideoFrame> video_frame,
-      const base::TimeTicks& render_time) {
+  void DecodeComplete(const scoped_refptr<media::VideoFrame>& video_frame,
+                      const base::TimeTicks& render_time) {
     ++num_called_;
   }