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 <algorithm>
 #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 134 matching lines @@
   return make_scoped_refptr(new AudioBuffer(kUnknownSampleFormat,
                                             CHANNEL_LAYOUT_NONE,
                                             0,
                                             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) {
-  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 63 matching lines @@
   DCHECK(
       sample_format_ == kSampleFormatU8 || sample_format_ == kSampleFormatS16 ||
       sample_format_ == kSampleFormatS24 || sample_format_ == kSampleFormatS32);
   int bytes_per_channel = SampleFormatToBytesPerChannel(sample_format_);
   int frame_size = channel_count_ * bytes_per_channel;
   const uint8_t* source_data = data_.get() + source_frame_offset * frame_size;
   dest->FromInterleavedPartial(
       source_data, dest_frame_offset, frames_to_copy, bytes_per_channel);
 }
 
-template <class Target, typename Dest>
-void InterleaveAndConvert(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 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 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>(
+      PlanarToInterleaved<int16_t, Dest>(
           channel_data, frames_to_copy * channel_count, trim_start, dest_data);
       break;
     case kSampleFormatS24:
     case kSampleFormatS32:
-      InterleaveAndConvert<int32_t, Dest>(
+      PlanarToInterleaved<int32_t, Dest>(
           channel_data, frames_to_copy * channel_count, trim_start, dest_data);
       break;
     case kSampleFormatF32:
-      InterleaveAndConvert<float, Dest>(
+      PlanarToInterleaved<float, 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);
+      PlanarToInterleaved<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);
+      PlanarToInterleaved<float, 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);
+      PlanarToInterleaved<int32_t, Dest>(channel_data, frames_to_copy,
+                                         trim_start, dest_data);
       break;
     case kUnknownSampleFormat:
       NOTREACHED();
       break;
   }
 }
 
 void AudioBuffer::ReadFramesInterleavedS32(int frames_to_copy,
                                            int32_t* dest_data) {
   DCHECK_LE(frames_to_copy, adjusted_frame_count_);
@@ skipping 70 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