blob: 4cc020290245f94c82b05404d0ca0b3046c035c2 [file] [log] [blame]
// 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;
}