Merge commit 'a6a750c7ef240b72ce01e9653343a0ddf247d196'
authorClément Bœsch <clement@stupeflix.com>
Wed, 22 Jun 2016 11:44:29 +0000 (13:44 +0200)
committerClément Bœsch <clement@stupeflix.com>
Wed, 22 Jun 2016 11:44:34 +0000 (13:44 +0200)
* commit 'a6a750c7ef240b72ce01e9653343a0ddf247d196':
  tests: Move all test programs to a subdirectory

Merged-by: Clément Bœsch <clement@stupeflix.com>
98 files changed:
1  2 
.gitignore
common.mak
libavcodec/Makefile
libavcodec/tests/.gitignore
libavcodec/tests/arm/dct.c
libavcodec/tests/avfft.c
libavcodec/tests/cabac.c
libavcodec/tests/dct.c
libavcodec/tests/fft-fixed.c
libavcodec/tests/fft-fixed32.c
libavcodec/tests/fft.c
libavcodec/tests/golomb.c
libavcodec/tests/iirfilter.c
libavcodec/tests/imgconvert.c
libavcodec/tests/jpeg2000dwt.c
libavcodec/tests/mathops.c
libavcodec/tests/motion.c
libavcodec/tests/options.c
libavcodec/tests/ppc/dct.c
libavcodec/tests/rangecoder.c
libavcodec/tests/snowenc.c
libavcodec/tests/utils.c
libavcodec/tests/x86/dct.c
libavdevice/tests/.gitignore
libavdevice/tests/timefilter.c
libavfilter/tests/.gitignore
libavfilter/tests/drawutils.c
libavfilter/tests/filtfmts.c
libavfilter/tests/formats.c
libavformat/matroskaenc.c
libavformat/tests/.gitignore
libavformat/tests/movenc.c
libavformat/tests/noproxy.c
libavformat/tests/rtmpdh.c
libavformat/tests/seek.c
libavformat/tests/srtp.c
libavformat/tests/url.c
libavresample/tests/avresample.c
libavutil/Makefile
libavutil/des.c
libavutil/tests/.gitignore
libavutil/tests/adler32.c
libavutil/tests/aes.c
libavutil/tests/atomic.c
libavutil/tests/avstring.c
libavutil/tests/base64.c
libavutil/tests/blowfish.c
libavutil/tests/bprint.c
libavutil/tests/camellia.c
libavutil/tests/cast5.c
libavutil/tests/color_utils.c
libavutil/tests/cpu.c
libavutil/tests/crc.c
libavutil/tests/des.c
libavutil/tests/dict.c
libavutil/tests/display.c
libavutil/tests/error.c
libavutil/tests/eval.c
libavutil/tests/fifo.c
libavutil/tests/file.c
libavutil/tests/float_dsp.c
libavutil/tests/hash.c
libavutil/tests/hmac.c
libavutil/tests/lfg.c
libavutil/tests/lls.c
libavutil/tests/log.c
libavutil/tests/lzo.c
libavutil/tests/md5.c
libavutil/tests/murmur3.c
libavutil/tests/opt.c
libavutil/tests/parseutils.c
libavutil/tests/pca.c
libavutil/tests/pixdesc.c
libavutil/tests/pixelutils.c
libavutil/tests/random_seed.c
libavutil/tests/rational.c
libavutil/tests/ripemd.c
libavutil/tests/sha.c
libavutil/tests/sha512.c
libavutil/tests/softfloat.c
libavutil/tests/tea.c
libavutil/tests/tree.c
libavutil/tests/twofish.c
libavutil/tests/utf8.c
libavutil/tests/xtea.c
library.mak
libswresample/tests/.gitignore
libswresample/tests/swresample.c
libswscale/tests/colorspace.c
libswscale/tests/swscale.c
tests/fate-run.sh
tests/fate/fft.mak
tests/fate/filter-audio.mak
tests/fate/filter-video.mak
tests/fate/libavcodec.mak
tests/fate/libavformat.mak
tests/fate/libavutil.mak
tests/fate/seek.mak

diff --cc .gitignore
  *.so.*
  *.swp
  *.ver
- *-test
 +*_g
 +\#*
 +.\#*
  /.config
  /.version
 -/avconv
 -/avplay
 -/avprobe
 -/avversion.h
 +/ffmpeg
 +/ffplay
 +/ffprobe
 +/ffserver
  /config.*
  /coverage.info
 +/avversion.h
  /lcov/
 +/src
diff --cc common.mak
@@@ -113,9 -15,8 +113,9 @@@ LDLIBS       = $(FFLIBS:%=%$(BUILDSUF)
  FFEXTRALIBS := $(LDLIBS:%=$(LD_LIB)) $(EXTRALIBS)
  
  OBJS      := $(sort $(OBJS:%=$(SUBDIR)%))
- TESTOBJS  := $(TESTOBJS:%=$(SUBDIR)%) $(TESTPROGS:%=$(SUBDIR)%-test.o)
- TESTPROGS := $(TESTPROGS:%=$(SUBDIR)%-test$(EXESUF))
 +SLIBOBJS  := $(sort $(SLIBOBJS:%=$(SUBDIR)%))
+ TESTOBJS  := $(TESTOBJS:%=$(SUBDIR)tests/%) $(TESTPROGS:%=$(SUBDIR)tests/%.o)
+ TESTPROGS := $(TESTPROGS:%=$(SUBDIR)tests/%$(EXESUF))
  HOSTOBJS  := $(HOSTPROGS:%=$(SUBDIR)%.o)
  HOSTPROGS := $(HOSTPROGS:%=$(SUBDIR)%$(HOSTEXESUF))
  TOOLS     += $(TOOLS-yes)
Simple merge
index 0000000,31fa59b..d8ab947
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,6 +1,16 @@@
++/avfft
++/cabac
+ /dct
+ /fft
+ /fft-fixed
++/fft-fixed32
+ /golomb
+ /iirfilter
++/imgconvert
++/jpeg2000dwt
++/mathops
++/motion
++/options
+ /rangecoder
++/snowenc
++/utils
index 0000000,d18cb52..596d369
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,40 +1,40 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 "libavcodec/arm/idct.h"
+ static const struct algo fdct_tab_arch[] = {
+     { 0 }
+ };
+ static const struct algo idct_tab_arch[] = {
+     { "SIMPLE-ARM",     ff_simple_idct_arm,     FF_IDCT_PERM_NONE },
+     { "INT-ARM",        ff_j_rev_dct_arm,       FF_IDCT_PERM_LIBMPEG2 },
+ #if HAVE_ARMV5TE
+     { "SIMPLE-ARMV5TE", ff_simple_idct_armv5te, FF_IDCT_PERM_NONE,      AV_CPU_FLAG_ARMV5TE },
+ #endif
+ #if HAVE_ARMV6
+     { "SIMPLE-ARMV6",   ff_simple_idct_armv6,   FF_IDCT_PERM_LIBMPEG2,  AV_CPU_FLAG_ARMV6 },
+ #endif
+ #if HAVE_NEON
+     { "SIMPLE-NEON",    ff_simple_idct_neon,    FF_IDCT_PERM_PARTTRANS, AV_CPU_FLAG_NEON },
+ #endif
+     { 0 }
+ };
index 0000000,0000000..6bc48ea
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,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
++ */
++
++#include "config.h"
++#include "libavutil/mem.h"
++#include "libavcodec/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;
++}
index 0000000,0000000..affe4eb
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,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 "libavcodec/cabac.c"
++
++#define SIZE 10240
++
++#include "libavutil/lfg.h"
++#include "libavcodec/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;
++}
index 0000000,6c6a4e0..5303fdf
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,472 +1,523 @@@
 - * This file is part of Libav.
+ /*
+  * (c) 2001 Fabrice Bellard
+  *     2007 Marc Hoffman <marc.hoffman@analog.com>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -#include "libavcodec/aandcttab.h"
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ /**
+  * @file
+  * DCT test (c) 2001 Fabrice Bellard
+  * Started from sample code by Juan J. Sierralta P.
+  */
+ #include "config.h"
+ #include <stdlib.h>
+ #include <stdio.h>
+ #include <string.h>
+ #if HAVE_UNISTD_H
+ #include <unistd.h>
+ #endif
+ #include <math.h>
+ #include "libavutil/cpu.h"
+ #include "libavutil/common.h"
+ #include "libavutil/internal.h"
+ #include "libavutil/lfg.h"
+ #include "libavutil/time.h"
 -#include "libavcodec/dctref.h"
 -#include "libavcodec/faandct.h"
 -#include "libavcodec/faanidct.h"
+ #include "libavcodec/dct.h"
 -static void init_block(int16_t block[64], int test, int is_idct, AVLFG *prng)
+ #include "libavcodec/idctdsp.h"
+ #include "libavcodec/simple_idct.h"
+ #include "libavcodec/xvididct.h"
++#include "libavcodec/aandcttab.h"
++#include "libavcodec/faandct.h"
++#include "libavcodec/faanidct.h"
++#include "libavcodec/dctref.h"
+ struct algo {
+     const char *name;
+     void (*func)(int16_t *block);
+     enum idct_permutation_type perm_type;
+     int cpu_flag;
+     int nonspec;
+ };
+ static const struct algo fdct_tab[] = {
+     { "REF-DBL",     ff_ref_fdct,          FF_IDCT_PERM_NONE },
+     { "IJG-AAN-INT", ff_fdct_ifast,        FF_IDCT_PERM_NONE },
+     { "IJG-LLM-INT", ff_jpeg_fdct_islow_8, FF_IDCT_PERM_NONE },
+ #if CONFIG_FAANDCT
+     { "FAAN",        ff_faandct,           FF_IDCT_PERM_NONE },
+ #endif /* CONFIG_FAANDCT */
+ };
++static void ff_prores_idct_wrap(int16_t *dst){
++    LOCAL_ALIGNED(16, int16_t, qmat, [64]);
++    int i;
++
++    for(i=0; i<64; i++){
++        qmat[i]=4;
++    }
++    ff_prores_idct(dst, qmat);
++    for(i=0; i<64; i++) {
++         dst[i] -= 512;
++    }
++}
++
+ static const struct algo idct_tab[] = {
+     { "REF-DBL",     ff_ref_idct,          FF_IDCT_PERM_NONE },
+     { "INT",         ff_j_rev_dct,         FF_IDCT_PERM_LIBMPEG2 },
+     { "SIMPLE-C",    ff_simple_idct_8,     FF_IDCT_PERM_NONE },
++    { "SIMPLE-C10",  ff_simple_idct_10,    FF_IDCT_PERM_NONE },
++    { "SIMPLE-C12",  ff_simple_idct_12,    FF_IDCT_PERM_NONE, 0, 1 },
++    { "PR-C",        ff_prores_idct_wrap,  FF_IDCT_PERM_NONE, 0, 1 },
+ #if CONFIG_FAANIDCT
+     { "FAANI",       ff_faanidct,          FF_IDCT_PERM_NONE },
+ #endif /* CONFIG_FAANIDCT */
+ #if CONFIG_MPEG4_DECODER
+     { "XVID",        ff_xvid_idct,         FF_IDCT_PERM_NONE, 0, 1 },
+ #endif /* CONFIG_MPEG4_DECODER */
+ };
+ #if ARCH_ARM
+ #include "arm/dct.c"
+ #elif ARCH_PPC
+ #include "ppc/dct.c"
+ #elif ARCH_X86
+ #include "x86/dct.c"
+ #else
+ static const struct algo fdct_tab_arch[] = { { 0 } };
+ static const struct algo idct_tab_arch[] = { { 0 } };
+ #endif
+ #define AANSCALE_BITS 12
+ #define NB_ITS 20000
+ #define NB_ITS_SPEED 50000
+ DECLARE_ALIGNED(16, static int16_t, block)[64];
+ DECLARE_ALIGNED(8,  static int16_t, block1)[64];
 -            block[i] = (av_lfg_get(prng) % 512) - 256;
++static void init_block(int16_t block[64], int test, int is_idct, AVLFG *prng, int vals)
+ {
+     int i, j;
+     memset(block, 0, 64 * sizeof(*block));
+     switch (test) {
+     case 0:
+         for (i = 0; i < 64; i++)
 -        for (i = 0; i < j; i++)
 -            block[av_lfg_get(prng) % 64] = av_lfg_get(prng) % 512 - 256;
++            block[i] = (av_lfg_get(prng) % (2*vals)) -vals;
+         if (is_idct) {
+             ff_ref_fdct(block);
+             for (i = 0; i < 64; i++)
+                 block[i] >>= 3;
+         }
+         break;
+     case 1:
+         j = av_lfg_get(prng) % 10 + 1;
 -        block[ 0] = av_lfg_get(prng) % 4096 - 2048;
++        for (i = 0; i < j; i++) {
++            int idx = av_lfg_get(prng) % 64;
++            block[idx] = av_lfg_get(prng) % (2*vals) -vals;
++        }
+         break;
+     case 2:
 -static int dct_error(const struct algo *dct, int test, int is_idct, int speed)
++        block[ 0] = av_lfg_get(prng) % (16*vals) - (8*vals);
+         block[63] = (block[0] & 1) ^ 1;
+         break;
+     }
+ }
+ static void permute(int16_t dst[64], const int16_t src[64],
+                     enum idct_permutation_type perm_type)
+ {
+     int i;
+ #if ARCH_X86
+     if (permute_x86(dst, src, perm_type))
+         return;
+ #endif
+     switch (perm_type) {
+     case FF_IDCT_PERM_LIBMPEG2:
+         for (i = 0; i < 64; i++)
+             dst[(i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2)] = src[i];
+         break;
+     case FF_IDCT_PERM_PARTTRANS:
+         for (i = 0; i < 64; i++)
+             dst[(i & 0x24) | ((i & 3) << 3) | ((i >> 3) & 3)] = src[i];
+         break;
++    case FF_IDCT_PERM_TRANSPOSE:
++        for (i = 0; i < 64; i++)
++            dst[(i>>3) | ((i<<3)&0x38)] = src[i];
++        break;
+     default:
+         for (i = 0; i < 64; i++)
+             dst[i] = src[i];
+         break;
+     }
+ }
 -        init_block(block1, test, is_idct, &prng);
