virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity

Merge remote-tracking branch 'qatar/master'

Browse Source 
* qatar/master:
  fate: Add tests for more AAC features.
  aacps: Add missing newline in error message.
  fate: Add tests for vc1/wmapro in ism.
  aacdec: Add a fate test for 5.1 channel SBR.
  aacdec: Turn off PS for multichannel files that use PCE based configs.
  cabac: remove put_cabac_u/ueg from cabac-test.
  swscale: RGB4444 and BGR444 input
  FATE: add test for xWMA demuxer.
  FATE: add test for SMJPEG demuxer and associated IMA ADPCM audio decoder.
  mpegaudiodec: optimized iMDCT transform
  mpegaudiodec: change imdct window arrangment for better pointer alignment
  mpegaudiodec: move imdct and windowing function to mpegaudiodsp
  mpegaudiodec: interleave iMDCT buffer to simplify future SIMD implementations
  swscale: convert yuy2/uyvy/nv12/nv21ToY/UV from inline asm to yasm.
  FATE: test to exercise WTV demuxer.
  mjpegdec: K&R formatting cosmetics
  swscale: K&R formatting cosmetics for code examples
  swscale: K&R reformatting cosmetics for header files
  FATE test: cvid-grayscale; ensures that the grayscale Cinepak variant is exercised.

Conflicts:
	libavcodec/cabac.c
	libavcodec/mjpegdec.c
	libavcodec/mpegaudiodec.c
	libavcodec/mpegaudiodsp.c
	libavcodec/mpegaudiodsp.h
	libavcodec/mpegaudiodsp_template.c
	libavcodec/x86/Makefile
	libavcodec/x86/imdct36_sse.asm
	libavcodec/x86/mpegaudiodec_mmx.c
	libswscale/swscale-test.c
	libswscale/swscale.c
	libswscale/swscale_internal.h
	libswscale/x86/swscale_template.c
	tests/fate/demux.mak
	tests/fate/microsoft.mak
	tests/fate/video.mak
	tests/fate/wma.mak
	tests/ref/lavfi/pixfmts_scale

Merged-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer 2012-01-10 02:50:54 +01:00
commit dd3ca3ea15
38 changed files with 2215 additions and 721 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
libavcodec/aac.h
View File

@ -84,6 +84,7 @@ enum BandType {
#define IS_CODEBOOK_UNSIGNED(x) ((x - 1) & 10) #define IS_CODEBOOK_UNSIGNED(x) ((x - 1) & 10)
enum ChannelPosition { enum ChannelPosition {
AAC_CHANNEL_OFF = 0,
AAC_CHANNEL_FRONT = 1, AAC_CHANNEL_FRONT = 1,
AAC_CHANNEL_SIDE = 2, AAC_CHANNEL_SIDE = 2,
AAC_CHANNEL_BACK = 3, AAC_CHANNEL_BACK = 3,

21
libavcodec/aacdec.c
View File

@ -163,6 +163,19 @@ static ChannelElement *get_che(AACContext *ac, int type, int elem_id)
} }
} }
static int count_channels(enum ChannelPosition che_pos[4][MAX_ELEM_ID])
{
int i, type, sum = 0;
for (i = 0; i < MAX_ELEM_ID; i++) {
for (type = 0; type < 4; type++) {
sum += (1 + (type == TYPE_CPE)) *
(che_pos[type][i] != AAC_CHANNEL_OFF &&
che_pos[type][i] != AAC_CHANNEL_CC);
}
}
return sum;
}
/** /**
* Check for the channel element in the current channel position configuration. * Check for the channel element in the current channel position configuration.
* If it exists, make sure the appropriate element is allocated and map the * If it exists, make sure the appropriate element is allocated and map the
@ -437,6 +450,12 @@ static int decode_ga_specific_config(AACContext *ac, AVCodecContext *avctx,
if ((ret = set_default_channel_config(avctx, new_che_pos, channel_config))) if ((ret = set_default_channel_config(avctx, new_che_pos, channel_config)))
return ret; return ret;
} }
if (count_channels(new_che_pos) > 1) {
m4ac->ps = 0;
} else if (m4ac->sbr == 1 && m4ac->ps == -1)
m4ac->ps = 1;
if (ac && (ret = output_configure(ac, ac->che_pos, new_che_pos, channel_config, OC_GLOBAL_HDR))) if (ac && (ret = output_configure(ac, ac->che_pos, new_che_pos, channel_config, OC_GLOBAL_HDR)))
return ret; return ret;
@ -495,8 +514,6 @@ static int decode_audio_specific_config(AACContext *ac,
av_log(avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", m4ac->sampling_index); av_log(avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", m4ac->sampling_index);
return -1; return -1;
} }
if (m4ac->sbr == 1 && m4ac->ps == -1)
m4ac->ps = 1;
skip_bits_long(&gb, i); skip_bits_long(&gb, i);

2
libavcodec/aacps.c
View File

@ -223,7 +223,7 @@ int ff_ps_read_data(AVCodecContext *avctx, GetBitContext *gb_host, PSContext *ps
cnt -= 2 + ps_read_extension_data(gb, ps, ps_extension_id); cnt -= 2 + ps_read_extension_data(gb, ps, ps_extension_id);
} }
if (cnt < 0) { if (cnt < 0) {
av_log(avctx, AV_LOG_ERROR, "ps extension overflow %d", cnt); av_log(avctx, AV_LOG_ERROR, "ps extension overflow %d\n", cnt);
goto err; goto err;
} }
skip_bits(gb, cnt); skip_bits(gb, cnt);

74
libavcodec/cabac.c
View File

@ -252,67 +252,6 @@ static int put_cabac_terminate(CABACContext *c, int bit){
return (put_bits_count(&c->pb)+7)>>3; return (put_bits_count(&c->pb)+7)>>3;
} }
/**
* put (truncated) unary binarization.
*/
static void put_cabac_u(CABACContext *c, uint8_t * state, int v, int max, int max_index, int truncated){
int i;
assert(v <= max);
for(i=0; i<v; i++){
put_cabac(c, state, 1);
if(i < max_index) state++;
}
if(truncated==0 || v<max)
put_cabac(c, state, 0);
}
/**
* put unary exp golomb k-th order binarization.
*/
static void put_cabac_ueg(CABACContext *c, uint8_t * state, int v, int max, int is_signed, int k, int max_index){
int i;
if(v==0)
put_cabac(c, state, 0);
else{
const int sign= v < 0;
if(is_signed) v= FFABS(v);
if(v<max){
for(i=0; i<v; i++){
put_cabac(c, state, 1);
if(i < max_index) state++;
}
put_cabac(c, state, 0);
}else{
int m= 1<<k;
for(i=0; i<max; i++){
put_cabac(c, state, 1);
if(i < max_index) state++;
}
v -= max;
while(v >= m){ //FIXME optimize
put_cabac_bypass(c, 1);
v-= m;
m+= m;
}
put_cabac_bypass(c, 0);
while(m>>=1){
put_cabac_bypass(c, v&m);
}
}
if(is_signed)
put_cabac_bypass(c, sign);
}
}
int main(void){ int main(void){
CABACContext c; CABACContext c;
uint8_t b[9*SIZE]; uint8_t b[9*SIZE];
@ -342,19 +281,6 @@ START_TIMER
STOP_TIMER("put_cabac") STOP_TIMER("put_cabac")
} }
#if 0
for(i=0; i<SIZE; i++){
START_TIMER
put_cabac_u(&c, state, r[i], 6, 3, i&1);
STOP_TIMER("put_cabac_u")
}
for(i=0; i<SIZE; i++){
START_TIMER
put_cabac_ueg(&c, state, r[i], 3, 0, 1, 2);
STOP_TIMER("put_cabac_ueg")
}
#endif
put_cabac_terminate(&c, 1); put_cabac_terminate(&c, 1);
ff_init_cabac_decoder(&c, b, SIZE); ff_init_cabac_decoder(&c, b, SIZE);

89
libavcodec/mpegaudiodec.c
View File

@ -132,10 +132,6 @@ static uint16_t band_index_long[9][23];
static INTFLOAT is_table[2][16]; static INTFLOAT is_table[2][16];
static INTFLOAT is_table_lsf[2][2][16]; static INTFLOAT is_table_lsf[2][2][16];
static INTFLOAT csa_table[8][4]; static INTFLOAT csa_table[8][4];
/** Window for MDCT. Note that only the component [0,17] and [20,37] are used,
the components 18 and 19 are there only to assure 128-bit alignment for asm
*/
DECLARE_ALIGNED(16, static INTFLOAT, mdct_win)[8][40];
static int16_t division_tab3[1<<6 ]; static int16_t division_tab3[1<<6 ];
static int16_t division_tab5[1<<8 ]; static int16_t division_tab5[1<<8 ];
@ -422,45 +418,6 @@ static av_cold void decode_init_static(void)
csa_table[i][3] = ca - cs; csa_table[i][3] = ca - cs;
#endif #endif
} }
/* compute mdct windows */
for (i = 0; i < 36; i++) {
for (j = 0; j < 4; j++) {
double d;
if (j == 2 && i % 3 != 1)
continue;
d = sin(M_PI * (i + 0.5) / 36.0);
if (j == 1) {
if (i >= 30) d = 0;
else if (i >= 24) d = sin(M_PI * (i - 18 + 0.5) / 12.0);
else if (i >= 18) d = 1;
} else if (j == 3) {
if (i < 6) d = 0;
else if (i < 12) d = sin(M_PI * (i - 6 + 0.5) / 12.0);
else if (i < 18) d = 1;
}
//merge last stage of imdct into the window coefficients
d *= 0.5 / cos(M_PI * (2 * i + 19) / 72);
if (j == 2)
mdct_win[j][i/3] = FIXHR((d / (1<<5)));
else {
int idx = i < 18 ? i : i + 2;
mdct_win[j][idx] = FIXHR((d / (1<<5)));
}
}
}
/* NOTE: we do frequency inversion adter the MDCT by changing
the sign of the right window coefs */
for (j = 0; j < 4; j++) {
for (i = 0; i < 40; i += 2) {
mdct_win[j + 4][i ] = mdct_win[j][i ];
mdct_win[j + 4][i + 1] = -mdct_win[j][i + 1];
}
}
} }
static av_cold int decode_init(AVCodecContext * avctx) static av_cold int decode_init(AVCodecContext * avctx)
@ -1284,59 +1241,53 @@ static void compute_imdct(MPADecodeContext *s, GranuleDef *g,
mdct_long_end = sblimit; mdct_long_end = sblimit;
} }
buf = mdct_buf; s->mpadsp.RENAME(imdct36_blocks)(sb_samples, mdct_buf, g->sb_hybrid,
ptr = g->sb_hybrid; mdct_long_end, g->switch_point,
for (j = 0; j < mdct_long_end; j++) { g->block_type);
int win_idx = (g->switch_point && j < 2) ? 0 : g->block_type;
/* apply window & overlap with previous buffer */ buf = mdct_buf + 4*18*(mdct_long_end >> 2) + (mdct_long_end & 3);
out_ptr = sb_samples + j; ptr = g->sb_hybrid + 18 * mdct_long_end;
/* select window */
win = mdct_win[win_idx + (4 & -(j & 1))];
s->mpadsp.RENAME(imdct36)(out_ptr, buf, ptr, win);
out_ptr += 18 * SBLIMIT;
ptr += 18;
buf += 18;
}
for (j = mdct_long_end; j < sblimit; j++) { for (j = mdct_long_end; j < sblimit; j++) {
/* select frequency inversion */ /* select frequency inversion */
win = mdct_win[2 + (4 & -(j & 1))]; win = RENAME(ff_mdct_win)[2 + (4 & -(j & 1))];
out_ptr = sb_samples + j; out_ptr = sb_samples + j;
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
*out_ptr = buf[i]; *out_ptr = buf[4*i];
out_ptr += SBLIMIT; out_ptr += SBLIMIT;
} }
imdct12(out2, ptr + 0); imdct12(out2, ptr + 0);
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
*out_ptr = MULH3(out2[i ], win[i ], 1) + buf[i + 6*1]; *out_ptr = MULH3(out2[i ], win[i ], 1) + buf[4*(i + 6*1)];
buf[i + 6*2] = MULH3(out2[i + 6], win[i + 6], 1); buf[4*(i + 6*2)] = MULH3(out2[i + 6], win[i + 6], 1);
out_ptr += SBLIMIT; out_ptr += SBLIMIT;
} }
imdct12(out2, ptr + 1); imdct12(out2, ptr + 1);
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
*out_ptr = MULH3(out2[i ], win[i ], 1) + buf[i + 6*2]; *out_ptr = MULH3(out2[i ], win[i ], 1) + buf[4*(i + 6*2)];
buf[i + 6*0] = MULH3(out2[i + 6], win[i + 6], 1); buf[4*(i + 6*0)] = MULH3(out2[i + 6], win[i + 6], 1);
out_ptr += SBLIMIT; out_ptr += SBLIMIT;
} }
imdct12(out2, ptr + 2); imdct12(out2, ptr + 2);
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
buf[i + 6*0] = MULH3(out2[i ], win[i ], 1) + buf[i + 6*0]; buf[4*(i + 6*0)] = MULH3(out2[i ], win[i ], 1) + buf[4*(i + 6*0)];
buf[i + 6*1] = MULH3(out2[i + 6], win[i + 6], 1); buf[4*(i + 6*1)] = MULH3(out2[i + 6], win[i + 6], 1);
buf[i + 6*2] = 0; buf[4*(i + 6*2)] = 0;
} }
ptr += 18; ptr += 18;
buf += 18; buf += (j&3) != 3 ? 1 : (4*18-3);
} }
/* zero bands */ /* zero bands */
for (j = sblimit; j < SBLIMIT; j++) { for (j = sblimit; j < SBLIMIT; j++) {
/* overlap */ /* overlap */
out_ptr = sb_samples + j; out_ptr = sb_samples + j;
for (i = 0; i < 18; i++) { for (i = 0; i < 18; i++) {
*out_ptr = buf[i]; *out_ptr = buf[4*i];
buf[i] = 0; buf[4*i] = 0;
out_ptr += SBLIMIT; out_ptr += SBLIMIT;
} }
buf += 18; buf += (j&3) != 3 ? 1 : (4*18-3);
} }
} }

6
libavcodec/mpegaudiodsp.c
View File

@ -28,6 +28,8 @@ void ff_mpadsp_init(MPADSPContext *s)
DCTContext dct; DCTContext dct;
ff_dct_init(&dct, 5, DCT_II); ff_dct_init(&dct, 5, DCT_II);
ff_init_mpadsp_tabs_float();
ff_init_mpadsp_tabs_fixed();
s->apply_window_float = ff_mpadsp_apply_window_float; s->apply_window_float = ff_mpadsp_apply_window_float;
s->apply_window_fixed = ff_mpadsp_apply_window_fixed; s->apply_window_fixed = ff_mpadsp_apply_window_fixed;
@ -35,8 +37,8 @@ void ff_mpadsp_init(MPADSPContext *s)
s->dct32_float = dct.dct32; s->dct32_float = dct.dct32;
s->dct32_fixed = ff_dct32_fixed; s->dct32_fixed = ff_dct32_fixed;
s->imdct36_float = ff_imdct36_float; s->imdct36_blocks_float = ff_imdct36_blocks_float;
s->imdct36_fixed = ff_imdct36_fixed; s->imdct36_blocks_fixed = ff_imdct36_blocks_fixed;
if (ARCH_ARM) ff_mpadsp_init_arm(s); if (ARCH_ARM) ff_mpadsp_init_arm(s);
if (HAVE_MMX) ff_mpadsp_init_mmx(s); if (HAVE_MMX) ff_mpadsp_init_mmx(s);

24
libavcodec/mpegaudiodsp.h
View File

@ -20,6 +20,7 @@
#define AVCODEC_MPEGAUDIODSP_H #define AVCODEC_MPEGAUDIODSP_H
#include <stdint.h> #include <stdint.h>
#include "libavutil/common.h"
typedef struct MPADSPContext { typedef struct MPADSPContext {
void (*apply_window_float)(float *synth_buf, float *window, void (*apply_window_float)(float *synth_buf, float *window,
@ -28,8 +29,11 @@ typedef struct MPADSPContext {
int *dither_state, int16_t *samples, int incr); int *dither_state, int16_t *samples, int incr);
void (*dct32_float)(float *dst, const float *src); void (*dct32_float)(float *dst, const float *src);
void (*dct32_fixed)(int *dst, const int *src); void (*dct32_fixed)(int *dst, const int *src);
void (*imdct36_float)(float *out, float *buf, float *in, float *win);
void (*imdct36_fixed)(int *out, int *buf, int *in, int *win); void (*imdct36_blocks_float)(float *out, float *buf, float *in,
int count, int switch_point, int block_type);
void (*imdct36_blocks_fixed)(int *out, int *buf, int *in,
int count, int switch_point, int block_type);
} MPADSPContext; } MPADSPContext;
void ff_mpadsp_init(MPADSPContext *s); void ff_mpadsp_init(MPADSPContext *s);
@ -63,7 +67,19 @@ void ff_mpadsp_apply_window_fixed(int32_t *synth_buf, int32_t *window,
int *dither_state, int16_t *samples, int *dither_state, int16_t *samples,
int incr); int incr);
void ff_imdct36_fixed(int *out, int *buf, int *in, int *win); void ff_imdct36_blocks_float(float *out, float *buf, float *in,
void ff_imdct36_float(float *out, float *buf, float *in, float *win); int count, int switch_point, int block_type);
void ff_imdct36_blocks_fixed(int *out, int *buf, int *in,
int count, int switch_point, int block_type);
void ff_init_mpadsp_tabs_float(void);
void ff_init_mpadsp_tabs_fixed(void);
/** For SSE implementation, MDCT_BUF_SIZE/2 should be 128-bit aligned */
#define MDCT_BUF_SIZE FFALIGN(36, 2*4)
extern int ff_mdct_win_fixed[8][MDCT_BUF_SIZE];
extern float ff_mdct_win_float[8][MDCT_BUF_SIZE];
#endif /* AVCODEC_MPEGAUDIODSP_H */ #endif /* AVCODEC_MPEGAUDIODSP_H */

121
libavcodec/mpegaudiodsp_template.c
View File

