X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fagm.c;h=f60cbf1a187499c3efc8cf4c24688a68e0ddc5cf;hb=ed0001482a74b60f3d5bc5cd7e304c9d65b2fcd5;hp=b0e8b80f81d59f7953a2dc17fd6446aa5bcca130;hpb=4e8cbbf70e7a4ca3bb157f31c2f28e2365322b45;p=ffmpeg

diff --git a/libavcodec/agm.c b/libavcodec/agm.c
index b0e8b80f81d..f60cbf1a187 100644
--- a/libavcodec/agm.c
+++ b/libavcodec/agm.c
@@ -68,11 +68,19 @@ typedef struct AGMContext {
     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;
 
@@ -81,6 +89,13 @@ typedef struct AGMContext {
 
     ScanTable scantable;
     DECLARE_ALIGNED(32, int16_t, block)[64];
+
+    int16_t *wblocks;
+    unsigned wblocks_size;
+
+    int      *map;
+    unsigned  map_size;
+
     IDCTDSPContext idsp;
 } AGMContext;
 
@@ -88,6 +103,9 @@ static int read_code(GetBitContext *gb, int *oskip, int *level, int *map, int mo
 {
     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:
@@ -173,7 +191,84 @@ static int read_code(GetBitContext *gb, int *oskip, int *level, int *map, int mo
     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;
@@ -218,18 +313,38 @@ static int decode_intra_plane(AGMContext *s, GetBitContext *gb, int size,
                               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);
+            }
         }
     }
 
@@ -242,7 +357,7 @@ static int decode_intra_plane(AGMContext *s, GetBitContext *gb, int size,
     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)
 {
@@ -281,7 +396,54 @@ static int decode_inter_plane(AGMContext *s, GetBitContext *gb, int size,
     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;
@@ -293,13 +455,13 @@ static int decode_inter_plane(AGMContext *s, GetBitContext *gb, int size,
                 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,
@@ -318,12 +480,35 @@ static int decode_inter_plane(AGMContext *s, GetBitContext *gb, int size,
                 }
             }
         }
+    } 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;
 
@@ -383,6 +568,230 @@ static void compute_quant_matrix(AGMContext *s, double qscale)
     }
 }
 
+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;
@@ -421,7 +830,7 @@ static int decode_intra(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame
 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,
@@ -501,6 +910,187 @@ static int decode_inter(AVCodecContext *avctx, GetBitContext *gb,
     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)
 {
@@ -509,6 +1099,8 @@ static int decode_frame(AVCodecContext *avctx, void *data,
     GetByteContext *gbyte = &s->gbyte;
     AVFrame *frame = data;
     int w, h, width, height, header;
+    unsigned compressed_size;
+    long skip;
     int ret;
 
     if (!avpkt->size)
@@ -524,57 +1116,89 @@ static int decode_frame(AVCodecContext *avctx, void *data,
     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);
-    if (w < 0) {
-        w = -w;
-        s->flags |= 2;
-    }
-    h = bytestream2_get_le32(gbyte);
-    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 (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);
@@ -582,7 +1206,13 @@ static int decode_frame(AVCodecContext *avctx, void *data,
                 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;
@@ -603,9 +1233,19 @@ static av_cold int decode_init(AVCodecContext *avctx)
 {
     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);
@@ -629,9 +1269,16 @@ static av_cold int decode_close(AVCodecContext *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;
 }