++static int dct_error(const struct algo *dct, int test, int is_idct, int speed, const int bits)
+ {
+     void (*ref)(int16_t *block) = is_idct ? ff_ref_idct : ff_ref_fdct;
+     int it, i, scale;
+     int err_inf, v;
+     int64_t err2, ti, ti1, it1, err_sum = 0;
+     int64_t sysErr[64], sysErrMax = 0;
+     int maxout = 0;
+     int blockSumErrMax = 0, blockSumErr;
+     AVLFG prng;
++    const int vals=1<<bits;
+     double omse, ome;
+     int spec_err;
+     av_lfg_init(&prng, 1);
+     err_inf = 0;
+     err2 = 0;
+     for (i = 0; i < 64; i++)
+         sysErr[i] = 0;
+     for (it = 0; it < NB_ITS; it++) {
 -    printf("%s %s: ppe=%d omse=%0.8f ome=%0.8f syserr=%0.8f maxout=%d blockSumErr=%d\n",
++        init_block(block1, test, is_idct, &prng, vals);
+         permute(block, block1, dct->perm_type);
+         dct->func(block);
+         emms_c();
+         if (!strcmp(dct->name, "IJG-AAN-INT")) {
+             for (i = 0; i < 64; i++) {
+                 scale = 8 * (1 << (AANSCALE_BITS + 11)) / ff_aanscales[i];
+                 block[i] = (block[i] * scale) >> AANSCALE_BITS;
+             }
+         }
+         ref(block1);
++        if (!strcmp(dct->name, "PR-SSE2"))
++            for (i = 0; i < 64; i++)
++                block1[i] = av_clip(block1[i], 4-512, 1019-512);
+         blockSumErr = 0;
+         for (i = 0; i < 64; i++) {
+             int err = block[i] - block1[i];
+             err_sum += err;
+             v = abs(err);
+             if (v > err_inf)
+                 err_inf = v;
+             err2 += v * v;
+             sysErr[i] += block[i] - block1[i];
+             blockSumErr += v;
+             if (abs(block[i]) > maxout)
+                 maxout = abs(block[i]);
+         }
+         if (blockSumErrMax < blockSumErr)
+             blockSumErrMax = blockSumErr;
+     }
+     for (i = 0; i < 64; i++)
+         sysErrMax = FFMAX(sysErrMax, FFABS(sysErr[i]));
+     for (i = 0; i < 64; i++) {
+         if (i % 8 == 0)
+             printf("\n");
+         printf("%7d ", (int) sysErr[i]);
+     }
+     printf("\n");
+     omse = (double) err2 / NB_ITS / 64;
+     ome  = (double) err_sum / NB_ITS / 64;
+     spec_err = is_idct && (err_inf > 1 || omse > 0.02 || fabs(ome) > 0.0015);
 -    if (spec_err && !dct->nonspec)
++    printf("%s %s: max_err=%d omse=%0.8f ome=%0.8f syserr=%0.8f maxout=%d blockSumErr=%d\n",
+            is_idct ? "IDCT" : "DCT", dct->name, err_inf,
+            omse, ome, (double) sysErrMax / NB_ITS,
+            maxout, blockSumErrMax);
 -    init_block(block, test, is_idct, &prng);
++    if (spec_err && !dct->nonspec) {
++        printf("Failed!\n");
+         return 1;
++    }
+     if (!speed)
+         return 0;
+     /* speed test */
 -    emms_c();
++
++    init_block(block, test, is_idct, &prng, vals);
+     permute(block1, block, dct->perm_type);
+     ti = av_gettime_relative();
+     it1 = 0;
+     do {
+         for (it = 0; it < NB_ITS_SPEED; it++) {
+             memcpy(block, block1, sizeof(block));
+             dct->func(block);
+         }
++        emms_c();
+         it1 += NB_ITS_SPEED;
+         ti1 = av_gettime_relative() - ti;
+     } while (ti1 < 1000000);
 -    emms_c();
+     printf("%s %s: %0.1f kdct/s\n", is_idct ? "IDCT" : "DCT", dct->name,
+            (double) it1 * 1000.0 / (double) ti1);
+     return 0;
+ }
+ DECLARE_ALIGNED(8, static uint8_t, img_dest)[64];
+ DECLARE_ALIGNED(8, static uint8_t, img_dest1)[64];
+ static void idct248_ref(uint8_t *dest, int linesize, int16_t *block)
+ {
+     static int init;
+     static double c8[8][8];
+     static double c4[4][4];
+     double block1[64], block2[64], block3[64];
+     double s, sum, v;
+     int i, j, k;
+     if (!init) {
+         init = 1;
+         for (i = 0; i < 8; i++) {
+             sum = 0;
+             for (j = 0; j < 8; j++) {
+                 s = (i == 0) ? sqrt(1.0 / 8.0) : sqrt(1.0 / 4.0);
+                 c8[i][j] = s * cos(M_PI * i * (j + 0.5) / 8.0);
+                 sum += c8[i][j] * c8[i][j];
+             }
+         }
+         for (i = 0; i < 4; i++) {
+             sum = 0;
+             for (j = 0; j < 4; j++) {
+                 s = (i == 0) ? sqrt(1.0 / 4.0) : sqrt(1.0 / 2.0);
+                 c4[i][j] = s * cos(M_PI * i * (j + 0.5) / 4.0);
+                 sum += c4[i][j] * c4[i][j];
+             }
+         }
+     }
+     /* butterfly */
+     s = 0.5 * sqrt(2.0);
+     for (i = 0; i < 4; i++) {
+         for (j = 0; j < 8; j++) {
+             block1[8 * (2 * i) + j] =
+                 (block[8 * (2 * i) + j] + block[8 * (2 * i + 1) + j]) * s;
+             block1[8 * (2 * i + 1) + j] =
+                 (block[8 * (2 * i) + j] - block[8 * (2 * i + 1) + j]) * s;
+         }
+     }
+     /* idct8 on lines */
+     for (i = 0; i < 8; i++) {
+         for (j = 0; j < 8; j++) {
+             sum = 0;
+             for (k = 0; k < 8; k++)
+                 sum += c8[k][j] * block1[8 * i + k];
+             block2[8 * i + j] = sum;
+         }
+     }
+     /* idct4 */
+     for (i = 0; i < 8; i++) {
+         for (j = 0; j < 4; j++) {
+             /* top */
+             sum = 0;
+             for (k = 0; k < 4; k++)
+                 sum += c4[k][j] * block2[8 * (2 * k) + i];
+             block3[8 * (2 * j) + i] = sum;
+             /* bottom */
+             sum = 0;
+             for (k = 0; k < 4; k++)
+                 sum += c4[k][j] * block2[8 * (2 * k + 1) + i];
+             block3[8 * (2 * j + 1) + i] = sum;
+         }
+     }
+     /* clamp and store the result */
+     for (i = 0; i < 8; i++) {
+         for (j = 0; j < 8; j++) {
+             v = block3[8 * i + j];
+             if      (v < 0)   v = 0;
+             else if (v > 255) v = 255;
+             dest[i * linesize + j] = (int) rint(v);
+         }
+     }
+ }
+ static void idct248_error(const char *name,
+                           void (*idct248_put)(uint8_t *dest, int line_size,
+                                               int16_t *block),
+                           int speed)
+ {
+     int it, i, it1, ti, ti1, err_max, v;
+     AVLFG prng;
+     av_lfg_init(&prng, 1);
+     /* just one test to see if code is correct (precision is less
+        important here) */
+     err_max = 0;
+     for (it = 0; it < NB_ITS; it++) {
+         /* XXX: use forward transform to generate values */
+         for (i = 0; i < 64; i++)
+             block1[i] = av_lfg_get(&prng) % 256 - 128;
+         block1[0] += 1024;
+         for (i = 0; i < 64; i++)
+             block[i] = block1[i];
+         idct248_ref(img_dest1, 8, block);
+         for (i = 0; i < 64; i++)
+             block[i] = block1[i];
+         idct248_put(img_dest, 8, block);
+         for (i = 0; i < 64; i++) {
+             v = abs((int) img_dest[i] - (int) img_dest1[i]);
+             if (v == 255)
+                 printf("%d %d\n", img_dest[i], img_dest1[i]);
+             if (v > err_max)
+                 err_max = v;
+         }
++#if 0
++        printf("ref=\n");
++        for(i=0;i<8;i++) {
++            int j;
++            for(j=0;j<8;j++) {
++                printf(" %3d", img_dest1[i*8+j]);
++            }
++            printf("\n");
++        }
++
++        printf("out=\n");
++        for(i=0;i<8;i++) {
++            int j;
++            for(j=0;j<8;j++) {
++                printf(" %3d", img_dest[i*8+j]);
++            }
++            printf("\n");
++        }
++#endif
+     }
+     printf("%s %s: err_inf=%d\n", 1 ? "IDCT248" : "DCT248", name, err_max);
+     if (!speed)
+         return;
+     ti = av_gettime_relative();
+     it1 = 0;
+     do {
+         for (it = 0; it < NB_ITS_SPEED; it++) {
+             for (i = 0; i < 64; i++)
+                 block[i] = block1[i];
+             idct248_put(img_dest, 8, block);
+         }
++        emms_c();
+         it1 += NB_ITS_SPEED;
+         ti1 = av_gettime_relative() - ti;
+     } while (ti1 < 1000000);
 -    printf("dct-test [-i] [<test-number>]\n"
+     printf("%s %s: %0.1f kdct/s\n", 1 ? "IDCT248" : "DCT248", name,
+            (double) it1 * 1000.0 / (double) ti1);
+ }
+ static void help(void)
+ {
 -    printf("Libav DCT/IDCT test\n");
++    printf("dct-test [-i] [<test-number>] [<bits>]\n"
+            "test-number 0 -> test with random matrixes\n"
+            "            1 -> test with random sparse matrixes\n"
+            "            2 -> do 3. test from MPEG-4 std\n"
++           "bits        Number of time domain bits to use, 8 is default\n"
+            "-i          test IDCT implementations\n"
+            "-4          test IDCT248 implementations\n"
+            "-t          speed test\n");
+ }
+ #if !HAVE_GETOPT
+ #include "compat/getopt.c"
+ #endif
+ int main(int argc, char **argv)
+ {
+     int test_idct = 0, test_248_dct = 0;
+     int c, i;
+     int test = 1;
+     int speed = 0;
+     int err = 0;
++    int bits=8;
+     ff_ref_dct_init();
+     for (;;) {
+         c = getopt(argc, argv, "ih4t");
+         if (c == -1)
+             break;
+         switch (c) {
+         case 'i':
+             test_idct = 1;
+             break;
+         case '4':
+             test_248_dct = 1;
+             break;
+         case 't':
+             speed = 1;
+             break;
+         default:
+         case 'h':
+             help();
+             return 0;
+         }
+     }
+     if (optind < argc)
+         test = atoi(argv[optind]);
++    if(optind+1 < argc) bits= atoi(argv[optind+1]);
 -                err |= dct_error(&idct_tab[i], test, test_idct, speed);
++    printf("ffmpeg DCT/IDCT test\n");
+     if (test_248_dct) {
+         idct248_error("SIMPLE-C", ff_simple_idct248_put, speed);
+     } else {
+         const int cpu_flags = av_get_cpu_flags();
+         if (test_idct) {
+             for (i = 0; i < FF_ARRAY_ELEMS(idct_tab); i++)
 -                    err |= dct_error(&idct_tab_arch[i], test, test_idct, speed);
++                err |= dct_error(&idct_tab[i], test, test_idct, speed, bits);
+             for (i = 0; idct_tab_arch[i].name; i++)
+                 if (!(~cpu_flags & idct_tab_arch[i].cpu_flag))
 -                err |= dct_error(&fdct_tab[i], test, test_idct, speed);
++                    err |= dct_error(&idct_tab_arch[i], test, test_idct, speed, bits);
+         }
+ #if CONFIG_FDCTDSP
+         else {
+             for (i = 0; i < FF_ARRAY_ELEMS(fdct_tab); i++)
 -                    err |= dct_error(&fdct_tab_arch[i], test, test_idct, speed);
++                err |= dct_error(&fdct_tab[i], test, test_idct, speed, bits);
+             for (i = 0; fdct_tab_arch[i].name; i++)
+                 if (!(~cpu_flags & fdct_tab_arch[i].cpu_flag))
++                    err |= dct_error(&fdct_tab_arch[i], test, test_idct, speed, bits);
+         }
+ #endif /* CONFIG_FDCTDSP */
+     }
+     if (err)
+         printf("Error: %d.\n", err);
+     return !!err;
+ }
index 0000000,6edd810..fe1b57a
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,20 +1,20 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 FFT_FLOAT 0
+ #include "fft.c"
index 0000000,0000000..f33494f
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,21 @@@
++/*
++ * 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 FFT_FLOAT 0
++#define FFT_FIXED_32 1
++#include "fft.c"
index 0000000,db1ce98..4717303
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,513 +1,519 @@@
 - * This file is part of Libav.
+ /*
+  * (c) 2002 Fabrice Bellard
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -    exptab = av_malloc((n / 2) * sizeof(*exptab));
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ /**
+  * @file
+  * FFT and MDCT tests.
+  */
+ #include "config.h"
+ #include <math.h>
+ #if HAVE_UNISTD_H
+ #include <unistd.h>
+ #endif
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
+ #include "libavutil/cpu.h"
+ #include "libavutil/lfg.h"
+ #include "libavutil/log.h"
+ #include "libavutil/mathematics.h"
+ #include "libavutil/time.h"
+ #include "libavcodec/fft.h"
+ #if FFT_FLOAT
+ #include "libavcodec/dct.h"
+ #include "libavcodec/rdft.h"
+ #endif
+ /* reference fft */
+ #define MUL16(a, b) ((a) * (b))
+ #define CMAC(pre, pim, are, aim, bre, bim)          \
+     {                                               \
+         pre += (MUL16(are, bre) - MUL16(aim, bim)); \
+         pim += (MUL16(are, bim) + MUL16(bre, aim)); \
+     }
+ #if FFT_FLOAT
+ #define RANGE 1.0
+ #define REF_SCALE(x, bits)  (x)
+ #define FMT "%10.6f"
++#elif FFT_FIXED_32
++#define RANGE 8388608
++#define REF_SCALE(x, bits) (x)
++#define FMT "%6d"
+ #else
+ #define RANGE 16384
+ #define REF_SCALE(x, bits) ((x) / (1 << (bits)))
+ #define FMT "%6d"
+ #endif
+ static struct {
+     float re, im;
+ } *exptab;
+ static int fft_ref_init(int nbits, int inverse)
+ {
+     int i, n = 1 << nbits;
 -static void idct_ref(float *output, float *input, int nbits)
++    exptab = av_malloc_array((n / 2), sizeof(*exptab));
+     if (!exptab)
+         return AVERROR(ENOMEM);
+     for (i = 0; i < (n / 2); i++) {
+         double alpha = 2 * M_PI * (float) i / (float) n;
+         double c1 = cos(alpha), s1 = sin(alpha);
+         if (!inverse)
+             s1 = -s1;
+         exptab[i].re = c1;
+         exptab[i].im = s1;
+     }
+     return 0;
+ }
+ static void fft_ref(FFTComplex *tabr, FFTComplex *tab, int nbits)
+ {
+     int i, j;
+     int n  = 1 << nbits;
+     int n2 = n >> 1;
+     for (i = 0; i < n; i++) {
+         double tmp_re = 0, tmp_im = 0;
+         FFTComplex *q = tab;
+         for (j = 0; j < n; j++) {
+             double s, c;
+             int k = (i * j) & (n - 1);
+             if (k >= n2) {
+                 c = -exptab[k - n2].re;
+                 s = -exptab[k - n2].im;
+             } else {
+                 c = exptab[k].re;
+                 s = exptab[k].im;
+             }
+             CMAC(tmp_re, tmp_im, c, s, q->re, q->im);
+             q++;
+         }
+         tabr[i].re = REF_SCALE(tmp_re, nbits);
+         tabr[i].im = REF_SCALE(tmp_im, nbits);
+     }
+ }
+ #if CONFIG_MDCT
+ static void imdct_ref(FFTSample *out, FFTSample *in, int nbits)
+ {
+     int i, k, n = 1 << nbits;
+     for (i = 0; i < n; i++) {
+         double sum = 0;
+         for (k = 0; k < n / 2; k++) {
+             int a = (2 * i + 1 + (n / 2)) * (2 * k + 1);
+             double f = cos(M_PI * a / (double) (2 * n));
+             sum += f * in[k];
+         }
+         out[i] = REF_SCALE(-sum, nbits - 2);
+     }
+ }
+ /* NOTE: no normalisation by 1 / N is done */
+ static void mdct_ref(FFTSample *output, FFTSample *input, int nbits)
+ {
+     int i, k, n = 1 << nbits;
+     /* do it by hand */
+     for (k = 0; k < n / 2; k++) {
+         double s = 0;
+         for (i = 0; i < n; i++) {
+             double a = (2 * M_PI * (2 * i + 1 + n / 2) * (2 * k + 1) / (4 * n));
+             s += input[i] * cos(a);
+         }
+         output[k] = REF_SCALE(s, nbits - 1);
+     }
+ }
+ #endif /* CONFIG_MDCT */
+ #if FFT_FLOAT
+ #if CONFIG_DCT
 -static void dct_ref(float *output, float *input, int nbits)
++static void idct_ref(FFTSample *output, FFTSample *input, int nbits)
+ {
+     int i, k, n = 1 << nbits;
+     /* do it by hand */
+     for (i = 0; i < n; i++) {
+         double s = 0.5 * input[0];
+         for (k = 1; k < n; k++) {
+             double a = M_PI * k * (i + 0.5) / n;
+             s += input[k] * cos(a);
+         }
+         output[i] = 2 * s / n;
+     }
+ }
 -    av_log(NULL, AV_LOG_INFO, "max:%f e:%g\n", max, sqrt(error) / n);
++static void dct_ref(FFTSample *output, FFTSample *input, int nbits)
+ {
+     int i, k, n = 1 << nbits;
+     /* do it by hand */
+     for (k = 0; k < n; k++) {
+         double s = 0;
+         for (i = 0; i < n; i++) {
+             double a = M_PI * k * (i + 0.5) / n;
+             s += input[i] * cos(a);
+         }
+         output[k] = s;
+     }
+ }
+ #endif /* CONFIG_DCT */
+ #endif /* FFT_FLOAT */
+ static FFTSample frandom(AVLFG *prng)
+ {
+     return (int16_t) av_lfg_get(prng) / 32768.0 * RANGE;
+ }
+ static int check_diff(FFTSample *tab1, FFTSample *tab2, int n, double scale)
+ {
+     int i, err = 0;
+     double error = 0, max = 0;
+     for (i = 0; i < n; i++) {
+         double e = fabs(tab1[i] - (tab2[i] / scale)) / RANGE;
+         if (e >= 1e-3) {
+             av_log(NULL, AV_LOG_ERROR, "ERROR %5d: "FMT" "FMT"\n",
+                    i, tab1[i], tab2[i]);
+             err = 1;
+         }
+         error += e * e;
+         if (e > max)
+             max = e;
+     }
 -            int cpuflags = av_parse_cpu_flags(optarg);
 -            if (cpuflags < 0)
++    av_log(NULL, AV_LOG_INFO, "max:%f e:%g\n", max, sqrt(error / n));
+     return err;
+ }
+ static void help(void)
+ {
+     av_log(NULL, AV_LOG_INFO,
+            "usage: fft-test [-h] [-s] [-i] [-n b]\n"
+            "-h     print this help\n"
+            "-s     speed test\n"
+            "-m     (I)MDCT test\n"
+            "-d     (I)DCT test\n"
+            "-r     (I)RDFT test\n"
+            "-i     inverse transform test\n"
+            "-n b   set the transform size to 2^b\n"
+            "-f x   set scale factor for output data of (I)MDCT to x\n");
+ }
+ enum tf_transform {
+     TRANSFORM_FFT,
+     TRANSFORM_MDCT,
+     TRANSFORM_RDFT,
+     TRANSFORM_DCT,
+ };
+ #if !HAVE_GETOPT
+ #include "compat/getopt.c"
+ #endif
+ int main(int argc, char **argv)
+ {
+     FFTComplex *tab, *tab1, *tab_ref;
+     FFTSample *tab2;
+     enum tf_transform transform = TRANSFORM_FFT;
+     FFTContext m, s;
+ #if FFT_FLOAT
+     RDFTContext r;
+     DCTContext d;
+ #endif /* FFT_FLOAT */
+     int it, i, err = 1;
+     int do_speed = 0, do_inverse = 0;
+     int fft_nbits = 9, fft_size;
+     double scale = 1.0;
+     AVLFG prng;
+     av_lfg_init(&prng, 1);
+     for (;;) {
+         int c = getopt(argc, argv, "hsimrdn:f:c:");
+         if (c == -1)
+             break;
+         switch (c) {
+         case 'h':
+             help();
+             return 1;
+         case 's':
+             do_speed = 1;
+             break;
+         case 'i':
+             do_inverse = 1;
+             break;
+         case 'm':
+             transform = TRANSFORM_MDCT;
+             break;
+         case 'r':
+             transform = TRANSFORM_RDFT;
+             break;
+         case 'd':
+             transform = TRANSFORM_DCT;
+             break;
+         case 'n':
+             fft_nbits = atoi(optarg);
+             break;
+         case 'f':
+             scale = atof(optarg);
+             break;
+         case 'c':
+         {
 -            av_set_cpu_flags_mask(cpuflags);
++            unsigned cpuflags = av_get_cpu_flags();
++
++            if (av_parse_cpu_caps(&cpuflags, optarg) < 0)
+                 return 1;
 -    tab      = av_malloc(fft_size * sizeof(FFTComplex));
 -    tab1     = av_malloc(fft_size * sizeof(FFTComplex));
 -    tab_ref  = av_malloc(fft_size * sizeof(FFTComplex));
 -    tab2     = av_malloc(fft_size * sizeof(FFTSample));
++
++            av_force_cpu_flags(cpuflags);
+             break;
+         }
+         }
+     }
+     fft_size = 1 << fft_nbits;
 -        if (err = fft_ref_init(fft_nbits, do_inverse) < 0)
++    tab      = av_malloc_array(fft_size, sizeof(FFTComplex));
++    tab1     = av_malloc_array(fft_size, sizeof(FFTComplex));
++    tab_ref  = av_malloc_array(fft_size, sizeof(FFTComplex));
++    tab2     = av_malloc_array(fft_size, sizeof(FFTSample));
+     if (!(tab && tab1 && tab_ref && tab2))
+         goto cleanup;
+     switch (transform) {
+ #if CONFIG_MDCT
+     case TRANSFORM_MDCT:
+         av_log(NULL, AV_LOG_INFO, "Scale factor is set to %f\n", scale);
+         if (do_inverse)
+             av_log(NULL, AV_LOG_INFO, "IMDCT");
+         else
+             av_log(NULL, AV_LOG_INFO, "MDCT");
+         ff_mdct_init(&m, fft_nbits, do_inverse, scale);
+         break;
+ #endif /* CONFIG_MDCT */
+     case TRANSFORM_FFT:
+         if (do_inverse)
+             av_log(NULL, AV_LOG_INFO, "IFFT");
+         else
+             av_log(NULL, AV_LOG_INFO, "FFT");
+         ff_fft_init(&s, fft_nbits, do_inverse);
 -#if CONFIG_RDFT
++        if ((err = fft_ref_init(fft_nbits, do_inverse)) < 0)
+             goto cleanup;
+         break;
+ #if FFT_FLOAT
 -        if (err = fft_ref_init(fft_nbits, do_inverse) < 0)
++#    if CONFIG_RDFT
+     case TRANSFORM_RDFT:
+         if (do_inverse)
+             av_log(NULL, AV_LOG_INFO, "IDFT_C2R");
+         else
+             av_log(NULL, AV_LOG_INFO, "DFT_R2C");
+         ff_rdft_init(&r, fft_nbits, do_inverse ? IDFT_C2R : DFT_R2C);
 -#endif /* CONFIG_RDFT */
 -#if CONFIG_DCT
++        if ((err = fft_ref_init(fft_nbits, do_inverse)) < 0)
+             goto cleanup;
+         break;
 -#endif /* CONFIG_DCT */
++#    endif /* CONFIG_RDFT */
++#    if CONFIG_DCT
+     case TRANSFORM_DCT:
+         if (do_inverse)
+             av_log(NULL, AV_LOG_INFO, "DCT_III");
+         else
+             av_log(NULL, AV_LOG_INFO, "DCT_II");
+         ff_dct_init(&d, fft_nbits, do_inverse ? DCT_III : DCT_II);
+         break;
 -#if CONFIG_RDFT
++#    endif /* CONFIG_DCT */
+ #endif /* FFT_FLOAT */
+     default:
+         av_log(NULL, AV_LOG_ERROR, "Requested transform not supported\n");
+         goto cleanup;
+     }
+     av_log(NULL, AV_LOG_INFO, " %d test\n", fft_size);
+     /* generate random data */
+     for (i = 0; i < fft_size; i++) {
+         tab1[i].re = frandom(&prng);
+         tab1[i].im = frandom(&prng);
+     }
+     /* checking result */
+     av_log(NULL, AV_LOG_INFO, "Checking...\n");
+     switch (transform) {
+ #if CONFIG_MDCT
+     case TRANSFORM_MDCT:
+         if (do_inverse) {
+             imdct_ref(&tab_ref->re, &tab1->re, fft_nbits);
+             m.imdct_calc(&m, tab2, &tab1->re);
+             err = check_diff(&tab_ref->re, tab2, fft_size, scale);
+         } else {
+             mdct_ref(&tab_ref->re, &tab1->re, fft_nbits);
+             m.mdct_calc(&m, tab2, &tab1->re);
+             err = check_diff(&tab_ref->re, tab2, fft_size / 2, scale);
+         }
+         break;
+ #endif /* CONFIG_MDCT */
+     case TRANSFORM_FFT:
+         memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
+         s.fft_permute(&s, tab);
+         s.fft_calc(&s, tab);
+         fft_ref(tab_ref, tab1, fft_nbits);
+         err = check_diff(&tab_ref->re, &tab->re, fft_size * 2, 1.0);
+         break;
+ #if FFT_FLOAT
+ #if CONFIG_RDFT
+     case TRANSFORM_RDFT:
+     {
+         int fft_size_2 = fft_size >> 1;
+         if (do_inverse) {
+             tab1[0].im          = 0;
+             tab1[fft_size_2].im = 0;
+             for (i = 1; i < fft_size_2; i++) {
+                 tab1[fft_size_2 + i].re =  tab1[fft_size_2 - i].re;
+                 tab1[fft_size_2 + i].im = -tab1[fft_size_2 - i].im;
+             }
+             memcpy(tab2, tab1, fft_size * sizeof(FFTSample));
+             tab2[1] = tab1[fft_size_2].re;
+             r.rdft_calc(&r, tab2);
+             fft_ref(tab_ref, tab1, fft_nbits);
+             for (i = 0; i < fft_size; i++) {
+                 tab[i].re = tab2[i];
+                 tab[i].im = 0;
+             }
+             err = check_diff(&tab_ref->re, &tab->re, fft_size * 2, 0.5);
+         } else {
+             for (i = 0; i < fft_size; i++) {
+                 tab2[i]    = tab1[i].re;
+                 tab1[i].im = 0;
+             }
+             r.rdft_calc(&r, tab2);
+             fft_ref(tab_ref, tab1, fft_nbits);
+             tab_ref[0].im = tab_ref[fft_size_2].re;
+             err = check_diff(&tab_ref->re, tab2, fft_size, 1.0);
+         }
+         break;
+     }
+ #endif /* CONFIG_RDFT */
+ #if CONFIG_DCT
+     case TRANSFORM_DCT:
+         memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
+         d.dct_calc(&d, &tab->re);
+         if (do_inverse)
+             idct_ref(&tab_ref->re, &tab1->re, fft_nbits);
+         else
+             dct_ref(&tab_ref->re, &tab1->re, fft_nbits);
+         err = check_diff(&tab_ref->re, &tab->re, fft_size, 1.0);
+         break;
+ #endif /* CONFIG_DCT */
+ #endif /* FFT_FLOAT */
+     }
+     /* do a speed test */
+     if (do_speed) {
+         int64_t time_start, duration;
+         int nb_its;
+         av_log(NULL, AV_LOG_INFO, "Speed test...\n");
+         /* we measure during about 1 seconds */
+         nb_its = 1;
+         for (;;) {
+             time_start = av_gettime_relative();
+             for (it = 0; it < nb_its; it++) {
+                 switch (transform) {
+                 case TRANSFORM_MDCT:
+                     if (do_inverse)
+                         m.imdct_calc(&m, &tab->re, &tab1->re);
+                     else
+                         m.mdct_calc(&m, &tab->re, &tab1->re);
+                     break;
+                 case TRANSFORM_FFT:
+                     memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
+                     s.fft_calc(&s, tab);
+                     break;
+ #if FFT_FLOAT
+                 case TRANSFORM_RDFT:
+                     memcpy(tab2, tab1, fft_size * sizeof(FFTSample));
+                     r.rdft_calc(&r, tab2);
+                     break;
+                 case TRANSFORM_DCT:
+                     memcpy(tab2, tab1, fft_size * sizeof(FFTSample));
+                     d.dct_calc(&d, tab2);
+                     break;
+ #endif /* FFT_FLOAT */
+                 }
+             }
+             duration = av_gettime_relative() - time_start;
+             if (duration >= 1000000)
+                 break;
+             nb_its *= 2;
+         }
+         av_log(NULL, AV_LOG_INFO,
+                "time: %0.1f us/transform [total time=%0.2f s its=%d]\n",
+                (double) duration / nb_its,
+                (double) duration / 1000000.0,
+                nb_its);
+     }
+     switch (transform) {
+ #if CONFIG_MDCT
+     case TRANSFORM_MDCT:
+         ff_mdct_end(&m);
+         break;
+ #endif /* CONFIG_MDCT */
+     case TRANSFORM_FFT:
+         ff_fft_end(&s);
+         break;
+ #if FFT_FLOAT
 -#endif /* CONFIG_RDFT */
 -#if CONFIG_DCT
++#    if CONFIG_RDFT
+     case TRANSFORM_RDFT:
+         ff_rdft_end(&r);
+         break;
 -#endif /* CONFIG_DCT */
++#    endif /* CONFIG_RDFT */
++#    if CONFIG_DCT
+     case TRANSFORM_DCT:
+         ff_dct_end(&d);
+         break;
++#    endif /* CONFIG_DCT */
+ #endif /* FFT_FLOAT */
+     }
+ cleanup:
+     av_free(tab);
+     av_free(tab1);
+     av_free(tab2);
+     av_free(tab_ref);
+     av_free(exptab);
+     if (err)
+         printf("Error: %d.\n", err);
+     return !!err;
+ }
index 0000000,7587402..965367b
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,97 +1,99 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -#include "libavcodec/put_bits.h"
++ * 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 "libavutil/mem.h"
+ #include "libavcodec/get_bits.h"
 -#define EXTEND(i) (i << 3 | i & 7)
+ #include "libavcodec/golomb.h"
++#include "libavcodec/put_bits.h"
+ #define COUNT 8191
+ #define SIZE (COUNT * 4)
+ int main(void)
+ {
+     int i, ret = 0;
+     uint8_t *temp;
+     PutBitContext pb;
+     GetBitContext gb;
+     temp = av_malloc(SIZE);
+     if (!temp)
+         return 2;
+     init_put_bits(&pb, temp, SIZE);
+     for (i = 0; i < COUNT; i++)
+         set_ue_golomb(&pb, i);
+     flush_put_bits(&pb);
+     init_get_bits(&gb, temp, 8 * SIZE);
+     for (i = 0; i < COUNT; i++) {
+         int j, s = show_bits(&gb, 25);
+         j = get_ue_golomb(&gb);
+         if (j != i) {
+             fprintf(stderr, "get_ue_golomb: expected %d, got %d. bits: %7x\n",
+                     i, j, s);
+             ret = 1;
+         }
+     }
++#define EXTEND(i) ((i) << 3 | (i) & 7)
+     init_put_bits(&pb, temp, SIZE);
+     for (i = 0; i < COUNT; i++)
+         set_ue_golomb(&pb, EXTEND(i));
+     flush_put_bits(&pb);
+     init_get_bits(&gb, temp, 8 * SIZE);
+     for (i = 0; i < COUNT; i++) {
+         int j, s = show_bits_long(&gb, 32);
+         j = get_ue_golomb_long(&gb);
+         if (j != EXTEND(i)) {
+             fprintf(stderr, "get_ue_golomb_long: expected %d, got %d. "
+                     "bits: %8x\n", EXTEND(i), j, s);
+             ret = 1;
+         }
+     }
+     init_put_bits(&pb, temp, SIZE);
+     for (i = 0; i < COUNT; i++)
+         set_se_golomb(&pb, i - COUNT / 2);
+     flush_put_bits(&pb);
+     init_get_bits(&gb, temp, 8 * SIZE);
+     for (i = 0; i < COUNT; i++) {
+         int j, s = show_bits(&gb, 25);
+         j = get_se_golomb(&gb);
+         if (j != i - COUNT / 2) {
+             fprintf(stderr, "get_se_golomb: expected %d, got %d. bits: %7x\n",
+                     i - COUNT / 2, j, s);
+             ret = 1;
+         }
+     }
+     av_free(temp);
+     return ret;
+ }
index 0000000,a6001a3..60cc6fc
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,54 +1,54 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -    ff_iir_filter_free_coeffs(fcoeffs);
 -    ff_iir_filter_free_state(fstate);
++ * 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 "libavutil/libm.h"
+ #include "libavcodec/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;
+ }
index 0000000,0000000..c598d46
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,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 "libavcodec/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 */
index 0000000,0000000..80b33be
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,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 "libavcodec/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;
++}
index 0000000,0000000..33a059c
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,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 "libavcodec/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;
++}
index 0000000,0000000..d89f940
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,152 @@@
++/*
++ * (c) 2001 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
++ */
++
++/**
++ * @file
++ * motion test.
++ */
++
++#include <stdlib.h>
++#include <stdio.h>
++#include <string.h>
++
++#include "config.h"
++#include "libavcodec/me_cmp.h"
++#include "libavutil/internal.h"
++#include "libavutil/lfg.h"
++#include "libavutil/mem.h"
++#include "libavutil/time.h"
++
++#undef printf
++
++#define WIDTH 64
++#define HEIGHT 64
++
++static uint8_t img1[WIDTH * HEIGHT];
++static uint8_t img2[WIDTH * HEIGHT];
++
++static void fill_random(uint8_t *tab, int size)
++{
++    int i;
++    AVLFG prng;
++
++    av_lfg_init(&prng, 1);
++    for(i=0;i<size;i++) {
++        tab[i] = av_lfg_get(&prng) % 256;
++    }
++}
++
++static void help(void)
++{
++    printf("motion-test [-h]\n"
++           "test motion implementations\n");
++}
++
++#define NB_ITS 500
++
++int dummy;
++
++static void test_motion(const char *name,
++                 me_cmp_func test_func, me_cmp_func ref_func)
++{
++    int x, y, d1, d2, it;
++    uint8_t *ptr;
++    int64_t ti;
++    printf("testing '%s'\n", name);
++
++    /* test correctness */
++    for(it=0;it<20;it++) {
++
++        fill_random(img1, WIDTH * HEIGHT);
++        fill_random(img2, WIDTH * HEIGHT);
++
++        for(y=0;y<HEIGHT-17;y++) {
++            for(x=0;x<WIDTH-17;x++) {
++                ptr = img2 + y * WIDTH + x;
++                d1 = test_func(NULL, img1, ptr, WIDTH, 8);
++                d2 = ref_func(NULL, img1, ptr, WIDTH, 8);
++                if (d1 != d2) {
++                    printf("error: mmx=%d c=%d\n", d1, d2);
++                }
++            }
++        }
++    }
++    emms_c();
++
++    /* speed test */
++    ti = av_gettime_relative();
++    d1 = 0;
++    for(it=0;it<NB_ITS;it++) {
++        for(y=0;y<HEIGHT-17;y++) {
++            for(x=0;x<WIDTH-17;x++) {
++                ptr = img2 + y * WIDTH + x;
++                d1 += test_func(NULL, img1, ptr, WIDTH, 8);
++            }
++        }
++    }
++    emms_c();
++    dummy = d1; /* avoid optimization */
++    ti = av_gettime_relative() - ti;
++
++    printf("  %0.0f kop/s\n",
++           (double)NB_ITS * (WIDTH - 16) * (HEIGHT - 16) /
++           (double)(ti / 1000.0));
++}
++
++
++int main(int argc, char **argv)
++{
++    AVCodecContext *ctx;
++    int c;
++    MECmpContext cctx, mmxctx;
++    int flags[2] = { AV_CPU_FLAG_MMX, AV_CPU_FLAG_MMXEXT };
++    int flags_size = HAVE_MMXEXT ? 2 : 1;
++
++    if (argc > 1) {
++        help();
++        return 1;
++    }
++
++    printf("ffmpeg motion test\n");
++
++    ctx = avcodec_alloc_context3(NULL);
++    ctx->flags |= AV_CODEC_FLAG_BITEXACT;
++    av_force_cpu_flags(0);
++    memset(&cctx, 0, sizeof(cctx));
++    ff_me_cmp_init(&cctx, ctx);
++    for (c = 0; c < flags_size; c++) {
++        int x;
++        av_force_cpu_flags(flags[c]);
++        memset(&mmxctx, 0, sizeof(mmxctx));
++        ff_me_cmp_init(&mmxctx, ctx);
++
++        for (x = 0; x < 2; x++) {
++            printf("%s for %dx%d pixels\n", c ? "mmx2" : "mmx",
++                   x ? 8 : 16, x ? 8 : 16);
++            test_motion("mmx",     mmxctx.pix_abs[x][0], cctx.pix_abs[x][0]);
++            test_motion("mmx_x2",  mmxctx.pix_abs[x][1], cctx.pix_abs[x][1]);
++            test_motion("mmx_y2",  mmxctx.pix_abs[x][2], cctx.pix_abs[x][2]);
++            test_motion("mmx_xy2", mmxctx.pix_abs[x][3], cctx.pix_abs[x][3]);
++        }
++    }
++    av_free(ctx);
++
++    return 0;
++}
index 0000000,0000000..7f0ee1d
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,194 @@@
++/*
++ * 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 "libavcodec/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) {
++        int ret;
++        printf("opened:\n");
++        ret = avcodec_open2(ctx1, ctx1->codec, NULL);
++        if (ret < 0) {
++            fprintf(stderr, "avcodec_open2 failed\n");
++            exit(1);
++        }
++        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;
++}
index 0000000,3d160d3..d95db52
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,32 +1,32 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -#if HAVE_ALTIVEC && HAVE_BIGENDIAN
++ * 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 "libavcodec/ppc/fdct.h"
+ static const struct algo fdct_tab_arch[] = {
++#if HAVE_ALTIVEC
+     { "altivecfdct", ff_fdct_altivec, FF_IDCT_PERM_NONE, AV_CPU_FLAG_ALTIVEC },
+ #endif
+     { 0 }
+ };
+ static const struct algo idct_tab_arch[] = {
+     { 0 }
+ };
index 0000000,26bb589..2da5c0c
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,64 +1,64 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -    ff_build_rac_states(&c, 0.05 * (1LL << 32), 128 + 64 + 32 + 16);
++ * 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 "libavcodec/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;
+ }
index 0000000,0000000..d5f94e8
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,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 "libavcodec/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;
++}
index 0000000,0000000..e2891fb
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,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 "libavcodec/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;
++}
index 0000000,2ddb555..b6cdfb3
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,86 +1,133 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -#if CONFIG_MPEG4_DECODER
 -#if HAVE_MMX_INLINE
++ * 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 "libavcodec/x86/fdct.h"
+ #include "libavcodec/x86/xvididct.h"
+ #include "libavcodec/x86/simple_idct.h"
++#if (CONFIG_PRORES_DECODER || CONFIG_PRORES_LGPL_DECODER) && ARCH_X86_64 && HAVE_YASM
++void ff_prores_idct_put_10_sse2(uint16_t *dst, int linesize,
++                                int16_t *block, int16_t *qmat);
++
++#define PR_WRAP(INSN) \
++static void ff_prores_idct_put_10_##INSN##_wrap(int16_t *dst){ \
++    LOCAL_ALIGNED(16, int16_t, qmat, [64]); \
++    LOCAL_ALIGNED(16, int16_t, tmp, [64]); \
++    int i; \
++ \
++    for(i=0; i<64; i++){ \
++        qmat[i]=4; \
++        tmp[i]= dst[i]; \
++    } \
++    ff_prores_idct_put_10_##INSN (dst, 16, tmp, qmat); \
++ \
++    for(i=0; i<64; i++) { \
++         dst[i] -= 512; \
++    } \
++}
++
++PR_WRAP(sse2)
++
++# if HAVE_AVX_EXTERNAL
++void ff_prores_idct_put_10_avx(uint16_t *dst, int linesize,
++                               int16_t *block, int16_t *qmat);
++PR_WRAP(avx)
++# endif
++
++#endif
++
+ static const struct algo fdct_tab_arch[] = {
+ #if HAVE_MMX_INLINE
+     { "MMX",    ff_fdct_mmx,    FF_IDCT_PERM_NONE, AV_CPU_FLAG_MMX },
+ #endif
+ #if HAVE_MMXEXT_INLINE
+     { "MMXEXT", ff_fdct_mmxext, FF_IDCT_PERM_NONE, AV_CPU_FLAG_MMXEXT },
+ #endif
+ #if HAVE_SSE2_INLINE
+     { "SSE2",   ff_fdct_sse2,   FF_IDCT_PERM_NONE, AV_CPU_FLAG_SSE2 },
+ #endif
+     { 0 }
+ };
+ static const struct algo idct_tab_arch[] = {
+ #if HAVE_MMX_INLINE
+     { "SIMPLE-MMX",  ff_simple_idct_mmx,  FF_IDCT_PERM_SIMPLE, AV_CPU_FLAG_MMX },
+ #endif
 -#endif
 -#if HAVE_MMXEXT_INLINE
++#if CONFIG_MPEG4_DECODER && HAVE_YASM
++#if ARCH_X86_32
+     { "XVID-MMX",    ff_xvid_idct_mmx,    FF_IDCT_PERM_NONE,   AV_CPU_FLAG_MMX,    1 },
 -#if HAVE_SSE2_INLINE
+     { "XVID-MMXEXT", ff_xvid_idct_mmxext, FF_IDCT_PERM_NONE,   AV_CPU_FLAG_MMXEXT, 1 },
+ #endif
 -#endif /* CONFIG_MPEG4_DECODER */
