diff --git a/libavcodec/Makefile b/libavcodec/Makefile
index 8c9c23ab8b2fa1e3c09874fdc11a08447ab40265..98e9a073ef42aa99593ae9e31e10f3f06e68dffe 100644
--- a/libavcodec/Makefile
+++ b/libavcodec/Makefile
@@ -996,9 +996,9 @@ TESTPROGS = imgconvert \
mathops \
options \
utils \
- avfft \
TESTPROGS-$(CONFIG_CABAC) += cabac
+TESTPROGS-$(CONFIG_DCT) += avfft
TESTPROGS-$(CONFIG_FFT) += fft fft-fixed fft-fixed32
TESTPROGS-$(CONFIG_GOLOMB) += golomb
TESTPROGS-$(CONFIG_IDCTDSP) += dct
diff --git a/libavcodec/avfft-test.c b/libavcodec/avfft-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..83949f4fb5a3189baabf527399cbf45ab1c9ba0c
--- /dev/null
+++ b/libavcodec/avfft-test.c
@@ -0,0 +1,52 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "config.h"
+#include "avfft.h"
+
+int main(int argc, char **argv)
+{
+ int i;
+#define LEN 1024
+ FFTSample *ref = av_malloc_array(LEN, sizeof(*ref));
+ FFTSample *data = av_malloc_array(LEN, sizeof(*data));
+ RDFTContext *rdft_context = av_rdft_init(10, DFT_R2C);
+ RDFTContext *irdft_context = av_rdft_init(10, IDFT_C2R);
+
+ if (!ref || !data || !rdft_context || !irdft_context)
+ return 2;
+ for (i=0; i<LEN; i++) {
+ ref[i] = data[i] = i*456 + 123 + i*i;
+ }
+ av_rdft_calc(rdft_context, data);
+ av_rdft_calc(irdft_context, data);
+
+ for (i=0; i<LEN; i++) {
+ if (fabs(ref[i] - data[i]/LEN*2) > 1) {
+ fprintf(stderr, "Failed at %d (%f %f)\n", i, ref[i], data[i]/LEN*2);
+ return 1;
+ }
+ }
+
+ av_rdft_end(rdft_context);
+ av_rdft_end(irdft_context);
+ av_free(data);
+ av_free(ref);
+
+ return 0;
+}
diff --git a/libavcodec/avfft.c b/libavcodec/avfft.c
index 675d2b906b443ac209ba291f85d97cea37684fcd..2200f37708f0efee4a6ab09faf80cc47840c6f19 100644
--- a/libavcodec/avfft.c
+++ b/libavcodec/avfft.c
@@ -142,38 +142,4 @@ av_cold void av_dct_end(DCTContext *s)
}
}
-#ifdef TEST
-int main(int argc, char **argv)
-{
- int i;
-#define LEN 1024
- FFTSample *ref = av_malloc_array(LEN, sizeof(*ref));
- FFTSample *data = av_malloc_array(LEN, sizeof(*data));
- RDFTContext *rdft_context = av_rdft_init(10, DFT_R2C);
- RDFTContext *irdft_context = av_rdft_init(10, IDFT_C2R);
-
- if (!ref || !data || !rdft_context || !irdft_context)
- return 2;
- for (i=0; i<LEN; i++) {
- ref[i] = data[i] = i*456 + 123 + i*i;
- }
- av_rdft_calc(rdft_context, data);
- av_rdft_calc(irdft_context, data);
-
- for (i=0; i<LEN; i++) {
- if (fabs(ref[i] - data[i]/LEN*2) > 1) {
- fprintf(stderr, "Failed at %d (%f %f)\n", i, ref[i], data[i]/LEN*2);
- return 1;
- }
- }
-
- av_rdft_end(rdft_context);
- av_rdft_end(irdft_context);
- av_free(data);
- av_free(ref);
-
- return 0;
-}
-#endif
-
#endif /* CONFIG_DCT */
diff --git a/libavcodec/cabac-test.c b/libavcodec/cabac-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..47f31e997c5bd844d3d067e766b691ed893534af
--- /dev/null
+++ b/libavcodec/cabac-test.c
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "cabac.c"
+
+#define SIZE 10240
+
+#include "libavutil/lfg.h"
+#include "avcodec.h"
+
+static inline void put_cabac_bit(CABACContext *c, int b){
+ put_bits(&c->pb, 1, b);
+ for(;c->outstanding_count; c->outstanding_count--){
+ put_bits(&c->pb, 1, 1-b);
+ }
+}
+
+static inline void renorm_cabac_encoder(CABACContext *c){
+ while(c->range < 0x100){
+ //FIXME optimize
+ if(c->low<0x100){
+ put_cabac_bit(c, 0);
+ }else if(c->low<0x200){
+ c->outstanding_count++;
+ c->low -= 0x100;
+ }else{
+ put_cabac_bit(c, 1);
+ c->low -= 0x200;
+ }
+
+ c->range+= c->range;
+ c->low += c->low;
+ }
+}
+
+static void put_cabac(CABACContext *c, uint8_t * const state, int bit){
+ int RangeLPS= ff_h264_lps_range[2*(c->range&0xC0) + *state];
+
+ if(bit == ((*state)&1)){
+ c->range -= RangeLPS;
+ *state = ff_h264_mlps_state[128 + *state];
+ }else{
+ c->low += c->range - RangeLPS;
+ c->range = RangeLPS;
+ *state= ff_h264_mlps_state[127 - *state];
+ }
+
+ renorm_cabac_encoder(c);
+}
+
+/**
+ * @param bit 0 -> write zero bit, !=0 write one bit
+ */
+static void put_cabac_bypass(CABACContext *c, int bit){
+ c->low += c->low;
+
+ if(bit){
+ c->low += c->range;
+ }
+//FIXME optimize
+ if(c->low<0x200){
+ put_cabac_bit(c, 0);
+ }else if(c->low<0x400){
+ c->outstanding_count++;
+ c->low -= 0x200;
+ }else{
+ put_cabac_bit(c, 1);
+ c->low -= 0x400;
+ }
+}
+
+/**
+ *
+ * @return the number of bytes written
+ */
+static int put_cabac_terminate(CABACContext *c, int bit){
+ c->range -= 2;
+
+ if(!bit){
+ renorm_cabac_encoder(c);
+ }else{
+ c->low += c->range;
+ c->range= 2;
+
+ renorm_cabac_encoder(c);
+
+ av_assert0(c->low <= 0x1FF);
+ put_cabac_bit(c, c->low>>9);
+ put_bits(&c->pb, 2, ((c->low>>7)&3)|1);
+
+ flush_put_bits(&c->pb); //FIXME FIXME FIXME XXX wrong
+ }
+
+ return (put_bits_count(&c->pb)+7)>>3;
+}
+
+int main(void){
+ CABACContext c;
+ uint8_t b[9*SIZE];
+ uint8_t r[9*SIZE];
+ int i, ret = 0;
+ uint8_t state[10]= {0};
+ AVLFG prng;
+
+ av_lfg_init(&prng, 1);
+ ff_init_cabac_encoder(&c, b, SIZE);
+
+ for(i=0; i<SIZE; i++){
+ if(2*i<SIZE) r[i] = av_lfg_get(&prng) % 7;
+ else r[i] = (i>>8)&1;
+ }
+
+ for(i=0; i<SIZE; i++){
+ put_cabac_bypass(&c, r[i]&1);
+ }
+
+ for(i=0; i<SIZE; i++){
+ put_cabac(&c, state, r[i]&1);
+ }
+
+ i= put_cabac_terminate(&c, 1);
+ b[i++] = av_lfg_get(&prng);
+ b[i ] = av_lfg_get(&prng);
+
+ ff_init_cabac_decoder(&c, b, SIZE);
+
+ memset(state, 0, sizeof(state));
+
+ for(i=0; i<SIZE; i++){
+ if( (r[i]&1) != get_cabac_bypass(&c) ) {
+ av_log(NULL, AV_LOG_ERROR, "CABAC bypass failure at %d\n", i);
+ ret = 1;
+ }
+ }
+
+ for(i=0; i<SIZE; i++){
+ if( (r[i]&1) != get_cabac_noinline(&c, state) ) {
+ av_log(NULL, AV_LOG_ERROR, "CABAC failure at %d\n", i);
+ ret = 1;
+ }
+ }
+ if(!get_cabac_terminate(&c)) {
+ av_log(NULL, AV_LOG_ERROR, "where's the Terminator?\n");
+ ret = 1;
+ }
+
+ return ret;
+}
diff --git a/libavcodec/cabac.c b/libavcodec/cabac.c
index 1a877dd2b5c1e0dd7500a4e6a66056c217b70d4e..a718d51ddbbf0861a4c7643867c05f143ab1b16d 100644
--- a/libavcodec/cabac.c
+++ b/libavcodec/cabac.c
@@ -200,150 +200,3 @@ int ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size){
return AVERROR_INVALIDDATA;
return 0;
}
-
-#ifdef TEST
-#define SIZE 10240
-
-#include "libavutil/lfg.h"
-#include "avcodec.h"
-
-static inline void put_cabac_bit(CABACContext *c, int b){
- put_bits(&c->pb, 1, b);
- for(;c->outstanding_count; c->outstanding_count--){
- put_bits(&c->pb, 1, 1-b);
- }
-}
-
-static inline void renorm_cabac_encoder(CABACContext *c){
- while(c->range < 0x100){
- //FIXME optimize
- if(c->low<0x100){
- put_cabac_bit(c, 0);
- }else if(c->low<0x200){
- c->outstanding_count++;
- c->low -= 0x100;
- }else{
- put_cabac_bit(c, 1);
- c->low -= 0x200;
- }
-
- c->range+= c->range;
- c->low += c->low;
- }
-}
-
-static void put_cabac(CABACContext *c, uint8_t * const state, int bit){
- int RangeLPS= ff_h264_lps_range[2*(c->range&0xC0) + *state];
-
- if(bit == ((*state)&1)){
- c->range -= RangeLPS;
- *state = ff_h264_mlps_state[128 + *state];
- }else{
- c->low += c->range - RangeLPS;
- c->range = RangeLPS;
- *state= ff_h264_mlps_state[127 - *state];
- }
-
- renorm_cabac_encoder(c);
-}
-
-/**
- * @param bit 0 -> write zero bit, !=0 write one bit
- */
-static void put_cabac_bypass(CABACContext *c, int bit){
- c->low += c->low;
-
- if(bit){
- c->low += c->range;
- }
-//FIXME optimize
- if(c->low<0x200){
- put_cabac_bit(c, 0);
- }else if(c->low<0x400){
- c->outstanding_count++;
- c->low -= 0x200;
- }else{
- put_cabac_bit(c, 1);
- c->low -= 0x400;
- }
-}
-
-/**
- *
- * @return the number of bytes written
- */
-static int put_cabac_terminate(CABACContext *c, int bit){
- c->range -= 2;
-
- if(!bit){
- renorm_cabac_encoder(c);
- }else{
- c->low += c->range;
- c->range= 2;
-
- renorm_cabac_encoder(c);
-
- av_assert0(c->low <= 0x1FF);
- put_cabac_bit(c, c->low>>9);
- put_bits(&c->pb, 2, ((c->low>>7)&3)|1);
-
- flush_put_bits(&c->pb); //FIXME FIXME FIXME XXX wrong
- }
-
- return (put_bits_count(&c->pb)+7)>>3;
-}
-
-int main(void){
- CABACContext c;
- uint8_t b[9*SIZE];
- uint8_t r[9*SIZE];
- int i, ret = 0;
- uint8_t state[10]= {0};
- AVLFG prng;
-
- av_lfg_init(&prng, 1);
- ff_init_cabac_encoder(&c, b, SIZE);
-
- for(i=0; i<SIZE; i++){
- if(2*i<SIZE) r[i] = av_lfg_get(&prng) % 7;
- else r[i] = (i>>8)&1;
- }
-
- for(i=0; i<SIZE; i++){
- put_cabac_bypass(&c, r[i]&1);
- }
-
- for(i=0; i<SIZE; i++){
- put_cabac(&c, state, r[i]&1);
- }
-
- i= put_cabac_terminate(&c, 1);
- b[i++] = av_lfg_get(&prng);
- b[i ] = av_lfg_get(&prng);
-
- ff_init_cabac_decoder(&c, b, SIZE);
-
- memset(state, 0, sizeof(state));
-
- for(i=0; i<SIZE; i++){
- if( (r[i]&1) != get_cabac_bypass(&c) ) {
- av_log(NULL, AV_LOG_ERROR, "CABAC bypass failure at %d\n", i);
- ret = 1;
- }
- }
-
- for(i=0; i<SIZE; i++){
- if( (r[i]&1) != get_cabac_noinline(&c, state) ) {
- av_log(NULL, AV_LOG_ERROR, "CABAC failure at %d\n", i);
- ret = 1;
- }
- }
- if(!get_cabac_terminate(&c)) {
- av_log(NULL, AV_LOG_ERROR, "where's the Terminator?\n");
- ret = 1;
- }
-
- return ret;
-}
-
-#endif /* TEST */
diff --git a/libavcodec/iirfilter-test.c b/libavcodec/iirfilter-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..01380973801a514968fd48ee1ec72f7b87d730a1
--- /dev/null
+++ b/libavcodec/iirfilter-test.c
@@ -0,0 +1,52 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include "iirfilter.h"
+
+#define FILT_ORDER 4
+#define SIZE 1024
+
+int main(void)
+{
+ struct FFIIRFilterCoeffs *fcoeffs = NULL;
+ struct FFIIRFilterState *fstate = NULL;
+ float cutoff_coeff = 0.4;
+ int16_t x[SIZE], y[SIZE];
+ int i;
+
+ fcoeffs = ff_iir_filter_init_coeffs(NULL, FF_FILTER_TYPE_BUTTERWORTH,
+ FF_FILTER_MODE_LOWPASS, FILT_ORDER,
+ cutoff_coeff, 0.0, 0.0);
+ fstate = ff_iir_filter_init_state(FILT_ORDER);
+
+ for (i = 0; i < SIZE; i++)
+ x[i] = lrint(0.75 * INT16_MAX * sin(0.5 * M_PI * i * i / SIZE));
+
+ ff_iir_filter(fcoeffs, fstate, SIZE, x, 1, y, 1);
+
+ for (i = 0; i < SIZE; i++)
+ printf("%6d %6d\n", x[i], y[i]);
+
+ ff_iir_filter_free_coeffsp(&fcoeffs);
+ ff_iir_filter_free_statep(&fstate);
+ return 0;
+}
diff --git a/libavcodec/iirfilter.c b/libavcodec/iirfilter.c
index 474f52fde73dc208dc0e2e2282a242869a97dcd0..a8c9b9b826ebe7280b3907c4d7364aead409a4ba 100644
--- a/libavcodec/iirfilter.c
+++ b/libavcodec/iirfilter.c
@@ -323,35 +323,3 @@ void ff_iir_filter_init(FFIIRFilterContext *f) {
if (HAVE_MIPSFPU)
ff_iir_filter_init_mips(f);
}
-
-#ifdef TEST
-#include <stdio.h>
-
-#define FILT_ORDER 4
-#define SIZE 1024
-int main(void)
-{
- struct FFIIRFilterCoeffs *fcoeffs = NULL;
- struct FFIIRFilterState *fstate = NULL;
- float cutoff_coeff = 0.4;
- int16_t x[SIZE], y[SIZE];
- int i;
-
- fcoeffs = ff_iir_filter_init_coeffs(NULL, FF_FILTER_TYPE_BUTTERWORTH,
- FF_FILTER_MODE_LOWPASS, FILT_ORDER,
- cutoff_coeff, 0.0, 0.0);
- fstate = ff_iir_filter_init_state(FILT_ORDER);
-
- for (i = 0; i < SIZE; i++)
- x[i] = lrint(0.75 * INT16_MAX * sin(0.5 * M_PI * i * i / SIZE));
-
- ff_iir_filter(fcoeffs, fstate, SIZE, x, 1, y, 1);
-
- for (i = 0; i < SIZE; i++)
- printf("%6d %6d\n", x[i], y[i]);
-
- ff_iir_filter_free_coeffsp(&fcoeffs);
- ff_iir_filter_free_statep(&fstate);
- return 0;
-}
-#endif /* TEST */
diff --git a/libavcodec/imgconvert-test.c b/libavcodec/imgconvert-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..96004d79c29c2154f57bbaea53ab80346832e702
--- /dev/null
+++ b/libavcodec/imgconvert-test.c
@@ -0,0 +1,50 @@
+/*
+ * Misc image conversion routines
+ * Copyright (c) 2001, 2002, 2003 Fabrice Bellard
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "imgconvert.c"
+
+#if FF_API_AVPICTURE
+FF_DISABLE_DEPRECATION_WARNINGS
+int main(void){
+ int i;
+ int err=0;
+ int skip = 0;
+
+ for (i=0; i<AV_PIX_FMT_NB*2; i++) {
+ const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(i);
+ if(!desc || !desc->name) {
+ skip ++;
+ continue;
+ }
+ if (skip) {
+ av_log(NULL, AV_LOG_INFO, "%3d unused pixel format values\n", skip);
+ skip = 0;
+ }
+ av_log(NULL, AV_LOG_INFO, "pix fmt %s yuv_plan:%d avg_bpp:%d\n", desc->name, is_yuv_planar(desc), av_get_padded_bits_per_pixel(desc));
+ if ((!(desc->flags & AV_PIX_FMT_FLAG_ALPHA)) != (desc->nb_components != 2 && desc->nb_components != 4)) {
+ av_log(NULL, AV_LOG_ERROR, "Alpha flag mismatch\n");
+ err = 1;
+ }
+ }
+ return err;
+}
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif /* FF_API_AVPICTURE */
diff --git a/libavcodec/imgconvert.c b/libavcodec/imgconvert.c
index 0035dc6e1cf29156716a3c38820d029f13828aa3..46fa7809bd3d8ce4fdfdcc308ed993903bcc6ca1 100644
--- a/libavcodec/imgconvert.c
+++ b/libavcodec/imgconvert.c
@@ -231,33 +231,5 @@ int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width,
return 0;
}
-
-#ifdef TEST
-
-int main(void){
- int i;
- int err=0;
- int skip = 0;
-
- for (i=0; i<AV_PIX_FMT_NB*2; i++) {
- const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(i);
- if(!desc || !desc->name) {
- skip ++;
- continue;
- }
- if (skip) {
- av_log(NULL, AV_LOG_INFO, "%3d unused pixel format values\n", skip);
- skip = 0;
- }
- av_log(NULL, AV_LOG_INFO, "pix fmt %s yuv_plan:%d avg_bpp:%d\n", desc->name, is_yuv_planar(desc), av_get_padded_bits_per_pixel(desc));
- if ((!(desc->flags & AV_PIX_FMT_FLAG_ALPHA)) != (desc->nb_components != 2 && desc->nb_components != 4)) {
- av_log(NULL, AV_LOG_ERROR, "Alpha flag mismatch\n");
- err = 1;
- }
- }
- return err;
-}
-
-#endif
FF_ENABLE_DEPRECATION_WARNINGS
#endif /* FF_API_AVPICTURE */
diff --git a/libavcodec/jpeg2000dwt-test.c b/libavcodec/jpeg2000dwt-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..30f1ce1ef7fd9284921a793e514fc899c61b7a9b
--- /dev/null
+++ b/libavcodec/jpeg2000dwt-test.c
@@ -0,0 +1,141 @@
+/*
+ * Discrete wavelet transform
+ * Copyright (c) 2007 Kamil Nowosad
+ * Copyright (c) 2013 Nicolas Bertrand <nicoinattendu@gmail.com>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "jpeg2000dwt.c"
+
+#include "libavutil/lfg.h"
+
+#define MAX_W 256
+
+static int test_dwt(int *array, int *ref, int border[2][2], int decomp_levels, int type, int max_diff) {
+ int ret, j;
+ DWTContext s1={{{0}}}, *s= &s1;
+ int64_t err2 = 0;
+
+ ret = ff_jpeg2000_dwt_init(s, border, decomp_levels, type);
+ if (ret < 0) {
+ fprintf(stderr, "ff_jpeg2000_dwt_init failed\n");
+ return 1;
+ }
+ ret = ff_dwt_encode(s, array);
+ if (ret < 0) {
+ fprintf(stderr, "ff_dwt_encode failed\n");
+ return 1;
+ }
+ ret = ff_dwt_decode(s, array);
+ if (ret < 0) {
+ fprintf(stderr, "ff_dwt_encode failed\n");
+ return 1;
+ }
+ for (j = 0; j<MAX_W * MAX_W; j++) {
+ if (FFABS(array[j] - ref[j]) > max_diff) {
+ fprintf(stderr, "missmatch at %d (%d != %d) decomp:%d border %d %d %d %d\n",
+ j, array[j], ref[j],decomp_levels, border[0][0], border[0][1], border[1][0], border[1][1]);
+ return 2;
+ }
+ err2 += (array[j] - ref[j]) * (array[j] - ref[j]);
+ array[j] = ref[j];
+ }
+ ff_dwt_destroy(s);
+
+ printf("%s, decomp:%2d border %3d %3d %3d %3d milli-err2:%9"PRId64"\n",
+ type == FF_DWT53 ? "5/3i" : "9/7i",
+ decomp_levels, border[0][0], border[0][1], border[1][0], border[1][1],
+ 1000*err2 / ((border[0][1] - border[0][0])*(border[1][1] - border[1][0])));
+
+ return 0;
+}
+
+static int test_dwtf(float *array, float *ref, int border[2][2], int decomp_levels, float max_diff) {
+ int ret, j;
+ DWTContext s1={{{0}}}, *s= &s1;
+ double err2 = 0;
+
+ ret = ff_jpeg2000_dwt_init(s, border, decomp_levels, FF_DWT97);
+ if (ret < 0) {
+ fprintf(stderr, "ff_jpeg2000_dwt_init failed\n");
+ return 1;
+ }
+ ret = ff_dwt_encode(s, array);
+ if (ret < 0) {
+ fprintf(stderr, "ff_dwt_encode failed\n");
+ return 1;
+ }
+ ret = ff_dwt_decode(s, array);
+ if (ret < 0) {
+ fprintf(stderr, "ff_dwt_encode failed\n");
+ return 1;
+ }
+ for (j = 0; j<MAX_W * MAX_W; j++) {
+ if (FFABS(array[j] - ref[j]) > max_diff) {
+ fprintf(stderr, "missmatch at %d (%f != %f) decomp:%d border %d %d %d %d\n",
+ j, array[j], ref[j],decomp_levels, border[0][0], border[0][1], border[1][0], border[1][1]);
+ return 2;
+ }
+ err2 += (array[j] - ref[j]) * (array[j] - ref[j]);
+ array[j] = ref[j];
+ }
+ ff_dwt_destroy(s);
+
+ printf("9/7f, decomp:%2d border %3d %3d %3d %3d err2:%20.3f\n",
+ decomp_levels, border[0][0], border[0][1], border[1][0], border[1][1],
+ err2 / ((border[0][1] - border[0][0])*(border[1][1] - border[1][0])));
+
+ return 0;
+}
+
+static int array[MAX_W * MAX_W];
+static int ref [MAX_W * MAX_W];
+static float arrayf[MAX_W * MAX_W];
+static float reff [MAX_W * MAX_W];
+
+int main(void) {
+ AVLFG prng;
+ int i,j;
+ int border[2][2];
+ int ret, decomp_levels;
+
+ av_lfg_init(&prng, 1);
+
+ for (i = 0; i<MAX_W * MAX_W; i++)
+ arrayf[i] = reff[i] = array[i] = ref[i] = av_lfg_get(&prng) % 2048;
+
+ for (i = 0; i < 100; i++) {
+ for (j=0; j<4; j++)
+ border[j>>1][j&1] = av_lfg_get(&prng) % MAX_W;
+ if (border[0][0] >= border[0][1] || border[1][0] >= border[1][1])
+ continue;
+ decomp_levels = av_lfg_get(&prng) % FF_DWT_MAX_DECLVLS;
+
+ ret = test_dwt(array, ref, border, decomp_levels, FF_DWT53, 0);
+ if (ret)
+ return ret;
+ ret = test_dwt(array, ref, border, decomp_levels, FF_DWT97_INT, FFMIN(7+5*decomp_levels, 15+3*decomp_levels));
+ if (ret)
+ return ret;
+ ret = test_dwtf(arrayf, reff, border, decomp_levels, 0.05);
+ if (ret)
+ return ret;
+ }
+
+ return 0;
+}
diff --git a/libavcodec/jpeg2000dwt.c b/libavcodec/jpeg2000dwt.c
index a46c93a9b20ea98984cfab89ca2770e1945cc76c..188cc261a415a3c023f3e16745610671bbc75b97 100644
--- a/libavcodec/jpeg2000dwt.c
+++ b/libavcodec/jpeg2000dwt.c
@@ -622,125 +622,3 @@ void ff_dwt_destroy(DWTContext *s)
av_freep(&s->f_linebuf);
av_freep(&s->i_linebuf);
}
-
-#ifdef TEST
-
-#include "libavutil/lfg.h"
-
-#define MAX_W 256
-
-static int test_dwt(int *array, int *ref, int border[2][2], int decomp_levels, int type, int max_diff) {
- int ret, j;
- DWTContext s1={{{0}}}, *s= &s1;
- int64_t err2 = 0;
-
- ret = ff_jpeg2000_dwt_init(s, border, decomp_levels, type);
- if (ret < 0) {
- fprintf(stderr, "ff_jpeg2000_dwt_init failed\n");
- return 1;
- }
- ret = ff_dwt_encode(s, array);
- if (ret < 0) {
- fprintf(stderr, "ff_dwt_encode failed\n");
- return 1;
- }
- ret = ff_dwt_decode(s, array);
- if (ret < 0) {
- fprintf(stderr, "ff_dwt_encode failed\n");
- return 1;
- }
- for (j = 0; j<MAX_W * MAX_W; j++) {
- if (FFABS(array[j] - ref[j]) > max_diff) {
- fprintf(stderr, "missmatch at %d (%d != %d) decomp:%d border %d %d %d %d\n",
- j, array[j], ref[j],decomp_levels, border[0][0], border[0][1], border[1][0], border[1][1]);
- return 2;
- }
- err2 += (array[j] - ref[j]) * (array[j] - ref[j]);
- array[j] = ref[j];
- }
- ff_dwt_destroy(s);
-
- printf("%s, decomp:%2d border %3d %3d %3d %3d milli-err2:%9"PRId64"\n",
- type == FF_DWT53 ? "5/3i" : "9/7i",
- decomp_levels, border[0][0], border[0][1], border[1][0], border[1][1],
- 1000*err2 / ((border[0][1] - border[0][0])*(border[1][1] - border[1][0])));
-
- return 0;
-}
-
-static int test_dwtf(float *array, float *ref, int border[2][2], int decomp_levels, float max_diff) {
- int ret, j;
- DWTContext s1={{{0}}}, *s= &s1;
- double err2 = 0;
-
- ret = ff_jpeg2000_dwt_init(s, border, decomp_levels, FF_DWT97);
- if (ret < 0) {
- fprintf(stderr, "ff_jpeg2000_dwt_init failed\n");
- return 1;
- }
- ret = ff_dwt_encode(s, array);
- if (ret < 0) {
- fprintf(stderr, "ff_dwt_encode failed\n");
- return 1;
- }
- ret = ff_dwt_decode(s, array);
- if (ret < 0) {
- fprintf(stderr, "ff_dwt_encode failed\n");
- return 1;
- }
- for (j = 0; j<MAX_W * MAX_W; j++) {
- if (FFABS(array[j] - ref[j]) > max_diff) {
- fprintf(stderr, "missmatch at %d (%f != %f) decomp:%d border %d %d %d %d\n",
- j, array[j], ref[j],decomp_levels, border[0][0], border[0][1], border[1][0], border[1][1]);
- return 2;
- }
- err2 += (array[j] - ref[j]) * (array[j] - ref[j]);
- array[j] = ref[j];
- }
- ff_dwt_destroy(s);
-
- printf("9/7f, decomp:%2d border %3d %3d %3d %3d err2:%20.3f\n",
- decomp_levels, border[0][0], border[0][1], border[1][0], border[1][1],
- err2 / ((border[0][1] - border[0][0])*(border[1][1] - border[1][0])));
-
- return 0;
-}
-
-static int array[MAX_W * MAX_W];
-static int ref [MAX_W * MAX_W];
-static float arrayf[MAX_W * MAX_W];
-static float reff [MAX_W * MAX_W];
-
-int main(void) {
- AVLFG prng;
- int i,j;
- int border[2][2];
- int ret, decomp_levels;
-
- av_lfg_init(&prng, 1);
-
- for (i = 0; i<MAX_W * MAX_W; i++)
- arrayf[i] = reff[i] = array[i] = ref[i] = av_lfg_get(&prng) % 2048;
-
- for (i = 0; i < 100; i++) {
- for (j=0; j<4; j++)
- border[j>>1][j&1] = av_lfg_get(&prng) % MAX_W;
- if (border[0][0] >= border[0][1] || border[1][0] >= border[1][1])
- continue;
- decomp_levels = av_lfg_get(&prng) % FF_DWT_MAX_DECLVLS;
-
- ret = test_dwt(array, ref, border, decomp_levels, FF_DWT53, 0);
- if (ret)
- return ret;
- ret = test_dwt(array, ref, border, decomp_levels, FF_DWT97_INT, FFMIN(7+5*decomp_levels, 15+3*decomp_levels));
- if (ret)
- return ret;
- ret = test_dwtf(arrayf, reff, border, decomp_levels, 0.05);
- if (ret)
- return ret;
- }
-
- return 0;
-}
-
-#endif
diff --git a/libavcodec/mathops-test.c b/libavcodec/mathops-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..d47f1442dffbcacc5024414e21e7b3deb0967d1c
--- /dev/null
+++ b/libavcodec/mathops-test.c
@@ -0,0 +1,41 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "mathops.h"
+
+#include <stdlib.h>
+
+int main(void)
+{
+ unsigned u;
+
+ for(u=0; u<65536; u++) {
+ unsigned s = u*u;
+ unsigned root = ff_sqrt(s);
+ unsigned root_m1 = ff_sqrt(s-1);
+ if (s && root != u) {
+ fprintf(stderr, "ff_sqrt failed at %u with %u\n", s, root);
+ return 1;
+ }
+ if (u && root_m1 != u - 1) {
+ fprintf(stderr, "ff_sqrt failed at %u with %u\n", s, root);
+ return 1;
+ }
+ }
+ return 0;
+}
diff --git a/libavcodec/mathops.c b/libavcodec/mathops.c
deleted file mode 100644
index 31c8e69e618edcf87a861befbdb467010c429c06..0000000000000000000000000000000000000000
--- a/libavcodec/mathops.c
+++ /dev/null
@@ -1,26 +0,0 @@
-#include "mathops.h"
-
-#ifdef TEST
-
-#include <stdlib.h>
-
-int main(void)
-{
- unsigned u;
-
- for(u=0; u<65536; u++) {
- unsigned s = u*u;
- unsigned root = ff_sqrt(s);
- unsigned root_m1 = ff_sqrt(s-1);
- if (s && root != u) {
- fprintf(stderr, "ff_sqrt failed at %u with %u\n", s, root);
- return 1;
- }
- if (u && root_m1 != u - 1) {
- fprintf(stderr, "ff_sqrt failed at %u with %u\n", s, root);
- return 1;
- }
- }
- return 0;
-}
-#endif /* TEST */
diff --git a/libavcodec/options-test.c b/libavcodec/options-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..2a085795d008d19c487bfe7a5e8904ece62ee91e
--- /dev/null
+++ b/libavcodec/options-test.c
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2001 Fabrice Bellard
+ * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "options.c"
+
+static int dummy_init(AVCodecContext *ctx)
+{
+ //TODO: this code should set every possible pointer that could be set by codec and is not an option;
+ ctx->extradata_size = 8;
+ ctx->extradata = av_malloc(ctx->extradata_size);
+ return 0;
+}
+
+static int dummy_close(AVCodecContext *ctx)
+{
+ av_freep(&ctx->extradata);
+ ctx->extradata_size = 0;
+ return 0;
+}
+
+static int dummy_encode(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
+{
+ return AVERROR(ENOSYS);
+}
+
+typedef struct Dummy12Context {
+ AVClass *av_class;
+ int num;
+ char* str;
+} Dummy12Context;
+
+typedef struct Dummy3Context {
+ void *fake_av_class;
+ int num;
+ char* str;
+} Dummy3Context;
+
+#define OFFSET(x) offsetof(Dummy12Context, x)
+#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
+static const AVOption dummy_options[] = {
+ { "str", "set str", OFFSET(str), AV_OPT_TYPE_STRING, { .str = "i'm src default value" }, 0, 0, VE},
+ { "num", "set num", OFFSET(num), AV_OPT_TYPE_INT, { .i64 = 1500100900 }, 0, INT_MAX, VE},
+ { NULL },
+};
+
+static const AVClass dummy_v1_class = {
+ .class_name = "dummy_v1_class",
+ .item_name = av_default_item_name,
+ .option = dummy_options,
+ .version = LIBAVUTIL_VERSION_INT,
+};
+
+static const AVClass dummy_v2_class = {
+ .class_name = "dummy_v2_class",
+ .item_name = av_default_item_name,
+ .option = dummy_options,
+ .version = LIBAVUTIL_VERSION_INT,
+};
+
+/* codec with options */
+static AVCodec dummy_v1_encoder = {
+ .name = "dummy_v1_codec",
+ .type = AVMEDIA_TYPE_VIDEO,
+ .id = AV_CODEC_ID_NONE - 1,
+ .encode2 = dummy_encode,
+ .init = dummy_init,
+ .close = dummy_close,
+ .priv_class = &dummy_v1_class,
+ .priv_data_size = sizeof(Dummy12Context),
+};
+
+/* codec with options, different class */
+static AVCodec dummy_v2_encoder = {
+ .name = "dummy_v2_codec",
+ .type = AVMEDIA_TYPE_VIDEO,
+ .id = AV_CODEC_ID_NONE - 2,
+ .encode2 = dummy_encode,
+ .init = dummy_init,
+ .close = dummy_close,
+ .priv_class = &dummy_v2_class,
+ .priv_data_size = sizeof(Dummy12Context),
+};
+
+/* codec with priv data, but no class */
+static AVCodec dummy_v3_encoder = {
+ .name = "dummy_v3_codec",
+ .type = AVMEDIA_TYPE_VIDEO,
+ .id = AV_CODEC_ID_NONE - 3,
+ .encode2 = dummy_encode,
+ .init = dummy_init,
+ .close = dummy_close,
+ .priv_data_size = sizeof(Dummy3Context),
+};
+
+/* codec without priv data */
+static AVCodec dummy_v4_encoder = {
+ .name = "dummy_v4_codec",
+ .type = AVMEDIA_TYPE_VIDEO,
+ .id = AV_CODEC_ID_NONE - 4,
+ .encode2 = dummy_encode,
+ .init = dummy_init,
+ .close = dummy_close,
+};
+
+static void test_copy_print_codec(const AVCodecContext *ctx)
+{
+ printf("%-14s: %dx%d prv: %s",
+ ctx->codec ? ctx->codec->name : "NULL",
+ ctx->width, ctx->height,
+ ctx->priv_data ? "set" : "null");
+ if (ctx->codec && ctx->codec->priv_class && ctx->codec->priv_data_size) {
+ int64_t i64;
+ char *str = NULL;
+ av_opt_get_int(ctx->priv_data, "num", 0, &i64);
+ av_opt_get(ctx->priv_data, "str", 0, (uint8_t**)&str);
+ printf(" opts: %"PRId64" %s", i64, str);
+ av_free(str);
+ }
+ printf("\n");
+}
+
+static void test_copy(const AVCodec *c1, const AVCodec *c2)
+{
+ AVCodecContext *ctx1, *ctx2;
+ printf("%s -> %s\nclosed:\n", c1 ? c1->name : "NULL", c2 ? c2->name : "NULL");
+ ctx1 = avcodec_alloc_context3(c1);
+ ctx2 = avcodec_alloc_context3(c2);
+ ctx1->width = ctx1->height = 128;
+ if (ctx2->codec && ctx2->codec->priv_class && ctx2->codec->priv_data_size) {
+ av_opt_set(ctx2->priv_data, "num", "667", 0);
+ av_opt_set(ctx2->priv_data, "str", "i'm dest value before copy", 0);
+ }
+ avcodec_copy_context(ctx2, ctx1);
+ test_copy_print_codec(ctx1);
+ test_copy_print_codec(ctx2);
+ if (ctx1->codec) {
+ printf("opened:\n");
+ avcodec_open2(ctx1, ctx1->codec, NULL);
+ if (ctx2->codec && ctx2->codec->priv_class && ctx2->codec->priv_data_size) {
+ av_opt_set(ctx2->priv_data, "num", "667", 0);
+ av_opt_set(ctx2->priv_data, "str", "i'm dest value before copy", 0);
+ }
+ avcodec_copy_context(ctx2, ctx1);
+ test_copy_print_codec(ctx1);
+ test_copy_print_codec(ctx2);
+ avcodec_close(ctx1);
+ }
+ avcodec_free_context(&ctx1);
+ avcodec_free_context(&ctx2);
+}
+
+int main(void)
+{
+ AVCodec *dummy_codec[] = {
+ &dummy_v1_encoder,
+ &dummy_v2_encoder,
+ &dummy_v3_encoder,
+ &dummy_v4_encoder,
+ NULL,
+ };
+ int i, j;
+
+ for (i = 0; dummy_codec[i]; i++)
+ avcodec_register(dummy_codec[i]);
+
+ printf("testing avcodec_copy_context()\n");
+ for (i = 0; i < FF_ARRAY_ELEMS(dummy_codec); i++)
+ for (j = 0; j < FF_ARRAY_ELEMS(dummy_codec); j++)
+ test_copy(dummy_codec[i], dummy_codec[j]);
+ return 0;
+}
diff --git a/libavcodec/rangecoder-test.c b/libavcodec/rangecoder-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..2892949033992e504220ab38f0f38602babd560e
--- /dev/null
+++ b/libavcodec/rangecoder-test.c
@@ -0,0 +1,64 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdint.h>
+#include <string.h>
+
+#include "libavutil/lfg.h"
+#include "libavutil/log.h"
+
+#include "rangecoder.h"
+
+#define SIZE 10240
+
+int main(void)
+{
+ RangeCoder c;
+ uint8_t b[9 * SIZE];
+ uint8_t r[9 * SIZE];
+ int i;
+ uint8_t state[10];
+ AVLFG prng;
+
+ av_lfg_init(&prng, 1);
+
+ ff_init_range_encoder(&c, b, SIZE);
+ ff_build_rac_states(&c, (1LL << 32) / 20, 128 + 64 + 32 + 16);
+
+ memset(state, 128, sizeof(state));
+
+ for (i = 0; i < SIZE; i++)
+ r[i] = av_lfg_get(&prng) % 7;
+
+ for (i = 0; i < SIZE; i++)
+ put_rac(&c, state, r[i] & 1);
+
+ ff_rac_terminate(&c);
+
+ ff_init_range_decoder(&c, b, SIZE);
+
+ memset(state, 128, sizeof(state));
+
+ for (i = 0; i < SIZE; i++)
+ if ((r[i] & 1) != get_rac(&c, state)) {
+ av_log(NULL, AV_LOG_ERROR, "rac failure at %d\n", i);
+ return 1;
+ }
+
+ return 0;
+}
diff --git a/libavcodec/rangecoder.c b/libavcodec/rangecoder.c
index 31bbaa58814200296101f96d1e8e5d91a8daa6ab..9c6ef75b69e5836475181b03a3eee8507b86aa83 100644
--- a/libavcodec/rangecoder.c
+++ b/libavcodec/rangecoder.c
@@ -114,48 +114,3 @@ int ff_rac_terminate(RangeCoder *c)
return c->bytestream - c->bytestream_start;
}
-
-#ifdef TEST
-#define SIZE 10240
-
-#include "libavutil/lfg.h"
-#include "libavutil/log.h"
-
-static uint8_t b[9 * SIZE];
-static uint8_t r[9 * SIZE];
-
-int main(void)
-{
- RangeCoder c;
- int i;
- uint8_t state[10];
- AVLFG prng;
-
- av_lfg_init(&prng, 1);
-
- ff_init_range_encoder(&c, b, SIZE);
- ff_build_rac_states(&c, (1LL << 32) / 20, 128 + 64 + 32 + 16);
-
- memset(state, 128, sizeof(state));
-
- for (i = 0; i < SIZE; i++)
- r[i] = av_lfg_get(&prng) % 7;
-
- for (i = 0; i < SIZE; i++)
- put_rac(&c, state, r[i] & 1);
-
- ff_rac_terminate(&c);
-
- ff_init_range_decoder(&c, b, SIZE);
-
- memset(state, 128, sizeof(state));
-
- for (i = 0; i < SIZE; i++)
- if ((r[i] & 1) != get_rac(&c, state)) {
- av_log(NULL, AV_LOG_ERROR, "rac failure at %d\n", i);
- return 1;
- }
-
- return 0;
-}
-#endif /* TEST */
diff --git a/libavcodec/snowenc-test.c b/libavcodec/snowenc-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..e1ed86f5c75d6154f4b7980bd925f4823d350b8e
--- /dev/null
+++ b/libavcodec/snowenc-test.c
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "snowenc.c"
+
+#undef malloc
+#undef free
+#undef printf
+
+#include "libavutil/lfg.h"
+#include "libavutil/mathematics.h"
+
+int main(void){
+#define width 256
+#define height 256
+ int buffer[2][width*height];
+ SnowContext s;
+ int i;
+ AVLFG prng;
+ s.spatial_decomposition_count=6;
+ s.spatial_decomposition_type=1;
+
+ s.temp_dwt_buffer = av_mallocz_array(width, sizeof(DWTELEM));
+ s.temp_idwt_buffer = av_mallocz_array(width, sizeof(IDWTELEM));
+
+ if (!s.temp_dwt_buffer || !s.temp_idwt_buffer) {
+ fprintf(stderr, "Failed to allocate memory\n");
+ return 1;
+ }
+
+ av_lfg_init(&prng, 1);
+
+ printf("testing 5/3 DWT\n");
+ for(i=0; i<width*height; i++)
+ buffer[0][i] = buffer[1][i] = av_lfg_get(&prng) % 54321 - 12345;
+
+ ff_spatial_dwt(buffer[0], s.temp_dwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
+ ff_spatial_idwt((IDWTELEM*)buffer[0], s.temp_idwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
+
+ for(i=0; i<width*height; i++)
+ if(buffer[0][i]!= buffer[1][i]) printf("fsck: %6d %12d %7d\n",i, buffer[0][i], buffer[1][i]);
+
+ printf("testing 9/7 DWT\n");
+ s.spatial_decomposition_type=0;
+ for(i=0; i<width*height; i++)
+ buffer[0][i] = buffer[1][i] = av_lfg_get(&prng) % 54321 - 12345;
+
+ ff_spatial_dwt(buffer[0], s.temp_dwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
+ ff_spatial_idwt((IDWTELEM*)buffer[0], s.temp_idwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
+
+ for(i=0; i<width*height; i++)
+ if(FFABS(buffer[0][i] - buffer[1][i])>20) printf("fsck: %6d %12d %7d\n",i, buffer[0][i], buffer[1][i]);
+
+ {
+ int level, orientation, x, y;
+ int64_t errors[8][4];
+ int64_t g=0;
+
+ memset(errors, 0, sizeof(errors));
+ s.spatial_decomposition_count=3;
+ s.spatial_decomposition_type=0;
+ for(level=0; level<s.spatial_decomposition_count; level++){
+ for(orientation=level ? 1 : 0; orientation<4; orientation++){
+ int w= width >> (s.spatial_decomposition_count-level);
+ int h= height >> (s.spatial_decomposition_count-level);
+ int stride= width << (s.spatial_decomposition_count-level);
+ DWTELEM *buf= buffer[0];
+ int64_t error=0;
+
+ if(orientation&1) buf+=w;
+ if(orientation>1) buf+=stride>>1;
+
+ memset(buffer[0], 0, sizeof(int)*width*height);
+ buf[w/2 + h/2*stride]= 256*256;
+ ff_spatial_idwt((IDWTELEM*)buffer[0], s.temp_idwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
+ for(y=0; y<height; y++){
+ for(x=0; x<width; x++){
+ int64_t d= buffer[0][x + y*width];
+ error += d*d;
+ if(FFABS(width/2-x)<9 && FFABS(height/2-y)<9 && level==2) printf("%8"PRId64" ", d);
+ }
+ if(FFABS(height/2-y)<9 && level==2) printf("\n");
+ }
+ error= (int)(sqrt(error)+0.5);
+ errors[level][orientation]= error;
+ if(g) g=av_gcd(g, error);
+ else g= error;
+ }
+ }
+ printf("static int const visual_weight[][4]={\n");
+ for(level=0; level<s.spatial_decomposition_count; level++){
+ printf(" {");
+ for(orientation=0; orientation<4; orientation++){
+ printf("%8"PRId64",", errors[level][orientation]/g);
+ }
+ printf("},\n");
+ }
+ printf("};\n");
+ {
+ int level=2;
+ int w= width >> (s.spatial_decomposition_count-level);
+ //int h= height >> (s.spatial_decomposition_count-level);
+ int stride= width << (s.spatial_decomposition_count-level);
+ DWTELEM *buf= buffer[0];
+ int64_t error=0;
+
+ buf+=w;
+ buf+=stride>>1;
+
+ memset(buffer[0], 0, sizeof(int)*width*height);
+ for(y=0; y<height; y++){
+ for(x=0; x<width; x++){
+ int tab[4]={0,2,3,1};
+ buffer[0][x+width*y]= 256*256*tab[(x&1) + 2*(y&1)];
+ }
+ }
+ ff_spatial_dwt(buffer[0], s.temp_dwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
+ for(y=0; y<height; y++){
+ for(x=0; x<width; x++){
+ int64_t d= buffer[0][x + y*width];
+ error += d*d;
+ if(FFABS(width/2-x)<9 && FFABS(height/2-y)<9) printf("%8"PRId64" ", d);
+ }
+ if(FFABS(height/2-y)<9) printf("\n");
+ }
+ }
+
+ }
+ return 0;
+}
diff --git a/libavcodec/snowenc.c b/libavcodec/snowenc.c
index b1d177d3b8975191eddc04b68cc2573ea09555e8..00aef572ae1eba12fbdea903988ae1b9f9603088 100644
--- a/libavcodec/snowenc.c
+++ b/libavcodec/snowenc.c
@@ -1955,132 +1955,3 @@ AVCodec ff_snow_encoder = {
.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
FF_CODEC_CAP_INIT_CLEANUP,
};
-
-
-#ifdef TEST
-#undef malloc
-#undef free
-#undef printf
-
-#include "libavutil/lfg.h"
-#include "libavutil/mathematics.h"
-
-int main(void){
-#define width 256
-#define height 256
- int buffer[2][width*height];
- SnowContext s;
- int i;
- AVLFG prng;
- s.spatial_decomposition_count=6;
- s.spatial_decomposition_type=1;
-
- s.temp_dwt_buffer = av_mallocz_array(width, sizeof(DWTELEM));
- s.temp_idwt_buffer = av_mallocz_array(width, sizeof(IDWTELEM));
-
- if (!s.temp_dwt_buffer || !s.temp_idwt_buffer) {
- fprintf(stderr, "Failed to allocate memory\n");
- return 1;
- }
-
- av_lfg_init(&prng, 1);
-
- printf("testing 5/3 DWT\n");
- for(i=0; i<width*height; i++)
- buffer[0][i] = buffer[1][i] = av_lfg_get(&prng) % 54321 - 12345;
-
- ff_spatial_dwt(buffer[0], s.temp_dwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
- ff_spatial_idwt((IDWTELEM*)buffer[0], s.temp_idwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
-
- for(i=0; i<width*height; i++)
- if(buffer[0][i]!= buffer[1][i]) printf("fsck: %6d %12d %7d\n",i, buffer[0][i], buffer[1][i]);
-
- printf("testing 9/7 DWT\n");
- s.spatial_decomposition_type=0;
- for(i=0; i<width*height; i++)
- buffer[0][i] = buffer[1][i] = av_lfg_get(&prng) % 54321 - 12345;
-
- ff_spatial_dwt(buffer[0], s.temp_dwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
- ff_spatial_idwt((IDWTELEM*)buffer[0], s.temp_idwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
-
- for(i=0; i<width*height; i++)
- if(FFABS(buffer[0][i] - buffer[1][i])>20) printf("fsck: %6d %12d %7d\n",i, buffer[0][i], buffer[1][i]);
-
- {
- int level, orientation, x, y;
- int64_t errors[8][4];
- int64_t g=0;
-
- memset(errors, 0, sizeof(errors));
- s.spatial_decomposition_count=3;
- s.spatial_decomposition_type=0;
- for(level=0; level<s.spatial_decomposition_count; level++){
- for(orientation=level ? 1 : 0; orientation<4; orientation++){
- int w= width >> (s.spatial_decomposition_count-level);
- int h= height >> (s.spatial_decomposition_count-level);
- int stride= width << (s.spatial_decomposition_count-level);
- DWTELEM *buf= buffer[0];
- int64_t error=0;
-
- if(orientation&1) buf+=w;
- if(orientation>1) buf+=stride>>1;
-
- memset(buffer[0], 0, sizeof(int)*width*height);
- buf[w/2 + h/2*stride]= 256*256;
- ff_spatial_idwt((IDWTELEM*)buffer[0], s.temp_idwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
- for(y=0; y<height; y++){
- for(x=0; x<width; x++){
- int64_t d= buffer[0][x + y*width];
- error += d*d;
- if(FFABS(width/2-x)<9 && FFABS(height/2-y)<9 && level==2) printf("%8"PRId64" ", d);
- }
- if(FFABS(height/2-y)<9 && level==2) printf("\n");
- }
- error= (int)(sqrt(error)+0.5);
- errors[level][orientation]= error;
- if(g) g=av_gcd(g, error);
- else g= error;
- }
- }
- printf("static int const visual_weight[][4]={\n");
- for(level=0; level<s.spatial_decomposition_count; level++){
- printf(" {");
- for(orientation=0; orientation<4; orientation++){
- printf("%8"PRId64",", errors[level][orientation]/g);
- }
- printf("},\n");
- }
- printf("};\n");
- {
- int level=2;
- int w= width >> (s.spatial_decomposition_count-level);
- //int h= height >> (s.spatial_decomposition_count-level);
- int stride= width << (s.spatial_decomposition_count-level);
- DWTELEM *buf= buffer[0];
- int64_t error=0;
-
- buf+=w;
- buf+=stride>>1;
-
- memset(buffer[0], 0, sizeof(int)*width*height);
- for(y=0; y<height; y++){
- for(x=0; x<width; x++){
- int tab[4]={0,2,3,1};
- buffer[0][x+width*y]= 256*256*tab[(x&1) + 2*(y&1)];
- }
- }
- ff_spatial_dwt(buffer[0], s.temp_dwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
- for(y=0; y<height; y++){
- for(x=0; x<width; x++){
- int64_t d= buffer[0][x + y*width];
- error += d*d;
- if(FFABS(width/2-x)<9 && FFABS(height/2-y)<9) printf("%8"PRId64" ", d);
- }
- if(FFABS(height/2-y)<9) printf("\n");
- }
- }
-
- }
- return 0;
-}
-#endif /* TEST */
diff --git a/libavcodec/utils-test.c b/libavcodec/utils-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..7b3b718bd15a03d3a08534365c6f2946a90501f0
--- /dev/null
+++ b/libavcodec/utils-test.c
@@ -0,0 +1,37 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "avcodec.h"
+
+int main(void){
+ AVCodec *codec = NULL;
+ int ret = 0;
+ avcodec_register_all();
+
+ while (codec = av_codec_next(codec)) {
+ if (av_codec_is_encoder(codec)) {
+ if (codec->type == AVMEDIA_TYPE_AUDIO) {
+ if (!codec->sample_fmts) {
+ av_log(NULL, AV_LOG_FATAL, "Encoder %s is missing the sample_fmts field\n", codec->name);
+ ret = 1;
+ }
+ }
+ }
+ }
+ return ret;
+}
diff --git a/libavcodec/utils.c b/libavcodec/utils.c
index e6609ef9b2bd4c6c76e9a4a06d43b90c7ed66a92..8652b17ee7c8d62826183d65c919d176d1286063 100644
--- a/libavcodec/utils.c
+++ b/libavcodec/utils.c
@@ -4172,23 +4172,3 @@ int avcodec_parameters_to_context(AVCodecContext *codec,
return 0;
}
-
-#ifdef TEST
-int main(void){
- AVCodec *codec = NULL;
- int ret = 0;
- avcodec_register_all();
-
- while (codec = av_codec_next(codec)) {
- if (av_codec_is_encoder(codec)) {
- if (codec->type == AVMEDIA_TYPE_AUDIO) {
- if (!codec->sample_fmts) {
- av_log(NULL, AV_LOG_FATAL, "Encoder %s is missing the sample_fmts field\n", codec->name);
- ret = 1;
- }
- }
- }
- }
- return ret;
-}
-#endif /* TEST */
diff --git a/libavdevice/timefilter-test.c b/libavdevice/timefilter-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..39432d5ed75acb08c3fa2b9831a0e6a0e25ea581
--- /dev/null
+++ b/libavdevice/timefilter-test.c
@@ -0,0 +1,98 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdio.h>
+
+#include "libavutil/common.h"
+#include "libavutil/lfg.h"
+
+#include "timefilter.h"
+
+#define LFG_MAX ((1LL << 32) - 1)
+
+int main(void)
+{
+ AVLFG prng;
+ double n0, n1;
+#define SAMPLES 1000
+ double ideal[SAMPLES];
+ double samples[SAMPLES];
+ double samplet[SAMPLES];
+ for (n0 = 0; n0 < 40; n0 = 2 * n0 + 1) {
+ for (n1 = 0; n1 < 10; n1 = 2 * n1 + 1) {
+ double best_error = 1000000000;
+ double bestpar0 = n0 ? 1 : 100000;
+ double bestpar1 = 1;
+ int better, i;
+
+ av_lfg_init(&prng, 123);
+ for (i = 0; i < SAMPLES; i++) {
+ samplet[i] = 10 + i + (av_lfg_get(&prng) < LFG_MAX/2 ? 0 : 0.999);
+ ideal[i] = samplet[i] + n1 * i / (1000);
+ samples[i] = ideal[i] + n0 * (av_lfg_get(&prng) - LFG_MAX / 2) / (LFG_MAX * 10LL);
+ if(i && samples[i]<samples[i-1])
+ samples[i]=samples[i-1]+0.001;
+ }
+
+ do {
+ double par0, par1;
+ better = 0;
+ for (par0 = bestpar0 * 0.8; par0 <= bestpar0 * 1.21; par0 += bestpar0 * 0.05) {
+ for (par1 = bestpar1 * 0.8; par1 <= bestpar1 * 1.21; par1 += bestpar1 * 0.05) {
+ double error = 0;
+ TimeFilter *tf = ff_timefilter_new(1, par0, par1);
+ if (!tf) {
+ printf("Could not allocate memory for timefilter.\n");
+ exit(1);
+ }
+ for (i = 0; i < SAMPLES; i++) {
+ double filtered;
+ filtered = ff_timefilter_update(tf, samples[i], i ? (samplet[i] - samplet[i-1]) : 1);
+ if(filtered < 0 || filtered > 1000000000)
+ printf("filter is unstable\n");
+ error += (filtered - ideal[i]) * (filtered - ideal[i]);
+ }
+ ff_timefilter_destroy(tf);
+ if (error < best_error) {
+ best_error = error;
+ bestpar0 = par0;
+ bestpar1 = par1;
+ better = 1;
+ }
+ }
+ }
+ } while (better);
+#if 0
+ double lastfil = 9;
+ TimeFilter *tf = ff_timefilter_new(1, bestpar0, bestpar1);
+ for (i = 0; i < SAMPLES; i++) {
+ double filtered;
+ filtered = ff_timefilter_update(tf, samples[i], 1);
+ printf("%f %f %f %f\n", i - samples[i] + 10, filtered - samples[i],
+ samples[FFMAX(i, 1)] - samples[FFMAX(i - 1, 0)], filtered - lastfil);
+ lastfil = filtered;
+ }
+ ff_timefilter_destroy(tf);
+#else
+ printf(" [%12f %11f %9f]", bestpar0, bestpar1, best_error);
+#endif
+ }
+ printf("\n");
+ }
+ return 0;
+}
diff --git a/libavdevice/timefilter.c b/libavdevice/timefilter.c
index a4ae20413984b79c75bb7e2a75adc5efb60049cc..ad6485d5e7807a29ee33a158c5cd3b3d3fa12b06 100644
--- a/libavdevice/timefilter.c
+++ b/libavdevice/timefilter.c
@@ -89,80 +89,3 @@ double ff_timefilter_eval(TimeFilter *self, double delta)
{
return self->cycle_time + self->clock_period * delta;
}
-
-#ifdef TEST
-#include "libavutil/lfg.h"
-#define LFG_MAX ((1LL << 32) - 1)
-
-int main(void)
-{
- AVLFG prng;
- double n0, n1;
-#define SAMPLES 1000
- double ideal[SAMPLES];
- double samples[SAMPLES];
- double samplet[SAMPLES];
- for (n0 = 0; n0 < 40; n0 = 2 * n0 + 1) {
- for (n1 = 0; n1 < 10; n1 = 2 * n1 + 1) {
- double best_error = 1000000000;
- double bestpar0 = n0 ? 1 : 100000;
- double bestpar1 = 1;
- int better, i;
-
- av_lfg_init(&prng, 123);
- for (i = 0; i < SAMPLES; i++) {
- samplet[i] = 10 + i + (av_lfg_get(&prng) < LFG_MAX/2 ? 0 : 0.999);
- ideal[i] = samplet[i] + n1 * i / (1000);
- samples[i] = ideal[i] + n0 * (av_lfg_get(&prng) - LFG_MAX / 2) / (LFG_MAX * 10LL);
- if(i && samples[i]<samples[i-1])
- samples[i]=samples[i-1]+0.001;
- }
-
- do {
- double par0, par1;
- better = 0;
- for (par0 = bestpar0 * 0.8; par0 <= bestpar0 * 1.21; par0 += bestpar0 * 0.05) {
- for (par1 = bestpar1 * 0.8; par1 <= bestpar1 * 1.21; par1 += bestpar1 * 0.05) {
- double error = 0;
- TimeFilter *tf = ff_timefilter_new(1, par0, par1);
- if (!tf) {
- printf("Could not allocate memory for timefilter.\n");
- exit(1);
- }
- for (i = 0; i < SAMPLES; i++) {
- double filtered;
- filtered = ff_timefilter_update(tf, samples[i], i ? (samplet[i] - samplet[i-1]) : 1);
- if(filtered < 0 || filtered > 1000000000)
- printf("filter is unstable\n");
- error += (filtered - ideal[i]) * (filtered - ideal[i]);
- }
- ff_timefilter_destroy(tf);
- if (error < best_error) {
- best_error = error;
- bestpar0 = par0;
- bestpar1 = par1;
- better = 1;
- }
- }
- }
- } while (better);
-#if 0
- double lastfil = 9;
- TimeFilter *tf = ff_timefilter_new(1, bestpar0, bestpar1);
- for (i = 0; i < SAMPLES; i++) {
- double filtered;
- filtered = ff_timefilter_update(tf, samples[i], 1);
- printf("%f %f %f %f\n", i - samples[i] + 10, filtered - samples[i],
- samples[FFMAX(i, 1)] - samples[FFMAX(i - 1, 0)], filtered - lastfil);
- lastfil = filtered;
- }
- ff_timefilter_destroy(tf);
-#else
- printf(" [%12f %11f %9f]", bestpar0, bestpar1, best_error);
-#endif
- }
- printf("\n");
- }
- return 0;
-}
-#endif
diff --git a/libavfilter/filtfmts.c b/libavfilter/filtfmts-test.c
similarity index 100%
rename from libavfilter/filtfmts.c
rename to libavfilter/filtfmts-test.c
diff --git a/libavfilter/formats-test.c b/libavfilter/formats-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..a8916383e60e289cff5025df8b886cdf37cd5da9
--- /dev/null
+++ b/libavfilter/formats-test.c
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2007 Bobby Bingham
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "formats.c"
+
+#undef printf
+
+int main(void)
+{
+ const int64_t *cl;
+ char buf[512];
+ int i;
+ const char *teststrings[] ={
+ "blah",
+ "1",
+ "2",
+ "-1",
+ "60",
+ "65",
+ "1c",
+ "2c",
+ "-1c",
+ "60c",
+ "65c",
+ "5.1",
+ "stereo",
+ "1+1+1+1",
+ "1c+1c+1c+1c",
+ "2c+1c",
+ "0x3",
+ };
+
+ for (cl = avfilter_all_channel_layouts; *cl != -1; cl++) {
+ av_get_channel_layout_string(buf, sizeof(buf), -1, *cl);
+ printf("%s\n", buf);
+ }
+
+ for ( i = 0; i<FF_ARRAY_ELEMS(teststrings); i++) {
+ int64_t layout = -1;
+ int count = -1;
+ int ret;
+ ret = ff_parse_channel_layout(&layout, &count, teststrings[i], NULL);
+
+ printf ("%d = ff_parse_channel_layout(%016"PRIX64", %2d, %s);\n", ret ? -1 : 0, layout, count, teststrings[i]);
+ }
+
+ return 0;
+}
diff --git a/libavfilter/formats.c b/libavfilter/formats.c
index f12dcf47834b65a409df64e54434e5e2a9295ac6..20f45e33cc7be47842c137d7e9cae44d4dd997fd 100644
--- a/libavfilter/formats.c
+++ b/libavfilter/formats.c
@@ -683,52 +683,3 @@ int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg,
*nret = av_get_channel_layout_nb_channels(chlayout);
return 0;
}
-
-#ifdef TEST
-
-#undef printf
-
-int main(void)
-{
- const int64_t *cl;
- char buf[512];
- int i;
- const char *teststrings[] ={
- "blah",
- "1",
- "2",
- "-1",
- "60",
- "65",
- "1c",
- "2c",
- "-1c",
- "60c",
- "65c",
- "5.1",
- "stereo",
- "1+1+1+1",
- "1c+1c+1c+1c",
- "2c+1c",
- "0x3",
- };
-
- for (cl = avfilter_all_channel_layouts; *cl != -1; cl++) {
- av_get_channel_layout_string(buf, sizeof(buf), -1, *cl);
- printf("%s\n", buf);
- }
-
- for ( i = 0; i<FF_ARRAY_ELEMS(teststrings); i++) {
- int64_t layout = -1;
- int count = -1;
- int ret;
- ret = ff_parse_channel_layout(&layout, &count, teststrings[i], NULL);
-
- printf ("%d = ff_parse_channel_layout(%016"PRIX64", %2d, %s);\n", ret ? -1 : 0, layout, count, teststrings[i]);
- }
-
- return 0;
-}
-
-#endif
-
diff --git a/libavformat/rtmpdh-test.c b/libavformat/rtmpdh-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..e86fb18f9759916d2094a4834d87ad5cf4128e1b
--- /dev/null
+++ b/libavformat/rtmpdh-test.c
@@ -0,0 +1,158 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "rtmpdh.c"
+
+#include <stdio.h>
+
+static int test_random_shared_secret(void)
+{
+ FF_DH *peer1 = NULL, *peer2 = NULL;
+ int ret;
+ uint8_t pubkey1[128], pubkey2[128];
+ uint8_t sharedkey1[128], sharedkey2[128];
+
+ peer1 = ff_dh_init(1024);
+ peer2 = ff_dh_init(1024);
+ if (!peer1 || !peer2) {
+ ret = AVERROR(ENOMEM);
+ goto fail;
+ }
+ if ((ret = ff_dh_generate_public_key(peer1)) < 0)
+ goto fail;
+ if ((ret = ff_dh_generate_public_key(peer2)) < 0)
+ goto fail;
+ if ((ret = ff_dh_write_public_key(peer1, pubkey1, sizeof(pubkey1))) < 0)
+ goto fail;
+ if ((ret = ff_dh_write_public_key(peer2, pubkey2, sizeof(pubkey2))) < 0)
+ goto fail;
+ if ((ret = ff_dh_compute_shared_secret_key(peer1, pubkey2, sizeof(pubkey2),
+ sharedkey1, sizeof(sharedkey1))) < 0)
+ goto fail;
+ if ((ret = ff_dh_compute_shared_secret_key(peer2, pubkey1, sizeof(pubkey1),
+ sharedkey2, sizeof(sharedkey2))) < 0)
+ goto fail;
+ if (memcmp(sharedkey1, sharedkey2, sizeof(sharedkey1))) {
+ printf("Mismatched generated shared key\n");
+ ret = AVERROR_INVALIDDATA;
+ } else {
+ printf("Generated shared key ok\n");
+ }
+fail:
+ ff_dh_free(peer1);
+ ff_dh_free(peer2);
+ return ret;
+}
+
+static const char *private_key =
+ "976C18FCADC255B456564F74F3EEDA59D28AF6B744D743F2357BFD2404797EF896EF1A"
+ "7C1CBEAAA3AB60AF3192D189CFF3F991C9CBBFD78119FCA2181384B94011943B6D6F28"
+ "9E1B708E2D1A0C7771169293F03DA27E561F15F16F0AC9BC858C77A80FA98FD088A232"
+ "19D08BE6F165DE0B02034B18705829FAD0ACB26A5B75EF";
+static const char *public_key =
+ "F272ECF8362257C5D2C3CC2229CF9C0A03225BC109B1DBC76A68C394F256ACA3EF5F64"
+ "FC270C26382BF315C19E97A76104A716FC998A651E8610A3AE6CF65D8FAE5D3F32EEA0"
+ "0B32CB9609B494116A825D7142D17B88E3D20EDD98743DE29CF37A23A9F6A58B960591"
+ "3157D5965FCB46DDA73A1F08DD897BAE88DFE6FC937CBA";
+static const uint8_t public_key_bin[] = {
+ 0xf2, 0x72, 0xec, 0xf8, 0x36, 0x22, 0x57, 0xc5, 0xd2, 0xc3, 0xcc, 0x22,
+ 0x29, 0xcf, 0x9c, 0x0a, 0x03, 0x22, 0x5b, 0xc1, 0x09, 0xb1, 0xdb, 0xc7,
+ 0x6a, 0x68, 0xc3, 0x94, 0xf2, 0x56, 0xac, 0xa3, 0xef, 0x5f, 0x64, 0xfc,
+ 0x27, 0x0c, 0x26, 0x38, 0x2b, 0xf3, 0x15, 0xc1, 0x9e, 0x97, 0xa7, 0x61,
+ 0x04, 0xa7, 0x16, 0xfc, 0x99, 0x8a, 0x65, 0x1e, 0x86, 0x10, 0xa3, 0xae,
+ 0x6c, 0xf6, 0x5d, 0x8f, 0xae, 0x5d, 0x3f, 0x32, 0xee, 0xa0, 0x0b, 0x32,
+ 0xcb, 0x96, 0x09, 0xb4, 0x94, 0x11, 0x6a, 0x82, 0x5d, 0x71, 0x42, 0xd1,
+ 0x7b, 0x88, 0xe3, 0xd2, 0x0e, 0xdd, 0x98, 0x74, 0x3d, 0xe2, 0x9c, 0xf3,
+ 0x7a, 0x23, 0xa9, 0xf6, 0xa5, 0x8b, 0x96, 0x05, 0x91, 0x31, 0x57, 0xd5,
+ 0x96, 0x5f, 0xcb, 0x46, 0xdd, 0xa7, 0x3a, 0x1f, 0x08, 0xdd, 0x89, 0x7b,
+ 0xae, 0x88, 0xdf, 0xe6, 0xfc, 0x93, 0x7c, 0xba
+};
+static const uint8_t peer_public_key[] = {
+ 0x58, 0x66, 0x05, 0x49, 0x94, 0x23, 0x2b, 0x66, 0x52, 0x13, 0xff, 0x46,
+ 0xf2, 0xb3, 0x79, 0xa9, 0xee, 0xae, 0x1a, 0x13, 0xf0, 0x71, 0x52, 0xfb,
+ 0x93, 0x4e, 0xee, 0x97, 0x05, 0x73, 0x50, 0x7d, 0xaf, 0x02, 0x07, 0x72,
+ 0xac, 0xdc, 0xa3, 0x95, 0x78, 0xee, 0x9a, 0x19, 0x71, 0x7e, 0x99, 0x9f,
+ 0x2a, 0xd4, 0xb3, 0xe2, 0x0c, 0x1d, 0x1a, 0x78, 0x4c, 0xde, 0xf1, 0xad,
+ 0xb4, 0x60, 0xa8, 0x51, 0xac, 0x71, 0xec, 0x86, 0x70, 0xa2, 0x63, 0x36,
+ 0x92, 0x7c, 0xe3, 0x87, 0xee, 0xe4, 0xf1, 0x62, 0x24, 0x74, 0xb4, 0x04,
+ 0xfa, 0x5c, 0xdf, 0xba, 0xfa, 0xa3, 0xc2, 0xbb, 0x62, 0x27, 0xd0, 0xf4,
+ 0xe4, 0x43, 0xda, 0x8a, 0x88, 0x69, 0x60, 0xe2, 0xdb, 0x75, 0x2a, 0x98,
+ 0x9d, 0xb5, 0x50, 0xe3, 0x99, 0xda, 0xe0, 0xa6, 0x14, 0xc9, 0x80, 0x12,
+ 0xf9, 0x3c, 0xac, 0x06, 0x02, 0x7a, 0xde, 0x74
+};
+static const uint8_t shared_secret[] = {
+ 0xb2, 0xeb, 0xcb, 0x71, 0xf3, 0x61, 0xfb, 0x5b, 0x4e, 0x5c, 0x4c, 0xcf,
+ 0x5c, 0x08, 0x5f, 0x96, 0x26, 0x77, 0x1d, 0x31, 0xf1, 0xe1, 0xf7, 0x4b,
+ 0x92, 0xac, 0x82, 0x2a, 0x88, 0xc7, 0x83, 0xe1, 0xc7, 0xf3, 0xd3, 0x1a,
+ 0x7d, 0xc8, 0x31, 0xe3, 0x97, 0xe4, 0xec, 0x31, 0x0e, 0x8f, 0x73, 0x1a,
+ 0xe4, 0xf6, 0xd8, 0xc8, 0x94, 0xff, 0xa0, 0x03, 0x84, 0x03, 0x0f, 0xa5,
+ 0x30, 0x5d, 0x67, 0xe0, 0x7a, 0x3b, 0x5f, 0xed, 0x4c, 0xf5, 0xbc, 0x18,
+ 0xea, 0xd4, 0x77, 0xa9, 0x07, 0xb3, 0x54, 0x0b, 0x02, 0xd9, 0xc6, 0xb8,
+ 0x66, 0x5e, 0xec, 0xa4, 0xcd, 0x47, 0xed, 0xc9, 0x38, 0xc6, 0x91, 0x08,
+ 0xf3, 0x85, 0x9b, 0x69, 0x16, 0x78, 0x0d, 0xb7, 0x74, 0x51, 0xaa, 0x5b,
+ 0x4d, 0x74, 0xe4, 0x29, 0x2e, 0x9e, 0x8e, 0xf7, 0xe5, 0x42, 0x83, 0xb0,
+ 0x65, 0xb0, 0xce, 0xc6, 0xb2, 0x8f, 0x5b, 0xb0
+};
+
+static int test_ref_data(void)
+{
+ FF_DH *dh;
+ int ret = AVERROR(ENOMEM);
+ uint8_t pubkey_test[128];
+ uint8_t sharedkey_test[128];
+
+ dh = ff_dh_init(1024);
+ if (!dh)
+ goto fail;
+ bn_hex2bn(dh->priv_key, private_key, ret);
+ if (!ret)
+ goto fail;
+ bn_hex2bn(dh->pub_key, public_key, ret);
+ if (!ret)
+ goto fail;
+ if ((ret = ff_dh_write_public_key(dh, pubkey_test, sizeof(pubkey_test))) < 0)
+ goto fail;
+ if (memcmp(pubkey_test, public_key_bin, sizeof(pubkey_test))) {
+ printf("Mismatched generated public key\n");
+ ret = AVERROR_INVALIDDATA;
+ goto fail;
+ } else {
+ printf("Generated public key ok\n");
+ }
+ if ((ret = ff_dh_compute_shared_secret_key(dh, peer_public_key, sizeof(peer_public_key),
+ sharedkey_test, sizeof(sharedkey_test))) < 0)
+ goto fail;
+ if (memcmp(shared_secret, sharedkey_test, sizeof(sharedkey_test))) {
+ printf("Mismatched generated shared key\n");
+ ret = AVERROR_INVALIDDATA;
+ } else {
+ printf("Generated shared key ok\n");
+ }
+fail:
+ ff_dh_free(dh);
+ return ret;
+}
+
+int main(void)
+{
+ if (test_random_shared_secret() < 0)
+ return 1;
+ if (test_ref_data() < 0)
+ return 1;
+ return 0;
+}
diff --git a/libavformat/rtmpdh.c b/libavformat/rtmpdh.c
index 4f205883729d31f51c6b8140e202ee73a846982a..1876fd44f9ec45f428354c48ceb179cdd9bbe5b3 100644
--- a/libavformat/rtmpdh.c
+++ b/libavformat/rtmpdh.c
@@ -369,145 +369,3 @@ fail:
return ret;
}
-
-#ifdef TEST
-
-#include <stdio.h>
-
-static int test_random_shared_secret(void)
-{
- FF_DH *peer1 = NULL, *peer2 = NULL;
- int ret;
- uint8_t pubkey1[128], pubkey2[128];
- uint8_t sharedkey1[128], sharedkey2[128];
-
- peer1 = ff_dh_init(1024);
- peer2 = ff_dh_init(1024);
- if (!peer1 || !peer2) {
- ret = AVERROR(ENOMEM);
- goto fail;
- }
- if ((ret = ff_dh_generate_public_key(peer1)) < 0)
- goto fail;
- if ((ret = ff_dh_generate_public_key(peer2)) < 0)
- goto fail;
- if ((ret = ff_dh_write_public_key(peer1, pubkey1, sizeof(pubkey1))) < 0)
- goto fail;
- if ((ret = ff_dh_write_public_key(peer2, pubkey2, sizeof(pubkey2))) < 0)
- goto fail;
- if ((ret = ff_dh_compute_shared_secret_key(peer1, pubkey2, sizeof(pubkey2),
- sharedkey1, sizeof(sharedkey1))) < 0)
- goto fail;
- if ((ret = ff_dh_compute_shared_secret_key(peer2, pubkey1, sizeof(pubkey1),
- sharedkey2, sizeof(sharedkey2))) < 0)
- goto fail;
- if (memcmp(sharedkey1, sharedkey2, sizeof(sharedkey1))) {
- printf("Mismatched generated shared key\n");
- ret = AVERROR_INVALIDDATA;
- } else {
- printf("Generated shared key ok\n");
- }
-fail:
- ff_dh_free(peer1);
- ff_dh_free(peer2);
- return ret;
-}
-
-static const char *private_key =
- "976C18FCADC255B456564F74F3EEDA59D28AF6B744D743F2357BFD2404797EF896EF1A"
- "7C1CBEAAA3AB60AF3192D189CFF3F991C9CBBFD78119FCA2181384B94011943B6D6F28"
- "9E1B708E2D1A0C7771169293F03DA27E561F15F16F0AC9BC858C77A80FA98FD088A232"
- "19D08BE6F165DE0B02034B18705829FAD0ACB26A5B75EF";
-static const char *public_key =
- "F272ECF8362257C5D2C3CC2229CF9C0A03225BC109B1DBC76A68C394F256ACA3EF5F64"
- "FC270C26382BF315C19E97A76104A716FC998A651E8610A3AE6CF65D8FAE5D3F32EEA0"
- "0B32CB9609B494116A825D7142D17B88E3D20EDD98743DE29CF37A23A9F6A58B960591"
- "3157D5965FCB46DDA73A1F08DD897BAE88DFE6FC937CBA";
-static const uint8_t public_key_bin[] = {
- 0xf2, 0x72, 0xec, 0xf8, 0x36, 0x22, 0x57, 0xc5, 0xd2, 0xc3, 0xcc, 0x22,
- 0x29, 0xcf, 0x9c, 0x0a, 0x03, 0x22, 0x5b, 0xc1, 0x09, 0xb1, 0xdb, 0xc7,
- 0x6a, 0x68, 0xc3, 0x94, 0xf2, 0x56, 0xac, 0xa3, 0xef, 0x5f, 0x64, 0xfc,
- 0x27, 0x0c, 0x26, 0x38, 0x2b, 0xf3, 0x15, 0xc1, 0x9e, 0x97, 0xa7, 0x61,
- 0x04, 0xa7, 0x16, 0xfc, 0x99, 0x8a, 0x65, 0x1e, 0x86, 0x10, 0xa3, 0xae,
- 0x6c, 0xf6, 0x5d, 0x8f, 0xae, 0x5d, 0x3f, 0x32, 0xee, 0xa0, 0x0b, 0x32,
- 0xcb, 0x96, 0x09, 0xb4, 0x94, 0x11, 0x6a, 0x82, 0x5d, 0x71, 0x42, 0xd1,
- 0x7b, 0x88, 0xe3, 0xd2, 0x0e, 0xdd, 0x98, 0x74, 0x3d, 0xe2, 0x9c, 0xf3,
- 0x7a, 0x23, 0xa9, 0xf6, 0xa5, 0x8b, 0x96, 0x05, 0x91, 0x31, 0x57, 0xd5,
- 0x96, 0x5f, 0xcb, 0x46, 0xdd, 0xa7, 0x3a, 0x1f, 0x08, 0xdd, 0x89, 0x7b,
- 0xae, 0x88, 0xdf, 0xe6, 0xfc, 0x93, 0x7c, 0xba
-};
-static const uint8_t peer_public_key[] = {
- 0x58, 0x66, 0x05, 0x49, 0x94, 0x23, 0x2b, 0x66, 0x52, 0x13, 0xff, 0x46,
- 0xf2, 0xb3, 0x79, 0xa9, 0xee, 0xae, 0x1a, 0x13, 0xf0, 0x71, 0x52, 0xfb,
- 0x93, 0x4e, 0xee, 0x97, 0x05, 0x73, 0x50, 0x7d, 0xaf, 0x02, 0x07, 0x72,
- 0xac, 0xdc, 0xa3, 0x95, 0x78, 0xee, 0x9a, 0x19, 0x71, 0x7e, 0x99, 0x9f,
- 0x2a, 0xd4, 0xb3, 0xe2, 0x0c, 0x1d, 0x1a, 0x78, 0x4c, 0xde, 0xf1, 0xad,
- 0xb4, 0x60, 0xa8, 0x51, 0xac, 0x71, 0xec, 0x86, 0x70, 0xa2, 0x63, 0x36,
- 0x92, 0x7c, 0xe3, 0x87, 0xee, 0xe4, 0xf1, 0x62, 0x24, 0x74, 0xb4, 0x04,
- 0xfa, 0x5c, 0xdf, 0xba, 0xfa, 0xa3, 0xc2, 0xbb, 0x62, 0x27, 0xd0, 0xf4,
- 0xe4, 0x43, 0xda, 0x8a, 0x88, 0x69, 0x60, 0xe2, 0xdb, 0x75, 0x2a, 0x98,
- 0x9d, 0xb5, 0x50, 0xe3, 0x99, 0xda, 0xe0, 0xa6, 0x14, 0xc9, 0x80, 0x12,
- 0xf9, 0x3c, 0xac, 0x06, 0x02, 0x7a, 0xde, 0x74
-};
-static const uint8_t shared_secret[] = {
- 0xb2, 0xeb, 0xcb, 0x71, 0xf3, 0x61, 0xfb, 0x5b, 0x4e, 0x5c, 0x4c, 0xcf,
- 0x5c, 0x08, 0x5f, 0x96, 0x26, 0x77, 0x1d, 0x31, 0xf1, 0xe1, 0xf7, 0x4b,
- 0x92, 0xac, 0x82, 0x2a, 0x88, 0xc7, 0x83, 0xe1, 0xc7, 0xf3, 0xd3, 0x1a,
- 0x7d, 0xc8, 0x31, 0xe3, 0x97, 0xe4, 0xec, 0x31, 0x0e, 0x8f, 0x73, 0x1a,
- 0xe4, 0xf6, 0xd8, 0xc8, 0x94, 0xff, 0xa0, 0x03, 0x84, 0x03, 0x0f, 0xa5,
- 0x30, 0x5d, 0x67, 0xe0, 0x7a, 0x3b, 0x5f, 0xed, 0x4c, 0xf5, 0xbc, 0x18,
- 0xea, 0xd4, 0x77, 0xa9, 0x07, 0xb3, 0x54, 0x0b, 0x02, 0xd9, 0xc6, 0xb8,
- 0x66, 0x5e, 0xec, 0xa4, 0xcd, 0x47, 0xed, 0xc9, 0x38, 0xc6, 0x91, 0x08,
- 0xf3, 0x85, 0x9b, 0x69, 0x16, 0x78, 0x0d, 0xb7, 0x74, 0x51, 0xaa, 0x5b,
- 0x4d, 0x74, 0xe4, 0x29, 0x2e, 0x9e, 0x8e, 0xf7, 0xe5, 0x42, 0x83, 0xb0,
- 0x65, 0xb0, 0xce, 0xc6, 0xb2, 0x8f, 0x5b, 0xb0
-};
-
-static int test_ref_data(void)
-{
- FF_DH *dh;
- int ret = AVERROR(ENOMEM);
- uint8_t pubkey_test[128];
- uint8_t sharedkey_test[128];
-
- dh = ff_dh_init(1024);
- if (!dh)
- goto fail;
- bn_hex2bn(dh->priv_key, private_key, ret);
- if (!ret)
- goto fail;
- bn_hex2bn(dh->pub_key, public_key, ret);
- if (!ret)
- goto fail;
- if ((ret = ff_dh_write_public_key(dh, pubkey_test, sizeof(pubkey_test))) < 0)
- goto fail;
- if (memcmp(pubkey_test, public_key_bin, sizeof(pubkey_test))) {
- printf("Mismatched generated public key\n");
- ret = AVERROR_INVALIDDATA;
- goto fail;
- } else {
- printf("Generated public key ok\n");
- }
- if ((ret = ff_dh_compute_shared_secret_key(dh, peer_public_key, sizeof(peer_public_key),
- sharedkey_test, sizeof(sharedkey_test))) < 0)
- goto fail;
- if (memcmp(shared_secret, sharedkey_test, sizeof(sharedkey_test))) {
- printf("Mismatched generated shared key\n");
- ret = AVERROR_INVALIDDATA;
- } else {
- printf("Generated shared key ok\n");
- }
-fail:
- ff_dh_free(dh);
- return ret;
-}
-
-int main(void)
-{
- if (test_random_shared_secret() < 0)
- return 1;
- if (test_ref_data() < 0)
- return 1;
- return 0;
-}
-#endif
diff --git a/libavformat/srtp-test.c b/libavformat/srtp-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..1198f592bcb4278837ed50a11b6a18dc1336bfea
--- /dev/null
+++ b/libavformat/srtp-test.c
@@ -0,0 +1,167 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "rtpdec.h"
+#include "srtp.h"
+
+static const char *aes128_80_key = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn";
+
+static const uint8_t rtp_aes128_80[] = {
+ // RTP header
+ 0x80, 0xe0, 0x12, 0x34, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78,
+ // encrypted payload
+ 0x62, 0x69, 0x76, 0xca, 0xc5,
+ // HMAC
+ 0xa1, 0xac, 0x1b, 0xb4, 0xa0, 0x1c, 0xd5, 0x49, 0x28, 0x99,
+};
+
+static const uint8_t rtcp_aes128_80[] = {
+ // RTCP header
+ 0x81, 0xc9, 0x00, 0x07, 0x12, 0x34, 0x56, 0x78,
+ // encrypted payload
+ 0x8a, 0xac, 0xdc, 0xa5, 0x4c, 0xf6, 0x78, 0xa6, 0x62, 0x8f, 0x24, 0xda,
+ 0x6c, 0x09, 0x3f, 0xa9, 0x28, 0x7a, 0xb5, 0x7f, 0x1f, 0x0f, 0xc9, 0x35,
+ // RTCP index
+ 0x80, 0x00, 0x00, 0x03,
+ // HMAC
+ 0xe9, 0x3b, 0xc0, 0x5c, 0x0c, 0x06, 0x9f, 0xab, 0xc0, 0xde,
+};
+
+static const char *aes128_32_key = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn";
+
+static const uint8_t rtp_aes128_32[] = {
+ // RTP header
+ 0x80, 0xe0, 0x12, 0x34, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78,
+ // encrypted payload
+ 0x62, 0x69, 0x76, 0xca, 0xc5,
+ // HMAC
+ 0xa1, 0xac, 0x1b, 0xb4,
+};
+
+static const uint8_t rtcp_aes128_32[] = {
+ // RTCP header
+ 0x81, 0xc9, 0x00, 0x07, 0x12, 0x34, 0x56, 0x78,
+ // encrypted payload
+ 0x35, 0xe9, 0xb5, 0xff, 0x0d, 0xd1, 0xde, 0x70, 0x74, 0x10, 0xaa, 0x1b,
+ 0xb2, 0x8d, 0xf0, 0x20, 0x02, 0x99, 0x6b, 0x1b, 0x0b, 0xd0, 0x47, 0x34,
+ // RTCP index
+ 0x80, 0x00, 0x00, 0x04,
+ // HMAC
+ 0x5b, 0xd2, 0xa9, 0x9d,
+};
+
+static const char *aes128_80_32_key = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn";
+
+static const uint8_t rtp_aes128_80_32[] = {
+ // RTP header
+ 0x80, 0xe0, 0x12, 0x34, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78,
+ // encrypted payload
+ 0x62, 0x69, 0x76, 0xca, 0xc5,
+ // HMAC
+ 0xa1, 0xac, 0x1b, 0xb4,
+};
+
+static const uint8_t rtcp_aes128_80_32[] = {
+ // RTCP header
+ 0x81, 0xc9, 0x00, 0x07, 0x12, 0x34, 0x56, 0x78,
+ // encrypted payload
+ 0xd6, 0xae, 0xc1, 0x58, 0x63, 0x70, 0xc9, 0x88, 0x66, 0x26, 0x1c, 0x53,
+ 0xff, 0x5d, 0x5d, 0x2b, 0x0f, 0x8c, 0x72, 0x3e, 0xc9, 0x1d, 0x43, 0xf9,
+ // RTCP index
+ 0x80, 0x00, 0x00, 0x05,
+ // HMAC
+ 0x09, 0x16, 0xb4, 0x27, 0x9a, 0xe9, 0x92, 0x26, 0x4e, 0x10,
+};
+
+static void print_data(const uint8_t *buf, int len)
+{
+ int i;
+ for (i = 0; i < len; i++)
+ printf("%02x", buf[i]);
+ printf("\n");
+}
+
+static int test_decrypt(struct SRTPContext *srtp, const uint8_t *in, int len,
+ uint8_t *out)
+{
+ memcpy(out, in, len);
+ if (!ff_srtp_decrypt(srtp, out, &len)) {
+ print_data(out, len);
+ return len;
+ } else
+ return -1;
+}
+
+static void test_encrypt(const uint8_t *data, int in_len, const char *suite,
+ const char *key)
+{
+ struct SRTPContext enc = { 0 }, dec = { 0 };
+ int len;
+ char buf[RTP_MAX_PACKET_LENGTH];
+ ff_srtp_set_crypto(&enc, suite, key);
+ ff_srtp_set_crypto(&dec, suite, key);
+ len = ff_srtp_encrypt(&enc, data, in_len, buf, sizeof(buf));
+ if (!ff_srtp_decrypt(&dec, buf, &len)) {
+ if (len == in_len && !memcmp(buf, data, len))
+ printf("Decrypted content matches input\n");
+ else
+ printf("Decrypted content doesn't match input\n");
+ } else {
+ printf("Decryption failed\n");
+ }
+ ff_srtp_free(&enc);
+ ff_srtp_free(&dec);
+}
+
+int main(void)
+{
+ static const char *aes128_80_suite = "AES_CM_128_HMAC_SHA1_80";
+ static const char *aes128_32_suite = "AES_CM_128_HMAC_SHA1_32";
+ static const char *aes128_80_32_suite = "SRTP_AES128_CM_HMAC_SHA1_32";
+ static const char *test_key = "abcdefghijklmnopqrstuvwxyz1234567890ABCD";
+ uint8_t buf[RTP_MAX_PACKET_LENGTH];
+ struct SRTPContext srtp = { 0 };
+ int len;
+ ff_srtp_set_crypto(&srtp, aes128_80_suite, aes128_80_key);
+ len = test_decrypt(&srtp, rtp_aes128_80, sizeof(rtp_aes128_80), buf);
+ test_encrypt(buf, len, aes128_80_suite, test_key);
+ test_encrypt(buf, len, aes128_32_suite, test_key);
+ test_encrypt(buf, len, aes128_80_32_suite, test_key);
+ test_decrypt(&srtp, rtcp_aes128_80, sizeof(rtcp_aes128_80), buf);
+ test_encrypt(buf, len, aes128_80_suite, test_key);
+ test_encrypt(buf, len, aes128_32_suite, test_key);
+ test_encrypt(buf, len, aes128_80_32_suite, test_key);
+ ff_srtp_free(&srtp);
+
+ memset(&srtp, 0, sizeof(srtp)); // Clear the context
+ ff_srtp_set_crypto(&srtp, aes128_32_suite, aes128_32_key);
+ test_decrypt(&srtp, rtp_aes128_32, sizeof(rtp_aes128_32), buf);
+ test_decrypt(&srtp, rtcp_aes128_32, sizeof(rtcp_aes128_32), buf);
+ ff_srtp_free(&srtp);
+
+ memset(&srtp, 0, sizeof(srtp)); // Clear the context
+ ff_srtp_set_crypto(&srtp, aes128_80_32_suite, aes128_80_32_key);
+ test_decrypt(&srtp, rtp_aes128_80_32, sizeof(rtp_aes128_80_32), buf);
+ test_decrypt(&srtp, rtcp_aes128_80_32, sizeof(rtcp_aes128_80_32), buf);
+ ff_srtp_free(&srtp);
+ return 0;
+}
diff --git a/libavformat/srtp.c b/libavformat/srtp.c
index b6e821115cd84b4de9fa2d5a1496a15342e1a464..f8b686c5aaa71caf3b83388c8f7d41ca38a6e9af 100644
--- a/libavformat/srtp.c
+++ b/libavformat/srtp.c
@@ -323,150 +323,3 @@ int ff_srtp_encrypt(struct SRTPContext *s, const uint8_t *in, int len,
len += hmac_size;
return buf + len - out;
}
-
-#ifdef TEST
-#include <stdio.h>
-
-static const char *aes128_80_key = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn";
-
-static const uint8_t rtp_aes128_80[] = {
- // RTP header
- 0x80, 0xe0, 0x12, 0x34, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78,
- // encrypted payload
- 0x62, 0x69, 0x76, 0xca, 0xc5,
- // HMAC
- 0xa1, 0xac, 0x1b, 0xb4, 0xa0, 0x1c, 0xd5, 0x49, 0x28, 0x99,
-};
-
-static const uint8_t rtcp_aes128_80[] = {
- // RTCP header
- 0x81, 0xc9, 0x00, 0x07, 0x12, 0x34, 0x56, 0x78,
- // encrypted payload
- 0x8a, 0xac, 0xdc, 0xa5, 0x4c, 0xf6, 0x78, 0xa6, 0x62, 0x8f, 0x24, 0xda,
- 0x6c, 0x09, 0x3f, 0xa9, 0x28, 0x7a, 0xb5, 0x7f, 0x1f, 0x0f, 0xc9, 0x35,
- // RTCP index
- 0x80, 0x00, 0x00, 0x03,
- // HMAC
- 0xe9, 0x3b, 0xc0, 0x5c, 0x0c, 0x06, 0x9f, 0xab, 0xc0, 0xde,
-};
-
-static const char *aes128_32_key = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn";
-
-static const uint8_t rtp_aes128_32[] = {
- // RTP header
- 0x80, 0xe0, 0x12, 0x34, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78,
- // encrypted payload
- 0x62, 0x69, 0x76, 0xca, 0xc5,
- // HMAC
- 0xa1, 0xac, 0x1b, 0xb4,
-};
-
-static const uint8_t rtcp_aes128_32[] = {
- // RTCP header
- 0x81, 0xc9, 0x00, 0x07, 0x12, 0x34, 0x56, 0x78,
- // encrypted payload
- 0x35, 0xe9, 0xb5, 0xff, 0x0d, 0xd1, 0xde, 0x70, 0x74, 0x10, 0xaa, 0x1b,
- 0xb2, 0x8d, 0xf0, 0x20, 0x02, 0x99, 0x6b, 0x1b, 0x0b, 0xd0, 0x47, 0x34,
- // RTCP index
- 0x80, 0x00, 0x00, 0x04,
- // HMAC
- 0x5b, 0xd2, 0xa9, 0x9d,
-};
-
-static const char *aes128_80_32_key = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn";
-
-static const uint8_t rtp_aes128_80_32[] = {
- // RTP header
- 0x80, 0xe0, 0x12, 0x34, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78,
- // encrypted payload
- 0x62, 0x69, 0x76, 0xca, 0xc5,
- // HMAC
- 0xa1, 0xac, 0x1b, 0xb4,
-};
-
-static const uint8_t rtcp_aes128_80_32[] = {
- // RTCP header
- 0x81, 0xc9, 0x00, 0x07, 0x12, 0x34, 0x56, 0x78,
- // encrypted payload
- 0xd6, 0xae, 0xc1, 0x58, 0x63, 0x70, 0xc9, 0x88, 0x66, 0x26, 0x1c, 0x53,
- 0xff, 0x5d, 0x5d, 0x2b, 0x0f, 0x8c, 0x72, 0x3e, 0xc9, 0x1d, 0x43, 0xf9,
- // RTCP index
- 0x80, 0x00, 0x00, 0x05,
- // HMAC
- 0x09, 0x16, 0xb4, 0x27, 0x9a, 0xe9, 0x92, 0x26, 0x4e, 0x10,
-};
-
-static void print_data(const uint8_t *buf, int len)
-{
- int i;
- for (i = 0; i < len; i++)
- printf("%02x", buf[i]);
- printf("\n");
-}
-
-static int test_decrypt(struct SRTPContext *srtp, const uint8_t *in, int len,
- uint8_t *out)
-{
- memcpy(out, in, len);
- if (!ff_srtp_decrypt(srtp, out, &len)) {
- print_data(out, len);
- return len;
- } else
- return -1;
-}
-
-static void test_encrypt(const uint8_t *data, int in_len, const char *suite,
- const char *key)
-{
- struct SRTPContext enc = { 0 }, dec = { 0 };
- int len;
- char buf[RTP_MAX_PACKET_LENGTH];
- ff_srtp_set_crypto(&enc, suite, key);
- ff_srtp_set_crypto(&dec, suite, key);
- len = ff_srtp_encrypt(&enc, data, in_len, buf, sizeof(buf));
- if (!ff_srtp_decrypt(&dec, buf, &len)) {
- if (len == in_len && !memcmp(buf, data, len))
- printf("Decrypted content matches input\n");
- else
- printf("Decrypted content doesn't match input\n");
- } else {
- printf("Decryption failed\n");
- }
- ff_srtp_free(&enc);
- ff_srtp_free(&dec);
-}
-
-int main(void)
-{
- static const char *aes128_80_suite = "AES_CM_128_HMAC_SHA1_80";
- static const char *aes128_32_suite = "AES_CM_128_HMAC_SHA1_32";
- static const char *aes128_80_32_suite = "SRTP_AES128_CM_HMAC_SHA1_32";
- static const char *test_key = "abcdefghijklmnopqrstuvwxyz1234567890ABCD";
- uint8_t buf[RTP_MAX_PACKET_LENGTH];
- struct SRTPContext srtp = { 0 };
- int len;
- ff_srtp_set_crypto(&srtp, aes128_80_suite, aes128_80_key);
- len = test_decrypt(&srtp, rtp_aes128_80, sizeof(rtp_aes128_80), buf);
- test_encrypt(buf, len, aes128_80_suite, test_key);
- test_encrypt(buf, len, aes128_32_suite, test_key);
- test_encrypt(buf, len, aes128_80_32_suite, test_key);
- test_decrypt(&srtp, rtcp_aes128_80, sizeof(rtcp_aes128_80), buf);
- test_encrypt(buf, len, aes128_80_suite, test_key);
- test_encrypt(buf, len, aes128_32_suite, test_key);
- test_encrypt(buf, len, aes128_80_32_suite, test_key);
- ff_srtp_free(&srtp);
-
- memset(&srtp, 0, sizeof(srtp)); // Clear the context
- ff_srtp_set_crypto(&srtp, aes128_32_suite, aes128_32_key);
- test_decrypt(&srtp, rtp_aes128_32, sizeof(rtp_aes128_32), buf);
- test_decrypt(&srtp, rtcp_aes128_32, sizeof(rtcp_aes128_32), buf);
- ff_srtp_free(&srtp);
-
- memset(&srtp, 0, sizeof(srtp)); // Clear the context
- ff_srtp_set_crypto(&srtp, aes128_80_32_suite, aes128_80_32_key);
- test_decrypt(&srtp, rtp_aes128_80_32, sizeof(rtp_aes128_80_32), buf);
- test_decrypt(&srtp, rtcp_aes128_80_32, sizeof(rtcp_aes128_80_32), buf);
- ff_srtp_free(&srtp);
- return 0;
-}
-#endif /* TEST */
diff --git a/libavutil/adler32-test.c b/libavutil/adler32-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..f93cf9d4494f8864b0ca3aea850a67c8cbde8ceb
--- /dev/null
+++ b/libavutil/adler32-test.c
@@ -0,0 +1,53 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+// LCOV_EXCL_START
+#include <string.h>
+
+#include "log.h"
+#include "timer.h"
+#include "adler32.h"
+
+#define LEN 7001
+
+static volatile int checksum;
+
+int main(int argc, char **argv)
+{
+ int i;
+ uint8_t data[LEN];
+
+ av_log_set_level(AV_LOG_DEBUG);
+
+ for (i = 0; i < LEN; i++)
+ data[i] = ((i * i) >> 3) + 123 * i;
+
+ if (argc > 1 && !strcmp(argv[1], "-t")) {
+ for (i = 0; i < 1000; i++) {
+ START_TIMER;
+ checksum = av_adler32_update(1, data, LEN);
+ STOP_TIMER("adler");
+ }
+ } else {
+ checksum = av_adler32_update(1, data, LEN);
+ }
+
+ av_log(NULL, AV_LOG_DEBUG, "%X (expected 50E6E508)\n", checksum);
+ return checksum == 0x50e6e508 ? 0 : 1;
+}
+// LCOV_EXCL_STOP
diff --git a/libavutil/adler32.c b/libavutil/adler32.c
index 64c8767ca09c9c0291c453e0d80dbe8bfd3c15af..c87d5e261c4803b86d888dc180d7c3c1d34d526c 100644
--- a/libavutil/adler32.c
+++ b/libavutil/adler32.c
@@ -95,38 +95,3 @@ unsigned long av_adler32_update(unsigned long adler, const uint8_t * buf,
}
return (s2 << 16) | s1;
}
-
-#ifdef TEST
-// LCOV_EXCL_START
-#include <string.h>
-#include "log.h"
-#include "timer.h"
-#define LEN 7001
-
-static volatile int checksum;
-
-int main(int argc, char **argv)
-{
- int i;
- uint8_t data[LEN];
-
- av_log_set_level(AV_LOG_DEBUG);
-
- for (i = 0; i < LEN; i++)
- data[i] = ((i * i) >> 3) + 123 * i;
-
- if (argc > 1 && !strcmp(argv[1], "-t")) {
- for (i = 0; i < 1000; i++) {
- START_TIMER;
- checksum = av_adler32_update(1, data, LEN);
- STOP_TIMER("adler");
- }
- } else {
- checksum = av_adler32_update(1, data, LEN);
- }
-
- av_log(NULL, AV_LOG_DEBUG, "%X (expected 50E6E508)\n", checksum);
- return checksum == 0x50e6e508 ? 0 : 1;
-}
-// LCOV_EXCL_STOP
-#endif
diff --git a/libavutil/aes-test.c b/libavutil/aes-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..a71b7fee28c2205faf6ab59987665e02f4004bd2
--- /dev/null
+++ b/libavutil/aes-test.c
@@ -0,0 +1,102 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "aes.c"
+
+// LCOV_EXCL_START
+#include <string.h>
+
+#include "lfg.h"
+#include "log.h"
+
+int main(int argc, char **argv)
+{
+ int i, j;
+ AVAES b;
+ uint8_t rkey[2][16] = {
+ { 0 },
+ { 0x10, 0xa5, 0x88, 0x69, 0xd7, 0x4b, 0xe5, 0xa3,
+ 0x74, 0xcf, 0x86, 0x7c, 0xfb, 0x47, 0x38, 0x59 }
+ };
+ uint8_t pt[32], rpt[2][16] = {
+ { 0x6a, 0x84, 0x86, 0x7c, 0xd7, 0x7e, 0x12, 0xad,
+ 0x07, 0xea, 0x1b, 0xe8, 0x95, 0xc5, 0x3f, 0xa3 },
+ { 0 }
+ };
+ uint8_t rct[2][16] = {
+ { 0x73, 0x22, 0x81, 0xc0, 0xa0, 0xaa, 0xb8, 0xf7,
+ 0xa5, 0x4a, 0x0c, 0x67, 0xa0, 0xc4, 0x5e, 0xcf },
+ { 0x6d, 0x25, 0x1e, 0x69, 0x44, 0xb0, 0x51, 0xe0,
+ 0x4e, 0xaa, 0x6f, 0xb4, 0xdb, 0xf7, 0x84, 0x65 }
+ };
+ uint8_t temp[32];
+ uint8_t iv[2][16];
+ int err = 0;
+
+ av_log_set_level(AV_LOG_DEBUG);
+
+ for (i = 0; i < 2; i++) {
+ av_aes_init(&b, rkey[i], 128, 1);
+ av_aes_crypt(&b, temp, rct[i], 1, NULL, 1);
+ for (j = 0; j < 16; j++) {
+ if (rpt[i][j] != temp[j]) {
+ av_log(NULL, AV_LOG_ERROR, "%d %02X %02X\n",
+ j, rpt[i][j], temp[j]);
+ err = 1;
+ }
+ }
+ }
+
+ if (argc > 1 && !strcmp(argv[1], "-t")) {
+ AVAES ae, ad;
+ AVLFG prng;
+
+ av_aes_init(&ae, (const uint8_t*)"PI=3.141592654..", 128, 0);
+ av_aes_init(&ad, (const uint8_t*)"PI=3.141592654..", 128, 1);
+ av_lfg_init(&prng, 1);
+
+ for (i = 0; i < 10000; i++) {
+ for (j = 0; j < 32; j++)
+ pt[j] = av_lfg_get(&prng);
+ for (j = 0; j < 16; j++)
+ iv[0][j] = iv[1][j] = av_lfg_get(&prng);
+ {
+ START_TIMER;
+ av_aes_crypt(&ae, temp, pt, 2, iv[0], 0);
+ if (!(i & (i - 1)))
+ av_log(NULL, AV_LOG_ERROR, "%02X %02X %02X %02X\n",
+ temp[0], temp[5], temp[10], temp[15]);
+ av_aes_crypt(&ad, temp, temp, 2, iv[1], 1);
+ av_aes_crypt(&ae, temp, pt, 2, NULL, 0);
+ if (!(i & (i - 1)))
+ av_log(NULL, AV_LOG_ERROR, "%02X %02X %02X %02X\n",
+ temp[0], temp[5], temp[10], temp[15]);
+ av_aes_crypt(&ad, temp, temp, 2, NULL, 1);
+ STOP_TIMER("aes");
+ }
+ for (j = 0; j < 16; j++) {
+ if (pt[j] != temp[j]) {
+ av_log(NULL, AV_LOG_ERROR, "%d %d %02X %02X\n",
+ i, j, pt[j], temp[j]);
+ }
+ }
+ }
+ }
+ return err;
+}
+// LCOV_EXCL_STOP
diff --git a/libavutil/aes.c b/libavutil/aes.c
index 172086e5396828a098eec77d1071216ba86915fd..397ea773898b14d0aee3f09d6b0318b1b9396ddd 100644
--- a/libavutil/aes.c
+++ b/libavutil/aes.c
@@ -266,87 +266,3 @@ int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt)
return 0;
}
-#ifdef TEST
-// LCOV_EXCL_START
-#include <string.h>
-
-#include "lfg.h"
-#include "log.h"
-
-int main(int argc, char **argv)
-{
- int i, j;
- AVAES b;
- uint8_t rkey[2][16] = {
- { 0 },
- { 0x10, 0xa5, 0x88, 0x69, 0xd7, 0x4b, 0xe5, 0xa3,
- 0x74, 0xcf, 0x86, 0x7c, 0xfb, 0x47, 0x38, 0x59 }
- };
- uint8_t pt[32], rpt[2][16] = {
- { 0x6a, 0x84, 0x86, 0x7c, 0xd7, 0x7e, 0x12, 0xad,
- 0x07, 0xea, 0x1b, 0xe8, 0x95, 0xc5, 0x3f, 0xa3 },
- { 0 }
- };
- uint8_t rct[2][16] = {
- { 0x73, 0x22, 0x81, 0xc0, 0xa0, 0xaa, 0xb8, 0xf7,
- 0xa5, 0x4a, 0x0c, 0x67, 0xa0, 0xc4, 0x5e, 0xcf },
- { 0x6d, 0x25, 0x1e, 0x69, 0x44, 0xb0, 0x51, 0xe0,
- 0x4e, 0xaa, 0x6f, 0xb4, 0xdb, 0xf7, 0x84, 0x65 }
- };
- uint8_t temp[32];
- uint8_t iv[2][16];
- int err = 0;
-
- av_log_set_level(AV_LOG_DEBUG);
-
- for (i = 0; i < 2; i++) {
- av_aes_init(&b, rkey[i], 128, 1);
- av_aes_crypt(&b, temp, rct[i], 1, NULL, 1);
- for (j = 0; j < 16; j++) {
- if (rpt[i][j] != temp[j]) {
- av_log(NULL, AV_LOG_ERROR, "%d %02X %02X\n",
- j, rpt[i][j], temp[j]);
- err = 1;
- }
- }
- }
-
- if (argc > 1 && !strcmp(argv[1], "-t")) {
- AVAES ae, ad;
- AVLFG prng;
-
- av_aes_init(&ae, (const uint8_t*)"PI=3.141592654..", 128, 0);
- av_aes_init(&ad, (const uint8_t*)"PI=3.141592654..", 128, 1);
- av_lfg_init(&prng, 1);
-
- for (i = 0; i < 10000; i++) {
- for (j = 0; j < 32; j++)
- pt[j] = av_lfg_get(&prng);
- for (j = 0; j < 16; j++)
- iv[0][j] = iv[1][j] = av_lfg_get(&prng);
- {
- START_TIMER;
- av_aes_crypt(&ae, temp, pt, 2, iv[0], 0);
- if (!(i & (i - 1)))
- av_log(NULL, AV_LOG_ERROR, "%02X %02X %02X %02X\n",
- temp[0], temp[5], temp[10], temp[15]);
- av_aes_crypt(&ad, temp, temp, 2, iv[1], 1);
- av_aes_crypt(&ae, temp, pt, 2, NULL, 0);
- if (!(i & (i - 1)))
- av_log(NULL, AV_LOG_ERROR, "%02X %02X %02X %02X\n",
- temp[0], temp[5], temp[10], temp[15]);
- av_aes_crypt(&ad, temp, temp, 2, NULL, 1);
- STOP_TIMER("aes");
- }
- for (j = 0; j < 16; j++) {
- if (pt[j] != temp[j]) {
- av_log(NULL, AV_LOG_ERROR, "%d %d %02X %02X\n",
- i, j, pt[j], temp[j]);
- }
- }
- }
- }
- return err;
-}
-// LCOV_EXCL_STOP
-#endif
diff --git a/libavutil/atomic-test.c b/libavutil/atomic-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..397d8c92850c95c555b3b4cb94f2f9be9c0414f6
--- /dev/null
+++ b/libavutil/atomic-test.c
@@ -0,0 +1,34 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "atomic.h"
+#include "avassert.h"
+
+int main(void)
+{
+ volatile int val = 1;
+ int res;
+
+ res = avpriv_atomic_int_add_and_fetch(&val, 1);
+ av_assert0(res == 2);
+ avpriv_atomic_int_set(&val, 3);
+ res = avpriv_atomic_int_get(&val);
+ av_assert0(res == 3);
+
+ return 0;
+}
diff --git a/libavutil/atomic.c b/libavutil/atomic.c
index b13725d14fb548d4aba9008520cd8eaaee9651a8..64cff2576fd3032822e499ad2c8036935289714d 100644
--- a/libavutil/atomic.c
+++ b/libavutil/atomic.c
@@ -107,21 +107,3 @@ void *avpriv_atomic_ptr_cas(void * volatile *ptr, void *oldval, void *newval)
#endif /* HAVE_PTHREADS */
#endif /* !HAVE_ATOMICS_NATIVE */
-
-#ifdef TEST
-#include "avassert.h"
-
-int main(void)
-{
- volatile int val = 1;
- int res;
-
- res = avpriv_atomic_int_add_and_fetch(&val, 1);
- av_assert0(res == 2);
- avpriv_atomic_int_set(&val, 3);
- res = avpriv_atomic_int_get(&val);
- av_assert0(res == 3);
-
- return 0;
-}
-#endif
diff --git a/libavutil/avstring-test.c b/libavutil/avstring-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..3e29661e9673a90e7a2d086450d001a35ad04aed
--- /dev/null
+++ b/libavutil/avstring-test.c
@@ -0,0 +1,83 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdio.h>
+
+#include "common.h"
+#include "mem.h"
+#include "avstring.h"
+
+int main(void)
+{
+ int i;
+ char *fullpath;
+ static const char * const strings[] = {
+ "''",
+ "",
+ ":",
+ "\\",
+ "'",
+ " '' :",
+ " '' '' :",
+ "foo '' :",
+ "'foo'",
+ "foo ",
+ " ' foo ' ",
+ "foo\\",
+ "foo': blah:blah",
+ "foo\\: blah:blah",
+ "foo\'",
+ "'foo : ' :blahblah",
+ "\\ :blah",
+ " foo",
+ " foo ",
+ " foo \\ ",
+ "foo ':blah",
+ " foo bar : blahblah",
+ "\\f\\o\\o",
+ "'foo : \\ \\ ' : blahblah",
+ "'\\fo\\o:': blahblah",
+ "\\'fo\\o\\:': foo ' :blahblah"
+ };
+
+ printf("Testing av_get_token()\n");
+ for (i = 0; i < FF_ARRAY_ELEMS(strings); i++) {
+ const char *p = strings[i];
+ char *q;
+ printf("|%s|", p);
+ q = av_get_token(&p, ":");
+ printf(" -> |%s|", q);
+ printf(" + |%s|\n", p);
+ av_free(q);
+ }
+
+ printf("Testing av_append_path_component()\n");
+ #define TEST_APPEND_PATH_COMPONENT(path, component, expected) \
+ fullpath = av_append_path_component((path), (component)); \
+ printf("%s = %s\n", fullpath ? fullpath : "(null)", expected); \
+ av_free(fullpath);
+ TEST_APPEND_PATH_COMPONENT(NULL, NULL, "(null)")
+ TEST_APPEND_PATH_COMPONENT("path", NULL, "path");
+ TEST_APPEND_PATH_COMPONENT(NULL, "comp", "comp");
+ TEST_APPEND_PATH_COMPONENT("path", "comp", "path/comp");
+ TEST_APPEND_PATH_COMPONENT("path/", "comp", "path/comp");
+ TEST_APPEND_PATH_COMPONENT("path", "/comp", "path/comp");
+ TEST_APPEND_PATH_COMPONENT("path/", "/comp", "path/comp");
+ TEST_APPEND_PATH_COMPONENT("path/path2/", "/comp/comp2", "path/path2/comp/comp2");
+ return 0;
+}
diff --git a/libavutil/avstring.c b/libavutil/avstring.c
index b4dace08ccae839eea5be4117da0cfe76a08cd32..1787a1ef54f68dd02615d7492aebaf8d9f7394e4 100644
--- a/libavutil/avstring.c
+++ b/libavutil/avstring.c
@@ -435,67 +435,3 @@ int av_match_list(const char *name, const char *list, char separator)
return 0;
}
-
-#ifdef TEST
-
-int main(void)
-{
- int i;
- char *fullpath;
- static const char * const strings[] = {
- "''",
- "",
- ":",
- "\\",
- "'",
- " '' :",
- " '' '' :",
- "foo '' :",
- "'foo'",
- "foo ",
- " ' foo ' ",
- "foo\\",
- "foo': blah:blah",
- "foo\\: blah:blah",
- "foo\'",
- "'foo : ' :blahblah",
- "\\ :blah",
- " foo",
- " foo ",
- " foo \\ ",
- "foo ':blah",
- " foo bar : blahblah",
- "\\f\\o\\o",
- "'foo : \\ \\ ' : blahblah",
- "'\\fo\\o:': blahblah",
- "\\'fo\\o\\:': foo ' :blahblah"
- };
-
- printf("Testing av_get_token()\n");
- for (i = 0; i < FF_ARRAY_ELEMS(strings); i++) {
- const char *p = strings[i];
- char *q;
- printf("|%s|", p);
- q = av_get_token(&p, ":");
- printf(" -> |%s|", q);
- printf(" + |%s|\n", p);
- av_free(q);
- }
-
- printf("Testing av_append_path_component()\n");
- #define TEST_APPEND_PATH_COMPONENT(path, component, expected) \
- fullpath = av_append_path_component((path), (component)); \
- printf("%s = %s\n", fullpath ? fullpath : "(null)", expected); \
- av_free(fullpath);
- TEST_APPEND_PATH_COMPONENT(NULL, NULL, "(null)")
- TEST_APPEND_PATH_COMPONENT("path", NULL, "path");
- TEST_APPEND_PATH_COMPONENT(NULL, "comp", "comp");
- TEST_APPEND_PATH_COMPONENT("path", "comp", "path/comp");
- TEST_APPEND_PATH_COMPONENT("path/", "comp", "path/comp");
- TEST_APPEND_PATH_COMPONENT("path", "/comp", "path/comp");
- TEST_APPEND_PATH_COMPONENT("path/", "/comp", "path/comp");
- TEST_APPEND_PATH_COMPONENT("path/path2/", "/comp/comp2", "path/path2/comp/comp2");
- return 0;
-}
-
-#endif /* TEST */
diff --git a/libavutil/base64-test.c b/libavutil/base64-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..19ecd2bee18ca4e1a376bae99b145708c8ce5fff
--- /dev/null
+++ b/libavutil/base64-test.c
@@ -0,0 +1,128 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+// LCOV_EXCL_START
+#include <stdint.h>
+#include <stdio.h>
+
+#include "common.h"
+#include "base64.h"
+#include "timer.h"
+
+#define MAX_DATA_SIZE 1024
+#define MAX_ENCODED_SIZE 2048
+
+static int test_encode_decode(const uint8_t *data, unsigned int data_size,
+ const char *encoded_ref)
+{
+ char encoded[MAX_ENCODED_SIZE];
+ uint8_t data2[MAX_DATA_SIZE];
+ int data2_size, max_data2_size = MAX_DATA_SIZE;
+
+ if (!av_base64_encode(encoded, MAX_ENCODED_SIZE, data, data_size)) {
+ printf("Failed: cannot encode the input data\n");
+ return 1;
+ }
+ if (encoded_ref && strcmp(encoded, encoded_ref)) {
+ printf("Failed: encoded string differs from reference\n"
+ "Encoded:\n%s\nReference:\n%s\n", encoded, encoded_ref);
+ return 1;
+ }
+
+ if ((data2_size = av_base64_decode(data2, encoded, max_data2_size)) != data_size) {
+ printf("Failed: cannot decode the encoded string\n"
+ "Encoded:\n%s\n", encoded);
+ return 1;
+ }
+ if ((data2_size = av_base64_decode(data2, encoded, data_size)) != data_size) {
+ printf("Failed: cannot decode with minimal buffer\n"
+ "Encoded:\n%s\n", encoded);
+ return 1;
+ }
+ if (memcmp(data2, data, data_size)) {
+ printf("Failed: encoded/decoded data differs from original data\n");
+ return 1;
+ }
+ if (av_base64_decode(NULL, encoded, 0) != 0) {
+ printf("Failed: decode to NULL buffer\n");
+ return 1;
+ }
+ if (strlen(encoded)) {
+ char *end = strchr(encoded, '=');
+ if (!end)
+ end = encoded + strlen(encoded) - 1;
+ *end = '%';
+ if (av_base64_decode(NULL, encoded, 0) >= 0) {
+ printf("Failed: error detection\n");
+ return 1;
+ }
+ }
+
+ printf("Passed!\n");
+ return 0;
+}
+
+int main(int argc, char ** argv)
+{
+ int i, error_count = 0;
+ struct test {
+ const uint8_t *data;
+ const char *encoded_ref;
+ } tests[] = {
+ { "", ""},
+ { "1", "MQ=="},
+ { "22", "MjI="},
+ { "333", "MzMz"},
+ { "4444", "NDQ0NA=="},
+ { "55555", "NTU1NTU="},
+ { "666666", "NjY2NjY2"},
+ { "abc:def", "YWJjOmRlZg=="},
+ };
+ char in[1024], out[2048];
+
+ printf("Encoding/decoding tests\n");
+ for (i = 0; i < FF_ARRAY_ELEMS(tests); i++)
+ error_count += test_encode_decode(tests[i].data, strlen(tests[i].data), tests[i].encoded_ref);
+
+ if (argc>1 && !strcmp(argv[1], "-t")) {
+ memset(in, 123, sizeof(in));
+ for(i=0; i<10000; i++){
+ START_TIMER
+ av_base64_encode(out, sizeof(out), in, sizeof(in));
+ STOP_TIMER("encode")
+ }
+ for(i=0; i<10000; i++){
+ START_TIMER
+ av_base64_decode(in, out, sizeof(in));
+ STOP_TIMER("decode")
+ }
+
+ for(i=0; i<10000; i++){
+ START_TIMER
+ av_base64_decode(NULL, out, 0);
+ STOP_TIMER("syntax check")
+ }
+ }
+
+ if (error_count)
+ printf("Error Count: %d.\n", error_count);
+
+ return !!error_count;
+}
+
+// LCOV_EXCL_STOP
diff --git a/libavutil/base64.c b/libavutil/base64.c
index 03ebce8b8034cd5e1da93e329ce3bc3e1c44e47f..25ae8c411ce180518afc3699cd6dff785e8ea57f 100644
--- a/libavutil/base64.c
+++ b/libavutil/base64.c
@@ -172,110 +172,3 @@ char *av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size)
return ret;
}
-
-#ifdef TEST
-// LCOV_EXCL_START
-
-#define MAX_DATA_SIZE 1024
-#define MAX_ENCODED_SIZE 2048
-
-static int test_encode_decode(const uint8_t *data, unsigned int data_size,
- const char *encoded_ref)
-{
- char encoded[MAX_ENCODED_SIZE];
- uint8_t data2[MAX_DATA_SIZE];
- int data2_size, max_data2_size = MAX_DATA_SIZE;
-
- if (!av_base64_encode(encoded, MAX_ENCODED_SIZE, data, data_size)) {
- printf("Failed: cannot encode the input data\n");
- return 1;
- }
- if (encoded_ref && strcmp(encoded, encoded_ref)) {
- printf("Failed: encoded string differs from reference\n"
- "Encoded:\n%s\nReference:\n%s\n", encoded, encoded_ref);
- return 1;
- }
-
- if ((data2_size = av_base64_decode(data2, encoded, max_data2_size)) != data_size) {
- printf("Failed: cannot decode the encoded string\n"
- "Encoded:\n%s\n", encoded);
- return 1;
- }
- if ((data2_size = av_base64_decode(data2, encoded, data_size)) != data_size) {
- printf("Failed: cannot decode with minimal buffer\n"
- "Encoded:\n%s\n", encoded);
- return 1;
- }
- if (memcmp(data2, data, data_size)) {
- printf("Failed: encoded/decoded data differs from original data\n");
- return 1;
- }
- if (av_base64_decode(NULL, encoded, 0) != 0) {
- printf("Failed: decode to NULL buffer\n");
- return 1;
- }
- if (strlen(encoded)) {
- char *end = strchr(encoded, '=');
- if (!end)
- end = encoded + strlen(encoded) - 1;
- *end = '%';
- if (av_base64_decode(NULL, encoded, 0) >= 0) {
- printf("Failed: error detection\n");
- return 1;
- }
- }
-
- printf("Passed!\n");
- return 0;
-}
-
-int main(int argc, char ** argv)
-{
- int i, error_count = 0;
- struct test {
- const uint8_t *data;
- const char *encoded_ref;
- } tests[] = {
- { "", ""},
- { "1", "MQ=="},
- { "22", "MjI="},
- { "333", "MzMz"},
- { "4444", "NDQ0NA=="},
- { "55555", "NTU1NTU="},
- { "666666", "NjY2NjY2"},
- { "abc:def", "YWJjOmRlZg=="},
- };
- char in[1024], out[2048];
-
- printf("Encoding/decoding tests\n");
- for (i = 0; i < FF_ARRAY_ELEMS(tests); i++)
- error_count += test_encode_decode(tests[i].data, strlen(tests[i].data), tests[i].encoded_ref);
-
- if (argc>1 && !strcmp(argv[1], "-t")) {
- memset(in, 123, sizeof(in));
- for(i=0; i<10000; i++){
- START_TIMER
- av_base64_encode(out, sizeof(out), in, sizeof(in));
- STOP_TIMER("encode")
- }
- for(i=0; i<10000; i++){
- START_TIMER
- av_base64_decode(in, out, sizeof(in));
- STOP_TIMER("decode")
- }
-
- for(i=0; i<10000; i++){
- START_TIMER
- av_base64_decode(NULL, out, 0);
- STOP_TIMER("syntax check")
- }
- }
-
- if (error_count)
- printf("Error Count: %d.\n", error_count);
-
- return !!error_count;
-}
-
-// LCOV_EXCL_STOP
-#endif
diff --git a/libavutil/blowfish-test.c b/libavutil/blowfish-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..3ad7cd76655b13758f0dfa5faea1b5e1af862c20
--- /dev/null
+++ b/libavutil/blowfish-test.c
@@ -0,0 +1,190 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "blowfish.h"
+
+#define NUM_VARIABLE_KEY_TESTS 34
+
+/* plaintext bytes -- left halves */
+static const uint32_t plaintext_l[NUM_VARIABLE_KEY_TESTS] = {
+ 0x00000000, 0xFFFFFFFF, 0x10000000, 0x11111111, 0x11111111,
+ 0x01234567, 0x00000000, 0x01234567, 0x01A1D6D0, 0x5CD54CA8,
+ 0x0248D438, 0x51454B58, 0x42FD4430, 0x059B5E08, 0x0756D8E0,
+ 0x762514B8, 0x3BDD1190, 0x26955F68, 0x164D5E40, 0x6B056E18,
+ 0x004BD6EF, 0x480D3900, 0x437540C8, 0x072D43A0, 0x02FE5577,
+ 0x1D9D5C50, 0x30553228, 0x01234567, 0x01234567, 0x01234567,
+ 0xFFFFFFFF, 0x00000000, 0x00000000, 0xFFFFFFFF
+};
+
+/* plaintext bytes -- right halves */
+static const uint32_t plaintext_r[NUM_VARIABLE_KEY_TESTS] = {
+ 0x00000000, 0xFFFFFFFF, 0x00000001, 0x11111111, 0x11111111,
+ 0x89ABCDEF, 0x00000000, 0x89ABCDEF, 0x39776742, 0x3DEF57DA,
+ 0x06F67172, 0x2DDF440A, 0x59577FA2, 0x51CF143A, 0x774761D2,
+ 0x29BF486A, 0x49372802, 0x35AF609A, 0x4F275232, 0x759F5CCA,
+ 0x09176062, 0x6EE762F2, 0x698F3CFA, 0x77075292, 0x8117F12A,
+ 0x18F728C2, 0x6D6F295A, 0x89ABCDEF, 0x89ABCDEF, 0x89ABCDEF,
+ 0xFFFFFFFF, 0x00000000, 0x00000000, 0xFFFFFFFF
+};
+
+/* key bytes for variable key tests */
+static const uint8_t variable_key[NUM_VARIABLE_KEY_TESTS][8] = {
+ { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+ { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF },
+ { 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+ { 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11 },
+ { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
+ { 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11 },
+ { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+ { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 },
+ { 0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57 },
+ { 0x01, 0x31, 0xD9, 0x61, 0x9D, 0xC1, 0x37, 0x6E },
+ { 0x07, 0xA1, 0x13, 0x3E, 0x4A, 0x0B, 0x26, 0x86 },
+ { 0x38, 0x49, 0x67, 0x4C, 0x26, 0x02, 0x31, 0x9E },
+ { 0x04, 0xB9, 0x15, 0xBA, 0x43, 0xFE, 0xB5, 0xB6 },
+ { 0x01, 0x13, 0xB9, 0x70, 0xFD, 0x34, 0xF2, 0xCE },
+ { 0x01, 0x70, 0xF1, 0x75, 0x46, 0x8F, 0xB5, 0xE6 },
+ { 0x43, 0x29, 0x7F, 0xAD, 0x38, 0xE3, 0x73, 0xFE },
+ { 0x07, 0xA7, 0x13, 0x70, 0x45, 0xDA, 0x2A, 0x16 },
+ { 0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F },
+ { 0x37, 0xD0, 0x6B, 0xB5, 0x16, 0xCB, 0x75, 0x46 },
+ { 0x1F, 0x08, 0x26, 0x0D, 0x1A, 0xC2, 0x46, 0x5E },
+ { 0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76 },
+ { 0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xB0, 0x07 },
+ { 0x49, 0x79, 0x3E, 0xBC, 0x79, 0xB3, 0x25, 0x8F },
+ { 0x4F, 0xB0, 0x5E, 0x15, 0x15, 0xAB, 0x73, 0xA7 },
+ { 0x49, 0xE9, 0x5D, 0x6D, 0x4C, 0xA2, 0x29, 0xBF },
+ { 0x01, 0x83, 0x10, 0xDC, 0x40, 0x9B, 0x26, 0xD6 },
+ { 0x1C, 0x58, 0x7F, 0x1C, 0x13, 0x92, 0x4F, 0xEF },
+ { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
+ { 0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E },
+ { 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE },
+ { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+ { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF },
+ { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
+ { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 }
+};
+
+/* ciphertext bytes -- left halves */
+static const uint32_t ciphertext_l[NUM_VARIABLE_KEY_TESTS] = {
+ 0x4EF99745, 0x51866FD5, 0x7D856F9A, 0x2466DD87, 0x61F9C380,
+ 0x7D0CC630, 0x4EF99745, 0x0ACEAB0F, 0x59C68245, 0xB1B8CC0B,
+ 0x1730E577, 0xA25E7856, 0x353882B1, 0x48F4D088, 0x432193B7,
+ 0x13F04154, 0x2EEDDA93, 0xD887E039, 0x5F99D04F, 0x4A057A3B,
+ 0x452031C1, 0x7555AE39, 0x53C55F9C, 0x7A8E7BFA, 0xCF9C5D7A,
+ 0xD1ABB290, 0x55CB3774, 0xFA34EC48, 0xA7907951, 0xC39E072D,
+ 0x014933E0, 0xF21E9A77, 0x24594688, 0x6B5C5A9C
+};
+
+/* ciphertext bytes -- right halves */
+static const uint32_t ciphertext_r[NUM_VARIABLE_KEY_TESTS] = {
+ 0x6198DD78, 0xB85ECB8A, 0x613063F2, 0x8B963C9D, 0x2281B096,
+ 0xAFDA1EC7, 0x6198DD78, 0xC6A0A28D, 0xEB05282B, 0x250F09A0,
+ 0x8BEA1DA4, 0xCF2651EB, 0x09CE8F1A, 0x4C379918, 0x8951FC98,
+ 0xD69D1AE5, 0xFFD39C79, 0x3C2DA6E3, 0x5B163969, 0x24D3977B,
+ 0xE4FADA8E, 0xF59B87BD, 0xB49FC019, 0x937E89A3, 0x4986ADB5,
+ 0x658BC778, 0xD13EF201, 0x47B268B2, 0x08EA3CAE, 0x9FAC631D,
+ 0xCDAFF6E4, 0xB71C49BC, 0x5754369A, 0x5D9E0A5A
+};
+
+/* plaintext bytes */
+static const uint8_t plaintext[8] = "BLOWFISH";
+
+static const uint8_t plaintext2[16] = "BLOWFISHBLOWFISH";
+
+/* ciphertext bytes */
+static const uint8_t ciphertext[8] = {
+ 0x32, 0x4E, 0xD0, 0xFE, 0xF4, 0x13, 0xA2, 0x03
+};
+
+static const uint8_t ciphertext2[16] = {
+ 0x53, 0x00, 0x40, 0x06, 0x63, 0xf2, 0x1d, 0x99,
+ 0x3b, 0x9b, 0x27, 0x64, 0x46, 0xfd, 0x20, 0xc1,
+};
+
+#define IV "blowfish"
+
+static void test_blowfish(AVBlowfish *ctx, uint8_t *dst, const uint8_t *src,
+ const uint8_t *ref, int len, uint8_t *iv, int dir,
+ const char *test)
+{
+ av_blowfish_crypt(ctx, dst, src, len, iv, dir);
+ if (memcmp(dst, ref, 8*len)) {
+ int i;
+ printf("%s failed\ngot ", test);
+ for (i = 0; i < 8*len; i++)
+ printf("%02x ", dst[i]);
+ printf("\nexpected ");
+ for (i = 0; i < 8*len; i++)
+ printf("%02x ", ref[i]);
+ printf("\n");
+ exit(1);
+ }
+}
+
+int main(void)
+{
+ AVBlowfish ctx;
+ uint32_t tmptext_l[NUM_VARIABLE_KEY_TESTS];
+ uint32_t tmptext_r[NUM_VARIABLE_KEY_TESTS];
+ uint8_t tmp[16], iv[8];
+ int i;
+
+ av_blowfish_init(&ctx, "abcdefghijklmnopqrstuvwxyz", 26);
+
+ test_blowfish(&ctx, tmp, plaintext, ciphertext, 1, NULL, 0, "encryption");
+ test_blowfish(&ctx, tmp, ciphertext, plaintext, 1, NULL, 1, "decryption");
+ test_blowfish(&ctx, tmp, tmp, ciphertext, 1, NULL, 0, "Inplace encryption");
+ test_blowfish(&ctx, tmp, tmp, plaintext, 1, NULL, 1, "Inplace decryption");
+ memcpy(iv, IV, 8);
+ test_blowfish(&ctx, tmp, plaintext2, ciphertext2, 2, iv, 0, "CBC encryption");
+ memcpy(iv, IV, 8);
+ test_blowfish(&ctx, tmp, ciphertext2, plaintext2, 2, iv, 1, "CBC decryption");
+ memcpy(iv, IV, 8);
+ test_blowfish(&ctx, tmp, tmp, ciphertext2, 2, iv, 0, "Inplace CBC encryption");
+ memcpy(iv, IV, 8);
+ test_blowfish(&ctx, tmp, tmp, plaintext2, 2, iv, 1, "Inplace CBC decryption");
+
+ memcpy(tmptext_l, plaintext_l, sizeof(*plaintext_l) * NUM_VARIABLE_KEY_TESTS);
+ memcpy(tmptext_r, plaintext_r, sizeof(*plaintext_r) * NUM_VARIABLE_KEY_TESTS);
+
+ for (i = 0; i < NUM_VARIABLE_KEY_TESTS; i++) {
+ av_blowfish_init(&ctx, variable_key[i], 8);
+
+ av_blowfish_crypt_ecb(&ctx, &tmptext_l[i], &tmptext_r[i], 0);
+ if (tmptext_l[i] != ciphertext_l[i] || tmptext_r[i] != ciphertext_r[i]) {
+ printf("Test encryption failed.\n");
+ return 1;
+ }
+
+ av_blowfish_crypt_ecb(&ctx, &tmptext_l[i], &tmptext_r[i], 1);
+ if (tmptext_l[i] != plaintext_l[i] || tmptext_r[i] != plaintext_r[i]) {
+ printf("Test decryption failed.\n");
+ return 1;
+ }
+ }
+ printf("Test encryption/decryption success.\n");
+
+ return 0;
+}
+
diff --git a/libavutil/blowfish.c b/libavutil/blowfish.c
index 0ab104eb8b44ef8e9d6390ba3b85b358f7caccef..abc0e03d4d25574d29c88f42441a2951463956c8 100644
--- a/libavutil/blowfish.c
+++ b/libavutil/blowfish.c
@@ -422,173 +422,3 @@ void av_blowfish_crypt(AVBlowfish *ctx, uint8_t *dst, const uint8_t *src,
}
}
}
-
-#ifdef TEST
-#include <stdio.h>
-
-#define NUM_VARIABLE_KEY_TESTS 34
-
-/* plaintext bytes -- left halves */
-static const uint32_t plaintext_l[NUM_VARIABLE_KEY_TESTS] = {
- 0x00000000, 0xFFFFFFFF, 0x10000000, 0x11111111, 0x11111111,
- 0x01234567, 0x00000000, 0x01234567, 0x01A1D6D0, 0x5CD54CA8,
- 0x0248D438, 0x51454B58, 0x42FD4430, 0x059B5E08, 0x0756D8E0,
- 0x762514B8, 0x3BDD1190, 0x26955F68, 0x164D5E40, 0x6B056E18,
- 0x004BD6EF, 0x480D3900, 0x437540C8, 0x072D43A0, 0x02FE5577,
- 0x1D9D5C50, 0x30553228, 0x01234567, 0x01234567, 0x01234567,
- 0xFFFFFFFF, 0x00000000, 0x00000000, 0xFFFFFFFF
-};
-
-/* plaintext bytes -- right halves */
-static const uint32_t plaintext_r[NUM_VARIABLE_KEY_TESTS] = {
- 0x00000000, 0xFFFFFFFF, 0x00000001, 0x11111111, 0x11111111,
- 0x89ABCDEF, 0x00000000, 0x89ABCDEF, 0x39776742, 0x3DEF57DA,
- 0x06F67172, 0x2DDF440A, 0x59577FA2, 0x51CF143A, 0x774761D2,
- 0x29BF486A, 0x49372802, 0x35AF609A, 0x4F275232, 0x759F5CCA,
- 0x09176062, 0x6EE762F2, 0x698F3CFA, 0x77075292, 0x8117F12A,
- 0x18F728C2, 0x6D6F295A, 0x89ABCDEF, 0x89ABCDEF, 0x89ABCDEF,
- 0xFFFFFFFF, 0x00000000, 0x00000000, 0xFFFFFFFF
-};
-
-/* key bytes for variable key tests */
-static const uint8_t variable_key[NUM_VARIABLE_KEY_TESTS][8] = {
- { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
- { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF },
- { 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
- { 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11 },
- { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
- { 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11 },
- { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
- { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 },
- { 0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57 },
- { 0x01, 0x31, 0xD9, 0x61, 0x9D, 0xC1, 0x37, 0x6E },
- { 0x07, 0xA1, 0x13, 0x3E, 0x4A, 0x0B, 0x26, 0x86 },
- { 0x38, 0x49, 0x67, 0x4C, 0x26, 0x02, 0x31, 0x9E },
- { 0x04, 0xB9, 0x15, 0xBA, 0x43, 0xFE, 0xB5, 0xB6 },
- { 0x01, 0x13, 0xB9, 0x70, 0xFD, 0x34, 0xF2, 0xCE },
- { 0x01, 0x70, 0xF1, 0x75, 0x46, 0x8F, 0xB5, 0xE6 },
- { 0x43, 0x29, 0x7F, 0xAD, 0x38, 0xE3, 0x73, 0xFE },
- { 0x07, 0xA7, 0x13, 0x70, 0x45, 0xDA, 0x2A, 0x16 },
- { 0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F },
- { 0x37, 0xD0, 0x6B, 0xB5, 0x16, 0xCB, 0x75, 0x46 },
- { 0x1F, 0x08, 0x26, 0x0D, 0x1A, 0xC2, 0x46, 0x5E },
- { 0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76 },
- { 0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xB0, 0x07 },
- { 0x49, 0x79, 0x3E, 0xBC, 0x79, 0xB3, 0x25, 0x8F },
- { 0x4F, 0xB0, 0x5E, 0x15, 0x15, 0xAB, 0x73, 0xA7 },
- { 0x49, 0xE9, 0x5D, 0x6D, 0x4C, 0xA2, 0x29, 0xBF },
- { 0x01, 0x83, 0x10, 0xDC, 0x40, 0x9B, 0x26, 0xD6 },
- { 0x1C, 0x58, 0x7F, 0x1C, 0x13, 0x92, 0x4F, 0xEF },
- { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
- { 0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E },
- { 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE },
- { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
- { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF },
- { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
- { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 }
-};
-
-/* ciphertext bytes -- left halves */
-static const uint32_t ciphertext_l[NUM_VARIABLE_KEY_TESTS] = {
- 0x4EF99745, 0x51866FD5, 0x7D856F9A, 0x2466DD87, 0x61F9C380,
- 0x7D0CC630, 0x4EF99745, 0x0ACEAB0F, 0x59C68245, 0xB1B8CC0B,
- 0x1730E577, 0xA25E7856, 0x353882B1, 0x48F4D088, 0x432193B7,
- 0x13F04154, 0x2EEDDA93, 0xD887E039, 0x5F99D04F, 0x4A057A3B,
- 0x452031C1, 0x7555AE39, 0x53C55F9C, 0x7A8E7BFA, 0xCF9C5D7A,
- 0xD1ABB290, 0x55CB3774, 0xFA34EC48, 0xA7907951, 0xC39E072D,
- 0x014933E0, 0xF21E9A77, 0x24594688, 0x6B5C5A9C
-};
-
-/* ciphertext bytes -- right halves */
-static const uint32_t ciphertext_r[NUM_VARIABLE_KEY_TESTS] = {
- 0x6198DD78, 0xB85ECB8A, 0x613063F2, 0x8B963C9D, 0x2281B096,
- 0xAFDA1EC7, 0x6198DD78, 0xC6A0A28D, 0xEB05282B, 0x250F09A0,
- 0x8BEA1DA4, 0xCF2651EB, 0x09CE8F1A, 0x4C379918, 0x8951FC98,
- 0xD69D1AE5, 0xFFD39C79, 0x3C2DA6E3, 0x5B163969, 0x24D3977B,
- 0xE4FADA8E, 0xF59B87BD, 0xB49FC019, 0x937E89A3, 0x4986ADB5,
- 0x658BC778, 0xD13EF201, 0x47B268B2, 0x08EA3CAE, 0x9FAC631D,
- 0xCDAFF6E4, 0xB71C49BC, 0x5754369A, 0x5D9E0A5A
-};
-
-/* plaintext bytes */
-static const uint8_t plaintext[8] = "BLOWFISH";
-
-static const uint8_t plaintext2[16] = "BLOWFISHBLOWFISH";
-
-/* ciphertext bytes */
-static const uint8_t ciphertext[8] = {
- 0x32, 0x4E, 0xD0, 0xFE, 0xF4, 0x13, 0xA2, 0x03
-};
-
-static const uint8_t ciphertext2[16] = {
- 0x53, 0x00, 0x40, 0x06, 0x63, 0xf2, 0x1d, 0x99,
- 0x3b, 0x9b, 0x27, 0x64, 0x46, 0xfd, 0x20, 0xc1,
-};
-
-#define IV "blowfish"
-
-static void test_blowfish(AVBlowfish *ctx, uint8_t *dst, const uint8_t *src,
- const uint8_t *ref, int len, uint8_t *iv, int dir,
- const char *test)
-{
- av_blowfish_crypt(ctx, dst, src, len, iv, dir);
- if (memcmp(dst, ref, 8*len)) {
- int i;
- printf("%s failed\ngot ", test);
- for (i = 0; i < 8*len; i++)
- printf("%02x ", dst[i]);
- printf("\nexpected ");
- for (i = 0; i < 8*len; i++)
- printf("%02x ", ref[i]);
- printf("\n");
- exit(1);
- }
-}
-
-int main(void)
-{
- AVBlowfish ctx;
- uint32_t tmptext_l[NUM_VARIABLE_KEY_TESTS];
- uint32_t tmptext_r[NUM_VARIABLE_KEY_TESTS];
- uint8_t tmp[16], iv[8];
- int i;
-
- av_blowfish_init(&ctx, "abcdefghijklmnopqrstuvwxyz", 26);
-
- test_blowfish(&ctx, tmp, plaintext, ciphertext, 1, NULL, 0, "encryption");
- test_blowfish(&ctx, tmp, ciphertext, plaintext, 1, NULL, 1, "decryption");
- test_blowfish(&ctx, tmp, tmp, ciphertext, 1, NULL, 0, "Inplace encryption");
- test_blowfish(&ctx, tmp, tmp, plaintext, 1, NULL, 1, "Inplace decryption");
- memcpy(iv, IV, 8);
- test_blowfish(&ctx, tmp, plaintext2, ciphertext2, 2, iv, 0, "CBC encryption");
- memcpy(iv, IV, 8);
- test_blowfish(&ctx, tmp, ciphertext2, plaintext2, 2, iv, 1, "CBC decryption");
- memcpy(iv, IV, 8);
- test_blowfish(&ctx, tmp, tmp, ciphertext2, 2, iv, 0, "Inplace CBC encryption");
- memcpy(iv, IV, 8);
- test_blowfish(&ctx, tmp, tmp, plaintext2, 2, iv, 1, "Inplace CBC decryption");
-
- memcpy(tmptext_l, plaintext_l, sizeof(*plaintext_l) * NUM_VARIABLE_KEY_TESTS);
- memcpy(tmptext_r, plaintext_r, sizeof(*plaintext_r) * NUM_VARIABLE_KEY_TESTS);
-
- for (i = 0; i < NUM_VARIABLE_KEY_TESTS; i++) {
- av_blowfish_init(&ctx, variable_key[i], 8);
-
- av_blowfish_crypt_ecb(&ctx, &tmptext_l[i], &tmptext_r[i], 0);
- if (tmptext_l[i] != ciphertext_l[i] || tmptext_r[i] != ciphertext_r[i]) {
- printf("Test encryption failed.\n");
- return 1;
- }
-
- av_blowfish_crypt_ecb(&ctx, &tmptext_l[i], &tmptext_r[i], 1);
- if (tmptext_l[i] != plaintext_l[i] || tmptext_r[i] != plaintext_r[i]) {
- printf("Test decryption failed.\n");
- return 1;
- }
- }
- printf("Test encryption/decryption success.\n");
-
- return 0;
-}
-
-#endif
diff --git a/libavutil/bprint-test.c b/libavutil/bprint-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..f081c4485e754a829d3051e1d223aa8e94613e5e
--- /dev/null
+++ b/libavutil/bprint-test.c
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2012 Nicolas George
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "bprint.c"
+
+#undef printf
+
+static void bprint_pascal(AVBPrint *b, unsigned size)
+{
+ unsigned i, j;
+ unsigned p[42];
+
+ av_assert0(size < FF_ARRAY_ELEMS(p));
+
+ p[0] = 1;
+ av_bprintf(b, "%8d\n", 1);
+ for (i = 1; i <= size; i++) {
+ p[i] = 1;
+ for (j = i - 1; j > 0; j--)
+ p[j] = p[j] + p[j - 1];
+ for (j = 0; j <= i; j++)
+ av_bprintf(b, "%8d", p[j]);
+ av_bprintf(b, "\n");
+ }
+}
+
+int main(void)
+{
+ AVBPrint b;
+ char buf[256];
+ struct tm testtime = { .tm_year = 100, .tm_mon = 11, .tm_mday = 20 };
+
+ av_bprint_init(&b, 0, -1);
+ bprint_pascal(&b, 5);
+ printf("Short text in unlimited buffer: %u/%u\n", (unsigned)strlen(b.str), b.len);
+ printf("%s\n", b.str);
+ av_bprint_finalize(&b, NULL);
+
+ av_bprint_init(&b, 0, -1);
+ bprint_pascal(&b, 25);
+ printf("Long text in unlimited buffer: %u/%u\n", (unsigned)strlen(b.str), b.len);
+ av_bprint_finalize(&b, NULL);
+
+ av_bprint_init(&b, 0, 2048);
+ bprint_pascal(&b, 25);
+ printf("Long text in limited buffer: %u/%u\n", (unsigned)strlen(b.str), b.len);
+ av_bprint_finalize(&b, NULL);
+
+ av_bprint_init(&b, 0, 1);
+ bprint_pascal(&b, 5);
+ printf("Short text in automatic buffer: %u/%u\n", (unsigned)strlen(b.str), b.len);
+
+ av_bprint_init(&b, 0, 1);
+ bprint_pascal(&b, 25);
+ printf("Long text in automatic buffer: %u/%u\n", (unsigned)strlen(b.str)/8*8, b.len);
+ /* Note that the size of the automatic buffer is arch-dependent. */
+
+ av_bprint_init(&b, 0, 0);
+ bprint_pascal(&b, 25);
+ printf("Long text count only buffer: %u/%u\n", (unsigned)strlen(b.str), b.len);
+
+ av_bprint_init_for_buffer(&b, buf, sizeof(buf));
+ bprint_pascal(&b, 25);
+ printf("Long text count only buffer: %u/%u\n", (unsigned)strlen(buf), b.len);
+
+ av_bprint_init(&b, 0, -1);
+ av_bprint_strftime(&b, "%Y-%m-%d", &testtime);
+ printf("strftime full: %u/%u \"%s\"\n", (unsigned)strlen(buf), b.len, b.str);
+ av_bprint_finalize(&b, NULL);
+
+ av_bprint_init(&b, 0, 8);
+ av_bprint_strftime(&b, "%Y-%m-%d", &testtime);
+ printf("strftime truncated: %u/%u \"%s\"\n", (unsigned)strlen(buf), b.len, b.str);
+
+ return 0;
+}
diff --git a/libavutil/bprint.c b/libavutil/bprint.c
index 7ef84d4d269546e66f274572057984f73431009b..2f059c5ba6bfd66e6d9fd98d02394fa226b92776 100644
--- a/libavutil/bprint.c
+++ b/libavutil/bprint.c
@@ -303,79 +303,3 @@ void av_bprint_escape(AVBPrint *dstbuf, const char *src, const char *special_cha
break;
}
}
-
-#ifdef TEST
-
-#undef printf
-
-static void bprint_pascal(AVBPrint *b, unsigned size)
-{
- unsigned i, j;
- unsigned p[42];
-
- av_assert0(size < FF_ARRAY_ELEMS(p));
-
- p[0] = 1;
- av_bprintf(b, "%8d\n", 1);
- for (i = 1; i <= size; i++) {
- p[i] = 1;
- for (j = i - 1; j > 0; j--)
- p[j] = p[j] + p[j - 1];
- for (j = 0; j <= i; j++)
- av_bprintf(b, "%8d", p[j]);
- av_bprintf(b, "\n");
- }
-}
-
-int main(void)
-{
- AVBPrint b;
- char buf[256];
- struct tm testtime = { .tm_year = 100, .tm_mon = 11, .tm_mday = 20 };
-
- av_bprint_init(&b, 0, -1);
- bprint_pascal(&b, 5);
- printf("Short text in unlimited buffer: %u/%u\n", (unsigned)strlen(b.str), b.len);
- printf("%s\n", b.str);
- av_bprint_finalize(&b, NULL);
-
- av_bprint_init(&b, 0, -1);
- bprint_pascal(&b, 25);
- printf("Long text in unlimited buffer: %u/%u\n", (unsigned)strlen(b.str), b.len);
- av_bprint_finalize(&b, NULL);
-
- av_bprint_init(&b, 0, 2048);
- bprint_pascal(&b, 25);
- printf("Long text in limited buffer: %u/%u\n", (unsigned)strlen(b.str), b.len);
- av_bprint_finalize(&b, NULL);
-
- av_bprint_init(&b, 0, 1);
- bprint_pascal(&b, 5);
- printf("Short text in automatic buffer: %u/%u\n", (unsigned)strlen(b.str), b.len);
-
- av_bprint_init(&b, 0, 1);
- bprint_pascal(&b, 25);
- printf("Long text in automatic buffer: %u/%u\n", (unsigned)strlen(b.str)/8*8, b.len);
- /* Note that the size of the automatic buffer is arch-dependent. */
-
- av_bprint_init(&b, 0, 0);
- bprint_pascal(&b, 25);
- printf("Long text count only buffer: %u/%u\n", (unsigned)strlen(b.str), b.len);
-
- av_bprint_init_for_buffer(&b, buf, sizeof(buf));
- bprint_pascal(&b, 25);
- printf("Long text count only buffer: %u/%u\n", (unsigned)strlen(buf), b.len);
-
- av_bprint_init(&b, 0, -1);
- av_bprint_strftime(&b, "%Y-%m-%d", &testtime);
- printf("strftime full: %u/%u \"%s\"\n", (unsigned)strlen(buf), b.len, b.str);
- av_bprint_finalize(&b, NULL);
-
- av_bprint_init(&b, 0, 8);
- av_bprint_strftime(&b, "%Y-%m-%d", &testtime);
- printf("strftime truncated: %u/%u \"%s\"\n", (unsigned)strlen(buf), b.len, b.str);
-
- return 0;
-}
-
-#endif
diff --git a/libavutil/camellia-test.c b/libavutil/camellia-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..ad905873451997b652833afec3bf151fa34f9f60
--- /dev/null
+++ b/libavutil/camellia-test.c
@@ -0,0 +1,78 @@
+/*
+ * An implementation of the CAMELLIA algorithm as mentioned in RFC3713
+ * Copyright (c) 2014 Supraja Meedinti
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "camellia.c"
+#include "log.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ const uint8_t Key[3][32] = {
+ {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
+ {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77},
+ {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}
+ };
+ const uint8_t rct[3][16] = {
+ {0x67, 0x67, 0x31, 0x38, 0x54, 0x96, 0x69, 0x73, 0x08, 0x57, 0x06, 0x56, 0x48, 0xea, 0xbe, 0x43},
+ {0xb4, 0x99, 0x34, 0x01, 0xb3, 0xe9,0x96, 0xf8, 0x4e, 0xe5, 0xce, 0xe7, 0xd7, 0x9b, 0x09, 0xb9},
+ {0x9a, 0xcc, 0x23, 0x7d, 0xff, 0x16, 0xd7, 0x6c, 0x20, 0xef, 0x7c, 0x91, 0x9e, 0x3a, 0x75, 0x09}
+ };
+ const uint8_t rpt[32] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10};
+ const int kbits[3] = {128, 192, 256};
+ int i, j, err = 0;
+ uint8_t temp[32], iv[16];
+ AVCAMELLIA *cs;
+ cs = av_camellia_alloc();
+ if (!cs)
+ return 1;
+ for (j = 0; j < 3; j++) {
+ av_camellia_init(cs, Key[j], kbits[j]);
+ av_camellia_crypt(cs, temp, rpt, 1, NULL, 0);
+ for (i = 0; i < 16; i++) {
+ if (rct[j][i] != temp[i]) {
+ av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rct[j][i], temp[i]);
+ err = 1;
+ }
+ }
+ av_camellia_crypt(cs, temp, rct[j], 1, NULL, 1);
+ for (i = 0; i < 16; i++) {
+ if (rpt[i] != temp[i]) {
+ av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rpt[i], temp[i]);
+ err = 1;
+ }
+ }
+ }
+ av_camellia_init(cs, Key[0], 128);
+ memcpy(iv, "HALLO123HALLO123", 16);
+ av_camellia_crypt(cs, temp, rpt, 2, iv, 0);
+ memcpy(iv, "HALLO123HALLO123", 16);
+ av_camellia_crypt(cs, temp, temp, 2, iv, 1);
+ for (i = 0; i < 32; i++) {
+ if (rpt[i] != temp[i]) {
+ av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rpt[i], temp[i]);
+ err = 1;
+ }
+ }
+ av_free(cs);
+ return err;
+}
diff --git a/libavutil/camellia.c b/libavutil/camellia.c
index f21ca12604fbc6a747722d0616e5c4e9e63d80e1..f33ee9babc658d3cfdb7b2941d585f3a5934b727 100644
--- a/libavutil/camellia.c
+++ b/libavutil/camellia.c
@@ -410,61 +410,3 @@ void av_camellia_crypt(AVCAMELLIA *cs, uint8_t *dst, const uint8_t *src, int cou
dst = dst + 16;
}
}
-
-#ifdef TEST
-#include<stdio.h>
-#include<stdlib.h>
-#include"log.h"
-
-int main(int argc, char *argv[])
-{
- const uint8_t Key[3][32] = {
- {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
- {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77},
- {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}
- };
- const uint8_t rct[3][16] = {
- {0x67, 0x67, 0x31, 0x38, 0x54, 0x96, 0x69, 0x73, 0x08, 0x57, 0x06, 0x56, 0x48, 0xea, 0xbe, 0x43},
- {0xb4, 0x99, 0x34, 0x01, 0xb3, 0xe9,0x96, 0xf8, 0x4e, 0xe5, 0xce, 0xe7, 0xd7, 0x9b, 0x09, 0xb9},
- {0x9a, 0xcc, 0x23, 0x7d, 0xff, 0x16, 0xd7, 0x6c, 0x20, 0xef, 0x7c, 0x91, 0x9e, 0x3a, 0x75, 0x09}
- };
- const uint8_t rpt[32] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10};
- const int kbits[3] = {128, 192, 256};
- int i, j, err = 0;
- uint8_t temp[32], iv[16];
- AVCAMELLIA *cs;
- cs = av_camellia_alloc();
- if (!cs)
- return 1;
- for (j = 0; j < 3; j++) {
- av_camellia_init(cs, Key[j], kbits[j]);
- av_camellia_crypt(cs, temp, rpt, 1, NULL, 0);
- for (i = 0; i < 16; i++) {
- if (rct[j][i] != temp[i]) {
- av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rct[j][i], temp[i]);
- err = 1;
- }
- }
- av_camellia_crypt(cs, temp, rct[j], 1, NULL, 1);
- for (i = 0; i < 16; i++) {
- if (rpt[i] != temp[i]) {
- av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rpt[i], temp[i]);
- err = 1;
- }
- }
- }
- av_camellia_init(cs, Key[0], 128);
- memcpy(iv, "HALLO123HALLO123", 16);
- av_camellia_crypt(cs, temp, rpt, 2, iv, 0);
- memcpy(iv, "HALLO123HALLO123", 16);
- av_camellia_crypt(cs, temp, temp, 2, iv, 1);
- for (i = 0; i < 32; i++) {
- if (rpt[i] != temp[i]) {
- av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rpt[i], temp[i]);
- err = 1;
- }
- }
- av_free(cs);
- return err;
-}
-#endif
diff --git a/libavutil/cast5-test.c b/libavutil/cast5-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..3776d11d67d5c58547c560b37b89bbc6eafda4ce
--- /dev/null
+++ b/libavutil/cast5-test.c
@@ -0,0 +1,106 @@
+/*
+ * An implementation of the CAST128 algorithm as mentioned in RFC2144
+ * Copyright (c) 2014 Supraja Meedinti
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "cast5.c"
+#include "log.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char** argv)
+{
+
+ static const uint8_t Key[3][16] = {
+ {0x01, 0x23, 0x45, 0x67, 0x12, 0x34, 0x56, 0x78, 0x23, 0x45, 0x67, 0x89, 0x34, 0x56, 0x78, 0x9a},
+ {0x01, 0x23, 0x45, 0x67, 0x12, 0x34, 0x56, 0x78, 0x23, 0x45},
+ {0x01, 0x23, 0x45, 0x67, 0x12}
+ };
+ static const uint8_t rpt[8] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef};
+ static const uint8_t rct[3][8] = {
+ {0x23, 0x8b, 0x4f, 0xe5, 0x84, 0x7e, 0x44, 0xb2},
+ {0xeb, 0x6a, 0x71, 0x1a, 0x2c, 0x02, 0x27, 0x1b},
+ {0x7a, 0xc8, 0x16, 0xd1, 0x6e, 0x9b, 0x30, 0x2e}
+ };
+ static const uint8_t rct2[2][16] = {
+ {0xee, 0xa9, 0xd0, 0xa2, 0x49, 0xfd, 0x3b, 0xa6, 0xb3, 0x43, 0x6f, 0xb8, 0x9d, 0x6d, 0xca, 0x92},
+ {0xb2, 0xc9, 0x5e, 0xb0, 0x0c, 0x31, 0xad, 0x71, 0x80, 0xac, 0x05, 0xb8, 0xe8, 0x3d, 0x69, 0x6e}
+ };
+ static const uint8_t iv[8] = {0xee, 0xa9, 0xd0, 0xa2, 0x49, 0xfd, 0x3b, 0xa6};
+ static uint8_t rpt2[2][16];
+ int i, j, err = 0;
+ static const int key_bits[3] = {128, 80, 40};
+ uint8_t temp[8];
+ AVCAST5 *cs;
+ cs = av_cast5_alloc();
+ if (!cs)
+ return 1;
+ for (j = 0; j < 3; j++){
+
+ av_cast5_init(cs, Key[j], key_bits[j]);
+ av_cast5_crypt(cs, temp, rpt, 1, 0);
+ for (i = 0;i < 8; i++){
+ if (rct[j][i] != temp[i]){
+ av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rct[j][i], temp[i]);
+ err = 1;
+ }
+ }
+
+ av_cast5_crypt(cs, temp, rct[j], 1, 1);
+ for (i =0; i < 8; i++) {
+ if (rpt[i] != temp[i]) {
+ av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rpt[i], temp[i]);
+ err = 1;
+ }
+ }
+ }
+ memcpy(rpt2[0], Key[0], 16);
+ memcpy(rpt2[1], Key[0], 16);
+ for (i = 0; i < 1000000; i++){
+ av_cast5_init(cs, rpt2[1], 128);
+ av_cast5_crypt(cs, rpt2[0], rpt2[0], 2, 0);
+ av_cast5_init(cs, rpt2[0], 128);
+ av_cast5_crypt(cs, rpt2[1], rpt2[1], 2, 0);
+ }
+ for (j = 0; j < 2; j++) {
+ for (i = 0; i < 16; i++) {
+ if (rct2[j][i] != rpt2[j][i]) {
+ av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rct2[j][i], rpt2[j][i]);
+ err = 1;
+ }
+ }
+ }
+ for (j = 0; j < 3; j++) {
+
+ av_cast5_init(cs, Key[j], key_bits[j]);
+ memcpy(temp, iv, 8);
+ av_cast5_crypt2(cs, rpt2[0], rct2[0], 2, temp, 0);
+ memcpy(temp, iv, 8);
+ av_cast5_crypt2(cs, rpt2[0], rpt2[0], 2, temp, 1);
+ for (i = 0; i < 16; i++) {
+ if (rct2[0][i] != rpt2[0][i]) {
+ av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rct2[0][i], rpt2[0][i]);
+ err = 1;
+ }
+ }
+ }
+ av_free(cs);
+ return err;
+}
diff --git a/libavutil/cast5.c b/libavutil/cast5.c
index a47697b2f8a1f9bbbdfe7aef36d10689efe975d4..445eb55c12a3083663fac0fe88de1fb19f54156a 100644
--- a/libavutil/cast5.c
+++ b/libavutil/cast5.c
@@ -505,89 +505,3 @@ void av_cast5_crypt(AVCAST5* cs, uint8_t* dst, const uint8_t* src, int count, in
dst = dst + 8;
}
}
-
-#ifdef TEST
-#include<stdio.h>
-#include<stdlib.h>
-#include"log.h"
-
-int main(int argc, char** argv)
-{
-
- static const uint8_t Key[3][16] = {
- {0x01, 0x23, 0x45, 0x67, 0x12, 0x34, 0x56, 0x78, 0x23, 0x45, 0x67, 0x89, 0x34, 0x56, 0x78, 0x9a},
- {0x01, 0x23, 0x45, 0x67, 0x12, 0x34, 0x56, 0x78, 0x23, 0x45},
- {0x01, 0x23, 0x45, 0x67, 0x12}
- };
- static const uint8_t rpt[8] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef};
- static const uint8_t rct[3][8] = {
- {0x23, 0x8b, 0x4f, 0xe5, 0x84, 0x7e, 0x44, 0xb2},
- {0xeb, 0x6a, 0x71, 0x1a, 0x2c, 0x02, 0x27, 0x1b},
- {0x7a, 0xc8, 0x16, 0xd1, 0x6e, 0x9b, 0x30, 0x2e}
- };
- static const uint8_t rct2[2][16] = {
- {0xee, 0xa9, 0xd0, 0xa2, 0x49, 0xfd, 0x3b, 0xa6, 0xb3, 0x43, 0x6f, 0xb8, 0x9d, 0x6d, 0xca, 0x92},
- {0xb2, 0xc9, 0x5e, 0xb0, 0x0c, 0x31, 0xad, 0x71, 0x80, 0xac, 0x05, 0xb8, 0xe8, 0x3d, 0x69, 0x6e}
- };
- static const uint8_t iv[8] = {0xee, 0xa9, 0xd0, 0xa2, 0x49, 0xfd, 0x3b, 0xa6};
- static uint8_t rpt2[2][16];
- int i, j, err = 0;
- static const int key_bits[3] = {128, 80, 40};
- uint8_t temp[8];
- AVCAST5 *cs;
- cs = av_cast5_alloc();
- if (!cs)
- return 1;
- for (j = 0; j < 3; j++){
-
- av_cast5_init(cs, Key[j], key_bits[j]);
- av_cast5_crypt(cs, temp, rpt, 1, 0);
- for (i = 0;i < 8; i++){
- if (rct[j][i] != temp[i]){
- av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rct[j][i], temp[i]);
- err = 1;
- }
- }
-
- av_cast5_crypt(cs, temp, rct[j], 1, 1);
- for (i =0; i < 8; i++) {
- if (rpt[i] != temp[i]) {
- av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rpt[i], temp[i]);
- err = 1;
- }
- }
- }
- memcpy(rpt2[0], Key[0], 16);
- memcpy(rpt2[1], Key[0], 16);
- for (i = 0; i < 1000000; i++){
- av_cast5_init(cs, rpt2[1], 128);
- av_cast5_crypt(cs, rpt2[0], rpt2[0], 2, 0);
- av_cast5_init(cs, rpt2[0], 128);
- av_cast5_crypt(cs, rpt2[1], rpt2[1], 2, 0);
- }
- for (j = 0; j < 2; j++) {
- for (i = 0; i < 16; i++) {
- if (rct2[j][i] != rpt2[j][i]) {
- av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rct2[j][i], rpt2[j][i]);
- err = 1;
- }
- }
- }
- for (j = 0; j < 3; j++) {
-
- av_cast5_init(cs, Key[j], key_bits[j]);
- memcpy(temp, iv, 8);
- av_cast5_crypt2(cs, rpt2[0], rct2[0], 2, temp, 0);
- memcpy(temp, iv, 8);
- av_cast5_crypt2(cs, rpt2[0], rpt2[0], 2, temp, 1);
- for (i = 0; i < 16; i++) {
- if (rct2[0][i] != rpt2[0][i]) {
- av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rct2[0][i], rpt2[0][i]);
- err = 1;
- }
- }
- }
- av_free(cs);
- return err;
-}
-#endif
diff --git a/libavutil/color_utils-test.c b/libavutil/color_utils-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..083872c3e4d6ff66a60af0aab14d01d74dfcd3aa
--- /dev/null
+++ b/libavutil/color_utils-test.c
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2015 Kevin Wheatley <kevin.j.wheatley@gmail.com>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "color_utils.c"
+
+int main(int argc, char *argv[])
+{
+ int i, j;
+ static const double test_data[] = {
+ -0.1, -0.018053968510807, -0.01, -0.00449, 0.0, 0.00316227760, 0.005,
+ 0.009, 0.015, 0.1, 1.0, 52.37, 125.098765, 1999.11123, 6945.443,
+ 15123.4567, 19845.88923, 98678.4231, 99999.899998
+ };
+
+ for(i = 0; i < AVCOL_TRC_NB; i++) {
+ avpriv_trc_function func = avpriv_get_trc_function_from_trc(i);
+ for(j = 0; j < FF_ARRAY_ELEMS(test_data); j++) {
+ if(func != NULL) {
+ double result = func(test_data[j]);
+ printf("AVColorTransferCharacteristic=%d calling func(%f) expected=%f\n",
+ i, test_data[j], result);
+ }
+ }
+ }
+
+}
diff --git a/libavutil/color_utils.c b/libavutil/color_utils.c
index 6dba46a81694dbb6b2f1521c86c8a0d885a5b720..63f2230980020aca9ac7045f39ee32f606a2c475 100644
--- a/libavutil/color_utils.c
+++ b/libavutil/color_utils.c
@@ -217,31 +217,3 @@ avpriv_trc_function avpriv_get_trc_function_from_trc(enum AVColorTransferCharact
}
return func;
}
-
-#ifdef TEST
-// LCOV_EXCL_START
-
-int main(int argc, char *argv[])
-{
- int i, j;
- static const double test_data[] = {
- -0.1, -0.018053968510807, -0.01, -0.00449, 0.0, 0.00316227760, 0.005,
- 0.009, 0.015, 0.1, 1.0, 52.37, 125.098765, 1999.11123, 6945.443,
- 15123.4567, 19845.88923, 98678.4231, 99999.899998
- };
-
- for(i = 0; i < AVCOL_TRC_NB; i++) {
- avpriv_trc_function func = avpriv_get_trc_function_from_trc(i);
- for(j = 0; j < FF_ARRAY_ELEMS(test_data); j++) {
- if(func != NULL) {
- double result = func(test_data[j]);
- printf("AVColorTransferCharacteristic=%d calling func(%f) expected=%f\n",
- i, test_data[j], result);
- }
- }
- }
-
-}
-
-// LCOV_EXCL_STOP
-#endif
diff --git a/libavutil/cpu-test.c b/libavutil/cpu-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..3eca6d203388b4a8c65af7e2c7d598c69341b116
--- /dev/null
+++ b/libavutil/cpu-test.c
@@ -0,0 +1,147 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdio.h>
+#include "avstring.h"
+
+#if !HAVE_GETOPT
+#include "compat/getopt.c"
+#endif
+
+#include <stdint.h>
+#include <stdio.h>
+
+#include "avstring.h"
+#include "common.h"
+#include "cpu.h"
+
+static const struct {
+ int flag;
+ const char *name;
+} cpu_flag_tab[] = {
+#if ARCH_AARCH64
+ { AV_CPU_FLAG_ARMV8, "armv8" },
+ { AV_CPU_FLAG_NEON, "neon" },
+ { AV_CPU_FLAG_VFP, "vfp" },
+#elif ARCH_ARM
+ { AV_CPU_FLAG_ARMV5TE, "armv5te" },
+ { AV_CPU_FLAG_ARMV6, "armv6" },
+ { AV_CPU_FLAG_ARMV6T2, "armv6t2" },
+ { AV_CPU_FLAG_VFP, "vfp" },
+ { AV_CPU_FLAG_VFP_VM, "vfp_vm" },
+ { AV_CPU_FLAG_VFPV3, "vfpv3" },
+ { AV_CPU_FLAG_NEON, "neon" },
+ { AV_CPU_FLAG_SETEND, "setend" },
+#elif ARCH_PPC
+ { AV_CPU_FLAG_ALTIVEC, "altivec" },
+#elif ARCH_X86
+ { AV_CPU_FLAG_MMX, "mmx" },
+ { AV_CPU_FLAG_MMXEXT, "mmxext" },
+ { AV_CPU_FLAG_SSE, "sse" },
+ { AV_CPU_FLAG_SSE2, "sse2" },
+ { AV_CPU_FLAG_SSE2SLOW, "sse2slow" },
+ { AV_CPU_FLAG_SSE3, "sse3" },
+ { AV_CPU_FLAG_SSE3SLOW, "sse3slow" },
+ { AV_CPU_FLAG_SSSE3, "ssse3" },
+ { AV_CPU_FLAG_ATOM, "atom" },
+ { AV_CPU_FLAG_SSE4, "sse4.1" },
+ { AV_CPU_FLAG_SSE42, "sse4.2" },
+ { AV_CPU_FLAG_AVX, "avx" },
+ { AV_CPU_FLAG_AVXSLOW, "avxslow" },
+ { AV_CPU_FLAG_XOP, "xop" },
+ { AV_CPU_FLAG_FMA3, "fma3" },
+ { AV_CPU_FLAG_FMA4, "fma4" },
+ { AV_CPU_FLAG_3DNOW, "3dnow" },
+ { AV_CPU_FLAG_3DNOWEXT, "3dnowext" },
+ { AV_CPU_FLAG_CMOV, "cmov" },
+ { AV_CPU_FLAG_AVX2, "avx2" },
+ { AV_CPU_FLAG_BMI1, "bmi1" },
+ { AV_CPU_FLAG_BMI2, "bmi2" },
+ { AV_CPU_FLAG_AESNI, "aesni" },
+#endif
+ { 0 }
+};
+
+static void print_cpu_flags(int cpu_flags, const char *type)
+{
+ int i;
+
+ printf("cpu_flags(%s) = 0x%08X\n", type, cpu_flags);
+ printf("cpu_flags_str(%s) =", type);
+ for (i = 0; cpu_flag_tab[i].flag; i++)
+ if (cpu_flags & cpu_flag_tab[i].flag)
+ printf(" %s", cpu_flag_tab[i].name);
+ printf("\n");
+}
+
+
+int main(int argc, char **argv)
+{
+ int cpu_flags_raw = av_get_cpu_flags();
+ int cpu_flags_eff;
+ int cpu_count = av_cpu_count();
+ char threads[5] = "auto";
+ int i;
+
+ for(i = 0; cpu_flag_tab[i].flag; i++) {
+ unsigned tmp = 0;
+ if (av_parse_cpu_caps(&tmp, cpu_flag_tab[i].name) < 0) {
+ fprintf(stderr, "Table missing %s\n", cpu_flag_tab[i].name);
+ return 4;
+ }
+ }
+
+ if (cpu_flags_raw < 0)
+ return 1;
+
+ for (;;) {
+ int c = getopt(argc, argv, "c:t:");
+ if (c == -1)
+ break;
+ switch (c) {
+ case 'c':
+ {
+ unsigned flags = av_get_cpu_flags();
+ if (av_parse_cpu_caps(&flags, optarg) < 0)
+ return 2;
+
+ av_force_cpu_flags(flags);
+ break;
+ }
+ case 't':
+ {
+ int len = av_strlcpy(threads, optarg, sizeof(threads));
+ if (len >= sizeof(threads)) {
+ fprintf(stderr, "Invalid thread count '%s'\n", optarg);
+ return 2;
+ }
+ }
+ }
+ }
+
+ cpu_flags_eff = av_get_cpu_flags();
+
+ if (cpu_flags_eff < 0)
+ return 3;
+
+ print_cpu_flags(cpu_flags_raw, "raw");
+ print_cpu_flags(cpu_flags_eff, "effective");
+ printf("threads = %s (cpu_count = %d)\n", threads, cpu_count);
+
+ return 0;
+}
diff --git a/libavutil/cpu.c b/libavutil/cpu.c
index cd55d3be2e553b01d1a428b35fbf866ce3156497..f5785fc13fb86355d46f8f5bba0e11fb9a22fda0 100644
--- a/libavutil/cpu.c
+++ b/libavutil/cpu.c
@@ -294,130 +294,3 @@ int av_cpu_count(void)
return nb_cpus;
}
-
-#ifdef TEST
-
-#include <stdio.h>
-#include "avstring.h"
-
-#if !HAVE_GETOPT
-#include "compat/getopt.c"
-#endif
-
-static const struct {
- int flag;
- const char *name;
-} cpu_flag_tab[] = {
-#if ARCH_AARCH64
- { AV_CPU_FLAG_ARMV8, "armv8" },
- { AV_CPU_FLAG_NEON, "neon" },
- { AV_CPU_FLAG_VFP, "vfp" },
-#elif ARCH_ARM
- { AV_CPU_FLAG_ARMV5TE, "armv5te" },
- { AV_CPU_FLAG_ARMV6, "armv6" },
- { AV_CPU_FLAG_ARMV6T2, "armv6t2" },
- { AV_CPU_FLAG_VFP, "vfp" },
- { AV_CPU_FLAG_VFP_VM, "vfp_vm" },
- { AV_CPU_FLAG_VFPV3, "vfpv3" },
- { AV_CPU_FLAG_NEON, "neon" },
- { AV_CPU_FLAG_SETEND, "setend" },
-#elif ARCH_PPC
- { AV_CPU_FLAG_ALTIVEC, "altivec" },
-#elif ARCH_X86
- { AV_CPU_FLAG_MMX, "mmx" },
- { AV_CPU_FLAG_MMXEXT, "mmxext" },
- { AV_CPU_FLAG_SSE, "sse" },
- { AV_CPU_FLAG_SSE2, "sse2" },
- { AV_CPU_FLAG_SSE2SLOW, "sse2slow" },
- { AV_CPU_FLAG_SSE3, "sse3" },
- { AV_CPU_FLAG_SSE3SLOW, "sse3slow" },
- { AV_CPU_FLAG_SSSE3, "ssse3" },
- { AV_CPU_FLAG_ATOM, "atom" },
- { AV_CPU_FLAG_SSE4, "sse4.1" },
- { AV_CPU_FLAG_SSE42, "sse4.2" },
- { AV_CPU_FLAG_AVX, "avx" },
- { AV_CPU_FLAG_AVXSLOW, "avxslow" },
- { AV_CPU_FLAG_XOP, "xop" },
- { AV_CPU_FLAG_FMA3, "fma3" },
- { AV_CPU_FLAG_FMA4, "fma4" },
- { AV_CPU_FLAG_3DNOW, "3dnow" },
- { AV_CPU_FLAG_3DNOWEXT, "3dnowext" },
- { AV_CPU_FLAG_CMOV, "cmov" },
- { AV_CPU_FLAG_AVX2, "avx2" },
- { AV_CPU_FLAG_BMI1, "bmi1" },
- { AV_CPU_FLAG_BMI2, "bmi2" },
- { AV_CPU_FLAG_AESNI, "aesni" },
-#endif
- { 0 }
-};
-
-static void print_cpu_flags(int cpu_flags, const char *type)
-{
- int i;
-
- printf("cpu_flags(%s) = 0x%08X\n", type, cpu_flags);
- printf("cpu_flags_str(%s) =", type);
- for (i = 0; cpu_flag_tab[i].flag; i++)
- if (cpu_flags & cpu_flag_tab[i].flag)
- printf(" %s", cpu_flag_tab[i].name);
- printf("\n");
-}
-
-
-int main(int argc, char **argv)
-{
- int cpu_flags_raw = av_get_cpu_flags();
- int cpu_flags_eff;
- int cpu_count = av_cpu_count();
- char threads[5] = "auto";
- int i;
-
- for(i = 0; cpu_flag_tab[i].flag; i++) {
- unsigned tmp = 0;
- if (av_parse_cpu_caps(&tmp, cpu_flag_tab[i].name) < 0) {
- fprintf(stderr, "Table missing %s\n", cpu_flag_tab[i].name);
- return 4;
- }
- }
-
- if (cpu_flags_raw < 0)
- return 1;
-
- for (;;) {
- int c = getopt(argc, argv, "c:t:");
- if (c == -1)
- break;
- switch (c) {
- case 'c':
- {
- unsigned flags = av_get_cpu_flags();
- if (av_parse_cpu_caps(&flags, optarg) < 0)
- return 2;
-
- av_force_cpu_flags(flags);
- break;
- }
- case 't':
- {
- int len = av_strlcpy(threads, optarg, sizeof(threads));
- if (len >= sizeof(threads)) {
- fprintf(stderr, "Invalid thread count '%s'\n", optarg);
- return 2;
- }
- }
- }
- }
-
- cpu_flags_eff = av_get_cpu_flags();
-
- if (cpu_flags_eff < 0)
- return 3;
-
- print_cpu_flags(cpu_flags_raw, "raw");
- print_cpu_flags(cpu_flags_eff, "effective");
- printf("threads = %s (cpu_count = %d)\n", threads, cpu_count);
-
- return 0;
-}
-
-#endif
diff --git a/libavutil/crc-test.c b/libavutil/crc-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..3c250df91937a0e1ccdf1c0464bdefbb27d63f48
--- /dev/null
+++ b/libavutil/crc-test.c
@@ -0,0 +1,46 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+
+#include "crc.h"
+
+int main(void)
+{
+ uint8_t buf[1999];
+ int i;
+ unsigned p[6][3] = {
+ { AV_CRC_32_IEEE_LE, 0xEDB88320, 0x3D5CDD04 },
+ { AV_CRC_32_IEEE , 0x04C11DB7, 0xC0F5BAE0 },
+ { AV_CRC_24_IEEE , 0x864CFB , 0xB704CE },
+ { AV_CRC_16_ANSI_LE, 0xA001 , 0xBFD8 },
+ { AV_CRC_16_ANSI , 0x8005 , 0x1FBB },
+ { AV_CRC_8_ATM , 0x07 , 0xE3 }
+ };
+ const AVCRC *ctx;
+
+ for (i = 0; i < sizeof(buf); i++)
+ buf[i] = i + i * i;
+
+ for (i = 0; i < 6; i++) {
+ ctx = av_crc_get_table(p[i][0]);
+ printf("crc %08X = %X\n", p[i][1], av_crc(ctx, 0, buf, sizeof(buf)));
+ }
+ return 0;
+}
diff --git a/libavutil/crc.c b/libavutil/crc.c
index 8d9cb326bc09a73364a8192c44f93f621e3ea0e6..495732b1636b73c4ad54a6cff9d3b962a69d0288 100644
--- a/libavutil/crc.c
+++ b/libavutil/crc.c
@@ -378,29 +378,3 @@ uint32_t av_crc(const AVCRC *ctx, uint32_t crc,
return crc;
}
-
-#ifdef TEST
-int main(void)
-{
- uint8_t buf[1999];
- int i;
- unsigned p[6][3] = {
- { AV_CRC_32_IEEE_LE, 0xEDB88320, 0x3D5CDD04 },
- { AV_CRC_32_IEEE , 0x04C11DB7, 0xC0F5BAE0 },
- { AV_CRC_24_IEEE , 0x864CFB , 0xB704CE },
- { AV_CRC_16_ANSI_LE, 0xA001 , 0xBFD8 },
- { AV_CRC_16_ANSI , 0x8005 , 0x1FBB },
- { AV_CRC_8_ATM , 0x07 , 0xE3 }
- };
- const AVCRC *ctx;
-
- for (i = 0; i < sizeof(buf); i++)
- buf[i] = i + i * i;
-
- for (i = 0; i < 6; i++) {
- ctx = av_crc_get_table(p[i][0]);
- printf("crc %08X = %X\n", p[i][1], av_crc(ctx, 0, buf, sizeof(buf)));
- }
- return 0;
-}
-#endif
diff --git a/libavutil/des-test.c b/libavutil/des-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..99453af6a734169288e6a970b6fc5e9ccd5f0407
--- /dev/null
+++ b/libavutil/des-test.c
@@ -0,0 +1,128 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "des.c"
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "time.h"
+
+static uint64_t rand64(void)
+{
+ uint64_t r = rand();
+ r = (r << 32) | rand();
+ return r;
+}
+
+static const uint8_t test_key[] = { 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0 };
+static const DECLARE_ALIGNED(8, uint8_t, plain)[] = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
+static const DECLARE_ALIGNED(8, uint8_t, crypt)[] = { 0x4a, 0xb6, 0x5b, 0x3d, 0x4b, 0x06, 0x15, 0x18 };
+static DECLARE_ALIGNED(8, uint8_t, tmp)[8];
+static DECLARE_ALIGNED(8, uint8_t, large_buffer)[10002][8];
+static const uint8_t cbc_key[] = {
+ 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
+ 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01,
+ 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x23
+};
+
+static int run_test(int cbc, int decrypt)
+{
+ AVDES d;
+ int delay = cbc && !decrypt ? 2 : 1;
+ uint64_t res;
+ AV_WB64(large_buffer[0], 0x4e6f772069732074ULL);
+ AV_WB64(large_buffer[1], 0x1234567890abcdefULL);
+ AV_WB64(tmp, 0x1234567890abcdefULL);
+ av_des_init(&d, cbc_key, 192, decrypt);
+ av_des_crypt(&d, large_buffer[delay], large_buffer[0], 10000, cbc ? tmp : NULL, decrypt);
+ res = AV_RB64(large_buffer[9999 + delay]);
+ if (cbc) {
+ if (decrypt)
+ return res == 0xc5cecf63ecec514cULL;
+ else
+ return res == 0xcb191f85d1ed8439ULL;
+ } else {
+ if (decrypt)
+ return res == 0x8325397644091a0aULL;
+ else
+ return res == 0xdd17e8b8b437d232ULL;
+ }
+}
+
+int main(void)
+{
+ AVDES d;
+ int i;
+ uint64_t key[3];
+ uint64_t data;
+ uint64_t ct;
+ uint64_t roundkeys[16];
+ srand(av_gettime());
+ key[0] = AV_RB64(test_key);
+ data = AV_RB64(plain);
+ gen_roundkeys(roundkeys, key[0]);
+ if (des_encdec(data, roundkeys, 0) != AV_RB64(crypt)) {
+ printf("Test 1 failed\n");
+ return 1;
+ }
+ av_des_init(&d, test_key, 64, 0);
+ av_des_crypt(&d, tmp, plain, 1, NULL, 0);
+ if (memcmp(tmp, crypt, sizeof(crypt))) {
+ printf("Public API decryption failed\n");
+ return 1;
+ }
+ if (!run_test(0, 0) || !run_test(0, 1) || !run_test(1, 0) || !run_test(1, 1)) {
+ printf("Partial Monte-Carlo test failed\n");
+ return 1;
+ }
+ for (i = 0; i < 1000; i++) {
+ key[0] = rand64();
+ key[1] = rand64();
+ key[2] = rand64();
+ data = rand64();
+ av_des_init(&d, (uint8_t *) key, 192, 0);
+ av_des_crypt(&d, (uint8_t *) &ct, (uint8_t *) &data, 1, NULL, 0);
+ av_des_init(&d, (uint8_t *) key, 192, 1);
+ av_des_crypt(&d, (uint8_t *) &ct, (uint8_t *) &ct, 1, NULL, 1);
+ if (ct != data) {
+ printf("Test 2 failed\n");
+ return 1;
+ }
+ }
+#ifdef GENTABLES
+ printf("static const uint32_t S_boxes_P_shuffle[8][64] = {\n");
+ for (i = 0; i < 8; i++) {
+ int j;
+ printf(" {");
+ for (j = 0; j < 64; j++) {
+ uint32_t v = S_boxes[i][j >> 1];
+ v = j & 1 ? v >> 4 : v & 0xf;
+ v <<= 28 - 4 * i;
+ v = shuffle(v, P_shuffle, sizeof(P_shuffle));
+ printf((j & 7) == 0 ? "\n " : " ");
+ printf("0x%08X,", v);
+ }
+ printf("\n },\n");
+ }
+ printf("};\n");
+#endif
+ return 0;
+}
diff --git a/libavutil/des.c b/libavutil/des.c
index 25f3b6f517cf23d1b92de789061e34aaa539bf17..d3750952730bdc50e7f3195212683d966217c97d 100644
--- a/libavutil/des.c
+++ b/libavutil/des.c
@@ -104,7 +104,7 @@ static const uint8_t S_boxes[8][32] = {
#else
/**
* This table contains the results of applying both the S-box and P-shuffle.
- * It can be regenerated by compiling this file with -DCONFIG_SMALL -DTEST -DGENTABLES
+ * It can be regenerated by compiling des-test.c with "-DCONFIG_SMALL -DGENTABLES".
*/
static const uint32_t S_boxes_P_shuffle[8][64] = {
{ 0x00808200, 0x00000000, 0x00008000, 0x00808202, 0x00808002, 0x00008202, 0x00000002, 0x00008000,
@@ -329,112 +329,3 @@ void av_des_mac(AVDES *d, uint8_t *dst, const uint8_t *src, int count)
{
av_des_crypt_mac(d, dst, src, count, (uint8_t[8]) { 0 }, 0, 1);
}
-
-#ifdef TEST
-#include <stdlib.h>
-#include <stdio.h>
-
-#include "time.h"
-
-static uint64_t rand64(void)
-{
- uint64_t r = rand();
- r = (r << 32) | rand();
- return r;
-}
-
-static const uint8_t test_key[] = { 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0 };
-static const DECLARE_ALIGNED(8, uint8_t, plain)[] = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
-static const DECLARE_ALIGNED(8, uint8_t, crypt)[] = { 0x4a, 0xb6, 0x5b, 0x3d, 0x4b, 0x06, 0x15, 0x18 };
-static DECLARE_ALIGNED(8, uint8_t, tmp)[8];
-static DECLARE_ALIGNED(8, uint8_t, large_buffer)[10002][8];
-static const uint8_t cbc_key[] = {
- 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
- 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01,
- 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x23
-};
-
-static int run_test(int cbc, int decrypt)
-{
- AVDES d;
- int delay = cbc && !decrypt ? 2 : 1;
- uint64_t res;
- AV_WB64(large_buffer[0], 0x4e6f772069732074ULL);
- AV_WB64(large_buffer[1], 0x1234567890abcdefULL);
- AV_WB64(tmp, 0x1234567890abcdefULL);
- av_des_init(&d, cbc_key, 192, decrypt);
- av_des_crypt(&d, large_buffer[delay], large_buffer[0], 10000, cbc ? tmp : NULL, decrypt);
- res = AV_RB64(large_buffer[9999 + delay]);
- if (cbc) {
- if (decrypt)
- return res == 0xc5cecf63ecec514cULL;
- else
- return res == 0xcb191f85d1ed8439ULL;
- } else {
- if (decrypt)
- return res == 0x8325397644091a0aULL;
- else
- return res == 0xdd17e8b8b437d232ULL;
- }
-}
-
-int main(void)
-{
- AVDES d;
- int i;
- uint64_t key[3];
- uint64_t data;
- uint64_t ct;
- uint64_t roundkeys[16];
- srand(av_gettime());
- key[0] = AV_RB64(test_key);
- data = AV_RB64(plain);
- gen_roundkeys(roundkeys, key[0]);
- if (des_encdec(data, roundkeys, 0) != AV_RB64(crypt)) {
- printf("Test 1 failed\n");
- return 1;
- }
- av_des_init(&d, test_key, 64, 0);
- av_des_crypt(&d, tmp, plain, 1, NULL, 0);
- if (memcmp(tmp, crypt, sizeof(crypt))) {
- printf("Public API decryption failed\n");
- return 1;
- }
- if (!run_test(0, 0) || !run_test(0, 1) || !run_test(1, 0) || !run_test(1, 1)) {
- printf("Partial Monte-Carlo test failed\n");
- return 1;
- }
- for (i = 0; i < 1000; i++) {
- key[0] = rand64();
- key[1] = rand64();
- key[2] = rand64();
- data = rand64();
- av_des_init(&d, (uint8_t *) key, 192, 0);
- av_des_crypt(&d, (uint8_t *) &ct, (uint8_t *) &data, 1, NULL, 0);
- av_des_init(&d, (uint8_t *) key, 192, 1);
- av_des_crypt(&d, (uint8_t *) &ct, (uint8_t *) &ct, 1, NULL, 1);
- if (ct != data) {
- printf("Test 2 failed\n");
- return 1;
- }
- }
-#ifdef GENTABLES
- printf("static const uint32_t S_boxes_P_shuffle[8][64] = {\n");
- for (i = 0; i < 8; i++) {
- int j;
- printf(" {");
- for (j = 0; j < 64; j++) {
- uint32_t v = S_boxes[i][j >> 1];
- v = j & 1 ? v >> 4 : v & 0xf;
- v <<= 28 - 4 * i;
- v = shuffle(v, P_shuffle, sizeof(P_shuffle));
- printf((j & 7) == 0 ? "\n " : " ");
- printf("0x%08X,", v);
- }
- printf("\n },\n");
- }
- printf("};\n");
-#endif
- return 0;
-}
-#endif
diff --git a/libavutil/dict-test.c b/libavutil/dict-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..e40b57885f6e1ccf34d0a7b0fe2c2e9a4a4a9183
--- /dev/null
+++ b/libavutil/dict-test.c
@@ -0,0 +1,133 @@
+/*
+ * copyright (c) 2009 Michael Niedermayer
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "dict.c"
+
+static void print_dict(const AVDictionary *m)
+{
+ AVDictionaryEntry *t = NULL;
+ while ((t = av_dict_get(m, "", t, AV_DICT_IGNORE_SUFFIX)))
+ printf("%s %s ", t->key, t->value);
+ printf("\n");
+}
+
+static void test_separators(const AVDictionary *m, const char pair, const char val)
+{
+ AVDictionary *dict = NULL;
+ char pairs[] = {pair , '\0'};
+ char vals[] = {val, '\0'};
+
+ char *buffer = NULL;
+ av_dict_copy(&dict, m, 0);
+ print_dict(dict);
+ av_dict_get_string(dict, &buffer, val, pair);
+ printf("%s\n", buffer);
+ av_dict_free(&dict);
+ av_dict_parse_string(&dict, buffer, vals, pairs, 0);
+ av_freep(&buffer);
+ print_dict(dict);
+ av_dict_free(&dict);
+}
+
+int main(void)
+{
+ AVDictionary *dict = NULL;
+ AVDictionaryEntry *e;
+ char *buffer = NULL;
+
+ printf("Testing av_dict_get_string() and av_dict_parse_string()\n");
+ av_dict_get_string(dict, &buffer, '=', ',');
+ printf("%s\n", buffer);
+ av_freep(&buffer);
+ av_dict_set(&dict, "aaa", "aaa", 0);
+ av_dict_set(&dict, "b,b", "bbb", 0);
+ av_dict_set(&dict, "c=c", "ccc", 0);
+ av_dict_set(&dict, "ddd", "d,d", 0);
+ av_dict_set(&dict, "eee", "e=e", 0);
+ av_dict_set(&dict, "f,f", "f=f", 0);
+ av_dict_set(&dict, "g=g", "g,g", 0);
+ test_separators(dict, ',', '=');
+ av_dict_free(&dict);
+ av_dict_set(&dict, "aaa", "aaa", 0);
+ av_dict_set(&dict, "bbb", "bbb", 0);
+ av_dict_set(&dict, "ccc", "ccc", 0);
+ av_dict_set(&dict, "\\,=\'\"", "\\,=\'\"", 0);
+ test_separators(dict, '"', '=');
+ test_separators(dict, '\'', '=');
+ test_separators(dict, ',', '"');
+ test_separators(dict, ',', '\'');
+ test_separators(dict, '\'', '"');
+ test_separators(dict, '"', '\'');
+ av_dict_free(&dict);
+
+ printf("\nTesting av_dict_set()\n");
+ av_dict_set(&dict, "a", "a", 0);
+ av_dict_set(&dict, "b", av_strdup("b"), AV_DICT_DONT_STRDUP_VAL);
+ av_dict_set(&dict, av_strdup("c"), "c", AV_DICT_DONT_STRDUP_KEY);
+ av_dict_set(&dict, av_strdup("d"), av_strdup("d"), AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL);
+ av_dict_set(&dict, "e", "e", AV_DICT_DONT_OVERWRITE);
+ av_dict_set(&dict, "e", "f", AV_DICT_DONT_OVERWRITE);
+ av_dict_set(&dict, "f", "f", 0);
+ av_dict_set(&dict, "f", NULL, 0);
+ av_dict_set(&dict, "ff", "f", 0);
+ av_dict_set(&dict, "ff", "f", AV_DICT_APPEND);
+ e = NULL;
+ while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX)))
+ printf("%s %s\n", e->key, e->value);
+ av_dict_free(&dict);
+
+ av_dict_set(&dict, NULL, "a", 0);
+ av_dict_set(&dict, NULL, "b", 0);
+ av_dict_get(dict, NULL, NULL, 0);
+ e = NULL;
+ while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX)))
+ printf("'%s' '%s'\n", e->key, e->value);
+ av_dict_free(&dict);
+
+
+ //valgrind sensible test
+ printf("\nTesting av_dict_set_int()\n");
+ av_dict_set_int(&dict, "1", 1, AV_DICT_DONT_STRDUP_VAL);
+ av_dict_set_int(&dict, av_strdup("2"), 2, AV_DICT_DONT_STRDUP_KEY);
+ av_dict_set_int(&dict, av_strdup("3"), 3, AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL);
+ av_dict_set_int(&dict, "4", 4, 0);
+ av_dict_set_int(&dict, "5", 5, AV_DICT_DONT_OVERWRITE);
+ av_dict_set_int(&dict, "5", 6, AV_DICT_DONT_OVERWRITE);
+ av_dict_set_int(&dict, "12", 1, 0);
+ av_dict_set_int(&dict, "12", 2, AV_DICT_APPEND);
+ e = NULL;
+ while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX)))
+ printf("%s %s\n", e->key, e->value);
+ av_dict_free(&dict);
+
+ //valgrind sensible test
+ printf("\nTesting av_dict_set() with existing AVDictionaryEntry.key as key\n");
+ av_dict_set(&dict, "key", "old", 0);
+ e = av_dict_get(dict, "key", NULL, 0);
+ av_dict_set(&dict, e->key, "new val OK", 0);
+ e = av_dict_get(dict, "key", NULL, 0);
+ printf("%s\n", e->value);
+ av_dict_set(&dict, e->key, e->value, 0);
+ e = av_dict_get(dict, "key", NULL, 0);
+ printf("%s\n", e->value);
+ av_dict_free(&dict);
+
+ return 0;
+}
diff --git a/libavutil/dict.c b/libavutil/dict.c
index 3b509a41c707093fb66fb10d663e708b32899bd5..f70c7e0051034d8adbef984c719b570038b78ad8 100644
--- a/libavutil/dict.c
+++ b/libavutil/dict.c
@@ -253,117 +253,3 @@ int av_dict_get_string(const AVDictionary *m, char **buffer,
}
return av_bprint_finalize(&bprint, buffer);
}
-
-#ifdef TEST
-static void print_dict(const AVDictionary *m)
-{
- AVDictionaryEntry *t = NULL;
- while ((t = av_dict_get(m, "", t, AV_DICT_IGNORE_SUFFIX)))
- printf("%s %s ", t->key, t->value);
- printf("\n");
-}
-
-static void test_separators(const AVDictionary *m, const char pair, const char val)
-{
- AVDictionary *dict = NULL;
- char pairs[] = {pair , '\0'};
- char vals[] = {val, '\0'};
-
- char *buffer = NULL;
- av_dict_copy(&dict, m, 0);
- print_dict(dict);
- av_dict_get_string(dict, &buffer, val, pair);
- printf("%s\n", buffer);
- av_dict_free(&dict);
- av_dict_parse_string(&dict, buffer, vals, pairs, 0);
- av_freep(&buffer);
- print_dict(dict);
- av_dict_free(&dict);
-}
-
-int main(void)
-{
- AVDictionary *dict = NULL;
- AVDictionaryEntry *e;
- char *buffer = NULL;
-
- printf("Testing av_dict_get_string() and av_dict_parse_string()\n");
- av_dict_get_string(dict, &buffer, '=', ',');
- printf("%s\n", buffer);
- av_freep(&buffer);
- av_dict_set(&dict, "aaa", "aaa", 0);
- av_dict_set(&dict, "b,b", "bbb", 0);
- av_dict_set(&dict, "c=c", "ccc", 0);
- av_dict_set(&dict, "ddd", "d,d", 0);
- av_dict_set(&dict, "eee", "e=e", 0);
- av_dict_set(&dict, "f,f", "f=f", 0);
- av_dict_set(&dict, "g=g", "g,g", 0);
- test_separators(dict, ',', '=');
- av_dict_free(&dict);
- av_dict_set(&dict, "aaa", "aaa", 0);
- av_dict_set(&dict, "bbb", "bbb", 0);
- av_dict_set(&dict, "ccc", "ccc", 0);
- av_dict_set(&dict, "\\,=\'\"", "\\,=\'\"", 0);
- test_separators(dict, '"', '=');
- test_separators(dict, '\'', '=');
- test_separators(dict, ',', '"');
- test_separators(dict, ',', '\'');
- test_separators(dict, '\'', '"');
- test_separators(dict, '"', '\'');
- av_dict_free(&dict);
-
- printf("\nTesting av_dict_set()\n");
- av_dict_set(&dict, "a", "a", 0);
- av_dict_set(&dict, "b", av_strdup("b"), AV_DICT_DONT_STRDUP_VAL);
- av_dict_set(&dict, av_strdup("c"), "c", AV_DICT_DONT_STRDUP_KEY);
- av_dict_set(&dict, av_strdup("d"), av_strdup("d"), AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL);
- av_dict_set(&dict, "e", "e", AV_DICT_DONT_OVERWRITE);
- av_dict_set(&dict, "e", "f", AV_DICT_DONT_OVERWRITE);
- av_dict_set(&dict, "f", "f", 0);
- av_dict_set(&dict, "f", NULL, 0);
- av_dict_set(&dict, "ff", "f", 0);
- av_dict_set(&dict, "ff", "f", AV_DICT_APPEND);
- e = NULL;
- while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX)))
- printf("%s %s\n", e->key, e->value);
- av_dict_free(&dict);
-
- av_dict_set(&dict, NULL, "a", 0);
- av_dict_set(&dict, NULL, "b", 0);
- av_dict_get(dict, NULL, NULL, 0);
- e = NULL;
- while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX)))
- printf("'%s' '%s'\n", e->key, e->value);
- av_dict_free(&dict);
-
-
- //valgrind sensible test
- printf("\nTesting av_dict_set_int()\n");
- av_dict_set_int(&dict, "1", 1, AV_DICT_DONT_STRDUP_VAL);
- av_dict_set_int(&dict, av_strdup("2"), 2, AV_DICT_DONT_STRDUP_KEY);
- av_dict_set_int(&dict, av_strdup("3"), 3, AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL);
- av_dict_set_int(&dict, "4", 4, 0);
- av_dict_set_int(&dict, "5", 5, AV_DICT_DONT_OVERWRITE);
- av_dict_set_int(&dict, "5", 6, AV_DICT_DONT_OVERWRITE);
- av_dict_set_int(&dict, "12", 1, 0);
- av_dict_set_int(&dict, "12", 2, AV_DICT_APPEND);
- e = NULL;
- while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX)))
- printf("%s %s\n", e->key, e->value);
- av_dict_free(&dict);
-
- //valgrind sensible test
- printf("\nTesting av_dict_set() with existing AVDictionaryEntry.key as key\n");
- av_dict_set(&dict, "key", "old", 0);
- e = av_dict_get(dict, "key", NULL, 0);
- av_dict_set(&dict, e->key, "new val OK", 0);
- e = av_dict_get(dict, "key", NULL, 0);
- printf("%s\n", e->value);
- av_dict_set(&dict, e->key, e->value, 0);
- e = av_dict_get(dict, "key", NULL, 0);
- printf("%s\n", e->value);
- av_dict_free(&dict);
-
- return 0;
-}
-#endif
diff --git a/libavutil/display-test.c b/libavutil/display-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..b42ab893a8f58018f58349d75847c2ea1c0e1d68
--- /dev/null
+++ b/libavutil/display-test.c
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2014 Vittorio Giovara <vittorio.giovara@gmail.com>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "display.c"
+
+static void print_matrix(int32_t matrix[9])
+{
+ int i, j;
+
+ for (i = 0; i < 3; ++i) {
+ for (j = 0; j < 3 - 1; ++j)
+ printf("%d ", matrix[i*3 + j]);
+
+ printf("%d\n", matrix[i*3 + j]);
+ }
+}
+
+int main(void)
+{
+ int32_t matrix[9];
+
+ // Set the matrix to 90 degrees
+ av_display_rotation_set(matrix, 90);
+ print_matrix(matrix);
+ printf("degrees: %f\n", av_display_rotation_get(matrix));
+
+ // Set the matrix to -45 degrees
+ av_display_rotation_set(matrix, -45);
+ print_matrix(matrix);
+ printf("degrees: %f\n", av_display_rotation_get(matrix));
+
+ // flip horizontal
+ av_display_matrix_flip(matrix, 1, 0);
+ print_matrix(matrix);
+ printf("degrees: %f\n", av_display_rotation_get(matrix));
+
+ // flip vertical
+ av_display_matrix_flip(matrix, 0, 1);
+ print_matrix(matrix);
+ printf("degrees: %f\n", av_display_rotation_get(matrix));
+
+ return 0;
+
+}
diff --git a/libavutil/display.c b/libavutil/display.c
index ceed49275667625cdba330f34ce0163f549f738f..a0076e067bb3152fa4d12658c919b63d564c2152 100644
--- a/libavutil/display.c
+++ b/libavutil/display.c
@@ -71,46 +71,3 @@ void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip)
for (i = 0; i < 9; i++)
matrix[i] *= flip[i % 3];
}
-
-#ifdef TEST
-
-static void print_matrix(int32_t matrix[9])
-{
- int i, j;
-
- for (i = 0; i < 3; ++i) {
- for (j = 0; j < 3 - 1; ++j)
- printf("%d ", matrix[i*3 + j]);
-
- printf("%d\n", matrix[i*3 + j]);
- }
-}
-
-int main(void)
-{
- int32_t matrix[9];
-
- // Set the matrix to 90 degrees
- av_display_rotation_set(matrix, 90);
- print_matrix(matrix);
- printf("degrees: %f\n", av_display_rotation_get(matrix));
-
- // Set the matrix to -45 degrees
- av_display_rotation_set(matrix, -45);
- print_matrix(matrix);
- printf("degrees: %f\n", av_display_rotation_get(matrix));
-
- // flip horizontal
- av_display_matrix_flip(matrix, 1, 0);
- print_matrix(matrix);
- printf("degrees: %f\n", av_display_rotation_get(matrix));
-
- // flip vertical
- av_display_matrix_flip(matrix, 0, 1);
- print_matrix(matrix);
- printf("degrees: %f\n", av_display_rotation_get(matrix));
-
- return 0;
-
-}
-#endif
diff --git a/libavutil/error-test.c b/libavutil/error-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..36240daa4e856e927629baeb3a3ffc762ae7066f
--- /dev/null
+++ b/libavutil/error-test.c
@@ -0,0 +1,37 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "error.c"
+
+#undef printf
+
+int main(void)
+{
+ int i;
+
+ for (i = 0; i < FF_ARRAY_ELEMS(error_entries); i++) {
+ const struct error_entry *entry = &error_entries[i];
+ printf("%d: %s [%s]\n", entry->num, av_err2str(entry->num), entry->tag);
+ }
+
+ for (i = 0; i < 256; i++) {
+ printf("%d: %s\n", -i, av_err2str(-i));
+ }
+
+ return 0;
+}
diff --git a/libavutil/error.c b/libavutil/error.c
index 8df73dbc23e968e69a122d94df849c7d933f45d9..b96304837bb7685841a01da3c8100ec90b087bde 100644
--- a/libavutil/error.c
+++ b/libavutil/error.c
@@ -127,25 +127,3 @@ int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
return ret;
}
-
-#ifdef TEST
-
-#undef printf
-
-int main(void)
-{
- int i;
-
- for (i = 0; i < FF_ARRAY_ELEMS(error_entries); i++) {
- const struct error_entry *entry = &error_entries[i];
- printf("%d: %s [%s]\n", entry->num, av_err2str(entry->num), entry->tag);
- }
-
- for (i = 0; i < 256; i++) {
- printf("%d: %s\n", -i, av_err2str(-i));
- }
-
- return 0;
-}
-
-#endif /* TEST */
diff --git a/libavutil/eval-test.c b/libavutil/eval-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..7646e4db619619b16d93e83dbb481b8ea0dad889
--- /dev/null
+++ b/libavutil/eval-test.c
@@ -0,0 +1,173 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "timer.h"
+#include "eval.h"
+
+static const double const_values[] = {
+ M_PI,
+ M_E,
+ 0
+};
+
+static const char *const const_names[] = {
+ "PI",
+ "E",
+ 0
+};
+
+int main(int argc, char **argv)
+{
+ int i;
+ double d;
+ const char *const *expr;
+ static const char *const exprs[] = {
+ "",
+ "1;2",
+ "-20",
+ "-PI",
+ "+PI",
+ "1+(5-2)^(3-1)+1/2+sin(PI)-max(-2.2,-3.1)",
+ "80G/80Gi",
+ "1k",
+ "1Gi",
+ "1gi",
+ "1GiFoo",
+ "1k+1k",
+ "1Gi*3foo",
+ "foo",
+ "foo(",
+ "foo()",
+ "foo)",
+ "sin",
+ "sin(",
+ "sin()",
+ "sin)",
+ "sin 10",
+ "sin(1,2,3)",
+ "sin(1 )",
+ "1",
+ "1foo",
+ "bar + PI + E + 100f*2 + foo",
+ "13k + 12f - foo(1, 2)",
+ "1gi",
+ "1Gi",
+ "st(0, 123)",
+ "st(1, 123); ld(1)",
+ "lte(0, 1)",
+ "lte(1, 1)",
+ "lte(1, 0)",
+ "lt(0, 1)",
+ "lt(1, 1)",
+ "gt(1, 0)",
+ "gt(2, 7)",
+ "gte(122, 122)",
+ /* compute 1+2+...+N */
+ "st(0, 1); while(lte(ld(0), 100), st(1, ld(1)+ld(0));st(0, ld(0)+1)); ld(1)",
+ /* compute Fib(N) */
+ "st(1, 1); st(2, 2); st(0, 1); while(lte(ld(0),10), st(3, ld(1)+ld(2)); st(1, ld(2)); st(2, ld(3)); st(0, ld(0)+1)); ld(3)",
+ "while(0, 10)",
+ "st(0, 1); while(lte(ld(0),100), st(1, ld(1)+ld(0)); st(0, ld(0)+1))",
+ "isnan(1)",
+ "isnan(NAN)",
+ "isnan(INF)",
+ "isinf(1)",
+ "isinf(NAN)",
+ "isinf(INF)",
+ "floor(NAN)",
+ "floor(123.123)",
+ "floor(-123.123)",
+ "trunc(123.123)",
+ "trunc(-123.123)",
+ "ceil(123.123)",
+ "ceil(-123.123)",
+ "sqrt(1764)",
+ "isnan(sqrt(-1))",
+ "not(1)",
+ "not(NAN)",
+ "not(0)",
+ "6.0206dB",
+ "-3.0103dB",
+ "pow(0,1.23)",
+ "pow(PI,1.23)",
+ "PI^1.23",
+ "pow(-1,1.23)",
+ "if(1, 2)",
+ "if(1, 1, 2)",
+ "if(0, 1, 2)",
+ "ifnot(0, 23)",
+ "ifnot(1, NaN) + if(0, 1)",
+ "ifnot(1, 1, 2)",
+ "ifnot(0, 1, 2)",
+ "taylor(1, 1)",
+ "taylor(eq(mod(ld(1),4),1)-eq(mod(ld(1),4),3), PI/2, 1)",
+ "root(sin(ld(0))-1, 2)",
+ "root(sin(ld(0))+6+sin(ld(0)/12)-log(ld(0)), 100)",
+ "7000000B*random(0)",
+ "squish(2)",
+ "gauss(0.1)",
+ "hypot(4,3)",
+ "gcd(30,55)*print(min(9,1))",
+ "bitor(42, 12)",
+ "bitand(42, 12)",
+ "bitand(NAN, 1)",
+ "between(10, -3, 10)",
+ "between(-4, -2, -1)",
+ "between(1,2)",
+ "clip(0, 2, 1)",
+ "clip(0/0, 1, 2)",
+ "clip(0, 0/0, 1)",
+ NULL
+ };
+
+ for (expr = exprs; *expr; expr++) {
+ printf("Evaluating '%s'\n", *expr);
+ av_expr_parse_and_eval(&d, *expr,
+ const_names, const_values,
+ NULL, NULL, NULL, NULL, NULL, 0, NULL);
+ if (isnan(d))
+ printf("'%s' -> nan\n\n", *expr);
+ else
+ printf("'%s' -> %f\n\n", *expr, d);
+ }
+
+ av_expr_parse_and_eval(&d, "1+(5-2)^(3-1)+1/2+sin(PI)-max(-2.2,-3.1)",
+ const_names, const_values,
+ NULL, NULL, NULL, NULL, NULL, 0, NULL);
+ printf("%f == 12.7\n", d);
+ av_expr_parse_and_eval(&d, "80G/80Gi",
+ const_names, const_values,
+ NULL, NULL, NULL, NULL, NULL, 0, NULL);
+ printf("%f == 0.931322575\n", d);
+
+ if (argc > 1 && !strcmp(argv[1], "-t")) {
+ for (i = 0; i < 1050; i++) {
+ START_TIMER;
+ av_expr_parse_and_eval(&d, "1+(5-2)^(3-1)+1/2+sin(PI)-max(-2.2,-3.1)",
+ const_names, const_values,
+ NULL, NULL, NULL, NULL, NULL, 0, NULL);
+ STOP_TIMER("av_expr_parse_and_eval");
+ }
+ }
+
+ return 0;
+}
diff --git a/libavutil/eval.c b/libavutil/eval.c
index 37b8511845b5112f39a6e94f60eebe2c7f8a55e5..d291c5d6d50f84b7787beeea067613c022384de0 100644
--- a/libavutil/eval.c
+++ b/libavutil/eval.c
@@ -737,156 +737,3 @@ int av_expr_parse_and_eval(double *d, const char *s,
av_expr_free(e);
return isnan(*d) ? AVERROR(EINVAL) : 0;
}
-
-#ifdef TEST
-#include <string.h>
-
-static const double const_values[] = {
- M_PI,
- M_E,
- 0
-};
-
-static const char *const const_names[] = {
- "PI",
- "E",
- 0
-};
-
-int main(int argc, char **argv)
-{
- int i;
- double d;
- const char *const *expr;
- static const char *const exprs[] = {
- "",
- "1;2",
- "-20",
- "-PI",
- "+PI",
- "1+(5-2)^(3-1)+1/2+sin(PI)-max(-2.2,-3.1)",
- "80G/80Gi",
- "1k",
- "1Gi",
- "1gi",
- "1GiFoo",
- "1k+1k",
- "1Gi*3foo",
- "foo",
- "foo(",
- "foo()",
- "foo)",
- "sin",
- "sin(",
- "sin()",
- "sin)",
- "sin 10",
- "sin(1,2,3)",
- "sin(1 )",
- "1",
- "1foo",
- "bar + PI + E + 100f*2 + foo",
- "13k + 12f - foo(1, 2)",
- "1gi",
- "1Gi",
- "st(0, 123)",
- "st(1, 123); ld(1)",
- "lte(0, 1)",
- "lte(1, 1)",
- "lte(1, 0)",
- "lt(0, 1)",
- "lt(1, 1)",
- "gt(1, 0)",
- "gt(2, 7)",
- "gte(122, 122)",
- /* compute 1+2+...+N */
- "st(0, 1); while(lte(ld(0), 100), st(1, ld(1)+ld(0));st(0, ld(0)+1)); ld(1)",
- /* compute Fib(N) */
- "st(1, 1); st(2, 2); st(0, 1); while(lte(ld(0),10), st(3, ld(1)+ld(2)); st(1, ld(2)); st(2, ld(3)); st(0, ld(0)+1)); ld(3)",
- "while(0, 10)",
- "st(0, 1); while(lte(ld(0),100), st(1, ld(1)+ld(0)); st(0, ld(0)+1))",
- "isnan(1)",
- "isnan(NAN)",
- "isnan(INF)",
- "isinf(1)",
- "isinf(NAN)",
- "isinf(INF)",
- "floor(NAN)",
- "floor(123.123)",
- "floor(-123.123)",
- "trunc(123.123)",
- "trunc(-123.123)",
- "ceil(123.123)",
- "ceil(-123.123)",
- "sqrt(1764)",
- "isnan(sqrt(-1))",
- "not(1)",
- "not(NAN)",
- "not(0)",
- "6.0206dB",
- "-3.0103dB",
- "pow(0,1.23)",
- "pow(PI,1.23)",
- "PI^1.23",
- "pow(-1,1.23)",
- "if(1, 2)",
- "if(1, 1, 2)",
- "if(0, 1, 2)",
- "ifnot(0, 23)",
- "ifnot(1, NaN) + if(0, 1)",
- "ifnot(1, 1, 2)",
- "ifnot(0, 1, 2)",
- "taylor(1, 1)",
- "taylor(eq(mod(ld(1),4),1)-eq(mod(ld(1),4),3), PI/2, 1)",
- "root(sin(ld(0))-1, 2)",
- "root(sin(ld(0))+6+sin(ld(0)/12)-log(ld(0)), 100)",
- "7000000B*random(0)",
- "squish(2)",
- "gauss(0.1)",
- "hypot(4,3)",
- "gcd(30,55)*print(min(9,1))",
- "bitor(42, 12)",
- "bitand(42, 12)",
- "bitand(NAN, 1)",
- "between(10, -3, 10)",
- "between(-4, -2, -1)",
- "between(1,2)",
- "clip(0, 2, 1)",
- "clip(0/0, 1, 2)",
- "clip(0, 0/0, 1)",
- NULL
- };
-
- for (expr = exprs; *expr; expr++) {
- printf("Evaluating '%s'\n", *expr);
- av_expr_parse_and_eval(&d, *expr,
- const_names, const_values,
- NULL, NULL, NULL, NULL, NULL, 0, NULL);
- if (isnan(d))
- printf("'%s' -> nan\n\n", *expr);
- else
- printf("'%s' -> %f\n\n", *expr, d);
- }
-
- av_expr_parse_and_eval(&d, "1+(5-2)^(3-1)+1/2+sin(PI)-max(-2.2,-3.1)",
- const_names, const_values,
- NULL, NULL, NULL, NULL, NULL, 0, NULL);
- printf("%f == 12.7\n", d);
- av_expr_parse_and_eval(&d, "80G/80Gi",
- const_names, const_values,
- NULL, NULL, NULL, NULL, NULL, 0, NULL);
- printf("%f == 0.931322575\n", d);
-
- if (argc > 1 && !strcmp(argv[1], "-t")) {
- for (i = 0; i < 1050; i++) {
- START_TIMER;
- av_expr_parse_and_eval(&d, "1+(5-2)^(3-1)+1/2+sin(PI)-max(-2.2,-3.1)",
- const_names, const_values,
- NULL, NULL, NULL, NULL, NULL, 0, NULL);
- STOP_TIMER("av_expr_parse_and_eval");
- }
- }
-
- return 0;
-}
-#endif
diff --git a/libavutil/fifo-test.c b/libavutil/fifo-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..71a9172a45c5f1d7208e8957948ad2ed2692ce1b
--- /dev/null
+++ b/libavutil/fifo-test.c
@@ -0,0 +1,74 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdio.h>
+
+#include "fifo.h"
+
+int main(void)
+{
+ /* create a FIFO buffer */
+ AVFifoBuffer *fifo = av_fifo_alloc(13 * sizeof(int));
+ int i, j, n;
+
+ /* fill data */
+ for (i = 0; av_fifo_space(fifo) >= sizeof(int); i++)
+ av_fifo_generic_write(fifo, &i, sizeof(int), NULL);
+
+ /* peek at FIFO */
+ n = av_fifo_size(fifo) / sizeof(int);
+ for (i = -n + 1; i < n; i++) {
+ int *v = (int *)av_fifo_peek2(fifo, i * sizeof(int));
+ printf("%d: %d\n", i, *v);
+ }
+ printf("\n");
+
+ /* peek_at at FIFO */
+ n = av_fifo_size(fifo) / sizeof(int);
+ for (i = 0; i < n; i++) {
+ av_fifo_generic_peek_at(fifo, &j, i * sizeof(int), sizeof(j), NULL);
+ printf("%d: %d\n", i, j);
+ }
+ printf("\n");
+
+ /* read data */
+ for (i = 0; av_fifo_size(fifo) >= sizeof(int); i++) {
+ av_fifo_generic_read(fifo, &j, sizeof(int), NULL);
+ printf("%d ", j);
+ }
+ printf("\n");
+
+ /* test *ndx overflow */
+ av_fifo_reset(fifo);
+ fifo->rndx = fifo->wndx = ~(uint32_t)0 - 5;
+
+ /* fill data */
+ for (i = 0; av_fifo_space(fifo) >= sizeof(int); i++)
+ av_fifo_generic_write(fifo, &i, sizeof(int), NULL);
+
+ /* peek_at at FIFO */
+ n = av_fifo_size(fifo) / sizeof(int);
+ for (i = 0; i < n; i++) {
+ av_fifo_generic_peek_at(fifo, &j, i * sizeof(int), sizeof(j), NULL);
+ printf("%d: %d\n", i, j);
+ }
+
+ av_fifo_free(fifo);
+
+ return 0;
+}
diff --git a/libavutil/fifo.c b/libavutil/fifo.c
index 7bd48a2271adb958ce38257bc3c2a2a57761b5e4..986729aedb0e46ede0a0352d0311b6080e7d9b0e 100644
--- a/libavutil/fifo.c
+++ b/libavutil/fifo.c
@@ -238,60 +238,3 @@ void av_fifo_drain(AVFifoBuffer *f, int size)
f->rptr -= f->end - f->buffer;
f->rndx += size;
}
-
-#ifdef TEST
-
-int main(void)
-{
- /* create a FIFO buffer */
- AVFifoBuffer *fifo = av_fifo_alloc(13 * sizeof(int));
- int i, j, n;
-
- /* fill data */
- for (i = 0; av_fifo_space(fifo) >= sizeof(int); i++)
- av_fifo_generic_write(fifo, &i, sizeof(int), NULL);
-
- /* peek at FIFO */
- n = av_fifo_size(fifo) / sizeof(int);
- for (i = -n + 1; i < n; i++) {
- int *v = (int *)av_fifo_peek2(fifo, i * sizeof(int));
- printf("%d: %d\n", i, *v);
- }
- printf("\n");
-
- /* peek_at at FIFO */
- n = av_fifo_size(fifo) / sizeof(int);
- for (i = 0; i < n; i++) {
- av_fifo_generic_peek_at(fifo, &j, i * sizeof(int), sizeof(j), NULL);
- printf("%d: %d\n", i, j);
- }
- printf("\n");
-
- /* read data */
- for (i = 0; av_fifo_size(fifo) >= sizeof(int); i++) {
- av_fifo_generic_read(fifo, &j, sizeof(int), NULL);
- printf("%d ", j);
- }
- printf("\n");
-
- /* test *ndx overflow */
- av_fifo_reset(fifo);
- fifo->rndx = fifo->wndx = ~(uint32_t)0 - 5;
-
- /* fill data */
- for (i = 0; av_fifo_space(fifo) >= sizeof(int); i++)
- av_fifo_generic_write(fifo, &i, sizeof(int), NULL);
-
- /* peek_at at FIFO */
- n = av_fifo_size(fifo) / sizeof(int);
- for (i = 0; i < n; i++) {
- av_fifo_generic_peek_at(fifo, &j, i * sizeof(int), sizeof(j), NULL);
- printf("%d: %d\n", i, j);
- }
-
- av_fifo_free(fifo);
-
- return 0;
-}
-
-#endif
diff --git a/libavutil/file-test.c b/libavutil/file-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..0324081fb9c8ab362a409ff89d3a173fe4cac500
--- /dev/null
+++ b/libavutil/file-test.c
@@ -0,0 +1,34 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "file.c"
+
+#undef printf
+
+int main(void)
+{
+ uint8_t *buf;
+ size_t size;
+ if (av_file_map("file.c", &buf, &size, 0, NULL) < 0)
+ return 1;
+
+ buf[0] = 's';
+ printf("%s", buf);
+ av_file_unmap(buf, size);
+ return 0;
+}
diff --git a/libavutil/file.c b/libavutil/file.c
index 25381b17d7ad6cf8e89a6e6c148019b1935c677f..7bdf6cde840fb82bd486a1c6dba007028311f6ae 100644
--- a/libavutil/file.c
+++ b/libavutil/file.c
@@ -140,22 +140,3 @@ void av_file_unmap(uint8_t *bufptr, size_t size)
int av_tempfile(const char *prefix, char **filename, int log_offset, void *log_ctx) {
return avpriv_tempfile(prefix, filename, log_offset, log_ctx);
}
-
-#ifdef TEST
-
-#undef printf
-
-int main(void)
-{
- uint8_t *buf;
- size_t size;
- if (av_file_map("file.c", &buf, &size, 0, NULL) < 0)
- return 1;
-
- buf[0] = 's';
- printf("%s", buf);
- av_file_unmap(buf, size);
- return 0;
-}
-#endif
-
diff --git a/libavutil/float_dsp-test.c b/libavutil/float_dsp-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..2603ee565d04932d201e58abc5e71083d9100899
--- /dev/null
+++ b/libavutil/float_dsp-test.c
@@ -0,0 +1,331 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <float.h>
+#include <math.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#if HAVE_UNISTD_H
+#include <unistd.h> /* for getopt */
+#endif
+#if !HAVE_GETOPT
+#include "compat/getopt.c"
+#endif
+
+#include "common.h"
+#include "cpu.h"
+#include "internal.h"
+#include "lfg.h"
+#include "log.h"
+#include "random_seed.h"
+#include "float_dsp.h"
+
+#define LEN 240
+
+static void fill_float_array(AVLFG *lfg, float *a, int len)
+{
+ int i;
+ double bmg[2], stddev = 10.0, mean = 0.0;
+
+ for (i = 0; i < len; i += 2) {
+ av_bmg_get(lfg, bmg);
+ a[i] = bmg[0] * stddev + mean;
+ a[i + 1] = bmg[1] * stddev + mean;
+ }
+}
+static int compare_floats(const float *a, const float *b, int len,
+ float max_diff)
+{
+ int i;
+ for (i = 0; i < len; i++) {
+ if (fabsf(a[i] - b[i]) > max_diff) {
+ av_log(NULL, AV_LOG_ERROR, "%d: %- .12f - %- .12f = % .12g\n",
+ i, a[i], b[i], a[i] - b[i]);
+ return -1;
+ }
+ }
+ return 0;
+}
+
+static void fill_double_array(AVLFG *lfg, double *a, int len)
+{
+ int i;
+ double bmg[2], stddev = 10.0, mean = 0.0;
+
+ for (i = 0; i < len; i += 2) {
+ av_bmg_get(lfg, bmg);
+ a[i] = bmg[0] * stddev + mean;
+ a[i + 1] = bmg[1] * stddev + mean;
+ }
+}
+
+static int compare_doubles(const double *a, const double *b, int len,
+ double max_diff)
+{
+ int i;
+
+ for (i = 0; i < len; i++) {
+ if (fabs(a[i] - b[i]) > max_diff) {
+ av_log(NULL, AV_LOG_ERROR, "%d: %- .12f - %- .12f = % .12g\n",
+ i, a[i], b[i], a[i] - b[i]);
+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int test_vector_fmul(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
+ const float *v1, const float *v2)
+{
+ LOCAL_ALIGNED(32, float, cdst, [LEN]);
+ LOCAL_ALIGNED(32, float, odst, [LEN]);
+ int ret;
+
+ cdsp->vector_fmul(cdst, v1, v2, LEN);
+ fdsp->vector_fmul(odst, v1, v2, LEN);
+
+ if (ret = compare_floats(cdst, odst, LEN, FLT_EPSILON))
+ av_log(NULL, AV_LOG_ERROR, "vector_fmul failed\n");
+
+ return ret;
+}
+
+#define ARBITRARY_FMAC_SCALAR_CONST 0.005
+static int test_vector_fmac_scalar(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
+ const float *v1, const float *src0, float scale)
+{
+ LOCAL_ALIGNED(32, float, cdst, [LEN]);
+ LOCAL_ALIGNED(32, float, odst, [LEN]);
+ int ret;
+
+ memcpy(cdst, v1, LEN * sizeof(*v1));
+ memcpy(odst, v1, LEN * sizeof(*v1));
+
+ cdsp->vector_fmac_scalar(cdst, src0, scale, LEN);
+ fdsp->vector_fmac_scalar(odst, src0, scale, LEN);
+
+ if (ret = compare_floats(cdst, odst, LEN, ARBITRARY_FMAC_SCALAR_CONST))
+ av_log(NULL, AV_LOG_ERROR, "vector_fmac_scalar failed\n");
+
+ return ret;
+}
+
+static int test_vector_fmul_scalar(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
+ const float *v1, float scale)
+{
+ LOCAL_ALIGNED(32, float, cdst, [LEN]);
+ LOCAL_ALIGNED(32, float, odst, [LEN]);
+ int ret;
+
+ cdsp->vector_fmul_scalar(cdst, v1, scale, LEN);
+ fdsp->vector_fmul_scalar(odst, v1, scale, LEN);
+
+ if (ret = compare_floats(cdst, odst, LEN, FLT_EPSILON))
+ av_log(NULL, AV_LOG_ERROR, "vector_fmul_scalar failed\n");
+
+ return ret;
+}
+
+static int test_vector_dmul_scalar(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
+ const double *v1, double scale)
+{
+ LOCAL_ALIGNED(32, double, cdst, [LEN]);
+ LOCAL_ALIGNED(32, double, odst, [LEN]);
+ int ret;
+
+ cdsp->vector_dmul_scalar(cdst, v1, scale, LEN);
+ fdsp->vector_dmul_scalar(odst, v1, scale, LEN);
+
+ if (ret = compare_doubles(cdst, odst, LEN, DBL_EPSILON))
+ av_log(NULL, AV_LOG_ERROR, "vector_dmul_scalar failed\n");
+
+ return ret;
+}
+
+#define ARBITRARY_FMUL_WINDOW_CONST 0.008
+static int test_vector_fmul_window(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
+ const float *v1, const float *v2, const float *v3)
+{
+ LOCAL_ALIGNED(32, float, cdst, [LEN]);
+ LOCAL_ALIGNED(32, float, odst, [LEN]);
+ int ret;
+
+ cdsp->vector_fmul_window(cdst, v1, v2, v3, LEN / 2);
+ fdsp->vector_fmul_window(odst, v1, v2, v3, LEN / 2);
+
+ if (ret = compare_floats(cdst, odst, LEN, ARBITRARY_FMUL_WINDOW_CONST))
+ av_log(NULL, AV_LOG_ERROR, "vector_fmul_window failed\n");
+
+ return ret;
+}
+
+#define ARBITRARY_FMUL_ADD_CONST 0.005
+static int test_vector_fmul_add(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
+ const float *v1, const float *v2, const float *v3)
+{
+ LOCAL_ALIGNED(32, float, cdst, [LEN]);
+ LOCAL_ALIGNED(32, float, odst, [LEN]);
+ int ret;
+
+ cdsp->vector_fmul_add(cdst, v1, v2, v3, LEN);
+ fdsp->vector_fmul_add(odst, v1, v2, v3, LEN);
+
+ if (ret = compare_floats(cdst, odst, LEN, ARBITRARY_FMUL_ADD_CONST))
+ av_log(NULL, AV_LOG_ERROR, "vector_fmul_add failed\n");
+
+ return ret;
+}
+
+static int test_vector_fmul_reverse(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
+ const float *v1, const float *v2)
+{
+ LOCAL_ALIGNED(32, float, cdst, [LEN]);
+ LOCAL_ALIGNED(32, float, odst, [LEN]);
+ int ret;
+
+ cdsp->vector_fmul_reverse(cdst, v1, v2, LEN);
+ fdsp->vector_fmul_reverse(odst, v1, v2, LEN);
+
+ if (ret = compare_floats(cdst, odst, LEN, FLT_EPSILON))
+ av_log(NULL, AV_LOG_ERROR, "vector_fmul_reverse failed\n");
+
+ return ret;
+}
+
+static int test_butterflies_float(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
+ const float *v1, const float *v2)
+{
+ LOCAL_ALIGNED(32, float, cv1, [LEN]);
+ LOCAL_ALIGNED(32, float, cv2, [LEN]);
+ LOCAL_ALIGNED(32, float, ov1, [LEN]);
+ LOCAL_ALIGNED(32, float, ov2, [LEN]);
+ int ret;
+
+ memcpy(cv1, v1, LEN * sizeof(*v1));
+ memcpy(cv2, v2, LEN * sizeof(*v2));
+ memcpy(ov1, v1, LEN * sizeof(*v1));
+ memcpy(ov2, v2, LEN * sizeof(*v2));
+
+ cdsp->butterflies_float(cv1, cv2, LEN);
+ fdsp->butterflies_float(ov1, ov2, LEN);
+
+ if ((ret = compare_floats(cv1, ov1, LEN, FLT_EPSILON)) ||
+ (ret = compare_floats(cv2, ov2, LEN, FLT_EPSILON)))
+ av_log(NULL, AV_LOG_ERROR, "butterflies_float failed\n");
+
+ return ret;
+}
+
+#define ARBITRARY_SCALARPRODUCT_CONST 0.2
+static int test_scalarproduct_float(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
+ const float *v1, const float *v2)
+{
+ float cprod, oprod;
+ int ret;
+
+ cprod = cdsp->scalarproduct_float(v1, v2, LEN);
+ oprod = fdsp->scalarproduct_float(v1, v2, LEN);
+
+ if (ret = compare_floats(&cprod, &oprod, 1, ARBITRARY_SCALARPRODUCT_CONST))
+ av_log(NULL, AV_LOG_ERROR, "scalarproduct_float failed\n");
+
+ return ret;
+}
+
+int main(int argc, char **argv)
+{
+ int ret = 0, seeded = 0;
+ uint32_t seed;
+ AVFloatDSPContext *fdsp, *cdsp;
+ AVLFG lfg;
+
+ LOCAL_ALIGNED(32, float, src0, [LEN]);
+ LOCAL_ALIGNED(32, float, src1, [LEN]);
+ LOCAL_ALIGNED(32, float, src2, [LEN]);
+ LOCAL_ALIGNED(32, double, dbl_src0, [LEN]);
+ LOCAL_ALIGNED(32, double, dbl_src1, [LEN]);
+
+ for (;;) {
+ int arg = getopt(argc, argv, "s:c:");
+ if (arg == -1)
+ break;
+ switch (arg) {
+ case 's':
+ seed = strtoul(optarg, NULL, 10);
+ seeded = 1;
+ break;
+ case 'c':
+ {
+ int cpuflags = av_get_cpu_flags();
+
+ if (av_parse_cpu_caps(&cpuflags, optarg) < 0)
+ return 1;
+
+ av_force_cpu_flags(cpuflags);
+ break;
+ }
+ }
+ }
+ if (!seeded)
+ seed = av_get_random_seed();
+
+ av_log(NULL, AV_LOG_INFO, "float_dsp-test: %s %u\n", seeded ? "seed" : "random seed", seed);
+
+ fdsp = avpriv_float_dsp_alloc(1);
+ av_force_cpu_flags(0);
+ cdsp = avpriv_float_dsp_alloc(1);
+
+ if (!fdsp || !cdsp) {
+ ret = 1;
+ goto end;
+ }
+
+ av_lfg_init(&lfg, seed);
+
+ fill_float_array(&lfg, src0, LEN);
+ fill_float_array(&lfg, src1, LEN);
+ fill_float_array(&lfg, src2, LEN);
+
+ fill_double_array(&lfg, dbl_src0, LEN);
+ fill_double_array(&lfg, dbl_src1, LEN);
+
+ if (test_vector_fmul(fdsp, cdsp, src0, src1))
+ ret -= 1 << 0;
+ if (test_vector_fmac_scalar(fdsp, cdsp, src2, src0, src1[0]))
+ ret -= 1 << 1;
+ if (test_vector_fmul_scalar(fdsp, cdsp, src0, src1[0]))
+ ret -= 1 << 2;
+ if (test_vector_fmul_window(fdsp, cdsp, src0, src1, src2))
+ ret -= 1 << 3;
+ if (test_vector_fmul_add(fdsp, cdsp, src0, src1, src2))
+ ret -= 1 << 4;
+ if (test_vector_fmul_reverse(fdsp, cdsp, src0, src1))
+ ret -= 1 << 5;
+ if (test_butterflies_float(fdsp, cdsp, src0, src1))
+ ret -= 1 << 6;
+ if (test_scalarproduct_float(fdsp, cdsp, src0, src1))
+ ret -= 1 << 7;
+ if (test_vector_dmul_scalar(fdsp, cdsp, dbl_src0, dbl_src1[0]))
+ ret -= 1 << 8;
+
+end:
+ av_freep(&fdsp);
+ av_freep(&cdsp);
+ return ret;
+}
diff --git a/libavutil/float_dsp.c b/libavutil/float_dsp.c
index 49e0ae7f0307f4d1b09b61d0524294683a285c4d..c85daffc6a96a1dea29393da58d089eacfc981b3 100644
--- a/libavutil/float_dsp.c
+++ b/libavutil/float_dsp.c
@@ -144,321 +144,3 @@ av_cold AVFloatDSPContext *avpriv_float_dsp_alloc(int bit_exact)
ff_float_dsp_init_mips(fdsp);
return fdsp;
}
-
-
-#ifdef TEST
-
-#include <float.h>
-#include <math.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#if HAVE_UNISTD_H
-#include <unistd.h> /* for getopt */
-#endif
-#if !HAVE_GETOPT
-#include "compat/getopt.c"
-#endif
-
-#include "common.h"
-#include "cpu.h"
-#include "internal.h"
-#include "lfg.h"
-#include "log.h"
-#include "random_seed.h"
-
-#define LEN 240
-
-static void fill_float_array(AVLFG *lfg, float *a, int len)
-{
- int i;
- double bmg[2], stddev = 10.0, mean = 0.0;
-
- for (i = 0; i < len; i += 2) {
- av_bmg_get(lfg, bmg);
- a[i] = bmg[0] * stddev + mean;
- a[i + 1] = bmg[1] * stddev + mean;
- }
-}
-static int compare_floats(const float *a, const float *b, int len,
- float max_diff)
-{
- int i;
- for (i = 0; i < len; i++) {
- if (fabsf(a[i] - b[i]) > max_diff) {
- av_log(NULL, AV_LOG_ERROR, "%d: %- .12f - %- .12f = % .12g\n",
- i, a[i], b[i], a[i] - b[i]);
- return -1;
- }
- }
- return 0;
-}
-
-static void fill_double_array(AVLFG *lfg, double *a, int len)
-{
- int i;
- double bmg[2], stddev = 10.0, mean = 0.0;
-
- for (i = 0; i < len; i += 2) {
- av_bmg_get(lfg, bmg);
- a[i] = bmg[0] * stddev + mean;
- a[i + 1] = bmg[1] * stddev + mean;
- }
-}
-
-static int compare_doubles(const double *a, const double *b, int len,
- double max_diff)
-{
- int i;
-
- for (i = 0; i < len; i++) {
- if (fabs(a[i] - b[i]) > max_diff) {
- av_log(NULL, AV_LOG_ERROR, "%d: %- .12f - %- .12f = % .12g\n",
- i, a[i], b[i], a[i] - b[i]);
- return -1;
- }
- }
- return 0;
-}
-
-static int test_vector_fmul(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
- const float *v1, const float *v2)
-{
- LOCAL_ALIGNED(32, float, cdst, [LEN]);
- LOCAL_ALIGNED(32, float, odst, [LEN]);
- int ret;
-
- cdsp->vector_fmul(cdst, v1, v2, LEN);
- fdsp->vector_fmul(odst, v1, v2, LEN);
-
- if (ret = compare_floats(cdst, odst, LEN, FLT_EPSILON))
- av_log(NULL, AV_LOG_ERROR, "vector_fmul failed\n");
-
- return ret;
-}
-
-#define ARBITRARY_FMAC_SCALAR_CONST 0.005
-static int test_vector_fmac_scalar(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
- const float *v1, const float *src0, float scale)
-{
- LOCAL_ALIGNED(32, float, cdst, [LEN]);
- LOCAL_ALIGNED(32, float, odst, [LEN]);
- int ret;
-
- memcpy(cdst, v1, LEN * sizeof(*v1));
- memcpy(odst, v1, LEN * sizeof(*v1));
-
- cdsp->vector_fmac_scalar(cdst, src0, scale, LEN);
- fdsp->vector_fmac_scalar(odst, src0, scale, LEN);
-
- if (ret = compare_floats(cdst, odst, LEN, ARBITRARY_FMAC_SCALAR_CONST))
- av_log(NULL, AV_LOG_ERROR, "vector_fmac_scalar failed\n");
-
- return ret;
-}
-
-static int test_vector_fmul_scalar(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
- const float *v1, float scale)
-{
- LOCAL_ALIGNED(32, float, cdst, [LEN]);
- LOCAL_ALIGNED(32, float, odst, [LEN]);
- int ret;
-
- cdsp->vector_fmul_scalar(cdst, v1, scale, LEN);
- fdsp->vector_fmul_scalar(odst, v1, scale, LEN);
-
- if (ret = compare_floats(cdst, odst, LEN, FLT_EPSILON))
- av_log(NULL, AV_LOG_ERROR, "vector_fmul_scalar failed\n");
-
- return ret;
-}
-
-static int test_vector_dmul_scalar(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
- const double *v1, double scale)
-{
- LOCAL_ALIGNED(32, double, cdst, [LEN]);
- LOCAL_ALIGNED(32, double, odst, [LEN]);
- int ret;
-
- cdsp->vector_dmul_scalar(cdst, v1, scale, LEN);
- fdsp->vector_dmul_scalar(odst, v1, scale, LEN);
-
- if (ret = compare_doubles(cdst, odst, LEN, DBL_EPSILON))
- av_log(NULL, AV_LOG_ERROR, "vector_dmul_scalar failed\n");
-
- return ret;
-}
-
-#define ARBITRARY_FMUL_WINDOW_CONST 0.008
-static int test_vector_fmul_window(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
- const float *v1, const float *v2, const float *v3)
-{
- LOCAL_ALIGNED(32, float, cdst, [LEN]);
- LOCAL_ALIGNED(32, float, odst, [LEN]);
- int ret;
-
- cdsp->vector_fmul_window(cdst, v1, v2, v3, LEN / 2);
- fdsp->vector_fmul_window(odst, v1, v2, v3, LEN / 2);
-
- if (ret = compare_floats(cdst, odst, LEN, ARBITRARY_FMUL_WINDOW_CONST))
- av_log(NULL, AV_LOG_ERROR, "vector_fmul_window failed\n");
-
- return ret;
-}
-
-#define ARBITRARY_FMUL_ADD_CONST 0.005
-static int test_vector_fmul_add(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
- const float *v1, const float *v2, const float *v3)
-{
- LOCAL_ALIGNED(32, float, cdst, [LEN]);
- LOCAL_ALIGNED(32, float, odst, [LEN]);
- int ret;
-
- cdsp->vector_fmul_add(cdst, v1, v2, v3, LEN);
- fdsp->vector_fmul_add(odst, v1, v2, v3, LEN);
-
- if (ret = compare_floats(cdst, odst, LEN, ARBITRARY_FMUL_ADD_CONST))
- av_log(NULL, AV_LOG_ERROR, "vector_fmul_add failed\n");
-
- return ret;
-}
-
-static int test_vector_fmul_reverse(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
- const float *v1, const float *v2)
-{
- LOCAL_ALIGNED(32, float, cdst, [LEN]);
- LOCAL_ALIGNED(32, float, odst, [LEN]);
- int ret;
-
- cdsp->vector_fmul_reverse(cdst, v1, v2, LEN);
- fdsp->vector_fmul_reverse(odst, v1, v2, LEN);
-
- if (ret = compare_floats(cdst, odst, LEN, FLT_EPSILON))
- av_log(NULL, AV_LOG_ERROR, "vector_fmul_reverse failed\n");
-
- return ret;
-}
-
-static int test_butterflies_float(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
- const float *v1, const float *v2)
-{
- LOCAL_ALIGNED(32, float, cv1, [LEN]);
- LOCAL_ALIGNED(32, float, cv2, [LEN]);
- LOCAL_ALIGNED(32, float, ov1, [LEN]);
- LOCAL_ALIGNED(32, float, ov2, [LEN]);
- int ret;
-
- memcpy(cv1, v1, LEN * sizeof(*v1));
- memcpy(cv2, v2, LEN * sizeof(*v2));
- memcpy(ov1, v1, LEN * sizeof(*v1));
- memcpy(ov2, v2, LEN * sizeof(*v2));
-
- cdsp->butterflies_float(cv1, cv2, LEN);
- fdsp->butterflies_float(ov1, ov2, LEN);
-
- if ((ret = compare_floats(cv1, ov1, LEN, FLT_EPSILON)) ||
- (ret = compare_floats(cv2, ov2, LEN, FLT_EPSILON)))
- av_log(NULL, AV_LOG_ERROR, "butterflies_float failed\n");
-
- return ret;
-}
-
-#define ARBITRARY_SCALARPRODUCT_CONST 0.2
-static int test_scalarproduct_float(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
- const float *v1, const float *v2)
-{
- float cprod, oprod;
- int ret;
-
- cprod = cdsp->scalarproduct_float(v1, v2, LEN);
- oprod = fdsp->scalarproduct_float(v1, v2, LEN);
-
- if (ret = compare_floats(&cprod, &oprod, 1, ARBITRARY_SCALARPRODUCT_CONST))
- av_log(NULL, AV_LOG_ERROR, "scalarproduct_float failed\n");
-
- return ret;
-}
-
-int main(int argc, char **argv)
-{
- int ret = 0, seeded = 0;
- uint32_t seed;
- AVFloatDSPContext *fdsp, *cdsp;
- AVLFG lfg;
-
- LOCAL_ALIGNED(32, float, src0, [LEN]);
- LOCAL_ALIGNED(32, float, src1, [LEN]);
- LOCAL_ALIGNED(32, float, src2, [LEN]);
- LOCAL_ALIGNED(32, double, dbl_src0, [LEN]);
- LOCAL_ALIGNED(32, double, dbl_src1, [LEN]);
-
- for (;;) {
- int arg = getopt(argc, argv, "s:c:");
- if (arg == -1)
- break;
- switch (arg) {
- case 's':
- seed = strtoul(optarg, NULL, 10);
- seeded = 1;
- break;
- case 'c':
- {
- int cpuflags = av_get_cpu_flags();
-
- if (av_parse_cpu_caps(&cpuflags, optarg) < 0)
- return 1;
-
- av_force_cpu_flags(cpuflags);
- break;
- }
- }
- }
- if (!seeded)
- seed = av_get_random_seed();
-
- av_log(NULL, AV_LOG_INFO, "float_dsp-test: %s %u\n", seeded ? "seed" : "random seed", seed);
-
- fdsp = avpriv_float_dsp_alloc(1);
- av_force_cpu_flags(0);
- cdsp = avpriv_float_dsp_alloc(1);
-
- if (!fdsp || !cdsp) {
- ret = 1;
- goto end;
- }
-
- av_lfg_init(&lfg, seed);
-
- fill_float_array(&lfg, src0, LEN);
- fill_float_array(&lfg, src1, LEN);
- fill_float_array(&lfg, src2, LEN);
-
- fill_double_array(&lfg, dbl_src0, LEN);
- fill_double_array(&lfg, dbl_src1, LEN);
-
- if (test_vector_fmul(fdsp, cdsp, src0, src1))
- ret -= 1 << 0;
- if (test_vector_fmac_scalar(fdsp, cdsp, src2, src0, src1[0]))
- ret -= 1 << 1;
- if (test_vector_fmul_scalar(fdsp, cdsp, src0, src1[0]))
- ret -= 1 << 2;
- if (test_vector_fmul_window(fdsp, cdsp, src0, src1, src2))
- ret -= 1 << 3;
- if (test_vector_fmul_add(fdsp, cdsp, src0, src1, src2))
- ret -= 1 << 4;
- if (test_vector_fmul_reverse(fdsp, cdsp, src0, src1))
- ret -= 1 << 5;
- if (test_butterflies_float(fdsp, cdsp, src0, src1))
- ret -= 1 << 6;
- if (test_scalarproduct_float(fdsp, cdsp, src0, src1))
- ret -= 1 << 7;
- if (test_vector_dmul_scalar(fdsp, cdsp, dbl_src0, dbl_src1[0]))
- ret -= 1 << 8;
-
-end:
- av_freep(&fdsp);
- av_freep(&cdsp);
- return ret;
-}
-
-#endif /* TEST */
diff --git a/libavutil/hash-test.c b/libavutil/hash-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..fe14cc3b1c4410e55dba2b90434b00f4b087cd99
--- /dev/null
+++ b/libavutil/hash-test.c
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2013 Reimar Döffinger <Reimar.Doeffinger@gmx.de>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "hash.c"
+
+#define SRC_BUF_SIZE 64
+#define DST_BUF_SIZE (AV_HASH_MAX_SIZE * 8)
+
+int main(void)
+{
+ struct AVHashContext *ctx = NULL;
+ int i, j;
+ static const uint8_t src[SRC_BUF_SIZE] = { 0 };
+ uint8_t dst[DST_BUF_SIZE];
+ for (i = 0; i < NUM_HASHES; i++) {
+ if (av_hash_alloc(&ctx, av_hash_names(i)) < 0)
+ return 1;
+
+ av_hash_init(ctx);
+ av_hash_update(ctx, src, SRC_BUF_SIZE);
+ memset(dst, 0, DST_BUF_SIZE);
+ av_hash_final_hex(ctx, dst, DST_BUF_SIZE);
+ printf("%s hex: %s\n", av_hash_get_name(ctx), dst);
+
+ av_hash_init(ctx);
+ av_hash_update(ctx, src, SRC_BUF_SIZE);
+ av_hash_final_bin(ctx, dst, DST_BUF_SIZE);
+ printf("%s bin: ", av_hash_get_name(ctx));
+ for (j = 0; j < av_hash_get_size(ctx); j++) {
+ printf("%#x ", dst[j]);
+ }
+ printf("\n");
+
+ av_hash_init(ctx);
+ av_hash_update(ctx, src, SRC_BUF_SIZE);
+ av_hash_final_b64(ctx, dst, DST_BUF_SIZE);
+ printf("%s b64: %s\n", av_hash_get_name(ctx), dst);
+ av_hash_freep(&ctx);
+ }
+ return 0;
+}
diff --git a/libavutil/hash.c b/libavutil/hash.c
index e5452ba9298a6439e8ffb5d4345fe121ace62813..7037b0d6ff7e365a621cab0f839a4579d70bceee 100644
--- a/libavutil/hash.c
+++ b/libavutil/hash.c
@@ -237,45 +237,3 @@ void av_hash_freep(AVHashContext **ctx)
av_freep(&(*ctx)->ctx);
av_freep(ctx);
}
-
-#ifdef TEST
-// LCOV_EXCL_START
-#define SRC_BUF_SIZE 64
-#define DST_BUF_SIZE (AV_HASH_MAX_SIZE * 8)
-
-int main(void)
-{
- struct AVHashContext *ctx = NULL;
- int i, j;
- static const uint8_t src[SRC_BUF_SIZE] = { 0 };
- uint8_t dst[DST_BUF_SIZE];
- for (i = 0; i < NUM_HASHES; i++) {
- if (av_hash_alloc(&ctx, av_hash_names(i)) < 0)
- return 1;
-
- av_hash_init(ctx);
- av_hash_update(ctx, src, SRC_BUF_SIZE);
- memset(dst, 0, DST_BUF_SIZE);
- av_hash_final_hex(ctx, dst, DST_BUF_SIZE);
- printf("%s hex: %s\n", av_hash_get_name(ctx), dst);
-
- av_hash_init(ctx);
- av_hash_update(ctx, src, SRC_BUF_SIZE);
- av_hash_final_bin(ctx, dst, DST_BUF_SIZE);
- printf("%s bin: ", av_hash_get_name(ctx));
- for (j = 0; j < av_hash_get_size(ctx); j++) {
- printf("%#x ", dst[j]);
- }
- printf("\n");
-
- av_hash_init(ctx);
- av_hash_update(ctx, src, SRC_BUF_SIZE);
- av_hash_final_b64(ctx, dst, DST_BUF_SIZE);
- printf("%s b64: %s\n", av_hash_get_name(ctx), dst);
- av_hash_freep(&ctx);
- }
- return 0;
-}
-
-// LCOV_EXCL_STOP
-#endif
diff --git a/libavutil/hmac-test.c b/libavutil/hmac-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..925f3dfef6befcfb22a6cb19fe14bae0e1990c39
--- /dev/null
+++ b/libavutil/hmac-test.c
@@ -0,0 +1,99 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "hmac.c"
+
+#include <stdio.h>
+#include <string.h>
+
+static void test(AVHMAC *hmac, const uint8_t *key, int keylen,
+ const uint8_t *data, int datalen)
+{
+ uint8_t buf[MAX_HASHLEN];
+ int out, i;
+ // Some of the test vectors are strings, where sizeof() includes the
+ // trailing null byte - remove that.
+ if (!key[keylen - 1])
+ keylen--;
+ if (!data[datalen - 1])
+ datalen--;
+ out = av_hmac_calc(hmac, data, datalen, key, keylen, buf, sizeof(buf));
+ for (i = 0; i < out; i++)
+ printf("%02x", buf[i]);
+ printf("\n");
+}
+
+int main(void)
+{
+ uint8_t key1[20], key3[131], data3[50];
+ AVHMAC *hmac;
+ enum AVHMACType i;
+ static const uint8_t key2[] = "Jefe";
+ static const uint8_t data1[] = "Hi There";
+ static const uint8_t data2[] = "what do ya want for nothing?";
+ static const uint8_t data4[] = "Test Using Larger Than Block-Size Key - Hash Key First";
+ static const uint8_t data5[] = "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data";
+ static const uint8_t data6[] = "This is a test using a larger than block-size key and a larger "
+ "than block-size data. The key needs to be hashed before being used"
+ " by the HMAC algorithm.";
+ memset(key1, 0x0b, sizeof(key1));
+ memset(key3, 0xaa, sizeof(key3));
+ memset(data3, 0xdd, sizeof(data3));
+
+ /* MD5, SHA-1 */
+ for (i = AV_HMAC_MD5; i <= AV_HMAC_SHA1; i++) {
+ hmac = av_hmac_alloc(i);
+ if (!hmac)
+ return 1;
+ // RFC 2202 test vectors
+ test(hmac, key1, hmac->hashlen, data1, sizeof(data1));
+ test(hmac, key2, sizeof(key2), data2, sizeof(data2));
+ test(hmac, key3, hmac->hashlen, data3, sizeof(data3));
+ test(hmac, key3, 80, data4, sizeof(data4));
+ test(hmac, key3, 80, data5, sizeof(data5));
+ av_hmac_free(hmac);
+ }
+
+ /* SHA-2 */
+ for (i = AV_HMAC_SHA224; i <= AV_HMAC_SHA256; i++) {
+ hmac = av_hmac_alloc(i);
+ if (!hmac)
+ return 1;
+ // RFC 4231 test vectors
+ test(hmac, key1, sizeof(key1), data1, sizeof(data1));
+ test(hmac, key2, sizeof(key2), data2, sizeof(data2));
+ test(hmac, key3, 20, data3, sizeof(data3));
+ test(hmac, key3, sizeof(key3), data4, sizeof(data4));
+ test(hmac, key3, sizeof(key3), data6, sizeof(data6));
+ av_hmac_free(hmac);
+ }
+
+ for (i = AV_HMAC_SHA384; i <= AV_HMAC_SHA512; i++) {
+ hmac = av_hmac_alloc(i);
+ if (!hmac)
+ return 1;
+ // RFC 4231 test vectors
+ test(hmac, key1, sizeof(key1), data1, sizeof(data1));
+ test(hmac, key2, sizeof(key2), data2, sizeof(data2));
+ test(hmac, key3, 20, data3, sizeof(data3));
+ test(hmac, key3, sizeof(key3), data4, sizeof(data4));
+ test(hmac, key3, sizeof(key3), data6, sizeof(data6));
+ av_hmac_free(hmac);
+ }
+ return 0;
+}
diff --git a/libavutil/hmac.c b/libavutil/hmac.c
index 3e11509a278e0e6a999b108cb08949eb1e6f7a7b..8ec6d70406c9d6931c05929c1b5eb4d9b3713751 100644
--- a/libavutil/hmac.c
+++ b/libavutil/hmac.c
@@ -183,84 +183,3 @@ int av_hmac_calc(AVHMAC *c, const uint8_t *data, unsigned int len,
av_hmac_update(c, data, len);
return av_hmac_final(c, out, outlen);
}
-
-#ifdef TEST
-#include <stdio.h>
-
-static void test(AVHMAC *hmac, const uint8_t *key, int keylen,
- const uint8_t *data, int datalen)
-{
- uint8_t buf[MAX_HASHLEN];
- int out, i;
- // Some of the test vectors are strings, where sizeof() includes the
- // trailing null byte - remove that.
- if (!key[keylen - 1])
- keylen--;
- if (!data[datalen - 1])
- datalen--;
- out = av_hmac_calc(hmac, data, datalen, key, keylen, buf, sizeof(buf));
- for (i = 0; i < out; i++)
- printf("%02x", buf[i]);
- printf("\n");
-}
-
-int main(void)
-{
- uint8_t key1[20], key3[131], data3[50];
- AVHMAC *hmac;
- enum AVHMACType i;
- static const uint8_t key2[] = "Jefe";
- static const uint8_t data1[] = "Hi There";
- static const uint8_t data2[] = "what do ya want for nothing?";
- static const uint8_t data4[] = "Test Using Larger Than Block-Size Key - Hash Key First";
- static const uint8_t data5[] = "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data";
- static const uint8_t data6[] = "This is a test using a larger than block-size key and a larger "
- "than block-size data. The key needs to be hashed before being used"
- " by the HMAC algorithm.";
- memset(key1, 0x0b, sizeof(key1));
- memset(key3, 0xaa, sizeof(key3));
- memset(data3, 0xdd, sizeof(data3));
-
- /* MD5, SHA-1 */
- for (i = AV_HMAC_MD5; i <= AV_HMAC_SHA1; i++) {
- hmac = av_hmac_alloc(i);
- if (!hmac)
- return 1;
- // RFC 2202 test vectors
- test(hmac, key1, hmac->hashlen, data1, sizeof(data1));
- test(hmac, key2, sizeof(key2), data2, sizeof(data2));
- test(hmac, key3, hmac->hashlen, data3, sizeof(data3));
- test(hmac, key3, 80, data4, sizeof(data4));
- test(hmac, key3, 80, data5, sizeof(data5));
- av_hmac_free(hmac);
- }
-
- /* SHA-2 */
- for (i = AV_HMAC_SHA224; i <= AV_HMAC_SHA256; i++) {
- hmac = av_hmac_alloc(i);
- if (!hmac)
- return 1;
- // RFC 4231 test vectors
- test(hmac, key1, sizeof(key1), data1, sizeof(data1));
- test(hmac, key2, sizeof(key2), data2, sizeof(data2));
- test(hmac, key3, 20, data3, sizeof(data3));
- test(hmac, key3, sizeof(key3), data4, sizeof(data4));
- test(hmac, key3, sizeof(key3), data6, sizeof(data6));
- av_hmac_free(hmac);
- }
-
- for (i = AV_HMAC_SHA384; i <= AV_HMAC_SHA512; i++) {
- hmac = av_hmac_alloc(i);
- if (!hmac)
- return 1;
- // RFC 4231 test vectors
- test(hmac, key1, sizeof(key1), data1, sizeof(data1));
- test(hmac, key2, sizeof(key2), data2, sizeof(data2));
- test(hmac, key3, 20, data3, sizeof(data3));
- test(hmac, key3, sizeof(key3), data4, sizeof(data4));
- test(hmac, key3, sizeof(key3), data6, sizeof(data6));
- av_hmac_free(hmac);
- }
- return 0;
-}
-#endif /* TEST */
diff --git a/libavutil/lfg-test.c b/libavutil/lfg-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..2b6f3828dc52db9afdf4c5935f89f32b733921e5
--- /dev/null
+++ b/libavutil/lfg-test.c
@@ -0,0 +1,74 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "log.h"
+#include "timer.h"
+#include "lfg.h"
+
+int main(void)
+{
+ int x = 0;
+ int i, j;
+ AVLFG state;
+
+ av_lfg_init(&state, 0xdeadbeef);
+ for (j = 0; j < 10000; j++) {
+ START_TIMER
+ for (i = 0; i < 624; i++) {
+ //av_log(NULL, AV_LOG_ERROR, "%X\n", av_lfg_get(&state));
+ x += av_lfg_get(&state);
+ }
+ STOP_TIMER("624 calls of av_lfg_get");
+ }
+ av_log(NULL, AV_LOG_ERROR, "final value:%X\n", x);
+
+ /* BMG usage example */
+ {
+ double mean = 1000;
+ double stddev = 53;
+ double samp_mean = 0.0, samp_stddev = 0.0;
+ double samp0, samp1;
+
+ av_lfg_init(&state, 42);
+
+ for (i = 0; i < 1000; i += 2) {
+ double bmg_out[2];
+ av_bmg_get(&state, bmg_out);
+ samp0 = bmg_out[0] * stddev + mean;
+ samp1 = bmg_out[1] * stddev + mean;
+ samp_mean += samp0 + samp1;
+ samp_stddev += samp0 * samp0 + samp1 * samp1;
+ av_log(NULL, AV_LOG_INFO,
+ "%f\n%f\n",
+ samp0,
+ samp1);
+ }
+ /* TODO: add proper normality test */
+ samp_mean /= 1000;
+ samp_stddev /= 999;
+ samp_stddev -= (1000.0/999.0)*samp_mean*samp_mean;
+ samp_stddev = sqrt(samp_stddev);
+ av_log(NULL, AV_LOG_INFO, "sample mean : %f\n"
+ "true mean : %f\n"
+ "sample stddev: %f\n"
+ "true stddev : %f\n",
+ samp_mean, mean, samp_stddev, stddev);
+ }
+
+ return 0;
+}
diff --git a/libavutil/lfg.c b/libavutil/lfg.c
index 5ffd76f18155008867010a32addac551a4254995..08a4f678e2e89727c39ad8940f10b37a65dc3919 100644
--- a/libavutil/lfg.c
+++ b/libavutil/lfg.c
@@ -58,61 +58,3 @@ void av_bmg_get(AVLFG *lfg, double out[2])
out[0] = x1 * w;
out[1] = x2 * w;
}
-
-#ifdef TEST
-#include "log.h"
-#include "timer.h"
-
-int main(void)
-{
- int x = 0;
- int i, j;
- AVLFG state;
-
- av_lfg_init(&state, 0xdeadbeef);
- for (j = 0; j < 10000; j++) {
- START_TIMER
- for (i = 0; i < 624; i++) {
- //av_log(NULL, AV_LOG_ERROR, "%X\n", av_lfg_get(&state));
- x += av_lfg_get(&state);
- }
- STOP_TIMER("624 calls of av_lfg_get");
- }
- av_log(NULL, AV_LOG_ERROR, "final value:%X\n", x);
-
- /* BMG usage example */
- {
- double mean = 1000;
- double stddev = 53;
- double samp_mean = 0.0, samp_stddev = 0.0;
- double samp0, samp1;
-
- av_lfg_init(&state, 42);
-
- for (i = 0; i < 1000; i += 2) {
- double bmg_out[2];
- av_bmg_get(&state, bmg_out);
- samp0 = bmg_out[0] * stddev + mean;
- samp1 = bmg_out[1] * stddev + mean;
- samp_mean += samp0 + samp1;
- samp_stddev += samp0 * samp0 + samp1 * samp1;
- av_log(NULL, AV_LOG_INFO,
- "%f\n%f\n",
- samp0,
- samp1);
- }
- /* TODO: add proper normality test */
- samp_mean /= 1000;
- samp_stddev /= 999;
- samp_stddev -= (1000.0/999.0)*samp_mean*samp_mean;
- samp_stddev = sqrt(samp_stddev);
- av_log(NULL, AV_LOG_INFO, "sample mean : %f\n"
- "true mean : %f\n"
- "sample stddev: %f\n"
- "true stddev : %f\n",
- samp_mean, mean, samp_stddev, stddev);
- }
-
- return 0;
-}
-#endif
diff --git a/libavutil/lls-test.c b/libavutil/lls-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..12215c5257801e06fc8fde6a5c36063b7cf73be4
--- /dev/null
+++ b/libavutil/lls-test.c
@@ -0,0 +1,54 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <limits.h>
+#include <stdio.h>
+
+#include "internal.h"
+#include "lfg.h"
+#include "lls.h"
+
+int main(void)
+{
+ LLSModel m;
+ int i, order;
+ AVLFG lfg;
+
+ av_lfg_init(&lfg, 1);
+ avpriv_init_lls(&m, 3);
+
+ for (i = 0; i < 100; i++) {
+ LOCAL_ALIGNED(32, double, var, [4]);
+ double eval;
+
+ var[0] = (av_lfg_get(&lfg) / (double) UINT_MAX - 0.5) * 2;
+ var[1] = var[0] + av_lfg_get(&lfg) / (double) UINT_MAX - 0.5;
+ var[2] = var[1] + av_lfg_get(&lfg) / (double) UINT_MAX - 0.5;
+ var[3] = var[2] + av_lfg_get(&lfg) / (double) UINT_MAX - 0.5;
+ m.update_lls(&m, var);
+ avpriv_solve_lls(&m, 0.001, 0);
+ for (order = 0; order < 3; order++) {
+ eval = m.evaluate_lls(&m, var + 1, order);
+ printf("real:%9f order:%d pred:%9f var:%f coeffs:%f %9f %9f\n",
+ var[0], order, eval, sqrt(m.variance[order] / (i + 1)),
+ m.coeff[order][0], m.coeff[order][1],
+ m.coeff[order][2]);
+ }
+ }
+ return 0;
+}
diff --git a/libavutil/lls.c b/libavutil/lls.c
index c5753ae574d5bb92bd80d68bb140aafe34ce4bbb..0560b6a79caf76ded3c696d90403da8c84555332 100644
--- a/libavutil/lls.c
+++ b/libavutil/lls.c
@@ -121,41 +121,3 @@ av_cold void avpriv_init_lls(LLSModel *m, int indep_count)
if (ARCH_X86)
ff_init_lls_x86(m);
}
-
-#ifdef TEST
-
-#include <stdio.h>
-#include <limits.h>
-#include "lfg.h"
-
-int main(void)
-{
- LLSModel m;
- int i, order;
- AVLFG lfg;
-
- av_lfg_init(&lfg, 1);
- avpriv_init_lls(&m, 3);
-
- for (i = 0; i < 100; i++) {
- LOCAL_ALIGNED(32, double, var, [4]);
- double eval;
-
- var[0] = (av_lfg_get(&lfg) / (double) UINT_MAX - 0.5) * 2;
- var[1] = var[0] + av_lfg_get(&lfg) / (double) UINT_MAX - 0.5;
- var[2] = var[1] + av_lfg_get(&lfg) / (double) UINT_MAX - 0.5;
- var[3] = var[2] + av_lfg_get(&lfg) / (double) UINT_MAX - 0.5;
- m.update_lls(&m, var);
- avpriv_solve_lls(&m, 0.001, 0);
- for (order = 0; order < 3; order++) {
- eval = m.evaluate_lls(&m, var + 1, order);
- printf("real:%9f order:%d pred:%9f var:%f coeffs:%f %9f %9f\n",
- var[0], order, eval, sqrt(m.variance[order] / (i + 1)),
- m.coeff[order][0], m.coeff[order][1],
- m.coeff[order][2]);
- }
- }
- return 0;
-}
-
-#endif
diff --git a/libavutil/log-test.c b/libavutil/log-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..14d476436f2c36d8e16afffe6f66dc2f6b64bea0
--- /dev/null
+++ b/libavutil/log-test.c
@@ -0,0 +1,71 @@
+/*
+ * log functions
+ * Copyright (c) 2003 Michel Bardiaux
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "log.c"
+
+#include <string.h>
+
+static int call_log_format_line2(const char *fmt, char *buffer, int buffer_size, ...)
+{
+ va_list args;
+ int ret;
+ int print_prefix=1;
+ va_start(args, buffer_size);
+ ret = av_log_format_line2(NULL, AV_LOG_INFO, fmt, args, buffer, buffer_size, &print_prefix);
+ va_end(args);
+ return ret;
+}
+
+int main(int argc, char **argv)
+{
+ int i;
+ av_log_set_level(AV_LOG_DEBUG);
+ for (use_color=0; use_color<=256; use_color = 255*use_color+1) {
+ av_log(NULL, AV_LOG_FATAL, "use_color: %d\n", use_color);
+ for (i = AV_LOG_DEBUG; i>=AV_LOG_QUIET; i-=8) {
+ av_log(NULL, i, " %d", i);
+ av_log(NULL, AV_LOG_INFO, "e ");
+ av_log(NULL, i + 256*123, "C%d", i);
+ av_log(NULL, AV_LOG_INFO, "e");
+ }
+ av_log(NULL, AV_LOG_PANIC, "\n");
+ }
+ {
+ int result;
+ char buffer[4];
+ result = call_log_format_line2("foo", NULL, 0);
+ if(result != 3) {
+ printf("Test NULL buffer failed.\n");
+ return 1;
+ }
+ result = call_log_format_line2("foo", buffer, 2);
+ if(result != 3 || strncmp(buffer, "f", 2)) {
+ printf("Test buffer too small failed.\n");
+ return 1;
+ }
+ result = call_log_format_line2("foo", buffer, 4);
+ if(result != 3 || strncmp(buffer, "foo", 4)) {
+ printf("Test buffer sufficiently big failed.\n");
+ return 1;
+ }
+ }
+ return 0;
+}
diff --git a/libavutil/log.c b/libavutil/log.c
index 7e279ad6cb2f78616a4fdb65b6a47406f3e4bc02..44c11cb0917e856b19a6634e775683b243e2e8a6 100644
--- a/libavutil/log.c
+++ b/libavutil/log.c
@@ -439,56 +439,3 @@ void avpriv_report_missing_feature(void *avc, const char *msg, ...)
missing_feature_sample(0, avc, msg, argument_list);
va_end(argument_list);
}
-
-#ifdef TEST
-// LCOV_EXCL_START
-#include <string.h>
-
-static int call_log_format_line2(const char *fmt, char *buffer, int buffer_size, ...)
-{
- va_list args;
- int ret;
- int print_prefix=1;
- va_start(args, buffer_size);
- ret = av_log_format_line2(NULL, AV_LOG_INFO, fmt, args, buffer, buffer_size, &print_prefix);
- va_end(args);
- return ret;
-}
-
-int main(int argc, char **argv)
-{
- int i;
- av_log_set_level(AV_LOG_DEBUG);
- for (use_color=0; use_color<=256; use_color = 255*use_color+1) {
- av_log(NULL, AV_LOG_FATAL, "use_color: %d\n", use_color);
- for (i = AV_LOG_DEBUG; i>=AV_LOG_QUIET; i-=8) {
- av_log(NULL, i, " %d", i);
- av_log(NULL, AV_LOG_INFO, "e ");
- av_log(NULL, i + 256*123, "C%d", i);
- av_log(NULL, AV_LOG_INFO, "e");
- }
- av_log(NULL, AV_LOG_PANIC, "\n");
- }
- {
- int result;
- char buffer[4];
- result = call_log_format_line2("foo", NULL, 0);
- if(result != 3) {
- printf("Test NULL buffer failed.\n");
- return 1;
- }
- result = call_log_format_line2("foo", buffer, 2);
- if(result != 3 || strncmp(buffer, "f", 2)) {
- printf("Test buffer too small failed.\n");
- return 1;
- }
- result = call_log_format_line2("foo", buffer, 4);
- if(result != 3 || strncmp(buffer, "foo", 4)) {
- printf("Test buffer sufficiently big failed.\n");
- return 1;
- }
- }
- return 0;
-}
-// LCOV_EXCL_STOP
-#endif
diff --git a/libavutil/md5-test.c b/libavutil/md5-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..547f74b8809b2b10c0fbff8d8d49213beea144ec
--- /dev/null
+++ b/libavutil/md5-test.c
@@ -0,0 +1,55 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+
+#include "md5.h"
+
+static void print_md5(uint8_t *md5)
+{
+ int i;
+ for (i = 0; i < 16; i++)
+ printf("%02x", md5[i]);
+ printf("\n");
+}
+
+int main(void)
+{
+ uint8_t md5val[16];
+ int i;
+ volatile uint8_t in[1000]; // volatile to workaround http://llvm.org/bugs/show_bug.cgi?id=20849
+ // FIXME remove volatile once it has been fixed and all fate clients are updated
+
+ for (i = 0; i < 1000; i++)
+ in[i] = i * i;
+ av_md5_sum(md5val, in, 1000);
+ print_md5(md5val);
+ av_md5_sum(md5val, in, 63);
+ print_md5(md5val);
+ av_md5_sum(md5val, in, 64);
+ print_md5(md5val);
+ av_md5_sum(md5val, in, 65);
+ print_md5(md5val);
+ for (i = 0; i < 1000; i++)
+ in[i] = i % 127;
+ av_md5_sum(md5val, in, 999);
+ print_md5(md5val);
+
+ return 0;
+}
diff --git a/libavutil/md5.c b/libavutil/md5.c
index 482582b5d1071547e622a4f1f8fafbc33d93408d..057085b937d59e53829970a144284c83fc8ddcab 100644
--- a/libavutil/md5.c
+++ b/libavutil/md5.c
@@ -212,40 +212,3 @@ void av_md5_sum(uint8_t *dst, const uint8_t *src, const int len)
av_md5_update(&ctx, src, len);
av_md5_final(&ctx, dst);
}
-
-#ifdef TEST
-#include <stdio.h>
-
-static void print_md5(uint8_t *md5)
-{
- int i;
- for (i = 0; i < 16; i++)
- printf("%02x", md5[i]);
- printf("\n");
-}
-
-int main(void)
-{
- uint8_t md5val[16];
- int i;
- volatile uint8_t in[1000]; // volatile to workaround http://llvm.org/bugs/show_bug.cgi?id=20849
- // FIXME remove volatile once it has been fixed and all fate clients are updated
-
- for (i = 0; i < 1000; i++)
- in[i] = i * i;
- av_md5_sum(md5val, in, 1000);
- print_md5(md5val);
- av_md5_sum(md5val, in, 63);
- print_md5(md5val);
- av_md5_sum(md5val, in, 64);
- print_md5(md5val);
- av_md5_sum(md5val, in, 65);
- print_md5(md5val);
- for (i = 0; i < 1000; i++)
- in[i] = i % 127;
- av_md5_sum(md5val, in, 999);
- print_md5(md5val);
-
- return 0;
-}
-#endif
diff --git a/libavutil/murmur3-test.c b/libavutil/murmur3-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..19ea0a46ffe64f157f77c113f43d9a179ab01a46
--- /dev/null
+++ b/libavutil/murmur3-test.c
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2013 Reimar Döffinger <Reimar.Doeffinger@gmx.de>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "murmur3.c"
+
+int main(void)
+{
+ int i;
+ uint8_t hash_result[16] = {0};
+ AVMurMur3 *ctx = av_murmur3_alloc();
+#if 1
+ uint8_t in[256] = {0};
+ uint8_t *hashes = av_mallocz(256 * 16);
+ for (i = 0; i < 256; i++)
+ {
+ in[i] = i;
+ av_murmur3_init_seeded(ctx, 256 - i);
+ // Note: this actually tests hashing 0 bytes
+ av_murmur3_update(ctx, in, i);
+ av_murmur3_final(ctx, hashes + 16 * i);
+ }
+ av_murmur3_init_seeded(ctx, 0);
+ av_murmur3_update(ctx, hashes, 256 * 16);
+ av_murmur3_final(ctx, hash_result);
+ av_free(hashes);
+ av_freep(&ctx);
+ printf("result: 0x%"PRIx64" 0x%"PRIx64"\n", AV_RL64(hash_result), AV_RL64(hash_result + 8));
+ // official reference value is 32 bit
+ return AV_RL32(hash_result) != 0x6384ba69;
+#else
+ uint8_t *in = av_mallocz(512*1024);
+ av_murmur3_init(ctx);
+ for (i = 0; i < 40*1024; i++)
+ av_murmur3_update(ctx, in, 512*1024);
+ av_murmur3_final(ctx, hash_result);
+ av_free(in);
+ return hash_result[0];
+#endif
+}
diff --git a/libavutil/murmur3.c b/libavutil/murmur3.c
index c4d8dcb529f047fff4bd08f2c2c3538e251a0126..4271e01453f77237eb71d9babb989004b0728d04 100644
--- a/libavutil/murmur3.c
+++ b/libavutil/murmur3.c
@@ -153,40 +153,3 @@ void av_murmur3_final(AVMurMur3 *c, uint8_t dst[16])
AV_WL64(dst, h1);
AV_WL64(dst + 8, h2);
}
-
-#ifdef TEST
-int main(void)
-{
- int i;
- uint8_t hash_result[16] = {0};
- AVMurMur3 *ctx = av_murmur3_alloc();
-#if 1
- uint8_t in[256] = {0};
- uint8_t *hashes = av_mallocz(256 * 16);
- for (i = 0; i < 256; i++)
- {
- in[i] = i;
- av_murmur3_init_seeded(ctx, 256 - i);
- // Note: this actually tests hashing 0 bytes
- av_murmur3_update(ctx, in, i);
- av_murmur3_final(ctx, hashes + 16 * i);
- }
- av_murmur3_init_seeded(ctx, 0);
- av_murmur3_update(ctx, hashes, 256 * 16);
- av_murmur3_final(ctx, hash_result);
- av_free(hashes);
- av_freep(&ctx);
- printf("result: 0x%"PRIx64" 0x%"PRIx64"\n", AV_RL64(hash_result), AV_RL64(hash_result + 8));
- // official reference value is 32 bit
- return AV_RL32(hash_result) != 0x6384ba69;
-#else
- uint8_t *in = av_mallocz(512*1024);
- av_murmur3_init(ctx);
- for (i = 0; i < 40*1024; i++)
- av_murmur3_update(ctx, in, 512*1024);
- av_murmur3_final(ctx, hash_result);
- av_free(in);
- return hash_result[0];
-#endif
-}
-#endif
diff --git a/libavutil/opt-test.c b/libavutil/opt-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..1f813d69a59e45c84d9f367a5615f57d00c785b7
--- /dev/null
+++ b/libavutil/opt-test.c
@@ -0,0 +1,312 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <limits.h>
+#include <stdio.h>
+
+#include "common.h"
+#include "channel_layout.h"
+#include "error.h"
+#include "log.h"
+#include "mem.h"
+#include "rational.h"
+#include "opt.h"
+#include "pixdesc.h"
+
+typedef struct TestContext {
+ const AVClass *class;
+ int num;
+ int toggle;
+ char *string;
+ int flags;
+ AVRational rational;
+ AVRational video_rate;
+ int w, h;
+ enum AVPixelFormat pix_fmt;
+ enum AVSampleFormat sample_fmt;
+ int64_t duration;
+ uint8_t color[4];
+ int64_t channel_layout;
+ void *binary;
+ int binary_size;
+ void *binary1;
+ int binary_size1;
+ void *binary2;
+ int binary_size2;
+ int64_t num64;
+ float flt;
+ double dbl;
+ char *escape;
+ int bool1;
+ int bool2;
+ int bool3;
+} TestContext;
+
+#define OFFSET(x) offsetof(TestContext, x)
+
+#define TEST_FLAG_COOL 01
+#define TEST_FLAG_LAME 02
+#define TEST_FLAG_MU 04
+
+static const AVOption test_options[]= {
+ {"num", "set num", OFFSET(num), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 100, 1 },
+ {"toggle", "set toggle", OFFSET(toggle), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, 1 },
+ {"rational", "set rational", OFFSET(rational), AV_OPT_TYPE_RATIONAL, { .dbl = 1 }, 0, 10, 1 },
+ {"string", "set string", OFFSET(string), AV_OPT_TYPE_STRING, { .str = "default" }, CHAR_MIN, CHAR_MAX, 1 },
+ {"escape", "set escape str", OFFSET(escape), AV_OPT_TYPE_STRING, { .str = "\\=," }, CHAR_MIN, CHAR_MAX, 1 },
+ {"flags", "set flags", OFFSET(flags), AV_OPT_TYPE_FLAGS, { .i64 = 1 }, 0, INT_MAX, 1, "flags" },
+ {"cool", "set cool flag", 0, AV_OPT_TYPE_CONST, { .i64 = TEST_FLAG_COOL }, INT_MIN, INT_MAX, 1, "flags" },
+ {"lame", "set lame flag", 0, AV_OPT_TYPE_CONST, { .i64 = TEST_FLAG_LAME }, INT_MIN, INT_MAX, 1, "flags" },
+ {"mu", "set mu flag", 0, AV_OPT_TYPE_CONST, { .i64 = TEST_FLAG_MU }, INT_MIN, INT_MAX, 1, "flags" },
+ {"size", "set size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, { .str="200x300" }, 0, 0, 1 },
+ {"pix_fmt", "set pixfmt", OFFSET(pix_fmt), AV_OPT_TYPE_PIXEL_FMT, { .i64 = AV_PIX_FMT_0BGR }, -1, INT_MAX, 1 },
+ {"sample_fmt", "set samplefmt", OFFSET(sample_fmt), AV_OPT_TYPE_SAMPLE_FMT, { .i64 = AV_SAMPLE_FMT_S16 }, -1, INT_MAX, 1 },
+ {"video_rate", "set videorate", OFFSET(video_rate), AV_OPT_TYPE_VIDEO_RATE, { .str = "25" }, 0, 0, 1 },
+ {"duration", "set duration", OFFSET(duration), AV_OPT_TYPE_DURATION, { .i64 = 1000 }, 0, INT64_MAX, 1 },
+ {"color", "set color", OFFSET(color), AV_OPT_TYPE_COLOR, { .str = "pink" }, 0, 0, 1 },
+ {"cl", "set channel layout", OFFSET(channel_layout), AV_OPT_TYPE_CHANNEL_LAYOUT, { .i64 = AV_CH_LAYOUT_HEXAGONAL }, 0, INT64_MAX, 1 },
+ {"bin", "set binary value", OFFSET(binary), AV_OPT_TYPE_BINARY, { .str="62696e00" }, 0, 0, 1 },
+ {"bin1", "set binary value", OFFSET(binary1), AV_OPT_TYPE_BINARY, { .str=NULL }, 0, 0, 1 },
+ {"bin2", "set binary value", OFFSET(binary2), AV_OPT_TYPE_BINARY, { .str="" }, 0, 0, 1 },
+ {"num64", "set num 64bit", OFFSET(num64), AV_OPT_TYPE_INT64, { .i64 = 1 }, 0, 100, 1 },
+ {"flt", "set float", OFFSET(flt), AV_OPT_TYPE_FLOAT, { .dbl = 1.0 / 3 }, 0, 100, 1 },
+ {"dbl", "set double", OFFSET(dbl), AV_OPT_TYPE_DOUBLE, { .dbl = 1.0 / 3 }, 0, 100, 1 },
+ {"bool1", "set boolean value", OFFSET(bool1), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, 1 },
+ {"bool2", "set boolean value", OFFSET(bool2), AV_OPT_TYPE_BOOL, { .i64 = 1 }, -1, 1, 1 },
+ {"bool3", "set boolean value", OFFSET(bool3), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, 1 },
+ { NULL },
+};
+
+static const char *test_get_name(void *ctx)
+{
+ return "test";
+}
+
+static const AVClass test_class = {
+ "TestContext",
+ test_get_name,
+ test_options
+};
+
+static void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
+{
+ vfprintf(stdout, fmt, vl);
+}
+
+int main(void)
+{
+ int i;
+
+ av_log_set_level(AV_LOG_DEBUG);
+ av_log_set_callback(log_callback_help);
+
+ printf("Testing default values\n");
+ {
+ TestContext test_ctx = { 0 };
+ test_ctx.class = &test_class;
+ av_opt_set_defaults(&test_ctx);
+
+ printf("num=%d\n", test_ctx.num);
+ printf("toggle=%d\n", test_ctx.toggle);
+ printf("string=%s\n", test_ctx.string);
+ printf("escape=%s\n", test_ctx.escape);
+ printf("flags=%d\n", test_ctx.flags);
+ printf("rational=%d/%d\n", test_ctx.rational.num, test_ctx.rational.den);
+ printf("video_rate=%d/%d\n", test_ctx.video_rate.num, test_ctx.video_rate.den);
+ printf("width=%d height=%d\n", test_ctx.w, test_ctx.h);
+ printf("pix_fmt=%s\n", av_get_pix_fmt_name(test_ctx.pix_fmt));
+ printf("sample_fmt=%s\n", av_get_sample_fmt_name(test_ctx.sample_fmt));
+ printf("duration=%"PRId64"\n", test_ctx.duration);
+ printf("color=%d %d %d %d\n", test_ctx.color[0], test_ctx.color[1], test_ctx.color[2], test_ctx.color[3]);
+ printf("channel_layout=%"PRId64"=%"PRId64"\n", test_ctx.channel_layout, (int64_t)AV_CH_LAYOUT_HEXAGONAL);
+ if (test_ctx.binary)
+ printf("binary=%x %x %x %x\n", ((uint8_t*)test_ctx.binary)[0], ((uint8_t*)test_ctx.binary)[1], ((uint8_t*)test_ctx.binary)[2], ((uint8_t*)test_ctx.binary)[3]);
+ printf("binary_size=%d\n", test_ctx.binary_size);
+ printf("num64=%"PRId64"\n", test_ctx.num64);
+ printf("flt=%.6f\n", test_ctx.flt);
+ printf("dbl=%.6f\n", test_ctx.dbl);
+
+ av_opt_show2(&test_ctx, NULL, -1, 0);
+
+ av_opt_free(&test_ctx);
+ }
+
+ printf("\nTesting av_opt_is_set_to_default()\n");
+ {
+ int ret;
+ TestContext test_ctx = { 0 };
+ const AVOption *o = NULL;
+ test_ctx.class = &test_class;
+
+ av_log_set_level(AV_LOG_QUIET);
+
+ while (o = av_opt_next(&test_ctx, o)) {
+ ret = av_opt_is_set_to_default_by_name(&test_ctx, o->name, 0);
+ printf("name:%10s default:%d error:%s\n", o->name, !!ret, ret < 0 ? av_err2str(ret) : "");
+ }
+ av_opt_set_defaults(&test_ctx);
+ while (o = av_opt_next(&test_ctx, o)) {
+ ret = av_opt_is_set_to_default_by_name(&test_ctx, o->name, 0);
+ printf("name:%10s default:%d error:%s\n", o->name, !!ret, ret < 0 ? av_err2str(ret) : "");
+ }
+ av_opt_free(&test_ctx);
+ }
+
+ printf("\nTest av_opt_serialize()\n");
+ {
+ TestContext test_ctx = { 0 };
+ char *buf;
+ test_ctx.class = &test_class;
+
+ av_log_set_level(AV_LOG_QUIET);
+
+ av_opt_set_defaults(&test_ctx);
+ if (av_opt_serialize(&test_ctx, 0, 0, &buf, '=', ',') >= 0) {
+ printf("%s\n", buf);
+ av_opt_free(&test_ctx);
+ memset(&test_ctx, 0, sizeof(test_ctx));
+ test_ctx.class = &test_class;
+ av_set_options_string(&test_ctx, buf, "=", ",");
+ av_free(buf);
+ if (av_opt_serialize(&test_ctx, 0, 0, &buf, '=', ',') >= 0) {
+ printf("%s\n", buf);
+ av_free(buf);
+ }
+ }
+ av_opt_free(&test_ctx);
+ }
+
+ printf("\nTesting av_set_options_string()\n");
+ {
+ TestContext test_ctx = { 0 };
+ static const char * const options[] = {
+ "",
+ ":",
+ "=",
+ "foo=:",
+ ":=foo",
+ "=foo",
+ "foo=",
+ "foo",
+ "foo=val",
+ "foo==val",
+ "toggle=:",
+ "string=:",
+ "toggle=1 : foo",
+ "toggle=100",
+ "toggle==1",
+ "flags=+mu-lame : num=42: toggle=0",
+ "num=42 : string=blahblah",
+ "rational=0 : rational=1/2 : rational=1/-1",
+ "rational=-1/0",
+ "size=1024x768",
+ "size=pal",
+ "size=bogus",
+ "pix_fmt=yuv420p",
+ "pix_fmt=2",
+ "pix_fmt=bogus",
+ "sample_fmt=s16",
+ "sample_fmt=2",
+ "sample_fmt=bogus",
+ "video_rate=pal",
+ "video_rate=25",
+ "video_rate=30000/1001",
+ "video_rate=30/1.001",
+ "video_rate=bogus",
+ "duration=bogus",
+ "duration=123.45",
+ "duration=1\\:23\\:45.67",
+ "color=blue",
+ "color=0x223300",
+ "color=0x42FF07AA",
+ "cl=stereo+downmix",
+ "cl=foo",
+ "bin=boguss",
+ "bin=111",
+ "bin=ffff",
+ "num64=bogus",
+ "num64=44",
+ "num64=44.4",
+ "num64=-1",
+ "num64=101",
+ "flt=bogus",
+ "flt=2",
+ "flt=2.2",
+ "flt=-1",
+ "flt=101",
+ "dbl=bogus",
+ "dbl=2",
+ "dbl=2.2",
+ "dbl=-1",
+ "dbl=101",
+ "bool1=true",
+ "bool2=auto",
+ };
+
+ test_ctx.class = &test_class;
+ av_opt_set_defaults(&test_ctx);
+
+ av_log_set_level(AV_LOG_QUIET);
+
+ for (i=0; i < FF_ARRAY_ELEMS(options); i++) {
+ int silence_log = !strcmp(options[i], "rational=-1/0"); // inf formating differs between platforms
+ av_log(&test_ctx, AV_LOG_DEBUG, "Setting options string '%s'\n", options[i]);
+ if (silence_log)
+ av_log_set_callback(NULL);
+ if (av_set_options_string(&test_ctx, options[i], "=", ":") < 0)
+ printf("Error '%s'\n", options[i]);
+ else
+ printf("OK '%s'\n", options[i]);
+ av_log_set_callback(log_callback_help);
+ }
+ av_opt_free(&test_ctx);
+ }
+
+ printf("\nTesting av_opt_set_from_string()\n");
+ {
+ TestContext test_ctx = { 0 };
+ static const char * const options[] = {
+ "",
+ "5",
+ "5:hello",
+ "5:hello:size=pal",
+ "5:size=pal:hello",
+ ":",
+ "=",
+ " 5 : hello : size = pal ",
+ "a_very_long_option_name_that_will_need_to_be_ellipsized_around_here=42"
+ };
+ static const char * const shorthand[] = { "num", "string", NULL };
+
+ test_ctx.class = &test_class;
+ av_opt_set_defaults(&test_ctx);
+
+ av_log_set_level(AV_LOG_QUIET);
+
+ for (i=0; i < FF_ARRAY_ELEMS(options); i++) {
+ av_log(&test_ctx, AV_LOG_DEBUG, "Setting options string '%s'\n", options[i]);
+ if (av_opt_set_from_string(&test_ctx, options[i], shorthand, "=", ":") < 0)
+ printf("Error '%s'\n", options[i]);
+ else
+ printf("OK '%s'\n", options[i]);
+ }
+ av_opt_free(&test_ctx);
+ }
+
+ return 0;
+}
diff --git a/libavutil/opt.c b/libavutil/opt.c
index e63bd8a5ce35be0628a06bd7f7aed265448cb99b..7e9ad8f4b28c6b5b826f6701dc30e634c7d65302 100644
--- a/libavutil/opt.c
+++ b/libavutil/opt.c
@@ -1987,290 +1987,3 @@ int av_opt_serialize(void *obj, int opt_flags, int flags, char **buffer,
av_bprint_finalize(&bprint, buffer);
return 0;
}
-
-#ifdef TEST
-
-typedef struct TestContext {
- const AVClass *class;
- int num;
- int toggle;
- char *string;
- int flags;
- AVRational rational;
- AVRational video_rate;
- int w, h;
- enum AVPixelFormat pix_fmt;
- enum AVSampleFormat sample_fmt;
- int64_t duration;
- uint8_t color[4];
- int64_t channel_layout;
- void *binary;
- int binary_size;
- void *binary1;
- int binary_size1;
- void *binary2;
- int binary_size2;
- int64_t num64;
- float flt;
- double dbl;
- char *escape;
- int bool1;
- int bool2;
- int bool3;
-} TestContext;
-
-#define OFFSET(x) offsetof(TestContext, x)
-
-#define TEST_FLAG_COOL 01
-#define TEST_FLAG_LAME 02
-#define TEST_FLAG_MU 04
-
-static const AVOption test_options[]= {
- {"num", "set num", OFFSET(num), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 100, 1 },
- {"toggle", "set toggle", OFFSET(toggle), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, 1 },
- {"rational", "set rational", OFFSET(rational), AV_OPT_TYPE_RATIONAL, { .dbl = 1 }, 0, 10, 1 },
- {"string", "set string", OFFSET(string), AV_OPT_TYPE_STRING, { .str = "default" }, CHAR_MIN, CHAR_MAX, 1 },
- {"escape", "set escape str", OFFSET(escape), AV_OPT_TYPE_STRING, { .str = "\\=," }, CHAR_MIN, CHAR_MAX, 1 },
- {"flags", "set flags", OFFSET(flags), AV_OPT_TYPE_FLAGS, { .i64 = 1 }, 0, INT_MAX, 1, "flags" },
- {"cool", "set cool flag", 0, AV_OPT_TYPE_CONST, { .i64 = TEST_FLAG_COOL }, INT_MIN, INT_MAX, 1, "flags" },
- {"lame", "set lame flag", 0, AV_OPT_TYPE_CONST, { .i64 = TEST_FLAG_LAME }, INT_MIN, INT_MAX, 1, "flags" },
- {"mu", "set mu flag", 0, AV_OPT_TYPE_CONST, { .i64 = TEST_FLAG_MU }, INT_MIN, INT_MAX, 1, "flags" },
- {"size", "set size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, { .str="200x300" }, 0, 0, 1 },
- {"pix_fmt", "set pixfmt", OFFSET(pix_fmt), AV_OPT_TYPE_PIXEL_FMT, { .i64 = AV_PIX_FMT_0BGR }, -1, INT_MAX, 1 },
- {"sample_fmt", "set samplefmt", OFFSET(sample_fmt), AV_OPT_TYPE_SAMPLE_FMT, { .i64 = AV_SAMPLE_FMT_S16 }, -1, INT_MAX, 1 },
- {"video_rate", "set videorate", OFFSET(video_rate), AV_OPT_TYPE_VIDEO_RATE, { .str = "25" }, 0, 0, 1 },
- {"duration", "set duration", OFFSET(duration), AV_OPT_TYPE_DURATION, { .i64 = 1000 }, 0, INT64_MAX, 1 },
- {"color", "set color", OFFSET(color), AV_OPT_TYPE_COLOR, { .str = "pink" }, 0, 0, 1 },
- {"cl", "set channel layout", OFFSET(channel_layout), AV_OPT_TYPE_CHANNEL_LAYOUT, { .i64 = AV_CH_LAYOUT_HEXAGONAL }, 0, INT64_MAX, 1 },
- {"bin", "set binary value", OFFSET(binary), AV_OPT_TYPE_BINARY, { .str="62696e00" }, 0, 0, 1 },
- {"bin1", "set binary value", OFFSET(binary1), AV_OPT_TYPE_BINARY, { .str=NULL }, 0, 0, 1 },
- {"bin2", "set binary value", OFFSET(binary2), AV_OPT_TYPE_BINARY, { .str="" }, 0, 0, 1 },
- {"num64", "set num 64bit", OFFSET(num64), AV_OPT_TYPE_INT64, { .i64 = 1 }, 0, 100, 1 },
- {"flt", "set float", OFFSET(flt), AV_OPT_TYPE_FLOAT, { .dbl = 1.0 / 3 }, 0, 100, 1 },
- {"dbl", "set double", OFFSET(dbl), AV_OPT_TYPE_DOUBLE, { .dbl = 1.0 / 3 }, 0, 100, 1 },
- {"bool1", "set boolean value", OFFSET(bool1), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, 1 },
- {"bool2", "set boolean value", OFFSET(bool2), AV_OPT_TYPE_BOOL, { .i64 = 1 }, -1, 1, 1 },
- {"bool3", "set boolean value", OFFSET(bool3), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, 1 },
- { NULL },
-};
-
-static const char *test_get_name(void *ctx)
-{
- return "test";
-}
-
-static const AVClass test_class = {
- "TestContext",
- test_get_name,
- test_options
-};
-
-static void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
-{
- vfprintf(stdout, fmt, vl);
-}
-
-int main(void)
-{
- int i;
-
- av_log_set_level(AV_LOG_DEBUG);
- av_log_set_callback(log_callback_help);
-
- printf("Testing default values\n");
- {
- TestContext test_ctx = { 0 };
- test_ctx.class = &test_class;
- av_opt_set_defaults(&test_ctx);
-
- printf("num=%d\n", test_ctx.num);
- printf("toggle=%d\n", test_ctx.toggle);
- printf("string=%s\n", test_ctx.string);
- printf("escape=%s\n", test_ctx.escape);
- printf("flags=%d\n", test_ctx.flags);
- printf("rational=%d/%d\n", test_ctx.rational.num, test_ctx.rational.den);
- printf("video_rate=%d/%d\n", test_ctx.video_rate.num, test_ctx.video_rate.den);
- printf("width=%d height=%d\n", test_ctx.w, test_ctx.h);
- printf("pix_fmt=%s\n", av_get_pix_fmt_name(test_ctx.pix_fmt));
- printf("sample_fmt=%s\n", av_get_sample_fmt_name(test_ctx.sample_fmt));
- printf("duration=%"PRId64"\n", test_ctx.duration);
- printf("color=%d %d %d %d\n", test_ctx.color[0], test_ctx.color[1], test_ctx.color[2], test_ctx.color[3]);
- printf("channel_layout=%"PRId64"=%"PRId64"\n", test_ctx.channel_layout, (int64_t)AV_CH_LAYOUT_HEXAGONAL);
- if (test_ctx.binary)
- printf("binary=%x %x %x %x\n", ((uint8_t*)test_ctx.binary)[0], ((uint8_t*)test_ctx.binary)[1], ((uint8_t*)test_ctx.binary)[2], ((uint8_t*)test_ctx.binary)[3]);
- printf("binary_size=%d\n", test_ctx.binary_size);
- printf("num64=%"PRId64"\n", test_ctx.num64);
- printf("flt=%.6f\n", test_ctx.flt);
- printf("dbl=%.6f\n", test_ctx.dbl);
-
- av_opt_show2(&test_ctx, NULL, -1, 0);
-
- av_opt_free(&test_ctx);
- }
-
- printf("\nTesting av_opt_is_set_to_default()\n");
- {
- int ret;
- TestContext test_ctx = { 0 };
- const AVOption *o = NULL;
- test_ctx.class = &test_class;
-
- av_log_set_level(AV_LOG_QUIET);
-
- while (o = av_opt_next(&test_ctx, o)) {
- ret = av_opt_is_set_to_default_by_name(&test_ctx, o->name, 0);
- printf("name:%10s default:%d error:%s\n", o->name, !!ret, ret < 0 ? av_err2str(ret) : "");
- }
- av_opt_set_defaults(&test_ctx);
- while (o = av_opt_next(&test_ctx, o)) {
- ret = av_opt_is_set_to_default_by_name(&test_ctx, o->name, 0);
- printf("name:%10s default:%d error:%s\n", o->name, !!ret, ret < 0 ? av_err2str(ret) : "");
- }
- av_opt_free(&test_ctx);
- }
-
- printf("\nTest av_opt_serialize()\n");
- {
- TestContext test_ctx = { 0 };
- char *buf;
- test_ctx.class = &test_class;
-
- av_log_set_level(AV_LOG_QUIET);
-
- av_opt_set_defaults(&test_ctx);
- if (av_opt_serialize(&test_ctx, 0, 0, &buf, '=', ',') >= 0) {
- printf("%s\n", buf);
- av_opt_free(&test_ctx);
- memset(&test_ctx, 0, sizeof(test_ctx));
- test_ctx.class = &test_class;
- av_set_options_string(&test_ctx, buf, "=", ",");
- av_free(buf);
- if (av_opt_serialize(&test_ctx, 0, 0, &buf, '=', ',') >= 0) {
- printf("%s\n", buf);
- av_free(buf);
- }
- }
- av_opt_free(&test_ctx);
- }
-
- printf("\nTesting av_set_options_string()\n");
- {
- TestContext test_ctx = { 0 };
- static const char * const options[] = {
- "",
- ":",
- "=",
- "foo=:",
- ":=foo",
- "=foo",
- "foo=",
- "foo",
- "foo=val",
- "foo==val",
- "toggle=:",
- "string=:",
- "toggle=1 : foo",
- "toggle=100",
- "toggle==1",
- "flags=+mu-lame : num=42: toggle=0",
- "num=42 : string=blahblah",
- "rational=0 : rational=1/2 : rational=1/-1",
- "rational=-1/0",
- "size=1024x768",
- "size=pal",
- "size=bogus",
- "pix_fmt=yuv420p",
- "pix_fmt=2",
- "pix_fmt=bogus",
- "sample_fmt=s16",
- "sample_fmt=2",
- "sample_fmt=bogus",
- "video_rate=pal",
- "video_rate=25",
- "video_rate=30000/1001",
- "video_rate=30/1.001",
- "video_rate=bogus",
- "duration=bogus",
- "duration=123.45",
- "duration=1\\:23\\:45.67",
- "color=blue",
- "color=0x223300",
- "color=0x42FF07AA",
- "cl=stereo+downmix",
- "cl=foo",
- "bin=boguss",
- "bin=111",
- "bin=ffff",
- "num64=bogus",
- "num64=44",
- "num64=44.4",
- "num64=-1",
- "num64=101",
- "flt=bogus",
- "flt=2",
- "flt=2.2",
- "flt=-1",
- "flt=101",
- "dbl=bogus",
- "dbl=2",
- "dbl=2.2",
- "dbl=-1",
- "dbl=101",
- "bool1=true",
- "bool2=auto",
- };
-
- test_ctx.class = &test_class;
- av_opt_set_defaults(&test_ctx);
-
- av_log_set_level(AV_LOG_QUIET);
-
- for (i=0; i < FF_ARRAY_ELEMS(options); i++) {
- int silence_log = !strcmp(options[i], "rational=-1/0"); // inf formating differs between platforms
- av_log(&test_ctx, AV_LOG_DEBUG, "Setting options string '%s'\n", options[i]);
- if (silence_log)
- av_log_set_callback(NULL);
- if (av_set_options_string(&test_ctx, options[i], "=", ":") < 0)
- printf("Error '%s'\n", options[i]);
- else
- printf("OK '%s'\n", options[i]);
- av_log_set_callback(log_callback_help);
- }
- av_opt_free(&test_ctx);
- }
-
- printf("\nTesting av_opt_set_from_string()\n");
- {
- TestContext test_ctx = { 0 };
- static const char * const options[] = {
- "",
- "5",
- "5:hello",
- "5:hello:size=pal",
- "5:size=pal:hello",
- ":",
- "=",
- " 5 : hello : size = pal ",
- "a_very_long_option_name_that_will_need_to_be_ellipsized_around_here=42"
- };
- static const char * const shorthand[] = { "num", "string", NULL };
-
- test_ctx.class = &test_class;
- av_opt_set_defaults(&test_ctx);
-
- av_log_set_level(AV_LOG_QUIET);
-
- for (i=0; i < FF_ARRAY_ELEMS(options); i++) {
- av_log(&test_ctx, AV_LOG_DEBUG, "Setting options string '%s'\n", options[i]);
- if (av_opt_set_from_string(&test_ctx, options[i], shorthand, "=", ":") < 0)
- printf("Error '%s'\n", options[i]);
- else
- printf("OK '%s'\n", options[i]);
- }
- av_opt_free(&test_ctx);
- }
-
- return 0;
-}
-
-#endif
diff --git a/libavutil/parseutils-test.c b/libavutil/parseutils-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..fa9c1c1d053f65d26f1c3debe7377bc7d2af4e5c
--- /dev/null
+++ b/libavutil/parseutils-test.c
@@ -0,0 +1,260 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#define TEST
+#include "parseutils.c"
+
+#include <stdint.h>
+#include <stdio.h>
+
+#include "common.h"
+#include "log.h"
+#include "rational.h"
+
+static uint32_t randomv = MKTAG('L','A','V','U');
+
+static uint32_t av_get_random_seed_deterministic(void)
+{
+ return randomv = randomv * 1664525 + 1013904223;
+}
+
+static void test_av_parse_video_rate(void)
+{
+ int i;
+ static const char *const rates[] = {
+ "-inf",
+ "inf",
+ "nan",
+ "123/0",
+ "-123 / 0",
+ "",
+ "/",
+ " 123 / 321",
+ "foo/foo",
+ "foo/1",
+ "1/foo",
+ "0/0",
+ "/0",
+ "1/",
+ "1",
+ "0",
+ "-123/123",
+ "-foo",
+ "123.23",
+ ".23",
+ "-.23",
+ "-0.234",
+ "-0.0000001",
+ " 21332.2324 ",
+ " -21332.2324 ",
+ };
+
+ for (i = 0; i < FF_ARRAY_ELEMS(rates); i++) {
+ int ret;
+ AVRational q = { 0, 0 };
+ ret = av_parse_video_rate(&q, rates[i]);
+ printf("'%s' -> %d/%d %s\n",
+ rates[i], q.num, q.den, ret ? "ERROR" : "OK");
+ }
+}
+
+static void test_av_parse_color(void)
+{
+ int i;
+ uint8_t rgba[4];
+ static const char *const color_names[] = {
+ "bikeshed",
+ "RaNdOm",
+ "foo",
+ "red",
+ "Red ",
+ "RED",
+ "Violet",
+ "Yellow",
+ "Red",
+ "0x000000",
+ "0x0000000",
+ "0xff000000",
+ "0x3e34ff",
+ "0x3e34ffaa",
+ "0xffXXee",
+ "0xfoobar",
+ "0xffffeeeeeeee",
+ "#ff0000",
+ "#ffXX00",
+ "ff0000",
+ "ffXX00",
+ "red@foo",
+ "random@10",
+ "0xff0000@1.0",
+ "red@",
+ "red@0xfff",
+ "red@0xf",
+ "red@2",
+ "red@0.1",
+ "red@-1",
+ "red@0.5",
+ "red@1.0",
+ "red@256",
+ "red@10foo",
+ "red@-1.0",
+ "red@-0.0",
+ };
+
+ av_log_set_level(AV_LOG_DEBUG);
+
+ for (i = 0; i < FF_ARRAY_ELEMS(color_names); i++) {
+ if (av_parse_color(rgba, color_names[i], -1, NULL) >= 0)
+ printf("%s -> R(%d) G(%d) B(%d) A(%d)\n",
+ color_names[i], rgba[0], rgba[1], rgba[2], rgba[3]);
+ else
+ printf("%s -> error\n", color_names[i]);
+ }
+}
+
+static void test_av_small_strptime(void)
+{
+ int i;
+ struct tm tm = { 0 };
+ struct fmt_timespec_entry {
+ const char *fmt, *timespec;
+ } fmt_timespec_entries[] = {
+ { "%Y-%m-%d", "2012-12-21" },
+ { "%Y - %m - %d", "2012-12-21" },
+ { "%Y-%m-%d %H:%M:%S", "2012-12-21 20:12:21" },
+ { " %Y - %m - %d %H : %M : %S", " 2012 - 12 - 21 20 : 12 : 21" },
+ };
+
+ av_log_set_level(AV_LOG_DEBUG);
+ for (i = 0; i < FF_ARRAY_ELEMS(fmt_timespec_entries); i++) {
+ char *p;
+ struct fmt_timespec_entry *e = &fmt_timespec_entries[i];
+ printf("fmt:'%s' spec:'%s' -> ", e->fmt, e->timespec);
+ p = av_small_strptime(e->timespec, e->fmt, &tm);
+ if (p) {
+ printf("%04d-%02d-%2d %02d:%02d:%02d\n",
+ 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
+ tm.tm_hour, tm.tm_min, tm.tm_sec);
+ } else {
+ printf("error\n");
+ }
+ }
+}
+
+static void test_av_parse_time(void)
+{
+ int i;
+ int64_t tv;
+ time_t tvi;
+ struct tm *tm;
+ static char tzstr[] = "TZ=CET-1";
+ static const char * const time_string[] = {
+ "now",
+ "12:35:46",
+ "2000-12-20 0:02:47.5z",
+ "2012 - 02-22 17:44:07",
+ "2000-12-20T010247.6",
+ "2000-12-12 1:35:46+05:30",
+ "2002-12-12 22:30:40-02",
+ };
+ static const char * const duration_string[] = {
+ "2:34:56.79",
+ "-1:23:45.67",
+ "42.1729",
+ "-1729.42",
+ "12:34",
+ };
+
+ av_log_set_level(AV_LOG_DEBUG);
+ putenv(tzstr);
+ printf("(now is 2012-03-17 09:14:13.2 +0100, local time is UTC+1)\n");
+ for (i = 0; i < FF_ARRAY_ELEMS(time_string); i++) {
+ printf("%-24s -> ", time_string[i]);
+ if (av_parse_time(&tv, time_string[i], 0)) {
+ printf("error\n");
+ } else {
+ tvi = tv / 1000000;
+ tm = gmtime(&tvi);
+ printf("%14"PRIi64".%06d = %04d-%02d-%02dT%02d:%02d:%02dZ\n",
+ tv / 1000000, (int)(tv % 1000000),
+ tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
+ tm->tm_hour, tm->tm_min, tm->tm_sec);
+ }
+ }
+ for (i = 0; i < FF_ARRAY_ELEMS(duration_string); i++) {
+ printf("%-24s -> ", duration_string[i]);
+ if (av_parse_time(&tv, duration_string[i], 1)) {
+ printf("error\n");
+ } else {
+ printf("%+21"PRIi64"\n", tv);
+ }
+ }
+}
+
+static void test_av_get_known_color_name(void)
+{
+ int i;
+ const uint8_t *rgba;
+ const char *color;
+
+ for (i = 0; i < FF_ARRAY_ELEMS(color_table); ++i) {
+ color = av_get_known_color_name(i, &rgba);
+ if (color)
+ printf("%s -> R(%d) G(%d) B(%d) A(%d)\n",
+ color, rgba[0], rgba[1], rgba[2], rgba[3]);
+ else
+ printf("Color ID: %d not found\n", i);
+ }
+}
+
+static void test_av_find_info_tag(void)
+{
+ static const char args[] = "?tag1=val1&tag2=val2&tag3=val3&tag41=value 41&tag42=random1";
+ static const char *tags[] = {"tag1", "tag2", "tag3", "tag4", "tag41", "41", "random1"};
+ char buff[16];
+ int i;
+
+ for (i = 0; i < FF_ARRAY_ELEMS(tags); ++i) {
+ if (av_find_info_tag(buff, sizeof(buff), tags[i], args))
+ printf("%d. %s found: %s\n", i, tags[i], buff);
+ else
+ printf("%d. %s not found\n", i, tags[i]);
+ }
+}
+
+int main(void)
+{
+ printf("Testing av_parse_video_rate()\n");
+ test_av_parse_video_rate();
+
+ printf("\nTesting av_parse_color()\n");
+ test_av_parse_color();
+
+ printf("\nTesting av_small_strptime()\n");
+ test_av_small_strptime();
+
+ printf("\nTesting av_parse_time()\n");
+ test_av_parse_time();
+
+ printf("\nTesting av_get_known_color_name()\n");
+ test_av_get_known_color_name();
+
+ printf("\nTesting av_find_info_tag()\n");
+ test_av_find_info_tag();
+ return 0;
+}
diff --git a/libavutil/parseutils.c b/libavutil/parseutils.c
index e0534fd77dfeeb376233dbf5d3f23faaccfb1567..a4efd796283c186790ee2920e8f54c9f2fd35f8f 100644
--- a/libavutil/parseutils.c
+++ b/libavutil/parseutils.c
@@ -739,240 +739,3 @@ int av_find_info_tag(char *arg, int arg_size, const char *tag1, const char *info
}
return 0;
}
-
-#ifdef TEST
-
-static uint32_t randomv = MKTAG('L','A','V','U');
-
-static uint32_t av_get_random_seed_deterministic(void)
-{
- return randomv = randomv * 1664525 + 1013904223;
-}
-
-static void test_av_parse_video_rate(void)
-{
- int i;
- static const char *const rates[] = {
- "-inf",
- "inf",
- "nan",
- "123/0",
- "-123 / 0",
- "",
- "/",
- " 123 / 321",
- "foo/foo",
- "foo/1",
- "1/foo",
- "0/0",
- "/0",
- "1/",
- "1",
- "0",
- "-123/123",
- "-foo",
- "123.23",
- ".23",
- "-.23",
- "-0.234",
- "-0.0000001",
- " 21332.2324 ",
- " -21332.2324 ",
- };
-
- for (i = 0; i < FF_ARRAY_ELEMS(rates); i++) {
- int ret;
- AVRational q = { 0, 0 };
- ret = av_parse_video_rate(&q, rates[i]);
- printf("'%s' -> %d/%d %s\n",
- rates[i], q.num, q.den, ret ? "ERROR" : "OK");
- }
-}
-
-static void test_av_parse_color(void)
-{
- int i;
- uint8_t rgba[4];
- static const char *const color_names[] = {
- "bikeshed",
- "RaNdOm",
- "foo",
- "red",
- "Red ",
- "RED",
- "Violet",
- "Yellow",
- "Red",
- "0x000000",
- "0x0000000",
- "0xff000000",
- "0x3e34ff",
- "0x3e34ffaa",
- "0xffXXee",
- "0xfoobar",
- "0xffffeeeeeeee",
- "#ff0000",
- "#ffXX00",
- "ff0000",
- "ffXX00",
- "red@foo",
- "random@10",
- "0xff0000@1.0",
- "red@",
- "red@0xfff",
- "red@0xf",
- "red@2",
- "red@0.1",
- "red@-1",
- "red@0.5",
- "red@1.0",
- "red@256",
- "red@10foo",
- "red@-1.0",
- "red@-0.0",
- };
-
- av_log_set_level(AV_LOG_DEBUG);
-
- for (i = 0; i < FF_ARRAY_ELEMS(color_names); i++) {
- if (av_parse_color(rgba, color_names[i], -1, NULL) >= 0)
- printf("%s -> R(%d) G(%d) B(%d) A(%d)\n",
- color_names[i], rgba[0], rgba[1], rgba[2], rgba[3]);
- else
- printf("%s -> error\n", color_names[i]);
- }
-}
-
-static void test_av_small_strptime(void)
-{
- int i;
- struct tm tm = { 0 };
- struct fmt_timespec_entry {
- const char *fmt, *timespec;
- } fmt_timespec_entries[] = {
- { "%Y-%m-%d", "2012-12-21" },
- { "%Y - %m - %d", "2012-12-21" },
- { "%Y-%m-%d %H:%M:%S", "2012-12-21 20:12:21" },
- { " %Y - %m - %d %H : %M : %S", " 2012 - 12 - 21 20 : 12 : 21" },
- };
-
- av_log_set_level(AV_LOG_DEBUG);
- for (i = 0; i < FF_ARRAY_ELEMS(fmt_timespec_entries); i++) {
- char *p;
- struct fmt_timespec_entry *e = &fmt_timespec_entries[i];
- printf("fmt:'%s' spec:'%s' -> ", e->fmt, e->timespec);
- p = av_small_strptime(e->timespec, e->fmt, &tm);
- if (p) {
- printf("%04d-%02d-%2d %02d:%02d:%02d\n",
- 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
- tm.tm_hour, tm.tm_min, tm.tm_sec);
- } else {
- printf("error\n");
- }
- }
-}
-
-static void test_av_parse_time(void)
-{
- int i;
- int64_t tv;
- time_t tvi;
- struct tm *tm;
- static char tzstr[] = "TZ=CET-1";
- static const char * const time_string[] = {
- "now",
- "12:35:46",
- "2000-12-20 0:02:47.5z",
- "2012 - 02-22 17:44:07",
- "2000-12-20T010247.6",
- "2000-12-12 1:35:46+05:30",
- "2002-12-12 22:30:40-02",
- };
- static const char * const duration_string[] = {
- "2:34:56.79",
- "-1:23:45.67",
- "42.1729",
- "-1729.42",
- "12:34",
- };
-
- av_log_set_level(AV_LOG_DEBUG);
- putenv(tzstr);
- printf("(now is 2012-03-17 09:14:13.2 +0100, local time is UTC+1)\n");
- for (i = 0; i < FF_ARRAY_ELEMS(time_string); i++) {
- printf("%-24s -> ", time_string[i]);
- if (av_parse_time(&tv, time_string[i], 0)) {
- printf("error\n");
- } else {
- tvi = tv / 1000000;
- tm = gmtime(&tvi);
- printf("%14"PRIi64".%06d = %04d-%02d-%02dT%02d:%02d:%02dZ\n",
- tv / 1000000, (int)(tv % 1000000),
- tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
- tm->tm_hour, tm->tm_min, tm->tm_sec);
- }
- }
- for (i = 0; i < FF_ARRAY_ELEMS(duration_string); i++) {
- printf("%-24s -> ", duration_string[i]);
- if (av_parse_time(&tv, duration_string[i], 1)) {
- printf("error\n");
- } else {
- printf("%+21"PRIi64"\n", tv);
- }
- }
-}
-
-static void test_av_get_known_color_name(void)
-{
- int i;
- const uint8_t *rgba;
- const char *color;
-
- for (i = 0; i < FF_ARRAY_ELEMS(color_table); ++i) {
- color = av_get_known_color_name(i, &rgba);
- if (color)
- printf("%s -> R(%d) G(%d) B(%d) A(%d)\n",
- color, rgba[0], rgba[1], rgba[2], rgba[3]);
- else
- printf("Color ID: %d not found\n", i);
- }
-}
-
-static void test_av_find_info_tag(void)
-{
- static const char args[] = "?tag1=val1&tag2=val2&tag3=val3&tag41=value 41&tag42=random1";
- static const char *tags[] = {"tag1", "tag2", "tag3", "tag4", "tag41", "41", "random1"};
- char buff[16];
- int i;
-
- for (i = 0; i < FF_ARRAY_ELEMS(tags); ++i) {
- if (av_find_info_tag(buff, sizeof(buff), tags[i], args))
- printf("%d. %s found: %s\n", i, tags[i], buff);
- else
- printf("%d. %s not found\n", i, tags[i]);
- }
-}
-
-int main(void)
-{
- printf("Testing av_parse_video_rate()\n");
- test_av_parse_video_rate();
-
- printf("\nTesting av_parse_color()\n");
- test_av_parse_color();
-
- printf("\nTesting av_small_strptime()\n");
- test_av_small_strptime();
-
- printf("\nTesting av_parse_time()\n");
- test_av_parse_time();
-
- printf("\nTesting av_get_known_color_name()\n");
- test_av_get_known_color_name();
-
- printf("\nTesting av_find_info_tag()\n");
- test_av_find_info_tag();
- return 0;
-}
-
-#endif /* TEST */
diff --git a/libavutil/pca-test.c b/libavutil/pca-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..e56d6185b1e9d3c06978ff79c7b7b486da3281a9
--- /dev/null
+++ b/libavutil/pca-test.c
@@ -0,0 +1,102 @@
+/*
+ * principal component analysis (PCA)
+ * Copyright (c) 2004 Michael Niedermayer <michaelni@gmx.at>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "pca.c"
+#include "lfg.h"
+
+#undef printf
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void){
+ PCA *pca;
+ int i, j, k;
+#define LEN 8
+ double eigenvector[LEN*LEN];
+ double eigenvalue[LEN];
+ AVLFG prng;
+
+ av_lfg_init(&prng, 1);
+
+ pca= ff_pca_init(LEN);
+
+ for(i=0; i<9000000; i++){
+ double v[2*LEN+100];
+ double sum=0;
+ int pos = av_lfg_get(&prng) % LEN;
+ int v2 = av_lfg_get(&prng) % 101 - 50;
+ v[0] = av_lfg_get(&prng) % 101 - 50;
+ for(j=1; j<8; j++){
+ if(j<=pos) v[j]= v[0];
+ else v[j]= v2;
+ sum += v[j];
+ }
+/* for(j=0; j<LEN; j++){
+ v[j] -= v[pos];
+ }*/
+// sum += av_lfg_get(&prng) % 10;
+/* for(j=0; j<LEN; j++){
+ v[j] -= sum/LEN;
+ }*/
+// lbt1(v+100,v+100,LEN);
+ ff_pca_add(pca, v);
+ }
+
+
+ ff_pca(pca, eigenvector, eigenvalue);
+ for(i=0; i<LEN; i++){
+ pca->count= 1;
+ pca->mean[i]= 0;
+
+// (0.5^|x|)^2 = 0.5^2|x| = 0.25^|x|
+
+
+// pca.covariance[i + i*LEN]= pow(0.5, fabs
+ for(j=i; j<LEN; j++){
+ printf("%f ", pca->covariance[i + j*LEN]);
+ }
+ printf("\n");
+ }
+
+ for(i=0; i<LEN; i++){
+ double v[LEN];
+ double error=0;
+ memset(v, 0, sizeof(v));
+ for(j=0; j<LEN; j++){
+ for(k=0; k<LEN; k++){
+ v[j] += pca->covariance[FFMIN(k,j) + FFMAX(k,j)*LEN] * eigenvector[i + k*LEN];
+ }
+ v[j] /= eigenvalue[i];
+ error += fabs(v[j] - eigenvector[i + j*LEN]);
+ }
+ printf("%f ", error);
+ }
+ printf("\n");
+
+ for(i=0; i<LEN; i++){
+ for(j=0; j<LEN; j++){
+ printf("%9.6f ", eigenvector[i + j*LEN]);
+ }
+ printf(" %9.1f %f\n", eigenvalue[i], eigenvalue[i]/eigenvalue[0]);
+ }
+
+ return 0;
+}
diff --git a/libavutil/pca.c b/libavutil/pca.c
index 1d88ff300afb34563ab974423c4304660c348419..4e52c7b362cc16f4694952ce8e4614b87cd758d0 100644
--- a/libavutil/pca.c
+++ b/libavutil/pca.c
@@ -171,86 +171,3 @@ int ff_pca(PCA *pca, double *eigenvector, double *eigenvalue){
return -1;
}
-
-#ifdef TEST
-
-#undef printf
-#include <stdio.h>
-#include <stdlib.h>
-#include "lfg.h"
-
-int main(void){
- PCA *pca;
- int i, j, k;
-#define LEN 8
- double eigenvector[LEN*LEN];
- double eigenvalue[LEN];
- AVLFG prng;
-
- av_lfg_init(&prng, 1);
-
- pca= ff_pca_init(LEN);
-
- for(i=0; i<9000000; i++){
- double v[2*LEN+100];
- double sum=0;
- int pos = av_lfg_get(&prng) % LEN;
- int v2 = av_lfg_get(&prng) % 101 - 50;
- v[0] = av_lfg_get(&prng) % 101 - 50;
- for(j=1; j<8; j++){
- if(j<=pos) v[j]= v[0];
- else v[j]= v2;
- sum += v[j];
- }
-/* for(j=0; j<LEN; j++){
- v[j] -= v[pos];
- }*/
-// sum += av_lfg_get(&prng) % 10;
-/* for(j=0; j<LEN; j++){
- v[j] -= sum/LEN;
- }*/
-// lbt1(v+100,v+100,LEN);
- ff_pca_add(pca, v);
- }
-
-
- ff_pca(pca, eigenvector, eigenvalue);
- for(i=0; i<LEN; i++){
- pca->count= 1;
- pca->mean[i]= 0;
-
-// (0.5^|x|)^2 = 0.5^2|x| = 0.25^|x|
-
-
-// pca.covariance[i + i*LEN]= pow(0.5, fabs
- for(j=i; j<LEN; j++){
- printf("%f ", pca->covariance[i + j*LEN]);
- }
- printf("\n");
- }
-
- for(i=0; i<LEN; i++){
- double v[LEN];
- double error=0;
- memset(v, 0, sizeof(v));
- for(j=0; j<LEN; j++){
- for(k=0; k<LEN; k++){
- v[j] += pca->covariance[FFMIN(k,j) + FFMAX(k,j)*LEN] * eigenvector[i + k*LEN];
- }
- v[j] /= eigenvalue[i];
- error += fabs(v[j] - eigenvector[i + j*LEN]);
- }
- printf("%f ", error);
- }
- printf("\n");
-
- for(i=0; i<LEN; i++){
- for(j=0; j<LEN; j++){
- printf("%9.6f ", eigenvector[i + j*LEN]);
- }
- printf(" %9.1f %f\n", eigenvalue[i], eigenvalue[i]/eigenvalue[0]);
- }
-
- return 0;
-}
-#endif
diff --git a/libavutil/pixdesc-test.c b/libavutil/pixdesc-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..cd7d4c5f7b492b776cde571b21143869700e8a2a
--- /dev/null
+++ b/libavutil/pixdesc-test.c
@@ -0,0 +1,46 @@
+/*
+ * pixel format descriptor
+ * Copyright (c) 2009 Michael Niedermayer <michaelni@gmx.at>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "pixdesc.c"
+
+int main(void){
+ int i;
+ int err=0;
+ int skip = 0;
+
+ for (i=0; i<AV_PIX_FMT_NB*2; i++) {
+ const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(i);
+ if(!desc || !desc->name) {
+ skip ++;
+ continue;
+ }
+ if (skip) {
+ av_log(NULL, AV_LOG_INFO, "%3d unused pixel format values\n", skip);
+ skip = 0;
+ }
+ av_log(NULL, AV_LOG_INFO, "pix fmt %s avg_bpp:%d colortype:%d\n", desc->name, av_get_padded_bits_per_pixel(desc), get_color_type(desc));
+ if ((!(desc->flags & AV_PIX_FMT_FLAG_ALPHA)) != (desc->nb_components != 2 && desc->nb_components != 4)) {
+ av_log(NULL, AV_LOG_ERROR, "Alpha flag mismatch\n");
+ err = 1;
+ }
+ }
+ return err;
+}
diff --git a/libavutil/pixdesc.c b/libavutil/pixdesc.c
index 8a9475c4e3f5f6f6df970d6aba3cd935dcb69877..c630d840ce9772ef2773a01643b686268440a155 100644
--- a/libavutil/pixdesc.c
+++ b/libavutil/pixdesc.c
@@ -2532,32 +2532,3 @@ const char *av_chroma_location_name(enum AVChromaLocation location)
return (unsigned) location < AVCHROMA_LOC_NB ?
chroma_location_names[location] : NULL;
}
-
-#ifdef TEST
-
-int main(void){
- int i;
- int err=0;
- int skip = 0;
-
- for (i=0; i<AV_PIX_FMT_NB*2; i++) {
- const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(i);
- if(!desc || !desc->name) {
- skip ++;
- continue;
- }
- if (skip) {
- av_log(NULL, AV_LOG_INFO, "%3d unused pixel format values\n", skip);
- skip = 0;
- }
- av_log(NULL, AV_LOG_INFO, "pix fmt %s avg_bpp:%d colortype:%d\n", desc->name, av_get_padded_bits_per_pixel(desc), get_color_type(desc));
- if ((!(desc->flags & AV_PIX_FMT_FLAG_ALPHA)) != (desc->nb_components != 2 && desc->nb_components != 4)) {
- av_log(NULL, AV_LOG_ERROR, "Alpha flag mismatch\n");
- err = 1;
- }
- }
- return err;
-}
-
-#endif
-
diff --git a/libavutil/pixelutils-test.c b/libavutil/pixelutils-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..eebc524c875b5561d54031c84643352423ffcbd9
--- /dev/null
+++ b/libavutil/pixelutils-test.c
@@ -0,0 +1,152 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "pixelutils.c"
+
+#define W1 320
+#define H1 240
+#define W2 640
+#define H2 480
+
+static int run_single_test(const char *test,
+ const uint8_t *block1, ptrdiff_t stride1,
+ const uint8_t *block2, ptrdiff_t stride2,
+ int align, int n)
+{
+ int out, ref;
+ av_pixelutils_sad_fn f_ref = sad_c[n - 1];
+ av_pixelutils_sad_fn f_out = av_pixelutils_get_sad_fn(n, n, align, NULL);
+
+ switch (align) {
+ case 0: block1++; block2++; break;
+ case 1: block2++; break;
+ case 2: break;
+ }
+
+ out = f_out(block1, stride1, block2, stride2);
+ ref = f_ref(block1, stride1, block2, stride2);
+ printf("[%s] [%c%c] SAD [%s] %dx%d=%d ref=%d\n",
+ out == ref ? "OK" : "FAIL",
+ align ? 'A' : 'U', align == 2 ? 'A' : 'U',
+ test, 1<<n, 1<<n, out, ref);
+ return out != ref;
+}
+
+static int run_test(const char *test,
+ const uint8_t *b1, const uint8_t *b2)
+{
+ int i, a, ret = 0;
+
+ for (a = 0; a < 3; a++) {
+ const uint8_t *block1 = b1;
+ const uint8_t *block2 = b2;
+
+ switch (a) {
+ case 0: block1++; block2++; break;
+ case 1: block2++; break;
+ case 2: break;
+ }
+ for (i = 1; i <= FF_ARRAY_ELEMS(sad_c); i++) {
+ int r = run_single_test(test, b1, W1, b2, W2, a, i);
+ if (r)
+ ret = r;
+ }
+ }
+ return ret;
+}
+
+int main(void)
+{
+ int i, align, ret;
+ uint8_t *buf1 = av_malloc(W1*H1);
+ uint8_t *buf2 = av_malloc(W2*H2);
+ uint32_t state = 0;
+
+ if (!buf1 || !buf2) {
+ fprintf(stderr, "malloc failure\n");
+ ret = 1;
+ goto end;
+ }
+
+ ff_check_pixfmt_descriptors();
+
+#define RANDOM_INIT(buf, size) do { \
+ int k; \
+ for (k = 0; k < size; k++) { \
+ state = state * 1664525 + 1013904223; \
+ buf[k] = state>>24; \
+ } \
+} while (0)
+
+ /* Normal test with different strides */
+ RANDOM_INIT(buf1, W1*H1);
+ RANDOM_INIT(buf2, W2*H2);
+ ret = run_test("random", buf1, buf2);
+ if (ret < 0)
+ goto end;
+
+ /* Check for maximum SAD */
+ memset(buf1, 0xff, W1*H1);
+ memset(buf2, 0x00, W2*H2);
+ ret = run_test("max", buf1, buf2);
+ if (ret < 0)
+ goto end;
+
+ /* Check for minimum SAD */
+ memset(buf1, 0x90, W1*H1);
+ memset(buf2, 0x90, W2*H2);
+ ret = run_test("min", buf1, buf2);
+ if (ret < 0)
+ goto end;
+
+ /* Exact buffer sizes, to check for overreads */
+ for (i = 1; i <= 4; i++) {
+ for (align = 0; align < 3; align++) {
+ int size1, size2;
+
+ av_freep(&buf1);
+ av_freep(&buf2);
+
+ size1 = size2 = 1 << (i << 1);
+
+ switch (align) {
+ case 0: size1++; size2++; break;
+ case 1: size2++; break;
+ case 2: break;
+ }
+
+ buf1 = av_malloc(size1);
+ buf2 = av_malloc(size2);
+ if (!buf1 || !buf2) {
+ fprintf(stderr, "malloc failure\n");
+ ret = 1;
+ goto end;
+ }
+ RANDOM_INIT(buf1, size1);
+ RANDOM_INIT(buf2, size2);
+ ret = run_single_test("small", buf1, 1<<i, buf2, 1<<i, align, i);
+ if (ret < 0)
+ goto end;
+ }
+ }
+
+end:
+ av_free(buf1);
+ av_free(buf2);
+ return ret;
+}
diff --git a/libavutil/pixelutils.c b/libavutil/pixelutils.c
index 1ec4fbb0ec868d7eed3eae3c1ad6c1e0fb7a1f94..b663027b42eba3e361686dfb7c145e1499eb7faf 100644
--- a/libavutil/pixelutils.c
+++ b/libavutil/pixelutils.c
@@ -85,138 +85,3 @@ av_pixelutils_sad_fn av_pixelutils_get_sad_fn(int w_bits, int h_bits, int aligne
return sad[w_bits - 1];
#endif
}
-
-#ifdef TEST
-#define W1 320
-#define H1 240
-#define W2 640
-#define H2 480
-
-static int run_single_test(const char *test,
- const uint8_t *block1, ptrdiff_t stride1,
- const uint8_t *block2, ptrdiff_t stride2,
- int align, int n)
-{
- int out, ref;
- av_pixelutils_sad_fn f_ref = sad_c[n - 1];
- av_pixelutils_sad_fn f_out = av_pixelutils_get_sad_fn(n, n, align, NULL);
-
- switch (align) {
- case 0: block1++; block2++; break;
- case 1: block2++; break;
- case 2: break;
- }
-
- out = f_out(block1, stride1, block2, stride2);
- ref = f_ref(block1, stride1, block2, stride2);
- printf("[%s] [%c%c] SAD [%s] %dx%d=%d ref=%d\n",
- out == ref ? "OK" : "FAIL",
- align ? 'A' : 'U', align == 2 ? 'A' : 'U',
- test, 1<<n, 1<<n, out, ref);
- return out != ref;
-}
-
-static int run_test(const char *test,
- const uint8_t *b1, const uint8_t *b2)
-{
- int i, a, ret = 0;
-
- for (a = 0; a < 3; a++) {
- const uint8_t *block1 = b1;
- const uint8_t *block2 = b2;
-
- switch (a) {
- case 0: block1++; block2++; break;
- case 1: block2++; break;
- case 2: break;
- }
- for (i = 1; i <= FF_ARRAY_ELEMS(sad_c); i++) {
- int r = run_single_test(test, b1, W1, b2, W2, a, i);
- if (r)
- ret = r;
- }
- }
- return ret;
-}
-
-int main(void)
-{
- int i, align, ret;
- uint8_t *buf1 = av_malloc(W1*H1);
- uint8_t *buf2 = av_malloc(W2*H2);
- uint32_t state = 0;
-
- if (!buf1 || !buf2) {
- fprintf(stderr, "malloc failure\n");
- ret = 1;
- goto end;
- }
-
- ff_check_pixfmt_descriptors();
-
-#define RANDOM_INIT(buf, size) do { \
- int k; \
- for (k = 0; k < size; k++) { \
- state = state * 1664525 + 1013904223; \
- buf[k] = state>>24; \
- } \
-} while (0)
-
- /* Normal test with different strides */
- RANDOM_INIT(buf1, W1*H1);
- RANDOM_INIT(buf2, W2*H2);
- ret = run_test("random", buf1, buf2);
- if (ret < 0)
- goto end;
-
- /* Check for maximum SAD */
- memset(buf1, 0xff, W1*H1);
- memset(buf2, 0x00, W2*H2);
- ret = run_test("max", buf1, buf2);
- if (ret < 0)
- goto end;
-
- /* Check for minimum SAD */
- memset(buf1, 0x90, W1*H1);
- memset(buf2, 0x90, W2*H2);
- ret = run_test("min", buf1, buf2);
- if (ret < 0)
- goto end;
-
- /* Exact buffer sizes, to check for overreads */
- for (i = 1; i <= 4; i++) {
- for (align = 0; align < 3; align++) {
- int size1, size2;
-
- av_freep(&buf1);
- av_freep(&buf2);
-
- size1 = size2 = 1 << (i << 1);
-
- switch (align) {
- case 0: size1++; size2++; break;
- case 1: size2++; break;
- case 2: break;
- }
-
- buf1 = av_malloc(size1);
- buf2 = av_malloc(size2);
- if (!buf1 || !buf2) {
- fprintf(stderr, "malloc failure\n");
- ret = 1;
- goto end;
- }
- RANDOM_INIT(buf1, size1);
- RANDOM_INIT(buf2, size2);
- ret = run_single_test("small", buf1, 1<<i, buf2, 1<<i, align, i);
- if (ret < 0)
- goto end;
- }
- }
-
-end:
- av_free(buf1);
- av_free(buf2);
- return ret;
-}
-#endif /* TEST */
diff --git a/libavutil/random_seed-test.c b/libavutil/random_seed-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..182c8a6dd61de621c72e474f32b85c0ea61ec169
--- /dev/null
+++ b/libavutil/random_seed-test.c
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2009 Baptiste Coudurier <baptiste.coudurier@gmail.com>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#define TEST 1
+#include "random_seed.c"
+
+#undef printf
+#define N 256
+#include <stdio.h>
+
+int main(void)
+{
+ int i, j, retry;
+ uint32_t seeds[N];
+
+ for (retry=0; retry<3; retry++){
+ for (i=0; i<N; i++){
+ seeds[i] = av_get_random_seed();
+ for (j=0; j<i; j++)
+ if (seeds[j] == seeds[i])
+ goto retry;
+ }
+ printf("seeds OK\n");
+ return 0;
+ retry:;
+ }
+ printf("FAIL at %d with %X\n", j, seeds[j]);
+ return 1;
+}
diff --git a/libavutil/random_seed.c b/libavutil/random_seed.c
index 0821550bc87dd496627e6e345350d306d170089b..d1ded7b50960c6ede82b65b291be0c790b979556 100644
--- a/libavutil/random_seed.c
+++ b/libavutil/random_seed.c
@@ -136,29 +136,3 @@ uint32_t av_get_random_seed(void)
return seed;
return get_generic_seed();
}
-
-#if TEST
-#undef printf
-#define N 256
-#include <stdio.h>
-
-int main(void)
-{
- int i, j, retry;
- uint32_t seeds[N];
-
- for (retry=0; retry<3; retry++){
- for (i=0; i<N; i++){
- seeds[i] = av_get_random_seed();
- for (j=0; j<i; j++)
- if (seeds[j] == seeds[i])
- goto retry;
- }
- printf("seeds OK\n");
- return 0;
- retry:;
- }
- printf("FAIL at %d with %X\n", j, seeds[j]);
- return 1;
-}
-#endif
diff --git a/libavutil/rational-test.c b/libavutil/rational-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..455d9c42b28abbfdd186518a5908e1ade50afa6e
--- /dev/null
+++ b/libavutil/rational-test.c
@@ -0,0 +1,135 @@
+/*
+ * rational numbers
+ * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "rational.c"
+
+#include "integer.h"
+
+int main(void)
+{
+ AVRational a,b,r;
+ int i,j,k;
+ static const int64_t numlist[] = {
+ INT64_MIN, INT64_MIN+1, INT64_MAX, INT32_MIN, INT32_MAX, 1,0,-1,
+ 123456789, INT32_MAX-1, INT32_MAX+1LL, UINT32_MAX-1, UINT32_MAX, UINT32_MAX+1LL
+ };
+
+ for (a.num = -2; a.num <= 2; a.num++) {
+ for (a.den = -2; a.den <= 2; a.den++) {
+ for (b.num = -2; b.num <= 2; b.num++) {
+ for (b.den = -2; b.den <= 2; b.den++) {
+ int c = av_cmp_q(a,b);
+ double d = av_q2d(a) == av_q2d(b) ?
+ 0 : (av_q2d(a) - av_q2d(b));
+ if (d > 0) d = 1;
+ else if (d < 0) d = -1;
+ else if (d != d) d = INT_MIN;
+ if (c != d)
+ av_log(NULL, AV_LOG_ERROR, "%d/%d %d/%d, %d %f\n", a.num,
+ a.den, b.num, b.den, c,d);
+ r = av_sub_q(av_add_q(b,a), b);
+ if(b.den && (r.num*a.den != a.num*r.den || !r.num != !a.num || !r.den != !a.den))
+ av_log(NULL, AV_LOG_ERROR, "%d/%d ", r.num, r.den);
+ }
+ }
+ }
+ }
+
+ for (i = 0; i < FF_ARRAY_ELEMS(numlist); i++) {
+ int64_t a = numlist[i];
+
+ for (j = 0; j < FF_ARRAY_ELEMS(numlist); j++) {
+ int64_t b = numlist[j];
+ if (b<=0)
+ continue;
+ for (k = 0; k < FF_ARRAY_ELEMS(numlist); k++) {
+ int64_t c = numlist[k];
+ int64_t res;
+ AVInteger ai;
+
+ if (c<=0)
+ continue;
+ res = av_rescale_rnd(a,b,c, AV_ROUND_ZERO);
+
+ ai = av_mul_i(av_int2i(a), av_int2i(b));
+ ai = av_div_i(ai, av_int2i(c));
+
+ if (av_cmp_i(ai, av_int2i(INT64_MAX)) > 0 && res == INT64_MIN)
+ continue;
+ if (av_cmp_i(ai, av_int2i(INT64_MIN)) < 0 && res == INT64_MIN)
+ continue;
+ if (av_cmp_i(ai, av_int2i(res)) == 0)
+ continue;
+
+ // Special exception for INT64_MIN, remove this in case INT64_MIN is handled without off by 1 error
+ if (av_cmp_i(ai, av_int2i(res-1)) == 0 && a == INT64_MIN)
+ continue;
+
+ av_log(NULL, AV_LOG_ERROR, "%"PRId64" * %"PRId64" / %"PRId64" = %"PRId64" or %"PRId64"\n", a,b,c, res, av_i2int(ai));
+ }
+ }
+ }
+
+ for (a.num = 1; a.num <= 10; a.num++) {
+ for (a.den = 1; a.den <= 10; a.den++) {
+ if (av_gcd(a.num, a.den) > 1)
+ continue;
+ for (b.num = 1; b.num <= 10; b.num++) {
+ for (b.den = 1; b.den <= 10; b.den++) {
+ int start;
+ if (av_gcd(b.num, b.den) > 1)
+ continue;
+ if (av_cmp_q(b, a) < 0)
+ continue;
+ for (start = 0; start < 10 ; start++) {
+ int acc= start;
+ int i;
+
+ for (i = 0; i<100; i++) {
+ int exact = start + av_rescale_q(i+1, b, a);
+ acc = av_add_stable(a, acc, b, 1);
+ if (FFABS(acc - exact) > 2) {
+ av_log(NULL, AV_LOG_ERROR, "%d/%d %d/%d, %d %d\n", a.num,
+ a.den, b.num, b.den, acc, exact);
+ return 1;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ for (a.den = 1; a.den < 0x100000000U/3; a.den*=3) {
+ for (a.num = -1; a.num < (1<<27); a.num += 1 + a.num/100) {
+ float f = av_int2float(av_q2intfloat(a));
+ float f2 = av_q2d(a);
+ if (fabs(f - f2) > fabs(f)/5000000) {
+ av_log(NULL, AV_LOG_ERROR, "%d/%d %f %f\n", a.num,
+ a.den, f, f2);
+ return 1;
+ }
+
+ }
+ }
+
+ return 0;
+}
diff --git a/libavutil/rational.c b/libavutil/rational.c
index cab443818a66c8b43a89cae244dd87b09fbe9c74..35ee08877f3497379d383b06a7c424a1c940d1cd 100644
--- a/libavutil/rational.c
+++ b/libavutil/rational.c
@@ -182,119 +182,3 @@ uint32_t av_q2intfloat(AVRational q) {
return sign<<31 | (150-shift)<<23 | (n - (1<<23));
}
-
-#ifdef TEST
-
-#include "integer.h"
-
-int main(void)
-{
- AVRational a,b,r;
- int i,j,k;
- static const int64_t numlist[] = {
- INT64_MIN, INT64_MIN+1, INT64_MAX, INT32_MIN, INT32_MAX, 1,0,-1,
- 123456789, INT32_MAX-1, INT32_MAX+1LL, UINT32_MAX-1, UINT32_MAX, UINT32_MAX+1LL
- };
-
- for (a.num = -2; a.num <= 2; a.num++) {
- for (a.den = -2; a.den <= 2; a.den++) {
- for (b.num = -2; b.num <= 2; b.num++) {
- for (b.den = -2; b.den <= 2; b.den++) {
- int c = av_cmp_q(a,b);
- double d = av_q2d(a) == av_q2d(b) ?
- 0 : (av_q2d(a) - av_q2d(b));
- if (d > 0) d = 1;
- else if (d < 0) d = -1;
- else if (d != d) d = INT_MIN;
- if (c != d)
- av_log(NULL, AV_LOG_ERROR, "%d/%d %d/%d, %d %f\n", a.num,
- a.den, b.num, b.den, c,d);
- r = av_sub_q(av_add_q(b,a), b);
- if(b.den && (r.num*a.den != a.num*r.den || !r.num != !a.num || !r.den != !a.den))
- av_log(NULL, AV_LOG_ERROR, "%d/%d ", r.num, r.den);
- }
- }
- }
- }
-
- for (i = 0; i < FF_ARRAY_ELEMS(numlist); i++) {
- int64_t a = numlist[i];
-
- for (j = 0; j < FF_ARRAY_ELEMS(numlist); j++) {
- int64_t b = numlist[j];
- if (b<=0)
- continue;
- for (k = 0; k < FF_ARRAY_ELEMS(numlist); k++) {
- int64_t c = numlist[k];
- int64_t res;
- AVInteger ai;
-
- if (c<=0)
- continue;
- res = av_rescale_rnd(a,b,c, AV_ROUND_ZERO);
-
- ai = av_mul_i(av_int2i(a), av_int2i(b));
- ai = av_div_i(ai, av_int2i(c));
-
- if (av_cmp_i(ai, av_int2i(INT64_MAX)) > 0 && res == INT64_MIN)
- continue;
- if (av_cmp_i(ai, av_int2i(INT64_MIN)) < 0 && res == INT64_MIN)
- continue;
- if (av_cmp_i(ai, av_int2i(res)) == 0)
- continue;
-
- // Special exception for INT64_MIN, remove this in case INT64_MIN is handled without off by 1 error
- if (av_cmp_i(ai, av_int2i(res-1)) == 0 && a == INT64_MIN)
- continue;
-
- av_log(NULL, AV_LOG_ERROR, "%"PRId64" * %"PRId64" / %"PRId64" = %"PRId64" or %"PRId64"\n", a,b,c, res, av_i2int(ai));
- }
- }
- }
-
- for (a.num = 1; a.num <= 10; a.num++) {
- for (a.den = 1; a.den <= 10; a.den++) {
- if (av_gcd(a.num, a.den) > 1)
- continue;
- for (b.num = 1; b.num <= 10; b.num++) {
- for (b.den = 1; b.den <= 10; b.den++) {
- int start;
- if (av_gcd(b.num, b.den) > 1)
- continue;
- if (av_cmp_q(b, a) < 0)
- continue;
- for (start = 0; start < 10 ; start++) {
- int acc= start;
- int i;
-
- for (i = 0; i<100; i++) {
- int exact = start + av_rescale_q(i+1, b, a);
- acc = av_add_stable(a, acc, b, 1);
- if (FFABS(acc - exact) > 2) {
- av_log(NULL, AV_LOG_ERROR, "%d/%d %d/%d, %d %d\n", a.num,
- a.den, b.num, b.den, acc, exact);
- return 1;
- }
- }
- }
- }
- }
- }
- }
-
- for (a.den = 1; a.den < 0x100000000U/3; a.den*=3) {
- for (a.num = -1; a.num < (1<<27); a.num += 1 + a.num/100) {
- float f = av_int2float(av_q2intfloat(a));
- float f2 = av_q2d(a);
- if (fabs(f - f2) > fabs(f)/5000000) {
- av_log(NULL, AV_LOG_ERROR, "%d/%d %f %f\n", a.num,
- a.den, f, f2);
- return 1;
- }
-
- }
- }
-
- return 0;
-}
-#endif
diff --git a/libavutil/ripemd-test.c b/libavutil/ripemd-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..5f1c39cec42d09d112533f895aa2736547fc6124
--- /dev/null
+++ b/libavutil/ripemd-test.c
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2007 Michael Niedermayer <michaelni@gmx.at>
+ * Copyright (C) 2013 James Almer
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "ripemd.c"
+
+#include <stdio.h>
+
+int main(void)
+{
+ int i, j, k;
+ AVRIPEMD ctx;
+ unsigned char digest[40];
+ static const int lengths[4] = { 128, 160, 256, 320 };
+
+ for (j = 0; j < 4; j++) {
+ printf("Testing RIPEMD-%d\n", lengths[j]);
+ for (k = 0; k < 3; k++) {
+ av_ripemd_init(&ctx, lengths[j]);
+ if (k == 0)
+ av_ripemd_update(&ctx, "abc", 3);
+ else if (k == 1)
+ av_ripemd_update(&ctx, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56);
+ else
+ for (i = 0; i < 1000*1000; i++)
+ av_ripemd_update(&ctx, "a", 1);
+ av_ripemd_final(&ctx, digest);
+ for (i = 0; i < lengths[j] >> 3; i++)
+ printf("%02X", digest[i]);
+ putchar('\n');
+ }
+ switch (j) { //test vectors (from ISO:IEC 10118-3 (2004) and http://homes.esat.kuleuven.be/~bosselae/ripemd160.html)
+ case 0:
+ printf("c14a1219 9c66e4ba 84636b0f 69144c77\n"
+ "a1aa0689 d0fafa2d dc22e88b 49133a06\n"
+ "4a7f5723 f954eba1 216c9d8f 6320431f\n");
+ break;
+ case 1:
+ printf("8eb208f7 e05d987a 9b044a8e 98c6b087 f15a0bfc\n"
+ "12a05338 4a9c0c88 e405a06c 27dcf49a da62eb2b\n"
+ "52783243 c1697bdb e16d37f9 7f68f083 25dc1528\n");
+ break;
+ case 2:
+ printf("afbd6e22 8b9d8cbb cef5ca2d 03e6dba1 0ac0bc7d cbe4680e 1e42d2e9 75459b65\n"
+ "38430455 83aac6c8 c8d91285 73e7a980 9afb2a0f 34ccc36e a9e72f16 f6368e3f\n"
+ "ac953744 e10e3151 4c150d4d 8d7b6773 42e33399 788296e4 3ae4850c e4f97978\n");
+ break;
+ case 3:
+ printf("de4c01b3 054f8930 a79d09ae 738e9230 1e5a1708 5beffdc1 b8d11671 3e74f82f a942d64c dbc4682d\n"
+ "d034a795 0cf72202 1ba4b84d f769a5de 2060e259 df4c9bb4 a4268c0e 935bbc74 70a969c9 d072a1ac\n"
+ "bdee37f4 371e2064 6b8b0d86 2dda1629 2ae36f40 965e8c85 09e63d1d bddecc50 3e2b63eb 9245bb66\n");
+ break;
+ }
+ }
+
+ return 0;
+}
diff --git a/libavutil/ripemd.c b/libavutil/ripemd.c
index 6777c994f8cea7aa9b95c4bb5287964c17a59194..b0db2970db8a883803d40fb6f2650602b612c7c5 100644
--- a/libavutil/ripemd.c
+++ b/libavutil/ripemd.c
@@ -549,57 +549,3 @@ void av_ripemd_final(AVRIPEMD* ctx, uint8_t *digest)
for (i = 0; i < ctx->digest_len; i++)
AV_WL32(digest + i*4, ctx->state[i]);
}
-
-#ifdef TEST
-#include <stdio.h>
-
-int main(void)
-{
- int i, j, k;
- AVRIPEMD ctx;
- unsigned char digest[40];
- static const int lengths[4] = { 128, 160, 256, 320 };
-
- for (j = 0; j < 4; j++) {
- printf("Testing RIPEMD-%d\n", lengths[j]);
- for (k = 0; k < 3; k++) {
- av_ripemd_init(&ctx, lengths[j]);
- if (k == 0)
- av_ripemd_update(&ctx, "abc", 3);
- else if (k == 1)
- av_ripemd_update(&ctx, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56);
- else
- for (i = 0; i < 1000*1000; i++)
- av_ripemd_update(&ctx, "a", 1);
- av_ripemd_final(&ctx, digest);
- for (i = 0; i < lengths[j] >> 3; i++)
- printf("%02X", digest[i]);
- putchar('\n');
- }
- switch (j) { //test vectors (from ISO:IEC 10118-3 (2004) and http://homes.esat.kuleuven.be/~bosselae/ripemd160.html)
- case 0:
- printf("c14a1219 9c66e4ba 84636b0f 69144c77\n"
- "a1aa0689 d0fafa2d dc22e88b 49133a06\n"
- "4a7f5723 f954eba1 216c9d8f 6320431f\n");
- break;
- case 1:
- printf("8eb208f7 e05d987a 9b044a8e 98c6b087 f15a0bfc\n"
- "12a05338 4a9c0c88 e405a06c 27dcf49a da62eb2b\n"
- "52783243 c1697bdb e16d37f9 7f68f083 25dc1528\n");
- break;
- case 2:
- printf("afbd6e22 8b9d8cbb cef5ca2d 03e6dba1 0ac0bc7d cbe4680e 1e42d2e9 75459b65\n"
- "38430455 83aac6c8 c8d91285 73e7a980 9afb2a0f 34ccc36e a9e72f16 f6368e3f\n"
- "ac953744 e10e3151 4c150d4d 8d7b6773 42e33399 788296e4 3ae4850c e4f97978\n");
- break;
- case 3:
- printf("de4c01b3 054f8930 a79d09ae 738e9230 1e5a1708 5beffdc1 b8d11671 3e74f82f a942d64c dbc4682d\n"
- "d034a795 0cf72202 1ba4b84d f769a5de 2060e259 df4c9bb4 a4268c0e 935bbc74 70a969c9 d072a1ac\n"
- "bdee37f4 371e2064 6b8b0d86 2dda1629 2ae36f40 965e8c85 09e63d1d bddecc50 3e2b63eb 9245bb66\n");
- break;
- }
- }
-
- return 0;
-}
-#endif
diff --git a/libavutil/sha-test.c b/libavutil/sha-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..1557591c7545eb188fe022b0504d24fa2a8c43f0
--- /dev/null
+++ b/libavutil/sha-test.c
@@ -0,0 +1,69 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "sha.c"
+
+#include <stdio.h>
+
+int main(void)
+{
+ int i, j, k;
+ AVSHA ctx;
+ unsigned char digest[32];
+ static const int lengths[3] = { 160, 224, 256 };
+
+ for (j = 0; j < 3; j++) {
+ printf("Testing SHA-%d\n", lengths[j]);
+ for (k = 0; k < 3; k++) {
+ av_sha_init(&ctx, lengths[j]);
+ if (k == 0)
+ av_sha_update(&ctx, "abc", 3);
+ else if (k == 1)
+ av_sha_update(&ctx, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56);
+ else
+ for (i = 0; i < 1000*1000; i++)
+ av_sha_update(&ctx, "a", 1);
+ av_sha_final(&ctx, digest);
+ for (i = 0; i < lengths[j] >> 3; i++)
+ printf("%02X", digest[i]);
+ putchar('\n');
+ }
+ switch (j) {
+ case 0:
+ //test vectors (from FIPS PUB 180-1)
+ printf("A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D\n"
+ "84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1\n"
+ "34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F\n");
+ break;
+ case 1:
+ //test vectors (from FIPS PUB 180-2 Appendix A)
+ printf("23097d22 3405d822 8642a477 bda255b3 2aadbce4 bda0b3f7 e36c9da7\n"
+ "75388b16 512776cc 5dba5da1 fd890150 b0c6455c b4f58b19 52522525\n"
+ "20794655 980c91d8 bbb4c1ea 97618a4b f03f4258 1948b2ee 4ee7ad67\n");
+ break;
+ case 2:
+ //test vectors (from FIPS PUB 180-2)
+ printf("ba7816bf 8f01cfea 414140de 5dae2223 b00361a3 96177a9c b410ff61 f20015ad\n"
+ "248d6a61 d20638b8 e5c02693 0c3e6039 a33ce459 64ff2167 f6ecedd4 19db06c1\n"
+ "cdc76e5c 9914fb92 81a1c7e2 84d73e67 f1809a48 a497200e 046d39cc c7112cd0\n");
+ break;
+ }
+ }
+
+ return 0;
+}
diff --git a/libavutil/sha.c b/libavutil/sha.c
index 748bb9c558e6fce50736a6e7ef51d4260df2ee50..5b42ccf1b2f009a1ceaa8781676af998f5f48ae6 100644
--- a/libavutil/sha.c
+++ b/libavutil/sha.c
@@ -350,55 +350,3 @@ void av_sha_final(AVSHA* ctx, uint8_t *digest)
for (i = 0; i < ctx->digest_len; i++)
AV_WB32(digest + i*4, ctx->state[i]);
}
-
-#ifdef TEST
-#include <stdio.h>
-
-int main(void)
-{
- int i, j, k;
- AVSHA ctx;
- unsigned char digest[32];
- static const int lengths[3] = { 160, 224, 256 };
-
- for (j = 0; j < 3; j++) {
- printf("Testing SHA-%d\n", lengths[j]);
- for (k = 0; k < 3; k++) {
- av_sha_init(&ctx, lengths[j]);
- if (k == 0)
- av_sha_update(&ctx, "abc", 3);
- else if (k == 1)
- av_sha_update(&ctx, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56);
- else
- for (i = 0; i < 1000*1000; i++)
- av_sha_update(&ctx, "a", 1);
- av_sha_final(&ctx, digest);
- for (i = 0; i < lengths[j] >> 3; i++)
- printf("%02X", digest[i]);
- putchar('\n');
- }
- switch (j) {
- case 0:
- //test vectors (from FIPS PUB 180-1)
- printf("A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D\n"
- "84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1\n"
- "34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F\n");
- break;
- case 1:
- //test vectors (from FIPS PUB 180-2 Appendix A)
- printf("23097d22 3405d822 8642a477 bda255b3 2aadbce4 bda0b3f7 e36c9da7\n"
- "75388b16 512776cc 5dba5da1 fd890150 b0c6455c b4f58b19 52522525\n"
- "20794655 980c91d8 bbb4c1ea 97618a4b f03f4258 1948b2ee 4ee7ad67\n");
- break;
- case 2:
- //test vectors (from FIPS PUB 180-2)
- printf("ba7816bf 8f01cfea 414140de 5dae2223 b00361a3 96177a9c b410ff61 f20015ad\n"
- "248d6a61 d20638b8 e5c02693 0c3e6039 a33ce459 64ff2167 f6ecedd4 19db06c1\n"
- "cdc76e5c 9914fb92 81a1c7e2 84d73e67 f1809a48 a497200e 046d39cc c7112cd0\n");
- break;
- }
- }
-
- return 0;
-}
-#endif
diff --git a/libavutil/sha512-test.c b/libavutil/sha512-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..dd472aa868766c2b62329180166ff33c9cef328b
--- /dev/null
+++ b/libavutil/sha512-test.c
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2007 Michael Niedermayer <michaelni@gmx.at>
+ * Copyright (C) 2009 Konstantin Shishkov
+ * Copyright (C) 2013 James Almer
+ * based on BSD-licensed SHA-2 code by Aaron D. Gifford
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "sha512.c"
+
+#include <stdio.h>
+
+int main(void)
+{
+ int i, j, k;
+ AVSHA512 ctx;
+ unsigned char digest[64];
+ static const int lengths[4] = { 224, 256, 384, 512 };
+
+ for (j = 0; j < 4; j++) {
+ if (j < 2) printf("Testing SHA-512/%d\n", lengths[j]);
+ else printf("Testing SHA-%d\n", lengths[j]);
+ for (k = 0; k < 3; k++) {
+ av_sha512_init(&ctx, lengths[j]);
+ if (k == 0)
+ av_sha512_update(&ctx, "abc", 3);
+ else if (k == 1)
+ av_sha512_update(&ctx, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
+ "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu", 112);
+ else
+ for (i = 0; i < 1000*1000; i++)
+ av_sha512_update(&ctx, "a", 1);
+ av_sha512_final(&ctx, digest);
+ for (i = 0; i < lengths[j] >> 3; i++)
+ printf("%02X", digest[i]);
+ putchar('\n');
+ }
+ switch (j) { //test vectors (from FIPS PUB 180-4 Apendix A)
+ case 0:
+ printf("4634270f 707b6a54 daae7530 460842e2 0e37ed26 5ceee9a4 3e8924aa\n"
+ "23fec5bb 94d60b23 30819264 0b0c4533 35d66473 4fe40e72 68674af9\n"
+ "37ab331d 76f0d36d e422bd0e deb22a28 accd487b 7a8453ae 965dd287\n");
+ break;
+ case 1:
+ printf("53048e26 81941ef9 9b2e29b7 6b4c7dab e4c2d0c6 34fc6d46 e0e2f131 07e7af23\n"
+ "3928e184 fb8690f8 40da3988 121d31be 65cb9d3e f83ee614 6feac861 e19b563a\n"
+ "9a59a052 930187a9 7038cae6 92f30708 aa649192 3ef51943 94dc68d5 6c74fb21\n");
+ break;
+ case 2:
+ printf("cb00753f 45a35e8b b5a03d69 9ac65007 272c32ab 0eded163 "
+ "1a8b605a 43ff5bed 8086072b a1e7cc23 58baeca1 34c825a7\n"
+ "09330c33 f71147e8 3d192fc7 82cd1b47 53111b17 3b3b05d2 "
+ "2fa08086 e3b0f712 fcc7c71a 557e2db9 66c3e9fa 91746039\n"
+ "9d0e1809 716474cb 086e834e 310a4a1c ed149e9c 00f24852 "
+ "7972cec5 704c2a5b 07b8b3dc 38ecc4eb ae97ddd8 7f3d8985\n");
+ break;
+ case 3:
+ printf("ddaf35a1 93617aba cc417349 ae204131 12e6fa4e 89a97ea2 0a9eeee6 4b55d39a "
+ "2192992a 274fc1a8 36ba3c23 a3feebbd 454d4423 643ce80e 2a9ac94f a54ca49f\n"
+ "8e959b75 dae313da 8cf4f728 14fc143f 8f7779c6 eb9f7fa1 7299aead b6889018 "
+ "501d289e 4900f7e4 331b99de c4b5433a c7d329ee b6dd2654 5e96e55b 874be909\n"
+ "e718483d 0ce76964 4e2e42c7 bc15b463 8e1f98b1 3b204428 5632a803 afa973eb "
+ "de0ff244 877ea60a 4cb0432c e577c31b eb009c5c 2c49aa2e 4eadb217 ad8cc09b\n");
+ break;
+ }
+ }
+
+ return 0;
+}
diff --git a/libavutil/sha512.c b/libavutil/sha512.c
index e2fc58a423db39a426eeaa982aa88e43256e6d61..2c5da255918bf068f50d6dd9bc9f6d44ecc890e6 100644
--- a/libavutil/sha512.c
+++ b/libavutil/sha512.c
@@ -281,65 +281,3 @@ void av_sha512_final(AVSHA512* ctx, uint8_t *digest)
if (ctx->digest_len & 1) /* SHA512/224 is 28 bytes, and is not divisible by 8. */
AV_WB32(digest + i*8, ctx->state[i] >> 32);
}
-
-#ifdef TEST
-#include <stdio.h>
-
-int main(void)
-{
- int i, j, k;
- AVSHA512 ctx;
- unsigned char digest[64];
- static const int lengths[4] = { 224, 256, 384, 512 };
-
- for (j = 0; j < 4; j++) {
- if (j < 2) printf("Testing SHA-512/%d\n", lengths[j]);
- else printf("Testing SHA-%d\n", lengths[j]);
- for (k = 0; k < 3; k++) {
- av_sha512_init(&ctx, lengths[j]);
- if (k == 0)
- av_sha512_update(&ctx, "abc", 3);
- else if (k == 1)
- av_sha512_update(&ctx, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
- "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu", 112);
- else
- for (i = 0; i < 1000*1000; i++)
- av_sha512_update(&ctx, "a", 1);
- av_sha512_final(&ctx, digest);
- for (i = 0; i < lengths[j] >> 3; i++)
- printf("%02X", digest[i]);
- putchar('\n');
- }
- switch (j) { //test vectors (from FIPS PUB 180-4 Apendix A)
- case 0:
- printf("4634270f 707b6a54 daae7530 460842e2 0e37ed26 5ceee9a4 3e8924aa\n"
- "23fec5bb 94d60b23 30819264 0b0c4533 35d66473 4fe40e72 68674af9\n"
- "37ab331d 76f0d36d e422bd0e deb22a28 accd487b 7a8453ae 965dd287\n");
- break;
- case 1:
- printf("53048e26 81941ef9 9b2e29b7 6b4c7dab e4c2d0c6 34fc6d46 e0e2f131 07e7af23\n"
- "3928e184 fb8690f8 40da3988 121d31be 65cb9d3e f83ee614 6feac861 e19b563a\n"
- "9a59a052 930187a9 7038cae6 92f30708 aa649192 3ef51943 94dc68d5 6c74fb21\n");
- break;
- case 2:
- printf("cb00753f 45a35e8b b5a03d69 9ac65007 272c32ab 0eded163 "
- "1a8b605a 43ff5bed 8086072b a1e7cc23 58baeca1 34c825a7\n"
- "09330c33 f71147e8 3d192fc7 82cd1b47 53111b17 3b3b05d2 "
- "2fa08086 e3b0f712 fcc7c71a 557e2db9 66c3e9fa 91746039\n"
- "9d0e1809 716474cb 086e834e 310a4a1c ed149e9c 00f24852 "
- "7972cec5 704c2a5b 07b8b3dc 38ecc4eb ae97ddd8 7f3d8985\n");
- break;
- case 3:
- printf("ddaf35a1 93617aba cc417349 ae204131 12e6fa4e 89a97ea2 0a9eeee6 4b55d39a "
- "2192992a 274fc1a8 36ba3c23 a3feebbd 454d4423 643ce80e 2a9ac94f a54ca49f\n"
- "8e959b75 dae313da 8cf4f728 14fc143f 8f7779c6 eb9f7fa1 7299aead b6889018 "
- "501d289e 4900f7e4 331b99de c4b5433a c7d329ee b6dd2654 5e96e55b 874be909\n"
- "e718483d 0ce76964 4e2e42c7 bc15b463 8e1f98b1 3b204428 5632a803 afa973eb "
- "de0ff244 877ea60a 4cb0432c e577c31b eb009c5c 2c49aa2e 4eadb217 ad8cc09b\n");
- break;
- }
- }
-
- return 0;
-}
-#endif
diff --git a/libavutil/softfloat.c b/libavutil/softfloat-test.c
similarity index 99%
rename from libavutil/softfloat.c
rename to libavutil/softfloat-test.c
index 4bfbbb26afa8ba7ce6d24ae384a702d979099bf0..3293450df808af81f000a6b3d072404f3b149363 100644
--- a/libavutil/softfloat.c
+++ b/libavutil/softfloat-test.c
@@ -23,7 +23,6 @@
#include "common.h"
#include "log.h"
-#ifdef TEST
#include <stdio.h>
static const SoftFloat FLOAT_0_017776489257 = {0x1234, 12};
@@ -154,4 +153,3 @@ int main(void){
return 0;
}
-#endif
diff --git a/libavutil/tea-test.c b/libavutil/tea-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..07ec56139a1e5e92aa1cae1da0a444eac41b2953
--- /dev/null
+++ b/libavutil/tea-test.c
@@ -0,0 +1,114 @@
+/*
+ * A 32-bit implementation of the TEA algorithm
+ * Copyright (c) 2015 Vesselin Bontchev
+ *
+ * Loosely based on the implementation of David Wheeler and Roger Needham,
+ * https://en.wikipedia.org/wiki/Tiny_Encryption_Algorithm#Reference_code
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "tea.c"
+
+#include <stdio.h>
+
+#define TEA_NUM_TESTS 4
+
+// https://github.com/logandrews/TeaCrypt/blob/master/tea/tea_test.go
+static const uint8_t tea_test_key[TEA_NUM_TESTS][16] = {
+ { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+ },
+ { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+ },
+ { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+ 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
+ },
+ { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+ 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
+ }
+};
+
+static const uint8_t tea_test_pt[TEA_NUM_TESTS][8] = {
+ { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+ { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 },
+ { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 },
+ { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF }
+};
+
+static const uint8_t tea_test_ct[TEA_NUM_TESTS][8] = {
+ { 0x41, 0xEA, 0x3A, 0x0A, 0x94, 0xBA, 0xA9, 0x40 },
+ { 0x6A, 0x2F, 0x9C, 0xF3, 0xFC, 0xCF, 0x3C, 0x55 },
+ { 0xDE, 0xB1, 0xC0, 0xA2, 0x7E, 0x74, 0x5D, 0xB3 },
+ { 0x12, 0x6C, 0x6B, 0x92, 0xC0, 0x65, 0x3A, 0x3E }
+};
+
+static void test_tea(AVTEA *ctx, uint8_t *dst, const uint8_t *src,
+ const uint8_t *ref, int len, uint8_t *iv, int dir,
+ const char *test)
+{
+ av_tea_crypt(ctx, dst, src, len, iv, dir);
+ if (memcmp(dst, ref, 8*len)) {
+ int i;
+ printf("%s failed\ngot ", test);
+ for (i = 0; i < 8*len; i++)
+ printf("%02x ", dst[i]);
+ printf("\nexpected ");
+ for (i = 0; i < 8*len; i++)
+ printf("%02x ", ref[i]);
+ printf("\n");
+ exit(1);
+ }
+}
+
+int main(void)
+{
+ AVTEA *ctx;
+ uint8_t buf[8], iv[8];
+ int i;
+ static const uint8_t src[32] = "HelloWorldHelloWorldHelloWorld";
+ uint8_t ct[32];
+ uint8_t pl[32];
+
+ ctx = av_tea_alloc();
+ if (!ctx)
+ return 1;
+
+ for (i = 0; i < TEA_NUM_TESTS; i++) {
+ av_tea_init(ctx, tea_test_key[i], 64);
+
+ test_tea(ctx, buf, tea_test_pt[i], tea_test_ct[i], 1, NULL, 0, "encryption");
+ test_tea(ctx, buf, tea_test_ct[i], tea_test_pt[i], 1, NULL, 1, "decryption");
+
+ /* encrypt */
+ memcpy(iv, "HALLO123", 8);
+ av_tea_crypt(ctx, ct, src, 4, iv, 0);
+
+ /* decrypt into pl */
+ memcpy(iv, "HALLO123", 8);
+ test_tea(ctx, pl, ct, src, 4, iv, 1, "CBC decryption");
+
+ memcpy(iv, "HALLO123", 8);
+ test_tea(ctx, ct, ct, src, 4, iv, 1, "CBC inplace decryption");
+ }
+
+ printf("Test encryption/decryption success.\n");
+ av_free(ctx);
+
+ return 0;
+}
diff --git a/libavutil/tea.c b/libavutil/tea.c
index bf767188f4869918d10db419f54ba50976068de7..b138f8bea1a3e925480a0f705c0ef5522a29743a 100644
--- a/libavutil/tea.c
+++ b/libavutil/tea.c
@@ -119,95 +119,3 @@ void av_tea_crypt(AVTEA *ctx, uint8_t *dst, const uint8_t *src, int count,
}
}
}
-
-#ifdef TEST
-#include <stdio.h>
-
-#define TEA_NUM_TESTS 4
-
-// https://github.com/logandrews/TeaCrypt/blob/master/tea/tea_test.go
-static const uint8_t tea_test_key[TEA_NUM_TESTS][16] = {
- { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
- },
- { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
- },
- { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
- 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
- },
- { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
- 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
- }
-};
-
-static const uint8_t tea_test_pt[TEA_NUM_TESTS][8] = {
- { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
- { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 },
- { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 },
- { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF }
-};
-
-static const uint8_t tea_test_ct[TEA_NUM_TESTS][8] = {
- { 0x41, 0xEA, 0x3A, 0x0A, 0x94, 0xBA, 0xA9, 0x40 },
- { 0x6A, 0x2F, 0x9C, 0xF3, 0xFC, 0xCF, 0x3C, 0x55 },
- { 0xDE, 0xB1, 0xC0, 0xA2, 0x7E, 0x74, 0x5D, 0xB3 },
- { 0x12, 0x6C, 0x6B, 0x92, 0xC0, 0x65, 0x3A, 0x3E }
-};
-
-static void test_tea(AVTEA *ctx, uint8_t *dst, const uint8_t *src,
- const uint8_t *ref, int len, uint8_t *iv, int dir,
- const char *test)
-{
- av_tea_crypt(ctx, dst, src, len, iv, dir);
- if (memcmp(dst, ref, 8*len)) {
- int i;
- printf("%s failed\ngot ", test);
- for (i = 0; i < 8*len; i++)
- printf("%02x ", dst[i]);
- printf("\nexpected ");
- for (i = 0; i < 8*len; i++)
- printf("%02x ", ref[i]);
- printf("\n");
- exit(1);
- }
-}
-
-int main(void)
-{
- AVTEA *ctx;
- uint8_t buf[8], iv[8];
- int i;
- static const uint8_t src[32] = "HelloWorldHelloWorldHelloWorld";
- uint8_t ct[32];
- uint8_t pl[32];
-
- ctx = av_tea_alloc();
- if (!ctx)
- return 1;
-
- for (i = 0; i < TEA_NUM_TESTS; i++) {
- av_tea_init(ctx, tea_test_key[i], 64);
-
- test_tea(ctx, buf, tea_test_pt[i], tea_test_ct[i], 1, NULL, 0, "encryption");
- test_tea(ctx, buf, tea_test_ct[i], tea_test_pt[i], 1, NULL, 1, "decryption");
-
- /* encrypt */
- memcpy(iv, "HALLO123", 8);
- av_tea_crypt(ctx, ct, src, 4, iv, 0);
-
- /* decrypt into pl */
- memcpy(iv, "HALLO123", 8);
- test_tea(ctx, pl, ct, src, 4, iv, 1, "CBC decryption");
-
- memcpy(iv, "HALLO123", 8);
- test_tea(ctx, ct, ct, src, 4, iv, 1, "CBC inplace decryption");
- }
-
- printf("Test encryption/decryption success.\n");
- av_free(ctx);
-
- return 0;
-}
-
-#endif
diff --git a/libavutil/tree-test.c b/libavutil/tree-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..d1df0b6c87ac5d9cc59cf3ebb66dac771676dff0
--- /dev/null
+++ b/libavutil/tree-test.c
@@ -0,0 +1,108 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "tree.c"
+
+#include <stdint.h>
+
+#include "common.h"
+#include "lfg.h"
+#include "log.h"
+
+static int check(AVTreeNode *t)
+{
+ if (t) {
+ int left = check(t->child[0]);
+ int right = check(t->child[1]);
+
+ if (left > 999 || right > 999)
+ return 1000;
+ if (right - left != t->state)
+ return 1000;
+ if (t->state > 1 || t->state < -1)
+ return 1000;
+ return FFMAX(left, right) + 1;
+ }
+ return 0;
+}
+
+static void print(AVTreeNode *t, int depth)
+{
+ int i;
+ for (i = 0; i < depth * 4; i++)
+ av_log(NULL, AV_LOG_ERROR, " ");
+ if (t) {
+ av_log(NULL, AV_LOG_ERROR, "Node %p %2d %p\n", t, t->state, t->elem);
+ print(t->child[0], depth + 1);
+ print(t->child[1], depth + 1);
+ } else
+ av_log(NULL, AV_LOG_ERROR, "NULL\n");
+}
+
+static int cmp(const void *a, const void *b)
+{
+ return (const uint8_t *) a - (const uint8_t *) b;
+}
+
+int main(int argc, char **argv)
+{
+ int i;
+ void *k;
+ AVTreeNode *root = NULL, *node = NULL;
+ AVLFG prng;
+ int log_level = argc <= 1 ? AV_LOG_INFO : atoi(argv[1]);
+
+ av_log_set_level(log_level);
+
+ av_lfg_init(&prng, 1);
+
+ for (i = 0; i < 10000; i++) {
+ intptr_t j = av_lfg_get(&prng) % 86294;
+
+ if (check(root) > 999) {
+ av_log(NULL, AV_LOG_ERROR, "FATAL error %d\n", i);
+ print(root, 0);
+ return 1;
+ }
+ av_log(NULL, AV_LOG_DEBUG, "inserting %4d\n", (int)j);
+
+ if (!node)
+ node = av_tree_node_alloc();
+ if (!node) {
+ av_log(NULL, AV_LOG_ERROR, "Memory allocation failure.\n");
+ return 1;
+ }
+ av_tree_insert(&root, (void *)(j + 1), cmp, &node);
+
+ j = av_lfg_get(&prng) % 86294;
+ {
+ AVTreeNode *node2 = NULL;
+ av_log(NULL, AV_LOG_DEBUG, "removing %4d\n", (int)j);
+ av_tree_insert(&root, (void *)(j + 1), cmp, &node2);
+ k = av_tree_find(root, (void *)(j + 1), cmp, NULL);
+ if (k)
+ av_log(NULL, AV_LOG_ERROR, "removal failure %d\n", i);
+ av_free(node2);
+ }
+ }
+ av_free(node);
+
+ av_tree_destroy(root);
+
+ return 0;
+}
diff --git a/libavutil/tree.c b/libavutil/tree.c
index 2495cdf3c6f7f8474c50ceec3f083ab21a235aac..7b57b2d39a78abc2320b8cf17e6a1de300a81ea5 100644
--- a/libavutil/tree.c
+++ b/libavutil/tree.c
@@ -166,92 +166,3 @@ void av_tree_enumerate(AVTreeNode *t, void *opaque,
av_tree_enumerate(t->child[1], opaque, cmp, enu);
}
}
-
-#ifdef TEST
-
-#include "common.h"
-#include "lfg.h"
-
-static int check(AVTreeNode *t)
-{
- if (t) {
- int left = check(t->child[0]);
- int right = check(t->child[1]);
-
- if (left > 999 || right > 999)
- return 1000;
- if (right - left != t->state)
- return 1000;
- if (t->state > 1 || t->state < -1)
- return 1000;
- return FFMAX(left, right) + 1;
- }
- return 0;
-}
-
-static void print(AVTreeNode *t, int depth)
-{
- int i;
- for (i = 0; i < depth * 4; i++)
- av_log(NULL, AV_LOG_ERROR, " ");
- if (t) {
- av_log(NULL, AV_LOG_ERROR, "Node %p %2d %p\n", t, t->state, t->elem);
- print(t->child[0], depth + 1);
- print(t->child[1], depth + 1);
- } else
- av_log(NULL, AV_LOG_ERROR, "NULL\n");
-}
-
-static int cmp(const void *a, const void *b)
-{
- return (const uint8_t *) a - (const uint8_t *) b;
-}
-
-int main(int argc, char **argv)
-{
- int i;
- void *k;
- AVTreeNode *root = NULL, *node = NULL;
- AVLFG prng;
- int log_level = argc <= 1 ? AV_LOG_INFO : atoi(argv[1]);
-
- av_log_set_level(log_level);
-
- av_lfg_init(&prng, 1);
-
- for (i = 0; i < 10000; i++) {
- intptr_t j = av_lfg_get(&prng) % 86294;
-
- if (check(root) > 999) {
- av_log(NULL, AV_LOG_ERROR, "FATAL error %d\n", i);
- print(root, 0);
- return 1;
- }
- av_log(NULL, AV_LOG_DEBUG, "inserting %4d\n", (int)j);
-
- if (!node)
- node = av_tree_node_alloc();
- if (!node) {
- av_log(NULL, AV_LOG_ERROR, "Memory allocation failure.\n");
- return 1;
- }
- av_tree_insert(&root, (void *)(j + 1), cmp, &node);
-
- j = av_lfg_get(&prng) % 86294;
- {
- AVTreeNode *node2 = NULL;
- av_log(NULL, AV_LOG_DEBUG, "removing %4d\n", (int)j);
- av_tree_insert(&root, (void *)(j + 1), cmp, &node2);
- k = av_tree_find(root, (void *)(j + 1), cmp, NULL);
- if (k)
- av_log(NULL, AV_LOG_ERROR, "removal failure %d\n", i);
- av_free(node2);
- }
- }
- av_free(node);
-
- av_tree_destroy(root);
-
- return 0;
-}
-#endif
diff --git a/libavutil/twofish-test.c b/libavutil/twofish-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..1f22132d6abcc70eadf629406c843f0ffe474b85
--- /dev/null
+++ b/libavutil/twofish-test.c
@@ -0,0 +1,94 @@
+/*
+ * An implementation of the TwoFish algorithm
+ * Copyright (c) 2015 Supraja Meedinti
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "twofish.c"
+#include "log.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+ uint8_t Key[32] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff
+ };
+ const uint8_t rct[6][16] = {
+ {0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32, 0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a},
+ {0xcf, 0xd1, 0xd2, 0xe5, 0xa9, 0xbe, 0x9c, 0xdf, 0x50, 0x1f, 0x13, 0xb8, 0x92, 0xbd, 0x22, 0x48},
+ {0x37, 0x52, 0x7b, 0xe0, 0x05, 0x23, 0x34, 0xb8, 0x9f, 0x0c, 0xfc, 0xca, 0xe8, 0x7c, 0xfa, 0x20},
+ {0x5d, 0x9d, 0x4e, 0xef, 0xfa, 0x91, 0x51, 0x57, 0x55, 0x24, 0xf1, 0x15, 0x81, 0x5a, 0x12, 0xe0},
+ {0xe7, 0x54, 0x49, 0x21, 0x2b, 0xee, 0xf9, 0xf4, 0xa3, 0x90, 0xbd, 0x86, 0x0a, 0x64, 0x09, 0x41},
+ {0x37, 0xfe, 0x26, 0xff, 0x1c, 0xf6, 0x61, 0x75, 0xf5, 0xdd, 0xf4, 0xc3, 0x3b, 0x97, 0xa2, 0x05}
+ };
+ uint8_t temp[32], iv[16], rpt[32] = {0};
+ const int kbits[3] = {128, 192, 256};
+ int i, j, err = 0;
+ AVTWOFISH *cs;
+ cs = av_twofish_alloc();
+ if (!cs)
+ return 1;
+ for (j = 1; j < 3; j++) {
+ av_twofish_init(cs, Key, kbits[j]);
+ av_twofish_crypt(cs, temp, rpt, 1, NULL, 0);
+ for (i = 0; i < 16; i++) {
+ if (rct[j][i] != temp[i]) {
+ av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rct[j][i], temp[i]);
+ err = 1;
+ }
+ }
+ av_twofish_crypt(cs, temp, rct[j], 1, NULL, 1);
+ for (i = 0; i < 16; i++) {
+ if (rpt[i] != temp[i]) {
+ av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rpt[i], temp[i]);
+ err = 1;
+ }
+ }
+ }
+ for (j = 0; j < 3; j++) {
+ memset(Key, 0, sizeof(Key));
+ memset(rpt, 0, sizeof(rpt));
+ for (i = 1; i < 50; i++) {
+ av_twofish_init(cs, Key, kbits[j]);
+ av_twofish_crypt(cs, temp, rpt, 1, NULL, 0);
+ memcpy(Key+16,Key,(kbits[j]-128) >> 3);
+ memcpy(Key,rpt,16);
+ memcpy(rpt,temp,16);
+ }
+ for (i = 0; i < 16; i++) {
+ if (rct[3 + j][i] != temp[i]) {
+ av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rct[3 + j][i], temp[i]);
+ err = 1;
+ }
+ }
+ }
+ memset(rpt, 0, sizeof(rpt));
+ memcpy(iv, "HALLO123HALLO123", 16);
+ av_twofish_crypt(cs, temp, rpt, 2, iv, 0);
+ memcpy(iv, "HALLO123HALLO123", 16);
+ av_twofish_crypt(cs, temp, temp, 2, iv, 1);
+ for (i = 0; i < 32; i++) {
+ if (rpt[i] != temp[i]) {
+ av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rpt[i], temp[i]);
+ err = 1;
+ }
+ }
+ av_free(cs);
+ return err;
+}
diff --git a/libavutil/twofish.c b/libavutil/twofish.c
index 162069be5c0a956d60b81dd1698b3ce0b314622e..d84fa4f363a09327b89d22b9cd9ab2a76b2430f6 100644
--- a/libavutil/twofish.c
+++ b/libavutil/twofish.c
@@ -329,77 +329,3 @@ void av_twofish_crypt(AVTWOFISH *cs, uint8_t *dst, const uint8_t *src, int count
dst = dst + 16;
}
}
-
-#ifdef TEST
-#include<stdio.h>
-#include<stdlib.h>
-#include"log.h"
-
-int main(int argc, char *argv[])
-{
- uint8_t Key[32] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff
- };
- const uint8_t rct[6][16] = {
- {0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32, 0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a},
- {0xcf, 0xd1, 0xd2, 0xe5, 0xa9, 0xbe, 0x9c, 0xdf, 0x50, 0x1f, 0x13, 0xb8, 0x92, 0xbd, 0x22, 0x48},
- {0x37, 0x52, 0x7b, 0xe0, 0x05, 0x23, 0x34, 0xb8, 0x9f, 0x0c, 0xfc, 0xca, 0xe8, 0x7c, 0xfa, 0x20},
- {0x5d, 0x9d, 0x4e, 0xef, 0xfa, 0x91, 0x51, 0x57, 0x55, 0x24, 0xf1, 0x15, 0x81, 0x5a, 0x12, 0xe0},
- {0xe7, 0x54, 0x49, 0x21, 0x2b, 0xee, 0xf9, 0xf4, 0xa3, 0x90, 0xbd, 0x86, 0x0a, 0x64, 0x09, 0x41},
- {0x37, 0xfe, 0x26, 0xff, 0x1c, 0xf6, 0x61, 0x75, 0xf5, 0xdd, 0xf4, 0xc3, 0x3b, 0x97, 0xa2, 0x05}
- };
- uint8_t temp[32], iv[16], rpt[32] = {0};
- const int kbits[3] = {128, 192, 256};
- int i, j, err = 0;
- AVTWOFISH *cs;
- cs = av_twofish_alloc();
- if (!cs)
- return 1;
- for (j = 1; j < 3; j++) {
- av_twofish_init(cs, Key, kbits[j]);
- av_twofish_crypt(cs, temp, rpt, 1, NULL, 0);
- for (i = 0; i < 16; i++) {
- if (rct[j][i] != temp[i]) {
- av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rct[j][i], temp[i]);
- err = 1;
- }
- }
- av_twofish_crypt(cs, temp, rct[j], 1, NULL, 1);
- for (i = 0; i < 16; i++) {
- if (rpt[i] != temp[i]) {
- av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rpt[i], temp[i]);
- err = 1;
- }
- }
- }
- for (j = 0; j < 3; j++) {
- memset(Key, 0, sizeof(Key));
- memset(rpt, 0, sizeof(rpt));
- for (i = 1; i < 50; i++) {
- av_twofish_init(cs, Key, kbits[j]);
- av_twofish_crypt(cs, temp, rpt, 1, NULL, 0);
- memcpy(Key+16,Key,(kbits[j]-128) >> 3);
- memcpy(Key,rpt,16);
- memcpy(rpt,temp,16);
- }
- for (i = 0; i < 16; i++) {
- if (rct[3 + j][i] != temp[i]) {
- av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rct[3 + j][i], temp[i]);
- err = 1;
- }
- }
- }
- memset(rpt, 0, sizeof(rpt));
- memcpy(iv, "HALLO123HALLO123", 16);
- av_twofish_crypt(cs, temp, rpt, 2, iv, 0);
- memcpy(iv, "HALLO123HALLO123", 16);
- av_twofish_crypt(cs, temp, temp, 2, iv, 1);
- for (i = 0; i < 32; i++) {
- if (rpt[i] != temp[i]) {
- av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rpt[i], temp[i]);
- err = 1;
- }
- }
- av_free(cs);
- return err;
-}
-#endif
diff --git a/libavutil/utf8.c b/libavutil/utf8-test.c
similarity index 99%
rename from libavutil/utf8.c
rename to libavutil/utf8-test.c
index 3447a5192b36f73c377a20473a6599a537dda949..37a2802b5f021a851786feb74f8b1e04de0d3ae8 100644
--- a/libavutil/utf8.c
+++ b/libavutil/utf8-test.c
@@ -18,7 +18,6 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
-#ifdef TEST
#include <stdio.h>
#include "libavutil/avstring.h"
@@ -70,4 +69,3 @@ int main(int argc, char **argv)
av_file_unmap(file_buf, file_buf_size);
return 0;
}
-#endif
diff --git a/libavutil/xtea-test.c b/libavutil/xtea-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..e8f39150d99e1f635cdd0c6e686bd44d7a60737e
--- /dev/null
+++ b/libavutil/xtea-test.c
@@ -0,0 +1,121 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "intreadwrite.h"
+#include "xtea.h"
+
+#define XTEA_NUM_TESTS 6
+
+static const uint8_t xtea_test_key[XTEA_NUM_TESTS][16] = {
+ { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
+ { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
+ { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
+ { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+ { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+ { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
+};
+
+static const uint8_t xtea_test_pt[XTEA_NUM_TESTS][8] = {
+ { 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48 },
+ { 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41 },
+ { 0x5a, 0x5b, 0x6e, 0x27, 0x89, 0x48, 0xd7, 0x7f },
+ { 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48 },
+ { 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41 },
+ { 0x70, 0xe1, 0x22, 0x5d, 0x6e, 0x4e, 0x76, 0x55 }
+};
+
+static const uint8_t xtea_test_ct[XTEA_NUM_TESTS][8] = {
+ { 0x49, 0x7d, 0xf3, 0xd0, 0x72, 0x61, 0x2c, 0xb5 },
+ { 0xe7, 0x8f, 0x2d, 0x13, 0x74, 0x43, 0x41, 0xd8 },
+ { 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41 },
+ { 0xa0, 0x39, 0x05, 0x89, 0xf8, 0xb8, 0xef, 0xa5 },
+ { 0xed, 0x23, 0x37, 0x5a, 0x82, 0x1a, 0x8c, 0x2d },
+ { 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41 }
+};
+
+static void test_xtea(AVXTEA *ctx, uint8_t *dst, const uint8_t *src,
+ const uint8_t *ref, int len, uint8_t *iv, int dir,
+ const char *test,
+ void (*crypt)(AVXTEA *, uint8_t *, const uint8_t *, int, uint8_t *, int))
+{
+ crypt(ctx, dst, src, len, iv, dir);
+ if (memcmp(dst, ref, 8*len)) {
+ int i;
+ printf("%s failed\ngot ", test);
+ for (i = 0; i < 8*len; i++)
+ printf("%02x ", dst[i]);
+ printf("\nexpected ");
+ for (i = 0; i < 8*len; i++)
+ printf("%02x ", ref[i]);
+ printf("\n");
+ exit(1);
+ }
+}
+
+int main(void)
+{
+ AVXTEA ctx;
+ uint8_t buf[16], iv[8];
+ int i, j;
+ static const uint8_t src[32] = "HelloWorldHelloWorldHelloWorld";
+ uint8_t ct[32];
+ uint8_t pl[32];
+
+ for (i = 0; i < XTEA_NUM_TESTS; i++) {
+ av_xtea_init(&ctx, xtea_test_key[i]);
+
+ test_xtea(&ctx, buf, xtea_test_pt[i], xtea_test_ct[i], 1, NULL, 0, "encryption", av_xtea_crypt);
+ test_xtea(&ctx, buf, xtea_test_ct[i], xtea_test_pt[i], 1, NULL, 1, "decryption", av_xtea_crypt);
+
+ for (j = 0; j < 4; j++)
+ AV_WL32(&buf[4*j], AV_RB32(&xtea_test_key[i][4*j]));
+ av_xtea_le_init(&ctx, buf);
+ for (j = 0; j < 2; j++) {
+ AV_WL32(&ct[4*j], AV_RB32(&xtea_test_ct[i][4*j]));
+ AV_WL32(&pl[4*j], AV_RB32(&xtea_test_pt[i][4*j]));
+ }
+ test_xtea(&ctx, buf, pl, ct, 1, NULL, 0, "encryption", av_xtea_le_crypt);
+ test_xtea(&ctx, buf, ct, pl, 1, NULL, 1, "decryption", av_xtea_le_crypt);
+
+ /* encrypt */
+ memcpy(iv, "HALLO123", 8);
+ av_xtea_crypt(&ctx, ct, src, 4, iv, 0);
+
+ /* decrypt into pl */
+ memcpy(iv, "HALLO123", 8);
+ test_xtea(&ctx, pl, ct, src, 4, iv, 1, "CBC decryption", av_xtea_crypt);
+
+ memcpy(iv, "HALLO123", 8);
+ test_xtea(&ctx, ct, ct, src, 4, iv, 1, "CBC inplace decryption", av_xtea_crypt);
+ }
+
+ printf("Test encryption/decryption success.\n");
+
+ return 0;
+}
diff --git a/libavutil/xtea.c b/libavutil/xtea.c
index 2139aa55206a124f741f1bd71611f5f6e041ca65..f7892af9fb30aea429ba7dafc78633803350d138 100644
--- a/libavutil/xtea.c
+++ b/libavutil/xtea.c
@@ -251,104 +251,3 @@ void av_xtea_le_crypt(AVXTEA *ctx, uint8_t *dst, const uint8_t *src, int count,
{
xtea_crypt(ctx, dst, src, count, iv, decrypt, xtea_le_crypt_ecb);
}
-
-#ifdef TEST
-#include <stdio.h>
-
-#define XTEA_NUM_TESTS 6
-
-static const uint8_t xtea_test_key[XTEA_NUM_TESTS][16] = {
- { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
- { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
- { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
- { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
- { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
- { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
-};
-
-static const uint8_t xtea_test_pt[XTEA_NUM_TESTS][8] = {
- { 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48 },
- { 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41 },
- { 0x5a, 0x5b, 0x6e, 0x27, 0x89, 0x48, 0xd7, 0x7f },
- { 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48 },
- { 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41 },
- { 0x70, 0xe1, 0x22, 0x5d, 0x6e, 0x4e, 0x76, 0x55 }
-};
-
-static const uint8_t xtea_test_ct[XTEA_NUM_TESTS][8] = {
- { 0x49, 0x7d, 0xf3, 0xd0, 0x72, 0x61, 0x2c, 0xb5 },
- { 0xe7, 0x8f, 0x2d, 0x13, 0x74, 0x43, 0x41, 0xd8 },
- { 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41 },
- { 0xa0, 0x39, 0x05, 0x89, 0xf8, 0xb8, 0xef, 0xa5 },
- { 0xed, 0x23, 0x37, 0x5a, 0x82, 0x1a, 0x8c, 0x2d },
- { 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41 }
-};
-
-static void test_xtea(AVXTEA *ctx, uint8_t *dst, const uint8_t *src,
- const uint8_t *ref, int len, uint8_t *iv, int dir,
- const char *test,
- void (*crypt)(AVXTEA *, uint8_t *, const uint8_t *, int, uint8_t *, int))
-{
- crypt(ctx, dst, src, len, iv, dir);
- if (memcmp(dst, ref, 8*len)) {
- int i;
- printf("%s failed\ngot ", test);
- for (i = 0; i < 8*len; i++)
- printf("%02x ", dst[i]);
- printf("\nexpected ");
- for (i = 0; i < 8*len; i++)
- printf("%02x ", ref[i]);
- printf("\n");
- exit(1);
- }
-}
-
-int main(void)
-{
- AVXTEA ctx;
- uint8_t buf[16], iv[8];
- int i, j;
- static const uint8_t src[32] = "HelloWorldHelloWorldHelloWorld";
- uint8_t ct[32];
- uint8_t pl[32];
-
- for (i = 0; i < XTEA_NUM_TESTS; i++) {
- av_xtea_init(&ctx, xtea_test_key[i]);
-
- test_xtea(&ctx, buf, xtea_test_pt[i], xtea_test_ct[i], 1, NULL, 0, "encryption", av_xtea_crypt);
- test_xtea(&ctx, buf, xtea_test_ct[i], xtea_test_pt[i], 1, NULL, 1, "decryption", av_xtea_crypt);
-
- for (j = 0; j < 4; j++)
- AV_WL32(&buf[4*j], AV_RB32(&xtea_test_key[i][4*j]));
- av_xtea_le_init(&ctx, buf);
- for (j = 0; j < 2; j++) {
- AV_WL32(&ct[4*j], AV_RB32(&xtea_test_ct[i][4*j]));
- AV_WL32(&pl[4*j], AV_RB32(&xtea_test_pt[i][4*j]));
- }
- test_xtea(&ctx, buf, pl, ct, 1, NULL, 0, "encryption", av_xtea_le_crypt);
- test_xtea(&ctx, buf, ct, pl, 1, NULL, 1, "decryption", av_xtea_le_crypt);
-
- /* encrypt */
- memcpy(iv, "HALLO123", 8);
- av_xtea_crypt(&ctx, ct, src, 4, iv, 0);
-
- /* decrypt into pl */
- memcpy(iv, "HALLO123", 8);
- test_xtea(&ctx, pl, ct, src, 4, iv, 1, "CBC decryption", av_xtea_crypt);
-
- memcpy(iv, "HALLO123", 8);
- test_xtea(&ctx, ct, ct, src, 4, iv, 1, "CBC inplace decryption", av_xtea_crypt);
- }
-
- printf("Test encryption/decryption success.\n");
-
- return 0;
-}
-
-#endif
diff --git a/library.mak b/library.mak
index 3e1082c57250934c2e698b9fb3b98ea3a2648b12..cc4b498df9bf05ec022ca0acc23b708b18968b23 100644
--- a/library.mak
+++ b/library.mak
@@ -10,18 +10,6 @@ INSTHEADERS := $(INSTHEADERS) $(HEADERS:%=$(SUBDIR)%)
all-$(CONFIG_STATIC): $(SUBDIR)$(LIBNAME)
all-$(CONFIG_SHARED): $(SUBDIR)$(SLIBNAME)
-$(SUBDIR)%-test.o: $(SUBDIR)%-test.c
- $(COMPILE_C)
-
-$(SUBDIR)%-test.o: $(SUBDIR)%.c
- $(COMPILE_C)
-
-$(SUBDIR)%-test.i: $(SUBDIR)%-test.c
- $(CC) $(CCFLAGS) $(CC_E) $<
-
-$(SUBDIR)%-test.i: $(SUBDIR)%.c
- $(CC) $(CCFLAGS) $(CC_E) $<
-
$(SUBDIR)x86/%$(DEFAULT_YASMD).asm: $(SUBDIR)x86/%.asm
$(DEPYASM) $(YASMFLAGS) -I $(<D)/ -M -o $@ $< > $(@:.asm=.d)
$(YASM) $(YASMFLAGS) -I $(<D)/ -e $< | sed '/^%/d;/^$$/d;' > $@
@@ -33,8 +21,6 @@ $(SUBDIR)x86/%.o: $(SUBDIR)x86/%$(YASMD).asm
LIBOBJS := $(OBJS) $(SUBDIR)%.h.o $(TESTOBJS)
$(LIBOBJS) $(LIBOBJS:.o=.s) $(LIBOBJS:.o=.i): CPPFLAGS += -DHAVE_AV_CONFIG_H
-$(TESTOBJS) $(TESTOBJS:.o=.i): CPPFLAGS += -DTEST
-$(TESTOBJS) $(TESTOBJS:.o=.i): CFLAGS += -Umain
$(SUBDIR)$(LIBNAME): $(OBJS)
$(RM) $@
diff --git a/tests/ref/fate/source b/tests/ref/fate/source
index ec0a98e2d3eb604bf66e18027ba7618f113e8283..c7ea3dad087b321213a19f26c3f9f17bb24b62c6 100644
--- a/tests/ref/fate/source
+++ b/tests/ref/fate/source
@@ -5,7 +5,6 @@ compat/avisynth/windowsPorts/windows2linux.h
libavcodec/file_open.c
libavcodec/interplayacm.c
libavcodec/log2_tab.c
-libavcodec/mathops.c
libavcodec/reverse.c
libavdevice/file_open.c
libavfilter/log2_tab.c