Home | History | Annotate | Download | only in aapt
      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 = NULL;
    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 
    467     // Make sure the amount of rows and columns will fit in the number of
    468     // colors we can use in the 9-patch format.
    469     if (numRows * numCols > 0x7F) {
    470         errorMsg = "Too many rows and columns in 9-patch perimeter";
    471         goto getout;
    472     }
    473 
    474     numColors = numRows * numCols;
    475     image->info9Patch.numColors = numColors;
    476     image->info9Patch.colors = (uint32_t*)malloc(numColors * sizeof(uint32_t));
    477 
    478     // Fill in color information for each patch.
    479 
    480     uint32_t c;
    481     top = 0;
    482 
    483     // The first row always starts with the top being at y=0 and the bottom
    484     // being either yDivs[1] (if yDivs[0]=0) of yDivs[0].  In the former case
    485     // the first row is stretchable along the Y axis, otherwise it is fixed.
    486     // The last row always ends with the bottom being bitmap.height and the top
    487     // being either yDivs[numYDivs-2] (if yDivs[numYDivs-1]=bitmap.height) or
    488     // yDivs[numYDivs-1]. In the former case the last row is stretchable along
    489     // the Y axis, otherwise it is fixed.
    490     //
    491     // The first and last columns are similarly treated with respect to the X
    492     // axis.
    493     //
    494     // The above is to help explain some of the special casing that goes on the
    495     // code below.
    496 
    497     // The initial yDiv and whether the first row is considered stretchable or
    498     // not depends on whether yDiv[0] was zero or not.
    499     for (j = (yDivs[0] == 0 ? 1 : 0);
    500           j <= numYDivs && top < H;
    501           j++) {
    502         if (j == numYDivs) {
    503             bottom = H;
    504         } else {
    505             bottom = yDivs[j];
    506         }
    507         left = 0;
    508         // The initial xDiv and whether the first column is considered
    509         // stretchable or not depends on whether xDiv[0] was zero or not.
    510         for (i = xDivs[0] == 0 ? 1 : 0;
    511               i <= numXDivs && left < W;
    512               i++) {
    513             if (i == numXDivs) {
    514                 right = W;
    515             } else {
    516                 right = xDivs[i];
    517             }
    518             c = get_color(image->rows, left, top, right - 1, bottom - 1);
    519             image->info9Patch.colors[colorIndex++] = c;
    520             NOISY(if (c != Res_png_9patch::NO_COLOR) hasColor = true);
    521             left = right;
    522         }
    523         top = bottom;
    524     }
    525 
    526     assert(colorIndex == numColors);
    527 
    528     for (i=0; i<numColors; i++) {
    529         if (hasColor) {
    530             if (i == 0) printf("Colors in %s:\n ", imageName);
    531             printf(" #%08x", image->info9Patch.colors[i]);
    532             if (i == numColors - 1) printf("\n");
    533         }
    534     }
    535 
    536     image->is9Patch = true;
    537     image->info9Patch.deviceToFile();
    538 
    539 getout:
    540     if (errorMsg) {
    541         fprintf(stderr,
    542             "ERROR: 9-patch image %s malformed.\n"
    543             "       %s.\n", imageName, errorMsg);
    544         if (errorEdge != NULL) {
    545             if (errorPixel >= 0) {
    546                 fprintf(stderr,
    547                     "       Found at pixel #%d along %s edge.\n", errorPixel, errorEdge);
    548             } else {
    549                 fprintf(stderr,
    550                     "       Found along %s edge.\n", errorEdge);
    551             }
    552         }
    553         return UNKNOWN_ERROR;
    554     }
    555     return NO_ERROR;
    556 }
    557 
    558 static void checkNinePatchSerialization(Res_png_9patch* inPatch,  void * data)
    559 {
    560     if (sizeof(void*) != sizeof(int32_t)) {
    561         // can't deserialize on a non-32 bit system
    562         return;
    563     }
    564     size_t patchSize = inPatch->serializedSize();
    565     void * newData = malloc(patchSize);
    566     memcpy(newData, data, patchSize);
    567     Res_png_9patch* outPatch = inPatch->deserialize(newData);
    568     // deserialization is done in place, so outPatch == newData
    569     assert(outPatch == newData);
    570     assert(outPatch->numXDivs == inPatch->numXDivs);
    571     assert(outPatch->numYDivs == inPatch->numYDivs);
    572     assert(outPatch->paddingLeft == inPatch->paddingLeft);
    573     assert(outPatch->paddingRight == inPatch->paddingRight);
    574     assert(outPatch->paddingTop == inPatch->paddingTop);
    575     assert(outPatch->paddingBottom == inPatch->paddingBottom);
    576     for (int i = 0; i < outPatch->numXDivs; i++) {
    577         assert(outPatch->xDivs[i] == inPatch->xDivs[i]);
    578     }
    579     for (int i = 0; i < outPatch->numYDivs; i++) {
    580         assert(outPatch->yDivs[i] == inPatch->yDivs[i]);
    581     }
    582     for (int i = 0; i < outPatch->numColors; i++) {
    583         assert(outPatch->colors[i] == inPatch->colors[i]);
    584     }
    585     free(newData);
    586 }
    587 
    588 static bool patch_equals(Res_png_9patch& patch1, Res_png_9patch& patch2) {
    589     if (!(patch1.numXDivs == patch2.numXDivs &&
    590           patch1.numYDivs == patch2.numYDivs &&
    591           patch1.numColors == patch2.numColors &&
    592           patch1.paddingLeft == patch2.paddingLeft &&
    593           patch1.paddingRight == patch2.paddingRight &&
    594           patch1.paddingTop == patch2.paddingTop &&
    595           patch1.paddingBottom == patch2.paddingBottom)) {
    596             return false;
    597     }
    598     for (int i = 0; i < patch1.numColors; i++) {
    599         if (patch1.colors[i] != patch2.colors[i]) {
    600             return false;
    601         }
    602     }
    603     for (int i = 0; i < patch1.numXDivs; i++) {
    604         if (patch1.xDivs[i] != patch2.xDivs[i]) {
    605             return false;
    606         }
    607     }
    608     for (int i = 0; i < patch1.numYDivs; i++) {
    609         if (patch1.yDivs[i] != patch2.yDivs[i]) {
    610             return false;
    611         }
    612     }
    613     return true;
    614 }
    615 
    616 static void dump_image(int w, int h, png_bytepp rows, int color_type)
    617 {
    618     int i, j, rr, gg, bb, aa;
    619 
    620     int bpp;
    621     if (color_type == PNG_COLOR_TYPE_PALETTE || color_type == PNG_COLOR_TYPE_GRAY) {
    622         bpp = 1;
    623     } else if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
    624         bpp = 2;
    625     } else if (color_type == PNG_COLOR_TYPE_RGB || color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
    626         // We use a padding byte even when there is no alpha
    627         bpp = 4;
    628     } else {
    629         printf("Unknown color type %d.\n", color_type);
    630     }
    631 
    632     for (j = 0; j < h; j++) {
    633         png_bytep row = rows[j];
    634         for (i = 0; i < w; i++) {
    635             rr = row[0];
    636             gg = row[1];
    637             bb = row[2];
    638             aa = row[3];
    639             row += bpp;
    640 
    641             if (i == 0) {
    642                 printf("Row %d:", j);
    643             }
    644             switch (bpp) {
    645             case 1:
    646                 printf(" (%d)", rr);
    647                 break;
    648             case 2:
    649                 printf(" (%d %d", rr, gg);
    650                 break;
    651             case 3:
    652                 printf(" (%d %d %d)", rr, gg, bb);
    653                 break;
    654             case 4:
    655                 printf(" (%d %d %d %d)", rr, gg, bb, aa);
    656                 break;
    657             }
    658             if (i == (w - 1)) {
    659                 NOISY(printf("\n"));
    660             }
    661         }
    662     }
    663 }
    664 
    665 #define MAX(a,b) ((a)>(b)?(a):(b))
    666 #define ABS(a)   ((a)<0?-(a):(a))
    667 
    668 static void analyze_image(const char *imageName, image_info &imageInfo, int grayscaleTolerance,
    669                           png_colorp rgbPalette, png_bytep alphaPalette,
    670                           int *paletteEntries, bool *hasTransparency, int *colorType,
    671                           png_bytepp outRows)
    672 {
    673     int w = imageInfo.width;
    674     int h = imageInfo.height;
    675     int i, j, rr, gg, bb, aa, idx;
    676     uint32_t colors[256], col;
    677     int num_colors = 0;
    678     int maxGrayDeviation = 0;
    679 
    680     bool isOpaque = true;
    681     bool isPalette = true;
    682     bool isGrayscale = true;
    683 
    684     // Scan the entire image and determine if:
    685     // 1. Every pixel has R == G == B (grayscale)
    686     // 2. Every pixel has A == 255 (opaque)
    687     // 3. There are no more than 256 distinct RGBA colors
    688 
    689     // NOISY(printf("Initial image data:\n"));
    690     // dump_image(w, h, imageInfo.rows, PNG_COLOR_TYPE_RGB_ALPHA);
    691 
    692     for (j = 0; j < h; j++) {
    693         png_bytep row = imageInfo.rows[j];
    694         png_bytep out = outRows[j];
    695         for (i = 0; i < w; i++) {
    696             rr = *row++;
    697             gg = *row++;
    698             bb = *row++;
    699             aa = *row++;
    700 
    701             int odev = maxGrayDeviation;
    702             maxGrayDeviation = MAX(ABS(rr - gg), maxGrayDeviation);
    703             maxGrayDeviation = MAX(ABS(gg - bb), maxGrayDeviation);
    704             maxGrayDeviation = MAX(ABS(bb - rr), maxGrayDeviation);
    705             if (maxGrayDeviation > odev) {
    706                 NOISY(printf("New max dev. = %d at pixel (%d, %d) = (%d %d %d %d)\n",
    707                              maxGrayDeviation, i, j, rr, gg, bb, aa));
    708             }
    709 
    710             // Check if image is really grayscale
    711             if (isGrayscale) {
    712                 if (rr != gg || rr != bb) {
    713                      NOISY(printf("Found a non-gray pixel at %d, %d = (%d %d %d %d)\n",
    714                                   i, j, rr, gg, bb, aa));
    715                     isGrayscale = false;
    716                 }
    717             }
    718 
    719             // Check if image is really opaque
    720             if (isOpaque) {
    721                 if (aa != 0xff) {
    722                     NOISY(printf("Found a non-opaque pixel at %d, %d = (%d %d %d %d)\n",
    723                                  i, j, rr, gg, bb, aa));
    724                     isOpaque = false;
    725                 }
    726             }
    727 
    728             // Check if image is really <= 256 colors
    729             if (isPalette) {
    730                 col = (uint32_t) ((rr << 24) | (gg << 16) | (bb << 8) | aa);
    731                 bool match = false;
    732                 for (idx = 0; idx < num_colors; idx++) {
    733                     if (colors[idx] == col) {
    734                         match = true;
    735                         break;
    736                     }
    737                 }
    738 
    739                 // Write the palette index for the pixel to outRows optimistically
    740                 // We might overwrite it later if we decide to encode as gray or
    741                 // gray + alpha
    742                 *out++ = idx;
    743                 if (!match) {
    744                     if (num_colors == 256) {
    745                         NOISY(printf("Found 257th color at %d, %d\n", i, j));
    746                         isPalette = false;
    747                     } else {
    748                         colors[num_colors++] = col;
    749                     }
    750                 }
    751             }
    752         }
    753     }
    754 
    755     *paletteEntries = 0;
    756     *hasTransparency = !isOpaque;
    757     int bpp = isOpaque ? 3 : 4;
    758     int paletteSize = w * h + bpp * num_colors;
    759 
    760     NOISY(printf("isGrayscale = %s\n", isGrayscale ? "true" : "false"));
    761     NOISY(printf("isOpaque = %s\n", isOpaque ? "true" : "false"));
    762     NOISY(printf("isPalette = %s\n", isPalette ? "true" : "false"));
    763     NOISY(printf("Size w/ palette = %d, gray+alpha = %d, rgb(a) = %d\n",
    764                  paletteSize, 2 * w * h, bpp * w * h));
    765     NOISY(printf("Max gray deviation = %d, tolerance = %d\n", maxGrayDeviation, grayscaleTolerance));
    766 
    767     // Choose the best color type for the image.
    768     // 1. Opaque gray - use COLOR_TYPE_GRAY at 1 byte/pixel
    769     // 2. Gray + alpha - use COLOR_TYPE_PALETTE if the number of distinct combinations
    770     //     is sufficiently small, otherwise use COLOR_TYPE_GRAY_ALPHA
    771     // 3. RGB(A) - use COLOR_TYPE_PALETTE if the number of distinct colors is sufficiently
    772     //     small, otherwise use COLOR_TYPE_RGB{_ALPHA}
    773     if (isGrayscale) {
    774         if (isOpaque) {
    775             *colorType = PNG_COLOR_TYPE_GRAY; // 1 byte/pixel
    776         } else {
    777             // Use a simple heuristic to determine whether using a palette will
    778             // save space versus using gray + alpha for each pixel.
    779             // This doesn't take into account chunk overhead, filtering, LZ
    780             // compression, etc.
    781             if (isPalette && (paletteSize < 2 * w * h)) {
    782                 *colorType = PNG_COLOR_TYPE_PALETTE; // 1 byte/pixel + 4 bytes/color
    783             } else {
    784                 *colorType = PNG_COLOR_TYPE_GRAY_ALPHA; // 2 bytes per pixel
    785             }
    786         }
    787     } else if (isPalette && (paletteSize < bpp * w * h)) {
    788         *colorType = PNG_COLOR_TYPE_PALETTE;
    789     } else {
    790         if (maxGrayDeviation <= grayscaleTolerance) {
    791             printf("%s: forcing image to gray (max deviation = %d)\n", imageName, maxGrayDeviation);
    792             *colorType = isOpaque ? PNG_COLOR_TYPE_GRAY : PNG_COLOR_TYPE_GRAY_ALPHA;
    793         } else {
    794             *colorType = isOpaque ? PNG_COLOR_TYPE_RGB : PNG_COLOR_TYPE_RGB_ALPHA;
    795         }
    796     }
    797 
    798     // Perform postprocessing of the image or palette data based on the final
    799     // color type chosen
    800 
    801     if (*colorType == PNG_COLOR_TYPE_PALETTE) {
    802         // Create separate RGB and Alpha palettes and set the number of colors
    803         *paletteEntries = num_colors;
    804 
    805         // Create the RGB and alpha palettes
    806         for (int idx = 0; idx < num_colors; idx++) {
    807             col = colors[idx];
    808             rgbPalette[idx].red   = (png_byte) ((col >> 24) & 0xff);
    809             rgbPalette[idx].green = (png_byte) ((col >> 16) & 0xff);
    810             rgbPalette[idx].blue  = (png_byte) ((col >>  8) & 0xff);
    811             alphaPalette[idx]     = (png_byte)  (col        & 0xff);
    812         }
    813     } else if (*colorType == PNG_COLOR_TYPE_GRAY || *colorType == PNG_COLOR_TYPE_GRAY_ALPHA) {
    814         // If the image is gray or gray + alpha, compact the pixels into outRows
    815         for (j = 0; j < h; j++) {
    816             png_bytep row = imageInfo.rows[j];
    817             png_bytep out = outRows[j];
    818             for (i = 0; i < w; i++) {
    819                 rr = *row++;
    820                 gg = *row++;
    821                 bb = *row++;
    822                 aa = *row++;
    823 
    824                 if (isGrayscale) {
    825                     *out++ = rr;
    826                 } else {
    827                     *out++ = (png_byte) (rr * 0.2126f + gg * 0.7152f + bb * 0.0722f);
    828                 }
    829                 if (!isOpaque) {
    830                     *out++ = aa;
    831                 }
    832            }
    833         }
    834     }
    835 }
    836 
    837 
    838 static void write_png(const char* imageName,
    839                       png_structp write_ptr, png_infop write_info,
    840                       image_info& imageInfo, int grayscaleTolerance)
    841 {
    842     bool optimize = true;
    843     png_uint_32 width, height;
    844     int color_type;
    845     int bit_depth, interlace_type, compression_type;
    846     int i;
    847 
    848     png_unknown_chunk unknowns[1];
    849     unknowns[0].data = NULL;
    850 
    851     png_bytepp outRows = (png_bytepp) malloc((int) imageInfo.height * png_sizeof(png_bytep));
    852     if (outRows == (png_bytepp) 0) {
    853         printf("Can't allocate output buffer!\n");
    854         exit(1);
    855     }
    856     for (i = 0; i < (int) imageInfo.height; i++) {
    857         outRows[i] = (png_bytep) malloc(2 * (int) imageInfo.width);
    858         if (outRows[i] == (png_bytep) 0) {
    859             printf("Can't allocate output buffer!\n");
    860             exit(1);
    861         }
    862     }
    863 
    864     png_set_compression_level(write_ptr, Z_BEST_COMPRESSION);
    865 
    866     NOISY(printf("Writing image %s: w = %d, h = %d\n", imageName,
    867           (int) imageInfo.width, (int) imageInfo.height));
    868 
    869     png_color rgbPalette[256];
    870     png_byte alphaPalette[256];
    871     bool hasTransparency;
    872     int paletteEntries;
    873 
    874     analyze_image(imageName, imageInfo, grayscaleTolerance, rgbPalette, alphaPalette,
    875                   &paletteEntries, &hasTransparency, &color_type, outRows);
    876 
    877     // If the image is a 9-patch, we need to preserve it as a ARGB file to make
    878     // sure the pixels will not be pre-dithered/clamped until we decide they are
    879     if (imageInfo.is9Patch && (color_type == PNG_COLOR_TYPE_RGB ||
    880             color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_PALETTE)) {
    881         color_type = PNG_COLOR_TYPE_RGB_ALPHA;
    882     }
    883 
    884     switch (color_type) {
    885     case PNG_COLOR_TYPE_PALETTE:
    886         NOISY(printf("Image %s has %d colors%s, using PNG_COLOR_TYPE_PALETTE\n",
    887                      imageName, paletteEntries,
    888                      hasTransparency ? " (with alpha)" : ""));
    889         break;
    890     case PNG_COLOR_TYPE_GRAY:
    891         NOISY(printf("Image %s is opaque gray, using PNG_COLOR_TYPE_GRAY\n", imageName));
    892         break;
    893     case PNG_COLOR_TYPE_GRAY_ALPHA:
    894         NOISY(printf("Image %s is gray + alpha, using PNG_COLOR_TYPE_GRAY_ALPHA\n", imageName));
    895         break;
    896     case PNG_COLOR_TYPE_RGB:
    897         NOISY(printf("Image %s is opaque RGB, using PNG_COLOR_TYPE_RGB\n", imageName));
    898         break;
    899     case PNG_COLOR_TYPE_RGB_ALPHA:
    900         NOISY(printf("Image %s is RGB + alpha, using PNG_COLOR_TYPE_RGB_ALPHA\n", imageName));
    901         break;
    902     }
    903 
    904     png_set_IHDR(write_ptr, write_info, imageInfo.width, imageInfo.height,
    905                  8, color_type, PNG_INTERLACE_NONE,
    906                  PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
    907 
    908     if (color_type == PNG_COLOR_TYPE_PALETTE) {
    909         png_set_PLTE(write_ptr, write_info, rgbPalette, paletteEntries);
    910         if (hasTransparency) {
    911             png_set_tRNS(write_ptr, write_info, alphaPalette, paletteEntries, (png_color_16p) 0);
    912         }
    913        png_set_filter(write_ptr, 0, PNG_NO_FILTERS);
    914     } else {
    915        png_set_filter(write_ptr, 0, PNG_ALL_FILTERS);
    916     }
    917 
    918     if (imageInfo.is9Patch) {
    919         NOISY(printf("Adding 9-patch info...\n"));
    920         strcpy((char*)unknowns[0].name, "npTc");
    921         unknowns[0].data = (png_byte*)imageInfo.info9Patch.serialize();
    922         unknowns[0].size = imageInfo.info9Patch.serializedSize();
    923         // TODO: remove the check below when everything works
    924         checkNinePatchSerialization(&imageInfo.info9Patch, unknowns[0].data);
    925         png_set_keep_unknown_chunks(write_ptr, PNG_HANDLE_CHUNK_ALWAYS,
    926                                     (png_byte*)"npTc", 1);
    927         png_set_unknown_chunks(write_ptr, write_info, unknowns, 1);
    928         // XXX I can't get this to work without forcibly changing
    929         // the location to what I want...  which apparently is supposed
    930         // to be a private API, but everything else I have tried results
    931         // in the location being set to what I -last- wrote so I never
    932         // get written. :p
    933         png_set_unknown_chunk_location(write_ptr, write_info, 0, PNG_HAVE_PLTE);
    934     }
    935 
    936     png_write_info(write_ptr, write_info);
    937 
    938     png_bytepp rows;
    939     if (color_type == PNG_COLOR_TYPE_RGB || color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
    940         png_set_filler(write_ptr, 0, PNG_FILLER_AFTER);
    941         rows = imageInfo.rows;
    942     } else {
    943         rows = outRows;
    944     }
    945     png_write_image(write_ptr, rows);
    946 
    947 //     NOISY(printf("Final image data:\n"));
    948 //     dump_image(imageInfo.width, imageInfo.height, rows, color_type);
    949 
    950     png_write_end(write_ptr, write_info);
    951 
    952     for (i = 0; i < (int) imageInfo.height; i++) {
    953         free(outRows[i]);
    954     }
    955     free(outRows);
    956     free(unknowns[0].data);
    957 
    958     png_get_IHDR(write_ptr, write_info, &width, &height,
    959        &bit_depth, &color_type, &interlace_type,
    960        &compression_type, NULL);
    961 
    962     NOISY(printf("Image written: w=%d, h=%d, d=%d, colors=%d, inter=%d, comp=%d\n",
    963                  (int)width, (int)height, bit_depth, color_type, interlace_type,
    964                  compression_type));
    965 }
    966 
    967 status_t preProcessImage(Bundle* bundle, const sp<AaptAssets>& assets,
    968                          const sp<AaptFile>& file, String8* outNewLeafName)
    969 {
    970     String8 ext(file->getPath().getPathExtension());
    971 
    972     // We currently only process PNG images.
    973     if (strcmp(ext.string(), ".png") != 0) {
    974         return NO_ERROR;
    975     }
    976 
    977     // Example of renaming a file:
    978     //*outNewLeafName = file->getPath().getBasePath().getFileName();
    979     //outNewLeafName->append(".nupng");
    980 
    981     String8 printableName(file->getPrintableSource());
    982 
    983     if (bundle->getVerbose()) {
    984         printf("Processing image: %s\n", printableName.string());
    985     }
    986 
    987     png_structp read_ptr = NULL;
    988     png_infop read_info = NULL;
    989     FILE* fp;
    990 
    991     image_info imageInfo;
    992 
    993     png_structp write_ptr = NULL;
    994     png_infop write_info = NULL;
    995 
    996     status_t error = UNKNOWN_ERROR;
    997 
    998     const size_t nameLen = file->getPath().length();
    999 
   1000     fp = fopen(file->getSourceFile().string(), "rb");
   1001     if (fp == NULL) {
   1002         fprintf(stderr, "%s: ERROR: Unable to open PNG file\n", printableName.string());
   1003         goto bail;
   1004     }
   1005 
   1006     read_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, (png_error_ptr)NULL,
   1007                                         (png_error_ptr)NULL);
   1008     if (!read_ptr) {
   1009         goto bail;
   1010     }
   1011 
   1012     read_info = png_create_info_struct(read_ptr);
   1013     if (!read_info) {
   1014         goto bail;
   1015     }
   1016 
   1017     if (setjmp(png_jmpbuf(read_ptr))) {
   1018         goto bail;
   1019     }
   1020 
   1021     png_init_io(read_ptr, fp);
   1022 
   1023     read_png(printableName.string(), read_ptr, read_info, &imageInfo);
   1024 
   1025     if (nameLen > 6) {
   1026         const char* name = file->getPath().string();
   1027         if (name[nameLen-5] == '9' && name[nameLen-6] == '.') {
   1028             if (do_9patch(printableName.string(), &imageInfo) != NO_ERROR) {
   1029                 goto bail;
   1030             }
   1031         }
   1032     }
   1033 
   1034     write_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, (png_error_ptr)NULL,
   1035                                         (png_error_ptr)NULL);
   1036     if (!write_ptr)
   1037     {
   1038         goto bail;
   1039     }
   1040 
   1041     write_info = png_create_info_struct(write_ptr);
   1042     if (!write_info)
   1043     {
   1044         goto bail;
   1045     }
   1046 
   1047     png_set_write_fn(write_ptr, (void*)file.get(),
   1048                      png_write_aapt_file, png_flush_aapt_file);
   1049 
   1050     if (setjmp(png_jmpbuf(write_ptr)))
   1051     {
   1052         goto bail;
   1053     }
   1054 
   1055     write_png(printableName.string(), write_ptr, write_info, imageInfo,
   1056               bundle->getGrayscaleTolerance());
   1057 
   1058     error = NO_ERROR;
   1059 
   1060     if (bundle->getVerbose()) {
   1061         fseek(fp, 0, SEEK_END);
   1062         size_t oldSize = (size_t)ftell(fp);
   1063         size_t newSize = file->getSize();
   1064         float factor = ((float)newSize)/oldSize;
   1065         int percent = (int)(factor*100);
   1066         printf("    (processed image %s: %d%% size of source)\n", printableName.string(), percent);
   1067     }
   1068 
   1069 bail:
   1070     if (read_ptr) {
   1071         png_destroy_read_struct(&read_ptr, &read_info, (png_infopp)NULL);
   1072     }
   1073     if (fp) {
   1074         fclose(fp);
   1075     }
   1076     if (write_ptr) {
   1077         png_destroy_write_struct(&write_ptr, &write_info);
   1078     }
   1079 
   1080     if (error != NO_ERROR) {
   1081         fprintf(stderr, "ERROR: Failure processing PNG image %s\n",
   1082                 file->getPrintableSource().string());
   1083     }
   1084     return error;
   1085 }
   1086 
   1087 status_t preProcessImageToCache(Bundle* bundle, String8 source, String8 dest)
   1088 {
   1089     png_structp read_ptr = NULL;
   1090     png_infop read_info = NULL;
   1091 
   1092     FILE* fp;
   1093 
   1094     image_info imageInfo;
   1095 
   1096     png_structp write_ptr = NULL;
   1097     png_infop write_info = NULL;
   1098 
   1099     status_t error = UNKNOWN_ERROR;
   1100 
   1101     if (bundle->getVerbose()) {
   1102         printf("Processing image to cache: %s => %s\n", source.string(), dest.string());
   1103     }
   1104 
   1105     // Get a file handler to read from
   1106     fp = fopen(source.string(),"rb");
   1107     if (fp == NULL) {
   1108         fprintf(stderr, "%s ERROR: Unable to open PNG file\n", source.string());
   1109         return error;
   1110     }
   1111 
   1112     // Call libpng to get a struct to read image data into
   1113     read_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
   1114     if (!read_ptr) {
   1115         fclose(fp);
   1116         png_destroy_read_struct(&read_ptr, &read_info,NULL);
   1117         return error;
   1118     }
   1119 
   1120     // Call libpng to get a struct to read image info into
   1121     read_info = png_create_info_struct(read_ptr);
   1122     if (!read_info) {
   1123         fclose(fp);
   1124         png_destroy_read_struct(&read_ptr, &read_info,NULL);
   1125         return error;
   1126     }
   1127 
   1128     // Set a jump point for libpng to long jump back to on error
   1129     if (setjmp(png_jmpbuf(read_ptr))) {
   1130         fclose(fp);
   1131         png_destroy_read_struct(&read_ptr, &read_info,NULL);
   1132         return error;
   1133     }
   1134 
   1135     // Set up libpng to read from our file.
   1136     png_init_io(read_ptr,fp);
   1137 
   1138     // Actually read data from the file
   1139     read_png(source.string(), read_ptr, read_info, &imageInfo);
   1140 
   1141     // We're done reading so we can clean up
   1142     // Find old file size before releasing handle
   1143     fseek(fp, 0, SEEK_END);
   1144     size_t oldSize = (size_t)ftell(fp);
   1145     fclose(fp);
   1146     png_destroy_read_struct(&read_ptr, &read_info,NULL);
   1147 
   1148     // Check to see if we're dealing with a 9-patch
   1149     // If we are, process appropriately
   1150     if (source.getBasePath().getPathExtension() == ".9")  {
   1151         if (do_9patch(source.string(), &imageInfo) != NO_ERROR) {
   1152             return error;
   1153         }
   1154     }
   1155 
   1156     // Call libpng to create a structure to hold the processed image data
   1157     // that can be written to disk
   1158     write_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
   1159     if (!write_ptr) {
   1160         png_destroy_write_struct(&write_ptr, &write_info);
   1161         return error;
   1162     }
   1163 
   1164     // Call libpng to create a structure to hold processed image info that can
   1165     // be written to disk
   1166     write_info = png_create_info_struct(write_ptr);
   1167     if (!write_info) {
   1168         png_destroy_write_struct(&write_ptr, &write_info);
   1169         return error;
   1170     }
   1171 
   1172     // Open up our destination file for writing
   1173     fp = fopen(dest.string(), "wb");
   1174     if (!fp) {
   1175         fprintf(stderr, "%s ERROR: Unable to open PNG file\n", dest.string());
   1176         png_destroy_write_struct(&write_ptr, &write_info);
   1177         return error;
   1178     }
   1179 
   1180     // Set up libpng to write to our file
   1181     png_init_io(write_ptr, fp);
   1182 
   1183     // Set up a jump for libpng to long jump back on on errors
   1184     if (setjmp(png_jmpbuf(write_ptr))) {
   1185         fclose(fp);
   1186         png_destroy_write_struct(&write_ptr, &write_info);
   1187         return error;
   1188     }
   1189 
   1190     // Actually write out to the new png
   1191     write_png(dest.string(), write_ptr, write_info, imageInfo,
   1192               bundle->getGrayscaleTolerance());
   1193 
   1194     if (bundle->getVerbose()) {
   1195         // Find the size of our new file
   1196         FILE* reader = fopen(dest.string(), "rb");
   1197         fseek(reader, 0, SEEK_END);
   1198         size_t newSize = (size_t)ftell(reader);
   1199         fclose(reader);
   1200 
   1201         float factor = ((float)newSize)/oldSize;
   1202         int percent = (int)(factor*100);
   1203         printf("  (processed image to cache entry %s: %d%% size of source)\n",
   1204                dest.string(), percent);
   1205     }
   1206 
   1207     //Clean up
   1208     fclose(fp);
   1209     png_destroy_write_struct(&write_ptr, &write_info);
   1210 
   1211     return NO_ERROR;
   1212 }
   1213 
   1214 status_t postProcessImage(const sp<AaptAssets>& assets,
   1215                           ResourceTable* table, const sp<AaptFile>& file)
   1216 {
   1217     String8 ext(file->getPath().getPathExtension());
   1218 
   1219     // At this point, now that we have all the resource data, all we need to
   1220     // do is compile XML files.
   1221     if (strcmp(ext.string(), ".xml") == 0) {
   1222         return compileXmlFile(assets, file, table);
   1223     }
   1224 
   1225     return NO_ERROR;
   1226 }
   1227