projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'linux-next' of git://git.infradead.org/ubi-2.6
[deliverable/linux.git] / drivers / media / video / cx2341x.c
1 /*
2 * cx2341x - generic code for cx23415/6/8 based devices
3 *
4 * Copyright (C) 2006 Hans Verkuil <hverkuil@xs4all.nl>
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 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21
22 #include <linux/module.h>
23 #include <linux/errno.h>
24 #include <linux/kernel.h>
25 #include <linux/init.h>
26 #include <linux/types.h>
27 #include <linux/videodev2.h>
28
29 #include <media/tuner.h>
30 #include <media/cx2341x.h>
31 #include <media/v4l2-common.h>
32
33 MODULE_DESCRIPTION("cx23415/6/8 driver");
34 MODULE_AUTHOR("Hans Verkuil");
35 MODULE_LICENSE("GPL");
36
37 static int debug;
38 module_param(debug, int, 0644);
39 MODULE_PARM_DESC(debug, "Debug level (0-1)");
40
41 /* Must be sorted from low to high control ID! */
42 const u32 cx2341x_mpeg_ctrls[] = {
43 V4L2_CID_MPEG_CLASS,
44 V4L2_CID_MPEG_STREAM_TYPE,
45 V4L2_CID_MPEG_STREAM_VBI_FMT,
46 V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ,
47 V4L2_CID_MPEG_AUDIO_ENCODING,
48 V4L2_CID_MPEG_AUDIO_L2_BITRATE,
49 V4L2_CID_MPEG_AUDIO_MODE,
50 V4L2_CID_MPEG_AUDIO_MODE_EXTENSION,
51 V4L2_CID_MPEG_AUDIO_EMPHASIS,
52 V4L2_CID_MPEG_AUDIO_CRC,
53 V4L2_CID_MPEG_AUDIO_MUTE,
54 V4L2_CID_MPEG_AUDIO_AC3_BITRATE,
55 V4L2_CID_MPEG_VIDEO_ENCODING,
56 V4L2_CID_MPEG_VIDEO_ASPECT,
57 V4L2_CID_MPEG_VIDEO_B_FRAMES,
58 V4L2_CID_MPEG_VIDEO_GOP_SIZE,
59 V4L2_CID_MPEG_VIDEO_GOP_CLOSURE,
60 V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
61 V4L2_CID_MPEG_VIDEO_BITRATE,
62 V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
63 V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION,
64 V4L2_CID_MPEG_VIDEO_MUTE,
65 V4L2_CID_MPEG_VIDEO_MUTE_YUV,
66 V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE,
67 V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER,
68 V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE,
69 V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE,
70 V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE,
71 V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER,
72 V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE,
73 V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM,
74 V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP,
75 V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM,
76 V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP,
77 V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS,
78 0
79 };
80 EXPORT_SYMBOL(cx2341x_mpeg_ctrls);
81
82 static const struct cx2341x_mpeg_params default_params = {
83 /* misc */
84 .capabilities = 0,
85 .port = CX2341X_PORT_MEMORY,
86 .width = 720,
87 .height = 480,
88 .is_50hz = 0,
89
90 /* stream */
91 .stream_type = V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
92 .stream_vbi_fmt = V4L2_MPEG_STREAM_VBI_FMT_NONE,
93 .stream_insert_nav_packets = 0,
94
95 /* audio */
96 .audio_sampling_freq = V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000,
97 .audio_encoding = V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
98 .audio_l2_bitrate = V4L2_MPEG_AUDIO_L2_BITRATE_224K,
99 .audio_ac3_bitrate = V4L2_MPEG_AUDIO_AC3_BITRATE_224K,
100 .audio_mode = V4L2_MPEG_AUDIO_MODE_STEREO,
101 .audio_mode_extension = V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
102 .audio_emphasis = V4L2_MPEG_AUDIO_EMPHASIS_NONE,
103 .audio_crc = V4L2_MPEG_AUDIO_CRC_NONE,
104 .audio_mute = 0,
105
106 /* video */
107 .video_encoding = V4L2_MPEG_VIDEO_ENCODING_MPEG_2,
108 .video_aspect = V4L2_MPEG_VIDEO_ASPECT_4x3,
109 .video_b_frames = 2,
110 .video_gop_size = 12,
111 .video_gop_closure = 1,
112 .video_bitrate_mode = V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
113 .video_bitrate = 6000000,
114 .video_bitrate_peak = 8000000,
115 .video_temporal_decimation = 0,
116 .video_mute = 0,
117 .video_mute_yuv = 0x008080, /* YCbCr value for black */
118
119 /* encoding filters */
120 .video_spatial_filter_mode =
121 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL,
122 .video_spatial_filter = 0,
123 .video_luma_spatial_filter_type =
124 V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_1D_HOR,
125 .video_chroma_spatial_filter_type =
126 V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR,
127 .video_temporal_filter_mode =
128 V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL,
129 .video_temporal_filter = 8,
130 .video_median_filter_type =
131 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF,
132 .video_luma_median_filter_top = 255,
133 .video_luma_median_filter_bottom = 0,
134 .video_chroma_median_filter_top = 255,
135 .video_chroma_median_filter_bottom = 0,
136 };
137
138
139 /* Map the control ID to the correct field in the cx2341x_mpeg_params
140 struct. Return -EINVAL if the ID is unknown, else return 0. */
141 static int cx2341x_get_ctrl(const struct cx2341x_mpeg_params *params,
142 struct v4l2_ext_control *ctrl)
143 {
144 switch (ctrl->id) {
145 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
146 ctrl->value = params->audio_sampling_freq;
147 break;
148 case V4L2_CID_MPEG_AUDIO_ENCODING:
149 ctrl->value = params->audio_encoding;
150 break;
151 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
152 ctrl->value = params->audio_l2_bitrate;
153 break;
154 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
155 ctrl->value = params->audio_ac3_bitrate;
156 break;
157 case V4L2_CID_MPEG_AUDIO_MODE:
158 ctrl->value = params->audio_mode;
159 break;
160 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
161 ctrl->value = params->audio_mode_extension;
162 break;
163 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
164 ctrl->value = params->audio_emphasis;
165 break;
166 case V4L2_CID_MPEG_AUDIO_CRC:
167 ctrl->value = params->audio_crc;
168 break;
169 case V4L2_CID_MPEG_AUDIO_MUTE:
170 ctrl->value = params->audio_mute;
171 break;
172 case V4L2_CID_MPEG_VIDEO_ENCODING:
173 ctrl->value = params->video_encoding;
174 break;
175 case V4L2_CID_MPEG_VIDEO_ASPECT:
176 ctrl->value = params->video_aspect;
177 break;
178 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
179 ctrl->value = params->video_b_frames;
180 break;
181 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
182 ctrl->value = params->video_gop_size;
183 break;
184 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
185 ctrl->value = params->video_gop_closure;
186 break;
187 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
188 ctrl->value = params->video_bitrate_mode;
189 break;
190 case V4L2_CID_MPEG_VIDEO_BITRATE:
191 ctrl->value = params->video_bitrate;
192 break;
193 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
194 ctrl->value = params->video_bitrate_peak;
195 break;
196 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
197 ctrl->value = params->video_temporal_decimation;
198 break;
199 case V4L2_CID_MPEG_VIDEO_MUTE:
200 ctrl->value = params->video_mute;
201 break;
202 case V4L2_CID_MPEG_VIDEO_MUTE_YUV:
203 ctrl->value = params->video_mute_yuv;
204 break;
205 case V4L2_CID_MPEG_STREAM_TYPE:
206 ctrl->value = params->stream_type;
207 break;
208 case V4L2_CID_MPEG_STREAM_VBI_FMT:
209 ctrl->value = params->stream_vbi_fmt;
210 break;
211 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
212 ctrl->value = params->video_spatial_filter_mode;
213 break;
214 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
215 ctrl->value = params->video_spatial_filter;
216 break;
217 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
218 ctrl->value = params->video_luma_spatial_filter_type;
219 break;
220 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
221 ctrl->value = params->video_chroma_spatial_filter_type;
222 break;
223 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
224 ctrl->value = params->video_temporal_filter_mode;
225 break;
226 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
227 ctrl->value = params->video_temporal_filter;
228 break;
229 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
230 ctrl->value = params->video_median_filter_type;
231 break;
232 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
233 ctrl->value = params->video_luma_median_filter_top;
234 break;
235 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
236 ctrl->value = params->video_luma_median_filter_bottom;
237 break;
238 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
239 ctrl->value = params->video_chroma_median_filter_top;
240 break;
241 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
242 ctrl->value = params->video_chroma_median_filter_bottom;
243 break;
244 case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
245 ctrl->value = params->stream_insert_nav_packets;
246 break;
247 default:
248 return -EINVAL;
249 }
250 return 0;
251 }
252
253 /* Map the control ID to the correct field in the cx2341x_mpeg_params
254 struct. Return -EINVAL if the ID is unknown, else return 0. */
255 static int cx2341x_set_ctrl(struct cx2341x_mpeg_params *params, int busy,
256 struct v4l2_ext_control *ctrl)
257 {
258 switch (ctrl->id) {
259 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
260 if (busy)
261 return -EBUSY;
262 params->audio_sampling_freq = ctrl->value;
263 break;
264 case V4L2_CID_MPEG_AUDIO_ENCODING:
265 if (busy)
266 return -EBUSY;
267 if (params->capabilities & CX2341X_CAP_HAS_AC3)
268 if (ctrl->value != V4L2_MPEG_AUDIO_ENCODING_LAYER_2 &&
269 ctrl->value != V4L2_MPEG_AUDIO_ENCODING_AC3)
270 return -ERANGE;
271 params->audio_encoding = ctrl->value;
272 break;
273 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
274 if (busy)
275 return -EBUSY;
276 params->audio_l2_bitrate = ctrl->value;
277 break;
278 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
279 if (busy)
280 return -EBUSY;
281 if (!(params->capabilities & CX2341X_CAP_HAS_AC3))
282 return -EINVAL;
283 params->audio_ac3_bitrate = ctrl->value;
284 break;
285 case V4L2_CID_MPEG_AUDIO_MODE:
286 params->audio_mode = ctrl->value;
287 break;
288 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
289 params->audio_mode_extension = ctrl->value;
290 break;
291 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
292 params->audio_emphasis = ctrl->value;
293 break;
294 case V4L2_CID_MPEG_AUDIO_CRC:
295 params->audio_crc = ctrl->value;
296 break;
297 case V4L2_CID_MPEG_AUDIO_MUTE:
298 params->audio_mute = ctrl->value;
299 break;
300 case V4L2_CID_MPEG_VIDEO_ASPECT:
301 params->video_aspect = ctrl->value;
302 break;
303 case V4L2_CID_MPEG_VIDEO_B_FRAMES: {
304 int b = ctrl->value + 1;
305 int gop = params->video_gop_size;
306 params->video_b_frames = ctrl->value;
307 params->video_gop_size = b * ((gop + b - 1) / b);
308 /* Max GOP size = 34 */
309 while (params->video_gop_size > 34)
310 params->video_gop_size -= b;
311 break;
312 }
313 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: {
314 int b = params->video_b_frames + 1;
315 int gop = ctrl->value;
316 params->video_gop_size = b * ((gop + b - 1) / b);
317 /* Max GOP size = 34 */
318 while (params->video_gop_size > 34)
319 params->video_gop_size -= b;
320 ctrl->value = params->video_gop_size;
321 break;
322 }
323 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
324 params->video_gop_closure = ctrl->value;
325 break;
326 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
327 if (busy)
328 return -EBUSY;
329 /* MPEG-1 only allows CBR */
330 if (params->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1 &&
331 ctrl->value != V4L2_MPEG_VIDEO_BITRATE_MODE_CBR)
332 return -EINVAL;
333 params->video_bitrate_mode = ctrl->value;
334 break;
335 case V4L2_CID_MPEG_VIDEO_BITRATE:
336 if (busy)
337 return -EBUSY;
338 params->video_bitrate = ctrl->value;
339 break;
340 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
341 if (busy)
342 return -EBUSY;
343 params->video_bitrate_peak = ctrl->value;
344 break;
345 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
346 params->video_temporal_decimation = ctrl->value;
347 break;
348 case V4L2_CID_MPEG_VIDEO_MUTE:
349 params->video_mute = (ctrl->value != 0);
350 break;
351 case V4L2_CID_MPEG_VIDEO_MUTE_YUV:
352 params->video_mute_yuv = ctrl->value;
353 break;
354 case V4L2_CID_MPEG_STREAM_TYPE:
355 if (busy)
356 return -EBUSY;
357 params->stream_type = ctrl->value;
358 params->video_encoding =
359 (params->stream_type == V4L2_MPEG_STREAM_TYPE_MPEG1_SS ||
360 params->stream_type == V4L2_MPEG_STREAM_TYPE_MPEG1_VCD) ?
361 V4L2_MPEG_VIDEO_ENCODING_MPEG_1 :
362 V4L2_MPEG_VIDEO_ENCODING_MPEG_2;
363 if (params->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
364 /* MPEG-1 implies CBR */
365 params->video_bitrate_mode =
366 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR;
367 break;
368 case V4L2_CID_MPEG_STREAM_VBI_FMT:
369 params->stream_vbi_fmt = ctrl->value;
370 break;
371 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
372 params->video_spatial_filter_mode = ctrl->value;
373 break;
374 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
375 params->video_spatial_filter = ctrl->value;
376 break;
377 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
378 params->video_luma_spatial_filter_type = ctrl->value;
379 break;
380 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
381 params->video_chroma_spatial_filter_type = ctrl->value;
382 break;
383 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
384 params->video_temporal_filter_mode = ctrl->value;
385 break;
386 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
387 params->video_temporal_filter = ctrl->value;
388 break;
389 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
390 params->video_median_filter_type = ctrl->value;
391 break;
392 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
393 params->video_luma_median_filter_top = ctrl->value;
394 break;
395 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
396 params->video_luma_median_filter_bottom = ctrl->value;
397 break;
398 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
399 params->video_chroma_median_filter_top = ctrl->value;
400 break;
401 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
402 params->video_chroma_median_filter_bottom = ctrl->value;
403 break;
404 case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
405 params->stream_insert_nav_packets = ctrl->value;
406 break;
407 default:
408 return -EINVAL;
409 }
410 return 0;
411 }
412
413 static int cx2341x_ctrl_query_fill(struct v4l2_queryctrl *qctrl,
414 s32 min, s32 max, s32 step, s32 def)
415 {
416 const char *name;
417
418 qctrl->flags = 0;
419 switch (qctrl->id) {
420 /* MPEG controls */
421 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
422 name = "Spatial Filter Mode";
423 break;
424 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
425 name = "Spatial Filter";
426 break;
427 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
428 name = "Spatial Luma Filter Type";
429 break;
430 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
431 name = "Spatial Chroma Filter Type";
432 break;
433 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
434 name = "Temporal Filter Mode";
435 break;
436 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
437 name = "Temporal Filter";
438 break;
439 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
440 name = "Median Filter Type";
441 break;
442 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
443 name = "Median Luma Filter Maximum";
444 break;
445 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
446 name = "Median Luma Filter Minimum";
447 break;
448 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
449 name = "Median Chroma Filter Maximum";
450 break;
451 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
452 name = "Median Chroma Filter Minimum";
453 break;
454 case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
455 name = "Insert Navigation Packets";
456 break;
457
458 default:
459 return v4l2_ctrl_query_fill(qctrl, min, max, step, def);
460 }
461 switch (qctrl->id) {
462 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
463 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
464 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
465 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
466 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
467 qctrl->type = V4L2_CTRL_TYPE_MENU;
468 min = 0;
469 step = 1;
470 break;
471 case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
472 qctrl->type = V4L2_CTRL_TYPE_BOOLEAN;
473 min = 0;
474 max = 1;
475 step = 1;
476 break;
477 default:
478 qctrl->type = V4L2_CTRL_TYPE_INTEGER;
479 break;
480 }
481 switch (qctrl->id) {
482 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
483 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
484 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
485 qctrl->flags |= V4L2_CTRL_FLAG_UPDATE;
486 break;
487 }
488 qctrl->minimum = min;
489 qctrl->maximum = max;
490 qctrl->step = step;
491 qctrl->default_value = def;
492 qctrl->reserved[0] = qctrl->reserved[1] = 0;
493 snprintf(qctrl->name, sizeof(qctrl->name), name);
494 return 0;
495 }
496
497 int cx2341x_ctrl_query(const struct cx2341x_mpeg_params *params,
498 struct v4l2_queryctrl *qctrl)
499 {
500 int err;
501
502 switch (qctrl->id) {
503 case V4L2_CID_MPEG_STREAM_TYPE:
504 return v4l2_ctrl_query_fill(qctrl,
505 V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
506 V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD, 1,
507 V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
508
509 case V4L2_CID_MPEG_STREAM_VBI_FMT:
510 if (params->capabilities & CX2341X_CAP_HAS_SLICED_VBI)
511 return v4l2_ctrl_query_fill(qctrl,
512 V4L2_MPEG_STREAM_VBI_FMT_NONE,
513 V4L2_MPEG_STREAM_VBI_FMT_IVTV, 1,
514 V4L2_MPEG_STREAM_VBI_FMT_NONE);
515 return cx2341x_ctrl_query_fill(qctrl,
516 V4L2_MPEG_STREAM_VBI_FMT_NONE,
517 V4L2_MPEG_STREAM_VBI_FMT_NONE, 1,
518 default_params.stream_vbi_fmt);
519
520 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
521 return v4l2_ctrl_query_fill(qctrl,
522 V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100,
523 V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000, 1,
524 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000);
525
526 case V4L2_CID_MPEG_AUDIO_ENCODING:
527 if (params->capabilities & CX2341X_CAP_HAS_AC3) {
528 /*
529 * The state of L2 & AC3 bitrate controls can change
530 * when this control changes, but v4l2_ctrl_query_fill()
531 * already sets V4L2_CTRL_FLAG_UPDATE for
532 * V4L2_CID_MPEG_AUDIO_ENCODING, so we don't here.
533 */
534 return v4l2_ctrl_query_fill(qctrl,
535 V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
536 V4L2_MPEG_AUDIO_ENCODING_AC3, 1,
537 default_params.audio_encoding);
538 }
539
540 return v4l2_ctrl_query_fill(qctrl,
541 V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
542 V4L2_MPEG_AUDIO_ENCODING_LAYER_2, 1,
543 default_params.audio_encoding);
544
545 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
546 err = v4l2_ctrl_query_fill(qctrl,
547 V4L2_MPEG_AUDIO_L2_BITRATE_192K,
548 V4L2_MPEG_AUDIO_L2_BITRATE_384K, 1,
549 default_params.audio_l2_bitrate);
550 if (err)
551 return err;
552 if (params->capabilities & CX2341X_CAP_HAS_AC3 &&
553 params->audio_encoding != V4L2_MPEG_AUDIO_ENCODING_LAYER_2)
554 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
555 return 0;
556
557 case V4L2_CID_MPEG_AUDIO_MODE:
558 return v4l2_ctrl_query_fill(qctrl,
559 V4L2_MPEG_AUDIO_MODE_STEREO,
560 V4L2_MPEG_AUDIO_MODE_MONO, 1,
561 V4L2_MPEG_AUDIO_MODE_STEREO);
562
563 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
564 err = v4l2_ctrl_query_fill(qctrl,
565 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
566 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16, 1,
567 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4);
568 if (err == 0 &&
569 params->audio_mode != V4L2_MPEG_AUDIO_MODE_JOINT_STEREO)
570 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
571 return err;
572
573 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
574 return v4l2_ctrl_query_fill(qctrl,
575 V4L2_MPEG_AUDIO_EMPHASIS_NONE,
576 V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17, 1,
577 V4L2_MPEG_AUDIO_EMPHASIS_NONE);
578
579 case V4L2_CID_MPEG_AUDIO_CRC:
580 return v4l2_ctrl_query_fill(qctrl,
581 V4L2_MPEG_AUDIO_CRC_NONE,
582 V4L2_MPEG_AUDIO_CRC_CRC16, 1,
583 V4L2_MPEG_AUDIO_CRC_NONE);
584
585 case V4L2_CID_MPEG_AUDIO_MUTE:
586 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
587
588 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
589 err = v4l2_ctrl_query_fill(qctrl,
590 V4L2_MPEG_AUDIO_AC3_BITRATE_48K,
591 V4L2_MPEG_AUDIO_AC3_BITRATE_448K, 1,
592 default_params.audio_ac3_bitrate);
593 if (err)
594 return err;
595 if (params->capabilities & CX2341X_CAP_HAS_AC3) {
596 if (params->audio_encoding !=
597 V4L2_MPEG_AUDIO_ENCODING_AC3)
598 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
599 } else
600 qctrl->flags |= V4L2_CTRL_FLAG_DISABLED;
601 return 0;
602
603 case V4L2_CID_MPEG_VIDEO_ENCODING:
604 /* this setting is read-only for the cx2341x since the
605 V4L2_CID_MPEG_STREAM_TYPE really determines the
606 MPEG-1/2 setting */
607 err = v4l2_ctrl_query_fill(qctrl,
608 V4L2_MPEG_VIDEO_ENCODING_MPEG_1,
609 V4L2_MPEG_VIDEO_ENCODING_MPEG_2, 1,
610 V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
611 if (err == 0)
612 qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
613 return err;
614
615 case V4L2_CID_MPEG_VIDEO_ASPECT:
616 return v4l2_ctrl_query_fill(qctrl,
617 V4L2_MPEG_VIDEO_ASPECT_1x1,
618 V4L2_MPEG_VIDEO_ASPECT_221x100, 1,
619 V4L2_MPEG_VIDEO_ASPECT_4x3);
620
621 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
622 return v4l2_ctrl_query_fill(qctrl, 0, 33, 1, 2);
623
624 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
625 return v4l2_ctrl_query_fill(qctrl, 1, 34, 1,
626 params->is_50hz ? 12 : 15);
627
628 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
629 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 1);
630
631 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
632 err = v4l2_ctrl_query_fill(qctrl,
633 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
634 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 1,
635 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
636 if (err == 0 &&
637 params->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
638 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
639 return err;
640
641 case V4L2_CID_MPEG_VIDEO_BITRATE:
642 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 6000000);
643
644 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
645 err = v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 8000000);
646 if (err == 0 &&
647 params->video_bitrate_mode ==
648 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR)
649 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
650 return err;
651
652 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
653 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
654
655 case V4L2_CID_MPEG_VIDEO_MUTE:
656 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
657
658 case V4L2_CID_MPEG_VIDEO_MUTE_YUV: /* Init YUV (really YCbCr) to black */
659 return v4l2_ctrl_query_fill(qctrl, 0, 0xffffff, 1, 0x008080);
660
661 /* CX23415/6 specific */
662 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
663 return cx2341x_ctrl_query_fill(qctrl,
664 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL,
665 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO, 1,
666 default_params.video_spatial_filter_mode);
667
668 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
669 cx2341x_ctrl_query_fill(qctrl, 0, 15, 1,
670 default_params.video_spatial_filter);
671 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
672 if (params->video_spatial_filter_mode ==
673 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO)
674 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
675 return 0;
676
677 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
678 cx2341x_ctrl_query_fill(qctrl,
679 V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_OFF,
680 V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_2D_SYM_NON_SEPARABLE,
681 1,
682 default_params.video_luma_spatial_filter_type);
683 if (params->video_spatial_filter_mode ==
684 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO)
685 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
686 return 0;
687
688 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
689 cx2341x_ctrl_query_fill(qctrl,
690 V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_OFF,
691 V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR,
692 1,
693 default_params.video_chroma_spatial_filter_type);
694 if (params->video_spatial_filter_mode ==
695 V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO)
696 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
697 return 0;
698
699 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
700 return cx2341x_ctrl_query_fill(qctrl,
701 V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL,
702 V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO, 1,
703 default_params.video_temporal_filter_mode);
704
705 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
706 cx2341x_ctrl_query_fill(qctrl, 0, 31, 1,
707 default_params.video_temporal_filter);
708 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
709 if (params->video_temporal_filter_mode ==
710 V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO)
711 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
712 return 0;
713
714 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
715 return cx2341x_ctrl_query_fill(qctrl,
716 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF,
717 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_DIAG, 1,
718 default_params.video_median_filter_type);
719
720 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
721 cx2341x_ctrl_query_fill(qctrl, 0, 255, 1,
722 default_params.video_luma_median_filter_top);
723 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
724 if (params->video_median_filter_type ==
725 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
726 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
727 return 0;
728
729 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
730 cx2341x_ctrl_query_fill(qctrl, 0, 255, 1,
731 default_params.video_luma_median_filter_bottom);
732 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
733 if (params->video_median_filter_type ==
734 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
735 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
736 return 0;
737
738 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
739 cx2341x_ctrl_query_fill(qctrl, 0, 255, 1,
740 default_params.video_chroma_median_filter_top);
741 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
742 if (params->video_median_filter_type ==
743 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
744 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
745 return 0;
746
747 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
748 cx2341x_ctrl_query_fill(qctrl, 0, 255, 1,
749 default_params.video_chroma_median_filter_bottom);
750 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
751 if (params->video_median_filter_type ==
752 V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
753 qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
754 return 0;
755
756 case V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS:
757 return cx2341x_ctrl_query_fill(qctrl, 0, 1, 1,
758 default_params.stream_insert_nav_packets);
759
760 default:
761 return -EINVAL;
762
763 }
764 }
765 EXPORT_SYMBOL(cx2341x_ctrl_query);
766
767 const char **cx2341x_ctrl_get_menu(const struct cx2341x_mpeg_params *p, u32 id)
768 {
769 static const char *mpeg_stream_type_without_ts[] = {
770 "MPEG-2 Program Stream",
771 "",
772 "MPEG-1 System Stream",
773 "MPEG-2 DVD-compatible Stream",
774 "MPEG-1 VCD-compatible Stream",
775 "MPEG-2 SVCD-compatible Stream",
776 NULL
777 };
778
779 static const char *mpeg_stream_type_with_ts[] = {
780 "MPEG-2 Program Stream",
781 "MPEG-2 Transport Stream",
782 "MPEG-1 System Stream",
783 "MPEG-2 DVD-compatible Stream",
784 "MPEG-1 VCD-compatible Stream",
785 "MPEG-2 SVCD-compatible Stream",
786 NULL
787 };
788
789 static const char *mpeg_audio_encoding_l2_ac3[] = {
790 "",
791 "MPEG-1/2 Layer II",
792 "",
793 "",
794 "AC-3",
795 NULL
796 };
797
798 static const char *cx2341x_video_spatial_filter_mode_menu[] = {
799 "Manual",
800 "Auto",
801 NULL
802 };
803
804 static const char *cx2341x_video_luma_spatial_filter_type_menu[] = {
805 "Off",
806 "1D Horizontal",
807 "1D Vertical",
808 "2D H/V Separable",
809 "2D Symmetric non-separable",
810 NULL
811 };
812
813 static const char *cx2341x_video_chroma_spatial_filter_type_menu[] = {
814 "Off",
815 "1D Horizontal",
816 NULL
817 };
818
819 static const char *cx2341x_video_temporal_filter_mode_menu[] = {
820 "Manual",
821 "Auto",
822 NULL
823 };
824
825 static const char *cx2341x_video_median_filter_type_menu[] = {
826 "Off",
827 "Horizontal",
828 "Vertical",
829 "Horizontal/Vertical",
830 "Diagonal",
831 NULL
832 };
833
834 switch (id) {
835 case V4L2_CID_MPEG_STREAM_TYPE:
836 return (p->capabilities & CX2341X_CAP_HAS_TS) ?
837 mpeg_stream_type_with_ts : mpeg_stream_type_without_ts;
838 case V4L2_CID_MPEG_AUDIO_ENCODING:
839 return (p->capabilities & CX2341X_CAP_HAS_AC3) ?
840 mpeg_audio_encoding_l2_ac3 : v4l2_ctrl_get_menu(id);
841 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
842 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
843 return NULL;
844 case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
845 return cx2341x_video_spatial_filter_mode_menu;
846 case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
847 return cx2341x_video_luma_spatial_filter_type_menu;
848 case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
849 return cx2341x_video_chroma_spatial_filter_type_menu;
850 case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
851 return cx2341x_video_temporal_filter_mode_menu;
852 case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
853 return cx2341x_video_median_filter_type_menu;
854 default:
855 return v4l2_ctrl_get_menu(id);
856 }
857 }
858 EXPORT_SYMBOL(cx2341x_ctrl_get_menu);
859
860 /* definitions for audio properties bits 29-28 */
861 #define CX2341X_AUDIO_ENCODING_METHOD_MPEG 0
862 #define CX2341X_AUDIO_ENCODING_METHOD_AC3 1
863 #define CX2341X_AUDIO_ENCODING_METHOD_LPCM 2
864
865 static void cx2341x_calc_audio_properties(struct cx2341x_mpeg_params *params)
866 {
867 params->audio_properties =
868 (params->audio_sampling_freq << 0) |
869 (params->audio_mode << 8) |
870 (params->audio_mode_extension << 10) |
871 (((params->audio_emphasis == V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17)
872 ? 3 : params->audio_emphasis) << 12) |
873 (params->audio_crc << 14);
874
875 if ((params->capabilities & CX2341X_CAP_HAS_AC3) &&
876 params->audio_encoding == V4L2_MPEG_AUDIO_ENCODING_AC3) {
877 params->audio_properties |=
878 /* Not sure if this MPEG Layer II setting is required */
879 ((3 - V4L2_MPEG_AUDIO_ENCODING_LAYER_2) << 2) |
880 (params->audio_ac3_bitrate << 4) |
881 (CX2341X_AUDIO_ENCODING_METHOD_AC3 << 28);
882 } else {
883 /* Assuming MPEG Layer II */
884 params->audio_properties |=
885 ((3 - params->audio_encoding) << 2) |
886 ((1 + params->audio_l2_bitrate) << 4);
887 }
888 }
889
890 int cx2341x_ext_ctrls(struct cx2341x_mpeg_params *params, int busy,
891 struct v4l2_ext_controls *ctrls, unsigned int cmd)
892 {
893 int err = 0;
894 int i;
895
896 if (cmd == VIDIOC_G_EXT_CTRLS) {
897 for (i = 0; i < ctrls->count; i++) {
898 struct v4l2_ext_control *ctrl = ctrls->controls + i;
899
900 err = cx2341x_get_ctrl(params, ctrl);
901 if (err) {
902 ctrls->error_idx = i;
903 break;
904 }
905 }
906 return err;
907 }
908 for (i = 0; i < ctrls->count; i++) {
909 struct v4l2_ext_control *ctrl = ctrls->controls + i;
910 struct v4l2_queryctrl qctrl;
911 const char **menu_items = NULL;
912
913 qctrl.id = ctrl->id;
914 err = cx2341x_ctrl_query(params, &qctrl);
915 if (err)
916 break;
917 if (qctrl.type == V4L2_CTRL_TYPE_MENU)
918 menu_items = cx2341x_ctrl_get_menu(params, qctrl.id);
919 err = v4l2_ctrl_check(ctrl, &qctrl, menu_items);
920 if (err)
921 break;
922 err = cx2341x_set_ctrl(params, busy, ctrl);
923 if (err)
924 break;
925 }
926 if (err == 0 &&
927 params->video_bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR &&
928 params->video_bitrate_peak < params->video_bitrate) {
929 err = -ERANGE;
930 ctrls->error_idx = ctrls->count;
931 }
932 if (err)
933 ctrls->error_idx = i;
934 else
935 cx2341x_calc_audio_properties(params);
936 return err;
937 }
938 EXPORT_SYMBOL(cx2341x_ext_ctrls);
939
940 void cx2341x_fill_defaults(struct cx2341x_mpeg_params *p)
941 {
942 *p = default_params;
943 cx2341x_calc_audio_properties(p);
944 }
945 EXPORT_SYMBOL(cx2341x_fill_defaults);
946
947 static int cx2341x_api(void *priv, cx2341x_mbox_func func,
948 u32 cmd, int args, ...)
949 {
950 u32 data[CX2341X_MBOX_MAX_DATA];
951 va_list vargs;
952 int i;
953
954 va_start(vargs, args);
955
956 for (i = 0; i < args; i++)
957 data[i] = va_arg(vargs, int);
958 va_end(vargs);
959 return func(priv, cmd, args, 0, data);
960 }
961
962 #define NEQ(field) (old->field != new->field)
963
964 int cx2341x_update(void *priv, cx2341x_mbox_func func,
965 const struct cx2341x_mpeg_params *old,
966 const struct cx2341x_mpeg_params *new)
967 {
968 static int mpeg_stream_type[] = {
969 0, /* MPEG-2 PS */
970 1, /* MPEG-2 TS */
971 2, /* MPEG-1 SS */
972 14, /* DVD */
973 11, /* VCD */
974 12, /* SVCD */
975 };
976
977 int err = 0;
978 int force = (old == NULL);
979 u16 temporal = new->video_temporal_filter;
980
981 cx2341x_api(priv, func, CX2341X_ENC_SET_OUTPUT_PORT, 2, new->port, 0);
982
983 if (force || NEQ(is_50hz)) {
984 err = cx2341x_api(priv, func, CX2341X_ENC_SET_FRAME_RATE, 1,
985 new->is_50hz);
986 if (err) return err;
987 }
988
989 if (force || NEQ(width) || NEQ(height) || NEQ(video_encoding)) {
990 u16 w = new->width;
991 u16 h = new->height;
992
993 if (new->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1) {
994 w /= 2;
995 h /= 2;
996 }
997 err = cx2341x_api(priv, func, CX2341X_ENC_SET_FRAME_SIZE, 2,
998 h, w);
999 if (err) return err;
1000 }
1001
1002 if (new->width != 720 || new->height != (new->is_50hz ? 576 : 480)) {
1003 /* Adjust temporal filter if necessary. The problem with the
1004 temporal filter is that it works well with full resolution
1005 capturing, but not when the capture window is scaled (the
1006 filter introduces a ghosting effect). So if the capture
1007 window is scaled, then force the filter to 0.
1008
1009 For full resolution the filter really improves the video
1010 quality, especially if the original video quality is
1011 suboptimal. */
1012 temporal = 0;
1013 }
1014
1015 if (force || NEQ(stream_type)) {
1016 err = cx2341x_api(priv, func, CX2341X_ENC_SET_STREAM_TYPE, 1,
1017 mpeg_stream_type[new->stream_type]);
1018 if (err) return err;
1019 }
1020 if (force || NEQ(video_aspect)) {
1021 err = cx2341x_api(priv, func, CX2341X_ENC_SET_ASPECT_RATIO, 1,
1022 1 + new->video_aspect);
1023 if (err) return err;
1024 }
1025 if (force || NEQ(video_b_frames) || NEQ(video_gop_size)) {
1026 err = cx2341x_api(priv, func, CX2341X_ENC_SET_GOP_PROPERTIES, 2,
1027 new->video_gop_size, new->video_b_frames + 1);
1028 if (err) return err;
1029 }
1030 if (force || NEQ(video_gop_closure)) {
1031 err = cx2341x_api(priv, func, CX2341X_ENC_SET_GOP_CLOSURE, 1,
1032 new->video_gop_closure);
1033 if (err) return err;
1034 }
1035 if (force || NEQ(audio_properties)) {
1036 err = cx2341x_api(priv, func, CX2341X_ENC_SET_AUDIO_PROPERTIES,
1037 1, new->audio_properties);
1038 if (err) return err;
1039 }
1040 if (force || NEQ(audio_mute)) {
1041 err = cx2341x_api(priv, func, CX2341X_ENC_MUTE_AUDIO, 1,
1042 new->audio_mute);
1043 if (err) return err;
1044 }
1045 if (force || NEQ(video_bitrate_mode) || NEQ(video_bitrate) ||
1046 NEQ(video_bitrate_peak)) {
1047 err = cx2341x_api(priv, func, CX2341X_ENC_SET_BIT_RATE, 5,
1048 new->video_bitrate_mode, new->video_bitrate,
1049 new->video_bitrate_peak / 400, 0, 0);
1050 if (err) return err;
1051 }
1052 if (force || NEQ(video_spatial_filter_mode) ||
1053 NEQ(video_temporal_filter_mode) ||
1054 NEQ(video_median_filter_type)) {
1055 err = cx2341x_api(priv, func, CX2341X_ENC_SET_DNR_FILTER_MODE,
1056 2, new->video_spatial_filter_mode |
1057 (new->video_temporal_filter_mode << 1),
1058 new->video_median_filter_type);
1059 if (err) return err;
1060 }
1061 if (force || NEQ(video_luma_median_filter_bottom) ||
1062 NEQ(video_luma_median_filter_top) ||
1063 NEQ(video_chroma_median_filter_bottom) ||
1064 NEQ(video_chroma_median_filter_top)) {
1065 err = cx2341x_api(priv, func, CX2341X_ENC_SET_CORING_LEVELS, 4,
1066 new->video_luma_median_filter_bottom,
1067 new->video_luma_median_filter_top,
1068 new->video_chroma_median_filter_bottom,
1069 new->video_chroma_median_filter_top);
1070 if (err) return err;
1071 }
1072 if (force || NEQ(video_luma_spatial_filter_type) ||
1073 NEQ(video_chroma_spatial_filter_type)) {
1074 err = cx2341x_api(priv, func,
1075 CX2341X_ENC_SET_SPATIAL_FILTER_TYPE,
1076 2, new->video_luma_spatial_filter_type,
1077 new->video_chroma_spatial_filter_type);
1078 if (err) return err;
1079 }
1080 if (force || NEQ(video_spatial_filter) ||
1081 old->video_temporal_filter != temporal) {
1082 err = cx2341x_api(priv, func, CX2341X_ENC_SET_DNR_FILTER_PROPS,
1083 2, new->video_spatial_filter, temporal);
1084 if (err) return err;
1085 }
1086 if (force || NEQ(video_temporal_decimation)) {
1087 err = cx2341x_api(priv, func, CX2341X_ENC_SET_FRAME_DROP_RATE,
1088 1, new->video_temporal_decimation);
1089 if (err) return err;
1090 }
1091 if (force || NEQ(video_mute) ||
1092 (new->video_mute && NEQ(video_mute_yuv))) {
1093 err = cx2341x_api(priv, func, CX2341X_ENC_MUTE_VIDEO, 1,
1094 new->video_mute | (new->video_mute_yuv << 8));
1095 if (err) return err;
1096 }
1097 if (force || NEQ(stream_insert_nav_packets)) {
1098 err = cx2341x_api(priv, func, CX2341X_ENC_MISC, 2,
1099 7, new->stream_insert_nav_packets);
1100 if (err) return err;
1101 }
1102 return 0;
1103 }
1104 EXPORT_SYMBOL(cx2341x_update);
1105
1106 static const char *cx2341x_menu_item(const struct cx2341x_mpeg_params *p, u32 id)
1107 {
1108 const char **menu = cx2341x_ctrl_get_menu(p, id);
1109 struct v4l2_ext_control ctrl;
1110
1111 if (menu == NULL)
1112 goto invalid;
1113 ctrl.id = id;
1114 if (cx2341x_get_ctrl(p, &ctrl))
1115 goto invalid;
1116 while (ctrl.value-- && *menu) menu++;
1117 if (*menu == NULL)
1118 goto invalid;
1119 return *menu;
1120
1121 invalid:
1122 return "<invalid>";
1123 }
1124
1125 void cx2341x_log_status(const struct cx2341x_mpeg_params *p, const char *prefix)
1126 {
1127 int is_mpeg1 = p->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1;
1128 int temporal = p->video_temporal_filter;
1129
1130 /* Stream */
1131 printk(KERN_INFO "%s: Stream: %s",
1132 prefix,
1133 cx2341x_menu_item(p, V4L2_CID_MPEG_STREAM_TYPE));
1134 if (p->stream_insert_nav_packets)
1135 printk(" (with navigation packets)");
1136 printk("\n");
1137 printk(KERN_INFO "%s: VBI Format: %s\n",
1138 prefix,
1139 cx2341x_menu_item(p, V4L2_CID_MPEG_STREAM_VBI_FMT));
1140
1141 /* Video */
1142 printk(KERN_INFO "%s: Video: %dx%d, %d fps%s\n",
1143 prefix,
1144 p->width / (is_mpeg1 ? 2 : 1), p->height / (is_mpeg1 ? 2 : 1),
1145 p->is_50hz ? 25 : 30,
1146 (p->video_mute) ? " (muted)" : "");
1147 printk(KERN_INFO "%s: Video: %s, %s, %s, %d",
1148 prefix,
1149 cx2341x_menu_item(p, V4L2_CID_MPEG_VIDEO_ENCODING),
1150 cx2341x_menu_item(p, V4L2_CID_MPEG_VIDEO_ASPECT),
1151 cx2341x_menu_item(p, V4L2_CID_MPEG_VIDEO_BITRATE_MODE),
1152 p->video_bitrate);
1153 if (p->video_bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR)
1154 printk(", Peak %d", p->video_bitrate_peak);
1155 printk("\n");
1156 printk(KERN_INFO
1157 "%s: Video: GOP Size %d, %d B-Frames, %sGOP Closure\n",
1158 prefix,
1159 p->video_gop_size, p->video_b_frames,
1160 p->video_gop_closure ? "" : "No ");
1161 if (p->video_temporal_decimation)
1162 printk(KERN_INFO "%s: Video: Temporal Decimation %d\n",
1163 prefix, p->video_temporal_decimation);
1164
1165 /* Audio */
1166 printk(KERN_INFO "%s: Audio: %s, %s, %s, %s%s",
1167 prefix,
1168 cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ),
1169 cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_ENCODING),
1170 cx2341x_menu_item(p,
1171 p->audio_encoding == V4L2_MPEG_AUDIO_ENCODING_AC3
1172 ? V4L2_CID_MPEG_AUDIO_AC3_BITRATE
1173 : V4L2_CID_MPEG_AUDIO_L2_BITRATE),
1174 cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_MODE),
1175 p->audio_mute ? " (muted)" : "");
1176 if (p->audio_mode == V4L2_MPEG_AUDIO_MODE_JOINT_STEREO)
1177 printk(", %s", cx2341x_menu_item(p,
1178 V4L2_CID_MPEG_AUDIO_MODE_EXTENSION));
1179 printk(", %s, %s\n",
1180 cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_EMPHASIS),
1181 cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_CRC));
1182
1183 /* Encoding filters */
1184 printk(KERN_INFO "%s: Spatial Filter: %s, Luma %s, Chroma %s, %d\n",
1185 prefix,
1186 cx2341x_menu_item(p,
1187 V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE),
1188 cx2341x_menu_item(p,
1189 V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE),
1190 cx2341x_menu_item(p,
1191 V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE),
1192 p->video_spatial_filter);
1193
1194 if (p->width != 720 || p->height != (p->is_50hz ? 576 : 480))
1195 temporal = 0;
1196
1197 printk(KERN_INFO "%s: Temporal Filter: %s, %d\n",
1198 prefix,
1199 cx2341x_menu_item(p,
1200 V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE),
1201 temporal);
1202 printk(KERN_INFO
1203 "%s: Median Filter: %s, Luma [%d, %d], Chroma [%d, %d]\n",
1204 prefix,
1205 cx2341x_menu_item(p,
1206 V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE),
1207 p->video_luma_median_filter_bottom,
1208 p->video_luma_median_filter_top,
1209 p->video_chroma_median_filter_bottom,
1210 p->video_chroma_median_filter_top);
1211 }
1212 EXPORT_SYMBOL(cx2341x_log_status);
1213
1214 /*
1215 * Local variables:
1216 * c-basic-offset: 8
1217 * End:
1218 */
1219
Linux kernel - Deliverables
This page took 0.077947 seconds and 5 git commands to generate.