Determine the audible state in MediaSourcePlayer

media/base/android/media_source_player_unittest.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 <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
@@ skipping 28 matching lines @@
 // fix flaky pointer-based MDJ inequality testing. See http://crbug.com/327839.
 
 // Mock of MediaPlayerManager for testing purpose.
 class MockMediaPlayerManager : public MediaPlayerManager {
  public:
   explicit MockMediaPlayerManager(base::MessageLoop* message_loop)
       : message_loop_(message_loop),
         playback_completed_(false),
         num_resources_requested_(0),
         num_metadata_changes_(0),
-        timestamp_updated_(false) {}
+        timestamp_updated_(false),
+        is_audible_(false),
+        is_delay_expired_(false) {}
   ~MockMediaPlayerManager() override {}
 
   // MediaPlayerManager implementation.
   MediaResourceGetter* GetMediaResourceGetter() override { return NULL; }
   MediaUrlInterceptor* GetMediaUrlInterceptor() override { return NULL; }
   void OnTimeUpdate(int player_id,
                     base::TimeDelta current_time,
                     base::TimeTicks current_time_ticks) override {
     timestamp_updated_ = true;
   }
   void OnMediaMetadataChanged(int player_id,
                               base::TimeDelta duration,
                               int width,
                               int height,
                               bool success) override {
     num_metadata_changes_++;
   }
   void OnPlaybackComplete(int player_id) override {
     playback_completed_ = true;
     if (message_loop_->is_running())
       message_loop_->Quit();
   }
   void OnMediaInterrupted(int player_id) override {}
   void OnBufferingUpdate(int player_id, int percentage) override {}
   void OnSeekComplete(int player_id,
                       const base::TimeDelta& current_time) override {}
   void OnError(int player_id, int error) override {}
   void OnVideoSizeChanged(int player_id, int width, int height) override {}
-  void OnAudibleStateChanged(int player_id, bool is_audible_now) override {}
   void OnWaitingForDecryptionKey(int player_id) override {}
   MediaPlayerAndroid* GetFullscreenPlayer() override { return NULL; }
   MediaPlayerAndroid* GetPlayer(int player_id) override { return NULL; }
   void RequestFullScreen(int player_id) override {}
 #if defined(VIDEO_HOLE)
   bool ShouldUseVideoOverlayForEmbeddedEncryptedVideo() override {
     return false;
   }
 #endif  // defined(VIDEO_HOLE)
 
+  void OnAudibleStateChanged(int player_id, bool is_audible_now) override {
+    is_audible_ = is_audible_now;
+  }
+
   bool playback_completed() const {
     return playback_completed_;
   }
 
   int num_resources_requested() const {
     return num_resources_requested_;
   }
 
   int num_metadata_changes() const {
     return num_metadata_changes_;
   }
 
   void OnMediaResourcesRequested(int player_id) {
     num_resources_requested_++;
   }
 
   bool timestamp_updated() const {
     return timestamp_updated_;
   }
 
   void ResetTimestampUpdated() {
     timestamp_updated_ = false;
   }
 
+  bool is_audible() const {
+    return is_audible_;
+  }
+
+  bool is_delay_expired() const {
+    return is_delay_expired_;
+  }
+
+  void SetDelayExpired(bool value) {
+    is_delay_expired_ = value;
+  }
+
  private:
   base::MessageLoop* message_loop_;
   bool playback_completed_;
   // The number of resource requests this object has seen.
   int num_resources_requested_;
   // The number of metadata changes reported by the player.
   int num_metadata_changes_;
   // Playback timestamp was updated.
   bool timestamp_updated_;
+  // Audible state of the pipeline
+  bool is_audible_;
+  // Helper flag to ensure delay for WaitForDelay().
+  bool is_delay_expired_;
 
   DISALLOW_COPY_AND_ASSIGN(MockMediaPlayerManager);
 };
 
 class MockDemuxerAndroid : public DemuxerAndroid {
  public:
   explicit MockDemuxerAndroid(base::MessageLoop* message_loop)
       : message_loop_(message_loop),
         num_data_requests_(0),
         num_seek_requests_(0),
@@ skipping 37 matching lines @@
   MediaSourcePlayerTest()
       : manager_(&message_loop_),
         demuxer_(new MockDemuxerAndroid(&message_loop_)),
         player_(0, &manager_,
                 base::Bind(&MockMediaPlayerManager::OnMediaResourcesRequested,
                            base::Unretained(&manager_)),
                 scoped_ptr<DemuxerAndroid>(demuxer_),
                 GURL()),
         decoder_callback_hook_executed_(false),
         surface_texture_a_is_next_(true) {}
+
   ~MediaSourcePlayerTest() override {}
 
  protected:
   // Get the decoder job from the MediaSourcePlayer. The return value must not
   // be NULL.
   MediaDecoderJob* GetMediaDecoderJob(bool is_audio) {
     if (is_audio) {
       return reinterpret_cast<MediaDecoderJob*>(
           player_.audio_decoder_job_.get());
     }
@@ skipping 343 matching lines @@
       EXPECT_TRUE(GetMediaDecoderJob(is_audio)->is_decoding());
       EXPECT_TRUE(GetMediaCodecBridge(is_audio));
       EXPECT_TRUE(!is_clock_manager ||
                   target_timestamp == player_.GetCurrentTime());
       current_timestamp += 30;
       WaitForDecodeDone(is_audio, !is_audio);
     }
     EXPECT_LE(target_timestamp, player_.GetCurrentTime());
   }
 
