mtklein@google.com | a7a9f37 | 2013-10-18 20:52:44 +0000 | [diff] [blame] | 1 | #include "DMWriteTask.h" |
| 2 | |
scroggo | 7a10fb6 | 2014-11-04 07:21:10 -0800 | [diff] [blame] | 3 | #include "DMJsonWriter.h" |
mtklein@google.com | a7a9f37 | 2013-10-18 20:52:44 +0000 | [diff] [blame] | 4 | #include "DMUtil.h" |
commit-bot@chromium.org | 389fb7f | 2014-01-15 21:28:25 +0000 | [diff] [blame] | 5 | #include "SkColorPriv.h" |
caryclark | 17f0b6d | 2014-07-22 10:15:34 -0700 | [diff] [blame] | 6 | #include "SkCommonFlags.h" |
mtklein | 197ceda | 2014-09-09 07:36:57 -0700 | [diff] [blame] | 7 | #include "SkData.h" |
mtklein@google.com | a7a9f37 | 2013-10-18 20:52:44 +0000 | [diff] [blame] | 8 | #include "SkImageEncoder.h" |
mtklein | 1d0f164 | 2014-09-08 08:05:18 -0700 | [diff] [blame] | 9 | #include "SkMD5.h" |
commit-bot@chromium.org | eef834f | 2014-03-05 15:37:11 +0000 | [diff] [blame] | 10 | #include "SkMallocPixelRef.h" |
mtklein | 1d0f164 | 2014-09-08 08:05:18 -0700 | [diff] [blame] | 11 | #include "SkOSFile.h" |
commit-bot@chromium.org | 1426c1e | 2014-03-03 15:43:56 +0000 | [diff] [blame] | 12 | #include "SkStream.h" |
commit-bot@chromium.org | eef834f | 2014-03-05 15:37:11 +0000 | [diff] [blame] | 13 | #include "SkString.h" |
mtklein@google.com | a7a9f37 | 2013-10-18 20:52:44 +0000 | [diff] [blame] | 14 | |
mtklein | 858baf5 | 2014-09-08 11:33:48 -0700 | [diff] [blame] | 15 | DEFINE_bool(nameByHash, false, "If true, write .../hash.png instead of .../mode/config/name.png"); |
| 16 | |
mtklein@google.com | a7a9f37 | 2013-10-18 20:52:44 +0000 | [diff] [blame] | 17 | namespace DM { |
| 18 | |
commit-bot@chromium.org | 99589af | 2013-12-10 14:53:16 +0000 | [diff] [blame] | 19 | // Splits off the last N suffixes of name (splitting on _) and appends them to out. |
| 20 | // Returns the total number of characters consumed. |
| 21 | static int split_suffixes(int N, const char* name, SkTArray<SkString>* out) { |
rmistry@google.com | d6bab02 | 2013-12-02 13:50:38 +0000 | [diff] [blame] | 22 | SkTArray<SkString> split; |
| 23 | SkStrSplit(name, "_", &split); |
commit-bot@chromium.org | 99589af | 2013-12-10 14:53:16 +0000 | [diff] [blame] | 24 | int consumed = 0; |
| 25 | for (int i = 0; i < N; i++) { |
rmistry@google.com | d6bab02 | 2013-12-02 13:50:38 +0000 | [diff] [blame] | 26 | // We're splitting off suffixes from the back to front. |
commit-bot@chromium.org | 99589af | 2013-12-10 14:53:16 +0000 | [diff] [blame] | 27 | out->push_back(split[split.count()-i-1]); |
| 28 | consumed += out->back().size() + 1; // Add one for the _. |
rmistry@google.com | d6bab02 | 2013-12-02 13:50:38 +0000 | [diff] [blame] | 29 | } |
commit-bot@chromium.org | 99589af | 2013-12-10 14:53:16 +0000 | [diff] [blame] | 30 | return consumed; |
| 31 | } |
| 32 | |
mtklein | 1d0f164 | 2014-09-08 08:05:18 -0700 | [diff] [blame] | 33 | inline static SkString find_base_name(const Task& parent, SkTArray<SkString>* suffixList) { |
commit-bot@chromium.org | d6dcacd | 2014-05-14 20:26:00 +0000 | [diff] [blame] | 34 | const int suffixes = parent.depth() + 1; |
| 35 | const SkString& name = parent.name(); |
mtklein | 30bf3e2 | 2014-06-03 13:57:14 -0700 | [diff] [blame] | 36 | const int totalSuffixLength = split_suffixes(suffixes, name.c_str(), suffixList); |
| 37 | return SkString(name.c_str(), name.size() - totalSuffixLength); |
rmistry@google.com | d6bab02 | 2013-12-02 13:50:38 +0000 | [diff] [blame] | 38 | } |
mtklein@google.com | a7a9f37 | 2013-10-18 20:52:44 +0000 | [diff] [blame] | 39 | |
mtklein | ea65bfa | 2014-09-09 07:59:46 -0700 | [diff] [blame] | 40 | WriteTask::WriteTask(const Task& parent, const char* sourceType, SkBitmap bitmap) |
mtklein | 30bf3e2 | 2014-06-03 13:57:14 -0700 | [diff] [blame] | 41 | : CpuTask(parent) |
mtklein | 1d0f164 | 2014-09-08 08:05:18 -0700 | [diff] [blame] | 42 | , fBaseName(find_base_name(parent, &fSuffixes)) |
mtklein | ea65bfa | 2014-09-09 07:59:46 -0700 | [diff] [blame] | 43 | , fSourceType(sourceType) |
mtklein | 30bf3e2 | 2014-06-03 13:57:14 -0700 | [diff] [blame] | 44 | , fBitmap(bitmap) |
| 45 | , fData(NULL) |
mtklein | 1d0f164 | 2014-09-08 08:05:18 -0700 | [diff] [blame] | 46 | , fExtension(".png") { |
| 47 | } |
mtklein | 30bf3e2 | 2014-06-03 13:57:14 -0700 | [diff] [blame] | 48 | |
mtklein | ea65bfa | 2014-09-09 07:59:46 -0700 | [diff] [blame] | 49 | WriteTask::WriteTask(const Task& parent, |
| 50 | const char* sourceType, |
| 51 | SkStreamAsset *data, |
| 52 | const char* ext) |
mtklein | 30bf3e2 | 2014-06-03 13:57:14 -0700 | [diff] [blame] | 53 | : CpuTask(parent) |
mtklein | 1d0f164 | 2014-09-08 08:05:18 -0700 | [diff] [blame] | 54 | , fBaseName(find_base_name(parent, &fSuffixes)) |
mtklein | ea65bfa | 2014-09-09 07:59:46 -0700 | [diff] [blame] | 55 | , fSourceType(sourceType) |
halcanary | a4c6094 | 2014-08-26 10:38:07 -0700 | [diff] [blame] | 56 | , fData(data) |
| 57 | , fExtension(ext) { |
| 58 | SkASSERT(fData.get()); |
| 59 | SkASSERT(fData->unique()); |
| 60 | } |
mtklein | 30bf3e2 | 2014-06-03 13:57:14 -0700 | [diff] [blame] | 61 | |
rmistry@google.com | d6bab02 | 2013-12-02 13:50:38 +0000 | [diff] [blame] | 62 | void WriteTask::makeDirOrFail(SkString dir) { |
| 63 | if (!sk_mkdir(dir.c_str())) { |
| 64 | this->fail(); |
| 65 | } |
mtklein@google.com | a7a9f37 | 2013-10-18 20:52:44 +0000 | [diff] [blame] | 66 | } |
| 67 | |
bungeman | d51ce44 | 2014-10-02 13:39:00 -0700 | [diff] [blame] | 68 | static SkString get_md5_string(SkMD5* hasher) { |
mtklein | e2d4eb7 | 2014-09-08 12:42:23 -0700 | [diff] [blame] | 69 | SkMD5::Digest digest; |
bungeman | d51ce44 | 2014-10-02 13:39:00 -0700 | [diff] [blame] | 70 | hasher->finish(digest); |
mtklein | e2d4eb7 | 2014-09-08 12:42:23 -0700 | [diff] [blame] | 71 | |
| 72 | SkString md5; |
| 73 | for (int i = 0; i < 16; i++) { |
| 74 | md5.appendf("%02x", digest.data[i]); |
| 75 | } |
| 76 | return md5; |
mtklein | 858baf5 | 2014-09-08 11:33:48 -0700 | [diff] [blame] | 77 | } |
| 78 | |
bungeman | d51ce44 | 2014-10-02 13:39:00 -0700 | [diff] [blame] | 79 | static SkString get_md5(const void* ptr, size_t len) { |
| 80 | SkMD5 hasher; |
| 81 | hasher.write(ptr, len); |
| 82 | return get_md5_string(&hasher); |
| 83 | } |
| 84 | |
halcanary | daf36c1 | 2014-10-17 14:36:10 -0700 | [diff] [blame] | 85 | static bool write_asset(SkStreamAsset* input, SkWStream* output) { |
| 86 | return input->rewind() && output->writeStream(input, input->getLength()); |
| 87 | } |
| 88 | |
bungeman | d51ce44 | 2014-10-02 13:39:00 -0700 | [diff] [blame] | 89 | static SkString get_md5(SkStreamAsset* stream) { |
| 90 | SkMD5 hasher; |
halcanary | daf36c1 | 2014-10-17 14:36:10 -0700 | [diff] [blame] | 91 | write_asset(stream, &hasher); |
bungeman | d51ce44 | 2014-10-02 13:39:00 -0700 | [diff] [blame] | 92 | return get_md5_string(&hasher); |
| 93 | } |
| 94 | |
mtklein@google.com | a7a9f37 | 2013-10-18 20:52:44 +0000 | [diff] [blame] | 95 | void WriteTask::draw() { |
mtklein | c54056c | 2014-09-09 08:42:04 -0700 | [diff] [blame] | 96 | SkString md5; |
| 97 | { |
| 98 | SkAutoLockPixels lock(fBitmap); |
bungeman | d51ce44 | 2014-10-02 13:39:00 -0700 | [diff] [blame] | 99 | md5 = fData ? get_md5(fData) |
mtklein | c54056c | 2014-09-09 08:42:04 -0700 | [diff] [blame] | 100 | : get_md5(fBitmap.getPixels(), fBitmap.getSize()); |
mtklein | e2d4eb7 | 2014-09-08 12:42:23 -0700 | [diff] [blame] | 101 | } |
mtklein | 858baf5 | 2014-09-08 11:33:48 -0700 | [diff] [blame] | 102 | |
mtklein | 87e2437 | 2014-09-19 10:35:07 -0700 | [diff] [blame] | 103 | SkASSERT(fSuffixes.count() > 0); |
| 104 | SkString config = fSuffixes.back(); |
| 105 | SkString mode("direct"); |
| 106 | if (fSuffixes.count() > 1) { |
| 107 | mode = fSuffixes.fromBack(1); |
| 108 | } |
| 109 | |
mtklein | 858baf5 | 2014-09-08 11:33:48 -0700 | [diff] [blame] | 110 | { |
scroggo | 7a10fb6 | 2014-11-04 07:21:10 -0800 | [diff] [blame] | 111 | const JsonWriter::BitmapResult entry = { fBaseName, |
| 112 | config, |
| 113 | mode, |
| 114 | fSourceType, |
| 115 | md5 }; |
| 116 | JsonWriter::AddBitmapResult(entry); |
mtklein | 858baf5 | 2014-09-08 11:33:48 -0700 | [diff] [blame] | 117 | } |
| 118 | |
rmistry@google.com | d6bab02 | 2013-12-02 13:50:38 +0000 | [diff] [blame] | 119 | SkString dir(FLAGS_writePath[0]); |
tfarina | 6b87df2 | 2014-10-06 10:46:50 -0700 | [diff] [blame] | 120 | #if defined(SK_BUILD_FOR_IOS) |
caryclark | 17f0b6d | 2014-07-22 10:15:34 -0700 | [diff] [blame] | 121 | if (dir.equals("@")) { |
| 122 | dir.set(FLAGS_resourcePath[0]); |
| 123 | } |
| 124 | #endif |
rmistry@google.com | d6bab02 | 2013-12-02 13:50:38 +0000 | [diff] [blame] | 125 | this->makeDirOrFail(dir); |
mtklein | 30bf3e2 | 2014-06-03 13:57:14 -0700 | [diff] [blame] | 126 | |
mtklein | 858baf5 | 2014-09-08 11:33:48 -0700 | [diff] [blame] | 127 | SkString path; |
| 128 | if (FLAGS_nameByHash) { |
| 129 | // Flat directory of hash-named files. |
mtklein | c54056c | 2014-09-09 08:42:04 -0700 | [diff] [blame] | 130 | path = SkOSPath::Join(dir.c_str(), md5.c_str()); |
mtklein | 858baf5 | 2014-09-08 11:33:48 -0700 | [diff] [blame] | 131 | path.append(fExtension); |
| 132 | // We're content-addressed, so it's possible two threads race to write |
| 133 | // this file. We let the first one win. This also means we won't |
| 134 | // overwrite identical files from previous runs. |
| 135 | if (sk_exists(path.c_str())) { |
| 136 | return; |
| 137 | } |
mtklein | 1d0f164 | 2014-09-08 08:05:18 -0700 | [diff] [blame] | 138 | } else { |
mtklein | 858baf5 | 2014-09-08 11:33:48 -0700 | [diff] [blame] | 139 | // Nested by mode, config, etc. |
| 140 | for (int i = 0; i < fSuffixes.count(); i++) { |
| 141 | dir = SkOSPath::Join(dir.c_str(), fSuffixes[i].c_str()); |
| 142 | this->makeDirOrFail(dir); |
| 143 | } |
| 144 | path = SkOSPath::Join(dir.c_str(), fBaseName.c_str()); |
| 145 | path.append(fExtension); |
| 146 | // The path is unique, so two threads can't both write to the same file. |
| 147 | // If already present we overwrite here, since the content may have changed. |
mtklein | 1d0f164 | 2014-09-08 08:05:18 -0700 | [diff] [blame] | 148 | } |
| 149 | |
mtklein | e2d4eb7 | 2014-09-08 12:42:23 -0700 | [diff] [blame] | 150 | SkFILEWStream file(path.c_str()); |
| 151 | if (!file.isValid()) { |
| 152 | return this->fail("Can't open file."); |
| 153 | } |
| 154 | |
halcanary | daf36c1 | 2014-10-17 14:36:10 -0700 | [diff] [blame] | 155 | bool ok = fData ? write_asset(fData, &file) |
mtklein | c54056c | 2014-09-09 08:42:04 -0700 | [diff] [blame] | 156 | : SkImageEncoder::EncodeStream(&file, fBitmap, SkImageEncoder::kPNG_Type, 100); |
| 157 | if (!ok) { |
mtklein | e2d4eb7 | 2014-09-08 12:42:23 -0700 | [diff] [blame] | 158 | return this->fail("Can't write to file."); |
mtklein@google.com | a7a9f37 | 2013-10-18 20:52:44 +0000 | [diff] [blame] | 159 | } |
| 160 | } |
| 161 | |
| 162 | SkString WriteTask::name() const { |
rmistry@google.com | d6bab02 | 2013-12-02 13:50:38 +0000 | [diff] [blame] | 163 | SkString name("writing "); |
| 164 | for (int i = 0; i < fSuffixes.count(); i++) { |
| 165 | name.appendf("%s/", fSuffixes[i].c_str()); |
| 166 | } |
mtklein | 1d0f164 | 2014-09-08 08:05:18 -0700 | [diff] [blame] | 167 | name.append(fBaseName.c_str()); |
rmistry@google.com | d6bab02 | 2013-12-02 13:50:38 +0000 | [diff] [blame] | 168 | return name; |
mtklein@google.com | a7a9f37 | 2013-10-18 20:52:44 +0000 | [diff] [blame] | 169 | } |
| 170 | |
| 171 | bool WriteTask::shouldSkip() const { |
| 172 | return FLAGS_writePath.isEmpty(); |
| 173 | } |
| 174 | |
mtklein@google.com | a7a9f37 | 2013-10-18 20:52:44 +0000 | [diff] [blame] | 175 | } // namespace DM |