Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

asv: K&R formatting cosmetics

Browse Source 
Signed-off-by: Diego Biurrun <diego@biurrun.de>
pull/88/head
Gabriel Dume 10 years ago committed by Diego Biurrun
parent 74512f7e36
commit f61e47dd68
4 changed files with 210 additions and 173 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 77
      libavcodec/asv.c
  2. 2
      libavcodec/asv.h
  3. 55
      libavcodec/asvdec.c
  4. 249
      libavcodec/asvenc.c

77
libavcodec/asv.c
Unescape View File

@ -30,65 +30,66 @@
#include "bswapdsp.h" #include "bswapdsp.h"
const uint8_t ff_asv_scantab[64] = { const uint8_t ff_asv_scantab[64] = {
0x00,0x08,0x01,0x09,0x10,0x18,0x11,0x19, 0x00, 0x08, 0x01, 0x09, 0x10, 0x18, 0x11, 0x19,
0x02,0x0A,0x03,0x0B,0x12,0x1A,0x13,0x1B, 0x02, 0x0A, 0x03, 0x0B, 0x12, 0x1A, 0x13, 0x1B,
0x04,0x0C,0x05,0x0D,0x20,0x28,0x21,0x29, 0x04, 0x0C, 0x05, 0x0D, 0x20, 0x28, 0x21, 0x29,
0x06,0x0E,0x07,0x0F,0x14,0x1C,0x15,0x1D, 0x06, 0x0E, 0x07, 0x0F, 0x14, 0x1C, 0x15, 0x1D,
0x22,0x2A,0x23,0x2B,0x30,0x38,0x31,0x39, 0x22, 0x2A, 0x23, 0x2B, 0x30, 0x38, 0x31, 0x39,
0x16,0x1E,0x17,0x1F,0x24,0x2C,0x25,0x2D, 0x16, 0x1E, 0x17, 0x1F, 0x24, 0x2C, 0x25, 0x2D,
0x32,0x3A,0x33,0x3B,0x26,0x2E,0x27,0x2F, 0x32, 0x3A, 0x33, 0x3B, 0x26, 0x2E, 0x27, 0x2F,
0x34,0x3C,0x35,0x3D,0x36,0x3E,0x37,0x3F, 0x34, 0x3C, 0x35, 0x3D, 0x36, 0x3E, 0x37, 0x3F,
}; };
const uint8_t ff_asv_ccp_tab[17][2] = { const uint8_t ff_asv_ccp_tab[17][2] = {
{0x2,2}, {0x7,5}, {0xB,5}, {0x3,5}, { 0x2, 2 }, { 0x7, 5 }, { 0xB, 5 }, { 0x3, 5 },
{0xD,5}, {0x5,5}, {0x9,5}, {0x1,5}, { 0xD, 5 }, { 0x5, 5 }, { 0x9, 5 }, { 0x1, 5 },
{0xE,5}, {0x6,5}, {0xA,5}, {0x2,5}, { 0xE, 5 }, { 0x6, 5 }, { 0xA, 5 }, { 0x2, 5 },
{0xC,5}, {0x4,5}, {0x8,5}, {0x3,2}, { 0xC, 5 }, { 0x4, 5 }, { 0x8, 5 }, { 0x3, 2 },
{0xF,5}, //EOB { 0xF, 5 }, // EOB
}; };
const uint8_t ff_asv_level_tab[7][2] = { const uint8_t ff_asv_level_tab[7][2] = {
{3,4}, {3,3}, {3,2}, {0,3}, {2,2}, {2,3}, {2,4} { 3, 4 }, { 3, 3 }, { 3, 2 }, { 0, 3 }, { 2, 2 }, { 2, 3 }, { 2, 4 }
}; };
const uint8_t ff_asv_dc_ccp_tab[8][2] = { const uint8_t ff_asv_dc_ccp_tab[8][2] = {
{0x1,2}, {0xD,4}, {0xF,4}, {0xC,4}, { 0x1, 2 }, { 0xD, 4 }, { 0xF, 4 }, { 0xC, 4 },
{0x5,3}, {0xE,4}, {0x4,3}, {0x0,2}, { 0x5, 3 }, { 0xE, 4 }, { 0x4, 3 }, { 0x0, 2 },
}; };
const uint8_t ff_asv_ac_ccp_tab[16][2] = { const uint8_t ff_asv_ac_ccp_tab[16][2] = {
{0x00,2}, {0x3B,6}, {0x0A,4}, {0x3A,6}, { 0x00, 2 }, { 0x3B, 6 }, { 0x0A, 4 }, { 0x3A, 6 },
{0x02,3}, {0x39,6}, {0x3C,6}, {0x38,6}, { 0x02, 3 }, { 0x39, 6 }, { 0x3C, 6 }, { 0x38, 6 },
{0x03,3}, {0x3D,6}, {0x08,4}, {0x1F,5}, { 0x03, 3 }, { 0x3D, 6 }, { 0x08, 4 }, { 0x1F, 5 },
{0x09,4}, {0x0B,4}, {0x0D,4}, {0x0C,4}, { 0x09, 4 }, { 0x0B, 4 }, { 0x0D, 4 }, { 0x0C, 4 },
}; };
const uint8_t ff_asv2_level_tab[63][2] = { const uint8_t ff_asv2_level_tab[63][2] = {
{0x3F,10},{0x2F,10},{0x37,10},{0x27,10},{0x3B,10},{0x2B,10},{0x33,10},{0x23,10}, { 0x3F, 10 }, { 0x2F, 10 }, { 0x37, 10 }, { 0x27, 10 }, { 0x3B, 10 }, { 0x2B, 10 }, { 0x33, 10 }, { 0x23, 10 },
{0x3D,10},{0x2D,10},{0x35,10},{0x25,10},{0x39,10},{0x29,10},{0x31,10},{0x21,10}, { 0x3D, 10 }, { 0x2D, 10 }, { 0x35, 10 }, { 0x25, 10 }, { 0x39, 10 }, { 0x29, 10 }, { 0x31, 10 }, { 0x21, 10 },
{0x1F, 8},{0x17, 8},{0x1B, 8},{0x13, 8},{0x1D, 8},{0x15, 8},{0x19, 8},{0x11, 8}, { 0x1F, 8 }, { 0x17, 8 }, { 0x1B, 8 }, { 0x13, 8 }, { 0x1D, 8 }, { 0x15, 8 }, { 0x19, 8 }, { 0x11, 8 },
{0x0F, 6},{0x0B, 6},{0x0D, 6},{0x09, 6}, { 0x0F, 6 }, { 0x0B, 6 }, { 0x0D, 6 }, { 0x09, 6 },
{0x07, 4},{0x05, 4}, { 0x07, 4 }, { 0x05, 4 },
{0x03, 2}, { 0x03, 2 },
{0x00, 5}, { 0x00, 5 },
{0x02, 2}, { 0x02, 2 },
{0x04, 4},{0x06, 4}, { 0x04, 4 }, { 0x06, 4 },
{0x08, 6},{0x0C, 6},{0x0A, 6},{0x0E, 6}, { 0x08, 6 }, { 0x0C, 6 }, { 0x0A, 6 }, { 0x0E, 6 },
{0x10, 8},{0x18, 8},{0x14, 8},{0x1C, 8},{0x12, 8},{0x1A, 8},{0x16, 8},{0x1E, 8}, { 0x10, 8 }, { 0x18, 8 }, { 0x14, 8 }, { 0x1C, 8 }, { 0x12, 8 }, { 0x1A, 8 }, { 0x16, 8 }, { 0x1E, 8 },
{0x20,10},{0x30,10},{0x28,10},{0x38,10},{0x24,10},{0x34,10},{0x2C,10},{0x3C,10}, { 0x20, 10 }, { 0x30, 10 }, { 0x28, 10 }, { 0x38, 10 }, { 0x24, 10 }, { 0x34, 10 }, { 0x2C, 10 }, { 0x3C, 10 },
{0x22,10},{0x32,10},{0x2A,10},{0x3A,10},{0x26,10},{0x36,10},{0x2E,10},{0x3E,10}, { 0x22, 10 }, { 0x32, 10 }, { 0x2A, 10 }, { 0x3A, 10 }, { 0x26, 10 }, { 0x36, 10 }, { 0x2E, 10 }, { 0x3E, 10 },
}; };
av_cold void ff_asv_common_init(AVCodecContext *avctx) { av_cold void ff_asv_common_init(AVCodecContext *avctx)
ASV1Context * const a = avctx->priv_data; {
ASV1Context *const a = avctx->priv_data;
ff_bswapdsp_init(&a->bbdsp); ff_bswapdsp_init(&a->bbdsp);
a->mb_width = (avctx->width + 15) / 16; a->mb_width = (avctx->width + 15) / 16;
a->mb_height = (avctx->height + 15) / 16; a->mb_height = (avctx->height + 15) / 16;
a->mb_width2 = (avctx->width + 0) / 16; a->mb_width2 = (avctx->width + 0) / 16;
a->mb_height2 = (avctx->height + 0) / 16; a->mb_height2 = (avctx->height + 0) / 16;
a->avctx= avctx; a->avctx = avctx;
} }

