int main(int argc, char **argv) {
uvc_context_t *ctx;
uvc_device_t *dev;
uvc_device_handle_t *devh;
uvc_stream_ctrl_t ctrl;
uvc_error_t res;
uvc_device_t **list;
/* Initialize a UVC service context. Libuvc will set up its own libusb
* context. Replace NULL with a libusb_context pointer to run libuvc
* from an existing libusb context. */
res = uvc_init(&ctx, NULL);
if (res < 0) {
uvc_perror(res, "uvc_init");
return res;
}
puts("UVC initialized");
res = uvc_get_device_list(ctx, &list);
if (res < 0) {
uvc_perror(res, "uvc_get_device_list");
return res;
}
/* for(int i = 0; i < 1; i++) {
res = uvc_open(list[i], &devh);
uvc_print_diag(devh, stderr);
uvc_close(devh);
}
uchar x;
uvc_free_device_list(list, x);
*/
/* Locates the first attached UVC device, stores in dev */
res = uvc_find_device(
ctx, &dev,
0, 0, NULL); /* filter devices: vendor_id, product_id, "serial_num" */
if (res < 0) {
uvc_perror(res, "uvc_find_device"); /* no devices found */
} else {
puts("Device found");
/* Try to open the device: requires exclusive access */
res = uvc_open(dev, &devh);
if (res < 0) {
uvc_perror(res, "uvc_open"); /* unable to open device */
printf("Unable to open device");
} else {
puts("Device opened");
/* Print out a message containing all the information that libuvc
* knows about the device */
uvc_print_diag(devh, stderr);
/* Try to negotiate a 640x480 30 fps YUYV stream profile */
res = uvc_get_stream_ctrl_format_size(
devh, &ctrl, /* result stored in ctrl */
UVC_FRAME_FORMAT_YUYV, /* YUV 422, aka YUV 4:2:2. try _COMPRESSED */
640, 480, 30 /* width, height, fps */
);
/* Print out the result */
uvc_print_stream_ctrl(&ctrl, stderr);
if (res < 0) {
uvc_perror(res, "get_mode"); /* device doesn't provide a matching stream */
} else {
/* Start the video stream. The library will call user function cb:
* cb(frame, (void*) 12345)
*/
res = uvc_start_streaming(devh, &ctrl, cb, (void*)12345, 0);
if (res < 0) {
uvc_perror(res, "start_streaming"); /* unable to start stream */
} else {
puts("Streaming...");
uvc_set_ae_mode(devh, 0); /* e.g., turn on auto exposure */
sleep(10); /* stream for 10 seconds */
/* End the stream. Blocks until last callback is serviced */
uvc_stop_streaming(devh);
puts("Done streaming.");
}
}
/* Release our handle on the device */
uvc_close(devh);
puts("Device closed");
}
/* Release the device descriptor */
uvc_unref_device(dev);
}
/* Close the UVC context. This closes and cleans up any existing device handles,
* and it closes the libusb context if one was not provided. */
uvc_exit(ctx);
puts("UVC exited");
return 0;
}
static void foreach_uvc_device(uvc_context_t *ctx,
std::function<void(
const uvc_device_info &info,
const std::string&)> action)
{
uvc_error_t res;
uvc_device_t **device_list;
uvc_device_internal *dev;
uvc_device_info info;
uvc_device_descriptor_t *device_desc;
// get all uvc devices.
res = uvc_get_device_list(ctx, &device_list);
if (res < 0) {
throw linux_backend_exception("fail to get uvc device list.");
}
int i = 0;
// iterate over all devices.
while (device_list[i] != NULL) {
// get the internal device object so we can use the libusb handle.
dev = (uvc_device_internal *) device_list[i];
// set up the unique id for the device.
info.unique_id = get_usb_port_id(dev->usb_dev);
// get device descriptor.
res = uvc_get_device_descriptor((uvc_device_t *)dev, &device_desc);
if ( res < 0) {
uvc_free_device_list(device_list, 0);
throw linux_backend_exception("fail to get device descriptor");
}
// set up device definitions.
info.pid = device_desc->idProduct;
info.vid = device_desc->idVendor;
info.mi = dev->interface-1;
uvc_free_device_descriptor(device_desc);
// declare this device to the caller.
action(info, "Intel Camera");
// this code was used for the sr300 version.
/* libusb_config_descriptor *config;
int status = libusb_get_active_config_descriptor(dev->usb_dev, &config);
if (config->bNumInterfaces >= 2)
{
info.mi = 2;
action(info, "depth");
}
libusb_free_config_descriptor(config);*/
i++;
}
uvc_free_device_list(device_list, 0);
}
