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 598 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)
         player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
-      else
+      else {

[wolenetz, 2014/06/06 23:28:07]

lint nit: put {} around clause prior to else to match clause formats before and
after else.

[qinmin, 2014/06/07 01:31:55]

Done.

         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());
 }
 
+TEST_F(MediaSourcePlayerTest, VideoDemuxerConfigChangeWithAdaptivePlayback) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that video config change notification results in creating a new

[wolenetz, 2014/06/06 23:28:07]

No new codec should have been created beyond the one used to decode the prefetch
media data prior to the kConfigChanged. The existing one was adaptive.

[qinmin, 2014/06/07 01:31:55]

Done.

+  // video codec without any browser seek.
+  StartConfigChange(false, true, 1, true);
+
+  // No browser seek should be needed.
+  EXPECT_TRUE(GetMediaCodecBridge(false));

[wolenetz, 2014/06/06 23:28:07]

We need to somehow verify the resulting codec bridge is the same as the one
prior to kConfigChanged. Any ideas how (without pointer comparison flakiness)?
Check that the original bridge never needed draining?

[qinmin, 2014/06/07 01:31:55]

we can use manager_.num_resources_requested().

On 2014/06/06 23:28:07, wolenetz wrote:

+  EXPECT_EQ(3, demuxer_->num_data_requests());
+  EXPECT_EQ(0, demuxer_->num_seek_requests());
+}
+
 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