diff --git a/samples/ApiDemos/AndroidManifest.xml b/samples/ApiDemos/AndroidManifest.xml
index 4dbf13683..b0cda301f 100644
--- a/samples/ApiDemos/AndroidManifest.xml
+++ b/samples/ApiDemos/AndroidManifest.xml
@@ -1405,7 +1405,17 @@
-
+
+
+
+
+
+
+
+
+#include
+#include
+#include
+#include
+
+#include
+#include
+
+
+int writePNGFile(const char* pOutput, png_uint_32 width, png_uint_32 height,
+ const png_bytep pImageData, png_uint_32 imageStride);
+
+const char* gpExeName;
+
+static
+void usage(char* message, ...) {
+ if (message) {
+ va_list ap;
+ va_start(ap, message);
+ vfprintf(stderr, message, ap);
+ va_end(ap);
+ fprintf(stderr, "\n\n");
+ fprintf(stderr, "usage:\n");
+ }
+ fprintf(
+ stderr,
+ "%s infile [--help | --encode | --encodeNoHeader | --decode] [--showDifference difffile] [-o outfile]\n",
+ gpExeName);
+ fprintf(stderr, "\tDefault is --encode\n");
+ fprintf(stderr, "\t\t--help print this usage information.\n");
+ fprintf(stderr,
+ "\t\t--encode create an ETC1 file from a PNG file.\n");
+ fprintf(
+ stderr,
+ "\t\t--encodeNoHeader create a raw ETC1 data file (without a header) from a PNG file.\n");
+ fprintf(stderr,
+ "\t\t--decode create a PNG file from an ETC1 file.\n");
+ fprintf(stderr,
+ "\t\t--showDifference difffile Write difference between original and encoded\n");
+ fprintf(stderr,
+ "\t\t image to difffile. (Only valid when encoding).\n");
+ fprintf(stderr,
+ "\tIf outfile is not specified, an outfile path is constructed from infile,\n");
+ fprintf(stderr, "\twith the apropriate suffix (.pkm or .png).\n");
+ exit(1);
+}
+
+// Returns non-zero if an error occured
+
+static
+int changeExtension(char* pPath, size_t pathCapacity, const char* pExtension) {
+ size_t pathLen = strlen(pPath);
+ size_t extensionLen = strlen(pExtension);
+ if (pathLen + extensionLen + 1 > pathCapacity) {
+ return -1;
+ }
+
+ // Check for '.' and '..'
+ if ((pathLen == 1 && pPath[0] == '.') || (pathLen == 2 && pPath[0] == '.'
+ && pPath[1] == '.') || (pathLen >= 2 && pPath[pathLen - 2] == '/'
+ && pPath[pathLen - 1] == '.') || (pathLen >= 3
+ && pPath[pathLen - 3] == '/' && pPath[pathLen - 2] == '.'
+ && pPath[pathLen - 1] == '.')) {
+ return -2;
+ }
+
+ int index;
+ for (index = pathLen - 1; index > 0; index--) {
+ char c = pPath[index];
+ if (c == '/') {
+ // No extension found. Append our extension.
+ strcpy(pPath + pathLen, pExtension);
+ return 0;
+ } else if (c == '.') {
+ strcpy(pPath + index, pExtension);
+ return 0;
+ }
+ }
+
+ // No extension or directory found. Append our extension
+ strcpy(pPath + pathLen, pExtension);
+ return 0;
+}
+
+void PNGAPI user_error_fn(png_structp png_ptr, png_const_charp message) {
+ fprintf(stderr, "PNG error: %s\n", message);
+}
+
+void PNGAPI user_warning_fn(png_structp png_ptr, png_const_charp message) {
+ fprintf(stderr, "PNG warning: %s\n", message);
+}
+
+// Return non-zero on error
+int fwrite_big_endian_uint16(png_uint_32 data, FILE* pOut) {
+ if (fputc(0xff & (data >> 8), pOut) == EOF) {
+ return -1;
+ }
+ if (fputc(0xff & data, pOut) == EOF) {
+ return -1;
+ }
+ return 0;
+}
+
+// Return non-zero on error
+int fread_big_endian_uint16(png_uint_32* data, FILE* pIn) {
+ int a, b;
+ if ((a = fgetc(pIn)) == EOF) {
+ return -1;
+ }
+ if ((b = fgetc(pIn)) == EOF) {
+ return -1;
+ }
+ *data = ((0xff & a) << 8) | (0xff & b);
+ return 0;
+}
+
+// Read a PNG file into a contiguous buffer.
+// Returns non-zero if an error occurred.
+// caller has to delete[] *ppImageData when done with the image.
+
+int read_PNG_File(const char* pInput, etc1_byte** ppImageData,
+ etc1_uint32* pWidth, etc1_uint32* pHeight) {
+ FILE* pIn = NULL;
+ png_structp png_ptr = NULL;
+ png_infop info_ptr = NULL;
+ png_infop end_info = NULL;
+ png_bytep* row_pointers = NULL; // Does not need to be deallocated.
+ png_uint_32 width = 0;
+ png_uint_32 height = 0;
+ int result = -1;
+ etc1_byte* pSourceImage = 0;
+
+ if ((pIn = fopen(pInput, "rb")) == NULL) {
+ fprintf(stderr, "Could not open input file %s for reading: %d\n",
+ pInput, errno);
+ goto exit;
+ }
+
+ static const size_t PNG_HEADER_SIZE = 8;
+ png_byte pngHeader[PNG_HEADER_SIZE];
+ if (fread(pngHeader, 1, PNG_HEADER_SIZE, pIn) != PNG_HEADER_SIZE) {
+ fprintf(stderr, "Could not read PNG header from %s: %d\n", pInput,
+ errno);
+ goto exit;
+ }
+
+ if (png_sig_cmp(pngHeader, 0, PNG_HEADER_SIZE)) {
+ fprintf(stderr, "%s is not a PNG file.\n", pInput);
+ goto exit;
+ }
+
+ if (!(png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
+ (png_voidp) NULL, user_error_fn, user_warning_fn))) {
+ fprintf(stderr, "Could not initialize png read struct.\n");
+ goto exit;
+ }
+
+ if (!(info_ptr = png_create_info_struct(png_ptr))) {
+ fprintf(stderr, "Could not create info struct.\n");
+ goto exit;
+ }
+ if (!(end_info = png_create_info_struct(png_ptr))) {
+ fprintf(stderr, "Could not create end_info struct.\n");
+ goto exit;
+ }
+
+ if (setjmp(png_jmpbuf(png_ptr))) {
+ goto exit;
+ }
+
+ png_init_io(png_ptr, pIn);
+ png_set_sig_bytes(png_ptr, PNG_HEADER_SIZE);
+ png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY
+ | PNG_TRANSFORM_STRIP_16 | PNG_TRANSFORM_STRIP_ALPHA
+ | PNG_TRANSFORM_PACKING, NULL);
+
+ row_pointers = png_get_rows(png_ptr, info_ptr);
+ {
+ int bit_depth, color_type;
+ png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth,
+ &color_type, NULL, NULL, NULL);
+ }
+
+ png_uint_32 stride = 3 * width;
+
+ pSourceImage = new etc1_byte[stride * height];
+ if (! pSourceImage) {
+ fprintf(stderr, "Out of memory.\n");
+ goto exit;
+ }
+
+ for (etc1_uint32 y = 0; y < height; y++) {
+ memcpy(pSourceImage + y * stride, row_pointers[y], stride);
+ }
+
+ *pWidth = width;
+ *pHeight = height;
+ *ppImageData = pSourceImage;
+
+ result = 0;
+ exit:
+ if (result) {
+ delete[] pSourceImage;
+ }
+ if (png_ptr) {
+ png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
+ }
+ if (pIn) {
+ fclose(pIn);
+ }
+
+ return result;
+}
+
+// Read a PNG file into a contiguous buffer.
+// Returns non-zero if an error occurred.
+// caller has to delete[] *ppImageData when done with the image.
+int readPKMFile(const char* pInput, etc1_byte** ppImageData,
+ etc1_uint32* pWidth, etc1_uint32* pHeight) {
+ int result = -1;
+ FILE* pIn = NULL;
+ etc1_byte header[ETC_PKM_HEADER_SIZE];
+ png_bytep pEncodedData = NULL;
+ png_bytep pImageData = NULL;
+
+ png_uint_32 width = 0;
+ png_uint_32 height = 0;
+ png_uint_32 stride = 0;
+ png_uint_32 encodedSize = 0;
+
+ if ((pIn = fopen(pInput, "rb")) == NULL) {
+ fprintf(stderr, "Could not open input file %s for reading: %d\n",
+ pInput, errno);
+ goto exit;
+ }
+
+ if (fread(header, sizeof(header), 1, pIn) != 1) {
+ fprintf(stderr, "Could not read header from input file %s: %d\n",
+ pInput, errno);
+ goto exit;
+ }
+
+ if (! etc1_pkm_is_valid(header)) {
+ fprintf(stderr, "Bad header PKM header for input file %s\n", pInput);
+ goto exit;
+ }
+
+ width = etc1_pkm_get_width(header);
+ height = etc1_pkm_get_height(header);
+ encodedSize = etc1_get_encoded_data_size(width, height);
+
+ pEncodedData = new png_byte[encodedSize];
+ if (!pEncodedData) {
+ fprintf(stderr, "Out of memory.\n");
+ goto exit;
+ }
+
+ if (fread(pEncodedData, encodedSize, 1, pIn) != 1) {
+ fprintf(stderr, "Could not read encoded data from input file %s: %d\n",
+ pInput, errno);
+ goto exit;
+ }
+
+ fclose(pIn);
+ pIn = NULL;
+
+ stride = width * 3;
+ pImageData = new png_byte[stride * height];
+ if (!pImageData) {
+ fprintf(stderr, "Out of memory.\n");
+ goto exit;
+ }
+
+ etc1_decode_image(pEncodedData, pImageData, width, height, 3, stride);
+
+ // Success
+ result = 0;
+ *ppImageData = pImageData;
+ pImageData = 0;
+ *pWidth = width;
+ *pHeight = height;
+
+ exit:
+ delete[] pEncodedData;
+ delete[] pImageData;
+ if (pIn) {
+ fclose(pIn);
+ }
+
+ return result;
+}
+
+
+// Encode the file.
+// Returns non-zero if an error occurred.
+
+int encode(const char* pInput, const char* pOutput, bool bEmitHeader, const char* pDiffFile) {
+ FILE* pOut = NULL;
+ etc1_uint32 width = 0;
+ etc1_uint32 height = 0;
+ etc1_uint32 encodedSize = 0;
+ int result = -1;
+ etc1_byte* pSourceImage = 0;
+ etc1_byte* pEncodedData = 0;
+ etc1_byte* pDiffImage = 0; // Used for differencing
+
+ if (read_PNG_File(pInput, &pSourceImage, &width, &height)) {
+ goto exit;
+ }
+
+ encodedSize = etc1_get_encoded_data_size(width, height);
+ pEncodedData = new etc1_byte[encodedSize];
+ if (!pEncodedData) {
+ fprintf(stderr, "Out of memory.\n");
+ goto exit;
+ }
+
+ etc1_encode_image(pSourceImage,
+ width, height, 3, width * 3, pEncodedData);
+
+ if ((pOut = fopen(pOutput, "wb")) == NULL) {
+ fprintf(stderr, "Could not open output file %s: %d\n", pOutput, errno);
+ goto exit;
+ }
+
+ if (bEmitHeader) {
+ etc1_byte header[ETC_PKM_HEADER_SIZE];
+ etc1_pkm_format_header(header, width, height);
+ if (fwrite(header, sizeof(header), 1, pOut) != 1) {
+ fprintf(stderr,
+ "Could not write header output file %s: %d\n",
+ pOutput, errno);
+ goto exit;
+ }
+ }
+
+ if (fwrite(pEncodedData, encodedSize, 1, pOut) != 1) {
+ fprintf(stderr,
+ "Could not write encoded data to output file %s: %d\n",
+ pOutput, errno);
+ goto exit;
+ }
+
+ fclose(pOut);
+ pOut = NULL;
+
+ if (pDiffFile) {
+ etc1_uint32 outWidth;
+ etc1_uint32 outHeight;
+ if (readPKMFile(pOutput, &pDiffImage, &outWidth, &outHeight)) {
+ goto exit;
+ }
+ if (outWidth != width || outHeight != height) {
+ fprintf(stderr, "Output file has incorrect bounds: %u, %u != %u, %u\n",
+ outWidth, outHeight, width, height);
+ goto exit;
+ }
+ const etc1_byte* pSrc = pSourceImage;
+ etc1_byte* pDest = pDiffImage;
+ etc1_uint32 size = width * height * 3;
+ for (etc1_uint32 i = 0; i < size; i++) {
+ int diff = *pSrc++ - *pDest;
+ diff *= diff;
+ diff <<= 3;
+ if (diff < 0) {
+ diff = 0;
+ } else if (diff > 255) {
+ diff = 255;
+ }
+ *pDest++ = (png_byte) diff;
+ }
+ writePNGFile(pDiffFile, outWidth, outHeight, pDiffImage, 3 * outWidth);
+ }
+
+ // Success
+ result = 0;
+
+ exit:
+ delete[] pSourceImage;
+ delete[] pEncodedData;
+ delete[] pDiffImage;
+
+ if (pOut) {
+ fclose(pOut);
+ }
+ return result;
+}
+
+int writePNGFile(const char* pOutput, png_uint_32 width, png_uint_32 height,
+ const png_bytep pImageData, png_uint_32 imageStride) {
+ int result = -1;
+ FILE* pOut = NULL;
+ png_structp png_ptr = NULL;
+ png_infop info_ptr = NULL;
+
+ if (!(png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
+ (png_voidp) NULL, user_error_fn, user_warning_fn)) || !(info_ptr
+ = png_create_info_struct(png_ptr))) {
+ fprintf(stderr, "Could not initialize PNG library for writing.\n");
+ goto exit;
+ }
+
+ if (setjmp(png_jmpbuf(png_ptr))) {
+ goto exit;
+ }
+
+ if ((pOut = fopen(pOutput, "wb")) == NULL) {
+ fprintf(stderr, "Could not open output file %s: %d\n", pOutput, errno);
+ goto exit;
+ }
+
+ png_init_io(png_ptr, pOut);
+
+ png_set_IHDR(png_ptr, info_ptr, width, height, 8, PNG_COLOR_TYPE_RGB,
+ PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
+ PNG_FILTER_TYPE_DEFAULT);
+
+ png_write_info(png_ptr, info_ptr);
+
+ for (png_uint_32 y = 0; y < height; y++) {
+ png_write_row(png_ptr, pImageData + y * imageStride);
+ }
+ png_write_end(png_ptr, info_ptr);
+
+ result = 0;
+
+ exit: if (png_ptr) {
+ png_destroy_write_struct(&png_ptr, &info_ptr);
+ }
+
+ if (pOut) {
+ fclose(pOut);
+ }
+ return result;
+}
+
+int decode(const char* pInput, const char* pOutput) {
+ int result = -1;
+ png_bytep pImageData = NULL;
+ etc1_uint32 width = 0;
+ etc1_uint32 height = 0;
+
+ if (readPKMFile(pInput, &pImageData, &width, &height)) {
+ goto exit;
+ }
+
+ if (writePNGFile(pOutput, width, height, pImageData, width * 3)) {
+ goto exit;
+ }
+
+ // Success
+ result = 0;
+
+ exit: delete[] pImageData;
+
+ return result;
+}
+
+void multipleEncodeDecodeCheck(bool* pbEncodeDecodeSeen) {
+ if (*pbEncodeDecodeSeen) {
+ usage("At most one occurrence of --encode --encodeNoHeader or --decode is allowed.\n");
+ }
+ *pbEncodeDecodeSeen = true;
+}
+
+int main(int argc, char** argv) {
+ gpExeName = argv[0];
+ const char* pInput = NULL;
+ const char* pOutput = NULL;
+ const char* pDiffFile = NULL;
+ char* pOutputFileBuff = NULL;
+
+ bool bEncodeDecodeSeen = false;
+ bool bEncode = false;
+ bool bEncodeHeader = false;
+ bool bDecode = false;
+ bool bShowDifference = false;
+
+ for (int i = 1; i < argc; i++) {
+ const char* pArg = argv[i];
+ if (pArg[0] == '-') {
+ char c = pArg[1];
+ switch (c) {
+ case 'o':
+ if (pOutput != NULL) {
+ usage("Only one -o flag allowed.");
+ }
+ if (i + 1 >= argc) {
+ usage("Expected outfile after -o");
+ }
+ pOutput = argv[++i];
+ break;
+ case '-':
+ if (strcmp(pArg, "--encode") == 0) {
+ multipleEncodeDecodeCheck(&bEncodeDecodeSeen);
+ bEncode = true;
+ bEncodeHeader = true;
+ } else if (strcmp(pArg, "--encodeNoHeader") == 0) {
+ multipleEncodeDecodeCheck(&bEncodeDecodeSeen);
+ bEncode = true;
+ bEncodeHeader = false;
+ } else if (strcmp(pArg, "--decode") == 0) {
+ multipleEncodeDecodeCheck(&bEncodeDecodeSeen);
+ bDecode = true;
+ } else if (strcmp(pArg, "--showDifference") == 0) {
+ if (bShowDifference) {
+ usage("Only one --showDifference option allowed.\n");
+ }
+ bShowDifference = true;
+ if (i + 1 >= argc) {
+ usage("Expected difffile after --showDifference");
+ }
+ pDiffFile = argv[++i];
+ } else if (strcmp(pArg, "--help") == 0) {
+ usage( NULL);
+ } else {
+ usage("Unknown flag %s", pArg);
+ }
+
+ break;
+ default:
+ usage("Unknown flag %s", pArg);
+ break;
+ }
+ } else {
+ if (pInput != NULL) {
+ usage(
+ "Only one input file allowed. Already have %s, now see %s",
+ pInput, pArg);
+ }
+ pInput = pArg;
+ }
+ }
+
+ if (!bEncodeDecodeSeen) {
+ bEncode = true;
+ bEncodeHeader = true;
+ }
+ if ((! bEncode) && bShowDifference) {
+ usage("--showDifference is only valid when encoding.");
+ }
+
+ if (!pInput) {
+ usage("Expected an input file.");
+ }
+
+ if (!pOutput) {
+ const char* kDefaultExtension = bEncode ? ".pkm" : ".png";
+ size_t buffSize = strlen(pInput) + strlen(kDefaultExtension) + 1;
+ pOutputFileBuff = new char[buffSize];
+ strcpy(pOutputFileBuff, pInput);
+ if (changeExtension(pOutputFileBuff, buffSize, kDefaultExtension)) {
+ usage("Could not change extension of input file name: %s\n", pInput);
+ }
+ pOutput = pOutputFileBuff;
+ }
+
+ if (bEncode) {
+ encode(pInput, pOutput, bEncodeHeader, pDiffFile);
+ } else {
+ decode(pInput, pOutput);
+ }
+
+ delete[] pOutputFileBuff;
+
+ return 0;
+}