debayering et encodage quicktime

Bonjour,

J'ai un problème technique à soumettre aux experts ;)
Je développe avec netbeans 5.x sous ubuntu 8.04 avec la J2SE.
Mon application pilote une caméra numérique en Ethernet, et je dois maintenant transférer des images via Ethernet. Je créer donc une socket etc... je peux récupérer les images sous forme d'un tableau de byte. Jusque là, pas de problème.
Le hic, c'est que je dois "debayerer" les images, et ensuite convertir la séquence en quicktime 10 bits uncompressed (festival quoi).
Il y a plusieurs obstacles, d'abord, jusqu'a présent je stockais mes pixels dans des unisgned char (8 bits), sauf que la, si je dois récupérer des données sur 10 bits, je sais plus comment les traiter. De plus, je n'ai pas trouvé comment afficher les images en ayant que les pixels, mais ça c'est une autre problématique.
Je pencherais pour du unsigned short au niveau stockage des pixels, qui est codé sur 16 bits (2 octets), mais bon, je suis pas sûr de moi, d'où mon interrogation.

Voici un bout de code que j'ai trouvé sur le filtre bayer sur developpez.net

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
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
 
#include "stdafx.h"
#include "main.h"
 
 
 
static int tile_colors[8][4] = {
    {0, 1, 1, 2},
    {1, 0, 2, 1},
    {2, 1, 1, 0},
    {1, 2, 0, 1},
    {0, 1, 1, 2},
    {1, 0, 2, 1},
    {2, 1, 1, 0},
    {1, 2, 0, 1}};
 
#define RED 0
#define GREEN 1
#define BLUE 2
 
int
gp_bayer_expand (unsigned char *input, int w, int h, unsigned char *output,
         BayerTile tile)
{
    int x, y, i;
    int colour, bayer;
    char *ptr = (char*)input;
    switch (tile) {
 
        case BAYER_TILE_RGGB:
        case BAYER_TILE_GRBG:
        case BAYER_TILE_BGGR:
        case BAYER_TILE_GBRG: 
 
            for (y = 0; y < h; ++y)
            {
                for (x = 0; x < w; ++x, ++ptr) {
                    bayer = (x&1?0:1) + (y&1?0:2);
                    colour = tile_colors[tile][bayer];
                    i = (y * w + x) * 3;
 
                    output[i+RED]    = 0;
                    output[i+GREEN]  = 0;
                    output[i+BLUE]   = 0;
                    output[i+colour] = *ptr;
                }
            }
            break;
 
        case BAYER_TILE_RGGB_INTERLACED:
        case BAYER_TILE_GRBG_INTERLACED:
        case BAYER_TILE_BGGR_INTERLACED:
        case BAYER_TILE_GBRG_INTERLACED:
 
 
            for (y = 0; y < h; ++y, ptr+=w)
                for (x = 0; x < w; ++x) {
                    bayer = (x&1?0:1) + (y&1?0:2);
 
                    colour = tile_colors[tile][bayer];
 
                    i = (y * w + x) * 3;
 
                    output[i+RED]    = 0;
                    output[i+GREEN]  = 0;
                    output[i+BLUE]   = 0;
                    output[i+colour] = (x&1)? ptr[x>>1]:ptr[(w>>1)+(x>>1)];
                }
            break;
    }
 
    return 1;
}
 
#define AD(x, y, w) ((y)*(w)*3+3*(x))
 
