Cast: Reshuffle files under media/cast

media/cast/receiver/audio_decoder_unittest.cc

 // Copyright 2014 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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/sys_byteorder.h"
 #include "base/time/time.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/receiver/audio_decoder.h"
 #include "media/cast/test/utility/audio_utility.h"
 #include "media/cast/test/utility/standalone_cast_environment.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/opus/src/include/opus.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 struct TestScenario {
-  transport::Codec codec;
+  Codec codec;
   int num_channels;
   int sampling_rate;
 
-  TestScenario(transport::Codec c, int n, int s)
+  TestScenario(Codec c, int n, int s)
       : codec(c), num_channels(n), sampling_rate(s) {}
 };
 }  // namespace
 
 class AudioDecoderTest : public ::testing::TestWithParam<TestScenario> {
  public:
   AudioDecoderTest()
       : cast_environment_(new StandaloneCastEnvironment()),
         cond_(&lock_) {}
 
  protected:
   virtual void SetUp() OVERRIDE {
     audio_decoder_.reset(new AudioDecoder(cast_environment_,
                                           GetParam().num_channels,
                                           GetParam().sampling_rate,
                                           GetParam().codec));
     CHECK_EQ(STATUS_AUDIO_INITIALIZED, audio_decoder_->InitializationResult());
 
     audio_bus_factory_.reset(
         new TestAudioBusFactory(GetParam().num_channels,
                                 GetParam().sampling_rate,
                                 TestAudioBusFactory::kMiddleANoteFreq,
                                 0.5f));
     last_frame_id_ = 0;
     seen_a_decoded_frame_ = false;
 
-    if (GetParam().codec == transport::CODEC_AUDIO_OPUS) {
+    if (GetParam().codec == CODEC_AUDIO_OPUS) {
       opus_encoder_memory_.reset(
           new uint8[opus_encoder_get_size(GetParam().num_channels)]);
       OpusEncoder* const opus_encoder =
           reinterpret_cast<OpusEncoder*>(opus_encoder_memory_.get());
       CHECK_EQ(OPUS_OK, opus_encoder_init(opus_encoder,
                                           GetParam().sampling_rate,
                                           GetParam().num_channels,
                                           OPUS_APPLICATION_AUDIO));
       CHECK_EQ(OPUS_OK,
                opus_encoder_ctl(opus_encoder, OPUS_SET_BITRATE(OPUS_AUTO)));
     }
 
     total_audio_feed_in_ = base::TimeDelta();
     total_audio_decoded_ = base::TimeDelta();
   }
 
   // Called from the unit test thread to create another EncodedFrame and push it
   // into the decoding pipeline.
   void FeedMoreAudio(const base::TimeDelta& duration,
                      int num_dropped_frames) {
     // Prepare a simulated EncodedFrame to feed into the AudioDecoder.
-    scoped_ptr<transport::EncodedFrame> encoded_frame(
-        new transport::EncodedFrame());
-    encoded_frame->dependency = transport::EncodedFrame::KEY;
+    scoped_ptr<EncodedFrame> encoded_frame(
+        new EncodedFrame());
+    encoded_frame->dependency = EncodedFrame::KEY;
     encoded_frame->frame_id = last_frame_id_ + 1 + num_dropped_frames;
     encoded_frame->referenced_frame_id = encoded_frame->frame_id;
     last_frame_id_ = encoded_frame->frame_id;
 
     const scoped_ptr<AudioBus> audio_bus(
         audio_bus_factory_->NextAudioBus(duration).Pass());
 
     // Encode |audio_bus| into |encoded_frame->data|.
     const int num_elements = audio_bus->channels() * audio_bus->frames();
     std::vector<int16> interleaved(num_elements);
     audio_bus->ToInterleaved(
         audio_bus->frames(), sizeof(int16), &interleaved.front());
-    if (GetParam().codec == transport::CODEC_AUDIO_PCM16) {
+    if (GetParam().codec == CODEC_AUDIO_PCM16) {
       encoded_frame->data.resize(num_elements * sizeof(int16));
       int16* const pcm_data =
           reinterpret_cast<int16*>(encoded_frame->mutable_bytes());
       for (size_t i = 0; i < interleaved.size(); ++i)
         pcm_data[i] = static_cast<int16>(base::HostToNet16(interleaved[i]));
-    } else if (GetParam().codec == transport::CODEC_AUDIO_OPUS) {
+    } else if (GetParam().codec == CODEC_AUDIO_OPUS) {
       OpusEncoder* const opus_encoder =
           reinterpret_cast<OpusEncoder*>(opus_encoder_memory_.get());
       const int kOpusEncodeBufferSize = 4000;
       encoded_frame->data.resize(kOpusEncodeBufferSize);
       const int payload_size =
           opus_encode(opus_encoder,
                       &interleaved.front(),
                       audio_bus->frames(),
                       encoded_frame->mutable_bytes(),
                       encoded_frame->data.size());
@@ skipping 39 matching lines @@
     // A NULL |audio_bus| indicates a decode error, which we don't expect.
     ASSERT_FALSE(!audio_bus);
 
     // Did the decoder detect whether frames were dropped?
     EXPECT_EQ(should_be_continuous, is_continuous);
 
     // Does the audio data seem to be intact?  For Opus, we have to ignore the
     // first frame seen at the start (and immediately after dropped packet
     // recovery) because it introduces a tiny, significant delay.
     bool examine_signal = true;
-    if (GetParam().codec == transport::CODEC_AUDIO_OPUS) {
+    if (GetParam().codec == CODEC_AUDIO_OPUS) {
       examine_signal = seen_a_decoded_frame_ && should_be_continuous;
       seen_a_decoded_frame_ = true;
     }
     if (examine_signal) {
       for (int ch = 0; ch < audio_bus->channels(); ++ch) {
         EXPECT_NEAR(
             TestAudioBusFactory::kMiddleANoteFreq * 2 * audio_bus->frames() /
                 GetParam().sampling_rate,
             CountZeroCrossings(audio_bus->channel(ch), audio_bus->frames()),
             1);
@@ skipping 58 matching lines @@
       FeedMoreAudio(kTenMilliseconds, 0);
     }
   }
   WaitForAllAudioToBeDecoded();
 }
 
 INSTANTIATE_TEST_CASE_P(
     AudioDecoderTestScenarios,
     AudioDecoderTest,
     ::testing::Values(
-         TestScenario(transport::CODEC_AUDIO_PCM16, 1, 8000),
-         TestScenario(transport::CODEC_AUDIO_PCM16, 2, 48000),
-         TestScenario(transport::CODEC_AUDIO_OPUS, 1, 8000),
-         TestScenario(transport::CODEC_AUDIO_OPUS, 2, 48000)));
+         TestScenario(CODEC_AUDIO_PCM16, 1, 8000),
+         TestScenario(CODEC_AUDIO_PCM16, 2, 48000),
+         TestScenario(CODEC_AUDIO_OPUS, 1, 8000),
+         TestScenario(CODEC_AUDIO_OPUS, 2, 48000)));
 
 }  // namespace cast
 }  // namespace media