gtk_cam.c

外国人写的一个很好的嵌入式视频采集源程序。

/*
    cc `gtk-config --cflags` -o gtk_cam gtk_cam.c `gtk-config --libs` `gdk-pixbuf-config --libs` `gdk-pixbuf-config --cflags`

*/



#include <strings.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <linux/videodev.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <time.h>
#include <gtk/gtk.h>

#define DOT	fprintf (stderr,".");

void swap_rgb24(unsigned char *mem, int n) {
	unsigned char  c;
	unsigned char *p = mem;
	int   i = n ; 
	while (--i) {
		c = p[0];
		p[0] = p[2];
		p[2] = c;
		p += 3;
	}
}               
														
int blend_images(unsigned char *from, int from_w, int from_h, int from_depth, 
		unsigned char *to, int to_w, int to_h, int to_depth, 
		int off_x, int off_y, unsigned char alpha);

void bgr2rgb(unsigned char *b, unsigned int tam) {
        unsigned char temp;
        while (tam) {
		temp=*b;
		*b=*(b+2);
		*(b+2)=temp;
		b+=3;
		tam--;
		}
}
													
#define COLS    320
#define ROWS    240

//#define COLS    640
//#define ROWS    480
#define DEPTH  3 


struct video_picture      grab_pic;
struct video_capability   grab_cap;
struct video_channel      grab_vid; /* escolher canal e NTSC */
struct video_tuner       grab_tun; /* escolher canal e NTSC */
struct video_mmap         grab_buf;
struct video_mbuf         grab_vm;
unsigned int              grab_fd, grab_size, frame, i, done=1;
static unsigned char  *grab_data= NULL, *buf=NULL, *logo_image;


GtkWidget *status;
GtkWidget *darea;
GtkWidget *label;
int global_frames=0;
gint context_id;

void send_expose(void);
void on_darea_expose (GtkWidget *widget);
int load_pnm(char *, unsigned char *);
void brilho (unsigned char *);

void open_dev (void) {
        

	grab_size= ROWS * COLS * DEPTH;
	
	if ((grab_fd = open("/dev/video0",O_RDWR)) == -1 ) {
		perror("open videodev");
		exit(-1);
	}

	if (ioctl(grab_fd,VIDIOCGCAP,&grab_cap) == -1) {
		fprintf(stderr,"wrong device\n");
		exit(-1);
	}
	
	/* test */
	if (ioctl(grab_fd,  VIDIOCGCHAN, &grab_vid)==-1){
		perror("VIDIOCGCHAN");
	}
	grab_vid.norm=VIDEO_MODE_NTSC;
	grab_vid.channel=0; // Input channel


	if (ioctl(grab_fd,  VIDIOCSCHAN, &grab_vid)==-1){
		perror("VIDIOCSCHAN");
	}
	
        /* Query the actual buffers available */
        if(ioctl(grab_fd, VIDIOCGMBUF, &grab_vm) < 0) {
        	perror("VIDIOCGMBUF");
		exit(-1);
	}
        
	grab_buf.frame  = 0; 
        grab_buf.width  = COLS; 
        grab_buf.height = ROWS; 
        grab_buf.format = VIDEO_PALETTE_RGB24; 
	
        /* MMap all available buffers */
        grab_data = mmap(0, grab_vm.size, PROT_READ|PROT_WRITE, MAP_SHARED, grab_fd, 0);
    	
	if (grab_data==(unsigned char *)-1) {
        	perror("mmap");
		exit(-1);
	}
					    
				
        fprintf (stderr,"buffers: %d - size: %d - grab_size: %d\n", grab_vm.frames, grab_vm.size, grab_size);

        if (ioctl(grab_fd, VIDIOCGTUNER, &(grab_tun)) == -1) {
                   perror("VIDIOCGTUNER");
                   return;
        }
          grab_tun.flags = VIDEO_TUNER_NTSC;
	  grab_tun.mode = VIDEO_MODE_NTSC;
			  
	if (ioctl(grab_fd, VIDIOCSTUNER, &(grab_tun)) == -1) {
                   perror("VIDIOCSTUNER");
                   return;
        }
	

	if (ioctl (grab_fd, VIDIOCGPICT, &grab_pic) < 0) {
	  	perror("VIDIOCGPICT");
	}


	// picture.

	if (ioctl (grab_fd, VIDIOCSPICT, &grab_pic) < 0) {
	  	perror("VIDIOCSPICT");
	}
								  
	

}



/* Obligatory basic callback */
static void print_hello(GtkWidget * w, gpointer data) {
    gtk_statusbar_push (GTK_STATUSBAR (status), 1, "menu opt");
    g_message("Hello, World!\n");
}

void file_ok_sel( GtkWidget*w,  GtkFileSelection *fs ){
	
	g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));

}

void open_file(GtkWidget *widget, gpointer *data) {
	GtkWidget *filew;
	
	filew = gtk_file_selection_new ("File selection");
//	gtk_signal_connect (GTK_OBJECT (filew), "destroy",
//	                   (GtkSignalFunc) destroy, &filew);
	gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (filew)->ok_button),
	               "clicked", (GtkSignalFunc) file_ok_sel, filew );
	
	gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION
				  (filew)->cancel_button),
				  "clicked", (GtkSignalFunc) gtk_widget_destroy,
				  GTK_OBJECT (filew));
	gtk_widget_show(filew);
}
static void ok_about (GtkWidget *widget, gpointer window) {
	gtk_widget_destroy (GTK_WIDGET (window));
}


