28package com.jogamp.opengl.test.junit.jogl.util.texture;
30import java.io.IOException;
31import java.net.MalformedURLException;
32import java.nio.ByteBuffer;
33import java.nio.ByteOrder;
35import com.jogamp.nativewindow.util.Dimension;
36import com.jogamp.nativewindow.util.PixelFormat;
37import com.jogamp.nativewindow.util.PixelFormatUtil;
38import com.jogamp.nativewindow.util.PixelRectangle;
39import com.jogamp.nativewindow.util.PixelFormat.CType;
41import org.junit.Assert;
43import org.junit.FixMethodOrder;
44import org.junit.runners.MethodSorters;
46import com.jogamp.common.util.Bitstream;
47import com.jogamp.opengl.test.junit.util.UITestCase;
53@FixMethodOrder(MethodSorters.NAME_ASCENDING)
55 static final byte undef_val = (byte)0xFF;
57 static final float red___valF;
58 static final float green_valF;
59 static final float blue__valF;
60 static final float alpha_valF;
61 static final float lum___valF;
65 final byte red___val = (byte)0x30;
66 final byte green_val = (byte)0x60;
67 final byte blue__val = (byte)0x90;
68 final byte alpha_val = (byte)0xC0;
69 red___valF = comp_val.toFloat(red___val, 0,
false);
70 green_valF = comp_val.toFloat(green_val, 1,
false);
71 blue__valF = comp_val.toFloat(blue__val, 2,
false);
72 alpha_valF = comp_val.toFloat(alpha_val, 3,
false);
73 lum___valF = ( red___valF + green_valF + blue__valF ) / 3f;
77 public void testConversion00() throws InterruptedException, IOException, MalformedURLException {
80 final PixelFormat.Composition comp = fmt.
comp;
81 System.err.printf(
"%s, %s:%n", fmt, comp);
82 final int u16_alpha = comp.
encode4CompI8((
byte)comp.fromFloat(red___valF, 0,
false),
83 (
byte)comp.fromFloat(green_valF, 0,
false),
84 (
byte)comp.fromFloat(blue__valF, 0,
false),
85 (
byte)comp.fromFloat(alpha_valF, 0,
false));
86 final int u16_undef = comp.encode4CompI8((
byte)comp.fromFloat(red___valF, 0,
false),
87 (
byte)comp.fromFloat(green_valF, 0,
false),
88 (
byte)comp.fromFloat(blue__valF, 0,
false),
90 System.err.printf(
" u16_alpha %s%n", Bitstream.toHexBinString(
true, u16_alpha, comp.bitsPerPixel()));
91 System.err.printf(
" u16_undef %s%n", Bitstream.toHexBinString(
true, u16_undef, comp.bitsPerPixel()));
93 final byte c4NormI8_alpha = (byte)comp.fromFloat(alpha_valF, 0,
false);
94 final byte c4NormI8_undef = undef_val;
95 final int compBitShift = 15;
96 final int compMask = 0x1;
97 final int v_alpha = ( c4NormI8_alpha & compMask ) << compBitShift ;
98 final int v_undef = ( c4NormI8_undef & compMask ) << compBitShift ;
99 System.err.printf(
" xx_alpha %s%n", Bitstream.toHexBinString(
true, v_alpha, comp.bitsPerPixel()));
100 System.err.printf(
" xx_undef %s%n", Bitstream.toHexBinString(
true, v_undef, comp.bitsPerPixel()));
115 final PixelFormat.Composition rgba8888Comp = rgba8888Fmt.
comp;
117 final PixelFormat.Composition rgb565Comp = rgb565Fmt.
comp;
119 final PixelFormat.Composition lumComp = lumFmt.
comp;
120 System.err.printf(
"%s, %s -> %s %s%n", rgb565Fmt, rgb565Comp, lumFmt, lumComp);
123 final float r8f = rgba8888Comp.
toFloat(r8, 0,
false);
124 final int r8fi = rgba8888Comp.fromFloat(r8f, 0,
false);
125 final float g8f = rgba8888Comp.toFloat(g8, 1,
false);
126 final int g8fi = rgba8888Comp.fromFloat(g8f, 1,
false);
127 final float b8f = rgba8888Comp.toFloat(b8, 2,
false);
128 final int b8fi = rgba8888Comp.fromFloat(b8f, 2,
false);
129 final float a8f = rgba8888Comp.toFloat(a8, 3,
false);
130 final int a8fi = rgba8888Comp.fromFloat(a8f, 3,
false);
132 System.err.printf(
"res00.0.r %s -> %f -> %s%n", Bitstream.toHexBinString(
true, r8, 8), r8f, Bitstream.toHexBinString(
true, r8fi, 8));
133 System.err.printf(
"res00.0.g %s -> %f -> %s%n", Bitstream.toHexBinString(
true, g8, 8), g8f, Bitstream.toHexBinString(
true, g8fi, 8));
134 System.err.printf(
"res00.0.b %s -> %f -> %s%n", Bitstream.toHexBinString(
true, b8, 8), b8f, Bitstream.toHexBinString(
true, b8fi, 8));
135 System.err.printf(
"res00.0.a %s -> %f -> %s%n", Bitstream.toHexBinString(
true, a8, 8), a8f, Bitstream.toHexBinString(
true, a8fi, 8));
138 final float res00_0 = ( red___valF + green_valF + blue__valF ) / 3f;
139 final int res00 = rgba8888Comp.fromFloat(res00_0, 0,
false);
140 System.err.printf(
"res01.0 ( %f + %f + %f ) / 3f = %f -> %s%n",
141 red___valF, green_valF, blue__valF, res00_0, Bitstream.toHexBinString(
true, res00, 8));
144 final float res00_0 = ( red___valF + green_valF + blue__valF ) / 3f;
145 final int res00 = lumComp.fromFloat(res00_0, 0,
false);
146 System.err.printf(
"res02.1 ( %f + %f + %f ) / 3f = %f -> %s%n",
147 red___valF, green_valF, blue__valF, res00_0, Bitstream.toHexBinString(
true, res00, 8));
151 final int rl1 = lumComp.fromFloat(red___valF, 0,
false);
152 final int gl1 = lumComp.fromFloat(green_valF, 0,
false);
153 final int bl1 = lumComp.fromFloat(blue__valF, 0,
false);
154 final float rl2 = lumComp.toFloat(rl1, 0,
false);
155 final float gl2 = lumComp.toFloat(gl1, 0,
false);
156 final float bl2 = lumComp.toFloat(bl1, 0,
false);
157 System.err.printf(
"res20.l1 ( %s + %s + %s )%n",
158 Bitstream.toHexBinString(
true, rl1, 8),
159 Bitstream.toHexBinString(
true, gl1, 8),
160 Bitstream.toHexBinString(
true, bl1, 8));
161 System.err.printf(
"res20.l2 ( %f + %f + %f )%n", rl2, gl2, bl2);
162 final float res02_l2_0 = ( rl2 + gl2 + bl2 ) / 3f;
163 final int res02_l2_x = lumComp.fromFloat(res02_l2_0, 0,
false);
164 System.err.printf(
"res20.l3 ( %f + %f + %f ) / 3f = %f -> %s%n",
165 rl2, gl2, bl2, res02_l2_0, Bitstream.toHexBinString(
true, res02_l2_x, 8));
168 final int r_1 = rgb565Comp.fromFloat(rl2, 0,
false);
169 final int g_1 = rgb565Comp.fromFloat(gl2, 1,
false);
170 final int b_1 = rgb565Comp.fromFloat(bl2, 2,
false);
171 final float r_2 = rgb565Comp.toFloat(r_1, 0,
false);
172 final float g_2 = rgb565Comp.toFloat(g_1, 1,
false);
173 final float b_2 = rgb565Comp.toFloat(b_1, 2,
false);
174 System.err.printf(
"res20._1 ( %s + %s + %s )%n",
175 Bitstream.toHexBinString(
true, r_1, 8),
176 Bitstream.toHexBinString(
true, g_1, 8),
177 Bitstream.toHexBinString(
true, b_1, 8));
178 System.err.printf(
"res20._2 ( %f + %f + %f )%n", r_2, g_2, b_2);
179 final float res02__3_0 = ( r_2 + g_2 + b_2 ) / 3f;
180 final int res02__3_x = lumComp.fromFloat(res02__3_0, 0,
false);
181 System.err.printf(
"res20._3 ( %f + %f + %f ) / 3f = %f -> %s%n",
182 r_2, g_2, b_2, res02__3_0, Bitstream.toHexBinString(
true, res02__3_x, 8));
187 final float rF = rgb565Comp.toFloat(rescaleComp(lumComp, 0, rgb565Comp, 0, red___valF), 0,
false);
188 final float gF = rgb565Comp.toFloat(rescaleComp(lumComp, 0, rgb565Comp, 1, green_valF), 1,
false);
189 final float bF = rgb565Comp.toFloat(rescaleComp(lumComp, 0, rgb565Comp, 2, blue__valF), 2,
false);
190 final float res01_0 = ( rF + gF + bF ) / 3f;
191 final int res01 = lumComp.fromFloat(res01_0, 0,
false);
192 System.err.printf(
"res30.xx ( %f + %f + %f ) / 3f = %f -> %s%n",
193 rF, gF, bF, res01_0, Bitstream.toHexBinString(
true, res01, 8));
196 final float rF = rgb565Comp.toFloat(r5, 0,
false);
197 final float gF = rgb565Comp.toFloat(g6, 1,
false);
198 final float bF = rgb565Comp.toFloat(b5, 2,
false);
200 final float lF = ( rF + gF + bF ) / 3f;
201 final int res00 = lumComp.fromFloat(lF, 0,
false);
203 System.err.printf(
"res40 ( %f + %f + %f ) / 3f = %s%n",
204 rF, gF, bF, Bitstream.toHexBinString(
true, res00, 8));
212 testConversionImpl(0 , ByteOrder.BIG_ENDIAN,
false ,
217 testConversionImpl(0 , ByteOrder.LITTLE_ENDIAN,
false ,
222 testConversionImpl(0 , ByteOrder.BIG_ENDIAN,
false ,
227 testConversionImpl(259 , ByteOrder.BIG_ENDIAN,
false ,
232 testConversionImpl(301 , ByteOrder.BIG_ENDIAN,
false ,
240 if( sIdx >= 0 && sIdx < srcComp.componentCount() ) {
241 return srcComp.toFloat(srcComp.fromFloat(f, sIdx,
false), sIdx,
false);
246 static final byte rescaleComp(
final PixelFormat.Composition srcComp,
final int sIdx,
247 final PixelFormat.Composition dstComp,
final int dIdx,
final float f) {
248 if( dIdx >= 0 && dIdx < dstComp.componentCount() ) {
249 return (
byte)dstComp.fromFloat(sourceNorm(srcComp, sIdx, f), dIdx,
false);
254 static final void getComponentData(
final PixelFormat srcFmt,
final PixelFormat dstFmt,
final byte[] components) {
255 final PixelFormat.Composition srcComp = srcFmt.comp;
256 final PixelFormat.Composition dstComp = dstFmt.comp;
257 final byte b1, b2, b3, b4;
259 if( PixelFormat.LUMINANCE == srcFmt ) {
263 b1 = rescaleComp(srcComp, 0, dstComp, 0, lum___valF);
270 u16 = dstComp.encode3CompI8(
271 rescaleComp(srcComp, 0, dstComp, 0, lum___valF),
272 rescaleComp(srcComp, 0, dstComp, 1, lum___valF),
273 rescaleComp(srcComp, 0, dstComp, 2, lum___valF));
274 b1 = (byte)( u16 & 0xff );
275 b2 = (byte)( ( u16 >>> 8 ) & 0xff );
280 u16 = dstComp.encode4CompI8(
281 rescaleComp(srcComp, 0, dstComp, 0, lum___valF),
282 rescaleComp(srcComp, 0, dstComp, 1, lum___valF),
283 rescaleComp(srcComp, 0, dstComp, 2, lum___valF),
285 b1 = (byte)( u16 & 0xff );
286 b2 = (byte)( ( u16 >>> 8 ) & 0xff );
291 u16 = dstComp.encode4CompI8(
293 rescaleComp(srcComp, 0, dstComp, 0, lum___valF),
294 rescaleComp(srcComp, 0, dstComp, 1, lum___valF),
295 rescaleComp(srcComp, 0, dstComp, 2, lum___valF) );
296 b1 = (byte)( u16 & 0xff );
297 b2 = (byte)( ( u16 >>> 8 ) & 0xff );
306 b1 = rescaleComp(srcComp, 0, dstComp, 0, lum___valF);
307 b2 = rescaleComp(srcComp, 0, dstComp, 1, lum___valF);
308 b3 = rescaleComp(srcComp, 0, dstComp, 2, lum___valF);
314 b2 = rescaleComp(srcComp, 0, dstComp, 1, lum___valF);
315 b3 = rescaleComp(srcComp, 0, dstComp, 2, lum___valF);
316 b4 = rescaleComp(srcComp, 0, dstComp, 3, lum___valF);
319 b1 = rescaleComp(srcComp, 0, dstComp, 0, lum___valF);
320 b2 = rescaleComp(srcComp, 0, dstComp, 1, lum___valF);
321 b3 = rescaleComp(srcComp, 0, dstComp, 2, lum___valF);
325 throw new InternalError(
"Unhandled format "+dstFmt);
328 final int srcIdxR = srcComp.find(CType.R);
329 final int srcIdxG = srcComp.find(CType.G);
330 final int srcIdxB = srcComp.find(CType.B);
331 final int srcIdxA = srcComp.find(CType.A);
332 final boolean srcHasAlpha = 0 <= srcIdxA;
333 final boolean srcHasRGB = 0 <= srcIdxR && 0 <= srcIdxG && 0 <= srcIdxB;
338 final float rF = sourceNorm(srcComp, srcIdxR, red___valF);
339 final float gF = sourceNorm(srcComp, srcIdxG, green_valF);
340 final float bF = sourceNorm(srcComp, srcIdxB, blue__valF);
341 b1 = (byte)dstComp.fromFloat( ( rF + gF + bF ) / 3f, 0,
false);
346 b1 = rescaleComp(srcComp, 0, dstComp, 0, red___valF);
353 u16 = dstComp.encode3CompI8(
354 rescaleComp(srcComp, srcIdxR, dstComp, 0, red___valF),
355 rescaleComp(srcComp, srcIdxG, dstComp, 1, green_valF),
356 rescaleComp(srcComp, srcIdxB, dstComp, 2, blue__valF));
357 b1 = (byte)( u16 & 0xff );
358 b2 = (byte)( ( u16 >>> 8 ) & 0xff );
363 u16 = dstComp.encode3CompI8(
364 rescaleComp(srcComp, srcIdxB, dstComp, 0, blue__valF),
365 rescaleComp(srcComp, srcIdxG, dstComp, 1, green_valF),
366 rescaleComp(srcComp, srcIdxR, dstComp, 2, red___valF));
367 b1 = (byte)( u16 & 0xff );
368 b2 = (byte)( ( u16 >>> 8 ) & 0xff );
373 u16 = dstComp.encode4CompI8(
374 rescaleComp(srcComp, srcIdxR, dstComp, 0, red___valF),
375 rescaleComp(srcComp, srcIdxG, dstComp, 1, green_valF),
376 rescaleComp(srcComp, srcIdxB, dstComp, 2, blue__valF),
377 srcHasAlpha ? rescaleComp(srcComp, srcIdxA, dstComp, 3, alpha_valF) : undef_val);
378 b1 = (byte)( u16 & 0xff );
379 b2 = (byte)( ( u16 >>> 8 ) & 0xff );
384 u16 = dstComp.encode4CompI8(
385 srcHasAlpha ? rescaleComp(srcComp, srcIdxA, dstComp, 0, alpha_valF) : undef_val,
386 rescaleComp(srcComp, srcIdxB, dstComp, 1, blue__valF),
387 rescaleComp(srcComp, srcIdxG, dstComp, 2, green_valF),
388 rescaleComp(srcComp, srcIdxR, dstComp, 3, red___valF) );
389 b1 = (byte)( u16 & 0xff );
390 b2 = (byte)( ( u16 >>> 8 ) & 0xff );
396 b1 = rescaleComp(srcComp, srcIdxR, dstComp, 0, red___valF);
397 b2 = rescaleComp(srcComp, srcIdxG, dstComp, 1, green_valF);
398 b3 = rescaleComp(srcComp, srcIdxB, dstComp, 2, blue__valF);
403 b1 = rescaleComp(srcComp, srcIdxB, dstComp, 0, blue__valF);
404 b2 = rescaleComp(srcComp, srcIdxG, dstComp, 1, green_valF);
405 b3 = rescaleComp(srcComp, srcIdxR, dstComp, 2, red___valF);
409 b1 = rescaleComp(srcComp, srcIdxR, dstComp, 0, red___valF);
410 b2 = rescaleComp(srcComp, srcIdxG, dstComp, 1, green_valF);
411 b3 = rescaleComp(srcComp, srcIdxB, dstComp, 2, blue__valF);
413 b4 = rescaleComp(srcComp, srcIdxA, dstComp, 3, alpha_valF);
420 b1 = rescaleComp(srcComp, srcIdxA, dstComp, 0, alpha_valF);
424 b2 = rescaleComp(srcComp, srcIdxB, dstComp, 1, blue__valF);
425 b3 = rescaleComp(srcComp, srcIdxG, dstComp, 2, green_valF);
426 b4 = rescaleComp(srcComp, srcIdxR, dstComp, 3, red___valF);
429 b1 = rescaleComp(srcComp, srcIdxB, dstComp, 0, blue__valF);
430 b2 = rescaleComp(srcComp, srcIdxG, dstComp, 1, green_valF);
431 b3 = rescaleComp(srcComp, srcIdxR, dstComp, 2, red___valF);
433 b4 = rescaleComp(srcComp, srcIdxA, dstComp, 3, alpha_valF);
440 b1 = rescaleComp(srcComp, srcIdxA, dstComp, 0, alpha_valF);
444 b2 = rescaleComp(srcComp, srcIdxR, dstComp, 1, red___valF);
445 b3 = rescaleComp(srcComp, srcIdxG, dstComp, 2, green_valF);
446 b4 = rescaleComp(srcComp, srcIdxB, dstComp, 3, blue__valF);
449 throw new InternalError(
"Unhandled format "+dstFmt);
457 private void testConversionImpl(
final int srcMinStrideInBytes,
final ByteOrder srcByteOrder,
final boolean srcIsGLOriented,
458 final int destMinStrideInBytes,
final boolean destIsGLOriented)
459 throws InterruptedException, IOException, MalformedURLException
461 System.err.println(
"Test00: srcMinStrideInBytes "+srcMinStrideInBytes+
", srcByteOrder "+srcByteOrder+
", srcIsGLOriented "+srcIsGLOriented+
462 ", destMinStrideInBytes "+destMinStrideInBytes+
", destIsGLOriented "+destIsGLOriented);
470 final PixelFormat[] srcFormats = PixelFormat.values();
471 final PixelFormat[] dstFormats = PixelFormat.values();
472 final int width = 64, height = 64;
474 for(
int i=0; i<srcFormats.length; i++) {
475 final PixelFormat srcFmt = srcFormats[i];
476 final int srcBpp = srcFmt.comp.bytesPerPixel();
477 final int srcStrideBytes = Math.max(srcMinStrideInBytes, width*srcBpp);
478 final ByteBuffer srcPixels = ByteBuffer.allocate(height*srcStrideBytes).order(srcByteOrder);
479 final byte[] srcData =
new byte[4];
480 getComponentData(srcFmt, srcFmt, srcData);
481 for(
int y=0; y<height; y++) {
482 int o = y*srcStrideBytes;
483 for(
int x=0; x<width; x++) {
486 srcPixels.put(o++, srcData[0]);
492 srcPixels.put(o++, srcData[0]);
493 srcPixels.put(o++, srcData[1]);
497 srcPixels.put(o++, srcData[0]);
498 srcPixels.put(o++, srcData[1]);
499 srcPixels.put(o++, srcData[2]);
507 srcPixels.put(o++, srcData[0]);
508 srcPixels.put(o++, srcData[1]);
509 srcPixels.put(o++, srcData[2]);
510 srcPixels.put(o++, srcData[3]);
513 throw new InternalError(
"Unhandled format "+srcFmt);
517 final PixelRectangle imageSrc =
new PixelRectangle.GenericPixelRect(srcFmt,
new Dimension(width, height),
518 srcStrideBytes, srcIsGLOriented, srcPixels);
520 System.err.println(
"CONVERT["+i+
"][*]: Image0 - Orig: "+imageSrc);
521 System.err.printf(
"Source %s, %s%n", srcFmt, srcFmt.comp);
522 System.err.printf(
"Source Data: %s%n", Bitstream.toHexBinString(
true, srcData, 0, srcFmt.comp.bytesPerPixel()));
523 testComponents(imageSrc, 0, 0, srcData, 0);
524 testComponents(imageSrc, width-1, height-1, srcData, 0);
526 final int maxDelta = 12;
528 for(
int j=0; j<dstFormats.length; j++) {
529 final PixelFormat destFmt = dstFormats[j];
530 System.err.println(
"CONVERT["+i+
"]["+j+
"]: "+srcFmt+
" -> "+destFmt);
531 final int destStrideBytes = Math.max(destMinStrideInBytes, width*destFmt.comp.bytesPerPixel());
532 final byte[] destComponents =
new byte[4];
533 getComponentData(srcFmt, destFmt, destComponents);
534 System.err.printf(
"Source %s, %s%n", srcFmt, srcFmt.comp);
535 System.err.printf(
"Source Data: %s%n", Bitstream.toHexBinString(
true, srcData, 0, srcFmt.comp.bytesPerPixel()));
536 System.err.printf(
"Dest %s, %s%n", destFmt, destFmt.comp);
537 System.err.printf(
"Dest Data: %s%n", Bitstream.toHexBinString(
true, destComponents, 0, destFmt.comp.bytesPerPixel()));
538 final PixelRectangle imageConv1 = PixelFormatUtil.convert(imageSrc, destFmt, destStrideBytes, destIsGLOriented,
false );
539 System.err.println(
"CONVERT["+i+
"]["+j+
"]: Conv1: "+imageConv1+
", maxDelta "+maxDelta);
540 System.err.printf(
"Conv1 Data: %s%n", Bitstream.toHexBinString(
true, imageConv1.getPixels(), 0, destFmt.comp.bytesPerPixel()));
541 testComponents(imageConv1, 0, 0, destComponents, maxDelta);
542 testComponents(imageConv1, width-1, height-1, destComponents, maxDelta);
543 if( PixelFormat.LUMINANCE != srcFmt && PixelFormat.LUMINANCE == destFmt ) {
545 System.err.println(
"CONVERT["+i+
"]["+j+
"]: Conv2: Dropped due to RGB* -> LUM");
546 }
else if( srcFmt.comp.componentCount() > destFmt.comp.componentCount() ) {
548 System.err.println(
"CONVERT["+i+
"]["+j+
"]: Conv2: Dropped due to src.componentCount > dest.componentCount");
550 final PixelRectangle imageConv2 = PixelFormatUtil.convert(imageConv1, imageSrc.getPixelformat(), imageSrc.getStride(), imageSrc.isGLOriented(),
false );
551 System.err.println(
"CONVERT["+i+
"]["+j+
"]: Conv2: "+imageConv2+
", maxDelta "+maxDelta);
552 System.err.printf(
"Conv2 Data: %s%n", Bitstream.toHexBinString(
true, imageConv2.getPixels(), 0, srcFmt.comp.bytesPerPixel()));
553 final byte[] destReComponents =
new byte[4];
554 getComponentData(destFmt, srcFmt, destReComponents);
555 System.err.printf(
"DestRe Data: %s%n", Bitstream.toHexBinString(
true, destReComponents, 0, srcFmt.comp.bytesPerPixel()));
556 testComponents(imageConv2, 0, 0, destReComponents, maxDelta);
557 testComponents(imageConv2, width-1, height-1, destReComponents, maxDelta);
570 static void dumpComponents(
final PixelRectangle image,
int x1,
int y1,
final int w,
final int h) {
571 if( x1 + w >= image.getSize().getWidth() ) {
572 x1 = image.getSize().getWidth() - w;
574 if( y1 + h >= image.getSize().getHeight() ) {
575 y1 = image.getSize().getHeight() - h;
577 System.err.print(
"PixelsBytes "+x1+
"/"+y1+
" "+w+
"x"+h+
":");
578 final ByteBuffer bb = image.getPixels();
579 final int bpp = image.getPixelformat().comp.bytesPerPixel();
580 for(
int y = y1; y< y1+h; y++) {
581 System.err.printf(
"%n[%3d][%3d] ", x1, y);
582 int o = y * image.getStride()+x1*bpp;
583 for(
int x = x1; x< x1+w; x++) {
586 final byte a = bb.get(o++);
587 System.err.printf(
" 0x%02X", a);
591 final byte a = bb.get(o++), b = bb.get(o++);
592 System.err.printf(
" 0x%02X%02X", b, a);
596 final byte a = bb.get(o++), b = bb.get(o++), c = bb.get(o++);
597 System.err.printf(
" 0x%02X%02X%02X", c, b, a);
601 final byte a = bb.get(o++), b = bb.get(o++), c = bb.get(o++), d = bb.get(o++);
602 System.err.printf(
" 0x%02X%02X%02X%02X", d, c, b, a);
608 System.err.println();
611 static final void assertEquals(
final int a,
final int b,
final int maxDelta) {
612 final int d = Math.abs( a - b );
613 Assert.assertTrue(String.format(
"Not equal: abs(%s - %s) = %d, > %d maxDelta",
614 Bitstream.toHexBinString(
true, a, 8), Bitstream.toHexBinString(
true, b, 8), d, maxDelta),
617 static final boolean equals(
final int a,
final int b,
final int maxDelta) {
618 final int d = Math.abs( a - b );
619 return d <= maxDelta;
630 static void testComponents(
final PixelRectangle image,
final int x,
final int y,
final byte[] expData,
final int maxDelta) {
631 dumpComponents(image, x, y, 3, 3);
632 final PixelFormat.Composition imgComp = image.getPixelformat().comp;
633 final ByteBuffer bb = image.getPixels();
634 final int bytesPerPixel = imgComp.bytesPerPixel();
635 final int compCount = imgComp.componentCount();
636 final int[] compBitCount = imgComp.componentBitCount();
638 final int srcPixOffset = y * image.getStride()+x*bytesPerPixel;
639 final int bbPos = bb.position();
640 bb.position(bbPos+srcPixOffset);
642 final long srcPix64 = PixelFormatUtil.getShiftedI64(imgComp.bytesPerPixel(), bb,
true);
643 final int[] srcComponents =
new int[compCount];
644 final long expPix64 = PixelFormatUtil.getShiftedI64(imgComp.bytesPerPixel(), expData, 0);
645 final int[] expComponents =
new int[compCount];
646 boolean equal =
true;
647 for(
int i=0; i<compCount; i++) {
648 srcComponents[i] = imgComp.decodeSingleI64(srcPix64, i);
649 expComponents[i] = imgComp.decodeSingleI64(expPix64, i);
650 equal = equal && equals(srcComponents[i], expComponents[i], maxDelta);
652 System.err.printf(
"Test [%3d][%3d] exp ", x, y);
653 for(
int i=0; i<compCount; i++) { System.err.printf(
"%s ", Bitstream.toHexBinString(
true, expComponents[i], compBitCount[i])); }
654 System.err.printf(
"==%nTest [%3d][%3d] has ", x, y);
655 for(
int i=0; i<compCount; i++) { System.err.printf(
"%s ", Bitstream.toHexBinString(
true, srcComponents[i], compBitCount[i])); }
656 System.err.printf(
": equal %b%n%n", equal);
657 for(
int i=0; i<compCount; i++) {
658 assertEquals(srcComponents[i], expComponents[i], maxDelta);
664 public static void main(
final String args[]) {
Testing PixelFormatUtil's Conversion using synthetic test data including strides, endian-order and al...
static void main(final String args[])
void testConversion05_srcS301_BE_TL_destS259_TL()
void testConversion01_srcS000_BE_TL_destS000_TL()
void testConversion04_srcS259_BE_TL_destS259_TL()
void testConversion03_srcS000_BE_TL_destS259_TL()
void testConversion02_srcS000_LE_TL_destS000_TL()