Android media: VideoFrame should not store so many sync points.

content/renderer/media/android/webmediaplayer_android.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/android/webmediaplayer_android.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 78 matching lines @@
     RendererMediaPlayerManager* player_manager,
     RendererCdmManager* cdm_manager,
     scoped_refptr<StreamTextureFactory> factory,
     const scoped_refptr<base::MessageLoopProxy>& media_loop,
     media::MediaLog* media_log)
     : RenderFrameObserver(RenderFrame::FromWebFrame(frame)),
       frame_(frame),
       client_(client),
       delegate_(delegate),
       buffered_(static_cast<size_t>(1)),
+      main_loop_(base::MessageLoopProxy::current()),
       media_loop_(media_loop),
       ignore_metadata_duration_change_(false),
       pending_seek_(false),
       seeking_(false),
       did_loading_progress_(false),
       player_manager_(player_manager),
       cdm_manager_(cdm_manager),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       texture_id_(0),
@@ skipping 915 matching lines @@
                                           remote_playback_texture_id)),
       canvas_size /* coded_size */,
       gfx::Rect(canvas_size) /* visible_rect */,
       canvas_size /* natural_size */,
       base::TimeDelta() /* timestamp */,
       VideoFrame::ReadPixelsCB());
   SetCurrentFrameInternal(new_frame);
 }
 
 void WebMediaPlayerAndroid::ReallocateVideoFrame() {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   if (needs_external_surface_) {
     // VideoFrame::CreateHoleFrame is only defined under VIDEO_HOLE.
 #if defined(VIDEO_HOLE)
     if (!natural_size_.isEmpty()) {
       scoped_refptr<VideoFrame> new_frame =
           VideoFrame::CreateHoleFrame(natural_size_);
       SetCurrentFrameInternal(new_frame);
       // Force the client to grab the hole frame.
       client_->repaint();
     }
 #else
     NOTIMPLEMENTED() << "Hole punching not supported without VIDEO_HOLE flag";
 #endif  // defined(VIDEO_HOLE)
   } else if (!is_remote_ && texture_id_) {
     GLES2Interface* gl = stream_texture_factory_->ContextGL();
     GLuint texture_id_ref = 0;
+    // FIXME: reuse texture pool like gpu_video_decoder.

[dshwang, 2014/06/03 15:39:40]

Currently every frame create new texture. We can avoid via texture pool like
gpu_video_decoder.
If you agree on this approach, I'll improve about it.

     gl->GenTextures(1, &texture_id_ref);
     GLuint texture_target = kGLTextureExternalOES;
     gl->BindTexture(texture_target, texture_id_ref);
     gl->ConsumeTextureCHROMIUM(texture_target, texture_mailbox_.name);
     gl->Flush();
     GLuint texture_mailbox_sync_point = gl->InsertSyncPointCHROMIUM();
 
     scoped_refptr<VideoFrame> new_frame = VideoFrame::WrapNativeTexture(
         make_scoped_ptr(new gpu::MailboxHolder(
             texture_mailbox_, texture_target, texture_mailbox_sync_point)),
@@ skipping 42 matching lines @@
     stream_texture_factory_->SetStreamTextureSize(stream_id_, natural_size);
     stream_texture_proxy_initialized_ = true;
     cached_stream_texture_size_ = natural_size;
   }
 
   return video_frame;
 }
 
 void WebMediaPlayerAndroid::PutCurrentFrame(
     const scoped_refptr<media::VideoFrame>& frame) {
+  // Create new VideoFrame when a client return the previous frame.
+  DCHECK(!main_thread_checker_.CalledOnValidThread());
+  // FIXME: instead of here, VideoFrameProvider::Client::DidReceiveFrame() can
+  // handle it.

[dshwang, 2014/06/03 15:39:40]

I use PutCurrentFrame() as the end of each frame, but it feels alien because
other decoders do same thing when the frame is ready.
We can match this impl to other decoder via
VideoFrameProviderClientImpl::DidReceiveFrame() callback.

TL;DR
However, if VideoFrameProviderClientImpl::DidReceiveFrame() calls
WebMediaPlayerAndroid::DidReceiveFrame(), it looks weird too because
VideoFrameProviderClientImpl is subclass of VideoFrameProvider::Client and
WebMediaPlayerAndroid is subclass of VideoFrameProvider. Is it weird for
VideoFrameProvider::Client::DidReceiveFrame() to call
VideoFrameProvider::DidReceiveFrame()?

+  main_loop_->PostTask(FROM_HERE,
+                       base::Bind(&WebMediaPlayerAndroid::ReallocateVideoFrame,
+                                  weak_factory_.GetWeakPtr()));
 }
 
 void WebMediaPlayerAndroid::TryCreateStreamTextureProxyIfNeeded() {
   // Already created.
   if (stream_texture_proxy_)
     return;
 
   // No factory to create proxy.
   if (!stream_texture_factory_)
     return;
@@ skipping 443 matching lines @@
 
 void WebMediaPlayerAndroid::exitFullscreen() {
   player_manager_->ExitFullscreen(player_id_);
 }
 
 bool WebMediaPlayerAndroid::canEnterFullscreen() const {
   return player_manager_->CanEnterFullscreen(frame_);
 }
 
 }  // namespace content