Refactored DecoderBuffer to use unix_hacker_style naming.

media/filters/ffmpeg_video_decoder.cc

 // Copyright (c) 2012 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/ffmpeg_video_decoder.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 44 matching lines @@
   return decode_threads;
 }
 
 FFmpegVideoDecoder::FFmpegVideoDecoder(
     const scoped_refptr<base::MessageLoopProxy>& message_loop)
     : message_loop_(message_loop),
       weak_factory_(this),
       state_(kUninitialized),
       codec_context_(NULL),
       av_frame_(NULL),
-      demuxer_stream_(NULL) {
-}
+      demuxer_stream_(NULL) {}
 
 int FFmpegVideoDecoder::GetVideoBuffer(AVCodecContext* codec_context,
                                        AVFrame* frame) {
   // Don't use |codec_context_| here! With threaded decoding,
   // it will contain unsynchronized width/height/pix_fmt values,
   // whereas |codec_context| contains the current threads's
   // updated width/height/pix_fmt, which can change for adaptive
   // content.
   VideoFrame::Format format = PixelFormatToVideoFormat(codec_context->pix_fmt);
-  if (format == VideoFrame::INVALID)
-    return AVERROR(EINVAL);
+  if (format == VideoFrame::INVALID) return AVERROR(EINVAL);
   DCHECK(format == VideoFrame::YV12 || format == VideoFrame::YV16);
 
   gfx::Size size(codec_context->width, codec_context->height);
   int ret;
   if ((ret = av_image_check_size(size.width(), size.height(), 0, NULL)) < 0)
     return ret;
 
   gfx::Size natural_size;
   if (codec_context->sample_aspect_ratio.num > 0) {
-    natural_size = GetNaturalSize(size,
-                                  codec_context->sample_aspect_ratio.num,
+    natural_size = GetNaturalSize(size, codec_context->sample_aspect_ratio.num,
                                   codec_context->sample_aspect_ratio.den);
   } else {
     natural_size = demuxer_stream_->video_decoder_config().natural_size();
   }
 
   if (!VideoFrame::IsValidConfig(format, size, gfx::Rect(size), natural_size))
     return AVERROR(EINVAL);
 
-  scoped_refptr<VideoFrame> video_frame =
-      VideoFrame::CreateFrame(format, size, gfx::Rect(size), natural_size,
-                              kNoTimestamp());
+  scoped_refptr<VideoFrame> video_frame = VideoFrame::CreateFrame(
+      format, size, gfx::Rect(size), natural_size, kNoTimestamp());
 
   for (int i = 0; i < 3; i++) {
     frame->base[i] = video_frame->data(i);
     frame->data[i] = video_frame->data(i);
     frame->linesize[i] = video_frame->stride(i);
   }
 
   frame->opaque = NULL;
   video_frame.swap(reinterpret_cast<VideoFrame**>(&frame->opaque));
   frame->type = FF_BUFFER_TYPE_USER;
-  frame->pkt_pts = codec_context->pkt ? codec_context->pkt->pts :
-                                        AV_NOPTS_VALUE;
+  frame->pkt_pts =
+      codec_context->pkt ? codec_context->pkt->pts : AV_NOPTS_VALUE;
   frame->width = codec_context->width;
   frame->height = codec_context->height;
   frame->format = codec_context->pix_fmt;
 
   return 0;
 }
 
 static int GetVideoBufferImpl(AVCodecContext* s, AVFrame* frame) {
   FFmpegVideoDecoder* vd = static_cast<FFmpegVideoDecoder*>(s->opaque);
   return vd->GetVideoBuffer(s, frame);
@@ skipping 54 matching lines @@
 
   ReadFromDemuxerStream();
 }
 
 void FFmpegVideoDecoder::Reset(const base::Closure& closure) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(reset_cb_.is_null());
   reset_cb_ = BindToCurrentLoop(closure);
 
   // Defer the reset if a read is pending.
-  if (!read_cb_.is_null())
-    return;
+  if (!read_cb_.is_null()) return;
 
   DoReset();
 }
 
 void FFmpegVideoDecoder::DoReset() {
   DCHECK(read_cb_.is_null());
 
   avcodec_flush_buffers(codec_context_);
   state_ = kNormal;
   base::ResetAndReturn(&reset_cb_).Run();
 }
 
 void FFmpegVideoDecoder::Stop(const base::Closure& closure) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   base::ScopedClosureRunner runner(BindToCurrentLoop(closure));
 
-  if (state_ == kUninitialized)
-    return;
+  if (state_ == kUninitialized) return;
 
-  if (!read_cb_.is_null())
-    base::ResetAndReturn(&read_cb_).Run(kOk, NULL);
+  if (!read_cb_.is_null()) base::ResetAndReturn(&read_cb_).Run(kOk, NULL);
 
   ReleaseFFmpegResources();
   state_ = kUninitialized;
 }
 
 FFmpegVideoDecoder::~FFmpegVideoDecoder() {
   DCHECK_EQ(kUninitialized, state_);
   DCHECK(!codec_context_);
   DCHECK(!av_frame_);
 }
 
 void FFmpegVideoDecoder::ReadFromDemuxerStream() {
   DCHECK_NE(state_, kUninitialized);
   DCHECK_NE(state_, kDecodeFinished);
   DCHECK_NE(state_, kError);
   DCHECK(!read_cb_.is_null());
 
-  demuxer_stream_->Read(base::Bind(
-      &FFmpegVideoDecoder::BufferReady, weak_this_));
+  demuxer_stream_->Read(
+      base::Bind(&FFmpegVideoDecoder::BufferReady, weak_this_));
 }
 
 void FFmpegVideoDecoder::BufferReady(
-    DemuxerStream::Status status,
-    const scoped_refptr<DecoderBuffer>& buffer) {
+    DemuxerStream::Status status, const scoped_refptr<DecoderBuffer>& buffer) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK_NE(state_, kDecodeFinished);
   DCHECK_NE(state_, kError);
   DCHECK_EQ(status != DemuxerStream::kOk, !buffer.get()) << status;
 
