Example #1
0
int
camera_get_config_cam_desc (Camera *camera, CameraWidget **window,
			    GPContext *context)
{
	CameraWidget *section;
	int indw, indr;
	const CameraDescType *cam_desc = NULL;

	GP_DEBUG ("*** camera_get_config_cam_desc");
	CHECK (camera_start (camera, context));
	gp_widget_new (GP_WIDGET_WINDOW, _("Camera Configuration"), window);

	cam_desc = camera->pl->cam_desc;
	for (indw = 0; indw < 2 /* XXX sizeof () */; indw++) {
		GP_DEBUG ("%s registers", cam_desc->regset[indw].window_name);
		gp_widget_new (GP_WIDGET_SECTION,
			       _(cam_desc->regset[indw].window_name), &section);
		gp_widget_append (*window, section);
		for (indr = 0; indr < cam_desc->regset[indw].reg_cnt;  indr++) {
			camera_cam_desc_get_widget (camera,
			      &cam_desc->regset[indw].regs[indr], section,
			      context);
		}
	}
	return (GP_OK);
}
Example #2
0
void
camera_restart(void)
	{
	VideoCircularBuffer	*vcb = &video_circular_buffer;

	pthread_mutex_lock(&vcb->mutex);
	video_record_stop(vcb);
	vcb->state = VCB_STATE_RESTARTING;
	pikrellcam.camera_adjust = camera_adjust_temp;	/* May not be changed */
	pthread_mutex_unlock(&vcb->mutex);

	camera_stop();
	camera_start();
	}
Example #3
0
/* Camera initial setup */
void camera_setup () {
  imgWidth = 320;
  imgHeight = 256;
  strcpy1(imgHead, "##IMJ5");
  i2cwrite(0x30, ov9655_setup, sizeof(ov9655_setup)>>1);
  i2cwrite(0x30, ov9655_qvga, sizeof(ov9655_qvga)>>1);
  camera_init((unsigned char *)DMA_BUF1, (unsigned char *)DMA_BUF2, imgWidth, imgHeight);
  camera_start();

	/* Initialise camera-related globals */
	framecount = 0;
	overlay_flag = 1;
	quality = 3; // Default JPEG quality.
}
Example #4
0
void MainWindow::createActions()
{
    openAction = new QAction(tr("&open..."),this);
    connect(openAction,SIGNAL(triggered()),this,SLOT(open()));
    saveAction = new QAction(tr("&save..."),this);
    connect(saveAction,SIGNAL(triggered()),this,SLOT(save()));
    exitAction = new QAction(tr("&exit"), this);
    connect(exitAction, SIGNAL(triggered()),this,SLOT(exit()));

    facedetectAction = new QAction(tr("&Face Detect"),this);
    connect(facedetectAction, SIGNAL(triggered()),this,SLOT(facedetect()));
    powertfAction = new QAction(tr("&Power Transform"),this);
    connect(powertfAction, SIGNAL(triggered()),this,SLOT(powertf()));
    edgedetectAction = new QAction(tr("&Edge Detect"),this);
    connect(edgedetectAction, SIGNAL(triggered()),this,SLOT(edgedetect()));
    houghAction = new QAction(tr("&Hough Check"),this);
    connect(houghAction, SIGNAL(triggered()), this, SLOT(houghcheck()));
    morphAction = new QAction(tr("&Morphology"),this);
    connect(morphAction, SIGNAL(triggered()), this, SLOT(morphology()));
    blurAction = new QAction(tr("&Blur"),this);
    connect(blurAction, SIGNAL(triggered()), this, SLOT(bluropt()));
    histeqAction = new QAction(tr("&Histeq"),this);
    connect(histeqAction, SIGNAL(triggered()), this, SLOT(histeqopt()));

    aboutAction = new QAction(tr("&about"),this);
    connect(aboutAction, SIGNAL(triggered()),this,SLOT(about()));
    docAction = new QAction(tr("&doc"),this);
    connect(docAction, SIGNAL(triggered()),this,SLOT(doc()));

    backwardAction = new QAction(tr("&backward"),this);
    backwardAction->setIcon(QIcon(":/images/backward.png"));
    connect(backwardAction,SIGNAL(triggered()), this, SLOT(backward()));
    forwardAction = new QAction(tr("&forward"),this);
    forwardAction->setIcon(QIcon(":/images/forward.png"));
    connect(forwardAction,SIGNAL(triggered()), this, SLOT(forward()));
    camstartAction = new QAction(tr("&CAM_Start"), this);
    camstartAction->setIcon(QIcon(":/images/Start.png"));
    camstartAction->setEnabled(true);
    connect(camstartAction,SIGNAL(triggered()),this,SLOT(camera_start()));
    camstopAction = new QAction(tr("&CAM_Stop"), this);
    camstopAction->setIcon(QIcon(":/images/Stop.png"));
    camstopAction->setEnabled(false);
    connect(camstopAction,SIGNAL(triggered()),this,SLOT(camera_stop()));
}
// Initialize Camera and Sensors
void initDevices(void) {
	struct pxacam_setting camset;
	
	// Backboard uart init
	fdBackBoard = openSerial();

	// 3-axis sensor init 
	fdThreeAxis = open("/dev/MMA_ADC", O_RDONLY);
	ASSERT(fdThreeAxis);

	ioctl(fdThreeAxis,MMA_VIN_ON, 0);
	ioctl(fdThreeAxis,MMA_SLEEP_MODE_ON, 0);
	ioctl(fdThreeAxis,MMA_SENS_60G, 0);

	// infrared sensor init
	fdInfra = open("/dev/FOUR_ADC", O_NOCTTY);
	ASSERT(fdInfra);

	// Camera init
	fdCamera = camera_open(NULL,0);
	ASSERT(fdCamera);

	memset(&camset,0,sizeof(camset));
	camset.mode = CAM_MODE_VIDEO;
	camset.format = pxavid_ycbcr422;

	camset.width = 320;
	camset.height = 240;

	camera_config(fdCamera,&camset);
	camera_start(fdCamera);

	fdOverlay2 = overlay2_open(NULL,pxavid_ycbcr422,NULL, 320, 240, 0 , 0);

	overlay2_getbuf(fdOverlay2, &vidbuf_overlay);
	len_vidbuf = vidbuf_overlay.width * vidbuf_overlay.height;

	cImg.width=camset.width*2;
	cImg.height=camset.height;

	// init finish
	printf("Initializing Device Finished\n");	
}
Example #6
0
struct tlv_packet *webcam_start(struct tlv_handler_ctx *ctx)
{
  uint32_t deviceIndex = 0;
  uint32_t quality = 0;
  tlv_packet_get_u32(ctx->req, TLV_TYPE_WEBCAM_INTERFACE_ID, &deviceIndex);
  tlv_packet_get_u32(ctx->req, TLV_TYPE_WEBCAM_QUALITY, &quality);

