modularization/src/driver/driver_h264_usbimx291/sonix_io.c

#include "sonix_xu_ctrls.h"
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdint.h>
#include <stdlib.h>
#include <errno.h>
#include <getopt.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/select.h>
#include <sys/time.h>		//for timestamp incomplete error in kernel 2.6.21
#include <linux/videodev2.h>
#include <linux/version.h>
#include <sys/utsname.h>
#include <pthread.h>

//#include "v4l2uvc.h"
#include "sonix_xu_ctrls.h"
#include "nalu.h"
#include "debug.h"
//#include "cap_desc_parser.h"
//#include "cap_desc.h"

#define V4L_BUFFERS_DEFAULT	6//16
#define V4L_BUFFERS_MAX		16//32

#define H264_SIZE_HD				((1280<<16)|720)
#define H264_SIZE_VGA				((640<<16)|480)
#define H264_SIZE_QVGA				((320<<16)|240)
#define H264_SIZE_QQVGA				((160<<16)|112)
#define H264_SIZE_360P				((640<<16)|360)
#define H264_SIZE_180P				((320<<16)|180)

#define MULTI_STREAM_HD_QVGA		0x01
#define MULTI_STREAM_HD_180P		0x02
#define MULTI_STREAM_HD_360P		0x04
#define MULTI_STREAM_HD_VGA			0x08
#define MULTI_STREAM_HD_QVGA_VGA	0x10
#define MULTI_STREAM_QVGA_VGA	    0x20
#define MULTI_STREAM_HD_180P_360P	0x40
#define MULTI_STREAM_360P_180P	    0x80


struct H264Format *gH264fmt = NULL;
int Dbg_Param = 0x1f;

int video_get_framerate(int dev, int *framerate)
{
    struct v4l2_streamparm parm;
    int ret;

    memset(&parm, 0, sizeof parm);
    parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    ret = ioctl(dev, VIDIOC_G_PARM, &parm);
    if (ret < 0) {
        TestAp_Printf(TESTAP_DBG_ERR, "Unable to get frame rate: %d.\n", errno);
        return ret;
    }

    TestAp_Printf(TESTAP_DBG_FLOW, "Current frame rate: %u/%u\n",
        parm.parm.capture.timeperframe.numerator,
        parm.parm.capture.timeperframe.denominator);
    *framerate = parm.parm.capture.timeperframe.denominator;

    return 0;
}

