/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * 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 HW_EMULATOR_CAMERA_EMULATED_CAMERA2_H
#define HW_EMULATOR_CAMERA_EMULATED_CAMERA2_H

/*
 * Contains declaration of a class EmulatedCamera that encapsulates
 * functionality common to all version 2.0 emulated camera devices.  Instances
 * of this class (for each emulated camera) are created during the construction
 * of the EmulatedCameraFactory instance.  This class serves as an entry point
 * for all camera API calls that defined by camera2_device_ops_t API.
 */

#include "hardware/camera2.h"
#include "system/camera_metadata.h"
#include "EmulatedBaseCamera.h"

namespace android {

/* Encapsulates functionality common to all version 2.0 emulated camera devices
 *
 * Note that EmulatedCameraFactory instantiates object of this class just once,
 * when EmulatedCameraFactory instance gets constructed. Connection to /
 * disconnection from the actual camera device is handled by calls to
 * connectDevice(), and closeCamera() methods of this class that are invoked in
 * response to hw_module_methods_t::open, and camera_device::close callbacks.
 */
class EmulatedCamera2 : public camera2_device, public EmulatedBaseCamera {
public:
    /* Constructs EmulatedCamera2 instance.
     * Param:
     *  cameraId - Zero based camera identifier, which is an index of the camera
     *      instance in camera factory's array.
     *  module - Emulated camera HAL module descriptor.
     */
    EmulatedCamera2(int cameraId,
            struct hw_module_t* module);

    /* Destructs EmulatedCamera2 instance. */
    virtual ~EmulatedCamera2();

    /****************************************************************************
     * Abstract API
     ***************************************************************************/

public:

    /****************************************************************************
     * Public API
     ***************************************************************************/

public:
    virtual status_t Initialize();

    /****************************************************************************
     * Camera API implementation
     ***************************************************************************/

public:
    virtual status_t connectCamera(hw_device_t** device);

    virtual status_t closeCamera();

    virtual status_t getCameraInfo(struct camera_info* info);

    /****************************************************************************
     * Camera API implementation.
     * These methods are called from the camera API callback routines.
     ***************************************************************************/

protected:
    /** Request input queue */

    int setRequestQueueSrcOps(
        camera2_metadata_queue_src_ops *request_queue_src_ops);

    int requestQueueNotifyNotEmpty();

    /** Reprocessing input queue */

    int setReprocessQueueSrcOps(
        camera2_metadata_queue_src_ops *reprocess_queue_src_ops);

    int reprocessQueueNotifyNotEmpty();

    /** Frame output queue */

    int setFrameQueueDstOps(camera2_metadata_queue_dst_ops *frame_queue_dst_ops);

    int frameQueueBufferCount();
    int frameQueueDequeue(camera_metadata_t **buffer);
    int frameQueueFree(camera_metadata_t *old_buffer);

    /** Notifications to application */
    int setNotifyCallback(camera2_notify_callback notify_cb);

    /** Count of requests in flight */
    int getInProgressCount();

    /** Cancel all captures in flight */
    int flushCapturesInProgress();

    /** Reprocessing input stream management */
    int reprocessStreamDequeueBuffer(buffer_handle_t** buffer,
            int *stride);

    int reprocessStreamEnqueueBuffer(buffer_handle_t* buffer);

    int reprocessStreamCancelBuffer(buffer_handle_t* buffer);

    int reprocessStreamSetBufferCount(int count);

    int reprocessStreamSetCrop(int left, int top, int right, int bottom);

    int reprocessStreamSetTimestamp(int64_t timestamp);

    int reprocessStreamSetUsage(int usage);

    int reprocessStreamSetSwapInterval(int interval);

    int reprocessStreamGetMinUndequeuedBufferCount(int *count);

    int reprocessStreamLockBuffer(buffer_handle_t *buffer);

    /** Output stream creation and management */

    int getStreamSlotCount();

    int allocateStream(uint32_t stream_slot,
            uint32_t width,
            uint32_t height,
            int format,
            camera2_stream_ops_t *stream_ops);

    int releaseStream(uint32_t stream_slot);

    /** Custom tag definitions */
    const char* getVendorSectionName(uint32_t tag);
    const char* getVendorTagName(uint32_t tag);
    int         getVendorTagType(uint32_t tag);

    /** Shutdown and debug methods */

    int release();

    int dump(int fd);

    int close();

    /****************************************************************************
     * Camera API callbacks as defined by camera2_device_ops structure.  See
     * hardware/libhardware/include/hardware/camera2.h for information on each
     * of these callbacks. Implemented in this class, these callbacks simply
     * dispatch the call into an instance of EmulatedCamera2 class defined in the
     * 'camera_device2' parameter.
     ***************************************************************************/

private:
    /** Input request queue */
    static int set_request_queue_src_ops(camera2_device_t *,
            camera2_metadata_queue_src_ops *queue_src_ops);
    static int get_request_queue_dst_ops(camera2_device_t *,
            camera2_metadata_queue_dst_ops **queue_dst_ops);
    // for get_request_queue_dst_ops
    static int request_queue_notify_queue_not_empty(
        camera2_metadata_queue_dst_ops *);

