MediaCodecPlayer implementation (stage 3 - browser seek and surface change)

media/base/android/media_codec_player.cc

Index: media/base/android/media_codec_player.cc
diff --git a/media/base/android/media_codec_player.cc b/media/base/android/media_codec_player.cc
index 27b5bcadb86711426a3a84c18e7f929932578e7a..4123ad02eb2c4ec90ccdbc00d21424ad021ff9e0 100644
--- a/media/base/android/media_codec_player.cc
+++ b/media/base/android/media_codec_player.cc
@@ -58,7 +58,7 @@ MediaCodecPlayer::MediaCodecPlayer(
                          frame_url),
       ui_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       demuxer_(demuxer.Pass()),
-      state_(STATE_PAUSED),
+      state_(kStatePaused),
       interpolator_(&default_tick_clock_),
       pending_start_(false),
       pending_seek_(kNoTimestamp()),
@@ -73,6 +73,7 @@ MediaCodecPlayer::MediaCodecPlayer(
       base::Bind(&MediaPlayerManager::OnPlaybackComplete, manager, player_id);
   seek_done_cb_ =
       base::Bind(&MediaPlayerManager::OnSeekComplete, manager, player_id);
+  error_cb_ = base::Bind(&MediaPlayerManager::OnError, manager, player_id);
   attach_listener_cb_ = base::Bind(&MediaPlayerAndroid::AttachListener,
                                    WeakPtrForUIThread(), nullptr);
   detach_listener_cb_ =
@@ -130,16 +131,62 @@ void MediaCodecPlayer::SetVideoSurface(gfx::ScopedJavaSurface surface) {
 
   DVLOG(1) << __FUNCTION__ << (surface.IsEmpty() ? " empty" : " non-empty");
 
-  // I assume that if video decoder already has the surface,
-  // there will be two calls:
-  // (1) SetVideoSurface(0)
-  // (2) SetVideoSurface(new_surface)
-  video_decoder_->SetPendingSurface(surface.Pass());
+  // Save the empty-ness before we pass the surface to the decoder.
+  bool surface_is_empty = surface.IsEmpty();
 
-  if (video_decoder_->HasPendingSurface() &&
-      state_ == STATE_WAITING_FOR_SURFACE) {
-    SetState(STATE_PLAYING);
-    StartPlaybackDecoders();
+  // Apparently RemoveVideoSurface() can be called several times in a row,
+  // ignore the second and subsequent calls.
+  if (surface_is_empty && !video_decoder_->HasVideoSurface()) {
+    DVLOG(1) << __FUNCTION__ << ": surface already removed, ignoring";
+    return;
+  }
+
+  video_decoder_->SetVideoSurface(surface.Pass());
+
+  if (surface_is_empty) {
+    // Remove video surface.
+    switch (state_) {
+      case kStatePlaying:
+        if (VideoFinished())
+          break;
+
+        DVLOG(1) << __FUNCTION__ << ": stopping and restarting";
+        // Stop decoders as quickly as possible.
+        StopDecoders();  // synchronous stop
+
+        // Prefetch or wait for initial configuration.
+        if (HasAudio() || HasVideo()) {
+          SetState(kStatePrefetching);
+          StartPrefetchDecoders();
+        } else {
+          SetState(kStateWaitingForConfig);
+        }
+        break;
+
+      default:
+        break;  // ignore
+    }
+  } else {
+    // Replace video surface.
+    switch (state_) {
+      case kStateWaitingForSurface:
+        SetState(kStatePlaying);
+        StartPlaybackOrBrowserSeek();
+        break;
+
+      case kStatePlaying:
+        if (VideoFinished())
+          break;
+
+        DVLOG(1) << __FUNCTION__ << ": requesting to stop and restart";
+        SetState(kStateStopping);
+        RequestToStopDecoders();
+        SetPendingStart(true);
+        break;
+
+      default:
+        break;  // ignore
+    }
   }
 }
 
@@ -149,24 +196,24 @@ void MediaCodecPlayer::Start() {
   DVLOG(1) << __FUNCTION__;
 
   switch (state_) {
-    case STATE_PAUSED:
+    case kStatePaused:
       // Prefetch or wait for initial configuration.
       if (HasAudio() || HasVideo()) {
-        SetState(STATE_PREFETCHING);
+        SetState(kStatePrefetching);
         StartPrefetchDecoders();
       } else {
-        SetState(STATE_WAITING_FOR_CONFIG);
+        SetState(kStateWaitingForConfig);
       }
       break;
-    case STATE_STOPPING:
-    case STATE_WAITING_FOR_SEEK:
+    case kStateStopping:
+    case kStateWaitingForSeek:
       SetPendingStart(true);
       break;
-    case STATE_WAITING_FOR_CONFIG:
-    case STATE_PREFETCHING:
-    case STATE_PLAYING:
-    case STATE_WAITING_FOR_SURFACE:
-    case STATE_ERROR:
+    case kStateWaitingForConfig:
+    case kStatePrefetching:
+    case kStatePlaying:
+    case kStateWaitingForSurface:
+    case kStateError:
       break;  // Ignore
     default:
       NOTREACHED();
@@ -182,20 +229,20 @@ void MediaCodecPlayer::Pause(bool is_media_related_action) {
   SetPendingStart(false);
 
   switch (state_) {
-    case STATE_WAITING_FOR_CONFIG:
-    case STATE_PREFETCHING:
-    case STATE_WAITING_FOR_SURFACE:
-      SetState(STATE_PAUSED);
+    case kStateWaitingForConfig:
+    case kStatePrefetching:
+    case kStateWaitingForSurface:
+      SetState(kStatePaused);
       StopDecoders();
       break;
-    case STATE_PLAYING:
-      SetState(STATE_STOPPING);
+    case kStatePlaying:
+      SetState(kStateStopping);
       RequestToStopDecoders();
       break;
-    case STATE_PAUSED:
-    case STATE_STOPPING:
-    case STATE_WAITING_FOR_SEEK:
-    case STATE_ERROR:
+    case kStatePaused:
+    case kStateStopping:
+    case kStateWaitingForSeek:
+    case kStateError:
       break;  // Ignore
     default:
       NOTREACHED();
@@ -209,31 +256,31 @@ void MediaCodecPlayer::SeekTo(base::TimeDelta timestamp) {
   DVLOG(1) << __FUNCTION__ << " " << timestamp;
 
   switch (state_) {
-    case STATE_PAUSED:
-      SetState(STATE_WAITING_FOR_SEEK);
+    case kStatePaused:
+      SetState(kStateWaitingForSeek);
       RequestDemuxerSeek(timestamp);
       break;
-    case STATE_WAITING_FOR_CONFIG:
-    case STATE_PREFETCHING:
-    case STATE_WAITING_FOR_SURFACE:
-      SetState(STATE_WAITING_FOR_SEEK);
+    case kStateWaitingForConfig:
+    case kStatePrefetching:
+    case kStateWaitingForSurface:
+      SetState(kStateWaitingForSeek);
       StopDecoders();
       SetPendingStart(true);
       RequestDemuxerSeek(timestamp);
       break;
-    case STATE_PLAYING:
-      SetState(STATE_STOPPING);
+    case kStatePlaying:
+      SetState(kStateStopping);
       RequestToStopDecoders();
       SetPendingStart(true);
       SetPendingSeek(timestamp);
       break;
-    case STATE_STOPPING:
+    case kStateStopping:
       SetPendingSeek(timestamp);
       break;
-    case STATE_WAITING_FOR_SEEK:
+    case kStateWaitingForSeek:
       SetPendingSeek(timestamp);
       break;
-    case STATE_ERROR:
+    case kStateError:
       break;  // ignore
     default:
       NOTREACHED();
@@ -246,8 +293,22 @@ void MediaCodecPlayer::Release() {
 
   DVLOG(1) << __FUNCTION__;
 
-  SetState(STATE_PAUSED);
+  // Stop decoding threads and delete MediaCodecs, but keep IPC between browser
+  // and renderer processes going. Seek should work across and after Release().
+
   ReleaseDecoderResources();
+
+  SetPendingStart(false);
+
+  if (state_ != kStateWaitingForSeek)
+    SetState(kStatePaused);
+
+  base::TimeDelta pending_seek_time = GetPendingSeek();
+  if (pending_seek_time != kNoTimestamp()) {
+    SetPendingSeek(kNoTimestamp());
+    SetState(kStateWaitingForSeek);
+    RequestDemuxerSeek(pending_seek_time);
+  }
 }
 
 void MediaCodecPlayer::SetVolume(double volume) {
@@ -282,7 +343,7 @@ bool MediaCodecPlayer::IsPlaying() {
 
   // TODO(timav): Use another variable since |state_| should only be accessed on
   // Media thread.
-  return state_ == STATE_PLAYING || state_ == STATE_STOPPING;
+  return state_ == kStatePlaying || state_ == kStateStopping;
 }
 
 bool MediaCodecPlayer::CanPause() {
@@ -354,9 +415,6 @@ void MediaCodecPlayer::OnDemuxerSeekDone(
 
   DVLOG(1) << __FUNCTION__ << " actual_time:" << actual_browser_seek_time;
 
-  if (state_ != STATE_WAITING_FOR_SEEK)
-    return;  // ignore
-
   DCHECK(seek_info_.get());
   DCHECK(seek_info_->seek_time != kNoTimestamp());
 
@@ -375,9 +433,22 @@ void MediaCodecPlayer::OnDemuxerSeekDone(
   interpolator_.SetBounds(seek_time, seek_time);
   audio_decoder_->SetBaseTimestamp(seek_time);
 
+  // The Flush() might set the state to kStateError.
+  if (state_ == kStateError) {

[Tima Vaisburd, 2015/07/30 20:28:36]

This is the new error state handling.

[wolenetz, 2015/07/30 21:10:39]

I'm having difficulty understanding this scenario. Is this a pre-existing defect
of MediaSourcePlayer, too? And for desktop Pipeline.cc?

What is the net effect of signaling seek done back to WMPA (if somehow we are in
error state when we receive notice that the demuxer has finished a requested
seek) versus not signaling completion of the seek? I think what you have here is
more correct, I just would like to understand more clearly the impact.

[wolenetz, 2015/07/30 21:41:10]

I looked further into desktop WMPI and Pipeline behavior when error is
encountered during a seek operation. tl;dr: signaling seek_done_cb_ here sgtm
and is more in parity with desktop implementation of Pipeline.

Detail:
desktop uses a SerialRunner to process the various steps in a seek. Any step
(including flush) that results in error (anything but PIPELINE_OK) cancels the
remaining steps. There's some funkiness around pending seek in WMPI too, but the
seek completion callback into WMPI is called even in the case of error. So I
think your change is not regressing.

lgtm % previous 2 nits

+    // Notify the Renderer.
+    if (!seek_info_->is_browser_seek)
+      ui_task_runner_->PostTask(FROM_HERE,
+                                base::Bind(seek_done_cb_, seek_time));
+
+    seek_info_.reset();
+    return;
+  }
+
+  DCHECK(state_ == kStateWaitingForSeek);

[wolenetz, 2015/07/30 21:10:39]

nit: DCHECK_EQ(kStateWaitingForSeek, state_);

[Tima Vaisburd, 2015/07/30 22:25:32]

Done.

+
   base::TimeDelta pending_seek_time = GetPendingSeek();
   if (pending_seek_time != kNoTimestamp()) {
-    // Keep STATE_WAITING_FOR_SEEK
+    // Keep kStateWaitingForSeek
     SetPendingSeek(kNoTimestamp());
     RequestDemuxerSeek(pending_seek_time);
     return;
@@ -387,13 +458,13 @@ void MediaCodecPlayer::OnDemuxerSeekDone(
     SetPendingStart(false);
     // Prefetch or wait for initial configuration.
     if (HasAudio() || HasVideo()) {
-      SetState(STATE_PREFETCHING);
+      SetState(kStatePrefetching);
       StartPrefetchDecoders();
     } else {
-      SetState(STATE_WAITING_FOR_CONFIG);
+      SetState(kStateWaitingForConfig);
     }
   } else {
-    SetState(STATE_PAUSED);
+    SetState(kStatePaused);
   }
 
   // Notify the Renderer.
@@ -458,7 +529,7 @@ void MediaCodecPlayer::RequestDemuxerData(DemuxerStream::Type stream_type) {
 void MediaCodecPlayer::OnPrefetchDone() {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 
-  if (state_ != STATE_PREFETCHING) {
+  if (state_ != kStatePrefetching) {
     DVLOG(1) << __FUNCTION__ << " wrong state " << AsString(state_)
              << " ignoring";
     return;  // Ignore
@@ -470,17 +541,18 @@ void MediaCodecPlayer::OnPrefetchDone() {
     // No configuration at all after prefetching.
     // This is an error, initial configuration is expected
     // before the first data chunk.
-    GetMediaTaskRunner()->PostTask(FROM_HERE, error_cb_);
+    DCHECK(!internal_error_cb_.is_null());
+    GetMediaTaskRunner()->PostTask(FROM_HERE, internal_error_cb_);
     return;
   }
 
-  if (HasVideo() && !HasPendingSurface()) {
-    SetState(STATE_WAITING_FOR_SURFACE);
+  if (HasVideo() && !video_decoder_->HasVideoSurface()) {
+    SetState(kStateWaitingForSurface);
     return;
   }
 
-  SetState(STATE_PLAYING);
-  StartPlaybackDecoders();
+  SetState(kStatePlaying);
+  StartPlaybackOrBrowserSeek();
 }
 
 void MediaCodecPlayer::OnStopDone() {
@@ -496,23 +568,23 @@ void MediaCodecPlayer::OnStopDone() {
 
   base::TimeDelta seek_time;
   switch (state_) {
-    case STATE_STOPPING: {
+    case kStateStopping: {
       base::TimeDelta seek_time = GetPendingSeek();
       if (seek_time != kNoTimestamp()) {
-        SetState(STATE_WAITING_FOR_SEEK);
+        SetState(kStateWaitingForSeek);
         SetPendingSeek(kNoTimestamp());
         RequestDemuxerSeek(seek_time);
       } else if (HasPendingStart()) {
         SetPendingStart(false);
-        SetState(STATE_PREFETCHING);
+        SetState(kStatePrefetching);
         StartPrefetchDecoders();
       } else {
-        SetState(STATE_PAUSED);
+        SetState(kStatePaused);
       }
     } break;
-    case STATE_PLAYING:
+    case kStatePlaying:
       // Unexpected stop means completion
-      SetState(STATE_PAUSED);
+      SetState(kStatePaused);
       break;
     default:
       // DVLOG(0) << __FUNCTION__ << " illegal state: " << AsString(state_);
@@ -520,7 +592,7 @@ void MediaCodecPlayer::OnStopDone() {
       // Ignore! There can be a race condition: audio posts OnStopDone,
       // then video posts, then first OnStopDone arrives at which point
       // both streams are already stopped, then second OnStopDone arrives. When
-      // the second one arrives, the state us not STATE_STOPPING any more.
+      // the second one arrives, the state us not kStateStopping any more.
       break;
   }
 
@@ -535,20 +607,23 @@ void MediaCodecPlayer::OnError() {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
-  // STATE_ERROR blocks all events
-  SetState(STATE_ERROR);
+  // kStateError blocks all events
+  SetState(kStateError);
 
   ReleaseDecoderResources();
+
+  ui_task_runner_->PostTask(FROM_HERE,
+                            base::Bind(error_cb_, MEDIA_ERROR_DECODE));
 }
 
 void MediaCodecPlayer::OnStarvation(DemuxerStream::Type type) {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " stream type:" << type;
 
-  if (state_ != STATE_PLAYING)
+  if (state_ != kStatePlaying)
     return;  // Ignore
 
-  SetState(STATE_STOPPING);
+  SetState(kStateStopping);
   RequestToStopDecoders();
   SetPendingStart(true);
 }
@@ -605,17 +680,6 @@ void MediaCodecPlayer::SetState(PlayerState new_state) {
   state_ = new_state;
 }
 
-void MediaCodecPlayer::SetPendingSurface(gfx::ScopedJavaSurface surface) {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__;
-
-  video_decoder_->SetPendingSurface(surface.Pass());
-}
-
-bool MediaCodecPlayer::HasPendingSurface() const {
-  return video_decoder_->HasPendingSurface();
-}
-
 void MediaCodecPlayer::SetPendingStart(bool need_to_start) {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << ": " << need_to_start;
@@ -665,8 +729,8 @@ void MediaCodecPlayer::SetDemuxerConfigs(const DemuxerConfigs& configs) {
   if (configs.video_codec != kUnknownVideoCodec)
     video_decoder_->SetDemuxerConfigs(configs);
 
-  if (state_ == STATE_WAITING_FOR_CONFIG) {
-    SetState(STATE_PREFETCHING);
+  if (state_ == kStateWaitingForConfig) {
+    SetState(kStatePrefetching);
     StartPrefetchDecoders();
   }
 }
@@ -699,33 +763,63 @@ void MediaCodecPlayer::StartPrefetchDecoders() {
     video_decoder_->Prefetch(prefetch_cb);
 }
 
-void MediaCodecPlayer::StartPlaybackDecoders() {
+void MediaCodecPlayer::StartPlaybackOrBrowserSeek() {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
-  // Configure all streams before the start since
-  // we may discover that browser seek is required.
+  // TODO(timav): consider replacing this method with posting a
+  // browser seek task (i.e. generate an event) from StartPlaybackDecoders().
+
+  StartStatus status = StartPlaybackDecoders();
+
+  switch (status) {
+    case kStartBrowserSeekRequired:
+      // Browser seek
+      SetState(kStateWaitingForSeek);
+      SetPendingStart(true);
+      StopDecoders();
+      RequestDemuxerSeek(GetInterpolatedTime(), true);
+      break;
+    case kStartFailed:
+      GetMediaTaskRunner()->PostTask(FROM_HERE, internal_error_cb_);
+      break;
+    case kStartOk:
+      break;
+  }
+}
+
+MediaCodecPlayer::StartStatus MediaCodecPlayer::StartPlaybackDecoders() {
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__;
 
   bool do_audio = !AudioFinished();
   bool do_video = !VideoFinished();
 
-  // If there is nothing to play, the state machine should determine
-  // this at the prefetch state and never call this method.
+  // If there is nothing to play, the state machine should determine this at the
+  // prefetch state and never call this method.
   DCHECK(do_audio || do_video);
 
-  if (do_audio) {
-    MediaCodecDecoder::ConfigStatus status = audio_decoder_->Configure();
-    if (status != MediaCodecDecoder::CONFIG_OK) {
-      GetMediaTaskRunner()->PostTask(FROM_HERE, error_cb_);
-      return;
-    }
-  }
+  // Configure all streams before the start since we may discover that browser
+  // seek is required. Start with video: if browser seek is required it would
+  // not make sense to configure audio.
 
   if (do_video) {
     MediaCodecDecoder::ConfigStatus status = video_decoder_->Configure();
-    if (status != MediaCodecDecoder::CONFIG_OK) {
-      GetMediaTaskRunner()->PostTask(FROM_HERE, error_cb_);
-      return;
+    switch (status) {
+      case MediaCodecDecoder::kConfigOk:
+        break;
+      case MediaCodecDecoder::kConfigKeyFrameRequired:
+        // TODO(timav): post a task or return the status?
+        return kStartBrowserSeekRequired;
+      case MediaCodecDecoder::kConfigFailure:
+        return kStartFailed;
+    }
+  }
+
+  if (do_audio) {
+    MediaCodecDecoder::ConfigStatus status = audio_decoder_->Configure();
+    if (status != MediaCodecDecoder::kConfigOk) {
+      return kStartFailed;
     }
   }
 
@@ -737,8 +831,7 @@ void MediaCodecPlayer::StartPlaybackDecoders() {
 
   if (do_audio) {
     if (!audio_decoder_->Start(current_time)) {
-      GetMediaTaskRunner()->PostTask(FROM_HERE, error_cb_);
-      return;
+      return kStartFailed;
     }
 
     // Attach listener on UI thread
@@ -747,18 +840,19 @@ void MediaCodecPlayer::StartPlaybackDecoders() {
 
   if (do_video) {
     if (!video_decoder_->Start(current_time)) {
-      GetMediaTaskRunner()->PostTask(FROM_HERE, error_cb_);
-      return;
+      return kStartFailed;
     }
   }
+
+  return kStartOk;
 }
 
 void MediaCodecPlayer::StopDecoders() {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
-  audio_decoder_->SyncStop();
   video_decoder_->SyncStop();
+  audio_decoder_->SyncStop();
 }
 
 void MediaCodecPlayer::RequestToStopDecoders() {
@@ -789,14 +883,14 @@ void MediaCodecPlayer::RequestDemuxerSeek(base::TimeDelta seek_time,
                                           bool is_browser_seek) {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " " << seek_time
-           << (is_browser_seek ? " browser_seek" : "");
+           << (is_browser_seek ? " BROWSER_SEEK" : "");
 
   // Flush decoders before requesting demuxer.
   audio_decoder_->Flush();
   video_decoder_->Flush();
 
-  // Save active seek data. Logically it is attached to STATE_WAITING_FOR_SEEK.
-  DCHECK(state_ == STATE_WAITING_FOR_SEEK);
+  // Save active seek data. Logically it is attached to kStateWaitingForSeek.
+  DCHECK(state_ == kStateWaitingForSeek);

[wolenetz, 2015/07/30 21:10:39]

nit ditto

[Tima Vaisburd, 2015/07/30 22:25:32]

Done.

   seek_info_.reset(new SeekInfo(seek_time, is_browser_seek));
 
   demuxer_->RequestDemuxerSeek(seek_time, is_browser_seek);
@@ -821,14 +915,15 @@ void MediaCodecPlayer::CreateDecoders() {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
-  error_cb_ = base::Bind(&MediaCodecPlayer::OnError, media_weak_this_);
+  internal_error_cb_ = base::Bind(&MediaCodecPlayer::OnError, media_weak_this_);
 
   audio_decoder_.reset(new MediaCodecAudioDecoder(
       GetMediaTaskRunner(), base::Bind(&MediaCodecPlayer::RequestDemuxerData,
                                        media_weak_this_, DemuxerStream::AUDIO),
       base::Bind(&MediaCodecPlayer::OnStarvation, media_weak_this_,
                  DemuxerStream::AUDIO),
-      base::Bind(&MediaCodecPlayer::OnStopDone, media_weak_this_), error_cb_,
+      base::Bind(&MediaCodecPlayer::OnStopDone, media_weak_this_),
+      internal_error_cb_,
       base::Bind(&MediaCodecPlayer::OnTimeIntervalUpdate, media_weak_this_,
                  DemuxerStream::AUDIO)));
 
@@ -837,7 +932,8 @@ void MediaCodecPlayer::CreateDecoders() {
                                        media_weak_this_, DemuxerStream::VIDEO),
       base::Bind(&MediaCodecPlayer::OnStarvation, media_weak_this_,
                  DemuxerStream::VIDEO),
-      base::Bind(&MediaCodecPlayer::OnStopDone, media_weak_this_), error_cb_,
+      base::Bind(&MediaCodecPlayer::OnStopDone, media_weak_this_),
+      internal_error_cb_,
       base::Bind(&MediaCodecPlayer::OnTimeIntervalUpdate, media_weak_this_,
                  DemuxerStream::VIDEO),
       base::Bind(&MediaCodecPlayer::OnVideoResolutionChanged, media_weak_this_),
@@ -866,14 +962,14 @@ base::TimeDelta MediaCodecPlayer::GetInterpolatedTime() {
 
 const char* MediaCodecPlayer::AsString(PlayerState state) {
   switch (state) {
-    RETURN_STRING(STATE_PAUSED);
-    RETURN_STRING(STATE_WAITING_FOR_CONFIG);
-    RETURN_STRING(STATE_PREFETCHING);
-    RETURN_STRING(STATE_PLAYING);
-    RETURN_STRING(STATE_STOPPING);
-    RETURN_STRING(STATE_WAITING_FOR_SURFACE);
-    RETURN_STRING(STATE_WAITING_FOR_SEEK);
-    RETURN_STRING(STATE_ERROR);
+    RETURN_STRING(kStatePaused);
+    RETURN_STRING(kStateWaitingForConfig);
+    RETURN_STRING(kStatePrefetching);
+    RETURN_STRING(kStatePlaying);
+    RETURN_STRING(kStateStopping);
+    RETURN_STRING(kStateWaitingForSurface);
+    RETURN_STRING(kStateWaitingForSeek);
+    RETURN_STRING(kStateError);
   }
   return nullptr;  // crash early
 }