++#if HAVE_SSE2_EXTERNAL
+     { "XVID-SSE2",   ff_xvid_idct_sse2,   FF_IDCT_PERM_SSE2,   AV_CPU_FLAG_SSE2,   1 },
+ #endif
 -static short idct_simple_mmx_perm[64] = {
++#endif /* CONFIG_MPEG4_DECODER && HAVE_YASM */
++#if (CONFIG_PRORES_DECODER || CONFIG_PRORES_LGPL_DECODER) && ARCH_X86_64 && HAVE_YASM
++    { "PR-SSE2",     ff_prores_idct_put_10_sse2_wrap, FF_IDCT_PERM_TRANSPOSE, AV_CPU_FLAG_SSE2, 1 },
++# if HAVE_AVX_EXTERNAL
++    { "PR-AVX",      ff_prores_idct_put_10_avx_wrap, FF_IDCT_PERM_TRANSPOSE, AV_CPU_FLAG_AVX, 1 },
++# endif
++#endif
++#if HAVE_YASM
++#if ARCH_X86_64
++#if HAVE_SSE2_EXTERNAL
++    { "SIMPLE10-SSE2",  ff_simple_idct10_sse2, FF_IDCT_PERM_TRANSPOSE, AV_CPU_FLAG_SSE2},
++    { "SIMPLE12-SSE2",  ff_simple_idct12_sse2, FF_IDCT_PERM_TRANSPOSE, AV_CPU_FLAG_SSE2, 1 },
++#endif
++#if HAVE_AVX_EXTERNAL
++    { "SIMPLE10-AVX",   ff_simple_idct10_avx,  FF_IDCT_PERM_TRANSPOSE, AV_CPU_FLAG_AVX},
++    { "SIMPLE12-AVX",   ff_simple_idct12_avx,  FF_IDCT_PERM_TRANSPOSE, AV_CPU_FLAG_AVX,  1 },
++#endif
++#endif
++#endif
+     { 0 }
+ };
++static const uint8_t idct_simple_mmx_perm[64] = {
+     0x00, 0x08, 0x04, 0x09, 0x01, 0x0C, 0x05, 0x0D,
+     0x10, 0x18, 0x14, 0x19, 0x11, 0x1C, 0x15, 0x1D,
+     0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0x25, 0x2D,
+     0x12, 0x1A, 0x16, 0x1B, 0x13, 0x1E, 0x17, 0x1F,
+     0x02, 0x0A, 0x06, 0x0B, 0x03, 0x0E, 0x07, 0x0F,
+     0x30, 0x38, 0x34, 0x39, 0x31, 0x3C, 0x35, 0x3D,
+     0x22, 0x2A, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F,
+     0x32, 0x3A, 0x36, 0x3B, 0x33, 0x3E, 0x37, 0x3F,
+ };
+ static const uint8_t idct_sse2_row_perm[8] = { 0, 4, 1, 5, 2, 6, 3, 7 };
+ static int permute_x86(int16_t dst[64], const int16_t src[64],
+                        enum idct_permutation_type perm_type)
+ {
+     int i;
+     switch (perm_type) {
+     case FF_IDCT_PERM_SIMPLE:
+         for (i = 0; i < 64; i++)
+             dst[idct_simple_mmx_perm[i]] = src[i];
+         return 1;
+     case FF_IDCT_PERM_SSE2:
+         for (i = 0; i < 64; i++)
+             dst[(i & 0x38) | idct_sse2_row_perm[i & 7]] = src[i];
+         return 1;
+     }
+     return 0;
+ }
index 0000000,0000000..b4a2281
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,1 @@@
++/timefilter
index 0000000,8c7cba2..7c1ed0a
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,92 +1,98 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -            double bestpar0   = 1;
 -            double bestpar1   = 0.001;
