mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2025-06-07 17:44:04 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #11633 from alalek:issue_10546

Browse Source
This commit is contained in:
Alexander Alekhin 2018-05-31 15:08:45 +00:00
commit 58d47ae9c8
1 changed files with 682 additions and 708 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

116
modules/videoio/src/cap_v4l.cpp
View File

@ -265,8 +265,6 @@ struct buffer
size_t length;
};
static unsigned int n_buffers = 0;
struct CvCaptureCAM_V4L CV_FINAL : public CvCapture
{
int deviceHandle;
@ -347,43 +345,10 @@ static int icvSetPropertyCAM_V4L( CvCaptureCAM_V4L* capture, int property_id,
/*********************** Implementations ***************************************/
static int numCameras = 0;
static int indexList = 0;
CvCaptureCAM_V4L::~CvCaptureCAM_V4L() {
icvCloseCAM_V4L(this);
}
/* Simple test program: Find number of Video Sources available.
Start from 0 and go to MAX_CAMERAS while checking for the device with that name.
If it fails on the first attempt of /dev/video0, then check if /dev/video is valid.
Returns the global numCameras with the correct value (we hope) */
static void icvInitCapture_V4L() {
int deviceHandle;
int CameraNumber;
char deviceName[MAX_DEVICE_DRIVER_NAME];
CameraNumber = 0;
while(CameraNumber < MAX_CAMERAS) {
/* Print the CameraNumber at the end of the string with a width of one character */
sprintf(deviceName, "/dev/video%1d", CameraNumber);
/* Test using an open to see if this new device name really does exists. */
deviceHandle = open(deviceName, O_RDONLY);
if (deviceHandle != -1) {
/* This device does indeed exist - add it to the total so far */
// add indexList
indexList|=(1 << CameraNumber);
numCameras++;
}
if (deviceHandle != -1)
close(deviceHandle);
/* Set up to test the next /dev/video source in line */
CameraNumber++;
} /* End while */
}; /* End icvInitCapture_V4L */
static bool try_palette_v4l2(CvCaptureCAM_V4L* capture)
{
capture->form = v4l2_format();
@ -690,7 +655,7 @@ static int _capture_V4L2 (CvCaptureCAM_V4L *capture)
unsigned int buffer_number = capture->bufferSize;
try_again:
try_again:
capture->req.count = buffer_number;
capture->req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
@ -726,7 +691,7 @@ static int _capture_V4L2 (CvCaptureCAM_V4L *capture)
}
}
for (n_buffers = 0; n_buffers < capture->req.count; ++n_buffers)
for (unsigned int n_buffers = 0; n_buffers < capture->req.count; ++n_buffers)
{
v4l2_buffer buf = v4l2_buffer();
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
@ -785,39 +750,48 @@ static bool v4l2_reset( CvCaptureCAM_V4L* capture) {
bool CvCaptureCAM_V4L::open(int _index)
{
int autoindex = 0;
char _deviceName[MAX_DEVICE_DRIVER_NAME];
if (!numCameras)
icvInitCapture_V4L(); /* Haven't called icvInitCapture yet - do it now! */
if (!numCameras)
return false; /* Are there any /dev/video input sources? */
//search index in indexList
if ( (_index>-1) && ! ((1 << _index) & indexList) )
{
fprintf( stderr, "VIDEOIO ERROR: V4L: index %d is not correct!\n",_index);
return false; /* Did someone ask for not correct video source number? */
}
cv::String name;
/* Select camera, or rather, V4L video source */
if (_index<0) { // Asking for the first device available
for (; autoindex<MAX_CAMERAS;autoindex++)
if (indexList & (1<<autoindex))
if (_index < 0) // Asking for the first device available
{
for (int autoindex = 0; autoindex < MAX_CAMERAS; ++autoindex)
{
name = cv::format("/dev/video%d", autoindex);
/* Test using an open to see if this new device name really does exists. */
int h = ::open(name.c_str(), O_RDONLY);
if (h != -1)
{
::close(h);
_index = autoindex;
break;
if (autoindex==MAX_CAMERAS)
}
}
if (_index < 0)
{
fprintf(stderr, "VIDEOIO ERROR: V4L: can't find camera device\n");
name.clear();
return false;
_index=autoindex;
autoindex++;// i can recall icvOpenCAM_V4l with index=-1 for next camera
}
}
else
{
name = cv::format("/dev/video%d", _index);
}
/* Print the CameraNumber at the end of the string with a width of one character */
sprintf(_deviceName, "/dev/video%1d", _index);
return open(_deviceName);
bool res = open(name.c_str());
if (!res)
{
fprintf(stderr, "VIDEOIO ERROR: V4L: can't open camera by index %d\n", _index);
}
return res;
}
bool CvCaptureCAM_V4L::open(const char* _deviceName)
{
#ifndef NDEBUG
fprintf(stderr, "(DEBUG) V4L: opening %s\n", _deviceName);
#endif
FirstCapture = 1;
width = DEFAULT_V4L_WIDTH;
height = DEFAULT_V4L_HEIGHT;
@ -1014,13 +988,13 @@ move_411_block(int yTL, int yTR, int yBL, int yBR, int u, int v,
int r, g, b;
g = guScale * u + gvScale * v;
// if (force_rgb) {
// r = buScale * u;
// b = rvScale * v;
// } else {
// if (force_rgb) {
// r = buScale * u;
// b = rvScale * v;
// } else {
r = rvScale * v;
b = buScale * u;
// }
// }
yTL *= yScale; yTR *= yScale;
yBL *= yScale; yBR *= yScale;
@ -1325,7 +1299,7 @@ static int init_done = 0;
Each entry at index x in the table represents the codeword
present at the MSB of byte x.
*/
*/
static void sonix_decompress_init(void)
{
int i;
@ -1403,7 +1377,7 @@ static void sonix_decompress_init(void)
Returns 0 if the operation was successful.
Returns <0 if operation failed.
*/
*/
static int sonix_decompress(int width, int height, unsigned char *inp, unsigned char *outp)
{
int row, col;
@ -1859,13 +1833,13 @@ static void icvCloseCAM_V4L( CvCaptureCAM_V4L* capture ){
perror ("Unable to stop the stream");
}
for (unsigned int n_buffers_ = 0; n_buffers_ < MAX_V4L_BUFFERS; ++n_buffers_)
for (unsigned int n_buffers = 0; n_buffers < MAX_V4L_BUFFERS; ++n_buffers)
{
if (capture->buffers[n_buffers_].start) {
if (-1 == munmap (capture->buffers[n_buffers_].start, capture->buffers[n_buffers_].length)) {
if (capture->buffers[n_buffers].start) {
if (-1 == munmap (capture->buffers[n_buffers].start, capture->buffers[n_buffers].length)) {
perror ("munmap");
} else {
capture->buffers[n_buffers_].start = 0;
capture->buffers[n_buffers].start = 0;
}
}
}