EVEA cleanup: use video utility functions in media::*

content/renderer/media/rtc_video_encoder.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_encoder.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/synchronization/waitable_event.h"
 #include "content/renderer/media/renderer_gpu_video_accelerator_factories.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/video_frame.h"
+#include "media/base/video_util.h"
 #include "media/filters/gpu_video_accelerator_factories.h"
 #include "media/video/video_encode_accelerator.h"
 
 #define NOTIFY_ERROR(x)                             \
   do {                                              \
     DLOG(ERROR) << "calling NotifyError(): " << x;  \
     NotifyError(x);                                 \
   } while (0)
 
 namespace content {
@@ skipping 235 matching lines @@
            << ", output_buffer_size=" << output_buffer_size;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!video_encoder_)
     return;
 
   input_frame_coded_size_ = input_coded_size;
 
   for (unsigned int i = 0; i < input_count + kInputBufferExtraCount; ++i) {
     base::SharedMemory* shm =
-        gpu_factories_->CreateSharedMemory(input_coded_size.GetArea() * 3 / 2);
+        gpu_factories_->CreateSharedMemory(media::VideoFrame::AllocationSize(
+            media::VideoFrame::I420, input_coded_size));
     if (!shm) {
       DLOG(ERROR) << "Impl::RequireBitstreamBuffers(): "
                      "failed to create input buffer " << i;
       NOTIFY_ERROR(media::VideoEncodeAccelerator::kPlatformFailureError);
       return;
     }
     input_buffers_.push_back(shm);
     input_buffers_free_.push_back(i);
   }
 
@@ skipping 107 matching lines @@
   input_next_frame_ = NULL;
   input_next_frame_keyframe_ = false;
 
   if (!video_encoder_) {
     SignalAsyncWaiter(WEBRTC_VIDEO_CODEC_ERROR);
     return;
   }
 
   const int index = input_buffers_free_.back();
   base::SharedMemory* input_buffer = input_buffers_[index];
-
-  // Do a strided copy of the input frame to match the input requirements for
-  // the encoder.
-  // TODO(sheu): support zero-copy from WebRTC.  http://crbug.com/269312
-  const uint8_t* src = next_frame->buffer(webrtc::kYPlane);
-  uint8* dst = reinterpret_cast<uint8*>(input_buffer->memory());
-  uint8* const y_dst = dst;
-  int width = input_frame_coded_size_.width();
-  int stride = next_frame->stride(webrtc::kYPlane);
-  for (int i = 0; i < next_frame->height(); ++i) {
-    memcpy(dst, src, width);
-    src += stride;
-    dst += width;
-  }
-  src = next_frame->buffer(webrtc::kUPlane);
-  width = input_frame_coded_size_.width() / 2;
-  stride = next_frame->stride(webrtc::kUPlane);
-  for (int i = 0; i < next_frame->height() / 2; ++i) {
-    memcpy(dst, src, width);
-    src += stride;
-    dst += width;
-  }
-  src = next_frame->buffer(webrtc::kVPlane);
-  width = input_frame_coded_size_.width() / 2;
-  stride = next_frame->stride(webrtc::kVPlane);
-  for (int i = 0; i < next_frame->height() / 2; ++i) {
-    memcpy(dst, src, width);
-    src += stride;
-    dst += width;
-  }
-
   scoped_refptr<media::VideoFrame> frame =
       media::VideoFrame::WrapExternalSharedMemory(
           media::VideoFrame::I420,
           input_frame_coded_size_,
           gfx::Rect(input_visible_size_),
           input_visible_size_,
-          y_dst,
+          reinterpret_cast<uint8*>(input_buffer->memory()),
+          input_buffer->mapped_size(),
           input_buffer->handle(),
           base::TimeDelta(),
           base::Bind(&RTCVideoEncoder::Impl::EncodeFrameFinished, this, index));
