Capturer une image WebCam?

Bonjour a tous,
je viens de débuter en FLEX, et je me suis lancer sur un tuto proposé par O'Reilly. Ce tuto de Flex2 et AMFPHP propose la réalisation d'un trombinoscope...c'est a dire une interface, sur laquelle on peut consulter une liste d'employés, puis ajouter,supprimer ou modifier ces employés (en intéraction avec une DB)...De plus sur l'interface, il y a un petit volet avec le retour Webcam de l'utilisateur...lorsqu'il clique sur ajouter, c'est censé faire une capture de la video, et en ressortir une image PNG (qui correspond a la photo de l'employé ajouté)...donc tout marche super bien sauf cette capture video=>PNG, le fichier PNG est bien généré dans le repertoire pictures (comme prévu) mais il fait 0ko! J'ai fait des recherches sur le Web mais malheureusement pas grand chose sur le FLEX...et vu que je débute, je suis bien bloqué...donc si un expert passe par la :mrgreen: et a une idée d'ou pourrait venir ce problème, c'est avec grand plaisir!!
Merci bcp.

Bonjour,
ça manque un peu de contenu :)
as tu un lien vers le tuto ou un extrait de tes sources ?

Membor

Merci pour ta réponse :)
Voici un peu plus de contenu du projet...ça sera surement plus simple a debuggué...

Code:

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
 
