support adaptive playback in MSE

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 584 matching lines @@
               demuxer_->num_browser_seek_requests());
     EXPECT_EQ(expected_num_data_requests, demuxer_->num_data_requests());
   }
 
   // Creates a new media codec bridge and feeds it data ending with a
   // |kConfigChanged| access unit. If |config_unit_in_prefetch| is true, sends
   // feeds the config change AU in response to the job's first read request
   // (prefetch). If false, regular data is fed and decoded prior to feeding the
   // config change AU in response to the second data request (after prefetch
   // completed). |config_unit_index| controls which access unit is
-  // |kConfigChanged|.
+  // |kConfigChanged|. If |enable_adaptive_playback| is true, config change will
+  // not cause the decoder to recreate the media codec bridge. Otherwise, the
+  // decoder has to drain all its data before recreating the new codec.
   void SendConfigChangeToDecoder(bool is_audio,
                                  bool config_unit_in_prefetch,
-                                 int config_unit_index) {
+                                 int config_unit_index,
+                                 bool enable_adaptive_playback) {
     EXPECT_FALSE(GetMediaCodecBridge(is_audio));
     if (is_audio) {
       StartAudioDecoderJob();
     } else {
       CreateNextTextureAndSetVideoSurface();
       StartVideoDecoderJob();
     }
 
     int expected_num_data_requests = demuxer_->num_data_requests();
     // Feed and decode a standalone access unit so the player exits prefetch.
     if (!config_unit_in_prefetch) {
-      if (is_audio)
+      if (is_audio) {
         player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
-      else
+      } else {
         player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
+        EnableAdaptiveVideoPlayback(enable_adaptive_playback);
+      }
 
       WaitForDecodeDone(is_audio, !is_audio);
 
       // We should have completed the prefetch phase at this point.
       expected_num_data_requests++;
       EXPECT_EQ(expected_num_data_requests, demuxer_->num_data_requests());
     }
 
     DemuxerConfigs configs = is_audio ?
         CreateAudioDemuxerConfigs(kCodecAAC, false) :
         CreateVideoDemuxerConfigs(true);
     // Feed and decode access units with data for any units prior to
     // |config_unit_index|, and a |kConfigChanged| unit at that index.
     // Player should prepare to reconfigure the decoder job, and should request
     // new demuxer configs.
     player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckWithConfigChanged(
         is_audio, config_unit_index, configs));
 
     expected_num_data_requests++;
     EXPECT_EQ(expected_num_data_requests, demuxer_->num_data_requests());
     if (is_audio)
       player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
     else
       player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
+
+    // If the adaptive playback setting was not passed to the MediaCodecBridge
+    // earlier, do it here.
+    if (config_unit_in_prefetch && !is_audio)
+      EnableAdaptiveVideoPlayback(enable_adaptive_playback);
   }
 
   // Send a config change to the decoder job and drain the decoder so that the
   // config change is processed.
   void StartConfigChange(bool is_audio,
                          bool config_unit_in_prefetch,
-                         int config_unit_index) {
+                         int config_unit_index,
+                         bool enable_adaptive_playback) {
     SendConfigChangeToDecoder(is_audio, config_unit_in_prefetch,
-                              config_unit_index);
-    EXPECT_EQ(!config_unit_in_prefetch && config_unit_index == 0,
-              IsDrainingDecoder(is_audio));
+                              config_unit_index, enable_adaptive_playback);
+
+    EXPECT_EQ(!config_unit_in_prefetch && !enable_adaptive_playback &&
+              config_unit_index == 0, IsDrainingDecoder(is_audio));
     int expected_num_data_requests = demuxer_->num_data_requests();
     // Run until decoder starts to request new data.
     while (demuxer_->num_data_requests() == expected_num_data_requests)
       message_loop_.RunUntilIdle();
     EXPECT_FALSE(IsDrainingDecoder(is_audio));
   }
 
