/*
 * The following example is to demostrate how to set CSC controls to perform
 * standard color space conversion. Video input in CCIR 10-bit YUV 422 packing
 * is converted to full-range 10-bit ABGR packing which will be saved in
 * memory. Controls for constant hue and alpha correction are enabled.
 *
 * Video input is source, memory (VGI1) is drain, and CSC is a internal node
 * in a video to memory path. Because this is a CSC example, codes other
 * than CSC are replaced by comments in this examples. 
 */

#include <errno.h>
#include <stdio.h>
#include <dmedia/vl.h>
#include <dmedia/vl_mgv.h>

void main(void)
{
        VLTransferDescriptor xferDesc;
        VLControlValue val;
        VLServer svr;
        VLPath path;
        VLNode src, drn;
        VLNode csc_node;

        /* We connect to daemon and set up nodes for source and drain */

        /* Create CSC internal node */ 
        csc_node = vlGetNode(svr, VL_INTERNAL, VL_CSC, VL_MGV_NODE_NUMBER_CSC);
        /* 
         * We create a video to memory path with the source and drain
         * created above.
         */

        /* Add the CSC internal node to the path */
        if (vlAddNode(svr, path, csc_node)) {
            vlPerror(“Add CSC Device Node”);
            vlDestroyPath(svr, path);
        }

        /* Set CSC input range to CCIR */
        val.intVal = VL_FORMAT_DIGITAL_COMPONENT_SERIAL;
        if (vlSetControl(svr, path, csc_node, VL_MGV_CSC_IN_RANGE, &val) < 0)
            vlPerror(“SetControl of CSC input range failed”);

        /* Set CSC input packing to 10-bit YUV 422 */
        val.intVal = VL_PACKING_YVYU_422_10;
        if (vlSetControl(svr, path, csc_node, VL_MGV_CSC_IN_PACKING, &val) < 0)
            vlPerror(“SetControl of CSC input packing failed”);

        /* Set CSC output range to full range */
        val.intVal = VL_FORMAT_RGB;
        if (vlSetControl(svr, path, csc_node, VL_MGV_CSC_OUT_RANGE, &val) < 0)
            vlPerror(“SetControl of CSC output range failed”);

        /* Set CSC output packing to 10-bit ABGR */
        val.intVal = VL_PACKING_ABGR_10; 
        if (vlSetControl(svr, path, csc_node, VL_MGV_CSC_OUT_PACKING, &val) < 0)
            vlPerror(“SetControl of CSC output packing failed”);

        /* Enable CSC constant hue algorithm, default is TRUE */
        val.boolVal = TRUE;
        if (vlSetControl(svr, path, csc_node, VL_MGV_CSC_CONST_HUE, &val) < 0)
            vlPerror(“SetControl of CSC constant hue failed\n”);
        /* Enable alpha correction in the alpha channel, default is FALSE */
        val.boolVal = TRUE;
        if (vlSetControl(svr, path, csc_node, VL_MGV_CSC_ALPHA_CORRECTION, &val)
            < 0)
            vlPerror(“SetControl of CSC alpha correction failed\n”);

        /* We set VGI1's controls below */

        /* VGI1's VL_FORMAT should be same as CSC's output range */
        val.intVal = VL_FORMAT_RGB;
        if (vlSetControl(svr, path, drn, VL_FORMAT, &val) < 0)
            vlPerror(“SetControl of memory format failed”);

        /* VGI1's VL_PACKING should be same as CSC's output packing */
        val.intVal = VL_PACKING_ABGR_10;
        if (vlSetControl(svr, path, drn, VL_PACKING, &val) < 0)
            vlPerror(“SetControl of memory packing failed”);

        /* Begin the data transfer */
        if (vlBeginTransfer(svr, path, 1, &xferDesc)) {
            vlPerror(“vlBeginTransfer failed”);
        }

        /* Loop until all requested frames are grabbed */
        vlMainLoop();
 
}

/*
 * The following example is to demostrate how to load matrix coefficients,
 * input luts, output luts and alpha lut.  Codes other than loading are
 * replaced by comments in this examples.
 */

#include <errno.h>
#include <stdio.h>
#include <dmedia/vl.h>
#include <dmedia/vl_mgv.h>