Il ne nous reste plus qu’à ajouter l’appel de la méthode chargeEmployes(affiche la liste d'employés dans la DB) à l’initialisation de
l’application. Nous plaçons notre appel au sein de la fonction init déclenchée à l’initialisation de
l’application :
private function init ():void
{
monService.chargeEmployes();
videoScreen.attachCamera(Camera.getCamera());
}
monService étant l’identifiant de la classe RemoteObject, nous appelons la méthode chargeEmployes() directement
sur notre objet RemoteObject. Nous appelons ainsi une méthode de notre service distant, comme si
cette méthode était définie en ActionScript. Vous devriez voir la liste afficher les employés.
Nous ajoutons au passage un appel à la méthode attachCamera afin d’afficher l’image d’une webcam dans
l’objet VideoDisplay
[---]
voici la fonction prepareEmployés dans laquelle est censé se faire la conversion
 
private function prepareEmploye ():void
{
// récupération des champs de saisie
var prenom:String = prenom.text;
var nom:String = nom.text;
var emploi:String = emploi.text;
// nous créons une image bitmap aux dimensions de la vidéo de la webcam
var myBitmapData:BitmapData = new BitmapData ( videoScreen.width,
videoScreen.height, false);
// nous stockons la vidéo de la webcam en bitmap
myBitmapData.draw ( videoScreen );
// nous encodons le bitmap en flux PNG
var myBytes:ByteArray = PNGEnc.encode( myBitmapData );
// puis nous créons l'objet à envoyer
var monEmploye:Object = { bytes : myBytes, prenom : prenom, nom : nom,
emploi : emploi };
// nous passons l'objet à la méthode distante
monService.ajouteEmploye(monEmploye);
}

Voici maintenant le package encoding censé faire la conversion en PNG

Code:

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
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
 
package encoding
{
	import flash.utils.ByteArray;
	import flash.display.BitmapData;
	import flash.utils.getTimer;
	import flash.geom.Rectangle;
 
	public class PNGEnc {
 
	    public static function encode(img:BitmapData, type:uint = 0):ByteArray {
 
 
 
	        // Create output byte array
	        var png:ByteArray = new ByteArray();
	        // Write PNG signature
	        png.writeUnsignedInt(0x89504e47);
	        png.writeUnsignedInt(0x0D0A1A0A);
	        // Build IHDR chunk
	        var IHDR:ByteArray = new ByteArray();
	        IHDR.writeInt(img.width);
	        IHDR.writeInt(img.height);
	        if(img.transparent || type == 0)
	        {
	        	IHDR.writeUnsignedInt(0x08060000); // 32bit RGBA
	        }
	        else
	        {
	        	IHDR.writeUnsignedInt(0x08020000); //24bit RGB
	        }
	        IHDR.writeByte(0);
	        writeChunk(png,0x49484452,IHDR);
	        // Build IDAT chunk
	        var IDAT:ByteArray= new ByteArray();
 
	        switch(type)
	        {
	        	case 0:
	        		writeRaw(img, IDAT);
	        		break;
	        	case 1:
	        		writeSub(img, IDAT);
	        		break;
	        }
 
	        IDAT.compress();
	        writeChunk(png,0x49444154,IDAT);
	        // Build IEND chunk
	        writeChunk(png,0x49454E44,null);
	        // return PNG
 
 
 
	        return png;
	    }
 
	    private static function writeRaw(img:BitmapData, IDAT:ByteArray)
	    {
	        var h:int = img.height;
	        var w:int = img.width;
	        var transparent:Boolean = img.transparent;
 
	        for(var i:int=0;i < h;i++) {
	            // no filter
	            if ( !transparent ) {
	            	var subImage:ByteArray = img.getPixels(
	            		new Rectangle(0, i, w, 1));
	            	//Here we overwrite the alpha value of the first pixel
	            	//to be the filter 0 flag
	            	subImage[0] = 0;
					IDAT.writeBytes(subImage);
					//And we add a byte at the end to wrap the alpha values
					IDAT.writeByte(0xff);
	            } else {
	            	IDAT.writeByte(0);
	            	var p:uint;
	                for(var j:int=0;j < w;j++) {
	                    p = img.getPixel32(j,i);
	                    IDAT.writeUnsignedInt(
	                        uint(((p&0xFFFFFF) << 8)|
	                        (p>>>24)));
	                }
	            }
	        }
	    }
 
	    private static function writeSub(img:BitmapData, IDAT:ByteArray)
	    {
            var r1:uint;
            var g1:uint;
            var b1:uint;
            var a1:uint;
 
            var r2:uint;
            var g2:uint;
            var b2:uint;
            var a2:uint;
 
            var r3:uint;
            var g3:uint;
            var b3:uint;
            var a3:uint;
 
            var p:uint;
	        var h:int = img.height;
	        var w:int = img.width;
 
	        for(var i:int=0;i < h;i++) {
	            // no filter
	            IDAT.writeByte(1);
	            if ( !img.transparent ) {
					r1 = 0;
					g1 = 0;
					b1 = 0;
					a1 = 0xff;
	                for(var j:int=0;j < w;j++) {
	                    p = img.getPixel(j,i);
 
	                    r2 = p >> 16 & 0xff;
	                    g2 = p >> 8  & 0xff;
	                    b2 = p & 0xff;
 
	                    r3 = (r2 - r1 + 256) & 0xff;
	                    g3 = (g2 - g1 + 256) & 0xff;
	                    b3 = (b2 - b1 + 256) & 0xff;
 
	                    IDAT.writeByte(r3);
	                    IDAT.writeByte(g3);
	                    IDAT.writeByte(b3);
 
	                    r1 = r2;
	                    g1 = g2;
	                    b1 = b2;
	                    a1 = 0;
	                }
	            } else {
					r1 = 0;
					g1 = 0;
					b1 = 0;
					a1 = 0;
	                for(var k:int=0;k < w;k++) {
	                    p = img.getPixel32(k,i);
 
	                    a2 = p >> 24 & 0xff;
	                    r2 = p >> 16 & 0xff;
	                    g2 = p >> 8  & 0xff;
	                    b2 = p & 0xff;
 
	                    r3 = (r2 - r1 + 256) & 0xff;
	                    g3 = (g2 - g1 + 256) & 0xff;
	                    b3 = (b2 - b1 + 256) & 0xff;
	                    a3 = (a2 - a1 + 256) & 0xff;
 
	                    IDAT.writeByte(r3);
	                    IDAT.writeByte(g3);
	                    IDAT.writeByte(b3);
	                    IDAT.writeByte(a3);
 
	                    r1 = r2;
	                    g1 = g2;
	                    b1 = b2;
	                    a1 = a2;
	                }
	            }
	        }
	    }
 
	    private static var crcTable:Array;
	    private static var crcTableComputed:Boolean = false;
 
	    private static function writeChunk(png:ByteArray, 
	            type:uint, data:ByteArray) {
	        if (!crcTableComputed) {
	            crcTableComputed = true;
	            crcTable = [];
	            for (var n:uint = 0; n < 256; n++) {
	                var c:uint = n;
	                for (var k:uint = 0; k < 8; k++) {
	                    if (c & 1) {
	                        c = uint(uint(0xedb88320) ^ 
	                            uint(c >>> 1));
	                    } else {
	                        c = uint(c >>> 1);
	                    }
	                }
	                crcTable[n] = c;
	            }
	        }
	        var len:uint = 0;
	        if (data != null) {
	            len = data.length;
	        }
	        png.writeUnsignedInt(len);
	        var p:uint = png.position;
	        png.writeUnsignedInt(type);
	        if ( data != null ) {
	            png.writeBytes(data);
	        }
	        var e:uint = png.position;
	        png.position = p;
	        var c:uint = 0xffffffff;
	        for (var i:int = 0; i < (e-p); i++) {
	            c = uint(crcTable[
	                (c ^ png.readUnsignedByte()) & 
	                0xff] ^ (c >>> 8));
	        }
	        c = uint(c^uint(0xffffffff));
	        png.position = e;
	        png.writeUnsignedInt(c);
	    }
	}
}

Merci d'avance pour votre aide.
A+