FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/gdv.c
Date: 2024-11-20 23:03:26
Exec Total Coverage
Lines: 0 329 0.0%
Functions: 0 14 0.0%
Branches: 0 178 0.0%
Line Branch Exec Source
1 /*
2 * Gremlin Digital Video (GDV) decoder
3 * Copyright (c) 2017 Konstantin Shishkov
4 * Copyright (c) 2017 Paul B Mahol
5 *
6 * This file is part of FFmpeg.
7 *
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 */
22
23 #include "libavutil/common.h"
24 #include "libavutil/mem.h"
25 #include "avcodec.h"
26 #include "bytestream.h"
27 #include "codec_internal.h"
28 #include "decode.h"
29
30 typedef struct GDVContext {
31 AVCodecContext *avctx;
32
33 GetByteContext gb;
34 GetByteContext g2;
35 PutByteContext pb;
36
37 uint32_t pal[256];
38 uint8_t *frame;
39 unsigned frame_size;
40 unsigned scale_h, scale_v;
41 } GDVContext;
42
43 typedef struct Bits8 {
44 uint8_t queue;
45 uint8_t fill;
46 } Bits8;
47
48 typedef struct Bits32 {
49 uint32_t queue;
50 uint8_t fill;
51 } Bits32;
52
53 #define PREAMBLE_SIZE 4096
54
55 ✗ static av_cold int gdv_decode_init(AVCodecContext *avctx)
56 {
57 ✗ GDVContext *gdv = avctx->priv_data;
58 int i, j, k;
59
60 ✗ avctx->pix_fmt = AV_PIX_FMT_PAL8;
61 ✗ gdv->frame_size = avctx->width * avctx->height + PREAMBLE_SIZE;
62 ✗ gdv->frame = av_calloc(gdv->frame_size, 1);
63 ✗ if (!gdv->frame)
64 ✗ return AVERROR(ENOMEM);
65
66 ✗ for (i = 0; i < 2; i++) {
67 ✗ for (j = 0; j < 256; j++) {
68 ✗ for (k = 0; k < 8; k++) {
69 ✗ gdv->frame[i * 2048 + j * 8 + k] = j;
70 }
71 }
72 }
73
74 ✗ return 0;
75 }
76
77 ✗ static void scaleup(uint8_t *dst, const uint8_t *src, int w)
78 {
79 int x;
80 ✗ for (x = 0; x < w - 7; x+=8) {
81 ✗ dst[x + 0] =
82 ✗ dst[x + 1] = src[(x>>1) + 0];
83 ✗ dst[x + 2] =
84 ✗ dst[x + 3] = src[(x>>1) + 1];
85 ✗ dst[x + 4] =
86 ✗ dst[x + 5] = src[(x>>1) + 2];
87 ✗ dst[x + 6] =
88 ✗ dst[x + 7] = src[(x>>1) + 3];
89 }
90 ✗ for (; x < w; x++) {
91 ✗ dst[x] = src[(x>>1)];
92 }
93 ✗ }
94
95 ✗ static void scaleup_rev(uint8_t *dst, const uint8_t *src, int w)
96 {
97 int x;
98
99 ✗ for (x = w - 1; (x+1) & 7; x--) {
100 ✗ dst[x] = src[(x>>1)];
101 }
102 ✗ for (x -= 7; x >= 0; x -= 8) {
103 ✗ dst[x + 6] =
104 ✗ dst[x + 7] = src[(x>>1) + 3];
105 ✗ dst[x + 4] =
106 ✗ dst[x + 5] = src[(x>>1) + 2];
107 ✗ dst[x + 2] =
108 ✗ dst[x + 3] = src[(x>>1) + 1];
109 ✗ dst[x + 0] =
110 ✗ dst[x + 1] = src[(x>>1) + 0];
111 }
112 ✗ }
113
114 ✗ static void scaledown(uint8_t *dst, const uint8_t *src, int w)
115 {
116 int x;
117 ✗ for (x = 0; x < w - 7; x+=8) {
118 ✗ dst[x + 0] = src[2*x + 0];
119 ✗ dst[x + 1] = src[2*x + 2];
120 ✗ dst[x + 2] = src[2*x + 4];
121 ✗ dst[x + 3] = src[2*x + 6];
122 ✗ dst[x + 4] = src[2*x + 8];
123 ✗ dst[x + 5] = src[2*x +10];
124 ✗ dst[x + 6] = src[2*x +12];
125 ✗ dst[x + 7] = src[2*x +14];
126 }
127 ✗ for (; x < w; x++) {
128 ✗ dst[x] = src[2*x];
129 }
130 ✗ }
131
132 ✗ static void rescale(GDVContext *gdv, uint8_t *dst, int w, int h, int scale_v, int scale_h)
133 {
134 int j, y;
135
136 ✗ if ((gdv->scale_v == scale_v) && (gdv->scale_h == scale_h)) {
137 ✗ return;
138 }
139
140 ✗ if (gdv->scale_v) {
141 ✗ for (j = 0; j < h; j++) {
142 ✗ int y = h - j - 1;
143 ✗ uint8_t *dst1 = dst + PREAMBLE_SIZE + y * w;
144 ✗ uint8_t *src1 = dst + PREAMBLE_SIZE + (y>>!!gdv->scale_h) * (w>>1);
145
146 ✗ scaleup_rev(dst1, src1, w);
147 }
148 ✗ } else if (gdv->scale_h) {
149 ✗ for (j = 0; j < h; j++) {
150 ✗ int y = h - j - 1;
151 ✗ uint8_t *dst1 = dst + PREAMBLE_SIZE + y * w;
152 ✗ uint8_t *src1 = dst + PREAMBLE_SIZE + (y>>1) * w;
153 ✗ memcpy(dst1, src1, w);
154 }
155 }
156
157 ✗ if (scale_h && scale_v) {
158 ✗ for (y = 0; y < (h>>1); y++) {
159 ✗ uint8_t *dst1 = dst + PREAMBLE_SIZE + y * (w>>1);
160 ✗ uint8_t *src1 = dst + PREAMBLE_SIZE + y*2 * w;
161 ✗ scaledown(dst1, src1, w>>1);
162 }
163 ✗ } else if (scale_h) {
164 ✗ for (y = 0; y < (h>>1); y++) {
165 ✗ uint8_t *dst1 = dst + PREAMBLE_SIZE + y * w;
166 ✗ uint8_t *src1 = dst + PREAMBLE_SIZE + y*2 * w;
167 ✗ memcpy(dst1, src1, w);
168 }
169 ✗ } else if (scale_v) {
170 ✗ for (y = 0; y < h; y++) {
171 ✗ uint8_t *dst1 = dst + PREAMBLE_SIZE + y * w;
172 ✗ scaledown(dst1, dst1, w>>1);
173 }
174 }
175
176 ✗ gdv->scale_v = scale_v;
177 ✗ gdv->scale_h = scale_h;
178 }
179
180 ✗ static int read_bits2(Bits8 *bits, GetByteContext *gb)
181 {
182 int res;
183
184 ✗ if (bits->fill == 0) {
185 ✗ bits->queue |= bytestream2_get_byte(gb);
186 ✗ bits->fill = 8;
187 }
188 ✗ res = bits->queue >> 6;
189 ✗ bits->queue <<= 2;
190 ✗ bits->fill -= 2;
191
192 ✗ return res;
193 }
194
195 ✗ static void fill_bits32(Bits32 *bits, GetByteContext *gb)
196 {
197 ✗ bits->queue = bytestream2_get_le32(gb);
198 ✗ bits->fill = 32;
199 ✗ }
200
201 ✗ static int read_bits32(Bits32 *bits, GetByteContext *gb, int nbits)
202 {
203 ✗ int res = bits->queue & ((1 << nbits) - 1);
204
205 ✗ bits->queue >>= nbits;
206 ✗ bits->fill -= nbits;
207 ✗ if (bits->fill <= 16) {
208 ✗ bits->queue |= bytestream2_get_le16(gb) << bits->fill;
209 ✗ bits->fill += 16;
210 }
211
212 ✗ return res;
213 }
214
215 ✗ static void lz_copy(PutByteContext *pb, GetByteContext *g2, int offset, unsigned len)
216 {
217 int i;
218
219 ✗ if (offset == -1) {
220 int c;
221
222 ✗ bytestream2_seek(g2, bytestream2_tell_p(pb) - 1, SEEK_SET);
223 ✗ c = bytestream2_get_byte(g2);
224 ✗ for (i = 0; i < len; i++) {
225 ✗ bytestream2_put_byte(pb, c);
226 }
227 ✗ } else if (offset < 0) {
228 ✗ int start = bytestream2_tell_p(pb) - (-offset);
229
230 ✗ bytestream2_seek(g2, start, SEEK_SET);
231 ✗ for (i = 0; i < len; i++) {
232 ✗ bytestream2_put_byte(pb, bytestream2_get_byte(g2));
233 }
234 } else {
235 ✗ int start = bytestream2_tell_p(pb) + offset;
236
237 ✗ bytestream2_seek(g2, start, SEEK_SET);
238 ✗ for (i = 0; i < len; i++) {
239 ✗ bytestream2_put_byte(pb, bytestream2_get_byte(g2));
240 }
241 }
242 ✗ }
243
244 ✗ static int decompress_2(AVCodecContext *avctx)
245 {
246 ✗ GDVContext *gdv = avctx->priv_data;
247 ✗ GetByteContext *gb = &gdv->gb;
248 ✗ GetByteContext *g2 = &gdv->g2;
249 ✗ PutByteContext *pb = &gdv->pb;
250 ✗ Bits8 bits = { 0 };
251 int c, i;
252
253 ✗ bytestream2_init(g2, gdv->frame, gdv->frame_size);
254 ✗ bytestream2_skip_p(pb, PREAMBLE_SIZE);
255
256 ✗ for (c = 0; c < 256; c++) {
257 ✗ for (i = 0; i < 16; i++) {
258 ✗ gdv->frame[c * 16 + i] = c;
259 }
260 }
261
262 ✗ while (bytestream2_get_bytes_left_p(pb) > 0 && bytestream2_get_bytes_left(gb) > 0) {
263 ✗ int tag = read_bits2(&bits, gb);
264 ✗ if (tag == 0) {
265 ✗ bytestream2_put_byte(pb, bytestream2_get_byte(gb));
266 ✗ } else if (tag == 1) {
267 ✗ int b = bytestream2_get_byte(gb);
268 ✗ int len = (b & 0xF) + 3;
269 ✗ int top = (b >> 4) & 0xF;
270 ✗ int off = (bytestream2_get_byte(gb) << 4) + top - 4096;
271 ✗ lz_copy(pb, g2, off, len);
272 ✗ } else if (tag == 2) {
273 ✗ int len = (bytestream2_get_byte(gb)) + 2;
274 ✗ bytestream2_skip_p(pb, len);
275 } else {
276 ✗ break;
277 }
278 }
279
280 ✗ if (bytestream2_get_bytes_left_p(pb) > 0)
281 ✗ return AVERROR_INVALIDDATA;
282
283 ✗ return 0;
284 }
285
286 ✗ static int decompress_5(AVCodecContext *avctx, unsigned skip)
287 {
288 ✗ GDVContext *gdv = avctx->priv_data;
289 ✗ GetByteContext *gb = &gdv->gb;
290 ✗ GetByteContext *g2 = &gdv->g2;
291 ✗ PutByteContext *pb = &gdv->pb;
292 ✗ Bits8 bits = { 0 };
293
294 ✗ bytestream2_init(g2, gdv->frame, gdv->frame_size);
295 ✗ bytestream2_skip_p(pb, skip + PREAMBLE_SIZE);
296
297 ✗ while (bytestream2_get_bytes_left_p(pb) > 0 && bytestream2_get_bytes_left(gb) > 0) {
298 ✗ int tag = read_bits2(&bits, gb);
299 ✗ if (bytestream2_get_bytes_left(gb) < 1)
300 ✗ return AVERROR_INVALIDDATA;
301 ✗ if (tag == 0) {
302 ✗ bytestream2_put_byte(pb, bytestream2_get_byte(gb));
303 ✗ } else if (tag == 1) {
304 ✗ int b = bytestream2_get_byte(gb);
305 ✗ int len = (b & 0xF) + 3;
306 ✗ int top = b >> 4;
307 ✗ int off = (bytestream2_get_byte(gb) << 4) + top - 4096;
308 ✗ lz_copy(pb, g2, off, len);
309 ✗ } else if (tag == 2) {
310 int len;
311 ✗ int b = bytestream2_get_byte(gb);
312 ✗ if (b == 0) {
313 ✗ return 0;
314 }
315 ✗ if (b != 0xFF) {
316 ✗ len = b;
317 } else {
318 ✗ len = bytestream2_get_le16(gb);
319 }
320 ✗ bytestream2_skip_p(pb, len + 1);
321 } else {
322 ✗ int b = bytestream2_get_byte(gb);
323 ✗ int len = (b & 0x3) + 2;
324 ✗ int off = -(b >> 2) - 1;
325 ✗ lz_copy(pb, g2, off, len);
326 }
327 }
328 ✗ if (bytestream2_get_bytes_left_p(pb) > 0)
329 ✗ return AVERROR_INVALIDDATA;
330 ✗ return 0;
331 }
332
333 ✗ static int decompress_68(AVCodecContext *avctx, unsigned skip, unsigned use8)
334 {
335 ✗ GDVContext *gdv = avctx->priv_data;
336 ✗ GetByteContext *gb = &gdv->gb;
337 ✗ GetByteContext *g2 = &gdv->g2;
338 ✗ PutByteContext *pb = &gdv->pb;
339 Bits32 bits;
340
341 ✗ bytestream2_init(g2, gdv->frame, gdv->frame_size);
342 ✗ bytestream2_skip_p(pb, skip + PREAMBLE_SIZE);
343 ✗ fill_bits32(&bits, gb);
344
345 ✗ while (bytestream2_get_bytes_left_p(pb) > 0 && bytestream2_get_bytes_left(gb) > 0) {
346 ✗ int tag = read_bits32(&bits, gb, 2);
347 ✗ if (tag == 0) {
348 ✗ int b = read_bits32(&bits, gb, 1);
349 ✗ if (b == 0) {
350 ✗ bytestream2_put_byte(pb, bytestream2_get_byte(gb));
351 } else {
352 ✗ int i, len = 2;
353 ✗ int lbits = 0;
354 ✗ while (1) {
355 int val;
356
357 ✗ lbits += 1;
358 ✗ val = read_bits32(&bits, gb, lbits);
359 ✗ len += val;
360 ✗ if (val != ((1 << lbits) - 1)) {
361 ✗ break;
362 }
363 ✗ if (lbits >= 16)
364 ✗ return AVERROR_INVALIDDATA;
365 }
366 ✗ for (i = 0; i < len; i++) {
367 ✗ bytestream2_put_byte(pb, bytestream2_get_byte(gb));
368 }
369 }
370 ✗ } else if (tag == 1) {
371 ✗ int b = read_bits32(&bits, gb, 1);
372 int len;
373
374 ✗ if (b == 0) {
375 ✗ len = (read_bits32(&bits, gb, 4)) + 2;
376 } else {
377 ✗ int bb = bytestream2_get_byte(gb);
378 ✗ if ((bb & 0x80) == 0) {
379 ✗ len = bb + 18;
380 } else {
381 ✗ int top = (bb & 0x7F) << 8;
382 ✗ len = top + bytestream2_get_byte(gb) + 146;
383 }
384 }
385 ✗ bytestream2_skip_p(pb, len);
386 ✗ } else if (tag == 2) {
387 ✗ int i, subtag = read_bits32(&bits, gb, 2);
388
389 ✗ if (subtag != 3) {
390 ✗ int top = (read_bits32(&bits, gb, 4)) << 8;
391 ✗ int offs = top + bytestream2_get_byte(gb);
392 ✗ if ((subtag != 0) || (offs <= 0xF80)) {
393 ✗ int len = (subtag) + 3;
394 ✗ lz_copy(pb, g2, (offs) - 4096, len);
395 } else {
396 int real_off, len, c1, c2;
397
398 ✗ if (offs == 0xFFF) {
399 ✗ return 0;
400 }
401
402 ✗ real_off = ((offs >> 4) & 0x7) + 1;
403 ✗ len = ((offs & 0xF) + 2) * 2;
404 ✗ c1 = gdv->frame[bytestream2_tell_p(pb) - real_off];
405 ✗ c2 = gdv->frame[bytestream2_tell_p(pb) - real_off + 1];
406 ✗ for (i = 0; i < len/2; i++) {
407 ✗ bytestream2_put_byte(pb, c1);
408 ✗ bytestream2_put_byte(pb, c2);
409 }
410 }
411 } else {
412 ✗ int b = bytestream2_get_byte(gb);
413 ✗ int off = ((b & 0x7F)) + 1;
414 ✗ int len = ((b & 0x80) == 0) ? 2 : 3;
415
416 ✗ lz_copy(pb, g2, -off, len);
417 }
418 } else {
419 int len;
420 int off;
421 ✗ if (use8) {
422 ✗ int q, b = bytestream2_get_byte(gb);
423 ✗ if ((b & 0xC0) == 0xC0) {
424 ✗ len = ((b & 0x3F)) + 8;
425 ✗ q = read_bits32(&bits, gb, 4);
426 ✗ off = (q << 8) + (bytestream2_get_byte(gb)) + 1;
427 } else {
428 int ofs1;
429 ✗ if ((b & 0x80) == 0) {
430 ✗ len = ((b >> 4)) + 6;
431 ✗ ofs1 = (b & 0xF);
432 } else {
433 ✗ len = ((b & 0x3F)) + 14;
434 ✗ ofs1 = read_bits32(&bits, gb, 4);
435 }
436 ✗ off = (ofs1 << 8) + (bytestream2_get_byte(gb)) - 4096;
437 }
438 } else {
439 ✗ int ofs1, b = bytestream2_get_byte(gb);
440
441 ✗ if ((b >> 4) == 0xF) {
442 ✗ len = bytestream2_get_byte(gb) + 21;
443 } else {
444 ✗ len = (b >> 4) + 6;
445 }
446 ✗ ofs1 = (b & 0xF);
447 ✗ off = (ofs1 << 8) + bytestream2_get_byte(gb) - 4096;
448 }
449 ✗ lz_copy(pb, g2, off, len);
450 }
451 }
452
453 ✗ if (bytestream2_get_bytes_left_p(pb) > 0)
454 ✗ return AVERROR_INVALIDDATA;
455
456 ✗ return 0;
457 }
458
459 ✗ static int gdv_decode_frame(AVCodecContext *avctx, AVFrame *frame,
460 int *got_frame, AVPacket *avpkt)
461 {
462 ✗ GDVContext *gdv = avctx->priv_data;
463 ✗ GetByteContext *gb = &gdv->gb;
464 ✗ PutByteContext *pb = &gdv->pb;
465 int ret, i;
466 int compression;
467 unsigned flags;
468 uint8_t *dst;
469
470 ✗ bytestream2_init(gb, avpkt->data, avpkt->size);
471 ✗ bytestream2_init_writer(pb, gdv->frame, gdv->frame_size);
472
473 ✗ flags = bytestream2_get_le32(gb);
474 ✗ compression = flags & 0xF;
475
476 ✗ if (compression == 4 || compression == 7 || compression > 8)
477 ✗ return AVERROR_INVALIDDATA;
478
479 ✗ if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
480 ✗ return ret;
481 ✗ ff_copy_palette(gdv->pal, avpkt, avctx);
482
483 ✗ if (compression < 2 && bytestream2_get_bytes_left(gb) < 256*3)
484 ✗ return AVERROR_INVALIDDATA;
485 ✗ rescale(gdv, gdv->frame, avctx->width, avctx->height,
486 ✗ !!(flags & 0x10), !!(flags & 0x20));
487
488 ✗ switch (compression) {
489 ✗ case 1:
490 ✗ memset(gdv->frame + PREAMBLE_SIZE, 0, gdv->frame_size - PREAMBLE_SIZE);
491 ✗ case 0:
492 ✗ for (i = 0; i < 256; i++) {
493 ✗ unsigned r = bytestream2_get_byte(gb);
494 ✗ unsigned g = bytestream2_get_byte(gb);
495 ✗ unsigned b = bytestream2_get_byte(gb);
496 ✗ gdv->pal[i] = 0xFFU << 24 | r << 18 | g << 10 | b << 2;
497 }
498 ✗ break;
499 ✗ case 2:
500 ✗ ret = decompress_2(avctx);
501 ✗ break;
502 ✗ case 3:
503 ✗ break;
504 ✗ case 5:
505 ✗ ret = decompress_5(avctx, flags >> 8);
506 ✗ break;
507 ✗ case 6:
508 ✗ ret = decompress_68(avctx, flags >> 8, 0);
509 ✗ break;
510 ✗ case 8:
511 ✗ ret = decompress_68(avctx, flags >> 8, 1);
512 ✗ break;
513 ✗ default:
514 ✗ av_assert0(0);
515 }
516 ✗ if (ret < 0)
517 ✗ return ret;
518
519 ✗ memcpy(frame->data[1], gdv->pal, AVPALETTE_SIZE);
520 ✗ dst = frame->data[0];
521
522 ✗ if (!gdv->scale_v && !gdv->scale_h) {
523 ✗ int sidx = PREAMBLE_SIZE, didx = 0;
524 int y;
525
526 ✗ for (y = 0; y < avctx->height; y++) {
527 ✗ memcpy(dst + didx, gdv->frame + sidx, avctx->width);
528 ✗ sidx += avctx->width;
529 ✗ didx += frame->linesize[0];
530 }
531 } else {
532 ✗ int sidx = PREAMBLE_SIZE, didx = 0;
533 int y;
534
535 ✗ for (y = 0; y < avctx->height; y++) {
536 ✗ if (!gdv->scale_v) {
537 ✗ memcpy(dst + didx, gdv->frame + sidx, avctx->width);
538 } else {
539 ✗ uint8_t *dst2 = dst + didx;
540 ✗ uint8_t *src2 = gdv->frame + sidx;
541
542 ✗ scaleup(dst2, src2, avctx->width);
543 }
544 ✗ if (!gdv->scale_h || ((y & 1) == 1)) {
545 ✗ sidx += !gdv->scale_v ? avctx->width : avctx->width/2;
546 }
547 ✗ didx += frame->linesize[0];
548 }
549 }
550
551 ✗ *got_frame = 1;
552
553 ✗ return avpkt->size;
554 }
555
556 ✗ static av_cold int gdv_decode_close(AVCodecContext *avctx)
557 {
558 ✗ GDVContext *gdv = avctx->priv_data;
559 ✗ av_freep(&gdv->frame);
560 ✗ return 0;
561 }
562
563 const FFCodec ff_gdv_decoder = {
564 .p.name = "gdv",
565 CODEC_LONG_NAME("Gremlin Digital Video"),
566 .p.type = AVMEDIA_TYPE_VIDEO,
567 .p.id = AV_CODEC_ID_GDV,
568 .priv_data_size = sizeof(GDVContext),
569 .init = gdv_decode_init,
570 .close = gdv_decode_close,
571 FF_CODEC_DECODE_CB(gdv_decode_frame),
572 .p.capabilities = AV_CODEC_CAP_DR1,
573 };
574