FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/agm.c
Date: 2022-07-07 01:21:54
Exec Total Coverage
Lines: 0 773 0.0%
Branches: 0 481 0.0%

Line Branch Exec Source
1 /*
2 * Amuse Graphics Movie decoder
3 *
4 * Copyright (c) 2018 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 <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26
27 #define BITSTREAM_READER_LE
28
29 #include "libavutil/mem_internal.h"
30
31 #include "avcodec.h"
32 #include "bytestream.h"
33 #include "codec_internal.h"
34 #include "copy_block.h"
35 #include "get_bits.h"
36 #include "idctdsp.h"
37 #include "internal.h"
38
39 static const uint8_t unscaled_luma[64] = {
40 16, 11, 10, 16, 24, 40, 51, 61, 12, 12, 14, 19,
41 26, 58, 60, 55, 14, 13, 16, 24, 40, 57, 69, 56,
42 14, 17, 22, 29, 51, 87, 80, 62, 18, 22, 37, 56,
43 68,109,103, 77, 24, 35, 55, 64, 81,104,113, 92,
44 49, 64, 78, 87,103,121,120,101, 72, 92, 95, 98,
45 112,100,103,99
46 };
47
48 static const uint8_t unscaled_chroma[64] = {
49 17, 18, 24, 47, 99, 99, 99, 99, 18, 21, 26, 66,
50 99, 99, 99, 99, 24, 26, 56, 99, 99, 99, 99, 99,
51 47, 66, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
52 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
53 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
54 99, 99, 99, 99
55 };
56
57 typedef struct MotionVector {
58 int16_t x, y;
59 } MotionVector;
60
61 typedef struct AGMContext {
62 const AVClass *class;
63 AVCodecContext *avctx;
64 GetBitContext gb;
65 GetByteContext gbyte;
66
67 int key_frame;
68 int bitstream_size;
69 int compression;
70 int blocks_w;
71 int blocks_h;
72 int size[3];
73 int plus;
74 int dct;
75 int rgb;
76 unsigned flags;
77 unsigned fflags;
78
79 uint8_t *output;
80 unsigned padded_output_size;
81 unsigned output_size;
82
83 MotionVector *mvectors;
84 unsigned mvectors_size;
85
86 VLC vlc;
87
88 AVFrame *prev_frame;
89
90 int luma_quant_matrix[64];
91 int chroma_quant_matrix[64];
92
93 ScanTable scantable;
94 DECLARE_ALIGNED(32, int16_t, block)[64];
95
96 int16_t *wblocks;
97 unsigned wblocks_size;
98
99 int *map;
100 unsigned map_size;
101
102 IDCTDSPContext idsp;
103 } AGMContext;
104
105 static int read_code(GetBitContext *gb, int *oskip, int *level, int *map, int mode)
106 {
107 int len = 0, skip = 0, max;
108
109 if (get_bits_left(gb) < 2)
110 return AVERROR_INVALIDDATA;
111
112 if (show_bits(gb, 2)) {
113 switch (show_bits(gb, 4)) {
114 case 1:
115 case 9:
116 len = 1;
117 skip = 3;
118 break;
119 case 2:
120 len = 3;
121 skip = 4;
122 break;
123 case 3:
124 len = 7;
125 skip = 4;
126 break;
127 case 5:
128 case 13:
129 len = 2;
130 skip = 3;
131 break;
132 case 6:
133 len = 4;
134 skip = 4;
135 break;
136 case 7:
137 len = 8;
138 skip = 4;
139 break;
140 case 10:
141 len = 5;
142 skip = 4;
143 break;
144 case 11:
145 len = 9;
146 skip = 4;
147 break;
148 case 14:
149 len = 6;
150 skip = 4;
151 break;
152 case 15:
153 len = ((show_bits(gb, 5) & 0x10) | 0xA0) >> 4;
154 skip = 5;
155 break;
156 default:
157 return AVERROR_INVALIDDATA;
158 }
159
160 skip_bits(gb, skip);
161 *level = get_bits(gb, len);
162 *map = 1;
163 *oskip = 0;
164 max = 1 << (len - 1);
165 if (*level < max)
166 *level = -(max + *level);
167 } else if (show_bits(gb, 3) & 4) {
168 skip_bits(gb, 3);
169 if (mode == 1) {
170 if (show_bits(gb, 4)) {
171 if (show_bits(gb, 4) == 1) {
172 skip_bits(gb, 4);
173 *oskip = get_bits(gb, 16);
174 } else {
175 *oskip = get_bits(gb, 4);
176 }
177 } else {
178 skip_bits(gb, 4);
179 *oskip = get_bits(gb, 10);
180 }
181 } else if (mode == 0) {
182 *oskip = get_bits(gb, 10);
183 }
184 *level = 0;
185 } else {
186 skip_bits(gb, 3);
187 if (mode == 0)
188 *oskip = get_bits(gb, 4);
189 else if (mode == 1)
190 *oskip = 0;
191 *level = 0;
192 }
193
194 return 0;
195 }
196
197 static int decode_intra_blocks(AGMContext *s, GetBitContext *gb,
198 const int *quant_matrix, int *skip, int *dc_level)
199 {
200 const uint8_t *scantable = s->scantable.permutated;
201 int level, ret, map = 0;
202
203 memset(s->wblocks, 0, s->wblocks_size);
204
205 for (int i = 0; i < 64; i++) {
206 int16_t *block = s->wblocks + scantable[i];
207
208 for (int j = 0; j < s->blocks_w;) {
209 if (*skip > 0) {
210 int rskip;
211
212 rskip = FFMIN(*skip, s->blocks_w - j);
213 j += rskip;
214 if (i == 0) {
215 for (int k = 0; k < rskip; k++)
216 block[64 * k] = *dc_level * quant_matrix[0];
217 }
218 block += rskip * 64;
219 *skip -= rskip;
220 } else {
221 ret = read_code(gb, skip, &level, &map, s->flags & 1);
222 if (ret < 0)
223 return ret;
224
225 if (i == 0)
226 *dc_level += level;
227
228 block[0] = (i == 0 ? *dc_level : level) * quant_matrix[i];
229 block += 64;
230 j++;
231 }
232 }
233 }
234
235 return 0;
236 }
237
238 static int decode_inter_blocks(AGMContext *s, GetBitContext *gb,
239 const int *quant_matrix, int *skip,
240 int *map)
241 {
242 const uint8_t *scantable = s->scantable.permutated;
243 int level, ret;
244
245 memset(s->wblocks, 0, s->wblocks_size);
246 memset(s->map, 0, s->map_size);
247
248 for (int i = 0; i < 64; i++) {
249 int16_t *block = s->wblocks + scantable[i];
250
251 for (int j = 0; j < s->blocks_w;) {
252 if (*skip > 0) {
253 int rskip;
254
255 rskip = FFMIN(*skip, s->blocks_w - j);
256 j += rskip;
257 block += rskip * 64;
258 *skip -= rskip;
259 } else {
260 ret = read_code(gb, skip, &level, &map[j], s->flags & 1);
261 if (ret < 0)
262 return ret;
263
264 block[0] = level * quant_matrix[i];
265 block += 64;
266 j++;
267 }
268 }
269 }
270
271 return 0;
272 }
273
274 static int decode_intra_block(AGMContext *s, GetBitContext *gb,
275 const int *quant_matrix, int *skip, int *dc_level)
276 {
277 const uint8_t *scantable = s->scantable.permutated;
278 const int offset = s->plus ? 0 : 1024;
279 int16_t *block = s->block;
280 int level, ret, map = 0;
281
282 memset(block, 0, sizeof(s->block));
283
284 if (*skip > 0) {
285 (*skip)--;
286 } else {
287 ret = read_code(gb, skip, &level, &map, s->flags & 1);
288 if (ret < 0)
289 return ret;
290 *dc_level += level;
291 }
292 block[scantable[0]] = offset + *dc_level * quant_matrix[0];
293
294 for (int i = 1; i < 64;) {
295 if (*skip > 0) {
296 int rskip;
297
298 rskip = FFMIN(*skip, 64 - i);
299 i += rskip;
300 *skip -= rskip;
301 } else {
302 ret = read_code(gb, skip, &level, &map, s->flags & 1);
303 if (ret < 0)
304 return ret;
305
306 block[scantable[i]] = level * quant_matrix[i];
307 i++;
308 }
309 }
310
311 return 0;
312 }
313
314 static int decode_intra_plane(AGMContext *s, GetBitContext *gb, int size,
315 const int *quant_matrix, AVFrame *frame,
316 int plane)
317 {
318 int ret, skip = 0, dc_level = 0;
319 const int offset = s->plus ? 0 : 1024;
320
321 if ((ret = init_get_bits8(gb, s->gbyte.buffer, size)) < 0)
322 return ret;
323
324 if (s->flags & 1) {
325 av_fast_padded_malloc(&s->wblocks, &s->wblocks_size,
326 64 * s->blocks_w * sizeof(*s->wblocks));
327 if (!s->wblocks)
328 return AVERROR(ENOMEM);
329
330 for (int y = 0; y < s->blocks_h; y++) {
331 ret = decode_intra_blocks(s, gb, quant_matrix, &skip, &dc_level);
332 if (ret < 0)
333 return ret;
334
335 for (int x = 0; x < s->blocks_w; x++) {
336 s->wblocks[64 * x] += offset;
337 s->idsp.idct_put(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
338 frame->linesize[plane], s->wblocks + 64 * x);
339 }
340 }
341 } else {
342 for (int y = 0; y < s->blocks_h; y++) {
343 for (int x = 0; x < s->blocks_w; x++) {
344 ret = decode_intra_block(s, gb, quant_matrix, &skip, &dc_level);
345 if (ret < 0)
346 return ret;
347
348 s->idsp.idct_put(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
349 frame->linesize[plane], s->block);
350 }
351 }
352 }
353
354 align_get_bits(gb);
355 if (get_bits_left(gb) < 0)
356 av_log(s->avctx, AV_LOG_WARNING, "overread\n");
357 if (get_bits_left(gb) > 0)
358 av_log(s->avctx, AV_LOG_WARNING, "underread: %d\n", get_bits_left(gb));
359
360 return 0;
361 }
362
363 static int decode_inter_block(AGMContext *s, GetBitContext *gb,
364 const int *quant_matrix, int *skip,
365 int *map)
366 {
367 const uint8_t *scantable = s->scantable.permutated;
368 int16_t *block = s->block;
369 int level, ret;
370
371 memset(block, 0, sizeof(s->block));
372
373 for (int i = 0; i < 64;) {
374 if (*skip > 0) {
375 int rskip;
376
377 rskip = FFMIN(*skip, 64 - i);
378 i += rskip;
379 *skip -= rskip;
380 } else {
381 ret = read_code(gb, skip, &level, map, s->flags & 1);
382 if (ret < 0)
383 return ret;
384
385 block[scantable[i]] = level * quant_matrix[i];
386 i++;
387 }
388 }
389
390 return 0;
391 }
392
393 static int decode_inter_plane(AGMContext *s, GetBitContext *gb, int size,
394 const int *quant_matrix, AVFrame *frame,
395 AVFrame *prev, int plane)
396 {
397 int ret, skip = 0;
398
399 if ((ret = init_get_bits8(gb, s->gbyte.buffer, size)) < 0)
400 return ret;
401
402 if (s->flags == 3) {
403 av_fast_padded_malloc(&s->wblocks, &s->wblocks_size,
404 64 * s->blocks_w * sizeof(*s->wblocks));
405 if (!s->wblocks)
406 return AVERROR(ENOMEM);
407
408 av_fast_padded_malloc(&s->map, &s->map_size,
409 s->blocks_w * sizeof(*s->map));
410 if (!s->map)
411 return AVERROR(ENOMEM);
412
413 for (int y = 0; y < s->blocks_h; y++) {
414 ret = decode_inter_blocks(s, gb, quant_matrix, &skip, s->map);
415 if (ret < 0)
416 return ret;
417
418 for (int x = 0; x < s->blocks_w; x++) {
419 int shift = plane == 0;
420 int mvpos = (y >> shift) * (s->blocks_w >> shift) + (x >> shift);
421 int orig_mv_x = s->mvectors[mvpos].x;
422 int mv_x = s->mvectors[mvpos].x / (1 + !shift);
423 int mv_y = s->mvectors[mvpos].y / (1 + !shift);
424 int h = s->avctx->coded_height >> !shift;
425 int w = s->avctx->coded_width >> !shift;
426 int map = s->map[x];
427
428 if (orig_mv_x >= -32) {
429 if (y * 8 + mv_y < 0 || y * 8 + mv_y + 8 > h ||
430 x * 8 + mv_x < 0 || x * 8 + mv_x + 8 > w)
431 return AVERROR_INVALIDDATA;
432
433 copy_block8(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
434 prev->data[plane] + ((s->blocks_h - 1 - y) * 8 - mv_y) * prev->linesize[plane] + (x * 8 + mv_x),
435 frame->linesize[plane], prev->linesize[plane], 8);
436 if (map) {
437 s->idsp.idct(s->wblocks + x * 64);
438 for (int i = 0; i < 64; i++)
439 s->wblocks[i + x * 64] = (s->wblocks[i + x * 64] + 1) & 0xFFFC;
440 s->idsp.add_pixels_clamped(&s->wblocks[x*64], frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
441 frame->linesize[plane]);
442 }
443 } else if (map) {
444 s->idsp.idct_put(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
445 frame->linesize[plane], s->wblocks + x * 64);
446 }
447 }
448 }
449 } else if (s->flags & 2) {
450 for (int y = 0; y < s->blocks_h; y++) {
451 for (int x = 0; x < s->blocks_w; x++) {
452 int shift = plane == 0;
453 int mvpos = (y >> shift) * (s->blocks_w >> shift) + (x >> shift);
454 int orig_mv_x = s->mvectors[mvpos].x;
455 int mv_x = s->mvectors[mvpos].x / (1 + !shift);
456 int mv_y = s->mvectors[mvpos].y / (1 + !shift);
457 int h = s->avctx->coded_height >> !shift;
458 int w = s->avctx->coded_width >> !shift;
459 int map = 0;
460
461 ret = decode_inter_block(s, gb, quant_matrix, &skip, &map);
462 if (ret < 0)
463 return ret;
464
465 if (orig_mv_x >= -32) {
466 if (y * 8 + mv_y < 0 || y * 8 + mv_y + 8 > h ||
467 x * 8 + mv_x < 0 || x * 8 + mv_x + 8 > w)
468 return AVERROR_INVALIDDATA;
469
470 copy_block8(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
471 prev->data[plane] + ((s->blocks_h - 1 - y) * 8 - mv_y) * prev->linesize[plane] + (x * 8 + mv_x),
472 frame->linesize[plane], prev->linesize[plane], 8);
473 if (map) {
474 s->idsp.idct(s->block);
475 for (int i = 0; i < 64; i++)
476 s->block[i] = (s->block[i] + 1) & 0xFFFC;
477 s->idsp.add_pixels_clamped(s->block, frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
478 frame->linesize[plane]);
479 }
480 } else if (map) {
481 s->idsp.idct_put(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
482 frame->linesize[plane], s->block);
483 }
484 }
485 }
486 } else if (s->flags & 1) {
487 av_fast_padded_malloc(&s->wblocks, &s->wblocks_size,
488 64 * s->blocks_w * sizeof(*s->wblocks));
489 if (!s->wblocks)
490 return AVERROR(ENOMEM);
491
492 av_fast_padded_malloc(&s->map, &s->map_size,
493 s->blocks_w * sizeof(*s->map));
494 if (!s->map)
495 return AVERROR(ENOMEM);
496
497 for (int y = 0; y < s->blocks_h; y++) {
498 ret = decode_inter_blocks(s, gb, quant_matrix, &skip, s->map);
499 if (ret < 0)
500 return ret;
501
502 for (int x = 0; x < s->blocks_w; x++) {
503 if (!s->map[x])
504 continue;
505 s->idsp.idct_add(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
506 frame->linesize[plane], s->wblocks + 64 * x);
507 }
508 }
509 } else {
510 for (int y = 0; y < s->blocks_h; y++) {
511 for (int x = 0; x < s->blocks_w; x++) {
512 int map = 0;
513
514 ret = decode_inter_block(s, gb, quant_matrix, &skip, &map);
515 if (ret < 0)
516 return ret;
517
518 if (!map)
519 continue;
520 s->idsp.idct_add(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
521 frame->linesize[plane], s->block);
522 }
523 }
524 }
525
526 align_get_bits(gb);
527 if (get_bits_left(gb) < 0)
528 av_log(s->avctx, AV_LOG_WARNING, "overread\n");
529 if (get_bits_left(gb) > 0)
530 av_log(s->avctx, AV_LOG_WARNING, "underread: %d\n", get_bits_left(gb));
531
532 return 0;
533 }
534
535 static void compute_quant_matrix(AGMContext *s, double qscale)
536 {
537 int luma[64], chroma[64];
538 double f = 1.0 - fabs(qscale);
539
540 if (!s->key_frame && (s->flags & 2)) {
541 if (qscale >= 0.0) {
542 for (int i = 0; i < 64; i++) {
543 luma[i] = FFMAX(1, 16 * f);
544 chroma[i] = FFMAX(1, 16 * f);
545 }
546 } else {
547 for (int i = 0; i < 64; i++) {
548 luma[i] = FFMAX(1, 16 - qscale * 32);
549 chroma[i] = FFMAX(1, 16 - qscale * 32);
550 }
551 }
552 } else {
553 if (qscale >= 0.0) {
554 for (int i = 0; i < 64; i++) {
555 luma[i] = FFMAX(1, unscaled_luma [(i & 7) * 8 + (i >> 3)] * f);
556 chroma[i] = FFMAX(1, unscaled_chroma[(i & 7) * 8 + (i >> 3)] * f);
557 }
558 } else {
559 for (int i = 0; i < 64; i++) {
560 luma[i] = FFMAX(1, 255.0 - (255 - unscaled_luma [(i & 7) * 8 + (i >> 3)]) * f);
561 chroma[i] = FFMAX(1, 255.0 - (255 - unscaled_chroma[(i & 7) * 8 + (i >> 3)]) * f);
562 }
563 }
564 }
565
566 for (int i = 0; i < 64; i++) {
567 int pos = ff_zigzag_direct[i];
568
569 s->luma_quant_matrix[i] = luma[pos] * ((pos / 8) & 1 ? -1 : 1);
570 s->chroma_quant_matrix[i] = chroma[pos] * ((pos / 8) & 1 ? -1 : 1);
571 }
572 }
573
574 static int decode_raw_intra_rgb(AVCodecContext *avctx, GetByteContext *gbyte, AVFrame *frame)
575 {
576 uint8_t *dst = frame->data[0] + (avctx->height - 1) * frame->linesize[0];
577 uint8_t r = 0, g = 0, b = 0;
578
579 if (bytestream2_get_bytes_left(gbyte) < 3 * avctx->width * avctx->height)
580 return AVERROR_INVALIDDATA;
581
582 for (int y = 0; y < avctx->height; y++) {
583 for (int x = 0; x < avctx->width; x++) {
584 dst[x*3+0] = bytestream2_get_byteu(gbyte) + r;
585 r = dst[x*3+0];
586 dst[x*3+1] = bytestream2_get_byteu(gbyte) + g;
587 g = dst[x*3+1];
588 dst[x*3+2] = bytestream2_get_byteu(gbyte) + b;
589 b = dst[x*3+2];
590 }
591 dst -= frame->linesize[0];
592 }
593
594 return 0;
595 }
596
597 av_always_inline static int fill_pixels(uint8_t **y0, uint8_t **y1,
598 uint8_t **u, uint8_t **v,
599 int ylinesize, int ulinesize, int vlinesize,
600 uint8_t *fill,
601 int *nx, int *ny, int *np, int w, int h)
602 {
603 uint8_t *y0dst = *y0;
604 uint8_t *y1dst = *y1;
605 uint8_t *udst = *u;
606 uint8_t *vdst = *v;
607 int x = *nx, y = *ny, pos = *np;
608
609 if (pos == 0) {
610 y0dst[2*x+0] += fill[0];
611 y0dst[2*x+1] += fill[1];
612 y1dst[2*x+0] += fill[2];
613 y1dst[2*x+1] += fill[3];
614 pos++;
615 } else if (pos == 1) {
616 udst[x] += fill[0];
617 vdst[x] += fill[1];
618 x++;
619 if (x >= w) {
620 x = 0;
621 y++;
622 if (y >= h)
623 return 1;
624 y0dst -= 2*ylinesize;
625 y1dst -= 2*ylinesize;
626 udst -= ulinesize;
627 vdst -= vlinesize;
628 }
629 y0dst[2*x+0] += fill[2];
630 y0dst[2*x+1] += fill[3];
631 pos++;
632 } else if (pos == 2) {
633 y1dst[2*x+0] += fill[0];
634 y1dst[2*x+1] += fill[1];
635 udst[x] += fill[2];
636 vdst[x] += fill[3];
637 x++;
638 if (x >= w) {
639 x = 0;
640 y++;
641 if (y >= h)
642 return 1;
643 y0dst -= 2*ylinesize;
644 y1dst -= 2*ylinesize;
645 udst -= ulinesize;
646 vdst -= vlinesize;
647 }
648 pos = 0;
649 }
650
651 *y0 = y0dst;
652 *y1 = y1dst;
653 *u = udst;
654 *v = vdst;
655 *np = pos;
656 *nx = x;
657 *ny = y;
658
659 return 0;
660 }
661
662 static int decode_runlen_rgb(AVCodecContext *avctx, GetByteContext *gbyte, AVFrame *frame)
663 {
664 uint8_t *dst = frame->data[0] + (avctx->height - 1) * frame->linesize[0];
665 int runlen, y = 0, x = 0;
666 uint8_t fill[4];
667 unsigned code;
668
669 while (bytestream2_get_bytes_left(gbyte) > 0) {
670 code = bytestream2_peek_le32(gbyte);
671 runlen = code & 0xFFFFFF;
672
673 if (code >> 24 == 0x77) {
674 bytestream2_skip(gbyte, 4);
675
676 for (int i = 0; i < 4; i++)
677 fill[i] = bytestream2_get_byte(gbyte);
678
679 while (runlen > 0) {
680 runlen--;
681
682 for (int i = 0; i < 4; i++) {
683 dst[x] += fill[i];
684 x++;
685 if (x >= frame->width * 3) {
686 x = 0;
687 y++;
688 dst -= frame->linesize[0];
689 if (y >= frame->height)
690 return 0;
691 }
692 }
693 }
694 } else {
695 for (int i = 0; i < 4; i++)
696 fill[i] = bytestream2_get_byte(gbyte);
697
698 for (int i = 0; i < 4; i++) {
699 dst[x] += fill[i];
700 x++;
701 if (x >= frame->width * 3) {
702 x = 0;
703 y++;
704 dst -= frame->linesize[0];
705 if (y >= frame->height)
706 return 0;
707 }
708 }
709 }
710 }
711
712 return 0;
713 }
714
715 static int decode_runlen(AVCodecContext *avctx, GetByteContext *gbyte, AVFrame *frame)
716 {
717 uint8_t *y0dst = frame->data[0] + (avctx->height - 1) * frame->linesize[0];
718 uint8_t *y1dst = y0dst - frame->linesize[0];
719 uint8_t *udst = frame->data[1] + ((avctx->height >> 1) - 1) * frame->linesize[1];
720 uint8_t *vdst = frame->data[2] + ((avctx->height >> 1) - 1) * frame->linesize[2];
721 int runlen, y = 0, x = 0, pos = 0;
722 uint8_t fill[4];
723 unsigned code;
724
725 while (bytestream2_get_bytes_left(gbyte) > 0) {
726 code = bytestream2_peek_le32(gbyte);
727 runlen = code & 0xFFFFFF;
728
729 if (code >> 24 == 0x77) {
730 bytestream2_skip(gbyte, 4);
731
732 for (int i = 0; i < 4; i++)
733 fill[i] = bytestream2_get_byte(gbyte);
734
735 while (runlen > 0) {
736 runlen--;
737
738 if (fill_pixels(&y0dst, &y1dst, &udst, &vdst,
739 frame->linesize[0],
740 frame->linesize[1],
741 frame->linesize[2],
742 fill, &x, &y, &pos,
743 avctx->width / 2,
744 avctx->height / 2))
745 return 0;
746 }
747 } else {
748 for (int i = 0; i < 4; i++)
749 fill[i] = bytestream2_get_byte(gbyte);
750
751 if (fill_pixels(&y0dst, &y1dst, &udst, &vdst,
752 frame->linesize[0],
753 frame->linesize[1],
754 frame->linesize[2],
755 fill, &x, &y, &pos,
756 avctx->width / 2,
757 avctx->height / 2))
758 return 0;
759 }
760 }
761
762 return 0;
763 }
764
765 static int decode_raw_intra(AVCodecContext *avctx, GetByteContext *gbyte, AVFrame *frame)
766 {
767 uint8_t *y0dst = frame->data[0] + (avctx->height - 1) * frame->linesize[0];
768 uint8_t *y1dst = y0dst - frame->linesize[0];
769 uint8_t *udst = frame->data[1] + ((avctx->height >> 1) - 1) * frame->linesize[1];
770 uint8_t *vdst = frame->data[2] + ((avctx->height >> 1) - 1) * frame->linesize[2];
771 uint8_t ly0 = 0, ly1 = 0, ly2 = 0, ly3 = 0, lu = 0, lv = 0;
772
773 for (int y = 0; y < avctx->height / 2; y++) {
774 for (int x = 0; x < avctx->width / 2; x++) {
775 y0dst[x*2+0] = bytestream2_get_byte(gbyte) + ly0;
776 ly0 = y0dst[x*2+0];
777 y0dst[x*2+1] = bytestream2_get_byte(gbyte) + ly1;
778 ly1 = y0dst[x*2+1];
779 y1dst[x*2+0] = bytestream2_get_byte(gbyte) + ly2;
780 ly2 = y1dst[x*2+0];
781 y1dst[x*2+1] = bytestream2_get_byte(gbyte) + ly3;
782 ly3 = y1dst[x*2+1];
783 udst[x] = bytestream2_get_byte(gbyte) + lu;
784 lu = udst[x];
785 vdst[x] = bytestream2_get_byte(gbyte) + lv;
786 lv = vdst[x];
787 }
788
789 y0dst -= 2*frame->linesize[0];
790 y1dst -= 2*frame->linesize[0];
791 udst -= frame->linesize[1];
792 vdst -= frame->linesize[2];
793 }
794
795 return 0;
796 }
797
798 static int decode_intra(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame)
799 {
800 AGMContext *s = avctx->priv_data;
801 int ret;
802
803 compute_quant_matrix(s, (2 * s->compression - 100) / 100.0);
804
805 s->blocks_w = avctx->coded_width >> 3;
806 s->blocks_h = avctx->coded_height >> 3;
807
808 ret = decode_intra_plane(s, gb, s->size[0], s->luma_quant_matrix, frame, 0);
809 if (ret < 0)
810 return ret;
811
812 bytestream2_skip(&s->gbyte, s->size[0]);
813
814 s->blocks_w = avctx->coded_width >> 4;
815 s->blocks_h = avctx->coded_height >> 4;
816
817 ret = decode_intra_plane(s, gb, s->size[1], s->chroma_quant_matrix, frame, 2);
818 if (ret < 0)
819 return ret;
820
821 bytestream2_skip(&s->gbyte, s->size[1]);
822
823 s->blocks_w = avctx->coded_width >> 4;
824 s->blocks_h = avctx->coded_height >> 4;
825
826 ret = decode_intra_plane(s, gb, s->size[2], s->chroma_quant_matrix, frame, 1);
827 if (ret < 0)
828 return ret;
829
830 return 0;
831 }
832
833 static int decode_motion_vectors(AVCodecContext *avctx, GetBitContext *gb)
834 {
835 AGMContext *s = avctx->priv_data;
836 int nb_mvs = ((avctx->coded_height + 15) >> 4) * ((avctx->coded_width + 15) >> 4);
837 int ret, skip = 0, value, map;
838
839 av_fast_padded_malloc(&s->mvectors, &s->mvectors_size,
840 nb_mvs * sizeof(*s->mvectors));
841 if (!s->mvectors)
842 return AVERROR(ENOMEM);
843
844 if ((ret = init_get_bits8(gb, s->gbyte.buffer, bytestream2_get_bytes_left(&s->gbyte) -
845 (s->size[0] + s->size[1] + s->size[2]))) < 0)
846 return ret;
847
848 memset(s->mvectors, 0, sizeof(*s->mvectors) * nb_mvs);
849
850 for (int i = 0; i < nb_mvs; i++) {
851 ret = read_code(gb, &skip, &value, &map, 1);
852 if (ret < 0)
853 return ret;
854 s->mvectors[i].x = value;
855 i += skip;
856 }
857
858 for (int i = 0; i < nb_mvs; i++) {
859 ret = read_code(gb, &skip, &value, &map, 1);
860 if (ret < 0)
861 return ret;
862 s->mvectors[i].y = value;
863 i += skip;
864 }
865
866 if (get_bits_left(gb) <= 0)
867 return AVERROR_INVALIDDATA;
868 skip = (get_bits_count(gb) >> 3) + 1;
869 bytestream2_skip(&s->gbyte, skip);
870
871 return 0;
872 }
873
874 static int decode_inter(AVCodecContext *avctx, GetBitContext *gb,
875 AVFrame *frame, AVFrame *prev)
876 {
877 AGMContext *s = avctx->priv_data;
878 int ret;
879
880 compute_quant_matrix(s, (2 * s->compression - 100) / 100.0);
881
882 if (s->flags & 2) {
883 ret = decode_motion_vectors(avctx, gb);
884 if (ret < 0)
885 return ret;
886 }
887
888 s->blocks_w = avctx->coded_width >> 3;
889 s->blocks_h = avctx->coded_height >> 3;
890
891 ret = decode_inter_plane(s, gb, s->size[0], s->luma_quant_matrix, frame, prev, 0);
892 if (ret < 0)
893 return ret;
894
895 bytestream2_skip(&s->gbyte, s->size[0]);
896
897 s->blocks_w = avctx->coded_width >> 4;
898 s->blocks_h = avctx->coded_height >> 4;
899
900 ret = decode_inter_plane(s, gb, s->size[1], s->chroma_quant_matrix, frame, prev, 2);
901 if (ret < 0)
902 return ret;
903
904 bytestream2_skip(&s->gbyte, s->size[1]);
905
906 s->blocks_w = avctx->coded_width >> 4;
907 s->blocks_h = avctx->coded_height >> 4;
908
909 ret = decode_inter_plane(s, gb, s->size[2], s->chroma_quant_matrix, frame, prev, 1);
910 if (ret < 0)
911 return ret;
912
913 return 0;
914 }
915
916 typedef struct Node {
917 int parent;
918 int child[2];
919 } Node;
920
921 static void get_tree_codes(uint32_t *codes, Node *nodes, int idx, uint32_t pfx, int bitpos)
922 {
923 if (idx < 256 && idx >= 0) {
924 codes[idx] = pfx;
925 } else if (idx >= 0) {
926 get_tree_codes(codes, nodes, nodes[idx].child[0], pfx + (0 << bitpos), bitpos + 1);
927 get_tree_codes(codes, nodes, nodes[idx].child[1], pfx + (1U << bitpos), bitpos + 1);
928 }
929 }
930
931 static int make_new_tree(const uint8_t *bitlens, uint32_t *codes)
932 {
933 int zlcount = 0, curlen, idx, nindex, last, llast;
934 int blcounts[32] = { 0 };
935 int syms[8192];
936 Node nodes[512];
937 int node_idx[1024];
938 int old_idx[512];
939
940 for (int i = 0; i < 256; i++) {
941 int bitlen = bitlens[i];
942 int blcount = blcounts[bitlen];
943
944 zlcount += bitlen < 1;
945 syms[(bitlen << 8) + blcount] = i;
946 blcounts[bitlen]++;
947 }
948
949 for (int i = 0; i < 512; i++) {
950 nodes[i].child[0] = -1;
951 nodes[i].child[1] = -1;
952 }
953
954 for (int i = 0; i < 256; i++) {
955 node_idx[i] = 257 + i;
956 }
957
958 curlen = 1;
959 node_idx[512] = 256;
960 last = 255;
961 nindex = 1;
962
963 for (curlen = 1; curlen < 32; curlen++) {
964 if (blcounts[curlen] > 0) {
965 int max_zlcount = zlcount + blcounts[curlen];
966
967 for (int i = 0; zlcount < 256 && zlcount < max_zlcount; zlcount++, i++) {
968 int p = node_idx[nindex - 1 + 512];
969 int ch = syms[256 * curlen + i];
970
971 if (nindex <= 0)
972 return AVERROR_INVALIDDATA;
973
974 if (nodes[p].child[0] == -1) {
975 nodes[p].child[0] = ch;
976 } else {
977 nodes[p].child[1] = ch;
978 nindex--;
979 }
980 nodes[ch].parent = p;
981 }
982 }
983 llast = last - 1;
984 idx = 0;
985 while (nindex > 0) {
986 int p, ch;
987
988 last = llast - idx;
989 p = node_idx[nindex - 1 + 512];
990 ch = node_idx[last];
991 if (nodes[p].child[0] == -1) {
992 nodes[p].child[0] = ch;
993 } else {
994 nodes[p].child[1] = ch;
995 nindex--;
996 }
997 old_idx[idx] = ch;
998 nodes[ch].parent = p;
999 if (idx == llast)
1000 goto next;
1001 idx++;
1002 if (nindex <= 0) {
1003 for (int i = 0; i < idx; i++)
1004 node_idx[512 + i] = old_idx[i];
1005 }
1006 }
1007 nindex = idx;
1008 }
1009
1010 next:
1011
1012 get_tree_codes(codes, nodes, 256, 0, 0);
1013 return 0;
1014 }
1015
1016 static int build_huff(const uint8_t *bitlen, VLC *vlc)
1017 {
1018 uint32_t new_codes[256];
1019 uint8_t bits[256];
1020 uint8_t symbols[256];
1021 uint32_t codes[256];
1022 int nb_codes = 0;
1023
1024 int ret = make_new_tree(bitlen, new_codes);
1025 if (ret < 0)
1026 return ret;
1027
1028 for (int i = 0; i < 256; i++) {
1029 if (bitlen[i]) {
1030 bits[nb_codes] = bitlen[i];
1031 codes[nb_codes] = new_codes[i];
1032 symbols[nb_codes] = i;
1033 nb_codes++;
1034 }
1035 }
1036
1037 ff_free_vlc(vlc);
1038 return ff_init_vlc_sparse(vlc, 13, nb_codes,
1039 bits, 1, 1,
1040 codes, 4, 4,
1041 symbols, 1, 1,
1042 INIT_VLC_LE);
1043 }
1044
1045 static int decode_huffman2(AVCodecContext *avctx, int header, int size)
1046 {
1047 AGMContext *s = avctx->priv_data;
1048 GetBitContext *gb = &s->gb;
1049 uint8_t lens[256];
1050 int ret, x, len;
1051
1052 if ((ret = init_get_bits8(gb, s->gbyte.buffer,
1053 bytestream2_get_bytes_left(&s->gbyte))) < 0)
1054 return ret;
1055
1056 s->output_size = get_bits_long(gb, 32);
1057
1058 if (s->output_size > avctx->width * avctx->height * 9LL + 10000)
1059 return AVERROR_INVALIDDATA;
1060
1061 av_fast_padded_malloc(&s->output, &s->padded_output_size, s->output_size);
1062 if (!s->output)
1063 return AVERROR(ENOMEM);
1064
1065 x = get_bits(gb, 1);
1066 len = 4 + get_bits(gb, 1);
1067 if (x) {
1068 int cb[8] = { 0 };
1069 int count = get_bits(gb, 3) + 1;
1070
1071 for (int i = 0; i < count; i++)
1072 cb[i] = get_bits(gb, len);
1073
1074 for (int i = 0; i < 256; i++) {
1075 int idx = get_bits(gb, 3);
1076 lens[i] = cb[idx];
1077 }
1078 } else {
1079 for (int i = 0; i < 256; i++)
1080 lens[i] = get_bits(gb, len);
1081 }
1082
1083 if ((ret = build_huff(lens, &s->vlc)) < 0)
1084 return ret;
1085
1086 x = 0;
1087 while (get_bits_left(gb) > 0 && x < s->output_size) {
1088 int val = get_vlc2(gb, s->vlc.table, s->vlc.bits, 3);
1089 if (val < 0)
1090 return AVERROR_INVALIDDATA;
1091 s->output[x++] = val;
1092 }
1093
1094 return 0;
1095 }
1096
1097 static int decode_frame(AVCodecContext *avctx, AVFrame *frame,
1098 int *got_frame, AVPacket *avpkt)
1099 {
1100 AGMContext *s = avctx->priv_data;
1101 GetBitContext *gb = &s->gb;
1102 GetByteContext *gbyte = &s->gbyte;
1103 int w, h, width, height, header;
1104 unsigned compressed_size;
1105 long skip;
1106 int ret;
1107
1108 if (!avpkt->size)
1109 return 0;
1110
1111 bytestream2_init(gbyte, avpkt->data, avpkt->size);
1112
1113 header = bytestream2_get_le32(gbyte);
1114 s->fflags = bytestream2_get_le32(gbyte);
1115 s->bitstream_size = s->fflags & 0x1FFFFFFF;
1116 s->fflags >>= 29;
1117 av_log(avctx, AV_LOG_DEBUG, "fflags: %X\n", s->fflags);
1118 if (avpkt->size < s->bitstream_size + 8)
1119 return AVERROR_INVALIDDATA;
1120
1121 s->key_frame = (avpkt->flags & AV_PKT_FLAG_KEY);
1122 frame->key_frame = s->key_frame;
1123 frame->pict_type = s->key_frame ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
1124
1125 if (!s->key_frame) {
1126 if (!s->prev_frame->data[0]) {
1127 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1128 return AVERROR_INVALIDDATA;
1129 }
1130 }
1131
1132 if (header) {
1133 if (avctx->codec_tag == MKTAG('A', 'G', 'M', '0') ||
1134 avctx->codec_tag == MKTAG('A', 'G', 'M', '1'))
1135 return AVERROR_PATCHWELCOME;
1136 else
1137 ret = decode_huffman2(avctx, header, (avpkt->size - s->bitstream_size) - 8);
1138 if (ret < 0)
1139 return ret;
1140 bytestream2_init(gbyte, s->output, s->output_size);
1141 } else if (!s->dct) {
1142 bytestream2_skip(gbyte, 4);
1143 }
1144
1145 if (s->dct) {
1146 s->flags = 0;
1147 w = bytestream2_get_le32(gbyte);
1148 h = bytestream2_get_le32(gbyte);
1149 if (w == INT32_MIN || h == INT32_MIN)
1150 return AVERROR_INVALIDDATA;
1151 if (w < 0) {
1152 w = -w;
1153 s->flags |= 2;
1154 }
1155 if (h < 0) {
1156 h = -h;
1157 s->flags |= 1;
1158 }
1159
1160 width = avctx->width;
1161 height = avctx->height;
1162 if (w < width || h < height || w & 7 || h & 7)
1163 return AVERROR_INVALIDDATA;
1164
1165 ret = ff_set_dimensions(avctx, w, h);
1166 if (ret < 0)
1167 return ret;
1168 avctx->width = width;
1169 avctx->height = height;
1170
1171 s->compression = bytestream2_get_le32(gbyte);
1172 if (s->compression < 0 || s->compression > 100)
1173 return AVERROR_INVALIDDATA;
1174
1175 for (int i = 0; i < 3; i++)
1176 s->size[i] = bytestream2_get_le32(gbyte);
1177 if (header) {
1178 compressed_size = s->output_size;
1179 skip = 8LL;
1180 } else {
1181 compressed_size = avpkt->size;
1182 skip = 32LL;
1183 }
1184 if (s->size[0] < 0 || s->size[1] < 0 || s->size[2] < 0 ||
1185 skip + s->size[0] + s->size[1] + s->size[2] > compressed_size) {
1186 return AVERROR_INVALIDDATA;
1187 }
1188 }
1189
1190 if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
1191 return ret;
1192
1193 if (frame->key_frame) {
1194 if (!s->dct && !s->rgb)
1195 ret = decode_raw_intra(avctx, gbyte, frame);
1196 else if (!s->dct && s->rgb)
1197 ret = decode_raw_intra_rgb(avctx, gbyte, frame);
1198 else
1199 ret = decode_intra(avctx, gb, frame);
1200 } else {
1201 if (s->prev_frame-> width != frame->width ||
1202 s->prev_frame->height != frame->height)
1203 return AVERROR_INVALIDDATA;
1204
1205 if (!(s->flags & 2)) {
1206 ret = av_frame_copy(frame, s->prev_frame);
1207 if (ret < 0)
1208 return ret;
1209 }
1210
1211 if (s->dct) {
1212 ret = decode_inter(avctx, gb, frame, s->prev_frame);
1213 } else if (!s->dct && !s->rgb) {
1214 ret = decode_runlen(avctx, gbyte, frame);
1215 } else {
1216 ret = decode_runlen_rgb(avctx, gbyte, frame);
1217 }
1218 }
1219 if (ret < 0)
1220 return ret;
1221
1222 av_frame_unref(s->prev_frame);
1223 if ((ret = av_frame_ref(s->prev_frame, frame)) < 0)
1224 return ret;
1225
1226 frame->crop_top = avctx->coded_height - avctx->height;
1227 frame->crop_left = avctx->coded_width - avctx->width;
1228
1229 *got_frame = 1;
1230
1231 return avpkt->size;
1232 }
1233
1234 static av_cold int decode_init(AVCodecContext *avctx)
1235 {
1236 AGMContext *s = avctx->priv_data;
1237
1238 s->rgb = avctx->codec_tag == MKTAG('A', 'G', 'M', '4');
1239 avctx->pix_fmt = s->rgb ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_YUV420P;
1240 s->avctx = avctx;
1241 s->plus = avctx->codec_tag == MKTAG('A', 'G', 'M', '3') ||
1242 avctx->codec_tag == MKTAG('A', 'G', 'M', '7');
1243
1244 s->dct = avctx->codec_tag != MKTAG('A', 'G', 'M', '4') &&
1245 avctx->codec_tag != MKTAG('A', 'G', 'M', '5');
1246
1247 if (!s->rgb && !s->dct) {
1248 if ((avctx->width & 1) || (avctx->height & 1))
1249 return AVERROR_INVALIDDATA;
1250 }
1251
1252 avctx->idct_algo = FF_IDCT_SIMPLE;
1253 ff_idctdsp_init(&s->idsp, avctx);
1254 ff_init_scantable(s->idsp.idct_permutation, &s->scantable, ff_zigzag_direct);
1255
1256 s->prev_frame = av_frame_alloc();
1257 if (!s->prev_frame)
1258 return AVERROR(ENOMEM);
1259
1260 return 0;
1261 }
1262
1263 static void decode_flush(AVCodecContext *avctx)
1264 {
1265 AGMContext *s = avctx->priv_data;
1266
1267 av_frame_unref(s->prev_frame);
1268 }
1269
1270 static av_cold int decode_close(AVCodecContext *avctx)
1271 {
1272 AGMContext *s = avctx->priv_data;
1273
1274 ff_free_vlc(&s->vlc);
1275 av_frame_free(&s->prev_frame);
1276 av_freep(&s->mvectors);
1277 s->mvectors_size = 0;
1278 av_freep(&s->wblocks);
1279 s->wblocks_size = 0;
1280 av_freep(&s->output);
1281 s->padded_output_size = 0;
1282 av_freep(&s->map);
1283 s->map_size = 0;
1284
1285 return 0;
1286 }
1287
1288 const FFCodec ff_agm_decoder = {
1289 .p.name = "agm",
1290 .p.long_name = NULL_IF_CONFIG_SMALL("Amuse Graphics Movie"),
1291 .p.type = AVMEDIA_TYPE_VIDEO,
1292 .p.id = AV_CODEC_ID_AGM,
1293 .p.capabilities = AV_CODEC_CAP_DR1,
1294 .priv_data_size = sizeof(AGMContext),
1295 .init = decode_init,
1296 .close = decode_close,
1297 FF_CODEC_DECODE_CB(decode_frame),
1298 .flush = decode_flush,
1299 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
1300 FF_CODEC_CAP_INIT_CLEANUP |
1301 FF_CODEC_CAP_EXPORTS_CROPPING,
1302 };
1303