├── install_deps.sh
├── test_ov5640_image_mode.sh
├── test_ov5640.sh
├── test_ov8865.sh
├── cap.c
├── readme.md
└── videodev2.h


/install_deps.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | echo "Install development deps..."
3 | sudo apt-get update
4 | sudo apt-get upgrade
5 | sudo apt-get install build-essential automake autoconf libtool yasm git gnupg flex bison gperf curl tofrodos u-boot-tools device-tree-compiler libncurses5-dev zip gzip libzip-dev pkg-config
6 | sudo apt-get install libopencv-dev python3-opencv
7 | echo "Done!"
8 | 


--------------------------------------------------------------------------------
/test_ov5640_image_mode.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | widht=(2592 2048 1920 1600 1280 1280 1024 800 640 320)
 4 | heigth=(1936 1536 1080 1200 960 720 768 600 480 240)
 5 | 
 6 | function reload() {
 7 | 	echo "Re-Loading ov5640..."
 8 | 	sleep 1
 9 | 	modprobe -r -v vfe_v4l2
10 | 	sleep 2
11 | 	modprobe -r -v ov5640
12 | 	sleep 1
13 | 	modprobe ov5640 frame_rate="$1"
14 | 	sleep 2
15 | 	modprobe vfe_v4l2
16 | 	sleep 1
17 | 	echo "done!"
18 | }
19 | 
20 | function load() {
21 | 	echo "Loading ov5640..."
22 | 	modprobe vfe_v4l2
23 | 	sleep 2
24 | 	modprobe ov5640 frame_rate
25 | 	sleep 1
26 | 	echo "done!"
27 | }
28 | 
29 | function unload() {
30 | 	echo "Unloading ov5640.."
31 | 	sleep 1
32 | 	modprobe -r -v vfe_v4l2
33 | 	modprobe -r -v ov5640
34 | 	echo "done!"
35 | }
36 | 
37 | for index in ${!widht[*]}
38 | do
39 | 	# reload "$1"
40 | 	echo "TEST $index"
41 | 	echo "Widht : ${widht[$index]}, Heigth : ${heigth[$index]}"
42 | 	# ./cap <width> <height> <buffers [4,8]> <video mode [0,1]> <exposure [-4,4]> <hflip [0,1]> <vflip [0,1]>
43 | 	./cap "${widht[$index]}" "${heigth[$index]}" "4" "0" "-999" "-1" "-1"
44 | done


--------------------------------------------------------------------------------
/test_ov5640.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | width=(2592 2048 1920 1600 1280 1280 1024 800 640 320 176)
 4 | heigth=(1936 1536 1080 1200 960 720 768 600 480 240 144)
 5 | 
 6 | function reload() {
 7 | 	echo "Reloading OV5640, wait..."
 8 | 	sleep 1
 9 | 	sudo modprobe -r -v vfe_v4l2
10 | 	sleep 2
11 | 	sudo modprobe -r -v ov5640
12 | 	sleep 1
13 | 	sudo modprobe ov5640 frame_rate="$1"
14 | 	sleep 2
15 | 	sudo modprobe vfe_v4l2
16 | 	sleep 1
17 | 	echo "done!"
18 | }
19 | 
20 | function load() {
21 | 	echo "Loading OV5640, wait..."
22 | 	sleep 1
23 |     sudo modprobe ov5640 frame_rate="$1"
24 | 	sleep 2
25 | 	sudo modprobe vfe_v4l2
26 | 	sleep 1
27 | 	echo "done!"
28 | }
29 | 
30 | function unload() {
31 | 	echo "Unloading OV5640, wait..."
32 | 	sleep 1
33 | 	sudo modprobe -r -v vfe_v4l2
34 | 	sleep 2
35 | 	sudo modprobe -r -v ov5640
36 | 	sleep 1
37 | 	echo "done!"
38 | }
39 | 
40 | for index in ${!width[*]}
41 | do
42 | 	# reload "$1"
43 | 	echo "TEST OV5640 - $index - ( ${width[$index]} x ${heigth[$index]} )"
44 | 	# ./cap <width> <height> <buffers [4,8]> <video mode [0,1]> <exposure [-4,4]> <hflip [0,1]> <vflip [0,1]>
45 | 	./cap "${width[$index]}" "${heigth[$index]}" "4" "1" "-999" "-1" "-1"
46 | done
47 | 


--------------------------------------------------------------------------------
/test_ov8865.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | w=(3264 3264 1920 1600 1280 800 640)
 4 | h=(2448 1836 1080 1200 960 600 480)
 5 | 
 6 | function reload() {
 7 |     echo "Reloading OV8865, wait..."
 8 |     sleep 1
 9 | 	sudo modprobe -r -v vfe_v4l2
10 |     sleep 2
11 | 	sudo modprobe -r -v ov8858_4lane
12 |     sleep 1
13 |     sudo modprobe -r -v vm149c_act
14 |     sleep 1
15 |     sudo modprobe vm149c_act
16 |     sleep 1
17 | 	sudo modprobe ov8858_4lane
18 |     sleep 2
19 | 	sudo modprobe vfe_v4l2
20 |     echo "done!"
21 | }
22 | 
23 | function load() {
24 |     echo "Loading OV8865, wait..."
25 |     sudo modprobe vm149c_act
26 |     sudo modprobe ov8858_4lane
27 | 	sudo modprobe vfe_v4l2
28 |     echo "done!"
29 | }
30 | 
31 | function unload() {
32 |     echo "Unloading OV8865, wait..."
33 | 	sudo modprobe -r -v vfe_v4l2
34 | 	sleep 2
35 | 	sudo modprobe -r -v ov8858_4lane
36 | 	sleep 1
37 |     sudo modprobe -r -v vm149c_act
38 | 	sleep 1
39 |     echo "done!"
40 | }
41 | 
42 | for index in ${!w[*]}
43 | do
44 | 	# reload "$1"
45 | 	echo "TEST OV8865 - $index ( ${w[$index]} x ${h[$index]} )"
46 | 	# ./cap <width> <height> <buffers [4,8]> <video mode [0,1]> <exposure [-4,4]> <hflip [0,1]> <vflip [0,1]>
47 | 	./cap "${w[$index]}" "${h[$index]}" "8" "1" "-999" "-1" "-1"
48 | done
49 | 


--------------------------------------------------------------------------------
/cap.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *  OpenCV BSD3 License
  3 |  *  videodev2.h BSD License (dual license)
  4 |  *  If you raise some license issue here simply don't use it and let us know
  5 |  * 
  6 |  *  Copyright (C) 2016 the contributors
  7 |  *
  8 |  *  Luiz Vitor Martinez Cardoso
  9 |  *  Jules Thuillier
 10 |  *  @lex (avafinger)
 11 |  *
 12 |  *  gcc cap.c -o cap $(pkg-config --libs --cflags opencv) -lm
 13 |  *
 14 |  *  gcc -I/usr/src/linux-headers-VERSION/ cap.c -o cap $(pkg-config --libs --cflags opencv) -lm -O3
 15 |  *
 16 | */
 17 | 
 18 | #include <stdlib.h>
 19 | #include <stdio.h>
 20 | #include <errno.h>
 21 | #include <fcntl.h>
 22 | #include <stdint.h>
 23 | #include <unistd.h>
 24 | #include <malloc.h>
 25 | #include <string.h>
 26 | #include <sys/mman.h>
 27 | #include <sys/time.h>
 28 | #include <sys/ioctl.h>
 29 | 
 30 | /* -----------------------------------------------------------------------------
 31 |  * BananaPi M64 / Pine64+ (A64) or if you want to control Exposure,Hflip,Vflip
 32 |  * -----------------------------------------------------------------------------
 33 |  * _V4L2_KERNEL_ should be defined and point to: /usr/src/linux-headers-version
 34 |  * 
 35 |  * build with: gcc -I/usr/src/linux-headers-3.10.102/ cap.c -o cap $(pkg-config --libs --cflags opencv) -lm -O3
 36 |  *
 37 |  * 
 38 |  * -----------------------------------------------------------------------------
 39 |  * OrangePi / BananaPi / NanoPi (H3) / BPI-M3 (A83T - ov5640 & ov8865)
 40 |  * -----------------------------------------------------------------------------
 41 |  * _V4L2_KERNEL_ should not be defined unless you want Exposure, Hflip and Vflip
 42 |  *
 43 |  * build with: gcc cap.c -o cap $(pkg-config --libs --cflags opencv) -lm
 44 |  *
 45 |  * 
 46 | */
 47 | //#define _V4L2_KERNEL_	// BananaPi M64 / Pine64+ only or for setting Exposure,Hflip,Vflip
 48 | 
 49 | #ifdef _V4L2_KERNEL_
 50 | /* --- A64 --- */
 51 | #include <linux/videodev2.h>
 52 | #else
 53 | /* --- H3 / A83T --- */
 54 | #include "videodev2.h"
 55 | #endif
 56 | 
 57 | // #include <opencv2/core/core.hpp>
 58 | // #include <opencv2/highgui/highgui.hpp>
 59 | 
 60 | #include <opencv2/core/core.hpp>
 61 | #include <opencv2/imgproc/imgproc_c.h>
 62 | #include <opencv2/imgproc.hpp>
 63 | #include <opencv2/imgcodecs.hpp>
 64 | #include <opencv2/opencv.hpp>
 65 | #include <opencv2/videoio.hpp>
 66 | #include <opencv2/highgui.hpp>
 67 | 
 68 | using namespace cv;
 69 | using namespace std;
 70 | 
 71 | #ifdef _V4L2_KERNEL_
 72 | #define V4L2_MODE_VIDEO				0x0002  /* video capture */
 73 | #define V4L2_MODE_IMAGE				0x0003  /* image capture */
 74 | #define V4L2_MODE_PREVIEW			0x0004  /* preview capture */
 75 | #endif
 76 | 
 77 | #define N_BUFFERS 4
 78 | #define CAP_OK 0
 79 | #define CAP_ERROR -1
 80 | #define CAP_ERROR_RET(s) { \
 81 | 							printf("v4l2: %s\n", s); \
 82 | 							return CAP_ERROR; \
 83 | 						 }
 84 | #define CAP_CLIP(val, min, max) (((val) > (max)) ? (max) : (((val) < (min)) ? (min) : (val)))
 85 | 
 86 | #define CLEAR(x) memset (&(x), 0, sizeof (x))
 87 | #define ALIGN_4K(x) (((x) + (4095)) & ~(4095))
 88 | #define ALIGN_16B(x) (((x) + (15)) & ~(15))
 89 | 
 90 | 
 91 | typedef struct {
 92 |     void *start;
 93 |     size_t length;
 94 | } v4l2_buffer_t;
 95 | 
 96 | int width;
 97 | int height;
 98 | v4l2_buffer_t *buffers = NULL;
 99 | int n_buffers = N_BUFFERS;
