xref: /foundation/graphic/surface_lite/interfaces/innerkits/surface_impl.h

/*
 * Copyright (c) 2020-2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef GRAPHIC_LITE_SURFACE_IMPL_H
#define GRAPHIC_LITE_SURFACE_IMPL_H

#include "buffer_producer.h"
#include "buffer_queue_consumer.h"
#include "ibuffer_consumer_listener.h"
#include "surface.h"
#include "surface_buffer.h"
#include "surface_type.h"

namespace OHOS {
/**
 * @brief SurfaceImpl Object. Provide the shared memory ability.
 *        Supported allocate physical and virtual memory.
 *        Using in multi media and graphic for multi process.
 */
class SurfaceImpl : public Surface {
public:
    /**
     * @brief Generic Surface from ipc io, used for producer on multi process.
     * @param [in] IpcIo io. Consumer surface sid, ipc sending request param.
     * @returns Surface pointer.
     */
    static Surface* GenericSurfaceByIpcIo(IpcIo& io);

    /**
     * @brief Surface Constructor, used for consumer.
     * @returns Surface pointer.
     */
    SurfaceImpl();

    /**
     * @brief Lite Surface Destructor. Free all buffers.
     */
    ~SurfaceImpl();

    /**
     * @brief Set queue size, the surface could alloc max buffer count.
     *        Default is 1. Max count is 10.
     * @param [in] queueSize. Could alloc buffer count.
     */
    void SetQueueSize(uint8_t queueSize) override;

    /**
     * @brief Get queue size, the surface could alloc max buffer count.
     * @returns queue size.
     */
    uint8_t GetQueueSize() override;

    /**
     * @brief Set width and height to calculate the buffer size.
     * @param [in] width, Buffer width.
     * @param [in] height, Buffer height.
     */
    void SetWidthAndHeight(uint32_t width, uint32_t height) override;

    /**
     * @brief Get width, buffer width to calculate the buffer size..
     * @returns width, Buffer width.
     */
    uint32_t GetWidth() override;

    /**
     * @brief Get height, buffer height to calculate the buffer size..
     * @returns height, Buffer height.
     */
    uint32_t GetHeight() override;

    /**
     * @brief Set format, to calculate the buffer size.
     *        Default is IMAGE_PIXEL_FORMAT_RGB565. See all formats in OHOS::ImageFormat
     * @param [in] format, Buffer format.
     */
    void SetFormat(uint32_t format) override;

    /**
     * @brief Get format, buffer format to calculate the buffer size..
     * @returns format, Buffer format.
     */
    uint32_t GetFormat() override;

    /**
     * @brief Set stride alignment bytes. Default alignment is 4 bytes.
     * @param [in] strideAlignment, Buffer stride alignment
     */
    void SetStrideAlignment(uint32_t strideAlignment) override;

    /**
     * @brief Get stride alignment bytes. Default alignment is 4 bytes.
     * @returns strideAlignment, Buffer stride alignment.
     */
    uint32_t GetStrideAlignment() override;

    /**
     * @brief Get bytes of one stride which calculate by width, format and stride alignment.
     * @returns The stride
     */
    uint32_t GetStride() override;

    /**
     * @brief Set buffer size. Surface alloc buffer size, no need to calculate by width, height, format...
     * @param [in] The buffer size
     */
    void SetSize(uint32_t size) override;

    /**
     * @brief Get buffer size. Surface alloc buffer size.
     *        The size is setted by SetSize() or calculated by width, height, format...
     * @returns The buffer size.
     */
    uint32_t GetSize() override;

    /**
     * @brief Set buffer usage. Surface alloc physical or virtual memory buffer.
     *        Support usage see detail in OHOS::BUFFER_CONSUMER_USAGE.
     *        Default is BUFFER_CONSUMER_USAGE_SORTWARE, which will alloc virtual memory buffer.
     * @param [in] The buffer usage.
     */
    void SetUsage(uint32_t usage) override;

