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:
  build: improve rules for test programs
  build: factor out the .c and .S compile commands as a macro
  swscale: remove unused xInc/srcW arguments from hScale().
  H.264: disable 2tap qpel with CODEC_FLAG2_FAST and >8-bit
  H.264: make filter_mb_fast support 4:4:4
  mpeg4videoenc: Remove disabled variant of mpeg4_encode_block().
  configure: allow post-fixed cpu strings for athlon64, k8, and opteron when setting the -march flag.
  Move some variable declarations below the proper #ifdefs.

Conflicts:
	Makefile
	ffplay.c
	libswscale/swscale.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer 2011-06-27 03:32:45 +02:00
commit f211d9d839
11 changed files with 82 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
common.mak
View File

@ -27,20 +27,26 @@ $(eval INSTALL = @$(call ECHO,INSTALL,$$(^:$(SRC_DIR)/%=%)); $(INSTALL))
endif endif
# NASM requires -I path terminated with / # NASM requires -I path terminated with /
IFLAGS := -I. -I$(SRC_PATH)/ IFLAGS := -I. -I$(SRC_PATH)/
CPPFLAGS := $(IFLAGS) $(CPPFLAGS) CPPFLAGS := $(IFLAGS) $(CPPFLAGS)
CFLAGS += $(ECFLAGS) CFLAGS += $(ECFLAGS)
YASMFLAGS += $(IFLAGS) -Pconfig.asm CCFLAGS = $(CFLAGS)
YASMFLAGS += $(IFLAGS) -Pconfig.asm
HOSTCFLAGS += $(IFLAGS) HOSTCFLAGS += $(IFLAGS)
define COMPILE
$($(1)DEP)
$($(1)) $(CPPFLAGS) $($(1)FLAGS) $($(1)_DEPFLAGS) -c $($(1)_O) $<
endef
COMPILE_C = $(call COMPILE,CC)
COMPILE_S = $(call COMPILE,AS)
%.o: %.c %.o: %.c
$(CCDEP) $(COMPILE_C)
$(CC) $(CPPFLAGS) $(CFLAGS) $(CC_DEPFLAGS) -c $(CC_O) $<
%.o: %.S %.o: %.S
$(ASDEP) $(COMPILE_S)
$(AS) $(CPPFLAGS) $(ASFLAGS) $(AS_DEPFLAGS) -c -o $@ $<
%.ho: %.h %.ho: %.h
$(CC) $(CPPFLAGS) $(CFLAGS) -Wno-unused -c -o $@ -x c $< $(CC) $(CPPFLAGS) $(CFLAGS) -Wno-unused -c -o $@ -x c $<

2
configure vendored
View File

@ -1704,6 +1704,7 @@ SLIBNAME_WITH_VERSION='$(SLIBNAME).$(LIBVERSION)'
SLIBNAME_WITH_MAJOR='$(SLIBNAME).$(LIBMAJOR)' SLIBNAME_WITH_MAJOR='$(SLIBNAME).$(LIBMAJOR)'
LIB_INSTALL_EXTRA_CMD='$$(RANLIB) "$(LIBDIR)/$(LIBNAME)"' LIB_INSTALL_EXTRA_CMD='$$(RANLIB) "$(LIBDIR)/$(LIBNAME)"'
AS_O='-o $@'
CC_O='-o $@' CC_O='-o $@'
host_cflags='-D_ISOC99_SOURCE -O3 -g' host_cflags='-D_ISOC99_SOURCE -O3 -g'
@ -3346,6 +3347,7 @@ STRIP=$strip
CPPFLAGS=$CPPFLAGS CPPFLAGS=$CPPFLAGS
CFLAGS=$CFLAGS CFLAGS=$CFLAGS
ASFLAGS=$ASFLAGS ASFLAGS=$ASFLAGS
AS_O=$CC_O
CC_O=$CC_O CC_O=$CC_O
LDFLAGS=$LDFLAGS LDFLAGS=$LDFLAGS
FFSERVERLDFLAGS=$FFSERVERLDFLAGS FFSERVERLDFLAGS=$FFSERVERLDFLAGS

5
libavcodec/fft-test.c
View File