100 | int sensor_video_mode;
101 | int sensor_exposure;
102 | int sensor_hflip;
103 | int sensor_vflip;
104 | 
105 | double get_wall_time()
106 | {
107 |     struct timeval time;
108 |     if (gettimeofday(&time, NULL))
109 |         return 0.;
110 |     return (double) time.tv_sec + (double) time.tv_usec * .000001;
111 | }
112 | 
113 | int yuv420p_to_bgr(void *in, int length, unsigned char *out)
114 | {
115 |     uint8_t *yptr, *uptr, *vptr;
116 |     uint32_t x, y, p;
117 | 
118 |     if (length < (width * height * 3) / 2)
119 |         return CAP_ERROR;
120 | 
121 |     yptr = (uint8_t *) in;
122 |     uptr = yptr + (width * height);
123 |     vptr = uptr + (width * height / 4);
124 |     p = 0;
125 | 
126 |     for (y = 0; y < height; y++) {
127 |         for (x = 0; x < width; x++) {
128 |             int r, g, b;
129 |             int y, u, v;
130 | 
131 |             y = *(yptr++) << 8;
132 |             u = uptr[p] - 128;
133 |             v = vptr[p] - 128;
134 | 
135 |             r = (y + (359 * v)) >> 8;
136 |             g = (y - (88 * u) - (183 * v)) >> 8;
137 |             b = (y + (454 * u)) >> 8;
138 | 
139 |             *(out++) += CAP_CLIP(b, 0x00, 0xFF);
140 |             *(out++) += CAP_CLIP(g, 0x00, 0xFF);
141 |             *(out++) += CAP_CLIP(r, 0x00, 0xFF);
142 | 
143 |             if (x & 1)
144 |                 p++;
145 |         }
146 | 
147 |         if (!(y & 1))
148 |             p -= width / 2;
149 |     }
150 | 
151 |     return CAP_ERROR;
152 | }
153 | 
154 | static int xioctl(int fd, int request, void *arg)
155 | {
156 |     int r;
157 |     int tries = 3;
158 | 
159 |     do {
160 |         r = ioctl(fd, request, arg);
161 |     } while (--tries > 0 && -1 == r && EINTR == errno);
162 | 
163 |     return r;
164 | }
165 | 
166 | int v4l2_display_sizes_pix_format(int fd)
167 | {
168 | 	int ret = 0;
169 | 	int fsizeind = 0; /*index for supported sizes*/
170 | 	struct v4l2_frmsizeenum fsize;
171 | 
172 |     printf("V4L2 pixel sizes:\n");
173 | 
174 | 	CLEAR(fsize);
175 | 	fsize.index = 0;
176 | 	fsize.pixel_format = V4L2_PIX_FMT_YUV420;
177 | 
178 | 	while ((ret = xioctl(fd, VIDIOC_ENUM_FRAMESIZES, &fsize)) == 0)	{
179 | 		fsize.index++;
180 | 		if (fsize.type == V4L2_FRMSIZE_TYPE_DISCRETE) {
181 | 			printf("( %u x %u ) Pixels\n", fsize.discrete.width, fsize.discrete.height);
182 | 			fsizeind++;
183 | 		}	
184 | 	}
185 |     return fsizeind;
186 | }
187 | 
188 | int v4l2_display_pix_format(int fd)
189 | {
190 |     struct v4l2_fmtdesc fmt;
191 |     int index;
192 | 
193 |     printf("V4L2 pixel formats:\n");
194 | 
195 |     index = 0;
196 |     CLEAR(fmt);
197 |     fmt.index = index;
198 |     fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
199 | 
200 |     while (ioctl(fd, VIDIOC_ENUM_FMT, &fmt) != -1) {
201 |         printf("%i: [0x%08X] '%c%c%c%c' (%s)\n", index, fmt.pixelformat, fmt.pixelformat >> 0, fmt.pixelformat >> 8, fmt.pixelformat >> 16, fmt.pixelformat >> 24, fmt.description);
202 | 
203 |         memset(&fmt, 0, sizeof(fmt));
204 |         fmt.index = ++index;
205 |         fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
206 |     }
207 |     // printf("\n");
208 | }
209 | 
210 | #ifdef _V4L2_KERNEL_
211 | int v4l2_set_exposure(int fd, int exposure)
212 | {
213 |     struct v4l2_queryctrl queryctrl;
214 |     struct v4l2_control control;
215 |     int rc;
216 | 
217 |     printf("set Exposure: %d\n", exposure);
218 |     rc = 0;
219 |     memset(&control, 0, sizeof(control));
220 |     control.id = V4L2_CID_EXPOSURE;
221 |     rc = xioctl(fd, VIDIOC_G_CTRL, &control);
222 |     printf("rc: %d - get exposure: %d\n", rc, control.value);
223 |     control.value = exposure;
224 |     rc = xioctl(fd, VIDIOC_S_CTRL, &control);
225 |     printf("rc: %d - new exposure: %d\n", rc, exposure);
226 |     return rc;
227 | }
228 | 
229 | int v4l2_set_hflip(int fd, int hflip)
230 | {
231 |     struct v4l2_queryctrl queryctrl;
232 |     struct v4l2_control control;
233 |     int rc;
234 | 
235 |     printf("set Hflip: %d\n", hflip);
236 |     rc = 0;
237 |     memset(&control, 0, sizeof(control));
238 |     control.id = V4L2_CID_HFLIP;
239 |     rc = xioctl(fd, VIDIOC_G_CTRL, &control);
240 |     printf("rc: %d - get value: %d\n", rc, control.value);
241 |     control.value = hflip;
242 |     rc = xioctl(fd, VIDIOC_S_CTRL, &control);
243 |     printf("rc: %d - new value: %d\n", rc, control.value);
244 |     return rc;
245 | }
246 | 
247 | int v4l2_set_vflip(int fd, int vflip)
248 | {
249 |     struct v4l2_queryctrl queryctrl;
250 |     struct v4l2_control control;
251 |     int rc;
252 | 
253 |     printf("set Vflip: %d\n", vflip);
254 |     rc = 0;
255 |     memset(&control, 0, sizeof(control));
256 |     control.id = V4L2_CID_VFLIP;
257 |     rc = xioctl(fd, VIDIOC_G_CTRL, &control);
258 |     printf("rc: %d - get value: %d\n", rc, control.value);
259 |     control.value = vflip;
260 |     rc = xioctl(fd, VIDIOC_S_CTRL, &control);
261 |     printf("rc: %d - new value: %d\n", rc, control.value);
262 |     return rc;
263 | }
264 | #endif
265 | 
266 | int v4l2_init_camera(int fd)
267 | {
268 |     uint32_t i;
269 |     uint32_t index;
270 |     struct v4l2_streamparm parms;
271 |     struct v4l2_format fmt;
272 |     struct v4l2_input input;
273 |     struct v4l2_capability caps;
274 | 
275 |     CLEAR(fmt);
276 |     CLEAR(input);
277 |     CLEAR(caps);
278 | 
279 | 
280 |     if (xioctl(fd, VIDIOC_QUERYCAP, &caps) == -1) {
281 |         CAP_ERROR_RET("unable to query capabilities.");
282 |     }
283 | 
284 |     if (!(caps.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
285 |         CAP_ERROR_RET("doesn't support video capturing.");
286 |     }
287 | 
288 |     printf("Driver: \"%s\"\n", caps.driver);
289 |     printf("Card: \"%s\"\n", caps.card);
290 |     printf("Bus: \"%s\"\n", caps.bus_info);
291 |     printf("Version: %d.%d\n", (caps.version >> 16) && 0xff, (caps.version >> 24) && 0xff);
292 |     printf("Capabilities: %08x\n", caps.capabilities);
293 | 
294 |     input.index = 0;
295 |     if (xioctl(fd, VIDIOC_ENUMINPUT, &input) == -1) {
296 |         CAP_ERROR_RET("unable to enumerate input.");
297 |     }
298 | 
299 |     printf("Input: %d\n", input.index);
300 |     if (xioctl(fd, VIDIOC_S_INPUT, &input.index) == -1) {
301 |         CAP_ERROR_RET("unable to set input.");
302 |     }
303 | 
304 |     parms.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
305 |     parms.parm.capture.capturemode = sensor_video_mode ? V4L2_MODE_VIDEO : V4L2_MODE_IMAGE;
306 |     // parms.parm.capture.capturemode =0;
307 |     parms.parm.capture.timeperframe.numerator = 1;
308 |     parms.parm.capture.timeperframe.denominator = sensor_video_mode ? 30 : 7;
309 |     if (-1 == xioctl(fd, VIDIOC_S_PARM, &parms)) {
310 |         CAP_ERROR_RET("unable to set stream parm.");
311 |     }
312 | 
313 |     v4l2_display_pix_format(fd);
314 |     v4l2_display_sizes_pix_format(fd);
315 |     printf("\n");
316 | 
317 |     fmt.fmt.pix.width = width;
318 |     fmt.fmt.pix.height = height;
319 |     fmt.fmt.pix.field = V4L2_FIELD_NONE;        // V4L2_FIELD_ANY;
320 |     fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
321 |     fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420;
322 |     //fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB24;
323 | 
324 |     if (xioctl(fd, VIDIOC_TRY_FMT, &fmt) == -1) {
325 |         CAP_ERROR_RET("failed trying to set pixel format.");
326 |     }
327 | 
328 |     if (fmt.fmt.pix.width != width || fmt.fmt.pix.height != height) {
329 |         width = fmt.fmt.pix.width;
330 |         height = fmt.fmt.pix.height;
331 |         printf("Sensor size adjusted to: %dx%d pixels\n", width, height);
332 |     } else {
333 |         printf("Sensor size: %dx%d pixels\n", width, height);
334 |     }
335 | 
336 |     if (xioctl(fd, VIDIOC_S_FMT, &fmt) == -1) {
337 |         CAP_ERROR_RET("failed to set pixel format.");
338 |     }
339 | 
340 |     switch (fmt.fmt.pix.pixelformat) {
341 |     case V4L2_PIX_FMT_RGB24:
342 |             printf("Pixel Format: V4L2_PIX_FMT_RGB24 [0x%08X]\n",fmt.fmt.pix.pixelformat);
343 |             break;
344 |         
345 |     case V4L2_PIX_FMT_YUV420:
346 |             printf("Pixel Format: V4L2_PIX_FMT_YUV420 [0x%08X]\n",fmt.fmt.pix.pixelformat);
347 |             break;
348 |         
349 |     }
350 | 
351 |     return CAP_OK;
352 | }
353 | 
354 | int v4l2_set_mmap(int fd, int *buffers_count)
355 | {
356 |     int i;
357 |     int nbf;
358 |     enum v4l2_buf_type type;
359 |     struct v4l2_requestbuffers req;
360 |     struct v4l2_buffer buf;
361 | 
362 |     CLEAR(req);
363 |     req.count = sensor_video_mode ? n_buffers : 1;
364 |     req.memory = V4L2_MEMORY_MMAP;
365 |     req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
366 |     if (xioctl(fd, VIDIOC_REQBUFS, &req) == -1) {
367 |         CAP_ERROR_RET("failed requesting buffers.");
368 |     }
369 |     nbf = req.count;
370 |     if (n_buffers != nbf) {
371 |         CAP_ERROR_RET("insufficient buffer memory.");
372 |     }
373 | 
374 |     buffers = (v4l2_buffer_t *) calloc(nbf, sizeof(v4l2_buffer_t));
375 |     if (!buffers) {
376 |         CAP_ERROR_RET("failed to allocated buffers memory.");
377 |     }
378 | 
379 |     for (i = 0; i < nbf; i++) {
380 |         CLEAR(buf);
381 |         buf.index = i;
382 |         buf.memory = V4L2_MEMORY_MMAP;
383 |         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
384 |         if (xioctl(fd, VIDIOC_QUERYBUF, &buf) == -1) {
385 |             CAP_ERROR_RET("failed to query buffer.");
386 |         }
387 |         buffers[i].length = buf.length;
388 |         buffers[i].start = mmap(NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, buf.m.offset);
389 |         if (MAP_FAILED == buffers[i].start) {
390 |             CAP_ERROR_RET("failed to mmap buffer.");
391 |         }
392 |     }
393 | 
394 |     for (i = 0; i < nbf; i++) {
395 |         CLEAR(buf);
396 |         buf.index = i;
397 |         buf.memory = V4L2_MEMORY_MMAP;
398 |         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
399 | 
400 |         if (xioctl(fd, VIDIOC_QBUF, &buf) == -1) {
401 |             CAP_ERROR_RET("failed to queue buffer.");
402 |         }
403 |     }
404 | 
405 |     type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
406 |     if (xioctl(fd, VIDIOC_STREAMON, &type) == -1) {
407 |         CAP_ERROR_RET("failed to stream on.");
408 |     }
409 | 
410 |     *buffers_count = nbf;
411 | 
412 |     return CAP_OK;
413 | }
414 | 
415 | int v4l2_retrieve_frame(int fd, int buffers_count, int save_frame_jpg, int save_frame_yuv)
416 | {
417 |     int sz;
418 |     char frame_name[128];
419 |     FILE *f;
420 |     fd_set fds;
421 |     IplImage *frame_ipl;
422 |     CvMat frame_bgr;
423 |     unsigned char *frame_yuv;
424 |     struct timeval tv;
425 |     struct v4l2_buffer buf;
426 |     int rc;
427 | 
428 |     CLEAR(tv);
429 |     CLEAR(buf);
430 | 
431 |     rc = 1;
432 |     while (rc > 0) {
433 |         FD_ZERO(&fds);
434 |         FD_SET(fd, &fds);
435 | 
436 |         tv.tv_sec = 2;
437 |         tv.tv_usec = 0;
438 | 
439 |         rc = select(fd + 1, &fds, NULL, NULL, &tv);
440 |         if (-1 == rc) {
441 |             if (EINTR == errno) {
442 |                 rc = 1;         // try again
443 |                 continue;
444 |             }
445 |             CAP_ERROR_RET("failed to select frame.");
446 |         }
447 |         /* we got something */
448 |         break;
449 |     }
450 |     if (rc <= 0) {
451 |         sprintf(frame_name, "errno: %d - check sensor, something wrong.", errno);
452 |         CAP_ERROR_RET(frame_name);
453 |     }
454 | 
455 |     buf.memory = V4L2_MEMORY_MMAP;
456 |     buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
457 |     if (xioctl(fd, VIDIOC_DQBUF, &buf) == -1) {
458 |         CAP_ERROR_RET("failed to retrieve frame.");
459 |     }
460 | 
461 |     printf("Length: %d \tBytesused: %d \tAddress: %p\n", buf.length, buf.bytesused, &buffers[buf.index]);
462 | 
463 |     if (save_frame_yuv) {
464 |         sprintf(frame_name, "frame_%dx%d.yuv", width, height);
465 |         f = fopen(frame_name, "wb");
466 |         if (f != NULL) {
467 |             sz = ALIGN_16B(width) * height * 3 / 2;
468 |             fwrite(buffers[buf.index].start, sz, 1, f);
469 |             fclose(f);
470 |         }
471 |     }
472 | 
473 |     if (save_frame_jpg) {
474 |         unsigned char **frame_yuv = (unsigned char **)calloc(ALIGN_16B(width) * height * 3, sizeof(*frame_yuv));
475 |         yuv420p_to_bgr(buffers[buf.index].start, buf.length, *frame_yuv);
476 |         cv::Mat frame_bgr = cv::Mat(height, width, CV_8UC3, frame_yuv);
477 |         sprintf(frame_name, "frame_%dx%d.jpg", width, height);
478 |         imwrite(frame_name, frame_bgr);
479 |         free(frame_yuv);
480 |     }
481 | 
482 |     if (xioctl(fd, VIDIOC_QBUF, &buf) == -1) {
483 |         CAP_ERROR_RET("failed to queue buffer.");
484 |     }
485 | 
486 |     return CAP_OK;
487 | }
488 | 
489 | int v4l2_close_camera(int fd, int buffers_count)
490 | {
491 |     int i;
492 |     enum v4l2_buf_type type;
493 | 
494 |     type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
495 |     if (xioctl(fd, VIDIOC_STREAMOFF, &type) == -1) {
496 |         CAP_ERROR_RET("failed to stream off.");
497 |     }
498 | 
499 |     for (i = 0; i < buffers_count; i++)
500 |         munmap(buffers[i].start, buffers[i].length);
501 | 
502 |     close(fd);
503 | }
504 | 
505 | int main(int argc, char *argv[])
506 | {
507 |     int i, n, save_frame;
508 |     int fd;
509 |     double after;
510 |     double before;
511 |     double avg, fps;
512 |     int buffers_count;
513 | 
514 |     if (argc != 8) {
515 |         CAP_ERROR_RET("./cap <width> <height> <buffers [4,8]> <video mode [0,1]> <exposure [-4,4]> <hflip [0,1]> <vflip [0,1]>")
516 |     }
517 |     n = 0;
518 |     width = (int) atoi(argv[1]);
519 |     height = (int) atoi(argv[2]);
520 |     n_buffers = (int) atoi(argv[3]);
521 |     if (n_buffers < 4)
522 |         n_buffers = 4;
523 |     if (n_buffers > 8)
524 |         n_buffers = 8;          // enough in VIDEO MODE!!!
525 | 
526 |     sensor_video_mode = (int) atoi(argv[4]);
527 |     if (!sensor_video_mode)
528 |         n_buffers = 1;
529 |     sensor_exposure = (int) atoi(argv[5]);
530 |     sensor_hflip = (int) atoi(argv[6]);
531 |     sensor_vflip = (int) atoi(argv[7]);
532 | 
533 |     printf("---- cap parameters -----\nwidth: %d\nheight: %d\nv4l2 buffers: %d\nexposure: %d\nhflip: %d\nvflip: %d\nMode: %s\n", width, height, n_buffers, sensor_exposure, sensor_hflip, sensor_vflip, sensor_video_mode ? "V4L2_MODE_VIDEO" : "V4L2_MODE_IMAGE");
534 | 
535 |     fd = open("/dev/video0", O_RDWR | O_NONBLOCK);
536 |     if (fd == -1) {
537 |         CAP_ERROR_RET("failed to open the camera.");
538 |     }
539 | 
540 |     if (v4l2_init_camera(fd) == -1) {
541 |         CAP_ERROR_RET("failed to init camera.");
542 |     }
543 | #ifdef _V4L2_KERNEL_
544 |     if (sensor_exposure != -999) {
545 |         v4l2_set_exposure(fd, sensor_exposure);
546 |     }
547 |     if (sensor_hflip != -1) {
548 |         v4l2_set_hflip(fd, sensor_hflip);
549 |     }
550 | 
551 |     if (sensor_vflip != -1) {
552 |         v4l2_set_vflip(fd, sensor_vflip);
553 |     }
554 | #endif
555 | 
556 |     if (v4l2_set_mmap(fd, &buffers_count) == -1) {
557 |         CAP_ERROR_RET("failed to mmap.");
558 |     }
559 | 
560 |     /* cvNamedWindow("frame", CV_WINDOW_AUTOSIZE); */
561 |     save_frame = sensor_video_mode ? 10 : 1;   // run some frame grabbing before saving the JPG / PNG image
562 |     printf("Frame #%d will be saved!\n", save_frame);
563 |     for (i = 0; i < save_frame; i++) {
564 |         before = get_wall_time();
565 |         if (v4l2_retrieve_frame(fd, buffers_count, (i + 1 == save_frame), 0) == -1) {
566 |             CAP_ERROR_RET("failed to retrieve frame.");
567 |         }
568 |         after = get_wall_time();
569 |         fps = 1.0 / (after - before);
570 |         if (i && (i + 1) != save_frame) {
571 |             avg += fps;
572 |             n++;
573 |         }
574 |         printf("FPS[%d]: %.2f\n", i, fps);
575 |     }
576 | 
577 |     v4l2_close_camera(fd, buffers_count);
578 |     
579 |     if (n) {
580 |         printf("------- Avg FPS: %.2f --------\n\n", (double) (avg / (double) n));
581 |     }
582 | 
583 |     return CAP_OK;
584 | }
585 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
  1 | cap - v4l2 and OpenCV capture frames on OV5640 and OV8865
  2 | =========================================================
  3 | 
  4 | Capture frames from a CMOS camera (ov5640 / ov8865 / gc2035) and save it int YUV or JPG file with the help of OpenCV.
  5 | 
  6 | Usage (OV5640)
  7 | ==============
  8 | 	./cap width heigth n_buffers video_mode exposure Hflip Vflip
  9 | 
 10 | Example:
 11 | 
 12 | 	./cap 1920 1080 4 1 -999 -1 -1
 13 | 
 14 | 
 15 | 
 16 | Usage (OV8865)
 17 | ==============
 18 | 	./cap width heigth n_buffers=8 video_mode=1 exposure=-999 Hflip=-1 Vflip=-1
 19 | 
 20 | Example:
 21 | 
 22 | 	./cap 1920 1080 8 1 -999 -1 -1
 23 | 
 24 | 
 25 | Requirements:
 26 | =============
 27 | 
 28 | - good Distro image (Ubuntu or Jessie) with no broken packages
 29 | - gcc and all the deps libraries (run sudo ./install_deps.sh)
 30 | - run the ./build_script.sh for H3 / A83T and ./build_script_A64.sh for the A64
 31 | - linux headers if you build for A64 (or get it here: https://github.com/avafinger/OV5640_camera)
 32 | 
 33 | How to build
 34 | ============
 35 | 
 36 | 	git clone https://github.com/avafinger/cap-v4l2
 37 | 	cd cap-v4l2
 38 | 	sudo ./install_deps.sh
 39 | 	./build_script.sh
 40 | 	./cap 1920 1080 4 1 -999 -1 -1 (output will be frame_1920x1080.jpg)
 41 | 
 42 | - Important (A64):
 43 | 
 44 | You will need Linux headers source files (/usr/src/linux-headers-XXXXXXX) when building for A64, install the kernel headers
 45 | 
 46 | 
 47 | 
 48 | Building for A64 use the provided script: 
 49 | 
 50 | 	./build_script_A64.sh
 51 | 
 52 | 
 53 | - Important (A83T):
 54 | 
 55 | If you run cap on BananaPi M3 you need to re-compile kernel and supress some BPI fix for the 8M sensor that set v4l2 minimum buffer to 8.
 56 | Or you can try to increase buffer number and see if you don't get the error: 'insufficient buffer memory.'
 57 | 
 58 | Building for A83T use the provided script: 
 59 | 
 60 | 	./build_script.sh
 61 | 
 62 | 
 63 | 
 64 | - you can run a simple test ./test_ov5640.sh to grab all frames and display some FPS statistics
 65 | 
 66 | 
 67 | Output from testing cap app
 68 | ===========================
 69 | 
 70 | 	TEST 0 - ( 2592 x 1936 )
 71 | 	---- cap parameters -----
 72 | 	width: 2592
 73 | 	height: 1936
 74 | 	v4l2 buffers: 4
 75 | 	exposure: -999
 76 | 	hflip: -1
 77 | 	sensor_vflip: -1
 78 | 	Mode: V4L2_MODE_VIDEO
 79 | 	Driver: "sunxi-vfe"
 80 | 	Card: "sunxi-vfe"
 81 | 	Bus: "sunxi_vfe vfe.12"
 82 | 	Version: 1.0
 83 | 	Capabilities: 05000001
 84 | 	Input: 0
 85 | 	V4L2 pixel formats:
 86 | 	0: [0x50323234] '422P' (planar YUV 422)
 87 | 	1: [0x32315559] 'YU12' (planar YUV 420)
 88 | 	2: [0x32315659] 'YV12' (planar YVU 420)
 89 | 	3: [0x3631564E] 'NV16' (planar YUV 422 UV combined)
 90 | 	4: [0x3231564E] 'NV12' (planar YUV 420 UV combined)
 91 | 	5: [0x3136564E] 'NV61' (planar YUV 422 VU combined)
 92 | 	6: [0x3132564E] 'NV21' (planar YUV 420 VU combined)
 93 | 	7: [0x32314D48] 'HM12' (MB YUV420)
 94 | 	8: [0x56595559] 'YUYV' (YUV422 YUYV)
 95 | 	9: [0x55595659] 'YVYU' (YUV422 YVYU)
 96 | 	10: [0x59565955] 'UYVY' (YUV422 UYVY)
 97 | 	11: [0x59555956] 'VYUY' (YUV422 VYUY)
 98 | 	12: [0x31384142] 'BA81' (RAW Bayer BGGR 8bit)
 99 | 	13: [0x47524247] 'GBRG' (RAW Bayer GBRG 8bit)
100 | 	14: [0x47425247] 'GRBG' (RAW Bayer GRBG 8bit)
101 | 	15: [0x47425247] 'GRBG' (RAW Bayer RGGB 8bit)
102 | 	16: [0x30314742] 'BG10' (RAW Bayer BGGR 10bit)
103 | 	17: [0x30314247] 'GB10' (RAW Bayer GBRG 10bit)
104 | 	18: [0x30314142] 'BA10' (RAW Bayer GRBG 10bit)
105 | 	19: [0x30314142] 'BA10' (RAW Bayer RGGB 10bit)
106 | 	20: [0x32314742] 'BG12' (RAW Bayer BGGR 12bit)
107 | 	21: [0x32314247] 'GB12' (RAW Bayer GBRG 12bit)
108 | 	22: [0x32314142] 'BA12' (RAW Bayer GRBG 12bit)
109 | 	23: [0x32314142] 'BA12' (RAW Bayer RGGB 12bit)
110 | 	
111 | 	Sensor size: 2592x1936 pixels
112 | 	Pixel Format: V4L2_PIX_FMT_YUV420
113 | 	Frame #10 will be saved!
114 | 	Length: 7528448 	Bytesused: 7528448 	Address: 0x453be0
115 | 	FPS[0]: 1.27
116 | 	Length: 7528448 	Bytesused: 7528448 	Address: 0x453bf0
117 | 	FPS[1]: 7.51
118 | 	Length: 7528448 	Bytesused: 7528448 	Address: 0x453c00
119 | 	FPS[2]: 7.51
120 | 	Length: 7528448 	Bytesused: 7528448 	Address: 0x453c10
121 | 	FPS[3]: 7.51
122 | 	Length: 7528448 	Bytesused: 7528448 	Address: 0x453be0
123 | 	FPS[4]: 7.50
124 | 	Length: 7528448 	Bytesused: 7528448 	Address: 0x453bf0
125 | 	FPS[5]: 7.51
126 | 	Length: 7528448 	Bytesused: 7528448 	Address: 0x453c00
127 | 	FPS[6]: 7.50
128 | 	Length: 7528448 	Bytesused: 7528448 	Address: 0x453c10
129 | 	FPS[7]: 7.50
130 | 	Length: 7528448 	Bytesused: 7528448 	Address: 0x453be0
131 | 	FPS[8]: 7.50
132 | 	Length: 7528448 	Bytesused: 7528448 	Address: 0x453bf0
133 | 	FPS[9]: 0.30
134 | 	------- Avg FPS: 7.51 --------
135 | 	
136 | 	TEST 1 - ( 2048 x 1536 )
137 | 	---- cap parameters -----
138 | 	width: 2048
139 | 	height: 1536
140 | 	v4l2 buffers: 4
141 | 	exposure: -999
142 | 	hflip: -1
143 | 	sensor_vflip: -1
144 | 	Mode: V4L2_MODE_VIDEO
145 | 	Driver: "sunxi-vfe"
146 | 	Card: "sunxi-vfe"
147 | 	Bus: "sunxi_vfe vfe.12"
148 | 	Version: 1.0
149 | 	Capabilities: 05000001
150 | 	Input: 0
151 | 	V4L2 pixel formats:
152 | 	0: [0x50323234] '422P' (planar YUV 422)
153 | 	1: [0x32315559] 'YU12' (planar YUV 420)
154 | 	2: [0x32315659] 'YV12' (planar YVU 420)
155 | 	3: [0x3631564E] 'NV16' (planar YUV 422 UV combined)
156 | 	4: [0x3231564E] 'NV12' (planar YUV 420 UV combined)
157 | 	5: [0x3136564E] 'NV61' (planar YUV 422 VU combined)
158 | 	6: [0x3132564E] 'NV21' (planar YUV 420 VU combined)
159 | 	7: [0x32314D48] 'HM12' (MB YUV420)
160 | 	8: [0x56595559] 'YUYV' (YUV422 YUYV)
161 | 	9: [0x55595659] 'YVYU' (YUV422 YVYU)
162 | 	10: [0x59565955] 'UYVY' (YUV422 UYVY)
163 | 	11: [0x59555956] 'VYUY' (YUV422 VYUY)
164 | 	12: [0x31384142] 'BA81' (RAW Bayer BGGR 8bit)
165 | 	13: [0x47524247] 'GBRG' (RAW Bayer GBRG 8bit)
166 | 	14: [0x47425247] 'GRBG' (RAW Bayer GRBG 8bit)
167 | 	15: [0x47425247] 'GRBG' (RAW Bayer RGGB 8bit)
168 | 	16: [0x30314742] 'BG10' (RAW Bayer BGGR 10bit)
169 | 	17: [0x30314247] 'GB10' (RAW Bayer GBRG 10bit)
170 | 	18: [0x30314142] 'BA10' (RAW Bayer GRBG 10bit)
171 | 	19: [0x30314142] 'BA10' (RAW Bayer RGGB 10bit)
172 | 	20: [0x32314742] 'BG12' (RAW Bayer BGGR 12bit)
173 | 	21: [0x32314247] 'GB12' (RAW Bayer GBRG 12bit)
174 | 	22: [0x32314142] 'BA12' (RAW Bayer GRBG 12bit)
175 | 	23: [0x32314142] 'BA12' (RAW Bayer RGGB 12bit)
176 | 	
177 | 	Sensor size: 2048x1536 pixels
178 | 	Pixel Format: V4L2_PIX_FMT_YUV420
179 | 	Frame #10 will be saved!
180 | 	Length: 4718592 	Bytesused: 4718592 	Address: 0x453be0
181 | 	FPS[0]: 1.12
182 | 	Length: 4718592 	Bytesused: 4718592 	Address: 0x453bf0
183 | 	FPS[1]: 7.51
184 | 	Length: 4718592 	Bytesused: 4718592 	Address: 0x453c00
185 | 	FPS[2]: 7.51
186 | 	Length: 4718592 	Bytesused: 4718592 	Address: 0x453c10
187 | 	FPS[3]: 7.50
188 | 	Length: 4718592 	Bytesused: 4718592 	Address: 0x453be0
189 | 	FPS[4]: 7.50
190 | 	Length: 4718592 	Bytesused: 4718592 	Address: 0x453bf0
191 | 	FPS[5]: 7.51
192 | 	Length: 4718592 	Bytesused: 4718592 	Address: 0x453c00
193 | 	FPS[6]: 7.50
194 | 	Length: 4718592 	Bytesused: 4718592 	Address: 0x453c10
195 | 	FPS[7]: 7.50
196 | 	Length: 4718592 	Bytesused: 4718592 	Address: 0x453be0
197 | 	FPS[8]: 7.50
198 | 	Length: 4718592 	Bytesused: 4718592 	Address: 0x453bf0
199 | 	FPS[9]: 0.46
200 | 	------- Avg FPS: 7.51 --------
201 | 	
202 | 	TEST 2 - ( 1920 x 1080 )
203 | 	---- cap parameters -----
204 | 	width: 1920
205 | 	height: 1080
206 | 	v4l2 buffers: 4
207 | 	exposure: -999
208 | 	hflip: -1
209 | 	sensor_vflip: -1
210 | 	Mode: V4L2_MODE_VIDEO
211 | 	Driver: "sunxi-vfe"
212 | 	Card: "sunxi-vfe"
213 | 	Bus: "sunxi_vfe vfe.12"
214 | 	Version: 1.0
215 | 	Capabilities: 05000001
216 | 	Input: 0
217 | 	V4L2 pixel formats:
218 | 	0: [0x50323234] '422P' (planar YUV 422)
219 | 	1: [0x32315559] 'YU12' (planar YUV 420)
220 | 	2: [0x32315659] 'YV12' (planar YVU 420)
221 | 	3: [0x3631564E] 'NV16' (planar YUV 422 UV combined)
222 | 	4: [0x3231564E] 'NV12' (planar YUV 420 UV combined)
223 | 	5: [0x3136564E] 'NV61' (planar YUV 422 VU combined)
224 | 	6: [0x3132564E] 'NV21' (planar YUV 420 VU combined)
225 | 	7: [0x32314D48] 'HM12' (MB YUV420)
226 | 	8: [0x56595559] 'YUYV' (YUV422 YUYV)
227 | 	9: [0x55595659] 'YVYU' (YUV422 YVYU)
228 | 	10: [0x59565955] 'UYVY' (YUV422 UYVY)
229 | 	11: [0x59555956] 'VYUY' (YUV422 VYUY)
230 | 	12: [0x31384142] 'BA81' (RAW Bayer BGGR 8bit)
231 | 	13: [0x47524247] 'GBRG' (RAW Bayer GBRG 8bit)
232 | 	14: [0x47425247] 'GRBG' (RAW Bayer GRBG 8bit)
233 | 	15: [0x47425247] 'GRBG' (RAW Bayer RGGB 8bit)
234 | 	16: [0x30314742] 'BG10' (RAW Bayer BGGR 10bit)
235 | 	17: [0x30314247] 'GB10' (RAW Bayer GBRG 10bit)
236 | 	18: [0x30314142] 'BA10' (RAW Bayer GRBG 10bit)
237 | 	19: [0x30314142] 'BA10' (RAW Bayer RGGB 10bit)
238 | 	20: [0x32314742] 'BG12' (RAW Bayer BGGR 12bit)
239 | 	21: [0x32314247] 'GB12' (RAW Bayer GBRG 12bit)
240 | 	22: [0x32314142] 'BA12' (RAW Bayer GRBG 12bit)
241 | 	23: [0x32314142] 'BA12' (RAW Bayer RGGB 12bit)
242 | 	
243 | 	Sensor size: 1920x1080 pixels
244 | 	Pixel Format: V4L2_PIX_FMT_YUV420
245 | 	Frame #10 will be saved!
246 | 	Length: 3112960 	Bytesused: 3112960 	Address: 0x453be0
247 | 	FPS[0]: 4.76
248 | 	Length: 3112960 	Bytesused: 3112960 	Address: 0x453bf0
249 | 	FPS[1]: 12.52
250 | 	Length: 3112960 	Bytesused: 3112960 	Address: 0x453c00
251 | 	FPS[2]: 12.50
252 | 	Length: 3112960 	Bytesused: 3112960 	Address: 0x453c10
253 | 	FPS[3]: 12.50
254 | 	Length: 3112960 	Bytesused: 3112960 	Address: 0x453be0
255 | 	FPS[4]: 12.49
256 | 	Length: 3112960 	Bytesused: 3112960 	Address: 0x453bf0
257 | 	FPS[5]: 12.51
258 | 	Length: 3112960 	Bytesused: 3112960 	Address: 0x453c00
259 | 	FPS[6]: 12.50
260 | 	Length: 3112960 	Bytesused: 3112960 	Address: 0x453c10
261 | 	FPS[7]: 12.50
262 | 	Length: 3112960 	Bytesused: 3112960 	Address: 0x453be0
263 | 	FPS[8]: 12.50
264 | 	Length: 3112960 	Bytesused: 3112960 	Address: 0x453bf0
265 | 	FPS[9]: 0.71
266 | 	------- Avg FPS: 12.50 --------
267 | 	
268 | 	TEST 3 - ( 1600 x 1200 )
269 | 	---- cap parameters -----
270 | 	width: 1600
271 | 	height: 1200
272 | 	v4l2 buffers: 4
273 | 	exposure: -999
274 | 	hflip: -1
275 | 	sensor_vflip: -1
276 | 	Mode: V4L2_MODE_VIDEO
277 | 	Driver: "sunxi-vfe"
278 | 	Card: "sunxi-vfe"
279 | 	Bus: "sunxi_vfe vfe.12"
280 | 	Version: 1.0
281 | 	Capabilities: 05000001
282 | 	Input: 0
283 | 	V4L2 pixel formats:
284 | 	0: [0x50323234] '422P' (planar YUV 422)
285 | 	1: [0x32315559] 'YU12' (planar YUV 420)
286 | 	2: [0x32315659] 'YV12' (planar YVU 420)
287 | 	3: [0x3631564E] 'NV16' (planar YUV 422 UV combined)
288 | 	4: [0x3231564E] 'NV12' (planar YUV 420 UV combined)
289 | 	5: [0x3136564E] 'NV61' (planar YUV 422 VU combined)
290 | 	6: [0x3132564E] 'NV21' (planar YUV 420 VU combined)
291 | 	7: [0x32314D48] 'HM12' (MB YUV420)
292 | 	8: [0x56595559] 'YUYV' (YUV422 YUYV)
293 | 	9: [0x55595659] 'YVYU' (YUV422 YVYU)
294 | 	10: [0x59565955] 'UYVY' (YUV422 UYVY)
295 | 	11: [0x59555956] 'VYUY' (YUV422 VYUY)
296 | 	12: [0x31384142] 'BA81' (RAW Bayer BGGR 8bit)
297 | 	13: [0x47524247] 'GBRG' (RAW Bayer GBRG 8bit)
298 | 	14: [0x47425247] 'GRBG' (RAW Bayer GRBG 8bit)
299 | 	15: [0x47425247] 'GRBG' (RAW Bayer RGGB 8bit)
300 | 	16: [0x30314742] 'BG10' (RAW Bayer BGGR 10bit)
301 | 	17: [0x30314247] 'GB10' (RAW Bayer GBRG 10bit)
302 | 	18: [0x30314142] 'BA10' (RAW Bayer GRBG 10bit)
303 | 	19: [0x30314142] 'BA10' (RAW Bayer RGGB 10bit)
304 | 	20: [0x32314742] 'BG12' (RAW Bayer BGGR 12bit)
305 | 	21: [0x32314247] 'GB12' (RAW Bayer GBRG 12bit)
306 | 	22: [0x32314142] 'BA12' (RAW Bayer GRBG 12bit)
307 | 	23: [0x32314142] 'BA12' (RAW Bayer RGGB 12bit)
308 | 	
309 | 	Sensor size: 1600x1200 pixels
310 | 	Pixel Format: V4L2_PIX_FMT_YUV420
311 | 	Frame #10 will be saved!
312 | 	Length: 2883584 	Bytesused: 2883584 	Address: 0x453be0
313 | 	FPS[0]: 0.96
314 | 	Length: 2883584 	Bytesused: 2883584 	Address: 0x453bf0
315 | 	FPS[1]: 7.51
316 | 	Length: 2883584 	Bytesused: 2883584 	Address: 0x453c00
317 | 	FPS[2]: 7.50
318 | 	Length: 2883584 	Bytesused: 2883584 	Address: 0x453c10
319 | 	FPS[3]: 7.51
320 | 	Length: 2883584 	Bytesused: 2883584 	Address: 0x453be0
321 | 	FPS[4]: 7.50
322 | 	Length: 2883584 	Bytesused: 2883584 	Address: 0x453bf0
323 | 	FPS[5]: 7.50
324 | 	Length: 2883584 	Bytesused: 2883584 	Address: 0x453c00
325 | 	FPS[6]: 7.50
326 | 	Length: 2883584 	Bytesused: 2883584 	Address: 0x453c10
327 | 	FPS[7]: 7.51
328 | 	Length: 2883584 	Bytesused: 2883584 	Address: 0x453be0
329 | 	FPS[8]: 7.51
330 | 	Length: 2883584 	Bytesused: 2883584 	Address: 0x453bf0
331 | 	FPS[9]: 0.73
332 | 	------- Avg FPS: 7.51 --------
333 | 	
334 | 	TEST 4 - ( 1280 x 960 )
335 | 	---- cap parameters -----
336 | 	width: 1280
337 | 	height: 960
338 | 	v4l2 buffers: 4
339 | 	exposure: -999
340 | 	hflip: -1
341 | 	sensor_vflip: -1
342 | 	Mode: V4L2_MODE_VIDEO
343 | 	Driver: "sunxi-vfe"
344 | 	Card: "sunxi-vfe"
345 | 	Bus: "sunxi_vfe vfe.12"
346 | 	Version: 1.0
347 | 	Capabilities: 05000001
348 | 	Input: 0
349 | 	V4L2 pixel formats:
350 | 	0: [0x50323234] '422P' (planar YUV 422)
351 | 	1: [0x32315559] 'YU12' (planar YUV 420)
352 | 	2: [0x32315659] 'YV12' (planar YVU 420)
353 | 	3: [0x3631564E] 'NV16' (planar YUV 422 UV combined)
354 | 	4: [0x3231564E] 'NV12' (planar YUV 420 UV combined)
355 | 	5: [0x3136564E] 'NV61' (planar YUV 422 VU combined)
356 | 	6: [0x3132564E] 'NV21' (planar YUV 420 VU combined)
357 | 	7: [0x32314D48] 'HM12' (MB YUV420)
358 | 	8: [0x56595559] 'YUYV' (YUV422 YUYV)
359 | 	9: [0x55595659] 'YVYU' (YUV422 YVYU)
360 | 	10: [0x59565955] 'UYVY' (YUV422 UYVY)
361 | 	11: [0x59555956] 'VYUY' (YUV422 VYUY)
362 | 	12: [0x31384142] 'BA81' (RAW Bayer BGGR 8bit)
363 | 	13: [0x47524247] 'GBRG' (RAW Bayer GBRG 8bit)
364 | 	14: [0x47425247] 'GRBG' (RAW Bayer GRBG 8bit)
365 | 	15: [0x47425247] 'GRBG' (RAW Bayer RGGB 8bit)
366 | 	16: [0x30314742] 'BG10' (RAW Bayer BGGR 10bit)
367 | 	17: [0x30314247] 'GB10' (RAW Bayer GBRG 10bit)
368 | 	18: [0x30314142] 'BA10' (RAW Bayer GRBG 10bit)
369 | 	19: [0x30314142] 'BA10' (RAW Bayer RGGB 10bit)
370 | 	20: [0x32314742] 'BG12' (RAW Bayer BGGR 12bit)
371 | 	21: [0x32314247] 'GB12' (RAW Bayer GBRG 12bit)
372 | 	22: [0x32314142] 'BA12' (RAW Bayer GRBG 12bit)
373 | 	23: [0x32314142] 'BA12' (RAW Bayer RGGB 12bit)
374 | 	
375 | 	Sensor size: 1280x960 pixels
376 | 	Pixel Format: V4L2_PIX_FMT_YUV420
377 | 	Frame #10 will be saved!
378 | 	Length: 1843200 	Bytesused: 1843200 	Address: 0x453be0
379 | 	FPS[0]: 6.77
380 | 	Length: 1843200 	Bytesused: 1843200 	Address: 0x453bf0
381 | 	FPS[1]: 15.03
382 | 	Length: 1843200 	Bytesused: 1843200 	Address: 0x453c00
383 | 	FPS[2]: 15.01
384 | 	Length: 1843200 	Bytesused: 1843200 	Address: 0x453c10
385 | 	FPS[3]: 15.02
386 | 	Length: 1843200 	Bytesused: 1843200 	Address: 0x453be0
387 | 	FPS[4]: 15.01
388 | 	Length: 1843200 	Bytesused: 1843200 	Address: 0x453bf0
389 | 	FPS[5]: 15.01
390 | 	Length: 1843200 	Bytesused: 1843200 	Address: 0x453c00
391 | 	FPS[6]: 15.01
392 | 	Length: 1843200 	Bytesused: 1843200 	Address: 0x453c10
393 | 	FPS[7]: 15.01
394 | 	Length: 1843200 	Bytesused: 1843200 	Address: 0x453be0
395 | 	FPS[8]: 15.01
396 | 	Length: 1843200 	Bytesused: 1843200 	Address: 0x453bf0
397 | 	FPS[9]: 1.15
398 | 	------- Avg FPS: 15.01 --------
399 | 	
400 | 	TEST 5 - ( 1280 x 720 )
401 | 	---- cap parameters -----
402 | 	width: 1280
403 | 	height: 720
404 | 	v4l2 buffers: 4
405 | 	exposure: -999
406 | 	hflip: -1
407 | 	sensor_vflip: -1
408 | 	Mode: V4L2_MODE_VIDEO
409 | 	Driver: "sunxi-vfe"
410 | 	Card: "sunxi-vfe"
411 | 	Bus: "sunxi_vfe vfe.12"
412 | 	Version: 1.0
413 | 	Capabilities: 05000001
414 | 	Input: 0
415 | 	V4L2 pixel formats:
416 | 	0: [0x50323234] '422P' (planar YUV 422)
417 | 	1: [0x32315559] 'YU12' (planar YUV 420)
418 | 	2: [0x32315659] 'YV12' (planar YVU 420)
419 | 	3: [0x3631564E] 'NV16' (planar YUV 422 UV combined)
420 | 	4: [0x3231564E] 'NV12' (planar YUV 420 UV combined)
421 | 	5: [0x3136564E] 'NV61' (planar YUV 422 VU combined)
422 | 	6: [0x3132564E] 'NV21' (planar YUV 420 VU combined)
423 | 	7: [0x32314D48] 'HM12' (MB YUV420)
424 | 	8: [0x56595559] 'YUYV' (YUV422 YUYV)
425 | 	9: [0x55595659] 'YVYU' (YUV422 YVYU)
426 | 	10: [0x59565955] 'UYVY' (YUV422 UYVY)
427 | 	11: [0x59555956] 'VYUY' (YUV422 VYUY)
428 | 	12: [0x31384142] 'BA81' (RAW Bayer BGGR 8bit)
429 | 	13: [0x47524247] 'GBRG' (RAW Bayer GBRG 8bit)
430 | 	14: [0x47425247] 'GRBG' (RAW Bayer GRBG 8bit)
431 | 	15: [0x47425247] 'GRBG' (RAW Bayer RGGB 8bit)
432 | 	16: [0x30314742] 'BG10' (RAW Bayer BGGR 10bit)
433 | 	17: [0x30314247] 'GB10' (RAW Bayer GBRG 10bit)
434 | 	18: [0x30314142] 'BA10' (RAW Bayer GRBG 10bit)
435 | 	19: [0x30314142] 'BA10' (RAW Bayer RGGB 10bit)
436 | 	20: [0x32314742] 'BG12' (RAW Bayer BGGR 12bit)
437 | 	21: [0x32314247] 'GB12' (RAW Bayer GBRG 12bit)
438 | 	22: [0x32314142] 'BA12' (RAW Bayer GRBG 12bit)
439 | 	23: [0x32314142] 'BA12' (RAW Bayer RGGB 12bit)
440 | 	
441 | 	Sensor size: 1280x720 pixels
442 | 	Pixel Format: V4L2_PIX_FMT_YUV420
443 | 	Frame #10 will be saved!
444 | 	Length: 1384448 	Bytesused: 1384448 	Address: 0x453be0
445 | 	FPS[0]: 2.74
446 | 	Length: 1384448 	Bytesused: 1384448 	Address: 0x453bf0
447 | 	FPS[1]: 32.99
448 | 	Length: 1384448 	Bytesused: 1384448 	Address: 0x453c00
449 | 	FPS[2]: 32.87
450 | 	Length: 1384448 	Bytesused: 1384448 	Address: 0x453c10
451 | 	FPS[3]: 32.87
452 | 	Length: 1384448 	Bytesused: 1384448 	Address: 0x453be0
453 | 	FPS[4]: 32.87
454 | 	Length: 1384448 	Bytesused: 1384448 	Address: 0x453bf0
455 | 	FPS[5]: 32.86
456 | 	Length: 1384448 	Bytesused: 1384448 	Address: 0x453c00
457 | 	FPS[6]: 32.87
458 | 	Length: 1384448 	Bytesused: 1384448 	Address: 0x453c10
459 | 	FPS[7]: 32.86
460 | 	Length: 1384448 	Bytesused: 1384448 	Address: 0x453be0
461 | 	FPS[8]: 32.87
462 | 	Length: 1384448 	Bytesused: 1384448 	Address: 0x453bf0
463 | 	FPS[9]: 1.58
464 | 	------- Avg FPS: 32.88 --------
465 | 	
466 | 	TEST 6 - ( 1024 x 768 )
467 | 	---- cap parameters -----
468 | 	width: 1024
469 | 	height: 768
470 | 	v4l2 buffers: 4
471 | 	exposure: -999
472 | 	hflip: -1
473 | 	sensor_vflip: -1
474 | 	Mode: V4L2_MODE_VIDEO
475 | 	Driver: "sunxi-vfe"
476 | 	Card: "sunxi-vfe"
477 | 	Bus: "sunxi_vfe vfe.12"
478 | 	Version: 1.0
479 | 	Capabilities: 05000001
480 | 	Input: 0
481 | 	V4L2 pixel formats:
482 | 	0: [0x50323234] '422P' (planar YUV 422)
483 | 	1: [0x32315559] 'YU12' (planar YUV 420)
484 | 	2: [0x32315659] 'YV12' (planar YVU 420)
485 | 	3: [0x3631564E] 'NV16' (planar YUV 422 UV combined)
486 | 	4: [0x3231564E] 'NV12' (planar YUV 420 UV combined)
487 | 	5: [0x3136564E] 'NV61' (planar YUV 422 VU combined)
488 | 	6: [0x3132564E] 'NV21' (planar YUV 420 VU combined)
489 | 	7: [0x32314D48] 'HM12' (MB YUV420)
490 | 	8: [0x56595559] 'YUYV' (YUV422 YUYV)
491 | 	9: [0x55595659] 'YVYU' (YUV422 YVYU)
492 | 	10: [0x59565955] 'UYVY' (YUV422 UYVY)
493 | 	11: [0x59555956] 'VYUY' (YUV422 VYUY)
494 | 	12: [0x31384142] 'BA81' (RAW Bayer BGGR 8bit)
495 | 	13: [0x47524247] 'GBRG' (RAW Bayer GBRG 8bit)
496 | 	14: [0x47425247] 'GRBG' (RAW Bayer GRBG 8bit)
497 | 	15: [0x47425247] 'GRBG' (RAW Bayer RGGB 8bit)
498 | 	16: [0x30314742] 'BG10' (RAW Bayer BGGR 10bit)
499 | 	17: [0x30314247] 'GB10' (RAW Bayer GBRG 10bit)
500 | 	18: [0x30314142] 'BA10' (RAW Bayer GRBG 10bit)
501 | 	19: [0x30314142] 'BA10' (RAW Bayer RGGB 10bit)
502 | 	20: [0x32314742] 'BG12' (RAW Bayer BGGR 12bit)
503 | 	21: [0x32314247] 'GB12' (RAW Bayer GBRG 12bit)
504 | 	22: [0x32314142] 'BA12' (RAW Bayer GRBG 12bit)
505 | 	23: [0x32314142] 'BA12' (RAW Bayer RGGB 12bit)
506 | 	
507 | 	Sensor size: 1024x768 pixels
508 | 	Pixel Format: V4L2_PIX_FMT_YUV420
509 | 	Frame #10 will be saved!
510 | 	Length: 1179648 	Bytesused: 1179648 	Address: 0x453be0
511 | 	FPS[0]: 1.25
512 | 	Length: 1179648 	Bytesused: 1179648 	Address: 0x453bf0
513 | 	FPS[1]: 9.40
514 | 	Length: 1179648 	Bytesused: 1179648 	Address: 0x453c00
515 | 	FPS[2]: 9.38
516 | 	Length: 1179648 	Bytesused: 1179648 	Address: 0x453c10
517 | 	FPS[3]: 9.38
518 | 	Length: 1179648 	Bytesused: 1179648 	Address: 0x453be0
519 | 	FPS[4]: 9.38
520 | 	Length: 1179648 	Bytesused: 1179648 	Address: 0x453bf0
521 | 	FPS[5]: 9.38
522 | 	Length: 1179648 	Bytesused: 1179648 	Address: 0x453c00
523 | 	FPS[6]: 9.38
524 | 	Length: 1179648 	Bytesused: 1179648 	Address: 0x453c10
525 | 	FPS[7]: 9.38
526 | 	Length: 1179648 	Bytesused: 1179648 	Address: 0x453be0
527 | 	FPS[8]: 9.39
528 | 	Length: 1179648 	Bytesused: 1179648 	Address: 0x453bf0
529 | 	FPS[9]: 1.63
530 | 	------- Avg FPS: 9.38 --------
531 | 	
532 | 	TEST 7 - ( 800 x 600 )
533 | 	---- cap parameters -----
534 | 	width: 800
535 | 	height: 600
536 | 	v4l2 buffers: 4
537 | 	exposure: -999
538 | 	hflip: -1
539 | 	sensor_vflip: -1
540 | 	Mode: V4L2_MODE_VIDEO
541 | 	Driver: "sunxi-vfe"
542 | 	Card: "sunxi-vfe"
543 | 	Bus: "sunxi_vfe vfe.12"
544 | 	Version: 1.0
545 | 	Capabilities: 05000001
546 | 	Input: 0
547 | 	V4L2 pixel formats:
548 | 	0: [0x50323234] '422P' (planar YUV 422)
549 | 	1: [0x32315559] 'YU12' (planar YUV 420)
550 | 	2: [0x32315659] 'YV12' (planar YVU 420)
551 | 	3: [0x3631564E] 'NV16' (planar YUV 422 UV combined)
552 | 	4: [0x3231564E] 'NV12' (planar YUV 420 UV combined)
553 | 	5: [0x3136564E] 'NV61' (planar YUV 422 VU combined)
554 | 	6: [0x3132564E] 'NV21' (planar YUV 420 VU combined)
555 | 	7: [0x32314D48] 'HM12' (MB YUV420)
556 | 	8: [0x56595559] 'YUYV' (YUV422 YUYV)
557 | 	9: [0x55595659] 'YVYU' (YUV422 YVYU)
558 | 	10: [0x59565955] 'UYVY' (YUV422 UYVY)
559 | 	11: [0x59555956] 'VYUY' (YUV422 VYUY)
560 | 	12: [0x31384142] 'BA81' (RAW Bayer BGGR 8bit)
561 | 	13: [0x47524247] 'GBRG' (RAW Bayer GBRG 8bit)
562 | 	14: [0x47425247] 'GRBG' (RAW Bayer GRBG 8bit)
563 | 	15: [0x47425247] 'GRBG' (RAW Bayer RGGB 8bit)
564 | 	16: [0x30314742] 'BG10' (RAW Bayer BGGR 10bit)
565 | 	17: [0x30314247] 'GB10' (RAW Bayer GBRG 10bit)
566 | 	18: [0x30314142] 'BA10' (RAW Bayer GRBG 10bit)
567 | 	19: [0x30314142] 'BA10' (RAW Bayer RGGB 10bit)
568 | 	20: [0x32314742] 'BG12' (RAW Bayer BGGR 12bit)
569 | 	21: [0x32314247] 'GB12' (RAW Bayer GBRG 12bit)
570 | 	22: [0x32314142] 'BA12' (RAW Bayer GRBG 12bit)
571 | 	23: [0x32314142] 'BA12' (RAW Bayer RGGB 12bit)
572 | 	
573 | 	Sensor size: 800x600 pixels
574 | 	Pixel Format: V4L2_PIX_FMT_YUV420
575 | 	Frame #10 will be saved!
576 | 	Length: 720896 	Bytesused: 720896 	Address: 0x453be0
577 | 	FPS[0]: 2.16
578 | 	Length: 720896 	Bytesused: 720896 	Address: 0x453bf0
579 | 	FPS[1]: 22.57
580 | 	Length: 720896 	Bytesused: 720896 	Address: 0x453c00
581 | 	FPS[2]: 22.52
582 | 	Length: 720896 	Bytesused: 720896 	Address: 0x453c10
583 | 	FPS[3]: 22.52
584 | 	Length: 720896 	Bytesused: 720896 	Address: 0x453be0
585 | 	FPS[4]: 22.52
586 | 	Length: 720896 	Bytesused: 720896 	Address: 0x453bf0
587 | 	FPS[5]: 22.52
588 | 	Length: 720896 	Bytesused: 720896 	Address: 0x453c00
589 | 	FPS[6]: 22.52
590 | 	Length: 720896 	Bytesused: 720896 	Address: 0x453c10
591 | 	FPS[7]: 22.50
592 | 	Length: 720896 	Bytesused: 720896 	Address: 0x453be0
593 | 	FPS[8]: 22.53
594 | 	Length: 720896 	Bytesused: 720896 	Address: 0x453bf0
595 | 	FPS[9]: 2.79
596 | 	------- Avg FPS: 22.53 --------
597 | 	
598 | 	TEST 8 - ( 640 x 480 )
599 | 	---- cap parameters -----
600 | 	width: 640
601 | 	height: 480
602 | 	v4l2 buffers: 4
603 | 	exposure: -999
604 | 	hflip: -1
605 | 	sensor_vflip: -1
606 | 	Mode: V4L2_MODE_VIDEO
607 | 	Driver: "sunxi-vfe"
608 | 	Card: "sunxi-vfe"
609 | 	Bus: "sunxi_vfe vfe.12"
610 | 	Version: 1.0
611 | 	Capabilities: 05000001
612 | 	Input: 0
613 | 	V4L2 pixel formats:
614 | 	0: [0x50323234] '422P' (planar YUV 422)
615 | 	1: [0x32315559] 'YU12' (planar YUV 420)
616 | 	2: [0x32315659] 'YV12' (planar YVU 420)
617 | 	3: [0x3631564E] 'NV16' (planar YUV 422 UV combined)
618 | 	4: [0x3231564E] 'NV12' (planar YUV 420 UV combined)
619 | 	5: [0x3136564E] 'NV61' (planar YUV 422 VU combined)
620 | 	6: [0x3132564E] 'NV21' (planar YUV 420 VU combined)
621 | 	7: [0x32314D48] 'HM12' (MB YUV420)
622 | 	8: [0x56595559] 'YUYV' (YUV422 YUYV)
623 | 	9: [0x55595659] 'YVYU' (YUV422 YVYU)
624 | 	10: [0x59565955] 'UYVY' (YUV422 UYVY)
625 | 	11: [0x59555956] 'VYUY' (YUV422 VYUY)
626 | 	12: [0x31384142] 'BA81' (RAW Bayer BGGR 8bit)
627 | 	13: [0x47524247] 'GBRG' (RAW Bayer GBRG 8bit)
628 | 	14: [0x47425247] 'GRBG' (RAW Bayer GRBG 8bit)
629 | 	15: [0x47425247] 'GRBG' (RAW Bayer RGGB 8bit)
630 | 	16: [0x30314742] 'BG10' (RAW Bayer BGGR 10bit)
631 | 	17: [0x30314247] 'GB10' (RAW Bayer GBRG 10bit)
632 | 	18: [0x30314142] 'BA10' (RAW Bayer GRBG 10bit)
633 | 	19: [0x30314142] 'BA10' (RAW Bayer RGGB 10bit)
634 | 	20: [0x32314742] 'BG12' (RAW Bayer BGGR 12bit)
635 | 	21: [0x32314247] 'GB12' (RAW Bayer GBRG 12bit)
636 | 	22: [0x32314142] 'BA12' (RAW Bayer GRBG 12bit)
637 | 	23: [0x32314142] 'BA12' (RAW Bayer RGGB 12bit)
638 | 	
639 | 	Sensor size: 640x480 pixels
640 | 	Pixel Format: V4L2_PIX_FMT_YUV420
641 | 	Frame #10 will be saved!
642 | 	Length: 462848 	Bytesused: 462848 	Address: 0x453be0
643 | 	FPS[0]: 3.28
644 | 	Length: 462848 	Bytesused: 462848 	Address: 0x453bf0
645 | 	FPS[1]: 30.12
646 | 	Length: 462848 	Bytesused: 462848 	Address: 0x453c00
647 | 	FPS[2]: 30.03
648 | 	Length: 462848 	Bytesused: 462848 	Address: 0x453c10
649 | 	FPS[3]: 30.03
650 | 	Length: 462848 	Bytesused: 462848 	Address: 0x453be0
651 | 	FPS[4]: 30.01
652 | 	Length: 462848 	Bytesused: 462848 	Address: 0x453bf0
653 | 	FPS[5]: 30.02
654 | 	Length: 462848 	Bytesused: 462848 	Address: 0x453c00
655 | 	FPS[6]: 30.07
656 | 	Length: 462848 	Bytesused: 462848 	Address: 0x453c10
657 | 	FPS[7]: 30.07
658 | 	Length: 462848 	Bytesused: 462848 	Address: 0x453be0
659 | 	FPS[8]: 30.03
660 | 	Length: 462848 	Bytesused: 462848 	Address: 0x453bf0
661 | 	FPS[9]: 4.14
662 | 	------- Avg FPS: 30.05 --------
663 | 	
664 | 	TEST 9 - ( 320 x 240 )
665 | 	---- cap parameters -----
666 | 	width: 320
667 | 	height: 240
668 | 	v4l2 buffers: 4
669 | 	exposure: -999
670 | 	hflip: -1
671 | 	sensor_vflip: -1
672 | 	Mode: V4L2_MODE_VIDEO
673 | 	Driver: "sunxi-vfe"
674 | 	Card: "sunxi-vfe"
675 | 	Bus: "sunxi_vfe vfe.12"
676 | 	Version: 1.0
677 | 	Capabilities: 05000001
678 | 	Input: 0
679 | 	V4L2 pixel formats:
680 | 	0: [0x50323234] '422P' (planar YUV 422)
681 | 	1: [0x32315559] 'YU12' (planar YUV 420)
682 | 	2: [0x32315659] 'YV12' (planar YVU 420)
683 | 	3: [0x3631564E] 'NV16' (planar YUV 422 UV combined)
684 | 	4: [0x3231564E] 'NV12' (planar YUV 420 UV combined)
685 | 	5: [0x3136564E] 'NV61' (planar YUV 422 VU combined)
686 | 	6: [0x3132564E] 'NV21' (planar YUV 420 VU combined)
687 | 	7: [0x32314D48] 'HM12' (MB YUV420)
688 | 	8: [0x56595559] 'YUYV' (YUV422 YUYV)
689 | 	9: [0x55595659] 'YVYU' (YUV422 YVYU)
690 | 	10: [0x59565955] 'UYVY' (YUV422 UYVY)
691 | 	11: [0x59555956] 'VYUY' (YUV422 VYUY)
692 | 	12: [0x31384142] 'BA81' (RAW Bayer BGGR 8bit)
693 | 	13: [0x47524247] 'GBRG' (RAW Bayer GBRG 8bit)
694 | 	14: [0x47425247] 'GRBG' (RAW Bayer GRBG 8bit)
695 | 	15: [0x47425247] 'GRBG' (RAW Bayer RGGB 8bit)
696 | 	16: [0x30314742] 'BG10' (RAW Bayer BGGR 10bit)
697 | 	17: [0x30314247] 'GB10' (RAW Bayer GBRG 10bit)
698 | 	18: [0x30314142] 'BA10' (RAW Bayer GRBG 10bit)
699 | 	19: [0x30314142] 'BA10' (RAW Bayer RGGB 10bit)
700 | 	20: [0x32314742] 'BG12' (RAW Bayer BGGR 12bit)
701 | 	21: [0x32314247] 'GB12' (RAW Bayer GBRG 12bit)
702 | 	22: [0x32314142] 'BA12' (RAW Bayer GRBG 12bit)
703 | 	23: [0x32314142] 'BA12' (RAW Bayer RGGB 12bit)
704 | 	
705 | 	Sensor size: 320x240 pixels
706 | 	Pixel Format: V4L2_PIX_FMT_YUV420
707 | 	Frame #10 will be saved!
708 | 	Length: 118784 	Bytesused: 118784 	Address: 0x453be0
709 | 	FPS[0]: 3.20
710 | 	Length: 118784 	Bytesused: 118784 	Address: 0x453bf0
711 | 	FPS[1]: 30.15
712 | 	Length: 118784 	Bytesused: 118784 	Address: 0x453c00
713 | 	FPS[2]: 30.04
714 | 	Length: 118784 	Bytesused: 118784 	Address: 0x453c10
715 | 	FPS[3]: 30.02
716 | 	Length: 118784 	Bytesused: 118784 	Address: 0x453be0
717 | 	FPS[4]: 30.03
718 | 	Length: 118784 	Bytesused: 118784 	Address: 0x453bf0
719 | 	FPS[5]: 30.03
720 | 	Length: 118784 	Bytesused: 118784 	Address: 0x453c00
721 | 	FPS[6]: 30.03
722 | 	Length: 118784 	Bytesused: 118784 	Address: 0x453c10
723 | 	FPS[7]: 30.01
724 | 	Length: 118784 	Bytesused: 118784 	Address: 0x453be0
725 | 	FPS[8]: 30.04
726 | 	Length: 118784 	Bytesused: 118784 	Address: 0x453bf0
727 | 	FPS[9]: 9.92
728 | 	------- Avg FPS: 30.04 --------
729 | 	
730 | 	TEST 10 - ( 176 x 144 )
731 | 	---- cap parameters -----
732 | 	width: 176
733 | 	height: 144
734 | 	v4l2 buffers: 4
735 | 	exposure: -999
736 | 	hflip: -1
737 | 	sensor_vflip: -1
738 | 	Mode: V4L2_MODE_VIDEO
739 | 	Driver: "sunxi-vfe"
740 | 	Card: "sunxi-vfe"
741 | 	Bus: "sunxi_vfe vfe.12"
742 | 	Version: 1.0
743 | 	Capabilities: 05000001
744 | 	Input: 0
745 | 	V4L2 pixel formats:
746 | 	0: [0x50323234] '422P' (planar YUV 422)
747 | 	1: [0x32315559] 'YU12' (planar YUV 420)
748 | 	2: [0x32315659] 'YV12' (planar YVU 420)
749 | 	3: [0x3631564E] 'NV16' (planar YUV 422 UV combined)
750 | 	4: [0x3231564E] 'NV12' (planar YUV 420 UV combined)
751 | 	5: [0x3136564E] 'NV61' (planar YUV 422 VU combined)
752 | 	6: [0x3132564E] 'NV21' (planar YUV 420 VU combined)
753 | 	7: [0x32314D48] 'HM12' (MB YUV420)
754 | 	8: [0x56595559] 'YUYV' (YUV422 YUYV)
755 | 	9: [0x55595659] 'YVYU' (YUV422 YVYU)
756 | 	10: [0x59565955] 'UYVY' (YUV422 UYVY)
757 | 	11: [0x59555956] 'VYUY' (YUV422 VYUY)
758 | 	12: [0x31384142] 'BA81' (RAW Bayer BGGR 8bit)
759 | 	13: [0x47524247] 'GBRG' (RAW Bayer GBRG 8bit)
760 | 	14: [0x47425247] 'GRBG' (RAW Bayer GRBG 8bit)
761 | 	15: [0x47425247] 'GRBG' (RAW Bayer RGGB 8bit)
762 | 	16: [0x30314742] 'BG10' (RAW Bayer BGGR 10bit)
763 | 	17: [0x30314247] 'GB10' (RAW Bayer GBRG 10bit)
764 | 	18: [0x30314142] 'BA10' (RAW Bayer GRBG 10bit)
765 | 	19: [0x30314142] 'BA10' (RAW Bayer RGGB 10bit)
766 | 	20: [0x32314742] 'BG12' (RAW Bayer BGGR 12bit)
767 | 	21: [0x32314247] 'GB12' (RAW Bayer GBRG 12bit)
768 | 	22: [0x32314142] 'BA12' (RAW Bayer GRBG 12bit)
769 | 	23: [0x32314142] 'BA12' (RAW Bayer RGGB 12bit)
770 | 	
771 | 	Sensor size: 176x144 pixels
772 | 	Pixel Format: V4L2_PIX_FMT_YUV420
773 | 	Frame #10 will be saved!
774 | 	Length: 40960 	Bytesused: 40960 	Address: 0x453be0
775 | 	FPS[0]: 3.23
776 | 	Length: 40960 	Bytesused: 40960 	Address: 0x453bf0
777 | 	FPS[1]: 30.13
778 | 	Length: 40960 	Bytesused: 40960 	Address: 0x453c00
779 | 	FPS[2]: 30.04
780 | 	Length: 40960 	Bytesused: 40960 	Address: 0x453c10
781 | 	FPS[3]: 30.03
782 | 	Length: 40960 	Bytesused: 40960 	Address: 0x453be0
783 | 	FPS[4]: 30.03
784 | 	Length: 40960 	Bytesused: 40960 	Address: 0x453bf0
785 | 	FPS[5]: 30.03
786 | 	Length: 40960 	Bytesused: 40960 	Address: 0x453c00
787 | 	FPS[6]: 30.03
788 | 	Length: 40960 	Bytesused: 40960 	Address: 0x453c10
789 | 	FPS[7]: 30.03
790 | 	Length: 40960 	Bytesused: 40960 	Address: 0x453be0
791 | 	FPS[8]: 30.03
792 | 	Length: 40960 	Bytesused: 40960 	Address: 0x453bf0
793 | 	FPS[9]: 13.27
794 | 	------- Avg FPS: 30.04 --------
795 | 
796 | 


--------------------------------------------------------------------------------
/videodev2.h:
--------------------------------------------------------------------------------
   1 | /*
   2 |  *  Video for Linux Two header file
   3 |  *
   4 |  *  Copyright (C) 1999-2007 the contributors
   5 |  *
   6 |  *  This program is free software; you can redistribute it and/or modify
   7 |  *  it under the terms of the GNU General Public License as published by
   8 |  *  the Free Software Foundation; either version 2 of the License, or
   9 |  *  (at your option) any later version.
  10 |  *
  11 |  *  This program is distributed in the hope that it will be useful,
  12 |  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 |  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 |  *  GNU General Public License for more details.
  15 |  *
  16 |  *  Alternatively you can redistribute this file under the terms of the
  17 |  *  BSD license as stated below:
  18 |  *
  19 |  *  Redistribution and use in source and binary forms, with or without
  20 |  *  modification, are permitted provided that the following conditions
  21 |  *  are met:
  22 |  *  1. Redistributions of source code must retain the above copyright
  23 |  *     notice, this list of conditions and the following disclaimer.
  24 |  *  2. Redistributions in binary form must reproduce the above copyright
  25 |  *     notice, this list of conditions and the following disclaimer in
  26 |  *     the documentation and/or other materials provided with the
  27 |  *     distribution.
  28 |  *  3. The names of its contributors may not be used to endorse or promote
  29 |  *     products derived from this software without specific prior written
  30 |  *     permission.
  31 |  *
  32 |  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  33 |  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  34 |  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  35 |  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  36 |  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  37 |  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  38 |  *  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  39 |  *  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  40 |  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  41 |  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  42 |  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  43 |  *
  44 |  *	Header file for v4l or V4L2 drivers and applications
  45 |  * with public API.
  46 |  * All kernel-specific stuff were moved to media/v4l2-dev.h, so
  47 |  * no #if __KERNEL tests are allowed here
  48 |  *
  49 |  *	See http://linuxtv.org for more info
  50 |  *
  51 |  *	Author: Bill Dirks <bill@thedirks.org>
  52 |  *		Justin Schoeman
  53 |  *              Hans Verkuil <hverkuil@xs4all.nl>
  54 |  *		et al.
  55 |  */
  56 | #ifndef __LINUX_VIDEODEV2_H
  57 | #define __LINUX_VIDEODEV2_H
  58 | 
  59 | #ifdef __KERNEL__
  60 | #include <linux/time.h>     /* need struct timeval */
  61 | #include <linux/compiler.h>
  62 | #else
  63 | #include <sys/time.h>
  64 | #endif
  65 | //#include <linux/compiler.h>
  66 | #include <linux/ioctl.h>
  67 | #include <linux/types.h>
  68 | 
  69 | /*
  70 |  * Common stuff for both V4L1 and V4L2
  71 |  * Moved from videodev.h
  72 |  */
  73 | #define VIDEO_MAX_FRAME               32
  74 | #define VIDEO_MAX_PLANES               8
  75 | 
  76 | #ifndef __KERNEL__
  77 | 
  78 | /* These defines are V4L1 specific and should not be used with the V4L2 API!
  79 |    They will be removed from this header in the future. */
  80 | 
  81 | #define VID_TYPE_CAPTURE	1	/* Can capture */
  82 | #define VID_TYPE_TUNER		2	/* Can tune */
  83 | #define VID_TYPE_TELETEXT	4	/* Does teletext */
  84 | #define VID_TYPE_OVERLAY	8	/* Overlay onto frame buffer */
  85 | #define VID_TYPE_CHROMAKEY	16	/* Overlay by chromakey */
  86 | #define VID_TYPE_CLIPPING	32	/* Can clip */
  87 | #define VID_TYPE_FRAMERAM	64	/* Uses the frame buffer memory */
  88 | #define VID_TYPE_SCALES		128	/* Scalable */
  89 | #define VID_TYPE_MONOCHROME	256	/* Monochrome only */
  90 | #define VID_TYPE_SUBCAPTURE	512	/* Can capture subareas of the image */
  91 | #define VID_TYPE_MPEG_DECODER	1024	/* Can decode MPEG streams */
  92 | #define VID_TYPE_MPEG_ENCODER	2048	/* Can encode MPEG streams */
  93 | #define VID_TYPE_MJPEG_DECODER	4096	/* Can decode MJPEG streams */
  94 | #define VID_TYPE_MJPEG_ENCODER	8192	/* Can encode MJPEG streams */
  95 | #endif
  96 | 
  97 | /*
  98 |  *	M I S C E L L A N E O U S
  99 |  */
 100 | 
 101 | /*  Four-character-code (FOURCC) */
 102 | #define v4l2_fourcc(a, b, c, d)\
 103 | 	((__u32)(a) | ((__u32)(b) << 8) | ((__u32)(c) << 16) | ((__u32)(d) << 24))
 104 | 
 105 | /*
 106 |  *	E N U M S
 107 |  */
 108 | enum v4l2_field {
 109 | 	V4L2_FIELD_ANY           = 0, /* driver can choose from none,
 110 | 					 top, bottom, interlaced
 111 | 					 depending on whatever it thinks
 112 | 					 is approximate ... */
 113 | 	V4L2_FIELD_NONE          = 1, /* this device has no fields ... */
 114 | 	V4L2_FIELD_TOP           = 2, /* top field only */
 115 | 	V4L2_FIELD_BOTTOM        = 3, /* bottom field only */
 116 | 	V4L2_FIELD_INTERLACED    = 4, /* both fields interlaced */
 117 | 	V4L2_FIELD_SEQ_TB        = 5, /* both fields sequential into one
 118 | 					 buffer, top-bottom order */
 119 | 	V4L2_FIELD_SEQ_BT        = 6, /* same as above + bottom-top order */
 120 | 	V4L2_FIELD_ALTERNATE     = 7, /* both fields alternating into
 121 | 					 separate buffers */
 122 | 	V4L2_FIELD_INTERLACED_TB = 8, /* both fields interlaced, top field
 123 | 					 first and the top field is
 124 | 					 transmitted first */
 125 | 	V4L2_FIELD_INTERLACED_BT = 9, /* both fields interlaced, top field
 126 | 					 first and the bottom field is
 127 | 					 transmitted first */
 128 | };
 129 | #define V4L2_FIELD_HAS_TOP(field)	\
 130 | 	((field) == V4L2_FIELD_TOP 	||\
 131 | 	 (field) == V4L2_FIELD_INTERLACED ||\
 132 | 	 (field) == V4L2_FIELD_INTERLACED_TB ||\
 133 | 	 (field) == V4L2_FIELD_INTERLACED_BT ||\
 134 | 	 (field) == V4L2_FIELD_SEQ_TB	||\
 135 | 	 (field) == V4L2_FIELD_SEQ_BT)
 136 | #define V4L2_FIELD_HAS_BOTTOM(field)	\
 137 | 	((field) == V4L2_FIELD_BOTTOM 	||\
 138 | 	 (field) == V4L2_FIELD_INTERLACED ||\
 139 | 	 (field) == V4L2_FIELD_INTERLACED_TB ||\
 140 | 	 (field) == V4L2_FIELD_INTERLACED_BT ||\
 141 | 	 (field) == V4L2_FIELD_SEQ_TB	||\
 142 | 	 (field) == V4L2_FIELD_SEQ_BT)
 143 | #define V4L2_FIELD_HAS_BOTH(field)	\
 144 | 	((field) == V4L2_FIELD_INTERLACED ||\
 145 | 	 (field) == V4L2_FIELD_INTERLACED_TB ||\
 146 | 	 (field) == V4L2_FIELD_INTERLACED_BT ||\
 147 | 	 (field) == V4L2_FIELD_SEQ_TB ||\
 148 | 	 (field) == V4L2_FIELD_SEQ_BT)
 149 | 
 150 | enum v4l2_buf_type {
 151 | 	V4L2_BUF_TYPE_VIDEO_CAPTURE        = 1,
 152 | 	V4L2_BUF_TYPE_VIDEO_OUTPUT         = 2,
 153 | 	V4L2_BUF_TYPE_VIDEO_OVERLAY        = 3,
 154 | 	V4L2_BUF_TYPE_VBI_CAPTURE          = 4,
 155 | 	V4L2_BUF_TYPE_VBI_OUTPUT           = 5,
 156 | 	V4L2_BUF_TYPE_SLICED_VBI_CAPTURE   = 6,
 157 | 	V4L2_BUF_TYPE_SLICED_VBI_OUTPUT    = 7,
 158 | #if 1
 159 | 	/* Experimental */
 160 | 	V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8,
 161 | #endif
 162 | 	V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE = 9,
 163 | 	V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE  = 10,
 164 | 	V4L2_BUF_TYPE_PRIVATE              = 0x80,
 165 | };
 166 | 
 167 | #define V4L2_TYPE_IS_MULTIPLANAR(type)			\
 168 | 	((type) == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE	\
 169 | 	 || (type) == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
 170 | 
 171 | #define V4L2_TYPE_IS_OUTPUT(type)				\
 172 | 	((type) == V4L2_BUF_TYPE_VIDEO_OUTPUT			\
 173 | 	 || (type) == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE		\
 174 | 	 || (type) == V4L2_BUF_TYPE_VIDEO_OVERLAY		\
 175 | 	 || (type) == V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY	\
 176 | 	 || (type) == V4L2_BUF_TYPE_VBI_OUTPUT			\
 177 | 	 || (type) == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT)
 178 | 
 179 | enum v4l2_tuner_type {
 180 | 	V4L2_TUNER_RADIO	     = 1,
 181 | 	V4L2_TUNER_ANALOG_TV	     = 2,
 182 | 	V4L2_TUNER_DIGITAL_TV	     = 3,
 183 | };
 184 | 
 185 | enum v4l2_memory {
 186 | 	V4L2_MEMORY_MMAP             = 1,
 187 | 	V4L2_MEMORY_USERPTR          = 2,
 188 | 	V4L2_MEMORY_OVERLAY          = 3,
 189 | };
 190 | 
 191 | /* see also http://vektor.theorem.ca/graphics/ycbcr/ */
 192 | enum v4l2_colorspace {
 193 | 	/* ITU-R 601 -- broadcast NTSC/PAL */
 194 | 	V4L2_COLORSPACE_SMPTE170M     = 1,
 195 | 
 196 | 	/* 1125-Line (US) HDTV */
 197 | 	V4L2_COLORSPACE_SMPTE240M     = 2,
 198 | 
 199 | 	/* HD and modern captures. */
 200 | 	V4L2_COLORSPACE_REC709        = 3,
 201 | 
 202 | 	/* broken BT878 extents (601, luma range 16-253 instead of 16-235) */
 203 | 	V4L2_COLORSPACE_BT878         = 4,
 204 | 
 205 | 	/* These should be useful.  Assume 601 extents. */
 206 | 	V4L2_COLORSPACE_470_SYSTEM_M  = 5,
 207 | 	V4L2_COLORSPACE_470_SYSTEM_BG = 6,
 208 | 
 209 | 	/* I know there will be cameras that send this.  So, this is
 210 | 	 * unspecified chromaticities and full 0-255 on each of the
 211 | 	 * Y'CbCr components
 212 | 	 */
 213 | 	V4L2_COLORSPACE_JPEG          = 7,
 214 | 
 215 | 	/* For RGB colourspaces, this is probably a good start. */
 216 | 	V4L2_COLORSPACE_SRGB          = 8,
 217 | };
 218 | 
 219 | enum v4l2_priority {
 220 | 	V4L2_PRIORITY_UNSET       = 0,  /* not initialized */
 221 | 	V4L2_PRIORITY_BACKGROUND  = 1,
 222 | 	V4L2_PRIORITY_INTERACTIVE = 2,
 223 | 	V4L2_PRIORITY_RECORD      = 3,
 224 | 	V4L2_PRIORITY_DEFAULT     = V4L2_PRIORITY_INTERACTIVE,
 225 | };
 226 | 
 227 | struct v4l2_rect {
 228 | 	__s32   left;
 229 | 	__s32   top;
 230 | 	__s32   width;
 231 | 	__s32   height;
 232 | };
 233 | 
 234 | struct v4l2_fract {
 235 | 	__u32   numerator;
 236 | 	__u32   denominator;
 237 | };
 238 | 
 239 | /**
 240 |   * struct v4l2_capability - Describes V4L2 device caps returned by VIDIOC_QUERYCAP
 241 |   *
 242 |   * @driver:	   name of the driver module (e.g. "bttv")
 243 |   * @card:	   name of the card (e.g. "Hauppauge WinTV")
 244 |   * @bus_info:	   name of the bus (e.g. "PCI:" + pci_name(pci_dev) )
 245 |   * @version:	   KERNEL_VERSION
 246 |   * @capabilities: capabilities of the physical device as a whole
 247 |   * @device_caps:  capabilities accessed via this particular device (node)
 248 |   * @reserved:	   reserved fields for future extensions
 249 |   */
 250 | struct v4l2_capability {
 251 | 	__u8	driver[16];
 252 | 	__u8	card[32];
 253 | 	__u8	bus_info[32];
 254 | 	__u32   version;
 255 | 	__u32	capabilities;
 256 | 	__u32	device_caps;
 257 | 	__u32	reserved[3];
 258 | };
 259 | 
 260 | /* Values for 'capabilities' field */
 261 | #define V4L2_CAP_VIDEO_CAPTURE		0x00000001  /* Is a video capture device */
 262 | #define V4L2_CAP_VIDEO_OUTPUT		0x00000002  /* Is a video output device */
 263 | #define V4L2_CAP_VIDEO_OVERLAY		0x00000004  /* Can do video overlay */
 264 | #define V4L2_CAP_VBI_CAPTURE		0x00000010  /* Is a raw VBI capture device */
 265 | #define V4L2_CAP_VBI_OUTPUT		0x00000020  /* Is a raw VBI output device */
 266 | #define V4L2_CAP_SLICED_VBI_CAPTURE	0x00000040  /* Is a sliced VBI capture device */
 267 | #define V4L2_CAP_SLICED_VBI_OUTPUT	0x00000080  /* Is a sliced VBI output device */
 268 | #define V4L2_CAP_RDS_CAPTURE		0x00000100  /* RDS data capture */
 269 | #define V4L2_CAP_VIDEO_OUTPUT_OVERLAY	0x00000200  /* Can do video output overlay */
 270 | #define V4L2_CAP_HW_FREQ_SEEK		0x00000400  /* Can do hardware frequency seek  */
 271 | #define V4L2_CAP_RDS_OUTPUT		0x00000800  /* Is an RDS encoder */
 272 | 
 273 | /* Is a video capture device that supports multiplanar formats */
 274 | #define V4L2_CAP_VIDEO_CAPTURE_MPLANE	0x00001000
 275 | /* Is a video output device that supports multiplanar formats */
 276 | #define V4L2_CAP_VIDEO_OUTPUT_MPLANE	0x00002000
 277 | 
 278 | #define V4L2_CAP_TUNER			0x00010000  /* has a tuner */
 279 | #define V4L2_CAP_AUDIO			0x00020000  /* has audio support */
 280 | #define V4L2_CAP_RADIO			0x00040000  /* is a radio device */
 281 | #define V4L2_CAP_MODULATOR		0x00080000  /* has a modulator */
 282 | 
 283 | #define V4L2_CAP_READWRITE              0x01000000  /* read/write systemcalls */
 284 | #define V4L2_CAP_ASYNCIO                0x02000000  /* async I/O */
 285 | #define V4L2_CAP_STREAMING              0x04000000  /* streaming I/O ioctls */
 286 | 
 287 | #define V4L2_CAP_DEVICE_CAPS            0x80000000  /* sets device capabilities field */
 288 | 
 289 | /*
 290 |  *	V I D E O   I M A G E   F O R M A T
 291 |  */
 292 | /* Add windows coordinates struct by raymonxiu */
 293 | struct v4l2_win_coordinate {
 294 | 	__s32			x1;
 295 | 	__s32			y1;
 296 | 	__s32			x2;
 297 | 	__s32			y2;	
 298 | };
 299 | 
 300 | #define MAX_EXP_FRAMES     5
 301 | #define MAX_ISP_BUF_SIZE   0x2100
 302 | 
 303 | struct isp_hdr_setting_t {
 304 |   __s32 hdr_en;
 305 |   __s32 hdr_mode;
 306 |   __s32 frames_count;
 307 |   __s32 total_frames;
 308 |   __s32 values[MAX_EXP_FRAMES];
 309 | };
 310 | 
 311 | struct isp_exif_attribute {
 312 | 	struct v4l2_fract exposure_time;
 313 | 	struct v4l2_fract shutter_speed;
 314 | 	__u32 fnumber;
 315 | 	__u32 focal_length;
 316 | 	__s32 exposure_bias;
 317 | 	__u32 iso_speed;
 318 | 	__u32 flash_fire;
 319 | 	__u32 brightness;
 320 | 	__s32 reserved[16];
 321 | };
 322 | 
 323 | struct isp_stat_buf {
 324 | 	void *buf;
 325 | 	__u32 buf_size;
 326 | };
 327 | 
 328 |  
 329 | struct v4l2_pix_format {
 330 | 	__u32         		width;
 331 | 	__u32			height;
 332 | 	__u32			pixelformat;
 333 | 	enum v4l2_field  	field;
 334 | 	__u32            	bytesperline;	/* for padding, zero if unused */
 335 | 	__u32          		sizeimage;
 336 | 	enum v4l2_colorspace	colorspace;
 337 | 	__u32			priv;		/* private data, depends on pixelformat */
 338 | 	__u32			rot_angle;  /* add by raymonxiu */
 339 | 	struct v4l2_pix_format	 *subchannel;	/* add by raymonxiu */
 340 | };
 341 | 
 342 | /*      Pixel format         FOURCC                          depth  Description  */
 343 | 
 344 | /* RGB formats */
 345 | #define V4L2_PIX_FMT_RGB332  v4l2_fourcc('R', 'G', 'B', '1') /*  8  RGB-3-3-2     */
 346 | #define V4L2_PIX_FMT_RGB444  v4l2_fourcc('R', '4', '4', '4') /* 16  xxxxrrrr ggggbbbb */
 347 | #define V4L2_PIX_FMT_RGB555  v4l2_fourcc('R', 'G', 'B', 'O') /* 16  RGB-5-5-5     */
 348 | #define V4L2_PIX_FMT_RGB565  v4l2_fourcc('R', 'G', 'B', 'P') /* 16  RGB-5-6-5     */
 349 | #define V4L2_PIX_FMT_RGB555X v4l2_fourcc('R', 'G', 'B', 'Q') /* 16  RGB-5-5-5 BE  */
 350 | #define V4L2_PIX_FMT_RGB565X v4l2_fourcc('R', 'G', 'B', 'R') /* 16  RGB-5-6-5 BE  */
 351 | #define V4L2_PIX_FMT_BGR666  v4l2_fourcc('B', 'G', 'R', 'H') /* 18  BGR-6-6-6	  */
 352 | #define V4L2_PIX_FMT_BGR24   v4l2_fourcc('B', 'G', 'R', '3') /* 24  BGR-8-8-8     */
 353 | #define V4L2_PIX_FMT_RGB24   v4l2_fourcc('R', 'G', 'B', '3') /* 24  RGB-8-8-8     */
 354 | #define V4L2_PIX_FMT_BGR32   v4l2_fourcc('B', 'G', 'R', '4') /* 32  BGR-8-8-8-8   */
 355 | #define V4L2_PIX_FMT_RGB32   v4l2_fourcc('R', 'G', 'B', '4') /* 32  RGB-8-8-8-8   */
 356 | 
 357 | /* Grey formats */
 358 | #define V4L2_PIX_FMT_GREY    v4l2_fourcc('G', 'R', 'E', 'Y') /*  8  Greyscale     */
 359 | #define V4L2_PIX_FMT_Y4      v4l2_fourcc('Y', '0', '4', ' ') /*  4  Greyscale     */
 360 | #define V4L2_PIX_FMT_Y6      v4l2_fourcc('Y', '0', '6', ' ') /*  6  Greyscale     */
 361 | #define V4L2_PIX_FMT_Y10     v4l2_fourcc('Y', '1', '0', ' ') /* 10  Greyscale     */
 362 | #define V4L2_PIX_FMT_Y12     v4l2_fourcc('Y', '1', '2', ' ') /* 12  Greyscale     */
 363 | #define V4L2_PIX_FMT_Y16     v4l2_fourcc('Y', '1', '6', ' ') /* 16  Greyscale     */
 364 | 
 365 | /* Grey bit-packed formats */
 366 | #define V4L2_PIX_FMT_Y10BPACK    v4l2_fourcc('Y', '1', '0', 'B') /* 10  Greyscale bit-packed */
 367 | 
 368 | /* Palette formats */
 369 | #define V4L2_PIX_FMT_PAL8    v4l2_fourcc('P', 'A', 'L', '8') /*  8  8-bit palette */
 370 | 
 371 | /* Luminance+Chrominance formats */
 372 | #define V4L2_PIX_FMT_YVU410  v4l2_fourcc('Y', 'V', 'U', '9') /*  9  YVU 4:1:0     */
 373 | #define V4L2_PIX_FMT_YVU420  v4l2_fourcc('Y', 'V', '1', '2') /* 12  YVU 4:2:0     */
 374 | #define V4L2_PIX_FMT_YUYV    v4l2_fourcc('Y', 'U', 'Y', 'V') /* 16  YUV 4:2:2     */
 375 | #define V4L2_PIX_FMT_YYUV    v4l2_fourcc('Y', 'Y', 'U', 'V') /* 16  YUV 4:2:2     */
 376 | #define V4L2_PIX_FMT_YVYU    v4l2_fourcc('Y', 'V', 'Y', 'U') /* 16 YVU 4:2:2 */
 377 | #define V4L2_PIX_FMT_UYVY    v4l2_fourcc('U', 'Y', 'V', 'Y') /* 16  YUV 4:2:2     */
 378 | #define V4L2_PIX_FMT_VYUY    v4l2_fourcc('V', 'Y', 'U', 'Y') /* 16  YUV 4:2:2     */
 379 | #define V4L2_PIX_FMT_YUV422P v4l2_fourcc('4', '2', '2', 'P') /* 16  YVU422 planar */
 380 | #define V4L2_PIX_FMT_YUV411P v4l2_fourcc('4', '1', '1', 'P') /* 16  YVU411 planar */
 381 | #define V4L2_PIX_FMT_Y41P    v4l2_fourcc('Y', '4', '1', 'P') /* 12  YUV 4:1:1     */
 382 | #define V4L2_PIX_FMT_YUV444  v4l2_fourcc('Y', '4', '4', '4') /* 16  xxxxyyyy uuuuvvvv */
 383 | #define V4L2_PIX_FMT_YUV555  v4l2_fourcc('Y', 'U', 'V', 'O') /* 16  YUV-5-5-5     */
 384 | #define V4L2_PIX_FMT_YUV565  v4l2_fourcc('Y', 'U', 'V', 'P') /* 16  YUV-5-6-5     */
 385 | #define V4L2_PIX_FMT_YUV32   v4l2_fourcc('Y', 'U', 'V', '4') /* 32  YUV-8-8-8-8   */
 386 | #define V4L2_PIX_FMT_YUV410  v4l2_fourcc('Y', 'U', 'V', '9') /*  9  YUV 4:1:0     */
 387 | #define V4L2_PIX_FMT_YUV420  v4l2_fourcc('Y', 'U', '1', '2') /* 12  YUV 4:2:0     */
 388 | #define V4L2_PIX_FMT_HI240   v4l2_fourcc('H', 'I', '2', '4') /*  8  8-bit color   */
 389 | #define V4L2_PIX_FMT_HM12    v4l2_fourcc('H', 'M', '1', '2') /*  8  YUV 4:2:0 16x16 macroblocks */
 390 | #define V4L2_PIX_FMT_M420    v4l2_fourcc('M', '4', '2', '0') /* 12  YUV 4:2:0 2 lines y, 1 line uv interleaved */
 391 | 
 392 | /* two planes -- one Y, one Cr + Cb interleaved  */
 393 | #define V4L2_PIX_FMT_NV12    v4l2_fourcc('N', 'V', '1', '2') /* 12  Y/CbCr 4:2:0  */
 394 | #define V4L2_PIX_FMT_NV21    v4l2_fourcc('N', 'V', '2', '1') /* 12  Y/CrCb 4:2:0  */
 395 | #define V4L2_PIX_FMT_NV16    v4l2_fourcc('N', 'V', '1', '6') /* 16  Y/CbCr 4:2:2  */
 396 | #define V4L2_PIX_FMT_NV61    v4l2_fourcc('N', 'V', '6', '1') /* 16  Y/CrCb 4:2:2  */
 397 | #define V4L2_PIX_FMT_NV24    v4l2_fourcc('N', 'V', '2', '4') /* 24  Y/CbCr 4:4:4  */
 398 | #define V4L2_PIX_FMT_NV42    v4l2_fourcc('N', 'V', '4', '2') /* 24  Y/CrCb 4:4:4  */
 399 | 
 400 | /* two non contiguous planes - one Y, one Cr + Cb interleaved  */
 401 | #define V4L2_PIX_FMT_NV12M   v4l2_fourcc('N', 'M', '1', '2') /* 12  Y/CbCr 4:2:0  */
 402 | #define V4L2_PIX_FMT_NV12MT  v4l2_fourcc('T', 'M', '1', '2') /* 12  Y/CbCr 4:2:0 64x32 macroblocks */
 403 | 
 404 | /* three non contiguous planes - Y, Cb, Cr */
 405 | #define V4L2_PIX_FMT_YUV420M v4l2_fourcc('Y', 'M', '1', '2') /* 12  YUV420 planar */
 406 | 
 407 | /* Bayer formats - see http://www.siliconimaging.com/RGB%20Bayer.htm */
 408 | #define V4L2_PIX_FMT_SBGGR8  v4l2_fourcc('B', 'A', '8', '1') /*  8  BGBG.. GRGR.. */
 409 | #define V4L2_PIX_FMT_SGBRG8  v4l2_fourcc('G', 'B', 'R', 'G') /*  8  GBGB.. RGRG.. */
 410 | #define V4L2_PIX_FMT_SGRBG8  v4l2_fourcc('G', 'R', 'B', 'G') /*  8  GRGR.. BGBG.. */
 411 | #define V4L2_PIX_FMT_SRGGB8  v4l2_fourcc('R', 'G', 'G', 'B') /*  8  RGRG.. GBGB.. */
 412 | #define V4L2_PIX_FMT_SBGGR10 v4l2_fourcc('B', 'G', '1', '0') /* 10  BGBG.. GRGR.. */
 413 | #define V4L2_PIX_FMT_SGBRG10 v4l2_fourcc('G', 'B', '1', '0') /* 10  GBGB.. RGRG.. */
 414 | #define V4L2_PIX_FMT_SGRBG10 v4l2_fourcc('B', 'A', '1', '0') /* 10  GRGR.. BGBG.. */
 415 | #define V4L2_PIX_FMT_SRGGB10 v4l2_fourcc('R', 'G', '1', '0') /* 10  RGRG.. GBGB.. */
 416 | #define V4L2_PIX_FMT_SBGGR12 v4l2_fourcc('B', 'G', '1', '2') /* 12  BGBG.. GRGR.. */
 417 | #define V4L2_PIX_FMT_SGBRG12 v4l2_fourcc('G', 'B', '1', '2') /* 12  GBGB.. RGRG.. */
 418 | #define V4L2_PIX_FMT_SGRBG12 v4l2_fourcc('B', 'A', '1', '2') /* 12  GRGR.. BGBG.. */
 419 | #define V4L2_PIX_FMT_SRGGB12 v4l2_fourcc('R', 'G', '1', '2') /* 12  RGRG.. GBGB.. */
 420 | 	/* 10bit raw bayer DPCM compressed to 8 bits */
 421 | #define V4L2_PIX_FMT_SGRBG10DPCM8 v4l2_fourcc('B', 'D', '1', '0')
 422 | 	/*
 423 | 	 * 10bit raw bayer, expanded to 16 bits
 424 | 	 * xxxxrrrrrrrrrrxxxxgggggggggg xxxxggggggggggxxxxbbbbbbbbbb...
 425 | 	 */
 426 | #define V4L2_PIX_FMT_SBGGR16 v4l2_fourcc('B', 'Y', 'R', '2') /* 16  BGBG.. GRGR.. */
 427 | 
 428 | /* compressed formats */
 429 | #define V4L2_PIX_FMT_MJPEG    v4l2_fourcc('M', 'J', 'P', 'G') /* Motion-JPEG   */
 430 | #define V4L2_PIX_FMT_JPEG     v4l2_fourcc('J', 'P', 'E', 'G') /* JFIF JPEG     */
 431 | #define V4L2_PIX_FMT_DV       v4l2_fourcc('d', 'v', 's', 'd') /* 1394          */
 432 | #define V4L2_PIX_FMT_MPEG     v4l2_fourcc('M', 'P', 'E', 'G') /* MPEG-1/2/4 Multiplexed */
 433 | #define V4L2_PIX_FMT_H264     v4l2_fourcc('H', '2', '6', '4') /* H264 with start codes */
 434 | #define V4L2_PIX_FMT_H264_NO_SC v4l2_fourcc('A', 'V', 'C', '1') /* H264 without start codes */
 435 | #define V4L2_PIX_FMT_H263     v4l2_fourcc('H', '2', '6', '3') /* H263          */
 436 | #define V4L2_PIX_FMT_MPEG1    v4l2_fourcc('M', 'P', 'G', '1') /* MPEG-1 ES     */
 437 | #define V4L2_PIX_FMT_MPEG2    v4l2_fourcc('M', 'P', 'G', '2') /* MPEG-2 ES     */
 438 | #define V4L2_PIX_FMT_MPEG4    v4l2_fourcc('M', 'P', 'G', '4') /* MPEG-4 ES     */
 439 | #define V4L2_PIX_FMT_XVID     v4l2_fourcc('X', 'V', 'I', 'D') /* Xvid           */
 440 | #define V4L2_PIX_FMT_VC1_ANNEX_G v4l2_fourcc('V', 'C', '1', 'G') /* SMPTE 421M Annex G compliant stream */
 441 | #define V4L2_PIX_FMT_VC1_ANNEX_L v4l2_fourcc('V', 'C', '1', 'L') /* SMPTE 421M Annex L compliant stream */
 442 | 
 443 | /*  Vendor-specific formats   */
 444 | #define V4L2_PIX_FMT_CPIA1    v4l2_fourcc('C', 'P', 'I', 'A') /* cpia1 YUV */
 445 | #define V4L2_PIX_FMT_WNVA     v4l2_fourcc('W', 'N', 'V', 'A') /* Winnov hw compress */
 446 | #define V4L2_PIX_FMT_SN9C10X  v4l2_fourcc('S', '9', '1', '0') /* SN9C10x compression */
 447 | #define V4L2_PIX_FMT_SN9C20X_I420 v4l2_fourcc('S', '9', '2', '0') /* SN9C20x YUV 4:2:0 */
 448 | #define V4L2_PIX_FMT_PWC1     v4l2_fourcc('P', 'W', 'C', '1') /* pwc older webcam */
 449 | #define V4L2_PIX_FMT_PWC2     v4l2_fourcc('P', 'W', 'C', '2') /* pwc newer webcam */
 450 | #define V4L2_PIX_FMT_ET61X251 v4l2_fourcc('E', '6', '2', '5') /* ET61X251 compression */
 451 | #define V4L2_PIX_FMT_SPCA501  v4l2_fourcc('S', '5', '0', '1') /* YUYV per line */
 452 | #define V4L2_PIX_FMT_SPCA505  v4l2_fourcc('S', '5', '0', '5') /* YYUV per line */
 453 | #define V4L2_PIX_FMT_SPCA508  v4l2_fourcc('S', '5', '0', '8') /* YUVY per line */
 454 | #define V4L2_PIX_FMT_SPCA561  v4l2_fourcc('S', '5', '6', '1') /* compressed GBRG bayer */
 455 | #define V4L2_PIX_FMT_PAC207   v4l2_fourcc('P', '2', '0', '7') /* compressed BGGR bayer */
 456 | #define V4L2_PIX_FMT_MR97310A v4l2_fourcc('M', '3', '1', '0') /* compressed BGGR bayer */
 457 | #define V4L2_PIX_FMT_JL2005BCD v4l2_fourcc('J', 'L', '2', '0') /* compressed RGGB bayer */
 458 | #define V4L2_PIX_FMT_SN9C2028 v4l2_fourcc('S', 'O', 'N', 'X') /* compressed GBRG bayer */
 459 | #define V4L2_PIX_FMT_SQ905C   v4l2_fourcc('9', '0', '5', 'C') /* compressed RGGB bayer */
 460 | #define V4L2_PIX_FMT_PJPG     v4l2_fourcc('P', 'J', 'P', 'G') /* Pixart 73xx JPEG */
 461 | #define V4L2_PIX_FMT_OV511    v4l2_fourcc('O', '5', '1', '1') /* ov511 JPEG */
 462 | #define V4L2_PIX_FMT_OV518    v4l2_fourcc('O', '5', '1', '8') /* ov518 JPEG */
 463 | #define V4L2_PIX_FMT_STV0680  v4l2_fourcc('S', '6', '8', '0') /* stv0680 bayer */
 464 | #define V4L2_PIX_FMT_TM6000   v4l2_fourcc('T', 'M', '6', '0') /* tm5600/tm60x0 */
 465 | #define V4L2_PIX_FMT_CIT_YYVYUY v4l2_fourcc('C', 'I', 'T', 'V') /* one line of Y then 1 line of VYUY */
 466 | #define V4L2_PIX_FMT_KONICA420  v4l2_fourcc('K', 'O', 'N', 'I') /* YUV420 planar in blocks of 256 pixels */
 467 | #define V4L2_PIX_FMT_JPGL	v4l2_fourcc('J', 'P', 'G', 'L') /* JPEG-Lite */
 468 | #define V4L2_PIX_FMT_SE401      v4l2_fourcc('S', '4', '0', '1') /* se401 janggu compressed rgb */
 469 | 
 470 | /*
 471 |  *	F O R M A T   E N U M E R A T I O N
 472 |  */
 473 | struct v4l2_fmtdesc {
 474 | 	__u32		    index;             /* Format number      */
 475 | 	enum v4l2_buf_type  type;              /* buffer type        */
 476 | 	__u32               flags;
 477 | 	__u8		    description[32];   /* Description string */
 478 | 	__u32		    pixelformat;       /* Format fourcc      */
 479 | 	__u32		    reserved[4];
 480 | };
 481 | 
 482 | #define V4L2_FMT_FLAG_COMPRESSED 0x0001
 483 | #define V4L2_FMT_FLAG_EMULATED   0x0002
 484 | 
 485 | #if 1
 486 | 	/* Experimental Frame Size and frame rate enumeration */
 487 | /*
 488 |  *	F R A M E   S I Z E   E N U M E R A T I O N
 489 |  */
 490 | enum v4l2_frmsizetypes {
 491 | 	V4L2_FRMSIZE_TYPE_DISCRETE	= 1,
 492 | 	V4L2_FRMSIZE_TYPE_CONTINUOUS	= 2,
 493 | 	V4L2_FRMSIZE_TYPE_STEPWISE	= 3,
 494 | };
 495 | 
 496 | struct v4l2_frmsize_discrete {
 497 | 	__u32			width;		/* Frame width [pixel] */
 498 | 	__u32			height;		/* Frame height [pixel] */
 499 | };
 500 | 
 501 | struct v4l2_frmsize_stepwise {
 502 | 	__u32			min_width;	/* Minimum frame width [pixel] */
 503 | 	__u32			max_width;	/* Maximum frame width [pixel] */
 504 | 	__u32			step_width;	/* Frame width step size [pixel] */
 505 | 	__u32			min_height;	/* Minimum frame height [pixel] */
 506 | 	__u32			max_height;	/* Maximum frame height [pixel] */
 507 | 	__u32			step_height;	/* Frame height step size [pixel] */
 508 | };
 509 | 
 510 | struct v4l2_frmsizeenum {
 511 | 	__u32			index;		/* Frame size number */
 512 | 	__u32			pixel_format;	/* Pixel format */
 513 | 	__u32			type;		/* Frame size type the device supports. */
 514 | 
 515 | 	union {					/* Frame size */
 516 | 		struct v4l2_frmsize_discrete	discrete;
 517 | 		struct v4l2_frmsize_stepwise	stepwise;
 518 | 	};
 519 | 
 520 | 	__u32   reserved[2];			/* Reserved space for future use */
 521 | };
 522 | 
 523 | /*
 524 |  *	F R A M E   R A T E   E N U M E R A T I O N
 525 |  */
 526 | enum v4l2_frmivaltypes {
 527 | 	V4L2_FRMIVAL_TYPE_DISCRETE	= 1,
 528 | 	V4L2_FRMIVAL_TYPE_CONTINUOUS	= 2,
 529 | 	V4L2_FRMIVAL_TYPE_STEPWISE	= 3,
 530 | };
 531 | 
 532 | struct v4l2_frmival_stepwise {
 533 | 	struct v4l2_fract	min;		/* Minimum frame interval [s] */
 534 | 	struct v4l2_fract	max;		/* Maximum frame interval [s] */
 535 | 	struct v4l2_fract	step;		/* Frame interval step size [s] */
 536 | };
 537 | 
 538 | struct v4l2_frmivalenum {
 539 | 	__u32			index;		/* Frame format index */
 540 | 	__u32			pixel_format;	/* Pixel format */
 541 | 	__u32			width;		/* Frame width */
 542 | 	__u32			height;		/* Frame height */
 543 | 	__u32			type;		/* Frame interval type the device supports. */
 544 | 
 545 | 	union {					/* Frame interval */
 546 | 		struct v4l2_fract		discrete;
 547 | 		struct v4l2_frmival_stepwise	stepwise;
 548 | 	};
 549 | 
 550 | 	__u32	reserved[2];			/* Reserved space for future use */
 551 | };
 552 | #endif
 553 | 
 554 | /*
 555 |  *	T I M E C O D E
 556 |  */
 557 | struct v4l2_timecode {
 558 | 	__u32	type;
 559 | 	__u32	flags;
 560 | 	__u8	frames;
 561 | 	__u8	seconds;
 562 | 	__u8	minutes;
 563 | 	__u8	hours;
 564 | 	__u8	userbits[4];
 565 | };
 566 | 
 567 | /*  Type  */
 568 | #define V4L2_TC_TYPE_24FPS		1
 569 | #define V4L2_TC_TYPE_25FPS		2
 570 | #define V4L2_TC_TYPE_30FPS		3
 571 | #define V4L2_TC_TYPE_50FPS		4
 572 | #define V4L2_TC_TYPE_60FPS		5
 573 | 
 574 | /*  Flags  */
 575 | #define V4L2_TC_FLAG_DROPFRAME		0x0001 /* "drop-frame" mode */
 576 | #define V4L2_TC_FLAG_COLORFRAME		0x0002
 577 | #define V4L2_TC_USERBITS_field		0x000C
 578 | #define V4L2_TC_USERBITS_USERDEFINED	0x0000
 579 | #define V4L2_TC_USERBITS_8BITCHARS	0x0008
 580 | /* The above is based on SMPTE timecodes */
 581 | 
 582 | struct v4l2_jpegcompression {
 583 | 	int quality;
 584 | 
 585 | 	int  APPn;              /* Number of APP segment to be written,
 586 | 				 * must be 0..15 */
 587 | 	int  APP_len;           /* Length of data in JPEG APPn segment */
 588 | 	char APP_data[60];      /* Data in the JPEG APPn segment. */
 589 | 
 590 | 	int  COM_len;           /* Length of data in JPEG COM segment */
 591 | 	char COM_data[60];      /* Data in JPEG COM segment */
 592 | 
 593 | 	__u32 jpeg_markers;     /* Which markers should go into the JPEG
 594 | 				 * output. Unless you exactly know what
 595 | 				 * you do, leave them untouched.
 596 | 				 * Inluding less markers will make the
 597 | 				 * resulting code smaller, but there will
 598 | 				 * be fewer applications which can read it.
 599 | 				 * The presence of the APP and COM marker
 600 | 				 * is influenced by APP_len and COM_len
 601 | 				 * ONLY, not by this property! */
 602 | 
 603 | #define V4L2_JPEG_MARKER_DHT (1<<3)    /* Define Huffman Tables */
 604 | #define V4L2_JPEG_MARKER_DQT (1<<4)    /* Define Quantization Tables */
 605 | #define V4L2_JPEG_MARKER_DRI (1<<5)    /* Define Restart Interval */
 606 | #define V4L2_JPEG_MARKER_COM (1<<6)    /* Comment segment */
 607 | #define V4L2_JPEG_MARKER_APP (1<<7)    /* App segment, driver will
 608 | 					* allways use APP0 */
 609 | };
 610 | 
 611 | /*
 612 |  *	M E M O R Y - M A P P I N G   B U F F E R S
 613 |  */
 614 | struct v4l2_requestbuffers {
 615 | 	__u32			count;
 616 | 	enum v4l2_buf_type      type;
 617 | 	enum v4l2_memory        memory;
 618 | 	__u32			reserved[2];
 619 | };
 620 | 
 621 | /**
 622 |  * struct v4l2_plane - plane info for multi-planar buffers
 623 |  * @bytesused:		number of bytes occupied by data in the plane (payload)
 624 |  * @length:		size of this plane (NOT the payload) in bytes
 625 |  * @mem_offset:		when memory in the associated struct v4l2_buffer is
 626 |  *			V4L2_MEMORY_MMAP, equals the offset from the start of
 627 |  *			the device memory for this plane (or is a "cookie" that
 628 |  *			should be passed to mmap() called on the video node)
 629 |  * @userptr:		when memory is V4L2_MEMORY_USERPTR, a userspace pointer
 630 |  *			pointing to this plane
 631 |  * @data_offset:	offset in the plane to the start of data; usually 0,
 632 |  *			unless there is a header in front of the data
 633 |  *
 634 |  * Multi-planar buffers consist of one or more planes, e.g. an YCbCr buffer
 635 |  * with two planes can have one plane for Y, and another for interleaved CbCr
 636 |  * components. Each plane can reside in a separate memory buffer, or even in
 637 |  * a completely separate memory node (e.g. in embedded devices).
 638 |  */
 639 | struct v4l2_plane {
 640 | 	__u32			bytesused;
 641 | 	__u32			length;
 642 | 	union {
 643 | 		__u32		mem_offset;
 644 | 		unsigned long	userptr;
 645 | 	} m;
 646 | 	__u32			data_offset;
 647 | 	__u32			reserved[11];
 648 | };
 649 | 
 650 | /**
 651 |  * struct v4l2_buffer - video buffer info
 652 |  * @index:	id number of the buffer
 653 |  * @type:	buffer type (type == *_MPLANE for multiplanar buffers)
 654 |  * @bytesused:	number of bytes occupied by data in the buffer (payload);
 655 |  *		unused (set to 0) for multiplanar buffers
 656 |  * @flags:	buffer informational flags
 657 |  * @field:	field order of the image in the buffer
 658 |  * @timestamp:	frame timestamp
 659 |  * @timecode:	frame timecode
 660 |  * @sequence:	sequence count of this frame
 661 |  * @memory:	the method, in which the actual video data is passed
 662 |  * @offset:	for non-multiplanar buffers with memory == V4L2_MEMORY_MMAP;
 663 |  *		offset from the start of the device memory for this plane,
 664 |  *		(or a "cookie" that should be passed to mmap() as offset)
 665 |  * @userptr:	for non-multiplanar buffers with memory == V4L2_MEMORY_USERPTR;
 666 |  *		a userspace pointer pointing to this buffer
 667 |  * @planes:	for multiplanar buffers; userspace pointer to the array of plane
 668 |  *		info structs for this buffer
 669 |  * @length:	size in bytes of the buffer (NOT its payload) for single-plane
 670 |  *		buffers (when type != *_MPLANE); number of elements in the
 671 |  *		planes array for multi-plane buffers
 672 |  * @input:	input number from which the video data has has been captured
 673 |  *
 674 |  * Contains data exchanged by application and driver using one of the Streaming
 675 |  * I/O methods.
 676 |  */
 677 | struct v4l2_buffer {
 678 | 	__u32			index;
 679 | 	enum v4l2_buf_type      type;
 680 | 	__u32			bytesused;
 681 | 	__u32			flags;
 682 | 	enum v4l2_field		field;
 683 | 	struct timeval		timestamp;
 684 | 	struct v4l2_timecode	timecode;
 685 | 	__u32			sequence;
 686 | 
 687 | 	/* memory location */
 688 | 	enum v4l2_memory        memory;
 689 | 	union {
 690 | 		__u32           offset;
 691 | 		unsigned long   userptr;
 692 | 		struct v4l2_plane *planes;
 693 | 	} m;
 694 | 	__u32			length;
 695 | 	__u32			input;
 696 | 	__u32			reserved;
 697 | };
 698 | 
 699 | /*  Flags for 'flags' field */
 700 | #define V4L2_BUF_FLAG_MAPPED	0x0001  /* Buffer is mapped (flag) */
 701 | #define V4L2_BUF_FLAG_QUEUED	0x0002	/* Buffer is queued for processing */
 702 | #define V4L2_BUF_FLAG_DONE	0x0004	/* Buffer is ready */
 703 | #define V4L2_BUF_FLAG_KEYFRAME	0x0008	/* Image is a keyframe (I-frame) */
 704 | #define V4L2_BUF_FLAG_PFRAME	0x0010	/* Image is a P-frame */
 705 | #define V4L2_BUF_FLAG_BFRAME	0x0020	/* Image is a B-frame */
 706 | /* Buffer is ready, but the data contained within is corrupted. */
 707 | #define V4L2_BUF_FLAG_ERROR	0x0040
 708 | #define V4L2_BUF_FLAG_TIMECODE	0x0100	/* timecode field is valid */
 709 | #define V4L2_BUF_FLAG_INPUT     0x0200  /* input field is valid */
 710 | #define V4L2_BUF_FLAG_PREPARED	0x0400	/* Buffer is prepared for queuing */
 711 | /* Cache handling flags */
 712 | #define V4L2_BUF_FLAG_NO_CACHE_INVALIDATE	0x0800
 713 | #define V4L2_BUF_FLAG_NO_CACHE_CLEAN		0x1000
 714 | 
 715 | /*
 716 |  *	O V E R L A Y   P R E V I E W
 717 |  */
 718 | struct v4l2_framebuffer {
 719 | 	__u32			capability;
 720 | 	__u32			flags;
 721 | /* FIXME: in theory we should pass something like PCI device + memory
 722 |  * region + offset instead of some physical address */
 723 | 	void                    *base;
 724 | 	struct v4l2_pix_format	fmt;
 725 | };
 726 | /*  Flags for the 'capability' field. Read only */
 727 | #define V4L2_FBUF_CAP_EXTERNOVERLAY	0x0001
 728 | #define V4L2_FBUF_CAP_CHROMAKEY		0x0002
 729 | #define V4L2_FBUF_CAP_LIST_CLIPPING     0x0004
 730 | #define V4L2_FBUF_CAP_BITMAP_CLIPPING	0x0008
 731 | #define V4L2_FBUF_CAP_LOCAL_ALPHA	0x0010
 732 | #define V4L2_FBUF_CAP_GLOBAL_ALPHA	0x0020
 733 | #define V4L2_FBUF_CAP_LOCAL_INV_ALPHA	0x0040
 734 | #define V4L2_FBUF_CAP_SRC_CHROMAKEY	0x0080
 735 | /*  Flags for the 'flags' field. */
 736 | #define V4L2_FBUF_FLAG_PRIMARY		0x0001
 737 | #define V4L2_FBUF_FLAG_OVERLAY		0x0002
 738 | #define V4L2_FBUF_FLAG_CHROMAKEY	0x0004
 739 | #define V4L2_FBUF_FLAG_LOCAL_ALPHA	0x0008
 740 | #define V4L2_FBUF_FLAG_GLOBAL_ALPHA	0x0010
 741 | #define V4L2_FBUF_FLAG_LOCAL_INV_ALPHA	0x0020
 742 | #define V4L2_FBUF_FLAG_SRC_CHROMAKEY	0x0040
 743 | 
 744 | struct v4l2_clip {
 745 | 	struct v4l2_rect        c;
 746 | 	struct v4l2_clip	 *next;
 747 | };
 748 | 
 749 | struct v4l2_window {
 750 | 	struct v4l2_rect        w;
 751 | 	enum v4l2_field  	field;
 752 | 	__u32			chromakey;
 753 | 	struct v4l2_clip	*clips;
 754 | 	__u32			clipcount;
 755 | 	void			*bitmap;
 756 | 	__u8                    global_alpha;
 757 | };
 758 | 
 759 | /*
 760 |  *	C A P T U R E   P A R A M E T E R S
 761 |  */
 762 | struct v4l2_captureparm {
 763 | 	__u32		   capability;	  /*  Supported modes */
 764 | 	__u32		   capturemode;	  /*  Current mode */
 765 | 	struct v4l2_fract  timeperframe;  /*  Time per frame in .1us units */
 766 | 	__u32		   extendedmode;  /*  Driver-specific extensions */
 767 | 	__u32              readbuffers;   /*  # of buffers for read */
 768 | 	__u32		   reserved[4];
 769 | };
 770 | 
 771 | /*  Flags for 'capability' and 'capturemode' fields */
 772 | #define V4L2_MODE_HIGHQUALITY	0x0001	/*  High quality imaging mode */
 773 | #define V4L2_MODE_VIDEO				0x0002	/*  Added by raymonxiu For video capture */
 774 | #define V4L2_MODE_IMAGE				0x0003	/*  Added by raymonxiu For image capture */
 775 | #define V4L2_MODE_PREVIEW			0x0004	/*  Added by raymonxiu For preview capture */
 776 | #define V4L2_CAP_TIMEPERFRAME	0x1000	/*  timeperframe field is supported */
 777 | 
 778 | struct v4l2_outputparm {
 779 | 	__u32		   capability;	 /*  Supported modes */
 780 | 	__u32		   outputmode;	 /*  Current mode */
 781 | 	struct v4l2_fract  timeperframe; /*  Time per frame in seconds */
 782 | 	__u32		   extendedmode; /*  Driver-specific extensions */
 783 | 	__u32              writebuffers; /*  # of buffers for write */
 784 | 	__u32		   reserved[4];
 785 | };
 786 | 
 787 | /*
 788 |  *	I N P U T   I M A G E   C R O P P I N G
 789 |  */
 790 | struct v4l2_cropcap {
 791 | 	enum v4l2_buf_type      type;
 792 | 	struct v4l2_rect        bounds;
 793 | 	struct v4l2_rect        defrect;
 794 | 	struct v4l2_fract       pixelaspect;
 795 | };
 796 | 
 797 | struct v4l2_crop {
 798 | 	enum v4l2_buf_type      type;
 799 | 	struct v4l2_rect        c;
 800 | };
 801 | 
 802 | /* Hints for adjustments of selection rectangle */
 803 | #define V4L2_SEL_FLAG_GE	0x00000001
 804 | #define V4L2_SEL_FLAG_LE	0x00000002
 805 | 
 806 | /* Selection targets */
 807 | 
 808 | /* Current cropping area */
 809 | #define V4L2_SEL_TGT_CROP_ACTIVE	0x0000
 810 | /* Default cropping area */
 811 | #define V4L2_SEL_TGT_CROP_DEFAULT	0x0001
 812 | /* Cropping bounds */
 813 | #define V4L2_SEL_TGT_CROP_BOUNDS	0x0002
 814 | /* Current composing area */
 815 | #define V4L2_SEL_TGT_COMPOSE_ACTIVE	0x0100
 816 | /* Default composing area */
 817 | #define V4L2_SEL_TGT_COMPOSE_DEFAULT	0x0101
 818 | /* Composing bounds */
 819 | #define V4L2_SEL_TGT_COMPOSE_BOUNDS	0x0102
 820 | /* Current composing area plus all padding pixels */
 821 | #define V4L2_SEL_TGT_COMPOSE_PADDED	0x0103
 822 | 
 823 | /**
 824 |  * struct v4l2_selection - selection info
 825 |  * @type:	buffer type (do not use *_MPLANE types)
 826 |  * @target:	selection target, used to choose one of possible rectangles
 827 |  * @flags:	constraints flags
 828 |  * @r:		coordinates of selection window
 829 |  * @reserved:	for future use, rounds structure size to 64 bytes, set to zero
 830 |  *
 831 |  * Hardware may use multiple helper windows to process a video stream.
 832 |  * The structure is used to exchange this selection areas between
 833 |  * an application and a driver.
 834 |  */
 835 | struct v4l2_selection {
 836 | 	__u32			type;
 837 | 	__u32			target;
 838 | 	__u32                   flags;
 839 | 	struct v4l2_rect        r;
 840 | 	__u32                   reserved[9];
 841 | };
 842 | 
 843 | 
 844 | /*
 845 |  *      A N A L O G   V I D E O   S T A N D A R D
 846 |  */
 847 | 
 848 | typedef __u64 v4l2_std_id;
 849 | 
 850 | /* one bit for each */
 851 | #define V4L2_STD_PAL_B          ((v4l2_std_id)0x00000001)
 852 | #define V4L2_STD_PAL_B1         ((v4l2_std_id)0x00000002)
 853 | #define V4L2_STD_PAL_G          ((v4l2_std_id)0x00000004)
 854 | #define V4L2_STD_PAL_H          ((v4l2_std_id)0x00000008)
 855 | #define V4L2_STD_PAL_I          ((v4l2_std_id)0x00000010)
 856 | #define V4L2_STD_PAL_D          ((v4l2_std_id)0x00000020)
 857 | #define V4L2_STD_PAL_D1         ((v4l2_std_id)0x00000040)
 858 | #define V4L2_STD_PAL_K          ((v4l2_std_id)0x00000080)
 859 | 
 860 | #define V4L2_STD_PAL_M          ((v4l2_std_id)0x00000100)
 861 | #define V4L2_STD_PAL_N          ((v4l2_std_id)0x00000200)
 862 | #define V4L2_STD_PAL_Nc         ((v4l2_std_id)0x00000400)
 863 | #define V4L2_STD_PAL_60         ((v4l2_std_id)0x00000800)
 864 | 
 865 | #define V4L2_STD_NTSC_M         ((v4l2_std_id)0x00001000)	/* BTSC */
 866 | #define V4L2_STD_NTSC_M_JP      ((v4l2_std_id)0x00002000)	/* EIA-J */
 867 | #define V4L2_STD_NTSC_443       ((v4l2_std_id)0x00004000)
 868 | #define V4L2_STD_NTSC_M_KR      ((v4l2_std_id)0x00008000)	/* FM A2 */
 869 | 
 870 | #define V4L2_STD_SECAM_B        ((v4l2_std_id)0x00010000)
 871 | #define V4L2_STD_SECAM_D        ((v4l2_std_id)0x00020000)
 872 | #define V4L2_STD_SECAM_G        ((v4l2_std_id)0x00040000)
 873 | #define V4L2_STD_SECAM_H        ((v4l2_std_id)0x00080000)
 874 | #define V4L2_STD_SECAM_K        ((v4l2_std_id)0x00100000)
 875 | #define V4L2_STD_SECAM_K1       ((v4l2_std_id)0x00200000)
 876 | #define V4L2_STD_SECAM_L        ((v4l2_std_id)0x00400000)
 877 | #define V4L2_STD_SECAM_LC       ((v4l2_std_id)0x00800000)
 878 | 
 879 | /* ATSC/HDTV */
 880 | #define V4L2_STD_ATSC_8_VSB     ((v4l2_std_id)0x01000000)
 881 | #define V4L2_STD_ATSC_16_VSB    ((v4l2_std_id)0x02000000)
 882 | 
 883 | /* FIXME:
 884 |    Although std_id is 64 bits, there is an issue on PPC32 architecture that
 885 |    makes switch(__u64) to break. So, there's a hack on v4l2-common.c rounding
 886 |    this value to 32 bits.
 887 |    As, currently, the max value is for V4L2_STD_ATSC_16_VSB (30 bits wide),
 888 |    it should work fine. However, if needed to add more than two standards,
 889 |    v4l2-common.c should be fixed.
 890 |  */
 891 | 
 892 | /*
 893 |  * Some macros to merge video standards in order to make live easier for the
 894 |  * drivers and V4L2 applications
 895 |  */
 896 | 
 897 | /*
 898 |  * "Common" NTSC/M - It should be noticed that V4L2_STD_NTSC_443 is
 899 |  * Missing here.
 900 |  */
 901 | #define V4L2_STD_NTSC           (V4L2_STD_NTSC_M	|\
 902 | 				 V4L2_STD_NTSC_M_JP     |\
 903 | 				 V4L2_STD_NTSC_M_KR)
 904 | /* Secam macros */
 905 | #define V4L2_STD_SECAM_DK      	(V4L2_STD_SECAM_D	|\
 906 | 				 V4L2_STD_SECAM_K	|\
 907 | 				 V4L2_STD_SECAM_K1)
 908 | /* All Secam Standards */
 909 | #define V4L2_STD_SECAM		(V4L2_STD_SECAM_B	|\
 910 | 				 V4L2_STD_SECAM_G	|\
 911 | 				 V4L2_STD_SECAM_H	|\
 912 | 				 V4L2_STD_SECAM_DK	|\
 913 | 				 V4L2_STD_SECAM_L       |\
 914 | 				 V4L2_STD_SECAM_LC)
 915 | /* PAL macros */
 916 | #define V4L2_STD_PAL_BG		(V4L2_STD_PAL_B		|\
 917 | 				 V4L2_STD_PAL_B1	|\
 918 | 				 V4L2_STD_PAL_G)
 919 | #define V4L2_STD_PAL_DK		(V4L2_STD_PAL_D		|\
 920 | 				 V4L2_STD_PAL_D1	|\
 921 | 				 V4L2_STD_PAL_K)
 922 | /*
 923 |  * "Common" PAL - This macro is there to be compatible with the old
 924 |  * V4L1 concept of "PAL": /BGDKHI.
 925 |  * Several PAL standards are mising here: /M, /N and /Nc
 926 |  */
 927 | #define V4L2_STD_PAL		(V4L2_STD_PAL_BG	|\
 928 | 				 V4L2_STD_PAL_DK	|\
 929 | 				 V4L2_STD_PAL_H		|\
 930 | 				 V4L2_STD_PAL_I)
 931 | /* Chroma "agnostic" standards */
 932 | #define V4L2_STD_B		(V4L2_STD_PAL_B		|\
 933 | 				 V4L2_STD_PAL_B1	|\
 934 | 				 V4L2_STD_SECAM_B)
 935 | #define V4L2_STD_G		(V4L2_STD_PAL_G		|\
 936 | 				 V4L2_STD_SECAM_G)
 937 | #define V4L2_STD_H		(V4L2_STD_PAL_H		|\
 938 | 				 V4L2_STD_SECAM_H)
 939 | #define V4L2_STD_L		(V4L2_STD_SECAM_L	|\
 940 | 				 V4L2_STD_SECAM_LC)
 941 | #define V4L2_STD_GH		(V4L2_STD_G		|\
 942 | 				 V4L2_STD_H)
 943 | #define V4L2_STD_DK		(V4L2_STD_PAL_DK	|\
 944 | 				 V4L2_STD_SECAM_DK)
 945 | #define V4L2_STD_BG		(V4L2_STD_B		|\
 946 | 				 V4L2_STD_G)
 947 | #define V4L2_STD_MN		(V4L2_STD_PAL_M		|\
 948 | 				 V4L2_STD_PAL_N		|\
 949 | 				 V4L2_STD_PAL_Nc	|\
 950 | 				 V4L2_STD_NTSC)
 951 | 
 952 | /* Standards where MTS/BTSC stereo could be found */
 953 | #define V4L2_STD_MTS		(V4L2_STD_NTSC_M	|\
 954 | 				 V4L2_STD_PAL_M		|\
 955 | 				 V4L2_STD_PAL_N		|\
 956 | 				 V4L2_STD_PAL_Nc)
 957 | 
 958 | /* Standards for Countries with 60Hz Line frequency */
 959 | #define V4L2_STD_525_60		(V4L2_STD_PAL_M		|\
 960 | 				 V4L2_STD_PAL_60	|\
 961 | 				 V4L2_STD_NTSC		|\
 962 | 				 V4L2_STD_NTSC_443)
 963 | /* Standards for Countries with 50Hz Line frequency */
 964 | #define V4L2_STD_625_50		(V4L2_STD_PAL		|\
 965 | 				 V4L2_STD_PAL_N		|\
 966 | 				 V4L2_STD_PAL_Nc	|\
 967 | 				 V4L2_STD_SECAM)
 968 | 
 969 | #define V4L2_STD_ATSC           (V4L2_STD_ATSC_8_VSB    |\
 970 | 				 V4L2_STD_ATSC_16_VSB)
 971 | /* Macros with none and all analog standards */
 972 | #define V4L2_STD_UNKNOWN        0
 973 | #define V4L2_STD_ALL            (V4L2_STD_525_60	|\
 974 | 				 V4L2_STD_625_50)
 975 | 
 976 | struct v4l2_standard {
 977 | 	__u32		     index;
 978 | 	v4l2_std_id          id;
 979 | 	__u8		     name[24];
 980 | 	struct v4l2_fract    frameperiod; /* Frames, not fields */
 981 | 	__u32		     framelines;
 982 | 	__u32		     reserved[4];
 983 | };
 984 | 
 985 | /*
 986 |  *	V I D E O	T I M I N G S	D V	P R E S E T
 987 |  */
 988 | struct v4l2_dv_preset {
 989 | 	__u32	preset;
 990 | 	__u32	reserved[4];
 991 | };
 992 | 
 993 | /*
 994 |  *	D V	P R E S E T S	E N U M E R A T I O N
 995 |  */
 996 | struct v4l2_dv_enum_preset {
 997 | 	__u32	index;
 998 | 	__u32	preset;
 999 | 	__u8	name[32]; /* Name of the preset timing */
1000 | 	__u32	width;
1001 | 	__u32	height;
1002 | 	__u32	reserved[4];
1003 | };
1004 | 
1005 | /*
1006 |  * 	D V	P R E S E T	V A L U E S
1007 |  */
1008 | #define		V4L2_DV_INVALID		0
1009 | #define		V4L2_DV_480P59_94	1 /* BT.1362 */
1010 | #define		V4L2_DV_576P50		2 /* BT.1362 */
1011 | #define		V4L2_DV_720P24		3 /* SMPTE 296M */
1012 | #define		V4L2_DV_720P25		4 /* SMPTE 296M */
1013 | #define		V4L2_DV_720P30		5 /* SMPTE 296M */
1014 | #define		V4L2_DV_720P50		6 /* SMPTE 296M */
1015 | #define		V4L2_DV_720P59_94	7 /* SMPTE 274M */
1016 | #define		V4L2_DV_720P60		8 /* SMPTE 274M/296M */
1017 | #define		V4L2_DV_1080I29_97	9 /* BT.1120/ SMPTE 274M */
1018 | #define		V4L2_DV_1080I30		10 /* BT.1120/ SMPTE 274M */
1019 | #define		V4L2_DV_1080I25		11 /* BT.1120 */
1020 | #define		V4L2_DV_1080I50		12 /* SMPTE 296M */
1021 | #define		V4L2_DV_1080I60		13 /* SMPTE 296M */
1022 | #define		V4L2_DV_1080P24		14 /* SMPTE 296M */
1023 | #define		V4L2_DV_1080P25		15 /* SMPTE 296M */
1024 | #define		V4L2_DV_1080P30		16 /* SMPTE 296M */
1025 | #define		V4L2_DV_1080P50		17 /* BT.1120 */
1026 | #define		V4L2_DV_1080P60		18 /* BT.1120 */
1027 | 
1028 | /*
1029 |  *	D V 	B T	T I M I N G S
1030 |  */
1031 | 
1032 | /* BT.656/BT.1120 timing data */
1033 | struct v4l2_bt_timings {
1034 | 	__u32	width;		/* width in pixels */
1035 | 	__u32	height;		/* height in lines */
1036 | 	__u32	interlaced;	/* Interlaced or progressive */
1037 | 	__u32	polarities;	/* Positive or negative polarity */
1038 | 	__u64	pixelclock;	/* Pixel clock in HZ. Ex. 74.25MHz->74250000 */
1039 | 	__u32	hfrontporch;	/* Horizpontal front porch in pixels */
1040 | 	__u32	hsync;		/* Horizontal Sync length in pixels */
1041 | 	__u32	hbackporch;	/* Horizontal back porch in pixels */
1042 | 	__u32	vfrontporch;	/* Vertical front porch in pixels */
1043 | 	__u32	vsync;		/* Vertical Sync length in lines */
1044 | 	__u32	vbackporch;	/* Vertical back porch in lines */
1045 | 	__u32	il_vfrontporch;	/* Vertical front porch for bottom field of
1046 | 				 * interlaced field formats
1047 | 				 */
1048 | 	__u32	il_vsync;	/* Vertical sync length for bottom field of
1049 | 				 * interlaced field formats
1050 | 				 */
1051 | 	__u32	il_vbackporch;	/* Vertical back porch for bottom field of
1052 | 				 * interlaced field formats
1053 | 				 */
1054 | 	__u32	reserved[16];
1055 | } __attribute__ ((packed));
1056 | 
1057 | /* Interlaced or progressive format */
1058 | #define	V4L2_DV_PROGRESSIVE	0
1059 | #define	V4L2_DV_INTERLACED	1
1060 | 
1061 | /* Polarities. If bit is not set, it is assumed to be negative polarity */
1062 | #define V4L2_DV_VSYNC_POS_POL	0x00000001
1063 | #define V4L2_DV_HSYNC_POS_POL	0x00000002
1064 | 
1065 | 
1066 | /* DV timings */
1067 | struct v4l2_dv_timings {
1068 | 	__u32 type;
1069 | 	union {
1070 | 		struct v4l2_bt_timings	bt;
1071 | 		__u32	reserved[32];
1072 | 	};
1073 | } __attribute__ ((packed));
1074 | 
1075 | /* Values for the type field */
1076 | #define V4L2_DV_BT_656_1120	0	/* BT.656/1120 timing type */
1077 | 
1078 | /*
1079 |  *	V I D E O   I N P U T S
1080 |  */
1081 | struct v4l2_input {
1082 | 	__u32	     index;		/*  Which input */
1083 | 	__u8	     name[32];		/*  Label */
1084 | 	__u32	     type;		/*  Type of input */
1085 | 	__u32	     audioset;		/*  Associated audios (bitfield) */
1086 | 	__u32        tuner;             /*  Associated tuner */
1087 | 	v4l2_std_id  std;
1088 | 	__u32	     status;
1089 | 	__u32	     capabilities;
1090 | 	__u32	     reserved[3];
1091 | };
1092 | 
1093 | /*  Values for the 'type' field */
1094 | #define V4L2_INPUT_TYPE_TUNER		1
1095 | #define V4L2_INPUT_TYPE_CAMERA		2
1096 | 
1097 | /* field 'status' - general */
1098 | #define V4L2_IN_ST_NO_POWER    0x00000001  /* Attached device is off */
1099 | #define V4L2_IN_ST_NO_SIGNAL   0x00000002
1100 | #define V4L2_IN_ST_NO_COLOR    0x00000004
1101 | 
1102 | /* field 'status' - sensor orientation */
1103 | /* If sensor is mounted upside down set both bits */
1104 | #define V4L2_IN_ST_HFLIP       0x00000010 /* Frames are flipped horizontally */
1105 | #define V4L2_IN_ST_VFLIP       0x00000020 /* Frames are flipped vertically */
1106 | 
1107 | /* field 'status' - analog */
1108 | #define V4L2_IN_ST_NO_H_LOCK   0x00000100  /* No horizontal sync lock */
1109 | #define V4L2_IN_ST_COLOR_KILL  0x00000200  /* Color killer is active */
1110 | 
1111 | /* field 'status' - digital */
1112 | #define V4L2_IN_ST_NO_SYNC     0x00010000  /* No synchronization lock */
1113 | #define V4L2_IN_ST_NO_EQU      0x00020000  /* No equalizer lock */
1114 | #define V4L2_IN_ST_NO_CARRIER  0x00040000  /* Carrier recovery failed */
1115 | 
1116 | /* field 'status' - VCR and set-top box */
1117 | #define V4L2_IN_ST_MACROVISION 0x01000000  /* Macrovision detected */
1118 | #define V4L2_IN_ST_NO_ACCESS   0x02000000  /* Conditional access denied */
1119 | #define V4L2_IN_ST_VTR         0x04000000  /* VTR time constant */
1120 | 
1121 | /* capabilities flags */
1122 | #define V4L2_IN_CAP_PRESETS		0x00000001 /* Supports S_DV_PRESET */
1123 | #define V4L2_IN_CAP_CUSTOM_TIMINGS	0x00000002 /* Supports S_DV_TIMINGS */
1124 | #define V4L2_IN_CAP_STD			0x00000004 /* Supports S_STD */
1125 | 
1126 | /*
1127 |  *	V I D E O   O U T P U T S
1128 |  */
1129 | struct v4l2_output {
1130 | 	__u32	     index;		/*  Which output */
1131 | 	__u8	     name[32];		/*  Label */
1132 | 	__u32	     type;		/*  Type of output */
1133 | 	__u32	     audioset;		/*  Associated audios (bitfield) */
1134 | 	__u32	     modulator;         /*  Associated modulator */
1135 | 	v4l2_std_id  std;
1136 | 	__u32	     capabilities;
1137 | 	__u32	     reserved[3];
1138 | };
1139 | /*  Values for the 'type' field */
1140 | #define V4L2_OUTPUT_TYPE_MODULATOR		1
1141 | #define V4L2_OUTPUT_TYPE_ANALOG			2
1142 | #define V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY	3
1143 | 
1144 | /* capabilities flags */
1145 | #define V4L2_OUT_CAP_PRESETS		0x00000001 /* Supports S_DV_PRESET */
1146 | #define V4L2_OUT_CAP_CUSTOM_TIMINGS	0x00000002 /* Supports S_DV_TIMINGS */
1147 | #define V4L2_OUT_CAP_STD		0x00000004 /* Supports S_STD */
1148 | 
1149 | /*
1150 |  *	C O N T R O L S
1151 |  */
1152 | struct v4l2_control {
1153 | 	__u32		     id;
1154 | 	__s32		     value;
1155 | 	__u32				 user_pt;	/* Add user pointer by raymonxiu */	
1156 | };
1157 | 
1158 | struct v4l2_ext_control {
1159 | 	__u32 id;
1160 | 	__u32 size;
1161 | 	__u32 reserved2[1];
1162 | 	union {
1163 | 		__s32 value;
1164 | 		__s64 value64;
1165 | 		char *string;
1166 | 	};
1167 | } __attribute__ ((packed));
1168 | 
1169 | struct v4l2_ext_controls {
1170 | 	__u32 ctrl_class;
1171 | 	__u32 count;
1172 | 	__u32 error_idx;
1173 | 	__u32 reserved[2];
1174 | 	struct v4l2_ext_control *controls;
1175 | };
1176 | 
1177 | /*  Values for ctrl_class field */
1178 | #define V4L2_CTRL_CLASS_USER 0x00980000	/* Old-style 'user' controls */
1179 | #define V4L2_CTRL_CLASS_MPEG 0x00990000	/* MPEG-compression controls */
1180 | #define V4L2_CTRL_CLASS_CAMERA 0x009a0000	/* Camera class controls */
1181 | #define V4L2_CTRL_CLASS_FM_TX 0x009b0000	/* FM Modulator control class */
1182 | #define V4L2_CTRL_CLASS_FLASH 0x009c0000	/* Camera flash controls */
1183 | #define V4L2_CTRL_CLASS_JPEG 0x009d0000		/* JPEG-compression controls */
1184 | 
1185 | #define V4L2_CTRL_ID_MASK      	  (0x0fffffff)
1186 | #define V4L2_CTRL_ID2CLASS(id)    ((id) & 0x0fff0000UL)
1187 | #define V4L2_CTRL_DRIVER_PRIV(id) (((id) & 0xffff) >= 0x1000)
1188 | 
1189 | enum v4l2_ctrl_type {
1190 | 	V4L2_CTRL_TYPE_INTEGER	     = 1,
1191 | 	V4L2_CTRL_TYPE_BOOLEAN	     = 2,
1192 | 	V4L2_CTRL_TYPE_MENU	     = 3,
1193 | 	V4L2_CTRL_TYPE_BUTTON	     = 4,
1194 | 	V4L2_CTRL_TYPE_INTEGER64     = 5,
1195 | 	V4L2_CTRL_TYPE_CTRL_CLASS    = 6,
1196 | 	V4L2_CTRL_TYPE_STRING        = 7,
1197 | 	V4L2_CTRL_TYPE_BITMASK       = 8,
1198 | };
1199 | 
1200 | /*  Used in the VIDIOC_QUERYCTRL ioctl for querying controls */
1201 | struct v4l2_queryctrl {
1202 | 	__u32		     id;
1203 | 	enum v4l2_ctrl_type  type;
1204 | 	__u8		     name[32];	/* Whatever */
1205 | 	__s32		     minimum;	/* Note signedness */
1206 | 	__s32		     maximum;
1207 | 	__s32		     step;
1208 | 	__s32		     default_value;
1209 | 	__u32                flags;
1210 | 	__u32		     reserved[2];
1211 | };
1212 | 
1213 | /*  Used in the VIDIOC_QUERYMENU ioctl for querying menu items */
1214 | struct v4l2_querymenu {
1215 | 	__u32		id;
1216 | 	__u32		index;
1217 | 	__u8		name[32];	/* Whatever */
1218 | 	__u32		reserved;
1219 | };
1220 | 
1221 | /*  Control flags  */
1222 | #define V4L2_CTRL_FLAG_DISABLED		0x0001
1223 | #define V4L2_CTRL_FLAG_GRABBED		0x0002
1224 | #define V4L2_CTRL_FLAG_READ_ONLY 	0x0004
1225 | #define V4L2_CTRL_FLAG_UPDATE 		0x0008
1226 | #define V4L2_CTRL_FLAG_INACTIVE 	0x0010
1227 | #define V4L2_CTRL_FLAG_SLIDER 		0x0020
1228 | #define V4L2_CTRL_FLAG_WRITE_ONLY 	0x0040
1229 | #define V4L2_CTRL_FLAG_VOLATILE		0x0080
1230 | 
1231 | /*  Query flag, to be ORed with the control ID */
1232 | #define V4L2_CTRL_FLAG_NEXT_CTRL	0x80000000
1233 | 
1234 | /*  User-class control IDs defined by V4L2 */
1235 | #define V4L2_CID_MAX_CTRLS		1024
1236 | #define V4L2_CID_BASE			(V4L2_CTRL_CLASS_USER | 0x900)
1237 | #define V4L2_CID_USER_BASE 		V4L2_CID_BASE
1238 | /*  IDs reserved for driver specific controls */
1239 | #define V4L2_CID_PRIVATE_BASE		0x08000000
1240 | 
1241 | #define V4L2_CID_USER_CLASS 		(V4L2_CTRL_CLASS_USER | 1)
1242 | #define V4L2_CID_BRIGHTNESS		(V4L2_CID_BASE+0)
1243 | #define V4L2_CID_CONTRAST		(V4L2_CID_BASE+1)
1244 | #define V4L2_CID_SATURATION		(V4L2_CID_BASE+2)
1245 | #define V4L2_CID_HUE			(V4L2_CID_BASE+3)
1246 | #define V4L2_CID_AUDIO_VOLUME		(V4L2_CID_BASE+5)
1247 | #define V4L2_CID_AUDIO_BALANCE		(V4L2_CID_BASE+6)
1248 | #define V4L2_CID_AUDIO_BASS		(V4L2_CID_BASE+7)
1249 | #define V4L2_CID_AUDIO_TREBLE		(V4L2_CID_BASE+8)
1250 | #define V4L2_CID_AUDIO_MUTE		(V4L2_CID_BASE+9)
1251 | #define V4L2_CID_AUDIO_LOUDNESS		(V4L2_CID_BASE+10)
1252 | #define V4L2_CID_BLACK_LEVEL		(V4L2_CID_BASE+11) /* Deprecated */
1253 | #define V4L2_CID_AUTO_WHITE_BALANCE	(V4L2_CID_BASE+12)
1254 | #define V4L2_CID_DO_WHITE_BALANCE	(V4L2_CID_BASE+13)
1255 | #define V4L2_CID_RED_BALANCE		(V4L2_CID_BASE+14)
1256 | #define V4L2_CID_BLUE_BALANCE		(V4L2_CID_BASE+15)
1257 | #define V4L2_CID_GAMMA			(V4L2_CID_BASE+16)
1258 | #define V4L2_CID_WHITENESS		(V4L2_CID_GAMMA) /* Deprecated */
1259 | #define V4L2_CID_EXPOSURE		(V4L2_CID_BASE+17)
1260 | #define V4L2_CID_AUTOGAIN		(V4L2_CID_BASE+18)
1261 | #define V4L2_CID_GAIN			(V4L2_CID_BASE+19)
1262 | #define V4L2_CID_HFLIP			(V4L2_CID_BASE+20)
1263 | #define V4L2_CID_VFLIP			(V4L2_CID_BASE+21)
1264 | 
1265 | /* Deprecated; use V4L2_CID_PAN_RESET and V4L2_CID_TILT_RESET */
1266 | #define V4L2_CID_HCENTER		(V4L2_CID_BASE+22)
1267 | #define V4L2_CID_VCENTER		(V4L2_CID_BASE+23)
1268 | 
1269 | #define V4L2_CID_POWER_LINE_FREQUENCY	(V4L2_CID_BASE+24)
1270 | enum v4l2_power_line_frequency {
1271 | 	V4L2_CID_POWER_LINE_FREQUENCY_DISABLED	= 0,
1272 | 	V4L2_CID_POWER_LINE_FREQUENCY_50HZ	= 1,
1273 | 	V4L2_CID_POWER_LINE_FREQUENCY_60HZ	= 2,
1274 | 	V4L2_CID_POWER_LINE_FREQUENCY_AUTO	= 3,
1275 | };
1276 | #define V4L2_CID_HUE_AUTO			(V4L2_CID_BASE+25)
1277 | #define V4L2_CID_WHITE_BALANCE_TEMPERATURE	(V4L2_CID_BASE+26)
1278 | #define V4L2_CID_SHARPNESS			(V4L2_CID_BASE+27)
1279 | #define V4L2_CID_BACKLIGHT_COMPENSATION 	(V4L2_CID_BASE+28)
1280 | #define V4L2_CID_CHROMA_AGC                     (V4L2_CID_BASE+29)
1281 | #define V4L2_CID_COLOR_KILLER                   (V4L2_CID_BASE+30)
1282 | #define V4L2_CID_COLORFX			(V4L2_CID_BASE+31)
1283 | enum v4l2_colorfx {
1284 | 	V4L2_COLORFX_NONE	= 0,
1285 | 	V4L2_COLORFX_BW		= 1,
1286 | 	V4L2_COLORFX_SEPIA	= 2,
1287 | 	V4L2_COLORFX_NEGATIVE = 3,
1288 | 	V4L2_COLORFX_EMBOSS = 4,
1289 | 	V4L2_COLORFX_SKETCH = 5,
1290 | 	V4L2_COLORFX_SKY_BLUE = 6,
1291 | 	V4L2_COLORFX_GRASS_GREEN = 7,
1292 | 	V4L2_COLORFX_SKIN_WHITEN = 8,
1293 | 	V4L2_COLORFX_VIVID = 9,
1294 | 	V4L2_COLORFX_AQUA			= 10,
1295 | 	V4L2_COLORFX_ART_FREEZE			= 11,
1296 | 	V4L2_COLORFX_SILHOUETTE			= 12,
1297 | 	V4L2_COLORFX_SOLARIZATION		= 13,
1298 | 	V4L2_COLORFX_ANTIQUE			= 14,
1299 | 	V4L2_COLORFX_SET_CBCR			= 15,
1300 | };
1301 | #define V4L2_CID_AUTOBRIGHTNESS			(V4L2_CID_BASE+32)
1302 | #define V4L2_CID_BAND_STOP_FILTER		(V4L2_CID_BASE+33)
1303 | 
1304 | #define V4L2_CID_ROTATE				(V4L2_CID_BASE+34)
1305 | #define V4L2_CID_BG_COLOR			(V4L2_CID_BASE+35)
1306 | 
1307 | #define V4L2_CID_CHROMA_GAIN                    (V4L2_CID_BASE+36)
1308 | 
1309 | #define V4L2_CID_ILLUMINATORS_1			(V4L2_CID_BASE+37)
1310 | #define V4L2_CID_ILLUMINATORS_2			(V4L2_CID_BASE+38)
1311 | 
1312 | #define V4L2_CID_MIN_BUFFERS_FOR_CAPTURE	(V4L2_CID_BASE+39)
1313 | #define V4L2_CID_MIN_BUFFERS_FOR_OUTPUT		(V4L2_CID_BASE+40)
1314 | 
1315 | #define V4L2_CID_ALPHA_COMPONENT		(V4L2_CID_BASE+41)
1316 | #define V4L2_CID_COLORFX_CBCR			(V4L2_CID_BASE+42)
1317 | 
1318 | /* last CID + 1 */
1319 | #define V4L2_CID_LASTP1                         (V4L2_CID_BASE+43)
1320 | 
1321 | /* Driver Specific Control */
1322 | 
1323 | /* Add thumb picture mirror and flip by raymonxiu */
1324 | #define V4L2_CID_HFLIP_THUMB		(V4L2_CID_PRIVATE_BASE+0)
1325 | #define V4L2_CID_VFLIP_THUMB		(V4L2_CID_PRIVATE_BASE+1)
1326 | /* Add autofocus windows number by raymonxiu */
1327 | #define V4L2_CID_AUTO_FOCUS_WIN_NUM		(V4L2_CID_PRIVATE_BASE+2)
1328 | /* Add camera autofocus ctrl by raymonxiu */
1329 | #define V4L2_CID_AUTO_FOCUS_INIT		(V4L2_CID_PRIVATE_BASE+3)
1330 | #define V4L2_CID_AUTO_FOCUS_RELEASE	(V4L2_CID_PRIVATE_BASE+4)
1331 | 
1332 | /* Add auto exposure windows number by raymonxiu */
1333 | #define V4L2_CID_AUTO_EXPOSURE_WIN_NUM		(V4L2_CID_PRIVATE_BASE+5)
1334 | /* Add gsensor rotation degree by raymonxiu */
1335 | #define V4L2_CID_GSENSOR_ROTATION		(V4L2_CID_PRIVATE_BASE+6)
1336 | 
1337 | #define V4L2_CID_FRAME_RATE             (V4L2_CID_PRIVATE_BASE+7)
1338 | /* Add take picture by yang */
1339 | #define V4L2_CID_TAKE_PICTURE           (V4L2_CID_PRIVATE_BASE+8)
1340 | enum v4l2_take_picture {
1341 | 	V4L2_TAKE_PICTURE_STOP	= 0,
1342 | 	V4L2_TAKE_PICTURE_NORM	= 1,
1343 | 	V4L2_TAKE_PICTURE_FAST	= 2,
1344 | 	V4L2_TAKE_PICTURE_FLASH	= 3,
1345 | 	V4L2_TAKE_PICTURE_HDR	= 4,
1346 | };
1347 | #define V4L2_CID_HDR                   (V4L2_CID_PRIVATE_BASE+9)
1348 | typedef union
1349 | {
1350 | 	unsigned int dwval;
1351 | 	struct
1352 | 	{
1353 | 		unsigned int af_sharp             : 16 ; 
1354 | 		unsigned int hdr_cnt                    :  4 ; 
1355 | 		unsigned int flash_ok             : 1 ;
1356 | 		unsigned int capture_ok        :  1 ; 
1357 | 		unsigned int fast_capture_ok        :  1 ; 
1358 | 		unsigned int res0        :  9 ; 
1359 | 	} bits;
1360 | } IMAGE_FLAG_t;
1361 | 
1362 | #define V4L2_GAIN_SHIFT				0
1363 | #define V4L2_SHARP_LEVEL_SHIFT		8
1364 | #define V4L2_SHARP_MIN_SHIFT		20
1365 | #define V4L2_NDF_SHIFT				26
1366 | 
1367 | /* Add horizontal visual angle by yang */
1368 | #define  V4L2_CID_HOR_VISUAL_ANGLE	(V4L2_CID_PRIVATE_BASE+10)
1369 | /* Add vertical  visual angle by yang */
1370 | #define  V4L2_CID_VER_VISUAL_ANGLE       (V4L2_CID_PRIVATE_BASE+11)
1371 | /* Add focus length by yang */
1372 | #define  V4L2_CID_FOCUS_LENGTH               (V4L2_CID_PRIVATE_BASE+12)
1373 | /* Add red gain by yang */
1374 | #define  V4L2_CID_R_GAIN					(V4L2_CID_PRIVATE_BASE+13)
1375 | /* Add green gain by yang */
1376 | #define  V4L2_CID_G_GAIN   			    (V4L2_CID_PRIVATE_BASE+14)
1377 | /* Add blue gain by yang */
1378 | #define  V4L2_CID_B_GAIN    		           (V4L2_CID_PRIVATE_BASE+15)
1379 | /* Add sensor type by yang */
1380 | #define V4L2_CID_SENSOR_TYPE         (V4L2_CID_PRIVATE_BASE+16)
1381 | enum v4l2_sensor_type
1382 | {
1383 | 	V4L2_SENSOR_TYPE_YUV		= 0,
1384 | 	V4L2_SENSOR_TYPE_RAW		= 1,
1385 | };
1386 | 
1387 | /*  MPEG-class control IDs defined by V4L2 */
1388 | #define V4L2_CID_MPEG_BASE 			(V4L2_CTRL_CLASS_MPEG | 0x900)
1389 | #define V4L2_CID_MPEG_CLASS 			(V4L2_CTRL_CLASS_MPEG | 1)
1390 | 
1391 | /*  MPEG streams, specific to multiplexed streams */
1392 | #define V4L2_CID_MPEG_STREAM_TYPE 		(V4L2_CID_MPEG_BASE+0)
1393 | enum v4l2_mpeg_stream_type {
1394 | 	V4L2_MPEG_STREAM_TYPE_MPEG2_PS   = 0, /* MPEG-2 program stream */
1395 | 	V4L2_MPEG_STREAM_TYPE_MPEG2_TS   = 1, /* MPEG-2 transport stream */
1396 | 	V4L2_MPEG_STREAM_TYPE_MPEG1_SS   = 2, /* MPEG-1 system stream */
1397 | 	V4L2_MPEG_STREAM_TYPE_MPEG2_DVD  = 3, /* MPEG-2 DVD-compatible stream */
1398 | 	V4L2_MPEG_STREAM_TYPE_MPEG1_VCD  = 4, /* MPEG-1 VCD-compatible stream */
1399 | 	V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD = 5, /* MPEG-2 SVCD-compatible stream */
1400 | };
1401 | #define V4L2_CID_MPEG_STREAM_PID_PMT 		(V4L2_CID_MPEG_BASE+1)
1402 | #define V4L2_CID_MPEG_STREAM_PID_AUDIO 		(V4L2_CID_MPEG_BASE+2)
1403 | #define V4L2_CID_MPEG_STREAM_PID_VIDEO 		(V4L2_CID_MPEG_BASE+3)
1404 | #define V4L2_CID_MPEG_STREAM_PID_PCR 		(V4L2_CID_MPEG_BASE+4)
1405 | #define V4L2_CID_MPEG_STREAM_PES_ID_AUDIO 	(V4L2_CID_MPEG_BASE+5)
1406 | #define V4L2_CID_MPEG_STREAM_PES_ID_VIDEO 	(V4L2_CID_MPEG_BASE+6)
1407 | #define V4L2_CID_MPEG_STREAM_VBI_FMT 		(V4L2_CID_MPEG_BASE+7)
1408 | enum v4l2_mpeg_stream_vbi_fmt {
1409 | 	V4L2_MPEG_STREAM_VBI_FMT_NONE = 0,  /* No VBI in the MPEG stream */
1410 | 	V4L2_MPEG_STREAM_VBI_FMT_IVTV = 1,  /* VBI in private packets, IVTV format */
1411 | };
1412 | 
1413 | /*  MPEG audio controls specific to multiplexed streams  */
1414 | #define V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ 	(V4L2_CID_MPEG_BASE+100)
1415 | enum v4l2_mpeg_audio_sampling_freq {
1416 | 	V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100 = 0,
1417 | 	V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000 = 1,
1418 | 	V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000 = 2,
1419 | };
1420 | #define V4L2_CID_MPEG_AUDIO_ENCODING 		(V4L2_CID_MPEG_BASE+101)
1421 | enum v4l2_mpeg_audio_encoding {
1422 | 	V4L2_MPEG_AUDIO_ENCODING_LAYER_1 = 0,
1423 | 	V4L2_MPEG_AUDIO_ENCODING_LAYER_2 = 1,
1424 | 	V4L2_MPEG_AUDIO_ENCODING_LAYER_3 = 2,
1425 | 	V4L2_MPEG_AUDIO_ENCODING_AAC     = 3,
1426 | 	V4L2_MPEG_AUDIO_ENCODING_AC3     = 4,
1427 | };
1428 | #define V4L2_CID_MPEG_AUDIO_L1_BITRATE 		(V4L2_CID_MPEG_BASE+102)
1429 | enum v4l2_mpeg_audio_l1_bitrate {
1430 | 	V4L2_MPEG_AUDIO_L1_BITRATE_32K  = 0,
1431 | 	V4L2_MPEG_AUDIO_L1_BITRATE_64K  = 1,
1432 | 	V4L2_MPEG_AUDIO_L1_BITRATE_96K  = 2,
1433 | 	V4L2_MPEG_AUDIO_L1_BITRATE_128K = 3,
1434 | 	V4L2_MPEG_AUDIO_L1_BITRATE_160K = 4,
1435 | 	V4L2_MPEG_AUDIO_L1_BITRATE_192K = 5,
1436 | 	V4L2_MPEG_AUDIO_L1_BITRATE_224K = 6,
1437 | 	V4L2_MPEG_AUDIO_L1_BITRATE_256K = 7,
1438 | 	V4L2_MPEG_AUDIO_L1_BITRATE_288K = 8,
1439 | 	V4L2_MPEG_AUDIO_L1_BITRATE_320K = 9,
1440 | 	V4L2_MPEG_AUDIO_L1_BITRATE_352K = 10,
1441 | 	V4L2_MPEG_AUDIO_L1_BITRATE_384K = 11,
1442 | 	V4L2_MPEG_AUDIO_L1_BITRATE_416K = 12,
1443 | 	V4L2_MPEG_AUDIO_L1_BITRATE_448K = 13,
1444 | };
1445 | #define V4L2_CID_MPEG_AUDIO_L2_BITRATE 		(V4L2_CID_MPEG_BASE+103)
1446 | enum v4l2_mpeg_audio_l2_bitrate {
1447 | 	V4L2_MPEG_AUDIO_L2_BITRATE_32K  = 0,
1448 | 	V4L2_MPEG_AUDIO_L2_BITRATE_48K  = 1,
1449 | 	V4L2_MPEG_AUDIO_L2_BITRATE_56K  = 2,
1450 | 	V4L2_MPEG_AUDIO_L2_BITRATE_64K  = 3,
1451 | 	V4L2_MPEG_AUDIO_L2_BITRATE_80K  = 4,
1452 | 	V4L2_MPEG_AUDIO_L2_BITRATE_96K  = 5,
1453 | 	V4L2_MPEG_AUDIO_L2_BITRATE_112K = 6,
1454 | 	V4L2_MPEG_AUDIO_L2_BITRATE_128K = 7,
1455 | 	V4L2_MPEG_AUDIO_L2_BITRATE_160K = 8,
1456 | 	V4L2_MPEG_AUDIO_L2_BITRATE_192K = 9,
1457 | 	V4L2_MPEG_AUDIO_L2_BITRATE_224K = 10,
1458 | 	V4L2_MPEG_AUDIO_L2_BITRATE_256K = 11,
1459 | 	V4L2_MPEG_AUDIO_L2_BITRATE_320K = 12,
1460 | 	V4L2_MPEG_AUDIO_L2_BITRATE_384K = 13,
1461 | };
1462 | #define V4L2_CID_MPEG_AUDIO_L3_BITRATE 		(V4L2_CID_MPEG_BASE+104)
1463 | enum v4l2_mpeg_audio_l3_bitrate {
1464 | 	V4L2_MPEG_AUDIO_L3_BITRATE_32K  = 0,
1465 | 	V4L2_MPEG_AUDIO_L3_BITRATE_40K  = 1,
1466 | 	V4L2_MPEG_AUDIO_L3_BITRATE_48K  = 2,
1467 | 	V4L2_MPEG_AUDIO_L3_BITRATE_56K  = 3,
1468 | 	V4L2_MPEG_AUDIO_L3_BITRATE_64K  = 4,
1469 | 	V4L2_MPEG_AUDIO_L3_BITRATE_80K  = 5,
1470 | 	V4L2_MPEG_AUDIO_L3_BITRATE_96K  = 6,
1471 | 	V4L2_MPEG_AUDIO_L3_BITRATE_112K = 7,
1472 | 	V4L2_MPEG_AUDIO_L3_BITRATE_128K = 8,
1473 | 	V4L2_MPEG_AUDIO_L3_BITRATE_160K = 9,
1474 | 	V4L2_MPEG_AUDIO_L3_BITRATE_192K = 10,
1475 | 	V4L2_MPEG_AUDIO_L3_BITRATE_224K = 11,
1476 | 	V4L2_MPEG_AUDIO_L3_BITRATE_256K = 12,
1477 | 	V4L2_MPEG_AUDIO_L3_BITRATE_320K = 13,
1478 | };
1479 | #define V4L2_CID_MPEG_AUDIO_MODE 		(V4L2_CID_MPEG_BASE+105)
1480 | enum v4l2_mpeg_audio_mode {
1481 | 	V4L2_MPEG_AUDIO_MODE_STEREO       = 0,
1482 | 	V4L2_MPEG_AUDIO_MODE_JOINT_STEREO = 1,
1483 | 	V4L2_MPEG_AUDIO_MODE_DUAL         = 2,
1484 | 	V4L2_MPEG_AUDIO_MODE_MONO         = 3,
1485 | };
1486 | #define V4L2_CID_MPEG_AUDIO_MODE_EXTENSION 	(V4L2_CID_MPEG_BASE+106)
1487 | enum v4l2_mpeg_audio_mode_extension {
1488 | 	V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4  = 0,
1489 | 	V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_8  = 1,
1490 | 	V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_12 = 2,
1491 | 	V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16 = 3,
1492 | };
1493 | #define V4L2_CID_MPEG_AUDIO_EMPHASIS 		(V4L2_CID_MPEG_BASE+107)
1494 | enum v4l2_mpeg_audio_emphasis {
1495 | 	V4L2_MPEG_AUDIO_EMPHASIS_NONE         = 0,
1496 | 	V4L2_MPEG_AUDIO_EMPHASIS_50_DIV_15_uS = 1,
1497 | 	V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17    = 2,
1498 | };
1499 | #define V4L2_CID_MPEG_AUDIO_CRC 		(V4L2_CID_MPEG_BASE+108)
1500 | enum v4l2_mpeg_audio_crc {
1501 | 	V4L2_MPEG_AUDIO_CRC_NONE  = 0,
1502 | 	V4L2_MPEG_AUDIO_CRC_CRC16 = 1,
1503 | };
1504 | #define V4L2_CID_MPEG_AUDIO_MUTE 		(V4L2_CID_MPEG_BASE+109)
1505 | #define V4L2_CID_MPEG_AUDIO_AAC_BITRATE		(V4L2_CID_MPEG_BASE+110)
1506 | #define V4L2_CID_MPEG_AUDIO_AC3_BITRATE		(V4L2_CID_MPEG_BASE+111)
1507 | enum v4l2_mpeg_audio_ac3_bitrate {
1508 | 	V4L2_MPEG_AUDIO_AC3_BITRATE_32K  = 0,
1509 | 	V4L2_MPEG_AUDIO_AC3_BITRATE_40K  = 1,
1510 | 	V4L2_MPEG_AUDIO_AC3_BITRATE_48K  = 2,
1511 | 	V4L2_MPEG_AUDIO_AC3_BITRATE_56K  = 3,
1512 | 	V4L2_MPEG_AUDIO_AC3_BITRATE_64K  = 4,
1513 | 	V4L2_MPEG_AUDIO_AC3_BITRATE_80K  = 5,
1514 | 	V4L2_MPEG_AUDIO_AC3_BITRATE_96K  = 6,
1515 | 	V4L2_MPEG_AUDIO_AC3_BITRATE_112K = 7,
1516 | 	V4L2_MPEG_AUDIO_AC3_BITRATE_128K = 8,
1517 | 	V4L2_MPEG_AUDIO_AC3_BITRATE_160K = 9,
1518 | 	V4L2_MPEG_AUDIO_AC3_BITRATE_192K = 10,
1519 | 	V4L2_MPEG_AUDIO_AC3_BITRATE_224K = 11,
1520 | 	V4L2_MPEG_AUDIO_AC3_BITRATE_256K = 12,
1521 | 	V4L2_MPEG_AUDIO_AC3_BITRATE_320K = 13,
1522 | 	V4L2_MPEG_AUDIO_AC3_BITRATE_384K = 14,
1523 | 	V4L2_MPEG_AUDIO_AC3_BITRATE_448K = 15,
1524 | 	V4L2_MPEG_AUDIO_AC3_BITRATE_512K = 16,
1525 | 	V4L2_MPEG_AUDIO_AC3_BITRATE_576K = 17,
1526 | 	V4L2_MPEG_AUDIO_AC3_BITRATE_640K = 18,
1527 | };
1528 | #define V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK	(V4L2_CID_MPEG_BASE+112)
1529 | enum v4l2_mpeg_audio_dec_playback {
1530 | 	V4L2_MPEG_AUDIO_DEC_PLAYBACK_AUTO	    = 0,
1531 | 	V4L2_MPEG_AUDIO_DEC_PLAYBACK_STEREO	    = 1,
1532 | 	V4L2_MPEG_AUDIO_DEC_PLAYBACK_LEFT	    = 2,
1533 | 	V4L2_MPEG_AUDIO_DEC_PLAYBACK_RIGHT	    = 3,
1534 | 	V4L2_MPEG_AUDIO_DEC_PLAYBACK_MONO	    = 4,
1535 | 	V4L2_MPEG_AUDIO_DEC_PLAYBACK_SWAPPED_STEREO = 5,
1536 | };
1537 | #define V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK (V4L2_CID_MPEG_BASE+113)
1538 | 
1539 | /*  MPEG video controls specific to multiplexed streams */
1540 | #define V4L2_CID_MPEG_VIDEO_ENCODING 		(V4L2_CID_MPEG_BASE+200)
1541 | enum v4l2_mpeg_video_encoding {
1542 | 	V4L2_MPEG_VIDEO_ENCODING_MPEG_1     = 0,
1543 | 	V4L2_MPEG_VIDEO_ENCODING_MPEG_2     = 1,
1544 | 	V4L2_MPEG_VIDEO_ENCODING_MPEG_4_AVC = 2,
1545 | };
1546 | #define V4L2_CID_MPEG_VIDEO_ASPECT 		(V4L2_CID_MPEG_BASE+201)
1547 | enum v4l2_mpeg_video_aspect {
1548 | 	V4L2_MPEG_VIDEO_ASPECT_1x1     = 0,
1549 | 	V4L2_MPEG_VIDEO_ASPECT_4x3     = 1,
1550 | 	V4L2_MPEG_VIDEO_ASPECT_16x9    = 2,
1551 | 	V4L2_MPEG_VIDEO_ASPECT_221x100 = 3,
1552 | };
1553 | #define V4L2_CID_MPEG_VIDEO_B_FRAMES 		(V4L2_CID_MPEG_BASE+202)
1554 | #define V4L2_CID_MPEG_VIDEO_GOP_SIZE 		(V4L2_CID_MPEG_BASE+203)
1555 | #define V4L2_CID_MPEG_VIDEO_GOP_CLOSURE 	(V4L2_CID_MPEG_BASE+204)
1556 | #define V4L2_CID_MPEG_VIDEO_PULLDOWN 		(V4L2_CID_MPEG_BASE+205)
1557 | #define V4L2_CID_MPEG_VIDEO_BITRATE_MODE 	(V4L2_CID_MPEG_BASE+206)
1558 | enum v4l2_mpeg_video_bitrate_mode {
1559 | 	V4L2_MPEG_VIDEO_BITRATE_MODE_VBR = 0,
1560 | 	V4L2_MPEG_VIDEO_BITRATE_MODE_CBR = 1,
1561 | };
1562 | #define V4L2_CID_MPEG_VIDEO_BITRATE 		(V4L2_CID_MPEG_BASE+207)
1563 | #define V4L2_CID_MPEG_VIDEO_BITRATE_PEAK 	(V4L2_CID_MPEG_BASE+208)
1564 | #define V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION (V4L2_CID_MPEG_BASE+209)
1565 | #define V4L2_CID_MPEG_VIDEO_MUTE 		(V4L2_CID_MPEG_BASE+210)
1566 | #define V4L2_CID_MPEG_VIDEO_MUTE_YUV 		(V4L2_CID_MPEG_BASE+211)
1567 | #define V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE		(V4L2_CID_MPEG_BASE+212)
1568 | #define V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER	(V4L2_CID_MPEG_BASE+213)
1569 | #define V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB		(V4L2_CID_MPEG_BASE+214)
1570 | #define V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE			(V4L2_CID_MPEG_BASE+215)
1571 | #define V4L2_CID_MPEG_VIDEO_HEADER_MODE				(V4L2_CID_MPEG_BASE+216)
1572 | enum v4l2_mpeg_video_header_mode {
1573 | 	V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE			= 0,
1574 | 	V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME	= 1,
1575 | 
1576 | };
1577 | #define V4L2_CID_MPEG_VIDEO_MAX_REF_PIC			(V4L2_CID_MPEG_BASE+217)
1578 | #define V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE		(V4L2_CID_MPEG_BASE+218)
1579 | #define V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES	(V4L2_CID_MPEG_BASE+219)
1580 | #define V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB		(V4L2_CID_MPEG_BASE+220)
1581 | #define V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE		(V4L2_CID_MPEG_BASE+221)
1582 | enum v4l2_mpeg_video_multi_slice_mode {
1583 | 	V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE		= 0,
1584 | 	V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_MB		= 1,
1585 | 	V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_BYTES	= 2,
1586 | };
1587 | #define V4L2_CID_MPEG_VIDEO_VBV_SIZE			(V4L2_CID_MPEG_BASE+222)
1588 | #define V4L2_CID_MPEG_VIDEO_DEC_PTS			(V4L2_CID_MPEG_BASE+223)
1589 | #define V4L2_CID_MPEG_VIDEO_DEC_FRAME			(V4L2_CID_MPEG_BASE+224)
1590 | 
1591 | #define V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP		(V4L2_CID_MPEG_BASE+300)
1592 | #define V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP		(V4L2_CID_MPEG_BASE+301)
1593 | #define V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP		(V4L2_CID_MPEG_BASE+302)
1594 | #define V4L2_CID_MPEG_VIDEO_H263_MIN_QP			(V4L2_CID_MPEG_BASE+303)
1595 | #define V4L2_CID_MPEG_VIDEO_H263_MAX_QP			(V4L2_CID_MPEG_BASE+304)
1596 | #define V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP		(V4L2_CID_MPEG_BASE+350)
1597 | #define V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP		(V4L2_CID_MPEG_BASE+351)
1598 | #define V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP		(V4L2_CID_MPEG_BASE+352)
1599 | #define V4L2_CID_MPEG_VIDEO_H264_MIN_QP			(V4L2_CID_MPEG_BASE+353)
1600 | #define V4L2_CID_MPEG_VIDEO_H264_MAX_QP			(V4L2_CID_MPEG_BASE+354)
1601 | #define V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM		(V4L2_CID_MPEG_BASE+355)
1602 | #define V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE		(V4L2_CID_MPEG_BASE+356)
1603 | #define V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE		(V4L2_CID_MPEG_BASE+357)
1604 | enum v4l2_mpeg_video_h264_entropy_mode {
1605 | 	V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC	= 0,
1606 | 	V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC	= 1,
1607 | };
1608 | #define V4L2_CID_MPEG_VIDEO_H264_I_PERIOD		(V4L2_CID_MPEG_BASE+358)
1609 | #define V4L2_CID_MPEG_VIDEO_H264_LEVEL			(V4L2_CID_MPEG_BASE+359)
1610 | enum v4l2_mpeg_video_h264_level {
1611 | 	V4L2_MPEG_VIDEO_H264_LEVEL_1_0	= 0,
1612 | 	V4L2_MPEG_VIDEO_H264_LEVEL_1B	= 1,
1613 | 	V4L2_MPEG_VIDEO_H264_LEVEL_1_1	= 2,
1614 | 	V4L2_MPEG_VIDEO_H264_LEVEL_1_2	= 3,
1615 | 	V4L2_MPEG_VIDEO_H264_LEVEL_1_3	= 4,
1616 | 	V4L2_MPEG_VIDEO_H264_LEVEL_2_0	= 5,
1617 | 	V4L2_MPEG_VIDEO_H264_LEVEL_2_1	= 6,
1618 | 	V4L2_MPEG_VIDEO_H264_LEVEL_2_2	= 7,
1619 | 	V4L2_MPEG_VIDEO_H264_LEVEL_3_0	= 8,
1620 | 	V4L2_MPEG_VIDEO_H264_LEVEL_3_1	= 9,
1621 | 	V4L2_MPEG_VIDEO_H264_LEVEL_3_2	= 10,
1622 | 	V4L2_MPEG_VIDEO_H264_LEVEL_4_0	= 11,
1623 | 	V4L2_MPEG_VIDEO_H264_LEVEL_4_1	= 12,
1624 | 	V4L2_MPEG_VIDEO_H264_LEVEL_4_2	= 13,
1625 | 	V4L2_MPEG_VIDEO_H264_LEVEL_5_0	= 14,
1626 | 	V4L2_MPEG_VIDEO_H264_LEVEL_5_1	= 15,
1627 | };
1628 | #define V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA	(V4L2_CID_MPEG_BASE+360)
1629 | #define V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA	(V4L2_CID_MPEG_BASE+361)
1630 | #define V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE	(V4L2_CID_MPEG_BASE+362)
1631 | enum v4l2_mpeg_video_h264_loop_filter_mode {
1632 | 	V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED				= 0,
1633 | 	V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED				= 1,
1634 | 	V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED_AT_SLICE_BOUNDARY	= 2,
1635 | };
1636 | #define V4L2_CID_MPEG_VIDEO_H264_PROFILE		(V4L2_CID_MPEG_BASE+363)
1637 | enum v4l2_mpeg_video_h264_profile {
1638 | 	V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE			= 0,
1639 | 	V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE	= 1,
1640 | 	V4L2_MPEG_VIDEO_H264_PROFILE_MAIN			= 2,
1641 | 	V4L2_MPEG_VIDEO_H264_PROFILE_EXTENDED			= 3,
1642 | 	V4L2_MPEG_VIDEO_H264_PROFILE_HIGH			= 4,
1643 | 	V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_10			= 5,
1644 | 	V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_422			= 6,
1645 | 	V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_444_PREDICTIVE	= 7,
1646 | 	V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_10_INTRA		= 8,
1647 | 	V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_422_INTRA		= 9,
1648 | 	V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_444_INTRA		= 10,
1649 | 	V4L2_MPEG_VIDEO_H264_PROFILE_CAVLC_444_INTRA		= 11,
1650 | 	V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_BASELINE		= 12,
1651 | 	V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_HIGH		= 13,
1652 | 	V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_HIGH_INTRA	= 14,
1653 | 	V4L2_MPEG_VIDEO_H264_PROFILE_STEREO_HIGH		= 15,
1654 | 	V4L2_MPEG_VIDEO_H264_PROFILE_MULTIVIEW_HIGH		= 16,
1655 | };
1656 | #define V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT	(V4L2_CID_MPEG_BASE+364)
1657 | #define V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH	(V4L2_CID_MPEG_BASE+365)
1658 | #define V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE		(V4L2_CID_MPEG_BASE+366)
1659 | #define V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC		(V4L2_CID_MPEG_BASE+367)
1660 | enum v4l2_mpeg_video_h264_vui_sar_idc {
1661 | 	V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_UNSPECIFIED	= 0,
1662 | 	V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_1x1		= 1,
1663 | 	V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_12x11		= 2,
1664 | 	V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_10x11		= 3,
1665 | 	V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_16x11		= 4,
1666 | 	V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_40x33		= 5,
1667 | 	V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_24x11		= 6,
1668 | 	V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_20x11		= 7,
1669 | 	V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_32x11		= 8,
1670 | 	V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_80x33		= 9,
1671 | 	V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_18x11		= 10,
1672 | 	V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_15x11		= 11,
1673 | 	V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_64x33		= 12,
1674 | 	V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_160x99		= 13,
1675 | 	V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_4x3		= 14,
1676 | 	V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_3x2		= 15,
1677 | 	V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_2x1		= 16,
1678 | 	V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED	= 17,
1679 | };
1680 | #define V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP	(V4L2_CID_MPEG_BASE+400)
1681 | #define V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP	(V4L2_CID_MPEG_BASE+401)
1682 | #define V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP	(V4L2_CID_MPEG_BASE+402)
1683 | #define V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP	(V4L2_CID_MPEG_BASE+403)
1684 | #define V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP	(V4L2_CID_MPEG_BASE+404)
1685 | #define V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL		(V4L2_CID_MPEG_BASE+405)
1686 | enum v4l2_mpeg_video_mpeg4_level {
1687 | 	V4L2_MPEG_VIDEO_MPEG4_LEVEL_0	= 0,
1688 | 	V4L2_MPEG_VIDEO_MPEG4_LEVEL_0B	= 1,
1689 | 	V4L2_MPEG_VIDEO_MPEG4_LEVEL_1	= 2,
1690 | 	V4L2_MPEG_VIDEO_MPEG4_LEVEL_2	= 3,
1691 | 	V4L2_MPEG_VIDEO_MPEG4_LEVEL_3	= 4,
1692 | 	V4L2_MPEG_VIDEO_MPEG4_LEVEL_3B	= 5,
1693 | 	V4L2_MPEG_VIDEO_MPEG4_LEVEL_4	= 6,
1694 | 	V4L2_MPEG_VIDEO_MPEG4_LEVEL_5	= 7,
1695 | };
1696 | #define V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE	(V4L2_CID_MPEG_BASE+406)
1697 | enum v4l2_mpeg_video_mpeg4_profile {
1698 | 	V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE				= 0,
1699 | 	V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_SIMPLE			= 1,
1700 | 	V4L2_MPEG_VIDEO_MPEG4_PROFILE_CORE				= 2,
1701 | 	V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE_SCALABLE			= 3,
1702 | 	V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY	= 4,
1703 | };
1704 | #define V4L2_CID_MPEG_VIDEO_MPEG4_QPEL		(V4L2_CID_MPEG_BASE+407)
1705 | 
1706 | /*  MPEG-class control IDs specific to the CX2341x driver as defined by V4L2 */
1707 | #define V4L2_CID_MPEG_CX2341X_BASE 				(V4L2_CTRL_CLASS_MPEG | 0x1000)
1708 | #define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE 	(V4L2_CID_MPEG_CX2341X_BASE+0)
1709 | enum v4l2_mpeg_cx2341x_video_spatial_filter_mode {
1710 | 	V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL = 0,
1711 | 	V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO   = 1,
1712 | };
1713 | #define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER 		(V4L2_CID_MPEG_CX2341X_BASE+1)
1714 | #define V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE 	(V4L2_CID_MPEG_CX2341X_BASE+2)
1715 | enum v4l2_mpeg_cx2341x_video_luma_spatial_filter_type {
1716 | 	V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_OFF                  = 0,
1717 | 	V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_1D_HOR               = 1,
1718 | 	V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_1D_VERT              = 2,
1719 | 	V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_2D_HV_SEPARABLE      = 3,
1720 | 	V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_2D_SYM_NON_SEPARABLE = 4,
1721 | };
1722 | #define V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE 	(V4L2_CID_MPEG_CX2341X_BASE+3)
1723 | enum v4l2_mpeg_cx2341x_video_chroma_spatial_filter_type {
1724 | 	V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_OFF    = 0,
1725 | 	V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR = 1,
1726 | };
1727 | #define V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE 	(V4L2_CID_MPEG_CX2341X_BASE+4)
1728 | enum v4l2_mpeg_cx2341x_video_temporal_filter_mode {
1729 | 	V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL = 0,
1730 | 	V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO   = 1,
1731 | };
1732 | #define V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER 		(V4L2_CID_MPEG_CX2341X_BASE+5)
1733 | #define V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE 		(V4L2_CID_MPEG_CX2341X_BASE+6)
1734 | enum v4l2_mpeg_cx2341x_video_median_filter_type {
1735 | 	V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF      = 0,
1736 | 	V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_HOR      = 1,
1737 | 	V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_VERT     = 2,
1738 | 	V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_HOR_VERT = 3,
1739 | 	V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_DIAG     = 4,
1740 | };
1741 | #define V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM 	(V4L2_CID_MPEG_CX2341X_BASE+7)
1742 | #define V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP 	(V4L2_CID_MPEG_CX2341X_BASE+8)
1743 | #define V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM	(V4L2_CID_MPEG_CX2341X_BASE+9)
1744 | #define V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP 	(V4L2_CID_MPEG_CX2341X_BASE+10)
1745 | #define V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS 	(V4L2_CID_MPEG_CX2341X_BASE+11)
1746 | 
1747 | /*  MPEG-class control IDs specific to the Samsung MFC 5.1 driver as defined by V4L2 */
1748 | #define V4L2_CID_MPEG_MFC51_BASE				(V4L2_CTRL_CLASS_MPEG | 0x1100)
1749 | 
1750 | #define V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY		(V4L2_CID_MPEG_MFC51_BASE+0)
1751 | #define V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY_ENABLE	(V4L2_CID_MPEG_MFC51_BASE+1)
1752 | #define V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE			(V4L2_CID_MPEG_MFC51_BASE+2)
1753 | enum v4l2_mpeg_mfc51_video_frame_skip_mode {
1754 | 	V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_DISABLED		= 0,
1755 | 	V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_LEVEL_LIMIT	= 1,
1756 | 	V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT		= 2,
1757 | };
1758 | #define V4L2_CID_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE			(V4L2_CID_MPEG_MFC51_BASE+3)
1759 | enum v4l2_mpeg_mfc51_video_force_frame_type {
1760 | 	V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_DISABLED		= 0,
1761 | 	V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_I_FRAME		= 1,
1762 | 	V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_NOT_CODED	= 2,
1763 | };
1764 | #define V4L2_CID_MPEG_MFC51_VIDEO_PADDING				(V4L2_CID_MPEG_MFC51_BASE+4)
1765 | #define V4L2_CID_MPEG_MFC51_VIDEO_PADDING_YUV				(V4L2_CID_MPEG_MFC51_BASE+5)
1766 | #define V4L2_CID_MPEG_MFC51_VIDEO_RC_FIXED_TARGET_BIT			(V4L2_CID_MPEG_MFC51_BASE+6)
1767 | #define V4L2_CID_MPEG_MFC51_VIDEO_RC_REACTION_COEFF			(V4L2_CID_MPEG_MFC51_BASE+7)
1768 | #define V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_ACTIVITY		(V4L2_CID_MPEG_MFC51_BASE+50)
1769 | #define V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_DARK			(V4L2_CID_MPEG_MFC51_BASE+51)
1770 | #define V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_SMOOTH		(V4L2_CID_MPEG_MFC51_BASE+52)
1771 | #define V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_STATIC		(V4L2_CID_MPEG_MFC51_BASE+53)
1772 | #define V4L2_CID_MPEG_MFC51_VIDEO_H264_NUM_REF_PIC_FOR_P		(V4L2_CID_MPEG_MFC51_BASE+54)
1773 | 
1774 | /*  Camera class control IDs */
1775 | #define V4L2_CID_CAMERA_CLASS_BASE 	(V4L2_CTRL_CLASS_CAMERA | 0x900)
1776 | #define V4L2_CID_CAMERA_CLASS 		(V4L2_CTRL_CLASS_CAMERA | 1)
1777 | 
1778 | #define V4L2_CID_EXPOSURE_AUTO			(V4L2_CID_CAMERA_CLASS_BASE+1)
1779 | enum  v4l2_exposure_auto_type {
1780 | 	V4L2_EXPOSURE_AUTO = 0,
1781 | 	V4L2_EXPOSURE_MANUAL = 1,
1782 | 	V4L2_EXPOSURE_SHUTTER_PRIORITY = 2,
1783 | 	V4L2_EXPOSURE_APERTURE_PRIORITY = 3
1784 | };
1785 | #define V4L2_CID_EXPOSURE_ABSOLUTE		(V4L2_CID_CAMERA_CLASS_BASE+2)
1786 | #define V4L2_CID_EXPOSURE_AUTO_PRIORITY		(V4L2_CID_CAMERA_CLASS_BASE+3)
1787 | 
1788 | #define V4L2_CID_PAN_RELATIVE			(V4L2_CID_CAMERA_CLASS_BASE+4)
1789 | #define V4L2_CID_TILT_RELATIVE			(V4L2_CID_CAMERA_CLASS_BASE+5)
1790 | #define V4L2_CID_PAN_RESET			(V4L2_CID_CAMERA_CLASS_BASE+6)
1791 | #define V4L2_CID_TILT_RESET			(V4L2_CID_CAMERA_CLASS_BASE+7)
1792 | 
1793 | #define V4L2_CID_PAN_ABSOLUTE			(V4L2_CID_CAMERA_CLASS_BASE+8)
1794 | #define V4L2_CID_TILT_ABSOLUTE			(V4L2_CID_CAMERA_CLASS_BASE+9)
1795 | 
1796 | #define V4L2_CID_FOCUS_ABSOLUTE			(V4L2_CID_CAMERA_CLASS_BASE+10)
1797 | #define V4L2_CID_FOCUS_RELATIVE			(V4L2_CID_CAMERA_CLASS_BASE+11)
1798 | #define V4L2_CID_FOCUS_AUTO			(V4L2_CID_CAMERA_CLASS_BASE+12)
1799 | 
1800 | #define V4L2_CID_ZOOM_ABSOLUTE			(V4L2_CID_CAMERA_CLASS_BASE+13)
1801 | #define V4L2_CID_ZOOM_RELATIVE			(V4L2_CID_CAMERA_CLASS_BASE+14)
1802 | #define V4L2_CID_ZOOM_CONTINUOUS		(V4L2_CID_CAMERA_CLASS_BASE+15)
1803 | 
1804 | #define V4L2_CID_PRIVACY			(V4L2_CID_CAMERA_CLASS_BASE+16)
1805 | 
1806 | #define V4L2_CID_IRIS_ABSOLUTE			(V4L2_CID_CAMERA_CLASS_BASE+17)
1807 | #define V4L2_CID_IRIS_RELATIVE			(V4L2_CID_CAMERA_CLASS_BASE+18)
1808 | 
1809 | #define V4L2_CID_AUTO_EXPOSURE_BIAS		(V4L2_CID_CAMERA_CLASS_BASE+19)
1810 | 
1811 | #define V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE	(V4L2_CID_CAMERA_CLASS_BASE+20)
1812 | enum v4l2_auto_n_preset_white_balance {
1813 | 	V4L2_WHITE_BALANCE_MANUAL		= 0,
1814 | 	V4L2_WHITE_BALANCE_AUTO			= 1,
1815 | 	V4L2_WHITE_BALANCE_INCANDESCENT		= 2,
1816 | 	V4L2_WHITE_BALANCE_FLUORESCENT		= 3,
1817 | 	V4L2_WHITE_BALANCE_FLUORESCENT_H	= 4,
1818 | 	V4L2_WHITE_BALANCE_HORIZON		= 5,
1819 | 	V4L2_WHITE_BALANCE_DAYLIGHT		= 6,
1820 | 	V4L2_WHITE_BALANCE_FLASH		= 7,
1821 | 	V4L2_WHITE_BALANCE_CLOUDY		= 8,
1822 | 	V4L2_WHITE_BALANCE_SHADE		= 9,
1823 | };
1824 | 
1825 | #define V4L2_CID_WIDE_DYNAMIC_RANGE		(V4L2_CID_CAMERA_CLASS_BASE+21)
1826 | #define V4L2_CID_IMAGE_STABILIZATION		(V4L2_CID_CAMERA_CLASS_BASE+22)
1827 | 
1828 | #define V4L2_CID_ISO_SENSITIVITY		(V4L2_CID_CAMERA_CLASS_BASE+23)
1829 | #define V4L2_CID_ISO_SENSITIVITY_AUTO		(V4L2_CID_CAMERA_CLASS_BASE+24)
1830 | enum v4l2_iso_sensitivity_auto_type {
1831 | 	V4L2_ISO_SENSITIVITY_MANUAL		= 0,
1832 | 	V4L2_ISO_SENSITIVITY_AUTO		= 1,
1833 | };
1834 | 
1835 | #define V4L2_CID_EXPOSURE_METERING		(V4L2_CID_CAMERA_CLASS_BASE+25)
1836 | enum v4l2_exposure_metering {
1837 | 	V4L2_EXPOSURE_METERING_AVERAGE		= 0,
1838 | 	V4L2_EXPOSURE_METERING_CENTER_WEIGHTED	= 1,
1839 | 	V4L2_EXPOSURE_METERING_SPOT		= 2,
1840 | };
1841 | 
1842 | #define V4L2_CID_SCENE_MODE			(V4L2_CID_CAMERA_CLASS_BASE+26)
1843 | enum v4l2_scene_mode {
1844 | 	V4L2_SCENE_MODE_NONE			= 0,
1845 | 	V4L2_SCENE_MODE_BACKLIGHT		= 1,
1846 | 	V4L2_SCENE_MODE_BEACH_SNOW		= 2,
1847 | 	V4L2_SCENE_MODE_CANDLE_LIGHT		= 3,
1848 | 	V4L2_SCENE_MODE_DAWN_DUSK		= 4,
1849 | 	V4L2_SCENE_MODE_FALL_COLORS		= 5,
1850 | 	V4L2_SCENE_MODE_FIREWORKS		= 6,
1851 | 	V4L2_SCENE_MODE_LANDSCAPE		= 7,
1852 | 	V4L2_SCENE_MODE_NIGHT			= 8,
1853 | 	V4L2_SCENE_MODE_PARTY_INDOOR		= 9,
1854 | 	V4L2_SCENE_MODE_PORTRAIT		= 10,
1855 | 	V4L2_SCENE_MODE_SPORTS			= 11,
1856 | 	V4L2_SCENE_MODE_SUNSET			= 12,
1857 | 	V4L2_SCENE_MODE_TEXT			= 13,
1858 | };
1859 | 
1860 | #define V4L2_CID_3A_LOCK			(V4L2_CID_CAMERA_CLASS_BASE+27)
1861 | #define V4L2_LOCK_EXPOSURE			(1 << 0)
1862 | #define V4L2_LOCK_WHITE_BALANCE			(1 << 1)
1863 | #define V4L2_LOCK_FOCUS				(1 << 2)
1864 | 
1865 | #define V4L2_CID_AUTO_FOCUS_START		(V4L2_CID_CAMERA_CLASS_BASE+28)
1866 | #define V4L2_CID_AUTO_FOCUS_STOP		(V4L2_CID_CAMERA_CLASS_BASE+29)
1867 | #define V4L2_CID_AUTO_FOCUS_STATUS		(V4L2_CID_CAMERA_CLASS_BASE+30)
1868 | #define V4L2_AUTO_FOCUS_STATUS_IDLE		(0 << 0)
1869 | #define V4L2_AUTO_FOCUS_STATUS_BUSY		(1 << 0)
1870 | #define V4L2_AUTO_FOCUS_STATUS_REACHED		(1 << 1)
1871 | #define V4L2_AUTO_FOCUS_STATUS_FAILED		(1 << 2)
1872 | 
1873 | #define V4L2_CID_AUTO_FOCUS_RANGE		(V4L2_CID_CAMERA_CLASS_BASE+31)
1874 | enum v4l2_auto_focus_range {
1875 | 	V4L2_AUTO_FOCUS_RANGE_AUTO		= 0,
1876 | 	V4L2_AUTO_FOCUS_RANGE_NORMAL		= 1,
1877 | 	V4L2_AUTO_FOCUS_RANGE_MACRO		= 2,
1878 | 	V4L2_AUTO_FOCUS_RANGE_INFINITY		= 3,
1879 | };
1880 | 
1881 | 
1882 | /* FM Modulator class control IDs */
1883 | #define V4L2_CID_FM_TX_CLASS_BASE		(V4L2_CTRL_CLASS_FM_TX | 0x900)
1884 | #define V4L2_CID_FM_TX_CLASS			(V4L2_CTRL_CLASS_FM_TX | 1)
1885 | 
1886 | #define V4L2_CID_RDS_TX_DEVIATION		(V4L2_CID_FM_TX_CLASS_BASE + 1)
1887 | #define V4L2_CID_RDS_TX_PI			(V4L2_CID_FM_TX_CLASS_BASE + 2)
1888 | #define V4L2_CID_RDS_TX_PTY			(V4L2_CID_FM_TX_CLASS_BASE + 3)
1889 | #define V4L2_CID_RDS_TX_PS_NAME			(V4L2_CID_FM_TX_CLASS_BASE + 5)
1890 | #define V4L2_CID_RDS_TX_RADIO_TEXT		(V4L2_CID_FM_TX_CLASS_BASE + 6)
1891 | 
1892 | #define V4L2_CID_AUDIO_LIMITER_ENABLED		(V4L2_CID_FM_TX_CLASS_BASE + 64)
1893 | #define V4L2_CID_AUDIO_LIMITER_RELEASE_TIME	(V4L2_CID_FM_TX_CLASS_BASE + 65)
1894 | #define V4L2_CID_AUDIO_LIMITER_DEVIATION	(V4L2_CID_FM_TX_CLASS_BASE + 66)
1895 | 
1896 | #define V4L2_CID_AUDIO_COMPRESSION_ENABLED	(V4L2_CID_FM_TX_CLASS_BASE + 80)
1897 | #define V4L2_CID_AUDIO_COMPRESSION_GAIN		(V4L2_CID_FM_TX_CLASS_BASE + 81)
1898 | #define V4L2_CID_AUDIO_COMPRESSION_THRESHOLD	(V4L2_CID_FM_TX_CLASS_BASE + 82)
1899 | #define V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME	(V4L2_CID_FM_TX_CLASS_BASE + 83)
1900 | #define V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME	(V4L2_CID_FM_TX_CLASS_BASE + 84)
1901 | 
1902 | #define V4L2_CID_PILOT_TONE_ENABLED		(V4L2_CID_FM_TX_CLASS_BASE + 96)
1903 | #define V4L2_CID_PILOT_TONE_DEVIATION		(V4L2_CID_FM_TX_CLASS_BASE + 97)
1904 | #define V4L2_CID_PILOT_TONE_FREQUENCY		(V4L2_CID_FM_TX_CLASS_BASE + 98)
1905 | 
1906 | #define V4L2_CID_TUNE_PREEMPHASIS		(V4L2_CID_FM_TX_CLASS_BASE + 112)
1907 | enum v4l2_preemphasis {
1908 | 	V4L2_PREEMPHASIS_DISABLED	= 0,
1909 | 	V4L2_PREEMPHASIS_50_uS		= 1,
1910 | 	V4L2_PREEMPHASIS_75_uS		= 2,
1911 | };
1912 | #define V4L2_CID_TUNE_POWER_LEVEL		(V4L2_CID_FM_TX_CLASS_BASE + 113)
1913 | #define V4L2_CID_TUNE_ANTENNA_CAPACITOR		(V4L2_CID_FM_TX_CLASS_BASE + 114)
1914 | 
1915 | /* Flash and privacy (indicator) light controls */
1916 | #define V4L2_CID_FLASH_CLASS_BASE		(V4L2_CTRL_CLASS_FLASH | 0x900)
1917 | #define V4L2_CID_FLASH_CLASS			(V4L2_CTRL_CLASS_FLASH | 1)
1918 | 
1919 | #define V4L2_CID_FLASH_LED_MODE			(V4L2_CID_FLASH_CLASS_BASE + 1)
1920 | enum v4l2_flash_led_mode {
1921 | 	V4L2_FLASH_LED_MODE_NONE,
1922 | 	V4L2_FLASH_LED_MODE_FLASH,
1923 | 	V4L2_FLASH_LED_MODE_TORCH,
1924 | 	V4L2_FLASH_LED_MODE_AUTO,		//add by raymonxiu
1925 | 	V4L2_FLASH_LED_MODE_RED_EYE,	//add by raymonxiu
1926 | };
1927 | 
1928 | #define V4L2_CID_FLASH_STROBE_SOURCE		(V4L2_CID_FLASH_CLASS_BASE + 2)
1929 | enum v4l2_flash_strobe_source {
1930 | 	V4L2_FLASH_STROBE_SOURCE_SOFTWARE,
1931 | 	V4L2_FLASH_STROBE_SOURCE_EXTERNAL,
1932 | };
1933 | 
1934 | #define V4L2_CID_FLASH_STROBE			(V4L2_CID_FLASH_CLASS_BASE + 3)
1935 | #define V4L2_CID_FLASH_STROBE_STOP		(V4L2_CID_FLASH_CLASS_BASE + 4)
1936 | #define V4L2_CID_FLASH_STROBE_STATUS		(V4L2_CID_FLASH_CLASS_BASE + 5)
1937 | 
1938 | #define V4L2_CID_FLASH_TIMEOUT			(V4L2_CID_FLASH_CLASS_BASE + 6)
1939 | #define V4L2_CID_FLASH_INTENSITY		(V4L2_CID_FLASH_CLASS_BASE + 7)
1940 | #define V4L2_CID_FLASH_TORCH_INTENSITY		(V4L2_CID_FLASH_CLASS_BASE + 8)
1941 | #define V4L2_CID_FLASH_INDICATOR_INTENSITY	(V4L2_CID_FLASH_CLASS_BASE + 9)
1942 | 
1943 | #define V4L2_CID_FLASH_FAULT			(V4L2_CID_FLASH_CLASS_BASE + 10)
1944 | #define V4L2_FLASH_FAULT_OVER_VOLTAGE		(1 << 0)
1945 | #define V4L2_FLASH_FAULT_TIMEOUT		(1 << 1)
1946 | #define V4L2_FLASH_FAULT_OVER_TEMPERATURE	(1 << 2)
1947 | #define V4L2_FLASH_FAULT_SHORT_CIRCUIT		(1 << 3)
1948 | #define V4L2_FLASH_FAULT_OVER_CURRENT		(1 << 4)
1949 | #define V4L2_FLASH_FAULT_INDICATOR		(1 << 5)
1950 | 
1951 | #define V4L2_CID_FLASH_CHARGE			(V4L2_CID_FLASH_CLASS_BASE + 11)
1952 | #define V4L2_CID_FLASH_READY			(V4L2_CID_FLASH_CLASS_BASE + 12)
1953 | 
1954 | /*  JPEG-class control IDs defined by V4L2 */
1955 | #define V4L2_CID_JPEG_CLASS_BASE		(V4L2_CTRL_CLASS_JPEG | 0x900)
1956 | #define V4L2_CID_JPEG_CLASS			(V4L2_CTRL_CLASS_JPEG | 1)
1957 | 
1958 | #define	V4L2_CID_JPEG_CHROMA_SUBSAMPLING	(V4L2_CID_JPEG_CLASS_BASE + 1)
1959 | enum v4l2_jpeg_chroma_subsampling {
1960 | 	V4L2_JPEG_CHROMA_SUBSAMPLING_444	= 0,
1961 | 	V4L2_JPEG_CHROMA_SUBSAMPLING_422	= 1,
1962 | 	V4L2_JPEG_CHROMA_SUBSAMPLING_420	= 2,
1963 | 	V4L2_JPEG_CHROMA_SUBSAMPLING_411	= 3,
1964 | 	V4L2_JPEG_CHROMA_SUBSAMPLING_410	= 4,
1965 | 	V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY	= 5,
1966 | };
1967 | #define	V4L2_CID_JPEG_RESTART_INTERVAL		(V4L2_CID_JPEG_CLASS_BASE + 2)
1968 | #define	V4L2_CID_JPEG_COMPRESSION_QUALITY	(V4L2_CID_JPEG_CLASS_BASE + 3)
1969 | 
1970 | #define	V4L2_CID_JPEG_ACTIVE_MARKER		(V4L2_CID_JPEG_CLASS_BASE + 4)
1971 | #define	V4L2_JPEG_ACTIVE_MARKER_APP0		(1 << 0)
1972 | #define	V4L2_JPEG_ACTIVE_MARKER_APP1		(1 << 1)
1973 | #define	V4L2_JPEG_ACTIVE_MARKER_COM		(1 << 16)
1974 | #define	V4L2_JPEG_ACTIVE_MARKER_DQT		(1 << 17)
1975 | #define	V4L2_JPEG_ACTIVE_MARKER_DHT		(1 << 18)
1976 | 
1977 | /*
1978 |  *	T U N I N G
1979 |  */
1980 | struct v4l2_tuner {
1981 | 	__u32                   index;
1982 | 	__u8			name[32];
1983 | 	enum v4l2_tuner_type    type;
1984 | 	__u32			capability;
1985 | 	__u32			rangelow;
1986 | 	__u32			rangehigh;
1987 | 	__u32			rxsubchans;
1988 | 	__u32			audmode;
1989 | 	__s32			signal;
1990 | 	__s32			afc;
1991 | 	__u32			reserved[4];
1992 | };
1993 | 
1994 | struct v4l2_modulator {
1995 | 	__u32			index;
1996 | 	__u8			name[32];
1997 | 	__u32			capability;
1998 | 	__u32			rangelow;
1999 | 	__u32			rangehigh;
2000 | 	__u32			txsubchans;
2001 | 	__u32			reserved[4];
2002 | };
2003 | 
2004 | /*  Flags for the 'capability' field */
2005 | #define V4L2_TUNER_CAP_LOW		0x0001
2006 | #define V4L2_TUNER_CAP_NORM		0x0002
2007 | #define V4L2_TUNER_CAP_STEREO		0x0010
2008 | #define V4L2_TUNER_CAP_LANG2		0x0020
2009 | #define V4L2_TUNER_CAP_SAP		0x0020
2010 | #define V4L2_TUNER_CAP_LANG1		0x0040
2011 | #define V4L2_TUNER_CAP_RDS		0x0080
2012 | #define V4L2_TUNER_CAP_RDS_BLOCK_IO	0x0100
2013 | #define V4L2_TUNER_CAP_RDS_CONTROLS	0x0200
2014 | 
2015 | /*  Flags for the 'rxsubchans' field */
2016 | #define V4L2_TUNER_SUB_MONO		0x0001
2017 | #define V4L2_TUNER_SUB_STEREO		0x0002
2018 | #define V4L2_TUNER_SUB_LANG2		0x0004
2019 | #define V4L2_TUNER_SUB_SAP		0x0004
2020 | #define V4L2_TUNER_SUB_LANG1		0x0008
2021 | #define V4L2_TUNER_SUB_RDS		0x0010
2022 | 
2023 | /*  Values for the 'audmode' field */
2024 | #define V4L2_TUNER_MODE_MONO		0x0000
2025 | #define V4L2_TUNER_MODE_STEREO		0x0001
2026 | #define V4L2_TUNER_MODE_LANG2		0x0002
2027 | #define V4L2_TUNER_MODE_SAP		0x0002
2028 | #define V4L2_TUNER_MODE_LANG1		0x0003
2029 | #define V4L2_TUNER_MODE_LANG1_LANG2	0x0004
2030 | 
2031 | struct v4l2_frequency {
2032 | 	__u32		      tuner;
2033 | 	enum v4l2_tuner_type  type;
2034 | 	__u32		      frequency;
2035 | 	__u32		      reserved[8];
2036 | };
2037 | 
2038 | struct v4l2_hw_freq_seek {
2039 | 	__u32		      tuner;
2040 | 	enum v4l2_tuner_type  type;
2041 | 	__u32		      seek_upward;
2042 | 	__u32		      wrap_around;
2043 | 	__u32		      spacing;
2044 | 	__u32		      reserved[7];
2045 | };
2046 | 
2047 | /*
2048 |  *	R D S
2049 |  */
2050 | 
2051 | struct v4l2_rds_data {
2052 | 	__u8 	lsb;
2053 | 	__u8 	msb;
2054 | 	__u8 	block;
2055 | } __attribute__ ((packed));
2056 | 
2057 | #define V4L2_RDS_BLOCK_MSK 	 0x7
2058 | #define V4L2_RDS_BLOCK_A 	 0
2059 | #define V4L2_RDS_BLOCK_B 	 1
2060 | #define V4L2_RDS_BLOCK_C 	 2
2061 | #define V4L2_RDS_BLOCK_D 	 3
2062 | #define V4L2_RDS_BLOCK_C_ALT 	 4
2063 | #define V4L2_RDS_BLOCK_INVALID 	 7
2064 | 
2065 | #define V4L2_RDS_BLOCK_CORRECTED 0x40
2066 | #define V4L2_RDS_BLOCK_ERROR 	 0x80
2067 | 
2068 | /*
2069 |  *	A U D I O
2070 |  */
2071 | struct v4l2_audio {
2072 | 	__u32	index;
2073 | 	__u8	name[32];
2074 | 	__u32	capability;
2075 | 	__u32	mode;
2076 | 	__u32	reserved[2];
2077 | };
2078 | 
2079 | /*  Flags for the 'capability' field */
2080 | #define V4L2_AUDCAP_STEREO		0x00001
2081 | #define V4L2_AUDCAP_AVL			0x00002
2082 | 
2083 | /*  Flags for the 'mode' field */
2084 | #define V4L2_AUDMODE_AVL		0x00001
2085 | 
2086 | struct v4l2_audioout {
2087 | 	__u32	index;
2088 | 	__u8	name[32];
2089 | 	__u32	capability;
2090 | 	__u32	mode;
2091 | 	__u32	reserved[2];
2092 | };
2093 | 
2094 | /*
2095 |  *	M P E G   S E R V I C E S
2096 |  *
2097 |  *	NOTE: EXPERIMENTAL API
2098 |  */
2099 | #if 1
2100 | #define V4L2_ENC_IDX_FRAME_I    (0)
2101 | #define V4L2_ENC_IDX_FRAME_P    (1)
2102 | #define V4L2_ENC_IDX_FRAME_B    (2)
2103 | #define V4L2_ENC_IDX_FRAME_MASK (0xf)
2104 | 
2105 | struct v4l2_enc_idx_entry {
2106 | 	__u64 offset;
2107 | 	__u64 pts;
2108 | 	__u32 length;
2109 | 	__u32 flags;
2110 | 	__u32 reserved[2];
2111 | };
2112 | 
2113 | #define V4L2_ENC_IDX_ENTRIES (64)
2114 | struct v4l2_enc_idx {
2115 | 	__u32 entries;
2116 | 	__u32 entries_cap;
2117 | 	__u32 reserved[4];
2118 | 	struct v4l2_enc_idx_entry entry[V4L2_ENC_IDX_ENTRIES];
2119 | };
2120 | 
2121 | 
2122 | #define V4L2_ENC_CMD_START      (0)
2123 | #define V4L2_ENC_CMD_STOP       (1)
2124 | #define V4L2_ENC_CMD_PAUSE      (2)
2125 | #define V4L2_ENC_CMD_RESUME     (3)
2126 | 
2127 | /* Flags for V4L2_ENC_CMD_STOP */
2128 | #define V4L2_ENC_CMD_STOP_AT_GOP_END    (1 << 0)
2129 | 
2130 | struct v4l2_encoder_cmd {
2131 | 	__u32 cmd;
2132 | 	__u32 flags;
2133 | 	union {
2134 | 		struct {
2135 | 			__u32 data[8];
2136 | 		} raw;
2137 | 	};
2138 | };
2139 | 
2140 | /* Decoder commands */
2141 | #define V4L2_DEC_CMD_START       (0)
2142 | #define V4L2_DEC_CMD_STOP        (1)
2143 | #define V4L2_DEC_CMD_PAUSE       (2)
2144 | #define V4L2_DEC_CMD_RESUME      (3)
2145 | 
2146 | /* Flags for V4L2_DEC_CMD_START */
2147 | #define V4L2_DEC_CMD_START_MUTE_AUDIO	(1 << 0)
2148 | 
2149 | /* Flags for V4L2_DEC_CMD_PAUSE */
2150 | #define V4L2_DEC_CMD_PAUSE_TO_BLACK	(1 << 0)
2151 | 
2152 | /* Flags for V4L2_DEC_CMD_STOP */
2153 | #define V4L2_DEC_CMD_STOP_TO_BLACK	(1 << 0)
2154 | #define V4L2_DEC_CMD_STOP_IMMEDIATELY	(1 << 1)
2155 | 
2156 | /* Play format requirements (returned by the driver): */
2157 | 
2158 | /* The decoder has no special format requirements */
2159 | #define V4L2_DEC_START_FMT_NONE		(0)
2160 | /* The decoder requires full GOPs */
2161 | #define V4L2_DEC_START_FMT_GOP		(1)
2162 | 
2163 | /* The structure must be zeroed before use by the application
2164 |    This ensures it can be extended safely in the future. */
2165 | struct v4l2_decoder_cmd {
2166 | 	__u32 cmd;
2167 | 	__u32 flags;
2168 | 	union {
2169 | 		struct {
2170 | 			__u64 pts;
2171 | 		} stop;
2172 | 
2173 | 		struct {
2174 | 			/* 0 or 1000 specifies normal speed,
2175 | 			   1 specifies forward single stepping,
2176 | 			   -1 specifies backward single stepping,
2177 | 			   >1: playback at speed/1000 of the normal speed,
2178 | 			   <-1: reverse playback at (-speed/1000) of the normal speed. */
2179 | 			__s32 speed;
2180 | 			__u32 format;
2181 | 		} start;
2182 | 
2183 | 		struct {
2184 | 			__u32 data[16];
2185 | 		} raw;
2186 | 	};
2187 | };
2188 | #endif
2189 | 
2190 | 
2191 | /*
2192 |  *	D A T A   S E R V I C E S   ( V B I )
2193 |  *
2194 |  *	Data services API by Michael Schimek
2195 |  */
2196 | 
2197 | /* Raw VBI */
2198 | struct v4l2_vbi_format {
2199 | 	__u32	sampling_rate;		/* in 1 Hz */
2200 | 	__u32	offset;
2201 | 	__u32	samples_per_line;
2202 | 	__u32	sample_format;		/* V4L2_PIX_FMT_* */
2203 | 	__s32	start[2];
2204 | 	__u32	count[2];
2205 | 	__u32	flags;			/* V4L2_VBI_* */
2206 | 	__u32	reserved[2];		/* must be zero */
2207 | };
2208 | 
2209 | /*  VBI flags  */
2210 | #define V4L2_VBI_UNSYNC		(1 << 0)
2211 | #define V4L2_VBI_INTERLACED	(1 << 1)
2212 | 
2213 | /* Sliced VBI
2214 |  *
2215 |  *    This implements is a proposal V4L2 API to allow SLICED VBI
2216 |  * required for some hardware encoders. It should change without
2217 |  * notice in the definitive implementation.
2218 |  */
2219 | 
2220 | struct v4l2_sliced_vbi_format {
2221 | 	__u16   service_set;
2222 | 	/* service_lines[0][...] specifies lines 0-23 (1-23 used) of the first field
2223 | 	   service_lines[1][...] specifies lines 0-23 (1-23 used) of the second field
2224 | 				 (equals frame lines 313-336 for 625 line video
2225 | 				  standards, 263-286 for 525 line standards) */
2226 | 	__u16   service_lines[2][24];
2227 | 	__u32   io_size;
2228 | 	__u32   reserved[2];            /* must be zero */
2229 | };
2230 | 
2231 | /* Teletext World System Teletext
2232 |    (WST), defined on ITU-R BT.653-2 */
2233 | #define V4L2_SLICED_TELETEXT_B          (0x0001)
2234 | /* Video Program System, defined on ETS 300 231*/
2235 | #define V4L2_SLICED_VPS                 (0x0400)
2236 | /* Closed Caption, defined on EIA-608 */
2237 | #define V4L2_SLICED_CAPTION_525         (0x1000)
2238 | /* Wide Screen System, defined on ITU-R BT1119.1 */
2239 | #define V4L2_SLICED_WSS_625             (0x4000)
2240 | 
2241 | #define V4L2_SLICED_VBI_525             (V4L2_SLICED_CAPTION_525)
2242 | #define V4L2_SLICED_VBI_625             (V4L2_SLICED_TELETEXT_B | V4L2_SLICED_VPS | V4L2_SLICED_WSS_625)
2243 | 
2244 | struct v4l2_sliced_vbi_cap {
2245 | 	__u16   service_set;
2246 | 	/* service_lines[0][...] specifies lines 0-23 (1-23 used) of the first field
2247 | 	   service_lines[1][...] specifies lines 0-23 (1-23 used) of the second field
2248 | 				 (equals frame lines 313-336 for 625 line video
2249 | 				  standards, 263-286 for 525 line standards) */
2250 | 	__u16   service_lines[2][24];
2251 | 	enum v4l2_buf_type type;
2252 | 	__u32   reserved[3];    /* must be 0 */
2253 | };
2254 | 
2255 | struct v4l2_sliced_vbi_data {
2256 | 	__u32   id;
2257 | 	__u32   field;          /* 0: first field, 1: second field */
2258 | 	__u32   line;           /* 1-23 */
2259 | 	__u32   reserved;       /* must be 0 */
2260 | 	__u8    data[48];
2261 | };
2262 | 
2263 | /*
2264 |  * Sliced VBI data inserted into MPEG Streams
2265 |  */
2266 | 
2267 | /*
2268 |  * V4L2_MPEG_STREAM_VBI_FMT_IVTV:
2269 |  *
2270 |  * Structure of payload contained in an MPEG 2 Private Stream 1 PES Packet in an
2271 |  * MPEG-2 Program Pack that contains V4L2_MPEG_STREAM_VBI_FMT_IVTV Sliced VBI
2272 |  * data
2273 |  *
2274 |  * Note, the MPEG-2 Program Pack and Private Stream 1 PES packet header
2275 |  * definitions are not included here.  See the MPEG-2 specifications for details
2276 |  * on these headers.
2277 |  */
2278 | 
2279 | /* Line type IDs */
2280 | #define V4L2_MPEG_VBI_IVTV_TELETEXT_B     (1)
2281 | #define V4L2_MPEG_VBI_IVTV_CAPTION_525    (4)
2282 | #define V4L2_MPEG_VBI_IVTV_WSS_625        (5)
2283 | #define V4L2_MPEG_VBI_IVTV_VPS            (7)
2284 | 
2285 | struct v4l2_mpeg_vbi_itv0_line {
2286 | 	__u8 id;	/* One of V4L2_MPEG_VBI_IVTV_* above */
2287 | 	__u8 data[42];	/* Sliced VBI data for the line */
2288 | } __attribute__ ((packed));
2289 | 
2290 | struct v4l2_mpeg_vbi_itv0 {
2291 | 	__le32 linemask[2]; /* Bitmasks of VBI service lines present */
2292 | 	struct v4l2_mpeg_vbi_itv0_line line[35];
2293 | } __attribute__ ((packed));
2294 | 
2295 | struct v4l2_mpeg_vbi_ITV0 {
2296 | 	struct v4l2_mpeg_vbi_itv0_line line[36];
2297 | } __attribute__ ((packed));
2298 | 
2299 | #define V4L2_MPEG_VBI_IVTV_MAGIC0	"itv0"
2300 | #define V4L2_MPEG_VBI_IVTV_MAGIC1	"ITV0"
2301 | 
2302 | struct v4l2_mpeg_vbi_fmt_ivtv {
2303 | 	__u8 magic[4];
2304 | 	union {
2305 | 		struct v4l2_mpeg_vbi_itv0 itv0;
2306 | 		struct v4l2_mpeg_vbi_ITV0 ITV0;
2307 | 	};
2308 | } __attribute__ ((packed));
2309 | 
2310 | /*
2311 |  *	A G G R E G A T E   S T R U C T U R E S
2312 |  */
2313 | 
2314 | /**
2315 |  * struct v4l2_plane_pix_format - additional, per-plane format definition
2316 |  * @sizeimage:		maximum size in bytes required for data, for which
2317 |  *			this plane will be used
2318 |  * @bytesperline:	distance in bytes between the leftmost pixels in two
2319 |  *			adjacent lines
2320 |  */
2321 | struct v4l2_plane_pix_format {
2322 | 	__u32		sizeimage;
2323 | 	__u16		bytesperline;
2324 | 	__u16		reserved[7];
2325 | } __attribute__ ((packed));
2326 | 
2327 | /**
2328 |  * struct v4l2_pix_format_mplane - multiplanar format definition
2329 |  * @width:		image width in pixels
2330 |  * @height:		image height in pixels
2331 |  * @pixelformat:	little endian four character code (fourcc)
2332 |  * @field:		field order (for interlaced video)
2333 |  * @colorspace:		supplemental to pixelformat
2334 |  * @plane_fmt:		per-plane information
2335 |  * @num_planes:		number of planes for this format
2336 |  */
2337 | struct v4l2_pix_format_mplane {
2338 | 	__u32				width;
2339 | 	__u32				height;
2340 | 	__u32				pixelformat;
2341 | 	enum v4l2_field			field;
2342 | 	enum v4l2_colorspace		colorspace;
2343 | 
2344 | 	struct v4l2_plane_pix_format	plane_fmt[VIDEO_MAX_PLANES];
2345 | 	__u8				num_planes;
2346 | 	__u8				reserved[11];
2347 | } __attribute__ ((packed));
2348 | 
2349 | /**
2350 |  * struct v4l2_format - stream data format
2351 |  * @type:	type of the data stream
2352 |  * @pix:	definition of an image format
2353 |  * @pix_mp:	definition of a multiplanar image format
2354 |  * @win:	definition of an overlaid image
2355 |  * @vbi:	raw VBI capture or output parameters
2356 |  * @sliced:	sliced VBI capture or output parameters
2357 |  * @raw_data:	placeholder for future extensions and custom formats
2358 |  */
2359 | struct v4l2_format {
2360 | 	enum v4l2_buf_type type;
2361 | 	union {
2362 | 		struct v4l2_pix_format		pix;     /* V4L2_BUF_TYPE_VIDEO_CAPTURE */
2363 | 		struct v4l2_pix_format_mplane	pix_mp;  /* V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE */
2364 | 		struct v4l2_window		win;     /* V4L2_BUF_TYPE_VIDEO_OVERLAY */
2365 | 		struct v4l2_vbi_format		vbi;     /* V4L2_BUF_TYPE_VBI_CAPTURE */
2366 | 		struct v4l2_sliced_vbi_format	sliced;  /* V4L2_BUF_TYPE_SLICED_VBI_CAPTURE */
2367 | 		__u8	raw_data[200];                   /* user-defined */
2368 | 	} fmt;
2369 | };
2370 | 
2371 | /*	Stream type-dependent parameters
2372 |  */
2373 | struct v4l2_streamparm {
2374 | 	enum v4l2_buf_type type;
2375 | 	union {
2376 | 		struct v4l2_captureparm	capture;
2377 | 		struct v4l2_outputparm	output;
2378 | 		__u8	raw_data[200];  /* user-defined */
2379 | 	} parm;
2380 | };
2381 | 
2382 | /*
2383 |  *	E V E N T S
2384 |  */
2385 | 
2386 | #define V4L2_EVENT_ALL				0
2387 | #define V4L2_EVENT_VSYNC			1
2388 | #define V4L2_EVENT_EOS				2
2389 | #define V4L2_EVENT_CTRL				3
2390 | #define V4L2_EVENT_FRAME_SYNC			4
2391 | #define V4L2_EVENT_PRIVATE_START		0x08000000
2392 | 
2393 | /* Payload for V4L2_EVENT_VSYNC */
2394 | struct v4l2_event_vsync {
2395 | 	/* Can be V4L2_FIELD_ANY, _NONE, _TOP or _BOTTOM */
2396 | 	__u8 field;
2397 | } __attribute__ ((packed));
2398 | 
2399 | /* Payload for V4L2_EVENT_CTRL */
2400 | #define V4L2_EVENT_CTRL_CH_VALUE		(1 << 0)
2401 | #define V4L2_EVENT_CTRL_CH_FLAGS		(1 << 1)
2402 | 
2403 | struct v4l2_event_ctrl {
2404 | 	__u32 changes;
2405 | 	__u32 type;
2406 | 	union {
2407 | 		__s32 value;
2408 | 		__s64 value64;
2409 | 	};
2410 | 	__u32 flags;
2411 | 	__s32 minimum;
2412 | 	__s32 maximum;
2413 | 	__s32 step;
2414 | 	__s32 default_value;
2415 | };
2416 | 
2417 | struct v4l2_event_frame_sync {
2418 | 	__u32 frame_sequence;
2419 | };
2420 | 
2421 | struct v4l2_event {
2422 | 	__u32				type;
2423 | 	union {
2424 | 		struct v4l2_event_vsync		vsync;
2425 | 		struct v4l2_event_ctrl		ctrl;
2426 | 		struct v4l2_event_frame_sync	frame_sync;
2427 | 		__u8				data[64];
2428 | 	} u;
2429 | 	__u32				pending;
2430 | 	__u32				sequence;
2431 | 	struct timespec			timestamp;
2432 | 	__u32				id;
2433 | 	__u32				reserved[8];
2434 | };
2435 | 
2436 | #define V4L2_EVENT_SUB_FL_SEND_INITIAL		(1 << 0)
2437 | #define V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK	(1 << 1)
2438 | 
2439 | struct v4l2_event_subscription {
2440 | 	__u32				type;
2441 | 	__u32				id;
2442 | 	__u32				flags;
2443 | 	__u32				reserved[5];
2444 | };
2445 | 
2446 | /*
2447 |  *	A D V A N C E D   D E B U G G I N G
2448 |  *
2449 |  *	NOTE: EXPERIMENTAL API, NEVER RELY ON THIS IN APPLICATIONS!
2450 |  *	FOR DEBUGGING, TESTING AND INTERNAL USE ONLY!
2451 |  */
2452 | 
2453 | /* VIDIOC_DBG_G_REGISTER and VIDIOC_DBG_S_REGISTER */
2454 | 
2455 | #define V4L2_CHIP_MATCH_HOST       0  /* Match against chip ID on host (0 for the host) */
2456 | #define V4L2_CHIP_MATCH_I2C_DRIVER 1  /* Match against I2C driver name */
2457 | #define V4L2_CHIP_MATCH_I2C_ADDR   2  /* Match against I2C 7-bit address */
2458 | #define V4L2_CHIP_MATCH_AC97       3  /* Match against anciliary AC97 chip */
2459 | 
2460 | struct v4l2_dbg_match {
2461 | 	__u32 type; /* Match type */
2462 | 	union {     /* Match this chip, meaning determined by type */
2463 | 		__u32 addr;
2464 | 		char name[32];
2465 | 	};
2466 | } __attribute__ ((packed));
2467 | 
2468 | struct v4l2_dbg_register {
2469 | 	struct v4l2_dbg_match match;
2470 | 	__u32 size;	/* register size in bytes */
2471 | 	__u64 reg;
2472 | 	__u64 val;
2473 | } __attribute__ ((packed));
2474 | 
2475 | /* VIDIOC_DBG_G_CHIP_IDENT */
2476 | struct v4l2_dbg_chip_ident {
2477 | 	struct v4l2_dbg_match match;
2478 | 	__u32 ident;       /* chip identifier as specified in <media/v4l2-chip-ident.h> */
2479 | 	__u32 revision;    /* chip revision, chip specific */
2480 | } __attribute__ ((packed));
2481 | 
2482 | /**
2483 |  * struct v4l2_create_buffers - VIDIOC_CREATE_BUFS argument
2484 |  * @index:	on return, index of the first created buffer
2485 |  * @count:	entry: number of requested buffers,
2486 |  *		return: number of created buffers
2487 |  * @memory:	buffer memory type
2488 |  * @format:	frame format, for which buffers are requested
2489 |  * @reserved:	future extensions
2490 |  */
2491 | struct v4l2_create_buffers {
2492 | 	__u32			index;
2493 | 	__u32			count;
2494 | 	enum v4l2_memory        memory;
2495 | 	struct v4l2_format	format;
2496 | 	__u32			reserved[8];
2497 | };
2498 | 
2499 | /*
2500 |  *	I O C T L   C O D E S   F O R   V I D E O   D E V I C E S
2501 |  *
2502 |  */
2503 | #define VIDIOC_QUERYCAP		 _IOR('V',  0, struct v4l2_capability)
2504 | #define VIDIOC_RESERVED		  _IO('V',  1)
2505 | #define VIDIOC_ENUM_FMT         _IOWR('V',  2, struct v4l2_fmtdesc)
2506 | #define VIDIOC_G_FMT		_IOWR('V',  4, struct v4l2_format)
2507 | #define VIDIOC_S_FMT		_IOWR('V',  5, struct v4l2_format)
2508 | #define VIDIOC_REQBUFS		_IOWR('V',  8, struct v4l2_requestbuffers)
2509 | #define VIDIOC_QUERYBUF		_IOWR('V',  9, struct v4l2_buffer)
2510 | #define VIDIOC_G_FBUF		 _IOR('V', 10, struct v4l2_framebuffer)
2511 | #define VIDIOC_S_FBUF		 _IOW('V', 11, struct v4l2_framebuffer)
2512 | #define VIDIOC_OVERLAY		 _IOW('V', 14, int)
2513 | #define VIDIOC_QBUF		_IOWR('V', 15, struct v4l2_buffer)
2514 | #define VIDIOC_DQBUF		_IOWR('V', 17, struct v4l2_buffer)
2515 | #define VIDIOC_STREAMON		 _IOW('V', 18, int)
2516 | #define VIDIOC_STREAMOFF	 _IOW('V', 19, int)
2517 | #define VIDIOC_G_PARM		_IOWR('V', 21, struct v4l2_streamparm)
2518 | #define VIDIOC_S_PARM		_IOWR('V', 22, struct v4l2_streamparm)
2519 | #define VIDIOC_G_STD		 _IOR('V', 23, v4l2_std_id)
2520 | #define VIDIOC_S_STD		 _IOW('V', 24, v4l2_std_id)
2521 | #define VIDIOC_ENUMSTD		_IOWR('V', 25, struct v4l2_standard)
2522 | #define VIDIOC_ENUMINPUT	_IOWR('V', 26, struct v4l2_input)
2523 | #define VIDIOC_G_CTRL		_IOWR('V', 27, struct v4l2_control)
2524 | #define VIDIOC_S_CTRL		_IOWR('V', 28, struct v4l2_control)
2525 | #define VIDIOC_G_TUNER		_IOWR('V', 29, struct v4l2_tuner)
2526 | #define VIDIOC_S_TUNER		 _IOW('V', 30, struct v4l2_tuner)
2527 | #define VIDIOC_G_AUDIO		 _IOR('V', 33, struct v4l2_audio)
2528 | #define VIDIOC_S_AUDIO		 _IOW('V', 34, struct v4l2_audio)
2529 | #define VIDIOC_QUERYCTRL	_IOWR('V', 36, struct v4l2_queryctrl)
2530 | #define VIDIOC_QUERYMENU	_IOWR('V', 37, struct v4l2_querymenu)
2531 | #define VIDIOC_G_INPUT		 _IOR('V', 38, int)
2532 | #define VIDIOC_S_INPUT		_IOWR('V', 39, int)
2533 | #define VIDIOC_G_OUTPUT		 _IOR('V', 46, int)
2534 | #define VIDIOC_S_OUTPUT		_IOWR('V', 47, int)
2535 | #define VIDIOC_ENUMOUTPUT	_IOWR('V', 48, struct v4l2_output)
2536 | #define VIDIOC_G_AUDOUT		 _IOR('V', 49, struct v4l2_audioout)
2537 | #define VIDIOC_S_AUDOUT		 _IOW('V', 50, struct v4l2_audioout)
2538 | #define VIDIOC_G_MODULATOR	_IOWR('V', 54, struct v4l2_modulator)
2539 | #define VIDIOC_S_MODULATOR	 _IOW('V', 55, struct v4l2_modulator)
2540 | #define VIDIOC_G_FREQUENCY	_IOWR('V', 56, struct v4l2_frequency)
2541 | #define VIDIOC_S_FREQUENCY	 _IOW('V', 57, struct v4l2_frequency)
2542 | #define VIDIOC_CROPCAP		_IOWR('V', 58, struct v4l2_cropcap)
2543 | #define VIDIOC_G_CROP		_IOWR('V', 59, struct v4l2_crop)
2544 | #define VIDIOC_S_CROP		 _IOW('V', 60, struct v4l2_crop)
2545 | #define VIDIOC_G_JPEGCOMP	 _IOR('V', 61, struct v4l2_jpegcompression)
2546 | #define VIDIOC_S_JPEGCOMP	 _IOW('V', 62, struct v4l2_jpegcompression)
2547 | #define VIDIOC_QUERYSTD      	 _IOR('V', 63, v4l2_std_id)
2548 | #define VIDIOC_TRY_FMT      	_IOWR('V', 64, struct v4l2_format)
2549 | #define VIDIOC_ENUMAUDIO	_IOWR('V', 65, struct v4l2_audio)
2550 | #define VIDIOC_ENUMAUDOUT	_IOWR('V', 66, struct v4l2_audioout)
2551 | #define VIDIOC_G_PRIORITY        _IOR('V', 67, enum v4l2_priority)
2552 | #define VIDIOC_S_PRIORITY        _IOW('V', 68, enum v4l2_priority)
2553 | #define VIDIOC_G_SLICED_VBI_CAP _IOWR('V', 69, struct v4l2_sliced_vbi_cap)
2554 | #define VIDIOC_LOG_STATUS         _IO('V', 70)
2555 | #define VIDIOC_G_EXT_CTRLS	_IOWR('V', 71, struct v4l2_ext_controls)
2556 | #define VIDIOC_S_EXT_CTRLS	_IOWR('V', 72, struct v4l2_ext_controls)
2557 | #define VIDIOC_TRY_EXT_CTRLS	_IOWR('V', 73, struct v4l2_ext_controls)
2558 | #if 1
2559 | #define VIDIOC_ENUM_FRAMESIZES	_IOWR('V', 74, struct v4l2_frmsizeenum)
2560 | #define VIDIOC_ENUM_FRAMEINTERVALS _IOWR('V', 75, struct v4l2_frmivalenum)
2561 | #define VIDIOC_G_ENC_INDEX       _IOR('V', 76, struct v4l2_enc_idx)
2562 | #define VIDIOC_ENCODER_CMD      _IOWR('V', 77, struct v4l2_encoder_cmd)
2563 | #define VIDIOC_TRY_ENCODER_CMD  _IOWR('V', 78, struct v4l2_encoder_cmd)
2564 | #endif
2565 | 
2566 | #if 1
2567 | /* Experimental, meant for debugging, testing and internal use.
2568 |    Only implemented if CONFIG_VIDEO_ADV_DEBUG is defined.
2569 |    You must be root to use these ioctls. Never use these in applications! */
2570 | #define	VIDIOC_DBG_S_REGISTER 	 _IOW('V', 79, struct v4l2_dbg_register)
2571 | #define	VIDIOC_DBG_G_REGISTER 	_IOWR('V', 80, struct v4l2_dbg_register)
2572 | 
2573 | /* Experimental, meant for debugging, testing and internal use.
2574 |    Never use this ioctl in applications! */
2575 | #define VIDIOC_DBG_G_CHIP_IDENT _IOWR('V', 81, struct v4l2_dbg_chip_ident)
2576 | #endif
2577 | 
2578 | #define VIDIOC_S_HW_FREQ_SEEK	 _IOW('V', 82, struct v4l2_hw_freq_seek)
2579 | #define	VIDIOC_ENUM_DV_PRESETS	_IOWR('V', 83, struct v4l2_dv_enum_preset)
2580 | #define	VIDIOC_S_DV_PRESET	_IOWR('V', 84, struct v4l2_dv_preset)
2581 | #define	VIDIOC_G_DV_PRESET	_IOWR('V', 85, struct v4l2_dv_preset)
2582 | #define	VIDIOC_QUERY_DV_PRESET	_IOR('V',  86, struct v4l2_dv_preset)
2583 | #define	VIDIOC_S_DV_TIMINGS	_IOWR('V', 87, struct v4l2_dv_timings)
2584 | #define	VIDIOC_G_DV_TIMINGS	_IOWR('V', 88, struct v4l2_dv_timings)
2585 | #define	VIDIOC_DQEVENT		 _IOR('V', 89, struct v4l2_event)
2586 | #define	VIDIOC_SUBSCRIBE_EVENT	 _IOW('V', 90, struct v4l2_event_subscription)
2587 | #define	VIDIOC_UNSUBSCRIBE_EVENT _IOW('V', 91, struct v4l2_event_subscription)
2588 | 
2589 | /* Experimental, the below two ioctls may change over the next couple of kernel
2590 |    versions */
2591 | #define VIDIOC_CREATE_BUFS	_IOWR('V', 92, struct v4l2_create_buffers)
2592 | #define VIDIOC_PREPARE_BUF	_IOWR('V', 93, struct v4l2_buffer)
2593 | 
2594 | /* Experimental selection API */
2595 | #define VIDIOC_G_SELECTION	_IOWR('V', 94, struct v4l2_selection)
2596 | #define VIDIOC_S_SELECTION	_IOWR('V', 95, struct v4l2_selection)
2597 | 
2598 | /* Experimental, these two ioctls may change over the next couple of kernel
2599 |    versions. */
2600 | #define VIDIOC_DECODER_CMD	_IOWR('V', 96, struct v4l2_decoder_cmd)
2601 | #define VIDIOC_TRY_DECODER_CMD	_IOWR('V', 97, struct v4l2_decoder_cmd)
2602 | 
2603 | /* Reminder: when adding new ioctls please add support for them to
2604 |    drivers/media/video/v4l2-compat-ioctl32.c as well! */
2605 | 
2606 | #define BASE_VIDIOC_PRIVATE	192		/* 192-255 are private */
2607 | 
2608 | //add by yang
2609 | #define VIDIOC_ISP_AE_STAT_REQ \
2610 | 	_IOWR('V', BASE_VIDIOC_PRIVATE + 1, struct isp_stat_buf)
2611 | //add by yang
2612 | #define VIDIOC_ISP_HIST_STAT_REQ \
2613 | 	_IOWR('V', BASE_VIDIOC_PRIVATE + 2, struct isp_stat_buf)
2614 | //add by yang
2615 | #define VIDIOC_ISP_AF_STAT_REQ \
2616 | 	_IOWR('V', BASE_VIDIOC_PRIVATE + 3, struct isp_stat_buf)
2617 | //add by yang
2618 | #define VIDIOC_ISP_EXIF_REQ \
2619 | 	_IOWR('V', BASE_VIDIOC_PRIVATE + 4, struct isp_exif_attribute)
2620 | //add by yang
2621 | #define VIDIOC_ISP_GAMMA_REQ \
2622 | 	_IOWR('V', BASE_VIDIOC_PRIVATE + 5, struct isp_stat_buf)
2623 | 
2624 | #endif /* __LINUX_VIDEODEV2_H */
2625 | 


--------------------------------------------------------------------------------