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