pepper: add software vp9 encoder support to PPB_VideoEncoder

ppapi/examples/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>
@@ skipping 31 matching lines @@
 #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);
 }
 
+std::string ToUpperString(const std::string& str) {
+  std::string ret;
+  for (uint32_t i = 0; i < str.size(); i++)
+    ret.push_back(static_cast<char>(toupper(str[i])));
+  return ret;
+}
+
 // 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; }
-  uint32_t WriteFileHeader(uint8_t* mem, int32_t width, int32_t height);
+  uint32_t WriteFileHeader(uint8_t* mem,
+                           const std::string& codec,
+                           int32_t width,
+                           int32_t height);
   uint32_t WriteFrameHeader(uint8_t* mem, uint64_t pts, size_t frame_size);
 
  private:
   void PutLE16(uint8_t* mem, int val) const {
     mem[0] = (val >> 0) & 0xff;
     mem[1] = (val >> 8) & 0xff;
   }
   void PutLE32(uint8_t* mem, int val) const {
     mem[0] = (val >> 0) & 0xff;
     mem[1] = (val >> 8) & 0xff;
     mem[2] = (val >> 16) & 0xff;
     mem[3] = (val >> 24) & 0xff;
   }
 };
 
 uint32_t IVFWriter::WriteFileHeader(uint8_t* mem,
+                                    const std::string& codec,
                                     int32_t width,
                                     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
+  PutLE32(mem + 8, fourcc(codec[0], codec[1], codec[2], '0'));  // fourcc
   PutLE16(mem + 12, static_cast<uint16_t>(width));   // width
   PutLE16(mem + 14, static_cast<uint16_t>(height));  // height
   PutLE32(mem + 16, 1000);                           // rate
   PutLE32(mem + 20, 1);                              // scale
   PutLE32(mem + 24, 0xffffffff);                     // length
   PutLE32(mem + 28, 0);                              // unused
 
   return 32;
 }
 
@@ skipping 51 matching lines @@
   void StartTrackFrames();
   void StopTrackFrames();
   void OnTrackFrame(int32_t result, pp::VideoFrame frame);
 
   void StopEncode();
 
   void LogError(int32_t error, const std::string& message);
   void Log(const std::string& message);
 
   void PostDataMessage(const void* buffer, uint32_t size);
-  void PostSignalMessage(const char* name);
 
   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_;
@@ skipping 86 matching lines @@
     frame_size_ = encoder_size_;
 
   int32_t attrib_list[] = {PP_MEDIASTREAMVIDEOTRACK_ATTRIB_FORMAT,
                            frame_format_,
                            PP_MEDIASTREAMVIDEOTRACK_ATTRIB_WIDTH,
                            frame_size_.width(),
                            PP_MEDIASTREAMVIDEOTRACK_ATTRIB_HEIGHT,
                            frame_size_.height(),
                            PP_MEDIASTREAMVIDEOTRACK_ATTRIB_NONE};
 
-  pp::VarDictionary dict;
-  dict.Set(pp::Var("status"), pp::Var("configuring video track"));
-  dict.Set(pp::Var("width"), pp::Var(frame_size_.width()));
-  dict.Set(pp::Var("height"), pp::Var(frame_size_.height()));
-  PostMessage(dict);
-
   video_track_.Configure(
       attrib_list,
       callback_factory_.NewCallback(&VideoEncoderInstance::OnConfiguredTrack));
 }
 
 void VideoEncoderInstance::OnConfiguredTrack(int32_t result) {
   if (result != PP_OK) {
     LogError(result, "Cannot configure track");
     return;
   }
@@ skipping 18 matching lines @@
   dict.Set(pp::Var("name"), pp::Var("supportedProfiles"));
   pp::VarArray js_profiles;
   dict.Set(pp::Var("profiles"), js_profiles);
 
   if (result < 0) {
     LogError(result, "Cannot get supported profiles");
     PostMessage(dict);
   }
 
   int32_t idx = 0;
-  for (const PP_VideoProfileDescription& profile : profiles)
+  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;
   }
 }
 
 void VideoEncoderInstance::OnInitializedEncoder(int32_t result) {
   if (result != PP_OK) {
     LogError(result, "Encoder initialization failed");
     return;
   }
 
   is_encoding_ = true;
-  PostSignalMessage("started");
+  Log("started");
 
   if (video_encoder_.GetFrameCodedSize(&encoder_size_) != PP_OK) {
     LogError(result, "Cannot get encoder coded frame size");
     return;
   }
 
   video_encoder_.GetBitstreamBuffer(callback_factory_.NewCallbackWithOutput(
       &VideoEncoderInstance::OnGetBitstreamBuffer));
 
   if (encoder_size_ != frame_size_)
@@ skipping 177 matching lines @@
       return;
     }
     pp::Resource resource_track = var_track.AsResource();
     video_track_ = pp::MediaStreamVideoTrack(resource_track);
     video_encoder_ = pp::VideoEncoder();
     video_profile_ = VideoProfileFromString(
         dict_message.Get("profile").AsString());
     ConfigureTrack();
   } else if (command == "stop") {
     StopEncode();
-    PostSignalMessage("stopped");
+    Log("stopped");
   } else {
     LogToConsole(PP_LOGLEVEL_ERROR, pp::Var("Invalid command!"));
   }
 }
 
 void VideoEncoderInstance::PostDataMessage(const void* buffer, uint32_t size) {
   pp::VarDictionary dictionary;
 
   dictionary.Set(pp::Var("name"), pp::Var("data"));
 
   pp::VarArrayBuffer array_buffer;
   uint8_t* data_ptr;
   uint32_t data_offset = 0;
   if (video_profile_ == PP_VIDEOPROFILE_VP8_ANY ||
       video_profile_ == PP_VIDEOPROFILE_VP9_ANY) {
     uint32_t frame_offset = 0;
     if (encoded_frames_ == 1) {
       array_buffer = pp::VarArrayBuffer(
           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());
+          data_ptr, ToUpperString(VideoProfileToString(video_profile_)),
+          frame_size_.width(), frame_size_.height());
     } else {
       array_buffer = pp::VarArrayBuffer(
           size + ivf_writer_.GetFrameHeaderSize());
       data_ptr = static_cast<uint8_t*>(array_buffer.Map());
     }
     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);
 }
 
-void VideoEncoderInstance::PostSignalMessage(const char* name) {
-  pp::VarDictionary dictionary;
-  dictionary.Set(pp::Var("name"), pp::Var(name));
-
-  PostMessage(dictionary);
-}
-
 void VideoEncoderInstance::LogError(int32_t error, const std::string& message) {
   std::string msg("Error: ");
   msg.append(pp::Var(error).DebugString());
   msg.append(" : ");
   msg.append(message);
-  LogToConsole(PP_LOGLEVEL_ERROR, pp::Var(msg));
+
+  Log(msg);
 }
 
 void VideoEncoderInstance::Log(const std::string& message) {
-  LogToConsole(PP_LOGLEVEL_LOG, pp::Var(message));
+  pp::VarDictionary dictionary;
+  dictionary.Set(pp::Var("name"), pp::Var("log"));
+  dictionary.Set(pp::Var("message"), pp::Var(message));
+
+  PostMessage(dictionary);
 }
 
 pp::Instance* VideoEncoderModule::CreateInstance(PP_Instance instance) {
   return new VideoEncoderInstance(instance, this);
 }
 
 }  // anonymous namespace
 
 namespace pp {
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new VideoEncoderModule();
 }
 }  // namespace pp