Home | History | Annotate | Download | only in base 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "media/base/audio_buffer.h"
      6 
      7 #include "base/logging.h"
      8 #include "media/base/audio_bus.h"
      9 #include "media/base/buffers.h"
     10 #include "media/base/limits.h"
     11 
     12 namespace media {
     13 
     14 AudioBuffer::AudioBuffer(SampleFormat sample_format,
     15                          int channel_count,
     16                          int frame_count,
     17                          bool create_buffer,
     18                          const uint8* const* data,
     19                          const base::TimeDelta timestamp,
     20                          const base::TimeDelta duration)
     21     : sample_format_(sample_format),
     22       channel_count_(channel_count),
     23       adjusted_frame_count_(frame_count),
     24       trim_start_(0),
     25       end_of_stream_(!create_buffer && data == NULL && frame_count == 0),
     26       timestamp_(timestamp),
     27       duration_(duration) {
     28   CHECK_GE(channel_count, 0);
     29   CHECK_LE(channel_count, limits::kMaxChannels);
     30   CHECK_GE(frame_count, 0);
     31   int bytes_per_channel = SampleFormatToBytesPerChannel(sample_format);
     32   DCHECK_LE(bytes_per_channel, kChannelAlignment);
     33   int data_size = frame_count * bytes_per_channel;
     34 
     35   // Empty buffer?
     36   if (!create_buffer)
     37     return;
     38 
     39   if (sample_format == kSampleFormatPlanarF32 ||
     40       sample_format == kSampleFormatPlanarS16) {
     41     // Planar data, so need to allocate buffer for each channel.
     42     // Determine per channel data size, taking into account alignment.
     43     int block_size_per_channel =
     44         (data_size + kChannelAlignment - 1) & ~(kChannelAlignment - 1);
     45     DCHECK_GE(block_size_per_channel, data_size);
     46 
     47     // Allocate a contiguous buffer for all the channel data.
     48     data_.reset(static_cast<uint8*>(base::AlignedAlloc(
     49         channel_count * block_size_per_channel, kChannelAlignment)));
     50     channel_data_.reserve(channel_count);
     51 
     52     // Copy each channel's data into the appropriate spot.
     53     for (int i = 0; i < channel_count; ++i) {
     54       channel_data_.push_back(data_.get() + i * block_size_per_channel);
     55       if (data)
     56         memcpy(channel_data_[i], data[i], data_size);
     57     }
     58     return;
     59   }
     60 
     61   // Remaining formats are interleaved data.
     62   DCHECK(sample_format_ == kSampleFormatU8 ||
     63          sample_format_ == kSampleFormatS16 ||
     64          sample_format_ == kSampleFormatS32 ||
     65          sample_format_ == kSampleFormatF32) << sample_format_;
     66   // Allocate our own buffer and copy the supplied data into it. Buffer must
     67   // contain the data for all channels.
     68   data_size *= channel_count;
     69   data_.reset(
     70       static_cast<uint8*>(base::AlignedAlloc(data_size, kChannelAlignment)));
     71   channel_data_.reserve(1);
     72   channel_data_.push_back(data_.get());
     73   if (data)
     74     memcpy(data_.get(), data[0], data_size);
     75 }
     76 
     77 AudioBuffer::~AudioBuffer() {}
     78 
     79 // static
     80 scoped_refptr<AudioBuffer> AudioBuffer::CopyFrom(
     81     SampleFormat sample_format,
     82     int channel_count,
     83     int frame_count,
     84     const uint8* const* data,
     85     const base::TimeDelta timestamp,
     86     const base::TimeDelta duration) {
     87   // If you hit this CHECK you likely have a bug in a demuxer. Go fix it.
     88   CHECK_GT(frame_count, 0);  // Otherwise looks like an EOF buffer.
     89   CHECK(data[0]);
     90   return make_scoped_refptr(new AudioBuffer(sample_format,
     91                                             channel_count,
     92                                             frame_count,
     93                                             true,
     94                                             data,
     95                                             timestamp,
     96                                             duration));
     97 }
     98 
     99 // static
    100 scoped_refptr<AudioBuffer> AudioBuffer::CreateBuffer(SampleFormat sample_format,
    101                                                      int channel_count,
    102                                                      int frame_count) {
    103   CHECK_GT(frame_count, 0);  // Otherwise looks like an EOF buffer.
    104   return make_scoped_refptr(new AudioBuffer(sample_format,
    105                                             channel_count,
    106                                             frame_count,
    107                                             true,
    108                                             NULL,
    109                                             kNoTimestamp(),
    110                                             kNoTimestamp()));
    111 }
    112 
    113 // static
    114 scoped_refptr<AudioBuffer> AudioBuffer::CreateEmptyBuffer(
    115     int channel_count,
    116     int frame_count,
    117     const base::TimeDelta timestamp,
    118     const base::TimeDelta duration) {
    119   CHECK_GT(frame_count, 0);  // Otherwise looks like an EOF buffer.
    120   // Since data == NULL, format doesn't matter.
    121   return make_scoped_refptr(new AudioBuffer(kSampleFormatF32,
    122                                             channel_count,
    123                                             frame_count,
    124                                             false,
    125                                             NULL,
    126                                             timestamp,
    127                                             duration));
    128 }
    129 
    130 // static
    131 scoped_refptr<AudioBuffer> AudioBuffer::CreateEOSBuffer() {
    132   return make_scoped_refptr(new AudioBuffer(
    133       kUnknownSampleFormat, 1, 0, false, NULL, kNoTimestamp(), kNoTimestamp()));
    134 }
    135 
    136 // Convert int16 values in the range [kint16min, kint16max] to [-1.0, 1.0].
    137 static inline float ConvertS16ToFloat(int16 value) {
    138   return value * (value < 0 ? -1.0f / kint16min : 1.0f / kint16max);
    139 }
    140 
    141 void AudioBuffer::ReadFrames(int frames_to_copy,
    142                              int source_frame_offset,
    143                              int dest_frame_offset,
    144                              AudioBus* dest) {
    145   // Deinterleave each channel (if necessary) and convert to 32bit
    146   // floating-point with nominal range -1.0 -> +1.0 (if necessary).
    147 
    148   // |dest| must have the same number of channels, and the number of frames
    149   // specified must be in range.
    150   DCHECK(!end_of_stream());
    151   DCHECK_EQ(dest->channels(), channel_count_);
    152   DCHECK_LE(source_frame_offset + frames_to_copy, adjusted_frame_count_);
    153   DCHECK_LE(dest_frame_offset + frames_to_copy, dest->frames());
    154 
    155   // Move the start past any frames that have been trimmed.
    156   source_frame_offset += trim_start_;
    157 
    158   if (!data_) {
    159     // Special case for an empty buffer.
    160     dest->ZeroFramesPartial(dest_frame_offset, frames_to_copy);
    161     return;
    162   }
    163 
    164   if (sample_format_ == kSampleFormatPlanarF32) {
    165     // Format is planar float32. Copy the data from each channel as a block.
    166     for (int ch = 0; ch < channel_count_; ++ch) {
    167       const float* source_data =
    168           reinterpret_cast<const float*>(channel_data_[ch]) +
    169           source_frame_offset;
    170       memcpy(dest->channel(ch) + dest_frame_offset,
    171              source_data,
    172              sizeof(float) * frames_to_copy);
    173     }
    174     return;
    175   }
    176 
    177   if (sample_format_ == kSampleFormatPlanarS16) {
    178     // Format is planar signed16. Convert each value into float and insert into
    179     // output channel data.
    180     for (int ch = 0; ch < channel_count_; ++ch) {
    181       const int16* source_data =
    182           reinterpret_cast<const int16*>(channel_data_[ch]) +
    183           source_frame_offset;
    184       float* dest_data = dest->channel(ch) + dest_frame_offset;
    185       for (int i = 0; i < frames_to_copy; ++i) {
    186         dest_data[i] = ConvertS16ToFloat(source_data[i]);
    187       }
    188     }
    189     return;
    190   }
    191 
    192   if (sample_format_ == kSampleFormatF32) {
    193     // Format is interleaved float32. Copy the data into each channel.
    194     const float* source_data = reinterpret_cast<const float*>(data_.get()) +
    195                                source_frame_offset * channel_count_;
    196     for (int ch = 0; ch < channel_count_; ++ch) {
    197       float* dest_data = dest->channel(ch) + dest_frame_offset;
    198       for (int i = 0, offset = ch; i < frames_to_copy;
    199            ++i, offset += channel_count_) {
    200         dest_data[i] = source_data[offset];
    201       }
    202     }
    203     return;
    204   }
    205 
    206   // Remaining formats are integer interleaved data. Use the deinterleaving code
    207   // in AudioBus to copy the data.
    208   DCHECK(sample_format_ == kSampleFormatU8 ||
    209          sample_format_ == kSampleFormatS16 ||
    210          sample_format_ == kSampleFormatS32);
    211   int bytes_per_channel = SampleFormatToBytesPerChannel(sample_format_);
    212   int frame_size = channel_count_ * bytes_per_channel;
    213   const uint8* source_data = data_.get() + source_frame_offset * frame_size;
    214   dest->FromInterleavedPartial(
    215       source_data, dest_frame_offset, frames_to_copy, bytes_per_channel);
    216 }
    217 
    218 void AudioBuffer::TrimStart(int frames_to_trim) {
    219   CHECK_GE(frames_to_trim, 0);
    220   CHECK_LE(frames_to_trim, adjusted_frame_count_);
    221 
    222   // Adjust timestamp_ and duration_ to reflect the smaller number of frames.
    223   double offset = static_cast<double>(duration_.InMicroseconds()) *
    224                   frames_to_trim / adjusted_frame_count_;
    225   base::TimeDelta offset_as_time =
    226       base::TimeDelta::FromMicroseconds(static_cast<int64>(offset));
    227   timestamp_ += offset_as_time;
    228   duration_ -= offset_as_time;
    229 
    230   // Finally adjust the number of frames in this buffer and where the start
    231   // really is.
    232   adjusted_frame_count_ -= frames_to_trim;
    233   trim_start_ += frames_to_trim;
    234 }
    235 
    236 void AudioBuffer::TrimEnd(int frames_to_trim) {
    237   CHECK_GE(frames_to_trim, 0);
    238   CHECK_LE(frames_to_trim, adjusted_frame_count_);
    239 
    240   // Adjust duration_ only to reflect the smaller number of frames.
    241   double offset = static_cast<double>(duration_.InMicroseconds()) *
    242                   frames_to_trim / adjusted_frame_count_;
    243   base::TimeDelta offset_as_time =
    244       base::TimeDelta::FromMicroseconds(static_cast<int64>(offset));
    245   duration_ -= offset_as_time;
    246 
    247   // Finally adjust the number of frames in this buffer.
    248   adjusted_frame_count_ -= frames_to_trim;
    249 }
    250 
    251 }  // namespace media
    252