++ * 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 "libavdevice/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;
 -                ideal[i]   = 10 + i + n1 * i / (1000);
++            double bestpar0   = n0 ? 1 : 100000;
++            double bestpar1   = 1;
+             int better, i;
+             av_lfg_init(&prng, 123);
+             for (i = 0; i < SAMPLES; i++) {
 -                            filtered = ff_timefilter_update(tf, samples[i], 1);
++                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;
 -            printf(" [%f %f %9f]", bestpar0, bestpar1, best_error);
++                            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;
+ }
index 0000000,a55b386..b605afa
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,1 +1,3 @@@
++/drawutils
+ /filtfmts
++/formats
index 0000000,0000000..7fe53dd
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,56 @@@
++/*
++ * 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/pixdesc.h"
++#include "libavfilter/drawutils.h"
++
++int main(void)
++{
++    enum AVPixelFormat f;
++    const AVPixFmtDescriptor *desc;
++    FFDrawContext draw;
++    FFDrawColor color;
++    int r, i;
++
++    for (f = 0; av_pix_fmt_desc_get(f); f++) {
++        desc = av_pix_fmt_desc_get(f);
++        if (!desc->name)
++            continue;
++        printf("Testing %s...%*s", desc->name,
++               (int)(16 - strlen(desc->name)), "");
++        r = ff_draw_init(&draw, f, 0);
++        if (r < 0) {
++            char buf[128];
++            av_strerror(r, buf, sizeof(buf));
++            printf("no: %s\n", buf);
++            continue;
++        }
++        ff_draw_color(&draw, &color, (uint8_t[]) { 1, 0, 0, 1 });
++        for (i = 0; i < sizeof(color); i++)
++            if (((uint8_t *)&color)[i] != 128)
++                break;
++        if (i == sizeof(color)) {
++            printf("fallback color\n");
++            continue;
++        }
++        printf("ok\n");
++    }
++    return 0;
++}
index 0000000,cc04654..46a2d94
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,124 +1,150 @@@
 - * This file is part of Libav.
+ /*
+  * Copyright (c) 2009 Stefano Sabatini
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -    int i, j, ret = 0;
++ * 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/channel_layout.h"
+ #include "libavutil/mem.h"
+ #include "libavutil/pixdesc.h"
++#include "libavutil/samplefmt.h"
+ #include "libavfilter/avfilter.h"
+ #include "libavfilter/formats.h"
++static void print_formats(AVFilterContext *filter_ctx)
++{
++    int i, j;
++
++#define PRINT_FMTS(inout, outin, INOUT)                                 \
++    for (i = 0; i < filter_ctx->nb_##inout##puts; i++) {                     \
++        if (filter_ctx->inout##puts[i]->type == AVMEDIA_TYPE_VIDEO) {   \
++            AVFilterFormats *fmts =                                     \
++                filter_ctx->inout##puts[i]->outin##_formats;            \
++            for (j = 0; j < fmts->nb_formats; j++)                    \
++                if(av_get_pix_fmt_name(fmts->formats[j]))               \
++                printf(#INOUT "PUT[%d] %s: fmt:%s\n",                   \
++                       i, avfilter_pad_get_name(filter_ctx->inout##put_pads, i),      \
++                       av_get_pix_fmt_name(fmts->formats[j]));          \
++        } else if (filter_ctx->inout##puts[i]->type == AVMEDIA_TYPE_AUDIO) { \
++            AVFilterFormats *fmts;                                      \
++            AVFilterChannelLayouts *layouts;                            \
++                                                                        \
++            fmts = filter_ctx->inout##puts[i]->outin##_formats;         \
++            for (j = 0; j < fmts->nb_formats; j++)                    \
++                printf(#INOUT "PUT[%d] %s: fmt:%s\n",                   \
++                       i, avfilter_pad_get_name(filter_ctx->inout##put_pads, i),      \
++                       av_get_sample_fmt_name(fmts->formats[j]));       \
++                                                                        \
++            layouts = filter_ctx->inout##puts[i]->outin##_channel_layouts; \
++            for (j = 0; j < layouts->nb_channel_layouts; j++) {                  \
++                char buf[256];                                          \
++                av_get_channel_layout_string(buf, sizeof(buf), -1,      \
++                                             layouts->channel_layouts[j]);         \
++                printf(#INOUT "PUT[%d] %s: chlayout:%s\n",              \
++                       i, avfilter_pad_get_name(filter_ctx->inout##put_pads, i), buf); \
++            }                                                           \
++        }                                                               \
++    }                                                                   \
++
++    PRINT_FMTS(in,  out, IN);
++    PRINT_FMTS(out, in,  OUT);
++}
++
+ int main(int argc, char **argv)
+ {
+     AVFilter *filter;
+     AVFilterContext *filter_ctx;
+     AVFilterGraph *graph_ctx;
+     const char *filter_name;
+     const char *filter_args = NULL;
 -    if (!argv[1]) {
++    int i;
++    int ret = 0;
+     av_log_set_level(AV_LOG_DEBUG);
 -    if (argv[2])
++    if (argc < 2) {
+         fprintf(stderr, "Missing filter name as argument\n");
+         return 1;
+     }
+     filter_name = argv[1];
 -        link->type = avfilter_pad_get_type(filter_ctx->filter->inputs, i);
++    if (argc > 2)
+         filter_args = argv[2];
+     /* allocate graph */
+     graph_ctx = avfilter_graph_alloc();
+     if (!graph_ctx)
+         return 1;
+     avfilter_register_all();
+     /* get a corresponding filter and open it */
+     if (!(filter = avfilter_get_by_name(filter_name))) {
+         fprintf(stderr, "Unrecognized filter with name '%s'\n", filter_name);
+         return 1;
+     }
+     /* open filter and add it to the graph */
+     if (!(filter_ctx = avfilter_graph_alloc_filter(graph_ctx, filter, filter_name))) {
+         fprintf(stderr, "Impossible to open filter with name '%s'\n",
+                 filter_name);
+         return 1;
+     }
+     if (avfilter_init_str(filter_ctx, filter_args) < 0) {
+         fprintf(stderr, "Impossible to init filter '%s' with arguments '%s'\n",
+                 filter_name, filter_args);
+         return 1;
+     }
+     /* create a link for each of the input pads */
+     for (i = 0; i < filter_ctx->nb_inputs; i++) {
+         AVFilterLink *link = av_mallocz(sizeof(AVFilterLink));
+         if (!link) {
+             fprintf(stderr, "Unable to allocate memory for filter input link\n");
+             ret = 1;
+             goto fail;
+         }
 -        link->type = avfilter_pad_get_type(filter_ctx->filter->outputs, i);
++        link->type = avfilter_pad_get_type(filter_ctx->input_pads, i);
+         filter_ctx->inputs[i] = link;
+     }
+     for (i = 0; i < filter_ctx->nb_outputs; i++) {
+         AVFilterLink *link = av_mallocz(sizeof(AVFilterLink));
+         if (!link) {
+             fprintf(stderr, "Unable to allocate memory for filter output link\n");
+             ret = 1;
+             goto fail;
+         }
 -    /* print the supported formats in input */
 -    for (i = 0; i < filter_ctx->nb_inputs; i++) {
 -        AVFilterFormats *fmts = filter_ctx->inputs[i]->out_formats;
 -        for (j = 0; j < fmts->nb_formats; j++)
 -            printf("INPUT[%d] %s: %s\n",
 -                   i, avfilter_pad_get_name(filter_ctx->filter->inputs, i),
 -                   av_get_pix_fmt_name(fmts->formats[j]));
 -    }
 -
 -    /* print the supported formats in output */
 -    for (i = 0; i < filter_ctx->nb_outputs; i++) {
 -        AVFilterFormats *fmts = filter_ctx->outputs[i]->in_formats;
 -        for (j = 0; j < fmts->nb_formats; j++)
 -            printf("OUTPUT[%d] %s: %s\n",
 -                   i, avfilter_pad_get_name(filter_ctx->filter->outputs, i),
 -                   av_get_pix_fmt_name(fmts->formats[j]));
 -    }
++        link->type = avfilter_pad_get_type(filter_ctx->output_pads, i);
+         filter_ctx->outputs[i] = link;
+     }
+     if (filter->query_formats)
+         filter->query_formats(filter_ctx);
+     else
+         ff_default_query_formats(filter_ctx);
++    print_formats(filter_ctx);
+ fail:
+     avfilter_free(filter_ctx);
+     avfilter_graph_free(&graph_ctx);
+     fflush(stdout);
+     return ret;
+ }
index 0000000,0000000..0e8ba4a
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,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 "libavfilter/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;
++}
@@@ -1564,30 -1223,7 +1572,19 @@@ static int mkv_write_header(AVFormatCon
              put_ebml_string(pb, MATROSKA_ID_WRITINGAPP, tag->value);
          else
              put_ebml_string(pb, MATROSKA_ID_WRITINGAPP, LIBAVFORMAT_IDENT);
-         if (mkv->mode != MODE_WEBM) {
-             uint32_t segment_uid[4];
-             AVLFG lfg;
-             av_lfg_init(&lfg, av_get_random_seed());
-             for (i = 0; i < 4; i++)
-                 segment_uid[i] = av_lfg_get(&lfg);
-             put_ebml_binary(pb, MATROSKA_ID_SEGMENTUID, segment_uid, 16);
-         }
+         put_ebml_binary(pb, MATROSKA_ID_SEGMENTUID, segment_uid, 16);
 +    } else {
 +        const char *ident = "Lavf";
 +        put_ebml_string(pb, MATROSKA_ID_MUXINGAPP , ident);
 +        put_ebml_string(pb, MATROSKA_ID_WRITINGAPP, ident);
 +    }
 +
 +    if (ff_parse_creation_time_metadata(s, &creation_time, 0) > 0) {
 +        // Adjust time so it's relative to 2001-01-01 and convert to nanoseconds.
 +        int64_t date_utc = (creation_time - 978307200000000LL) * 1000;
 +        uint8_t date_utc_buf[8];
 +        AV_WB64(date_utc_buf, date_utc);
 +        put_ebml_binary(pb, MATROSKA_ID_DATEUTC, date_utc_buf, 8);
      }
  
      // reserve space for the duration