@ -252,8 +252,9 @@ int main(int argc, char **argv)
#if CONFIG_FFT_FLOAT #if CONFIG_FFT_FLOAT
RDFTContext r1, *r = &r1; RDFTContext r1, *r = &r1;
DCTContext d1, *d = &d1; DCTContext d1, *d = &d1;
int fft_size_2;
#endif #endif
int fft_nbits, fft_size, fft_size_2; int fft_nbits, fft_size;
double scale = 1.0; double scale = 1.0;
AVLFG prng; AVLFG prng;
av_lfg_init(&prng, 1); av_lfg_init(&prng, 1);
@ -292,7 +293,6 @@ int main(int argc, char **argv)
} }
fft_size = 1 << fft_nbits; fft_size = 1 << fft_nbits;
fft_size_2 = fft_size >> 1;
tab = av_malloc(fft_size * sizeof(FFTComplex)); tab = av_malloc(fft_size * sizeof(FFTComplex));
tab1 = av_malloc(fft_size * sizeof(FFTComplex)); tab1 = av_malloc(fft_size * sizeof(FFTComplex));
tab_ref = av_malloc(fft_size * sizeof(FFTComplex)); tab_ref = av_malloc(fft_size * sizeof(FFTComplex));
@ -372,6 +372,7 @@ int main(int argc, char **argv)
break; break;
#if CONFIG_FFT_FLOAT #if CONFIG_FFT_FLOAT
case TRANSFORM_RDFT: case TRANSFORM_RDFT:
fft_size_2 = fft_size >> 1;
if (do_inverse) { if (do_inverse) {
tab1[ 0].im = 0; tab1[ 0].im = 0;
tab1[fft_size_2].im = 0; tab1[fft_size_2].im = 0;

3
libavcodec/h264.c
View File

@ -2488,7 +2488,8 @@ static int decode_slice_header(H264Context *h, H264Context *h0){
s->dropable= h->nal_ref_idc == 0; s->dropable= h->nal_ref_idc == 0;
if((s->avctx->flags2 & CODEC_FLAG2_FAST) && !h->nal_ref_idc){ /* FIXME: 2tap qpel isn't implemented for high bit depth. */
if((s->avctx->flags2 & CODEC_FLAG2_FAST) && !h->nal_ref_idc && !h->pixel_shift){
s->me.qpel_put= s->dsp.put_2tap_qpel_pixels_tab; s->me.qpel_put= s->dsp.put_2tap_qpel_pixels_tab;
s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab; s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab;
}else{ }else{

62
libavcodec/h264_loopfilter.c
View File

@ -218,10 +218,11 @@ void ff_h264_filter_mb_fast( H264Context *h, int mb_x, int mb_y, uint8_t *img_y,
int mb_type, left_type; int mb_type, left_type;
int qp, qp0, qp1, qpc, qpc0, qpc1, qp_thresh; int qp, qp0, qp1, qpc, qpc0, qpc1, qp_thresh;
int chroma = !(CONFIG_GRAY && (s->flags&CODEC_FLAG_GRAY)); int chroma = !(CONFIG_GRAY && (s->flags&CODEC_FLAG_GRAY));
int chroma444 = CHROMA444;
mb_xy = h->mb_xy; mb_xy = h->mb_xy;
if(!h->top_type || !h->h264dsp.h264_loop_filter_strength || h->pps.chroma_qp_diff || CHROMA444) { if(!h->top_type || !h->h264dsp.h264_loop_filter_strength || h->pps.chroma_qp_diff) {
ff_h264_filter_mb(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize); ff_h264_filter_mb(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize);
return; return;
} }
@ -264,16 +265,46 @@ void ff_h264_filter_mb_fast( H264Context *h, int mb_x, int mb_y, uint8_t *img_y,
filter_mb_edgeh( &img_y[4*3*linesize], linesize, bS3, qp, h); filter_mb_edgeh( &img_y[4*3*linesize], linesize, bS3, qp, h);
} }
if(chroma){ if(chroma){
if(left_type){ if(chroma444){
filter_mb_edgecv( &img_cb[2*0], uvlinesize, bS4, qpc0, h); if(left_type){
filter_mb_edgecv( &img_cr[2*0], uvlinesize, bS4, qpc0, h); filter_mb_edgev( &img_cb[4*0], linesize, bS4, qpc0, h);
filter_mb_edgev( &img_cr[4*0], linesize, bS4, qpc0, h);
}
if( IS_8x8DCT(mb_type) ) {
filter_mb_edgev( &img_cb[4*2], linesize, bS3, qpc, h);
filter_mb_edgev( &img_cr[4*2], linesize, bS3, qpc, h);
filter_mb_edgeh( &img_cb[4*0*linesize], linesize, bSH, qpc1, h);
filter_mb_edgeh( &img_cr[4*0*linesize], linesize, bSH, qpc1, h);
filter_mb_edgeh( &img_cb[4*2*linesize], linesize, bS3, qpc, h);
filter_mb_edgeh( &img_cr[4*2*linesize], linesize, bS3, qpc, h);
} else {
filter_mb_edgev( &img_cb[4*1], linesize, bS3, qpc, h);
filter_mb_edgev( &img_cr[4*1], linesize, bS3, qpc, h);
filter_mb_edgev( &img_cb[4*2], linesize, bS3, qpc, h);
filter_mb_edgev( &img_cr[4*2], linesize, bS3, qpc, h);
filter_mb_edgev( &img_cb[4*3], linesize, bS3, qpc, h);
filter_mb_edgev( &img_cr[4*3], linesize, bS3, qpc, h);
filter_mb_edgeh( &img_cb[4*0*linesize], linesize, bSH, qpc1, h);
filter_mb_edgeh( &img_cr[4*0*linesize], linesize, bSH, qpc1, h);
filter_mb_edgeh( &img_cb[4*1*linesize], linesize, bS3, qpc, h);
filter_mb_edgeh( &img_cr[4*1*linesize], linesize, bS3, qpc, h);
filter_mb_edgeh( &img_cb[4*2*linesize], linesize, bS3, qpc, h);
filter_mb_edgeh( &img_cr[4*2*linesize], linesize, bS3, qpc, h);
filter_mb_edgeh( &img_cb[4*3*linesize], linesize, bS3, qpc, h);
filter_mb_edgeh( &img_cr[4*3*linesize], linesize, bS3, qpc, h);
}
}else{
if(left_type){
filter_mb_edgecv( &img_cb[2*0], uvlinesize, bS4, qpc0, h);
filter_mb_edgecv( &img_cr[2*0], uvlinesize, bS4, qpc0, h);
}
filter_mb_edgecv( &img_cb[2*2], uvlinesize, bS3, qpc, h);
filter_mb_edgecv( &img_cr[2*2], uvlinesize, bS3, qpc, h);
filter_mb_edgech( &img_cb[2*0*uvlinesize], uvlinesize, bSH, qpc1, h);
filter_mb_edgech( &img_cb[2*2*uvlinesize], uvlinesize, bS3, qpc, h);
filter_mb_edgech( &img_cr[2*0*uvlinesize], uvlinesize, bSH, qpc1, h);
filter_mb_edgech( &img_cr[2*2*uvlinesize], uvlinesize, bS3, qpc, h);
} }
filter_mb_edgecv( &img_cb[2*2], uvlinesize, bS3, qpc, h);
filter_mb_edgecv( &img_cr[2*2], uvlinesize, bS3, qpc, h);
filter_mb_edgech( &img_cb[2*0*uvlinesize], uvlinesize, bSH, qpc1, h);
filter_mb_edgech( &img_cb[2*2*uvlinesize], uvlinesize, bS3, qpc, h);
filter_mb_edgech( &img_cr[2*0*uvlinesize], uvlinesize, bSH, qpc1, h);
filter_mb_edgech( &img_cr[2*2*uvlinesize], uvlinesize, bS3, qpc, h);
} }
return; return;
} else { } else {
@ -301,9 +332,14 @@ void ff_h264_filter_mb_fast( H264Context *h, int mb_x, int mb_y, uint8_t *img_y,
#define FILTER(hv,dir,edge)\ #define FILTER(hv,dir,edge)\
if(AV_RN64A(bS[dir][edge])) { \ if(AV_RN64A(bS[dir][edge])) { \
filter_mb_edge##hv( &img_y[4*edge*(dir?linesize:1)], linesize, bS[dir][edge], edge ? qp : qp##dir, h );\ filter_mb_edge##hv( &img_y[4*edge*(dir?linesize:1)], linesize, bS[dir][edge], edge ? qp : qp##dir, h );\
if(chroma && !(edge&1)) {\ if(chroma){\
filter_mb_edgec##hv( &img_cb[2*edge*(dir?uvlinesize:1)], uvlinesize, bS[dir][edge], edge ? qpc : qpc##dir, h );\ if(chroma444){\
filter_mb_edgec##hv( &img_cr[2*edge*(dir?uvlinesize:1)], uvlinesize, bS[dir][edge], edge ? qpc : qpc##dir, h );\ filter_mb_edge##hv( &img_cb[4*edge*(dir?linesize:1)], linesize, bS[dir][edge], edge ? qpc : qpc##dir, h );\
filter_mb_edge##hv( &img_cr[4*edge*(dir?linesize:1)], linesize, bS[dir][edge], edge ? qpc : qpc##dir, h );\
} else if(!(edge&1)) {\
filter_mb_edgec##hv( &img_cb[2*edge*(dir?uvlinesize:1)], uvlinesize, bS[dir][edge], edge ? qpc : qpc##dir, h );\
filter_mb_edgec##hv( &img_cr[2*edge*(dir?uvlinesize:1)], uvlinesize, bS[dir][edge], edge ? qpc : qpc##dir, h );\
}\
}\ }\
} }
if(left_type) if(left_type)

65
libavcodec/mpeg4videoenc.c
View File

@ -296,10 +296,6 @@ static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n
uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb) uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
{ {
int i, last_non_zero; int i, last_non_zero;
#if 0 //variables for the outcommented version
int code, sign, last;
#endif
const RLTable *rl;
uint32_t *bits_tab; uint32_t *bits_tab;
uint8_t *len_tab; uint8_t *len_tab;
const int last_index = s->block_last_index[n]; const int last_index = s->block_last_index[n];
@ -309,20 +305,17 @@ static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n
mpeg4_encode_dc(dc_pb, intra_dc, n); mpeg4_encode_dc(dc_pb, intra_dc, n);
if(last_index<1) return; if(last_index<1) return;
i = 1; i = 1;
rl = &ff_mpeg4_rl_intra;
bits_tab= uni_mpeg4_intra_rl_bits; bits_tab= uni_mpeg4_intra_rl_bits;
len_tab = uni_mpeg4_intra_rl_len; len_tab = uni_mpeg4_intra_rl_len;
} else { } else {
if(last_index<0) return; if(last_index<0) return;
i = 0; i = 0;
rl = &ff_h263_rl_inter;
bits_tab= uni_mpeg4_inter_rl_bits; bits_tab= uni_mpeg4_inter_rl_bits;
len_tab = uni_mpeg4_inter_rl_len; len_tab = uni_mpeg4_inter_rl_len;
} }
/* AC coefs */ /* AC coefs */
last_non_zero = i - 1; last_non_zero = i - 1;
#if 1
for (; i < last_index; i++) { for (; i < last_index; i++) {
int level = block[ scan_table[i] ]; int level = block[ scan_table[i] ];
if (level) { if (level) {
@ -348,64 +341,6 @@ static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n
put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1); put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
} }
} }
#else
for (; i <= last_index; i++) {
const int slevel = block[ scan_table[i] ];
if (slevel) {
int level;
int run = i - last_non_zero - 1;
last = (i == last_index);
sign = 0;
level = slevel;
if (level < 0) {
sign = 1;
level = -level;
}
code = get_rl_index(rl, last, run, level);
put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
if (code == rl->n) {
int level1, run1;
level1 = level - rl->max_level[last][run];
if (level1 < 1)
goto esc2;
code = get_rl_index(rl, last, run, level1);
if (code == rl->n) {
esc2:
put_bits(ac_pb, 1, 1);
if (level > MAX_LEVEL)
goto esc3;
run1 = run - rl->max_run[last][level] - 1;
if (run1 < 0)
goto esc3;
code = get_rl_index(rl, last, run1, level);
if (code == rl->n) {
esc3:
/* third escape */
put_bits(ac_pb, 1, 1);
put_bits(ac_pb, 1, last);
put_bits(ac_pb, 6, run);
put_bits(ac_pb, 1, 1);
put_sbits(ac_pb, 12, slevel);
put_bits(ac_pb, 1, 1);
} else {
/* second escape */
put_bits(ac_pb, 1, 0);
put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
put_bits(ac_pb, 1, sign);
}
} else {
/* first escape */
put_bits(ac_pb, 1, 0);
put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
put_bits(ac_pb, 1, sign);
}
} else {
put_bits(ac_pb, 1, sign);
}
last_non_zero = i;
}
}
#endif
} }
static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,

3
libswscale/ppc/swscale_altivec.c
View File

@ -222,8 +222,7 @@ yuv2yuvX_altivec_real(SwsContext *c,
} }
static void hScale_altivec_real(int16_t *dst, int dstW, static void hScale_altivec_real(int16_t *dst, int dstW,
const uint8_t *src, int srcW, const uint8_t *src, const int16_t *filter,
int xInc, const int16_t *filter,
const int16_t *filterPos, int filterSize) const int16_t *filterPos, int filterSize)
{ {
register int i; register int i;

8
libswscale/swscale.c
View File

@ -1920,10 +1920,8 @@ static void rgb24ToUV_half_c(int16_t *dstU, int16_t *dstV, const uint8_t *src1,
} }
} }
// bilinear / bicubic scaling // bilinear / bicubic scaling
static void hScale_c(int16_t *dst, int dstW, const uint8_t *src, static void hScale_c(int16_t *dst, int dstW, const uint8_t *src,
int srcW, int xInc,
const int16_t *filter, const int16_t *filterPos, const int16_t *filter, const int16_t *filterPos,
int filterSize) int filterSize)
{ {
@ -2036,7 +2034,7 @@ static av_always_inline void hyscale(SwsContext *c, uint16_t *dst, int dstWidth,
int shift= isAnyRGB(c->srcFormat) || c->srcFormat==PIX_FMT_PAL8 ? 13 : av_pix_fmt_descriptors[c->srcFormat].comp[0].depth_minus1; int shift= isAnyRGB(c->srcFormat) || c->srcFormat==PIX_FMT_PAL8 ? 13 : av_pix_fmt_descriptors[c->srcFormat].comp[0].depth_minus1;
c->hScale16(dst, dstWidth, (const uint16_t*)src, srcW, xInc, hLumFilter, hLumFilterPos, hLumFilterSize, shift); c->hScale16(dst, dstWidth, (const uint16_t*)src, srcW, xInc, hLumFilter, hLumFilterPos, hLumFilterSize, shift);
} else if (!c->hyscale_fast) { } else if (!c->hyscale_fast) {
c->hScale(dst, dstWidth, src, srcW, xInc, hLumFilter, hLumFilterPos, hLumFilterSize); c->hScale(dst, dstWidth, src, hLumFilter, hLumFilterPos, hLumFilterSize);
} else { // fast bilinear upscale / crap downscale } else { // fast bilinear upscale / crap downscale
c->hyscale_fast(c, dst, dstWidth, src, srcW, xInc); c->hyscale_fast(c, dst, dstWidth, src, srcW, xInc);
} }
@ -2082,8 +2080,8 @@ static av_always_inline void hcscale(SwsContext *c, uint16_t *dst1, uint16_t *ds
c->hScale16(dst1, dstWidth, (const uint16_t*)src1, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize, shift); c->hScale16(dst1, dstWidth, (const uint16_t*)src1, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize, shift);
c->hScale16(dst2, dstWidth, (const uint16_t*)src2, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize, shift); c->hScale16(dst2, dstWidth, (const uint16_t*)src2, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize, shift);
} else if (!c->hcscale_fast) { } else if (!c->hcscale_fast) {
c->hScale(dst1, dstWidth, src1, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize); c->hScale(dst1, dstWidth, src1, hChrFilter, hChrFilterPos, hChrFilterSize);
c->hScale(dst2, dstWidth, src2, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize); c->hScale(dst2, dstWidth, src2, hChrFilter, hChrFilterPos, hChrFilterSize);
} else { // fast bilinear upscale / crap downscale } else { // fast bilinear upscale / crap downscale
c->hcscale_fast(c, dst1, dst2, dstWidth, src1, src2, srcW, xInc); c->hcscale_fast(c, dst1, dst2, dstWidth, src1, src2, srcW, xInc);
} }

