301 lines
9.5 KiB
C
301 lines
9.5 KiB
C
/*
|
|
* fonctions pour afficher les structures de V4L2
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <inttypes.h>
|
|
#include <linux/videodev2.h>
|
|
|
|
#include "v4l2_pr_structs.h"
|
|
|
|
#define FP (stdout)
|
|
|
|
extern int verbosity;
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
static char *fmttype2str(int type)
|
|
{
|
|
|
|
switch(type) {
|
|
case 0: return "[zero]";
|
|
case V4L2_BUF_TYPE_VIDEO_CAPTURE: return "video capture";
|
|
case V4L2_BUF_TYPE_VIDEO_OUTPUT: return "video output";
|
|
|
|
case 13: return "META capture";
|
|
}
|
|
|
|
return "XXX";
|
|
}
|
|
/* --------------------------------------------------------------------- */
|
|
static void pr_capabilities(uint32_t caps)
|
|
{
|
|
fputs(" ", FP);
|
|
|
|
if (caps & V4L2_CAP_VIDEO_CAPTURE) fputs("vcapt ", FP);
|
|
if (caps & V4L2_CAP_VIDEO_OUTPUT) fputs("vout ", FP);
|
|
if (caps & V4L2_CAP_VIDEO_OVERLAY) fputs("overlay ", FP);
|
|
if (caps & V4L2_CAP_VBI_CAPTURE) fputs("vbicapt ", FP);
|
|
if (caps & V4L2_CAP_VBI_OUTPUT) fputs("vbiout ", FP);
|
|
|
|
/* to be continued */
|
|
|
|
if (caps & V4L2_CAP_AUDIO) fputs("audio ", FP);
|
|
|
|
|
|
if (caps & V4L2_CAP_SDR_CAPTURE) fputs("sdrcapt ", FP);
|
|
if (caps & V4L2_CAP_EXT_PIX_FORMAT) fputs("extpix ", FP);
|
|
if (caps & V4L2_CAP_SDR_OUTPUT) fputs("sdrout ", FP);
|
|
|
|
|
|
|
|
|
|
if (caps & V4L2_CAP_READWRITE) fputs("rwsysc ", FP);
|
|
if (caps & V4L2_CAP_ASYNCIO) fputs("asyncio ", FP);
|
|
if (caps & V4L2_CAP_STREAMING) fputs("stream ", FP);
|
|
|
|
|
|
fputs("\n", FP);
|
|
}
|
|
/* --------------------------------------------------------------------- */
|
|
int pr_v4l2_capability(char *txt, struct v4l2_capability *ptr)
|
|
{
|
|
fprintf(FP, "## v4l2_capability, %-15s %p\n", txt, ptr);
|
|
|
|
fprintf(FP, " driver %s\n", ptr->driver);
|
|
fprintf(FP, " card %s\n", ptr->card);
|
|
fprintf(FP, " bus info %s\n", ptr->bus_info);
|
|
|
|
fprintf(FP, " version 0x%X\n", ptr->version);
|
|
fprintf(FP, " capabilities 0x%X\n", ptr->capabilities);
|
|
pr_capabilities(ptr->capabilities);
|
|
fprintf(FP, " device caps 0x%X\n", ptr->device_caps);
|
|
|
|
return -1;
|
|
}
|
|
/* --------------------------------------------------------------------- */
|
|
/*
|
|
* warning, this function return a pointer to a static
|
|
* strint, so it was NOT reentrant !
|
|
*/
|
|
char *str_fourcc(uint32_t fcc)
|
|
{
|
|
static char chaine[10];
|
|
|
|
chaine[0] = '['; chaine[5] = ']'; chaine[6] = '\0';
|
|
chaine[1] = (fcc>>0) & 0xff;
|
|
chaine[2] = (fcc>>8) & 0xff;
|
|
chaine[3] = (fcc>>16) & 0xff;
|
|
chaine[4] = (fcc>>24) & 0xff;
|
|
|
|
return chaine;
|
|
}
|
|
/* --------------------------------------------------------------------- */
|
|
char *str_buf_type(int type)
|
|
{
|
|
switch (type) {
|
|
case V4L2_BUF_TYPE_VIDEO_CAPTURE: return "vidcapt";
|
|
case V4L2_BUF_TYPE_VIDEO_OUTPUT: return "vidout";
|
|
case V4L2_BUF_TYPE_VIDEO_OVERLAY: return "vidovrl";
|
|
case V4L2_BUF_TYPE_VBI_CAPTURE: return "vbicapt";
|
|
case V4L2_BUF_TYPE_VBI_OUTPUT: return "vbicapt";
|
|
case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE: return "slicevcapt";
|
|
case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT: return "slicevout";
|
|
case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY: return "v-outover";
|
|
case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: return "v-captmpla";
|
|
case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: return "v-outmpla";
|
|
case V4L2_BUF_TYPE_SDR_CAPTURE: return "sdrcapt";
|
|
case V4L2_BUF_TYPE_SDR_OUTPUT: return "sdrout";
|
|
/* Deprecated, do not use */
|
|
case V4L2_BUF_TYPE_PRIVATE: return "private";
|
|
|
|
}
|
|
|
|
return "???";
|
|
}
|
|
/* --------------------------------------------------------------------- */
|
|
int pr_v4l2_fmtdesc(char *txt, struct v4l2_fmtdesc *ptr)
|
|
{
|
|
fprintf(FP, "## v4l2_fmtdesc, %-15s %p\n", txt, ptr);
|
|
|
|
fprintf(FP, " index %d\n", ptr->index);
|
|
fprintf(FP, " type %d\n", ptr->type); /* enum v4l2_buf_type */
|
|
fprintf(FP, " flags 0x%X\n", ptr->flags);
|
|
fprintf(FP, " description %s\n", ptr->description);
|
|
fprintf(FP, " pixel format 0x%X\n", ptr->pixelformat); /* FOURCC */
|
|
|
|
return -1;
|
|
}
|
|
/* --------------------------------------------------------------------- */
|
|
char *str_input_type(int t)
|
|
{
|
|
switch (t) {
|
|
case V4L2_INPUT_TYPE_TUNER: return "tuner";
|
|
case V4L2_INPUT_TYPE_CAMERA: return "camera";
|
|
case V4L2_INPUT_TYPE_TOUCH: return "touch";
|
|
}
|
|
return "???";
|
|
}
|
|
/* --------------------------------------------------------------------- */
|
|
static void pr_input_status(uint32_t st)
|
|
{
|
|
if (st & V4L2_IN_ST_NO_POWER) fputs("nopow ", FP);
|
|
if (st & V4L2_IN_ST_NO_SIGNAL) fputs("nosig ", FP);
|
|
if (st & V4L2_IN_ST_NO_COLOR) fputs("nocol ", FP);
|
|
|
|
if (st & V4L2_IN_ST_HFLIP) fputs("hflip ", FP);
|
|
if (st & V4L2_IN_ST_VFLIP) fputs("vflip ", FP);
|
|
|
|
if (st & V4L2_IN_ST_NO_H_LOCK) fputs("nohlck ", FP);
|
|
if (st & V4L2_IN_ST_COLOR_KILL) fputs("colkil ", FP);
|
|
if (st & V4L2_IN_ST_NO_V_LOCK) fputs("novlck ", FP);
|
|
if (st & V4L2_IN_ST_NO_STD_LOCK) fputs("nostdlk ", FP);
|
|
|
|
if (st & V4L2_IN_ST_NO_EQU) fputs("noequ ", FP);
|
|
if (st & V4L2_IN_ST_NO_CARRIER) fputs("nocarr ", FP);
|
|
|
|
if (st & V4L2_IN_ST_MACROVISION) fputs("macrov ", FP);
|
|
if (st & V4L2_IN_ST_NO_ACCESS) fputs("noacces ", FP);
|
|
if (st & V4L2_IN_ST_VTR) fputs("VTR ", FP);
|
|
|
|
/* to be continued ?*/
|
|
}
|
|
/* --------------------------------------------------------------------- */
|
|
static void pr_input_capabilities(uint32_t st)
|
|
{
|
|
if (st & V4L2_IN_CAP_DV_TIMINGS) fputs("DVtime ", FP);
|
|
if (st & V4L2_IN_CAP_STD) fputs("s_std ", FP);
|
|
if (st & V4L2_IN_CAP_NATIVE_SIZE) fputs("nativsz ", FP);
|
|
|
|
}
|
|
/* --------------------------------------------------------------------- */
|
|
int pr_v4l2_input(char *txt, struct v4l2_input *ptr)
|
|
{
|
|
fprintf(FP, "## v4l2_input, %-15s %p\n", txt, ptr);
|
|
|
|
fprintf(FP, " index %d\n", ptr->index);
|
|
fprintf(FP, " name %s\n", ptr->name);
|
|
fprintf(FP, " type %d %s\n", ptr->type,
|
|
str_input_type(ptr->type));
|
|
fprintf(FP, " audioset 0x%X\n", ptr->audioset);
|
|
fprintf(FP, " tuner 0x%X\n", ptr->tuner);
|
|
/* XXX v4l2_std_id std; */
|
|
fprintf(FP, " status 0x%X\n", ptr->status);
|
|
if (ptr->status) {
|
|
fputs(" ",FP);
|
|
pr_input_status(ptr->status);
|
|
fputs("\n",FP);
|
|
}
|
|
fprintf(FP, " capabilities 0x%X\n", ptr->capabilities);
|
|
if (ptr->capabilities) {
|
|
fputs(" ",FP);
|
|
pr_input_capabilities(ptr->capabilities);
|
|
fputs("\n",FP);
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
/* --------------------------------------------------------------------- */
|
|
char * str_colorspace(int colspace)
|
|
{
|
|
switch(colspace) {
|
|
case V4L2_COLORSPACE_DEFAULT: return "default";
|
|
case V4L2_COLORSPACE_SMPTE170M: return "smpte170m";
|
|
case V4L2_COLORSPACE_SMPTE240M: return "smpte240m";
|
|
case V4L2_COLORSPACE_REC709: return "rec709";
|
|
case V4L2_COLORSPACE_BT878: return "bt878";
|
|
case V4L2_COLORSPACE_470_SYSTEM_M: return "470-sys-M";
|
|
case V4L2_COLORSPACE_470_SYSTEM_BG: return "470-sys-BG";
|
|
case V4L2_COLORSPACE_JPEG: return "jpeg";
|
|
case V4L2_COLORSPACE_SRGB: return "srgb";
|
|
case V4L2_COLORSPACE_ADOBERGB: return "adobergb";
|
|
case V4L2_COLORSPACE_BT2020: return "bt2020";
|
|
case V4L2_COLORSPACE_RAW: return "raw";
|
|
case V4L2_COLORSPACE_DCI_P3: return "dci-p3";
|
|
}
|
|
|
|
return "???";
|
|
}
|
|
/* --------------------------------------------------------------------- */
|
|
int pr_v4l2_format(char *txt, struct v4l2_format *ptr)
|
|
{
|
|
fprintf(FP, "## v4l2_format, %-15s, %p\n", txt, ptr);
|
|
fprintf(FP, " type %d %s\n", ptr->type,/* enum v4l2_buf_type */
|
|
fmttype2str(ptr->type));
|
|
|
|
switch(ptr->type) {
|
|
|
|
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
|
|
fprintf(FP, " dims %dx%d\n",
|
|
ptr->fmt.pix.width,
|
|
ptr->fmt.pix.height);
|
|
fprintf(FP, " pixformat %s\n",
|
|
str_fourcc(ptr->fmt.pix.pixelformat));
|
|
fprintf(FP, " field %d\n",
|
|
ptr->fmt.pix.field); /* enum v4l2_field */
|
|
fprintf(FP, " padding %d\n",
|
|
ptr->fmt.pix.bytesperline);
|
|
fprintf(FP, " sizeimage %d\n",
|
|
ptr->fmt.pix.sizeimage);
|
|
fprintf(FP, " colorspace %d %s\n",
|
|
ptr->fmt.pix.colorspace,
|
|
str_colorspace(ptr->fmt.pix.colorspace));
|
|
break;
|
|
|
|
default: fprintf(FP, "XXX type %d unknow\n", ptr->type);
|
|
break;
|
|
|
|
}
|
|
return 0;
|
|
}
|
|
/* --------------------------------------------------------------------- */
|
|
int pr_v4l2_requestbuffers(char *txt, struct v4l2_requestbuffers *ptr)
|
|
{
|
|
fprintf(FP, "## v4l2_requestbuffers, %s %p\n", txt, ptr);
|
|
fprintf(FP, " type %d\n", ptr->type); /* enum v4l2_buf_type */
|
|
|
|
|
|
return 0;
|
|
}
|
|
/* --------------------------------------------------------------------- */
|
|
char *str_ctrl_type(int type)
|
|
{
|
|
switch (type) {
|
|
case V4L2_CTRL_TYPE_INTEGER: return "integer";
|
|
case V4L2_CTRL_TYPE_BOOLEAN: return "boolean";
|
|
case V4L2_CTRL_TYPE_MENU: return "menu";
|
|
case V4L2_CTRL_TYPE_BUTTON: return "button";
|
|
case V4L2_CTRL_TYPE_INTEGER64: return "int64";
|
|
case V4L2_CTRL_TYPE_CTRL_CLASS: return "ctrl-class";
|
|
case V4L2_CTRL_TYPE_STRING: return "string";
|
|
case V4L2_CTRL_TYPE_BITMASK: return "bitmask";
|
|
case V4L2_CTRL_TYPE_INTEGER_MENU: return "int-menu";
|
|
}
|
|
|
|
return "???";
|
|
}
|
|
/* --------------------------------------------------------------------- */
|
|
/*
|
|
The 32-bit qctrl.id value is subdivided into three bit ranges:
|
|
the top 4 bits are reserved for flags (e. g. V4L2_CTRL_FLAG_NEXT_CTRL)
|
|
and are not actually part of the ID.
|
|
The remaining 28 bits form the control ID, of which the most significant
|
|
12 bits define the control class and the least significant
|
|
16 bits identify the control within the control class.
|
|
*/
|
|
void pr_ctrl_id(uint32_t id)
|
|
{
|
|
|
|
if (verbosity>1) fprintf(FP, "%08x : ", id);
|
|
|
|
fprintf(FP, "%x %03lx %04x", (id>>28)&0xf,
|
|
V4L2_CTRL_ID2CLASS(id)>>16, id&0xffff);
|
|
|
|
}
|
|
/* --------------------------------------------------------------------- */
|
|
int pr_v4l2_control(char *txt, struct v4l2_control *ptr)
|
|
{
|
|
|
|
return -1;
|
|
}
|
|
/* --------------------------------------------------------------------- */
|