void RealSenseDriver::Start(int vid, int pid, char* sn) { //The RealSense camera is capable of delivering separate streams for rgb and depth at separate resolutions //For now, use 640x480@30fps for each one //There are separate streams defined for depth using non-standard UVC GUIDs - use the YUYV-advertised GUID, which is really just //gray16 data width_ = 640; height_ = 480; fps_ = 30; if(ctx_) { Stop(); } uvc_init(&ctx_, NULL); if(!ctx_) { throw DeviceException("Unable to open UVC library context"); } uvc_error_t find_err; if (sn) find_err = uvc_find_device(ctx_, &dev_, vid, pid, sn ); else find_err = uvc_find_device(ctx_, &dev_, vid, pid, NULL); if (find_err != UVC_SUCCESS) { uvc_perror(find_err, "uvc_find_device"); throw DeviceException("Unable to open RealSense device"); } if(!dev_) { throw DeviceException("Unable to open RealSense Device - no pointer returned."); } uvc_error_t open_err = uvc_open2(dev_, &devh_rgb, 0); //Camera 0 is RGB if (open_err != UVC_SUCCESS) { uvc_perror(open_err, "uvc_open"); uvc_unref_device(dev_); throw DeviceException("Unable to open RealSense RGB device"); } open_err = uvc_open2(dev_, &devh_d, 1); //Camera 1 is depth if (open_err != UVC_SUCCESS) { uvc_perror(open_err, "uvc_open"); uvc_unref_device(dev_); throw DeviceException("Unable to open RealSense Depth device"); } // uvc_set_status_callback(devh_, &CameraDriver::AutoControlsCallbackAdapter, this); uvc_error_t mode_err = uvc_get_stream_ctrl_format_size( devh_rgb, &ctrl_rgb, UVC_COLOR_FORMAT_YUYV, width_, height_, 60); pbtype_rgb = pb::PB_UNSIGNED_BYTE; pbformat_rgb = pb::PB_RGB; if (mode_err != UVC_SUCCESS) { uvc_perror(mode_err, "uvc_get_stream_ctrl_format_size"); uvc_close(devh_rgb); uvc_close(devh_d); uvc_unref_device(dev_); throw DeviceException("Unable to get RGB device mode."); } //Use the same frame parameters for both RGB and depth (for now) if (useIR) { //Depth as mono8 mode_err = uvc_get_stream_ctrl_format_size( devh_d, &ctrl_d, UVC_FRAME_FORMAT_INVI, width_, height_, fps_); pbtype_d = pb::PB_UNSIGNED_BYTE; } else { //Grayscale depth as yuyv, mono16 mode_err = uvc_get_stream_ctrl_format_size( devh_d, &ctrl_d, //UVC_FRAME_FORMAT_INVI, UVC_FRAME_FORMAT_YUYV, width_, height_, fps_); pbtype_d = pb::PB_UNSIGNED_SHORT; } pbformat_d = pb::PB_LUMINANCE; if (mode_err != UVC_SUCCESS) { uvc_perror(mode_err, "uvc_get_stream_ctrl_format_size"); uvc_close(devh_rgb); uvc_close(devh_d); uvc_unref_device(dev_); throw DeviceException("Unable to get depth device mode."); } uvc_error_t stream_ctl_err = uvc_stream_open_ctrl(devh_rgb, &streamh_rgb, &ctrl_rgb); if (stream_ctl_err != UVC_SUCCESS) { uvc_perror(stream_ctl_err, "uvc_stream_open_ctrl"); uvc_close(devh_rgb); uvc_close(devh_d); uvc_unref_device(dev_); throw DeviceException("Unable to open stream on RGB."); } stream_ctl_err = uvc_stream_open_ctrl(devh_d, &streamh_d, &ctrl_d); if (stream_ctl_err != UVC_SUCCESS) { uvc_perror(stream_ctl_err, "uvc_stream_open_ctrl"); uvc_close(devh_rgb); uvc_close(devh_d); uvc_unref_device(dev_); throw DeviceException("Unable to open stream on depth."); } uvc_error_t stream_start_err = uvc_stream_start(streamh_rgb, NULL, this, 0); if (stream_start_err != UVC_SUCCESS) { uvc_perror(stream_start_err, "uvc_stream_start"); uvc_close(devh_rgb); uvc_close(devh_d); uvc_unref_device(dev_); throw DeviceException("Unable to start streaming on rgb."); } stream_start_err = uvc_stream_start(streamh_d, NULL, this, 0); if (stream_start_err != UVC_SUCCESS) { uvc_perror(stream_start_err, "uvc_stream_start"); uvc_close(devh_rgb); uvc_close(devh_d); uvc_unref_device(dev_); throw DeviceException("Unable to start streaming on depth."); } if (frame_rgb) uvc_free_frame(frame_rgb); if (frame_d) uvc_free_frame(frame_d); frame_rgb = uvc_allocate_frame(ctrl_rgb.dwMaxVideoFrameSize); if(!frame_rgb) { throw DeviceException("Unable to allocate RGB frame."); } frame_d = uvc_allocate_frame(ctrl_d.dwMaxVideoFrameSize); if(!frame_d) { throw DeviceException("Unable to allocate depth frame."); } if (useSync) { std::cout << "RealSense: Using SCR to sync" << std::endl; } }
/* responsible for a specific uvc device.*/ libuvc_uvc_device(const uvc_device_info& info) : _name(""), _info(), _is_capturing(false) { uvc_error_t res; // init libUVC res = uvc_init(&_ctx, NULL); if (res < 0) { throw linux_backend_exception("fail to initialize libuvc"); } // search the device in device list. foreach_uvc_device(_ctx, [&info, this](const uvc_device_info& i, const std::string& name) { if (i == info) { _name = name; _info = i; _device_path = i.device_path; _interface = i.mi; } }); if (_name == "") throw linux_backend_exception("device is no longer connected!"); }
bool CameraDriver::Start() { assert(state_ == kInitial); uvc_error_t err; err = uvc_init(&ctx_, NULL); if (err != UVC_SUCCESS) { uvc_perror(err, "ERROR: uvc_init"); return false; } state_ = kStopped; config_server_.setCallback(boost::bind(&CameraDriver::ReconfigureCallback, this, _1, _2)); return state_ == kRunning; }
/* query UVC devices on the system */ std::vector<uvc_device_info> query_uvc_devices() const override { uvc_error_t res; uvc_context_t *ctx; // init libUVC. res = uvc_init(&ctx, NULL); if (res < 0) { throw linux_backend_exception("fail to initialize libuvc"); } // build a list of uvc devices. std::vector<uvc_device_info> results; libuvc_uvc_device::foreach_uvc_device(ctx, [&results](const uvc_device_info& i, const std::string&) { results.push_back(i); }); uvc_exit(ctx); return results; }
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; }
void UvcDriver::Start(int vid, int pid, char* sn) { width_ = 640; height_ = 480; fps_ = 30; if(ctx_) { Stop(); } uvc_init(&ctx_, NULL); if(!ctx_) { throw DeviceException("Unable to open UVC Context"); } uvc_error_t find_err = uvc_find_device(ctx_, &dev_, vid, pid, sn ); if (find_err != UVC_SUCCESS) { uvc_perror(find_err, "uvc_find_device"); throw DeviceException("Unable to open UVC Device"); } if(!dev_) { throw DeviceException("Unable to open UVC Device - no pointer returned."); } uvc_error_t open_err = uvc_open(dev_, &devh_); if (open_err != UVC_SUCCESS) { uvc_perror(open_err, "uvc_open"); uvc_unref_device(dev_); throw DeviceException("Unable to open device"); } // uvc_set_status_callback(devh_, &CameraDriver::AutoControlsCallbackAdapter, this); uvc_stream_ctrl_t ctrl; uvc_error_t mode_err = uvc_get_stream_ctrl_format_size( devh_, &ctrl, UVC_COLOR_FORMAT_YUYV, width_, height_, fps_); pbtype = hal::PB_UNSIGNED_BYTE; pbformat = hal::PB_LUMINANCE; if (mode_err != UVC_SUCCESS) { uvc_perror(mode_err, "uvc_get_stream_ctrl_format_size"); uvc_close(devh_); uvc_unref_device(dev_); throw DeviceException("Unable to device mode."); } // uvc_error_t stream_err = uvc_start_iso_streaming(devh_, &ctrl, &UvcDriver::ImageCallbackAdapter, this); //uvc_error_t stream_err = uvc_start_iso_streaming(devh_, &ctrl, NULL, this); uvc_error_t stream_err = uvc_start_streaming(devh_, &ctrl, NULL, this, 0); if (stream_err != UVC_SUCCESS) { uvc_perror(stream_err, "uvc_start_iso_streaming"); uvc_close(devh_); uvc_unref_device(dev_); throw DeviceException("Unable to start iso streaming."); } if (frame_) uvc_free_frame(frame_); frame_ = uvc_allocate_frame(ctrl.dwMaxVideoFrameSize); if(!frame_) { throw DeviceException("Unable to allocate frame."); } }
context() : ctx() { check("uvc_init", uvc_init(&ctx, nullptr)); }