media/mojo/services/mojo_video_encode_accelerator_service.h

   1 // Copyright 2017 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef MEDIA_MOJO_SERVICES_MOJO_VIDEO_ENCODE_ACCELERATOR_SERVICE_H_
   6 #define MEDIA_MOJO_SERVICES_MOJO_VIDEO_ENCODE_ACCELERATOR_SERVICE_H_
   7
   8 #include <stddef.h>
   9 #include <stdint.h>
  10
  11 #include <memory>
  12 #include <vector>
  13
  14 #include "base/compiler_specific.h"
  15 #include "base/containers/lru_cache.h"
  16 #include "base/memory/unsafe_shared_memory_region.h"
  17 #include "base/memory/weak_ptr.h"
  18 #include "base/sequence_checker.h"
  19 #include "base/time/time.h"
  20 #include "gpu/config/gpu_driver_bug_workarounds.h"
  21 #include "gpu/config/gpu_info.h"
  22 #include "gpu/config/gpu_preferences.h"
  23 #include "media/mojo/mojom/video_encode_accelerator.mojom.h"
  24 #include "media/mojo/services/media_mojo_export.h"
  25 #include "media/video/video_encode_accelerator.h"
  26 #include "mojo/public/cpp/bindings/associated_remote.h"
  27 #include "mojo/public/cpp/bindings/pending_associated_receiver.h"
  28 #include "mojo/public/cpp/bindings/pending_associated_remote.h"
  29 #include "mojo/public/cpp/bindings/remote.h"
  30
  31 namespace media {
  32
  33 class MojoMediaLog;
  34
  35 // This class implements the interface mojom::VideoEncodeAccelerator.
  36 class MEDIA_MOJO_EXPORT MojoVideoEncodeAcceleratorService
  37     : public mojom::VideoEncodeAccelerator,
  38       public VideoEncodeAccelerator::Client {
  39  public:
  40   // Create and initialize a VEA. Returns nullptr if either part fails.
  41   using CreateAndInitializeVideoEncodeAcceleratorCallback =
  42       base::OnceCallback<std::unique_ptr<::media::VideoEncodeAccelerator>(
  43           const ::media::VideoEncodeAccelerator::Config& config,
  44           Client* client,
  45           const gpu::GpuPreferences& gpu_preferences,
  46           const gpu::GpuDriverBugWorkarounds& gpu_workarounds,
  47           const gpu::GPUInfo::GPUDevice& gpu_device,
  48           std::unique_ptr<MediaLog> media_log)>;
  49
  50   static void Create(
  51       mojo::PendingReceiver<mojom::VideoEncodeAccelerator> receiver,
  52       CreateAndInitializeVideoEncodeAcceleratorCallback create_vea_callback,
  53       const gpu::GpuPreferences& gpu_preferences,
  54       const gpu::GpuDriverBugWorkarounds& gpu_workarounds,
  55       const gpu::GPUInfo::GPUDevice& gpu_device);
  56
  57   MojoVideoEncodeAcceleratorService(
  58       CreateAndInitializeVideoEncodeAcceleratorCallback create_vea_callback,
  59       const gpu::GpuPreferences& gpu_preferences,
  60       const gpu::GpuDriverBugWorkarounds& gpu_workarounds,
  61       const gpu::GPUInfo::GPUDevice& gpu_device);
  62
  63   MojoVideoEncodeAcceleratorService(const MojoVideoEncodeAcceleratorService&) =
  64       delete;
  65   MojoVideoEncodeAcceleratorService& operator=(
  66       const MojoVideoEncodeAcceleratorService&) = delete;
  67
  68   ~MojoVideoEncodeAcceleratorService() override;
  69
  70   // mojom::VideoEncodeAccelerator impl.
  71   void Initialize(
  72       const media::VideoEncodeAccelerator::Config& config,
  73       mojo::PendingAssociatedRemote<mojom::VideoEncodeAcceleratorClient> client,
  74       mojo::PendingRemote<mojom::MediaLog> media_log,
  75       InitializeCallback callback) override;
  76   void Encode(const scoped_refptr<VideoFrame>& frame,
  77               const media::VideoEncoder::EncodeOptions& options,
  78               EncodeCallback callback) override;
  79   void UseOutputBitstreamBuffer(int32_t bitstream_buffer_id,
  80                                 base::UnsafeSharedMemoryRegion region) override;
  81   void RequestEncodingParametersChangeWithBitrate(
  82       const media::Bitrate& bitrate_allocation,
  83       uint32_t framerate) override;
  84   void RequestEncodingParametersChangeWithLayers(
  85       const media::VideoBitrateAllocation& bitrate_allocation,
  86       uint32_t framerate) override;
  87   void IsFlushSupported(IsFlushSupportedCallback callback) override;
  88   void Flush(FlushCallback callback) override;
  89
  90  private:
  91   friend class MojoVideoEncodeAcceleratorIntegrationTest;
  92   friend class MojoVideoEncodeAcceleratorServiceTest;
  93
  94   // VideoEncodeAccelerator::Client implementation.
  95   void RequireBitstreamBuffers(unsigned int input_count,
  96                                const gfx::Size& input_coded_size,
  97                                size_t output_buffer_size) override;
  98   void BitstreamBufferReady(
  99       int32_t bitstream_buffer_id,
 100       const media::BitstreamBufferMetadata& metadata) override;
 101   void NotifyErrorStatus(const EncoderStatus& status) override;
 102   void NotifyEncoderInfoChange(const ::media::VideoEncoderInfo& info) override;
 103
 104   CreateAndInitializeVideoEncodeAcceleratorCallback create_vea_callback_;
 105   const gpu::GpuPreferences gpu_preferences_;
 106   const gpu::GpuDriverBugWorkarounds gpu_workarounds_;
 107   const gpu::GPUInfo::GPUDevice gpu_device_;
 108
 109   // Owned pointer to the underlying VideoEncodeAccelerator.
 110   std::unique_ptr<::media::VideoEncodeAccelerator> encoder_;
 111   mojo::AssociatedRemote<mojom::VideoEncodeAcceleratorClient> vea_client_;
 112
 113   // Proxy object for providing media log services.
 114   std::unique_ptr<MojoMediaLog> media_log_;
 115
 116   // Cache of parameters for sanity verification.
 117   size_t output_buffer_size_;
 118   gfx::Size input_coded_size_;
 119
 120   base::LRUCache<int64_t, base::TimeTicks> timestamps_;
 121
 122   // Note that this class is already thread hostile when bound.
 123   SEQUENCE_CHECKER(sequence_checker_);
 124
 125   base::WeakPtrFactory<MojoVideoEncodeAcceleratorService> weak_factory_{this};
 126 };
 127
 128 }  // namespace media
 129
 130 #endif  // MEDIA_MOJO_SERVICES_MOJO_VIDEO_ENCODE_ACCELERATOR_SERVICE_H_