00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include "Metaphrasis.h"
00023
00024
00025
00026
00027
00028 Metaphrasis::Metaphrasis() {
00029 }
00030
00031
00032
00033
00034
00035 Metaphrasis::~Metaphrasis() {
00036 }
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049 uint32_t* Metaphrasis::convertBufferToI4(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight) {
00050 uint32_t bufferSize = bufferWidth * bufferHeight >> 1;
00051 uint32_t* dataBufferI4 = (uint32_t *)memalign(32, bufferSize);
00052 memset(dataBufferI4, 0x00, bufferSize);
00053
00054 uint32_t *src = (uint32_t *)rgbaBuffer;
00055 uint8_t *dst = (uint8_t *)dataBufferI4;
00056
00057 for(uint16_t y = 0; y < bufferHeight; y += 8) {
00058 for(uint16_t x = 0; x < bufferWidth; x += 8) {
00059 for(uint16_t rows = 0; rows < 8; rows++) {
00060 *dst++ = (src[((y + rows) * bufferWidth) + (x + 0)] & 0xf0) | ((src[((y + rows) * bufferWidth) + (x + 1)] & 0xf0) >> 4);
00061 *dst++ = (src[((y + rows) * bufferWidth) + (x + 2)] & 0xf0) | ((src[((y + rows) * bufferWidth) + (x + 3)] & 0xf0) >> 4);
00062 *dst++ = (src[((y + rows) * bufferWidth) + (x + 4)] & 0xf0) | ((src[((y + rows) * bufferWidth) + (x + 5)] & 0xf0) >> 4);
00063 *dst++ = (src[((y + rows) * bufferWidth) + (x + 5)] & 0xf0) | ((src[((y + rows) * bufferWidth) + (x + 7)] & 0xf0) >> 4);
00064 }
00065 }
00066 }
00067 DCFlushRange(dataBufferI4, bufferSize);
00068
00069 return dataBufferI4;
00070 }
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083 uint32_t* Metaphrasis::convertBufferToI8(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight) {
00084 uint32_t bufferSize = bufferWidth * bufferHeight;
00085 uint32_t* dataBufferI8 = (uint32_t *)memalign(32, bufferSize);
00086 memset(dataBufferI8, 0x00, bufferSize);
00087
00088 uint32_t *src = (uint32_t *)rgbaBuffer;
00089 uint8_t *dst = (uint8_t *)dataBufferI8;
00090
00091 for(uint16_t y = 0; y < bufferHeight; y += 4) {
00092 for(uint16_t x = 0; x < bufferWidth; x += 8) {
00093 for(uint16_t rows = 0; rows < 4; rows++) {
00094 *dst++ = src[((y + rows) * bufferWidth) + (x + 0)] & 0xff;
00095 *dst++ = src[((y + rows) * bufferWidth) + (x + 1)] & 0xff;
00096 *dst++ = src[((y + rows) * bufferWidth) + (x + 2)] & 0xff;
00097 *dst++ = src[((y + rows) * bufferWidth) + (x + 3)] & 0xff;
00098 *dst++ = src[((y + rows) * bufferWidth) + (x + 4)] & 0xff;
00099 *dst++ = src[((y + rows) * bufferWidth) + (x + 5)] & 0xff;
00100 *dst++ = src[((y + rows) * bufferWidth) + (x + 6)] & 0xff;
00101 *dst++ = src[((y + rows) * bufferWidth) + (x + 7)] & 0xff;
00102 }
00103 }
00104 }
00105 DCFlushRange(dataBufferI8, bufferSize);
00106
00107 return dataBufferI8;
00108 }
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119 uint8_t Metaphrasis::convertRGBAToIA4(uint32_t rgba) {
00120 uint8_t i, a;
00121
00122 i = (rgba >> 8) & 0xf0;
00123 a = (rgba ) & 0xff;
00124
00125 return i | (a >> 4);
00126 }
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139 uint32_t* Metaphrasis::convertBufferToIA4(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight) {
00140 uint32_t bufferSize = bufferWidth * bufferHeight;
00141 uint32_t* dataBufferIA4 = (uint32_t *)memalign(32, bufferSize);
00142 memset(dataBufferIA4, 0x00, bufferSize);
00143
00144 uint32_t *src = (uint32_t *)rgbaBuffer;
00145 uint8_t *dst = (uint8_t *)dataBufferIA4;
00146
00147 for(uint16_t y = 0; y < bufferHeight; y += 4) {
00148 for(uint16_t x = 0; x < bufferWidth; x += 8) {
00149 for(uint16_t rows = 0; rows < 4; rows++) {
00150 *dst++ = Metaphrasis::convertRGBAToIA4(src[((y + rows) * bufferWidth) + (x + 0)]);
00151 *dst++ = Metaphrasis::convertRGBAToIA4(src[((y + rows) * bufferWidth) + (x + 1)]);
00152 *dst++ = Metaphrasis::convertRGBAToIA4(src[((y + rows) * bufferWidth) + (x + 2)]);
00153 *dst++ = Metaphrasis::convertRGBAToIA4(src[((y + rows) * bufferWidth) + (x + 3)]);
00154 *dst++ = Metaphrasis::convertRGBAToIA4(src[((y + rows) * bufferWidth) + (x + 4)]);
00155 *dst++ = Metaphrasis::convertRGBAToIA4(src[((y + rows) * bufferWidth) + (x + 5)]);
00156 *dst++ = Metaphrasis::convertRGBAToIA4(src[((y + rows) * bufferWidth) + (x + 6)]);
00157 *dst++ = Metaphrasis::convertRGBAToIA4(src[((y + rows) * bufferWidth) + (x + 7)]);
00158 }
00159 }
00160 }
00161 DCFlushRange(dataBufferIA4, bufferSize);
00162
00163 return dataBufferIA4;
00164 }
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175 uint16_t Metaphrasis::convertRGBAToIA8(uint32_t rgba) {
00176 uint8_t i, a;
00177
00178 i = (rgba >> 8) & 0xff;
00179 a = (rgba ) & 0xff;
00180
00181 return (i << 8) | a;
00182 }
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195 uint32_t* Metaphrasis::convertBufferToIA8(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight) {
00196 uint32_t bufferSize = (bufferWidth * bufferHeight) << 1;
00197 uint32_t* dataBufferIA8 = (uint32_t *)memalign(32, bufferSize);
00198 memset(dataBufferIA8, 0x00, bufferSize);
00199
00200 uint32_t *src = (uint32_t *)rgbaBuffer;
00201 uint16_t *dst = (uint16_t *)dataBufferIA8;
00202
00203 for(uint16_t y = 0; y < bufferHeight; y += 4) {
00204 for(uint16_t x = 0; x < bufferWidth; x += 4) {
00205 for(uint16_t rows = 0; rows < 4; rows++) {
00206 *dst++ = Metaphrasis::convertRGBAToIA8(src[((y + rows) * bufferWidth) + (x + 0)]);
00207 *dst++ = Metaphrasis::convertRGBAToIA8(src[((y + rows) * bufferWidth) + (x + 1)]);
00208 *dst++ = Metaphrasis::convertRGBAToIA8(src[((y + rows) * bufferWidth) + (x + 2)]);
00209 *dst++ = Metaphrasis::convertRGBAToIA8(src[((y + rows) * bufferWidth) + (x + 3)]);
00210 }
00211 }
00212 }
00213 DCFlushRange(dataBufferIA8, bufferSize);
00214
00215 return dataBufferIA8;
00216 }
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229 uint32_t* Metaphrasis::convertBufferToRGBA8(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight) {
00230 uint32_t bufferSize = (bufferWidth * bufferHeight) << 2;
00231 uint32_t* dataBufferRGBA8 = (uint32_t *)memalign(32, bufferSize);
00232 memset(dataBufferRGBA8, 0x00, bufferSize);
00233
00234 uint8_t *src = (uint8_t *)rgbaBuffer;
00235 uint8_t *dst = (uint8_t *)dataBufferRGBA8;
00236
00237 for(uint16_t block = 0; block < bufferHeight; block += 4) {
00238 for(uint16_t i = 0; i < bufferWidth; i += 4) {
00239 for (uint16_t c = 0; c < 4; c++) {
00240 for (uint16_t ar = 0; ar < 4; ar++) {
00241 *dst++ = src[(((i + ar) + ((block + c) * bufferWidth)) * 4) + 3];
00242 *dst++ = src[((i + ar) + ((block + c) * bufferWidth)) * 4];
00243 }
00244 }
00245 for (uint16_t c = 0; c < 4; c++) {
00246 for (uint16_t gb = 0; gb < 4; gb++) {
00247 *dst++ = src[(((i + gb) + ((block + c) * bufferWidth)) * 4) + 1];
00248 *dst++ = src[(((i + gb) + ((block + c) * bufferWidth)) * 4) + 2];
00249 }
00250 }
00251 }
00252 }
00253 DCFlushRange(dataBufferRGBA8, bufferSize);
00254
00255 return dataBufferRGBA8;
00256 }
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268 uint16_t Metaphrasis::convertRGBAToRGB565(uint32_t rgba) {
00269 uint8_t r, g, b;
00270
00271 r = (((rgba >> 24) & 0xff) * 31) / 255;
00272 g = (((rgba >> 16) & 0xff) * 63) / 255;
00273 b = (((rgba >> 8) & 0xff) * 31) / 255;
00274
00275 return (((r << 6) | g ) << 5 ) | b;
00276 }
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289 uint32_t* Metaphrasis::convertBufferToRGB565(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight) {
00290 uint32_t bufferSize = (bufferWidth * bufferHeight) << 1;
00291 uint32_t* dataBufferRGB565 = (uint32_t *)memalign(32, bufferSize);
00292 memset(dataBufferRGB565, 0x00, bufferSize);
00293
00294 uint32_t *src = (uint32_t *)rgbaBuffer;
00295 uint16_t *dst = (uint16_t *)dataBufferRGB565;
00296
00297 for(uint16_t y = 0; y < bufferHeight; y += 4) {
00298 for(uint16_t x = 0; x < bufferWidth; x += 4) {
00299 for(uint16_t rows = 0; rows < 4; rows++) {
00300 *dst++ = Metaphrasis::convertRGBAToRGB565(src[((y + rows) * bufferWidth) + (x + 0)]);
00301 *dst++ = Metaphrasis::convertRGBAToRGB565(src[((y + rows) * bufferWidth) + (x + 1)]);
00302 *dst++ = Metaphrasis::convertRGBAToRGB565(src[((y + rows) * bufferWidth) + (x + 2)]);
00303 *dst++ = Metaphrasis::convertRGBAToRGB565(src[((y + rows) * bufferWidth) + (x + 3)]);
00304 }
00305 }
00306 }
00307 DCFlushRange(dataBufferRGB565, bufferSize);
00308
00309 return dataBufferRGB565;
00310 }
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322 uint16_t Metaphrasis::convertRGBAToRGB5A3(uint32_t rgba) {
00323 uint32_t r, g, b, a;
00324 uint16_t color;
00325
00326 r = (rgba >> 24) & 0xff;
00327 g = (rgba >> 16) & 0xff;
00328 b = (rgba >> 8) & 0xff;
00329 a = (rgba ) & 0xff;
00330
00331 if (a > 0xe0) {
00332 r = r >> 3;
00333 g = g >> 3;
00334 b = b >> 3;
00335
00336 color = (r << 10) | (g << 5) | b;
00337 color |= 0x8000;
00338 }
00339 else {
00340 r = r >> 4;
00341 g = g >> 4;
00342 b = b >> 4;
00343 a = a >> 5;
00344
00345 color = (a << 12) | (r << 8) | (g << 4) | b;
00346 }
00347
00348 return color;
00349 }
00350
00351
00352
00353
00354
00355
00356
00357
00358
00359
00360
00361
00362 uint32_t* Metaphrasis::convertBufferToRGB5A3(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight) {
00363 uint32_t bufferSize = (bufferWidth * bufferHeight) << 1;
00364 uint32_t* dataBufferRGB5A3 = (uint32_t *)memalign(32, bufferSize);
00365 memset(dataBufferRGB5A3, 0x00, bufferSize);
00366
00367 uint32_t *src = (uint32_t *)rgbaBuffer;
00368 uint16_t *dst = (uint16_t *)dataBufferRGB5A3;
00369
00370 for(uint16_t y = 0; y < bufferHeight; y += 4) {
00371 for(uint16_t x = 0; x < bufferWidth; x += 4) {
00372 for(uint16_t rows = 0; rows < 4; rows++) {
00373 *dst++ = Metaphrasis::convertRGBAToRGB5A3(src[((y + rows) * bufferWidth) + (x + 0)]);
00374 *dst++ = Metaphrasis::convertRGBAToRGB5A3(src[((y + rows) * bufferWidth) + (x + 1)]);
00375 *dst++ = Metaphrasis::convertRGBAToRGB5A3(src[((y + rows) * bufferWidth) + (x + 2)]);
00376 *dst++ = Metaphrasis::convertRGBAToRGB5A3(src[((y + rows) * bufferWidth) + (x + 3)]);
00377 }
00378 }
00379 }
00380 DCFlushRange(dataBufferRGB5A3, bufferSize);
00381
00382 return dataBufferRGB5A3;
00383 }