+  void EnableAdaptiveVideoPlayback(bool enable) {
+    EXPECT_TRUE(GetMediaCodecBridge(false));
+    static_cast<VideoCodecBridge*>(GetMediaCodecBridge(false))->
+        set_adaptive_playback_supported_for_testing(
+            enable ? 1 : 0);
+  }
+
   void CreateNextTextureAndSetVideoSurface() {
     gfx::SurfaceTexture* surface_texture;
     if (surface_texture_a_is_next_) {
       surface_texture_a_ = gfx::SurfaceTexture::Create(next_texture_id_++);
       surface_texture = surface_texture_a_.get();
     } else {
       surface_texture_b_ = gfx::SurfaceTexture::Create(next_texture_id_++);
       surface_texture = surface_texture_b_.get();
     }
 
@@ skipping 962 matching lines @@
 
   // Test that the player allows simultaneous audio and video config change,
   // such as might occur during OnPrefetchDone() if next access unit for both
   // audio and video jobs is |kConfigChanged|.
   CreateNextTextureAndSetVideoSurface();
   Start(CreateAudioVideoDemuxerConfigs());
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
   EXPECT_TRUE(GetMediaCodecBridge(true));
   EXPECT_TRUE(GetMediaCodecBridge(false));
+  EnableAdaptiveVideoPlayback(false);
   WaitForAudioVideoDecodeDone();
 
   // Simulate audio |kConfigChanged| prefetched as standalone access unit.
   DemuxerConfigs audio_configs = CreateAudioDemuxerConfigs(kCodecVorbis, true);
   player_.OnDemuxerDataAvailable(
       CreateReadFromDemuxerAckWithConfigChanged(true, 0, audio_configs));
 
   // Simulate video |kConfigChanged| prefetched as standalone access unit.
   player_.OnDemuxerDataAvailable(
       CreateReadFromDemuxerAckWithConfigChanged(
           false, 0, CreateVideoDemuxerConfigs(true)));
   EXPECT_EQ(6, demuxer_->num_data_requests());
   EXPECT_TRUE(IsDrainingDecoder(true));
   EXPECT_TRUE(IsDrainingDecoder(false));
 
   // Waiting for decoder to finish draining.
   while (IsDrainingDecoder(true) || IsDrainingDecoder(false))
     message_loop_.RunUntilIdle();
 }
 
+TEST_F(MediaSourcePlayerTest,
+       SimultaneousAudioVideoConfigChangeWithAdaptivePlayback) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that the player allows simultaneous audio and video config change with
+  // adaptive video playback enabled.
+  CreateNextTextureAndSetVideoSurface();
+  Start(CreateAudioVideoDemuxerConfigs());
+  player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
+  player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
+  EXPECT_TRUE(GetMediaCodecBridge(true));
+  EXPECT_TRUE(GetMediaCodecBridge(false));
+  EnableAdaptiveVideoPlayback(true);
+  WaitForAudioVideoDecodeDone();
+
+  // Simulate audio |kConfigChanged| prefetched as standalone access unit.
+  DemuxerConfigs audio_configs = CreateAudioDemuxerConfigs(kCodecVorbis, true);
+  player_.OnDemuxerDataAvailable(
+      CreateReadFromDemuxerAckWithConfigChanged(true, 0, audio_configs));
+
+  // Simulate video |kConfigChanged| prefetched as standalone access unit.
+  player_.OnDemuxerDataAvailable(
+      CreateReadFromDemuxerAckWithConfigChanged(
+          false, 0, CreateVideoDemuxerConfigs(true)));
+  EXPECT_EQ(6, demuxer_->num_data_requests());
+  EXPECT_TRUE(IsDrainingDecoder(true));
+  EXPECT_FALSE(IsDrainingDecoder(false));
+
+  // Waiting for audio decoder to finish draining.
+  while (IsDrainingDecoder(true))
+    message_loop_.RunUntilIdle();
+}
+
 TEST_F(MediaSourcePlayerTest, DemuxerConfigRequestedIfInPrefetchUnit0) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that the player detects need for and requests demuxer configs if
   // the |kConfigChanged| unit is the very first unit in the set of units
   // received in OnDemuxerDataAvailable() ostensibly while
   // |PREFETCH_DONE_EVENT_PENDING|.