+  void PlayAudioForTimeInterval(const base::TimeDelta& start_timestamp,
+                                const base::TimeDelta& target_timestamp ) {
+
+    DemuxerData data = CreateReadFromDemuxerAckForAudio(1);
+    int current_timestamp = start_timestamp.InMilliseconds();
+    int stop_timestamp = target_timestamp.InMilliseconds();
+    while (current_timestamp < stop_timestamp) {
+      data.access_units[0].timestamp =
+          base::TimeDelta::FromMilliseconds(current_timestamp);
+      player_.OnDemuxerDataAvailable(data);
+      current_timestamp += 30;
+      WaitForAudioDecodeDone();
+    }
+  }
+
+  void WaitForDelay(const base::TimeDelta& delay) {
+    // Let the message_loop_ process events.
+    // We post delayed task and RunUnitilIdle() until it signals.
+
+    manager_.SetDelayExpired(false);
+    message_loop_.PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&MockMediaPlayerManager::SetDelayExpired,
+                   base::Unretained(&manager_),
+                   true),
+        delay);
+
+    while (!manager_.is_delay_expired())
+      message_loop_.RunUntilIdle();
+  }
+
   DemuxerData CreateReadFromDemuxerAckWithConfigChanged(
       bool is_audio,
       int config_unit_index,
       const DemuxerConfigs& configs) {
     DemuxerData data;
     data.type = is_audio ? DemuxerStream::AUDIO : DemuxerStream::VIDEO;
     data.access_units.resize(config_unit_index + 1);
 
     for (int i = 0; i < config_unit_index; ++i)
       data.access_units[i] = CreateAccessUnitWithData(is_audio, i, false);
@@ skipping 283 matching lines @@
   }
 
   bool IsRequestingDemuxerData(bool is_audio) {
     return GetMediaDecoderJob(is_audio)->is_requesting_demuxer_data_;
   }
 
   bool IsDrainingDecoder(bool is_audio) {
     return GetMediaDecoderJob(is_audio)->drain_decoder_;
   }
 
+ protected:
   base::MessageLoop message_loop_;
   MockMediaPlayerManager manager_;
   MockDemuxerAndroid* demuxer_;  // Owned by |player_|.
   MediaSourcePlayer player_;
 
   // Track whether a possibly async decoder callback test hook has run.
   bool decoder_callback_hook_executed_;
 
   // We need to keep the surface texture while the decoder is actively decoding.
   // Otherwise, it may trigger unexpected crashes on some devices. To switch
   // surfaces, tests need to create a new surface texture without releasing
   // their previous one. In CreateNextTextureAndSetVideoSurface(), we toggle
   // between two surface textures, only replacing the N-2 texture. Assumption is
   // that no more than N-1 texture is in use by decoder when
   // CreateNextTextureAndSetVideoSurface() is called.
   scoped_refptr<gfx::SurfaceTexture> surface_texture_a_;
   scoped_refptr<gfx::SurfaceTexture> surface_texture_b_;
   bool surface_texture_a_is_next_;
   int next_texture_id_;
 
+  bool verify_not_audible_is_called_;
+
   DISALLOW_COPY_AND_ASSIGN(MediaSourcePlayerTest);
 };
 
 TEST_F(MediaSourcePlayerTest, StartAudioDecoderWithValidConfig) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test audio codec will be created when valid configs and data are passed to
   // the audio decoder job.
   StartAudioDecoderJob();
   EXPECT_EQ(0, demuxer_->num_seek_requests());
@@ skipping 11 matching lines @@
   uint8 invalid_codec_data[] = { 0x00, 0xff, 0xff, 0xff, 0xff };
   configs.audio_extra_data.insert(configs.audio_extra_data.begin(),
                                  invalid_codec_data, invalid_codec_data + 4);
   Start(configs);
 
   // Decoder is not created after data is received.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
   EXPECT_FALSE(GetMediaCodecBridge(true));
 }
 