int
gp_bayer_interpolate (unsigned char *image, int w, int h, BayerTile tile)
{
    Log("Je suis ici dans interpolate");
    int x, y, bayer;
    int p0, p1, p2, p3;
    int div, value;
 
    switch (tile) {
    default:
    case BAYER_TILE_RGGB:
    case BAYER_TILE_RGGB_INTERLACED:
        p0 = 0; p1 = 1; p2 = 2; p3 = 3;
        break;
    case BAYER_TILE_GRBG:
    case BAYER_TILE_GRBG_INTERLACED:
        p0 = 1; p1 = 0; p2 = 3; p3 = 2;
        break;
    case BAYER_TILE_BGGR:
    case BAYER_TILE_BGGR_INTERLACED:
        p0 = 3; p1 = 2; p2 = 1; p3 = 0;
        break;
    case BAYER_TILE_GBRG:
    case BAYER_TILE_GBRG_INTERLACED:    
        p0 = 2; p1 = 3; p2 = 0; p3 = 1;
        break;
    }
 
    for (y = 0; y < h; y++)
        for (x = 0; x < w; x++) {
            bayer = (x&1?0:1) + (y&1?0:2);
            if ( bayer == p0 ) {
 
                /* red. green lrtb, blue diagonals */
                div = value = 0;
                if (y) {
                    value += image[AD(x,y-1,w)+GREEN];
                    div++;
                }
                if (y < (h - 1)) {
                    value += image[AD(x,y+1,w)+GREEN];
                    div++;
                }
                if (x) {
                    value += image[AD(x-1,y,w)+GREEN];
                    div++;
                }
                if (x < (w - 1)) {
                    value += image[AD(x+1,y,w)+GREEN];
                    div++;
                }
                image[AD(x,y,w)+GREEN] = value / div;
 
                div = value = 0;
                if ((y < (h - 1)) && (x < (w - 1))) {
                    value += image[AD(x+1,y+1,w)+BLUE];
                    div++;
                }
                if ((y) && (x)) {
                    value += image[AD(x-1,y-1,w)+BLUE];
                    div++;
                }
                if ((y < (h - 1)) && (x)) {
                    value += image[AD(x-1,y+1,w)+BLUE];
                    div++;
                }
                if ((y) && (x < (w - 1))) {
                    value += image[AD(x+1,y-1,w)+BLUE];
                    div++;
                }
                image[AD(x,y,w)+BLUE] = value / div;
 
            } else if (bayer == p1) {
 
                /* green. red lr, blue tb */
                div = value = 0;
                if (x < (w - 1)) {
                    value += image[AD(x+1,y,w)+RED];
                    div++;
                }
                if (x) {
                    value += image[AD(x-1,y,w)+RED];
                    div++;
                }
                image[AD(x,y,w)+RED] = value / div;
 
                div = value = 0;
                if (y < (h - 1)) {
                    value += image[AD(x,y+1,w)+BLUE];
                    div++;
                }
                if (y) {
                    value += image[AD(x,y-1,w)+BLUE];
                    div++;
                }
                image[AD(x,y,w)+BLUE] = value / div;
 
            } else if ( bayer == p2 ) {
 
                /* green. blue lr, red tb */
                div = value = 0;
 
                if (x < (w - 1)) {
                    value += image[AD(x+1,y,w)+BLUE];
                    div++;
                }
                if (x) {
                    value += image[AD(x-1,y,w)+BLUE];
                    div++;
                }
                image[AD(x,y,w)+BLUE] = value / div;
 
                div = value = 0;
                if (y < (h - 1)) {
                    value += image[AD(x,y+1,w)+RED];
                    div++;
                }
                if (y) {
                    value += image[AD(x,y-1,w)+RED];
                    div++;
                }
                image[AD(x,y,w)+RED] = value / div;
 
            } else {
 
                /* blue. green lrtb, red diagonals */
                div = value = 0;
 
                if (y) {
                    value += image[AD(x,y-1,w)+GREEN];
                    div++;
                }
                if (y < (h - 1)) {
                    value += image[AD(x,y+1,w)+GREEN];
                    div++;
                }
                if (x) {
                    value += image[AD(x-1,y,w)+GREEN];
                    div++;
                }
                if (x < (w - 1)) {
                    value += image[AD(x+1,y,w)+GREEN];
                    div++;
                }
                image[AD(x,y,w)+GREEN] = value / div;
 
                div = value = 0;
                if ((y < (h - 1)) && (x < (w - 1))) {
                    value += image[AD(x+1,y+1,w)+RED];
                    div++;
                }
                if ((y) && (x)) {
                    value += image[AD(x-1,y-1,w)+RED];
                    div++;
                }
                if ((y < (h - 1)) && (x)) {
                    value += image[AD(x-1,y+1,w)+RED];
                    div++;
                }
                if ((y) && (x < (w - 1))) {
                    value += image[AD(x+1,y-1,w)+RED];
                    div++;
                }
                image[AD(x,y,w)+RED] = value / div;
            }
        }
 
    return 1;
}
 
int
gp_bayer_decode (unsigned char *input, int w, int h, unsigned char *output,
         BayerTile tile)
{
    gp_bayer_expand (input, w, h, output, tile);
    gp_bayer_interpolate (output, w, h, tile);
    return 1;
}

Ce code est fait pour du 8 bit me semble-t-il, comment pourrais-je faire pour l'appliquer sur 10 bits.

Ensuite, il y'a un autre gros obstacle, la conversion des images en une séquence quicktime 10 bit uncompressed. Et la, je nage totalement :oops:
Déjà est-ce faisable sous linux ?

Si quelqu'un aurait au moins une piste que je puisse creuser ça serait gentil.
Merci beaucoup,
Dan.

* Ton code n'est pas en Java mais en C!

* Si tu recuperes des donnees en 16 bits au lieu de 8 bits, oui remplace unsigned char par unsigned short

* Dans ces 16 bits, lesquels sont significatifs? S'ils ne sont pas alignes a droite il faut un shift (>>)

* En combien de bits est ta sortie? Je suppose que c'est du 32 bit = 10+10+10 bit avec 2 bits inutilises. Dans ce cas utilise un tableau de long (32 bit) en output. Ensuite tu as quelque chose comme:

Code:

output[n] = rouge << 20 + vert << 10 + bleu;

Citation:

Envoyé par bredelet

* Ton code n'est pas en Java mais en C!

C'était juste pour la logique de l'algo de debayering en fait :)

Citation:

Envoyé par bredelet

* En combien de bits est ta sortie? Je suppose que c'est du 32 bit = 10+10+10 bit avec 2 bits inutilises.

Je récupère chaque pixels de l'image sur 10bits mais non interpolés, donc je dois appliquer un filtre bayer. En sortie, en effet je dois théoriquement retrouver le RGB sur chacun 10bits. Il est donc effectivement plus rentable d'utiliser un long plutôt que 3 WORD (enfin, unsigned short, désolé habitude mfc)

Mais je me heurte à un autre problème maintenant, le coté quicktime. J'ai bien regardé de partout et le java quicktime n'est dispo que sous windows (et aussi sous mac je crois), mais sous linux rien. Alors j'ai trouvé une librairie qui est quicktime 4 linux, en C, donc telles que les choses se présentent, je pense devoir utliser la JNI (sans être sûr du résultat), ce qui ne m'enchante pas du tout :?
J'ai posté sur le forum de SUN pour voir si les gars ont quelque chose sous le coude.

Merci,
Dan.