  int result = camera_open(deviceIndex - 1);
  if (result == -1) {
    return tlv_packet_response_result(ctx, TLV_RESULT_FAILURE);
  }

  result = camera_start();
  if (result == -1) {
    return tlv_packet_response_result(ctx, TLV_RESULT_FAILURE);
  }

  return tlv_packet_response_result(ctx, TLV_RESULT_SUCCESS);
}
Example #7
0
int  camera_info_init(struct camera * dev) {

    if(strlen(dev->dev_name) <= 0 )
        strncpy(dev->dev_name,"/dev/video100",strlen("/dev/video100")+2);
    if(dev->v4l_info.wide <= 0 )
        dev->v4l_info.wide = 320;
    if(dev->v4l_info.high <=0 )
        dev->v4l_info.high =240;
    if(dev->v4l_info.v4l_num<=0)
        dev->v4l_info.v4l_num =4;

    if(dev->exit==NULL)
        dev->exit   =&camera_exit;

    if(dev->get_rgb16==NULL)
        dev->get_rgb16 = &get_rgb16;

    if(camera_init(dev) <0)
        return -1;
    return camera_start(dev) ;
}
Example #8
0
int 
camera_set_config_cam_desc (Camera *camera, CameraWidget *window,
			    GPContext *context)
{
	int wind, rind;
	const CameraDescType *cam_desc = NULL;

	GP_DEBUG ("*** camera_set_config_cam_desc");
	CHECK (camera_start (camera, context));

	cam_desc = camera->pl->cam_desc;
	for (wind = 0; wind < 2 /* XXX sizeof () */; wind++) {
		GP_DEBUG ("%s registers", cam_desc->regset[wind].window_name);
		for (rind = 0; rind < cam_desc->regset[wind].reg_cnt;  rind++) {
			camera_cam_desc_set_widget (camera,
			      &cam_desc->regset[wind].regs[rind], window,
			      context);
		}
	}
	return (GP_OK);
}
// Initialize Camera and Sensors
void initDevices(void) {
	struct pxacam_setting camset;
	
	printf("-----Initializing Device Started-----\n");	
	
	// Backboard uart init
	fdBackBoard = openSerial();
	printf("Initializing BackBoard complete!\n");	
		
	// 적외선 센서 init
	fdInfra = open("/dev/FOUR_ADC", O_NOCTTY);
		
		
	// Camera init
	fdCamera = camera_open(NULL,0);
	ASSERT(fdCamera);

	system("echo b > /proc/invert/tb"); //LCD DriverIC top-bottom invert ctrl

	memset(&camset,0,sizeof(camset));
	camset.mode = CAM_MODE_VIDEO;
	camset.format = pxavid_ycbcr422;

	
	camset.width = MAX_X;
	camset.height = MAX_Y;

	camera_config(fdCamera,&camset);
	camera_start(fdCamera);

	fdOverlay2 = overlay2_open(NULL,pxavid_ycbcr422,NULL, MAX_X, MAX_Y, 0 , 0);

	overlay2_getbuf(fdOverlay2, &vidbuf_overlay);
	len_vidbuf = vidbuf_overlay.width * vidbuf_overlay.height;

	printf("Initializing Camera complete!\n");	
	
	// init finish
	printf("-----Initializing Device Finished-----\n");	
}
Example #10
0
int
main(int argc, char *argv[])
	{
	int		fifo;
	int	 	i, n;
	char	*opt, *arg, *equal_arg, *homedir, *user;
	char	*line, *eol, buf[4096];

	pgm_name = argv[0];
	bcm_host_init();
	time(&pikrellcam.t_now);

	config_set_defaults();

	for (i = 1; i < argc; i++)
		get_arg_pass1(argv[i]);

	if (!config_load(pikrellcam.config_file))
		config_save(pikrellcam.config_file);
	if (!motion_regions_config_load(pikrellcam.motion_regions_config_file))
		motion_regions_config_save(pikrellcam.motion_regions_config_file);
	if (!at_commands_config_load(pikrellcam.at_commands_config_file))
		at_commands_config_save(pikrellcam.at_commands_config_file);

	for (i = 1; i < argc; i++)
		{
		if (get_arg_pass1(argv[i]))
			continue;
		opt = argv[i];

		/* Just for initial install-pikrellcam.sh run to create config files.
		*/
		if (!strcmp(opt, "-quit"))
			exit(0);

		/* Accept: --opt arg   -opt arg    opt=arg    --opt=arg    -opt=arg
		*/
		for (i = 0; i < 2; ++i)
			if (*opt == '-')
				++opt;
		if ((equal_arg = strchr(opt, '=')) != NULL)
			{
			*equal_arg++ = '\0';
			arg = equal_arg;
			++i;
			}
		else
			arg = argv[i + 1];

		/* For camera parameters, do not set the camera, only replace
		|  values in the parameter table.
		*/
		if (   !config_set_option(opt, arg, TRUE)
		    && !mmalcam_config_parameter_set(opt, arg, FALSE)
		   )
			{
			log_printf("Bad arg: %s\n", opt);
			exit(1);
			}
		}

	homedir = getpwuid(geteuid())->pw_dir;
	user = strrchr(homedir, '/');
	pikrellcam.effective_user = strdup(user ? user + 1 : "pi");

	if (*pikrellcam.log_file != '/')
		{
		snprintf(buf, sizeof(buf), "%s/%s", pikrellcam.install_dir, pikrellcam.log_file);
		dup_string(&pikrellcam.log_file, buf);
		}
	if (*pikrellcam.media_dir != '/')
		{
		snprintf(buf, sizeof(buf), "%s/%s", pikrellcam.install_dir, pikrellcam.media_dir);
		dup_string(&pikrellcam.media_dir, buf);
		}
	strftime(buf, sizeof(buf), "%F %T", localtime(&pikrellcam.t_now));
	log_printf("\n%s ==== PiKrellCam started ====\n", buf);

	snprintf(buf, sizeof(buf), "%s/%s", pikrellcam.install_dir, "www");
	check_modes(buf, 0775);

	asprintf(&pikrellcam.command_fifo, "%s/www/FIFO", pikrellcam.install_dir);
	asprintf(&pikrellcam.script_dir, "%s/scripts", pikrellcam.install_dir);
	asprintf(&pikrellcam.mjpeg_filename, "%s/mjpeg.jpg", pikrellcam.mjpeg_dir);

	log_printf("using FIFO: %s\n", pikrellcam.command_fifo);
	log_printf("using mjpeg: %s\n", pikrellcam.mjpeg_filename);


	/* Subdirs must match www/config.php and the init script is supposed
	|  to take care of that.
	*/
	asprintf(&pikrellcam.video_dir, "%s/%s", pikrellcam.media_dir, PIKRELLCAM_VIDEO_SUBDIR);
	asprintf(&pikrellcam.still_dir, "%s/%s", pikrellcam.media_dir, PIKRELLCAM_STILL_SUBDIR);
	asprintf(&pikrellcam.timelapse_dir, "%s/%s", pikrellcam.media_dir, PIKRELLCAM_TIMELAPSE_SUBDIR);

	if (!make_dir(pikrellcam.media_dir))
		exit(1);

	snprintf(buf, sizeof(buf), "%s/scripts-dist/init $I $m $M $P $G",
								pikrellcam.install_dir);
	exec_wait(buf, NULL);

	/* User may have enabled a mount disk on media_dir
	*/
	exec_wait(pikrellcam.on_startup_cmd, NULL);
	check_modes(pikrellcam.media_dir, 0775);

	if (   !make_dir(pikrellcam.mjpeg_dir)
	    || !make_dir(pikrellcam.video_dir)
	    || !make_dir(pikrellcam.still_dir)
	    || !make_dir(pikrellcam.timelapse_dir)
	    || !make_fifo(pikrellcam.command_fifo)
	   )
		exit(1);

	if ((fifo = open(pikrellcam.command_fifo, O_RDONLY | O_NONBLOCK)) < 0)
		{
		log_printf("Failed to open FIFO: %s.  %m\n", pikrellcam.command_fifo);
		exit(1);
		}

	fcntl(fifo, F_SETFL, 0);
	read(fifo, buf, sizeof(buf));
	
	sun_times_init();
	camera_start();
	config_timelapse_load_status();

	signal(SIGINT, signal_quit);
	signal(SIGTERM, signal_quit);
	signal(SIGCHLD, event_child_signal);

	while (1)
		{
		usleep(1000000 / EVENT_LOOP_FREQUENCY);
		event_process();

		/* Process lines in the FIFO.  Single lines via an echo "xxx" > FIFO
		|  or from a web page may not have a terminating \n.
		|  Local scripts may dump multiple \n terminated lines into the FIFO.
		*/
		if ((n = read(fifo, buf, sizeof(buf) - 2)) > 0)
			{
			if (buf[n - 1] != '\n')
				buf[n++] = '\n';	/* ensures all lines in buf end in \n */
			buf[n] = '\0';
			line = buf;
			eol = strchr(line, '\n');

			while (eol > line)
				{
				*eol++ = '\0';
				command_process(line);
				while (*eol == '\n')
					++eol;
				line = eol;
				eol = strchr(line, '\n');
				}
			}
		}
	return 0;
	}
