Jetpack/kernel/kernel-4.9/include/media/v4l2-tpg.h

615 lines
15 KiB
C

/*
* v4l2-tpg.h - Test Pattern Generator
*
* Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
*
* This program is free software; you may redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; version 2 of the License.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#ifndef _V4L2_TPG_H_
#define _V4L2_TPG_H_
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/random.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/videodev2.h>
#include <media/v4l2-tpg-colors.h>
enum tpg_pattern {
TPG_PAT_75_COLORBAR,
TPG_PAT_100_COLORBAR,
TPG_PAT_CSC_COLORBAR,
TPG_PAT_100_HCOLORBAR,
TPG_PAT_100_COLORSQUARES,
TPG_PAT_BLACK,
TPG_PAT_WHITE,
TPG_PAT_RED,
TPG_PAT_GREEN,
TPG_PAT_BLUE,
TPG_PAT_CHECKERS_16X16,
TPG_PAT_CHECKERS_2X2,
TPG_PAT_CHECKERS_1X1,
TPG_PAT_COLOR_CHECKERS_2X2,
TPG_PAT_COLOR_CHECKERS_1X1,
TPG_PAT_ALTERNATING_HLINES,
TPG_PAT_ALTERNATING_VLINES,
TPG_PAT_CROSS_1_PIXEL,
TPG_PAT_CROSS_2_PIXELS,
TPG_PAT_CROSS_10_PIXELS,
TPG_PAT_GRAY_RAMP,
/* Must be the last pattern */
TPG_PAT_NOISE,
};
extern const char * const tpg_pattern_strings[];
enum tpg_quality {
TPG_QUAL_COLOR,
TPG_QUAL_GRAY,
TPG_QUAL_NOISE
};
enum tpg_video_aspect {
TPG_VIDEO_ASPECT_IMAGE,
TPG_VIDEO_ASPECT_4X3,
TPG_VIDEO_ASPECT_14X9_CENTRE,
TPG_VIDEO_ASPECT_16X9_CENTRE,
TPG_VIDEO_ASPECT_16X9_ANAMORPHIC,
};
enum tpg_pixel_aspect {
TPG_PIXEL_ASPECT_SQUARE,
TPG_PIXEL_ASPECT_NTSC,
TPG_PIXEL_ASPECT_PAL,
};
enum tpg_move_mode {
TPG_MOVE_NEG_FAST,
TPG_MOVE_NEG,
TPG_MOVE_NEG_SLOW,
TPG_MOVE_NONE,
TPG_MOVE_POS_SLOW,
TPG_MOVE_POS,
TPG_MOVE_POS_FAST,
};
extern const char * const tpg_aspect_strings[];
#define TPG_MAX_PLANES 3
#define TPG_MAX_PAT_LINES 8
struct tpg_data {
/* Source frame size */
unsigned src_width, src_height;
/* Buffer height */
unsigned buf_height[TPG_MAX_PLANES];
/* Scaled output frame size */
unsigned scaled_width;
u32 field;
bool field_alternate;
/* crop coordinates are frame-based */
struct v4l2_rect crop;
/* compose coordinates are format-based */
struct v4l2_rect compose;
/* border and square coordinates are frame-based */
struct v4l2_rect border;
struct v4l2_rect square;
/* Color-related fields */
enum tpg_quality qual;
unsigned qual_offset;
u8 alpha_component;
bool alpha_red_only;
u8 brightness;
u8 contrast;
u8 saturation;
s16 hue;
u32 fourcc;
bool is_yuv;
u32 colorspace;
u32 xfer_func;
u32 ycbcr_enc;
/*
* Stores the actual transfer function, i.e. will never be
* V4L2_XFER_FUNC_DEFAULT.
*/
u32 real_xfer_func;
/*
* Stores the actual Y'CbCr encoding, i.e. will never be
* V4L2_YCBCR_ENC_DEFAULT.
*/
u32 real_ycbcr_enc;
u32 quantization;
/*
* Stores the actual quantization, i.e. will never be
* V4L2_QUANTIZATION_DEFAULT.
*/
u32 real_quantization;
enum tpg_video_aspect vid_aspect;
enum tpg_pixel_aspect pix_aspect;
unsigned rgb_range;
unsigned real_rgb_range;
unsigned buffers;
unsigned planes;
bool interleaved;
u8 vdownsampling[TPG_MAX_PLANES];
u8 hdownsampling[TPG_MAX_PLANES];
u8 packedpixels[TPG_MAX_PLANES];
/*
* horizontal positions must be ANDed with this value to enforce
* correct boundaries for packed YUYV values.
*/
unsigned hmask[TPG_MAX_PLANES];
/* Used to store the colors in native format, either RGB or YUV */
u8 colors[TPG_COLOR_MAX][3];
u8 textfg[TPG_MAX_PLANES][8], textbg[TPG_MAX_PLANES][8];
/* size in bytes for two pixels in each plane */
unsigned twopixelsize[TPG_MAX_PLANES];
unsigned bytesperline[TPG_MAX_PLANES];
/* Configuration */
enum tpg_pattern pattern;
bool hflip;
bool vflip;
unsigned perc_fill;
bool perc_fill_blank;
bool show_border;
bool show_square;
bool insert_sav;
bool insert_eav;
/* Test pattern movement */
enum tpg_move_mode mv_hor_mode;
int mv_hor_count;
int mv_hor_step;
enum tpg_move_mode mv_vert_mode;
int mv_vert_count;
int mv_vert_step;
bool recalc_colors;
bool recalc_lines;
bool recalc_square_border;
/* Used to store TPG_MAX_PAT_LINES lines, each with up to two planes */
unsigned max_line_width;
u8 *lines[TPG_MAX_PAT_LINES][TPG_MAX_PLANES];
u8 *downsampled_lines[TPG_MAX_PAT_LINES][TPG_MAX_PLANES];
u8 *random_line[TPG_MAX_PLANES];
u8 *contrast_line[TPG_MAX_PLANES];
u8 *black_line[TPG_MAX_PLANES];
};
void tpg_init(struct tpg_data *tpg, unsigned w, unsigned h);
int tpg_alloc(struct tpg_data *tpg, unsigned max_w);
void tpg_free(struct tpg_data *tpg);
void tpg_reset_source(struct tpg_data *tpg, unsigned width, unsigned height,
u32 field);
void tpg_log_status(struct tpg_data *tpg);
void tpg_set_font(const u8 *f);
void tpg_gen_text(const struct tpg_data *tpg,
u8 *basep[TPG_MAX_PLANES][2], int y, int x, char *text);
void tpg_calc_text_basep(struct tpg_data *tpg,
u8 *basep[TPG_MAX_PLANES][2], unsigned p, u8 *vbuf);
unsigned tpg_g_interleaved_plane(const struct tpg_data *tpg, unsigned buf_line);
void tpg_fill_plane_buffer(struct tpg_data *tpg, v4l2_std_id std,
unsigned p, u8 *vbuf);
void tpg_fillbuffer(struct tpg_data *tpg, v4l2_std_id std,
unsigned p, u8 *vbuf);
bool tpg_s_fourcc(struct tpg_data *tpg, u32 fourcc, u32 metadata_height);
void tpg_s_crop_compose(struct tpg_data *tpg, const struct v4l2_rect *crop,
const struct v4l2_rect *compose);
static inline void tpg_s_pattern(struct tpg_data *tpg, enum tpg_pattern pattern)
{
if (tpg->pattern == pattern)
return;
tpg->pattern = pattern;
tpg->recalc_colors = true;
}
static inline void tpg_s_quality(struct tpg_data *tpg,
enum tpg_quality qual, unsigned qual_offset)
{
if (tpg->qual == qual && tpg->qual_offset == qual_offset)
return;
tpg->qual = qual;
tpg->qual_offset = qual_offset;
tpg->recalc_colors = true;
}
static inline enum tpg_quality tpg_g_quality(const struct tpg_data *tpg)
{
return tpg->qual;
}
static inline void tpg_s_alpha_component(struct tpg_data *tpg,
u8 alpha_component)
{
if (tpg->alpha_component == alpha_component)
return;
tpg->alpha_component = alpha_component;
tpg->recalc_colors = true;
}
static inline void tpg_s_alpha_mode(struct tpg_data *tpg,
bool red_only)
{
if (tpg->alpha_red_only == red_only)
return;
tpg->alpha_red_only = red_only;
tpg->recalc_colors = true;
}
static inline void tpg_s_brightness(struct tpg_data *tpg,
u8 brightness)
{
if (tpg->brightness == brightness)
return;
tpg->brightness = brightness;
tpg->recalc_colors = true;
}
static inline void tpg_s_contrast(struct tpg_data *tpg,
u8 contrast)
{
if (tpg->contrast == contrast)
return;
tpg->contrast = contrast;
tpg->recalc_colors = true;
}
static inline void tpg_s_saturation(struct tpg_data *tpg,
u8 saturation)
{
if (tpg->saturation == saturation)
return;
tpg->saturation = saturation;
tpg->recalc_colors = true;
}
static inline void tpg_s_hue(struct tpg_data *tpg,
s16 hue)
{
if (tpg->hue == hue)
return;
tpg->hue = hue;
tpg->recalc_colors = true;
}
static inline void tpg_s_rgb_range(struct tpg_data *tpg,
unsigned rgb_range)
{
if (tpg->rgb_range == rgb_range)
return;
tpg->rgb_range = rgb_range;
tpg->recalc_colors = true;
}
static inline void tpg_s_real_rgb_range(struct tpg_data *tpg,
unsigned rgb_range)
{
if (tpg->real_rgb_range == rgb_range)
return;
tpg->real_rgb_range = rgb_range;
tpg->recalc_colors = true;
}
static inline void tpg_s_colorspace(struct tpg_data *tpg, u32 colorspace)
{
if (tpg->colorspace == colorspace)
return;
tpg->colorspace = colorspace;
tpg->recalc_colors = true;
}
static inline u32 tpg_g_colorspace(const struct tpg_data *tpg)
{
return tpg->colorspace;
}
static inline void tpg_s_ycbcr_enc(struct tpg_data *tpg, u32 ycbcr_enc)
{
if (tpg->ycbcr_enc == ycbcr_enc)
return;
tpg->ycbcr_enc = ycbcr_enc;
tpg->recalc_colors = true;
}
static inline u32 tpg_g_ycbcr_enc(const struct tpg_data *tpg)
{
return tpg->ycbcr_enc;
}
static inline void tpg_s_xfer_func(struct tpg_data *tpg, u32 xfer_func)
{
if (tpg->xfer_func == xfer_func)
return;
tpg->xfer_func = xfer_func;
tpg->recalc_colors = true;
}
static inline u32 tpg_g_xfer_func(const struct tpg_data *tpg)
{
return tpg->xfer_func;
}
static inline void tpg_s_quantization(struct tpg_data *tpg, u32 quantization)
{
if (tpg->quantization == quantization)
return;
tpg->quantization = quantization;
tpg->recalc_colors = true;
}
static inline u32 tpg_g_quantization(const struct tpg_data *tpg)
{
return tpg->quantization;
}
static inline unsigned tpg_g_buffers(const struct tpg_data *tpg)
{
return tpg->buffers;
}
static inline unsigned tpg_g_planes(const struct tpg_data *tpg)
{
return tpg->interleaved ? 1 : tpg->planes;
}
static inline bool tpg_g_interleaved(const struct tpg_data *tpg)
{
return tpg->interleaved;
}
static inline unsigned tpg_g_twopixelsize(const struct tpg_data *tpg, unsigned plane)
{
return tpg->twopixelsize[plane];
}
static inline unsigned tpg_g_packedpixels(const struct tpg_data *tpg, unsigned plane)
{
return tpg->packedpixels[plane];
}
static inline unsigned tpg_hdiv(const struct tpg_data *tpg,
unsigned plane, unsigned x)
{
if (tpg->packedpixels[plane] > 1)
return ((((x / tpg->hdownsampling[plane]) & tpg->hmask[plane]) *
tpg->twopixelsize[plane]) /
(2 * tpg->packedpixels[plane]));
else
return ((x / tpg->hdownsampling[plane]) & tpg->hmask[plane]) *
(tpg->twopixelsize[plane] / 2);
}
static inline unsigned tpg_hscale(const struct tpg_data *tpg, unsigned x)
{
return (x * tpg->scaled_width) / tpg->src_width;
}
static inline unsigned tpg_hscale_div(const struct tpg_data *tpg,
unsigned plane, unsigned x)
{
return tpg_hdiv(tpg, plane, tpg_hscale(tpg, x));
}
static inline unsigned tpg_g_bytesperline(const struct tpg_data *tpg, unsigned plane)
{
return tpg->bytesperline[plane];
}
static inline void tpg_s_bytesperline(struct tpg_data *tpg, unsigned plane, unsigned bpl)
{
unsigned p;
if (tpg->buffers > 1) {
tpg->bytesperline[plane] = bpl;
return;
}
for (p = 0; p < tpg_g_planes(tpg); p++) {
unsigned plane_w = bpl * tpg->twopixelsize[p] / tpg->twopixelsize[0];
tpg->bytesperline[p] = plane_w / tpg->hdownsampling[p];
}
if (tpg_g_interleaved(tpg))
tpg->bytesperline[1] = tpg->bytesperline[0];
}
static inline unsigned tpg_g_line_width(const struct tpg_data *tpg, unsigned plane)
{
unsigned w = 0;
unsigned p;
if (tpg->buffers > 1)
return tpg_g_bytesperline(tpg, plane);
for (p = 0; p < tpg_g_planes(tpg); p++) {
unsigned plane_w = tpg_g_bytesperline(tpg, p);
w += plane_w / tpg->vdownsampling[p];
}
return w;
}
static inline unsigned tpg_calc_line_width(const struct tpg_data *tpg,
unsigned plane, unsigned bpl)
{
unsigned w = 0;
unsigned p;
if (tpg->buffers > 1)
return bpl;
for (p = 0; p < tpg_g_planes(tpg); p++) {
unsigned plane_w = bpl * tpg->twopixelsize[p] / tpg->twopixelsize[0];
plane_w /= tpg->hdownsampling[p];
w += plane_w / tpg->vdownsampling[p];
}
return w;
}
static inline unsigned tpg_calc_plane_size(const struct tpg_data *tpg, unsigned plane)
{
if (plane >= tpg_g_planes(tpg))
return 0;
return tpg_g_bytesperline(tpg, plane) * tpg->buf_height[plane] /
tpg->vdownsampling[plane];
}
static inline unsigned tpg_g_buf_height(struct tpg_data *tpg, unsigned plane)
{
return tpg->buf_height[plane];
}
static inline void tpg_s_buf_height(struct tpg_data *tpg,
unsigned p, unsigned h)
{
tpg->buf_height[p] = h;
}
static inline void tpg_s_field(struct tpg_data *tpg, unsigned field, bool alternate)
{
tpg->field = field;
tpg->field_alternate = alternate;
}
static inline void tpg_s_perc_fill(struct tpg_data *tpg,
unsigned perc_fill)
{
tpg->perc_fill = perc_fill;
}
static inline unsigned tpg_g_perc_fill(const struct tpg_data *tpg)
{
return tpg->perc_fill;
}
static inline void tpg_s_perc_fill_blank(struct tpg_data *tpg,
bool perc_fill_blank)
{
tpg->perc_fill_blank = perc_fill_blank;
}
static inline void tpg_s_video_aspect(struct tpg_data *tpg,
enum tpg_video_aspect vid_aspect)
{
if (tpg->vid_aspect == vid_aspect)
return;
tpg->vid_aspect = vid_aspect;
tpg->recalc_square_border = true;
}
static inline enum tpg_video_aspect tpg_g_video_aspect(const struct tpg_data *tpg)
{
return tpg->vid_aspect;
}
static inline void tpg_s_pixel_aspect(struct tpg_data *tpg,
enum tpg_pixel_aspect pix_aspect)
{
if (tpg->pix_aspect == pix_aspect)
return;
tpg->pix_aspect = pix_aspect;
tpg->recalc_square_border = true;
}
static inline void tpg_s_show_border(struct tpg_data *tpg,
bool show_border)
{
tpg->show_border = show_border;
}
static inline void tpg_s_show_square(struct tpg_data *tpg,
bool show_square)
{
tpg->show_square = show_square;
}
static inline void tpg_s_insert_sav(struct tpg_data *tpg, bool insert_sav)
{
tpg->insert_sav = insert_sav;
}
static inline void tpg_s_insert_eav(struct tpg_data *tpg, bool insert_eav)
{
tpg->insert_eav = insert_eav;
}
void tpg_update_mv_step(struct tpg_data *tpg);
static inline void tpg_s_mv_hor_mode(struct tpg_data *tpg,
enum tpg_move_mode mv_hor_mode)
{
tpg->mv_hor_mode = mv_hor_mode;
tpg_update_mv_step(tpg);
}
static inline void tpg_s_mv_vert_mode(struct tpg_data *tpg,
enum tpg_move_mode mv_vert_mode)
{
tpg->mv_vert_mode = mv_vert_mode;
tpg_update_mv_step(tpg);
}
static inline void tpg_init_mv_count(struct tpg_data *tpg)
{
tpg->mv_hor_count = tpg->mv_vert_count = 0;
}
static inline void tpg_update_mv_count(struct tpg_data *tpg, bool frame_is_field)
{
tpg->mv_hor_count += tpg->mv_hor_step * (frame_is_field ? 1 : 2);
tpg->mv_vert_count += tpg->mv_vert_step * (frame_is_field ? 1 : 2);
}
static inline void tpg_s_hflip(struct tpg_data *tpg, bool hflip)
{
if (tpg->hflip == hflip)
return;
tpg->hflip = hflip;
tpg_update_mv_step(tpg);
tpg->recalc_lines = true;
}
static inline bool tpg_g_hflip(const struct tpg_data *tpg)
{
return tpg->hflip;
}
static inline void tpg_s_vflip(struct tpg_data *tpg, bool vflip)
{
tpg->vflip = vflip;
}
static inline bool tpg_g_vflip(const struct tpg_data *tpg)
{
return tpg->vflip;
}
static inline bool tpg_pattern_is_static(const struct tpg_data *tpg)
{
return tpg->pattern != TPG_PAT_NOISE &&
tpg->mv_hor_mode == TPG_MOVE_NONE &&
tpg->mv_vert_mode == TPG_MOVE_NONE;
}
#endif