Line data    Source code

       1             : /*
       2             :  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
       3             :  *
       4             :  *  Use of this source code is governed by a BSD-style license
       5             :  *  that can be found in the LICENSE file in the root of the source
       6             :  *  tree. An additional intellectual property rights grant can be found
       7             :  *  in the file PATENTS.  All contributing project authors may
       8             :  *  be found in the AUTHORS file in the root of the source tree.
       9             :  */
      10             : 
      11             : #include "webrtc/common_audio/lapped_transform.h"
      12             : 
      13             : #include <algorithm>
      14             : #include <cstdlib>
      15             : #include <cstring>
      16             : 
      17             : #include "webrtc/base/checks.h"
      18             : #include "webrtc/common_audio/real_fourier.h"
      19             : 
      20             : namespace webrtc {
      21             : 
      22           0 : void LappedTransform::BlockThunk::ProcessBlock(const float* const* input,
      23             :                                                size_t num_frames,
      24             :                                                size_t num_input_channels,
      25             :                                                size_t num_output_channels,
      26             :                                                float* const* output) {
      27           0 :   RTC_CHECK_EQ(num_input_channels, parent_->num_in_channels_);
      28           0 :   RTC_CHECK_EQ(num_output_channels, parent_->num_out_channels_);
      29           0 :   RTC_CHECK_EQ(parent_->block_length_, num_frames);
      30             : 
      31           0 :   for (size_t i = 0; i < num_input_channels; ++i) {
      32           0 :     memcpy(parent_->real_buf_.Row(i), input[i],
      33           0 :            num_frames * sizeof(*input[0]));
      34           0 :     parent_->fft_->Forward(parent_->real_buf_.Row(i),
      35           0 :                            parent_->cplx_pre_.Row(i));
      36             :   }
      37             : 
      38           0 :   size_t block_length = RealFourier::ComplexLength(
      39           0 :       RealFourier::FftOrder(num_frames));
      40           0 :   RTC_CHECK_EQ(parent_->cplx_length_, block_length);
      41           0 :   parent_->block_processor_->ProcessAudioBlock(parent_->cplx_pre_.Array(),
      42             :                                                num_input_channels,
      43           0 :                                                parent_->cplx_length_,
      44             :                                                num_output_channels,
      45           0 :                                                parent_->cplx_post_.Array());
      46             : 
      47           0 :   for (size_t i = 0; i < num_output_channels; ++i) {
      48           0 :     parent_->fft_->Inverse(parent_->cplx_post_.Row(i),
      49           0 :                            parent_->real_buf_.Row(i));
      50           0 :     memcpy(output[i], parent_->real_buf_.Row(i),
      51           0 :            num_frames * sizeof(*input[0]));
      52             :   }
      53           0 : }
      54             : 
      55           0 : LappedTransform::LappedTransform(size_t num_in_channels,
      56             :                                  size_t num_out_channels,
      57             :                                  size_t chunk_length,
      58             :                                  const float* window,
      59             :                                  size_t block_length,
      60             :                                  size_t shift_amount,
      61           0 :                                  Callback* callback)
      62             :     : blocker_callback_(this),
      63             :       num_in_channels_(num_in_channels),
      64             :       num_out_channels_(num_out_channels),
      65             :       block_length_(block_length),
      66             :       chunk_length_(chunk_length),
      67             :       block_processor_(callback),
      68           0 :       blocker_(chunk_length_,
      69           0 :                block_length_,
      70           0 :                num_in_channels_,
      71           0 :                num_out_channels_,
      72             :                window,
      73             :                shift_amount,
      74             :                &blocker_callback_),
      75           0 :       fft_(RealFourier::Create(RealFourier::FftOrder(block_length_))),
      76           0 :       cplx_length_(RealFourier::ComplexLength(fft_->order())),
      77             :       real_buf_(num_in_channels,
      78           0 :                 block_length_,
      79             :                 RealFourier::kFftBufferAlignment),
      80             :       cplx_pre_(num_in_channels,
      81           0 :                 cplx_length_,
      82             :                 RealFourier::kFftBufferAlignment),
      83             :       cplx_post_(num_out_channels,
      84           0 :                  cplx_length_,
      85           0 :                  RealFourier::kFftBufferAlignment) {
      86           0 :   RTC_CHECK(num_in_channels_ > 0);
      87           0 :   RTC_CHECK_GT(block_length_, 0);
      88           0 :   RTC_CHECK_GT(chunk_length_, 0);
      89           0 :   RTC_CHECK(block_processor_);
      90             : 
      91             :   // block_length_ power of 2?
      92           0 :   RTC_CHECK_EQ(0, block_length_ & (block_length_ - 1));
      93           0 : }
      94             : 
      95             : LappedTransform::~LappedTransform() = default;
      96             : 
      97           0 : void LappedTransform::ProcessChunk(const float* const* in_chunk,
      98             :                                    float* const* out_chunk) {
      99           0 :   blocker_.ProcessChunk(in_chunk, chunk_length_, num_in_channels_,
     100           0 :                         num_out_channels_, out_chunk);
     101           0 : }
     102             : 
     103             : }  // namespace webrtc