-  StartConfigChange(true, true, 0);
+  StartConfigChange(true, true, 0, false);
 }
 
 TEST_F(MediaSourcePlayerTest, DemuxerConfigRequestedIfInPrefetchUnit1) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that the player detects need for and requests demuxer configs if
   // the |kConfigChanged| unit is not the first unit in the set of units
   // received in OnDemuxerDataAvailable() ostensibly while
   // |PREFETCH_DONE_EVENT_PENDING|.
-  StartConfigChange(true, true, 1);
+  StartConfigChange(true, true, 1, false);
 }
 
 TEST_F(MediaSourcePlayerTest, DemuxerConfigRequestedIfInUnit0AfterPrefetch) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that the player detects need for and requests demuxer configs if
   // the |kConfigChanged| unit is the very first unit in the set of units
   // received in OnDemuxerDataAvailable() from data requested ostensibly while
   // not prefetching.
-  StartConfigChange(true, false, 0);
+  StartConfigChange(true, false, 0, false);
 }
 
 TEST_F(MediaSourcePlayerTest, DemuxerConfigRequestedIfInUnit1AfterPrefetch) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that the player detects need for and requests demuxer configs if
   // the |kConfigChanged| unit is not the first unit in the set of units
   // received in OnDemuxerDataAvailable() from data requested ostensibly while
   // not prefetching.
-  StartConfigChange(true, false, 1);
+  StartConfigChange(true, false, 1, false);
 }
 
 TEST_F(MediaSourcePlayerTest, BrowserSeek_PrerollAfterBrowserSeek) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test decoder job will preroll the media to the actual seek position
   // resulting from a browser seek.
   BrowserSeekPlayer(false);
 
   // Simulate browser seek is done, but to a later time than was requested.
   EXPECT_LT(player_.GetCurrentTime().InMillisecondsF(), 100);
   player_.OnDemuxerSeekDone(base::TimeDelta::FromMilliseconds(100));
   // Because next AU is not I-frame, MediaCodecBridge will not be recreated.
   EXPECT_FALSE(GetMediaCodecBridge(false));
   EXPECT_EQ(100.0, player_.GetCurrentTime().InMillisecondsF());
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
   EXPECT_EQ(3, demuxer_->num_data_requests());
 
   PrerollDecoderToTime(
       false, base::TimeDelta(), base::TimeDelta::FromMilliseconds(100));
 }
 
 TEST_F(MediaSourcePlayerTest, VideoDemuxerConfigChange) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that video config change notification results in creating a new
   // video codec without any browser seek.
-  StartConfigChange(false, true, 1);
+  StartConfigChange(false, true, 1, false);
 
   // New video codec should have been created and configured, without any
   // browser seek.
   EXPECT_TRUE(GetMediaCodecBridge(false));
   EXPECT_EQ(3, demuxer_->num_data_requests());
   EXPECT_EQ(0, demuxer_->num_seek_requests());
+
+  // 2 codecs should have been created, one before the config change, and one
+  // after it.
+  EXPECT_EQ(2, manager_.num_resources_requested());
+  EXPECT_EQ(1, manager_.num_resources_released());
+}
+
+TEST_F(MediaSourcePlayerTest, VideoDemuxerConfigChangeWithAdaptivePlayback) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that if codec supports adaptive playback, no new codec should be
+  // created beyond the one used to decode the prefetch media data prior to
+  // the kConfigChanged.
+  StartConfigChange(false, true, 1, true);
+
+  // No browser seek should be needed.
+  EXPECT_TRUE(GetMediaCodecBridge(false));
+  EXPECT_EQ(3, demuxer_->num_data_requests());
+  EXPECT_EQ(0, demuxer_->num_seek_requests());
+
+  // Only 1 codec should have been created so far.
+  EXPECT_EQ(1, manager_.num_resources_requested());
 }
 
 TEST_F(MediaSourcePlayerTest, DecoderDrainInterruptedBySeek) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test if a decoder is being drained while receiving a seek request, draining
   // is canceled.