static void ok_cb (GtkWidget *widget, gpointer window) {
	gchar *entry_text;
	
	entry_text = gtk_entry_get_text(GTK_ENTRY(label));
	gtk_statusbar_push (GTK_STATUSBAR (status), 1, entry_text);
	gtk_widget_destroy (GTK_WIDGET (window));
}


static void ok_cancel (GtkWidget *widget, gpointer window) {
	gtk_widget_destroy (GTK_WIDGET (window));
}

static void process_entry (GtkWidget *widget, gpointer *entry) {
	gchar *entry_text;
	entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
	gtk_statusbar_push (GTK_STATUSBAR (status), 1, entry_text);
}

static void about (GtkWidget *wido, gpointer *data) {
	GtkWidget *win, *vbox, *button, *hbox, *label;
	
	win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title (GTK_WINDOW (win), "About");
	gtk_widget_set_usize(GTK_WIDGET(win), 200, 90);
	gtk_widget_realize (win);
	
	vbox= gtk_vbox_new (FALSE, 0);
	gtk_container_add (GTK_CONTAINER (win), vbox );
	gtk_widget_show(vbox);

	label = gtk_label_new ("This is a Normal label\nGleicon 2001");
	gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
	gtk_widget_show(label);
	
	
	hbox = gtk_hbox_new (FALSE, 0);
	gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, FALSE, 0);
	gtk_widget_show (hbox);
	
	button=gtk_button_new_with_label ("Ok");
	gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, FALSE, 10);
	gtk_signal_connect (GTK_OBJECT (button), "clicked",
	                   (GtkSignalFunc) ok_about, (gpointer) win);
	gtk_widget_show (button);
	
	gtk_widget_show(win);
	
}


static void effect (GtkWidget *wido, gpointer data) {
	GtkWidget *wida, *button1, *button2, *hbox, *vbox, *frame;

	wida= gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title (GTK_WINDOW (wida), "ask-o");
    	gtk_widget_set_usize(GTK_WIDGET(wida), 200, 90);
	gtk_widget_realize (wida);

	vbox= gtk_vbox_new (FALSE, 0);
	gtk_container_add (GTK_CONTAINER (wida), vbox );
	gtk_widget_show(vbox);

	frame = gtk_frame_new (" Enter parameters ");

	label= gtk_entry_new ();
	gtk_container_add (GTK_CONTAINER (frame), label);
	gtk_signal_connect (GTK_OBJECT (label), "activate", 
			   (GtkSignalFunc) process_entry, (gpointer) label);
	
	gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, FALSE, 0);
	gtk_widget_show(frame);
	
	
	hbox = gtk_hbox_new (FALSE, 0);
	gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, FALSE, 0);
	gtk_widget_show (hbox);

	
	button1=gtk_button_new_with_label ("Ok");
	gtk_box_pack_start (GTK_BOX (hbox), button1, TRUE, FALSE, 10);
	gtk_signal_connect (GTK_OBJECT (button1), "clicked",
	                   (GtkSignalFunc) ok_cb, (gpointer) wida);
	gtk_widget_show (button1);
		
	button2=gtk_button_new_with_label ("Cancel");
	gtk_box_pack_start (GTK_BOX (hbox), button2, TRUE, FALSE, 10);
	gtk_signal_connect (GTK_OBJECT (button2), "clicked",
	                   (GtkSignalFunc) ok_cancel, (gpointer) wida);
	gtk_widget_show (button2);
	
	gtk_widget_show(wida);

	
}

static void change_input (GtkWidget *wido, gpointer data) {
	char buff[25];
	
	if (ioctl (grab_fd, VIDIOCGCHAN, &grab_vid) == -1) {
		fprintf(stderr,"Erro VIDIOCGCHAN\n");
		exit(0);
	}
	
	grab_vid.norm=1; // NTSC

	grab_vid.channel=(gulong *) data;
	g_snprintf(buff, 20, "Input %d", grab_vid.channel);
	
	fprintf (stderr,"Input %d\n", grab_vid.channel);
    	gtk_statusbar_push (GTK_STATUSBAR (status), context_id, buff);

	if (ioctl (grab_fd, VIDIOCSCHAN, &grab_vid) == -1) {
		fprintf(stderr,"Erro VIDIOCSCHAN\n");
		exit(0);
	}

}


/* This is the GtkItemFactoryEntry structure used to generate new menus.
Item 1: The menu path. The letter after the underscore indicates an
accelerator key once the menu is open.
Item 2: The accelerator key for the entry
Item 3: The callback function.
Item 4: The callback action.  This changes the parameters with
which the function is called.  The default is 0.
Item 5: The item type, used to define what kind of an item it is.
Here are the possible values:
NULL               -> "<Item>"
""                 -> "<Item>"
"<Title>"          -> create a title item
"<Item>"           -> create a simple item