1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "third_party/blink/renderer/platform/image-decoders/skia/segment_stream.h"
#include <utility>
#include "base/compiler_specific.h"
#include "third_party/blink/renderer/platform/image-decoders/segment_reader.h"
namespace blink {
SegmentStream::SegmentStream(size_t reading_offset)
: position_(reading_offset), reading_offset_(reading_offset) {}
SegmentStream::SegmentStream(SegmentStream&& rhs)
: reader_(std::move(rhs.reader_)),
position_(rhs.position_),
reading_offset_(rhs.reading_offset_) {}
SegmentStream& SegmentStream::operator=(SegmentStream&& rhs) {
reader_ = std::move(rhs.reader_);
position_ = rhs.position_;
reading_offset_ = rhs.reading_offset_;
return *this;
}
SegmentStream::~SegmentStream() = default;
void SegmentStream::SetReader(scoped_refptr<SegmentReader> reader) {
reader_ = std::move(reader);
}
bool SegmentStream::IsCleared() const {
return !reader_ || position_ > reader_->size();
}
size_t SegmentStream::read(void* buffer, size_t size) {
if (IsCleared()) {
return 0;
}
size = std::min(size, reader_->size() - position_);
size_t bytes_advanced = 0;
if (!buffer) { // skipping, not reading
bytes_advanced = size;
} else {
bytes_advanced = peek(buffer, size);
}
position_ += bytes_advanced;
return bytes_advanced;
}
size_t SegmentStream::peek(void* buffer, size_t size) const {
if (IsCleared()) {
return 0;
}
size = std::min(size, reader_->size() - position_);
size_t total_bytes_peeked = 0;
auto buffer_span =
UNSAFE_TODO(base::span(static_cast<uint8_t*>(buffer), size));
while (!buffer_span.empty()) {
base::span<const uint8_t> segment =
reader_->GetSomeData(position_ + total_bytes_peeked);
if (segment.empty()) {
break;
}
if (segment.size() > buffer_span.size()) {
segment = segment.first(buffer_span.size());
}
buffer_span.copy_prefix_from(segment);
buffer_span = buffer_span.subspan(segment.size());
total_bytes_peeked += segment.size();
}
return total_bytes_peeked;
}
bool SegmentStream::isAtEnd() const {
return !reader_ || position_ >= reader_->size();
}
bool SegmentStream::rewind() {
position_ = reading_offset_;
return true;
}
bool SegmentStream::hasPosition() const {
return true;
}
size_t SegmentStream::getPosition() const {
return position_ - reading_offset_;
}
bool SegmentStream::seek(size_t position) {
position_ = reading_offset_ + position;
return true;
}
bool SegmentStream::move(long offset) {
DCHECK_GT(offset, 0);
position_ += offset;
return true;
}
bool SegmentStream::hasLength() const {
return true;
}
size_t SegmentStream::getLength() const {
if (reader_) {
return reader_->size();
}
return 0;
}
} // namespace blink
|
