FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/cbs_jpeg.c
Date: 2022-12-09 07:38:14
Exec Total Coverage
Lines: 0 189 0.0%
Functions: 0 6 0.0%
Branches: 0 148 0.0%

Line Branch Exec Source
1 /*
2 * This file is part of FFmpeg.
3 *
4 * FFmpeg is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * FFmpeg is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with FFmpeg; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19 #include "cbs.h"
20 #include "cbs_internal.h"
21 #include "cbs_jpeg.h"
22
23
24 #define HEADER(name) do { \
25 ff_cbs_trace_header(ctx, name); \
26 } while (0)
27
28 #define CHECK(call) do { \
29 err = (call); \
30 if (err < 0) \
31 return err; \
32 } while (0)
33
34 #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)
35
36 #define u(width, name, range_min, range_max) \
37 xu(width, name, range_min, range_max, 0, )
38 #define us(width, name, sub, range_min, range_max) \
39 xu(width, name, range_min, range_max, 1, sub)
40
41
42 #define READ
43 #define READWRITE read
44 #define RWContext GetBitContext
45 #define FUNC(name) cbs_jpeg_read_ ## name
46
47 #define xu(width, name, range_min, range_max, subs, ...) do { \
48 uint32_t value; \
49 CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
50 SUBSCRIPTS(subs, __VA_ARGS__), \
51 &value, range_min, range_max)); \
52 current->name = value; \
53 } while (0)
54
55 #include "cbs_jpeg_syntax_template.c"
56
57 #undef READ
58 #undef READWRITE
59 #undef RWContext
60 #undef FUNC
61 #undef xu
62
63 #define WRITE
64 #define READWRITE write
65 #define RWContext PutBitContext
66 #define FUNC(name) cbs_jpeg_write_ ## name
67
68 #define xu(width, name, range_min, range_max, subs, ...) do { \
69 uint32_t value = current->name; \
70 CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
71 SUBSCRIPTS(subs, __VA_ARGS__), \
72 value, range_min, range_max)); \
73 } while (0)
74
75
76 #include "cbs_jpeg_syntax_template.c"
77
78 #undef WRITE
79 #undef READWRITE
80 #undef RWContext
81 #undef FUNC
82 #undef xu
83
84
85 static int cbs_jpeg_split_fragment(CodedBitstreamContext *ctx,
86 CodedBitstreamFragment *frag,
87 int header)
88 {
89 AVBufferRef *data_ref;
90 uint8_t *data;
91 size_t data_size;
92 int start, end, marker, next_start, next_marker;
93 int err, i, j, length;
94
95 if (frag->data_size < 4) {
96 // Definitely too short to be meaningful.
97 return AVERROR_INVALIDDATA;
98 }
99
100 for (i = 0; i + 1 < frag->data_size && frag->data[i] != 0xff; i++);
101 if (i > 0) {
102 av_log(ctx->log_ctx, AV_LOG_WARNING, "Discarding %d bytes at "
103 "beginning of image.\n", i);
104 }
105 for (++i; i + 1 < frag->data_size && frag->data[i] == 0xff; i++);
106 if (i + 1 >= frag->data_size && frag->data[i]) {
107 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: "
108 "no SOI marker found.\n");
109 return AVERROR_INVALIDDATA;
110 }
111 marker = frag->data[i];
112 if (marker != JPEG_MARKER_SOI) {
113 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: first "
114 "marker is %02x, should be SOI.\n", marker);
115 return AVERROR_INVALIDDATA;
116 }
117 for (++i; i + 1 < frag->data_size && frag->data[i] == 0xff; i++);
118 if (i + 1 >= frag->data_size) {
119 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: "
120 "no image content found.\n");
121 return AVERROR_INVALIDDATA;
122 }
123 marker = frag->data[i];
124 start = i + 1;
125
126 do {
127 if (marker == JPEG_MARKER_EOI) {
128 break;
129 } else if (marker == JPEG_MARKER_SOS) {
130 next_marker = -1;
131 end = start;
132 for (i = start; i + 1 < frag->data_size; i++) {
133 if (frag->data[i] != 0xff)
134 continue;
135 end = i;
136 for (++i; i + 1 < frag->data_size &&
137 frag->data[i] == 0xff; i++);
138 if (i + 1 < frag->data_size) {
139 if (frag->data[i] == 0x00)
140 continue;
141 next_marker = frag->data[i];
142 next_start = i + 1;
143 }
144 break;
145 }
146 } else {
147 i = start;
148 if (i + 2 > frag->data_size) {
149 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: "
150 "truncated at %02x marker.\n", marker);
151 return AVERROR_INVALIDDATA;
152 }
153 length = AV_RB16(frag->data + i);
154 if (i + length > frag->data_size) {
155 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: "
156 "truncated at %02x marker segment.\n", marker);
157 return AVERROR_INVALIDDATA;
158 }
159 end = start + length;
160
161 i = end;
162 if (frag->data[i] != 0xff) {
163 next_marker = -1;
164 } else {
165 for (++i; i + 1 < frag->data_size &&
166 frag->data[i] == 0xff; i++);
167 if (i + 1 >= frag->data_size) {
168 next_marker = -1;
169 } else {
170 next_marker = frag->data[i];
171 next_start = i + 1;
172 }
173 }
174 }
175
176 if (marker == JPEG_MARKER_SOS) {
177 length = AV_RB16(frag->data + start);
178
179 if (length > end - start)
180 return AVERROR_INVALIDDATA;
181
182 data_ref = NULL;
183 data = av_malloc(end - start +
184 AV_INPUT_BUFFER_PADDING_SIZE);
185 if (!data)
186 return AVERROR(ENOMEM);
187
188 memcpy(data, frag->data + start, length);
189 for (i = start + length, j = length; i < end; i++, j++) {
190 if (frag->data[i] == 0xff) {
191 while (frag->data[i] == 0xff)
192 ++i;
193 data[j] = 0xff;
194 } else {
195 data[j] = frag->data[i];
196 }
197 }
198 data_size = j;
199
200 memset(data + data_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
201
202 } else {
203 data = frag->data + start;
204 data_size = end - start;
205 data_ref = frag->data_ref;
206 }
207
208 err = ff_cbs_append_unit_data(frag, marker,
209 data, data_size, data_ref);
210 if (err < 0)
211 return err;
212
213 marker = next_marker;
214 start = next_start;
215 } while (next_marker != -1);
216
217 return 0;
218 }
219
220 static int cbs_jpeg_read_unit(CodedBitstreamContext *ctx,
221 CodedBitstreamUnit *unit)
222 {
223 GetBitContext gbc;
224 int err;
225
226 err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
227 if (err < 0)
228 return err;
229
230 err = ff_cbs_alloc_unit_content(ctx, unit);
231 if (err < 0)
232 return err;
233
234 if (unit->type >= JPEG_MARKER_SOF0 &&
235 unit->type <= JPEG_MARKER_SOF3) {
236 err = cbs_jpeg_read_frame_header(ctx, &gbc, unit->content);
237 if (err < 0)
238 return err;
239
240 } else if (unit->type >= JPEG_MARKER_APPN &&
241 unit->type <= JPEG_MARKER_APPN + 15) {
242 err = cbs_jpeg_read_application_data(ctx, &gbc, unit->content);
243 if (err < 0)
244 return err;
245
246 } else if (unit->type == JPEG_MARKER_SOS) {
247 JPEGRawScan *scan = unit->content;
248 int pos;
249
250 err = cbs_jpeg_read_scan_header(ctx, &gbc, &scan->header);
251 if (err < 0)
252 return err;
253
254 pos = get_bits_count(&gbc);
255 av_assert0(pos % 8 == 0);
256 if (pos > 0) {
257 scan->data_size = unit->data_size - pos / 8;
258 scan->data_ref = av_buffer_ref(unit->data_ref);
259 if (!scan->data_ref)
260 return AVERROR(ENOMEM);
261 scan->data = unit->data + pos / 8;
262 }
263
264 } else {
265 switch (unit->type) {
266 #define SEGMENT(marker, func) \
267 case JPEG_MARKER_ ## marker: \
268 { \
269 err = cbs_jpeg_read_ ## func(ctx, &gbc, unit->content); \
270 if (err < 0) \
271 return err; \
272 } \
273 break
274 SEGMENT(DQT, dqt);
275 SEGMENT(DHT, dht);
276 SEGMENT(COM, comment);
277 #undef SEGMENT
278 default:
279 return AVERROR(ENOSYS);
280 }
281 }
282
283 return 0;
284 }
285
286 static int cbs_jpeg_write_scan(CodedBitstreamContext *ctx,
287 CodedBitstreamUnit *unit,
288 PutBitContext *pbc)
289 {
290 JPEGRawScan *scan = unit->content;
291 int err;
292
293 err = cbs_jpeg_write_scan_header(ctx, pbc, &scan->header);
294 if (err < 0)
295 return err;
296
297 if (scan->data) {
298 if (scan->data_size * 8 > put_bits_left(pbc))
299 return AVERROR(ENOSPC);
300
301 av_assert0(put_bits_count(pbc) % 8 == 0);
302
303 flush_put_bits(pbc);
304
305 memcpy(put_bits_ptr(pbc), scan->data, scan->data_size);
306 skip_put_bytes(pbc, scan->data_size);
307 }
308
309 return 0;
310 }
311
312 static int cbs_jpeg_write_segment(CodedBitstreamContext *ctx,
313 CodedBitstreamUnit *unit,
314 PutBitContext *pbc)
315 {
316 int err;
317
318 if (unit->type >= JPEG_MARKER_SOF0 &&
319 unit->type <= JPEG_MARKER_SOF3) {
320 err = cbs_jpeg_write_frame_header(ctx, pbc, unit->content);
321 } else if (unit->type >= JPEG_MARKER_APPN &&
322 unit->type <= JPEG_MARKER_APPN + 15) {
323 err = cbs_jpeg_write_application_data(ctx, pbc, unit->content);
324 } else {
325 switch (unit->type) {
326 #define SEGMENT(marker, func) \
327 case JPEG_MARKER_ ## marker: \
328 err = cbs_jpeg_write_ ## func(ctx, pbc, unit->content); \
329 break;
330 SEGMENT(DQT, dqt);
331 SEGMENT(DHT, dht);
332 SEGMENT(COM, comment);
333 default:
334 return AVERROR_PATCHWELCOME;
335 }
336 }
337
338 return err;
339 }
340
341 static int cbs_jpeg_write_unit(CodedBitstreamContext *ctx,
342 CodedBitstreamUnit *unit,
343 PutBitContext *pbc)
344 {
345 if (unit->type == JPEG_MARKER_SOS)
346 return cbs_jpeg_write_scan (ctx, unit, pbc);
347 else
348 return cbs_jpeg_write_segment(ctx, unit, pbc);
349 }
350
351 static int cbs_jpeg_assemble_fragment(CodedBitstreamContext *ctx,
352 CodedBitstreamFragment *frag)
353 {
354 const CodedBitstreamUnit *unit;
355 uint8_t *data;
356 size_t size, dp, sp;
357 int i;
358
359 size = 4; // SOI + EOI.
360 for (i = 0; i < frag->nb_units; i++) {
361 unit = &frag->units[i];
362 size += 2 + unit->data_size;
363 if (unit->type == JPEG_MARKER_SOS) {
364 for (sp = 0; sp < unit->data_size; sp++) {
365 if (unit->data[sp] == 0xff)
366 ++size;
367 }
368 }
369 }
370
371 frag->data_ref = av_buffer_alloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
372 if (!frag->data_ref)
373 return AVERROR(ENOMEM);
374 data = frag->data_ref->data;
375
376 dp = 0;
377
378 data[dp++] = 0xff;
379 data[dp++] = JPEG_MARKER_SOI;
380
381 for (i = 0; i < frag->nb_units; i++) {
382 unit = &frag->units[i];
383
384 data[dp++] = 0xff;
385 data[dp++] = unit->type;
386
387 if (unit->type != JPEG_MARKER_SOS) {
388 memcpy(data + dp, unit->data, unit->data_size);
389 dp += unit->data_size;
390 } else {
391 sp = AV_RB16(unit->data);
392 av_assert0(sp <= unit->data_size);
393 memcpy(data + dp, unit->data, sp);
394 dp += sp;
395
396 for (; sp < unit->data_size; sp++) {
397 if (unit->data[sp] == 0xff) {
398 data[dp++] = 0xff;
399 data[dp++] = 0x00;
400 } else {
401 data[dp++] = unit->data[sp];
402 }
403 }
404 }
405 }
406
407 data[dp++] = 0xff;
408 data[dp++] = JPEG_MARKER_EOI;
409
410 av_assert0(dp == size);
411
412 memset(data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
413 frag->data = data;
414 frag->data_size = size;
415
416 return 0;
417 }
418
419 static const CodedBitstreamUnitTypeDescriptor cbs_jpeg_unit_types[] = {
420 CBS_UNIT_RANGE_POD(JPEG_MARKER_SOF0, JPEG_MARKER_SOF3, JPEGRawFrameHeader),
421
422 CBS_UNIT_RANGE_INTERNAL_REF(JPEG_MARKER_APPN, JPEG_MARKER_APPN + 15,
423 JPEGRawApplicationData, Ap),
424
425 CBS_UNIT_TYPE_INTERNAL_REF(JPEG_MARKER_SOS, JPEGRawScan, data),
426
427 CBS_UNIT_TYPE_POD(JPEG_MARKER_DQT, JPEGRawQuantisationTableSpecification),
428 CBS_UNIT_TYPE_POD(JPEG_MARKER_DHT, JPEGRawHuffmanTableSpecification),
429
430 CBS_UNIT_TYPE_INTERNAL_REF(JPEG_MARKER_COM, JPEGRawComment, Cm),
431
432 CBS_UNIT_TYPE_END_OF_LIST
433 };
434
435 const CodedBitstreamType ff_cbs_type_jpeg = {
436 .codec_id = AV_CODEC_ID_MJPEG,
437
438 .unit_types = cbs_jpeg_unit_types,
439
440 .split_fragment = &cbs_jpeg_split_fragment,
441 .read_unit = &cbs_jpeg_read_unit,
442 .write_unit = &cbs_jpeg_write_unit,
443 .assemble_fragment = &cbs_jpeg_assemble_fragment,
444 };
445