index 0000000,cfd51f2..c8adb86
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,5 +1,6 @@@
+ /movenc
+ /noproxy
++/rtmpdh
+ /seek
+ /srtp
+ /url
index 0000000,711e157..786f1dc
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,672 +1,676 @@@
 - * This file is part of Libav.
+ /*
+  * Copyright (c) 2015 Martin Storsjo
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -const char *format = "mp4";
++ * 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 "libavutil/intreadwrite.h"
+ #include "libavutil/mathematics.h"
+ #include "libavutil/md5.h"
+ #include "libavformat/avformat.h"
+ #if HAVE_UNISTD_H
+ #include <unistd.h>
+ #endif
+ #if !HAVE_GETOPT
+ #include "compat/getopt.c"
+ #endif
+ #define HASH_SIZE 16
+ static const uint8_t h264_extradata[] = {
+     0x01, 0x4d, 0x40, 0x1e, 0xff, 0xe1, 0x00, 0x02, 0x67, 0x4d, 0x01, 0x00, 0x02, 0x68, 0xef
+ };
+ static const uint8_t aac_extradata[] = {
+     0x12, 0x10
+ };
 -        uint8_t pktdata[4];
++static const char *format = "mp4";
+ AVFormatContext *ctx;
+ uint8_t iobuf[32768];
+ AVDictionary *opts;
+ int write_file;
+ const char *cur_name;
+ FILE* out;
+ int out_size;
+ struct AVMD5* md5;
+ uint8_t hash[HASH_SIZE];
+ AVStream *video_st, *audio_st;
+ int64_t audio_dts, video_dts;
+ int bframes;
+ int64_t duration;
+ int64_t audio_duration;
+ int frames;
+ int gop_size;
+ int64_t next_p_pts;
+ enum AVPictureType last_picture;
+ int skip_write;
+ int skip_write_audio;
+ int clear_duration;
+ int num_warnings;
+ int check_faults;
+ static void count_warnings(void *avcl, int level, const char *fmt, va_list vl)
+ {
+     if (level == AV_LOG_WARNING)
+         num_warnings++;
+ }
+ static void init_count_warnings(void)
+ {
+     av_log_set_callback(count_warnings);
+     num_warnings = 0;
+ }
+ static void reset_count_warnings(void)
+ {
+     av_log_set_callback(av_log_default_callback);
+ }
+ static int io_write(void *opaque, uint8_t *buf, int size)
+ {
+     out_size += size;
+     av_md5_update(md5, buf, size);
+     if (out)
+         fwrite(buf, 1, size, out);
+     return size;
+ }
+ static void init_out(const char *name)
+ {
+     char buf[100];
+     cur_name = name;
+     snprintf(buf, sizeof(buf), "%s.%s", cur_name, format);
+     av_md5_init(md5);
+     if (write_file) {
+         out = fopen(buf, "wb");
+         if (!out)
+             perror(buf);
+     }
+     out_size = 0;
+ }
+ static void close_out(void)
+ {
+     int i;
+     av_md5_final(md5, hash);
+     for (i = 0; i < HASH_SIZE; i++)
+         printf("%02x", hash[i]);
+     printf(" %d %s\n", out_size, cur_name);
+     if (out)
+         fclose(out);
+     out = NULL;
+ }
+ static void check_func(int value, int line, const char *msg, ...)
+ {
+     if (!value) {
+         va_list ap;
+         va_start(ap, msg);
+         printf("%d: ", line);
+         vprintf(msg, ap);
+         printf("\n");
+         check_faults++;
+         va_end(ap);
+     }
+ }
+ #define check(value, ...) check_func(value, __LINE__, __VA_ARGS__)
+ static void init_fps(int bf, int audio_preroll, int fps)
+ {
+     AVStream *st;
+     ctx = avformat_alloc_context();
+     if (!ctx)
+         exit(1);
+     ctx->oformat = av_guess_format(format, NULL, NULL);
+     if (!ctx->oformat)
+         exit(1);
+     ctx->pb = avio_alloc_context(iobuf, sizeof(iobuf), AVIO_FLAG_WRITE, NULL, NULL, io_write, NULL);
+     if (!ctx->pb)
+         exit(1);
+     ctx->flags |= AVFMT_FLAG_BITEXACT;
+     st = avformat_new_stream(ctx, NULL);
+     if (!st)
+         exit(1);
+     st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
+     st->codecpar->codec_id = AV_CODEC_ID_H264;
+     st->codecpar->width = 640;
+     st->codecpar->height = 480;
+     st->time_base.num = 1;
+     st->time_base.den = 30;
+     st->codecpar->extradata_size = sizeof(h264_extradata);
+     st->codecpar->extradata = av_mallocz(st->codecpar->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
+     if (!st->codecpar->extradata)
+         exit(1);
+     memcpy(st->codecpar->extradata, h264_extradata, sizeof(h264_extradata));
+     video_st = st;
+     st = avformat_new_stream(ctx, NULL);
+     if (!st)
+         exit(1);
+     st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
+     st->codecpar->codec_id = AV_CODEC_ID_AAC;
+     st->codecpar->sample_rate = 44100;
+     st->codecpar->channels = 2;
+     st->time_base.num = 1;
+     st->time_base.den = 44100;
+     st->codecpar->extradata_size = sizeof(aac_extradata);
+     st->codecpar->extradata = av_mallocz(st->codecpar->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
+     if (!st->codecpar->extradata)
+         exit(1);
+     memcpy(st->codecpar->extradata, aac_extradata, sizeof(aac_extradata));
+     audio_st = st;
+     if (avformat_write_header(ctx, &opts) < 0)
+         exit(1);
+     av_dict_free(&opts);
+     frames = 0;
+     gop_size = 30;
+     duration = video_st->time_base.den / fps;
+     audio_duration = 1024LL * audio_st->time_base.den / audio_st->codecpar->sample_rate;
+     if (audio_preroll)
+         audio_preroll = 2048LL * audio_st->time_base.den / audio_st->codecpar->sample_rate;
+     bframes = bf;
+     video_dts = bframes ? -duration : 0;
+     audio_dts = -audio_preroll;
+ }
+ static void init(int bf, int audio_preroll)
+ {
+     init_fps(bf, audio_preroll, 30);
+ }
+ static void mux_frames(int n)
+ {
+     int end_frames = frames + n;
+     while (1) {
+         AVPacket pkt;
 -        AV_WB32(pktdata, pkt.pts);
++        uint8_t pktdata[8] = { 0 };
+         av_init_packet(&pkt);
+         if (av_compare_ts(audio_dts, audio_st->time_base, video_dts, video_st->time_base) < 0) {
+             pkt.dts = pkt.pts = audio_dts;
+             pkt.stream_index = 1;
+             pkt.duration = audio_duration;
+             audio_dts += audio_duration;
+         } else {
+             if (frames == end_frames)
+                 break;
+             pkt.dts = video_dts;
+             pkt.stream_index = 0;
+             pkt.duration = duration;
+             if ((frames % gop_size) == 0) {
+                 pkt.flags |= AV_PKT_FLAG_KEY;
+                 last_picture = AV_PICTURE_TYPE_I;
+                 pkt.pts = pkt.dts + duration;
+                 video_dts = pkt.pts;
+             } else {
+                 if (last_picture == AV_PICTURE_TYPE_P) {
+                     last_picture = AV_PICTURE_TYPE_B;
+                     pkt.pts = pkt.dts;
+                     video_dts = next_p_pts;
+                 } else {
+                     last_picture = AV_PICTURE_TYPE_P;
+                     if (((frames + 1) % gop_size) == 0) {
+                         pkt.pts = pkt.dts + duration;
+                         video_dts = pkt.pts;
+                     } else {
+                         next_p_pts = pkt.pts = pkt.dts + 2 * duration;
+                         video_dts += duration;
+                     }
+                 }
+             }
+             if (!bframes)
+                 pkt.pts = pkt.dts;
+             frames++;
+         }
+         if (clear_duration)
+             pkt.duration = 0;
 -        pkt.size = 4;
++        AV_WB32(pktdata + 4, pkt.pts);
+         pkt.data = pktdata;
++        pkt.size = 8;
+         if (skip_write)
+             continue;
+         if (skip_write_audio && pkt.stream_index == 1)
+             continue;
+         av_write_frame(ctx, &pkt);
+     }
+ }
+ static void mux_gops(int n)
+ {
+     mux_frames(gop_size * n);
+ }
+ static void skip_gops(int n)
+ {
+     skip_write = 1;
+     mux_gops(n);
+     skip_write = 0;
+ }
+ static void signal_init_ts(void)
+ {
+     AVPacket pkt;
+     av_init_packet(&pkt);
+     pkt.size = 0;
+     pkt.data = NULL;
+     pkt.stream_index = 0;
+     pkt.dts = video_dts;
+     pkt.pts = 0;
+     av_write_frame(ctx, &pkt);
+     pkt.stream_index = 1;
+     pkt.dts = pkt.pts = audio_dts;
+     av_write_frame(ctx, &pkt);
+ }
+ static void finish(void)
+ {
+     av_write_trailer(ctx);
+     av_free(ctx->pb);
+     avformat_free_context(ctx);
+     ctx = NULL;
+ }
+ static void help(void)
+ {
+     printf("movenc-test [-w]\n"
+            "-w          write output into files\n");
+ }
+ int main(int argc, char **argv)
+ {
+     int c;
+     uint8_t header[HASH_SIZE];
+     uint8_t content[HASH_SIZE];
+     int empty_moov_pos;
+     int prev_pos;
+     for (;;) {
+         c = getopt(argc, argv, "wh");
+         if (c == -1)
+             break;
+         switch (c) {
+         case 'w':
+             write_file = 1;
+             break;
+         default:
+         case 'h':
+             help();
+             return 0;
+         }
+     }
+     av_register_all();
+     md5 = av_md5_alloc();
+     if (!md5)
+         return 1;
+     // Write a fragmented file with an initial moov that actually contains some
+     // samples. One moov+mdat with 1 second of data and one moof+mdat with 1
+     // second of data.
+     init_out("non-empty-moov");
+     av_dict_set(&opts, "movflags", "frag_keyframe", 0);
+     init(0, 0);
+     mux_gops(2);
+     finish();
+     close_out();
+     // Write a similar file, but with B-frames and audio preroll, handled
+     // via an edit list.
+     init_out("non-empty-moov-elst");
+     av_dict_set(&opts, "movflags", "frag_keyframe", 0);
+     av_dict_set(&opts, "use_editlist", "1", 0);
+     init(1, 1);
+     mux_gops(2);
+     finish();
+     close_out();
+     // Use B-frames but no audio-preroll, but without an edit list.
+     // Due to avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO, the dts
+     // of the first audio packet is > 0, but it is set to zero since edit
+     // lists aren't used, increasing the duration of the first packet instead.
+     init_out("non-empty-moov-no-elst");
+     av_dict_set(&opts, "movflags", "frag_keyframe", 0);
+     av_dict_set(&opts, "use_editlist", "0", 0);
+     init(1, 0);
+     mux_gops(2);
+     finish();
+     close_out();
+     format = "ismv";
+     // Write an ISMV, with B-frames and audio preroll.
+     init_out("ismv");
+     av_dict_set(&opts, "movflags", "frag_keyframe", 0);
+     init(1, 1);
+     mux_gops(2);
+     finish();
+     close_out();
+     format = "mp4";
+     // An initial moov that doesn't contain any samples, followed by two
+     // moof+mdat pairs.
+     init_out("empty-moov");
+     av_dict_set(&opts, "movflags", "frag_keyframe+empty_moov", 0);
++    av_dict_set(&opts, "use_editlist", "0", 0);
+     init(0, 0);
+     mux_gops(2);
+     finish();
+     close_out();
+     memcpy(content, hash, HASH_SIZE);
+     // Similar to the previous one, but with input that doesn't start at
+     // pts/dts 0. avoid_negative_ts behaves in the same way as
+     // in non-empty-moov-no-elst above.
+     init_out("empty-moov-no-elst");
+     av_dict_set(&opts, "movflags", "frag_keyframe+empty_moov", 0);
+     init(1, 0);
+     mux_gops(2);
+     finish();
+     close_out();
+     // Same as the previous one, but disable avoid_negative_ts (which
+     // would require using an edit list, but with empty_moov, one can't
+     // write a sensible edit list, when the start timestamps aren't known).
+     // This should trigger a warning - we check that the warning is produced.
+     init_count_warnings();
+     init_out("empty-moov-no-elst-no-adjust");
+     av_dict_set(&opts, "movflags", "frag_keyframe+empty_moov", 0);
+     av_dict_set(&opts, "avoid_negative_ts", "0", 0);
+     init(1, 0);
+     mux_gops(2);
+     finish();
+     close_out();
+     reset_count_warnings();
+     check(num_warnings > 0, "No warnings printed for unhandled start offset");
+     // Verify that delay_moov produces the same as empty_moov for
+     // simple input
+     init_out("delay-moov");
+     av_dict_set(&opts, "movflags", "frag_keyframe+delay_moov", 0);
++    av_dict_set(&opts, "use_editlist", "0", 0);
+     init(0, 0);
+     mux_gops(2);
+     finish();
+     close_out();
+     check(!memcmp(hash, content, HASH_SIZE), "delay_moov differs from empty_moov");
+     // Test writing content that requires an edit list using delay_moov
+     init_out("delay-moov-elst");
+     av_dict_set(&opts, "movflags", "frag_keyframe+delay_moov", 0);
+     init(1, 1);
+     mux_gops(2);
+     finish();
+     close_out();
+     // Test writing a file with one track lacking packets, with delay_moov.
+     skip_write_audio = 1;
+     init_out("delay-moov-empty-track");
+     av_dict_set(&opts, "movflags", "frag_keyframe+delay_moov", 0);
+     init(0, 0);
+     mux_gops(2);
+     // The automatic flushing shouldn't output anything, since we're still
+     // waiting for data for some tracks
+     check(out_size == 0, "delay_moov flushed prematurely");
+     // When closed (or manually flushed), all the written data should still
+     // be output.
+     finish();
+     close_out();
+     check(out_size > 0, "delay_moov didn't output anything");
+     // Check that manually flushing still outputs things as expected. This
+     // produces two fragments, while the one above produces only one.
+     init_out("delay-moov-empty-track-flush");
+     av_dict_set(&opts, "movflags", "frag_custom+delay_moov", 0);
+     init(0, 0);
+     mux_gops(1);
+     av_write_frame(ctx, NULL); // Force writing the moov
+     check(out_size > 0, "No moov written");
+     av_write_frame(ctx, NULL);
+     mux_gops(1);
+     av_write_frame(ctx, NULL);
+     finish();
+     close_out();
+     skip_write_audio = 0;
+     // Verify that the header written by delay_moov when manually flushed
+     // is identical to the one by empty_moov.
+     init_out("empty-moov-header");
+     av_dict_set(&opts, "movflags", "frag_keyframe+empty_moov", 0);
++    av_dict_set(&opts, "use_editlist", "0", 0);
+     init(0, 0);
+     close_out();
+     memcpy(header, hash, HASH_SIZE);
+     init_out("empty-moov-content");
+     mux_gops(2);
+     // Written 2 seconds of content, with an automatic flush after 1 second.
+     check(out_size > 0, "No automatic flush?");
+     empty_moov_pos = prev_pos = out_size;
+     // Manually flush the second fragment
+     av_write_frame(ctx, NULL);
+     check(out_size > prev_pos, "No second fragment flushed?");
+     prev_pos = out_size;
+     // Check that an extra flush doesn't output any more data
+     av_write_frame(ctx, NULL);
+     check(out_size == prev_pos, "More data written?");
+     close_out();
+     memcpy(content, hash, HASH_SIZE);
+     // Ignore the trailer written here
+     finish();
+     init_out("delay-moov-header");
+     av_dict_set(&opts, "movflags", "frag_custom+delay_moov", 0);
++    av_dict_set(&opts, "use_editlist", "0", 0);
+     init(0, 0);
+     check(out_size == 0, "Output written during init with delay_moov");
+     mux_gops(1); // Write 1 second of content
+     av_write_frame(ctx, NULL); // Force writing the moov
+     close_out();
+     check(!memcmp(hash, header, HASH_SIZE), "delay_moov header differs from empty_moov");
+     init_out("delay-moov-content");
+     av_write_frame(ctx, NULL); // Flush the first fragment
+     check(out_size == empty_moov_pos, "Manually flushed content differs from automatically flushed, %d vs %d", out_size, empty_moov_pos);
+     mux_gops(1); // Write the rest of the content
+     av_write_frame(ctx, NULL); // Flush the second fragment
+     close_out();
+     check(!memcmp(hash, content, HASH_SIZE), "delay_moov content differs from empty_moov");
+     finish();
+     // Verify that we can produce an identical second fragment without
+     // writing the first one. First write the reference fragments that
+     // we want to reproduce.
+     av_dict_set(&opts, "movflags", "frag_custom+empty_moov+dash", 0);
+     init(0, 0);
+     mux_gops(1);
+     av_write_frame(ctx, NULL); // Output the first fragment
+     init_out("empty-moov-second-frag");
+     mux_gops(1);
+     av_write_frame(ctx, NULL); // Output the second fragment
+     close_out();
+     memcpy(content, hash, HASH_SIZE);
+     finish();
+     // Produce the same second fragment without actually writing the first
+     // one before.
+     av_dict_set(&opts, "movflags", "frag_custom+empty_moov+dash+frag_discont", 0);
+     av_dict_set(&opts, "fragment_index", "2", 0);
+     av_dict_set(&opts, "avoid_negative_ts", "0", 0);
+     av_dict_set(&opts, "use_editlist", "0", 0);
+     init(0, 0);
+     skip_gops(1);
+     init_out("empty-moov-second-frag-discont");
+     mux_gops(1);
+     av_write_frame(ctx, NULL); // Output the second fragment
+     close_out();
+     check(!memcmp(hash, content, HASH_SIZE), "discontinuously written fragment differs");
+     finish();
+     // Produce the same thing by using delay_moov, which requires a slightly
+     // different call sequence.
+     av_dict_set(&opts, "movflags", "frag_custom+delay_moov+dash+frag_discont", 0);
+     av_dict_set(&opts, "fragment_index", "2", 0);
+     init(0, 0);
+     skip_gops(1);
+     mux_gops(1);
+     av_write_frame(ctx, NULL); // Output the moov
+     init_out("delay-moov-second-frag-discont");
+     av_write_frame(ctx, NULL); // Output the second fragment
+     close_out();
+     check(!memcmp(hash, content, HASH_SIZE), "discontinuously written fragment differs");
+     finish();
+     // Test discontinuously written fragments with B-frames (where the
+     // assumption of starting at pts=0 works) but not with audio preroll
+     // (which can't be guessed).
+     av_dict_set(&opts, "movflags", "frag_custom+delay_moov+dash", 0);
+     init(1, 0);
+     mux_gops(1);
+     init_out("delay-moov-elst-init");
+     av_write_frame(ctx, NULL); // Output the moov
+     close_out();
+     memcpy(header, hash, HASH_SIZE);
+     av_write_frame(ctx, NULL); // Output the first fragment
+     init_out("delay-moov-elst-second-frag");
+     mux_gops(1);
+     av_write_frame(ctx, NULL); // Output the second fragment
+     close_out();
+     memcpy(content, hash, HASH_SIZE);
+     finish();
+     av_dict_set(&opts, "movflags", "frag_custom+delay_moov+dash+frag_discont", 0);
+     av_dict_set(&opts, "fragment_index", "2", 0);
+     init(1, 0);
+     skip_gops(1);
+     mux_gops(1); // Write the second fragment
+     init_out("delay-moov-elst-init-discont");
+     av_write_frame(ctx, NULL); // Output the moov
+     close_out();
+     check(!memcmp(hash, header, HASH_SIZE), "discontinuously written header differs");
+     init_out("delay-moov-elst-second-frag-discont");
+     av_write_frame(ctx, NULL); // Output the second fragment
+     close_out();
+     check(!memcmp(hash, content, HASH_SIZE), "discontinuously written fragment differs");
+     finish();
+     // Test discontinuously written fragments with B-frames and audio preroll,
+     // properly signaled.
+     av_dict_set(&opts, "movflags", "frag_custom+delay_moov+dash", 0);
+     init(1, 1);
+     mux_gops(1);
+     init_out("delay-moov-elst-signal-init");
+     av_write_frame(ctx, NULL); // Output the moov
+     close_out();
+     memcpy(header, hash, HASH_SIZE);
+     av_write_frame(ctx, NULL); // Output the first fragment
+     init_out("delay-moov-elst-signal-second-frag");
+     mux_gops(1);
+     av_write_frame(ctx, NULL); // Output the second fragment
+     close_out();
+     memcpy(content, hash, HASH_SIZE);
+     finish();
+     av_dict_set(&opts, "movflags", "frag_custom+delay_moov+dash+frag_discont", 0);
+     av_dict_set(&opts, "fragment_index", "2", 0);
+     init(1, 1);
+     signal_init_ts();
+     skip_gops(1);
+     mux_gops(1); // Write the second fragment
+     init_out("delay-moov-elst-signal-init-discont");
+     av_write_frame(ctx, NULL); // Output the moov
+     close_out();
+     check(!memcmp(hash, header, HASH_SIZE), "discontinuously written header differs");
+     init_out("delay-moov-elst-signal-second-frag-discont");
+     av_write_frame(ctx, NULL); // Output the second fragment
+     close_out();
+     check(!memcmp(hash, content, HASH_SIZE), "discontinuously written fragment differs");
+     finish();
+     // Test VFR content, with sidx atoms (which declare the pts duration
+     // of a fragment, forcing overriding the start pts of the next one).
+     // Here, the fragment duration in pts is significantly different from
+     // the duration in dts. The video stream starts at dts=-10,pts=0, and
+     // the second fragment starts at dts=155,pts=156. The trun duration sum
+     // of the first fragment is 165, which also is written as
+     // baseMediaDecodeTime in the tfdt in the second fragment. The sidx for
+     // the first fragment says earliest_presentation_time = 0 and
+     // subsegment_duration = 156, which also matches the sidx in the second
+     // fragment. For the audio stream, the pts and dts durations also don't
+     // match - the input stream starts at pts=-2048, but that part is excluded
+     // by the edit list.
+     init_out("vfr");
+     av_dict_set(&opts, "movflags", "frag_keyframe+delay_moov+dash", 0);
+     init_fps(1, 1, 3);
+     mux_frames(gop_size/2);
+     duration /= 10;
+     mux_frames(gop_size/2);
+     mux_gops(1);
+     finish();
+     close_out();
+     // Test VFR content, with cleared duration fields. In these cases,
+     // the muxer must guess the duration of the last packet of each
+     // fragment. As long as the framerate doesn't vary (too much) at the
+     // fragment edge, it works just fine. Additionally, when automatically
+     // cutting fragments, the muxer already know the timestamps of the next
+     // packet for one stream (in most cases the video stream), avoiding
+     // having to use guesses for that one.
+     init_count_warnings();
+     clear_duration = 1;
+     init_out("vfr-noduration");
+     av_dict_set(&opts, "movflags", "frag_keyframe+delay_moov+dash", 0);
+     init_fps(1, 1, 3);
+     mux_frames(gop_size/2);
+     duration /= 10;
+     mux_frames(gop_size/2);
+     mux_gops(1);
+     finish();
+     close_out();
+     clear_duration = 0;
+     reset_count_warnings();
+     check(num_warnings > 0, "No warnings printed for filled in durations");
+     av_free(md5);
+     return check_faults > 0 ? 1 : 0;
+ }
index 0000000,9daee05..782356c
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,43 +1,43 @@@
 - * This file is part of Libav.
+ /*
+  * Copyright (c) 2013 Martin Storsjo
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 "libavformat/network.h"
+ static void test(const char *pattern, const char *host)
+ {
+     int res = ff_http_match_no_proxy(pattern, host);
+     printf("The pattern \"%s\" %s the hostname %s\n",
+            pattern ? pattern : "(null)", res ? "matches" : "does not match",
+            host);
+ }
+ int main(void)
+ {
+     test(NULL, "domain.com");
+     test("example.com domain.com", "domain.com");
+     test("example.com other.com", "domain.com");
+     test("example.com,domain.com", "domain.com");
+     test("example.com,domain.com", "otherdomain.com");
+     test("example.com, *.domain.com", "sub.domain.com");
+     test("example.com, *.domain.com", "domain.com");
+     test("example.com, .domain.com", "domain.com");
+     test("*", "domain.com");
+     return 0;
+ }
index 0000000,c25ca91..929b3f3
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,158 +1,158 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 "libavformat/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;
+ }
index 0000000,82da374..7ed56ba
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,130 +1,161 @@@
 - * This file is part of Libav.
+ /*
+  * Copyright (c) 2003 Fabrice Bellard
+  * Copyright (c) 2007 Michael Niedermayer
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -    double tsval;
++ * 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 <stdlib.h>
+ #include <stdio.h>
+ #include <string.h>
+ #include "libavutil/common.h"
+ #include "libavutil/mathematics.h"
+ #include "libavformat/avformat.h"
+ static char buffer[20];
+ static const char *ret_str(int v)
+ {
+     switch (v) {
+     case AVERROR_EOF:     return "-EOF";
+     case AVERROR(EIO):    return "-EIO";
+     case AVERROR(ENOMEM): return "-ENOMEM";
+     case AVERROR(EINVAL): return "-EINVAL";
+     default:
+         snprintf(buffer, sizeof(buffer), "%2d", v);
+         return buffer;
+     }
+ }
+ static void ts_str(char buffer[60], int64_t ts, AVRational base)
+ {
 -    tsval = ts * av_q2d(base);
 -    snprintf(buffer, 60, "%9f", tsval);
+     if (ts == AV_NOPTS_VALUE) {
+         strcpy(buffer, " NOPTS   ");
+         return;
+     }
 -    AVFormatContext *ic = NULL;
++    ts= av_rescale_q(ts, base, (AVRational){1, 1000000});
++    snprintf(buffer, 60, "%c%"PRId64".%06"PRId64"", ts<0 ? '-' : ' ', FFABS(ts)/1000000, FFABS(ts)%1000000);
+ }
+ int main(int argc, char **argv)
+ {
+     const char *filename;
 -    if (argc != 2) {
++    AVFormatContext *ic = avformat_alloc_context();
+     int i, ret, stream_id;
++    int j;
+     int64_t timestamp;
+     AVDictionary *format_opts = NULL;
++    int64_t seekfirst = AV_NOPTS_VALUE;
++    int firstback=0;
++    int frame_count = 1;
++    int duration = 4;
++
++    for(i=2; i<argc; i+=2){
++        if       (!strcmp(argv[i], "-seekforw")){
++            seekfirst = atoi(argv[i+1]);
++        } else if(!strcmp(argv[i], "-seekback")){
++            seekfirst = atoi(argv[i+1]);
++            firstback = 1;
++        } else if(!strcmp(argv[i], "-frames")){
++            frame_count = atoi(argv[i+1]);
++        } else if(!strcmp(argv[i], "-duration")){
++            duration = atoi(argv[i+1]);
++        } else if(!strcmp(argv[i], "-fastseek")) {
++            if (atoi(argv[i+1])) {
++                ic->flags |= AVFMT_FLAG_FAST_SEEK;
++            }
++        } else if(argv[i][0] == '-' && argv[i+1]) {
++            av_dict_set(&format_opts, argv[i] + 1, argv[i+1], 0);
++        } else {
++            argc = 1;
++        }
++    }
+     av_dict_set(&format_opts, "channels", "1", 0);
+     av_dict_set(&format_opts, "sample_rate", "22050", 0);
+     /* initialize libavcodec, and register all codecs and formats */
+     av_register_all();
 -        timestamp= (i*19362894167LL) % (4*AV_TIME_BASE) - AV_TIME_BASE;