@ -69,6 +69,12 @@ static inline int round_sample(int64_t *sum)
# define FIXHR(a) ((int)((a) * (1LL<<32) + 0.5)) # define FIXHR(a) ((int)((a) * (1LL<<32) + 0.5))
#endif #endif
/** Window for MDCT. Actually only the elements in [0,17] and
[MDCT_BUF_SIZE/2, MDCT_BUF_SIZE/2 + 17] are actually used. The rest
is just to preserve alignment for SIMD implementations.
*/
DECLARE_ALIGNED(16, INTFLOAT, RENAME(ff_mdct_win))[8][MDCT_BUF_SIZE];
DECLARE_ALIGNED(16, MPA_INT, RENAME(ff_mpa_synth_window))[512+256]; DECLARE_ALIGNED(16, MPA_INT, RENAME(ff_mpa_synth_window))[512+256];
#define SUM8(op, sum, w, p) \ #define SUM8(op, sum, w, p) \
@ -204,6 +210,7 @@ void av_cold RENAME(ff_mpa_synth_init)(MPA_INT *window)
window[512 - i] = v; window[512 - i] = v;
} }
// Needed for avoiding shuffles in ASM implementations // Needed for avoiding shuffles in ASM implementations
for(i=0; i < 8; i++) for(i=0; i < 8; i++)
for(j=0; j < 16; j++) for(j=0; j < 16; j++)
@ -214,6 +221,48 @@ void av_cold RENAME(ff_mpa_synth_init)(MPA_INT *window)
window[512+128+16*i+j] = window[64*i+48-j]; window[512+128+16*i+j] = window[64*i+48-j];
} }
void RENAME(ff_init_mpadsp_tabs)(void)
{
int i, j;
/* compute mdct windows */
for (i = 0; i < 36; i++) {
for (j = 0; j < 4; j++) {
double d;
if (j == 2 && i % 3 != 1)
continue;
d = sin(M_PI * (i + 0.5) / 36.0);
if (j == 1) {
if (i >= 30) d = 0;
else if (i >= 24) d = sin(M_PI * (i - 18 + 0.5) / 12.0);
else if (i >= 18) d = 1;
} else if (j == 3) {
if (i < 6) d = 0;
else if (i < 12) d = sin(M_PI * (i - 6 + 0.5) / 12.0);
else if (i < 18) d = 1;
}
//merge last stage of imdct into the window coefficients
d *= 0.5 / cos(M_PI * (2 * i + 19) / 72);
if (j == 2)
RENAME(ff_mdct_win)[j][i/3] = FIXHR((d / (1<<5)));
else {
int idx = i < 18 ? i : i + (MDCT_BUF_SIZE/2 - 18);
RENAME(ff_mdct_win)[j][idx] = FIXHR((d / (1<<5)));
}
}
}
/* NOTE: we do frequency inversion adter the MDCT by changing
the sign of the right window coefs */
for (j = 0; j < 4; j++) {
for (i = 0; i < MDCT_BUF_SIZE; i += 2) {
RENAME(ff_mdct_win)[j + 4][i ] = RENAME(ff_mdct_win)[j][i ];
RENAME(ff_mdct_win)[j + 4][i + 1] = -RENAME(ff_mdct_win)[j][i + 1];
}
}
}
/* cos(pi*i/18) */ /* cos(pi*i/18) */
#define C1 FIXHR(0.98480775301220805936/2) #define C1 FIXHR(0.98480775301220805936/2)
#define C2 FIXHR(0.93969262078590838405/2) #define C2 FIXHR(0.93969262078590838405/2)
@ -227,43 +276,42 @@ void av_cold RENAME(ff_mpa_synth_init)(MPA_INT *window)
/* 0.5 / cos(pi*(2*i+1)/36) */ /* 0.5 / cos(pi*(2*i+1)/36) */
static const INTFLOAT icos36[9] = { static const INTFLOAT icos36[9] = {
FIXR(0.50190991877167369479), FIXR(0.50190991877167369479),
FIXR(0.51763809020504152469), FIXR(0.51763809020504152469), //0
FIXR(0.55168895948124587824), FIXR(0.55168895948124587824),
FIXR(0.61038729438072803416), FIXR(0.61038729438072803416),
FIXR(0.70710678118654752439), FIXR(0.70710678118654752439), //1
FIXR(0.87172339781054900991), FIXR(0.87172339781054900991),
FIXR(1.18310079157624925896), FIXR(1.18310079157624925896),
FIXR(1.93185165257813657349), FIXR(1.93185165257813657349), //2
FIXR(5.73685662283492756461), FIXR(5.73685662283492756461),
}; };
/* 0.5 / cos(pi*(2*i+1)/36) */ /* 0.5 / cos(pi*(2*i+1)/36) */
static const INTFLOAT icos36h[9] = { static const INTFLOAT icos36h[9] = {
FIXHR(0.50190991877167369479/2), FIXHR(0.50190991877167369479/2),
FIXHR(0.51763809020504152469/2), FIXHR(0.51763809020504152469/2), //0
FIXHR(0.55168895948124587824/2), FIXHR(0.55168895948124587824/2),
FIXHR(0.61038729438072803416/2), FIXHR(0.61038729438072803416/2),
FIXHR(0.70710678118654752439/2), FIXHR(0.70710678118654752439/2), //1
FIXHR(0.87172339781054900991/2), FIXHR(0.87172339781054900991/2),
FIXHR(1.18310079157624925896/4), FIXHR(1.18310079157624925896/4),
FIXHR(1.93185165257813657349/4), FIXHR(1.93185165257813657349/4), //2
// FIXHR(5.73685662283492756461),
}; };
/* using Lee like decomposition followed by hand coded 9 points DCT */ /* using Lee like decomposition followed by hand coded 9 points DCT */
void RENAME(ff_imdct36)(INTFLOAT *out, INTFLOAT *buf, INTFLOAT *in, static void imdct36(INTFLOAT *out, INTFLOAT *buf, INTFLOAT *in, INTFLOAT *win)
INTFLOAT *win)
{ {
int i, j; int i, j;
INTFLOAT t0, t1, t2, t3, s0, s1, s2, s3; INTFLOAT t0, t1, t2, t3, s0, s1, s2, s3;
INTFLOAT tmp[18], *tmp1, *in1; INTFLOAT tmp[18], *tmp1, *in1;
for(i=17;i>=1;i--) for (i = 17; i >= 1; i--)
in[i] += in[i-1]; in[i] += in[i-1];
for(i=17;i>=3;i-=2) for (i = 17; i >= 3; i -= 2)
in[i] += in[i-2]; in[i] += in[i-2];
for(j=0;j<2;j++) { for (j = 0; j < 2; j++) {
tmp1 = tmp + j; tmp1 = tmp + j;
in1 = in + j; in1 = in + j;
@ -295,7 +343,7 @@ void RENAME(ff_imdct36)(INTFLOAT *out, INTFLOAT *buf, INTFLOAT *in,
} }
i = 0; i = 0;
for(j=0;j<4;j++) { for (j = 0; j < 4; j++) {
t0 = tmp[i]; t0 = tmp[i];
t1 = tmp[i + 2]; t1 = tmp[i + 2];
s0 = t1 + t0; s0 = t1 + t0;
@ -303,22 +351,22 @@ void RENAME(ff_imdct36)(INTFLOAT *out, INTFLOAT *buf, INTFLOAT *in,
t2 = tmp[i + 1]; t2 = tmp[i + 1];
t3 = tmp[i + 3]; t3 = tmp[i + 3];
s1 = MULH3(t3 + t2, icos36h[j], 2); s1 = MULH3(t3 + t2, icos36h[ j], 2);
s3 = MULLx(t3 - t2, icos36[8 - j], FRAC_BITS); s3 = MULLx(t3 - t2, icos36 [8 - j], FRAC_BITS);
t0 = s0 + s1; t0 = s0 + s1;
t1 = s0 - s1; t1 = s0 - s1;
out[(9 + j)*SBLIMIT] = MULH3(t1, win[9 + j], 1) + buf[9 + j]; out[(9 + j) * SBLIMIT] = MULH3(t1, win[ 9 + j], 1) + buf[4*(9 + j)];
out[(8 - j)*SBLIMIT] = MULH3(t1, win[8 - j], 1) + buf[8 - j]; out[(8 - j) * SBLIMIT] = MULH3(t1, win[ 8 - j], 1) + buf[4*(8 - j)];
buf[9 + j] = MULH3(t0, win[20 + 9 + j], 1); buf[4 * ( 9 + j )] = MULH3(t0, win[MDCT_BUF_SIZE/2 + 9 + j], 1);
buf[8 - j] = MULH3(t0, win[20 + 8 - j], 1); buf[4 * ( 8 - j )] = MULH3(t0, win[MDCT_BUF_SIZE/2 + 8 - j], 1);
t0 = s2 + s3; t0 = s2 + s3;
t1 = s2 - s3; t1 = s2 - s3;
out[(9 + 8 - j)*SBLIMIT] = MULH3(t1, win[9 + 8 - j], 1) + buf[9 + 8 - j]; out[(9 + 8 - j) * SBLIMIT] = MULH3(t1, win[ 9 + 8 - j], 1) + buf[4*(9 + 8 - j)];
out[( j)*SBLIMIT] = MULH3(t1, win[ j], 1) + buf[ j]; out[ j * SBLIMIT] = MULH3(t1, win[ j], 1) + buf[4*( j)];
buf[9 + 8 - j] = MULH3(t0, win[20 + 9 + 8 - j], 1); buf[4 * ( 9 + 8 - j )] = MULH3(t0, win[MDCT_BUF_SIZE/2 + 9 + 8 - j], 1);
buf[ + j] = MULH3(t0, win[20 + j], 1); buf[4 * ( j )] = MULH3(t0, win[MDCT_BUF_SIZE/2 + j], 1);
i += 4; i += 4;
} }
@ -326,9 +374,28 @@ void RENAME(ff_imdct36)(INTFLOAT *out, INTFLOAT *buf, INTFLOAT *in,
s1 = MULH3(tmp[17], icos36h[4], 2); s1 = MULH3(tmp[17], icos36h[4], 2);
t0 = s0 + s1; t0 = s0 + s1;
t1 = s0 - s1; t1 = s0 - s1;
out[(9 + 4)*SBLIMIT] = MULH3(t1, win[9 + 4], 1) + buf[9 + 4]; out[(9 + 4) * SBLIMIT] = MULH3(t1, win[ 9 + 4], 1) + buf[4*(9 + 4)];
out[(8 - 4)*SBLIMIT] = MULH3(t1, win[8 - 4], 1) + buf[8 - 4]; out[(8 - 4) * SBLIMIT] = MULH3(t1, win[ 8 - 4], 1) + buf[4*(8 - 4)];
buf[9 + 4] = MULH3(t0, win[20 + 9 + 4], 1); buf[4 * ( 9 + 4 )] = MULH3(t0, win[MDCT_BUF_SIZE/2 + 9 + 4], 1);
buf[8 - 4] = MULH3(t0, win[20 + 8 - 4], 1); buf[4 * ( 8 - 4 )] = MULH3(t0, win[MDCT_BUF_SIZE/2 + 8 - 4], 1);
}
void RENAME(ff_imdct36_blocks)(INTFLOAT *out, INTFLOAT *buf, INTFLOAT *in,
int count, int switch_point, int block_type)
{
int j;
for (j=0 ; j < count; j++) {
/* apply window & overlap with previous buffer */
/* select window */
int win_idx = (switch_point && j < 2) ? 0 : block_type;
INTFLOAT *win = RENAME(ff_mdct_win)[win_idx + (4 & -(j & 1))];
imdct36(out, buf, in, win);
in += 18;
buf += ((j&3) != 3 ? 1 : (72-3));
out++;
}
} }

536
libavcodec/x86/imdct36_sse.asm
View File

@ -53,92 +53,118 @@ ps_cosh_sse3: dd 1.0, -0.50190991877167369479, 1.0, -5.73685662283492756461
dd 1.0, -0.61038729438072803416, -1.0, 0.87172339781054900991 dd 1.0, -0.61038729438072803416, -1.0, 0.87172339781054900991
dd 1.0, 0.70710678118654752439, 0.0, 0.0 dd 1.0, 0.70710678118654752439, 0.0, 0.0
costabs: times 4 dd 0.98480773
times 4 dd 0.93969262
times 4 dd 0.86602539
times 4 dd -0.76604444
times 4 dd -0.64278764
times 4 dd 0.50000000
times 4 dd -0.50000000
times 4 dd -0.34202015
times 4 dd -0.17364818
times 4 dd 0.50190992
times 4 dd 0.51763808
times 4 dd 0.55168896
times 4 dd 0.61038726
times 4 dd 0.70710677
times 4 dd 0.87172341
times 4 dd 1.18310082
times 4 dd 1.93185163
times 4 dd 5.73685646
%define SBLIMIT 32 %define SBLIMIT 32
SECTION_TEXT SECTION_TEXT
%macro PSHUFD_SSE_AVX 3 %macro PSHUFD 3
shufps %1, %2, %2, %3 %if cpuflag(sse2) && notcpuflag(avx)
%endmacro
%macro PSHUFD_SSE2 3
pshufd %1, %2, %3 pshufd %1, %2, %3
%else
shufps %1, %2, %2, %3
%endif
%endmacro %endmacro
; input %1={x1,x2,x3,x4}, %2={y1,y2,y3,y4} ; input %2={x1,x2,x3,x4}, %3={y1,y2,y3,y4}
; output %3={x3,x4,y1,y2} ; output %1={x3,x4,y1,y2}
%macro BUILDINVHIGHLOW_SSE 3 %macro BUILDINVHIGHLOW 3
movlhps %3, %2 %if cpuflag(avx)
movhlps %3, %1 shufps %1, %2, %3, 0x4e
%endmacro %else
%macro BUILDINVHIGHLOW_AVX 3 movlhps %1, %3
shufps %3, %1, %2, 0x4e movhlps %1, %2
%endif
%endmacro %endmacro
; input %1={x1,x2,x3,x4}, %2={y1,y2,y3,y4} ; input %2={x1,x2,x3,x4}, %3={y1,y2,y3,y4}
; output %3={x4,y1,y2,y3} ; output %1={x4,y1,y2,y3}
%macro ROTLEFT_SSE 3 %macro ROTLEFT 3
%if cpuflag(ssse3)
palignr %1, %3, %2, 12
%else
BUILDINVHIGHLOW %1, %2, %3 BUILDINVHIGHLOW %1, %2, %3
shufps %3, %3, %2, 0x99 shufps %1, %1, %3, 0x99
%endif
%endmacro %endmacro
%macro ROTLEFT_SSSE3 3 %macro INVERTHL 2
palignr %3, %2, %1, 12 %if cpuflag(sse2)
%endmacro PSHUFD %1, %2, 0x4e
%else
%macro INVERTHL_SSE1 2
movhlps %1, %2 movhlps %1, %2
movlhps %1, %2 movlhps %1, %2
%endif
%endmacro %endmacro
%macro INVERTHL_SSE2 2 %macro BUTTERF 3
PSHUFD %1, %2, 0x4e
%endmacro
%macro BUTTERF_SSE12 3
INVERTHL %2, %1 INVERTHL %2, %1
xorps %1, [ps_p1p1m1m1] xorps %1, [ps_p1p1m1m1]
addps %1, %2 addps %1, %2
%if cpuflag(sse3)
mulps %1, %1, [ps_cosh_sse3 + %3]
PSHUFD %2, %1, 0xb1
addsubps %1, %1, %2
%else
mulps %1, [ps_cosh + %3] mulps %1, [ps_cosh + %3]
PSHUFD %2, %1, 0xb1 PSHUFD %2, %1, 0xb1
xorps %1, [ps_p1m1p1m1] xorps %1, [ps_p1m1p1m1]
addps %1, %2 addps %1, %2
%endmacro %endif
%macro BUTTERF_SSE3 3
INVERTHL %2, %1
xorps %1, %1, [ps_p1p1m1m1]
addps %1, %1, %2
mulps %1, %1, [ps_cosh_sse3 + %3]
PSHUFD %2, %1, 0xb1
addsubps %1, %1, %2
%endmacro %endmacro
%macro STORE 3 %macro STORE 4
movhlps %2, %1 movhlps %2, %1
movss [%3 ], %1 movss [%3 ], %1
movss [%3 + 8*SBLIMIT], %2 movss [%3 + 2*%4], %2
shufps %1, %1, 0xb1 shufps %1, %1, 0xb1
movss [%3 + 4*SBLIMIT], %1 movss [%3 + %4], %1
movhlps %2, %1 movhlps %2, %1
movss [%3 + 12*SBLIMIT], %2 movss [%3 + 3*%4], %2
%endmacro
%macro LOAD 4
movlps %1, [%3 ]
movhps %1, [%3 + %4]
movlps %2, [%3 + 2*%4]
movhps %2, [%3 + 3*%4]
shufps %1, %2, 0x88
%endmacro %endmacro
%macro LOADA64 2 %macro LOADA64 2
%if cpuflag(avx)
movu %1, [%2]
%else
movlps %1, [%2] movlps %1, [%2]
movhps %1, [%2 + 8] movhps %1, [%2 + 8]
%endif
%endmacro %endmacro
%macro STOREA64 2 %macro DEFINE_IMDCT 0
movlps [%1 ], %2 cglobal imdct36_float, 4,4,9, out, buf, in, win
movhps [%1 + 8], %2
%endmacro
%macro DEFINE_IMDCT 1
cglobal imdct36_float_%1, 4,4,9, out, buf, in, win
; for(i=17;i>=1;i--) in[i] += in[i-1]; ; for(i=17;i>=1;i--) in[i] += in[i-1];
LOADA64 m0, inq LOADA64 m0, inq
LOADA64 m1, inq + 16 LOADA64 m1, inq + 16
ROTLEFT m0, m1, m5 ROTLEFT m5, m0, m1
PSHUFD m6, m0, 0x93 PSHUFD m6, m0, 0x93
andps m6, m6, [ps_mask] andps m6, m6, [ps_mask]
@ -146,16 +172,16 @@ cglobal imdct36_float_%1, 4,4,9, out, buf, in, win
LOADA64 m2, inq + 32 LOADA64 m2, inq + 32
ROTLEFT m1, m2, m7 ROTLEFT m7, m1, m2
addps m1, m1, m5 addps m1, m1, m5
LOADA64 m3, inq + 48 LOADA64 m3, inq + 48
ROTLEFT m2, m3, m5 ROTLEFT m5, m2, m3
xorps m4, m4, m4 xorps m4, m4, m4
movlps m4, [inq+64] movlps m4, [inq+64]
BUILDINVHIGHLOW m3, m4, m6 BUILDINVHIGHLOW m6, m3, m4
shufps m6, m6, m4, 0xa9 shufps m6, m6, m4, 0xa9
addps m4, m4, m6 addps m4, m4, m6
@ -166,17 +192,17 @@ cglobal imdct36_float_%1, 4,4,9, out, buf, in, win
movlhps m5, m5, m0 movlhps m5, m5, m0
andps m5, m5, [ps_mask3] andps m5, m5, [ps_mask3]
BUILDINVHIGHLOW m0, m1, m7 BUILDINVHIGHLOW m7, m0, m1
andps m7, m7, [ps_mask2] andps m7, m7, [ps_mask2]
addps m0, m0, m5 addps m0, m0, m5
BUILDINVHIGHLOW m1, m2, m6 BUILDINVHIGHLOW m6, m1, m2
andps m6, m6, [ps_mask2] andps m6, m6, [ps_mask2]
addps m1, m1, m7 addps m1, m1, m7
BUILDINVHIGHLOW m2, m3, m7 BUILDINVHIGHLOW m7, m2, m3
andps m7, m7, [ps_mask2] andps m7, m7, [ps_mask2]
addps m2, m2, m6 addps m2, m2, m6
@ -245,7 +271,7 @@ cglobal imdct36_float_%1, 4,4,9, out, buf, in, win
subps m0, m0, m1 subps m0, m0, m1
addps m0, m0, m6 addps m0, m0, m6
BUILDINVHIGHLOW m2, m3, m4 BUILDINVHIGHLOW m4, m2, m3
shufps m3, m3, m2, 0x4e shufps m3, m3, m2, 0x4e
; we have tmp = {SwAPLH(m0), SwAPLH(m7), m3, m4, m5} ; we have tmp = {SwAPLH(m0), SwAPLH(m7), m3, m4, m5}
@ -280,7 +306,9 @@ cglobal imdct36_float_%1, 4,4,9, out, buf, in, win
; permutation done ; permutation done
PSHUFD m6, m2, 0xb1 PSHUFD m6, m2, 0xb1
movlps m7, [bufq + 64] movss m4, [bufq + 4*68]
movss m7, [bufq + 4*64]
unpcklps m7, m7, m4
mulps m6, m6, [winq + 16*4] mulps m6, m6, [winq + 16*4]
addps m6, m6, m7 addps m6, m6, m7
movss [outq + 64*SBLIMIT], m6 movss [outq + 64*SBLIMIT], m6
@ -288,74 +316,406 @@ cglobal imdct36_float_%1, 4,4,9, out, buf, in, win
movss [outq + 68*SBLIMIT], m6 movss [outq + 68*SBLIMIT], m6
mulps m6, m3, [winq + 4*4] mulps m6, m3, [winq + 4*4]
LOADA64 m4, bufq + 16 LOAD m4, m7, bufq + 4*16, 16
addps m6, m6, m4 addps m6, m6, m4
STORE m6, m7, outq + 16*SBLIMIT STORE m6, m7, outq + 16*SBLIMIT, 4*SBLIMIT
shufps m4, m0, m3, 0xb5 shufps m4, m0, m3, 0xb5
mulps m4, m4, [winq + 8*4] mulps m4, m4, [winq + 8*4]
LOADA64 m7, bufq + 32 LOAD m7, m6, bufq + 4*32, 16
addps m4, m4, m7 addps m4, m4, m7
STORE m4, m6, outq + 32*SBLIMIT STORE m4, m6, outq + 32*SBLIMIT, 4*SBLIMIT
shufps m3, m3, m2, 0xb1 shufps m3, m3, m2, 0xb1
mulps m3, m3, [winq + 12*4] mulps m3, m3, [winq + 12*4]
LOADA64 m7, bufq + 48 LOAD m7, m6, bufq + 4*48, 16
addps m3, m3, m7 addps m3, m3, m7
STORE m3, m7, outq + 48*SBLIMIT STORE m3, m7, outq + 48*SBLIMIT, 4*SBLIMIT
mulps m2, m2, [winq] mulps m2, m2, [winq]
LOADA64 m6, bufq LOAD m6, m7, bufq, 16
addps m2, m2, m6 addps m2, m2, m6
STORE m2, m7, outq STORE m2, m7, outq, 4*SBLIMIT
mulps m4, m1, [winq + 20*4] mulps m4, m1, [winq + 20*4]
STOREA64 bufq, m4 STORE m4, m7, bufq, 16
mulps m3, m5, [winq + 24*4] mulps m3, m5, [winq + 24*4]
STOREA64 bufq + 16, m3 STORE m3, m7, bufq + 4*16, 16
shufps m0, m0, m5, 0xb0 shufps m0, m0, m5, 0xb0
mulps m0, m0, [winq + 28*4] mulps m0, m0, [winq + 28*4]
STOREA64 bufq + 32, m0 STORE m0, m7, bufq + 4*32, 16
shufps m5, m5, m1, 0xb1 shufps m5, m5, m1, 0xb1
mulps m5, m5, [winq + 32*4] mulps m5, m5, [winq + 32*4]
STOREA64 bufq + 48, m5 STORE m5, m7, bufq + 4*48, 16
shufps m1, m1, m1, 0xb1 shufps m1, m1, m1, 0xb1
mulps m1, m1, [winq + 36*4] mulps m1, m1, [winq + 36*4]
movlps [bufq + 64], m1 movss [bufq + 4*64], m1
shufps m1, m1, 0xb1
movss [bufq + 4*68], m1
RET RET
%endmacro %endmacro
%define PSHUFD PSHUFD_SSE_AVX INIT_XMM sse
%define INVERTHL INVERTHL_SSE1 DEFINE_IMDCT
%define BUTTERF BUTTERF_SSE12
%define BUTTERF0 BUTTERF0_SSE12
%define BUILDINVHIGHLOW BUILDINVHIGHLOW_SSE
%define ROTLEFT ROTLEFT_SSE
INIT_XMM INIT_XMM sse2
DEFINE_IMDCT
DEFINE_IMDCT sse INIT_XMM sse3
DEFINE_IMDCT
%define PSHUFD PSHUFD_SSE2 INIT_XMM ssse3
%define INVERTHL INVERTHL_SSE2 DEFINE_IMDCT
DEFINE_IMDCT sse2 INIT_XMM avx
DEFINE_IMDCT
%define BUTTERF BUTTERF_SSE3 INIT_XMM sse
%define BUTTERF0 BUTTERF0_SSE3
DEFINE_IMDCT sse3 %ifdef ARCH_X86_64
%define SPILL SWAP
%define UNSPILL SWAP
%define SPILLED(x) m %+ x
%else
%define SPILLED(x) [tmpq+(x-8)*16 + 32*4]
%macro SPILL 2 ; xmm#, mempos
movaps SPILLED(%2), m%1
%endmacro
%macro UNSPILL 2
movaps m%1, SPILLED(%2)
%endmacro
%endif
%define ROTLEFT ROTLEFT_SSSE3 %macro DEFINE_FOUR_IMDCT 0
cglobal four_imdct36_float, 5,5,8, out, buf, in, win, tmp
movlps m0, [inq+64]
movhps m0, [inq+64 + 72]
movlps m3, [inq+64 + 2*72]
movhps m3, [inq+64 + 3*72]
DEFINE_IMDCT ssse3 shufps m5, m0, m3, 0xdd
shufps m0, m0, m3, 0x88
%define BUILDINVHIGHLOW BUILDINVHIGHLOW_AVX mova m1, [inq+48]
%define PSHUFD PSHUFD_SSE_AVX movu m6, [inq+48 + 72]
mova m7, [inq+48 + 2*72]
movu m3, [inq+48 + 3*72]
INIT_AVX TRANSPOSE4x4PS 1, 6, 7, 3, 4
DEFINE_IMDCT avx
addps m4, m6, m7
mova [tmpq+4*28], m4
addps m7, m3
addps m6, m1
addps m3, m0
addps m0, m5
addps m0, m7
addps m7, m6
mova [tmpq+4*12], m7
SPILL 3, 12
mova m4, [inq+32]
movu m5, [inq+32 + 72]
mova m2, [inq+32 + 2*72]
movu m7, [inq+32 + 3*72]
TRANSPOSE4x4PS 4, 5, 2, 7, 3
addps m1, m7
SPILL 1, 11
addps m3, m5, m2
SPILL 3, 13
addps m7, m2
addps m5, m4
addps m6, m7
mova [tmpq], m6
addps m7, m5
mova [tmpq+4*16], m7
mova m2, [inq+16]
movu m7, [inq+16 + 72]
mova m1, [inq+16 + 2*72]
movu m6, [inq+16 + 3*72]
TRANSPOSE4x4PS 2, 7, 1, 6, 3
addps m4, m6
addps m6, m1
addps m1, m7
addps m7, m2
addps m5, m6
SPILL 5, 15
addps m6, m7
mulps m6, [costabs + 16*2]
mova [tmpq+4*8], m6
SPILL 1, 10
SPILL 0, 14
mova m1, [inq]
movu m6, [inq + 72]
mova m3, [inq + 2*72]
movu m5, [inq + 3*72]
TRANSPOSE4x4PS 1, 6, 3, 5, 0
addps m2, m5
addps m5, m3
addps m7, m5
addps m3, m6
addps m6, m1
SPILL 7, 8
addps m5, m6
SPILL 6, 9
addps m6, m4, SPILLED(12)
subps m6, m2
UNSPILL 7, 11
SPILL 5, 11
subps m5, m1, m7
mulps m7, [costabs + 16*5]
addps m7, m1
mulps m0, m6, [costabs + 16*6]
addps m0, m5
mova [tmpq+4*24], m0
addps m6, m5
mova [tmpq+4*4], m6
addps m6, m4, m2
mulps m6, [costabs + 16*1]
subps m4, SPILLED(12)
mulps m4, [costabs + 16*8]
addps m2, SPILLED(12)
mulps m2, [costabs + 16*3]
subps m5, m7, m6
subps m5, m2
addps m6, m7
addps m6, m4
addps m7, m2
subps m7, m4
mova [tmpq+4*20], m7
mova m2, [tmpq+4*28]
mova [tmpq+4*28], m5
UNSPILL 7, 13
subps m5, m7, m2
mulps m5, [costabs + 16*7]
UNSPILL 1, 10
mulps m1, [costabs + 16*2]
addps m4, m3, m2
mulps m4, [costabs + 16*4]
addps m2, m7
addps m7, m3
mulps m7, [costabs]
subps m3, m2
mulps m3, [costabs + 16*2]
addps m2, m7, m5
addps m2, m1
SPILL 2, 10
addps m7, m4
subps m7, m1
SPILL 7, 12
subps m5, m4
subps m5, m1
UNSPILL 0, 14
SPILL 5, 13
addps m1, m0, SPILLED(15)
subps m1, SPILLED(8)
mova m4, [costabs + 16*5]
mulps m4, [tmpq]
UNSPILL 2, 9
addps m4, m2
subps m2, [tmpq]
mulps m5, m1, [costabs + 16*6]
addps m5, m2
SPILL 5, 9
addps m2, m1
SPILL 2, 14
UNSPILL 5, 15
subps m7, m5, m0
addps m5, SPILLED(8)
mulps m5, [costabs + 16*1]
mulps m7, [costabs + 16*8]
addps m0, SPILLED(8)
mulps m0, [costabs + 16*3]
subps m2, m4, m5
subps m2, m0
SPILL 2, 15
addps m5, m4
addps m5, m7
addps m4, m0
subps m4, m7
SPILL 4, 8
mova m7, [tmpq+4*16]
mova m2, [tmpq+4*12]
addps m0, m7, m2
subps m0, SPILLED(11)
mulps m0, [costabs + 16*2]
addps m4, m7, SPILLED(11)
mulps m4, [costabs]
subps m7, m2
mulps m7, [costabs + 16*7]
addps m2, SPILLED(11)
mulps m2, [costabs + 16*4]
addps m1, m7, [tmpq+4*8]
addps m1, m4
addps m4, m2
subps m4, [tmpq+4*8]
SPILL 4, 11
subps m7, m2
subps m7, [tmpq+4*8]
addps m4, m6, SPILLED(10)
subps m6, SPILLED(10)
addps m2, m5, m1
mulps m2, [costabs + 16*9]
subps m5, m1
mulps m5, [costabs + 16*17]
subps m1, m4, m2
addps m4, m2
mulps m2, m1, [winq+4*36]
addps m2, [bufq+4*36]
mova [outq+1152], m2
mulps m1, [winq+4*32]
addps m1, [bufq+4*32]
mova [outq+1024], m1
mulps m1, m4, [winq+4*116]
mova [bufq+4*36], m1
mulps m4, [winq+4*112]
mova [bufq+4*32], m4
addps m2, m6, m5
subps m6, m5
mulps m1, m6, [winq+4*68]
addps m1, [bufq+4*68]
mova [outq+2176], m1
mulps m6, [winq]
addps m6, [bufq]
mova [outq], m6
mulps m1, m2, [winq+4*148]
mova [bufq+4*68], m1
mulps m2, [winq+4*80]
mova [bufq], m2
addps m5, m3, [tmpq+4*24]
mova m2, [tmpq+4*24]
subps m2, m3
mova m1, SPILLED(9)
subps m1, m0
mulps m1, [costabs + 16*10]
addps m0, SPILLED(9)
mulps m0, [costabs + 16*16]
addps m6, m5, m1
subps m5, m1
mulps m3, m5, [winq+4*40]
addps m3, [bufq+4*40]
mova [outq+1280], m3
mulps m5, [winq+4*28]
addps m5, [bufq+4*28]
mova [outq+896], m5
mulps m1, m6, [winq+4*120]
mova [bufq+4*40], m1
mulps m6, [winq+4*108]
mova [bufq+4*28], m6
addps m1, m2, m0
subps m2, m0
mulps m5, m2, [winq+4*64]
addps m5, [bufq+4*64]
mova [outq+2048], m5
mulps m2, [winq+4*4]
addps m2, [bufq+4*4]
mova [outq+128], m2
mulps m0, m1, [winq+4*144]
mova [bufq+4*64], m0
mulps m1, [winq+4*84]
mova [bufq+4*4], m1
mova m1, [tmpq+4*28]
mova m5, m1
addps m1, SPILLED(13)
subps m5, SPILLED(13)
UNSPILL 3, 15
addps m2, m7, m3
mulps m2, [costabs + 16*11]
subps m3, m7
mulps m3, [costabs + 16*15]
addps m0, m2, m1
subps m1, m2
SWAP m0, m2
mulps m6, m1, [winq+4*44]
addps m6, [bufq+4*44]
mova [outq+1408], m6
mulps m1, [winq+4*24]
addps m1, [bufq+4*24]
mova [outq+768], m1
mulps m0, m2, [winq+4*124]
mova [bufq+4*44], m0
mulps m2, [winq+4*104]
mova [bufq+4*24], m2
addps m0, m5, m3
subps m5, m3
mulps m1, m5, [winq+4*60]
addps m1, [bufq+4*60]
mova [outq+1920], m1
mulps m5, [winq+4*8]
addps m5, [bufq+4*8]
mova [outq+256], m5
mulps m1, m0, [winq+4*140]
mova [bufq+4*60], m1
mulps m0, [winq+4*88]
mova [bufq+4*8], m0
mova m1, [tmpq+4*20]
addps m1, SPILLED(12)
mova m2, [tmpq+4*20]
subps m2, SPILLED(12)
UNSPILL 7, 8
subps m0, m7, SPILLED(11)
addps m7, SPILLED(11)
mulps m4, m7, [costabs + 16*12]
mulps m0, [costabs + 16*14]
addps m5, m1, m4
subps m1, m4
mulps m7, m1, [winq+4*48]
addps m7, [bufq+4*48]
mova [outq+1536], m7
mulps m1, [winq+4*20]
addps m1, [bufq+4*20]
mova [outq+640], m1
mulps m1, m5, [winq+4*128]
mova [bufq+4*48], m1
mulps m5, [winq+4*100]
mova [bufq+4*20], m5
addps m6, m2, m0
subps m2, m0
mulps m1, m2, [winq+4*56]
addps m1, [bufq+4*56]
mova [outq+1792], m1
mulps m2, [winq+4*12]
addps m2, [bufq+4*12]
mova [outq+384], m2
mulps m0, m6, [winq+4*136]
mova [bufq+4*56], m0
mulps m6, [winq+4*92]
mova [bufq+4*12], m6
UNSPILL 0, 14
mulps m0, [costabs + 16*13]
mova m3, [tmpq+4*4]
addps m2, m0, m3
subps m3, m0
mulps m0, m3, [winq+4*52]
addps m0, [bufq+4*52]
mova [outq+1664], m0
mulps m3, [winq+4*16]
addps m3, [bufq+4*16]
mova [outq+512], m3
mulps m0, m2, [winq+4*132]
mova [bufq+4*52], m0
mulps m2, [winq+4*96]
mova [bufq+4*16], m2
RET
%endmacro
INIT_XMM sse
DEFINE_FOUR_IMDCT
INIT_XMM avx
DEFINE_FOUR_IMDCT

87
libavcodec/x86/mpegaudiodec_mmx.c
View File

@ -29,6 +29,12 @@ void ff_imdct36_float_sse2(float *out, float *buf, float *in, float *win);
void ff_imdct36_float_sse3(float *out, float *buf, float *in, float *win); void ff_imdct36_float_sse3(float *out, float *buf, float *in, float *win);
void ff_imdct36_float_ssse3(float *out, float *buf, float *in, float *win); void ff_imdct36_float_ssse3(float *out, float *buf, float *in, float *win);
void ff_imdct36_float_avx(float *out, float *buf, float *in, float *win); void ff_imdct36_float_avx(float *out, float *buf, float *in, float *win);
void ff_four_imdct36_float_sse(float *out, float *buf, float *in, float *win,
float *tmpbuf);
void ff_four_imdct36_float_avx(float *out, float *buf, float *in, float *win,
float *tmpbuf);
DECLARE_ALIGNED(16, static float, mdct_win_sse)[2][4][4*40];
#define MACS(rt, ra, rb) rt+=(ra)*(rb) #define MACS(rt, ra, rb) rt+=(ra)*(rb)
#define MLSS(rt, ra, rb) rt-=(ra)*(rb) #define MLSS(rt, ra, rb) rt-=(ra)*(rb)
@ -153,26 +159,79 @@ static void apply_window_mp3(float *in, float *win, int *unused, float *out,
*out = sum; *out = sum;
} }
#define DECL_IMDCT_BLOCKS(CPU1, CPU2) \
static void imdct36_blocks_ ## CPU1(float *out, float *buf, float *in, \
int count, int switch_point, int block_type) \
{ \
int align_end = count - (count & 3); \
int j; \
for (j = 0; j < align_end; j+= 4) { \
LOCAL_ALIGNED_16(float, tmpbuf, [1024]); \
float *win = mdct_win_sse[switch_point && j < 4][block_type]; \
/* apply window & overlap with previous buffer */ \
\
/* select window */ \
ff_four_imdct36_float_ ## CPU2(out, buf, in, win, tmpbuf); \
in += 4*18; \
buf += 4*18; \
out += 4; \
} \
for (; j < count; j++) { \
/* apply window & overlap with previous buffer */ \
\
/* select window */ \
int win_idx = (switch_point && j < 2) ? 0 : block_type; \
float *win = ff_mdct_win_float[win_idx + (4 & -(j & 1))]; \
\
ff_imdct36_float_ ## CPU1(out, buf, in, win); \
\
in += 18; \
buf++; \
out++; \
} \
}
DECL_IMDCT_BLOCKS(sse,sse)
DECL_IMDCT_BLOCKS(sse2,sse)
DECL_IMDCT_BLOCKS(sse3,sse)
DECL_IMDCT_BLOCKS(ssse3,sse)
DECL_IMDCT_BLOCKS(avx,avx)
void ff_mpadsp_init_mmx(MPADSPContext *s) void ff_mpadsp_init_mmx(MPADSPContext *s)
{ {
int mm_flags = av_get_cpu_flags(); int mm_flags = av_get_cpu_flags();
int i, j;
for (j = 0; j < 4; j++) {
for (i = 0; i < 40; i ++) {
mdct_win_sse[0][j][4*i ] = ff_mdct_win_float[j ][i];
mdct_win_sse[0][j][4*i + 1] = ff_mdct_win_float[j + 4][i];
mdct_win_sse[0][j][4*i + 2] = ff_mdct_win_float[j ][i];
mdct_win_sse[0][j][4*i + 3] = ff_mdct_win_float[j + 4][i];
mdct_win_sse[1][j][4*i ] = ff_mdct_win_float[0 ][i];
mdct_win_sse[1][j][4*i + 1] = ff_mdct_win_float[4 ][i];
mdct_win_sse[1][j][4*i + 2] = ff_mdct_win_float[j ][i];
mdct_win_sse[1][j][4*i + 3] = ff_mdct_win_float[j + 4][i];
}
}
if (mm_flags & AV_CPU_FLAG_SSE2) { if (mm_flags & AV_CPU_FLAG_SSE2) {
s->apply_window_float = apply_window_mp3; s->apply_window_float = apply_window_mp3;
} }
if (HAVE_YASM && mm_flags & AV_CPU_FLAG_AVX && HAVE_AVX) { #if HAVE_YASM
s->imdct36_float = ff_imdct36_float_avx; if (mm_flags & AV_CPU_FLAG_AVX && HAVE_AVX) {
} s->imdct36_blocks_float = imdct36_blocks_avx;
else if (HAVE_YASM && mm_flags & AV_CPU_FLAG_SSSE3 && HAVE_SSE) { #if HAVE_SSE
s->imdct36_float = ff_imdct36_float_ssse3; } else if (mm_flags & AV_CPU_FLAG_SSSE3) {
} s->imdct36_blocks_float = imdct36_blocks_ssse3;
else if (HAVE_YASM && mm_flags & AV_CPU_FLAG_SSE3 && HAVE_SSE) { } else if (mm_flags & AV_CPU_FLAG_SSE3) {
s->imdct36_float = ff_imdct36_float_sse3; s->imdct36_blocks_float = imdct36_blocks_sse3;
} } else if (mm_flags & AV_CPU_FLAG_SSE2) {
else if (HAVE_YASM && mm_flags & AV_CPU_FLAG_SSE2 && HAVE_SSE) { s->imdct36_blocks_float = imdct36_blocks_sse2;
s->imdct36_float = ff_imdct36_float_sse2; } else if (mm_flags & AV_CPU_FLAG_SSE) {
} s->imdct36_blocks_float = imdct36_blocks_sse;
else if (HAVE_YASM && mm_flags & AV_CPU_FLAG_SSE && HAVE_SSE) { #endif /* HAVE_SSE */
s->imdct36_float = ff_imdct36_float_sse;
} }
#endif /* HAVE_YASM */
} }

2
libavutil/x86/x86inc.asm
View File

@ -931,6 +931,8 @@ AVX_INSTR minpd, 1, 0, 1
AVX_INSTR minps, 1, 0, 1 AVX_INSTR minps, 1, 0, 1
AVX_INSTR minsd, 1, 0, 1 AVX_INSTR minsd, 1, 0, 1
AVX_INSTR minss, 1, 0, 1 AVX_INSTR minss, 1, 0, 1
AVX_INSTR movhlps, 1, 0, 0
AVX_INSTR movlhps, 1, 0, 0
AVX_INSTR movsd, 1, 0, 0 AVX_INSTR movsd, 1, 0, 0
AVX_INSTR movss, 1, 0, 0 AVX_INSTR movss, 1, 0, 0
AVX_INSTR mpsadbw, 0, 1, 0 AVX_INSTR mpsadbw, 0, 1, 0

3
libswscale/Makefile
View File

@ -19,7 +19,8 @@ OBJS-$(HAVE_MMX) += x86/rgb2rgb.o \
x86/swscale_mmx.o \ x86/swscale_mmx.o \
x86/yuv2rgb_mmx.o x86/yuv2rgb_mmx.o
OBJS-$(HAVE_VIS) += sparc/yuv2rgb_vis.o OBJS-$(HAVE_VIS) += sparc/yuv2rgb_vis.o
MMX-OBJS-$(HAVE_YASM) += x86/output.o \ MMX-OBJS-$(HAVE_YASM) += x86/input.o \
x86/output.o \
x86/scale.o x86/scale.o
$(SUBDIR)x86/swscale_mmx.o: CFLAGS += $(NOREDZONE_FLAGS) $(SUBDIR)x86/swscale_mmx.o: CFLAGS += $(NOREDZONE_FLAGS)

79
libswscale/colorspace-test.c
View File

@ -27,19 +27,19 @@
#include "swscale.h" #include "swscale.h"
#include "rgb2rgb.h" #include "rgb2rgb.h"
#define SIZE 1000 #define SIZE 1000
#define srcByte 0x55 #define srcByte 0x55
#define dstByte 0xBB #define dstByte 0xBB
#define FUNC(s,d,n) {s,d,#n,n} #define FUNC(s, d, n) { s, d, #n, n }
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
int i, funcNum; int i, funcNum;
uint8_t *srcBuffer = av_malloc(SIZE); uint8_t *srcBuffer = av_malloc(SIZE);
uint8_t *dstBuffer = av_malloc(SIZE); uint8_t *dstBuffer = av_malloc(SIZE);
int failedNum=0; int failedNum = 0;
int passedNum=0; int passedNum = 0;
if (!srcBuffer || !dstBuffer) if (!srcBuffer || !dstBuffer)
return -1; return -1;
@ -47,7 +47,7 @@ int main(int argc, char **argv)
av_log(NULL, AV_LOG_INFO, "memory corruption test ...\n"); av_log(NULL, AV_LOG_INFO, "memory corruption test ...\n");
sws_rgb2rgb_init(); sws_rgb2rgb_init();
for(funcNum=0; ; funcNum++) { for (funcNum = 0; ; funcNum++) {
struct func_info_s { struct func_info_s {
int src_bpp; int src_bpp;
int dst_bpp; int dst_bpp;
@ -85,67 +85,78 @@ int main(int argc, char **argv)
FUNC(0, 0, NULL) FUNC(0, 0, NULL)
}; };
int width; int width;
int failed=0; int failed = 0;
int srcBpp=0; int srcBpp = 0;
int dstBpp=0; int dstBpp = 0;
if (!func_info[funcNum].func) break; if (!func_info[funcNum].func)
break;
av_log(NULL, AV_LOG_INFO,"."); av_log(NULL, AV_LOG_INFO, ".");
memset(srcBuffer, srcByte, SIZE); memset(srcBuffer, srcByte, SIZE);
for(width=63; width>0; width--) { for (width = 63; width > 0; width--) {
int dstOffset; int dstOffset;
for(dstOffset=128; dstOffset<196; dstOffset+=4) { for (dstOffset = 128; dstOffset < 196; dstOffset += 4) {
int srcOffset; int srcOffset;
memset(dstBuffer, dstByte, SIZE); memset(dstBuffer, dstByte, SIZE);
for(srcOffset=128; srcOffset<196; srcOffset+=4) { for (srcOffset = 128; srcOffset < 196; srcOffset += 4) {
uint8_t *src= srcBuffer+srcOffset; uint8_t *src = srcBuffer + srcOffset;
uint8_t *dst= dstBuffer+dstOffset; uint8_t *dst = dstBuffer + dstOffset;
const char *name=NULL; const char *name = NULL;
if(failed) break; //don't fill the screen with shit ... // don't fill the screen with shit ...
if (failed)
break;
srcBpp = func_info[funcNum].src_bpp; srcBpp = func_info[funcNum].src_bpp;
dstBpp = func_info[funcNum].dst_bpp; dstBpp = func_info[funcNum].dst_bpp;
name = func_info[funcNum].name; name = func_info[funcNum].name;
func_info[funcNum].func(src, dst, width*srcBpp); func_info[funcNum].func(src, dst, width * srcBpp);
if(!srcBpp) break; if (!srcBpp)
break;
for(i=0; i<SIZE; i++) { for (i = 0; i < SIZE; i++) {
if(srcBuffer[i]!=srcByte) { if (srcBuffer[i] != srcByte) {
av_log(NULL, AV_LOG_INFO, "src damaged at %d w:%d src:%d dst:%d %s\n", av_log(NULL, AV_LOG_INFO,
"src damaged at %d w:%d src:%d dst:%d %s\n",
i, width, srcOffset, dstOffset, name); i, width, srcOffset, dstOffset, name);
failed=1; failed = 1;
break; break;
} }
} }
for(i=0; i<dstOffset; i++) { for (i = 0; i < dstOffset; i++) {
if(dstBuffer[i]!=dstByte) { if (dstBuffer[i] != dstByte) {
av_log(NULL, AV_LOG_INFO, "dst damaged at %d w:%d src:%d dst:%d %s\n", av_log(NULL, AV_LOG_INFO,
"dst damaged at %d w:%d src:%d dst:%d %s\n",
i, width, srcOffset, dstOffset, name); i, width, srcOffset, dstOffset, name);
failed=1; failed = 1;
break; break;
} }
} }
for(i=dstOffset + width*dstBpp; i<SIZE; i++) { for (i = dstOffset + width * dstBpp; i < SIZE; i++) {
if(dstBuffer[i]!=dstByte) { if (dstBuffer[i] != dstByte) {
av_log(NULL, AV_LOG_INFO, "dst damaged at %d w:%d src:%d dst:%d %s\n", av_log(NULL, AV_LOG_INFO,
"dst damaged at %d w:%d src:%d dst:%d %s\n",
i, width, srcOffset, dstOffset, name); i, width, srcOffset, dstOffset, name);
failed=1; failed = 1;
break; break;
} }
} }
} }
} }
} }
if(failed) failedNum++; if (failed)
else if(srcBpp) passedNum++; failedNum++;
else if (srcBpp)
passedNum++;
} }
av_log(NULL, AV_LOG_INFO, "\n%d converters passed, %d converters randomly overwrote memory\n", passedNum, failedNum); av_log(NULL, AV_LOG_INFO,
"\n%d converters passed, %d converters randomly overwrote memory\n",
passedNum, failedNum);
return failedNum; return failedNum;
} }

