projects / openwrt / openwrt.git / blob
? search:


ab578bf5316b1f40c0ce85921484a26c724c2f57
[openwrt/openwrt.git] / target / linux / brcm2708 / patches-3.14 / 0031-V4L2-Fixes-from-6by9.patch
1 From 4365e08f272ba098698196234dbd38ac3dd5a606 Mon Sep 17 00:00:00 2001
2 From: Dave Stevenson <dsteve@broadcom.com>
3 Date: Mon, 9 Dec 2013 10:58:01 +0000
4 Subject: [PATCH 31/54] V4L2: Fixes from 6by9
5
6 V4L2: Fix EV values. Add manual shutter speed control
7
8 V4L2 EV values should be in units of 1/1000. Corrected.
9 Add support for V4L2_CID_EXPOSURE_ABSOLUTE which should
10 give manual shutter control. Requires manual exposure mode
11 to be selected first.
12
13 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
14
15 V4L2: Correct JPEG Q-factor range
16
17 Should be 1-100, not 0-100
18
19 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
20
21 V4L2: Fix issue of driver jamming if STREAMON failed.
22
23 Fix issue where the driver was left in a partially enabled
24 state if STREAMON failed, and would then reject many IOCTLs
25 as it thought it was streaming.
26
27 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
28
29 V4L2: Fix ISO controls.
30
31 Driver was passing the index to the GPU, and not the desired
32 ISO value.
33
34 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
35
36 V4L2: Add flicker avoidance controls
37
38 Add support for V4L2_CID_POWER_LINE_FREQUENCY to set flicker
39 avoidance frequencies.
40
41 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
42
43 V4L2: Add support for frame rate control.
44
45 Add support for frame rate (or time per frame as V4L2
46 inverts it) control via s_parm.
47
48 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
49
50 V4L2: Improve G_FBUF handling so we pass conformance
51
52 Return some sane numbers for get framebuffer so that
53 we pass conformance.
54
55 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
56
57 V4L2: Fix information advertised through g_vidfmt
58
59 Width and height were being stored based on incorrect
60 values.
61
62 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
63
64 V4L2: Add support for inline H264 headers
65
66 Add support for V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER
67 to control H264 inline headers.
68 Requires firmware fix to work correctly, otherwise format
69 has to be set to H264 before this parameter is set.
70
71 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
72
73 V4L2: Fix JPEG timestamp issue
74
75 JPEG images were coming through from the GPU with timestamp
76 of 0. Detect this and give current system time instead
77 of some invalid value.
78
79 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
80
81 V4L2: Fix issue when switching down JPEG resolution.
82
83 JPEG buffer size calculation is based on input resolution.
84 Input resolution was being configured after output port
85 format. Caused failures if switching from one JPEG resolution
86 to a smaller one.
87
88 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
89
90 V4L2: Enable MJPEG encoding
91
92 Requires GPU firmware update to support MJPEG encoder.
93
94 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
95
96 V4L2: Correct flag settings for compressed formats
97
98 Set flags field correctly on enum_fmt_vid_cap for compressed
99 image formats.
100
101 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
102
103 V4L2: H264 profile & level ctrls, FPS control and auto exp pri
104
105 Several control handling updates.
106 H264 profile and level controls.
107 Timeperframe/FPS reworked to add V4L2_CID_EXPOSURE_AUTO_PRIORITY to
108 select whether AE is allowed to override the framerate specified.
109
110 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
111
112 V4L2: Correct BGR24 to RGB24 in format table
113
114 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
115
116 V4L2: Add additional pixel formats. Correct colourspace
117
118 Adds the other flavours of YUYV, and NV12.
119 Corrects the overlay advertised colourspace.
120
121 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
122
123 V4L2: Drop logging msg from info to debug
124
125 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
126
127 V4L2: Initial pass at scene modes.
128
129 Only supports exposure mode and metering modes.
130
131 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
132
133 V4L2: Add manual white balance control.
134
135 Adds support for V4L2_CID_RED_BALANCE and
136 V4L2_CID_BLUE_BALANCE. Only has an effect if
137 V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE has
138 V4L2_WHITE_BALANCE_MANUAL selected.
139
140 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
141
142 config: Enable V4L / MMAL driver
143
144 V4L2: Increase the MMAL timeout to 3sec
145
146 MJPEG codec flush is now taking longer and results
147 in a kernel panic if the driver has stopped waiting for
148 the result when it finally completes.
149 Increase the timeout value from 1 to 3secs.
150
151 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
152
153 V4L2: Add support for setting H264_I_PERIOD
154
155 Adds support for the parameter V4L2_CID_MPEG_VIDEO_H264_I_PERIOD
156 to set the frequency with which I frames are produced.
157
158 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
159
160 V4L2: Enable GPU function for removing padding from images.
161
162 GPU can now support arbitrary strides, although may require
163 additional processing to achieve it. Enable this feature
164 so that the images delivered are the size requested.
165
166 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
167
168 V4L2: Add support for V4L2_PIX_FMT_BGR32
169
170 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
171
172 V4L2: Set the colourspace to avoid odd YUV-RGB conversions
173
174 Removes the amiguity from the conversion routines and stops
175 them dropping back to the SD vs HD choice of coeffs.
176
177 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
178
179 V4L2: Make video/still threshold a run-time param
180
181 Move the define for at what resolution the driver
182 switches from a video mode capture to a stills mode
183 capture to module parameters.
184
185 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
186
187 V4L2: Fix incorrect pool sizing
188
189 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
190
191 V4L2: Add option to disable enum_framesizes.
192
193 Gstreamer's handling of a driver that advertises
194 V4L2_FRMSIZE_TYPE_STEPWISE to define the supported
195 resolutions is broken. See bug
196 https://bugzilla.gnome.org/show_bug.cgi?id=726521
197
198 Optional parameter of gst_v4l2src_is_broken added.
199 If non-zero, the driver claims not to support that
200 ioctl, and gstreamer should be happy again (it
201 guesses a set of defaults for itself).
202
203 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
204
205 V4L2: Add support for more image formats
206
207 Adds YVU420 (YV12), YVU420SP (NV21), and BGR888.
208
209 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
210
211 V4L2: Extend range for V4L2_CID_MPEG_VIDEO_H264_I_PERIOD
212
213 Request to extend the range from the fairly arbitrary
214 1000 frames (33 seconds at 30fps). Extend out to the
215 max range supported (int32 value).
216 Also allow 0, which is handled by the codec as only
217 send an I-frame on the first frame and never again.
218 There may be an exception if it detects a significant
219 scene change, but there's no easy way around that.
220
221 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
222 ---
223 arch/arm/configs/bcmrpi_defconfig | 3 +
224 drivers/media/platform/bcm2835/bcm2835-camera.c | 561 ++++++++++++++----
225 drivers/media/platform/bcm2835/bcm2835-camera.h | 23 +-
226 drivers/media/platform/bcm2835/controls.c | 723 +++++++++++++++++++++--
227 drivers/media/platform/bcm2835/mmal-common.h | 1 +
228 drivers/media/platform/bcm2835/mmal-encodings.h | 34 ++
229 drivers/media/platform/bcm2835/mmal-parameters.h | 121 +++-
230 drivers/media/platform/bcm2835/mmal-vchiq.c | 4 +-
231 8 files changed, 1292 insertions(+), 178 deletions(-)
232
233 diff --git a/arch/arm/configs/bcmrpi_defconfig b/arch/arm/configs/bcmrpi_defconfig
234 index e89e430..d70da44 100644
235 --- a/arch/arm/configs/bcmrpi_defconfig
236 +++ b/arch/arm/configs/bcmrpi_defconfig
237 @@ -694,6 +694,9 @@ CONFIG_DVB_B2C2_FLEXCOP_USB=m
238 CONFIG_VIDEO_EM28XX=m
239 CONFIG_VIDEO_EM28XX_ALSA=m
240 CONFIG_VIDEO_EM28XX_DVB=m
241 +CONFIG_V4L_PLATFORM_DRIVERS=y
242 +CONFIG_VIDEO_BCM2835=y
243 +CONFIG_VIDEO_BCM2835_MMAL=m
244 CONFIG_RADIO_SI470X=y
245 CONFIG_USB_SI470X=m
246 CONFIG_I2C_SI470X=m
247 diff --git a/drivers/media/platform/bcm2835/bcm2835-camera.c b/drivers/media/platform/bcm2835/bcm2835-camera.c
248 index 47fe45d..f809b83 100644
249 --- a/drivers/media/platform/bcm2835/bcm2835-camera.c
250 +++ b/drivers/media/platform/bcm2835/bcm2835-camera.c
251 @@ -36,7 +36,8 @@
252
253 #define BM2835_MMAL_VERSION "0.0.2"
254 #define BM2835_MMAL_MODULE_NAME "bcm2835-v4l2"
255 -
256 +#define MIN_WIDTH 16
257 +#define MIN_HEIGHT 16
258 #define MAX_WIDTH 2592
259 #define MAX_HEIGHT 1944
260 #define MIN_BUFFER_SIZE (80*1024)
261 @@ -53,13 +54,43 @@ int bcm2835_v4l2_debug;
262 module_param_named(debug, bcm2835_v4l2_debug, int, 0644);
263 MODULE_PARM_DESC(bcm2835_v4l2_debug, "Debug level 0-2");
264
265 +int max_video_width = MAX_VIDEO_MODE_WIDTH;
266 +int max_video_height = MAX_VIDEO_MODE_HEIGHT;
267 +module_param(max_video_width, int, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
268 +MODULE_PARM_DESC(max_video_width, "Threshold for video mode");
269 +module_param(max_video_height, int, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
270 +MODULE_PARM_DESC(max_video_height, "Threshold for video mode");
271 +
272 +/* Gstreamer bug https://bugzilla.gnome.org/show_bug.cgi?id=726521
273 + * v4l2src does bad (and actually wrong) things when the vidioc_enum_framesizes
274 + * function says type V4L2_FRMSIZE_TYPE_STEPWISE, which we do by default.
275 + * It's happier if we just don't say anything at all, when it then
276 + * sets up a load of defaults that it thinks might work.
277 + * If gst_v4l2src_is_broken is non-zero, then we remove the function from
278 + * our function table list (actually switch to an alternate set, but same
279 + * result).
280 + */
281 +int gst_v4l2src_is_broken = 0;
282 +module_param(gst_v4l2src_is_broken, int, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
283 +MODULE_PARM_DESC(gst_v4l2src_is_broken, "If non-zero, enable workaround for Gstreamer");
284 +
285 static struct bm2835_mmal_dev *gdev; /* global device data */
286
287 +#define FPS_MIN 1
288 +#define FPS_MAX 90
289 +
290 +/* timeperframe: min/max and default */
291 +static const struct v4l2_fract
292 + tpf_min = {.numerator = 1, .denominator = FPS_MAX},
293 + tpf_max = {.numerator = 1, .denominator = FPS_MIN},
294 + tpf_default = {.numerator = 1000, .denominator = 30000};
295 +
296 /* video formats */
297 static struct mmal_fmt formats[] = {
298 {
299 .name = "4:2:0, packed YUV",
300 .fourcc = V4L2_PIX_FMT_YUV420,
301 + .flags = 0,
302 .mmal = MMAL_ENCODING_I420,
303 .depth = 12,
304 .mmal_component = MMAL_COMPONENT_CAMERA,
305 @@ -67,13 +98,15 @@ static struct mmal_fmt formats[] = {
306 {
307 .name = "4:2:2, packed, YUYV",
308 .fourcc = V4L2_PIX_FMT_YUYV,
309 + .flags = 0,
310 .mmal = MMAL_ENCODING_YUYV,
311 .depth = 16,
312 .mmal_component = MMAL_COMPONENT_CAMERA,
313 },
314 {
315 - .name = "RGB24 (BE)",
316 - .fourcc = V4L2_PIX_FMT_BGR24,
317 + .name = "RGB24 (LE)",
318 + .fourcc = V4L2_PIX_FMT_RGB24,
319 + .flags = 0,
320 .mmal = MMAL_ENCODING_BGR24,
321 .depth = 24,
322 .mmal_component = MMAL_COMPONENT_CAMERA,
323 @@ -81,6 +114,7 @@ static struct mmal_fmt formats[] = {
324 {
325 .name = "JPEG",
326 .fourcc = V4L2_PIX_FMT_JPEG,
327 + .flags = V4L2_FMT_FLAG_COMPRESSED,
328 .mmal = MMAL_ENCODING_JPEG,
329 .depth = 8,
330 .mmal_component = MMAL_COMPONENT_IMAGE_ENCODE,
331 @@ -88,10 +122,83 @@ static struct mmal_fmt formats[] = {
332 {
333 .name = "H264",
334 .fourcc = V4L2_PIX_FMT_H264,
335 + .flags = V4L2_FMT_FLAG_COMPRESSED,
336 .mmal = MMAL_ENCODING_H264,
337 .depth = 8,
338 .mmal_component = MMAL_COMPONENT_VIDEO_ENCODE,
339 - }
340 + },
341 + {
342 + .name = "MJPEG",
343 + .fourcc = V4L2_PIX_FMT_MJPEG,
344 + .flags = V4L2_FMT_FLAG_COMPRESSED,
345 + .mmal = MMAL_ENCODING_MJPEG,
346 + .depth = 8,
347 + .mmal_component = MMAL_COMPONENT_VIDEO_ENCODE,
348 + },
349 + {
350 + .name = "4:2:2, packed, YVYU",
351 + .fourcc = V4L2_PIX_FMT_YVYU,
352 + .flags = 0,
353 + .mmal = MMAL_ENCODING_YVYU,
354 + .depth = 16,
355 + .mmal_component = MMAL_COMPONENT_CAMERA,
356 + },
357 + {
358 + .name = "4:2:2, packed, VYUY",
359 + .fourcc = V4L2_PIX_FMT_VYUY,
360 + .flags = 0,
361 + .mmal = MMAL_ENCODING_VYUY,
362 + .depth = 16,
363 + .mmal_component = MMAL_COMPONENT_CAMERA,
364 + },
365 + {
366 + .name = "4:2:2, packed, UYVY",
367 + .fourcc = V4L2_PIX_FMT_UYVY,
368 + .flags = 0,
369 + .mmal = MMAL_ENCODING_UYVY,
370 + .depth = 16,
371 + .mmal_component = MMAL_COMPONENT_CAMERA,
372 + },
373 + {
374 + .name = "4:2:0, packed, NV12",
375 + .fourcc = V4L2_PIX_FMT_NV12,
376 + .flags = 0,
377 + .mmal = MMAL_ENCODING_NV12,
378 + .depth = 12,
379 + .mmal_component = MMAL_COMPONENT_CAMERA,
380 + },
381 + {
382 + .name = "RGB24 (BE)",
383 + .fourcc = V4L2_PIX_FMT_BGR24,
384 + .flags = 0,
385 + .mmal = MMAL_ENCODING_RGB24,
386 + .depth = 24,
387 + .mmal_component = MMAL_COMPONENT_CAMERA,
388 + },
389 + {
390 + .name = "4:2:0, packed YVU",
391 + .fourcc = V4L2_PIX_FMT_YVU420,
392 + .flags = 0,
393 + .mmal = MMAL_ENCODING_YV12,
394 + .depth = 12,
395 + .mmal_component = MMAL_COMPONENT_CAMERA,
396 + },
397 + {
398 + .name = "4:2:0, packed, NV21",
399 + .fourcc = V4L2_PIX_FMT_NV21,
400 + .flags = 0,
401 + .mmal = MMAL_ENCODING_NV21,
402 + .depth = 12,
403 + .mmal_component = MMAL_COMPONENT_CAMERA,
404 + },
405 + {
406 + .name = "RGB32 (BE)",
407 + .fourcc = V4L2_PIX_FMT_BGR32,
408 + .flags = 0,
409 + .mmal = MMAL_ENCODING_BGRA,
410 + .depth = 32,
411 + .mmal_component = MMAL_COMPONENT_CAMERA,
412 + },
413 };
414
415 static struct mmal_fmt *get_format(struct v4l2_format *f)
416 @@ -229,7 +336,8 @@ static void buffer_cb(struct vchiq_mmal_instance *instance,
417 }
418 } else {
419 if (dev->capture.frame_count) {
420 - if (dev->capture.vc_start_timestamp != -1) {
421 + if (dev->capture.vc_start_timestamp != -1 &&
422 + pts != 0) {
423 s64 runtime_us = pts -
424 dev->capture.vc_start_timestamp;
425 u32 div = 0;
426 @@ -250,7 +358,7 @@ static void buffer_cb(struct vchiq_mmal_instance *instance,
427 USEC_PER_SEC;
428 }
429 v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
430 - "Convert start time %d.%06d and %llu"
431 + "Convert start time %d.%06d and %llu "
432 "with offset %llu to %d.%06d\n",
433 (int)dev->capture.kernel_start_ts.
434 tv_sec,
435 @@ -425,7 +533,15 @@ static int start_streaming(struct vb2_queue *vq, unsigned int count)
436 vchiq_mmal_port_enable(dev->instance, dev->capture.port, buffer_cb);
437 if (ret) {
438 v4l2_err(&dev->v4l2_dev,
439 - "Failed to enable capture port - error %d\n", ret);
440 + "Failed to enable capture port - error %d. "
441 + "Disabling camera port again\n", ret);
442 +
443 + vchiq_mmal_port_disable(dev->instance,
444 + dev->capture.camera_port);
445 + if (disable_camera(dev) < 0) {
446 + v4l2_err(&dev->v4l2_dev, "Failed to disable camera");
447 + return -EINVAL;
448 + }
449 return -1;
450 }
451
452 @@ -530,6 +646,7 @@ static int vidioc_enum_fmt_vid_overlay(struct file *file, void *priv,
453
454 strlcpy(f->description, fmt->name, sizeof(f->description));
455 f->pixelformat = fmt->fourcc;
456 + f->flags = fmt->flags;
457
458 return 0;
459 }
460 @@ -647,10 +764,18 @@ static int vidioc_g_fbuf(struct file *file, void *fh,
461 {
462 /* The video overlay must stay within the framebuffer and can't be
463 positioned independently. */
464 + struct bm2835_mmal_dev *dev = video_drvdata(file);
465 + struct vchiq_mmal_port *preview_port =
466 + &dev->component[MMAL_COMPONENT_CAMERA]->
467 + output[MMAL_CAMERA_PORT_PREVIEW];
468 a->flags = V4L2_FBUF_FLAG_OVERLAY;
469 -
470 - /* todo: v4l2_framebuffer still needs more info filling in
471 - * in order to pass the v4l2-compliance test. */
472 + a->fmt.width = preview_port->es.video.width;
473 + a->fmt.height = preview_port->es.video.height;
474 + a->fmt.pixelformat = V4L2_PIX_FMT_YUV420;
475 + a->fmt.bytesperline = (preview_port->es.video.width * 3)>>1;
476 + a->fmt.sizeimage = (preview_port->es.video.width *
477 + preview_port->es.video.height * 3)>>1;
478 + a->fmt.colorspace = V4L2_COLORSPACE_JPEG;
479
480 return 0;
481 }
482 @@ -717,6 +842,8 @@ static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
483
484 strlcpy(f->description, fmt->name, sizeof(f->description));
485 f->pixelformat = fmt->fourcc;
486 + f->flags = fmt->flags;
487 +
488 return 0;
489 }
490
491 @@ -729,20 +856,13 @@ static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
492 f->fmt.pix.height = dev->capture.height;
493 f->fmt.pix.field = V4L2_FIELD_NONE;
494 f->fmt.pix.pixelformat = dev->capture.fmt->fourcc;
495 - f->fmt.pix.bytesperline =
496 - (f->fmt.pix.width * dev->capture.fmt->depth) >> 3;
497 - f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
498 - if (dev->capture.fmt->fourcc == V4L2_PIX_FMT_JPEG
499 - && f->fmt.pix.sizeimage < (100 << 10)) {
500 - /* Need a minimum size for JPEG to account for EXIF. */
501 - f->fmt.pix.sizeimage = (100 << 10);
502 - }
503 + f->fmt.pix.bytesperline = dev->capture.stride;
504 + f->fmt.pix.sizeimage = dev->capture.buffersize;
505
506 - if (dev->capture.fmt->fourcc == V4L2_PIX_FMT_YUYV ||
507 - dev->capture.fmt->fourcc == V4L2_PIX_FMT_UYVY)
508 - f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
509 - else
510 + if (dev->capture.fmt->fourcc == V4L2_PIX_FMT_RGB24)
511 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
512 + else
513 + f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
514 f->fmt.pix.priv = 0;
515
516 v4l2_dump_pix_format(1, bcm2835_v4l2_debug, &dev->v4l2_dev, &f->fmt.pix,
517 @@ -766,21 +886,35 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
518 }
519
520 f->fmt.pix.field = V4L2_FIELD_NONE;
521 - /* image must be a multiple of 32 pixels wide and 16 lines high */
522 - v4l_bound_align_image(&f->fmt.pix.width, 48, MAX_WIDTH, 5,
523 - &f->fmt.pix.height, 32, MAX_HEIGHT, 4, 0);
524 - f->fmt.pix.bytesperline = (f->fmt.pix.width * mfmt->depth) >> 3;
525 - f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
526 - if (f->fmt.pix.sizeimage < MIN_BUFFER_SIZE)
527 +
528 + v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
529 + "Clipping/aligning %dx%d format %08X\n",
530 + f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.pixelformat);
531 +
532 + v4l_bound_align_image(&f->fmt.pix.width, MIN_WIDTH, MAX_WIDTH, 1,
533 + &f->fmt.pix.height, MIN_HEIGHT, MAX_HEIGHT, 1, 0);
534 + f->fmt.pix.bytesperline = (f->fmt.pix.width * mfmt->depth)>>3;
535 +
536 + /* Image buffer has to be padded to allow for alignment, even though
537 + * we then remove that padding before delivering the buffer.
538 + */
539 + f->fmt.pix.sizeimage = ((f->fmt.pix.height+15)&~15) *
540 + (((f->fmt.pix.width+31)&~31) * mfmt->depth) >> 3;
541 +
542 + if ((mfmt->flags & V4L2_FMT_FLAG_COMPRESSED) &&
543 + f->fmt.pix.sizeimage < MIN_BUFFER_SIZE)
544 f->fmt.pix.sizeimage = MIN_BUFFER_SIZE;
545
546 - if (mfmt->fourcc == V4L2_PIX_FMT_YUYV ||
547 - mfmt->fourcc == V4L2_PIX_FMT_UYVY)
548 - f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
549 - else
550 + if (dev->capture.fmt->fourcc == V4L2_PIX_FMT_RGB24)
551 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
552 + else
553 + f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
554 f->fmt.pix.priv = 0;
555
556 + v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
557 + "Now %dx%d format %08X\n",
558 + f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.pixelformat);
559 +
560 v4l2_dump_pix_format(1, bcm2835_v4l2_debug, &dev->v4l2_dev, &f->fmt.pix,
561 __func__);
562 return 0;
563 @@ -818,8 +952,8 @@ static int mmal_setup_components(struct bm2835_mmal_dev *dev,
564 switch (mfmt->mmal_component) {
565 case MMAL_COMPONENT_CAMERA:
566 /* Make a further decision on port based on resolution */
567 - if (f->fmt.pix.width <= MAX_VIDEO_MODE_WIDTH
568 - && f->fmt.pix.height <= MAX_VIDEO_MODE_HEIGHT)
569 + if (f->fmt.pix.width <= max_video_width
570 + && f->fmt.pix.height <= max_video_height)
571 camera_port = port =
572 &dev->component[MMAL_COMPONENT_CAMERA]->
573 output[MMAL_CAMERA_PORT_VIDEO];
574 @@ -861,8 +995,9 @@ static int mmal_setup_components(struct bm2835_mmal_dev *dev,
575 camera_port->es.video.crop.y = 0;
576 camera_port->es.video.crop.width = f->fmt.pix.width;
577 camera_port->es.video.crop.height = f->fmt.pix.height;
578 - camera_port->es.video.frame_rate.num = 30;
579 + camera_port->es.video.frame_rate.num = 0;
580 camera_port->es.video.frame_rate.den = 1;
581 + camera_port->es.video.color_space = MMAL_COLOR_SPACE_JPEG_JFIF;
582
583 ret = vchiq_mmal_port_set_format(dev->instance, camera_port);
584
585 @@ -896,8 +1031,10 @@ static int mmal_setup_components(struct bm2835_mmal_dev *dev,
586 preview_port->es.video.crop.y = 0;
587 preview_port->es.video.crop.width = f->fmt.pix.width;
588 preview_port->es.video.crop.height = f->fmt.pix.height;
589 - preview_port->es.video.frame_rate.num = 30;
590 - preview_port->es.video.frame_rate.den = 1;
591 + preview_port->es.video.frame_rate.num =
592 + dev->capture.timeperframe.denominator;
593 + preview_port->es.video.frame_rate.den =
594 + dev->capture.timeperframe.numerator;
595 ret = vchiq_mmal_port_set_format(dev->instance, preview_port);
596 if (overlay_enabled) {
597 ret = vchiq_mmal_port_connect_tunnel(
598 @@ -913,7 +1050,9 @@ static int mmal_setup_components(struct bm2835_mmal_dev *dev,
599
600 if (ret) {
601 v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
602 - "%s failed to set format\n", __func__);
603 + "%s failed to set format %dx%d %08X\n", __func__,
604 + f->fmt.pix.width, f->fmt.pix.height,
605 + f->fmt.pix.pixelformat);
606 /* ensure capture is not going to be tried */
607 dev->capture.port = NULL;
608 } else {
609 @@ -927,69 +1066,91 @@ static int mmal_setup_components(struct bm2835_mmal_dev *dev,
610 camera_port->current_buffer.num =
611 camera_port->recommended_buffer.num;
612
613 - port->format.encoding = mfmt->mmal;
614 - port->format.encoding_variant = 0;
615 - /* Set any encoding specific parameters */
616 - switch (mfmt->mmal_component) {
617 - case MMAL_COMPONENT_VIDEO_ENCODE:
618 - port->format.bitrate =
619 - dev->capture.encode_bitrate;
620 - break;
621 - case MMAL_COMPONENT_IMAGE_ENCODE:
622 - /* Could set EXIF parameters here */
623 - break;
624 - default:
625 - break;
626 - }
627 - ret = vchiq_mmal_port_set_format(dev->instance, port);
628 -
629 + ret =
630 + vchiq_mmal_port_connect_tunnel(
631 + dev->instance,
632 + camera_port,
633 + &encode_component->input[0]);
634 if (ret) {
635 - v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
636 - "%s failed to set format\n", __func__);
637 + v4l2_dbg(1, bcm2835_v4l2_debug,
638 + &dev->v4l2_dev,
639 + "%s failed to create connection\n",
640 + __func__);
641 + /* ensure capture is not going to be tried */
642 + dev->capture.port = NULL;
643 } else {
644 + port->es.video.width = f->fmt.pix.width;
645 + port->es.video.height = f->fmt.pix.height;
646 + port->es.video.crop.x = 0;
647 + port->es.video.crop.y = 0;
648 + port->es.video.crop.width = f->fmt.pix.width;
649 + port->es.video.crop.height = f->fmt.pix.height;
650 + port->es.video.frame_rate.num =
651 + dev->capture.timeperframe.denominator;
652 + port->es.video.frame_rate.den =
653 + dev->capture.timeperframe.numerator;
654 +
655 + port->format.encoding = mfmt->mmal;
656 + port->format.encoding_variant = 0;
657 + /* Set any encoding specific parameters */
658 + switch (mfmt->mmal_component) {
659 + case MMAL_COMPONENT_VIDEO_ENCODE:
660 + port->format.bitrate =
661 + dev->capture.encode_bitrate;
662 + break;
663 + case MMAL_COMPONENT_IMAGE_ENCODE:
664 + /* Could set EXIF parameters here */
665 + break;
666 + default:
667 + break;
668 + }
669 + ret = vchiq_mmal_port_set_format(dev->instance,
670 + port);
671 + if (ret)
672 + v4l2_dbg(1, bcm2835_v4l2_debug,
673 + &dev->v4l2_dev,
674 + "%s failed to set format %dx%d fmt %08X\n",
675 + __func__,
676 + f->fmt.pix.width,
677 + f->fmt.pix.height,
678 + f->fmt.pix.pixelformat
679 + );
680 + }
681 +
682 + if (!ret) {
683 ret = vchiq_mmal_component_enable(
684 dev->instance,
685 encode_component);
686 if (ret) {
687 v4l2_dbg(1, bcm2835_v4l2_debug,
688 - &dev->v4l2_dev,
689 - "%s Failed to enable encode components\n",
690 - __func__);
691 - } else {
692 - /* configure buffering */
693 - port->current_buffer.num = 1;
694 - port->current_buffer.size =
695 - f->fmt.pix.sizeimage;
696 - if (port->format.encoding ==
697 - MMAL_ENCODING_JPEG) {
698 - v4l2_dbg(1, bcm2835_v4l2_debug,
699 - &dev->v4l2_dev,
700 - "JPEG - fiddle buffer size\n");
701 - port->current_buffer.size =
702 - (f->fmt.pix.sizeimage <
703 - (100 << 10))
704 - ? (100 << 10) : f->fmt.pix.
705 - sizeimage;
706 - }
707 + &dev->v4l2_dev,
708 + "%s Failed to enable encode components\n",
709 + __func__);
710 + }
711 + }
712 + if (!ret) {
713 + /* configure buffering */
714 + port->current_buffer.num = 1;
715 + port->current_buffer.size =
716 + f->fmt.pix.sizeimage;
717 + if (port->format.encoding ==
718 + MMAL_ENCODING_JPEG) {
719 v4l2_dbg(1, bcm2835_v4l2_debug,
720 - &dev->v4l2_dev,
721 - "vid_cap - current_buffer.size being set to %d\n",
722 - f->fmt.pix.sizeimage);
723 - port->current_buffer.alignment = 0;
724 - ret =
725 - vchiq_mmal_port_connect_tunnel(
726 - dev->instance,
727 - camera_port,
728 - &encode_component->input[0]);
729 - if (ret) {
730 - v4l2_dbg(1, bcm2835_v4l2_debug,
731 - &dev->v4l2_dev,
732 - "%s failed to create connection\n",
733 - __func__);
734 - /* ensure capture is not going to be tried */
735 - dev->capture.port = NULL;
736 - }
737 + &dev->v4l2_dev,
738 + "JPG - buf size now %d was %d\n",
739 + f->fmt.pix.sizeimage,
740 + port->current_buffer.size);
741 + port->current_buffer.size =
742 + (f->fmt.pix.sizeimage <
743 + (100 << 10))
744 + ? (100 << 10) : f->fmt.pix.
745 + sizeimage;
746 }
747 + v4l2_dbg(1, bcm2835_v4l2_debug,
748 + &dev->v4l2_dev,
749 + "vid_cap - cur_buf.size set to %d\n",
750 + f->fmt.pix.sizeimage);
751 + port->current_buffer.alignment = 0;
752 }
753 } else {
754 /* configure buffering */
755 @@ -1001,13 +1162,20 @@ static int mmal_setup_components(struct bm2835_mmal_dev *dev,
756 if (!ret) {
757 dev->capture.fmt = mfmt;
758 dev->capture.stride = f->fmt.pix.bytesperline;
759 - dev->capture.width = port->es.video.crop.width;
760 - dev->capture.height = port->es.video.crop.height;
761 + dev->capture.width = camera_port->es.video.crop.width;
762 + dev->capture.height = camera_port->es.video.crop.height;
763 + dev->capture.buffersize = port->current_buffer.size;
764
765 /* select port for capture */
766 dev->capture.port = port;
767 dev->capture.camera_port = camera_port;
768 dev->capture.encode_component = encode_component;
769 + v4l2_dbg(1, bcm2835_v4l2_debug,
770 + &dev->v4l2_dev,
771 + "Set dev->capture.fmt %08X, %dx%d, stride %d, size %d",
772 + port->format.encoding,
773 + dev->capture.width, dev->capture.height,
774 + dev->capture.stride, dev->capture.buffersize);
775 }
776 }
777
778 @@ -1048,14 +1216,115 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
779 }
780
781 ret = mmal_setup_components(dev, f);
782 - if (ret != 0)
783 + if (ret != 0) {
784 v4l2_err(&dev->v4l2_dev,
785 "%s: failed to setup mmal components: %d\n",
786 __func__, ret);
787 + ret = -EINVAL;
788 + }
789
790 return ret;
791 }
792
793 +int vidioc_enum_framesizes(struct file *file, void *fh,
794 + struct v4l2_frmsizeenum *fsize)
795 +{
796 + static const struct v4l2_frmsize_stepwise sizes = {
797 + MIN_WIDTH, MAX_WIDTH, 2,
798 + MIN_HEIGHT, MAX_HEIGHT, 2
799 + };
800 + int i;
801 +
802 + if (fsize->index)
803 + return -EINVAL;
804 + for (i = 0; i < ARRAY_SIZE(formats); i++)
805 + if (formats[i].fourcc == fsize->pixel_format)
806 + break;
807 + if (i == ARRAY_SIZE(formats))
808 + return -EINVAL;
809 + fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
810 + fsize->stepwise = sizes;
811 + return 0;
812 +}
813 +
814 +/* timeperframe is arbitrary and continous */
815 +static int vidioc_enum_frameintervals(struct file *file, void *priv,
816 + struct v4l2_frmivalenum *fival)
817 +{
818 + int i;
819 +
820 + if (fival->index)
821 + return -EINVAL;
822 +
823 + for (i = 0; i < ARRAY_SIZE(formats); i++)
824 + if (formats[i].fourcc == fival->pixel_format)
825 + break;
826 + if (i == ARRAY_SIZE(formats))
827 + return -EINVAL;
828 +
829 + /* regarding width & height - we support any within range */
830 + if (fival->width < MIN_WIDTH || fival->width > MAX_WIDTH ||
831 + fival->height < MIN_HEIGHT || fival->height > MAX_HEIGHT)
832 + return -EINVAL;
833 +
834 + fival->type = V4L2_FRMIVAL_TYPE_CONTINUOUS;
835 +
836 + /* fill in stepwise (step=1.0 is requred by V4L2 spec) */
837 + fival->stepwise.min = tpf_min;
838 + fival->stepwise.max = tpf_max;
839 + fival->stepwise.step = (struct v4l2_fract) {1, 1};
840 +
841 + return 0;
842 +}
843 +
844 +static int vidioc_g_parm(struct file *file, void *priv,
845 + struct v4l2_streamparm *parm)
846 +{
847 + struct bm2835_mmal_dev *dev = video_drvdata(file);
848 +
849 + if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
850 + return -EINVAL;
851 +
852 + parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
853 + parm->parm.capture.timeperframe = dev->capture.timeperframe;
854 + parm->parm.capture.readbuffers = 1;
855 + return 0;
856 +}
857 +
858 +#define FRACT_CMP(a, OP, b) \
859 + ((u64)(a).numerator * (b).denominator OP \
860 + (u64)(b).numerator * (a).denominator)
861 +
862 +static int vidioc_s_parm(struct file *file, void *priv,
863 + struct v4l2_streamparm *parm)
864 +{
865 + struct bm2835_mmal_dev *dev = video_drvdata(file);
866 + struct v4l2_fract tpf;
867 + struct mmal_parameter_rational fps_param;
868 +
869 + if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
870 + return -EINVAL;
871 +
872 + tpf = parm->parm.capture.timeperframe;
873 +
874 + /* tpf: {*, 0} resets timing; clip to [min, max]*/
875 + tpf = tpf.denominator ? tpf : tpf_default;
876 + tpf = FRACT_CMP(tpf, <, tpf_min) ? tpf_min : tpf;
877 + tpf = FRACT_CMP(tpf, >, tpf_max) ? tpf_max : tpf;
878 +
879 + dev->capture.timeperframe = tpf;
880 + parm->parm.capture.timeperframe = tpf;
881 + parm->parm.capture.readbuffers = 1;
882 +
883 + fps_param.num = 0; /* Select variable fps, and then use
884 + * FPS_RANGE to select the actual limits.
885 + */
886 + fps_param.den = 1;
887 + set_framerate_params(dev);
888 +
889 + return 0;
890 +}
891 +
892 static const struct v4l2_ioctl_ops camera0_ioctl_ops = {
893 /* overlay */
894 .vidioc_enum_fmt_vid_overlay = vidioc_enum_fmt_vid_overlay,
895 @@ -1084,6 +1353,51 @@ static const struct v4l2_ioctl_ops camera0_ioctl_ops = {
896 .vidioc_querybuf = vb2_ioctl_querybuf,
897 .vidioc_qbuf = vb2_ioctl_qbuf,
898 .vidioc_dqbuf = vb2_ioctl_dqbuf,
899 + .vidioc_enum_framesizes = vidioc_enum_framesizes,
900 + .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
901 + .vidioc_g_parm = vidioc_g_parm,
902 + .vidioc_s_parm = vidioc_s_parm,
903 + .vidioc_streamon = vb2_ioctl_streamon,
904 + .vidioc_streamoff = vb2_ioctl_streamoff,
905 +
906 + .vidioc_log_status = v4l2_ctrl_log_status,
907 + .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
908 + .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
909 +};
910 +
911 +static const struct v4l2_ioctl_ops camera0_ioctl_ops_gstreamer = {
912 + /* overlay */
913 + .vidioc_enum_fmt_vid_overlay = vidioc_enum_fmt_vid_overlay,
914 + .vidioc_g_fmt_vid_overlay = vidioc_g_fmt_vid_overlay,
915 + .vidioc_try_fmt_vid_overlay = vidioc_try_fmt_vid_overlay,
916 + .vidioc_s_fmt_vid_overlay = vidioc_s_fmt_vid_overlay,
917 + .vidioc_overlay = vidioc_overlay,
918 + .vidioc_g_fbuf = vidioc_g_fbuf,
919 +
920 + /* inputs */
921 + .vidioc_enum_input = vidioc_enum_input,
922 + .vidioc_g_input = vidioc_g_input,
923 + .vidioc_s_input = vidioc_s_input,
924 +
925 + /* capture */
926 + .vidioc_querycap = vidioc_querycap,
927 + .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
928 + .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
929 + .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
930 + .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
931 +
932 + /* buffer management */
933 + .vidioc_reqbufs = vb2_ioctl_reqbufs,
934 + .vidioc_create_bufs = vb2_ioctl_create_bufs,
935 + .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
936 + .vidioc_querybuf = vb2_ioctl_querybuf,
937 + .vidioc_qbuf = vb2_ioctl_qbuf,
938 + .vidioc_dqbuf = vb2_ioctl_dqbuf,
939 + /* Remove this function ptr to fix gstreamer bug
940 + .vidioc_enum_framesizes = vidioc_enum_framesizes, */
941 + .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
942 + .vidioc_g_parm = vidioc_g_parm,
943 + .vidioc_s_parm = vidioc_s_parm,
944 .vidioc_streamon = vb2_ioctl_streamon,
945 .vidioc_streamoff = vb2_ioctl_streamoff,
946
947 @@ -1122,8 +1436,10 @@ static int set_camera_parameters(struct vchiq_mmal_instance *instance,
948 .max_stills_h = MAX_HEIGHT,
949 .stills_yuv422 = 1,
950 .one_shot_stills = 1,
951 - .max_preview_video_w = 1920,
952 - .max_preview_video_h = 1088,
953 + .max_preview_video_w = (max_video_width > 1920) ?
954 + max_video_width : 1920,
955 + .max_preview_video_h = (max_video_height > 1088) ?
956 + max_video_height : 1088,
957 .num_preview_video_frames = 3,
958 .stills_capture_circular_buffer_height = 0,
959 .fast_preview_resume = 0,
960 @@ -1141,6 +1457,7 @@ static int __init mmal_init(struct bm2835_mmal_dev *dev)
961 {
962 int ret;
963 struct mmal_es_format *format;
964 + u32 bool_true = 1;
965
966 ret = vchiq_mmal_init(&dev->instance);
967 if (ret < 0)
968 @@ -1176,8 +1493,8 @@ static int __init mmal_init(struct bm2835_mmal_dev *dev)
969 format->es->video.crop.y = 0;
970 format->es->video.crop.width = 1024;
971 format->es->video.crop.height = 768;
972 - format->es->video.frame_rate.num = PREVIEW_FRAME_RATE_NUM;
973 - format->es->video.frame_rate.den = PREVIEW_FRAME_RATE_DEN;
974 + format->es->video.frame_rate.num = 0; /* Rely on fps_range */
975 + format->es->video.frame_rate.den = 1;
976
977 format =
978 &dev->component[MMAL_COMPONENT_CAMERA]->
979 @@ -1192,8 +1509,14 @@ static int __init mmal_init(struct bm2835_mmal_dev *dev)
980 format->es->video.crop.y = 0;
981 format->es->video.crop.width = 1024;
982 format->es->video.crop.height = 768;
983 - format->es->video.frame_rate.num = PREVIEW_FRAME_RATE_NUM;
984 - format->es->video.frame_rate.den = PREVIEW_FRAME_RATE_DEN;
985 + format->es->video.frame_rate.num = 0; /* Rely on fps_range */
986 + format->es->video.frame_rate.den = 1;
987 +
988 + vchiq_mmal_port_parameter_set(dev->instance,
989 + &dev->component[MMAL_COMPONENT_CAMERA]->
990 + output[MMAL_CAMERA_PORT_VIDEO],
991 + MMAL_PARAMETER_NO_IMAGE_PADDING,
992 + &bool_true, sizeof(bool_true));
993
994 format =
995 &dev->component[MMAL_COMPONENT_CAMERA]->
996 @@ -1207,13 +1530,22 @@ static int __init mmal_init(struct bm2835_mmal_dev *dev)
997 format->es->video.crop.y = 0;
998 format->es->video.crop.width = 2592;
999 format->es->video.crop.height = 1944;
1000 - format->es->video.frame_rate.num = 30;
1001 + format->es->video.frame_rate.num = 0; /* Rely on fps_range */
1002 format->es->video.frame_rate.den = 1;
1003
1004 dev->capture.width = format->es->video.width;
1005 dev->capture.height = format->es->video.height;
1006 dev->capture.fmt = &formats[0];
1007 dev->capture.encode_component = NULL;
1008 + dev->capture.timeperframe = tpf_default;
1009 + dev->capture.enc_profile = V4L2_MPEG_VIDEO_H264_PROFILE_HIGH;
1010 + dev->capture.enc_level = V4L2_MPEG_VIDEO_H264_LEVEL_4_0;
1011 +
1012 + vchiq_mmal_port_parameter_set(dev->instance,
1013 + &dev->component[MMAL_COMPONENT_CAMERA]->
1014 + output[MMAL_CAMERA_PORT_CAPTURE],
1015 + MMAL_PARAMETER_NO_IMAGE_PADDING,
1016 + &bool_true, sizeof(bool_true));
1017
1018 /* get the preview component ready */
1019 ret = vchiq_mmal_component_init(
1020 @@ -1260,6 +1592,14 @@ static int __init mmal_init(struct bm2835_mmal_dev *dev)
1021 }
1022
1023 {
1024 + struct vchiq_mmal_port *encoder_port =
1025 + &dev->component[MMAL_COMPONENT_VIDEO_ENCODE]->output[0];
1026 + encoder_port->format.encoding = MMAL_ENCODING_H264;
1027 + ret = vchiq_mmal_port_set_format(dev->instance,
1028 + encoder_port);
1029 + }
1030 +
1031 + {
1032 unsigned int enable = 1;
1033 vchiq_mmal_port_parameter_set(
1034 dev->instance,
1035 @@ -1312,6 +1652,11 @@ static int __init bm2835_mmal_init_device(struct bm2835_mmal_dev *dev,
1036 int ret;
1037
1038 *vfd = vdev_template;
1039 + if (gst_v4l2src_is_broken) {
1040 + v4l2_info(&dev->v4l2_dev,
1041 + "Work-around for gstreamer issue is active.\n");
1042 + vfd->ioctl_ops = &camera0_ioctl_ops_gstreamer;
1043 + }
1044
1045 vfd->v4l2_dev = &dev->v4l2_dev;
1046
1047 @@ -1328,8 +1673,9 @@ static int __init bm2835_mmal_init_device(struct bm2835_mmal_dev *dev,
1048 if (ret < 0)
1049 return ret;
1050
1051 - v4l2_info(vfd->v4l2_dev, "V4L2 device registered as %s\n",
1052 - video_device_node_name(vfd));
1053 + v4l2_info(vfd->v4l2_dev,
1054 + "V4L2 device registered as %s - stills mode > %dx%d\n",
1055 + video_device_node_name(vfd), max_video_width, max_video_height);
1056
1057 return 0;
1058 }
1059 @@ -1337,9 +1683,9 @@ static int __init bm2835_mmal_init_device(struct bm2835_mmal_dev *dev,
1060 static struct v4l2_format default_v4l2_format = {
1061 .fmt.pix.pixelformat = V4L2_PIX_FMT_JPEG,
1062 .fmt.pix.width = 1024,
1063 - .fmt.pix.bytesperline = 1024 * 3 / 2,
1064 + .fmt.pix.bytesperline = 1024,
1065 .fmt.pix.height = 768,
1066 - .fmt.pix.sizeimage = 1<<18,
1067 + .fmt.pix.sizeimage = 1024*768,
1068 };
1069
1070 static int __init bm2835_mmal_init(void)
1071 @@ -1402,6 +1748,9 @@ static int __init bm2835_mmal_init(void)
1072 if (ret < 0)
1073 goto unreg_dev;
1074
1075 + /* Really want to call vidioc_s_fmt_vid_cap with the default
1076 + * format, but currently the APIs don't join up.
1077 + */
1078 ret = mmal_setup_components(dev, &default_v4l2_format);
1079 if (ret < 0) {
1080 v4l2_err(&dev->v4l2_dev,
1081 diff --git a/drivers/media/platform/bcm2835/bcm2835-camera.h b/drivers/media/platform/bcm2835/bcm2835-camera.h
1082 index 883eab7..7fe9f65 100644
1083 --- a/drivers/media/platform/bcm2835/bcm2835-camera.h
1084 +++ b/drivers/media/platform/bcm2835/bcm2835-camera.h
1085 @@ -15,7 +15,7 @@
1086 * core driver device
1087 */
1088
1089 -#define V4L2_CTRL_COUNT 18 /* number of v4l controls */
1090 +#define V4L2_CTRL_COUNT 28 /* number of v4l controls */
1091
1092 enum {
1093 MMAL_COMPONENT_CAMERA = 0,
1094 @@ -32,9 +32,6 @@ enum {
1095 MMAL_CAMERA_PORT_COUNT
1096 };
1097
1098 -#define PREVIEW_FRAME_RATE_NUM 30
1099 -#define PREVIEW_FRAME_RATE_DEN 1
1100 -
1101 #define PREVIEW_LAYER 2
1102
1103 extern int bcm2835_v4l2_debug;
1104 @@ -48,9 +45,19 @@ struct bm2835_mmal_dev {
1105 /* controls */
1106 struct v4l2_ctrl_handler ctrl_handler;
1107 struct v4l2_ctrl *ctrls[V4L2_CTRL_COUNT];
1108 + enum v4l2_scene_mode scene_mode;
1109 struct mmal_colourfx colourfx;
1110 int hflip;
1111 int vflip;
1112 + int red_gain;
1113 + int blue_gain;
1114 + enum mmal_parameter_exposuremode exposure_mode_user;
1115 + enum v4l2_exposure_auto_type exposure_mode_v4l2_user;
1116 + /* active exposure mode may differ if selected via a scene mode */
1117 + enum mmal_parameter_exposuremode exposure_mode_active;
1118 + enum mmal_parameter_exposuremeteringmode metering_mode;
1119 + unsigned int manual_shutter_speed;
1120 + bool exp_auto_priority;
1121
1122 /* allocated mmal instance and components */
1123 struct vchiq_mmal_instance *instance;
1124 @@ -63,12 +70,18 @@ struct bm2835_mmal_dev {
1125 unsigned int width; /* width */
1126 unsigned int height; /* height */
1127 unsigned int stride; /* stride */
1128 + unsigned int buffersize; /* buffer size with padding */
1129 struct mmal_fmt *fmt;
1130 + struct v4l2_fract timeperframe;
1131
1132 /* H264 encode bitrate */
1133 int encode_bitrate;
1134 /* H264 bitrate mode. CBR/VBR */
1135 int encode_bitrate_mode;
1136 + /* H264 profile */
1137 + enum v4l2_mpeg_video_h264_profile enc_profile;
1138 + /* H264 level */
1139 + enum v4l2_mpeg_video_h264_level enc_level;
1140 /* JPEG Q-factor */
1141 int q_factor;
1142
1143 @@ -98,7 +111,7 @@ int bm2835_mmal_init_controls(
1144 struct v4l2_ctrl_handler *hdl);
1145
1146 int bm2835_mmal_set_all_camera_controls(struct bm2835_mmal_dev *dev);
1147 -
1148 +int set_framerate_params(struct bm2835_mmal_dev *dev);
1149
1150 /* Debug helpers */
1151
1152 diff --git a/drivers/media/platform/bcm2835/controls.c b/drivers/media/platform/bcm2835/controls.c
1153 index d1408e5..3017b94 100644
1154 --- a/drivers/media/platform/bcm2835/controls.c
1155 +++ b/drivers/media/platform/bcm2835/controls.c
1156 @@ -30,11 +30,23 @@
1157 #include "mmal-parameters.h"
1158 #include "bcm2835-camera.h"
1159
1160 -/* The supported V4L2_CID_AUTO_EXPOSURE_BIAS values are from -24 to +24.
1161 - * These are in 1/6th increments so the effective range is -4.0EV to +4.0EV.
1162 +/* The supported V4L2_CID_AUTO_EXPOSURE_BIAS values are from -4.0 to +4.0.
1163 + * MMAL values are in 1/6th increments so the MMAL range is -24 to +24.
1164 + * V4L2 docs say value "is expressed in terms of EV, drivers should interpret
1165 + * the values as 0.001 EV units, where the value 1000 stands for +1 EV."
1166 + * V4L2 is limited to a max of 32 values in a menu, so count in 1/3rds from
1167 + * -4 to +4
1168 */
1169 static const s64 ev_bias_qmenu[] = {
1170 - -24, -21, -18, -15, -12, -9, -6, -3, 0, 3, 6, 9, 12, 15, 18, 21, 24
1171 + -4000, -3667, -3333,
1172 + -3000, -2667, -2333,
1173 + -2000, -1667, -1333,
1174 + -1000, -667, -333,
1175 + 0, 333, 667,
1176 + 1000, 1333, 1667,
1177 + 2000, 2333, 2667,
1178 + 3000, 3333, 3667,
1179 + 4000
1180 };
1181
1182 /* Supported ISO values
1183 @@ -44,13 +56,19 @@ static const s64 iso_qmenu[] = {
1184 0, 100, 200, 400, 800,
1185 };
1186
1187 +static const s64 mains_freq_qmenu[] = {
1188 + V4L2_CID_POWER_LINE_FREQUENCY_DISABLED,
1189 + V4L2_CID_POWER_LINE_FREQUENCY_50HZ,
1190 + V4L2_CID_POWER_LINE_FREQUENCY_60HZ,
1191 + V4L2_CID_POWER_LINE_FREQUENCY_AUTO
1192 +};
1193 +
1194 /* Supported video encode modes */
1195 static const s64 bitrate_mode_qmenu[] = {
1196 (s64)V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
1197 (s64)V4L2_MPEG_VIDEO_BITRATE_MODE_CBR,
1198 };
1199
1200 -
1201 enum bm2835_mmal_ctrl_type {
1202 MMAL_CONTROL_TYPE_STD,
1203 MMAL_CONTROL_TYPE_STD_MENU,
1204 @@ -77,6 +95,7 @@ struct bm2835_mmal_v4l2_ctrl {
1205 const s64 *imenu; /* integer menu array */
1206 u32 mmal_id; /* mmal parameter id */
1207 bm2835_mmal_v4l2_ctrl_cb *setter;
1208 + bool ignore_errors;
1209 };
1210
1211 struct v4l2_to_mmal_effects_setting {
1212 @@ -126,6 +145,25 @@ static const struct v4l2_to_mmal_effects_setting
1213 1, 1, 0, 0, 0, {0, 0, 0, 0, 0} }
1214 };
1215
1216 +struct v4l2_mmal_scene_config {
1217 + enum v4l2_scene_mode v4l2_scene;
1218 + enum mmal_parameter_exposuremode exposure_mode;
1219 + enum mmal_parameter_exposuremeteringmode metering_mode;
1220 +};
1221 +
1222 +static const struct v4l2_mmal_scene_config scene_configs[] = {
1223 + /* V4L2_SCENE_MODE_NONE automatically added */
1224 + {
1225 + V4L2_SCENE_MODE_NIGHT,
1226 + MMAL_PARAM_EXPOSUREMODE_NIGHT,
1227 + MMAL_PARAM_EXPOSUREMETERINGMODE_AVERAGE
1228 + },
1229 + {
1230 + V4L2_SCENE_MODE_SPORTS,
1231 + MMAL_PARAM_EXPOSUREMODE_SPORTS,
1232 + MMAL_PARAM_EXPOSUREMETERINGMODE_AVERAGE
1233 + },
1234 +};
1235
1236 /* control handlers*/
1237
1238 @@ -133,10 +171,7 @@ static int ctrl_set_rational(struct bm2835_mmal_dev *dev,
1239 struct v4l2_ctrl *ctrl,
1240 const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1241 {
1242 - struct {
1243 - s32 num; /**< Numerator */
1244 - s32 den; /**< Denominator */
1245 - } rational_value;
1246 + struct mmal_parameter_rational rational_value;
1247 struct vchiq_mmal_port *control;
1248
1249 control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
1250 @@ -166,6 +201,41 @@ static int ctrl_set_value(struct bm2835_mmal_dev *dev,
1251 &u32_value, sizeof(u32_value));
1252 }
1253
1254 +static int ctrl_set_value_menu(struct bm2835_mmal_dev *dev,
1255 + struct v4l2_ctrl *ctrl,
1256 + const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1257 +{
1258 + u32 u32_value;
1259 + struct vchiq_mmal_port *control;
1260 +
1261 + if (ctrl->val > mmal_ctrl->max || ctrl->val < mmal_ctrl->min)
1262 + return 1;
1263 +
1264 + control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
1265 +
1266 + u32_value = mmal_ctrl->imenu[ctrl->val];
1267 +
1268 + return vchiq_mmal_port_parameter_set(dev->instance, control,
1269 + mmal_ctrl->mmal_id,
1270 + &u32_value, sizeof(u32_value));
1271 +}
1272 +
1273 +static int ctrl_set_value_ev(struct bm2835_mmal_dev *dev,
1274 + struct v4l2_ctrl *ctrl,
1275 + const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1276 +{
1277 + s32 s32_value;
1278 + struct vchiq_mmal_port *control;
1279 +
1280 + control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
1281 +
1282 + s32_value = (ctrl->val-12)*2; /* Convert from index to 1/6ths */
1283 +
1284 + return vchiq_mmal_port_parameter_set(dev->instance, control,
1285 + mmal_ctrl->mmal_id,
1286 + &s32_value, sizeof(s32_value));
1287 +}
1288 +
1289 static int ctrl_set_rotate(struct bm2835_mmal_dev *dev,
1290 struct v4l2_ctrl *ctrl,
1291 const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1292 @@ -245,37 +315,97 @@ static int ctrl_set_exposure(struct bm2835_mmal_dev *dev,
1293 struct v4l2_ctrl *ctrl,
1294 const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1295 {
1296 - u32 u32_value;
1297 + enum mmal_parameter_exposuremode exp_mode = dev->exposure_mode_user;
1298 + u32 shutter_speed = 0;
1299 struct vchiq_mmal_port *control;
1300 + int ret = 0;
1301
1302 control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
1303
1304 + if (mmal_ctrl->mmal_id == MMAL_PARAMETER_SHUTTER_SPEED) {
1305 + /* V4L2 is in 100usec increments.
1306 + * MMAL is 1usec.
1307 + */
1308 + dev->manual_shutter_speed = ctrl->val * 100;
1309 + } else if (mmal_ctrl->mmal_id == MMAL_PARAMETER_EXPOSURE_MODE) {
1310 + switch (ctrl->val) {
1311 + case V4L2_EXPOSURE_AUTO:
1312 + exp_mode = MMAL_PARAM_EXPOSUREMODE_AUTO;
1313 + break;
1314 +
1315 + case V4L2_EXPOSURE_MANUAL:
1316 + exp_mode = MMAL_PARAM_EXPOSUREMODE_OFF;
1317 + break;
1318 + }
1319 + dev->exposure_mode_user = exp_mode;
1320 + dev->exposure_mode_v4l2_user = ctrl->val;
1321 + } else if (mmal_ctrl->id == V4L2_CID_EXPOSURE_AUTO_PRIORITY) {
1322 + dev->exp_auto_priority = ctrl->val;
1323 + }
1324 +
1325 + if (dev->scene_mode == V4L2_SCENE_MODE_NONE) {
1326 + if (exp_mode == MMAL_PARAM_EXPOSUREMODE_OFF)
1327 + shutter_speed = dev->manual_shutter_speed;
1328 +
1329 + ret = vchiq_mmal_port_parameter_set(dev->instance,
1330 + control,
1331 + MMAL_PARAMETER_SHUTTER_SPEED,
1332 + &shutter_speed,
1333 + sizeof(shutter_speed));
1334 + ret += vchiq_mmal_port_parameter_set(dev->instance,
1335 + control,
1336 + MMAL_PARAMETER_EXPOSURE_MODE,
1337 + &exp_mode,
1338 + sizeof(u32));
1339 + dev->exposure_mode_active = exp_mode;
1340 + }
1341 + /* exposure_dynamic_framerate (V4L2_CID_EXPOSURE_AUTO_PRIORITY) should
1342 + * always apply irrespective of scene mode.
1343 + */
1344 + ret += set_framerate_params(dev);
1345 +
1346 + return ret;
1347 +}
1348 +
1349 +static int ctrl_set_metering_mode(struct bm2835_mmal_dev *dev,
1350 + struct v4l2_ctrl *ctrl,
1351 + const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1352 +{
1353 switch (ctrl->val) {
1354 - case V4L2_EXPOSURE_AUTO:
1355 - u32_value = MMAL_PARAM_EXPOSUREMODE_AUTO;
1356 + case V4L2_EXPOSURE_METERING_AVERAGE:
1357 + dev->metering_mode = MMAL_PARAM_EXPOSUREMETERINGMODE_AVERAGE;
1358 break;
1359
1360 - case V4L2_EXPOSURE_MANUAL:
1361 - u32_value = MMAL_PARAM_EXPOSUREMODE_OFF;
1362 + case V4L2_EXPOSURE_METERING_CENTER_WEIGHTED:
1363 + dev->metering_mode = MMAL_PARAM_EXPOSUREMETERINGMODE_BACKLIT;
1364 break;
1365
1366 - case V4L2_EXPOSURE_SHUTTER_PRIORITY:
1367 - u32_value = MMAL_PARAM_EXPOSUREMODE_SPORTS;
1368 + case V4L2_EXPOSURE_METERING_SPOT:
1369 + dev->metering_mode = MMAL_PARAM_EXPOSUREMETERINGMODE_SPOT;
1370 break;
1371
1372 - case V4L2_EXPOSURE_APERTURE_PRIORITY:
1373 - u32_value = MMAL_PARAM_EXPOSUREMODE_NIGHT;
1374 + /* todo matrix weighting not added to Linux API till 3.9
1375 + case V4L2_EXPOSURE_METERING_MATRIX:
1376 + dev->metering_mode = MMAL_PARAM_EXPOSUREMETERINGMODE_MATRIX;
1377 break;
1378 + */
1379
1380 }
1381
1382 - /* todo: what about the other ten modes there are MMAL parameters for */
1383 - return vchiq_mmal_port_parameter_set(dev->instance, control,
1384 + if (dev->scene_mode == V4L2_SCENE_MODE_NONE) {
1385 + struct vchiq_mmal_port *control;
1386 + u32 u32_value = dev->metering_mode;
1387 +
1388 + control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
1389 +
1390 + return vchiq_mmal_port_parameter_set(dev->instance, control,
1391 mmal_ctrl->mmal_id,
1392 &u32_value, sizeof(u32_value));
1393 + } else
1394 + return 0;
1395 }
1396
1397 -static int ctrl_set_metering_mode(struct bm2835_mmal_dev *dev,
1398 +static int ctrl_set_flicker_avoidance(struct bm2835_mmal_dev *dev,
1399 struct v4l2_ctrl *ctrl,
1400 const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1401 {
1402 @@ -285,24 +415,18 @@ static int ctrl_set_metering_mode(struct bm2835_mmal_dev *dev,
1403 control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
1404
1405 switch (ctrl->val) {
1406 - case V4L2_EXPOSURE_METERING_AVERAGE:
1407 - u32_value = MMAL_PARAM_EXPOSUREMETERINGMODE_AVERAGE;
1408 + case V4L2_CID_POWER_LINE_FREQUENCY_DISABLED:
1409 + u32_value = MMAL_PARAM_FLICKERAVOID_OFF;
1410 break;
1411 -
1412 - case V4L2_EXPOSURE_METERING_CENTER_WEIGHTED:
1413 - u32_value = MMAL_PARAM_EXPOSUREMETERINGMODE_BACKLIT;
1414 + case V4L2_CID_POWER_LINE_FREQUENCY_50HZ:
1415 + u32_value = MMAL_PARAM_FLICKERAVOID_50HZ;
1416 break;
1417 -
1418 - case V4L2_EXPOSURE_METERING_SPOT:
1419 - u32_value = MMAL_PARAM_EXPOSUREMETERINGMODE_SPOT;
1420 + case V4L2_CID_POWER_LINE_FREQUENCY_60HZ:
1421 + u32_value = MMAL_PARAM_FLICKERAVOID_60HZ;
1422 break;
1423 -
1424 - /* todo matrix weighting not added to Linux API till 3.9
1425 - case V4L2_EXPOSURE_METERING_MATRIX:
1426 - u32_value = MMAL_PARAM_EXPOSUREMETERINGMODE_MATRIX;
1427 + case V4L2_CID_POWER_LINE_FREQUENCY_AUTO:
1428 + u32_value = MMAL_PARAM_FLICKERAVOID_AUTO;
1429 break;
1430 - */
1431 -
1432 }
1433
1434 return vchiq_mmal_port_parameter_set(dev->instance, control,
1435 @@ -367,6 +491,29 @@ static int ctrl_set_awb_mode(struct bm2835_mmal_dev *dev,
1436 &u32_value, sizeof(u32_value));
1437 }
1438
1439 +static int ctrl_set_awb_gains(struct bm2835_mmal_dev *dev,
1440 + struct v4l2_ctrl *ctrl,
1441 + const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1442 +{
1443 + struct vchiq_mmal_port *control;
1444 + struct mmal_parameter_awbgains gains;
1445 +
1446 + control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
1447 +
1448 + if (ctrl->id == V4L2_CID_RED_BALANCE)
1449 + dev->red_gain = ctrl->val;
1450 + else if (ctrl->id == V4L2_CID_BLUE_BALANCE)
1451 + dev->blue_gain = ctrl->val;
1452 +
1453 + gains.r_gain.num = dev->red_gain;
1454 + gains.b_gain.num = dev->blue_gain;
1455 + gains.r_gain.den = gains.b_gain.den = 1000;
1456 +
1457 + return vchiq_mmal_port_parameter_set(dev->instance, control,
1458 + mmal_ctrl->mmal_id,
1459 + &gains, sizeof(gains));
1460 +}
1461 +
1462 static int ctrl_set_image_effect(struct bm2835_mmal_dev *dev,
1463 struct v4l2_ctrl *ctrl,
1464 const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1465 @@ -443,8 +590,8 @@ static int ctrl_set_colfx(struct bm2835_mmal_dev *dev,
1466 &dev->colourfx, sizeof(dev->colourfx));
1467
1468 v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
1469 - "After: mmal_ctrl:%p ctrl id:0x%x ctrl val:%d ret %d(%d)\n",
1470 - mmal_ctrl, ctrl->id, ctrl->val, ret,
1471 + "%s: After: mmal_ctrl:%p ctrl id:0x%x ctrl val:%d ret %d(%d)\n",
1472 + __func__, mmal_ctrl, ctrl->id, ctrl->val, ret,
1473 (ret == 0 ? 0 : -EINVAL));
1474 return (ret == 0 ? 0 : EINVAL);
1475 }
1476 @@ -494,7 +641,7 @@ static int ctrl_set_bitrate_mode(struct bm2835_mmal_dev *dev,
1477 return 0;
1478 }
1479
1480 -static int ctrl_set_q_factor(struct bm2835_mmal_dev *dev,
1481 +static int ctrl_set_image_encode_output(struct bm2835_mmal_dev *dev,
1482 struct v4l2_ctrl *ctrl,
1483 const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1484 {
1485 @@ -510,12 +657,247 @@ static int ctrl_set_q_factor(struct bm2835_mmal_dev *dev,
1486 &u32_value, sizeof(u32_value));
1487 }
1488
1489 +static int ctrl_set_video_encode_param_output(struct bm2835_mmal_dev *dev,
1490 + struct v4l2_ctrl *ctrl,
1491 + const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1492 +{
1493 + u32 u32_value;
1494 + struct vchiq_mmal_port *vid_enc_ctl;
1495 +
1496 + vid_enc_ctl = &dev->component[MMAL_COMPONENT_VIDEO_ENCODE]->output[0];
1497 +
1498 + u32_value = ctrl->val;
1499 +
1500 + return vchiq_mmal_port_parameter_set(dev->instance, vid_enc_ctl,
1501 + mmal_ctrl->mmal_id,
1502 + &u32_value, sizeof(u32_value));
1503 +}
1504 +
1505 +static int ctrl_set_video_encode_profile_level(struct bm2835_mmal_dev *dev,
1506 + struct v4l2_ctrl *ctrl,
1507 + const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1508 +{
1509 + struct mmal_parameter_video_profile param;
1510 + int ret = 0;
1511 +
1512 + if (ctrl->id == V4L2_CID_MPEG_VIDEO_H264_PROFILE) {
1513 + switch (ctrl->val) {
1514 + case V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE:
1515 + case V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE:
1516 + case V4L2_MPEG_VIDEO_H264_PROFILE_MAIN:
1517 + case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH:
1518 + dev->capture.enc_profile = ctrl->val;
1519 + break;
1520 + default:
1521 + ret = -EINVAL;
1522 + break;
1523 + }
1524 + } else if (ctrl->id == V4L2_CID_MPEG_VIDEO_H264_LEVEL) {
1525 + switch (ctrl->val) {
1526 + case V4L2_MPEG_VIDEO_H264_LEVEL_1_0:
1527 + case V4L2_MPEG_VIDEO_H264_LEVEL_1B:
1528 + case V4L2_MPEG_VIDEO_H264_LEVEL_1_1:
1529 + case V4L2_MPEG_VIDEO_H264_LEVEL_1_2:
1530 + case V4L2_MPEG_VIDEO_H264_LEVEL_1_3:
1531 + case V4L2_MPEG_VIDEO_H264_LEVEL_2_0:
1532 + case V4L2_MPEG_VIDEO_H264_LEVEL_2_1:
1533 + case V4L2_MPEG_VIDEO_H264_LEVEL_2_2:
1534 + case V4L2_MPEG_VIDEO_H264_LEVEL_3_0:
1535 + case V4L2_MPEG_VIDEO_H264_LEVEL_3_1:
1536 + case V4L2_MPEG_VIDEO_H264_LEVEL_3_2:
1537 + case V4L2_MPEG_VIDEO_H264_LEVEL_4_0:
1538 + dev->capture.enc_level = ctrl->val;
1539 + break;
1540 + default:
1541 + ret = -EINVAL;
1542 + break;
1543 + }
1544 + }
1545 +
1546 + if (!ret) {
1547 + switch (dev->capture.enc_profile) {
1548 + case V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE:
1549 + param.profile = MMAL_VIDEO_PROFILE_H264_BASELINE;
1550 + break;
1551 + case V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE:
1552 + param.profile =
1553 + MMAL_VIDEO_PROFILE_H264_CONSTRAINED_BASELINE;
1554 + break;
1555 + case V4L2_MPEG_VIDEO_H264_PROFILE_MAIN:
1556 + param.profile = MMAL_VIDEO_PROFILE_H264_MAIN;
1557 + break;
1558 + case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH:
1559 + param.profile = MMAL_VIDEO_PROFILE_H264_HIGH;
1560 + break;
1561 + default:
1562 + /* Should never get here */
1563 + break;
1564 + }
1565 +
1566 + switch (dev->capture.enc_level) {
1567 + case V4L2_MPEG_VIDEO_H264_LEVEL_1_0:
1568 + param.level = MMAL_VIDEO_LEVEL_H264_1;
1569 + break;
1570 + case V4L2_MPEG_VIDEO_H264_LEVEL_1B:
1571 + param.level = MMAL_VIDEO_LEVEL_H264_1b;
1572 + break;
1573 + case V4L2_MPEG_VIDEO_H264_LEVEL_1_1:
1574 + param.level = MMAL_VIDEO_LEVEL_H264_11;
1575 + break;
1576 + case V4L2_MPEG_VIDEO_H264_LEVEL_1_2:
1577 + param.level = MMAL_VIDEO_LEVEL_H264_12;
1578 + break;
1579 + case V4L2_MPEG_VIDEO_H264_LEVEL_1_3:
1580 + param.level = MMAL_VIDEO_LEVEL_H264_13;
1581 + break;
1582 + case V4L2_MPEG_VIDEO_H264_LEVEL_2_0:
1583 + param.level = MMAL_VIDEO_LEVEL_H264_2;
1584 + break;
1585 + case V4L2_MPEG_VIDEO_H264_LEVEL_2_1:
1586 + param.level = MMAL_VIDEO_LEVEL_H264_21;
1587 + break;
1588 + case V4L2_MPEG_VIDEO_H264_LEVEL_2_2:
1589 + param.level = MMAL_VIDEO_LEVEL_H264_22;
1590 + break;
1591 + case V4L2_MPEG_VIDEO_H264_LEVEL_3_0:
1592 + param.level = MMAL_VIDEO_LEVEL_H264_3;
1593 + break;
1594 + case V4L2_MPEG_VIDEO_H264_LEVEL_3_1:
1595 + param.level = MMAL_VIDEO_LEVEL_H264_31;
1596 + break;
1597 + case V4L2_MPEG_VIDEO_H264_LEVEL_3_2:
1598 + param.level = MMAL_VIDEO_LEVEL_H264_32;
1599 + break;
1600 + case V4L2_MPEG_VIDEO_H264_LEVEL_4_0:
1601 + param.level = MMAL_VIDEO_LEVEL_H264_4;
1602 + break;
1603 + default:
1604 + /* Should never get here */
1605 + break;
1606 + }
1607 +
1608 + ret = vchiq_mmal_port_parameter_set(dev->instance,
1609 + &dev->component[MMAL_COMPONENT_VIDEO_ENCODE]->output[0],
1610 + mmal_ctrl->mmal_id,
1611 + &param, sizeof(param));
1612 + }
1613 + return ret;
1614 +}
1615 +
1616 +static int ctrl_set_scene_mode(struct bm2835_mmal_dev *dev,
1617 + struct v4l2_ctrl *ctrl,
1618 + const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1619 +{
1620 + int ret = 0;
1621 + int shutter_speed;
1622 + struct vchiq_mmal_port *control;
1623 +
1624 + v4l2_dbg(0, bcm2835_v4l2_debug, &dev->v4l2_dev,
1625 + "scene mode selected %d, was %d\n", ctrl->val,
1626 + dev->scene_mode);
1627 + control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
1628 +
1629 + if (ctrl->val == dev->scene_mode)
1630 + return 0;
1631 +
1632 + if (ctrl->val == V4L2_SCENE_MODE_NONE) {
1633 + /* Restore all user selections */
1634 + dev->scene_mode = V4L2_SCENE_MODE_NONE;
1635 +
1636 + if (dev->exposure_mode_user == MMAL_PARAM_EXPOSUREMODE_OFF)
1637 + shutter_speed = dev->manual_shutter_speed;
1638 + else
1639 + shutter_speed = 0;
1640 +
1641 + v4l2_dbg(0, bcm2835_v4l2_debug, &dev->v4l2_dev,
1642 + "%s: scene mode none: shut_speed %d, exp_mode %d, metering %d\n",
1643 + __func__, shutter_speed, dev->exposure_mode_user,
1644 + dev->metering_mode);
1645 + ret = vchiq_mmal_port_parameter_set(dev->instance,
1646 + control,
1647 + MMAL_PARAMETER_SHUTTER_SPEED,
1648 + &shutter_speed,
1649 + sizeof(shutter_speed));
1650 + ret += vchiq_mmal_port_parameter_set(dev->instance,
1651 + control,
1652 + MMAL_PARAMETER_EXPOSURE_MODE,
1653 + &dev->exposure_mode_user,
1654 + sizeof(u32));
1655 + dev->exposure_mode_active = dev->exposure_mode_user;
1656 + ret += vchiq_mmal_port_parameter_set(dev->instance,
1657 + control,
1658 + MMAL_PARAMETER_EXP_METERING_MODE,
1659 + &dev->metering_mode,
1660 + sizeof(u32));
1661 + ret += set_framerate_params(dev);
1662 + } else {
1663 + /* Set up scene mode */
1664 + int i;
1665 + const struct v4l2_mmal_scene_config *scene = NULL;
1666 + int shutter_speed;
1667 + enum mmal_parameter_exposuremode exposure_mode;
1668 + enum mmal_parameter_exposuremeteringmode metering_mode;
1669 +
1670 + for (i = 0; i < ARRAY_SIZE(scene_configs); i++) {
1671 + if (scene_configs[i].v4l2_scene ==
1672 + ctrl->val) {
1673 + scene = &scene_configs[i];
1674 + break;
1675 + }
1676 + }
1677 + if (i >= ARRAY_SIZE(scene_configs))
1678 + return -EINVAL;
1679 +
1680 + /* Set all the values */
1681 + dev->scene_mode = ctrl->val;
1682 +
1683 + if (scene->exposure_mode == MMAL_PARAM_EXPOSUREMODE_OFF)
1684 + shutter_speed = dev->manual_shutter_speed;
1685 + else
1686 + shutter_speed = 0;
1687 + exposure_mode = scene->exposure_mode;
1688 + metering_mode = scene->metering_mode;
1689 +
1690 + v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
1691 + "%s: scene mode none: shut_speed %d, exp_mode %d, metering %d\n",
1692 + __func__, shutter_speed, exposure_mode, metering_mode);
1693 +
1694 + ret = vchiq_mmal_port_parameter_set(dev->instance, control,
1695 + MMAL_PARAMETER_SHUTTER_SPEED,
1696 + &shutter_speed,
1697 + sizeof(shutter_speed));
1698 + ret += vchiq_mmal_port_parameter_set(dev->instance,
1699 + control,
1700 + MMAL_PARAMETER_EXPOSURE_MODE,
1701 + &exposure_mode,
1702 + sizeof(u32));
1703 + dev->exposure_mode_active = exposure_mode;
1704 + ret += vchiq_mmal_port_parameter_set(dev->instance, control,
1705 + MMAL_PARAMETER_EXPOSURE_MODE,
1706 + &exposure_mode,
1707 + sizeof(u32));
1708 + ret += vchiq_mmal_port_parameter_set(dev->instance, control,
1709 + MMAL_PARAMETER_EXP_METERING_MODE,
1710 + &metering_mode,
1711 + sizeof(u32));
1712 + ret += set_framerate_params(dev);
1713 + }
1714 + if (ret) {
1715 + v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
1716 + "%s: Setting scene to %d, ret=%d\n",
1717 + __func__, ctrl->val, ret);
1718 + ret = -EINVAL;
1719 + }
1720 + return 0;
1721 +}
1722 +
1723 static int bm2835_mmal_s_ctrl(struct v4l2_ctrl *ctrl)
1724 {
1725 struct bm2835_mmal_dev *dev =
1726 container_of(ctrl->handler, struct bm2835_mmal_dev,
1727 ctrl_handler);
1728 const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl = ctrl->priv;
1729 + int ret;
1730
1731 if ((mmal_ctrl == NULL) ||
1732 (mmal_ctrl->id != ctrl->id) ||
1733 @@ -524,7 +906,13 @@ static int bm2835_mmal_s_ctrl(struct v4l2_ctrl *ctrl)
1734 return -EINVAL;
1735 }
1736
1737 - return mmal_ctrl->setter(dev, ctrl, mmal_ctrl);
1738 + ret = mmal_ctrl->setter(dev, ctrl, mmal_ctrl);
1739 + if (ret)
1740 + pr_warn("ctrl id:%d/MMAL param %08X- returned ret %d\n",
1741 + ctrl->id, mmal_ctrl->mmal_id, ret);
1742 + if (mmal_ctrl->ignore_errors)
1743 + ret = 0;
1744 + return ret;
1745 }
1746
1747 static const struct v4l2_ctrl_ops bm2835_mmal_ctrl_ops = {
1748 @@ -537,40 +925,54 @@ static const struct bm2835_mmal_v4l2_ctrl v4l2_ctrls[V4L2_CTRL_COUNT] = {
1749 {
1750 V4L2_CID_SATURATION, MMAL_CONTROL_TYPE_STD,
1751 -100, 100, 0, 1, NULL,
1752 - MMAL_PARAMETER_SATURATION, &ctrl_set_rational
1753 + MMAL_PARAMETER_SATURATION,
1754 + &ctrl_set_rational,
1755 + false
1756 },
1757 {
1758 V4L2_CID_SHARPNESS, MMAL_CONTROL_TYPE_STD,
1759 -100, 100, 0, 1, NULL,
1760 - MMAL_PARAMETER_SHARPNESS, &ctrl_set_rational
1761 + MMAL_PARAMETER_SHARPNESS,
1762 + &ctrl_set_rational,
1763 + false
1764 },
1765 {
1766 V4L2_CID_CONTRAST, MMAL_CONTROL_TYPE_STD,
1767 -100, 100, 0, 1, NULL,
1768 - MMAL_PARAMETER_CONTRAST, &ctrl_set_rational
1769 + MMAL_PARAMETER_CONTRAST,
1770 + &ctrl_set_rational,
1771 + false
1772 },
1773 {
1774 V4L2_CID_BRIGHTNESS, MMAL_CONTROL_TYPE_STD,
1775 0, 100, 50, 1, NULL,
1776 - MMAL_PARAMETER_BRIGHTNESS, &ctrl_set_rational
1777 + MMAL_PARAMETER_BRIGHTNESS,
1778 + &ctrl_set_rational,
1779 + false
1780 },
1781 {
1782 V4L2_CID_ISO_SENSITIVITY, MMAL_CONTROL_TYPE_INT_MENU,
1783 0, ARRAY_SIZE(iso_qmenu) - 1, 0, 1, iso_qmenu,
1784 - MMAL_PARAMETER_ISO, &ctrl_set_value
1785 + MMAL_PARAMETER_ISO,
1786 + &ctrl_set_value_menu,
1787 + false
1788 },
1789 {
1790 V4L2_CID_IMAGE_STABILIZATION, MMAL_CONTROL_TYPE_STD,
1791 0, 1, 0, 1, NULL,
1792 - MMAL_PARAMETER_VIDEO_STABILISATION, &ctrl_set_value
1793 + MMAL_PARAMETER_VIDEO_STABILISATION,
1794 + &ctrl_set_value,
1795 + false
1796 },
1797 /* {
1798 0, MMAL_CONTROL_TYPE_CLUSTER, 3, 1, 0, NULL, 0, NULL
1799 - },
1800 -*/ {
1801 + }, */
1802 + {
1803 V4L2_CID_EXPOSURE_AUTO, MMAL_CONTROL_TYPE_STD_MENU,
1804 ~0x03, 3, V4L2_EXPOSURE_AUTO, 0, NULL,
1805 - MMAL_PARAMETER_EXPOSURE_MODE, &ctrl_set_exposure
1806 + MMAL_PARAMETER_EXPOSURE_MODE,
1807 + &ctrl_set_exposure,
1808 + false
1809 },
1810 /* todo this needs mixing in with set exposure
1811 {
1812 @@ -578,83 +980,258 @@ static const struct bm2835_mmal_v4l2_ctrl v4l2_ctrls[V4L2_CTRL_COUNT] = {
1813 },
1814 */
1815 {
1816 + V4L2_CID_EXPOSURE_ABSOLUTE, MMAL_CONTROL_TYPE_STD,
1817 + /* Units of 100usecs */
1818 + 1, 1*1000*10, 100*10, 1, NULL,
1819 + MMAL_PARAMETER_SHUTTER_SPEED,
1820 + &ctrl_set_exposure,
1821 + false
1822 + },
1823 + {
1824 V4L2_CID_AUTO_EXPOSURE_BIAS, MMAL_CONTROL_TYPE_INT_MENU,
1825 0, ARRAY_SIZE(ev_bias_qmenu) - 1,
1826 (ARRAY_SIZE(ev_bias_qmenu)+1)/2 - 1, 0, ev_bias_qmenu,
1827 - MMAL_PARAMETER_EXPOSURE_COMP, &ctrl_set_value
1828 + MMAL_PARAMETER_EXPOSURE_COMP,
1829 + &ctrl_set_value_ev,
1830 + false
1831 + },
1832 + {
1833 + V4L2_CID_EXPOSURE_AUTO_PRIORITY, MMAL_CONTROL_TYPE_STD,
1834 + 0, 1,
1835 + 0, 1, NULL,
1836 + 0, /* Dummy MMAL ID as it gets mapped into FPS range*/
1837 + &ctrl_set_exposure,
1838 + false
1839 },
1840 {
1841 V4L2_CID_EXPOSURE_METERING,
1842 MMAL_CONTROL_TYPE_STD_MENU,
1843 ~0x7, 2, V4L2_EXPOSURE_METERING_AVERAGE, 0, NULL,
1844 - MMAL_PARAMETER_EXP_METERING_MODE, &ctrl_set_metering_mode
1845 + MMAL_PARAMETER_EXP_METERING_MODE,
1846 + &ctrl_set_metering_mode,
1847 + false
1848 },
1849 {
1850 V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE,
1851 MMAL_CONTROL_TYPE_STD_MENU,
1852 - ~0x3fe, 9, V4L2_WHITE_BALANCE_AUTO, 0, NULL,
1853 - MMAL_PARAMETER_AWB_MODE, &ctrl_set_awb_mode
1854 + ~0x3ff, 9, V4L2_WHITE_BALANCE_AUTO, 0, NULL,
1855 + MMAL_PARAMETER_AWB_MODE,
1856 + &ctrl_set_awb_mode,
1857 + false
1858 + },
1859 + {
1860 + V4L2_CID_RED_BALANCE, MMAL_CONTROL_TYPE_STD,
1861 + 1, 7999, 1000, 1, NULL,
1862 + MMAL_PARAMETER_CUSTOM_AWB_GAINS,
1863 + &ctrl_set_awb_gains,
1864 + false
1865 + },
1866 + {
1867 + V4L2_CID_BLUE_BALANCE, MMAL_CONTROL_TYPE_STD,
1868 + 1, 7999, 1000, 1, NULL,
1869 + MMAL_PARAMETER_CUSTOM_AWB_GAINS,
1870 + &ctrl_set_awb_gains,
1871 + false
1872 },
1873 {
1874 V4L2_CID_COLORFX, MMAL_CONTROL_TYPE_STD_MENU,
1875 0, 15, V4L2_COLORFX_NONE, 0, NULL,
1876 - MMAL_PARAMETER_IMAGE_EFFECT, &ctrl_set_image_effect
1877 + MMAL_PARAMETER_IMAGE_EFFECT,
1878 + &ctrl_set_image_effect,
1879 + false
1880 },
1881 {
1882 V4L2_CID_COLORFX_CBCR, MMAL_CONTROL_TYPE_STD,
1883 0, 0xffff, 0x8080, 1, NULL,
1884 - MMAL_PARAMETER_COLOUR_EFFECT, &ctrl_set_colfx
1885 + MMAL_PARAMETER_COLOUR_EFFECT,
1886 + &ctrl_set_colfx,
1887 + false
1888 },
1889 {
1890 V4L2_CID_ROTATE, MMAL_CONTROL_TYPE_STD,
1891 0, 360, 0, 90, NULL,
1892 - MMAL_PARAMETER_ROTATION, &ctrl_set_rotate
1893 + MMAL_PARAMETER_ROTATION,
1894 + &ctrl_set_rotate,
1895 + false
1896 },
1897 {
1898 V4L2_CID_HFLIP, MMAL_CONTROL_TYPE_STD,
1899 0, 1, 0, 1, NULL,
1900 - MMAL_PARAMETER_MIRROR, &ctrl_set_flip
1901 + MMAL_PARAMETER_MIRROR,
1902 + &ctrl_set_flip,
1903 + false
1904 },
1905 {
1906 V4L2_CID_VFLIP, MMAL_CONTROL_TYPE_STD,
1907 0, 1, 0, 1, NULL,
1908 - MMAL_PARAMETER_MIRROR, &ctrl_set_flip
1909 + MMAL_PARAMETER_MIRROR,
1910 + &ctrl_set_flip,
1911 + false
1912 },
1913 {
1914 V4L2_CID_MPEG_VIDEO_BITRATE_MODE, MMAL_CONTROL_TYPE_STD_MENU,
1915 0, ARRAY_SIZE(bitrate_mode_qmenu) - 1,
1916 0, 0, bitrate_mode_qmenu,
1917 - MMAL_PARAMETER_RATECONTROL, &ctrl_set_bitrate_mode
1918 + MMAL_PARAMETER_RATECONTROL,
1919 + &ctrl_set_bitrate_mode,
1920 + false
1921 },
1922 {
1923 V4L2_CID_MPEG_VIDEO_BITRATE, MMAL_CONTROL_TYPE_STD,
1924 25*1000, 25*1000*1000, 10*1000*1000, 25*1000, NULL,
1925 - MMAL_PARAMETER_VIDEO_BIT_RATE, &ctrl_set_bitrate
1926 + MMAL_PARAMETER_VIDEO_BIT_RATE,
1927 + &ctrl_set_bitrate,
1928 + false
1929 },
1930 {
1931 V4L2_CID_JPEG_COMPRESSION_QUALITY, MMAL_CONTROL_TYPE_STD,
1932 - 0, 100,
1933 + 1, 100,
1934 30, 1, NULL,
1935 - MMAL_PARAMETER_JPEG_Q_FACTOR, &ctrl_set_q_factor
1936 + MMAL_PARAMETER_JPEG_Q_FACTOR,
1937 + &ctrl_set_image_encode_output,
1938 + false
1939 + },
1940 + {
1941 + V4L2_CID_POWER_LINE_FREQUENCY, MMAL_CONTROL_TYPE_STD_MENU,
1942 + 0, ARRAY_SIZE(mains_freq_qmenu) - 1,
1943 + 1, 1, NULL,
1944 + MMAL_PARAMETER_FLICKER_AVOID,
1945 + &ctrl_set_flicker_avoidance,
1946 + false
1947 + },
1948 + {
1949 + V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER, MMAL_CONTROL_TYPE_STD,
1950 + 0, 1,
1951 + 0, 1, NULL,
1952 + MMAL_PARAMETER_VIDEO_ENCODE_INLINE_HEADER,
1953 + &ctrl_set_video_encode_param_output,
1954 + true /* Errors ignored as requires latest firmware to work */
1955 + },
1956 + {
1957 + V4L2_CID_MPEG_VIDEO_H264_PROFILE,
1958 + MMAL_CONTROL_TYPE_STD_MENU,
1959 + ~((1<<V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE) |
1960 + (1<<V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE) |
1961 + (1<<V4L2_MPEG_VIDEO_H264_PROFILE_MAIN) |
1962 + (1<<V4L2_MPEG_VIDEO_H264_PROFILE_HIGH)),
1963 + V4L2_MPEG_VIDEO_H264_PROFILE_HIGH,
1964 + V4L2_MPEG_VIDEO_H264_PROFILE_HIGH, 1, NULL,
1965 + MMAL_PARAMETER_PROFILE,
1966 + &ctrl_set_video_encode_profile_level,
1967 + false
1968 + },
1969 + {
1970 + V4L2_CID_MPEG_VIDEO_H264_LEVEL, MMAL_CONTROL_TYPE_STD_MENU,
1971 + ~((1<<V4L2_MPEG_VIDEO_H264_LEVEL_1_0) |
1972 + (1<<V4L2_MPEG_VIDEO_H264_LEVEL_1B) |
1973 + (1<<V4L2_MPEG_VIDEO_H264_LEVEL_1_1) |
1974 + (1<<V4L2_MPEG_VIDEO_H264_LEVEL_1_2) |
1975 + (1<<V4L2_MPEG_VIDEO_H264_LEVEL_1_3) |
1976 + (1<<V4L2_MPEG_VIDEO_H264_LEVEL_2_0) |
1977 + (1<<V4L2_MPEG_VIDEO_H264_LEVEL_2_1) |
1978 + (1<<V4L2_MPEG_VIDEO_H264_LEVEL_2_2) |
1979 + (1<<V4L2_MPEG_VIDEO_H264_LEVEL_3_0) |
1980 + (1<<V4L2_MPEG_VIDEO_H264_LEVEL_3_1) |
1981 + (1<<V4L2_MPEG_VIDEO_H264_LEVEL_3_2) |
1982 + (1<<V4L2_MPEG_VIDEO_H264_LEVEL_4_0)),
1983 + V4L2_MPEG_VIDEO_H264_LEVEL_4_0,
1984 + V4L2_MPEG_VIDEO_H264_LEVEL_4_0, 1, NULL,
1985 + MMAL_PARAMETER_PROFILE,
1986 + &ctrl_set_video_encode_profile_level,
1987 + false
1988 + },
1989 + {
1990 + V4L2_CID_SCENE_MODE, MMAL_CONTROL_TYPE_STD_MENU,
1991 + -1, /* Min is computed at runtime */
1992 + V4L2_SCENE_MODE_TEXT,
1993 + V4L2_SCENE_MODE_NONE, 1, NULL,
1994 + MMAL_PARAMETER_PROFILE,
1995 + &ctrl_set_scene_mode,
1996 + false
1997 + },
1998 + {
1999 + V4L2_CID_MPEG_VIDEO_H264_I_PERIOD, MMAL_CONTROL_TYPE_STD,
2000 + 0, 0x7FFFFFFF, 60, 1, NULL,
2001 + MMAL_PARAMETER_INTRAPERIOD,
2002 + &ctrl_set_video_encode_param_output,
2003 + false
2004 },
2005 };
2006
2007 int bm2835_mmal_set_all_camera_controls(struct bm2835_mmal_dev *dev)
2008 {
2009 int c;
2010 - int ret;
2011 + int ret = 0;
2012
2013 for (c = 0; c < V4L2_CTRL_COUNT; c++) {
2014 if ((dev->ctrls[c]) && (v4l2_ctrls[c].setter)) {
2015 ret = v4l2_ctrls[c].setter(dev, dev->ctrls[c],
2016 &v4l2_ctrls[c]);
2017 - if (ret)
2018 + if (!v4l2_ctrls[c].ignore_errors && ret) {
2019 + v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
2020 + "Failed when setting default values for ctrl %d\n",
2021 + c);
2022 break;
2023 + }
2024 }
2025 }
2026 return ret;
2027 }
2028
2029 +int set_framerate_params(struct bm2835_mmal_dev *dev)
2030 +{
2031 + struct mmal_parameter_fps_range fps_range;
2032 + int ret;
2033 +
2034 + if ((dev->exposure_mode_active != MMAL_PARAM_EXPOSUREMODE_OFF) &&
2035 + (dev->exp_auto_priority)) {
2036 + /* Variable FPS. Define min FPS as 1fps.
2037 + * Max as max defined FPS.
2038 + */
2039 + fps_range.fps_low.num = 1;
2040 + fps_range.fps_low.den = 1;
2041 + fps_range.fps_high.num = dev->capture.timeperframe.denominator;
2042 + fps_range.fps_high.den = dev->capture.timeperframe.numerator;
2043 + } else {
2044 + /* Fixed FPS - set min and max to be the same */
2045 + fps_range.fps_low.num = fps_range.fps_high.num =
2046 + dev->capture.timeperframe.denominator;
2047 + fps_range.fps_low.den = fps_range.fps_high.den =
2048 + dev->capture.timeperframe.numerator;
2049 + }
2050 +
2051 + v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
2052 + "Set fps range to %d/%d to %d/%d\n",
2053 + fps_range.fps_low.num,
2054 + fps_range.fps_low.den,
2055 + fps_range.fps_high.num,
2056 + fps_range.fps_high.den
2057 + );
2058 +
2059 + ret = vchiq_mmal_port_parameter_set(dev->instance,
2060 + &dev->component[MMAL_COMPONENT_CAMERA]->
2061 + output[MMAL_CAMERA_PORT_PREVIEW],
2062 + MMAL_PARAMETER_FPS_RANGE,
2063 + &fps_range, sizeof(fps_range));
2064 + ret += vchiq_mmal_port_parameter_set(dev->instance,
2065 + &dev->component[MMAL_COMPONENT_CAMERA]->
2066 + output[MMAL_CAMERA_PORT_VIDEO],
2067 + MMAL_PARAMETER_FPS_RANGE,
2068 + &fps_range, sizeof(fps_range));
2069 + ret += vchiq_mmal_port_parameter_set(dev->instance,
2070 + &dev->component[MMAL_COMPONENT_CAMERA]->
2071 + output[MMAL_CAMERA_PORT_CAPTURE],
2072 + MMAL_PARAMETER_FPS_RANGE,
2073 + &fps_range, sizeof(fps_range));
2074 + if (ret)
2075 + v4l2_dbg(0, bcm2835_v4l2_debug, &dev->v4l2_dev,
2076 + "Failed to set fps ret %d\n",
2077 + ret);
2078 +
2079 + return ret;
2080 +
2081 +}
2082 +
2083 int bm2835_mmal_init_controls(struct bm2835_mmal_dev *dev,
2084 struct v4l2_ctrl_handler *hdl)
2085 {
2086 @@ -674,10 +1251,30 @@ int bm2835_mmal_init_controls(struct bm2835_mmal_dev *dev,
2087 break;
2088
2089 case MMAL_CONTROL_TYPE_STD_MENU:
2090 + {
2091 + int mask = ctrl->min;
2092 +
2093 + if (ctrl->id == V4L2_CID_SCENE_MODE) {
2094 + /* Special handling to work out the mask
2095 + * value based on the scene_configs array
2096 + * at runtime. Reduces the chance of
2097 + * mismatches.
2098 + */
2099 + int i;
2100 + mask = 1<<V4L2_SCENE_MODE_NONE;
2101 + for (i = 0;
2102 + i < ARRAY_SIZE(scene_configs);
2103 + i++) {
2104 + mask |= 1<<scene_configs[i].v4l2_scene;
2105 + }
2106 + mask = ~mask;
2107 + }
2108 +
2109 dev->ctrls[c] = v4l2_ctrl_new_std_menu(hdl,
2110 &bm2835_mmal_ctrl_ops, ctrl->id,
2111 - ctrl->max, ctrl->min, ctrl->def);
2112 + ctrl->max, mask, ctrl->def);
2113 break;
2114 + }
2115
2116 case MMAL_CONTROL_TYPE_INT_MENU:
2117 dev->ctrls[c] = v4l2_ctrl_new_int_menu(hdl,
2118 diff --git a/drivers/media/platform/bcm2835/mmal-common.h b/drivers/media/platform/bcm2835/mmal-common.h
2119 index 602b4a7..076f9a8 100644
2120 --- a/drivers/media/platform/bcm2835/mmal-common.h
2121 +++ b/drivers/media/platform/bcm2835/mmal-common.h
2122 @@ -26,6 +26,7 @@
2123 struct mmal_fmt {
2124 char *name;
2125 u32 fourcc; /* v4l2 format id */
2126 + int flags; /* v4l2 flags field */
2127 u32 mmal;
2128 int depth;
2129 u32 mmal_component; /* MMAL component index to be used to encode */
2130 diff --git a/drivers/media/platform/bcm2835/mmal-encodings.h b/drivers/media/platform/bcm2835/mmal-encodings.h
2131 index 856e80e..024d620 100644
2132 --- a/drivers/media/platform/bcm2835/mmal-encodings.h
2133 +++ b/drivers/media/platform/bcm2835/mmal-encodings.h
2134 @@ -12,6 +12,8 @@
2135 * Simon Mellor <simellor@broadcom.com>
2136 * Luke Diamand <luked@broadcom.com>
2137 */
2138 +#ifndef MMAL_ENCODINGS_H
2139 +#define MMAL_ENCODINGS_H
2140
2141 #define MMAL_ENCODING_H264 MMAL_FOURCC('H', '2', '6', '4')
2142 #define MMAL_ENCODING_H263 MMAL_FOURCC('H', '2', '6', '3')
2143 @@ -27,6 +29,7 @@
2144 #define MMAL_ENCODING_VP6 MMAL_FOURCC('V', 'P', '6', ' ')
2145 #define MMAL_ENCODING_THEORA MMAL_FOURCC('T', 'H', 'E', 'O')
2146 #define MMAL_ENCODING_SPARK MMAL_FOURCC('S', 'P', 'R', 'K')
2147 +#define MMAL_ENCODING_MJPEG MMAL_FOURCC('M', 'J', 'P', 'G')
2148
2149 #define MMAL_ENCODING_JPEG MMAL_FOURCC('J', 'P', 'E', 'G')
2150 #define MMAL_ENCODING_GIF MMAL_FOURCC('G', 'I', 'F', ' ')
2151 @@ -91,3 +94,34 @@
2152 #define MMAL_ENCODING_VARIANT_H264_AVC1 MMAL_FOURCC('A', 'V', 'C', '1')
2153 /** Implicitly delineated NAL units without emulation prevention */
2154 #define MMAL_ENCODING_VARIANT_H264_RAW MMAL_FOURCC('R', 'A', 'W', ' ')
2155 +
2156 +
2157 +/** \defgroup MmalColorSpace List of pre-defined video color spaces
2158 + * This defines a list of common color spaces. This list isn't exhaustive and
2159 + * is only provided as a convenience to avoid clients having to use FourCC
2160 + * codes directly. However components are allowed to define and use their own
2161 + * FourCC codes.
2162 + */
2163 +/* @{ */
2164 +
2165 +/** Unknown color space */
2166 +#define MMAL_COLOR_SPACE_UNKNOWN 0
2167 +/** ITU-R BT.601-5 [SDTV] */
2168 +#define MMAL_COLOR_SPACE_ITUR_BT601 MMAL_FOURCC('Y', '6', '0', '1')
2169 +/** ITU-R BT.709-3 [HDTV] */
2170 +#define MMAL_COLOR_SPACE_ITUR_BT709 MMAL_FOURCC('Y', '7', '0', '9')
2171 +/** JPEG JFIF */
2172 +#define MMAL_COLOR_SPACE_JPEG_JFIF MMAL_FOURCC('Y', 'J', 'F', 'I')
2173 +/** Title 47 Code of Federal Regulations (2003) 73.682 (a) (20) */
2174 +#define MMAL_COLOR_SPACE_FCC MMAL_FOURCC('Y', 'F', 'C', 'C')
2175 +/** Society of Motion Picture and Television Engineers 240M (1999) */
2176 +#define MMAL_COLOR_SPACE_SMPTE240M MMAL_FOURCC('Y', '2', '4', '0')
2177 +/** ITU-R BT.470-2 System M */
2178 +#define MMAL_COLOR_SPACE_BT470_2_M MMAL_FOURCC('Y', '_', '_', 'M')
2179 +/** ITU-R BT.470-2 System BG */
2180 +#define MMAL_COLOR_SPACE_BT470_2_BG MMAL_FOURCC('Y', '_', 'B', 'G')
2181 +/** JPEG JFIF, but with 16..255 luma */
2182 +#define MMAL_COLOR_SPACE_JFIF_Y16_255 MMAL_FOURCC('Y', 'Y', '1', '6')
2183 +/* @} MmalColorSpace List */
2184 +
2185 +#endif /* MMAL_ENCODINGS_H */
2186 diff --git a/drivers/media/platform/bcm2835/mmal-parameters.h b/drivers/media/platform/bcm2835/mmal-parameters.h
2187 index c611b58..aa0fd18 100644
2188 --- a/drivers/media/platform/bcm2835/mmal-parameters.h
2189 +++ b/drivers/media/platform/bcm2835/mmal-parameters.h
2190 @@ -57,7 +57,8 @@ enum mmal_parameter_common_type {
2191 MMAL_PARAMETER_SEEK, /**< MMAL_PARAMETER_SEEK_T */
2192 MMAL_PARAMETER_POWERMON_ENABLE, /**< MMAL_PARAMETER_BOOLEAN_T */
2193 MMAL_PARAMETER_LOGGING, /**< MMAL_PARAMETER_LOGGING_T */
2194 - MMAL_PARAMETER_SYSTEM_TIME /**< MMAL_PARAMETER_UINT64_T */
2195 + MMAL_PARAMETER_SYSTEM_TIME, /**< MMAL_PARAMETER_UINT64_T */
2196 + MMAL_PARAMETER_NO_IMAGE_PADDING /**< MMAL_PARAMETER_BOOLEAN_T */
2197 };
2198
2199 /* camera parameters */
2200 @@ -161,6 +162,13 @@ enum mmal_parameter_camera_type {
2201 MMAL_PARAMETER_SW_SHARPEN_DISABLE, /**< @ref MMAL_PARAMETER_BOOLEAN_T */
2202 MMAL_PARAMETER_FLASH_REQUIRED, /**< @ref MMAL_PARAMETER_BOOLEAN_T */
2203 MMAL_PARAMETER_SW_SATURATION_DISABLE, /**< @ref MMAL_PARAMETER_BOOLEAN_T */
2204 + MMAL_PARAMETER_SHUTTER_SPEED, /**< Takes a @ref MMAL_PARAMETER_UINT32_T */
2205 + MMAL_PARAMETER_CUSTOM_AWB_GAINS, /**< Takes a @ref MMAL_PARAMETER_AWB_GAINS_T */
2206 +};
2207 +
2208 +struct mmal_parameter_rational {
2209 + s32 num; /**< Numerator */
2210 + s32 den; /**< Denominator */
2211 };
2212
2213 enum mmal_parameter_camera_config_timestamp_mode {
2214 @@ -176,6 +184,14 @@ enum mmal_parameter_camera_config_timestamp_mode {
2215 */
2216 };
2217
2218 +struct mmal_parameter_fps_range {
2219 + /**< Low end of the permitted framerate range */
2220 + struct mmal_parameter_rational fps_low;
2221 + /**< High end of the permitted framerate range */
2222 + struct mmal_parameter_rational fps_high;
2223 +};
2224 +
2225 +
2226 /* camera configuration parameter */
2227 struct mmal_parameter_camera_config {
2228 /* Parameters for setting up the image pools */
2229 @@ -270,6 +286,19 @@ enum mmal_parameter_imagefx {
2230 MMAL_PARAM_IMAGEFX_CARTOON,
2231 };
2232
2233 +enum MMAL_PARAM_FLICKERAVOID_T {
2234 + MMAL_PARAM_FLICKERAVOID_OFF,
2235 + MMAL_PARAM_FLICKERAVOID_AUTO,
2236 + MMAL_PARAM_FLICKERAVOID_50HZ,
2237 + MMAL_PARAM_FLICKERAVOID_60HZ,
2238 + MMAL_PARAM_FLICKERAVOID_MAX = 0x7FFFFFFF
2239 +};
2240 +
2241 +struct mmal_parameter_awbgains {
2242 + struct mmal_parameter_rational r_gain; /**< Red gain */
2243 + struct mmal_parameter_rational b_gain; /**< Blue gain */
2244 +};
2245 +
2246 /** Manner of video rate control */
2247 enum mmal_parameter_rate_control_mode {
2248 MMAL_VIDEO_RATECONTROL_DEFAULT,
2249 @@ -279,6 +308,85 @@ enum mmal_parameter_rate_control_mode {
2250 MMAL_VIDEO_RATECONTROL_CONSTANT_SKIP_FRAMES
2251 };
2252
2253 +enum mmal_video_profile {
2254 + MMAL_VIDEO_PROFILE_H263_BASELINE,
2255 + MMAL_VIDEO_PROFILE_H263_H320CODING,
2256 + MMAL_VIDEO_PROFILE_H263_BACKWARDCOMPATIBLE,
2257 + MMAL_VIDEO_PROFILE_H263_ISWV2,
2258 + MMAL_VIDEO_PROFILE_H263_ISWV3,
2259 + MMAL_VIDEO_PROFILE_H263_HIGHCOMPRESSION,
2260 + MMAL_VIDEO_PROFILE_H263_INTERNET,
2261 + MMAL_VIDEO_PROFILE_H263_INTERLACE,
2262 + MMAL_VIDEO_PROFILE_H263_HIGHLATENCY,
2263 + MMAL_VIDEO_PROFILE_MP4V_SIMPLE,
2264 + MMAL_VIDEO_PROFILE_MP4V_SIMPLESCALABLE,
2265 + MMAL_VIDEO_PROFILE_MP4V_CORE,
2266 + MMAL_VIDEO_PROFILE_MP4V_MAIN,
2267 + MMAL_VIDEO_PROFILE_MP4V_NBIT,
2268 + MMAL_VIDEO_PROFILE_MP4V_SCALABLETEXTURE,
2269 + MMAL_VIDEO_PROFILE_MP4V_SIMPLEFACE,
2270 + MMAL_VIDEO_PROFILE_MP4V_SIMPLEFBA,
2271 + MMAL_VIDEO_PROFILE_MP4V_BASICANIMATED,
2272 + MMAL_VIDEO_PROFILE_MP4V_HYBRID,
2273 + MMAL_VIDEO_PROFILE_MP4V_ADVANCEDREALTIME,
2274 + MMAL_VIDEO_PROFILE_MP4V_CORESCALABLE,
2275 + MMAL_VIDEO_PROFILE_MP4V_ADVANCEDCODING,
2276 + MMAL_VIDEO_PROFILE_MP4V_ADVANCEDCORE,
2277 + MMAL_VIDEO_PROFILE_MP4V_ADVANCEDSCALABLE,
2278 + MMAL_VIDEO_PROFILE_MP4V_ADVANCEDSIMPLE,
2279 + MMAL_VIDEO_PROFILE_H264_BASELINE,
2280 + MMAL_VIDEO_PROFILE_H264_MAIN,
2281 + MMAL_VIDEO_PROFILE_H264_EXTENDED,
2282 + MMAL_VIDEO_PROFILE_H264_HIGH,
2283 + MMAL_VIDEO_PROFILE_H264_HIGH10,
2284 + MMAL_VIDEO_PROFILE_H264_HIGH422,
2285 + MMAL_VIDEO_PROFILE_H264_HIGH444,
2286 + MMAL_VIDEO_PROFILE_H264_CONSTRAINED_BASELINE,
2287 + MMAL_VIDEO_PROFILE_DUMMY = 0x7FFFFFFF
2288 +};
2289 +
2290 +enum mmal_video_level {
2291 + MMAL_VIDEO_LEVEL_H263_10,
2292 + MMAL_VIDEO_LEVEL_H263_20,
2293 + MMAL_VIDEO_LEVEL_H263_30,
2294 + MMAL_VIDEO_LEVEL_H263_40,
2295 + MMAL_VIDEO_LEVEL_H263_45,
2296 + MMAL_VIDEO_LEVEL_H263_50,
2297 + MMAL_VIDEO_LEVEL_H263_60,
2298 + MMAL_VIDEO_LEVEL_H263_70,
2299 + MMAL_VIDEO_LEVEL_MP4V_0,
2300 + MMAL_VIDEO_LEVEL_MP4V_0b,
2301 + MMAL_VIDEO_LEVEL_MP4V_1,
2302 + MMAL_VIDEO_LEVEL_MP4V_2,
2303 + MMAL_VIDEO_LEVEL_MP4V_3,
2304 + MMAL_VIDEO_LEVEL_MP4V_4,
2305 + MMAL_VIDEO_LEVEL_MP4V_4a,
2306 + MMAL_VIDEO_LEVEL_MP4V_5,
2307 + MMAL_VIDEO_LEVEL_MP4V_6,
2308 + MMAL_VIDEO_LEVEL_H264_1,
2309 + MMAL_VIDEO_LEVEL_H264_1b,
2310 + MMAL_VIDEO_LEVEL_H264_11,
2311 + MMAL_VIDEO_LEVEL_H264_12,
2312 + MMAL_VIDEO_LEVEL_H264_13,
2313 + MMAL_VIDEO_LEVEL_H264_2,
2314 + MMAL_VIDEO_LEVEL_H264_21,
2315 + MMAL_VIDEO_LEVEL_H264_22,
2316 + MMAL_VIDEO_LEVEL_H264_3,
2317 + MMAL_VIDEO_LEVEL_H264_31,
2318 + MMAL_VIDEO_LEVEL_H264_32,
2319 + MMAL_VIDEO_LEVEL_H264_4,
2320 + MMAL_VIDEO_LEVEL_H264_41,
2321 + MMAL_VIDEO_LEVEL_H264_42,
2322 + MMAL_VIDEO_LEVEL_H264_5,
2323 + MMAL_VIDEO_LEVEL_H264_51,
2324 + MMAL_VIDEO_LEVEL_DUMMY = 0x7FFFFFFF
2325 +};
2326 +
2327 +struct mmal_parameter_video_profile {
2328 + enum mmal_video_profile profile;
2329 + enum mmal_video_level level;
2330 +};
2331 +
2332 /* video parameters */
2333
2334 enum mmal_parameter_video_type {
2335 @@ -407,7 +515,16 @@ enum mmal_parameter_video_type {
2336 MMAL_PARAMETER_VIDEO_DRM_PROTECT_BUFFER,
2337
2338 /** @ref MMAL_PARAMETER_BYTES_T */
2339 - MMAL_PARAMETER_VIDEO_DECODE_CONFIG_VD3
2340 + MMAL_PARAMETER_VIDEO_DECODE_CONFIG_VD3,
2341 +
2342 + /**< @ref MMAL_PARAMETER_BOOLEAN_T */
2343 + MMAL_PARAMETER_VIDEO_ENCODE_H264_VCL_HRD_PARAMETERS,
2344 +
2345 + /**< @ref MMAL_PARAMETER_BOOLEAN_T */
2346 + MMAL_PARAMETER_VIDEO_ENCODE_H264_LOW_DELAY_HRD_FLAG,
2347 +
2348 + /**< @ref MMAL_PARAMETER_BOOLEAN_T */
2349 + MMAL_PARAMETER_VIDEO_ENCODE_INLINE_HEADER
2350 };
2351
2352 /** Valid mirror modes */
2353 diff --git a/drivers/media/platform/bcm2835/mmal-vchiq.c b/drivers/media/platform/bcm2835/mmal-vchiq.c
2354 index a06fb44..76f249e 100644
2355 --- a/drivers/media/platform/bcm2835/mmal-vchiq.c
2356 +++ b/drivers/media/platform/bcm2835/mmal-vchiq.c
2357 @@ -742,7 +742,7 @@ static int send_synchronous_mmal_msg(struct vchiq_mmal_instance *instance,
2358 return ret;
2359 }
2360
2361 - ret = wait_for_completion_timeout(&msg_context.u.sync.cmplt, HZ);
2362 + ret = wait_for_completion_timeout(&msg_context.u.sync.cmplt, 3*HZ);
2363 if (ret <= 0) {
2364 pr_err("error %d waiting for sync completion\n", ret);
2365 if (ret == 0)
2366 @@ -1326,7 +1326,7 @@ static int port_parameter_get(struct vchiq_mmal_instance *instance,
2367 memcpy(value, &rmsg->u.port_parameter_get_reply.value,
2368 rmsg->u.port_parameter_get_reply.size);
2369
2370 - pr_info("%s:result:%d component:0x%x port:%d parameter:%d\n", __func__,
2371 + pr_debug("%s:result:%d component:0x%x port:%d parameter:%d\n", __func__,
2372 ret, port->component->handle, port->handle, parameter_id);
2373
2374 release_msg:
2375 --
2376 1.9.1
2377
OpenWrt Source Repository