Deprecate AudioProcessing::AnalyzeReverseStream(AudioFrame) API

webrtc/modules/audio_processing/test/audio_processing_unittest.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 566 matching lines @@
                              frame_->samples_per_channel_,
                              frame_->sample_rate_hz_,
                              LayoutFromChannels(frame_->num_channels_),
                              output_sample_rate_hz_,
                              LayoutFromChannels(num_output_channels_),
                              float_cb_->channels());
 }
 
 int ApmTest::AnalyzeReverseStreamChooser(Format format) {
   if (format == kIntFormat) {
-    return apm_->AnalyzeReverseStream(revframe_);
+    return apm_->ProcessReverseStream(revframe_);
   }
   return apm_->AnalyzeReverseStream(
       revfloat_cb_->channels(),
       revframe_->samples_per_channel_,
       revframe_->sample_rate_hz_,
       LayoutFromChannels(revframe_->num_channels_));
 }
 
 void ApmTest::ProcessDelayVerificationTest(int delay_ms, int system_delay_ms,
                                            int delay_min, int delay_max) {
@@ skipping 35 matching lines @@
     AudioFrame* reverse_frame = frame;
     AudioFrame* process_frame = frame_queue.front();
     if (!causal) {
       reverse_frame = frame_queue.front();
       // When we call ProcessStream() the frame is modified, so we can't use the
       // pointer directly when things are non-causal. Use an intermediate frame
       // and copy the data.
       process_frame = &tmp_frame;
       process_frame->CopyFrom(*frame);
     }
-    EXPECT_EQ(apm_->kNoError, apm_->AnalyzeReverseStream(reverse_frame));
+    EXPECT_EQ(apm_->kNoError, apm_->ProcessReverseStream(reverse_frame));
     EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(system_delay_ms));
     EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(process_frame));
     frame = frame_queue.front();
     frame_queue.pop();
     delete frame;
 
     if (frame_count == 250) {
       int median;
       int std;
       float poor_fraction;
@@ skipping 149 matching lines @@
   EXPECT_EQ(0, apm_->stream_delay_ms());
   EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(100));
   EXPECT_EQ(50, apm_->stream_delay_ms());
 }
 
 void ApmTest::TestChangingChannelsInt16Interface(
     size_t num_channels,
     AudioProcessing::Error expected_return) {
   frame_->num_channels_ = num_channels;
   EXPECT_EQ(expected_return, apm_->ProcessStream(frame_));
-  EXPECT_EQ(expected_return, apm_->AnalyzeReverseStream(frame_));
+  EXPECT_EQ(expected_return, apm_->ProcessReverseStream(frame_));
 }
 
 void ApmTest::TestChangingForwardChannels(
     size_t num_in_channels,
     size_t num_out_channels,
     AudioProcessing::Error expected_return) {
   const StreamConfig input_stream = {frame_->sample_rate_hz_, num_in_channels};
   const StreamConfig output_stream = {output_sample_rate_hz_, num_out_channels};
 
   EXPECT_EQ(expected_return,
@@ skipping 758 matching lines @@
          2,
          2,
          2,
          false);
     int analog_level = 127;
     ASSERT_EQ(0, feof(far_file_));
     ASSERT_EQ(0, feof(near_file_));
     while (ReadFrame(far_file_, revframe_) && ReadFrame(near_file_, frame_)) {
       CopyLeftToRightChannel(revframe_->data_, revframe_->samples_per_channel_);
 
-      ASSERT_EQ(kNoErr, apm_->AnalyzeReverseStream(revframe_));
+      ASSERT_EQ(kNoErr, apm_->ProcessReverseStream(revframe_));
 
       CopyLeftToRightChannel(frame_->data_, frame_->samples_per_channel_);
       frame_->vad_activity_ = AudioFrame::kVadUnknown;
 
       ASSERT_EQ(kNoErr, apm_->set_stream_delay_ms(0));
       apm_->echo_cancellation()->set_stream_drift_samples(0);
       ASSERT_EQ(kNoErr,
           apm_->gain_control()->set_stream_analog_level(analog_level));
       ASSERT_EQ(kNoErr, apm_->ProcessStream(frame_));
       analog_level = apm_->gain_control()->stream_analog_level();
@@ skipping 254 matching lines @@
       test::TempFilename(test::OutputPath(), "debug_aec");
   EXPECT_EQ(apm_->kNullPointerError,
             apm_->StartDebugRecording(static_cast<const char*>(NULL), -1));
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   // Stopping without having started should be OK.
   EXPECT_EQ(apm_->kNoError, apm_->StopDebugRecording());
 
   EXPECT_EQ(apm_->kNoError, apm_->StartDebugRecording(filename.c_str(), -1));
   EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));
