#include "sonix_xu_ctrls.h" #include #include #include #include #include #include #include #include #include #include #include #include //for timestamp incomplete error in kernel 2.6.21 #include #include #include #include //#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; }