void main(void)
{
        VLTransferDescriptor xferDesc;
        VLControlValue val;
        VLServer svr;
        VLPath path;
        VLNode src, drn;
        int i;

        int coef_table[9] =
            {0, 10, 20, 30, 40, 50, 60, 70, 80};

        /* We connect to daemon and set up nodes for source and drain */

        /* Create CSC internal node */
        csc_node = vlGetNode(svr, VL_INTERNAL, VL_CSC, VL_MGV_NODE_NUMBER_CSC);

        /*
         * We create a video to memory path with the source and drain
         * created above.
         */

        /* Add the CSC internal node to the path */
        if (vlAddNode(svr, path, csc_node)) {
            vlPerror(“Add CSC Device Node”);
            vlDestroyPath(svr, path);
        }
        /* Load 9 coefficients */
        extVal.dataPointer = coef_table;
        extVal.dataSize = sizeof (coef_table);
        extVal.dataType = MGV_CSC_COEF;

        val.extVal = extVal;

        if (vlSetControl(svr, path, csc_node, VL_MGV_CSC_COEF, &val) < 0) {
            vlPerror(“SetControl of CSC coefficients failed”);
        }

        /* Generate one page of lut */
        for (i = 0; i < 1024; i++)
            inlutVal.lut[i] = 1000;

        /* Assign one page of lut we generated to be in 1st page of
           input luts and alpha lut. */
        inlutVal.pageNumber = 0;

        extVal.dataType = MGV_CSC_LUT_INPUT_AND_ALPHA;
        extVal.dataSize = sizeof(VL_MGVInAlphaLutValue);
        extVal.dataPointer = &inlutVal;

        val.extVal = extVal;

        /* Load the page to input Y/G lut */
        if (vlSetControl(svr, path, csc_node, VL_MGV_CSC_LUT_IN_YG, &val) < 0) {
            vlPerror(“SetControl of CSC YG input lut failed\n”);
        }

        /* Load the page to input U/B lut */
        if (vlSetControl(svr, path, csc_node, VL_MGV_CSC_LUT_IN_UB, &val) < 0) {
            vlPerror(“SetControl of CSC UB input lut failed\n”);
        }

        /* Load the page to input V/R lut */
        if (vlSetControl(svr, path, csc_node, VL_MGV_CSC_LUT_IN_VR, &val) < 0) {
            vlPerror(“SetControl of CSC VR input lut failed\n”);
        }

        /* Load the page to alpha lut */
        if (vlSetControl(svr, path, csc_node, VL_MGV_CSC_LUT_ALPHA, &val) < 0) {
            vlPerror(“SetControl of CSC ALPHA lut failed\n”);
        }

        /* Select the 1st page of input and alpha luts to be active during
           normal mode, so they will be used for normal operation. */
        val.intVal = 0;
        if (vlSetControl(svr, path, csc_node, VL_MGV_CSC_LUT_IN_PAGE, &val) < 0)
            vlPerror(“SetControl of CSC input lut page failed\n”);

        val.intVal = 0;
        if (vlSetControl(svr, path, csc_node, VL_MGV_CSC_LUT_ALPHA_PAGE, &val)
            < 0)
            vlPerror(“SetControl of CSC alphalut page failed\n”);
 
        /* Generate 4 pages of lut */
        for (i = 0; i < 4096; i++)
            outlutVal.lut[i] = 1000;

        extVal.dataType = MGV_CSC_LUT_OUTPUT;
        extVal.dataSize = sizeof(VL_MGVOutLutValue);
        extVal.dataPointer = &outlutVal;

        val.extVal = extVal;

        /* Load all 4 pages to output Y/G lut */
        if (vlSetControl(svr, path, csc_node, VL_MGV_CSC_LUT_OUT_YG, &val)
            < 0) {
            vlPerror(“SetControl of CSC YG output lut failed\n”);
        }

        /* Load all 4 pages to output U/B lut */
        if (vlSetControl(svr, path, csc_node, VL_MGV_CSC_LUT_OUT_UB, &val)
            < 0) {
            vlPerror(“SetControl of CSC YG output lut failed\n”);
        }

        /* Load all 4 pages to output V/R lut */
        if (vlSetControl(svr, path, csc_node, VL_MGV_CSC_LUT_OUT_VR, &val)
            < 0) {
            vlPerror(“SetControl of CSC YG output lut failed\n”);
        }

        /* Here we set VGI1 controls, begin transfer and Loop until all 
           requested frames are grabbed */

}