ppapi: VideoEncoder: improve accuracy of encoding tick

native_client_sdk/src/examples/api/video_encode/video_encode.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 <math.h>
 #include <stdio.h>
 #include <string.h>
 
+#include <algorithm>
 #include <iostream>
 #include <map>
 #include <sstream>
 #include <vector>
 
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_console.h"
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/media_stream_video_track.h"
@@ skipping 149 matching lines @@
   PP_VideoFrame_Format frame_format_;
 
   pp::Size requested_size_;
   pp::Size frame_size_;
   pp::Size encoder_size_;
   uint32_t encoded_frames_;
 
   pp::VideoFrame current_track_frame_;
 
   IVFWriter ivf_writer_;
+
+  PP_Time last_encode_tick_;
 };
 
 VideoEncoderInstance::VideoEncoderInstance(PP_Instance instance,
                                            pp::Module* module)
     : pp::Instance(instance),
       is_encoding_(false),
       callback_factory_(this),
 #if defined(USE_VP8_INSTEAD_OF_H264)
       video_profile_(PP_VIDEOPROFILE_VP8_ANY),
 #else
       video_profile_(PP_VIDEOPROFILE_H264MAIN),
 #endif
       frame_format_(PP_VIDEOFRAME_FORMAT_I420),
-      encoded_frames_(0) {
+      encoded_frames_(0),
+      last_encode_tick_(0) {
   InitializeVideoProfiles();
   ProbeEncoder();
 }
 
 VideoEncoderInstance::~VideoEncoderInstance() {
 }
 
 void VideoEncoderInstance::AddVideoProfile(PP_VideoProfile profile,
                                            const std::string& profile_str) {
   profile_to_string_.insert(std::make_pair(profile, profile_str));
@@ skipping 125 matching lines @@
 
   if (encoder_size_ != frame_size_)
     ConfigureTrack();
   else {
     StartTrackFrames();
     ScheduleNextEncode();
   }
 }
 
 void VideoEncoderInstance::ScheduleNextEncode() {
+  PP_Time now = pp::Module::Get()->core()->GetTime();
   pp::Module::Get()->core()->CallOnMainThread(
-      1000 / 30,
+      std::min(std::max(now - last_encode_tick_, 0.0), 1000.0 / 30),
       callback_factory_.NewCallback(&VideoEncoderInstance::GetEncoderFrameTick),
       0);
+  last_encode_tick_ = now;
 }
 
 void VideoEncoderInstance::GetEncoderFrameTick(int32_t result) {
   if (is_encoding_) {
     if (!current_track_frame_.is_null()) {
       pp::VideoFrame frame = current_track_frame_;
       current_track_frame_.detach();
       GetEncoderFrame(frame);
     }
     ScheduleNextEncode();
@@ skipping 212 matching lines @@
 }
 
 }  // anonymous namespace
 
 namespace pp {
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new VideoEncoderModule();
 }
 }  // namespace pp