#include "BigBuffer.h"
#include "BinaryResourceParser.h"
#include "Files.h"
+#include "Flag.h"
#include "JavaClassGenerator.h"
#include "Linker.h"
#include "ManifestParser.h"
#include "ManifestValidator.h"
+#include "Png.h"
#include "ResourceParser.h"
#include "ResourceTable.h"
#include "ResourceValues.h"
#include <iostream>
#include <sstream>
#include <sys/stat.h>
+#include <utils/Errors.h>
using namespace aapt;
* Collect files from 'root', filtering out any files that do not
* match the FileFilter 'filter'.
*/
-bool walkTree(const StringPiece& root, const FileFilter& filter,
- std::vector<Source>& outEntries) {
+bool walkTree(const Source& root, const FileFilter& filter,
+ std::vector<Source>* outEntries) {
bool error = false;
- for (const std::string& dirName : listFiles(root)) {
- std::string dir(root.toString());
+ for (const std::string& dirName : listFiles(root.path)) {
+ std::string dir = root.path;
appendPath(&dir, dirName);
FileType ft = getFileType(dir);
}
if (ft != FileType::kRegular) {
- Logger::error(Source{ file })
- << "not a regular file."
- << std::endl;
+ Logger::error(Source{ file }) << "not a regular file." << std::endl;
error = true;
continue;
}
- outEntries.emplace_back(Source{ file });
+ outEntries->push_back(Source{ file });
}
}
return !error;
}
bool loadResTable(android::ResTable* table, const Source& source) {
- // For NO_ERROR (which on Windows is a MACRO).
- using namespace android;
-
std::ifstream ifs(source.path, std::ifstream::in | std::ifstream::binary);
if (!ifs) {
Logger::error(source) << strerror(errno) << std::endl;
char* buf = new char[dataSize];
ifs.read(buf, dataSize);
- bool result = table->add(buf, dataSize, -1, true) == NO_ERROR;
+ bool result = table->add(buf, dataSize, -1, true) == android::NO_ERROR;
delete [] buf;
return result;
}
}
- std::unique_ptr<FileReference> fileResource = makeFileReference(
- table->getValueStringPool(),
- util::utf16ToUtf8(name.entry) + ".xml",
- name.type,
- config);
- table->addResource(name, config, source.line(0), std::move(fileResource));
-
for (size_t level : sdkLevels) {
Logger::note(source)
<< "creating v" << level << " versioned file."
return true;
}
-struct CompileXml {
+struct CompileItem {
Source source;
ResourceName name;
ConfigDescription config;
+ std::string extension;
};
-bool compileXml(std::shared_ptr<Resolver> resolver, const CompileXml& item,
- const Source& outputSource, std::queue<CompileXml>* queue) {
+bool compileXml(std::shared_ptr<Resolver> resolver, const CompileItem& item,
+ const Source& outputSource, std::queue<CompileItem>* queue) {
std::ifstream in(item.source.path, std::ifstream::binary);
if (!in) {
Logger::error(item.source) << strerror(errno) << std::endl;
if (minStrippedSdk.value() > 0) {
// Something was stripped, so let's generate a new file
// with the version of the smallest SDK version stripped.
- CompileXml newWork = item;
+ CompileItem newWork = item;
newWork.config.sdkVersion = minStrippedSdk.value();
queue->push(newWork);
}
return true;
}
+bool compilePng(const Source& source, const Source& output) {
+ std::ifstream in(source.path, std::ifstream::binary);
+ if (!in) {
+ Logger::error(source) << strerror(errno) << std::endl;
+ return false;
+ }
+
+ std::ofstream out(output.path, std::ofstream::binary);
+ if (!out) {
+ Logger::error(output) << strerror(errno) << std::endl;
+ return false;
+ }
+
+ std::string err;
+ Png png;
+ if (!png.process(source, in, out, {}, &err)) {
+ Logger::error(source) << err << std::endl;
+ return false;
+ }
+ return true;
+}
+
+bool copyFile(const Source& source, const Source& output) {
+ std::ifstream in(source.path, std::ifstream::binary);
+ if (!in) {
+ Logger::error(source) << strerror(errno) << std::endl;
+ return false;
+ }
+
+ std::ofstream out(output.path, std::ofstream::binary);
+ if (!out) {
+ Logger::error(output) << strerror(errno) << std::endl;
+ return false;
+ }
+
+ if (out << in.rdbuf()) {
+ Logger::error(output) << strerror(errno) << std::endl;
+ return true;
+ }
+ return false;
+}
+
struct AaptOptions {
enum class Phase {
- LegacyFull,
+ Full,
Collect,
Link,
Compile,
// The location of the manifest file.
Source manifest;
- // The files to process.
- std::vector<Source> sources;
+ // The source directories to walk and find resource files.
+ std::vector<Source> sourceDirs;
+
+ // The resource files to process and collect.
+ std::vector<Source> collectFiles;
+
+ // The binary table files to link.
+ std::vector<Source> linkFiles;
+
+ // The resource files to compile.
+ std::vector<Source> compileFiles;
// The libraries these files may reference.
std::vector<Source> libraries;
- // Output directory.
+ // Output path. This can be a directory or file
+ // depending on the phase.
Source output;
- // Whether to generate a Java Class.
+ // Directory to in which to generate R.java.
Maybe<Source> generateJavaClass;
// Whether to output verbose details about
bool verbose = false;
};
-bool compileAndroidManifest(std::shared_ptr<Resolver> resolver, const AaptOptions& options) {
- using namespace android;
-
+bool compileAndroidManifest(const std::shared_ptr<Resolver>& resolver,
+ const AaptOptions& options) {
Source outSource = options.output;
appendPath(&outSource.path, "AndroidManifest.xml");
p += b.size;
}
- ResXMLTree tree;
- if (tree.setTo(data.get(), outBuffer.size()) != NO_ERROR) {
+ android::ResXMLTree tree;
+ if (tree.setTo(data.get(), outBuffer.size()) != android::NO_ERROR) {
return false;
}
return parser.parse(source, pullParser, outInfo);
}
-/**
- * Parses legacy options and walks the source directories collecting
- * files to process.
- */
-bool prepareLegacy(std::vector<StringPiece>::const_iterator argsIter,
- const std::vector<StringPiece>::const_iterator argsEndIter,
- AaptOptions &options) {
- options.phase = AaptOptions::Phase::LegacyFull;
-
- std::vector<StringPiece> sourceDirs;
- while (argsIter != argsEndIter) {
- if (*argsIter == "-S") {
- ++argsIter;
- if (argsIter == argsEndIter) {
- Logger::error() << "-S missing argument." << std::endl;
- return false;
- }
- sourceDirs.push_back(*argsIter);
- } else if (*argsIter == "-I") {
- ++argsIter;
- if (argsIter == argsEndIter) {
- Logger::error() << "-I missing argument." << std::endl;
- return false;
- }
- options.libraries.push_back(Source{ argsIter->toString() });
- } else if (*argsIter == "-M") {
- ++argsIter;
- if (argsIter == argsEndIter) {
- Logger::error() << "-M missing argument." << std::endl;
- return false;
- }
+static AaptOptions prepareArgs(int argc, char** argv) {
+ if (argc < 2) {
+ std::cerr << "no command specified." << std::endl;
+ exit(1);
+ }
- if (!options.manifest.path.empty()) {
- Logger::error() << "multiple -M flags are not allowed." << std::endl;
- return false;
- }
- options.manifest.path = argsIter->toString();
- } else if (*argsIter == "-o") {
- ++argsIter;
- if (argsIter == argsEndIter) {
- Logger::error() << "-o missing argument." << std::endl;
- return false;
- }
- options.output = Source{ argsIter->toString() };
- } else if (*argsIter == "-J") {
- ++argsIter;
- if (argsIter == argsEndIter) {
- Logger::error() << "-J missing argument." << std::endl;
- return false;
- }
- options.generateJavaClass = make_value<Source>(Source{ argsIter->toString() });
- } else if (*argsIter == "-v") {
- options.verbose = true;
- } else {
- Logger::error() << "unrecognized option '" << *argsIter << "'." << std::endl;
- return false;
- }
+ const StringPiece command(argv[1]);
+ argc -= 2;
+ argv += 2;
- ++argsIter;
- }
+ AaptOptions options;
- if (options.manifest.path.empty()) {
- Logger::error() << "must specify manifest file with -M." << std::endl;
- return false;
+ StringPiece outputDescription = "place output in file";
+ if (command == "package") {
+ options.phase = AaptOptions::Phase::Full;
+ outputDescription = "place output in directory";
+ } else if (command == "collect") {
+ options.phase = AaptOptions::Phase::Collect;
+ } else if (command == "link") {
+ options.phase = AaptOptions::Phase::Link;
+ } else if (command == "compile") {
+ options.phase = AaptOptions::Phase::Compile;
+ outputDescription = "place output in directory";
+ } else {
+ std::cerr << "invalid command '" << command << "'." << std::endl;
+ exit(1);
}
- // Load the App's package name, etc.
- if (!loadAppInfo(options.manifest, &options.appInfo)) {
- return false;
- }
+ if (options.phase == AaptOptions::Phase::Full) {
+ flag::requiredFlag("-S", "add a directory in which to find resources",
+ [&options](const StringPiece& arg) {
+ options.sourceDirs.push_back(Source{ arg.toString() });
+ });
+
+ flag::requiredFlag("-M", "path to AndroidManifest.xml",
+ [&options](const StringPiece& arg) {
+ options.manifest = Source{ arg.toString() };
+ });
+
+ flag::optionalFlag("-I", "add an Android APK to link against",
+ [&options](const StringPiece& arg) {
+ options.libraries.push_back(Source{ arg.toString() });
+ });
+
+ flag::optionalFlag("--java", "directory in which to generate R.java",
+ [&options](const StringPiece& arg) {
+ options.generateJavaClass = Source{ arg.toString() };
+ });
- /**
- * Set up the file filter to ignore certain files.
- */
- const char* customIgnore = getenv("ANDROID_AAPT_IGNORE");
- FileFilter fileFilter;
- if (customIgnore && customIgnore[0]) {
- fileFilter.setPattern(customIgnore);
} else {
- fileFilter.setPattern(
- "!.svn:!.git:!.ds_store:!*.scc:.*:<dir>_*:!CVS:!thumbs.db:!picasa.ini:!*~");
- }
+ flag::requiredFlag("--package", "Android package name",
+ [&options](const StringPiece& arg) {
+ options.appInfo.package = util::utf8ToUtf16(arg);
+ });
- /*
- * Enumerate the files in each source directory.
- */
- for (const StringPiece& source : sourceDirs) {
- if (!walkTree(source, fileFilter, options.sources)) {
- return false;
+ if (options.phase != AaptOptions::Phase::Collect) {
+ flag::optionalFlag("-I", "add an Android APK to link against",
+ [&options](const StringPiece& arg) {
+ options.libraries.push_back(Source{ arg.toString() });
+ });
}
- }
- return true;
-}
-
-bool prepareCollect(std::vector<StringPiece>::const_iterator argsIter,
- const std::vector<StringPiece>::const_iterator argsEndIter,
- AaptOptions& options) {
- options.phase = AaptOptions::Phase::Collect;
- while (argsIter != argsEndIter) {
- if (*argsIter == "--package") {
- ++argsIter;
- if (argsIter == argsEndIter) {
- Logger::error() << "--package missing argument." << std::endl;
- return false;
- }
- options.appInfo.package = util::utf8ToUtf16(*argsIter);
- } else if (*argsIter == "-o") {
- ++argsIter;
- if (argsIter == argsEndIter) {
- Logger::error() << "-o missing argument." << std::endl;
- return false;
- }
- options.output = Source{ argsIter->toString() };
- } else if (*argsIter == "-v") {
- options.verbose = true;
- } else if (argsIter->data()[0] != '-') {
- options.sources.push_back(Source{ argsIter->toString() });
- } else {
- Logger::error()
- << "unknown option '"
- << *argsIter
- << "'."
- << std::endl;
- return false;
+ if (options.phase == AaptOptions::Phase::Link) {
+ flag::optionalFlag("--java", "directory in which to generate R.java",
+ [&options](const StringPiece& arg) {
+ options.generateJavaClass = Source{ arg.toString() };
+ });
}
- ++argsIter;
}
- return true;
-}
-bool prepareLink(std::vector<StringPiece>::const_iterator argsIter,
- const std::vector<StringPiece>::const_iterator argsEndIter,
- AaptOptions& options) {
- options.phase = AaptOptions::Phase::Link;
+ // Common flags for all steps.
+ flag::requiredFlag("-o", outputDescription, [&options](const StringPiece& arg) {
+ options.output = Source{ arg.toString() };
+ });
+ flag::optionalSwitch("-v", "enables verbose logging", &options.verbose);
- while (argsIter != argsEndIter) {
- if (*argsIter == "--package") {
- ++argsIter;
- if (argsIter == argsEndIter) {
- Logger::error() << "--package missing argument." << std::endl;
- return false;
- }
- options.appInfo.package = util::utf8ToUtf16(*argsIter);
- } else if (*argsIter == "-o") {
- ++argsIter;
- if (argsIter == argsEndIter) {
- Logger::error() << "-o missing argument." << std::endl;
- return false;
- }
- options.output = Source{ argsIter->toString() };
- } else if (*argsIter == "-I") {
- ++argsIter;
- if (argsIter == argsEndIter) {
- Logger::error() << "-I missing argument." << std::endl;
- return false;
- }
- options.libraries.push_back(Source{ argsIter->toString() });
- } else if (*argsIter == "--java") {
- ++argsIter;
- if (argsIter == argsEndIter) {
- Logger::error() << "--java missing argument." << std::endl;
- return false;
- }
- options.generateJavaClass = make_value<Source>(Source{ argsIter->toString() });
- } else if (*argsIter == "-v") {
- options.verbose = true;
- } else if (argsIter->data()[0] != '-') {
- options.sources.push_back(Source{ argsIter->toString() });
- } else {
- Logger::error()
- << "unknown option '"
- << *argsIter
- << "'."
- << std::endl;
- return false;
- }
- ++argsIter;
- }
- return true;
-}
+ // Build the command string for output (eg. "aapt2 compile").
+ std::string fullCommand = "aapt2";
+ fullCommand += " ";
+ fullCommand += command.toString();
-bool prepareCompile(std::vector<StringPiece>::const_iterator argsIter,
- const std::vector<StringPiece>::const_iterator argsEndIter,
- AaptOptions& options) {
- options.phase = AaptOptions::Phase::Compile;
+ // Actually read the command line flags.
+ flag::parse(argc, argv, fullCommand);
- while (argsIter != argsEndIter) {
- if (*argsIter == "--package") {
- ++argsIter;
- if (argsIter == argsEndIter) {
- Logger::error() << "--package missing argument." << std::endl;
- return false;
- }
- options.appInfo.package = util::utf8ToUtf16(*argsIter);
- } else if (*argsIter == "-o") {
- ++argsIter;
- if (argsIter == argsEndIter) {
- Logger::error() << "-o missing argument." << std::endl;
- return false;
- }
- options.output = Source{ argsIter->toString() };
- } else if (*argsIter == "-I") {
- ++argsIter;
- if (argsIter == argsEndIter) {
- Logger::error() << "-I missing argument." << std::endl;
- return false;
- }
- options.libraries.push_back(Source{ argsIter->toString() });
- } else if (*argsIter == "-v") {
- options.verbose = true;
- } else if (argsIter->data()[0] != '-') {
- options.sources.push_back(Source{ argsIter->toString() });
- } else {
- Logger::error()
- << "unknown option '"
- << *argsIter
- << "'."
- << std::endl;
- return false;
+ // Copy all the remaining arguments.
+ if (options.phase == AaptOptions::Phase::Collect) {
+ for (const std::string& arg : flag::getArgs()) {
+ options.collectFiles.push_back(Source{ arg });
+ }
+ } else if (options.phase == AaptOptions::Phase::Compile) {
+ for (const std::string& arg : flag::getArgs()) {
+ options.compileFiles.push_back(Source{ arg });
+ }
+ } else if (options.phase == AaptOptions::Phase::Link) {
+ for (const std::string& arg : flag::getArgs()) {
+ options.linkFiles.push_back(Source{ arg });
}
- ++argsIter;
}
- return true;
+ return options;
}
-struct CollectValuesItem {
- Source source;
- ConfigDescription config;
-};
-
-bool collectValues(std::shared_ptr<ResourceTable> table, const CollectValuesItem& item) {
- std::ifstream in(item.source.path, std::ifstream::binary);
+static bool collectValues(const std::shared_ptr<ResourceTable>& table, const Source& source,
+ const ConfigDescription& config) {
+ std::ifstream in(source.path, std::ifstream::binary);
if (!in) {
- Logger::error(item.source) << strerror(errno) << std::endl;
+ Logger::error(source) << strerror(errno) << std::endl;
return false;
}
std::shared_ptr<XmlPullParser> xmlParser = std::make_shared<SourceXmlPullParser>(in);
- ResourceParser parser(table, item.source, item.config, xmlParser);
+ ResourceParser parser(table, source, config, xmlParser);
return parser.parse();
}
* Resource file paths are expected to look like:
* [--/res/]type[-config]/name
*/
-Maybe<ResourcePathData> extractResourcePathData(const Source& source) {
+static Maybe<ResourcePathData> extractResourcePathData(const Source& source) {
std::vector<std::string> parts = util::splitAndLowercase(source.path, '/');
if (parts.size() < 2) {
Logger::error(source) << "bad resource path." << std::endl;
};
}
-static bool doLegacy(std::shared_ptr<ResourceTable> table, std::shared_ptr<Resolver> resolver,
- const AaptOptions& options) {
+bool doAll(AaptOptions* options, const std::shared_ptr<ResourceTable>& table,
+ const std::shared_ptr<Resolver>& resolver) {
+ const bool versionStyles = (options->phase == AaptOptions::Phase::Full ||
+ options->phase == AaptOptions::Phase::Link);
+ const bool verifyNoMissingSymbols = (options->phase == AaptOptions::Phase::Full ||
+ options->phase == AaptOptions::Phase::Link);
+ const bool compileFiles = (options->phase == AaptOptions::Phase::Full ||
+ options->phase == AaptOptions::Phase::Compile);
+ const bool flattenTable = (options->phase == AaptOptions::Phase::Full ||
+ options->phase == AaptOptions::Phase::Collect ||
+ options->phase == AaptOptions::Phase::Link);
+ const bool useExtendedChunks = options->phase == AaptOptions::Phase::Collect;
+
+ // Build the output table path.
+ Source outputTable = options->output;
+ if (options->phase == AaptOptions::Phase::Full) {
+ appendPath(&outputTable.path, "resources.arsc");
+ }
+
bool error = false;
- std::queue<CompileXml> xmlCompileQueue;
+ std::queue<CompileItem> compileQueue;
+
+ // If source directories were specified, walk them looking for resource files.
+ if (!options->sourceDirs.empty()) {
+ const char* customIgnore = getenv("ANDROID_AAPT_IGNORE");
+ FileFilter fileFilter;
+ if (customIgnore && customIgnore[0]) {
+ fileFilter.setPattern(customIgnore);
+ } else {
+ fileFilter.setPattern(
+ "!.svn:!.git:!.ds_store:!*.scc:.*:<dir>_*:!CVS:!thumbs.db:!picasa.ini:!*~");
+ }
+
+ for (const Source& source : options->sourceDirs) {
+ if (!walkTree(source, fileFilter, &options->collectFiles)) {
+ return false;
+ }
+ }
+ }
+
+ // Load all binary resource tables.
+ for (const Source& source : options->linkFiles) {
+ error |= !loadBinaryResourceTable(table, source);
+ }
+
+ if (error) {
+ return false;
+ }
- //
- // Read values XML files and XML/PNG files.
+ // Collect all the resource files.
// Need to parse the resource type/config/filename.
- //
- for (const Source& source : options.sources) {
+ for (const Source& source : options->collectFiles) {
Maybe<ResourcePathData> maybePathData = extractResourcePathData(source);
if (!maybePathData) {
return false;
const ResourcePathData& pathData = maybePathData.value();
if (pathData.resourceDir == u"values") {
- if (options.verbose) {
+ if (options->verbose) {
Logger::note(source) << "collecting values..." << std::endl;
}
- error |= !collectValues(table, CollectValuesItem{ source, pathData.config });
+ error |= !collectValues(table, source, pathData.config);
continue;
}
const ResourceType* type = parseResourceType(pathData.resourceDir);
if (!type) {
- Logger::error(source)
- << "invalid resource type '"
- << pathData.resourceDir
- << "'."
- << std::endl;
+ Logger::error(source) << "invalid resource type '" << pathData.resourceDir << "'."
+ << std::endl;
return false;
}
ResourceName resourceName = { table->getPackage(), *type, pathData.name };
- if (pathData.extension == "xml") {
- if (options.verbose) {
- Logger::note(source) << "collecting XML..." << std::endl;
- }
- error |= !collectXml(table, source, resourceName, pathData.config);
- xmlCompileQueue.push(CompileXml{
- source,
- resourceName,
- pathData.config
- });
- } else {
- std::unique_ptr<FileReference> fileReference = makeFileReference(
- table->getValueStringPool(),
- util::utf16ToUtf8(pathData.name) + "." + pathData.extension,
- *type, pathData.config);
+ // Add the file name to the resource table.
+ std::unique_ptr<FileReference> fileReference = makeFileReference(
+ table->getValueStringPool(),
+ util::utf16ToUtf8(pathData.name) + "." + pathData.extension,
+ *type, pathData.config);
+ error |= !table->addResource(resourceName, pathData.config, source.line(0),
+ std::move(fileReference));
- error |= !table->addResource(resourceName, pathData.config, source.line(0),
- std::move(fileReference));
+ if (pathData.extension == "xml") {
+ error |= !collectXml(table, source, resourceName, pathData.config);
}
+
+ compileQueue.push(
+ CompileItem{ source, resourceName, pathData.config, pathData.extension });
}
if (error) {
return false;
}
- versionStylesForCompat(table);
+ // Version all styles referencing attributes outside of their specified SDK version.
+ if (versionStyles) {
+ versionStylesForCompat(table);
+ }
- //
- // Verify all references and data types.
- //
+ // Verify that all references are valid.
Linker linker(table, resolver);
if (!linker.linkAndValidate()) {
- Logger::error()
- << "linking failed."
- << std::endl;
return false;
}
- const auto& unresolvedRefs = linker.getUnresolvedReferences();
- if (!unresolvedRefs.empty()) {
- for (const auto& entry : unresolvedRefs) {
- for (const auto& source : entry.second) {
- Logger::error(source)
- << "unresolved symbol '"
- << entry.first
- << "'."
- << std::endl;
+ // Verify that all symbols exist.
+ if (verifyNoMissingSymbols) {
+ const auto& unresolvedRefs = linker.getUnresolvedReferences();
+ if (!unresolvedRefs.empty()) {
+ for (const auto& entry : unresolvedRefs) {
+ for (const auto& source : entry.second) {
+ Logger::error(source) << "unresolved symbol '" << entry.first << "'."
+ << std::endl;
+ }
}
- }
- return false;
- }
-
- //
- // Compile the XML files.
- //
- while (!xmlCompileQueue.empty()) {
- const CompileXml& item = xmlCompileQueue.front();
-
- // Create the output path from the resource name.
- std::stringstream outputPath;
- outputPath << item.name.type;
- if (item.config != ConfigDescription{}) {
- outputPath << "-" << item.config.toString();
- }
-
- Source outSource = options.output;
- appendPath(&outSource.path, "res");
- appendPath(&outSource.path, outputPath.str());
-
- if (!mkdirs(outSource.path)) {
- Logger::error(outSource) << strerror(errno) << std::endl;
return false;
}
-
- appendPath(&outSource.path, util::utf16ToUtf8(item.name.entry) + ".xml");
-
- if (options.verbose) {
- Logger::note(outSource) << "compiling XML file." << std::endl;
- }
-
- error |= !compileXml(resolver, item, outSource, &xmlCompileQueue);
- xmlCompileQueue.pop();
- }
-
- if (error) {
- return false;
- }
-
- //
- // Compile the AndroidManifest.xml file.
- //
- if (!compileAndroidManifest(resolver, options)) {
- return false;
}
- //
- // Generate the Java R class.
- //
- if (options.generateJavaClass) {
- Source outPath = options.generateJavaClass.value();
- if (options.verbose) {
- Logger::note()
- << "writing symbols to "
- << outPath
- << "."
- << std::endl;
- }
-
- for (std::string& part : util::split(util::utf16ToUtf8(table->getPackage()), '.')) {
- appendPath(&outPath.path, part);
- }
-
- if (!mkdirs(outPath.path)) {
- Logger::error(outPath) << strerror(errno) << std::endl;
- return false;
- }
-
- appendPath(&outPath.path, "R.java");
-
- std::ofstream fout(outPath.path);
- if (!fout) {
- Logger::error(outPath) << strerror(errno) << std::endl;
- return false;
- }
-
- JavaClassGenerator generator(table, JavaClassGenerator::Options{});
- if (!generator.generate(fout)) {
- Logger::error(outPath)
- << generator.getError()
- << "."
- << std::endl;
- return false;
- }
- }
-
- //
- // Flatten resource table.
- //
- if (table->begin() != table->end()) {
- BigBuffer buffer(1024);
- TableFlattener::Options tableOptions;
- tableOptions.useExtendedChunks = false;
- TableFlattener flattener(tableOptions);
- if (!flattener.flatten(&buffer, *table)) {
- Logger::error()
- << "failed to flatten resource table->"
- << std::endl;
- return false;
- }
-
- if (options.verbose) {
- Logger::note()
- << "Final resource table size="
- << util::formatSize(buffer.size())
- << std::endl;
- }
+ // Compile files.
+ if (compileFiles) {
+ // First process any input compile files.
+ for (const Source& source : options->compileFiles) {
+ Maybe<ResourcePathData> maybePathData = extractResourcePathData(source);
+ if (!maybePathData) {
+ return false;
+ }
- std::string outTable(options.output.path);
- appendPath(&outTable, "resources.arsc");
+ const ResourcePathData& pathData = maybePathData.value();
+ const ResourceType* type = parseResourceType(pathData.resourceDir);
+ if (!type) {
+ Logger::error(source) << "invalid resource type '" << pathData.resourceDir
+ << "'." << std::endl;
+ return false;
+ }
- std::ofstream fout(outTable, std::ofstream::binary);
- if (!fout) {
- Logger::error(Source{outTable})
- << strerror(errno)
- << "."
- << std::endl;
- return false;
+ ResourceName resourceName = { table->getPackage(), *type, pathData.name };
+ compileQueue.push(
+ CompileItem{ source, resourceName, pathData.config, pathData.extension });
}
- if (!util::writeAll(fout, buffer)) {
- Logger::error(Source{outTable})
- << strerror(errno)
- << "."
- << std::endl;
- return false;
- }
- fout.flush();
- }
- return true;
-}
-
-static bool doCollect(std::shared_ptr<ResourceTable> table, std::shared_ptr<Resolver> resolver,
- const AaptOptions& options) {
- bool error = false;
-
- //
- // Read values XML files and XML/PNG files.
- // Need to parse the resource type/config/filename.
- //
- for (const Source& source : options.sources) {
- Maybe<ResourcePathData> maybePathData = extractResourcePathData(source);
- if (!maybePathData) {
- return false;
- }
+ // Now process the actual compile queue.
+ for (; !compileQueue.empty(); compileQueue.pop()) {
+ const CompileItem& item = compileQueue.front();
- const ResourcePathData& pathData = maybePathData.value();
- if (pathData.resourceDir == u"values") {
- if (options.verbose) {
- Logger::note(source) << "collecting values..." << std::endl;
+ // Create the output directory path from the resource type and config.
+ std::stringstream outputPath;
+ outputPath << item.name.type;
+ if (item.config != ConfigDescription{}) {
+ outputPath << "-" << item.config.toString();
}
- error |= !collectValues(table, CollectValuesItem{ source, pathData.config });
- continue;
- }
+ Source outSource = options->output;
+ appendPath(&outSource.path, "res");
+ appendPath(&outSource.path, outputPath.str());
- const ResourceType* type = parseResourceType(pathData.resourceDir);
- if (!type) {
- Logger::error(source)
- << "invalid resource type '"
- << pathData.resourceDir
- << "'."
- << std::endl;
- return false;
- }
-
- ResourceName resourceName = { table->getPackage(), *type, pathData.name };
- if (pathData.extension == "xml") {
- if (options.verbose) {
- Logger::note(source) << "collecting XML..." << std::endl;
+ // Make the directory.
+ if (!mkdirs(outSource.path)) {
+ Logger::error(outSource) << strerror(errno) << std::endl;
+ return false;
}
- error |= !collectXml(table, source, resourceName, pathData.config);
- } else {
- std::unique_ptr<FileReference> fileReference = makeFileReference(
- table->getValueStringPool(),
- util::utf16ToUtf8(pathData.name) + "." + pathData.extension,
- *type,
- pathData.config);
- error |= !table->addResource(resourceName, pathData.config, source.line(0),
- std::move(fileReference));
- }
- }
-
- if (error) {
- return false;
- }
+ // Add the file name to the directory path.
+ appendPath(&outSource.path, util::utf16ToUtf8(item.name.entry) + "." + item.extension);
- Linker linker(table, resolver);
- if (!linker.linkAndValidate()) {
- return false;
- }
+ if (item.extension == "xml") {
+ if (options->verbose) {
+ Logger::note(outSource) << "compiling XML file." << std::endl;
+ }
- //
- // Flatten resource table->
- //
- if (table->begin() != table->end()) {
- BigBuffer buffer(1024);
- TableFlattener::Options tableOptions;
- tableOptions.useExtendedChunks = true;
- TableFlattener flattener(tableOptions);
- if (!flattener.flatten(&buffer, *table)) {
- Logger::error()
- << "failed to flatten resource table->"
- << std::endl;
- return false;
- }
+ error |= !compileXml(resolver, item, outSource, &compileQueue);
+ } else if (item.extension == "png" || item.extension == "9.png") {
+ if (options->verbose) {
+ Logger::note(outSource) << "compiling png file." << std::endl;
+ }
- std::ofstream fout(options.output.path, std::ofstream::binary);
- if (!fout) {
- Logger::error(options.output)
- << strerror(errno)
- << "."
- << std::endl;
- return false;
+ error |= !compilePng(item.source, outSource);
+ } else {
+ error |= !copyFile(item.source, outSource);
+ }
}
- if (!util::writeAll(fout, buffer)) {
- Logger::error(options.output)
- << strerror(errno)
- << "."
- << std::endl;
+ if (error) {
return false;
}
- fout.flush();
- }
- return true;
-}
-
-static bool doLink(std::shared_ptr<ResourceTable> table, std::shared_ptr<Resolver> resolver,
- const AaptOptions& options) {
- bool error = false;
-
- for (const Source& source : options.sources) {
- error |= !loadBinaryResourceTable(table, source);
- }
-
- if (error) {
- return false;
}
- versionStylesForCompat(table);
-
- Linker linker(table, resolver);
- if (!linker.linkAndValidate()) {
- return false;
- }
-
- const auto& unresolvedRefs = linker.getUnresolvedReferences();
- if (!unresolvedRefs.empty()) {
- for (const auto& entry : unresolvedRefs) {
- for (const auto& source : entry.second) {
- Logger::error(source)
- << "unresolved symbol '"
- << entry.first
- << "'."
- << std::endl;
- }
+ // Compile and validate the AndroidManifest.xml.
+ if (!options->manifest.path.empty()) {
+ if (!compileAndroidManifest(resolver, *options)) {
+ return false;
}
- return false;
}
- //
- // Generate the Java R class.
- //
- if (options.generateJavaClass) {
- Source outPath = options.generateJavaClass.value();
- if (options.verbose) {
- Logger::note()
- << "writing symbols to "
- << outPath
- << "."
- << std::endl;
+ // Generate the Java class file.
+ if (options->generateJavaClass) {
+ Source outPath = options->generateJavaClass.value();
+ if (options->verbose) {
+ Logger::note() << "writing symbols to " << outPath << "." << std::endl;
}
- for (std::string& part : util::split(util::utf16ToUtf8(table->getPackage()), '.')) {
+ // Build the output directory from the package name.
+ // Eg. com.android.app -> com/android/app
+ const std::string packageUtf8 = util::utf16ToUtf8(table->getPackage());
+ for (StringPiece part : util::tokenize<char>(packageUtf8, '.')) {
appendPath(&outPath.path, part);
}
return false;
}
- JavaClassGenerator generator(table, JavaClassGenerator::Options{});
+ JavaClassGenerator generator(table, {});
if (!generator.generate(fout)) {
- Logger::error(outPath)
- << generator.getError()
- << "."
- << std::endl;
+ Logger::error(outPath) << generator.getError() << "." << std::endl;
return false;
}
}
- //
- // Flatten resource table.
- //
- if (table->begin() != table->end()) {
+ // Flatten the resource table.
+ if (flattenTable && table->begin() != table->end()) {
BigBuffer buffer(1024);
TableFlattener::Options tableOptions;
- tableOptions.useExtendedChunks = false;
+ tableOptions.useExtendedChunks = useExtendedChunks;
TableFlattener flattener(tableOptions);
if (!flattener.flatten(&buffer, *table)) {
- Logger::error()
- << "failed to flatten resource table->"
- << std::endl;
+ Logger::error() << "failed to flatten resource table." << std::endl;
return false;
}
- if (options.verbose) {
- Logger::note()
- << "Final resource table size="
- << util::formatSize(buffer.size())
- << std::endl;
+ if (options->verbose) {
+ Logger::note() << "Final resource table size=" << util::formatSize(buffer.size())
+ << std::endl;
}
- std::ofstream fout(options.output.path, std::ofstream::binary);
+ std::ofstream fout(outputTable.path, std::ofstream::binary);
if (!fout) {
- Logger::error(options.output)
- << strerror(errno)
- << "."
- << std::endl;
+ Logger::error(outputTable) << strerror(errno) << "." << std::endl;
return false;
}
if (!util::writeAll(fout, buffer)) {
- Logger::error(options.output)
- << strerror(errno)
- << "."
- << std::endl;
+ Logger::error(outputTable) << strerror(errno) << "." << std::endl;
return false;
}
fout.flush();
return true;
}
-static bool doCompile(std::shared_ptr<ResourceTable> table, std::shared_ptr<Resolver> resolver,
- const AaptOptions& options) {
- std::queue<CompileXml> xmlCompileQueue;
-
- for (const Source& source : options.sources) {
- Maybe<ResourcePathData> maybePathData = extractResourcePathData(source);
- if (!maybePathData) {
- return false;
- }
-
- ResourcePathData& pathData = maybePathData.value();
- const ResourceType* type = parseResourceType(pathData.resourceDir);
- if (!type) {
- Logger::error(source)
- << "invalid resource type '"
- << pathData.resourceDir
- << "'."
- << std::endl;
- return false;
- }
-
- ResourceName resourceName = { table->getPackage(), *type, pathData.name };
- if (pathData.extension == "xml") {
- xmlCompileQueue.push(CompileXml{
- source,
- resourceName,
- pathData.config
- });
- } else {
- // TODO(adamlesinski): Handle images here.
- }
- }
-
- bool error = false;
- while (!xmlCompileQueue.empty()) {
- const CompileXml& item = xmlCompileQueue.front();
-
- // Create the output path from the resource name.
- std::stringstream outputPath;
- outputPath << item.name.type;
- if (item.config != ConfigDescription{}) {
- outputPath << "-" << item.config.toString();
- }
-
- Source outSource = options.output;
- appendPath(&outSource.path, "res");
- appendPath(&outSource.path, outputPath.str());
-
- if (!mkdirs(outSource.path)) {
- Logger::error(outSource) << strerror(errno) << std::endl;
- return false;
- }
-
- appendPath(&outSource.path, util::utf16ToUtf8(item.name.entry) + ".xml");
-
- if (options.verbose) {
- Logger::note(outSource) << "compiling XML file." << std::endl;
- }
-
- error |= !compileXml(resolver, item, outSource, &xmlCompileQueue);
- xmlCompileQueue.pop();
- }
- return !error;
-}
-
int main(int argc, char** argv) {
Logger::setLog(std::make_shared<Log>(std::cerr, std::cerr));
+ AaptOptions options = prepareArgs(argc, argv);
- std::vector<StringPiece> args;
- args.reserve(argc - 1);
- for (int i = 1; i < argc; i++) {
- args.emplace_back(argv[i], strlen(argv[i]));
- }
-
- if (args.empty()) {
- Logger::error() << "no command specified." << std::endl;
- return 1;
- }
-
- AaptOptions options;
-
- // Check the command we're running.
- const StringPiece& command = args.front();
- if (command == "package") {
- if (!prepareLegacy(std::begin(args) + 1, std::end(args), options)) {
- return 1;
- }
- } else if (command == "collect") {
- if (!prepareCollect(std::begin(args) + 1, std::end(args), options)) {
- return 1;
- }
- } else if (command == "link") {
- if (!prepareLink(std::begin(args) + 1, std::end(args), options)) {
- return 1;
- }
- } else if (command == "compile") {
- if (!prepareCompile(std::begin(args) + 1, std::end(args), options)) {
- return 1;
+ // If we specified a manifest, go ahead and load the package name from the manifest.
+ if (!options.manifest.path.empty()) {
+ if (!loadAppInfo(options.manifest, &options.appInfo)) {
+ return false;
}
- } else {
- Logger::error() << "unknown command '" << command << "'." << std::endl;
- return 1;
}
- //
// Verify we have some common options set.
- //
-
- if (options.sources.empty()) {
- Logger::error() << "no sources specified." << std::endl;
- return false;
- }
-
- if (options.output.path.empty()) {
- Logger::error() << "no output directory specified." << std::endl;
- return false;
- }
-
if (options.appInfo.package.empty()) {
Logger::error() << "no package name specified." << std::endl;
return false;
}
-
- //
- // Every phase needs a resource table and a resolver/linker.
- //
-
+ // Every phase needs a resource table.
std::shared_ptr<ResourceTable> table = std::make_shared<ResourceTable>();
table->setPackage(options.appInfo.package);
if (options.appInfo.package == u"android") {
table->setPackageId(0x7f);
}
- //
// Load the included libraries.
- //
std::shared_ptr<android::AssetManager> libraries = std::make_shared<android::AssetManager>();
for (const Source& source : options.libraries) {
if (util::stringEndsWith(source.path, ".arsc")) {
// Make the resolver that will cache IDs for us.
std::shared_ptr<Resolver> resolver = std::make_shared<Resolver>(table, libraries);
- //
- // Dispatch to the real phase here.
- //
-
- bool result = true;
- switch (options.phase) {
- case AaptOptions::Phase::LegacyFull:
- result = doLegacy(table, resolver, options);
- break;
-
- case AaptOptions::Phase::Collect:
- result = doCollect(table, resolver, options);
- break;
-
- case AaptOptions::Phase::Link:
- result = doLink(table, resolver, options);
- break;
-
- case AaptOptions::Phase::Compile:
- result = doCompile(table, resolver, options);
- break;
- }
-
- if (!result) {
- Logger::error()
- << "aapt exiting with failures."
- << std::endl;
+ // Do the work.
+ if (!doAll(&options, table, resolver)) {
+ Logger::error() << "aapt exiting with failures." << std::endl;
return 1;
}
return 0;
--- /dev/null
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * 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 "Logger.h"
+#include "Png.h"
+#include "Source.h"
+#include "Util.h"
+
+#include <androidfw/ResourceTypes.h>
+#include <iostream>
+#include <png.h>
+#include <sstream>
+#include <string>
+#include <vector>
+#include <zlib.h>
+
+namespace aapt {
+
+constexpr bool kDebug = false;
+constexpr size_t kPngSignatureSize = 8u;
+
+struct PngInfo {
+ ~PngInfo() {
+ for (png_bytep row : rows) {
+ if (row != nullptr) {
+ delete[] row;
+ }
+ }
+
+ delete[] xDivs;
+ delete[] yDivs;
+ }
+
+ void* serialize9Patch() {
+ void* serialized = android::Res_png_9patch::serialize(info9Patch, xDivs, yDivs,
+ colors.data());
+ reinterpret_cast<android::Res_png_9patch*>(serialized)->deviceToFile();
+ return serialized;
+ }
+
+ uint32_t width = 0;
+ uint32_t height = 0;
+ std::vector<png_bytep> rows;
+
+ bool is9Patch = false;
+ android::Res_png_9patch info9Patch;
+ int32_t* xDivs = nullptr;
+ int32_t* yDivs = nullptr;
+ std::vector<uint32_t> colors;
+
+ // Layout padding.
+ bool haveLayoutBounds = false;
+ int32_t layoutBoundsLeft;
+ int32_t layoutBoundsTop;
+ int32_t layoutBoundsRight;
+ int32_t layoutBoundsBottom;
+
+ // Round rect outline description.
+ int32_t outlineInsetsLeft;
+ int32_t outlineInsetsTop;
+ int32_t outlineInsetsRight;
+ int32_t outlineInsetsBottom;
+ float outlineRadius;
+ uint8_t outlineAlpha;
+};
+
+static void readDataFromStream(png_structp readPtr, png_bytep data, png_size_t length) {
+ std::istream* input = reinterpret_cast<std::istream*>(png_get_io_ptr(readPtr));
+ if (!input->read(reinterpret_cast<char*>(data), length)) {
+ png_error(readPtr, strerror(errno));
+ }
+}
+
+static void writeDataToStream(png_structp writePtr, png_bytep data, png_size_t length) {
+ std::ostream* output = reinterpret_cast<std::ostream*>(png_get_io_ptr(writePtr));
+ if (!output->write(reinterpret_cast<const char*>(data), length)) {
+ png_error(writePtr, strerror(errno));
+ }
+}
+
+static void flushDataToStream(png_structp writePtr) {
+ std::ostream* output = reinterpret_cast<std::ostream*>(png_get_io_ptr(writePtr));
+ if (!output->flush()) {
+ png_error(writePtr, strerror(errno));
+ }
+}
+
+static void logWarning(png_structp readPtr, png_const_charp warningMessage) {
+ SourceLogger* logger = reinterpret_cast<SourceLogger*>(png_get_error_ptr(readPtr));
+ logger->warn() << warningMessage << "." << std::endl;
+}
+
+
+static bool readPng(png_structp readPtr, png_infop infoPtr, PngInfo* outInfo,
+ std::string* outError) {
+ if (setjmp(png_jmpbuf(readPtr))) {
+ *outError = "failed reading png";
+ return false;
+ }
+
+ png_set_sig_bytes(readPtr, kPngSignatureSize);
+ png_read_info(readPtr, infoPtr);
+
+ int colorType, bitDepth, interlaceType, compressionType;
+ png_get_IHDR(readPtr, infoPtr, &outInfo->width, &outInfo->height, &bitDepth, &colorType,
+ &interlaceType, &compressionType, nullptr);
+
+ if (colorType == PNG_COLOR_TYPE_PALETTE) {
+ png_set_palette_to_rgb(readPtr);
+ }
+
+ if (colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8) {
+ png_set_expand_gray_1_2_4_to_8(readPtr);
+ }
+
+ if (png_get_valid(readPtr, infoPtr, PNG_INFO_tRNS)) {
+ png_set_tRNS_to_alpha(readPtr);
+ }
+
+ if (bitDepth == 16) {
+ png_set_strip_16(readPtr);
+ }
+
+ if (!(colorType & PNG_COLOR_MASK_ALPHA)) {
+ png_set_add_alpha(readPtr, 0xFF, PNG_FILLER_AFTER);
+ }
+
+ if (colorType == PNG_COLOR_TYPE_GRAY || colorType == PNG_COLOR_TYPE_GRAY_ALPHA) {
+ png_set_gray_to_rgb(readPtr);
+ }
+
+ png_set_interlace_handling(readPtr);
+ png_read_update_info(readPtr, infoPtr);
+
+ const uint32_t rowBytes = png_get_rowbytes(readPtr, infoPtr);
+ outInfo->rows.resize(outInfo->height);
+ for (size_t i = 0; i < outInfo->height; i++) {
+ outInfo->rows[i] = new png_byte[rowBytes];
+ }
+
+ png_read_image(readPtr, outInfo->rows.data());
+ png_read_end(readPtr, infoPtr);
+ return true;
+}
+
+static void checkNinePatchSerialization(android::Res_png_9patch* inPatch, void* data) {
+ size_t patchSize = inPatch->serializedSize();
+ void* newData = malloc(patchSize);
+ memcpy(newData, data, patchSize);
+ android::Res_png_9patch* outPatch = inPatch->deserialize(newData);
+ outPatch->fileToDevice();
+ // deserialization is done in place, so outPatch == newData
+ assert(outPatch == newData);
+ assert(outPatch->numXDivs == inPatch->numXDivs);
+ assert(outPatch->numYDivs == inPatch->numYDivs);
+ assert(outPatch->paddingLeft == inPatch->paddingLeft);
+ assert(outPatch->paddingRight == inPatch->paddingRight);
+ assert(outPatch->paddingTop == inPatch->paddingTop);
+ assert(outPatch->paddingBottom == inPatch->paddingBottom);
+/* for (int i = 0; i < outPatch->numXDivs; i++) {
+ assert(outPatch->getXDivs()[i] == inPatch->getXDivs()[i]);
+ }
+ for (int i = 0; i < outPatch->numYDivs; i++) {
+ assert(outPatch->getYDivs()[i] == inPatch->getYDivs()[i]);
+ }
+ for (int i = 0; i < outPatch->numColors; i++) {
+ assert(outPatch->getColors()[i] == inPatch->getColors()[i]);
+ }*/
+ free(newData);
+}
+
+/*static void dump_image(int w, int h, const png_byte* const* rows, int color_type) {
+ int i, j, rr, gg, bb, aa;
+
+ int bpp;
+ if (color_type == PNG_COLOR_TYPE_PALETTE || color_type == PNG_COLOR_TYPE_GRAY) {
+ bpp = 1;
+ } else if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
+ bpp = 2;
+ } else if (color_type == PNG_COLOR_TYPE_RGB || color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
+ // We use a padding byte even when there is no alpha
+ bpp = 4;
+ } else {
+ printf("Unknown color type %d.\n", color_type);
+ }
+
+ for (j = 0; j < h; j++) {
+ const png_byte* row = rows[j];
+ for (i = 0; i < w; i++) {
+ rr = row[0];
+ gg = row[1];
+ bb = row[2];
+ aa = row[3];
+ row += bpp;
+
+ if (i == 0) {
+ printf("Row %d:", j);
+ }
+ switch (bpp) {
+ case 1:
+ printf(" (%d)", rr);
+ break;
+ case 2:
+ printf(" (%d %d", rr, gg);
+ break;
+ case 3:
+ printf(" (%d %d %d)", rr, gg, bb);
+ break;
+ case 4:
+ printf(" (%d %d %d %d)", rr, gg, bb, aa);
+ break;
+ }
+ if (i == (w - 1)) {
+ printf("\n");
+ }
+ }
+ }
+}*/
+
+#define MAX(a,b) ((a)>(b)?(a):(b))
+#define ABS(a) ((a)<0?-(a):(a))
+
+static void analyze_image(SourceLogger* logger, const PngInfo& imageInfo, int grayscaleTolerance,
+ png_colorp rgbPalette, png_bytep alphaPalette,
+ int *paletteEntries, bool *hasTransparency, int *colorType,
+ png_bytepp outRows) {
+ int w = imageInfo.width;
+ int h = imageInfo.height;
+ int i, j, rr, gg, bb, aa, idx;
+ uint32_t colors[256], col;
+ int num_colors = 0;
+ int maxGrayDeviation = 0;
+
+ bool isOpaque = true;
+ bool isPalette = true;
+ bool isGrayscale = true;
+
+ // Scan the entire image and determine if:
+ // 1. Every pixel has R == G == B (grayscale)
+ // 2. Every pixel has A == 255 (opaque)
+ // 3. There are no more than 256 distinct RGBA colors
+
+ if (kDebug) {
+ printf("Initial image data:\n");
+ //dump_image(w, h, imageInfo.rows.data(), PNG_COLOR_TYPE_RGB_ALPHA);
+ }
+
+ for (j = 0; j < h; j++) {
+ const png_byte* row = imageInfo.rows[j];
+ png_bytep out = outRows[j];
+ for (i = 0; i < w; i++) {
+ rr = *row++;
+ gg = *row++;
+ bb = *row++;
+ aa = *row++;
+
+ int odev = maxGrayDeviation;
+ maxGrayDeviation = MAX(ABS(rr - gg), maxGrayDeviation);
+ maxGrayDeviation = MAX(ABS(gg - bb), maxGrayDeviation);
+ maxGrayDeviation = MAX(ABS(bb - rr), maxGrayDeviation);
+ if (maxGrayDeviation > odev) {
+ if (kDebug) {
+ printf("New max dev. = %d at pixel (%d, %d) = (%d %d %d %d)\n",
+ maxGrayDeviation, i, j, rr, gg, bb, aa);
+ }
+ }
+
+ // Check if image is really grayscale
+ if (isGrayscale) {
+ if (rr != gg || rr != bb) {
+ if (kDebug) {
+ printf("Found a non-gray pixel at %d, %d = (%d %d %d %d)\n",
+ i, j, rr, gg, bb, aa);
+ }
+ isGrayscale = false;
+ }
+ }
+
+ // Check if image is really opaque
+ if (isOpaque) {
+ if (aa != 0xff) {
+ if (kDebug) {
+ printf("Found a non-opaque pixel at %d, %d = (%d %d %d %d)\n",
+ i, j, rr, gg, bb, aa);
+ }
+ isOpaque = false;
+ }
+ }
+
+ // Check if image is really <= 256 colors
+ if (isPalette) {
+ col = (uint32_t) ((rr << 24) | (gg << 16) | (bb << 8) | aa);
+ bool match = false;
+ for (idx = 0; idx < num_colors; idx++) {
+ if (colors[idx] == col) {
+ match = true;
+ break;
+ }
+ }
+
+ // Write the palette index for the pixel to outRows optimistically
+ // We might overwrite it later if we decide to encode as gray or
+ // gray + alpha
+ *out++ = idx;
+ if (!match) {
+ if (num_colors == 256) {
+ if (kDebug) {
+ printf("Found 257th color at %d, %d\n", i, j);
+ }
+ isPalette = false;
+ } else {
+ colors[num_colors++] = col;
+ }
+ }
+ }
+ }
+ }
+
+ *paletteEntries = 0;
+ *hasTransparency = !isOpaque;
+ int bpp = isOpaque ? 3 : 4;
+ int paletteSize = w * h + bpp * num_colors;
+
+ if (kDebug) {
+ printf("isGrayscale = %s\n", isGrayscale ? "true" : "false");
+ printf("isOpaque = %s\n", isOpaque ? "true" : "false");
+ printf("isPalette = %s\n", isPalette ? "true" : "false");
+ printf("Size w/ palette = %d, gray+alpha = %d, rgb(a) = %d\n",
+ paletteSize, 2 * w * h, bpp * w * h);
+ printf("Max gray deviation = %d, tolerance = %d\n", maxGrayDeviation, grayscaleTolerance);
+ }
+
+ // Choose the best color type for the image.
+ // 1. Opaque gray - use COLOR_TYPE_GRAY at 1 byte/pixel
+ // 2. Gray + alpha - use COLOR_TYPE_PALETTE if the number of distinct combinations
+ // is sufficiently small, otherwise use COLOR_TYPE_GRAY_ALPHA
+ // 3. RGB(A) - use COLOR_TYPE_PALETTE if the number of distinct colors is sufficiently
+ // small, otherwise use COLOR_TYPE_RGB{_ALPHA}
+ if (isGrayscale) {
+ if (isOpaque) {
+ *colorType = PNG_COLOR_TYPE_GRAY; // 1 byte/pixel
+ } else {
+ // Use a simple heuristic to determine whether using a palette will
+ // save space versus using gray + alpha for each pixel.
+ // This doesn't take into account chunk overhead, filtering, LZ
+ // compression, etc.
+ if (isPalette && (paletteSize < 2 * w * h)) {
+ *colorType = PNG_COLOR_TYPE_PALETTE; // 1 byte/pixel + 4 bytes/color
+ } else {
+ *colorType = PNG_COLOR_TYPE_GRAY_ALPHA; // 2 bytes per pixel
+ }
+ }
+ } else if (isPalette && (paletteSize < bpp * w * h)) {
+ *colorType = PNG_COLOR_TYPE_PALETTE;
+ } else {
+ if (maxGrayDeviation <= grayscaleTolerance) {
+ logger->note() << "forcing image to gray (max deviation = " << maxGrayDeviation
+ << ")."
+ << std::endl;
+ *colorType = isOpaque ? PNG_COLOR_TYPE_GRAY : PNG_COLOR_TYPE_GRAY_ALPHA;
+ } else {
+ *colorType = isOpaque ? PNG_COLOR_TYPE_RGB : PNG_COLOR_TYPE_RGB_ALPHA;
+ }
+ }
+
+ // Perform postprocessing of the image or palette data based on the final
+ // color type chosen
+
+ if (*colorType == PNG_COLOR_TYPE_PALETTE) {
+ // Create separate RGB and Alpha palettes and set the number of colors
+ *paletteEntries = num_colors;
+
+ // Create the RGB and alpha palettes
+ for (int idx = 0; idx < num_colors; idx++) {
+ col = colors[idx];
+ rgbPalette[idx].red = (png_byte) ((col >> 24) & 0xff);
+ rgbPalette[idx].green = (png_byte) ((col >> 16) & 0xff);
+ rgbPalette[idx].blue = (png_byte) ((col >> 8) & 0xff);
+ alphaPalette[idx] = (png_byte) (col & 0xff);
+ }
+ } else if (*colorType == PNG_COLOR_TYPE_GRAY || *colorType == PNG_COLOR_TYPE_GRAY_ALPHA) {
+ // If the image is gray or gray + alpha, compact the pixels into outRows
+ for (j = 0; j < h; j++) {
+ const png_byte* row = imageInfo.rows[j];
+ png_bytep out = outRows[j];
+ for (i = 0; i < w; i++) {
+ rr = *row++;
+ gg = *row++;
+ bb = *row++;
+ aa = *row++;
+
+ if (isGrayscale) {
+ *out++ = rr;
+ } else {
+ *out++ = (png_byte) (rr * 0.2126f + gg * 0.7152f + bb * 0.0722f);
+ }
+ if (!isOpaque) {
+ *out++ = aa;
+ }
+ }
+ }
+ }
+}
+
+static bool writePng(png_structp writePtr, png_infop infoPtr, PngInfo* info,
+ int grayScaleTolerance, SourceLogger* logger, std::string* outError) {
+ if (setjmp(png_jmpbuf(writePtr))) {
+ *outError = "failed to write png";
+ return false;
+ }
+
+ uint32_t width, height;
+ int colorType, bitDepth, interlaceType, compressionType;
+
+ png_unknown_chunk unknowns[3];
+ unknowns[0].data = nullptr;
+ unknowns[1].data = nullptr;
+ unknowns[2].data = nullptr;
+
+ png_bytepp outRows = (png_bytepp) malloc((int) info->height * sizeof(png_bytep));
+ if (outRows == (png_bytepp) 0) {
+ printf("Can't allocate output buffer!\n");
+ exit(1);
+ }
+ for (uint32_t i = 0; i < info->height; i++) {
+ outRows[i] = (png_bytep) malloc(2 * (int) info->width);
+ if (outRows[i] == (png_bytep) 0) {
+ printf("Can't allocate output buffer!\n");
+ exit(1);
+ }
+ }
+
+ png_set_compression_level(writePtr, Z_BEST_COMPRESSION);
+
+ if (kDebug) {
+ logger->note() << "writing image: w = " << info->width
+ << ", h = " << info->height
+ << std::endl;
+ }
+
+ png_color rgbPalette[256];
+ png_byte alphaPalette[256];
+ bool hasTransparency;
+ int paletteEntries;
+
+ analyze_image(logger, *info, grayScaleTolerance, rgbPalette, alphaPalette,
+ &paletteEntries, &hasTransparency, &colorType, outRows);
+
+ // If the image is a 9-patch, we need to preserve it as a ARGB file to make
+ // sure the pixels will not be pre-dithered/clamped until we decide they are
+ if (info->is9Patch && (colorType == PNG_COLOR_TYPE_RGB ||
+ colorType == PNG_COLOR_TYPE_GRAY || colorType == PNG_COLOR_TYPE_PALETTE)) {
+ colorType = PNG_COLOR_TYPE_RGB_ALPHA;
+ }
+
+ if (kDebug) {
+ switch (colorType) {
+ case PNG_COLOR_TYPE_PALETTE:
+ logger->note() << "has " << paletteEntries
+ << " colors" << (hasTransparency ? " (with alpha)" : "")
+ << ", using PNG_COLOR_TYPE_PALLETTE."
+ << std::endl;
+ break;
+ case PNG_COLOR_TYPE_GRAY:
+ logger->note() << "is opaque gray, using PNG_COLOR_TYPE_GRAY." << std::endl;
+ break;
+ case PNG_COLOR_TYPE_GRAY_ALPHA:
+ logger->note() << "is gray + alpha, using PNG_COLOR_TYPE_GRAY_ALPHA." << std::endl;
+ break;
+ case PNG_COLOR_TYPE_RGB:
+ logger->note() << "is opaque RGB, using PNG_COLOR_TYPE_RGB." << std::endl;
+ break;
+ case PNG_COLOR_TYPE_RGB_ALPHA:
+ logger->note() << "is RGB + alpha, using PNG_COLOR_TYPE_RGB_ALPHA." << std::endl;
+ break;
+ }
+ }
+
+ png_set_IHDR(writePtr, infoPtr, info->width, info->height, 8, colorType,
+ PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+
+ if (colorType == PNG_COLOR_TYPE_PALETTE) {
+ png_set_PLTE(writePtr, infoPtr, rgbPalette, paletteEntries);
+ if (hasTransparency) {
+ png_set_tRNS(writePtr, infoPtr, alphaPalette, paletteEntries, (png_color_16p) 0);
+ }
+ png_set_filter(writePtr, 0, PNG_NO_FILTERS);
+ } else {
+ png_set_filter(writePtr, 0, PNG_ALL_FILTERS);
+ }
+
+ if (info->is9Patch) {
+ int chunkCount = 2 + (info->haveLayoutBounds ? 1 : 0);
+ int pIndex = info->haveLayoutBounds ? 2 : 1;
+ int bIndex = 1;
+ int oIndex = 0;
+
+ // Chunks ordered thusly because older platforms depend on the base 9 patch data being last
+ png_bytep chunkNames = info->haveLayoutBounds
+ ? (png_bytep)"npOl\0npLb\0npTc\0"
+ : (png_bytep)"npOl\0npTc";
+
+ // base 9 patch data
+ if (kDebug) {
+ logger->note() << "adding 9-patch info..." << std::endl;
+ }
+ strcpy((char*)unknowns[pIndex].name, "npTc");
+ unknowns[pIndex].data = (png_byte*) info->serialize9Patch();
+ unknowns[pIndex].size = info->info9Patch.serializedSize();
+ // TODO: remove the check below when everything works
+ checkNinePatchSerialization(&info->info9Patch, unknowns[pIndex].data);
+
+ // automatically generated 9 patch outline data
+ int chunkSize = sizeof(png_uint_32) * 6;
+ strcpy((char*)unknowns[oIndex].name, "npOl");
+ unknowns[oIndex].data = (png_byte*) calloc(chunkSize, 1);
+ png_byte outputData[chunkSize];
+ memcpy(&outputData, &info->outlineInsetsLeft, 4 * sizeof(png_uint_32));
+ ((float*) outputData)[4] = info->outlineRadius;
+ ((png_uint_32*) outputData)[5] = info->outlineAlpha;
+ memcpy(unknowns[oIndex].data, &outputData, chunkSize);
+ unknowns[oIndex].size = chunkSize;
+
+ // optional optical inset / layout bounds data
+ if (info->haveLayoutBounds) {
+ int chunkSize = sizeof(png_uint_32) * 4;
+ strcpy((char*)unknowns[bIndex].name, "npLb");
+ unknowns[bIndex].data = (png_byte*) calloc(chunkSize, 1);
+ memcpy(unknowns[bIndex].data, &info->layoutBoundsLeft, chunkSize);
+ unknowns[bIndex].size = chunkSize;
+ }
+
+ for (int i = 0; i < chunkCount; i++) {
+ unknowns[i].location = PNG_HAVE_PLTE;
+ }
+ png_set_keep_unknown_chunks(writePtr, PNG_HANDLE_CHUNK_ALWAYS,
+ chunkNames, chunkCount);
+ png_set_unknown_chunks(writePtr, infoPtr, unknowns, chunkCount);
+
+#if PNG_LIBPNG_VER < 10600
+ // Deal with unknown chunk location bug in 1.5.x and earlier.
+ png_set_unknown_chunk_location(writePtr, infoPtr, 0, PNG_HAVE_PLTE);
+ if (info->haveLayoutBounds) {
+ png_set_unknown_chunk_location(writePtr, infoPtr, 1, PNG_HAVE_PLTE);
+ }
+#endif
+ }
+
+ png_write_info(writePtr, infoPtr);
+
+ png_bytepp rows;
+ if (colorType == PNG_COLOR_TYPE_RGB || colorType == PNG_COLOR_TYPE_RGB_ALPHA) {
+ if (colorType == PNG_COLOR_TYPE_RGB) {
+ png_set_filler(writePtr, 0, PNG_FILLER_AFTER);
+ }
+ rows = info->rows.data();
+ } else {
+ rows = outRows;
+ }
+ png_write_image(writePtr, rows);
+
+ if (kDebug) {
+ printf("Final image data:\n");
+ //dump_image(info->width, info->height, rows, colorType);
+ }
+
+ png_write_end(writePtr, infoPtr);
+
+ for (uint32_t i = 0; i < info->height; i++) {
+ free(outRows[i]);
+ }
+ free(outRows);
+ free(unknowns[0].data);
+ free(unknowns[1].data);
+ free(unknowns[2].data);
+
+ png_get_IHDR(writePtr, infoPtr, &width, &height, &bitDepth, &colorType, &interlaceType,
+ &compressionType, nullptr);
+
+ if (kDebug) {
+ logger->note() << "image written: w = " << width << ", h = " << height
+ << ", d = " << bitDepth << ", colors = " << colorType
+ << ", inter = " << interlaceType << ", comp = " << compressionType
+ << std::endl;
+ }
+ return true;
+}
+
+constexpr uint32_t kColorWhite = 0xffffffffu;
+constexpr uint32_t kColorTick = 0xff000000u;
+constexpr uint32_t kColorLayoutBoundsTick = 0xff0000ffu;
+
+enum class TickType {
+ kNone,
+ kTick,
+ kLayoutBounds,
+ kBoth
+};
+
+static TickType tickType(png_bytep p, bool transparent, const char** outError) {
+ png_uint_32 color = p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
+
+ if (transparent) {
+ if (p[3] == 0) {
+ return TickType::kNone;
+ }
+ if (color == kColorLayoutBoundsTick) {
+ return TickType::kLayoutBounds;
+ }
+ if (color == kColorTick) {
+ return TickType::kTick;
+ }
+
+ // Error cases
+ if (p[3] != 0xff) {
+ *outError = "Frame pixels must be either solid or transparent "
+ "(not intermediate alphas)";
+ return TickType::kNone;
+ }
+
+ if (p[0] != 0 || p[1] != 0 || p[2] != 0) {
+ *outError = "Ticks in transparent frame must be black or red";
+ }
+ return TickType::kTick;
+ }
+
+ if (p[3] != 0xFF) {
+ *outError = "White frame must be a solid color (no alpha)";
+ }
+ if (color == kColorWhite) {
+ return TickType::kNone;
+ }
+ if (color == kColorTick) {
+ return TickType::kTick;
+ }
+ if (color == kColorLayoutBoundsTick) {
+ return TickType::kLayoutBounds;
+ }
+
+ if (p[0] != 0 || p[1] != 0 || p[2] != 0) {
+ *outError = "Ticks in white frame must be black or red";
+ return TickType::kNone;
+ }
+ return TickType::kTick;
+}
+
+enum class TickState {
+ kStart,
+ kInside1,
+ kOutside1
+};
+
+static bool getHorizontalTicks(png_bytep row, int width, bool transparent, bool required,
+ int32_t* outLeft, int32_t* outRight, const char** outError,
+ uint8_t* outDivs, bool multipleAllowed) {
+ *outLeft = *outRight = -1;
+ TickState state = TickState::kStart;
+ bool found = false;
+
+ for (int i = 1; i < width - 1; i++) {
+ if (tickType(row+i*4, transparent, outError) == TickType::kTick) {
+ if (state == TickState::kStart ||
+ (state == TickState::kOutside1 && multipleAllowed)) {
+ *outLeft = i-1;
+ *outRight = width-2;
+ found = true;
+ if (outDivs != NULL) {
+ *outDivs += 2;
+ }
+ state = TickState::kInside1;
+ } else if (state == TickState::kOutside1) {
+ *outError = "Can't have more than one marked region along edge";
+ *outLeft = i;
+ return false;
+ }
+ } else if (!*outError) {
+ if (state == TickState::kInside1) {
+ // We're done with this div. Move on to the next.
+ *outRight = i-1;
+ outRight += 2;
+ outLeft += 2;
+ state = TickState::kOutside1;
+ }
+ } else {
+ *outLeft = i;
+ return false;
+ }
+ }
+
+ if (required && !found) {
+ *outError = "No marked region found along edge";
+ *outLeft = -1;
+ return false;
+ }
+ return true;
+}
+
+static bool getVerticalTicks(png_bytepp rows, int offset, int height, bool transparent,
+ bool required, int32_t* outTop, int32_t* outBottom,
+ const char** outError, uint8_t* outDivs, bool multipleAllowed) {
+ *outTop = *outBottom = -1;
+ TickState state = TickState::kStart;
+ bool found = false;
+
+ for (int i = 1; i < height - 1; i++) {
+ if (tickType(rows[i]+offset, transparent, outError) == TickType::kTick) {
+ if (state == TickState::kStart ||
+ (state == TickState::kOutside1 && multipleAllowed)) {
+ *outTop = i-1;
+ *outBottom = height-2;
+ found = true;
+ if (outDivs != NULL) {
+ *outDivs += 2;
+ }
+ state = TickState::kInside1;
+ } else if (state == TickState::kOutside1) {
+ *outError = "Can't have more than one marked region along edge";
+ *outTop = i;
+ return false;
+ }
+ } else if (!*outError) {
+ if (state == TickState::kInside1) {
+ // We're done with this div. Move on to the next.
+ *outBottom = i-1;
+ outTop += 2;
+ outBottom += 2;
+ state = TickState::kOutside1;
+ }
+ } else {
+ *outTop = i;
+ return false;
+ }
+ }
+
+ if (required && !found) {
+ *outError = "No marked region found along edge";
+ *outTop = -1;
+ return false;
+ }
+ return true;
+}
+
+static bool getHorizontalLayoutBoundsTicks(png_bytep row, int width, bool transparent,
+ bool /* required */, int32_t* outLeft,
+ int32_t* outRight, const char** outError) {
+ *outLeft = *outRight = 0;
+
+ // Look for left tick
+ if (tickType(row + 4, transparent, outError) == TickType::kLayoutBounds) {
+ // Starting with a layout padding tick
+ int i = 1;
+ while (i < width - 1) {
+ (*outLeft)++;
+ i++;
+ if (tickType(row + i * 4, transparent, outError) != TickType::kLayoutBounds) {
+ break;
+ }
+ }
+ }
+
+ // Look for right tick
+ if (tickType(row + (width - 2) * 4, transparent, outError) == TickType::kLayoutBounds) {
+ // Ending with a layout padding tick
+ int i = width - 2;
+ while (i > 1) {
+ (*outRight)++;
+ i--;
+ if (tickType(row+i*4, transparent, outError) != TickType::kLayoutBounds) {
+ break;
+ }
+ }
+ }
+ return true;
+}
+
+static bool getVerticalLayoutBoundsTicks(png_bytepp rows, int offset, int height, bool transparent,
+ bool /* required */, int32_t* outTop, int32_t* outBottom,
+ const char** outError) {
+ *outTop = *outBottom = 0;
+
+ // Look for top tick
+ if (tickType(rows[1] + offset, transparent, outError) == TickType::kLayoutBounds) {
+ // Starting with a layout padding tick
+ int i = 1;
+ while (i < height - 1) {
+ (*outTop)++;
+ i++;
+ if (tickType(rows[i] + offset, transparent, outError) != TickType::kLayoutBounds) {
+ break;
+ }
+ }
+ }
+
+ // Look for bottom tick
+ if (tickType(rows[height - 2] + offset, transparent, outError) == TickType::kLayoutBounds) {
+ // Ending with a layout padding tick
+ int i = height - 2;
+ while (i > 1) {
+ (*outBottom)++;
+ i--;
+ if (tickType(rows[i] + offset, transparent, outError) != TickType::kLayoutBounds) {
+ break;
+ }
+ }
+ }
+ return true;
+}
+
+static void findMaxOpacity(png_bytepp rows, int startX, int startY, int endX, int endY,
+ int dX, int dY, int* outInset) {
+ uint8_t maxOpacity = 0;
+ int inset = 0;
+ *outInset = 0;
+ for (int x = startX, y = startY; x != endX && y != endY; x += dX, y += dY, inset++) {
+ png_byte* color = rows[y] + x * 4;
+ uint8_t opacity = color[3];
+ if (opacity > maxOpacity) {
+ maxOpacity = opacity;
+ *outInset = inset;
+ }
+ if (opacity == 0xff) return;
+ }
+}
+
+static uint8_t maxAlphaOverRow(png_bytep row, int startX, int endX) {
+ uint8_t maxAlpha = 0;
+ for (int x = startX; x < endX; x++) {
+ uint8_t alpha = (row + x * 4)[3];
+ if (alpha > maxAlpha) maxAlpha = alpha;
+ }
+ return maxAlpha;
+}
+
+static uint8_t maxAlphaOverCol(png_bytepp rows, int offsetX, int startY, int endY) {
+ uint8_t maxAlpha = 0;
+ for (int y = startY; y < endY; y++) {
+ uint8_t alpha = (rows[y] + offsetX * 4)[3];
+ if (alpha > maxAlpha) maxAlpha = alpha;
+ }
+ return maxAlpha;
+}
+
+static void getOutline(PngInfo* image) {
+ int midX = image->width / 2;
+ int midY = image->height / 2;
+ int endX = image->width - 2;
+ int endY = image->height - 2;
+
+ // find left and right extent of nine patch content on center row
+ if (image->width > 4) {
+ findMaxOpacity(image->rows.data(), 1, midY, midX, -1, 1, 0, &image->outlineInsetsLeft);
+ findMaxOpacity(image->rows.data(), endX, midY, midX, -1, -1, 0,
+ &image->outlineInsetsRight);
+ } else {
+ image->outlineInsetsLeft = 0;
+ image->outlineInsetsRight = 0;
+ }
+
+ // find top and bottom extent of nine patch content on center column
+ if (image->height > 4) {
+ findMaxOpacity(image->rows.data(), midX, 1, -1, midY, 0, 1, &image->outlineInsetsTop);
+ findMaxOpacity(image->rows.data(), midX, endY, -1, midY, 0, -1,
+ &image->outlineInsetsBottom);
+ } else {
+ image->outlineInsetsTop = 0;
+ image->outlineInsetsBottom = 0;
+ }
+
+ int innerStartX = 1 + image->outlineInsetsLeft;
+ int innerStartY = 1 + image->outlineInsetsTop;
+ int innerEndX = endX - image->outlineInsetsRight;
+ int innerEndY = endY - image->outlineInsetsBottom;
+ int innerMidX = (innerEndX + innerStartX) / 2;
+ int innerMidY = (innerEndY + innerStartY) / 2;
+
+ // assuming the image is a round rect, compute the radius by marching
+ // diagonally from the top left corner towards the center
+ image->outlineAlpha = std::max(
+ maxAlphaOverRow(image->rows[innerMidY], innerStartX, innerEndX),
+ maxAlphaOverCol(image->rows.data(), innerMidX, innerStartY, innerStartY));
+
+ int diagonalInset = 0;
+ findMaxOpacity(image->rows.data(), innerStartX, innerStartY, innerMidX, innerMidY, 1, 1,
+ &diagonalInset);
+
+ /* Determine source radius based upon inset:
+ * sqrt(r^2 + r^2) = sqrt(i^2 + i^2) + r
+ * sqrt(2) * r = sqrt(2) * i + r
+ * (sqrt(2) - 1) * r = sqrt(2) * i
+ * r = sqrt(2) / (sqrt(2) - 1) * i
+ */
+ image->outlineRadius = 3.4142f * diagonalInset;
+
+ if (kDebug) {
+ printf("outline insets %d %d %d %d, rad %f, alpha %x\n",
+ image->outlineInsetsLeft,
+ image->outlineInsetsTop,
+ image->outlineInsetsRight,
+ image->outlineInsetsBottom,
+ image->outlineRadius,
+ image->outlineAlpha);
+ }
+}
+
+static uint32_t getColor(png_bytepp rows, int left, int top, int right, int bottom) {
+ png_bytep color = rows[top] + left*4;
+
+ if (left > right || top > bottom) {
+ return android::Res_png_9patch::TRANSPARENT_COLOR;
+ }
+
+ while (top <= bottom) {
+ for (int i = left; i <= right; i++) {
+ png_bytep p = rows[top]+i*4;
+ if (color[3] == 0) {
+ if (p[3] != 0) {
+ return android::Res_png_9patch::NO_COLOR;
+ }
+ } else if (p[0] != color[0] || p[1] != color[1] ||
+ p[2] != color[2] || p[3] != color[3]) {
+ return android::Res_png_9patch::NO_COLOR;
+ }
+ }
+ top++;
+ }
+
+ if (color[3] == 0) {
+ return android::Res_png_9patch::TRANSPARENT_COLOR;
+ }
+ return (color[3]<<24) | (color[0]<<16) | (color[1]<<8) | color[2];
+}
+
+static bool do9Patch(PngInfo* image, std::string* outError) {
+ image->is9Patch = true;
+
+ int W = image->width;
+ int H = image->height;
+ int i, j;
+
+ const int maxSizeXDivs = W * sizeof(int32_t);
+ const int maxSizeYDivs = H * sizeof(int32_t);
+ int32_t* xDivs = image->xDivs = new int32_t[W];
+ int32_t* yDivs = image->yDivs = new int32_t[H];
+ uint8_t numXDivs = 0;
+ uint8_t numYDivs = 0;
+
+ int8_t numColors;
+ int numRows;
+ int numCols;
+ int top;
+ int left;
+ int right;
+ int bottom;
+ memset(xDivs, -1, maxSizeXDivs);
+ memset(yDivs, -1, maxSizeYDivs);
+ image->info9Patch.paddingLeft = image->info9Patch.paddingRight = -1;
+ image->info9Patch.paddingTop = image->info9Patch.paddingBottom = -1;
+ image->layoutBoundsLeft = image->layoutBoundsRight = 0;
+ image->layoutBoundsTop = image->layoutBoundsBottom = 0;
+
+ png_bytep p = image->rows[0];
+ bool transparent = p[3] == 0;
+ bool hasColor = false;
+
+ const char* errorMsg = nullptr;
+ int errorPixel = -1;
+ const char* errorEdge = nullptr;
+
+ int colorIndex = 0;
+ std::vector<png_bytep> newRows;
+
+ // Validate size...
+ if (W < 3 || H < 3) {
+ errorMsg = "Image must be at least 3x3 (1x1 without frame) pixels";
+ goto getout;
+ }
+
+ // Validate frame...
+ if (!transparent &&
+ (p[0] != 0xFF || p[1] != 0xFF || p[2] != 0xFF || p[3] != 0xFF)) {
+ errorMsg = "Must have one-pixel frame that is either transparent or white";
+ goto getout;
+ }
+
+ // Find left and right of sizing areas...
+ if (!getHorizontalTicks(p, W, transparent, true, &xDivs[0], &xDivs[1], &errorMsg, &numXDivs,
+ true)) {
+ errorPixel = xDivs[0];
+ errorEdge = "top";
+ goto getout;
+ }
+
+ // Find top and bottom of sizing areas...
+ if (!getVerticalTicks(image->rows.data(), 0, H, transparent, true, &yDivs[0], &yDivs[1],
+ &errorMsg, &numYDivs, true)) {
+ errorPixel = yDivs[0];
+ errorEdge = "left";
+ goto getout;
+ }
+
+ // Copy patch size data into image...
+ image->info9Patch.numXDivs = numXDivs;
+ image->info9Patch.numYDivs = numYDivs;
+
+ // Find left and right of padding area...
+ if (!getHorizontalTicks(image->rows[H-1], W, transparent, false,
+ &image->info9Patch.paddingLeft, &image->info9Patch.paddingRight,
+ &errorMsg, nullptr, false)) {
+ errorPixel = image->info9Patch.paddingLeft;
+ errorEdge = "bottom";
+ goto getout;
+ }
+
+ // Find top and bottom of padding area...
+ if (!getVerticalTicks(image->rows.data(), (W-1)*4, H, transparent, false,
+ &image->info9Patch.paddingTop, &image->info9Patch.paddingBottom,
+ &errorMsg, nullptr, false)) {
+ errorPixel = image->info9Patch.paddingTop;
+ errorEdge = "right";
+ goto getout;
+ }
+
+ // Find left and right of layout padding...
+ getHorizontalLayoutBoundsTicks(image->rows[H-1], W, transparent, false,
+ &image->layoutBoundsLeft, &image->layoutBoundsRight, &errorMsg);
+
+ getVerticalLayoutBoundsTicks(image->rows.data(), (W-1)*4, H, transparent, false,
+ &image->layoutBoundsTop, &image->layoutBoundsBottom, &errorMsg);
+
+ image->haveLayoutBounds = image->layoutBoundsLeft != 0
+ || image->layoutBoundsRight != 0
+ || image->layoutBoundsTop != 0
+ || image->layoutBoundsBottom != 0;
+
+ if (image->haveLayoutBounds) {
+ if (kDebug) {
+ printf("layoutBounds=%d %d %d %d\n", image->layoutBoundsLeft, image->layoutBoundsTop,
+ image->layoutBoundsRight, image->layoutBoundsBottom);
+ }
+ }
+
+ // use opacity of pixels to estimate the round rect outline
+ getOutline(image);
+
+ // If padding is not yet specified, take values from size.
+ if (image->info9Patch.paddingLeft < 0) {
+ image->info9Patch.paddingLeft = xDivs[0];
+ image->info9Patch.paddingRight = W - 2 - xDivs[1];
+ } else {
+ // Adjust value to be correct!
+ image->info9Patch.paddingRight = W - 2 - image->info9Patch.paddingRight;
+ }
+ if (image->info9Patch.paddingTop < 0) {
+ image->info9Patch.paddingTop = yDivs[0];
+ image->info9Patch.paddingBottom = H - 2 - yDivs[1];
+ } else {
+ // Adjust value to be correct!
+ image->info9Patch.paddingBottom = H - 2 - image->info9Patch.paddingBottom;
+ }
+
+/* if (kDebug) {
+ printf("Size ticks for %s: x0=%d, x1=%d, y0=%d, y1=%d\n", imageName,
+ xDivs[0], xDivs[1],
+ yDivs[0], yDivs[1]);
+ printf("padding ticks for %s: l=%d, r=%d, t=%d, b=%d\n", imageName,
+ image->info9Patch.paddingLeft, image->info9Patch.paddingRight,
+ image->info9Patch.paddingTop, image->info9Patch.paddingBottom);
+ }*/
+
+ // Remove frame from image.
+ newRows.resize(H - 2);
+ for (i = 0; i < H - 2; i++) {
+ newRows[i] = image->rows[i + 1];
+ memmove(newRows[i], newRows[i] + 4, (W - 2) * 4);
+ }
+ image->rows.swap(newRows);
+
+ image->width -= 2;
+ W = image->width;
+ image->height -= 2;
+ H = image->height;
+
+ // Figure out the number of rows and columns in the N-patch
+ numCols = numXDivs + 1;
+ if (xDivs[0] == 0) { // Column 1 is strechable
+ numCols--;
+ }
+ if (xDivs[numXDivs - 1] == W) {
+ numCols--;
+ }
+ numRows = numYDivs + 1;
+ if (yDivs[0] == 0) { // Row 1 is strechable
+ numRows--;
+ }
+ if (yDivs[numYDivs - 1] == H) {
+ numRows--;
+ }
+
+ // Make sure the amount of rows and columns will fit in the number of
+ // colors we can use in the 9-patch format.
+ if (numRows * numCols > 0x7F) {
+ errorMsg = "Too many rows and columns in 9-patch perimeter";
+ goto getout;
+ }
+
+ numColors = numRows * numCols;
+ image->info9Patch.numColors = numColors;
+ image->colors.resize(numColors);
+
+ // Fill in color information for each patch.
+
+ uint32_t c;
+ top = 0;
+
+ // The first row always starts with the top being at y=0 and the bottom
+ // being either yDivs[1] (if yDivs[0]=0) of yDivs[0]. In the former case
+ // the first row is stretchable along the Y axis, otherwise it is fixed.
+ // The last row always ends with the bottom being bitmap.height and the top
+ // being either yDivs[numYDivs-2] (if yDivs[numYDivs-1]=bitmap.height) or
+ // yDivs[numYDivs-1]. In the former case the last row is stretchable along
+ // the Y axis, otherwise it is fixed.
+ //
+ // The first and last columns are similarly treated with respect to the X
+ // axis.
+ //
+ // The above is to help explain some of the special casing that goes on the
+ // code below.
+
+ // The initial yDiv and whether the first row is considered stretchable or
+ // not depends on whether yDiv[0] was zero or not.
+ for (j = (yDivs[0] == 0 ? 1 : 0); j <= numYDivs && top < H; j++) {
+ if (j == numYDivs) {
+ bottom = H;
+ } else {
+ bottom = yDivs[j];
+ }
+ left = 0;
+ // The initial xDiv and whether the first column is considered
+ // stretchable or not depends on whether xDiv[0] was zero or not.
+ for (i = xDivs[0] == 0 ? 1 : 0; i <= numXDivs && left < W; i++) {
+ if (i == numXDivs) {
+ right = W;
+ } else {
+ right = xDivs[i];
+ }
+ c = getColor(image->rows.data(), left, top, right - 1, bottom - 1);
+ image->colors[colorIndex++] = c;
+ if (kDebug) {
+ if (c != android::Res_png_9patch::NO_COLOR) {
+ hasColor = true;
+ }
+ }
+ left = right;
+ }
+ top = bottom;
+ }
+
+ assert(colorIndex == numColors);
+
+ if (kDebug && hasColor) {
+ for (i = 0; i < numColors; i++) {
+ if (i == 0) printf("Colors:\n");
+ printf(" #%08x", image->colors[i]);
+ if (i == numColors - 1) printf("\n");
+ }
+ }
+getout:
+ if (errorMsg) {
+ std::stringstream err;
+ err << "9-patch malformed: " << errorMsg;
+ if (!errorEdge) {
+ err << "." << std::endl;
+ if (errorPixel >= 0) {
+ err << "Found at pixel #" << errorPixel << " along " << errorEdge << " edge";
+ } else {
+ err << "Found along " << errorEdge << " edge";
+ }
+ }
+ *outError = err.str();
+ return false;
+ }
+ return true;
+}
+
+
+bool Png::process(const Source& source, std::istream& input, std::ostream& output,
+ const Options& options, std::string* outError) {
+ png_byte signature[kPngSignatureSize];
+
+ // Read the PNG signature first.
+ if (!input.read(reinterpret_cast<char*>(signature), kPngSignatureSize)) {
+ *outError = strerror(errno);
+ return false;
+ }
+
+ // If the PNG signature doesn't match, bail early.
+ if (png_sig_cmp(signature, 0, kPngSignatureSize) != 0) {
+ *outError = "not a valid png file";
+ return false;
+ }
+
+ SourceLogger logger(source);
+ bool result = false;
+ png_structp readPtr = nullptr;
+ png_infop infoPtr = nullptr;
+ png_structp writePtr = nullptr;
+ png_infop writeInfoPtr = nullptr;
+ PngInfo pngInfo = {};
+
+ readPtr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, nullptr, nullptr);
+ if (!readPtr) {
+ *outError = "failed to allocate read ptr";
+ goto bail;
+ }
+
+ infoPtr = png_create_info_struct(readPtr);
+ if (!infoPtr) {
+ *outError = "failed to allocate info ptr";
+ goto bail;
+ }
+
+ png_set_error_fn(readPtr, reinterpret_cast<png_voidp>(&logger), nullptr, logWarning);
+
+ // Set the read function to read from std::istream.
+ png_set_read_fn(readPtr, (png_voidp)&input, readDataFromStream);
+
+ if (!readPng(readPtr, infoPtr, &pngInfo, outError)) {
+ goto bail;
+ }
+
+ if (util::stringEndsWith(source.path, ".9.png")) {
+ if (!do9Patch(&pngInfo, outError)) {
+ goto bail;
+ }
+ }
+
+ writePtr = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, nullptr, nullptr);
+ if (!writePtr) {
+ *outError = "failed to allocate write ptr";
+ goto bail;
+ }
+
+ writeInfoPtr = png_create_info_struct(writePtr);
+ if (!writeInfoPtr) {
+ *outError = "failed to allocate write info ptr";
+ goto bail;
+ }
+
+ png_set_error_fn(writePtr, nullptr, nullptr, logWarning);
+
+ // Set the write function to write to std::ostream.
+ png_set_write_fn(writePtr, (png_voidp)&output, writeDataToStream, flushDataToStream);
+
+ if (!writePng(writePtr, writeInfoPtr, &pngInfo, options.grayScaleTolerance, &logger,
+ outError)) {
+ goto bail;
+ }
+
+ result = true;
+bail:
+ if (readPtr) {
+ png_destroy_read_struct(&readPtr, &infoPtr, nullptr);
+ }
+
+ if (writePtr) {
+ png_destroy_write_struct(&writePtr, &writeInfoPtr);
+ }
+ return result;
+}
+
+} // namespace aapt
OSDN Git Service