+// timav
+TEST_F(MediaSourcePlayerTest, AudioDecoderSetsAudibleState) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // No data arrived yet
+  EXPECT_FALSE(manager_.is_audible());
+
+  // Initialize decoder
+  StartAudioDecoderJob();
+  player_.SetVolume(1.0);
+
+  // Process frames until prerolling is done.
+  SeekPlayerWithAbort(true, base::TimeDelta::FromMilliseconds(100));
+  EXPECT_TRUE(IsPrerolling(true));
+  PrerollDecoderToTime(
+      true, base::TimeDelta(), base::TimeDelta::FromMilliseconds(100), false);
+  EXPECT_TRUE(IsPrerolling(false));
+
+  // Send more packets
+  PlayAudioForTimeInterval(base::TimeDelta::FromMilliseconds(150),
+                           base::TimeDelta::FromMilliseconds(220));
+
+  // The player should trigger audible status
+  EXPECT_TRUE(manager_.is_audible());
+
+  // The player release should report a non-audible state.
+  ReleasePlayer();
+  EXPECT_FALSE(manager_.is_audible());
+}
+
+TEST_F(MediaSourcePlayerTest, AudioDecoderRemovesAudibleStateWhenPaused) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // No data arrived yet
+  EXPECT_FALSE(manager_.is_audible());
+
+  // Initialize decoder
+  StartAudioDecoderJob();
+  player_.SetVolume(1.0);
+
+  // Process frames until prerolling is done.
+  SeekPlayerWithAbort(true, base::TimeDelta::FromMilliseconds(100));
+  EXPECT_TRUE(IsPrerolling(true));
+  PrerollDecoderToTime(
+      true, base::TimeDelta(), base::TimeDelta::FromMilliseconds(100), false);
+  EXPECT_TRUE(IsPrerolling(false));
+
+  // Send more packets
+  PlayAudioForTimeInterval(base::TimeDelta::FromMilliseconds(150),
+                           base::TimeDelta::FromMilliseconds(220));
+
+  // The player should trigger audible status
+  EXPECT_TRUE(manager_.is_audible());
+
+  // Pause the player
+  player_.Pause(true);
+
+  // Send more packets
+  PlayAudioForTimeInterval(base::TimeDelta::FromMilliseconds(240),
+                           base::TimeDelta::FromMilliseconds(280));
+
+  // The player should trigger audible status again
+  EXPECT_FALSE(manager_.is_audible());
+
+  player_.Release();
+}
+
+TEST_F(MediaSourcePlayerTest, AudioDecoderRemovesAudibleStateWhenIdle) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // No data arrived yet
+  EXPECT_FALSE(manager_.is_audible());
+
+  // Initialize decoder
+  StartAudioDecoderJob();
+  player_.SetVolume(1.0);
+
+  // Process frames until prerolling is done.
+  SeekPlayerWithAbort(true, base::TimeDelta::FromMilliseconds(100));
+  EXPECT_TRUE(IsPrerolling(true));
+  PrerollDecoderToTime(
+      true, base::TimeDelta(), base::TimeDelta::FromMilliseconds(100), false);
+  EXPECT_TRUE(IsPrerolling(false));
+
+  // Send more packets
+  PlayAudioForTimeInterval(base::TimeDelta::FromMilliseconds(150),
+                           base::TimeDelta::FromMilliseconds(220));
+
+  // The player should trigger audible status
+  EXPECT_TRUE(manager_.is_audible());
+
+  // Simulate the freeze on demuxer: wait for 300 ms
+  WaitForDelay(base::TimeDelta::FromMilliseconds(300));
+
+  // By this time the player should have reported
+  // that there is no audio.
+  EXPECT_FALSE(manager_.is_audible());
+
+  ReleasePlayer();
+}
+
 TEST_F(MediaSourcePlayerTest, StartVideoCodecWithValidSurface) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test video codec will not be created until data is received.
   StartVideoDecoderJob();
 
   // Set both an initial and a later video surface without receiving any
   // demuxed data yet.
   CreateNextTextureAndSetVideoSurface();
   EXPECT_FALSE(GetMediaCodecBridge(false));
@@ skipping 1449 matching lines @@
   // Wait for the metadata change.
   while(manager_.num_metadata_changes() == 1) {
     player_.OnDemuxerDataAvailable(data);
     WaitForVideoDecodeDone();
   }
   EXPECT_EQ(2, manager_.num_metadata_changes());
   WaitForVideoDecodeDone();
 }
 
 }  // namespace media