    /**
     * @brief Get buffer usage. Surface alloc physical or virtual memory buffer.
     *        All usage sees detail in OHOS::BUFFER_CONSUMER_USAGE.
     * @returns The buffer usage.
     */
    uint32_t GetUsage() override;

    /**
     * @brief Set user data. Surface would construct a local map to store all the user-data.
     * @param [in] key.
     * @param [in] value.
     */
    void SetUserData(const std::string& key, const std::string& value) override;

    /**
     * @brief Get user data. Surface get the value from local map.
     * @returns value refers to the key.
     */
    std::string GetUserData(const std::string& key) override;

    /**
     * @brief Request buffer. Surface producer requests buffer.
     *        Waiting until some buffer could used. Default wait = 0;
     * @param [in] whether waiting or not.
     *        wait = 1. waiting util get surface buffer.
     *        wait = 0. No wait to get surface buffer.
     * @returns buffer pointer.
     */
    SurfaceBuffer* RequestBuffer(uint8_t wait = 0) override;

    /**
     * @brief Flush buffer for consumer acquire. When producer flush buffer, buffer
     *        whill push to dirty list, and call back to consumer that buffer is available to acquire.
     * @param [in] SurfaceBuffer pointer, Which buffer could acquire for consumer.
     * @returns Flush buffer succeed or not.
     *        0 is succeed; other is failed.
     */
    int32_t FlushBuffer(SurfaceBuffer* buffer) override;

    /**
     * @brief Acquire buffer. Consumer acquire buffer, which producer has flush and push to free list.
     * @returns buffer pointer.
     */
    SurfaceBuffer* AcquireBuffer() override;

    /**
     * @brief Release buffer. Consumer release buffer, which will push to free list for producer request it.
     * @param [in] SurfaceBuffer, Which buffer need to release.
     * @returns Whether Release buffer succeed or not.
     */
    bool ReleaseBuffer(SurfaceBuffer* buffer) override;

    /**
     * @brief Cancel buffer. Producer cancel this buffer, buffer will push to free list for request it.
     * @param [in] SurfaceBuffer pointer, Which buffer will push back to free list for request it.
     */
    void CancelBuffer(SurfaceBuffer* buffer) override;

    /**
     * @brief Register consumer listener, when some buffer is available for acquired.
     *        One surface only has one consumer listener.
     * @param [in], IBufferConsumerListener listener.
     */
    void RegisterConsumerListener(IBufferConsumerListener& listener) override;

    /**
     * @brief Unregister consumer listener, remove the consumer listener.
     *        One surface only has one consumer listener, So when invoking this method,
     *        there will have no listener.
     */
    void UnregisterConsumerListener() override;
    /**
     * @brief Serialize Surface attr to IpcIo.
     * @param [out], IpcIo.
     */
    void WriteIoIpcIo(IpcIo& io);

    /**
     * @brief Deal with the ipc msg. When multi process, producer will send request. This is to deal with the request.
     * @param [in] ipcMsg, ipc msg, constains request code...
     * @param [in] IpcIo pointer, ipc msg object, constains request attr...
     * @returns 0 is succeed; other is failed.
     */
    int32_t DoIpcMsg(uint32_t code, IpcIo* data, IpcIo* reply, MessageOption option);

    /**
     * @brief Surface init succeed or not
     * @returns Init succeed return true, else return false.
     */
    bool Init();

private:
    /**
     * @brief SurfaceImpl Constructor, used for producer on multi process.
     * @param [in] SvcIdentity. Consumer sid, ipc sending request param.
     * @returns Surface pointer.
     */
    SurfaceImpl(const SvcIdentity& sid);
    static int32_t IpcRequestHandler(uint32_t code, IpcIo* data, IpcIo* reply, MessageOption option);
    SvcIdentity sid_;
    IpcObjectStub objectStub_;
    BufferQueueConsumer* consumer_;
    BufferProducer* producer_;
    bool IsConsumer_;
};
} // end namespace
#endif