Clamp AudioBuffer float to int{16,32} conversion

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"
+#include "media/base/audio_sample_conversion.h"
 #include "media/base/limits.h"
 #include "media/base/timestamp_constants.h"
 
 namespace media {
 
 static base::TimeDelta CalculateDuration(int frames, double sample_rate) {
   DCHECK_GT(sample_rate, 0);
   return base::TimeDelta::FromMicroseconds(
       frames * base::Time::kMicrosecondsPerSecond / sample_rate);
 }
@@ skipping 137 matching lines @@
                                             0,
                                             0,
                                             false,
                                             NULL,
                                             kNoTimestamp()));
 }
 
 template <typename Target, typename Dest>
 static inline Dest ConvertSample(Target value);
 
-// Convert int16_t values in the range [INT16_MIN, INT16_MAX] to [-1.0, 1.0].
-template <>
-inline float ConvertSample<int16_t, float>(int16_t value) {
-  return value * (value < 0 ? -1.0f / std::numeric_limits<int16_t>::min()
-                            : 1.0f / std::numeric_limits<int16_t>::max());
-}
-
 // Specializations for int32_t
 template <>
 inline int32_t ConvertSample<int16_t, int32_t>(int16_t value) {

[DaleCurtis, 2016/04/01 19:31:20]

Do we still need the rest of these?

   return static_cast<int32_t>(value) << 16;
 }
 
 template <>
 inline int32_t ConvertSample<int32_t, int32_t>(int32_t value) {
   return value;
 }
 
-template <>
-inline int32_t ConvertSample<float, int32_t>(float value) {
-  return static_cast<int32_t>(
-      value < 0 ? (-value) * std::numeric_limits<int32_t>::min()
-                : value * std::numeric_limits<int32_t>::max());
-}
-
 // Specializations for int16_t
 template <>
 inline int16_t ConvertSample<int16_t, int16_t>(int16_t sample) {
   return sample;
 }
 
 template <>
 inline int16_t ConvertSample<int32_t, int16_t>(int32_t sample) {
   return sample >> 16;
 }
 
-template <>
-inline int16_t ConvertSample<float, int16_t>(float sample) {
-  return static_cast<int16_t>(
-      nearbyint(sample < 0 ? (-sample) * std::numeric_limits<int16_t>::min()
-                           : sample * std::numeric_limits<int16_t>::max()));
-}
-
 void AudioBuffer::AdjustSampleRate(int sample_rate) {
   DCHECK(!end_of_stream_);
   sample_rate_ = sample_rate;
   duration_ = CalculateDuration(adjusted_frame_count_, sample_rate_);
 }
 
 void AudioBuffer::ReadFrames(int frames_to_copy,
                              int source_frame_offset,
                              int dest_frame_offset,
                              AudioBus* dest) {
@@ skipping 30 matching lines @@
   }
 
   if (sample_format_ == kSampleFormatPlanarS16) {
     // Format is planar signed16. Convert each value into float and insert into
     // output channel data.
     for (int ch = 0; ch < channel_count_; ++ch) {
       const int16_t* source_data =
           reinterpret_cast<const int16_t*>(channel_data_[ch]) +
           source_frame_offset;
       float* dest_data = dest->channel(ch) + dest_frame_offset;
-      for (int i = 0; i < frames_to_copy; ++i) {
-        dest_data[i] = ConvertSample<int16_t, float>(source_data[i]);
-      }
+      DeinterleaveOneChannel<int16_t>(source_data, 0, frames_to_copy, dest_data,
+                                      1, 0);
     }
     return;
   }
 
   if (sample_format_ == kSampleFormatF32) {
     // Format is interleaved float32. Copy the data into each channel.
     const float* source_data = reinterpret_cast<const float*>(data_.get()) +
                                source_frame_offset * channel_count_;
     for (int ch = 0; ch < channel_count_; ++ch) {
       float* dest_data = dest->channel(ch) + dest_frame_offset;
-      for (int i = 0, offset = ch; i < frames_to_copy;
-           ++i, offset += channel_count_) {
-        dest_data[i] = source_data[offset];
-      }
+      DeinterleaveOneChannel<float>(source_data, 0, frames_to_copy, dest_data,
+                                    channel_count_, ch);
     }
     return;
   }
 
   // Remaining formats are integer interleaved data. Use the deinterleaving code
   // in AudioBus to copy the data.
   DCHECK(
       sample_format_ == kSampleFormatU8 || sample_format_ == kSampleFormatS16 ||
       sample_format_ == kSampleFormatS24 || sample_format_ == kSampleFormatS32);
   int bytes_per_channel = SampleFormatToBytesPerChannel(sample_format_);
@@ skipping 12 matching lines @@
     const Target* source_data =
         reinterpret_cast<const Target*>(channel_data[ch]) + trim_start;
     for (size_t i = 0, offset = ch; i < frames_to_copy;
          ++i, offset += channel_data.size()) {
       dest_data[offset] = ConvertSample<Target, Dest>(source_data[i]);
     }
   }
 }
 
 template <typename Dest>
+void InterleaveAndConvertFloat(const std::vector<uint8_t*>& channel_data,
+                               size_t frames_to_copy,
+                               int trim_start,
+                               Dest* dest_data) {
+  for (size_t ch = 0; ch < channel_data.size(); ++ch) {
+    const float* source_data =
+        reinterpret_cast<const float*>(channel_data[ch]) + trim_start;
+    InterleaveOneChannel<Dest>(source_data, 0, frames_to_copy, dest_data,
+                               channel_data.size(), ch);
+  }
+}
+
+template <typename Dest>
 void ReadFramesInterleaved(const std::vector<uint8_t*>& channel_data,
                            int channel_count,
                            SampleFormat sample_format,
                            int frames_to_copy,
                            int trim_start,
                            Dest* dest_data) {
   switch (sample_format) {
     case kSampleFormatU8:
       NOTREACHED();
       break;
     case kSampleFormatS16:
       InterleaveAndConvert<int16_t, Dest>(
           channel_data, frames_to_copy * channel_count, trim_start, dest_data);
       break;
     case kSampleFormatS24:
     case kSampleFormatS32:
       InterleaveAndConvert<int32_t, Dest>(
           channel_data, frames_to_copy * channel_count, trim_start, dest_data);
       break;
     case kSampleFormatF32:
-      InterleaveAndConvert<float, Dest>(
+      InterleaveAndConvertFloat<Dest>(
           channel_data, frames_to_copy * channel_count, trim_start, dest_data);
       break;
     case kSampleFormatPlanarS16:
       InterleaveAndConvert<int16_t, Dest>(channel_data, frames_to_copy,
                                           trim_start, dest_data);
       break;
     case kSampleFormatPlanarF32:
-      InterleaveAndConvert<float, Dest>(channel_data, frames_to_copy,
-                                        trim_start, dest_data);
+      InterleaveAndConvertFloat<Dest>(channel_data, frames_to_copy, trim_start,
+                                      dest_data);
       break;
     case kSampleFormatPlanarS32:
       InterleaveAndConvert<int32_t, Dest>(channel_data, frames_to_copy,
                                           trim_start, dest_data);
       break;
     case kUnknownSampleFormat:
       NOTREACHED();
       break;
   }
 }
@@ skipping 74 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