Traneptora/FFmpeg
1
Fork 0
forked from FFmpeg/FFmpeg
Code Pull requests Activity

avcodec/asv: Split ASV1Context into decoder and encoder contexts

Browse source 
A lot of the stuff in ASV1Context is actually only used
by decoders or encoders, but not both: Of the seven contexts
in ASV1Context, only the BswapDSPContext is used by both.
So splitting makes sense.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
This commit is contained in:
Andreas Rheinhardt 2022-10-01 17:05:45 +02:00
parent bd3e552549
commit 8a9eac7e42
4 changed files with 93 additions and 78 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
libavcodec/asv.c
View file

@ -25,6 +25,8 @@
#include <stdint.h> #include <stdint.h>
#include "libavutil/attributes.h"
#include "asv.h" #include "asv.h"
#include "avcodec.h" #include "avcodec.h"
#include "bswapdsp.h" #include "bswapdsp.h"
@ -88,7 +90,7 @@ const uint16_t ff_asv2_level_tab[63][2] = {
av_cold void ff_asv_common_init(AVCodecContext *avctx) av_cold void ff_asv_common_init(AVCodecContext *avctx)
{ {
ASV1Context *const a = avctx->priv_data; ASVCommonContext *const a = avctx->priv_data;
ff_bswapdsp_init(&a->bbdsp); ff_bswapdsp_init(&a->bbdsp);

25
libavcodec/asv.h
View file

@ -28,38 +28,17 @@
#include <stdint.h> #include <stdint.h>
#include "libavutil/mem_internal.h"
#include "avcodec.h" #include "avcodec.h"
#include "blockdsp.h"
#include "bswapdsp.h" #include "bswapdsp.h"
#include "fdctdsp.h"
#include "idctdsp.h"
#include "get_bits.h"
#include "pixblockdsp.h"
#include "put_bits.h"
typedef struct ASV1Context { typedef struct ASVCommonContext {
AVCodecContext *avctx; AVCodecContext *avctx;
BlockDSPContext bdsp;
BswapDSPContext bbdsp; BswapDSPContext bbdsp;
FDCTDSPContext fdsp;
IDCTDSPContext idsp;
PixblockDSPContext pdsp;
PutBitContext pb;
GetBitContext gb;
ScanTable scantable;
int inv_qscale;
int mb_width; int mb_width;
int mb_height; int mb_height;
int mb_width2; int mb_width2;
int mb_height2; int mb_height2;
DECLARE_ALIGNED(32, int16_t, block)[6][64]; } ASVCommonContext;
uint16_t intra_matrix[64];
int q_intra_matrix[64];
uint8_t *bitstream_buffer;
unsigned int bitstream_buffer_size;
} ASV1Context;
extern const uint8_t ff_asv_scantab[64]; extern const uint8_t ff_asv_scantab[64];
extern const uint8_t ff_asv_ccp_tab[17][2]; extern const uint8_t ff_asv_ccp_tab[17][2];

73
libavcodec/asvdec.c
View file

@ -25,6 +25,7 @@
#include "libavutil/attributes.h" #include "libavutil/attributes.h"
#include "libavutil/mem.h" #include "libavutil/mem.h"
#include "libavutil/mem_internal.h"
#include "libavutil/thread.h" #include "libavutil/thread.h"
#include "asv.h" #include "asv.h"
@ -33,8 +34,10 @@
#include "codec_internal.h" #include "codec_internal.h"
#include "config_components.h" #include "config_components.h"
#include "decode.h" #include "decode.h"
#include "get_bits.h"
#include "idctdsp.h" #include "idctdsp.h"
#include "mpeg12data.h" #include "mpeg12data.h"
#include "vlc.h"
#define CCP_VLC_BITS 5 #define CCP_VLC_BITS 5
#define DC_CCP_VLC_BITS 4 #define DC_CCP_VLC_BITS 4
@ -48,6 +51,20 @@ static VLC dc_ccp_vlc;
static VLC ac_ccp_vlc; static VLC ac_ccp_vlc;
static VLC asv2_level_vlc; static VLC asv2_level_vlc;
typedef struct ASVDecContext {
ASVCommonContext c;
GetBitContext gb;
BlockDSPContext bdsp;
IDCTDSPContext idsp;
ScanTable scantable;
DECLARE_ALIGNED(32, int16_t, block)[6][64];
uint16_t intra_matrix[64];
uint8_t *bitstream_buffer;
unsigned int bitstream_buffer_size;
} ASVDecContext;
static av_cold void init_vlcs(void) static av_cold void init_vlcs(void)
{ {
INIT_VLC_STATIC(&ccp_vlc, CCP_VLC_BITS, 17, INIT_VLC_STATIC(&ccp_vlc, CCP_VLC_BITS, 17,
@ -106,7 +123,7 @@ static inline int asv2_get_level(GetBitContext *gb)
return code - 31; return code - 31;
} }
static inline int asv1_decode_block(ASV1Context *a, int16_t block[64]) static inline int asv1_decode_block(ASVDecContext *a, int16_t block[64])
{ {
int i; int i;
@ -119,7 +136,7 @@ static inline int asv1_decode_block(ASV1Context *a, int16_t block[64])
if (ccp == 16) if (ccp == 16)
break; break;
if (ccp < 0 || i >= 10) { if (ccp < 0 || i >= 10) {
av_log(a->avctx, AV_LOG_ERROR, "coded coeff pattern damaged\n"); av_log(a->c.avctx, AV_LOG_ERROR, "coded coeff pattern damaged\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
@ -137,7 +154,7 @@ static inline int asv1_decode_block(ASV1Context *a, int16_t block[64])
return 0; return 0;
} }
static inline int asv2_decode_block(ASV1Context *a, int16_t block[64]) static inline int asv2_decode_block(ASVDecContext *a, int16_t block[64])
{ {
int i, count, ccp; int i, count, ccp;
@ -173,13 +190,13 @@ static inline int asv2_decode_block(ASV1Context *a, int16_t block[64])
return 0; return 0;
} }
static inline int decode_mb(ASV1Context *a, int16_t block[6][64]) static inline int decode_mb(ASVDecContext *a, int16_t block[6][64])
{ {
int i, ret; int i, ret;
a->bdsp.clear_blocks(block[0]); a->bdsp.clear_blocks(block[0]);
if (a->avctx->codec_id == AV_CODEC_ID_ASV1) { if (a->c.avctx->codec_id == AV_CODEC_ID_ASV1) {
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
if ((ret = asv1_decode_block(a, block[i])) < 0) if ((ret = asv1_decode_block(a, block[i])) < 0)
return ret; return ret;
@ -193,7 +210,7 @@ static inline int decode_mb(ASV1Context *a, int16_t block[6][64])
return 0; return 0;
} }
static inline void idct_put(ASV1Context *a, AVFrame *frame, int mb_x, int mb_y) static inline void idct_put(ASVDecContext *a, AVFrame *frame, int mb_x, int mb_y)
{ {
int16_t(*block)[64] = a->block; int16_t(*block)[64] = a->block;
int linesize = frame->linesize[0]; int linesize = frame->linesize[0];
@ -207,7 +224,7 @@ static inline void idct_put(ASV1Context *a, AVFrame *frame, int mb_x, int mb_y)
a->idsp.idct_put(dest_y + 8 * linesize, linesize, block[2]); a->idsp.idct_put(dest_y + 8 * linesize, linesize, block[2]);
a->idsp.idct_put(dest_y + 8 * linesize + 8, linesize, block[3]); a->idsp.idct_put(dest_y + 8 * linesize + 8, linesize, block[3]);
if (!(a->avctx->flags & AV_CODEC_FLAG_GRAY)) { if (!(a->c.avctx->flags & AV_CODEC_FLAG_GRAY)) {
a->idsp.idct_put(dest_cb, frame->linesize[1], block[4]); a->idsp.idct_put(dest_cb, frame->linesize[1], block[4]);
a->idsp.idct_put(dest_cr, frame->linesize[2], block[5]); a->idsp.idct_put(dest_cr, frame->linesize[2], block[5]);
} }
@ -216,12 +233,13 @@ static inline void idct_put(ASV1Context *a, AVFrame *frame, int mb_x, int mb_y)
static int decode_frame(AVCodecContext *avctx, AVFrame *p, static int decode_frame(AVCodecContext *avctx, AVFrame *p,
int *got_frame, AVPacket *avpkt) int *got_frame, AVPacket *avpkt)
{ {
ASV1Context *const a = avctx->priv_data; ASVDecContext *const a = avctx->priv_data;
const ASVCommonContext *const c = &a->c;
const uint8_t *buf = avpkt->data; const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size; int buf_size = avpkt->size;
int mb_x, mb_y, ret; int ret;
if (buf_size * 8LL < a->mb_height * a->mb_width * 13LL) if (buf_size * 8LL < c->mb_height * c->mb_width * 13LL)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if ((ret = ff_get_buffer(avctx, p, 0)) < 0) if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
@ -235,7 +253,7 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *p,
if (!a->bitstream_buffer) if (!a->bitstream_buffer)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
a->bbdsp.bswap_buf((uint32_t *) a->bitstream_buffer, c->bbdsp.bswap_buf((uint32_t *) a->bitstream_buffer,
(const uint32_t *) buf, buf_size / 4); (const uint32_t *) buf, buf_size / 4);
ret = init_get_bits8(&a->gb, a->bitstream_buffer, buf_size); ret = init_get_bits8(&a->gb, a->bitstream_buffer, buf_size);
} else { } else {
@ -244,8 +262,8 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *p,
if (ret < 0) if (ret < 0)
return ret; return ret;
for (mb_y = 0; mb_y < a->mb_height2; mb_y++) { for (int mb_y = 0; mb_y < c->mb_height2; mb_y++) {
for (mb_x = 0; mb_x < a->mb_width2; mb_x++) { for (int mb_x = 0; mb_x < c->mb_width2; mb_x++) {
if ((ret = decode_mb(a, a->block)) < 0) if ((ret = decode_mb(a, a->block)) < 0)
return ret; return ret;
@ -253,9 +271,9 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *p,
} }
} }
if (a->mb_width2 != a->mb_width) { if (c->mb_width2 != c->mb_width) {
mb_x = a->mb_width2; int mb_x = c->mb_width2;
for (mb_y = 0; mb_y < a->mb_height2; mb_y++) { for (int mb_y = 0; mb_y < c->mb_height2; mb_y++) {
if ((ret = decode_mb(a, a->block)) < 0) if ((ret = decode_mb(a, a->block)) < 0)
return ret; return ret;
@ -263,9 +281,9 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *p,
} }
} }
if (a->mb_height2 != a->mb_height) { if (c->mb_height2 != c->mb_height) {
mb_y = a->mb_height2; int mb_y = c->mb_height2;
for (mb_x = 0; mb_x < a->mb_width; mb_x++) { for (int mb_x = 0; mb_x < c->mb_width; mb_x++) {
if ((ret = decode_mb(a, a->block)) < 0) if ((ret = decode_mb(a, a->block)) < 0)
return ret; return ret;
@ -283,8 +301,9 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *p,
static av_cold int decode_init(AVCodecContext *avctx) static av_cold int decode_init(AVCodecContext *avctx)
{ {
static AVOnce init_static_once = AV_ONCE_INIT; static AVOnce init_static_once = AV_ONCE_INIT;
ASV1Context *const a = avctx->priv_data; ASVDecContext *const a = avctx->priv_data;
const int scale = avctx->codec_id == AV_CODEC_ID_ASV1 ? 1 : 2; const int scale = avctx->codec_id == AV_CODEC_ID_ASV1 ? 1 : 2;
int inv_qscale;
int i; int i;
if (avctx->extradata_size < 1) { if (avctx->extradata_size < 1) {
@ -297,19 +316,19 @@ static av_cold int decode_init(AVCodecContext *avctx)
ff_init_scantable(a->idsp.idct_permutation, &a->scantable, ff_asv_scantab); ff_init_scantable(a->idsp.idct_permutation, &a->scantable, ff_asv_scantab);
avctx->pix_fmt = AV_PIX_FMT_YUV420P; avctx->pix_fmt = AV_PIX_FMT_YUV420P;
if (avctx->extradata_size < 1 || (a->inv_qscale = avctx->extradata[0]) == 0) { if (avctx->extradata_size < 1 || (inv_qscale = avctx->extradata[0]) == 0) {
av_log(avctx, AV_LOG_ERROR, "illegal qscale 0\n"); av_log(avctx, AV_LOG_ERROR, "illegal qscale 0\n");
if (avctx->codec_id == AV_CODEC_ID_ASV1) if (avctx->codec_id == AV_CODEC_ID_ASV1)
a->inv_qscale = 6; inv_qscale = 6;
else else
a->inv_qscale = 10; inv_qscale = 10;
} }
for (i = 0; i < 64; i++) { for (i = 0; i < 64; i++) {
int index = ff_asv_scantab[i]; int index = ff_asv_scantab[i];
a->intra_matrix[i] = 64 * scale * ff_mpeg1_default_intra_matrix[index] / a->intra_matrix[i] = 64 * scale * ff_mpeg1_default_intra_matrix[index] /
a->inv_qscale; inv_qscale;
} }
ff_thread_once(&init_static_once, init_vlcs); ff_thread_once(&init_static_once, init_vlcs);
@ -319,7 +338,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
static av_cold int decode_end(AVCodecContext *avctx) static av_cold int decode_end(AVCodecContext *avctx)
{ {
ASV1Context *const a = avctx->priv_data; ASVDecContext *const a = avctx->priv_data;
av_freep(&a->bitstream_buffer); av_freep(&a->bitstream_buffer);
a->bitstream_buffer_size = 0; a->bitstream_buffer_size = 0;
@ -333,7 +352,7 @@ const FFCodec ff_asv1_decoder = {
CODEC_LONG_NAME("ASUS V1"), CODEC_LONG_NAME("ASUS V1"),
.p.type = AVMEDIA_TYPE_VIDEO, .p.type = AVMEDIA_TYPE_VIDEO,
.p.id = AV_CODEC_ID_ASV1, .p.id = AV_CODEC_ID_ASV1,
.priv_data_size = sizeof(ASV1Context), .priv_data_size = sizeof(ASVDecContext),
.init = decode_init, .init = decode_init,
.close = decode_end, .close = decode_end,
FF_CODEC_DECODE_CB(decode_frame), FF_CODEC_DECODE_CB(decode_frame),
@ -347,7 +366,7 @@ const FFCodec ff_asv2_decoder = {
CODEC_LONG_NAME("ASUS V2"), CODEC_LONG_NAME("ASUS V2"),
.p.type = AVMEDIA_TYPE_VIDEO, .p.type = AVMEDIA_TYPE_VIDEO,
.p.id = AV_CODEC_ID_ASV2, .p.id = AV_CODEC_ID_ASV2,
.priv_data_size = sizeof(ASV1Context), .priv_data_size = sizeof(ASVDecContext),
.init = decode_init, .init = decode_init,
FF_CODEC_DECODE_CB(decode_frame), FF_CODEC_DECODE_CB(decode_frame),
.p.capabilities = AV_CODEC_CAP_DR1, .p.capabilities = AV_CODEC_CAP_DR1,

69
libavcodec/asvenc.c
View file

@ -27,6 +27,7 @@
#include "libavutil/attributes.h" #include "libavutil/attributes.h"
#include "libavutil/mem.h" #include "libavutil/mem.h"
#include "libavutil/mem_internal.h"
#include "aandcttab.h" #include "aandcttab.h"
#include "asv.h" #include "asv.h"
@ -36,6 +37,19 @@
#include "encode.h" #include "encode.h"
#include "fdctdsp.h" #include "fdctdsp.h"
#include "mpeg12data.h" #include "mpeg12data.h"
#include "pixblockdsp.h"
#include "put_bits.h"
typedef struct ASVEncContext {
ASVCommonContext c;
PutBitContext pb;
PixblockDSPContext pdsp;
FDCTDSPContext fdsp;
DECLARE_ALIGNED(32, int16_t, block)[6][64];
int q_intra_matrix[64];
} ASVEncContext;
static inline void asv1_put_level(PutBitContext *pb, int level) static inline void asv1_put_level(PutBitContext *pb, int level)
{ {
@ -49,7 +63,7 @@ static inline void asv1_put_level(PutBitContext *pb, int level)
} }
} }
static inline void asv2_put_level(ASV1Context *a, PutBitContext *pb, int level) static inline void asv2_put_level(ASVEncContext *a, PutBitContext *pb, int level)
{ {
unsigned int index = level + 31; unsigned int index = level + 31;
@ -58,14 +72,14 @@ static inline void asv2_put_level(ASV1Context *a, PutBitContext *pb, int level)
} else { } else {
put_bits_le(pb, 5, 0); /* Escape code */ put_bits_le(pb, 5, 0); /* Escape code */
if (level < -128 || level > 127) { if (level < -128 || level > 127) {
av_log(a->avctx, AV_LOG_WARNING, "Clipping level %d, increase qscale\n", level); av_log(a->c.avctx, AV_LOG_WARNING, "Clipping level %d, increase qscale\n", level);
level = av_clip_int8(level); level = av_clip_int8(level);
} }
put_bits_le(pb, 8, level & 0xFF); put_bits_le(pb, 8, level & 0xFF);
} }
} }
static inline void asv1_encode_block(ASV1Context *a, int16_t block[64]) static inline void asv1_encode_block(ASVEncContext *a, int16_t block[64])
{ {
int i; int i;
int nc_count = 0; int nc_count = 0;
@ -111,7 +125,7 @@ static inline void asv1_encode_block(ASV1Context *a, int16_t block[64])
put_bits(&a->pb, 5, 0xF); /* End of block */ put_bits(&a->pb, 5, 0xF); /* End of block */
} }
static inline void asv2_encode_block(ASV1Context *a, int16_t block[64]) static inline void asv2_encode_block(ASVEncContext *a, int16_t block[64])
{ {
int i; int i;
int count = 0; int count = 0;
@ -166,13 +180,13 @@ static inline void asv2_encode_block(ASV1Context *a, int16_t block[64])
#define MAX_MB_SIZE (30 * 16 * 16 * 3 / 2 / 8) #define MAX_MB_SIZE (30 * 16 * 16 * 3 / 2 / 8)
static inline int encode_mb(ASV1Context *a, int16_t block[6][64]) static inline int encode_mb(ASVEncContext *a, int16_t block[6][64])
{ {
int i; int i;
av_assert0(put_bytes_left(&a->pb, 0) >= MAX_MB_SIZE); av_assert0(put_bytes_left(&a->pb, 0) >= MAX_MB_SIZE);
if (a->avctx->codec_id == AV_CODEC_ID_ASV1) { if (a->c.avctx->codec_id == AV_CODEC_ID_ASV1) {
for (i = 0; i < 6; i++) for (i = 0; i < 6; i++)
asv1_encode_block(a, block[i]); asv1_encode_block(a, block[i]);
} else { } else {
@ -183,7 +197,7 @@ static inline int encode_mb(ASV1Context *a, int16_t block[6][64])
return 0; return 0;
} }
static inline void dct_get(ASV1Context *a, const AVFrame *frame, static inline void dct_get(ASVEncContext *a, const AVFrame *frame,
int mb_x, int mb_y) int mb_x, int mb_y)
{ {
int16_t (*block)[64] = a->block; int16_t (*block)[64] = a->block;
@ -201,7 +215,7 @@ static inline void dct_get(ASV1Context *a, const AVFrame *frame,
for (i = 0; i < 4; i++) for (i = 0; i < 4; i++)
a->fdsp.fdct(block[i]); a->fdsp.fdct(block[i]);
if (!(a->avctx->flags & AV_CODEC_FLAG_GRAY)) { if (!(a->c.avctx->flags & AV_CODEC_FLAG_GRAY)) {
a->pdsp.get_pixels(block[4], ptr_cb, frame->linesize[1]); a->pdsp.get_pixels(block[4], ptr_cb, frame->linesize[1]);
a->pdsp.get_pixels(block[5], ptr_cr, frame->linesize[2]); a->pdsp.get_pixels(block[5], ptr_cr, frame->linesize[2]);
for (i = 4; i < 6; i++) for (i = 4; i < 6; i++)
@ -212,9 +226,9 @@ static inline void dct_get(ASV1Context *a, const AVFrame *frame,
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *pict, int *got_packet) const AVFrame *pict, int *got_packet)
{ {
ASV1Context *const a = avctx->priv_data; ASVEncContext *const a = avctx->priv_data;
const ASVCommonContext *const c = &a->c;
int size, ret; int size, ret;
int mb_x, mb_y;
if (pict->width % 16 || pict->height % 16) { if (pict->width % 16 || pict->height % 16) {
AVFrame *clone = av_frame_alloc(); AVFrame *clone = av_frame_alloc();
@ -258,30 +272,30 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
return ret; return ret;
} }
if ((ret = ff_alloc_packet(avctx, pkt, a->mb_height * a->mb_width * MAX_MB_SIZE + if ((ret = ff_alloc_packet(avctx, pkt, c->mb_height * c->mb_width * MAX_MB_SIZE +
AV_INPUT_BUFFER_MIN_SIZE)) < 0) AV_INPUT_BUFFER_MIN_SIZE)) < 0)
return ret; return ret;
init_put_bits(&a->pb, pkt->data, pkt->size); init_put_bits(&a->pb, pkt->data, pkt->size);
for (mb_y = 0; mb_y < a->mb_height2; mb_y++) { for (int mb_y = 0; mb_y < c->mb_height2; mb_y++) {
for (mb_x = 0; mb_x < a->mb_width2; mb_x++) { for (int mb_x = 0; mb_x < c->mb_width2; mb_x++) {
dct_get(a, pict, mb_x, mb_y); dct_get(a, pict, mb_x, mb_y);
encode_mb(a, a->block); encode_mb(a, a->block);
} }
} }
if (a->mb_width2 != a->mb_width) { if (c->mb_width2 != c->mb_width) {
mb_x = a->mb_width2; int mb_x = c->mb_width2;
for (mb_y = 0; mb_y < a->mb_height2; mb_y++) { for (int mb_y = 0; mb_y < c->mb_height2; mb_y++) {
dct_get(a, pict, mb_x, mb_y); dct_get(a, pict, mb_x, mb_y);
encode_mb(a, a->block); encode_mb(a, a->block);
} }
} }
if (a->mb_height2 != a->mb_height) { if (c->mb_height2 != c->mb_height) {
mb_y = a->mb_height2; int mb_y = c->mb_height2;
for (mb_x = 0; mb_x < a->mb_width; mb_x++) { for (int mb_x = 0; mb_x < c->mb_width; mb_x++) {
dct_get(a, pict, mb_x, mb_y); dct_get(a, pict, mb_x, mb_y);
encode_mb(a, a->block); encode_mb(a, a->block);
} }
@ -296,7 +310,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
size = (put_bytes_output(&a->pb) + 3) / 4; size = (put_bytes_output(&a->pb) + 3) / 4;
if (avctx->codec_id == AV_CODEC_ID_ASV1) { if (avctx->codec_id == AV_CODEC_ID_ASV1) {
a->bbdsp.bswap_buf((uint32_t *) pkt->data, c->bbdsp.bswap_buf((uint32_t *) pkt->data,
(uint32_t *) pkt->data, size); (uint32_t *) pkt->data, size);
} }
@ -308,9 +322,10 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
static av_cold int encode_init(AVCodecContext *avctx) static av_cold int encode_init(AVCodecContext *avctx)
{ {
ASV1Context *const a = avctx->priv_data; ASVEncContext *const a = avctx->priv_data;
int i; int i;
const int scale = avctx->codec_id == AV_CODEC_ID_ASV1 ? 1 : 2; const int scale = avctx->codec_id == AV_CODEC_ID_ASV1 ? 1 : 2;
int inv_qscale;
ff_asv_common_init(avctx); ff_asv_common_init(avctx);
ff_fdctdsp_init(&a->fdsp, avctx); ff_fdctdsp_init(&a->fdsp, avctx);
@ -319,23 +334,23 @@ static av_cold int encode_init(AVCodecContext *avctx)
if (avctx->global_quality <= 0) if (avctx->global_quality <= 0)
avctx->global_quality = 4 * FF_QUALITY_SCALE; avctx->global_quality = 4 * FF_QUALITY_SCALE;
a->inv_qscale = (32 * scale * FF_QUALITY_SCALE + inv_qscale = (32 * scale * FF_QUALITY_SCALE +
avctx->global_quality / 2) / avctx->global_quality; avctx->global_quality / 2) / avctx->global_quality;
avctx->extradata = av_mallocz(8); avctx->extradata = av_mallocz(8);
if (!avctx->extradata) if (!avctx->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
avctx->extradata_size = 8; avctx->extradata_size = 8;
((uint32_t *) avctx->extradata)[0] = av_le2ne32(a->inv_qscale); AV_WLA(32, avctx->extradata, inv_qscale);
((uint32_t *) avctx->extradata)[1] = av_le2ne32(AV_RL32("ASUS")); ((uint32_t *) avctx->extradata)[1] = av_le2ne32(AV_RL32("ASUS"));
for (i = 0; i < 64; i++) { for (i = 0; i < 64; i++) {
if (a->fdsp.fdct == ff_fdct_ifast) { if (a->fdsp.fdct == ff_fdct_ifast) {
int q = 32LL * scale * ff_mpeg1_default_intra_matrix[i] * ff_aanscales[i]; int q = 32LL * scale * ff_mpeg1_default_intra_matrix[i] * ff_aanscales[i];
a->q_intra_matrix[i] = (((int64_t)a->inv_qscale << 30) + q / 2) / q; a->q_intra_matrix[i] = (((int64_t)inv_qscale << 30) + q / 2) / q;
} else { } else {
int q = 32 * scale * ff_mpeg1_default_intra_matrix[i]; int q = 32 * scale * ff_mpeg1_default_intra_matrix[i];
a->q_intra_matrix[i] = ((a->inv_qscale << 16) + q / 2) / q; a->q_intra_matrix[i] = ((inv_qscale << 16) + q / 2) / q;
} }
} }
@ -349,7 +364,7 @@ const FFCodec ff_asv1_encoder = {
.p.type = AVMEDIA_TYPE_VIDEO, .p.type = AVMEDIA_TYPE_VIDEO,
.p.id = AV_CODEC_ID_ASV1, .p.id = AV_CODEC_ID_ASV1,
.p.capabilities = AV_CODEC_CAP_DR1, .p.capabilities = AV_CODEC_CAP_DR1,
.priv_data_size = sizeof(ASV1Context), .priv_data_size = sizeof(ASVEncContext),
.init = encode_init, .init = encode_init,
FF_CODEC_ENCODE_CB(encode_frame), FF_CODEC_ENCODE_CB(encode_frame),
.p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P, .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
@ -364,7 +379,7 @@ const FFCodec ff_asv2_encoder = {
.p.type = AVMEDIA_TYPE_VIDEO, .p.type = AVMEDIA_TYPE_VIDEO,
.p.id = AV_CODEC_ID_ASV2, .p.id = AV_CODEC_ID_ASV2,
.p.capabilities = AV_CODEC_CAP_DR1, .p.capabilities = AV_CODEC_CAP_DR1,
.priv_data_size = sizeof(ASV1Context), .priv_data_size = sizeof(ASVEncContext),
.init = encode_init, .init = encode_init,
FF_CODEC_ENCODE_CB(encode_frame), FF_CODEC_ENCODE_CB(encode_frame),
.p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P, .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,