Example #11
0
/**
 * Resume previewing
 */
static javacall_result camera_resume(javacall_handle handle)
{
    return camera_start(handle);
}
int webcam_run() {

#ifdef HAVE_CAMERA
    // Our mandatory renderers, ensures they are run first being registered last
    struct Node *n = cameras.l_head;
    while (list_isNode(n)) {
        CAMERA camera = (CAMERA) n;
        n = n->n_succ;
        // Put annotated last
        list_addTail(&camera->renderers.renderers, &create_annotatedrenderer()->node);
        // These go first
        list_addHead(&camera->renderers.renderers, &create_thumbnailrenderer()->node);
        list_addHead(&camera->renderers.renderers, &create_rawrenderer()->node);
    }
#endif

    // Now start the system up
    webserver_initialise(config);

#ifdef HAVE_CAMERA
    // Initialise the renderers
    n = cameras.l_head;
    while (list_isNode(n)) {
        CAMERA camera = (CAMERA) n;
        n = n->n_succ;
        imagerenderer_init(camera);
    }
#endif

    // Initialise the loggers
    logger_start();

    // Finish off configuring the webserver, default port etc
    webserver_set_defaults();

#ifdef HAVE_CAMERA
    n = cameras.l_head;
    while (list_isNode(n)) {
        CAMERA camera = (CAMERA) n;
        n = n->n_succ;
        imagerenderer_postinit(camera);
    }
#endif

    sensor_postinit();

    // The camera home page
    //create_homepage();

    // Start everything up
    webserver_start();

#ifdef HAVE_CAMERA
    camera_start();
#endif

    // Now the main loop, monitor for sensor updates
    //sensor_loop();
    while (1)
        sleep(60);

    // Shutdown - we never actually get here
    webserver_stop();
    logger_stop();

#ifdef HAVE_CAMERA
    camera_stop();
#endif

    return 0;
}
Example #13
0
/* camera_new */
Camera * camera_new(GtkWidget * window, GtkAccelGroup * group,
		char const * device)
{
	Camera * camera;
	GtkWidget * vbox;
	GtkWidget * widget;
	GtkToolItem * toolitem;

	if((camera = object_new(sizeof(*camera))) == NULL)
		return NULL;
	camera->device = (device != NULL)
		? string_new(device) : string_new("/dev/video0");
	camera->hflip = FALSE;
	camera->vflip = FALSE;
	camera->ratio = TRUE;
	camera->interp = GDK_INTERP_BILINEAR;
	camera->snapshot_format = CSF_PNG;
	camera->snapshot_quality = 100;
	camera->source = 0;
	camera->fd = -1;
	memset(&camera->cap, 0, sizeof(camera->cap));
	camera->channel = NULL;
	camera->buffers = NULL;
	camera->buffers_cnt = 0;
	camera->raw_buffer = NULL;
	camera->raw_buffer_cnt = 0;
	camera->rgb_buffer = NULL;
	camera->rgb_buffer_cnt = 0;
	camera->yuv_amp = 255;
	camera->overlays = NULL;
	camera->overlays_cnt = 0;
	camera->widget = NULL;
	camera->window = window;
	camera->bold = NULL;
	camera->gc = NULL;
	camera->pr_window = NULL;
	camera->pp_window = NULL;
	/* check for errors */
	if(camera->device == NULL)
	{
		camera_delete(camera);
		return NULL;
	}
	/* create the window */
	camera->bold = pango_font_description_new();
	pango_font_description_set_weight(camera->bold, PANGO_WEIGHT_BOLD);
	camera->gc = gdk_gc_new(window->window); /* XXX */
#if GTK_CHECK_VERSION(3, 0, 0)
	camera->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#else
	camera->widget = gtk_vbox_new(FALSE, 0);
#endif
	vbox = camera->widget;
	/* toolbar */
	widget = desktop_toolbar_create(_camera_toolbar, camera, group);
	gtk_widget_set_sensitive(GTK_WIDGET(_camera_toolbar[0].widget), FALSE);
	gtk_widget_set_sensitive(GTK_WIDGET(_camera_toolbar[2].widget), FALSE);
	gtk_widget_set_sensitive(GTK_WIDGET(_camera_toolbar[4].widget), FALSE);
	toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_FULLSCREEN);
	g_signal_connect_swapped(toolitem, "clicked", G_CALLBACK(
				_camera_on_fullscreen), camera);
	gtk_toolbar_insert(GTK_TOOLBAR(widget), toolitem, -1);
	gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0);
