citra_qt: camera integration (#3566)

* Implement camera feature

* Make OpenCVCamera optional

* Fix styling problems

* CI configuration

* Fix CI

* Hopefully final fix

* Hopefully final fix

* Fix all the problems

* Oops..

* Add Qt Multimedia Camera

* Another oops

* Try to fix broken linux CI

* Try to fix broken linux CI

* Fix problems

* Improve UI

* Fix problems

* camera: Add support for Qt <5.10 and fix preview error

* CI: try to fix linux-frozen travis build

* camera: fix problems and add multiple handlers support

* fix CI

* remove most ServiceFramework changes

* Fix format

* Remove last ServiceFramework change

* camera: remove unused interfaces; revert submodule change

* camera: fix CI error

* ci: use ccache for opencv build

* citra_qt: fix configuration error; CI: add mediaservice plugin

* citra_qt: fix clang-format

* citra_qt: fix documentation error

* citra_qt: fix configuration page; camera: fix pausing crash

* citra_qt: fix preview not stopping

* camera: extend handlers length

* camera: fix camera resume error

* camera: fix clang-format

* camera: remove all OpenCV; citra_qt: rewrite configuration

* camera: remove all OpenCV; citra_qt: rewrite configuration

* camera: remove all OpenCV; citra_qt: rewrite configuration

* CI: fix linux ci

* camera: check settings update; citra_qt: fix configuration error

* service_cam: use a better way to apply configuration

* Service_CAM: rewrite camera reload

* cam: fix clang format

* citra_qt: fix argument load issue; camera: base of system camera selection

* citra_qt: Add system camera selection

* camera: fix image upside down, Implement SetFrameRate in Qt Multimedia Camera

* camera: Add missing <array> include, update SetFrameRate and add settings in Qt Multimedia Camera header

* camera: move started in Qt Multimedia Camera header

* QtMultimediaCamera: Move frame rates to SetFrameRate; Set minimum and maximum frame rate

* Update appveyor.yml

src/core/frontend/camera/blank_camera.cpp

@@ -23,9 +23,13 @@ void BlankCamera::SetFlip(Service::CAM::Flip) {}
 
 void BlankCamera::SetEffect(Service::CAM::Effect) {}
 
-std::vector<u16> BlankCamera::ReceiveFrame() const {
+std::vector<u16> BlankCamera::ReceiveFrame() {
     // Note: 0x80008000 stands for two black pixels in YUV422
     return std::vector<u16>(width * height, output_rgb ? 0 : 0x8000);
 }
 
+bool BlankCamera::IsPreviewAvailable() {
+    return true;
+}
+
 } // namespace Camera

src/core/frontend/camera/blank_camera.h

@@ -17,7 +17,9 @@ public:
     void SetFlip(Service::CAM::Flip) override;
     void SetEffect(Service::CAM::Effect) override;
     void SetFormat(Service::CAM::OutputFormat) override;
-    std::vector<u16> ReceiveFrame() const override;
+    void SetFrameRate(Service::CAM::FrameRate frame_rate) override {}
+    std::vector<u16> ReceiveFrame() override;
+    bool IsPreviewAvailable() override;
 
 private:
     int width = 0;

src/core/frontend/camera/factory.cpp

@@ -29,4 +29,18 @@ std::unique_ptr<CameraInterface> CreateCamera(const std::string& name, const std
     return std::make_unique<BlankCamera>();
 }
 
+std::unique_ptr<CameraInterface> CreateCameraPreview(const std::string& name,
+                                                     const std::string& config, int width,
+                                                     int height) {
+    auto pair = factories.find(name);
+    if (pair != factories.end()) {
+        return pair->second->CreatePreview(config, width, height);
+    }
+
+    if (name != "blank") {
+        LOG_ERROR(Service_CAM, "Unknown camera \"%s\"", name.c_str());
+    }
+    return std::make_unique<BlankCamera>();
+}
+
 } // namespace Camera

src/core/frontend/camera/factory.h

@@ -21,6 +21,20 @@ public:
      * @returns a unique_ptr to the created camera object.
      */
     virtual std::unique_ptr<CameraInterface> Create(const std::string& config) const = 0;
+
+    /**
+     * Creates a camera object for preview based on the configuration string.
+     * @param config Configuration string to create the camera. The implementation can decide the
+     *               meaning of this string.
+     * @returns a unique_ptr to the created camera object.
+     * Note: The default implementation for this is to call Create(). Derived classes may have other
+     *       Implementations. For example, A dialog may be used instead of LOG_ERROR when error
+     * occurs.
+     */
+    virtual std::unique_ptr<CameraInterface> CreatePreview(const std::string& config, int width,
+                                                           int height) const {
+        return Create(config);
+    }
 };
 
 /**
@@ -38,4 +52,14 @@ void RegisterFactory(const std::string& name, std::unique_ptr<CameraFactory> fac
  */
 std::unique_ptr<CameraInterface> CreateCamera(const std::string& name, const std::string& config);
 
+/**
+ * Creates a camera from the factory for previewing.
+ * @param name Identifier of the camera factory.
+ * @param config Configuration string to create the camera. The meaning of this string is
+ *     defined by the factory.
+ */
+std::unique_ptr<CameraInterface> CreateCameraPreview(const std::string& name,
+                                                     const std::string& config, int width,
+                                                     int height);
+
 } // namespace Camera

src/core/frontend/camera/interface.h

@@ -49,13 +49,27 @@ public:
      */
     virtual void SetFormat(Service::CAM::OutputFormat format) = 0;
 
+    /**
+     * Sets the recommended framerate of the camera.
+     * @param frame_rate Recommended framerate
+     */
+    virtual void SetFrameRate(Service::CAM::FrameRate frame_rate) = 0;
+
     /**
      * Receives a frame from the camera.
      * This function should be only called between a StartCapture call and a StopCapture call.
      * @returns A std::vector<u16> containing pixels. The total size of the vector is width * height
      *     where width and height are set by a call to SetResolution.
      */
-    virtual std::vector<u16> ReceiveFrame() const = 0;
+    virtual std::vector<u16> ReceiveFrame() = 0;
+
+    /**
+     * Test if the camera is opened successfully and can receive a preview frame. Only used for
+     * preview. This function should be only called between a StartCapture call and a StopCapture
+     * call.
+     * @returns true if the camera is opened successfully and false otherwise
+     */
+    virtual bool IsPreviewAvailable() = 0;
 };
 
 } // namespace Camera