xenia-project/FFmpeg
1
0
Fork 0
mirror of https://github.com/xenia-project/FFmpeg.git synced 2024-11-24 03:59:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

bink: make IDCT take 32-bit input

Browse Source 
Since IDCT transforming 32-bit input to 8-bit output is unusual and unpractical
for most codecs, move Bink IDCT into separate context. Get rid of an additional
permutation table while at it since SIMD support for Bink IDCT is unlikely to
be implemented in foreseeable future.
Quantisation tables also have to change type to signed for proper
dequantisation of DCT coefficients.

Signed-off-by: Mans Rullgard <mans@mansr.com>
This commit is contained in:
Kostya Shishkov 2011-07-23 15:46:35 +02:00 committed by Mans Rullgard
parent 001e600c3b
commit 2968bedf12
6 changed files with 86 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libavcodec/Makefile
View File

@ -89,7 +89,7 @@ OBJS-$(CONFIG_AURA2_DECODER) += aura.o
OBJS-$(CONFIG_AVS_DECODER) += avs.o OBJS-$(CONFIG_AVS_DECODER) += avs.o
OBJS-$(CONFIG_BETHSOFTVID_DECODER) += bethsoftvideo.o OBJS-$(CONFIG_BETHSOFTVID_DECODER) += bethsoftvideo.o
OBJS-$(CONFIG_BFI_DECODER) += bfi.o OBJS-$(CONFIG_BFI_DECODER) += bfi.o
OBJS-$(CONFIG_BINK_DECODER) += bink.o binkidct.o OBJS-$(CONFIG_BINK_DECODER) += bink.o binkdsp.o
OBJS-$(CONFIG_BINKAUDIO_DCT_DECODER) += binkaudio.o wma.o OBJS-$(CONFIG_BINKAUDIO_DCT_DECODER) += binkaudio.o wma.o
OBJS-$(CONFIG_BINKAUDIO_RDFT_DECODER) += binkaudio.o wma.o OBJS-$(CONFIG_BINKAUDIO_RDFT_DECODER) += binkaudio.o wma.o
OBJS-$(CONFIG_BMP_DECODER) += bmp.o msrledec.o OBJS-$(CONFIG_BMP_DECODER) += bmp.o msrledec.o

58
libavcodec/bink.c
View File

