Home | History | Annotate | Download | only in android 
      1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "media/base/android/media_source_player.h"
      6 
      7 #include "base/android/jni_android.h"
      8 #include "base/android/jni_string.h"
      9 #include "base/basictypes.h"
     10 #include "base/bind.h"
     11 #include "base/lazy_instance.h"
     12 #include "base/logging.h"
     13 #include "base/message_loop/message_loop.h"
     14 #include "base/threading/thread.h"
     15 #include "media/base/android/media_codec_bridge.h"
     16 #include "media/base/android/media_drm_bridge.h"
     17 #include "media/base/android/media_player_manager.h"
     18 #include "media/base/audio_timestamp_helper.h"
     19 
     20 namespace {
     21 
     22 // Timeout value for media codec operations. Because the first
     23 // DequeInputBuffer() can take about 150 milliseconds, use 250 milliseconds
     24 // here. See b/9357571.
     25 const int kMediaCodecTimeoutInMilliseconds = 250;
     26 
     27 // Use 16bit PCM for audio output. Keep this value in sync with the output
     28 // format we passed to AudioTrack in MediaCodecBridge.
     29 const int kBytesPerAudioOutputSample = 2;
     30 
     31 class DecoderThread : public base::Thread {
     32  public:
     33   virtual ~DecoderThread() {}
     34  protected:
     35   DecoderThread(const char* name) : base::Thread(name) { Start(); }
     36 };
     37 
     38 class AudioDecoderThread : public DecoderThread {
     39  public:
     40   AudioDecoderThread() : DecoderThread("MediaSource_AudioDecoderThread") {}
     41 };
     42 
     43 class VideoDecoderThread : public DecoderThread {
     44  public:
     45   VideoDecoderThread() : DecoderThread("MediaSource_VideoDecoderThread") {}
     46 };
     47 
     48 // TODO(qinmin): Check if it is tolerable to use worker pool to handle all the
     49 // decoding tasks so that we don't need the global threads here.
     50 // http://crbug.com/245750
     51 base::LazyInstance<AudioDecoderThread>::Leaky
     52     g_audio_decoder_thread = LAZY_INSTANCE_INITIALIZER;
     53 
     54 base::LazyInstance<VideoDecoderThread>::Leaky
     55     g_video_decoder_thread = LAZY_INSTANCE_INITIALIZER;
     56 
     57 }
     58 
     59 namespace media {
     60 
     61 MediaDecoderJob::MediaDecoderJob(
     62     const scoped_refptr<base::MessageLoopProxy>& decoder_loop,
     63     MediaCodecBridge* media_codec_bridge,
     64     bool is_audio)
     65     : ui_loop_(base::MessageLoopProxy::current()),
     66       decoder_loop_(decoder_loop),
     67       media_codec_bridge_(media_codec_bridge),
     68       needs_flush_(false),
     69       is_audio_(is_audio),
     70       input_eos_encountered_(false),
     71       weak_this_(this),
     72       is_decoding_(false) {
     73 }
     74 
     75 MediaDecoderJob::~MediaDecoderJob() {}
     76 
     77 // Class for managing audio decoding jobs.
     78 class AudioDecoderJob : public MediaDecoderJob {
     79  public:
     80   virtual ~AudioDecoderJob() {}
     81 
     82   static AudioDecoderJob* Create(
     83       const AudioCodec audio_codec, int sample_rate, int channel_count,
     84       const uint8* extra_data, size_t extra_data_size, jobject media_crypto);
     85 
     86   void SetVolume(double volume);
     87 
     88  private:
     89   AudioDecoderJob(MediaCodecBridge* media_codec_bridge);
     90 };
     91 
     92 // Class for managing video decoding jobs.
     93 class VideoDecoderJob : public MediaDecoderJob {
     94  public:
     95   virtual ~VideoDecoderJob() {}
     96 
     97   static VideoDecoderJob* Create(
     98       const VideoCodec video_codec, const gfx::Size& size, jobject surface,
     99       jobject media_crypto);
    100 
    101  private:
    102   VideoDecoderJob(MediaCodecBridge* media_codec_bridge);
    103 };
    104 
    105 void MediaDecoderJob::Decode(
    106     const AccessUnit& unit,
    107     const base::TimeTicks& start_time_ticks,
    108     const base::TimeDelta& start_presentation_timestamp,
    109     const MediaDecoderJob::DecoderCallback& callback) {
    110   DCHECK(!is_decoding_);
    111   DCHECK(ui_loop_->BelongsToCurrentThread());
    112   is_decoding_ = true;
    113   decoder_loop_->PostTask(FROM_HERE, base::Bind(
    114       &MediaDecoderJob::DecodeInternal, base::Unretained(this), unit,
    115       start_time_ticks, start_presentation_timestamp, needs_flush_,
    116       callback));
    117   needs_flush_ = false;
    118 }
    119 
    120 MediaDecoderJob::DecodeStatus MediaDecoderJob::QueueInputBuffer(
    121     const AccessUnit& unit) {
    122   base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(
    123       kMediaCodecTimeoutInMilliseconds);
    124   int input_buf_index = media_codec_bridge_->DequeueInputBuffer(timeout);
    125   if (input_buf_index == MediaCodecBridge::INFO_MEDIA_CODEC_ERROR)
    126     return DECODE_FAILED;
    127   if (input_buf_index == MediaCodecBridge::INFO_TRY_AGAIN_LATER)
    128     return DECODE_TRY_ENQUEUE_INPUT_AGAIN_LATER;
    129 
    130   // TODO(qinmin): skip frames if video is falling far behind.
    131   DCHECK(input_buf_index >= 0);
    132   if (unit.end_of_stream || unit.data.empty()) {
    133     media_codec_bridge_->QueueEOS(input_buf_index);
    134     return DECODE_INPUT_END_OF_STREAM;
    135   }
    136   if (unit.key_id.empty()) {
    137     media_codec_bridge_->QueueInputBuffer(
    138         input_buf_index, &unit.data[0], unit.data.size(), unit.timestamp);
    139   } else {
    140     if (unit.iv.empty() || unit.subsamples.empty()) {
    141       LOG(ERROR) << "The access unit doesn't have iv or subsamples while it "
    142                  << "has key IDs!";
    143       return DECODE_FAILED;
    144     }
    145     media_codec_bridge_->QueueSecureInputBuffer(
    146         input_buf_index, &unit.data[0], unit.data.size(),
    147         reinterpret_cast<const uint8*>(&unit.key_id[0]), unit.key_id.size(),
    148         reinterpret_cast<const uint8*>(&unit.iv[0]), unit.iv.size(),
    149         &unit.subsamples[0], unit.subsamples.size(), unit.timestamp);
    150   }
    151 
    152   return DECODE_SUCCEEDED;
    153 }
    154 
    155 void MediaDecoderJob::DecodeInternal(
    156     const AccessUnit& unit,
    157     const base::TimeTicks& start_time_ticks,
    158     const base::TimeDelta& start_presentation_timestamp,
    159     bool needs_flush,
    160     const MediaDecoderJob::DecoderCallback& callback) {
    161   if (needs_flush) {
    162     DVLOG(1) << "DecodeInternal needs flush.";
    163     input_eos_encountered_ = false;
    164     int reset_status = media_codec_bridge_->Reset();
    165     if (0 != reset_status) {
    166       ui_loop_->PostTask(FROM_HERE, base::Bind(
    167           callback, DECODE_FAILED, start_presentation_timestamp, 0));
    168       return;
    169     }
    170   }
    171 
    172   DecodeStatus decode_status = DECODE_INPUT_END_OF_STREAM;
    173   if (!input_eos_encountered_) {
    174     decode_status = QueueInputBuffer(unit);
    175     if (decode_status == DECODE_INPUT_END_OF_STREAM) {
    176       input_eos_encountered_ = true;
    177     } else if (decode_status != DECODE_SUCCEEDED) {
    178       ui_loop_->PostTask(FROM_HERE,
    179                          base::Bind(callback, decode_status,
    180                                     start_presentation_timestamp, 0));
    181       return;
    182     }
    183   }
    184 
    185   size_t offset = 0;
    186   size_t size = 0;
    187   base::TimeDelta presentation_timestamp;
    188   bool end_of_stream = false;
    189 
    190   base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(
    191       kMediaCodecTimeoutInMilliseconds);
    192   int outputBufferIndex = media_codec_bridge_->DequeueOutputBuffer(
    193       timeout, &offset, &size, &presentation_timestamp, &end_of_stream);
    194 
    195   if (end_of_stream)
    196     decode_status = DECODE_OUTPUT_END_OF_STREAM;
    197   switch (outputBufferIndex) {
    198     case MediaCodecBridge::INFO_OUTPUT_BUFFERS_CHANGED:
    199       DCHECK(decode_status != DECODE_INPUT_END_OF_STREAM);
    200       media_codec_bridge_->GetOutputBuffers();
    201       break;
    202     case MediaCodecBridge::INFO_OUTPUT_FORMAT_CHANGED:
    203       DCHECK(decode_status != DECODE_INPUT_END_OF_STREAM);
    204       // TODO(qinmin): figure out what we should do if format changes.
    205       decode_status = DECODE_FORMAT_CHANGED;
    206       break;
    207     case MediaCodecBridge::INFO_TRY_AGAIN_LATER:
    208       decode_status = DECODE_TRY_DEQUEUE_OUTPUT_AGAIN_LATER;
    209       break;
    210     case MediaCodecBridge::INFO_MEDIA_CODEC_ERROR:
    211       decode_status = DECODE_FAILED;
    212       break;
    213     default:
    214       DCHECK_LE(0, outputBufferIndex);
    215       base::TimeDelta time_to_render;
    216       DCHECK(!start_time_ticks.is_null());
    217       if (!is_audio_) {
    218         time_to_render = presentation_timestamp - (base::TimeTicks::Now() -
    219             start_time_ticks + start_presentation_timestamp);
    220       }
    221       if (time_to_render >= base::TimeDelta()) {
    222         base::MessageLoop::current()->PostDelayedTask(
    223             FROM_HERE,
    224             base::Bind(&MediaDecoderJob::ReleaseOutputBuffer,
    225                        weak_this_.GetWeakPtr(), outputBufferIndex, size,
    226                        presentation_timestamp, callback, decode_status),
    227             time_to_render);
    228       } else {
    229         // TODO(qinmin): The codec is lagging behind, need to recalculate the
    230         // |start_presentation_timestamp_| and |start_time_ticks_|.
    231         DVLOG(1) << (is_audio_ ? "audio " : "video ")
    232             << "codec is lagging behind :" << time_to_render.InMicroseconds();
    233         ReleaseOutputBuffer(outputBufferIndex, size, presentation_timestamp,
    234                             callback, decode_status);
    235       }
    236       return;
    237   }
    238   ui_loop_->PostTask(FROM_HERE, base::Bind(
    239       callback, decode_status, start_presentation_timestamp, 0));
    240 }
    241 
    242 void MediaDecoderJob::ReleaseOutputBuffer(
    243     int outputBufferIndex, size_t size,
    244     const base::TimeDelta& presentation_timestamp,
    245     const MediaDecoderJob::DecoderCallback& callback, DecodeStatus status) {
    246   // TODO(qinmin): Refactor this function. Maybe AudioDecoderJob should provide
    247   // its own ReleaseOutputBuffer().
    248   if (is_audio_) {
    249     static_cast<AudioCodecBridge*>(media_codec_bridge_.get())->PlayOutputBuffer(
    250         outputBufferIndex, size);
    251   }
    252   if (status != DECODE_OUTPUT_END_OF_STREAM || size != 0u)
    253     media_codec_bridge_->ReleaseOutputBuffer(outputBufferIndex, !is_audio_);
    254   ui_loop_->PostTask(FROM_HERE, base::Bind(
    255       callback, status, presentation_timestamp, is_audio_ ? size : 0));
    256 }
    257 
    258 void MediaDecoderJob::OnDecodeCompleted() {
    259   DCHECK(ui_loop_->BelongsToCurrentThread());
    260   is_decoding_ = false;
    261 }
    262 
    263 void MediaDecoderJob::Flush() {
    264   // Do nothing, flush when the next Decode() happens.
    265   needs_flush_ = true;
    266 }
    267 
    268 void MediaDecoderJob::Release() {
    269   // If |decoding_| is false, there is nothing running on the decoder thread.
    270   // So it is safe to delete the MediaDecoderJob on the UI thread. However,
    271   // if we post a task to the decoder thread to delete object, then we cannot
    272   // immediately pass the surface to a new MediaDecoderJob instance because
    273   // the java surface is still owned by the old object. New decoder creation
    274   // will be blocked on the UI thread until the previous decoder gets deleted.
    275   // This introduces extra latency during config changes, and makes the logic in
    276   // MediaSourcePlayer more complicated.
    277   //
    278   // TODO(qinmin): Figure out the logic to passing the surface to a new
    279   // MediaDecoderJob instance after the previous one gets deleted on the decoder
    280   // thread.
    281   if (is_decoding_ && !decoder_loop_->BelongsToCurrentThread()) {
    282     DCHECK(ui_loop_->BelongsToCurrentThread());
    283     decoder_loop_->DeleteSoon(FROM_HERE, this);
    284   } else {
    285     delete this;
    286   }
    287 }
    288 
    289 VideoDecoderJob* VideoDecoderJob::Create(
    290     const VideoCodec video_codec, const gfx::Size& size, jobject surface,
    291     jobject media_crypto) {
    292   scoped_ptr<VideoCodecBridge> codec(VideoCodecBridge::Create(video_codec));
    293   if (codec && codec->Start(video_codec, size, surface, media_crypto))
    294     return new VideoDecoderJob(codec.release());
    295   return NULL;
    296 }
    297 
    298 VideoDecoderJob::VideoDecoderJob(MediaCodecBridge* media_codec_bridge)
    299     : MediaDecoderJob(g_video_decoder_thread.Pointer()->message_loop_proxy(),
    300                       media_codec_bridge,
    301                       false) {}
    302 
    303 AudioDecoderJob* AudioDecoderJob::Create(
    304     const AudioCodec audio_codec,
    305     int sample_rate,
    306     int channel_count,
    307     const uint8* extra_data,
    308     size_t extra_data_size,
    309     jobject media_crypto) {
    310   scoped_ptr<AudioCodecBridge> codec(AudioCodecBridge::Create(audio_codec));
    311   if (codec && codec->Start(audio_codec, sample_rate, channel_count, extra_data,
    312                             extra_data_size, true, media_crypto)) {
    313     return new AudioDecoderJob(codec.release());
    314   }
    315   return NULL;
    316 }
    317 
    318 AudioDecoderJob::AudioDecoderJob(MediaCodecBridge* media_codec_bridge)
    319     : MediaDecoderJob(g_audio_decoder_thread.Pointer()->message_loop_proxy(),
    320                       media_codec_bridge,
    321                       true) {}
    322 
    323 void AudioDecoderJob::SetVolume(double volume) {
    324   static_cast<AudioCodecBridge*>(media_codec_bridge_.get())->SetVolume(volume);
    325 }
    326 
    327 MediaSourcePlayer::MediaSourcePlayer(
    328     int player_id,
    329     MediaPlayerManager* manager)
    330     : MediaPlayerAndroid(player_id, manager),
    331       pending_event_(NO_EVENT_PENDING),
    332       seek_request_id_(0),
    333       width_(0),
    334       height_(0),
    335       audio_codec_(kUnknownAudioCodec),
    336       video_codec_(kUnknownVideoCodec),
    337       num_channels_(0),
    338       sampling_rate_(0),
    339       audio_finished_(true),
    340       video_finished_(true),
    341       playing_(false),
    342       is_audio_encrypted_(false),
    343       is_video_encrypted_(false),
    344       volume_(-1.0),
    345       clock_(&default_tick_clock_),
    346       reconfig_audio_decoder_(false),
    347       reconfig_video_decoder_(false),
    348       audio_access_unit_index_(0),
    349       video_access_unit_index_(0),
    350       waiting_for_audio_data_(false),
    351       waiting_for_video_data_(false),
    352       sync_decoder_jobs_(true),
    353       weak_this_(this),
    354       drm_bridge_(NULL) {
    355 }
    356 
    357 MediaSourcePlayer::~MediaSourcePlayer() {
    358   Release();
    359 }
    360 
    361 void MediaSourcePlayer::SetVideoSurface(gfx::ScopedJavaSurface surface) {
    362   // Ignore non-empty surface that is unprotected if |is_video_encrypted_| is
    363   // true.
    364   if (is_video_encrypted_ && !surface.IsEmpty() && !surface.is_protected())
    365     return;
    366 
    367   surface_ =  surface.Pass();
    368   pending_event_ |= SURFACE_CHANGE_EVENT_PENDING;
    369   if (pending_event_ & SEEK_EVENT_PENDING) {
    370     // Waiting for the seek to finish.
    371     return;
    372   }
    373   // Setting a new surface will require a new MediaCodec to be created.
    374   // Request a seek so that the new decoder will decode an I-frame first.
    375   // Or otherwise, the new MediaCodec might crash. See b/8950387.
    376   pending_event_ |= SEEK_EVENT_PENDING;
    377   ProcessPendingEvents();
    378 }
    379 
    380 bool MediaSourcePlayer::Seekable() {
    381   // If the duration TimeDelta, converted to milliseconds from microseconds,
    382   // is >= 2^31, then the media is assumed to be unbounded and unseekable.
    383   // 2^31 is the bound due to java player using 32-bit integer for time
    384   // values at millisecond resolution.
    385   return duration_ <
    386          base::TimeDelta::FromMilliseconds(std::numeric_limits<int32>::max());
    387 }
    388 
    389 void MediaSourcePlayer::Start() {
    390   playing_ = true;
    391 
    392   if (is_video_encrypted_)
    393     manager()->OnProtectedSurfaceRequested(player_id());
    394 
    395   StartInternal();
    396 }
    397 
    398 void MediaSourcePlayer::Pause() {
    399   // Since decoder jobs have their own thread, decoding is not fully paused
    400   // until all the decoder jobs call MediaDecoderCallback(). It is possible
    401   // that Start() is called while the player is waiting for
    402   // MediaDecoderCallback(). In that case, decoding will continue when
    403   // MediaDecoderCallback() is called.
    404   playing_ = false;
    405   start_time_ticks_ = base::TimeTicks();
    406 }
    407 
    408 bool MediaSourcePlayer::IsPlaying() {
    409   return playing_;
    410 }
    411 
    412 int MediaSourcePlayer::GetVideoWidth() {
    413   return width_;
    414 }
    415 
    416 int MediaSourcePlayer::GetVideoHeight() {
    417   return height_;
    418 }
    419 
    420 void MediaSourcePlayer::SeekTo(base::TimeDelta timestamp) {
    421   clock_.SetTime(timestamp, timestamp);
    422   if (audio_timestamp_helper_)
    423     audio_timestamp_helper_->SetBaseTimestamp(timestamp);
    424   pending_event_ |= SEEK_EVENT_PENDING;
    425   ProcessPendingEvents();
    426 }
    427 
    428 base::TimeDelta MediaSourcePlayer::GetCurrentTime() {
    429   return clock_.Elapsed();
    430 }
    431 
    432 base::TimeDelta MediaSourcePlayer::GetDuration() {
    433   return duration_;
    434 }
    435 
    436 void MediaSourcePlayer::Release() {
    437   ClearDecodingData();
    438   audio_decoder_job_.reset();
    439   video_decoder_job_.reset();
    440   reconfig_audio_decoder_ = false;
    441   reconfig_video_decoder_ = false;
    442   playing_ = false;
    443   pending_event_ = NO_EVENT_PENDING;
    444   surface_ = gfx::ScopedJavaSurface();
    445   ReleaseMediaResourcesFromManager();
    446 }
    447 
    448 void MediaSourcePlayer::SetVolume(double volume) {
    449   volume_ = volume;
    450   SetVolumeInternal();
    451 }
    452 
    453 bool MediaSourcePlayer::CanPause() {
    454   return Seekable();
    455 }
    456 
    457 bool MediaSourcePlayer::CanSeekForward() {
    458   return Seekable();
    459 }
    460 
    461 bool MediaSourcePlayer::CanSeekBackward() {
    462   return Seekable();
    463 }
    464 
    465 bool MediaSourcePlayer::IsPlayerReady() {
    466   return audio_decoder_job_ || video_decoder_job_;
    467 }
    468 
    469 void MediaSourcePlayer::StartInternal() {
    470   // If there are pending events, wait for them finish.
    471   if (pending_event_ != NO_EVENT_PENDING)
    472     return;
    473 
    474   // Create decoder jobs if they are not created
    475   ConfigureAudioDecoderJob();
    476   ConfigureVideoDecoderJob();
    477 
    478 
    479   // If one of the decoder job is not ready, do nothing.
    480   if ((HasAudio() && !audio_decoder_job_) ||
    481       (HasVideo() && !video_decoder_job_)) {
    482     return;
    483   }
    484 
    485   audio_finished_ = false;
    486   video_finished_ = false;
    487   sync_decoder_jobs_ = true;
    488   SyncAndStartDecoderJobs();
    489 }
    490 
    491 void MediaSourcePlayer::DemuxerReady(
    492     const MediaPlayerHostMsg_DemuxerReady_Params& params) {
    493   duration_ = base::TimeDelta::FromMilliseconds(params.duration_ms);
    494   clock_.SetDuration(duration_);
    495 
    496   audio_codec_ = params.audio_codec;
    497   num_channels_ = params.audio_channels;
    498   sampling_rate_ = params.audio_sampling_rate;
    499   is_audio_encrypted_ = params.is_audio_encrypted;
    500   audio_extra_data_ = params.audio_extra_data;
    501   if (HasAudio()) {
    502     DCHECK_GT(num_channels_, 0);
    503     audio_timestamp_helper_.reset(new AudioTimestampHelper(sampling_rate_));
    504     audio_timestamp_helper_->SetBaseTimestamp(GetCurrentTime());
    505   } else {
    506     audio_timestamp_helper_.reset();
    507   }
    508 
    509   video_codec_ = params.video_codec;
    510   width_ = params.video_size.width();
    511   height_ = params.video_size.height();
    512   is_video_encrypted_ = params.is_video_encrypted;
    513 
    514   OnMediaMetadataChanged(duration_, width_, height_, true);
    515 
    516   if (pending_event_ & CONFIG_CHANGE_EVENT_PENDING) {
    517     if (reconfig_audio_decoder_)
    518       ConfigureAudioDecoderJob();
    519 
    520     // If there is a pending surface change, we can merge it with the config
    521     // change.
    522     if (reconfig_video_decoder_) {
    523       pending_event_ &= ~SURFACE_CHANGE_EVENT_PENDING;
    524       ConfigureVideoDecoderJob();
    525     }
    526     pending_event_ &= ~CONFIG_CHANGE_EVENT_PENDING;
    527     if (playing_)
    528       StartInternal();
    529   }
    530 }
    531 
    532 void MediaSourcePlayer::ReadFromDemuxerAck(
    533     const MediaPlayerHostMsg_ReadFromDemuxerAck_Params& params) {
    534   DCHECK_LT(0u, params.access_units.size());
    535   if (params.type == DemuxerStream::AUDIO)
    536     waiting_for_audio_data_ = false;
    537   else
    538     waiting_for_video_data_ = false;
    539 
    540   // If there is a pending seek request, ignore the data from the chunk demuxer.
    541   // The data will be requested later when OnSeekRequestAck() is called.
    542   if (pending_event_ & SEEK_EVENT_PENDING)
    543     return;
    544 
    545   if (params.type == DemuxerStream::AUDIO) {
    546     DCHECK_EQ(0u, audio_access_unit_index_);
    547     received_audio_ = params;
    548   } else {
    549     DCHECK_EQ(0u, video_access_unit_index_);
    550     received_video_ = params;
    551   }
    552 
    553   if (pending_event_ != NO_EVENT_PENDING || !playing_)
    554     return;
    555 
    556   if (sync_decoder_jobs_) {
    557     SyncAndStartDecoderJobs();
    558     return;
    559   }
    560 
    561   if (params.type == DemuxerStream::AUDIO)
    562     DecodeMoreAudio();
    563   else
    564     DecodeMoreVideo();
    565 }
    566 
    567 void MediaSourcePlayer::DurationChanged(const base::TimeDelta& duration) {
    568   duration_ = duration;
    569   clock_.SetDuration(duration_);
    570 }
    571 
    572 void MediaSourcePlayer::SetDrmBridge(MediaDrmBridge* drm_bridge) {
    573   // Currently we don't support DRM change during the middle of playback, even
    574   // if the player is paused.
    575   // TODO(qinmin): support DRM change after playback has started.
    576   // http://crbug.com/253792.
    577   if (GetCurrentTime() > base::TimeDelta()) {
    578     LOG(INFO) << "Setting DRM bridge after play back has started. "
    579               << "This is not well supported!";
    580   }
    581 
    582   drm_bridge_ = drm_bridge;
    583 
    584   if (playing_)
    585     StartInternal();
    586 }
    587 
    588 void MediaSourcePlayer::OnSeekRequestAck(unsigned seek_request_id) {
    589   DVLOG(1) << "OnSeekRequestAck(" << seek_request_id << ")";
    590   // Do nothing until the most recent seek request is processed.
    591   if (seek_request_id_ != seek_request_id)
    592     return;
    593   pending_event_ &= ~SEEK_EVENT_PENDING;
    594   OnSeekComplete();
    595   ProcessPendingEvents();
    596 }
    597 
    598 void MediaSourcePlayer::UpdateTimestamps(
    599     const base::TimeDelta& presentation_timestamp, size_t audio_output_bytes) {
    600   if (audio_output_bytes > 0) {
    601     audio_timestamp_helper_->AddFrames(
    602         audio_output_bytes / (kBytesPerAudioOutputSample * num_channels_));
    603     clock_.SetMaxTime(audio_timestamp_helper_->GetTimestamp());
    604   } else {
    605     clock_.SetMaxTime(presentation_timestamp);
    606   }
    607 
    608   OnTimeUpdated();
    609 }
    610 
    611 void MediaSourcePlayer::ProcessPendingEvents() {
    612   // Wait for all the decoding jobs to finish before processing pending tasks.
    613   if ((audio_decoder_job_ && audio_decoder_job_->is_decoding()) ||
    614       (video_decoder_job_ && video_decoder_job_->is_decoding())) {
    615     return;
    616   }
    617 
    618   if (pending_event_ & SEEK_EVENT_PENDING) {
    619     ClearDecodingData();
    620     manager()->OnMediaSeekRequest(
    621         player_id(), GetCurrentTime(), ++seek_request_id_);
    622     return;
    623   }
    624 
    625   start_time_ticks_ = base::TimeTicks();
    626   if (pending_event_ & CONFIG_CHANGE_EVENT_PENDING) {
    627     DCHECK(reconfig_audio_decoder_ || reconfig_video_decoder_);
    628     manager()->OnMediaConfigRequest(player_id());
    629     return;
    630   }
    631 
    632   if (pending_event_ & SURFACE_CHANGE_EVENT_PENDING) {
    633     video_decoder_job_.reset();
    634     ConfigureVideoDecoderJob();
    635     pending_event_ &= ~SURFACE_CHANGE_EVENT_PENDING;
    636   }
    637 
    638   if (playing_)
    639     StartInternal();
    640 }
    641 
    642 void MediaSourcePlayer::MediaDecoderCallback(
    643     bool is_audio, MediaDecoderJob::DecodeStatus decode_status,
    644     const base::TimeDelta& presentation_timestamp, size_t audio_output_bytes) {
    645   if (is_audio && audio_decoder_job_)
    646     audio_decoder_job_->OnDecodeCompleted();
    647   if (!is_audio && video_decoder_job_)
    648     video_decoder_job_->OnDecodeCompleted();
    649 
    650   if (is_audio)
    651     decoder_starvation_callback_.Cancel();
    652 
    653   if (decode_status == MediaDecoderJob::DECODE_FAILED) {
    654     Release();
    655     OnMediaError(MEDIA_ERROR_DECODE);
    656     return;
    657   }
    658 
    659   // If the input reaches input EOS, there is no need to request new data.
    660   if (decode_status != MediaDecoderJob::DECODE_TRY_ENQUEUE_INPUT_AGAIN_LATER &&
    661       decode_status != MediaDecoderJob::DECODE_INPUT_END_OF_STREAM) {
    662     if (is_audio)
    663       audio_access_unit_index_++;
    664     else
    665       video_access_unit_index_++;
    666   }
    667 
    668   if (pending_event_ != NO_EVENT_PENDING) {
    669     ProcessPendingEvents();
    670     return;
    671   }
    672 
    673   if (decode_status == MediaDecoderJob::DECODE_SUCCEEDED &&
    674       (is_audio || !HasAudio())) {
    675     UpdateTimestamps(presentation_timestamp, audio_output_bytes);
    676   }
    677 
    678   if (decode_status == MediaDecoderJob::DECODE_OUTPUT_END_OF_STREAM) {
    679     PlaybackCompleted(is_audio);
    680     return;
    681   }
    682 
    683   if (!playing_) {
    684     if (is_audio || !HasAudio())
    685       clock_.Pause();
    686     return;
    687   }
    688 
    689   if (sync_decoder_jobs_) {
    690     SyncAndStartDecoderJobs();
    691     return;
    692   }
    693 
    694   base::TimeDelta current_timestamp = GetCurrentTime();
    695   if (is_audio) {
    696     if (decode_status == MediaDecoderJob::DECODE_SUCCEEDED) {
    697       base::TimeDelta timeout =
    698           audio_timestamp_helper_->GetTimestamp() - current_timestamp;
    699       StartStarvationCallback(timeout);
    700     }
    701     if (!HasAudioData())
    702       RequestAudioData();
    703     else
    704       DecodeMoreAudio();
    705     return;
    706   }
    707 
    708   if (!HasAudio() && decode_status == MediaDecoderJob::DECODE_SUCCEEDED) {
    709     DCHECK(current_timestamp <= presentation_timestamp);
    710     // For video only streams, fps can be estimated from the difference
    711     // between the previous and current presentation timestamps. The
    712     // previous presentation timestamp is equal to current_timestamp.
    713     // TODO(qinmin): determine whether 2 is a good coefficient for estimating
    714     // video frame timeout.
    715     StartStarvationCallback(2 * (presentation_timestamp - current_timestamp));
    716   }
    717   if (!HasVideoData())
    718     RequestVideoData();
    719   else
    720     DecodeMoreVideo();
    721 }
    722 
    723 void MediaSourcePlayer::DecodeMoreAudio() {
    724   DCHECK(!audio_decoder_job_->is_decoding());
    725   DCHECK(HasAudioData());
    726 
    727   if (DemuxerStream::kConfigChanged ==
    728       received_audio_.access_units[audio_access_unit_index_].status) {
    729     // Wait for demuxer ready message.
    730     reconfig_audio_decoder_ = true;
    731     pending_event_ |= CONFIG_CHANGE_EVENT_PENDING;
    732     received_audio_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
    733     audio_access_unit_index_ = 0;
    734     ProcessPendingEvents();
    735     return;
    736   }
    737 
    738   audio_decoder_job_->Decode(
    739       received_audio_.access_units[audio_access_unit_index_],
    740       start_time_ticks_, start_presentation_timestamp_,
    741       base::Bind(&MediaSourcePlayer::MediaDecoderCallback,
    742                  weak_this_.GetWeakPtr(), true));
    743 }
    744 
    745 void MediaSourcePlayer::DecodeMoreVideo() {
    746   DVLOG(1) << "DecodeMoreVideo()";
    747   DCHECK(!video_decoder_job_->is_decoding());
    748   DCHECK(HasVideoData());
    749 
    750   if (DemuxerStream::kConfigChanged ==
    751       received_video_.access_units[video_access_unit_index_].status) {
    752     // Wait for demuxer ready message.
    753     reconfig_video_decoder_ = true;
    754     pending_event_ |= CONFIG_CHANGE_EVENT_PENDING;
    755     received_video_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
    756     video_access_unit_index_ = 0;
    757     ProcessPendingEvents();
    758     return;
    759   }
    760 
    761   DVLOG(3) << "VideoDecoderJob::Decode(" << video_access_unit_index_ << ", "
    762            << start_time_ticks_.ToInternalValue() << ", "
    763            << start_presentation_timestamp_.InMilliseconds() << ")";
    764   video_decoder_job_->Decode(
    765       received_video_.access_units[video_access_unit_index_],
    766       start_time_ticks_, start_presentation_timestamp_,
    767       base::Bind(&MediaSourcePlayer::MediaDecoderCallback,
    768                  weak_this_.GetWeakPtr(), false));
    769 }
    770 
    771 void MediaSourcePlayer::PlaybackCompleted(bool is_audio) {
    772   if (is_audio)
    773     audio_finished_ = true;
    774   else
    775     video_finished_ = true;
    776 
    777   if ((!HasAudio() || audio_finished_) && (!HasVideo() || video_finished_)) {
    778     playing_ = false;
    779     clock_.Pause();
    780     start_time_ticks_ = base::TimeTicks();
    781     OnPlaybackComplete();
    782   }
    783 }
    784 
    785 void MediaSourcePlayer::ClearDecodingData() {
    786   DVLOG(1) << "ClearDecodingData()";
    787   if (audio_decoder_job_)
    788     audio_decoder_job_->Flush();
    789   if (video_decoder_job_)
    790     video_decoder_job_->Flush();
    791   start_time_ticks_ = base::TimeTicks();
    792   received_audio_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
    793   received_video_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
    794   audio_access_unit_index_ = 0;
    795   video_access_unit_index_ = 0;
    796   waiting_for_audio_data_ = false;
    797   waiting_for_video_data_ = false;
    798 }
    799 
    800 bool MediaSourcePlayer::HasVideo() {
    801   return kUnknownVideoCodec != video_codec_;
    802 }
    803 
    804 bool MediaSourcePlayer::HasAudio() {
    805   return kUnknownAudioCodec != audio_codec_;
    806 }
    807 
    808 void MediaSourcePlayer::ConfigureAudioDecoderJob() {
    809   if (!HasAudio()) {
    810     audio_decoder_job_.reset();
    811     return;
    812   }
    813 
    814   // Create audio decoder job only if config changes.
    815   if (audio_decoder_job_ && !reconfig_audio_decoder_)
    816     return;
    817 
    818   base::android::ScopedJavaLocalRef<jobject> media_codec;
    819   if (is_audio_encrypted_) {
    820     if (drm_bridge_) {
    821       media_codec = drm_bridge_->GetMediaCrypto();
    822       // TODO(qinmin): currently we assume MediaCrypto is available whenever
    823       // MediaDrmBridge is constructed. This will change if we want to support
    824       // more general uses cases of EME.
    825       DCHECK(!media_codec.is_null());
    826     } else {
    827       // Don't create the decoder job if |drm_bridge_| is not set,
    828       // so StartInternal() will not proceed.
    829       LOG(INFO) << "MediaDrmBridge is not available when creating decoder "
    830                 << "for encrypted audio stream.";
    831       return;
    832     }
    833   }
    834 
    835   audio_decoder_job_.reset(AudioDecoderJob::Create(
    836       audio_codec_, sampling_rate_, num_channels_, &audio_extra_data_[0],
    837       audio_extra_data_.size(), media_codec.obj()));
    838 
    839   if (audio_decoder_job_) {
    840     SetVolumeInternal();
    841     reconfig_audio_decoder_ =  false;
    842   }
    843 }
    844 
    845 void MediaSourcePlayer::ConfigureVideoDecoderJob() {
    846   if (!HasVideo() || surface_.IsEmpty()) {
    847     video_decoder_job_.reset();
    848     return;
    849   }
    850 
    851   // Create video decoder job only if config changes.
    852   if (video_decoder_job_ && !reconfig_video_decoder_)
    853     return;
    854 
    855   base::android::ScopedJavaLocalRef<jobject> media_codec;
    856   if (is_video_encrypted_) {
    857     if (drm_bridge_) {
    858       media_codec = drm_bridge_->GetMediaCrypto();
    859       DCHECK(!media_codec.is_null());
    860     } else {
    861       LOG(INFO) << "MediaDrmBridge is not available when creating decoder "
    862                 << "for encrypted video stream.";
    863       return;
    864     }
    865   }
    866 
    867   // Release the old VideoDecoderJob first so the surface can get released.
    868   // Android does not allow 2 MediaCodec instances use the same surface.
    869   video_decoder_job_.reset();
    870   // Create the new VideoDecoderJob.
    871   video_decoder_job_.reset(VideoDecoderJob::Create(
    872       video_codec_, gfx::Size(width_, height_), surface_.j_surface().obj(),
    873       media_codec.obj()));
    874   if (video_decoder_job_)
    875     reconfig_video_decoder_ = false;
    876 
    877   // Inform the fullscreen view the player is ready.
    878   // TODO(qinmin): refactor MediaPlayerBridge so that we have a better way
    879   // to inform ContentVideoView.
    880   OnMediaMetadataChanged(duration_, width_, height_, true);
    881 }
    882 
    883 void MediaSourcePlayer::OnDecoderStarved() {
    884   sync_decoder_jobs_ = true;
    885 }
    886 
    887 void MediaSourcePlayer::StartStarvationCallback(
    888     const base::TimeDelta& timeout) {
    889   decoder_starvation_callback_.Reset(
    890       base::Bind(&MediaSourcePlayer::OnDecoderStarved,
    891                  weak_this_.GetWeakPtr()));
    892   base::MessageLoop::current()->PostDelayedTask(
    893       FROM_HERE, decoder_starvation_callback_.callback(), timeout);
    894 }
    895 
    896 void MediaSourcePlayer::SyncAndStartDecoderJobs() {
    897   // For streams with both audio and video, send the request for video too.
    898   // However, don't wait for the response so that we won't have lots of
    899   // noticeable pauses in the audio. Video will sync with audio by itself.
    900   if (HasVideo() && !HasVideoData()) {
    901     RequestVideoData();
    902     if (!HasAudio())
    903       return;
    904   }
    905   if (HasAudio() && !HasAudioData()) {
    906     RequestAudioData();
    907     return;
    908   }
    909   start_time_ticks_ = base::TimeTicks::Now();
    910   start_presentation_timestamp_ = GetCurrentTime();
    911   if (!clock_.IsPlaying())
    912     clock_.Play();
    913   if (HasAudioData() && !audio_decoder_job_->is_decoding())
    914     DecodeMoreAudio();
    915   if (HasVideoData() && !video_decoder_job_->is_decoding())
    916     DecodeMoreVideo();
    917   sync_decoder_jobs_ = false;
    918 }
    919 
    920 void MediaSourcePlayer::RequestAudioData() {
    921   DVLOG(2) << "RequestAudioData()";
    922   DCHECK(HasAudio());
    923 
    924   if (waiting_for_audio_data_)
    925     return;
    926 
    927   manager()->OnReadFromDemuxer(player_id(), DemuxerStream::AUDIO);
    928   received_audio_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
    929   audio_access_unit_index_ = 0;
    930   waiting_for_audio_data_ = true;
    931 }
    932 
    933 void MediaSourcePlayer::RequestVideoData() {
    934   DVLOG(2) << "RequestVideoData()";
    935   DCHECK(HasVideo());
    936   if (waiting_for_video_data_)
    937     return;
    938 
    939   manager()->OnReadFromDemuxer(player_id(), DemuxerStream::VIDEO);
    940   received_video_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
    941   video_access_unit_index_ = 0;
    942   waiting_for_video_data_ = true;
    943 }
    944 
    945 bool MediaSourcePlayer::HasAudioData() const {
    946   return audio_access_unit_index_ < received_audio_.access_units.size();
    947 }
    948 
    949 bool MediaSourcePlayer::HasVideoData() const {
    950   return video_access_unit_index_ < received_video_.access_units.size();
    951 }
    952 
    953 void MediaSourcePlayer::SetVolumeInternal() {
    954   if (audio_decoder_job_ && volume_ >= 0)
    955     audio_decoder_job_.get()->SetVolume(volume_);
    956 }
    957 
    958 }  // namespace media
    959