-  EXPECT_EQ(apm_->kNoError, apm_->AnalyzeReverseStream(revframe_));
+  EXPECT_EQ(apm_->kNoError, apm_->ProcessReverseStream(revframe_));
   EXPECT_EQ(apm_->kNoError, apm_->StopDebugRecording());
 
   // Verify the file has been written.
   FILE* fid = fopen(filename.c_str(), "r");
   ASSERT_TRUE(fid != NULL);
 
   // Clean it up.
   ASSERT_EQ(0, fclose(fid));
   ASSERT_EQ(0, remove(filename.c_str()));
 #else
@@ skipping 13 matching lines @@
   const std::string filename =
       test::TempFilename(test::OutputPath(), "debug_aec");
   fid = fopen(filename.c_str(), "w");
   ASSERT_TRUE(fid);
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   // Stopping without having started should be OK.
   EXPECT_EQ(apm_->kNoError, apm_->StopDebugRecording());
 
   EXPECT_EQ(apm_->kNoError, apm_->StartDebugRecording(fid, -1));
-  EXPECT_EQ(apm_->kNoError, apm_->AnalyzeReverseStream(revframe_));
+  EXPECT_EQ(apm_->kNoError, apm_->ProcessReverseStream(revframe_));
   EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));
   EXPECT_EQ(apm_->kNoError, apm_->StopDebugRecording());
 
   // Verify the file has been written.
   fid = fopen(filename.c_str(), "r");
   ASSERT_TRUE(fid != NULL);
 
   // Clean it up.
   ASSERT_EQ(0, fclose(fid));
   ASSERT_EQ(0, remove(filename.c_str()));
@@ skipping 39 matching lines @@
     ChannelBuffer<int16_t> output_cb(samples_per_channel, num_input_channels);
     ChannelBuffer<int16_t> output_int16(samples_per_channel,
                                         num_input_channels);
 
     int analog_level = 127;
     size_t num_bad_chunks = 0;
     while (ReadFrame(far_file_, revframe_, revfloat_cb_.get()) &&
            ReadFrame(near_file_, frame_, float_cb_.get())) {
       frame_->vad_activity_ = AudioFrame::kVadUnknown;
 
-      EXPECT_NOERR(apm_->AnalyzeReverseStream(revframe_));
+      EXPECT_NOERR(apm_->ProcessReverseStream(revframe_));
       EXPECT_NOERR(fapm->AnalyzeReverseStream(
           revfloat_cb_->channels(),
           samples_per_channel,
           test->sample_rate(),
           LayoutFromChannels(num_render_channels)));
 
       EXPECT_NOERR(apm_->set_stream_delay_ms(0));
       EXPECT_NOERR(fapm->set_stream_delay_ms(0));
       apm_->echo_cancellation()->set_stream_drift_samples(0);
       fapm->echo_cancellation()->set_stream_drift_samples(0);
@@ skipping 119 matching lines @@
     int frame_count = 0;
     int has_echo_count = 0;
     int has_voice_count = 0;
     int is_saturated_count = 0;
     int analog_level = 127;
     int analog_level_average = 0;
     int max_output_average = 0;
     float ns_speech_prob_average = 0.0f;
 
     while (ReadFrame(far_file_, revframe_) && ReadFrame(near_file_, frame_)) {
-      EXPECT_EQ(apm_->kNoError, apm_->AnalyzeReverseStream(revframe_));
+      EXPECT_EQ(apm_->kNoError, apm_->ProcessReverseStream(revframe_));
 
       frame_->vad_activity_ = AudioFrame::kVadUnknown;
 
       EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(0));
       apm_->echo_cancellation()->set_stream_drift_samples(0);
       EXPECT_EQ(apm_->kNoError,
           apm_->gain_control()->set_stream_analog_level(analog_level));
 
       EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));
 
@@ skipping 632 matching lines @@
                     std::tr1::make_tuple(16000, 32000, 48000, 32000, 25, 35),
                     std::tr1::make_tuple(16000, 32000, 32000, 32000, 25, 0),
                     std::tr1::make_tuple(16000, 32000, 16000, 32000, 25, 20),
                     std::tr1::make_tuple(16000, 16000, 48000, 16000, 35, 20),
                     std::tr1::make_tuple(16000, 16000, 32000, 16000, 35, 20),
                     std::tr1::make_tuple(16000, 16000, 16000, 16000, 0, 0)));
 #endif
 
 }  // namespace
 }  // namespace webrtc