++    if (argc < 2) {
+         printf("usage: %s input_file\n"
+                "\n", argv[0]);
+         return 1;
+     }
+     filename = argv[1];
+     ret = avformat_open_input(&ic, filename, NULL, &format_opts);
+     av_dict_free(&format_opts);
+     if (ret < 0) {
+         fprintf(stderr, "cannot open %s\n", filename);
+         return 1;
+     }
+     ret = avformat_find_stream_info(ic, NULL);
+     if (ret < 0) {
+         fprintf(stderr, "%s: could not find codec parameters\n", filename);
+         return 1;
+     }
++    if(seekfirst != AV_NOPTS_VALUE){
++        if(firstback)   avformat_seek_file(ic, -1, INT64_MIN, seekfirst, seekfirst, 0);
++        else            avformat_seek_file(ic, -1, seekfirst, seekfirst, INT64_MAX, 0);
++    }
+     for(i=0; ; i++){
+         AVPacket pkt = { 0 };
+         AVStream *av_uninit(st);
+         char ts_buf[60];
+         if(ret>=0){
++            for(j=0; j<frame_count; j++) {
+             ret= av_read_frame(ic, &pkt);
+             if(ret>=0){
+                 char dts_buf[60];
+                 st= ic->streams[pkt.stream_index];
+                 ts_str(dts_buf, pkt.dts, st->time_base);
+                 ts_str(ts_buf,  pkt.pts, st->time_base);
+                 printf("ret:%-10s st:%2d flags:%d dts:%s pts:%s pos:%7" PRId64 " size:%6d", ret_str(ret), pkt.stream_index, pkt.flags, dts_buf, ts_buf, pkt.pos, pkt.size);
+                 av_packet_unref(&pkt);
+             } else
+                 printf("ret:%s", ret_str(ret)); // necessary to avoid trailing whitespace
+             printf("\n");
++            }
+         }
+         if(i>25) break;
+         stream_id= (i>>1)%(ic->nb_streams+1) - 1;
++        timestamp= (i*19362894167LL) % (duration*AV_TIME_BASE) - AV_TIME_BASE;
+         if(stream_id>=0){
+             st= ic->streams[stream_id];
+             timestamp= av_rescale_q(timestamp, AV_TIME_BASE_Q, st->time_base);
+         }
+         //FIXME fully test the new seek API
+         if(i&1) ret = avformat_seek_file(ic, stream_id, INT64_MIN, timestamp, timestamp, 0);
+         else    ret = avformat_seek_file(ic, stream_id, timestamp, timestamp, INT64_MAX, 0);
+         ts_str(ts_buf, timestamp, stream_id < 0 ? AV_TIME_BASE_Q : st->time_base);
+         printf("ret:%-10s st:%2d flags:%d  ts:%s\n", ret_str(ret), stream_id, i&1, ts_buf);
+     }
+     avformat_close_input(&ic);
+     return 0;
+ }
index 0000000,1703193..89450ce
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,167 +1,167 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 "libavformat/rtpdec.h"
+ #include "libavformat/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;
+ }
index 0000000,ec33173..1623179
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,55 +1,55 @@@
 - * This file is part of Libav.
+ /*
+  * Copyright (c) 2012 Martin Storsjo
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 "libavformat/url.h"
+ static void test(const char *base, const char *rel)
+ {
+     char buf[200], buf2[200];
+     ff_make_absolute_url(buf, sizeof(buf), base, rel);
+     printf("%s\n", buf);
+     if (base) {
+         /* Test in-buffer replacement */
+         snprintf(buf2, sizeof(buf2), "%s", base);
+         ff_make_absolute_url(buf2, sizeof(buf2), buf2, rel);
+         if (strcmp(buf, buf2)) {
+             printf("In-place handling of %s + %s failed\n", base, rel);
+             exit(1);
+         }
+     }
+ }
+ int main(void)
+ {
+     test(NULL, "baz");
+     test("/foo/bar", "baz");
+     test("/foo/bar", "../baz");
+     test("/foo/bar", "/baz");
+     test("http://server/foo/", "baz");
+     test("http://server/foo/bar", "baz");
+     test("http://server/foo/", "../baz");
+     test("http://server/foo/bar/123", "../../baz");
+     test("http://server/foo/bar/123", "/baz");
+     test("http://server/foo/bar/123", "https://other/url");
+     test("http://server/foo/bar?param=value/with/slashes", "/baz");
+     test("http://server/foo/bar?param&otherparam", "?someparam");
+     test("http://server/foo/bar", "//other/url");
+     return 0;
+ }
index 0000000,7759996..8c377ba
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,342 +1,342 @@@
 - * This file is part of Libav.
