Bibliothèque de traitements d'images en virgule flottante. http://la.buvette.org/photos/cumul/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 

300 lines
9.5 KiB

/*
* 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;
}
/* --------------------------------------------------------------------- */