19
libswscale/ppc/yuv2rgb_altivec.h
View File

@ -24,13 +24,18 @@
#ifndef SWSCALE_PPC_YUV2RGB_ALTIVEC_H #ifndef SWSCALE_PPC_YUV2RGB_ALTIVEC_H
#define SWSCALE_PPC_YUV2RGB_ALTIVEC_H #define SWSCALE_PPC_YUV2RGB_ALTIVEC_H
#define YUV2PACKEDX_HEADER(suffix) \ #define YUV2PACKEDX_HEADER(suffix) \
void ff_yuv2 ## suffix ## _X_altivec(SwsContext *c, const int16_t *lumFilter, \ void ff_yuv2 ## suffix ## _X_altivec(SwsContext *c, \
const int16_t **lumSrc, int lumFilterSize, \ const int16_t *lumFilter, \
const int16_t *chrFilter, const int16_t **chrUSrc, \ const int16_t **lumSrc, \
const int16_t **chrVSrc, int chrFilterSize, \ int lumFilterSize, \
const int16_t **alpSrc, uint8_t *dest, \ const int16_t *chrFilter, \
int dstW, int dstY); const int16_t **chrUSrc, \
const int16_t **chrVSrc, \
int chrFilterSize, \
const int16_t **alpSrc, \
uint8_t *dest, \
int dstW, int dstY);
YUV2PACKEDX_HEADER(abgr); YUV2PACKEDX_HEADER(abgr);
YUV2PACKEDX_HEADER(bgra); YUV2PACKEDX_HEADER(bgra);

30
libswscale/rgb2rgb.h
View File

@ -36,32 +36,33 @@ extern void (*rgb24tobgr32)(const uint8_t *src, uint8_t *dst, int src_size);
extern void (*rgb24tobgr16)(const uint8_t *src, uint8_t *dst, int src_size); extern void (*rgb24tobgr16)(const uint8_t *src, uint8_t *dst, int src_size);
extern void (*rgb24tobgr15)(const uint8_t *src, uint8_t *dst, int src_size); extern void (*rgb24tobgr15)(const uint8_t *src, uint8_t *dst, int src_size);
extern void (*rgb32tobgr24)(const uint8_t *src, uint8_t *dst, int src_size); extern void (*rgb32tobgr24)(const uint8_t *src, uint8_t *dst, int src_size);
extern void (*rgb32to16) (const uint8_t *src, uint8_t *dst, int src_size); extern void (*rgb32to16)(const uint8_t *src, uint8_t *dst, int src_size);
extern void (*rgb32to15) (const uint8_t *src, uint8_t *dst, int src_size); extern void (*rgb32to15)(const uint8_t *src, uint8_t *dst, int src_size);
extern void (*rgb15to16) (const uint8_t *src, uint8_t *dst, int src_size); extern void (*rgb15to16)(const uint8_t *src, uint8_t *dst, int src_size);
extern void (*rgb15tobgr24)(const uint8_t *src, uint8_t *dst, int src_size); extern void (*rgb15tobgr24)(const uint8_t *src, uint8_t *dst, int src_size);
extern void (*rgb15to32) (const uint8_t *src, uint8_t *dst, int src_size); extern void (*rgb15to32)(const uint8_t *src, uint8_t *dst, int src_size);
extern void (*rgb16to15) (const uint8_t *src, uint8_t *dst, int src_size); extern void (*rgb16to15)(const uint8_t *src, uint8_t *dst, int src_size);
extern void (*rgb16tobgr24)(const uint8_t *src, uint8_t *dst, int src_size); extern void (*rgb16tobgr24)(const uint8_t *src, uint8_t *dst, int src_size);
extern void (*rgb16to32) (const uint8_t *src, uint8_t *dst, int src_size); extern void (*rgb16to32)(const uint8_t *src, uint8_t *dst, int src_size);
extern void (*rgb24tobgr24)(const uint8_t *src, uint8_t *dst, int src_size); extern void (*rgb24tobgr24)(const uint8_t *src, uint8_t *dst, int src_size);
extern void (*rgb24to16) (const uint8_t *src, uint8_t *dst, int src_size); extern void (*rgb24to16)(const uint8_t *src, uint8_t *dst, int src_size);
extern void (*rgb24to15) (const uint8_t *src, uint8_t *dst, int src_size); extern void (*rgb24to15)(const uint8_t *src, uint8_t *dst, int src_size);
extern void (*shuffle_bytes_2103)(const uint8_t *src, uint8_t *dst, int src_size);
extern void (*rgb32tobgr16)(const uint8_t *src, uint8_t *dst, int src_size); extern void (*rgb32tobgr16)(const uint8_t *src, uint8_t *dst, int src_size);
extern void (*rgb32tobgr15)(const uint8_t *src, uint8_t *dst, int src_size); extern void (*rgb32tobgr15)(const uint8_t *src, uint8_t *dst, int src_size);
void rgb24to32 (const uint8_t *src, uint8_t *dst, int src_size); extern void (*shuffle_bytes_2103)(const uint8_t *src, uint8_t *dst, int src_size);
void rgb32to24 (const uint8_t *src, uint8_t *dst, int src_size);
void rgb24to32(const uint8_t *src, uint8_t *dst, int src_size);
void rgb32to24(const uint8_t *src, uint8_t *dst, int src_size);
void rgb16tobgr32(const uint8_t *src, uint8_t *dst, int src_size); void rgb16tobgr32(const uint8_t *src, uint8_t *dst, int src_size);
void rgb16to24 (const uint8_t *src, uint8_t *dst, int src_size); void rgb16to24(const uint8_t *src, uint8_t *dst, int src_size);
void rgb16tobgr16(const uint8_t *src, uint8_t *dst, int src_size); void rgb16tobgr16(const uint8_t *src, uint8_t *dst, int src_size);
void rgb16tobgr15(const uint8_t *src, uint8_t *dst, int src_size); void rgb16tobgr15(const uint8_t *src, uint8_t *dst, int src_size);
void rgb15tobgr32(const uint8_t *src, uint8_t *dst, int src_size); void rgb15tobgr32(const uint8_t *src, uint8_t *dst, int src_size);
void rgb15to24 (const uint8_t *src, uint8_t *dst, int src_size); void rgb15to24(const uint8_t *src, uint8_t *dst, int src_size);
void rgb15tobgr16(const uint8_t *src, uint8_t *dst, int src_size); void rgb15tobgr16(const uint8_t *src, uint8_t *dst, int src_size);
void rgb15tobgr15(const uint8_t *src, uint8_t *dst, int src_size); void rgb15tobgr15(const uint8_t *src, uint8_t *dst, int src_size);
void bgr8torgb8 (const uint8_t *src, uint8_t *dst, int src_size); void bgr8torgb8(const uint8_t *src, uint8_t *dst, int src_size);
void shuffle_bytes_0321(const uint8_t *src, uint8_t *dst, int src_size); void shuffle_bytes_0321(const uint8_t *src, uint8_t *dst, int src_size);
void shuffle_bytes_1230(const uint8_t *src, uint8_t *dst, int src_size); void shuffle_bytes_1230(const uint8_t *src, uint8_t *dst, int src_size);
@ -138,7 +139,6 @@ extern void (*yvu9_to_yuy2)(const uint8_t *src1, const uint8_t *src2, const uint
int srcStride1, int srcStride2, int srcStride1, int srcStride2,
int srcStride3, int dstStride); int srcStride3, int dstStride);
extern void (*uyvytoyuv420)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src, extern void (*uyvytoyuv420)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src,
int width, int height, int width, int height,
int lumStride, int chromStride, int srcStride); int lumStride, int chromStride, int srcStride);

184
libswscale/swscale-test.c
View File

