frontend.c

LINUX下非常有名的视频采集和显示源代码,直接安装后可以使用,效果很好

    gtk_box_pack_start(GTK_BOX(camera->controlcontainer), camera->controltop, TRUE, TRUE, 0);
  else
    gtk_container_add (GTK_CONTAINER(camera->controlwindow), camera->controltop);
}

void close_controls(GtkWidget *widget, GdkEvent *event, struct Camera *camera)
{
  dock_controls(widget, camera);
}


void dock_controls(GtkWidget *widget, struct Camera *camera)
{
  if (camera->docked){
    //    printf("Floating(%d)\n", camera->docked);
    camera->docked = 0;
    gtk_widget_destroy(camera->controltop);
    if (camera->greyscale)
      create_controls_greyscale(camera);
    else
      create_controls_color(camera);
    camera->controlwindow = gtk_window_new(GTK_WINDOW_DIALOG);
    gtk_container_add (GTK_CONTAINER(camera->controlwindow), camera->controltop);
    gtk_window_set_title(GTK_WINDOW (camera->controlwindow), "Gqcam - Control Panel");
    gtk_signal_connect (GTK_OBJECT (camera->controlwindow), "delete_event",
			GTK_SIGNAL_FUNC (close_controls), camera);
    gtk_widget_show(camera->controlwindow);
 
  }
  else {
    camera->docked = 1;
    gtk_widget_destroy(camera->controlwindow);
    if (camera->greyscale)
      create_controls_greyscale(camera);
    else
      create_controls_color(camera);  
    gtk_box_pack_start(GTK_BOX(camera->controlcontainer), camera->controltop, TRUE, TRUE, 0);
    //    printf("Docked\n");
  }
}


void clearimg(struct Camera *camera)
{
  GdkRectangle update_rec;

  configure_event(GTK_WIDGET (camera->drawing_area),NULL, camera);

  update_rec.x = 0;
  update_rec.y = 0;
  update_rec.width = camera->vid_caps.maxwidth;
  update_rec.height = camera->vid_caps.maxheight;
  gtk_widget_draw (camera->drawing_area, &update_rec);
  return;
}

static gint configure_event (GtkWidget *widget, GdkEventConfigure *event, struct Camera *camera)
{
  if (camera->pixmap)
    gdk_pixmap_unref(camera->pixmap);

  camera->pixmap = gdk_pixmap_new(widget->window,
				  widget->allocation.width,
				  widget->allocation.height,
				  -1);
  gdk_draw_rectangle (camera->pixmap,
		      widget->style->white_gc,
		      TRUE,
		      0, 0,
		      widget->allocation.width,
		      widget->allocation.height);
  return TRUE;
}

static gint expose_event (GtkWidget *widget, GdkEventExpose *event, struct Camera *camera)
{
  //  display(camera);
  gdk_draw_pixmap(widget->window,
		  widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
		  camera->pixmap,
		  event->area.x, event->area.y,
		  event->area.x, event->area.y,
		  event->area.width, event->area.height);
  return FALSE;
}

void freeze(GtkWidget *widget, struct Camera *camera)
{
  /* correct our state */
  if( !camera->frozen && ( GTK_TOGGLE_BUTTON (widget)->active ) ) {
    GTK_TOGGLE_BUTTON (widget)->active;
  }
  /* Careful, if we aren't capturing we don't want to grab the freeze lock,
     or we will deadlock */
  /* same goes for saving */
  pthread_mutex_lock( &camera->pref_mutex );
  if( camera->capture && !camera->saving ) {
    if (GTK_TOGGLE_BUTTON (widget)->active){
      pthread_mutex_lock( &camera->freeze_mutex );
      camera->frozen=1;
    } else {
      camera->frozen=0;
      pthread_mutex_unlock( &camera->freeze_mutex );
    } 
  }
  else {  
    GTK_TOGGLE_BUTTON (widget)->active = !GTK_TOGGLE_BUTTON (widget)->active;
  }
  pthread_mutex_unlock( &camera->pref_mutex );
}