-  SendConfigChangeToDecoder(true, false, 0);
+  SendConfigChangeToDecoder(true, false, 0, false);
   EXPECT_TRUE(IsDrainingDecoder(true));
 
   player_.SeekTo(base::TimeDelta::FromMilliseconds(100));
   WaitForAudioDecodeDone();
   EXPECT_FALSE(IsDrainingDecoder(true));
   player_.OnDemuxerSeekDone(kNoTimestamp());
 
   EXPECT_EQ(1, demuxer_->num_seek_requests());
   EXPECT_EQ(4, demuxer_->num_data_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, DecoderDrainInterruptedByRelease) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test if a decoder is being drained while receiving a release request,
   // draining is canceled.
-  SendConfigChangeToDecoder(true, false, 0);
+  SendConfigChangeToDecoder(true, false, 0, false);
   EXPECT_TRUE(IsDrainingDecoder(true));
 
   ReleasePlayer();
   WaitForAudioDecodeDone();
   EXPECT_EQ(3, demuxer_->num_data_requests());
   EXPECT_FALSE(IsDrainingDecoder(true));
 
   EXPECT_FALSE(GetMediaCodecBridge(true));
   EXPECT_FALSE(player_.IsPlaying());
 
   player_.Start();
   EXPECT_TRUE(player_.IsPlaying());
   EXPECT_EQ(3, demuxer_->num_data_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, DecoderDrainInterruptedBySurfaceChange) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test if a video decoder is being drained while surface changes, draining
   // is canceled.
-  SendConfigChangeToDecoder(false, false, 0);
+  SendConfigChangeToDecoder(false, false, 0, false);
   EXPECT_TRUE(IsDrainingDecoder(false));
 
   CreateNextTextureAndSetVideoSurface();
   WaitForVideoDecodeDone();
 
   EXPECT_FALSE(IsDrainingDecoder(false));
   EXPECT_FALSE(GetMediaCodecBridge(false));
   EXPECT_TRUE(player_.IsPlaying());
   EXPECT_EQ(3, demuxer_->num_data_requests());
 
@@ skipping 185 matching lines @@
   // No further seek should have been requested since before Release(), above.
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, ConfigChangedThenReleaseThenStart) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test if Release() occurs after |kConfigChanged| is processed, new data
   // requested of demuxer, and the requested data arrive before the next
   // Start(), then the player starts to decode the new data without any seek.
-  StartConfigChange(true, true, 0);
+  StartConfigChange(true, true, 0, false);
   ReleasePlayer();
 
   EXPECT_TRUE(GetMediaCodecBridge(true));
   EXPECT_FALSE(player_.IsPlaying());
   EXPECT_EQ(3, demuxer_->num_data_requests());
   player_.OnDemuxerDataAvailable(
         CreateReadFromDemuxerAckWithConfigChanged(
             true, 4, CreateAudioDemuxerConfigs(kCodecVorbis, false)));
   WaitForAudioDecodeDone();
   EXPECT_FALSE(GetMediaCodecBridge(true));
@@ skipping 113 matching lines @@
 
   DemuxerConfigs configs = CreateAudioDemuxerConfigs(kCodecVorbis, true);
   DemuxerData data = CreateReadFromDemuxerAckWithConfigChanged(
       true, 0, configs);
   player_.OnDemuxerDataAvailable(data);
   WaitForAudioDecodeDone();
   DecodeAudioDataUntilOutputBecomesAvailable();
 }
 
 }  // namespace media