FFmpeg coverage


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