int create_frontend(struct Camera *camera)
{
  GtkWidget *window;
  GtkWidget *topbox;
  GtkWidget *outerbox;
  GtkWidget *innerbox;
  GtkWidget *scalebox;
  GtkWidget *frame;
  GtkObject *adjb;
  GtkWidget *scaleb;
  GtkObject *adjw;
  GtkWidget *scalew;
  GtkObject *adjc;
  GtkWidget *scalec;
  GtkWidget *radiobutton;
  GtkWidget *dockbutton;
  GSList *radiogroup;
  GtkWidget *button;
  GdkDrawable *drawable;
  GtkTooltips *tooltips;
  GtkWidget *statusbar;

  GtkWidget *menubar;
  GtkWidget *filemenu;
  GtkWidget *fileitem;
  GtkWidget *quititem;
  GtkWidget *saveitem;
  GtkWidget *openitem;
  GtkWidget *closeitem;
  GtkWidget *prefitem;
  GtkWidget *seperator;
  GtkWidget *cameramenu;
  GtkWidget *cameraitem;
  GtkWidget *infoitem;
  GtkWidget *updateitem;
  GtkWidget *startitem;
  GtkWidget *stopitem;
  GtkWidget *timeritem;
  GtkWidget *helpmenu;
  GtkWidget *helpitem;
  GtkWidget *aboutitem;

  guchar *gbuff;
  GdkColor c;
  char title[50] = "Gqcam - ";
  struct video_clip vid_clips[32];
  int ib=130, ic=30, iw=150, i, count=32;

  strcat(title, camera->vid_caps.name);
/*
  for (i = 0; i < count; i++) {
    vid_clips[i].x      = 0;
    vid_clips[i].y      = 0;
    vid_clips[i].width  = 0;
    vid_clips[i].height = 0;
  }
  
  vid_win.clips = vid_clips;
  vid_win.clipcount = 0;

  ib = (vid_pic.brightness)/256;
  ic = (vid_pic.contrast)/256;
  iw = (vid_pic.whiteness)/256;
*/  
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title (GTK_WINDOW (window), title);
  gtk_window_set_policy(GTK_WINDOW(window), FALSE, TRUE, TRUE);
  gtk_signal_connect (GTK_OBJECT (window), "delete_event",
		      GTK_SIGNAL_FUNC (delete_event), camera);

  /* Create topbox */
  topbox = gtk_vbox_new (FALSE, 0);
  gtk_container_add (GTK_CONTAINER (window), topbox);

  /* Create Menu */

  menubar = gtk_menu_bar_new ();
  filemenu = gtk_menu_new();

  openitem = gtk_menu_item_new_with_label("Open New Camera...");
  gtk_menu_append(GTK_MENU(filemenu), openitem);
  gtk_signal_connect(GTK_OBJECT (openitem), "activate",
		     GTK_SIGNAL_FUNC (open_dialog), camera);
  gtk_widget_show(openitem);

  saveitem = gtk_menu_item_new_with_label("Save Image...");
  gtk_menu_append(GTK_MENU(filemenu), saveitem);
  gtk_signal_connect(GTK_OBJECT (saveitem), "activate",
		     GTK_SIGNAL_FUNC (save_dialog), camera);
  gtk_widget_show(saveitem);

  /*   closeitem = gtk_menu_item_new_with_label("Close Camera");
       gtk_menu_append(GTK_MENU(filemenu), closeitem);
       gtk_signal_connect(GTK_OBJECT (closeitem), "activate",
       GTK_SIGNAL_FUNC (close_dialog), camera);  
       gtk_widget_show(closeitem); */

  seperator = gtk_menu_item_new();
  gtk_menu_append(GTK_MENU(filemenu), seperator);
  gtk_widget_show(seperator);

  prefitem = gtk_menu_item_new_with_label("Preferences...");
  gtk_menu_append(GTK_MENU(filemenu), prefitem);
  gtk_signal_connect(GTK_OBJECT (prefitem), "activate",
		     GTK_SIGNAL_FUNC (pref_dialog), camera);
  gtk_widget_show(prefitem);

  seperator = gtk_menu_item_new();
  gtk_menu_append(GTK_MENU(filemenu), seperator);
  gtk_widget_show(seperator);

  quititem = gtk_menu_item_new_with_label("Quit");
  gtk_menu_append(GTK_MENU(filemenu), quititem);
  gtk_signal_connect(GTK_OBJECT (quititem), "activate",
		     GTK_SIGNAL_FUNC (delete_event),
		     camera);
  gtk_widget_show(quititem);

  fileitem = gtk_menu_item_new_with_label("File");
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(fileitem), filemenu);
  gtk_menu_bar_append(GTK_MENU_BAR(menubar), fileitem);


  cameramenu = gtk_menu_new();
  infoitem = gtk_menu_item_new_with_label("Camera Info...");
  gtk_menu_append(GTK_MENU(cameramenu), infoitem);
  gtk_signal_connect(GTK_OBJECT (infoitem), "activate",
		     GTK_SIGNAL_FUNC (camera_info),
		     camera);
  gtk_widget_show(infoitem);

  startitem = gtk_menu_item_new_with_label("Start Capturing");
  gtk_signal_connect(GTK_OBJECT (startitem), "activate",
		     GTK_SIGNAL_FUNC (start_capture),
		     camera);
  gtk_menu_append(GTK_MENU(cameramenu), startitem);
  gtk_widget_show(startitem);
  
  stopitem = gtk_menu_item_new_with_label("Stop Capturing");
  gtk_signal_connect(GTK_OBJECT (stopitem), "activate",
		     GTK_SIGNAL_FUNC (stop_capture),
		     camera);
  gtk_signal_connect(GTK_OBJECT (stopitem), "activate",
		     GTK_SIGNAL_FUNC (en_dis_able),
		     startitem);
  gtk_signal_connect(GTK_OBJECT (startitem), "activate",
		     GTK_SIGNAL_FUNC (en_dis_able),
		     stopitem);
  gtk_menu_append(GTK_MENU(cameramenu), stopitem);
  gtk_widget_show(stopitem);

  if (camera->capture)
    gtk_widget_set_sensitive(startitem, FALSE);
  else
    gtk_widget_set_sensitive(stopitem, FALSE);

  timeritem = gtk_menu_item_new_with_label("Set Timer...");
  gtk_menu_append(GTK_MENU(cameramenu), timeritem);
  gtk_signal_connect(GTK_OBJECT (timeritem), "activate",
		     GTK_SIGNAL_FUNC (set_timer),
		     camera);
  gtk_widget_show(timeritem);

  /*
  updateitem = gtk_menu_item_new_with_label("Update Controls");
  gtk_menu_append(GTK_MENU(cameramenu), updateitem);
  gtk_signal_connect(GTK_OBJECT (updateitem), "activate",
		     GTK_SIGNAL_FUNC (update_controls), camera);
  gtk_widget_show(updateitem);
*/
  cameraitem = gtk_menu_item_new_with_label("Camera");
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(cameraitem), cameramenu);
  gtk_menu_bar_append(GTK_MENU_BAR(menubar), cameraitem);

  helpmenu = gtk_menu_new();
  aboutitem = gtk_menu_item_new_with_label("About");
  gtk_signal_connect(GTK_OBJECT (aboutitem), "activate",
		     GTK_SIGNAL_FUNC (about_dialog),
		     camera);
  gtk_menu_append(GTK_MENU(helpmenu), aboutitem);
  helpitem = gtk_menu_item_new_with_label("Help");
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(helpitem), helpmenu);
  gtk_menu_item_right_justify(GTK_MENU_ITEM(helpitem));
  gtk_menu_bar_append(GTK_MENU_BAR(menubar), helpitem);
  gtk_widget_show(aboutitem);

  gtk_widget_show(fileitem);
  gtk_widget_show(cameraitem);
  gtk_widget_show(helpitem);

  gtk_box_pack_start(GTK_BOX(topbox), menubar, FALSE, TRUE, 0);
  gtk_widget_show (menubar);


  /* Create the drawing area */
  frame = gtk_frame_new(NULL);
  gtk_box_pack_start (GTK_BOX(topbox), frame, FALSE, TRUE, 0);
  gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
  gtk_widget_show(frame);

  camera->drawing_area = gtk_drawing_area_new();
  gtk_drawing_area_size (GTK_DRAWING_AREA (camera->drawing_area), camera->vid_caps.maxwidth, camera->vid_caps.maxheight);
  gtk_container_add(GTK_CONTAINER(frame), camera->drawing_area);
  gtk_widget_show (camera->drawing_area);
