Combine bytes-decoded notification with memory usage and frame count.

media/renderers/video_renderer_impl.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/renderers/video_renderer_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 33 matching lines @@
                                                media_log)),
       gpu_memory_buffer_pool_(nullptr),
       media_log_(media_log),
       low_delay_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       state_(kUninitialized),
       pending_read_(false),
       drop_frames_(drop_frames),
       buffering_state_(BUFFERING_HAVE_NOTHING),
+      bytes_decoded_(0),
       frames_decoded_(0),
       frames_dropped_(0),
       tick_clock_(new base::DefaultTickClock()),
       was_background_rendering_(false),
       time_progressing_(false),
       last_video_memory_usage_(0),
       have_renderered_frames_(false),
       last_frame_opaque_(false),
       weak_factory_(this),
       frame_callback_weak_factory_(this) {
@@ skipping 86 matching lines @@
   // failed.
   init_cb_ = BindToCurrentLoop(init_cb);
 
   client_ = client;
   wall_clock_time_cb_ = wall_clock_time_cb;
   state_ = kInitializing;
 
   video_frame_stream_->Initialize(
       stream, base::Bind(&VideoRendererImpl::OnVideoFrameStreamInitialized,
                          weak_factory_.GetWeakPtr()),
-      cdm_context, base::Bind(&VideoRendererImpl::OnStatisticsUpdate,
-                              weak_factory_.GetWeakPtr()),
+      cdm_context,
+      base::Bind(&VideoRendererImpl::BytesDecoded, weak_factory_.GetWeakPtr()),

[DaleCurtis, 2016/06/17 23:03:17]

This is only returned when a frame is decoded, so I wonder if we should return
it instead as metadata on each video frame and drop this entire callback.

[alokp, 2016/06/18 04:18:06]

We could do that, but what do you want to do for AudioRendererImpl? We need to
do something symmetric for both Audio and Video renderers because they both use
DecoderStream<DemuxerStream::Type>.

FWIW this callback is pretty cheap now.

       base::Bind(&VideoRendererImpl::OnWaitingForDecryptionKey,
                  weak_factory_.GetWeakPtr()));
 }
 
 scoped_refptr<VideoFrame> VideoRendererImpl::Render(
     base::TimeTicks deadline_min,
     base::TimeTicks deadline_max,
     bool background_rendering) {
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kPlaying);
@@ skipping 138 matching lines @@
 
     // Make sure we expire everything we can if we can't read anymore currently,
     // otherwise playback may hang indefinitely.  Note: There are no effective
     // frames queued at this point, otherwise FrameReady() would have canceled
     // the underflow state before reaching this point.
     if (buffering_state_ == BUFFERING_HAVE_NOTHING)
       RemoveFramesForUnderflowOrBackgroundRendering();
   }
 }
 
+void VideoRendererImpl::BytesDecoded(uint64_t bytes) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  base::AutoLock auto_lock(lock_);
+  bytes_decoded_ += bytes;
+}
+
 void VideoRendererImpl::FrameReadyForCopyingToGpuMemoryBuffers(
     VideoFrameStream::Status status,
     const scoped_refptr<VideoFrame>& frame) {
   if (status != VideoFrameStream::OK || IsBeforeStartTime(frame->timestamp())) {
     VideoRendererImpl::FrameReady(status, frame);
     return;
   }
 
   DCHECK(frame);
   gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
@@ skipping 196 matching lines @@
   base::ResetAndReturn(&flush_cb_).Run();
 }
 
 void VideoRendererImpl::UpdateStats_Locked() {
   lock_.AssertAcquired();
   DCHECK_GE(frames_decoded_, 0);
   DCHECK_GE(frames_dropped_, 0);
 
   if (frames_decoded_ || frames_dropped_) {
     PipelineStatistics statistics;
+    statistics.video_bytes_decoded = bytes_decoded_;
     statistics.video_frames_decoded = frames_decoded_;
     statistics.video_frames_dropped = frames_dropped_;
 
     const size_t memory_usage = algorithm_->GetMemoryUsage();
     statistics.video_memory_usage = memory_usage - last_video_memory_usage_;
 
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&VideoRendererImpl::OnStatisticsUpdate,
                                       weak_factory_.GetWeakPtr(), statistics));
+    bytes_decoded_ = 0;
     frames_decoded_ = 0;
     frames_dropped_ = 0;
     last_video_memory_usage_ = memory_usage;
   }
 }
 
 bool VideoRendererImpl::HaveReachedBufferingCap() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   const size_t kMaxVideoFrames = limits::kMaxVideoFrames;
 
@@ skipping 132 matching lines @@
 
 void VideoRendererImpl::AttemptReadAndCheckForMetadataChanges(
     VideoPixelFormat pixel_format,
     const gfx::Size& natural_size) {
   base::AutoLock auto_lock(lock_);
   CheckForMetadataChanges(pixel_format, natural_size);
   AttemptRead_Locked();
 }
 
 }  // namespace media