Use cached Key frames to avoid browser seek

media/base/android/media_decoder_job.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 "media/base/android/media_decoder_job.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 92 matching lines @@
   if (HasData()) {
     DVLOG(1) << __FUNCTION__ << " : using previously received data";
     ui_task_runner_->PostTask(FROM_HERE, prefetch_cb);
     return;
   }
 
   DVLOG(1) << __FUNCTION__ << " : requesting data";
   RequestData(prefetch_cb);
 }
 
-bool MediaDecoderJob::Decode(
+MediaDecoderJob::MediaDecoderJobStatus MediaDecoderJob::Decode(
     base::TimeTicks start_time_ticks,
     base::TimeDelta start_presentation_timestamp,
     const DecoderCallback& callback) {
   DCHECK(decode_cb_.is_null());
   DCHECK(data_received_cb_.is_null());
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   if (!media_codec_bridge_ || need_to_reconfig_decoder_job_) {
     if (drain_decoder_)
       OnDecoderDrained();
-    need_to_reconfig_decoder_job_ = !CreateMediaCodecBridge();
+    MediaDecoderJobStatus status = CreateMediaCodecBridge();
+    need_to_reconfig_decoder_job_ = (status != STATUS_SUCCESS);
     skip_eos_enqueue_ = true;
     if (need_to_reconfig_decoder_job_)
-      return false;
+      return status;
   }
 
   decode_cb_ = callback;
 
   if (!HasData()) {
     RequestData(base::Bind(&MediaDecoderJob::DecodeCurrentAccessUnit,
                            base::Unretained(this),
                            start_time_ticks,
                            start_presentation_timestamp));
-    return true;
+    return STATUS_SUCCESS;
   }
 
   DecodeCurrentAccessUnit(start_time_ticks, start_presentation_timestamp);
-  return true;
+  return STATUS_SUCCESS;
 }
 
 void MediaDecoderJob::StopDecode() {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   DCHECK(is_decoding());
   stop_decode_pending_ = true;
 }
 
 bool MediaDecoderJob::OutputEOSReached() const {
   return !drain_decoder_ && output_eos_encountered_;
@@ skipping 47 matching lines @@
   release_resources_pending_ = true;
 }
 
 base::android::ScopedJavaLocalRef<jobject> MediaDecoderJob::GetMediaCrypto() {
   base::android::ScopedJavaLocalRef<jobject> media_crypto;
   if (drm_bridge_)
     media_crypto = drm_bridge_->GetMediaCrypto();
   return media_crypto;
 }
 
+bool MediaDecoderJob::SetCurrentFrameToPreviouslyCachedKeyFrame() {
+  const std::vector<AccessUnit>& access_units =
+      received_data_[current_demuxer_data_index_].access_units;
+  // If the current data chunk is empty, the player must be in an initial or
+  // seek state. The next access unit will always be a key frame.
+  if (access_units.size() == 0)
+    return true;
+
+  // Find key frame in all the access units the decoder have decoded,
+  // or is about to decode.
+  int i = std::min(access_unit_index_[current_demuxer_data_index_],
+                   access_units.size() - 1);
+  for (; i >= 0; --i) {
+    // Config change is always the last access unit, and it always come with
+    // a key frame afterwards.
+    if (access_units[i].status == DemuxerStream::kConfigChanged)
+      return true;
+    if (access_units[i].is_key_frame) {
+      access_unit_index_[current_demuxer_data_index_] = i;
+      return true;
+    }
+  }
+  return false;
+}
+
+
 void MediaDecoderJob::Release() {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
   // If the decoder job is still decoding, we cannot delete the job immediately.
   destroy_pending_ = is_decoding();
 
   request_data_cb_.Reset();
   data_received_cb_.Reset();
   decode_cb_.Reset();
@@ skipping 293 matching lines @@
   if (current_presentation_timestamp != kNoTimestamp() ||
       status == MEDIA_CODEC_OUTPUT_END_OF_STREAM) {
     prerolling_ = false;
   }
 
   switch (status) {
     case MEDIA_CODEC_OK:
     case MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER:
     case MEDIA_CODEC_OUTPUT_FORMAT_CHANGED:
     case MEDIA_CODEC_OUTPUT_END_OF_STREAM:
-      if (!input_eos_encountered_) {
-        CurrentDataConsumed(
-            CurrentAccessUnit().status == DemuxerStream::kConfigChanged);
+      if (!input_eos_encountered_)
         access_unit_index_[current_demuxer_data_index_]++;
-      }
       break;
 
     case MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER:
     case MEDIA_CODEC_INPUT_END_OF_STREAM:
     case MEDIA_CODEC_NO_KEY:
     case MEDIA_CODEC_ABORT:
     case MEDIA_CODEC_ERROR:
       // Do nothing.
       break;
 
@@ skipping 46 matching lines @@
 }
 
 void MediaDecoderJob::RequestCurrentChunkIfEmpty() {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   DCHECK(HasData());
   if (!NoAccessUnitsRemainingInChunk(true))
     return;
 
   // Requests new data if the the last access unit of the next chunk is not EOS.
   current_demuxer_data_index_ = inactive_demuxer_data_index();
-  const AccessUnit last_access_unit =
+  const AccessUnit& last_access_unit =
       received_data_[current_demuxer_data_index_].access_units.back();
   if (!last_access_unit.is_end_of_stream &&
       last_access_unit.status != DemuxerStream::kAborted) {
     RequestData(base::Closure());
   }
 }
 
 void MediaDecoderJob::InitializeReceivedData() {
   for (size_t i = 0; i < 2; ++i) {
     received_data_[i] = DemuxerData();
     access_unit_index_[i] = 0;
   }
 }
 
 void MediaDecoderJob::OnDecoderDrained() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   DCHECK(drain_decoder_);
 
   input_eos_encountered_ = false;
   output_eos_encountered_ = false;
   drain_decoder_ = false;
   ReleaseMediaCodecBridge();
   // Increase the access unit index so that the new decoder will not handle
   // the config change again.
   access_unit_index_[current_demuxer_data_index_]++;
-  CurrentDataConsumed(true);
 }
 
-bool MediaDecoderJob::CreateMediaCodecBridge() {
+MediaDecoderJob::MediaDecoderJobStatus
+    MediaDecoderJob::CreateMediaCodecBridge() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   DCHECK(decode_cb_.is_null());
 
   if (!HasStream()) {
     ReleaseMediaCodecBridge();
-    return false;
+    return STATUS_FAILURE;
   }
 
   // Create |media_codec_bridge_| only if config changes.
   if (media_codec_bridge_ && !need_to_reconfig_decoder_job_)
-    return true;
+    return STATUS_SUCCESS;
 
   base::android::ScopedJavaLocalRef<jobject> media_crypto = GetMediaCrypto();
   if (is_content_encrypted_ && media_crypto.is_null())
-    return false;
+    return STATUS_FAILURE;
 
   ReleaseMediaCodecBridge();
   DVLOG(1) << __FUNCTION__ << " : creating new media codec bridge";
 
   return CreateMediaCodecBridgeInternal();
 }
 
 bool MediaDecoderJob::IsCodecReconfigureNeeded(
     const DemuxerConfigs& configs) const {
   if (!AreDemuxerConfigsChanged(configs))
     return false;
   return true;
 }
 
 void MediaDecoderJob::OnOutputFormatChanged() {}
 
 bool MediaDecoderJob::UpdateOutputFormat() {
   return false;
 }
 
 void MediaDecoderJob::ReleaseMediaCodecBridge() {
   if (!media_codec_bridge_)
     return;
 
   media_codec_bridge_.reset();
   input_buf_index_ = -1;
 }
 
 }  // namespace media