Decode entire in-memory file for WebAudio

media/filters/audio_file_reader_unittest.cc

 // Copyright (c) 2012 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/filters/audio_file_reader.h"
 
 #include <memory>
 
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 17 matching lines @@
 
   void Initialize(const char* filename) {
     data_ = ReadTestDataFile(filename);
     protocol_.reset(
         new InMemoryUrlProtocol(data_->data(), data_->data_size(), false));
     reader_.reset(new AudioFileReader(protocol_.get()));
   }
 
   // Reads and the entire file provided to Initialize().
   void ReadAndVerify(const char* expected_audio_hash, int expected_frames) {
+    std::vector<std::unique_ptr<AudioBus>> decoded_audio_packets;
+    int actual_frames = reader_->Read(&decoded_audio_packets);
     std::unique_ptr<AudioBus> decoded_audio_data =
-        AudioBus::Create(reader_->channels(), reader_->GetNumberOfFrames());
-    int actual_frames = reader_->Read(decoded_audio_data.get());
+        AudioBus::Create(reader_->channels(), actual_frames);
+    int dest_start_frame = 0;
+    for (size_t k = 0; k < decoded_audio_packets.size(); ++k) {
+      const AudioBus* packet = decoded_audio_packets[k].get();
+      int frame_count = packet->frames();
+      packet->CopyPartialFramesTo(0, frame_count, dest_start_frame,
+                                  decoded_audio_data.get());
+      dest_start_frame += frame_count;
+    }
     ASSERT_LE(actual_frames, decoded_audio_data->frames());
     ASSERT_EQ(expected_frames, actual_frames);
 
     AudioHash audio_hash;
     audio_hash.Update(decoded_audio_data.get(), actual_frames);
     EXPECT_EQ(expected_audio_hash, audio_hash.ToString());
   }
 
   // Verify packets are consistent across demuxer runs.  Reads the first few
   // packets and then seeks back to the start timestamp and verifies that the
@@ skipping 31 matching lines @@
       ASSERT_TRUE(reader_->SeekForTesting(start_timestamp));
     }
   }
 
   void RunTest(const char* fn,
                const char* hash,
                int channels,
                int sample_rate,
                base::TimeDelta duration,
                int frames,
-               int trimmed_frames) {
+               int expected_frames) {
     Initialize(fn);
     ASSERT_TRUE(reader_->Open());
     EXPECT_EQ(channels, reader_->channels());
     EXPECT_EQ(sample_rate, reader_->sample_rate());
-    EXPECT_EQ(duration.InMicroseconds(),
-              reader_->GetDuration().InMicroseconds());
-    EXPECT_EQ(frames, reader_->GetNumberOfFrames());
+    if (frames >= 0) {
+      EXPECT_EQ(duration.InMicroseconds(),
+                reader_->GetDuration().InMicroseconds());
+      EXPECT_EQ(frames, reader_->GetNumberOfFrames());
+      EXPECT_EQ(reader_->HasKnownDuration(), true);
+    } else {
+      EXPECT_EQ(reader_->HasKnownDuration(), false);
+    }
     if (!packet_verification_disabled_)
       ASSERT_NO_FATAL_FAILURE(VerifyPackets());
-    ReadAndVerify(hash, trimmed_frames);
+    ReadAndVerify(hash, expected_frames);
   }
 
   void RunTestFailingDemux(const char* fn) {
     Initialize(fn);
     EXPECT_FALSE(reader_->Open());
   }
 
   void RunTestFailingDecode(const char* fn) {
     Initialize(fn);
     EXPECT_TRUE(reader_->Open());
-    std::unique_ptr<AudioBus> decoded_audio_data =
-        AudioBus::Create(reader_->channels(), reader_->GetNumberOfFrames());
-    EXPECT_EQ(reader_->Read(decoded_audio_data.get()), 0);
+    std::vector<std::unique_ptr<AudioBus>> decoded_audio_packets;
+    EXPECT_EQ(reader_->Read(&decoded_audio_packets), 0);
   }
 
   void disable_packet_verification() {
     packet_verification_disabled_ = true;
   }
 
  protected:
   scoped_refptr<DecoderBuffer> data_;
   std::unique_ptr<InMemoryUrlProtocol> protocol_;
   std::unique_ptr<AudioFileReader> reader_;
   bool packet_verification_disabled_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioFileReaderTest);
 };
 
 TEST_F(AudioFileReaderTest, WithoutOpen) {
   Initialize("bear.ogv");
 }
 
 TEST_F(AudioFileReaderTest, InvalidFile) {
   RunTestFailingDemux("ten_byte_file");
 }
 
-TEST_F(AudioFileReaderTest, InfiniteDuration) {
-  RunTestFailingDemux("bear-320x240-live.webm");
+TEST_F(AudioFileReaderTest, UnknownDuration) {
+  RunTest("bear-320x240-live.webm", "-3.59,-2.06,-0.43,2.15,0.77,-0.95,", 2,
+          44100, base::TimeDelta::FromMicroseconds(-1), -1, 121024);
 }
 
 TEST_F(AudioFileReaderTest, WithVideo) {
-  RunTest("bear.ogv",
-          "-2.49,-0.75,0.38,1.60,0.70,-1.22,",
-          2,
-          44100,
-          base::TimeDelta::FromMicroseconds(1011520),
-          44609,
-          44609);
+  RunTest("bear.ogv", "-0.73,0.92,0.48,-0.07,-0.92,-0.88,", 2, 44100,
+          base::TimeDelta::FromMicroseconds(1011520), 44609, 45632);
 }
 
 TEST_F(AudioFileReaderTest, Vorbis) {
-  RunTest("sfx.ogg",
-          "4.36,4.81,4.84,4.45,4.61,4.63,",
-          1,
-          44100,
-          base::TimeDelta::FromMicroseconds(350001),
-          15436,
-          15436);
+  RunTest("sfx.ogg", "2.17,3.31,5.15,6.33,5.97,4.35,", 1, 44100,
+          base::TimeDelta::FromMicroseconds(350001), 15436, 15936);
 }
 
 TEST_F(AudioFileReaderTest, WaveU8) {
   RunTest("sfx_u8.wav",
           "-1.23,-1.57,-1.14,-0.91,-0.87,-0.07,",
           1,
           44100,
           base::TimeDelta::FromMicroseconds(288414),
           12720,
           12719);
@@ skipping 71 matching lines @@
   RunTest("4ch.wav",
           "131.71,38.02,130.31,44.89,135.98,42.52,",
           4,
           44100,
           base::TimeDelta::FromMicroseconds(100001),
           4411,
           4410);
 }
 
 }  // namespace media