Images.cpp

   1 //
   2 // Copyright 2006 The Android Open Source Project
   3 //
   4 // Build resource files from raw assets.
   5 //
   6
   7 #define PNG_INTERNAL
   8
   9 #include "Images.h"
  10
  11 #include <utils/ResourceTypes.h>
  12 #include <utils/ByteOrder.h>
  13
  14 #include <png.h>
  15
  16 #define NOISY(x) //x
  17
  18 static void
  19 png_write_aapt_file(png_structp png_ptr, png_bytep data, png_size_t length)
  20 {
  21     status_t err = ((AaptFile*)png_ptr->io_ptr)->writeData(data, length);
  22     if (err != NO_ERROR) {
  23         png_error(png_ptr, "Write Error");
  24     }
  25 }
  26
  27
  28 static void
  29 png_flush_aapt_file(png_structp png_ptr)
  30 {
  31 }
  32
  33 // This holds an image as 8bpp RGBA.
  34 struct image_info
  35 {
  36     image_info() : rows(NULL), is9Patch(false), allocRows(NULL) { }
  37     ~image_info() {
  38         if (rows && rows != allocRows) {
  39             free(rows);
  40         }
  41         if (allocRows) {
  42             for (int i=0; i<(int)allocHeight; i++) {
  43                 free(allocRows[i]);
  44             }
  45             free(allocRows);
  46         }
  47     }
  48
  49     png_uint_32 width;
  50     png_uint_32 height;
  51     png_bytepp rows;
  52
  53     // 9-patch info.
  54     bool is9Patch;
  55     Res_png_9patch info9Patch;
  56
  57     png_uint_32 allocHeight;
  58     png_bytepp allocRows;
  59 };
  60
  61 static void read_png(const char* imageName,
  62                      png_structp read_ptr, png_infop read_info,
  63                      image_info* outImageInfo)
  64 {
  65     int color_type;
  66     int bit_depth, interlace_type, compression_type;
  67     int i;
  68
  69     png_read_info(read_ptr, read_info);
  70
  71     png_get_IHDR(read_ptr, read_info, &outImageInfo->width,
  72        &outImageInfo->height, &bit_depth, &color_type,
  73        &interlace_type, &compression_type, NULL);
  74
  75     //printf("Image %s:\n", imageName);
  76     //printf("color_type=%d, bit_depth=%d, interlace_type=%d, compression_type=%d\n",
  77     //       color_type, bit_depth, interlace_type, compression_type);
  78
  79     if (color_type == PNG_COLOR_TYPE_PALETTE)
  80         png_set_palette_to_rgb(read_ptr);
  81
  82     if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
  83         png_set_gray_1_2_4_to_8(read_ptr);
  84
  85     if (png_get_valid(read_ptr, read_info, PNG_INFO_tRNS)) {
  86         //printf("Has PNG_INFO_tRNS!\n");
  87         png_set_tRNS_to_alpha(read_ptr);
  88     }
  89
  90     if (bit_depth == 16)
  91         png_set_strip_16(read_ptr);
  92
  93     if ((color_type&PNG_COLOR_MASK_ALPHA) == 0)
  94         png_set_add_alpha(read_ptr, 0xFF, PNG_FILLER_AFTER);
  95
  96     if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
  97         png_set_gray_to_rgb(read_ptr);
  98
  99     png_read_update_info(read_ptr, read_info);
 100
 101     outImageInfo->rows = (png_bytepp)malloc(
 102         outImageInfo->height * png_sizeof(png_bytep));
 103     outImageInfo->allocHeight = outImageInfo->height;
 104     outImageInfo->allocRows = outImageInfo->rows;
 105
 106     png_set_rows(read_ptr, read_info, outImageInfo->rows);
 107
 108     for (i = 0; i < (int)outImageInfo->height; i++)
 109     {
 110         outImageInfo->rows[i] = (png_bytep)
 111             malloc(png_get_rowbytes(read_ptr, read_info));
 112     }
 113
 114     png_read_image(read_ptr, outImageInfo->rows);
 115
 116     png_read_end(read_ptr, read_info);
 117
 118     NOISY(printf("Image %s: w=%d, h=%d, d=%d, colors=%d, inter=%d, comp=%d\n",
 119                  imageName,
 120                  (int)outImageInfo->width, (int)outImageInfo->height,
 121                  bit_depth, color_type,
 122                  interlace_type, compression_type));
 123
 124     png_get_IHDR(read_ptr, read_info, &outImageInfo->width,
 125        &outImageInfo->height, &bit_depth, &color_type,
 126        &interlace_type, &compression_type, NULL);
 127 }
 128
 129 static bool is_tick(png_bytep p, bool transparent, const char** outError)
 130 {
 131     if (transparent) {
 132         if (p[3] == 0) {
 133             return false;
 134         }
 135         if (p[3] != 0xff) {
 136             *outError = "Frame pixels must be either solid or transparent (not intermediate alphas)";
 137             return false;
 138         }
 139         if (p[0] != 0 || p[1] != 0 || p[2] != 0) {
 140             *outError = "Ticks in transparent frame must be black";
 141         }
 142         return true;
 143     }
 144
 145     if (p[3] != 0xFF) {
 146         *outError = "White frame must be a solid color (no alpha)";
 147     }
 148     if (p[0] == 0xFF && p[1] == 0xFF && p[2] == 0xFF) {
 149         return false;
 150     }
 151     if (p[0] != 0 || p[1] != 0 || p[2] != 0) {
 152         *outError = "Ticks in white frame must be black";
 153         return false;
 154     }
 155     return true;
 156 }
 157
 158 enum {
 159     TICK_START,
 160     TICK_INSIDE_1,
 161     TICK_OUTSIDE_1
 162 };
 163
 164 static status_t get_horizontal_ticks(
 165         png_bytep row, int width, bool transparent, bool required,
 166         int32_t* outLeft, int32_t* outRight, const char** outError,
 167         uint8_t* outDivs, bool multipleAllowed)
 168 {
 169     int i;
 170     *outLeft = *outRight = -1;
 171     int state = TICK_START;
 172     bool found = false;
 173
 174     for (i=1; i<width-1; i++) {
 175         if (is_tick(row+i*4, transparent, outError)) {
 176             if (state == TICK_START ||
 177                 (state == TICK_OUTSIDE_1 && multipleAllowed)) {
 178                 *outLeft = i-1;
 179                 *outRight = width-2;
 180                 found = true;
 181                 if (outDivs != NULL) {
 182                     *outDivs += 2;
 183                 }
 184                 state = TICK_INSIDE_1;
 185             } else if (state == TICK_OUTSIDE_1) {
 186                 *outError = "Can't have more than one marked region along edge";
 187                 *outLeft = i;
 188                 return UNKNOWN_ERROR;
 189             }
 190         } else if (*outError == NULL) {
 191             if (state == TICK_INSIDE_1) {
 192                 // We're done with this div.  Move on to the next.
 193                 *outRight = i-1;
 194                 outRight += 2;
 195                 outLeft += 2;
 196                 state = TICK_OUTSIDE_1;
 197             }
 198         } else {
 199             *outLeft = i;
 200             return UNKNOWN_ERROR;
 201         }
 202     }
 203
 204     if (required && !found) {
 205         *outError = "No marked region found along edge";
 206         *outLeft = -1;
 207         return UNKNOWN_ERROR;
 208     }
 209
 210     return NO_ERROR;
 211 }
 212
 213 static status_t get_vertical_ticks(
 214         png_bytepp rows, int offset, int height, bool transparent, bool required,
 215         int32_t* outTop, int32_t* outBottom, const char** outError,
 216         uint8_t* outDivs, bool multipleAllowed)
 217 {
 218     int i;
 219     *outTop = *outBottom = -1;
 220     int state = TICK_START;
 221     bool found = false;
 222
 223     for (i=1; i<height-1; i++) {
 224         if (is_tick(rows[i]+offset, transparent, outError)) {
 225             if (state == TICK_START ||
 226                 (state == TICK_OUTSIDE_1 && multipleAllowed)) {
 227                 *outTop = i-1;
 228                 *outBottom = height-2;
 229                 found = true;
 230                 if (outDivs != NULL) {
 231                     *outDivs += 2;
 232                 }
 233                 state = TICK_INSIDE_1;
 234             } else if (state == TICK_OUTSIDE_1) {
 235                 *outError = "Can't have more than one marked region along edge";
 236                 *outTop = i;
 237                 return UNKNOWN_ERROR;
 238             }
 239         } else if (*outError == NULL) {
 240             if (state == TICK_INSIDE_1) {
 241                 // We're done with this div.  Move on to the next.
 242                 *outBottom = i-1;
 243                 outTop += 2;
 244                 outBottom += 2;
 245                 state = TICK_OUTSIDE_1;
 246             }
 247         } else {
 248             *outTop = i;
 249             return UNKNOWN_ERROR;
 250         }
 251     }
 252
 253     if (required && !found) {
 254         *outError = "No marked region found along edge";
 255         *outTop = -1;
 256         return UNKNOWN_ERROR;
 257     }
 258
 259     return NO_ERROR;
 260 }
 261
 262 static uint32_t get_color(
 263     png_bytepp rows, int left, int top, int right, int bottom)
 264 {
 265     png_bytep color = rows[top] + left*4;
 266
 267     if (left > right || top > bottom) {
 268         return Res_png_9patch::TRANSPARENT_COLOR;
 269     }
 270
 271     while (top <= bottom) {
 272         for (int i = left; i <= right; i++) {
 273             png_bytep p = rows[top]+i*4;
 274             if (color[3] == 0) {
 275                 if (p[3] != 0) {
 276                     return Res_png_9patch::NO_COLOR;
 277                 }
 278             } else if (p[0] != color[0] || p[1] != color[1]
 279                        || p[2] != color[2] || p[3] != color[3]) {
 280                 return Res_png_9patch::NO_COLOR;
 281             }
 282         }
 283         top++;
 284     }
 285
 286     if (color[3] == 0) {
 287         return Res_png_9patch::TRANSPARENT_COLOR;
 288     }
 289     return (color[3]<<24) | (color[0]<<16) | (color[1]<<8) | color[2];
 290 }
 291
 292 static void select_patch(
 293     int which, int front, int back, int size, int* start, int* end)
 294 {
 295     switch (which) {
 296     case 0:
 297         *start = 0;
 298         *end = front-1;
 299         break;
 300     case 1:
 301         *start = front;
 302         *end = back-1;
 303         break;
 304     case 2:
 305         *start = back;
 306         *end = size-1;
 307         break;
 308     }
 309 }
 310
 311 static uint32_t get_color(image_info* image, int hpatch, int vpatch)
 312 {
 313     int left, right, top, bottom;
 314     select_patch(
 315         hpatch, image->info9Patch.xDivs[0], image->info9Patch.xDivs[1],
 316         image->width, &left, &right);
 317     select_patch(
 318         vpatch, image->info9Patch.yDivs[0], image->info9Patch.yDivs[1],
 319         image->height, &top, &bottom);
 320     //printf("Selecting h=%d v=%d: (%d,%d)-(%d,%d)\n",
 321     //       hpatch, vpatch, left, top, right, bottom);
 322     const uint32_t c = get_color(image->rows, left, top, right, bottom);
 323     NOISY(printf("Color in (%d,%d)-(%d,%d): #%08x\n", left, top, right, bottom, c));
 324     return c;
 325 }
 326
 327 static status_t do_9patch(const char* imageName, image_info* image)
 328 {
 329     image->is9Patch = true;
 330
 331     int W = image->width;
 332     int H = image->height;
 333     int i, j;
 334
 335     int maxSizeXDivs = (W / 2 + 1) * sizeof(int32_t);
 336     int maxSizeYDivs = (H / 2 + 1) * sizeof(int32_t);
 337     int32_t* xDivs = (int32_t*) malloc(maxSizeXDivs);
 338     int32_t* yDivs = (int32_t*) malloc(maxSizeYDivs);
 339     uint8_t  numXDivs = 0;
 340     uint8_t  numYDivs = 0;
 341     int8_t numColors;
 342     int numRows;
 343     int numCols;
 344     int top;
 345     int left;
 346     int right;
 347     int bottom;
 348     memset(xDivs, -1, maxSizeXDivs);
 349     memset(yDivs, -1, maxSizeYDivs);
 350     image->info9Patch.paddingLeft = image->info9Patch.paddingRight =
 351         image->info9Patch.paddingTop = image->info9Patch.paddingBottom = -1;
 352
 353     png_bytep p = image->rows[0];
 354     bool transparent = p[3] == 0;
 355     bool hasColor = false;
 356
 357     const char* errorMsg = NULL;
 358     int errorPixel = -1;
 359     const char* errorEdge = "";
 360
 361     int colorIndex = 0;
 362
 363     // Validate size...
 364     if (W < 3 || H < 3) {
 365         errorMsg = "Image must be at least 3x3 (1x1 without frame) pixels";
 366         goto getout;
 367     }
 368
 369     // Validate frame...
 370     if (!transparent &&
 371         (p[0] != 0xFF || p[1] != 0xFF || p[2] != 0xFF || p[3] != 0xFF)) {
 372         errorMsg = "Must have one-pixel frame that is either transparent or white";
 373         goto getout;
 374     }
 375
 376     // Find left and right of sizing areas...
 377     if (get_horizontal_ticks(p, W, transparent, true, &xDivs[0],
 378                              &xDivs[1], &errorMsg, &numXDivs, true) != NO_ERROR) {
 379         errorPixel = xDivs[0];
 380         errorEdge = "top";
 381         goto getout;
 382     }
 383
 384     // Find top and bottom of sizing areas...
 385     if (get_vertical_ticks(image->rows, 0, H, transparent, true, &yDivs[0],
 386                            &yDivs[1], &errorMsg, &numYDivs, true) != NO_ERROR) {
 387         errorPixel = yDivs[0];
 388         errorEdge = "left";
 389         goto getout;
 390     }
 391
 392     // Find left and right of padding area...
 393     if (get_horizontal_ticks(image->rows[H-1], W, transparent, false, &image->info9Patch.paddingLeft,
 394                              &image->info9Patch.paddingRight, &errorMsg, NULL, false) != NO_ERROR) {
 395         errorPixel = image->info9Patch.paddingLeft;
 396         errorEdge = "bottom";
 397         goto getout;
 398     }
 399
 400     // Find top and bottom of padding area...
 401     if (get_vertical_ticks(image->rows, (W-1)*4, H, transparent, false, &image->info9Patch.paddingTop,
 402                            &image->info9Patch.paddingBottom, &errorMsg, NULL, false) != NO_ERROR) {
 403         errorPixel = image->info9Patch.paddingTop;
 404         errorEdge = "right";
 405         goto getout;
 406     }
 407
 408     // Copy patch data into image
 409     image->info9Patch.numXDivs = numXDivs;
 410     image->info9Patch.numYDivs = numYDivs;
 411     image->info9Patch.xDivs = xDivs;
 412     image->info9Patch.yDivs = yDivs;
 413
 414     // If padding is not yet specified, take values from size.
 415     if (image->info9Patch.paddingLeft < 0) {
 416         image->info9Patch.paddingLeft = xDivs[0];
 417         image->info9Patch.paddingRight = W - 2 - xDivs[1];
 418     } else {
 419         // Adjust value to be correct!
 420         image->info9Patch.paddingRight = W - 2 - image->info9Patch.paddingRight;
 421     }
 422     if (image->info9Patch.paddingTop < 0) {
 423         image->info9Patch.paddingTop = yDivs[0];
 424         image->info9Patch.paddingBottom = H - 2 - yDivs[1];
 425     } else {
 426         // Adjust value to be correct!
 427         image->info9Patch.paddingBottom = H - 2 - image->info9Patch.paddingBottom;
 428     }
 429
 430     NOISY(printf("Size ticks for %s: x0=%d, x1=%d, y0=%d, y1=%d\n", imageName,
 431                  image->info9Patch.xDivs[0], image->info9Patch.xDivs[1],
 432                  image->info9Patch.yDivs[0], image->info9Patch.yDivs[1]));
 433     NOISY(printf("padding ticks for %s: l=%d, r=%d, t=%d, b=%d\n", imageName,
 434                  image->info9Patch.paddingLeft, image->info9Patch.paddingRight,
 435                  image->info9Patch.paddingTop, image->info9Patch.paddingBottom));
 436
 437     // Remove frame from image.
 438     image->rows = (png_bytepp)malloc((H-2) * png_sizeof(png_bytep));
 439     for (i=0; i<(H-2); i++) {
 440         image->rows[i] = image->allocRows[i+1];
 441         memmove(image->rows[i], image->rows[i]+4, (W-2)*4);
 442     }
 443     image->width -= 2;
 444     W = image->width;
 445     image->height -= 2;
 446     H = image->height;
 447
 448     // Figure out the number of rows and columns in the N-patch
 449     numCols = numXDivs + 1;
 450     if (xDivs[0] == 0) {  // Column 1 is strechable
 451         numCols--;
 452     }
 453     if (xDivs[numXDivs - 1] == W) {
 454         numCols--;
 455     }
 456     numRows = numYDivs + 1;
 457     if (yDivs[0] == 0) {  // Row 1 is strechable
 458         numRows--;
 459     }
 460     if (yDivs[numYDivs - 1] == H) {
 461         numRows--;
 462     }
 463     numColors = numRows * numCols;
 464     image->info9Patch.numColors = numColors;
 465     image->info9Patch.colors = (uint32_t*)malloc(numColors * sizeof(uint32_t));
 466
 467     // Fill in color information for each patch.
 468
 469     uint32_t c;
 470     top = 0;
 471
 472     // The first row always starts with the top being at y=0 and the bottom
 473     // being either yDivs[1] (if yDivs[0]=0) of yDivs[0].  In the former case
 474     // the first row is stretchable along the Y axis, otherwise it is fixed.
 475     // The last row always ends with the bottom being bitmap.height and the top
 476     // being either yDivs[numYDivs-2] (if yDivs[numYDivs-1]=bitmap.height) or
 477     // yDivs[numYDivs-1]. In the former case the last row is stretchable along
 478     // the Y axis, otherwise it is fixed.
 479     //
 480     // The first and last columns are similarly treated with respect to the X
 481     // axis.
 482     //
 483     // The above is to help explain some of the special casing that goes on the
 484     // code below.
 485
 486     // The initial yDiv and whether the first row is considered stretchable or
 487     // not depends on whether yDiv[0] was zero or not.
 488     for (j = (yDivs[0] == 0 ? 1 : 0);
 489           j <= numYDivs && top < H;
 490           j++) {
 491         if (j == numYDivs) {
 492             bottom = H;
 493         } else {
 494             bottom = yDivs[j];
 495         }
 496         left = 0;
 497         // The initial xDiv and whether the first column is considered
 498         // stretchable or not depends on whether xDiv[0] was zero or not.
 499         for (i = xDivs[0] == 0 ? 1 : 0;
 500               i <= numXDivs && left < W;
 501               i++) {
 502             if (i == numXDivs) {
 503                 right = W;
 504             } else {
 505                 right = xDivs[i];
 506             }
 507             c = get_color(image->rows, left, top, right - 1, bottom - 1);
 508             image->info9Patch.colors[colorIndex++] = c;
 509             NOISY(if (c != Res_png_9patch::NO_COLOR) hasColor = true);
 510             left = right;
 511         }
 512         top = bottom;
 513     }
 514
 515     assert(colorIndex == numColors);
 516
 517     for (i=0; i<numColors; i++) {
 518         if (hasColor) {
 519             if (i == 0) printf("Colors in %s:\n ", imageName);
 520             printf(" #%08x", image->info9Patch.colors[i]);
 521             if (i == numColors - 1) printf("\n");
 522         }
 523     }
 524
 525     image->is9Patch = true;
 526     image->info9Patch.deviceToFile();
 527
 528 getout:
 529     if (errorMsg) {
 530         fprintf(stderr,
 531             "ERROR: 9-patch image %s malformed.\n"
 532             "       %s.\n", imageName, errorMsg);
 533         if (errorPixel >= 0) {
 534             fprintf(stderr,
 535             "       Found at pixel #%d along %s edge.\n", errorPixel, errorEdge);
 536         } else {
 537             fprintf(stderr,
 538             "       Found along %s edge.\n", errorEdge);
 539         }
 540         return UNKNOWN_ERROR;
 541     }
 542     return NO_ERROR;
 543 }
 544
 545 static void checkNinePatchSerialization(Res_png_9patch* inPatch,  void * data)
 546 {
 547     if (sizeof(void*) != sizeof(int32_t)) {
 548         // can't deserialize on a non-32 bit system
 549         return;
 550     }
 551     size_t patchSize = inPatch->serializedSize();
 552     void * newData = malloc(patchSize);
 553     memcpy(newData, data, patchSize);
 554     Res_png_9patch* outPatch = inPatch->deserialize(newData);
 555     // deserialization is done in place, so outPatch == newData
 556     assert(outPatch == newData);
 557     assert(outPatch->numXDivs == inPatch->numXDivs);
 558     assert(outPatch->numYDivs == inPatch->numYDivs);
 559     assert(outPatch->paddingLeft == inPatch->paddingLeft);
 560     assert(outPatch->paddingRight == inPatch->paddingRight);
 561     assert(outPatch->paddingTop == inPatch->paddingTop);
 562     assert(outPatch->paddingBottom == inPatch->paddingBottom);
 563     for (int i = 0; i < outPatch->numXDivs; i++) {
 564         assert(outPatch->xDivs[i] == inPatch->xDivs[i]);
 565     }
 566     for (int i = 0; i < outPatch->numYDivs; i++) {
 567         assert(outPatch->yDivs[i] == inPatch->yDivs[i]);
 568     }
 569     for (int i = 0; i < outPatch->numColors; i++) {
 570         assert(outPatch->colors[i] == inPatch->colors[i]);
 571     }
 572     free(newData);
 573 }
 574
 575 static bool patch_equals(Res_png_9patch& patch1, Res_png_9patch& patch2) {
 576     if (!(patch1.numXDivs == patch2.numXDivs &&
 577           patch1.numYDivs == patch2.numYDivs &&
 578           patch1.numColors == patch2.numColors &&
 579           patch1.paddingLeft == patch2.paddingLeft &&
 580           patch1.paddingRight == patch2.paddingRight &&
 581           patch1.paddingTop == patch2.paddingTop &&
 582           patch1.paddingBottom == patch2.paddingBottom)) {
 583             return false;
 584     }
 585     for (int i = 0; i < patch1.numColors; i++) {
 586         if (patch1.colors[i] != patch2.colors[i]) {
 587             return false;
 588         }
 589     }
 590     for (int i = 0; i < patch1.numXDivs; i++) {
 591         if (patch1.xDivs[i] != patch2.xDivs[i]) {
 592             return false;
 593         }
 594     }
 595     for (int i = 0; i < patch1.numYDivs; i++) {
 596         if (patch1.yDivs[i] != patch2.yDivs[i]) {
 597             return false;
 598         }
 599     }
 600     return true;
 601 }
 602
 603 static void dump_image(int w, int h, png_bytepp rows, int bpp)
 604 {
 605     int i, j, rr, gg, bb, aa;
 606
 607     for (j = 0; j < h; j++) {
 608         png_bytep row = rows[j];
 609         for (i = 0; i < w; i++) {
 610             rr = row[0];
 611             gg = row[1];
 612             bb = row[2];
 613             aa = row[3];
 614             row += bpp;
 615
 616             if (i == 0) {
 617                 printf("Row %d:", j);
 618             }
 619             switch (bpp) {
 620             case 1:
 621                 printf(" (%d)", rr);
 622                 break;
 623             case 2:
 624                 printf(" (%d %d", rr, gg);
 625                 break;
 626             case 3:
 627                 printf(" (%d %d %d)", rr, gg, bb);
 628                 break;
 629             case 4:
 630                 printf(" (%d %d %d %d)", rr, gg, bb, aa);
 631                 break;
 632             }
 633             if (i == (w - 1)) {
 634                 NOISY(printf("\n"));
 635             }
 636         }
 637     }
 638 }
 639
 640 #define MAX(a,b) ((a)>(b)?(a):(b))
 641 #define ABS(a)   ((a)<0?-(a):(a))
 642
 643 static void analyze_image(image_info &imageInfo, int grayscaleTolerance,
 644                           png_colorp rgbPalette, png_bytep alphaPalette,
 645                           int *paletteEntries, bool *hasTransparency, int *colorType,
 646                           png_bytepp outRows)
 647 {
 648     int w = imageInfo.width;
 649     int h = imageInfo.height;
 650     int i, j, rr, gg, bb, aa, idx;
 651     uint32_t colors[256], col;
 652     int num_colors = 0;
 653     int maxGrayDeviation = 0;
 654
 655     bool isOpaque = true;
 656     bool isPalette = true;
 657     bool isGrayscale = true;
 658
 659     // Scan the entire image and determine if:
 660     // 1. Every pixel has R == G == B (grayscale)
 661     // 2. Every pixel has A == 255 (opaque)
 662     // 3. There are no more than 256 distinct RGBA colors
 663
 664     // NOISY(printf("Initial image data:\n"));
 665     // dump_image(w, h, imageInfo.rows, 4);
 666
 667     for (j = 0; j < h; j++) {
 668         png_bytep row = imageInfo.rows[j];
 669         png_bytep out = outRows[j];
 670         for (i = 0; i < w; i++) {
 671             rr = *row++;
 672             gg = *row++;
 673             bb = *row++;
 674             aa = *row++;
 675
 676             int odev = maxGrayDeviation;
 677             maxGrayDeviation = MAX(ABS(rr - gg), maxGrayDeviation);
 678             maxGrayDeviation = MAX(ABS(gg - bb), maxGrayDeviation);
 679             maxGrayDeviation = MAX(ABS(bb - rr), maxGrayDeviation);
 680             if (maxGrayDeviation > odev) {
 681                 NOISY(printf("New max dev. = %d at pixel (%d, %d) = (%d %d %d %d)\n",
 682                              maxGrayDeviation, i, j, rr, gg, bb, aa));
 683             }
 684
 685             // Check if image is really grayscale
 686             if (isGrayscale) {
 687                 if (rr != gg || rr != bb) {
 688                      NOISY(printf("Found a non-gray pixel at %d, %d = (%d %d %d %d)\n",
 689                                   i, j, rr, gg, bb, aa));
 690                     isGrayscale = false;
 691                 }
 692             }
 693
 694             // Check if image is really opaque
 695             if (isOpaque) {
 696                 if (aa != 0xff) {
 697                     NOISY(printf("Found a non-opaque pixel at %d, %d = (%d %d %d %d)\n",
 698                                  i, j, rr, gg, bb, aa));
 699                     isOpaque = false;
 700                 }
 701             }
 702
 703             // Check if image is really <= 256 colors
 704             if (isPalette) {
 705                 col = (uint32_t) ((rr << 24) | (gg << 16) | (bb << 8) | aa);
 706                 bool match = false;
 707                 for (idx = 0; idx < num_colors; idx++) {
 708                     if (colors[idx] == col) {
 709                         match = true;
 710                         break;
 711                     }
 712                 }
 713
 714                 // Write the palette index for the pixel to outRows optimistically
 715                 // We might overwrite it later if we decide to encode as gray or
 716                 // gray + alpha
 717                 *out++ = idx;
 718                 if (!match) {
 719                     if (num_colors == 256) {
 720                         NOISY(printf("Found 257th color at %d, %d\n", i, j));
 721                         isPalette = false;
 722                     } else {
 723                         colors[num_colors++] = col;
 724                     }
 725                 }
 726             }
 727         }
 728     }
 729
 730     *paletteEntries = 0;
 731     *hasTransparency = !isOpaque;
 732     int bpp = isOpaque ? 3 : 4;
 733     int paletteSize = w * h + bpp * num_colors;
 734
 735     NOISY(printf("isGrayscale = %s\n", isGrayscale ? "true" : "false"));
 736     NOISY(printf("isOpaque = %s\n", isOpaque ? "true" : "false"));
 737     NOISY(printf("isPalette = %s\n", isPalette ? "true" : "false"));
 738     NOISY(printf("Size w/ palette = %d, gray+alpha = %d, rgb(a) = %d\n",
 739                  paletteSize, 2 * w * h, bpp * w * h));
 740     NOISY(printf("Max gray deviation = %d, tolerance = %d\n", maxGrayDeviation, grayscaleTolerance));
 741
 742     // Choose the best color type for the image.
 743     // 1. Opaque gray - use COLOR_TYPE_GRAY at 1 byte/pixel
 744     // 2. Gray + alpha - use COLOR_TYPE_PALETTE if the number of distinct combinations
 745     //     is sufficiently small, otherwise use COLOR_TYPE_GRAY_ALPHA
 746     // 3. RGB(A) - use COLOR_TYPE_PALETTE if the number of distinct colors is sufficiently
 747     //     small, otherwise use COLOR_TYPE_RGB{_ALPHA}
 748     if (isGrayscale) {
 749         if (isOpaque) {
 750             *colorType = PNG_COLOR_TYPE_GRAY; // 1 byte/pixel
 751         } else {
 752             // Use a simple heuristic to determine whether using a palette will
 753             // save space versus using gray + alpha for each pixel.
 754             // This doesn't take into account chunk overhead, filtering, LZ
 755             // compression, etc.
 756             if (isPalette && (paletteSize < 2 * w * h)) {
 757                 *colorType = PNG_COLOR_TYPE_PALETTE; // 1 byte/pixel + 4 bytes/color
 758             } else {
 759                 *colorType = PNG_COLOR_TYPE_GRAY_ALPHA; // 2 bytes per pixel
 760             }
 761         }
 762     } else if (isPalette && (paletteSize < bpp * w * h)) {
 763         *colorType = PNG_COLOR_TYPE_PALETTE;
 764     } else {
 765         if (maxGrayDeviation <= grayscaleTolerance) {
 766             NOISY(printf("Forcing image to gray (max deviation = %d)\n", maxGrayDeviation));
 767             *colorType = isOpaque ? PNG_COLOR_TYPE_GRAY : PNG_COLOR_TYPE_GRAY_ALPHA;
 768         } else {
 769             *colorType = isOpaque ? PNG_COLOR_TYPE_RGB : PNG_COLOR_TYPE_RGB_ALPHA;
 770         }
 771     }
 772
 773     // Perform postprocessing of the image or palette data based on the final
 774     // color type chosen
 775
 776     if (*colorType == PNG_COLOR_TYPE_PALETTE) {
 777         // Create separate RGB and Alpha palettes and set the number of colors
 778         *paletteEntries = num_colors;
 779
 780         // Create the RGB and alpha palettes
 781         for (int idx = 0; idx < num_colors; idx++) {
 782             col = colors[idx];
 783             rgbPalette[idx].red   = (png_byte) ((col >> 24) & 0xff);
 784             rgbPalette[idx].green = (png_byte) ((col >> 16) & 0xff);
 785             rgbPalette[idx].blue  = (png_byte) ((col >>  8) & 0xff);
 786             alphaPalette[idx]     = (png_byte)  (col        & 0xff);
 787         }
 788     } else if (*colorType == PNG_COLOR_TYPE_GRAY || *colorType == PNG_COLOR_TYPE_GRAY_ALPHA) {
 789         // If the image is gray or gray + alpha, compact the pixels into outRows
 790         for (j = 0; j < h; j++) {
 791             png_bytep row = imageInfo.rows[j];
 792             png_bytep out = outRows[j];
 793             for (i = 0; i < w; i++) {
 794                 rr = *row++;
 795                 gg = *row++;
 796                 bb = *row++;
 797                 aa = *row++;
 798
 799                 if (isGrayscale) {
 800                     *out++ = rr;
 801                 } else {
 802                     *out++ = (png_byte) (rr * 0.2126f + gg * 0.7152f + bb * 0.0722f);
 803                 }
 804                 if (!isOpaque) {
 805                     *out++ = aa;
 806                 }
 807            }
 808         }
 809     }
 810 }
 811
 812
 813 static void write_png(const char* imageName,
 814                       png_structp write_ptr, png_infop write_info,
 815                       image_info& imageInfo, int grayscaleTolerance)
 816 {
 817     bool optimize = true;
 818     png_uint_32 width, height;
 819     int color_type;
 820     int bit_depth, interlace_type, compression_type;
 821     int i;
 822
 823     png_unknown_chunk unknowns[1];
 824
 825     png_bytepp outRows = (png_bytepp) malloc((int) imageInfo.height * png_sizeof(png_bytep));
 826     if (outRows == (png_bytepp) 0) {
 827         printf("Can't allocate output buffer!\n");
 828         exit(1);
 829     }
 830     for (i = 0; i < (int) imageInfo.height; i++) {
 831         outRows[i] = (png_bytep) malloc(2 * (int) imageInfo.width);
 832         if (outRows[i] == (png_bytep) 0) {
 833             printf("Can't allocate output buffer!\n");
 834             exit(1);
 835         }
 836     }
 837
 838     png_set_compression_level(write_ptr, Z_BEST_COMPRESSION);
 839
 840     NOISY(printf("Writing image %s: w = %d, h = %d\n", imageName,
 841           (int) imageInfo.width, (int) imageInfo.height));
 842
 843     png_color rgbPalette[256];
 844     png_byte alphaPalette[256];
 845     bool hasTransparency;
 846     int paletteEntries;
 847
 848     analyze_image(imageInfo, grayscaleTolerance, rgbPalette, alphaPalette,
 849                   &paletteEntries, &hasTransparency, &color_type, outRows);
 850     switch (color_type) {
 851     case PNG_COLOR_TYPE_PALETTE:
 852         NOISY(printf("Image %s has %d colors%s, using PNG_COLOR_TYPE_PALETTE\n",
 853                      imageName, paletteEntries,
 854                      hasTransparency ? " (with alpha)" : ""));
 855         break;
 856     case PNG_COLOR_TYPE_GRAY:
 857         NOISY(printf("Image %s is opaque gray, using PNG_COLOR_TYPE_GRAY\n", imageName));
 858         break;
 859     case PNG_COLOR_TYPE_GRAY_ALPHA:
 860         NOISY(printf("Image %s is gray + alpha, using PNG_COLOR_TYPE_GRAY_ALPHA\n", imageName));
 861         break;
 862     case PNG_COLOR_TYPE_RGB:
 863         NOISY(printf("Image %s is opaque RGB, using PNG_COLOR_TYPE_RGB\n", imageName));
 864         break;
 865     case PNG_COLOR_TYPE_RGB_ALPHA:
 866         NOISY(printf("Image %s is RGB + alpha, using PNG_COLOR_TYPE_RGB_ALPHA\n", imageName));
 867         break;
 868     }
 869
 870     png_set_IHDR(write_ptr, write_info, imageInfo.width, imageInfo.height,
 871                  8, color_type, PNG_INTERLACE_NONE,
 872                  PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
 873
 874     if (color_type == PNG_COLOR_TYPE_PALETTE) {
 875         png_set_PLTE(write_ptr, write_info, rgbPalette, paletteEntries);
 876         if (hasTransparency) {
 877             png_set_tRNS(write_ptr, write_info, alphaPalette, paletteEntries, (png_color_16p) 0);
 878         }
 879        png_set_filter(write_ptr, 0, PNG_NO_FILTERS);
 880     } else {
 881        png_set_filter(write_ptr, 0, PNG_ALL_FILTERS);
 882     }
 883
 884     if (imageInfo.is9Patch) {
 885         NOISY(printf("Adding 9-patch info...\n"));
 886         strcpy((char*)unknowns[0].name, "npTc");
 887         unknowns[0].data = (png_byte*)imageInfo.info9Patch.serialize();
 888         unknowns[0].size = imageInfo.info9Patch.serializedSize();
 889         // TODO: remove the check below when everything works
 890         checkNinePatchSerialization(&imageInfo.info9Patch, unknowns[0].data);
 891         png_set_keep_unknown_chunks(write_ptr, PNG_HANDLE_CHUNK_ALWAYS,
 892                                     (png_byte*)"npTc", 1);
 893         png_set_unknown_chunks(write_ptr, write_info, unknowns, 1);
 894         // XXX I can't get this to work without forcibly changing
 895         // the location to what I want...  which apparently is supposed
 896         // to be a private API, but everything else I have tried results
 897         // in the location being set to what I -last- wrote so I never
 898         // get written. :p
 899         png_set_unknown_chunk_location(write_ptr, write_info, 0, PNG_HAVE_PLTE);
 900     }
 901
 902     png_write_info(write_ptr, write_info);
 903
 904     png_bytepp rows;
 905     if (color_type == PNG_COLOR_TYPE_RGB || color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
 906         png_set_filler(write_ptr, 0, PNG_FILLER_AFTER);
 907         rows = imageInfo.rows;
 908     } else {
 909         rows = outRows;
 910     }
 911     png_write_image(write_ptr, rows);
 912
 913 //     int bpp;
 914 //     if (color_type == PNG_COLOR_TYPE_PALETTE || color_type == PNG_COLOR_TYPE_GRAY) {
 915 //         bpp = 1;
 916 //     } else if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
 917 //         bpp = 2;
 918 //     } else if (color_type == PNG_COLOR_TYPE_RGB) {
 919 //         bpp = 4;
 920 //     } else if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
 921 //         bpp = 4;
 922 //     } else {
 923 //         printf("Uknknown color type %d, exiting.\n", color_type);
 924 //         exit(1);
 925 //     }
 926 //     NOISY(printf("Final image data:\n"));
 927 //     dump_image(imageInfo.width, imageInfo.height, rows, bpp);
 928
 929     png_write_end(write_ptr, write_info);
 930
 931     for (i = 0; i < (int) imageInfo.height; i++) {
 932         free(outRows[i]);
 933     }
 934     free(outRows);
 935
 936     png_get_IHDR(write_ptr, write_info, &width, &height,
 937        &bit_depth, &color_type, &interlace_type,
 938        &compression_type, NULL);
 939
 940     NOISY(printf("Image written: w=%d, h=%d, d=%d, colors=%d, inter=%d, comp=%d\n",
 941                  (int)width, (int)height, bit_depth, color_type, interlace_type,
 942                  compression_type));
 943 }
 944
 945 status_t preProcessImage(Bundle* bundle, const sp<AaptAssets>& assets,
 946                          const sp<AaptFile>& file, String8* outNewLeafName)
 947 {
 948     String8 ext(file->getPath().getPathExtension());
 949
 950     // We currently only process PNG images.
 951     if (strcmp(ext.string(), ".png") != 0) {
 952         return NO_ERROR;
 953     }
 954
 955     // Example of renaming a file:
 956     //*outNewLeafName = file->getPath().getBasePath().getFileName();
 957     //outNewLeafName->append(".nupng");
 958
 959     String8 printableName(file->getPrintableSource());
 960
 961     png_structp read_ptr = NULL;
 962     png_infop read_info = NULL;
 963     FILE* fp;
 964
 965     image_info imageInfo;
 966
 967     png_structp write_ptr = NULL;
 968     png_infop write_info = NULL;
 969
 970     status_t error = UNKNOWN_ERROR;
 971
 972     const size_t nameLen = file->getPath().length();
 973
 974     fp = fopen(file->getSourceFile().string(), "rb");
 975     if (fp == NULL) {
 976         fprintf(stderr, "%s: ERROR: Unable to open PNG file\n", printableName.string());
 977         goto bail;
 978     }
 979
 980     read_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, (png_error_ptr)NULL,
 981                                         (png_error_ptr)NULL);
 982     if (!read_ptr) {
 983         goto bail;
 984     }
 985
 986     read_info = png_create_info_struct(read_ptr);
 987     if (!read_info) {
 988         goto bail;
 989     }
 990
 991     if (setjmp(png_jmpbuf(read_ptr))) {
 992         goto bail;
 993     }
 994
 995     png_init_io(read_ptr, fp);
 996
 997     read_png(printableName.string(), read_ptr, read_info, &imageInfo);
 998
 999     if (nameLen > 6) {
1000         const char* name = file->getPath().string();
1001         if (name[nameLen-5] == '9' && name[nameLen-6] == '.') {
1002             if (do_9patch(printableName.string(), &imageInfo) != NO_ERROR) {
1003                 goto bail;
1004             }
1005         }
1006     }
1007
1008     write_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, (png_error_ptr)NULL,
1009                                         (png_error_ptr)NULL);
1010     if (!write_ptr)
1011     {
1012         goto bail;
1013     }
1014
1015     write_info = png_create_info_struct(write_ptr);
1016     if (!write_info)
1017     {
1018         goto bail;
1019     }
1020
1021     png_set_write_fn(write_ptr, (void*)file.get(),
1022                      png_write_aapt_file, png_flush_aapt_file);
1023
1024     if (setjmp(png_jmpbuf(write_ptr)))
1025     {
1026         goto bail;
1027     }
1028
1029     write_png(printableName.string(), write_ptr, write_info, imageInfo,
1030               bundle->getGrayscaleTolerance());
1031
1032     error = NO_ERROR;
1033
1034     if (bundle->getVerbose()) {
1035         fseek(fp, 0, SEEK_END);
1036         size_t oldSize = (size_t)ftell(fp);
1037         size_t newSize = file->getSize();
1038         float factor = ((float)newSize)/oldSize;
1039         int percent = (int)(factor*100);
1040         printf("    (processed image %s: %d%% size of source)\n", printableName.string(), percent);
1041     }
1042
1043 bail:
1044     if (read_ptr) {
1045         png_destroy_read_struct(&read_ptr, &read_info, (png_infopp)NULL);
1046     }
1047     if (fp) {
1048         fclose(fp);
1049     }
1050     if (write_ptr) {
1051         png_destroy_write_struct(&write_ptr, &write_info);
1052     }
1053
1054     if (error != NO_ERROR) {
1055         fprintf(stderr, "ERROR: Failure processing PNG image %s\n",
1056                 file->getPrintableSource().string());
1057     }
1058     return error;
1059 }
1060
1061
1062
1063 status_t postProcessImage(const sp<AaptAssets>& assets,
1064                           ResourceTable* table, const sp<AaptFile>& file)
1065 {
1066     String8 ext(file->getPath().getPathExtension());
1067
1068     // At this point, now that we have all the resource data, all we need to
1069     // do is compile XML files.
1070     if (strcmp(ext.string(), ".xml") == 0) {
1071         return compileXmlFile(assets, file, table);
1072     }
1073
1074     return NO_ERROR;
1075 }