ppapi: VideoEncoder: prevent scheduling encoding multiple times

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>
@@ skipping 28 matching lines @@
 // include-guards), make sure this is the last file #include'd in this file.
 #undef NDEBUG
 #include <assert.h>
 
 #define fourcc(a, b, c, d)                                               \
   (((uint32_t)(a) << 0) | ((uint32_t)(b) << 8) | ((uint32_t)(c) << 16) | \
    ((uint32_t)(d) << 24))
 
 namespace {
 
+double clamp(double min, double max, double value) {
+  return std::max(std::min(value, max), min);
+}
+
 // IVF container writer. It is possible to parse H264 bitstream using
 // NAL units but for VP8 we need a container to at least find encoded
 // pictures as well as the picture sizes.
 class IVFWriter {
  public:
   IVFWriter() {}
   ~IVFWriter() {}
 
   uint32_t GetFileHeaderSize() const { return 32; }
   uint32_t GetFrameHeaderSize() const { return 12; }
@@ skipping 95 matching lines @@
 
   void PostDataMessage(const void* buffer, uint32_t size);
 
   typedef std::map<std::string, PP_VideoProfile> VideoProfileFromStringMap;
   VideoProfileFromStringMap profile_from_string_;
 
   typedef std::map<PP_VideoProfile, std::string> VideoProfileToStringMap;
   VideoProfileToStringMap profile_to_string_;
 
   bool is_encoding_;
+  bool is_encode_ticking_;
   bool is_receiving_track_frames_;
 
   pp::VideoEncoder video_encoder_;
   pp::MediaStreamVideoTrack video_track_;
   pp::CompletionCallbackFactory<VideoEncoderInstance> callback_factory_;
 
   PP_VideoProfile video_profile_;
   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),
+      is_encode_ticking_(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),
       last_encode_tick_(0) {
   InitializeVideoProfiles();
@@ skipping 134 matching lines @@
 
   if (encoder_size_ != frame_size_)
     ConfigureTrack();
   else {
     StartTrackFrames();
     ScheduleNextEncode();
   }
 }
 
 void VideoEncoderInstance::ScheduleNextEncode() {
+  // Avoid scheduling more than once at a time.
+  if (is_encode_ticking_)
+    return;
+
   PP_Time now = pp::Module::Get()->core()->GetTime();
+  PP_Time tick = 1.0 / 30;
+  // If the callback was triggered late, we need to account for that
+  // delay for the next tick.
+  PP_Time delta = tick - clamp(0, tick, now - last_encode_tick_ - tick);

[binji, 2015/06/30 18:50:34]

Just to be clear: this assumes the callback is never called early, right? I
guess that never happens in practice.

[llandwerlin-old, 2015/06/30 19:14:15]

Yes, that's right. I assumed the implementation would be similar to a poll() on
unix ("the actual timeout interval shall be rounded up to the next supported
value" http://pubs.opengroup.org/onlinepubs/009695399/functions/poll.html)

+
   pp::Module::Get()->core()->CallOnMainThread(
-      std::min(std::max(now - last_encode_tick_, 0.0), 1000.0 / 30),
+      delta * 1000,
       callback_factory_.NewCallback(&VideoEncoderInstance::GetEncoderFrameTick),
       0);
+
   last_encode_tick_ = now;
+  is_encode_ticking_ = true;
 }
 
 void VideoEncoderInstance::GetEncoderFrameTick(int32_t result) {
+  is_encode_ticking_ = false;
+
   if (is_encoding_) {
     if (!current_track_frame_.is_null()) {
       pp::VideoFrame frame = current_track_frame_;
       current_track_frame_.detach();
       GetEncoderFrame(frame);
     }
     ScheduleNextEncode();
   }
 }
 
@@ skipping 209 matching lines @@
 }
 
 }  // anonymous namespace
 
 namespace pp {
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new VideoEncoderModule();
 }
 }  // namespace pp