/*
Copyright (c) 2019 Ferhat Kurtulmuş
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/

module opencvd.videoio;

import std.string;

import opencvd.cvcore;

struct _VideoCapture{
    void* p;
    
    // Close VideoCapture object.
    void close(){
        VideoCapture_Close(&this);
    }
    
    // fromFile opens a VideoCapture from a file and prepares
    // to start capturing.
    bool fromFile(string uri){
        return VideoCapture_Open(&this, toStringz(uri));
    }
    
    // fromDevice opens a VideoCapture from a device and prepares
    // to start capturing.
    bool fromDevice(int device){
        return VideoCapture_OpenDevice(&this, device);
    }
    
    // Set parameter with property 
    void setProperty(int prop, double param){
        VideoCapture_Set(&this, prop, param);
    }
    alias set = setProperty;
    
    // Get parameter with property 
    double getProperty(int prop){
        return VideoCapture_Get(&this, prop);
    }
    alias get = getProperty;
    
    // a file or capture device.
    bool isOpened(){
        return VideoCapture_IsOpened(&this) == 0 ? false: true;
    }
    
    // Read reads the next frame from the VideoCapture to the Mat passed in
    // as the param. It returns false if the VideoCapture cannot read frame.
    bool read(Mat buf){
        return VideoCapture_Read(&this, buf) == 0 ? false: true;
    }
    
    // Grab skips a specific number of frames.
    void grab(int skip){
        VideoCapture_Grab(&this, skip);
    }
}

alias VideoCapture  = _VideoCapture*;

VideoCapture newVideoCapture(){
    return VideoCapture_New();
}
/* An example usage

void main()
{
    
    auto cap = newVideoCapture();
    cap.fromDevice(0);

    namedWindow("mywin", 0);
    setWindowTitle("mywin", "süper pencere / 超级窗口");

    for(;;)
    {
        Mat frame = newMat();

        cap.read(frame);

        imshow("mywin", frame);
        
        if (waitKey(10) == 27) break;
    }
    
    cap.close();
}
*/

struct _VideoWriter{
    void* p;
    
    void close(){
        VideoWriter_Close(&this);
    }
    
    void toFile(string name, string codec, double fps, int width,
            int height, bool isColor){
        VideoWriter_Open(&this, toStringz(name), toStringz(codec), fps, width, height, isColor);
    }
    
    bool isOpened(){
        return VideoWriter_IsOpened(&this) == 0 ? false: true;
    }
    
    void write(Mat img){
        VideoWriter_Write(&this, img);
    }
}

alias VideoWriter  = _VideoWriter*;

VideoWriter newVideoWriter(){
    return VideoWriter_New();
}


//private {
    extern (C){
        // VideoCapture
        VideoCapture VideoCapture_New();
        void VideoCapture_Close(VideoCapture v);
        bool VideoCapture_Open(VideoCapture v, const char* uri);
        bool VideoCapture_OpenDevice(VideoCapture v, int device);
        void VideoCapture_Set(VideoCapture v, int prop, double param);
        double VideoCapture_Get(VideoCapture v, int prop);
        int VideoCapture_IsOpened(VideoCapture v);
        int VideoCapture_Read(VideoCapture v, Mat buf);
        void VideoCapture_Grab(VideoCapture v, int skip);

        // VideoWriter
        VideoWriter VideoWriter_New();
        void VideoWriter_Close(VideoWriter vw);
        void VideoWriter_Open(VideoWriter vw, const char* name, const char* codec, double fps, int width,
            int height, bool isColor);
        int VideoWriter_IsOpened(VideoWriter vw);
        void VideoWriter_Write(VideoWriter vw, Mat img);
    }
//}

enum: int { 
    CAP_PROP_POS_MSEC =0, 
    CAP_PROP_POS_FRAMES =1, 
    CAP_PROP_POS_AVI_RATIO =2, 
    CAP_PROP_FRAME_WIDTH =3, 
    CAP_PROP_FRAME_HEIGHT =4, 
    CAP_PROP_FPS =5, 
    CAP_PROP_FOURCC =6, 
    CAP_PROP_FRAME_COUNT =7, 
    CAP_PROP_FORMAT =8, 
    CAP_PROP_MODE =9, 
    CAP_PROP_BRIGHTNESS =10, 
    CAP_PROP_CONTRAST =11, 
    CAP_PROP_SATURATION =12, 
    CAP_PROP_HUE =13, 
    CAP_PROP_GAIN =14, 
    CAP_PROP_EXPOSURE =15, 
    CAP_PROP_CONVERT_RGB =16, 
    CAP_PROP_WHITE_BALANCE_BLUE_U =17, 
    CAP_PROP_RECTIFICATION =18, 
    CAP_PROP_MONOCHROME =19, 
    CAP_PROP_SHARPNESS =20, 
    CAP_PROP_AUTO_EXPOSURE =21, 
    CAP_PROP_GAMMA =22, 
    CAP_PROP_TEMPERATURE =23, 
    CAP_PROP_TRIGGER =24, 
    CAP_PROP_TRIGGER_DELAY =25, 
    CAP_PROP_WHITE_BALANCE_RED_V =26, 
    CAP_PROP_ZOOM =27, 
    CAP_PROP_FOCUS =28, 
    CAP_PROP_GUID =29, 
    CAP_PROP_ISO_SPEED =30, 
    CAP_PROP_BACKLIGHT =32, 
    CAP_PROP_PAN =33, 
    CAP_PROP_TILT =34, 
    CAP_PROP_ROLL =35, 
    CAP_PROP_IRIS =36, 
    CAP_PROP_SETTINGS =37, 
    CAP_PROP_BUFFERSIZE =38, 
    CAP_PROP_AUTOFOCUS =39, 
    CAP_PROP_SAR_NUM =40, 
    CAP_PROP_SAR_DEN =41, 
    CAP_PROP_BACKEND =42, 
    CAP_PROP_CHANNEL =43, 
    CAP_PROP_AUTO_WB =44, 
    CAP_PROP_WB_TEMPERATURE =45 
}