+ /*
+  * Copyright (c) 2002 Fabrice Bellard
+  * Copyright (c) 2012 Justin Ruggles <justin.ruggles@gmail.com>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 "libavutil/avstring.h"
+ #include "libavutil/common.h"
+ #include "libavutil/lfg.h"
+ #include "libavutil/libm.h"
+ #include "libavutil/log.h"
+ #include "libavutil/mem.h"
+ #include "libavutil/opt.h"
+ #include "libavutil/samplefmt.h"
+ #include "libavresample/avresample.h"
+ static double dbl_rand(AVLFG *lfg)
+ {
+     return 2.0 * (av_lfg_get(lfg) / (double)UINT_MAX) - 1.0;
+ }
+ #define PUT_FUNC(name, fmt, type, expr)                                     \
+ static void put_sample_ ## name(void **data, enum AVSampleFormat sample_fmt,\
+                                 int channels, int sample, int ch,           \
+                                 double v_dbl)                               \
+ {                                                                           \
+     type v = expr;                                                          \
+     type **out = (type **)data;                                             \
+     if (av_sample_fmt_is_planar(sample_fmt))                                \
+         out[ch][sample] = v;                                                \
+     else                                                                    \
+         out[0][sample * channels + ch] = v;                                 \
+ }
+ PUT_FUNC(u8,  AV_SAMPLE_FMT_U8,  uint8_t, av_clip_uint8 ( lrint(v_dbl * (1  <<  7)) + 128))
+ PUT_FUNC(s16, AV_SAMPLE_FMT_S16, int16_t, av_clip_int16 ( lrint(v_dbl * (1  << 15))))
+ PUT_FUNC(s32, AV_SAMPLE_FMT_S32, int32_t, av_clipl_int32(llrint(v_dbl * (1U << 31))))
+ PUT_FUNC(flt, AV_SAMPLE_FMT_FLT, float,   v_dbl)
+ PUT_FUNC(dbl, AV_SAMPLE_FMT_DBL, double,  v_dbl)
+ static void put_sample(void **data, enum AVSampleFormat sample_fmt,
+                        int channels, int sample, int ch, double v_dbl)
+ {
+     switch (av_get_packed_sample_fmt(sample_fmt)) {
+     case AV_SAMPLE_FMT_U8:
+         put_sample_u8(data, sample_fmt, channels, sample, ch, v_dbl);
+         break;
+     case AV_SAMPLE_FMT_S16:
+         put_sample_s16(data, sample_fmt, channels, sample, ch, v_dbl);
+         break;
+     case AV_SAMPLE_FMT_S32:
+         put_sample_s32(data, sample_fmt, channels, sample, ch, v_dbl);
+         break;
+     case AV_SAMPLE_FMT_FLT:
+         put_sample_flt(data, sample_fmt, channels, sample, ch, v_dbl);
+         break;
+     case AV_SAMPLE_FMT_DBL:
+         put_sample_dbl(data, sample_fmt, channels, sample, ch, v_dbl);
+         break;
+     }
+ }
+ static void audiogen(AVLFG *rnd, void **data, enum AVSampleFormat sample_fmt,
+                      int channels, int sample_rate, int nb_samples)
+ {
+     int i, ch, k;
+     double v, f, a, ampa;
+     double tabf1[AVRESAMPLE_MAX_CHANNELS];
+     double tabf2[AVRESAMPLE_MAX_CHANNELS];
+     double taba[AVRESAMPLE_MAX_CHANNELS];
+ #define PUT_SAMPLE put_sample(data, sample_fmt, channels, k, ch, v);
+     k = 0;
+     /* 1 second of single freq sine at 1000 Hz */
+     a = 0;
+     for (i = 0; i < 1 * sample_rate && k < nb_samples; i++, k++) {
+         v = sin(a) * 0.30;
+         for (ch = 0; ch < channels; ch++)
+             PUT_SAMPLE
+         a += M_PI * 1000.0 * 2.0 / sample_rate;
+     }
+     /* 1 second of varying frequency between 100 and 10000 Hz */
+     a = 0;
+     for (i = 0; i < 1 * sample_rate && k < nb_samples; i++, k++) {
+         v = sin(a) * 0.30;
+         for (ch = 0; ch < channels; ch++)
+             PUT_SAMPLE
+         f  = 100.0 + (((10000.0 - 100.0) * i) / sample_rate);
+         a += M_PI * f * 2.0 / sample_rate;
+     }
+     /* 0.5 second of low amplitude white noise */
+     for (i = 0; i < sample_rate / 2 && k < nb_samples; i++, k++) {
+         v = dbl_rand(rnd) * 0.30;
+         for (ch = 0; ch < channels; ch++)
+             PUT_SAMPLE
+     }
+     /* 0.5 second of high amplitude white noise */
+     for (i = 0; i < sample_rate / 2 && k < nb_samples; i++, k++) {
+         v = dbl_rand(rnd);
+         for (ch = 0; ch < channels; ch++)
+             PUT_SAMPLE
+     }
+     /* 1 second of unrelated ramps for each channel */
+     for (ch = 0; ch < channels; ch++) {
+         taba[ch]  = 0;
+         tabf1[ch] = 100 + av_lfg_get(rnd) % 5000;
+         tabf2[ch] = 100 + av_lfg_get(rnd) % 5000;
+     }
+     for (i = 0; i < 1 * sample_rate && k < nb_samples; i++, k++) {
+         for (ch = 0; ch < channels; ch++) {
+             v = sin(taba[ch]) * 0.30;
+             PUT_SAMPLE
+             f = tabf1[ch] + (((tabf2[ch] - tabf1[ch]) * i) / sample_rate);
+             taba[ch] += M_PI * f * 2.0 / sample_rate;
+         }
+     }
+     /* 2 seconds of 500 Hz with varying volume */
+     a    = 0;
+     ampa = 0;
+     for (i = 0; i < 2 * sample_rate && k < nb_samples; i++, k++) {
+         for (ch = 0; ch < channels; ch++) {
+             double amp = (1.0 + sin(ampa)) * 0.15;
+             if (ch & 1)
+                 amp = 0.30 - amp;
+             v = sin(a) * amp;
+             PUT_SAMPLE
+             a    += M_PI * 500.0 * 2.0 / sample_rate;
+             ampa += M_PI *  2.0 / sample_rate;
+         }
+     }
+ }
+ /* formats, rates, and layouts are ordered for priority in testing.
+    e.g. 'avresample-test 4 2 2' will test all input/output combinations of
+    S16/FLTP/S16P/FLT, 48000/44100, and stereo/mono */
+ static const enum AVSampleFormat formats[] = {
+     AV_SAMPLE_FMT_S16,
+     AV_SAMPLE_FMT_FLTP,
+     AV_SAMPLE_FMT_S16P,
+     AV_SAMPLE_FMT_FLT,
+     AV_SAMPLE_FMT_S32P,
+     AV_SAMPLE_FMT_S32,
+     AV_SAMPLE_FMT_U8P,
+     AV_SAMPLE_FMT_U8,
+     AV_SAMPLE_FMT_DBLP,
+     AV_SAMPLE_FMT_DBL,
+ };
+ static const int rates[] = {
+     48000,
+     44100,
+     16000
+ };
+ static const uint64_t layouts[] = {
+     AV_CH_LAYOUT_STEREO,
+     AV_CH_LAYOUT_MONO,
+     AV_CH_LAYOUT_5POINT1,
+     AV_CH_LAYOUT_7POINT1,
+ };
+ int main(int argc, char **argv)
+ {
+     AVAudioResampleContext *s;
+     AVLFG rnd;
+     int ret = 0;
+     uint8_t *in_buf = NULL;
+     uint8_t *out_buf = NULL;
+     unsigned int in_buf_size;
+     unsigned int out_buf_size;
+     uint8_t  *in_data[AVRESAMPLE_MAX_CHANNELS] = { 0 };
+     uint8_t *out_data[AVRESAMPLE_MAX_CHANNELS] = { 0 };
+     int in_linesize;
+     int out_linesize;
+     uint64_t in_ch_layout;
+     int in_channels;
+     enum AVSampleFormat in_fmt;
+     int in_rate;
+     uint64_t out_ch_layout;
+     int out_channels;
+     enum AVSampleFormat out_fmt;
+     int out_rate;
+     int num_formats, num_rates, num_layouts;
+     int i, j, k, l, m, n;
+     num_formats = 2;
+     num_rates   = 2;
+     num_layouts = 2;
+     if (argc > 1) {
+         if (!av_strncasecmp(argv[1], "-h", 3)) {
+             av_log(NULL, AV_LOG_INFO, "Usage: avresample-test [<num formats> "
+                    "[<num sample rates> [<num channel layouts>]]]\n"
+                    "Default is 2 2 2\n");
+             return 0;
+         }
+         num_formats = strtol(argv[1], NULL, 0);
+         num_formats = av_clip(num_formats, 1, FF_ARRAY_ELEMS(formats));
+     }
+     if (argc > 2) {
+         num_rates = strtol(argv[2], NULL, 0);
+         num_rates = av_clip(num_rates, 1, FF_ARRAY_ELEMS(rates));
+     }
+     if (argc > 3) {
+         num_layouts = strtol(argv[3], NULL, 0);
+         num_layouts = av_clip(num_layouts, 1, FF_ARRAY_ELEMS(layouts));
+     }
+     av_log_set_level(AV_LOG_DEBUG);
+     av_lfg_init(&rnd, 0xC0FFEE);
+     in_buf_size = av_samples_get_buffer_size(&in_linesize, 8, 48000 * 6,
+                                              AV_SAMPLE_FMT_DBLP, 0);
+     out_buf_size = in_buf_size;
+     in_buf = av_malloc(in_buf_size);
+     if (!in_buf)
+         goto end;
+     out_buf = av_malloc(out_buf_size);
+     if (!out_buf)
+         goto end;
+     s = avresample_alloc_context();
+     if (!s) {
+         av_log(NULL, AV_LOG_ERROR, "Error allocating AVAudioResampleContext\n");
+         ret = 1;
+         goto end;
+     }
+     for (i = 0; i < num_formats; i++) {
+         in_fmt = formats[i];
+         for (k = 0; k < num_layouts; k++) {
+             in_ch_layout = layouts[k];
+             in_channels  = av_get_channel_layout_nb_channels(in_ch_layout);
+             for (m = 0; m < num_rates; m++) {
+                 in_rate = rates[m];
+                 ret = av_samples_fill_arrays(in_data, &in_linesize, in_buf,
+                                              in_channels, in_rate * 6,
+                                              in_fmt, 0);
+                 if (ret < 0) {
+                     av_log(s, AV_LOG_ERROR, "failed in_data fill arrays\n");
+                     goto end;
+                 }
+                 audiogen(&rnd, (void **)in_data, in_fmt, in_channels, in_rate, in_rate * 6);
+                 for (j = 0; j < num_formats; j++) {
+                     out_fmt = formats[j];
+                     for (l = 0; l < num_layouts; l++) {
+                         out_ch_layout = layouts[l];
+                         out_channels  = av_get_channel_layout_nb_channels(out_ch_layout);
+                         for (n = 0; n < num_rates; n++) {
+                             out_rate = rates[n];
+                             av_log(NULL, AV_LOG_INFO, "%s to %s, %d to %d channels, %d Hz to %d Hz\n",
+                                    av_get_sample_fmt_name(in_fmt), av_get_sample_fmt_name(out_fmt),
+                                    in_channels, out_channels, in_rate, out_rate);
+                             ret = av_samples_fill_arrays(out_data, &out_linesize,
+                                                          out_buf, out_channels,
+                                                          out_rate * 6, out_fmt, 0);
+                             if (ret < 0) {
+                                 av_log(s, AV_LOG_ERROR, "failed out_data fill arrays\n");
+                                 goto end;
+                             }
+                             av_opt_set_int(s, "in_channel_layout",  in_ch_layout,  0);
+                             av_opt_set_int(s, "in_sample_fmt",      in_fmt,        0);
+                             av_opt_set_int(s, "in_sample_rate",     in_rate,       0);
+                             av_opt_set_int(s, "out_channel_layout", out_ch_layout, 0);
+                             av_opt_set_int(s, "out_sample_fmt",     out_fmt,       0);
+                             av_opt_set_int(s, "out_sample_rate",    out_rate,      0);
+                             av_opt_set_int(s, "internal_sample_fmt", AV_SAMPLE_FMT_FLTP, 0);
+                             ret = avresample_open(s);
+                             if (ret < 0) {
+                                 av_log(s, AV_LOG_ERROR, "Error opening context\n");
+                                 goto end;
+                             }
+                             ret = avresample_convert(s, out_data, out_linesize, out_rate * 6,
+                                                          in_data,  in_linesize,  in_rate * 6);
+                             if (ret < 0) {
+                                 char errbuf[256];
+                                 av_strerror(ret, errbuf, sizeof(errbuf));
+                                 av_log(NULL, AV_LOG_ERROR, "%s\n", errbuf);
+                                 goto end;
+                             }
+                             av_log(NULL, AV_LOG_INFO, "Converted %d samples to %d samples\n",
+                                    in_rate * 6, ret);
+                             if (avresample_get_delay(s) > 0)
+                                 av_log(NULL, AV_LOG_INFO, "%d delay samples not converted\n",
+                                        avresample_get_delay(s));
+                             if (avresample_available(s) > 0)
+                                 av_log(NULL, AV_LOG_INFO, "%d samples available for output\n",
+                                        avresample_available(s));
+                             av_log(NULL, AV_LOG_INFO, "\n");
+                             avresample_close(s);
+                         }
+                     }
+                 }
+             }
+         }
+     }
+     ret = 0;
+ end:
+     av_freep(&in_buf);
+     av_freep(&out_buf);
+     avresample_free(&s);
+     return ret;
+ }
@@@ -194,31 -136,9 +194,31 @@@ TESTPROGS = adler3
              hmac                                                        \
              lfg                                                         \
              lls                                                         \
 +            log                                                         \
              md5                                                         \
 +            murmur3                                                     \
              opt                                                         \
 +            pca                                                         \
              parseutils                                                  \
 +            pixdesc                                                     \
 +            pixelutils                                                  \
 +            random_seed                                                 \
 +            rational                                                    \
 +            ripemd                                                      \
              sha                                                         \
 +            sha512                                                      \
 +            softfloat                                                   \
              tree                                                        \
 +            twofish                                                     \
 +            utf8                                                        \
              xtea                                                        \
- $(SUBDIR)lzo-test$(EXESUF): ELIBS = -llzo2
 +            tea                                                         \
 +
 +TESTPROGS-$(HAVE_LZO1X_999_COMPRESS) += lzo
 +
 +TOOLS = crypto_bench ffhash ffeval ffescape
 +
 +tools/crypto_bench$(EXESUF): ELIBS += $(if $(VERSUS),$(subst +, -l,+$(VERSUS)),)
 +tools/crypto_bench$(EXESUF): CFLAGS += -DUSE_EXT_LIBS=0$(if $(VERSUS),$(subst +,+USE_,+$(VERSUS)),)
 +
++$(SUBDIR)tests/lzo$(EXESUF): ELIBS = -llzo2
diff --cc libavutil/des.c
Simple merge
index 0000000,c4d1d06..c23c44b
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,21 +1,44 @@@
+ /adler32
+ /aes
+ /atomic
+ /avstring
+ /base64
+ /blowfish
++/bprint
++/camellia
++/cast5
++/color_utils
+ /cpu
+ /crc
+ /des
++/dict
++/display
++/error
+ /eval
+ /fifo
++/file
+ /float_dsp
++/hash
+ /hmac
+ /lfg
+ /lls
++/log
++/lzo
+ /md5
++/murmur3
+ /opt
+ /parseutils
++/pca
++/pixdesc
++/pixelutils
++/random_seed
++/rational
++/ripemd
+ /sha
++/sha512
++/softfloat
++/tea
+ /tree
++/twofish
++/utf8
+ /xtea
index 0000000,3236900..511bf1e
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,51 +1,53 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -    char data[LEN];
++ * 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 "libavutil/log.h"
+ #include "libavutil/timer.h"
+ #include "libavutil/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
index 0000000,49ca553..1291ad6
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,92 +1,119 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -#include "libavutil/aes.c"
 -
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
 -    AVAES b;
++// LCOV_EXCL_START
+ #include <string.h>
++#include "libavutil/aes.h"
+ #include "libavutil/lfg.h"
+ #include "libavutil/log.h"
++#include "libavutil/mem.h"
+ int main(int argc, char **argv)
+ {
+     int i, j;
 -    uint8_t pt[16], temp[16];
++    struct AVAES *b;
+     static const uint8_t rkey[2][16] = {
+         { 0 },
+         { 0x10, 0xa5, 0x88, 0x69, 0xd7, 0x4b, 0xe5, 0xa3,
+           0x74, 0xcf, 0x86, 0x7c, 0xfb, 0x47, 0x38, 0x59 }
+     };
+     static const uint8_t rpt[2][16] = {
+         { 0x6a, 0x84, 0x86, 0x7c, 0xd7, 0x7e, 0x12, 0xad,
+           0x07, 0xea, 0x1b, 0xe8, 0x95, 0xc5, 0x3f, 0xa3 },
+         { 0 }
+     };
+     static const 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 }
+     };
 -        av_aes_init(&b, rkey[i], 128, 1);
 -        av_aes_crypt(&b, temp, rct[i], 1, NULL, 1);
++    uint8_t pt[32];
++    uint8_t temp[32];
++    uint8_t iv[2][16];
+     int err = 0;
++    b = av_aes_alloc();
++    if (!b)
++        return 1;
++
+     av_log_set_level(AV_LOG_DEBUG);
+     for (i = 0; i < 2; i++) {
 -        AVAES ae, ad;
++        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;
+             }
+         }
+     }
++    av_free(b);
+     if (argc > 1 && !strcmp(argv[1], "-t")) {
 -        av_aes_init(&ae, "PI=3.141592654..", 128, 0);
 -        av_aes_init(&ad, "PI=3.141592654..", 128, 1);
++        struct AVAES *ae, *ad;
+         AVLFG prng;
 -            for (j = 0; j < 16; j++)
++        ae = av_aes_alloc();
++        ad = av_aes_alloc();
++
++        if (!ae || !ad) {
++            av_free(ae);
++            av_free(ad);
++            return 1;
++        }
++
++        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++) {
 -                av_aes_crypt(&ae, temp, pt, 1, NULL, 0);
++            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(&ad, temp, temp, 1, NULL, 1);
++                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]);
+                 }
+             }
+         }
++        av_free(ae);
++        av_free(ad);
+     }
+     return err;
+ }
++// LCOV_EXCL_STOP
index 0000000,70636f4..c92f220
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,35 +1,34 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -#include <assert.h>
 -
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
 -    assert(res == 2);
