Release video frames earlier in MediaRecorder

media/muxers/webm_muxer.cc

 // Copyright 2015 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/muxers/webm_muxer.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/limits.h"
 #include "media/base/video_frame.h"
 #include "media/filters/opus_constants.h"
-#include "ui/gfx/geometry/size.h"
 
 namespace media {
 
 namespace {
 
 void WriteOpusHeader(const media::AudioParameters& params, uint8_t* header) {
   // See https://wiki.xiph.org/OggOpus#ID_Header.
   // Set magic signature.
   std::string label = "OpusHead";
   memcpy(header + OPUS_EXTRADATA_LABEL_OFFSET, label.c_str(), label.size());
@@ skipping 24 matching lines @@
     // Set the actual stream map.
     for (int i = 0; i < params.channels(); ++i) {
       header[OPUS_EXTRADATA_STREAM_MAP_OFFSET + i] =
           kOpusVorbisChannelMap[params.channels() - 1][i];
     }
   } else {
     header[OPUS_EXTRADATA_CHANNEL_MAPPING_OFFSET] = 0;
   }
 }
 
-static double GetFrameRate(const scoped_refptr<VideoFrame>& video_frame) {
+static double GetFrameRate(const WebmMuxer::VideoParameters& params) {
   const double kZeroFrameRate = 0.0;
   const double kDefaultFrameRate = 30.0;
 
-  double frame_rate = kDefaultFrameRate;
-  if (!video_frame->metadata()->GetDouble(VideoFrameMetadata::FRAME_RATE,
-                                          &frame_rate) ||
-      frame_rate <= kZeroFrameRate ||
+  double frame_rate = params.frame_rate;
+  if (frame_rate <= kZeroFrameRate ||
       frame_rate > media::limits::kMaxFramesPerSecond) {
     frame_rate = kDefaultFrameRate;
   }
   return frame_rate;
 }
 
 static const char kH264CodecId[] = "V_MPEG4/ISO/AVC";
 
 static const char* MkvCodeIcForMediaVideoCodecId(VideoCodec video_codec) {
   switch (video_codec) {
     case kCodecVP8:
       return mkvmuxer::Tracks::kVp8CodecId;
     case kCodecVP9:
       return mkvmuxer::Tracks::kVp9CodecId;
     case kCodecH264:
       return kH264CodecId;
     default:
       NOTREACHED() << "Unsupported codec " << GetCodecName(video_codec);
       return "";
   }
 }
 
 }  // anonymous namespace
 
+WebmMuxer::VideoParameters::VideoParameters(
+    scoped_refptr<media::VideoFrame> frame) {
+  visible_rect_size = frame->visible_rect().size();
+  frame_rate = 0.0;
+  ignore_result(frame->metadata()->GetDouble(VideoFrameMetadata::FRAME_RATE,
+                                             &frame_rate));
+}
+
+WebmMuxer::VideoParameters::~VideoParameters() {}
+
 WebmMuxer::WebmMuxer(VideoCodec codec,
                      bool has_video,
                      bool has_audio,
                      const WriteDataCB& write_data_callback)
     : video_codec_(codec),
       video_track_index_(0),
       audio_track_index_(0),
       has_video_(has_video),
       has_audio_(has_audio),
       write_data_callback_(write_data_callback),
@@ skipping 15 matching lines @@
   thread_checker_.DetachFromThread();
 }
 
 WebmMuxer::~WebmMuxer() {
   // No need to segment_.Finalize() since is not Seekable(), i.e. a live
   // stream, but is a good practice.
   DCHECK(thread_checker_.CalledOnValidThread());
   segment_.Finalize();
 }
 
-void WebmMuxer::OnEncodedVideo(const scoped_refptr<VideoFrame>& video_frame,
+void WebmMuxer::OnEncodedVideo(const VideoParameters& params,
                                std::unique_ptr<std::string> encoded_data,
                                base::TimeTicks timestamp,
                                bool is_key_frame) {
   DVLOG(1) << __func__ << " - " << encoded_data->size() << "B";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!video_track_index_) {
     // |track_index_|, cannot be zero (!), initialize WebmMuxer in that case.
     // http://www.matroska.org/technical/specs/index.html#Tracks
-    AddVideoTrack(video_frame->visible_rect().size(),
-                  GetFrameRate(video_frame));
+    AddVideoTrack(params.visible_rect_size, GetFrameRate(params));
     if (first_frame_timestamp_video_.is_null())
       first_frame_timestamp_video_ = timestamp;
   }
 
   // TODO(ajose): Support multiple tracks: http://crbug.com/528523
   if (has_audio_ && !audio_track_index_) {
     DVLOG(1) << __func__ << ": delaying until audio track ready.";
     if (is_key_frame)  // Upon Key frame reception, empty the encoded queue.
       encoded_frames_queue_.clear();
 
@@ skipping 176 matching lines @@
 
 WebmMuxer::EncodedVideoFrame::EncodedVideoFrame(
     std::unique_ptr<std::string> data,
     base::TimeTicks timestamp,
     bool is_keyframe)
     : data(std::move(data)), timestamp(timestamp), is_keyframe(is_keyframe) {}
 
 WebmMuxer::EncodedVideoFrame::~EncodedVideoFrame() {}
 
 }  // namespace media