content: pepper: VideoEncoder: add software encoder support

content/renderer/pepper/pepper_video_encoder_host.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 "base/bind.h"
 #include "base/memory/shared_memory.h"
 #include "base/numerics/safe_math.h"
 #include "content/common/gpu/client/command_buffer_proxy_impl.h"
 #include "content/common/gpu/client/gpu_video_encode_accelerator_host.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
 #include "content/renderer/pepper/gfx_conversion.h"
 #include "content/renderer/pepper/host_globals.h"
 #include "content/renderer/pepper/pepper_video_encoder_host.h"
+#include "content/renderer/pepper/video_encoder_shim.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/video_frame.h"
 #include "media/filters/gpu_video_accelerator_factories.h"
 #include "media/video/video_encode_accelerator.h"
 #include "ppapi/c/pp_codecs.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_graphics_3d.h"
 #include "ppapi/host/dispatch_host_message.h"
 #include "ppapi/host/ppapi_host.h"
@@ skipping 134 matching lines @@
   PP_VideoProfileDescription pp_profile;
   pp_profile.profile = PP_FromMediaVideoProfile(profile.profile);
   pp_profile.max_resolution = PP_FromGfxSize(profile.max_resolution);
   pp_profile.max_framerate_numerator = profile.max_framerate_numerator;
   pp_profile.max_framerate_denominator = profile.max_framerate_denominator;
   pp_profile.acceleration = acceleration;
   return pp_profile;
 }
 
 bool PP_HardwareAccelerationCompatible(PP_HardwareAcceleration supply,
                                        PP_HardwareAcceleration demand) {

[bbudge, 2015/03/02 20:01:06]

Now that we know how merging supported profiles will work with software
fallback, we should fix the supported profile struct to use PP_Bool for hardware
/ software rather than the enum. If you prefer to do this in another CL, leave a
TODO here to fix this.

[llandwerlin-old, 2015/03/03 15:23:27]

Leaving this for another CL.

   switch (supply) {
     case PP_HARDWAREACCELERATION_ONLY:
       return (demand == PP_HARDWAREACCELERATION_ONLY ||
               demand == PP_HARDWAREACCELERATION_WITHFALLBACK);
     case PP_HARDWAREACCELERATION_WITHFALLBACK:
       return true;
     case PP_HARDWAREACCELERATION_NONE:
       return (demand == PP_HARDWAREACCELERATION_WITHFALLBACK ||
               demand == PP_HARDWAREACCELERATION_NONE);
     // No default case, to catch unhandled PP_HardwareAcceleration values.
@@ skipping 94 matching lines @@
   gfx::Size input_size(input_visible_size.width, input_visible_size.height);
   if (input_size.IsEmpty())
     return PP_ERROR_BADARGUMENT;
 
   if (!IsInitializationValid(input_visible_size, output_profile, acceleration))
     return PP_ERROR_NOTSUPPORTED;
 
   int32_t error = PP_ERROR_NOTSUPPORTED;
   initialize_reply_context_ = context->MakeReplyMessageContext();
 
-  if (acceleration == PP_HARDWAREACCELERATION_ONLY ||
-      acceleration == PP_HARDWAREACCELERATION_WITHFALLBACK) {
+  if (acceleration != PP_HARDWAREACCELERATION_NONE) {
     if (InitializeHardware(media_input_format_, input_size, media_profile,
                            initial_bitrate))
       return PP_OK_COMPLETIONPENDING;
 
     if (acceleration == PP_HARDWAREACCELERATION_ONLY)
       error = PP_ERROR_FAILED;
   }
 
-  // TODO(llandwerlin): Software encoder.
+  if (acceleration != PP_HARDWAREACCELERATION_ONLY) {
+    encoder_.reset(new VideoEncoderShim(this));
+    if (encoder_->Initialize(media_input_format_, input_size, media_profile,
+                             initial_bitrate, this))
+      return PP_OK_COMPLETIONPENDING;
+    error = PP_ERROR_FAILED;
+  }
+
   initialize_reply_context_ = ppapi::host::ReplyMessageContext();
   Close();
   return error;
 }
 
 int32_t PepperVideoEncoderHost::OnHostMsgGetVideoFrames(
     ppapi::host::HostMessageContext* context) {
   if (encoder_last_error_)
     return encoder_last_error_;
 
@@ skipping 143 matching lines @@
   if (!EnsureGpuChannel())
     return;
 
   std::vector<media::VideoEncodeAccelerator::SupportedProfile> profiles =
       GpuVideoEncodeAcceleratorHost::ConvertGpuToMediaProfiles(
           channel_->gpu_info().video_encode_accelerator_supported_profiles);
   for (media::VideoEncodeAccelerator::SupportedProfile profile : profiles)
     pp_profiles->push_back(PP_FromVideoEncodeAcceleratorSupportedProfile(
         profile, PP_HARDWAREACCELERATION_ONLY));
 
-  // TODO(llandwerlin): add software supported profiles.
+  VideoEncoderShim software_encoder(this);
+  profiles = software_encoder.GetSupportedProfiles();
+  for (media::VideoEncodeAccelerator::SupportedProfile profile : profiles)
+    pp_profiles->push_back(PP_FromVideoEncodeAcceleratorSupportedProfile(
+        profile, PP_HARDWAREACCELERATION_NONE));
 }
 
 bool PepperVideoEncoderHost::IsInitializationValid(
     const PP_Size& input_size,
     PP_VideoProfile output_profile,
     PP_HardwareAcceleration acceleration) {
   DCHECK(RenderThreadImpl::current());
 
   std::vector<PP_VideoProfileDescription> profiles;
   GetSupportedProfiles(&profiles);
@@ skipping 174 matching lines @@
 void PepperVideoEncoderHost::NotifyPepperError(int32_t error) {
   DCHECK(RenderThreadImpl::current());
 
   encoder_last_error_ = error;
   Close();
   host()->SendUnsolicitedReply(
       pp_resource(),
       PpapiPluginMsg_VideoEncoder_NotifyError(encoder_last_error_));
 }
 
+uint8_t* PepperVideoEncoderHost::ShmHandleToAddress(int32 buffer_id) {
+  DCHECK(RenderThreadImpl::current());
+  DCHECK_GE(buffer_id, 0);
+  DCHECK_LT(buffer_id, static_cast<int32>(shm_buffers_.size()));
+  return static_cast<uint8_t*>(shm_buffers_[buffer_id]->shm->memory());
+}
+
 }  // namespace content