TinyGPU
Loading...
Searching...
No Matches
AVIWriter.h
Go to the documentation of this file.
1#pragma once
2
3#include <stddef.h>
4#include <stdint.h>
5
6#include "TinyGPU/Surface/ISurface.h"
7
8#if defined(ARDUINO) || __has_include(<Print.h>)
9#include <Print.h>
10#else
11namespace tinygpu {
12/// Byte output used by AVIWriter when no Arduino API is available (plain desktop builds).
13class Print {
14 public:
15 virtual ~Print() {}
16 virtual size_t write(uint8_t c) = 0;
17 size_t write(const uint8_t* buf, size_t n) {
18 size_t written = 0;
19 for (size_t i = 0; i < n; ++i) written += write(buf[i]);
20 return written;
21 }
22 virtual void flush() {}
23};
24} // namespace tinygpu
25#endif
26
27namespace tinygpu {
28
29/**
30 * @brief Writes a simple AVI movie containing RGB565 frames.
31 *
32 * The implementation writes frames directly to the output stream as they are
33 * added. When the expected frame count is provided in begin(), the AVI headers
34 * and optional idx1 index can be precomputed without buffering the frame data.
35 * Frames are encoded as uncompressed 16-bit BI_BITFIELDS video using RGB565
36 * channel masks.
37 *
38 */
39template <typename RGB_T = RGB565>
40class AVIWriter {
41 public:
42 /// Creates an AVI writer that streams data to the provided Print output.
43 AVIWriter(Print& out) : out_(out) {}
44 /// Finalizes the AVI stream if it is still open.
46
47 /// Starts a new AVI stream using the surface dimensions and optional frame
48 /// count.
49 bool begin(const ISurface<RGB_T>& surface, uint16_t fps = 30,
50 uint32_t frameCount = 0) {
51 end();
52
53 width_ = static_cast<uint32_t>(surface.width());
54 height_ = static_cast<uint32_t>(surface.height());
55 if (width_ == 0 || height_ == 0) {
57 return false;
58 }
59
60 fps_ = fps == 0 ? 1 : fps;
63 expectedFrameCount_ = frameCount;
64 frameCount_ = 0;
65 isOpen_ = true;
66
68 return add(surface);
69 }
70
71 /// Finalizes the AVI stream and writes the optional frame index.
72 void end() {
73 if (!isOpen_) {
74 return;
75 }
76
77 if (expectedFrameCount_ != 0) {
79 }
81 }
82
83 /// Appends one RGB565 frame to the AVI stream.
84 bool add(const ISurface<RGB_T>& surface) {
85 if (!isOpen_ || surface.width() != width_ || surface.height() != height_) {
86 return false;
87 }
88
90 return false;
91 }
92
93 writeFourCC("00db");
95 writeFrame(surface);
96 if ((frameSize_ & 0x1U) != 0U) {
97 writeU8(0);
98 }
99
100 ++frameCount_;
101 return true;
102 }
103
104 protected:
105 Print& out_;
106 uint32_t width_ = 0;
107 uint32_t height_ = 0;
108 uint16_t fps_ = 30;
109 uint32_t rowStride_ = 0;
110 uint32_t frameSize_ = 0;
112 uint32_t frameCount_ = 0;
113 bool isOpen_ = false;
114
115 /// Returns the padded byte stride of one RGB565 frame row.
116 static uint32_t frameRowStride(uint32_t width) {
117 return ((width * 2U) + 3U) & ~0x3U;
118 }
119
120 /// Returns the data size rounded up to an even AVI chunk length.
121 static uint32_t paddedChunkSize(uint32_t dataSize) {
122 return dataSize + (dataSize & 0x1U);
123 }
124
125 /// Resets the writer state after finishing or aborting a stream.
126 void resetState() {
127 width_ = 0;
128 height_ = 0;
129 fps_ = 30;
130 rowStride_ = 0;
131 frameSize_ = 0;
133 frameCount_ = 0;
134 isOpen_ = false;
135 }
136
137 /// Writes the RIFF, AVI, stream, and movi headers.
138 void writeHeader() {
139 const uint32_t avihSize = 56;
140 const uint32_t strhSize = 56;
141 const uint32_t strfSize = 52;
142 const uint32_t avihChunkSize = 8 + avihSize;
143 const uint32_t strhChunkSize = 8 + strhSize;
144 const uint32_t strfChunkSize = 8 + strfSize;
145 const uint32_t strlListSize = 4 + strhChunkSize + strfChunkSize;
146 const uint32_t strlChunkSize = 8 + strlListSize;
147 const uint32_t hdrlListSize = 4 + avihChunkSize + strlChunkSize;
148 const uint32_t hdrlChunkSize = 8 + hdrlListSize;
149 const uint32_t frameChunkSize = 8 + paddedChunkSize(frameSize_);
150 const uint32_t headerFrameCount = expectedFrameCount_;
151 const uint32_t moviListSize =
152 expectedFrameCount_ == 0 ? 4
153 : 4 + (frameChunkSize * expectedFrameCount_);
154 const uint32_t moviChunkSize = 8 + moviListSize;
155 const uint32_t idx1Size =
157 const uint32_t idx1ChunkSize = expectedFrameCount_ == 0 ? 0 : 8 + idx1Size;
158 const uint32_t riffSize =
160 ? 4 + hdrlChunkSize + moviChunkSize
161 : 4 + hdrlChunkSize + moviChunkSize + idx1ChunkSize;
162 const uint32_t microsecondsPerFrame = 1000000UL / fps_;
163 const uint32_t maxBytesPerSecond = frameSize_ * fps_;
164 const uint32_t suggestedBufferSize = frameSize_;
165
166 writeFourCC("RIFF"); // RIFF chunk id
167 writeU32(riffSize); // RIFF chunk size
168 writeFourCC("AVI "); // AVI form type
169
170 writeFourCC("LIST"); // LIST chunk id
171 writeU32(hdrlListSize); // hdrl list size
172 writeFourCC("hdrl"); // header list type
173
174 writeFourCC("avih"); // main AVI header chunk id
175 writeU32(avihSize); // main AVI header size
176 writeU32(microsecondsPerFrame); // dwMicroSecPerFrame
177 writeU32(maxBytesPerSecond); // dwMaxBytesPerSec
178 writeU32(0); // dwPaddingGranularity
179 writeU32(0x10); // dwFlags (AVIF_HASINDEX when indexed)
180 writeU32(headerFrameCount); // dwTotalFrames
181 writeU32(0); // dwInitialFrames
182 writeU32(1); // dwStreams
183 writeU32(suggestedBufferSize); // dwSuggestedBufferSize
184 writeU32(width_); // dwWidth
185 writeU32(height_); // dwHeight
186 writeU32(0); // dwReserved[0]
187 writeU32(0); // dwReserved[1]
188 writeU32(0); // dwReserved[2]
189 writeU32(0); // dwReserved[3]
190
191 writeFourCC("LIST"); // LIST chunk id
192 writeU32(strlListSize); // strl list size
193 writeFourCC("strl"); // stream list type
194
195 writeFourCC("strh"); // stream header chunk id
196 writeU32(strhSize); // stream header size
197 writeFourCC("vids"); // fccType = video stream
198 writeFourCC("DIB "); // fccHandler = uncompressed DIB
199 writeU32(0); // dwFlags
200 writeU16(0); // wPriority
201 writeU16(0); // wLanguage
202 writeU32(0); // dwInitialFrames
203 writeU32(1); // dwScale
204 writeU32(fps_); // dwRate
205 writeU32(0); // dwStart
206 writeU32(headerFrameCount); // dwLength
207 writeU32(suggestedBufferSize); // dwSuggestedBufferSize
208 writeU32(0xFFFFFFFFUL); // dwQuality
209 writeU32(0); // dwSampleSize
210 writeU16(0); // rcFrame.left
211 writeU16(0); // rcFrame.top
212 writeU16(static_cast<uint16_t>(width_)); // rcFrame.right
213 writeU16(static_cast<uint16_t>(height_)); // rcFrame.bottom
214
215 writeFourCC("strf"); // stream format chunk id
216 writeU32(strfSize); // stream format size
217 writeU32(40); // biSize
218 writeU32(width_); // biWidth
219 writeU32(height_); // biHeight
220 writeU16(1); // biPlanes
221 writeU16(16); // biBitCount
222 writeU32(3); // biCompression = BI_BITFIELDS
223 writeU32(frameSize_); // biSizeImage
224 writeU32(0); // biXPelsPerMeter
225 writeU32(0); // biYPelsPerMeter
226 writeU32(0); // biClrUsed
227 writeU32(0); // biClrImportant
228 writeU32(0xF800); // red mask
229 writeU32(0x07E0); // green mask
230 writeU32(0x001F); // blue mask
231
232 writeFourCC("LIST"); // LIST chunk id
233 writeU32(moviListSize); // movi list size
234 writeFourCC("movi"); // movi list type
235 }
236
237 /// Writes one surface as a bottom-up padded RGB565 AVI frame.
238 void writeFrame(const ISurface<RGB_T>& surface) {
239 const uint32_t width = static_cast<uint32_t>(surface.width());
240 const uint32_t height = static_cast<uint32_t>(surface.height());
241 const uint32_t rowStride = frameRowStride(width);
242 const uint8_t padByte = 0;
243
244 for (uint32_t row = 0; row < height; ++row) {
245 const uint32_t sourceY = height - 1U - row;
246 for (uint32_t x = 0; x < width; ++x) {
247 // getValue() is byte-swapped (SPI/QSPI wire order); the header
248 // above declares standard RGB565 bitmasks, which describe the
249 // conventional (native) bit layout, so undo the swap here.
250 writeU16(surface.getPixel(x, sourceY).getValueSwapped());
251 }
252 for (uint32_t padding = width * 2U; padding < rowStride; ++padding) {
253 writeBytes(&padByte, 1);
254 }
255 }
256 }
257
258 /// Writes the idx1 frame index when a frame count was provided.
259 void writeIndex() {
260 const uint32_t frameDataSize = frameSize_;
261 const uint32_t idx1Size = expectedFrameCount_ * 16U;
262
263 writeFourCC("idx1");
264 writeU32(idx1Size);
265
266 uint32_t moviOffset = 4;
267 for (uint32_t frame = 0; frame < expectedFrameCount_; ++frame) {
268 writeFourCC("00db");
269 writeU32(0x10);
270 writeU32(moviOffset);
271 writeU32(frameDataSize);
272 moviOffset += 8 + paddedChunkSize(frameDataSize);
273 }
274 }
275
276 /// Writes a four-character AVI chunk identifier.
277 void writeFourCC(const char* value) {
278 writeBytes(reinterpret_cast<const uint8_t*>(value), 4);
279 }
280
281 /// Writes a single byte to the output stream.
282 void writeU8(uint8_t value) { out_.write(value); }
283
284 /// Writes a 16-bit little-endian value to the output stream.
285 void writeU16(uint16_t value) {
286 const uint8_t bytes[2] = {static_cast<uint8_t>(value & 0xFFU),
287 static_cast<uint8_t>((value >> 8) & 0xFFU)};
288 writeBytes(bytes, sizeof(bytes));
289 }
290
291 /// Writes a 32-bit little-endian value to the output stream.
292 void writeU32(uint32_t value) {
293 const uint8_t bytes[4] = {static_cast<uint8_t>(value & 0xFFU),
294 static_cast<uint8_t>((value >> 8) & 0xFFU),
295 static_cast<uint8_t>((value >> 16) & 0xFFU),
296 static_cast<uint8_t>((value >> 24) & 0xFFU)};
297 writeBytes(bytes, sizeof(bytes));
298 }
299
300 /// Writes a raw byte sequence to the output stream.
301 void writeBytes(const uint8_t* data, size_t length) {
302 out_.write(data, length);
303 }
304};
305
306} // namespace tinygpu
Writes a simple AVI movie containing RGB565 frames.
Definition: AVIWriter.h:40
uint32_t width_
Definition: AVIWriter.h:106
void writeIndex()
Writes the idx1 frame index when a frame count was provided.
Definition: AVIWriter.h:259
uint32_t frameSize_
Definition: AVIWriter.h:110
static uint32_t paddedChunkSize(uint32_t dataSize)
Returns the data size rounded up to an even AVI chunk length.
Definition: AVIWriter.h:121
uint32_t rowStride_
Definition: AVIWriter.h:109
uint16_t fps_
Definition: AVIWriter.h:108
void writeHeader()
Writes the RIFF, AVI, stream, and movi headers.
Definition: AVIWriter.h:138
void writeU8(uint8_t value)
Writes a single byte to the output stream.
Definition: AVIWriter.h:282
bool begin(const ISurface< RGB_T > &surface, uint16_t fps=30, uint32_t frameCount=0)
Definition: AVIWriter.h:49
uint32_t height_
Definition: AVIWriter.h:107
void writeU32(uint32_t value)
Writes a 32-bit little-endian value to the output stream.
Definition: AVIWriter.h:292
void writeU16(uint16_t value)
Writes a 16-bit little-endian value to the output stream.
Definition: AVIWriter.h:285
void writeFrame(const ISurface< RGB_T > &surface)
Writes one surface as a bottom-up padded RGB565 AVI frame.
Definition: AVIWriter.h:238
void resetState()
Resets the writer state after finishing or aborting a stream.
Definition: AVIWriter.h:126
static uint32_t frameRowStride(uint32_t width)
Returns the padded byte stride of one RGB565 frame row.
Definition: AVIWriter.h:116
uint32_t expectedFrameCount_
Definition: AVIWriter.h:111
bool isOpen_
Definition: AVIWriter.h:113
void writeBytes(const uint8_t *data, size_t length)
Writes a raw byte sequence to the output stream.
Definition: AVIWriter.h:301
bool add(const ISurface< RGB_T > &surface)
Appends one RGB565 frame to the AVI stream.
Definition: AVIWriter.h:84
uint32_t frameCount_
Definition: AVIWriter.h:112
void end()
Finalizes the AVI stream and writes the optional frame index.
Definition: AVIWriter.h:72
void writeFourCC(const char *value)
Writes a four-character AVI chunk identifier.
Definition: AVIWriter.h:277
AVIWriter(Print &out)
Creates an AVI writer that streams data to the provided Print output.
Definition: AVIWriter.h:43
~AVIWriter()
Finalizes the AVI stream if it is still open.
Definition: AVIWriter.h:45
Print & out_
Definition: AVIWriter.h:105
RGB color stored in 16-bit RGB565 format, byte-swapped from the conventional bit layout.
Definition: RGB565.h:24
Definition: DSIBusESP32.h:19