OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2006 The Android Open Source Project | 2 * Copyright 2006 The Android Open Source Project |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 | 8 |
9 #include "SkStream.h" | 9 #include "SkStream.h" |
10 #include "SkStreamPriv.h" | 10 #include "SkStreamPriv.h" |
(...skipping 288 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
299 fOffset = 0; | 299 fOffset = 0; |
300 } | 300 } |
301 | 301 |
302 SkMemoryStream::SkMemoryStream(sk_sp<SkData> data) : fData(std::move(data)) { | 302 SkMemoryStream::SkMemoryStream(sk_sp<SkData> data) : fData(std::move(data)) { |
303 if (nullptr == fData) { | 303 if (nullptr == fData) { |
304 fData = SkData::MakeEmpty(); | 304 fData = SkData::MakeEmpty(); |
305 } | 305 } |
306 fOffset = 0; | 306 fOffset = 0; |
307 } | 307 } |
308 | 308 |
| 309 #ifdef SK_SUPPORT_LEGACY_STREAM_DATA |
309 SkMemoryStream::SkMemoryStream(SkData* data) { | 310 SkMemoryStream::SkMemoryStream(SkData* data) { |
310 if (nullptr == data) { | 311 if (nullptr == data) { |
311 fData = SkData::MakeEmpty(); | 312 fData = SkData::MakeEmpty(); |
312 } else { | 313 } else { |
313 fData = sk_ref_sp(data); | 314 fData = sk_ref_sp(data); |
314 } | 315 } |
315 fOffset = 0; | 316 fOffset = 0; |
316 } | 317 } |
| 318 #endif |
317 | 319 |
318 void SkMemoryStream::setMemoryOwned(const void* src, size_t size) { | 320 void SkMemoryStream::setMemoryOwned(const void* src, size_t size) { |
319 fData = SkData::MakeFromMalloc(src, size); | 321 fData = SkData::MakeFromMalloc(src, size); |
320 fOffset = 0; | 322 fOffset = 0; |
321 } | 323 } |
322 | 324 |
323 void SkMemoryStream::setMemory(const void* src, size_t size, bool copyData) { | 325 void SkMemoryStream::setMemory(const void* src, size_t size, bool copyData) { |
324 fData = newFromParams(src, size, copyData); | 326 fData = newFromParams(src, size, copyData); |
325 fOffset = 0; | 327 fOffset = 0; |
326 } | 328 } |
327 | 329 |
328 SkData* SkMemoryStream::copyToData() const { | 330 void SkMemoryStream::setData(sk_sp<SkData> data) { |
329 return SkSafeRef(fData.get()); | |
330 } | |
331 | |
332 SkData* SkMemoryStream::setData(SkData* data) { | |
333 if (nullptr == data) { | 331 if (nullptr == data) { |
334 fData = SkData::MakeEmpty(); | 332 fData = SkData::MakeEmpty(); |
335 } else { | 333 } else { |
336 fData = sk_ref_sp(data); | 334 fData = data; |
337 } | 335 } |
338 fOffset = 0; | 336 fOffset = 0; |
339 return data; | |
340 } | 337 } |
341 | 338 |
342 void SkMemoryStream::skipToAlign4() { | 339 void SkMemoryStream::skipToAlign4() { |
343 // cast to remove unary-minus warning | 340 // cast to remove unary-minus warning |
344 fOffset += -(int)fOffset & 0x03; | 341 fOffset += -(int)fOffset & 0x03; |
345 } | 342 } |
346 | 343 |
347 size_t SkMemoryStream::read(void* buffer, size_t size) { | 344 size_t SkMemoryStream::read(void* buffer, size_t size) { |
348 size_t dataSize = fData->size(); | 345 size_t dataSize = fData->size(); |
349 | 346 |
(...skipping 285 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
635 void SkDynamicMemoryWStream::padToAlign4() | 632 void SkDynamicMemoryWStream::padToAlign4() |
636 { | 633 { |
637 // cast to remove unary-minus warning | 634 // cast to remove unary-minus warning |
638 int padBytes = -(int)fBytesWritten & 0x03; | 635 int padBytes = -(int)fBytesWritten & 0x03; |
639 if (padBytes == 0) | 636 if (padBytes == 0) |
640 return; | 637 return; |
641 int zero = 0; | 638 int zero = 0; |
642 write(&zero, padBytes); | 639 write(&zero, padBytes); |
643 } | 640 } |
644 | 641 |
645 SkData* SkDynamicMemoryWStream::copyToData() const { | 642 sk_sp<SkData> SkDynamicMemoryWStream::snapshotAsData() const { |
646 if (nullptr == fCopy) { | 643 if (nullptr == fCopy) { |
647 auto data = SkData::MakeUninitialized(fBytesWritten); | 644 auto data = SkData::MakeUninitialized(fBytesWritten); |
648 // be sure to call copyTo() before we assign to fCopy | 645 // be sure to call copyTo() before we assign to fCopy |
649 this->copyTo(data->writable_data()); | 646 this->copyTo(data->writable_data()); |
650 fCopy = std::move(data); | 647 fCopy = std::move(data); |
651 } | 648 } |
652 return SkRef(fCopy.get()); | 649 return fCopy; |
| 650 } |
| 651 |
| 652 sk_sp<SkData> SkDynamicMemoryWStream::detachAsData() { |
| 653 sk_sp<SkData> data = this->snapshotAsData(); |
| 654 this->reset(); |
| 655 return data; |
653 } | 656 } |
654 | 657 |
655 void SkDynamicMemoryWStream::invalidateCopy() { | 658 void SkDynamicMemoryWStream::invalidateCopy() { |
656 fCopy = nullptr; | 659 fCopy = nullptr; |
657 } | 660 } |
658 | 661 |
659 class SkBlockMemoryRefCnt : public SkRefCnt { | 662 class SkBlockMemoryRefCnt : public SkRefCnt { |
660 public: | 663 public: |
661 explicit SkBlockMemoryRefCnt(SkDynamicMemoryWStream::Block* head) : fHead(he
ad) { } | 664 explicit SkBlockMemoryRefCnt(SkDynamicMemoryWStream::Block* head) : fHead(he
ad) { } |
662 | 665 |
(...skipping 212 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
875 return SkData::MakeFromStream(stream, stream->getLength()); | 878 return SkData::MakeFromStream(stream, stream->getLength()); |
876 } | 879 } |
877 | 880 |
878 SkDynamicMemoryWStream tempStream; | 881 SkDynamicMemoryWStream tempStream; |
879 const size_t bufferSize = 4096; | 882 const size_t bufferSize = 4096; |
880 char buffer[bufferSize]; | 883 char buffer[bufferSize]; |
881 do { | 884 do { |
882 size_t bytesRead = stream->read(buffer, bufferSize); | 885 size_t bytesRead = stream->read(buffer, bufferSize); |
883 tempStream.write(buffer, bytesRead); | 886 tempStream.write(buffer, bytesRead); |
884 } while (!stream->isAtEnd()); | 887 } while (!stream->isAtEnd()); |
885 return sk_sp<SkData>(tempStream.copyToData()); | 888 return tempStream.detachAsData(); |
886 } | 889 } |
887 | 890 |
888 bool SkStreamCopy(SkWStream* out, SkStream* input) { | 891 bool SkStreamCopy(SkWStream* out, SkStream* input) { |
889 const char* base = static_cast<const char*>(input->getMemoryBase()); | 892 const char* base = static_cast<const char*>(input->getMemoryBase()); |
890 if (base && input->hasPosition() && input->hasLength()) { | 893 if (base && input->hasPosition() && input->hasLength()) { |
891 // Shortcut that avoids the while loop. | 894 // Shortcut that avoids the while loop. |
892 size_t position = input->getPosition(); | 895 size_t position = input->getPosition(); |
893 size_t length = input->getLength(); | 896 size_t length = input->getLength(); |
894 SkASSERT(length >= position); | 897 SkASSERT(length >= position); |
895 return out->write(&base[position], length - position); | 898 return out->write(&base[position], length - position); |
896 } | 899 } |
897 char scratch[4096]; | 900 char scratch[4096]; |
898 size_t count; | 901 size_t count; |
899 while (true) { | 902 while (true) { |
900 count = input->read(scratch, sizeof(scratch)); | 903 count = input->read(scratch, sizeof(scratch)); |
901 if (0 == count) { | 904 if (0 == count) { |
902 return true; | 905 return true; |
903 } | 906 } |
904 if (!out->write(scratch, count)) { | 907 if (!out->write(scratch, count)) { |
905 return false; | 908 return false; |
906 } | 909 } |
907 } | 910 } |
908 } | 911 } |
OLD | NEW |