tools/mac/icons/additional_tools/unmakeicns.cc - chromium/src - Git at Google

 // Copyright 2015 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include <arpa/inet.h>
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <unistd.h>

 #include <string>

 #include "makepng.h"
 #include "unpackicon.h"

 #define arraysize(x) (sizeof(x) / sizeof(x[0]))

 namespace {

 struct IconType {
   uint32_t magic;
   const char* filename;
 };

 // clang-format off
 const IconType icon_types[] = {
   { 'icp4', "16x16" },
   { 'icp5', "32x32" },
   { 'icp6', "64x64" },
   { 'ic07', "128x128" },
   { 'ic08', "256x256" },
   { 'ic09', "512x512" },
   { 'ic10', "512x512@2x" },  // previously 1024x1024
   { 'ic11', "16x16@2x" },
   { 'ic12', "32x32@2x" },
   { 'ic13', "128x128@2x" },
   { 'ic14', "256x256@2x" },
 };
 // clang-format on

 struct IcnsHeader {
   uint32_t magic;
   uint32_t length;
 };

 struct IconHeader {
   uint32_t magic;
   uint32_t length;
 };

 bool IsPrintableASCIINoSlash(char c) {
   return c >= ' ' && c <= '~' && c != '/';
 }

 std::string FourCCToASCII(uint32_t fourcc) {
   const char chars[] = {
       fourcc >> 24,
       (fourcc >> 16) & 0xff,
       (fourcc >> 8) & 0xff,
       fourcc & 0xff,
   };

   bool use_ascii = true;
   for (size_t i = 0; i < arraysize(chars); ++i) {
     if (!IsPrintableASCIINoSlash(chars[i])) {
       use_ascii = false;
       break;
     }
   }

   char buf[11];
   if (use_ascii) {
     snprintf(buf, sizeof(buf), "%c%c%c%c", chars[0], chars[1], chars[2],
              chars[3]);
   } else {
     snprintf(buf, sizeof(buf), "0x%x", fourcc);
   }

   return std::string(buf);
 }

 }  // namespace

 int main(int argc, char* argv[]) {
   const char* me = argv[0];

   if (argc != 3) {
     fprintf(stderr, "usage: %s <icns> <iconset>\n", me);
     return EXIT_FAILURE;
   }

   const char* input_path = argv[1];
   int input_fd = open(input_path, O_RDONLY);
   if (input_fd < 0) {
     fprintf(stderr, "%s: open %s: %s\n", me, input_path, strerror(errno));
     return EXIT_FAILURE;
   }

   const char* output_path = argv[2];
   if (mkdir(output_path, 0755) != 0 && errno != EEXIST) {
     fprintf(stderr, "%s: mkdir %s: %s\n", me, output_path, strerror(errno));
     return EXIT_FAILURE;
   }

   size_t total_read = 0;
   IcnsHeader icns_header;
   ssize_t nread = read(input_fd, &icns_header, sizeof(icns_header));
   if (nread < 0) {
     fprintf(stderr, "%s: read: %s\n", me, strerror(errno));
     return EXIT_FAILURE;
   } else if (nread != sizeof(icns_header)) {
     fprintf(stderr, "%s: read: expected %zu, observed %zd\n", me,
             sizeof(icns_header), nread);
     return EXIT_FAILURE;
   }
   total_read += nread;

   const uint32_t icns_header_magic = ntohl(icns_header.magic);
   if (icns_header_magic != 'icns') {
     fprintf(stderr, "%s: icns file magic: expected 0x%x, observed 0x%x\n", me,
             'icns', icns_header_magic);
     return EXIT_FAILURE;
   }

   const uint32_t icns_header_length = ntohl(icns_header.length);

   struct ImageAndMask {
     std::string image_path;
     std::string mask_path;
     std::string png_path;
   };
   ImageAndMask images_and_masks[4];
   enum ImageAndMaskIndex {
     IMAGE_16,
     IMAGE_32,
     IMAGE_48,
     IMAGE_128,
     IMAGE_NONE,
   };
   const size_t kImageAndMaskDimensions[] = {16, 32, 48, 128};

   while (total_read < icns_header_length) {
     IconHeader icon_header;
     nread = read(input_fd, &icon_header, sizeof(icon_header));
     if (nread < 0) {
       fprintf(stderr, "%s: read: %s\n", me, strerror(errno));
       return EXIT_FAILURE;
     } else if (nread != sizeof(icon_header)) {
       fprintf(stderr, "%s: read: expected %zd, observed %zu\n", me,
               sizeof(icon_header), nread);
       return EXIT_FAILURE;
     }
     total_read += nread;

     size_t icon_length = ntohl(icon_header.length) - sizeof(icon_header);
     char* icon_data = reinterpret_cast<char*>(malloc(icon_length));
     if (!icon_data) {
       fprintf(stderr, "%s: malloc %zu: %s\n", me, icon_length, strerror(errno));
       return EXIT_FAILURE;
     }

     size_t icon_data_read = 0;
     while (icon_length - icon_data_read > 0) {
       nread = read(input_fd, icon_data + icon_data_read,
                    icon_length - icon_data_read);
       if (nread < 0) {
         fprintf(stderr, "%s: read: %s\n", me, strerror(errno));
         return EXIT_FAILURE;
       } else if (nread > icon_length - icon_data_read) {
         fprintf(stderr, "%s: read: expected %zu, observed %zd\n", me,
                 icon_length - icon_data_read, nread);
         return EXIT_FAILURE;
       }
       icon_data_read += nread;
     }
     total_read += icon_data_read;

     const uint32_t icon_header_magic = ntohl(icon_header.magic);
     bool found = false;
     std::string output_icon_path = output_path;
     output_icon_path += '/';
     for (size_t icon_type_index = 0; icon_type_index < arraysize(icon_types);
          ++icon_type_index) {
       const IconType& icon_type = icon_types[icon_type_index];
       if (icon_header_magic == icon_type.magic) {
         found = true;
         output_icon_path += "icon_";
         output_icon_path += icon_type.filename;
         output_icon_path += ".png";
         break;
       }
     }

     if (!found) {
       output_icon_path += FourCCToASCII(icon_header_magic);
     }

     const char* output_icon_path_c = output_icon_path.c_str();
     printf("%s\n", output_icon_path_c);

     int output_fd;
     output_fd = open(output_icon_path_c, O_WRONLY | O_CREAT | O_TRUNC, 0644);
     if (output_fd < 0) {
       fprintf(stderr, "%s: open %s: %s\n", me, output_icon_path_c,
               strerror(errno));
       return EXIT_FAILURE;
     }

     size_t icon_data_written = 0;
     while (icon_length - icon_data_written > 0) {
       ssize_t nwritten = write(output_fd, icon_data + icon_data_written,
                                icon_length - icon_data_written);
       if (nwritten < 0) {
         fprintf(stderr, "%s: write: %s\n", me, strerror(errno));
         return EXIT_FAILURE;
       } else if (nwritten > icon_length - icon_data_written) {
         fprintf(stderr, "%s: write: expected %zu, observed %zd\n", me,
                 icon_length - icon_data_written, nwritten);
         return EXIT_FAILURE;
       }
       icon_data_written += nwritten;
     }

     if (close(output_fd) < 0) {
       fprintf(stderr, "%s: close %s: %s\n", me, output_icon_path_c,
               strerror(errno));
       return EXIT_FAILURE;
     }

     free(icon_data);

     ImageAndMaskIndex index = IMAGE_NONE;
     switch (icon_header_magic) {
       case 'is32':
         index = IMAGE_16;
         break;
       case 'il32':
         index = IMAGE_32;
         break;
       case 'ih32':
         index = IMAGE_48;
         break;
       case 'it32':
         index = IMAGE_128;
         break;
       case 's8mk':
         images_and_masks[IMAGE_16].mask_path = output_icon_path;
         break;
       case 'l8mk':
         images_and_masks[IMAGE_32].mask_path = output_icon_path;
         break;
       case 'h8mk':
         images_and_masks[IMAGE_48].mask_path = output_icon_path;
         break;
       case 't8mk':
         images_and_masks[IMAGE_128].mask_path = output_icon_path;
         break;
     }

     if (index != IMAGE_NONE) {
       images_and_masks[index].image_path = output_icon_path;
       images_and_masks[index].png_path = output_icon_path + ".png";
     }

     if ((icon_header_magic == 'is32' && icon_length != 16 * 16 * 3) ||
         (icon_header_magic == 'il32' && icon_length != 32 * 32 * 3) ||
         (icon_header_magic == 'ih32' && icon_length != 48 * 48 * 3) ||
         (icon_header_magic == 'it32' && icon_length != 128 * 128 * 3)) {
       const std::string output_icon_unpacked_path =
           output_icon_path + ".unpacked";
       const char* output_icon_unpacked_path_c =
           output_icon_unpacked_path.c_str();
       printf("%s\n", output_icon_unpacked_path_c);

       // is32 and il32 definitely don’t use skip. it32 definitely does. I’m not
       // sure about ih32, but I think it doesn’t use skip.
       const bool skip = icon_header_magic == 'it32';

       if (!UnpackIcon(output_icon_path_c, output_icon_unpacked_path_c, skip)) {
         return EXIT_FAILURE;
       }

       assert(index != IMAGE_NONE);
       images_and_masks[index].image_path = output_icon_unpacked_path;
     }
   }

   for (size_t index = 0; index < arraysize(images_and_masks); ++index) {
     const ImageAndMask& image_and_mask = images_and_masks[index];
     if (!image_and_mask.image_path.empty() &&
         !image_and_mask.mask_path.empty()) {
       printf("%s\n", image_and_mask.png_path.c_str());
       if (!EncodePNG(image_and_mask.image_path.c_str(),
                      image_and_mask.mask_path.c_str(),
                      image_and_mask.png_path.c_str(),
                      kImageAndMaskDimensions[index])) {
         return EXIT_FAILURE;
       }
     }
   }

   if (total_read != icns_header_length) {
     fprintf(stderr, "%s: icns file length: expected %d, observed %zu\n", me,
             icns_header_length, total_read);
     return EXIT_FAILURE;
   }

   if (close(input_fd) < 0) {
     fprintf(stderr, "%s: close %s: %s\n", me, input_path, strerror(errno));
     return EXIT_FAILURE;
   }

   return EXIT_SUCCESS;
 }
	// Copyright 2015 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include <arpa/inet.h>
	#include <assert.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/stat.h>
	#include <unistd.h>

	#include <string>

	#include "makepng.h"
	#include "unpackicon.h"

	#define arraysize(x) (sizeof(x) / sizeof(x[0]))

	namespace {

	struct IconType {
	uint32_t magic;
	const char* filename;
	};

	// clang-format off
	const IconType icon_types[] = {
	{ 'icp4', "16x16" },
	{ 'icp5', "32x32" },
	{ 'icp6', "64x64" },
	{ 'ic07', "128x128" },
	{ 'ic08', "256x256" },
	{ 'ic09', "512x512" },
	{ 'ic10', "512x512@2x" }, // previously 1024x1024
	{ 'ic11', "16x16@2x" },
	{ 'ic12', "32x32@2x" },
	{ 'ic13', "128x128@2x" },
	{ 'ic14', "256x256@2x" },
	};
	// clang-format on

	struct IcnsHeader {
	uint32_t magic;
	uint32_t length;
	};

	struct IconHeader {
	uint32_t magic;
	uint32_t length;
	};

	bool IsPrintableASCIINoSlash(char c) {
	return c >= ' ' && c <= '~' && c != '/';
	}

	std::string FourCCToASCII(uint32_t fourcc) {
	const char chars[] = {
	fourcc >> 24,
	(fourcc >> 16) & 0xff,
	(fourcc >> 8) & 0xff,
	fourcc & 0xff,
	};

	bool use_ascii = true;
	for (size_t i = 0; i < arraysize(chars); ++i) {
	if (!IsPrintableASCIINoSlash(chars[i])) {
	use_ascii = false;
	break;
	}
	}

	char buf[11];
	if (use_ascii) {
	snprintf(buf, sizeof(buf), "%c%c%c%c", chars[0], chars[1], chars[2],
	chars[3]);
	} else {
	snprintf(buf, sizeof(buf), "0x%x", fourcc);
	}

	return std::string(buf);
	}

	} // namespace

	int main(int argc, char* argv[]) {
	const char* me = argv[0];

	if (argc != 3) {
	fprintf(stderr, "usage: %s <icns> <iconset>\n", me);
	return EXIT_FAILURE;
	}

	const char* input_path = argv[1];
	int input_fd = open(input_path, O_RDONLY);
	if (input_fd < 0) {
	fprintf(stderr, "%s: open %s: %s\n", me, input_path, strerror(errno));
	return EXIT_FAILURE;
	}

	const char* output_path = argv[2];
	if (mkdir(output_path, 0755) != 0 && errno != EEXIST) {
	fprintf(stderr, "%s: mkdir %s: %s\n", me, output_path, strerror(errno));
	return EXIT_FAILURE;
	}

	size_t total_read = 0;
	IcnsHeader icns_header;
	ssize_t nread = read(input_fd, &icns_header, sizeof(icns_header));
	if (nread < 0) {
	fprintf(stderr, "%s: read: %s\n", me, strerror(errno));
	return EXIT_FAILURE;
	} else if (nread != sizeof(icns_header)) {
	fprintf(stderr, "%s: read: expected %zu, observed %zd\n", me,
	sizeof(icns_header), nread);
	return EXIT_FAILURE;
	}
	total_read += nread;

	const uint32_t icns_header_magic = ntohl(icns_header.magic);
	if (icns_header_magic != 'icns') {
	fprintf(stderr, "%s: icns file magic: expected 0x%x, observed 0x%x\n", me,
	'icns', icns_header_magic);
	return EXIT_FAILURE;
	}

	const uint32_t icns_header_length = ntohl(icns_header.length);

	struct ImageAndMask {
	std::string image_path;
	std::string mask_path;
	std::string png_path;
	};
	ImageAndMask images_and_masks[4];
	enum ImageAndMaskIndex {
	IMAGE_16,
	IMAGE_32,
	IMAGE_48,
	IMAGE_128,
	IMAGE_NONE,
	};
	const size_t kImageAndMaskDimensions[] = {16, 32, 48, 128};

	while (total_read < icns_header_length) {
	IconHeader icon_header;
	nread = read(input_fd, &icon_header, sizeof(icon_header));
	if (nread < 0) {
	fprintf(stderr, "%s: read: %s\n", me, strerror(errno));
	return EXIT_FAILURE;
	} else if (nread != sizeof(icon_header)) {
	fprintf(stderr, "%s: read: expected %zd, observed %zu\n", me,
	sizeof(icon_header), nread);
	return EXIT_FAILURE;
	}
	total_read += nread;

	size_t icon_length = ntohl(icon_header.length) - sizeof(icon_header);
	char* icon_data = reinterpret_cast<char*>(malloc(icon_length));
	if (!icon_data) {
	fprintf(stderr, "%s: malloc %zu: %s\n", me, icon_length, strerror(errno));
	return EXIT_FAILURE;
	}

	size_t icon_data_read = 0;
	while (icon_length - icon_data_read > 0) {
	nread = read(input_fd, icon_data + icon_data_read,
	icon_length - icon_data_read);
	if (nread < 0) {
	fprintf(stderr, "%s: read: %s\n", me, strerror(errno));
	return EXIT_FAILURE;
	} else if (nread > icon_length - icon_data_read) {
	fprintf(stderr, "%s: read: expected %zu, observed %zd\n", me,
	icon_length - icon_data_read, nread);
	return EXIT_FAILURE;
	}
	icon_data_read += nread;
	}
	total_read += icon_data_read;

	const uint32_t icon_header_magic = ntohl(icon_header.magic);
	bool found = false;
	std::string output_icon_path = output_path;
	output_icon_path += '/';
	for (size_t icon_type_index = 0; icon_type_index < arraysize(icon_types);
	++icon_type_index) {
	const IconType& icon_type = icon_types[icon_type_index];
	if (icon_header_magic == icon_type.magic) {
	found = true;
	output_icon_path += "icon_";
	output_icon_path += icon_type.filename;
	output_icon_path += ".png";
	break;
	}
	}

	if (!found) {
	output_icon_path += FourCCToASCII(icon_header_magic);
	}

	const char* output_icon_path_c = output_icon_path.c_str();
	printf("%s\n", output_icon_path_c);

	int output_fd;
	output_fd = open(output_icon_path_c, O_WRONLY \| O_CREAT \| O_TRUNC, 0644);
	if (output_fd < 0) {
	fprintf(stderr, "%s: open %s: %s\n", me, output_icon_path_c,
	strerror(errno));
	return EXIT_FAILURE;
	}

	size_t icon_data_written = 0;
	while (icon_length - icon_data_written > 0) {
	ssize_t nwritten = write(output_fd, icon_data + icon_data_written,
	icon_length - icon_data_written);
	if (nwritten < 0) {
	fprintf(stderr, "%s: write: %s\n", me, strerror(errno));
	return EXIT_FAILURE;
	} else if (nwritten > icon_length - icon_data_written) {
	fprintf(stderr, "%s: write: expected %zu, observed %zd\n", me,
	icon_length - icon_data_written, nwritten);
	return EXIT_FAILURE;
	}
	icon_data_written += nwritten;
	}

	if (close(output_fd) < 0) {
	fprintf(stderr, "%s: close %s: %s\n", me, output_icon_path_c,
	strerror(errno));
	return EXIT_FAILURE;
	}

	free(icon_data);

	ImageAndMaskIndex index = IMAGE_NONE;
	switch (icon_header_magic) {
	case 'is32':
	index = IMAGE_16;
	break;
	case 'il32':
	index = IMAGE_32;
	break;
	case 'ih32':
	index = IMAGE_48;
	break;
	case 'it32':
	index = IMAGE_128;
	break;
	case 's8mk':
	images_and_masks[IMAGE_16].mask_path = output_icon_path;
	break;
	case 'l8mk':
	images_and_masks[IMAGE_32].mask_path = output_icon_path;
	break;
	case 'h8mk':
	images_and_masks[IMAGE_48].mask_path = output_icon_path;
	break;
	case 't8mk':
	images_and_masks[IMAGE_128].mask_path = output_icon_path;
	break;
	}

	if (index != IMAGE_NONE) {
	images_and_masks[index].image_path = output_icon_path;
	images_and_masks[index].png_path = output_icon_path + ".png";
	}

	if ((icon_header_magic == 'is32' && icon_length != 16 * 16 * 3) \|\|
	(icon_header_magic == 'il32' && icon_length != 32 * 32 * 3) \|\|
	(icon_header_magic == 'ih32' && icon_length != 48 * 48 * 3) \|\|
	(icon_header_magic == 'it32' && icon_length != 128 * 128 * 3)) {
	const std::string output_icon_unpacked_path =
	output_icon_path + ".unpacked";
	const char* output_icon_unpacked_path_c =
	output_icon_unpacked_path.c_str();
	printf("%s\n", output_icon_unpacked_path_c);

	// is32 and il32 definitely don’t use skip. it32 definitely does. I’m not
	// sure about ih32, but I think it doesn’t use skip.
	const bool skip = icon_header_magic == 'it32';

	if (!UnpackIcon(output_icon_path_c, output_icon_unpacked_path_c, skip)) {
	return EXIT_FAILURE;
	}

	assert(index != IMAGE_NONE);
	images_and_masks[index].image_path = output_icon_unpacked_path;
	}
	}

	for (size_t index = 0; index < arraysize(images_and_masks); ++index) {
	const ImageAndMask& image_and_mask = images_and_masks[index];
	if (!image_and_mask.image_path.empty() &&
	!image_and_mask.mask_path.empty()) {
	printf("%s\n", image_and_mask.png_path.c_str());
	if (!EncodePNG(image_and_mask.image_path.c_str(),
	image_and_mask.mask_path.c_str(),
	image_and_mask.png_path.c_str(),
	kImageAndMaskDimensions[index])) {
	return EXIT_FAILURE;
	}
	}
	}

	if (total_read != icns_header_length) {
	fprintf(stderr, "%s: icns file length: expected %d, observed %zu\n", me,
	icns_header_length, total_read);
	return EXIT_FAILURE;
	}

	if (close(input_fd) < 0) {
	fprintf(stderr, "%s: close %s: %s\n", me, input_path, strerror(errno));
	return EXIT_FAILURE;
	}

	return EXIT_SUCCESS;
	}