2
libavcodec/asv.h
Unescape View File

@ -39,7 +39,7 @@
#include "pixblockdsp.h" #include "pixblockdsp.h"
#include "put_bits.h" #include "put_bits.h"
typedef struct ASV1Context{ typedef struct ASV1Context {
AVCodecContext *avctx; AVCodecContext *avctx;
BlockDSPContext bdsp; BlockDSPContext bdsp;
BswapDSPContext bbdsp; BswapDSPContext bbdsp;

55
libavcodec/asvdec.c
Unescape View File

@ -35,7 +35,7 @@
#include "mathops.h" #include "mathops.h"
#include "mpeg12data.h" #include "mpeg12data.h"
#define VLC_BITS 6 #define VLC_BITS 6
#define ASV2_LEVEL_VLC_BITS 10 #define ASV2_LEVEL_VLC_BITS 10
static VLC ccp_vlc; static VLC ccp_vlc;
@ -69,10 +69,10 @@ static av_cold void init_vlcs(ASV1Context *a)
} }
} }
//FIXME write a reversed bitstream reader to avoid the double reverse // FIXME write a reversed bitstream reader to avoid the double reverse
static inline int asv2_get_bits(GetBitContext *gb, int n) static inline int asv2_get_bits(GetBitContext *gb, int n)
{ {
return ff_reverse[get_bits(gb, n) << (8-n)]; return ff_reverse[get_bits(gb, n) << (8 - n)];
} }
static inline int asv1_get_level(GetBitContext *gb) static inline int asv1_get_level(GetBitContext *gb)
@ -90,7 +90,7 @@ static inline int asv2_get_level(GetBitContext *gb)
int code = get_vlc2(gb, asv2_level_vlc.table, ASV2_LEVEL_VLC_BITS, 1); int code = get_vlc2(gb, asv2_level_vlc.table, ASV2_LEVEL_VLC_BITS, 1);
if (code == 31) if (code == 31)
return (int8_t)asv2_get_bits(gb, 8); return (int8_t) asv2_get_bits(gb, 8);
else else
return code - 31; return code - 31;
} }
@ -149,13 +149,13 @@ static inline int asv2_decode_block(ASV1Context *a, int16_t block[64])
if (ccp) { if (ccp) {
if (ccp & 8) if (ccp & 8)
block[a->scantable.permutated[4*i + 0]] = (asv2_get_level(&a->gb) * a->intra_matrix[4*i + 0]) >> 4; block[a->scantable.permutated[4 * i + 0]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 0]) >> 4;
if (ccp & 4) if (ccp & 4)
block[a->scantable.permutated[4*i + 1]] = (asv2_get_level(&a->gb) * a->intra_matrix[4*i + 1]) >> 4; block[a->scantable.permutated[4 * i + 1]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 1]) >> 4;
if (ccp & 2) if (ccp & 2)
block[a->scantable.permutated[4*i + 2]] = (asv2_get_level(&a->gb) * a->intra_matrix[4*i + 2]) >> 4; block[a->scantable.permutated[4 * i + 2]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 2]) >> 4;
if (ccp & 1) if (ccp & 1)
block[a->scantable.permutated[4*i + 3]] = (asv2_get_level(&a->gb) * a->intra_matrix[4*i + 3]) >> 4; block[a->scantable.permutated[4 * i + 3]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 3]) >> 4;
} }
} }
@ -184,32 +184,31 @@ static inline int decode_mb(ASV1Context *a, int16_t block[6][64])
static inline void idct_put(ASV1Context *a, AVFrame *frame, int mb_x, int mb_y) static inline void idct_put(ASV1Context *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];
uint8_t *dest_y = frame->data[0] + (mb_y * 16* linesize ) + mb_x * 16; uint8_t *dest_y = frame->data[0] + (mb_y * 16 * linesize) + mb_x * 16;
uint8_t *dest_cb = frame->data[1] + (mb_y * 8 * frame->linesize[1]) + mb_x * 8; uint8_t *dest_cb = frame->data[1] + (mb_y * 8 * frame->linesize[1]) + mb_x * 8;
uint8_t *dest_cr = frame->data[2] + (mb_y * 8 * frame->linesize[2]) + mb_x * 8; uint8_t *dest_cr = frame->data[2] + (mb_y * 8 * frame->linesize[2]) + mb_x * 8;
a->idsp.idct_put(dest_y, linesize, block[0]); a->idsp.idct_put(dest_y, linesize, block[0]);
a->idsp.idct_put(dest_y + 8, linesize, block[1]); a->idsp.idct_put(dest_y + 8, linesize, block[1]);
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&CODEC_FLAG_GRAY)) { if (!(a->avctx->flags & 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]);
} }
} }
static int decode_frame(AVCodecContext *avctx, static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
void *data, int *got_frame,
AVPacket *avpkt) AVPacket *avpkt)
{ {
ASV1Context * const a = avctx->priv_data; ASV1Context *const a = avctx->priv_data;
const uint8_t *buf = avpkt->data; const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size; int buf_size = avpkt->size;
AVFrame * const p = data; AVFrame *const p = data;
int mb_x, mb_y, ret; int mb_x, mb_y, ret;
if ((ret = ff_get_buffer(avctx, p, 0)) < 0) { if ((ret = ff_get_buffer(avctx, p, 0)) < 0) {
@ -224,16 +223,16 @@ static int decode_frame(AVCodecContext *avctx,
if (!a->bitstream_buffer) if (!a->bitstream_buffer)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
if (avctx->codec_id == AV_CODEC_ID_ASV1) if (avctx->codec_id == AV_CODEC_ID_ASV1) {
a->bbdsp.bswap_buf((uint32_t *) a->bitstream_buffer, a->bbdsp.bswap_buf((uint32_t *) a->bitstream_buffer,
(const uint32_t *) buf, buf_size / 4); (const uint32_t *) buf, buf_size / 4);
else { } else {
int i; int i;
for (i = 0; i < buf_size; i++) for (i = 0; i < buf_size; i++)
a->bitstream_buffer[i] = ff_reverse[buf[i]]; a->bitstream_buffer[i] = ff_reverse[buf[i]];
} }
init_get_bits(&a->gb, a->bitstream_buffer, buf_size*8); init_get_bits(&a->gb, a->bitstream_buffer, buf_size * 8);
for (mb_y = 0; mb_y < a->mb_height2; mb_y++) { for (mb_y = 0; mb_y < a->mb_height2; mb_y++) {
for (mb_x = 0; mb_x < a->mb_width2; mb_x++) { for (mb_x = 0; mb_x < a->mb_width2; mb_x++) {
@ -273,8 +272,8 @@ static int decode_frame(AVCodecContext *avctx,
static av_cold int decode_init(AVCodecContext *avctx) static av_cold int decode_init(AVCodecContext *avctx)
{ {
ASV1Context * const a = avctx->priv_data; ASV1Context *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 i; int i;
if (avctx->extradata_size < 1) { if (avctx->extradata_size < 1) {
@ -301,7 +300,8 @@ static av_cold int decode_init(AVCodecContext *avctx)
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->inv_qscale; a->intra_matrix[i] = 64 * scale * ff_mpeg1_default_intra_matrix[index] /
a->inv_qscale;
} }
return 0; return 0;
@ -309,7 +309,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; ASV1Context *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;
@ -340,4 +340,3 @@ AVCodec ff_asv2_decoder = {
.decode = decode_frame, .decode = decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
}; };

249
libavcodec/asvenc.c
Unescape View File

@ -32,117 +32,150 @@
#include "mathops.h" #include "mathops.h"
#include "mpeg12data.h" #include "mpeg12data.h"
static inline void asv2_put_bits(PutBitContext *pb, int n, int v){ static inline void asv2_put_bits(PutBitContext *pb, int n, int v)
put_bits(pb, n, ff_reverse[ v << (8-n) ]); {
put_bits(pb, n, ff_reverse[v << (8 - n)]);
} }
static inline void asv1_put_level(PutBitContext *pb, int level){ static inline void asv1_put_level(PutBitContext *pb, int level)
unsigned int index= level + 3; {
unsigned int index = level + 3;
if(index <= 6) put_bits(pb, ff_asv_level_tab[index][1], ff_asv_level_tab[index][0]); if (index <= 6) {
else{ put_bits(pb, ff_asv_level_tab[index][1], ff_asv_level_tab[index][0]);
} else {
put_bits(pb, ff_asv_level_tab[3][1], ff_asv_level_tab[3][0]); put_bits(pb, ff_asv_level_tab[3][1], ff_asv_level_tab[3][0]);
put_sbits(pb, 8, level); put_sbits(pb, 8, level);
} }
} }
static inline void asv2_put_level(PutBitContext *pb, int level){ static inline void asv2_put_level(PutBitContext *pb, int level)
unsigned int index= level + 31; {
unsigned int index = level + 31;
if(index <= 62) put_bits(pb, ff_asv2_level_tab[index][1], ff_asv2_level_tab[index][0]); if (index <= 62) {
else{ put_bits(pb, ff_asv2_level_tab[index][1], ff_asv2_level_tab[index][0]);
} else {
put_bits(pb, ff_asv2_level_tab[31][1], ff_asv2_level_tab[31][0]); put_bits(pb, ff_asv2_level_tab[31][1], ff_asv2_level_tab[31][0]);
asv2_put_bits(pb, 8, level&0xFF); asv2_put_bits(pb, 8, level & 0xFF);
} }
} }
static inline void asv1_encode_block(ASV1Context *a, int16_t block[64]){ static inline void asv1_encode_block(ASV1Context *a, int16_t block[64])
{
int i; int i;
int nc_count=0; int nc_count = 0;
put_bits(&a->pb, 8, (block[0] + 32)>>6); put_bits(&a->pb, 8, (block[0] + 32) >> 6);
block[0]= 0; block[0] = 0;
for(i=0; i<10; i++){ for (i = 0; i < 10; i++) {
const int index = ff_asv_scantab[4*i]; const int index = ff_asv_scantab[4 * i];
int ccp=0; int ccp = 0;
if( (block[index + 0] = (block[index + 0]*a->q_intra_matrix[index + 0] + (1<<15))>>16) ) ccp |= 8; if ((block[index + 0] = (block[index + 0] *
if( (block[index + 8] = (block[index + 8]*a->q_intra_matrix[index + 8] + (1<<15))>>16) ) ccp |= 4; a->q_intra_matrix[index + 0] + (1 << 15)) >> 16))
if( (block[index + 1] = (block[index + 1]*a->q_intra_matrix[index + 1] + (1<<15))>>16) ) ccp |= 2; ccp |= 8;
if( (block[index + 9] = (block[index + 9]*a->q_intra_matrix[index + 9] + (1<<15))>>16) ) ccp |= 1; if ((block[index + 8] = (block[index + 8] *
a->q_intra_matrix[index + 8] + (1 << 15)) >> 16))
if(ccp){ ccp |= 4;
for(;nc_count; nc_count--) if ((block[index + 1] = (block[index + 1] *
a->q_intra_matrix[index + 1] + (1 << 15)) >> 16))
ccp |= 2;
if ((block[index + 9] = (block[index + 9] *
a->q_intra_matrix[index + 9] + (1 << 15)) >> 16))
ccp |= 1;
if (ccp) {
for (; nc_count; nc_count--)
put_bits(&a->pb, ff_asv_ccp_tab[0][1], ff_asv_ccp_tab[0][0]); put_bits(&a->pb, ff_asv_ccp_tab[0][1], ff_asv_ccp_tab[0][0]);
put_bits(&a->pb, ff_asv_ccp_tab[ccp][1], ff_asv_ccp_tab[ccp][0]); put_bits(&a->pb, ff_asv_ccp_tab[ccp][1], ff_asv_ccp_tab[ccp][0]);
if(ccp&8) asv1_put_level(&a->pb, block[index + 0]); if (ccp & 8)
if(ccp&4) asv1_put_level(&a->pb, block[index + 8]); asv1_put_level(&a->pb, block[index + 0]);
if(ccp&2) asv1_put_level(&a->pb, block[index + 1]); if (ccp & 4)
if(ccp&1) asv1_put_level(&a->pb, block[index + 9]); asv1_put_level(&a->pb, block[index + 8]);
}else{ if (ccp & 2)
asv1_put_level(&a->pb, block[index + 1]);
if (ccp & 1)
asv1_put_level(&a->pb, block[index + 9]);
} else {
nc_count++; nc_count++;
} }
} }
put_bits(&a->pb, ff_asv_ccp_tab[16][1], ff_asv_ccp_tab[16][0]); put_bits(&a->pb, ff_asv_ccp_tab[16][1], ff_asv_ccp_tab[16][0]);
} }
static inline void asv2_encode_block(ASV1Context *a, int16_t block[64]){ static inline void asv2_encode_block(ASV1Context *a, int16_t block[64])
{
int i; int i;
int count=0; int count = 0;
for(count=63; count>3; count--){ for (count = 63; count > 3; count--) {
const int index = ff_asv_scantab[count]; const int index = ff_asv_scantab[count];
if ((block[index] * a->q_intra_matrix[index] + (1 << 15)) >> 16)
if( (block[index]*a->q_intra_matrix[index] + (1<<15))>>16 )
break; break;
} }
count >>= 2; count >>= 2;
asv2_put_bits(&a->pb, 4, count); asv2_put_bits(&a->pb, 4, count);
asv2_put_bits(&a->pb, 8, (block[0] + 32)>>6); asv2_put_bits(&a->pb, 8, (block[0] + 32) >> 6);
block[0]= 0; block[0] = 0;
for(i=0; i<=count; i++){ for (i = 0; i <= count; i++) {
const int index = ff_asv_scantab[4*i]; const int index = ff_asv_scantab[4 * i];
int ccp=0; int ccp = 0;
if( (block[index + 0] = (block[index + 0]*a->q_intra_matrix[index + 0] + (1<<15))>>16) ) ccp |= 8; if ((block[index + 0] = (block[index + 0] *
if( (block[index + 8] = (block[index + 8]*a->q_intra_matrix[index + 8] + (1<<15))>>16) ) ccp |= 4; a->q_intra_matrix[index + 0] + (1 << 15)) >> 16))
if( (block[index + 1] = (block[index + 1]*a->q_intra_matrix[index + 1] + (1<<15))>>16) ) ccp |= 2; ccp |= 8;
if( (block[index + 9] = (block[index + 9]*a->q_intra_matrix[index + 9] + (1<<15))>>16) ) ccp |= 1; if ((block[index + 8] = (block[index + 8] *
a->q_intra_matrix[index + 8] + (1 << 15)) >> 16))
assert(i || ccp<8); ccp |= 4;
if(i) put_bits(&a->pb, ff_asv_ac_ccp_tab[ccp][1], ff_asv_ac_ccp_tab[ccp][0]); if ((block[index + 1] = (block[index + 1] *
else put_bits(&a->pb, ff_asv_dc_ccp_tab[ccp][1], ff_asv_dc_ccp_tab[ccp][0]); a->q_intra_matrix[index + 1] + (1 << 15)) >> 16))
ccp |= 2;
if(ccp){ if ((block[index + 9] = (block[index + 9] *
if(ccp&8) asv2_put_level(&a->pb, block[index + 0]); a->q_intra_matrix[index + 9] + (1 << 15)) >> 16))
if(ccp&4) asv2_put_level(&a->pb, block[index + 8]); ccp |= 1;
if(ccp&2) asv2_put_level(&a->pb, block[index + 1]);
if(ccp&1) asv2_put_level(&a->pb, block[index + 9]); assert(i || ccp < 8);
if (i)
put_bits(&a->pb, ff_asv_ac_ccp_tab[ccp][1], ff_asv_ac_ccp_tab[ccp][0]);
else
put_bits(&a->pb, ff_asv_dc_ccp_tab[ccp][1], ff_asv_dc_ccp_tab[ccp][0]);
if (ccp) {
if (ccp & 8)
asv2_put_level(&a->pb, block[index + 0]);
if (ccp & 4)
asv2_put_level(&a->pb, block[index + 8]);
if (ccp & 2)
asv2_put_level(&a->pb, block[index + 1]);
if (ccp & 1)
asv2_put_level(&a->pb, block[index + 9]);
} }
} }
} }
#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(ASV1Context *a, int16_t block[6][64])
{
int i; int i;
if (a->pb.buf_end - a->pb.buf - (put_bits_count(&a->pb)>>3) < MAX_MB_SIZE) { if (a->pb.buf_end - a->pb.buf - (put_bits_count(&a->pb) >> 3) < MAX_MB_SIZE) {
av_log(a->avctx, AV_LOG_ERROR, "encoded frame too large\n"); av_log(a->avctx, AV_LOG_ERROR, "encoded frame too large\n");
return -1; return -1;
} }
if(a->avctx->codec_id == AV_CODEC_ID_ASV1){ if (a->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 {
for(i=0; i<6; i++) for (i = 0; i < 6; i++)
asv2_encode_block(a, block[i]); asv2_encode_block(a, block[i]);
} }
return 0; return 0;
@ -151,25 +184,25 @@ static inline int encode_mb(ASV1Context *a, int16_t block[6][64]){
static inline void dct_get(ASV1Context *a, const AVFrame *frame, static inline void dct_get(ASV1Context *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;
int linesize = frame->linesize[0]; int linesize = frame->linesize[0];
int i; int i;
uint8_t *ptr_y = frame->data[0] + (mb_y * 16* linesize ) + mb_x * 16; uint8_t *ptr_y = frame->data[0] + (mb_y * 16 * linesize) + mb_x * 16;
uint8_t *ptr_cb = frame->data[1] + (mb_y * 8 * frame->linesize[1]) + mb_x * 8; uint8_t *ptr_cb = frame->data[1] + (mb_y * 8 * frame->linesize[1]) + mb_x * 8;
uint8_t *ptr_cr = frame->data[2] + (mb_y * 8 * frame->linesize[2]) + mb_x * 8; uint8_t *ptr_cr = frame->data[2] + (mb_y * 8 * frame->linesize[2]) + mb_x * 8;
a->pdsp.get_pixels(block[0], ptr_y, linesize); a->pdsp.get_pixels(block[0], ptr_y, linesize);
a->pdsp.get_pixels(block[1], ptr_y + 8, linesize); a->pdsp.get_pixels(block[1], ptr_y + 8, linesize);
a->pdsp.get_pixels(block[2], ptr_y + 8 * linesize, linesize); a->pdsp.get_pixels(block[2], ptr_y + 8 * linesize, linesize);
a->pdsp.get_pixels(block[3], ptr_y + 8 * linesize + 8, linesize); a->pdsp.get_pixels(block[3], ptr_y + 8 * linesize + 8, linesize);
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&CODEC_FLAG_GRAY)){ if (!(a->avctx->flags & 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++)
a->fdsp.fdct(block[i]); a->fdsp.fdct(block[i]);
} }
} }
@ -177,37 +210,37 @@ 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; ASV1Context *const a = avctx->priv_data;
int size, ret; int size, ret;
int mb_x, mb_y; int mb_x, mb_y;
if (!pkt->data && if (!pkt->data &&
(ret = av_new_packet(pkt, a->mb_height*a->mb_width*MAX_MB_SIZE + (ret = av_new_packet(pkt, a->mb_height * a->mb_width * MAX_MB_SIZE +
FF_MIN_BUFFER_SIZE)) < 0) { FF_MIN_BUFFER_SIZE)) < 0) {
av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n"); av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
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 (mb_y = 0; mb_y < a->mb_height2; mb_y++) {
for(mb_x=0; mb_x<a->mb_width2; mb_x++){ for (mb_x = 0; mb_x < a->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 (a->mb_width2 != a->mb_width) {
mb_x= a->mb_width2; mb_x = a->mb_width2;
for(mb_y=0; mb_y<a->mb_height2; mb_y++){ for (mb_y = 0; mb_y < a->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 (a->mb_height2 != a->mb_height) {
mb_y= a->mb_height2; mb_y = a->mb_height2;
for(mb_x=0; mb_x<a->mb_width; mb_x++){ for (mb_x = 0; mb_x < a->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);
} }
@ -215,31 +248,32 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
emms_c(); emms_c();
avpriv_align_put_bits(&a->pb); avpriv_align_put_bits(&a->pb);
while(put_bits_count(&a->pb)&31) while (put_bits_count(&a->pb) & 31)
put_bits(&a->pb, 8, 0); put_bits(&a->pb, 8, 0);
size= put_bits_count(&a->pb)/32; size = put_bits_count(&a->pb) / 32;
if(avctx->codec_id == AV_CODEC_ID_ASV1) if (avctx->codec_id == AV_CODEC_ID_ASV1) {
a->bbdsp.bswap_buf((uint32_t *) pkt->data, a->bbdsp.bswap_buf((uint32_t *) pkt->data,
(uint32_t *) pkt->data, size); (uint32_t *) pkt->data, size);
else{ } else {
int i; int i;
for(i=0; i<4*size; i++) for (i = 0; i < 4 * size; i++)
pkt->data[i] = ff_reverse[pkt->data[i]]; pkt->data[i] = ff_reverse[pkt->data[i]];
} }
pkt->size = size*4; pkt->size = size * 4;
pkt->flags |= AV_PKT_FLAG_KEY; pkt->flags |= AV_PKT_FLAG_KEY;
*got_packet = 1; *got_packet = 1;
return 0; return 0;
} }
static av_cold int encode_init(AVCodecContext *avctx){ static av_cold int encode_init(AVCodecContext *avctx)
ASV1Context * const a = avctx->priv_data; {
ASV1Context *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;
avctx->coded_frame = av_frame_alloc(); avctx->coded_frame = av_frame_alloc();
if (!avctx->coded_frame) if (!avctx->coded_frame)
@ -251,22 +285,25 @@ static av_cold int encode_init(AVCodecContext *avctx){
ff_fdctdsp_init(&a->fdsp, avctx); ff_fdctdsp_init(&a->fdsp, avctx);
ff_pixblockdsp_init(&a->pdsp, avctx); ff_pixblockdsp_init(&a->pdsp, avctx);
if(avctx->global_quality == 0) avctx->global_quality= 4*FF_QUALITY_SCALE; if (avctx->global_quality == 0)
avctx->global_quality = 4 * FF_QUALITY_SCALE;
a->inv_qscale= (32*scale*FF_QUALITY_SCALE + avctx->global_quality/2) / avctx->global_quality; a->inv_qscale = (32 * scale * FF_QUALITY_SCALE +
avctx->global_quality / 2) / avctx->global_quality;
avctx->extradata= av_mallocz(8); avctx->extradata = av_mallocz(8);
avctx->extradata_size=8; avctx->extradata_size = 8;
((uint32_t*)avctx->extradata)[0]= av_le2ne32(a->inv_qscale); ((uint32_t *) avctx->extradata)[0] = av_le2ne32(a->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++) {
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] = ((a->inv_qscale << 16) + q / 2) / q;
} }
return 0; return 0;
} }
static av_cold int asv_encode_close(AVCodecContext *avctx) static av_cold int asv_encode_close(AVCodecContext *avctx)
{ {
av_frame_free(&avctx->coded_frame); av_frame_free(&avctx->coded_frame);
@ -284,8 +321,8 @@ AVCodec ff_asv1_encoder = {
.init = encode_init, .init = encode_init,
.encode2 = encode_frame, .encode2 = encode_frame,
.close = asv_encode_close, .close = asv_encode_close,
.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
AV_PIX_FMT_NONE }, AV_PIX_FMT_NONE },
}; };
#endif #endif
@ -299,7 +336,7 @@ AVCodec ff_asv2_encoder = {
.init = encode_init, .init = encode_init,
.encode2 = encode_frame, .encode2 = encode_frame,
.close = asv_encode_close, .close = asv_encode_close,
.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
AV_PIX_FMT_NONE }, AV_PIX_FMT_NONE },
}; };
#endif #endif

Write Preview
Loading…
Cancel
Save