media/base/android/media_codec_player.cc

   1 // Copyright 2015 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_codec_player.h"
   6
   7 #include "base/barrier_closure.h"
   8 #include "base/bind.h"
   9 #include "base/lazy_instance.h"
  10 #include "base/logging.h"
  11 #include "base/thread_task_runner_handle.h"
  12 #include "base/threading/thread.h"
  13 #include "media/base/android/media_codec_audio_decoder.h"
  14 #include "media/base/android/media_codec_video_decoder.h"
  15 #include "media/base/android/media_player_manager.h"
  16 #include "media/base/buffers.h"
  17
  18 #define RUN_ON_MEDIA_THREAD(METHOD, ...)                                     \
  19   do {                                                                       \
  20     if (!GetMediaTaskRunner()->BelongsToCurrentThread()) {                   \
  21       DCHECK(ui_task_runner_->BelongsToCurrentThread());                     \
  22       GetMediaTaskRunner()->PostTask(                                        \
  23           FROM_HERE, base::Bind(&MediaCodecPlayer::METHOD, media_weak_this_, \
  24                                 ##__VA_ARGS__));                             \
  25       return;                                                                \
  26     }                                                                        \
  27   } while (0)
  28
  29 namespace media {
  30
  31 class MediaThread : public base::Thread {
  32  public:
  33   MediaThread() : base::Thread("BrowserMediaThread") {
  34     Start();
  35   }
  36 };
  37
  38 // Create media thread
  39 base::LazyInstance<MediaThread>::Leaky
  40     g_media_thread = LAZY_INSTANCE_INITIALIZER;
  41
  42
  43 scoped_refptr<base::SingleThreadTaskRunner> GetMediaTaskRunner() {
  44   return g_media_thread.Pointer()->task_runner();
  45 }
  46
  47 // MediaCodecPlayer implementation.
  48
  49 MediaCodecPlayer::MediaCodecPlayer(
  50     int player_id,
  51     base::WeakPtr<MediaPlayerManager> manager,
  52     const RequestMediaResourcesCB& request_media_resources_cb,
  53     scoped_ptr<DemuxerAndroid> demuxer,
  54     const GURL& frame_url)
  55     : MediaPlayerAndroid(player_id,
  56                          manager.get(),
  57                          request_media_resources_cb,
  58                          frame_url),
  59       ui_task_runner_(base::ThreadTaskRunnerHandle::Get()),
  60       demuxer_(demuxer.Pass()),
  61       state_(kStatePaused),
  62       interpolator_(&default_tick_clock_),
  63       pending_start_(false),
  64       pending_seek_(kNoTimestamp()),
  65       media_weak_factory_(this) {
  66   DCHECK(ui_task_runner_->BelongsToCurrentThread());
  67
  68   DVLOG(1) << "MediaCodecPlayer::MediaCodecPlayer: player_id:" << player_id;
  69
  70   request_resources_cb_ = base::Bind(request_media_resources_cb_, player_id);
  71
  72   completion_cb_ =
  73       base::Bind(&MediaPlayerManager::OnPlaybackComplete, manager, player_id);
  74   seek_done_cb_ =
  75       base::Bind(&MediaPlayerManager::OnSeekComplete, manager, player_id);
  76   error_cb_ = base::Bind(&MediaPlayerManager::OnError, manager, player_id);
  77   attach_listener_cb_ = base::Bind(&MediaPlayerAndroid::AttachListener,
  78                                    WeakPtrForUIThread(), nullptr);
  79   detach_listener_cb_ =
  80       base::Bind(&MediaPlayerAndroid::DetachListener, WeakPtrForUIThread());
  81   metadata_changed_cb_ = base::Bind(&MediaPlayerAndroid::OnMediaMetadataChanged,
  82                                     WeakPtrForUIThread());
  83   time_update_cb_ =
  84       base::Bind(&MediaPlayerAndroid::OnTimeUpdate, WeakPtrForUIThread());
  85
  86   media_weak_this_ = media_weak_factory_.GetWeakPtr();
  87
  88   // Finish initializaton on Media thread
  89   GetMediaTaskRunner()->PostTask(
  90       FROM_HERE, base::Bind(&MediaCodecPlayer::Initialize, media_weak_this_));
  91 }
  92
  93 MediaCodecPlayer::~MediaCodecPlayer()
  94 {
  95   DVLOG(1) << "MediaCodecPlayer::~MediaCodecPlayer";
  96   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
  97 }
  98
  99 void MediaCodecPlayer::Initialize() {
 100   DVLOG(1) << __FUNCTION__;
 101   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 102
 103   interpolator_.SetUpperBound(base::TimeDelta());
 104
 105   CreateDecoders();
 106
 107   // This call might in turn call MediaCodecPlayer::OnDemuxerConfigsAvailable()
 108   // which propagates configs into decoders. Therefore CreateDecoders() should
 109   // be called first.
 110   demuxer_->Initialize(this);
 111 }
 112
 113 // The implementation of MediaPlayerAndroid interface.
 114
 115 void MediaCodecPlayer::DeleteOnCorrectThread() {
 116   DVLOG(1) << __FUNCTION__;
 117   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 118
 119   DetachListener();
 120
 121   // The base class part that deals with MediaPlayerListener
 122   // has to be destroyed on UI thread.
 123   DestroyListenerOnUIThread();
 124
 125   // Post deletion onto Media thread
 126   GetMediaTaskRunner()->DeleteSoon(FROM_HERE, this);
 127 }
 128
 129 void MediaCodecPlayer::SetVideoSurface(gfx::ScopedJavaSurface surface) {
 130   RUN_ON_MEDIA_THREAD(SetVideoSurface, base::Passed(&surface));
 131
 132   DVLOG(1) << __FUNCTION__ << (surface.IsEmpty() ? " empty" : " non-empty");
 133
 134   // Save the empty-ness before we pass the surface to the decoder.
 135   bool surface_is_empty = surface.IsEmpty();
 136
 137   // Apparently RemoveVideoSurface() can be called several times in a row,
 138   // ignore the second and subsequent calls.
 139   if (surface_is_empty && !video_decoder_->HasVideoSurface()) {
 140     DVLOG(1) << __FUNCTION__ << ": surface already removed, ignoring";
 141     return;
 142   }
 143
 144   video_decoder_->SetVideoSurface(surface.Pass());
 145
 146   if (surface_is_empty) {
 147     // Remove video surface.
 148     switch (state_) {
 149       case kStatePlaying:
 150         if (VideoFinished())
 151           break;
 152
 153         DVLOG(1) << __FUNCTION__ << ": stopping and restarting";
 154         // Stop decoders as quickly as possible.
 155         StopDecoders();  // synchronous stop
 156
 157         // Prefetch or wait for initial configuration.
 158         if (HasAudio() || HasVideo()) {
 159           SetState(kStatePrefetching);
 160           StartPrefetchDecoders();
 161         } else {
 162           SetState(kStateWaitingForConfig);
 163         }
 164         break;
 165
 166       default:
 167         break;  // ignore
 168     }
 169   } else {
 170     // Replace video surface.
 171     switch (state_) {
 172       case kStateWaitingForSurface:
 173         SetState(kStatePlaying);
 174         StartPlaybackOrBrowserSeek();
 175         break;
 176
 177       case kStatePlaying:
 178         if (VideoFinished())
 179           break;
 180
 181         DVLOG(1) << __FUNCTION__ << ": requesting to stop and restart";
 182         SetState(kStateStopping);
 183         RequestToStopDecoders();
 184         SetPendingStart(true);
 185         break;
 186
 187       default:
 188         break;  // ignore
 189     }
 190   }
 191 }
 192
 193 void MediaCodecPlayer::Start() {
 194   RUN_ON_MEDIA_THREAD(Start);
 195
 196   DVLOG(1) << __FUNCTION__;
 197
 198   switch (state_) {
 199     case kStatePaused:
 200       // Prefetch or wait for initial configuration.
 201       if (HasAudio() || HasVideo()) {
 202         SetState(kStatePrefetching);
 203         StartPrefetchDecoders();
 204       } else {
 205         SetState(kStateWaitingForConfig);
 206       }
 207       break;
 208     case kStateStopping:
 209     case kStateWaitingForSeek:
 210       SetPendingStart(true);
 211       break;
 212     case kStateWaitingForConfig:
 213     case kStatePrefetching:
 214     case kStatePlaying:
 215     case kStateWaitingForSurface:
 216     case kStateError:
 217       break;  // Ignore
 218     default:
 219       NOTREACHED();
 220       break;
 221   }
 222 }
 223
 224 void MediaCodecPlayer::Pause(bool is_media_related_action) {
 225   RUN_ON_MEDIA_THREAD(Pause, is_media_related_action);
 226
 227   DVLOG(1) << __FUNCTION__;
 228
 229   SetPendingStart(false);
 230
 231   switch (state_) {
 232     case kStateWaitingForConfig:
 233     case kStatePrefetching:
 234     case kStateWaitingForSurface:
 235       SetState(kStatePaused);
 236       StopDecoders();
 237       break;
 238     case kStatePlaying:
 239       SetState(kStateStopping);
 240       RequestToStopDecoders();
 241       break;
 242     case kStatePaused:
 243     case kStateStopping:
 244     case kStateWaitingForSeek:
 245     case kStateError:
 246       break;  // Ignore
 247     default:
 248       NOTREACHED();
 249       break;
 250   }
 251 }
 252
 253 void MediaCodecPlayer::SeekTo(base::TimeDelta timestamp) {
 254   RUN_ON_MEDIA_THREAD(SeekTo, timestamp);
 255
 256   DVLOG(1) << __FUNCTION__ << " " << timestamp;
 257
 258   switch (state_) {
 259     case kStatePaused:
 260       SetState(kStateWaitingForSeek);
 261       RequestDemuxerSeek(timestamp);
 262       break;
 263     case kStateWaitingForConfig:
 264     case kStatePrefetching:
 265     case kStateWaitingForSurface:
 266       SetState(kStateWaitingForSeek);
 267       StopDecoders();
 268       SetPendingStart(true);
 269       RequestDemuxerSeek(timestamp);
 270       break;
 271     case kStatePlaying:
 272       SetState(kStateStopping);
 273       RequestToStopDecoders();
 274       SetPendingStart(true);
 275       SetPendingSeek(timestamp);
 276       break;
 277     case kStateStopping:
 278       SetPendingSeek(timestamp);
 279       break;
 280     case kStateWaitingForSeek:
 281       SetPendingSeek(timestamp);
 282       break;
 283     case kStateError:
 284       break;  // ignore
 285     default:
 286       NOTREACHED();
 287       break;
 288   }
 289 }
 290
 291 void MediaCodecPlayer::Release() {
 292   RUN_ON_MEDIA_THREAD(Release);
 293
 294   DVLOG(1) << __FUNCTION__;
 295
 296   // Stop decoding threads and delete MediaCodecs, but keep IPC between browser
 297   // and renderer processes going. Seek should work across and after Release().
 298
 299   ReleaseDecoderResources();
 300
 301   SetPendingStart(false);
 302
 303   if (state_ != kStateWaitingForSeek)
 304     SetState(kStatePaused);
 305
 306   base::TimeDelta pending_seek_time = GetPendingSeek();
 307   if (pending_seek_time != kNoTimestamp()) {
 308     SetPendingSeek(kNoTimestamp());
 309     SetState(kStateWaitingForSeek);
 310     RequestDemuxerSeek(pending_seek_time);
 311   }
 312 }
 313
 314 void MediaCodecPlayer::SetVolume(double volume) {
 315   RUN_ON_MEDIA_THREAD(SetVolume, volume);
 316
 317   DVLOG(1) << __FUNCTION__ << " " << volume;
 318   audio_decoder_->SetVolume(volume);
 319 }
 320
 321 int MediaCodecPlayer::GetVideoWidth() {
 322   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 323   return metadata_cache_.video_size.width();
 324 }
 325
 326 int MediaCodecPlayer::GetVideoHeight() {
 327   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 328   return metadata_cache_.video_size.height();
 329 }
 330
 331 base::TimeDelta MediaCodecPlayer::GetCurrentTime() {
 332   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 333   return current_time_cache_;
 334 }
 335
 336 base::TimeDelta MediaCodecPlayer::GetDuration() {
 337   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 338   return metadata_cache_.duration;
 339 }
 340
 341 bool MediaCodecPlayer::IsPlaying() {
 342   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 343
 344   // TODO(timav): Use another variable since |state_| should only be accessed on
 345   // Media thread.
 346   return state_ == kStatePlaying || state_ == kStateStopping;
 347 }
 348
 349 bool MediaCodecPlayer::CanPause() {
 350   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 351   NOTIMPLEMENTED();
 352   return false;
 353 }
 354
 355 bool MediaCodecPlayer::CanSeekForward() {
 356   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 357   NOTIMPLEMENTED();
 358   return false;
 359 }
 360
 361 bool MediaCodecPlayer::CanSeekBackward() {
 362   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 363   NOTIMPLEMENTED();
 364   return false;
 365 }
 366
 367 bool MediaCodecPlayer::IsPlayerReady() {
 368   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 369   // This method is called to check whether it's safe to release the player when
 370   // the OS needs more resources. This class can be released at any time.
 371   return true;
 372 }
 373
 374 void MediaCodecPlayer::SetCdm(BrowserCdm* cdm) {
 375   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 376   NOTIMPLEMENTED();
 377 }
 378
 379 // Callbacks from Demuxer.
 380
 381 void MediaCodecPlayer::OnDemuxerConfigsAvailable(
 382     const DemuxerConfigs& configs) {
 383   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 384
 385   DVLOG(1) << __FUNCTION__;
 386
 387   duration_ = configs.duration;
 388
 389   SetDemuxerConfigs(configs);
 390
 391   // Update cache and notify manager on UI thread
 392   gfx::Size video_size = HasVideo() ? configs.video_size : gfx::Size();
 393   ui_task_runner_->PostTask(
 394       FROM_HERE, base::Bind(metadata_changed_cb_, duration_, video_size));
 395 }
 396
 397 void MediaCodecPlayer::OnDemuxerDataAvailable(const DemuxerData& data) {
 398   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 399
 400   DCHECK_LT(0u, data.access_units.size());
 401   CHECK_GE(1u, data.demuxer_configs.size());
 402
 403   DVLOG(2) << "Player::" << __FUNCTION__;
 404
 405   if (data.type == DemuxerStream::AUDIO)
 406     audio_decoder_->OnDemuxerDataAvailable(data);
 407
 408   if (data.type == DemuxerStream::VIDEO)
 409     video_decoder_->OnDemuxerDataAvailable(data);
 410 }
 411
 412 void MediaCodecPlayer::OnDemuxerSeekDone(
 413     base::TimeDelta actual_browser_seek_time) {
 414   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 415
 416   DVLOG(1) << __FUNCTION__ << " actual_time:" << actual_browser_seek_time;
 417
 418   DCHECK(seek_info_.get());
 419   DCHECK(seek_info_->seek_time != kNoTimestamp());
 420
 421   // A browser seek must not jump into the past. Ideally, it seeks to the
 422   // requested time, but it might jump into the future.
 423   DCHECK(!seek_info_->is_browser_seek ||
 424          seek_info_->seek_time <= actual_browser_seek_time);
 425
 426   // Restrict the current time to be equal to seek_time
 427   // for the next StartPlaybackDecoders() call.
 428
 429   base::TimeDelta seek_time = seek_info_->is_browser_seek
 430                                   ? actual_browser_seek_time
 431                                   : seek_info_->seek_time;
 432
 433   interpolator_.SetBounds(seek_time, seek_time);
 434   audio_decoder_->SetBaseTimestamp(seek_time);
 435
 436   // The Flush() might set the state to kStateError.
 437   if (state_ == kStateError) {
 438     // Notify the Renderer.
 439     if (!seek_info_->is_browser_seek)
 440       ui_task_runner_->PostTask(FROM_HERE,
 441                                 base::Bind(seek_done_cb_, seek_time));
 442
 443     seek_info_.reset();
 444     return;
 445   }
 446
 447   DCHECK_EQ(kStateWaitingForSeek, state_);
 448
 449   base::TimeDelta pending_seek_time = GetPendingSeek();
 450   if (pending_seek_time != kNoTimestamp()) {
 451     // Keep kStateWaitingForSeek
 452     SetPendingSeek(kNoTimestamp());
 453     RequestDemuxerSeek(pending_seek_time);
 454     return;
 455   }
 456
 457   if (HasPendingStart()) {
 458     SetPendingStart(false);
 459     // Prefetch or wait for initial configuration.
 460     if (HasAudio() || HasVideo()) {
 461       SetState(kStatePrefetching);
 462       StartPrefetchDecoders();
 463     } else {
 464       SetState(kStateWaitingForConfig);
 465     }
 466   } else {
 467     SetState(kStatePaused);
 468   }
 469
 470   // Notify the Renderer.
 471   if (!seek_info_->is_browser_seek)
 472     ui_task_runner_->PostTask(FROM_HERE, base::Bind(seek_done_cb_, seek_time));
 473
 474   seek_info_.reset();
 475 }
 476
 477 void MediaCodecPlayer::OnDemuxerDurationChanged(
 478     base::TimeDelta duration) {
 479   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 480   DVLOG(1) << __FUNCTION__ << " duration:" << duration;
 481
 482   duration_ = duration;
 483 }
 484
 485 // Events from Player, called on UI thread
 486
 487 void MediaCodecPlayer::OnMediaMetadataChanged(base::TimeDelta duration,
 488                                               const gfx::Size& video_size) {
 489   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 490
 491   if (duration != kNoTimestamp())
 492     metadata_cache_.duration = duration;
 493
 494   if (!video_size.IsEmpty())
 495     metadata_cache_.video_size = video_size;
 496
 497   manager()->OnMediaMetadataChanged(player_id(), metadata_cache_.duration,
 498                                     metadata_cache_.video_size.width(),
 499                                     metadata_cache_.video_size.height(), true);
 500 }
 501
 502 void MediaCodecPlayer::OnTimeUpdate(base::TimeDelta current_timestamp,
 503                                     base::TimeTicks current_time_ticks) {
 504   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 505
 506   current_time_cache_ = current_timestamp;
 507   manager()->OnTimeUpdate(player_id(), current_timestamp, current_time_ticks);
 508 }
 509
 510 // Events from Decoders, called on Media thread
 511
 512 void MediaCodecPlayer::RequestDemuxerData(DemuxerStream::Type stream_type) {
 513   DVLOG(2) << __FUNCTION__ << " streamType:" << stream_type;
 514
 515   // Use this method instead of directly binding with
 516   // DemuxerAndroid::RequestDemuxerData() to avoid the race condition on
 517   // deletion:
 518   // 1. DeleteSoon is posted from UI to Media thread.
 519   // 2. RequestDemuxerData callback is posted from Decoder to Media thread.
 520   // 3. DeleteSoon arrives, we delete the player and detach from
 521   //    BrowserDemuxerAndroid.
 522   // 4. RequestDemuxerData is processed by the media thread queue. Since the
 523   //    weak_ptr was invalidated in (3), this is a no-op. If we used
 524   //    DemuxerAndroid::RequestDemuxerData() it would arrive and will try to
 525   //    call the client, but the client (i.e. this player) would not exist.
 526   demuxer_->RequestDemuxerData(stream_type);
 527 }
 528
 529 void MediaCodecPlayer::OnPrefetchDone() {
 530   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 531
 532   if (state_ != kStatePrefetching) {
 533     DVLOG(1) << __FUNCTION__ << " wrong state " << AsString(state_)
 534              << " ignoring";
 535     return;  // Ignore
 536   }
 537
 538   DVLOG(1) << __FUNCTION__;
 539
 540   if (!HasAudio() && !HasVideo()) {
 541     // No configuration at all after prefetching.
 542     // This is an error, initial configuration is expected
 543     // before the first data chunk.
 544     DCHECK(!internal_error_cb_.is_null());
 545     GetMediaTaskRunner()->PostTask(FROM_HERE, internal_error_cb_);
 546     return;
 547   }
 548
 549   if (HasVideo() && !video_decoder_->HasVideoSurface()) {
 550     SetState(kStateWaitingForSurface);
 551     return;
 552   }
 553
 554   SetState(kStatePlaying);
 555   StartPlaybackOrBrowserSeek();
 556 }
 557
 558 void MediaCodecPlayer::OnStopDone() {
 559   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 560   DVLOG(1) << __FUNCTION__;
 561
 562   if (!(audio_decoder_->IsStopped() && video_decoder_->IsStopped()))
 563     return;  // Wait until other stream is stopped
 564
 565   // At this point decoder threads should not be running
 566   if (interpolator_.interpolating())
 567     interpolator_.StopInterpolating();
 568
 569   base::TimeDelta seek_time;
 570   switch (state_) {
 571     case kStateStopping: {
 572       base::TimeDelta seek_time = GetPendingSeek();
 573       if (seek_time != kNoTimestamp()) {
 574         SetState(kStateWaitingForSeek);
 575         SetPendingSeek(kNoTimestamp());
 576         RequestDemuxerSeek(seek_time);
 577       } else if (HasPendingStart()) {
 578         SetPendingStart(false);
 579         SetState(kStatePrefetching);
 580         StartPrefetchDecoders();
 581       } else {
 582         SetState(kStatePaused);
 583       }
 584     } break;
 585     case kStatePlaying:
 586       // Unexpected stop means completion
 587       SetState(kStatePaused);
 588       break;
 589     default:
 590       // DVLOG(0) << __FUNCTION__ << " illegal state: " << AsString(state_);
 591       // NOTREACHED();
 592       // Ignore! There can be a race condition: audio posts OnStopDone,
 593       // then video posts, then first OnStopDone arrives at which point
 594       // both streams are already stopped, then second OnStopDone arrives. When
 595       // the second one arrives, the state us not kStateStopping any more.
 596       break;
 597   }
 598
 599   // DetachListener to UI thread
 600   ui_task_runner_->PostTask(FROM_HERE, detach_listener_cb_);
 601
 602   if (AudioFinished() && VideoFinished())
 603     ui_task_runner_->PostTask(FROM_HERE, completion_cb_);
 604 }
 605
 606 void MediaCodecPlayer::OnError() {
 607   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 608   DVLOG(1) << __FUNCTION__;
 609
 610   // kStateError blocks all events
 611   SetState(kStateError);
 612
 613   ReleaseDecoderResources();
 614
 615   ui_task_runner_->PostTask(FROM_HERE,
 616                             base::Bind(error_cb_, MEDIA_ERROR_DECODE));
 617 }
 618
 619 void MediaCodecPlayer::OnStarvation(DemuxerStream::Type type) {
 620   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 621   DVLOG(1) << __FUNCTION__ << " stream type:" << type;
 622
 623   if (state_ != kStatePlaying)
 624     return;  // Ignore
 625
 626   SetState(kStateStopping);
 627   RequestToStopDecoders();
 628   SetPendingStart(true);
 629 }
 630
 631 void MediaCodecPlayer::OnTimeIntervalUpdate(DemuxerStream::Type type,
 632                                             base::TimeDelta now_playing,
 633                                             base::TimeDelta last_buffered) {
 634   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 635
 636   DVLOG(2) << __FUNCTION__ << ": stream type:" << type << " [" << now_playing
 637            << "," << last_buffered << "]";
 638
 639   // I assume that audio stream cannot be added after we get configs by
 640   // OnDemuxerConfigsAvailable(), but that audio can finish early.
 641
 642   if (type == DemuxerStream::VIDEO) {
 643     // Ignore video PTS if there is audio stream or if it's behind current
 644     // time as set by audio stream.
 645     if (!AudioFinished() || now_playing < interpolator_.GetInterpolatedTime())
 646       return;
 647   }
 648
 649   interpolator_.SetBounds(now_playing, last_buffered);
 650
 651   // Post to UI thread
 652   ui_task_runner_->PostTask(FROM_HERE,
 653                             base::Bind(time_update_cb_, GetInterpolatedTime(),
 654                                        base::TimeTicks::Now()));
 655 }
 656
 657 void MediaCodecPlayer::OnVideoCodecCreated() {
 658   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 659
 660   // This callback requests resources by releasing other players.
 661   ui_task_runner_->PostTask(FROM_HERE, request_resources_cb_);
 662 }
 663
 664 void MediaCodecPlayer::OnVideoResolutionChanged(const gfx::Size& size) {
 665   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 666
 667   DVLOG(1) << __FUNCTION__ << " " << size.width() << "x" << size.height();
 668
 669   // Update cache and notify manager on UI thread
 670   ui_task_runner_->PostTask(
 671       FROM_HERE, base::Bind(metadata_changed_cb_, kNoTimestamp(), size));
 672 }
 673
 674 // State machine operations, called on Media thread
 675
 676 void MediaCodecPlayer::SetState(PlayerState new_state) {
 677   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 678
 679   DVLOG(1) << "SetState:" << AsString(state_) << " -> " << AsString(new_state);
 680   state_ = new_state;
 681 }
 682
 683 void MediaCodecPlayer::SetPendingStart(bool need_to_start) {
 684   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 685   DVLOG(1) << __FUNCTION__ << ": " << need_to_start;
 686   pending_start_ = need_to_start;
 687 }
 688
 689 bool MediaCodecPlayer::HasPendingStart() const {
 690   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 691   return pending_start_;
 692 }
 693
 694 void MediaCodecPlayer::SetPendingSeek(base::TimeDelta timestamp) {
 695   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 696   DVLOG(1) << __FUNCTION__ << ": " << timestamp;
 697   pending_seek_ = timestamp;
 698 }
 699
 700 base::TimeDelta MediaCodecPlayer::GetPendingSeek() const {
 701   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 702   return pending_seek_;
 703 }
 704
 705 bool MediaCodecPlayer::HasAudio() const {
 706   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 707   return audio_decoder_->HasStream();
 708 }
 709
 710 bool MediaCodecPlayer::HasVideo() const {
 711   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 712   return video_decoder_->HasStream();
 713 }
 714
 715 void MediaCodecPlayer::SetDemuxerConfigs(const DemuxerConfigs& configs) {
 716   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 717   DVLOG(1) << __FUNCTION__ << " " << configs;
 718
 719   DCHECK(audio_decoder_);
 720   DCHECK(video_decoder_);
 721
 722   // At least one valid codec must be present.
 723   DCHECK(configs.audio_codec != kUnknownAudioCodec ||
 724          configs.video_codec != kUnknownVideoCodec);
 725
 726   if (configs.audio_codec != kUnknownAudioCodec)
 727     audio_decoder_->SetDemuxerConfigs(configs);
 728
 729   if (configs.video_codec != kUnknownVideoCodec)
 730     video_decoder_->SetDemuxerConfigs(configs);
 731
 732   if (state_ == kStateWaitingForConfig) {
 733     SetState(kStatePrefetching);
 734     StartPrefetchDecoders();
 735   }
 736 }
 737
 738 void MediaCodecPlayer::StartPrefetchDecoders() {
 739   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 740   DVLOG(1) << __FUNCTION__;
 741
 742   bool do_audio = false;
 743   bool do_video = false;
 744   int count = 0;
 745   if (!AudioFinished()) {
 746     do_audio = true;
 747     ++count;
 748   }
 749   if (!VideoFinished()) {
 750     do_video = true;
 751     ++count;
 752   }
 753
 754   DCHECK_LT(0, count);  // at least one decoder should be active
 755
 756   base::Closure prefetch_cb = base::BarrierClosure(
 757       count, base::Bind(&MediaCodecPlayer::OnPrefetchDone, media_weak_this_));
 758
 759   if (do_audio)
 760     audio_decoder_->Prefetch(prefetch_cb);
 761
 762   if (do_video)
 763     video_decoder_->Prefetch(prefetch_cb);
 764 }
 765
 766 void MediaCodecPlayer::StartPlaybackOrBrowserSeek() {
 767   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 768   DVLOG(1) << __FUNCTION__;
 769
 770   // TODO(timav): consider replacing this method with posting a
 771   // browser seek task (i.e. generate an event) from StartPlaybackDecoders().
 772
 773   StartStatus status = StartPlaybackDecoders();
 774
 775   switch (status) {
 776     case kStartBrowserSeekRequired:
 777       // Browser seek
 778       SetState(kStateWaitingForSeek);
 779       SetPendingStart(true);
 780       StopDecoders();
 781       RequestDemuxerSeek(GetInterpolatedTime(), true);
 782       break;
 783     case kStartFailed:
 784       GetMediaTaskRunner()->PostTask(FROM_HERE, internal_error_cb_);
 785       break;
 786     case kStartOk:
 787       break;
 788   }
 789 }
 790
 791 MediaCodecPlayer::StartStatus MediaCodecPlayer::StartPlaybackDecoders() {
 792   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 793   DVLOG(1) << __FUNCTION__;
 794
 795   bool do_audio = !AudioFinished();
 796   bool do_video = !VideoFinished();
 797
 798   // If there is nothing to play, the state machine should determine this at the
 799   // prefetch state and never call this method.
 800   DCHECK(do_audio || do_video);
 801
 802   // Configure all streams before the start since we may discover that browser
 803   // seek is required. Start with video: if browser seek is required it would
 804   // not make sense to configure audio.
 805
 806   if (do_video) {
 807     MediaCodecDecoder::ConfigStatus status = video_decoder_->Configure();
 808     switch (status) {
 809       case MediaCodecDecoder::kConfigOk:
 810         break;
 811       case MediaCodecDecoder::kConfigKeyFrameRequired:
 812         // TODO(timav): post a task or return the status?
 813         return kStartBrowserSeekRequired;
 814       case MediaCodecDecoder::kConfigFailure:
 815         return kStartFailed;
 816     }
 817   }
 818
 819   if (do_audio) {
 820     MediaCodecDecoder::ConfigStatus status = audio_decoder_->Configure();
 821     if (status != MediaCodecDecoder::kConfigOk) {
 822       return kStartFailed;
 823     }
 824   }
 825
 826   // At this point decoder threads should not be running.
 827   if (!interpolator_.interpolating())
 828     interpolator_.StartInterpolating();
 829
 830   base::TimeDelta current_time = GetInterpolatedTime();
 831
 832   if (do_audio) {
 833     if (!audio_decoder_->Start(current_time)) {
 834       return kStartFailed;
 835     }
 836
 837     // Attach listener on UI thread
 838     ui_task_runner_->PostTask(FROM_HERE, attach_listener_cb_);
 839   }
 840
 841   if (do_video) {
 842     if (!video_decoder_->Start(current_time)) {
 843       return kStartFailed;
 844     }
 845   }
 846
 847   return kStartOk;
 848 }
 849
 850 void MediaCodecPlayer::StopDecoders() {
 851   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 852   DVLOG(1) << __FUNCTION__;
 853
 854   video_decoder_->SyncStop();
 855   audio_decoder_->SyncStop();
 856 }
 857
 858 void MediaCodecPlayer::RequestToStopDecoders() {
 859   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 860   DVLOG(1) << __FUNCTION__;
 861
 862   bool do_audio = false;
 863   bool do_video = false;
 864
 865   if (audio_decoder_->IsPrefetchingOrPlaying())
 866     do_audio = true;
 867   if (video_decoder_->IsPrefetchingOrPlaying())
 868     do_video = true;
 869
 870   if (!do_audio && !do_video) {
 871     GetMediaTaskRunner()->PostTask(
 872         FROM_HERE, base::Bind(&MediaCodecPlayer::OnStopDone, media_weak_this_));
 873     return;
 874   }
 875
 876   if (do_audio)
 877     audio_decoder_->RequestToStop();
 878   if (do_video)
 879     video_decoder_->RequestToStop();
 880 }
 881
 882 void MediaCodecPlayer::RequestDemuxerSeek(base::TimeDelta seek_time,
 883                                           bool is_browser_seek) {
 884   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 885   DVLOG(1) << __FUNCTION__ << " " << seek_time
 886            << (is_browser_seek ? " BROWSER_SEEK" : "");
 887
 888   // Flush decoders before requesting demuxer.
 889   audio_decoder_->Flush();
 890   video_decoder_->Flush();
 891
 892   // Save active seek data. Logically it is attached to kStateWaitingForSeek.
 893   DCHECK_EQ(kStateWaitingForSeek, state_);
 894   seek_info_.reset(new SeekInfo(seek_time, is_browser_seek));
 895
 896   demuxer_->RequestDemuxerSeek(seek_time, is_browser_seek);
 897 }
 898
 899 void MediaCodecPlayer::ReleaseDecoderResources() {
 900   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 901   DVLOG(1) << __FUNCTION__;
 902
 903   if (audio_decoder_)
 904     audio_decoder_->ReleaseDecoderResources();
 905
 906   if (video_decoder_)
 907     video_decoder_->ReleaseDecoderResources();
 908
 909   // At this point decoder threads should not be running
 910   if (interpolator_.interpolating())
 911     interpolator_.StopInterpolating();
 912 }
 913
 914 void MediaCodecPlayer::CreateDecoders() {
 915   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 916   DVLOG(1) << __FUNCTION__;
 917
 918   internal_error_cb_ = base::Bind(&MediaCodecPlayer::OnError, media_weak_this_);
 919
 920   audio_decoder_.reset(new MediaCodecAudioDecoder(
 921       GetMediaTaskRunner(), base::Bind(&MediaCodecPlayer::RequestDemuxerData,
 922                                        media_weak_this_, DemuxerStream::AUDIO),
 923       base::Bind(&MediaCodecPlayer::OnStarvation, media_weak_this_,
 924                  DemuxerStream::AUDIO),
 925       base::Bind(&MediaCodecPlayer::OnStopDone, media_weak_this_),
 926       internal_error_cb_,
 927       base::Bind(&MediaCodecPlayer::OnTimeIntervalUpdate, media_weak_this_,
 928                  DemuxerStream::AUDIO)));
 929
 930   video_decoder_.reset(new MediaCodecVideoDecoder(
 931       GetMediaTaskRunner(), base::Bind(&MediaCodecPlayer::RequestDemuxerData,
 932                                        media_weak_this_, DemuxerStream::VIDEO),
 933       base::Bind(&MediaCodecPlayer::OnStarvation, media_weak_this_,
 934                  DemuxerStream::VIDEO),
 935       base::Bind(&MediaCodecPlayer::OnStopDone, media_weak_this_),
 936       internal_error_cb_,
 937       base::Bind(&MediaCodecPlayer::OnTimeIntervalUpdate, media_weak_this_,
 938                  DemuxerStream::VIDEO),
 939       base::Bind(&MediaCodecPlayer::OnVideoResolutionChanged, media_weak_this_),
 940       base::Bind(&MediaCodecPlayer::OnVideoCodecCreated, media_weak_this_)));
 941 }
 942
 943 bool MediaCodecPlayer::AudioFinished() const {
 944   return audio_decoder_->IsCompleted() || !audio_decoder_->HasStream();
 945 }
 946
 947 bool MediaCodecPlayer::VideoFinished() const {
 948   return video_decoder_->IsCompleted() || !video_decoder_->HasStream();
 949 }
 950
 951 base::TimeDelta MediaCodecPlayer::GetInterpolatedTime() {
 952   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 953
 954   base::TimeDelta interpolated_time = interpolator_.GetInterpolatedTime();
 955   return std::min(interpolated_time, duration_);
 956 }
 957
 958 #undef RETURN_STRING
 959 #define RETURN_STRING(x) \
 960   case x:                \
 961     return #x;
 962
 963 const char* MediaCodecPlayer::AsString(PlayerState state) {
 964   switch (state) {
 965     RETURN_STRING(kStatePaused);
 966     RETURN_STRING(kStateWaitingForConfig);
 967     RETURN_STRING(kStatePrefetching);
 968     RETURN_STRING(kStatePlaying);
 969     RETURN_STRING(kStateStopping);
 970     RETURN_STRING(kStateWaitingForSurface);
 971     RETURN_STRING(kStateWaitingForSeek);
 972     RETURN_STRING(kStateError);
 973   }
 974   return nullptr;  // crash early
 975 }
 976
 977 #undef RETURN_STRING
 978
 979 }  // namespace media