Android: Propagate sample rate change to audio decoder job

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/debug/trace_event.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 427 matching lines @@
            status != MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER);
 
   if (status != MEDIA_CODEC_OK) {
     callback.Run(status, kNoTimestamp(), kNoTimestamp());
     return;
   }
 
   // TODO(xhwang/qinmin): This logic is correct but strange. Clean it up.
   if (output_eos_encountered_)
     status = MEDIA_CODEC_OUTPUT_END_OF_STREAM;
-  else if (has_format_change)
+  else if (has_format_change && UpdateOutputFormat())

[gunsch, 2015/01/12 16:30:51]

What's the reason for moving UpdateOutputFormat up here?

[kjoswiak, 2015/01/12 19:44:48]

Short story, it crashes without this change.

Long story, when we get the format changed information, it means the buffers we
just got from decoder have new format. If this call is where it was previously,
in the OnDecodeComplete function, we only update the internal state after the
Decode process. However, we now need this information to be up to date during
the decode (specifically before we run ReleaseOutputBuffer, which is where we
render the buffers and do the timestamp helper stuff). Tracking these frames at
an incorrect rate, and then suddenly on the next call at the correct one,
happens to screw up the state enough to cause check failure. I think there's
technically another fix I could do to make the tracking more robust, but I think
its best we ensure we are always working with correct information =)

Also shouldn't break anything else, as https://codereview.chromium.org/730133003
almost reduced this function to a no-op video side, or at very least negated
what appears to be the original intent of this code path.

     status = MEDIA_CODEC_OUTPUT_FORMAT_CHANGED;
 
   bool render_output  = presentation_timestamp >= preroll_timestamp_ &&
       (status != MEDIA_CODEC_OUTPUT_END_OF_STREAM || size != 0u);
   base::TimeDelta time_to_render;
   DCHECK(!start_time_ticks.is_null());
   if (render_output && ComputeTimeToRender()) {
     time_to_render = presentation_timestamp - (base::TimeTicks::Now() -
         start_time_ticks + start_presentation_timestamp);
   }
@@ skipping 77 matching lines @@
       DCHECK(false) << "Invalid output status";
       break;
   };
 
   if (status == MEDIA_CODEC_OUTPUT_END_OF_STREAM && drain_decoder_) {
     OnDecoderDrained();
     status = MEDIA_CODEC_OK;
   }
 
   if (status == MEDIA_CODEC_OUTPUT_FORMAT_CHANGED) {
-    if (UpdateOutputFormat())
-      config_changed_cb_.Run();
+    config_changed_cb_.Run();
     status = MEDIA_CODEC_OK;
   }
 
   if (release_resources_pending_) {
     ReleaseMediaCodecBridge();
     release_resources_pending_ = false;
     if (drain_decoder_)
       OnDecoderDrained();
   }
 
@@ skipping 84 matching lines @@
   return CreateMediaCodecBridgeInternal();
 }
 
 bool MediaDecoderJob::IsCodecReconfigureNeeded(
     const DemuxerConfigs& configs) const {
   if (!AreDemuxerConfigsChanged(configs))
     return false;
   return true;
 }
 
-bool MediaDecoderJob::UpdateOutputFormat() {
-  return false;
-}
-
 void MediaDecoderJob::ReleaseMediaCodecBridge() {
   if (!media_codec_bridge_)
     return;
 
   media_codec_bridge_.reset();
   input_buf_index_ = -1;
 }
 
 }  // namespace media