#if GTK_CHECK_VERSION(2, 18, 0)
	/* infobar */
	camera->infobar = gtk_info_bar_new_with_buttons(GTK_STOCK_CLOSE,
			GTK_RESPONSE_CLOSE, NULL);
	gtk_info_bar_set_message_type(GTK_INFO_BAR(camera->infobar),
			GTK_MESSAGE_ERROR);
	g_signal_connect(camera->infobar, "close", G_CALLBACK(gtk_widget_hide),
			NULL);
	g_signal_connect(camera->infobar, "response", G_CALLBACK(
				gtk_widget_hide), NULL);
	widget = gtk_info_bar_get_content_area(GTK_INFO_BAR(camera->infobar));
	camera->infobar_label = gtk_label_new(NULL);
	gtk_widget_show(camera->infobar_label);
	gtk_box_pack_start(GTK_BOX(widget), camera->infobar_label, TRUE, TRUE,
			0);
	gtk_widget_set_no_show_all(camera->infobar, TRUE);
	gtk_box_pack_start(GTK_BOX(vbox), camera->infobar, FALSE, TRUE, 0);
#endif
	camera->area = gtk_drawing_area_new();
	camera->pixmap = NULL;
	g_signal_connect(camera->area, "configure-event", G_CALLBACK(
				_camera_on_drawing_area_configure), camera);
	g_signal_connect(camera->area, "expose-event", G_CALLBACK(
				_camera_on_drawing_area_expose), camera);
	gtk_box_pack_start(GTK_BOX(vbox), camera->area, TRUE, TRUE, 0);
	gtk_widget_show_all(vbox);
	camera_start(camera);
	return camera;
}