2 * Amuse Graphics Movie decoder
4 * Copyright (c) 2018 Paul B Mahol
6 * This file is part of FFmpeg.
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.
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.
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
27 #define BITSTREAM_READER_LE
30 #include "bytestream.h"
31 #include "copy_block.h"
36 static const uint8_t unscaled_luma[64] = {
37 16, 11, 10, 16, 24, 40, 51, 61, 12, 12, 14, 19,
38 26, 58, 60, 55, 14, 13, 16, 24, 40, 57, 69, 56,
39 14, 17, 22, 29, 51, 87, 80, 62, 18, 22, 37, 56,
40 68,109,103, 77, 24, 35, 55, 64, 81,104,113, 92,
41 49, 64, 78, 87,103,121,120,101, 72, 92, 95, 98,
45 static const uint8_t unscaled_chroma[64] = {
46 17, 18, 24, 47, 99, 99, 99, 99, 18, 21, 26, 66,
47 99, 99, 99, 99, 24, 26, 56, 99, 99, 99, 99, 99,
48 47, 66, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
49 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
50 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
54 typedef struct MotionVector {
58 typedef struct AGMContext {
60 AVCodecContext *avctx;
77 unsigned padded_output_size;
80 MotionVector *mvectors;
81 unsigned mvectors_size;
87 int luma_quant_matrix[64];
88 int chroma_quant_matrix[64];
91 DECLARE_ALIGNED(32, int16_t, block)[64];
94 unsigned wblocks_size;
102 static int read_code(GetBitContext *gb, int *oskip, int *level, int *map, int mode)
104 int len = 0, skip = 0, max;
106 if (get_bits_left(gb) < 2)
107 return AVERROR_INVALIDDATA;
109 if (show_bits(gb, 2)) {
110 switch (show_bits(gb, 4)) {
150 len = ((show_bits(gb, 5) & 0x10) | 0xA0) >> 4;
154 return AVERROR_INVALIDDATA;
158 *level = get_bits(gb, len);
161 max = 1 << (len - 1);
163 *level = -(max + *level);
164 } else if (show_bits(gb, 3) & 4) {
167 if (show_bits(gb, 4)) {
168 if (show_bits(gb, 4) == 1) {
170 *oskip = get_bits(gb, 16);
172 *oskip = get_bits(gb, 4);
176 *oskip = get_bits(gb, 10);
178 } else if (mode == 0) {
179 *oskip = get_bits(gb, 10);
185 *oskip = get_bits(gb, 4);
194 static int decode_intra_blocks(AGMContext *s, GetBitContext *gb,
195 const int *quant_matrix, int *skip, int *dc_level)
197 const uint8_t *scantable = s->scantable.permutated;
198 int level, ret, map = 0;
200 memset(s->wblocks, 0, s->wblocks_size);
202 for (int i = 0; i < 64; i++) {
203 int16_t *block = s->wblocks + scantable[i];
205 for (int j = 0; j < s->blocks_w;) {
209 rskip = FFMIN(*skip, s->blocks_w - j);
212 for (int k = 0; k < rskip; k++)
213 block[64 * k] = *dc_level * quant_matrix[0];
218 ret = read_code(gb, skip, &level, &map, s->flags & 1);
225 block[0] = (i == 0 ? *dc_level : level) * quant_matrix[i];
235 static int decode_inter_blocks(AGMContext *s, GetBitContext *gb,
236 const int *quant_matrix, int *skip,
239 const uint8_t *scantable = s->scantable.permutated;
242 memset(s->wblocks, 0, s->wblocks_size);
243 memset(s->map, 0, s->map_size);
245 for (int i = 0; i < 64; i++) {
246 int16_t *block = s->wblocks + scantable[i];
248 for (int j = 0; j < s->blocks_w;) {
252 rskip = FFMIN(*skip, s->blocks_w - j);
257 ret = read_code(gb, skip, &level, &map[j], s->flags & 1);
261 block[0] = level * quant_matrix[i];
271 static int decode_intra_block(AGMContext *s, GetBitContext *gb,
272 const int *quant_matrix, int *skip, int *dc_level)
274 const uint8_t *scantable = s->scantable.permutated;
275 const int offset = s->plus ? 0 : 1024;
276 int16_t *block = s->block;
277 int level, ret, map = 0;
279 memset(block, 0, sizeof(s->block));
284 ret = read_code(gb, skip, &level, &map, s->flags & 1);
289 block[scantable[0]] = offset + *dc_level * quant_matrix[0];
291 for (int i = 1; i < 64;) {
295 rskip = FFMIN(*skip, 64 - i);
299 ret = read_code(gb, skip, &level, &map, s->flags & 1);
303 block[scantable[i]] = level * quant_matrix[i];
311 static int decode_intra_plane(AGMContext *s, GetBitContext *gb, int size,
312 const int *quant_matrix, AVFrame *frame,
315 int ret, skip = 0, dc_level = 0;
316 const int offset = s->plus ? 0 : 1024;
318 if ((ret = init_get_bits8(gb, s->gbyte.buffer, size)) < 0)
322 av_fast_padded_malloc(&s->wblocks, &s->wblocks_size,
323 64 * s->blocks_w * sizeof(*s->wblocks));
325 return AVERROR(ENOMEM);
327 for (int y = 0; y < s->blocks_h; y++) {
328 ret = decode_intra_blocks(s, gb, quant_matrix, &skip, &dc_level);
332 for (int x = 0; x < s->blocks_w; x++) {
333 s->wblocks[64 * x] += offset;
334 s->idsp.idct_put(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
335 frame->linesize[plane], s->wblocks + 64 * x);
339 for (int y = 0; y < s->blocks_h; y++) {
340 for (int x = 0; x < s->blocks_w; x++) {
341 ret = decode_intra_block(s, gb, quant_matrix, &skip, &dc_level);
345 s->idsp.idct_put(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
346 frame->linesize[plane], s->block);
352 if (get_bits_left(gb) < 0)
353 av_log(s->avctx, AV_LOG_WARNING, "overread\n");
354 if (get_bits_left(gb) > 0)
355 av_log(s->avctx, AV_LOG_WARNING, "underread: %d\n", get_bits_left(gb));
360 static int decode_inter_block(AGMContext *s, GetBitContext *gb,
361 const int *quant_matrix, int *skip,
364 const uint8_t *scantable = s->scantable.permutated;
365 int16_t *block = s->block;
368 memset(block, 0, sizeof(s->block));
370 for (int i = 0; i < 64;) {
374 rskip = FFMIN(*skip, 64 - i);
378 ret = read_code(gb, skip, &level, map, s->flags & 1);
382 block[scantable[i]] = level * quant_matrix[i];
390 static int decode_inter_plane(AGMContext *s, GetBitContext *gb, int size,
391 const int *quant_matrix, AVFrame *frame,
392 AVFrame *prev, int plane)
396 if ((ret = init_get_bits8(gb, s->gbyte.buffer, size)) < 0)
400 av_fast_padded_malloc(&s->wblocks, &s->wblocks_size,
401 64 * s->blocks_w * sizeof(*s->wblocks));
403 return AVERROR(ENOMEM);
405 av_fast_padded_malloc(&s->map, &s->map_size,
406 s->blocks_w * sizeof(*s->map));
408 return AVERROR(ENOMEM);
410 for (int y = 0; y < s->blocks_h; y++) {
411 ret = decode_inter_blocks(s, gb, quant_matrix, &skip, s->map);
415 for (int x = 0; x < s->blocks_w; x++) {
416 int shift = plane == 0;
417 int mvpos = (y >> shift) * (s->blocks_w >> shift) + (x >> shift);
418 int orig_mv_x = s->mvectors[mvpos].x;
419 int mv_x = s->mvectors[mvpos].x / (1 + !shift);
420 int mv_y = s->mvectors[mvpos].y / (1 + !shift);
421 int h = s->avctx->coded_height >> !shift;
422 int w = s->avctx->coded_width >> !shift;
425 if (orig_mv_x >= -32) {
426 if (y * 8 + mv_y < 0 || y * 8 + mv_y >= h ||
427 x * 8 + mv_x < 0 || x * 8 + mv_x >= w)
428 return AVERROR_INVALIDDATA;
430 copy_block8(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
431 prev->data[plane] + ((s->blocks_h - 1 - y) * 8 - mv_y) * prev->linesize[plane] + (x * 8 + mv_x),
432 frame->linesize[plane], prev->linesize[plane], 8);
434 s->idsp.idct(s->wblocks + x * 64);
435 for (int i = 0; i < 64; i++)
436 s->wblocks[i + x * 64] = (s->wblocks[i + x * 64] + 1) & 0xFFFC;
437 s->idsp.add_pixels_clamped(&s->wblocks[x*64], frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
438 frame->linesize[plane]);
441 s->idsp.idct_put(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
442 frame->linesize[plane], s->wblocks + x * 64);
446 } else if (s->flags & 2) {
447 for (int y = 0; y < s->blocks_h; y++) {
448 for (int x = 0; x < s->blocks_w; x++) {
449 int shift = plane == 0;
450 int mvpos = (y >> shift) * (s->blocks_w >> shift) + (x >> shift);
451 int orig_mv_x = s->mvectors[mvpos].x;
452 int mv_x = s->mvectors[mvpos].x / (1 + !shift);
453 int mv_y = s->mvectors[mvpos].y / (1 + !shift);
454 int h = s->avctx->coded_height >> !shift;
455 int w = s->avctx->coded_width >> !shift;
458 ret = decode_inter_block(s, gb, quant_matrix, &skip, &map);
462 if (orig_mv_x >= -32) {
463 if (y * 8 + mv_y < 0 || y * 8 + mv_y >= h ||
464 x * 8 + mv_x < 0 || x * 8 + mv_x >= w)
465 return AVERROR_INVALIDDATA;
467 copy_block8(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
468 prev->data[plane] + ((s->blocks_h - 1 - y) * 8 - mv_y) * prev->linesize[plane] + (x * 8 + mv_x),
469 frame->linesize[plane], prev->linesize[plane], 8);
471 s->idsp.idct(s->block);
472 for (int i = 0; i < 64; i++)
473 s->block[i] = (s->block[i] + 1) & 0xFFFC;
474 s->idsp.add_pixels_clamped(s->block, frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
475 frame->linesize[plane]);
478 s->idsp.idct_put(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
479 frame->linesize[plane], s->block);
483 } else if (s->flags & 1) {
484 av_fast_padded_malloc(&s->wblocks, &s->wblocks_size,
485 64 * s->blocks_w * sizeof(*s->wblocks));
487 return AVERROR(ENOMEM);
489 av_fast_padded_malloc(&s->map, &s->map_size,
490 s->blocks_w * sizeof(*s->map));
492 return AVERROR(ENOMEM);
494 for (int y = 0; y < s->blocks_h; y++) {
495 ret = decode_inter_blocks(s, gb, quant_matrix, &skip, s->map);
499 for (int x = 0; x < s->blocks_w; x++) {
502 s->idsp.idct_add(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
503 frame->linesize[plane], s->wblocks + 64 * x);
507 for (int y = 0; y < s->blocks_h; y++) {
508 for (int x = 0; x < s->blocks_w; x++) {
511 ret = decode_inter_block(s, gb, quant_matrix, &skip, &map);
517 s->idsp.idct_add(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
518 frame->linesize[plane], s->block);
524 if (get_bits_left(gb) < 0)
525 av_log(s->avctx, AV_LOG_WARNING, "overread\n");
526 if (get_bits_left(gb) > 0)
527 av_log(s->avctx, AV_LOG_WARNING, "underread: %d\n", get_bits_left(gb));
532 static void compute_quant_matrix(AGMContext *s, double qscale)
534 int luma[64], chroma[64];
535 double f = 1.0 - fabs(qscale);
537 if (!s->key_frame && (s->flags & 2)) {
539 for (int i = 0; i < 64; i++) {
540 luma[i] = FFMAX(1, 16 * f);
541 chroma[i] = FFMAX(1, 16 * f);
544 for (int i = 0; i < 64; i++) {
545 luma[i] = FFMAX(1, 16 - qscale * 32);
546 chroma[i] = FFMAX(1, 16 - qscale * 32);
551 for (int i = 0; i < 64; i++) {
552 luma[i] = FFMAX(1, unscaled_luma [(i & 7) * 8 + (i >> 3)] * f);
553 chroma[i] = FFMAX(1, unscaled_chroma[(i & 7) * 8 + (i >> 3)] * f);
556 for (int i = 0; i < 64; i++) {
557 luma[i] = FFMAX(1, 255.0 - (255 - unscaled_luma [(i & 7) * 8 + (i >> 3)]) * f);
558 chroma[i] = FFMAX(1, 255.0 - (255 - unscaled_chroma[(i & 7) * 8 + (i >> 3)]) * f);
563 for (int i = 0; i < 64; i++) {
564 int pos = ff_zigzag_direct[i];
566 s->luma_quant_matrix[i] = luma[pos] * ((pos / 8) & 1 ? -1 : 1);
567 s->chroma_quant_matrix[i] = chroma[pos] * ((pos / 8) & 1 ? -1 : 1);
571 static int decode_raw_intra_rgb(AVCodecContext *avctx, GetByteContext *gbyte, AVFrame *frame)
573 uint8_t *dst = frame->data[0] + (avctx->height - 1) * frame->linesize[0];
574 uint8_t r = 0, g = 0, b = 0;
576 for (int y = 0; y < avctx->height; y++) {
577 for (int x = 0; x < avctx->width; x++) {
578 dst[x*3+0] = bytestream2_get_byte(gbyte) + r;
580 dst[x*3+1] = bytestream2_get_byte(gbyte) + g;
582 dst[x*3+2] = bytestream2_get_byte(gbyte) + b;
585 dst -= frame->linesize[0];
591 static int fill_pixels(uint8_t **y0, uint8_t **y1,
592 uint8_t **u, uint8_t **v,
593 int ylinesize, int ulinesize, int vlinesize,
595 int *nx, int *ny, int *np, int w, int h)
597 uint8_t *y0dst = *y0;
598 uint8_t *y1dst = *y1;
601 int x = *nx, y = *ny, pos = *np;
604 y0dst[2*x+0] += fill[0];
605 y0dst[2*x+1] += fill[1];
606 y1dst[2*x+0] += fill[2];
607 y1dst[2*x+1] += fill[3];
609 } else if (pos == 1) {
618 y0dst -= 2*ylinesize;
619 y1dst -= 2*ylinesize;
623 y0dst[2*x+0] += fill[2];
624 y0dst[2*x+1] += fill[3];
626 } else if (pos == 2) {
627 y1dst[2*x+0] += fill[0];
628 y1dst[2*x+1] += fill[1];
637 y0dst -= 2*ylinesize;
638 y1dst -= 2*ylinesize;
656 static int decode_runlen_rgb(AVCodecContext *avctx, GetByteContext *gbyte, AVFrame *frame)
658 uint8_t *dst = frame->data[0] + (avctx->height - 1) * frame->linesize[0];
659 int runlen, y = 0, x = 0;
663 while (bytestream2_get_bytes_left(gbyte) > 0) {
664 code = bytestream2_peek_le32(gbyte);
665 runlen = code & 0xFFFFFF;
667 if (code >> 24 == 0x77) {
668 bytestream2_skip(gbyte, 4);
670 for (int i = 0; i < 4; i++)
671 fill[i] = bytestream2_get_byte(gbyte);
676 for (int i = 0; i < 4; i++) {
679 if (x >= frame->width * 3) {
682 dst -= frame->linesize[0];
683 if (y >= frame->height)
689 for (int i = 0; i < 4; i++)
690 fill[i] = bytestream2_get_byte(gbyte);
692 for (int i = 0; i < 4; i++) {
695 if (x >= frame->width * 3) {
698 dst -= frame->linesize[0];
699 if (y >= frame->height)
709 static int decode_runlen(AVCodecContext *avctx, GetByteContext *gbyte, AVFrame *frame)
711 uint8_t *y0dst = frame->data[0] + (avctx->height - 1) * frame->linesize[0];
712 uint8_t *y1dst = y0dst - frame->linesize[0];
713 uint8_t *udst = frame->data[1] + ((avctx->height >> 1) - 1) * frame->linesize[1];
714 uint8_t *vdst = frame->data[2] + ((avctx->height >> 1) - 1) * frame->linesize[2];
715 int runlen, y = 0, x = 0, pos = 0;
719 while (bytestream2_get_bytes_left(gbyte) > 0) {
720 code = bytestream2_peek_le32(gbyte);
721 runlen = code & 0xFFFFFF;
723 if (code >> 24 == 0x77) {
724 bytestream2_skip(gbyte, 4);
726 for (int i = 0; i < 4; i++)
727 fill[i] = bytestream2_get_byte(gbyte);
732 if (fill_pixels(&y0dst, &y1dst, &udst, &vdst,
742 for (int i = 0; i < 4; i++)
743 fill[i] = bytestream2_get_byte(gbyte);
745 if (fill_pixels(&y0dst, &y1dst, &udst, &vdst,
759 static int decode_raw_intra(AVCodecContext *avctx, GetByteContext *gbyte, AVFrame *frame)
761 uint8_t *y0dst = frame->data[0] + (avctx->height - 1) * frame->linesize[0];
762 uint8_t *y1dst = y0dst - frame->linesize[0];
763 uint8_t *udst = frame->data[1] + ((avctx->height >> 1) - 1) * frame->linesize[1];
764 uint8_t *vdst = frame->data[2] + ((avctx->height >> 1) - 1) * frame->linesize[2];
765 uint8_t ly0 = 0, ly1 = 0, ly2 = 0, ly3 = 0, lu = 0, lv = 0;
767 for (int y = 0; y < avctx->height / 2; y++) {
768 for (int x = 0; x < avctx->width / 2; x++) {
769 y0dst[x*2+0] = bytestream2_get_byte(gbyte) + ly0;
771 y0dst[x*2+1] = bytestream2_get_byte(gbyte) + ly1;
773 y1dst[x*2+0] = bytestream2_get_byte(gbyte) + ly2;
775 y1dst[x*2+1] = bytestream2_get_byte(gbyte) + ly3;
777 udst[x] = bytestream2_get_byte(gbyte) + lu;
779 vdst[x] = bytestream2_get_byte(gbyte) + lv;
783 y0dst -= 2*frame->linesize[0];
784 y1dst -= 2*frame->linesize[0];
785 udst -= frame->linesize[1];
786 vdst -= frame->linesize[2];
792 static int decode_intra(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame)
794 AGMContext *s = avctx->priv_data;
797 compute_quant_matrix(s, (2 * s->compression - 100) / 100.0);
799 s->blocks_w = avctx->coded_width >> 3;
800 s->blocks_h = avctx->coded_height >> 3;
802 ret = decode_intra_plane(s, gb, s->size[0], s->luma_quant_matrix, frame, 0);
806 bytestream2_skip(&s->gbyte, s->size[0]);
808 s->blocks_w = avctx->coded_width >> 4;
809 s->blocks_h = avctx->coded_height >> 4;
811 ret = decode_intra_plane(s, gb, s->size[1], s->chroma_quant_matrix, frame, 2);
815 bytestream2_skip(&s->gbyte, s->size[1]);
817 s->blocks_w = avctx->coded_width >> 4;
818 s->blocks_h = avctx->coded_height >> 4;
820 ret = decode_intra_plane(s, gb, s->size[2], s->chroma_quant_matrix, frame, 1);
827 static int decode_motion_vectors(AVCodecContext *avctx, GetBitContext *gb)
829 AGMContext *s = avctx->priv_data;
830 int nb_mvs = ((avctx->height + 15) >> 4) * ((avctx->width + 15) >> 4);
831 int ret, skip = 0, value, map;
833 av_fast_padded_malloc(&s->mvectors, &s->mvectors_size,
834 nb_mvs * sizeof(*s->mvectors));
836 return AVERROR(ENOMEM);
838 if ((ret = init_get_bits8(gb, s->gbyte.buffer, bytestream2_get_bytes_left(&s->gbyte) -
839 (s->size[0] + s->size[1] + s->size[2]))) < 0)
842 memset(s->mvectors, 0, sizeof(*s->mvectors) * nb_mvs);
844 for (int i = 0; i < nb_mvs; i++) {
845 ret = read_code(gb, &skip, &value, &map, 1);
848 s->mvectors[i].x = value;
852 for (int i = 0; i < nb_mvs; i++) {
853 ret = read_code(gb, &skip, &value, &map, 1);
856 s->mvectors[i].y = value;
860 if (get_bits_left(gb) <= 0)
861 return AVERROR_INVALIDDATA;
862 skip = (get_bits_count(gb) >> 3) + 1;
863 bytestream2_skip(&s->gbyte, skip);
868 static int decode_inter(AVCodecContext *avctx, GetBitContext *gb,
869 AVFrame *frame, AVFrame *prev)
871 AGMContext *s = avctx->priv_data;
874 compute_quant_matrix(s, (2 * s->compression - 100) / 100.0);
877 ret = decode_motion_vectors(avctx, gb);
882 s->blocks_w = avctx->coded_width >> 3;
883 s->blocks_h = avctx->coded_height >> 3;
885 ret = decode_inter_plane(s, gb, s->size[0], s->luma_quant_matrix, frame, prev, 0);
889 bytestream2_skip(&s->gbyte, s->size[0]);
891 s->blocks_w = avctx->coded_width >> 4;
892 s->blocks_h = avctx->coded_height >> 4;
894 ret = decode_inter_plane(s, gb, s->size[1], s->chroma_quant_matrix, frame, prev, 2);
898 bytestream2_skip(&s->gbyte, s->size[1]);
900 s->blocks_w = avctx->coded_width >> 4;
901 s->blocks_h = avctx->coded_height >> 4;
903 ret = decode_inter_plane(s, gb, s->size[2], s->chroma_quant_matrix, frame, prev, 1);
910 typedef struct Node {
915 static void get_tree_codes(uint32_t *codes, Node *nodes, int idx, uint32_t pfx, int bitpos)
917 if (idx < 256 && idx >= 0) {
919 } else if (idx >= 0) {
920 get_tree_codes(codes, nodes, nodes[idx].child[0], pfx + (0 << bitpos), bitpos + 1);
921 get_tree_codes(codes, nodes, nodes[idx].child[1], pfx + (1U << bitpos), bitpos + 1);
925 static int make_new_tree(const uint8_t *bitlens, uint32_t *codes)
927 int zlcount = 0, curlen, idx, nindex, last, llast;
928 int blcounts[32] = { 0 };
934 for (int i = 0; i < 256; i++) {
935 int bitlen = bitlens[i];
936 int blcount = blcounts[bitlen];
938 zlcount += bitlen < 1;
939 syms[(bitlen << 8) + blcount] = i;
943 for (int i = 0; i < 512; i++) {
944 nodes[i].child[0] = -1;
945 nodes[i].child[1] = -1;
948 for (int i = 0; i < 256; i++) {
949 node_idx[i] = 257 + i;
957 for (curlen = 1; curlen < 32; curlen++) {
958 if (blcounts[curlen] > 0) {
959 int max_zlcount = zlcount + blcounts[curlen];
961 for (int i = 0; zlcount < 256 && zlcount < max_zlcount; zlcount++, i++) {
962 int p = node_idx[nindex - 1 + 512];
963 int ch = syms[256 * curlen + i];
966 return AVERROR_INVALIDDATA;
968 if (nodes[p].child[0] == -1) {
969 nodes[p].child[0] = ch;
971 nodes[p].child[1] = ch;
974 nodes[ch].parent = p;
983 p = node_idx[nindex - 1 + 512];
985 if (nodes[p].child[0] == -1) {
986 nodes[p].child[0] = ch;
988 nodes[p].child[1] = ch;
992 nodes[ch].parent = p;
997 for (int i = 0; i < idx; i++)
998 node_idx[512 + i] = old_idx[i];
1006 get_tree_codes(codes, nodes, 256, 0, 0);
1010 static int build_huff(const uint8_t *bitlen, VLC *vlc)
1012 uint32_t new_codes[256];
1014 uint8_t symbols[256];
1015 uint32_t codes[256];
1018 int ret = make_new_tree(bitlen, new_codes);
1022 for (int i = 0; i < 256; i++) {
1024 bits[nb_codes] = bitlen[i];
1025 codes[nb_codes] = new_codes[i];
1026 symbols[nb_codes] = i;
1032 return ff_init_vlc_sparse(vlc, 13, nb_codes,
1039 static int decode_huffman2(AVCodecContext *avctx, int header, int size)
1041 AGMContext *s = avctx->priv_data;
1042 GetBitContext *gb = &s->gb;
1046 if ((ret = init_get_bits8(gb, s->gbyte.buffer,
1047 bytestream2_get_bytes_left(&s->gbyte))) < 0)
1050 s->output_size = get_bits_long(gb, 32);
1052 if (s->output_size > avctx->width * avctx->height * 9LL + 10000)
1053 return AVERROR_INVALIDDATA;
1055 av_fast_padded_malloc(&s->output, &s->padded_output_size, s->output_size);
1057 return AVERROR(ENOMEM);
1059 x = get_bits(gb, 1);
1060 len = 4 + get_bits(gb, 1);
1063 int count = get_bits(gb, 3) + 1;
1065 for (int i = 0; i < count; i++)
1066 cb[i] = get_bits(gb, len);
1068 for (int i = 0; i < 256; i++) {
1069 int idx = get_bits(gb, 3);
1073 for (int i = 0; i < 256; i++)
1074 lens[i] = get_bits(gb, len);
1077 if ((ret = build_huff(lens, &s->vlc)) < 0)
1081 while (get_bits_left(gb) > 0 && x < s->output_size) {
1082 int val = get_vlc2(gb, s->vlc.table, s->vlc.bits, 3);
1084 return AVERROR_INVALIDDATA;
1085 s->output[x++] = val;
1091 static int decode_frame(AVCodecContext *avctx, void *data,
1092 int *got_frame, AVPacket *avpkt)
1094 AGMContext *s = avctx->priv_data;
1095 GetBitContext *gb = &s->gb;
1096 GetByteContext *gbyte = &s->gbyte;
1097 AVFrame *frame = data;
1098 int w, h, width, height, header;
1099 unsigned compressed_size;
1106 bytestream2_init(gbyte, avpkt->data, avpkt->size);
1108 header = bytestream2_get_le32(gbyte);
1109 s->fflags = bytestream2_get_le32(gbyte);
1110 s->bitstream_size = s->fflags & 0x1FFFFFFF;
1112 av_log(avctx, AV_LOG_DEBUG, "fflags: %X\n", s->fflags);
1113 if (avpkt->size < s->bitstream_size + 8)
1114 return AVERROR_INVALIDDATA;
1116 s->key_frame = (avpkt->flags & AV_PKT_FLAG_KEY);
1117 frame->key_frame = s->key_frame;
1118 frame->pict_type = s->key_frame ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
1120 if (!s->key_frame) {
1121 if (!s->prev_frame->data[0]) {
1122 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1123 return AVERROR_INVALIDDATA;
1128 if (avctx->codec_tag == MKTAG('A', 'G', 'M', '0') ||
1129 avctx->codec_tag == MKTAG('A', 'G', 'M', '1'))
1130 return AVERROR_PATCHWELCOME;
1132 ret = decode_huffman2(avctx, header, (avpkt->size - s->bitstream_size) - 8);
1135 bytestream2_init(gbyte, s->output, s->output_size);
1136 } else if (!s->dct) {
1137 bytestream2_skip(gbyte, 4);
1142 w = bytestream2_get_le32(gbyte);
1143 h = bytestream2_get_le32(gbyte);
1144 if (w == INT32_MIN || h == INT32_MIN)
1145 return AVERROR_INVALIDDATA;
1155 width = avctx->width;
1156 height = avctx->height;
1157 if (w < width || h < height || w & 7 || h & 7)
1158 return AVERROR_INVALIDDATA;
1160 ret = ff_set_dimensions(avctx, w, h);
1163 avctx->width = width;
1164 avctx->height = height;
1166 s->compression = bytestream2_get_le32(gbyte);
1167 if (s->compression < 0 || s->compression > 100)
1168 return AVERROR_INVALIDDATA;
1170 for (int i = 0; i < 3; i++)
1171 s->size[i] = bytestream2_get_le32(gbyte);
1173 compressed_size = s->output_size;
1176 compressed_size = avpkt->size;
1179 if (s->size[0] < 0 || s->size[1] < 0 || s->size[2] < 0 ||
1180 skip + s->size[0] + s->size[1] + s->size[2] > compressed_size) {
1181 return AVERROR_INVALIDDATA;
1185 if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
1188 if (frame->key_frame) {
1189 if (!s->dct && !s->rgb)
1190 ret = decode_raw_intra(avctx, gbyte, frame);
1191 else if (!s->dct && s->rgb)
1192 ret = decode_raw_intra_rgb(avctx, gbyte, frame);
1194 ret = decode_intra(avctx, gb, frame);
1196 if (s->prev_frame-> width != frame->width ||
1197 s->prev_frame->height != frame->height)
1198 return AVERROR_INVALIDDATA;
1200 if (!(s->flags & 2)) {
1201 ret = av_frame_copy(frame, s->prev_frame);
1207 ret = decode_inter(avctx, gb, frame, s->prev_frame);
1208 } else if (!s->dct && !s->rgb) {
1209 ret = decode_runlen(avctx, gbyte, frame);
1211 ret = decode_runlen_rgb(avctx, gbyte, frame);
1217 av_frame_unref(s->prev_frame);
1218 if ((ret = av_frame_ref(s->prev_frame, frame)) < 0)
1221 frame->crop_top = avctx->coded_height - avctx->height;
1222 frame->crop_left = avctx->coded_width - avctx->width;
1229 static av_cold int decode_init(AVCodecContext *avctx)
1231 AGMContext *s = avctx->priv_data;
1233 s->rgb = avctx->codec_tag == MKTAG('A', 'G', 'M', '4');
1234 avctx->pix_fmt = s->rgb ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_YUV420P;
1236 s->plus = avctx->codec_tag == MKTAG('A', 'G', 'M', '3') ||
1237 avctx->codec_tag == MKTAG('A', 'G', 'M', '7');
1239 s->dct = avctx->codec_tag != MKTAG('A', 'G', 'M', '4') &&
1240 avctx->codec_tag != MKTAG('A', 'G', 'M', '5');
1242 avctx->idct_algo = FF_IDCT_SIMPLE;
1243 ff_idctdsp_init(&s->idsp, avctx);
1244 ff_init_scantable(s->idsp.idct_permutation, &s->scantable, ff_zigzag_direct);
1246 s->prev_frame = av_frame_alloc();
1248 return AVERROR(ENOMEM);
1253 static void decode_flush(AVCodecContext *avctx)
1255 AGMContext *s = avctx->priv_data;
1257 av_frame_unref(s->prev_frame);
1260 static av_cold int decode_close(AVCodecContext *avctx)
1262 AGMContext *s = avctx->priv_data;
1264 ff_free_vlc(&s->vlc);
1265 av_frame_free(&s->prev_frame);
1266 av_freep(&s->mvectors);
1267 s->mvectors_size = 0;
1268 av_freep(&s->wblocks);
1269 s->wblocks_size = 0;
1270 av_freep(&s->output);
1271 s->padded_output_size = 0;
1278 AVCodec ff_agm_decoder = {
1280 .long_name = NULL_IF_CONFIG_SMALL("Amuse Graphics Movie"),
1281 .type = AVMEDIA_TYPE_VIDEO,
1282 .id = AV_CODEC_ID_AGM,
1283 .priv_data_size = sizeof(AGMContext),
1284 .init = decode_init,
1285 .close = decode_close,
1286 .decode = decode_frame,
1287 .flush = decode_flush,
1288 .capabilities = AV_CODEC_CAP_DR1,
1289 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
1290 FF_CODEC_CAP_INIT_CLEANUP |
1291 FF_CODEC_CAP_EXPORTS_CROPPING,