-  if (state_ == kUninitialized)
-    return;
+  if (state_ == kUninitialized) return;
 
   DCHECK(!read_cb_.is_null());
 
   if (!reset_cb_.is_null()) {
     base::ResetAndReturn(&read_cb_).Run(kOk, NULL);
     DoReset();
     return;
   }
 
   if (status == DemuxerStream::kAborted) {
@@ skipping 27 matching lines @@
   //            are discarded.
   //   kFlushCodec: There isn't any more input data. Call avcodec_decode_video2
   //                until no more data is returned to flush out remaining
   //                frames. The input buffer is ignored at this point.
   //   kDecodeFinished: All calls return empty frames.
   //   kError: Unexpected error happened.
   //
   // These are the possible state transitions.
   //
   // kNormal -> kFlushCodec:
-  //     When buffer->IsEndOfStream() is first true.
+  //     When buffer->is_end_of_stream() is first true.
   // kNormal -> kError:
   //     A decoding error occurs and decoding needs to stop.
   // kFlushCodec -> kDecodeFinished:
   //     When avcodec_decode_video2() returns 0 data.
   // kFlushCodec -> kError:
   //     When avcodec_decode_video2() errors out.
   // (any state) -> kNormal:
   //     Any time Reset() is called.
 
   // Transition to kFlushCodec on the first end of stream buffer.
-  if (state_ == kNormal && buffer->IsEndOfStream()) {
+  if (state_ == kNormal && buffer->is_end_of_stream()) {
     state_ = kFlushCodec;
   }
 
   scoped_refptr<VideoFrame> video_frame;
   if (!Decode(buffer, &video_frame)) {
     state_ = kError;
     base::ResetAndReturn(&read_cb_).Run(kDecodeError, NULL);
     return;
   }
 
   // Any successful decode counts!
-  if (!buffer->IsEndOfStream() && buffer->GetDataSize() > 0) {
+  if (!buffer->is_end_of_stream() && buffer->get_data_size() > 0) {
     PipelineStatistics statistics;
-    statistics.video_bytes_decoded = buffer->GetDataSize();
+    statistics.video_bytes_decoded = buffer->get_data_size();
     statistics_cb_.Run(statistics);
   }
 
   if (!video_frame.get()) {
     if (state_ == kFlushCodec) {
-      DCHECK(buffer->IsEndOfStream());
+      DCHECK(buffer->is_end_of_stream());
       state_ = kDecodeFinished;
       base::ResetAndReturn(&read_cb_).Run(kOk, VideoFrame::CreateEmptyFrame());
       return;
     }
 
     ReadFromDemuxerStream();
     return;
   }
 
   base::ResetAndReturn(&read_cb_).Run(kOk, video_frame);
 }
 
-bool FFmpegVideoDecoder::Decode(
-    const scoped_refptr<DecoderBuffer>& buffer,
-    scoped_refptr<VideoFrame>* video_frame) {
+bool FFmpegVideoDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
+                                scoped_refptr<VideoFrame>* video_frame) {
   DCHECK(video_frame);
 
   // Reset frame to default values.
   avcodec_get_frame_defaults(av_frame_);
 
   // Create a packet for input data.
   // Due to FFmpeg API changes we no longer have const read-only pointers.
   AVPacket packet;
   av_init_packet(&packet);
-  if (buffer->IsEndOfStream()) {
+  if (buffer->is_end_of_stream()) {
     packet.data = NULL;
     packet.size = 0;
   } else {
-    packet.data = const_cast<uint8*>(buffer->GetData());
-    packet.size = buffer->GetDataSize();
+    packet.data = const_cast<uint8*>(buffer->get_data());
+    packet.size = buffer->get_data_size();
 
     // Let FFmpeg handle presentation timestamp reordering.
-    codec_context_->reordered_opaque = buffer->GetTimestamp().InMicroseconds();
+    codec_context_->reordered_opaque = buffer->get_timestamp().InMicroseconds();
 
     // This is for codecs not using get_buffer to initialize
     // |av_frame_->reordered_opaque|
     av_frame_->reordered_opaque = codec_context_->reordered_opaque;
   }
 
   int frame_decoded = 0;
-  int result = avcodec_decode_video2(codec_context_,
-                                     av_frame_,
-                                     &frame_decoded,
-                                     &packet);
+  int result =
+      avcodec_decode_video2(codec_context_, av_frame_, &frame_decoded, &packet);
   // Log the problem if we can't decode a video frame and exit early.
   if (result < 0) {
-    LOG(ERROR) << "Error decoding video: " << buffer->AsHumanReadableString();
+    LOG(ERROR)
+        << "Error decoding video: " << buffer->as_human_readable_string();
     *video_frame = NULL;
     return false;
   }
 
   // If no frame was produced then signal that more data is required to
   // produce more frames. This can happen under two circumstances:
   //   1) Decoder was recently initialized/flushed
   //   2) End of stream was reached and all internal frames have been output
   if (frame_decoded == 0) {
     *video_frame = NULL;
@@ skipping 69 matching lines @@
   if (!codec || avcodec_open2(codec_context_, codec, NULL) < 0) {
     ReleaseFFmpegResources();
     return false;
   }
 
   av_frame_ = avcodec_alloc_frame();
   return true;
 }
 
 }  // namespace media