    /** Input reprocess queue */
    static int set_reprocess_queue_src_ops(camera2_device_t *,
            camera2_metadata_queue_src_ops *reprocess_queue_src_ops);
    static int get_reprocess_queue_dst_ops(camera2_device_t *,
            camera2_metadata_queue_dst_ops **queue_dst_ops);
    // for reprocess_queue_dst_ops
    static int reprocess_queue_notify_queue_not_empty(
            camera2_metadata_queue_dst_ops *);

    /** Output frame queue */
    static int set_frame_queue_dst_ops(camera2_device_t *,
            camera2_metadata_queue_dst_ops *queue_dst_ops);
    static int get_frame_queue_src_ops(camera2_device_t *,
            camera2_metadata_queue_src_ops **queue_src_ops);
    // for get_frame_queue_src_ops
    static int frame_queue_buffer_count(camera2_metadata_queue_src_ops *);
    static int frame_queue_dequeue(camera2_metadata_queue_src_ops *,
            camera_metadata_t **buffer);
    static int frame_queue_free(camera2_metadata_queue_src_ops *,
            camera_metadata_t *old_buffer);

    /** Notifications to application */
    static int set_notify_callback(camera2_device_t *,
            camera2_notify_callback notify_cb);

    /** In-progress request management */
    static int get_in_progress_count(camera2_device_t *);

    static int flush_captures_in_progress(camera2_device_t *);

    /** Input reprocessing stream */
    static int get_reprocess_stream_ops(camera2_device_t *,
            camera2_stream_ops_t **stream);
    // for get_reprocess_stream_ops
    static int reprocess_stream_dequeue_buffer(camera2_stream_ops *,
            buffer_handle_t** buffer, int *stride);
    static int reprocess_stream_enqueue_buffer(camera2_stream_ops *,
            buffer_handle_t* buffer);
    static int reprocess_stream_cancel_buffer(camera2_stream_ops *,
            buffer_handle_t* buffer);
    static int reprocess_stream_set_buffer_count(camera2_stream_ops *,
            int count);
    static int reprocess_stream_set_crop(camera2_stream_ops *,
            int left, int top, int right, int bottom);
    static int reprocess_stream_set_timestamp(camera2_stream_ops *,
            int64_t timestamp);
    static int reprocess_stream_set_usage(camera2_stream_ops *,
            int usage);
    static int reprocess_stream_set_swap_interval(camera2_stream_ops *,
            int interval);
    static int reprocess_stream_get_min_undequeued_buffer_count(
            const camera2_stream_ops *,
            int *count);
    static int reprocess_stream_lock_buffer(camera2_stream_ops *,
            buffer_handle_t* buffer);

    /** Output stream allocation and management */

    static int get_stream_slot_count(camera2_device_t *);

    static int allocate_stream(camera2_device_t *,
            uint32_t stream_slot,
            uint32_t width,
            uint32_t height,
            uint32_t format,
            camera2_stream_ops_t *stream_ops);

    static int release_stream(camera2_device_t *,
            uint32_t stream_slot);

    static void release(camera2_device_t *);

    /** Vendor metadata registration */

    static int get_metadata_vendor_tag_ops(camera2_device_t *,
            vendor_tag_query_ops_t **ops);
    // for get_metadata_vendor_tag_ops
    static const char* get_camera_vendor_section_name(
            const vendor_tag_query_ops_t *,
            uint32_t tag);
    static const char* get_camera_vendor_tag_name(
            const vendor_tag_query_ops_t *,
            uint32_t tag);
    static int get_camera_vendor_tag_type(
            const vendor_tag_query_ops_t *,
            uint32_t tag);

    static int dump(camera2_device_t *, int fd);

    static int close(struct hw_device_t* device);

    /****************************************************************************
     * Data members
     ***************************************************************************/

  private:
    static camera2_device_ops_t sDeviceOps;

    struct QueueDstOps : public camera2_metadata_queue_dst_ops {
        EmulatedCamera2 *parent;
    };

    struct QueueSrcOps : public camera2_metadata_queue_src_ops {
        EmulatedCamera2 *parent;
    };

    struct StreamOps : public camera2_stream_ops {
        EmulatedCamera2 *parent;
    };

    struct TagOps : public vendor_tag_query_ops {
        EmulatedCamera2 *parent;
    };

    QueueDstOps mRequestQueueDstOps;
    QueueDstOps mReprocessQueueDstOps;
    QueueSrcOps mFrameQueueSrcOps;
    StreamOps   mReprocessStreamOps;
    TagOps      mVendorTagOps;
};

}; /* namespace android */

#endif  /* HW_EMULATOR_CAMERA_EMULATED_CAMERA2_H */