git.sesse.net Git - ffmpeg/blob - libavcodec/agm.c

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