Refactored DecoderBuffer to use unix_hacker_style naming.

media/filters/ffmpeg_audio_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_audio_decoder.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 10 matching lines @@
 
 namespace media {
 
 // Helper structure for managing multiple decoded audio frames per packet.
 struct QueuedAudioBuffer {
   AudioDecoder::Status status;
   scoped_refptr<DataBuffer> buffer;
 };
 
 // Returns true if the decode result was end of stream.
-static inline bool IsEndOfStream(int result, int decoded_size,
+static inline bool is_end_of_stream(int result, int decoded_size,
                                  const scoped_refptr<DecoderBuffer>& input) {
   // Three conditions to meet to declare end of stream for this decoder:
   // 1. FFmpeg didn't read anything.
   // 2. FFmpeg didn't output anything.
   // 3. An end of stream buffer is received.
-  return result == 0 && decoded_size == 0 && input->IsEndOfStream();
+  return result == 0 && decoded_size == 0 && input->is_end_of_stream();
 }
 
 FFmpegAudioDecoder::FFmpegAudioDecoder(
     const scoped_refptr<base::MessageLoopProxy>& message_loop)
     : message_loop_(message_loop),
       weak_factory_(this),
       demuxer_stream_(NULL),
       codec_context_(NULL),
       bits_per_channel_(0),
       channel_layout_(CHANNEL_LAYOUT_NONE),
@@ skipping 102 matching lines @@
     DCHECK(!input.get());
     base::ResetAndReturn(&read_cb_).Run(kAborted, NULL);
     return;
   }
 
   if (status == DemuxerStream::kConfigChanged) {
     DCHECK(!input.get());
 
     // Send a "end of stream" buffer to the decode loop
     // to output any remaining data still in the decoder.
-    RunDecodeLoop(DecoderBuffer::CreateEOSBuffer(), true);
+    RunDecodeLoop(DecoderBuffer::create_eos_buffer(), true);
 
     DVLOG(1) << "Config changed.";
 
     if (!ConfigureDecoder()) {
       base::ResetAndReturn(&read_cb_).Run(kDecodeError, NULL);
       return;
     }
 
     ResetTimestampState();
 
     if (queued_audio_.empty()) {
       ReadFromDemuxerStream();
       return;
     }
 
     base::ResetAndReturn(&read_cb_).Run(
         queued_audio_.front().status, queued_audio_.front().buffer);
     queued_audio_.pop_front();
     return;
   }
 
   DCHECK_EQ(status, DemuxerStream::kOk);
   DCHECK(input.get());
 
   // Make sure we are notified if http://crbug.com/49709 returns.  Issue also
   // occurs with some damaged files.
-  if (!input->IsEndOfStream() && input->GetTimestamp() == kNoTimestamp() &&
+  if (!input->is_end_of_stream() && input->get_timestamp() == kNoTimestamp() &&
       output_timestamp_helper_->base_timestamp() == kNoTimestamp()) {
     DVLOG(1) << "Received a buffer without timestamps!";
     base::ResetAndReturn(&read_cb_).Run(kDecodeError, NULL);
     return;
   }
 
   bool is_vorbis = codec_context_->codec_id == AV_CODEC_ID_VORBIS;
-  if (!input->IsEndOfStream()) {
+  if (!input->is_end_of_stream()) {
     if (last_input_timestamp_ == kNoTimestamp()) {
-      if (is_vorbis && (input->GetTimestamp() < base::TimeDelta())) {
+      if (is_vorbis && (input->get_timestamp() < base::TimeDelta())) {
         // Dropping frames for negative timestamps as outlined in section A.2
         // in the Vorbis spec. http://xiph.org/vorbis/doc/Vorbis_I_spec.html
         int frames_to_drop = floor(
-            0.5 + -input->GetTimestamp().InSecondsF() * samples_per_second_);
+            0.5 + -input->get_timestamp().InSecondsF() * samples_per_second_);
         output_bytes_to_drop_ = bytes_per_frame_ * frames_to_drop;
       } else {
-        last_input_timestamp_ = input->GetTimestamp();
+        last_input_timestamp_ = input->get_timestamp();
       }
-    } else if (input->GetTimestamp() != kNoTimestamp()) {
-      if (input->GetTimestamp() < last_input_timestamp_) {
-        base::TimeDelta diff = input->GetTimestamp() - last_input_timestamp_;
+    } else if (input->get_timestamp() != kNoTimestamp()) {
+      if (input->get_timestamp() < last_input_timestamp_) {
+        base::TimeDelta diff = input->get_timestamp() - last_input_timestamp_;
         DVLOG(1) << "Input timestamps are not monotonically increasing! "
-                 << " ts " << input->GetTimestamp().InMicroseconds() << " us"
+                 << " ts " << input->get_timestamp().InMicroseconds() << " us"
                  << " diff " << diff.InMicroseconds() << " us";
         base::ResetAndReturn(&read_cb_).Run(kDecodeError, NULL);
         return;
       }
 
-      last_input_timestamp_ = input->GetTimestamp();
+      last_input_timestamp_ = input->get_timestamp();
     }
   }
 
   RunDecodeLoop(input, false);
 
   // We exhausted the provided packet, but it wasn't enough for a frame.  Ask
   // for more data in order to fulfill this read.
   if (queued_audio_.empty()) {
     ReadFromDemuxerStream();
     return;
@@ skipping 107 matching lines @@
   output_timestamp_helper_->SetBaseTimestamp(kNoTimestamp());
   last_input_timestamp_ = kNoTimestamp();
   output_bytes_to_drop_ = 0;
 }
 
 void FFmpegAudioDecoder::RunDecodeLoop(
     const scoped_refptr<DecoderBuffer>& input,
     bool skip_eos_append) {
   AVPacket packet;
   av_init_packet(&packet);
-  if (input->IsEndOfStream()) {
+  if (input->is_end_of_stream()) {
     packet.data = NULL;
     packet.size = 0;
   } else {
-    packet.data = const_cast<uint8*>(input->GetData());
-    packet.size = input->GetDataSize();
+    packet.data = const_cast<uint8*>(input->get_data());
+    packet.size = input->get_data_size();
   }
 
   // Each audio packet may contain several frames, so we must call the decoder
   // until we've exhausted the packet.  Regardless of the packet size we always
   // want to hand it to the decoder at least once, otherwise we would end up
   // skipping end of stream packets since they have a size of zero.
   do {
     // Reset frame to default values.
     avcodec_get_frame_defaults(av_frame_);
 
     int frame_decoded = 0;
     int result = avcodec_decode_audio4(
         codec_context_, av_frame_, &frame_decoded, &packet);
 
     if (result < 0) {
-      DCHECK(!input->IsEndOfStream())
+      DCHECK(!input->is_end_of_stream())
           << "End of stream buffer produced an error! "
           << "This is quite possibly a bug in the audio decoder not handling "
           << "end of stream AVPackets correctly.";
 
       DLOG(ERROR)
           << "Error decoding an audio frame with timestamp: "
-          << input->GetTimestamp().InMicroseconds() << " us, duration: "
-          << input->GetDuration().InMicroseconds() << " us, packet size: "
-          << input->GetDataSize() << " bytes";
+          << input->get_timestamp().InMicroseconds() << " us, duration: "
+          << input->get_duration().InMicroseconds() << " us, packet size: "
+          << input->get_data_size() << " bytes";
 
       // TODO(dalecurtis): We should return a kDecodeError here instead:
       // http://crbug.com/145276
       break;
     }
 
     // Update packet size and data pointer in case we need to call the decoder
     // with the remaining bytes from this packet.
     packet.size -= result;
     packet.data += result;
 
     if (output_timestamp_helper_->base_timestamp() == kNoTimestamp() &&
-        !input->IsEndOfStream()) {
-      DCHECK(input->GetTimestamp() != kNoTimestamp());
+        !input->is_end_of_stream()) {
+      DCHECK(input->get_timestamp() != kNoTimestamp());
       if (output_bytes_to_drop_ > 0) {
         // Currently Vorbis is the only codec that causes us to drop samples.
         // If we have to drop samples it always means the timeline starts at 0.
         DCHECK_EQ(codec_context_->codec_id, AV_CODEC_ID_VORBIS);
         output_timestamp_helper_->SetBaseTimestamp(base::TimeDelta());
       } else {
-        output_timestamp_helper_->SetBaseTimestamp(input->GetTimestamp());
+        output_timestamp_helper_->SetBaseTimestamp(input->get_timestamp());
       }
     }
 
     int decoded_audio_size = 0;
 #ifdef CHROMIUM_NO_AVFRAME_CHANNELS
     int channels = av_get_channel_layout_nb_channels(
         av_frame_->channel_layout);
 #else
     int channels = av_frame_->channels;
 #endif
@@ skipping 72 matching lines @@
             output->get_writable_data());
       } else {
         output = DataBuffer::copy_from(
             av_frame_->extended_data[0] + start_sample * bytes_per_frame_,
             decoded_audio_size);
       }
       output->set_timestamp(output_timestamp_helper_->GetTimestamp());
       output->set_duration(
           output_timestamp_helper_->GetDuration(decoded_audio_size));
       output_timestamp_helper_->AddBytes(decoded_audio_size);
-    } else if (IsEndOfStream(result, decoded_audio_size, input) &&
+    } else if (is_end_of_stream(result, decoded_audio_size, input) &&
                !skip_eos_append) {
       DCHECK_EQ(packet.size, 0);
       output = DataBuffer::create_eos_buffer();
     }
 
     if (output.get()) {
       QueuedAudioBuffer queue_entry = { kOk, output };
       queued_audio_.push_back(queue_entry);
     }
 
     // Decoding finished successfully, update statistics.
     if (result > 0) {
       PipelineStatistics statistics;
       statistics.audio_bytes_decoded = result;
       statistics_cb_.Run(statistics);
     }
   } while (packet.size > 0);
 }
 
 }  // namespace media