Quelle  vivid-core.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0-only */
/*
 * vivid-core.h - core datastructures
 *
 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
 */

#ifndef _VIVID_CORE_H_
#define _VIVID_CORE_H_

#include <linux/fb.h>
#include <linux/workqueue.h>
#include <media/cec.h>
#include <media/videobuf2-v4l2.h>
#include <media/v4l2-device.h>
#include <media/v4l2-dev.h>
#include <media/v4l2-ctrls.h>
#include <media/tpg/v4l2-tpg.h>
#include "vivid-rds-gen.h"
#include "vivid-vbi-gen.h"

#define dprintk(dev, level, fmt, arg...) \
 v4l2_dbg(level, vivid_debug, &dev->v4l2_dev, fmt, ## arg)

/* The maximum number of inputs */
#define MAX_INPUTS 16
/* The maximum number of outputs */
#define MAX_OUTPUTS 16
/* The maximum number of video capture buffers */
#define MAX_VID_CAP_BUFFERS 64
/* The maximum up or down scaling factor is 4 */
#define MAX_ZOOM  4
/* The maximum image width/height are set to 4K DMT */
#define MAX_WIDTH  4096
#define MAX_HEIGHT 2160
/* The minimum image width/height */
#define MIN_WIDTH  16
#define MIN_HEIGHT MIN_WIDTH
/* Pixel Array control divider */
#define PIXEL_ARRAY_DIV MIN_WIDTH
/* The data_offset of plane 0 for the multiplanar formats */
#define PLANE0_DATA_OFFSET 128

/* The supported TV frequency range in MHz */
#define MIN_TV_FREQ (44U * 16U)
#define MAX_TV_FREQ (958U * 16U)

/* The number of samples returned in every SDR buffer */
#define SDR_CAP_SAMPLES_PER_BUF 0x4000

/* used by the threads to know when to resync internal counters */
#define JIFFIES_PER_DAY (3600U * 24U * HZ)
#define JIFFIES_RESYNC (JIFFIES_PER_DAY * (0xf0000000U / JIFFIES_PER_DAY))

/*
 * Maximum number of HDMI inputs allowed by vivid, due to limitations
 * of the Physical Address in the EDID and used by CEC we stop at 15
 * inputs and outputs.
 */
#define MAX_HDMI_INPUTS 15
#define MAX_HDMI_OUTPUTS 15

/* Maximum number of S-Video inputs allowed by vivid */
#define MAX_SVID_INPUTS 16

/* The maximum number of items in a menu control */
#define MAX_MENU_ITEMS BITS_PER_LONG_LONG

/* Number of fixed menu items in the 'Connected To' menu controls */
#define FIXED_MENU_ITEMS 2

/* The maximum number of vivid devices */
#define VIVID_MAX_DEVS CONFIG_VIDEO_VIVID_MAX_DEVS

extern const struct v4l2_rect vivid_min_rect;
extern const struct v4l2_rect vivid_max_rect;
extern unsigned vivid_debug;

/*
 * NULL-terminated string array for the HDMI 'Connected To' menu controls
 * with the list of possible HDMI outputs.
 *
 * The first two items are fixed ("TPG" and "None").
 */
extern char *vivid_ctrl_hdmi_to_output_strings[1 + MAX_MENU_ITEMS];
/* Menu control skip mask of all HDMI outputs that are in use */
extern u64 hdmi_to_output_menu_skip_mask;
/*
 * Bitmask of which vivid instances need to update any connected
 * HDMI outputs.
 */
extern u64 hdmi_input_update_outputs_mask;
/*
 * Spinlock for access to hdmi_to_output_menu_skip_mask and
 * hdmi_input_update_outputs_mask.
 */
extern spinlock_t hdmi_output_skip_mask_lock;
/*
 * Workqueue that updates the menu controls whenever the HDMI menu skip mask
 * changes.
 */
extern struct workqueue_struct *update_hdmi_ctrls_workqueue;

/*
 * The HDMI menu control value (index in the menu list) maps to an HDMI
 * output that is part of the given vivid_dev instance and has the given
 * output index (as returned by VIDIOC_G_OUTPUT).
 *
 * NULL/0 if not available.
 */
extern struct vivid_dev *vivid_ctrl_hdmi_to_output_instance[MAX_MENU_ITEMS];
extern unsigned int vivid_ctrl_hdmi_to_output_index[MAX_MENU_ITEMS];

/*
 * NULL-terminated string array for the S-Video 'Connected To' menu controls
 * with the list of possible S-Video outputs.
 *
 * The first two items are fixed ("TPG" and "None").
 */
extern char *vivid_ctrl_svid_to_output_strings[1 + MAX_MENU_ITEMS];
/* Menu control skip mask of all S-Video outputs that are in use */
extern u64 svid_to_output_menu_skip_mask;
/* Spinlock for access to svid_to_output_menu_skip_mask */
extern spinlock_t svid_output_skip_mask_lock;
/*
 * Workqueue that updates the menu controls whenever the S-Video menu skip mask
 * changes.
 */
extern struct workqueue_struct *update_svid_ctrls_workqueue;

/*
 * The S-Video menu control value (index in the menu list) maps to an S-Video
 * output that is part of the given vivid_dev instance and has the given
 * output index (as returned by VIDIOC_G_OUTPUT).
 *
 * NULL/0 if not available.
 */
extern struct vivid_dev *vivid_ctrl_svid_to_output_instance[MAX_MENU_ITEMS];
extern unsigned int vivid_ctrl_svid_to_output_index[MAX_MENU_ITEMS];

extern struct vivid_dev *vivid_devs[VIVID_MAX_DEVS];
extern unsigned int n_devs;

struct vivid_fmt {
 u32 fourcc;          /* v4l2 format id */
 enum tgp_color_enc color_enc;
 bool can_do_overlay;
 u8 vdownsampling[TPG_MAX_PLANES];
 u32 alpha_mask;
 u8 planes;
 u8 buffers;
 u32 data_offset[TPG_MAX_PLANES];
 u32 bit_depth[TPG_MAX_PLANES];
};

extern struct vivid_fmt vivid_formats[];

/* buffer for one video frame */
struct vivid_buffer {
 /* common v4l buffer stuff -- must be first */
 struct vb2_v4l2_buffer vb;
 struct list_head list;
};

enum vivid_input {
 WEBCAM,
 TV,
 SVID,
 HDMI,
};

enum vivid_signal_mode {
 CURRENT_DV_TIMINGS,
 CURRENT_STD = CURRENT_DV_TIMINGS,
 NO_SIGNAL,
 NO_LOCK,
 OUT_OF_RANGE,
 SELECTED_DV_TIMINGS,
 SELECTED_STD = SELECTED_DV_TIMINGS,
 CYCLE_DV_TIMINGS,
 CYCLE_STD = CYCLE_DV_TIMINGS,
 CUSTOM_DV_TIMINGS,
};

enum vivid_colorspace {
 VIVID_CS_170M,
 VIVID_CS_709,
 VIVID_CS_SRGB,
 VIVID_CS_OPRGB,
 VIVID_CS_2020,
 VIVID_CS_DCI_P3,
 VIVID_CS_240M,
 VIVID_CS_SYS_M,
 VIVID_CS_SYS_BG,
};

#define VIVID_INVALID_SIGNAL(mode) \
 ((mode) == NO_SIGNAL || (mode) == NO_LOCK || (mode) == OUT_OF_RANGE)

struct vivid_cec_xfer {
 struct cec_adapter *adap;
 u8   msg[CEC_MAX_MSG_SIZE];
 u32   len;
 u32   sft;
};

struct vivid_dev {
 u8    inst;
 struct v4l2_device  v4l2_dev;
#ifdef CONFIG_MEDIA_CONTROLLER
 struct media_device  mdev;
 struct media_pad  vid_cap_pad;
 struct media_pad  vid_out_pad;
 struct media_pad  vbi_cap_pad;
 struct media_pad  vbi_out_pad;
 struct media_pad  sdr_cap_pad;
 struct media_pad  meta_cap_pad;
 struct media_pad  meta_out_pad;
 struct media_pad  touch_cap_pad;
#endif
 struct v4l2_ctrl_handler ctrl_hdl_user_gen;
 struct v4l2_ctrl_handler ctrl_hdl_user_vid;
 struct v4l2_ctrl_handler ctrl_hdl_user_aud;
 struct v4l2_ctrl_handler ctrl_hdl_streaming;
 struct v4l2_ctrl_handler ctrl_hdl_sdtv_cap;
 struct v4l2_ctrl_handler ctrl_hdl_loop_cap;
 struct v4l2_ctrl_handler ctrl_hdl_fb;
 struct video_device  vid_cap_dev;
 struct v4l2_ctrl_handler ctrl_hdl_vid_cap;
 struct video_device  vid_out_dev;
 struct v4l2_ctrl_handler ctrl_hdl_vid_out;
 struct video_device  vbi_cap_dev;
 struct v4l2_ctrl_handler ctrl_hdl_vbi_cap;
 struct video_device  vbi_out_dev;
 struct v4l2_ctrl_handler ctrl_hdl_vbi_out;
 struct video_device  radio_rx_dev;
 struct v4l2_ctrl_handler ctrl_hdl_radio_rx;
 struct video_device  radio_tx_dev;
 struct v4l2_ctrl_handler ctrl_hdl_radio_tx;
 struct video_device  sdr_cap_dev;
 struct v4l2_ctrl_handler ctrl_hdl_sdr_cap;
 struct video_device  meta_cap_dev;
 struct v4l2_ctrl_handler ctrl_hdl_meta_cap;
 struct video_device  meta_out_dev;
 struct v4l2_ctrl_handler ctrl_hdl_meta_out;
 struct video_device  touch_cap_dev;
 struct v4l2_ctrl_handler ctrl_hdl_touch_cap;

 spinlock_t   slock;
 struct mutex   mutex;
 struct work_struct  update_hdmi_ctrl_work;
 struct work_struct  update_svid_ctrl_work;

 /* capabilities */
 u32    vid_cap_caps;
 u32    vid_out_caps;
 u32    vbi_cap_caps;
 u32    vbi_out_caps;
 u32    sdr_cap_caps;
 u32    radio_rx_caps;
 u32    radio_tx_caps;
 u32    meta_cap_caps;
 u32    meta_out_caps;
 u32    touch_cap_caps;

 /* supported features */
 bool    multiplanar;
 u8    num_inputs;
 u8    num_hdmi_inputs;
 u8    num_svid_inputs;
 u8    input_type[MAX_INPUTS];
 u8    input_name_counter[MAX_INPUTS];
 u8    num_outputs;
 u8    num_hdmi_outputs;
 u8    output_type[MAX_OUTPUTS];
 u8    output_name_counter[MAX_OUTPUTS];
 bool    has_audio_inputs;
 bool    has_audio_outputs;
 bool    has_vid_cap;
 bool    has_vid_out;
 bool    has_vbi_cap;
 bool    has_raw_vbi_cap;
 bool    has_sliced_vbi_cap;
 bool    has_vbi_out;
 bool    has_raw_vbi_out;
 bool    has_sliced_vbi_out;
 bool    has_radio_rx;
 bool    has_radio_tx;
 bool    has_sdr_cap;
 bool    has_fb;
 bool    has_meta_cap;
 bool    has_meta_out;
 bool    has_tv_tuner;
 bool    has_touch_cap;

 /* Output index (0-MAX_OUTPUTS) to vivid instance of connected input */
 struct vivid_dev  *output_to_input_instance[MAX_OUTPUTS];
 /* Output index (0-MAX_OUTPUTS) to input index (0-MAX_INPUTS) of connected input */
 u8    output_to_input_index[MAX_OUTPUTS];
 /* Output index (0-MAX_OUTPUTS) to HDMI or S-Video output index (0-MAX_HDMI/SVID_OUTPUTS) */
 u8    output_to_iface_index[MAX_OUTPUTS];
 /* ctrl_hdmi_to_output or ctrl_svid_to_output control value for each input */
 s32                             input_is_connected_to_output[MAX_INPUTS];
 /* HDMI index (0-MAX_HDMI_OUTPUTS) to output index (0-MAX_OUTPUTS) */
 u8    hdmi_index_to_output_index[MAX_HDMI_OUTPUTS];
 /* HDMI index (0-MAX_HDMI_INPUTS) to input index (0-MAX_INPUTS) */
 u8    hdmi_index_to_input_index[MAX_HDMI_INPUTS];
 /* S-Video index (0-MAX_SVID_INPUTS) to input index (0-MAX_INPUTS) */
 u8    svid_index_to_input_index[MAX_SVID_INPUTS];

 /* controls */
 struct v4l2_ctrl  *brightness;
 struct v4l2_ctrl  *contrast;
 struct v4l2_ctrl  *saturation;
 struct v4l2_ctrl  *hue;
 struct {
  /* autogain/gain cluster */
  struct v4l2_ctrl *autogain;
  struct v4l2_ctrl *gain;
 };
 struct v4l2_ctrl  *volume;
 struct v4l2_ctrl  *mute;
 struct v4l2_ctrl  *alpha;
 struct v4l2_ctrl  *button;
 struct v4l2_ctrl  *boolean;
 struct v4l2_ctrl  *int32;
 struct v4l2_ctrl  *int64;
 struct v4l2_ctrl  *menu;
 struct v4l2_ctrl  *string;
 struct v4l2_ctrl  *bitmask;
 struct v4l2_ctrl  *int_menu;
 struct v4l2_ctrl  *ro_int32;
 struct v4l2_ctrl  *pixel_array;
 struct v4l2_ctrl  *test_pattern;
 struct v4l2_ctrl  *colorspace;
 struct v4l2_ctrl  *rgb_range_cap;
 struct v4l2_ctrl  *real_rgb_range_cap;
 struct {
  /* std_signal_mode/standard cluster */
  struct v4l2_ctrl *ctrl_std_signal_mode;
  struct v4l2_ctrl *ctrl_standard;
 };
 struct {
  /* dv_timings_signal_mode/timings cluster */
  struct v4l2_ctrl *ctrl_dv_timings_signal_mode;
  struct v4l2_ctrl *ctrl_dv_timings;
 };
 struct v4l2_ctrl  *ctrl_has_crop_cap;
 struct v4l2_ctrl  *ctrl_has_compose_cap;
 struct v4l2_ctrl  *ctrl_has_scaler_cap;
 struct v4l2_ctrl  *ctrl_has_crop_out;
 struct v4l2_ctrl  *ctrl_has_compose_out;
 struct v4l2_ctrl  *ctrl_has_scaler_out;
 struct v4l2_ctrl  *ctrl_tx_mode;
 struct v4l2_ctrl  *ctrl_tx_rgb_range;
 struct v4l2_ctrl  *ctrl_tx_edid_present;
 struct v4l2_ctrl  *ctrl_tx_hotplug;
 struct v4l2_ctrl  *ctrl_tx_rxsense;

 struct v4l2_ctrl  *ctrl_rx_power_present;

 struct v4l2_ctrl  *radio_tx_rds_pi;
 struct v4l2_ctrl  *radio_tx_rds_pty;
 struct v4l2_ctrl  *radio_tx_rds_mono_stereo;
 struct v4l2_ctrl  *radio_tx_rds_art_head;
 struct v4l2_ctrl  *radio_tx_rds_compressed;
 struct v4l2_ctrl  *radio_tx_rds_dyn_pty;
 struct v4l2_ctrl  *radio_tx_rds_ta;
 struct v4l2_ctrl  *radio_tx_rds_tp;
 struct v4l2_ctrl  *radio_tx_rds_ms;
 struct v4l2_ctrl  *radio_tx_rds_psname;
 struct v4l2_ctrl  *radio_tx_rds_radiotext;

 struct v4l2_ctrl  *radio_rx_rds_pty;
 struct v4l2_ctrl  *radio_rx_rds_ta;
 struct v4l2_ctrl  *radio_rx_rds_tp;
 struct v4l2_ctrl  *radio_rx_rds_ms;
 struct v4l2_ctrl  *radio_rx_rds_psname;
 struct v4l2_ctrl  *radio_rx_rds_radiotext;

 struct v4l2_ctrl                *ctrl_hdmi_to_output[MAX_HDMI_INPUTS];
 char    ctrl_hdmi_to_output_names[MAX_HDMI_INPUTS][32];
 struct v4l2_ctrl  *ctrl_svid_to_output[MAX_SVID_INPUTS];
 char    ctrl_svid_to_output_names[MAX_SVID_INPUTS][32];

 unsigned   input_brightness[MAX_INPUTS];
 unsigned   osd_mode;
 unsigned   button_pressed;
 bool    sensor_hflip;
 bool    sensor_vflip;
 bool    hflip;
 bool    vflip;
 bool    vbi_cap_interlaced;
 bool    loop_video;
 bool    reduced_fps;

 /* Framebuffer */
 unsigned long   video_pbase;
 void    *video_vbase;
 u32    video_buffer_size;
 int    display_width;
 int    display_height;
 int    display_byte_stride;
 int    bits_per_pixel;
 int    bytes_per_pixel;
#ifdef CONFIG_VIDEO_VIVID_OSD
 struct fb_info   fb_info;
 struct fb_var_screeninfo fb_defined;
 struct fb_fix_screeninfo fb_fix;
#endif

 /* Error injection */
 bool    disconnect_error;
 bool    queue_setup_error;
 bool    buf_prepare_error;
 bool    start_streaming_error;
 bool    dqbuf_error;
 bool    req_validate_error;
 bool    seq_wrap;
 u64    time_wrap;
 u64    time_wrap_offset;
 unsigned   perc_dropped_buffers;
 enum vivid_signal_mode  std_signal_mode[MAX_INPUTS];
 unsigned int   query_std_last[MAX_INPUTS];
 v4l2_std_id   query_std[MAX_INPUTS];
 enum tpg_video_aspect  std_aspect_ratio[MAX_INPUTS];

 enum vivid_signal_mode  dv_timings_signal_mode[MAX_INPUTS];
 char    **query_dv_timings_qmenu;
 char    *query_dv_timings_qmenu_strings;
 unsigned   query_dv_timings_size;
 unsigned int   query_dv_timings_last[MAX_INPUTS];
 unsigned int   query_dv_timings[MAX_INPUTS];
 enum tpg_video_aspect  dv_timings_aspect_ratio[MAX_INPUTS];

 /* Input */
 unsigned   input;
 v4l2_std_id   std_cap[MAX_INPUTS];
 struct v4l2_dv_timings  dv_timings_cap[MAX_INPUTS];
 int    dv_timings_cap_sel[MAX_INPUTS];
 u32    service_set_cap;
 struct vivid_vbi_gen_data vbi_gen;
 u8    *edid;
 unsigned   edid_blocks;
 unsigned   edid_max_blocks;
 unsigned   webcam_size_idx;
 unsigned   webcam_ival_idx;
 unsigned   tv_freq;
 unsigned   tv_audmode;
 unsigned   tv_field_cap;
 unsigned   tv_audio_input;

 u32    power_present;

 /* Output */
 unsigned   output;
 v4l2_std_id   std_out;
 struct v4l2_dv_timings  dv_timings_out;
 u32    colorspace_out;
 u32    ycbcr_enc_out;
 u32    hsv_enc_out;
 u32    quantization_out;
 u32    xfer_func_out;
 u32    service_set_out;
 unsigned   bytesperline_out[TPG_MAX_PLANES];
 unsigned   tv_field_out;
 unsigned   tv_audio_output;
 bool    vbi_out_have_wss;
 u8    vbi_out_wss[2];
 bool    vbi_out_have_cc[2];
 u8    vbi_out_cc[2][2];
 bool    dvi_d_out;
 u8    *scaled_line;
 u8    *blended_line;
 unsigned   cur_scaled_line;

 /* Output Overlay */
 void    *fb_vbase_out;
 bool    overlay_out_enabled;
 int    overlay_out_top, overlay_out_left;
 unsigned   fbuf_out_flags;
 u32    chromakey_out;
 u8    global_alpha_out;

 /* video capture */
 struct tpg_data   tpg;
 unsigned   ms_vid_cap;
 bool    must_blank[MAX_VID_CAP_BUFFERS];

 const struct vivid_fmt  *fmt_cap;
 struct v4l2_fract  timeperframe_vid_cap;
 enum v4l2_field   field_cap;
 struct v4l2_rect  src_rect;
 struct v4l2_rect  fmt_cap_rect;
 struct v4l2_rect  crop_cap;
 struct v4l2_rect  compose_cap;
 struct v4l2_rect  crop_bounds_cap;
 struct vb2_queue  vb_vid_cap_q;
 struct list_head  vid_cap_active;
 struct vb2_queue  vb_vbi_cap_q;
 struct list_head  vbi_cap_active;
 struct vb2_queue  vb_meta_cap_q;
 struct list_head  meta_cap_active;
 struct vb2_queue  vb_touch_cap_q;
 struct list_head  touch_cap_active;

 /* thread for generating video capture stream */
 struct task_struct  *kthread_vid_cap;
 unsigned long   jiffies_vid_cap;
 u64    cap_stream_start;
 u64    cap_frame_period;
 u64    cap_frame_eof_offset;
 u32    cap_seq_offset;
 u32    cap_seq_count;
 bool    cap_seq_resync;
 u32    vid_cap_seq_start;
 u32    vid_cap_seq_count;
 bool    vid_cap_streaming;
 u32    vbi_cap_seq_start;
 u32    vbi_cap_seq_count;
 bool    vbi_cap_streaming;
 u32    meta_cap_seq_start;
 u32    meta_cap_seq_count;
 bool    meta_cap_streaming;

 /* Touch capture */
 struct task_struct  *kthread_touch_cap;
 unsigned long   jiffies_touch_cap;
 u64    touch_cap_stream_start;
 u32    touch_cap_seq_offset;
 bool    touch_cap_seq_resync;
 u32    touch_cap_seq_start;
 u32    touch_cap_seq_count;
 u32    touch_cap_with_seq_wrap_count;
 bool    touch_cap_streaming;
 struct v4l2_fract  timeperframe_tch_cap;
 struct v4l2_pix_format  tch_format;
 int    tch_pat_random;

 /* video output */
 const struct vivid_fmt  *fmt_out;
 struct v4l2_fract  timeperframe_vid_out;
 enum v4l2_field   field_out;
 struct v4l2_rect  sink_rect;
 struct v4l2_rect  fmt_out_rect;
 struct v4l2_rect  crop_out;
 struct v4l2_rect  compose_out;
 struct v4l2_rect  compose_bounds_out;
 struct vb2_queue  vb_vid_out_q;
 struct list_head  vid_out_active;
 struct vb2_queue  vb_vbi_out_q;
 struct list_head  vbi_out_active;
 struct vb2_queue  vb_meta_out_q;
 struct list_head  meta_out_active;

 /* video loop precalculated rectangles */

 /*
 * Intersection between what the output side composes and the capture side
 * crops. I.e., what actually needs to be copied from the output buffer to
 * the capture buffer.
 */
 struct v4l2_rect  loop_vid_copy;
 /* The part of the output buffer that (after scaling) corresponds to loop_vid_copy. */
 struct v4l2_rect  loop_vid_out;
 /* The part of the capture buffer that (after scaling) corresponds to loop_vid_copy. */
 struct v4l2_rect  loop_vid_cap;
 /*
 * The intersection of the framebuffer, the overlay output window and
 * loop_vid_copy. I.e., the part of the framebuffer that actually should be
 * blended with the compose_out rectangle. This uses the framebuffer origin.
 */
 struct v4l2_rect  loop_fb_copy;
 /* The same as loop_fb_copy but with compose_out origin. */
 struct v4l2_rect  loop_vid_overlay;
 /*
 * The part of the capture buffer that (after scaling) corresponds
 * to loop_vid_overlay.
 */
 struct v4l2_rect  loop_vid_overlay_cap;

 /* thread for generating video output stream */
 struct task_struct  *kthread_vid_out;
 unsigned long   jiffies_vid_out;
 u32    out_seq_offset;
 u32    out_seq_count;
 bool    out_seq_resync;
 u32    vid_out_seq_start;
 u32    vid_out_seq_count;
 bool    vid_out_streaming;
 u32    vbi_out_seq_start;
 u32    vbi_out_seq_count;
 bool    vbi_out_streaming;
 bool    stream_sliced_vbi_out;
 u32    meta_out_seq_start;
 u32    meta_out_seq_count;
 bool    meta_out_streaming;

 /* SDR capture */
 struct vb2_queue  vb_sdr_cap_q;
 struct list_head  sdr_cap_active;
 u32    sdr_pixelformat; /* v4l2 format id */
 unsigned   sdr_buffersize;
 unsigned   sdr_adc_freq;
 unsigned   sdr_fm_freq;
 unsigned   sdr_fm_deviation;
 int    sdr_fixp_src_phase;
 int    sdr_fixp_mod_phase;

 bool    tstamp_src_is_soe;
 bool    has_crop_cap;
 bool    has_compose_cap;
 bool    has_scaler_cap;
 bool    has_crop_out;
 bool    has_compose_out;
 bool    has_scaler_out;

 /* thread for generating SDR stream */
 struct task_struct  *kthread_sdr_cap;
 unsigned long   jiffies_sdr_cap;
 u32    sdr_cap_seq_offset;
 u32    sdr_cap_seq_start;
 u32    sdr_cap_seq_count;
 u32    sdr_cap_with_seq_wrap_count;
 bool    sdr_cap_seq_resync;

 /* RDS generator */
 struct vivid_rds_gen  rds_gen;

 /* Radio receiver */
 unsigned   radio_rx_freq;
 unsigned   radio_rx_audmode;
 int    radio_rx_sig_qual;
 unsigned   radio_rx_hw_seek_mode;
 bool    radio_rx_hw_seek_prog_lim;
 bool    radio_rx_rds_controls;
 bool    radio_rx_rds_enabled;
 unsigned   radio_rx_rds_use_alternates;
 unsigned   radio_rx_rds_last_block;
 struct v4l2_fh   *radio_rx_rds_owner;

 /* Radio transmitter */
 unsigned   radio_tx_freq;
 unsigned   radio_tx_subchans;
 bool    radio_tx_rds_controls;
 unsigned   radio_tx_rds_last_block;
 struct v4l2_fh   *radio_tx_rds_owner;

 /* Shared between radio receiver and transmitter */
 bool    radio_rds_loop;
 ktime_t    radio_rds_init_time;

 /* CEC */
 struct cec_adapter  *cec_rx_adap;
 struct cec_adapter  *cec_tx_adap[MAX_HDMI_OUTPUTS];
 struct task_struct  *kthread_cec;
 wait_queue_head_t  kthread_waitq_cec;
 struct vivid_cec_xfer  xfers[MAX_OUTPUTS];
 spinlock_t   cec_xfers_slock; /* read and write cec messages */
 u32    cec_sft; /* bus signal free time, in bit periods */
 u8    last_initiator;

 /* CEC OSD String */
 char    osd[14];
 unsigned long   osd_jiffies;

 bool    meta_pts;
 bool    meta_scr;
};

static inline bool vivid_is_webcam(const struct vivid_dev *dev)
{
 return dev->input_type[dev->input] == WEBCAM;
}

static inline bool vivid_is_tv_cap(const struct vivid_dev *dev)
{
 return dev->input_type[dev->input] == TV;
}

static inline bool vivid_is_svid_cap(const struct vivid_dev *dev)
{
 return dev->input_type[dev->input] == SVID;
}

static inline bool vivid_is_hdmi_cap(const struct vivid_dev *dev)
{
 return dev->input_type[dev->input] == HDMI;
}

static inline bool vivid_is_sdtv_cap(const struct vivid_dev *dev)
{
 return vivid_is_tv_cap(dev) || vivid_is_svid_cap(dev);
}

static inline bool vivid_is_svid_out(const struct vivid_dev *dev)
{
 return dev->output_type[dev->output] == SVID;
}

static inline bool vivid_is_hdmi_out(const struct vivid_dev *dev)
{
 return dev->output_type[dev->output] == HDMI;
}

#endif