@ -24,6 +24,7 @@
#include "avcodec.h" #include "avcodec.h"
#include "dsputil.h" #include "dsputil.h"
#include "binkdata.h" #include "binkdata.h"
#include "binkdsp.h"
#include "mathops.h" #include "mathops.h"
#define ALT_BITSTREAM_READER_LE #define ALT_BITSTREAM_READER_LE
@ -60,8 +61,8 @@ static const int binkb_bundle_signed[BINKB_NB_SRC] = {
0, 0, 0, 1, 1, 0, 1, 0, 0, 0 0, 0, 0, 1, 1, 0, 1, 0, 0, 0
}; };
static uint32_t binkb_intra_quant[16][64]; static int32_t binkb_intra_quant[16][64];
static uint32_t binkb_inter_quant[16][64]; static int32_t binkb_inter_quant[16][64];
/** /**
* IDs for different data types used in Bink video codec * IDs for different data types used in Bink video codec
@ -109,11 +110,11 @@ typedef struct Bundle {
typedef struct BinkContext { typedef struct BinkContext {
AVCodecContext *avctx; AVCodecContext *avctx;
DSPContext dsp; DSPContext dsp;
BinkDSPContext bdsp;
AVFrame pic, last; AVFrame pic, last;
int version; ///< internal Bink file version int version; ///< internal Bink file version
int has_alpha; int has_alpha;
int swap_planes; int swap_planes;
ScanTable scantable; ///< permutated scantable for DCT coeffs decoding
Bundle bundle[BINKB_NB_SRC]; ///< bundles for decoding all data types Bundle bundle[BINKB_NB_SRC]; ///< bundles for decoding all data types
Tree col_high[16]; ///< trees for decoding high nibble in "colours" data type Tree col_high[16]; ///< trees for decoding high nibble in "colours" data type
@ -580,8 +581,8 @@ static inline int binkb_get_value(BinkContext *c, int bundle_num)
* @param quant_matrices quantization matrices * @param quant_matrices quantization matrices
* @return 0 for success, negative value in other cases * @return 0 for success, negative value in other cases
*/ */
static int read_dct_coeffs(GetBitContext *gb, DCTELEM block[64], const uint8_t *scan, static int read_dct_coeffs(GetBitContext *gb, int32_t block[64], const uint8_t *scan,
const uint32_t quant_matrices[16][64], int q) const int32_t quant_matrices[16][64], int q)
{ {
int coef_list[128]; int coef_list[128];
int mode_list[128]; int mode_list[128];
@ -590,7 +591,7 @@ static int read_dct_coeffs(GetBitContext *gb, DCTELEM block[64], const uint8_t *
int coef_count = 0; int coef_count = 0;
int coef_idx[64]; int coef_idx[64];
int quant_idx; int quant_idx;
const uint32_t *quant; const int32_t *quant;
coef_list[list_end] = 4; mode_list[list_end++] = 0; coef_list[list_end] = 4; mode_list[list_end++] = 0;
coef_list[list_end] = 24; mode_list[list_end++] = 0; coef_list[list_end] = 24; mode_list[list_end++] = 0;
@ -791,6 +792,7 @@ static int binkb_decode_plane(BinkContext *c, GetBitContext *gb, int plane_idx,
const uint8_t *scan; const uint8_t *scan;
int xoff, yoff; int xoff, yoff;
LOCAL_ALIGNED_16(DCTELEM, block, [64]); LOCAL_ALIGNED_16(DCTELEM, block, [64]);
LOCAL_ALIGNED_16(int32_t, dctblock, [64]);
int coordmap[64]; int coordmap[64];
int ybias = is_key ? -15 : 0; int ybias = is_key ? -15 : 0;
int qp; int qp;
@ -845,11 +847,11 @@ static int binkb_decode_plane(BinkContext *c, GetBitContext *gb, int plane_idx,
dst[coordmap[*scan++]] = binkb_get_value(c, BINKB_SRC_COLORS); dst[coordmap[*scan++]] = binkb_get_value(c, BINKB_SRC_COLORS);
break; break;
case 2: case 2:
c->dsp.clear_block(block); memset(dctblock, 0, sizeof(*dctblock) * 64);
block[0] = binkb_get_value(c, BINKB_SRC_INTRA_DC); dctblock[0] = binkb_get_value(c, BINKB_SRC_INTRA_DC);
qp = binkb_get_value(c, BINKB_SRC_INTRA_Q); qp = binkb_get_value(c, BINKB_SRC_INTRA_Q);
read_dct_coeffs(gb, block, c->scantable.permutated, binkb_intra_quant, qp); read_dct_coeffs(gb, dctblock, bink_scan, binkb_intra_quant, qp);
c->dsp.idct_put(dst, stride, block); c->bdsp.idct_put(dst, stride, dctblock);
break; break;
case 3: case 3:
xoff = binkb_get_value(c, BINKB_SRC_X_OFF); xoff = binkb_get_value(c, BINKB_SRC_X_OFF);
@ -878,11 +880,11 @@ static int binkb_decode_plane(BinkContext *c, GetBitContext *gb, int plane_idx,
} else { } else {
put_pixels8x8_overlapped(dst, ref, stride); put_pixels8x8_overlapped(dst, ref, stride);
} }
c->dsp.clear_block(block); memset(dctblock, 0, sizeof(*dctblock) * 64);
block[0] = binkb_get_value(c, BINKB_SRC_INTER_DC); dctblock[0] = binkb_get_value(c, BINKB_SRC_INTER_DC);
qp = binkb_get_value(c, BINKB_SRC_INTER_Q); qp = binkb_get_value(c, BINKB_SRC_INTER_Q);
read_dct_coeffs(gb, block, c->scantable.permutated, binkb_inter_quant, qp); read_dct_coeffs(gb, dctblock, bink_scan, binkb_inter_quant, qp);
c->dsp.idct_add(dst, stride, block); c->bdsp.idct_add(dst, stride, dctblock);
break; break;
case 5: case 5:
v = binkb_get_value(c, BINKB_SRC_COLORS); v = binkb_get_value(c, BINKB_SRC_COLORS);
@ -937,6 +939,7 @@ static int bink_decode_plane(BinkContext *c, GetBitContext *gb, int plane_idx,
int xoff, yoff; int xoff, yoff;
LOCAL_ALIGNED_16(DCTELEM, block, [64]); LOCAL_ALIGNED_16(DCTELEM, block, [64]);
LOCAL_ALIGNED_16(uint8_t, ublock, [64]); LOCAL_ALIGNED_16(uint8_t, ublock, [64]);
LOCAL_ALIGNED_16(int32_t, dctblock, [64]);
int coordmap[64]; int coordmap[64];
const int stride = c->pic.linesize[plane_idx]; const int stride = c->pic.linesize[plane_idx];
@ -1019,11 +1022,10 @@ static int bink_decode_plane(BinkContext *c, GetBitContext *gb, int plane_idx,
ublock[*scan++] = get_value(c, BINK_SRC_COLORS); ublock[*scan++] = get_value(c, BINK_SRC_COLORS);
break; break;
case INTRA_BLOCK: case INTRA_BLOCK:
c->dsp.clear_block(block); memset(dctblock, 0, sizeof(*dctblock) * 64);
block[0] = get_value(c, BINK_SRC_INTRA_DC); dctblock[0] = get_value(c, BINK_SRC_INTRA_DC);
read_dct_coeffs(gb, block, c->scantable.permutated, bink_intra_quant, -1); read_dct_coeffs(gb, dctblock, bink_scan, bink_intra_quant, -1);
c->dsp.idct(block); c->bdsp.idct_put(ublock, 8, dctblock);
c->dsp.put_pixels_nonclamped(block, ublock, 8);
break; break;
case FILL_BLOCK: case FILL_BLOCK:
v = get_value(c, BINK_SRC_COLORS); v = get_value(c, BINK_SRC_COLORS);
@ -1103,10 +1105,10 @@ static int bink_decode_plane(BinkContext *c, GetBitContext *gb, int plane_idx,
c->dsp.add_pixels8(dst, block, stride); c->dsp.add_pixels8(dst, block, stride);
break; break;
case INTRA_BLOCK: case INTRA_BLOCK:
c->dsp.clear_block(block); memset(dctblock, 0, sizeof(*dctblock) * 64);
block[0] = get_value(c, BINK_SRC_INTRA_DC); dctblock[0] = get_value(c, BINK_SRC_INTRA_DC);
read_dct_coeffs(gb, block, c->scantable.permutated, bink_intra_quant, -1); read_dct_coeffs(gb, dctblock, bink_scan, bink_intra_quant, -1);
c->dsp.idct_put(dst, stride, block); c->bdsp.idct_put(dst, stride, dctblock);
break; break;
case FILL_BLOCK: case FILL_BLOCK:
v = get_value(c, BINK_SRC_COLORS); v = get_value(c, BINK_SRC_COLORS);
@ -1117,10 +1119,10 @@ static int bink_decode_plane(BinkContext *c, GetBitContext *gb, int plane_idx,
yoff = get_value(c, BINK_SRC_Y_OFF); yoff = get_value(c, BINK_SRC_Y_OFF);
ref = prev + xoff + yoff * stride; ref = prev + xoff + yoff * stride;
c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8); c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
c->dsp.clear_block(block); memset(dctblock, 0, sizeof(*dctblock) * 64);
block[0] = get_value(c, BINK_SRC_INTER_DC); dctblock[0] = get_value(c, BINK_SRC_INTER_DC);
read_dct_coeffs(gb, block, c->scantable.permutated, bink_inter_quant, -1); read_dct_coeffs(gb, dctblock, bink_scan, bink_inter_quant, -1);
c->dsp.idct_add(dst, stride, block); c->bdsp.idct_add(dst, stride, dctblock);
break; break;
case PATTERN_BLOCK: case PATTERN_BLOCK:
for (i = 0; i < 2; i++) for (i = 0; i < 2; i++)
@ -1288,7 +1290,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
avctx->idct_algo = FF_IDCT_BINK; avctx->idct_algo = FF_IDCT_BINK;
dsputil_init(&c->dsp, avctx); dsputil_init(&c->dsp, avctx);
ff_init_scantable(c->dsp.idct_permutation, &c->scantable, bink_scan); ff_binkdsp_init(&c->bdsp);
init_bundles(c); init_bundles(c);

4
libavcodec/binkdata.h
View File

@ -285,7 +285,7 @@ static const uint8_t bink_patterns[16][64] = {
} }
}; };
static const uint32_t bink_intra_quant[16][64] = { static const int32_t bink_intra_quant[16][64] = {
{ {
0x010000, 0x016315, 0x01E83D, 0x02A535, 0x014E7B, 0x016577, 0x02F1E6, 0x02724C, 0x010000, 0x016315, 0x01E83D, 0x02A535, 0x014E7B, 0x016577, 0x02F1E6, 0x02724C,
0x010000, 0x00EEDA, 0x024102, 0x017F9B, 0x00BE80, 0x00611E, 0x01083C, 0x00A552, 0x010000, 0x00EEDA, 0x024102, 0x017F9B, 0x00BE80, 0x00611E, 0x01083C, 0x00A552,
@ -448,7 +448,7 @@ static const uint32_t bink_intra_quant[16][64] = {
}, },
}; };
static const uint32_t bink_inter_quant[16][64] = { static const int32_t bink_inter_quant[16][64] = {
{ {
0x010000, 0x017946, 0x01A5A9, 0x0248DC, 0x016363, 0x0152A7, 0x0243EC, 0x0209EA, 0x010000, 0x017946, 0x01A5A9, 0x0248DC, 0x016363, 0x0152A7, 0x0243EC, 0x0209EA,
0x012000, 0x00E248, 0x01BBDA, 0x015CBC, 0x00A486, 0x0053E0, 0x00F036, 0x008095, 0x012000, 0x00E248, 0x01BBDA, 0x015CBC, 0x00A486, 0x0053E0, 0x00F036, 0x008095,

21
libavcodec/binkidct.c → libavcodec/binkdsp.c
View File

@ -1,5 +1,5 @@
/* /*
* Bink IDCT algorithm * Bink DSP routines
* Copyright (c) 2009 Kostya Shishkov * Copyright (c) 2009 Kostya Shishkov
* *
* This file is part of Libav. * This file is part of Libav.
@ -21,10 +21,11 @@
/** /**
* @file * @file
* Bink IDCT algorithm * Bink DSP routines
*/ */
#include "dsputil.h" #include "dsputil.h"
#include "binkdsp.h"
#define A1 2896 /* (1/sqrt(2))<<12 */ #define A1 2896 /* (1/sqrt(2))<<12 */
#define A2 2217 #define A2 2217
@ -62,7 +63,7 @@
#define MUNGE_ROW(x) (((x) + 0x7F)>>8) #define MUNGE_ROW(x) (((x) + 0x7F)>>8)
#define IDCT_ROW(dest,src) IDCT_TRANSFORM(dest,0,1,2,3,4,5,6,7,0,1,2,3,4,5,6,7,MUNGE_ROW,src) #define IDCT_ROW(dest,src) IDCT_TRANSFORM(dest,0,1,2,3,4,5,6,7,0,1,2,3,4,5,6,7,MUNGE_ROW,src)
static inline void bink_idct_col(int *dest, const DCTELEM *src) static inline void bink_idct_col(int *dest, const int32_t *src)
{ {
if ((src[8]|src[16]|src[24]|src[32]|src[40]|src[48]|src[56])==0) { if ((src[8]|src[16]|src[24]|src[32]|src[40]|src[48]|src[56])==0) {
dest[0] = dest[0] =
@ -78,7 +79,7 @@ static inline void bink_idct_col(int *dest, const DCTELEM *src)
} }
} }
void ff_bink_idct_c(DCTELEM *block) static void bink_idct_c(int32_t *block)
{ {
int i; int i;
int temp[64]; int temp[64];
@ -90,17 +91,17 @@ void ff_bink_idct_c(DCTELEM *block)
} }
} }
void ff_bink_idct_add_c(uint8_t *dest, int linesize, DCTELEM *block) static void bink_idct_add_c(uint8_t *dest, int linesize, int32_t *block)
{ {
int i, j; int i, j;
ff_bink_idct_c(block); bink_idct_c(block);
for (i = 0; i < 8; i++, dest += linesize, block += 8) for (i = 0; i < 8; i++, dest += linesize, block += 8)
for (j = 0; j < 8; j++) for (j = 0; j < 8; j++)
dest[j] += block[j]; dest[j] += block[j];
} }
void ff_bink_idct_put_c(uint8_t *dest, int linesize, DCTELEM *block) static void bink_idct_put_c(uint8_t *dest, int linesize, int32_t *block)
{ {
int i; int i;
int temp[64]; int temp[64];
@ -110,3 +111,9 @@ void ff_bink_idct_put_c(uint8_t *dest, int linesize, DCTELEM *block)
IDCT_ROW( (&dest[i*linesize]), (&temp[8*i]) ); IDCT_ROW( (&dest[i*linesize]), (&temp[8*i]) );
} }
} }
void ff_binkdsp_init(BinkDSPContext *c)
{
c->idct_add = bink_idct_add_c;
c->idct_put = bink_idct_put_c;
}

39
libavcodec/binkdsp.h Normal file
View File

@ -0,0 +1,39 @@
/*
* Bink DSP routines
* Copyright (c) 2009 Kostya Shishkov
*
* This file is part of Libav.
*
* Libav 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.
*
* Libav 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 Libav; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/**
* @file
* Bink DSP routines
*/
#ifndef AVCODEC_BINKDSP_H
#define AVCODEC_BINKDSP_H
#include "dsputil.h"
typedef struct BinkDSPContext {
void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, int32_t *block/*align 16*/);
void (*idct_add)(uint8_t *dest/*align 8*/, int line_size, int32_t *block/*align 16*/);
} BinkDSPContext;
void ff_binkdsp_init(BinkDSPContext *c);
#endif /* AVCODEC_BINKDSP_H */

5
libavcodec/dsputil.c
View File

@ -2894,11 +2894,6 @@ av_cold void dsputil_init(DSPContext* c, AVCodecContext *avctx)
}else if(CONFIG_EATGQ_DECODER && avctx->idct_algo==FF_IDCT_EA) { }else if(CONFIG_EATGQ_DECODER && avctx->idct_algo==FF_IDCT_EA) {
c->idct_put= ff_ea_idct_put_c; c->idct_put= ff_ea_idct_put_c;
c->idct_permutation_type= FF_NO_IDCT_PERM; c->idct_permutation_type= FF_NO_IDCT_PERM;
}else if(CONFIG_BINK_DECODER && avctx->idct_algo==FF_IDCT_BINK) {
c->idct = ff_bink_idct_c;
c->idct_add = ff_bink_idct_add_c;
c->idct_put = ff_bink_idct_put_c;
c->idct_permutation_type = FF_NO_IDCT_PERM;
}else{ //accurate/default }else{ //accurate/default
c->idct_put = ff_simple_idct_put_8; c->idct_put = ff_simple_idct_put_8;
c->idct_add = ff_simple_idct_add_8; c->idct_add = ff_simple_idct_add_8;