tools/aapt/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 <androidfw/ResourceTypes.h>
  12 #include <utils/ByteOrder.h>
  13
  14 #include <png.h>
  15 #include <zlib.h>
  16
  17 // Change this to true for noisy debug output.
  18 static const bool kIsDebug = false;
  19
  20 static void
  21 png_write_aapt_file(png_structp png_ptr, png_bytep data, png_size_t length)
  22 {
  23     AaptFile* aaptfile = (AaptFile*) png_get_io_ptr(png_ptr);
  24     status_t err = aaptfile->writeData(data, length);
  25     if (err != NO_ERROR) {
  26         png_error(png_ptr, "Write Error");
  27     }
  28 }
  29
  30
  31 static void
  32 png_flush_aapt_file(png_structp /* png_ptr */)
  33 {
  34 }
  35
  36 // This holds an image as 8bpp RGBA.
  37 struct image_info
  38 {
  39     image_info() : rows(NULL), is9Patch(false),
  40         xDivs(NULL), yDivs(NULL), colors(NULL), allocRows(NULL) { }
  41
  42     ~image_info() {
  43         if (rows && rows != allocRows) {
  44             free(rows);
  45         }
  46         if (allocRows) {
  47             for (int i=0; i<(int)allocHeight; i++) {
  48                 free(allocRows[i]);
  49             }
  50             free(allocRows);
  51         }
  52         free(xDivs);
  53         free(yDivs);
  54         free(colors);
  55     }
  56
  57     void* serialize9patch() {
  58         void* serialized = Res_png_9patch::serialize(info9Patch, xDivs, yDivs, colors);
  59         reinterpret_cast<Res_png_9patch*>(serialized)->deviceToFile();
  60         return serialized;
  61     }
  62
  63     png_uint_32 width;
  64     png_uint_32 height;
  65     png_bytepp rows;
  66
  67     // 9-patch info.
  68     bool is9Patch;
  69     Res_png_9patch info9Patch;
  70     int32_t* xDivs;
  71     int32_t* yDivs;
  72     uint32_t* colors;
  73
  74     // Layout padding, if relevant
  75     bool haveLayoutBounds;
  76     int32_t layoutBoundsLeft;
  77     int32_t layoutBoundsTop;
  78     int32_t layoutBoundsRight;
  79     int32_t layoutBoundsBottom;
  80
  81     // Round rect outline description
  82     int32_t outlineInsetsLeft;
  83     int32_t outlineInsetsTop;
  84     int32_t outlineInsetsRight;
  85     int32_t outlineInsetsBottom;
  86     float outlineRadius;
  87     uint8_t outlineAlpha;
  88
  89     png_uint_32 allocHeight;
  90     png_bytepp allocRows;
  91 };
  92
  93 static void log_warning(png_structp png_ptr, png_const_charp warning_message)
  94 {
  95     const char* imageName = (const char*) png_get_error_ptr(png_ptr);
  96     fprintf(stderr, "%s: libpng warning: %s\n", imageName, warning_message);
  97 }
  98
  99 static void read_png(const char* imageName,
 100                      png_structp read_ptr, png_infop read_info,
 101                      image_info* outImageInfo)
 102 {
 103     int color_type;
 104     int bit_depth, interlace_type, compression_type;
 105     int i;
 106
 107     png_set_error_fn(read_ptr, const_cast<char*>(imageName),
 108             NULL /* use default errorfn */, log_warning);
 109     png_read_info(read_ptr, read_info);
 110
 111     png_get_IHDR(read_ptr, read_info, &outImageInfo->width,
 112        &outImageInfo->height, &bit_depth, &color_type,
 113        &interlace_type, &compression_type, NULL);
 114
 115     //printf("Image %s:\n", imageName);
 116     //printf("color_type=%d, bit_depth=%d, interlace_type=%d, compression_type=%d\n",
 117     //       color_type, bit_depth, interlace_type, compression_type);
 118
 119     if (color_type == PNG_COLOR_TYPE_PALETTE)
 120         png_set_palette_to_rgb(read_ptr);
 121
 122     if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
 123         png_set_expand_gray_1_2_4_to_8(read_ptr);
 124
 125     if (png_get_valid(read_ptr, read_info, PNG_INFO_tRNS)) {
 126         //printf("Has PNG_INFO_tRNS!\n");
 127         png_set_tRNS_to_alpha(read_ptr);
 128     }
 129
 130     if (bit_depth == 16)
 131         png_set_strip_16(read_ptr);
 132
 133     if ((color_type&PNG_COLOR_MASK_ALPHA) == 0)
 134         png_set_add_alpha(read_ptr, 0xFF, PNG_FILLER_AFTER);
 135
 136     if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
 137         png_set_gray_to_rgb(read_ptr);
 138
 139     png_set_interlace_handling(read_ptr);
 140
 141     png_read_update_info(read_ptr, read_info);
 142
 143     outImageInfo->rows = (png_bytepp)malloc(
 144         outImageInfo->height * sizeof(png_bytep));
 145     outImageInfo->allocHeight = outImageInfo->height;
 146     outImageInfo->allocRows = outImageInfo->rows;
 147
 148     png_set_rows(read_ptr, read_info, outImageInfo->rows);
 149
 150     for (i = 0; i < (int)outImageInfo->height; i++)
 151     {
 152         outImageInfo->rows[i] = (png_bytep)
 153             malloc(png_get_rowbytes(read_ptr, read_info));
 154     }
 155
 156     png_read_image(read_ptr, outImageInfo->rows);
 157
 158     png_read_end(read_ptr, read_info);
 159
 160     if (kIsDebug) {
 161         printf("Image %s: w=%d, h=%d, d=%d, colors=%d, inter=%d, comp=%d\n",
 162                 imageName,
 163                 (int)outImageInfo->width, (int)outImageInfo->height,
 164                 bit_depth, color_type,
 165                 interlace_type, compression_type);
 166     }
 167
 168     png_get_IHDR(read_ptr, read_info, &outImageInfo->width,
 169        &outImageInfo->height, &bit_depth, &color_type,
 170        &interlace_type, &compression_type, NULL);
 171 }
 172
 173 #define COLOR_TRANSPARENT 0
 174 #define COLOR_WHITE 0xFFFFFFFF
 175 #define COLOR_TICK  0xFF000000
 176 #define COLOR_LAYOUT_BOUNDS_TICK 0xFF0000FF
 177
 178 enum {
 179     TICK_TYPE_NONE,
 180     TICK_TYPE_TICK,
 181     TICK_TYPE_LAYOUT_BOUNDS,
 182     TICK_TYPE_BOTH
 183 };
 184
 185 static int tick_type(png_bytep p, bool transparent, const char** outError)
 186 {
 187     png_uint_32 color = p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
 188
 189     if (transparent) {
 190         if (p[3] == 0) {
 191             return TICK_TYPE_NONE;
 192         }
 193         if (color == COLOR_LAYOUT_BOUNDS_TICK) {
 194             return TICK_TYPE_LAYOUT_BOUNDS;
 195         }
 196         if (color == COLOR_TICK) {
 197             return TICK_TYPE_TICK;
 198         }
 199
 200         // Error cases
 201         if (p[3] != 0xff) {
 202             *outError = "Frame pixels must be either solid or transparent (not intermediate alphas)";
 203             return TICK_TYPE_NONE;
 204         }
 205         if (p[0] != 0 || p[1] != 0 || p[2] != 0) {
 206             *outError = "Ticks in transparent frame must be black or red";
 207         }
 208         return TICK_TYPE_TICK;
 209     }
 210
 211     if (p[3] != 0xFF) {
 212         *outError = "White frame must be a solid color (no alpha)";
 213     }
 214     if (color == COLOR_WHITE) {
 215         return TICK_TYPE_NONE;
 216     }
 217     if (color == COLOR_TICK) {
 218         return TICK_TYPE_TICK;
 219     }
 220     if (color == COLOR_LAYOUT_BOUNDS_TICK) {
 221         return TICK_TYPE_LAYOUT_BOUNDS;
 222     }
 223
 224     if (p[0] != 0 || p[1] != 0 || p[2] != 0) {
 225         *outError = "Ticks in white frame must be black or red";
 226         return TICK_TYPE_NONE;
 227     }
 228     return TICK_TYPE_TICK;
 229 }
 230
 231 enum {
 232     TICK_START,
 233     TICK_INSIDE_1,
 234     TICK_OUTSIDE_1
 235 };
 236
 237 static status_t get_horizontal_ticks(
 238         png_bytep row, int width, bool transparent, bool required,
 239         int32_t* outLeft, int32_t* outRight, const char** outError,
 240         uint8_t* outDivs, bool multipleAllowed)
 241 {
 242     int i;
 243     *outLeft = *outRight = -1;
 244     int state = TICK_START;
 245     bool found = false;
 246
 247     for (i=1; i<width-1; i++) {
 248         if (TICK_TYPE_TICK == tick_type(row+i*4, transparent, outError)) {
 249             if (state == TICK_START ||
 250                 (state == TICK_OUTSIDE_1 && multipleAllowed)) {
 251                 *outLeft = i-1;
 252                 *outRight = width-2;
 253                 found = true;
 254                 if (outDivs != NULL) {
 255                     *outDivs += 2;
 256                 }
 257                 state = TICK_INSIDE_1;
 258             } else if (state == TICK_OUTSIDE_1) {
 259                 *outError = "Can't have more than one marked region along edge";
 260                 *outLeft = i;
 261                 return UNKNOWN_ERROR;
 262             }
 263         } else if (*outError == NULL) {
 264             if (state == TICK_INSIDE_1) {
 265                 // We're done with this div.  Move on to the next.
 266                 *outRight = i-1;
 267                 outRight += 2;
 268                 outLeft += 2;
 269                 state = TICK_OUTSIDE_1;
 270             }
 271         } else {
 272             *outLeft = i;
 273             return UNKNOWN_ERROR;
 274         }
 275     }
 276
 277     if (required && !found) {
 278         *outError = "No marked region found along edge";
 279         *outLeft = -1;
 280         return UNKNOWN_ERROR;
 281     }
 282
 283     return NO_ERROR;
 284 }
 285
 286 static status_t get_vertical_ticks(
 287         png_bytepp rows, int offset, int height, bool transparent, bool required,
 288         int32_t* outTop, int32_t* outBottom, const char** outError,
 289         uint8_t* outDivs, bool multipleAllowed)
 290 {
 291     int i;
 292     *outTop = *outBottom = -1;
 293     int state = TICK_START;
 294     bool found = false;
 295
 296     for (i=1; i<height-1; i++) {
 297         if (TICK_TYPE_TICK == tick_type(rows[i]+offset, transparent, outError)) {
 298             if (state == TICK_START ||
 299                 (state == TICK_OUTSIDE_1 && multipleAllowed)) {
 300                 *outTop = i-1;
 301                 *outBottom = height-2;
 302                 found = true;
 303                 if (outDivs != NULL) {
 304                     *outDivs += 2;
 305                 }
 306                 state = TICK_INSIDE_1;
 307             } else if (state == TICK_OUTSIDE_1) {
 308                 *outError = "Can't have more than one marked region along edge";
 309                 *outTop = i;
 310                 return UNKNOWN_ERROR;
 311             }
 312         } else if (*outError == NULL) {
 313             if (state == TICK_INSIDE_1) {
 314                 // We're done with this div.  Move on to the next.
 315                 *outBottom = i-1;
 316                 outTop += 2;
 317                 outBottom += 2;
 318                 state = TICK_OUTSIDE_1;
 319             }
 320         } else {
 321             *outTop = i;
 322             return UNKNOWN_ERROR;
 323         }
 324     }
 325
 326     if (required && !found) {
 327         *outError = "No marked region found along edge";
 328         *outTop = -1;
 329         return UNKNOWN_ERROR;
 330     }
 331
 332     return NO_ERROR;
 333 }
 334
 335 static status_t get_horizontal_layout_bounds_ticks(
 336         png_bytep row, int width, bool transparent, bool /* required */,
 337         int32_t* outLeft, int32_t* outRight, const char** outError)
 338 {
 339     int i;
 340     *outLeft = *outRight = 0;
 341
 342     // Look for left tick
 343     if (TICK_TYPE_LAYOUT_BOUNDS == tick_type(row + 4, transparent, outError)) {
 344         // Starting with a layout padding tick
 345         i = 1;
 346         while (i < width - 1) {
 347             (*outLeft)++;
 348             i++;
 349             int tick = tick_type(row + i * 4, transparent, outError);
 350             if (tick != TICK_TYPE_LAYOUT_BOUNDS) {
 351                 break;
 352             }
 353         }
 354     }
 355
 356     // Look for right tick
 357     if (TICK_TYPE_LAYOUT_BOUNDS == tick_type(row + (width - 2) * 4, transparent, outError)) {
 358         // Ending with a layout padding tick
 359         i = width - 2;
 360         while (i > 1) {
 361             (*outRight)++;
 362             i--;
 363             int tick = tick_type(row+i*4, transparent, outError);
 364             if (tick != TICK_TYPE_LAYOUT_BOUNDS) {
 365                 break;
 366             }
 367         }
 368     }
 369
 370     return NO_ERROR;
 371 }
 372
 373 static status_t get_vertical_layout_bounds_ticks(
 374         png_bytepp rows, int offset, int height, bool transparent, bool /* required */,
 375         int32_t* outTop, int32_t* outBottom, const char** outError)
 376 {
 377     int i;
 378     *outTop = *outBottom = 0;
 379
 380     // Look for top tick
 381     if (TICK_TYPE_LAYOUT_BOUNDS == tick_type(rows[1] + offset, transparent, outError)) {
 382         // Starting with a layout padding tick
 383         i = 1;
 384         while (i < height - 1) {
 385             (*outTop)++;
 386             i++;
 387             int tick = tick_type(rows[i] + offset, transparent, outError);
 388             if (tick != TICK_TYPE_LAYOUT_BOUNDS) {
 389                 break;
 390             }
 391         }
 392     }
 393
 394     // Look for bottom tick
 395     if (TICK_TYPE_LAYOUT_BOUNDS == tick_type(rows[height - 2] + offset, transparent, outError)) {
 396         // Ending with a layout padding tick
 397         i = height - 2;
 398         while (i > 1) {
 399             (*outBottom)++;
 400             i--;
 401             int tick = tick_type(rows[i] + offset, transparent, outError);
 402             if (tick != TICK_TYPE_LAYOUT_BOUNDS) {
 403                 break;
 404             }
 405         }
 406     }
 407
 408     return NO_ERROR;
 409 }
 410
 411 static void find_max_opacity(png_byte** rows,
 412                              int startX, int startY, int endX, int endY, int dX, int dY,
 413                              int* out_inset)
 414 {
 415     uint8_t max_opacity = 0;
 416     int inset = 0;
 417     *out_inset = 0;
 418     for (int x = startX, y = startY; x != endX && y != endY; x += dX, y += dY, inset++) {
 419         png_byte* color = rows[y] + x * 4;
 420         uint8_t opacity = color[3];
 421         if (opacity > max_opacity) {
 422             max_opacity = opacity;
 423             *out_inset = inset;
 424         }
 425         if (opacity == 0xff) return;
 426     }
 427 }
 428
 429 static uint8_t max_alpha_over_row(png_byte* row, int startX, int endX)
 430 {
 431     uint8_t max_alpha = 0;
 432     for (int x = startX; x < endX; x++) {
 433         uint8_t alpha = (row + x * 4)[3];
 434         if (alpha > max_alpha) max_alpha = alpha;
 435     }
 436     return max_alpha;
 437 }
 438
 439 static uint8_t max_alpha_over_col(png_byte** rows, int offsetX, int startY, int endY)
 440 {
 441     uint8_t max_alpha = 0;
 442     for (int y = startY; y < endY; y++) {
 443         uint8_t alpha = (rows[y] + offsetX * 4)[3];
 444         if (alpha > max_alpha) max_alpha = alpha;
 445     }
 446     return max_alpha;
 447 }
 448
 449 static void get_outline(image_info* image)
 450 {
 451     int midX = image->width / 2;
 452     int midY = image->height / 2;
 453     int endX = image->width - 2;
 454     int endY = image->height - 2;
 455
 456     // find left and right extent of nine patch content on center row
 457     if (image->width > 4) {
 458         find_max_opacity(image->rows, 1, midY, midX, -1, 1, 0, &image->outlineInsetsLeft);
 459         find_max_opacity(image->rows, endX, midY, midX, -1, -1, 0, &image->outlineInsetsRight);
 460     } else {
 461         image->outlineInsetsLeft = 0;
 462         image->outlineInsetsRight = 0;
 463     }
 464
 465     // find top and bottom extent of nine patch content on center column
 466     if (image->height > 4) {
 467         find_max_opacity(image->rows, midX, 1, -1, midY, 0, 1, &image->outlineInsetsTop);
 468         find_max_opacity(image->rows, midX, endY, -1, midY, 0, -1, &image->outlineInsetsBottom);
 469     } else {
 470         image->outlineInsetsTop = 0;
 471         image->outlineInsetsBottom = 0;
 472     }
 473
 474     int innerStartX = 1 + image->outlineInsetsLeft;
 475     int innerStartY = 1 + image->outlineInsetsTop;
 476     int innerEndX = endX - image->outlineInsetsRight;
 477     int innerEndY = endY - image->outlineInsetsBottom;
 478     int innerMidX = (innerEndX + innerStartX) / 2;
 479     int innerMidY = (innerEndY + innerStartY) / 2;
 480
 481     // assuming the image is a round rect, compute the radius by marching
 482     // diagonally from the top left corner towards the center
 483     image->outlineAlpha = std::max(
 484         max_alpha_over_row(image->rows[innerMidY], innerStartX, innerEndX),
 485         max_alpha_over_col(image->rows, innerMidX, innerStartY, innerStartY));
 486
 487     int diagonalInset = 0;
 488     find_max_opacity(image->rows, innerStartX, innerStartY, innerMidX, innerMidY, 1, 1,
 489             &diagonalInset);
 490
 491     /* Determine source radius based upon inset:
 492      *     sqrt(r^2 + r^2) = sqrt(i^2 + i^2) + r
 493      *     sqrt(2) * r = sqrt(2) * i + r
 494      *     (sqrt(2) - 1) * r = sqrt(2) * i
 495      *     r = sqrt(2) / (sqrt(2) - 1) * i
 496      */
 497     image->outlineRadius = 3.4142f * diagonalInset;
 498
 499     if (kIsDebug) {
 500         printf("outline insets %d %d %d %d, rad %f, alpha %x\n",
 501                 image->outlineInsetsLeft,
 502                 image->outlineInsetsTop,
 503                 image->outlineInsetsRight,
 504                 image->outlineInsetsBottom,
 505                 image->outlineRadius,
 506                 image->outlineAlpha);
 507     }
 508 }
 509
 510
 511 static uint32_t get_color(
 512     png_bytepp rows, int left, int top, int right, int bottom)
 513 {
 514     png_bytep color = rows[top] + left*4;
 515
 516     if (left > right || top > bottom) {
 517         return Res_png_9patch::TRANSPARENT_COLOR;
 518     }
 519
 520     while (top <= bottom) {
 521         for (int i = left; i <= right; i++) {
 522             png_bytep p = rows[top]+i*4;
 523             if (color[3] == 0) {
 524                 if (p[3] != 0) {
 525                     return Res_png_9patch::NO_COLOR;
 526                 }
 527             } else if (p[0] != color[0] || p[1] != color[1]
 528                        || p[2] != color[2] || p[3] != color[3]) {
 529                 return Res_png_9patch::NO_COLOR;
 530             }
 531         }
 532         top++;
 533     }
 534
 535     if (color[3] == 0) {
 536         return Res_png_9patch::TRANSPARENT_COLOR;
 537     }
 538     return (color[3]<<24) | (color[0]<<16) | (color[1]<<8) | color[2];
 539 }
 540
 541 static status_t do_9patch(const char* imageName, image_info* image)
 542 {
 543     image->is9Patch = true;
 544
 545     int W = image->width;
 546     int H = image->height;
 547     int i, j;
 548
 549     int maxSizeXDivs = W * sizeof(int32_t);
 550     int maxSizeYDivs = H * sizeof(int32_t);
 551     int32_t* xDivs = image->xDivs = (int32_t*) malloc(maxSizeXDivs);
 552     int32_t* yDivs = image->yDivs = (int32_t*) malloc(maxSizeYDivs);
 553     uint8_t numXDivs = 0;
 554     uint8_t numYDivs = 0;
 555
 556     int8_t numColors;
 557     int numRows;
 558     int numCols;
 559     int top;
 560     int left;
 561     int right;
 562     int bottom;
 563     memset(xDivs, -1, maxSizeXDivs);
 564     memset(yDivs, -1, maxSizeYDivs);
 565     image->info9Patch.paddingLeft = image->info9Patch.paddingRight =
 566         image->info9Patch.paddingTop = image->info9Patch.paddingBottom = -1;
 567
 568     image->layoutBoundsLeft = image->layoutBoundsRight =
 569         image->layoutBoundsTop = image->layoutBoundsBottom = 0;
 570
 571     png_bytep p = image->rows[0];
 572     bool transparent = p[3] == 0;
 573     bool hasColor = false;
 574
 575     const char* errorMsg = NULL;
 576     int errorPixel = -1;
 577     const char* errorEdge = NULL;
 578
 579     int colorIndex = 0;
 580
 581     // Validate size...
 582     if (W < 3 || H < 3) {
 583         errorMsg = "Image must be at least 3x3 (1x1 without frame) pixels";
 584         goto getout;
 585     }
 586
 587     // Validate frame...
 588     if (!transparent &&
 589         (p[0] != 0xFF || p[1] != 0xFF || p[2] != 0xFF || p[3] != 0xFF)) {
 590         errorMsg = "Must have one-pixel frame that is either transparent or white";
 591         goto getout;
 592     }
 593
 594     // Find left and right of sizing areas...
 595     if (get_horizontal_ticks(p, W, transparent, true, &xDivs[0],
 596                              &xDivs[1], &errorMsg, &numXDivs, true) != NO_ERROR) {
 597         errorPixel = xDivs[0];
 598         errorEdge = "top";
 599         goto getout;
 600     }
 601
 602     // Find top and bottom of sizing areas...
 603     if (get_vertical_ticks(image->rows, 0, H, transparent, true, &yDivs[0],
 604                            &yDivs[1], &errorMsg, &numYDivs, true) != NO_ERROR) {
 605         errorPixel = yDivs[0];
 606         errorEdge = "left";
 607         goto getout;
 608     }
 609
 610     // Copy patch size data into image...
 611     image->info9Patch.numXDivs = numXDivs;
 612     image->info9Patch.numYDivs = numYDivs;
 613
 614     // Find left and right of padding area...
 615     if (get_horizontal_ticks(image->rows[H-1], W, transparent, false, &image->info9Patch.paddingLeft,
 616                              &image->info9Patch.paddingRight, &errorMsg, NULL, false) != NO_ERROR) {
 617         errorPixel = image->info9Patch.paddingLeft;
 618         errorEdge = "bottom";
 619         goto getout;
 620     }
 621
 622     // Find top and bottom of padding area...
 623     if (get_vertical_ticks(image->rows, (W-1)*4, H, transparent, false, &image->info9Patch.paddingTop,
 624                            &image->info9Patch.paddingBottom, &errorMsg, NULL, false) != NO_ERROR) {
 625         errorPixel = image->info9Patch.paddingTop;
 626         errorEdge = "right";
 627         goto getout;
 628     }
 629
 630     // Find left and right of layout padding...
 631     get_horizontal_layout_bounds_ticks(image->rows[H-1], W, transparent, false,
 632                                         &image->layoutBoundsLeft,
 633                                         &image->layoutBoundsRight, &errorMsg);
 634
 635     get_vertical_layout_bounds_ticks(image->rows, (W-1)*4, H, transparent, false,
 636                                         &image->layoutBoundsTop,
 637                                         &image->layoutBoundsBottom, &errorMsg);
 638
 639     image->haveLayoutBounds = image->layoutBoundsLeft != 0
 640                                || image->layoutBoundsRight != 0
 641                                || image->layoutBoundsTop != 0
 642                                || image->layoutBoundsBottom != 0;
 643
 644     if (image->haveLayoutBounds) {
 645         if (kIsDebug) {
 646             printf("layoutBounds=%d %d %d %d\n", image->layoutBoundsLeft, image->layoutBoundsTop,
 647                     image->layoutBoundsRight, image->layoutBoundsBottom);
 648         }
 649     }
 650
 651     // use opacity of pixels to estimate the round rect outline
 652     get_outline(image);
 653
 654     // If padding is not yet specified, take values from size.
 655     if (image->info9Patch.paddingLeft < 0) {
 656         image->info9Patch.paddingLeft = xDivs[0];
 657         image->info9Patch.paddingRight = W - 2 - xDivs[1];
 658     } else {
 659         // Adjust value to be correct!
 660         image->info9Patch.paddingRight = W - 2 - image->info9Patch.paddingRight;
 661     }
 662     if (image->info9Patch.paddingTop < 0) {
 663         image->info9Patch.paddingTop = yDivs[0];
 664         image->info9Patch.paddingBottom = H - 2 - yDivs[1];
 665     } else {
 666         // Adjust value to be correct!
 667         image->info9Patch.paddingBottom = H - 2 - image->info9Patch.paddingBottom;
 668     }
 669
 670     if (kIsDebug) {
 671         printf("Size ticks for %s: x0=%d, x1=%d, y0=%d, y1=%d\n", imageName,
 672                 xDivs[0], xDivs[1],
 673                 yDivs[0], yDivs[1]);
 674         printf("padding ticks for %s: l=%d, r=%d, t=%d, b=%d\n", imageName,
 675                 image->info9Patch.paddingLeft, image->info9Patch.paddingRight,
 676                 image->info9Patch.paddingTop, image->info9Patch.paddingBottom);
 677     }
 678
 679     // Remove frame from image.
 680     image->rows = (png_bytepp)malloc((H-2) * sizeof(png_bytep));
 681     for (i=0; i<(H-2); i++) {
 682         image->rows[i] = image->allocRows[i+1];
 683         memmove(image->rows[i], image->rows[i]+4, (W-2)*4);
 684     }
 685     image->width -= 2;
 686     W = image->width;
 687     image->height -= 2;
 688     H = image->height;
 689
 690     // Figure out the number of rows and columns in the N-patch
 691     numCols = numXDivs + 1;
 692     if (xDivs[0] == 0) {  // Column 1 is strechable
 693         numCols--;
 694     }
 695     if (xDivs[numXDivs - 1] == W) {
 696         numCols--;
 697     }
 698     numRows = numYDivs + 1;
 699     if (yDivs[0] == 0) {  // Row 1 is strechable
 700         numRows--;
 701     }
 702     if (yDivs[numYDivs - 1] == H) {
 703         numRows--;
 704     }
 705
 706     // Make sure the amount of rows and columns will fit in the number of
 707     // colors we can use in the 9-patch format.
 708     if (numRows * numCols > 0x7F) {
 709         errorMsg = "Too many rows and columns in 9-patch perimeter";
 710         goto getout;
 711     }
 712
 713     numColors = numRows * numCols;
 714     image->info9Patch.numColors = numColors;
 715     image->colors = (uint32_t*)malloc(numColors * sizeof(uint32_t));
 716
 717     // Fill in color information for each patch.
 718
 719     uint32_t c;
 720     top = 0;
 721
 722     // The first row always starts with the top being at y=0 and the bottom
 723     // being either yDivs[1] (if yDivs[0]=0) of yDivs[0].  In the former case
 724     // the first row is stretchable along the Y axis, otherwise it is fixed.
 725     // The last row always ends with the bottom being bitmap.height and the top
 726     // being either yDivs[numYDivs-2] (if yDivs[numYDivs-1]=bitmap.height) or
 727     // yDivs[numYDivs-1]. In the former case the last row is stretchable along
 728     // the Y axis, otherwise it is fixed.
 729     //
 730     // The first and last columns are similarly treated with respect to the X
 731     // axis.
 732     //
 733     // The above is to help explain some of the special casing that goes on the
 734     // code below.
 735
 736     // The initial yDiv and whether the first row is considered stretchable or
 737     // not depends on whether yDiv[0] was zero or not.
 738     for (j = (yDivs[0] == 0 ? 1 : 0);
 739           j <= numYDivs && top < H;
 740           j++) {
 741         if (j == numYDivs) {
 742             bottom = H;
 743         } else {
 744             bottom = yDivs[j];
 745         }
 746         left = 0;
 747         // The initial xDiv and whether the first column is considered
 748         // stretchable or not depends on whether xDiv[0] was zero or not.
 749         for (i = xDivs[0] == 0 ? 1 : 0;
 750               i <= numXDivs && left < W;
 751               i++) {
 752             if (i == numXDivs) {
 753                 right = W;
 754             } else {
 755                 right = xDivs[i];
 756             }
 757             c = get_color(image->rows, left, top, right - 1, bottom - 1);
 758             image->colors[colorIndex++] = c;
 759             if (kIsDebug) {
 760                 if (c != Res_png_9patch::NO_COLOR)
 761                     hasColor = true;
 762             }
 763             left = right;
 764         }
 765         top = bottom;
 766     }
 767
 768     assert(colorIndex == numColors);
 769
 770     for (i=0; i<numColors; i++) {
 771         if (hasColor) {
 772             if (i == 0) printf("Colors in %s:\n ", imageName);
 773             printf(" #%08x", image->colors[i]);
 774             if (i == numColors - 1) printf("\n");
 775         }
 776     }
 777 getout:
 778     if (errorMsg) {
 779         fprintf(stderr,
 780             "ERROR: 9-patch image %s malformed.\n"
 781             "       %s.\n", imageName, errorMsg);
 782         if (errorEdge != NULL) {
 783             if (errorPixel >= 0) {
 784                 fprintf(stderr,
 785                     "       Found at pixel #%d along %s edge.\n", errorPixel, errorEdge);
 786             } else {
 787                 fprintf(stderr,
 788                     "       Found along %s edge.\n", errorEdge);
 789             }
 790         }
 791         return UNKNOWN_ERROR;
 792     }
 793     return NO_ERROR;
 794 }
 795
 796 static void checkNinePatchSerialization(Res_png_9patch* inPatch,  void* data)
 797 {
 798     size_t patchSize = inPatch->serializedSize();
 799     void* newData = malloc(patchSize);
 800     memcpy(newData, data, patchSize);
 801     Res_png_9patch* outPatch = inPatch->deserialize(newData);
 802     // deserialization is done in place, so outPatch == newData
 803     assert(outPatch == newData);
 804     assert(outPatch->numXDivs == inPatch->numXDivs);
 805     assert(outPatch->numYDivs == inPatch->numYDivs);
 806     assert(outPatch->paddingLeft == inPatch->paddingLeft);
 807     assert(outPatch->paddingRight == inPatch->paddingRight);
 808     assert(outPatch->paddingTop == inPatch->paddingTop);
 809     assert(outPatch->paddingBottom == inPatch->paddingBottom);
 810     for (int i = 0; i < outPatch->numXDivs; i++) {
 811         assert(outPatch->getXDivs()[i] == inPatch->getXDivs()[i]);
 812     }
 813     for (int i = 0; i < outPatch->numYDivs; i++) {
 814         assert(outPatch->getYDivs()[i] == inPatch->getYDivs()[i]);
 815     }
 816     for (int i = 0; i < outPatch->numColors; i++) {
 817         assert(outPatch->getColors()[i] == inPatch->getColors()[i]);
 818     }
 819     free(newData);
 820 }
 821
 822 static void dump_image(int w, int h, png_bytepp rows, int color_type)
 823 {
 824     int i, j, rr, gg, bb, aa;
 825
 826     int bpp;
 827     if (color_type == PNG_COLOR_TYPE_PALETTE || color_type == PNG_COLOR_TYPE_GRAY) {
 828         bpp = 1;
 829     } else if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
 830         bpp = 2;
 831     } else if (color_type == PNG_COLOR_TYPE_RGB || color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
 832         // We use a padding byte even when there is no alpha
 833         bpp = 4;
 834     } else {
 835         printf("Unknown color type %d.\n", color_type);
 836     }
 837
 838     for (j = 0; j < h; j++) {
 839         png_bytep row = rows[j];
 840         for (i = 0; i < w; i++) {
 841             rr = row[0];
 842             gg = row[1];
 843             bb = row[2];
 844             aa = row[3];
 845             row += bpp;
 846
 847             if (i == 0) {
 848                 printf("Row %d:", j);
 849             }
 850             switch (bpp) {
 851             case 1:
 852                 printf(" (%d)", rr);
 853                 break;
 854             case 2:
 855                 printf(" (%d %d", rr, gg);
 856                 break;
 857             case 3:
 858                 printf(" (%d %d %d)", rr, gg, bb);
 859                 break;
 860             case 4:
 861                 printf(" (%d %d %d %d)", rr, gg, bb, aa);
 862                 break;
 863             }
 864             if (i == (w - 1)) {
 865                 printf("\n");
 866             }
 867         }
 868     }
 869 }
 870
 871 #define MAX(a,b) ((a)>(b)?(a):(b))
 872 #define ABS(a)   ((a)<0?-(a):(a))
 873
 874 static void analyze_image(const char *imageName, image_info &imageInfo, int grayscaleTolerance,
 875                           png_colorp rgbPalette, png_bytep alphaPalette,
 876                           int *paletteEntries, int *alphaPaletteEntries, bool *hasTransparency,
 877                           int *colorType, png_bytepp outRows)
 878 {
 879     int w = imageInfo.width;
 880     int h = imageInfo.height;
 881     int i, j, rr, gg, bb, aa, idx;;
 882     uint32_t opaqueColors[256], alphaColors[256];
 883     uint32_t col;
 884     int numOpaqueColors = 0, numAlphaColors = 0;
 885     int maxGrayDeviation = 0;
 886
 887     bool isOpaque = true;
 888     bool isPalette = true;
 889     bool isGrayscale = true;
 890
 891     // Scan the entire image and determine if:
 892     // 1. Every pixel has R == G == B (grayscale)
 893     // 2. Every pixel has A == 255 (opaque)
 894     // 3. There are no more than 256 distinct RGBA colors
 895     //        We will track opaque colors separately from colors with
 896     //        alpha.  This allows us to reencode the color table more
 897     //        efficiently (color tables entries without a corresponding
 898     //        alpha value are assumed to be opaque).
 899
 900     if (kIsDebug) {
 901         printf("Initial image data:\n");
 902         dump_image(w, h, imageInfo.rows, PNG_COLOR_TYPE_RGB_ALPHA);
 903     }
 904
 905     for (j = 0; j < h; j++) {
 906         png_bytep row = imageInfo.rows[j];
 907         png_bytep out = outRows[j];
 908         for (i = 0; i < w; i++) {
 909
 910             // Make sure any zero alpha pixels are fully zeroed.  On average,
 911             // each of our PNG assets seem to have about four distinct pixels
 912             // with zero alpha.
 913             // There are several advantages to setting these to zero:
 914             // (1) Images are more likely able to be encodable with a palette.
 915             // (2) Image palettes will be smaller.
 916             // (3) Premultiplied and unpremultiplied PNG decodes can skip
 917             //     writing zeros to memory, often saving significant numbers
 918             //     of memory pages.
 919             aa = *(row + 3);
 920             if (aa == 0) {
 921                 rr = 0;
 922                 gg = 0;
 923                 bb = 0;
 924
 925                 // Also set red, green, and blue to zero in "row".  If we later
 926                 // decide to encode the PNG as RGB or RGBA, we will use the
 927                 // values stored there.
 928                 *(row) = 0;
 929                 *(row + 1) = 0;
 930                 *(row + 2) = 0;
 931             } else {
 932                 rr = *(row);
 933                 gg = *(row + 1);
 934                 bb = *(row + 2);
 935             }
 936             row += 4;
 937
 938             int odev = maxGrayDeviation;
 939             maxGrayDeviation = MAX(ABS(rr - gg), maxGrayDeviation);
 940             maxGrayDeviation = MAX(ABS(gg - bb), maxGrayDeviation);
 941             maxGrayDeviation = MAX(ABS(bb - rr), maxGrayDeviation);
 942             if (maxGrayDeviation > odev) {
 943                 if (kIsDebug) {
 944                     printf("New max dev. = %d at pixel (%d, %d) = (%d %d %d %d)\n",
 945                             maxGrayDeviation, i, j, rr, gg, bb, aa);
 946                 }
 947             }
 948
 949             // Check if image is really grayscale
 950             if (isGrayscale) {
 951                 if (rr != gg || rr != bb) {
 952                     if (kIsDebug) {
 953                         printf("Found a non-gray pixel at %d, %d = (%d %d %d %d)\n",
 954                                 i, j, rr, gg, bb, aa);
 955                     }
 956                     isGrayscale = false;
 957                 }
 958             }
 959
 960             // Check if image is really opaque
 961             if (isOpaque) {
 962                 if (aa != 0xff) {
 963                     if (kIsDebug) {
 964                         printf("Found a non-opaque pixel at %d, %d = (%d %d %d %d)\n",
 965                                 i, j, rr, gg, bb, aa);
 966                     }
 967                     isOpaque = false;
 968                 }
 969             }
 970
 971             // Check if image is really <= 256 colors
 972             if (isPalette) {
 973                 col = (uint32_t) ((rr << 24) | (gg << 16) | (bb << 8) | aa);
 974                 bool match = false;
 975
 976                 if (aa == 0xff) {
 977                     for (idx = 0; idx < numOpaqueColors; idx++) {
 978                         if (opaqueColors[idx] == col) {
 979                             match = true;
 980                             break;
 981                         }
 982                     }
 983
 984                     if (!match) {
 985                         if (numOpaqueColors < 256) {
 986                             opaqueColors[numOpaqueColors] = col;
 987                         }
 988                         numOpaqueColors++;
 989                     }
 990
 991                     // Write the palette index for the pixel to outRows optimistically.
 992                     // We might overwrite it later if we decide to encode as gray or
 993                     // gray + alpha.  We may also need to overwrite it when we combine
 994                     // into a single palette.
 995                     *out++ = idx;
 996                 } else {
 997                     for (idx = 0; idx < numAlphaColors; idx++) {
 998                         if (alphaColors[idx] == col) {
 999                             match = true;
1000                             break;
1001                         }
1002                     }
1003
1004                     if (!match) {
1005                         if (numAlphaColors < 256) {
1006                             alphaColors[numAlphaColors] = col;
1007                         }
1008                         numAlphaColors++;
1009                     }
1010
1011                     // Write the palette index for the pixel to outRows optimistically.
1012                     // We might overwrite it later if we decide to encode as gray or
1013                     // gray + alpha.
1014                     *out++ = idx;
1015                 }
1016
1017                 if (numOpaqueColors + numAlphaColors > 256) {
1018                     if (kIsDebug) {
1019                         printf("Found 257th color at %d, %d\n", i, j);
1020                     }
1021                     isPalette = false;
1022                 }
1023             }
1024         }
1025     }
1026
1027     // If we decide to encode the image using a palette, we will reset these counts
1028     // to the appropriate values later.  Initializing them here avoids compiler
1029     // complaints about uses of possibly uninitialized variables.
1030     *paletteEntries = 0;
1031     *alphaPaletteEntries = 0;
1032
1033     *hasTransparency = !isOpaque;
1034     int paletteSize = w * h + 3 * numOpaqueColors + 4 * numAlphaColors;
1035
1036     int bpp = isOpaque ? 3 : 4;
1037     if (kIsDebug) {
1038         printf("isGrayscale = %s\n", isGrayscale ? "true" : "false");
1039         printf("isOpaque = %s\n", isOpaque ? "true" : "false");
1040         printf("isPalette = %s\n", isPalette ? "true" : "false");
1041         printf("Size w/ palette = %d, gray+alpha = %d, rgb(a) = %d\n",
1042                 paletteSize, 2 * w * h, bpp * w * h);
1043         printf("Max gray deviation = %d, tolerance = %d\n", maxGrayDeviation, grayscaleTolerance);
1044     }
1045
1046     // Choose the best color type for the image.
1047     // 1. Opaque gray - use COLOR_TYPE_GRAY at 1 byte/pixel
1048     // 2. Gray + alpha - use COLOR_TYPE_PALETTE if the number of distinct combinations
1049     //     is sufficiently small, otherwise use COLOR_TYPE_GRAY_ALPHA
1050     // 3. RGB(A) - use COLOR_TYPE_PALETTE if the number of distinct colors is sufficiently
1051     //     small, otherwise use COLOR_TYPE_RGB{_ALPHA}
1052     if (isGrayscale) {
1053         if (isOpaque) {
1054             *colorType = PNG_COLOR_TYPE_GRAY; // 1 byte/pixel
1055         } else {
1056             // Use a simple heuristic to determine whether using a palette will
1057             // save space versus using gray + alpha for each pixel.
1058             // This doesn't take into account chunk overhead, filtering, LZ
1059             // compression, etc.
1060             if (isPalette && (paletteSize < 2 * w * h)) {
1061                 *colorType = PNG_COLOR_TYPE_PALETTE; // 1 byte/pixel + 4 bytes/color
1062             } else {
1063                 *colorType = PNG_COLOR_TYPE_GRAY_ALPHA; // 2 bytes per pixel
1064             }
1065         }
1066     } else if (isPalette && (paletteSize < bpp * w * h)) {
1067         *colorType = PNG_COLOR_TYPE_PALETTE;
1068     } else {
1069         if (maxGrayDeviation <= grayscaleTolerance) {
1070             printf("%s: forcing image to gray (max deviation = %d)\n", imageName, maxGrayDeviation);
1071             *colorType = isOpaque ? PNG_COLOR_TYPE_GRAY : PNG_COLOR_TYPE_GRAY_ALPHA;
1072         } else {
1073             *colorType = isOpaque ? PNG_COLOR_TYPE_RGB : PNG_COLOR_TYPE_RGB_ALPHA;
1074         }
1075     }
1076
1077     // Perform postprocessing of the image or palette data based on the final
1078     // color type chosen
1079
1080     if (*colorType == PNG_COLOR_TYPE_PALETTE) {
1081         // Combine the alphaColors and the opaqueColors into a single palette.
1082         // The alphaColors must be at the start of the palette.
1083         uint32_t* colors = alphaColors;
1084         memcpy(colors + numAlphaColors, opaqueColors, 4 * numOpaqueColors);
1085
1086         // Fix the indices of the opaque colors in the image.
1087         for (j = 0; j < h; j++) {
1088             png_bytep row = imageInfo.rows[j];
1089             png_bytep out = outRows[j];
1090             for (i = 0; i < w; i++) {
1091                 uint32_t pixel = ((uint32_t*) row)[i];
1092                 if (pixel >> 24 == 0xFF) {
1093                     out[i] += numAlphaColors;
1094                 }
1095             }
1096         }
1097
1098         // Create separate RGB and Alpha palettes and set the number of colors
1099         int numColors = numOpaqueColors + numAlphaColors;
1100         *paletteEntries = numColors;
1101         *alphaPaletteEntries = numAlphaColors;
1102
1103         // Create the RGB and alpha palettes
1104         for (int idx = 0; idx < numColors; idx++) {
1105             col = colors[idx];
1106             rgbPalette[idx].red   = (png_byte) ((col >> 24) & 0xff);
1107             rgbPalette[idx].green = (png_byte) ((col >> 16) & 0xff);
1108             rgbPalette[idx].blue  = (png_byte) ((col >>  8) & 0xff);
1109             if (idx < numAlphaColors) {
1110                 alphaPalette[idx] = (png_byte)  (col        & 0xff);
1111             }
1112         }
1113     } else if (*colorType == PNG_COLOR_TYPE_GRAY || *colorType == PNG_COLOR_TYPE_GRAY_ALPHA) {
1114         // If the image is gray or gray + alpha, compact the pixels into outRows
1115         for (j = 0; j < h; j++) {
1116             png_bytep row = imageInfo.rows[j];
1117             png_bytep out = outRows[j];
1118             for (i = 0; i < w; i++) {
1119                 rr = *row++;
1120                 gg = *row++;
1121                 bb = *row++;
1122                 aa = *row++;
1123
1124                 if (isGrayscale) {
1125                     *out++ = rr;
1126                 } else {
1127                     *out++ = (png_byte) (rr * 0.2126f + gg * 0.7152f + bb * 0.0722f);
1128                 }
1129                 if (!isOpaque) {
1130                     *out++ = aa;
1131                 }
1132            }
1133         }
1134     }
1135 }
1136
1137 static void write_png(const char* imageName,
1138                       png_structp write_ptr, png_infop write_info,
1139                       image_info& imageInfo, const Bundle* bundle)
1140 {
1141     png_uint_32 width, height;
1142     int color_type;
1143     int bit_depth, interlace_type, compression_type;
1144     int i;
1145
1146     png_unknown_chunk unknowns[3];
1147     unknowns[0].data = NULL;
1148     unknowns[1].data = NULL;
1149     unknowns[2].data = NULL;
1150
1151     png_bytepp outRows = (png_bytepp) malloc((int) imageInfo.height * sizeof(png_bytep));
1152     if (outRows == (png_bytepp) 0) {
1153         printf("Can't allocate output buffer!\n");
1154         exit(1);
1155     }
1156     for (i = 0; i < (int) imageInfo.height; i++) {
1157         outRows[i] = (png_bytep) malloc(2 * (int) imageInfo.width);
1158         if (outRows[i] == (png_bytep) 0) {
1159             printf("Can't allocate output buffer!\n");
1160             exit(1);
1161         }
1162     }
1163
1164     png_set_compression_level(write_ptr, Z_BEST_COMPRESSION);
1165
1166     if (kIsDebug) {
1167         printf("Writing image %s: w = %d, h = %d\n", imageName,
1168                 (int) imageInfo.width, (int) imageInfo.height);
1169     }
1170
1171     png_color rgbPalette[256];
1172     png_byte alphaPalette[256];
1173     bool hasTransparency;
1174     int paletteEntries, alphaPaletteEntries;
1175
1176     int grayscaleTolerance = bundle->getGrayscaleTolerance();
1177     analyze_image(imageName, imageInfo, grayscaleTolerance, rgbPalette, alphaPalette,
1178                   &paletteEntries, &alphaPaletteEntries, &hasTransparency, &color_type, outRows);
1179
1180     // Legacy versions of aapt would always encode 9patch PNGs as RGBA.  This had the unintended
1181     // benefit of working around a bug decoding paletted images in Android 4.1.
1182     // https://code.google.com/p/android/issues/detail?id=34619
1183     //
1184     // If SDK_JELLY_BEAN is supported, we need to avoid a paletted encoding in order to not expose
1185     // this bug.
1186     if (!bundle->isMinSdkAtLeast(SDK_JELLY_BEAN_MR1)) {
1187         if (imageInfo.is9Patch && PNG_COLOR_TYPE_PALETTE == color_type) {
1188             if (hasTransparency) {
1189                 color_type = PNG_COLOR_TYPE_RGB_ALPHA;
1190             } else {
1191                 color_type = PNG_COLOR_TYPE_RGB;
1192             }
1193         }
1194     }
1195
1196     if (kIsDebug) {
1197         switch (color_type) {
1198         case PNG_COLOR_TYPE_PALETTE:
1199             printf("Image %s has %d colors%s, using PNG_COLOR_TYPE_PALETTE\n",
1200                     imageName, paletteEntries,
1201                     hasTransparency ? " (with alpha)" : "");
1202             break;
1203         case PNG_COLOR_TYPE_GRAY:
1204             printf("Image %s is opaque gray, using PNG_COLOR_TYPE_GRAY\n", imageName);
1205             break;
1206         case PNG_COLOR_TYPE_GRAY_ALPHA:
1207             printf("Image %s is gray + alpha, using PNG_COLOR_TYPE_GRAY_ALPHA\n", imageName);
1208             break;
1209         case PNG_COLOR_TYPE_RGB:
1210             printf("Image %s is opaque RGB, using PNG_COLOR_TYPE_RGB\n", imageName);
1211             break;
1212         case PNG_COLOR_TYPE_RGB_ALPHA:
1213             printf("Image %s is RGB + alpha, using PNG_COLOR_TYPE_RGB_ALPHA\n", imageName);
1214             break;
1215         }
1216     }
1217
1218     png_set_IHDR(write_ptr, write_info, imageInfo.width, imageInfo.height,
1219                  8, color_type, PNG_INTERLACE_NONE,
1220                  PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
1221
1222     if (color_type == PNG_COLOR_TYPE_PALETTE) {
1223         png_set_PLTE(write_ptr, write_info, rgbPalette, paletteEntries);
1224         if (hasTransparency) {
1225             png_set_tRNS(write_ptr, write_info, alphaPalette, alphaPaletteEntries,
1226                     (png_color_16p) 0);
1227         }
1228        png_set_filter(write_ptr, 0, PNG_NO_FILTERS);
1229     } else {
1230        png_set_filter(write_ptr, 0, PNG_ALL_FILTERS);
1231     }
1232
1233     if (imageInfo.is9Patch) {
1234         int chunk_count = 2 + (imageInfo.haveLayoutBounds ? 1 : 0);
1235         int p_index = imageInfo.haveLayoutBounds ? 2 : 1;
1236         int b_index = 1;
1237         int o_index = 0;
1238
1239         // Chunks ordered thusly because older platforms depend on the base 9 patch data being last
1240         png_byte *chunk_names = imageInfo.haveLayoutBounds
1241                 ? (png_byte*)"npOl\0npLb\0npTc\0"
1242                 : (png_byte*)"npOl\0npTc";
1243
1244         // base 9 patch data
1245         if (kIsDebug) {
1246             printf("Adding 9-patch info...\n");
1247         }
1248         strcpy((char*)unknowns[p_index].name, "npTc");
1249         unknowns[p_index].data = (png_byte*)imageInfo.serialize9patch();
1250         unknowns[p_index].size = imageInfo.info9Patch.serializedSize();
1251         // TODO: remove the check below when everything works
1252         checkNinePatchSerialization(&imageInfo.info9Patch, unknowns[p_index].data);
1253
1254         // automatically generated 9 patch outline data
1255         int chunk_size = sizeof(png_uint_32) * 6;
1256         strcpy((char*)unknowns[o_index].name, "npOl");
1257         unknowns[o_index].data = (png_byte*) calloc(chunk_size, 1);
1258         png_byte outputData[chunk_size];
1259         memcpy(&outputData, &imageInfo.outlineInsetsLeft, 4 * sizeof(png_uint_32));
1260         ((float*) outputData)[4] = imageInfo.outlineRadius;
1261         ((png_uint_32*) outputData)[5] = imageInfo.outlineAlpha;
1262         memcpy(unknowns[o_index].data, &outputData, chunk_size);
1263         unknowns[o_index].size = chunk_size;
1264
1265         // optional optical inset / layout bounds data
1266         if (imageInfo.haveLayoutBounds) {
1267             int chunk_size = sizeof(png_uint_32) * 4;
1268             strcpy((char*)unknowns[b_index].name, "npLb");
1269             unknowns[b_index].data = (png_byte*) calloc(chunk_size, 1);
1270             memcpy(unknowns[b_index].data, &imageInfo.layoutBoundsLeft, chunk_size);
1271             unknowns[b_index].size = chunk_size;
1272         }
1273
1274         for (int i = 0; i < chunk_count; i++) {
1275             unknowns[i].location = PNG_HAVE_IHDR;
1276         }
1277         png_set_keep_unknown_chunks(write_ptr, PNG_HANDLE_CHUNK_ALWAYS,
1278                                     chunk_names, chunk_count);
1279         png_set_unknown_chunks(write_ptr, write_info, unknowns, chunk_count);
1280     }
1281
1282
1283     png_write_info(write_ptr, write_info);
1284
1285     png_bytepp rows;
1286     if (color_type == PNG_COLOR_TYPE_RGB || color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
1287         if (color_type == PNG_COLOR_TYPE_RGB) {
1288             png_set_filler(write_ptr, 0, PNG_FILLER_AFTER);
1289         }
1290         rows = imageInfo.rows;
1291     } else {
1292         rows = outRows;
1293     }
1294     png_write_image(write_ptr, rows);
1295
1296     if (kIsDebug) {
1297         printf("Final image data:\n");
1298         dump_image(imageInfo.width, imageInfo.height, rows, color_type);
1299     }
1300
1301     png_write_end(write_ptr, write_info);
1302
1303     for (i = 0; i < (int) imageInfo.height; i++) {
1304         free(outRows[i]);
1305     }
1306     free(outRows);
1307     free(unknowns[0].data);
1308     free(unknowns[1].data);
1309     free(unknowns[2].data);
1310
1311     png_get_IHDR(write_ptr, write_info, &width, &height,
1312        &bit_depth, &color_type, &interlace_type,
1313        &compression_type, NULL);
1314
1315     if (kIsDebug) {
1316         printf("Image written: w=%d, h=%d, d=%d, colors=%d, inter=%d, comp=%d\n",
1317                 (int)width, (int)height, bit_depth, color_type, interlace_type,
1318                 compression_type);
1319     }
1320 }
1321
1322 static bool read_png_protected(png_structp read_ptr, String8& printableName, png_infop read_info,
1323                                const sp<AaptFile>& file, FILE* fp, image_info* imageInfo) {
1324     if (setjmp(png_jmpbuf(read_ptr))) {
1325         return false;
1326     }
1327
1328     png_init_io(read_ptr, fp);
1329
1330     read_png(printableName.string(), read_ptr, read_info, imageInfo);
1331
1332     const size_t nameLen = file->getPath().length();
1333     if (nameLen > 6) {
1334         const char* name = file->getPath().string();
1335         if (name[nameLen-5] == '9' && name[nameLen-6] == '.') {
1336             if (do_9patch(printableName.string(), imageInfo) != NO_ERROR) {
1337                 return false;
1338             }
1339         }
1340     }
1341
1342     return true;
1343 }
1344
1345 static bool write_png_protected(png_structp write_ptr, String8& printableName, png_infop write_info,
1346                                 image_info* imageInfo, const Bundle* bundle) {
1347     if (setjmp(png_jmpbuf(write_ptr))) {
1348         return false;
1349     }
1350
1351     write_png(printableName.string(), write_ptr, write_info, *imageInfo, bundle);
1352
1353     return true;
1354 }
1355
1356 status_t preProcessImage(const Bundle* bundle, const sp<AaptAssets>& /* assets */,
1357                          const sp<AaptFile>& file, String8* /* outNewLeafName */)
1358 {
1359     String8 ext(file->getPath().getPathExtension());
1360
1361     // We currently only process PNG images.
1362     if (strcmp(ext.string(), ".png") != 0) {
1363         return NO_ERROR;
1364     }
1365
1366     // Example of renaming a file:
1367     //*outNewLeafName = file->getPath().getBasePath().getFileName();
1368     //outNewLeafName->append(".nupng");
1369
1370     String8 printableName(file->getPrintableSource());
1371
1372     if (bundle->getVerbose()) {
1373         printf("Processing image: %s\n", printableName.string());
1374     }
1375
1376     png_structp read_ptr = NULL;
1377     png_infop read_info = NULL;
1378     FILE* fp;
1379
1380     image_info imageInfo;
1381
1382     png_structp write_ptr = NULL;
1383     png_infop write_info = NULL;
1384
1385     status_t error = UNKNOWN_ERROR;
1386
1387     fp = fopen(file->getSourceFile().string(), "rb");
1388     if (fp == NULL) {
1389         fprintf(stderr, "%s: ERROR: Unable to open PNG file\n", printableName.string());
1390         goto bail;
1391     }
1392
1393     read_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, (png_error_ptr)NULL,
1394                                         (png_error_ptr)NULL);
1395     if (!read_ptr) {
1396         goto bail;
1397     }
1398
1399     read_info = png_create_info_struct(read_ptr);
1400     if (!read_info) {
1401         goto bail;
1402     }
1403
1404     if (!read_png_protected(read_ptr, printableName, read_info, file, fp, &imageInfo)) {
1405         goto bail;
1406     }
1407
1408     write_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, (png_error_ptr)NULL,
1409                                         (png_error_ptr)NULL);
1410     if (!write_ptr)
1411     {
1412         goto bail;
1413     }
1414
1415     write_info = png_create_info_struct(write_ptr);
1416     if (!write_info)
1417     {
1418         goto bail;
1419     }
1420
1421     png_set_write_fn(write_ptr, (void*)file.get(),
1422                      png_write_aapt_file, png_flush_aapt_file);
1423
1424     if (!write_png_protected(write_ptr, printableName, write_info, &imageInfo, bundle)) {
1425         goto bail;
1426     }
1427
1428     error = NO_ERROR;
1429
1430     if (bundle->getVerbose()) {
1431         fseek(fp, 0, SEEK_END);
1432         size_t oldSize = (size_t)ftell(fp);
1433         size_t newSize = file->getSize();
1434         float factor = ((float)newSize)/oldSize;
1435         int percent = (int)(factor*100);
1436         printf("    (processed image %s: %d%% size of source)\n", printableName.string(), percent);
1437     }
1438
1439 bail:
1440     if (read_ptr) {
1441         png_destroy_read_struct(&read_ptr, &read_info, (png_infopp)NULL);
1442     }
1443     if (fp) {
1444         fclose(fp);
1445     }
1446     if (write_ptr) {
1447         png_destroy_write_struct(&write_ptr, &write_info);
1448     }
1449
1450     if (error != NO_ERROR) {
1451         fprintf(stderr, "ERROR: Failure processing PNG image %s\n",
1452                 file->getPrintableSource().string());
1453     }
1454     return error;
1455 }
1456
1457 status_t preProcessImageToCache(const Bundle* bundle, const String8& source, const String8& dest)
1458 {
1459     png_structp read_ptr = NULL;
1460     png_infop read_info = NULL;
1461
1462     FILE* fp;
1463
1464     image_info imageInfo;
1465
1466     png_structp write_ptr = NULL;
1467     png_infop write_info = NULL;
1468
1469     status_t error = UNKNOWN_ERROR;
1470
1471     if (bundle->getVerbose()) {
1472         printf("Processing image to cache: %s => %s\n", source.string(), dest.string());
1473     }
1474
1475     // Get a file handler to read from
1476     fp = fopen(source.string(),"rb");
1477     if (fp == NULL) {
1478         fprintf(stderr, "%s ERROR: Unable to open PNG file\n", source.string());
1479         return error;
1480     }
1481
1482     // Call libpng to get a struct to read image data into
1483     read_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
1484     if (!read_ptr) {
1485         fclose(fp);
1486         png_destroy_read_struct(&read_ptr, &read_info,NULL);
1487         return error;
1488     }
1489
1490     // Call libpng to get a struct to read image info into
1491     read_info = png_create_info_struct(read_ptr);
1492     if (!read_info) {
1493         fclose(fp);
1494         png_destroy_read_struct(&read_ptr, &read_info,NULL);
1495         return error;
1496     }
1497
1498     // Set a jump point for libpng to long jump back to on error
1499     if (setjmp(png_jmpbuf(read_ptr))) {
1500         fclose(fp);
1501         png_destroy_read_struct(&read_ptr, &read_info,NULL);
1502         return error;
1503     }
1504
1505     // Set up libpng to read from our file.
1506     png_init_io(read_ptr,fp);
1507
1508     // Actually read data from the file
1509     read_png(source.string(), read_ptr, read_info, &imageInfo);
1510
1511     // We're done reading so we can clean up
1512     // Find old file size before releasing handle
1513     fseek(fp, 0, SEEK_END);
1514     size_t oldSize = (size_t)ftell(fp);
1515     fclose(fp);
1516     png_destroy_read_struct(&read_ptr, &read_info,NULL);
1517
1518     // Check to see if we're dealing with a 9-patch
1519     // If we are, process appropriately
1520     if (source.getBasePath().getPathExtension() == ".9")  {
1521         if (do_9patch(source.string(), &imageInfo) != NO_ERROR) {
1522             return error;
1523         }
1524     }
1525
1526     // Call libpng to create a structure to hold the processed image data
1527     // that can be written to disk
1528     write_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
1529     if (!write_ptr) {
1530         png_destroy_write_struct(&write_ptr, &write_info);
1531         return error;
1532     }
1533
1534     // Call libpng to create a structure to hold processed image info that can
1535     // be written to disk
1536     write_info = png_create_info_struct(write_ptr);
1537     if (!write_info) {
1538         png_destroy_write_struct(&write_ptr, &write_info);
1539         return error;
1540     }
1541
1542     // Open up our destination file for writing
1543     fp = fopen(dest.string(), "wb");
1544     if (!fp) {
1545         fprintf(stderr, "%s ERROR: Unable to open PNG file\n", dest.string());
1546         png_destroy_write_struct(&write_ptr, &write_info);
1547         return error;
1548     }
1549
1550     // Set up libpng to write to our file
1551     png_init_io(write_ptr, fp);
1552
1553     // Set up a jump for libpng to long jump back on on errors
1554     if (setjmp(png_jmpbuf(write_ptr))) {
1555         fclose(fp);
1556         png_destroy_write_struct(&write_ptr, &write_info);
1557         return error;
1558     }
1559
1560     // Actually write out to the new png
1561     write_png(dest.string(), write_ptr, write_info, imageInfo, bundle);
1562
1563     if (bundle->getVerbose()) {
1564         // Find the size of our new file
1565         FILE* reader = fopen(dest.string(), "rb");
1566         fseek(reader, 0, SEEK_END);
1567         size_t newSize = (size_t)ftell(reader);
1568         fclose(reader);
1569
1570         float factor = ((float)newSize)/oldSize;
1571         int percent = (int)(factor*100);
1572         printf("  (processed image to cache entry %s: %d%% size of source)\n",
1573                dest.string(), percent);
1574     }
1575
1576     //Clean up
1577     fclose(fp);
1578     png_destroy_write_struct(&write_ptr, &write_info);
1579
1580     return NO_ERROR;
1581 }
1582
1583 status_t postProcessImage(const Bundle* bundle, const sp<AaptAssets>& assets,
1584                           ResourceTable* table, const sp<AaptFile>& file)
1585 {
1586     String8 ext(file->getPath().getPathExtension());
1587
1588     // At this point, now that we have all the resource data, all we need to
1589     // do is compile XML files.
1590     if (strcmp(ext.string(), ".xml") == 0) {
1591         String16 resourceName(parseResourceName(file->getSourceFile().getPathLeaf()));
1592         return compileXmlFile(bundle, assets, resourceName, file, table);
1593     }
1594
1595     return NO_ERROR;
1596 }