mirror of
https://github.com/FFmpeg/FFmpeg.git
synced 2025-01-08 13:22:53 +02:00
avcodec: add Argonaut Games Video decoder
This commit is contained in:
Paul B Mahol
parent
e575d59afe
commit
a3a6b56200
@ -29,6 +29,7 @@ version <next>:
|
||||
- aax demuxer
|
||||
- IPU decoder, parser and demuxer
|
||||
- Intel QSV-accelerated AV1 decoding
|
||||
- Argonaut Games Video decoder
|
||||
|
||||
|
||||
version 4.3:
|
||||
|
||||
@ -210,6 +210,7 @@ OBJS-$(CONFIG_APTX_HD_ENCODER) += aptxenc.o aptx.o
|
||||
OBJS-$(CONFIG_APNG_DECODER) += png.o pngdec.o pngdsp.o
|
||||
OBJS-$(CONFIG_APNG_ENCODER) += png.o pngenc.o
|
||||
OBJS-$(CONFIG_ARBC_DECODER) += arbc.o
|
||||
OBJS-$(CONFIG_ARGO_DECODER) += argo.o
|
||||
OBJS-$(CONFIG_SSA_DECODER) += assdec.o ass.o
|
||||
OBJS-$(CONFIG_SSA_ENCODER) += assenc.o ass.o
|
||||
OBJS-$(CONFIG_ASS_DECODER) += assdec.o ass.o
|
||||
|
||||
@ -43,6 +43,7 @@ extern AVCodec ff_ansi_decoder;
|
||||
extern AVCodec ff_apng_encoder;
|
||||
extern AVCodec ff_apng_decoder;
|
||||
extern AVCodec ff_arbc_decoder;
|
||||
extern AVCodec ff_argo_decoder;
|
||||
extern AVCodec ff_asv1_encoder;
|
||||
extern AVCodec ff_asv1_decoder;
|
||||
extern AVCodec ff_asv2_encoder;
|
||||
|
||||
740
libavcodec/argo.c
Normal file
740
libavcodec/argo.c
Normal file
@ -0,0 +1,740 @@
|
||||
/*
|
||||
* Argonaut Games Video decoder
|
||||
* Copyright (c) 2020 Paul B Mahol
|
||||
*
|
||||
* This file is part of FFmpeg.
|
||||
*
|
||||
* FFmpeg is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* FFmpeg is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with FFmpeg; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "libavutil/imgutils.h"
|
||||
#include "libavutil/internal.h"
|
||||
#include "libavutil/intreadwrite.h"
|
||||
#include "libavutil/mem.h"
|
||||
|
||||
#include "avcodec.h"
|
||||
#include "bytestream.h"
|
||||
#include "internal.h"
|
||||
|
||||
typedef struct ArgoContext {
|
||||
GetByteContext gb;
|
||||
|
||||
int bpp;
|
||||
int key;
|
||||
int mv0[128][2];
|
||||
int mv1[16][2];
|
||||
uint32_t pal[256];
|
||||
AVFrame *frame;
|
||||
} ArgoContext;
|
||||
|
||||
static int decode_pal8(AVCodecContext *avctx, uint32_t *pal)
|
||||
{
|
||||
ArgoContext *s = avctx->priv_data;
|
||||
GetByteContext *gb = &s->gb;
|
||||
int start, count;
|
||||
|
||||
start = bytestream2_get_le16(gb);
|
||||
count = bytestream2_get_le16(gb);
|
||||
|
||||
if (start + count > 256)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
if (bytestream2_get_bytes_left(gb) < 3 * count)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
pal[start + i] = (0xFF << 24U) | bytestream2_get_be24u(gb);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int decode_avcf(AVCodecContext *avctx, AVFrame *frame)
|
||||
{
|
||||
ArgoContext *s = avctx->priv_data;
|
||||
GetByteContext *gb = &s->gb;
|
||||
const int l = frame->linesize[0];
|
||||
const uint8_t *map = gb->buffer;
|
||||
uint8_t *dst = frame->data[0];
|
||||
|
||||
if (bytestream2_get_bytes_left(gb) < 1024 + (frame->width / 2) * (frame->height / 2))
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
bytestream2_skipu(gb, 1024);
|
||||
for (int y = 0; y < frame->height; y += 2) {
|
||||
for (int x = 0; x < frame->width; x += 2) {
|
||||
int index = bytestream2_get_byteu(gb);
|
||||
const uint8_t *block = map + index * 4;
|
||||
|
||||
dst[x+0] = block[0];
|
||||
dst[x+1] = block[1];
|
||||
dst[x+l] = block[2];
|
||||
dst[x+l+1] = block[3];
|
||||
}
|
||||
|
||||
dst += frame->linesize[0] * 2;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int decode_alcd(AVCodecContext *avctx, AVFrame *frame)
|
||||
{
|
||||
ArgoContext *s = avctx->priv_data;
|
||||
GetByteContext *gb = &s->gb;
|
||||
GetByteContext sb;
|
||||
const int l = frame->linesize[0];
|
||||
const uint8_t *map = gb->buffer;
|
||||
uint8_t *dst = frame->data[0];
|
||||
uint8_t codes = 0;
|
||||
int count = 0;
|
||||
|
||||
if (bytestream2_get_bytes_left(gb) < 1024 + (((frame->width / 2) * (frame->height / 2) + 7) >> 3))
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
bytestream2_skipu(gb, 1024);
|
||||
sb = *gb;
|
||||
bytestream2_skipu(gb, ((frame->width / 2) * (frame->height / 2) + 7) >> 3);
|
||||
|
||||
for (int y = 0; y < frame->height; y += 2) {
|
||||
for (int x = 0; x < frame->width; x += 2) {
|
||||
const uint8_t *block;
|
||||
int index;
|
||||
|
||||
if (count == 0) {
|
||||
codes = bytestream2_get_byteu(&sb);
|
||||
count = 8;
|
||||
}
|
||||
|
||||
if (codes & 0x80) {
|
||||
index = bytestream2_get_byte(gb);
|
||||
block = map + index * 4;
|
||||
|
||||
dst[x+0] = block[0];
|
||||
dst[x+1] = block[1];
|
||||
dst[x+l] = block[2];
|
||||
dst[x+l+1] = block[3];
|
||||
}
|
||||
|
||||
codes <<= 1;
|
||||
count--;
|
||||
}
|
||||
|
||||
dst += frame->linesize[0] * 2;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int decode_mad1(AVCodecContext *avctx, AVFrame *frame)
|
||||
{
|
||||
ArgoContext *s = avctx->priv_data;
|
||||
GetByteContext *gb = &s->gb;
|
||||
const int w = frame->width;
|
||||
const int h = frame->height;
|
||||
const int l = frame->linesize[0];
|
||||
|
||||
while (bytestream2_get_bytes_left(gb) > 0) {
|
||||
int size, type, pos, dy;
|
||||
uint8_t *dst;
|
||||
|
||||
type = bytestream2_get_byte(gb);
|
||||
if (type == 0xFF)
|
||||
break;
|
||||
|
||||
switch (type) {
|
||||
case 8:
|
||||
dst = frame->data[0];
|
||||
for (int y = 0; y < h; y += 8) {
|
||||
for (int x = 0; x < w; x += 8) {
|
||||
int fill = bytestream2_get_byte(gb);
|
||||
uint8_t *ddst = dst + x;
|
||||
|
||||
for (int by = 0; by < 8; by++) {
|
||||
memset(ddst, fill, 8);
|
||||
ddst += l;
|
||||
}
|
||||
}
|
||||
|
||||
dst += 8 * l;
|
||||
}
|
||||
break;
|
||||
case 7:
|
||||
while (bytestream2_get_bytes_left(gb) > 0) {
|
||||
int bsize = bytestream2_get_byte(gb);
|
||||
uint8_t *src;
|
||||
int count;
|
||||
|
||||
if (!bsize)
|
||||
break;
|
||||
|
||||
count = bytestream2_get_be16(gb);
|
||||
while (count > 0) {
|
||||
int mvx, mvy, a, b, c, mx, my;
|
||||
int bsize_w, bsize_h;
|
||||
|
||||
bsize_w = bsize_h = bsize;
|
||||
if (bytestream2_get_bytes_left(gb) < 4)
|
||||
return AVERROR_INVALIDDATA;
|
||||
mvx = bytestream2_get_byte(gb) * bsize;
|
||||
mvy = bytestream2_get_byte(gb) * bsize;
|
||||
a = bytestream2_get_byte(gb);
|
||||
b = bytestream2_get_byte(gb);
|
||||
c = ((a & 0x3F) << 8) + b;
|
||||
mx = mvx + (c & 0x7F) - 64;
|
||||
my = mvy + (c >> 7) - 64;
|
||||
|
||||
if (mvy < 0 || mvy >= h)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
if (mvx < 0 || mvx >= w)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
if (my < 0 || my >= h)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
if (mx < 0 || mx >= w)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
dst = frame->data[0] + mvx + l * mvy;
|
||||
src = frame->data[0] + mx + l * my;
|
||||
|
||||
bsize_w = FFMIN3(bsize_w, w - mvx, w - mx);
|
||||
bsize_h = FFMIN3(bsize_h, h - mvy, h - my);
|
||||
|
||||
if (mvy >= my && (mvy != my || mvx >= mx)) {
|
||||
src += (bsize_h - 1) * l;
|
||||
dst += (bsize_h - 1) * l;
|
||||
for (int by = 0; by < bsize_h; by++) {
|
||||
memmove(dst, src, bsize_w);
|
||||
src -= l;
|
||||
dst -= l;
|
||||
}
|
||||
} else {
|
||||
for (int by = 0; by < bsize_h; by++) {
|
||||
memmove(dst, src, bsize_w);
|
||||
src += l;
|
||||
dst += l;
|
||||
}
|
||||
}
|
||||
|
||||
count--;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 6:
|
||||
dst = frame->data[0];
|
||||
if (bytestream2_get_bytes_left(gb) < w * h)
|
||||
return AVERROR_INVALIDDATA;
|
||||
for (int y = 0; y < h; y++) {
|
||||
bytestream2_get_bufferu(gb, dst, w);
|
||||
dst += l;
|
||||
}
|
||||
break;
|
||||
case 5:
|
||||
dst = frame->data[0];
|
||||
for (int y = 0; y < h; y += 2) {
|
||||
for (int x = 0; x < w; x += 2) {
|
||||
int fill = bytestream2_get_byte(gb);
|
||||
uint8_t *ddst = dst + x;
|
||||
|
||||
fill = (fill << 8) | fill;
|
||||
for (int by = 0; by < 2; by++) {
|
||||
AV_WN16(ddst, fill);
|
||||
|
||||
ddst += l;
|
||||
}
|
||||
}
|
||||
|
||||
dst += 2 * l;
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
size = bytestream2_get_le16(gb);
|
||||
if (size > 0) {
|
||||
int x = bytestream2_get_byte(gb) * 4;
|
||||
int y = bytestream2_get_byte(gb) * 4;
|
||||
int count = bytestream2_get_byte(gb);
|
||||
int fill = bytestream2_get_byte(gb);
|
||||
|
||||
av_log(avctx, AV_LOG_DEBUG, "%d %d %d %d\n", x, y, count, fill);
|
||||
for (int i = 0; i < count; i++)
|
||||
;
|
||||
return AVERROR_PATCHWELCOME;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
dst = frame->data[0];
|
||||
pos = 0;
|
||||
dy = 0;
|
||||
while (bytestream2_get_bytes_left(gb) > 0) {
|
||||
int count = bytestream2_get_byteu(gb);
|
||||
int skip = count & 0x3F;
|
||||
|
||||
count = count >> 6;
|
||||
if (skip == 0x3F) {
|
||||
pos += 0x3E;
|
||||
while (pos >= w) {
|
||||
pos -= w;
|
||||
dst += l;
|
||||
dy++;
|
||||
if (dy >= h)
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
pos += skip;
|
||||
while (pos >= w) {
|
||||
pos -= w;
|
||||
dst += l;
|
||||
dy++;
|
||||
if (dy >= h)
|
||||
return 0;
|
||||
}
|
||||
while (count >= 0) {
|
||||
int bits = bytestream2_get_byte(gb);
|
||||
|
||||
for (int i = 0; i < 4; i++) {
|
||||
switch (bits & 3) {
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
if (dy < 1 && !pos)
|
||||
return AVERROR_INVALIDDATA;
|
||||
else
|
||||
dst[pos] = pos ? dst[pos - 1] : dst[-l + w - 1];
|
||||
break;
|
||||
case 2:
|
||||
if (dy < 1)
|
||||
return AVERROR_INVALIDDATA;
|
||||
dst[pos] = dst[pos - l];
|
||||
break;
|
||||
case 3:
|
||||
dst[pos] = bytestream2_get_byte(gb);
|
||||
break;
|
||||
}
|
||||
|
||||
pos++;
|
||||
if (pos >= w) {
|
||||
pos -= w;
|
||||
dst += l;
|
||||
dy++;
|
||||
if (dy >= h)
|
||||
return 0;
|
||||
}
|
||||
bits >>= 2;
|
||||
}
|
||||
count--;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int decode_mad1_24(AVCodecContext *avctx, AVFrame *frame)
|
||||
{
|
||||
ArgoContext *s = avctx->priv_data;
|
||||
GetByteContext *gb = &s->gb;
|
||||
const int w = frame->width;
|
||||
const int h = frame->height;
|
||||
const int l = frame->linesize[0] / 4;
|
||||
|
||||
while (bytestream2_get_bytes_left(gb) > 0) {
|
||||
int osize, type, pos, dy, di, bcode, value, v14;
|
||||
const uint8_t *bits;
|
||||
uint32_t *dst;
|
||||
|
||||
type = bytestream2_get_byte(gb);
|
||||
if (type == 0xFF)
|
||||
return 0;
|
||||
|
||||
switch (type) {
|
||||
case 8:
|
||||
dst = (uint32_t *)frame->data[0];
|
||||
for (int y = 0; y + 12 <= h; y += 12) {
|
||||
for (int x = 0; x + 12 <= w; x += 12) {
|
||||
int fill = bytestream2_get_be24(gb);
|
||||
uint32_t *dstp = dst + x;
|
||||
|
||||
for (int by = 0; by < 12; by++) {
|
||||
for (int bx = 0; bx < 12; bx++)
|
||||
dstp[bx] = fill;
|
||||
|
||||
dstp += l;
|
||||
}
|
||||
}
|
||||
|
||||
dst += 12 * l;
|
||||
}
|
||||
break;
|
||||
case 7:
|
||||
while (bytestream2_get_bytes_left(gb) > 0) {
|
||||
int bsize = bytestream2_get_byte(gb);
|
||||
uint32_t *src;
|
||||
int count;
|
||||
|
||||
if (!bsize)
|
||||
break;
|
||||
|
||||
count = bytestream2_get_be16(gb);
|
||||
while (count > 0) {
|
||||
int mvx, mvy, a, b, c, mx, my;
|
||||
int bsize_w, bsize_h;
|
||||
|
||||
bsize_w = bsize_h = bsize;
|
||||
if (bytestream2_get_bytes_left(gb) < 4)
|
||||
return AVERROR_INVALIDDATA;
|
||||
mvx = bytestream2_get_byte(gb) * bsize;
|
||||
mvy = bytestream2_get_byte(gb) * bsize;
|
||||
a = bytestream2_get_byte(gb);
|
||||
b = bytestream2_get_byte(gb);
|
||||
c = ((a & 0x3F) << 8) + b;
|
||||
mx = mvx + (c & 0x7F) - 64;
|
||||
my = mvy + (c >> 7) - 64;
|
||||
|
||||
if (mvy < 0 || mvy >= h)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
if (mvx < 0 || mvx >= w)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
if (my < 0 || my >= h)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
if (mx < 0 || mx >= w)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
dst = (uint32_t *)frame->data[0] + mvx + l * mvy;
|
||||
src = (uint32_t *)frame->data[0] + mx + l * my;
|
||||
|
||||
bsize_w = FFMIN3(bsize_w, w - mvx, w - mx);
|
||||
bsize_h = FFMIN3(bsize_h, h - mvy, h - my);
|
||||
|
||||
if (mvy >= my && (mvy != my || mvx >= mx)) {
|
||||
src += (bsize_h - 1) * l;
|
||||
dst += (bsize_h - 1) * l;
|
||||
for (int by = 0; by < bsize_h; by++) {
|
||||
memmove(dst, src, bsize_w * 4);
|
||||
src -= l;
|
||||
dst -= l;
|
||||
}
|
||||
} else {
|
||||
for (int by = 0; by < bsize_h; by++) {
|
||||
memmove(dst, src, bsize_w * 4);
|
||||
src += l;
|
||||
dst += l;
|
||||
}
|
||||
}
|
||||
|
||||
count--;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 12:
|
||||
osize = ((h + 3) / 4) * ((w + 3) / 4) + 7;
|
||||
bits = gb->buffer;
|
||||
di = 0;
|
||||
bcode = v14 = 0;
|
||||
if (bytestream2_get_bytes_left(gb) < osize >> 3)
|
||||
return AVERROR_INVALIDDATA;
|
||||
bytestream2_skip(gb, osize >> 3);
|
||||
for (int x = 0; x < w; x += 4) {
|
||||
for (int y = 0; y < h; y += 4) {
|
||||
int astate = 0;
|
||||
|
||||
if (bits[di >> 3] & (1 << (di & 7))) {
|
||||
int codes = bytestream2_get_byte(gb);
|
||||
|
||||
for (int count = 0; count < 4; count++) {
|
||||
uint32_t *src = (uint32_t *)frame->data[0];
|
||||
size_t src_size = l * (h - 1) + (w - 1);
|
||||
int nv, v, code = codes & 3;
|
||||
|
||||
pos = x;
|
||||
dy = y + count;
|
||||
dst = (uint32_t *)frame->data[0] + pos + dy * l;
|
||||
if (code & 1)
|
||||
bcode = bytestream2_get_byte(gb);
|
||||
if (code == 3) {
|
||||
for (int j = 0; j < 4; j++) {
|
||||
switch (bcode & 3) {
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
if (dy < 1 && !pos)
|
||||
return AVERROR_INVALIDDATA;
|
||||
dst[0] = dst[-1];
|
||||
break;
|
||||
case 2:
|
||||
if (dy < 1)
|
||||
return AVERROR_INVALIDDATA;
|
||||
dst[0] = dst[-l];
|
||||
break;
|
||||
case 3:
|
||||
if (astate) {
|
||||
nv = value >> 4;
|
||||
} else {
|
||||
value = bytestream2_get_byte(gb);
|
||||
nv = value & 0xF;
|
||||
}
|
||||
astate ^= 1;
|
||||
dst[0] = src[av_clip(l * (dy + s->mv1[nv][1]) + pos +
|
||||
s->mv1[nv][0], 0, src_size)];
|
||||
break;
|
||||
}
|
||||
|
||||
bcode >>= 2;
|
||||
dst++;
|
||||
pos++;
|
||||
}
|
||||
} else if (code) {
|
||||
if (code == 1)
|
||||
v14 = bcode;
|
||||
else
|
||||
bcode = v14;
|
||||
for (int j = 0; j < 4; j++) {
|
||||
switch (bcode & 3) {
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
if (dy < 1 && !pos)
|
||||
return AVERROR_INVALIDDATA;
|
||||
dst[0] = dst[-1];
|
||||
break;
|
||||
case 2:
|
||||
if (dy < 1)
|
||||
return AVERROR_INVALIDDATA;
|
||||
dst[0] = dst[-l];
|
||||
break;
|
||||
case 3:
|
||||
v = bytestream2_get_byte(gb);
|
||||
if (v < 128) {
|
||||
dst[0] = src[av_clip(l * (dy + s->mv0[v][1]) + pos +
|
||||
s->mv0[v][0], 0, src_size)];
|
||||
} else {
|
||||
dst[0] = ((v & 0x7F) << 17) | bytestream2_get_be16(gb);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
bcode >>= 2;
|
||||
dst++;
|
||||
pos++;
|
||||
}
|
||||
}
|
||||
|
||||
codes >>= 2;
|
||||
}
|
||||
}
|
||||
|
||||
di++;
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
}
|
||||
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
|
||||
static int decode_rle(AVCodecContext *avctx, AVFrame *frame)
|
||||
{
|
||||
ArgoContext *s = avctx->priv_data;
|
||||
GetByteContext *gb = &s->gb;
|
||||
const int w = frame->width;
|
||||
const int h = frame->height;
|
||||
const int l = frame->linesize[0] / 4;
|
||||
uint8_t *dst = frame->data[0];
|
||||
int pos = 0, y = 0;
|
||||
|
||||
while (bytestream2_get_bytes_left(gb) > 0) {
|
||||
int count = bytestream2_get_byte(gb);
|
||||
int pixel = bytestream2_get_byte(gb);
|
||||
|
||||
if (!count) {
|
||||
pos += pixel;
|
||||
while (pos >= w) {
|
||||
pos -= w;
|
||||
y++;
|
||||
if (y >= h)
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
while (count > 0) {
|
||||
dst[pos + y * l] = pixel;
|
||||
count--;
|
||||
pos++;
|
||||
if (pos >= w) {
|
||||
pos = 0;
|
||||
y++;
|
||||
if (y >= h)
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int decode_frame(AVCodecContext *avctx, void *data,
|
||||
int *got_frame, AVPacket *avpkt)
|
||||
{
|
||||
ArgoContext *s = avctx->priv_data;
|
||||
GetByteContext *gb = &s->gb;
|
||||
AVFrame *frame = s->frame;
|
||||
uint32_t chunk;
|
||||
int ret;
|
||||
|
||||
bytestream2_init(gb, avpkt->data, avpkt->size);
|
||||
|
||||
if ((ret = ff_reget_buffer(avctx, frame, 0)) < 0)
|
||||
return ret;
|
||||
|
||||
chunk = bytestream2_get_be32(gb);
|
||||
switch (chunk) {
|
||||
case MKBETAG('P', 'A', 'L', '8'):
|
||||
for (int y = 0; y < frame->height; y++)
|
||||
memset(frame->data[0] + y * frame->linesize[0], 0, frame->width * s->bpp);
|
||||
if (avctx->pix_fmt == AV_PIX_FMT_PAL8)
|
||||
memset(frame->data[1], 0, AVPALETTE_SIZE);
|
||||
return decode_pal8(avctx, s->pal);
|
||||
case MKBETAG('M', 'A', 'D', '1'):
|
||||
if (avctx->pix_fmt == AV_PIX_FMT_PAL8)
|
||||
ret = decode_mad1(avctx, frame);
|
||||
else
|
||||
ret = decode_mad1_24(avctx, frame);
|
||||
break;
|
||||
case MKBETAG('A', 'V', 'C', 'F'):
|
||||
if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
|
||||
s->key = 1;
|
||||
ret = decode_avcf(avctx, frame);
|
||||
break;
|
||||
}
|
||||
case MKBETAG('A', 'L', 'C', 'D'):
|
||||
if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
|
||||
s->key = 0;
|
||||
ret = decode_alcd(avctx, frame);
|
||||
break;
|
||||
}
|
||||
case MKBETAG('R', 'L', 'E', 'F'):
|
||||
if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
|
||||
s->key = 1;
|
||||
ret = decode_rle(avctx, frame);
|
||||
break;
|
||||
}
|
||||
case MKBETAG('R', 'L', 'E', 'D'):
|
||||
if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
|
||||
s->key = 0;
|
||||
ret = decode_rle(avctx, frame);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
av_log(avctx, AV_LOG_DEBUG, "unknown chunk 0x%X\n", chunk);
|
||||
break;
|
||||
}
|
||||
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
if (avctx->pix_fmt == AV_PIX_FMT_PAL8)
|
||||
memcpy(frame->data[1], s->pal, AVPALETTE_SIZE);
|
||||
|
||||
if ((ret = av_frame_ref(data, s->frame)) < 0)
|
||||
return ret;
|
||||
|
||||
frame->pict_type = s->key ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
|
||||
frame->key_frame = s->key;
|
||||
*got_frame = 1;
|
||||
|
||||
return avpkt->size;
|
||||
}
|
||||
|
||||
static av_cold int decode_init(AVCodecContext *avctx)
|
||||
{
|
||||
ArgoContext *s = avctx->priv_data;
|
||||
|
||||
switch (avctx->bits_per_raw_sample) {
|
||||
case 8: s->bpp = 1;
|
||||
avctx->pix_fmt = AV_PIX_FMT_PAL8; break;
|
||||
case 24: s->bpp = 4;
|
||||
avctx->pix_fmt = AV_PIX_FMT_BGR0; break;
|
||||
default: avpriv_request_sample(s, "depth == %u", avctx->bits_per_raw_sample);
|
||||
return AVERROR_PATCHWELCOME;
|
||||
}
|
||||
|
||||
s->frame = av_frame_alloc();
|
||||
if (!s->frame)
|
||||
return AVERROR(ENOMEM);
|
||||
|
||||
for (int n = 0, i = -4; i < 4; i++) {
|
||||
for (int j = -14; j < 2; j++) {
|
||||
s->mv0[n][0] = j;
|
||||
s->mv0[n++][1] = i;
|
||||
}
|
||||
}
|
||||
|
||||
for (int n = 0, i = -5; i <= 1; i += 2) {
|
||||
int j = -5;
|
||||
|
||||
while (j <= 1) {
|
||||
s->mv1[n][0] = j;
|
||||
s->mv1[n++][1] = i;
|
||||
j += 2;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void decode_flush(AVCodecContext *avctx)
|
||||
{
|
||||
ArgoContext *s = avctx->priv_data;
|
||||
|
||||
av_frame_unref(s->frame);
|
||||
}
|
||||
|
||||
static av_cold int decode_close(AVCodecContext *avctx)
|
||||
{
|
||||
ArgoContext *s = avctx->priv_data;
|
||||
|
||||
av_frame_free(&s->frame);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
AVCodec ff_argo_decoder = {
|
||||
.name = "argo",
|
||||
.long_name = NULL_IF_CONFIG_SMALL("Argonaut Games Video"),
|
||||
.type = AVMEDIA_TYPE_VIDEO,
|
||||
.id = AV_CODEC_ID_ARGO,
|
||||
.priv_data_size = sizeof(ArgoContext),
|
||||
.init = decode_init,
|
||||
.decode = decode_frame,
|
||||
.flush = decode_flush,
|
||||
.close = decode_close,
|
||||
.capabilities = AV_CODEC_CAP_DR1,
|
||||
.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
|
||||
};
|
||||
@ -1805,6 +1805,13 @@ static const AVCodecDescriptor codec_descriptors[] = {
|
||||
.long_name = NULL_IF_CONFIG_SMALL("IPU Video"),
|
||||
.props = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSY,
|
||||
},
|
||||
{
|
||||
.id = AV_CODEC_ID_ARGO,
|
||||
.type = AVMEDIA_TYPE_VIDEO,
|
||||
.name = "argo",
|
||||
.long_name = NULL_IF_CONFIG_SMALL("Argonaut Games Video"),
|
||||
.props = AV_CODEC_PROP_LOSSY,
|
||||
},
|
||||
|
||||
/* various PCM "codecs" */
|
||||
{
|
||||
|
||||
@ -299,6 +299,7 @@ enum AVCodecID {
|
||||
AV_CODEC_ID_MOBICLIP,
|
||||
AV_CODEC_ID_PHOTOCD,
|
||||
AV_CODEC_ID_IPU,
|
||||
AV_CODEC_ID_ARGO,
|
||||
|
||||
/* various PCM "codecs" */
|
||||
AV_CODEC_ID_FIRST_AUDIO = 0x10000, ///< A dummy id pointing at the start of audio codecs
|
||||
|
||||
@ -28,7 +28,7 @@
|
||||
#include "libavutil/version.h"
|
||||
|
||||
#define LIBAVCODEC_VERSION_MAJOR 58
|
||||
#define LIBAVCODEC_VERSION_MINOR 107
|
||||
#define LIBAVCODEC_VERSION_MINOR 108
|
||||
#define LIBAVCODEC_VERSION_MICRO 100
|
||||
|
||||
#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
|
||||
|
||||
@ -211,9 +211,7 @@ static int argo_brp_read_header(AVFormatContext *s)
|
||||
ArgoBVIDHeader *bvid = &hdr->extradata.bvid;
|
||||
|
||||
st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
|
||||
|
||||
/* No decoder for this yet. */
|
||||
st->codecpar->codec_id = AV_CODEC_ID_NONE;
|
||||
st->codecpar->codec_id = AV_CODEC_ID_ARGO;
|
||||
|
||||
bvid->num_frames = AV_RL32(buf + 0);
|
||||
bvid->width = AV_RL32(buf + 4);
|
||||
@ -228,17 +226,8 @@ static int argo_brp_read_header(AVFormatContext *s)
|
||||
|
||||
st->codecpar->width = bvid->width;
|
||||
st->codecpar->height = bvid->height;
|
||||
|
||||
if (bvid->depth == 8) {
|
||||
st->codecpar->format = AV_PIX_FMT_PAL8;
|
||||
} else if (bvid->depth == 24) {
|
||||
st->codecpar->format = AV_PIX_FMT_RGB24;
|
||||
} else {
|
||||
avpriv_request_sample(s, "depth == %u", bvid->depth);
|
||||
return AVERROR_PATCHWELCOME;
|
||||
}
|
||||
|
||||
st->nb_frames = bvid->num_frames;
|
||||
st->codecpar->bits_per_raw_sample = bvid->depth;
|
||||
} else if (hdr->codec_id == BRP_CODEC_ID_BASF) {
|
||||
/*
|
||||
* It would make the demuxer significantly more complicated
|
||||
|
||||
Loading…
Reference in New Issue
Block a user