FastLED 3.9.15
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
pixel_stream.cpp
Go to the documentation of this file.
1
3#include "fl/dbg.h"
4#include "fl/namespace.h"
5
6#ifndef INT32_MAX
7#define INT32_MAX 0x7fffffff
8#endif
9
10#define DBG FASTLED_DBG
11
12using fl::ByteStreamPtr;
13using fl::FileHandlePtr;
14
15namespace fl {
16
17PixelStream::PixelStream(int bytes_per_frame)
18 : mbytesPerFrame(bytes_per_frame), mUsingByteStream(false) {}
19
21
22bool PixelStream::begin(FileHandlePtr h) {
23 close();
24 mFileHandle = h;
25 mUsingByteStream = false;
26 return mFileHandle->available();
27}
28
29bool PixelStream::beginStream(ByteStreamPtr s) {
30 close();
31 mByteStream = s;
32 mUsingByteStream = true;
33 return mByteStream->available(mbytesPerFrame);
34}
35
38 mFileHandle.reset();
39 }
40 mByteStream.reset();
41 mFileHandle.reset();
42}
43
45
47 if (mUsingByteStream) {
48 return mByteStream->read(&dst->r, 1) && mByteStream->read(&dst->g, 1) &&
49 mByteStream->read(&dst->b, 1);
50 } else {
51 return mFileHandle->read(&dst->r, 1) && mFileHandle->read(&dst->g, 1) &&
52 mFileHandle->read(&dst->b, 1);
53 }
54}
55
57 if (mUsingByteStream) {
58 return mByteStream->available(mbytesPerFrame);
59 } else {
60 return mFileHandle->available();
61 }
62}
63
64bool PixelStream::atEnd() const {
65 if (mUsingByteStream) {
66 return false;
67 } else {
68 return !mFileHandle->available();
69 }
70}
71
73 if (!frame) {
74 return false;
75 }
76 if (!mUsingByteStream) {
77 if (!framesRemaining()) {
78 return false;
79 }
80 size_t n = mFileHandle->readCRGB(frame->rgb(), mbytesPerFrame / 3);
81 DBG("pos: " << mFileHandle->pos());
82 return n * 3 == size_t(mbytesPerFrame);
83 }
84 size_t n = mByteStream->readCRGB(frame->rgb(), mbytesPerFrame / 3);
85 return n * 3 == size_t(mbytesPerFrame);
86}
87
88bool PixelStream::hasFrame(uint32_t frameNumber) {
89 if (mUsingByteStream) {
90 // ByteStream doesn't support seeking
91 DBG("Not implemented and therefore always returns true");
92 return true;
93 } else {
94 size_t total_bytes = mFileHandle->size();
95 return frameNumber * mbytesPerFrame < total_bytes;
96 }
97}
98
99bool PixelStream::readFrameAt(uint32_t frameNumber, Frame *frame) {
100 // DBG("read frame at " << frameNumber);
101 if (mUsingByteStream) {
102 // ByteStream doesn't support seeking
103 FASTLED_DBG("ByteStream doesn't support seeking");
104 return false;
105 } else {
106 // DBG("mbytesPerFrame: " << mbytesPerFrame);
107 mFileHandle->seek(frameNumber * mbytesPerFrame);
108 if (mFileHandle->bytesLeft() == 0) {
109 return false;
110 }
111 size_t read =
112 mFileHandle->readCRGB(frame->rgb(), mbytesPerFrame / 3) * 3;
113 // DBG("read: " << read);
114 // DBG("pos: " << mFileHandle->Position());
115
116 bool ok = int(read) == mbytesPerFrame;
117 if (!ok) {
118 DBG("readFrameAt failed - read: "
119 << read << ", mbytesPerFrame: " << mbytesPerFrame << ", frame:"
120 << frameNumber << ", left: " << mFileHandle->bytesLeft());
121 }
122 return ok;
123 }
124}
125
127 if (mbytesPerFrame == 0)
128 return 0;
129 int32_t bytes_left = bytesRemaining();
130 if (bytes_left <= 0) {
131 return 0;
132 }
133 return bytes_left / mbytesPerFrame;
134}
135
137 if (mUsingByteStream) {
138 // ByteStream doesn't have a concept of total size, so we can't
139 // calculate this
140 return -1;
141 } else {
142 int32_t bytes_played = mFileHandle->pos();
143 return bytes_played / mbytesPerFrame;
144 }
145}
146
148 if (mUsingByteStream) {
149 return INT32_MAX;
150 } else {
151 return mFileHandle->bytesLeft();
152 }
153}
154
158
160 if (mUsingByteStream) {
161 // ByteStream doesn't support rewinding
162 return false;
163 } else {
164 mFileHandle->seek(0);
165 return true;
166 }
167}
168
172
173size_t PixelStream::readBytes(uint8_t *dst, size_t len) {
174 uint16_t bytesRead = 0;
175 if (mUsingByteStream) {
176 while (bytesRead < len && mByteStream->available(len)) {
177 // use pop_front()
178 if (mByteStream->read(dst + bytesRead, 1)) {
179 bytesRead++;
180 } else {
181 break;
182 }
183 }
184 } else {
185 while (bytesRead < len && mFileHandle->available()) {
186 if (mFileHandle->read(dst + bytesRead, 1)) {
187 bytesRead++;
188 } else {
189 break;
190 }
191 }
192 }
193 return bytesRead;
194}
195
196} // namespace fl
CRGB * rgb()
Definition frame.h:30
bool hasFrame(uint32_t frameNumber)
int32_t framesRemaining() const
bool readFrameAt(uint32_t frameNumber, Frame *frame)
int32_t bytesRemaining() const
bool begin(fl::FileHandlePtr h)
int32_t bytesPerFrame()
virtual ~PixelStream()
int32_t bytesRemainingInFrame() const
PixelStream(int bytes_per_frame)
int32_t framesDisplayed() const
bool atEnd() const
int32_t mbytesPerFrame
bool readPixel(CRGB *dst)
bool readFrame(Frame *frame)
bool beginStream(fl::ByteStreamPtr s)
size_t readBytes(uint8_t *dst, size_t len)
fl::ByteStreamPtr mByteStream
fl::FileHandlePtr mFileHandle
Type getType() const
bool available() const
#define FASTLED_DBG(X)
Definition dbg.h:57
Implements the FastLED namespace macros.
Implements a simple red square effect for 2D LED grids.
Definition crgb.h:16
#define INT32_MAX
Representation of an RGB pixel (Red, Green, Blue)
Definition crgb.h:55
#define DBG
Definition time.cpp:8