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]); |
bsalomon | ef3fcd8 | 2014-12-12 08:51:38 -0800 | [diff] [blame] | 28 | consumed += SkToInt(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) { |
mtklein | f6139f7 | 2014-12-12 16:41:12 -0800 | [diff] [blame] | 63 | // This can be a little racy, so if it fails check to see if someone else succeeded. |
| 64 | if (!sk_mkdir(dir.c_str()) && !sk_isdir(dir.c_str())) { |
| 65 | this->fail("Can't make directory."); |
rmistry@google.com | d6bab02 | 2013-12-02 13:50:38 +0000 | [diff] [blame] | 66 | } |
mtklein@google.com | a7a9f37 | 2013-10-18 20:52:44 +0000 | [diff] [blame] | 67 | } |
| 68 | |
bungeman | d51ce44 | 2014-10-02 13:39:00 -0700 | [diff] [blame] | 69 | static SkString get_md5_string(SkMD5* hasher) { |
mtklein | e2d4eb7 | 2014-09-08 12:42:23 -0700 | [diff] [blame] | 70 | SkMD5::Digest digest; |
bungeman | d51ce44 | 2014-10-02 13:39:00 -0700 | [diff] [blame] | 71 | hasher->finish(digest); |
mtklein | e2d4eb7 | 2014-09-08 12:42:23 -0700 | [diff] [blame] | 72 | |
| 73 | SkString md5; |
| 74 | for (int i = 0; i < 16; i++) { |
| 75 | md5.appendf("%02x", digest.data[i]); |
| 76 | } |
| 77 | return md5; |
mtklein | 858baf5 | 2014-09-08 11:33:48 -0700 | [diff] [blame] | 78 | } |
| 79 | |
bungeman | d51ce44 | 2014-10-02 13:39:00 -0700 | [diff] [blame] | 80 | static SkString get_md5(const void* ptr, size_t len) { |
| 81 | SkMD5 hasher; |
| 82 | hasher.write(ptr, len); |
| 83 | return get_md5_string(&hasher); |
| 84 | } |
| 85 | |
halcanary | daf36c1 | 2014-10-17 14:36:10 -0700 | [diff] [blame] | 86 | static bool write_asset(SkStreamAsset* input, SkWStream* output) { |
| 87 | return input->rewind() && output->writeStream(input, input->getLength()); |
| 88 | } |
| 89 | |
bungeman | d51ce44 | 2014-10-02 13:39:00 -0700 | [diff] [blame] | 90 | static SkString get_md5(SkStreamAsset* stream) { |
| 91 | SkMD5 hasher; |
halcanary | daf36c1 | 2014-10-17 14:36:10 -0700 | [diff] [blame] | 92 | write_asset(stream, &hasher); |
bungeman | d51ce44 | 2014-10-02 13:39:00 -0700 | [diff] [blame] | 93 | return get_md5_string(&hasher); |
| 94 | } |
| 95 | |
mtklein | f6139f7 | 2014-12-12 16:41:12 -0800 | [diff] [blame] | 96 | static bool encode_png(const SkBitmap& src, SkFILEWStream* file) { |
| 97 | SkBitmap bm; |
| 98 | // We can't encode A8 bitmaps as PNGs. Convert them to 8888 first. |
| 99 | if (src.info().colorType() == kAlpha_8_SkColorType) { |
| 100 | if (!src.copyTo(&bm, kN32_SkColorType)) { |
| 101 | return false; |
| 102 | } |
| 103 | } else { |
| 104 | bm = src; |
| 105 | } |
| 106 | return SkImageEncoder::EncodeStream(file, bm, SkImageEncoder::kPNG_Type, 100); |
| 107 | } |
| 108 | |
mtklein@google.com | a7a9f37 | 2013-10-18 20:52:44 +0000 | [diff] [blame] | 109 | void WriteTask::draw() { |
mtklein | c54056c | 2014-09-09 08:42:04 -0700 | [diff] [blame] | 110 | SkString md5; |
| 111 | { |
| 112 | SkAutoLockPixels lock(fBitmap); |
bungeman | d51ce44 | 2014-10-02 13:39:00 -0700 | [diff] [blame] | 113 | md5 = fData ? get_md5(fData) |
mtklein | c54056c | 2014-09-09 08:42:04 -0700 | [diff] [blame] | 114 | : get_md5(fBitmap.getPixels(), fBitmap.getSize()); |
mtklein | e2d4eb7 | 2014-09-08 12:42:23 -0700 | [diff] [blame] | 115 | } |
mtklein | 858baf5 | 2014-09-08 11:33:48 -0700 | [diff] [blame] | 116 | |
mtklein | 87e2437 | 2014-09-19 10:35:07 -0700 | [diff] [blame] | 117 | SkASSERT(fSuffixes.count() > 0); |
| 118 | SkString config = fSuffixes.back(); |
| 119 | SkString mode("direct"); |
| 120 | if (fSuffixes.count() > 1) { |
| 121 | mode = fSuffixes.fromBack(1); |
| 122 | } |
| 123 | |
mtklein | 858baf5 | 2014-09-08 11:33:48 -0700 | [diff] [blame] | 124 | { |
scroggo | 7a10fb6 | 2014-11-04 07:21:10 -0800 | [diff] [blame] | 125 | const JsonWriter::BitmapResult entry = { fBaseName, |
| 126 | config, |
| 127 | mode, |
| 128 | fSourceType, |
| 129 | md5 }; |
| 130 | JsonWriter::AddBitmapResult(entry); |
mtklein | 858baf5 | 2014-09-08 11:33:48 -0700 | [diff] [blame] | 131 | } |
| 132 | |
rmistry@google.com | d6bab02 | 2013-12-02 13:50:38 +0000 | [diff] [blame] | 133 | SkString dir(FLAGS_writePath[0]); |
tfarina | 6b87df2 | 2014-10-06 10:46:50 -0700 | [diff] [blame] | 134 | #if defined(SK_BUILD_FOR_IOS) |
caryclark | 17f0b6d | 2014-07-22 10:15:34 -0700 | [diff] [blame] | 135 | if (dir.equals("@")) { |
| 136 | dir.set(FLAGS_resourcePath[0]); |
| 137 | } |
| 138 | #endif |
rmistry@google.com | d6bab02 | 2013-12-02 13:50:38 +0000 | [diff] [blame] | 139 | this->makeDirOrFail(dir); |
mtklein | 30bf3e2 | 2014-06-03 13:57:14 -0700 | [diff] [blame] | 140 | |
mtklein | 858baf5 | 2014-09-08 11:33:48 -0700 | [diff] [blame] | 141 | SkString path; |
| 142 | if (FLAGS_nameByHash) { |
| 143 | // Flat directory of hash-named files. |
mtklein | c54056c | 2014-09-09 08:42:04 -0700 | [diff] [blame] | 144 | path = SkOSPath::Join(dir.c_str(), md5.c_str()); |
mtklein | 858baf5 | 2014-09-08 11:33:48 -0700 | [diff] [blame] | 145 | path.append(fExtension); |
| 146 | // We're content-addressed, so it's possible two threads race to write |
| 147 | // this file. We let the first one win. This also means we won't |
| 148 | // overwrite identical files from previous runs. |
| 149 | if (sk_exists(path.c_str())) { |
| 150 | return; |
| 151 | } |
mtklein | 1d0f164 | 2014-09-08 08:05:18 -0700 | [diff] [blame] | 152 | } else { |
mtklein | 858baf5 | 2014-09-08 11:33:48 -0700 | [diff] [blame] | 153 | // Nested by mode, config, etc. |
| 154 | for (int i = 0; i < fSuffixes.count(); i++) { |
| 155 | dir = SkOSPath::Join(dir.c_str(), fSuffixes[i].c_str()); |
| 156 | this->makeDirOrFail(dir); |
| 157 | } |
| 158 | path = SkOSPath::Join(dir.c_str(), fBaseName.c_str()); |
| 159 | path.append(fExtension); |
| 160 | // The path is unique, so two threads can't both write to the same file. |
| 161 | // If already present we overwrite here, since the content may have changed. |
mtklein | 1d0f164 | 2014-09-08 08:05:18 -0700 | [diff] [blame] | 162 | } |
| 163 | |
mtklein | e2d4eb7 | 2014-09-08 12:42:23 -0700 | [diff] [blame] | 164 | SkFILEWStream file(path.c_str()); |
| 165 | if (!file.isValid()) { |
| 166 | return this->fail("Can't open file."); |
| 167 | } |
| 168 | |
halcanary | daf36c1 | 2014-10-17 14:36:10 -0700 | [diff] [blame] | 169 | bool ok = fData ? write_asset(fData, &file) |
mtklein | f6139f7 | 2014-12-12 16:41:12 -0800 | [diff] [blame] | 170 | : encode_png(fBitmap, &file); |
mtklein | c54056c | 2014-09-09 08:42:04 -0700 | [diff] [blame] | 171 | if (!ok) { |
mtklein | e2d4eb7 | 2014-09-08 12:42:23 -0700 | [diff] [blame] | 172 | return this->fail("Can't write to file."); |
mtklein@google.com | a7a9f37 | 2013-10-18 20:52:44 +0000 | [diff] [blame] | 173 | } |
| 174 | } |
| 175 | |
| 176 | SkString WriteTask::name() const { |
rmistry@google.com | d6bab02 | 2013-12-02 13:50:38 +0000 | [diff] [blame] | 177 | SkString name("writing "); |
| 178 | for (int i = 0; i < fSuffixes.count(); i++) { |
| 179 | name.appendf("%s/", fSuffixes[i].c_str()); |
| 180 | } |
mtklein | 1d0f164 | 2014-09-08 08:05:18 -0700 | [diff] [blame] | 181 | name.append(fBaseName.c_str()); |
rmistry@google.com | d6bab02 | 2013-12-02 13:50:38 +0000 | [diff] [blame] | 182 | return name; |
mtklein@google.com | a7a9f37 | 2013-10-18 20:52:44 +0000 | [diff] [blame] | 183 | } |
| 184 | |
| 185 | bool WriteTask::shouldSkip() const { |
| 186 | return FLAGS_writePath.isEmpty(); |
| 187 | } |
| 188 | |
mtklein@google.com | a7a9f37 | 2013-10-18 20:52:44 +0000 | [diff] [blame] | 189 | } // namespace DM |