tools/etc1tool/etc1tool.cpp - platform/development - Git at Google

 // Copyright 2009 Google Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include <errno.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 #include <png.h>
 #include <ETC1/etc1.h>


 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;
     png_uint_32 stride = 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);
     }

     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;
 }
	// Copyright 2009 Google Inc.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include <errno.h>
	#include <stdarg.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	#include <png.h>
	#include <ETC1/etc1.h>


	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;
	png_uint_32 stride = 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);
	}

	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;
	}