static int video_open(const char *devname)
{
    struct v4l2_capability cap;
    int dev, ret;

    dev = open(devname, O_RDWR);
    if (dev < 0) {
        TestAp_Printf(TESTAP_DBG_ERR, "Error opening device %s: %d.\n", devname, errno);
        return dev;
    }

    memset(&cap, 0, sizeof cap);
    ret = ioctl(dev, VIDIOC_QUERYCAP, &cap);
    if (ret < 0) {
        TestAp_Printf(TESTAP_DBG_ERR, "Error opening device %s: unable to query device.\n",
            devname);
        close(dev);
        return ret;
    }

#if 0
    if ((cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == 0) {
        TestAp_Printf(TESTAP_DBG_ERR, "Error opening device %s: video capture not supported.\n",
            devname);
        close(dev);
        return -EINVAL;
    }
#endif

    printf( "Device %s opened: %s.\n", devname, cap.card);
    return dev;
}

static int get_vendor_verson(int dev, unsigned char szFlashVendorVer[12])
{
    return XU_SF_Read(dev, 0x154, szFlashVendorVer, 12);
}

static int video_set_format(int dev, unsigned int w, unsigned int h, unsigned int format)
{
    struct v4l2_format fmt;
    int ret;

    memset(&fmt, 0, sizeof fmt);
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    fmt.fmt.pix.width = w;
    fmt.fmt.pix.height = h;
    fmt.fmt.pix.pixelformat = format;
    fmt.fmt.pix.field = V4L2_FIELD_ANY;

    ret = ioctl(dev, VIDIOC_S_FMT, &fmt);
    if (ret < 0) {
        TestAp_Printf(TESTAP_DBG_ERR, "Unable to set format: %d.\n", errno);
        return ret;
    }

    TestAp_Printf(TESTAP_DBG_FLOW, "Video format set: width: %u height: %u buffer size: %u\n",
        fmt.fmt.pix.width, fmt.fmt.pix.height, fmt.fmt.pix.sizeimage);
    return 0;
}


static int video_set_still_format(int dev, unsigned int w, unsigned int h, unsigned int format)
{
    struct v4l2_format fmt;
    int ret;

    memset(&fmt, 0, sizeof fmt);
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    fmt.fmt.pix.width = w;
    fmt.fmt.pix.height = h;
    fmt.fmt.pix.pixelformat = format;
    fmt.fmt.pix.field = V4L2_FIELD_ANY;

    if(GetKernelVersion()> KERNEL_VERSION (3, 0, 36))
        ret = ioctl(dev, UVCIOC_STILL_S_FMT_KNL3, &fmt);
    else
        ret = ioctl(dev, UVCIOC_STILL_S_FMT_KNL2, &fmt);

    if (ret < 0) {
        TestAp_Printf(TESTAP_DBG_ERR, "Unable to set still format: %d.\n", errno);
        if(errno == EINVAL)
        TestAp_Printf(TESTAP_DBG_ERR, "still function doesn't support?\n", errno);
        return ret;
    }

    TestAp_Printf(TESTAP_DBG_FLOW, "still format set: width: %u height: %u buffer size: %u\n",
        fmt.fmt.pix.width, fmt.fmt.pix.height, fmt.fmt.pix.sizeimage);
    return 0;
}



static int video_set_framerate(int dev, int framerate, unsigned int *MaxPayloadTransferSize)
{
    struct v4l2_streamparm parm;
    int ret;

    memset(&parm, 0, sizeof parm);
    parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    ret = ioctl(dev, VIDIOC_G_PARM, &parm);
    if (ret < 0) {
        TestAp_Printf(TESTAP_DBG_ERR, "Unable to get frame rate: %d.\n", errno);
        return ret;
    }

    TestAp_Printf(TESTAP_DBG_FLOW, "Current frame rate: %u/%u\n",
        parm.parm.capture.timeperframe.numerator,
        parm.parm.capture.timeperframe.denominator);

    parm.parm.capture.timeperframe.numerator = 1;
    parm.parm.capture.timeperframe.denominator = framerate;

    ret = ioctl(dev, VIDIOC_S_PARM, &parm);
    if (ret < 0) {
        TestAp_Printf(TESTAP_DBG_ERR, "Unable to set frame rate: %d.\n", errno);
        return ret;
    }

    //yiling: get MaxPayloadTransferSize from sonix driver
    if(MaxPayloadTransferSize)
        *MaxPayloadTransferSize = parm.parm.capture.reserved[0];

    ret = ioctl(dev, VIDIOC_G_PARM, &parm);
    if (ret < 0) {
        TestAp_Printf(TESTAP_DBG_ERR, "Unable to get frame rate: %d.\n", errno);
        return ret;
    }

    TestAp_Printf(TESTAP_DBG_FLOW, "Frame rate set: %u/%u\n",
        parm.parm.capture.timeperframe.numerator,
        parm.parm.capture.timeperframe.denominator);
    return 0;
}

static int video_req_still_buf(int dev)
{
    struct v4l2_requestbuffers rb;
    int ret;

    memset(&rb, 0, sizeof rb);
    rb.count = 1;
    rb.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    rb.memory = V4L2_MEMORY_MMAP;

    if(GetKernelVersion()> KERNEL_VERSION (3, 0, 36))
        ret = ioctl(dev, UVCIOC_STILL_REQBUF_KNL3, &rb);
    else
        ret = ioctl(dev, UVCIOC_STILL_REQBUF_KNL2, &rb);


    if (ret < 0) {
        TestAp_Printf(TESTAP_DBG_ERR, "Unable to allocate still buffers: %d.\n", errno);
        return ret;
    }

    TestAp_Printf(TESTAP_DBG_FLOW, "still buffers allocated.\n");
    return rb.count;
}

static int video_enable(int dev, int enable)
{
    int type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    int ret;

    ret = ioctl(dev, enable ? VIDIOC_STREAMON : VIDIOC_STREAMOFF, &type);
    if (ret < 0) {
        TestAp_Printf(TESTAP_DBG_ERR, "Unable to %s capture: %d.\n",
            enable ? "start" : "stop", errno);
        return ret;
    }

    return 0;
}

int get_still_image(int dev, unsigned int w, unsigned int h, unsigned int format)
{
    char filename[30];
    struct v4l2_buffer buf;
    FILE *file = NULL;
    int ret = 0, repeat_setting = 0;
    void *mem;
    static int counter = 0;
    static int still_dev = 0, still_width = 0, still_height = 0, still_format = 0;

    TestAp_Printf(TESTAP_DBG_FLOW, "%s ============>\n",__FUNCTION__);
    if(still_dev == dev && still_width == w && still_height == h && still_format == format)
        repeat_setting = 1;


    //set file name
    if(format == V4L2_PIX_FMT_MJPEG)
        sprintf(filename, "still_img-%02u.jpg", counter);
    else if(format == V4L2_PIX_FMT_YUYV)
        sprintf(filename, "still_img-%02u.yuyv", counter);

    TestAp_Printf(TESTAP_DBG_FLOW, "repeat_setting = %d, fname = %s\n",repeat_setting, filename);

    if(!repeat_setting)
    {
        //set format
        video_set_still_format(dev, w, h, format);

        //request still buffer
        ret = video_req_still_buf(dev);
        if (ret < 0) {
            TestAp_Printf(TESTAP_DBG_ERR, "Unable to request still buffer(%d).\n", errno);
            return ret;
        }
    }
    //mmap
    memset(&buf, 0, sizeof buf);
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    if(GetKernelVersion()> KERNEL_VERSION (3, 0, 36))
        ret = ioctl(dev, UVCIOC_STILL_QUERYBUF_KNL3, &buf);
    else
        ret = ioctl(dev, UVCIOC_STILL_QUERYBUF_KNL2, &buf);

    if (ret < 0) {
        TestAp_Printf(TESTAP_DBG_ERR, "Unable to query still buffer(%d).\n", errno);
        return ret;
    }
    TestAp_Printf(TESTAP_DBG_FLOW, "length: %u offset: %10u     --  ", buf.length, buf.m.offset);


    mem = mmap(0, buf.length, PROT_READ, MAP_SHARED, dev, buf.m.offset);

    if (mem == MAP_FAILED) {
        TestAp_Printf(TESTAP_DBG_ERR, "Unable to map still buffer(%d)\n", errno);
        return -1;
    }
    TestAp_Printf(TESTAP_DBG_FLOW, "still Buffer mapped at address %p.\n", mem);

    //get data
    if(GetKernelVersion()> KERNEL_VERSION (3, 0, 36))
        ret = ioctl(dev, UVCIOC_STILL_GET_FRAME_KNL3, &buf);
    else
        ret = ioctl(dev, UVCIOC_STILL_GET_FRAME_KNL2, &buf);
    if (ret < 0) {
        TestAp_Printf(TESTAP_DBG_ERR, "Unable to get still image(%d).\n", errno);
        return ret;
    }
    TestAp_Printf(TESTAP_DBG_FLOW, "buf.bytesused = %d\n", buf.bytesused);

    file = fopen(filename, "wb");
    if (file != NULL)
        fwrite(mem, buf.bytesused, 1, file);

    fclose(file);
    munmap(mem, buf.length);

    counter ++;
    TestAp_Printf(TESTAP_DBG_FLOW, "%s <============\n",__FUNCTION__);
    still_dev = dev;
    still_width = w;
    still_height = h;
    still_format = format;
    return 0;

}


static int GetFreeRam(int* freeram)
{
    FILE *meminfo = fopen("/proc/meminfo", "r");
    char line[256];
    if(meminfo == NULL)
    {
        TestAp_Printf(TESTAP_DBG_ERR, "/proc/meminfo can't open\n");
        return 0;
    }
    while(fgets(line, sizeof(line), meminfo))
    {
        if(sscanf(line, "MemFree: %d kB", freeram) == 1)
        {
            *freeram <<= 10;
            fclose(meminfo);
            return 1;
        }
    }

    fclose(meminfo);
    return 0;
}

static int video_reqbufs(int dev, int nbufs)
{
    struct v4l2_requestbuffers rb;
    int ret;

    memset(&rb, 0, sizeof rb);
    rb.count = nbufs;
    rb.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    rb.memory = V4L2_MEMORY_MMAP;

    ret = ioctl(dev, VIDIOC_REQBUFS, &rb);
    if (ret < 0) {
        TestAp_Printf(TESTAP_DBG_ERR, "Unable to allocate buffers: %d.\n", errno);
        return ret;
    }

    TestAp_Printf(TESTAP_DBG_FLOW, "%u buffers allocated.\n", rb.count);
    return rb.count;
}

int test(const char * strdevname)
{
    char filename[] = "quickcam-0000.jpg";
    char rec_filename[30] = "RecordH264.h264";			/*"H264.ts"*/
    char rec_filename1[30] = "RecordH264HD.h264";		/*"H264.ts"*/
    char rec_filename2[30] = "RecordH264QVGA.h264";	/*"H264.ts"*/
    char rec_filename3[30] = "RecordH264QQVGA.h264";	/*"H264.ts"*/
    char rec_filename4[30] = "RecordH264VGA.h264";		/*"H264.ts"*/
    int dev, ret;
    int fake_dev; // chris
    int freeram;

    /* Options parsings */
    char do_save = 0, do_enum_inputs = 0, do_capture = 0, do_get_still_image = 0;
    char do_list_controls = 0, do_set_input = 0;
    char *endptr;
    int c;
    int framerate = 30;
    int bit_num = 0, tmp = 0;

    /* Video buffers */
    void *mem0[V4L_BUFFERS_MAX];
    void *mem1[V4L_BUFFERS_MAX];
    unsigned int pixelformat = V4L2_PIX_FMT_MJPEG;
    unsigned int width = 1280;
    unsigned int height = 720;
    unsigned int nbufs = V4L_BUFFERS_DEFAULT;
    unsigned int input = 0;
    unsigned int skip = 0;

    /* Capture loop */
    struct timeval start, end, ts;
    unsigned int delay = 0, nframes = (unsigned int)-1;
    FILE *file = NULL;
    FILE *rec_fp1 = NULL;
    FILE *rec_fp2 = NULL;
    FILE *rec_fp3 = NULL;
    FILE *rec_fp4 = NULL;
    double fps;

    struct v4l2_buffer buf0;
    struct v4l2_buffer buf1;
    unsigned int i;

    char do_record 			= 0;
    /* Houston 2010/11/23 XU Ctrls */
    char do_add_xu_ctrl 	= 0;
    char do_xu_get_chip 	= 0;
    char do_xu_get_fmt   	= 0;
    char do_xu_set_fmt   	= 0;
    char do_xu_get_qp  		= 0;
    char do_xu_set_qp  		= 0;
    char do_xu_get_br  		= 0;
    char do_xu_set_br  		= 0;
    char do_enum_MaxPayloadTransSize = 0;
    int m_QP_Val = 0;
    double m_BitRate = 0.0;
    struct Cur_H264Format cur_H264fmt;
    char do_xu_get 			= 0;
    char do_xu_set 			= 0;
    unsigned char GetXU_ID = 0;
    unsigned char SetXU_ID = 0;
    unsigned char GetCS = 0;
    unsigned char SetCS = 0;
    unsigned char GetCmdDataNum = 0;
    unsigned char SetCmdDataNum = 0;
    __u8 GetData[11] = {0};
    __u8 SetData[11] = {0};

    char do_vendor_version_get = 0;
    char do_bri_set = 0;
    char do_bri_get = 0;
    int m_bri_val = 0;
    char do_shrp_set = 0;
    char do_shrp_get = 0;
    int m_shrp_val = 0;
    char do_asic_r = 0;
    char do_asic_w = 0;
    unsigned int rAsicAddr = 0x0;
    unsigned char rAsicData = 0x0;
    unsigned int wAsicAddr = 0x0;
    unsigned char wAsicData = 0x0;

 // chris +
    /* multi-stream */
    unsigned char multi_stream_format = 0;
    unsigned char multi_stream_enable = 0;
    unsigned int multi_stream_width = 0;//1280;
    unsigned int multi_stream_height = 0;//720;
    unsigned int multi_stream_resolution = 0;//(multi_stream_width << 16) | (multi_stream_height);
    unsigned int MS_bitrate = 0;
    unsigned int MS_qp = 0;
    unsigned int MS_H264_mode = 0;
    unsigned int MS_sub_fr = 0;
    unsigned int MS_sub_gop = 0;
    unsigned int streamID_set = 0;
    unsigned int streamID_get = 0;
    char do_multi_stream_set_bitrate = 0;
    char do_multi_stream_get_bitrate = 0;
    char do_multi_stream_set_qp = 0;
    char do_multi_stream_get_qp = 0;
    char do_multi_stream_set_H264Mode = 0;
    char do_multi_stream_get_H264Mode = 0;
    char do_multi_stream_set_sub_fr = 0;
    char do_multi_stream_get_sub_fr = 0;
    char do_multi_stream_set_sub_gop = 0;
    char do_multi_stream_get_sub_gop = 0;
 // chris -
 //cjc +
    char do_multi_stream_set_type = 0;
    struct Multistream_Info TestInfo;
    char do_multi_stream_get_status = 0;
    char do_multi_stream_get_info = 0;
    char do_multi_stream_set_enable = 0;
    char do_multi_stream_get_enable = 0;
    char do_osd_timer_ctrl_set = 0;
    char do_osd_rtc_set = 0;
    char do_osd_rtc_get = 0;
    char do_osd_size_set = 0;
    char do_osd_size_get = 0;
    char do_osd_color_set = 0;
    char do_osd_color_get = 0;
    char do_osd_show_set = 0;
    char do_osd_show_get = 0;
    char do_osd_autoscale_set = 0;
    char do_osd_autoscale_get = 0;
    char do_osd_ms_size_set = 0;
    char do_osd_ms_size_get = 0;
    char do_osd_position_set = 0;
    char do_osd_position_get = 0;
    char do_osd_ms_position_set = 0;
    char do_osd_ms_position_get = 0;
    char do_md_mode_set = 0;
    char do_md_mode_get = 0;
    char do_md_threshold_set = 0;
    char do_md_threshold_get = 0;
    char do_md_mask_set = 0;
    char do_md_mask_get = 0;
    char do_md_result_set = 0;
    char do_md_result_get = 0;
    char do_mjpg_bitrate_set = 0;
    char do_mjpg_bitrate_get = 0;
    char do_h264_iframe_set = 0;
    char do_h264_sei_set = 0;
    char do_h264_sei_get = 0;
    char do_h264_gop_set = 0;
    char do_h264_gop_get = 0;
    char do_h264_mode_get = 0;
    char do_h264_mode_set = 0;
    char do_img_mirror_set = 0;
    char do_img_mirror_get = 0;
    char do_img_flip_set = 0;
    char do_img_flip_get = 0;
    char do_img_color_set = 0;
    char do_img_color_get = 0;
    char do_osd_string_set = 0;
    char do_osd_string_get = 0;
    char do_osd_carcam_set = 0;
    char do_osd_carcam_get = 0;
    char do_osd_speed_set = 0;
    char do_osd_speed_get = 0;
    char do_osd_coordinate_set = 0;
    char do_osd_coordinate_get = 0;
    char do_gpio_ctrl_set = 0;
    char do_gpio_ctrl_get = 0;
    char do_frame_drop_en_set = 0;
    char do_frame_drop_en_get = 0;
    char do_frame_drop_ctrl_set = 0;
    char do_frame_drop_ctrl_get = 0;
    unsigned char osd_timer_count = 0;
    unsigned int osd_rtc_year = 0;
    unsigned char osd_rtc_month = 0;
    unsigned char osd_rtc_day = 0;
    unsigned char osd_rtc_hour = 0;
    unsigned char osd_rtc_minute = 0;
    unsigned char osd_rtc_second = 0;
    unsigned char osd_size_line = 0;
    unsigned char osd_size_block = 0;
    unsigned char osd_color_font = 0;
    unsigned char osd_color_border = 0;
    unsigned char osd_show_line = 0;
    unsigned char osd_show_block = 0;
    unsigned char osd_autoscale_line = 0;
    unsigned char osd_autoscale_block = 0;
    unsigned char osd_ms_size_stream0 = 0;
    unsigned char osd_ms_size_stream1 = 0;
    unsigned char osd_ms_size_stream2 = 0;
    unsigned char osd_type = 0;
    unsigned int osd_start_row = 0;
    unsigned int osd_start_col = 0;
    unsigned char osd_ms_position_streamid = 0;
    unsigned char osd_ms_start_row = 0;
    unsigned char osd_ms_start_col = 0;
    unsigned char osd_ms_s0_start_row = 0;
    unsigned char osd_ms_s0_start_col = 0;
    unsigned char osd_ms_s1_start_row = 0;
    unsigned char osd_ms_s1_start_col = 0;
    unsigned char osd_ms_s2_start_row = 0;
    unsigned char osd_ms_s2_start_col = 0;
    unsigned int osd_line_start_row = 0;
    unsigned int osd_line_start_col = 0;
    unsigned int osd_block_start_row = 0;
    unsigned int osd_block_start_col = 0;
    unsigned char md_mode = 0;
    unsigned int md_threshold = 0;
    unsigned char md_mask[24] = {0};
    unsigned char md_result[24] = {0};
    unsigned int mjpg_bitrate = 0;
    unsigned char h264_sei_en = 0;
    unsigned int h264_gop = 0;
    unsigned int h264_mode = 0;
    unsigned char img_mirror = 0;
    unsigned char img_flip = 0;
    unsigned char img_color = 0;
    unsigned char h264_iframe_reset = 0;
    unsigned char osd_2nd_string_group = 0;
    unsigned char osd_speed_en = 0;
    unsigned char osd_coordinate_en = 0;
    unsigned char osd_coordinate_ctrl = 0;
    unsigned int osd_speed = 0;
    unsigned char osd_coordinate_direction = 0;
    unsigned char osd_direction_value[6] = {0};
    unsigned char osd_direction_value1 = 0;
    unsigned long osd_direction_value2 = 0;
    unsigned char osd_direction_value3 = 0;
    unsigned long osd_direction_value4 = 0;
    unsigned char gpio_ctrl_en = 0;
    unsigned char gpio_ctrl_output_value = 0;
    unsigned char gpio_ctrl_input_value = 0;
    unsigned char stream1_frame_drop_en = 0;
    unsigned char stream2_frame_drop_en = 0;
    unsigned char stream1_frame_drop_ctrl = 0;
    unsigned char stream2_frame_drop_ctrl = 0;
    char osd_string[12] = {"0"};
    pthread_t thread_capture_id;
    do_xu_get_chip = 1;

    do_capture = 1;
    do_xu_get_br = 1;
    do_xu_set_br = 1;
    do_vendor_version_get = 1;

    dev = video_open(strdevname);
    if (dev < 0)
    {
        printf("fail open device.\n");
        return -1;
    }

    if(do_vendor_version_get)
    {
        char vendor_version[12];
        get_vendor_verson(dev, vendor_version);
        TestAp_Printf(TESTAP_DBG_FLOW, "Vendor Version : %s\n",vendor_version);

    }

    // cjc +
    ret = XU_Ctrl_ReadChipID(dev);
    if(ret<0)
        TestAp_Printf(TESTAP_DBG_ERR, "SONiX_UVC_TestAP @main : XU_Ctrl_ReadChipID Failed\n");
    // cjc -

    if(do_xu_get_br)
    {
        XU_H264_Get_BitRate(dev, &m_BitRate);
        if(m_BitRate < 0 )
            TestAp_Printf(TESTAP_DBG_ERR, "SONiX_UVC_TestAP @main : XU_H264_Get_BitRate Failed\n");
        TestAp_Printf(TESTAP_DBG_FLOW, "Current bit rate: %.2f Kbps\n",m_BitRate);
    }

    m_BitRate = 10000000;
    if(do_xu_set_br)
    {
        if(XU_H264_Set_BitRate(dev, m_BitRate) < 0 )
            TestAp_Printf(TESTAP_DBG_ERR, "SONiX_UVC_TestAP @main : XU_H264_Set_BitRate Failed\n");
    }



    width = 1920;
    height = 1080;
    framerate = 30;
    if (video_set_format(dev, width, height, pixelformat) < 0) {
// cjc +
        if(pixelformat == V4L2_PIX_FMT_H264) {
            TestAp_Printf(TESTAP_DBG_ERR, " === Set Format Failed : skip for H264 ===  \n");
        }
        else {
// cjc -
            close(dev);
            return 1;
        }
    }

    /* Set the frame rate. */
    if (video_set_framerate(dev, framerate, NULL) < 0) {
        close(dev);
        return -2;
    }


    if(GetFreeRam(&freeram) && freeram<1843200*nbufs+4194304)
    {
        TestAp_Printf(TESTAP_DBG_ERR, "free memory isn't enough(%d)\n",freeram);
        return 1;
    }

    /* Allocate buffers. */
    if ((int)(nbufs = video_reqbufs(dev, nbufs)) < 0) {
        close(dev);
    }

    /* Map the buffers. */
    for (i = 0; i < nbufs; ++i) {
        memset(&buf0, 0, sizeof buf0);
        buf0.index = i;
        buf0.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf0.memory = V4L2_MEMORY_MMAP;
        ret = ioctl(dev, VIDIOC_QUERYBUF, &buf0);
        if (ret < 0) {
            TestAp_Printf(TESTAP_DBG_ERR, "Unable to query buffer %u (%d).\n", i, errno);
            close(dev);
            return 1;
        }
        TestAp_Printf(TESTAP_DBG_FLOW, "length: %u offset: %10u     --  ", buf0.length, buf0.m.offset);

        mem0[i] = mmap(0, buf0.length, PROT_READ, MAP_SHARED, dev, buf0.m.offset);
        if (mem0[i] == MAP_FAILED) {
            TestAp_Printf(TESTAP_DBG_ERR, "Unable to map buffer %u (%d)\n", i, errno);
            close(dev);
            return 1;
        }
        TestAp_Printf(TESTAP_DBG_FLOW, "Buffer %u mapped at address %p.\n", i, mem0[i]);
    }

    /* Queue the buffers. */
    for (i = 0; i < nbufs; ++i) {
        memset(&buf0, 0, sizeof buf0);
        buf0.index = i;
        buf0.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf0.memory = V4L2_MEMORY_MMAP;
        ret = ioctl(dev, VIDIOC_QBUF, &buf0);
        if (ret < 0) {
            TestAp_Printf(TESTAP_DBG_ERR, "Unable to queue buffer0(%d).\n", errno);
            close(dev);
            return 1;
        }
    }

    /* Start streaming. */
    video_enable(dev, 1);

    for (i = 0; i < nframes; ++i) {



        /* Dequeue a buffer. */
        memset(&buf0, 0, sizeof buf0);
        buf0.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf0.memory = V4L2_MEMORY_MMAP;
        ret = ioctl(dev, VIDIOC_DQBUF, &buf0);
        if (ret < 0) {
            TestAp_Printf(TESTAP_DBG_ERR, "Unable to dequeue buffer0 (%d).\n", errno);
            close(dev);
            if(multi_stream_enable)
                close(fake_dev);
            return 1;
        }

        gettimeofday(&ts, NULL);


        TestAp_Printf(TESTAP_DBG_FRAME, "Frame[%4u] %u bytes %ld.%06ld %ld.%06ld\n ", i, buf0.bytesused, buf0.timestamp.tv_sec, buf0.timestamp.tv_usec, ts.tv_sec, ts.tv_usec);


        if (i == 0)
            start = ts;


        ret = ioctl(dev, VIDIOC_QBUF, &buf0);
        if (ret < 0) {
            TestAp_Printf(TESTAP_DBG_ERR, "Unable to requeue buffer0 (%d).\n", errno);
            close(dev);
            if(multi_stream_enable)
                close(fake_dev);
            return 1;
        }

        fflush(stdout);
    }


    return 0;

}