Define AudioBuffer and VideoFrame for mojo

media/base/audio_buffer.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/base/audio_buffer.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "media/base/audio_bus.h"
@@ skipping 19 matching lines @@
     : sample_format_(sample_format),
       channel_layout_(channel_layout),
       channel_count_(channel_count),
       sample_rate_(sample_rate),
       adjusted_frame_count_(frame_count),
       trim_start_(0),
       end_of_stream_(!create_buffer && data == NULL && frame_count == 0),
       timestamp_(timestamp),
       duration_(end_of_stream_
                     ? base::TimeDelta()
-                    : CalculateDuration(adjusted_frame_count_, sample_rate_)) {
+                    : CalculateDuration(adjusted_frame_count_, sample_rate_)),
+      data_size_(0) {
   CHECK_GE(channel_count_, 0);
   CHECK_LE(channel_count_, limits::kMaxChannels);
   CHECK_GE(frame_count, 0);
   DCHECK(channel_layout == CHANNEL_LAYOUT_DISCRETE ||
          ChannelLayoutToChannelCount(channel_layout) == channel_count);
 
   int bytes_per_channel = SampleFormatToBytesPerChannel(sample_format);
   DCHECK_LE(bytes_per_channel, kChannelAlignment);
-  int data_size = frame_count * bytes_per_channel;
 
   // Empty buffer?
   if (!create_buffer)
     return;
 
-  if (sample_format == kSampleFormatPlanarF32 ||
-      sample_format == kSampleFormatPlanarS16 ||
-      sample_format == kSampleFormatPlanarS32) {
+  int data_size_per_channel = frame_count * bytes_per_channel;
+  if (IsPlanar(sample_format)) {
     // Planar data, so need to allocate buffer for each channel.
     // Determine per channel data size, taking into account alignment.
     int block_size_per_channel =
-        (data_size + kChannelAlignment - 1) & ~(kChannelAlignment - 1);
-    DCHECK_GE(block_size_per_channel, data_size);
+        (data_size_per_channel + kChannelAlignment - 1) &
+        ~(kChannelAlignment - 1);
+    DCHECK_GE(block_size_per_channel, data_size_per_channel);
 
     // Allocate a contiguous buffer for all the channel data.
-    data_.reset(static_cast<uint8*>(base::AlignedAlloc(
-        channel_count_ * block_size_per_channel, kChannelAlignment)));
+    data_size_ = channel_count_ * block_size_per_channel;
+    data_.reset(
+        static_cast<uint8*>(base::AlignedAlloc(data_size_, kChannelAlignment)));
     channel_data_.reserve(channel_count_);
 
     // Copy each channel's data into the appropriate spot.
     for (int i = 0; i < channel_count_; ++i) {
       channel_data_.push_back(data_.get() + i * block_size_per_channel);
       if (data)
-        memcpy(channel_data_[i], data[i], data_size);
+        memcpy(channel_data_[i], data[i], data_size_per_channel);
     }
     return;
   }
 
   // Remaining formats are interleaved data.
   DCHECK(sample_format_ == kSampleFormatU8 ||
          sample_format_ == kSampleFormatS16 ||
          sample_format_ == kSampleFormatS32 ||
          sample_format_ == kSampleFormatF32) << sample_format_;

[xhwang, 2015/11/24 05:59:13]

!IsPlanar()?

Actually we could also have kUnknownSampleFormat, so maybe we need an
IsInterleaved() method.

[jrummell, 2015/11/24 20:51:05]

Done.

   // Allocate our own buffer and copy the supplied data into it. Buffer must
   // contain the data for all channels.
-  data_size *= channel_count_;
+  data_size_ = data_size_per_channel * channel_count_;
   data_.reset(
-      static_cast<uint8*>(base::AlignedAlloc(data_size, kChannelAlignment)));
+      static_cast<uint8*>(base::AlignedAlloc(data_size_, kChannelAlignment)));
   channel_data_.reserve(1);
   channel_data_.push_back(data_.get());
   if (data)
-    memcpy(data_.get(), data[0], data_size);
+    memcpy(data_.get(), data[0], data_size_);
 }
 
 AudioBuffer::~AudioBuffer() {}
 
 // static
 scoped_refptr<AudioBuffer> AudioBuffer::CopyFrom(
     SampleFormat sample_format,
     ChannelLayout channel_layout,
     int channel_count,
     int sample_rate,
@@ skipping 316 matching lines @@
     }
   } else {
     CHECK_EQ(frames_to_copy, 0);
   }
 
   // Trim the leftover data off the end of the buffer and update duration.
   TrimEnd(frames_to_trim);
 }
 
 }  // namespace media