1620 lines
56 KiB
C
1620 lines
56 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* V4L2 controls framework control definitions.
|
|
*
|
|
* Copyright (C) 2010-2021 Hans Verkuil <hverkuil-cisco@xs4all.nl>
|
|
*/
|
|
|
|
#include <linux/export.h>
|
|
#include <media/v4l2-ctrls.h>
|
|
|
|
/*
|
|
* Returns NULL or a character pointer array containing the menu for
|
|
* the given control ID. The pointer array ends with a NULL pointer.
|
|
* An empty string signifies a menu entry that is invalid. This allows
|
|
* drivers to disable certain options if it is not supported.
|
|
*/
|
|
const char * const *v4l2_ctrl_get_menu(u32 id)
|
|
{
|
|
static const char * const mpeg_audio_sampling_freq[] = {
|
|
"44.1 kHz",
|
|
"48 kHz",
|
|
"32 kHz",
|
|
NULL
|
|
};
|
|
static const char * const mpeg_audio_encoding[] = {
|
|
"MPEG-1/2 Layer I",
|
|
"MPEG-1/2 Layer II",
|
|
"MPEG-1/2 Layer III",
|
|
"MPEG-2/4 AAC",
|
|
"AC-3",
|
|
NULL
|
|
};
|
|
static const char * const mpeg_audio_l1_bitrate[] = {
|
|
"32 kbps",
|
|
"64 kbps",
|
|
"96 kbps",
|
|
"128 kbps",
|
|
"160 kbps",
|
|
"192 kbps",
|
|
"224 kbps",
|
|
"256 kbps",
|
|
"288 kbps",
|
|
"320 kbps",
|
|
"352 kbps",
|
|
"384 kbps",
|
|
"416 kbps",
|
|
"448 kbps",
|
|
NULL
|
|
};
|
|
static const char * const mpeg_audio_l2_bitrate[] = {
|
|
"32 kbps",
|
|
"48 kbps",
|
|
"56 kbps",
|
|
"64 kbps",
|
|
"80 kbps",
|
|
"96 kbps",
|
|
"112 kbps",
|
|
"128 kbps",
|
|
"160 kbps",
|
|
"192 kbps",
|
|
"224 kbps",
|
|
"256 kbps",
|
|
"320 kbps",
|
|
"384 kbps",
|
|
NULL
|
|
};
|
|
static const char * const mpeg_audio_l3_bitrate[] = {
|
|
"32 kbps",
|
|
"40 kbps",
|
|
"48 kbps",
|
|
"56 kbps",
|
|
"64 kbps",
|
|
"80 kbps",
|
|
"96 kbps",
|
|
"112 kbps",
|
|
"128 kbps",
|
|
"160 kbps",
|
|
"192 kbps",
|
|
"224 kbps",
|
|
"256 kbps",
|
|
"320 kbps",
|
|
NULL
|
|
};
|
|
static const char * const mpeg_audio_ac3_bitrate[] = {
|
|
"32 kbps",
|
|
"40 kbps",
|
|
"48 kbps",
|
|
"56 kbps",
|
|
"64 kbps",
|
|
"80 kbps",
|
|
"96 kbps",
|
|
"112 kbps",
|
|
"128 kbps",
|
|
"160 kbps",
|
|
"192 kbps",
|
|
"224 kbps",
|
|
"256 kbps",
|
|
"320 kbps",
|
|
"384 kbps",
|
|
"448 kbps",
|
|
"512 kbps",
|
|
"576 kbps",
|
|
"640 kbps",
|
|
NULL
|
|
};
|
|
static const char * const mpeg_audio_mode[] = {
|
|
"Stereo",
|
|
"Joint Stereo",
|
|
"Dual",
|
|
"Mono",
|
|
NULL
|
|
};
|
|
static const char * const mpeg_audio_mode_extension[] = {
|
|
"Bound 4",
|
|
"Bound 8",
|
|
"Bound 12",
|
|
"Bound 16",
|
|
NULL
|
|
};
|
|
static const char * const mpeg_audio_emphasis[] = {
|
|
"No Emphasis",
|
|
"50/15 us",
|
|
"CCITT J17",
|
|
NULL
|
|
};
|
|
static const char * const mpeg_audio_crc[] = {
|
|
"No CRC",
|
|
"16-bit CRC",
|
|
NULL
|
|
};
|
|
static const char * const mpeg_audio_dec_playback[] = {
|
|
"Auto",
|
|
"Stereo",
|
|
"Left",
|
|
"Right",
|
|
"Mono",
|
|
"Swapped Stereo",
|
|
NULL
|
|
};
|
|
static const char * const mpeg_video_encoding[] = {
|
|
"MPEG-1",
|
|
"MPEG-2",
|
|
"MPEG-4 AVC",
|
|
NULL
|
|
};
|
|
static const char * const mpeg_video_aspect[] = {
|
|
"1x1",
|
|
"4x3",
|
|
"16x9",
|
|
"2.21x1",
|
|
NULL
|
|
};
|
|
static const char * const mpeg_video_bitrate_mode[] = {
|
|
"Variable Bitrate",
|
|
"Constant Bitrate",
|
|
"Constant Quality",
|
|
NULL
|
|
};
|
|
static const char * const mpeg_stream_type[] = {
|
|
"MPEG-2 Program Stream",
|
|
"MPEG-2 Transport Stream",
|
|
"MPEG-1 System Stream",
|
|
"MPEG-2 DVD-compatible Stream",
|
|
"MPEG-1 VCD-compatible Stream",
|
|
"MPEG-2 SVCD-compatible Stream",
|
|
NULL
|
|
};
|
|
static const char * const mpeg_stream_vbi_fmt[] = {
|
|
"No VBI",
|
|
"Private Packet, IVTV Format",
|
|
NULL
|
|
};
|
|
static const char * const camera_power_line_frequency[] = {
|
|
"Disabled",
|
|
"50 Hz",
|
|
"60 Hz",
|
|
"Auto",
|
|
NULL
|
|
};
|
|
static const char * const camera_exposure_auto[] = {
|
|
"Auto Mode",
|
|
"Manual Mode",
|
|
"Shutter Priority Mode",
|
|
"Aperture Priority Mode",
|
|
NULL
|
|
};
|
|
static const char * const camera_exposure_metering[] = {
|
|
"Average",
|
|
"Center Weighted",
|
|
"Spot",
|
|
"Matrix",
|
|
NULL
|
|
};
|
|
static const char * const camera_auto_focus_range[] = {
|
|
"Auto",
|
|
"Normal",
|
|
"Macro",
|
|
"Infinity",
|
|
NULL
|
|
};
|
|
static const char * const colorfx[] = {
|
|
"None",
|
|
"Black & White",
|
|
"Sepia",
|
|
"Negative",
|
|
"Emboss",
|
|
"Sketch",
|
|
"Sky Blue",
|
|
"Grass Green",
|
|
"Skin Whiten",
|
|
"Vivid",
|
|
"Aqua",
|
|
"Art Freeze",
|
|
"Silhouette",
|
|
"Solarization",
|
|
"Antique",
|
|
"Set Cb/Cr",
|
|
NULL
|
|
};
|
|
static const char * const auto_n_preset_white_balance[] = {
|
|
"Manual",
|
|
"Auto",
|
|
"Incandescent",
|
|
"Fluorescent",
|
|
"Fluorescent H",
|
|
"Horizon",
|
|
"Daylight",
|
|
"Flash",
|
|
"Cloudy",
|
|
"Shade",
|
|
NULL,
|
|
};
|
|
static const char * const camera_iso_sensitivity_auto[] = {
|
|
"Manual",
|
|
"Auto",
|
|
NULL
|
|
};
|
|
static const char * const scene_mode[] = {
|
|
"None",
|
|
"Backlight",
|
|
"Beach/Snow",
|
|
"Candle Light",
|
|
"Dusk/Dawn",
|
|
"Fall Colors",
|
|
"Fireworks",
|
|
"Landscape",
|
|
"Night",
|
|
"Party/Indoor",
|
|
"Portrait",
|
|
"Sports",
|
|
"Sunset",
|
|
"Text",
|
|
NULL
|
|
};
|
|
static const char * const tune_emphasis[] = {
|
|
"None",
|
|
"50 Microseconds",
|
|
"75 Microseconds",
|
|
NULL,
|
|
};
|
|
static const char * const header_mode[] = {
|
|
"Separate Buffer",
|
|
"Joined With 1st Frame",
|
|
NULL,
|
|
};
|
|
static const char * const multi_slice[] = {
|
|
"Single",
|
|
"Max Macroblocks",
|
|
"Max Bytes",
|
|
NULL,
|
|
};
|
|
static const char * const entropy_mode[] = {
|
|
"CAVLC",
|
|
"CABAC",
|
|
NULL,
|
|
};
|
|
static const char * const mpeg_h264_level[] = {
|
|
"1",
|
|
"1b",
|
|
"1.1",
|
|
"1.2",
|
|
"1.3",
|
|
"2",
|
|
"2.1",
|
|
"2.2",
|
|
"3",
|
|
"3.1",
|
|
"3.2",
|
|
"4",
|
|
"4.1",
|
|
"4.2",
|
|
"5",
|
|
"5.1",
|
|
"5.2",
|
|
"6.0",
|
|
"6.1",
|
|
"6.2",
|
|
NULL,
|
|
};
|
|
static const char * const h264_loop_filter[] = {
|
|
"Enabled",
|
|
"Disabled",
|
|
"Disabled at Slice Boundary",
|
|
NULL,
|
|
};
|
|
static const char * const h264_profile[] = {
|
|
"Baseline",
|
|
"Constrained Baseline",
|
|
"Main",
|
|
"Extended",
|
|
"High",
|
|
"High 10",
|
|
"High 422",
|
|
"High 444 Predictive",
|
|
"High 10 Intra",
|
|
"High 422 Intra",
|
|
"High 444 Intra",
|
|
"CAVLC 444 Intra",
|
|
"Scalable Baseline",
|
|
"Scalable High",
|
|
"Scalable High Intra",
|
|
"Stereo High",
|
|
"Multiview High",
|
|
"Constrained High",
|
|
NULL,
|
|
};
|
|
static const char * const vui_sar_idc[] = {
|
|
"Unspecified",
|
|
"1:1",
|
|
"12:11",
|
|
"10:11",
|
|
"16:11",
|
|
"40:33",
|
|
"24:11",
|
|
"20:11",
|
|
"32:11",
|
|
"80:33",
|
|
"18:11",
|
|
"15:11",
|
|
"64:33",
|
|
"160:99",
|
|
"4:3",
|
|
"3:2",
|
|
"2:1",
|
|
"Extended SAR",
|
|
NULL,
|
|
};
|
|
static const char * const h264_fp_arrangement_type[] = {
|
|
"Checkerboard",
|
|
"Column",
|
|
"Row",
|
|
"Side by Side",
|
|
"Top Bottom",
|
|
"Temporal",
|
|
NULL,
|
|
};
|
|
static const char * const h264_fmo_map_type[] = {
|
|
"Interleaved Slices",
|
|
"Scattered Slices",
|
|
"Foreground with Leftover",
|
|
"Box Out",
|
|
"Raster Scan",
|
|
"Wipe Scan",
|
|
"Explicit",
|
|
NULL,
|
|
};
|
|
static const char * const h264_decode_mode[] = {
|
|
"Slice-Based",
|
|
"Frame-Based",
|
|
NULL,
|
|
};
|
|
static const char * const h264_start_code[] = {
|
|
"No Start Code",
|
|
"Annex B Start Code",
|
|
NULL,
|
|
};
|
|
static const char * const h264_hierarchical_coding_type[] = {
|
|
"Hier Coding B",
|
|
"Hier Coding P",
|
|
NULL,
|
|
};
|
|
static const char * const mpeg_mpeg2_level[] = {
|
|
"Low",
|
|
"Main",
|
|
"High 1440",
|
|
"High",
|
|
NULL,
|
|
};
|
|
static const char * const mpeg2_profile[] = {
|
|
"Simple",
|
|
"Main",
|
|
"SNR Scalable",
|
|
"Spatially Scalable",
|
|
"High",
|
|
NULL,
|
|
};
|
|
static const char * const mpeg_mpeg4_level[] = {
|
|
"0",
|
|
"0b",
|
|
"1",
|
|
"2",
|
|
"3",
|
|
"3b",
|
|
"4",
|
|
"5",
|
|
NULL,
|
|
};
|
|
static const char * const mpeg4_profile[] = {
|
|
"Simple",
|
|
"Advanced Simple",
|
|
"Core",
|
|
"Simple Scalable",
|
|
"Advanced Coding Efficiency",
|
|
NULL,
|
|
};
|
|
|
|
static const char * const vpx_golden_frame_sel[] = {
|
|
"Use Previous Frame",
|
|
"Use Previous Specific Frame",
|
|
NULL,
|
|
};
|
|
static const char * const vp8_profile[] = {
|
|
"0",
|
|
"1",
|
|
"2",
|
|
"3",
|
|
NULL,
|
|
};
|
|
static const char * const vp9_profile[] = {
|
|
"0",
|
|
"1",
|
|
"2",
|
|
"3",
|
|
NULL,
|
|
};
|
|
static const char * const vp9_level[] = {
|
|
"1",
|
|
"1.1",
|
|
"2",
|
|
"2.1",
|
|
"3",
|
|
"3.1",
|
|
"4",
|
|
"4.1",
|
|
"5",
|
|
"5.1",
|
|
"5.2",
|
|
"6",
|
|
"6.1",
|
|
"6.2",
|
|
NULL,
|
|
};
|
|
|
|
static const char * const flash_led_mode[] = {
|
|
"Off",
|
|
"Flash",
|
|
"Torch",
|
|
NULL,
|
|
};
|
|
static const char * const flash_strobe_source[] = {
|
|
"Software",
|
|
"External",
|
|
NULL,
|
|
};
|
|
|
|
static const char * const jpeg_chroma_subsampling[] = {
|
|
"4:4:4",
|
|
"4:2:2",
|
|
"4:2:0",
|
|
"4:1:1",
|
|
"4:1:0",
|
|
"Gray",
|
|
NULL,
|
|
};
|
|
static const char * const dv_tx_mode[] = {
|
|
"DVI-D",
|
|
"HDMI",
|
|
NULL,
|
|
};
|
|
static const char * const dv_rgb_range[] = {
|
|
"Automatic",
|
|
"RGB Limited Range (16-235)",
|
|
"RGB Full Range (0-255)",
|
|
NULL,
|
|
};
|
|
static const char * const dv_it_content_type[] = {
|
|
"Graphics",
|
|
"Photo",
|
|
"Cinema",
|
|
"Game",
|
|
"No IT Content",
|
|
NULL,
|
|
};
|
|
static const char * const detect_md_mode[] = {
|
|
"Disabled",
|
|
"Global",
|
|
"Threshold Grid",
|
|
"Region Grid",
|
|
NULL,
|
|
};
|
|
|
|
static const char * const hevc_profile[] = {
|
|
"Main",
|
|
"Main Still Picture",
|
|
"Main 10",
|
|
NULL,
|
|
};
|
|
static const char * const hevc_level[] = {
|
|
"1",
|
|
"2",
|
|
"2.1",
|
|
"3",
|
|
"3.1",
|
|
"4",
|
|
"4.1",
|
|
"5",
|
|
"5.1",
|
|
"5.2",
|
|
"6",
|
|
"6.1",
|
|
"6.2",
|
|
NULL,
|
|
};
|
|
static const char * const hevc_hierarchial_coding_type[] = {
|
|
"B",
|
|
"P",
|
|
NULL,
|
|
};
|
|
static const char * const hevc_refresh_type[] = {
|
|
"None",
|
|
"CRA",
|
|
"IDR",
|
|
NULL,
|
|
};
|
|
static const char * const hevc_size_of_length_field[] = {
|
|
"0",
|
|
"1",
|
|
"2",
|
|
"4",
|
|
NULL,
|
|
};
|
|
static const char * const hevc_tier[] = {
|
|
"Main",
|
|
"High",
|
|
NULL,
|
|
};
|
|
static const char * const hevc_loop_filter_mode[] = {
|
|
"Disabled",
|
|
"Enabled",
|
|
"Disabled at slice boundary",
|
|
"NULL",
|
|
};
|
|
static const char * const hevc_decode_mode[] = {
|
|
"Slice-Based",
|
|
"Frame-Based",
|
|
NULL,
|
|
};
|
|
static const char * const hevc_start_code[] = {
|
|
"No Start Code",
|
|
"Annex B Start Code",
|
|
NULL,
|
|
};
|
|
static const char * const camera_orientation[] = {
|
|
"Front",
|
|
"Back",
|
|
"External",
|
|
NULL,
|
|
};
|
|
static const char * const mpeg_video_frame_skip[] = {
|
|
"Disabled",
|
|
"Level Limit",
|
|
"VBV/CPB Limit",
|
|
NULL,
|
|
};
|
|
static const char * const intra_refresh_period_type[] = {
|
|
"Random",
|
|
"Cyclic",
|
|
NULL,
|
|
};
|
|
|
|
switch (id) {
|
|
case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
|
|
return mpeg_audio_sampling_freq;
|
|
case V4L2_CID_MPEG_AUDIO_ENCODING:
|
|
return mpeg_audio_encoding;
|
|
case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
|
|
return mpeg_audio_l1_bitrate;
|
|
case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
|
|
return mpeg_audio_l2_bitrate;
|
|
case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
|
|
return mpeg_audio_l3_bitrate;
|
|
case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
|
|
return mpeg_audio_ac3_bitrate;
|
|
case V4L2_CID_MPEG_AUDIO_MODE:
|
|
return mpeg_audio_mode;
|
|
case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
|
|
return mpeg_audio_mode_extension;
|
|
case V4L2_CID_MPEG_AUDIO_EMPHASIS:
|
|
return mpeg_audio_emphasis;
|
|
case V4L2_CID_MPEG_AUDIO_CRC:
|
|
return mpeg_audio_crc;
|
|
case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
|
|
case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
|
|
return mpeg_audio_dec_playback;
|
|
case V4L2_CID_MPEG_VIDEO_ENCODING:
|
|
return mpeg_video_encoding;
|
|
case V4L2_CID_MPEG_VIDEO_ASPECT:
|
|
return mpeg_video_aspect;
|
|
case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
|
|
return mpeg_video_bitrate_mode;
|
|
case V4L2_CID_MPEG_STREAM_TYPE:
|
|
return mpeg_stream_type;
|
|
case V4L2_CID_MPEG_STREAM_VBI_FMT:
|
|
return mpeg_stream_vbi_fmt;
|
|
case V4L2_CID_POWER_LINE_FREQUENCY:
|
|
return camera_power_line_frequency;
|
|
case V4L2_CID_EXPOSURE_AUTO:
|
|
return camera_exposure_auto;
|
|
case V4L2_CID_EXPOSURE_METERING:
|
|
return camera_exposure_metering;
|
|
case V4L2_CID_AUTO_FOCUS_RANGE:
|
|
return camera_auto_focus_range;
|
|
case V4L2_CID_COLORFX:
|
|
return colorfx;
|
|
case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
|
|
return auto_n_preset_white_balance;
|
|
case V4L2_CID_ISO_SENSITIVITY_AUTO:
|
|
return camera_iso_sensitivity_auto;
|
|
case V4L2_CID_SCENE_MODE:
|
|
return scene_mode;
|
|
case V4L2_CID_TUNE_PREEMPHASIS:
|
|
return tune_emphasis;
|
|
case V4L2_CID_TUNE_DEEMPHASIS:
|
|
return tune_emphasis;
|
|
case V4L2_CID_FLASH_LED_MODE:
|
|
return flash_led_mode;
|
|
case V4L2_CID_FLASH_STROBE_SOURCE:
|
|
return flash_strobe_source;
|
|
case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
|
|
return header_mode;
|
|
case V4L2_CID_MPEG_VIDEO_FRAME_SKIP_MODE:
|
|
return mpeg_video_frame_skip;
|
|
case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
|
|
return multi_slice;
|
|
case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
|
|
return entropy_mode;
|
|
case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
|
|
return mpeg_h264_level;
|
|
case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
|
|
return h264_loop_filter;
|
|
case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
|
|
return h264_profile;
|
|
case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
|
|
return vui_sar_idc;
|
|
case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
|
|
return h264_fp_arrangement_type;
|
|
case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
|
|
return h264_fmo_map_type;
|
|
case V4L2_CID_STATELESS_H264_DECODE_MODE:
|
|
return h264_decode_mode;
|
|
case V4L2_CID_STATELESS_H264_START_CODE:
|
|
return h264_start_code;
|
|
case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE:
|
|
return h264_hierarchical_coding_type;
|
|
case V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL:
|
|
return mpeg_mpeg2_level;
|
|
case V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE:
|
|
return mpeg2_profile;
|
|
case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
|
|
return mpeg_mpeg4_level;
|
|
case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
|
|
return mpeg4_profile;
|
|
case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:
|
|
return vpx_golden_frame_sel;
|
|
case V4L2_CID_MPEG_VIDEO_VP8_PROFILE:
|
|
return vp8_profile;
|
|
case V4L2_CID_MPEG_VIDEO_VP9_PROFILE:
|
|
return vp9_profile;
|
|
case V4L2_CID_MPEG_VIDEO_VP9_LEVEL:
|
|
return vp9_level;
|
|
case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
|
|
return jpeg_chroma_subsampling;
|
|
case V4L2_CID_DV_TX_MODE:
|
|
return dv_tx_mode;
|
|
case V4L2_CID_DV_TX_RGB_RANGE:
|
|
case V4L2_CID_DV_RX_RGB_RANGE:
|
|
return dv_rgb_range;
|
|
case V4L2_CID_DV_TX_IT_CONTENT_TYPE:
|
|
case V4L2_CID_DV_RX_IT_CONTENT_TYPE:
|
|
return dv_it_content_type;
|
|
case V4L2_CID_DETECT_MD_MODE:
|
|
return detect_md_mode;
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE:
|
|
return hevc_profile;
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL:
|
|
return hevc_level;
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_TYPE:
|
|
return hevc_hierarchial_coding_type;
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_TYPE:
|
|
return hevc_refresh_type;
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_SIZE_OF_LENGTH_FIELD:
|
|
return hevc_size_of_length_field;
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_TIER:
|
|
return hevc_tier;
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE:
|
|
return hevc_loop_filter_mode;
|
|
case V4L2_CID_STATELESS_HEVC_DECODE_MODE:
|
|
return hevc_decode_mode;
|
|
case V4L2_CID_STATELESS_HEVC_START_CODE:
|
|
return hevc_start_code;
|
|
case V4L2_CID_CAMERA_ORIENTATION:
|
|
return camera_orientation;
|
|
case V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD_TYPE:
|
|
return intra_refresh_period_type;
|
|
default:
|
|
return NULL;
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(v4l2_ctrl_get_menu);
|
|
|
|
#define __v4l2_qmenu_int_len(arr, len) ({ *(len) = ARRAY_SIZE(arr); (arr); })
|
|
/*
|
|
* Returns NULL or an s64 type array containing the menu for given
|
|
* control ID. The total number of the menu items is returned in @len.
|
|
*/
|
|
const s64 *v4l2_ctrl_get_int_menu(u32 id, u32 *len)
|
|
{
|
|
static const s64 qmenu_int_vpx_num_partitions[] = {
|
|
1, 2, 4, 8,
|
|
};
|
|
|
|
static const s64 qmenu_int_vpx_num_ref_frames[] = {
|
|
1, 2, 3,
|
|
};
|
|
|
|
switch (id) {
|
|
case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:
|
|
return __v4l2_qmenu_int_len(qmenu_int_vpx_num_partitions, len);
|
|
case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:
|
|
return __v4l2_qmenu_int_len(qmenu_int_vpx_num_ref_frames, len);
|
|
default:
|
|
*len = 0;
|
|
return NULL;
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(v4l2_ctrl_get_int_menu);
|
|
|
|
/* Return the control name. */
|
|
const char *v4l2_ctrl_get_name(u32 id)
|
|
{
|
|
switch (id) {
|
|
/* USER controls */
|
|
/* Keep the order of the 'case's the same as in v4l2-controls.h! */
|
|
case V4L2_CID_USER_CLASS: return "User Controls";
|
|
case V4L2_CID_BRIGHTNESS: return "Brightness";
|
|
case V4L2_CID_CONTRAST: return "Contrast";
|
|
case V4L2_CID_SATURATION: return "Saturation";
|
|
case V4L2_CID_HUE: return "Hue";
|
|
case V4L2_CID_AUDIO_VOLUME: return "Volume";
|
|
case V4L2_CID_AUDIO_BALANCE: return "Balance";
|
|
case V4L2_CID_AUDIO_BASS: return "Bass";
|
|
case V4L2_CID_AUDIO_TREBLE: return "Treble";
|
|
case V4L2_CID_AUDIO_MUTE: return "Mute";
|
|
case V4L2_CID_AUDIO_LOUDNESS: return "Loudness";
|
|
case V4L2_CID_BLACK_LEVEL: return "Black Level";
|
|
case V4L2_CID_AUTO_WHITE_BALANCE: return "White Balance, Automatic";
|
|
case V4L2_CID_DO_WHITE_BALANCE: return "Do White Balance";
|
|
case V4L2_CID_RED_BALANCE: return "Red Balance";
|
|
case V4L2_CID_BLUE_BALANCE: return "Blue Balance";
|
|
case V4L2_CID_GAMMA: return "Gamma";
|
|
case V4L2_CID_EXPOSURE: return "Exposure";
|
|
case V4L2_CID_AUTOGAIN: return "Gain, Automatic";
|
|
case V4L2_CID_GAIN: return "Gain";
|
|
case V4L2_CID_HFLIP: return "Horizontal Flip";
|
|
case V4L2_CID_VFLIP: return "Vertical Flip";
|
|
case V4L2_CID_POWER_LINE_FREQUENCY: return "Power Line Frequency";
|
|
case V4L2_CID_HUE_AUTO: return "Hue, Automatic";
|
|
case V4L2_CID_WHITE_BALANCE_TEMPERATURE: return "White Balance Temperature";
|
|
case V4L2_CID_SHARPNESS: return "Sharpness";
|
|
case V4L2_CID_BACKLIGHT_COMPENSATION: return "Backlight Compensation";
|
|
case V4L2_CID_CHROMA_AGC: return "Chroma AGC";
|
|
case V4L2_CID_COLOR_KILLER: return "Color Killer";
|
|
case V4L2_CID_COLORFX: return "Color Effects";
|
|
case V4L2_CID_AUTOBRIGHTNESS: return "Brightness, Automatic";
|
|
case V4L2_CID_BAND_STOP_FILTER: return "Band-Stop Filter";
|
|
case V4L2_CID_ROTATE: return "Rotate";
|
|
case V4L2_CID_BG_COLOR: return "Background Color";
|
|
case V4L2_CID_CHROMA_GAIN: return "Chroma Gain";
|
|
case V4L2_CID_ILLUMINATORS_1: return "Illuminator 1";
|
|
case V4L2_CID_ILLUMINATORS_2: return "Illuminator 2";
|
|
case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE: return "Min Number of Capture Buffers";
|
|
case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT: return "Min Number of Output Buffers";
|
|
case V4L2_CID_ALPHA_COMPONENT: return "Alpha Component";
|
|
case V4L2_CID_COLORFX_CBCR: return "Color Effects, CbCr";
|
|
case V4L2_CID_COLORFX_RGB: return "Color Effects, RGB";
|
|
|
|
/*
|
|
* Codec controls
|
|
*
|
|
* The MPEG controls are applicable to all codec controls
|
|
* and the 'MPEG' part of the define is historical.
|
|
*
|
|
* Keep the order of the 'case's the same as in videodev2.h!
|
|
*/
|
|
case V4L2_CID_CODEC_CLASS: return "Codec Controls";
|
|
case V4L2_CID_MPEG_STREAM_TYPE: return "Stream Type";
|
|
case V4L2_CID_MPEG_STREAM_PID_PMT: return "Stream PMT Program ID";
|
|
case V4L2_CID_MPEG_STREAM_PID_AUDIO: return "Stream Audio Program ID";
|
|
case V4L2_CID_MPEG_STREAM_PID_VIDEO: return "Stream Video Program ID";
|
|
case V4L2_CID_MPEG_STREAM_PID_PCR: return "Stream PCR Program ID";
|
|
case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: return "Stream PES Audio ID";
|
|
case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: return "Stream PES Video ID";
|
|
case V4L2_CID_MPEG_STREAM_VBI_FMT: return "Stream VBI Format";
|
|
case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: return "Audio Sampling Frequency";
|
|
case V4L2_CID_MPEG_AUDIO_ENCODING: return "Audio Encoding";
|
|
case V4L2_CID_MPEG_AUDIO_L1_BITRATE: return "Audio Layer I Bitrate";
|
|
case V4L2_CID_MPEG_AUDIO_L2_BITRATE: return "Audio Layer II Bitrate";
|
|
case V4L2_CID_MPEG_AUDIO_L3_BITRATE: return "Audio Layer III Bitrate";
|
|
case V4L2_CID_MPEG_AUDIO_MODE: return "Audio Stereo Mode";
|
|
case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: return "Audio Stereo Mode Extension";
|
|
case V4L2_CID_MPEG_AUDIO_EMPHASIS: return "Audio Emphasis";
|
|
case V4L2_CID_MPEG_AUDIO_CRC: return "Audio CRC";
|
|
case V4L2_CID_MPEG_AUDIO_MUTE: return "Audio Mute";
|
|
case V4L2_CID_MPEG_AUDIO_AAC_BITRATE: return "Audio AAC Bitrate";
|
|
case V4L2_CID_MPEG_AUDIO_AC3_BITRATE: return "Audio AC-3 Bitrate";
|
|
case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK: return "Audio Playback";
|
|
case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK: return "Audio Multilingual Playback";
|
|
case V4L2_CID_MPEG_VIDEO_ENCODING: return "Video Encoding";
|
|
case V4L2_CID_MPEG_VIDEO_ASPECT: return "Video Aspect";
|
|
case V4L2_CID_MPEG_VIDEO_B_FRAMES: return "Video B Frames";
|
|
case V4L2_CID_MPEG_VIDEO_GOP_SIZE: return "Video GOP Size";
|
|
case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE: return "Video GOP Closure";
|
|
case V4L2_CID_MPEG_VIDEO_PULLDOWN: return "Video Pulldown";
|
|
case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: return "Video Bitrate Mode";
|
|
case V4L2_CID_MPEG_VIDEO_CONSTANT_QUALITY: return "Constant Quality";
|
|
case V4L2_CID_MPEG_VIDEO_BITRATE: return "Video Bitrate";
|
|
case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK: return "Video Peak Bitrate";
|
|
case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: return "Video Temporal Decimation";
|
|
case V4L2_CID_MPEG_VIDEO_MUTE: return "Video Mute";
|
|
case V4L2_CID_MPEG_VIDEO_MUTE_YUV: return "Video Mute YUV";
|
|
case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE: return "Decoder Slice Interface";
|
|
case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER: return "MPEG4 Loop Filter Enable";
|
|
case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB: return "Number of Intra Refresh MBs";
|
|
case V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD_TYPE: return "Intra Refresh Period Type";
|
|
case V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD: return "Intra Refresh Period";
|
|
case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE: return "Frame Level Rate Control Enable";
|
|
case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE: return "H264 MB Level Rate Control";
|
|
case V4L2_CID_MPEG_VIDEO_HEADER_MODE: return "Sequence Header Mode";
|
|
case V4L2_CID_MPEG_VIDEO_MAX_REF_PIC: return "Max Number of Reference Pics";
|
|
case V4L2_CID_MPEG_VIDEO_FRAME_SKIP_MODE: return "Frame Skip Mode";
|
|
case V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY: return "Display Delay";
|
|
case V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE: return "Display Delay Enable";
|
|
case V4L2_CID_MPEG_VIDEO_AU_DELIMITER: return "Generate Access Unit Delimiters";
|
|
case V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP: return "H263 I-Frame QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP: return "H263 P-Frame QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP: return "H263 B-Frame QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_H263_MIN_QP: return "H263 Minimum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_H263_MAX_QP: return "H263 Maximum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP: return "H264 I-Frame QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP: return "H264 P-Frame QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP: return "H264 B-Frame QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_H264_MAX_QP: return "H264 Maximum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_H264_MIN_QP: return "H264 Minimum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM: return "H264 8x8 Transform Enable";
|
|
case V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE: return "H264 CPB Buffer Size";
|
|
case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE: return "H264 Entropy Mode";
|
|
case V4L2_CID_MPEG_VIDEO_H264_I_PERIOD: return "H264 I-Frame Period";
|
|
case V4L2_CID_MPEG_VIDEO_H264_LEVEL: return "H264 Level";
|
|
case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA: return "H264 Loop Filter Alpha Offset";
|
|
case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA: return "H264 Loop Filter Beta Offset";
|
|
case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE: return "H264 Loop Filter Mode";
|
|
case V4L2_CID_MPEG_VIDEO_H264_PROFILE: return "H264 Profile";
|
|
case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT: return "Vertical Size of SAR";
|
|
case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH: return "Horizontal Size of SAR";
|
|
case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE: return "Aspect Ratio VUI Enable";
|
|
case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC: return "VUI Aspect Ratio IDC";
|
|
case V4L2_CID_MPEG_VIDEO_H264_SEI_FRAME_PACKING: return "H264 Enable Frame Packing SEI";
|
|
case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_CURRENT_FRAME_0: return "H264 Set Curr. Frame as Frame0";
|
|
case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE: return "H264 FP Arrangement Type";
|
|
case V4L2_CID_MPEG_VIDEO_H264_FMO: return "H264 Flexible MB Ordering";
|
|
case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE: return "H264 Map Type for FMO";
|
|
case V4L2_CID_MPEG_VIDEO_H264_FMO_SLICE_GROUP: return "H264 FMO Number of Slice Groups";
|
|
case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_DIRECTION: return "H264 FMO Direction of Change";
|
|
case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_RATE: return "H264 FMO Size of 1st Slice Grp";
|
|
case V4L2_CID_MPEG_VIDEO_H264_FMO_RUN_LENGTH: return "H264 FMO No. of Consecutive MBs";
|
|
case V4L2_CID_MPEG_VIDEO_H264_ASO: return "H264 Arbitrary Slice Ordering";
|
|
case V4L2_CID_MPEG_VIDEO_H264_ASO_SLICE_ORDER: return "H264 ASO Slice Order";
|
|
case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING: return "Enable H264 Hierarchical Coding";
|
|
case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE: return "H264 Hierarchical Coding Type";
|
|
case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER:return "H264 Number of HC Layers";
|
|
case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER_QP:
|
|
return "H264 Set QP Value for HC Layers";
|
|
case V4L2_CID_MPEG_VIDEO_H264_CONSTRAINED_INTRA_PREDICTION:
|
|
return "H264 Constrained Intra Pred";
|
|
case V4L2_CID_MPEG_VIDEO_H264_CHROMA_QP_INDEX_OFFSET: return "H264 Chroma QP Index Offset";
|
|
case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MIN_QP: return "H264 I-Frame Minimum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MAX_QP: return "H264 I-Frame Maximum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MIN_QP: return "H264 P-Frame Minimum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MAX_QP: return "H264 P-Frame Maximum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_MIN_QP: return "H264 B-Frame Minimum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_MAX_QP: return "H264 B-Frame Maximum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L0_BR: return "H264 Hierarchical Lay 0 Bitrate";
|
|
case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L1_BR: return "H264 Hierarchical Lay 1 Bitrate";
|
|
case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L2_BR: return "H264 Hierarchical Lay 2 Bitrate";
|
|
case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L3_BR: return "H264 Hierarchical Lay 3 Bitrate";
|
|
case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L4_BR: return "H264 Hierarchical Lay 4 Bitrate";
|
|
case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L5_BR: return "H264 Hierarchical Lay 5 Bitrate";
|
|
case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L6_BR: return "H264 Hierarchical Lay 6 Bitrate";
|
|
case V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL: return "MPEG2 Level";
|
|
case V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE: return "MPEG2 Profile";
|
|
case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP: return "MPEG4 I-Frame QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP: return "MPEG4 P-Frame QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP: return "MPEG4 B-Frame QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP: return "MPEG4 Minimum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP: return "MPEG4 Maximum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL: return "MPEG4 Level";
|
|
case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE: return "MPEG4 Profile";
|
|
case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL: return "Quarter Pixel Search Enable";
|
|
case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES: return "Maximum Bytes in a Slice";
|
|
case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB: return "Number of MBs in a Slice";
|
|
case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE: return "Slice Partitioning Method";
|
|
case V4L2_CID_MPEG_VIDEO_VBV_SIZE: return "VBV Buffer Size";
|
|
case V4L2_CID_MPEG_VIDEO_DEC_PTS: return "Video Decoder PTS";
|
|
case V4L2_CID_MPEG_VIDEO_DEC_FRAME: return "Video Decoder Frame Count";
|
|
case V4L2_CID_MPEG_VIDEO_DEC_CONCEAL_COLOR: return "Video Decoder Conceal Color";
|
|
case V4L2_CID_MPEG_VIDEO_VBV_DELAY: return "Initial Delay for VBV Control";
|
|
case V4L2_CID_MPEG_VIDEO_MV_H_SEARCH_RANGE: return "Horizontal MV Search Range";
|
|
case V4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGE: return "Vertical MV Search Range";
|
|
case V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER: return "Repeat Sequence Header";
|
|
case V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME: return "Force Key Frame";
|
|
case V4L2_CID_MPEG_VIDEO_BASELAYER_PRIORITY_ID: return "Base Layer Priority ID";
|
|
case V4L2_CID_MPEG_VIDEO_LTR_COUNT: return "LTR Count";
|
|
case V4L2_CID_MPEG_VIDEO_FRAME_LTR_INDEX: return "Frame LTR Index";
|
|
case V4L2_CID_MPEG_VIDEO_USE_LTR_FRAMES: return "Use LTR Frames";
|
|
case V4L2_CID_FWHT_I_FRAME_QP: return "FWHT I-Frame QP Value";
|
|
case V4L2_CID_FWHT_P_FRAME_QP: return "FWHT P-Frame QP Value";
|
|
|
|
/* VPX controls */
|
|
case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS: return "VPX Number of Partitions";
|
|
case V4L2_CID_MPEG_VIDEO_VPX_IMD_DISABLE_4X4: return "VPX Intra Mode Decision Disable";
|
|
case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES: return "VPX No. of Refs for P Frame";
|
|
case V4L2_CID_MPEG_VIDEO_VPX_FILTER_LEVEL: return "VPX Loop Filter Level Range";
|
|
case V4L2_CID_MPEG_VIDEO_VPX_FILTER_SHARPNESS: return "VPX Deblocking Effect Control";
|
|
case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_REF_PERIOD: return "VPX Golden Frame Refresh Period";
|
|
case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL: return "VPX Golden Frame Indicator";
|
|
case V4L2_CID_MPEG_VIDEO_VPX_MIN_QP: return "VPX Minimum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_VPX_MAX_QP: return "VPX Maximum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_VPX_I_FRAME_QP: return "VPX I-Frame QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_VPX_P_FRAME_QP: return "VPX P-Frame QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_VP8_PROFILE: return "VP8 Profile";
|
|
case V4L2_CID_MPEG_VIDEO_VP9_PROFILE: return "VP9 Profile";
|
|
case V4L2_CID_MPEG_VIDEO_VP9_LEVEL: return "VP9 Level";
|
|
|
|
/* HEVC controls */
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_QP: return "HEVC I-Frame QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_QP: return "HEVC P-Frame QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_QP: return "HEVC B-Frame QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_MIN_QP: return "HEVC Minimum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_MAX_QP: return "HEVC Maximum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_MIN_QP: return "HEVC I-Frame Minimum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_MAX_QP: return "HEVC I-Frame Maximum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_MIN_QP: return "HEVC P-Frame Minimum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_MAX_QP: return "HEVC P-Frame Maximum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_MIN_QP: return "HEVC B-Frame Minimum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_MAX_QP: return "HEVC B-Frame Maximum QP Value";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE: return "HEVC Profile";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL: return "HEVC Level";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_TIER: return "HEVC Tier";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_FRAME_RATE_RESOLUTION: return "HEVC Frame Rate Resolution";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_MAX_PARTITION_DEPTH: return "HEVC Maximum Coding Unit Depth";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_TYPE: return "HEVC Refresh Type";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_CONST_INTRA_PRED: return "HEVC Constant Intra Prediction";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_LOSSLESS_CU: return "HEVC Lossless Encoding";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_WAVEFRONT: return "HEVC Wavefront";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE: return "HEVC Loop Filter";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_HIER_QP: return "HEVC QP Values";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_TYPE: return "HEVC Hierarchical Coding Type";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_LAYER: return "HEVC Hierarchical Coding Layer";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L0_QP: return "HEVC Hierarchical Layer 0 QP";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L1_QP: return "HEVC Hierarchical Layer 1 QP";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L2_QP: return "HEVC Hierarchical Layer 2 QP";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L3_QP: return "HEVC Hierarchical Layer 3 QP";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L4_QP: return "HEVC Hierarchical Layer 4 QP";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L5_QP: return "HEVC Hierarchical Layer 5 QP";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L6_QP: return "HEVC Hierarchical Layer 6 QP";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L0_BR: return "HEVC Hierarchical Lay 0 BitRate";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L1_BR: return "HEVC Hierarchical Lay 1 BitRate";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L2_BR: return "HEVC Hierarchical Lay 2 BitRate";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L3_BR: return "HEVC Hierarchical Lay 3 BitRate";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L4_BR: return "HEVC Hierarchical Lay 4 BitRate";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L5_BR: return "HEVC Hierarchical Lay 5 BitRate";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L6_BR: return "HEVC Hierarchical Lay 6 BitRate";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_GENERAL_PB: return "HEVC General PB";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_TEMPORAL_ID: return "HEVC Temporal ID";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_STRONG_SMOOTHING: return "HEVC Strong Intra Smoothing";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_INTRA_PU_SPLIT: return "HEVC Intra PU Split";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_TMV_PREDICTION: return "HEVC TMV Prediction";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_MAX_NUM_MERGE_MV_MINUS1: return "HEVC Max Num of Candidate MVs";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_WITHOUT_STARTCODE: return "HEVC ENC Without Startcode";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_PERIOD: return "HEVC Num of I-Frame b/w 2 IDR";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_LF_BETA_OFFSET_DIV2: return "HEVC Loop Filter Beta Offset";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_LF_TC_OFFSET_DIV2: return "HEVC Loop Filter TC Offset";
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_SIZE_OF_LENGTH_FIELD: return "HEVC Size of Length Field";
|
|
case V4L2_CID_MPEG_VIDEO_REF_NUMBER_FOR_PFRAMES: return "Reference Frames for a P-Frame";
|
|
case V4L2_CID_MPEG_VIDEO_PREPEND_SPSPPS_TO_IDR: return "Prepend SPS and PPS to IDR";
|
|
|
|
/* CAMERA controls */
|
|
/* Keep the order of the 'case's the same as in v4l2-controls.h! */
|
|
case V4L2_CID_CAMERA_CLASS: return "Camera Controls";
|
|
case V4L2_CID_EXPOSURE_AUTO: return "Auto Exposure";
|
|
case V4L2_CID_EXPOSURE_ABSOLUTE: return "Exposure Time, Absolute";
|
|
case V4L2_CID_EXPOSURE_AUTO_PRIORITY: return "Exposure, Dynamic Framerate";
|
|
case V4L2_CID_PAN_RELATIVE: return "Pan, Relative";
|
|
case V4L2_CID_TILT_RELATIVE: return "Tilt, Relative";
|
|
case V4L2_CID_PAN_RESET: return "Pan, Reset";
|
|
case V4L2_CID_TILT_RESET: return "Tilt, Reset";
|
|
case V4L2_CID_PAN_ABSOLUTE: return "Pan, Absolute";
|
|
case V4L2_CID_TILT_ABSOLUTE: return "Tilt, Absolute";
|
|
case V4L2_CID_FOCUS_ABSOLUTE: return "Focus, Absolute";
|
|
case V4L2_CID_FOCUS_RELATIVE: return "Focus, Relative";
|
|
case V4L2_CID_FOCUS_AUTO: return "Focus, Automatic Continuous";
|
|
case V4L2_CID_ZOOM_ABSOLUTE: return "Zoom, Absolute";
|
|
case V4L2_CID_ZOOM_RELATIVE: return "Zoom, Relative";
|
|
case V4L2_CID_ZOOM_CONTINUOUS: return "Zoom, Continuous";
|
|
case V4L2_CID_PRIVACY: return "Privacy";
|
|
case V4L2_CID_IRIS_ABSOLUTE: return "Iris, Absolute";
|
|
case V4L2_CID_IRIS_RELATIVE: return "Iris, Relative";
|
|
case V4L2_CID_AUTO_EXPOSURE_BIAS: return "Auto Exposure, Bias";
|
|
case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE: return "White Balance, Auto & Preset";
|
|
case V4L2_CID_WIDE_DYNAMIC_RANGE: return "Wide Dynamic Range";
|
|
case V4L2_CID_IMAGE_STABILIZATION: return "Image Stabilization";
|
|
case V4L2_CID_ISO_SENSITIVITY: return "ISO Sensitivity";
|
|
case V4L2_CID_ISO_SENSITIVITY_AUTO: return "ISO Sensitivity, Auto";
|
|
case V4L2_CID_EXPOSURE_METERING: return "Exposure, Metering Mode";
|
|
case V4L2_CID_SCENE_MODE: return "Scene Mode";
|
|
case V4L2_CID_3A_LOCK: return "3A Lock";
|
|
case V4L2_CID_AUTO_FOCUS_START: return "Auto Focus, Start";
|
|
case V4L2_CID_AUTO_FOCUS_STOP: return "Auto Focus, Stop";
|
|
case V4L2_CID_AUTO_FOCUS_STATUS: return "Auto Focus, Status";
|
|
case V4L2_CID_AUTO_FOCUS_RANGE: return "Auto Focus, Range";
|
|
case V4L2_CID_PAN_SPEED: return "Pan, Speed";
|
|
case V4L2_CID_TILT_SPEED: return "Tilt, Speed";
|
|
case V4L2_CID_UNIT_CELL_SIZE: return "Unit Cell Size";
|
|
case V4L2_CID_CAMERA_ORIENTATION: return "Camera Orientation";
|
|
case V4L2_CID_CAMERA_SENSOR_ROTATION: return "Camera Sensor Rotation";
|
|
case V4L2_CID_HDR_SENSOR_MODE: return "HDR Sensor Mode";
|
|
|
|
/* FM Radio Modulator controls */
|
|
/* Keep the order of the 'case's the same as in v4l2-controls.h! */
|
|
case V4L2_CID_FM_TX_CLASS: return "FM Radio Modulator Controls";
|
|
case V4L2_CID_RDS_TX_DEVIATION: return "RDS Signal Deviation";
|
|
case V4L2_CID_RDS_TX_PI: return "RDS Program ID";
|
|
case V4L2_CID_RDS_TX_PTY: return "RDS Program Type";
|
|
case V4L2_CID_RDS_TX_PS_NAME: return "RDS PS Name";
|
|
case V4L2_CID_RDS_TX_RADIO_TEXT: return "RDS Radio Text";
|
|
case V4L2_CID_RDS_TX_MONO_STEREO: return "RDS Stereo";
|
|
case V4L2_CID_RDS_TX_ARTIFICIAL_HEAD: return "RDS Artificial Head";
|
|
case V4L2_CID_RDS_TX_COMPRESSED: return "RDS Compressed";
|
|
case V4L2_CID_RDS_TX_DYNAMIC_PTY: return "RDS Dynamic PTY";
|
|
case V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT: return "RDS Traffic Announcement";
|
|
case V4L2_CID_RDS_TX_TRAFFIC_PROGRAM: return "RDS Traffic Program";
|
|
case V4L2_CID_RDS_TX_MUSIC_SPEECH: return "RDS Music";
|
|
case V4L2_CID_RDS_TX_ALT_FREQS_ENABLE: return "RDS Enable Alt Frequencies";
|
|
case V4L2_CID_RDS_TX_ALT_FREQS: return "RDS Alternate Frequencies";
|
|
case V4L2_CID_AUDIO_LIMITER_ENABLED: return "Audio Limiter Feature Enabled";
|
|
case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME: return "Audio Limiter Release Time";
|
|
case V4L2_CID_AUDIO_LIMITER_DEVIATION: return "Audio Limiter Deviation";
|
|
case V4L2_CID_AUDIO_COMPRESSION_ENABLED: return "Audio Compression Enabled";
|
|
case V4L2_CID_AUDIO_COMPRESSION_GAIN: return "Audio Compression Gain";
|
|
case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD: return "Audio Compression Threshold";
|
|
case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME: return "Audio Compression Attack Time";
|
|
case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME: return "Audio Compression Release Time";
|
|
case V4L2_CID_PILOT_TONE_ENABLED: return "Pilot Tone Feature Enabled";
|
|
case V4L2_CID_PILOT_TONE_DEVIATION: return "Pilot Tone Deviation";
|
|
case V4L2_CID_PILOT_TONE_FREQUENCY: return "Pilot Tone Frequency";
|
|
case V4L2_CID_TUNE_PREEMPHASIS: return "Pre-Emphasis";
|
|
case V4L2_CID_TUNE_POWER_LEVEL: return "Tune Power Level";
|
|
case V4L2_CID_TUNE_ANTENNA_CAPACITOR: return "Tune Antenna Capacitor";
|
|
|
|
/* Flash controls */
|
|
/* Keep the order of the 'case's the same as in v4l2-controls.h! */
|
|
case V4L2_CID_FLASH_CLASS: return "Flash Controls";
|
|
case V4L2_CID_FLASH_LED_MODE: return "LED Mode";
|
|
case V4L2_CID_FLASH_STROBE_SOURCE: return "Strobe Source";
|
|
case V4L2_CID_FLASH_STROBE: return "Strobe";
|
|
case V4L2_CID_FLASH_STROBE_STOP: return "Stop Strobe";
|
|
case V4L2_CID_FLASH_STROBE_STATUS: return "Strobe Status";
|
|
case V4L2_CID_FLASH_TIMEOUT: return "Strobe Timeout";
|
|
case V4L2_CID_FLASH_INTENSITY: return "Intensity, Flash Mode";
|
|
case V4L2_CID_FLASH_TORCH_INTENSITY: return "Intensity, Torch Mode";
|
|
case V4L2_CID_FLASH_INDICATOR_INTENSITY: return "Intensity, Indicator";
|
|
case V4L2_CID_FLASH_FAULT: return "Faults";
|
|
case V4L2_CID_FLASH_CHARGE: return "Charge";
|
|
case V4L2_CID_FLASH_READY: return "Ready to Strobe";
|
|
|
|
/* JPEG encoder controls */
|
|
/* Keep the order of the 'case's the same as in v4l2-controls.h! */
|
|
case V4L2_CID_JPEG_CLASS: return "JPEG Compression Controls";
|
|
case V4L2_CID_JPEG_CHROMA_SUBSAMPLING: return "Chroma Subsampling";
|
|
case V4L2_CID_JPEG_RESTART_INTERVAL: return "Restart Interval";
|
|
case V4L2_CID_JPEG_COMPRESSION_QUALITY: return "Compression Quality";
|
|
case V4L2_CID_JPEG_ACTIVE_MARKER: return "Active Markers";
|
|
|
|
/* Image source controls */
|
|
/* Keep the order of the 'case's the same as in v4l2-controls.h! */
|
|
case V4L2_CID_IMAGE_SOURCE_CLASS: return "Image Source Controls";
|
|
case V4L2_CID_VBLANK: return "Vertical Blanking";
|
|
case V4L2_CID_HBLANK: return "Horizontal Blanking";
|
|
case V4L2_CID_ANALOGUE_GAIN: return "Analogue Gain";
|
|
case V4L2_CID_TEST_PATTERN_RED: return "Red Pixel Value";
|
|
case V4L2_CID_TEST_PATTERN_GREENR: return "Green (Red) Pixel Value";
|
|
case V4L2_CID_TEST_PATTERN_BLUE: return "Blue Pixel Value";
|
|
case V4L2_CID_TEST_PATTERN_GREENB: return "Green (Blue) Pixel Value";
|
|
case V4L2_CID_NOTIFY_GAINS: return "Notify Gains";
|
|
|
|
/* Image processing controls */
|
|
/* Keep the order of the 'case's the same as in v4l2-controls.h! */
|
|
case V4L2_CID_IMAGE_PROC_CLASS: return "Image Processing Controls";
|
|
case V4L2_CID_LINK_FREQ: return "Link Frequency";
|
|
case V4L2_CID_PIXEL_RATE: return "Pixel Rate";
|
|
case V4L2_CID_TEST_PATTERN: return "Test Pattern";
|
|
case V4L2_CID_DEINTERLACING_MODE: return "Deinterlacing Mode";
|
|
case V4L2_CID_DIGITAL_GAIN: return "Digital Gain";
|
|
|
|
/* DV controls */
|
|
/* Keep the order of the 'case's the same as in v4l2-controls.h! */
|
|
case V4L2_CID_DV_CLASS: return "Digital Video Controls";
|
|
case V4L2_CID_DV_TX_HOTPLUG: return "Hotplug Present";
|
|
case V4L2_CID_DV_TX_RXSENSE: return "RxSense Present";
|
|
case V4L2_CID_DV_TX_EDID_PRESENT: return "EDID Present";
|
|
case V4L2_CID_DV_TX_MODE: return "Transmit Mode";
|
|
case V4L2_CID_DV_TX_RGB_RANGE: return "Tx RGB Quantization Range";
|
|
case V4L2_CID_DV_TX_IT_CONTENT_TYPE: return "Tx IT Content Type";
|
|
case V4L2_CID_DV_RX_POWER_PRESENT: return "Power Present";
|
|
case V4L2_CID_DV_RX_RGB_RANGE: return "Rx RGB Quantization Range";
|
|
case V4L2_CID_DV_RX_IT_CONTENT_TYPE: return "Rx IT Content Type";
|
|
|
|
case V4L2_CID_FM_RX_CLASS: return "FM Radio Receiver Controls";
|
|
case V4L2_CID_TUNE_DEEMPHASIS: return "De-Emphasis";
|
|
case V4L2_CID_RDS_RECEPTION: return "RDS Reception";
|
|
case V4L2_CID_RF_TUNER_CLASS: return "RF Tuner Controls";
|
|
case V4L2_CID_RF_TUNER_RF_GAIN: return "RF Gain";
|
|
case V4L2_CID_RF_TUNER_LNA_GAIN_AUTO: return "LNA Gain, Auto";
|
|
case V4L2_CID_RF_TUNER_LNA_GAIN: return "LNA Gain";
|
|
case V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO: return "Mixer Gain, Auto";
|
|
case V4L2_CID_RF_TUNER_MIXER_GAIN: return "Mixer Gain";
|
|
case V4L2_CID_RF_TUNER_IF_GAIN_AUTO: return "IF Gain, Auto";
|
|
case V4L2_CID_RF_TUNER_IF_GAIN: return "IF Gain";
|
|
case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO: return "Bandwidth, Auto";
|
|
case V4L2_CID_RF_TUNER_BANDWIDTH: return "Bandwidth";
|
|
case V4L2_CID_RF_TUNER_PLL_LOCK: return "PLL Lock";
|
|
case V4L2_CID_RDS_RX_PTY: return "RDS Program Type";
|
|
case V4L2_CID_RDS_RX_PS_NAME: return "RDS PS Name";
|
|
case V4L2_CID_RDS_RX_RADIO_TEXT: return "RDS Radio Text";
|
|
case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT: return "RDS Traffic Announcement";
|
|
case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM: return "RDS Traffic Program";
|
|
case V4L2_CID_RDS_RX_MUSIC_SPEECH: return "RDS Music";
|
|
|
|
/* Detection controls */
|
|
/* Keep the order of the 'case's the same as in v4l2-controls.h! */
|
|
case V4L2_CID_DETECT_CLASS: return "Detection Controls";
|
|
case V4L2_CID_DETECT_MD_MODE: return "Motion Detection Mode";
|
|
case V4L2_CID_DETECT_MD_GLOBAL_THRESHOLD: return "MD Global Threshold";
|
|
case V4L2_CID_DETECT_MD_THRESHOLD_GRID: return "MD Threshold Grid";
|
|
case V4L2_CID_DETECT_MD_REGION_GRID: return "MD Region Grid";
|
|
|
|
/* Stateless Codec controls */
|
|
/* Keep the order of the 'case's the same as in v4l2-controls.h! */
|
|
case V4L2_CID_CODEC_STATELESS_CLASS: return "Stateless Codec Controls";
|
|
case V4L2_CID_STATELESS_H264_DECODE_MODE: return "H264 Decode Mode";
|
|
case V4L2_CID_STATELESS_H264_START_CODE: return "H264 Start Code";
|
|
case V4L2_CID_STATELESS_H264_SPS: return "H264 Sequence Parameter Set";
|
|
case V4L2_CID_STATELESS_H264_PPS: return "H264 Picture Parameter Set";
|
|
case V4L2_CID_STATELESS_H264_SCALING_MATRIX: return "H264 Scaling Matrix";
|
|
case V4L2_CID_STATELESS_H264_PRED_WEIGHTS: return "H264 Prediction Weight Table";
|
|
case V4L2_CID_STATELESS_H264_SLICE_PARAMS: return "H264 Slice Parameters";
|
|
case V4L2_CID_STATELESS_H264_DECODE_PARAMS: return "H264 Decode Parameters";
|
|
case V4L2_CID_STATELESS_FWHT_PARAMS: return "FWHT Stateless Parameters";
|
|
case V4L2_CID_STATELESS_VP8_FRAME: return "VP8 Frame Parameters";
|
|
case V4L2_CID_STATELESS_MPEG2_SEQUENCE: return "MPEG-2 Sequence Header";
|
|
case V4L2_CID_STATELESS_MPEG2_PICTURE: return "MPEG-2 Picture Header";
|
|
case V4L2_CID_STATELESS_MPEG2_QUANTISATION: return "MPEG-2 Quantisation Matrices";
|
|
case V4L2_CID_STATELESS_VP9_COMPRESSED_HDR: return "VP9 Probabilities Updates";
|
|
case V4L2_CID_STATELESS_VP9_FRAME: return "VP9 Frame Decode Parameters";
|
|
case V4L2_CID_STATELESS_HEVC_SPS: return "HEVC Sequence Parameter Set";
|
|
case V4L2_CID_STATELESS_HEVC_PPS: return "HEVC Picture Parameter Set";
|
|
case V4L2_CID_STATELESS_HEVC_SLICE_PARAMS: return "HEVC Slice Parameters";
|
|
case V4L2_CID_STATELESS_HEVC_SCALING_MATRIX: return "HEVC Scaling Matrix";
|
|
case V4L2_CID_STATELESS_HEVC_DECODE_PARAMS: return "HEVC Decode Parameters";
|
|
case V4L2_CID_STATELESS_HEVC_DECODE_MODE: return "HEVC Decode Mode";
|
|
case V4L2_CID_STATELESS_HEVC_START_CODE: return "HEVC Start Code";
|
|
case V4L2_CID_STATELESS_HEVC_ENTRY_POINT_OFFSETS: return "HEVC Entry Point Offsets";
|
|
|
|
/* Colorimetry controls */
|
|
/* Keep the order of the 'case's the same as in v4l2-controls.h! */
|
|
case V4L2_CID_COLORIMETRY_CLASS: return "Colorimetry Controls";
|
|
case V4L2_CID_COLORIMETRY_HDR10_CLL_INFO: return "HDR10 Content Light Info";
|
|
case V4L2_CID_COLORIMETRY_HDR10_MASTERING_DISPLAY: return "HDR10 Mastering Display";
|
|
default:
|
|
return NULL;
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(v4l2_ctrl_get_name);
|
|
|
|
void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type,
|
|
s64 *min, s64 *max, u64 *step, s64 *def, u32 *flags)
|
|
{
|
|
*name = v4l2_ctrl_get_name(id);
|
|
*flags = 0;
|
|
|
|
switch (id) {
|
|
case V4L2_CID_AUDIO_MUTE:
|
|
case V4L2_CID_AUDIO_LOUDNESS:
|
|
case V4L2_CID_AUTO_WHITE_BALANCE:
|
|
case V4L2_CID_AUTOGAIN:
|
|
case V4L2_CID_HFLIP:
|
|
case V4L2_CID_VFLIP:
|
|
case V4L2_CID_HUE_AUTO:
|
|
case V4L2_CID_CHROMA_AGC:
|
|
case V4L2_CID_COLOR_KILLER:
|
|
case V4L2_CID_AUTOBRIGHTNESS:
|
|
case V4L2_CID_MPEG_AUDIO_MUTE:
|
|
case V4L2_CID_MPEG_VIDEO_MUTE:
|
|
case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
|
|
case V4L2_CID_MPEG_VIDEO_PULLDOWN:
|
|
case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
|
|
case V4L2_CID_FOCUS_AUTO:
|
|
case V4L2_CID_PRIVACY:
|
|
case V4L2_CID_AUDIO_LIMITER_ENABLED:
|
|
case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
|
|
case V4L2_CID_PILOT_TONE_ENABLED:
|
|
case V4L2_CID_ILLUMINATORS_1:
|
|
case V4L2_CID_ILLUMINATORS_2:
|
|
case V4L2_CID_FLASH_STROBE_STATUS:
|
|
case V4L2_CID_FLASH_CHARGE:
|
|
case V4L2_CID_FLASH_READY:
|
|
case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER:
|
|
case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE:
|
|
case V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE:
|
|
case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:
|
|
case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:
|
|
case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:
|
|
case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:
|
|
case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL:
|
|
case V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER:
|
|
case V4L2_CID_MPEG_VIDEO_AU_DELIMITER:
|
|
case V4L2_CID_WIDE_DYNAMIC_RANGE:
|
|
case V4L2_CID_IMAGE_STABILIZATION:
|
|
case V4L2_CID_RDS_RECEPTION:
|
|
case V4L2_CID_RF_TUNER_LNA_GAIN_AUTO:
|
|
case V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO:
|
|
case V4L2_CID_RF_TUNER_IF_GAIN_AUTO:
|
|
case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:
|
|
case V4L2_CID_RF_TUNER_PLL_LOCK:
|
|
case V4L2_CID_RDS_TX_MONO_STEREO:
|
|
case V4L2_CID_RDS_TX_ARTIFICIAL_HEAD:
|
|
case V4L2_CID_RDS_TX_COMPRESSED:
|
|
case V4L2_CID_RDS_TX_DYNAMIC_PTY:
|
|
case V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT:
|
|
case V4L2_CID_RDS_TX_TRAFFIC_PROGRAM:
|
|
case V4L2_CID_RDS_TX_MUSIC_SPEECH:
|
|
case V4L2_CID_RDS_TX_ALT_FREQS_ENABLE:
|
|
case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT:
|
|
case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM:
|
|
case V4L2_CID_RDS_RX_MUSIC_SPEECH:
|
|
*type = V4L2_CTRL_TYPE_BOOLEAN;
|
|
*min = 0;
|
|
*max = *step = 1;
|
|
break;
|
|
case V4L2_CID_ROTATE:
|
|
*type = V4L2_CTRL_TYPE_INTEGER;
|
|
*flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT;
|
|
break;
|
|
case V4L2_CID_MPEG_VIDEO_MV_H_SEARCH_RANGE:
|
|
case V4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGE:
|
|
case V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY:
|
|
case V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD:
|
|
*type = V4L2_CTRL_TYPE_INTEGER;
|
|
break;
|
|
case V4L2_CID_MPEG_VIDEO_LTR_COUNT:
|
|
*type = V4L2_CTRL_TYPE_INTEGER;
|
|
break;
|
|
case V4L2_CID_MPEG_VIDEO_FRAME_LTR_INDEX:
|
|
*type = V4L2_CTRL_TYPE_INTEGER;
|
|
*flags |= V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
|
|
break;
|
|
case V4L2_CID_MPEG_VIDEO_USE_LTR_FRAMES:
|
|
*type = V4L2_CTRL_TYPE_BITMASK;
|
|
*flags |= V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
|
|
break;
|
|
case V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME:
|
|
case V4L2_CID_PAN_RESET:
|
|
case V4L2_CID_TILT_RESET:
|
|
case V4L2_CID_FLASH_STROBE:
|
|
case V4L2_CID_FLASH_STROBE_STOP:
|
|
case V4L2_CID_AUTO_FOCUS_START:
|
|
case V4L2_CID_AUTO_FOCUS_STOP:
|
|
case V4L2_CID_DO_WHITE_BALANCE:
|
|
*type = V4L2_CTRL_TYPE_BUTTON;
|
|
*flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
|
|
V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
|
|
*min = *max = *step = *def = 0;
|
|
break;
|
|
case V4L2_CID_POWER_LINE_FREQUENCY:
|
|
case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
|
|
case V4L2_CID_MPEG_AUDIO_ENCODING:
|
|
case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
|
|
case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
|
|
case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
|
|
case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
|
|
case V4L2_CID_MPEG_AUDIO_MODE:
|
|
case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
|
|
case V4L2_CID_MPEG_AUDIO_EMPHASIS:
|
|
case V4L2_CID_MPEG_AUDIO_CRC:
|
|
case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
|
|
case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
|
|
case V4L2_CID_MPEG_VIDEO_ENCODING:
|
|
case V4L2_CID_MPEG_VIDEO_ASPECT:
|
|
case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
|
|
case V4L2_CID_MPEG_STREAM_TYPE:
|
|
case V4L2_CID_MPEG_STREAM_VBI_FMT:
|
|
case V4L2_CID_EXPOSURE_AUTO:
|
|
case V4L2_CID_AUTO_FOCUS_RANGE:
|
|
case V4L2_CID_COLORFX:
|
|
case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
|
|
case V4L2_CID_TUNE_PREEMPHASIS:
|
|
case V4L2_CID_FLASH_LED_MODE:
|
|
case V4L2_CID_FLASH_STROBE_SOURCE:
|
|
case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
|
|
case V4L2_CID_MPEG_VIDEO_FRAME_SKIP_MODE:
|
|
case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
|
|
case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
|
|
case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
|
|
case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
|
|
case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
|
|
case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
|
|
case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
|
|
case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
|
|
case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE:
|
|
case V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL:
|
|
case V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE:
|
|
case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
|
|
case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
|
|
case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
|
|
case V4L2_CID_ISO_SENSITIVITY_AUTO:
|
|
case V4L2_CID_EXPOSURE_METERING:
|
|
case V4L2_CID_SCENE_MODE:
|
|
case V4L2_CID_DV_TX_MODE:
|
|
case V4L2_CID_DV_TX_RGB_RANGE:
|
|
case V4L2_CID_DV_TX_IT_CONTENT_TYPE:
|
|
case V4L2_CID_DV_RX_RGB_RANGE:
|
|
case V4L2_CID_DV_RX_IT_CONTENT_TYPE:
|
|
case V4L2_CID_TEST_PATTERN:
|
|
case V4L2_CID_DEINTERLACING_MODE:
|
|
case V4L2_CID_TUNE_DEEMPHASIS:
|
|
case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:
|
|
case V4L2_CID_MPEG_VIDEO_VP8_PROFILE:
|
|
case V4L2_CID_MPEG_VIDEO_VP9_PROFILE:
|
|
case V4L2_CID_MPEG_VIDEO_VP9_LEVEL:
|
|
case V4L2_CID_DETECT_MD_MODE:
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE:
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL:
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_TYPE:
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_TYPE:
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_SIZE_OF_LENGTH_FIELD:
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_TIER:
|
|
case V4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE:
|
|
case V4L2_CID_STATELESS_HEVC_DECODE_MODE:
|
|
case V4L2_CID_STATELESS_HEVC_START_CODE:
|
|
case V4L2_CID_STATELESS_H264_DECODE_MODE:
|
|
case V4L2_CID_STATELESS_H264_START_CODE:
|
|
case V4L2_CID_CAMERA_ORIENTATION:
|
|
case V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD_TYPE:
|
|
case V4L2_CID_HDR_SENSOR_MODE:
|
|
*type = V4L2_CTRL_TYPE_MENU;
|
|
break;
|
|
case V4L2_CID_LINK_FREQ:
|
|
*type = V4L2_CTRL_TYPE_INTEGER_MENU;
|
|
break;
|
|
case V4L2_CID_RDS_TX_PS_NAME:
|
|
case V4L2_CID_RDS_TX_RADIO_TEXT:
|
|
case V4L2_CID_RDS_RX_PS_NAME:
|
|
case V4L2_CID_RDS_RX_RADIO_TEXT:
|
|
*type = V4L2_CTRL_TYPE_STRING;
|
|
break;
|
|
case V4L2_CID_ISO_SENSITIVITY:
|
|
case V4L2_CID_AUTO_EXPOSURE_BIAS:
|
|
case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:
|
|
case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:
|
|
*type = V4L2_CTRL_TYPE_INTEGER_MENU;
|
|
break;
|
|
case V4L2_CID_USER_CLASS:
|
|
case V4L2_CID_CAMERA_CLASS:
|
|
case V4L2_CID_CODEC_CLASS:
|
|
case V4L2_CID_FM_TX_CLASS:
|
|
case V4L2_CID_FLASH_CLASS:
|
|
case V4L2_CID_JPEG_CLASS:
|
|
case V4L2_CID_IMAGE_SOURCE_CLASS:
|
|
case V4L2_CID_IMAGE_PROC_CLASS:
|
|
case V4L2_CID_DV_CLASS:
|
|
case V4L2_CID_FM_RX_CLASS:
|
|
case V4L2_CID_RF_TUNER_CLASS:
|
|
case V4L2_CID_DETECT_CLASS:
|
|
case V4L2_CID_CODEC_STATELESS_CLASS:
|
|
case V4L2_CID_COLORIMETRY_CLASS:
|
|
*type = V4L2_CTRL_TYPE_CTRL_CLASS;
|
|
/* You can neither read nor write these */
|
|
*flags |= V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_WRITE_ONLY;
|
|
*min = *max = *step = *def = 0;
|
|
break;
|
|
case V4L2_CID_BG_COLOR:
|
|
case V4L2_CID_COLORFX_RGB:
|
|
*type = V4L2_CTRL_TYPE_INTEGER;
|
|
*step = 1;
|
|
*min = 0;
|
|
/* Max is calculated as RGB888 that is 2^24 - 1 */
|
|
*max = 0xffffff;
|
|
break;
|
|
case V4L2_CID_COLORFX_CBCR:
|
|
*type = V4L2_CTRL_TYPE_INTEGER;
|
|
*step = 1;
|
|
*min = 0;
|
|
*max = 0xffff;
|
|
break;
|
|
case V4L2_CID_FLASH_FAULT:
|
|
case V4L2_CID_JPEG_ACTIVE_MARKER:
|
|
case V4L2_CID_3A_LOCK:
|
|
case V4L2_CID_AUTO_FOCUS_STATUS:
|
|
case V4L2_CID_DV_TX_HOTPLUG:
|
|
case V4L2_CID_DV_TX_RXSENSE:
|
|
case V4L2_CID_DV_TX_EDID_PRESENT:
|
|
case V4L2_CID_DV_RX_POWER_PRESENT:
|
|
*type = V4L2_CTRL_TYPE_BITMASK;
|
|
break;
|
|
case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:
|
|
case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:
|
|
*type = V4L2_CTRL_TYPE_INTEGER;
|
|
*flags |= V4L2_CTRL_FLAG_READ_ONLY;
|
|
break;
|
|
case V4L2_CID_MPEG_VIDEO_DEC_PTS:
|
|
*type = V4L2_CTRL_TYPE_INTEGER64;
|
|
*flags |= V4L2_CTRL_FLAG_VOLATILE | V4L2_CTRL_FLAG_READ_ONLY;
|
|
*min = *def = 0;
|
|
*max = 0x1ffffffffLL;
|
|
*step = 1;
|
|
break;
|
|
case V4L2_CID_MPEG_VIDEO_DEC_FRAME:
|
|
*type = V4L2_CTRL_TYPE_INTEGER64;
|
|
*flags |= V4L2_CTRL_FLAG_VOLATILE | V4L2_CTRL_FLAG_READ_ONLY;
|
|
*min = *def = 0;
|
|
*max = 0x7fffffffffffffffLL;
|
|
*step = 1;
|
|
break;
|
|
case V4L2_CID_MPEG_VIDEO_DEC_CONCEAL_COLOR:
|
|
*type = V4L2_CTRL_TYPE_INTEGER64;
|
|
*min = 0;
|
|
/* default for 8 bit black, luma is 16, chroma is 128 */
|
|
*def = 0x8000800010LL;
|
|
*max = 0xffffffffffffLL;
|
|
*step = 1;
|
|
break;
|
|
case V4L2_CID_PIXEL_RATE:
|
|
*type = V4L2_CTRL_TYPE_INTEGER64;
|
|
*flags |= V4L2_CTRL_FLAG_READ_ONLY;
|
|
break;
|
|
case V4L2_CID_DETECT_MD_REGION_GRID:
|
|
*type = V4L2_CTRL_TYPE_U8;
|
|
break;
|
|
case V4L2_CID_DETECT_MD_THRESHOLD_GRID:
|
|
*type = V4L2_CTRL_TYPE_U16;
|
|
break;
|
|
case V4L2_CID_RDS_TX_ALT_FREQS:
|
|
*type = V4L2_CTRL_TYPE_U32;
|
|
break;
|
|
case V4L2_CID_STATELESS_MPEG2_SEQUENCE:
|
|
*type = V4L2_CTRL_TYPE_MPEG2_SEQUENCE;
|
|
break;
|
|
case V4L2_CID_STATELESS_MPEG2_PICTURE:
|
|
*type = V4L2_CTRL_TYPE_MPEG2_PICTURE;
|
|
break;
|
|
case V4L2_CID_STATELESS_MPEG2_QUANTISATION:
|
|
*type = V4L2_CTRL_TYPE_MPEG2_QUANTISATION;
|
|
break;
|
|
case V4L2_CID_STATELESS_FWHT_PARAMS:
|
|
*type = V4L2_CTRL_TYPE_FWHT_PARAMS;
|
|
break;
|
|
case V4L2_CID_STATELESS_H264_SPS:
|
|
*type = V4L2_CTRL_TYPE_H264_SPS;
|
|
break;
|
|
case V4L2_CID_STATELESS_H264_PPS:
|
|
*type = V4L2_CTRL_TYPE_H264_PPS;
|
|
break;
|
|
case V4L2_CID_STATELESS_H264_SCALING_MATRIX:
|
|
*type = V4L2_CTRL_TYPE_H264_SCALING_MATRIX;
|
|
break;
|
|
case V4L2_CID_STATELESS_H264_SLICE_PARAMS:
|
|
*type = V4L2_CTRL_TYPE_H264_SLICE_PARAMS;
|
|
break;
|
|
case V4L2_CID_STATELESS_H264_DECODE_PARAMS:
|
|
*type = V4L2_CTRL_TYPE_H264_DECODE_PARAMS;
|
|
break;
|
|
case V4L2_CID_STATELESS_H264_PRED_WEIGHTS:
|
|
*type = V4L2_CTRL_TYPE_H264_PRED_WEIGHTS;
|
|
break;
|
|
case V4L2_CID_STATELESS_VP8_FRAME:
|
|
*type = V4L2_CTRL_TYPE_VP8_FRAME;
|
|
break;
|
|
case V4L2_CID_STATELESS_HEVC_SPS:
|
|
*type = V4L2_CTRL_TYPE_HEVC_SPS;
|
|
break;
|
|
case V4L2_CID_STATELESS_HEVC_PPS:
|
|
*type = V4L2_CTRL_TYPE_HEVC_PPS;
|
|
break;
|
|
case V4L2_CID_STATELESS_HEVC_SLICE_PARAMS:
|
|
*type = V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS;
|
|
*flags |= V4L2_CTRL_FLAG_DYNAMIC_ARRAY;
|
|
break;
|
|
case V4L2_CID_STATELESS_HEVC_SCALING_MATRIX:
|
|
*type = V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX;
|
|
break;
|
|
case V4L2_CID_STATELESS_HEVC_DECODE_PARAMS:
|
|
*type = V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS;
|
|
break;
|
|
case V4L2_CID_STATELESS_HEVC_ENTRY_POINT_OFFSETS:
|
|
*type = V4L2_CTRL_TYPE_U32;
|
|
*flags |= V4L2_CTRL_FLAG_DYNAMIC_ARRAY;
|
|
break;
|
|
case V4L2_CID_STATELESS_VP9_COMPRESSED_HDR:
|
|
*type = V4L2_CTRL_TYPE_VP9_COMPRESSED_HDR;
|
|
break;
|
|
case V4L2_CID_STATELESS_VP9_FRAME:
|
|
*type = V4L2_CTRL_TYPE_VP9_FRAME;
|
|
break;
|
|
case V4L2_CID_UNIT_CELL_SIZE:
|
|
*type = V4L2_CTRL_TYPE_AREA;
|
|
*flags |= V4L2_CTRL_FLAG_READ_ONLY;
|
|
break;
|
|
case V4L2_CID_COLORIMETRY_HDR10_CLL_INFO:
|
|
*type = V4L2_CTRL_TYPE_HDR10_CLL_INFO;
|
|
break;
|
|
case V4L2_CID_COLORIMETRY_HDR10_MASTERING_DISPLAY:
|
|
*type = V4L2_CTRL_TYPE_HDR10_MASTERING_DISPLAY;
|
|
break;
|
|
default:
|
|
*type = V4L2_CTRL_TYPE_INTEGER;
|
|
break;
|
|
}
|
|
switch (id) {
|
|
case V4L2_CID_MPEG_AUDIO_ENCODING:
|
|
case V4L2_CID_MPEG_AUDIO_MODE:
|
|
case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
|
|
case V4L2_CID_MPEG_VIDEO_B_FRAMES:
|
|
case V4L2_CID_MPEG_STREAM_TYPE:
|
|
*flags |= V4L2_CTRL_FLAG_UPDATE;
|
|
break;
|
|
case V4L2_CID_AUDIO_VOLUME:
|
|
case V4L2_CID_AUDIO_BALANCE:
|
|
case V4L2_CID_AUDIO_BASS:
|
|
case V4L2_CID_AUDIO_TREBLE:
|
|
case V4L2_CID_BRIGHTNESS:
|
|
case V4L2_CID_CONTRAST:
|
|
case V4L2_CID_SATURATION:
|
|
case V4L2_CID_HUE:
|
|
case V4L2_CID_RED_BALANCE:
|
|
case V4L2_CID_BLUE_BALANCE:
|
|
case V4L2_CID_GAMMA:
|
|
case V4L2_CID_SHARPNESS:
|
|
case V4L2_CID_CHROMA_GAIN:
|
|
case V4L2_CID_RDS_TX_DEVIATION:
|
|
case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
|
|
case V4L2_CID_AUDIO_LIMITER_DEVIATION:
|
|
case V4L2_CID_AUDIO_COMPRESSION_GAIN:
|
|
case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
|
|
case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
|
|
case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
|
|
case V4L2_CID_PILOT_TONE_DEVIATION:
|
|
case V4L2_CID_PILOT_TONE_FREQUENCY:
|
|
case V4L2_CID_TUNE_POWER_LEVEL:
|
|
case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
|
|
case V4L2_CID_RF_TUNER_RF_GAIN:
|
|
case V4L2_CID_RF_TUNER_LNA_GAIN:
|
|
case V4L2_CID_RF_TUNER_MIXER_GAIN:
|
|
case V4L2_CID_RF_TUNER_IF_GAIN:
|
|
case V4L2_CID_RF_TUNER_BANDWIDTH:
|
|
case V4L2_CID_DETECT_MD_GLOBAL_THRESHOLD:
|
|
*flags |= V4L2_CTRL_FLAG_SLIDER;
|
|
break;
|
|
case V4L2_CID_PAN_RELATIVE:
|
|
case V4L2_CID_TILT_RELATIVE:
|
|
case V4L2_CID_FOCUS_RELATIVE:
|
|
case V4L2_CID_IRIS_RELATIVE:
|
|
case V4L2_CID_ZOOM_RELATIVE:
|
|
*flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
|
|
V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
|
|
break;
|
|
case V4L2_CID_FLASH_STROBE_STATUS:
|
|
case V4L2_CID_AUTO_FOCUS_STATUS:
|
|
case V4L2_CID_FLASH_READY:
|
|
case V4L2_CID_DV_TX_HOTPLUG:
|
|
case V4L2_CID_DV_TX_RXSENSE:
|
|
case V4L2_CID_DV_TX_EDID_PRESENT:
|
|
case V4L2_CID_DV_RX_POWER_PRESENT:
|
|
case V4L2_CID_DV_RX_IT_CONTENT_TYPE:
|
|
case V4L2_CID_RDS_RX_PTY:
|
|
case V4L2_CID_RDS_RX_PS_NAME:
|
|
case V4L2_CID_RDS_RX_RADIO_TEXT:
|
|
case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT:
|
|
case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM:
|
|
case V4L2_CID_RDS_RX_MUSIC_SPEECH:
|
|
case V4L2_CID_CAMERA_ORIENTATION:
|
|
case V4L2_CID_CAMERA_SENSOR_ROTATION:
|
|
*flags |= V4L2_CTRL_FLAG_READ_ONLY;
|
|
break;
|
|
case V4L2_CID_RF_TUNER_PLL_LOCK:
|
|
*flags |= V4L2_CTRL_FLAG_VOLATILE;
|
|
break;
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(v4l2_ctrl_fill);
|