diff --git a/mythtv/libs/libmythsamplerate/libmythsamplerate.pro b/mythtv/libs/libmythsamplerate/libmythsamplerate.pro index 4816b72..680d53b 100644 --- a/mythtv/libs/libmythsamplerate/libmythsamplerate.pro +++ b/mythtv/libs/libmythsamplerate/libmythsamplerate.pro @@ -15,9 +15,9 @@ DEFINES += HAVE_AV_CONFIG_H _LARGEFILE_SOURCE QMAKE_CLEAN += $(TARGET) $(TARGETA) $(TARGETD) $(TARGET0) $(TARGET1) $(TARGET2) # Input -HEADERS += samplerate.h +HEADERS += samplerate.h src_sinc.h -SOURCES += samplerate.c src_linear.c src_sinc.c src_zoh.c +SOURCES += samplerate.c src_linear.c src_sinc.c src_sinc_calc.c src_zoh.c inc.path = $${PREFIX}/include/mythtv/ inc.files = samplerate.h diff --git a/mythtv/libs/libmythsamplerate/src_sinc.c b/mythtv/libs/libmythsamplerate/src_sinc.c index e7f46d3..f9173ac 100644 --- a/mythtv/libs/libmythsamplerate/src_sinc.c +++ b/mythtv/libs/libmythsamplerate/src_sinc.c @@ -26,86 +26,8 @@ #include #include -#include "../libmyth/mythconfig.h" +#include "src_sinc.h" #include "float_cast.h" -#include "common.h" - -#define SINC_MAGIC_MARKER MAKE_MAGIC (' ', 's', 'i', 'n', 'c', ' ') - -/*======================================================================================== -*/ - -#define MAKE_INCREMENT_T(x) ((increment_t) (x)) - -#define SHIFT_BITS 12 -#define FP_ONE ((double) (((increment_t) 1) << SHIFT_BITS)) -#define INV_FP_ONE (1.0 / FP_ONE) - -/*======================================================================================== -*/ - -typedef int32_t increment_t ; -typedef float coeff_t ; - -#include "fastest_coeffs.h" -#include "mid_qual_coeffs.h" -#include "high_qual_coeffs.h" - -typedef struct -{ int sinc_magic_marker ; - - int channels ; - long in_count, in_used ; - long out_count, out_gen ; - - int coeff_half_len, index_inc ; - - double src_ratio, input_index ; - - coeff_t const *coeffs ; - - int b_current, b_end, b_real_end, b_len ; - float buffer [1] ; -} SINC_FILTER ; - -static int sinc_vari_process (SRC_PRIVATE *psrc, SRC_DATA *data) ; - -static double calc_output (SINC_FILTER *filter, increment_t increment, increment_t start_filter_index, int ch) ; - -static void prepare_data (SINC_FILTER *filter, SRC_DATA *data, int half_filter_chan_len) ; - -static void sinc_reset (SRC_PRIVATE *psrc) ; - -static inline increment_t -double_to_fp (double x) -{ if (sizeof (increment_t) == 8) - return (llrint ((x) * FP_ONE)) ; - return (lrint ((x) * FP_ONE)) ; -} /* double_to_fp */ - -static inline increment_t -int_to_fp (int x) -{ return (((increment_t) (x)) << SHIFT_BITS) ; -} /* int_to_fp */ - -static inline int -fp_to_int (increment_t x) -{ return (((x) >> SHIFT_BITS)) ; -} /* fp_to_int */ - -static inline increment_t -fp_fraction_part (increment_t x) -{ return ((x) & ((((increment_t) 1) << SHIFT_BITS) - 1)) ; -} /* fp_fraction_part */ - -static inline double -fp_to_double (increment_t x) -{ return fp_fraction_part (x) * INV_FP_ONE ; -} /* fp_to_double */ - - -/*---------------------------------------------------------------------------------------- -*/ const char* sinc_get_name (int src_enum) @@ -411,57 +333,4 @@ prepare_data (SINC_FILTER *filter, SRC_DATA *data, int half_filter_chan_len) } ; return ; -} /* prepare_data */ - - -static double -calc_output (SINC_FILTER *filter, increment_t increment, increment_t start_filter_index, int ch) -{ double fraction, left, right, icoeff ; - increment_t filter_index, max_filter_index ; - int data_index, coeff_count, indx ; - - /* Convert input parameters into fixed point. */ - max_filter_index = int_to_fp (filter->coeff_half_len) ; - - /* First apply the left half of the filter. */ - filter_index = start_filter_index ; - coeff_count = (max_filter_index - filter_index) / increment ; - filter_index = filter_index + coeff_count * increment ; - data_index = filter->b_current - filter->channels * coeff_count + ch ; - - left = 0.0 ; - do - { fraction = fp_to_double (filter_index) ; - indx = fp_to_int (filter_index) ; - - icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ; - - left += icoeff * filter->buffer [data_index] ; - - filter_index -= increment ; - data_index = data_index + filter->channels ; - } - while (filter_index >= MAKE_INCREMENT_T (0)) ; - - /* Now apply the right half of the filter. */ - filter_index = increment - start_filter_index ; - coeff_count = (max_filter_index - filter_index) / increment ; - filter_index = filter_index + coeff_count * increment ; - data_index = filter->b_current + filter->channels * (1 + coeff_count) + ch ; - - right = 0.0 ; - do - { fraction = fp_to_double (filter_index) ; - indx = fp_to_int (filter_index) ; - - icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ; - - right += icoeff * filter->buffer [data_index] ; - - filter_index -= increment ; - data_index = data_index - filter->channels ; - } - while (filter_index > MAKE_INCREMENT_T (0)) ; - - return (left + right) ; -} /* calc_output */ +} diff --git a/mythtv/libs/libmythsamplerate/src_sinc.h b/mythtv/libs/libmythsamplerate/src_sinc.h new file mode 100644 index 0000000..f7c0936 --- /dev/null +++ b/mythtv/libs/libmythsamplerate/src_sinc.h @@ -0,0 +1,72 @@ +#include "../libmyth/mythconfig.h" +#include "common.h" + +#define SINC_MAGIC_MARKER MAKE_MAGIC (' ', 's', 'i', 'n', 'c', ' ') + +#define MAKE_INCREMENT_T(x) ((increment_t) (x)) +#define SHIFT_BITS 12 +#define FP_ONE ((double) (((increment_t) 1) << SHIFT_BITS)) +#define INV_FP_ONE (1.0 / FP_ONE) + +#define ALIGN16 __attribute__((aligned(16))) + +typedef int32_t increment_t ; +typedef float coeff_t ; + +#include "fastest_coeffs.h" +#include "mid_qual_coeffs.h" +#include "high_qual_coeffs.h" + +typedef struct +{ + int sinc_magic_marker ; + int channels ; + long in_count, in_used ; + long out_count, out_gen ; + int coeff_half_len, index_inc ; + double src_ratio, input_index ; + coeff_t const *coeffs ; + int b_current, b_end, b_real_end, b_len ; + float buffer [1] ; +} SINC_FILTER ; + +static int sinc_vari_process (SRC_PRIVATE *psrc, SRC_DATA *data) ; + +static void prepare_data (SINC_FILTER *filter, SRC_DATA *data, int half_filter_chan_len) ; + +static void sinc_reset (SRC_PRIVATE *psrc) ; + +double calc_output (SINC_FILTER *filter, increment_t increment, increment_t start_filter_index, int ch) ; + +static inline increment_t +double_to_fp (double x) +{ + if (sizeof (increment_t) == 8) + return (llrint ((x) * FP_ONE)) ; + return (lrint ((x) * FP_ONE)) ; +} /* double_to_fp */ + +static inline increment_t +int_to_fp (int x) +{ + return (((increment_t) (x)) << SHIFT_BITS) ; +} /* int_to_fp */ + +static inline int +fp_to_int (increment_t x) +{ + return (((x) >> SHIFT_BITS)) ; +} /* fp_to_int */ + +static inline increment_t +fp_fraction_part (increment_t x) +{ + return ((x) & ((((increment_t) 1) << SHIFT_BITS) - 1)) ; +} /* fp_fraction_part */ + +static inline double +fp_to_double (increment_t x) +{ + return fp_fraction_part (x) * INV_FP_ONE ; +} /* fp_to_double */ + diff --git a/mythtv/libs/libmythsamplerate/src_sinc_calc.c b/mythtv/libs/libmythsamplerate/src_sinc_calc.c new file mode 100644 index 0000000..9ec7cf1 --- /dev/null +++ b/mythtv/libs/libmythsamplerate/src_sinc_calc.c @@ -0,0 +1,302 @@ +#include "src_sinc.h" +static double ifp1 = 0.000244141; +static int fpm1 = 0xfff; + +#if (defined(ARCH_X86_32) && defined(MMX)) +// gcc -O3: About 25% faster on x86 but C is faster on amd64 +double calc_output(SINC_FILTER *filter, increment_t increment, + increment_t start_filter_index, int ch) +{ + double fpm[2] ALIGN16; + double ifp[2] ALIGN16; + double incd[2] ALIGN16; + increment_t incsl[4] ALIGN16; + increment_t incsr[4] ALIGN16; + double ret ALIGN16; + double fraction, icoeff; + increment_t filter_index, max_filter_index; + long i, indx, data_index; + int coeff_count; + + incsl[0] = incsr[3] = 0; + incsl[1] = incsr[2] = increment; + incsl[2] = incsr[1] = increment * 2; + incsl[3] = incsr[0] = increment * 3; + + max_filter_index = int_to_fp(filter->coeff_half_len); + + /* First apply the left half of the filter. */ + filter_index = start_filter_index ; + coeff_count = (max_filter_index - filter_index) / increment ; + filter_index = filter_index + coeff_count * increment ; + data_index = filter->b_current - filter->channels * coeff_count + ch ; + + ret = 0.0; + + asm volatile ( + // prep + "movd %6, %%xmm2 \n\t" // increment * 4 + "movsd %10, %%xmm4 \n\t" // 0 ifp1 + "punpckldq %%xmm2, %%xmm2 \n\t" + "movd %11, %%xmm3 \n\t" // 0 0 0 fpm1 + "unpcklpd %%xmm4, %%xmm4 \n\t" // ifp1 ifp1 + "movd %3, %%xmm7 \n\t" // 0 0 0 FI + "punpckldq %%xmm3, %%xmm3 \n\t" + "movdqa %%xmm4, %8 \n\t" // 8 = INV_FP_ONE + "punpckldq %%xmm3, %%xmm3 \n\t" // fpm1 fpm1 fpm1 fpm1 + "movdqa %2, %%xmm1 \n\t" // inc*3 inc*2 inc 0 + "punpckldq %%xmm2, %%xmm2 \n\t" // inc*4 inc*4 inc*4 inc*4 + "movdqa %%xmm3, %7 \n\t" // 7 = frac_part_mask + "punpckldq %%xmm7, %%xmm7 \n\t" // 0 0 FI FI + "pslld $2, %%xmm2 \n\t" + "punpckldq %%xmm7, %%xmm7 \n\t" // FI FI FI FI + "movdqa %%xmm2, %9 \n\t" // 9 = INCD + "psubd %%xmm1, %%xmm7 \n\t" // fi3 fi2 fi1 fi0 + // using 7 + // loop + "1: \n\t" + "pshufd $0xe4,%%xmm7, %%xmm3\n\t" + "movdqa %%xmm7, %%xmm2 \n\t" + "pand %7, %%xmm3 \n\t" // fp_fraction_parts + "psrld $12, %%xmm2 \n\t" // indx3 indx2 indx1 indx0 + "cvtdq2pd %%xmm3, %%xmm4 \n\t" // fpfp 1 fpfp 0 + "psrldq $8, %%xmm3 \n\t" + "movd %%xmm2, %%eax \n\t" // indx0 + "cvtdq2pd %%xmm3, %%xmm5 \n\t" // fpfp 3 fpfp 2 + "mulpd %8, %%xmm4 \n\t" // frac 1 frac 0 + "movlps (%4,%%eax,4), %%xmm1\n\t" // 0 0 c01 c0 + "mulpd %8, %%xmm5 \n\t" // frac 3 frac 2 + // using 1 2 4 5 7 + "psrldq $4, %%xmm2 \n\t" + "cvtps2pd %%xmm1, %%xmm1 \n\t" // c01 c0 + "movd %%xmm2, %%eax \n\t" // indx1 + "psrldq $4, %%xmm2 \n\t" + "movlps (%4,%%eax,4), %%xmm3\n\t" // 0 0 c11 c1 + "movd %%xmm2, %%eax \n\t" // indx2 + "cvtps2pd %%xmm3, %%xmm3 \n\t" // c11 c1 + "movdqa %%xmm1, %%xmm6 \n\t" + "psrldq $4, %%xmm2 \n\t" + "unpcklpd %%xmm3, %%xmm1 \n\t" // c1 c0 + "movlps (%4,%%eax,4), %%xmm0\n\t" // 0 0 c21 c2 + "unpckhpd %%xmm3, %%xmm6 \n\t" // c11 c01 + "movd %%xmm2, %%eax \n\t" // indx3 + "cvtps2pd %%xmm0, %%xmm0 \n\t" // c21 c2 + // using 0 1 4 5 6 7 + "movlps (%4,%%eax,4), %%xmm2\n\t" // 0 0 c31 c3 + "movdqa %%xmm0, %%xmm3 \n\t" + "cvtps2pd %%xmm2, %%xmm2 \n\t" // c31 c3 + "subpd %%xmm1, %%xmm6 \n\t" // c11-c1 c01-c0 + "unpcklpd %%xmm2, %%xmm0 \n\t" // c3 c2 + "mulpd %%xmm4, %%xmm6 \n\t" // frac1*c11-c1 frac0*c01-c0 + "unpckhpd %%xmm2, %%xmm3 \n\t" // c31 c21 + // using 0 1 3 5 6 7 + "addpd %%xmm6, %%xmm1 \n\t" // icoeff1 icoeff0 + "subpd %%xmm0, %%xmm3 \n\t" // c31-c3 c21-c2 + "movups (%5, %1, 4), %%xmm2 \n\t" // d3 d2 d1 d0 + "mulpd %%xmm5, %%xmm3 \n\t" // frac3*c31-c3 frac0*c21-c2 + "movups 16(%5,%1,4), %%xmm4 \n\t" // d7 d6 d5 d4 + "cvtps2pd %%xmm2, %%xmm5 \n\t" // d1 d0 + "addpd %%xmm3, %%xmm0 \n\t" // icoeff3 icoeff2 + // using 0 1 2 4 7 + "psrldq $8, %%xmm2 \n\t" + "cvtps2pd %%xmm4, %%xmm3 \n\t" // d5 d4 + "cvtps2pd %%xmm2, %%xmm6 \n\t" // d3 d2 + "psrldq $8, %%xmm4 \n\t" + "unpcklpd %%xmm6, %%xmm5 \n\t" // d2 d0 + "cvtps2pd %%xmm4, %%xmm2 \n\t" // d7 d6 + // using 0 1 2 3 5 7 + "mulpd %%xmm1, %%xmm5 \n\t" + "unpcklpd %%xmm2, %%xmm3 \n\t" // d6 d4 + "psubd %9, %%xmm7 \n\t" // fi -= increment (x 4) + "mulpd %%xmm0, %%xmm3 \n\t" + "movdqa %%xmm7, %%xmm2 \n\t" + "addpd %%xmm5, %%xmm3 \n\t" + "add $8, %1 \n\t" // data_index += 4 * channels + "haddpd %%xmm3, %%xmm3 \n\t" + "psrldq $12, %%xmm2 \n\t" + "movd %%xmm2, %%eax \n\t" + // using a 3 7 + "addsd %0, %%xmm3 \n\t" // ret += (d * icoeff) x 4 + "test %%eax, %%eax \n\t" // lowest fi >= 0 ? + "movsd %%xmm3, %0 \n\t" + "jns 1b \n\t" + "movdqa %%xmm7, %2 \n\t" + :"=m"(ret),"+r"(data_index) + :"m"(incsl[0]),"m"(filter_index),"r"(filter->coeffs), + "r"(filter->buffer),"m"(increment),"m"(fpm[0]),"m"(ifp[0]), + "m"(incd[0]),"m"(ifp1),"m"(fpm1) + :"eax","xmm0","xmm1","xmm2","xmm3","xmm4","xmm5","xmm6","xmm7","memory" + ); + + for (i = 0; i < 3; i++) + { + if (incsl[i] >= 0) + { + fraction = fp_to_double(incsl[i]); + indx = fp_to_int(incsl[i]); + icoeff = filter->coeffs[indx] + fraction * + (filter->coeffs[indx + 1] - filter->coeffs[indx]); + ret += icoeff * filter->buffer[data_index]; + data_index += 2; + } + } + + /* Now apply the right half of the filter. */ + filter_index = increment - start_filter_index ; + coeff_count = (max_filter_index - filter_index) / increment ; + filter_index = filter_index + coeff_count * increment ; + data_index = filter->b_current + filter->channels * (1 + coeff_count) + ch; + + asm volatile ( + // prep + "movd %3, %%xmm7 \n\t" // 0 0 0 FI + "punpckldq %%xmm7, %%xmm7 \n\t" // 0 0 FI FI + "movdqa %2, %%xmm5 \n\t" // 0 inc inc*2 inc*3 + "punpckldq %%xmm7, %%xmm7 \n\t" // FI FI FI FI + "psubd %%xmm5, %%xmm7 \n\t" // fi0 fi1 fi2 fi3 + // using 7 + // loop + "2: \n\t" + "pshufd $0xe4,%%xmm7, %%xmm3\n\t" + "movdqa %%xmm7, %%xmm2 \n\t" + "pand %7, %%xmm3 \n\t" // fp_fraction_parts + "psrld $12, %%xmm2 \n\t" // indx0 indx1 indx2 indx3 + "cvtdq2pd %%xmm3, %%xmm4 \n\t" // fpfp 2 fpfp 3 + "psrldq $8, %%xmm3 \n\t" + "movd %%xmm2, %%eax \n\t" // indx3 + "cvtdq2pd %%xmm3, %%xmm5 \n\t" // fpfp 0 fpfp 1 + "mulpd %8, %%xmm4 \n\t" // frac 2 frac 3 + "movlps (%4,%%eax,4), %%xmm1\n\t" // 0 0 c31 c3 + "mulpd %8, %%xmm5 \n\t" // frac 0 frac 1 + // using 1 2 4 5 7 + "psrldq $4, %%xmm2 \n\t" + "cvtps2pd %%xmm1, %%xmm1 \n\t" // c31 c3 + "movd %%xmm2, %%eax \n\t" // indx2 + "psrldq $4, %%xmm2 \n\t" + "movlps (%4,%%eax,4), %%xmm3\n\t" // 0 0 c21 c2 + "movd %%xmm2, %%eax \n\t" // indx1 + "cvtps2pd %%xmm3, %%xmm3 \n\t" // c21 c2 + "movdqa %%xmm1, %%xmm6 \n\t" + "psrldq $4, %%xmm2 \n\t" + "unpcklpd %%xmm3, %%xmm1 \n\t" // c2 c3 + "movlps (%4,%%eax,4), %%xmm0\n\t" // 0 0 c11 c1 + "unpckhpd %%xmm3, %%xmm6 \n\t" // c21 c31 + "movd %%xmm2, %%eax \n\t" // indx0 + "cvtps2pd %%xmm0, %%xmm0 \n\t" // c11 c1 + // using 0 1 2 4 5 6 7 + "movlps (%4,%%eax,4), %%xmm2\n\t" // 0 0 c01 c0 + "movdqa %%xmm0, %%xmm3 \n\t" + "cvtps2pd %%xmm2, %%xmm2 \n\t" // c01 c0 + "subpd %%xmm1, %%xmm6 \n\t" // c21-c2 c31-c3 + "unpcklpd %%xmm2, %%xmm0 \n\t" // c0 c1 + "mulpd %%xmm4, %%xmm6 \n\t" // frac2*c21-c2 frac3*c31-c3 + "unpckhpd %%xmm2, %%xmm3 \n\t" // c01 c11 + // using 0 1 3 5 6 7 + "addpd %%xmm6, %%xmm1 \n\t" // icoeff2 icoeff3 + "subpd %%xmm0, %%xmm3 \n\t" // c01-c0 c11-c1 + "movups -12(%5,%1,4), %%xmm2\n\t" // d0 d1 d2 d3 + "mulpd %%xmm5, %%xmm3 \n\t" // frac1*c01-c0 frac0*c11-c1 + "movups -28(%5,%1,4), %%xmm4\n\t" // d4 d5 d6 d7 + "cvtps2pd %%xmm2, %%xmm5 \n\t" // d2 d3 + "addpd %%xmm3, %%xmm0 \n\t" // icoeff0 icoeff1 + // using 0 1 2 4 5 7 + "psrldq $8, %%xmm2 \n\t" + "cvtps2pd %%xmm4, %%xmm3 \n\t" // d6 d7 + "cvtps2pd %%xmm2, %%xmm6 \n\t" // d0 d1 + "psrldq $8, %%xmm4 \n\t" + "unpckhpd %%xmm6, %%xmm5 \n\t" // d0 d2 + "cvtps2pd %%xmm4, %%xmm2 \n\t" // d4 d5 + // using 0 1 2 3 5 7 + "mulpd %%xmm0, %%xmm5 \n\t" + "unpckhpd %%xmm2, %%xmm3 \n\t" // d4 d6 + "psubd %9, %%xmm7 \n\t" // fi -= increment (x 4) + "mulpd %%xmm1, %%xmm3 \n\t" + "movdqa %%xmm7, %%xmm2 \n\t" + "addpd %%xmm5, %%xmm3 \n\t" + "sub $8, %1 \n\t" // data_index -= 4 * channels + "haddpd %%xmm3, %%xmm3 \n\t" + "movd %%xmm2, %%eax \n\t" + // using a 3 7 + "addsd %0, %%xmm3 \n\t" // ret += (d * icoeff) x 4 + "test %%eax, %%eax \n\t" // (lowest) fi > 0 + "movsd %%xmm3, %0 \n\t" + "jg 2b \n\t" + "movdqa %%xmm7, %2 \n\t" + :"=m"(ret),"+r"(data_index) + :"m"(incsr[0]),"m"(filter_index),"r"(filter->coeffs), + "r"(filter->buffer),"m"(increment),"m"(fpm[0]),"m"(ifp[0]), + "m"(incd[0]) + :"eax","xmm0","xmm1","xmm2","xmm3","xmm4","xmm5","xmm6","xmm7","memory" + ); + + // do remaining few + for (i = 3; i > 0; i--) + { + if (incsr[i] > 0) + { + fraction = fp_to_double(incsr[i]); + indx = fp_to_int(incsr[i]); + icoeff = filter->coeffs[indx] + fraction * + (filter->coeffs[indx + 1] - filter->coeffs[indx]); + ret += icoeff * filter->buffer[data_index]; + data_index -= 2; + } + } + + return ret; + +} +#else +double calc_output(SINC_FILTER *filter, increment_t increment, + increment_t start_filter_index, int ch) +{ + double fraction, left, right, icoeff ; + increment_t filter_index, max_filter_index ; + int data_index, coeff_count, indx ; + + /* Convert input parameters into fixed point. */ + max_filter_index = int_to_fp (filter->coeff_half_len) ; + + /* First apply the left half of the filter. */ + filter_index = start_filter_index ; + coeff_count = (max_filter_index - filter_index) / increment ; + filter_index = filter_index + coeff_count * increment ; + data_index = filter->b_current - filter->channels * coeff_count + ch ; + + left = 0.0 ; + do + { fraction = fp_to_double (filter_index) ; + indx = fp_to_int (filter_index) ; + + icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ; + + left += icoeff * filter->buffer [data_index] ; + + filter_index -= increment ; + data_index = data_index + filter->channels ; + } + while (filter_index >= MAKE_INCREMENT_T (0)) ; + + /* Now apply the right half of the filter. */ + filter_index = increment - start_filter_index ; + coeff_count = (max_filter_index - filter_index) / increment ; + filter_index = filter_index + coeff_count * increment ; + data_index = filter->b_current + filter->channels * (1 + coeff_count) + ch ; + + right = 0.0 ; + do + { fraction = fp_to_double (filter_index) ; + indx = fp_to_int (filter_index) ; + + icoeff = filter->coeffs [indx] + fraction * (filter->coeffs [indx + 1] - filter->coeffs [indx]) ; + + right += icoeff * filter->buffer [data_index] ; + + filter_index -= increment ; + data_index = data_index - filter->channels ; + } + while (filter_index > MAKE_INCREMENT_T (0)) ; + + return (left + right) ; +} +#endif