+  if (!frame) {
+    DLOG(ERROR) << "Impl::EncodeOneFrame(): failed to create frame";
+    NOTIFY_ERROR(media::VideoEncodeAccelerator::kPlatformFailureError);
+    return;
+  }
+
+  // Do a strided copy of the input frame to match the input requirements for
+  // the encoder.
+  // TODO(sheu): support zero-copy from WebRTC.  http://crbug.com/269312
+  media::CopyYPlane(next_frame->buffer(webrtc::kYPlane),
+                    next_frame->stride(webrtc::kYPlane),
+                    next_frame->height(),
+                    frame.get());
+  media::CopyUPlane(next_frame->buffer(webrtc::kUPlane),
+                    next_frame->stride(webrtc::kUPlane),
+                    next_frame->height(),
+                    frame.get());
+  media::CopyVPlane(next_frame->buffer(webrtc::kVPlane),
+                    next_frame->stride(webrtc::kVPlane),
+                    next_frame->height(),
+                    frame.get());
 
   video_encoder_->Encode(frame, next_frame_keyframe);
   input_buffers_free_.pop_back();
   SignalAsyncWaiter(WEBRTC_VIDEO_CODEC_OK);
 }
 
 void RTCVideoEncoder::Impl::EncodeFrameFinished(int index) {
   DVLOG(3) << "Impl::EncodeFrameFinished(): index=" << index;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_GE(index, 0);
@@ skipping 28 matching lines @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 RTCVideoEncoder::RTCVideoEncoder(
     webrtc::VideoCodecType type,
     media::VideoCodecProfile profile,
     const scoped_refptr<RendererGpuVideoAcceleratorFactories>& gpu_factories)
     : video_codec_type_(type),
       video_codec_profile_(profile),
       gpu_factories_(gpu_factories),
+      weak_this_factory_(this),
       encoded_image_callback_(NULL),
       impl_status_(WEBRTC_VIDEO_CODEC_UNINITIALIZED) {
   DVLOG(1) << "RTCVideoEncoder(): profile=" << profile;
 }
 
 RTCVideoEncoder::~RTCVideoEncoder() {
   DCHECK(thread_checker_.CalledOnValidThread());
   Release();
   DCHECK(!impl_);
 }
 
 int32_t RTCVideoEncoder::InitEncode(const webrtc::VideoCodec* codec_settings,
                                     int32_t number_of_cores,
                                     uint32_t max_payload_size) {
   DVLOG(1) << "InitEncode(): codecType=" << codec_settings->codecType
            << ", width=" << codec_settings->width
            << ", height=" << codec_settings->height
            << ", startBitrate=" << codec_settings->startBitrate;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!impl_);
 
-  weak_this_factory_.reset(new base::WeakPtrFactory<RTCVideoEncoder>(this));
-  impl_ = new Impl(weak_this_factory_->GetWeakPtr(), gpu_factories_);
+  weak_this_factory_.InvalidateWeakPtrs();
+  impl_ = new Impl(weak_this_factory_.GetWeakPtr(), gpu_factories_);
   base::WaitableEvent initialization_waiter(true, false);
   int32_t initialization_retval = WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   gpu_factories_->GetMessageLoop()->PostTask(
       FROM_HERE,
       base::Bind(&RTCVideoEncoder::Impl::CreateAndInitializeVEA,
                  impl_,
                  gfx::Size(codec_settings->width, codec_settings->height),
                  codec_settings->startBitrate,
                  video_codec_profile_,
                  &initialization_waiter,
@@ skipping 50 matching lines @@
   DVLOG(3) << "Release()";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Reset the gpu_factory_, in case we reuse this encoder.
   gpu_factories_->Abort();
   gpu_factories_ = gpu_factories_->Clone();
   if (impl_) {
     gpu_factories_->GetMessageLoop()->PostTask(
         FROM_HERE, base::Bind(&RTCVideoEncoder::Impl::Destroy, impl_));
     impl_ = NULL;
-    weak_this_factory_.reset();
+    weak_this_factory_.InvalidateWeakPtrs();
     impl_status_ = WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t RTCVideoEncoder::SetChannelParameters(uint32_t packet_loss, int rtt) {
   DVLOG(3) << "SetChannelParameters(): packet_loss=" << packet_loss
            << ", rtt=" << rtt;
   DCHECK(thread_checker_.CalledOnValidThread());
   // Ignored.
@@ skipping 57 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "NotifyError(): error=" << error;
 
   impl_status_ = error;
   gpu_factories_->GetMessageLoop()->PostTask(
       FROM_HERE, base::Bind(&RTCVideoEncoder::Impl::Destroy, impl_));
   impl_ = NULL;
 }
 
 }  // namespace content