@ -35,33 +35,32 @@
/* HACK Duplicated from swscale_internal.h. /* HACK Duplicated from swscale_internal.h.
* Should be removed when a cleaner pixel format system exists. */ * Should be removed when a cleaner pixel format system exists. */
#define isGray(x) ( \ #define isGray(x) \
(x)==PIX_FMT_GRAY8 \ ((x) == PIX_FMT_GRAY8 || \
|| (x)==PIX_FMT_GRAY16BE \ (x) == PIX_FMT_Y400A || \
|| (x)==PIX_FMT_GRAY16LE \ (x) == PIX_FMT_GRAY16BE || \
) (x) == PIX_FMT_GRAY16LE)
#define hasChroma(x) (!( \ #define hasChroma(x) \
isGray(x) \ (!(isGray(x) || \
|| (x)==PIX_FMT_MONOBLACK \ (x) == PIX_FMT_MONOBLACK || \
|| (x)==PIX_FMT_MONOWHITE \ (x) == PIX_FMT_MONOWHITE))
)) #define isALPHA(x) \
#define isALPHA(x) ( \ ((x) == PIX_FMT_BGR32 || \
(x)==PIX_FMT_BGR32 \ (x) == PIX_FMT_BGR32_1 || \
|| (x)==PIX_FMT_BGR32_1 \ (x) == PIX_FMT_RGB32 || \
|| (x)==PIX_FMT_RGB32 \ (x) == PIX_FMT_RGB32_1 || \
|| (x)==PIX_FMT_RGB32_1 \ (x) == PIX_FMT_YUVA420P)
|| (x)==PIX_FMT_YUVA420P \
)
static uint64_t getSSD(uint8_t *src1, uint8_t *src2, int stride1, int stride2, int w, int h) static uint64_t getSSD(uint8_t *src1, uint8_t *src2, int stride1,
int stride2, int w, int h)
{ {
int x,y; int x, y;
uint64_t ssd=0; uint64_t ssd = 0;
for (y=0; y<h; y++) { for (y = 0; y < h; y++) {
for (x=0; x<w; x++) { for (x = 0; x < w; x++) {
int d= src1[x + y*stride1] - src2[x + y*stride2]; int d = src1[x + y * stride1] - src2[x + y * stride2];
ssd+= d*d; ssd += d * d;
} }
} }
return ssd; return ssd;
@ -86,14 +85,14 @@ static int doTest(uint8_t *ref[4], int refStride[4], int w, int h,
static int cur_srcW, cur_srcH; static int cur_srcW, cur_srcH;
static uint8_t *src[4]; static uint8_t *src[4];
static int srcStride[4]; static int srcStride[4];
uint8_t *dst[4] = {0}; uint8_t *dst[4] = { 0 };
uint8_t *out[4] = {0}; uint8_t *out[4] = { 0 };
int dstStride[4]; int dstStride[4];
int i; int i;
uint64_t ssdY, ssdU=0, ssdV=0, ssdA=0; uint64_t ssdY, ssdU = 0, ssdV = 0, ssdA = 0;
struct SwsContext *dstContext = NULL, *outContext = NULL; struct SwsContext *dstContext = NULL, *outContext = NULL;
uint32_t crc = 0; uint32_t crc = 0;
int res = 0; int res = 0;
if (cur_srcFormat != srcFormat || cur_srcW != srcW || cur_srcH != srcH) { if (cur_srcFormat != srcFormat || cur_srcW != srcW || cur_srcH != srcH) {
struct SwsContext *srcContext = NULL; struct SwsContext *srcContext = NULL;
@ -106,11 +105,10 @@ static int doTest(uint8_t *ref[4], int refStride[4], int w, int h,
for (p = 0; p < 4; p++) { for (p = 0; p < 4; p++) {
srcStride[p] = FFALIGN(srcStride[p], 16); srcStride[p] = FFALIGN(srcStride[p], 16);
if (srcStride[p]) if (srcStride[p])
src[p] = av_mallocz(srcStride[p]*srcH+16); src[p] = av_mallocz(srcStride[p] * srcH + 16);
if (srcStride[p] && !src[p]) { if (srcStride[p] && !src[p]) {
perror("Malloc"); perror("Malloc");
res = -1; res = -1;
goto end; goto end;
} }
} }
@ -121,19 +119,18 @@ static int doTest(uint8_t *ref[4], int refStride[4], int w, int h,
av_pix_fmt_descriptors[PIX_FMT_YUVA420P].name, av_pix_fmt_descriptors[PIX_FMT_YUVA420P].name,
av_pix_fmt_descriptors[srcFormat].name); av_pix_fmt_descriptors[srcFormat].name);
res = -1; res = -1;
goto end; goto end;
} }
sws_scale(srcContext, ref, refStride, 0, h, src, srcStride); sws_scale(srcContext, ref, refStride, 0, h, src, srcStride);
sws_freeContext(srcContext); sws_freeContext(srcContext);
cur_srcFormat = srcFormat; cur_srcFormat = srcFormat;
cur_srcW = srcW; cur_srcW = srcW;
cur_srcH = srcH; cur_srcH = srcH;
} }
av_image_fill_linesizes(dstStride, dstFormat, dstW); av_image_fill_linesizes(dstStride, dstFormat, dstW);
for (i=0; i<4; i++) { for (i = 0; i < 4; i++) {
/* Image buffers passed into libswscale can be allocated any way you /* Image buffers passed into libswscale can be allocated any way you
* prefer, as long as they're aligned enough for the architecture, and * prefer, as long as they're aligned enough for the architecture, and
* they're freed appropriately (such as using av_free for buffers * they're freed appropriately (such as using av_free for buffers
@ -142,7 +139,7 @@ static int doTest(uint8_t *ref[4], int refStride[4], int w, int h,
* out of bounds. */ * out of bounds. */
dstStride[i] = FFALIGN(dstStride[i], 16); dstStride[i] = FFALIGN(dstStride[i], 16);
if (dstStride[i]) if (dstStride[i])
dst[i]= av_mallocz(dstStride[i]*dstH+16); dst[i] = av_mallocz(dstStride[i] * dstH + 16);
if (dstStride[i] && !dst[i]) { if (dstStride[i] && !dst[i]) {
perror("Malloc"); perror("Malloc");
res = -1; res = -1;
@ -151,13 +148,13 @@ static int doTest(uint8_t *ref[4], int refStride[4], int w, int h,
} }
} }
dstContext= sws_getContext(srcW, srcH, srcFormat, dstW, dstH, dstFormat, flags, NULL, NULL, NULL); dstContext = sws_getContext(srcW, srcH, srcFormat, dstW, dstH, dstFormat,
flags, NULL, NULL, NULL);
if (!dstContext) { if (!dstContext) {
fprintf(stderr, "Failed to get %s ---> %s\n", fprintf(stderr, "Failed to get %s ---> %s\n",
av_pix_fmt_descriptors[srcFormat].name, av_pix_fmt_descriptors[srcFormat].name,
av_pix_fmt_descriptors[dstFormat].name); av_pix_fmt_descriptors[dstFormat].name);
res = -1; res = -1;
goto end; goto end;
} }
@ -169,9 +166,9 @@ static int doTest(uint8_t *ref[4], int refStride[4], int w, int h,
sws_scale(dstContext, src, srcStride, 0, srcH, dst, dstStride); sws_scale(dstContext, src, srcStride, 0, srcH, dst, dstStride);
for (i = 0; i < 4 && dstStride[i]; i++) { for (i = 0; i < 4 && dstStride[i]; i++)
crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), crc, dst[i], dstStride[i] * dstH); crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), crc, dst[i],
} dstStride[i] * dstH);
if (r && crc == r->crc) { if (r && crc == r->crc) {
ssdY = r->ssdY; ssdY = r->ssdY;
@ -179,61 +176,60 @@ static int doTest(uint8_t *ref[4], int refStride[4], int w, int h,
ssdV = r->ssdV; ssdV = r->ssdV;
ssdA = r->ssdA; ssdA = r->ssdA;
} else { } else {
for (i=0; i<4; i++) { for (i = 0; i < 4; i++) {
refStride[i] = FFALIGN(refStride[i], 16); refStride[i] = FFALIGN(refStride[i], 16);
if (refStride[i]) if (refStride[i])
out[i]= av_mallocz(refStride[i]*h); out[i] = av_mallocz(refStride[i] * h);
if (refStride[i] && !out[i]) { if (refStride[i] && !out[i]) {
perror("Malloc"); perror("Malloc");
res = -1; res = -1;
goto end; goto end;
} }
} }
outContext= sws_getContext(dstW, dstH, dstFormat, w, h, PIX_FMT_YUVA420P, SWS_BILINEAR, NULL, NULL, NULL); outContext = sws_getContext(dstW, dstH, dstFormat, w, h,
PIX_FMT_YUVA420P, SWS_BILINEAR,
NULL, NULL, NULL);
if (!outContext) { if (!outContext) {
fprintf(stderr, "Failed to get %s ---> %s\n", fprintf(stderr, "Failed to get %s ---> %s\n",
av_pix_fmt_descriptors[dstFormat].name, av_pix_fmt_descriptors[dstFormat].name,
av_pix_fmt_descriptors[PIX_FMT_YUVA420P].name); av_pix_fmt_descriptors[PIX_FMT_YUVA420P].name);
res = -1; res = -1;
goto end; goto end;
} }
sws_scale(outContext, dst, dstStride, 0, dstH, out, refStride); sws_scale(outContext, dst, dstStride, 0, dstH, out, refStride);
ssdY= getSSD(ref[0], out[0], refStride[0], refStride[0], w, h); ssdY = getSSD(ref[0], out[0], refStride[0], refStride[0], w, h);
if (hasChroma(srcFormat) && hasChroma(dstFormat)) { if (hasChroma(srcFormat) && hasChroma(dstFormat)) {
//FIXME check that output is really gray //FIXME check that output is really gray
ssdU= getSSD(ref[1], out[1], refStride[1], refStride[1], (w+1)>>1, (h+1)>>1); ssdU = getSSD(ref[1], out[1], refStride[1], refStride[1],
ssdV= getSSD(ref[2], out[2], refStride[2], refStride[2], (w+1)>>1, (h+1)>>1); (w + 1) >> 1, (h + 1) >> 1);
ssdV = getSSD(ref[2], out[2], refStride[2], refStride[2],
(w + 1) >> 1, (h + 1) >> 1);
} }
if (isALPHA(srcFormat) && isALPHA(dstFormat)) if (isALPHA(srcFormat) && isALPHA(dstFormat))
ssdA= getSSD(ref[3], out[3], refStride[3], refStride[3], w, h); ssdA = getSSD(ref[3], out[3], refStride[3], refStride[3], w, h);
ssdY/= w*h; ssdY /= w * h;
ssdU/= w*h/4; ssdU /= w * h / 4;
ssdV/= w*h/4; ssdV /= w * h / 4;
ssdA/= w*h; ssdA /= w * h;
sws_freeContext(outContext); sws_freeContext(outContext);
for (i=0; i<4; i++) { for (i = 0; i < 4; i++)
if (refStride[i]) if (refStride[i])
av_free(out[i]); av_free(out[i]);
}
} }
printf(" CRC=%08x SSD=%5"PRId64",%5"PRId64",%5"PRId64",%5"PRId64"\n", printf(" CRC=%08x SSD=%5"PRId64 ",%5"PRId64 ",%5"PRId64 ",%5"PRId64 "\n",
crc, ssdY, ssdU, ssdV, ssdA); crc, ssdY, ssdU, ssdV, ssdA);
end: end:
sws_freeContext(dstContext); sws_freeContext(dstContext);
for (i=0; i<4; i++) { for (i = 0; i < 4; i++)
if (dstStride[i]) if (dstStride[i])
av_free(dst[i]); av_free(dst[i]);
}
return res; return res;
} }
@ -242,18 +238,18 @@ static void selfTest(uint8_t *ref[4], int refStride[4], int w, int h,
enum PixelFormat srcFormat_in, enum PixelFormat srcFormat_in,
enum PixelFormat dstFormat_in) enum PixelFormat dstFormat_in)
{ {
const int flags[] = { SWS_FAST_BILINEAR, const int flags[] = { SWS_FAST_BILINEAR, SWS_BILINEAR, SWS_BICUBIC,
SWS_BILINEAR, SWS_BICUBIC, SWS_X, SWS_POINT, SWS_AREA, 0 };
SWS_X , SWS_POINT , SWS_AREA, 0 }; const int srcW = w;
const int srcW = w; const int srcH = h;
const int srcH = h; const int dstW[] = { srcW - srcW / 3, srcW, srcW + srcW / 3, 0 };
const int dstW[] = { srcW - srcW/3, srcW, srcW + srcW/3, 0 }; const int dstH[] = { srcH - srcH / 3, srcH, srcH + srcH / 3, 0 };
const int dstH[] = { srcH - srcH/3, srcH, srcH + srcH/3, 0 };
enum PixelFormat srcFormat, dstFormat; enum PixelFormat srcFormat, dstFormat;
for (srcFormat = srcFormat_in != PIX_FMT_NONE ? srcFormat_in : 0; for (srcFormat = srcFormat_in != PIX_FMT_NONE ? srcFormat_in : 0;
srcFormat < PIX_FMT_NB; srcFormat++) { srcFormat < PIX_FMT_NB; srcFormat++) {
if (!sws_isSupportedInput(srcFormat) || !sws_isSupportedOutput(srcFormat)) if (!sws_isSupportedInput(srcFormat) ||
!sws_isSupportedOutput(srcFormat))
continue; continue;
for (dstFormat = dstFormat_in != PIX_FMT_NONE ? dstFormat_in : 0; for (dstFormat = dstFormat_in != PIX_FMT_NONE ? dstFormat_in : 0;
@ -261,7 +257,8 @@ static void selfTest(uint8_t *ref[4], int refStride[4], int w, int h,
int i, j, k; int i, j, k;
int res = 0; int res = 0;
if (!sws_isSupportedInput(dstFormat) || !sws_isSupportedOutput(dstFormat)) if (!sws_isSupportedInput(dstFormat) ||
!sws_isSupportedOutput(dstFormat))
continue; continue;
printf("%s -> %s\n", printf("%s -> %s\n",
@ -269,14 +266,13 @@ static void selfTest(uint8_t *ref[4], int refStride[4], int w, int h,
av_pix_fmt_descriptors[dstFormat].name); av_pix_fmt_descriptors[dstFormat].name);
fflush(stdout); fflush(stdout);
for (k = 0; flags[k] && !res; k++) { for (k = 0; flags[k] && !res; k++)
for (i = 0; dstW[i] && !res; i++) for (i = 0; dstW[i] && !res; i++)
for (j = 0; dstH[j] && !res; j++) for (j = 0; dstH[j] && !res; j++)
res = doTest(ref, refStride, w, h, res = doTest(ref, refStride, w, h,
srcFormat, dstFormat, srcFormat, dstFormat,
srcW, srcH, dstW[i], dstH[j], flags[k], srcW, srcH, dstW[i], dstH[j], flags[k],
NULL); NULL);
}
if (dstFormat_in != PIX_FMT_NONE) if (dstFormat_in != PIX_FMT_NONE)
break; break;
} }
@ -302,13 +298,14 @@ static int fileTest(uint8_t *ref[4], int refStride[4], int w, int h, FILE *fp,
int flags; int flags;
int ret; int ret;
ret = sscanf(buf, " %12s %dx%d -> %12s %dx%d flags=%d CRC=%x" ret = sscanf(buf,
" SSD=%"PRId64", %"PRId64", %"PRId64", %"PRId64"\n", " %12s %dx%d -> %12s %dx%d flags=%d CRC=%x"
srcStr, &srcW, &srcH, dstStr, &dstW, &dstH, " SSD=%"PRId64 ", %"PRId64 ", %"PRId64 ", %"PRId64 "\n",
&flags, &r.crc, &r.ssdY, &r.ssdU, &r.ssdV, &r.ssdA); srcStr, &srcW, &srcH, dstStr, &dstW, &dstH,
&flags, &r.crc, &r.ssdY, &r.ssdU, &r.ssdV, &r.ssdA);
if (ret != 12) { if (ret != 12) {
srcStr[0] = dstStr[0] = 0; srcStr[0] = dstStr[0] = 0;
ret = sscanf(buf, "%12s -> %12s\n", srcStr, dstStr); ret = sscanf(buf, "%12s -> %12s\n", srcStr, dstStr);
} }
srcFormat = av_get_pix_fmt(srcStr); srcFormat = av_get_pix_fmt(srcStr);
@ -342,12 +339,12 @@ int main(int argc, char **argv)
{ {
enum PixelFormat srcFormat = PIX_FMT_NONE; enum PixelFormat srcFormat = PIX_FMT_NONE;
enum PixelFormat dstFormat = PIX_FMT_NONE; enum PixelFormat dstFormat = PIX_FMT_NONE;
uint8_t *rgb_data = av_malloc (W*H*4); uint8_t *rgb_data = av_malloc(W * H * 4);
uint8_t *rgb_src[3]= {rgb_data, NULL, NULL}; uint8_t *rgb_src[3] = { rgb_data, NULL, NULL };
int rgb_stride[3]={4*W, 0, 0}; int rgb_stride[3] = { 4 * W, 0, 0 };
uint8_t *data = av_malloc (4*W*H); uint8_t *data = av_malloc(4 * W * H);
uint8_t *src[4]= {data, data+W*H, data+W*H*2, data+W*H*3}; uint8_t *src[4] = { data, data + W * H, data + W * H * 2, data + W * H * 3 };
int stride[4]={W, W, W, W}; int stride[4] = { W, W, W, W };
int x, y; int x, y;
struct SwsContext *sws; struct SwsContext *sws;
AVLFG rand; AVLFG rand;
@ -357,41 +354,40 @@ int main(int argc, char **argv)
if (!rgb_data || !data) if (!rgb_data || !data)
return -1; return -1;
sws= sws_getContext(W/12, H/12, PIX_FMT_RGB32, W, H, PIX_FMT_YUVA420P, SWS_BILINEAR, NULL, NULL, NULL); sws = sws_getContext(W / 12, H / 12, PIX_FMT_RGB32, W, H,
PIX_FMT_YUVA420P, SWS_BILINEAR, NULL, NULL, NULL);
av_lfg_init(&rand, 1); av_lfg_init(&rand, 1);
for (y=0; y<H; y++) { for (y = 0; y < H; y++)
for (x=0; x<W*4; x++) { for (x = 0; x < W * 4; x++)
rgb_data[ x + y*4*W]= av_lfg_get(&rand); rgb_data[ x + y * 4 * W] = av_lfg_get(&rand);
}
}
sws_scale(sws, rgb_src, rgb_stride, 0, H, src, stride); sws_scale(sws, rgb_src, rgb_stride, 0, H, src, stride);
sws_freeContext(sws); sws_freeContext(sws);
av_free(rgb_data); av_free(rgb_data);
for (i = 1; i < argc; i += 2) { for (i = 1; i < argc; i += 2) {
if (argv[i][0] != '-' || i+1 == argc) if (argv[i][0] != '-' || i + 1 == argc)
goto bad_option; goto bad_option;
if (!strcmp(argv[i], "-ref")) { if (!strcmp(argv[i], "-ref")) {
FILE *fp = fopen(argv[i+1], "r"); FILE *fp = fopen(argv[i + 1], "r");
if (!fp) { if (!fp) {
fprintf(stderr, "could not open '%s'\n", argv[i+1]); fprintf(stderr, "could not open '%s'\n", argv[i + 1]);
goto error; goto error;
} }
res = fileTest(src, stride, W, H, fp, srcFormat, dstFormat); res = fileTest(src, stride, W, H, fp, srcFormat, dstFormat);
fclose(fp); fclose(fp);
goto end; goto end;
} else if (!strcmp(argv[i], "-src")) { } else if (!strcmp(argv[i], "-src")) {
srcFormat = av_get_pix_fmt(argv[i+1]); srcFormat = av_get_pix_fmt(argv[i + 1]);
if (srcFormat == PIX_FMT_NONE) { if (srcFormat == PIX_FMT_NONE) {
fprintf(stderr, "invalid pixel format %s\n", argv[i+1]); fprintf(stderr, "invalid pixel format %s\n", argv[i + 1]);
return -1; return -1;
} }
} else if (!strcmp(argv[i], "-dst")) { } else if (!strcmp(argv[i], "-dst")) {
dstFormat = av_get_pix_fmt(argv[i+1]); dstFormat = av_get_pix_fmt(argv[i + 1]);
if (dstFormat == PIX_FMT_NONE) { if (dstFormat == PIX_FMT_NONE) {
fprintf(stderr, "invalid pixel format %s\n", argv[i+1]); fprintf(stderr, "invalid pixel format %s\n", argv[i + 1]);
return -1; return -1;
} }
} else { } else {

16
libswscale/swscale.c
View File

@ -1637,12 +1637,16 @@ rgb16_32_wrapper(PIX_FMT_RGB32, rgb32, 0, 0, 16, 0, 0x00FF, 0xFF00, 0xFF0
rgb16_32_wrapper(PIX_FMT_RGB32_1, rgb321, 0, 0, 16, 8, 0x00FF, 0xFF00, 0xFF0000, 8, 0, 8, RGB2YUV_SHIFT+8) rgb16_32_wrapper(PIX_FMT_RGB32_1, rgb321, 0, 0, 16, 8, 0x00FF, 0xFF00, 0xFF0000, 8, 0, 8, RGB2YUV_SHIFT+8)
rgb16_32_wrapper(PIX_FMT_BGR565LE, bgr16le, 0, 0, 0, 0, 0x001F, 0x07E0, 0xF800, 11, 5, 0, RGB2YUV_SHIFT+8) rgb16_32_wrapper(PIX_FMT_BGR565LE, bgr16le, 0, 0, 0, 0, 0x001F, 0x07E0, 0xF800, 11, 5, 0, RGB2YUV_SHIFT+8)
rgb16_32_wrapper(PIX_FMT_BGR555LE, bgr15le, 0, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, 10, 5, 0, RGB2YUV_SHIFT+7) rgb16_32_wrapper(PIX_FMT_BGR555LE, bgr15le, 0, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, 10, 5, 0, RGB2YUV_SHIFT+7)
rgb16_32_wrapper(PIX_FMT_BGR444LE, bgr12le, 0, 0, 0, 0, 0x000F, 0x00F0, 0x0F00, 8, 4, 0, RGB2YUV_SHIFT+4)
rgb16_32_wrapper(PIX_FMT_RGB565LE, rgb16le, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, 0, 5, 11, RGB2YUV_SHIFT+8) rgb16_32_wrapper(PIX_FMT_RGB565LE, rgb16le, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, 0, 5, 11, RGB2YUV_SHIFT+8)
rgb16_32_wrapper(PIX_FMT_RGB555LE, rgb15le, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, 0, 5, 10, RGB2YUV_SHIFT+7) rgb16_32_wrapper(PIX_FMT_RGB555LE, rgb15le, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, 0, 5, 10, RGB2YUV_SHIFT+7)
rgb16_32_wrapper(PIX_FMT_RGB444LE, rgb12le, 0, 0, 0, 0, 0x0F00, 0x00F0, 0x000F, 0, 4, 8, RGB2YUV_SHIFT+4)
rgb16_32_wrapper(PIX_FMT_BGR565BE, bgr16be, 0, 0, 0, 0, 0x001F, 0x07E0, 0xF800, 11, 5, 0, RGB2YUV_SHIFT+8) rgb16_32_wrapper(PIX_FMT_BGR565BE, bgr16be, 0, 0, 0, 0, 0x001F, 0x07E0, 0xF800, 11, 5, 0, RGB2YUV_SHIFT+8)
rgb16_32_wrapper(PIX_FMT_BGR555BE, bgr15be, 0, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, 10, 5, 0, RGB2YUV_SHIFT+7) rgb16_32_wrapper(PIX_FMT_BGR555BE, bgr15be, 0, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, 10, 5, 0, RGB2YUV_SHIFT+7)
rgb16_32_wrapper(PIX_FMT_BGR444BE, bgr12be, 0, 0, 0, 0, 0x000F, 0x00F0, 0x0F00, 8, 4, 0, RGB2YUV_SHIFT+4)
rgb16_32_wrapper(PIX_FMT_RGB565BE, rgb16be, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, 0, 5, 11, RGB2YUV_SHIFT+8) rgb16_32_wrapper(PIX_FMT_RGB565BE, rgb16be, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, 0, 5, 11, RGB2YUV_SHIFT+8)
rgb16_32_wrapper(PIX_FMT_RGB555BE, rgb15be, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, 0, 5, 10, RGB2YUV_SHIFT+7) rgb16_32_wrapper(PIX_FMT_RGB555BE, rgb15be, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, 0, 5, 10, RGB2YUV_SHIFT+7)
rgb16_32_wrapper(PIX_FMT_RGB444BE, rgb12be, 0, 0, 0, 0, 0x0F00, 0x00F0, 0x000F, 0, 4, 8, RGB2YUV_SHIFT+4)
static void gbr24pToUV_half_c(uint16_t *dstU, uint16_t *dstV, static void gbr24pToUV_half_c(uint16_t *dstU, uint16_t *dstV,
const uint8_t *gsrc, const uint8_t *bsrc, const uint8_t *rsrc, const uint8_t *gsrc, const uint8_t *bsrc, const uint8_t *rsrc,
@ -2887,6 +2891,8 @@ static av_cold void sws_init_swScale_c(SwsContext *c)
case PIX_FMT_BGR565BE: c->chrToYV12 = bgr16beToUV_half_c; break; case PIX_FMT_BGR565BE: c->chrToYV12 = bgr16beToUV_half_c; break;
case PIX_FMT_BGR555LE: c->chrToYV12 = bgr15leToUV_half_c; break; case PIX_FMT_BGR555LE: c->chrToYV12 = bgr15leToUV_half_c; break;
case PIX_FMT_BGR555BE: c->chrToYV12 = bgr15beToUV_half_c; break; case PIX_FMT_BGR555BE: c->chrToYV12 = bgr15beToUV_half_c; break;
case PIX_FMT_BGR444LE: c->chrToYV12 = bgr12leToUV_half_c; break;
case PIX_FMT_BGR444BE: c->chrToYV12 = bgr12beToUV_half_c; break;
case PIX_FMT_BGR32 : c->chrToYV12 = rgb32ToUV_half_c; break; case PIX_FMT_BGR32 : c->chrToYV12 = rgb32ToUV_half_c; break;
case PIX_FMT_BGR32_1 : c->chrToYV12 = rgb321ToUV_half_c; break; case PIX_FMT_BGR32_1 : c->chrToYV12 = rgb321ToUV_half_c; break;
case PIX_FMT_RGB24 : c->chrToYV12 = rgb24ToUV_half_c; break; case PIX_FMT_RGB24 : c->chrToYV12 = rgb24ToUV_half_c; break;
@ -2895,6 +2901,8 @@ static av_cold void sws_init_swScale_c(SwsContext *c)
case PIX_FMT_RGB555LE: c->chrToYV12 = rgb15leToUV_half_c; break; case PIX_FMT_RGB555LE: c->chrToYV12 = rgb15leToUV_half_c; break;
case PIX_FMT_RGB555BE: c->chrToYV12 = rgb15beToUV_half_c; break; case PIX_FMT_RGB555BE: c->chrToYV12 = rgb15beToUV_half_c; break;
case PIX_FMT_GBR24P : c->chrToYV12 = gbr24pToUV_half_c; break; case PIX_FMT_GBR24P : c->chrToYV12 = gbr24pToUV_half_c; break;
case PIX_FMT_RGB444LE: c->chrToYV12 = rgb12leToUV_half_c; break;
case PIX_FMT_RGB444BE: c->chrToYV12 = rgb12beToUV_half_c; break;
} }
} else { } else {
switch(srcFormat) { switch(srcFormat) {
@ -2909,6 +2917,8 @@ static av_cold void sws_init_swScale_c(SwsContext *c)
case PIX_FMT_BGR565BE: c->chrToYV12 = bgr16beToUV_c; break; case PIX_FMT_BGR565BE: c->chrToYV12 = bgr16beToUV_c; break;
case PIX_FMT_BGR555LE: c->chrToYV12 = bgr15leToUV_c; break; case PIX_FMT_BGR555LE: c->chrToYV12 = bgr15leToUV_c; break;
case PIX_FMT_BGR555BE: c->chrToYV12 = bgr15beToUV_c; break; case PIX_FMT_BGR555BE: c->chrToYV12 = bgr15beToUV_c; break;
case PIX_FMT_BGR444LE: c->chrToYV12 = bgr12leToUV_c; break;
case PIX_FMT_BGR444BE: c->chrToYV12 = bgr12beToUV_c; break;
case PIX_FMT_BGR32 : c->chrToYV12 = rgb32ToUV_c; break; case PIX_FMT_BGR32 : c->chrToYV12 = rgb32ToUV_c; break;
case PIX_FMT_BGR32_1 : c->chrToYV12 = rgb321ToUV_c; break; case PIX_FMT_BGR32_1 : c->chrToYV12 = rgb321ToUV_c; break;
case PIX_FMT_RGB24 : c->chrToYV12 = rgb24ToUV_c; break; case PIX_FMT_RGB24 : c->chrToYV12 = rgb24ToUV_c; break;
@ -2916,6 +2926,8 @@ static av_cold void sws_init_swScale_c(SwsContext *c)
case PIX_FMT_RGB565BE: c->chrToYV12 = rgb16beToUV_c; break; case PIX_FMT_RGB565BE: c->chrToYV12 = rgb16beToUV_c; break;
case PIX_FMT_RGB555LE: c->chrToYV12 = rgb15leToUV_c; break; case PIX_FMT_RGB555LE: c->chrToYV12 = rgb15leToUV_c; break;
case PIX_FMT_RGB555BE: c->chrToYV12 = rgb15beToUV_c; break; case PIX_FMT_RGB555BE: c->chrToYV12 = rgb15beToUV_c; break;
case PIX_FMT_RGB444LE: c->chrToYV12 = rgb12leToUV_c; break;
case PIX_FMT_RGB444BE: c->chrToYV12 = rgb12beToUV_c; break;
} }
} }
@ -2960,11 +2972,15 @@ static av_cold void sws_init_swScale_c(SwsContext *c)
case PIX_FMT_BGR565BE : c->lumToYV12 = bgr16beToY_c; break; case PIX_FMT_BGR565BE : c->lumToYV12 = bgr16beToY_c; break;
case PIX_FMT_BGR555LE : c->lumToYV12 = bgr15leToY_c; break; case PIX_FMT_BGR555LE : c->lumToYV12 = bgr15leToY_c; break;
case PIX_FMT_BGR555BE : c->lumToYV12 = bgr15beToY_c; break; case PIX_FMT_BGR555BE : c->lumToYV12 = bgr15beToY_c; break;
case PIX_FMT_BGR444LE : c->lumToYV12 = bgr12leToY_c; break;
case PIX_FMT_BGR444BE : c->lumToYV12 = bgr12beToY_c; break;
case PIX_FMT_RGB24 : c->lumToYV12 = rgb24ToY_c; break; case PIX_FMT_RGB24 : c->lumToYV12 = rgb24ToY_c; break;
case PIX_FMT_RGB565LE : c->lumToYV12 = rgb16leToY_c; break; case PIX_FMT_RGB565LE : c->lumToYV12 = rgb16leToY_c; break;
case PIX_FMT_RGB565BE : c->lumToYV12 = rgb16beToY_c; break; case PIX_FMT_RGB565BE : c->lumToYV12 = rgb16beToY_c; break;
case PIX_FMT_RGB555LE : c->lumToYV12 = rgb15leToY_c; break; case PIX_FMT_RGB555LE : c->lumToYV12 = rgb15leToY_c; break;
case PIX_FMT_RGB555BE : c->lumToYV12 = rgb15beToY_c; break; case PIX_FMT_RGB555BE : c->lumToYV12 = rgb15beToY_c; break;
case PIX_FMT_RGB444LE : c->lumToYV12 = rgb12leToY_c; break;
case PIX_FMT_RGB444BE : c->lumToYV12 = rgb12beToY_c; break;
case PIX_FMT_RGB8 : case PIX_FMT_RGB8 :
case PIX_FMT_BGR8 : case PIX_FMT_BGR8 :
case PIX_FMT_PAL8 : case PIX_FMT_PAL8 :

5
libswscale/swscale.h
View File

@ -135,7 +135,6 @@ const char *swscale_license(void);
*/ */
const int *sws_getCoefficients(int colorspace); const int *sws_getCoefficients(int colorspace);
// when used for filters they must have an odd number of elements // when used for filters they must have an odd number of elements
// coeffs cannot be shared between vectors // coeffs cannot be shared between vectors
typedef struct { typedef struct {
@ -235,9 +234,9 @@ struct SwsContext *sws_getContext(int srcW, int srcH, enum PixelFormat srcFormat
* the destination image * the destination image
* @return the height of the output slice * @return the height of the output slice
*/ */
int sws_scale(struct SwsContext *c, const uint8_t* const srcSlice[], int sws_scale(struct SwsContext *c, const uint8_t *const srcSlice[],
const int srcStride[], int srcSliceY, int srcSliceH, const int srcStride[], int srcSliceY, int srcSliceH,
uint8_t* const dst[], const int dstStride[]); uint8_t *const dst[], const int dstStride[]);
/** /**
* @param inv_table the yuv2rgb coefficients, normally ff_yuv2rgb_coeffs[x] * @param inv_table the yuv2rgb coefficients, normally ff_yuv2rgb_coeffs[x]

250
libswscale/swscale_internal.h
View File

@ -32,9 +32,9 @@
#include "libavutil/pixfmt.h" #include "libavutil/pixfmt.h"
#include "libavutil/pixdesc.h" #include "libavutil/pixdesc.h"
#define STR(s) AV_TOSTRING(s) //AV_STRINGIFY is too long #define STR(s) AV_TOSTRING(s) // AV_STRINGIFY is too long
#define FAST_BGR2YV12 //use 7-bit instead of 15-bit coefficients #define FAST_BGR2YV12 // use 7-bit instead of 15-bit coefficients
#define MAX_FILTER_SIZE 256 #define MAX_FILTER_SIZE 256
@ -47,21 +47,20 @@
#endif #endif
#if ARCH_X86_64 #if ARCH_X86_64
# define APCK_PTR2 8 # define APCK_PTR2 8
# define APCK_COEF 16 # define APCK_COEF 16
# define APCK_SIZE 24 # define APCK_SIZE 24
#else #else
# define APCK_PTR2 4 # define APCK_PTR2 4
# define APCK_COEF 8 # define APCK_COEF 8
# define APCK_SIZE 16 # define APCK_SIZE 16
#endif #endif
struct SwsContext; struct SwsContext;
typedef int (*SwsFunc)(struct SwsContext *context, const uint8_t* src[], typedef int (*SwsFunc)(struct SwsContext *context, const uint8_t *src[],
int srcStride[], int srcSliceY, int srcSliceH, int srcStride[], int srcSliceY, int srcSliceH,
uint8_t* dst[], int dstStride[]); uint8_t *dst[], int dstStride[]);
/** /**
* Write one line of horizontally scaled data to planar output * Write one line of horizontally scaled data to planar output
@ -75,8 +74,8 @@ typedef int (*SwsFunc)(struct SwsContext *context, const uint8_t* src[],
* @param dither ordered dither array of type int16_t and size 8 * @param dither ordered dither array of type int16_t and size 8
* @param offset Dither offset * @param offset Dither offset
*/ */
typedef void (*yuv2planar1_fn) (const int16_t *src, uint8_t *dest, int dstW, typedef void (*yuv2planar1_fn)(const int16_t *src, uint8_t *dest, int dstW,
const uint8_t *dither, int offset); const uint8_t *dither, int offset);
/** /**
* Write one line of horizontally scaled data to planar output * Write one line of horizontally scaled data to planar output
@ -91,9 +90,9 @@ typedef void (*yuv2planar1_fn) (const int16_t *src, uint8_t *dest, int dstW,
* @param dstW width of destination pixels * @param dstW width of destination pixels
* @param offset Dither offset * @param offset Dither offset
*/ */
typedef void (*yuv2planarX_fn) (const int16_t *filter, int filterSize, typedef void (*yuv2planarX_fn)(const int16_t *filter, int filterSize,
const int16_t **src, uint8_t *dest, int dstW, const int16_t **src, uint8_t *dest, int dstW,
const uint8_t *dither, int offset); const uint8_t *dither, int offset);
/** /**
* Write one line of horizontally scaled chroma to interleaved output * Write one line of horizontally scaled chroma to interleaved output
@ -110,9 +109,12 @@ typedef void (*yuv2planarX_fn) (const int16_t *filter, int filterSize,
* output, this is in uint16_t * output, this is in uint16_t
* @param dstW width of chroma planes * @param dstW width of chroma planes
*/ */
typedef void (*yuv2interleavedX_fn) (struct SwsContext *c, const int16_t *chrFilter, int chrFilterSize, typedef void (*yuv2interleavedX_fn)(struct SwsContext *c,
const int16_t **chrUSrc, const int16_t **chrVSrc, const int16_t *chrFilter,
uint8_t *dest, int dstW); int chrFilterSize,
const int16_t **chrUSrc,
const int16_t **chrVSrc,
uint8_t *dest, int dstW);
/** /**
* Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
@ -143,10 +145,11 @@ typedef void (*yuv2interleavedX_fn) (struct SwsContext *c, const int16_t *chrFil
* but can be used to generate comfort noise using dithering * but can be used to generate comfort noise using dithering
* for some output formats. * for some output formats.
*/ */
typedef void (*yuv2packed1_fn) (struct SwsContext *c, const int16_t *lumSrc, typedef void (*yuv2packed1_fn)(struct SwsContext *c, const int16_t *lumSrc,
const int16_t *chrUSrc[2], const int16_t *chrVSrc[2], const int16_t *chrUSrc[2],
const int16_t *alpSrc, uint8_t *dest, const int16_t *chrVSrc[2],
int dstW, int uvalpha, int y); const int16_t *alpSrc, uint8_t *dest,
int dstW, int uvalpha, int y);
/** /**
* Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
* output by doing bilinear scaling between two input lines. * output by doing bilinear scaling between two input lines.
@ -175,10 +178,12 @@ typedef void (*yuv2packed1_fn) (struct SwsContext *c, const int16_t *lumSrc,
* but can be used to generate comfort noise using dithering * but can be used to generate comfort noise using dithering
* for some output formats. * for some output formats.
*/ */
typedef void (*yuv2packed2_fn) (struct SwsContext *c, const int16_t *lumSrc[2], typedef void (*yuv2packed2_fn)(struct SwsContext *c, const int16_t *lumSrc[2],
const int16_t *chrUSrc[2], const int16_t *chrVSrc[2], const int16_t *chrUSrc[2],
const int16_t *alpSrc[2], uint8_t *dest, const int16_t *chrVSrc[2],
int dstW, int yalpha, int uvalpha, int y); const int16_t *alpSrc[2],
uint8_t *dest,
int dstW, int yalpha, int uvalpha, int y);
/** /**
* Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
* output by doing multi-point vertical scaling between input pixels. * output by doing multi-point vertical scaling between input pixels.
@ -205,12 +210,13 @@ typedef void (*yuv2packed2_fn) (struct SwsContext *c, const int16_t *lumSrc[2],
* but can be used to generate comfort noise using dithering * but can be used to generate comfort noise using dithering
* or some output formats. * or some output formats.
*/ */
typedef void (*yuv2packedX_fn) (struct SwsContext *c, const int16_t *lumFilter, typedef void (*yuv2packedX_fn)(struct SwsContext *c, const int16_t *lumFilter,
const int16_t **lumSrc, int lumFilterSize, const int16_t **lumSrc, int lumFilterSize,
const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t *chrFilter,
const int16_t **chrVSrc, int chrFilterSize, const int16_t **chrUSrc,
const int16_t **alpSrc, uint8_t *dest, const int16_t **chrVSrc, int chrFilterSize,
int dstW, int y); const int16_t **alpSrc, uint8_t *dest,
int dstW, int y);
/* This struct should be aligned on at least a 32-byte boundary. */ /* This struct should be aligned on at least a 32-byte boundary. */
typedef struct SwsContext { typedef struct SwsContext {
@ -263,12 +269,12 @@ typedef struct SwsContext {
int16_t **chrUPixBuf; ///< Ring buffer for scaled horizontal chroma plane lines to be fed to the vertical scaler. int16_t **chrUPixBuf; ///< Ring buffer for scaled horizontal chroma plane lines to be fed to the vertical scaler.
int16_t **chrVPixBuf; ///< Ring buffer for scaled horizontal chroma plane lines to be fed to the vertical scaler. int16_t **chrVPixBuf; ///< Ring buffer for scaled horizontal chroma plane lines to be fed to the vertical scaler.
int16_t **alpPixBuf; ///< Ring buffer for scaled horizontal alpha plane lines to be fed to the vertical scaler. int16_t **alpPixBuf; ///< Ring buffer for scaled horizontal alpha plane lines to be fed to the vertical scaler.
int vLumBufSize; ///< Number of vertical luma/alpha lines allocated in the ring buffer. int vLumBufSize; ///< Number of vertical luma/alpha lines allocated in the ring buffer.
int vChrBufSize; ///< Number of vertical chroma lines allocated in the ring buffer. int vChrBufSize; ///< Number of vertical chroma lines allocated in the ring buffer.
int lastInLumBuf; ///< Last scaled horizontal luma/alpha line from source in the ring buffer. int lastInLumBuf; ///< Last scaled horizontal luma/alpha line from source in the ring buffer.
int lastInChrBuf; ///< Last scaled horizontal chroma line from source in the ring buffer. int lastInChrBuf; ///< Last scaled horizontal chroma line from source in the ring buffer.
int lumBufIndex; ///< Index in ring buffer of the last scaled horizontal luma/alpha line from source. int lumBufIndex; ///< Index in ring buffer of the last scaled horizontal luma/alpha line from source.
int chrBufIndex; ///< Index in ring buffer of the last scaled horizontal chroma line from source. int chrBufIndex; ///< Index in ring buffer of the last scaled horizontal chroma line from source.
//@} //@}
uint8_t *formatConvBuffer; uint8_t *formatConvBuffer;
@ -295,10 +301,10 @@ typedef struct SwsContext {
int16_t *hChrFilterPos; ///< Array of horizontal filter starting positions for each dst[i] for chroma planes. int16_t *hChrFilterPos; ///< Array of horizontal filter starting positions for each dst[i] for chroma planes.
int16_t *vLumFilterPos; ///< Array of vertical filter starting positions for each dst[i] for luma/alpha planes. int16_t *vLumFilterPos; ///< Array of vertical filter starting positions for each dst[i] for luma/alpha planes.
int16_t *vChrFilterPos; ///< Array of vertical filter starting positions for each dst[i] for chroma planes. int16_t *vChrFilterPos; ///< Array of vertical filter starting positions for each dst[i] for chroma planes.
int hLumFilterSize; ///< Horizontal filter size for luma/alpha pixels. int hLumFilterSize; ///< Horizontal filter size for luma/alpha pixels.
int hChrFilterSize; ///< Horizontal filter size for chroma pixels. int hChrFilterSize; ///< Horizontal filter size for chroma pixels.
int vLumFilterSize; ///< Vertical filter size for luma/alpha pixels. int vLumFilterSize; ///< Vertical filter size for luma/alpha pixels.
int vChrFilterSize; ///< Vertical filter size for chroma pixels. int vChrFilterSize; ///< Vertical filter size for chroma pixels.
//@} //@}
int lumMmx2FilterCodeSize; ///< Runtime-generated MMX2 horizontal fast bilinear scaler code size for luma/alpha planes. int lumMmx2FilterCodeSize; ///< Runtime-generated MMX2 horizontal fast bilinear scaler code size for luma/alpha planes.
@ -310,11 +316,11 @@ typedef struct SwsContext {
int dstY; ///< Last destination vertical line output from last slice. int dstY; ///< Last destination vertical line output from last slice.
int flags; ///< Flags passed by the user to select scaler algorithm, optimizations, subsampling, etc... int flags; ///< Flags passed by the user to select scaler algorithm, optimizations, subsampling, etc...
void * yuvTable; // pointer to the yuv->rgb table start so it can be freed() void *yuvTable; // pointer to the yuv->rgb table start so it can be freed()
uint8_t * table_rV[256]; uint8_t *table_rV[256];
uint8_t * table_gU[256]; uint8_t *table_gU[256];
int table_gV[256]; int table_gV[256];
uint8_t * table_bU[256]; uint8_t *table_bU[256];
//Colorspace stuff //Colorspace stuff
int contrast, brightness, saturation; // for sws_getColorspaceDetails int contrast, brightness, saturation; // for sws_getColorspaceDetails
@ -366,15 +372,15 @@ typedef struct SwsContext {
DECLARE_ALIGNED(8, uint64_t, yOffset); DECLARE_ALIGNED(8, uint64_t, yOffset);
DECLARE_ALIGNED(8, uint64_t, uOffset); DECLARE_ALIGNED(8, uint64_t, uOffset);
DECLARE_ALIGNED(8, uint64_t, vOffset); DECLARE_ALIGNED(8, uint64_t, vOffset);
int32_t lumMmxFilter[4*MAX_FILTER_SIZE]; int32_t lumMmxFilter[4 * MAX_FILTER_SIZE];
int32_t chrMmxFilter[4*MAX_FILTER_SIZE]; int32_t chrMmxFilter[4 * MAX_FILTER_SIZE];
int dstW; ///< Width of destination luma/alpha planes. int dstW; ///< Width of destination luma/alpha planes.
DECLARE_ALIGNED(8, uint64_t, esp); DECLARE_ALIGNED(8, uint64_t, esp);
DECLARE_ALIGNED(8, uint64_t, vRounder); DECLARE_ALIGNED(8, uint64_t, vRounder);
DECLARE_ALIGNED(8, uint64_t, u_temp); DECLARE_ALIGNED(8, uint64_t, u_temp);
DECLARE_ALIGNED(8, uint64_t, v_temp); DECLARE_ALIGNED(8, uint64_t, v_temp);
DECLARE_ALIGNED(8, uint64_t, y_temp); DECLARE_ALIGNED(8, uint64_t, y_temp);
int32_t alpMmxFilter[4*MAX_FILTER_SIZE]; int32_t alpMmxFilter[4 * MAX_FILTER_SIZE];
// alignment of these values is not necessary, but merely here // alignment of these values is not necessary, but merely here
// to maintain the same offset across x8632 and x86-64. Once we // to maintain the same offset across x8632 and x86-64. Once we
// use proper offset macros in the asm, they can be removed. // use proper offset macros in the asm, they can be removed.
@ -393,7 +399,7 @@ typedef struct SwsContext {
vector signed short CGV; vector signed short CGV;
vector signed short OY; vector signed short OY;
vector unsigned short CSHIFT; vector unsigned short CSHIFT;
vector signed short *vYCoeffsBank, *vCCoeffsBank; vector signed short *vYCoeffsBank, *vCCoeffsBank;
#endif #endif
#if ARCH_BFIN #if ARCH_BFIN
@ -423,21 +429,25 @@ typedef struct SwsContext {
yuv2packed2_fn yuv2packed2; yuv2packed2_fn yuv2packed2;
yuv2packedX_fn yuv2packedX; yuv2packedX_fn yuv2packedX;
/// Unscaled conversion of luma plane to YV12 for horizontal scaler.
void (*lumToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3, void (*lumToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3,
int width, uint32_t *pal); ///< Unscaled conversion of luma plane to YV12 for horizontal scaler. int width, uint32_t *pal);
/// Unscaled conversion of alpha plane to YV12 for horizontal scaler.
void (*alpToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3, void (*alpToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3,
int width, uint32_t *pal); ///< Unscaled conversion of alpha plane to YV12 for horizontal scaler. int width, uint32_t *pal);
/// Unscaled conversion of chroma planes to YV12 for horizontal scaler.
void (*chrToYV12)(uint8_t *dstU, uint8_t *dstV, void (*chrToYV12)(uint8_t *dstU, uint8_t *dstV,
const uint8_t *src1, const uint8_t *src2, const uint8_t *src3, const uint8_t *src1, const uint8_t *src2, const uint8_t *src3,
int width, uint32_t *pal); ///< Unscaled conversion of chroma planes to YV12 for horizontal scaler. int width, uint32_t *pal);
/** /**
* Functions to read planar input, such as planar RGB, and convert * Functions to read planar input, such as planar RGB, and convert
* internally to Y/UV. * internally to Y/UV.
*/ */
/** @{ */ /** @{ */
void (*readLumPlanar)(uint8_t *dst, const uint8_t *src[4], int width); void (*readLumPlanar)(uint8_t *dst, const uint8_t *src[4], int width);
void (*readChrPlanar)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4], int width); void (*readChrPlanar)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4],
int width);
/** @} */ /** @} */
/** /**
@ -499,19 +509,20 @@ typedef struct SwsContext {
* to simplify creating SIMD code. * to simplify creating SIMD code.
*/ */
/** @{ */ /** @{ */
void (*hyScale)(struct SwsContext *c, int16_t *dst, int dstW, const uint8_t *src, void (*hyScale)(struct SwsContext *c, int16_t *dst, int dstW,
const int16_t *filter, const int16_t *filterPos, const uint8_t *src, const int16_t *filter,
int filterSize); const int16_t *filterPos, int filterSize);
void (*hcScale)(struct SwsContext *c, int16_t *dst, int dstW, const uint8_t *src, void (*hcScale)(struct SwsContext *c, int16_t *dst, int dstW,
const int16_t *filter, const int16_t *filterPos, const uint8_t *src, const int16_t *filter,
int filterSize); const int16_t *filterPos, int filterSize);
/** @} */ /** @} */
void (*lumConvertRange)(int16_t *dst, int width); ///< Color range conversion function for luma plane if needed. /// Color range conversion function for luma plane if needed.
void (*chrConvertRange)(int16_t *dst1, int16_t *dst2, int width); ///< Color range conversion function for chroma planes if needed. void (*lumConvertRange)(int16_t *dst, int width);
/// Color range conversion function for chroma planes if needed.
void (*chrConvertRange)(int16_t *dst1, int16_t *dst2, int width);
int needs_hcscale; ///< Set if there are chroma planes to be converted. int needs_hcscale; ///< Set if there are chroma planes to be converted.
} SwsContext; } SwsContext;
//FIXME check init (where 0) //FIXME check init (where 0)
@ -567,53 +578,54 @@ const char *sws_format_name(enum PixelFormat format);
(!(av_pix_fmt_descriptors[x].flags & PIX_FMT_PAL) && \ (!(av_pix_fmt_descriptors[x].flags & PIX_FMT_PAL) && \
av_pix_fmt_descriptors[x].nb_components <= 2) av_pix_fmt_descriptors[x].nb_components <= 2)
#else #else
#define isGray(x) ( \ #define isGray(x) \
(x)==PIX_FMT_GRAY8 \ ((x) == PIX_FMT_GRAY8 || \
|| (x)==PIX_FMT_GRAY8A \ (x) == PIX_FMT_Y400A || \
|| (x)==PIX_FMT_GRAY16BE \ (x) == PIX_FMT_GRAY16BE || \
|| (x)==PIX_FMT_GRAY16LE \ (x) == PIX_FMT_GRAY16LE)
)
#endif #endif
#define isRGBinInt(x) ( \ #define isRGBinInt(x) \
(x)==PIX_FMT_RGB48BE \ ( \
|| (x)==PIX_FMT_RGB48LE \ (x)==PIX_FMT_RGB48BE || \
|| (x)==PIX_FMT_RGBA64BE \ (x)==PIX_FMT_RGB48LE || \
|| (x)==PIX_FMT_RGBA64LE \ (x)==PIX_FMT_RGBA64BE || \
|| (x)==PIX_FMT_RGB32 \ (x)==PIX_FMT_RGBA64LE || \
|| (x)==PIX_FMT_RGB32_1 \ (x)==PIX_FMT_RGB32 || \
|| (x)==PIX_FMT_RGB24 \ (x)==PIX_FMT_RGB32_1 || \
|| (x)==PIX_FMT_RGB565BE \ (x)==PIX_FMT_RGB24 || \
|| (x)==PIX_FMT_RGB565LE \ (x)==PIX_FMT_RGB565BE || \
|| (x)==PIX_FMT_RGB555BE \ (x)==PIX_FMT_RGB565LE || \
|| (x)==PIX_FMT_RGB555LE \ (x)==PIX_FMT_RGB555BE || \
|| (x)==PIX_FMT_RGB444BE \ (x)==PIX_FMT_RGB555LE || \
|| (x)==PIX_FMT_RGB444LE \ (x)==PIX_FMT_RGB444BE || \
|| (x)==PIX_FMT_RGB8 \ (x)==PIX_FMT_RGB444LE || \
|| (x)==PIX_FMT_RGB4 \ (x)==PIX_FMT_RGB8 || \
|| (x)==PIX_FMT_RGB4_BYTE \ (x)==PIX_FMT_RGB4 || \
|| (x)==PIX_FMT_MONOBLACK \ (x)==PIX_FMT_RGB4_BYTE || \
|| (x)==PIX_FMT_MONOWHITE \ (x)==PIX_FMT_MONOBLACK || \
(x)==PIX_FMT_MONOWHITE \
) )
#define isBGRinInt(x) ( \ #define isBGRinInt(x) \
(x)==PIX_FMT_BGR48BE \ ( \
|| (x)==PIX_FMT_BGR48LE \ (x)==PIX_FMT_BGR48BE || \
|| (x)==PIX_FMT_BGRA64BE \ (x)==PIX_FMT_BGR48LE || \
|| (x)==PIX_FMT_BGRA64LE \ (x)==PIX_FMT_BGRA64BE || \
|| (x)==PIX_FMT_BGR32 \ (x)==PIX_FMT_BGRA64LE || \
|| (x)==PIX_FMT_BGR32_1 \ (x)==PIX_FMT_BGR32 || \
|| (x)==PIX_FMT_BGR24 \ (x)==PIX_FMT_BGR32_1 || \
|| (x)==PIX_FMT_BGR565BE \ (x)==PIX_FMT_BGR24 || \
|| (x)==PIX_FMT_BGR565LE \ (x)==PIX_FMT_BGR565BE || \
|| (x)==PIX_FMT_BGR555BE \ (x)==PIX_FMT_BGR565LE || \
|| (x)==PIX_FMT_BGR555LE \ (x)==PIX_FMT_BGR555BE || \
|| (x)==PIX_FMT_BGR444BE \ (x)==PIX_FMT_BGR555LE || \
|| (x)==PIX_FMT_BGR444LE \ (x)==PIX_FMT_BGR444BE || \
|| (x)==PIX_FMT_BGR8 \ (x)==PIX_FMT_BGR444LE || \
|| (x)==PIX_FMT_BGR4 \ (x)==PIX_FMT_BGR8 || \
|| (x)==PIX_FMT_BGR4_BYTE \ (x)==PIX_FMT_BGR4 || \
|| (x)==PIX_FMT_MONOBLACK \ (x)==PIX_FMT_BGR4_BYTE|| \
|| (x)==PIX_FMT_MONOWHITE \ (x)==PIX_FMT_MONOBLACK|| \
(x)==PIX_FMT_MONOWHITE \
) )
#define isRGBinBytes(x) ( \ #define isRGBinBytes(x) ( \
@ -635,10 +647,11 @@ const char *sws_format_name(enum PixelFormat format);
|| (x)==PIX_FMT_BGR24 \ || (x)==PIX_FMT_BGR24 \
) )
#define isAnyRGB(x) ( \ #define isAnyRGB(x) \
isRGBinInt(x) \ ( \
|| isBGRinInt(x) \ isRGBinInt(x) || \
|| (x)==PIX_FMT_GBR24P \ isBGRinInt(x) || \
(x)==PIX_FMT_GBR24P \
) )
#define isALPHA(x) \ #define isALPHA(x) \
@ -655,15 +668,14 @@ const char *sws_format_name(enum PixelFormat format);
|| isBGRinInt(x) \ || isBGRinInt(x) \
) )
#else #else
#define isPacked(x) (\ #define isPacked(x) \
(av_pix_fmt_descriptors[x].nb_components >= 2 && \ ((av_pix_fmt_descriptors[x].nb_components >= 2 && \
!(av_pix_fmt_descriptors[x].flags & PIX_FMT_PLANAR)) || \ !(av_pix_fmt_descriptors[x].flags & PIX_FMT_PLANAR)) || \
(x) == PIX_FMT_PAL8\ (x) == PIX_FMT_PAL8)
)
#endif #endif
#define isPlanar(x) \ #define isPlanar(x) \
(av_pix_fmt_descriptors[x].nb_components >= 2 && \ (av_pix_fmt_descriptors[x].nb_components >= 2 && \
(av_pix_fmt_descriptors[x].flags & PIX_FMT_PLANAR)) (av_pix_fmt_descriptors[x].flags & PIX_FMT_PLANAR))
#define usePal(x) ((av_pix_fmt_descriptors[x].flags & PIX_FMT_PAL) || (x) == PIX_FMT_Y400A) #define usePal(x) ((av_pix_fmt_descriptors[x].flags & PIX_FMT_PAL) || (x) == PIX_FMT_Y400A)

8
libswscale/utils.c
View File

@ -129,10 +129,10 @@ const static FormatEntry format_entries[PIX_FMT_NB] = {
[PIX_FMT_YUV422P16BE] = { 1 , 1 }, [PIX_FMT_YUV422P16BE] = { 1 , 1 },
[PIX_FMT_YUV444P16LE] = { 1 , 1 }, [PIX_FMT_YUV444P16LE] = { 1 , 1 },
[PIX_FMT_YUV444P16BE] = { 1 , 1 }, [PIX_FMT_YUV444P16BE] = { 1 , 1 },
[PIX_FMT_RGB444LE] = { 0 , 1 }, [PIX_FMT_RGB444LE] = { 1 , 1 },
[PIX_FMT_RGB444BE] = { 0 , 1 }, [PIX_FMT_RGB444BE] = { 1 , 1 },
[PIX_FMT_BGR444LE] = { 0 , 1 }, [PIX_FMT_BGR444LE] = { 1 , 1 },
[PIX_FMT_BGR444BE] = { 0 , 1 }, [PIX_FMT_BGR444BE] = { 1 , 1 },
[PIX_FMT_Y400A] = { 1 , 0 }, [PIX_FMT_Y400A] = { 1 , 0 },
[PIX_FMT_BGR48BE] = { 1 , 1 }, [PIX_FMT_BGR48BE] = { 1 , 1 },
[PIX_FMT_BGR48LE] = { 1 , 1 }, [PIX_FMT_BGR48LE] = { 1 , 1 },

242
libswscale/x86/input.asm Normal file
View File

@ -0,0 +1,242 @@
;******************************************************************************
;* x86-optimized input routines; does shuffling of packed
;* YUV formats into individual planes, and converts RGB
;* into YUV planes also.
;* Copyright (c) 2012 Ronald S. Bultje <rsbultje@gmail.com>
;*
;* 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
;******************************************************************************
%include "x86inc.asm"
%include "x86util.asm"
SECTION_RODATA
SECTION .text
;-----------------------------------------------------------------------------
; YUYV/UYVY/NV12/NV21 packed pixel shuffling.
;
; void <fmt>ToY_<opt>(uint8_t *dst, const uint8_t *src, int w);
; and
; void <fmt>toUV_<opt>(uint8_t *dstU, uint8_t *dstV, const uint8_t *src,
; const uint8_t *unused, int w);
;-----------------------------------------------------------------------------
; %1 = a (aligned) or u (unaligned)
; %2 = yuyv or uyvy
%macro LOOP_YUYV_TO_Y 2
.loop_%1:
mov%1 m0, [srcq+wq*2] ; (byte) { Y0, U0, Y1, V0, ... }
mov%1 m1, [srcq+wq*2+mmsize] ; (byte) { Y8, U4, Y9, V4, ... }
%ifidn %2, yuyv
pand m0, m2 ; (word) { Y0, Y1, ..., Y7 }
pand m1, m2 ; (word) { Y8, Y9, ..., Y15 }
%else ; uyvy
psrlw m0, 8 ; (word) { Y0, Y1, ..., Y7 }
psrlw m1, 8 ; (word) { Y8, Y9, ..., Y15 }
%endif ; yuyv/uyvy
packuswb m0, m1 ; (byte) { Y0, ..., Y15 }
mova [dstq+wq], m0
add wq, mmsize
jl .loop_%1
REP_RET
%endmacro
; %1 = nr. of XMM registers
; %2 = yuyv or uyvy
; %3 = if specified, it means that unaligned and aligned code in loop
; will be the same (i.e. YUYV+AVX), and thus we don't need to
; split the loop in an aligned and unaligned case
%macro YUYV_TO_Y_FN 2-3
cglobal %2ToY, 5, 5, %1, dst, unused0, unused1, src, w
%ifdef ARCH_X86_64
movsxd wq, wd
%endif
add dstq, wq
%if mmsize == 16
test srcq, 15
%endif
lea srcq, [srcq+wq*2]
%ifidn %2, yuyv
pcmpeqb m2, m2 ; (byte) { 0xff } x 16
psrlw m2, 8 ; (word) { 0x00ff } x 8
%endif ; yuyv
%if mmsize == 16
jnz .loop_u_start
neg wq
LOOP_YUYV_TO_Y a, %2
.loop_u_start:
neg wq
LOOP_YUYV_TO_Y u, %2
%else ; mmsize == 8
neg wq
LOOP_YUYV_TO_Y a, %2
%endif ; mmsize == 8/16
%endmacro
; %1 = a (aligned) or u (unaligned)
; %2 = yuyv or uyvy
%macro LOOP_YUYV_TO_UV 2
.loop_%1:
%ifidn %2, yuyv
mov%1 m0, [srcq+wq*4] ; (byte) { Y0, U0, Y1, V0, ... }
mov%1 m1, [srcq+wq*4+mmsize] ; (byte) { Y8, U4, Y9, V4, ... }
psrlw m0, 8 ; (word) { U0, V0, ..., U3, V3 }
psrlw m1, 8 ; (word) { U4, V4, ..., U7, V7 }
%else ; uyvy
%if cpuflag(avx)
vpand m0, m2, [srcq+wq*4] ; (word) { U0, V0, ..., U3, V3 }
vpand m1, m2, [srcq+wq*4+mmsize] ; (word) { U4, V4, ..., U7, V7 }
%else
mov%1 m0, [srcq+wq*4] ; (byte) { Y0, U0, Y1, V0, ... }
mov%1 m1, [srcq+wq*4+mmsize] ; (byte) { Y8, U4, Y9, V4, ... }
pand m0, m2 ; (word) { U0, V0, ..., U3, V3 }
pand m1, m2 ; (word) { U4, V4, ..., U7, V7 }
%endif
%endif ; yuyv/uyvy
packuswb m0, m1 ; (byte) { U0, V0, ..., U7, V7 }
pand m1, m0, m2 ; (word) { U0, U1, ..., U7 }
psrlw m0, 8 ; (word) { V0, V1, ..., V7 }
%if mmsize == 16
packuswb m1, m0 ; (byte) { U0, ... U7, V1, ... V7 }
movh [dstUq+wq], m1
movhps [dstVq+wq], m1
%else ; mmsize == 8
packuswb m1, m1 ; (byte) { U0, ... U3 }
packuswb m0, m0 ; (byte) { V0, ... V3 }
movh [dstUq+wq], m1
movh [dstVq+wq], m0
%endif ; mmsize == 8/16
add wq, mmsize / 2
jl .loop_%1
REP_RET
%endmacro
; %1 = nr. of XMM registers
; %2 = yuyv or uyvy
; %3 = if specified, it means that unaligned and aligned code in loop
; will be the same (i.e. UYVY+AVX), and thus we don't need to
; split the loop in an aligned and unaligned case
%macro YUYV_TO_UV_FN 2-3
cglobal %2ToUV, 4, 5, %1, dstU, dstV, unused, src, w
%ifdef ARCH_X86_64
movsxd wq, r5m
%else ; x86-32
mov wq, r5m
%endif
add dstUq, wq
add dstVq, wq
%if mmsize == 16 && %0 == 2
test srcq, 15
%endif
lea srcq, [srcq+wq*4]
pcmpeqb m2, m2 ; (byte) { 0xff } x 16
psrlw m2, 8 ; (word) { 0x00ff } x 8
; NOTE: if uyvy+avx, u/a are identical
%if mmsize == 16 && %0 == 2
jnz .loop_u_start
neg wq
LOOP_YUYV_TO_UV a, %2
.loop_u_start:
neg wq
LOOP_YUYV_TO_UV u, %2
%else ; mmsize == 8
neg wq
LOOP_YUYV_TO_UV a, %2
%endif ; mmsize == 8/16
%endmacro
; %1 = a (aligned) or u (unaligned)
; %2 = nv12 or nv21
%macro LOOP_NVXX_TO_UV 2
.loop_%1:
mov%1 m0, [srcq+wq*2] ; (byte) { U0, V0, U1, V1, ... }
mov%1 m1, [srcq+wq*2+mmsize] ; (byte) { U8, V8, U9, V9, ... }
pand m2, m0, m5 ; (word) { U0, U1, ..., U7 }
pand m3, m1, m5 ; (word) { U8, U9, ..., U15 }
psrlw m0, 8 ; (word) { V0, V1, ..., V7 }
psrlw m1, 8 ; (word) { V8, V9, ..., V15 }
packuswb m2, m3 ; (byte) { U0, ..., U15 }
packuswb m0, m1 ; (byte) { V0, ..., V15 }
%ifidn %2, nv12
mova [dstUq+wq], m2
mova [dstVq+wq], m0
%else ; nv21
mova [dstVq+wq], m2
mova [dstUq+wq], m0
%endif ; nv12/21
add wq, mmsize
jl .loop_%1
REP_RET
%endmacro
; %1 = nr. of XMM registers
; %2 = nv12 or nv21
%macro NVXX_TO_UV_FN 2
cglobal %2ToUV, 4, 5, %1, dstU, dstV, unused, src, w
%ifdef ARCH_X86_64
movsxd wq, r5m
%else ; x86-32
mov wq, r5m
%endif
add dstUq, wq
add dstVq, wq
%if mmsize == 16
test srcq, 15
%endif
lea srcq, [srcq+wq*2]
pcmpeqb m5, m5 ; (byte) { 0xff } x 16
psrlw m5, 8 ; (word) { 0x00ff } x 8
%if mmsize == 16
jnz .loop_u_start
neg wq
LOOP_NVXX_TO_UV a, %2
.loop_u_start:
neg wq
LOOP_NVXX_TO_UV u, %2
%else ; mmsize == 8
neg wq
LOOP_NVXX_TO_UV a, %2
%endif ; mmsize == 8/16
%endmacro
%ifdef ARCH_X86_32
INIT_MMX mmx
YUYV_TO_Y_FN 0, yuyv
YUYV_TO_Y_FN 0, uyvy
YUYV_TO_UV_FN 0, yuyv
YUYV_TO_UV_FN 0, uyvy
NVXX_TO_UV_FN 0, nv12
NVXX_TO_UV_FN 0, nv21
%endif
INIT_XMM sse2
YUYV_TO_Y_FN 3, yuyv
YUYV_TO_Y_FN 2, uyvy
YUYV_TO_UV_FN 3, yuyv
YUYV_TO_UV_FN 3, uyvy
NVXX_TO_UV_FN 5, nv12
NVXX_TO_UV_FN 5, nv21
INIT_XMM avx
; in theory, we could write a yuy2-to-y using vpand (i.e. AVX), but
; that's not faster in practice
YUYV_TO_UV_FN 3, yuyv
YUYV_TO_UV_FN 3, uyvy, 1
NVXX_TO_UV_FN 5, nv12
NVXX_TO_UV_FN 5, nv21

83
libswscale/x86/swscale_mmx.c
View File

@ -307,6 +307,26 @@ VSCALE_FUNCS(sse2, sse2);
VSCALE_FUNC(16, sse4); VSCALE_FUNC(16, sse4);
VSCALE_FUNCS(avx, avx); VSCALE_FUNCS(avx, avx);
#define INPUT_UV_FUNC(fmt, opt) \
extern void ff_ ## fmt ## ToUV_ ## opt(uint8_t *dstU, uint8_t *dstV, \
const uint8_t *src, const uint8_t *unused1, \
int w, uint32_t *unused2)
#define INPUT_FUNC(fmt, opt) \
extern void ff_ ## fmt ## ToY_ ## opt(uint8_t *dst, const uint8_t *src, \
int w, uint32_t *unused); \
INPUT_UV_FUNC(fmt, opt)
#define INPUT_FUNCS(opt) \
INPUT_FUNC(uyvy, opt); \
INPUT_FUNC(yuyv, opt); \
INPUT_UV_FUNC(nv12, opt); \
INPUT_UV_FUNC(nv21, opt)
#if ARCH_X86_32
INPUT_FUNCS(mmx);
#endif
INPUT_FUNCS(sse2);
INPUT_FUNCS(avx);
void ff_sws_init_swScale_mmx(SwsContext *c) void ff_sws_init_swScale_mmx(SwsContext *c)
{ {
int cpu_flags = av_get_cpu_flags(); int cpu_flags = av_get_cpu_flags();
@ -366,6 +386,30 @@ switch(c->dstBpc){ \
ASSIGN_MMX_SCALE_FUNC(c->hyScale, c->hLumFilterSize, mmx, mmx); ASSIGN_MMX_SCALE_FUNC(c->hyScale, c->hLumFilterSize, mmx, mmx);
ASSIGN_MMX_SCALE_FUNC(c->hcScale, c->hChrFilterSize, mmx, mmx); ASSIGN_MMX_SCALE_FUNC(c->hcScale, c->hChrFilterSize, mmx, mmx);
ASSIGN_VSCALE_FUNC(c->yuv2plane1, mmx, mmx2, cpu_flags & AV_CPU_FLAG_MMX2); ASSIGN_VSCALE_FUNC(c->yuv2plane1, mmx, mmx2, cpu_flags & AV_CPU_FLAG_MMX2);
switch (c->srcFormat) {
case PIX_FMT_Y400A:
c->lumToYV12 = ff_yuyvToY_mmx;
if (c->alpPixBuf)
c->alpToYV12 = ff_uyvyToY_mmx;
break;
case PIX_FMT_YUYV422:
c->lumToYV12 = ff_yuyvToY_mmx;
c->chrToYV12 = ff_yuyvToUV_mmx;
break;
case PIX_FMT_UYVY422:
c->lumToYV12 = ff_uyvyToY_mmx;
c->chrToYV12 = ff_uyvyToUV_mmx;
break;
case PIX_FMT_NV12:
c->chrToYV12 = ff_nv12ToUV_mmx;
break;
case PIX_FMT_NV21:
c->chrToYV12 = ff_nv21ToUV_mmx;
break;
default:
break;
}
} }
if (cpu_flags & AV_CPU_FLAG_MMX2) { if (cpu_flags & AV_CPU_FLAG_MMX2) {
ASSIGN_VSCALEX_FUNC(c->yuv2planeX, mmx2,); ASSIGN_VSCALEX_FUNC(c->yuv2planeX, mmx2,);
@ -384,6 +428,28 @@ switch(c->dstBpc){ \
ASSIGN_SSE_SCALE_FUNC(c->hcScale, c->hChrFilterSize, sse2, sse2); ASSIGN_SSE_SCALE_FUNC(c->hcScale, c->hChrFilterSize, sse2, sse2);
ASSIGN_VSCALEX_FUNC(c->yuv2planeX, sse2,); ASSIGN_VSCALEX_FUNC(c->yuv2planeX, sse2,);
ASSIGN_VSCALE_FUNC(c->yuv2plane1, sse2, sse2, 1); ASSIGN_VSCALE_FUNC(c->yuv2plane1, sse2, sse2, 1);
switch (c->srcFormat) {
case PIX_FMT_Y400A:
c->lumToYV12 = ff_yuyvToY_sse2;
if (c->alpPixBuf)
c->alpToYV12 = ff_uyvyToY_sse2;
break;
case PIX_FMT_YUYV422:
c->lumToYV12 = ff_yuyvToY_sse2;
c->chrToYV12 = ff_yuyvToUV_sse2;
break;
case PIX_FMT_UYVY422:
c->lumToYV12 = ff_uyvyToY_sse2;
c->chrToYV12 = ff_uyvyToUV_sse2;
break;
case PIX_FMT_NV12:
c->chrToYV12 = ff_nv12ToUV_sse2;
break;
case PIX_FMT_NV21:
c->chrToYV12 = ff_nv21ToUV_sse2;
break;
}
} }
if (cpu_flags & AV_CPU_FLAG_SSSE3) { if (cpu_flags & AV_CPU_FLAG_SSSE3) {
ASSIGN_SSE_SCALE_FUNC(c->hyScale, c->hLumFilterSize, ssse3, ssse3); ASSIGN_SSE_SCALE_FUNC(c->hyScale, c->hLumFilterSize, ssse3, ssse3);
@ -402,6 +468,23 @@ switch(c->dstBpc){ \
if (cpu_flags & AV_CPU_FLAG_AVX) { if (cpu_flags & AV_CPU_FLAG_AVX) {
ASSIGN_VSCALEX_FUNC(c->yuv2planeX, avx,); ASSIGN_VSCALEX_FUNC(c->yuv2planeX, avx,);
ASSIGN_VSCALE_FUNC(c->yuv2plane1, avx, avx, 1); ASSIGN_VSCALE_FUNC(c->yuv2plane1, avx, avx, 1);
switch (c->srcFormat) {
case PIX_FMT_YUYV422:
c->chrToYV12 = ff_yuyvToUV_avx;
break;
case PIX_FMT_UYVY422:
c->chrToYV12 = ff_uyvyToUV_avx;
break;
case PIX_FMT_NV12:
c->chrToYV12 = ff_nv12ToUV_avx;
break;
case PIX_FMT_NV21:
c->chrToYV12 = ff_nv21ToUV_avx;
break;
default:
break;
}
} }
#endif #endif
} }

163
libswscale/x86/swscale_template.c
View File

@ -1435,147 +1435,6 @@ static void RENAME(yuv2yuyv422_1)(SwsContext *c, const int16_t *buf0,
} }
} }
#if !COMPILE_TEMPLATE_MMX2
//FIXME yuy2* can read up to 7 samples too much
static void RENAME(yuy2ToY)(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
int width, uint32_t *unused)
{
__asm__ volatile(
"movq "MANGLE(bm01010101)", %%mm2 \n\t"
"mov %0, %%"REG_a" \n\t"
"1: \n\t"
"movq (%1, %%"REG_a",2), %%mm0 \n\t"
"movq 8(%1, %%"REG_a",2), %%mm1 \n\t"
"pand %%mm2, %%mm0 \n\t"
"pand %%mm2, %%mm1 \n\t"
"packuswb %%mm1, %%mm0 \n\t"
"movq %%mm0, (%2, %%"REG_a") \n\t"
"add $8, %%"REG_a" \n\t"
" js 1b \n\t"
: : "g" ((x86_reg)-width), "r" (src+width*2), "r" (dst+width)
: "%"REG_a
);
}
static void RENAME(yuy2ToUV)(uint8_t *dstU, uint8_t *dstV,
const uint8_t *unused1, const uint8_t *src1, const uint8_t *src2,
int width, uint32_t *unused)
{
__asm__ volatile(
"movq "MANGLE(bm01010101)", %%mm4 \n\t"
"mov %0, %%"REG_a" \n\t"
"1: \n\t"
"movq (%1, %%"REG_a",4), %%mm0 \n\t"
"movq 8(%1, %%"REG_a",4), %%mm1 \n\t"
"psrlw $8, %%mm0 \n\t"
"psrlw $8, %%mm1 \n\t"
"packuswb %%mm1, %%mm0 \n\t"
"movq %%mm0, %%mm1 \n\t"
"psrlw $8, %%mm0 \n\t"
"pand %%mm4, %%mm1 \n\t"
"packuswb %%mm0, %%mm0 \n\t"
"packuswb %%mm1, %%mm1 \n\t"
"movd %%mm0, (%3, %%"REG_a") \n\t"
"movd %%mm1, (%2, %%"REG_a") \n\t"
"add $4, %%"REG_a" \n\t"
" js 1b \n\t"
: : "g" ((x86_reg)-width), "r" (src1+width*4), "r" (dstU+width), "r" (dstV+width)
: "%"REG_a
);
assert(src1 == src2);
}
/* This is almost identical to the previous, end exists only because
* yuy2ToY/UV)(dst, src+1, ...) would have 100% unaligned accesses. */
static void RENAME(uyvyToY)(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
int width, uint32_t *unused)
{
__asm__ volatile(
"mov %0, %%"REG_a" \n\t"
"1: \n\t"
"movq (%1, %%"REG_a",2), %%mm0 \n\t"
"movq 8(%1, %%"REG_a",2), %%mm1 \n\t"
"psrlw $8, %%mm0 \n\t"
"psrlw $8, %%mm1 \n\t"
"packuswb %%mm1, %%mm0 \n\t"
"movq %%mm0, (%2, %%"REG_a") \n\t"
"add $8, %%"REG_a" \n\t"
" js 1b \n\t"
: : "g" ((x86_reg)-width), "r" (src+width*2), "r" (dst+width)
: "%"REG_a
);
}
static void RENAME(uyvyToUV)(uint8_t *dstU, uint8_t *dstV,
const uint8_t *unused1, const uint8_t *src1, const uint8_t *src2,
int width, uint32_t *unused)
{
__asm__ volatile(
"movq "MANGLE(bm01010101)", %%mm4 \n\t"
"mov %0, %%"REG_a" \n\t"
"1: \n\t"
"movq (%1, %%"REG_a",4), %%mm0 \n\t"
"movq 8(%1, %%"REG_a",4), %%mm1 \n\t"
"pand %%mm4, %%mm0 \n\t"
"pand %%mm4, %%mm1 \n\t"
"packuswb %%mm1, %%mm0 \n\t"
"movq %%mm0, %%mm1 \n\t"
"psrlw $8, %%mm0 \n\t"
"pand %%mm4, %%mm1 \n\t"
"packuswb %%mm0, %%mm0 \n\t"
"packuswb %%mm1, %%mm1 \n\t"
"movd %%mm0, (%3, %%"REG_a") \n\t"
"movd %%mm1, (%2, %%"REG_a") \n\t"
"add $4, %%"REG_a" \n\t"
" js 1b \n\t"
: : "g" ((x86_reg)-width), "r" (src1+width*4), "r" (dstU+width), "r" (dstV+width)
: "%"REG_a
);
assert(src1 == src2);
}
static av_always_inline void RENAME(nvXXtoUV)(uint8_t *dst1, uint8_t *dst2,
const uint8_t *src, int width)
{
__asm__ volatile(
"movq "MANGLE(bm01010101)", %%mm4 \n\t"
"mov %0, %%"REG_a" \n\t"
"1: \n\t"
"movq (%1, %%"REG_a",2), %%mm0 \n\t"
"movq 8(%1, %%"REG_a",2), %%mm1 \n\t"
"movq %%mm0, %%mm2 \n\t"
"movq %%mm1, %%mm3 \n\t"
"pand %%mm4, %%mm0 \n\t"
"pand %%mm4, %%mm1 \n\t"
"psrlw $8, %%mm2 \n\t"
"psrlw $8, %%mm3 \n\t"
"packuswb %%mm1, %%mm0 \n\t"
"packuswb %%mm3, %%mm2 \n\t"
"movq %%mm0, (%2, %%"REG_a") \n\t"
"movq %%mm2, (%3, %%"REG_a") \n\t"
"add $8, %%"REG_a" \n\t"
" js 1b \n\t"
: : "g" ((x86_reg)-width), "r" (src+width*2), "r" (dst1+width), "r" (dst2+width)
: "%"REG_a
);
}
static void RENAME(nv12ToUV)(uint8_t *dstU, uint8_t *dstV,
const uint8_t *unused1, const uint8_t *src1, const uint8_t *src2,
int width, uint32_t *unused)
{
RENAME(nvXXtoUV)(dstU, dstV, src1, width);
}
static void RENAME(nv21ToUV)(uint8_t *dstU, uint8_t *dstV,
const uint8_t *unused1, const uint8_t *src1, const uint8_t *src2,
int width, uint32_t *unused)
{
RENAME(nvXXtoUV)(dstV, dstU, src1, width);
}
#endif /* !COMPILE_TEMPLATE_MMX2 */
static av_always_inline void RENAME(bgr24ToY_mmx)(int16_t *dst, const uint8_t *src, static av_always_inline void RENAME(bgr24ToY_mmx)(int16_t *dst, const uint8_t *src,
int width, enum PixelFormat srcFormat) int width, enum PixelFormat srcFormat)
{ {
@ -1927,15 +1786,6 @@ static av_cold void RENAME(sws_init_swScale)(SwsContext *c)
#endif /* COMPILE_TEMPLATE_MMX2 */ #endif /* COMPILE_TEMPLATE_MMX2 */
} }
#if !COMPILE_TEMPLATE_MMX2
switch(srcFormat) {
case PIX_FMT_YUYV422 : c->chrToYV12 = RENAME(yuy2ToUV); break;
case PIX_FMT_UYVY422 : c->chrToYV12 = RENAME(uyvyToUV); break;
case PIX_FMT_NV12 : c->chrToYV12 = RENAME(nv12ToUV); break;
case PIX_FMT_NV21 : c->chrToYV12 = RENAME(nv21ToUV); break;
default: break;
}
#endif /* !COMPILE_TEMPLATE_MMX2 */
if (!c->chrSrcHSubSample) { if (!c->chrSrcHSubSample) {
switch(srcFormat) { switch(srcFormat) {
case PIX_FMT_BGR24 : c->chrToYV12 = RENAME(bgr24ToUV); break; case PIX_FMT_BGR24 : c->chrToYV12 = RENAME(bgr24ToUV); break;
@ -1945,21 +1795,8 @@ static av_cold void RENAME(sws_init_swScale)(SwsContext *c)
} }
switch (srcFormat) { switch (srcFormat) {
#if !COMPILE_TEMPLATE_MMX2
case PIX_FMT_YUYV422 :
case PIX_FMT_Y400A : c->lumToYV12 = RENAME(yuy2ToY); break;
case PIX_FMT_UYVY422 : c->lumToYV12 = RENAME(uyvyToY); break;
#endif /* !COMPILE_TEMPLATE_MMX2 */
case PIX_FMT_BGR24 : c->lumToYV12 = RENAME(bgr24ToY); break; case PIX_FMT_BGR24 : c->lumToYV12 = RENAME(bgr24ToY); break;
case PIX_FMT_RGB24 : c->lumToYV12 = RENAME(rgb24ToY); break; case PIX_FMT_RGB24 : c->lumToYV12 = RENAME(rgb24ToY); break;
default: break; default: break;
} }
#if !COMPILE_TEMPLATE_MMX2
if (c->alpPixBuf) {
switch (srcFormat) {
case PIX_FMT_Y400A : c->alpToYV12 = RENAME(yuy2ToY); break;
default: break;
}
}
#endif /* !COMPILE_TEMPLATE_MMX2 */
} }

16
tests/fate/aac.mak
View File

@ -14,18 +14,34 @@ FATE_AAC += fate-aac-al07_96
fate-aac-al07_96: CMD = pcm -i $(SAMPLES)/aac/al07_96.mp4 fate-aac-al07_96: CMD = pcm -i $(SAMPLES)/aac/al07_96.mp4
fate-aac-al07_96: REF = $(SAMPLES)/aac/al07_96.s16 fate-aac-al07_96: REF = $(SAMPLES)/aac/al07_96.s16
FATE_AAC += fate-aac-al15_44
fate-aac-al15_44: CMD = pcm -i $(SAMPLES)/aac/al15_44.mp4
fate-aac-al15_44: REF = $(SAMPLES)/aac/al15_44.s16
FATE_AAC += fate-aac-al17_44 FATE_AAC += fate-aac-al17_44
fate-aac-al17_44: CMD = pcm -i $(SAMPLES)/aac/al17_44.mp4 fate-aac-al17_44: CMD = pcm -i $(SAMPLES)/aac/al17_44.mp4
fate-aac-al17_44: REF = $(SAMPLES)/aac/al17_44.s16 fate-aac-al17_44: REF = $(SAMPLES)/aac/al17_44.s16
FATE_AAC += fate-aac-al18_44
fate-aac-al18_44: CMD = pcm -i $(SAMPLES)/aac/al18_44.mp4
fate-aac-al18_44: REF = $(SAMPLES)/aac/al18_44.s16
FATE_AAC += fate-aac-am00_88 FATE_AAC += fate-aac-am00_88
fate-aac-am00_88: CMD = pcm -i $(SAMPLES)/aac/am00_88.mp4 fate-aac-am00_88: CMD = pcm -i $(SAMPLES)/aac/am00_88.mp4
fate-aac-am00_88: REF = $(SAMPLES)/aac/am00_88.s16 fate-aac-am00_88: REF = $(SAMPLES)/aac/am00_88.s16
FATE_AAC += fate-aac-am05_44
fate-aac-am05_44: CMD = pcm -i $(SAMPLES)/aac/am05_44.mp4
fate-aac-am05_44: REF = $(SAMPLES)/aac/am05_44.s16
FATE_AAC += fate-aac-al_sbr_hq_cm_48_2 FATE_AAC += fate-aac-al_sbr_hq_cm_48_2
fate-aac-al_sbr_hq_cm_48_2: CMD = pcm -i $(SAMPLES)/aac/al_sbr_cm_48_2.mp4 fate-aac-al_sbr_hq_cm_48_2: CMD = pcm -i $(SAMPLES)/aac/al_sbr_cm_48_2.mp4
fate-aac-al_sbr_hq_cm_48_2: REF = $(SAMPLES)/aac/al_sbr_hq_cm_48_2.s16 fate-aac-al_sbr_hq_cm_48_2: REF = $(SAMPLES)/aac/al_sbr_hq_cm_48_2.s16
FATE_AAC += fate-aac-al_sbr_hq_cm_48_5.1
fate-aac-al_sbr_hq_cm_48_5.1: CMD = pcm -i $(SAMPLES)/aac/al_sbr_cm_48_5.1.mp4
fate-aac-al_sbr_hq_cm_48_5.1: REF = $(SAMPLES)/aac/al_sbr_hq_cm_48_5.1.s16
FATE_AAC += fate-aac-al_sbr_ps_06_ur FATE_AAC += fate-aac-al_sbr_ps_06_ur
fate-aac-al_sbr_ps_06_ur: CMD = pcm -i $(SAMPLES)/aac/al_sbr_ps_06_new.mp4 fate-aac-al_sbr_ps_06_ur: CMD = pcm -i $(SAMPLES)/aac/al_sbr_ps_06_new.mp4
fate-aac-al_sbr_ps_06_ur: REF = $(SAMPLES)/aac/al_sbr_ps_06_ur.s16 fate-aac-al_sbr_ps_06_ur: REF = $(SAMPLES)/aac/al_sbr_ps_06_ur.s16

9
tests/fate/demux.mak
View File

@ -79,11 +79,20 @@ fate-sierra-vmd: CMD = framecrc -i $(SAMPLES)/vmd/12.vmd -vsync 0 -pix_fmt rgb24
FATE_DEMUX += fate-siff FATE_DEMUX += fate-siff
fate-siff: CMD = framecrc -i $(SAMPLES)/SIFF/INTRO_B.VB -t 3 -pix_fmt rgb24 fate-siff: CMD = framecrc -i $(SAMPLES)/SIFF/INTRO_B.VB -t 3 -pix_fmt rgb24
FATE_DEMUX += fate-smjpeg
fate-smjpeg: CMD = framecrc -i $(SAMPLES)/smjpeg/scenwin.mjpg -vcodec copy
FATE_DEMUX += fate-westwood-aud FATE_DEMUX += fate-westwood-aud
fate-westwood-aud: CMD = md5 -i $(SAMPLES)/westwood-aud/excellent.aud -f s16le fate-westwood-aud: CMD = md5 -i $(SAMPLES)/westwood-aud/excellent.aud -f s16le
FATE_DEMUX += fate-wtv-demux
fate-wtv-demux: CMD = framecrc -i $(SAMPLES)/wtv/law-and-order-partial.wtv -vcodec copy -acodec copy
FATE_DEMUX += fate-xmv-demux FATE_DEMUX += fate-xmv-demux
fate-xmv-demux: CMD = framecrc -i $(SAMPLES)/xmv/logos1p.fmv -vcodec copy -acodec copy fate-xmv-demux: CMD = framecrc -i $(SAMPLES)/xmv/logos1p.fmv -vcodec copy -acodec copy
FATE_DEMUX += fate-xwma-demux
fate-xwma-demux: CMD = crc -i $(SAMPLES)/xwma/ergon.xwma -acodec copy
FATE_TESTS += $(FATE_DEMUX) FATE_TESTS += $(FATE_DEMUX)
fate-demux: $(FATE_DEMUX) fate-demux: $(FATE_DEMUX)

3
tests/fate/microsoft.mak
View File

@ -29,5 +29,8 @@ fate-vc1_sa10091: CMD = framecrc -i $(SAMPLES)/vc1/SA10091.vc1
FATE_MICROSOFT += fate-vc1_sa20021 FATE_MICROSOFT += fate-vc1_sa20021
fate-vc1_sa20021: CMD = framecrc -i $(SAMPLES)/vc1/SA20021.vc1 fate-vc1_sa20021: CMD = framecrc -i $(SAMPLES)/vc1/SA20021.vc1
FATE_MICROSOFT += fate-vc1-ism
fate-vc1-ism: CMD = framecrc -i $(SAMPLES)/isom/vc1-wmapro.ism -an
FATE_TESTS += $(FATE_MICROSOFT) FATE_TESTS += $(FATE_MICROSOFT)
fate-microsoft: $(FATE_MICROSOFT) fate-microsoft: $(FATE_MICROSOFT)

3
tests/fate/video.mak
View File

@ -49,6 +49,9 @@ fate-cvid: CMD = framecrc -i $(SAMPLES)/cvid/laracroft-cinepak-partial.avi -an
FATE_VIDEO += fate-cvid-palette FATE_VIDEO += fate-cvid-palette
fate-cvid-palette: CMD = framecrc -i $(SAMPLES)/cvid/catfight-cvid-pal8-partial.mov -pix_fmt rgb24 -an fate-cvid-palette: CMD = framecrc -i $(SAMPLES)/cvid/catfight-cvid-pal8-partial.mov -pix_fmt rgb24 -an
FATE_VIDEO += fate-cvid-grayscale
fate-cvid-grayscale: CMD = framecrc -i $(SAMPLES)/cvid/pcitva15.avi -an
FATE_VIDEO += fate-cyberia-c93 FATE_VIDEO += fate-cyberia-c93
fate-cyberia-c93: CMD = framecrc -i $(SAMPLES)/cyberia-c93/intro1.c93 -t 3 -pix_fmt rgb24 fate-cyberia-c93: CMD = framecrc -i $(SAMPLES)/cyberia-c93/intro1.c93 -t 3 -pix_fmt rgb24

5
tests/fate/wma.mak
View File

@ -8,6 +8,11 @@ fate-wmapro-5.1: CMD = pcm -i $(SAMPLES)/wmapro/latin_192_mulitchannel_cut.wma
fate-wmapro-5.1: CMP = oneoff fate-wmapro-5.1: CMP = oneoff
fate-wmapro-5.1: REF = $(SAMPLES)/wmapro/latin_192_mulitchannel_cut.pcm fate-wmapro-5.1: REF = $(SAMPLES)/wmapro/latin_192_mulitchannel_cut.pcm
FATE_WMA += fate-wmapro-ism
fate-wmapro-ism: CMD = pcm -i $(SAMPLES)/isom/vc1-wmapro.ism -vn
fate-wmapro-ism: CMP = oneoff
fate-wmapro-ism: REF = $(SAMPLES)/isom/vc1-wmapro.pcm
FATE_WMA += fate-wmavoice-7k FATE_WMA += fate-wmavoice-7k
fate-wmavoice-7k: CMD = pcm -i $(SAMPLES)/wmavoice/streaming_CBR-7K.wma fate-wmavoice-7k: CMD = pcm -i $(SAMPLES)/wmavoice/streaming_CBR-7K.wma
fate-wmavoice-7k: CMP = stddev fate-wmavoice-7k: CMP = stddev

152
tests/ref/fate/cvid-grayscale Normal file
View File

@ -0,0 +1,152 @@
0, 0, 11300, 0x46c78923
0, 17921, 11300, 0x3f2a1175
0, 35842, 11300, 0x722de221
0, 53763, 11300, 0x01746b88
0, 71684, 11300, 0x549587a7
0, 89605, 11300, 0x843ab943
0, 107526, 11300, 0x62fdee48
0, 125447, 11300, 0x74a62867
0, 143368, 11300, 0x35a20e2f
0, 161289, 11300, 0x4e9ef54d
0, 179210, 11300, 0xec7201f5
0, 197131, 11300, 0x363bfe27
0, 215052, 11300, 0x2aaab418
0, 232973, 11300, 0x6a48ab3f
0, 250894, 11300, 0x3fecea34
0, 268815, 11300, 0xa371f55e
0, 286736, 11300, 0xa86b147c
0, 304657, 11300, 0x49e9206e
0, 322578, 11300, 0x6c9a2155
0, 340499, 11300, 0x2c8a4798
0, 358420, 11300, 0x3485676c
0, 376341, 11300, 0xb0b293f2
0, 394262, 11300, 0xe4a9b068
0, 412183, 11300, 0xd68d0556
0, 430104, 11300, 0xc28e5193
0, 448025, 11300, 0xf6948483
0, 465945, 11300, 0xf21fbf57
0, 483866, 11300, 0x8345eb44
0, 501787, 11300, 0x8124f045
0, 519708, 11300, 0x18e31f10
0, 537629, 11300, 0xdb1943fc
0, 555550, 11300, 0x8701699f
0, 573471, 11300, 0xd7b18550
0, 591392, 11300, 0xa56faccc
0, 609313, 11300, 0xf8bcc17c
0, 627234, 11300, 0x446acab9
0, 645155, 11300, 0x755fd295
0, 663076, 11300, 0x92e3d100
0, 680997, 11300, 0x54895bb3
0, 698918, 11300, 0xd18bffda
0, 716839, 11300, 0x480dbe4f
0, 734760, 11300, 0x49ea9dbe
0, 752681, 11300, 0x00d3a003
0, 770602, 11300, 0xda7bbfb2
0, 788523, 11300, 0x9700d9c2
0, 806444, 11300, 0xa0a9e490
0, 824365, 11300, 0x00eb0979
0, 842286, 11300, 0x32b04630
0, 860207, 11300, 0xdfb73e51
0, 878128, 11300, 0x3d8e4f96
0, 896049, 11300, 0x2ca83271
0, 913970, 11300, 0xb5b123c0
0, 931891, 11300, 0x8a570e58
0, 949812, 11300, 0xc6c805bc
0, 967733, 11300, 0x27caf7a5
0, 985654, 11300, 0x5319ecb0
0, 1003575, 11300, 0x5471e3fd
0, 1021496, 11300, 0x6d68a6f4
0, 1039417, 11300, 0x872b7194
0, 1057338, 11300, 0x007c36bd
0, 1075259, 11300, 0x2714f1b5
0, 1093180, 11300, 0x6c8eb50f
0, 1111101, 11300, 0xf5d57be8
0, 1129022, 11300, 0x981f412b
0, 1146943, 11300, 0x1a9804a1
0, 1164864, 11300, 0xf0c1d24a
0, 1182785, 11300, 0xa70a9d9b
0, 1200706, 11300, 0x8c466876
0, 1218627, 11300, 0xcf2e32df
0, 1236548, 11300, 0xcb8cfebf
0, 1254469, 11300, 0xb961ca99
0, 1272390, 11300, 0x666d9619
0, 1290311, 11300, 0x84bf5b55
0, 1308232, 11300, 0xbfa22ccc
0, 1326153, 11300, 0xcde41849
0, 1344074, 11300, 0x71372dcd
0, 1361994, 11300, 0x13402cfd
0, 1379915, 11300, 0xdebdd321
0, 1397836, 11300, 0xdda66de1
0, 1415757, 11300, 0x7f4bb682
0, 1433678, 11300, 0xf67fd528
0, 1451599, 11300, 0xe739ff8c
0, 1469520, 11300, 0x2e131774
0, 1487441, 11300, 0xfa942811
0, 1505362, 11300, 0x0cd93ac2
0, 1523283, 11300, 0xd0445e0e
0, 1541204, 11300, 0x3f3497c7
0, 1559125, 11300, 0x11b5bd2c
0, 1577046, 11300, 0xccd5e62a
0, 1594967, 11300, 0xa9d4fcb5
0, 1612888, 11300, 0x34aa1a03
0, 1630809, 11300, 0x1ce6299e
0, 1648730, 11300, 0x661c2745
0, 1666651, 11300, 0x27d8a8b3
0, 1684572, 11300, 0x9eb07467
0, 1702493, 11300, 0x128374d2
0, 1720414, 11300, 0x05c36ff5
0, 1738335, 11300, 0x8a136bde
0, 1756256, 11300, 0x15c47c99
0, 1774177, 11300, 0xcc4a93f4
0, 1792098, 11300, 0x19529b2b
0, 1810019, 11300, 0x9943c076
0, 1827940, 11300, 0xf898e583
0, 1845861, 11300, 0x40f71f94
0, 1863782, 11300, 0x5b604afb
0, 1881703, 11300, 0x8c176af4
0, 1899624, 11300, 0x0f1a6216
0, 1917545, 11300, 0x38bbd13d
0, 1935466, 11300, 0x90c8d1fc
0, 1953387, 11300, 0x253000d7
0, 1971308, 11300, 0xb94b03b1
0, 1989229, 11300, 0xbc872268
0, 2007150, 11300, 0xe77adb8c
0, 2025071, 11300, 0xa38936b7
0, 2042992, 11300, 0xd6153632
0, 2060913, 11300, 0x1ae633cc
0, 2078834, 11300, 0xb90c286e
0, 2096755, 11300, 0xbc7e333d
0, 2114676, 11300, 0x1b5421f8
0, 2132597, 11300, 0xdde6506d
0, 2150518, 11300, 0xd3eb757e
0, 2168439, 11300, 0x5ad1929c
0, 2186360, 11300, 0x4f6aa47d
0, 2204281, 11300, 0xab3caf55
0, 2222202, 11300, 0x5ff9b39a
0, 2240123, 11300, 0x1454e12e
0, 2258043, 11300, 0xf18216e8
0, 2275964, 11300, 0x62144880
0, 2293885, 11300, 0x54284241
0, 2311806, 11300, 0x8e8c7228
0, 2329727, 11300, 0xb498d06e
0, 2347648, 11300, 0x7b1e6be1
0, 2365569, 11300, 0x5e5ea1f4
0, 2383490, 11300, 0x41eda28e
0, 2401411, 11300, 0x7ba6aa92
0, 2419332, 11300, 0xa8a8b1c7
0, 2437253, 11300, 0x0d30bd08
0, 2455174, 11300, 0xc610bf16
0, 2473095, 11300, 0xed57c075
0, 2491016, 11300, 0xb86dbfea
0, 2508937, 11300, 0x0970c03d
0, 2526858, 11300, 0x743ac2ac
0, 2544779, 11300, 0x0a44c816
0, 2562700, 11300, 0xe32acd6b
0, 2580621, 11300, 0x209bcdab
0, 2598542, 11300, 0x3cd0d105
0, 2616463, 11300, 0xc0bcd330
0, 2634384, 11300, 0x4785d6dc
0, 2652305, 11300, 0xe85f9c90
0, 2670226, 11300, 0xd4a72850
0, 2688147, 11300, 0x04766e41
0, 2706068, 11300, 0x04766e41

423
tests/ref/fate/smjpeg Normal file
View File

@ -0,0 +1,423 @@
0, 0, 734, 0x5a042c2c
1, 0, 1024, 0x00000000
1, 2090, 1024, 0x00000000
1, 4180, 1024, 0xd89a448e
1, 6269, 1024, 0x695b369c
1, 8359, 1024, 0xc8ba5707
0, 9990, 763, 0xb5893f2f
1, 10449, 1024, 0xdf241fc6
1, 12539, 1024, 0x61cf4166
1, 14629, 1024, 0x97cbc386
1, 16718, 1024, 0x44899d04
1, 18808, 1024, 0xa7cbaa62
0, 19980, 3023, 0x0f3907d3
1, 20898, 1024, 0xa7aea60c
1, 22988, 1024, 0xd7b18a89
1, 25078, 1024, 0x268e81f6
1, 27167, 1024, 0x9cf83a2f
1, 29257, 1024, 0x5559b508
0, 29970, 4800, 0x22e6e18a
1, 31347, 1024, 0xe1b9e71c
1, 33437, 1024, 0xdcee733e
1, 35527, 1024, 0xe5918f60
1, 37616, 1024, 0x29dbd209
1, 39706, 1024, 0x9bcbcf16
0, 39960, 6417, 0x427adde5
1, 41796, 1024, 0x86f5f458
1, 43886, 1024, 0xabcbda86
1, 45976, 1024, 0xc51f77b9
1, 48065, 1024, 0xf6b3a504
0, 49950, 6776, 0x7a74c6ad
1, 50155, 1024, 0x1af3e40e
1, 52245, 1024, 0x3866b03b
1, 54335, 1024, 0xbc005403
1, 56424, 1024, 0xe9dfcc51
1, 58514, 1024, 0x83c837cb
0, 59940, 6808, 0x1f6eb7c3
1, 60604, 1024, 0xfa649580
1, 62694, 1024, 0x519452ea
1, 64784, 1024, 0xd4978774
1, 66873, 1024, 0xe2a3b1cd
1, 68963, 1024, 0x9a9472ad
0, 69930, 6726, 0x452087e6
1, 71053, 1024, 0xa12d4060
1, 73143, 1024, 0x31fb0646
1, 75233, 1024, 0xfc44343f
1, 77322, 1024, 0x0847751a
1, 79412, 1024, 0x227968a2
0, 79920, 6829, 0xee82b109
1, 81502, 1024, 0x7cce9f1c
1, 83592, 1024, 0xb8356713
1, 85682, 1024, 0xb29f6e6f
1, 87771, 1024, 0x9e1430ab
1, 89861, 1024, 0x26d85423
0, 89910, 7055, 0xf41f1108
1, 91951, 1024, 0x6496547d
1, 94041, 1024, 0x316b1a86
1, 96131, 1024, 0x3cd83afc
1, 98220, 1024, 0x993ff633
0, 99990, 6977, 0xf8fe1ede
1, 100310, 1024, 0x0708d1a2
1, 102400, 1024, 0xd7230db9
1, 104490, 1024, 0xbb0779ca
1, 106580, 1024, 0xc6094e1b
1, 108669, 1024, 0x15a8b039
0, 109980, 6942, 0x9ad105c6
1, 110759, 1024, 0xd6dbe88c
1, 112849, 1024, 0x7e8d1140
1, 114939, 1024, 0xef88e525
1, 117029, 1024, 0x44e21149
1, 119118, 1024, 0x65b0f5f4
0, 119970, 6926, 0xe239dad6
1, 121208, 1024, 0xb955f687
1, 123298, 1024, 0xc85fba9c
1, 125388, 1024, 0xf59655ad
1, 127478, 1024, 0x6de80bf1
1, 129567, 1024, 0x2dcf6e41
0, 129960, 6966, 0x81dcfab1
1, 131657, 1024, 0xd0ddcf8a
1, 133747, 1024, 0x00135c2d
1, 135837, 1024, 0x697f8efd
1, 137927, 1024, 0x7a9bada5
0, 139950, 6896, 0x31e6cc02
1, 140016, 1024, 0x0d22783c
1, 142106, 1024, 0x7726d07d
1, 144196, 1024, 0xa2f14f67
1, 146286, 1024, 0x7f51060d
1, 148376, 1024, 0xc4ec6aea
0, 149940, 6889, 0x1cc1006e
1, 150465, 1024, 0x9bb37ca4
1, 152555, 1024, 0x9b085577
1, 154645, 1024, 0x8812f8af
1, 156735, 1024, 0x788f5221
1, 158824, 1024, 0x3a2ce642
0, 159930, 6933, 0xc303f87f
1, 160914, 1024, 0x72415692
1, 163004, 1024, 0xe3dcc105
1, 165094, 1024, 0xb26c0599
1, 167184, 1024, 0x5c9e55eb
1, 169273, 1024, 0x8fe88707
0, 169920, 7034, 0xb4970a20
1, 171363, 1024, 0xc5d7beb6
1, 173453, 1024, 0xe1d3a3b4
1, 175543, 1024, 0x012da0c6
1, 177633, 1024, 0x8d010922
1, 179722, 1024, 0x3366eb0d
0, 179910, 6961, 0xf064095d
1, 181812, 1024, 0xc9381a27
1, 183902, 1024, 0x0774f685
1, 185992, 1024, 0xc5cae0a5
1, 188082, 1024, 0xa6f4737c
0, 189990, 7089, 0x5ba350f9
1, 190171, 1024, 0x8fb6d0d1
1, 192261, 1024, 0x05f579c2
1, 194351, 1024, 0x56905d99
1, 196441, 1024, 0x002ee18d
1, 198531, 1024, 0xeb37ef51
0, 199980, 7078, 0xa83f3e88
1, 200620, 1024, 0x38025635
1, 202710, 1024, 0x4fe643c8
1, 204800, 1024, 0x11d66ab1
1, 206890, 1024, 0xcc3051e9
1, 208980, 1024, 0xcd93e854
0, 209970, 7147, 0xcda66cfc
1, 211069, 1024, 0x38f1196d
1, 213159, 1024, 0x657a15fc
1, 215249, 1024, 0x669ce2a9
1, 217339, 1024, 0x95862dda
1, 219429, 1024, 0x1726a7b2
0, 219960, 7173, 0xb7455859
1, 221518, 1024, 0xd6ece2a1
1, 223608, 1024, 0x33ab9553
1, 225698, 1024, 0xd50c73a6
1, 227788, 1024, 0xfe25b63a
1, 229878, 1024, 0x7e2959e3
0, 229950, 7213, 0x97b89994
1, 231967, 1024, 0xa4c07b34
1, 234057, 1024, 0xd6d8f15c
1, 236147, 1024, 0x1eccddd7
1, 238237, 1024, 0x2b69f9cb
0, 239940, 7170, 0xca8b2948
1, 240327, 1024, 0x667b775f
1, 242416, 1024, 0xad3b84e9
1, 244506, 1024, 0x4f29fc67
1, 246596, 1024, 0x8d611ab7
1, 248686, 1024, 0x278966ea
0, 249930, 7174, 0xc7cc6bbb
1, 250776, 1024, 0xaf33812b
1, 252865, 1024, 0xa55f4265
1, 254955, 1024, 0x023cb51c
1, 257045, 1024, 0x1d1f1005
1, 259135, 1024, 0x874cccf7
0, 259920, 7235, 0xc2e68d2b
1, 261224, 1024, 0xda705428
1, 263314, 1024, 0x48d9b440
1, 265404, 1024, 0xa14e0712
1, 267494, 1024, 0x7efbad1f
1, 269584, 1024, 0xdb82c17f
0, 270000, 7261, 0x8204a423
1, 271673, 1024, 0xcbe87613
1, 273763, 1024, 0x3a63df1d
1, 275853, 1024, 0xd5636bba
1, 277943, 1024, 0x9397af23
0, 279990, 7353, 0xacc7e7c0
1, 280033, 1024, 0x32a07c98
1, 282122, 1024, 0x202ca667
1, 284212, 1024, 0xdf969011
1, 286302, 1024, 0xc434d238
1, 288392, 1024, 0xe9ad7562
0, 289980, 7065, 0x45035c5c
1, 290482, 1024, 0xb51b6b50
1, 292571, 1024, 0xe70aecd3
1, 294661, 1024, 0x03c816b2
1, 296751, 1024, 0x869fdf25
1, 298841, 1024, 0xd40a0a62
0, 299970, 7269, 0x72edbb76
1, 300931, 1024, 0x5af7dd35
1, 303020, 1024, 0x891ffc72
1, 305110, 1024, 0x1ff68a08
1, 307200, 1024, 0x5a7517a9
1, 309290, 1024, 0x0f959f74
0, 309960, 7220, 0xb926772f
1, 311380, 1024, 0xe92a12a2
1, 313469, 1024, 0x38000e55
1, 315559, 1024, 0x39fbdd70
1, 317649, 1024, 0xca3d9184
1, 319739, 1024, 0x66c8995b
0, 319950, 7326, 0x0a66c632
1, 321829, 1024, 0xac25acea
1, 323918, 1024, 0x3cd1046c
1, 326008, 1024, 0x6a1df31c
1, 328098, 1024, 0x21ca10a1
0, 329940, 7225, 0xe39076ab
1, 330188, 1024, 0x1aeccedc
1, 332278, 1024, 0xddea1335
1, 334367, 1024, 0x19f5ca9f
1, 336457, 1024, 0x88e95e43
1, 338547, 1024, 0x726284fe
0, 339930, 7265, 0xe0209036
1, 340637, 1024, 0x6b85b40e
1, 342727, 1024, 0x111fee2a
1, 344816, 1024, 0x3656b588
1, 346906, 1024, 0xa5a2b552
1, 348996, 1024, 0x38fb2467
0, 349920, 7337, 0x7a5dc093
1, 351086, 1024, 0xaa919ccc
1, 353176, 1024, 0x15993dbc
1, 355265, 1024, 0xbe01a7b9
1, 357355, 1024, 0xefe93c09
1, 359445, 1024, 0x1bb566e5
0, 360000, 7246, 0x519a7a3c
1, 361535, 1024, 0x15ce6237
1, 363624, 1024, 0xa8552e66
1, 365714, 1024, 0x9d80187e
1, 367804, 1024, 0x5df3fc30
1, 369894, 1024, 0x1a312aa5
0, 369990, 7266, 0x352c8078
1, 371984, 1024, 0x6bb8e302
1, 374073, 1024, 0xbd9684bb
1, 376163, 1024, 0x78b0b166
1, 378253, 1024, 0xd9af5eae
0, 379980, 7323, 0xcaf69d7c
1, 380343, 1024, 0xdb90fe82
1, 382433, 1024, 0x327614e9
1, 384522, 1024, 0x1f19b7fe
1, 386612, 1024, 0x46c53f96
1, 388702, 1024, 0x921b2189
0, 389970, 7309, 0x98c1e6f7
1, 390792, 1024, 0xa8fbc85a
1, 392882, 1024, 0xabfdaaae
1, 394971, 1024, 0x6acc7387
1, 397061, 1024, 0x0d9c27b5
1, 399151, 1024, 0xba4dd809
0, 399960, 7121, 0x913d5bd6
1, 401241, 1024, 0x2a2ad521
1, 403331, 1024, 0x892de38a
1, 405420, 1024, 0xdc97a2eb
1, 407510, 1024, 0x4f614ca4
1, 409600, 1024, 0x9c8a77ea
0, 409950, 7088, 0x56302362
1, 411690, 1024, 0x2d30e646
1, 413780, 1024, 0x74e800a7
1, 415869, 1024, 0x1e01fb02
1, 417959, 1024, 0x4ed2c1d8
0, 419940, 7104, 0xc0d14f78
1, 420049, 1024, 0xf2fdbe63
1, 422139, 1024, 0x8d6f63a1
1, 424229, 1024, 0xded468d9
1, 426318, 1024, 0xccad839e
1, 428408, 1024, 0xdde7c082
0, 429930, 7169, 0xd03c825b
1, 430498, 1024, 0x548613c5
1, 432588, 1024, 0x383909bd
1, 434678, 1024, 0xfd37627b
1, 436767, 1024, 0x6d95a481
1, 438857, 1024, 0x56aa87fa
0, 439920, 7038, 0x1ecc201d
1, 440947, 1024, 0x7b67258c
1, 443037, 1024, 0x7dd99a92
1, 445127, 1024, 0x4a66d102
1, 447216, 1024, 0x7b3fce51
1, 449306, 1024, 0xbbd968aa
0, 450000, 7015, 0x83c94454
1, 451396, 1024, 0x8283ec36
1, 453486, 1024, 0x3c96493d
1, 455576, 1024, 0xfa4f8cf8
1, 457665, 1024, 0xe2cf872d
1, 459755, 1024, 0x0a9e7aa6
0, 459990, 6983, 0x9e51f54d
1, 461845, 1024, 0x6e7a0550
1, 463935, 1024, 0x3acfea2f
1, 466024, 1024, 0x7111d0fa
1, 468114, 1024, 0xe9a1eca9
0, 469980, 7088, 0x70d33de1
1, 470204, 1024, 0x24da6c46
1, 472294, 1024, 0x117cff37
1, 474384, 1024, 0x0f27cab6
1, 476473, 1024, 0x69b6b4e6
1, 478563, 1024, 0x1e6cc841
0, 479970, 7096, 0x4d0f81b5
1, 480653, 1024, 0xb01e2365
1, 482743, 1024, 0x14e200d3
1, 484833, 1024, 0xd1184c98
1, 486922, 1024, 0xef9140e9
1, 489012, 1024, 0x4cbb645e
0, 489960, 7106, 0xd1a83ddc
1, 491102, 1024, 0xe7fe2f06
1, 493192, 1024, 0xf8c45028
1, 495282, 1024, 0x561358f4
1, 497371, 1024, 0xd0129b77
1, 499461, 1024, 0xcc636e88
0, 499950, 7219, 0x20f47fe4
1, 501551, 1024, 0xe9406321
1, 503641, 1024, 0x9f16a041
1, 505731, 1024, 0x468bf409
1, 507820, 1024, 0x3df70f7b
1, 509910, 1024, 0xa880b11b
0, 509940, 7184, 0x45dc6a0e
1, 512000, 1024, 0x3286c489
1, 514090, 1024, 0x39fe9ebc
1, 516180, 1024, 0xc533d83b
1, 518269, 1024, 0x153b195d
0, 519930, 7222, 0x488c6499
1, 520359, 1024, 0xd84786a1
1, 522449, 1024, 0xdc295aaa
1, 524539, 1024, 0xfb764d8c
1, 526629, 1024, 0xeebc9db9
1, 528718, 1024, 0x7ba9403e
0, 529920, 7254, 0xbd097ba7
1, 530808, 1024, 0x4e5571ec
1, 532898, 1024, 0xd965fad4
1, 534988, 1024, 0x87e259f2
1, 537078, 1024, 0xae7e533b
1, 539167, 1024, 0x313cf4d6
0, 540000, 7189, 0x46e06d43
1, 541257, 1024, 0xe1844c90
1, 543347, 1024, 0xbb057b44
1, 545437, 1024, 0xa5099687
1, 547527, 1024, 0xbff10707
1, 549616, 1024, 0x37c4ffc0
0, 549990, 7283, 0x19dd7319
1, 551706, 1024, 0xf9fb6caa
1, 553796, 1024, 0x3b6a3a1f
1, 555886, 1024, 0x83431edb
1, 557976, 1024, 0x1eb713cf
0, 559980, 7161, 0x23171d02
1, 560065, 1024, 0xd7b07a6d
1, 562155, 1024, 0x81ae3391
1, 564245, 1024, 0xf150130a
1, 566335, 1024, 0x09678eaa
1, 568424, 1024, 0xb94e06f1
0, 569970, 6976, 0xcc610c26
1, 570514, 1024, 0x67b1dbc9
1, 572604, 1024, 0xd6edc235
1, 574694, 1024, 0x34e4c499
1, 576784, 1024, 0xeefd89c0
1, 578873, 1024, 0x38afdaf1
0, 579960, 7056, 0x6cd917b0
1, 580963, 1024, 0x29a60d76
1, 583053, 1024, 0xe28a4372
1, 585143, 1024, 0x7089454d
1, 587233, 1024, 0x0c01bb7b
1, 589322, 1024, 0xbd776a72
0, 589950, 6736, 0x02b78951
1, 591412, 1024, 0x86776fd0
1, 593502, 1024, 0xb37c88f7
1, 595592, 1024, 0x5f90aaf8
1, 597682, 1024, 0x203d4222
1, 599771, 1024, 0x382692a6
0, 599940, 6540, 0x767e0854
1, 601861, 1024, 0xf37c95fd
1, 603951, 1024, 0x6c0b8877
1, 606041, 1024, 0x2e54a8b6
1, 608131, 1024, 0x7f266488
0, 609930, 6170, 0xc84962fb
1, 610220, 1024, 0xfbf20f9a
1, 612310, 1024, 0xf2985cc0
1, 614400, 1024, 0xc7075340
1, 616490, 1024, 0xe4585695
1, 618580, 1024, 0xbdffa380
0, 619920, 6169, 0x27e06c03
1, 620669, 1024, 0x2422a8a9
1, 622759, 1024, 0x59cbd75f
1, 624849, 1024, 0x04ad1a8c
1, 626939, 1024, 0x33c09191
1, 629029, 1024, 0x55efa6fd
0, 630000, 5864, 0xd14db83f
1, 631118, 1024, 0xf73d0e5d
1, 633208, 1024, 0x6141ebae
1, 635298, 1024, 0x7db17a68
1, 637388, 1024, 0xa6c690b6
1, 639478, 1024, 0xa6fd6725
0, 639990, 5375, 0x4a21055d
1, 641567, 1024, 0x50a90b9b
1, 643657, 1024, 0xef990dc8
1, 645747, 1024, 0x75adf6b5
1, 647837, 1024, 0x61eac43e
1, 649927, 1024, 0x67797a19
0, 649980, 5206, 0x95ead3cb
1, 652016, 1024, 0xf325277a
1, 654106, 1024, 0x18bf254a
1, 656196, 1024, 0x2ce6bee3
1, 658286, 1024, 0x8d320860
0, 659970, 5220, 0xcfdcc37e
1, 660376, 1024, 0xc979b6e8
1, 662465, 1024, 0xdb644b41
1, 664555, 1024, 0xe1b368ba
1, 666645, 1024, 0xacc53d15
1, 668735, 1024, 0x42ea8c18
0, 669960, 4946, 0x2d864a77
1, 670824, 1024, 0xe52c99a4
1, 672914, 1024, 0xd7db54a6
1, 675004, 1024, 0x7f27a7e3
1, 677094, 1024, 0xf7ffeaa9
1, 679184, 1024, 0x792b6088
0, 679950, 4390, 0x2ab9f462
1, 681273, 1024, 0x61d99724
1, 683363, 1024, 0x5213720e
1, 685453, 1024, 0xac09dd30
1, 687543, 1024, 0x960bf6bb
1, 689633, 1024, 0xc90168e1
0, 689940, 4051, 0x1d09592e
1, 691722, 1024, 0x43b45768
1, 693812, 1024, 0x935d60a1
1, 695902, 1024, 0x9a342ef2
1, 697992, 1024, 0xc894709f
0, 699930, 3680, 0x39bd6a12
1, 700082, 1024, 0x59b43b07
1, 702171, 1024, 0x36a1a98d
1, 704261, 1024, 0x9e1a121c
1, 706351, 1024, 0x02208b78
1, 708441, 1024, 0xd1d7b274
0, 709920, 2910, 0x6337ece9
1, 710531, 1024, 0xdacd5096
1, 712620, 1024, 0x51b71ead
1, 714710, 1024, 0xd009a7ca
1, 716800, 1024, 0xb6d5a938
1, 718890, 1024, 0xf3d45e47
0, 720000, 2153, 0xf4e3bc17
1, 720980, 1024, 0xea8e04fc
1, 723069, 1024, 0x0b928bd8
1, 725159, 1024, 0x0f02caec
1, 727249, 1024, 0xe2b137a8
1, 729339, 1024, 0xd5f94892

120
tests/ref/fate/vc1-ism Normal file
View File

@ -0,0 +1,120 @@
0, 0, 37440, 0xd1bc5235
0, 3750, 37440, 0x158e6167
0, 7500, 37440, 0x0faa4481
0, 11250, 37440, 0x427158c5
0, 15000, 37440, 0x4eb53ac6
0, 18750, 37440, 0x99304eea
0, 22500, 37440, 0xcc554a6f
0, 26250, 37440, 0xabeb6c35
0, 30000, 37440, 0xddfc7e18
0, 33750, 37440, 0xaa79b504
0, 37500, 37440, 0x5cb1c839
0, 41250, 37440, 0x7e36ecca
0, 45000, 37440, 0xf486f425
0, 48750, 37440, 0xf1b4138f
0, 52500, 37440, 0x966f1a49
0, 56250, 37440, 0x5eff21da
0, 60000, 37440, 0x333f39b1
0, 63750, 37440, 0x62e5963e
0, 67500, 37440, 0x26930671
0, 71250, 37440, 0x27b4bb6c
0, 75000, 37440, 0xdbd07766
0, 78750, 37440, 0x04260104
0, 82500, 37440, 0x9b1e078b
0, 86250, 37440, 0xdf4e2474
0, 90000, 37440, 0x57d44986
0, 93750, 37440, 0x8780e34c
0, 97500, 37440, 0xf80c8bc0
0, 101250, 37440, 0x630a7583
0, 105000, 37440, 0x235ae089
0, 108750, 37440, 0x984b8f0e
0, 112500, 37440, 0x865cf592
0, 116250, 37440, 0x70f376f2
0, 120000, 37440, 0x8b30c035
0, 123750, 37440, 0xde772d79
0, 127500, 37440, 0x8e076be5
0, 131250, 37440, 0x3dc2bd9f
0, 135000, 37440, 0xb782eb67
0, 138750, 37440, 0x02025d73
0, 142500, 37440, 0x86bbbce8
0, 146250, 37440, 0xd6554f62
0, 150000, 37440, 0xb831b917
0, 153750, 37440, 0x80643560
0, 157500, 37440, 0x4ecf9afd
0, 161250, 37440, 0x9ce51e0b
0, 165000, 37440, 0x179466cd
0, 168750, 37440, 0x145fc900
0, 172500, 37440, 0xb1b50402
0, 176250, 37440, 0x0a87552a
0, 180000, 37440, 0x8f53821d
0, 183750, 37440, 0x1c07c825
0, 187500, 37440, 0x49dde82f
0, 191250, 37440, 0xb1a32605
0, 195000, 37440, 0x410f3cd5
0, 198750, 37440, 0xff5e6696
0, 202500, 37440, 0x96f678c9
0, 206250, 37440, 0x6c9e9e68
0, 210000, 37440, 0x79a2a655
0, 213750, 37440, 0xf237bd6c
0, 217500, 37440, 0x4051b611
0, 221250, 37440, 0xc7ccc918
0, 225000, 37440, 0xbd02c122
0, 228750, 37440, 0xacb3c881
0, 232500, 37440, 0x2abdb940
0, 236250, 37440, 0x19d5be85
0, 240000, 37440, 0xfa5fb1ba
0, 243750, 37440, 0xdae7a7aa
0, 247500, 37440, 0x6b0f9f69
0, 251250, 37440, 0x353e8201
0, 255000, 37440, 0xa21443aa
0, 258750, 37440, 0x66c8d7e0
0, 262500, 37440, 0xc332068e
0, 266250, 37440, 0x71431b9b
0, 270000, 37440, 0x392f15cb
0, 273750, 37440, 0x95a146bb
0, 277500, 37440, 0x7c51740a
0, 281250, 37440, 0xa3bdd43c
0, 285000, 37440, 0xa079f965
0, 288750, 37440, 0xa95423ea
0, 292500, 37440, 0xd1bd2c67
0, 296250, 37440, 0x6cf82844
0, 300000, 37440, 0xd401e128
0, 303750, 37440, 0x1f7db118
0, 307500, 37440, 0x2e0a65a9
0, 311250, 37440, 0x321c1c40
0, 315000, 37440, 0x95b2a127
0, 318750, 37440, 0xa1471f4b
0, 322500, 37440, 0x29d148c0
0, 326250, 37440, 0x24c07107
0, 330000, 37440, 0x0ead678d
0, 333750, 37440, 0xd0ca6495
0, 337500, 37440, 0x08f935ef
0, 341250, 37440, 0xb5ec3c38
0, 345000, 37440, 0xce371628
0, 348750, 37440, 0x68170812
0, 352500, 37440, 0xe222699e
0, 356250, 37440, 0xd688706c
0, 360000, 37440, 0x81a033f9
0, 363750, 37440, 0x28bd0fbf
0, 367500, 37440, 0xe36db7b2
0, 371250, 37440, 0x30559121
0, 375000, 37440, 0xbf2b5fc8
0, 378750, 37440, 0x4b427672
0, 382500, 37440, 0x0544b0b4
0, 386250, 37440, 0x38a70b06
0, 390000, 37440, 0x4ed62607
0, 393750, 37440, 0x6efe8ea6
0, 397500, 37440, 0x81197e11
0, 401250, 37440, 0xf4060050
0, 405000, 37440, 0xaf205f13
0, 408750, 37440, 0x5fa21382
0, 412500, 37440, 0x8627ad05
0, 416250, 37440, 0xf7130133
0, 420000, 37440, 0x76dea7ba
0, 423750, 37440, 0x1dbae1be
0, 427500, 37440, 0x74a933f7
0, 431250, 37440, 0xbdcd41a3
0, 435000, 37440, 0xf0fe8c1c
0, 438750, 37440, 0xc0036222
0, 442500, 37440, 0x3058385c
0, 446250, 37440, 0x68141016

139
tests/ref/fate/wtv-demux Normal file
View File

@ -0,0 +1,139 @@
1, 0, 576, 0x9b6e1638
1, 1620, 576, 0x0ca91183
1, 3780, 576, 0xec6a180f
1, 5940, 576, 0x478a2b9b
1, 8100, 576, 0x00fa15b3
1, 10260, 576, 0xfb551816
1, 12960, 576, 0x422e12bd
1, 15120, 576, 0xa7581b29
1, 17280, 576, 0xd4b31a74
1, 19440, 576, 0x11521b10
1, 21600, 576, 0x3dcc1474
1, 23760, 576, 0x66c31aab
1, 25920, 576, 0x97f318a8
1, 28080, 576, 0xd3fb1a30
1, 30240, 576, 0xd2bd16af
1, 32400, 576, 0x6c10146a
1, 34560, 576, 0x10d81468
1, 36720, 576, 0x3813162d
1, 38880, 576, 0x89e71d95
1, 41040, 576, 0xd1c717f9
1, 43200, 576, 0x1a311e5f
1, 45360, 576, 0x0ea80e05
1, 47520, 576, 0x2f1718f2
1, 49680, 576, 0xffe01e13
1, 51840, 576, 0xa7b02296
1, 54000, 576, 0x199f1597
1, 56160, 576, 0xdea217ba
1, 58320, 576, 0x8a790f01
1, 60480, 576, 0x23e80038
1, 62640, 576, 0x75dc048a
1, 64800, 576, 0xeb4b0d93
1, 66960, 576, 0xde1322f5
1, 69120, 576, 0xc3131f35
1, 71280, 576, 0x708f1381
1, 73440, 576, 0x1f00137e
0, 74578, 41980, 0xd4920915
1, 75600, 576, 0x05131eb0
1, 77760, 576, 0x78151c22
0, 78178, 7228, 0x1b141fa3
1, 79920, 576, 0x31771239
0, 81777, 7492, 0x1a47f3e4
1, 82080, 576, 0x3ce4097c
1, 84240, 576, 0x180e15f4
0, 85378, 25068, 0xcb70a744
1, 86400, 576, 0x30db0604
1, 88560, 576, 0x9b290284
0, 88978, 7212, 0x0ab9f558
1, 90720, 576, 0xcf340753
0, 92578, 7612, 0xa93054f0
1, 92880, 576, 0xdaa41457
1, 95040, 576, 0x34d310a2
0, 96177, 22868, 0xa77db64a
1, 97200, 576, 0x58b31010
1, 99360, 576, 0x19610f54
0, 99778, 6260, 0x6cf76411
1, 101520, 576, 0x17762352
0, 103377, 6156, 0xe168394b
1, 103680, 576, 0x1fea1448
1, 105840, 576, 0x55840a01
0, 106977, 23364, 0x53164f1e
1, 108000, 576, 0x6c9c24ce
1, 110160, 576, 0x955f1e97
0, 110578, 6708, 0x89877269
1, 112320, 576, 0x2827134f
0, 114178, 6908, 0x8d62a249
1, 114480, 576, 0x34a01c29
1, 116640, 576, 0x7d351e52
0, 117778, 38156, 0xec41f682
1, 118800, 576, 0x00c91d9e
1, 120960, 576, 0x57ea1a97
0, 121377, 5764, 0xcc04534b
1, 123120, 576, 0xef3a1c74
0, 124977, 5388, 0xb8a1c3c5
1, 125280, 576, 0x11fc217d
1, 127440, 576, 0x59ce20e5
0, 128578, 16764, 0x59460d96
1, 129600, 576, 0xaafc1dbf
1, 131760, 576, 0xdd941609
0, 132177, 5548, 0x5c91e93d
1, 133920, 576, 0x900420b0
0, 135777, 5652, 0x5e321aed
1, 136080, 576, 0x5f4f1aa1
1, 138240, 576, 0x7d7e18de
0, 139377, 15564, 0xefdf5080
1, 140400, 576, 0x986c0d9d
1, 142560, 576, 0xcb4c21c0
0, 142977, 6492, 0xd1d5c5f8
1, 144720, 576, 0xbcfb1e8b
0, 146577, 5604, 0xf9472b44
1, 146880, 576, 0xcb541b4c
1, 149040, 576, 0x980426e9
0, 150177, 17924, 0x45815b7b
1, 151200, 576, 0x09d00aa0
1, 153360, 576, 0xad591374
0, 153778, 5020, 0x3cc5e554
1, 155520, 576, 0x97bf1461
0, 157378, 5276, 0xa0554c12
1, 157680, 576, 0xdc871cc4
1, 159840, 576, 0x56781896
0, 160977, 31460, 0x5765eb5f
1, 162000, 576, 0xc77714e3
1, 164160, 576, 0x280e18d4
0, 164577, 4972, 0x91adbab7
1, 166320, 576, 0xbc0d2302
0, 168178, 5580, 0xfea707cb
1, 168480, 576, 0x79191384
1, 170640, 576, 0x65481c97
0, 171778, 17412, 0x0afe4d27
1, 172800, 576, 0xc94d227d
1, 174960, 576, 0xa68a1f14
0, 175378, 5236, 0x03f55309
1, 177120, 576, 0x6af11a5c
0, 178977, 4924, 0x558e753c
1, 179280, 576, 0x4d1019ef
1, 181440, 576, 0x3b1b17b5
0, 182577, 15396, 0xf145d121
1, 183600, 576, 0xcdd8159f
1, 185760, 576, 0x97cd1d06
0, 186177, 4708, 0x43066a92
1, 187920, 576, 0x5d1b1123
0, 189778, 4332, 0x9e22bcba
1, 190080, 576, 0x888d0cb0
1, 192240, 576, 0x556e1dad
0, 193377, 12876, 0x46ff9ef4
1, 194400, 576, 0xf7af0bce
1, 196560, 576, 0xb5da160a
0, 196978, 5940, 0x27cba62e
1, 198720, 576, 0x4a8d0e98
0, 200578, 6124, 0x6bab0a6d
1, 200880, 576, 0x183b1c7e
1, 203040, 576, 0xc47120e6
0, 204178, 36428, 0x942f9648
1, 205200, 576, 0xb1f31346
0, 207777, 6660, 0x545a0db7
0, 211377, 6780, 0x2d1d4189
0, 214978, 16460, 0x7c3b3ca4
0, 218578, 6724, 0x8538cc6f
0, 222178, 7068, 0x69574fd0
0, 225777, 19552, 0xf230e854

1
tests/ref/fate/xwma-demux Normal file
View File

@ -0,0 +1 @@
CRC=0x2ac2159e

4
tests/ref/lavfi/pixdesc
View File

@ -4,6 +4,8 @@ abgr 037bf9df6a765520ad6d490066bf4b89
argb c442a8261c2265a07212ef0f72e35f5a argb c442a8261c2265a07212ef0f72e35f5a
bgr0 0ef8ffe42bfe53be74973a0c118b775e bgr0 0ef8ffe42bfe53be74973a0c118b775e
bgr24 0d0cb38ab3fa0b2ec0865c14f78b217b bgr24 0d0cb38ab3fa0b2ec0865c14f78b217b
bgr444be d9ea9307d21b162225b8b2c524cf9477
bgr444le 88035350e9da3a8f67387890b956f0bc
bgr48be 00624e6c7ec7ab19897ba2f0a3257fe8 bgr48be 00624e6c7ec7ab19897ba2f0a3257fe8
bgr48le d02c235ebba7167881ca2d576497ff84 bgr48le d02c235ebba7167881ca2d576497ff84
bgr4_byte 50d23cc82d9dcef2fd12adb81fb9b806 bgr4_byte 50d23cc82d9dcef2fd12adb81fb9b806
@ -22,6 +24,8 @@ nv12 e0af357888584d36eec5aa0f673793ef
nv21 9a3297f3b34baa038b1f37cb202b512f nv21 9a3297f3b34baa038b1f37cb202b512f
rgb0 7c03f81f5e5346bf8ea42c4187f20605 rgb0 7c03f81f5e5346bf8ea42c4187f20605
rgb24 b41eba9651e1b5fe386289b506188105 rgb24 b41eba9651e1b5fe386289b506188105
rgb444be 9e89db334568c6b2e3d5d0540f4ba960
rgb444le 0a68cb6de8bf530aa30c5c1205c25155
rgb48be cc139ec1dd9451f0e049c0cb3a0c8aa2 rgb48be cc139ec1dd9451f0e049c0cb3a0c8aa2
rgb48le 86c5608904f75360d492dbc5c9589969 rgb48le 86c5608904f75360d492dbc5c9589969
rgb4_byte c93ba89b74c504e7f5ae9d9ab1546c73 rgb4_byte c93ba89b74c504e7f5ae9d9ab1546c73

4
tests/ref/lavfi/pixfmts_copy
View File

@ -4,6 +4,8 @@ abgr 037bf9df6a765520ad6d490066bf4b89
argb c442a8261c2265a07212ef0f72e35f5a argb c442a8261c2265a07212ef0f72e35f5a
bgr0 328a76e72c55508cdf04dc93a5b056fc bgr0 328a76e72c55508cdf04dc93a5b056fc
bgr24 0d0cb38ab3fa0b2ec0865c14f78b217b bgr24 0d0cb38ab3fa0b2ec0865c14f78b217b
bgr444be d9ea9307d21b162225b8b2c524cf9477
bgr444le 88035350e9da3a8f67387890b956f0bc
bgr48be 00624e6c7ec7ab19897ba2f0a3257fe8 bgr48be 00624e6c7ec7ab19897ba2f0a3257fe8
bgr48le d02c235ebba7167881ca2d576497ff84 bgr48le d02c235ebba7167881ca2d576497ff84
bgr4_byte 50d23cc82d9dcef2fd12adb81fb9b806 bgr4_byte 50d23cc82d9dcef2fd12adb81fb9b806
@ -23,6 +25,8 @@ nv21 9a3297f3b34baa038b1f37cb202b512f
pal8 dec8ed2258ec89b8a796f21cad4df867 pal8 dec8ed2258ec89b8a796f21cad4df867
rgb0 ff1a9f355d43f9d25f07a191b5aa906c rgb0 ff1a9f355d43f9d25f07a191b5aa906c
rgb24 b41eba9651e1b5fe386289b506188105 rgb24 b41eba9651e1b5fe386289b506188105
rgb444be 9e89db334568c6b2e3d5d0540f4ba960
rgb444le 0a68cb6de8bf530aa30c5c1205c25155
rgb48be cc139ec1dd9451f0e049c0cb3a0c8aa2 rgb48be cc139ec1dd9451f0e049c0cb3a0c8aa2
rgb48le 86c5608904f75360d492dbc5c9589969 rgb48le 86c5608904f75360d492dbc5c9589969
rgb4_byte c93ba89b74c504e7f5ae9d9ab1546c73 rgb4_byte c93ba89b74c504e7f5ae9d9ab1546c73

4
tests/ref/lavfi/pixfmts_null
View File

@ -4,6 +4,8 @@ abgr 037bf9df6a765520ad6d490066bf4b89
argb c442a8261c2265a07212ef0f72e35f5a argb c442a8261c2265a07212ef0f72e35f5a
bgr0 328a76e72c55508cdf04dc93a5b056fc bgr0 328a76e72c55508cdf04dc93a5b056fc
bgr24 0d0cb38ab3fa0b2ec0865c14f78b217b bgr24 0d0cb38ab3fa0b2ec0865c14f78b217b
bgr444be d9ea9307d21b162225b8b2c524cf9477
bgr444le 88035350e9da3a8f67387890b956f0bc
bgr48be 00624e6c7ec7ab19897ba2f0a3257fe8 bgr48be 00624e6c7ec7ab19897ba2f0a3257fe8
bgr48le d02c235ebba7167881ca2d576497ff84 bgr48le d02c235ebba7167881ca2d576497ff84
bgr4_byte 50d23cc82d9dcef2fd12adb81fb9b806 bgr4_byte 50d23cc82d9dcef2fd12adb81fb9b806
@ -23,6 +25,8 @@ nv21 9a3297f3b34baa038b1f37cb202b512f
pal8 dec8ed2258ec89b8a796f21cad4df867 pal8 dec8ed2258ec89b8a796f21cad4df867
rgb0 ff1a9f355d43f9d25f07a191b5aa906c rgb0 ff1a9f355d43f9d25f07a191b5aa906c
rgb24 b41eba9651e1b5fe386289b506188105 rgb24 b41eba9651e1b5fe386289b506188105
rgb444be 9e89db334568c6b2e3d5d0540f4ba960
rgb444le 0a68cb6de8bf530aa30c5c1205c25155
rgb48be cc139ec1dd9451f0e049c0cb3a0c8aa2 rgb48be cc139ec1dd9451f0e049c0cb3a0c8aa2
rgb48le 86c5608904f75360d492dbc5c9589969 rgb48le 86c5608904f75360d492dbc5c9589969
rgb4_byte c93ba89b74c504e7f5ae9d9ab1546c73 rgb4_byte c93ba89b74c504e7f5ae9d9ab1546c73

4
tests/ref/lavfi/pixfmts_scale
View File

@ -4,6 +4,8 @@ abgr cff82561a074874027ac1cc896fd2730
argb 756dd1eaa5baca2238ce23dbdc452684 argb 756dd1eaa5baca2238ce23dbdc452684
bgr0 ff6e1dfa26d4c2ada3a59e8b0b600d1f bgr0 ff6e1dfa26d4c2ada3a59e8b0b600d1f
bgr24 e44192347a45586c6c157e3059610cd1 bgr24 e44192347a45586c6c157e3059610cd1
bgr444be c23768338d76693f0da76e8a9b6fd8df
bgr444le 846c431a47bfb745437941bde768469c
bgr48be 390d3058a12a99c2b153ed7922508bea bgr48be 390d3058a12a99c2b153ed7922508bea
bgr48le 39fe06feb4ec1d9730dccc04a0cfac4c bgr48le 39fe06feb4ec1d9730dccc04a0cfac4c
bgr4_byte ee1d35a7baf8e9016891929a2f565c0b bgr4_byte ee1d35a7baf8e9016891929a2f565c0b
@ -23,6 +25,8 @@ nv21 69c699510ff1fb777b118ebee1002f14
pal8 6324fa058e1bc157ed7132bfe4022317 pal8 6324fa058e1bc157ed7132bfe4022317
rgb0 1bd6f54ad067503ac9783a70062c8f87 rgb0 1bd6f54ad067503ac9783a70062c8f87
rgb24 13ff53ebeab74dc05492836f1cfbd2c1 rgb24 13ff53ebeab74dc05492836f1cfbd2c1
rgb444be 46e466b2709f62b2fffc63708063eaaf
rgb444le f0c57a48be671428e2e53c9b54a6c4e2
rgb48be 8fac63787a711886030f8e056872b488 rgb48be 8fac63787a711886030f8e056872b488
rgb48le ab92f2763a2eb264c3870cc758f97149 rgb48le ab92f2763a2eb264c3870cc758f97149
rgb4_byte d81ffd3add95842a618eec81024f0b5c rgb4_byte d81ffd3add95842a618eec81024f0b5c

4
tests/ref/lavfi/pixfmts_vflip
View File

@ -4,6 +4,8 @@ abgr 25e72e9dbd01ab00727c976d577f7be5
argb 19869bf1a5ac0b6af4d8bbe2c104533c argb 19869bf1a5ac0b6af4d8bbe2c104533c
bgr0 e03d3ee0b977f6d86e5116b20494bef5 bgr0 e03d3ee0b977f6d86e5116b20494bef5
bgr24 89108a4ba00201f79b75b9305c42352d bgr24 89108a4ba00201f79b75b9305c42352d
bgr444be 9ef12c42fb791948ca4423c452dc6b9a
bgr444le 3650ecfc163abd1596c0cd29d130c4b0
bgr48be 2f23931844f57641f3737348182d118c bgr48be 2f23931844f57641f3737348182d118c
bgr48le 4242a026012b6c135a6aa138a6d67031 bgr48le 4242a026012b6c135a6aa138a6d67031
bgr4_byte 407fcf564ed764c38e1d748f700ab921 bgr4_byte 407fcf564ed764c38e1d748f700ab921
@ -23,6 +25,8 @@ nv21 01ea369dd2d0d3ed7451dc5c8d61497f
pal8 47ed19a7e128b0e33c25d2a463b0611a pal8 47ed19a7e128b0e33c25d2a463b0611a
rgb0 330bd6168e46c0d5eb4acbdbb50afa2e rgb0 330bd6168e46c0d5eb4acbdbb50afa2e
rgb24 eaefabc168d0b14576bab45bc1e56e1e rgb24 eaefabc168d0b14576bab45bc1e56e1e
rgb444be 06722e03f8404e7d2226665ed2444a32
rgb444le 185c9a5d9c2877484310d4196ef4cd6f
rgb48be 62dd185862ed142283bd300eb6dbd216 rgb48be 62dd185862ed142283bd300eb6dbd216
rgb48le dcb76353268bc5862194d131762220da rgb48le dcb76353268bc5862194d131762220da
rgb4_byte 8c6ff02df0b06dd2d574836c3741b2a2 rgb4_byte 8c6ff02df0b06dd2d574836c3741b2a2