dali/internal/system/common/capture-impl.h

   1 #ifndef DALI_INTERNAL_CAPTURE_H
   2 #define DALI_INTERNAL_CAPTURE_H
   3
   4 /*
   5  * Copyright (c) 2022 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/integration-api/processor-interface.h>
  23 #include <dali/public-api/object/base-object.h>
  24 #include <dali/public-api/object/ref-object.h>
  25 #include <dali/public-api/object/weak-handle.h>
  26 #include <dali/public-api/render-tasks/render-task.h>
  27 #include <dali/public-api/rendering/frame-buffer.h>
  28 #include <dali/public-api/rendering/texture.h>
  29 #include <memory>
  30 #include <string>
  31
  32 // INTERNAL INCLUDES
  33 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
  34 #include <dali/integration-api/adaptor-framework/scene-holder-impl.h>
  35 #include <dali/public-api/adaptor-framework/native-image-source.h>
  36 #include <dali/public-api/adaptor-framework/timer.h>
  37 #include <dali/public-api/capture/capture.h>
  38 #include <dali/public-api/dali-adaptor-common.h>
  39
  40 namespace Dali
  41 {
  42 namespace Internal
  43 {
  44 namespace Adaptor
  45 {
  46 class Capture;
  47 typedef IntrusivePtr<Capture> CapturePtr;
  48
  49 class Capture : public BaseObject, public ConnectionTracker, public Integration::Processor
  50 {
  51 public:
  52   static constexpr uint32_t DEFAULT_QUALITY = 100;
  53
  54   /**
  55    * @brief Constructor.
  56    */
  57   Capture();
  58
  59   Capture(Dali::CameraActor cameraActor);
  60
  61   /**
  62    * @copydoc Dali::Capture::New
  63    */
  64   static CapturePtr New();
  65
  66   /**
  67    * @copydoc Dali::Capture::New
  68    */
  69   static CapturePtr New(Dali::CameraActor cameraActor);
  70
  71   /**
  72    * @copydoc Dali::Capture::Start
  73    */
  74   void Start(Dali::Actor source, const Dali::Vector2& position, const Dali::Vector2& size, const std::string& path, const Dali::Vector4& clearColor, const uint32_t quality);
  75
  76   /**
  77    * @copydoc Dali::Capture::Start
  78    */
  79   void Start(Dali::Actor source, const Dali::Vector2& position, const Dali::Vector2& size, const std::string& path, const Dali::Vector4& clearColor);
  80
  81   /**
  82    * @copydoc Dali::Capture::SetImageQuality
  83    */
  84   void SetImageQuality(uint32_t quality);
  85
  86   /**
  87    * @copydoc Dali::Capture::SetExclusive
  88    */
  89   void SetExclusive(bool exclusive);
  90
  91   /**
  92    * @copydoc Dali::Capture::IsExclusive
  93    */
  94   bool IsExclusive() const;
  95
  96   /**
  97    * @copydoc Dali::Capture::GetNativeImageSource
  98    */
  99   Dali::NativeImageSourcePtr GetNativeImageSource() const;
 100
 101   /**
 102    * @copydoc Dali::Capture::GetCapturedBuffer
 103    */
 104   Dali::Devel::PixelBuffer GetCapturedBuffer();
 105
 106   /**
 107    * @copydoc Dali::Capture::GetTexture
 108    */
 109   Dali::Texture GetTexture() const;
 110
 111   /**
 112    * @copydoc Dali::Capture::FinishedSignal
 113    */
 114   Dali::Capture::CaptureFinishedSignalType& FinishedSignal();
 115
 116 protected:
 117   /**
 118    * @brief A reference counted object may only be deleted by calling Unreference()
 119    */
 120   virtual ~Capture();
 121
 122 private:
 123   /**
 124    * @brief Create texture.
 125    */
 126   void CreateTexture(const Dali::Vector2& size);
 127
 128   /**
 129    * @brief Delete native image source.
 130    */
 131   void DeleteNativeImageSource();
 132
 133   /**
 134    * @brief Create frame buffer.
 135    */
 136   void CreateFrameBuffer();
 137
 138   /**
 139    * @brief Delete frame buffer.
 140    */
 141   void DeleteFrameBuffer();
 142
 143   /**
 144    * @brief Query whether frame buffer is created or not.
 145    *
 146    * @return True is frame buffer is created.
 147    */
 148   bool IsFrameBufferCreated();
 149
 150   /**
 151    * @brief Setup render task.
 152    *
 153    * @param[in] position top-left position of area to be captured
 154    *            this position is defined in the window.
 155    * @param[in] size two dimensional size of area to be captured
 156    * @param[in] source sub-scene tree to be captured.
 157    * @param[in] clearColor background color
 158    */
 159   void SetupRenderTask(const Dali::Vector2& position, const Dali::Vector2& size, Dali::Actor source, const Dali::Vector4& clearColor);
 160
 161   /**
 162    * @brief Unset render task.
 163    */
 164   void UnsetRenderTask();
 165
 166   /**
 167    * @brief Query whether render task is setup or not.
 168    *
 169    * @return True is render task is setup.
 170    */
 171   bool IsRenderTaskSetup();
 172
 173   /**
 174    * @brief Setup resources for capture.
 175    *
 176    * @param[in] position top-left position of area to be captured
 177    *            this position is defined in the window.
 178    * @param[in] size two dimensional size of area to be captured
 179    * @param[in] clearColor color to clear background surface.
 180    * @param[in] source sub-scene tree to be captured.
 181    */
 182   void SetupResources(const Dali::Vector2& position, const Dali::Vector2& size, const Dali::Vector4& clearColor, Dali::Actor source);
 183
 184   /**
 185    * @brief Unset resources for capture.
 186    */
 187   void UnsetResources();
 188
 189   /**
 190    * @brief Callback when render is finished.
 191    *
 192    * @param[in] task is used for capture.
 193    */
 194   void OnRenderFinished(Dali::RenderTask& task);
 195
 196   /**
 197    * @brief Callback when timer is finished.
 198    *
 199    * @return True is timer start again.
 200    */
 201   bool OnTimeOut();
 202
 203   /**
 204    * @brief Save framebuffer.
 205    *
 206    * @return True is success to save, false is fail.
 207    */
 208   bool SaveFile();
 209
 210 private:
 211   // Undefined
 212   Capture(const Capture&);
 213
 214   // Undefined
 215   Capture& operator=(const Capture& rhs);
 216
 217 protected: // Implementation of Processor
 218   /**
 219    * @copydoc Dali::Integration::Processor::Process()
 220    */
 221   void Process(bool postProcessor) override;
 222
 223   /**
 224    * @copydoc Dali::Integration::Processor::GetProcessorName()
 225    */
 226   std::string_view GetProcessorName() const override
 227   {
 228     return "Capture";
 229   }
 230
 231 private:
 232   uint32_t                                         mQuality;
 233   Dali::Texture                                    mTexture;
 234   Dali::WeakHandle<Dali::Integration::SceneHolder> mSceneHolderHandle;
 235   Dali::FrameBuffer                                mFrameBuffer;
 236   Dali::RenderTask                                 mRenderTask;
 237   Dali::Actor                                      mSource;
 238   Dali::CameraActor                                mCameraActor;
 239   Dali::Timer                                      mTimer; ///< For timeout.
 240   Dali::Capture::CaptureFinishedSignalType         mFinishedSignal;
 241   std::string                                      mPath;
 242   Dali::NativeImageSourcePtr                       mNativeImageSourcePtr; ///< pointer to surface image
 243   Dali::Devel::PixelBuffer                         mPixelBuffer;
 244   bool                                             mInCapture{false};
 245   bool                                             mIsExclusive{false};
 246   bool                                             mFileSave;
 247   bool                                             mUseDefaultCamera;                   // Whether we use default generated camera, or use inputed camera.
 248   bool                                             mSceneOffCameraAfterCaptureFinished; // Whether we need to scene-off after capture finished.
 249 };
 250
 251 } // End of namespace Adaptor
 252 } // End of namespace Internal
 253
 254 // Helpers for public-api forwarding methods
 255
 256 inline Internal::Adaptor::Capture& GetImpl(Dali::Capture& captureWorker)
 257 {
 258   DALI_ASSERT_ALWAYS(captureWorker && "Capture handle is empty");
 259
 260   BaseObject& handle = captureWorker.GetBaseObject();
 261
 262   return static_cast<Internal::Adaptor::Capture&>(handle);
 263 }
 264
 265 inline const Internal::Adaptor::Capture& GetImpl(const Dali::Capture& captureWorker)
 266 {
 267   DALI_ASSERT_ALWAYS(captureWorker && "Capture handle is empty");
 268
 269   const BaseObject& handle = captureWorker.GetBaseObject();
 270
 271   return static_cast<const Internal::Adaptor::Capture&>(handle);
 272 }
 273
 274 } // End of namespace Dali
 275
 276 #endif // DALI_INTERNAL_CAPTURE_H