Merged VideoSurface, VideoFrame and VideoFrameImpl in VideoFrame.

media/filters/video_decoder_impl.cc

 // Copyright (c) 2010 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/filters/video_decoder_impl.h"
 
 #include "base/task.h"
 #include "media/base/filters.h"
 #include "media/base/limits.h"
-#include "media/base/video_frame_impl.h"
+#include "media/base/video_frame.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/ffmpeg_interfaces.h"
 #include "media/filters/video_decode_engine.h"
 #include "media/ffmpeg/ffmpeg_util.h"
 
 namespace media {
 
 VideoDecoderImpl::VideoDecoderImpl(VideoDecodeEngine* engine)
     : width_(0),
       height_(0),
@@ skipping 167 matching lines @@
   } else {
     // When in kFlushCodec, any errored decode, or a 0-lengthed frame,
     // is taken as a signal to stop decoding.
     if (state_ == kFlushCodec) {
       state_ = kDecodeFinished;
       EnqueueEmptyFrame();
     }
   }
 }
 
-bool VideoDecoderImpl::EnqueueVideoFrame(VideoSurface::Format surface_format,
+bool VideoDecoderImpl::EnqueueVideoFrame(VideoFrame::Format surface_format,
                                          const TimeTuple& time,
                                          const AVFrame* frame) {
   // TODO(fbarchard): Work around for FFmpeg http://crbug.com/27675
   // The decoder is in a bad state and not decoding correctly.
   // Checking for NULL avoids a crash in CopyPlane().
-  if (!frame->data[VideoSurface::kYPlane] ||
-      !frame->data[VideoSurface::kUPlane] ||
-      !frame->data[VideoSurface::kVPlane]) {
+  if (!frame->data[VideoFrame::kYPlane] ||
+      !frame->data[VideoFrame::kUPlane] ||
+      !frame->data[VideoFrame::kVPlane]) {
     return true;
   }
 
   scoped_refptr<VideoFrame> video_frame;
-  VideoFrameImpl::CreateFrame(surface_format, width_, height_,
-                              time.timestamp, time.duration, &video_frame);
+  VideoFrame::CreateFrame(surface_format, width_, height_,
+                          time.timestamp, time.duration, &video_frame);
   if (!video_frame) {
     return false;
   }
 
   // Copy the frame data since FFmpeg reuses internal buffers for AVFrame
   // output, meaning the data is only valid until the next
   // avcodec_decode_video() call.
   // TODO(scherkus): figure out pre-allocation/buffer cycling scheme.
   // TODO(scherkus): is there a cleaner way to figure out the # of planes?
-  VideoSurface surface;
-  if (!video_frame->Lock(&surface)) {
-    return false;
-  }
-  CopyPlane(VideoSurface::kYPlane, surface, frame);
-  CopyPlane(VideoSurface::kUPlane, surface, frame);
-  CopyPlane(VideoSurface::kVPlane, surface, frame);
-  video_frame->Unlock();
+  CopyPlane(VideoFrame::kYPlane, *video_frame, frame);
+  CopyPlane(VideoFrame::kUPlane, *video_frame, frame);
+  CopyPlane(VideoFrame::kVPlane, *video_frame, frame);
   EnqueueResult(video_frame);
   return true;
 }
 
 void VideoDecoderImpl::CopyPlane(size_t plane,
-                                 const VideoSurface& surface,
+                                 const VideoFrame& video_frame,
                                  const AVFrame* frame) {
-  DCHECK(surface.width % 2 == 0);
+  DCHECK(video_frame.width() % 2 == 0);
   const uint8* source = frame->data[plane];
   const size_t source_stride = frame->linesize[plane];
-  uint8* dest = surface.data[plane];
-  const size_t dest_stride = surface.strides[plane];
-  size_t bytes_per_line = surface.width;
-  size_t copy_lines = surface.height;
-  if (plane != VideoSurface::kYPlane) {
+  uint8* dest = video_frame.data(plane);
+  const size_t dest_stride = video_frame.stride(plane);
+  size_t bytes_per_line = video_frame.width();
+  size_t copy_lines = video_frame.height();
+  if (plane != VideoFrame::kYPlane) {
     bytes_per_line /= 2;
-    if (surface.format == VideoSurface::YV12) {
+    if (video_frame.format() == VideoFrame::YV12) {
       copy_lines = (copy_lines + 1) / 2;
     }
   }
   DCHECK(bytes_per_line <= source_stride && bytes_per_line <= dest_stride);
   for (size_t i = 0; i < copy_lines; ++i) {
     memcpy(dest, source, bytes_per_line);
     source += source_stride;
     dest += dest_stride;
   }
 }
 
 void VideoDecoderImpl::EnqueueEmptyFrame() {
   scoped_refptr<VideoFrame> video_frame;
-  VideoFrameImpl::CreateEmptyFrame(&video_frame);
+  VideoFrame::CreateEmptyFrame(&video_frame);
   EnqueueResult(video_frame);
 }
 
 VideoDecoderImpl::TimeTuple VideoDecoderImpl::FindPtsAndDuration(
     const AVRational& time_base,
     const PtsHeap& pts_heap,
     const TimeTuple& last_pts,
     const AVFrame* frame) {
   TimeTuple pts;
 
@@ skipping 37 matching lines @@
   host()->SetError(PIPELINE_ERROR_DECODE);
   state_ = kDecodeFinished;
 }
 
 void VideoDecoderImpl::SetVideoDecodeEngineForTest(
     VideoDecodeEngine* engine) {
   decode_engine_.reset(engine);
 }
 
 }  // namespace media