int main(int argc, char *argv[]) {
printf("Starting up the demo app!\n");
// initialize glut
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
// 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);
}
// auto-config the vsync rate
StereoHelper::ConfigRefreshRate(nv_ctx);
// create glut windows
glutInitWindowSize(GW, GH);
glutInitWindowPosition(500, 500);
glutCreateWindow("NVIDIA 3D Vision OpenGL on Linux Demo");
// set glut callbacks
glutIdleFunc(idle);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
// set up opengl state
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
Screenshot::Init();
// set up our 3D camera (see stereohelper.h for more documentation)
cam.type = StereoHelper::PARALLEL_AXIS_ASYMMETRIC;
cam.eye = StereoHelper::Vec3(39.0f, 53.0f, 22.0f);
cam.look = StereoHelper::Vec3(0.0f, 0.0f, 0.0f);
cam.up = StereoHelper::Vec3(0.0f, 1.0f, 0.0f);
cam.focal = 70.0f;
cam.fov = 50.0f;
cam.iod = cam.focal / 30.0f;
cam.near = 1.0f;
cam.far = 200.0f;
// off we go!
glutMainLoop();
// clean up usb emitter
nvstusb_deinit(nv_ctx);
return EXIT_SUCCESS;
}
/* 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);
}
