ppapi: VideoEncoder: augment precision of the IVF container

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 <deque>
 #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 61 matching lines @@
                                     int32_t height) {
   mem[0] = 'D';
   mem[1] = 'K';
   mem[2] = 'I';
   mem[3] = 'F';
   PutLE16(mem + 4, 0);                               // version
   PutLE16(mem + 6, 32);                              // header size
   PutLE32(mem + 8, fourcc('V', 'P', '8', '0'));      // fourcc
   PutLE16(mem + 12, static_cast<uint16_t>(width));   // width
   PutLE16(mem + 14, static_cast<uint16_t>(height));  // height
-  PutLE32(mem + 16, 30);                             // rate
+  PutLE32(mem + 16, 1000);                           // rate
   PutLE32(mem + 20, 1);                              // scale
   PutLE32(mem + 24, 0xffffffff);                     // length
   PutLE32(mem + 28, 0);                              // unused
 
   return 32;
 }
 
 uint32_t IVFWriter::WriteFrameHeader(uint8_t* mem,
                                      uint64_t pts,
                                      size_t frame_size) {
@@ skipping 71 matching lines @@
   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_;
 
+  std::deque<uint64_t> frames_timestamps_;
+
   pp::VideoFrame current_track_frame_;
 
   IVFWriter ivf_writer_;
 
   PP_Time last_encode_tick_;
 };
 
 VideoEncoderInstance::VideoEncoderInstance(PP_Instance instance,
                                            pp::Module* module)
     : pp::Instance(instance),
@@ skipping 108 matching lines @@
   int32_t idx = 0;
   for (uint32_t i = 0; i < profiles.size(); i++) {
     const PP_VideoProfileDescription& profile = profiles[i];
     js_profiles.Set(idx++, pp::Var(VideoProfileToString(profile.profile)));
   }
   PostMessage(dict);
 }
 
 void VideoEncoderInstance::StartEncoder() {
   video_encoder_ = pp::VideoEncoder(this);
+  frames_timestamps_.clear();
 
   int32_t error = video_encoder_.Initialize(
       frame_format_, frame_size_, video_profile_, 2000000,
       PP_HARDWAREACCELERATION_WITHFALLBACK,
       callback_factory_.NewCallback(
           &VideoEncoderInstance::OnInitializedEncoder));
   if (error != PP_OK_COMPLETIONPENDING) {
     LogError(error, "Cannot initialize encoder");
     return;
   }
@@ skipping 97 matching lines @@
     LogError(PP_ERROR_FAILED, oss.str());
     return PP_ERROR_FAILED;
   }
 
   dest.SetTimestamp(src.GetTimestamp());
   memcpy(dest.GetDataBuffer(), src.GetDataBuffer(), src.GetDataBufferSize());
   return PP_OK;
 }
 
 void VideoEncoderInstance::EncodeFrame(const pp::VideoFrame& frame) {
+  frames_timestamps_.push_back(
+      static_cast<uint64_t>(frame.GetTimestamp() * 1000));
   video_encoder_.Encode(
       frame, PP_FALSE,
       callback_factory_.NewCallback(&VideoEncoderInstance::OnEncodeDone));
 }
 
 void VideoEncoderInstance::OnEncodeDone(int32_t result) {
   if (result == PP_ERROR_ABORTED)
     return;
   if (result != PP_OK)
     LogError(result, "Encode failed");
@@ skipping 107 matching lines @@
           size + ivf_writer_.GetFileHeaderSize() +
           ivf_writer_.GetFrameHeaderSize());
       data_ptr = static_cast<uint8_t*>(array_buffer.Map());
       frame_offset = ivf_writer_.WriteFileHeader(
           data_ptr, frame_size_.width(), frame_size_.height());
     } else {
       array_buffer = pp::VarArrayBuffer(
           size + ivf_writer_.GetFrameHeaderSize());
       data_ptr = static_cast<uint8_t*>(array_buffer.Map());
     }
-    data_offset = frame_offset +
-      ivf_writer_.WriteFrameHeader(data_ptr + frame_offset,
-                                   encoded_frames_,
-                                   size);
+    uint64_t timestamp = frames_timestamps_.front();
+    frames_timestamps_.pop_front();
+    data_offset =
+        frame_offset +
+        ivf_writer_.WriteFrameHeader(data_ptr + frame_offset, timestamp, size);
   } else {
     array_buffer = pp::VarArrayBuffer(size);
     data_ptr = static_cast<uint8_t*>(array_buffer.Map());
   }
 
   memcpy(data_ptr + data_offset, buffer, size);
   array_buffer.Unmap();
   dictionary.Set(pp::Var("data"), array_buffer);
 
   PostMessage(dictionary);
@@ skipping 21 matching lines @@
 }
 
 }  // anonymous namespace
 
 namespace pp {
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new VideoEncoderModule();
 }
 }  // namespace pp