Cast: Switching recevier to use media::VideoFrame

media/cast/video_receiver/codecs/vp8/vp8_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 "media/cast/video_receiver/codecs/vp8/vp8_decoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
+#include "media/base/video_frame.h"
 #include "third_party/libvpx/source/libvpx/vpx/vp8dx.h"
+#include "ui/gfx/size.h"
 
 namespace media {
 namespace cast {
 
 Vp8Decoder::Vp8Decoder(int number_of_cores,
                        scoped_refptr<CastEnvironment> cast_environment)
     : decoder_(new vpx_dec_ctx_t()),
       cast_environment_(cast_environment) {
   InitDecode(number_of_cores);
 }
@@ skipping 30 matching lines @@
     VLOG(1) << "Failed to decode VP8 frame.";
     return false;
   }
 
   img = vpx_codec_get_frame(decoder_.get(), &iter);
   if (img == NULL) {
     VLOG(1) << "Skip rendering VP8 frame:" << frame_id_int;
     return false;
   }
 
-  scoped_ptr<I420VideoFrame> decoded_frame(new I420VideoFrame());
+  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());
 
-  // 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;
+  // Copy each plane individually (need to account for stride).
+  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());
 
-  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);
-
-  cast_environment_->Logging()->InsertFrameEvent(kVideoFrameDecoded,
-      kFrameIdUnknown, encoded_frame->frame_id);
   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;
 }
 
+void Vp8Decoder::CopyPlane(size_t plane, const uint8* source, int stride,

[scherkus (not reviewing), 2013/11/27 22:21:54]

you may want to look at VpxVideoDecoder::CopyVpxImageTo() and the Copy*Plane()
functions in media/base/video_util.{h,cc}

perhaps we can refactor / reuse some of that code instead?

I'd also highly recommend adding a TODO to eliminate the copy entirely once
fgalligan@ adds the necessary APIs to libvpx -- follow http://crbug.com/321856

[mikhal1, 2013/11/27 22:41:30]

Done.

+                           int rows, VideoFrame* frame) {
+  uint8* dest = frame->data(plane);
+  int dest_stride = frame->stride(plane);
+
+  // Clamp in case source frame has smaller stride.
+  int bytes_to_copy_per_row = std::min(frame->row_bytes(plane), stride);
+
+  // Clamp in case source frame has smaller height.
+  int rows_to_copy = std::min(frame->rows(plane), rows);
+
+  // Copy!
+  for (int row = 0; row < rows_to_copy; ++row) {
+    memcpy(dest, source, bytes_to_copy_per_row);
+    source += stride;
+    dest += dest_stride;
+  }
+}
+
 }  // namespace cast
 }  // namespace media