|
7 | 7 | #pragma once |
8 | 8 |
|
9 | 9 | #if defined(ESP32) |
10 | | - |
11 | | -#define READ_BUFFER_SIZE 1024 |
12 | | - |
13 | 10 | #include <driver/jpeg_decode.h> |
14 | 11 |
|
| 12 | +#define READ_BATCH_SIZE 1024 |
| 13 | + |
15 | 14 | class MjpegClass |
16 | 15 | { |
17 | 16 | public: |
18 | 17 | bool setup(const char *path) |
19 | 18 | { |
20 | 19 | _input = fopen(path, "r"); |
21 | | - _inputindex = 0; |
22 | | - |
23 | | - if (!_read_buf) |
24 | | - { |
25 | | - _read_buf = (uint8_t *)malloc(READ_BUFFER_SIZE); |
26 | | - } |
27 | | - |
28 | | - if (!_read_buf) |
29 | | - { |
30 | | - return false; |
31 | | - } |
| 20 | + _read = 0; |
32 | 21 |
|
33 | 22 | jpeg_decode_engine_cfg_t decode_eng_cfg = { |
34 | 23 | .intr_priority = 0, |
@@ -62,106 +51,112 @@ class MjpegClass |
62 | 51 |
|
63 | 52 | bool readMjpegBuf() |
64 | 53 | { |
65 | | - if (_inputindex == 0) |
| 54 | + if (_read == 0) |
66 | 55 | { |
67 | | - _buf_read = fread(_read_buf, 1, READ_BUFFER_SIZE, _input); |
68 | | - _inputindex += _buf_read; |
| 56 | + // _mjpeg_buf empty |
| 57 | + _read = fread(_mjpeg_buf, 1, READ_BATCH_SIZE, _input); |
69 | 58 | } |
70 | | - _mjpeg_buf_offset = 0; |
71 | | - int i = 0; |
| 59 | + else |
| 60 | + { |
| 61 | + // pad previous remain data to the start of _mjpeg_buf |
| 62 | + memcpy(_mjpeg_buf, _p, _read); |
| 63 | + } |
| 64 | + |
72 | 65 | bool found_FFD8 = false; |
73 | | - while ((_buf_read > 0) && (!found_FFD8)) |
| 66 | + _p = _mjpeg_buf; |
| 67 | + while ((_read > 0) && (!found_FFD8)) |
74 | 68 | { |
75 | | - i = 0; |
76 | | - while ((i < _buf_read) && (!found_FFD8)) |
| 69 | + while ((_read > 1) && (!found_FFD8)) |
77 | 70 | { |
78 | | - if ((_read_buf[i] == 0xFF) && (_read_buf[i + 1] == 0xD8)) // JPEG header |
| 71 | + --_read; |
| 72 | + if ((*_p++ == 0xFF) && (*_p == 0xD8)) // JPEG header |
79 | 73 | { |
80 | 74 | // Serial.printf("Found FFD8 at: %d.\n", i); |
81 | 75 | found_FFD8 = true; |
82 | 76 | } |
83 | | - ++i; |
84 | 77 | } |
85 | | - if (found_FFD8) |
| 78 | + if (!found_FFD8) |
86 | 79 | { |
87 | | - --i; |
88 | | - } |
89 | | - else |
90 | | - { |
91 | | - _buf_read = fread(_read_buf, 1, READ_BUFFER_SIZE, _input); |
| 80 | + if (*_p == 0xFF) |
| 81 | + { |
| 82 | + _mjpeg_buf[0] = 0xFF; |
| 83 | + _read = fread(_mjpeg_buf + 1, 1, READ_BATCH_SIZE, _input) + 1; |
| 84 | + } |
| 85 | + else |
| 86 | + { |
| 87 | + _read = fread(_mjpeg_buf, 1, READ_BATCH_SIZE, _input); |
| 88 | + } |
| 89 | + _p = _mjpeg_buf; |
92 | 90 | } |
93 | 91 | } |
94 | | - uint8_t *_p = _read_buf + i; |
95 | | - _buf_read -= i; |
| 92 | + |
| 93 | + if (!found_FFD8) |
| 94 | + { |
| 95 | + return false; |
| 96 | + } |
| 97 | + |
| 98 | + // rewind 1 byte |
| 99 | + --_p; |
| 100 | + ++_read; |
| 101 | + |
| 102 | + // pad JPEG header to the start of _mjpeg_buf |
| 103 | + if (_p > _mjpeg_buf) |
| 104 | + { |
| 105 | + Serial.println("(_p > _mjpeg_buf)"); |
| 106 | + memcpy(_mjpeg_buf, _p, _read); |
| 107 | + } |
| 108 | + |
| 109 | + // skip JPEG header |
| 110 | + _p += 2; |
| 111 | + _read -= 2; |
| 112 | + |
| 113 | + if (_read == 0) |
| 114 | + { |
| 115 | + _read = fread(_p, 1, READ_BATCH_SIZE, _input); |
| 116 | + } |
| 117 | + |
96 | 118 | bool found_FFD9 = false; |
97 | | - if (_buf_read > 0) |
| 119 | + while ((_read > 0) && (!found_FFD9)) |
98 | 120 | { |
99 | | - i = 3; |
100 | | - while ((_buf_read > 0) && (!found_FFD9)) |
| 121 | + while ((_read > 1) && (!found_FFD9)) |
101 | 122 | { |
102 | | - if ((_mjpeg_buf_offset > 0) && (_mjpeg_buf[_mjpeg_buf_offset - 1] == 0xFF) && (_p[0] == 0xD9)) // JPEG trailer |
| 123 | + --_read; |
| 124 | + if ((*_p++ == 0xFF) && (*_p == 0xD9)) // JPEG trailer |
103 | 125 | { |
104 | 126 | // Serial.printf("Found FFD9 at: %d.\n", i); |
105 | 127 | found_FFD9 = true; |
106 | 128 | } |
107 | | - else |
108 | | - { |
109 | | - while ((i < _buf_read) && (!found_FFD9)) |
110 | | - { |
111 | | - if ((_p[i] == 0xFF) && (_p[i + 1] == 0xD9)) // JPEG trailer |
112 | | - { |
113 | | - found_FFD9 = true; |
114 | | - ++i; |
115 | | - } |
116 | | - ++i; |
117 | | - } |
118 | | - } |
119 | | - |
120 | | - // Serial.printf("i: %d\n", i); |
121 | | - memcpy(_mjpeg_buf + _mjpeg_buf_offset, _p, i); |
122 | | - _mjpeg_buf_offset += i; |
123 | | - size_t o = _buf_read - i; |
124 | | - if (o > 0) |
125 | | - { |
126 | | - // Serial.printf("o: %d\n", o); |
127 | | - memcpy(_read_buf, _p + i, o); |
128 | | - _buf_read = fread(_read_buf + o, 1, READ_BUFFER_SIZE - o, _input); |
129 | | - _p = _read_buf; |
130 | | - _inputindex += _buf_read; |
131 | | - _buf_read += o; |
132 | | - // Serial.printf("_buf_read: %d\n", _buf_read); |
133 | | - } |
134 | | - else |
135 | | - { |
136 | | - _buf_read = fread(_read_buf, 1, READ_BUFFER_SIZE, _input); |
137 | | - _p = _read_buf; |
138 | | - _inputindex += _buf_read; |
139 | | - } |
140 | | - i = 0; |
141 | 129 | } |
142 | | - if (found_FFD9) |
| 130 | + |
| 131 | + if (!found_FFD9) |
143 | 132 | { |
144 | | - return true; |
| 133 | + _read += fread(_p + _read, 1, READ_BATCH_SIZE, _input); |
| 134 | + // Serial.printf("_read: %d\n", _read - 1); |
145 | 135 | } |
146 | 136 | } |
147 | 137 |
|
| 138 | + if (found_FFD9) |
| 139 | + { |
| 140 | + ++_p; |
| 141 | + --_read; |
| 142 | + return true; |
| 143 | + } |
| 144 | + |
148 | 145 | return false; |
149 | 146 | } |
150 | 147 |
|
151 | 148 | bool decodeJpg() |
152 | 149 | { |
153 | | - _remain = _mjpeg_buf_offset; |
154 | | - |
155 | 150 | jpeg_decode_picture_info_t header_info; |
156 | | - ESP_ERROR_CHECK(jpeg_decoder_get_info(_mjpeg_buf, _remain, &header_info)); |
| 151 | + ESP_ERROR_CHECK(jpeg_decoder_get_info(_mjpeg_buf, _p - _mjpeg_buf, &header_info)); |
157 | 152 | _w = header_info.width; |
158 | 153 | _h = header_info.height; |
159 | 154 | uint32_t out_size; |
160 | 155 | jpeg_decode_cfg_t decode_cfg_rgb = { |
161 | 156 | .output_format = JPEG_DECODE_OUT_FORMAT_RGB565, |
162 | 157 | .rgb_order = JPEG_DEC_RGB_ELEMENT_ORDER_BGR, |
163 | 158 | }; |
164 | | - ESP_ERROR_CHECK(jpeg_decoder_process(_decoder_engine, &decode_cfg_rgb, (const uint8_t *)_mjpeg_buf, _remain, (uint8_t *)_output_buf, MJPEG_OUTPUT_SIZE, &out_size)); |
| 159 | + ESP_ERROR_CHECK(jpeg_decoder_process(_decoder_engine, &decode_cfg_rgb, (const uint8_t *)_mjpeg_buf, _p - _mjpeg_buf, (uint8_t *)_output_buf, MJPEG_OUTPUT_SIZE, &out_size)); |
165 | 160 |
|
166 | 161 | return true; |
167 | 162 | } |
@@ -191,16 +186,11 @@ class MjpegClass |
191 | 186 | uint8_t *_mjpeg_buf; |
192 | 187 | uint16_t *_output_buf; |
193 | 188 |
|
194 | | - uint8_t *_read_buf; |
195 | | - int32_t _mjpeg_buf_offset = 0; |
196 | | - |
197 | 189 | jpeg_decoder_handle_t _decoder_engine; |
198 | | - |
199 | 190 | int16_t _w = 0, _h = 0; |
200 | 191 |
|
201 | | - int32_t _inputindex = 0; |
202 | | - int32_t _buf_read; |
203 | | - int32_t _remain = 0; |
| 192 | + uint8_t *_p; |
| 193 | + int32_t _read; |
204 | 194 | }; |
205 | 195 |
|
206 | 196 | #endif // defined(ESP32) |
0 commit comments