+ #include "libavutil/atomic.h"
++#include "libavutil/avassert.h"
+ int main(void)
+ {
+     volatile int val = 1;
+     int res;
+     res = avpriv_atomic_int_add_and_fetch(&val, 1);
 -    assert(res == 3);
++    av_assert0(res == 2);
+     avpriv_atomic_int_set(&val, 3);
+     res = avpriv_atomic_int_get(&val);
++    av_assert0(res == 3);
+     return 0;
+ }
index 0000000,2e5ee2d..1242b3f
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,69 +1,83 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -    static const char *strings[] = {
++ * 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/mem.h"
+ #include "libavutil/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;
+ }
index 0000000,16ea399..88fd55c
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,84 +1,128 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -    if ((data2_size = av_base64_decode(data2, encoded, max_data2_size)) < 0) {
++ * 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 "libavutil/common.h"
+ #include "libavutil/base64.h"
++#include "libavutil/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;
+     }
 -int main(void)
++    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
index 0000000,acaab70..2c2e004
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,190 +1,190 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 "libavutil/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;
+ }
index 0000000,0000000..d7f381d
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,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 "libavutil/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;
++}
index 0000000,0000000..1716b59
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,75 @@@
++/*
++ * 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 "libavutil/camellia.h"
++#include "libavutil/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];
++    struct 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;
++}
index 0000000,0000000..ce3aa80
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,103 @@@
++/*
++ * 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 "libavutil/cast5.h"
++#include "libavutil/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];
++    struct 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;
++}
index 0000000,0000000..ea01271
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,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 "libavutil/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);
++          }
++      }
++  }
++
++}
index 0000000,176b7eb..f02a54c
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,136 +1,147 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -#elif !HAVE_GETOPT
++ * 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 "config.h"
++#include "libavutil/cpu.h"
++#include "libavutil/avstring.h"
++
+ #if HAVE_UNISTD_H
+ #include <unistd.h>
 -#include <stdint.h>
 -#include <stdio.h>
 -
 -#include "libavutil/avstring.h"
 -#include "libavutil/common.h"
 -#include "libavutil/cpu.h"
 -
++#endif
++#if !HAVE_GETOPT
+ #include "compat/getopt.c"
+ #endif
 -    { AV_CPU_FLAG_SSE2SLOW,  "sse2(slow)" },
+ 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_SSE3SLOW,  "sse3(slow)" },
++    { AV_CPU_FLAG_SSE2SLOW,  "sse2slow"   },
+     { AV_CPU_FLAG_SSE3,      "sse3"       },
 -    fprintf(stderr, "cpu_flags(%s) = 0x%08X\n", type, cpu_flags);
 -    fprintf(stderr, "cpu_flags_str(%s) =", type);
++    { 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;
 -            fprintf(stderr, " %s", cpu_flag_tab[i].name);
 -    fprintf(stderr, "\n");
++    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)
 -            int cpuflags = av_parse_cpu_flags(optarg);
 -            if (cpuflags < 0)
++            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':
+         {
 -            av_set_cpu_flags_mask(cpuflags);
++            unsigned flags = av_get_cpu_flags();
++            if (av_parse_cpu_caps(&flags, optarg) < 0)
+                 return 2;
 -    fprintf(stderr, "threads = %s (cpu_count = %d)\n", threads, cpu_count);
++
++            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;
+ }
index 0000000,c2c609f..9825d6b
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,45 +1,46 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -    static const int p[5][3] = {
++ * 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 "libavutil/crc.h"
+ int main(void)
+ {
+     uint8_t buf[1999];
+     int i;
 -        { AV_CRC_32_IEEE,    0x04C11DB7, 0xC0F5BAE0 },
 -        { AV_CRC_16_ANSI_LE,     0xA001,     0xBFD8 },
 -        { AV_CRC_16_ANSI,        0x8005,     0x1FBB },
 -        { AV_CRC_8_ATM,            0x07,       0xE3 }
++    static const unsigned p[6][3] = {
+         { AV_CRC_32_IEEE_LE, 0xEDB88320, 0x3D5CDD04 },
 -    for (i = 0; i < 5; i++) {
++        { 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;
+ }
index 0000000,1e7a2fa..ed04fad
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,128 +1,128 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -        av_des_init(&d, key, 192, 0);
 -        av_des_crypt(&d, &ct, &data, 1, NULL, 0);
 -        av_des_init(&d, key, 192, 1);
 -        av_des_crypt(&d, &ct, &ct, 1, NULL, 1);
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #include "libavutil/des.c"
+ #include <stdint.h>
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
+ #include "libavutil/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;
+ }
index 0000000,0000000..0039ba5
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,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 "libavutil/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;
++}
index 0000000,0000000..893ebb5
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,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 "libavutil/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;
++
++}
index 0000000,0000000..16efc8a
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,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 "libavutil/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;
++}
index 0000000,818c59c..2a1afcc
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,145 +1,183 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -        av_expr_parse_and_eval(&d, *expr,
++ * 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 "libavutil/libm.h"
+ #include "libavutil/timer.h"
+ #include "libavutil/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
+     };
++    int ret;
+     for (expr = exprs; *expr; expr++) {
+         printf("Evaluating '%s'\n", *expr);
 -    av_expr_parse_and_eval(&d, "1+(5-2)^(3-1)+1/2+sin(PI)-max(-2.2,-3.1)",
++        ret = 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);
++        if (ret < 0)
++            printf("av_expr_parse_and_eval failed\n");
+     }
 -    av_expr_parse_and_eval(&d, "80G/80Gi",
++    ret = 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, "1+(5-2)^(3-1)+1/2+sin(PI)-max(-2.2,-3.1)",
++    if (ret < 0)
++        printf("av_expr_parse_and_eval failed\n");
++    ret = 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 (ret < 0)
++        printf("av_expr_parse_and_eval failed\n");
+     if (argc > 1 && !strcmp(argv[1], "-t")) {
+         for (i = 0; i < 1050; i++) {
+             START_TIMER;
++            ret = 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);
++            if (ret < 0)
++                printf("av_expr_parse_and_eval failed\n");
+             STOP_TIMER("av_expr_parse_and_eval");
+         }
+     }
+     return 0;
+ }
index 0000000,4c4b37a..e4d7edf
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,51 +1,74 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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/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;
+ }
index 0000000,0000000..3608bcc
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,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 "libavutil/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;
++}
index 0000000,ab6bf6a..053324d
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,296 +1,333 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 <float.h>
++#include <math.h>
+ #include <stdint.h>
+ #include <stdlib.h>
+ #include <string.h>
 -    int ret = 0;
++#if HAVE_UNISTD_H
++#include <unistd.h> /* for getopt */
++#endif
++#if !HAVE_GETOPT
++#include "compat/getopt.c"
++#endif
++
++#include "libavutil/common.h"
+ #include "libavutil/cpu.h"
+ #include "libavutil/internal.h"
+ #include "libavutil/lfg.h"
+ #include "libavutil/log.h"
+ #include "libavutil/random_seed.h"
+ #include "libavutil/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)
+ {
 -    AVFloatDSPContext fdsp, cdsp;
++    int ret = 0, seeded = 0;
+     uint32_t seed;
 -    if (argc > 2 && !strcmp(argv[1], "-s"))
 -        seed = strtoul(argv[2], NULL, 10);
 -    else
++    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]);
 -    av_log(NULL, AV_LOG_INFO, "float_dsp-test: random seed %u\n", seed);
++    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();
 -    avpriv_float_dsp_init(&fdsp, 1);
 -    av_set_cpu_flags_mask(0);
 -    avpriv_float_dsp_init(&cdsp, 1);
 -
 -    if (test_vector_fmul(&fdsp, &cdsp, src0, src1))
++    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_fmac_scalar(&fdsp, &cdsp, src2, src0, src1[0]))
++    if (test_vector_fmul(fdsp, cdsp, src0, src1))
+         ret -= 1 << 0;
 -    if (test_vector_fmul_scalar(&fdsp, &cdsp, src0, src1[0]))
++    if (test_vector_fmac_scalar(fdsp, cdsp, src2, src0, src1[0]))
+         ret -= 1 << 1;
 -    if (test_vector_fmul_window(&fdsp, &cdsp, src0, src1, src2))
++    if (test_vector_fmul_scalar(fdsp, cdsp, src0, src1[0]))
+         ret -= 1 << 2;
 -    if (test_vector_fmul_add(&fdsp, &cdsp, src0, src1, src2))
++    if (test_vector_fmul_window(fdsp, cdsp, src0, src1, src2))
+         ret -= 1 << 3;
 -    if (test_vector_fmul_reverse(&fdsp, &cdsp, src0, src1))
++    if (test_vector_fmul_add(fdsp, cdsp, src0, src1, src2))
+         ret -= 1 << 4;
 -    if (test_butterflies_float(&fdsp, &cdsp, src0, src1))
++    if (test_vector_fmul_reverse(fdsp, cdsp, src0, src1))
+         ret -= 1 << 5;
 -    if (test_scalarproduct_float(&fdsp, &cdsp, src0, src1))
++    if (test_butterflies_float(fdsp, cdsp, src0, src1))
+         ret -= 1 << 6;
 -    if (test_vector_dmul_scalar(&fdsp, &cdsp, dbl_src0, dbl_src1[0]))
++    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;
+ }
index 0000000,0000000..4f2ad52
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,65 @@@
++/*
++ * 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 <stdio.h>
++#include <string.h>
++
++#include "libavutil/hash.h"
++
++#define SRC_BUF_SIZE 64
++#define DST_BUF_SIZE (AV_HASH_MAX_SIZE * 8)
++
++int main(void)
++{
++   struct AVHashContext *ctx = NULL;
++   int i, j, numhashes = 0;
++   static const uint8_t src[SRC_BUF_SIZE] = { 0 };
++   uint8_t dst[DST_BUF_SIZE];
++
++   while (av_hash_names(numhashes))
++       numhashes++;
++
++   for (i = 0; i < numhashes; 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;
++}
index 0000000,600240f..5eeb63c
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,92 +1,99 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -    enum AVHMACType i = AV_HMAC_SHA224;
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #include "libavutil/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];
 -                                   "than block-size data. The key needs to be hashed before being used"
 -                                   " by the HMAC algorithm.";
 -    AVHMAC *hmac = av_hmac_alloc(AV_HMAC_MD5);
 -    if (!hmac)
 -        return 1;
++    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 "
 -    // RFC 2202 test vectors
 -    test(hmac, key1, 16, data1, sizeof(data1));
 -    test(hmac, key2, sizeof(key2), data2, sizeof(data2));
 -    test(hmac, key3, 16, data3, sizeof(data3));
 -    test(hmac, key3, 80, data4, sizeof(data4));
 -    test(hmac, key3, 80, data5, sizeof(data5));
 -    av_hmac_free(hmac);
++                            "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));
 -    /* SHA-1 */
 -    hmac = av_hmac_alloc(AV_HMAC_SHA1);
 -    if (!hmac)
 -        return 1;
 -    // RFC 2202 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, 80, data4, sizeof(data4));
 -    test(hmac, key3, 80, data5, sizeof(data5));
 -    av_hmac_free(hmac);
 -    while (i <= AV_HMAC_SHA256) {
++    /* 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 */
 -        i++;
++    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;
+ }
index 0000000,9a0c47c..1425e02
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,56 +1,74 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -        for (i = 0; i < 624; i++)
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #include "libavutil/log.h"
+ #include "libavutil/timer.h"
+ #include "libavutil/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
 -                   bmg_out[0] * stddev + mean,
 -                   bmg_out[1] * stddev + mean);
++        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;
+ }
index 0000000,7866b38..965b0f4
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,54 +1,54 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 "libavutil/internal.h"
+ #include "libavutil/lfg.h"
+ #include "libavutil/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;
+ }
index 0000000,0000000..8fe9461
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,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 "libavutil/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;
++}
index 0000000,0000000..0147ab5
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,79 @@@
++/*
++ * Copyright (c) 2006 Reimar Doeffinger
++ *
++ * 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 <lzo/lzo1x.h>
++
++#include "libavutil/log.h"
++#include "libavutil/lzo.h"
++#include "libavutil/mem.h"
++
++#define MAXSZ (10*1024*1024)
++
++/* Define one of these to 1 if you wish to benchmark liblzo
++ * instead of our native implementation. */
++#define BENCHMARK_LIBLZO_SAFE   0
++#define BENCHMARK_LIBLZO_UNSAFE 0
++
++int main(int argc, char *argv[]) {
++    FILE *in = fopen(argv[1], "rb");
++    int comp_level = argc > 2 ? atoi(argv[2]) : 0;
++    uint8_t *orig = av_malloc(MAXSZ + 16);
++    uint8_t *comp = av_malloc(2*MAXSZ + 16);
++    uint8_t *decomp = av_malloc(MAXSZ + 16);
++    size_t s = fread(orig, 1, MAXSZ, in);
++    lzo_uint clen = 0;
++    long tmp[LZO1X_MEM_COMPRESS];
++    int inlen, outlen;
++    int i;
++    av_log_set_level(AV_LOG_DEBUG);
++    if (comp_level == 0) {
++        lzo1x_1_compress(orig, s, comp, &clen, tmp);
++    } else if (comp_level == 11) {
++        lzo1x_1_11_compress(orig, s, comp, &clen, tmp);
++    } else if (comp_level == 12) {
++        lzo1x_1_12_compress(orig, s, comp, &clen, tmp);
++    } else if (comp_level == 15) {
++        lzo1x_1_15_compress(orig, s, comp, &clen, tmp);
++    } else
++        lzo1x_999_compress(orig, s, comp, &clen, tmp);
++    for (i = 0; i < 300; i++) {
++START_TIMER
++        inlen = clen; outlen = MAXSZ;
++#if BENCHMARK_LIBLZO_SAFE
++        if (lzo1x_decompress_safe(comp, inlen, decomp, &outlen, NULL))
++#elif BENCHMARK_LIBLZO_UNSAFE
++        if (lzo1x_decompress(comp, inlen, decomp, &outlen, NULL))
++#else
++        if (av_lzo1x_decode(decomp, &outlen, comp, &inlen))
++#endif
++            av_log(NULL, AV_LOG_ERROR, "decompression error\n");
++STOP_TIMER("lzod")
++    }
++    if (memcmp(orig, decomp, s))
++        av_log(NULL, AV_LOG_ERROR, "decompression incorrect\n");
++    else
++        av_log(NULL, AV_LOG_ERROR, "decompression OK\n");
++    fclose(in);
++    av_free(orig);
++    av_free(comp);
++    av_free(decomp);
++    return 0;
++}
index 0000000,9fb7006..42e4538
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,54 +1,55 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -    uint8_t in[1000];
++ * 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 "libavutil/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;
+ }
index 0000000,0000000..b8d6b1f
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,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 "libavutil/intreadwrite.h"
++#include "libavutil/mem.h"
++#include "libavutil/murmur3.h"
++
++int main(void)
++{
++    int i;
++    uint8_t hash_result[16] = {0};
++    struct 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
++}
index 0000000,350ce3d..568eb45
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,110 +1,312 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -static const AVOption test_options[] = {
 -    { "num",      "set num",        OFFSET(num),      AV_OPT_TYPE_INT,      { .i64 = 0 },                    0,      100 },
 -    { "toggle",   "set toggle",     OFFSET(toggle),   AV_OPT_TYPE_INT,      { .i64 = 0 },                    0,        1 },
 -    { "rational", "set rational",   OFFSET(rational), AV_OPT_TYPE_RATIONAL, { .dbl = 0 },                    0,       10 },
 -    { "string",   "set string",     OFFSET(string),   AV_OPT_TYPE_STRING,   { 0 },                    CHAR_MIN, CHAR_MAX },
 -    { "flags",    "set flags",      OFFSET(flags),    AV_OPT_TYPE_FLAGS,    { .i64 = 0 },                    0,  INT_MAX, 0, "flags"},
 -    { "cool",     "set cool flag ", 0,                AV_OPT_TYPE_CONST,    { .i64 = TEST_FLAG_COOL }, INT_MIN,  INT_MAX, 0, "flags"},
 -    { "lame",     "set lame flag ", 0,                AV_OPT_TYPE_CONST,    { .i64 = TEST_FLAG_LAME }, INT_MIN,  INT_MAX, 0, "flags"},
 -    { "mu",       "set mu flag ",   0,                AV_OPT_TYPE_CONST,    { .i64 = TEST_FLAG_MU },   INT_MIN,  INT_MAX, 0, "flags"},
++ * 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 "libavutil/common.h"
++#include "libavutil/channel_layout.h"
+ #include "libavutil/error.h"
+ #include "libavutil/log.h"
+ #include "libavutil/mem.h"
+ #include "libavutil/rational.h"
+ #include "libavutil/opt.h"
++#include "libavutil/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
 -    TestContext test_ctx = { .class = &test_class };
 -    static const char *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",
 -    };
++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",