/* Main function */
int main(int argc, char **argv)
{
Display *dpy;
Window win;
uint i_swap_cnt = 0;
char const * config_fw = NULL;
/* Getopt section */
struct option long_options[] =
{
/* These options set a flag. */
{NULL, 0, 0, 0}
};
while (1)
{
int c;
/* getopt_long stores the option index here. */
int option_index = 0;
c = getopt_long (argc, argv, "",
long_options, &option_index);
/* Detect the end of the options. */
if (c == -1)
break;
switch (c)
{
case '?':
default:
usage();
exit(EXIT_FAILURE);
}
}
if (optind < argc)
{
while (optind < argc) {
config_fw = argv[optind++];
}
}
/* Openning X display */
dpy = XOpenDisplay(0);
/* Preparing new X window */
Window s_window;
static int attributeList[] =
{ GLX_RGBA,
GLX_DOUBLEBUFFER,
GLX_RED_SIZE,
1,
GLX_GREEN_SIZE,
1,
GLX_BLUE_SIZE,
1,
None };
XVisualInfo *vi = glXChooseVisual(dpy, DefaultScreen(dpy), attributeList);
s_window = RootWindow(dpy, vi->screen);
XSetWindowAttributes swa;
swa.colormap = XCreateColormap(dpy, s_window, vi->visual, AllocNone);
swa.override_redirect = 1;
/* Create X window 1x1 top left of screen */
win = XCreateWindow(dpy,
s_window ,
0,
0,
1,
1,
0,
vi->depth,
InputOutput,
vi->visual,
CWColormap|CWOverrideRedirect,
&swa);
XMapWindow(dpy, win);
/* Create glX context */
GLXContext glx_ctx = glXCreateContext(dpy, vi, 0, 1);
glXMakeCurrent(dpy, win, glx_ctx);
/* Initialize libnvstusb */
ctx = nvstusb_init(config_fw);
if (0 == ctx) {
fprintf(stderr, "could not initialize NVIDIA 3D Stereo Controller, aborting\n");
exit(EXIT_FAILURE);
}
/* Get Vsync rate from X11 */
XF86VidModeModeLine modeline;
int pixelclock;
XF86VidModeGetModeLine( dpy, DefaultScreen(dpy), &pixelclock, &modeline );
double frameRate=(double) pixelclock*1000/modeline.htotal/modeline.vtotal;
printf("Vertical Refresh rate:%f Hz\n",frameRate);
nvstusb_set_rate(ctx, frameRate);
/* Loop until stop */
while (1) {
/* Send swap to usb controler */
nvstusb_swap(ctx, nvstusb_quad, NULL /*f_swap*/);
/* Read status from usb controler */
if(!(i_swap_cnt&0xF)) {
struct nvstusb_keys k;
nvstusb_get_keys(ctx, &k);
if (k.toggled3D) {
nvstusb_invert_eyes(ctx);
}
}
i_swap_cnt++;
}
/* Destroy context */
glx_ctx = glXGetCurrentContext();
glXDestroyContext(dpy, glx_ctx);
/* Denit libnvstusb */
nvstusb_deinit(ctx);
return EXIT_SUCCESS;
}
void gl_thread::Runnable3DVision()
{
try {
assert(_vo_qt_widget->context()->isValid());
_vo_qt_widget->makeCurrent();
assert(QGLContext::currentContext() == _vo_qt_widget->context());
// initialize communications with the usb emitter
nv_ctx = nvstusb_init();
if (nv_ctx == NULL)
{
fprintf(stderr, "Could not initialize NVIDIA 3D Vision IR emitter!\n");
exit(EXIT_FAILURE);
}
Display *display = XOpenDisplay(0);
double display_num = DefaultScreen(display);
XF86VidModeModeLine mode_line;
int pixel_clk = 0;
XF86VidModeGetModeLine(display, display_num, &pixel_clk, &mode_line);
double frame_rate = (double) pixel_clk * 1000.0 / mode_line.htotal / mode_line.vtotal;
printf("Detected refresh rate of %f Hz.\n", (frame_rate));
nvstusb_set_rate(nv_ctx, frame_rate);
bool odd = false;
struct timeval start, end;
long useconds;
gettimeofday(&start, NULL);
GLuint count;
while (_render)
{
{
_wait_mutex.lock();
if (_action_activate)
{
try {
_vo_qt->video_output::activate_next_frame();
}
catch (std::exception& e) {
_e = e;
_render = false;
_failure = true;
}
_action_activate = false;
_wait_cond.wake_one();
}
_wait_mutex.unlock();
}
if (_failure)
break;
_wait_mutex.lock();
if (_action_prepare) {
try {
_vo_qt->video_output::prepare_next_frame(_next_frame, _next_subtitle);
}
catch (std::exception& e) {
_e = e;
_render = false;
_failure = true;
}
_action_prepare = false;
_wait_cond.wake_one();
}
_wait_mutex.unlock();
if (_failure)
break;
if (_w > 0 && _h > 0
&& (_vo_qt->full_display_width() != _w
|| _vo_qt->full_display_height() != _h)) {
_vo_qt->reshape(_w, _h);
}
{
_vo_qt->display_current_frame(0);
_vo_qt_widget->swapBuffers();
gettimeofday(&end, NULL);
useconds = end.tv_usec - start.tv_usec;
nvstusb_swap_eye(nv_ctx, (nvstusb_eye) (0), useconds);
gettimeofday(&start, NULL);
//glXGetVideoSyncSGI(&count);
//glXWaitVideoSyncSGI(2, (count +1)%2, &count);
_vo_qt->display_current_frame(1);
_vo_qt_widget->swapBuffers();
gettimeofday(&end, NULL);
useconds = end.tv_usec - start.tv_usec;
nvstusb_swap_eye(nv_ctx, (nvstusb_eye) (1), useconds);
gettimeofday(&start, NULL);
}
}
}
catch (std::exception& e) {
_e = e;
_render = false;
_failure = true;
}
_wait_mutex.lock();
if (_action_activate || _action_prepare)
{
while (!_action_finished)
{
_wait_cond.wake_one();
_wait_mutex.unlock();
_wait_mutex.lock();
}
}
_wait_mutex.unlock();
_vo_qt_widget->doneCurrent();
#if QT_VERSION >= 0x050000
_vo_qt_widget->context()->moveToThread(QCoreApplication::instance()->thread());
#endif
nvstusb_deinit(nv_ctx);
}