#define BITSTREAM_READER_LE
+#include "libavutil/mem_internal.h"
+
#include "avcodec.h"
#include "bytestream.h"
#include "copy_block.h"
int blocks_h;
int size[3];
int plus;
+ int dct;
+ int rgb;
unsigned flags;
unsigned fflags;
+ uint8_t *output;
+ unsigned padded_output_size;
+ unsigned output_size;
+
MotionVector *mvectors;
- int mvectors_size;
+ unsigned mvectors_size;
+
+ VLC vlc;
AVFrame *prev_frame;
ScanTable scantable;
DECLARE_ALIGNED(32, int16_t, block)[64];
+
+ int16_t *wblocks;
+ unsigned wblocks_size;
+
+ int *map;
+ unsigned map_size;
+
IDCTDSPContext idsp;
} AGMContext;
{
int len = 0, skip = 0, max;
+ if (get_bits_left(gb) < 2)
+ return AVERROR_INVALIDDATA;
+
if (show_bits(gb, 2)) {
switch (show_bits(gb, 4)) {
case 1:
return 0;
}
-static int decode_intra_block(AGMContext *s, GetBitContext *gb, int size,
+static int decode_intra_blocks(AGMContext *s, GetBitContext *gb,
+ const int *quant_matrix, int *skip, int *dc_level)
+{
+ const uint8_t *scantable = s->scantable.permutated;
+ int level, ret, map = 0;
+
+ memset(s->wblocks, 0, s->wblocks_size);
+
+ for (int i = 0; i < 64; i++) {
+ int16_t *block = s->wblocks + scantable[i];
+
+ for (int j = 0; j < s->blocks_w;) {
+ if (*skip > 0) {
+ int rskip;
+
+ rskip = FFMIN(*skip, s->blocks_w - j);
+ j += rskip;
+ if (i == 0) {
+ for (int k = 0; k < rskip; k++)
+ block[64 * k] = *dc_level * quant_matrix[0];
+ }
+ block += rskip * 64;
+ *skip -= rskip;
+ } else {
+ ret = read_code(gb, skip, &level, &map, s->flags & 1);
+ if (ret < 0)
+ return ret;
+
+ if (i == 0)
+ *dc_level += level;
+
+ block[0] = (i == 0 ? *dc_level : level) * quant_matrix[i];
+ block += 64;
+ j++;
+ }
+ }
+ }
+
+ return 0;
+}
+
+static int decode_inter_blocks(AGMContext *s, GetBitContext *gb,
+ const int *quant_matrix, int *skip,
+ int *map)
+{
+ const uint8_t *scantable = s->scantable.permutated;
+ int level, ret;
+
+ memset(s->wblocks, 0, s->wblocks_size);
+ memset(s->map, 0, s->map_size);
+
+ for (int i = 0; i < 64; i++) {
+ int16_t *block = s->wblocks + scantable[i];
+
+ for (int j = 0; j < s->blocks_w;) {
+ if (*skip > 0) {
+ int rskip;
+
+ rskip = FFMIN(*skip, s->blocks_w - j);
+ j += rskip;
+ block += rskip * 64;
+ *skip -= rskip;
+ } else {
+ ret = read_code(gb, skip, &level, &map[j], s->flags & 1);
+ if (ret < 0)
+ return ret;
+
+ block[0] = level * quant_matrix[i];
+ block += 64;
+ j++;
+ }
+ }
+ }
+
+ return 0;
+}
+
+static int decode_intra_block(AGMContext *s, GetBitContext *gb,
const int *quant_matrix, int *skip, int *dc_level)
{
const uint8_t *scantable = s->scantable.permutated;
int plane)
{
int ret, skip = 0, dc_level = 0;
+ const int offset = s->plus ? 0 : 1024;
if ((ret = init_get_bits8(gb, s->gbyte.buffer, size)) < 0)
return ret;
- for (int y = 0; y < s->blocks_h; y++) {
- for (int x = 0; x < s->blocks_w; x++) {
- ret = decode_intra_block(s, gb, size, quant_matrix, &skip, &dc_level);
+ if (s->flags & 1) {
+ av_fast_padded_malloc(&s->wblocks, &s->wblocks_size,
+ 64 * s->blocks_w * sizeof(*s->wblocks));
+ if (!s->wblocks)
+ return AVERROR(ENOMEM);
+
+ for (int y = 0; y < s->blocks_h; y++) {
+ ret = decode_intra_blocks(s, gb, quant_matrix, &skip, &dc_level);
if (ret < 0)
return ret;
- s->idsp.idct_put(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
- frame->linesize[plane], s->block);
+ for (int x = 0; x < s->blocks_w; x++) {
+ s->wblocks[64 * x] += offset;
+ s->idsp.idct_put(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
+ frame->linesize[plane], s->wblocks + 64 * x);
+ }
+ }
+ } else {
+ for (int y = 0; y < s->blocks_h; y++) {
+ for (int x = 0; x < s->blocks_w; x++) {
+ ret = decode_intra_block(s, gb, quant_matrix, &skip, &dc_level);
+ if (ret < 0)
+ return ret;
+
+ s->idsp.idct_put(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
+ frame->linesize[plane], s->block);
+ }
}
}
return 0;
}
-static int decode_inter_block(AGMContext *s, GetBitContext *gb, int size,
+static int decode_inter_block(AGMContext *s, GetBitContext *gb,
const int *quant_matrix, int *skip,
int *map)
{
if ((ret = init_get_bits8(gb, s->gbyte.buffer, size)) < 0)
return ret;
- if (s->flags & 2) {
+ if (s->flags == 3) {
+ av_fast_padded_malloc(&s->wblocks, &s->wblocks_size,
+ 64 * s->blocks_w * sizeof(*s->wblocks));
+ if (!s->wblocks)
+ return AVERROR(ENOMEM);
+
+ av_fast_padded_malloc(&s->map, &s->map_size,
+ s->blocks_w * sizeof(*s->map));
+ if (!s->map)
+ return AVERROR(ENOMEM);
+
+ for (int y = 0; y < s->blocks_h; y++) {
+ ret = decode_inter_blocks(s, gb, quant_matrix, &skip, s->map);
+ if (ret < 0)
+ return ret;
+
+ for (int x = 0; x < s->blocks_w; x++) {
+ int shift = plane == 0;
+ int mvpos = (y >> shift) * (s->blocks_w >> shift) + (x >> shift);
+ int orig_mv_x = s->mvectors[mvpos].x;
+ int mv_x = s->mvectors[mvpos].x / (1 + !shift);
+ int mv_y = s->mvectors[mvpos].y / (1 + !shift);
+ int h = s->avctx->coded_height >> !shift;
+ int w = s->avctx->coded_width >> !shift;
+ int map = s->map[x];
+
+ if (orig_mv_x >= -32) {
+ if (y * 8 + mv_y < 0 || y * 8 + mv_y + 8 > h ||
+ x * 8 + mv_x < 0 || x * 8 + mv_x + 8 > w)
+ return AVERROR_INVALIDDATA;
+
+ copy_block8(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
+ prev->data[plane] + ((s->blocks_h - 1 - y) * 8 - mv_y) * prev->linesize[plane] + (x * 8 + mv_x),
+ frame->linesize[plane], prev->linesize[plane], 8);
+ if (map) {
+ s->idsp.idct(s->wblocks + x * 64);
+ for (int i = 0; i < 64; i++)
+ s->wblocks[i + x * 64] = (s->wblocks[i + x * 64] + 1) & 0xFFFC;
+ s->idsp.add_pixels_clamped(&s->wblocks[x*64], frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
+ frame->linesize[plane]);
+ }
+ } else if (map) {
+ s->idsp.idct_put(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
+ frame->linesize[plane], s->wblocks + x * 64);
+ }
+ }
+ }
+ } else if (s->flags & 2) {
for (int y = 0; y < s->blocks_h; y++) {
for (int x = 0; x < s->blocks_w; x++) {
int shift = plane == 0;
int w = s->avctx->coded_width >> !shift;
int map = 0;
- ret = decode_inter_block(s, gb, size, quant_matrix, &skip, &map);
+ ret = decode_inter_block(s, gb, quant_matrix, &skip, &map);
if (ret < 0)
return ret;
if (orig_mv_x >= -32) {
- if (y * 8 + mv_y < 0 || y * 8 + mv_y >= h ||
- x * 8 + mv_x < 0 || x * 8 + mv_x >= w)
+ if (y * 8 + mv_y < 0 || y * 8 + mv_y + 8 > h ||
+ x * 8 + mv_x < 0 || x * 8 + mv_x + 8 > w)
return AVERROR_INVALIDDATA;
copy_block8(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
}
}
}
+ } else if (s->flags & 1) {
+ av_fast_padded_malloc(&s->wblocks, &s->wblocks_size,
+ 64 * s->blocks_w * sizeof(*s->wblocks));
+ if (!s->wblocks)
+ return AVERROR(ENOMEM);
+
+ av_fast_padded_malloc(&s->map, &s->map_size,
+ s->blocks_w * sizeof(*s->map));
+ if (!s->map)
+ return AVERROR(ENOMEM);
+
+ for (int y = 0; y < s->blocks_h; y++) {
+ ret = decode_inter_blocks(s, gb, quant_matrix, &skip, s->map);
+ if (ret < 0)
+ return ret;
+
+ for (int x = 0; x < s->blocks_w; x++) {
+ if (!s->map[x])
+ continue;
+ s->idsp.idct_add(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
+ frame->linesize[plane], s->wblocks + 64 * x);
+ }
+ }
} else {
for (int y = 0; y < s->blocks_h; y++) {
for (int x = 0; x < s->blocks_w; x++) {
int map = 0;
- ret = decode_inter_block(s, gb, size, quant_matrix, &skip, &map);
+ ret = decode_inter_block(s, gb, quant_matrix, &skip, &map);
if (ret < 0)
return ret;
}
}
+static int decode_raw_intra_rgb(AVCodecContext *avctx, GetByteContext *gbyte, AVFrame *frame)
+{
+ uint8_t *dst = frame->data[0] + (avctx->height - 1) * frame->linesize[0];
+ uint8_t r = 0, g = 0, b = 0;
+
+ if (bytestream2_get_bytes_left(gbyte) < 3 * avctx->width * avctx->height)
+ return AVERROR_INVALIDDATA;
+
+ for (int y = 0; y < avctx->height; y++) {
+ for (int x = 0; x < avctx->width; x++) {
+ dst[x*3+0] = bytestream2_get_byteu(gbyte) + r;
+ r = dst[x*3+0];
+ dst[x*3+1] = bytestream2_get_byteu(gbyte) + g;
+ g = dst[x*3+1];
+ dst[x*3+2] = bytestream2_get_byteu(gbyte) + b;
+ b = dst[x*3+2];
+ }
+ dst -= frame->linesize[0];
+ }
+
+ return 0;
+}
+
+av_always_inline static int fill_pixels(uint8_t **y0, uint8_t **y1,
+ uint8_t **u, uint8_t **v,
+ int ylinesize, int ulinesize, int vlinesize,
+ uint8_t *fill,
+ int *nx, int *ny, int *np, int w, int h)
+{
+ uint8_t *y0dst = *y0;
+ uint8_t *y1dst = *y1;
+ uint8_t *udst = *u;
+ uint8_t *vdst = *v;
+ int x = *nx, y = *ny, pos = *np;
+
+ if (pos == 0) {
+ y0dst[2*x+0] += fill[0];
+ y0dst[2*x+1] += fill[1];
+ y1dst[2*x+0] += fill[2];
+ y1dst[2*x+1] += fill[3];
+ pos++;
+ } else if (pos == 1) {
+ udst[x] += fill[0];
+ vdst[x] += fill[1];
+ x++;
+ if (x >= w) {
+ x = 0;
+ y++;
+ if (y >= h)
+ return 1;
+ y0dst -= 2*ylinesize;
+ y1dst -= 2*ylinesize;
+ udst -= ulinesize;
+ vdst -= vlinesize;
+ }
+ y0dst[2*x+0] += fill[2];
+ y0dst[2*x+1] += fill[3];
+ pos++;
+ } else if (pos == 2) {
+ y1dst[2*x+0] += fill[0];
+ y1dst[2*x+1] += fill[1];
+ udst[x] += fill[2];
+ vdst[x] += fill[3];
+ x++;
+ if (x >= w) {
+ x = 0;
+ y++;
+ if (y >= h)
+ return 1;
+ y0dst -= 2*ylinesize;
+ y1dst -= 2*ylinesize;
+ udst -= ulinesize;
+ vdst -= vlinesize;
+ }
+ pos = 0;
+ }
+
+ *y0 = y0dst;
+ *y1 = y1dst;
+ *u = udst;
+ *v = vdst;
+ *np = pos;
+ *nx = x;
+ *ny = y;
+
+ return 0;
+}
+
+static int decode_runlen_rgb(AVCodecContext *avctx, GetByteContext *gbyte, AVFrame *frame)
+{
+ uint8_t *dst = frame->data[0] + (avctx->height - 1) * frame->linesize[0];
+ int runlen, y = 0, x = 0;
+ uint8_t fill[4];
+ unsigned code;
+
+ while (bytestream2_get_bytes_left(gbyte) > 0) {
+ code = bytestream2_peek_le32(gbyte);
+ runlen = code & 0xFFFFFF;
+
+ if (code >> 24 == 0x77) {
+ bytestream2_skip(gbyte, 4);
+
+ for (int i = 0; i < 4; i++)
+ fill[i] = bytestream2_get_byte(gbyte);
+
+ while (runlen > 0) {
+ runlen--;
+
+ for (int i = 0; i < 4; i++) {
+ dst[x] += fill[i];
+ x++;
+ if (x >= frame->width * 3) {
+ x = 0;
+ y++;
+ dst -= frame->linesize[0];
+ if (y >= frame->height)
+ return 0;
+ }
+ }
+ }
+ } else {
+ for (int i = 0; i < 4; i++)
+ fill[i] = bytestream2_get_byte(gbyte);
+
+ for (int i = 0; i < 4; i++) {
+ dst[x] += fill[i];
+ x++;
+ if (x >= frame->width * 3) {
+ x = 0;
+ y++;
+ dst -= frame->linesize[0];
+ if (y >= frame->height)
+ return 0;
+ }
+ }
+ }
+ }
+
+ return 0;
+}
+
+static int decode_runlen(AVCodecContext *avctx, GetByteContext *gbyte, AVFrame *frame)
+{
+ uint8_t *y0dst = frame->data[0] + (avctx->height - 1) * frame->linesize[0];
+ uint8_t *y1dst = y0dst - frame->linesize[0];
+ uint8_t *udst = frame->data[1] + ((avctx->height >> 1) - 1) * frame->linesize[1];
+ uint8_t *vdst = frame->data[2] + ((avctx->height >> 1) - 1) * frame->linesize[2];
+ int runlen, y = 0, x = 0, pos = 0;
+ uint8_t fill[4];
+ unsigned code;
+
+ while (bytestream2_get_bytes_left(gbyte) > 0) {
+ code = bytestream2_peek_le32(gbyte);
+ runlen = code & 0xFFFFFF;
+
+ if (code >> 24 == 0x77) {
+ bytestream2_skip(gbyte, 4);
+
+ for (int i = 0; i < 4; i++)
+ fill[i] = bytestream2_get_byte(gbyte);
+
+ while (runlen > 0) {
+ runlen--;
+
+ if (fill_pixels(&y0dst, &y1dst, &udst, &vdst,
+ frame->linesize[0],
+ frame->linesize[1],
+ frame->linesize[2],
+ fill, &x, &y, &pos,
+ avctx->width / 2,
+ avctx->height / 2))
+ return 0;
+ }
+ } else {
+ for (int i = 0; i < 4; i++)
+ fill[i] = bytestream2_get_byte(gbyte);
+
+ if (fill_pixels(&y0dst, &y1dst, &udst, &vdst,
+ frame->linesize[0],
+ frame->linesize[1],
+ frame->linesize[2],
+ fill, &x, &y, &pos,
+ avctx->width / 2,
+ avctx->height / 2))
+ return 0;
+ }
+ }
+
+ return 0;
+}
+
+static int decode_raw_intra(AVCodecContext *avctx, GetByteContext *gbyte, AVFrame *frame)
+{
+ uint8_t *y0dst = frame->data[0] + (avctx->height - 1) * frame->linesize[0];
+ uint8_t *y1dst = y0dst - frame->linesize[0];
+ uint8_t *udst = frame->data[1] + ((avctx->height >> 1) - 1) * frame->linesize[1];
+ uint8_t *vdst = frame->data[2] + ((avctx->height >> 1) - 1) * frame->linesize[2];
+ uint8_t ly0 = 0, ly1 = 0, ly2 = 0, ly3 = 0, lu = 0, lv = 0;
+
+ for (int y = 0; y < avctx->height / 2; y++) {
+ for (int x = 0; x < avctx->width / 2; x++) {
+ y0dst[x*2+0] = bytestream2_get_byte(gbyte) + ly0;
+ ly0 = y0dst[x*2+0];
+ y0dst[x*2+1] = bytestream2_get_byte(gbyte) + ly1;
+ ly1 = y0dst[x*2+1];
+ y1dst[x*2+0] = bytestream2_get_byte(gbyte) + ly2;
+ ly2 = y1dst[x*2+0];
+ y1dst[x*2+1] = bytestream2_get_byte(gbyte) + ly3;
+ ly3 = y1dst[x*2+1];
+ udst[x] = bytestream2_get_byte(gbyte) + lu;
+ lu = udst[x];
+ vdst[x] = bytestream2_get_byte(gbyte) + lv;
+ lv = vdst[x];
+ }
+
+ y0dst -= 2*frame->linesize[0];
+ y1dst -= 2*frame->linesize[0];
+ udst -= frame->linesize[1];
+ vdst -= frame->linesize[2];
+ }
+
+ return 0;
+}
+
static int decode_intra(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame)
{
AGMContext *s = avctx->priv_data;
static int decode_motion_vectors(AVCodecContext *avctx, GetBitContext *gb)
{
AGMContext *s = avctx->priv_data;
- int nb_mvs = ((avctx->height + 15) >> 4) * ((avctx->width + 15) >> 4);
+ int nb_mvs = ((avctx->coded_height + 15) >> 4) * ((avctx->coded_width + 15) >> 4);
int ret, skip = 0, value, map;
av_fast_padded_malloc(&s->mvectors, &s->mvectors_size,
return 0;
}
+typedef struct Node {
+ int parent;
+ int child[2];
+} Node;
+
+static void get_tree_codes(uint32_t *codes, Node *nodes, int idx, uint32_t pfx, int bitpos)
+{
+ if (idx < 256 && idx >= 0) {
+ codes[idx] = pfx;
+ } else if (idx >= 0) {
+ get_tree_codes(codes, nodes, nodes[idx].child[0], pfx + (0 << bitpos), bitpos + 1);
+ get_tree_codes(codes, nodes, nodes[idx].child[1], pfx + (1U << bitpos), bitpos + 1);
+ }
+}
+
+static int make_new_tree(const uint8_t *bitlens, uint32_t *codes)
+{
+ int zlcount = 0, curlen, idx, nindex, last, llast;
+ int blcounts[32] = { 0 };
+ int syms[8192];
+ Node nodes[512];
+ int node_idx[1024];
+ int old_idx[512];
+
+ for (int i = 0; i < 256; i++) {
+ int bitlen = bitlens[i];
+ int blcount = blcounts[bitlen];
+
+ zlcount += bitlen < 1;
+ syms[(bitlen << 8) + blcount] = i;
+ blcounts[bitlen]++;
+ }
+
+ for (int i = 0; i < 512; i++) {
+ nodes[i].child[0] = -1;
+ nodes[i].child[1] = -1;
+ }
+
+ for (int i = 0; i < 256; i++) {
+ node_idx[i] = 257 + i;
+ }
+
+ curlen = 1;
+ node_idx[512] = 256;
+ last = 255;
+ nindex = 1;
+
+ for (curlen = 1; curlen < 32; curlen++) {
+ if (blcounts[curlen] > 0) {
+ int max_zlcount = zlcount + blcounts[curlen];
+
+ for (int i = 0; zlcount < 256 && zlcount < max_zlcount; zlcount++, i++) {
+ int p = node_idx[nindex - 1 + 512];
+ int ch = syms[256 * curlen + i];
+
+ if (nindex <= 0)
+ return AVERROR_INVALIDDATA;
+
+ if (nodes[p].child[0] == -1) {
+ nodes[p].child[0] = ch;
+ } else {
+ nodes[p].child[1] = ch;
+ nindex--;
+ }
+ nodes[ch].parent = p;
+ }
+ }
+ llast = last - 1;
+ idx = 0;
+ while (nindex > 0) {
+ int p, ch;
+
+ last = llast - idx;
+ p = node_idx[nindex - 1 + 512];
+ ch = node_idx[last];
+ if (nodes[p].child[0] == -1) {
+ nodes[p].child[0] = ch;
+ } else {
+ nodes[p].child[1] = ch;
+ nindex--;
+ }
+ old_idx[idx] = ch;
+ nodes[ch].parent = p;
+ if (idx == llast)
+ goto next;
+ idx++;
+ if (nindex <= 0) {
+ for (int i = 0; i < idx; i++)
+ node_idx[512 + i] = old_idx[i];
+ }
+ }
+ nindex = idx;
+ }
+
+next:
+
+ get_tree_codes(codes, nodes, 256, 0, 0);
+ return 0;
+}
+
+static int build_huff(const uint8_t *bitlen, VLC *vlc)
+{
+ uint32_t new_codes[256];
+ uint8_t bits[256];
+ uint8_t symbols[256];
+ uint32_t codes[256];
+ int nb_codes = 0;
+
+ int ret = make_new_tree(bitlen, new_codes);
+ if (ret < 0)
+ return ret;
+
+ for (int i = 0; i < 256; i++) {
+ if (bitlen[i]) {
+ bits[nb_codes] = bitlen[i];
+ codes[nb_codes] = new_codes[i];
+ symbols[nb_codes] = i;
+ nb_codes++;
+ }
+ }
+
+ ff_free_vlc(vlc);
+ return ff_init_vlc_sparse(vlc, 13, nb_codes,
+ bits, 1, 1,
+ codes, 4, 4,
+ symbols, 1, 1,
+ INIT_VLC_LE);
+}
+
+static int decode_huffman2(AVCodecContext *avctx, int header, int size)
+{
+ AGMContext *s = avctx->priv_data;
+ GetBitContext *gb = &s->gb;
+ uint8_t lens[256];
+ int ret, x, len;
+
+ if ((ret = init_get_bits8(gb, s->gbyte.buffer,
+ bytestream2_get_bytes_left(&s->gbyte))) < 0)
+ return ret;
+
+ s->output_size = get_bits_long(gb, 32);
+
+ if (s->output_size > avctx->width * avctx->height * 9LL + 10000)
+ return AVERROR_INVALIDDATA;
+
+ av_fast_padded_malloc(&s->output, &s->padded_output_size, s->output_size);
+ if (!s->output)
+ return AVERROR(ENOMEM);
+
+ x = get_bits(gb, 1);
+ len = 4 + get_bits(gb, 1);
+ if (x) {
+ int cb[8] = { 0 };
+ int count = get_bits(gb, 3) + 1;
+
+ for (int i = 0; i < count; i++)
+ cb[i] = get_bits(gb, len);
+
+ for (int i = 0; i < 256; i++) {
+ int idx = get_bits(gb, 3);
+ lens[i] = cb[idx];
+ }
+ } else {
+ for (int i = 0; i < 256; i++)
+ lens[i] = get_bits(gb, len);
+ }
+
+ if ((ret = build_huff(lens, &s->vlc)) < 0)
+ return ret;
+
+ x = 0;
+ while (get_bits_left(gb) > 0 && x < s->output_size) {
+ int val = get_vlc2(gb, s->vlc.table, s->vlc.bits, 3);
+ if (val < 0)
+ return AVERROR_INVALIDDATA;
+ s->output[x++] = val;
+ }
+
+ return 0;
+}
+
static int decode_frame(AVCodecContext *avctx, void *data,
int *got_frame, AVPacket *avpkt)
{
GetByteContext *gbyte = &s->gbyte;
AVFrame *frame = data;
int w, h, width, height, header;
+ unsigned compressed_size;
+ long skip;
int ret;
if (!avpkt->size)
if (avpkt->size < s->bitstream_size + 8)
return AVERROR_INVALIDDATA;
- s->key_frame = s->fflags & 0x1;
+ s->key_frame = (avpkt->flags & AV_PKT_FLAG_KEY);
frame->key_frame = s->key_frame;
frame->pict_type = s->key_frame ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
- if (header) {
- av_log(avctx, AV_LOG_ERROR, "header: %X\n", header);
- return AVERROR_PATCHWELCOME;
+ if (!s->key_frame) {
+ if (!s->prev_frame->data[0]) {
+ av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
+ return AVERROR_INVALIDDATA;
+ }
}
- s->flags = 0;
- w = bytestream2_get_le32(gbyte);
- h = bytestream2_get_le32(gbyte);
- if (w == INT32_MIN || h == INT32_MIN)
- return AVERROR_INVALIDDATA;
- if (w < 0) {
- w = -w;
- s->flags |= 2;
- }
- if (h < 0) {
- h = -h;
- s->flags |= 1;
+ if (header) {
+ if (avctx->codec_tag == MKTAG('A', 'G', 'M', '0') ||
+ avctx->codec_tag == MKTAG('A', 'G', 'M', '1'))
+ return AVERROR_PATCHWELCOME;
+ else
+ ret = decode_huffman2(avctx, header, (avpkt->size - s->bitstream_size) - 8);
+ if (ret < 0)
+ return ret;
+ bytestream2_init(gbyte, s->output, s->output_size);
+ } else if (!s->dct) {
+ bytestream2_skip(gbyte, 4);
}
- width = avctx->width;
- height = avctx->height;
- if (w < width || h < height || w & 7 || h & 7)
- return AVERROR_INVALIDDATA;
+ if (s->dct) {
+ s->flags = 0;
+ w = bytestream2_get_le32(gbyte);
+ h = bytestream2_get_le32(gbyte);
+ if (w == INT32_MIN || h == INT32_MIN)
+ return AVERROR_INVALIDDATA;
+ if (w < 0) {
+ w = -w;
+ s->flags |= 2;
+ }
+ if (h < 0) {
+ h = -h;
+ s->flags |= 1;
+ }
- ret = ff_set_dimensions(avctx, w, h);
- if (ret < 0)
- return ret;
- avctx->width = width;
- avctx->height = height;
+ width = avctx->width;
+ height = avctx->height;
+ if (w < width || h < height || w & 7 || h & 7)
+ return AVERROR_INVALIDDATA;
- s->compression = bytestream2_get_le32(gbyte);
- if (s->compression < 0 || s->compression > 100)
- return AVERROR_INVALIDDATA;
+ ret = ff_set_dimensions(avctx, w, h);
+ if (ret < 0)
+ return ret;
+ avctx->width = width;
+ avctx->height = height;
- for (int i = 0; i < 3; i++)
- s->size[i] = bytestream2_get_le32(gbyte);
- if (s->size[0] < 0 || s->size[1] < 0 || s->size[2] < 0 ||
- 32LL + s->size[0] + s->size[1] + s->size[2] > avpkt->size)
- return AVERROR_INVALIDDATA;
+ s->compression = bytestream2_get_le32(gbyte);
+ if (s->compression < 0 || s->compression > 100)
+ return AVERROR_INVALIDDATA;
+
+ for (int i = 0; i < 3; i++)
+ s->size[i] = bytestream2_get_le32(gbyte);
+ if (header) {
+ compressed_size = s->output_size;
+ skip = 8LL;
+ } else {
+ compressed_size = avpkt->size;
+ skip = 32LL;
+ }
+ if (s->size[0] < 0 || s->size[1] < 0 || s->size[2] < 0 ||
+ skip + s->size[0] + s->size[1] + s->size[2] > compressed_size) {
+ return AVERROR_INVALIDDATA;
+ }
+ }
if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
return ret;
if (frame->key_frame) {
- ret = decode_intra(avctx, gb, frame);
+ if (!s->dct && !s->rgb)
+ ret = decode_raw_intra(avctx, gbyte, frame);
+ else if (!s->dct && s->rgb)
+ ret = decode_raw_intra_rgb(avctx, gbyte, frame);
+ else
+ ret = decode_intra(avctx, gb, frame);
} else {
- if (!s->prev_frame->data[0]) {
- av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
+ if (s->prev_frame-> width != frame->width ||
+ s->prev_frame->height != frame->height)
return AVERROR_INVALIDDATA;
- }
if (!(s->flags & 2)) {
ret = av_frame_copy(frame, s->prev_frame);
return ret;
}
- ret = decode_inter(avctx, gb, frame, s->prev_frame);
+ if (s->dct) {
+ ret = decode_inter(avctx, gb, frame, s->prev_frame);
+ } else if (!s->dct && !s->rgb) {
+ ret = decode_runlen(avctx, gbyte, frame);
+ } else {
+ ret = decode_runlen_rgb(avctx, gbyte, frame);
+ }
}
if (ret < 0)
return ret;
{
AGMContext *s = avctx->priv_data;
- avctx->pix_fmt = AV_PIX_FMT_YUV420P;
+ s->rgb = avctx->codec_tag == MKTAG('A', 'G', 'M', '4');
+ avctx->pix_fmt = s->rgb ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_YUV420P;
s->avctx = avctx;
- s->plus = avctx->codec_tag == MKTAG('A', 'G', 'M', '3');
+ s->plus = avctx->codec_tag == MKTAG('A', 'G', 'M', '3') ||
+ avctx->codec_tag == MKTAG('A', 'G', 'M', '7');
+
+ s->dct = avctx->codec_tag != MKTAG('A', 'G', 'M', '4') &&
+ avctx->codec_tag != MKTAG('A', 'G', 'M', '5');
+
+ if (!s->rgb && !s->dct) {
+ if ((avctx->width & 1) || (avctx->height & 1))
+ return AVERROR_INVALIDDATA;
+ }
avctx->idct_algo = FF_IDCT_SIMPLE;
ff_idctdsp_init(&s->idsp, avctx);
{
AGMContext *s = avctx->priv_data;
+ ff_free_vlc(&s->vlc);
av_frame_free(&s->prev_frame);
av_freep(&s->mvectors);
s->mvectors_size = 0;
+ av_freep(&s->wblocks);
+ s->wblocks_size = 0;
+ av_freep(&s->output);
+ s->padded_output_size = 0;
+ av_freep(&s->map);
+ s->map_size = 0;
return 0;
}
-AVCodec ff_agm_decoder = {
+const AVCodec ff_agm_decoder = {
.name = "agm",
.long_name = NULL_IF_CONFIG_SMALL("Amuse Graphics Movie"),
.type = AVMEDIA_TYPE_VIDEO,
projects / ffmpeg / blobdiff