/*
  gtk_signal_connect (GTK_OBJECT (camera->drawing_area), "expose_event",
		      (GtkSignalFunc) display, camera);
*/
/*------ bp -------*/

  gtk_signal_connect (GTK_OBJECT (camera->drawing_area), "expose_event",
		      (GtkSignalFunc) expose_event, camera);
  gtk_signal_connect (GTK_OBJECT(camera->drawing_area),"configure_event",
		      (GtkSignalFunc) configure_event, camera);

/*-----------------*/

  dockbutton = gtk_button_new();
  gtk_box_pack_start(GTK_BOX(topbox), dockbutton, FALSE, TRUE, 0);
  gtk_signal_connect (GTK_OBJECT (dockbutton), "clicked",
		      (GtkSignalFunc) dock_controls, camera);
  gtk_widget_show(dockbutton);

  tooltips = gtk_tooltips_new();
  gtk_tooltips_set_tip(tooltips, dockbutton, "Dock/Undock Controls", NULL);

  camera->controlcontainer = gtk_vbox_new (FALSE, 0);
  gtk_box_pack_start(GTK_BOX(topbox), camera->controlcontainer, FALSE, TRUE, 0);
  gtk_widget_show(camera->controlcontainer);

  if (camera->greyscale)
    create_controls_greyscale(camera);
  else
    create_controls_color(camera);

  gtk_box_pack_start(GTK_BOX(camera->controlcontainer), camera->controltop, FALSE, TRUE, 0);

  /* Create a few buttons */
  innerbox = gtk_hbox_new (TRUE, 0);
  gtk_box_pack_start( GTK_BOX (topbox), innerbox, FALSE, TRUE, 0);
  gtk_widget_show (innerbox);
  
  button = gtk_button_new_with_label ("Snap Picture");
  gtk_box_pack_start( GTK_BOX (innerbox), button, FALSE, TRUE, 0);
  gtk_widget_show(button);

  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      GTK_SIGNAL_FUNC (save_dialog), camera);

  button = gtk_toggle_button_new_with_label ("Freeze Picture");
  gtk_box_pack_start(GTK_BOX (innerbox), button, FALSE, TRUE, 0);
  gtk_widget_show(button);

  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      (GtkSignalFunc) freeze, camera);

  button = gtk_button_new_with_label ("Quit");
  gtk_box_pack_start( GTK_BOX (innerbox), button, FALSE, TRUE, 0);
  gtk_widget_show(button);

  gtk_signal_connect (GTK_OBJECT (button), "clicked",
	 	      GTK_SIGNAL_FUNC (delete_event), camera);

  /* create the frames per second status */
  if( 1 ) {
    gint context_id;
    camera->statusbar = gtk_statusbar_new();
    gtk_box_pack_start( GTK_BOX (topbox), camera->statusbar, TRUE, TRUE, 0);
    gtk_widget_show( camera->statusbar );
    context_id = gtk_statusbar_get_context_id( GTK_STATUSBAR(camera->statusbar), "Statusbar example" );
    gtk_statusbar_push( GTK_STATUSBAR( camera->statusbar ), context_id, "Speed - Calculating" );
  }
  gtk_widget_show (topbox);
  gtk_widget_show (window);

  return 0;
}