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
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 %03x %04x", (id>>28)&0xf, |
|
V4L2_CTRL_ID2CLASS(id)>>16, id&0xffff); |
|
|
|
} |
|
/* --------------------------------------------------------------------- */ |
|
int pr_v4l2_control(char *txt, struct v4l2_control *ptr) |
|
{ |
|
|
|
return -1; |
|
} |
|
/* --------------------------------------------------------------------- */
|
|
|