4
libswscale/swscale_internal.h
View File

@ -312,8 +312,8 @@ typedef struct SwsContext {
const uint8_t *src1, const uint8_t *src2, const uint8_t *src1, const uint8_t *src2,
int srcW, int xInc); int srcW, int xInc);
void (*hScale)(int16_t *dst, int dstW, const uint8_t *src, int srcW, void (*hScale)(int16_t *dst, int dstW, const uint8_t *src,
int xInc, const int16_t *filter, const int16_t *filterPos, const int16_t *filter, const int16_t *filterPos,
int filterSize); int filterSize);
void (*hScale16)(int16_t *dst, int dstW, const uint16_t *src, int srcW, void (*hScale16)(int16_t *dst, int dstW, const uint16_t *src, int srcW,

3
libswscale/x86/swscale_template.c
View File

@ -1915,8 +1915,7 @@ static void RENAME(rgb24ToUV)(int16_t *dstU, int16_t *dstV,
#if !COMPILE_TEMPLATE_MMX2 #if !COMPILE_TEMPLATE_MMX2
// bilinear / bicubic scaling // bilinear / bicubic scaling
static void RENAME(hScale)(int16_t *dst, int dstW, static void RENAME(hScale)(int16_t *dst, int dstW,
const uint8_t *src, int srcW, const uint8_t *src, const int16_t *filter,
int xInc, const int16_t *filter,
const int16_t *filterPos, int filterSize) const int16_t *filterPos, int filterSize)
{ {
assert(filterSize % 4 == 0 && filterSize>0); assert(filterSize % 4 == 0 && filterSize>0);

7
subdir.mak
View File

@ -11,16 +11,17 @@ all-$(CONFIG_STATIC): $(SUBDIR)$(LIBNAME)
all-$(CONFIG_SHARED): $(SUBDIR)$(SLIBNAME) all-$(CONFIG_SHARED): $(SUBDIR)$(SLIBNAME)
$(SUBDIR)%-test.o: $(SUBDIR)%-test.c $(SUBDIR)%-test.o: $(SUBDIR)%-test.c
$(CC) $(CPPFLAGS) $(CFLAGS) -DTEST -c $(CC_O) $^ $(COMPILE_C)
$(SUBDIR)%-test.o: $(SUBDIR)%.c $(SUBDIR)%-test.o: $(SUBDIR)%.c
$(CC) $(CPPFLAGS) $(CFLAGS) -DTEST -c $(CC_O) $^ $(COMPILE_C)
$(SUBDIR)x86/%.o: $(SUBDIR)x86/%.asm $(SUBDIR)x86/%.o: $(SUBDIR)x86/%.asm
$(YASMDEP) $(YASMFLAGS) -I $(<D)/ -M -o $@ $< > $(@:.o=.d) $(YASMDEP) $(YASMFLAGS) -I $(<D)/ -M -o $@ $< > $(@:.o=.d)
$(YASM) $(YASMFLAGS) -I $(<D)/ -o $@ $< $(YASM) $(YASMFLAGS) -I $(<D)/ -o $@ $<
$(OBJS) $(SUBDIR)%.ho $(SUBDIR)%-test.o $(TESTOBJS): CPPFLAGS += -DHAVE_AV_CONFIG_H $(OBJS) $(SUBDIR)%.ho $(TESTOBJS): CPPFLAGS += -DHAVE_AV_CONFIG_H
$(TESTOBJS): CPPFLAGS += -DTEST
$(SUBDIR)$(LIBNAME): $(OBJS) $(SUBDIR)$(LIBNAME): $(OBJS)
$(RM) $@ $(RM) $@