Attachment 154137 Details for Bug 223453 – /var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/temp/ccH88DAN.out

/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/temp/ccH88DAN.out

ccH88DAN.out (text/plain), 464.66 KB, created by Dan Johansson on 2008-05-24 14:45:51 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Dan Johansson

Created: 2008-05-24 14:45:51 UTC

Size: 464.66 KB

patch

obsolete

>// /usr/libexec/gcc/x86_64-pc-linux-gnu/3.4.6/cc1 -quiet -I/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg -I/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg -I/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil -I/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavcodec -I/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavformat -I/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libswscale -I/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libswscale -I/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavcodec -I/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg -I/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg -I/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil -D_REENTRANT -DBROKEN_RELOCATIONS -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_ISOC9X_SOURCE -DHAVE_AV_CONFIG_H -DHAVE_AV_CONFIG_H -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_ISOC9X_SOURCE -DBROKEN_RELOCATIONS -DPIC dsputil.c -quiet -dumpbase dsputil.c -march=k8 -march=k8 -auxbase-strip dsputil.o -O2 -O2 -Wdeclaration-after-statement -Wall -Wno-switch -Wdisabled-optimization -Wpointer-arith -Wredundant-decls -Wdeclaration-after-statement -Wall -Wno-switch -Wdisabled-optimization -Wpointer-arith -Wredundant-decls -fomit-frame-pointer -fomit-frame-pointer -fPIC -o - -frandom-seed=0
># 1 "dsputil.c"
># 1 "<built-in>"
># 1 "<command line>"
># 1 "dsputil.c"
># 30 "dsputil.c"
># 1 "avcodec.h" 1
># 30 "avcodec.h"
># 1 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/avutil.h" 1
># 40 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/avutil.h"
># 1 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/common.h" 1
># 29 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/common.h"
># 1 "/usr/include/inttypes.h" 1 3 4
># 26 "/usr/include/inttypes.h" 3 4
># 1 "/usr/include/features.h" 1 3 4
># 322 "/usr/include/features.h" 3 4
># 1 "/usr/include/sys/cdefs.h" 1 3 4
># 324 "/usr/include/sys/cdefs.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 325 "/usr/include/sys/cdefs.h" 2 3 4
># 323 "/usr/include/features.h" 2 3 4
># 345 "/usr/include/features.h" 3 4
># 1 "/usr/include/gnu/stubs.h" 1 3 4
>
>
>
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 5 "/usr/include/gnu/stubs.h" 2 3 4
>
>
>
>
># 1 "/usr/include/gnu/stubs-64.h" 1 3 4
># 10 "/usr/include/gnu/stubs.h" 2 3 4
># 346 "/usr/include/features.h" 2 3 4
># 27 "/usr/include/inttypes.h" 2 3 4
>
># 1 "/usr/include/stdint.h" 1 3 4
># 27 "/usr/include/stdint.h" 3 4
># 1 "/usr/include/bits/wchar.h" 1 3 4
># 28 "/usr/include/stdint.h" 2 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/stdint.h" 2 3 4
># 37 "/usr/include/stdint.h" 3 4
>typedef signed char int8_t;
>typedef short int int16_t;
>typedef int int32_t;
>
>typedef long int int64_t;
>
>
>
>
>
>
>
>typedef unsigned char uint8_t;
>typedef unsigned short int uint16_t;
>
>typedef unsigned int uint32_t;
>
>
>
>typedef unsigned long int uint64_t;
># 66 "/usr/include/stdint.h" 3 4
>typedef signed char int_least8_t;
>typedef short int int_least16_t;
>typedef int int_least32_t;
>
>typedef long int int_least64_t;
>
>
>
>
>
>
>typedef unsigned char uint_least8_t;
>typedef unsigned short int uint_least16_t;
>typedef unsigned int uint_least32_t;
>
>typedef unsigned long int uint_least64_t;
># 91 "/usr/include/stdint.h" 3 4
>typedef signed char int_fast8_t;
>
>typedef long int int_fast16_t;
>typedef long int int_fast32_t;
>typedef long int int_fast64_t;
># 104 "/usr/include/stdint.h" 3 4
>typedef unsigned char uint_fast8_t;
>
>typedef unsigned long int uint_fast16_t;
>typedef unsigned long int uint_fast32_t;
>typedef unsigned long int uint_fast64_t;
># 120 "/usr/include/stdint.h" 3 4
>typedef long int intptr_t;
>
>
>typedef unsigned long int uintptr_t;
># 135 "/usr/include/stdint.h" 3 4
>typedef long int intmax_t;
>typedef unsigned long int uintmax_t;
># 29 "/usr/include/inttypes.h" 2 3 4
>
>
>
>
>
>
>typedef int __gwchar_t;
># 274 "/usr/include/inttypes.h" 3 4
>
>
>
>
>
>typedef struct
>  {
>    long int quot;
>    long int rem;
>  } imaxdiv_t;
># 298 "/usr/include/inttypes.h" 3 4
>extern intmax_t imaxabs (intmax_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom)
>      __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern intmax_t strtoimax (__const char *__restrict __nptr,
>      char **__restrict __endptr, int __base) __attribute__ ((__nothrow__));
>
>
>extern uintmax_t strtoumax (__const char *__restrict __nptr,
>       char ** __restrict __endptr, int __base) __attribute__ ((__nothrow__));
>
>
>extern intmax_t wcstoimax (__const __gwchar_t *__restrict __nptr,
>      __gwchar_t **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__));
>
>
>extern uintmax_t wcstoumax (__const __gwchar_t *__restrict __nptr,
>       __gwchar_t ** __restrict __endptr, int __base)
>     __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>extern long int __strtol_internal (__const char *__restrict __nptr,
>       char **__restrict __endptr,
>       int __base, int __group) __attribute__ ((__nothrow__));
>
>
>extern __inline intmax_t
>__attribute__ ((__nothrow__)) strtoimax (__const char *__restrict nptr, char **__restrict endptr, int base)
>
>{
>  return __strtol_internal (nptr, endptr, base, 0);
>}
>
>
>
>extern unsigned long int __strtoul_internal (__const char *
>          __restrict __nptr,
>          char ** __restrict __endptr,
>          int __base, int __group) __attribute__ ((__nothrow__));
>
>
>extern __inline uintmax_t
>__attribute__ ((__nothrow__)) strtoumax (__const char *__restrict nptr, char **__restrict endptr, int base)
>
>{
>  return __strtoul_internal (nptr, endptr, base, 0);
>}
>
>
>
>extern long int __wcstol_internal (__const __gwchar_t * __restrict __nptr,
>       __gwchar_t **__restrict __endptr,
>       int __base, int __group) __attribute__ ((__nothrow__));
>
>
>extern __inline intmax_t
>__attribute__ ((__nothrow__)) wcstoimax (__const __gwchar_t *__restrict nptr, __gwchar_t **__restrict endptr, int base)
>
>{
>  return __wcstol_internal (nptr, endptr, base, 0);
>}
>
>
>
>
>extern unsigned long int __wcstoul_internal (__const __gwchar_t *
>          __restrict __nptr,
>          __gwchar_t **
>          __restrict __endptr,
>          int __base, int __group) __attribute__ ((__nothrow__));
>
>
>extern __inline uintmax_t
>__attribute__ ((__nothrow__)) wcstoumax (__const __gwchar_t *__restrict nptr, __gwchar_t **__restrict endptr, int base)
>
>{
>  return __wcstoul_internal (nptr, endptr, base, 0);
>}
># 459 "/usr/include/inttypes.h" 3 4
>
># 30 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/common.h" 2
>
>
>
># 1 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/config.h" 1
># 34 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/common.h" 2
>
># 1 "/usr/include/stdlib.h" 1 3 4
># 33 "/usr/include/stdlib.h" 3 4
># 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/stddef.h" 1 3 4
># 213 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/stddef.h" 3 4
>typedef long unsigned int size_t;
># 325 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/stddef.h" 3 4
>typedef int wchar_t;
># 34 "/usr/include/stdlib.h" 2 3 4
>
>
># 96 "/usr/include/stdlib.h" 3 4
>
>
>typedef struct
>  {
>    int quot;
>    int rem;
>  } div_t;
>
>
>
>typedef struct
>  {
>    long int quot;
>    long int rem;
>  } ldiv_t;
>
>
>
>
>
>
>
>__extension__ typedef struct
>  {
>    long long int quot;
>    long long int rem;
>  } lldiv_t;
>
>
># 140 "/usr/include/stdlib.h" 3 4
>extern size_t __ctype_get_mb_cur_max (void) __attribute__ ((__nothrow__)) ;
>
>
>
>
>extern double atof (__const char *__nptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern int atoi (__const char *__nptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern long int atol (__const char *__nptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>__extension__ extern long long int atoll (__const char *__nptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern double strtod (__const char *__restrict __nptr,
>        char **__restrict __endptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern float strtof (__const char *__restrict __nptr,
>       char **__restrict __endptr) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern long double strtold (__const char *__restrict __nptr,
>       char **__restrict __endptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern long int strtol (__const char *__restrict __nptr,
>   char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern unsigned long int strtoul (__const char *__restrict __nptr,
>      char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>__extension__
>extern long long int strtoq (__const char *__restrict __nptr,
>        char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>__extension__
>extern unsigned long long int strtouq (__const char *__restrict __nptr,
>           char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>__extension__
>extern long long int strtoll (__const char *__restrict __nptr,
>         char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>__extension__
>extern unsigned long long int strtoull (__const char *__restrict __nptr,
>     char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
># 279 "/usr/include/stdlib.h" 3 4
>extern double __strtod_internal (__const char *__restrict __nptr,
>     char **__restrict __endptr, int __group)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>extern float __strtof_internal (__const char *__restrict __nptr,
>    char **__restrict __endptr, int __group)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>extern long double __strtold_internal (__const char *__restrict __nptr,
>           char **__restrict __endptr,
>           int __group)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
># 305 "/usr/include/stdlib.h" 3 4
>__extension__
>extern long long int __strtoll_internal (__const char *__restrict __nptr,
>      char **__restrict __endptr,
>      int __base, int __group)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>__extension__
>extern unsigned long long int __strtoull_internal (__const char *
>         __restrict __nptr,
>         char **__restrict __endptr,
>         int __base, int __group)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>
>
>
>extern __inline double
>__attribute__ ((__nothrow__)) strtod (__const char *__restrict __nptr, char **__restrict __endptr)
>{
>  return __strtod_internal (__nptr, __endptr, 0);
>}
>extern __inline long int
>__attribute__ ((__nothrow__)) strtol (__const char *__restrict __nptr, char **__restrict __endptr, int __base)
>
>{
>  return __strtol_internal (__nptr, __endptr, __base, 0);
>}
>extern __inline unsigned long int
>__attribute__ ((__nothrow__)) strtoul (__const char *__restrict __nptr, char **__restrict __endptr, int __base)
>
>{
>  return __strtoul_internal (__nptr, __endptr, __base, 0);
>}
>
>
>
>
>extern __inline float
>__attribute__ ((__nothrow__)) strtof (__const char *__restrict __nptr, char **__restrict __endptr)
>{
>  return __strtof_internal (__nptr, __endptr, 0);
>}
>
>extern __inline long double
>__attribute__ ((__nothrow__)) strtold (__const char *__restrict __nptr, char **__restrict __endptr)
>{
>  return __strtold_internal (__nptr, __endptr, 0);
>}
>
>
>
>
>
>__extension__ extern __inline long long int
>__attribute__ ((__nothrow__)) strtoq (__const char *__restrict __nptr, char **__restrict __endptr, int __base)
>
>{
>  return __strtoll_internal (__nptr, __endptr, __base, 0);
>}
>__extension__ extern __inline unsigned long long int
>__attribute__ ((__nothrow__)) strtouq (__const char *__restrict __nptr, char **__restrict __endptr, int __base)
>
>{
>  return __strtoull_internal (__nptr, __endptr, __base, 0);
>}
>
>
>
>
>__extension__ extern __inline long long int
>__attribute__ ((__nothrow__)) strtoll (__const char *__restrict __nptr, char **__restrict __endptr, int __base)
>
>{
>  return __strtoll_internal (__nptr, __endptr, __base, 0);
>}
>__extension__ extern __inline unsigned long long int
>__attribute__ ((__nothrow__)) strtoull (__const char * __restrict __nptr, char **__restrict __endptr, int __base)
>
>{
>  return __strtoull_internal (__nptr, __endptr, __base, 0);
>}
>
>
>
>
>extern __inline double
>__attribute__ ((__nothrow__)) atof (__const char *__nptr)
>{
>  return strtod (__nptr, (char **) ((void *)0));
>}
>extern __inline int
>__attribute__ ((__nothrow__)) atoi (__const char *__nptr)
>{
>  return (int) strtol (__nptr, (char **) ((void *)0), 10);
>}
>extern __inline long int
>__attribute__ ((__nothrow__)) atol (__const char *__nptr)
>{
>  return strtol (__nptr, (char **) ((void *)0), 10);
>}
>
>
>
>
>__extension__ extern __inline long long int
>__attribute__ ((__nothrow__)) atoll (__const char *__nptr)
>{
>  return strtoll (__nptr, (char **) ((void *)0), 10);
>}
>
># 429 "/usr/include/stdlib.h" 3 4
>extern char *l64a (long int __n) __attribute__ ((__nothrow__)) ;
>
>
>extern long int a64l (__const char *__s)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
># 1 "/usr/include/sys/types.h" 1 3 4
># 29 "/usr/include/sys/types.h" 3 4
>
>
># 1 "/usr/include/bits/types.h" 1 3 4
># 28 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/bits/types.h" 2 3 4
>
>
># 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/stddef.h" 1 3 4
># 32 "/usr/include/bits/types.h" 2 3 4
>
>
>typedef unsigned char __u_char;
>typedef unsigned short int __u_short;
>typedef unsigned int __u_int;
>typedef unsigned long int __u_long;
>
>
>typedef signed char __int8_t;
>typedef unsigned char __uint8_t;
>typedef signed short int __int16_t;
>typedef unsigned short int __uint16_t;
>typedef signed int __int32_t;
>typedef unsigned int __uint32_t;
>
>typedef signed long int __int64_t;
>typedef unsigned long int __uint64_t;
>
>
>
>
>
>
>
>typedef long int __quad_t;
>typedef unsigned long int __u_quad_t;
># 134 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/typesizes.h" 1 3 4
># 135 "/usr/include/bits/types.h" 2 3 4
>
>
>typedef unsigned long int __dev_t;
>typedef unsigned int __uid_t;
>typedef unsigned int __gid_t;
>typedef unsigned long int __ino_t;
>typedef unsigned long int __ino64_t;
>typedef unsigned int __mode_t;
>typedef unsigned long int __nlink_t;
>typedef long int __off_t;
>typedef long int __off64_t;
>typedef int __pid_t;
>typedef struct { int __val[2]; } __fsid_t;
>typedef long int __clock_t;
>typedef unsigned long int __rlim_t;
>typedef unsigned long int __rlim64_t;
>typedef unsigned int __id_t;
>typedef long int __time_t;
>typedef unsigned int __useconds_t;
>typedef long int __suseconds_t;
>
>typedef int __daddr_t;
>typedef long int __swblk_t;
>typedef int __key_t;
>
>
>typedef int __clockid_t;
>
>
>typedef void * __timer_t;
>
>
>typedef long int __blksize_t;
>
>
>
>
>typedef long int __blkcnt_t;
>typedef long int __blkcnt64_t;
>
>
>typedef unsigned long int __fsblkcnt_t;
>typedef unsigned long int __fsblkcnt64_t;
>
>
>typedef unsigned long int __fsfilcnt_t;
>typedef unsigned long int __fsfilcnt64_t;
>
>typedef long int __ssize_t;
>
>
>
>typedef __off64_t __loff_t;
>typedef __quad_t *__qaddr_t;
>typedef char *__caddr_t;
>
>
>typedef long int __intptr_t;
>
>
>typedef unsigned int __socklen_t;
># 32 "/usr/include/sys/types.h" 2 3 4
>
>
>
>typedef __u_char u_char;
>typedef __u_short u_short;
>typedef __u_int u_int;
>typedef __u_long u_long;
>typedef __quad_t quad_t;
>typedef __u_quad_t u_quad_t;
>typedef __fsid_t fsid_t;
>
>
>
>
>typedef __loff_t loff_t;
>
>
>
>
>
>typedef __ino64_t ino_t;
># 62 "/usr/include/sys/types.h" 3 4
>typedef __dev_t dev_t;
>
>
>
>
>typedef __gid_t gid_t;
>
>
>
>
>typedef __mode_t mode_t;
>
>
>
>
>typedef __nlink_t nlink_t;
>
>
>
>
>typedef __uid_t uid_t;
>
>
>
>
>
>
>
>typedef __off64_t off_t;
># 100 "/usr/include/sys/types.h" 3 4
>typedef __pid_t pid_t;
>
>
>
>
>typedef __id_t id_t;
>
>
>
>
>typedef __ssize_t ssize_t;
>
>
>
>
>
>typedef __daddr_t daddr_t;
>typedef __caddr_t caddr_t;
>
>
>
>
>
>typedef __key_t key_t;
># 133 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/time.h" 1 3 4
># 75 "/usr/include/time.h" 3 4
>
>
>typedef __time_t time_t;
>
>
>
># 93 "/usr/include/time.h" 3 4
>typedef __clockid_t clockid_t;
># 105 "/usr/include/time.h" 3 4
>typedef __timer_t timer_t;
># 134 "/usr/include/sys/types.h" 2 3 4
># 147 "/usr/include/sys/types.h" 3 4
># 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/stddef.h" 1 3 4
># 148 "/usr/include/sys/types.h" 2 3 4
>
>
>
>typedef unsigned long int ulong;
>typedef unsigned short int ushort;
>typedef unsigned int uint;
># 201 "/usr/include/sys/types.h" 3 4
>typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
>typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
>typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
>typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
>
>typedef int register_t __attribute__ ((__mode__ (__word__)));
># 217 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/endian.h" 1 3 4
># 37 "/usr/include/endian.h" 3 4
># 1 "/usr/include/bits/endian.h" 1 3 4
># 38 "/usr/include/endian.h" 2 3 4
># 218 "/usr/include/sys/types.h" 2 3 4
>
>
># 1 "/usr/include/sys/select.h" 1 3 4
># 31 "/usr/include/sys/select.h" 3 4
># 1 "/usr/include/bits/select.h" 1 3 4
># 32 "/usr/include/sys/select.h" 2 3 4
>
>
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 24 "/usr/include/bits/sigset.h" 3 4
>typedef int __sig_atomic_t;
>
>
>
>
>typedef struct
>  {
>    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
>  } __sigset_t;
># 35 "/usr/include/sys/select.h" 2 3 4
>
>
>
>typedef __sigset_t sigset_t;
>
>
>
>
>
># 1 "/usr/include/time.h" 1 3 4
># 121 "/usr/include/time.h" 3 4
>struct timespec
>  {
>    __time_t tv_sec;
>    long int tv_nsec;
>  };
># 45 "/usr/include/sys/select.h" 2 3 4
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 69 "/usr/include/bits/time.h" 3 4
>struct timeval
>  {
>    __time_t tv_sec;
>    __suseconds_t tv_usec;
>  };
># 47 "/usr/include/sys/select.h" 2 3 4
>
>
>typedef __suseconds_t suseconds_t;
>
>
>
>
>
>typedef long int __fd_mask;
># 67 "/usr/include/sys/select.h" 3 4
>typedef struct
>  {
>
>
>
>
>
>
>    __fd_mask __fds_bits[1024 / (8 * sizeof (__fd_mask))];
>
>
>  } fd_set;
>
>
>
>
>
>
>typedef __fd_mask fd_mask;
># 99 "/usr/include/sys/select.h" 3 4
>
># 109 "/usr/include/sys/select.h" 3 4
>extern int select (int __nfds, fd_set *__restrict __readfds,
>     fd_set *__restrict __writefds,
>     fd_set *__restrict __exceptfds,
>     struct timeval *__restrict __timeout);
># 121 "/usr/include/sys/select.h" 3 4
>extern int pselect (int __nfds, fd_set *__restrict __readfds,
>      fd_set *__restrict __writefds,
>      fd_set *__restrict __exceptfds,
>      const struct timespec *__restrict __timeout,
>      const __sigset_t *__restrict __sigmask);
>
>
>
># 221 "/usr/include/sys/types.h" 2 3 4
>
>
># 1 "/usr/include/sys/sysmacros.h" 1 3 4
># 30 "/usr/include/sys/sysmacros.h" 3 4
>__extension__
>extern __inline unsigned int gnu_dev_major (unsigned long long int __dev)
>     __attribute__ ((__nothrow__));
>__extension__
>extern __inline unsigned int gnu_dev_minor (unsigned long long int __dev)
>     __attribute__ ((__nothrow__));
>__extension__
>extern __inline unsigned long long int gnu_dev_makedev (unsigned int __major,
>       unsigned int __minor)
>     __attribute__ ((__nothrow__));
>
>
>__extension__ extern __inline unsigned int
>__attribute__ ((__nothrow__)) gnu_dev_major (unsigned long long int __dev)
>{
>  return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff);
>}
>
>__extension__ extern __inline unsigned int
>__attribute__ ((__nothrow__)) gnu_dev_minor (unsigned long long int __dev)
>{
>  return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff);
>}
>
>__extension__ extern __inline unsigned long long int
>__attribute__ ((__nothrow__)) gnu_dev_makedev (unsigned int __major, unsigned int __minor)
>{
>  return ((__minor & 0xff) | ((__major & 0xfff) << 8)
>   | (((unsigned long long int) (__minor & ~0xff)) << 12)
>   | (((unsigned long long int) (__major & ~0xfff)) << 32));
>}
># 224 "/usr/include/sys/types.h" 2 3 4
># 248 "/usr/include/sys/types.h" 3 4
>typedef __blkcnt64_t blkcnt_t;
>
>
>
>typedef __fsblkcnt64_t fsblkcnt_t;
>
>
>
>typedef __fsfilcnt64_t fsfilcnt_t;
># 270 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
># 23 "/usr/include/bits/pthreadtypes.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 24 "/usr/include/bits/pthreadtypes.h" 2 3 4
># 50 "/usr/include/bits/pthreadtypes.h" 3 4
>typedef unsigned long int pthread_t;
>
>
>typedef union
>{
>  char __size[56];
>  long int __align;
>} pthread_attr_t;
>
>
>
>typedef struct __pthread_internal_list
>{
>  struct __pthread_internal_list *__prev;
>  struct __pthread_internal_list *__next;
>} __pthread_list_t;
># 76 "/usr/include/bits/pthreadtypes.h" 3 4
>typedef union
>{
>  struct __pthread_mutex_s
>  {
>    int __lock;
>    unsigned int __count;
>    int __owner;
>
>    unsigned int __nusers;
>
>
>
>    int __kind;
>
>    int __spins;
>    __pthread_list_t __list;
># 101 "/usr/include/bits/pthreadtypes.h" 3 4
>  } __data;
>  char __size[40];
>  long int __align;
>} pthread_mutex_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_mutexattr_t;
>
>
>
>
>typedef union
>{
>  struct
>  {
>    int __lock;
>    unsigned int __futex;
>    __extension__ unsigned long long int __total_seq;
>    __extension__ unsigned long long int __wakeup_seq;
>    __extension__ unsigned long long int __woken_seq;
>    void *__mutex;
>    unsigned int __nwaiters;
>    unsigned int __broadcast_seq;
>  } __data;
>  char __size[48];
>  __extension__ long long int __align;
>} pthread_cond_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_condattr_t;
>
>
>
>typedef unsigned int pthread_key_t;
>
>
>
>typedef int pthread_once_t;
>
>
>
>
>
>typedef union
>{
>
>  struct
>  {
>    int __lock;
>    unsigned int __nr_readers;
>    unsigned int __readers_wakeup;
>    unsigned int __writer_wakeup;
>    unsigned int __nr_readers_queued;
>    unsigned int __nr_writers_queued;
>    int __writer;
>    int __pad1;
>    unsigned long int __pad2;
>    unsigned long int __pad3;
>
>
>    unsigned int __flags;
>  } __data;
># 184 "/usr/include/bits/pthreadtypes.h" 3 4
>  char __size[56];
>  long int __align;
>} pthread_rwlock_t;
>
>typedef union
>{
>  char __size[8];
>  long int __align;
>} pthread_rwlockattr_t;
>
>
>
>
>
>typedef volatile int pthread_spinlock_t;
>
>
>
>
>typedef union
>{
>  char __size[32];
>  long int __align;
>} pthread_barrier_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_barrierattr_t;
># 271 "/usr/include/sys/types.h" 2 3 4
>
>
>
># 439 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>
>
>extern long int random (void) __attribute__ ((__nothrow__));
>
>
>extern void srandom (unsigned int __seed) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern char *initstate (unsigned int __seed, char *__statebuf,
>   size_t __statelen) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>extern char *setstate (char *__statebuf) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>struct random_data
>  {
>    int32_t *fptr;
>    int32_t *rptr;
>    int32_t *state;
>    int rand_type;
>    int rand_deg;
>    int rand_sep;
>    int32_t *end_ptr;
>  };
>
>extern int random_r (struct random_data *__restrict __buf,
>       int32_t *__restrict __result) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int srandom_r (unsigned int __seed, struct random_data *__buf)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
>   size_t __statelen,
>   struct random_data *__restrict __buf)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 4)));
>
>extern int setstate_r (char *__restrict __statebuf,
>         struct random_data *__restrict __buf)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern int rand (void) __attribute__ ((__nothrow__));
>
>extern void srand (unsigned int __seed) __attribute__ ((__nothrow__));
>
>
>
>
>extern int rand_r (unsigned int *__seed) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>extern double drand48 (void) __attribute__ ((__nothrow__));
>extern double erand48 (unsigned short int __xsubi[3]) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern long int lrand48 (void) __attribute__ ((__nothrow__));
>extern long int nrand48 (unsigned short int __xsubi[3])
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern long int mrand48 (void) __attribute__ ((__nothrow__));
>extern long int jrand48 (unsigned short int __xsubi[3])
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern void srand48 (long int __seedval) __attribute__ ((__nothrow__));
>extern unsigned short int *seed48 (unsigned short int __seed16v[3])
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>extern void lcong48 (unsigned short int __param[7]) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>struct drand48_data
>  {
>    unsigned short int __x[3];
>    unsigned short int __old_x[3];
>    unsigned short int __c;
>    unsigned short int __init;
>    unsigned long long int __a;
>  };
>
>
>extern int drand48_r (struct drand48_data *__restrict __buffer,
>        double *__restrict __result) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int erand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        double *__restrict __result) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int lrand48_r (struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int nrand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int mrand48_r (struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int jrand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>extern int seed48_r (unsigned short int __seed16v[3],
>       struct drand48_data *__buffer) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int lcong48_r (unsigned short int __param[7],
>        struct drand48_data *__buffer)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>
>
>
>extern void *malloc (size_t __size) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) ;
>
>extern void *calloc (size_t __nmemb, size_t __size)
>     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) ;
>
>
>
>
>
>
>
>extern void *realloc (void *__ptr, size_t __size)
>     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>extern void free (void *__ptr) __attribute__ ((__nothrow__));
>
>
>
>
>extern void cfree (void *__ptr) __attribute__ ((__nothrow__));
>
>
>
># 1 "/usr/include/alloca.h" 1 3 4
># 25 "/usr/include/alloca.h" 3 4
># 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/stddef.h" 1 3 4
># 26 "/usr/include/alloca.h" 2 3 4
>
>
>
>
>
>
>
>extern void *alloca (size_t __size) __attribute__ ((__nothrow__));
>
>
>
>
>
>
># 613 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>extern void *valloc (size_t __size) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) ;
>
>
>
>
>extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>extern void abort (void) __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));
>
>
>
>extern int atexit (void (*__func) (void)) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern void exit (int __status) __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));
>
>
>
>
>
>
>extern void _Exit (int __status) __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));
>
>
>
>
>
>
>extern char *getenv (__const char *__name) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>extern char *__secure_getenv (__const char *__name)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern int putenv (char *__string) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int setenv (__const char *__name, __const char *__value, int __replace)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>extern int unsetenv (__const char *__name) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern int clearenv (void) __attribute__ ((__nothrow__));
># 698 "/usr/include/stdlib.h" 3 4
>extern char *mktemp (char *__template) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
># 712 "/usr/include/stdlib.h" 3 4
>extern int mkstemp (char *__template) __asm__ ("" "mkstemp64")
>     __attribute__ ((__nonnull__ (1))) ;
># 729 "/usr/include/stdlib.h" 3 4
>extern char *mkdtemp (char *__template) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>
>
>
>extern int system (__const char *__command) ;
>
># 755 "/usr/include/stdlib.h" 3 4
>extern char *realpath (__const char *__restrict __name,
>         char *__restrict __resolved) __attribute__ ((__nothrow__)) ;
>
>
>
>
>
>
>typedef int (*__compar_fn_t) (__const void *, __const void *);
>
>
>
>
>
>
>
>
>
>extern void *bsearch (__const void *__key, __const void *__base,
>        size_t __nmemb, size_t __size, __compar_fn_t __compar)
>     __attribute__ ((__nonnull__ (1, 2, 5))) ;
>
>
>
>extern void qsort (void *__base, size_t __nmemb, size_t __size,
>     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
>
>
>
>extern int abs (int __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)) ;
>extern long int labs (long int __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)) ;
>
>
>
>__extension__ extern long long int llabs (long long int __x)
>     __attribute__ ((__nothrow__)) __attribute__ ((__const__)) ;
>
>
>
>
>
>
>
>extern div_t div (int __numer, int __denom)
>     __attribute__ ((__nothrow__)) __attribute__ ((__const__)) ;
>extern ldiv_t ldiv (long int __numer, long int __denom)
>     __attribute__ ((__nothrow__)) __attribute__ ((__const__)) ;
>
>
>
>
>__extension__ extern lldiv_t lldiv (long long int __numer,
>        long long int __denom)
>     __attribute__ ((__nothrow__)) __attribute__ ((__const__)) ;
>
># 820 "/usr/include/stdlib.h" 3 4
>extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4))) ;
>
>
>
>
>extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4))) ;
>
>
>
>
>extern char *gcvt (double __value, int __ndigit, char *__buf)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3))) ;
>
>
>
>
>extern char *qecvt (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4))) ;
>extern char *qfcvt (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4))) ;
>extern char *qgcvt (long double __value, int __ndigit, char *__buf)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3))) ;
>
>
>
>
>extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign, char *__restrict __buf,
>     size_t __len) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign, char *__restrict __buf,
>     size_t __len) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>
>extern int qecvt_r (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign,
>      char *__restrict __buf, size_t __len)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>extern int qfcvt_r (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign,
>      char *__restrict __buf, size_t __len)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>
>
>
>
>
>
>
>extern int mblen (__const char *__s, size_t __n) __attribute__ ((__nothrow__)) ;
>
>
>extern int mbtowc (wchar_t *__restrict __pwc,
>     __const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__)) ;
>
>
>extern int wctomb (char *__s, wchar_t __wchar) __attribute__ ((__nothrow__)) ;
>
>
>
>extern size_t mbstowcs (wchar_t *__restrict __pwcs,
>   __const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__));
>
>extern size_t wcstombs (char *__restrict __s,
>   __const wchar_t *__restrict __pwcs, size_t __n)
>     __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>extern int rpmatch (__const char *__response) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
># 925 "/usr/include/stdlib.h" 3 4
>extern int posix_openpt (int __oflag) ;
># 960 "/usr/include/stdlib.h" 3 4
>extern int getloadavg (double __loadavg[], int __nelem)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
># 976 "/usr/include/stdlib.h" 3 4
>
># 36 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/common.h" 2
># 1 "/usr/include/stdio.h" 1 3 4
># 30 "/usr/include/stdio.h" 3 4
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/stddef.h" 1 3 4
># 35 "/usr/include/stdio.h" 2 3 4
># 45 "/usr/include/stdio.h" 3 4
>struct _IO_FILE;
>
>
>
>typedef struct _IO_FILE FILE;
>
>
>
>
>
># 65 "/usr/include/stdio.h" 3 4
>typedef struct _IO_FILE __FILE;
># 75 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/libio.h" 1 3 4
># 32 "/usr/include/libio.h" 3 4
># 1 "/usr/include/_G_config.h" 1 3 4
># 14 "/usr/include/_G_config.h" 3 4
># 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/stddef.h" 1 3 4
># 354 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/stddef.h" 3 4
>typedef unsigned int wint_t;
># 15 "/usr/include/_G_config.h" 2 3 4
># 24 "/usr/include/_G_config.h" 3 4
># 1 "/usr/include/wchar.h" 1 3 4
># 48 "/usr/include/wchar.h" 3 4
># 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/stddef.h" 1 3 4
># 49 "/usr/include/wchar.h" 2 3 4
># 76 "/usr/include/wchar.h" 3 4
>typedef struct
>{
>  int __count;
>  union
>  {
>    wint_t __wch;
>    char __wchb[4];
>  } __value;
>} __mbstate_t;
># 25 "/usr/include/_G_config.h" 2 3 4
>
>typedef struct
>{
>  __off_t __pos;
>  __mbstate_t __state;
>} _G_fpos_t;
>typedef struct
>{
>  __off64_t __pos;
>  __mbstate_t __state;
>} _G_fpos64_t;
># 44 "/usr/include/_G_config.h" 3 4
># 1 "/usr/include/gconv.h" 1 3 4
># 28 "/usr/include/gconv.h" 3 4
># 1 "/usr/include/wchar.h" 1 3 4
># 48 "/usr/include/wchar.h" 3 4
># 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/stddef.h" 1 3 4
># 49 "/usr/include/wchar.h" 2 3 4
># 29 "/usr/include/gconv.h" 2 3 4
>
>
># 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/stddef.h" 1 3 4
># 32 "/usr/include/gconv.h" 2 3 4
>
>
>
>
>
>enum
>{
>  __GCONV_OK = 0,
>  __GCONV_NOCONV,
>  __GCONV_NODB,
>  __GCONV_NOMEM,
>
>  __GCONV_EMPTY_INPUT,
>  __GCONV_FULL_OUTPUT,
>  __GCONV_ILLEGAL_INPUT,
>  __GCONV_INCOMPLETE_INPUT,
>
>  __GCONV_ILLEGAL_DESCRIPTOR,
>  __GCONV_INTERNAL_ERROR
>};
>
>
>
>enum
>{
>  __GCONV_IS_LAST = 0x0001,
>  __GCONV_IGNORE_ERRORS = 0x0002
>};
>
>
>
>struct __gconv_step;
>struct __gconv_step_data;
>struct __gconv_loaded_object;
>struct __gconv_trans_data;
>
>
>
>typedef int (*__gconv_fct) (struct __gconv_step *, struct __gconv_step_data *,
>       __const unsigned char **, __const unsigned char *,
>       unsigned char **, size_t *, int, int);
>
>
>typedef wint_t (*__gconv_btowc_fct) (struct __gconv_step *, unsigned char);
>
>
>typedef int (*__gconv_init_fct) (struct __gconv_step *);
>typedef void (*__gconv_end_fct) (struct __gconv_step *);
>
>
>
>typedef int (*__gconv_trans_fct) (struct __gconv_step *,
>      struct __gconv_step_data *, void *,
>      __const unsigned char *,
>      __const unsigned char **,
>      __const unsigned char *, unsigned char **,
>      size_t *);
>
>
>typedef int (*__gconv_trans_context_fct) (void *, __const unsigned char *,
>       __const unsigned char *,
>       unsigned char *, unsigned char *);
>
>
>typedef int (*__gconv_trans_query_fct) (__const char *, __const char ***,
>     size_t *);
>
>
>typedef int (*__gconv_trans_init_fct) (void **, const char *);
>typedef void (*__gconv_trans_end_fct) (void *);
>
>struct __gconv_trans_data
>{
>
>  __gconv_trans_fct __trans_fct;
>  __gconv_trans_context_fct __trans_context_fct;
>  __gconv_trans_end_fct __trans_end_fct;
>  void *__data;
>  struct __gconv_trans_data *__next;
>};
>
>
>
>struct __gconv_step
>{
>  struct __gconv_loaded_object *__shlib_handle;
>  __const char *__modname;
>
>  int __counter;
>
>  char *__from_name;
>  char *__to_name;
>
>  __gconv_fct __fct;
>  __gconv_btowc_fct __btowc_fct;
>  __gconv_init_fct __init_fct;
>  __gconv_end_fct __end_fct;
>
>
>
>  int __min_needed_from;
>  int __max_needed_from;
>  int __min_needed_to;
>  int __max_needed_to;
>
>
>  int __stateful;
>
>  void *__data;
>};
>
>
>
>struct __gconv_step_data
>{
>  unsigned char *__outbuf;
>  unsigned char *__outbufend;
>
>
>
>  int __flags;
>
>
>
>  int __invocation_counter;
>
>
>
>  int __internal_use;
>
>  __mbstate_t *__statep;
>  __mbstate_t __state;
>
>
>
>  struct __gconv_trans_data *__trans;
>};
>
>
>
>typedef struct __gconv_info
>{
>  size_t __nsteps;
>  struct __gconv_step *__steps;
>  __extension__ struct __gconv_step_data __data [];
>} *__gconv_t;
># 45 "/usr/include/_G_config.h" 2 3 4
>typedef union
>{
>  struct __gconv_info __cd;
>  struct
>  {
>    struct __gconv_info __cd;
>    struct __gconv_step_data __data;
>  } __combined;
>} _G_iconv_t;
>
>typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
>typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
>typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
>typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
># 33 "/usr/include/libio.h" 2 3 4
># 53 "/usr/include/libio.h" 3 4
># 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/stdarg.h" 1 3 4
># 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/stdarg.h" 3 4
>typedef __builtin_va_list __gnuc_va_list;
># 54 "/usr/include/libio.h" 2 3 4
># 167 "/usr/include/libio.h" 3 4
>struct _IO_jump_t; struct _IO_FILE;
># 177 "/usr/include/libio.h" 3 4
>typedef void _IO_lock_t;
>
>
>
>
>
>struct _IO_marker {
>  struct _IO_marker *_next;
>  struct _IO_FILE *_sbuf;
>
>
>
>  int _pos;
># 200 "/usr/include/libio.h" 3 4
>};
>
>
>enum __codecvt_result
>{
>  __codecvt_ok,
>  __codecvt_partial,
>  __codecvt_error,
>  __codecvt_noconv
>};
># 268 "/usr/include/libio.h" 3 4
>struct _IO_FILE {
>  int _flags;
>
>
>
>
>  char* _IO_read_ptr;
>  char* _IO_read_end;
>  char* _IO_read_base;
>  char* _IO_write_base;
>  char* _IO_write_ptr;
>  char* _IO_write_end;
>  char* _IO_buf_base;
>  char* _IO_buf_end;
>
>  char *_IO_save_base;
>  char *_IO_backup_base;
>  char *_IO_save_end;
>
>  struct _IO_marker *_markers;
>
>  struct _IO_FILE *_chain;
>
>  int _fileno;
>
>
>
>  int _flags2;
>
>  __off_t _old_offset;
>
>
>
>  unsigned short _cur_column;
>  signed char _vtable_offset;
>  char _shortbuf[1];
>
>
>
>  _IO_lock_t *_lock;
># 316 "/usr/include/libio.h" 3 4
>  __off64_t _offset;
># 325 "/usr/include/libio.h" 3 4
>  void *__pad1;
>  void *__pad2;
>  void *__pad3;
>  void *__pad4;
>  size_t __pad5;
>
>  int _mode;
>
>  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
>
>};
>
>
>typedef struct _IO_FILE _IO_FILE;
>
>
>struct _IO_FILE_plus;
>
>extern struct _IO_FILE_plus _IO_2_1_stdin_;
>extern struct _IO_FILE_plus _IO_2_1_stdout_;
>extern struct _IO_FILE_plus _IO_2_1_stderr_;
># 361 "/usr/include/libio.h" 3 4
>typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
>
>
>
>
>
>
>
>typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
>     size_t __n);
>
>
>
>
>
>
>
>typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
>
>
>typedef int __io_close_fn (void *__cookie);
># 413 "/usr/include/libio.h" 3 4
>extern int __underflow (_IO_FILE *);
>extern int __uflow (_IO_FILE *);
>extern int __overflow (_IO_FILE *, int);
>extern wint_t __wunderflow (_IO_FILE *);
>extern wint_t __wuflow (_IO_FILE *);
>extern wint_t __woverflow (_IO_FILE *, wint_t);
># 451 "/usr/include/libio.h" 3 4
>extern int _IO_getc (_IO_FILE *__fp);
>extern int _IO_putc (int __c, _IO_FILE *__fp);
>extern int _IO_feof (_IO_FILE *__fp) __attribute__ ((__nothrow__));
>extern int _IO_ferror (_IO_FILE *__fp) __attribute__ ((__nothrow__));
>
>extern int _IO_peekc_locked (_IO_FILE *__fp);
>
>
>
>
>
>extern void _IO_flockfile (_IO_FILE *) __attribute__ ((__nothrow__));
>extern void _IO_funlockfile (_IO_FILE *) __attribute__ ((__nothrow__));
>extern int _IO_ftrylockfile (_IO_FILE *) __attribute__ ((__nothrow__));
># 481 "/usr/include/libio.h" 3 4
>extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
>   __gnuc_va_list, int *__restrict);
>extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
>    __gnuc_va_list);
>extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
>extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
>
>extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
>extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
>
>extern void _IO_free_backup_area (_IO_FILE *) __attribute__ ((__nothrow__));
># 76 "/usr/include/stdio.h" 2 3 4
># 89 "/usr/include/stdio.h" 3 4
>
>
>
>
>typedef _G_fpos64_t fpos_t;
>
>
># 141 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/stdio_lim.h" 1 3 4
># 142 "/usr/include/stdio.h" 2 3 4
>
>
>
>extern struct _IO_FILE *stdin;
>extern struct _IO_FILE *stdout;
>extern struct _IO_FILE *stderr;
>
>
>
>
>
>
>
>extern int remove (__const char *__filename) __attribute__ ((__nothrow__));
>
>extern int rename (__const char *__old, __const char *__new) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>
># 175 "/usr/include/stdio.h" 3 4
>extern FILE *tmpfile (void) __asm__ ("" "tmpfile64") ;
># 186 "/usr/include/stdio.h" 3 4
>extern char *tmpnam (char *__s) __attribute__ ((__nothrow__)) ;
>
>
>
>
>
>extern char *tmpnam_r (char *__s) __attribute__ ((__nothrow__)) ;
># 204 "/usr/include/stdio.h" 3 4
>extern char *tempnam (__const char *__dir, __const char *__pfx)
>     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) ;
>
>
>
>
>
>
>
>
>extern int fclose (FILE *__stream);
>
>
>
>
>extern int fflush (FILE *__stream);
>
># 229 "/usr/include/stdio.h" 3 4
>extern int fflush_unlocked (FILE *__stream);
># 243 "/usr/include/stdio.h" 3 4
>
># 260 "/usr/include/stdio.h" 3 4
>extern FILE *fopen (__const char *__restrict __filename, __const char *__restrict __modes) __asm__ ("" "fopen64")
>
>  ;
>extern FILE *freopen (__const char *__restrict __filename, __const char *__restrict __modes, FILE *__restrict __stream) __asm__ ("" "freopen64")
>
>
>  ;
>
>
>
>
>
>
># 283 "/usr/include/stdio.h" 3 4
>extern FILE *fdopen (int __fd, __const char *__modes) __attribute__ ((__nothrow__)) ;
># 304 "/usr/include/stdio.h" 3 4
>
>
>
>extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __attribute__ ((__nothrow__));
>
>
>
>extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
>      int __modes, size_t __n) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
>         size_t __size) __attribute__ ((__nothrow__));
>
>
>extern void setlinebuf (FILE *__stream) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>extern int fprintf (FILE *__restrict __stream,
>      __const char *__restrict __format, ...);
>
>
>
>
>extern int printf (__const char *__restrict __format, ...);
>
>extern int sprintf (char *__restrict __s,
>      __const char *__restrict __format, ...) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format,
>       __gnuc_va_list __arg);
>
>
>
>
>extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg);
>
>extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
>       __gnuc_va_list __arg) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern int snprintf (char *__restrict __s, size_t __maxlen,
>       __const char *__restrict __format, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4)));
>
>extern int vsnprintf (char *__restrict __s, size_t __maxlen,
>        __const char *__restrict __format, __gnuc_va_list __arg)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0)));
>
># 398 "/usr/include/stdio.h" 3 4
>
>
>
>
>
>extern int fscanf (FILE *__restrict __stream,
>     __const char *__restrict __format, ...) ;
>
>
>
>
>extern int scanf (__const char *__restrict __format, ...) ;
>
>extern int sscanf (__const char *__restrict __s,
>     __const char *__restrict __format, ...) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>extern int vfscanf (FILE *__restrict __s, __const char *__restrict __format,
>      __gnuc_va_list __arg)
>     __attribute__ ((__format__ (__scanf__, 2, 0))) ;
>
>
>
>
>
>extern int vscanf (__const char *__restrict __format, __gnuc_va_list __arg)
>     __attribute__ ((__format__ (__scanf__, 1, 0))) ;
>
>
>extern int vsscanf (__const char *__restrict __s,
>      __const char *__restrict __format, __gnuc_va_list __arg)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__scanf__, 2, 0)));
>
>
>
>
>
>
>
>
>
>extern int fgetc (FILE *__stream);
>extern int getc (FILE *__stream);
>
>
>
>
>
>extern int getchar (void);
>
># 464 "/usr/include/stdio.h" 3 4
>extern int getc_unlocked (FILE *__stream);
>extern int getchar_unlocked (void);
># 475 "/usr/include/stdio.h" 3 4
>extern int fgetc_unlocked (FILE *__stream);
>
>
>
>
>
>
>
>
>
>
>
>extern int fputc (int __c, FILE *__stream);
>extern int putc (int __c, FILE *__stream);
>
>
>
>
>
>extern int putchar (int __c);
>
># 508 "/usr/include/stdio.h" 3 4
>extern int fputc_unlocked (int __c, FILE *__stream);
>
>
>
>
>
>
>
>extern int putc_unlocked (int __c, FILE *__stream);
>extern int putchar_unlocked (int __c);
>
>
>
>
>
>
>extern int getw (FILE *__stream);
>
>
>extern int putw (int __w, FILE *__stream);
>
>
>
>
>
>
>
>
>extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
>     ;
>
>
>
>
>
>
>extern char *gets (char *__s) ;
>
># 589 "/usr/include/stdio.h" 3 4
>
>
>
>
>
>extern int fputs (__const char *__restrict __s, FILE *__restrict __stream);
>
>
>
>
>
>extern int puts (__const char *__s);
>
>
>
>
>
>
>extern int ungetc (int __c, FILE *__stream);
>
>
>
>
>
>
>extern size_t fread (void *__restrict __ptr, size_t __size,
>       size_t __n, FILE *__restrict __stream) ;
>
>
>
>
>extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
>        size_t __n, FILE *__restrict __s) ;
>
># 642 "/usr/include/stdio.h" 3 4
>extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
>         size_t __n, FILE *__restrict __stream) ;
>extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
>          size_t __n, FILE *__restrict __stream) ;
>
>
>
>
>
>
>
>
>extern int fseek (FILE *__stream, long int __off, int __whence);
>
>
>
>
>extern long int ftell (FILE *__stream) ;
>
>
>
>
>extern void rewind (FILE *__stream);
>
># 686 "/usr/include/stdio.h" 3 4
>extern int fseeko (FILE *__stream, __off64_t __off, int __whence) __asm__ ("" "fseeko64");
>
>
>extern __off64_t ftello (FILE *__stream) __asm__ ("" "ftello64");
>
>
>
>
>
>
>
>
># 711 "/usr/include/stdio.h" 3 4
>extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos) __asm__ ("" "fgetpos64");
>
>extern int fsetpos (FILE *__stream, __const fpos_t *__pos) __asm__ ("" "fsetpos64");
>
>
>
>
>
>
>
># 729 "/usr/include/stdio.h" 3 4
>
>
>extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__));
>
>extern int feof (FILE *__stream) __attribute__ ((__nothrow__)) ;
>
>extern int ferror (FILE *__stream) __attribute__ ((__nothrow__)) ;
>
>
>
>
>extern void clearerr_unlocked (FILE *__stream) __attribute__ ((__nothrow__));
>extern int feof_unlocked (FILE *__stream) __attribute__ ((__nothrow__)) ;
>extern int ferror_unlocked (FILE *__stream) __attribute__ ((__nothrow__)) ;
>
>
>
>
>
>
>
>
>extern void perror (__const char *__s);
>
>
>
>
>
>
># 1 "/usr/include/bits/sys_errlist.h" 1 3 4
># 27 "/usr/include/bits/sys_errlist.h" 3 4
>extern int sys_nerr;
>extern __const char *__const sys_errlist[];
># 759 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>extern int fileno (FILE *__stream) __attribute__ ((__nothrow__)) ;
>
>
>
>
>extern int fileno_unlocked (FILE *__stream) __attribute__ ((__nothrow__)) ;
># 778 "/usr/include/stdio.h" 3 4
>extern FILE *popen (__const char *__command, __const char *__modes) ;
>
>
>
>
>
>extern int pclose (FILE *__stream);
>
>
>
>
>
>extern char *ctermid (char *__s) __attribute__ ((__nothrow__));
># 818 "/usr/include/stdio.h" 3 4
>extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__));
>
>
>
>extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__)) ;
>
>
>extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__));
># 839 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/stdio.h" 1 3 4
># 33 "/usr/include/bits/stdio.h" 3 4
>extern __inline int
>vprintf (__const char *__restrict __fmt, __gnuc_va_list __arg)
>{
>  return vfprintf (stdout, __fmt, __arg);
>}
>
>
>extern __inline int
>getchar (void)
>{
>  return _IO_getc (stdin);
>}
>
>
>
>
>extern __inline int
>fgetc_unlocked (FILE *__fp)
>{
>  return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
>}
>
>
>
>
>
>extern __inline int
>getc_unlocked (FILE *__fp)
>{
>  return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
>}
>
>
>extern __inline int
>getchar_unlocked (void)
>{
>  return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
>}
>
>
>
>
>extern __inline int
>putchar (int __c)
>{
>  return _IO_putc (__c, stdout);
>}
>
>
>
>
>extern __inline int
>fputc_unlocked (int __c, FILE *__stream)
>{
>  return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
>}
>
>
>
>
>
>extern __inline int
>putc_unlocked (int __c, FILE *__stream)
>{
>  return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
>}
>
>
>extern __inline int
>putchar_unlocked (int __c)
>{
>  return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
>}
># 121 "/usr/include/bits/stdio.h" 3 4
>extern __inline int
>__attribute__ ((__nothrow__)) feof_unlocked (FILE *__stream)
>{
>  return (((__stream)->_flags & 0x10) != 0);
>}
>
>
>extern __inline int
>__attribute__ ((__nothrow__)) ferror_unlocked (FILE *__stream)
>{
>  return (((__stream)->_flags & 0x20) != 0);
>}
># 840 "/usr/include/stdio.h" 2 3 4
># 848 "/usr/include/stdio.h" 3 4
>
># 37 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/common.h" 2
># 1 "/usr/include/string.h" 1 3 4
># 28 "/usr/include/string.h" 3 4
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/stddef.h" 1 3 4
># 34 "/usr/include/string.h" 2 3 4
>
>
>
>
>extern void *memcpy (void *__restrict __dest,
>       __const void *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void *memmove (void *__dest, __const void *__src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
>        int __c, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern void *memset (void *__s, int __c, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void *memchr (__const void *__s, int __c, size_t __n)
>      __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
># 82 "/usr/include/string.h" 3 4
>
>
>extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncpy (char *__restrict __dest,
>        __const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
>        size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcmp (__const char *__s1, __const char *__s2)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcoll (__const char *__s1, __const char *__s2)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern size_t strxfrm (char *__restrict __dest,
>         __const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
># 130 "/usr/include/string.h" 3 4
>extern char *strdup (__const char *__s)
>     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
># 165 "/usr/include/string.h" 3 4
>
>
>extern char *strchr (__const char *__s, int __c)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>extern char *strrchr (__const char *__s, int __c)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
># 181 "/usr/include/string.h" 3 4
>
>
>
>extern size_t strcspn (__const char *__s, __const char *__reject)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern size_t strspn (__const char *__s, __const char *__accept)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strpbrk (__const char *__s, __const char *__accept)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strstr (__const char *__haystack, __const char *__needle)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern char *__strtok_r (char *__restrict __s,
>    __const char *__restrict __delim,
>    char **__restrict __save_ptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
>
>extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
>         char **__restrict __save_ptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
># 240 "/usr/include/string.h" 3 4
>
>
>extern size_t strlen (__const char *__s)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
># 254 "/usr/include/string.h" 3 4
>
>
>extern char *strerror (int __errnum) __attribute__ ((__nothrow__));
>
># 270 "/usr/include/string.h" 3 4
>extern int strerror_r (int __errnum, char *__buf, size_t __buflen) __asm__ ("" "__xpg_strerror_r") __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
># 294 "/usr/include/string.h" 3 4
>extern void __bzero (void *__s, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern void bcopy (__const void *__src, void *__dest, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void bzero (void *__s, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *index (__const char *__s, int __c)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern char *rindex (__const char *__s, int __c)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int ffs (int __i) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
># 331 "/usr/include/string.h" 3 4
>extern int strcasecmp (__const char *__s1, __const char *__s2)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
># 354 "/usr/include/string.h" 3 4
>extern char *strsep (char **__restrict __stringp,
>       __const char *__restrict __delim)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
># 420 "/usr/include/string.h" 3 4
># 1 "/usr/include/bits/string.h" 1 3 4
># 421 "/usr/include/string.h" 2 3 4
>
>
># 1 "/usr/include/bits/string2.h" 1 3 4
># 394 "/usr/include/bits/string2.h" 3 4
>extern void *__rawmemchr (const void *__s, int __c);
># 969 "/usr/include/bits/string2.h" 3 4
>extern __inline size_t __strcspn_c1 (__const char *__s, int __reject);
>extern __inline size_t
>__strcspn_c1 (__const char *__s, int __reject)
>{
>  register size_t __result = 0;
>  while (__s[__result] != '\0' && __s[__result] != __reject)
>    ++__result;
>  return __result;
>}
>
>extern __inline size_t __strcspn_c2 (__const char *__s, int __reject1,
>         int __reject2);
>extern __inline size_t
>__strcspn_c2 (__const char *__s, int __reject1, int __reject2)
>{
>  register size_t __result = 0;
>  while (__s[__result] != '\0' && __s[__result] != __reject1
>  && __s[__result] != __reject2)
>    ++__result;
>  return __result;
>}
>
>extern __inline size_t __strcspn_c3 (__const char *__s, int __reject1,
>         int __reject2, int __reject3);
>extern __inline size_t
>__strcspn_c3 (__const char *__s, int __reject1, int __reject2,
>       int __reject3)
>{
>  register size_t __result = 0;
>  while (__s[__result] != '\0' && __s[__result] != __reject1
>  && __s[__result] != __reject2 && __s[__result] != __reject3)
>    ++__result;
>  return __result;
>}
># 1045 "/usr/include/bits/string2.h" 3 4
>extern __inline size_t __strspn_c1 (__const char *__s, int __accept);
>extern __inline size_t
>__strspn_c1 (__const char *__s, int __accept)
>{
>  register size_t __result = 0;
>
>  while (__s[__result] == __accept)
>    ++__result;
>  return __result;
>}
>
>extern __inline size_t __strspn_c2 (__const char *__s, int __accept1,
>        int __accept2);
>extern __inline size_t
>__strspn_c2 (__const char *__s, int __accept1, int __accept2)
>{
>  register size_t __result = 0;
>
>  while (__s[__result] == __accept1 || __s[__result] == __accept2)
>    ++__result;
>  return __result;
>}
>
>extern __inline size_t __strspn_c3 (__const char *__s, int __accept1,
>        int __accept2, int __accept3);
>extern __inline size_t
>__strspn_c3 (__const char *__s, int __accept1, int __accept2, int __accept3)
>{
>  register size_t __result = 0;
>
>  while (__s[__result] == __accept1 || __s[__result] == __accept2
>  || __s[__result] == __accept3)
>    ++__result;
>  return __result;
>}
># 1121 "/usr/include/bits/string2.h" 3 4
>extern __inline char *__strpbrk_c2 (__const char *__s, int __accept1,
>         int __accept2);
>extern __inline char *
>__strpbrk_c2 (__const char *__s, int __accept1, int __accept2)
>{
>
>  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2)
>    ++__s;
>  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
>}
>
>extern __inline char *__strpbrk_c3 (__const char *__s, int __accept1,
>         int __accept2, int __accept3);
>extern __inline char *
>__strpbrk_c3 (__const char *__s, int __accept1, int __accept2,
>       int __accept3)
>{
>
>  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2
>  && *__s != __accept3)
>    ++__s;
>  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
>}
># 1173 "/usr/include/bits/string2.h" 3 4
>extern __inline char *__strtok_r_1c (char *__s, char __sep, char **__nextp);
>extern __inline char *
>__strtok_r_1c (char *__s, char __sep, char **__nextp)
>{
>  char *__result;
>  if (__s == ((void *)0))
>    __s = *__nextp;
>  while (*__s == __sep)
>    ++__s;
>  __result = ((void *)0);
>  if (*__s != '\0')
>    {
>      __result = __s++;
>      while (*__s != '\0')
> if (*__s++ == __sep)
>   {
>     __s[-1] = '\0';
>     break;
>   }
>      *__nextp = __s;
>    }
>  return __result;
>}
># 1205 "/usr/include/bits/string2.h" 3 4
>extern char *__strsep_g (char **__stringp, __const char *__delim);
># 1223 "/usr/include/bits/string2.h" 3 4
>extern __inline char *__strsep_1c (char **__s, char __reject);
>extern __inline char *
>__strsep_1c (char **__s, char __reject)
>{
>  register char *__retval = *__s;
>  if (__retval != ((void *)0) && (*__s = (__extension__ (__builtin_constant_p (__reject) && !__builtin_constant_p (__retval) && (__reject) == '\0' ? (char *) __rawmemchr (__retval, __reject) : __builtin_strchr (__retval, __reject)))) != ((void *)0))
>    *(*__s)++ = '\0';
>  return __retval;
>}
>
>extern __inline char *__strsep_2c (char **__s, char __reject1, char __reject2);
>extern __inline char *
>__strsep_2c (char **__s, char __reject1, char __reject2)
>{
>  register char *__retval = *__s;
>  if (__retval != ((void *)0))
>    {
>      register char *__cp = __retval;
>      while (1)
> {
>   if (*__cp == '\0')
>     {
>       __cp = ((void *)0);
>   break;
>     }
>   if (*__cp == __reject1 || *__cp == __reject2)
>     {
>       *__cp++ = '\0';
>       break;
>     }
>   ++__cp;
> }
>      *__s = __cp;
>    }
>  return __retval;
>}
>
>extern __inline char *__strsep_3c (char **__s, char __reject1, char __reject2,
>       char __reject3);
>extern __inline char *
>__strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
>{
>  register char *__retval = *__s;
>  if (__retval != ((void *)0))
>    {
>      register char *__cp = __retval;
>      while (1)
> {
>   if (*__cp == '\0')
>     {
>       __cp = ((void *)0);
>   break;
>     }
>   if (*__cp == __reject1 || *__cp == __reject2 || *__cp == __reject3)
>     {
>       *__cp++ = '\0';
>       break;
>     }
>   ++__cp;
> }
>      *__s = __cp;
>    }
>  return __retval;
>}
># 1304 "/usr/include/bits/string2.h" 3 4
>extern char *__strdup (__const char *__string) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));
># 1323 "/usr/include/bits/string2.h" 3 4
>extern char *__strndup (__const char *__string, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));
># 424 "/usr/include/string.h" 2 3 4
># 432 "/usr/include/string.h" 3 4
>
># 38 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/common.h" 2
># 1 "/usr/include/ctype.h" 1 3 4
># 30 "/usr/include/ctype.h" 3 4
>
># 48 "/usr/include/ctype.h" 3 4
>enum
>{
>  _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
>  _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
>  _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
>  _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
>  _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
>  _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
>  _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
>  _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
>  _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
>  _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
>  _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
>  _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
>};
># 81 "/usr/include/ctype.h" 3 4
>extern __const unsigned short int **__ctype_b_loc (void)
>     __attribute__ ((__const));
>extern __const __int32_t **__ctype_tolower_loc (void)
>     __attribute__ ((__const));
>extern __const __int32_t **__ctype_toupper_loc (void)
>     __attribute__ ((__const));
># 96 "/usr/include/ctype.h" 3 4
>
>
>
>
>
>
>extern int isalnum (int) __attribute__ ((__nothrow__));
>extern int isalpha (int) __attribute__ ((__nothrow__));
>extern int iscntrl (int) __attribute__ ((__nothrow__));
>extern int isdigit (int) __attribute__ ((__nothrow__));
>extern int islower (int) __attribute__ ((__nothrow__));
>extern int isgraph (int) __attribute__ ((__nothrow__));
>extern int isprint (int) __attribute__ ((__nothrow__));
>extern int ispunct (int) __attribute__ ((__nothrow__));
>extern int isspace (int) __attribute__ ((__nothrow__));
>extern int isupper (int) __attribute__ ((__nothrow__));
>extern int isxdigit (int) __attribute__ ((__nothrow__));
>
>
>
>extern int tolower (int __c) __attribute__ ((__nothrow__));
>
>
>extern int toupper (int __c) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>extern int isblank (int) __attribute__ ((__nothrow__));
>
>
># 142 "/usr/include/ctype.h" 3 4
>extern int isascii (int __c) __attribute__ ((__nothrow__));
>
>
>
>extern int toascii (int __c) __attribute__ ((__nothrow__));
>
>
>
>extern int _toupper (int) __attribute__ ((__nothrow__));
>extern int _tolower (int) __attribute__ ((__nothrow__));
># 190 "/usr/include/ctype.h" 3 4
>extern __inline int
>__attribute__ ((__nothrow__)) tolower (int __c)
>{
>  return __c >= -128 && __c < 256 ? (*__ctype_tolower_loc ())[__c] : __c;
>}
>
>extern __inline int
>__attribute__ ((__nothrow__)) toupper (int __c)
>{
>  return __c >= -128 && __c < 256 ? (*__ctype_toupper_loc ())[__c] : __c;
>}
># 323 "/usr/include/ctype.h" 3 4
>
># 39 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/common.h" 2
># 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/limits.h" 1 3 4
># 11 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/limits.h" 3 4
># 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/syslimits.h" 1 3 4
>
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/limits.h" 1 3 4
># 122 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/limits.h" 3 4
># 1 "/usr/include/limits.h" 1 3 4
># 145 "/usr/include/limits.h" 3 4
># 1 "/usr/include/bits/posix1_lim.h" 1 3 4
># 153 "/usr/include/bits/posix1_lim.h" 3 4
># 1 "/usr/include/bits/local_lim.h" 1 3 4
># 36 "/usr/include/bits/local_lim.h" 3 4
># 1 "/usr/include/linux/limits.h" 1 3 4
># 37 "/usr/include/bits/local_lim.h" 2 3 4
># 154 "/usr/include/bits/posix1_lim.h" 2 3 4
># 146 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/posix2_lim.h" 1 3 4
># 150 "/usr/include/limits.h" 2 3 4
># 123 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/limits.h" 2 3 4
># 8 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/syslimits.h" 2 3 4
># 12 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/limits.h" 2 3 4
># 40 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/common.h" 2
># 1 "/usr/include/errno.h" 1 3 4
># 32 "/usr/include/errno.h" 3 4
>
>
>
>
># 1 "/usr/include/bits/errno.h" 1 3 4
># 25 "/usr/include/bits/errno.h" 3 4
># 1 "/usr/include/linux/errno.h" 1 3 4
>
>
>
># 1 "/usr/include/asm/errno.h" 1 3 4
>
>
>
>
># 1 "/usr/include/asm-x86_64/errno.h" 1 3 4
>
>
>
># 1 "/usr/include/asm-generic/errno.h" 1 3 4
>
>
>
># 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
># 5 "/usr/include/asm-generic/errno.h" 2 3 4
># 5 "/usr/include/asm-x86_64/errno.h" 2 3 4
># 6 "/usr/include/asm/errno.h" 2 3 4
># 5 "/usr/include/linux/errno.h" 2 3 4
># 26 "/usr/include/bits/errno.h" 2 3 4
># 43 "/usr/include/bits/errno.h" 3 4
>extern int *__errno_location (void) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
># 37 "/usr/include/errno.h" 2 3 4
># 59 "/usr/include/errno.h" 3 4
>
># 41 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/common.h" 2
># 1 "/usr/include/math.h" 1 3 4
># 30 "/usr/include/math.h" 3 4
>
>
>
>
># 1 "/usr/include/bits/huge_val.h" 1 3 4
># 35 "/usr/include/math.h" 2 3 4
>
># 1 "/usr/include/bits/huge_valf.h" 1 3 4
># 37 "/usr/include/math.h" 2 3 4
># 1 "/usr/include/bits/huge_vall.h" 1 3 4
># 38 "/usr/include/math.h" 2 3 4
>
>
># 1 "/usr/include/bits/inf.h" 1 3 4
># 41 "/usr/include/math.h" 2 3 4
>
>
># 1 "/usr/include/bits/nan.h" 1 3 4
># 44 "/usr/include/math.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/mathdef.h" 1 3 4
># 26 "/usr/include/bits/mathdef.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 27 "/usr/include/bits/mathdef.h" 2 3 4
>
>
>
>
>typedef float float_t;
>typedef double double_t;
># 48 "/usr/include/math.h" 2 3 4
># 71 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 53 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern double acos (double __x) __attribute__ ((__nothrow__)); extern double __acos (double __x) __attribute__ ((__nothrow__));
>
>extern double asin (double __x) __attribute__ ((__nothrow__)); extern double __asin (double __x) __attribute__ ((__nothrow__));
>
>extern double atan (double __x) __attribute__ ((__nothrow__)); extern double __atan (double __x) __attribute__ ((__nothrow__));
>
>extern double atan2 (double __y, double __x) __attribute__ ((__nothrow__)); extern double __atan2 (double __y, double __x) __attribute__ ((__nothrow__));
>
>
>extern double cos (double __x) __attribute__ ((__nothrow__)); extern double __cos (double __x) __attribute__ ((__nothrow__));
>
>extern double sin (double __x) __attribute__ ((__nothrow__)); extern double __sin (double __x) __attribute__ ((__nothrow__));
>
>extern double tan (double __x) __attribute__ ((__nothrow__)); extern double __tan (double __x) __attribute__ ((__nothrow__));
>
>
>
>
>extern double cosh (double __x) __attribute__ ((__nothrow__)); extern double __cosh (double __x) __attribute__ ((__nothrow__));
>
>extern double sinh (double __x) __attribute__ ((__nothrow__)); extern double __sinh (double __x) __attribute__ ((__nothrow__));
>
>extern double tanh (double __x) __attribute__ ((__nothrow__)); extern double __tanh (double __x) __attribute__ ((__nothrow__));
>
># 87 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern double acosh (double __x) __attribute__ ((__nothrow__)); extern double __acosh (double __x) __attribute__ ((__nothrow__));
>
>extern double asinh (double __x) __attribute__ ((__nothrow__)); extern double __asinh (double __x) __attribute__ ((__nothrow__));
>
>extern double atanh (double __x) __attribute__ ((__nothrow__)); extern double __atanh (double __x) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>extern double exp (double __x) __attribute__ ((__nothrow__)); extern double __exp (double __x) __attribute__ ((__nothrow__));
>
>
>extern double frexp (double __x, int *__exponent) __attribute__ ((__nothrow__)); extern double __frexp (double __x, int *__exponent) __attribute__ ((__nothrow__));
>
>
>extern double ldexp (double __x, int __exponent) __attribute__ ((__nothrow__)); extern double __ldexp (double __x, int __exponent) __attribute__ ((__nothrow__));
>
>
>extern double log (double __x) __attribute__ ((__nothrow__)); extern double __log (double __x) __attribute__ ((__nothrow__));
>
>
>extern double log10 (double __x) __attribute__ ((__nothrow__)); extern double __log10 (double __x) __attribute__ ((__nothrow__));
>
>
>extern double modf (double __x, double *__iptr) __attribute__ ((__nothrow__)); extern double __modf (double __x, double *__iptr) __attribute__ ((__nothrow__));
>
># 127 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern double expm1 (double __x) __attribute__ ((__nothrow__)); extern double __expm1 (double __x) __attribute__ ((__nothrow__));
>
>
>extern double log1p (double __x) __attribute__ ((__nothrow__)); extern double __log1p (double __x) __attribute__ ((__nothrow__));
>
>
>extern double logb (double __x) __attribute__ ((__nothrow__)); extern double __logb (double __x) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern double exp2 (double __x) __attribute__ ((__nothrow__)); extern double __exp2 (double __x) __attribute__ ((__nothrow__));
>
>
>extern double log2 (double __x) __attribute__ ((__nothrow__)); extern double __log2 (double __x) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>extern double pow (double __x, double __y) __attribute__ ((__nothrow__)); extern double __pow (double __x, double __y) __attribute__ ((__nothrow__));
>
>
>extern double sqrt (double __x) __attribute__ ((__nothrow__)); extern double __sqrt (double __x) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern double hypot (double __x, double __y) __attribute__ ((__nothrow__)); extern double __hypot (double __x, double __y) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern double cbrt (double __x) __attribute__ ((__nothrow__)); extern double __cbrt (double __x) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>extern double ceil (double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern double __ceil (double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern double fabs (double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern double __fabs (double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern double floor (double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern double __floor (double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern double fmod (double __x, double __y) __attribute__ ((__nothrow__)); extern double __fmod (double __x, double __y) __attribute__ ((__nothrow__));
>
>
>
>
>extern int __isinf (double __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern int __finite (double __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>
>
>extern int isinf (double __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern int finite (double __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern double drem (double __x, double __y) __attribute__ ((__nothrow__)); extern double __drem (double __x, double __y) __attribute__ ((__nothrow__));
>
>
>
>extern double significand (double __x) __attribute__ ((__nothrow__)); extern double __significand (double __x) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern double copysign (double __x, double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern double __copysign (double __x, double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>
>
>
>extern double nan (__const char *__tagb) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern double __nan (__const char *__tagb) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnan (double __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>extern int isnan (double __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern double j0 (double) __attribute__ ((__nothrow__)); extern double __j0 (double) __attribute__ ((__nothrow__));
>extern double j1 (double) __attribute__ ((__nothrow__)); extern double __j1 (double) __attribute__ ((__nothrow__));
>extern double jn (int, double) __attribute__ ((__nothrow__)); extern double __jn (int, double) __attribute__ ((__nothrow__));
>extern double y0 (double) __attribute__ ((__nothrow__)); extern double __y0 (double) __attribute__ ((__nothrow__));
>extern double y1 (double) __attribute__ ((__nothrow__)); extern double __y1 (double) __attribute__ ((__nothrow__));
>extern double yn (int, double) __attribute__ ((__nothrow__)); extern double __yn (int, double) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern double erf (double) __attribute__ ((__nothrow__)); extern double __erf (double) __attribute__ ((__nothrow__));
>extern double erfc (double) __attribute__ ((__nothrow__)); extern double __erfc (double) __attribute__ ((__nothrow__));
>extern double lgamma (double) __attribute__ ((__nothrow__)); extern double __lgamma (double) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern double tgamma (double) __attribute__ ((__nothrow__)); extern double __tgamma (double) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern double gamma (double) __attribute__ ((__nothrow__)); extern double __gamma (double) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern double lgamma_r (double, int *__signgamp) __attribute__ ((__nothrow__)); extern double __lgamma_r (double, int *__signgamp) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>extern double rint (double __x) __attribute__ ((__nothrow__)); extern double __rint (double __x) __attribute__ ((__nothrow__));
>
>
>extern double nextafter (double __x, double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>extern double nexttoward (double __x, long double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>extern double remainder (double __x, double __y) __attribute__ ((__nothrow__)); extern double __remainder (double __x, double __y) __attribute__ ((__nothrow__));
>
>
>
>extern double scalbn (double __x, int __n) __attribute__ ((__nothrow__)); extern double __scalbn (double __x, int __n) __attribute__ ((__nothrow__));
>
>
>
>extern int ilogb (double __x) __attribute__ ((__nothrow__)); extern int __ilogb (double __x) __attribute__ ((__nothrow__));
>
>
>
>
>extern double scalbln (double __x, long int __n) __attribute__ ((__nothrow__)); extern double __scalbln (double __x, long int __n) __attribute__ ((__nothrow__));
>
>
>
>extern double nearbyint (double __x) __attribute__ ((__nothrow__)); extern double __nearbyint (double __x) __attribute__ ((__nothrow__));
>
>
>
>extern double round (double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern double __round (double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>extern double trunc (double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern double __trunc (double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>
>extern double remquo (double __x, double __y, int *__quo) __attribute__ ((__nothrow__)); extern double __remquo (double __x, double __y, int *__quo) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern long int lrint (double __x) __attribute__ ((__nothrow__)); extern long int __lrint (double __x) __attribute__ ((__nothrow__));
>extern long long int llrint (double __x) __attribute__ ((__nothrow__)); extern long long int __llrint (double __x) __attribute__ ((__nothrow__));
>
>
>
>extern long int lround (double __x) __attribute__ ((__nothrow__)); extern long int __lround (double __x) __attribute__ ((__nothrow__));
>extern long long int llround (double __x) __attribute__ ((__nothrow__)); extern long long int __llround (double __x) __attribute__ ((__nothrow__));
>
>
>
>extern double fdim (double __x, double __y) __attribute__ ((__nothrow__)); extern double __fdim (double __x, double __y) __attribute__ ((__nothrow__));
>
>
>extern double fmax (double __x, double __y) __attribute__ ((__nothrow__)); extern double __fmax (double __x, double __y) __attribute__ ((__nothrow__));
>
>
>extern double fmin (double __x, double __y) __attribute__ ((__nothrow__)); extern double __fmin (double __x, double __y) __attribute__ ((__nothrow__));
>
>
>
>extern int __fpclassify (double __value) __attribute__ ((__nothrow__))
>     __attribute__ ((__const__));
>
>
>extern int __signbit (double __value) __attribute__ ((__nothrow__))
>     __attribute__ ((__const__));
>
>
>
>extern double fma (double __x, double __y, double __z) __attribute__ ((__nothrow__)); extern double __fma (double __x, double __y, double __z) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>extern double scalb (double __x, double __n) __attribute__ ((__nothrow__)); extern double __scalb (double __x, double __n) __attribute__ ((__nothrow__));
># 72 "/usr/include/math.h" 2 3 4
># 94 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 53 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern float acosf (float __x) __attribute__ ((__nothrow__)); extern float __acosf (float __x) __attribute__ ((__nothrow__));
>
>extern float asinf (float __x) __attribute__ ((__nothrow__)); extern float __asinf (float __x) __attribute__ ((__nothrow__));
>
>extern float atanf (float __x) __attribute__ ((__nothrow__)); extern float __atanf (float __x) __attribute__ ((__nothrow__));
>
>extern float atan2f (float __y, float __x) __attribute__ ((__nothrow__)); extern float __atan2f (float __y, float __x) __attribute__ ((__nothrow__));
>
>
>extern float cosf (float __x) __attribute__ ((__nothrow__)); extern float __cosf (float __x) __attribute__ ((__nothrow__));
>
>extern float sinf (float __x) __attribute__ ((__nothrow__)); extern float __sinf (float __x) __attribute__ ((__nothrow__));
>
>extern float tanf (float __x) __attribute__ ((__nothrow__)); extern float __tanf (float __x) __attribute__ ((__nothrow__));
>
>
>
>
>extern float coshf (float __x) __attribute__ ((__nothrow__)); extern float __coshf (float __x) __attribute__ ((__nothrow__));
>
>extern float sinhf (float __x) __attribute__ ((__nothrow__)); extern float __sinhf (float __x) __attribute__ ((__nothrow__));
>
>extern float tanhf (float __x) __attribute__ ((__nothrow__)); extern float __tanhf (float __x) __attribute__ ((__nothrow__));
>
># 87 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern float acoshf (float __x) __attribute__ ((__nothrow__)); extern float __acoshf (float __x) __attribute__ ((__nothrow__));
>
>extern float asinhf (float __x) __attribute__ ((__nothrow__)); extern float __asinhf (float __x) __attribute__ ((__nothrow__));
>
>extern float atanhf (float __x) __attribute__ ((__nothrow__)); extern float __atanhf (float __x) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>extern float expf (float __x) __attribute__ ((__nothrow__)); extern float __expf (float __x) __attribute__ ((__nothrow__));
>
>
>extern float frexpf (float __x, int *__exponent) __attribute__ ((__nothrow__)); extern float __frexpf (float __x, int *__exponent) __attribute__ ((__nothrow__));
>
>
>extern float ldexpf (float __x, int __exponent) __attribute__ ((__nothrow__)); extern float __ldexpf (float __x, int __exponent) __attribute__ ((__nothrow__));
>
>
>extern float logf (float __x) __attribute__ ((__nothrow__)); extern float __logf (float __x) __attribute__ ((__nothrow__));
>
>
>extern float log10f (float __x) __attribute__ ((__nothrow__)); extern float __log10f (float __x) __attribute__ ((__nothrow__));
>
>
>extern float modff (float __x, float *__iptr) __attribute__ ((__nothrow__)); extern float __modff (float __x, float *__iptr) __attribute__ ((__nothrow__));
>
># 127 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern float expm1f (float __x) __attribute__ ((__nothrow__)); extern float __expm1f (float __x) __attribute__ ((__nothrow__));
>
>
>extern float log1pf (float __x) __attribute__ ((__nothrow__)); extern float __log1pf (float __x) __attribute__ ((__nothrow__));
>
>
>extern float logbf (float __x) __attribute__ ((__nothrow__)); extern float __logbf (float __x) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern float exp2f (float __x) __attribute__ ((__nothrow__)); extern float __exp2f (float __x) __attribute__ ((__nothrow__));
>
>
>extern float log2f (float __x) __attribute__ ((__nothrow__)); extern float __log2f (float __x) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>extern float powf (float __x, float __y) __attribute__ ((__nothrow__)); extern float __powf (float __x, float __y) __attribute__ ((__nothrow__));
>
>
>extern float sqrtf (float __x) __attribute__ ((__nothrow__)); extern float __sqrtf (float __x) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern float hypotf (float __x, float __y) __attribute__ ((__nothrow__)); extern float __hypotf (float __x, float __y) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern float cbrtf (float __x) __attribute__ ((__nothrow__)); extern float __cbrtf (float __x) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>extern float ceilf (float __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern float __ceilf (float __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern float fabsf (float __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern float __fabsf (float __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern float floorf (float __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern float __floorf (float __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern float fmodf (float __x, float __y) __attribute__ ((__nothrow__)); extern float __fmodf (float __x, float __y) __attribute__ ((__nothrow__));
>
>
>
>
>extern int __isinff (float __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern int __finitef (float __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>
>
>extern int isinff (float __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern int finitef (float __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern float dremf (float __x, float __y) __attribute__ ((__nothrow__)); extern float __dremf (float __x, float __y) __attribute__ ((__nothrow__));
>
>
>
>extern float significandf (float __x) __attribute__ ((__nothrow__)); extern float __significandf (float __x) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern float copysignf (float __x, float __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>
>
>
>extern float nanf (__const char *__tagb) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern float __nanf (__const char *__tagb) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnanf (float __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>extern int isnanf (float __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern float j0f (float) __attribute__ ((__nothrow__)); extern float __j0f (float) __attribute__ ((__nothrow__));
>extern float j1f (float) __attribute__ ((__nothrow__)); extern float __j1f (float) __attribute__ ((__nothrow__));
>extern float jnf (int, float) __attribute__ ((__nothrow__)); extern float __jnf (int, float) __attribute__ ((__nothrow__));
>extern float y0f (float) __attribute__ ((__nothrow__)); extern float __y0f (float) __attribute__ ((__nothrow__));
>extern float y1f (float) __attribute__ ((__nothrow__)); extern float __y1f (float) __attribute__ ((__nothrow__));
>extern float ynf (int, float) __attribute__ ((__nothrow__)); extern float __ynf (int, float) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern float erff (float) __attribute__ ((__nothrow__)); extern float __erff (float) __attribute__ ((__nothrow__));
>extern float erfcf (float) __attribute__ ((__nothrow__)); extern float __erfcf (float) __attribute__ ((__nothrow__));
>extern float lgammaf (float) __attribute__ ((__nothrow__)); extern float __lgammaf (float) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern float tgammaf (float) __attribute__ ((__nothrow__)); extern float __tgammaf (float) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern float gammaf (float) __attribute__ ((__nothrow__)); extern float __gammaf (float) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern float lgammaf_r (float, int *__signgamp) __attribute__ ((__nothrow__)); extern float __lgammaf_r (float, int *__signgamp) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>extern float rintf (float __x) __attribute__ ((__nothrow__)); extern float __rintf (float __x) __attribute__ ((__nothrow__));
>
>
>extern float nextafterf (float __x, float __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>extern float nexttowardf (float __x, long double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>extern float remainderf (float __x, float __y) __attribute__ ((__nothrow__)); extern float __remainderf (float __x, float __y) __attribute__ ((__nothrow__));
>
>
>
>extern float scalbnf (float __x, int __n) __attribute__ ((__nothrow__)); extern float __scalbnf (float __x, int __n) __attribute__ ((__nothrow__));
>
>
>
>extern int ilogbf (float __x) __attribute__ ((__nothrow__)); extern int __ilogbf (float __x) __attribute__ ((__nothrow__));
>
>
>
>
>extern float scalblnf (float __x, long int __n) __attribute__ ((__nothrow__)); extern float __scalblnf (float __x, long int __n) __attribute__ ((__nothrow__));
>
>
>
>extern float nearbyintf (float __x) __attribute__ ((__nothrow__)); extern float __nearbyintf (float __x) __attribute__ ((__nothrow__));
>
>
>
>extern float roundf (float __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern float __roundf (float __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>extern float truncf (float __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern float __truncf (float __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>
>extern float remquof (float __x, float __y, int *__quo) __attribute__ ((__nothrow__)); extern float __remquof (float __x, float __y, int *__quo) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern long int lrintf (float __x) __attribute__ ((__nothrow__)); extern long int __lrintf (float __x) __attribute__ ((__nothrow__));
>extern long long int llrintf (float __x) __attribute__ ((__nothrow__)); extern long long int __llrintf (float __x) __attribute__ ((__nothrow__));
>
>
>
>extern long int lroundf (float __x) __attribute__ ((__nothrow__)); extern long int __lroundf (float __x) __attribute__ ((__nothrow__));
>extern long long int llroundf (float __x) __attribute__ ((__nothrow__)); extern long long int __llroundf (float __x) __attribute__ ((__nothrow__));
>
>
>
>extern float fdimf (float __x, float __y) __attribute__ ((__nothrow__)); extern float __fdimf (float __x, float __y) __attribute__ ((__nothrow__));
>
>
>extern float fmaxf (float __x, float __y) __attribute__ ((__nothrow__)); extern float __fmaxf (float __x, float __y) __attribute__ ((__nothrow__));
>
>
>extern float fminf (float __x, float __y) __attribute__ ((__nothrow__)); extern float __fminf (float __x, float __y) __attribute__ ((__nothrow__));
>
>
>
>extern int __fpclassifyf (float __value) __attribute__ ((__nothrow__))
>     __attribute__ ((__const__));
>
>
>extern int __signbitf (float __value) __attribute__ ((__nothrow__))
>     __attribute__ ((__const__));
>
>
>
>extern float fmaf (float __x, float __y, float __z) __attribute__ ((__nothrow__)); extern float __fmaf (float __x, float __y, float __z) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>extern float scalbf (float __x, float __n) __attribute__ ((__nothrow__)); extern float __scalbf (float __x, float __n) __attribute__ ((__nothrow__));
># 95 "/usr/include/math.h" 2 3 4
># 141 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 53 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern long double acosl (long double __x) __attribute__ ((__nothrow__)); extern long double __acosl (long double __x) __attribute__ ((__nothrow__));
>
>extern long double asinl (long double __x) __attribute__ ((__nothrow__)); extern long double __asinl (long double __x) __attribute__ ((__nothrow__));
>
>extern long double atanl (long double __x) __attribute__ ((__nothrow__)); extern long double __atanl (long double __x) __attribute__ ((__nothrow__));
>
>extern long double atan2l (long double __y, long double __x) __attribute__ ((__nothrow__)); extern long double __atan2l (long double __y, long double __x) __attribute__ ((__nothrow__));
>
>
>extern long double cosl (long double __x) __attribute__ ((__nothrow__)); extern long double __cosl (long double __x) __attribute__ ((__nothrow__));
>
>extern long double sinl (long double __x) __attribute__ ((__nothrow__)); extern long double __sinl (long double __x) __attribute__ ((__nothrow__));
>
>extern long double tanl (long double __x) __attribute__ ((__nothrow__)); extern long double __tanl (long double __x) __attribute__ ((__nothrow__));
>
>
>
>
>extern long double coshl (long double __x) __attribute__ ((__nothrow__)); extern long double __coshl (long double __x) __attribute__ ((__nothrow__));
>
>extern long double sinhl (long double __x) __attribute__ ((__nothrow__)); extern long double __sinhl (long double __x) __attribute__ ((__nothrow__));
>
>extern long double tanhl (long double __x) __attribute__ ((__nothrow__)); extern long double __tanhl (long double __x) __attribute__ ((__nothrow__));
>
># 87 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern long double acoshl (long double __x) __attribute__ ((__nothrow__)); extern long double __acoshl (long double __x) __attribute__ ((__nothrow__));
>
>extern long double asinhl (long double __x) __attribute__ ((__nothrow__)); extern long double __asinhl (long double __x) __attribute__ ((__nothrow__));
>
>extern long double atanhl (long double __x) __attribute__ ((__nothrow__)); extern long double __atanhl (long double __x) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>extern long double expl (long double __x) __attribute__ ((__nothrow__)); extern long double __expl (long double __x) __attribute__ ((__nothrow__));
>
>
>extern long double frexpl (long double __x, int *__exponent) __attribute__ ((__nothrow__)); extern long double __frexpl (long double __x, int *__exponent) __attribute__ ((__nothrow__));
>
>
>extern long double ldexpl (long double __x, int __exponent) __attribute__ ((__nothrow__)); extern long double __ldexpl (long double __x, int __exponent) __attribute__ ((__nothrow__));
>
>
>extern long double logl (long double __x) __attribute__ ((__nothrow__)); extern long double __logl (long double __x) __attribute__ ((__nothrow__));
>
>
>extern long double log10l (long double __x) __attribute__ ((__nothrow__)); extern long double __log10l (long double __x) __attribute__ ((__nothrow__));
>
>
>extern long double modfl (long double __x, long double *__iptr) __attribute__ ((__nothrow__)); extern long double __modfl (long double __x, long double *__iptr) __attribute__ ((__nothrow__));
>
># 127 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern long double expm1l (long double __x) __attribute__ ((__nothrow__)); extern long double __expm1l (long double __x) __attribute__ ((__nothrow__));
>
>
>extern long double log1pl (long double __x) __attribute__ ((__nothrow__)); extern long double __log1pl (long double __x) __attribute__ ((__nothrow__));
>
>
>extern long double logbl (long double __x) __attribute__ ((__nothrow__)); extern long double __logbl (long double __x) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern long double exp2l (long double __x) __attribute__ ((__nothrow__)); extern long double __exp2l (long double __x) __attribute__ ((__nothrow__));
>
>
>extern long double log2l (long double __x) __attribute__ ((__nothrow__)); extern long double __log2l (long double __x) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>extern long double powl (long double __x, long double __y) __attribute__ ((__nothrow__)); extern long double __powl (long double __x, long double __y) __attribute__ ((__nothrow__));
>
>
>extern long double sqrtl (long double __x) __attribute__ ((__nothrow__)); extern long double __sqrtl (long double __x) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern long double hypotl (long double __x, long double __y) __attribute__ ((__nothrow__)); extern long double __hypotl (long double __x, long double __y) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern long double cbrtl (long double __x) __attribute__ ((__nothrow__)); extern long double __cbrtl (long double __x) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>extern long double ceill (long double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern long double __ceill (long double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern long double fabsl (long double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern long double __fabsl (long double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern long double floorl (long double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern long double __floorl (long double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern long double fmodl (long double __x, long double __y) __attribute__ ((__nothrow__)); extern long double __fmodl (long double __x, long double __y) __attribute__ ((__nothrow__));
>
>
>
>
>extern int __isinfl (long double __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern int __finitel (long double __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>
>
>extern int isinfl (long double __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern int finitel (long double __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern long double dreml (long double __x, long double __y) __attribute__ ((__nothrow__)); extern long double __dreml (long double __x, long double __y) __attribute__ ((__nothrow__));
>
>
>
>extern long double significandl (long double __x) __attribute__ ((__nothrow__)); extern long double __significandl (long double __x) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern long double copysignl (long double __x, long double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>
>
>
>extern long double nanl (__const char *__tagb) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern long double __nanl (__const char *__tagb) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnanl (long double __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>extern int isnanl (long double __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern long double j0l (long double) __attribute__ ((__nothrow__)); extern long double __j0l (long double) __attribute__ ((__nothrow__));
>extern long double j1l (long double) __attribute__ ((__nothrow__)); extern long double __j1l (long double) __attribute__ ((__nothrow__));
>extern long double jnl (int, long double) __attribute__ ((__nothrow__)); extern long double __jnl (int, long double) __attribute__ ((__nothrow__));
>extern long double y0l (long double) __attribute__ ((__nothrow__)); extern long double __y0l (long double) __attribute__ ((__nothrow__));
>extern long double y1l (long double) __attribute__ ((__nothrow__)); extern long double __y1l (long double) __attribute__ ((__nothrow__));
>extern long double ynl (int, long double) __attribute__ ((__nothrow__)); extern long double __ynl (int, long double) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern long double erfl (long double) __attribute__ ((__nothrow__)); extern long double __erfl (long double) __attribute__ ((__nothrow__));
>extern long double erfcl (long double) __attribute__ ((__nothrow__)); extern long double __erfcl (long double) __attribute__ ((__nothrow__));
>extern long double lgammal (long double) __attribute__ ((__nothrow__)); extern long double __lgammal (long double) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern long double tgammal (long double) __attribute__ ((__nothrow__)); extern long double __tgammal (long double) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern long double gammal (long double) __attribute__ ((__nothrow__)); extern long double __gammal (long double) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern long double lgammal_r (long double, int *__signgamp) __attribute__ ((__nothrow__)); extern long double __lgammal_r (long double, int *__signgamp) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>extern long double rintl (long double __x) __attribute__ ((__nothrow__)); extern long double __rintl (long double __x) __attribute__ ((__nothrow__));
>
>
>extern long double nextafterl (long double __x, long double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>extern long double nexttowardl (long double __x, long double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>extern long double remainderl (long double __x, long double __y) __attribute__ ((__nothrow__)); extern long double __remainderl (long double __x, long double __y) __attribute__ ((__nothrow__));
>
>
>
>extern long double scalbnl (long double __x, int __n) __attribute__ ((__nothrow__)); extern long double __scalbnl (long double __x, int __n) __attribute__ ((__nothrow__));
>
>
>
>extern int ilogbl (long double __x) __attribute__ ((__nothrow__)); extern int __ilogbl (long double __x) __attribute__ ((__nothrow__));
>
>
>
>
>extern long double scalblnl (long double __x, long int __n) __attribute__ ((__nothrow__)); extern long double __scalblnl (long double __x, long int __n) __attribute__ ((__nothrow__));
>
>
>
>extern long double nearbyintl (long double __x) __attribute__ ((__nothrow__)); extern long double __nearbyintl (long double __x) __attribute__ ((__nothrow__));
>
>
>
>extern long double roundl (long double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern long double __roundl (long double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>extern long double truncl (long double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern long double __truncl (long double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>
>extern long double remquol (long double __x, long double __y, int *__quo) __attribute__ ((__nothrow__)); extern long double __remquol (long double __x, long double __y, int *__quo) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern long int lrintl (long double __x) __attribute__ ((__nothrow__)); extern long int __lrintl (long double __x) __attribute__ ((__nothrow__));
>extern long long int llrintl (long double __x) __attribute__ ((__nothrow__)); extern long long int __llrintl (long double __x) __attribute__ ((__nothrow__));
>
>
>
>extern long int lroundl (long double __x) __attribute__ ((__nothrow__)); extern long int __lroundl (long double __x) __attribute__ ((__nothrow__));
>extern long long int llroundl (long double __x) __attribute__ ((__nothrow__)); extern long long int __llroundl (long double __x) __attribute__ ((__nothrow__));
>
>
>
>extern long double fdiml (long double __x, long double __y) __attribute__ ((__nothrow__)); extern long double __fdiml (long double __x, long double __y) __attribute__ ((__nothrow__));
>
>
>extern long double fmaxl (long double __x, long double __y) __attribute__ ((__nothrow__)); extern long double __fmaxl (long double __x, long double __y) __attribute__ ((__nothrow__));
>
>
>extern long double fminl (long double __x, long double __y) __attribute__ ((__nothrow__)); extern long double __fminl (long double __x, long double __y) __attribute__ ((__nothrow__));
>
>
>
>extern int __fpclassifyl (long double __value) __attribute__ ((__nothrow__))
>     __attribute__ ((__const__));
>
>
>extern int __signbitl (long double __value) __attribute__ ((__nothrow__))
>     __attribute__ ((__const__));
>
>
>
>extern long double fmal (long double __x, long double __y, long double __z) __attribute__ ((__nothrow__)); extern long double __fmal (long double __x, long double __y, long double __z) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>extern long double scalbl (long double __x, long double __n) __attribute__ ((__nothrow__)); extern long double __scalbl (long double __x, long double __n) __attribute__ ((__nothrow__));
># 142 "/usr/include/math.h" 2 3 4
># 157 "/usr/include/math.h" 3 4
>extern int signgam;
># 198 "/usr/include/math.h" 3 4
>enum
>  {
>    FP_NAN,
>
>    FP_INFINITE,
>
>    FP_ZERO,
>
>    FP_SUBNORMAL,
>
>    FP_NORMAL
>
>  };
># 284 "/usr/include/math.h" 3 4
>typedef enum
>{
>  _IEEE_ = -1,
>  _SVID_,
>  _XOPEN_,
>  _POSIX_,
>  _ISOC_
>} _LIB_VERSION_TYPE;
>
>
>
>
>extern _LIB_VERSION_TYPE _LIB_VERSION;
># 309 "/usr/include/math.h" 3 4
>struct exception
>
>  {
>    int type;
>    char *name;
>    double arg1;
>    double arg2;
>    double retval;
>  };
>
>
>
>
>extern int matherr (struct exception *__exc);
># 409 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathinline.h" 1 3 4
># 35 "/usr/include/bits/mathinline.h" 3 4
>extern __inline int
>__attribute__ ((__nothrow__)) __signbitf (float __x)
>{
>  __extension__ union { float __f; int __i; } __u = { __f: __x };
>  return __u.__i < 0;
>}
>extern __inline int
>__attribute__ ((__nothrow__)) __signbit (double __x)
>{
>  __extension__ union { double __d; int __i[2]; } __u = { __d: __x };
>  return __u.__i[1] < 0;
>}
>extern __inline int
>__attribute__ ((__nothrow__)) __signbitl (long double __x)
>{
>  __extension__ union { long double __l; int __i[3]; } __u = { __l: __x };
>  return (__u.__i[2] & 0x8000) != 0;
>}
># 410 "/usr/include/math.h" 2 3 4
># 465 "/usr/include/math.h" 3 4
>
># 42 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/common.h" 2
># 55 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/common.h"
># 1 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/internal.h" 1
># 85 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/internal.h"
># 1 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/intreadwrite.h" 1
># 24 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/intreadwrite.h"
>struct unaligned_64 { uint64_t l; } __attribute__((packed));
>struct unaligned_32 { uint32_t l; } __attribute__((packed));
>struct unaligned_16 { uint16_t l; } __attribute__((packed));
># 86 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/internal.h" 2
># 1 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/bswap.h" 1
># 30 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/bswap.h"
># 1 "/usr/include/byteswap.h" 1 3 4
># 23 "/usr/include/byteswap.h" 3 4
># 1 "/usr/include/bits/byteswap.h" 1 3 4
># 28 "/usr/include/bits/byteswap.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/bits/byteswap.h" 2 3 4
># 24 "/usr/include/byteswap.h" 2 3 4
># 31 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/bswap.h" 2
># 87 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/internal.h" 2
>
># 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/stddef.h" 1 3 4
># 151 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/stddef.h" 3 4
>typedef long int ptrdiff_t;
># 89 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/internal.h" 2
># 137 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/internal.h"
># 1 "/usr/include/assert.h" 1 3 4
># 138 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/internal.h" 2
># 150 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/internal.h"
>extern const uint32_t ff_inverse[256];
># 180 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/internal.h"
>extern const uint8_t ff_sqrt_tab[128];
>
>static inline int ff_sqrt(int a)
>{
>    int ret=0;
>    int s, b;
>
>    if(a<128) return ff_sqrt_tab[a];
>
>    for(s=30; s>=0; s-=2){
>        ret+=ret;
>        b= (1+2*ret)<<s;
>        if(b<=a){
>            a-=b;
>            ret++;
>        }
>    }
>    return ret;
>}
># 56 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/common.h" 2
># 74 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/common.h"
># 1 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/mem.h" 1
># 40 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/mem.h"
>void *av_malloc(unsigned int size);
>
>
>
>
>
>
>void *av_realloc(void *ptr, unsigned int size);
>
>
>
>
>
>
>void av_free(void *ptr);
>
>void *av_mallocz(unsigned int size);
>char *av_strdup(const char *s);
>
>
>
>
>
>void av_freep(void *ptr);
># 75 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/common.h" 2
># 89 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/common.h"
>extern const uint8_t ff_log2_tab[256];
>
>static inline int av_log2(unsigned int v)
>{
>    int n;
>
>    n = 0;
>    if (v & 0xffff0000) {
>        v >>= 16;
>        n += 16;
>    }
>    if (v & 0xff00) {
>        v >>= 8;
>        n += 8;
>    }
>    n += ff_log2_tab[v];
>
>    return n;
>}
>
>static inline int av_log2_16bit(unsigned int v)
>{
>    int n;
>
>    n = 0;
>    if (v & 0xff00) {
>        v >>= 8;
>        n += 8;
>    }
>    n += ff_log2_tab[v];
>
>    return n;
>}
>
>
>static inline int mid_pred(int a, int b, int c)
>{
># 149 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/common.h"
>    if(a>b){
>        if(c>b){
>            if(c>a) b=a;
>            else b=c;
>        }
>    }else{
>        if(b>c){
>            if(c>a) b=c;
>            else b=a;
>        }
>    }
>    return b;
>
>}
># 171 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/common.h"
>static inline int av_clip(int a, int amin, int amax)
>{
>    if (a < amin) return amin;
>    else if (a > amax) return amax;
>    else return a;
>}
>
>
>
>
>
>
>static inline uint8_t av_clip_uint8(int a)
>{
>    if (a&(~255)) return (-a)>>31;
>    else return a;
>}
>
>
>int64_t ff_gcd(int64_t a, int64_t b);
>
>
>
>
>static inline int ff_get_fourcc(const char *s){
>
>    ((void) (0));
>
>
>    return (s[0]) + (s[1]<<8) + (s[2]<<16) + (s[3]<<24);
>}
># 272 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/common.h"
>static inline uint64_t read_time(void)
>{
>        uint64_t a, d;
>        asm volatile( "rdtsc\n\t"
>                : "=a" (a), "=d" (d)
>        );
>        return (d << 32) | (a & 0xffffffff);
>}
># 41 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/avutil.h" 2
># 1 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/mathematics.h" 1
># 24 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/mathematics.h"
># 1 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/rational.h" 1
># 35 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/rational.h"
>typedef struct AVRational{
>    int num;
>    int den;
>} AVRational;
>
>
>
>
>
>
>
>static inline int av_cmp_q(AVRational a, AVRational b){
>    const int64_t tmp= a.num * (int64_t)b.den - b.num * (int64_t)a.den;
>
>    if(tmp) return (tmp>>63)|1;
>    else return 0;
>}
>
>
>
>
>
>
>static inline double av_q2d(AVRational a){
>    return a.num / (double) a.den;
>}
># 72 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/rational.h"
>int av_reduce(int *dst_nom, int *dst_den, int64_t nom, int64_t den, int64_t max);
>
>
>
>
>
>
>
>AVRational av_mul_q(AVRational b, AVRational c);
>
>
>
>
>
>
>
>AVRational av_div_q(AVRational b, AVRational c);
>
>
>
>
>
>
>
>AVRational av_add_q(AVRational b, AVRational c);
>
>
>
>
>
>
>
>AVRational av_sub_q(AVRational b, AVRational c);
>
>
>
>
>
>
>
>AVRational av_d2q(double d, int max);
># 25 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/mathematics.h" 2
>
>enum AVRounding {
>    AV_ROUND_ZERO = 0,
>    AV_ROUND_INF = 1,
>    AV_ROUND_DOWN = 2,
>    AV_ROUND_UP = 3,
>    AV_ROUND_NEAR_INF = 5,
>};
>
>
>
>
>
>int64_t av_rescale(int64_t a, int64_t b, int64_t c);
>
>
>
>
>
>int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding);
>
>
>
>
>int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq);
># 42 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/avutil.h" 2
>
># 1 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/integer.h" 1
># 34 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/integer.h"
>typedef struct AVInteger{
>    uint16_t v[8];
>} AVInteger;
>
>AVInteger av_add_i(AVInteger a, AVInteger b);
>AVInteger av_sub_i(AVInteger a, AVInteger b);
>
>
>
>
>
>int av_log2_i(AVInteger a);
>AVInteger av_mul_i(AVInteger a, AVInteger b);
>
>
>
>
>int av_cmp_i(AVInteger a, AVInteger b);
>
>
>
>
>
>AVInteger av_shr_i(AVInteger a, int s);
>
>
>
>
>
>AVInteger av_mod_i(AVInteger *quot, AVInteger a, AVInteger b);
>
>
>
>
>AVInteger av_div_i(AVInteger a, AVInteger b);
>
>
>
>
>AVInteger av_int2i(int64_t a);
>
>
>
>
>
>
>int64_t av_i2int(AVInteger a);
># 44 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/avutil.h" 2
># 1 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/intfloat_readwrite.h" 1
># 27 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/intfloat_readwrite.h"
>typedef struct AVExtFloat {
>    uint8_t exponent[2];
>    uint8_t mantissa[8];
>} AVExtFloat;
>
>double av_int2dbl(int64_t v);
>float av_int2flt(int32_t v);
>double av_ext2dbl(const AVExtFloat ext);
>int64_t av_dbl2int(double d);
>int32_t av_flt2int(float d);
>AVExtFloat av_dbl2ext(double d);
># 45 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/avutil.h" 2
># 1 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/log.h" 1
># 24 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/log.h"
># 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/stdarg.h" 1 3 4
># 105 "/usr/lib/gcc/x86_64-pc-linux-gnu/3.4.6/include/stdarg.h" 3 4
>typedef __gnuc_va_list va_list;
># 25 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/log.h" 2
>
>
>
>
>typedef struct AVCLASS AVClass;
>struct AVCLASS {
>    const char* class_name;
>    const char* (*item_name)(void*);
>
>
>
>    const struct AVOption *option;
>};
># 84 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/log.h"
>extern int av_log_level;
># 101 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/log.h"
>extern void av_log(void*, int level, const char *fmt, ...) __attribute__ ((__format__ (__printf__, 3, 4)));
>
>
>
>
>
>extern void av_vlog(void*, int level, const char *fmt, va_list);
>extern int av_log_get_level(void);
>extern void av_log_set_level(int);
>extern void av_log_set_callback(void (*)(void*, int, const char*, va_list));
>extern void av_log_default_callback(void* ptr, int level, const char* fmt, va_list vl);
># 46 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/avutil.h" 2
># 65 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/avutil.h"
>enum PixelFormat {
>    PIX_FMT_NONE= -1,
>    PIX_FMT_YUV420P,
>    PIX_FMT_YUYV422,
>    PIX_FMT_RGB24,
>    PIX_FMT_BGR24,
>    PIX_FMT_YUV422P,
>    PIX_FMT_YUV444P,
>    PIX_FMT_RGB32,
>    PIX_FMT_YUV410P,
>    PIX_FMT_YUV411P,
>    PIX_FMT_RGB565,
>    PIX_FMT_RGB555,
>    PIX_FMT_GRAY8,
>    PIX_FMT_MONOWHITE,
>    PIX_FMT_MONOBLACK,
>    PIX_FMT_PAL8,
>    PIX_FMT_YUVJ420P,
>    PIX_FMT_YUVJ422P,
>    PIX_FMT_YUVJ444P,
>    PIX_FMT_XVMC_MPEG2_MC,
>    PIX_FMT_XVMC_MPEG2_IDCT,
>    PIX_FMT_UYVY422,
>    PIX_FMT_UYYVYY411,
>    PIX_FMT_BGR32,
>    PIX_FMT_BGR565,
>    PIX_FMT_BGR555,
>    PIX_FMT_BGR8,
>    PIX_FMT_BGR4,
>    PIX_FMT_BGR4_BYTE,
>    PIX_FMT_RGB8,
>    PIX_FMT_RGB4,
>    PIX_FMT_RGB4_BYTE,
>    PIX_FMT_NV12,
>    PIX_FMT_NV21,
>
>    PIX_FMT_RGB32_1,
>    PIX_FMT_BGR32_1,
>
>    PIX_FMT_GRAY16BE,
>    PIX_FMT_GRAY16LE,
>    PIX_FMT_NB,
>};
># 31 "avcodec.h" 2
># 58 "avcodec.h"
>enum CodecID {
>    CODEC_ID_NONE,
>    CODEC_ID_MPEG1VIDEO,
>    CODEC_ID_MPEG2VIDEO,
>    CODEC_ID_MPEG2VIDEO_XVMC,
>    CODEC_ID_H261,
>    CODEC_ID_H263,
>    CODEC_ID_RV10,
>    CODEC_ID_RV20,
>    CODEC_ID_MJPEG,
>    CODEC_ID_MJPEGB,
>    CODEC_ID_LJPEG,
>    CODEC_ID_SP5X,
>    CODEC_ID_JPEGLS,
>    CODEC_ID_MPEG4,
>    CODEC_ID_RAWVIDEO,
>    CODEC_ID_MSMPEG4V1,
>    CODEC_ID_MSMPEG4V2,
>    CODEC_ID_MSMPEG4V3,
>    CODEC_ID_WMV1,
>    CODEC_ID_WMV2,
>    CODEC_ID_H263P,
>    CODEC_ID_H263I,
>    CODEC_ID_FLV1,
>    CODEC_ID_SVQ1,
>    CODEC_ID_SVQ3,
>    CODEC_ID_DVVIDEO,
>    CODEC_ID_HUFFYUV,
>    CODEC_ID_CYUV,
>    CODEC_ID_H264,
>    CODEC_ID_INDEO3,
>    CODEC_ID_VP3,
>    CODEC_ID_THEORA,
>    CODEC_ID_ASV1,
>    CODEC_ID_ASV2,
>    CODEC_ID_FFV1,
>    CODEC_ID_4XM,
>    CODEC_ID_VCR1,
>    CODEC_ID_CLJR,
>    CODEC_ID_MDEC,
>    CODEC_ID_ROQ,
>    CODEC_ID_INTERPLAY_VIDEO,
>    CODEC_ID_XAN_WC3,
>    CODEC_ID_XAN_WC4,
>    CODEC_ID_RPZA,
>    CODEC_ID_CINEPAK,
>    CODEC_ID_WS_VQA,
>    CODEC_ID_MSRLE,
>    CODEC_ID_MSVIDEO1,
>    CODEC_ID_IDCIN,
>    CODEC_ID_8BPS,
>    CODEC_ID_SMC,
>    CODEC_ID_FLIC,
>    CODEC_ID_TRUEMOTION1,
>    CODEC_ID_VMDVIDEO,
>    CODEC_ID_MSZH,
>    CODEC_ID_ZLIB,
>    CODEC_ID_QTRLE,
>    CODEC_ID_SNOW,
>    CODEC_ID_TSCC,
>    CODEC_ID_ULTI,
>    CODEC_ID_QDRAW,
>    CODEC_ID_VIXL,
>    CODEC_ID_QPEG,
>    CODEC_ID_XVID,
>    CODEC_ID_PNG,
>    CODEC_ID_PPM,
>    CODEC_ID_PBM,
>    CODEC_ID_PGM,
>    CODEC_ID_PGMYUV,
>    CODEC_ID_PAM,
>    CODEC_ID_FFVHUFF,
>    CODEC_ID_RV30,
>    CODEC_ID_RV40,
>    CODEC_ID_VC1,
>    CODEC_ID_WMV3,
>    CODEC_ID_LOCO,
>    CODEC_ID_WNV1,
>    CODEC_ID_AASC,
>    CODEC_ID_INDEO2,
>    CODEC_ID_FRAPS,
>    CODEC_ID_TRUEMOTION2,
>    CODEC_ID_BMP,
>    CODEC_ID_CSCD,
>    CODEC_ID_MMVIDEO,
>    CODEC_ID_ZMBV,
>    CODEC_ID_AVS,
>    CODEC_ID_SMACKVIDEO,
>    CODEC_ID_NUV,
>    CODEC_ID_KMVC,
>    CODEC_ID_FLASHSV,
>    CODEC_ID_CAVS,
>    CODEC_ID_JPEG2000,
>    CODEC_ID_VMNC,
>    CODEC_ID_VP5,
>    CODEC_ID_VP6,
>    CODEC_ID_VP6F,
>    CODEC_ID_TARGA,
>    CODEC_ID_DSICINVIDEO,
>    CODEC_ID_TIERTEXSEQVIDEO,
>    CODEC_ID_TIFF,
>    CODEC_ID_GIF,
>    CODEC_ID_FFH264,
>    CODEC_ID_DXA,
>    CODEC_ID_DNXHD,
>    CODEC_ID_THP,
>    CODEC_ID_SGI,
>    CODEC_ID_C93,
>    CODEC_ID_BETHSOFTVID,
>    CODEC_ID_PTX,
>    CODEC_ID_TXD,
>
>
>    CODEC_ID_PCM_S16LE= 0x10000,
>    CODEC_ID_PCM_S16BE,
>    CODEC_ID_PCM_U16LE,
>    CODEC_ID_PCM_U16BE,
>    CODEC_ID_PCM_S8,
>    CODEC_ID_PCM_U8,
>    CODEC_ID_PCM_MULAW,
>    CODEC_ID_PCM_ALAW,
>    CODEC_ID_PCM_S32LE,
>    CODEC_ID_PCM_S32BE,
>    CODEC_ID_PCM_U32LE,
>    CODEC_ID_PCM_U32BE,
>    CODEC_ID_PCM_S24LE,
>    CODEC_ID_PCM_S24BE,
>    CODEC_ID_PCM_U24LE,
>    CODEC_ID_PCM_U24BE,
>    CODEC_ID_PCM_S24DAUD,
>
>
>    CODEC_ID_ADPCM_IMA_QT= 0x11000,
>    CODEC_ID_ADPCM_IMA_WAV,
>    CODEC_ID_ADPCM_IMA_DK3,
>    CODEC_ID_ADPCM_IMA_DK4,
>    CODEC_ID_ADPCM_IMA_WS,
>    CODEC_ID_ADPCM_IMA_SMJPEG,
>    CODEC_ID_ADPCM_MS,
>    CODEC_ID_ADPCM_4XM,
>    CODEC_ID_ADPCM_XA,
>    CODEC_ID_ADPCM_ADX,
>    CODEC_ID_ADPCM_EA,
>    CODEC_ID_ADPCM_G726,
>    CODEC_ID_ADPCM_CT,
>    CODEC_ID_ADPCM_SWF,
>    CODEC_ID_ADPCM_YAMAHA,
>    CODEC_ID_ADPCM_SBPRO_4,
>    CODEC_ID_ADPCM_SBPRO_3,
>    CODEC_ID_ADPCM_SBPRO_2,
>    CODEC_ID_ADPCM_THP,
>
>
>    CODEC_ID_AMR_NB= 0x12000,
>    CODEC_ID_AMR_WB,
>
>
>    CODEC_ID_RA_144= 0x13000,
>    CODEC_ID_RA_288,
>
>
>    CODEC_ID_ROQ_DPCM= 0x14000,
>    CODEC_ID_INTERPLAY_DPCM,
>    CODEC_ID_XAN_DPCM,
>    CODEC_ID_SOL_DPCM,
>
>    CODEC_ID_MP2= 0x15000,
>    CODEC_ID_MP3,
>    CODEC_ID_AAC,
>
>    CODEC_ID_MPEG4AAC,
>
>    CODEC_ID_AC3,
>    CODEC_ID_DTS,
>    CODEC_ID_VORBIS,
>    CODEC_ID_DVAUDIO,
>    CODEC_ID_WMAV1,
>    CODEC_ID_WMAV2,
>    CODEC_ID_MACE3,
>    CODEC_ID_MACE6,
>    CODEC_ID_VMDAUDIO,
>    CODEC_ID_SONIC,
>    CODEC_ID_SONIC_LS,
>    CODEC_ID_FLAC,
>    CODEC_ID_MP3ADU,
>    CODEC_ID_MP3ON4,
>    CODEC_ID_SHORTEN,
>    CODEC_ID_ALAC,
>    CODEC_ID_WESTWOOD_SND1,
>    CODEC_ID_GSM,
>    CODEC_ID_QDM2,
>    CODEC_ID_COOK,
>    CODEC_ID_TRUESPEECH,
>    CODEC_ID_TTA,
>    CODEC_ID_SMACKAUDIO,
>    CODEC_ID_QCELP,
>    CODEC_ID_WAVPACK,
>    CODEC_ID_DSICINAUDIO,
>    CODEC_ID_IMC,
>    CODEC_ID_MUSEPACK7,
>    CODEC_ID_MLP,
>    CODEC_ID_GSM_MS,
>    CODEC_ID_ATRAC3,
>
>
>    CODEC_ID_DVD_SUBTITLE= 0x17000,
>    CODEC_ID_DVB_SUBTITLE,
>
>    CODEC_ID_MPEG2TS= 0x20000,
>
>};
>
>
>
>
>
>
>
>enum CodecType {
>    CODEC_TYPE_UNKNOWN = -1,
>    CODEC_TYPE_VIDEO,
>    CODEC_TYPE_AUDIO,
>    CODEC_TYPE_DATA,
>    CODEC_TYPE_SUBTITLE,
>    CODEC_TYPE_NB
>};
>
>
>
>enum SampleFormat {
>    SAMPLE_FMT_NONE = -1,
>    SAMPLE_FMT_U8,
>    SAMPLE_FMT_S16,
>    SAMPLE_FMT_S24,
>    SAMPLE_FMT_S32,
>    SAMPLE_FMT_FLT,
>};
># 315 "avcodec.h"
>enum Motion_Est_ID {
>    ME_ZERO = 1,
>    ME_FULL,
>    ME_LOG,
>    ME_PHODS,
>    ME_EPZS,
>    ME_X1,
>    ME_HEX,
>    ME_UMH,
>    ME_ITER,
>};
>
>enum AVDiscard{
>
>
>    AVDISCARD_NONE =-16,
>    AVDISCARD_DEFAULT= 0,
>    AVDISCARD_NONREF = 8,
>    AVDISCARD_BIDIR = 16,
>    AVDISCARD_NONKEY = 32,
>    AVDISCARD_ALL = 48,
>};
>
>typedef struct RcOverride{
>    int start_frame;
>    int end_frame;
>    int qscale;
>    float quality_factor;
>} RcOverride;
># 468 "avcodec.h"
>typedef struct AVPanScan{
>
>
>
>
>
>    int id;
>
>
>
>
>
>
>    int width;
>    int height;
>
>
>
>
>
>
>    int16_t position[3][2];
>}AVPanScan;
># 725 "avcodec.h"
>typedef struct AVFrame {
>    uint8_t *data[4]; int linesize[4]; uint8_t *base[4]; int key_frame; int pict_type; int64_t pts; int coded_picture_number; int display_picture_number; int quality; int age; int reference; int8_t *qscale_table; int qstride; uint8_t *mbskip_table; int16_t (*motion_val[2])[2]; uint32_t *mb_type; uint8_t motion_subsample_log2; void *opaque; uint64_t error[4]; int type; int repeat_pict; int qscale_type; int interlaced_frame; int top_field_first; AVPanScan *pan_scan; int palette_has_changed; int buffer_hints; short *dct_coeff; int8_t *ref_index[2];
>} AVFrame;
>
>
>
>
>
>
>typedef struct AVCodecContext {
>
>
>
>
>    AVClass *av_class;
>
>
>
>
>
>    int bit_rate;
>
>
>
>
>
>
>
>    int bit_rate_tolerance;
>
>
>
>
>
>
>    int flags;
># 770 "avcodec.h"
>    int sub_id;
># 779 "avcodec.h"
>    int me_method;
># 792 "avcodec.h"
>    uint8_t *extradata;
>    int extradata_size;
># 803 "avcodec.h"
>    AVRational time_base;
># 813 "avcodec.h"
>    int width, height;
># 822 "avcodec.h"
>    int gop_size;
>
>
>
>
>
>
>    enum PixelFormat pix_fmt;
>
>
>
>
>
>
>
>    int rate_emu;
># 851 "avcodec.h"
>    void (*draw_horiz_band)(struct AVCodecContext *s,
>                            const AVFrame *src, int offset[4],
>                            int y, int type, int height);
>
>
>    int sample_rate;
>    int channels;
>
>
>
>
>
>
>    enum SampleFormat sample_fmt;
>
>
>
>
>
>    int frame_size;
>    int frame_number;
>    int real_pict_num;
>
>
>
>
>
>
>
>    int delay;
>
>
>    float qcompress;
>    float qblur;
>
>
>
>
>
>
>    int qmin;
>
>
>
>
>
>
>    int qmax;
>
>
>
>
>
>
>    int max_qdiff;
>
>
>
>
>
>
>
>    int max_b_frames;
>
>
>
>
>
>
>    float b_quant_factor;
>
>
>    int rc_strategy;
>
>
>    int b_frame_strategy;
>
>
>
>
>
>
>
>    int hurry_up;
>
>    struct AVCodec *codec;
>
>    void *priv_data;
>
>
>
>    int rtp_mode;
>
>
>    int rtp_payload_size;
># 959 "avcodec.h"
>    void (*rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb);
>
>
>    int mv_bits;
>    int header_bits;
>    int i_tex_bits;
>    int p_tex_bits;
>    int i_count;
>    int p_count;
>    int skip_count;
>    int misc_bits;
>
>
>
>
>
>
>    int frame_bits;
>
>
>
>
>
>
>    void *opaque;
>
>    char codec_name[32];
>    enum CodecType codec_type;
>    enum CodecID codec_id;
># 1002 "avcodec.h"
>    unsigned int codec_tag;
>
>
>
>
>
>
>    int workaround_bugs;
># 1032 "avcodec.h"
>    int luma_elim_threshold;
>
>
>
>
>
>
>    int chroma_elim_threshold;
>
>
>
>
>
>
>    int strict_std_compliance;
># 1060 "avcodec.h"
>    float b_quant_offset;
>
>
>
>
>
>
>
>    int error_resilience;
># 1082 "avcodec.h"
>    int (*get_buffer)(struct AVCodecContext *c, AVFrame *pic);
># 1091 "avcodec.h"
>    void (*release_buffer)(struct AVCodecContext *c, AVFrame *pic);
>
>
>
>
>
>
>    int has_b_frames;
>
>
>
>
>
>    int block_align;
>
>    int parse_only;
># 1115 "avcodec.h"
>    int mpeg_quant;
>
>
>
>
>
>
>    char *stats_out;
>
>
>
>
>
>
>
>    char *stats_in;
>
>
>
>
>
>
>
>    float rc_qsquish;
>
>    float rc_qmod_amp;
>    int rc_qmod_freq;
>
>
>
>
>
>
>    RcOverride *rc_override;
>    int rc_override_count;
>
>
>
>
>
>
>    char *rc_eq;
>
>
>
>
>
>
>    int rc_max_rate;
>
>
>
>
>
>
>    int rc_min_rate;
>
>
>
>
>
>
>    int rc_buffer_size;
>    float rc_buffer_aggressivity;
># 1187 "avcodec.h"
>    float i_quant_factor;
>
>
>
>
>
>
>    float i_quant_offset;
>
>
>
>
>
>
>    float rc_initial_cplx;
>
>
>
>
>
>
>    int dct_algo;
># 1222 "avcodec.h"
>    float lumi_masking;
>
>
>
>
>
>
>    float temporal_cplx_masking;
>
>
>
>
>
>
>    float spatial_cplx_masking;
>
>
>
>
>
>
>    float p_masking;
>
>
>
>
>
>
>    float dark_masking;
>
>
>
>    int unused;
>
>
>
>
>
>
>    int idct_algo;
># 1286 "avcodec.h"
>    int slice_count;
>
>
>
>
>
>    int *slice_offset;
>
>
>
>
>
>
>    int error_concealment;
># 1311 "avcodec.h"
>    unsigned dsp_mask;
># 1329 "avcodec.h"
>     int bits_per_sample;
>
>
>
>
>
>
>     int prediction_method;
># 1347 "avcodec.h"
>    AVRational sample_aspect_ratio;
>
>
>
>
>
>
>    AVFrame *coded_frame;
>
>
>
>
>
>
>    int debug;
># 1383 "avcodec.h"
>    int debug_mv;
># 1393 "avcodec.h"
>    uint64_t error[4];
>
>
>
>
>
>
>    int mb_qmin;
>
>
>
>
>
>
>    int mb_qmax;
>
>
>
>
>
>
>    int me_cmp;
>
>
>
>
>
>    int me_sub_cmp;
>
>
>
>
>
>    int mb_cmp;
>
>
>
>
>
>    int ildct_cmp;
># 1455 "avcodec.h"
>    int dia_size;
>
>
>
>
>
>
>    int last_predictor_count;
>
>
>
>
>
>
>    int pre_me;
>
>
>
>
>
>
>    int me_pre_cmp;
>
>
>
>
>
>
>    int pre_dia_size;
>
>
>
>
>
>
>    int me_subpel_quality;
># 1501 "avcodec.h"
>    enum PixelFormat (*get_format)(struct AVCodecContext *s, const enum PixelFormat * fmt);
># 1511 "avcodec.h"
>    int dtg_active_format;
># 1527 "avcodec.h"
>    int me_range;
>
>
>
>
>
>
>    int intra_quant_bias;
>
>
>
>
>
>
>
>    int inter_quant_bias;
>
>
>
>
>
>
>
>    int color_table_id;
>
>
>
>
>
>    int internal_buffer_count;
>
>
>
>
>
>    void *internal_buffer;
># 1576 "avcodec.h"
>    int global_quality;
># 1588 "avcodec.h"
>    int coder_type;
>
>
>
>
>
>
>    int context_model;
># 1610 "avcodec.h"
>    int slice_flags;
># 1620 "avcodec.h"
>    int xvmc_acceleration;
>
>
>
>
>
>
>    int mb_decision;
># 1637 "avcodec.h"
>    uint16_t *intra_matrix;
>
>
>
>
>
>
>    uint16_t *inter_matrix;
>
>
>
>
>
>
>
>    unsigned int stream_codec_tag;
>
>
>
>
>
>
>
>    int scenechange_threshold;
>
>
>
>
>
>
>    int lmin;
>
>
>
>
>
>
>    int lmax;
>
>
>
>
>
>
>    struct AVPaletteControl *palctrl;
>
>
>
>
>
>
>    int noise_reduction;
># 1699 "avcodec.h"
>    int (*reget_buffer)(struct AVCodecContext *c, AVFrame *pic);
>
>
>
>
>
>
>    int rc_initial_buffer_occupancy;
>
>
>
>
>
>
>    int inter_threshold;
>
>
>
>
>
>
>    int flags2;
>
>
>
>
>
>
>    int error_rate;
>
>
>
>
>
>
>    int antialias_algo;
># 1744 "avcodec.h"
>    int quantizer_noise_shaping;
>
>
>
>
>
>
>
>    int thread_count;
># 1763 "avcodec.h"
>    int (*execute)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg), void **arg2, int *ret, int count);
>
>
>
>
>
>
>
>    void *thread_opaque;
># 1780 "avcodec.h"
>     int me_threshold;
>
>
>
>
>
>
>     int mb_threshold;
>
>
>
>
>
>
>     int intra_dc_precision;
>
>
>
>
>
>
>     int nsse_weight;
>
>
>
>
>
>
>     int skip_top;
>
>
>
>
>
>
>     int skip_bottom;
>
>
>
>
>
>
>     int profile;
># 1834 "avcodec.h"
>     int level;
>
>
>
>
>
>
>
>     int lowres;
>
>
>
>
>
>
>
>    int coded_width, coded_height;
>
>
>
>
>
>
>    int frame_skip_threshold;
>
>
>
>
>
>
>    int frame_skip_factor;
>
>
>
>
>
>
>    int frame_skip_exp;
>
>
>
>
>
>
>    int frame_skip_cmp;
>
>
>
>
>
>
>
>    float border_masking;
>
>
>
>
>
>
>    int mb_lmin;
>
>
>
>
>
>
>    int mb_lmax;
>
>
>
>
>
>
>    int me_penalty_compensation;
>
>
>
>
>
>
>    enum AVDiscard skip_loop_filter;
>
>
>
>
>
>
>    enum AVDiscard skip_idct;
>
>
>
>
>
>
>    enum AVDiscard skip_frame;
>
>
>
>
>
>
>    int bidir_refine;
>
>
>
>
>
>
>    int brd_scale;
>
>
>
>
>
>
>    float crf;
>
>
>
>
>
>
>    int cqp;
>
>
>
>
>
>
>    int keyint_min;
>
>
>
>
>
>
>    int refs;
>
>
>
>
>
>
>    int chromaoffset;
>
>
>
>
>
>
>    int bframebias;
>
>
>
>
>
>
>    int trellis;
>
>
>
>
>
>
>    float complexityblur;
>
>
>
>
>
>
>
>    int deblockalpha;
>
>
>
>
>
>
>
>    int deblockbeta;
>
>
>
>
>
>
>    int partitions;
># 2033 "avcodec.h"
>    int directpred;
>
>
>
>
>
>
>    int cutoff;
>
>
>
>
>
>
>    int scenechange_factor;
>
>
>
>
>
>
>
>    int mv0_threshold;
>
>
>
>
>
>
>    int b_sensitivity;
>
>
>
>
>
>    int compression_level;
>
>
>
>
>
>
>
>    int use_lpc;
>
>
>
>
>
>
>    int lpc_coeff_precision;
>
>
>
>
>
>    int min_prediction_order;
>
>
>
>
>
>    int max_prediction_order;
>
>
>
>
>
>
>    int prediction_order_method;
>
>
>
>
>
>    int min_partition_order;
>
>
>
>
>
>    int max_partition_order;
>
>
>
>
>
>
>    int64_t timecode_frame_start;
>} AVCodecContext;
>
>
>
>
>typedef struct AVCodec {
>
>
>
>
>
>
>    const char *name;
>    enum CodecType type;
>    enum CodecID id;
>    int priv_data_size;
>    int (*init)(AVCodecContext *);
>    int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data);
>    int (*close)(AVCodecContext *);
>    int (*decode)(AVCodecContext *, void *outdata, int *outdata_size,
>                  uint8_t *buf, int buf_size);
>    int capabilities;
>    struct AVCodec *next;
>    void (*flush)(AVCodecContext *);
>    const AVRational *supported_framerates;
>    const enum PixelFormat *pix_fmts;
>} AVCodec;
>
>
>
>
>
>typedef struct AVPicture {
>    uint8_t *data[4];
>    int linesize[4];
>} AVPicture;
># 2169 "avcodec.h"
>typedef struct AVPaletteControl {
>
>
>
>    int palette_changed;
>
>
>
>
>
>    unsigned int palette[256];
>
>} AVPaletteControl __attribute__((deprecated));
>
>typedef struct AVSubtitleRect {
>    uint16_t x;
>    uint16_t y;
>    uint16_t w;
>    uint16_t h;
>    uint16_t nb_colors;
>    int linesize;
>    uint32_t *rgba_palette;
>    uint8_t *bitmap;
>} AVSubtitleRect;
>
>typedef struct AVSubtitle {
>    uint16_t format;
>    uint32_t start_display_time;
>    uint32_t end_display_time;
>    uint32_t num_rects;
>    AVSubtitleRect *rects;
>} AVSubtitle;
>
>
>
>
>struct ReSampleContext;
>struct AVResampleContext;
>
>typedef struct ReSampleContext ReSampleContext;
>
>ReSampleContext *audio_resample_init(int output_channels, int input_channels,
>                                     int output_rate, int input_rate);
>int audio_resample(ReSampleContext *s, short *output, short *input, int nb_samples);
>void audio_resample_close(ReSampleContext *s);
>
>struct AVResampleContext *av_resample_init(int out_rate, int in_rate, int filter_length, int log2_phase_count, int linear, double cutoff);
>int av_resample(struct AVResampleContext *c, short *dst, short *src, int *consumed, int src_size, int dst_size, int update_ctx);
>void av_resample_compensate(struct AVResampleContext *c, int sample_delta, int compensation_distance);
>void av_resample_close(struct AVResampleContext *c);
>
>
>
>
>
>
>
>struct ImgReSampleContext __attribute__((deprecated));
>
>
>
>
>typedef struct ImgReSampleContext ImgReSampleContext __attribute__((deprecated));
>
>
>
>
>__attribute__((deprecated)) ImgReSampleContext *img_resample_init(int output_width, int output_height,
>                                      int input_width, int input_height);
>
>
>
>
>__attribute__((deprecated)) ImgReSampleContext *img_resample_full_init(int owidth, int oheight,
>                                      int iwidth, int iheight,
>                                      int topBand, int bottomBand,
>                                      int leftBand, int rightBand,
>                                      int padtop, int padbottom,
>                                      int padleft, int padright);
>
>
>
>
>__attribute__((deprecated)) void img_resample(ImgReSampleContext *s,
>                  AVPicture *output, const AVPicture *input);
>
>
>
>
>__attribute__((deprecated)) void img_resample_close(ImgReSampleContext *s);
># 2271 "avcodec.h"
>int avpicture_alloc(AVPicture *picture, int pix_fmt, int width, int height);
>
>
>
>
>
>
>void avpicture_free(AVPicture *picture);
># 2296 "avcodec.h"
>int avpicture_fill(AVPicture *picture, uint8_t *ptr,
>                   int pix_fmt, int width, int height);
>int avpicture_layout(const AVPicture* src, int pix_fmt, int width, int height,
>                     unsigned char *dest, int dest_size);
># 2310 "avcodec.h"
>int avpicture_get_size(int pix_fmt, int width, int height);
>void avcodec_get_chroma_sub_sample(int pix_fmt, int *h_shift, int *v_shift);
>const char *avcodec_get_pix_fmt_name(int pix_fmt);
>void avcodec_set_dimensions(AVCodecContext *s, int width, int height);
>enum PixelFormat avcodec_get_pix_fmt(const char* name);
>unsigned int avcodec_pix_fmt_to_codec_tag(enum PixelFormat p);
># 2341 "avcodec.h"
>int avcodec_get_pix_fmt_loss(int dst_pix_fmt, int src_pix_fmt,
>                             int has_alpha);
># 2366 "avcodec.h"
>int avcodec_find_best_pix_fmt(int pix_fmt_mask, int src_pix_fmt,
>                              int has_alpha, int *loss_ptr);
># 2380 "avcodec.h"
>void avcodec_pix_fmt_string (char *buf, int buf_size, int pix_fmt);
># 2389 "avcodec.h"
>int img_get_alpha_info(const AVPicture *src,
>                       int pix_fmt, int width, int height);
>
>
>
>
>
>
>__attribute__((deprecated)) int img_convert(AVPicture *dst, int dst_pix_fmt,
>                const AVPicture *src, int pix_fmt,
>                int width, int height);
>
>
>
>
>int avpicture_deinterlace(AVPicture *dst, const AVPicture *src,
>                          int pix_fmt, int width, int height);
>
>
>
>extern AVCodec *first_avcodec;
>
>
>unsigned avcodec_version(void);
>
>unsigned avcodec_build(void);
>
>
>
>
>
>
>
>void avcodec_init(void);
>
>void register_avcodec(AVCodec *format);
>
>
>
>
>
>
>
>AVCodec *avcodec_find_encoder(enum CodecID id);
>
>
>
>
>
>
>
>AVCodec *avcodec_find_encoder_by_name(const char *name);
>
>
>
>
>
>
>
>AVCodec *avcodec_find_decoder(enum CodecID id);
>
>
>
>
>
>
>
>AVCodec *avcodec_find_decoder_by_name(const char *name);
>void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode);
>
>
>
>
>
>
>void avcodec_get_context_defaults(AVCodecContext *s);
>
>
>
>void avcodec_get_context_defaults2(AVCodecContext *s, enum CodecType);
># 2477 "avcodec.h"
>AVCodecContext *avcodec_alloc_context(void);
>
>
>
>AVCodecContext *avcodec_alloc_context2(enum CodecType);
>
>
>
>
>
>
>void avcodec_get_frame_defaults(AVFrame *pic);
># 2497 "avcodec.h"
>AVFrame *avcodec_alloc_frame(void);
>
>int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic);
>void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic);
>int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic);
>void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height);
># 2512 "avcodec.h"
>int avcodec_check_dimensions(void *av_log_ctx, unsigned int w, unsigned int h);
>enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat * fmt);
>
>int avcodec_thread_init(AVCodecContext *s, int thread_count);
>void avcodec_thread_free(AVCodecContext *s);
>int avcodec_thread_execute(AVCodecContext *s, int (*func)(AVCodecContext *c2, void *arg2),void **arg, int *ret, int count);
>int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void **arg, int *ret, int count);
># 2548 "avcodec.h"
>int avcodec_open(AVCodecContext *avctx, AVCodec *codec);
>
>
>
>
>__attribute__((deprecated)) int avcodec_decode_audio(AVCodecContext *avctx, int16_t *samples,
>                         int *frame_size_ptr,
>                         uint8_t *buf, int buf_size);
># 2593 "avcodec.h"
>int avcodec_decode_audio2(AVCodecContext *avctx, int16_t *samples,
>                         int *frame_size_ptr,
>                         uint8_t *buf, int buf_size);
># 2628 "avcodec.h"
>int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture,
>                         int *got_picture_ptr,
>                         uint8_t *buf, int buf_size);
>
>
>
>
>int avcodec_decode_subtitle(AVCodecContext *avctx, AVSubtitle *sub,
>                            int *got_sub_ptr,
>                            const uint8_t *buf, int buf_size);
>int avcodec_parse_frame(AVCodecContext *avctx, uint8_t **pdata,
>                        int *data_size_ptr,
>                        uint8_t *buf, int buf_size);
># 2658 "avcodec.h"
>int avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size,
>                         const short *samples);
># 2676 "avcodec.h"
>int avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size,
>                         const AVFrame *pict);
>int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
>                            const AVSubtitle *sub);
>
>int avcodec_close(AVCodecContext *avctx);
>
>void avcodec_register_all(void);
>
>
>
>
>void avcodec_flush_buffers(AVCodecContext *avctx);
>
>void avcodec_default_free_buffers(AVCodecContext *s);
># 2700 "avcodec.h"
>char av_get_pict_type_char(int pict_type);
>
>
>
>
>
>
>
>int av_get_bits_per_sample(enum CodecID codec_id);
>
>
>typedef struct AVCodecParserContext {
>    void *priv_data;
>    struct AVCodecParser *parser;
>    int64_t frame_offset;
>    int64_t cur_offset;
>
>    int64_t last_frame_offset;
>
>    int pict_type;
>    int repeat_pict;
>    int64_t pts;
>    int64_t dts;
>
>
>    int64_t last_pts;
>    int64_t last_dts;
>    int fetch_timestamp;
>
>
>    int cur_frame_start_index;
>    int64_t cur_frame_offset[4];
>    int64_t cur_frame_pts[4];
>    int64_t cur_frame_dts[4];
>
>    int flags;
>
>
>    int64_t offset;
>    int64_t last_offset;
>} AVCodecParserContext;
>
>typedef struct AVCodecParser {
>    int codec_ids[5];
>    int priv_data_size;
>    int (*parser_init)(AVCodecParserContext *s);
>    int (*parser_parse)(AVCodecParserContext *s,
>                        AVCodecContext *avctx,
>                        const uint8_t **poutbuf, int *poutbuf_size,
>                        const uint8_t *buf, int buf_size);
>    void (*parser_close)(AVCodecParserContext *s);
>    int (*split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size);
>    struct AVCodecParser *next;
>} AVCodecParser;
>
>extern AVCodecParser *av_first_parser;
>
>void av_register_codec_parser(AVCodecParser *parser);
>AVCodecParserContext *av_parser_init(int codec_id);
>int av_parser_parse(AVCodecParserContext *s,
>                    AVCodecContext *avctx,
>                    uint8_t **poutbuf, int *poutbuf_size,
>                    const uint8_t *buf, int buf_size,
>                    int64_t pts, int64_t dts);
>int av_parser_change(AVCodecParserContext *s,
>                     AVCodecContext *avctx,
>                     uint8_t **poutbuf, int *poutbuf_size,
>                     const uint8_t *buf, int buf_size, int keyframe);
>void av_parser_close(AVCodecParserContext *s);
>
>extern AVCodecParser aac_parser;
>extern AVCodecParser ac3_parser;
>extern AVCodecParser cavsvideo_parser;
>extern AVCodecParser dca_parser;
>extern AVCodecParser dvbsub_parser;
>extern AVCodecParser dvdsub_parser;
>extern AVCodecParser h261_parser;
>extern AVCodecParser h263_parser;
>extern AVCodecParser h264_parser;
>extern AVCodecParser mjpeg_parser;
>extern AVCodecParser mpeg4video_parser;
>extern AVCodecParser mpegaudio_parser;
>extern AVCodecParser mpegvideo_parser;
>extern AVCodecParser pnm_parser;
>extern AVCodecParser vc1_parser;
>
>
>typedef struct AVBitStreamFilterContext {
>    void *priv_data;
>    struct AVBitStreamFilter *filter;
>    AVCodecParserContext *parser;
>    struct AVBitStreamFilterContext *next;
>} AVBitStreamFilterContext;
>
>
>typedef struct AVBitStreamFilter {
>    const char *name;
>    int priv_data_size;
>    int (*filter)(AVBitStreamFilterContext *bsfc,
>                  AVCodecContext *avctx, const char *args,
>                  uint8_t **poutbuf, int *poutbuf_size,
>                  const uint8_t *buf, int buf_size, int keyframe);
>    struct AVBitStreamFilter *next;
>} AVBitStreamFilter;
>
>extern AVBitStreamFilter *av_first_bitstream_filter;
>
>void av_register_bitstream_filter(AVBitStreamFilter *bsf);
>AVBitStreamFilterContext *av_bitstream_filter_init(const char *name);
>int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc,
>                               AVCodecContext *avctx, const char *args,
>                               uint8_t **poutbuf, int *poutbuf_size,
>                               const uint8_t *buf, int buf_size, int keyframe);
>void av_bitstream_filter_close(AVBitStreamFilterContext *bsf);
>
>extern AVBitStreamFilter dump_extradata_bsf;
>extern AVBitStreamFilter remove_extradata_bsf;
>extern AVBitStreamFilter noise_bsf;
>extern AVBitStreamFilter mp3_header_compress_bsf;
>extern AVBitStreamFilter mp3_header_decompress_bsf;
>extern AVBitStreamFilter mjpega_dump_header_bsf;
>extern AVBitStreamFilter imx_dump_header_bsf;
># 2832 "avcodec.h"
>void *av_fast_realloc(void *ptr, unsigned int *size, unsigned int min_size);
># 2844 "avcodec.h"
>__attribute__((deprecated)) void av_free_static(void);
># 2856 "avcodec.h"
>__attribute__((deprecated)) void *av_mallocz_static(unsigned int size);
>
>
>
>
>void av_picture_copy(AVPicture *dst, const AVPicture *src,
>              int pix_fmt, int width, int height);
>
>
>
>
>int av_picture_crop(AVPicture *dst, const AVPicture *src,
>             int pix_fmt, int top_band, int left_band);
>
>
>
>
>int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width, int pix_fmt,
>            int padtop, int padbottom, int padleft, int padright, int *color);
>
>
>
>
>
>__attribute__((deprecated)) void img_copy(AVPicture *dst, const AVPicture *src,
>              int pix_fmt, int width, int height);
>
>
>
>
>__attribute__((deprecated)) int img_crop(AVPicture *dst, const AVPicture *src,
>             int pix_fmt, int top_band, int left_band);
>
>
>
>
>__attribute__((deprecated)) int img_pad(AVPicture *dst, const AVPicture *src, int height, int width, int pix_fmt,
>            int padtop, int padbottom, int padleft, int padright, int *color);
>
>
>extern unsigned int av_xiphlacing(unsigned char *s, unsigned int v);
># 2909 "avcodec.h"
>int av_parse_video_frame_size(int *width_ptr, int *height_ptr, const char *str);
># 2920 "avcodec.h"
>int av_parse_video_frame_rate(AVRational *frame_rate, const char *str);
># 31 "dsputil.c" 2
># 1 "dsputil.h" 1
># 38 "dsputil.h"
>typedef short DCTELEM;
>typedef int DWTELEM;
>
>void fdct_ifast (DCTELEM *data);
>void fdct_ifast248 (DCTELEM *data);
>void ff_jpeg_fdct_islow (DCTELEM *data);
>void ff_fdct248_islow (DCTELEM *data);
>
>void j_rev_dct (DCTELEM *data);
>void j_rev_dct4 (DCTELEM *data);
>void j_rev_dct2 (DCTELEM *data);
>void j_rev_dct1 (DCTELEM *data);
>
>void ff_fdct_mmx(DCTELEM *block);
>void ff_fdct_mmx2(DCTELEM *block);
>void ff_fdct_sse2(DCTELEM *block);
>
>void ff_h264_idct8_add_c(uint8_t *dst, DCTELEM *block, int stride);
>void ff_h264_idct_add_c(uint8_t *dst, DCTELEM *block, int stride);
>void ff_h264_idct8_dc_add_c(uint8_t *dst, DCTELEM *block, int stride);
>void ff_h264_idct_dc_add_c(uint8_t *dst, DCTELEM *block, int stride);
>void ff_h264_lowres_idct_add_c(uint8_t *dst, int stride, DCTELEM *block);
>void ff_h264_lowres_idct_put_c(uint8_t *dst, int stride, DCTELEM *block);
>
>void ff_vector_fmul_add_add_c(float *dst, const float *src0, const float *src1,
>                              const float *src2, int src3, int blocksize, int step);
>void ff_float_to_int16_c(int16_t *dst, const float *src, int len);
>
>
>extern const uint8_t ff_alternate_horizontal_scan[64];
>extern const uint8_t ff_alternate_vertical_scan[64];
>extern const uint8_t ff_zigzag_direct[64];
>extern const uint8_t ff_zigzag248_direct[64];
>
>
>
>
>
>extern uint32_t ff_squareTbl[512];
>extern uint8_t ff_cropTbl[256 + 2 * 1024];
>
>
>void ff_vp3_idct_c(DCTELEM *block );
>void ff_vp3_idct_put_c(uint8_t *dest , int line_size, DCTELEM *block );
>void ff_vp3_idct_add_c(uint8_t *dest , int line_size, DCTELEM *block );
>
>
>void ff_img_copy_plane(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
>void ff_shrink22(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
>void ff_shrink44(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
>void ff_shrink88(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
>
>void ff_gmc_c(uint8_t *dst, uint8_t *src, int stride, int h, int ox, int oy,
>              int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height);
># 114 "dsputil.h"
>typedef void (*op_pixels_func)(uint8_t *block , const uint8_t *pixels , int line_size, int h);
>typedef void (*tpel_mc_func)(uint8_t *block , const uint8_t *pixels , int line_size, int w, int h);
>typedef void (*qpel_mc_func)(uint8_t *dst , uint8_t *src , int stride);
>typedef void (*h264_chroma_mc_func)(uint8_t *dst , uint8_t *src , int srcStride, int h, int x, int y);
>typedef void (*h264_weight_func)(uint8_t *block, int stride, int log2_denom, int weight, int offset);
>typedef void (*h264_biweight_func)(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offset);
>
>
>
>
>
>
>void ff_put_qpel16_mc11_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_put_no_rnd_qpel16_mc11_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_avg_qpel16_mc11_old_c (uint8_t *dst , uint8_t *src , int stride);
>void ff_put_qpel16_mc31_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_put_no_rnd_qpel16_mc31_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_avg_qpel16_mc31_old_c (uint8_t *dst , uint8_t *src , int stride);
>void ff_put_qpel16_mc12_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_put_no_rnd_qpel16_mc12_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_avg_qpel16_mc12_old_c (uint8_t *dst , uint8_t *src , int stride);
>void ff_put_qpel16_mc32_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_put_no_rnd_qpel16_mc32_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_avg_qpel16_mc32_old_c (uint8_t *dst , uint8_t *src , int stride);
>void ff_put_qpel16_mc13_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_put_no_rnd_qpel16_mc13_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_avg_qpel16_mc13_old_c (uint8_t *dst , uint8_t *src , int stride);
>void ff_put_qpel16_mc33_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_put_no_rnd_qpel16_mc33_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_avg_qpel16_mc33_old_c (uint8_t *dst , uint8_t *src , int stride);
>void ff_put_qpel8_mc11_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_put_no_rnd_qpel8_mc11_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_avg_qpel8_mc11_old_c (uint8_t *dst , uint8_t *src , int stride);
>void ff_put_qpel8_mc31_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_put_no_rnd_qpel8_mc31_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_avg_qpel8_mc31_old_c (uint8_t *dst , uint8_t *src , int stride);
>void ff_put_qpel8_mc12_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_put_no_rnd_qpel8_mc12_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_avg_qpel8_mc12_old_c (uint8_t *dst , uint8_t *src , int stride);
>void ff_put_qpel8_mc32_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_put_no_rnd_qpel8_mc32_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_avg_qpel8_mc32_old_c (uint8_t *dst , uint8_t *src , int stride);
>void ff_put_qpel8_mc13_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_put_no_rnd_qpel8_mc13_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_avg_qpel8_mc13_old_c (uint8_t *dst , uint8_t *src , int stride);
>void ff_put_qpel8_mc33_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_put_no_rnd_qpel8_mc33_old_c (uint8_t *dst , uint8_t *src , int stride);void ff_avg_qpel8_mc33_old_c (uint8_t *dst , uint8_t *src , int stride);
># 148 "dsputil.h"
>typedef int (*me_cmp_func)(void *s, uint8_t *blk1 , uint8_t *blk2 , int line_size, int h) ;
>
>
>
>typedef struct slice_buffer_s slice_buffer;
>
>
>
>
>typedef struct DSPContext {
>
>    void (*get_pixels)(DCTELEM *block , const uint8_t *pixels , int line_size);
>    void (*diff_pixels)(DCTELEM *block , const uint8_t *s1 , const uint8_t *s2 , int stride);
>    void (*put_pixels_clamped)(const DCTELEM *block , uint8_t *pixels , int line_size);
>    void (*put_signed_pixels_clamped)(const DCTELEM *block , uint8_t *pixels , int line_size);
>    void (*add_pixels_clamped)(const DCTELEM *block , uint8_t *pixels , int line_size);
>    void (*add_pixels8)(uint8_t *pixels, DCTELEM *block, int line_size);
>    void (*add_pixels4)(uint8_t *pixels, DCTELEM *block, int line_size);
>    int (*sum_abs_dctelem)(DCTELEM *block );
>
>
>
>    void (*gmc1)(uint8_t *dst , uint8_t *src , int srcStride, int h, int x16, int y16, int rounder);
>
>
>
>    void (*gmc )(uint8_t *dst , uint8_t *src , int stride, int h, int ox, int oy,
>                    int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height);
>    void (*clear_blocks)(DCTELEM *blocks );
>    int (*pix_sum)(uint8_t * pix, int line_size);
>    int (*pix_norm1)(uint8_t * pix, int line_size);
>
>
>    me_cmp_func sad[5];
>    me_cmp_func sse[5];
>    me_cmp_func hadamard8_diff[5];
>    me_cmp_func dct_sad[5];
>    me_cmp_func quant_psnr[5];
>    me_cmp_func bit[5];
>    me_cmp_func rd[5];
>    me_cmp_func vsad[5];
>    me_cmp_func vsse[5];
>    me_cmp_func nsse[5];
>    me_cmp_func w53[5];
>    me_cmp_func w97[5];
>    me_cmp_func dct_max[5];
>    me_cmp_func dct264_sad[5];
>
>    me_cmp_func me_pre_cmp[5];
>    me_cmp_func me_cmp[5];
>    me_cmp_func me_sub_cmp[5];
>    me_cmp_func mb_cmp[5];
>    me_cmp_func ildct_cmp[5];
>    me_cmp_func frame_skip_cmp[5];
>
>    int (*ssd_int8_vs_int16)(int8_t *pix1, int16_t *pix2, int size);
># 215 "dsputil.h"
>    op_pixels_func put_pixels_tab[4][4];
># 227 "dsputil.h"
>    op_pixels_func avg_pixels_tab[4][4];
># 239 "dsputil.h"
>    op_pixels_func put_no_rnd_pixels_tab[4][4];
># 251 "dsputil.h"
>    op_pixels_func avg_no_rnd_pixels_tab[4][4];
>
>    void (*put_no_rnd_pixels_l2[2])(uint8_t *block , const uint8_t *a , const uint8_t *b , int line_size, int h);
># 265 "dsputil.h"
>    tpel_mc_func put_tpel_pixels_tab[11];
>    tpel_mc_func avg_tpel_pixels_tab[11];
>
>    qpel_mc_func put_qpel_pixels_tab[2][16];
>    qpel_mc_func avg_qpel_pixels_tab[2][16];
>    qpel_mc_func put_no_rnd_qpel_pixels_tab[2][16];
>    qpel_mc_func avg_no_rnd_qpel_pixels_tab[2][16];
>    qpel_mc_func put_mspel_pixels_tab[8];
>
>
>
>
>    h264_chroma_mc_func put_h264_chroma_pixels_tab[3];
>
>    h264_chroma_mc_func put_no_rnd_h264_chroma_pixels_tab[3];
>    h264_chroma_mc_func avg_h264_chroma_pixels_tab[3];
>
>    qpel_mc_func put_h264_qpel_pixels_tab[4][16];
>    qpel_mc_func avg_h264_qpel_pixels_tab[4][16];
>
>    qpel_mc_func put_2tap_qpel_pixels_tab[4][16];
>    qpel_mc_func avg_2tap_qpel_pixels_tab[4][16];
>
>    h264_weight_func weight_h264_pixels_tab[10];
>    h264_biweight_func biweight_h264_pixels_tab[10];
>
>
>    qpel_mc_func put_cavs_qpel_pixels_tab[2][16];
>    qpel_mc_func avg_cavs_qpel_pixels_tab[2][16];
>    void (*cavs_filter_lv)(uint8_t *pix, int stride, int alpha, int beta, int tc, int bs1, int bs2);
>    void (*cavs_filter_lh)(uint8_t *pix, int stride, int alpha, int beta, int tc, int bs1, int bs2);
>    void (*cavs_filter_cv)(uint8_t *pix, int stride, int alpha, int beta, int tc, int bs1, int bs2);
>    void (*cavs_filter_ch)(uint8_t *pix, int stride, int alpha, int beta, int tc, int bs1, int bs2);
>    void (*cavs_idct8_add)(uint8_t *dst, DCTELEM *block, int stride);
>
>    me_cmp_func pix_abs[2][4];
>
>
>    void (*add_bytes)(uint8_t *dst , uint8_t *src , int w);
>    void (*diff_bytes)(uint8_t *dst , uint8_t *src1 , uint8_t *src2 ,int w);
>
>
>
>
>    void (*sub_hfyu_median_prediction)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w, int *left, int *left_top);
>    void (*bswap_buf)(uint32_t *dst, uint32_t *src, int w);
>
>    void (*h264_v_loop_filter_luma)(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0);
>    void (*h264_h_loop_filter_luma)(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0);
>    void (*h264_v_loop_filter_chroma)(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0);
>    void (*h264_h_loop_filter_chroma)(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0);
>    void (*h264_v_loop_filter_chroma_intra)(uint8_t *pix, int stride, int alpha, int beta);
>    void (*h264_h_loop_filter_chroma_intra)(uint8_t *pix, int stride, int alpha, int beta);
>
>    void (*h264_loop_filter_strength)(int16_t bS[2][4][4], uint8_t nnz[40], int8_t ref[2][40], int16_t mv[2][40][2],
>                                      int bidir, int edges, int step, int mask_mv0, int mask_mv1);
>
>    void (*h263_v_loop_filter)(uint8_t *src, int stride, int qscale);
>    void (*h263_h_loop_filter)(uint8_t *src, int stride, int qscale);
>
>    void (*h261_loop_filter)(uint8_t *src, int stride);
>
>
>    void (*vorbis_inverse_coupling)(float *mag, float *ang, int blocksize);
>
>    void (*vector_fmul)(float *dst, const float *src, int len);
>    void (*vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len);
>
>    void (*vector_fmul_add_add)(float *dst, const float *src0, const float *src1, const float *src2, int src3, int len, int step);
>
>
>
>    void (*float_to_int16)(int16_t *dst, const float *src, int len);
>
>
>    void (*fdct)(DCTELEM *block );
>    void (*fdct248)(DCTELEM *block );
>
>
>    void (*idct)(DCTELEM *block );
>
>
>
>
>
>
>    void (*idct_put)(uint8_t *dest , int line_size, DCTELEM *block );
>
>
>
>
>
>    void (*idct_add)(uint8_t *dest , int line_size, DCTELEM *block );
># 371 "dsputil.h"
>    uint8_t idct_permutation[64];
>    int idct_permutation_type;
>
>
>
>
>
>
>    int (*try_8x8basis)(int16_t rem[64], int16_t weight[64], int16_t basis[64], int scale);
>    void (*add_8x8basis)(int16_t rem[64], int16_t basis[64], int scale);
>
>
>
>
>    void (*h264_idct_add)(uint8_t *dst, DCTELEM *block, int stride);
>    void (*h264_idct8_add)(uint8_t *dst, DCTELEM *block, int stride);
>    void (*h264_idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride);
>    void (*h264_idct8_dc_add)(uint8_t *dst, DCTELEM *block, int stride);
>    void (*h264_dct)(DCTELEM block[4][4]);
>
>
>    void (*vertical_compose97i)(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, DWTELEM *b3, DWTELEM *b4, DWTELEM *b5, int width);
>    void (*horizontal_compose97i)(DWTELEM *b, int width);
>    void (*inner_add_yblock)(const uint8_t *obmc, const int obmc_stride, uint8_t * * block, int b_w, int b_h, int src_x, int src_y, int src_stride, slice_buffer * sb, int add, uint8_t * dst8);
>
>    void (*prefetch)(void *mem, int stride, int h);
>
>    void (*shrink[4])(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
>
>
>    void (*vc1_inv_trans_8x8)(DCTELEM *b);
>    void (*vc1_inv_trans_8x4)(DCTELEM *b, int n);
>    void (*vc1_inv_trans_4x8)(DCTELEM *b, int n);
>    void (*vc1_inv_trans_4x4)(DCTELEM *b, int n);
>    void (*vc1_v_overlap)(uint8_t* src, int stride);
>    void (*vc1_h_overlap)(uint8_t* src, int stride);
>
>
>
>    op_pixels_func put_vc1_mspel_pixels_tab[16];
>} DSPContext;
>
>void dsputil_static_init(void);
>void dsputil_init(DSPContext* p, AVCodecContext *avctx);
>
>int ff_check_alignment(void);
>
>
>
>
>
>void ff_block_permute(DCTELEM *block, uint8_t *permutation, const uint8_t *scantable, int last);
>
>void ff_set_cmp(DSPContext* c, me_cmp_func *cmp, int type);
>
>
>
>static inline uint32_t rnd_avg32(uint32_t a, uint32_t b)
>{
>    return (a | b) - (((a ^ b) & ~((0x01)*0x01010101UL)) >> 1);
>}
>
>static inline uint32_t no_rnd_avg32(uint32_t a, uint32_t b)
>{
>    return (a & b) + (((a ^ b) & ~((0x01)*0x01010101UL)) >> 1);
>}
>
>static inline int get_penalty_factor(int lambda, int lambda2, int type){
>    switch(type&0xFF){
>    default:
>    case 0:
>        return lambda>>7;
>    case 3:
>        return (3*lambda)>>(7 +1);
>    case 11:
>        return (4*lambda)>>(7);
>    case 12:
>        return (2*lambda)>>(7);
>    case 2:
>    case 14:
>        return (2*lambda)>>7;
>    case 6:
>    case 4:
>    case 1:
>    case 10:
>        return lambda2>>7;
>    case 5:
>        return 1;
>    }
>}
># 471 "dsputil.h"
>int mm_support(void);
>
>void dsputil_init_alpha(DSPContext* c, AVCodecContext *avctx);
>void dsputil_init_armv4l(DSPContext* c, AVCodecContext *avctx);
>void dsputil_init_bfin(DSPContext* c, AVCodecContext *avctx);
>void dsputil_init_mlib(DSPContext* c, AVCodecContext *avctx);
>void dsputil_init_mmi(DSPContext* c, AVCodecContext *avctx);
>void dsputil_init_mmx(DSPContext* c, AVCodecContext *avctx);
>void dsputil_init_ppc(DSPContext* c, AVCodecContext *avctx);
>void dsputil_init_sh4(DSPContext* c, AVCodecContext *avctx);
>void dsputil_init_vis(DSPContext* c, AVCodecContext *avctx);
># 588 "dsputil.h"
>void get_psnr(uint8_t *orig_image[3], uint8_t *coded_image[3],
>              int orig_linesize[3], int coded_linesize,
>              AVCodecContext *avctx);
>
>
>
>
>
>typedef float FFTSample;
>
>struct MDCTContext;
>
>typedef struct FFTComplex {
>    FFTSample re, im;
>} FFTComplex;
>
>typedef struct FFTContext {
>    int nbits;
>    int inverse;
>    uint16_t *revtab;
>    FFTComplex *exptab;
>    FFTComplex *exptab1;
>    void (*fft_calc)(struct FFTContext *s, FFTComplex *z);
>    void (*imdct_calc)(struct MDCTContext *s, FFTSample *output,
>                       const FFTSample *input, FFTSample *tmp);
>} FFTContext;
>
>int ff_fft_init(FFTContext *s, int nbits, int inverse);
>void ff_fft_permute(FFTContext *s, FFTComplex *z);
>void ff_fft_calc_c(FFTContext *s, FFTComplex *z);
>void ff_fft_calc_sse(FFTContext *s, FFTComplex *z);
>void ff_fft_calc_3dn(FFTContext *s, FFTComplex *z);
>void ff_fft_calc_3dn2(FFTContext *s, FFTComplex *z);
>void ff_fft_calc_altivec(FFTContext *s, FFTComplex *z);
>
>static inline void ff_fft_calc(FFTContext *s, FFTComplex *z)
>{
>    s->fft_calc(s, z);
>}
>void ff_fft_end(FFTContext *s);
>
>
>
>typedef struct MDCTContext {
>    int n;
>    int nbits;
>
>    FFTSample *tcos;
>    FFTSample *tsin;
>    FFTContext fft;
>} MDCTContext;
>
>int ff_mdct_init(MDCTContext *s, int nbits, int inverse);
>void ff_imdct_calc(MDCTContext *s, FFTSample *output,
>                const FFTSample *input, FFTSample *tmp);
>void ff_imdct_calc_3dn2(MDCTContext *s, FFTSample *output,
>                        const FFTSample *input, FFTSample *tmp);
>void ff_imdct_calc_sse(MDCTContext *s, FFTSample *output,
>                       const FFTSample *input, FFTSample *tmp);
>void ff_mdct_calc(MDCTContext *s, FFTSample *out,
>               const FFTSample *input, FFTSample *tmp);
>void ff_mdct_end(MDCTContext *s);
># 672 "dsputil.h"
>static inline void copy_block2(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
>{
>    int i;
>    for(i=0; i<h; i++)
>    {
>        (((struct unaligned_16 *) (dst))->l) = ((((const struct unaligned_16 *) (src))->l));
>        dst+=dstStride;
>        src+=srcStride;
>    }
>}
>
>static inline void copy_block4(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
>{
>    int i;
>    for(i=0; i<h; i++)
>    {
>        (((struct unaligned_32 *) (dst))->l) = ((((const struct unaligned_32 *) (src))->l));
>        dst+=dstStride;
>        src+=srcStride;
>    }
>}
>
>static inline void copy_block8(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
>{
>    int i;
>    for(i=0; i<h; i++)
>    {
>        (((struct unaligned_32 *) (dst))->l) = ((((const struct unaligned_32 *) (src))->l));
>        (((struct unaligned_32 *) (dst+4))->l) = ((((const struct unaligned_32 *) (src+4))->l));
>        dst+=dstStride;
>        src+=srcStride;
>    }
>}
>
>static inline void copy_block9(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
>{
>    int i;
>    for(i=0; i<h; i++)
>    {
>        (((struct unaligned_32 *) (dst))->l) = ((((const struct unaligned_32 *) (src))->l));
>        (((struct unaligned_32 *) (dst+4))->l) = ((((const struct unaligned_32 *) (src+4))->l));
>        dst[8]= src[8];
>        dst+=dstStride;
>        src+=srcStride;
>    }
>}
>
>static inline void copy_block16(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
>{
>    int i;
>    for(i=0; i<h; i++)
>    {
>        (((struct unaligned_32 *) (dst))->l) = ((((const struct unaligned_32 *) (src))->l));
>        (((struct unaligned_32 *) (dst+4))->l) = ((((const struct unaligned_32 *) (src+4))->l));
>        (((struct unaligned_32 *) (dst+8))->l) = ((((const struct unaligned_32 *) (src+8))->l));
>        (((struct unaligned_32 *) (dst+12))->l) = ((((const struct unaligned_32 *) (src+12))->l));
>        dst+=dstStride;
>        src+=srcStride;
>    }
>}
>
>static inline void copy_block17(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
>{
>    int i;
>    for(i=0; i<h; i++)
>    {
>        (((struct unaligned_32 *) (dst))->l) = ((((const struct unaligned_32 *) (src))->l));
>        (((struct unaligned_32 *) (dst+4))->l) = ((((const struct unaligned_32 *) (src+4))->l));
>        (((struct unaligned_32 *) (dst+8))->l) = ((((const struct unaligned_32 *) (src+8))->l));
>        (((struct unaligned_32 *) (dst+12))->l) = ((((const struct unaligned_32 *) (src+12))->l));
>        dst[16]= src[16];
>        dst+=dstStride;
>        src+=srcStride;
>    }
>}
># 32 "dsputil.c" 2
># 1 "mpegvideo.h" 1
># 32 "mpegvideo.h"
># 1 "bitstream.h" 1
># 29 "bitstream.h"
># 1 "/var/tmp/portage/media-video/ffmpeg-0.4.9_p20070616/work/ffmpeg/libavutil/log.h" 1
># 30 "bitstream.h" 2
># 48 "bitstream.h"
>extern const uint8_t ff_reverse[256];
>
>
>
>static inline int32_t NEG_SSR32( int32_t a, int8_t s){
>    asm ("sarl %1, %0\n\t"
>         : "+r" (a)
>         : "ic" ((uint8_t)(-s))
>    );
>    return a;
>}
>static inline uint32_t NEG_USR32(uint32_t a, int8_t s){
>    asm ("shrl %1, %0\n\t"
>         : "+r" (a)
>         : "ic" ((uint8_t)(-s))
>    );
>    return a;
>}
># 74 "bitstream.h"
>typedef struct PutBitContext {
>
>
>
>
>    uint32_t bit_buf;
>    int bit_left;
>    uint8_t *buf, *buf_ptr, *buf_end;
>
>} PutBitContext;
>
>static inline void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
>{
>    if(buffer_size < 0) {
>        buffer_size = 0;
>        buffer = ((void *)0);
>    }
>
>    s->buf = buffer;
>    s->buf_end = s->buf + buffer_size;
>
>
>
>
>
>    s->buf_ptr = s->buf;
>    s->bit_left=32;
>    s->bit_buf=0;
>
>}
>
>
>static inline int put_bits_count(PutBitContext *s)
>{
>
>
>
>    return (s->buf_ptr - s->buf) * 8 + 32 - s->bit_left;
>
>}
>
>
>static inline void flush_put_bits(PutBitContext *s)
>{
>
>
>
>    s->bit_buf<<= s->bit_left;
>    while (s->bit_left < 32) {
>
>        *s->buf_ptr++=s->bit_buf >> 24;
>        s->bit_buf<<=8;
>        s->bit_left+=8;
>    }
>    s->bit_left=32;
>    s->bit_buf=0;
>
>}
>
>void align_put_bits(PutBitContext *s);
>void ff_put_string(PutBitContext * pbc, char *s, int put_zero);
>
>
>
>typedef struct GetBitContext {
>    const uint8_t *buffer, *buffer_end;
>
>    int index;
># 152 "bitstream.h"
>    int size_in_bits;
>} GetBitContext;
>
>
>
>typedef struct VLC {
>    int bits;
>    int16_t (*table)[2];
>    int table_size, table_allocated;
>} VLC;
>
>typedef struct RL_VLC_ELEM {
>    int16_t level;
>    int8_t len;
>    uint8_t run;
>} RL_VLC_ELEM;
># 206 "bitstream.h"
>static inline void put_bits(PutBitContext *s, int n, unsigned int value)
>{
>    unsigned int bit_buf;
>    int bit_left;
>
>
>    ((void) (0));
>
>    bit_buf = s->bit_buf;
>    bit_left = s->bit_left;
>
>
>
>    if (n < bit_left) {
>        bit_buf = (bit_buf<<n) | value;
>        bit_left-=n;
>    } else {
>        bit_buf<<=bit_left;
>        bit_buf |= value >> (n - bit_left);
># 233 "bitstream.h"
>        *(uint32_t *)s->buf_ptr = (__extension__ ({ register unsigned int __v, __x = (bit_buf); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("bswap %0" : "=r" (__v) : "0" (__x)); __v; }));
>
>        s->buf_ptr+=4;
>        bit_left+=32 - n;
>        bit_buf = value;
>    }
>
>    s->bit_buf = bit_buf;
>    s->bit_left = bit_left;
>}
># 313 "bitstream.h"
>static inline uint8_t* pbBufPtr(PutBitContext *s)
>{
>
>
>
>        return s->buf_ptr;
>
>}
>
>
>
>
>
>static inline void skip_put_bytes(PutBitContext *s, int n){
>        ((void) (0));
>
>
>
>
>        ((void) (0));
>        s->buf_ptr += n;
>
>}
>
>
>
>
>
>static inline void skip_put_bits(PutBitContext *s, int n){
>
>
>
>    s->bit_left -= n;
>    s->buf_ptr-= s->bit_left>>5;
>    s->bit_left &= 31;
>
>}
>
>
>
>
>static inline void set_put_bits_buffer_size(PutBitContext *s, int size){
>    s->buf_end= s->buf + size;
>}
># 403 "bitstream.h"
>static inline int unaligned32_be(const void *v)
>{
>
>
>
>
>        return (__extension__ ({ register unsigned int __v, __x = ((*(const uint32_t*)(v))); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("bswap %0" : "=r" (__v) : "0" (__x)); __v; }));
>
>}
>
>static inline int unaligned32_le(const void *v)
>{
>
>
>
>
>       return ((*(const uint32_t*)(v)));
>
>}
># 477 "bitstream.h"
>static inline int get_bits_count(GetBitContext *s){
>    return s->index;
>}
>
>static inline void skip_bits_long(GetBitContext *s, int n){
>    s->index += n;
>}
># 642 "bitstream.h"
>static inline int get_xbits(GetBitContext *s, int n){
>    register int sign;
>    register int32_t cache;
>    int re_index= (s)->index; int re_cache= 0;
>    re_cache= unaligned32_be( ((const uint8_t *)(s)->buffer)+(re_index>>3) ) << (re_index&0x07);
>    cache = ((uint32_t)re_cache);
>    sign=(~cache)>>31;
>    re_index += (n);
>    (s)->index= re_index;
>    return (NEG_USR32(sign ^ cache, n) ^ sign) - sign;
>}
>
>static inline int get_sbits(GetBitContext *s, int n){
>    register int tmp;
>    int re_index= (s)->index; int re_cache= 0;
>    re_cache= unaligned32_be( ((const uint8_t *)(s)->buffer)+(re_index>>3) ) << (re_index&0x07);
>    tmp= NEG_SSR32(re_cache, n);
>    re_index += (n);
>    (s)->index= re_index;
>    return tmp;
>}
>
>
>
>
>
>static inline unsigned int get_bits(GetBitContext *s, int n){
>    register int tmp;
>    int re_index= (s)->index; int re_cache= 0;
>    re_cache= unaligned32_be( ((const uint8_t *)(s)->buffer)+(re_index>>3) ) << (re_index&0x07);
>    tmp= NEG_USR32(re_cache, n);
>    re_index += (n);
>    (s)->index= re_index;
>    return tmp;
>}
>
>
>
>
>
>static inline unsigned int show_bits(GetBitContext *s, int n){
>    register int tmp;
>    int re_index= (s)->index; int re_cache= 0;
>    re_cache= unaligned32_be( ((const uint8_t *)(s)->buffer)+(re_index>>3) ) << (re_index&0x07);
>    tmp= NEG_USR32(re_cache, n);
>
>    return tmp;
>}
>
>static inline void skip_bits(GetBitContext *s, int n){
>
>    int re_index= (s)->index; int re_cache= 0;
>    re_cache= unaligned32_be( ((const uint8_t *)(s)->buffer)+(re_index>>3) ) << (re_index&0x07);
>    re_index += (n);
>    (s)->index= re_index;
>}
>
>static inline unsigned int get_bits1(GetBitContext *s){
>
>    int index= s->index;
>    uint8_t result= s->buffer[ index>>3 ];
>
>
>
>
>    result<<= (index&0x07);
>    result>>= 8 - 1;
>
>    index++;
>    s->index= index;
>
>    return result;
>
>
>
>}
>
>static inline unsigned int show_bits1(GetBitContext *s){
>    return show_bits(s, 1);
>}
>
>static inline void skip_bits1(GetBitContext *s){
>    skip_bits(s, 1);
>}
>
>
>
>
>static inline unsigned int get_bits_long(GetBitContext *s, int n){
>    if(n<=17) return get_bits(s, n);
>    else{
>
>
>
>
>        int ret= get_bits(s, 16) << (n-16);
>        return ret | get_bits(s, n-16);
>
>    }
>}
>
>
>
>
>static inline unsigned int show_bits_long(GetBitContext *s, int n){
>    if(n<=17) return show_bits(s, n);
>    else{
>        GetBitContext gb= *s;
>        int ret= get_bits_long(s, n);
>        *s= gb;
>        return ret;
>    }
>}
>
>static inline int check_marker(GetBitContext *s, const char *msg)
>{
>    int bit= get_bits1(s);
>    if(!bit)
>        av_log(((void *)0), 1, "Marker bit missing %s\n", msg);
>
>    return bit;
>}
>
>
>
>
>
>
>
>static inline void init_get_bits(GetBitContext *s,
>                   const uint8_t *buffer, int bit_size)
>{
>    int buffer_size= (bit_size+7)>>3;
>    if(buffer_size < 0 || bit_size < 0) {
>        buffer_size = bit_size = 0;
>        buffer = ((void *)0);
>    }
>
>    s->buffer= buffer;
>    s->size_in_bits= bit_size;
>    s->buffer_end= buffer + buffer_size;
>
>    s->index=0;
># 794 "bitstream.h"
>}
>
>static inline void align_get_bits(GetBitContext *s)
>{
>    int n= (-get_bits_count(s)) & 7;
>    if(n) skip_bits(s, n);
>}
># 811 "bitstream.h"
>int init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes,
>             const void *bits, int bits_wrap, int bits_size,
>             const void *codes, int codes_wrap, int codes_size,
>             const void *symbols, int symbols_wrap, int symbols_size,
>             int flags);
>
>
>void free_vlc(VLC *vlc);
># 890 "bitstream.h"
>static __attribute__((always_inline)) inline int get_vlc2(GetBitContext *s, int16_t (*table)[2],
>                                  int bits, int max_depth)
>{
>    int code;
>
>    int re_index= (s)->index; int re_cache= 0;
>    re_cache= unaligned32_be( ((const uint8_t *)(s)->buffer)+(re_index>>3) ) << (re_index&0x07);
>
>    { int n, index, nb_bits; index= NEG_USR32(re_cache, bits); code = table[index][0]; n = table[index][1]; if(max_depth > 1 && n < 0){ re_index += (bits); re_cache= unaligned32_be( ((const uint8_t *)(s)->buffer)+(re_index>>3) ) << (re_index&0x07); nb_bits = -n; index= NEG_USR32(re_cache, nb_bits) + code; code = table[index][0]; n = table[index][1]; if(max_depth > 2 && n < 0){ re_index += (nb_bits); re_cache= unaligned32_be( ((const uint8_t *)(s)->buffer)+(re_index>>3) ) << (re_index&0x07); nb_bits = -n; index= NEG_USR32(re_cache, nb_bits) + code; code = table[index][0]; n = table[index][1]; } } { re_cache <<= (n); re_index += (n); }}
>
>    (s)->index= re_index;
>    return code;
>}
># 957 "bitstream.h"
>static inline int decode012(GetBitContext *gb){
>    int n;
>    n = get_bits1(gb);
>    if (n == 0)
>        return 0;
>    else
>        return get_bits1(gb) + 1;
>}
># 33 "mpegvideo.h" 2
># 1 "ratecontrol.h" 1
># 31 "ratecontrol.h"
># 1 "eval.h" 1
># 35 "eval.h"
>double ff_eval(char *s, double *const_value, const char **const_name,
>               double (**func1)(void *, double), const char **func1_name,
>               double (**func2)(void *, double, double), char **func2_name,
>               void *opaque);
># 55 "eval.h"
>double ff_eval2(char *s, double *const_value, const char **const_name,
>               double (**func1)(void *, double), const char **func1_name,
>               double (**func2)(void *, double, double), char **func2_name,
>               void *opaque, char **error);
>
>typedef struct ff_expr_s AVEvalExpr;
># 74 "eval.h"
>AVEvalExpr * ff_parse(char *s, const char **const_name,
>               double (**func1)(void *, double), const char **func1_name,
>               double (**func2)(void *, double, double), char **func2_name,
>               char **error);
>
>
>
>
>
>
>double ff_parse_eval(AVEvalExpr * e, double *const_value, void *opaque);
>void ff_eval_free(AVEvalExpr * e);
># 32 "ratecontrol.h" 2
>
>typedef struct Predictor{
>    double coeff;
>    double count;
>    double decay;
>} Predictor;
>
>typedef struct RateControlEntry{
>    int pict_type;
>    float qscale;
>    int mv_bits;
>    int i_tex_bits;
>    int p_tex_bits;
>    int misc_bits;
>    int header_bits;
>    uint64_t expected_bits;
>    int new_pict_type;
>    float new_qscale;
>    int mc_mb_var_sum;
>    int mb_var_sum;
>    int i_count;
>    int skip_count;
>    int f_code;
>    int b_code;
>}RateControlEntry;
>
>
>
>
>typedef struct RateControlContext{
>    FILE *stats_file;
>    int num_entries;
>    RateControlEntry *entry;
>    double buffer_index;
>    Predictor pred[5];
>    double short_term_qsum;
>    double short_term_qcount;
>    double pass1_rc_eq_output_sum;
>    double pass1_wanted_bits;
>    double last_qscale;
>    double last_qscale_for[5];
>    int last_mc_mb_var_sum;
>    int last_mb_var_sum;
>    uint64_t i_cplx_sum[5];
>    uint64_t p_cplx_sum[5];
>    uint64_t mv_bits_sum[5];
>    uint64_t qscale_sum[5];
>    int frame_count[5];
>    int last_non_b_pict_type;
>
>    void *non_lavc_opaque;
>    float dry_run_qscale;
>    int last_picture_number;
>    AVEvalExpr * rc_eq_eval;
>}RateControlContext;
>
>struct MpegEncContext;
>
>
>int ff_rate_control_init(struct MpegEncContext *s);
>float ff_rate_estimate_qscale(struct MpegEncContext *s, int dry_run);
>void ff_write_pass1_stats(struct MpegEncContext *s);
>void ff_rate_control_uninit(struct MpegEncContext *s);
>int ff_vbv_update(struct MpegEncContext *s, int frame_size);
>void ff_get_2pass_fcode(struct MpegEncContext *s);
>
>int ff_xvid_rate_control_init(struct MpegEncContext *s);
>void ff_xvid_rate_control_uninit(struct MpegEncContext *s);
>float ff_xvid_rate_estimate_qscale(struct MpegEncContext *s, int dry_run);
># 34 "mpegvideo.h" 2
># 1 "parser.h" 1
># 28 "parser.h"
>typedef struct ParseContext{
>    uint8_t *buffer;
>    int index;
>    int last_index;
>    unsigned int buffer_size;
>    uint32_t state;
>    int frame_start_found;
>    int overread;
>    int overread_index;
>} ParseContext;
>
>struct MpegEncContext;
>
>typedef struct ParseContext1{
>    ParseContext pc;
>
>
>    AVRational frame_rate;
>    int progressive_sequence;
>    int width, height;
>
>
>    struct MpegEncContext *enc;
>    int first_picture;
>} ParseContext1;
>
>
>
>int ff_combine_frame(ParseContext *pc, int next, const uint8_t **buf, int *buf_size);
>int ff_mpeg4video_split(AVCodecContext *avctx, const uint8_t *buf,
>                        int buf_size);
>void ff_parse_close(AVCodecParserContext *s);
>void ff_parse1_close(AVCodecParserContext *s);
># 35 "mpegvideo.h" 2
>
>
>
>enum OutputFormat {
>    FMT_MPEG1,
>    FMT_H261,
>    FMT_H263,
>    FMT_MJPEG,
>    FMT_H264,
>};
># 92 "mpegvideo.h"
>typedef struct ScanTable{
>    const uint8_t *scantable;
>    uint8_t permutated[64];
>    uint8_t raster_end[64];
>
>
>
>
>} ScanTable;
>
>
>
>
>typedef struct Picture{
>    uint8_t *data[4]; int linesize[4]; uint8_t *base[4]; int key_frame; int pict_type; int64_t pts; int coded_picture_number; int display_picture_number; int quality; int age; int reference; int8_t *qscale_table; int qstride; uint8_t *mbskip_table; int16_t (*motion_val[2])[2]; uint32_t *mb_type; uint8_t motion_subsample_log2; void *opaque; uint64_t error[4]; int type; int repeat_pict; int qscale_type; int interlaced_frame; int top_field_first; AVPanScan *pan_scan; int palette_has_changed; int buffer_hints; short *dct_coeff; int8_t *ref_index[2];
>
>
>
>
>    uint8_t *interpolated[3];
>    int16_t (*motion_val_base[2])[2];
>    uint32_t *mb_type_base;
># 139 "mpegvideo.h"
>    int field_poc[2];
>    int poc;
>    int frame_num;
>    int pic_id;
>    int long_ref;
>    int ref_poc[2][16];
>    int ref_count[2];
>
>    int mb_var_sum;
>    int mc_mb_var_sum;
>    uint16_t *mb_var;
>    uint16_t *mc_mb_var;
>    uint8_t *mb_mean;
>    int32_t *mb_cmp_score;
>    int b_frame_score;
>} Picture;
>
>struct MpegEncContext;
>
>
>
>
>typedef struct MotionEstContext{
>    AVCodecContext *avctx;
>    int skip;
>    int co_located_mv[4][2];
>    int direct_basis_mv[4][2];
>    uint8_t *scratchpad;
>    uint8_t *best_mb;
>    uint8_t *temp_mb[2];
>    uint8_t *temp;
>    int best_bits;
>    uint32_t *map;
>    uint32_t *score_map;
>    int map_generation;
>    int pre_penalty_factor;
>    int penalty_factor;
>
>
>
>
>    int sub_penalty_factor;
>    int mb_penalty_factor;
>    int flags;
>    int sub_flags;
>    int mb_flags;
>    int pre_pass;
>    int dia_size;
>    int xmin;
>    int xmax;
>    int ymin;
>    int ymax;
>    int pred_x;
>    int pred_y;
>    uint8_t *src[4][4];
>    uint8_t *ref[4][4];
>    int stride;
>    int uvstride;
>
>    int mc_mb_var_sum_temp;
>    int mb_var_sum_temp;
>    int scene_change_score;
>
>    op_pixels_func (*hpel_put)[4];
>    op_pixels_func (*hpel_avg)[4];
>    qpel_mc_func (*qpel_put)[16];
>    qpel_mc_func (*qpel_avg)[16];
>    uint8_t (*mv_penalty)[2048*2+1];
>    uint8_t *current_mv_penalty;
>    int (*sub_motion_search)(struct MpegEncContext * s,
>                                  int *mx_ptr, int *my_ptr, int dmin,
>                                  int src_index, int ref_index,
>                                  int size, int h);
>}MotionEstContext;
>
>
>
>
>typedef struct MpegEncContext {
>    struct AVCodecContext *avctx;
>
>    int width, height;
>    int gop_size;
>    int intra_only;
>    int bit_rate;
>    enum OutputFormat out_format;
>    int h263_pred;
>
>
>    int h263_plus;
>    int h263_msmpeg4;
>    int h263_flv;
>
>    enum CodecID codec_id;
>    int fixed_qscale;
>    int encoding;
>    int flags;
>    int flags2;
>    int max_b_frames;
>    int luma_elim_threshold;
>    int chroma_elim_threshold;
>    int strict_std_compliance;
>    int workaround_bugs;
>    int codec_tag;
>    int stream_codec_tag;
>
>
>
>    PutBitContext pb;
>
>
>    int context_initialized;
>    int input_picture_number;
>    int coded_picture_number;
>    int picture_number;
>    int picture_in_gop_number;
>    int b_frames_since_non_b;
>    int64_t user_specified_pts;
>    int mb_width, mb_height;
>    int mb_stride;
>    int b8_stride;
>    int b4_stride;
>    int h_edge_pos, v_edge_pos;
>    int mb_num;
>    int linesize;
>    int uvlinesize;
>    Picture *picture;
>    Picture **input_picture;
>    Picture **reordered_input_picture;
>
>    int start_mb_y;
>    int end_mb_y;
>    struct MpegEncContext *thread_context[8];
>
>
>
>
>
>    Picture last_picture;
>
>
>
>
>
>    Picture next_picture;
>
>
>
>
>
>    Picture new_picture;
>
>
>
>
>
>    Picture current_picture;
>
>    Picture *last_picture_ptr;
>    Picture *next_picture_ptr;
>    Picture *current_picture_ptr;
>    uint8_t *visualization_buffer[3];
>    int last_dc[3];
>    int16_t *dc_val_base;
>    int16_t *dc_val[3];
>    int16_t dc_cache[4*5];
>    int y_dc_scale, c_dc_scale;
>    const uint8_t *y_dc_scale_table;
>    const uint8_t *c_dc_scale_table;
>    const uint8_t *chroma_qscale_table;
>    uint8_t *coded_block_base;
>    uint8_t *coded_block;
>    int16_t (*ac_val_base)[16];
>    int16_t (*ac_val[3])[16];
>    int ac_pred;
>    uint8_t *prev_pict_types;
>
>    int mb_skipped;
>    uint8_t *mbskip_table;
>
>    uint8_t *mbintra_table;
>    uint8_t *cbp_table;
>    uint8_t *pred_dir_table;
>    uint8_t *allocated_edge_emu_buffer;
>    uint8_t *edge_emu_buffer;
>    uint8_t *rd_scratchpad;
>    uint8_t *obmc_scratchpad;
>    uint8_t *b_scratchpad;
>
>    int qscale;
>    int chroma_qscale;
>    unsigned int lambda;
>    unsigned int lambda2;
>    int *lambda_table;
>    int adaptive_quant;
>    int dquant;
>    int pict_type;
>    int last_pict_type;
>    int last_non_b_pict_type;
>    int dropable;
>    int frame_rate_index;
>    int last_lambda_for[5];
>    int skipdct;
>
>
>    int unrestricted_mv;
>    int h263_long_vectors;
>    int decode;
>
>    DSPContext dsp;
>    int f_code;
>    int b_code;
>    int16_t (*p_mv_table_base)[2];
>    int16_t (*b_forw_mv_table_base)[2];
>    int16_t (*b_back_mv_table_base)[2];
>    int16_t (*b_bidir_forw_mv_table_base)[2];
>    int16_t (*b_bidir_back_mv_table_base)[2];
>    int16_t (*b_direct_mv_table_base)[2];
>    int16_t (*p_field_mv_table_base[2][2])[2];
>    int16_t (*b_field_mv_table_base[2][2][2])[2];
>    int16_t (*p_mv_table)[2];
>    int16_t (*b_forw_mv_table)[2];
>    int16_t (*b_back_mv_table)[2];
>    int16_t (*b_bidir_forw_mv_table)[2];
>    int16_t (*b_bidir_back_mv_table)[2];
>    int16_t (*b_direct_mv_table)[2];
>    int16_t (*p_field_mv_table[2][2])[2];
>    int16_t (*b_field_mv_table[2][2][2])[2];
>    uint8_t (*p_field_select_table[2]);
>    uint8_t (*b_field_select_table[2][2]);
>    int me_method;
>    int mv_dir;
>
>
>
>    int mv_type;
># 385 "mpegvideo.h"
>    int mv[2][4][2];
>    int field_select[2][2];
>    int last_mv[2][2][2];
>    uint8_t *fcode_tab;
>    int16_t direct_scale_mv[2][64];
>
>    MotionEstContext me;
>
>    int no_rounding;
>
>
>    int hurry_up;
>
>
>
>    int mb_x, mb_y;
>    int mb_skip_run;
>    int mb_intra;
>    uint16_t *mb_type;
># 422 "mpegvideo.h"
>    int block_index[6];
>    int block_wrap[6];
>    uint8_t *dest[3];
>
>    int *mb_index2xy;
>
>
>    uint16_t intra_matrix[64];
>    uint16_t chroma_intra_matrix[64];
>    uint16_t inter_matrix[64];
>    uint16_t chroma_inter_matrix[64];
>
>    int intra_quant_bias;
>    int inter_quant_bias;
>    int min_qcoeff;
>    int max_qcoeff;
>    int ac_esc_length;
>    uint8_t *intra_ac_vlc_length;
>    uint8_t *intra_ac_vlc_last_length;
>    uint8_t *inter_ac_vlc_length;
>    uint8_t *inter_ac_vlc_last_length;
>    uint8_t *luma_dc_vlc_length;
>    uint8_t *chroma_dc_vlc_length;
>
>
>    int coded_score[8];
>
>
>    int (*q_intra_matrix)[64];
>    int (*q_inter_matrix)[64];
>
>    uint16_t (*q_intra_matrix16)[2][64];
>    uint16_t (*q_inter_matrix16)[2][64];
>    int block_last_index[12];
>
>    ScanTable intra_scantable __attribute__ ((aligned (8)));
>    ScanTable intra_h_scantable;
>    ScanTable intra_v_scantable;
>    ScanTable inter_scantable;
>
>
>    int (*dct_error_sum)[64];
>    int dct_count[2];
>    uint16_t (*dct_offset)[64];
>
>    void *opaque;
>
>
>    int64_t wanted_bits;
>    int64_t total_bits;
>    int frame_bits;
>    int next_lambda;
>    RateControlContext rc_context;
>
>
>    int mv_bits;
>    int header_bits;
>    int i_tex_bits;
>    int p_tex_bits;
>    int i_count;
>    int f_count;
>    int b_count;
>    int skip_count;
>    int misc_bits;
>    int last_bits;
>
>
>    int error_count;
>    uint8_t *error_status_table;
># 500 "mpegvideo.h"
>    int resync_mb_x;
>    int resync_mb_y;
>    GetBitContext last_resync_gb;
>    int mb_num_left;
>    int next_p_frame_damaged;
>    int error_resilience;
>
>    ParseContext parse_context;
>
>
>    int gob_index;
>    int obmc;
>
>
>    int umvplus;
>    int h263_aic;
>    int h263_aic_dir;
>    int h263_slice_structured;
>    int alt_inter_vlc;
>    int modified_quant;
>    int loop_filter;
>    int custom_pcf;
>
>
>    int time_increment_bits;
>    int last_time_base;
>    int time_base;
>    int64_t time_is_forbidden_due_to_security_issues;
>    int64_t last_non_b_time;
>    uint16_t pp_time;
>    uint16_t pb_time;
>    uint16_t pp_field_time;
>    uint16_t pb_field_time;
>    int shape;
>    int vol_sprite_usage;
>    int sprite_width;
>    int sprite_height;
>    int sprite_left;
>    int sprite_top;
>    int sprite_brightness_change;
>    int num_sprite_warping_points;
>    int real_sprite_warping_points;
>    int sprite_offset[2][2];
>    int sprite_delta[2][2];
>    int sprite_shift[2];
>    int mcsel;
>    int quant_precision;
>    int quarter_sample;
>    int scalability;
>    int hierachy_type;
>    int enhancement_type;
>    int new_pred;
>    int reduced_res_vop;
>    int aspect_ratio_info;
>    int sprite_warping_accuracy;
>    int low_latency_sprite;
>    int data_partitioning;
>    int partitioned_frame;
>    int rvlc;
>    int resync_marker;
>    int low_delay;
>    int vo_type;
>    int vol_control_parameters;
>    int intra_dc_threshold;
>    int use_intra_dc_vlc;
>    PutBitContext tex_pb;
>    PutBitContext pb2;
>    int mpeg_quant;
>    int t_frame;
>    int padding_bug_score;
>
>
>    int divx_version;
>    int divx_build;
>    int divx_packed;
>    uint8_t *bitstream_buffer;
>    int bitstream_buffer_size;
>    unsigned int allocated_bitstream_buffer_size;
>
>    int xvid_build;
>
>
>    int lavc_build;
>
>
>    int rv10_version;
>    int rv10_first_dc_coded[3];
>
>
>    struct MJpegContext *mjpeg_ctx;
>    int mjpeg_vsample[3];
>    int mjpeg_hsample[3];
>
>
>    int mv_table_index;
>    int rl_table_index;
>    int rl_chroma_table_index;
>    int dc_table_index;
>    int use_skip_mb_code;
>    int slice_height;
>    int first_slice_line;
>    int flipflop_rounding;
>    int msmpeg4_version;
>    int per_mb_rl_table;
>    int esc3_level_length;
>    int esc3_run_length;
>
>    int (*ac_stats)[2][64 +1][64 +1][2];
>    int inter_intra_pred;
>    int mspel;
>
>
>    GetBitContext gb;
>
>
>    int gop_picture_number;
>    int last_mv_dir;
>    int broken_link;
>    uint8_t *vbv_delay_ptr;
>
>
>    int progressive_sequence;
>    int mpeg_f_code[2][2];
>    int picture_structure;
>
>
>
>
>
>    int intra_dc_precision;
>    int frame_pred_frame_dct;
>    int top_field_first;
>    int concealment_motion_vectors;
>    int q_scale_type;
>    int intra_vlc_format;
>    int alternate_scan;
>    int repeat_first_field;
>    int chroma_420_type;
>    int chroma_format;
>
>
>
>    int chroma_x_shift;
>    int chroma_y_shift;
>
>    int progressive_frame;
>    int full_pel[2];
>    int interlaced_dct;
>    int first_slice;
>    int first_field;
>
>
>    int rtp_mode;
>
>    uint8_t *ptr_lastgob;
>    int swap_uv;
>    short * pblocks[12];
>
>    DCTELEM (*block)[64];
>    DCTELEM (*blocks)[8][64];
>    int (*decode_mb)(struct MpegEncContext *s, DCTELEM block[6][64]);
>
>
>
>
>
>    void (*dct_unquantize_mpeg1_intra)(struct MpegEncContext *s,
>                           DCTELEM *block , int n, int qscale);
>    void (*dct_unquantize_mpeg1_inter)(struct MpegEncContext *s,
>                           DCTELEM *block , int n, int qscale);
>    void (*dct_unquantize_mpeg2_intra)(struct MpegEncContext *s,
>                           DCTELEM *block , int n, int qscale);
>    void (*dct_unquantize_mpeg2_inter)(struct MpegEncContext *s,
>                           DCTELEM *block , int n, int qscale);
>    void (*dct_unquantize_h263_intra)(struct MpegEncContext *s,
>                           DCTELEM *block , int n, int qscale);
>    void (*dct_unquantize_h263_inter)(struct MpegEncContext *s,
>                           DCTELEM *block , int n, int qscale);
>    void (*dct_unquantize_h261_intra)(struct MpegEncContext *s,
>                           DCTELEM *block , int n, int qscale);
>    void (*dct_unquantize_h261_inter)(struct MpegEncContext *s,
>                           DCTELEM *block , int n, int qscale);
>    void (*dct_unquantize_intra)(struct MpegEncContext *s,
>                           DCTELEM *block , int n, int qscale);
>    void (*dct_unquantize_inter)(struct MpegEncContext *s,
>                           DCTELEM *block , int n, int qscale);
>    int (*dct_quantize)(struct MpegEncContext *s, DCTELEM *block , int n, int qscale, int *overflow);
>    int (*fast_dct_quantize)(struct MpegEncContext *s, DCTELEM *block , int n, int qscale, int *overflow);
>    void (*denoise_dct)(struct MpegEncContext *s, DCTELEM *block);
>} MpegEncContext;
>
>
>int DCT_common_init(MpegEncContext *s);
>void MPV_decode_defaults(MpegEncContext *s);
>int MPV_common_init(MpegEncContext *s);
>void MPV_common_end(MpegEncContext *s);
>void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]);
>int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx);
>void MPV_frame_end(MpegEncContext *s);
>int MPV_encode_init(AVCodecContext *avctx);
>int MPV_encode_end(AVCodecContext *avctx);
>int MPV_encode_picture(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data);
># 720 "mpegvideo.h"
>extern void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w);
>void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length);
>void ff_clean_intra_table_entries(MpegEncContext *s);
>void ff_init_scantable(uint8_t *, ScanTable *st, const uint8_t *src_scantable);
>void ff_draw_horiz_band(MpegEncContext *s, int y, int h);
>void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
>                                    int src_x, int src_y, int w, int h);
>void ff_mpeg_flush(AVCodecContext *avctx);
>void ff_print_debug_info(MpegEncContext *s, AVFrame *pict);
>void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix);
>int ff_find_unused_picture(MpegEncContext *s, int shared);
>void ff_denoise_dct(MpegEncContext *s, DCTELEM *block);
>void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src);
>const uint8_t *ff_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state);
>
>void ff_er_frame_start(MpegEncContext *s);
>void ff_er_frame_end(MpegEncContext *s);
>void ff_er_add_slice(MpegEncContext *s, int startx, int starty, int endx, int endy, int status);
>
>
>extern enum PixelFormat ff_yuv420p_list[2];
>
>void ff_init_block_index(MpegEncContext *s);
>
>static inline void ff_update_block_index(MpegEncContext *s){
>    const int block_size= 8>>s->avctx->lowres;
>
>    s->block_index[0]+=2;
>    s->block_index[1]+=2;
>    s->block_index[2]+=2;
>    s->block_index[3]+=2;
>    s->block_index[4]++;
>    s->block_index[5]++;
>    s->dest[0]+= 2*block_size;
>    s->dest[1]+= block_size;
>    s->dest[2]+= block_size;
>}
>
>static inline int get_bits_diff(MpegEncContext *s){
>    const int bits= put_bits_count(&s->pb);
>    const int last= s->last_bits;
>
>    s->last_bits = bits;
>
>    return bits - last;
>}
>
>
>void ff_estimate_p_frame_motion(MpegEncContext * s,
>                             int mb_x, int mb_y);
>void ff_estimate_b_frame_motion(MpegEncContext * s,
>                             int mb_x, int mb_y);
>int ff_get_best_fcode(MpegEncContext * s, int16_t (*mv_table)[2], int type);
>void ff_fix_long_p_mvs(MpegEncContext * s);
>void ff_fix_long_mvs(MpegEncContext * s, uint8_t *field_select_table, int field_select,
>                     int16_t (*mv_table)[2], int f_code, int type, int truncate);
>void ff_init_me(MpegEncContext *s);
>int ff_pre_estimate_p_frame_motion(MpegEncContext * s, int mb_x, int mb_y);
>inline int ff_epzs_motion_search(MpegEncContext * s, int *mx_ptr, int *my_ptr,
>                             int P[10][2], int src_index, int ref_index, int16_t (*last_mv)[2],
>                             int ref_mv_scale, int size, int h);
>inline int ff_get_mb_score(MpegEncContext * s, int mx, int my, int src_index,
>                               int ref_index, int size, int h, int add_rate);
>
>
>extern const uint16_t ff_mpeg1_default_intra_matrix[64];
>extern const uint16_t ff_mpeg1_default_non_intra_matrix[64];
>extern const uint8_t ff_mpeg1_dc_scale_table[128];
>extern const AVRational ff_frame_rate_tab[];
>
>void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number);
>void mpeg1_encode_mb(MpegEncContext *s,
>                     DCTELEM block[6][64],
>                     int motion_x, int motion_y);
>void ff_mpeg1_encode_init(MpegEncContext *s);
>void ff_mpeg1_encode_slice_header(MpegEncContext *s);
>void ff_mpeg1_clean_buffers(MpegEncContext *s);
>int ff_mpeg1_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size);
>
># 1 "rl.h" 1
># 10 "rl.h"
>typedef struct RLTable {
>    int n;
>    int last;
>    const uint16_t (*table_vlc)[2];
>    const int8_t *table_run;
>    const int8_t *table_level;
>    uint8_t *index_run[2];
>    int8_t *max_level[2];
>    int8_t *max_run[2];
>    VLC vlc;
>    RL_VLC_ELEM *rl_vlc[32];
>} RLTable;
>
>
>
>
>
>
>void init_rl(RLTable *rl, uint8_t static_store[2][2*64 + 64 + 3]);
>void init_vlc_rl(RLTable *rl, int use_static);
>
>static inline int get_rl_index(const RLTable *rl, int last, int run, int level)
>{
>    int index;
>    index = rl->index_run[last][run];
>    if (index >= rl->n)
>        return rl->n;
>    if (level > rl->max_level[last][run])
>        return rl->n;
>    return index + level - 1;
>}
># 800 "mpegvideo.h" 2
>
>extern const uint8_t ff_mpeg4_y_dc_scale_table[32];
>extern const uint8_t ff_mpeg4_c_dc_scale_table[32];
>extern const uint8_t ff_aic_dc_scale_table[32];
>extern const int16_t ff_mpeg4_default_intra_matrix[64];
>extern const int16_t ff_mpeg4_default_non_intra_matrix[64];
>extern const uint8_t ff_h263_chroma_qscale_table[32];
>extern const uint8_t ff_h263_loop_filter_strength[32];
>
>
>void ff_h261_loop_filter(MpegEncContext *s);
>void ff_h261_reorder_mb_index(MpegEncContext* s);
>void ff_h261_encode_mb(MpegEncContext *s,
>                    DCTELEM block[6][64],
>                    int motion_x, int motion_y);
>void ff_h261_encode_picture_header(MpegEncContext * s, int picture_number);
>void ff_h261_encode_init(MpegEncContext *s);
>int ff_h261_get_picture_format(int width, int height);
>
>
>
>int ff_h263_decode_init(AVCodecContext *avctx);
>int ff_h263_decode_frame(AVCodecContext *avctx,
>                             void *data, int *data_size,
>                             uint8_t *buf, int buf_size);
>int ff_h263_decode_end(AVCodecContext *avctx);
>void h263_encode_mb(MpegEncContext *s,
>                    DCTELEM block[6][64],
>                    int motion_x, int motion_y);
>void mpeg4_encode_mb(MpegEncContext *s,
>                    DCTELEM block[6][64],
>                    int motion_x, int motion_y);
>void h263_encode_picture_header(MpegEncContext *s, int picture_number);
>void ff_flv_encode_picture_header(MpegEncContext *s, int picture_number);
>void h263_encode_gob_header(MpegEncContext * s, int mb_line);
>int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
>                        int *px, int *py);
>void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
>                   int dir);
>void ff_set_mpeg4_time(MpegEncContext * s, int picture_number);
>void mpeg4_encode_picture_header(MpegEncContext *s, int picture_number);
>
>void h263_encode_init(MpegEncContext *s);
>
>
>
>void h263_decode_init_vlc(MpegEncContext *s);
>int h263_decode_picture_header(MpegEncContext *s);
>int ff_h263_decode_gob_header(MpegEncContext *s);
>int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb);
>void ff_h263_update_motion_val(MpegEncContext * s);
>void ff_h263_loop_filter(MpegEncContext * s);
>void ff_set_qscale(MpegEncContext * s, int qscale);
>int ff_h263_decode_mba(MpegEncContext *s);
>void ff_h263_encode_mba(MpegEncContext *s);
>
>int intel_h263_decode_picture_header(MpegEncContext *s);
>int flv_h263_decode_picture_header(MpegEncContext *s);
>int ff_h263_decode_mb(MpegEncContext *s,
>                      DCTELEM block[6][64]);
>int ff_mpeg4_decode_mb(MpegEncContext *s,
>                      DCTELEM block[6][64]);
>int h263_get_picture_format(int width, int height);
>void ff_mpeg4_encode_video_packet_header(MpegEncContext *s);
>void ff_mpeg4_clean_buffers(MpegEncContext *s);
>void ff_mpeg4_stuffing(PutBitContext * pbc);
>void ff_mpeg4_init_partitions(MpegEncContext *s);
>void ff_mpeg4_merge_partitions(MpegEncContext *s);
>void ff_clean_mpeg4_qscales(MpegEncContext *s);
>void ff_clean_h263_qscales(MpegEncContext *s);
>int ff_mpeg4_decode_partitions(MpegEncContext *s);
>int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s);
>int ff_h263_resync(MpegEncContext *s);
>int ff_h263_get_gob_height(MpegEncContext *s);
>void ff_mpeg4_init_direct_mv(MpegEncContext *s);
>int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my);
>int ff_h263_round_chroma(int x);
>void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code);
>
>
>
>void rv10_encode_picture_header(MpegEncContext *s, int picture_number);
>int rv_decode_dc(MpegEncContext *s, int n);
>void rv20_encode_picture_header(MpegEncContext *s, int picture_number);
>
>
>
>void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number);
>void msmpeg4_encode_ext_header(MpegEncContext * s);
>void msmpeg4_encode_mb(MpegEncContext * s,
>                       DCTELEM block[6][64],
>                       int motion_x, int motion_y);
>int msmpeg4_decode_picture_header(MpegEncContext * s);
>int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size);
>int ff_msmpeg4_decode_init(MpegEncContext *s);
>void ff_msmpeg4_encode_init(MpegEncContext *s);
>int ff_wmv2_decode_picture_header(MpegEncContext * s);
>int ff_wmv2_decode_secondary_picture_header(MpegEncContext * s);
>void ff_wmv2_add_mb(MpegEncContext *s, DCTELEM block[6][64], uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr);
>void ff_mspel_motion(MpegEncContext *s,
>                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
>                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
>                               int motion_x, int motion_y, int h);
>int ff_wmv2_encode_picture_header(MpegEncContext * s, int picture_number);
>void ff_wmv2_encode_mb(MpegEncContext * s,
>                       DCTELEM block[6][64],
>                       int motion_x, int motion_y);
># 33 "dsputil.c" 2
># 1 "simple_idct.h" 1
># 28 "simple_idct.h"
>void simple_idct_put(uint8_t *dest, int line_size, DCTELEM *block);
>void simple_idct_add(uint8_t *dest, int line_size, DCTELEM *block);
>void ff_simple_idct_mmx(int16_t *block);
>void ff_simple_idct_add_mmx(uint8_t *dest, int line_size, int16_t *block);
>void ff_simple_idct_put_mmx(uint8_t *dest, int line_size, int16_t *block);
>void simple_idct(DCTELEM *block);
>
>void simple_idct248_put(uint8_t *dest, int line_size, DCTELEM *block);
>
>void simple_idct84_add(uint8_t *dest, int line_size, DCTELEM *block);
>void simple_idct48_add(uint8_t *dest, int line_size, DCTELEM *block);
># 34 "dsputil.c" 2
># 1 "faandct.h" 1
># 32 "faandct.h"
>void ff_faandct(DCTELEM * data);
>void ff_faandct248(DCTELEM * data);
># 35 "dsputil.c" 2
># 1 "snow.h" 1
># 45 "snow.h"
>struct slice_buffer_s {
>    DWTELEM * * line;
>    DWTELEM * * data_stack;
>    int data_stack_top;
>    int line_count;
>    int line_width;
>    int data_count;
>    DWTELEM * base_buffer;
>};
># 126 "snow.h"
>extern void ff_snow_vertical_compose97i(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, DWTELEM *b3, DWTELEM *b4, DWTELEM *b5, int width);
>extern void ff_snow_horizontal_compose97i(DWTELEM *b, int width);
>extern void ff_snow_inner_add_yblock(const uint8_t *obmc, const int obmc_stride, uint8_t * * block, int b_w, int b_h, int src_x, int src_y, int src_stride, slice_buffer * sb, int add, uint8_t * dst8);
>
>
>int w53_32_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h);
>int w97_32_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h);
>
>
>
>
>
>
>
>static __attribute__((always_inline)) inline void snow_interleave_line_header(int * i, int width, DWTELEM * low, DWTELEM * high){
>    (*i) = (width) - 2;
>
>    if (width & 1){
>        low[(*i)+1] = low[((*i)+1)>>1];
>        (*i)--;
>    }
>}
>
>static __attribute__((always_inline)) inline void snow_interleave_line_footer(int * i, DWTELEM * low, DWTELEM * high){
>    for (; (*i)>=0; (*i)-=2){
>        low[(*i)+1] = high[(*i)>>1];
>        low[*i] = low[(*i)>>1];
>    }
>}
>
>static __attribute__((always_inline)) inline void snow_horizontal_compose_lift_lead_out(int i, DWTELEM * dst, DWTELEM * src, DWTELEM * ref, int width, int w, int lift_high, int mul, int add, int shift){
>    for(; i<w; i++){
>        dst[i] = src[i] - ((mul * (ref[i] + ref[i + 1]) + add) >> shift);
>    }
>
>    if((width^lift_high)&1){
>        dst[w] = src[w] - ((mul * 2 * ref[w] + add) >> shift);
>    }
>}
>
>static __attribute__((always_inline)) inline void snow_horizontal_compose_liftS_lead_out(int i, DWTELEM * dst, DWTELEM * src, DWTELEM * ref, int width, int w){
>        for(; i<w; i++){
>            dst[i] = src[i] - (((-(ref[i] + ref[(i+1)])+8) - 4 * src[i]) >> 4);
>        }
>
>        if(width&1){
>            dst[w] = src[w] - (((-2 * ref[w] + 8) - 4 * src[w]) >> 4);
>        }
>}
># 36 "dsputil.c" 2
>
>
>void ff_spatial_dwt(int *buffer, int width, int height, int stride, int type, int decomposition_count);
>
>
>void vorbis_inverse_coupling(float *mag, float *ang, int blocksize);
>
>uint8_t ff_cropTbl[256 + 2 * 1024] = {0, };
>uint32_t ff_squareTbl[512] = {0, };
>
>const uint8_t ff_zigzag_direct[64] = {
>    0, 1, 8, 16, 9, 2, 3, 10,
>    17, 24, 32, 25, 18, 11, 4, 5,
>    12, 19, 26, 33, 40, 48, 41, 34,
>    27, 20, 13, 6, 7, 14, 21, 28,
>    35, 42, 49, 56, 57, 50, 43, 36,
>    29, 22, 15, 23, 30, 37, 44, 51,
>    58, 59, 52, 45, 38, 31, 39, 46,
>    53, 60, 61, 54, 47, 55, 62, 63
>};
>
>
>
>const uint8_t ff_zigzag248_direct[64] = {
>     0, 8, 1, 9, 16, 24, 2, 10,
>    17, 25, 32, 40, 48, 56, 33, 41,
>    18, 26, 3, 11, 4, 12, 19, 27,
>    34, 42, 49, 57, 50, 58, 35, 43,
>    20, 28, 5, 13, 6, 14, 21, 29,
>    36, 44, 51, 59, 52, 60, 37, 45,
>    22, 30, 7, 15, 23, 31, 38, 46,
>    53, 61, 54, 62, 39, 47, 55, 63,
>};
>
>
>uint16_t inv_zigzag_direct16[64] __attribute__ ((aligned (8))) = {0, };
>
>const uint8_t ff_alternate_horizontal_scan[64] = {
>    0, 1, 2, 3, 8, 9, 16, 17,
>    10, 11, 4, 5, 6, 7, 15, 14,
>    13, 12, 19, 18, 24, 25, 32, 33,
>    26, 27, 20, 21, 22, 23, 28, 29,
>    30, 31, 34, 35, 40, 41, 48, 49,
>    42, 43, 36, 37, 38, 39, 44, 45,
>    46, 47, 50, 51, 56, 57, 58, 59,
>    52, 53, 54, 55, 60, 61, 62, 63,
>};
>
>const uint8_t ff_alternate_vertical_scan[64] = {
>    0, 8, 16, 24, 1, 9, 2, 10,
>    17, 25, 32, 40, 48, 56, 57, 49,
>    41, 33, 26, 18, 3, 11, 4, 12,
>    19, 27, 34, 42, 50, 58, 35, 43,
>    51, 59, 20, 28, 5, 13, 6, 14,
>    21, 29, 36, 44, 52, 60, 37, 45,
>    53, 61, 22, 30, 7, 15, 23, 31,
>    38, 46, 54, 62, 39, 47, 55, 63,
>};
>
>
>const uint32_t ff_inverse[256]={
>         0, 4294967295U,2147483648U,1431655766, 1073741824, 858993460, 715827883, 613566757,
> 536870912, 477218589, 429496730, 390451573, 357913942, 330382100, 306783379, 286331154,
> 268435456, 252645136, 238609295, 226050911, 214748365, 204522253, 195225787, 186737709,
> 178956971, 171798692, 165191050, 159072863, 153391690, 148102321, 143165577, 138547333,
> 134217728, 130150525, 126322568, 122713352, 119304648, 116080198, 113025456, 110127367,
> 107374183, 104755300, 102261127, 99882961, 97612894, 95443718, 93368855, 91382283,
>  89478486, 87652394, 85899346, 84215046, 82595525, 81037119, 79536432, 78090315,
>  76695845, 75350304, 74051161, 72796056, 71582789, 70409300, 69273667, 68174085,
>  67108864, 66076420, 65075263, 64103990, 63161284, 62245903, 61356676, 60492498,
>  59652324, 58835169, 58040099, 57266231, 56512728, 55778797, 55063684, 54366675,
>  53687092, 53024288, 52377650, 51746594, 51130564, 50529028, 49941481, 49367441,
>  48806447, 48258060, 47721859, 47197443, 46684428, 46182445, 45691142, 45210183,
>  44739243, 44278014, 43826197, 43383509, 42949673, 42524429, 42107523, 41698712,
>  41297763, 40904451, 40518560, 40139882, 39768216, 39403370, 39045158, 38693400,
>  38347923, 38008561, 37675152, 37347542, 37025581, 36709123, 36398028, 36092163,
>  35791395, 35495598, 35204650, 34918434, 34636834, 34359739, 34087043, 33818641,
>  33554432, 33294321, 33038210, 32786010, 32537632, 32292988, 32051995, 31814573,
>  31580642, 31350127, 31122952, 30899046, 30678338, 30460761, 30246249, 30034737,
>  29826162, 29620465, 29417585, 29217465, 29020050, 28825284, 28633116, 28443493,
>  28256364, 28071682, 27889399, 27709467, 27531842, 27356480, 27183338, 27012373,
>  26843546, 26676816, 26512144, 26349493, 26188825, 26030105, 25873297, 25718368,
>  25565282, 25414008, 25264514, 25116768, 24970741, 24826401, 24683721, 24542671,
>  24403224, 24265352, 24129030, 23994231, 23860930, 23729102, 23598722, 23469767,
>  23342214, 23216040, 23091223, 22967740, 22845571, 22724695, 22605092, 22486740,
>  22369622, 22253717, 22139007, 22025474, 21913099, 21801865, 21691755, 21582751,
>  21474837, 21367997, 21262215, 21157475, 21053762, 20951060, 20849356, 20748635,
>  20648882, 20550083, 20452226, 20355296, 20259280, 20164166, 20069941, 19976593,
>  19884108, 19792477, 19701685, 19611723, 19522579, 19434242, 19346700, 19259944,
>  19173962, 19088744, 19004281, 18920561, 18837576, 18755316, 18673771, 18592933,
>  18512791, 18433337, 18354562, 18276457, 18199014, 18122225, 18046082, 17970575,
>  17895698, 17821442, 17747799, 17674763, 17602325, 17530479, 17459217, 17388532,
>  17318417, 17248865, 17179870, 17111424, 17043522, 16976156, 16909321, 16843010,
>};
>
>
>static const uint8_t simple_mmx_permutation[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 int pix_sum_c(uint8_t * pix, int line_size)
>{
>    int s, i, j;
>
>    s = 0;
>    for (i = 0; i < 16; i++) {
>        for (j = 0; j < 16; j += 8) {
>            s += pix[0];
>            s += pix[1];
>            s += pix[2];
>            s += pix[3];
>            s += pix[4];
>            s += pix[5];
>            s += pix[6];
>            s += pix[7];
>            pix += 8;
>        }
>        pix += line_size - 16;
>    }
>    return s;
>}
>
>static int pix_norm1_c(uint8_t * pix, int line_size)
>{
>    int s, i, j;
>    uint32_t *sq = ff_squareTbl + 256;
>
>    s = 0;
>    for (i = 0; i < 16; i++) {
>        for (j = 0; j < 16; j += 8) {
># 184 "dsputil.c"
>            register uint64_t x=*(uint64_t*)pix;
>            s += sq[x&0xff];
>            s += sq[(x>>8)&0xff];
>            s += sq[(x>>16)&0xff];
>            s += sq[(x>>24)&0xff];
>            s += sq[(x>>32)&0xff];
>            s += sq[(x>>40)&0xff];
>            s += sq[(x>>48)&0xff];
>            s += sq[(x>>56)&0xff];
># 206 "dsputil.c"
>            pix += 8;
>        }
>        pix += line_size - 16;
>    }
>    return s;
>}
>
>static void bswap_buf(uint32_t *dst, uint32_t *src, int w){
>    int i;
>
>    for(i=0; i+8<=w; i+=8){
>        dst[i+0]= (__extension__ ({ register unsigned int __v, __x = (src[i+0]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("bswap %0" : "=r" (__v) : "0" (__x)); __v; }));
>        dst[i+1]= (__extension__ ({ register unsigned int __v, __x = (src[i+1]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("bswap %0" : "=r" (__v) : "0" (__x)); __v; }));
>        dst[i+2]= (__extension__ ({ register unsigned int __v, __x = (src[i+2]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("bswap %0" : "=r" (__v) : "0" (__x)); __v; }));
>        dst[i+3]= (__extension__ ({ register unsigned int __v, __x = (src[i+3]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("bswap %0" : "=r" (__v) : "0" (__x)); __v; }));
>        dst[i+4]= (__extension__ ({ register unsigned int __v, __x = (src[i+4]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("bswap %0" : "=r" (__v) : "0" (__x)); __v; }));
>        dst[i+5]= (__extension__ ({ register unsigned int __v, __x = (src[i+5]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("bswap %0" : "=r" (__v) : "0" (__x)); __v; }));
>        dst[i+6]= (__extension__ ({ register unsigned int __v, __x = (src[i+6]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("bswap %0" : "=r" (__v) : "0" (__x)); __v; }));
>        dst[i+7]= (__extension__ ({ register unsigned int __v, __x = (src[i+7]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("bswap %0" : "=r" (__v) : "0" (__x)); __v; }));
>    }
>    for(;i<w; i++){
>        dst[i+0]= (__extension__ ({ register unsigned int __v, __x = (src[i+0]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("bswap %0" : "=r" (__v) : "0" (__x)); __v; }));
>    }
>}
>
>static int sse4_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h)
>{
>    int s, i;
>    uint32_t *sq = ff_squareTbl + 256;
>
>    s = 0;
>    for (i = 0; i < h; i++) {
>        s += sq[pix1[0] - pix2[0]];
>        s += sq[pix1[1] - pix2[1]];
>        s += sq[pix1[2] - pix2[2]];
>        s += sq[pix1[3] - pix2[3]];
>        pix1 += line_size;
>        pix2 += line_size;
>    }
>    return s;
>}
>
>static int sse8_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h)
>{
>    int s, i;
>    uint32_t *sq = ff_squareTbl + 256;
>
>    s = 0;
>    for (i = 0; i < h; i++) {
>        s += sq[pix1[0] - pix2[0]];
>        s += sq[pix1[1] - pix2[1]];
>        s += sq[pix1[2] - pix2[2]];
>        s += sq[pix1[3] - pix2[3]];
>        s += sq[pix1[4] - pix2[4]];
>        s += sq[pix1[5] - pix2[5]];
>        s += sq[pix1[6] - pix2[6]];
>        s += sq[pix1[7] - pix2[7]];
>        pix1 += line_size;
>        pix2 += line_size;
>    }
>    return s;
>}
>
>static int sse16_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
>{
>    int s, i;
>    uint32_t *sq = ff_squareTbl + 256;
>
>    s = 0;
>    for (i = 0; i < h; i++) {
>        s += sq[pix1[ 0] - pix2[ 0]];
>        s += sq[pix1[ 1] - pix2[ 1]];
>        s += sq[pix1[ 2] - pix2[ 2]];
>        s += sq[pix1[ 3] - pix2[ 3]];
>        s += sq[pix1[ 4] - pix2[ 4]];
>        s += sq[pix1[ 5] - pix2[ 5]];
>        s += sq[pix1[ 6] - pix2[ 6]];
>        s += sq[pix1[ 7] - pix2[ 7]];
>        s += sq[pix1[ 8] - pix2[ 8]];
>        s += sq[pix1[ 9] - pix2[ 9]];
>        s += sq[pix1[10] - pix2[10]];
>        s += sq[pix1[11] - pix2[11]];
>        s += sq[pix1[12] - pix2[12]];
>        s += sq[pix1[13] - pix2[13]];
>        s += sq[pix1[14] - pix2[14]];
>        s += sq[pix1[15] - pix2[15]];
>
>        pix1 += line_size;
>        pix2 += line_size;
>    }
>    return s;
>}
>
>
>
>static inline int w_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int w, int h, int type){
>    int s, i, j;
>    const int dec_count= w==8 ? 3 : 4;
>    int tmp[32*32];
>    int level, ori;
>    static const int scale[2][2][4][4]={
>      {
>        {
>
>            {268, 239, 239, 213},
>            { 0, 224, 224, 152},
>            { 0, 135, 135, 110},
>        },{
>
>            {344, 310, 310, 280},
>            { 0, 320, 320, 228},
>            { 0, 175, 175, 136},
>            { 0, 129, 129, 102},
>        }
>      },{
>        {
>
>            {275, 245, 245, 218},
>            { 0, 230, 230, 156},
>            { 0, 138, 138, 113},
>        },{
>
>            {352, 317, 317, 286},
>            { 0, 328, 328, 233},
>            { 0, 180, 180, 140},
>            { 0, 132, 132, 105},
>        }
>      }
>    };
>
>    for (i = 0; i < h; i++) {
>        for (j = 0; j < w; j+=4) {
>            tmp[32*i+j+0] = (pix1[j+0] - pix2[j+0])<<4;
>            tmp[32*i+j+1] = (pix1[j+1] - pix2[j+1])<<4;
>            tmp[32*i+j+2] = (pix1[j+2] - pix2[j+2])<<4;
>            tmp[32*i+j+3] = (pix1[j+3] - pix2[j+3])<<4;
>        }
>        pix1 += line_size;
>        pix2 += line_size;
>    }
>
>    ff_spatial_dwt(tmp, w, h, 32, type, dec_count);
>
>    s=0;
>    ((void) (0));
>    for(level=0; level<dec_count; level++){
>        for(ori= level ? 1 : 0; ori<4; ori++){
>            int size= w>>(dec_count-level);
>            int sx= (ori&1) ? size : 0;
>            int stride= 32<<(dec_count-level);
>            int sy= (ori&2) ? stride>>1 : 0;
>
>            for(i=0; i<size; i++){
>                for(j=0; j<size; j++){
>                    int v= tmp[sx + sy + i*stride + j] * scale[type][dec_count-3][level][ori];
>                    s += ((v) >= 0 ? (v) : (-(v)));
>                }
>            }
>        }
>    }
>    ((void) (0));
>    return s>>9;
>}
>
>static int w53_8_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
>    return w_c(v, pix1, pix2, line_size, 8, h, 1);
>}
>
>static int w97_8_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
>    return w_c(v, pix1, pix2, line_size, 8, h, 0);
>}
>
>static int w53_16_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
>    return w_c(v, pix1, pix2, line_size, 16, h, 1);
>}
>
>static int w97_16_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
>    return w_c(v, pix1, pix2, line_size, 16, h, 0);
>}
>
>int w53_32_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
>    return w_c(v, pix1, pix2, line_size, 32, h, 1);
>}
>
>int w97_32_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
>    return w_c(v, pix1, pix2, line_size, 32, h, 0);
>}
>
>
>static void get_pixels_c(DCTELEM *__restrict__ block, const uint8_t *pixels, int line_size)
>{
>    int i;
>
>
>    for(i=0;i<8;i++) {
>        block[0] = pixels[0];
>        block[1] = pixels[1];
>        block[2] = pixels[2];
>        block[3] = pixels[3];
>        block[4] = pixels[4];
>        block[5] = pixels[5];
>        block[6] = pixels[6];
>        block[7] = pixels[7];
>        pixels += line_size;
>        block += 8;
>    }
>}
>
>static void diff_pixels_c(DCTELEM *__restrict__ block, const uint8_t *s1,
>                          const uint8_t *s2, int stride){
>    int i;
>
>
>    for(i=0;i<8;i++) {
>        block[0] = s1[0] - s2[0];
>        block[1] = s1[1] - s2[1];
>        block[2] = s1[2] - s2[2];
>        block[3] = s1[3] - s2[3];
>        block[4] = s1[4] - s2[4];
>        block[5] = s1[5] - s2[5];
>        block[6] = s1[6] - s2[6];
>        block[7] = s1[7] - s2[7];
>        s1 += stride;
>        s2 += stride;
>        block += 8;
>    }
>}
>
>
>static void put_pixels_clamped_c(const DCTELEM *block, uint8_t *__restrict__ pixels,
>                                 int line_size)
>{
>    int i;
>    uint8_t *cm = ff_cropTbl + 1024;
>
>
>    for(i=0;i<8;i++) {
>        pixels[0] = cm[block[0]];
>        pixels[1] = cm[block[1]];
>        pixels[2] = cm[block[2]];
>        pixels[3] = cm[block[3]];
>        pixels[4] = cm[block[4]];
>        pixels[5] = cm[block[5]];
>        pixels[6] = cm[block[6]];
>        pixels[7] = cm[block[7]];
>
>        pixels += line_size;
>        block += 8;
>    }
>}
>
>static void put_pixels_clamped4_c(const DCTELEM *block, uint8_t *__restrict__ pixels,
>                                 int line_size)
>{
>    int i;
>    uint8_t *cm = ff_cropTbl + 1024;
>
>
>    for(i=0;i<4;i++) {
>        pixels[0] = cm[block[0]];
>        pixels[1] = cm[block[1]];
>        pixels[2] = cm[block[2]];
>        pixels[3] = cm[block[3]];
>
>        pixels += line_size;
>        block += 8;
>    }
>}
>
>static void put_pixels_clamped2_c(const DCTELEM *block, uint8_t *__restrict__ pixels,
>                                 int line_size)
>{
>    int i;
>    uint8_t *cm = ff_cropTbl + 1024;
>
>
>    for(i=0;i<2;i++) {
>        pixels[0] = cm[block[0]];
>        pixels[1] = cm[block[1]];
>
>        pixels += line_size;
>        block += 8;
>    }
>}
>
>static void put_signed_pixels_clamped_c(const DCTELEM *block,
>                                        uint8_t *__restrict__ pixels,
>                                        int line_size)
>{
>    int i, j;
>
>    for (i = 0; i < 8; i++) {
>        for (j = 0; j < 8; j++) {
>            if (*block < -128)
>                *pixels = 0;
>            else if (*block > 127)
>                *pixels = 255;
>            else
>                *pixels = (uint8_t)(*block + 128);
>            block++;
>            pixels++;
>        }
>        pixels += (line_size - 8);
>    }
>}
>
>static void add_pixels_clamped_c(const DCTELEM *block, uint8_t *__restrict__ pixels,
>                          int line_size)
>{
>    int i;
>    uint8_t *cm = ff_cropTbl + 1024;
>
>
>    for(i=0;i<8;i++) {
>        pixels[0] = cm[pixels[0] + block[0]];
>        pixels[1] = cm[pixels[1] + block[1]];
>        pixels[2] = cm[pixels[2] + block[2]];
>        pixels[3] = cm[pixels[3] + block[3]];
>        pixels[4] = cm[pixels[4] + block[4]];
>        pixels[5] = cm[pixels[5] + block[5]];
>        pixels[6] = cm[pixels[6] + block[6]];
>        pixels[7] = cm[pixels[7] + block[7]];
>        pixels += line_size;
>        block += 8;
>    }
>}
>
>static void add_pixels_clamped4_c(const DCTELEM *block, uint8_t *__restrict__ pixels,
>                          int line_size)
>{
>    int i;
>    uint8_t *cm = ff_cropTbl + 1024;
>
>
>    for(i=0;i<4;i++) {
>        pixels[0] = cm[pixels[0] + block[0]];
>        pixels[1] = cm[pixels[1] + block[1]];
>        pixels[2] = cm[pixels[2] + block[2]];
>        pixels[3] = cm[pixels[3] + block[3]];
>        pixels += line_size;
>        block += 8;
>    }
>}
>
>static void add_pixels_clamped2_c(const DCTELEM *block, uint8_t *__restrict__ pixels,
>                          int line_size)
>{
>    int i;
>    uint8_t *cm = ff_cropTbl + 1024;
>
>
>    for(i=0;i<2;i++) {
>        pixels[0] = cm[pixels[0] + block[0]];
>        pixels[1] = cm[pixels[1] + block[1]];
>        pixels += line_size;
>        block += 8;
>    }
>}
>
>static void add_pixels8_c(uint8_t *__restrict__ pixels, DCTELEM *block, int line_size)
>{
>    int i;
>    for(i=0;i<8;i++) {
>        pixels[0] += block[0];
>        pixels[1] += block[1];
>        pixels[2] += block[2];
>        pixels[3] += block[3];
>        pixels[4] += block[4];
>        pixels[5] += block[5];
>        pixels[6] += block[6];
>        pixels[7] += block[7];
>        pixels += line_size;
>        block += 8;
>    }
>}
>
>static void add_pixels4_c(uint8_t *__restrict__ pixels, DCTELEM *block, int line_size)
>{
>    int i;
>    for(i=0;i<4;i++) {
>        pixels[0] += block[0];
>        pixels[1] += block[1];
>        pixels[2] += block[2];
>        pixels[3] += block[3];
>        pixels += line_size;
>        block += 4;
>    }
>}
>
>static int sum_abs_dctelem_c(DCTELEM *block)
>{
>    int sum=0, i;
>    for(i=0; i<64; i++)
>        sum+= ((block[i]) >= 0 ? (block[i]) : (-(block[i])));
>    return sum;
>}
># 1117 "dsputil.c"
>static void avg_pixels2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ int i; for(i=0; i<h; i++){ *((uint16_t*)(block )) = rnd_avg32(*((uint16_t*)(block )), (((const struct unaligned_16 *) (pixels))->l)); pixels+=line_size; block +=line_size; }}static void avg_pixels4_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ int i; for(i=0; i<h; i++){ *((uint32_t*)(block )) = rnd_avg32(*((uint32_t*)(block )), (((const struct unaligned_32 *) (pixels))->l)); pixels+=line_size; block +=line_size; }}static void avg_pixels8_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ int i; for(i=0; i<h; i++){ *((uint32_t*)(block )) = rnd_avg32(*((uint32_t*)(block )), (((const struct unaligned_32 *) (pixels))->l)); *((uint32_t*)(block+4)) = rnd_avg32(*((uint32_t*)(block+4)), (((const struct unaligned_32 *) (pixels+4))->l)); pixels+=line_size; block +=line_size; }}static inline void avg_no_rnd_pixels8_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ avg_pixels8_c(block, pixels, line_size, h);}static inline void avg_no_rnd_pixels8_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h){ int i; for(i=0; i<h; i++){ uint32_t a,b; a= (((const struct unaligned_32 *) (&src1[i*src_stride1 ]))->l); b= (((const struct unaligned_32 *) (&src2[i*src_stride2 ]))->l); *((uint32_t*)&dst[i*dst_stride ]) = rnd_avg32(*((uint32_t*)&dst[i*dst_stride ]), no_rnd_avg32(a, b)); a= (((const struct unaligned_32 *) (&src1[i*src_stride1+4]))->l); b= (((const struct unaligned_32 *) (&src2[i*src_stride2+4]))->l); *((uint32_t*)&dst[i*dst_stride+4]) = rnd_avg32(*((uint32_t*)&dst[i*dst_stride+4]), no_rnd_avg32(a, b)); }}static inline void avg_pixels8_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h){ int i; for(i=0; i<h; i++){ uint32_t a,b; a= (((const struct unaligned_32 *) (&src1[i*src_stride1 ]))->l); b= (((const struct unaligned_32 *) (&src2[i*src_stride2 ]))->l); *((uint32_t*)&dst[i*dst_stride ]) = rnd_avg32(*((uint32_t*)&dst[i*dst_stride ]), rnd_avg32(a, b)); a= (((const struct unaligned_32 *) (&src1[i*src_stride1+4]))->l); b= (((const struct unaligned_32 *) (&src2[i*src_stride2+4]))->l); *((uint32_t*)&dst[i*dst_stride+4]) = rnd_avg32(*((uint32_t*)&dst[i*dst_stride+4]), rnd_avg32(a, b)); }}static inline void avg_pixels4_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h){ int i; for(i=0; i<h; i++){ uint32_t a,b; a= (((const struct unaligned_32 *) (&src1[i*src_stride1 ]))->l); b= (((const struct unaligned_32 *) (&src2[i*src_stride2 ]))->l); *((uint32_t*)&dst[i*dst_stride ]) = rnd_avg32(*((uint32_t*)&dst[i*dst_stride ]), rnd_avg32(a, b)); }}static inline void avg_pixels2_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h){ int i; for(i=0; i<h; i++){ uint32_t a,b; a= (((const struct unaligned_16 *) (&src1[i*src_stride1 ]))->l); b= (((const struct unaligned_16 *) (&src2[i*src_stride2 ]))->l); *((uint16_t*)&dst[i*dst_stride ]) = rnd_avg32(*((uint16_t*)&dst[i*dst_stride ]), rnd_avg32(a, b)); }}static inline void avg_pixels16_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h){ avg_pixels8_l2(dst , src1 , src2 , dst_stride, src_stride1, src_stride2, h); avg_pixels8_l2(dst+8, src1+8, src2+8, dst_stride, src_stride1, src_stride2, h);}static inline void avg_no_rnd_pixels16_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h){ avg_no_rnd_pixels8_l2(dst , src1 , src2 , dst_stride, src_stride1, src_stride2, h); avg_no_rnd_pixels8_l2(dst+8, src1+8, src2+8, dst_stride, src_stride1, src_stride2, h);}static inline void avg_no_rnd_pixels8_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ avg_no_rnd_pixels8_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);}static inline void avg_pixels8_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ avg_pixels8_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);}static inline void avg_no_rnd_pixels8_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ avg_no_rnd_pixels8_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);}static inline void avg_pixels8_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ avg_pixels8_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);}static inline void avg_pixels8_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4, int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){ int i; for(i=0; i<h; i++){ uint32_t a, b, c, d, l0, l1, h0, h1; a= (((const struct unaligned_32 *) (&src1[i*src_stride1]))->l); b= (((const struct unaligned_32 *) (&src2[i*src_stride2]))->l); c= (((const struct unaligned_32 *) (&src3[i*src_stride3]))->l); d= (((const struct unaligned_32 *) (&src4[i*src_stride4]))->l); l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x02020202UL; h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); l1= (c&0x03030303UL) + (d&0x03030303UL); h1= ((c&0xFCFCFCFCUL)>>2) + ((d&0xFCFCFCFCUL)>>2); *((uint32_t*)&dst[i*dst_stride]) = rnd_avg32(*((uint32_t*)&dst[i*dst_stride]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL)); a= (((const struct unaligned_32 *) (&src1[i*src_stride1+4]))->l); b= (((const struct unaligned_32 *) (&src2[i*src_stride2+4]))->l); c= (((const struct unaligned_32 *) (&src3[i*src_stride3+4]))->l); d= (((const struct unaligned_32 *) (&src4[i*src_stride4+4]))->l); l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x02020202UL; h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); l1= (c&0x03030303UL) + (d&0x03030303UL); h1= ((c&0xFCFCFCFCUL)>>2) + ((d&0xFCFCFCFCUL)>>2); *((uint32_t*)&dst[i*dst_stride+4]) = rnd_avg32(*((uint32_t*)&dst[i*dst_stride+4]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL)); }}static inline void avg_pixels4_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ avg_pixels4_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);}static inline void avg_pixels4_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ avg_pixels4_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);}static inline void avg_pixels2_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ avg_pixels2_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);}static inline void avg_pixels2_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ avg_pixels2_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);}static inline void avg_no_rnd_pixels8_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4, int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){ int i; for(i=0; i<h; i++){ uint32_t a, b, c, d, l0, l1, h0, h1; a= (((const struct unaligned_32 *) (&src1[i*src_stride1]))->l); b= (((const struct unaligned_32 *) (&src2[i*src_stride2]))->l); c= (((const struct unaligned_32 *) (&src3[i*src_stride3]))->l); d= (((const struct unaligned_32 *) (&src4[i*src_stride4]))->l); l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x01010101UL; h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); l1= (c&0x03030303UL) + (d&0x03030303UL); h1= ((c&0xFCFCFCFCUL)>>2) + ((d&0xFCFCFCFCUL)>>2); *((uint32_t*)&dst[i*dst_stride]) = rnd_avg32(*((uint32_t*)&dst[i*dst_stride]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL)); a= (((const struct unaligned_32 *) (&src1[i*src_stride1+4]))->l); b= (((const struct unaligned_32 *) (&src2[i*src_stride2+4]))->l); c= (((const struct unaligned_32 *) (&src3[i*src_stride3+4]))->l); d= (((const struct unaligned_32 *) (&src4[i*src_stride4+4]))->l); l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x01010101UL; h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); l1= (c&0x03030303UL) + (d&0x03030303UL); h1= ((c&0xFCFCFCFCUL)>>2) + ((d&0xFCFCFCFCUL)>>2); *((uint32_t*)&dst[i*dst_stride+4]) = rnd_avg32(*((uint32_t*)&dst[i*dst_stride+4]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL)); }}static inline void avg_pixels16_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4, int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){ avg_pixels8_l4(dst , src1 , src2 , src3 , src4 , dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h); avg_pixels8_l4(dst+8, src1+8, src2+8, src3+8, src4+8, dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);}static inline void avg_no_rnd_pixels16_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4, int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){ avg_no_rnd_pixels8_l4(dst , src1 , src2 , src3 , src4 , dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h); avg_no_rnd_pixels8_l4(dst+8, src1+8, src2+8, src3+8, src4+8, dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);}static inline void avg_pixels2_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ int i, a0, b0, a1, b1; a0= pixels[0]; b0= pixels[1] + 2; a0 += b0; b0 += pixels[2]; pixels+=line_size; for(i=0; i<h; i+=2){ a1= pixels[0]; b1= pixels[1]; a1 += b1; b1 += pixels[2]; block[0]= (a1+a0)>>2; block[1]= (b1+b0)>>2; pixels+=line_size; block +=line_size; a0= pixels[0]; b0= pixels[1] + 2; a0 += b0; b0 += pixels[2]; block[0]= (a1+a0)>>2; block[1]= (b1+b0)>>2; pixels+=line_size; block +=line_size; }}static inline void avg_pixels4_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ int i; const uint32_t a= (((const struct unaligned_32 *) (pixels))->l); const uint32_t b= (((const struct unaligned_32 *) (pixels+1))->l); uint32_t l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x02020202UL; uint32_t h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); uint32_t l1,h1; pixels+=line_size; for(i=0; i<h; i+=2){ uint32_t a= (((const struct unaligned_32 *) (pixels))->l); uint32_t b= (((const struct unaligned_32 *) (pixels+1))->l); l1= (a&0x03030303UL) + (b&0x03030303UL); h1= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); *((uint32_t*)block) = rnd_avg32(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL)); pixels+=line_size; block +=line_size; a= (((const struct unaligned_32 *) (pixels))->l); b= (((const struct unaligned_32 *) (pixels+1))->l); l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x02020202UL; h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); *((uint32_t*)block) = rnd_avg32(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL)); pixels+=line_size; block +=line_size; }}static inline void avg_pixels8_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ int j; for(j=0; j<2; j++){ int i; const uint32_t a= (((const struct unaligned_32 *) (pixels))->l); const uint32_t b= (((const struct unaligned_32 *) (pixels+1))->l); uint32_t l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x02020202UL; uint32_t h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); uint32_t l1,h1; pixels+=line_size; for(i=0; i<h; i+=2){ uint32_t a= (((const struct unaligned_32 *) (pixels))->l); uint32_t b= (((const struct unaligned_32 *) (pixels+1))->l); l1= (a&0x03030303UL) + (b&0x03030303UL); h1= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); *((uint32_t*)block) = rnd_avg32(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL)); pixels+=line_size; block +=line_size; a= (((const struct unaligned_32 *) (pixels))->l); b= (((const struct unaligned_32 *) (pixels+1))->l); l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x02020202UL; h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); *((uint32_t*)block) = rnd_avg32(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL)); pixels+=line_size; block +=line_size; } pixels+=4-line_size*(h+1); block +=4-line_size*h; }}static inline void avg_no_rnd_pixels8_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ int j; for(j=0; j<2; j++){ int i; const uint32_t a= (((const struct unaligned_32 *) (pixels))->l); const uint32_t b= (((const struct unaligned_32 *) (pixels+1))->l); uint32_t l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x01010101UL; uint32_t h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); uint32_t l1,h1; pixels+=line_size; for(i=0; i<h; i+=2){ uint32_t a= (((const struct unaligned_32 *) (pixels))->l); uint32_t b= (((const struct unaligned_32 *) (pixels+1))->l); l1= (a&0x03030303UL) + (b&0x03030303UL); h1= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); *((uint32_t*)block) = rnd_avg32(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL)); pixels+=line_size; block +=line_size; a= (((const struct unaligned_32 *) (pixels))->l); b= (((const struct unaligned_32 *) (pixels+1))->l); l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x01010101UL; h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); *((uint32_t*)block) = rnd_avg32(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL)); pixels+=line_size; block +=line_size; } pixels+=4-line_size*(h+1); block +=4-line_size*h; }}static void avg_pixels16_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ avg_pixels8_c(block , pixels , line_size, h); avg_pixels8_c(block+8, pixels+8, line_size, h);}static void avg_pixels16_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ avg_pixels8_x2_c(block , pixels , line_size, h); avg_pixels8_x2_c(block+8, pixels+8, line_size, h);}static void avg_pixels16_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ avg_pixels8_y2_c(block , pixels , line_size, h); avg_pixels8_y2_c(block+8, pixels+8, line_size, h);}static void avg_pixels16_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ avg_pixels8_xy2_c(block , pixels , line_size, h); avg_pixels8_xy2_c(block+8, pixels+8, line_size, h);}static void avg_no_rnd_pixels16_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ avg_pixels8_c(block , pixels , line_size, h); avg_pixels8_c(block+8, pixels+8, line_size, h);}static void avg_no_rnd_pixels16_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ avg_no_rnd_pixels8_x2_c(block , pixels , line_size, h); avg_no_rnd_pixels8_x2_c(block+8, pixels+8, line_size, h);}static void avg_no_rnd_pixels16_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ avg_no_rnd_pixels8_y2_c(block , pixels , line_size, h); avg_no_rnd_pixels8_y2_c(block+8, pixels+8, line_size, h);}static void avg_no_rnd_pixels16_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ avg_no_rnd_pixels8_xy2_c(block , pixels , line_size, h); avg_no_rnd_pixels8_xy2_c(block+8, pixels+8, line_size, h);}
>static void put_pixels2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ int i; for(i=0; i<h; i++){ *((uint16_t*)(block )) = (((const struct unaligned_16 *) (pixels))->l); pixels+=line_size; block +=line_size; }}static void put_pixels4_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ int i; for(i=0; i<h; i++){ *((uint32_t*)(block )) = (((const struct unaligned_32 *) (pixels))->l); pixels+=line_size; block +=line_size; }}static void put_pixels8_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ int i; for(i=0; i<h; i++){ *((uint32_t*)(block )) = (((const struct unaligned_32 *) (pixels))->l); *((uint32_t*)(block+4)) = (((const struct unaligned_32 *) (pixels+4))->l); pixels+=line_size; block +=line_size; }}static inline void put_no_rnd_pixels8_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ put_pixels8_c(block, pixels, line_size, h);}static inline void put_no_rnd_pixels8_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h){ int i; for(i=0; i<h; i++){ uint32_t a,b; a= (((const struct unaligned_32 *) (&src1[i*src_stride1 ]))->l); b= (((const struct unaligned_32 *) (&src2[i*src_stride2 ]))->l); *((uint32_t*)&dst[i*dst_stride ]) = no_rnd_avg32(a, b); a= (((const struct unaligned_32 *) (&src1[i*src_stride1+4]))->l); b= (((const struct unaligned_32 *) (&src2[i*src_stride2+4]))->l); *((uint32_t*)&dst[i*dst_stride+4]) = no_rnd_avg32(a, b); }}static inline void put_pixels8_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h){ int i; for(i=0; i<h; i++){ uint32_t a,b; a= (((const struct unaligned_32 *) (&src1[i*src_stride1 ]))->l); b= (((const struct unaligned_32 *) (&src2[i*src_stride2 ]))->l); *((uint32_t*)&dst[i*dst_stride ]) = rnd_avg32(a, b); a= (((const struct unaligned_32 *) (&src1[i*src_stride1+4]))->l); b= (((const struct unaligned_32 *) (&src2[i*src_stride2+4]))->l); *((uint32_t*)&dst[i*dst_stride+4]) = rnd_avg32(a, b); }}static inline void put_pixels4_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h){ int i; for(i=0; i<h; i++){ uint32_t a,b; a= (((const struct unaligned_32 *) (&src1[i*src_stride1 ]))->l); b= (((const struct unaligned_32 *) (&src2[i*src_stride2 ]))->l); *((uint32_t*)&dst[i*dst_stride ]) = rnd_avg32(a, b); }}static inline void put_pixels2_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h){ int i; for(i=0; i<h; i++){ uint32_t a,b; a= (((const struct unaligned_16 *) (&src1[i*src_stride1 ]))->l); b= (((const struct unaligned_16 *) (&src2[i*src_stride2 ]))->l); *((uint16_t*)&dst[i*dst_stride ]) = rnd_avg32(a, b); }}static inline void put_pixels16_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h){ put_pixels8_l2(dst , src1 , src2 , dst_stride, src_stride1, src_stride2, h); put_pixels8_l2(dst+8, src1+8, src2+8, dst_stride, src_stride1, src_stride2, h);}static inline void put_no_rnd_pixels16_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h){ put_no_rnd_pixels8_l2(dst , src1 , src2 , dst_stride, src_stride1, src_stride2, h); put_no_rnd_pixels8_l2(dst+8, src1+8, src2+8, dst_stride, src_stride1, src_stride2, h);}static inline void put_no_rnd_pixels8_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ put_no_rnd_pixels8_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);}static inline void put_pixels8_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ put_pixels8_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);}static inline void put_no_rnd_pixels8_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ put_no_rnd_pixels8_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);}static inline void put_pixels8_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ put_pixels8_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);}static inline void put_pixels8_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4, int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){ int i; for(i=0; i<h; i++){ uint32_t a, b, c, d, l0, l1, h0, h1; a= (((const struct unaligned_32 *) (&src1[i*src_stride1]))->l); b= (((const struct unaligned_32 *) (&src2[i*src_stride2]))->l); c= (((const struct unaligned_32 *) (&src3[i*src_stride3]))->l); d= (((const struct unaligned_32 *) (&src4[i*src_stride4]))->l); l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x02020202UL; h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); l1= (c&0x03030303UL) + (d&0x03030303UL); h1= ((c&0xFCFCFCFCUL)>>2) + ((d&0xFCFCFCFCUL)>>2); *((uint32_t*)&dst[i*dst_stride]) = h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL); a= (((const struct unaligned_32 *) (&src1[i*src_stride1+4]))->l); b= (((const struct unaligned_32 *) (&src2[i*src_stride2+4]))->l); c= (((const struct unaligned_32 *) (&src3[i*src_stride3+4]))->l); d= (((const struct unaligned_32 *) (&src4[i*src_stride4+4]))->l); l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x02020202UL; h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); l1= (c&0x03030303UL) + (d&0x03030303UL); h1= ((c&0xFCFCFCFCUL)>>2) + ((d&0xFCFCFCFCUL)>>2); *((uint32_t*)&dst[i*dst_stride+4]) = h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL); }}static inline void put_pixels4_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ put_pixels4_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);}static inline void put_pixels4_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ put_pixels4_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);}static inline void put_pixels2_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ put_pixels2_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);}static inline void put_pixels2_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ put_pixels2_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);}static inline void put_no_rnd_pixels8_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4, int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){ int i; for(i=0; i<h; i++){ uint32_t a, b, c, d, l0, l1, h0, h1; a= (((const struct unaligned_32 *) (&src1[i*src_stride1]))->l); b= (((const struct unaligned_32 *) (&src2[i*src_stride2]))->l); c= (((const struct unaligned_32 *) (&src3[i*src_stride3]))->l); d= (((const struct unaligned_32 *) (&src4[i*src_stride4]))->l); l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x01010101UL; h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); l1= (c&0x03030303UL) + (d&0x03030303UL); h1= ((c&0xFCFCFCFCUL)>>2) + ((d&0xFCFCFCFCUL)>>2); *((uint32_t*)&dst[i*dst_stride]) = h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL); a= (((const struct unaligned_32 *) (&src1[i*src_stride1+4]))->l); b= (((const struct unaligned_32 *) (&src2[i*src_stride2+4]))->l); c= (((const struct unaligned_32 *) (&src3[i*src_stride3+4]))->l); d= (((const struct unaligned_32 *) (&src4[i*src_stride4+4]))->l); l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x01010101UL; h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); l1= (c&0x03030303UL) + (d&0x03030303UL); h1= ((c&0xFCFCFCFCUL)>>2) + ((d&0xFCFCFCFCUL)>>2); *((uint32_t*)&dst[i*dst_stride+4]) = h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL); }}static inline void put_pixels16_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4, int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){ put_pixels8_l4(dst , src1 , src2 , src3 , src4 , dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h); put_pixels8_l4(dst+8, src1+8, src2+8, src3+8, src4+8, dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);}static inline void put_no_rnd_pixels16_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4, int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){ put_no_rnd_pixels8_l4(dst , src1 , src2 , src3 , src4 , dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h); put_no_rnd_pixels8_l4(dst+8, src1+8, src2+8, src3+8, src4+8, dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);}static inline void put_pixels2_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ int i, a0, b0, a1, b1; a0= pixels[0]; b0= pixels[1] + 2; a0 += b0; b0 += pixels[2]; pixels+=line_size; for(i=0; i<h; i+=2){ a1= pixels[0]; b1= pixels[1]; a1 += b1; b1 += pixels[2]; block[0]= (a1+a0)>>2; block[1]= (b1+b0)>>2; pixels+=line_size; block +=line_size; a0= pixels[0]; b0= pixels[1] + 2; a0 += b0; b0 += pixels[2]; block[0]= (a1+a0)>>2; block[1]= (b1+b0)>>2; pixels+=line_size; block +=line_size; }}static inline void put_pixels4_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ int i; const uint32_t a= (((const struct unaligned_32 *) (pixels))->l); const uint32_t b= (((const struct unaligned_32 *) (pixels+1))->l); uint32_t l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x02020202UL; uint32_t h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); uint32_t l1,h1; pixels+=line_size; for(i=0; i<h; i+=2){ uint32_t a= (((const struct unaligned_32 *) (pixels))->l); uint32_t b= (((const struct unaligned_32 *) (pixels+1))->l); l1= (a&0x03030303UL) + (b&0x03030303UL); h1= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); *((uint32_t*)block) = h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL); pixels+=line_size; block +=line_size; a= (((const struct unaligned_32 *) (pixels))->l); b= (((const struct unaligned_32 *) (pixels+1))->l); l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x02020202UL; h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); *((uint32_t*)block) = h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL); pixels+=line_size; block +=line_size; }}static inline void put_pixels8_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ int j; for(j=0; j<2; j++){ int i; const uint32_t a= (((const struct unaligned_32 *) (pixels))->l); const uint32_t b= (((const struct unaligned_32 *) (pixels+1))->l); uint32_t l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x02020202UL; uint32_t h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); uint32_t l1,h1; pixels+=line_size; for(i=0; i<h; i+=2){ uint32_t a= (((const struct unaligned_32 *) (pixels))->l); uint32_t b= (((const struct unaligned_32 *) (pixels+1))->l); l1= (a&0x03030303UL) + (b&0x03030303UL); h1= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); *((uint32_t*)block) = h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL); pixels+=line_size; block +=line_size; a= (((const struct unaligned_32 *) (pixels))->l); b= (((const struct unaligned_32 *) (pixels+1))->l); l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x02020202UL; h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); *((uint32_t*)block) = h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL); pixels+=line_size; block +=line_size; } pixels+=4-line_size*(h+1); block +=4-line_size*h; }}static inline void put_no_rnd_pixels8_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ int j; for(j=0; j<2; j++){ int i; const uint32_t a= (((const struct unaligned_32 *) (pixels))->l); const uint32_t b= (((const struct unaligned_32 *) (pixels+1))->l); uint32_t l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x01010101UL; uint32_t h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); uint32_t l1,h1; pixels+=line_size; for(i=0; i<h; i+=2){ uint32_t a= (((const struct unaligned_32 *) (pixels))->l); uint32_t b= (((const struct unaligned_32 *) (pixels+1))->l); l1= (a&0x03030303UL) + (b&0x03030303UL); h1= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); *((uint32_t*)block) = h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL); pixels+=line_size; block +=line_size; a= (((const struct unaligned_32 *) (pixels))->l); b= (((const struct unaligned_32 *) (pixels+1))->l); l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x01010101UL; h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); *((uint32_t*)block) = h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL); pixels+=line_size; block +=line_size; } pixels+=4-line_size*(h+1); block +=4-line_size*h; }}static void put_pixels16_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ put_pixels8_c(block , pixels , line_size, h); put_pixels8_c(block+8, pixels+8, line_size, h);}static void put_pixels16_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ put_pixels8_x2_c(block , pixels , line_size, h); put_pixels8_x2_c(block+8, pixels+8, line_size, h);}static void put_pixels16_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ put_pixels8_y2_c(block , pixels , line_size, h); put_pixels8_y2_c(block+8, pixels+8, line_size, h);}static void put_pixels16_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ put_pixels8_xy2_c(block , pixels , line_size, h); put_pixels8_xy2_c(block+8, pixels+8, line_size, h);}static void put_no_rnd_pixels16_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ put_pixels8_c(block , pixels , line_size, h); put_pixels8_c(block+8, pixels+8, line_size, h);}static void put_no_rnd_pixels16_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ put_no_rnd_pixels8_x2_c(block , pixels , line_size, h); put_no_rnd_pixels8_x2_c(block+8, pixels+8, line_size, h);}static void put_no_rnd_pixels16_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ put_no_rnd_pixels8_y2_c(block , pixels , line_size, h); put_no_rnd_pixels8_y2_c(block+8, pixels+8, line_size, h);}static void put_no_rnd_pixels16_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ put_no_rnd_pixels8_xy2_c(block , pixels , line_size, h); put_no_rnd_pixels8_xy2_c(block+8, pixels+8, line_size, h);}
>
>
>
>
>
>
>static void put_no_rnd_pixels16_l2_c(uint8_t *dst, const uint8_t *a, const uint8_t *b, int stride, int h){
>    put_no_rnd_pixels16_l2(dst, a, b, stride, stride, stride, h);
>}
>
>static void put_no_rnd_pixels8_l2_c(uint8_t *dst, const uint8_t *a, const uint8_t *b, int stride, int h){
>    put_no_rnd_pixels8_l2(dst, a, b, stride, stride, stride, h);
>}
>
>static void gmc1_c(uint8_t *dst, uint8_t *src, int stride, int h, int x16, int y16, int rounder)
>{
>    const int A=(16-x16)*(16-y16);
>    const int B=( x16)*(16-y16);
>    const int C=(16-x16)*( y16);
>    const int D=( x16)*( y16);
>    int i;
>
>    for(i=0; i<h; i++)
>    {
>        dst[0]= (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1] + rounder)>>8;
>        dst[1]= (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2] + rounder)>>8;
>        dst[2]= (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3] + rounder)>>8;
>        dst[3]= (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4] + rounder)>>8;
>        dst[4]= (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5] + rounder)>>8;
>        dst[5]= (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6] + rounder)>>8;
>        dst[6]= (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7] + rounder)>>8;
>        dst[7]= (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8] + rounder)>>8;
>        dst+= stride;
>        src+= stride;
>    }
>}
>
>void ff_gmc_c(uint8_t *dst, uint8_t *src, int stride, int h, int ox, int oy,
>                  int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height)
>{
>    int y, vx, vy;
>    const int s= 1<<shift;
>
>    width--;
>    height--;
>
>    for(y=0; y<h; y++){
>        int x;
>
>        vx= ox;
>        vy= oy;
>        for(x=0; x<8; x++){
>            int src_x, src_y, frac_x, frac_y, index;
>
>            src_x= vx>>16;
>            src_y= vy>>16;
>            frac_x= src_x&(s-1);
>            frac_y= src_y&(s-1);
>            src_x>>=shift;
>            src_y>>=shift;
>
>            if((unsigned)src_x < width){
>                if((unsigned)src_y < height){
>                    index= src_x + src_y*stride;
>                    dst[y*stride + x]= ( ( src[index ]*(s-frac_x)
>                                           + src[index +1]* frac_x )*(s-frac_y)
>                                        + ( src[index+stride ]*(s-frac_x)
>                                           + src[index+stride+1]* frac_x )* frac_y
>                                        + r)>>(shift*2);
>                }else{
>                    index= src_x + av_clip(src_y, 0, height)*stride;
>                    dst[y*stride + x]= ( ( src[index ]*(s-frac_x)
>                                          + src[index +1]* frac_x )*s
>                                        + r)>>(shift*2);
>                }
>            }else{
>                if((unsigned)src_y < height){
>                    index= av_clip(src_x, 0, width) + src_y*stride;
>                    dst[y*stride + x]= ( ( src[index ]*(s-frac_y)
>                                           + src[index+stride ]* frac_y )*s
>                                        + r)>>(shift*2);
>                }else{
>                    index= av_clip(src_x, 0, width) + av_clip(src_y, 0, height)*stride;
>                    dst[y*stride + x]= src[index ];
>                }
>            }
>
>            vx+= dxx;
>            vy+= dyx;
>        }
>        ox += dxy;
>        oy += dyy;
>    }
>}
>
>static inline void put_tpel_pixels_mc00_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
>    switch(width){
>    case 2: put_pixels2_c (dst, src, stride, height); break;
>    case 4: put_pixels4_c (dst, src, stride, height); break;
>    case 8: put_pixels8_c (dst, src, stride, height); break;
>    case 16:put_pixels16_c(dst, src, stride, height); break;
>    }
>}
>
>static inline void put_tpel_pixels_mc10_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
>    int i,j;
>    for (i=0; i < height; i++) {
>      for (j=0; j < width; j++) {
>        dst[j] = (683*(2*src[j] + src[j+1] + 1)) >> 11;
>      }
>      src += stride;
>      dst += stride;
>    }
>}
>
>static inline void put_tpel_pixels_mc20_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
>    int i,j;
>    for (i=0; i < height; i++) {
>      for (j=0; j < width; j++) {
>        dst[j] = (683*(src[j] + 2*src[j+1] + 1)) >> 11;
>      }
>      src += stride;
>      dst += stride;
>    }
>}
>
>static inline void put_tpel_pixels_mc01_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
>    int i,j;
>    for (i=0; i < height; i++) {
>      for (j=0; j < width; j++) {
>        dst[j] = (683*(2*src[j] + src[j+stride] + 1)) >> 11;
>      }
>      src += stride;
>      dst += stride;
>    }
>}
>
>static inline void put_tpel_pixels_mc11_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
>    int i,j;
>    for (i=0; i < height; i++) {
>      for (j=0; j < width; j++) {
>        dst[j] = (2731*(4*src[j] + 3*src[j+1] + 3*src[j+stride] + 2*src[j+stride+1] + 6)) >> 15;
>      }
>      src += stride;
>      dst += stride;
>    }
>}
>
>static inline void put_tpel_pixels_mc12_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
>    int i,j;
>    for (i=0; i < height; i++) {
>      for (j=0; j < width; j++) {
>        dst[j] = (2731*(3*src[j] + 2*src[j+1] + 4*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15;
>      }
>      src += stride;
>      dst += stride;
>    }
>}
>
>static inline void put_tpel_pixels_mc02_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
>    int i,j;
>    for (i=0; i < height; i++) {
>      for (j=0; j < width; j++) {
>        dst[j] = (683*(src[j] + 2*src[j+stride] + 1)) >> 11;
>      }
>      src += stride;
>      dst += stride;
>    }
>}
>
>static inline void put_tpel_pixels_mc21_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
>    int i,j;
>    for (i=0; i < height; i++) {
>      for (j=0; j < width; j++) {
>        dst[j] = (2731*(3*src[j] + 4*src[j+1] + 2*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15;
>      }
>      src += stride;
>      dst += stride;
>    }
>}
>
>static inline void put_tpel_pixels_mc22_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
>    int i,j;
>    for (i=0; i < height; i++) {
>      for (j=0; j < width; j++) {
>        dst[j] = (2731*(2*src[j] + 3*src[j+1] + 3*src[j+stride] + 4*src[j+stride+1] + 6)) >> 15;
>      }
>      src += stride;
>      dst += stride;
>    }
>}
>
>static inline void avg_tpel_pixels_mc00_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
>    switch(width){
>    case 2: avg_pixels2_c (dst, src, stride, height); break;
>    case 4: avg_pixels4_c (dst, src, stride, height); break;
>    case 8: avg_pixels8_c (dst, src, stride, height); break;
>    case 16:avg_pixels16_c(dst, src, stride, height); break;
>    }
>}
>
>static inline void avg_tpel_pixels_mc10_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
>    int i,j;
>    for (i=0; i < height; i++) {
>      for (j=0; j < width; j++) {
>        dst[j] = (dst[j] + ((683*(2*src[j] + src[j+1] + 1)) >> 11) + 1) >> 1;
>      }
>      src += stride;
>      dst += stride;
>    }
>}
>
>static inline void avg_tpel_pixels_mc20_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
>    int i,j;
>    for (i=0; i < height; i++) {
>      for (j=0; j < width; j++) {
>        dst[j] = (dst[j] + ((683*(src[j] + 2*src[j+1] + 1)) >> 11) + 1) >> 1;
>      }
>      src += stride;
>      dst += stride;
>    }
>}
>
>static inline void avg_tpel_pixels_mc01_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
>    int i,j;
>    for (i=0; i < height; i++) {
>      for (j=0; j < width; j++) {
>        dst[j] = (dst[j] + ((683*(2*src[j] + src[j+stride] + 1)) >> 11) + 1) >> 1;
>      }
>      src += stride;
>      dst += stride;
>    }
>}
>
>static inline void avg_tpel_pixels_mc11_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
>    int i,j;
>    for (i=0; i < height; i++) {
>      for (j=0; j < width; j++) {
>        dst[j] = (dst[j] + ((2731*(4*src[j] + 3*src[j+1] + 3*src[j+stride] + 2*src[j+stride+1] + 6)) >> 15) + 1) >> 1;
>      }
>      src += stride;
>      dst += stride;
>    }
>}
>
>static inline void avg_tpel_pixels_mc12_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
>    int i,j;
>    for (i=0; i < height; i++) {
>      for (j=0; j < width; j++) {
>        dst[j] = (dst[j] + ((2731*(3*src[j] + 2*src[j+1] + 4*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15) + 1) >> 1;
>      }
>      src += stride;
>      dst += stride;
>    }
>}
>
>static inline void avg_tpel_pixels_mc02_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
>    int i,j;
>    for (i=0; i < height; i++) {
>      for (j=0; j < width; j++) {
>        dst[j] = (dst[j] + ((683*(src[j] + 2*src[j+stride] + 1)) >> 11) + 1) >> 1;
>      }
>      src += stride;
>      dst += stride;
>    }
>}
>
>static inline void avg_tpel_pixels_mc21_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
>    int i,j;
>    for (i=0; i < height; i++) {
>      for (j=0; j < width; j++) {
>        dst[j] = (dst[j] + ((2731*(3*src[j] + 4*src[j+1] + 2*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15) + 1) >> 1;
>      }
>      src += stride;
>      dst += stride;
>    }
>}
>
>static inline void avg_tpel_pixels_mc22_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
>    int i,j;
>    for (i=0; i < height; i++) {
>      for (j=0; j < width; j++) {
>        dst[j] = (dst[j] + ((2731*(2*src[j] + 3*src[j+1] + 3*src[j+stride] + 4*src[j+stride+1] + 6)) >> 15) + 1) >> 1;
>      }
>      src += stride;
>      dst += stride;
>    }
>}
># 1495 "dsputil.c"
>static void put_h264_chroma_mc2_c(uint8_t *dst , uint8_t *src , int stride, int h, int x, int y){ const int A=(8-x)*(8-y); const int B=( x)*(8-y); const int C=(8-x)*( y); const int D=( x)*( y); int i; ((void) (0)); for(i=0; i<h; i++) { dst[0] = ((((A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1])) + 32)>>6); dst[1] = ((((A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2])) + 32)>>6); dst+= stride; src+= stride; }}static void put_h264_chroma_mc4_c(uint8_t *dst , uint8_t *src , int stride, int h, int x, int y){ const int A=(8-x)*(8-y); const int B=( x)*(8-y); const int C=(8-x)*( y); const int D=( x)*( y); int i; ((void) (0)); for(i=0; i<h; i++) { dst[0] = ((((A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1])) + 32)>>6); dst[1] = ((((A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2])) + 32)>>6); dst[2] = ((((A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3])) + 32)>>6); dst[3] = ((((A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4])) + 32)>>6); dst+= stride; src+= stride; }}static void put_h264_chroma_mc8_c(uint8_t *dst , uint8_t *src , int stride, int h, int x, int y){ const int A=(8-x)*(8-y); const int B=( x)*(8-y); const int C=(8-x)*( y); const int D=( x)*( y); int i; ((void) (0)); for(i=0; i<h; i++) { dst[0] = ((((A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1])) + 32)>>6); dst[1] = ((((A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2])) + 32)>>6); dst[2] = ((((A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3])) + 32)>>6); dst[3] = ((((A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4])) + 32)>>6); dst[4] = ((((A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5])) + 32)>>6); dst[5] = ((((A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6])) + 32)>>6); dst[6] = ((((A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7])) + 32)>>6); dst[7] = ((((A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8])) + 32)>>6); dst+= stride; src+= stride; }}
>static void avg_h264_chroma_mc2_c(uint8_t *dst , uint8_t *src , int stride, int h, int x, int y){ const int A=(8-x)*(8-y); const int B=( x)*(8-y); const int C=(8-x)*( y); const int D=( x)*( y); int i; ((void) (0)); for(i=0; i<h; i++) { dst[0] = (((dst[0])+((((A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1])) + 32)>>6)+1)>>1); dst[1] = (((dst[1])+((((A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2])) + 32)>>6)+1)>>1); dst+= stride; src+= stride; }}static void avg_h264_chroma_mc4_c(uint8_t *dst , uint8_t *src , int stride, int h, int x, int y){ const int A=(8-x)*(8-y); const int B=( x)*(8-y); const int C=(8-x)*( y); const int D=( x)*( y); int i; ((void) (0)); for(i=0; i<h; i++) { dst[0] = (((dst[0])+((((A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1])) + 32)>>6)+1)>>1); dst[1] = (((dst[1])+((((A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2])) + 32)>>6)+1)>>1); dst[2] = (((dst[2])+((((A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3])) + 32)>>6)+1)>>1); dst[3] = (((dst[3])+((((A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4])) + 32)>>6)+1)>>1); dst+= stride; src+= stride; }}static void avg_h264_chroma_mc8_c(uint8_t *dst , uint8_t *src , int stride, int h, int x, int y){ const int A=(8-x)*(8-y); const int B=( x)*(8-y); const int C=(8-x)*( y); const int D=( x)*( y); int i; ((void) (0)); for(i=0; i<h; i++) { dst[0] = (((dst[0])+((((A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1])) + 32)>>6)+1)>>1); dst[1] = (((dst[1])+((((A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2])) + 32)>>6)+1)>>1); dst[2] = (((dst[2])+((((A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3])) + 32)>>6)+1)>>1); dst[3] = (((dst[3])+((((A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4])) + 32)>>6)+1)>>1); dst[4] = (((dst[4])+((((A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5])) + 32)>>6)+1)>>1); dst[5] = (((dst[5])+((((A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6])) + 32)>>6)+1)>>1); dst[6] = (((dst[6])+((((A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7])) + 32)>>6)+1)>>1); dst[7] = (((dst[7])+((((A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8])) + 32)>>6)+1)>>1); dst+= stride; src+= stride; }}
>
>
>
>static void put_no_rnd_h264_chroma_mc8_c(uint8_t *dst , uint8_t *src , int stride, int h, int x, int y){
>    const int A=(8-x)*(8-y);
>    const int B=( x)*(8-y);
>    const int C=(8-x)*( y);
>    const int D=( x)*( y);
>    int i;
>
>    ((void) (0));
>
>    for(i=0; i<h; i++)
>    {
>        dst[0] = (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1] + 32 - 4) >> 6;
>        dst[1] = (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2] + 32 - 4) >> 6;
>        dst[2] = (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3] + 32 - 4) >> 6;
>        dst[3] = (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4] + 32 - 4) >> 6;
>        dst[4] = (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5] + 32 - 4) >> 6;
>        dst[5] = (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6] + 32 - 4) >> 6;
>        dst[6] = (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7] + 32 - 4) >> 6;
>        dst[7] = (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8] + 32 - 4) >> 6;
>        dst+= stride;
>        src+= stride;
>    }
>}
># 2012 "dsputil.c"
>static void put_mpeg4_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){ uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<h; i++) { dst[0] = cm[(((src[0]+src[1])*20 - (src[0]+src[2])*6 + (src[1]+src[3])*3 - (src[2]+src[4])) + 16)>>5]; dst[1] = cm[(((src[1]+src[2])*20 - (src[0]+src[3])*6 + (src[0]+src[4])*3 - (src[1]+src[5])) + 16)>>5]; dst[2] = cm[(((src[2]+src[3])*20 - (src[1]+src[4])*6 + (src[0]+src[5])*3 - (src[0]+src[6])) + 16)>>5]; dst[3] = cm[(((src[3]+src[4])*20 - (src[2]+src[5])*6 + (src[1]+src[6])*3 - (src[0]+src[7])) + 16)>>5]; dst[4] = cm[(((src[4]+src[5])*20 - (src[3]+src[6])*6 + (src[2]+src[7])*3 - (src[1]+src[8])) + 16)>>5]; dst[5] = cm[(((src[5]+src[6])*20 - (src[4]+src[7])*6 + (src[3]+src[8])*3 - (src[2]+src[8])) + 16)>>5]; dst[6] = cm[(((src[6]+src[7])*20 - (src[5]+src[8])*6 + (src[4]+src[8])*3 - (src[3]+src[7])) + 16)>>5]; dst[7] = cm[(((src[7]+src[8])*20 - (src[6]+src[8])*6 + (src[5]+src[7])*3 - (src[4]+src[6])) + 16)>>5]; dst+=dstStride; src+=srcStride; }}static void put_mpeg4_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ const int w=8; uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<w; i++) { const int src0= src[0*srcStride]; const int src1= src[1*srcStride]; const int src2= src[2*srcStride]; const int src3= src[3*srcStride]; const int src4= src[4*srcStride]; const int src5= src[5*srcStride]; const int src6= src[6*srcStride]; const int src7= src[7*srcStride]; const int src8= src[8*srcStride]; dst[0*dstStride] = cm[(((src0+src1)*20 - (src0+src2)*6 + (src1+src3)*3 - (src2+src4)) + 16)>>5]; dst[1*dstStride] = cm[(((src1+src2)*20 - (src0+src3)*6 + (src0+src4)*3 - (src1+src5)) + 16)>>5]; dst[2*dstStride] = cm[(((src2+src3)*20 - (src1+src4)*6 + (src0+src5)*3 - (src0+src6)) + 16)>>5]; dst[3*dstStride] = cm[(((src3+src4)*20 - (src2+src5)*6 + (src1+src6)*3 - (src0+src7)) + 16)>>5]; dst[4*dstStride] = cm[(((src4+src5)*20 - (src3+src6)*6 + (src2+src7)*3 - (src1+src8)) + 16)>>5]; dst[5*dstStride] = cm[(((src5+src6)*20 - (src4+src7)*6 + (src3+src8)*3 - (src2+src8)) + 16)>>5]; dst[6*dstStride] = cm[(((src6+src7)*20 - (src5+src8)*6 + (src4+src8)*3 - (src3+src7)) + 16)>>5]; dst[7*dstStride] = cm[(((src7+src8)*20 - (src6+src8)*6 + (src5+src7)*3 - (src4+src6)) + 16)>>5]; dst++; src++; }}static void put_mpeg4_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){ uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<h; i++) { dst[ 0] = cm[(((src[ 0]+src[ 1])*20 - (src[ 0]+src[ 2])*6 + (src[ 1]+src[ 3])*3 - (src[ 2]+src[ 4])) + 16)>>5]; dst[ 1] = cm[(((src[ 1]+src[ 2])*20 - (src[ 0]+src[ 3])*6 + (src[ 0]+src[ 4])*3 - (src[ 1]+src[ 5])) + 16)>>5]; dst[ 2] = cm[(((src[ 2]+src[ 3])*20 - (src[ 1]+src[ 4])*6 + (src[ 0]+src[ 5])*3 - (src[ 0]+src[ 6])) + 16)>>5]; dst[ 3] = cm[(((src[ 3]+src[ 4])*20 - (src[ 2]+src[ 5])*6 + (src[ 1]+src[ 6])*3 - (src[ 0]+src[ 7])) + 16)>>5]; dst[ 4] = cm[(((src[ 4]+src[ 5])*20 - (src[ 3]+src[ 6])*6 + (src[ 2]+src[ 7])*3 - (src[ 1]+src[ 8])) + 16)>>5]; dst[ 5] = cm[(((src[ 5]+src[ 6])*20 - (src[ 4]+src[ 7])*6 + (src[ 3]+src[ 8])*3 - (src[ 2]+src[ 9])) + 16)>>5]; dst[ 6] = cm[(((src[ 6]+src[ 7])*20 - (src[ 5]+src[ 8])*6 + (src[ 4]+src[ 9])*3 - (src[ 3]+src[10])) + 16)>>5]; dst[ 7] = cm[(((src[ 7]+src[ 8])*20 - (src[ 6]+src[ 9])*6 + (src[ 5]+src[10])*3 - (src[ 4]+src[11])) + 16)>>5]; dst[ 8] = cm[(((src[ 8]+src[ 9])*20 - (src[ 7]+src[10])*6 + (src[ 6]+src[11])*3 - (src[ 5]+src[12])) + 16)>>5]; dst[ 9] = cm[(((src[ 9]+src[10])*20 - (src[ 8]+src[11])*6 + (src[ 7]+src[12])*3 - (src[ 6]+src[13])) + 16)>>5]; dst[10] = cm[(((src[10]+src[11])*20 - (src[ 9]+src[12])*6 + (src[ 8]+src[13])*3 - (src[ 7]+src[14])) + 16)>>5]; dst[11] = cm[(((src[11]+src[12])*20 - (src[10]+src[13])*6 + (src[ 9]+src[14])*3 - (src[ 8]+src[15])) + 16)>>5]; dst[12] = cm[(((src[12]+src[13])*20 - (src[11]+src[14])*6 + (src[10]+src[15])*3 - (src[ 9]+src[16])) + 16)>>5]; dst[13] = cm[(((src[13]+src[14])*20 - (src[12]+src[15])*6 + (src[11]+src[16])*3 - (src[10]+src[16])) + 16)>>5]; dst[14] = cm[(((src[14]+src[15])*20 - (src[13]+src[16])*6 + (src[12]+src[16])*3 - (src[11]+src[15])) + 16)>>5]; dst[15] = cm[(((src[15]+src[16])*20 - (src[14]+src[16])*6 + (src[13]+src[15])*3 - (src[12]+src[14])) + 16)>>5]; dst+=dstStride; src+=srcStride; }}static void put_mpeg4_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ uint8_t *cm = ff_cropTbl + 1024; int i; const int w=16; for(i=0; i<w; i++) { const int src0= src[0*srcStride]; const int src1= src[1*srcStride]; const int src2= src[2*srcStride]; const int src3= src[3*srcStride]; const int src4= src[4*srcStride]; const int src5= src[5*srcStride]; const int src6= src[6*srcStride]; const int src7= src[7*srcStride]; const int src8= src[8*srcStride]; const int src9= src[9*srcStride]; const int src10= src[10*srcStride]; const int src11= src[11*srcStride]; const int src12= src[12*srcStride]; const int src13= src[13*srcStride]; const int src14= src[14*srcStride]; const int src15= src[15*srcStride]; const int src16= src[16*srcStride]; dst[ 0*dstStride] = cm[(((src0 +src1 )*20 - (src0 +src2 )*6 + (src1 +src3 )*3 - (src2 +src4 )) + 16)>>5]; dst[ 1*dstStride] = cm[(((src1 +src2 )*20 - (src0 +src3 )*6 + (src0 +src4 )*3 - (src1 +src5 )) + 16)>>5]; dst[ 2*dstStride] = cm[(((src2 +src3 )*20 - (src1 +src4 )*6 + (src0 +src5 )*3 - (src0 +src6 )) + 16)>>5]; dst[ 3*dstStride] = cm[(((src3 +src4 )*20 - (src2 +src5 )*6 + (src1 +src6 )*3 - (src0 +src7 )) + 16)>>5]; dst[ 4*dstStride] = cm[(((src4 +src5 )*20 - (src3 +src6 )*6 + (src2 +src7 )*3 - (src1 +src8 )) + 16)>>5]; dst[ 5*dstStride] = cm[(((src5 +src6 )*20 - (src4 +src7 )*6 + (src3 +src8 )*3 - (src2 +src9 )) + 16)>>5]; dst[ 6*dstStride] = cm[(((src6 +src7 )*20 - (src5 +src8 )*6 + (src4 +src9 )*3 - (src3 +src10)) + 16)>>5]; dst[ 7*dstStride] = cm[(((src7 +src8 )*20 - (src6 +src9 )*6 + (src5 +src10)*3 - (src4 +src11)) + 16)>>5]; dst[ 8*dstStride] = cm[(((src8 +src9 )*20 - (src7 +src10)*6 + (src6 +src11)*3 - (src5 +src12)) + 16)>>5]; dst[ 9*dstStride] = cm[(((src9 +src10)*20 - (src8 +src11)*6 + (src7 +src12)*3 - (src6 +src13)) + 16)>>5]; dst[10*dstStride] = cm[(((src10+src11)*20 - (src9 +src12)*6 + (src8 +src13)*3 - (src7 +src14)) + 16)>>5]; dst[11*dstStride] = cm[(((src11+src12)*20 - (src10+src13)*6 + (src9 +src14)*3 - (src8 +src15)) + 16)>>5]; dst[12*dstStride] = cm[(((src12+src13)*20 - (src11+src14)*6 + (src10+src15)*3 - (src9 +src16)) + 16)>>5]; dst[13*dstStride] = cm[(((src13+src14)*20 - (src12+src15)*6 + (src11+src16)*3 - (src10+src16)) + 16)>>5]; dst[14*dstStride] = cm[(((src14+src15)*20 - (src13+src16)*6 + (src12+src16)*3 - (src11+src15)) + 16)>>5]; dst[15*dstStride] = cm[(((src15+src16)*20 - (src14+src16)*6 + (src13+src15)*3 - (src12+src14)) + 16)>>5]; dst++; src++; }}static void put_qpel8_mc00_c (uint8_t *dst, uint8_t *src, int stride){ put_pixels8_c(dst, src, stride, 8);}static void put_qpel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[64]; put_mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8); put_pixels8_l2(dst, src, half, stride, stride, 8, 8);}static void put_qpel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){ put_mpeg4_qpel8_h_lowpass(dst, src, stride, stride, 8);}static void put_qpel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[64]; put_mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8); put_pixels8_l2(dst, src+1, half, stride, stride, 8, 8);}static void put_qpel8_mc01_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t half[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_v_lowpass(half, full, 8, 16); put_pixels8_l2(dst, full, half, stride, 16, 8, 8);}static void put_qpel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_v_lowpass(dst, full, stride, 16);}static void put_qpel8_mc03_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t half[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_v_lowpass(half, full, 8, 16); put_pixels8_l2(dst, full+16, half, stride, 16, 8, 8);}void ff_put_qpel8_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfV[64]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_mpeg4_qpel8_v_lowpass(halfV, full, 8, 16); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_pixels8_l4(dst, full, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);}static void put_qpel8_mc11_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_pixels8_l2(halfH, halfH, full, 8, 8, 16, 9); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);}void ff_put_qpel8_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfV[64]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_pixels8_l4(dst, full+1, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);}static void put_qpel8_mc31_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);}void ff_put_qpel8_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfV[64]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_mpeg4_qpel8_v_lowpass(halfV, full, 8, 16); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_pixels8_l4(dst, full+16, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);}static void put_qpel8_mc13_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_pixels8_l2(halfH, halfH, full, 8, 8, 16, 9); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);}void ff_put_qpel8_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfV[64]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full , 8, 16, 9); put_mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_pixels8_l4(dst, full+17, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);}static void put_qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);}static void put_qpel8_mc21_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t halfH[72]; uint8_t halfHV[64]; put_mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);}static void put_qpel8_mc23_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t halfH[72]; uint8_t halfHV[64]; put_mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);}void ff_put_qpel8_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfV[64]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_mpeg4_qpel8_v_lowpass(halfV, full, 8, 16); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);}static void put_qpel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_pixels8_l2(halfH, halfH, full, 8, 8, 16, 9); put_mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);}void ff_put_qpel8_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfV[64]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);}static void put_qpel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9); put_mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);}static void put_qpel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t halfH[72]; put_mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9); put_mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);}static void put_qpel16_mc00_c (uint8_t *dst, uint8_t *src, int stride){ put_pixels16_c(dst, src, stride, 16);}static void put_qpel16_mc10_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[256]; put_mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16); put_pixels16_l2(dst, src, half, stride, stride, 16, 16);}static void put_qpel16_mc20_c(uint8_t *dst, uint8_t *src, int stride){ put_mpeg4_qpel16_h_lowpass(dst, src, stride, stride, 16);}static void put_qpel16_mc30_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[256]; put_mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16); put_pixels16_l2(dst, src+1, half, stride, stride, 16, 16);}static void put_qpel16_mc01_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t half[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_v_lowpass(half, full, 16, 24); put_pixels16_l2(dst, full, half, stride, 24, 16, 16);}static void put_qpel16_mc02_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_v_lowpass(dst, full, stride, 24);}static void put_qpel16_mc03_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t half[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_v_lowpass(half, full, 16, 24); put_pixels16_l2(dst, full+24, half, stride, 24, 16, 16);}void ff_put_qpel16_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfV[256]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_mpeg4_qpel16_v_lowpass(halfV, full, 16, 24); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_pixels16_l4(dst, full, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);}static void put_qpel16_mc11_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_pixels16_l2(halfH, halfH, full, 16, 16, 24, 17); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);}void ff_put_qpel16_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfV[256]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_pixels16_l4(dst, full+1, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);}static void put_qpel16_mc31_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);}void ff_put_qpel16_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfV[256]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_mpeg4_qpel16_v_lowpass(halfV, full, 16, 24); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_pixels16_l4(dst, full+24, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);}static void put_qpel16_mc13_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_pixels16_l2(halfH, halfH, full, 16, 16, 24, 17); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);}void ff_put_qpel16_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfV[256]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full , 16, 24, 17); put_mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_pixels16_l4(dst, full+25, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);}static void put_qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);}static void put_qpel16_mc21_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t halfH[272]; uint8_t halfHV[256]; put_mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);}static void put_qpel16_mc23_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t halfH[272]; uint8_t halfHV[256]; put_mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);}void ff_put_qpel16_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfV[256]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_mpeg4_qpel16_v_lowpass(halfV, full, 16, 24); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);}static void put_qpel16_mc12_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_pixels16_l2(halfH, halfH, full, 16, 16, 24, 17); put_mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);}void ff_put_qpel16_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfV[256]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);}static void put_qpel16_mc32_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17); put_mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);}static void put_qpel16_mc22_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t halfH[272]; put_mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17); put_mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);}
>static void put_no_rnd_mpeg4_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){ uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<h; i++) { dst[0] = cm[(((src[0]+src[1])*20 - (src[0]+src[2])*6 + (src[1]+src[3])*3 - (src[2]+src[4])) + 15)>>5]; dst[1] = cm[(((src[1]+src[2])*20 - (src[0]+src[3])*6 + (src[0]+src[4])*3 - (src[1]+src[5])) + 15)>>5]; dst[2] = cm[(((src[2]+src[3])*20 - (src[1]+src[4])*6 + (src[0]+src[5])*3 - (src[0]+src[6])) + 15)>>5]; dst[3] = cm[(((src[3]+src[4])*20 - (src[2]+src[5])*6 + (src[1]+src[6])*3 - (src[0]+src[7])) + 15)>>5]; dst[4] = cm[(((src[4]+src[5])*20 - (src[3]+src[6])*6 + (src[2]+src[7])*3 - (src[1]+src[8])) + 15)>>5]; dst[5] = cm[(((src[5]+src[6])*20 - (src[4]+src[7])*6 + (src[3]+src[8])*3 - (src[2]+src[8])) + 15)>>5]; dst[6] = cm[(((src[6]+src[7])*20 - (src[5]+src[8])*6 + (src[4]+src[8])*3 - (src[3]+src[7])) + 15)>>5]; dst[7] = cm[(((src[7]+src[8])*20 - (src[6]+src[8])*6 + (src[5]+src[7])*3 - (src[4]+src[6])) + 15)>>5]; dst+=dstStride; src+=srcStride; }}static void put_no_rnd_mpeg4_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ const int w=8; uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<w; i++) { const int src0= src[0*srcStride]; const int src1= src[1*srcStride]; const int src2= src[2*srcStride]; const int src3= src[3*srcStride]; const int src4= src[4*srcStride]; const int src5= src[5*srcStride]; const int src6= src[6*srcStride]; const int src7= src[7*srcStride]; const int src8= src[8*srcStride]; dst[0*dstStride] = cm[(((src0+src1)*20 - (src0+src2)*6 + (src1+src3)*3 - (src2+src4)) + 15)>>5]; dst[1*dstStride] = cm[(((src1+src2)*20 - (src0+src3)*6 + (src0+src4)*3 - (src1+src5)) + 15)>>5]; dst[2*dstStride] = cm[(((src2+src3)*20 - (src1+src4)*6 + (src0+src5)*3 - (src0+src6)) + 15)>>5]; dst[3*dstStride] = cm[(((src3+src4)*20 - (src2+src5)*6 + (src1+src6)*3 - (src0+src7)) + 15)>>5]; dst[4*dstStride] = cm[(((src4+src5)*20 - (src3+src6)*6 + (src2+src7)*3 - (src1+src8)) + 15)>>5]; dst[5*dstStride] = cm[(((src5+src6)*20 - (src4+src7)*6 + (src3+src8)*3 - (src2+src8)) + 15)>>5]; dst[6*dstStride] = cm[(((src6+src7)*20 - (src5+src8)*6 + (src4+src8)*3 - (src3+src7)) + 15)>>5]; dst[7*dstStride] = cm[(((src7+src8)*20 - (src6+src8)*6 + (src5+src7)*3 - (src4+src6)) + 15)>>5]; dst++; src++; }}static void put_no_rnd_mpeg4_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){ uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<h; i++) { dst[ 0] = cm[(((src[ 0]+src[ 1])*20 - (src[ 0]+src[ 2])*6 + (src[ 1]+src[ 3])*3 - (src[ 2]+src[ 4])) + 15)>>5]; dst[ 1] = cm[(((src[ 1]+src[ 2])*20 - (src[ 0]+src[ 3])*6 + (src[ 0]+src[ 4])*3 - (src[ 1]+src[ 5])) + 15)>>5]; dst[ 2] = cm[(((src[ 2]+src[ 3])*20 - (src[ 1]+src[ 4])*6 + (src[ 0]+src[ 5])*3 - (src[ 0]+src[ 6])) + 15)>>5]; dst[ 3] = cm[(((src[ 3]+src[ 4])*20 - (src[ 2]+src[ 5])*6 + (src[ 1]+src[ 6])*3 - (src[ 0]+src[ 7])) + 15)>>5]; dst[ 4] = cm[(((src[ 4]+src[ 5])*20 - (src[ 3]+src[ 6])*6 + (src[ 2]+src[ 7])*3 - (src[ 1]+src[ 8])) + 15)>>5]; dst[ 5] = cm[(((src[ 5]+src[ 6])*20 - (src[ 4]+src[ 7])*6 + (src[ 3]+src[ 8])*3 - (src[ 2]+src[ 9])) + 15)>>5]; dst[ 6] = cm[(((src[ 6]+src[ 7])*20 - (src[ 5]+src[ 8])*6 + (src[ 4]+src[ 9])*3 - (src[ 3]+src[10])) + 15)>>5]; dst[ 7] = cm[(((src[ 7]+src[ 8])*20 - (src[ 6]+src[ 9])*6 + (src[ 5]+src[10])*3 - (src[ 4]+src[11])) + 15)>>5]; dst[ 8] = cm[(((src[ 8]+src[ 9])*20 - (src[ 7]+src[10])*6 + (src[ 6]+src[11])*3 - (src[ 5]+src[12])) + 15)>>5]; dst[ 9] = cm[(((src[ 9]+src[10])*20 - (src[ 8]+src[11])*6 + (src[ 7]+src[12])*3 - (src[ 6]+src[13])) + 15)>>5]; dst[10] = cm[(((src[10]+src[11])*20 - (src[ 9]+src[12])*6 + (src[ 8]+src[13])*3 - (src[ 7]+src[14])) + 15)>>5]; dst[11] = cm[(((src[11]+src[12])*20 - (src[10]+src[13])*6 + (src[ 9]+src[14])*3 - (src[ 8]+src[15])) + 15)>>5]; dst[12] = cm[(((src[12]+src[13])*20 - (src[11]+src[14])*6 + (src[10]+src[15])*3 - (src[ 9]+src[16])) + 15)>>5]; dst[13] = cm[(((src[13]+src[14])*20 - (src[12]+src[15])*6 + (src[11]+src[16])*3 - (src[10]+src[16])) + 15)>>5]; dst[14] = cm[(((src[14]+src[15])*20 - (src[13]+src[16])*6 + (src[12]+src[16])*3 - (src[11]+src[15])) + 15)>>5]; dst[15] = cm[(((src[15]+src[16])*20 - (src[14]+src[16])*6 + (src[13]+src[15])*3 - (src[12]+src[14])) + 15)>>5]; dst+=dstStride; src+=srcStride; }}static void put_no_rnd_mpeg4_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ uint8_t *cm = ff_cropTbl + 1024; int i; const int w=16; for(i=0; i<w; i++) { const int src0= src[0*srcStride]; const int src1= src[1*srcStride]; const int src2= src[2*srcStride]; const int src3= src[3*srcStride]; const int src4= src[4*srcStride]; const int src5= src[5*srcStride]; const int src6= src[6*srcStride]; const int src7= src[7*srcStride]; const int src8= src[8*srcStride]; const int src9= src[9*srcStride]; const int src10= src[10*srcStride]; const int src11= src[11*srcStride]; const int src12= src[12*srcStride]; const int src13= src[13*srcStride]; const int src14= src[14*srcStride]; const int src15= src[15*srcStride]; const int src16= src[16*srcStride]; dst[ 0*dstStride] = cm[(((src0 +src1 )*20 - (src0 +src2 )*6 + (src1 +src3 )*3 - (src2 +src4 )) + 15)>>5]; dst[ 1*dstStride] = cm[(((src1 +src2 )*20 - (src0 +src3 )*6 + (src0 +src4 )*3 - (src1 +src5 )) + 15)>>5]; dst[ 2*dstStride] = cm[(((src2 +src3 )*20 - (src1 +src4 )*6 + (src0 +src5 )*3 - (src0 +src6 )) + 15)>>5]; dst[ 3*dstStride] = cm[(((src3 +src4 )*20 - (src2 +src5 )*6 + (src1 +src6 )*3 - (src0 +src7 )) + 15)>>5]; dst[ 4*dstStride] = cm[(((src4 +src5 )*20 - (src3 +src6 )*6 + (src2 +src7 )*3 - (src1 +src8 )) + 15)>>5]; dst[ 5*dstStride] = cm[(((src5 +src6 )*20 - (src4 +src7 )*6 + (src3 +src8 )*3 - (src2 +src9 )) + 15)>>5]; dst[ 6*dstStride] = cm[(((src6 +src7 )*20 - (src5 +src8 )*6 + (src4 +src9 )*3 - (src3 +src10)) + 15)>>5]; dst[ 7*dstStride] = cm[(((src7 +src8 )*20 - (src6 +src9 )*6 + (src5 +src10)*3 - (src4 +src11)) + 15)>>5]; dst[ 8*dstStride] = cm[(((src8 +src9 )*20 - (src7 +src10)*6 + (src6 +src11)*3 - (src5 +src12)) + 15)>>5]; dst[ 9*dstStride] = cm[(((src9 +src10)*20 - (src8 +src11)*6 + (src7 +src12)*3 - (src6 +src13)) + 15)>>5]; dst[10*dstStride] = cm[(((src10+src11)*20 - (src9 +src12)*6 + (src8 +src13)*3 - (src7 +src14)) + 15)>>5]; dst[11*dstStride] = cm[(((src11+src12)*20 - (src10+src13)*6 + (src9 +src14)*3 - (src8 +src15)) + 15)>>5]; dst[12*dstStride] = cm[(((src12+src13)*20 - (src11+src14)*6 + (src10+src15)*3 - (src9 +src16)) + 15)>>5]; dst[13*dstStride] = cm[(((src13+src14)*20 - (src12+src15)*6 + (src11+src16)*3 - (src10+src16)) + 15)>>5]; dst[14*dstStride] = cm[(((src14+src15)*20 - (src13+src16)*6 + (src12+src16)*3 - (src11+src15)) + 15)>>5]; dst[15*dstStride] = cm[(((src15+src16)*20 - (src14+src16)*6 + (src13+src15)*3 - (src12+src14)) + 15)>>5]; dst++; src++; }}static void put_no_rnd_qpel8_mc00_c (uint8_t *dst, uint8_t *src, int stride){ put_no_rnd_pixels8_c(dst, src, stride, 8);}static void put_no_rnd_qpel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[64]; put_no_rnd_mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8); put_no_rnd_pixels8_l2(dst, src, half, stride, stride, 8, 8);}static void put_no_rnd_qpel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){ put_no_rnd_mpeg4_qpel8_h_lowpass(dst, src, stride, stride, 8);}static void put_no_rnd_qpel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[64]; put_no_rnd_mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8); put_no_rnd_pixels8_l2(dst, src+1, half, stride, stride, 8, 8);}static void put_no_rnd_qpel8_mc01_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t half[64]; copy_block9(full, src, 16, stride, 9); put_no_rnd_mpeg4_qpel8_v_lowpass(half, full, 8, 16); put_no_rnd_pixels8_l2(dst, full, half, stride, 16, 8, 8);}static void put_no_rnd_qpel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; copy_block9(full, src, 16, stride, 9); put_no_rnd_mpeg4_qpel8_v_lowpass(dst, full, stride, 16);}static void put_no_rnd_qpel8_mc03_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t half[64]; copy_block9(full, src, 16, stride, 9); put_no_rnd_mpeg4_qpel8_v_lowpass(half, full, 8, 16); put_no_rnd_pixels8_l2(dst, full+16, half, stride, 16, 8, 8);}void ff_put_no_rnd_qpel8_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfV[64]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_no_rnd_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_no_rnd_mpeg4_qpel8_v_lowpass(halfV, full, 8, 16); put_no_rnd_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_no_rnd_pixels8_l4(dst, full, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);}static void put_no_rnd_qpel8_mc11_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_no_rnd_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_no_rnd_pixels8_l2(halfH, halfH, full, 8, 8, 16, 9); put_no_rnd_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_no_rnd_pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);}void ff_put_no_rnd_qpel8_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfV[64]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_no_rnd_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_no_rnd_mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16); put_no_rnd_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_no_rnd_pixels8_l4(dst, full+1, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);}static void put_no_rnd_qpel8_mc31_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_no_rnd_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_no_rnd_pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9); put_no_rnd_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_no_rnd_pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);}void ff_put_no_rnd_qpel8_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfV[64]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_no_rnd_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_no_rnd_mpeg4_qpel8_v_lowpass(halfV, full, 8, 16); put_no_rnd_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_no_rnd_pixels8_l4(dst, full+16, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);}static void put_no_rnd_qpel8_mc13_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_no_rnd_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_no_rnd_pixels8_l2(halfH, halfH, full, 8, 8, 16, 9); put_no_rnd_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_no_rnd_pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);}void ff_put_no_rnd_qpel8_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfV[64]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_no_rnd_mpeg4_qpel8_h_lowpass(halfH, full , 8, 16, 9); put_no_rnd_mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16); put_no_rnd_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_no_rnd_pixels8_l4(dst, full+17, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);}static void put_no_rnd_qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_no_rnd_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_no_rnd_pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9); put_no_rnd_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_no_rnd_pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);}static void put_no_rnd_qpel8_mc21_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t halfH[72]; uint8_t halfHV[64]; put_no_rnd_mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9); put_no_rnd_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_no_rnd_pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);}static void put_no_rnd_qpel8_mc23_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t halfH[72]; uint8_t halfHV[64]; put_no_rnd_mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9); put_no_rnd_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_no_rnd_pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);}void ff_put_no_rnd_qpel8_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfV[64]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_no_rnd_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_no_rnd_mpeg4_qpel8_v_lowpass(halfV, full, 8, 16); put_no_rnd_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_no_rnd_pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);}static void put_no_rnd_qpel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; copy_block9(full, src, 16, stride, 9); put_no_rnd_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_no_rnd_pixels8_l2(halfH, halfH, full, 8, 8, 16, 9); put_no_rnd_mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);}void ff_put_no_rnd_qpel8_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfV[64]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_no_rnd_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_no_rnd_mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16); put_no_rnd_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); put_no_rnd_pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);}static void put_no_rnd_qpel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; copy_block9(full, src, 16, stride, 9); put_no_rnd_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_no_rnd_pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9); put_no_rnd_mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);}static void put_no_rnd_qpel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t halfH[72]; put_no_rnd_mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9); put_no_rnd_mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);}static void put_no_rnd_qpel16_mc00_c (uint8_t *dst, uint8_t *src, int stride){ put_no_rnd_pixels16_c(dst, src, stride, 16);}static void put_no_rnd_qpel16_mc10_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[256]; put_no_rnd_mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16); put_no_rnd_pixels16_l2(dst, src, half, stride, stride, 16, 16);}static void put_no_rnd_qpel16_mc20_c(uint8_t *dst, uint8_t *src, int stride){ put_no_rnd_mpeg4_qpel16_h_lowpass(dst, src, stride, stride, 16);}static void put_no_rnd_qpel16_mc30_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[256]; put_no_rnd_mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16); put_no_rnd_pixels16_l2(dst, src+1, half, stride, stride, 16, 16);}static void put_no_rnd_qpel16_mc01_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t half[256]; copy_block17(full, src, 24, stride, 17); put_no_rnd_mpeg4_qpel16_v_lowpass(half, full, 16, 24); put_no_rnd_pixels16_l2(dst, full, half, stride, 24, 16, 16);}static void put_no_rnd_qpel16_mc02_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; copy_block17(full, src, 24, stride, 17); put_no_rnd_mpeg4_qpel16_v_lowpass(dst, full, stride, 24);}static void put_no_rnd_qpel16_mc03_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t half[256]; copy_block17(full, src, 24, stride, 17); put_no_rnd_mpeg4_qpel16_v_lowpass(half, full, 16, 24); put_no_rnd_pixels16_l2(dst, full+24, half, stride, 24, 16, 16);}void ff_put_no_rnd_qpel16_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfV[256]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_no_rnd_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_no_rnd_mpeg4_qpel16_v_lowpass(halfV, full, 16, 24); put_no_rnd_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_no_rnd_pixels16_l4(dst, full, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);}static void put_no_rnd_qpel16_mc11_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_no_rnd_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_no_rnd_pixels16_l2(halfH, halfH, full, 16, 16, 24, 17); put_no_rnd_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_no_rnd_pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);}void ff_put_no_rnd_qpel16_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfV[256]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_no_rnd_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_no_rnd_mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24); put_no_rnd_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_no_rnd_pixels16_l4(dst, full+1, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);}static void put_no_rnd_qpel16_mc31_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_no_rnd_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_no_rnd_pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17); put_no_rnd_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_no_rnd_pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);}void ff_put_no_rnd_qpel16_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfV[256]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_no_rnd_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_no_rnd_mpeg4_qpel16_v_lowpass(halfV, full, 16, 24); put_no_rnd_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_no_rnd_pixels16_l4(dst, full+24, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);}static void put_no_rnd_qpel16_mc13_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_no_rnd_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_no_rnd_pixels16_l2(halfH, halfH, full, 16, 16, 24, 17); put_no_rnd_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_no_rnd_pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);}void ff_put_no_rnd_qpel16_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfV[256]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_no_rnd_mpeg4_qpel16_h_lowpass(halfH, full , 16, 24, 17); put_no_rnd_mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24); put_no_rnd_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_no_rnd_pixels16_l4(dst, full+25, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);}static void put_no_rnd_qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_no_rnd_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_no_rnd_pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17); put_no_rnd_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_no_rnd_pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);}static void put_no_rnd_qpel16_mc21_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t halfH[272]; uint8_t halfHV[256]; put_no_rnd_mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17); put_no_rnd_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_no_rnd_pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);}static void put_no_rnd_qpel16_mc23_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t halfH[272]; uint8_t halfHV[256]; put_no_rnd_mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17); put_no_rnd_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_no_rnd_pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);}void ff_put_no_rnd_qpel16_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfV[256]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_no_rnd_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_no_rnd_mpeg4_qpel16_v_lowpass(halfV, full, 16, 24); put_no_rnd_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_no_rnd_pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);}static void put_no_rnd_qpel16_mc12_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; copy_block17(full, src, 24, stride, 17); put_no_rnd_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_no_rnd_pixels16_l2(halfH, halfH, full, 16, 16, 24, 17); put_no_rnd_mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);}void ff_put_no_rnd_qpel16_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfV[256]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_no_rnd_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_no_rnd_mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24); put_no_rnd_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); put_no_rnd_pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);}static void put_no_rnd_qpel16_mc32_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; copy_block17(full, src, 24, stride, 17); put_no_rnd_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_no_rnd_pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17); put_no_rnd_mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);}static void put_no_rnd_qpel16_mc22_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t halfH[272]; put_no_rnd_mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17); put_no_rnd_mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);}
>static void avg_mpeg4_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){ uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<h; i++) { dst[0] = (((dst[0])+cm[(((src[0]+src[1])*20 - (src[0]+src[2])*6 + (src[1]+src[3])*3 - (src[2]+src[4])) + 16)>>5]+1)>>1); dst[1] = (((dst[1])+cm[(((src[1]+src[2])*20 - (src[0]+src[3])*6 + (src[0]+src[4])*3 - (src[1]+src[5])) + 16)>>5]+1)>>1); dst[2] = (((dst[2])+cm[(((src[2]+src[3])*20 - (src[1]+src[4])*6 + (src[0]+src[5])*3 - (src[0]+src[6])) + 16)>>5]+1)>>1); dst[3] = (((dst[3])+cm[(((src[3]+src[4])*20 - (src[2]+src[5])*6 + (src[1]+src[6])*3 - (src[0]+src[7])) + 16)>>5]+1)>>1); dst[4] = (((dst[4])+cm[(((src[4]+src[5])*20 - (src[3]+src[6])*6 + (src[2]+src[7])*3 - (src[1]+src[8])) + 16)>>5]+1)>>1); dst[5] = (((dst[5])+cm[(((src[5]+src[6])*20 - (src[4]+src[7])*6 + (src[3]+src[8])*3 - (src[2]+src[8])) + 16)>>5]+1)>>1); dst[6] = (((dst[6])+cm[(((src[6]+src[7])*20 - (src[5]+src[8])*6 + (src[4]+src[8])*3 - (src[3]+src[7])) + 16)>>5]+1)>>1); dst[7] = (((dst[7])+cm[(((src[7]+src[8])*20 - (src[6]+src[8])*6 + (src[5]+src[7])*3 - (src[4]+src[6])) + 16)>>5]+1)>>1); dst+=dstStride; src+=srcStride; }}static void avg_mpeg4_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ const int w=8; uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<w; i++) { const int src0= src[0*srcStride]; const int src1= src[1*srcStride]; const int src2= src[2*srcStride]; const int src3= src[3*srcStride]; const int src4= src[4*srcStride]; const int src5= src[5*srcStride]; const int src6= src[6*srcStride]; const int src7= src[7*srcStride]; const int src8= src[8*srcStride]; dst[0*dstStride] = (((dst[0*dstStride])+cm[(((src0+src1)*20 - (src0+src2)*6 + (src1+src3)*3 - (src2+src4)) + 16)>>5]+1)>>1); dst[1*dstStride] = (((dst[1*dstStride])+cm[(((src1+src2)*20 - (src0+src3)*6 + (src0+src4)*3 - (src1+src5)) + 16)>>5]+1)>>1); dst[2*dstStride] = (((dst[2*dstStride])+cm[(((src2+src3)*20 - (src1+src4)*6 + (src0+src5)*3 - (src0+src6)) + 16)>>5]+1)>>1); dst[3*dstStride] = (((dst[3*dstStride])+cm[(((src3+src4)*20 - (src2+src5)*6 + (src1+src6)*3 - (src0+src7)) + 16)>>5]+1)>>1); dst[4*dstStride] = (((dst[4*dstStride])+cm[(((src4+src5)*20 - (src3+src6)*6 + (src2+src7)*3 - (src1+src8)) + 16)>>5]+1)>>1); dst[5*dstStride] = (((dst[5*dstStride])+cm[(((src5+src6)*20 - (src4+src7)*6 + (src3+src8)*3 - (src2+src8)) + 16)>>5]+1)>>1); dst[6*dstStride] = (((dst[6*dstStride])+cm[(((src6+src7)*20 - (src5+src8)*6 + (src4+src8)*3 - (src3+src7)) + 16)>>5]+1)>>1); dst[7*dstStride] = (((dst[7*dstStride])+cm[(((src7+src8)*20 - (src6+src8)*6 + (src5+src7)*3 - (src4+src6)) + 16)>>5]+1)>>1); dst++; src++; }}static void avg_mpeg4_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){ uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<h; i++) { dst[ 0] = (((dst[ 0])+cm[(((src[ 0]+src[ 1])*20 - (src[ 0]+src[ 2])*6 + (src[ 1]+src[ 3])*3 - (src[ 2]+src[ 4])) + 16)>>5]+1)>>1); dst[ 1] = (((dst[ 1])+cm[(((src[ 1]+src[ 2])*20 - (src[ 0]+src[ 3])*6 + (src[ 0]+src[ 4])*3 - (src[ 1]+src[ 5])) + 16)>>5]+1)>>1); dst[ 2] = (((dst[ 2])+cm[(((src[ 2]+src[ 3])*20 - (src[ 1]+src[ 4])*6 + (src[ 0]+src[ 5])*3 - (src[ 0]+src[ 6])) + 16)>>5]+1)>>1); dst[ 3] = (((dst[ 3])+cm[(((src[ 3]+src[ 4])*20 - (src[ 2]+src[ 5])*6 + (src[ 1]+src[ 6])*3 - (src[ 0]+src[ 7])) + 16)>>5]+1)>>1); dst[ 4] = (((dst[ 4])+cm[(((src[ 4]+src[ 5])*20 - (src[ 3]+src[ 6])*6 + (src[ 2]+src[ 7])*3 - (src[ 1]+src[ 8])) + 16)>>5]+1)>>1); dst[ 5] = (((dst[ 5])+cm[(((src[ 5]+src[ 6])*20 - (src[ 4]+src[ 7])*6 + (src[ 3]+src[ 8])*3 - (src[ 2]+src[ 9])) + 16)>>5]+1)>>1); dst[ 6] = (((dst[ 6])+cm[(((src[ 6]+src[ 7])*20 - (src[ 5]+src[ 8])*6 + (src[ 4]+src[ 9])*3 - (src[ 3]+src[10])) + 16)>>5]+1)>>1); dst[ 7] = (((dst[ 7])+cm[(((src[ 7]+src[ 8])*20 - (src[ 6]+src[ 9])*6 + (src[ 5]+src[10])*3 - (src[ 4]+src[11])) + 16)>>5]+1)>>1); dst[ 8] = (((dst[ 8])+cm[(((src[ 8]+src[ 9])*20 - (src[ 7]+src[10])*6 + (src[ 6]+src[11])*3 - (src[ 5]+src[12])) + 16)>>5]+1)>>1); dst[ 9] = (((dst[ 9])+cm[(((src[ 9]+src[10])*20 - (src[ 8]+src[11])*6 + (src[ 7]+src[12])*3 - (src[ 6]+src[13])) + 16)>>5]+1)>>1); dst[10] = (((dst[10])+cm[(((src[10]+src[11])*20 - (src[ 9]+src[12])*6 + (src[ 8]+src[13])*3 - (src[ 7]+src[14])) + 16)>>5]+1)>>1); dst[11] = (((dst[11])+cm[(((src[11]+src[12])*20 - (src[10]+src[13])*6 + (src[ 9]+src[14])*3 - (src[ 8]+src[15])) + 16)>>5]+1)>>1); dst[12] = (((dst[12])+cm[(((src[12]+src[13])*20 - (src[11]+src[14])*6 + (src[10]+src[15])*3 - (src[ 9]+src[16])) + 16)>>5]+1)>>1); dst[13] = (((dst[13])+cm[(((src[13]+src[14])*20 - (src[12]+src[15])*6 + (src[11]+src[16])*3 - (src[10]+src[16])) + 16)>>5]+1)>>1); dst[14] = (((dst[14])+cm[(((src[14]+src[15])*20 - (src[13]+src[16])*6 + (src[12]+src[16])*3 - (src[11]+src[15])) + 16)>>5]+1)>>1); dst[15] = (((dst[15])+cm[(((src[15]+src[16])*20 - (src[14]+src[16])*6 + (src[13]+src[15])*3 - (src[12]+src[14])) + 16)>>5]+1)>>1); dst+=dstStride; src+=srcStride; }}static void avg_mpeg4_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ uint8_t *cm = ff_cropTbl + 1024; int i; const int w=16; for(i=0; i<w; i++) { const int src0= src[0*srcStride]; const int src1= src[1*srcStride]; const int src2= src[2*srcStride]; const int src3= src[3*srcStride]; const int src4= src[4*srcStride]; const int src5= src[5*srcStride]; const int src6= src[6*srcStride]; const int src7= src[7*srcStride]; const int src8= src[8*srcStride]; const int src9= src[9*srcStride]; const int src10= src[10*srcStride]; const int src11= src[11*srcStride]; const int src12= src[12*srcStride]; const int src13= src[13*srcStride]; const int src14= src[14*srcStride]; const int src15= src[15*srcStride]; const int src16= src[16*srcStride]; dst[ 0*dstStride] = (((dst[ 0*dstStride])+cm[(((src0 +src1 )*20 - (src0 +src2 )*6 + (src1 +src3 )*3 - (src2 +src4 )) + 16)>>5]+1)>>1); dst[ 1*dstStride] = (((dst[ 1*dstStride])+cm[(((src1 +src2 )*20 - (src0 +src3 )*6 + (src0 +src4 )*3 - (src1 +src5 )) + 16)>>5]+1)>>1); dst[ 2*dstStride] = (((dst[ 2*dstStride])+cm[(((src2 +src3 )*20 - (src1 +src4 )*6 + (src0 +src5 )*3 - (src0 +src6 )) + 16)>>5]+1)>>1); dst[ 3*dstStride] = (((dst[ 3*dstStride])+cm[(((src3 +src4 )*20 - (src2 +src5 )*6 + (src1 +src6 )*3 - (src0 +src7 )) + 16)>>5]+1)>>1); dst[ 4*dstStride] = (((dst[ 4*dstStride])+cm[(((src4 +src5 )*20 - (src3 +src6 )*6 + (src2 +src7 )*3 - (src1 +src8 )) + 16)>>5]+1)>>1); dst[ 5*dstStride] = (((dst[ 5*dstStride])+cm[(((src5 +src6 )*20 - (src4 +src7 )*6 + (src3 +src8 )*3 - (src2 +src9 )) + 16)>>5]+1)>>1); dst[ 6*dstStride] = (((dst[ 6*dstStride])+cm[(((src6 +src7 )*20 - (src5 +src8 )*6 + (src4 +src9 )*3 - (src3 +src10)) + 16)>>5]+1)>>1); dst[ 7*dstStride] = (((dst[ 7*dstStride])+cm[(((src7 +src8 )*20 - (src6 +src9 )*6 + (src5 +src10)*3 - (src4 +src11)) + 16)>>5]+1)>>1); dst[ 8*dstStride] = (((dst[ 8*dstStride])+cm[(((src8 +src9 )*20 - (src7 +src10)*6 + (src6 +src11)*3 - (src5 +src12)) + 16)>>5]+1)>>1); dst[ 9*dstStride] = (((dst[ 9*dstStride])+cm[(((src9 +src10)*20 - (src8 +src11)*6 + (src7 +src12)*3 - (src6 +src13)) + 16)>>5]+1)>>1); dst[10*dstStride] = (((dst[10*dstStride])+cm[(((src10+src11)*20 - (src9 +src12)*6 + (src8 +src13)*3 - (src7 +src14)) + 16)>>5]+1)>>1); dst[11*dstStride] = (((dst[11*dstStride])+cm[(((src11+src12)*20 - (src10+src13)*6 + (src9 +src14)*3 - (src8 +src15)) + 16)>>5]+1)>>1); dst[12*dstStride] = (((dst[12*dstStride])+cm[(((src12+src13)*20 - (src11+src14)*6 + (src10+src15)*3 - (src9 +src16)) + 16)>>5]+1)>>1); dst[13*dstStride] = (((dst[13*dstStride])+cm[(((src13+src14)*20 - (src12+src15)*6 + (src11+src16)*3 - (src10+src16)) + 16)>>5]+1)>>1); dst[14*dstStride] = (((dst[14*dstStride])+cm[(((src14+src15)*20 - (src13+src16)*6 + (src12+src16)*3 - (src11+src15)) + 16)>>5]+1)>>1); dst[15*dstStride] = (((dst[15*dstStride])+cm[(((src15+src16)*20 - (src14+src16)*6 + (src13+src15)*3 - (src12+src14)) + 16)>>5]+1)>>1); dst++; src++; }}static void avg_qpel8_mc00_c (uint8_t *dst, uint8_t *src, int stride){ avg_pixels8_c(dst, src, stride, 8);}static void avg_qpel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[64]; put_mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8); avg_pixels8_l2(dst, src, half, stride, stride, 8, 8);}static void avg_qpel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){ avg_mpeg4_qpel8_h_lowpass(dst, src, stride, stride, 8);}static void avg_qpel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[64]; put_mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8); avg_pixels8_l2(dst, src+1, half, stride, stride, 8, 8);}static void avg_qpel8_mc01_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t half[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_v_lowpass(half, full, 8, 16); avg_pixels8_l2(dst, full, half, stride, 16, 8, 8);}static void avg_qpel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; copy_block9(full, src, 16, stride, 9); avg_mpeg4_qpel8_v_lowpass(dst, full, stride, 16);}static void avg_qpel8_mc03_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t half[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_v_lowpass(half, full, 8, 16); avg_pixels8_l2(dst, full+16, half, stride, 16, 8, 8);}void ff_avg_qpel8_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfV[64]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_mpeg4_qpel8_v_lowpass(halfV, full, 8, 16); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); avg_pixels8_l4(dst, full, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);}static void avg_qpel8_mc11_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_pixels8_l2(halfH, halfH, full, 8, 8, 16, 9); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); avg_pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);}void ff_avg_qpel8_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfV[64]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); avg_pixels8_l4(dst, full+1, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);}static void avg_qpel8_mc31_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); avg_pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);}void ff_avg_qpel8_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfV[64]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_mpeg4_qpel8_v_lowpass(halfV, full, 8, 16); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); avg_pixels8_l4(dst, full+16, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);}static void avg_qpel8_mc13_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_pixels8_l2(halfH, halfH, full, 8, 8, 16, 9); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); avg_pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);}void ff_avg_qpel8_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfV[64]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full , 8, 16, 9); put_mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); avg_pixels8_l4(dst, full+17, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);}static void avg_qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); avg_pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);}static void avg_qpel8_mc21_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t halfH[72]; uint8_t halfHV[64]; put_mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); avg_pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);}static void avg_qpel8_mc23_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t halfH[72]; uint8_t halfHV[64]; put_mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); avg_pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);}void ff_avg_qpel8_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfV[64]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_mpeg4_qpel8_v_lowpass(halfV, full, 8, 16); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); avg_pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);}static void avg_qpel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_pixels8_l2(halfH, halfH, full, 8, 8, 16, 9); avg_mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);}void ff_avg_qpel8_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; uint8_t halfV[64]; uint8_t halfHV[64]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16); put_mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8); avg_pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);}static void avg_qpel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*9]; uint8_t halfH[72]; copy_block9(full, src, 16, stride, 9); put_mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9); put_pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9); avg_mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);}static void avg_qpel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t halfH[72]; put_mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9); avg_mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);}static void avg_qpel16_mc00_c (uint8_t *dst, uint8_t *src, int stride){ avg_pixels16_c(dst, src, stride, 16);}static void avg_qpel16_mc10_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[256]; put_mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16); avg_pixels16_l2(dst, src, half, stride, stride, 16, 16);}static void avg_qpel16_mc20_c(uint8_t *dst, uint8_t *src, int stride){ avg_mpeg4_qpel16_h_lowpass(dst, src, stride, stride, 16);}static void avg_qpel16_mc30_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[256]; put_mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16); avg_pixels16_l2(dst, src+1, half, stride, stride, 16, 16);}static void avg_qpel16_mc01_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t half[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_v_lowpass(half, full, 16, 24); avg_pixels16_l2(dst, full, half, stride, 24, 16, 16);}static void avg_qpel16_mc02_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; copy_block17(full, src, 24, stride, 17); avg_mpeg4_qpel16_v_lowpass(dst, full, stride, 24);}static void avg_qpel16_mc03_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t half[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_v_lowpass(half, full, 16, 24); avg_pixels16_l2(dst, full+24, half, stride, 24, 16, 16);}void ff_avg_qpel16_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfV[256]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_mpeg4_qpel16_v_lowpass(halfV, full, 16, 24); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); avg_pixels16_l4(dst, full, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);}static void avg_qpel16_mc11_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_pixels16_l2(halfH, halfH, full, 16, 16, 24, 17); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); avg_pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);}void ff_avg_qpel16_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfV[256]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); avg_pixels16_l4(dst, full+1, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);}static void avg_qpel16_mc31_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); avg_pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);}void ff_avg_qpel16_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfV[256]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_mpeg4_qpel16_v_lowpass(halfV, full, 16, 24); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); avg_pixels16_l4(dst, full+24, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);}static void avg_qpel16_mc13_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_pixels16_l2(halfH, halfH, full, 16, 16, 24, 17); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); avg_pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);}void ff_avg_qpel16_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfV[256]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full , 16, 24, 17); put_mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); avg_pixels16_l4(dst, full+25, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);}static void avg_qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); avg_pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);}static void avg_qpel16_mc21_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t halfH[272]; uint8_t halfHV[256]; put_mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); avg_pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);}static void avg_qpel16_mc23_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t halfH[272]; uint8_t halfHV[256]; put_mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); avg_pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);}void ff_avg_qpel16_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfV[256]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_mpeg4_qpel16_v_lowpass(halfV, full, 16, 24); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); avg_pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);}static void avg_qpel16_mc12_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_pixels16_l2(halfH, halfH, full, 16, 16, 24, 17); avg_mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);}void ff_avg_qpel16_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; uint8_t halfV[256]; uint8_t halfHV[256]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24); put_mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16); avg_pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);}static void avg_qpel16_mc32_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[24*17]; uint8_t halfH[272]; copy_block17(full, src, 24, stride, 17); put_mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17); put_pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17); avg_mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);}static void avg_qpel16_mc22_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t halfH[272]; put_mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17); avg_mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);}
># 2429 "dsputil.c"
>static void put_h264_qpel2_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ const int h=2; uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<h; i++) { dst[0] = cm[(((src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3])) + 16)>>5]; dst[1] = cm[(((src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4])) + 16)>>5]; dst+=dstStride; src+=srcStride; }}static void put_h264_qpel2_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ const int w=2; uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<w; i++) { const int srcB= src[-2*srcStride]; const int srcA= src[-1*srcStride]; const int src0= src[0 *srcStride]; const int src1= src[1 *srcStride]; const int src2= src[2 *srcStride]; const int src3= src[3 *srcStride]; const int src4= src[4 *srcStride]; dst[0*dstStride] = cm[(((src0+src1)*20 - (srcA+src2)*5 + (srcB+src3)) + 16)>>5]; dst[1*dstStride] = cm[(((src1+src2)*20 - (src0+src3)*5 + (srcA+src4)) + 16)>>5]; dst++; src++; }}static void put_h264_qpel2_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){ const int h=2; const int w=2; uint8_t *cm = ff_cropTbl + 1024; int i; src -= 2*srcStride; for(i=0; i<h+5; i++) { tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]); tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]); tmp+=tmpStride; src+=srcStride; } tmp -= tmpStride*(h+5-2); for(i=0; i<w; i++) { const int tmpB= tmp[-2*tmpStride]; const int tmpA= tmp[-1*tmpStride]; const int tmp0= tmp[0 *tmpStride]; const int tmp1= tmp[1 *tmpStride]; const int tmp2= tmp[2 *tmpStride]; const int tmp3= tmp[3 *tmpStride]; const int tmp4= tmp[4 *tmpStride]; dst[0*dstStride] = cm[(((tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3)) + 512)>>10]; dst[1*dstStride] = cm[(((tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4)) + 512)>>10]; dst++; tmp++; }}static void put_h264_qpel4_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ const int h=4; uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<h; i++) { dst[0] = cm[(((src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3])) + 16)>>5]; dst[1] = cm[(((src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4])) + 16)>>5]; dst[2] = cm[(((src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5])) + 16)>>5]; dst[3] = cm[(((src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6])) + 16)>>5]; dst+=dstStride; src+=srcStride; }}static void put_h264_qpel4_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ const int w=4; uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<w; i++) { const int srcB= src[-2*srcStride]; const int srcA= src[-1*srcStride]; const int src0= src[0 *srcStride]; const int src1= src[1 *srcStride]; const int src2= src[2 *srcStride]; const int src3= src[3 *srcStride]; const int src4= src[4 *srcStride]; const int src5= src[5 *srcStride]; const int src6= src[6 *srcStride]; dst[0*dstStride] = cm[(((src0+src1)*20 - (srcA+src2)*5 + (srcB+src3)) + 16)>>5]; dst[1*dstStride] = cm[(((src1+src2)*20 - (src0+src3)*5 + (srcA+src4)) + 16)>>5]; dst[2*dstStride] = cm[(((src2+src3)*20 - (src1+src4)*5 + (src0+src5)) + 16)>>5]; dst[3*dstStride] = cm[(((src3+src4)*20 - (src2+src5)*5 + (src1+src6)) + 16)>>5]; dst++; src++; }}static void put_h264_qpel4_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){ const int h=4; const int w=4; uint8_t *cm = ff_cropTbl + 1024; int i; src -= 2*srcStride; for(i=0; i<h+5; i++) { tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]); tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]); tmp[2]= (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5]); tmp[3]= (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6]); tmp+=tmpStride; src+=srcStride; } tmp -= tmpStride*(h+5-2); for(i=0; i<w; i++) { const int tmpB= tmp[-2*tmpStride]; const int tmpA= tmp[-1*tmpStride]; const int tmp0= tmp[0 *tmpStride]; const int tmp1= tmp[1 *tmpStride]; const int tmp2= tmp[2 *tmpStride]; const int tmp3= tmp[3 *tmpStride]; const int tmp4= tmp[4 *tmpStride]; const int tmp5= tmp[5 *tmpStride]; const int tmp6= tmp[6 *tmpStride]; dst[0*dstStride] = cm[(((tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3)) + 512)>>10]; dst[1*dstStride] = cm[(((tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4)) + 512)>>10]; dst[2*dstStride] = cm[(((tmp2+tmp3)*20 - (tmp1+tmp4)*5 + (tmp0+tmp5)) + 512)>>10]; dst[3*dstStride] = cm[(((tmp3+tmp4)*20 - (tmp2+tmp5)*5 + (tmp1+tmp6)) + 512)>>10]; dst++; tmp++; }}static void put_h264_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ const int h=8; uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<h; i++) { dst[0] = cm[(((src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3 ])) + 16)>>5]; dst[1] = cm[(((src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4 ])) + 16)>>5]; dst[2] = cm[(((src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5 ])) + 16)>>5]; dst[3] = cm[(((src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6 ])) + 16)>>5]; dst[4] = cm[(((src[4]+src[5])*20 - (src[3 ]+src[6])*5 + (src[2 ]+src[7 ])) + 16)>>5]; dst[5] = cm[(((src[5]+src[6])*20 - (src[4 ]+src[7])*5 + (src[3 ]+src[8 ])) + 16)>>5]; dst[6] = cm[(((src[6]+src[7])*20 - (src[5 ]+src[8])*5 + (src[4 ]+src[9 ])) + 16)>>5]; dst[7] = cm[(((src[7]+src[8])*20 - (src[6 ]+src[9])*5 + (src[5 ]+src[10])) + 16)>>5]; dst+=dstStride; src+=srcStride; }}static void put_h264_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ const int w=8; uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<w; i++) { const int srcB= src[-2*srcStride]; const int srcA= src[-1*srcStride]; const int src0= src[0 *srcStride]; const int src1= src[1 *srcStride]; const int src2= src[2 *srcStride]; const int src3= src[3 *srcStride]; const int src4= src[4 *srcStride]; const int src5= src[5 *srcStride]; const int src6= src[6 *srcStride]; const int src7= src[7 *srcStride]; const int src8= src[8 *srcStride]; const int src9= src[9 *srcStride]; const int src10=src[10*srcStride]; dst[0*dstStride] = cm[(((src0+src1)*20 - (srcA+src2)*5 + (srcB+src3)) + 16)>>5]; dst[1*dstStride] = cm[(((src1+src2)*20 - (src0+src3)*5 + (srcA+src4)) + 16)>>5]; dst[2*dstStride] = cm[(((src2+src3)*20 - (src1+src4)*5 + (src0+src5)) + 16)>>5]; dst[3*dstStride] = cm[(((src3+src4)*20 - (src2+src5)*5 + (src1+src6)) + 16)>>5]; dst[4*dstStride] = cm[(((src4+src5)*20 - (src3+src6)*5 + (src2+src7)) + 16)>>5]; dst[5*dstStride] = cm[(((src5+src6)*20 - (src4+src7)*5 + (src3+src8)) + 16)>>5]; dst[6*dstStride] = cm[(((src6+src7)*20 - (src5+src8)*5 + (src4+src9)) + 16)>>5]; dst[7*dstStride] = cm[(((src7+src8)*20 - (src6+src9)*5 + (src5+src10)) + 16)>>5]; dst++; src++; }}static void put_h264_qpel8_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){ const int h=8; const int w=8; uint8_t *cm = ff_cropTbl + 1024; int i; src -= 2*srcStride; for(i=0; i<h+5; i++) { tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3 ]); tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4 ]); tmp[2]= (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5 ]); tmp[3]= (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6 ]); tmp[4]= (src[4]+src[5])*20 - (src[3 ]+src[6])*5 + (src[2 ]+src[7 ]); tmp[5]= (src[5]+src[6])*20 - (src[4 ]+src[7])*5 + (src[3 ]+src[8 ]); tmp[6]= (src[6]+src[7])*20 - (src[5 ]+src[8])*5 + (src[4 ]+src[9 ]); tmp[7]= (src[7]+src[8])*20 - (src[6 ]+src[9])*5 + (src[5 ]+src[10]); tmp+=tmpStride; src+=srcStride; } tmp -= tmpStride*(h+5-2); for(i=0; i<w; i++) { const int tmpB= tmp[-2*tmpStride]; const int tmpA= tmp[-1*tmpStride]; const int tmp0= tmp[0 *tmpStride]; const int tmp1= tmp[1 *tmpStride]; const int tmp2= tmp[2 *tmpStride]; const int tmp3= tmp[3 *tmpStride]; const int tmp4= tmp[4 *tmpStride]; const int tmp5= tmp[5 *tmpStride]; const int tmp6= tmp[6 *tmpStride]; const int tmp7= tmp[7 *tmpStride]; const int tmp8= tmp[8 *tmpStride]; const int tmp9= tmp[9 *tmpStride]; const int tmp10=tmp[10*tmpStride]; dst[0*dstStride] = cm[(((tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3)) + 512)>>10]; dst[1*dstStride] = cm[(((tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4)) + 512)>>10]; dst[2*dstStride] = cm[(((tmp2+tmp3)*20 - (tmp1+tmp4)*5 + (tmp0+tmp5)) + 512)>>10]; dst[3*dstStride] = cm[(((tmp3+tmp4)*20 - (tmp2+tmp5)*5 + (tmp1+tmp6)) + 512)>>10]; dst[4*dstStride] = cm[(((tmp4+tmp5)*20 - (tmp3+tmp6)*5 + (tmp2+tmp7)) + 512)>>10]; dst[5*dstStride] = cm[(((tmp5+tmp6)*20 - (tmp4+tmp7)*5 + (tmp3+tmp8)) + 512)>>10]; dst[6*dstStride] = cm[(((tmp6+tmp7)*20 - (tmp5+tmp8)*5 + (tmp4+tmp9)) + 512)>>10]; dst[7*dstStride] = cm[(((tmp7+tmp8)*20 - (tmp6+tmp9)*5 + (tmp5+tmp10)) + 512)>>10]; dst++; tmp++; }}static void put_h264_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ put_h264_qpel8_v_lowpass(dst , src , dstStride, srcStride); put_h264_qpel8_v_lowpass(dst+8, src+8, dstStride, srcStride); src += 8*srcStride; dst += 8*dstStride; put_h264_qpel8_v_lowpass(dst , src , dstStride, srcStride); put_h264_qpel8_v_lowpass(dst+8, src+8, dstStride, srcStride);}static void put_h264_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ put_h264_qpel8_h_lowpass(dst , src , dstStride, srcStride); put_h264_qpel8_h_lowpass(dst+8, src+8, dstStride, srcStride); src += 8*srcStride; dst += 8*dstStride; put_h264_qpel8_h_lowpass(dst , src , dstStride, srcStride); put_h264_qpel8_h_lowpass(dst+8, src+8, dstStride, srcStride);}static void put_h264_qpel16_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){ put_h264_qpel8_hv_lowpass(dst , tmp , src , dstStride, tmpStride, srcStride); put_h264_qpel8_hv_lowpass(dst+8, tmp+8, src+8, dstStride, tmpStride, srcStride); src += 8*srcStride; dst += 8*dstStride; put_h264_qpel8_hv_lowpass(dst , tmp , src , dstStride, tmpStride, srcStride); put_h264_qpel8_hv_lowpass(dst+8, tmp+8, src+8, dstStride, tmpStride, srcStride);}
>static void avg_h264_qpel2_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ const int h=2; uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<h; i++) { dst[0] = (((dst[0])+cm[(((src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3])) + 16)>>5]+1)>>1); dst[1] = (((dst[1])+cm[(((src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4])) + 16)>>5]+1)>>1); dst+=dstStride; src+=srcStride; }}static void avg_h264_qpel2_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ const int w=2; uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<w; i++) { const int srcB= src[-2*srcStride]; const int srcA= src[-1*srcStride]; const int src0= src[0 *srcStride]; const int src1= src[1 *srcStride]; const int src2= src[2 *srcStride]; const int src3= src[3 *srcStride]; const int src4= src[4 *srcStride]; dst[0*dstStride] = (((dst[0*dstStride])+cm[(((src0+src1)*20 - (srcA+src2)*5 + (srcB+src3)) + 16)>>5]+1)>>1); dst[1*dstStride] = (((dst[1*dstStride])+cm[(((src1+src2)*20 - (src0+src3)*5 + (srcA+src4)) + 16)>>5]+1)>>1); dst++; src++; }}static void avg_h264_qpel2_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){ const int h=2; const int w=2; uint8_t *cm = ff_cropTbl + 1024; int i; src -= 2*srcStride; for(i=0; i<h+5; i++) { tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]); tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]); tmp+=tmpStride; src+=srcStride; } tmp -= tmpStride*(h+5-2); for(i=0; i<w; i++) { const int tmpB= tmp[-2*tmpStride]; const int tmpA= tmp[-1*tmpStride]; const int tmp0= tmp[0 *tmpStride]; const int tmp1= tmp[1 *tmpStride]; const int tmp2= tmp[2 *tmpStride]; const int tmp3= tmp[3 *tmpStride]; const int tmp4= tmp[4 *tmpStride]; dst[0*dstStride] = (((dst[0*dstStride])+cm[(((tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3)) + 512)>>10]+1)>>1); dst[1*dstStride] = (((dst[1*dstStride])+cm[(((tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4)) + 512)>>10]+1)>>1); dst++; tmp++; }}static void avg_h264_qpel4_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ const int h=4; uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<h; i++) { dst[0] = (((dst[0])+cm[(((src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3])) + 16)>>5]+1)>>1); dst[1] = (((dst[1])+cm[(((src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4])) + 16)>>5]+1)>>1); dst[2] = (((dst[2])+cm[(((src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5])) + 16)>>5]+1)>>1); dst[3] = (((dst[3])+cm[(((src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6])) + 16)>>5]+1)>>1); dst+=dstStride; src+=srcStride; }}static void avg_h264_qpel4_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ const int w=4; uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<w; i++) { const int srcB= src[-2*srcStride]; const int srcA= src[-1*srcStride]; const int src0= src[0 *srcStride]; const int src1= src[1 *srcStride]; const int src2= src[2 *srcStride]; const int src3= src[3 *srcStride]; const int src4= src[4 *srcStride]; const int src5= src[5 *srcStride]; const int src6= src[6 *srcStride]; dst[0*dstStride] = (((dst[0*dstStride])+cm[(((src0+src1)*20 - (srcA+src2)*5 + (srcB+src3)) + 16)>>5]+1)>>1); dst[1*dstStride] = (((dst[1*dstStride])+cm[(((src1+src2)*20 - (src0+src3)*5 + (srcA+src4)) + 16)>>5]+1)>>1); dst[2*dstStride] = (((dst[2*dstStride])+cm[(((src2+src3)*20 - (src1+src4)*5 + (src0+src5)) + 16)>>5]+1)>>1); dst[3*dstStride] = (((dst[3*dstStride])+cm[(((src3+src4)*20 - (src2+src5)*5 + (src1+src6)) + 16)>>5]+1)>>1); dst++; src++; }}static void avg_h264_qpel4_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){ const int h=4; const int w=4; uint8_t *cm = ff_cropTbl + 1024; int i; src -= 2*srcStride; for(i=0; i<h+5; i++) { tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]); tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]); tmp[2]= (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5]); tmp[3]= (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6]); tmp+=tmpStride; src+=srcStride; } tmp -= tmpStride*(h+5-2); for(i=0; i<w; i++) { const int tmpB= tmp[-2*tmpStride]; const int tmpA= tmp[-1*tmpStride]; const int tmp0= tmp[0 *tmpStride]; const int tmp1= tmp[1 *tmpStride]; const int tmp2= tmp[2 *tmpStride]; const int tmp3= tmp[3 *tmpStride]; const int tmp4= tmp[4 *tmpStride]; const int tmp5= tmp[5 *tmpStride]; const int tmp6= tmp[6 *tmpStride]; dst[0*dstStride] = (((dst[0*dstStride])+cm[(((tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3)) + 512)>>10]+1)>>1); dst[1*dstStride] = (((dst[1*dstStride])+cm[(((tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4)) + 512)>>10]+1)>>1); dst[2*dstStride] = (((dst[2*dstStride])+cm[(((tmp2+tmp3)*20 - (tmp1+tmp4)*5 + (tmp0+tmp5)) + 512)>>10]+1)>>1); dst[3*dstStride] = (((dst[3*dstStride])+cm[(((tmp3+tmp4)*20 - (tmp2+tmp5)*5 + (tmp1+tmp6)) + 512)>>10]+1)>>1); dst++; tmp++; }}static void avg_h264_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ const int h=8; uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<h; i++) { dst[0] = (((dst[0])+cm[(((src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3 ])) + 16)>>5]+1)>>1); dst[1] = (((dst[1])+cm[(((src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4 ])) + 16)>>5]+1)>>1); dst[2] = (((dst[2])+cm[(((src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5 ])) + 16)>>5]+1)>>1); dst[3] = (((dst[3])+cm[(((src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6 ])) + 16)>>5]+1)>>1); dst[4] = (((dst[4])+cm[(((src[4]+src[5])*20 - (src[3 ]+src[6])*5 + (src[2 ]+src[7 ])) + 16)>>5]+1)>>1); dst[5] = (((dst[5])+cm[(((src[5]+src[6])*20 - (src[4 ]+src[7])*5 + (src[3 ]+src[8 ])) + 16)>>5]+1)>>1); dst[6] = (((dst[6])+cm[(((src[6]+src[7])*20 - (src[5 ]+src[8])*5 + (src[4 ]+src[9 ])) + 16)>>5]+1)>>1); dst[7] = (((dst[7])+cm[(((src[7]+src[8])*20 - (src[6 ]+src[9])*5 + (src[5 ]+src[10])) + 16)>>5]+1)>>1); dst+=dstStride; src+=srcStride; }}static void avg_h264_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ const int w=8; uint8_t *cm = ff_cropTbl + 1024; int i; for(i=0; i<w; i++) { const int srcB= src[-2*srcStride]; const int srcA= src[-1*srcStride]; const int src0= src[0 *srcStride]; const int src1= src[1 *srcStride]; const int src2= src[2 *srcStride]; const int src3= src[3 *srcStride]; const int src4= src[4 *srcStride]; const int src5= src[5 *srcStride]; const int src6= src[6 *srcStride]; const int src7= src[7 *srcStride]; const int src8= src[8 *srcStride]; const int src9= src[9 *srcStride]; const int src10=src[10*srcStride]; dst[0*dstStride] = (((dst[0*dstStride])+cm[(((src0+src1)*20 - (srcA+src2)*5 + (srcB+src3)) + 16)>>5]+1)>>1); dst[1*dstStride] = (((dst[1*dstStride])+cm[(((src1+src2)*20 - (src0+src3)*5 + (srcA+src4)) + 16)>>5]+1)>>1); dst[2*dstStride] = (((dst[2*dstStride])+cm[(((src2+src3)*20 - (src1+src4)*5 + (src0+src5)) + 16)>>5]+1)>>1); dst[3*dstStride] = (((dst[3*dstStride])+cm[(((src3+src4)*20 - (src2+src5)*5 + (src1+src6)) + 16)>>5]+1)>>1); dst[4*dstStride] = (((dst[4*dstStride])+cm[(((src4+src5)*20 - (src3+src6)*5 + (src2+src7)) + 16)>>5]+1)>>1); dst[5*dstStride] = (((dst[5*dstStride])+cm[(((src5+src6)*20 - (src4+src7)*5 + (src3+src8)) + 16)>>5]+1)>>1); dst[6*dstStride] = (((dst[6*dstStride])+cm[(((src6+src7)*20 - (src5+src8)*5 + (src4+src9)) + 16)>>5]+1)>>1); dst[7*dstStride] = (((dst[7*dstStride])+cm[(((src7+src8)*20 - (src6+src9)*5 + (src5+src10)) + 16)>>5]+1)>>1); dst++; src++; }}static void avg_h264_qpel8_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){ const int h=8; const int w=8; uint8_t *cm = ff_cropTbl + 1024; int i; src -= 2*srcStride; for(i=0; i<h+5; i++) { tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3 ]); tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4 ]); tmp[2]= (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5 ]); tmp[3]= (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6 ]); tmp[4]= (src[4]+src[5])*20 - (src[3 ]+src[6])*5 + (src[2 ]+src[7 ]); tmp[5]= (src[5]+src[6])*20 - (src[4 ]+src[7])*5 + (src[3 ]+src[8 ]); tmp[6]= (src[6]+src[7])*20 - (src[5 ]+src[8])*5 + (src[4 ]+src[9 ]); tmp[7]= (src[7]+src[8])*20 - (src[6 ]+src[9])*5 + (src[5 ]+src[10]); tmp+=tmpStride; src+=srcStride; } tmp -= tmpStride*(h+5-2); for(i=0; i<w; i++) { const int tmpB= tmp[-2*tmpStride]; const int tmpA= tmp[-1*tmpStride]; const int tmp0= tmp[0 *tmpStride]; const int tmp1= tmp[1 *tmpStride]; const int tmp2= tmp[2 *tmpStride]; const int tmp3= tmp[3 *tmpStride]; const int tmp4= tmp[4 *tmpStride]; const int tmp5= tmp[5 *tmpStride]; const int tmp6= tmp[6 *tmpStride]; const int tmp7= tmp[7 *tmpStride]; const int tmp8= tmp[8 *tmpStride]; const int tmp9= tmp[9 *tmpStride]; const int tmp10=tmp[10*tmpStride]; dst[0*dstStride] = (((dst[0*dstStride])+cm[(((tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3)) + 512)>>10]+1)>>1); dst[1*dstStride] = (((dst[1*dstStride])+cm[(((tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4)) + 512)>>10]+1)>>1); dst[2*dstStride] = (((dst[2*dstStride])+cm[(((tmp2+tmp3)*20 - (tmp1+tmp4)*5 + (tmp0+tmp5)) + 512)>>10]+1)>>1); dst[3*dstStride] = (((dst[3*dstStride])+cm[(((tmp3+tmp4)*20 - (tmp2+tmp5)*5 + (tmp1+tmp6)) + 512)>>10]+1)>>1); dst[4*dstStride] = (((dst[4*dstStride])+cm[(((tmp4+tmp5)*20 - (tmp3+tmp6)*5 + (tmp2+tmp7)) + 512)>>10]+1)>>1); dst[5*dstStride] = (((dst[5*dstStride])+cm[(((tmp5+tmp6)*20 - (tmp4+tmp7)*5 + (tmp3+tmp8)) + 512)>>10]+1)>>1); dst[6*dstStride] = (((dst[6*dstStride])+cm[(((tmp6+tmp7)*20 - (tmp5+tmp8)*5 + (tmp4+tmp9)) + 512)>>10]+1)>>1); dst[7*dstStride] = (((dst[7*dstStride])+cm[(((tmp7+tmp8)*20 - (tmp6+tmp9)*5 + (tmp5+tmp10)) + 512)>>10]+1)>>1); dst++; tmp++; }}static void avg_h264_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ avg_h264_qpel8_v_lowpass(dst , src , dstStride, srcStride); avg_h264_qpel8_v_lowpass(dst+8, src+8, dstStride, srcStride); src += 8*srcStride; dst += 8*dstStride; avg_h264_qpel8_v_lowpass(dst , src , dstStride, srcStride); avg_h264_qpel8_v_lowpass(dst+8, src+8, dstStride, srcStride);}static void avg_h264_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){ avg_h264_qpel8_h_lowpass(dst , src , dstStride, srcStride); avg_h264_qpel8_h_lowpass(dst+8, src+8, dstStride, srcStride); src += 8*srcStride; dst += 8*dstStride; avg_h264_qpel8_h_lowpass(dst , src , dstStride, srcStride); avg_h264_qpel8_h_lowpass(dst+8, src+8, dstStride, srcStride);}static void avg_h264_qpel16_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){ avg_h264_qpel8_hv_lowpass(dst , tmp , src , dstStride, tmpStride, srcStride); avg_h264_qpel8_hv_lowpass(dst+8, tmp+8, src+8, dstStride, tmpStride, srcStride); src += 8*srcStride; dst += 8*dstStride; avg_h264_qpel8_hv_lowpass(dst , tmp , src , dstStride, tmpStride, srcStride); avg_h264_qpel8_hv_lowpass(dst+8, tmp+8, src+8, dstStride, tmpStride, srcStride);}
>static void put_h264_qpel2_mc00_c (uint8_t *dst, uint8_t *src, int stride){ put_pixels2_c(dst, src, stride, 2);}static void put_h264_qpel2_mc10_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[2*2]; put_h264_qpel2_h_lowpass(half, src, 2, stride); put_pixels2_l2(dst, src, half, stride, stride, 2, 2);}static void put_h264_qpel2_mc20_c(uint8_t *dst, uint8_t *src, int stride){ put_h264_qpel2_h_lowpass(dst, src, stride, stride);}static void put_h264_qpel2_mc30_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[2*2]; put_h264_qpel2_h_lowpass(half, src, 2, stride); put_pixels2_l2(dst, src+1, half, stride, stride, 2, 2);}static void put_h264_qpel2_mc01_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[2*(2 +5)]; uint8_t * const full_mid= full + 2*2; uint8_t half[2*2]; copy_block2 (full, src - stride*2, 2, stride, 2 + 5); put_h264_qpel2_v_lowpass(half, full_mid, 2, 2); put_pixels2_l2(dst, full_mid, half, stride, 2, 2, 2);}static void put_h264_qpel2_mc02_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[2*(2 +5)]; uint8_t * const full_mid= full + 2*2; copy_block2 (full, src - stride*2, 2, stride, 2 + 5); put_h264_qpel2_v_lowpass(dst, full_mid, stride, 2);}static void put_h264_qpel2_mc03_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[2*(2 +5)]; uint8_t * const full_mid= full + 2*2; uint8_t half[2*2]; copy_block2 (full, src - stride*2, 2, stride, 2 + 5); put_h264_qpel2_v_lowpass(half, full_mid, 2, 2); put_pixels2_l2(dst, full_mid+2, half, stride, 2, 2, 2);}static void put_h264_qpel2_mc11_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[2*(2 +5)]; uint8_t * const full_mid= full + 2*2; uint8_t halfH[2*2]; uint8_t halfV[2*2]; put_h264_qpel2_h_lowpass(halfH, src, 2, stride); copy_block2 (full, src - stride*2, 2, stride, 2 + 5); put_h264_qpel2_v_lowpass(halfV, full_mid, 2, 2); put_pixels2_l2(dst, halfH, halfV, stride, 2, 2, 2);}static void put_h264_qpel2_mc31_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[2*(2 +5)]; uint8_t * const full_mid= full + 2*2; uint8_t halfH[2*2]; uint8_t halfV[2*2]; put_h264_qpel2_h_lowpass(halfH, src, 2, stride); copy_block2 (full, src - stride*2 + 1, 2, stride, 2 + 5); put_h264_qpel2_v_lowpass(halfV, full_mid, 2, 2); put_pixels2_l2(dst, halfH, halfV, stride, 2, 2, 2);}static void put_h264_qpel2_mc13_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[2*(2 +5)]; uint8_t * const full_mid= full + 2*2; uint8_t halfH[2*2]; uint8_t halfV[2*2]; put_h264_qpel2_h_lowpass(halfH, src + stride, 2, stride); copy_block2 (full, src - stride*2, 2, stride, 2 + 5); put_h264_qpel2_v_lowpass(halfV, full_mid, 2, 2); put_pixels2_l2(dst, halfH, halfV, stride, 2, 2, 2);}static void put_h264_qpel2_mc33_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[2*(2 +5)]; uint8_t * const full_mid= full + 2*2; uint8_t halfH[2*2]; uint8_t halfV[2*2]; put_h264_qpel2_h_lowpass(halfH, src + stride, 2, stride); copy_block2 (full, src - stride*2 + 1, 2, stride, 2 + 5); put_h264_qpel2_v_lowpass(halfV, full_mid, 2, 2); put_pixels2_l2(dst, halfH, halfV, stride, 2, 2, 2);}static void put_h264_qpel2_mc22_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[2*(2 +5)]; put_h264_qpel2_hv_lowpass(dst, tmp, src, stride, 2, stride);}static void put_h264_qpel2_mc21_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[2*(2 +5)]; uint8_t halfH[2*2]; uint8_t halfHV[2*2]; put_h264_qpel2_h_lowpass(halfH, src, 2, stride); put_h264_qpel2_hv_lowpass(halfHV, tmp, src, 2, 2, stride); put_pixels2_l2(dst, halfH, halfHV, stride, 2, 2, 2);}static void put_h264_qpel2_mc23_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[2*(2 +5)]; uint8_t halfH[2*2]; uint8_t halfHV[2*2]; put_h264_qpel2_h_lowpass(halfH, src + stride, 2, stride); put_h264_qpel2_hv_lowpass(halfHV, tmp, src, 2, 2, stride); put_pixels2_l2(dst, halfH, halfHV, stride, 2, 2, 2);}static void put_h264_qpel2_mc12_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[2*(2 +5)]; uint8_t * const full_mid= full + 2*2; int16_t tmp[2*(2 +5)]; uint8_t halfV[2*2]; uint8_t halfHV[2*2]; copy_block2 (full, src - stride*2, 2, stride, 2 + 5); put_h264_qpel2_v_lowpass(halfV, full_mid, 2, 2); put_h264_qpel2_hv_lowpass(halfHV, tmp, src, 2, 2, stride); put_pixels2_l2(dst, halfV, halfHV, stride, 2, 2, 2);}static void put_h264_qpel2_mc32_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[2*(2 +5)]; uint8_t * const full_mid= full + 2*2; int16_t tmp[2*(2 +5)]; uint8_t halfV[2*2]; uint8_t halfHV[2*2]; copy_block2 (full, src - stride*2 + 1, 2, stride, 2 + 5); put_h264_qpel2_v_lowpass(halfV, full_mid, 2, 2); put_h264_qpel2_hv_lowpass(halfHV, tmp, src, 2, 2, stride); put_pixels2_l2(dst, halfV, halfHV, stride, 2, 2, 2);}
>static void put_h264_qpel4_mc00_c (uint8_t *dst, uint8_t *src, int stride){ put_pixels4_c(dst, src, stride, 4);}static void put_h264_qpel4_mc10_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[4*4]; put_h264_qpel4_h_lowpass(half, src, 4, stride); put_pixels4_l2(dst, src, half, stride, stride, 4, 4);}static void put_h264_qpel4_mc20_c(uint8_t *dst, uint8_t *src, int stride){ put_h264_qpel4_h_lowpass(dst, src, stride, stride);}static void put_h264_qpel4_mc30_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[4*4]; put_h264_qpel4_h_lowpass(half, src, 4, stride); put_pixels4_l2(dst, src+1, half, stride, stride, 4, 4);}static void put_h264_qpel4_mc01_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[4*(4 +5)]; uint8_t * const full_mid= full + 4*2; uint8_t half[4*4]; copy_block4 (full, src - stride*2, 4, stride, 4 + 5); put_h264_qpel4_v_lowpass(half, full_mid, 4, 4); put_pixels4_l2(dst, full_mid, half, stride, 4, 4, 4);}static void put_h264_qpel4_mc02_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[4*(4 +5)]; uint8_t * const full_mid= full + 4*2; copy_block4 (full, src - stride*2, 4, stride, 4 + 5); put_h264_qpel4_v_lowpass(dst, full_mid, stride, 4);}static void put_h264_qpel4_mc03_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[4*(4 +5)]; uint8_t * const full_mid= full + 4*2; uint8_t half[4*4]; copy_block4 (full, src - stride*2, 4, stride, 4 + 5); put_h264_qpel4_v_lowpass(half, full_mid, 4, 4); put_pixels4_l2(dst, full_mid+4, half, stride, 4, 4, 4);}static void put_h264_qpel4_mc11_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[4*(4 +5)]; uint8_t * const full_mid= full + 4*2; uint8_t halfH[4*4]; uint8_t halfV[4*4]; put_h264_qpel4_h_lowpass(halfH, src, 4, stride); copy_block4 (full, src - stride*2, 4, stride, 4 + 5); put_h264_qpel4_v_lowpass(halfV, full_mid, 4, 4); put_pixels4_l2(dst, halfH, halfV, stride, 4, 4, 4);}static void put_h264_qpel4_mc31_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[4*(4 +5)]; uint8_t * const full_mid= full + 4*2; uint8_t halfH[4*4]; uint8_t halfV[4*4]; put_h264_qpel4_h_lowpass(halfH, src, 4, stride); copy_block4 (full, src - stride*2 + 1, 4, stride, 4 + 5); put_h264_qpel4_v_lowpass(halfV, full_mid, 4, 4); put_pixels4_l2(dst, halfH, halfV, stride, 4, 4, 4);}static void put_h264_qpel4_mc13_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[4*(4 +5)]; uint8_t * const full_mid= full + 4*2; uint8_t halfH[4*4]; uint8_t halfV[4*4]; put_h264_qpel4_h_lowpass(halfH, src + stride, 4, stride); copy_block4 (full, src - stride*2, 4, stride, 4 + 5); put_h264_qpel4_v_lowpass(halfV, full_mid, 4, 4); put_pixels4_l2(dst, halfH, halfV, stride, 4, 4, 4);}static void put_h264_qpel4_mc33_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[4*(4 +5)]; uint8_t * const full_mid= full + 4*2; uint8_t halfH[4*4]; uint8_t halfV[4*4]; put_h264_qpel4_h_lowpass(halfH, src + stride, 4, stride); copy_block4 (full, src - stride*2 + 1, 4, stride, 4 + 5); put_h264_qpel4_v_lowpass(halfV, full_mid, 4, 4); put_pixels4_l2(dst, halfH, halfV, stride, 4, 4, 4);}static void put_h264_qpel4_mc22_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[4*(4 +5)]; put_h264_qpel4_hv_lowpass(dst, tmp, src, stride, 4, stride);}static void put_h264_qpel4_mc21_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[4*(4 +5)]; uint8_t halfH[4*4]; uint8_t halfHV[4*4]; put_h264_qpel4_h_lowpass(halfH, src, 4, stride); put_h264_qpel4_hv_lowpass(halfHV, tmp, src, 4, 4, stride); put_pixels4_l2(dst, halfH, halfHV, stride, 4, 4, 4);}static void put_h264_qpel4_mc23_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[4*(4 +5)]; uint8_t halfH[4*4]; uint8_t halfHV[4*4]; put_h264_qpel4_h_lowpass(halfH, src + stride, 4, stride); put_h264_qpel4_hv_lowpass(halfHV, tmp, src, 4, 4, stride); put_pixels4_l2(dst, halfH, halfHV, stride, 4, 4, 4);}static void put_h264_qpel4_mc12_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[4*(4 +5)]; uint8_t * const full_mid= full + 4*2; int16_t tmp[4*(4 +5)]; uint8_t halfV[4*4]; uint8_t halfHV[4*4]; copy_block4 (full, src - stride*2, 4, stride, 4 + 5); put_h264_qpel4_v_lowpass(halfV, full_mid, 4, 4); put_h264_qpel4_hv_lowpass(halfHV, tmp, src, 4, 4, stride); put_pixels4_l2(dst, halfV, halfHV, stride, 4, 4, 4);}static void put_h264_qpel4_mc32_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[4*(4 +5)]; uint8_t * const full_mid= full + 4*2; int16_t tmp[4*(4 +5)]; uint8_t halfV[4*4]; uint8_t halfHV[4*4]; copy_block4 (full, src - stride*2 + 1, 4, stride, 4 + 5); put_h264_qpel4_v_lowpass(halfV, full_mid, 4, 4); put_h264_qpel4_hv_lowpass(halfHV, tmp, src, 4, 4, stride); put_pixels4_l2(dst, halfV, halfHV, stride, 4, 4, 4);}
>static void put_h264_qpel8_mc00_c (uint8_t *dst, uint8_t *src, int stride){ put_pixels8_c(dst, src, stride, 8);}static void put_h264_qpel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[8*8]; put_h264_qpel8_h_lowpass(half, src, 8, stride); put_pixels8_l2(dst, src, half, stride, stride, 8, 8);}static void put_h264_qpel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){ put_h264_qpel8_h_lowpass(dst, src, stride, stride);}static void put_h264_qpel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[8*8]; put_h264_qpel8_h_lowpass(half, src, 8, stride); put_pixels8_l2(dst, src+1, half, stride, stride, 8, 8);}static void put_h264_qpel8_mc01_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[8*(8 +5)]; uint8_t * const full_mid= full + 8*2; uint8_t half[8*8]; copy_block8 (full, src - stride*2, 8, stride, 8 + 5); put_h264_qpel8_v_lowpass(half, full_mid, 8, 8); put_pixels8_l2(dst, full_mid, half, stride, 8, 8, 8);}static void put_h264_qpel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[8*(8 +5)]; uint8_t * const full_mid= full + 8*2; copy_block8 (full, src - stride*2, 8, stride, 8 + 5); put_h264_qpel8_v_lowpass(dst, full_mid, stride, 8);}static void put_h264_qpel8_mc03_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[8*(8 +5)]; uint8_t * const full_mid= full + 8*2; uint8_t half[8*8]; copy_block8 (full, src - stride*2, 8, stride, 8 + 5); put_h264_qpel8_v_lowpass(half, full_mid, 8, 8); put_pixels8_l2(dst, full_mid+8, half, stride, 8, 8, 8);}static void put_h264_qpel8_mc11_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[8*(8 +5)]; uint8_t * const full_mid= full + 8*2; uint8_t halfH[8*8]; uint8_t halfV[8*8]; put_h264_qpel8_h_lowpass(halfH, src, 8, stride); copy_block8 (full, src - stride*2, 8, stride, 8 + 5); put_h264_qpel8_v_lowpass(halfV, full_mid, 8, 8); put_pixels8_l2(dst, halfH, halfV, stride, 8, 8, 8);}static void put_h264_qpel8_mc31_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[8*(8 +5)]; uint8_t * const full_mid= full + 8*2; uint8_t halfH[8*8]; uint8_t halfV[8*8]; put_h264_qpel8_h_lowpass(halfH, src, 8, stride); copy_block8 (full, src - stride*2 + 1, 8, stride, 8 + 5); put_h264_qpel8_v_lowpass(halfV, full_mid, 8, 8); put_pixels8_l2(dst, halfH, halfV, stride, 8, 8, 8);}static void put_h264_qpel8_mc13_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[8*(8 +5)]; uint8_t * const full_mid= full + 8*2; uint8_t halfH[8*8]; uint8_t halfV[8*8]; put_h264_qpel8_h_lowpass(halfH, src + stride, 8, stride); copy_block8 (full, src - stride*2, 8, stride, 8 + 5); put_h264_qpel8_v_lowpass(halfV, full_mid, 8, 8); put_pixels8_l2(dst, halfH, halfV, stride, 8, 8, 8);}static void put_h264_qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[8*(8 +5)]; uint8_t * const full_mid= full + 8*2; uint8_t halfH[8*8]; uint8_t halfV[8*8]; put_h264_qpel8_h_lowpass(halfH, src + stride, 8, stride); copy_block8 (full, src - stride*2 + 1, 8, stride, 8 + 5); put_h264_qpel8_v_lowpass(halfV, full_mid, 8, 8); put_pixels8_l2(dst, halfH, halfV, stride, 8, 8, 8);}static void put_h264_qpel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[8*(8 +5)]; put_h264_qpel8_hv_lowpass(dst, tmp, src, stride, 8, stride);}static void put_h264_qpel8_mc21_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[8*(8 +5)]; uint8_t halfH[8*8]; uint8_t halfHV[8*8]; put_h264_qpel8_h_lowpass(halfH, src, 8, stride); put_h264_qpel8_hv_lowpass(halfHV, tmp, src, 8, 8, stride); put_pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);}static void put_h264_qpel8_mc23_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[8*(8 +5)]; uint8_t halfH[8*8]; uint8_t halfHV[8*8]; put_h264_qpel8_h_lowpass(halfH, src + stride, 8, stride); put_h264_qpel8_hv_lowpass(halfHV, tmp, src, 8, 8, stride); put_pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);}static void put_h264_qpel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[8*(8 +5)]; uint8_t * const full_mid= full + 8*2; int16_t tmp[8*(8 +5)]; uint8_t halfV[8*8]; uint8_t halfHV[8*8]; copy_block8 (full, src - stride*2, 8, stride, 8 + 5); put_h264_qpel8_v_lowpass(halfV, full_mid, 8, 8); put_h264_qpel8_hv_lowpass(halfHV, tmp, src, 8, 8, stride); put_pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);}static void put_h264_qpel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[8*(8 +5)]; uint8_t * const full_mid= full + 8*2; int16_t tmp[8*(8 +5)]; uint8_t halfV[8*8]; uint8_t halfHV[8*8]; copy_block8 (full, src - stride*2 + 1, 8, stride, 8 + 5); put_h264_qpel8_v_lowpass(halfV, full_mid, 8, 8); put_h264_qpel8_hv_lowpass(halfHV, tmp, src, 8, 8, stride); put_pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);}
>static void put_h264_qpel16_mc00_c (uint8_t *dst, uint8_t *src, int stride){ put_pixels16_c(dst, src, stride, 16);}static void put_h264_qpel16_mc10_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[16*16]; put_h264_qpel16_h_lowpass(half, src, 16, stride); put_pixels16_l2(dst, src, half, stride, stride, 16, 16);}static void put_h264_qpel16_mc20_c(uint8_t *dst, uint8_t *src, int stride){ put_h264_qpel16_h_lowpass(dst, src, stride, stride);}static void put_h264_qpel16_mc30_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[16*16]; put_h264_qpel16_h_lowpass(half, src, 16, stride); put_pixels16_l2(dst, src+1, half, stride, stride, 16, 16);}static void put_h264_qpel16_mc01_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*(16 +5)]; uint8_t * const full_mid= full + 16*2; uint8_t half[16*16]; copy_block16 (full, src - stride*2, 16, stride, 16 + 5); put_h264_qpel16_v_lowpass(half, full_mid, 16, 16); put_pixels16_l2(dst, full_mid, half, stride, 16, 16, 16);}static void put_h264_qpel16_mc02_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*(16 +5)]; uint8_t * const full_mid= full + 16*2; copy_block16 (full, src - stride*2, 16, stride, 16 + 5); put_h264_qpel16_v_lowpass(dst, full_mid, stride, 16);}static void put_h264_qpel16_mc03_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*(16 +5)]; uint8_t * const full_mid= full + 16*2; uint8_t half[16*16]; copy_block16 (full, src - stride*2, 16, stride, 16 + 5); put_h264_qpel16_v_lowpass(half, full_mid, 16, 16); put_pixels16_l2(dst, full_mid+16, half, stride, 16, 16, 16);}static void put_h264_qpel16_mc11_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*(16 +5)]; uint8_t * const full_mid= full + 16*2; uint8_t halfH[16*16]; uint8_t halfV[16*16]; put_h264_qpel16_h_lowpass(halfH, src, 16, stride); copy_block16 (full, src - stride*2, 16, stride, 16 + 5); put_h264_qpel16_v_lowpass(halfV, full_mid, 16, 16); put_pixels16_l2(dst, halfH, halfV, stride, 16, 16, 16);}static void put_h264_qpel16_mc31_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*(16 +5)]; uint8_t * const full_mid= full + 16*2; uint8_t halfH[16*16]; uint8_t halfV[16*16]; put_h264_qpel16_h_lowpass(halfH, src, 16, stride); copy_block16 (full, src - stride*2 + 1, 16, stride, 16 + 5); put_h264_qpel16_v_lowpass(halfV, full_mid, 16, 16); put_pixels16_l2(dst, halfH, halfV, stride, 16, 16, 16);}static void put_h264_qpel16_mc13_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*(16 +5)]; uint8_t * const full_mid= full + 16*2; uint8_t halfH[16*16]; uint8_t halfV[16*16]; put_h264_qpel16_h_lowpass(halfH, src + stride, 16, stride); copy_block16 (full, src - stride*2, 16, stride, 16 + 5); put_h264_qpel16_v_lowpass(halfV, full_mid, 16, 16); put_pixels16_l2(dst, halfH, halfV, stride, 16, 16, 16);}static void put_h264_qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*(16 +5)]; uint8_t * const full_mid= full + 16*2; uint8_t halfH[16*16]; uint8_t halfV[16*16]; put_h264_qpel16_h_lowpass(halfH, src + stride, 16, stride); copy_block16 (full, src - stride*2 + 1, 16, stride, 16 + 5); put_h264_qpel16_v_lowpass(halfV, full_mid, 16, 16); put_pixels16_l2(dst, halfH, halfV, stride, 16, 16, 16);}static void put_h264_qpel16_mc22_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[16*(16 +5)]; put_h264_qpel16_hv_lowpass(dst, tmp, src, stride, 16, stride);}static void put_h264_qpel16_mc21_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[16*(16 +5)]; uint8_t halfH[16*16]; uint8_t halfHV[16*16]; put_h264_qpel16_h_lowpass(halfH, src, 16, stride); put_h264_qpel16_hv_lowpass(halfHV, tmp, src, 16, 16, stride); put_pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);}static void put_h264_qpel16_mc23_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[16*(16 +5)]; uint8_t halfH[16*16]; uint8_t halfHV[16*16]; put_h264_qpel16_h_lowpass(halfH, src + stride, 16, stride); put_h264_qpel16_hv_lowpass(halfHV, tmp, src, 16, 16, stride); put_pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);}static void put_h264_qpel16_mc12_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*(16 +5)]; uint8_t * const full_mid= full + 16*2; int16_t tmp[16*(16 +5)]; uint8_t halfV[16*16]; uint8_t halfHV[16*16]; copy_block16 (full, src - stride*2, 16, stride, 16 + 5); put_h264_qpel16_v_lowpass(halfV, full_mid, 16, 16); put_h264_qpel16_hv_lowpass(halfHV, tmp, src, 16, 16, stride); put_pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);}static void put_h264_qpel16_mc32_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*(16 +5)]; uint8_t * const full_mid= full + 16*2; int16_t tmp[16*(16 +5)]; uint8_t halfV[16*16]; uint8_t halfHV[16*16]; copy_block16 (full, src - stride*2 + 1, 16, stride, 16 + 5); put_h264_qpel16_v_lowpass(halfV, full_mid, 16, 16); put_h264_qpel16_hv_lowpass(halfHV, tmp, src, 16, 16, stride); put_pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);}
>static void avg_h264_qpel4_mc00_c (uint8_t *dst, uint8_t *src, int stride){ avg_pixels4_c(dst, src, stride, 4);}static void avg_h264_qpel4_mc10_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[4*4]; put_h264_qpel4_h_lowpass(half, src, 4, stride); avg_pixels4_l2(dst, src, half, stride, stride, 4, 4);}static void avg_h264_qpel4_mc20_c(uint8_t *dst, uint8_t *src, int stride){ avg_h264_qpel4_h_lowpass(dst, src, stride, stride);}static void avg_h264_qpel4_mc30_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[4*4]; put_h264_qpel4_h_lowpass(half, src, 4, stride); avg_pixels4_l2(dst, src+1, half, stride, stride, 4, 4);}static void avg_h264_qpel4_mc01_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[4*(4 +5)]; uint8_t * const full_mid= full + 4*2; uint8_t half[4*4]; copy_block4 (full, src - stride*2, 4, stride, 4 + 5); put_h264_qpel4_v_lowpass(half, full_mid, 4, 4); avg_pixels4_l2(dst, full_mid, half, stride, 4, 4, 4);}static void avg_h264_qpel4_mc02_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[4*(4 +5)]; uint8_t * const full_mid= full + 4*2; copy_block4 (full, src - stride*2, 4, stride, 4 + 5); avg_h264_qpel4_v_lowpass(dst, full_mid, stride, 4);}static void avg_h264_qpel4_mc03_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[4*(4 +5)]; uint8_t * const full_mid= full + 4*2; uint8_t half[4*4]; copy_block4 (full, src - stride*2, 4, stride, 4 + 5); put_h264_qpel4_v_lowpass(half, full_mid, 4, 4); avg_pixels4_l2(dst, full_mid+4, half, stride, 4, 4, 4);}static void avg_h264_qpel4_mc11_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[4*(4 +5)]; uint8_t * const full_mid= full + 4*2; uint8_t halfH[4*4]; uint8_t halfV[4*4]; put_h264_qpel4_h_lowpass(halfH, src, 4, stride); copy_block4 (full, src - stride*2, 4, stride, 4 + 5); put_h264_qpel4_v_lowpass(halfV, full_mid, 4, 4); avg_pixels4_l2(dst, halfH, halfV, stride, 4, 4, 4);}static void avg_h264_qpel4_mc31_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[4*(4 +5)]; uint8_t * const full_mid= full + 4*2; uint8_t halfH[4*4]; uint8_t halfV[4*4]; put_h264_qpel4_h_lowpass(halfH, src, 4, stride); copy_block4 (full, src - stride*2 + 1, 4, stride, 4 + 5); put_h264_qpel4_v_lowpass(halfV, full_mid, 4, 4); avg_pixels4_l2(dst, halfH, halfV, stride, 4, 4, 4);}static void avg_h264_qpel4_mc13_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[4*(4 +5)]; uint8_t * const full_mid= full + 4*2; uint8_t halfH[4*4]; uint8_t halfV[4*4]; put_h264_qpel4_h_lowpass(halfH, src + stride, 4, stride); copy_block4 (full, src - stride*2, 4, stride, 4 + 5); put_h264_qpel4_v_lowpass(halfV, full_mid, 4, 4); avg_pixels4_l2(dst, halfH, halfV, stride, 4, 4, 4);}static void avg_h264_qpel4_mc33_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[4*(4 +5)]; uint8_t * const full_mid= full + 4*2; uint8_t halfH[4*4]; uint8_t halfV[4*4]; put_h264_qpel4_h_lowpass(halfH, src + stride, 4, stride); copy_block4 (full, src - stride*2 + 1, 4, stride, 4 + 5); put_h264_qpel4_v_lowpass(halfV, full_mid, 4, 4); avg_pixels4_l2(dst, halfH, halfV, stride, 4, 4, 4);}static void avg_h264_qpel4_mc22_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[4*(4 +5)]; avg_h264_qpel4_hv_lowpass(dst, tmp, src, stride, 4, stride);}static void avg_h264_qpel4_mc21_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[4*(4 +5)]; uint8_t halfH[4*4]; uint8_t halfHV[4*4]; put_h264_qpel4_h_lowpass(halfH, src, 4, stride); put_h264_qpel4_hv_lowpass(halfHV, tmp, src, 4, 4, stride); avg_pixels4_l2(dst, halfH, halfHV, stride, 4, 4, 4);}static void avg_h264_qpel4_mc23_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[4*(4 +5)]; uint8_t halfH[4*4]; uint8_t halfHV[4*4]; put_h264_qpel4_h_lowpass(halfH, src + stride, 4, stride); put_h264_qpel4_hv_lowpass(halfHV, tmp, src, 4, 4, stride); avg_pixels4_l2(dst, halfH, halfHV, stride, 4, 4, 4);}static void avg_h264_qpel4_mc12_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[4*(4 +5)]; uint8_t * const full_mid= full + 4*2; int16_t tmp[4*(4 +5)]; uint8_t halfV[4*4]; uint8_t halfHV[4*4]; copy_block4 (full, src - stride*2, 4, stride, 4 + 5); put_h264_qpel4_v_lowpass(halfV, full_mid, 4, 4); put_h264_qpel4_hv_lowpass(halfHV, tmp, src, 4, 4, stride); avg_pixels4_l2(dst, halfV, halfHV, stride, 4, 4, 4);}static void avg_h264_qpel4_mc32_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[4*(4 +5)]; uint8_t * const full_mid= full + 4*2; int16_t tmp[4*(4 +5)]; uint8_t halfV[4*4]; uint8_t halfHV[4*4]; copy_block4 (full, src - stride*2 + 1, 4, stride, 4 + 5); put_h264_qpel4_v_lowpass(halfV, full_mid, 4, 4); put_h264_qpel4_hv_lowpass(halfHV, tmp, src, 4, 4, stride); avg_pixels4_l2(dst, halfV, halfHV, stride, 4, 4, 4);}
>static void avg_h264_qpel8_mc00_c (uint8_t *dst, uint8_t *src, int stride){ avg_pixels8_c(dst, src, stride, 8);}static void avg_h264_qpel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[8*8]; put_h264_qpel8_h_lowpass(half, src, 8, stride); avg_pixels8_l2(dst, src, half, stride, stride, 8, 8);}static void avg_h264_qpel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){ avg_h264_qpel8_h_lowpass(dst, src, stride, stride);}static void avg_h264_qpel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[8*8]; put_h264_qpel8_h_lowpass(half, src, 8, stride); avg_pixels8_l2(dst, src+1, half, stride, stride, 8, 8);}static void avg_h264_qpel8_mc01_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[8*(8 +5)]; uint8_t * const full_mid= full + 8*2; uint8_t half[8*8]; copy_block8 (full, src - stride*2, 8, stride, 8 + 5); put_h264_qpel8_v_lowpass(half, full_mid, 8, 8); avg_pixels8_l2(dst, full_mid, half, stride, 8, 8, 8);}static void avg_h264_qpel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[8*(8 +5)]; uint8_t * const full_mid= full + 8*2; copy_block8 (full, src - stride*2, 8, stride, 8 + 5); avg_h264_qpel8_v_lowpass(dst, full_mid, stride, 8);}static void avg_h264_qpel8_mc03_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[8*(8 +5)]; uint8_t * const full_mid= full + 8*2; uint8_t half[8*8]; copy_block8 (full, src - stride*2, 8, stride, 8 + 5); put_h264_qpel8_v_lowpass(half, full_mid, 8, 8); avg_pixels8_l2(dst, full_mid+8, half, stride, 8, 8, 8);}static void avg_h264_qpel8_mc11_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[8*(8 +5)]; uint8_t * const full_mid= full + 8*2; uint8_t halfH[8*8]; uint8_t halfV[8*8]; put_h264_qpel8_h_lowpass(halfH, src, 8, stride); copy_block8 (full, src - stride*2, 8, stride, 8 + 5); put_h264_qpel8_v_lowpass(halfV, full_mid, 8, 8); avg_pixels8_l2(dst, halfH, halfV, stride, 8, 8, 8);}static void avg_h264_qpel8_mc31_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[8*(8 +5)]; uint8_t * const full_mid= full + 8*2; uint8_t halfH[8*8]; uint8_t halfV[8*8]; put_h264_qpel8_h_lowpass(halfH, src, 8, stride); copy_block8 (full, src - stride*2 + 1, 8, stride, 8 + 5); put_h264_qpel8_v_lowpass(halfV, full_mid, 8, 8); avg_pixels8_l2(dst, halfH, halfV, stride, 8, 8, 8);}static void avg_h264_qpel8_mc13_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[8*(8 +5)]; uint8_t * const full_mid= full + 8*2; uint8_t halfH[8*8]; uint8_t halfV[8*8]; put_h264_qpel8_h_lowpass(halfH, src + stride, 8, stride); copy_block8 (full, src - stride*2, 8, stride, 8 + 5); put_h264_qpel8_v_lowpass(halfV, full_mid, 8, 8); avg_pixels8_l2(dst, halfH, halfV, stride, 8, 8, 8);}static void avg_h264_qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[8*(8 +5)]; uint8_t * const full_mid= full + 8*2; uint8_t halfH[8*8]; uint8_t halfV[8*8]; put_h264_qpel8_h_lowpass(halfH, src + stride, 8, stride); copy_block8 (full, src - stride*2 + 1, 8, stride, 8 + 5); put_h264_qpel8_v_lowpass(halfV, full_mid, 8, 8); avg_pixels8_l2(dst, halfH, halfV, stride, 8, 8, 8);}static void avg_h264_qpel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[8*(8 +5)]; avg_h264_qpel8_hv_lowpass(dst, tmp, src, stride, 8, stride);}static void avg_h264_qpel8_mc21_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[8*(8 +5)]; uint8_t halfH[8*8]; uint8_t halfHV[8*8]; put_h264_qpel8_h_lowpass(halfH, src, 8, stride); put_h264_qpel8_hv_lowpass(halfHV, tmp, src, 8, 8, stride); avg_pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);}static void avg_h264_qpel8_mc23_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[8*(8 +5)]; uint8_t halfH[8*8]; uint8_t halfHV[8*8]; put_h264_qpel8_h_lowpass(halfH, src + stride, 8, stride); put_h264_qpel8_hv_lowpass(halfHV, tmp, src, 8, 8, stride); avg_pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);}static void avg_h264_qpel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[8*(8 +5)]; uint8_t * const full_mid= full + 8*2; int16_t tmp[8*(8 +5)]; uint8_t halfV[8*8]; uint8_t halfHV[8*8]; copy_block8 (full, src - stride*2, 8, stride, 8 + 5); put_h264_qpel8_v_lowpass(halfV, full_mid, 8, 8); put_h264_qpel8_hv_lowpass(halfHV, tmp, src, 8, 8, stride); avg_pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);}static void avg_h264_qpel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[8*(8 +5)]; uint8_t * const full_mid= full + 8*2; int16_t tmp[8*(8 +5)]; uint8_t halfV[8*8]; uint8_t halfHV[8*8]; copy_block8 (full, src - stride*2 + 1, 8, stride, 8 + 5); put_h264_qpel8_v_lowpass(halfV, full_mid, 8, 8); put_h264_qpel8_hv_lowpass(halfHV, tmp, src, 8, 8, stride); avg_pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);}
>static void avg_h264_qpel16_mc00_c (uint8_t *dst, uint8_t *src, int stride){ avg_pixels16_c(dst, src, stride, 16);}static void avg_h264_qpel16_mc10_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[16*16]; put_h264_qpel16_h_lowpass(half, src, 16, stride); avg_pixels16_l2(dst, src, half, stride, stride, 16, 16);}static void avg_h264_qpel16_mc20_c(uint8_t *dst, uint8_t *src, int stride){ avg_h264_qpel16_h_lowpass(dst, src, stride, stride);}static void avg_h264_qpel16_mc30_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t half[16*16]; put_h264_qpel16_h_lowpass(half, src, 16, stride); avg_pixels16_l2(dst, src+1, half, stride, stride, 16, 16);}static void avg_h264_qpel16_mc01_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*(16 +5)]; uint8_t * const full_mid= full + 16*2; uint8_t half[16*16]; copy_block16 (full, src - stride*2, 16, stride, 16 + 5); put_h264_qpel16_v_lowpass(half, full_mid, 16, 16); avg_pixels16_l2(dst, full_mid, half, stride, 16, 16, 16);}static void avg_h264_qpel16_mc02_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*(16 +5)]; uint8_t * const full_mid= full + 16*2; copy_block16 (full, src - stride*2, 16, stride, 16 + 5); avg_h264_qpel16_v_lowpass(dst, full_mid, stride, 16);}static void avg_h264_qpel16_mc03_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*(16 +5)]; uint8_t * const full_mid= full + 16*2; uint8_t half[16*16]; copy_block16 (full, src - stride*2, 16, stride, 16 + 5); put_h264_qpel16_v_lowpass(half, full_mid, 16, 16); avg_pixels16_l2(dst, full_mid+16, half, stride, 16, 16, 16);}static void avg_h264_qpel16_mc11_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*(16 +5)]; uint8_t * const full_mid= full + 16*2; uint8_t halfH[16*16]; uint8_t halfV[16*16]; put_h264_qpel16_h_lowpass(halfH, src, 16, stride); copy_block16 (full, src - stride*2, 16, stride, 16 + 5); put_h264_qpel16_v_lowpass(halfV, full_mid, 16, 16); avg_pixels16_l2(dst, halfH, halfV, stride, 16, 16, 16);}static void avg_h264_qpel16_mc31_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*(16 +5)]; uint8_t * const full_mid= full + 16*2; uint8_t halfH[16*16]; uint8_t halfV[16*16]; put_h264_qpel16_h_lowpass(halfH, src, 16, stride); copy_block16 (full, src - stride*2 + 1, 16, stride, 16 + 5); put_h264_qpel16_v_lowpass(halfV, full_mid, 16, 16); avg_pixels16_l2(dst, halfH, halfV, stride, 16, 16, 16);}static void avg_h264_qpel16_mc13_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*(16 +5)]; uint8_t * const full_mid= full + 16*2; uint8_t halfH[16*16]; uint8_t halfV[16*16]; put_h264_qpel16_h_lowpass(halfH, src + stride, 16, stride); copy_block16 (full, src - stride*2, 16, stride, 16 + 5); put_h264_qpel16_v_lowpass(halfV, full_mid, 16, 16); avg_pixels16_l2(dst, halfH, halfV, stride, 16, 16, 16);}static void avg_h264_qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*(16 +5)]; uint8_t * const full_mid= full + 16*2; uint8_t halfH[16*16]; uint8_t halfV[16*16]; put_h264_qpel16_h_lowpass(halfH, src + stride, 16, stride); copy_block16 (full, src - stride*2 + 1, 16, stride, 16 + 5); put_h264_qpel16_v_lowpass(halfV, full_mid, 16, 16); avg_pixels16_l2(dst, halfH, halfV, stride, 16, 16, 16);}static void avg_h264_qpel16_mc22_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[16*(16 +5)]; avg_h264_qpel16_hv_lowpass(dst, tmp, src, stride, 16, stride);}static void avg_h264_qpel16_mc21_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[16*(16 +5)]; uint8_t halfH[16*16]; uint8_t halfHV[16*16]; put_h264_qpel16_h_lowpass(halfH, src, 16, stride); put_h264_qpel16_hv_lowpass(halfHV, tmp, src, 16, 16, stride); avg_pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);}static void avg_h264_qpel16_mc23_c(uint8_t *dst, uint8_t *src, int stride){ int16_t tmp[16*(16 +5)]; uint8_t halfH[16*16]; uint8_t halfHV[16*16]; put_h264_qpel16_h_lowpass(halfH, src + stride, 16, stride); put_h264_qpel16_hv_lowpass(halfHV, tmp, src, 16, 16, stride); avg_pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);}static void avg_h264_qpel16_mc12_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*(16 +5)]; uint8_t * const full_mid= full + 16*2; int16_t tmp[16*(16 +5)]; uint8_t halfV[16*16]; uint8_t halfHV[16*16]; copy_block16 (full, src - stride*2, 16, stride, 16 + 5); put_h264_qpel16_v_lowpass(halfV, full_mid, 16, 16); put_h264_qpel16_hv_lowpass(halfHV, tmp, src, 16, 16, stride); avg_pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);}static void avg_h264_qpel16_mc32_c(uint8_t *dst, uint8_t *src, int stride){ uint8_t full[16*(16 +5)]; uint8_t * const full_mid= full + 16*2; int16_t tmp[16*(16 +5)]; uint8_t halfV[16*16]; uint8_t halfHV[16*16]; copy_block16 (full, src - stride*2 + 1, 16, stride, 16 + 5); put_h264_qpel16_v_lowpass(halfV, full_mid, 16, 16); put_h264_qpel16_hv_lowpass(halfHV, tmp, src, 16, 16, stride); avg_pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);}
># 2500 "dsputil.c"
>static void weight_h264_pixels16x16_c(uint8_t *block, int stride, int log2_denom, int weight, int offset){ int y; offset <<= log2_denom; if(log2_denom) offset += 1<<(log2_denom-1); for(y=0; y<16; y++, block += stride){ block[0] = av_clip_uint8( (block[0]*weight + offset) >> log2_denom ); block[1] = av_clip_uint8( (block[1]*weight + offset) >> log2_denom ); if(16==2) continue; block[2] = av_clip_uint8( (block[2]*weight + offset) >> log2_denom ); block[3] = av_clip_uint8( (block[3]*weight + offset) >> log2_denom ); if(16==4) continue; block[4] = av_clip_uint8( (block[4]*weight + offset) >> log2_denom ); block[5] = av_clip_uint8( (block[5]*weight + offset) >> log2_denom ); block[6] = av_clip_uint8( (block[6]*weight + offset) >> log2_denom ); block[7] = av_clip_uint8( (block[7]*weight + offset) >> log2_denom ); if(16==8) continue; block[8] = av_clip_uint8( (block[8]*weight + offset) >> log2_denom ); block[9] = av_clip_uint8( (block[9]*weight + offset) >> log2_denom ); block[10] = av_clip_uint8( (block[10]*weight + offset) >> log2_denom ); block[11] = av_clip_uint8( (block[11]*weight + offset) >> log2_denom ); block[12] = av_clip_uint8( (block[12]*weight + offset) >> log2_denom ); block[13] = av_clip_uint8( (block[13]*weight + offset) >> log2_denom ); block[14] = av_clip_uint8( (block[14]*weight + offset) >> log2_denom ); block[15] = av_clip_uint8( (block[15]*weight + offset) >> log2_denom ); } } static void biweight_h264_pixels16x16_c(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offset){ int y; offset = ((offset + 1) | 1) << log2_denom; for(y=0; y<16; y++, dst += stride, src += stride){ dst[0] = av_clip_uint8( (src[0]*weights + dst[0]*weightd + offset) >> (log2_denom+1)); dst[1] = av_clip_uint8( (src[1]*weights + dst[1]*weightd + offset) >> (log2_denom+1)); if(16==2) continue; dst[2] = av_clip_uint8( (src[2]*weights + dst[2]*weightd + offset) >> (log2_denom+1)); dst[3] = av_clip_uint8( (src[3]*weights + dst[3]*weightd + offset) >> (log2_denom+1)); if(16==4) continue; dst[4] = av_clip_uint8( (src[4]*weights + dst[4]*weightd + offset) >> (log2_denom+1)); dst[5] = av_clip_uint8( (src[5]*weights + dst[5]*weightd + offset) >> (log2_denom+1)); dst[6] = av_clip_uint8( (src[6]*weights + dst[6]*weightd + offset) >> (log2_denom+1)); dst[7] = av_clip_uint8( (src[7]*weights + dst[7]*weightd + offset) >> (log2_denom+1)); if(16==8) continue; dst[8] = av_clip_uint8( (src[8]*weights + dst[8]*weightd + offset) >> (log2_denom+1)); dst[9] = av_clip_uint8( (src[9]*weights + dst[9]*weightd + offset) >> (log2_denom+1)); dst[10] = av_clip_uint8( (src[10]*weights + dst[10]*weightd + offset) >> (log2_denom+1)); dst[11] = av_clip_uint8( (src[11]*weights + dst[11]*weightd + offset) >> (log2_denom+1)); dst[12] = av_clip_uint8( (src[12]*weights + dst[12]*weightd + offset) >> (log2_denom+1)); dst[13] = av_clip_uint8( (src[13]*weights + dst[13]*weightd + offset) >> (log2_denom+1)); dst[14] = av_clip_uint8( (src[14]*weights + dst[14]*weightd + offset) >> (log2_denom+1)); dst[15] = av_clip_uint8( (src[15]*weights + dst[15]*weightd + offset) >> (log2_denom+1)); } }
>static void weight_h264_pixels16x8_c(uint8_t *block, int stride, int log2_denom, int weight, int offset){ int y; offset <<= log2_denom; if(log2_denom) offset += 1<<(log2_denom-1); for(y=0; y<8; y++, block += stride){ block[0] = av_clip_uint8( (block[0]*weight + offset) >> log2_denom ); block[1] = av_clip_uint8( (block[1]*weight + offset) >> log2_denom ); if(16==2) continue; block[2] = av_clip_uint8( (block[2]*weight + offset) >> log2_denom ); block[3] = av_clip_uint8( (block[3]*weight + offset) >> log2_denom ); if(16==4) continue; block[4] = av_clip_uint8( (block[4]*weight + offset) >> log2_denom ); block[5] = av_clip_uint8( (block[5]*weight + offset) >> log2_denom ); block[6] = av_clip_uint8( (block[6]*weight + offset) >> log2_denom ); block[7] = av_clip_uint8( (block[7]*weight + offset) >> log2_denom ); if(16==8) continue; block[8] = av_clip_uint8( (block[8]*weight + offset) >> log2_denom ); block[9] = av_clip_uint8( (block[9]*weight + offset) >> log2_denom ); block[10] = av_clip_uint8( (block[10]*weight + offset) >> log2_denom ); block[11] = av_clip_uint8( (block[11]*weight + offset) >> log2_denom ); block[12] = av_clip_uint8( (block[12]*weight + offset) >> log2_denom ); block[13] = av_clip_uint8( (block[13]*weight + offset) >> log2_denom ); block[14] = av_clip_uint8( (block[14]*weight + offset) >> log2_denom ); block[15] = av_clip_uint8( (block[15]*weight + offset) >> log2_denom ); } } static void biweight_h264_pixels16x8_c(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offset){ int y; offset = ((offset + 1) | 1) << log2_denom; for(y=0; y<8; y++, dst += stride, src += stride){ dst[0] = av_clip_uint8( (src[0]*weights + dst[0]*weightd + offset) >> (log2_denom+1)); dst[1] = av_clip_uint8( (src[1]*weights + dst[1]*weightd + offset) >> (log2_denom+1)); if(16==2) continue; dst[2] = av_clip_uint8( (src[2]*weights + dst[2]*weightd + offset) >> (log2_denom+1)); dst[3] = av_clip_uint8( (src[3]*weights + dst[3]*weightd + offset) >> (log2_denom+1)); if(16==4) continue; dst[4] = av_clip_uint8( (src[4]*weights + dst[4]*weightd + offset) >> (log2_denom+1)); dst[5] = av_clip_uint8( (src[5]*weights + dst[5]*weightd + offset) >> (log2_denom+1)); dst[6] = av_clip_uint8( (src[6]*weights + dst[6]*weightd + offset) >> (log2_denom+1)); dst[7] = av_clip_uint8( (src[7]*weights + dst[7]*weightd + offset) >> (log2_denom+1)); if(16==8) continue; dst[8] = av_clip_uint8( (src[8]*weights + dst[8]*weightd + offset) >> (log2_denom+1)); dst[9] = av_clip_uint8( (src[9]*weights + dst[9]*weightd + offset) >> (log2_denom+1)); dst[10] = av_clip_uint8( (src[10]*weights + dst[10]*weightd + offset) >> (log2_denom+1)); dst[11] = av_clip_uint8( (src[11]*weights + dst[11]*weightd + offset) >> (log2_denom+1)); dst[12] = av_clip_uint8( (src[12]*weights + dst[12]*weightd + offset) >> (log2_denom+1)); dst[13] = av_clip_uint8( (src[13]*weights + dst[13]*weightd + offset) >> (log2_denom+1)); dst[14] = av_clip_uint8( (src[14]*weights + dst[14]*weightd + offset) >> (log2_denom+1)); dst[15] = av_clip_uint8( (src[15]*weights + dst[15]*weightd + offset) >> (log2_denom+1)); } }
>static void weight_h264_pixels8x16_c(uint8_t *block, int stride, int log2_denom, int weight, int offset){ int y; offset <<= log2_denom; if(log2_denom) offset += 1<<(log2_denom-1); for(y=0; y<16; y++, block += stride){ block[0] = av_clip_uint8( (block[0]*weight + offset) >> log2_denom ); block[1] = av_clip_uint8( (block[1]*weight + offset) >> log2_denom ); if(8==2) continue; block[2] = av_clip_uint8( (block[2]*weight + offset) >> log2_denom ); block[3] = av_clip_uint8( (block[3]*weight + offset) >> log2_denom ); if(8==4) continue; block[4] = av_clip_uint8( (block[4]*weight + offset) >> log2_denom ); block[5] = av_clip_uint8( (block[5]*weight + offset) >> log2_denom ); block[6] = av_clip_uint8( (block[6]*weight + offset) >> log2_denom ); block[7] = av_clip_uint8( (block[7]*weight + offset) >> log2_denom ); if(8==8) continue; block[8] = av_clip_uint8( (block[8]*weight + offset) >> log2_denom ); block[9] = av_clip_uint8( (block[9]*weight + offset) >> log2_denom ); block[10] = av_clip_uint8( (block[10]*weight + offset) >> log2_denom ); block[11] = av_clip_uint8( (block[11]*weight + offset) >> log2_denom ); block[12] = av_clip_uint8( (block[12]*weight + offset) >> log2_denom ); block[13] = av_clip_uint8( (block[13]*weight + offset) >> log2_denom ); block[14] = av_clip_uint8( (block[14]*weight + offset) >> log2_denom ); block[15] = av_clip_uint8( (block[15]*weight + offset) >> log2_denom ); } } static void biweight_h264_pixels8x16_c(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offset){ int y; offset = ((offset + 1) | 1) << log2_denom; for(y=0; y<16; y++, dst += stride, src += stride){ dst[0] = av_clip_uint8( (src[0]*weights + dst[0]*weightd + offset) >> (log2_denom+1)); dst[1] = av_clip_uint8( (src[1]*weights + dst[1]*weightd + offset) >> (log2_denom+1)); if(8==2) continue; dst[2] = av_clip_uint8( (src[2]*weights + dst[2]*weightd + offset) >> (log2_denom+1)); dst[3] = av_clip_uint8( (src[3]*weights + dst[3]*weightd + offset) >> (log2_denom+1)); if(8==4) continue; dst[4] = av_clip_uint8( (src[4]*weights + dst[4]*weightd + offset) >> (log2_denom+1)); dst[5] = av_clip_uint8( (src[5]*weights + dst[5]*weightd + offset) >> (log2_denom+1)); dst[6] = av_clip_uint8( (src[6]*weights + dst[6]*weightd + offset) >> (log2_denom+1)); dst[7] = av_clip_uint8( (src[7]*weights + dst[7]*weightd + offset) >> (log2_denom+1)); if(8==8) continue; dst[8] = av_clip_uint8( (src[8]*weights + dst[8]*weightd + offset) >> (log2_denom+1)); dst[9] = av_clip_uint8( (src[9]*weights + dst[9]*weightd + offset) >> (log2_denom+1)); dst[10] = av_clip_uint8( (src[10]*weights + dst[10]*weightd + offset) >> (log2_denom+1)); dst[11] = av_clip_uint8( (src[11]*weights + dst[11]*weightd + offset) >> (log2_denom+1)); dst[12] = av_clip_uint8( (src[12]*weights + dst[12]*weightd + offset) >> (log2_denom+1)); dst[13] = av_clip_uint8( (src[13]*weights + dst[13]*weightd + offset) >> (log2_denom+1)); dst[14] = av_clip_uint8( (src[14]*weights + dst[14]*weightd + offset) >> (log2_denom+1)); dst[15] = av_clip_uint8( (src[15]*weights + dst[15]*weightd + offset) >> (log2_denom+1)); } }
>static void weight_h264_pixels8x8_c(uint8_t *block, int stride, int log2_denom, int weight, int offset){ int y; offset <<= log2_denom; if(log2_denom) offset += 1<<(log2_denom-1); for(y=0; y<8; y++, block += stride){ block[0] = av_clip_uint8( (block[0]*weight + offset) >> log2_denom ); block[1] = av_clip_uint8( (block[1]*weight + offset) >> log2_denom ); if(8==2) continue; block[2] = av_clip_uint8( (block[2]*weight + offset) >> log2_denom ); block[3] = av_clip_uint8( (block[3]*weight + offset) >> log2_denom ); if(8==4) continue; block[4] = av_clip_uint8( (block[4]*weight + offset) >> log2_denom ); block[5] = av_clip_uint8( (block[5]*weight + offset) >> log2_denom ); block[6] = av_clip_uint8( (block[6]*weight + offset) >> log2_denom ); block[7] = av_clip_uint8( (block[7]*weight + offset) >> log2_denom ); if(8==8) continue; block[8] = av_clip_uint8( (block[8]*weight + offset) >> log2_denom ); block[9] = av_clip_uint8( (block[9]*weight + offset) >> log2_denom ); block[10] = av_clip_uint8( (block[10]*weight + offset) >> log2_denom ); block[11] = av_clip_uint8( (block[11]*weight + offset) >> log2_denom ); block[12] = av_clip_uint8( (block[12]*weight + offset) >> log2_denom ); block[13] = av_clip_uint8( (block[13]*weight + offset) >> log2_denom ); block[14] = av_clip_uint8( (block[14]*weight + offset) >> log2_denom ); block[15] = av_clip_uint8( (block[15]*weight + offset) >> log2_denom ); } } static void biweight_h264_pixels8x8_c(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offset){ int y; offset = ((offset + 1) | 1) << log2_denom; for(y=0; y<8; y++, dst += stride, src += stride){ dst[0] = av_clip_uint8( (src[0]*weights + dst[0]*weightd + offset) >> (log2_denom+1)); dst[1] = av_clip_uint8( (src[1]*weights + dst[1]*weightd + offset) >> (log2_denom+1)); if(8==2) continue; dst[2] = av_clip_uint8( (src[2]*weights + dst[2]*weightd + offset) >> (log2_denom+1)); dst[3] = av_clip_uint8( (src[3]*weights + dst[3]*weightd + offset) >> (log2_denom+1)); if(8==4) continue; dst[4] = av_clip_uint8( (src[4]*weights + dst[4]*weightd + offset) >> (log2_denom+1)); dst[5] = av_clip_uint8( (src[5]*weights + dst[5]*weightd + offset) >> (log2_denom+1)); dst[6] = av_clip_uint8( (src[6]*weights + dst[6]*weightd + offset) >> (log2_denom+1)); dst[7] = av_clip_uint8( (src[7]*weights + dst[7]*weightd + offset) >> (log2_denom+1)); if(8==8) continue; dst[8] = av_clip_uint8( (src[8]*weights + dst[8]*weightd + offset) >> (log2_denom+1)); dst[9] = av_clip_uint8( (src[9]*weights + dst[9]*weightd + offset) >> (log2_denom+1)); dst[10] = av_clip_uint8( (src[10]*weights + dst[10]*weightd + offset) >> (log2_denom+1)); dst[11] = av_clip_uint8( (src[11]*weights + dst[11]*weightd + offset) >> (log2_denom+1)); dst[12] = av_clip_uint8( (src[12]*weights + dst[12]*weightd + offset) >> (log2_denom+1)); dst[13] = av_clip_uint8( (src[13]*weights + dst[13]*weightd + offset) >> (log2_denom+1)); dst[14] = av_clip_uint8( (src[14]*weights + dst[14]*weightd + offset) >> (log2_denom+1)); dst[15] = av_clip_uint8( (src[15]*weights + dst[15]*weightd + offset) >> (log2_denom+1)); } }
>static void weight_h264_pixels8x4_c(uint8_t *block, int stride, int log2_denom, int weight, int offset){ int y; offset <<= log2_denom; if(log2_denom) offset += 1<<(log2_denom-1); for(y=0; y<4; y++, block += stride){ block[0] = av_clip_uint8( (block[0]*weight + offset) >> log2_denom ); block[1] = av_clip_uint8( (block[1]*weight + offset) >> log2_denom ); if(8==2) continue; block[2] = av_clip_uint8( (block[2]*weight + offset) >> log2_denom ); block[3] = av_clip_uint8( (block[3]*weight + offset) >> log2_denom ); if(8==4) continue; block[4] = av_clip_uint8( (block[4]*weight + offset) >> log2_denom ); block[5] = av_clip_uint8( (block[5]*weight + offset) >> log2_denom ); block[6] = av_clip_uint8( (block[6]*weight + offset) >> log2_denom ); block[7] = av_clip_uint8( (block[7]*weight + offset) >> log2_denom ); if(8==8) continue; block[8] = av_clip_uint8( (block[8]*weight + offset) >> log2_denom ); block[9] = av_clip_uint8( (block[9]*weight + offset) >> log2_denom ); block[10] = av_clip_uint8( (block[10]*weight + offset) >> log2_denom ); block[11] = av_clip_uint8( (block[11]*weight + offset) >> log2_denom ); block[12] = av_clip_uint8( (block[12]*weight + offset) >> log2_denom ); block[13] = av_clip_uint8( (block[13]*weight + offset) >> log2_denom ); block[14] = av_clip_uint8( (block[14]*weight + offset) >> log2_denom ); block[15] = av_clip_uint8( (block[15]*weight + offset) >> log2_denom ); } } static void biweight_h264_pixels8x4_c(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offset){ int y; offset = ((offset + 1) | 1) << log2_denom; for(y=0; y<4; y++, dst += stride, src += stride){ dst[0] = av_clip_uint8( (src[0]*weights + dst[0]*weightd + offset) >> (log2_denom+1)); dst[1] = av_clip_uint8( (src[1]*weights + dst[1]*weightd + offset) >> (log2_denom+1)); if(8==2) continue; dst[2] = av_clip_uint8( (src[2]*weights + dst[2]*weightd + offset) >> (log2_denom+1)); dst[3] = av_clip_uint8( (src[3]*weights + dst[3]*weightd + offset) >> (log2_denom+1)); if(8==4) continue; dst[4] = av_clip_uint8( (src[4]*weights + dst[4]*weightd + offset) >> (log2_denom+1)); dst[5] = av_clip_uint8( (src[5]*weights + dst[5]*weightd + offset) >> (log2_denom+1)); dst[6] = av_clip_uint8( (src[6]*weights + dst[6]*weightd + offset) >> (log2_denom+1)); dst[7] = av_clip_uint8( (src[7]*weights + dst[7]*weightd + offset) >> (log2_denom+1)); if(8==8) continue; dst[8] = av_clip_uint8( (src[8]*weights + dst[8]*weightd + offset) >> (log2_denom+1)); dst[9] = av_clip_uint8( (src[9]*weights + dst[9]*weightd + offset) >> (log2_denom+1)); dst[10] = av_clip_uint8( (src[10]*weights + dst[10]*weightd + offset) >> (log2_denom+1)); dst[11] = av_clip_uint8( (src[11]*weights + dst[11]*weightd + offset) >> (log2_denom+1)); dst[12] = av_clip_uint8( (src[12]*weights + dst[12]*weightd + offset) >> (log2_denom+1)); dst[13] = av_clip_uint8( (src[13]*weights + dst[13]*weightd + offset) >> (log2_denom+1)); dst[14] = av_clip_uint8( (src[14]*weights + dst[14]*weightd + offset) >> (log2_denom+1)); dst[15] = av_clip_uint8( (src[15]*weights + dst[15]*weightd + offset) >> (log2_denom+1)); } }
>static void weight_h264_pixels4x8_c(uint8_t *block, int stride, int log2_denom, int weight, int offset){ int y; offset <<= log2_denom; if(log2_denom) offset += 1<<(log2_denom-1); for(y=0; y<8; y++, block += stride){ block[0] = av_clip_uint8( (block[0]*weight + offset) >> log2_denom ); block[1] = av_clip_uint8( (block[1]*weight + offset) >> log2_denom ); if(4==2) continue; block[2] = av_clip_uint8( (block[2]*weight + offset) >> log2_denom ); block[3] = av_clip_uint8( (block[3]*weight + offset) >> log2_denom ); if(4==4) continue; block[4] = av_clip_uint8( (block[4]*weight + offset) >> log2_denom ); block[5] = av_clip_uint8( (block[5]*weight + offset) >> log2_denom ); block[6] = av_clip_uint8( (block[6]*weight + offset) >> log2_denom ); block[7] = av_clip_uint8( (block[7]*weight + offset) >> log2_denom ); if(4==8) continue; block[8] = av_clip_uint8( (block[8]*weight + offset) >> log2_denom ); block[9] = av_clip_uint8( (block[9]*weight + offset) >> log2_denom ); block[10] = av_clip_uint8( (block[10]*weight + offset) >> log2_denom ); block[11] = av_clip_uint8( (block[11]*weight + offset) >> log2_denom ); block[12] = av_clip_uint8( (block[12]*weight + offset) >> log2_denom ); block[13] = av_clip_uint8( (block[13]*weight + offset) >> log2_denom ); block[14] = av_clip_uint8( (block[14]*weight + offset) >> log2_denom ); block[15] = av_clip_uint8( (block[15]*weight + offset) >> log2_denom ); } } static void biweight_h264_pixels4x8_c(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offset){ int y; offset = ((offset + 1) | 1) << log2_denom; for(y=0; y<8; y++, dst += stride, src += stride){ dst[0] = av_clip_uint8( (src[0]*weights + dst[0]*weightd + offset) >> (log2_denom+1)); dst[1] = av_clip_uint8( (src[1]*weights + dst[1]*weightd + offset) >> (log2_denom+1)); if(4==2) continue; dst[2] = av_clip_uint8( (src[2]*weights + dst[2]*weightd + offset) >> (log2_denom+1)); dst[3] = av_clip_uint8( (src[3]*weights + dst[3]*weightd + offset) >> (log2_denom+1)); if(4==4) continue; dst[4] = av_clip_uint8( (src[4]*weights + dst[4]*weightd + offset) >> (log2_denom+1)); dst[5] = av_clip_uint8( (src[5]*weights + dst[5]*weightd + offset) >> (log2_denom+1)); dst[6] = av_clip_uint8( (src[6]*weights + dst[6]*weightd + offset) >> (log2_denom+1)); dst[7] = av_clip_uint8( (src[7]*weights + dst[7]*weightd + offset) >> (log2_denom+1)); if(4==8) continue; dst[8] = av_clip_uint8( (src[8]*weights + dst[8]*weightd + offset) >> (log2_denom+1)); dst[9] = av_clip_uint8( (src[9]*weights + dst[9]*weightd + offset) >> (log2_denom+1)); dst[10] = av_clip_uint8( (src[10]*weights + dst[10]*weightd + offset) >> (log2_denom+1)); dst[11] = av_clip_uint8( (src[11]*weights + dst[11]*weightd + offset) >> (log2_denom+1)); dst[12] = av_clip_uint8( (src[12]*weights + dst[12]*weightd + offset) >> (log2_denom+1)); dst[13] = av_clip_uint8( (src[13]*weights + dst[13]*weightd + offset) >> (log2_denom+1)); dst[14] = av_clip_uint8( (src[14]*weights + dst[14]*weightd + offset) >> (log2_denom+1)); dst[15] = av_clip_uint8( (src[15]*weights + dst[15]*weightd + offset) >> (log2_denom+1)); } }
>static void weight_h264_pixels4x4_c(uint8_t *block, int stride, int log2_denom, int weight, int offset){ int y; offset <<= log2_denom; if(log2_denom) offset += 1<<(log2_denom-1); for(y=0; y<4; y++, block += stride){ block[0] = av_clip_uint8( (block[0]*weight + offset) >> log2_denom ); block[1] = av_clip_uint8( (block[1]*weight + offset) >> log2_denom ); if(4==2) continue; block[2] = av_clip_uint8( (block[2]*weight + offset) >> log2_denom ); block[3] = av_clip_uint8( (block[3]*weight + offset) >> log2_denom ); if(4==4) continue; block[4] = av_clip_uint8( (block[4]*weight + offset) >> log2_denom ); block[5] = av_clip_uint8( (block[5]*weight + offset) >> log2_denom ); block[6] = av_clip_uint8( (block[6]*weight + offset) >> log2_denom ); block[7] = av_clip_uint8( (block[7]*weight + offset) >> log2_denom ); if(4==8) continue; block[8] = av_clip_uint8( (block[8]*weight + offset) >> log2_denom ); block[9] = av_clip_uint8( (block[9]*weight + offset) >> log2_denom ); block[10] = av_clip_uint8( (block[10]*weight + offset) >> log2_denom ); block[11] = av_clip_uint8( (block[11]*weight + offset) >> log2_denom ); block[12] = av_clip_uint8( (block[12]*weight + offset) >> log2_denom ); block[13] = av_clip_uint8( (block[13]*weight + offset) >> log2_denom ); block[14] = av_clip_uint8( (block[14]*weight + offset) >> log2_denom ); block[15] = av_clip_uint8( (block[15]*weight + offset) >> log2_denom ); } } static void biweight_h264_pixels4x4_c(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offset){ int y; offset = ((offset + 1) | 1) << log2_denom; for(y=0; y<4; y++, dst += stride, src += stride){ dst[0] = av_clip_uint8( (src[0]*weights + dst[0]*weightd + offset) >> (log2_denom+1)); dst[1] = av_clip_uint8( (src[1]*weights + dst[1]*weightd + offset) >> (log2_denom+1)); if(4==2) continue; dst[2] = av_clip_uint8( (src[2]*weights + dst[2]*weightd + offset) >> (log2_denom+1)); dst[3] = av_clip_uint8( (src[3]*weights + dst[3]*weightd + offset) >> (log2_denom+1)); if(4==4) continue; dst[4] = av_clip_uint8( (src[4]*weights + dst[4]*weightd + offset) >> (log2_denom+1)); dst[5] = av_clip_uint8( (src[5]*weights + dst[5]*weightd + offset) >> (log2_denom+1)); dst[6] = av_clip_uint8( (src[6]*weights + dst[6]*weightd + offset) >> (log2_denom+1)); dst[7] = av_clip_uint8( (src[7]*weights + dst[7]*weightd + offset) >> (log2_denom+1)); if(4==8) continue; dst[8] = av_clip_uint8( (src[8]*weights + dst[8]*weightd + offset) >> (log2_denom+1)); dst[9] = av_clip_uint8( (src[9]*weights + dst[9]*weightd + offset) >> (log2_denom+1)); dst[10] = av_clip_uint8( (src[10]*weights + dst[10]*weightd + offset) >> (log2_denom+1)); dst[11] = av_clip_uint8( (src[11]*weights + dst[11]*weightd + offset) >> (log2_denom+1)); dst[12] = av_clip_uint8( (src[12]*weights + dst[12]*weightd + offset) >> (log2_denom+1)); dst[13] = av_clip_uint8( (src[13]*weights + dst[13]*weightd + offset) >> (log2_denom+1)); dst[14] = av_clip_uint8( (src[14]*weights + dst[14]*weightd + offset) >> (log2_denom+1)); dst[15] = av_clip_uint8( (src[15]*weights + dst[15]*weightd + offset) >> (log2_denom+1)); } }
>static void weight_h264_pixels4x2_c(uint8_t *block, int stride, int log2_denom, int weight, int offset){ int y; offset <<= log2_denom; if(log2_denom) offset += 1<<(log2_denom-1); for(y=0; y<2; y++, block += stride){ block[0] = av_clip_uint8( (block[0]*weight + offset) >> log2_denom ); block[1] = av_clip_uint8( (block[1]*weight + offset) >> log2_denom ); if(4==2) continue; block[2] = av_clip_uint8( (block[2]*weight + offset) >> log2_denom ); block[3] = av_clip_uint8( (block[3]*weight + offset) >> log2_denom ); if(4==4) continue; block[4] = av_clip_uint8( (block[4]*weight + offset) >> log2_denom ); block[5] = av_clip_uint8( (block[5]*weight + offset) >> log2_denom ); block[6] = av_clip_uint8( (block[6]*weight + offset) >> log2_denom ); block[7] = av_clip_uint8( (block[7]*weight + offset) >> log2_denom ); if(4==8) continue; block[8] = av_clip_uint8( (block[8]*weight + offset) >> log2_denom ); block[9] = av_clip_uint8( (block[9]*weight + offset) >> log2_denom ); block[10] = av_clip_uint8( (block[10]*weight + offset) >> log2_denom ); block[11] = av_clip_uint8( (block[11]*weight + offset) >> log2_denom ); block[12] = av_clip_uint8( (block[12]*weight + offset) >> log2_denom ); block[13] = av_clip_uint8( (block[13]*weight + offset) >> log2_denom ); block[14] = av_clip_uint8( (block[14]*weight + offset) >> log2_denom ); block[15] = av_clip_uint8( (block[15]*weight + offset) >> log2_denom ); } } static void biweight_h264_pixels4x2_c(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offset){ int y; offset = ((offset + 1) | 1) << log2_denom; for(y=0; y<2; y++, dst += stride, src += stride){ dst[0] = av_clip_uint8( (src[0]*weights + dst[0]*weightd + offset) >> (log2_denom+1)); dst[1] = av_clip_uint8( (src[1]*weights + dst[1]*weightd + offset) >> (log2_denom+1)); if(4==2) continue; dst[2] = av_clip_uint8( (src[2]*weights + dst[2]*weightd + offset) >> (log2_denom+1)); dst[3] = av_clip_uint8( (src[3]*weights + dst[3]*weightd + offset) >> (log2_denom+1)); if(4==4) continue; dst[4] = av_clip_uint8( (src[4]*weights + dst[4]*weightd + offset) >> (log2_denom+1)); dst[5] = av_clip_uint8( (src[5]*weights + dst[5]*weightd + offset) >> (log2_denom+1)); dst[6] = av_clip_uint8( (src[6]*weights + dst[6]*weightd + offset) >> (log2_denom+1)); dst[7] = av_clip_uint8( (src[7]*weights + dst[7]*weightd + offset) >> (log2_denom+1)); if(4==8) continue; dst[8] = av_clip_uint8( (src[8]*weights + dst[8]*weightd + offset) >> (log2_denom+1)); dst[9] = av_clip_uint8( (src[9]*weights + dst[9]*weightd + offset) >> (log2_denom+1)); dst[10] = av_clip_uint8( (src[10]*weights + dst[10]*weightd + offset) >> (log2_denom+1)); dst[11] = av_clip_uint8( (src[11]*weights + dst[11]*weightd + offset) >> (log2_denom+1)); dst[12] = av_clip_uint8( (src[12]*weights + dst[12]*weightd + offset) >> (log2_denom+1)); dst[13] = av_clip_uint8( (src[13]*weights + dst[13]*weightd + offset) >> (log2_denom+1)); dst[14] = av_clip_uint8( (src[14]*weights + dst[14]*weightd + offset) >> (log2_denom+1)); dst[15] = av_clip_uint8( (src[15]*weights + dst[15]*weightd + offset) >> (log2_denom+1)); } }
>static void weight_h264_pixels2x4_c(uint8_t *block, int stride, int log2_denom, int weight, int offset){ int y; offset <<= log2_denom; if(log2_denom) offset += 1<<(log2_denom-1); for(y=0; y<4; y++, block += stride){ block[0] = av_clip_uint8( (block[0]*weight + offset) >> log2_denom ); block[1] = av_clip_uint8( (block[1]*weight + offset) >> log2_denom ); if(2==2) continue; block[2] = av_clip_uint8( (block[2]*weight + offset) >> log2_denom ); block[3] = av_clip_uint8( (block[3]*weight + offset) >> log2_denom ); if(2==4) continue; block[4] = av_clip_uint8( (block[4]*weight + offset) >> log2_denom ); block[5] = av_clip_uint8( (block[5]*weight + offset) >> log2_denom ); block[6] = av_clip_uint8( (block[6]*weight + offset) >> log2_denom ); block[7] = av_clip_uint8( (block[7]*weight + offset) >> log2_denom ); if(2==8) continue; block[8] = av_clip_uint8( (block[8]*weight + offset) >> log2_denom ); block[9] = av_clip_uint8( (block[9]*weight + offset) >> log2_denom ); block[10] = av_clip_uint8( (block[10]*weight + offset) >> log2_denom ); block[11] = av_clip_uint8( (block[11]*weight + offset) >> log2_denom ); block[12] = av_clip_uint8( (block[12]*weight + offset) >> log2_denom ); block[13] = av_clip_uint8( (block[13]*weight + offset) >> log2_denom ); block[14] = av_clip_uint8( (block[14]*weight + offset) >> log2_denom ); block[15] = av_clip_uint8( (block[15]*weight + offset) >> log2_denom ); } } static void biweight_h264_pixels2x4_c(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offset){ int y; offset = ((offset + 1) | 1) << log2_denom; for(y=0; y<4; y++, dst += stride, src += stride){ dst[0] = av_clip_uint8( (src[0]*weights + dst[0]*weightd + offset) >> (log2_denom+1)); dst[1] = av_clip_uint8( (src[1]*weights + dst[1]*weightd + offset) >> (log2_denom+1)); if(2==2) continue; dst[2] = av_clip_uint8( (src[2]*weights + dst[2]*weightd + offset) >> (log2_denom+1)); dst[3] = av_clip_uint8( (src[3]*weights + dst[3]*weightd + offset) >> (log2_denom+1)); if(2==4) continue; dst[4] = av_clip_uint8( (src[4]*weights + dst[4]*weightd + offset) >> (log2_denom+1)); dst[5] = av_clip_uint8( (src[5]*weights + dst[5]*weightd + offset) >> (log2_denom+1)); dst[6] = av_clip_uint8( (src[6]*weights + dst[6]*weightd + offset) >> (log2_denom+1)); dst[7] = av_clip_uint8( (src[7]*weights + dst[7]*weightd + offset) >> (log2_denom+1)); if(2==8) continue; dst[8] = av_clip_uint8( (src[8]*weights + dst[8]*weightd + offset) >> (log2_denom+1)); dst[9] = av_clip_uint8( (src[9]*weights + dst[9]*weightd + offset) >> (log2_denom+1)); dst[10] = av_clip_uint8( (src[10]*weights + dst[10]*weightd + offset) >> (log2_denom+1)); dst[11] = av_clip_uint8( (src[11]*weights + dst[11]*weightd + offset) >> (log2_denom+1)); dst[12] = av_clip_uint8( (src[12]*weights + dst[12]*weightd + offset) >> (log2_denom+1)); dst[13] = av_clip_uint8( (src[13]*weights + dst[13]*weightd + offset) >> (log2_denom+1)); dst[14] = av_clip_uint8( (src[14]*weights + dst[14]*weightd + offset) >> (log2_denom+1)); dst[15] = av_clip_uint8( (src[15]*weights + dst[15]*weightd + offset) >> (log2_denom+1)); } }
>static void weight_h264_pixels2x2_c(uint8_t *block, int stride, int log2_denom, int weight, int offset){ int y; offset <<= log2_denom; if(log2_denom) offset += 1<<(log2_denom-1); for(y=0; y<2; y++, block += stride){ block[0] = av_clip_uint8( (block[0]*weight + offset) >> log2_denom ); block[1] = av_clip_uint8( (block[1]*weight + offset) >> log2_denom ); if(2==2) continue; block[2] = av_clip_uint8( (block[2]*weight + offset) >> log2_denom ); block[3] = av_clip_uint8( (block[3]*weight + offset) >> log2_denom ); if(2==4) continue; block[4] = av_clip_uint8( (block[4]*weight + offset) >> log2_denom ); block[5] = av_clip_uint8( (block[5]*weight + offset) >> log2_denom ); block[6] = av_clip_uint8( (block[6]*weight + offset) >> log2_denom ); block[7] = av_clip_uint8( (block[7]*weight + offset) >> log2_denom ); if(2==8) continue; block[8] = av_clip_uint8( (block[8]*weight + offset) >> log2_denom ); block[9] = av_clip_uint8( (block[9]*weight + offset) >> log2_denom ); block[10] = av_clip_uint8( (block[10]*weight + offset) >> log2_denom ); block[11] = av_clip_uint8( (block[11]*weight + offset) >> log2_denom ); block[12] = av_clip_uint8( (block[12]*weight + offset) >> log2_denom ); block[13] = av_clip_uint8( (block[13]*weight + offset) >> log2_denom ); block[14] = av_clip_uint8( (block[14]*weight + offset) >> log2_denom ); block[15] = av_clip_uint8( (block[15]*weight + offset) >> log2_denom ); } } static void biweight_h264_pixels2x2_c(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offset){ int y; offset = ((offset + 1) | 1) << log2_denom; for(y=0; y<2; y++, dst += stride, src += stride){ dst[0] = av_clip_uint8( (src[0]*weights + dst[0]*weightd + offset) >> (log2_denom+1)); dst[1] = av_clip_uint8( (src[1]*weights + dst[1]*weightd + offset) >> (log2_denom+1)); if(2==2) continue; dst[2] = av_clip_uint8( (src[2]*weights + dst[2]*weightd + offset) >> (log2_denom+1)); dst[3] = av_clip_uint8( (src[3]*weights + dst[3]*weightd + offset) >> (log2_denom+1)); if(2==4) continue; dst[4] = av_clip_uint8( (src[4]*weights + dst[4]*weightd + offset) >> (log2_denom+1)); dst[5] = av_clip_uint8( (src[5]*weights + dst[5]*weightd + offset) >> (log2_denom+1)); dst[6] = av_clip_uint8( (src[6]*weights + dst[6]*weightd + offset) >> (log2_denom+1)); dst[7] = av_clip_uint8( (src[7]*weights + dst[7]*weightd + offset) >> (log2_denom+1)); if(2==8) continue; dst[8] = av_clip_uint8( (src[8]*weights + dst[8]*weightd + offset) >> (log2_denom+1)); dst[9] = av_clip_uint8( (src[9]*weights + dst[9]*weightd + offset) >> (log2_denom+1)); dst[10] = av_clip_uint8( (src[10]*weights + dst[10]*weightd + offset) >> (log2_denom+1)); dst[11] = av_clip_uint8( (src[11]*weights + dst[11]*weightd + offset) >> (log2_denom+1)); dst[12] = av_clip_uint8( (src[12]*weights + dst[12]*weightd + offset) >> (log2_denom+1)); dst[13] = av_clip_uint8( (src[13]*weights + dst[13]*weightd + offset) >> (log2_denom+1)); dst[14] = av_clip_uint8( (src[14]*weights + dst[14]*weightd + offset) >> (log2_denom+1)); dst[15] = av_clip_uint8( (src[15]*weights + dst[15]*weightd + offset) >> (log2_denom+1)); } }
>
>
>
>
>
>static void wmv2_mspel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){
>    uint8_t *cm = ff_cropTbl + 1024;
>    int i;
>
>    for(i=0; i<h; i++){
>        dst[0]= cm[(9*(src[0] + src[1]) - (src[-1] + src[2]) + 8)>>4];
>        dst[1]= cm[(9*(src[1] + src[2]) - (src[ 0] + src[3]) + 8)>>4];
>        dst[2]= cm[(9*(src[2] + src[3]) - (src[ 1] + src[4]) + 8)>>4];
>        dst[3]= cm[(9*(src[3] + src[4]) - (src[ 2] + src[5]) + 8)>>4];
>        dst[4]= cm[(9*(src[4] + src[5]) - (src[ 3] + src[6]) + 8)>>4];
>        dst[5]= cm[(9*(src[5] + src[6]) - (src[ 4] + src[7]) + 8)>>4];
>        dst[6]= cm[(9*(src[6] + src[7]) - (src[ 5] + src[8]) + 8)>>4];
>        dst[7]= cm[(9*(src[7] + src[8]) - (src[ 6] + src[9]) + 8)>>4];
>        dst+=dstStride;
>        src+=srcStride;
>    }
>}
>
>
>
>void ff_cavsdsp_init(DSPContext* c, AVCodecContext *avctx);
>
>void ff_put_cavs_qpel8_mc00_c(uint8_t *dst, uint8_t *src, int stride) {
>    put_pixels8_c(dst, src, stride, 8);
>}
>void ff_avg_cavs_qpel8_mc00_c(uint8_t *dst, uint8_t *src, int stride) {
>    avg_pixels8_c(dst, src, stride, 8);
>}
>void ff_put_cavs_qpel16_mc00_c(uint8_t *dst, uint8_t *src, int stride) {
>    put_pixels16_c(dst, src, stride, 16);
>}
>void ff_avg_cavs_qpel16_mc00_c(uint8_t *dst, uint8_t *src, int stride) {
>    avg_pixels16_c(dst, src, stride, 16);
>}
>
>
>
>
>void ff_vc1dsp_init(DSPContext* c, AVCodecContext *avctx);
>
>void ff_put_vc1_mspel_mc00_c(uint8_t *dst, uint8_t *src, int stride, int rnd) {
>    put_pixels8_c(dst, src, stride, 8);
>}
>
>
>
>
>
>
>
>static void wmv2_mspel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int w){
>    uint8_t *cm = ff_cropTbl + 1024;
>    int i;
>
>    for(i=0; i<w; i++){
>        const int src_1= src[ -srcStride];
>        const int src0 = src[0 ];
>        const int src1 = src[ srcStride];
>        const int src2 = src[2*srcStride];
>        const int src3 = src[3*srcStride];
>        const int src4 = src[4*srcStride];
>        const int src5 = src[5*srcStride];
>        const int src6 = src[6*srcStride];
>        const int src7 = src[7*srcStride];
>        const int src8 = src[8*srcStride];
>        const int src9 = src[9*srcStride];
>        dst[0*dstStride]= cm[(9*(src0 + src1) - (src_1 + src2) + 8)>>4];
>        dst[1*dstStride]= cm[(9*(src1 + src2) - (src0 + src3) + 8)>>4];
>        dst[2*dstStride]= cm[(9*(src2 + src3) - (src1 + src4) + 8)>>4];
>        dst[3*dstStride]= cm[(9*(src3 + src4) - (src2 + src5) + 8)>>4];
>        dst[4*dstStride]= cm[(9*(src4 + src5) - (src3 + src6) + 8)>>4];
>        dst[5*dstStride]= cm[(9*(src5 + src6) - (src4 + src7) + 8)>>4];
>        dst[6*dstStride]= cm[(9*(src6 + src7) - (src5 + src8) + 8)>>4];
>        dst[7*dstStride]= cm[(9*(src7 + src8) - (src6 + src9) + 8)>>4];
>        src++;
>        dst++;
>    }
>}
>
>static void put_mspel8_mc00_c (uint8_t *dst, uint8_t *src, int stride){
>    put_pixels8_c(dst, src, stride, 8);
>}
>
>static void put_mspel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){
>    uint8_t half[64];
>    wmv2_mspel8_h_lowpass(half, src, 8, stride, 8);
>    put_pixels8_l2(dst, src, half, stride, stride, 8, 8);
>}
>
>static void put_mspel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){
>    wmv2_mspel8_h_lowpass(dst, src, stride, stride, 8);
>}
>
>static void put_mspel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){
>    uint8_t half[64];
>    wmv2_mspel8_h_lowpass(half, src, 8, stride, 8);
>    put_pixels8_l2(dst, src+1, half, stride, stride, 8, 8);
>}
>
>static void put_mspel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){
>    wmv2_mspel8_v_lowpass(dst, src, stride, stride, 8);
>}
>
>static void put_mspel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){
>    uint8_t halfH[88];
>    uint8_t halfV[64];
>    uint8_t halfHV[64];
>    wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
>    wmv2_mspel8_v_lowpass(halfV, src, 8, stride, 8);
>    wmv2_mspel8_v_lowpass(halfHV, halfH+8, 8, 8, 8);
>    put_pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);
>}
>static void put_mspel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){
>    uint8_t halfH[88];
>    uint8_t halfV[64];
>    uint8_t halfHV[64];
>    wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
>    wmv2_mspel8_v_lowpass(halfV, src+1, 8, stride, 8);
>    wmv2_mspel8_v_lowpass(halfHV, halfH+8, 8, 8, 8);
>    put_pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);
>}
>static void put_mspel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){
>    uint8_t halfH[88];
>    wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
>    wmv2_mspel8_v_lowpass(dst, halfH+8, stride, 8, 8);
>}
>
>static void h263_v_loop_filter_c(uint8_t *src, int stride, int qscale){
>    int x;
>    const int strength= ff_h263_loop_filter_strength[qscale];
>
>    for(x=0; x<8; x++){
>        int d1, d2, ad1;
>        int p0= src[x-2*stride];
>        int p1= src[x-1*stride];
>        int p2= src[x+0*stride];
>        int p3= src[x+1*stride];
>        int d = (p0 - p3 + 4*(p2 - p1)) / 8;
>
>        if (d<-2*strength) d1= 0;
>        else if(d<- strength) d1=-2*strength - d;
>        else if(d< strength) d1= d;
>        else if(d< 2*strength) d1= 2*strength - d;
>        else d1= 0;
>
>        p1 += d1;
>        p2 -= d1;
>        if(p1&256) p1= ~(p1>>31);
>        if(p2&256) p2= ~(p2>>31);
>
>        src[x-1*stride] = p1;
>        src[x+0*stride] = p2;
>
>        ad1= ((d1) >= 0 ? (d1) : (-(d1)))>>1;
>
>        d2= av_clip((p0-p3)/4, -ad1, ad1);
>
>        src[x-2*stride] = p0 - d2;
>        src[x+ stride] = p3 + d2;
>    }
>}
>
>static void h263_h_loop_filter_c(uint8_t *src, int stride, int qscale){
>    int y;
>    const int strength= ff_h263_loop_filter_strength[qscale];
>
>    for(y=0; y<8; y++){
>        int d1, d2, ad1;
>        int p0= src[y*stride-2];
>        int p1= src[y*stride-1];
>        int p2= src[y*stride+0];
>        int p3= src[y*stride+1];
>        int d = (p0 - p3 + 4*(p2 - p1)) / 8;
>
>        if (d<-2*strength) d1= 0;
>        else if(d<- strength) d1=-2*strength - d;
>        else if(d< strength) d1= d;
>        else if(d< 2*strength) d1= 2*strength - d;
>        else d1= 0;
>
>        p1 += d1;
>        p2 -= d1;
>        if(p1&256) p1= ~(p1>>31);
>        if(p2&256) p2= ~(p2>>31);
>
>        src[y*stride-1] = p1;
>        src[y*stride+0] = p2;
>
>        ad1= ((d1) >= 0 ? (d1) : (-(d1)))>>1;
>
>        d2= av_clip((p0-p3)/4, -ad1, ad1);
>
>        src[y*stride-2] = p0 - d2;
>        src[y*stride+1] = p3 + d2;
>    }
>}
>
>static void h261_loop_filter_c(uint8_t *src, int stride){
>    int x,y,xy,yz;
>    int temp[64];
>
>    for(x=0; x<8; x++){
>        temp[x ] = 4*src[x ];
>        temp[x + 7*8] = 4*src[x + 7*stride];
>    }
>    for(y=1; y<7; y++){
>        for(x=0; x<8; x++){
>            xy = y * stride + x;
>            yz = y * 8 + x;
>            temp[yz] = src[xy - stride] + 2*src[xy] + src[xy + stride];
>        }
>    }
>
>    for(y=0; y<8; y++){
>        src[ y*stride] = (temp[ y*8] + 2)>>2;
>        src[7+y*stride] = (temp[7+y*8] + 2)>>2;
>        for(x=1; x<7; x++){
>            xy = y * stride + x;
>            yz = y * 8 + x;
>            src[xy] = (temp[yz-1] + 2*temp[yz] + temp[yz+1] + 8)>>4;
>        }
>    }
>}
>
>static inline void h264_loop_filter_luma_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta, int8_t *tc0)
>{
>    int i, d;
>    for( i = 0; i < 4; i++ ) {
>        if( tc0[i] < 0 ) {
>            pix += 4*ystride;
>            continue;
>        }
>        for( d = 0; d < 4; d++ ) {
>            const int p0 = pix[-1*xstride];
>            const int p1 = pix[-2*xstride];
>            const int p2 = pix[-3*xstride];
>            const int q0 = pix[0];
>            const int q1 = pix[1*xstride];
>            const int q2 = pix[2*xstride];
>
>            if( ((p0 - q0) >= 0 ? (p0 - q0) : (-(p0 - q0))) < alpha &&
>                ((p1 - p0) >= 0 ? (p1 - p0) : (-(p1 - p0))) < beta &&
>                ((q1 - q0) >= 0 ? (q1 - q0) : (-(q1 - q0))) < beta ) {
>
>                int tc = tc0[i];
>                int i_delta;
>
>                if( ((p2 - p0) >= 0 ? (p2 - p0) : (-(p2 - p0))) < beta ) {
>                    pix[-2*xstride] = p1 + av_clip( (( p2 + ( ( p0 + q0 + 1 ) >> 1 ) ) >> 1) - p1, -tc0[i], tc0[i] );
>                    tc++;
>                }
>                if( ((q2 - q0) >= 0 ? (q2 - q0) : (-(q2 - q0))) < beta ) {
>                    pix[ xstride] = q1 + av_clip( (( q2 + ( ( p0 + q0 + 1 ) >> 1 ) ) >> 1) - q1, -tc0[i], tc0[i] );
>                    tc++;
>                }
>
>                i_delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
>                pix[-xstride] = av_clip_uint8( p0 + i_delta );
>                pix[0] = av_clip_uint8( q0 - i_delta );
>            }
>            pix += ystride;
>        }
>    }
>}
>static void h264_v_loop_filter_luma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
>{
>    h264_loop_filter_luma_c(pix, stride, 1, alpha, beta, tc0);
>}
>static void h264_h_loop_filter_luma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
>{
>    h264_loop_filter_luma_c(pix, 1, stride, alpha, beta, tc0);
>}
>
>static inline void h264_loop_filter_chroma_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta, int8_t *tc0)
>{
>    int i, d;
>    for( i = 0; i < 4; i++ ) {
>        const int tc = tc0[i];
>        if( tc <= 0 ) {
>            pix += 2*ystride;
>            continue;
>        }
>        for( d = 0; d < 2; d++ ) {
>            const int p0 = pix[-1*xstride];
>            const int p1 = pix[-2*xstride];
>            const int q0 = pix[0];
>            const int q1 = pix[1*xstride];
>
>            if( ((p0 - q0) >= 0 ? (p0 - q0) : (-(p0 - q0))) < alpha &&
>                ((p1 - p0) >= 0 ? (p1 - p0) : (-(p1 - p0))) < beta &&
>                ((q1 - q0) >= 0 ? (q1 - q0) : (-(q1 - q0))) < beta ) {
>
>                int delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
>
>                pix[-xstride] = av_clip_uint8( p0 + delta );
>                pix[0] = av_clip_uint8( q0 - delta );
>            }
>            pix += ystride;
>        }
>    }
>}
>static void h264_v_loop_filter_chroma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
>{
>    h264_loop_filter_chroma_c(pix, stride, 1, alpha, beta, tc0);
>}
>static void h264_h_loop_filter_chroma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
>{
>    h264_loop_filter_chroma_c(pix, 1, stride, alpha, beta, tc0);
>}
>
>static inline void h264_loop_filter_chroma_intra_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta)
>{
>    int d;
>    for( d = 0; d < 8; d++ ) {
>        const int p0 = pix[-1*xstride];
>        const int p1 = pix[-2*xstride];
>        const int q0 = pix[0];
>        const int q1 = pix[1*xstride];
>
>        if( ((p0 - q0) >= 0 ? (p0 - q0) : (-(p0 - q0))) < alpha &&
>            ((p1 - p0) >= 0 ? (p1 - p0) : (-(p1 - p0))) < beta &&
>            ((q1 - q0) >= 0 ? (q1 - q0) : (-(q1 - q0))) < beta ) {
>
>            pix[-xstride] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
>            pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
>        }
>        pix += ystride;
>    }
>}
>static void h264_v_loop_filter_chroma_intra_c(uint8_t *pix, int stride, int alpha, int beta)
>{
>    h264_loop_filter_chroma_intra_c(pix, stride, 1, alpha, beta);
>}
>static void h264_h_loop_filter_chroma_intra_c(uint8_t *pix, int stride, int alpha, int beta)
>{
>    h264_loop_filter_chroma_intra_c(pix, 1, stride, alpha, beta);
>}
>
>static inline int pix_abs16_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
>{
>    int s, i;
>
>    s = 0;
>    for(i=0;i<h;i++) {
>        s += abs(pix1[0] - pix2[0]);
>        s += abs(pix1[1] - pix2[1]);
>        s += abs(pix1[2] - pix2[2]);
>        s += abs(pix1[3] - pix2[3]);
>        s += abs(pix1[4] - pix2[4]);
>        s += abs(pix1[5] - pix2[5]);
>        s += abs(pix1[6] - pix2[6]);
>        s += abs(pix1[7] - pix2[7]);
>        s += abs(pix1[8] - pix2[8]);
>        s += abs(pix1[9] - pix2[9]);
>        s += abs(pix1[10] - pix2[10]);
>        s += abs(pix1[11] - pix2[11]);
>        s += abs(pix1[12] - pix2[12]);
>        s += abs(pix1[13] - pix2[13]);
>        s += abs(pix1[14] - pix2[14]);
>        s += abs(pix1[15] - pix2[15]);
>        pix1 += line_size;
>        pix2 += line_size;
>    }
>    return s;
>}
>
>static int pix_abs16_x2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
>{
>    int s, i;
>
>    s = 0;
>    for(i=0;i<h;i++) {
>        s += abs(pix1[0] - ((pix2[0]+pix2[1]+1)>>1));
>        s += abs(pix1[1] - ((pix2[1]+pix2[2]+1)>>1));
>        s += abs(pix1[2] - ((pix2[2]+pix2[3]+1)>>1));
>        s += abs(pix1[3] - ((pix2[3]+pix2[4]+1)>>1));
>        s += abs(pix1[4] - ((pix2[4]+pix2[5]+1)>>1));
>        s += abs(pix1[5] - ((pix2[5]+pix2[6]+1)>>1));
>        s += abs(pix1[6] - ((pix2[6]+pix2[7]+1)>>1));
>        s += abs(pix1[7] - ((pix2[7]+pix2[8]+1)>>1));
>        s += abs(pix1[8] - ((pix2[8]+pix2[9]+1)>>1));
>        s += abs(pix1[9] - ((pix2[9]+pix2[10]+1)>>1));
>        s += abs(pix1[10] - ((pix2[10]+pix2[11]+1)>>1));
>        s += abs(pix1[11] - ((pix2[11]+pix2[12]+1)>>1));
>        s += abs(pix1[12] - ((pix2[12]+pix2[13]+1)>>1));
>        s += abs(pix1[13] - ((pix2[13]+pix2[14]+1)>>1));
>        s += abs(pix1[14] - ((pix2[14]+pix2[15]+1)>>1));
>        s += abs(pix1[15] - ((pix2[15]+pix2[16]+1)>>1));
>        pix1 += line_size;
>        pix2 += line_size;
>    }
>    return s;
>}
>
>static int pix_abs16_y2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
>{
>    int s, i;
>    uint8_t *pix3 = pix2 + line_size;
>
>    s = 0;
>    for(i=0;i<h;i++) {
>        s += abs(pix1[0] - ((pix2[0]+pix3[0]+1)>>1));
>        s += abs(pix1[1] - ((pix2[1]+pix3[1]+1)>>1));
>        s += abs(pix1[2] - ((pix2[2]+pix3[2]+1)>>1));
>        s += abs(pix1[3] - ((pix2[3]+pix3[3]+1)>>1));
>        s += abs(pix1[4] - ((pix2[4]+pix3[4]+1)>>1));
>        s += abs(pix1[5] - ((pix2[5]+pix3[5]+1)>>1));
>        s += abs(pix1[6] - ((pix2[6]+pix3[6]+1)>>1));
>        s += abs(pix1[7] - ((pix2[7]+pix3[7]+1)>>1));
>        s += abs(pix1[8] - ((pix2[8]+pix3[8]+1)>>1));
>        s += abs(pix1[9] - ((pix2[9]+pix3[9]+1)>>1));
>        s += abs(pix1[10] - ((pix2[10]+pix3[10]+1)>>1));
>        s += abs(pix1[11] - ((pix2[11]+pix3[11]+1)>>1));
>        s += abs(pix1[12] - ((pix2[12]+pix3[12]+1)>>1));
>        s += abs(pix1[13] - ((pix2[13]+pix3[13]+1)>>1));
>        s += abs(pix1[14] - ((pix2[14]+pix3[14]+1)>>1));
>        s += abs(pix1[15] - ((pix2[15]+pix3[15]+1)>>1));
>        pix1 += line_size;
>        pix2 += line_size;
>        pix3 += line_size;
>    }
>    return s;
>}
>
>static int pix_abs16_xy2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
>{
>    int s, i;
>    uint8_t *pix3 = pix2 + line_size;
>
>    s = 0;
>    for(i=0;i<h;i++) {
>        s += abs(pix1[0] - ((pix2[0]+pix2[1]+pix3[0]+pix3[1]+2)>>2));
>        s += abs(pix1[1] - ((pix2[1]+pix2[2]+pix3[1]+pix3[2]+2)>>2));
>        s += abs(pix1[2] - ((pix2[2]+pix2[3]+pix3[2]+pix3[3]+2)>>2));
>        s += abs(pix1[3] - ((pix2[3]+pix2[4]+pix3[3]+pix3[4]+2)>>2));
>        s += abs(pix1[4] - ((pix2[4]+pix2[5]+pix3[4]+pix3[5]+2)>>2));
>        s += abs(pix1[5] - ((pix2[5]+pix2[6]+pix3[5]+pix3[6]+2)>>2));
>        s += abs(pix1[6] - ((pix2[6]+pix2[7]+pix3[6]+pix3[7]+2)>>2));
>        s += abs(pix1[7] - ((pix2[7]+pix2[8]+pix3[7]+pix3[8]+2)>>2));
>        s += abs(pix1[8] - ((pix2[8]+pix2[9]+pix3[8]+pix3[9]+2)>>2));
>        s += abs(pix1[9] - ((pix2[9]+pix2[10]+pix3[9]+pix3[10]+2)>>2));
>        s += abs(pix1[10] - ((pix2[10]+pix2[11]+pix3[10]+pix3[11]+2)>>2));
>        s += abs(pix1[11] - ((pix2[11]+pix2[12]+pix3[11]+pix3[12]+2)>>2));
>        s += abs(pix1[12] - ((pix2[12]+pix2[13]+pix3[12]+pix3[13]+2)>>2));
>        s += abs(pix1[13] - ((pix2[13]+pix2[14]+pix3[13]+pix3[14]+2)>>2));
>        s += abs(pix1[14] - ((pix2[14]+pix2[15]+pix3[14]+pix3[15]+2)>>2));
>        s += abs(pix1[15] - ((pix2[15]+pix2[16]+pix3[15]+pix3[16]+2)>>2));
>        pix1 += line_size;
>        pix2 += line_size;
>        pix3 += line_size;
>    }
>    return s;
>}
>
>static inline int pix_abs8_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
>{
>    int s, i;
>
>    s = 0;
>    for(i=0;i<h;i++) {
>        s += abs(pix1[0] - pix2[0]);
>        s += abs(pix1[1] - pix2[1]);
>        s += abs(pix1[2] - pix2[2]);
>        s += abs(pix1[3] - pix2[3]);
>        s += abs(pix1[4] - pix2[4]);
>        s += abs(pix1[5] - pix2[5]);
>        s += abs(pix1[6] - pix2[6]);
>        s += abs(pix1[7] - pix2[7]);
>        pix1 += line_size;
>        pix2 += line_size;
>    }
>    return s;
>}
>
>static int pix_abs8_x2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
>{
>    int s, i;
>
>    s = 0;
>    for(i=0;i<h;i++) {
>        s += abs(pix1[0] - ((pix2[0]+pix2[1]+1)>>1));
>        s += abs(pix1[1] - ((pix2[1]+pix2[2]+1)>>1));
>        s += abs(pix1[2] - ((pix2[2]+pix2[3]+1)>>1));
>        s += abs(pix1[3] - ((pix2[3]+pix2[4]+1)>>1));
>        s += abs(pix1[4] - ((pix2[4]+pix2[5]+1)>>1));
>        s += abs(pix1[5] - ((pix2[5]+pix2[6]+1)>>1));
>        s += abs(pix1[6] - ((pix2[6]+pix2[7]+1)>>1));
>        s += abs(pix1[7] - ((pix2[7]+pix2[8]+1)>>1));
>        pix1 += line_size;
>        pix2 += line_size;
>    }
>    return s;
>}
>
>static int pix_abs8_y2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
>{
>    int s, i;
>    uint8_t *pix3 = pix2 + line_size;
>
>    s = 0;
>    for(i=0;i<h;i++) {
>        s += abs(pix1[0] - ((pix2[0]+pix3[0]+1)>>1));
>        s += abs(pix1[1] - ((pix2[1]+pix3[1]+1)>>1));
>        s += abs(pix1[2] - ((pix2[2]+pix3[2]+1)>>1));
>        s += abs(pix1[3] - ((pix2[3]+pix3[3]+1)>>1));
>        s += abs(pix1[4] - ((pix2[4]+pix3[4]+1)>>1));
>        s += abs(pix1[5] - ((pix2[5]+pix3[5]+1)>>1));
>        s += abs(pix1[6] - ((pix2[6]+pix3[6]+1)>>1));
>        s += abs(pix1[7] - ((pix2[7]+pix3[7]+1)>>1));
>        pix1 += line_size;
>        pix2 += line_size;
>        pix3 += line_size;
>    }
>    return s;
>}
>
>static int pix_abs8_xy2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
>{
>    int s, i;
>    uint8_t *pix3 = pix2 + line_size;
>
>    s = 0;
>    for(i=0;i<h;i++) {
>        s += abs(pix1[0] - ((pix2[0]+pix2[1]+pix3[0]+pix3[1]+2)>>2));
>        s += abs(pix1[1] - ((pix2[1]+pix2[2]+pix3[1]+pix3[2]+2)>>2));
>        s += abs(pix1[2] - ((pix2[2]+pix2[3]+pix3[2]+pix3[3]+2)>>2));
>        s += abs(pix1[3] - ((pix2[3]+pix2[4]+pix3[3]+pix3[4]+2)>>2));
>        s += abs(pix1[4] - ((pix2[4]+pix2[5]+pix3[4]+pix3[5]+2)>>2));
>        s += abs(pix1[5] - ((pix2[5]+pix2[6]+pix3[5]+pix3[6]+2)>>2));
>        s += abs(pix1[6] - ((pix2[6]+pix2[7]+pix3[6]+pix3[7]+2)>>2));
>        s += abs(pix1[7] - ((pix2[7]+pix2[8]+pix3[7]+pix3[8]+2)>>2));
>        pix1 += line_size;
>        pix2 += line_size;
>        pix3 += line_size;
>    }
>    return s;
>}
>
>static int nsse16_c(void *v, uint8_t *s1, uint8_t *s2, int stride, int h){
>    MpegEncContext *c = v;
>    int score1=0;
>    int score2=0;
>    int x,y;
>
>    for(y=0; y<h; y++){
>        for(x=0; x<16; x++){
>            score1+= (s1[x ] - s2[x ])*(s1[x ] - s2[x ]);
>        }
>        if(y+1<h){
>            for(x=0; x<15; x++){
>                score2+= ((s1[x ] - s1[x +stride] - s1[x+1] + s1[x+1+stride]) >= 0 ? (s1[x ] - s1[x +stride] - s1[x+1] + s1[x+1+stride]) : (-(s1[x ] - s1[x +stride] - s1[x+1] + s1[x+1+stride])))
>
>                        -((s2[x ] - s2[x +stride] - s2[x+1] + s2[x+1+stride]) >= 0 ? (s2[x ] - s2[x +stride] - s2[x+1] + s2[x+1+stride]) : (-(s2[x ] - s2[x +stride] - s2[x+1] + s2[x+1+stride])));
>
>            }
>        }
>        s1+= stride;
>        s2+= stride;
>    }
>
>    if(c) return score1 + ((score2) >= 0 ? (score2) : (-(score2)))*c->avctx->nsse_weight;
>    else return score1 + ((score2) >= 0 ? (score2) : (-(score2)))*8;
>}
>
>static int nsse8_c(void *v, uint8_t *s1, uint8_t *s2, int stride, int h){
>    MpegEncContext *c = v;
>    int score1=0;
>    int score2=0;
>    int x,y;
>
>    for(y=0; y<h; y++){
>        for(x=0; x<8; x++){
>            score1+= (s1[x ] - s2[x ])*(s1[x ] - s2[x ]);
>        }
>        if(y+1<h){
>            for(x=0; x<7; x++){
>                score2+= ((s1[x ] - s1[x +stride] - s1[x+1] + s1[x+1+stride]) >= 0 ? (s1[x ] - s1[x +stride] - s1[x+1] + s1[x+1+stride]) : (-(s1[x ] - s1[x +stride] - s1[x+1] + s1[x+1+stride])))
>
>                        -((s2[x ] - s2[x +stride] - s2[x+1] + s2[x+1+stride]) >= 0 ? (s2[x ] - s2[x +stride] - s2[x+1] + s2[x+1+stride]) : (-(s2[x ] - s2[x +stride] - s2[x+1] + s2[x+1+stride])));
>
>            }
>        }
>        s1+= stride;
>        s2+= stride;
>    }
>
>    if(c) return score1 + ((score2) >= 0 ? (score2) : (-(score2)))*c->avctx->nsse_weight;
>    else return score1 + ((score2) >= 0 ? (score2) : (-(score2)))*8;
>}
>
>static int try_8x8basis_c(int16_t rem[64], int16_t weight[64], int16_t basis[64], int scale){
>    int i;
>    unsigned int sum=0;
>
>    for(i=0; i<8*8; i++){
>        int b= rem[i] + ((basis[i]*scale + (1<<(16 - 6 -1)))>>(16 - 6));
>        int w= weight[i];
>        b>>= 6;
>        ((void) (0));
>
>        sum += (w*b)*(w*b)>>4;
>    }
>    return sum>>2;
>}
>
>static void add_8x8basis_c(int16_t rem[64], int16_t basis[64], int scale){
>    int i;
>
>    for(i=0; i<8*8; i++){
>        rem[i] += (basis[i]*scale + (1<<(16 - 6 -1)))>>(16 - 6);
>    }
>}
># 3136 "dsputil.c"
>void ff_block_permute(DCTELEM *block, uint8_t *permutation, const uint8_t *scantable, int last)
>{
>    int i;
>    DCTELEM temp[64];
>
>    if(last<=0) return;
>
>
>    for(i=0; i<=last; i++){
>        const int j= scantable[i];
>        temp[j]= block[j];
>        block[j]=0;
>    }
>
>    for(i=0; i<=last; i++){
>        const int j= scantable[i];
>        const int perm_j= permutation[j];
>        block[perm_j]= temp[j];
>    }
>}
>
>static int zero_cmp(void *s, uint8_t *a, uint8_t *b, int stride, int h){
>    return 0;
>}
>
>void ff_set_cmp(DSPContext* c, me_cmp_func *cmp, int type){
>    int i;
>
>    memset(cmp, 0, sizeof(void*)*5);
>
>    for(i=0; i<5; i++){
>        switch(type&0xFF){
>        case 0:
>            cmp[i]= c->sad[i];
>            break;
>        case 2:
>            cmp[i]= c->hadamard8_diff[i];
>            break;
>        case 1:
>            cmp[i]= c->sse[i];
>            break;
>        case 3:
>            cmp[i]= c->dct_sad[i];
>            break;
>        case 14:
>            cmp[i]= c->dct264_sad[i];
>            break;
>        case 13:
>            cmp[i]= c->dct_max[i];
>            break;
>        case 4:
>            cmp[i]= c->quant_psnr[i];
>            break;
>        case 5:
>            cmp[i]= c->bit[i];
>            break;
>        case 6:
>            cmp[i]= c->rd[i];
>            break;
>        case 8:
>            cmp[i]= c->vsad[i];
>            break;
>        case 9:
>            cmp[i]= c->vsse[i];
>            break;
>        case 7:
>            cmp[i]= zero_cmp;
>            break;
>        case 10:
>            cmp[i]= c->nsse[i];
>            break;
>
>        case 11:
>            cmp[i]= c->w53[i];
>            break;
>        case 12:
>            cmp[i]= c->w97[i];
>            break;
>
>        default:
>            av_log(((void *)0), 0,"internal error in cmp function selection\n");
>        }
>    }
>}
>
>
>
>
>static void clear_blocks_c(DCTELEM *blocks)
>{
>    memset(blocks, 0, sizeof(DCTELEM)*6*64);
>}
>
>static void add_bytes_c(uint8_t *dst, uint8_t *src, int w){
>    int i;
>    for(i=0; i+7<w; i+=8){
>        dst[i+0] += src[i+0];
>        dst[i+1] += src[i+1];
>        dst[i+2] += src[i+2];
>        dst[i+3] += src[i+3];
>        dst[i+4] += src[i+4];
>        dst[i+5] += src[i+5];
>        dst[i+6] += src[i+6];
>        dst[i+7] += src[i+7];
>    }
>    for(; i<w; i++)
>        dst[i+0] += src[i+0];
>}
>
>static void diff_bytes_c(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w){
>    int i;
>    for(i=0; i+7<w; i+=8){
>        dst[i+0] = src1[i+0]-src2[i+0];
>        dst[i+1] = src1[i+1]-src2[i+1];
>        dst[i+2] = src1[i+2]-src2[i+2];
>        dst[i+3] = src1[i+3]-src2[i+3];
>        dst[i+4] = src1[i+4]-src2[i+4];
>        dst[i+5] = src1[i+5]-src2[i+5];
>        dst[i+6] = src1[i+6]-src2[i+6];
>        dst[i+7] = src1[i+7]-src2[i+7];
>    }
>    for(; i<w; i++)
>        dst[i+0] = src1[i+0]-src2[i+0];
>}
>
>static void sub_hfyu_median_prediction_c(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w, int *left, int *left_top){
>    int i;
>    uint8_t l, lt;
>
>    l= *left;
>    lt= *left_top;
>
>    for(i=0; i<w; i++){
>        const int pred= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF);
>        lt= src1[i];
>        l= src2[i];
>        dst[i]= l - pred;
>    }
>
>    *left= l;
>    *left_top= lt;
>}
># 3294 "dsputil.c"
>static int hadamard8_diff8x8_c( void *s, uint8_t *dst, uint8_t *src, int stride, int h){
>    int i;
>    int temp[64];
>    int sum=0;
>
>    ((void) (0));
>
>    for(i=0; i<8; i++){
>
>        temp[8*i+0]= (src[stride*i+0]-dst[stride*i+0])+(src[stride*i+1]-dst[stride*i+1]);temp[8*i+1]= (src[stride*i+0]-dst[stride*i+0])-(src[stride*i+1]-dst[stride*i+1]);;
>        temp[8*i+2]= (src[stride*i+2]-dst[stride*i+2])+(src[stride*i+3]-dst[stride*i+3]);temp[8*i+3]= (src[stride*i+2]-dst[stride*i+2])-(src[stride*i+3]-dst[stride*i+3]);;
>        temp[8*i+4]= (src[stride*i+4]-dst[stride*i+4])+(src[stride*i+5]-dst[stride*i+5]);temp[8*i+5]= (src[stride*i+4]-dst[stride*i+4])-(src[stride*i+5]-dst[stride*i+5]);;
>        temp[8*i+6]= (src[stride*i+6]-dst[stride*i+6])+(src[stride*i+7]-dst[stride*i+7]);temp[8*i+7]= (src[stride*i+6]-dst[stride*i+6])-(src[stride*i+7]-dst[stride*i+7]);;
>
>        { int a,b; a= temp[8*i+0]; b= temp[8*i+2]; temp[8*i+0]= a+b; temp[8*i+2]= a-b;};
>        { int a,b; a= temp[8*i+1]; b= temp[8*i+3]; temp[8*i+1]= a+b; temp[8*i+3]= a-b;};
>        { int a,b; a= temp[8*i+4]; b= temp[8*i+6]; temp[8*i+4]= a+b; temp[8*i+6]= a-b;};
>        { int a,b; a= temp[8*i+5]; b= temp[8*i+7]; temp[8*i+5]= a+b; temp[8*i+7]= a-b;};
>
>        { int a,b; a= temp[8*i+0]; b= temp[8*i+4]; temp[8*i+0]= a+b; temp[8*i+4]= a-b;};
>        { int a,b; a= temp[8*i+1]; b= temp[8*i+5]; temp[8*i+1]= a+b; temp[8*i+5]= a-b;};
>        { int a,b; a= temp[8*i+2]; b= temp[8*i+6]; temp[8*i+2]= a+b; temp[8*i+6]= a-b;};
>        { int a,b; a= temp[8*i+3]; b= temp[8*i+7]; temp[8*i+3]= a+b; temp[8*i+7]= a-b;};
>    }
>
>    for(i=0; i<8; i++){
>        { int a,b; a= temp[8*0+i]; b= temp[8*1+i]; temp[8*0+i]= a+b; temp[8*1+i]= a-b;};
>        { int a,b; a= temp[8*2+i]; b= temp[8*3+i]; temp[8*2+i]= a+b; temp[8*3+i]= a-b;};
>        { int a,b; a= temp[8*4+i]; b= temp[8*5+i]; temp[8*4+i]= a+b; temp[8*5+i]= a-b;};
>        { int a,b; a= temp[8*6+i]; b= temp[8*7+i]; temp[8*6+i]= a+b; temp[8*7+i]= a-b;};
>
>        { int a,b; a= temp[8*0+i]; b= temp[8*2+i]; temp[8*0+i]= a+b; temp[8*2+i]= a-b;};
>        { int a,b; a= temp[8*1+i]; b= temp[8*3+i]; temp[8*1+i]= a+b; temp[8*3+i]= a-b;};
>        { int a,b; a= temp[8*4+i]; b= temp[8*6+i]; temp[8*4+i]= a+b; temp[8*6+i]= a-b;};
>        { int a,b; a= temp[8*5+i]; b= temp[8*7+i]; temp[8*5+i]= a+b; temp[8*7+i]= a-b;};
>
>        sum +=
>             ((((temp[8*0+i])+(temp[8*4+i])) >= 0 ? ((temp[8*0+i])+(temp[8*4+i])) : (-((temp[8*0+i])+(temp[8*4+i])))) + (((temp[8*0+i])-(temp[8*4+i])) >= 0 ? ((temp[8*0+i])-(temp[8*4+i])) : (-((temp[8*0+i])-(temp[8*4+i])))))
>            +((((temp[8*1+i])+(temp[8*5+i])) >= 0 ? ((temp[8*1+i])+(temp[8*5+i])) : (-((temp[8*1+i])+(temp[8*5+i])))) + (((temp[8*1+i])-(temp[8*5+i])) >= 0 ? ((temp[8*1+i])-(temp[8*5+i])) : (-((temp[8*1+i])-(temp[8*5+i])))))
>            +((((temp[8*2+i])+(temp[8*6+i])) >= 0 ? ((temp[8*2+i])+(temp[8*6+i])) : (-((temp[8*2+i])+(temp[8*6+i])))) + (((temp[8*2+i])-(temp[8*6+i])) >= 0 ? ((temp[8*2+i])-(temp[8*6+i])) : (-((temp[8*2+i])-(temp[8*6+i])))))
>            +((((temp[8*3+i])+(temp[8*7+i])) >= 0 ? ((temp[8*3+i])+(temp[8*7+i])) : (-((temp[8*3+i])+(temp[8*7+i])))) + (((temp[8*3+i])-(temp[8*7+i])) >= 0 ? ((temp[8*3+i])-(temp[8*7+i])) : (-((temp[8*3+i])-(temp[8*7+i])))));
>    }
>
>
>
>
>
>
>
>    return sum;
>}
>
>static int hadamard8_intra8x8_c( void *s, uint8_t *src, uint8_t *dummy, int stride, int h){
>    int i;
>    int temp[64];
>    int sum=0;
>
>    ((void) (0));
>
>    for(i=0; i<8; i++){
>
>        temp[8*i+0]= (src[stride*i+0])+(src[stride*i+1]);temp[8*i+1]= (src[stride*i+0])-(src[stride*i+1]);;
>        temp[8*i+2]= (src[stride*i+2])+(src[stride*i+3]);temp[8*i+3]= (src[stride*i+2])-(src[stride*i+3]);;
>        temp[8*i+4]= (src[stride*i+4])+(src[stride*i+5]);temp[8*i+5]= (src[stride*i+4])-(src[stride*i+5]);;
>        temp[8*i+6]= (src[stride*i+6])+(src[stride*i+7]);temp[8*i+7]= (src[stride*i+6])-(src[stride*i+7]);;
>
>        { int a,b; a= temp[8*i+0]; b= temp[8*i+2]; temp[8*i+0]= a+b; temp[8*i+2]= a-b;};
>        { int a,b; a= temp[8*i+1]; b= temp[8*i+3]; temp[8*i+1]= a+b; temp[8*i+3]= a-b;};
>        { int a,b; a= temp[8*i+4]; b= temp[8*i+6]; temp[8*i+4]= a+b; temp[8*i+6]= a-b;};
>        { int a,b; a= temp[8*i+5]; b= temp[8*i+7]; temp[8*i+5]= a+b; temp[8*i+7]= a-b;};
>
>        { int a,b; a= temp[8*i+0]; b= temp[8*i+4]; temp[8*i+0]= a+b; temp[8*i+4]= a-b;};
>        { int a,b; a= temp[8*i+1]; b= temp[8*i+5]; temp[8*i+1]= a+b; temp[8*i+5]= a-b;};
>        { int a,b; a= temp[8*i+2]; b= temp[8*i+6]; temp[8*i+2]= a+b; temp[8*i+6]= a-b;};
>        { int a,b; a= temp[8*i+3]; b= temp[8*i+7]; temp[8*i+3]= a+b; temp[8*i+7]= a-b;};
>    }
>
>    for(i=0; i<8; i++){
>        { int a,b; a= temp[8*0+i]; b= temp[8*1+i]; temp[8*0+i]= a+b; temp[8*1+i]= a-b;};
>        { int a,b; a= temp[8*2+i]; b= temp[8*3+i]; temp[8*2+i]= a+b; temp[8*3+i]= a-b;};
>        { int a,b; a= temp[8*4+i]; b= temp[8*5+i]; temp[8*4+i]= a+b; temp[8*5+i]= a-b;};
>        { int a,b; a= temp[8*6+i]; b= temp[8*7+i]; temp[8*6+i]= a+b; temp[8*7+i]= a-b;};
>
>        { int a,b; a= temp[8*0+i]; b= temp[8*2+i]; temp[8*0+i]= a+b; temp[8*2+i]= a-b;};
>        { int a,b; a= temp[8*1+i]; b= temp[8*3+i]; temp[8*1+i]= a+b; temp[8*3+i]= a-b;};
>        { int a,b; a= temp[8*4+i]; b= temp[8*6+i]; temp[8*4+i]= a+b; temp[8*6+i]= a-b;};
>        { int a,b; a= temp[8*5+i]; b= temp[8*7+i]; temp[8*5+i]= a+b; temp[8*7+i]= a-b;};
>
>        sum +=
>             ((((temp[8*0+i])+(temp[8*4+i])) >= 0 ? ((temp[8*0+i])+(temp[8*4+i])) : (-((temp[8*0+i])+(temp[8*4+i])))) + (((temp[8*0+i])-(temp[8*4+i])) >= 0 ? ((temp[8*0+i])-(temp[8*4+i])) : (-((temp[8*0+i])-(temp[8*4+i])))))
>            +((((temp[8*1+i])+(temp[8*5+i])) >= 0 ? ((temp[8*1+i])+(temp[8*5+i])) : (-((temp[8*1+i])+(temp[8*5+i])))) + (((temp[8*1+i])-(temp[8*5+i])) >= 0 ? ((temp[8*1+i])-(temp[8*5+i])) : (-((temp[8*1+i])-(temp[8*5+i])))))
>            +((((temp[8*2+i])+(temp[8*6+i])) >= 0 ? ((temp[8*2+i])+(temp[8*6+i])) : (-((temp[8*2+i])+(temp[8*6+i])))) + (((temp[8*2+i])-(temp[8*6+i])) >= 0 ? ((temp[8*2+i])-(temp[8*6+i])) : (-((temp[8*2+i])-(temp[8*6+i])))))
>            +((((temp[8*3+i])+(temp[8*7+i])) >= 0 ? ((temp[8*3+i])+(temp[8*7+i])) : (-((temp[8*3+i])+(temp[8*7+i])))) + (((temp[8*3+i])-(temp[8*7+i])) >= 0 ? ((temp[8*3+i])-(temp[8*7+i])) : (-((temp[8*3+i])-(temp[8*7+i])))));
>    }
>
>    sum -= ((temp[8*0] + temp[8*4]) >= 0 ? (temp[8*0] + temp[8*4]) : (-(temp[8*0] + temp[8*4])));
>
>    return sum;
>}
>
>static int dct_sad8x8_c( void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
>    MpegEncContext * const s= (MpegEncContext *)c;
>    uint64_t aligned_temp[sizeof(DCTELEM)*64/8] __attribute__ ((aligned (16)));
>    DCTELEM * const temp= (DCTELEM*)aligned_temp;
>
>    ((void) (0));
>
>    s->dsp.diff_pixels(temp, src1, src2, stride);
>    s->dsp.fdct(temp);
>    return s->dsp.sum_abs_dctelem(temp);
>}
># 3434 "dsputil.c"
>static int dct264_sad8x8_c( void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
>    MpegEncContext * const s= (MpegEncContext *)c;
>    int16_t dct[8][8];
>    int i;
>    int sum=0;
>
>    s->dsp.diff_pixels(dct, src1, src2, stride);
>
>
>
>    for( i = 0; i < 8; i++ )
>        { const int s07 = dct[i][0] + dct[i][7]; const int s16 = dct[i][1] + dct[i][6]; const int s25 = dct[i][2] + dct[i][5]; const int s34 = dct[i][3] + dct[i][4]; const int a0 = s07 + s34; const int a1 = s16 + s25; const int a2 = s07 - s34; const int a3 = s16 - s25; const int d07 = dct[i][0] - dct[i][7]; const int d16 = dct[i][1] - dct[i][6]; const int d25 = dct[i][2] - dct[i][5]; const int d34 = dct[i][3] - dct[i][4]; const int a4 = d16 + d25 + (d07 + (d07>>1)); const int a5 = d07 - d34 - (d25 + (d25>>1)); const int a6 = d07 + d34 - (d16 + (d16>>1)); const int a7 = d16 - d25 + (d34 + (d34>>1)); dct[i][0]= a0 + a1 ; dct[i][1]= a4 + (a7>>2) ; dct[i][2]= a2 + (a3>>1) ; dct[i][3]= a5 + (a6>>2) ; dct[i][4]= a0 - a1 ; dct[i][5]= a6 - (a5>>2) ; dct[i][6]= (a2>>1) - a3 ; dct[i][7]= (a4>>2) - a7 ;}
>
>
>
>
>
>    for( i = 0; i < 8; i++ )
>        { const int s07 = dct[0][i] + dct[7][i]; const int s16 = dct[1][i] + dct[6][i]; const int s25 = dct[2][i] + dct[5][i]; const int s34 = dct[3][i] + dct[4][i]; const int a0 = s07 + s34; const int a1 = s16 + s25; const int a2 = s07 - s34; const int a3 = s16 - s25; const int d07 = dct[0][i] - dct[7][i]; const int d16 = dct[1][i] - dct[6][i]; const int d25 = dct[2][i] - dct[5][i]; const int d34 = dct[3][i] - dct[4][i]; const int a4 = d16 + d25 + (d07 + (d07>>1)); const int a5 = d07 - d34 - (d25 + (d25>>1)); const int a6 = d07 + d34 - (d16 + (d16>>1)); const int a7 = d16 - d25 + (d34 + (d34>>1)); sum += ((a0 + a1) >= 0 ? (a0 + a1) : (-(a0 + a1))) ; sum += ((a4 + (a7>>2)) >= 0 ? (a4 + (a7>>2)) : (-(a4 + (a7>>2)))) ; sum += ((a2 + (a3>>1)) >= 0 ? (a2 + (a3>>1)) : (-(a2 + (a3>>1)))) ; sum += ((a5 + (a6>>2)) >= 0 ? (a5 + (a6>>2)) : (-(a5 + (a6>>2)))) ; sum += ((a0 - a1) >= 0 ? (a0 - a1) : (-(a0 - a1))) ; sum += ((a6 - (a5>>2)) >= 0 ? (a6 - (a5>>2)) : (-(a6 - (a5>>2)))) ; sum += (((a2>>1) - a3) >= 0 ? ((a2>>1) - a3) : (-((a2>>1) - a3))) ; sum += (((a4>>2) - a7) >= 0 ? ((a4>>2) - a7) : (-((a4>>2) - a7))) ;}
>
>
>    return sum;
>}
>
>
>static int dct_max8x8_c( void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
>    MpegEncContext * const s= (MpegEncContext *)c;
>    uint64_t aligned_temp[sizeof(DCTELEM)*64/8] __attribute__ ((aligned (8)));
>    DCTELEM * const temp= (DCTELEM*)aligned_temp;
>    int sum=0, i;
>
>    ((void) (0));
>
>    s->dsp.diff_pixels(temp, src1, src2, stride);
>    s->dsp.fdct(temp);
>
>    for(i=0; i<64; i++)
>        sum= ((sum) > (((temp[i]) >= 0 ? (temp[i]) : (-(temp[i])))) ? (sum) : (((temp[i]) >= 0 ? (temp[i]) : (-(temp[i])))));
>
>    return sum;
>}
>
>static int quant_psnr8x8_c( void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
>    MpegEncContext * const s= (MpegEncContext *)c;
>    uint64_t aligned_temp[sizeof(DCTELEM)*64*2/8] __attribute__ ((aligned (8)));
>    DCTELEM * const temp= (DCTELEM*)aligned_temp;
>    DCTELEM * const bak = ((DCTELEM*)aligned_temp)+64;
>    int sum=0, i;
>
>    ((void) (0));
>    s->mb_intra=0;
>
>    s->dsp.diff_pixels(temp, src1, src2, stride);
>
>    memcpy(bak, temp, 64*sizeof(DCTELEM));
>
>    s->block_last_index[0 ]= s->fast_dct_quantize(s, temp, 0 , s->qscale, &i);
>    s->dct_unquantize_inter(s, temp, 0, s->qscale);
>    simple_idct(temp);
>
>    for(i=0; i<64; i++)
>        sum+= (temp[i]-bak[i])*(temp[i]-bak[i]);
>
>    return sum;
>}
>
>static int rd8x8_c( void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
>    MpegEncContext * const s= (MpegEncContext *)c;
>    const uint8_t *scantable= s->intra_scantable.permutated;
>    uint64_t aligned_temp[sizeof(DCTELEM)*64/8] __attribute__ ((aligned (8)));
>    uint64_t aligned_bak[stride] __attribute__ ((aligned (8)));
>    DCTELEM * const temp= (DCTELEM*)aligned_temp;
>    uint8_t * const bak= (uint8_t*)aligned_bak;
>    int i, last, run, bits, level, distoration, start_i;
>    const int esc_length= s->ac_esc_length;
>    uint8_t * length;
>    uint8_t * last_length;
>
>    ((void) (0));
>
>    for(i=0; i<8; i++){
>        ((uint32_t*)(bak + i*stride))[0]= ((uint32_t*)(src2 + i*stride))[0];
>        ((uint32_t*)(bak + i*stride))[1]= ((uint32_t*)(src2 + i*stride))[1];
>    }
>
>    s->dsp.diff_pixels(temp, src1, src2, stride);
>
>    s->block_last_index[0 ]= last= s->fast_dct_quantize(s, temp, 0 , s->qscale, &i);
>
>    bits=0;
>
>    if (s->mb_intra) {
>        start_i = 1;
>        length = s->intra_ac_vlc_length;
>        last_length= s->intra_ac_vlc_last_length;
>        bits+= s->luma_dc_vlc_length[temp[0] + 256];
>    } else {
>        start_i = 0;
>        length = s->inter_ac_vlc_length;
>        last_length= s->inter_ac_vlc_last_length;
>    }
>
>    if(last>=start_i){
>        run=0;
>        for(i=start_i; i<last; i++){
>            int j= scantable[i];
>            level= temp[j];
>
>            if(level){
>                level+=64;
>                if((level&(~127)) == 0){
>                    bits+= length[((run)*128 + (level))];
>                }else
>                    bits+= esc_length;
>                run=0;
>            }else
>                run++;
>        }
>        i= scantable[last];
>
>        level= temp[i] + 64;
>
>        ((void) (0));
>
>        if((level&(~127)) == 0){
>            bits+= last_length[((run)*128 + (level))];
>        }else
>            bits+= esc_length;
>
>    }
>
>    if(last>=0){
>        if(s->mb_intra)
>            s->dct_unquantize_intra(s, temp, 0, s->qscale);
>        else
>            s->dct_unquantize_inter(s, temp, 0, s->qscale);
>    }
>
>    s->dsp.idct_add(bak, stride, temp);
>
>    distoration= s->dsp.sse[1](((void *)0), bak, src1, stride, 8);
>
>    return distoration + ((bits*s->qscale*s->qscale*109 + 64)>>7);
>}
>
>static int bit8x8_c( void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
>    MpegEncContext * const s= (MpegEncContext *)c;
>    const uint8_t *scantable= s->intra_scantable.permutated;
>    uint64_t aligned_temp[sizeof(DCTELEM)*64/8] __attribute__ ((aligned (8)));
>    DCTELEM * const temp= (DCTELEM*)aligned_temp;
>    int i, last, run, bits, level, start_i;
>    const int esc_length= s->ac_esc_length;
>    uint8_t * length;
>    uint8_t * last_length;
>
>    ((void) (0));
>
>    s->dsp.diff_pixels(temp, src1, src2, stride);
>
>    s->block_last_index[0 ]= last= s->fast_dct_quantize(s, temp, 0 , s->qscale, &i);
>
>    bits=0;
>
>    if (s->mb_intra) {
>        start_i = 1;
>        length = s->intra_ac_vlc_length;
>        last_length= s->intra_ac_vlc_last_length;
>        bits+= s->luma_dc_vlc_length[temp[0] + 256];
>    } else {
>        start_i = 0;
>        length = s->inter_ac_vlc_length;
>        last_length= s->inter_ac_vlc_last_length;
>    }
>
>    if(last>=start_i){
>        run=0;
>        for(i=start_i; i<last; i++){
>            int j= scantable[i];
>            level= temp[j];
>
>            if(level){
>                level+=64;
>                if((level&(~127)) == 0){
>                    bits+= length[((run)*128 + (level))];
>                }else
>                    bits+= esc_length;
>                run=0;
>            }else
>                run++;
>        }
>        i= scantable[last];
>
>        level= temp[i] + 64;
>
>        ((void) (0));
>
>        if((level&(~127)) == 0){
>            bits+= last_length[((run)*128 + (level))];
>        }else
>            bits+= esc_length;
>    }
>
>    return bits;
>}
>
>static int vsad_intra16_c( void *c, uint8_t *s, uint8_t *dummy, int stride, int h){
>    int score=0;
>    int x,y;
>
>    for(y=1; y<h; y++){
>        for(x=0; x<16; x+=4){
>            score+= ((s[x ] - s[x +stride]) >= 0 ? (s[x ] - s[x +stride]) : (-(s[x ] - s[x +stride]))) + ((s[x+1] - s[x+1+stride]) >= 0 ? (s[x+1] - s[x+1+stride]) : (-(s[x+1] - s[x+1+stride])))
>                   +((s[x+2] - s[x+2+stride]) >= 0 ? (s[x+2] - s[x+2+stride]) : (-(s[x+2] - s[x+2+stride]))) + ((s[x+3] - s[x+3+stride]) >= 0 ? (s[x+3] - s[x+3+stride]) : (-(s[x+3] - s[x+3+stride])));
>        }
>        s+= stride;
>    }
>
>    return score;
>}
>
>static int vsad16_c( void *c, uint8_t *s1, uint8_t *s2, int stride, int h){
>    int score=0;
>    int x,y;
>
>    for(y=1; y<h; y++){
>        for(x=0; x<16; x++){
>            score+= ((s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]) >= 0 ? (s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]) : (-(s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride])));
>        }
>        s1+= stride;
>        s2+= stride;
>    }
>
>    return score;
>}
>
>
>static int vsse_intra16_c( void *c, uint8_t *s, uint8_t *dummy, int stride, int h){
>    int score=0;
>    int x,y;
>
>    for(y=1; y<h; y++){
>        for(x=0; x<16; x+=4){
>            score+= ((s[x ] - s[x +stride])*(s[x ] - s[x +stride])) + ((s[x+1] - s[x+1+stride])*(s[x+1] - s[x+1+stride]))
>                   +((s[x+2] - s[x+2+stride])*(s[x+2] - s[x+2+stride])) + ((s[x+3] - s[x+3+stride])*(s[x+3] - s[x+3+stride]));
>        }
>        s+= stride;
>    }
>
>    return score;
>}
>
>static int vsse16_c( void *c, uint8_t *s1, uint8_t *s2, int stride, int h){
>    int score=0;
>    int x,y;
>
>    for(y=1; y<h; y++){
>        for(x=0; x<16; x++){
>            score+= ((s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride])*(s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]));
>        }
>        s1+= stride;
>        s2+= stride;
>    }
>
>    return score;
>}
>
>static int ssd_int8_vs_int16_c(int8_t *pix1, int16_t *pix2, int size){
>    int score=0;
>    int i;
>    for(i=0; i<size; i++)
>        score += (pix1[i]-pix2[i])*(pix1[i]-pix2[i]);
>    return score;
>}
>
>static int hadamard8_diff16_c(void *s, uint8_t *dst, uint8_t *src, int stride, int h){ int score=0; score +=hadamard8_diff8x8_c(s, dst , src , stride, 8); score +=hadamard8_diff8x8_c(s, dst+8 , src+8 , stride, 8); if(h==16){ dst += 8*stride; src += 8*stride; score +=hadamard8_diff8x8_c(s, dst , src , stride, 8); score +=hadamard8_diff8x8_c(s, dst+8 , src+8 , stride, 8); } return score;}
>static int hadamard8_intra16_c(void *s, uint8_t *dst, uint8_t *src, int stride, int h){ int score=0; score +=hadamard8_intra8x8_c(s, dst , src , stride, 8); score +=hadamard8_intra8x8_c(s, dst+8 , src+8 , stride, 8); if(h==16){ dst += 8*stride; src += 8*stride; score +=hadamard8_intra8x8_c(s, dst , src , stride, 8); score +=hadamard8_intra8x8_c(s, dst+8 , src+8 , stride, 8); } return score;}
>static int dct_sad16_c(void *s, uint8_t *dst, uint8_t *src, int stride, int h){ int score=0; score +=dct_sad8x8_c(s, dst , src , stride, 8); score +=dct_sad8x8_c(s, dst+8 , src+8 , stride, 8); if(h==16){ dst += 8*stride; src += 8*stride; score +=dct_sad8x8_c(s, dst , src , stride, 8); score +=dct_sad8x8_c(s, dst+8 , src+8 , stride, 8); } return score;}
>
>static int dct264_sad16_c(void *s, uint8_t *dst, uint8_t *src, int stride, int h){ int score=0; score +=dct264_sad8x8_c(s, dst , src , stride, 8); score +=dct264_sad8x8_c(s, dst+8 , src+8 , stride, 8); if(h==16){ dst += 8*stride; src += 8*stride; score +=dct264_sad8x8_c(s, dst , src , stride, 8); score +=dct264_sad8x8_c(s, dst+8 , src+8 , stride, 8); } return score;}
>
>static int dct_max16_c(void *s, uint8_t *dst, uint8_t *src, int stride, int h){ int score=0; score +=dct_max8x8_c(s, dst , src , stride, 8); score +=dct_max8x8_c(s, dst+8 , src+8 , stride, 8); if(h==16){ dst += 8*stride; src += 8*stride; score +=dct_max8x8_c(s, dst , src , stride, 8); score +=dct_max8x8_c(s, dst+8 , src+8 , stride, 8); } return score;}
>static int quant_psnr16_c(void *s, uint8_t *dst, uint8_t *src, int stride, int h){ int score=0; score +=quant_psnr8x8_c(s, dst , src , stride, 8); score +=quant_psnr8x8_c(s, dst+8 , src+8 , stride, 8); if(h==16){ dst += 8*stride; src += 8*stride; score +=quant_psnr8x8_c(s, dst , src , stride, 8); score +=quant_psnr8x8_c(s, dst+8 , src+8 , stride, 8); } return score;}
>static int rd16_c(void *s, uint8_t *dst, uint8_t *src, int stride, int h){ int score=0; score +=rd8x8_c(s, dst , src , stride, 8); score +=rd8x8_c(s, dst+8 , src+8 , stride, 8); if(h==16){ dst += 8*stride; src += 8*stride; score +=rd8x8_c(s, dst , src , stride, 8); score +=rd8x8_c(s, dst+8 , src+8 , stride, 8); } return score;}
>static int bit16_c(void *s, uint8_t *dst, uint8_t *src, int stride, int h){ int score=0; score +=bit8x8_c(s, dst , src , stride, 8); score +=bit8x8_c(s, dst+8 , src+8 , stride, 8); if(h==16){ dst += 8*stride; src += 8*stride; score +=bit8x8_c(s, dst , src , stride, 8); score +=bit8x8_c(s, dst+8 , src+8 , stride, 8); } return score;}
>
>static void vector_fmul_c(float *dst, const float *src, int len){
>    int i;
>    for(i=0; i<len; i++)
>        dst[i] *= src[i];
>}
>
>static void vector_fmul_reverse_c(float *dst, const float *src0, const float *src1, int len){
>    int i;
>    src1 += len-1;
>    for(i=0; i<len; i++)
>        dst[i] = src0[i] * src1[-i];
>}
>
>void ff_vector_fmul_add_add_c(float *dst, const float *src0, const float *src1, const float *src2, int src3, int len, int step){
>    int i;
>    for(i=0; i<len; i++)
>        dst[i*step] = src0[i] * src1[i] + src2[i] + src3;
>}
>
>void ff_float_to_int16_c(int16_t *dst, const float *src, int len){
>    int i;
>    for(i=0; i<len; i++) {
>        int_fast32_t tmp = ((int32_t*)src)[i];
>        if(tmp & 0xf0000){
>            tmp = (0x43c0ffff - tmp)>>31;
>
>
>
>        }
>        dst[i] = tmp - 0x8000;
>    }
>}
>
>
>
>static void ff_jref_idct_put(uint8_t *dest, int line_size, DCTELEM *block)
>{
>    j_rev_dct (block);
>    put_pixels_clamped_c(block, dest, line_size);
>}
>static void ff_jref_idct_add(uint8_t *dest, int line_size, DCTELEM *block)
>{
>    j_rev_dct (block);
>    add_pixels_clamped_c(block, dest, line_size);
>}
>
>static void ff_jref_idct4_put(uint8_t *dest, int line_size, DCTELEM *block)
>{
>    j_rev_dct4 (block);
>    put_pixels_clamped4_c(block, dest, line_size);
>}
>static void ff_jref_idct4_add(uint8_t *dest, int line_size, DCTELEM *block)
>{
>    j_rev_dct4 (block);
>    add_pixels_clamped4_c(block, dest, line_size);
>}
>
>static void ff_jref_idct2_put(uint8_t *dest, int line_size, DCTELEM *block)
>{
>    j_rev_dct2 (block);
>    put_pixels_clamped2_c(block, dest, line_size);
>}
>static void ff_jref_idct2_add(uint8_t *dest, int line_size, DCTELEM *block)
>{
>    j_rev_dct2 (block);
>    add_pixels_clamped2_c(block, dest, line_size);
>}
>
>static void ff_jref_idct1_put(uint8_t *dest, int line_size, DCTELEM *block)
>{
>    uint8_t *cm = ff_cropTbl + 1024;
>
>    dest[0] = cm[(block[0] + 4)>>3];
>}
>static void ff_jref_idct1_add(uint8_t *dest, int line_size, DCTELEM *block)
>{
>    uint8_t *cm = ff_cropTbl + 1024;
>
>    dest[0] = cm[dest[0] + ((block[0] + 4)>>3)];
>}
>
>static void just_return(void *mem __attribute__((unused)), int stride __attribute__((unused)), int h __attribute__((unused))) { return; }
>
>
>void dsputil_static_init(void)
>{
>    int i;
>
>    for(i=0;i<256;i++) ff_cropTbl[i + 1024] = i;
>    for(i=0;i<1024;i++) {
>        ff_cropTbl[i] = 0;
>        ff_cropTbl[i + 1024 + 256] = 255;
>    }
>
>    for(i=0;i<512;i++) {
>        ff_squareTbl[i] = (i - 256) * (i - 256);
>    }
>
>    for(i=0; i<64; i++) inv_zigzag_direct16[ff_zigzag_direct[i]]= i+1;
>}
>
>int ff_check_alignment(void){
>    static int did_fail=0;
>    int aligned __attribute__ ((aligned (16)));
>
>    if((int)&aligned & 15){
>        if(!did_fail){
>
>
>
>
>
>
>            did_fail=1;
>        }
>        return -1;
>    }
>    return 0;
>}
>
>void dsputil_init(DSPContext* c, AVCodecContext *avctx)
>{
>    int i;
>
>    ff_check_alignment();
>
>
>    if(avctx->dct_algo==1) {
>        c->fdct = fdct_ifast;
>        c->fdct248 = fdct_ifast248;
>    }
>    else if(avctx->dct_algo==6) {
>        c->fdct = ff_faandct;
>        c->fdct248 = ff_faandct248;
>    }
>    else {
>        c->fdct = ff_jpeg_fdct_islow;
>        c->fdct248 = ff_fdct248_islow;
>    }
>
>
>    if(avctx->lowres==1){
>        if(avctx->idct_algo==1 || avctx->idct_algo==0 || !1){
>            c->idct_put= ff_jref_idct4_put;
>            c->idct_add= ff_jref_idct4_add;
>        }else{
>            c->idct_put= ff_h264_lowres_idct_put_c;
>            c->idct_add= ff_h264_lowres_idct_add_c;
>        }
>        c->idct = j_rev_dct4;
>        c->idct_permutation_type= 1;
>    }else if(avctx->lowres==2){
>        c->idct_put= ff_jref_idct2_put;
>        c->idct_add= ff_jref_idct2_add;
>        c->idct = j_rev_dct2;
>        c->idct_permutation_type= 1;
>    }else if(avctx->lowres==3){
>        c->idct_put= ff_jref_idct1_put;
>        c->idct_add= ff_jref_idct1_add;
>        c->idct = j_rev_dct1;
>        c->idct_permutation_type= 1;
>    }else{
>        if(avctx->idct_algo==1){
>            c->idct_put= ff_jref_idct_put;
>            c->idct_add= ff_jref_idct_add;
>            c->idct = j_rev_dct;
>            c->idct_permutation_type= 2;
>        }else if((1 || 1 || 1 || 1 ) &&
>                avctx->idct_algo==12){
>            c->idct_put= ff_vp3_idct_put_c;
>            c->idct_add= ff_vp3_idct_add_c;
>            c->idct = ff_vp3_idct_c;
>            c->idct_permutation_type= 1;
>        }else{
>            c->idct_put= simple_idct_put;
>            c->idct_add= simple_idct_add;
>            c->idct = simple_idct;
>            c->idct_permutation_type= 1;
>        }
>    }
>
>    if (1) {
>        c->h264_idct_add= ff_h264_idct_add_c;
>        c->h264_idct8_add= ff_h264_idct8_add_c;
>        c->h264_idct_dc_add= ff_h264_idct_dc_add_c;
>        c->h264_idct8_dc_add= ff_h264_idct8_dc_add_c;
>    }
>
>    c->get_pixels = get_pixels_c;
>    c->diff_pixels = diff_pixels_c;
>    c->put_pixels_clamped = put_pixels_clamped_c;
>    c->put_signed_pixels_clamped = put_signed_pixels_clamped_c;
>    c->add_pixels_clamped = add_pixels_clamped_c;
>    c->add_pixels8 = add_pixels8_c;
>    c->add_pixels4 = add_pixels4_c;
>    c->sum_abs_dctelem = sum_abs_dctelem_c;
>    c->gmc1 = gmc1_c;
>    c->gmc = ff_gmc_c;
>    c->clear_blocks = clear_blocks_c;
>    c->pix_sum = pix_sum_c;
>    c->pix_norm1 = pix_norm1_c;
>
>
>    c->pix_abs[0][0] = pix_abs16_c;
>    c->pix_abs[0][1] = pix_abs16_x2_c;
>    c->pix_abs[0][2] = pix_abs16_y2_c;
>    c->pix_abs[0][3] = pix_abs16_xy2_c;
>    c->pix_abs[1][0] = pix_abs8_c;
>    c->pix_abs[1][1] = pix_abs8_x2_c;
>    c->pix_abs[1][2] = pix_abs8_y2_c;
>    c->pix_abs[1][3] = pix_abs8_xy2_c;
>
>
>
>
>
>
>
>    c->put_pixels_tab[0][0] = put_pixels16_c; c->put_pixels_tab[0][1] = put_pixels16_x2_c; c->put_pixels_tab[0][2] = put_pixels16_y2_c; c->put_pixels_tab[0][3] = put_pixels16_xy2_c;
>    c->put_no_rnd_pixels_tab[0][0] = put_no_rnd_pixels16_c; c->put_no_rnd_pixels_tab[0][1] = put_no_rnd_pixels16_x2_c; c->put_no_rnd_pixels_tab[0][2] = put_no_rnd_pixels16_y2_c; c->put_no_rnd_pixels_tab[0][3] = put_no_rnd_pixels16_xy2_c;
>    c->put_pixels_tab[1][0] = put_pixels8_c; c->put_pixels_tab[1][1] = put_pixels8_x2_c; c->put_pixels_tab[1][2] = put_pixels8_y2_c; c->put_pixels_tab[1][3] = put_pixels8_xy2_c;
>    c->put_no_rnd_pixels_tab[1][0] = put_no_rnd_pixels8_c; c->put_no_rnd_pixels_tab[1][1] = put_no_rnd_pixels8_x2_c; c->put_no_rnd_pixels_tab[1][2] = put_no_rnd_pixels8_y2_c; c->put_no_rnd_pixels_tab[1][3] = put_no_rnd_pixels8_xy2_c;
>    c->put_pixels_tab[2][0] = put_pixels4_c; c->put_pixels_tab[2][1] = put_pixels4_x2_c; c->put_pixels_tab[2][2] = put_pixels4_y2_c; c->put_pixels_tab[2][3] = put_pixels4_xy2_c;
>    c->put_pixels_tab[3][0] = put_pixels2_c; c->put_pixels_tab[3][1] = put_pixels2_x2_c; c->put_pixels_tab[3][2] = put_pixels2_y2_c; c->put_pixels_tab[3][3] = put_pixels2_xy2_c;
>
>    c->avg_pixels_tab[0][0] = avg_pixels16_c; c->avg_pixels_tab[0][1] = avg_pixels16_x2_c; c->avg_pixels_tab[0][2] = avg_pixels16_y2_c; c->avg_pixels_tab[0][3] = avg_pixels16_xy2_c;
>    c->avg_no_rnd_pixels_tab[0][0] = avg_no_rnd_pixels16_c; c->avg_no_rnd_pixels_tab[0][1] = avg_no_rnd_pixels16_x2_c; c->avg_no_rnd_pixels_tab[0][2] = avg_no_rnd_pixels16_y2_c; c->avg_no_rnd_pixels_tab[0][3] = avg_no_rnd_pixels16_xy2_c;
>    c->avg_pixels_tab[1][0] = avg_pixels8_c; c->avg_pixels_tab[1][1] = avg_pixels8_x2_c; c->avg_pixels_tab[1][2] = avg_pixels8_y2_c; c->avg_pixels_tab[1][3] = avg_pixels8_xy2_c;
>    c->avg_no_rnd_pixels_tab[1][0] = avg_no_rnd_pixels8_c; c->avg_no_rnd_pixels_tab[1][1] = avg_no_rnd_pixels8_x2_c; c->avg_no_rnd_pixels_tab[1][2] = avg_no_rnd_pixels8_y2_c; c->avg_no_rnd_pixels_tab[1][3] = avg_no_rnd_pixels8_xy2_c;
>    c->avg_pixels_tab[2][0] = avg_pixels4_c; c->avg_pixels_tab[2][1] = avg_pixels4_x2_c; c->avg_pixels_tab[2][2] = avg_pixels4_y2_c; c->avg_pixels_tab[2][3] = avg_pixels4_xy2_c;
>    c->avg_pixels_tab[3][0] = avg_pixels2_c; c->avg_pixels_tab[3][1] = avg_pixels2_x2_c; c->avg_pixels_tab[3][2] = avg_pixels2_y2_c; c->avg_pixels_tab[3][3] = avg_pixels2_xy2_c;
>
>
>    c->put_no_rnd_pixels_l2[0]= put_no_rnd_pixels16_l2_c;
>    c->put_no_rnd_pixels_l2[1]= put_no_rnd_pixels8_l2_c;
>
>    c->put_tpel_pixels_tab[ 0] = put_tpel_pixels_mc00_c;
>    c->put_tpel_pixels_tab[ 1] = put_tpel_pixels_mc10_c;
>    c->put_tpel_pixels_tab[ 2] = put_tpel_pixels_mc20_c;
>    c->put_tpel_pixels_tab[ 4] = put_tpel_pixels_mc01_c;
>    c->put_tpel_pixels_tab[ 5] = put_tpel_pixels_mc11_c;
>    c->put_tpel_pixels_tab[ 6] = put_tpel_pixels_mc21_c;
>    c->put_tpel_pixels_tab[ 8] = put_tpel_pixels_mc02_c;
>    c->put_tpel_pixels_tab[ 9] = put_tpel_pixels_mc12_c;
>    c->put_tpel_pixels_tab[10] = put_tpel_pixels_mc22_c;
>
>    c->avg_tpel_pixels_tab[ 0] = avg_tpel_pixels_mc00_c;
>    c->avg_tpel_pixels_tab[ 1] = avg_tpel_pixels_mc10_c;
>    c->avg_tpel_pixels_tab[ 2] = avg_tpel_pixels_mc20_c;
>    c->avg_tpel_pixels_tab[ 4] = avg_tpel_pixels_mc01_c;
>    c->avg_tpel_pixels_tab[ 5] = avg_tpel_pixels_mc11_c;
>    c->avg_tpel_pixels_tab[ 6] = avg_tpel_pixels_mc21_c;
>    c->avg_tpel_pixels_tab[ 8] = avg_tpel_pixels_mc02_c;
>    c->avg_tpel_pixels_tab[ 9] = avg_tpel_pixels_mc12_c;
>    c->avg_tpel_pixels_tab[10] = avg_tpel_pixels_mc22_c;
># 3993 "dsputil.c"
>    c->put_qpel_pixels_tab[0][ 0] = put_qpel16_mc00_c; c->put_qpel_pixels_tab[0][ 1] = put_qpel16_mc10_c; c->put_qpel_pixels_tab[0][ 2] = put_qpel16_mc20_c; c->put_qpel_pixels_tab[0][ 3] = put_qpel16_mc30_c; c->put_qpel_pixels_tab[0][ 4] = put_qpel16_mc01_c; c->put_qpel_pixels_tab[0][ 5] = put_qpel16_mc11_c; c->put_qpel_pixels_tab[0][ 6] = put_qpel16_mc21_c; c->put_qpel_pixels_tab[0][ 7] = put_qpel16_mc31_c; c->put_qpel_pixels_tab[0][ 8] = put_qpel16_mc02_c; c->put_qpel_pixels_tab[0][ 9] = put_qpel16_mc12_c; c->put_qpel_pixels_tab[0][10] = put_qpel16_mc22_c; c->put_qpel_pixels_tab[0][11] = put_qpel16_mc32_c; c->put_qpel_pixels_tab[0][12] = put_qpel16_mc03_c; c->put_qpel_pixels_tab[0][13] = put_qpel16_mc13_c; c->put_qpel_pixels_tab[0][14] = put_qpel16_mc23_c; c->put_qpel_pixels_tab[0][15] = put_qpel16_mc33_c;
>    c->put_no_rnd_qpel_pixels_tab[0][ 0] = put_no_rnd_qpel16_mc00_c; c->put_no_rnd_qpel_pixels_tab[0][ 1] = put_no_rnd_qpel16_mc10_c; c->put_no_rnd_qpel_pixels_tab[0][ 2] = put_no_rnd_qpel16_mc20_c; c->put_no_rnd_qpel_pixels_tab[0][ 3] = put_no_rnd_qpel16_mc30_c; c->put_no_rnd_qpel_pixels_tab[0][ 4] = put_no_rnd_qpel16_mc01_c; c->put_no_rnd_qpel_pixels_tab[0][ 5] = put_no_rnd_qpel16_mc11_c; c->put_no_rnd_qpel_pixels_tab[0][ 6] = put_no_rnd_qpel16_mc21_c; c->put_no_rnd_qpel_pixels_tab[0][ 7] = put_no_rnd_qpel16_mc31_c; c->put_no_rnd_qpel_pixels_tab[0][ 8] = put_no_rnd_qpel16_mc02_c; c->put_no_rnd_qpel_pixels_tab[0][ 9] = put_no_rnd_qpel16_mc12_c; c->put_no_rnd_qpel_pixels_tab[0][10] = put_no_rnd_qpel16_mc22_c; c->put_no_rnd_qpel_pixels_tab[0][11] = put_no_rnd_qpel16_mc32_c; c->put_no_rnd_qpel_pixels_tab[0][12] = put_no_rnd_qpel16_mc03_c; c->put_no_rnd_qpel_pixels_tab[0][13] = put_no_rnd_qpel16_mc13_c; c->put_no_rnd_qpel_pixels_tab[0][14] = put_no_rnd_qpel16_mc23_c; c->put_no_rnd_qpel_pixels_tab[0][15] = put_no_rnd_qpel16_mc33_c;
>
>    c->avg_qpel_pixels_tab[0][ 0] = avg_qpel16_mc00_c; c->avg_qpel_pixels_tab[0][ 1] = avg_qpel16_mc10_c; c->avg_qpel_pixels_tab[0][ 2] = avg_qpel16_mc20_c; c->avg_qpel_pixels_tab[0][ 3] = avg_qpel16_mc30_c; c->avg_qpel_pixels_tab[0][ 4] = avg_qpel16_mc01_c; c->avg_qpel_pixels_tab[0][ 5] = avg_qpel16_mc11_c; c->avg_qpel_pixels_tab[0][ 6] = avg_qpel16_mc21_c; c->avg_qpel_pixels_tab[0][ 7] = avg_qpel16_mc31_c; c->avg_qpel_pixels_tab[0][ 8] = avg_qpel16_mc02_c; c->avg_qpel_pixels_tab[0][ 9] = avg_qpel16_mc12_c; c->avg_qpel_pixels_tab[0][10] = avg_qpel16_mc22_c; c->avg_qpel_pixels_tab[0][11] = avg_qpel16_mc32_c; c->avg_qpel_pixels_tab[0][12] = avg_qpel16_mc03_c; c->avg_qpel_pixels_tab[0][13] = avg_qpel16_mc13_c; c->avg_qpel_pixels_tab[0][14] = avg_qpel16_mc23_c; c->avg_qpel_pixels_tab[0][15] = avg_qpel16_mc33_c;
>
>
>    c->put_qpel_pixels_tab[1][ 0] = put_qpel8_mc00_c; c->put_qpel_pixels_tab[1][ 1] = put_qpel8_mc10_c; c->put_qpel_pixels_tab[1][ 2] = put_qpel8_mc20_c; c->put_qpel_pixels_tab[1][ 3] = put_qpel8_mc30_c; c->put_qpel_pixels_tab[1][ 4] = put_qpel8_mc01_c; c->put_qpel_pixels_tab[1][ 5] = put_qpel8_mc11_c; c->put_qpel_pixels_tab[1][ 6] = put_qpel8_mc21_c; c->put_qpel_pixels_tab[1][ 7] = put_qpel8_mc31_c; c->put_qpel_pixels_tab[1][ 8] = put_qpel8_mc02_c; c->put_qpel_pixels_tab[1][ 9] = put_qpel8_mc12_c; c->put_qpel_pixels_tab[1][10] = put_qpel8_mc22_c; c->put_qpel_pixels_tab[1][11] = put_qpel8_mc32_c; c->put_qpel_pixels_tab[1][12] = put_qpel8_mc03_c; c->put_qpel_pixels_tab[1][13] = put_qpel8_mc13_c; c->put_qpel_pixels_tab[1][14] = put_qpel8_mc23_c; c->put_qpel_pixels_tab[1][15] = put_qpel8_mc33_c;
>    c->put_no_rnd_qpel_pixels_tab[1][ 0] = put_no_rnd_qpel8_mc00_c; c->put_no_rnd_qpel_pixels_tab[1][ 1] = put_no_rnd_qpel8_mc10_c; c->put_no_rnd_qpel_pixels_tab[1][ 2] = put_no_rnd_qpel8_mc20_c; c->put_no_rnd_qpel_pixels_tab[1][ 3] = put_no_rnd_qpel8_mc30_c; c->put_no_rnd_qpel_pixels_tab[1][ 4] = put_no_rnd_qpel8_mc01_c; c->put_no_rnd_qpel_pixels_tab[1][ 5] = put_no_rnd_qpel8_mc11_c; c->put_no_rnd_qpel_pixels_tab[1][ 6] = put_no_rnd_qpel8_mc21_c; c->put_no_rnd_qpel_pixels_tab[1][ 7] = put_no_rnd_qpel8_mc31_c; c->put_no_rnd_qpel_pixels_tab[1][ 8] = put_no_rnd_qpel8_mc02_c; c->put_no_rnd_qpel_pixels_tab[1][ 9] = put_no_rnd_qpel8_mc12_c; c->put_no_rnd_qpel_pixels_tab[1][10] = put_no_rnd_qpel8_mc22_c; c->put_no_rnd_qpel_pixels_tab[1][11] = put_no_rnd_qpel8_mc32_c; c->put_no_rnd_qpel_pixels_tab[1][12] = put_no_rnd_qpel8_mc03_c; c->put_no_rnd_qpel_pixels_tab[1][13] = put_no_rnd_qpel8_mc13_c; c->put_no_rnd_qpel_pixels_tab[1][14] = put_no_rnd_qpel8_mc23_c; c->put_no_rnd_qpel_pixels_tab[1][15] = put_no_rnd_qpel8_mc33_c;
>
>    c->avg_qpel_pixels_tab[1][ 0] = avg_qpel8_mc00_c; c->avg_qpel_pixels_tab[1][ 1] = avg_qpel8_mc10_c; c->avg_qpel_pixels_tab[1][ 2] = avg_qpel8_mc20_c; c->avg_qpel_pixels_tab[1][ 3] = avg_qpel8_mc30_c; c->avg_qpel_pixels_tab[1][ 4] = avg_qpel8_mc01_c; c->avg_qpel_pixels_tab[1][ 5] = avg_qpel8_mc11_c; c->avg_qpel_pixels_tab[1][ 6] = avg_qpel8_mc21_c; c->avg_qpel_pixels_tab[1][ 7] = avg_qpel8_mc31_c; c->avg_qpel_pixels_tab[1][ 8] = avg_qpel8_mc02_c; c->avg_qpel_pixels_tab[1][ 9] = avg_qpel8_mc12_c; c->avg_qpel_pixels_tab[1][10] = avg_qpel8_mc22_c; c->avg_qpel_pixels_tab[1][11] = avg_qpel8_mc32_c; c->avg_qpel_pixels_tab[1][12] = avg_qpel8_mc03_c; c->avg_qpel_pixels_tab[1][13] = avg_qpel8_mc13_c; c->avg_qpel_pixels_tab[1][14] = avg_qpel8_mc23_c; c->avg_qpel_pixels_tab[1][15] = avg_qpel8_mc33_c;
>
>
>    c->put_h264_qpel_pixels_tab[0][ 0] = put_h264_qpel16_mc00_c; c->put_h264_qpel_pixels_tab[0][ 1] = put_h264_qpel16_mc10_c; c->put_h264_qpel_pixels_tab[0][ 2] = put_h264_qpel16_mc20_c; c->put_h264_qpel_pixels_tab[0][ 3] = put_h264_qpel16_mc30_c; c->put_h264_qpel_pixels_tab[0][ 4] = put_h264_qpel16_mc01_c; c->put_h264_qpel_pixels_tab[0][ 5] = put_h264_qpel16_mc11_c; c->put_h264_qpel_pixels_tab[0][ 6] = put_h264_qpel16_mc21_c; c->put_h264_qpel_pixels_tab[0][ 7] = put_h264_qpel16_mc31_c; c->put_h264_qpel_pixels_tab[0][ 8] = put_h264_qpel16_mc02_c; c->put_h264_qpel_pixels_tab[0][ 9] = put_h264_qpel16_mc12_c; c->put_h264_qpel_pixels_tab[0][10] = put_h264_qpel16_mc22_c; c->put_h264_qpel_pixels_tab[0][11] = put_h264_qpel16_mc32_c; c->put_h264_qpel_pixels_tab[0][12] = put_h264_qpel16_mc03_c; c->put_h264_qpel_pixels_tab[0][13] = put_h264_qpel16_mc13_c; c->put_h264_qpel_pixels_tab[0][14] = put_h264_qpel16_mc23_c; c->put_h264_qpel_pixels_tab[0][15] = put_h264_qpel16_mc33_c;
>    c->put_h264_qpel_pixels_tab[1][ 0] = put_h264_qpel8_mc00_c; c->put_h264_qpel_pixels_tab[1][ 1] = put_h264_qpel8_mc10_c; c->put_h264_qpel_pixels_tab[1][ 2] = put_h264_qpel8_mc20_c; c->put_h264_qpel_pixels_tab[1][ 3] = put_h264_qpel8_mc30_c; c->put_h264_qpel_pixels_tab[1][ 4] = put_h264_qpel8_mc01_c; c->put_h264_qpel_pixels_tab[1][ 5] = put_h264_qpel8_mc11_c; c->put_h264_qpel_pixels_tab[1][ 6] = put_h264_qpel8_mc21_c; c->put_h264_qpel_pixels_tab[1][ 7] = put_h264_qpel8_mc31_c; c->put_h264_qpel_pixels_tab[1][ 8] = put_h264_qpel8_mc02_c; c->put_h264_qpel_pixels_tab[1][ 9] = put_h264_qpel8_mc12_c; c->put_h264_qpel_pixels_tab[1][10] = put_h264_qpel8_mc22_c; c->put_h264_qpel_pixels_tab[1][11] = put_h264_qpel8_mc32_c; c->put_h264_qpel_pixels_tab[1][12] = put_h264_qpel8_mc03_c; c->put_h264_qpel_pixels_tab[1][13] = put_h264_qpel8_mc13_c; c->put_h264_qpel_pixels_tab[1][14] = put_h264_qpel8_mc23_c; c->put_h264_qpel_pixels_tab[1][15] = put_h264_qpel8_mc33_c;
>    c->put_h264_qpel_pixels_tab[2][ 0] = put_h264_qpel4_mc00_c; c->put_h264_qpel_pixels_tab[2][ 1] = put_h264_qpel4_mc10_c; c->put_h264_qpel_pixels_tab[2][ 2] = put_h264_qpel4_mc20_c; c->put_h264_qpel_pixels_tab[2][ 3] = put_h264_qpel4_mc30_c; c->put_h264_qpel_pixels_tab[2][ 4] = put_h264_qpel4_mc01_c; c->put_h264_qpel_pixels_tab[2][ 5] = put_h264_qpel4_mc11_c; c->put_h264_qpel_pixels_tab[2][ 6] = put_h264_qpel4_mc21_c; c->put_h264_qpel_pixels_tab[2][ 7] = put_h264_qpel4_mc31_c; c->put_h264_qpel_pixels_tab[2][ 8] = put_h264_qpel4_mc02_c; c->put_h264_qpel_pixels_tab[2][ 9] = put_h264_qpel4_mc12_c; c->put_h264_qpel_pixels_tab[2][10] = put_h264_qpel4_mc22_c; c->put_h264_qpel_pixels_tab[2][11] = put_h264_qpel4_mc32_c; c->put_h264_qpel_pixels_tab[2][12] = put_h264_qpel4_mc03_c; c->put_h264_qpel_pixels_tab[2][13] = put_h264_qpel4_mc13_c; c->put_h264_qpel_pixels_tab[2][14] = put_h264_qpel4_mc23_c; c->put_h264_qpel_pixels_tab[2][15] = put_h264_qpel4_mc33_c;
>    c->put_h264_qpel_pixels_tab[3][ 0] = put_h264_qpel2_mc00_c; c->put_h264_qpel_pixels_tab[3][ 1] = put_h264_qpel2_mc10_c; c->put_h264_qpel_pixels_tab[3][ 2] = put_h264_qpel2_mc20_c; c->put_h264_qpel_pixels_tab[3][ 3] = put_h264_qpel2_mc30_c; c->put_h264_qpel_pixels_tab[3][ 4] = put_h264_qpel2_mc01_c; c->put_h264_qpel_pixels_tab[3][ 5] = put_h264_qpel2_mc11_c; c->put_h264_qpel_pixels_tab[3][ 6] = put_h264_qpel2_mc21_c; c->put_h264_qpel_pixels_tab[3][ 7] = put_h264_qpel2_mc31_c; c->put_h264_qpel_pixels_tab[3][ 8] = put_h264_qpel2_mc02_c; c->put_h264_qpel_pixels_tab[3][ 9] = put_h264_qpel2_mc12_c; c->put_h264_qpel_pixels_tab[3][10] = put_h264_qpel2_mc22_c; c->put_h264_qpel_pixels_tab[3][11] = put_h264_qpel2_mc32_c; c->put_h264_qpel_pixels_tab[3][12] = put_h264_qpel2_mc03_c; c->put_h264_qpel_pixels_tab[3][13] = put_h264_qpel2_mc13_c; c->put_h264_qpel_pixels_tab[3][14] = put_h264_qpel2_mc23_c; c->put_h264_qpel_pixels_tab[3][15] = put_h264_qpel2_mc33_c;
>    c->avg_h264_qpel_pixels_tab[0][ 0] = avg_h264_qpel16_mc00_c; c->avg_h264_qpel_pixels_tab[0][ 1] = avg_h264_qpel16_mc10_c; c->avg_h264_qpel_pixels_tab[0][ 2] = avg_h264_qpel16_mc20_c; c->avg_h264_qpel_pixels_tab[0][ 3] = avg_h264_qpel16_mc30_c; c->avg_h264_qpel_pixels_tab[0][ 4] = avg_h264_qpel16_mc01_c; c->avg_h264_qpel_pixels_tab[0][ 5] = avg_h264_qpel16_mc11_c; c->avg_h264_qpel_pixels_tab[0][ 6] = avg_h264_qpel16_mc21_c; c->avg_h264_qpel_pixels_tab[0][ 7] = avg_h264_qpel16_mc31_c; c->avg_h264_qpel_pixels_tab[0][ 8] = avg_h264_qpel16_mc02_c; c->avg_h264_qpel_pixels_tab[0][ 9] = avg_h264_qpel16_mc12_c; c->avg_h264_qpel_pixels_tab[0][10] = avg_h264_qpel16_mc22_c; c->avg_h264_qpel_pixels_tab[0][11] = avg_h264_qpel16_mc32_c; c->avg_h264_qpel_pixels_tab[0][12] = avg_h264_qpel16_mc03_c; c->avg_h264_qpel_pixels_tab[0][13] = avg_h264_qpel16_mc13_c; c->avg_h264_qpel_pixels_tab[0][14] = avg_h264_qpel16_mc23_c; c->avg_h264_qpel_pixels_tab[0][15] = avg_h264_qpel16_mc33_c;
>    c->avg_h264_qpel_pixels_tab[1][ 0] = avg_h264_qpel8_mc00_c; c->avg_h264_qpel_pixels_tab[1][ 1] = avg_h264_qpel8_mc10_c; c->avg_h264_qpel_pixels_tab[1][ 2] = avg_h264_qpel8_mc20_c; c->avg_h264_qpel_pixels_tab[1][ 3] = avg_h264_qpel8_mc30_c; c->avg_h264_qpel_pixels_tab[1][ 4] = avg_h264_qpel8_mc01_c; c->avg_h264_qpel_pixels_tab[1][ 5] = avg_h264_qpel8_mc11_c; c->avg_h264_qpel_pixels_tab[1][ 6] = avg_h264_qpel8_mc21_c; c->avg_h264_qpel_pixels_tab[1][ 7] = avg_h264_qpel8_mc31_c; c->avg_h264_qpel_pixels_tab[1][ 8] = avg_h264_qpel8_mc02_c; c->avg_h264_qpel_pixels_tab[1][ 9] = avg_h264_qpel8_mc12_c; c->avg_h264_qpel_pixels_tab[1][10] = avg_h264_qpel8_mc22_c; c->avg_h264_qpel_pixels_tab[1][11] = avg_h264_qpel8_mc32_c; c->avg_h264_qpel_pixels_tab[1][12] = avg_h264_qpel8_mc03_c; c->avg_h264_qpel_pixels_tab[1][13] = avg_h264_qpel8_mc13_c; c->avg_h264_qpel_pixels_tab[1][14] = avg_h264_qpel8_mc23_c; c->avg_h264_qpel_pixels_tab[1][15] = avg_h264_qpel8_mc33_c;
>    c->avg_h264_qpel_pixels_tab[2][ 0] = avg_h264_qpel4_mc00_c; c->avg_h264_qpel_pixels_tab[2][ 1] = avg_h264_qpel4_mc10_c; c->avg_h264_qpel_pixels_tab[2][ 2] = avg_h264_qpel4_mc20_c; c->avg_h264_qpel_pixels_tab[2][ 3] = avg_h264_qpel4_mc30_c; c->avg_h264_qpel_pixels_tab[2][ 4] = avg_h264_qpel4_mc01_c; c->avg_h264_qpel_pixels_tab[2][ 5] = avg_h264_qpel4_mc11_c; c->avg_h264_qpel_pixels_tab[2][ 6] = avg_h264_qpel4_mc21_c; c->avg_h264_qpel_pixels_tab[2][ 7] = avg_h264_qpel4_mc31_c; c->avg_h264_qpel_pixels_tab[2][ 8] = avg_h264_qpel4_mc02_c; c->avg_h264_qpel_pixels_tab[2][ 9] = avg_h264_qpel4_mc12_c; c->avg_h264_qpel_pixels_tab[2][10] = avg_h264_qpel4_mc22_c; c->avg_h264_qpel_pixels_tab[2][11] = avg_h264_qpel4_mc32_c; c->avg_h264_qpel_pixels_tab[2][12] = avg_h264_qpel4_mc03_c; c->avg_h264_qpel_pixels_tab[2][13] = avg_h264_qpel4_mc13_c; c->avg_h264_qpel_pixels_tab[2][14] = avg_h264_qpel4_mc23_c; c->avg_h264_qpel_pixels_tab[2][15] = avg_h264_qpel4_mc33_c;
>
>
>    c->put_h264_chroma_pixels_tab[0]= put_h264_chroma_mc8_c;
>    c->put_h264_chroma_pixels_tab[1]= put_h264_chroma_mc4_c;
>    c->put_h264_chroma_pixels_tab[2]= put_h264_chroma_mc2_c;
>    c->avg_h264_chroma_pixels_tab[0]= avg_h264_chroma_mc8_c;
>    c->avg_h264_chroma_pixels_tab[1]= avg_h264_chroma_mc4_c;
>    c->avg_h264_chroma_pixels_tab[2]= avg_h264_chroma_mc2_c;
>    c->put_no_rnd_h264_chroma_pixels_tab[0]= put_no_rnd_h264_chroma_mc8_c;
>
>    c->weight_h264_pixels_tab[0]= weight_h264_pixels16x16_c;
>    c->weight_h264_pixels_tab[1]= weight_h264_pixels16x8_c;
>    c->weight_h264_pixels_tab[2]= weight_h264_pixels8x16_c;
>    c->weight_h264_pixels_tab[3]= weight_h264_pixels8x8_c;
>    c->weight_h264_pixels_tab[4]= weight_h264_pixels8x4_c;
>    c->weight_h264_pixels_tab[5]= weight_h264_pixels4x8_c;
>    c->weight_h264_pixels_tab[6]= weight_h264_pixels4x4_c;
>    c->weight_h264_pixels_tab[7]= weight_h264_pixels4x2_c;
>    c->weight_h264_pixels_tab[8]= weight_h264_pixels2x4_c;
>    c->weight_h264_pixels_tab[9]= weight_h264_pixels2x2_c;
>    c->biweight_h264_pixels_tab[0]= biweight_h264_pixels16x16_c;
>    c->biweight_h264_pixels_tab[1]= biweight_h264_pixels16x8_c;
>    c->biweight_h264_pixels_tab[2]= biweight_h264_pixels8x16_c;
>    c->biweight_h264_pixels_tab[3]= biweight_h264_pixels8x8_c;
>    c->biweight_h264_pixels_tab[4]= biweight_h264_pixels8x4_c;
>    c->biweight_h264_pixels_tab[5]= biweight_h264_pixels4x8_c;
>    c->biweight_h264_pixels_tab[6]= biweight_h264_pixels4x4_c;
>    c->biweight_h264_pixels_tab[7]= biweight_h264_pixels4x2_c;
>    c->biweight_h264_pixels_tab[8]= biweight_h264_pixels2x4_c;
>    c->biweight_h264_pixels_tab[9]= biweight_h264_pixels2x2_c;
>
>
>    ff_cavsdsp_init(c,avctx);
>
>
>    ff_vc1dsp_init(c,avctx);
>
>
>
>
>
>    c->put_mspel_pixels_tab[0]= put_mspel8_mc00_c;
>    c->put_mspel_pixels_tab[1]= put_mspel8_mc10_c;
>    c->put_mspel_pixels_tab[2]= put_mspel8_mc20_c;
>    c->put_mspel_pixels_tab[3]= put_mspel8_mc30_c;
>    c->put_mspel_pixels_tab[4]= put_mspel8_mc02_c;
>    c->put_mspel_pixels_tab[5]= put_mspel8_mc12_c;
>    c->put_mspel_pixels_tab[6]= put_mspel8_mc22_c;
>    c->put_mspel_pixels_tab[7]= put_mspel8_mc32_c;
>
>
>
>
>
>    c->hadamard8_diff[0]= hadamard8_diff16_c; c->hadamard8_diff[1]= hadamard8_diff8x8_c;
>    c->hadamard8_diff[4]= hadamard8_intra16_c;
>    c->dct_sad[0]= dct_sad16_c; c->dct_sad[1]= dct_sad8x8_c;
>    c->dct_max[0]= dct_max16_c; c->dct_max[1]= dct_max8x8_c;
>
>    c->dct264_sad[0]= dct264_sad16_c; c->dct264_sad[1]= dct264_sad8x8_c;
>
>    c->sad[0]= pix_abs16_c;
>    c->sad[1]= pix_abs8_c;
>    c->sse[0]= sse16_c;
>    c->sse[1]= sse8_c;
>    c->sse[2]= sse4_c;
>    c->quant_psnr[0]= quant_psnr16_c; c->quant_psnr[1]= quant_psnr8x8_c;
>    c->rd[0]= rd16_c; c->rd[1]= rd8x8_c;
>    c->bit[0]= bit16_c; c->bit[1]= bit8x8_c;
>    c->vsad[0]= vsad16_c;
>    c->vsad[4]= vsad_intra16_c;
>    c->vsse[0]= vsse16_c;
>    c->vsse[4]= vsse_intra16_c;
>    c->nsse[0]= nsse16_c;
>    c->nsse[1]= nsse8_c;
>
>    c->w53[0]= w53_16_c;
>    c->w53[1]= w53_8_c;
>    c->w97[0]= w97_16_c;
>    c->w97[1]= w97_8_c;
>
>
>    c->ssd_int8_vs_int16 = ssd_int8_vs_int16_c;
>
>    c->add_bytes= add_bytes_c;
>    c->diff_bytes= diff_bytes_c;
>    c->sub_hfyu_median_prediction= sub_hfyu_median_prediction_c;
>    c->bswap_buf= bswap_buf;
>
>    c->h264_v_loop_filter_luma= h264_v_loop_filter_luma_c;
>    c->h264_h_loop_filter_luma= h264_h_loop_filter_luma_c;
>    c->h264_v_loop_filter_chroma= h264_v_loop_filter_chroma_c;
>    c->h264_h_loop_filter_chroma= h264_h_loop_filter_chroma_c;
>    c->h264_v_loop_filter_chroma_intra= h264_v_loop_filter_chroma_intra_c;
>    c->h264_h_loop_filter_chroma_intra= h264_h_loop_filter_chroma_intra_c;
>    c->h264_loop_filter_strength= ((void *)0);
>
>    c->h263_h_loop_filter= h263_h_loop_filter_c;
>    c->h263_v_loop_filter= h263_v_loop_filter_c;
>
>    c->h261_loop_filter= h261_loop_filter_c;
>
>    c->try_8x8basis= try_8x8basis_c;
>    c->add_8x8basis= add_8x8basis_c;
>
>
>    c->vertical_compose97i = ff_snow_vertical_compose97i;
>    c->horizontal_compose97i = ff_snow_horizontal_compose97i;
>    c->inner_add_yblock = ff_snow_inner_add_yblock;
>
>
>
>    c->vorbis_inverse_coupling = vorbis_inverse_coupling;
>
>    c->vector_fmul = vector_fmul_c;
>    c->vector_fmul_reverse = vector_fmul_reverse_c;
>    c->vector_fmul_add_add = ff_vector_fmul_add_add_c;
>    c->float_to_int16 = ff_float_to_int16_c;
>
>    c->shrink[0]= ff_img_copy_plane;
>    c->shrink[1]= ff_shrink22;
>    c->shrink[2]= ff_shrink44;
>    c->shrink[3]= ff_shrink88;
>
>    c->prefetch= just_return;
>
>    memset(c->put_2tap_qpel_pixels_tab, 0, sizeof(c->put_2tap_qpel_pixels_tab));
>    memset(c->avg_2tap_qpel_pixels_tab, 0, sizeof(c->avg_2tap_qpel_pixels_tab));
>
>    if (0) dsputil_init_mmx (c, avctx);
>    if (0) dsputil_init_armv4l(c, avctx);
>    if (0) dsputil_init_mlib (c, avctx);
>    if (0) dsputil_init_vis (c, avctx);
>    if (0) dsputil_init_alpha (c, avctx);
>    if (0) dsputil_init_ppc (c, avctx);
>    if (0) dsputil_init_mmi (c, avctx);
>    if (0) dsputil_init_sh4 (c, avctx);
>    if (0) dsputil_init_bfin (c, avctx);
>
>    for(i=0; i<64; i++){
>        if(!c->put_2tap_qpel_pixels_tab[0][i])
>            c->put_2tap_qpel_pixels_tab[0][i]= c->put_h264_qpel_pixels_tab[0][i];
>        if(!c->avg_2tap_qpel_pixels_tab[0][i])
>            c->avg_2tap_qpel_pixels_tab[0][i]= c->avg_h264_qpel_pixels_tab[0][i];
>    }
>
>    switch(c->idct_permutation_type){
>    case 1:
>        for(i=0; i<64; i++)
>            c->idct_permutation[i]= i;
>        break;
>    case 2:
>        for(i=0; i<64; i++)
>            c->idct_permutation[i]= (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
>        break;
>    case 3:
>        for(i=0; i<64; i++)
>            c->idct_permutation[i]= simple_mmx_permutation[i];
>        break;
>    case 4:
>        for(i=0; i<64; i++)
>            c->idct_permutation[i]= ((i&7)<<3) | (i>>3);
>        break;
>    case 5:
>        for(i=0; i<64; i++)
>            c->idct_permutation[i]= (i&0x24) | ((i&3)<<3) | ((i>>3)&3);
>        break;
>    default:
>        av_log(avctx, 0, "Internal error, IDCT permutation not set\n");
>    }
>}

Actions: View

Attachments on bug 223453: 154137 | 154139 | 154141