Capturer signal vidéo

**Ikit** · 07/12/2007, 19h47

Bonjour,

J'ai fait une recherche sur le forum, mais il n'y a pas vraiment ce que je cherche.

Donc voilà, je dois développer une application d'analyse de scène (ça c'est mon problème

).
Seulement pour ça, faudrait déjà que je puisse capture le signal vidéo renvoyer par ma webcam.

Ce signal est disponible sur /dev/video0 (oui je suis sous linux, kernel 2.6 )
Seulement moi en programmation système je n'y connais rien, et j'ai déjà perdu beaucoup de temps à essayer de récupérer ce signal sous forme d'image pour que je suis procéder à l'analyse.

Mon meilleur espoire fut sur ce site : http://pficheux.free.fr/
- le pdf qui explique
- le source

Malheureusement je n'ai pas réussi à le compiler chez moi.

Connaitriez vous un moyen (si possible rapide et simple, pour capturer le flux vidéo, et le convertir en image (jpg, tiff, ou autre)

**apesle** · 08/12/2007, 13h26

Salut,
J'ai été confronté au même probleme que toi lorsque j'ai eu a faire une appli de reconnaissance de formes.
Voici le code C que j'utilise pour récuperer des images de la cam. Elle sont récupérés au format RGB24.
Ce code ne marchera qu'avec une webcam dont le driver est compatible avec V4L. Ceci est de plus en plus rare puisque c'est V4L2 qui est de plus en plus utilisé.
Moi j'utilise la samsung Pleomax PWC 3800, et sa marche nikel.

fichier webcam.c :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
#include "../headers/webcam.h"
 
 
int descrpFichier;
struct video_capability vidcap;
struct video_window fenetre;
struct video_capture capture;
struct video_mbuf mbuf;
struct video_mmap mapbuf;
struct video_buffer buffer;
unsigned char *ptr;
unsigned char *posImg;
 
 
 
/**Ouverture de la camera**/
void
openCam (char *deviceName)
{
  descrpFichier = open (deviceName, O_RDWR);
  if (descrpFichier < 0)
    {
      printf ("\aAucun peripherique detecte\n");
      printf ("Verifiez les droits d'acces a /dev/video0\n");
      exit (-1);
    }
}
 
/**Fermeture de la camera**/
void
closeCam (void)
{
  printf ("Le programme a quitte correctement\n");
  close (descrpFichier);
  munmap (ptr, WIDTH*HEIGHT*3);
}
 
/**Informations sur les capacites du peripherique**/
void
printCap (void)
{
  if (ioctl (descrpFichier, VIDIOCGCAP, &vidcap) < 0)
    exit (-1);
  if (ioctl (descrpFichier, VIDIOCGWIN, &fenetre) < 0)
    exit (-1);
  printf ("Nom: %s\n", vidcap.name);
  if (!(vidcap.type && VID_TYPE_CAPTURE))
    {
      printf ("Le peripherique detecte ne supporte pas la capture\n");
      exit (-1);
    }
  printf ("Type: Camera\n");
}
 
/**Definition de la fenetre de capture**/
void
setWin (void)
{
  fenetre.x = 0;
  fenetre.y = 0;
  fenetre.width = WIDTH;
  fenetre.height = HEIGHT;
  fenetre.clipcount = 0;
  fenetre.chromakey = 0;
  fenetre.clipcount = 0;
  if (ioctl (descrpFichier, VIDIOCSWIN, &fenetre) < 0)
    {
      perror ("VIDIOCSWIN");
	printf("Verifiez que la webcam supporte bien l'acquisition d'une image de %ix%i pixels.\n",WIDTH,HEIGHT);
      exit (-1);
    }
}
 
 
/**Definition des proprietes de l'image**/
void
setImage (int hue, int colour, int contrast, int brightness, int whiteness,
	  int depth)
{
   struct video_picture immage;
   /*on recupere les valeurs actuelle*/
   if (ioctl (descrpFichier, VIDIOCGPICT, &immage) < 0)
    {
      perror ("VIDIOCGPICT");
      exit (-1);
    }
	/*on les modifie pour leur donner les nouvelles valeur*/
  immage.hue = hue * 65536 / 100;
  immage.colour = colour * 65536 / 100;
  immage.contrast = contrast * 65536 / 100;
  immage.brightness = brightness * 65536 / 100;
  immage.whiteness = whiteness * 65536 / 100;
  immage.depth = depth;
  immage.palette = PALETTE;
	/*on les attribut au peripherique*/
  if (ioctl (descrpFichier, VIDIOCSPICT, &immage) < 0)
    {
      perror ("VIDIOCSPICT");
      exit (-1);
    }
}
 
 
/**Cette fonction de capture prend en param un pointeur sur une structure RGB24 
 et la modifie pour quelle contienne les composantes rgb de l'image prise.**/
void captureImage (RGB *rgb24)
{
  int i, j;
  int y = 0, x = 0;
 
 
  if (ioctl (descrpFichier, VIDIOCGMBUF, &mbuf) < 0)
    {
      perror ("VIDIOCGMBUF");
      exit (-1);
    }
 
  ptr =
    (unsigned char *) mmap (0, WIDTH*HEIGHT*3, PROT_READ | PROT_WRITE, MAP_SHARED,
			    descrpFichier, 0);
  if (ptr == ((unsigned char *) -1))
    {
      perror ("mmap");
      exit (-1);
    }
  mapbuf.frame = 0;
  mapbuf.height = HEIGHT;
  mapbuf.width = WIDTH;
  mapbuf.format = PALETTE;
  /* on demande une capture : */
  if (ioctl (descrpFichier, VIDIOCMCAPTURE, &mapbuf))
    {
      perror ("VIDIOCMCAPTURE");
      printf ("L'application doit quitter\n\a");
      closeCam ();
      exit (-1);
    }
  i = -1;
  /* Wait frame to be completed */
if (ioctl(descrpFichier, VIDIOCSYNC, &mapbuf.frame) < 0) {
  perror ("VIDIOCSYNC");
  exit (1);
}
  /*posImg est le pointeur vers le debut de l'image */
  posImg = ptr ;
  /*on remplit la structure RGB24 avec les donnes rgb : */
  /*on inverse lordre des pixels pour rétablir le sens de images*/
  i = 0;
  j= 3*WIDTH*HEIGHT-1-2;
  for (y = 0; y < HEIGHT; y++)
    {
      for (x = 0; x < WIDTH; x++)
	{
	  /*On remplit le tableau rgb2 avec les composantes */
	  rgb24->rgb2[i] = posImg[j];
	  i++; j++;
	  rgb24->rgb2[i] = posImg[j];
	  i++; j++;
	  rgb24->rgb2[i] = posImg[j];
	  i++; 
	  j-=5;
	}
    }
  rgb24->width = WIDTH;
  rgb24->height = HEIGHT;
}

fichier webcam.h :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
 
#ifndef CAMERA_H
#define CAMERA_H
 
#define PALETTE VIDEO_PALETTE_RGB24;
 
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <linux/videodev.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
 
 
void openCam (char *deviceName);
void closeCam (void);
void printCap (void);
void setWin (void);
void setImage (int hue, int colour, int contrast, int brightness,
	       int whiteness, int depth);
void captureImage (RGB *rgb24);
 
 
#endif

la sructure RGB24 utilisée pour recevoir l'image :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
/**Fichier rgb 24 bits**/
typedef struct RGB24{
	int *rgb2;
	/*taille*/
	int width,height;
}RGB;

voila avec sa t'aura ton image en mémoire. Pour pouvoir la visualiser, il faut écrire une image au format rgb, c'est la ou sa se complique un peu.
Je te met une archive en piece jointe avec les fichiers necessaires (prise d'image et ecriture au format rgb).
Voila c'est un peu le bordel dans le fichier manierLesimages.c mais bon.

**Ikit** · 08/12/2007, 21h00

salut,
Merci pour ton source

j'ai compilé ... pas d'erreur

Seulement à l'exécution, j'obtient le message suivant.
J'ai regardé vite fait

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Nom: Logitech QuickCam Zoom
Type: Camera
VIDIOCSPICT: Invalid argument

Est-ce que tu peux 'en dire plus sur cette erreur ?

**apesle** · 09/12/2007, 11h34

Bizarre, j'ai jamais eu cette erreure.
As tu tout les droits, sur ta webcam (xrw on sais jamais ..)

**Ikit** · 10/12/2007, 11h36

Hélas même en exécutant le script en root ça me donne la même erreur.

avec VLC j'arrive à récupérer le flux vidéos... ainsi qu'avec transcode

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

transcode -i /dev/video0 -g 128x128  -y jpg -o /tmp/test_

me donne des images de ma webcam.

Ni y a-t-il pas moyen que j'utilise ça ? Seulement dans un fichier C je ne sais pas comment m'y prendre.

**apesle** · 10/12/2007, 18h38

tu doit pouvoir utiliser sa avec un appel systeme :
system("ta commande");
mais je sais pas trop ce que ca va donner niveau efficacité, des appels répétés.

**madjidl** · 12/01/2008, 00h34

Bonjour,
l'exemple que tu as trouvé sur ce http://pficheux.free.fr/ n'est pas compatible avec la V4L2 du noyau 2.6.
Le mieux pour toi c'est de lancer une recherche d' exemple d'acquisition compatible V4L2, de recompiler ton noyau -> comptiblité avec V4L1 ou d'attendre lundi, je t'enverrai un.

Capturer signal vidéo

C

Discussions similaires

Partager

Partager