Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Thu, 9 Aug 2012 17:09:39 +0000 (19:09 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Thu, 9 Aug 2012 17:31:56 +0000 (19:31 +0200)
* qatar/master:
  mpegvideo: reduce excessive inlining of mpeg_motion()
  mpegvideo: convert mpegvideo_common.h to a .c file
  build: factor out mpegvideo.o dependencies to CONFIG_MPEGVIDEO
  Move MASK_ABS macro to libavcodec/mathops.h
  x86: move MANGLE() and related macros to libavutil/x86/asm.h
  x86: rename libavutil/x86_cpu.h to libavutil/x86/asm.h
  aacdec: Don't fall back to the old output configuration when no old configuration is present.
  rtmp: Add message tracking
  rtsp: Support mpegts in raw udp packets
  rtsp: Support receiving plain data over UDP without any RTP encapsulation
  rtpdec: Remove an unused include
  rtpenc: Remove an av_abort() that depends on user-supplied data
  vsrc_movie: discourage its use with avconv.
  avconv: allow no input files.
  avconv: prevent invalid reads in transcode_init()
  avconv: rename OutputStream.is_past_recording_time to finished.

Conflicts:
configure
doc/filters.texi
ffmpeg.c
ffmpeg.h
libavcodec/Makefile
libavcodec/aacdec.c
libavcodec/mpegvideo.c
libavformat/version.h

Merged-by: Michael Niedermayer <michaelni@gmx.at>
55 files changed:
1  2 
configure
doc/ffmpeg.texi
ffmpeg.c
ffmpeg.h
libavcodec/Makefile
libavcodec/aacdec.c
libavcodec/dnxhdenc.c
libavcodec/mathops.h
libavcodec/mpeg12enc.c
libavcodec/mpegvideo.c
libavcodec/mpegvideo.h
libavcodec/mpegvideo_enc.c
libavcodec/mpegvideo_motion.c
libavcodec/msmpeg4.c
libavcodec/x86/ac3dsp_mmx.c
libavcodec/x86/cabac.h
libavcodec/x86/cavsdsp_mmx.c
libavcodec/x86/dnxhd_mmx.c
libavcodec/x86/dsputil_mmx.c
libavcodec/x86/dsputil_mmx.h
libavcodec/x86/dsputilenc_mmx.c
libavcodec/x86/dwt.c
libavcodec/x86/fdct_mmx.c
libavcodec/x86/fmtconvert_mmx.c
libavcodec/x86/h264dsp_mmx.c
libavcodec/x86/idct_mmx.c
libavcodec/x86/idct_sse2_xvid.c
libavcodec/x86/lpc_mmx.c
libavcodec/x86/mathops.h
libavcodec/x86/mlpdsp.c
libavcodec/x86/motion_est_mmx.c
libavcodec/x86/mpegaudiodec_mmx.c
libavcodec/x86/mpegvideo_mmx.c
libavcodec/x86/snowdsp_mmx.c
libavcodec/x86/vc1dsp_mmx.c
libavcodec/x86/vp56dsp_init.c
libavcodec/x86/vp8dsp-init.c
libavfilter/x86/gradfun.c
libavfilter/x86/yadif.c
libavformat/rtmpproto.c
libavformat/rtpdec_h264.c
libavformat/rtpenc.c
libavformat/rtsp.c
libavformat/rtsp.h
libavformat/version.h
libavutil/internal.h
libavutil/x86/asm.h
libavutil/x86/cpu.c
libavutil/x86_cpu.h
libpostproc/postprocess_template.c
libswresample/x86/resample_mmx.h
libswscale/utils.c
libswscale/x86/rgb2rgb.c
libswscale/x86/swscale.c
libswscale/x86/yuv2rgb.c

diff --cc configure
+++ b/configure
@@@ -1504,15 -1354,13 +1505,15 @@@ cavs_decoder_select="golomb mpegvideo
  cook_decoder_select="mdct sinewin"
  cscd_decoder_suggest="zlib"
  dca_decoder_select="mdct"
- dnxhd_encoder_select="aandcttables"
 +dirac_decoder_select="dwt golomb"
+ dnxhd_encoder_select="aandcttables mpegvideo"
  dxa_decoder_select="zlib"
  eac3_decoder_select="ac3_decoder"
  eac3_encoder_select="mdct ac3dsp"
  eamad_decoder_select="aandcttables"
  eatgq_decoder_select="aandcttables"
- eatqi_decoder_select="aandcttables"
+ eatqi_decoder_select="aandcttables mpegvideo"
 +exr_decoder_select="zlib"
  ffv1_decoder_select="golomb"
  flac_decoder_select="golomb"
  flac_encoder_select="golomb lpc"
@@@ -1529,8 -1377,7 +1531,8 @@@ h263_encoder_select="aandcttables mpegv
  h263_vaapi_hwaccel_select="vaapi h263_decoder"
  h263i_decoder_select="h263_decoder"
  h263p_encoder_select="h263_encoder"
- h264_decoder_select="golomb h264chroma h264dsp h264pred h264qpel"
 +h264_crystalhd_decoder_select="crystalhd h264_mp4toannexb_bsf h264_parser"
+ h264_decoder_select="golomb h264chroma h264dsp h264pred h264qpel mpegvideo"
  h264_dxva2_hwaccel_deps="dxva2api_h"
  h264_dxva2_hwaccel_select="dxva2 h264_decoder"
  h264_vaapi_hwaccel_select="vaapi h264_decoder"
@@@ -1561,15 -1408,13 +1564,17 @@@ mpeg_vdpau_decoder_select="vdpau mpegvi
  mpeg_xvmc_decoder_deps="X11_extensions_XvMClib_h"
  mpeg_xvmc_decoder_select="mpegvideo_decoder"
  mpeg1_vdpau_decoder_select="vdpau mpeg1video_decoder"
- mpeg1video_encoder_select="aandcttables"
 +mpeg1_vdpau_hwaccel_select="vdpau mpeg1video_decoder"
+ mpeg1video_decoder_select="mpegvideo"
+ mpeg1video_encoder_select="aandcttables mpegvideo"
 +mpeg2_crystalhd_decoder_select="crystalhd"
  mpeg2_dxva2_hwaccel_deps="dxva2api_h"
  mpeg2_dxva2_hwaccel_select="dxva2 mpeg2video_decoder"
 +mpeg2_vdpau_hwaccel_select="vdpau mpeg2video_decoder"
  mpeg2_vaapi_hwaccel_select="vaapi mpeg2video_decoder"
- mpeg2video_encoder_select="aandcttables"
+ mpeg2video_encoder_select="mpegvideo"
+ mpeg2video_encoder_select="aandcttables mpegvideo"
 +mpeg4_crystalhd_decoder_select="crystalhd"
  mpeg4_decoder_select="h263_decoder mpeg4video_parser"
  mpeg4_encoder_select="h263_encoder"
  mpeg4_vaapi_hwaccel_select="vaapi mpeg4_decoder"
@@@ -1598,12 -1442,10 +1603,13 @@@ rv40_decoder_select="golomb h264chroma 
  shorten_decoder_select="golomb"
  sipr_decoder_select="lsp"
  snow_decoder_select="dwt"
- snow_encoder_select="aandcttables dwt"
+ snow_encoder_select="aandcttables dwt mpegvideo"
 +sonic_decoder_select="golomb"
 +sonic_encoder_select="golomb"
 +sonic_ls_encoder_select="golomb"
- svq1_encoder_select="aandcttables"
- svq3_decoder_select="golomb h264chroma h264dsp h264pred h264qpel"
+ svq1_encoder_select="mpegvideo"
+ svq1_encoder_select="aandcttables mpegvideo"
+ svq3_decoder_select="golomb h264chroma h264dsp h264pred h264qpel mpegvideo"
  svq3_decoder_suggest="zlib"
  theora_decoder_select="vp3_decoder"
  tiff_decoder_suggest="zlib"
@@@ -1653,11 -1493,12 +1659,14 @@@ vda_deps="VideoDecodeAcceleration_VDADe
  vdpau_deps="vdpau_vdpau_h vdpau_vdpau_x11_h"
  
  # parsers
- h264_parser_select="golomb h264dsp h264pred"
+ h264_parser_select="golomb h264dsp h264pred mpegvideo"
+ mpeg4video_parser_select="mpegvideo"
+ mpegvideo_parser_select="mpegvideo"
+ vc1_parser_select="mpegvideo"
  
  # external libraries
 +libaacplus_encoder_deps="libaacplus"
 +libcelt_decoder_deps="libcelt"
  libfaac_encoder_deps="libfaac"
  libfdk_aac_encoder_deps="libfdk_aac"
  libgsm_decoder_deps="libgsm"
diff --cc doc/ffmpeg.texi
@@@ -965,9 -805,12 +965,12 @@@ the matching type
  Output link labels are referred to with @option{-map}. Unlabeled outputs are
  added to the first output file.
  
+ Note that with this option it is possible to use only lavfi sources without
+ normal input files.
  For example, to overlay an image over video
  @example
 -avconv -i video.mkv -i image.png -filter_complex '[0:v][1:v]overlay[out]' -map
 +ffmpeg -i video.mkv -i image.png -filter_complex '[0:v][1:v]overlay[out]' -map
  '[out]' out.mkv
  @end example
  Here @code{[0:v]} refers to the first video stream in the first input file,
@@@ -985,58 -828,14 +988,63 @@@ ffmpeg -i video.mkv -i image.png -filte
  Furthermore we can omit the output label and the single output from the filter
  graph will be added to the output file automatically, so we can simply write
  @example
 -avconv -i video.mkv -i image.png -filter_complex 'overlay' out.mkv
 +ffmpeg -i video.mkv -i image.png -filter_complex 'overlay' out.mkv
  @end example
 -avconv -filter_complex 'color=red' -t 5 out.mkv
+ To generate 5 seconds of pure red video using lavfi @code{color} source:
+ @example
++ffmpeg -filter_complex 'color=red' -t 5 out.mkv
+ @end example
  @end table
 +
 +As a special exception, you can use a bitmap subtitle stream as input: it
 +will be converted into a video with the same size as the largest video in
 +the file, or 720×576 if no video is present. Note that this is an
 +experimental and temporary solution. It will be removed once libavfilter has
 +proper support for subtitles.
 +
 +For example, to hardcode subtitles on top of a DVB-T recording stored in
 +MPEG-TS format, delaying the subtitles by 1 second:
 +@example
 +ffmpeg -i input.ts -filter_complex \
 +  '[#0x2ef] setpts=PTS+1/TB [sub] ; [#0x2d0] [sub] overlay' \
 +  -sn -map '#0x2dc' output.mkv
 +@end example
 +(0x2d0, 0x2dc and 0x2ef are the MPEG-TS PIDs of respectively the video,
 +audio and subtitles streams; 0:0, 0:3 and 0:7 would have worked too)
 +
 +@section Preset files
 +A preset file contains a sequence of @var{option}=@var{value} pairs,
 +one for each line, specifying a sequence of options which would be
 +awkward to specify on the command line. Lines starting with the hash
 +('#') character are ignored and are used to provide comments. Check
 +the @file{presets} directory in the FFmpeg source tree for examples.
 +
 +Preset files are specified with the @code{vpre}, @code{apre},
 +@code{spre}, and @code{fpre} options. The @code{fpre} option takes the
 +filename of the preset instead of a preset name as input and can be
 +used for any kind of codec. For the @code{vpre}, @code{apre}, and
 +@code{spre} options, the options specified in a preset file are
 +applied to the currently selected codec of the same type as the preset
 +option.
 +
 +The argument passed to the @code{vpre}, @code{apre}, and @code{spre}
 +preset options identifies the preset file to use according to the
 +following rules:
 +
 +First ffmpeg searches for a file named @var{arg}.ffpreset in the
 +directories @file{$FFMPEG_DATADIR} (if set), and @file{$HOME/.ffmpeg}, and in
 +the datadir defined at configuration time (usually @file{PREFIX/share/ffmpeg})
 +or in a @file{ffpresets} folder along the executable on win32,
 +in that order. For example, if the argument is @code{libvpx-1080p}, it will
 +search for the file @file{libvpx-1080p.ffpreset}.
 +
 +If no such file is found, then ffmpeg will search for a file named
 +@var{codec_name}-@var{arg}.ffpreset in the above-mentioned
 +directories, where @var{codec_name} is the name of the codec to which
 +the preset file options will be applied. For example, if you select
 +the video codec with @code{-vcodec libvpx} and use @code{-vpre 1080p},
 +then it will search for the file @file{libvpx-1080p.ffpreset}.
  @c man end OPTIONS
  
  @chapter Tips
diff --cc ffmpeg.c
+++ b/ffmpeg.c
@@@ -1314,8 -981,8 +1314,8 @@@ static void do_streamcopy(InputStream *
          return;
  
      if (of->recording_time != INT64_MAX &&
 -        ist->last_dts >= of->recording_time + of->start_time) {
 +        ist->pts >= of->recording_time + of->start_time) {
-         ost->is_past_recording_time = 1;
+         ost->finished = 1;
          return;
      }
  
@@@ -2383,177 -1949,27 +2384,177 @@@ static int need_output(void
      return 0;
  }
  
 -static InputFile *select_input_file(void)
 +static int input_acceptable(InputStream *ist)
  {
 -    InputFile *ifile = NULL;
 -    int64_t ipts_min = INT64_MAX;
 -    int i;
 +    av_assert1(!ist->discard);
 +    return !input_files[ist->file_index]->eagain &&
 +           !input_files[ist->file_index]->eof_reached;
 +}
  
 -    for (i = 0; i < nb_input_streams; i++) {
 -        InputStream *ist = input_streams[i];
 -        int64_t ipts     = ist->last_dts;
 +static int find_graph_input(FilterGraph *graph)
 +{
 +    int i, nb_req_max = 0, file_index = -1;
 +
 +    for (i = 0; i < graph->nb_inputs; i++) {
 +        int nb_req = av_buffersrc_get_nb_failed_requests(graph->inputs[i]->filter);
 +        if (nb_req > nb_req_max) {
 +            InputStream *ist = graph->inputs[i]->ist;
 +            if (input_acceptable(ist)) {
 +                nb_req_max = nb_req;
 +                file_index = ist->file_index;
 +            }
 +        }
 +    }
  
 -        if (ist->discard || input_files[ist->file_index]->eagain)
 -            continue;
 -        if (!input_files[ist->file_index]->eof_reached) {
 -            if (ipts < ipts_min) {
 -                ipts_min = ipts;
 -                ifile    = input_files[ist->file_index];
 +    return file_index;
 +}
 +
 +/**
 + * Select the input file to read from.
 + *
 + * @return  >=0 index of the input file to use;
 + *          -1  if no file is acceptable;
 + *          -2  to read from filters without reading from a file
 + */
 +static int select_input_file(void)
 +{
 +    int i, ret, nb_active_out = nb_output_streams, ost_index = -1;
 +    int64_t opts_min;
 +    OutputStream *ost;
 +    AVFilterBufferRef *dummy;
 +
 +    for (i = 0; i < nb_output_streams; i++)
 +        nb_active_out -= output_streams[i]->unavailable =
-             output_streams[i]->is_past_recording_time;
++            output_streams[i]->finished;
 +    while (nb_active_out) {
 +        opts_min = INT64_MAX;
 +        ost_index = -1;
 +        for (i = 0; i < nb_output_streams; i++) {
 +            OutputStream *ost = output_streams[i];
 +            int64_t opts = av_rescale_q(ost->st->cur_dts, ost->st->time_base,
 +                                        AV_TIME_BASE_Q);
 +            if (!ost->unavailable && opts < opts_min) {
 +                opts_min  = opts;
 +                ost_index = i;
              }
          }
 +        if (ost_index < 0)
 +            return -1;
 +
 +        ost = output_streams[ost_index];
 +        if (ost->source_index >= 0) {
 +            /* ost is directly connected to an input */
 +            InputStream *ist = input_streams[ost->source_index];
 +            if (input_acceptable(ist))
 +                return ist->file_index;
 +        } else {
 +            /* ost is connected to a complex filtergraph */
 +            av_assert1(ost->filter);
 +            ret = av_buffersink_get_buffer_ref(ost->filter->filter, &dummy,
 +                                               AV_BUFFERSINK_FLAG_PEEK);
 +            if (ret >= 0)
 +                return -2;
 +            ret = find_graph_input(ost->filter->graph);
 +            if (ret >= 0)
 +                return ret;
 +        }
 +        ost->unavailable = 1;
 +        nb_active_out--;
      }
 +    return -1;
 +}
  
 -    return ifile;
 +static int check_keyboard_interaction(int64_t cur_time)
 +{
 +    int i, ret, key;
 +    static int64_t last_time;
 +    if (received_nb_signals)
 +        return AVERROR_EXIT;
 +    /* read_key() returns 0 on EOF */
 +    if(cur_time - last_time >= 100000 && !run_as_daemon){
 +        key =  read_key();
 +        last_time = cur_time;
 +    }else
 +        key = -1;
 +    if (key == 'q')
 +        return AVERROR_EXIT;
 +    if (key == '+') av_log_set_level(av_log_get_level()+10);
 +    if (key == '-') av_log_set_level(av_log_get_level()-10);
 +    if (key == 's') qp_hist     ^= 1;
 +    if (key == 'h'){
 +        if (do_hex_dump){
 +            do_hex_dump = do_pkt_dump = 0;
 +        } else if(do_pkt_dump){
 +            do_hex_dump = 1;
 +        } else
 +            do_pkt_dump = 1;
 +        av_log_set_level(AV_LOG_DEBUG);
 +    }
 +    if (key == 'c' || key == 'C'){
 +        char buf[4096], target[64], command[256], arg[256] = {0};
 +        double time;
 +        int k, n = 0;
 +        fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
 +        i = 0;
 +        while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
 +            if (k > 0)
 +                buf[i++] = k;
 +        buf[i] = 0;
 +        if (k > 0 &&
 +            (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
 +            av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
 +                   target, time, command, arg);
 +            for (i = 0; i < nb_filtergraphs; i++) {
 +                FilterGraph *fg = filtergraphs[i];
 +                if (fg->graph) {
 +                    if (time < 0) {
 +                        ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
 +                                                          key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
 +                        fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
 +                    } else {
 +                        ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
 +                    }
 +                }
 +            }
 +        } else {
 +            av_log(NULL, AV_LOG_ERROR,
 +                   "Parse error, at least 3 arguments were expected, "
 +                   "only %d given in string '%s'\n", n, buf);
 +        }
 +    }
 +    if (key == 'd' || key == 'D'){
 +        int debug=0;
 +        if(key == 'D') {
 +            debug = input_streams[0]->st->codec->debug<<1;
 +            if(!debug) debug = 1;
 +            while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
 +                debug += debug;
 +        }else
 +            if(scanf("%d", &debug)!=1)
 +                fprintf(stderr,"error parsing debug value\n");
 +        for(i=0;i<nb_input_streams;i++) {
 +            input_streams[i]->st->codec->debug = debug;
 +        }
 +        for(i=0;i<nb_output_streams;i++) {
 +            OutputStream *ost = output_streams[i];
 +            ost->st->codec->debug = debug;
 +        }
 +        if(debug) av_log_set_level(AV_LOG_DEBUG);
 +        fprintf(stderr,"debug=%d\n", debug);
 +    }
 +    if (key == '?'){
 +        fprintf(stderr, "key    function\n"
 +                        "?      show this help\n"
 +                        "+      increase verbosity\n"
 +                        "-      decrease verbosity\n"
 +                        "c      Send command to filtergraph\n"
 +                        "D      cycle through available debug modes\n"
 +                        "h      dump packets/hex press to cycle through the 3 states\n"
 +                        "q      quit\n"
 +                        "s      Show QP histogram\n"
 +        );
 +    }
 +    return 0;
  }
  
  #if HAVE_PTHREADS
@@@ -3078,12 -2431,7 +3079,12 @@@ int main(int argc, char **argv
          exit_program(1);
      }
  
-     if (nb_input_files == 0) {
-         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
-         exit_program(1);
-     }
 -    ti = getutime();
++//     if (nb_input_files == 0) {
++//         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
++//         exit_program(1);
++//     }
 +
 +    current_time = ti = getutime();
      if (transcode() < 0)
          exit_program(1);
      ti = getutime() - ti;
diff --cc ffmpeg.h
+++ b/ffmpeg.h
@@@ -303,11 -287,8 +303,11 @@@ typedef struct OutputStream 
      char *avfilter;
  
      int64_t sws_flags;
 +    int64_t swr_dither_method;
 +    double swr_dither_scale;
      AVDictionary *opts;
-     int is_past_recording_time;
+     int finished;        /* no more packets should be written for this stream */
 +    int unavailable;                     /* true if the steram is unavailable (possibly temporarily) */
      int stream_copy;
      const char *attachment_filename;
      int copy_initial_nonkeyframes;
@@@ -200,16 -174,13 +198,13 @@@ OBJS-$(CONFIG_GIF_DECODER)             
  OBJS-$(CONFIG_GIF_ENCODER)             += gif.o lzwenc.o
  OBJS-$(CONFIG_GSM_DECODER)             += gsmdec.o gsmdec_data.o msgsmdec.o
  OBJS-$(CONFIG_GSM_MS_DECODER)          += gsmdec.o gsmdec_data.o msgsmdec.o
- OBJS-$(CONFIG_H261_DECODER)            += h261dec.o h261.o h261data.o  \
-                                           mpegvideo.o error_resilience.o
 -OBJS-$(CONFIG_H261_DECODER)            += h261dec.o h261.o error_resilience.o
 -OBJS-$(CONFIG_H261_ENCODER)            += h261enc.o h261.o             \
++OBJS-$(CONFIG_H261_DECODER)            += h261dec.o h261.o h261data.o error_resilience.o
 +OBJS-$(CONFIG_H261_ENCODER)            += h261enc.o h261.o h261data.o  \
                                            mpegvideo_enc.o motion_est.o \
-                                           ratecontrol.o mpeg12data.o   \
-                                           mpegvideo.o
+                                           ratecontrol.o mpeg12data.o
  OBJS-$(CONFIG_H263_DECODER)            += h263dec.o h263.o ituh263dec.o        \
                                            mpeg4video.o mpeg4videodec.o flvdec.o\
-                                           intelh263dec.o mpegvideo.o           \
-                                           error_resilience.o
+                                           intelh263dec.o  error_resilience.o
  OBJS-$(CONFIG_H263_VAAPI_HWACCEL)      += vaapi_mpeg4.o
  OBJS-$(CONFIG_H263_ENCODER)            += mpegvideo_enc.o mpeg4video.o      \
                                            mpeg4videoenc.o motion_est.o      \
@@@ -256,8 -222,7 +250,8 @@@ OBJS-$(CONFIG_LOCO_DECODER)            
  OBJS-$(CONFIG_MACE3_DECODER)           += mace.o
  OBJS-$(CONFIG_MACE6_DECODER)           += mace.o
  OBJS-$(CONFIG_MDEC_DECODER)            += mdec.o mpeg12.o mpeg12data.o \
-                                           mpegvideo.o error_resilience.o
+                                           error_resilience.o
 +OBJS-$(CONFIG_MICRODVD_DECODER)        += microdvddec.o ass.o
  OBJS-$(CONFIG_MIMIC_DECODER)           += mimic.o
  OBJS-$(CONFIG_MJPEG_DECODER)           += mjpegdec.o mjpeg.o
  OBJS-$(CONFIG_MJPEG_ENCODER)           += mjpegenc.o mjpeg.o           \
@@@ -300,25 -262,21 +293,25 @@@ OBJS-$(CONFIG_MPC7_DECODER)            
  OBJS-$(CONFIG_MPC8_DECODER)            += mpc8.o mpc.o mpegaudiodec.o      \
                                            mpegaudiodecheader.o mpegaudio.o \
                                            mpegaudiodata.o
 +OBJS-$(CONFIG_MPEGVIDEO_DECODER)       += mpeg12.o mpeg12data.o \
 +                                          mpegvideo.o error_resilience.o
  OBJS-$(CONFIG_MPEG_XVMC_DECODER)       += mpegvideo_xvmc.o
  OBJS-$(CONFIG_MPEG1VIDEO_DECODER)      += mpeg12.o mpeg12data.o \
-                                           mpegvideo.o error_resilience.o
+                                           error_resilience.o
  OBJS-$(CONFIG_MPEG1VIDEO_ENCODER)      += mpeg12enc.o mpegvideo_enc.o \
 +                                          timecode.o                  \
                                            motion_est.o ratecontrol.o  \
                                            mpeg12.o mpeg12data.o       \
-                                           mpegvideo.o error_resilience.o
+                                           error_resilience.o
  OBJS-$(CONFIG_MPEG2_DXVA2_HWACCEL)     += dxva2_mpeg2.o
  OBJS-$(CONFIG_MPEG2_VAAPI_HWACCEL)     += vaapi_mpeg2.o
  OBJS-$(CONFIG_MPEG2VIDEO_DECODER)      += mpeg12.o mpeg12data.o \
-                                           mpegvideo.o error_resilience.o
+                                           error_resilience.o
  OBJS-$(CONFIG_MPEG2VIDEO_ENCODER)      += mpeg12enc.o mpegvideo_enc.o \
 +                                          timecode.o                  \
                                            motion_est.o ratecontrol.o  \
                                            mpeg12.o mpeg12data.o       \
-                                           mpegvideo.o error_resilience.o
+                                           error_resilience.o
  OBJS-$(CONFIG_MPEG4_VAAPI_HWACCEL)     += vaapi_mpeg4.o
  OBJS-$(CONFIG_MSMPEG4V1_DECODER)       += msmpeg4.o msmpeg4data.o
  OBJS-$(CONFIG_MSMPEG4V2_DECODER)       += msmpeg4.o msmpeg4data.o h263dec.o \
@@@ -400,12 -349,10 +393,12 @@@ OBJS-$(CONFIG_RV10_ENCODER)            
  OBJS-$(CONFIG_RV20_DECODER)            += rv10.o
  OBJS-$(CONFIG_RV20_ENCODER)            += rv20enc.o
  OBJS-$(CONFIG_RV30_DECODER)            += rv30.o rv34.o rv30dsp.o rv34dsp.o \
-                                           mpegvideo.o error_resilience.o
+                                           error_resilience.o
  OBJS-$(CONFIG_RV40_DECODER)            += rv40.o rv34.o rv34dsp.o rv40dsp.o \
-                                           mpegvideo.o error_resilience.o
+                                           error_resilience.o
 +OBJS-$(CONFIG_SAMI_DECODER)            += samidec.o ass.o
  OBJS-$(CONFIG_S302M_DECODER)           += s302m.o
 +OBJS-$(CONFIG_SANM_DECODER)            += sanm.o
  OBJS-$(CONFIG_SGI_DECODER)             += sgidec.o
  OBJS-$(CONFIG_SGI_ENCODER)             += sgienc.o rle.o
  OBJS-$(CONFIG_SHORTEN_DECODER)         += shorten.o
@@@ -647,21 -577,19 +640,21 @@@ OBJS-$(CONFIG_MATROSKA_AUDIO_MUXER)    
                                            flac.o flacdata.o
  OBJS-$(CONFIG_MATROSKA_DEMUXER)        += mpeg4audio.o mpegaudiodata.o
  OBJS-$(CONFIG_MATROSKA_MUXER)          += mpeg4audio.o mpegaudiodata.o  \
 -                                          flac.o flacdata.o xiph.o
 +                                          flac.o flacdata.o vorbis_data.o xiph.o
  OBJS-$(CONFIG_MP2_MUXER)               += mpegaudiodata.o mpegaudiodecheader.o
  OBJS-$(CONFIG_MP3_MUXER)               += mpegaudiodata.o mpegaudiodecheader.o
 -OBJS-$(CONFIG_MOV_DEMUXER)             += mpeg4audio.o mpegaudiodata.o ac3tab.o
 +OBJS-$(CONFIG_MOV_DEMUXER)             += mpeg4audio.o mpegaudiodata.o ac3tab.o timecode.o
  OBJS-$(CONFIG_MOV_MUXER)               += mpeg4audio.o mpegaudiodata.o
- OBJS-$(CONFIG_MPEGTS_MUXER)            += mpegvideo.o mpeg4audio.o
+ OBJS-$(CONFIG_MPEGTS_MUXER)            += mpeg4audio.o
  OBJS-$(CONFIG_MPEGTS_DEMUXER)          += mpeg4audio.o mpegaudiodata.o
 +OBJS-$(CONFIG_MXF_MUXER)               += timecode.o
  OBJS-$(CONFIG_NUT_MUXER)               += mpegaudiodata.o
  OBJS-$(CONFIG_OGG_DEMUXER)             += xiph.o flac.o flacdata.o     \
                                            mpeg12data.o vorbis_parser.o \
 -                                          dirac.o
 -OBJS-$(CONFIG_OGG_MUXER)               += xiph.o flac.o flacdata.o
 +                                          dirac.o vorbis_data.o
 +OBJS-$(CONFIG_OGG_MUXER)               += xiph.o flac.o flacdata.o \
 +                                          vorbis_data.o
- OBJS-$(CONFIG_RTP_MUXER)               += mpeg4audio.o mpegvideo.o xiph.o
+ OBJS-$(CONFIG_RTP_MUXER)               += mpeg4audio.o xiph.o
  OBJS-$(CONFIG_SPDIF_DEMUXER)           += aacadtsdec.o mpeg4audio.o
  OBJS-$(CONFIG_SPDIF_MUXER)             += dca.o
  OBJS-$(CONFIG_WEBM_MUXER)              += mpeg4audio.o mpegaudiodata.o  \
@@@ -742,10 -656,9 +735,10 @@@ OBJS-$(CONFIG_AAC_LATM_PARSER)         
  OBJS-$(CONFIG_MJPEG_PARSER)            += mjpeg_parser.o
  OBJS-$(CONFIG_MLP_PARSER)              += mlp_parser.o mlp.o
  OBJS-$(CONFIG_MPEG4VIDEO_PARSER)       += mpeg4video_parser.o h263.o \
-                                           mpegvideo.o error_resilience.o \
+                                           error_resilience.o \
                                            mpeg4videodec.o mpeg4video.o \
                                            ituh263dec.o h263dec.o
 +OBJS-$(CONFIG_PNG_PARSER)              += png_parser.o
  OBJS-$(CONFIG_MPEGAUDIO_PARSER)        += mpegaudio_parser.o \
                                            mpegaudiodecheader.o mpegaudiodata.o
  OBJS-$(CONFIG_MPEGVIDEO_PARSER)        += mpegvideo_parser.o    \
Simple merge
@@@ -31,9 -31,7 +31,8 @@@
  #include "dsputil.h"
  #include "internal.h"
  #include "mpegvideo.h"
- #include "mpegvideo_common.h"
  #include "dnxhdenc.h"
 +#include "internal.h"
  
  #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
  #define DNX10BIT_QMAT_SHIFT 18 // The largest value that will not lead to overflow for 10bit samples.
Simple merge
Simple merge
@@@ -2370,31 -2027,19 +2369,31 @@@ void MPV_decode_mb_internal(MpegEncCont
                      }
                  }
  
 -                op_qpix= s->me.qpel_put;
 -                if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
 -                    op_pix = s->dsp.put_pixels_tab;
 +                if(lowres_flag){
 +                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
 +
 +                    if (s->mv_dir & MV_DIR_FORWARD) {
 +                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
 +                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
 +                    }
 +                    if (s->mv_dir & MV_DIR_BACKWARD) {
 +                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
 +                    }
                  }else{
 -                    op_pix = s->dsp.put_no_rnd_pixels_tab;
 -                }
 -                if (s->mv_dir & MV_DIR_FORWARD) {
 -                    ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
 -                    op_pix = s->dsp.avg_pixels_tab;
 -                    op_qpix= s->me.qpel_avg;
 -                }
 -                if (s->mv_dir & MV_DIR_BACKWARD) {
 -                    ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
 +                    op_qpix= s->me.qpel_put;
 +                    if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
 +                        op_pix = s->dsp.put_pixels_tab;
 +                    }else{
 +                        op_pix = s->dsp.put_no_rnd_pixels_tab;
 +                    }
 +                    if (s->mv_dir & MV_DIR_FORWARD) {
-                         MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
++                        ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
 +                        op_pix = s->dsp.avg_pixels_tab;
 +                        op_qpix= s->me.qpel_avg;
 +                    }
 +                    if (s->mv_dir & MV_DIR_BACKWARD) {
-                         MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
++                        ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
 +                    }
                  }
              }
  
Simple merge
Simple merge
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
- /**
-  * @file
-  * The simplest mpeg encoder (well, it was the simplest!).
-  */
- #ifndef AVCODEC_MPEGVIDEO_COMMON_H
- #define AVCODEC_MPEGVIDEO_COMMON_H
  #include <string.h>
 +#include "libavutil/avassert.h"
  #include "avcodec.h"
  #include "dsputil.h"
  #include "mpegvideo.h"
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index 7ef9e24,0000000..e718c80
mode 100644,000000..100644
--- /dev/null
@@@ -1,202 -1,0 +1,202 @@@
- #include "libavutil/x86_cpu.h"
 +/*
 + * MMX optimized discrete wavelet transform
 + * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
 + * Copyright (c) 2010 David Conrad
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
++#include "libavutil/x86/asm.h"
 +#include "dsputil_mmx.h"
 +#include "dwt.h"
 +
 +#define COMPOSE_VERTICAL(ext, align) \
 +void ff_vertical_compose53iL0##ext(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width); \
 +void ff_vertical_compose_dirac53iH0##ext(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width); \
 +void ff_vertical_compose_dd137iL0##ext(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, IDWTELEM *b3, IDWTELEM *b4, int width); \
 +void ff_vertical_compose_dd97iH0##ext(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, IDWTELEM *b3, IDWTELEM *b4, int width); \
 +void ff_vertical_compose_haar##ext(IDWTELEM *b0, IDWTELEM *b1, int width); \
 +void ff_horizontal_compose_haar0i##ext(IDWTELEM *b, IDWTELEM *tmp, int w);\
 +void ff_horizontal_compose_haar1i##ext(IDWTELEM *b, IDWTELEM *tmp, int w);\
 +\
 +static void vertical_compose53iL0##ext(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width) \
 +{ \
 +    int i, width_align = width&~(align-1); \
 +\
 +    for(i=width_align; i<width; i++) \
 +        b1[i] = COMPOSE_53iL0(b0[i], b1[i], b2[i]); \
 +\
 +    ff_vertical_compose53iL0##ext(b0, b1, b2, width_align); \
 +} \
 +\
 +static void vertical_compose_dirac53iH0##ext(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width) \
 +{ \
 +    int i, width_align = width&~(align-1); \
 +\
 +    for(i=width_align; i<width; i++) \
 +        b1[i] = COMPOSE_DIRAC53iH0(b0[i], b1[i], b2[i]); \
 +\
 +    ff_vertical_compose_dirac53iH0##ext(b0, b1, b2, width_align); \
 +} \
 +\
 +static void vertical_compose_dd137iL0##ext(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, \
 +                                           IDWTELEM *b3, IDWTELEM *b4, int width) \
 +{ \
 +    int i, width_align = width&~(align-1); \
 +\
 +    for(i=width_align; i<width; i++) \
 +        b2[i] = COMPOSE_DD137iL0(b0[i], b1[i], b2[i], b3[i], b4[i]); \
 +\
 +    ff_vertical_compose_dd137iL0##ext(b0, b1, b2, b3, b4, width_align); \
 +} \
 +\
 +static void vertical_compose_dd97iH0##ext(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, \
 +                                          IDWTELEM *b3, IDWTELEM *b4, int width) \
 +{ \
 +    int i, width_align = width&~(align-1); \
 +\
 +    for(i=width_align; i<width; i++) \
 +        b2[i] = COMPOSE_DD97iH0(b0[i], b1[i], b2[i], b3[i], b4[i]); \
 +\
 +    ff_vertical_compose_dd97iH0##ext(b0, b1, b2, b3, b4, width_align); \
 +} \
 +static void vertical_compose_haar##ext(IDWTELEM *b0, IDWTELEM *b1, int width) \
 +{ \
 +    int i, width_align = width&~(align-1); \
 +\
 +    for(i=width_align; i<width; i++) { \
 +        b0[i] = COMPOSE_HAARiL0(b0[i], b1[i]); \
 +        b1[i] = COMPOSE_HAARiH0(b1[i], b0[i]); \
 +    } \
 +\
 +    ff_vertical_compose_haar##ext(b0, b1, width_align); \
 +} \
 +static void horizontal_compose_haar0i##ext(IDWTELEM *b, IDWTELEM *tmp, int w)\
 +{\
 +    int w2= w>>1;\
 +    int x= w2 - (w2&(align-1));\
 +    ff_horizontal_compose_haar0i##ext(b, tmp, w);\
 +\
 +    for (; x < w2; x++) {\
 +        b[2*x  ] = tmp[x];\
 +        b[2*x+1] = COMPOSE_HAARiH0(b[x+w2], tmp[x]);\
 +    }\
 +}\
 +static void horizontal_compose_haar1i##ext(IDWTELEM *b, IDWTELEM *tmp, int w)\
 +{\
 +    int w2= w>>1;\
 +    int x= w2 - (w2&(align-1));\
 +    ff_horizontal_compose_haar1i##ext(b, tmp, w);\
 +\
 +    for (; x < w2; x++) {\
 +        b[2*x  ] = (tmp[x] + 1)>>1;\
 +        b[2*x+1] = (COMPOSE_HAARiH0(b[x+w2], tmp[x]) + 1)>>1;\
 +    }\
 +}\
 +\
 +
 +#if HAVE_YASM
 +#if !ARCH_X86_64
 +COMPOSE_VERTICAL(_mmx, 4)
 +#endif
 +COMPOSE_VERTICAL(_sse2, 8)
 +
 +
 +void ff_horizontal_compose_dd97i_ssse3(IDWTELEM *b, IDWTELEM *tmp, int w);
 +
 +static void horizontal_compose_dd97i_ssse3(IDWTELEM *b, IDWTELEM *tmp, int w)
 +{
 +    int w2= w>>1;
 +    int x= w2 - (w2&7);
 +    ff_horizontal_compose_dd97i_ssse3(b, tmp, w);
 +
 +    for (; x < w2; x++) {
 +        b[2*x  ] = (tmp[x] + 1)>>1;
 +        b[2*x+1] = (COMPOSE_DD97iH0(tmp[x-1], tmp[x], b[x+w2], tmp[x+1], tmp[x+2]) + 1)>>1;
 +    }
 +}
 +#endif
 +
 +void ff_spatial_idwt_init_mmx(DWTContext *d, enum dwt_type type)
 +{
 +#if HAVE_YASM
 +  int mm_flags = av_get_cpu_flags();
 +
 +#if !ARCH_X86_64
 +    if (!(mm_flags & AV_CPU_FLAG_MMX))
 +        return;
 +
 +    switch (type) {
 +    case DWT_DIRAC_DD9_7:
 +        d->vertical_compose_l0 = (void*)vertical_compose53iL0_mmx;
 +        d->vertical_compose_h0 = (void*)vertical_compose_dd97iH0_mmx;
 +        break;
 +    case DWT_DIRAC_LEGALL5_3:
 +        d->vertical_compose_l0 = (void*)vertical_compose53iL0_mmx;
 +        d->vertical_compose_h0 = (void*)vertical_compose_dirac53iH0_mmx;
 +        break;
 +    case DWT_DIRAC_DD13_7:
 +        d->vertical_compose_l0 = (void*)vertical_compose_dd137iL0_mmx;
 +        d->vertical_compose_h0 = (void*)vertical_compose_dd97iH0_mmx;
 +        break;
 +    case DWT_DIRAC_HAAR0:
 +        d->vertical_compose   = (void*)vertical_compose_haar_mmx;
 +        d->horizontal_compose = horizontal_compose_haar0i_mmx;
 +        break;
 +    case DWT_DIRAC_HAAR1:
 +        d->vertical_compose   = (void*)vertical_compose_haar_mmx;
 +        d->horizontal_compose = horizontal_compose_haar1i_mmx;
 +        break;
 +    }
 +#endif
 +
 +    if (!(mm_flags & AV_CPU_FLAG_SSE2))
 +        return;
 +
 +    switch (type) {
 +    case DWT_DIRAC_DD9_7:
 +        d->vertical_compose_l0 = (void*)vertical_compose53iL0_sse2;
 +        d->vertical_compose_h0 = (void*)vertical_compose_dd97iH0_sse2;
 +        break;
 +    case DWT_DIRAC_LEGALL5_3:
 +        d->vertical_compose_l0 = (void*)vertical_compose53iL0_sse2;
 +        d->vertical_compose_h0 = (void*)vertical_compose_dirac53iH0_sse2;
 +        break;
 +    case DWT_DIRAC_DD13_7:
 +        d->vertical_compose_l0 = (void*)vertical_compose_dd137iL0_sse2;
 +        d->vertical_compose_h0 = (void*)vertical_compose_dd97iH0_sse2;
 +        break;
 +    case DWT_DIRAC_HAAR0:
 +        d->vertical_compose   = (void*)vertical_compose_haar_sse2;
 +        d->horizontal_compose = horizontal_compose_haar0i_sse2;
 +        break;
 +    case DWT_DIRAC_HAAR1:
 +        d->vertical_compose   = (void*)vertical_compose_haar_sse2;
 +        d->horizontal_compose = horizontal_compose_haar1i_sse2;
 +        break;
 +    }
 +
 +    if (!(mm_flags & AV_CPU_FLAG_SSSE3))
 +        return;
 +
 +    switch (type) {
 +    case DWT_DIRAC_DD9_7:
 +        d->horizontal_compose = horizontal_compose_dd97i_ssse3;
 +        break;
 +    }
 +#endif // HAVE_YASM
 +}
Simple merge
Simple merge
Simple merge
index 2408ab2,0000000..4b92f5c
mode 100644,000000..100644
--- /dev/null
@@@ -1,632 -1,0 +1,632 @@@
- #include "libavutil/x86_cpu.h"
 +/*
 + * Copyright (C) 1999-2001 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
 + *
 + * This file is part of mpeg2dec, a free MPEG-2 video stream decoder.
 + * See http://libmpeg2.sourceforge.net/ for updates.
 + *
 + * mpeg2dec is free software; you can redistribute it and/or modify
 + * it under the terms of the GNU General Public License as published by
 + * the Free Software Foundation; either version 2 of the License, or
 + * (at your option) any later version.
 + *
 + * mpeg2dec is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 + * GNU General Public License for more details.
 + *
 + * You should have received a copy of the GNU General Public License
 + * along with mpeg2dec; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +#include "libavutil/common.h"
 +#include "libavcodec/dsputil.h"
 +
++#include "libavutil/x86/asm.h"
 +#include "dsputil_mmx.h"
 +
 +#if HAVE_INLINE_ASM
 +
 +#define ROW_SHIFT 11
 +#define COL_SHIFT 6
 +
 +#define round(bias) ((int)(((bias)+0.5) * (1<<ROW_SHIFT)))
 +#define rounder(bias) {round (bias), round (bias)}
 +
 +
 +#if 0
 +/* C row IDCT - it is just here to document the MMXEXT and MMX versions */
 +static inline void idct_row (int16_t * row, int offset,
 +                             int16_t * table, int32_t * rounder)
 +{
 +    int C1, C2, C3, C4, C5, C6, C7;
 +    int a0, a1, a2, a3, b0, b1, b2, b3;
 +
 +    row += offset;
 +
 +    C1 = table[1];
 +    C2 = table[2];
 +    C3 = table[3];
 +    C4 = table[4];
 +    C5 = table[5];
 +    C6 = table[6];
 +    C7 = table[7];
 +
 +    a0 = C4*row[0] + C2*row[2] + C4*row[4] + C6*row[6] + *rounder;
 +    a1 = C4*row[0] + C6*row[2] - C4*row[4] - C2*row[6] + *rounder;
 +    a2 = C4*row[0] - C6*row[2] - C4*row[4] + C2*row[6] + *rounder;
 +    a3 = C4*row[0] - C2*row[2] + C4*row[4] - C6*row[6] + *rounder;
 +
 +    b0 = C1*row[1] + C3*row[3] + C5*row[5] + C7*row[7];
 +    b1 = C3*row[1] - C7*row[3] - C1*row[5] - C5*row[7];
 +    b2 = C5*row[1] - C1*row[3] + C7*row[5] + C3*row[7];
 +    b3 = C7*row[1] - C5*row[3] + C3*row[5] - C1*row[7];
 +
 +    row[0] = (a0 + b0) >> ROW_SHIFT;
 +    row[1] = (a1 + b1) >> ROW_SHIFT;
 +    row[2] = (a2 + b2) >> ROW_SHIFT;
 +    row[3] = (a3 + b3) >> ROW_SHIFT;
 +    row[4] = (a3 - b3) >> ROW_SHIFT;
 +    row[5] = (a2 - b2) >> ROW_SHIFT;
 +    row[6] = (a1 - b1) >> ROW_SHIFT;
 +    row[7] = (a0 - b0) >> ROW_SHIFT;
 +}
 +#endif
 +
 +
 +/* MMXEXT row IDCT */
 +
 +#define mmxext_table(c1,c2,c3,c4,c5,c6,c7)      {  c4,  c2, -c4, -c2,   \
 +                                                   c4,  c6,  c4,  c6,   \
 +                                                   c1,  c3, -c1, -c5,   \
 +                                                   c5,  c7,  c3, -c7,   \
 +                                                   c4, -c6,  c4, -c6,   \
 +                                                  -c4,  c2,  c4, -c2,   \
 +                                                   c5, -c1,  c3, -c1,   \
 +                                                   c7,  c3,  c7, -c5 }
 +
 +static inline void mmxext_row_head (int16_t * const row, const int offset,
 +                                    const int16_t * const table)
 +{
 +    __asm__ volatile(
 +        "movq     (%0), %%mm2        \n\t"  /* mm2 = x6 x4 x2 x0 */
 +
 +        "movq    8(%0), %%mm5        \n\t"  /* mm5 = x7 x5 x3 x1 */
 +        "movq    %%mm2, %%mm0        \n\t"  /* mm0 = x6 x4 x2 x0 */
 +
 +        "movq     (%1), %%mm3        \n\t"  /* mm3 = -C2 -C4 C2 C4 */
 +        "movq    %%mm5, %%mm6        \n\t"  /* mm6 = x7 x5 x3 x1 */
 +
 +        "movq    8(%1), %%mm4        \n\t"  /* mm4 = C6 C4 C6 C4 */
 +        "pmaddwd %%mm0, %%mm3        \n\t"  /* mm3 = -C4*x4-C2*x6 C4*x0+C2*x2 */
 +
 +        "pshufw  $0x4e, %%mm2, %%mm2 \n\t"  /* mm2 = x2 x0 x6 x4 */
 +        :: "r" ((row+offset)), "r" (table)
 +    );
 +}
 +
 +static inline void mmxext_row (const int16_t * const table,
 +                               const int32_t * const rounder)
 +{
 +    __asm__ volatile (
 +        "movq    16(%0), %%mm1         \n\t" /* mm1 = -C5 -C1 C3 C1 */
 +        "pmaddwd  %%mm2, %%mm4         \n\t" /* mm4 = C4*x0+C6*x2 C4*x4+C6*x6 */
 +
 +        "pmaddwd 32(%0), %%mm0         \n\t" /* mm0 = C4*x4-C6*x6 C4*x0-C6*x2 */
 +        "pshufw   $0x4e, %%mm6, %%mm6  \n\t" /* mm6 = x3 x1 x7 x5 */
 +
 +        "movq    24(%0), %%mm7         \n\t" /* mm7 = -C7 C3 C7 C5 */
 +        "pmaddwd  %%mm5, %%mm1         \n\t" /* mm1= -C1*x5-C5*x7 C1*x1+C3*x3 */
 +
 +        "paddd     (%1), %%mm3         \n\t" /* mm3 += rounder */
 +        "pmaddwd  %%mm6, %%mm7         \n\t" /* mm7 = C3*x1-C7*x3 C5*x5+C7*x7 */
 +
 +        "pmaddwd 40(%0), %%mm2         \n\t" /* mm2= C4*x0-C2*x2 -C4*x4+C2*x6 */
 +        "paddd    %%mm4, %%mm3         \n\t" /* mm3 = a1 a0 + rounder */
 +
 +        "pmaddwd 48(%0), %%mm5         \n\t" /* mm5 = C3*x5-C1*x7 C5*x1-C1*x3 */
 +        "movq     %%mm3, %%mm4         \n\t" /* mm4 = a1 a0 + rounder */
 +
 +        "pmaddwd 56(%0), %%mm6         \n\t" /* mm6 = C7*x1-C5*x3 C7*x5+C3*x7 */
 +        "paddd    %%mm7, %%mm1         \n\t" /* mm1 = b1 b0 */
 +
 +        "paddd     (%1), %%mm0         \n\t" /* mm0 += rounder */
 +        "psubd    %%mm1, %%mm3         \n\t" /* mm3 = a1-b1 a0-b0 + rounder */
 +
 +        "psrad $" AV_STRINGIFY(ROW_SHIFT) ", %%mm3         \n\t" /* mm3 = y6 y7 */
 +        "paddd    %%mm4, %%mm1         \n\t" /* mm1 = a1+b1 a0+b0 + rounder */
 +
 +        "paddd    %%mm2, %%mm0         \n\t" /* mm0 = a3 a2 + rounder */
 +        "psrad $" AV_STRINGIFY(ROW_SHIFT) ", %%mm1         \n\t" /* mm1 = y1 y0 */
 +
 +        "paddd    %%mm6, %%mm5         \n\t" /* mm5 = b3 b2 */
 +        "movq     %%mm0, %%mm4         \n\t" /* mm4 = a3 a2 + rounder */
 +
 +        "paddd    %%mm5, %%mm0         \n\t" /* mm0 = a3+b3 a2+b2 + rounder */
 +        "psubd    %%mm5, %%mm4         \n\t" /* mm4 = a3-b3 a2-b2 + rounder */
 +        : : "r" (table), "r" (rounder));
 +}
 +
 +static inline void mmxext_row_tail (int16_t * const row, const int store)
 +{
 +    __asm__ volatile (
 +        "psrad $" AV_STRINGIFY(ROW_SHIFT) ", %%mm0        \n\t"  /* mm0 = y3 y2 */
 +
 +        "psrad $" AV_STRINGIFY(ROW_SHIFT) ", %%mm4  \n\t"  /* mm4 = y4 y5 */
 +
 +        "packssdw %%mm0, %%mm1        \n\t"  /* mm1 = y3 y2 y1 y0 */
 +
 +        "packssdw %%mm3, %%mm4        \n\t"  /* mm4 = y6 y7 y4 y5 */
 +
 +        "movq     %%mm1, (%0)         \n\t"  /* save y3 y2 y1 y0 */
 +        "pshufw   $0xb1, %%mm4, %%mm4 \n\t"  /* mm4 = y7 y6 y5 y4 */
 +
 +        /* slot */
 +
 +        "movq     %%mm4, 8(%0)        \n\t"  /* save y7 y6 y5 y4 */
 +        :: "r" (row+store)
 +        );
 +}
 +
 +static inline void mmxext_row_mid (int16_t * const row, const int store,
 +                                   const int offset,
 +                                   const int16_t * const table)
 +{
 +    __asm__ volatile (
 +        "movq     (%0,%1), %%mm2       \n\t" /* mm2 = x6 x4 x2 x0 */
 +        "psrad $" AV_STRINGIFY(ROW_SHIFT) ", %%mm0 \n\t"   /* mm0 = y3 y2 */
 +
 +        "movq    8(%0,%1), %%mm5       \n\t" /* mm5 = x7 x5 x3 x1 */
 +        "psrad $" AV_STRINGIFY(ROW_SHIFT) ", %%mm4 \n\t" /* mm4 = y4 y5 */
 +
 +        "packssdw   %%mm0, %%mm1       \n\t" /* mm1 = y3 y2 y1 y0 */
 +        "movq       %%mm5, %%mm6       \n\t" /* mm6 = x7 x5 x3 x1 */
 +
 +        "packssdw   %%mm3, %%mm4       \n\t" /* mm4 = y6 y7 y4 y5 */
 +        "movq       %%mm2, %%mm0       \n\t" /* mm0 = x6 x4 x2 x0 */
 +
 +        "movq       %%mm1, (%0,%2)     \n\t" /* save y3 y2 y1 y0 */
 +        "pshufw     $0xb1, %%mm4, %%mm4\n\t" /* mm4 = y7 y6 y5 y4 */
 +
 +        "movq        (%3), %%mm3       \n\t" /* mm3 = -C2 -C4 C2 C4 */
 +        "movq       %%mm4, 8(%0,%2)    \n\t" /* save y7 y6 y5 y4 */
 +
 +        "pmaddwd    %%mm0, %%mm3       \n\t" /* mm3= -C4*x4-C2*x6 C4*x0+C2*x2 */
 +
 +        "movq       8(%3), %%mm4       \n\t" /* mm4 = C6 C4 C6 C4 */
 +        "pshufw     $0x4e, %%mm2, %%mm2\n\t" /* mm2 = x2 x0 x6 x4 */
 +        :: "r" (row), "r" ((x86_reg) (2*offset)), "r" ((x86_reg) (2*store)), "r" (table)
 +        );
 +}
 +
 +
 +/* MMX row IDCT */
 +
 +#define mmx_table(c1,c2,c3,c4,c5,c6,c7) {  c4,  c2,  c4,  c6,   \
 +                                           c4,  c6, -c4, -c2,   \
 +                                           c1,  c3,  c3, -c7,   \
 +                                           c5,  c7, -c1, -c5,   \
 +                                           c4, -c6,  c4, -c2,   \
 +                                          -c4,  c2,  c4, -c6,   \
 +                                           c5, -c1,  c7, -c5,   \
 +                                           c7,  c3,  c3, -c1 }
 +
 +static inline void mmx_row_head (int16_t * const row, const int offset,
 +                                 const int16_t * const table)
 +{
 +    __asm__ volatile (
 +        "movq (%0), %%mm2       \n\t"    /* mm2 = x6 x4 x2 x0 */
 +
 +        "movq 8(%0), %%mm5      \n\t"    /* mm5 = x7 x5 x3 x1 */
 +        "movq %%mm2, %%mm0      \n\t"    /* mm0 = x6 x4 x2 x0 */
 +
 +        "movq (%1), %%mm3       \n\t"    /* mm3 = C6 C4 C2 C4 */
 +        "movq %%mm5, %%mm6      \n\t"    /* mm6 = x7 x5 x3 x1 */
 +
 +        "punpckldq %%mm0, %%mm0 \n\t"    /* mm0 = x2 x0 x2 x0 */
 +
 +        "movq 8(%1), %%mm4      \n\t"    /* mm4 = -C2 -C4 C6 C4 */
 +        "pmaddwd %%mm0, %%mm3   \n\t"    /* mm3 = C4*x0+C6*x2 C4*x0+C2*x2 */
 +
 +        "movq 16(%1), %%mm1     \n\t"    /* mm1 = -C7 C3 C3 C1 */
 +        "punpckhdq %%mm2, %%mm2 \n\t"    /* mm2 = x6 x4 x6 x4 */
 +        :: "r" ((row+offset)), "r" (table)
 +        );
 +}
 +
 +static inline void mmx_row (const int16_t * const table,
 +                            const int32_t * const rounder)
 +{
 +    __asm__ volatile (
 +        "pmaddwd   %%mm2, %%mm4    \n\t"  /* mm4 = -C4*x4-C2*x6 C4*x4+C6*x6 */
 +        "punpckldq %%mm5, %%mm5    \n\t"  /* mm5 = x3 x1 x3 x1 */
 +
 +        "pmaddwd  32(%0), %%mm0    \n\t"  /* mm0 = C4*x0-C2*x2 C4*x0-C6*x2 */
 +        "punpckhdq %%mm6, %%mm6    \n\t"  /* mm6 = x7 x5 x7 x5 */
 +
 +        "movq     24(%0), %%mm7    \n\t"  /* mm7 = -C5 -C1 C7 C5 */
 +        "pmaddwd   %%mm5, %%mm1    \n\t"  /* mm1 = C3*x1-C7*x3 C1*x1+C3*x3 */
 +
 +        "paddd      (%1), %%mm3    \n\t"  /* mm3 += rounder */
 +        "pmaddwd   %%mm6, %%mm7    \n\t"  /* mm7 = -C1*x5-C5*x7 C5*x5+C7*x7 */
 +
 +        "pmaddwd  40(%0), %%mm2    \n\t"  /* mm2 = C4*x4-C6*x6 -C4*x4+C2*x6 */
 +        "paddd     %%mm4, %%mm3    \n\t"  /* mm3 = a1 a0 + rounder */
 +
 +        "pmaddwd  48(%0), %%mm5    \n\t"  /* mm5 = C7*x1-C5*x3 C5*x1-C1*x3 */
 +        "movq      %%mm3, %%mm4    \n\t"  /* mm4 = a1 a0 + rounder */
 +
 +        "pmaddwd  56(%0), %%mm6    \n\t"  /* mm6 = C3*x5-C1*x7 C7*x5+C3*x7 */
 +        "paddd     %%mm7, %%mm1    \n\t"  /* mm1 = b1 b0 */
 +
 +        "paddd      (%1), %%mm0    \n\t"  /* mm0 += rounder */
 +        "psubd     %%mm1, %%mm3    \n\t"  /* mm3 = a1-b1 a0-b0 + rounder */
 +
 +        "psrad $" AV_STRINGIFY(ROW_SHIFT) ", %%mm3    \n\t"  /* mm3 = y6 y7 */
 +        "paddd     %%mm4, %%mm1    \n\t"  /* mm1 = a1+b1 a0+b0 + rounder */
 +
 +        "paddd     %%mm2, %%mm0    \n\t"  /* mm0 = a3 a2 + rounder */
 +        "psrad $" AV_STRINGIFY(ROW_SHIFT) ", %%mm1    \n\t"  /* mm1 = y1 y0 */
 +
 +        "paddd     %%mm6, %%mm5    \n\t"  /* mm5 = b3 b2 */
 +        "movq      %%mm0, %%mm7    \n\t"  /* mm7 = a3 a2 + rounder */
 +
 +        "paddd     %%mm5, %%mm0    \n\t"  /* mm0 = a3+b3 a2+b2 + rounder */
 +        "psubd     %%mm5, %%mm7    \n\t"  /* mm7 = a3-b3 a2-b2 + rounder */
 +        :: "r" (table), "r" (rounder)
 +        );
 +}
 +
 +static inline void mmx_row_tail (int16_t * const row, const int store)
 +{
 +    __asm__ volatile (
 +        "psrad $" AV_STRINGIFY(ROW_SHIFT) ", %%mm0      \n\t" /* mm0 = y3 y2 */
 +
 +        "psrad $" AV_STRINGIFY(ROW_SHIFT) ", %%mm7      \n\t" /* mm7 = y4 y5 */
 +
 +        "packssdw %%mm0, %%mm1 \n\t" /* mm1 = y3 y2 y1 y0 */
 +
 +        "packssdw %%mm3, %%mm7 \n\t" /* mm7 = y6 y7 y4 y5 */
 +
 +        "movq %%mm1, (%0)      \n\t" /* save y3 y2 y1 y0 */
 +        "movq %%mm7, %%mm4     \n\t" /* mm4 = y6 y7 y4 y5 */
 +
 +        "pslld $16, %%mm7      \n\t" /* mm7 = y7 0 y5 0 */
 +
 +        "psrld $16, %%mm4      \n\t" /* mm4 = 0 y6 0 y4 */
 +
 +        "por %%mm4, %%mm7      \n\t" /* mm7 = y7 y6 y5 y4 */
 +
 +        /* slot */
 +
 +        "movq %%mm7, 8(%0)     \n\t" /* save y7 y6 y5 y4 */
 +        :: "r" (row+store)
 +        );
 +}
 +
 +static inline void mmx_row_mid (int16_t * const row, const int store,
 +                                const int offset, const int16_t * const table)
 +{
 +
 +    __asm__ volatile (
 +        "movq    (%0,%1), %%mm2    \n\t" /* mm2 = x6 x4 x2 x0 */
 +        "psrad $" AV_STRINGIFY(ROW_SHIFT) ", %%mm0 \n\t" /* mm0 = y3 y2 */
 +
 +        "movq   8(%0,%1), %%mm5    \n\t" /* mm5 = x7 x5 x3 x1 */
 +        "psrad $" AV_STRINGIFY(ROW_SHIFT) ", %%mm7 \n\t" /* mm7 = y4 y5 */
 +
 +        "packssdw  %%mm0, %%mm1    \n\t" /* mm1 = y3 y2 y1 y0 */
 +        "movq      %%mm5, %%mm6    \n\t" /* mm6 = x7 x5 x3 x1 */
 +
 +        "packssdw  %%mm3, %%mm7    \n\t" /* mm7 = y6 y7 y4 y5 */
 +        "movq      %%mm2, %%mm0    \n\t" /* mm0 = x6 x4 x2 x0 */
 +
 +        "movq      %%mm1, (%0,%2)  \n\t" /* save y3 y2 y1 y0 */
 +        "movq      %%mm7, %%mm1    \n\t" /* mm1 = y6 y7 y4 y5 */
 +
 +        "punpckldq %%mm0, %%mm0    \n\t" /* mm0 = x2 x0 x2 x0 */
 +        "psrld       $16, %%mm7    \n\t" /* mm7 = 0 y6 0 y4 */
 +
 +        "movq       (%3), %%mm3    \n\t" /* mm3 = C6 C4 C2 C4 */
 +        "pslld       $16, %%mm1    \n\t" /* mm1 = y7 0 y5 0 */
 +
 +        "movq      8(%3), %%mm4    \n\t" /* mm4 = -C2 -C4 C6 C4 */
 +        "por       %%mm1, %%mm7    \n\t" /* mm7 = y7 y6 y5 y4 */
 +
 +        "movq     16(%3), %%mm1    \n\t" /* mm1 = -C7 C3 C3 C1 */
 +        "punpckhdq %%mm2, %%mm2    \n\t" /* mm2 = x6 x4 x6 x4 */
 +
 +        "movq      %%mm7, 8(%0,%2) \n\t" /* save y7 y6 y5 y4 */
 +        "pmaddwd   %%mm0, %%mm3    \n\t" /* mm3 = C4*x0+C6*x2 C4*x0+C2*x2 */
 +        : : "r" (row), "r" ((x86_reg) (2*offset)), "r" ((x86_reg) (2*store)), "r" (table)
 +        );
 +}
 +
 +
 +#if 0
 +/* C column IDCT - it is just here to document the MMXEXT and MMX versions */
 +static inline void idct_col (int16_t * col, int offset)
 +{
 +/* multiplication - as implemented on mmx */
 +#define F(c,x) (((c) * (x)) >> 16)
 +
 +/* saturation - it helps us handle torture test cases */
 +#define S(x) (((x)>32767) ? 32767 : ((x)<-32768) ? -32768 : (x))
 +
 +    int16_t x0, x1, x2, x3, x4, x5, x6, x7;
 +    int16_t y0, y1, y2, y3, y4, y5, y6, y7;
 +    int16_t a0, a1, a2, a3, b0, b1, b2, b3;
 +    int16_t u04, v04, u26, v26, u17, v17, u35, v35, u12, v12;
 +
 +    col += offset;
 +
 +    x0 = col[0*8];
 +    x1 = col[1*8];
 +    x2 = col[2*8];
 +    x3 = col[3*8];
 +    x4 = col[4*8];
 +    x5 = col[5*8];
 +    x6 = col[6*8];
 +    x7 = col[7*8];
 +
 +    u04 = S (x0 + x4);
 +    v04 = S (x0 - x4);
 +    u26 = S (F (T2, x6) + x2);
 +    v26 = S (F (T2, x2) - x6);
 +
 +    a0 = S (u04 + u26);
 +    a1 = S (v04 + v26);
 +    a2 = S (v04 - v26);
 +    a3 = S (u04 - u26);
 +
 +    u17 = S (F (T1, x7) + x1);
 +    v17 = S (F (T1, x1) - x7);
 +    u35 = S (F (T3, x5) + x3);
 +    v35 = S (F (T3, x3) - x5);
 +
 +    b0 = S (u17 + u35);
 +    b3 = S (v17 - v35);
 +    u12 = S (u17 - u35);
 +    v12 = S (v17 + v35);
 +    u12 = S (2 * F (C4, u12));
 +    v12 = S (2 * F (C4, v12));
 +    b1 = S (u12 + v12);
 +    b2 = S (u12 - v12);
 +
 +    y0 = S (a0 + b0) >> COL_SHIFT;
 +    y1 = S (a1 + b1) >> COL_SHIFT;
 +    y2 = S (a2 + b2) >> COL_SHIFT;
 +    y3 = S (a3 + b3) >> COL_SHIFT;
 +
 +    y4 = S (a3 - b3) >> COL_SHIFT;
 +    y5 = S (a2 - b2) >> COL_SHIFT;
 +    y6 = S (a1 - b1) >> COL_SHIFT;
 +    y7 = S (a0 - b0) >> COL_SHIFT;
 +
 +    col[0*8] = y0;
 +    col[1*8] = y1;
 +    col[2*8] = y2;
 +    col[3*8] = y3;
 +    col[4*8] = y4;
 +    col[5*8] = y5;
 +    col[6*8] = y6;
 +    col[7*8] = y7;
 +}
 +#endif
 +
 +
 +/* MMX column IDCT */
 +static inline void idct_col (int16_t * const col, const int offset)
 +{
 +#define T1 13036
 +#define T2 27146
 +#define T3 43790
 +#define C4 23170
 +
 +    DECLARE_ALIGNED(8, static const short, t1_vector)[] = {
 +        T1,T1,T1,T1,
 +        T2,T2,T2,T2,
 +        T3,T3,T3,T3,
 +        C4,C4,C4,C4
 +    };
 +
 +    /* column code adapted from Peter Gubanov */
 +    /* http://www.elecard.com/peter/idct.shtml */
 +
 +    __asm__ volatile (
 +        "movq      (%0), %%mm0    \n\t" /* mm0 = T1 */
 +
 +        "movq   2*8(%1), %%mm1    \n\t" /* mm1 = x1 */
 +        "movq     %%mm0, %%mm2    \n\t" /* mm2 = T1 */
 +
 +        "movq 7*2*8(%1), %%mm4    \n\t" /* mm4 = x7 */
 +        "pmulhw   %%mm1, %%mm0    \n\t" /* mm0 = T1*x1 */
 +
 +        "movq    16(%0), %%mm5    \n\t" /* mm5 = T3 */
 +        "pmulhw   %%mm4, %%mm2    \n\t" /* mm2 = T1*x7 */
 +
 +        "movq 2*5*8(%1), %%mm6    \n\t" /* mm6 = x5 */
 +        "movq     %%mm5, %%mm7    \n\t" /* mm7 = T3-1 */
 +
 +        "movq 3*8*2(%1), %%mm3    \n\t" /* mm3 = x3 */
 +        "psubsw   %%mm4, %%mm0    \n\t" /* mm0 = v17 */
 +
 +        "movq     8(%0), %%mm4    \n\t" /* mm4 = T2 */
 +        "pmulhw   %%mm3, %%mm5    \n\t" /* mm5 = (T3-1)*x3 */
 +
 +        "paddsw   %%mm2, %%mm1    \n\t" /* mm1 = u17 */
 +        "pmulhw   %%mm6, %%mm7    \n\t" /* mm7 = (T3-1)*x5 */
 +
 +        /* slot */
 +
 +        "movq     %%mm4, %%mm2    \n\t" /* mm2 = T2 */
 +        "paddsw   %%mm3, %%mm5    \n\t" /* mm5 = T3*x3 */
 +
 +        "pmulhw 2*8*2(%1), %%mm4  \n\t" /* mm4 = T2*x2 */
 +        "paddsw   %%mm6, %%mm7    \n\t" /* mm7 = T3*x5 */
 +
 +        "psubsw   %%mm6, %%mm5    \n\t" /* mm5 = v35 */
 +        "paddsw   %%mm3, %%mm7    \n\t" /* mm7 = u35 */
 +
 +        "movq 6*8*2(%1), %%mm3    \n\t" /* mm3 = x6 */
 +        "movq     %%mm0, %%mm6    \n\t" /* mm6 = v17 */
 +
 +        "pmulhw   %%mm3, %%mm2    \n\t" /* mm2 = T2*x6 */
 +        "psubsw   %%mm5, %%mm0    \n\t" /* mm0 = b3 */
 +
 +        "psubsw   %%mm3, %%mm4    \n\t" /* mm4 = v26 */
 +        "paddsw   %%mm6, %%mm5    \n\t" /* mm5 = v12 */
 +
 +        "movq     %%mm0, 3*8*2(%1)\n\t" /* save b3 in scratch0 */
 +        "movq     %%mm1, %%mm6    \n\t" /* mm6 = u17 */
 +
 +        "paddsw 2*8*2(%1), %%mm2  \n\t" /* mm2 = u26 */
 +        "paddsw   %%mm7, %%mm6    \n\t" /* mm6 = b0 */
 +
 +        "psubsw   %%mm7, %%mm1    \n\t" /* mm1 = u12 */
 +        "movq     %%mm1, %%mm7    \n\t" /* mm7 = u12 */
 +
 +        "movq   0*8(%1), %%mm3    \n\t" /* mm3 = x0 */
 +        "paddsw   %%mm5, %%mm1    \n\t" /* mm1 = u12+v12 */
 +
 +        "movq    24(%0), %%mm0    \n\t" /* mm0 = C4/2 */
 +        "psubsw   %%mm5, %%mm7    \n\t" /* mm7 = u12-v12 */
 +
 +        "movq     %%mm6, 5*8*2(%1)\n\t" /* save b0 in scratch1 */
 +        "pmulhw   %%mm0, %%mm1    \n\t" /* mm1 = b1/2 */
 +
 +        "movq     %%mm4, %%mm6    \n\t" /* mm6 = v26 */
 +        "pmulhw   %%mm0, %%mm7    \n\t" /* mm7 = b2/2 */
 +
 +        "movq 4*8*2(%1), %%mm5    \n\t" /* mm5 = x4 */
 +        "movq     %%mm3, %%mm0    \n\t" /* mm0 = x0 */
 +
 +        "psubsw   %%mm5, %%mm3    \n\t" /* mm3 = v04 */
 +        "paddsw   %%mm5, %%mm0    \n\t" /* mm0 = u04 */
 +
 +        "paddsw   %%mm3, %%mm4    \n\t" /* mm4 = a1 */
 +        "movq     %%mm0, %%mm5    \n\t" /* mm5 = u04 */
 +
 +        "psubsw   %%mm6, %%mm3    \n\t" /* mm3 = a2 */
 +        "paddsw   %%mm2, %%mm5    \n\t" /* mm5 = a0 */
 +
 +        "paddsw   %%mm1, %%mm1    \n\t" /* mm1 = b1 */
 +        "psubsw   %%mm2, %%mm0    \n\t" /* mm0 = a3 */
 +
 +        "paddsw   %%mm7, %%mm7    \n\t" /* mm7 = b2 */
 +        "movq     %%mm3, %%mm2    \n\t" /* mm2 = a2 */
 +
 +        "movq     %%mm4, %%mm6    \n\t" /* mm6 = a1 */
 +        "paddsw   %%mm7, %%mm3    \n\t" /* mm3 = a2+b2 */
 +
 +        "psraw $" AV_STRINGIFY(COL_SHIFT) ", %%mm3\n\t" /* mm3 = y2 */
 +        "paddsw   %%mm1, %%mm4\n\t" /* mm4 = a1+b1 */
 +
 +        "psraw $" AV_STRINGIFY(COL_SHIFT) ", %%mm4\n\t" /* mm4 = y1 */
 +        "psubsw   %%mm1, %%mm6    \n\t" /* mm6 = a1-b1 */
 +
 +        "movq 5*8*2(%1), %%mm1    \n\t" /* mm1 = b0 */
 +        "psubsw   %%mm7, %%mm2    \n\t" /* mm2 = a2-b2 */
 +
 +        "psraw $" AV_STRINGIFY(COL_SHIFT) ", %%mm6\n\t" /* mm6 = y6 */
 +        "movq     %%mm5, %%mm7    \n\t" /* mm7 = a0 */
 +
 +        "movq     %%mm4, 1*8*2(%1)\n\t" /* save y1 */
 +        "psraw $" AV_STRINGIFY(COL_SHIFT) ", %%mm2\n\t" /* mm2 = y5 */
 +
 +        "movq     %%mm3, 2*8*2(%1)\n\t" /* save y2 */
 +        "paddsw   %%mm1, %%mm5    \n\t" /* mm5 = a0+b0 */
 +
 +        "movq 3*8*2(%1), %%mm4    \n\t" /* mm4 = b3 */
 +        "psubsw   %%mm1, %%mm7    \n\t" /* mm7 = a0-b0 */
 +
 +        "psraw $" AV_STRINGIFY(COL_SHIFT) ", %%mm5\n\t" /* mm5 = y0 */
 +        "movq     %%mm0, %%mm3    \n\t" /* mm3 = a3 */
 +
 +        "movq     %%mm2, 5*8*2(%1)\n\t" /* save y5 */
 +        "psubsw   %%mm4, %%mm3    \n\t" /* mm3 = a3-b3 */
 +
 +        "psraw $" AV_STRINGIFY(COL_SHIFT) ", %%mm7\n\t" /* mm7 = y7 */
 +        "paddsw   %%mm0, %%mm4    \n\t" /* mm4 = a3+b3 */
 +
 +        "movq     %%mm5, 0*8*2(%1)\n\t" /* save y0 */
 +        "psraw $" AV_STRINGIFY(COL_SHIFT) ", %%mm3\n\t" /* mm3 = y4 */
 +
 +        "movq     %%mm6, 6*8*2(%1)\n\t" /* save y6 */
 +        "psraw $" AV_STRINGIFY(COL_SHIFT) ", %%mm4\n\t" /* mm4 = y3 */
 +
 +        "movq     %%mm7, 7*8*2(%1)\n\t" /* save y7 */
 +
 +        "movq     %%mm3, 4*8*2(%1)\n\t" /* save y4 */
 +
 +        "movq     %%mm4, 3*8*2(%1)\n\t" /* save y3 */
 +        :: "r" (t1_vector), "r" (col+offset)
 +        );
 +
 +#undef T1
 +#undef T2
 +#undef T3
 +#undef C4
 +}
 +
 +
 +DECLARE_ALIGNED(8, static const int32_t, rounder0)[] =
 +    rounder ((1 << (COL_SHIFT - 1)) - 0.5);
 +DECLARE_ALIGNED(8, static const int32_t, rounder4)[] = rounder (0);
 +DECLARE_ALIGNED(8, static const int32_t, rounder1)[] =
 +    rounder (1.25683487303);        /* C1*(C1/C4+C1+C7)/2 */
 +DECLARE_ALIGNED(8, static const int32_t, rounder7)[] =
 +    rounder (-0.25);                /* C1*(C7/C4+C7-C1)/2 */
 +DECLARE_ALIGNED(8, static const int32_t, rounder2)[] =
 +    rounder (0.60355339059);        /* C2 * (C6+C2)/2 */
 +DECLARE_ALIGNED(8, static const int32_t, rounder6)[] =
 +    rounder (-0.25);                /* C2 * (C6-C2)/2 */
 +DECLARE_ALIGNED(8, static const int32_t, rounder3)[] =
 +    rounder (0.087788325588);       /* C3*(-C3/C4+C3+C5)/2 */
 +DECLARE_ALIGNED(8, static const int32_t, rounder5)[] =
 +    rounder (-0.441341716183);      /* C3*(-C5/C4+C5-C3)/2 */
 +
 +#undef COL_SHIFT
 +#undef ROW_SHIFT
 +
 +#define declare_idct(idct,table,idct_row_head,idct_row,idct_row_tail,idct_row_mid) \
 +void idct (int16_t * const block)                                       \
 +{                                                                       \
 +    DECLARE_ALIGNED(16, static const int16_t, table04)[] =              \
 +        table (22725, 21407, 19266, 16384, 12873,  8867, 4520);         \
 +    DECLARE_ALIGNED(16, static const int16_t, table17)[] =              \
 +        table (31521, 29692, 26722, 22725, 17855, 12299, 6270);         \
 +    DECLARE_ALIGNED(16, static const int16_t, table26)[] =              \
 +        table (29692, 27969, 25172, 21407, 16819, 11585, 5906);         \
 +    DECLARE_ALIGNED(16, static const int16_t, table35)[] =              \
 +        table (26722, 25172, 22654, 19266, 15137, 10426, 5315);         \
 +                                                                        \
 +    idct_row_head (block, 0*8, table04);                                \
 +    idct_row (table04, rounder0);                                       \
 +    idct_row_mid (block, 0*8, 4*8, table04);                            \
 +    idct_row (table04, rounder4);                                       \
 +    idct_row_mid (block, 4*8, 1*8, table17);                            \
 +    idct_row (table17, rounder1);                                       \
 +    idct_row_mid (block, 1*8, 7*8, table17);                            \
 +    idct_row (table17, rounder7);                                       \
 +    idct_row_mid (block, 7*8, 2*8, table26);                            \
 +    idct_row (table26, rounder2);                                       \
 +    idct_row_mid (block, 2*8, 6*8, table26);                            \
 +    idct_row (table26, rounder6);                                       \
 +    idct_row_mid (block, 6*8, 3*8, table35);                            \
 +    idct_row (table35, rounder3);                                       \
 +    idct_row_mid (block, 3*8, 5*8, table35);                            \
 +    idct_row (table35, rounder5);                                       \
 +    idct_row_tail (block, 5*8);                                         \
 +                                                                        \
 +    idct_col (block, 0);                                                \
 +    idct_col (block, 4);                                                \
 +}
 +
 +declare_idct (ff_mmxext_idct, mmxext_table,
 +              mmxext_row_head, mmxext_row, mmxext_row_tail, mmxext_row_mid)
 +
 +declare_idct (ff_mmx_idct, mmx_table,
 +              mmx_row_head, mmx_row, mmx_row_tail, mmx_row_mid)
 +
 +#endif /* HAVE_INLINE_ASM */
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -30,8 -30,8 +30,8 @@@
  #include "libavutil/avutil.h"
  
  #define LIBAVFORMAT_VERSION_MAJOR 54
 -#define LIBAVFORMAT_VERSION_MINOR 13
 -#define LIBAVFORMAT_VERSION_MICRO  2
 +#define LIBAVFORMAT_VERSION_MINOR 22
- #define LIBAVFORMAT_VERSION_MICRO 103
++#define LIBAVFORMAT_VERSION_MICRO 104
  
  #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
                                                 LIBAVFORMAT_VERSION_MINOR, \
Simple merge
index 0000000,a43ab3c..d2e76db
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,110 +1,110 @@@
 - * This file is part of Libav.
+ /*
+  * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * FFmpeg is free software; you can redistribute it and/or
+  * modify it under the terms of the GNU Lesser General Public
+  * License as published by the Free Software Foundation; either
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #ifndef AVUTIL_X86_ASM_H
+ #define AVUTIL_X86_ASM_H
+ #include <stdint.h>
+ #include "config.h"
+ #if ARCH_X86_64
+ #    define OPSIZE "q"
+ #    define REG_a "rax"
+ #    define REG_b "rbx"
+ #    define REG_c "rcx"
+ #    define REG_d "rdx"
+ #    define REG_D "rdi"
+ #    define REG_S "rsi"
+ #    define PTR_SIZE "8"
+ typedef int64_t x86_reg;
+ #    define REG_SP "rsp"
+ #    define REG_BP "rbp"
+ #    define REGBP   rbp
+ #    define REGa    rax
+ #    define REGb    rbx
+ #    define REGc    rcx
+ #    define REGd    rdx
+ #    define REGSP   rsp
+ #elif ARCH_X86_32
+ #    define OPSIZE "l"
+ #    define REG_a "eax"
+ #    define REG_b "ebx"
+ #    define REG_c "ecx"
+ #    define REG_d "edx"
+ #    define REG_D "edi"
+ #    define REG_S "esi"
+ #    define PTR_SIZE "4"
+ typedef int32_t x86_reg;
+ #    define REG_SP "esp"
+ #    define REG_BP "ebp"
+ #    define REGBP   ebp
+ #    define REGa    eax
+ #    define REGb    ebx
+ #    define REGc    ecx
+ #    define REGd    edx
+ #    define REGSP   esp
+ #else
+ typedef int x86_reg;
+ #endif
+ #define HAVE_7REGS (ARCH_X86_64 || (HAVE_EBX_AVAILABLE && HAVE_EBP_AVAILABLE))
+ #define HAVE_6REGS (ARCH_X86_64 || (HAVE_EBX_AVAILABLE || HAVE_EBP_AVAILABLE))
+ #if ARCH_X86_64 && defined(PIC)
+ #    define BROKEN_RELOCATIONS 1
+ #endif
+ /*
+  * If gcc is not set to support sse (-msse) it will not accept xmm registers
+  * in the clobber list for inline asm. XMM_CLOBBERS takes a list of xmm
+  * registers to be marked as clobbered and evaluates to nothing if they are
+  * not supported, or to the list itself if they are supported. Since a clobber
+  * list may not be empty, XMM_CLOBBERS_ONLY should be used if the xmm
+  * registers are the only in the clobber list.
+  * For example a list with "eax" and "xmm0" as clobbers should become:
+  * : XMM_CLOBBERS("xmm0",) "eax"
+  * and a list with only "xmm0" should become:
+  * XMM_CLOBBERS_ONLY("xmm0")
+  */
+ #if HAVE_XMM_CLOBBERS
+ #    define XMM_CLOBBERS(...)        __VA_ARGS__
+ #    define XMM_CLOBBERS_ONLY(...) : __VA_ARGS__
+ #else
+ #    define XMM_CLOBBERS(...)
+ #    define XMM_CLOBBERS_ONLY(...)
+ #endif
+ /* Use to export labels from asm. */
+ #define LABEL_MANGLE(a) EXTERN_PREFIX #a
+ // Use rip-relative addressing if compiling PIC code on x86-64.
+ #if ARCH_X86_64 && defined(PIC)
+ #    define LOCAL_MANGLE(a) #a "(%%rip)"
+ #else
+ #    define LOCAL_MANGLE(a) #a
+ #endif
+ #define MANGLE(a) EXTERN_PREFIX LOCAL_MANGLE(a)
+ #endif /* AVUTIL_X86_ASM_H */
Simple merge
index c3341c2,0000000..de74384
mode 100644,000000..100644
--- /dev/null
@@@ -1,98 -1,0 +1,1 @@@
- /*
-  * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
-  *
-  * This file is part of FFmpeg.
-  *
-  * FFmpeg is free software; you can redistribute it and/or
-  * modify it under the terms of the GNU Lesser General Public
-  * License as published by the Free Software Foundation; either
-  * version 2.1 of the License, or (at your option) any later version.
-  *
-  * FFmpeg is distributed in the hope that it will be useful,
-  * but WITHOUT ANY WARRANTY; without even the implied warranty of
-  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  * Lesser General Public License for more details.
-  *
-  * You should have received a copy of the GNU Lesser General Public
-  * License along with FFmpeg; if not, write to the Free Software
-  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-  */
- #ifndef AVUTIL_X86_CPU_H
- #define AVUTIL_X86_CPU_H
- #include <stdint.h>
- #include "config.h"
- #if ARCH_X86_64
- #    define OPSIZE "q"
- #    define REG_a "rax"
- #    define REG_b "rbx"
- #    define REG_c "rcx"
- #    define REG_d "rdx"
- #    define REG_D "rdi"
- #    define REG_S "rsi"
- #    define PTR_SIZE "8"
- typedef int64_t x86_reg;
- #    define REG_SP "rsp"
- #    define REG_BP "rbp"
- #    define REGBP   rbp
- #    define REGa    rax
- #    define REGb    rbx
- #    define REGc    rcx
- #    define REGd    rdx
- #    define REGSP   rsp
- #elif ARCH_X86_32
- #    define OPSIZE "l"
- #    define REG_a "eax"
- #    define REG_b "ebx"
- #    define REG_c "ecx"
- #    define REG_d "edx"
- #    define REG_D "edi"
- #    define REG_S "esi"
- #    define PTR_SIZE "4"
- typedef int32_t x86_reg;
- #    define REG_SP "esp"
- #    define REG_BP "ebp"
- #    define REGBP   ebp
- #    define REGa    eax
- #    define REGb    ebx
- #    define REGc    ecx
- #    define REGd    edx
- #    define REGSP   esp
- #else
- typedef int x86_reg;
- #endif
- #define HAVE_7REGS (ARCH_X86_64 || (HAVE_EBX_AVAILABLE && HAVE_EBP_AVAILABLE))
- #define HAVE_6REGS (ARCH_X86_64 || (HAVE_EBX_AVAILABLE || HAVE_EBP_AVAILABLE))
- #if ARCH_X86_64 && defined(PIC)
- #    define BROKEN_RELOCATIONS 1
- #endif
- /*
-  * If gcc is not set to support sse (-msse) it will not accept xmm registers
-  * in the clobber list for inline asm. XMM_CLOBBERS takes a list of xmm
-  * registers to be marked as clobbered and evaluates to nothing if they are
-  * not supported, or to the list itself if they are supported. Since a clobber
-  * list may not be empty, XMM_CLOBBERS_ONLY should be used if the xmm
-  * registers are the only in the clobber list.
-  * For example a list with "eax" and "xmm0" as clobbers should become:
-  * : XMM_CLOBBERS("xmm0",) "eax"
-  * and a list with only "xmm0" should become:
-  * XMM_CLOBBERS_ONLY("xmm0")
-  */
- #if HAVE_XMM_CLOBBERS
- #    define XMM_CLOBBERS(...)        __VA_ARGS__
- #    define XMM_CLOBBERS_ONLY(...) : __VA_ARGS__
- #else
- #    define XMM_CLOBBERS(...)
- #    define XMM_CLOBBERS_ONLY(...)
- #endif
- #endif /* AVUTIL_X86_CPU_H */
++#include "libavutil/x86/asm.h"
index 3419257,0000000..0fb2da4
mode 100644,000000..100644
--- /dev/null
@@@ -1,3631 -1,0 +1,3631 @@@
- #include "libavutil/x86_cpu.h"
 +/*
 + * Copyright (C) 2001-2002 Michael Niedermayer (michaelni@gmx.at)
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or modify
 + * it under the terms of the GNU General Public License as published by
 + * the Free Software Foundation; either version 2 of the License, or
 + * (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 + * GNU General Public License for more details.
 + *
 + * You should have received a copy of the GNU General Public License
 + * along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +/**
 + * @file
 + * mmx/mmx2/3dnow postprocess code.
 + */
 +
++#include "libavutil/x86/asm.h"
 +
 +#undef REAL_PAVGB
 +#undef PAVGB
 +#undef PMINUB
 +#undef PMAXUB
 +
 +#if   HAVE_MMX2
 +#define REAL_PAVGB(a,b) "pavgb " #a ", " #b " \n\t"
 +#elif HAVE_AMD3DNOW
 +#define REAL_PAVGB(a,b) "pavgusb " #a ", " #b " \n\t"
 +#endif
 +#define PAVGB(a,b)  REAL_PAVGB(a,b)
 +
 +#if   HAVE_MMX2
 +#define PMINUB(a,b,t) "pminub " #a ", " #b " \n\t"
 +#elif HAVE_MMX
 +#define PMINUB(b,a,t) \
 +    "movq " #a ", " #t " \n\t"\
 +    "psubusb " #b ", " #t " \n\t"\
 +    "psubb " #t ", " #a " \n\t"
 +#endif
 +
 +#if   HAVE_MMX2
 +#define PMAXUB(a,b) "pmaxub " #a ", " #b " \n\t"
 +#elif HAVE_MMX
 +#define PMAXUB(a,b) \
 +    "psubusb " #a ", " #b " \n\t"\
 +    "paddb " #a ", " #b " \n\t"
 +#endif
 +
 +//FIXME? |255-0| = 1 (should not be a problem ...)
 +#if HAVE_MMX
 +/**
 + * Check if the middle 8x8 Block in the given 8x16 block is flat
 + */
 +static inline int RENAME(vertClassify)(uint8_t src[], int stride, PPContext *c){
 +    int numEq= 0, dcOk;
 +    src+= stride*4; // src points to begin of the 8x8 Block
 +    __asm__ volatile(
 +        "movq %0, %%mm7                         \n\t"
 +        "movq %1, %%mm6                         \n\t"
 +        : : "m" (c->mmxDcOffset[c->nonBQP]),  "m" (c->mmxDcThreshold[c->nonBQP])
 +        );
 +
 +    __asm__ volatile(
 +        "lea (%2, %3), %%"REG_a"                \n\t"
 +//      0       1       2       3       4       5       6       7       8       9
 +//      %1      eax     eax+%2  eax+2%2 %1+4%2  ecx     ecx+%2  ecx+2%2 %1+8%2  ecx+4%2
 +
 +        "movq (%2), %%mm0                       \n\t"
 +        "movq (%%"REG_a"), %%mm1                \n\t"
 +        "movq %%mm0, %%mm3                      \n\t"
 +        "movq %%mm0, %%mm4                      \n\t"
 +        PMAXUB(%%mm1, %%mm4)
 +        PMINUB(%%mm1, %%mm3, %%mm5)
 +        "psubb %%mm1, %%mm0                     \n\t" // mm0 = differnece
 +        "paddb %%mm7, %%mm0                     \n\t"
 +        "pcmpgtb %%mm6, %%mm0                   \n\t"
 +
 +        "movq (%%"REG_a",%3), %%mm2             \n\t"
 +        PMAXUB(%%mm2, %%mm4)
 +        PMINUB(%%mm2, %%mm3, %%mm5)
 +        "psubb %%mm2, %%mm1                     \n\t"
 +        "paddb %%mm7, %%mm1                     \n\t"
 +        "pcmpgtb %%mm6, %%mm1                   \n\t"
 +        "paddb %%mm1, %%mm0                     \n\t"
 +
 +        "movq (%%"REG_a", %3, 2), %%mm1         \n\t"
 +        PMAXUB(%%mm1, %%mm4)
 +        PMINUB(%%mm1, %%mm3, %%mm5)
 +        "psubb %%mm1, %%mm2                     \n\t"
 +        "paddb %%mm7, %%mm2                     \n\t"
 +        "pcmpgtb %%mm6, %%mm2                   \n\t"
 +        "paddb %%mm2, %%mm0                     \n\t"
 +
 +        "lea (%%"REG_a", %3, 4), %%"REG_a"      \n\t"
 +
 +        "movq (%2, %3, 4), %%mm2                \n\t"
 +        PMAXUB(%%mm2, %%mm4)
 +        PMINUB(%%mm2, %%mm3, %%mm5)
 +        "psubb %%mm2, %%mm1                     \n\t"
 +        "paddb %%mm7, %%mm1                     \n\t"
 +        "pcmpgtb %%mm6, %%mm1                   \n\t"
 +        "paddb %%mm1, %%mm0                     \n\t"
 +
 +        "movq (%%"REG_a"), %%mm1                \n\t"
 +        PMAXUB(%%mm1, %%mm4)
 +        PMINUB(%%mm1, %%mm3, %%mm5)
 +        "psubb %%mm1, %%mm2                     \n\t"
 +        "paddb %%mm7, %%mm2                     \n\t"
 +        "pcmpgtb %%mm6, %%mm2                   \n\t"
 +        "paddb %%mm2, %%mm0                     \n\t"
 +
 +        "movq (%%"REG_a", %3), %%mm2            \n\t"
 +        PMAXUB(%%mm2, %%mm4)
 +        PMINUB(%%mm2, %%mm3, %%mm5)
 +        "psubb %%mm2, %%mm1                     \n\t"
 +        "paddb %%mm7, %%mm1                     \n\t"
 +        "pcmpgtb %%mm6, %%mm1                   \n\t"
 +        "paddb %%mm1, %%mm0                     \n\t"
 +
 +        "movq (%%"REG_a", %3, 2), %%mm1         \n\t"
 +        PMAXUB(%%mm1, %%mm4)
 +        PMINUB(%%mm1, %%mm3, %%mm5)
 +        "psubb %%mm1, %%mm2                     \n\t"
 +        "paddb %%mm7, %%mm2                     \n\t"
 +        "pcmpgtb %%mm6, %%mm2                   \n\t"
 +        "paddb %%mm2, %%mm0                     \n\t"
 +        "psubusb %%mm3, %%mm4                   \n\t"
 +
 +        "                                       \n\t"
 +#if HAVE_MMX2
 +        "pxor %%mm7, %%mm7                      \n\t"
 +        "psadbw %%mm7, %%mm0                    \n\t"
 +#else
 +        "movq %%mm0, %%mm1                      \n\t"
 +        "psrlw $8, %%mm0                        \n\t"
 +        "paddb %%mm1, %%mm0                     \n\t"
 +        "movq %%mm0, %%mm1                      \n\t"
 +        "psrlq $16, %%mm0                       \n\t"
 +        "paddb %%mm1, %%mm0                     \n\t"
 +        "movq %%mm0, %%mm1                      \n\t"
 +        "psrlq $32, %%mm0                       \n\t"
 +        "paddb %%mm1, %%mm0                     \n\t"
 +#endif
 +        "movq %4, %%mm7                         \n\t" // QP,..., QP
 +        "paddusb %%mm7, %%mm7                   \n\t" // 2QP ... 2QP
 +        "psubusb %%mm7, %%mm4                   \n\t" // Diff <= 2QP -> 0
 +        "packssdw %%mm4, %%mm4                  \n\t"
 +        "movd %%mm0, %0                         \n\t"
 +        "movd %%mm4, %1                         \n\t"
 +
 +        : "=r" (numEq), "=r" (dcOk)
 +        : "r" (src), "r" ((x86_reg)stride), "m" (c->pQPb)
 +        : "%"REG_a
 +        );
 +
 +    numEq= (-numEq) &0xFF;
 +    if(numEq > c->ppMode.flatnessThreshold){
 +        if(dcOk) return 0;
 +        else     return 1;
 +    }else{
 +        return 2;
 +    }
 +}
 +#endif //HAVE_MMX
 +
 +/**
 + * Do a vertical low pass filter on the 8x16 block (only write to the 8x8 block in the middle)
 + * using the 9-Tap Filter (1,1,2,2,4,2,2,1,1)/16
 + */
 +#if !HAVE_ALTIVEC
 +static inline void RENAME(doVertLowPass)(uint8_t *src, int stride, PPContext *c)
 +{
 +#if HAVE_MMX2 || HAVE_AMD3DNOW
 +    src+= stride*3;
 +    __asm__ volatile(        //"movv %0 %1 %2\n\t"
 +        "movq %2, %%mm0                         \n\t"  // QP,..., QP
 +        "pxor %%mm4, %%mm4                      \n\t"
 +
 +        "movq (%0), %%mm6                       \n\t"
 +        "movq (%0, %1), %%mm5                   \n\t"
 +        "movq %%mm5, %%mm1                      \n\t"
 +        "movq %%mm6, %%mm2                      \n\t"
 +        "psubusb %%mm6, %%mm5                   \n\t"
 +        "psubusb %%mm1, %%mm2                   \n\t"
 +        "por %%mm5, %%mm2                       \n\t" // ABS Diff of lines
 +        "psubusb %%mm0, %%mm2                   \n\t" // diff <= QP -> 0
 +        "pcmpeqb %%mm4, %%mm2                   \n\t" // diff <= QP -> FF
 +
 +        "pand %%mm2, %%mm6                      \n\t"
 +        "pandn %%mm1, %%mm2                     \n\t"
 +        "por %%mm2, %%mm6                       \n\t"// First Line to Filter
 +
 +        "movq (%0, %1, 8), %%mm5                \n\t"
 +        "lea (%0, %1, 4), %%"REG_a"             \n\t"
 +        "lea (%0, %1, 8), %%"REG_c"             \n\t"
 +        "sub %1, %%"REG_c"                      \n\t"
 +        "add %1, %0                             \n\t" // %0 points to line 1 not 0
 +        "movq (%0, %1, 8), %%mm7                \n\t"
 +        "movq %%mm5, %%mm1                      \n\t"
 +        "movq %%mm7, %%mm2                      \n\t"
 +        "psubusb %%mm7, %%mm5                   \n\t"
 +        "psubusb %%mm1, %%mm2                   \n\t"
 +        "por %%mm5, %%mm2                       \n\t" // ABS Diff of lines
 +        "psubusb %%mm0, %%mm2                   \n\t" // diff <= QP -> 0
 +        "pcmpeqb %%mm4, %%mm2                   \n\t" // diff <= QP -> FF
 +
 +        "pand %%mm2, %%mm7                      \n\t"
 +        "pandn %%mm1, %%mm2                     \n\t"
 +        "por %%mm2, %%mm7                       \n\t" // First Line to Filter
 +
 +
 +        //      1       2       3       4       5       6       7       8
 +        //      %0      %0+%1   %0+2%1  eax     %0+4%1  eax+2%1 ecx     eax+4%1
 +        // 6 4 2 2 1 1
 +        // 6 4 4 2
 +        // 6 8 2
 +
 +        "movq (%0, %1), %%mm0                   \n\t" //  1
 +        "movq %%mm0, %%mm1                      \n\t" //  1
 +        PAVGB(%%mm6, %%mm0)                           //1 1        /2
 +        PAVGB(%%mm6, %%mm0)                           //3 1        /4
 +
 +        "movq (%0, %1, 4), %%mm2                \n\t" //     1
 +        "movq %%mm2, %%mm5                      \n\t" //     1
 +        PAVGB((%%REGa), %%mm2)                        //    11        /2
 +        PAVGB((%0, %1, 2), %%mm2)                     //   211        /4
 +        "movq %%mm2, %%mm3                      \n\t" //   211        /4
 +        "movq (%0), %%mm4                       \n\t" // 1
 +        PAVGB(%%mm4, %%mm3)                           // 4 211        /8
 +        PAVGB(%%mm0, %%mm3)                           //642211        /16
 +        "movq %%mm3, (%0)                       \n\t" // X
 +        // mm1=2 mm2=3(211) mm4=1 mm5=5 mm6=0 mm7=9
 +        "movq %%mm1, %%mm0                      \n\t" //  1
 +        PAVGB(%%mm6, %%mm0)                           //1 1        /2
 +        "movq %%mm4, %%mm3                      \n\t" // 1
 +        PAVGB((%0,%1,2), %%mm3)                       // 1 1        /2
 +        PAVGB((%%REGa,%1,2), %%mm5)                   //     11        /2
 +        PAVGB((%%REGa), %%mm5)                        //    211 /4
 +        PAVGB(%%mm5, %%mm3)                           // 2 2211 /8
 +        PAVGB(%%mm0, %%mm3)                           //4242211 /16
 +        "movq %%mm3, (%0,%1)                    \n\t" //  X
 +        // mm1=2 mm2=3(211) mm4=1 mm5=4(211) mm6=0 mm7=9
 +        PAVGB(%%mm4, %%mm6)                                   //11        /2
 +        "movq (%%"REG_c"), %%mm0                \n\t" //       1
 +        PAVGB((%%REGa, %1, 2), %%mm0)                 //      11/2
 +        "movq %%mm0, %%mm3                      \n\t" //      11/2
 +        PAVGB(%%mm1, %%mm0)                           //  2   11/4
 +        PAVGB(%%mm6, %%mm0)                           //222   11/8
 +        PAVGB(%%mm2, %%mm0)                           //22242211/16
 +        "movq (%0, %1, 2), %%mm2                \n\t" //   1
 +        "movq %%mm0, (%0, %1, 2)                \n\t" //   X
 +        // mm1=2 mm2=3 mm3=6(11) mm4=1 mm5=4(211) mm6=0(11) mm7=9
 +        "movq (%%"REG_a", %1, 4), %%mm0         \n\t" //        1
 +        PAVGB((%%REGc), %%mm0)                        //       11        /2
 +        PAVGB(%%mm0, %%mm6)                           //11     11        /4
 +        PAVGB(%%mm1, %%mm4)                           // 11                /2
 +        PAVGB(%%mm2, %%mm1)                           //  11                /2
 +        PAVGB(%%mm1, %%mm6)                           //1122   11        /8
 +        PAVGB(%%mm5, %%mm6)                           //112242211        /16
 +        "movq (%%"REG_a"), %%mm5                \n\t" //    1
 +        "movq %%mm6, (%%"REG_a")                \n\t" //    X
 +        // mm0=7(11) mm1=2(11) mm2=3 mm3=6(11) mm4=1(11) mm5=4 mm7=9
 +        "movq (%%"REG_a", %1, 4), %%mm6         \n\t" //        1
 +        PAVGB(%%mm7, %%mm6)                           //        11        /2
 +        PAVGB(%%mm4, %%mm6)                           // 11     11        /4
 +        PAVGB(%%mm3, %%mm6)                           // 11   2211        /8
 +        PAVGB(%%mm5, %%mm2)                           //   11                /2
 +        "movq (%0, %1, 4), %%mm4                \n\t" //     1
 +        PAVGB(%%mm4, %%mm2)                           //   112                /4
 +        PAVGB(%%mm2, %%mm6)                           // 112242211        /16
 +        "movq %%mm6, (%0, %1, 4)                \n\t" //     X
 +        // mm0=7(11) mm1=2(11) mm2=3(112) mm3=6(11) mm4=5 mm5=4 mm7=9
 +        PAVGB(%%mm7, %%mm1)                           //  11     2        /4
 +        PAVGB(%%mm4, %%mm5)                           //    11                /2
 +        PAVGB(%%mm5, %%mm0)                           //    11 11        /4
 +        "movq (%%"REG_a", %1, 2), %%mm6         \n\t" //      1
 +        PAVGB(%%mm6, %%mm1)                           //  11  4  2        /8
 +        PAVGB(%%mm0, %%mm1)                           //  11224222        /16
 +        "movq %%mm1, (%%"REG_a", %1, 2)         \n\t" //      X
 +        // mm2=3(112) mm3=6(11) mm4=5 mm5=4(11) mm6=6 mm7=9
 +        PAVGB((%%REGc), %%mm2)                        //   112 4        /8
 +        "movq (%%"REG_a", %1, 4), %%mm0         \n\t" //        1
 +        PAVGB(%%mm0, %%mm6)                           //      1 1        /2
 +        PAVGB(%%mm7, %%mm6)                           //      1 12        /4
 +        PAVGB(%%mm2, %%mm6)                           //   1122424        /4
 +        "movq %%mm6, (%%"REG_c")                \n\t" //       X
 +        // mm0=8 mm3=6(11) mm4=5 mm5=4(11) mm7=9
 +        PAVGB(%%mm7, %%mm5)                           //    11   2        /4
 +        PAVGB(%%mm7, %%mm5)                           //    11   6        /8
 +
 +        PAVGB(%%mm3, %%mm0)                           //      112        /4
 +        PAVGB(%%mm0, %%mm5)                           //    112246        /16
 +        "movq %%mm5, (%%"REG_a", %1, 4)         \n\t" //        X
 +        "sub %1, %0                             \n\t"
 +
 +        :
 +        : "r" (src), "r" ((x86_reg)stride), "m" (c->pQPb)
 +        : "%"REG_a, "%"REG_c
 +    );
 +#else //HAVE_MMX2 || HAVE_AMD3DNOW
 +    const int l1= stride;
 +    const int l2= stride + l1;
 +    const int l3= stride + l2;
 +    const int l4= stride + l3;
 +    const int l5= stride + l4;
 +    const int l6= stride + l5;
 +    const int l7= stride + l6;
 +    const int l8= stride + l7;
 +    const int l9= stride + l8;
 +    int x;
 +    src+= stride*3;
 +    for(x=0; x<BLOCK_SIZE; x++){
 +        const int first= FFABS(src[0] - src[l1]) < c->QP ? src[0] : src[l1];
 +        const int last= FFABS(src[l8] - src[l9]) < c->QP ? src[l9] : src[l8];
 +
 +        int sums[10];
 +        sums[0] = 4*first + src[l1] + src[l2] + src[l3] + 4;
 +        sums[1] = sums[0] - first  + src[l4];
 +        sums[2] = sums[1] - first  + src[l5];
 +        sums[3] = sums[2] - first  + src[l6];
 +        sums[4] = sums[3] - first  + src[l7];
 +        sums[5] = sums[4] - src[l1] + src[l8];
 +        sums[6] = sums[5] - src[l2] + last;
 +        sums[7] = sums[6] - src[l3] + last;
 +        sums[8] = sums[7] - src[l4] + last;
 +        sums[9] = sums[8] - src[l5] + last;
 +
 +        src[l1]= (sums[0] + sums[2] + 2*src[l1])>>4;
 +        src[l2]= (sums[1] + sums[3] + 2*src[l2])>>4;
 +        src[l3]= (sums[2] + sums[4] + 2*src[l3])>>4;
 +        src[l4]= (sums[3] + sums[5] + 2*src[l4])>>4;
 +        src[l5]= (sums[4] + sums[6] + 2*src[l5])>>4;
 +        src[l6]= (sums[5] + sums[7] + 2*src[l6])>>4;
 +        src[l7]= (sums[6] + sums[8] + 2*src[l7])>>4;
 +        src[l8]= (sums[7] + sums[9] + 2*src[l8])>>4;
 +
 +        src++;
 +    }
 +#endif //HAVE_MMX2 || HAVE_AMD3DNOW
 +}
 +#endif //HAVE_ALTIVEC
 +
 +/**
 + * Experimental Filter 1
 + * will not damage linear gradients
 + * Flat blocks should look like they were passed through the (1,1,2,2,4,2,2,1,1) 9-Tap filter
 + * can only smooth blocks at the expected locations (it cannot smooth them if they did move)
 + * MMX2 version does correct clipping C version does not
 + */
 +static inline void RENAME(vertX1Filter)(uint8_t *src, int stride, PPContext *co)
 +{
 +#if HAVE_MMX2 || HAVE_AMD3DNOW
 +    src+= stride*3;
 +
 +    __asm__ volatile(
 +        "pxor %%mm7, %%mm7                      \n\t" // 0
 +        "lea (%0, %1), %%"REG_a"                \n\t"
 +        "lea (%%"REG_a", %1, 4), %%"REG_c"      \n\t"
 +//      0       1       2       3       4       5       6       7       8       9
 +//      %0      eax     eax+%1  eax+2%1 %0+4%1  ecx     ecx+%1  ecx+2%1 %0+8%1  ecx+4%1
 +        "movq (%%"REG_a", %1, 2), %%mm0         \n\t" // line 3
 +        "movq (%0, %1, 4), %%mm1                \n\t" // line 4
 +        "movq %%mm1, %%mm2                      \n\t" // line 4
 +        "psubusb %%mm0, %%mm1                   \n\t"
 +        "psubusb %%mm2, %%mm0                   \n\t"
 +        "por %%mm1, %%mm0                       \n\t" // |l2 - l3|
 +        "movq (%%"REG_c"), %%mm3                \n\t" // line 5
 +        "movq (%%"REG_c", %1), %%mm4            \n\t" // line 6
 +        "movq %%mm3, %%mm5                      \n\t" // line 5
 +        "psubusb %%mm4, %%mm3                   \n\t"
 +        "psubusb %%mm5, %%mm4                   \n\t"
 +        "por %%mm4, %%mm3                       \n\t" // |l5 - l6|
 +        PAVGB(%%mm3, %%mm0)                           // (|l2 - l3| + |l5 - l6|)/2
 +        "movq %%mm2, %%mm1                      \n\t" // line 4
 +        "psubusb %%mm5, %%mm2                   \n\t"
 +        "movq %%mm2, %%mm4                      \n\t"
 +        "pcmpeqb %%mm7, %%mm2                   \n\t" // (l4 - l5) <= 0 ? -1 : 0
 +        "psubusb %%mm1, %%mm5                   \n\t"
 +        "por %%mm5, %%mm4                       \n\t" // |l4 - l5|
 +        "psubusb %%mm0, %%mm4                   \n\t" //d = MAX(0, |l4-l5| - (|l2-l3| + |l5-l6|)/2)
 +        "movq %%mm4, %%mm3                      \n\t" // d
 +        "movq %2, %%mm0                         \n\t"
 +        "paddusb %%mm0, %%mm0                   \n\t"
 +        "psubusb %%mm0, %%mm4                   \n\t"
 +        "pcmpeqb %%mm7, %%mm4                   \n\t" // d <= QP ? -1 : 0
 +        "psubusb "MANGLE(b01)", %%mm3           \n\t"
 +        "pand %%mm4, %%mm3                      \n\t" // d <= QP ? d : 0
 +
 +        PAVGB(%%mm7, %%mm3)                           // d/2
 +        "movq %%mm3, %%mm1                      \n\t" // d/2
 +        PAVGB(%%mm7, %%mm3)                           // d/4
 +        PAVGB(%%mm1, %%mm3)                           // 3*d/8
 +
 +        "movq (%0, %1, 4), %%mm0                \n\t" // line 4
 +        "pxor %%mm2, %%mm0                      \n\t" //(l4 - l5) <= 0 ? -l4-1 : l4
 +        "psubusb %%mm3, %%mm0                   \n\t"
 +        "pxor %%mm2, %%mm0                      \n\t"
 +        "movq %%mm0, (%0, %1, 4)                \n\t" // line 4
 +
 +        "movq (%%"REG_c"), %%mm0                \n\t" // line 5
 +        "pxor %%mm2, %%mm0                      \n\t" //(l4 - l5) <= 0 ? -l5-1 : l5
 +        "paddusb %%mm3, %%mm0                   \n\t"
 +        "pxor %%mm2, %%mm0                      \n\t"
 +        "movq %%mm0, (%%"REG_c")                \n\t" // line 5
 +
 +        PAVGB(%%mm7, %%mm1)                           // d/4
 +
 +        "movq (%%"REG_a", %1, 2), %%mm0         \n\t" // line 3
 +        "pxor %%mm2, %%mm0                      \n\t" //(l4 - l5) <= 0 ? -l4-1 : l4
 +        "psubusb %%mm1, %%mm0                   \n\t"
 +        "pxor %%mm2, %%mm0                      \n\t"
 +        "movq %%mm0, (%%"REG_a", %1, 2)         \n\t" // line 3
 +
 +        "movq (%%"REG_c", %1), %%mm0            \n\t" // line 6
 +        "pxor %%mm2, %%mm0                      \n\t" //(l4 - l5) <= 0 ? -l5-1 : l5
 +        "paddusb %%mm1, %%mm0                   \n\t"
 +        "pxor %%mm2, %%mm0                      \n\t"
 +        "movq %%mm0, (%%"REG_c", %1)            \n\t" // line 6
 +
 +        PAVGB(%%mm7, %%mm1)                           // d/8
 +
 +        "movq (%%"REG_a", %1), %%mm0            \n\t" // line 2
 +        "pxor %%mm2, %%mm0                      \n\t" //(l4 - l5) <= 0 ? -l2-1 : l2
 +        "psubusb %%mm1, %%mm0                   \n\t"
 +        "pxor %%mm2, %%mm0                      \n\t"
 +        "movq %%mm0, (%%"REG_a", %1)            \n\t" // line 2
 +
 +        "movq (%%"REG_c", %1, 2), %%mm0         \n\t" // line 7
 +        "pxor %%mm2, %%mm0                      \n\t" //(l4 - l5) <= 0 ? -l7-1 : l7
 +        "paddusb %%mm1, %%mm0                   \n\t"
 +        "pxor %%mm2, %%mm0                      \n\t"
 +        "movq %%mm0, (%%"REG_c", %1, 2)         \n\t" // line 7
 +
 +        :
 +        : "r" (src), "r" ((x86_reg)stride), "m" (co->pQPb)
 +        : "%"REG_a, "%"REG_c
 +    );
 +#else //HAVE_MMX2 || HAVE_AMD3DNOW
 +
 +    const int l1= stride;
 +    const int l2= stride + l1;
 +    const int l3= stride + l2;
 +    const int l4= stride + l3;
 +    const int l5= stride + l4;
 +    const int l6= stride + l5;
 +    const int l7= stride + l6;
 +//    const int l8= stride + l7;
 +//    const int l9= stride + l8;
 +    int x;
 +
 +    src+= stride*3;
 +    for(x=0; x<BLOCK_SIZE; x++){
 +        int a= src[l3] - src[l4];
 +        int b= src[l4] - src[l5];
 +        int c= src[l5] - src[l6];
 +
 +        int d= FFABS(b) - ((FFABS(a) + FFABS(c))>>1);
 +        d= FFMAX(d, 0);
 +
 +        if(d < co->QP*2){
 +            int v = d * FFSIGN(-b);
 +
 +            src[l2] +=v>>3;
 +            src[l3] +=v>>2;
 +            src[l4] +=(3*v)>>3;
 +            src[l5] -=(3*v)>>3;
 +            src[l6] -=v>>2;
 +            src[l7] -=v>>3;
 +        }
 +        src++;
 +    }
 +#endif //HAVE_MMX2 || HAVE_AMD3DNOW
 +}
 +
 +#if !HAVE_ALTIVEC
 +static inline void RENAME(doVertDefFilter)(uint8_t src[], int stride, PPContext *c)
 +{
 +#if HAVE_MMX2 || HAVE_AMD3DNOW
 +/*
 +    uint8_t tmp[16];
 +    const int l1= stride;
 +    const int l2= stride + l1;
 +    const int l3= stride + l2;
 +    const int l4= (int)tmp - (int)src - stride*3;
 +    const int l5= (int)tmp - (int)src - stride*3 + 8;
 +    const int l6= stride*3 + l3;
 +    const int l7= stride + l6;
 +    const int l8= stride + l7;
 +
 +    memcpy(tmp, src+stride*7, 8);
 +    memcpy(tmp+8, src+stride*8, 8);
 +*/
 +    src+= stride*4;
 +    __asm__ volatile(
 +
 +#if 0 //slightly more accurate and slightly slower
 +        "pxor %%mm7, %%mm7                      \n\t" // 0
 +        "lea (%0, %1), %%"REG_a"                \n\t"
 +        "lea (%%"REG_a", %1, 4), %%"REG_c"      \n\t"
 +//      0       1       2       3       4       5       6       7
 +//      %0      %0+%1   %0+2%1  eax+2%1 %0+4%1  eax+4%1 ecx+%1  ecx+2%1
 +//      %0      eax     eax+%1  eax+2%1 %0+4%1  ecx     ecx+%1  ecx+2%1
 +
 +
 +        "movq (%0, %1, 2), %%mm0                \n\t" // l2
 +        "movq (%0), %%mm1                       \n\t" // l0
 +        "movq %%mm0, %%mm2                      \n\t" // l2
 +        PAVGB(%%mm7, %%mm0)                           // ~l2/2
 +        PAVGB(%%mm1, %%mm0)                           // ~(l2 + 2l0)/4
 +        PAVGB(%%mm2, %%mm0)                           // ~(5l2 + 2l0)/8
 +
 +        "movq (%%"REG_a"), %%mm1                \n\t" // l1
 +        "movq (%%"REG_a", %1, 2), %%mm3         \n\t" // l3
 +        "movq %%mm1, %%mm4                      \n\t" // l1
 +        PAVGB(%%mm7, %%mm1)                           // ~l1/2
 +        PAVGB(%%mm3, %%mm1)                           // ~(l1 + 2l3)/4
 +        PAVGB(%%mm4, %%mm1)                           // ~(5l1 + 2l3)/8
 +
 +        "movq %%mm0, %%mm4                      \n\t" // ~(5l2 + 2l0)/8
 +        "psubusb %%mm1, %%mm0                   \n\t"
 +        "psubusb %%mm4, %%mm1                   \n\t"
 +        "por %%mm0, %%mm1                       \n\t" // ~|2l0 - 5l1 + 5l2 - 2l3|/8
 +// mm1= |lenergy|, mm2= l2, mm3= l3, mm7=0
 +
 +        "movq (%0, %1, 4), %%mm0                \n\t" // l4
 +        "movq %%mm0, %%mm4                      \n\t" // l4
 +        PAVGB(%%mm7, %%mm0)                           // ~l4/2
 +        PAVGB(%%mm2, %%mm0)                           // ~(l4 + 2l2)/4
 +        PAVGB(%%mm4, %%mm0)                           // ~(5l4 + 2l2)/8
 +
 +        "movq (%%"REG_c"), %%mm2                \n\t" // l5
 +        "movq %%mm3, %%mm5                      \n\t" // l3
 +        PAVGB(%%mm7, %%mm3)                           // ~l3/2
 +        PAVGB(%%mm2, %%mm3)                           // ~(l3 + 2l5)/4
 +        PAVGB(%%mm5, %%mm3)                           // ~(5l3 + 2l5)/8
 +
 +        "movq %%mm0, %%mm6                      \n\t" // ~(5l4 + 2l2)/8
 +        "psubusb %%mm3, %%mm0                   \n\t"
 +        "psubusb %%mm6, %%mm3                   \n\t"
 +        "por %%mm0, %%mm3                       \n\t" // ~|2l2 - 5l3 + 5l4 - 2l5|/8
 +        "pcmpeqb %%mm7, %%mm0                   \n\t" // SIGN(2l2 - 5l3 + 5l4 - 2l5)
 +// mm0= SIGN(menergy), mm1= |lenergy|, mm2= l5, mm3= |menergy|, mm4=l4, mm5= l3, mm7=0
 +
 +        "movq (%%"REG_c", %1), %%mm6            \n\t" // l6
 +        "movq %%mm6, %%mm5                      \n\t" // l6
 +        PAVGB(%%mm7, %%mm6)                           // ~l6/2
 +        PAVGB(%%mm4, %%mm6)                           // ~(l6 + 2l4)/4
 +        PAVGB(%%mm5, %%mm6)                           // ~(5l6 + 2l4)/8
 +
 +        "movq (%%"REG_c", %1, 2), %%mm5         \n\t" // l7
 +        "movq %%mm2, %%mm4                      \n\t" // l5
 +        PAVGB(%%mm7, %%mm2)                           // ~l5/2
 +        PAVGB(%%mm5, %%mm2)                           // ~(l5 + 2l7)/4
 +        PAVGB(%%mm4, %%mm2)                           // ~(5l5 + 2l7)/8
 +
 +        "movq %%mm6, %%mm4                      \n\t" // ~(5l6 + 2l4)/8
 +        "psubusb %%mm2, %%mm6                   \n\t"
 +        "psubusb %%mm4, %%mm2                   \n\t"
 +        "por %%mm6, %%mm2                       \n\t" // ~|2l4 - 5l5 + 5l6 - 2l7|/8
 +// mm0= SIGN(menergy), mm1= |lenergy|/8, mm2= |renergy|/8, mm3= |menergy|/8, mm7=0
 +
 +
 +        PMINUB(%%mm2, %%mm1, %%mm4)                   // MIN(|lenergy|,|renergy|)/8
 +        "movq %2, %%mm4                         \n\t" // QP //FIXME QP+1 ?
 +        "paddusb "MANGLE(b01)", %%mm4           \n\t"
 +        "pcmpgtb %%mm3, %%mm4                   \n\t" // |menergy|/8 < QP
 +        "psubusb %%mm1, %%mm3                   \n\t" // d=|menergy|/8-MIN(|lenergy|,|renergy|)/8
 +        "pand %%mm4, %%mm3                      \n\t"
 +
 +        "movq %%mm3, %%mm1                      \n\t"
 +//        "psubusb "MANGLE(b01)", %%mm3           \n\t"
 +        PAVGB(%%mm7, %%mm3)
 +        PAVGB(%%mm7, %%mm3)
 +        "paddusb %%mm1, %%mm3                   \n\t"
 +//        "paddusb "MANGLE(b01)", %%mm3           \n\t"
 +
 +        "movq (%%"REG_a", %1, 2), %%mm6         \n\t" //l3
 +        "movq (%0, %1, 4), %%mm5                \n\t" //l4
 +        "movq (%0, %1, 4), %%mm4                \n\t" //l4
 +        "psubusb %%mm6, %%mm5                   \n\t"
 +        "psubusb %%mm4, %%mm6                   \n\t"
 +        "por %%mm6, %%mm5                       \n\t" // |l3-l4|
 +        "pcmpeqb %%mm7, %%mm6                   \n\t" // SIGN(l3-l4)
 +        "pxor %%mm6, %%mm0                      \n\t"
 +        "pand %%mm0, %%mm3                      \n\t"
 +        PMINUB(%%mm5, %%mm3, %%mm0)
 +
 +        "psubusb "MANGLE(b01)", %%mm3           \n\t"
 +        PAVGB(%%mm7, %%mm3)
 +
 +        "movq (%%"REG_a", %1, 2), %%mm0         \n\t"
 +        "movq (%0, %1, 4), %%mm2                \n\t"
 +        "pxor %%mm6, %%mm0                      \n\t"
 +        "pxor %%mm6, %%mm2                      \n\t"
 +        "psubb %%mm3, %%mm0                     \n\t"
 +        "paddb %%mm3, %%mm2                     \n\t"
 +        "pxor %%mm6, %%mm0                      \n\t"
 +        "pxor %%mm6, %%mm2                      \n\t"
 +        "movq %%mm0, (%%"REG_a", %1, 2)         \n\t"
 +        "movq %%mm2, (%0, %1, 4)                \n\t"
 +#endif //0
 +
 +        "lea (%0, %1), %%"REG_a"                \n\t"
 +        "pcmpeqb %%mm6, %%mm6                   \n\t" // -1
 +//      0       1       2       3       4       5       6       7
 +//      %0      %0+%1   %0+2%1  eax+2%1 %0+4%1  eax+4%1 ecx+%1  ecx+2%1
 +//      %0      eax     eax+%1  eax+2%1 %0+4%1  ecx     ecx+%1  ecx+2%1
 +
 +
 +        "movq (%%"REG_a", %1, 2), %%mm1         \n\t" // l3
 +        "movq (%0, %1, 4), %%mm0                \n\t" // l4
 +        "pxor %%mm6, %%mm1                      \n\t" // -l3-1
 +        PAVGB(%%mm1, %%mm0)                           // -q+128 = (l4-l3+256)/2
 +// mm1=-l3-1, mm0=128-q
 +
 +        "movq (%%"REG_a", %1, 4), %%mm2         \n\t" // l5
 +        "movq (%%"REG_a", %1), %%mm3            \n\t" // l2
 +        "pxor %%mm6, %%mm2                      \n\t" // -l5-1
 +        "movq %%mm2, %%mm5                      \n\t" // -l5-1
 +        "movq "MANGLE(b80)", %%mm4              \n\t" // 128
 +        "lea (%%"REG_a", %1, 4), %%"REG_c"      \n\t"
 +        PAVGB(%%mm3, %%mm2)                           // (l2-l5+256)/2
 +        PAVGB(%%mm0, %%mm4)                           // ~(l4-l3)/4 + 128
 +        PAVGB(%%mm2, %%mm4)                           // ~(l2-l5)/4 +(l4-l3)/8 + 128
 +        PAVGB(%%mm0, %%mm4)                           // ~(l2-l5)/8 +5(l4-l3)/16 + 128
 +// mm1=-l3-1, mm0=128-q, mm3=l2, mm4=menergy/16 + 128, mm5= -l5-1
 +
 +        "movq (%%"REG_a"), %%mm2                \n\t" // l1
 +        "pxor %%mm6, %%mm2                      \n\t" // -l1-1
 +        PAVGB(%%mm3, %%mm2)                           // (l2-l1+256)/2
 +        PAVGB((%0), %%mm1)                            // (l0-l3+256)/2
 +        "movq "MANGLE(b80)", %%mm3              \n\t" // 128
 +        PAVGB(%%mm2, %%mm3)                           // ~(l2-l1)/4 + 128
 +        PAVGB(%%mm1, %%mm3)                           // ~(l0-l3)/4 +(l2-l1)/8 + 128
 +        PAVGB(%%mm2, %%mm3)                           // ~(l0-l3)/8 +5(l2-l1)/16 + 128
 +// mm0=128-q, mm3=lenergy/16 + 128, mm4= menergy/16 + 128, mm5= -l5-1
 +
 +        PAVGB((%%REGc, %1), %%mm5)                    // (l6-l5+256)/2
 +        "movq (%%"REG_c", %1, 2), %%mm1         \n\t" // l7
 +        "pxor %%mm6, %%mm1                      \n\t" // -l7-1
 +        PAVGB((%0, %1, 4), %%mm1)                     // (l4-l7+256)/2
 +        "movq "MANGLE(b80)", %%mm2              \n\t" // 128
 +        PAVGB(%%mm5, %%mm2)                           // ~(l6-l5)/4 + 128
 +        PAVGB(%%mm1, %%mm2)                           // ~(l4-l7)/4 +(l6-l5)/8 + 128
 +        PAVGB(%%mm5, %%mm2)                           // ~(l4-l7)/8 +5(l6-l5)/16 + 128
 +// mm0=128-q, mm2=renergy/16 + 128, mm3=lenergy/16 + 128, mm4= menergy/16 + 128
 +
 +        "movq "MANGLE(b00)", %%mm1              \n\t" // 0
 +        "movq "MANGLE(b00)", %%mm5              \n\t" // 0
 +        "psubb %%mm2, %%mm1                     \n\t" // 128 - renergy/16
 +        "psubb %%mm3, %%mm5                     \n\t" // 128 - lenergy/16
 +        PMAXUB(%%mm1, %%mm2)                          // 128 + |renergy/16|
 +        PMAXUB(%%mm5, %%mm3)                          // 128 + |lenergy/16|
 +        PMINUB(%%mm2, %%mm3, %%mm1)                   // 128 + MIN(|lenergy|,|renergy|)/16
 +
 +// mm0=128-q, mm3=128 + MIN(|lenergy|,|renergy|)/16, mm4= menergy/16 + 128
 +
 +        "movq "MANGLE(b00)", %%mm7              \n\t" // 0
 +        "movq %2, %%mm2                         \n\t" // QP
 +        PAVGB(%%mm6, %%mm2)                           // 128 + QP/2
 +        "psubb %%mm6, %%mm2                     \n\t"
 +
 +        "movq %%mm4, %%mm1                      \n\t"
 +        "pcmpgtb %%mm7, %%mm1                   \n\t" // SIGN(menergy)
 +        "pxor %%mm1, %%mm4                      \n\t"
 +        "psubb %%mm1, %%mm4                     \n\t" // 128 + |menergy|/16
 +        "pcmpgtb %%mm4, %%mm2                   \n\t" // |menergy|/16 < QP/2
 +        "psubusb %%mm3, %%mm4                   \n\t" //d=|menergy|/16 - MIN(|lenergy|,|renergy|)/16
 +// mm0=128-q, mm1= SIGN(menergy), mm2= |menergy|/16 < QP/2, mm4= d/16
 +
 +        "movq %%mm4, %%mm3                      \n\t" // d
 +        "psubusb "MANGLE(b01)", %%mm4           \n\t"
 +        PAVGB(%%mm7, %%mm4)                           // d/32
 +        PAVGB(%%mm7, %%mm4)                           // (d + 32)/64
 +        "paddb %%mm3, %%mm4                     \n\t" // 5d/64
 +        "pand %%mm2, %%mm4                      \n\t"
 +
 +        "movq "MANGLE(b80)", %%mm5              \n\t" // 128
 +        "psubb %%mm0, %%mm5                     \n\t" // q
 +        "paddsb %%mm6, %%mm5                    \n\t" // fix bad rounding
 +        "pcmpgtb %%mm5, %%mm7                   \n\t" // SIGN(q)
 +        "pxor %%mm7, %%mm5                      \n\t"
 +
 +        PMINUB(%%mm5, %%mm4, %%mm3)                   // MIN(|q|, 5d/64)
 +        "pxor %%mm1, %%mm7                      \n\t" // SIGN(d*q)
 +
 +        "pand %%mm7, %%mm4                      \n\t"
 +        "movq (%%"REG_a", %1, 2), %%mm0         \n\t"
 +        "movq (%0, %1, 4), %%mm2                \n\t"
 +        "pxor %%mm1, %%mm0                      \n\t"
 +        "pxor %%mm1, %%mm2                      \n\t"
 +        "paddb %%mm4, %%mm0                     \n\t"
 +        "psubb %%mm4, %%mm2                     \n\t"
 +        "pxor %%mm1, %%mm0                      \n\t"
 +        "pxor %%mm1, %%mm2                      \n\t"
 +        "movq %%mm0, (%%"REG_a", %1, 2)         \n\t"
 +        "movq %%mm2, (%0, %1, 4)                \n\t"
 +
 +        :
 +        : "r" (src), "r" ((x86_reg)stride), "m" (c->pQPb)
 +        : "%"REG_a, "%"REG_c
 +    );
 +
 +/*
 +    {
 +    int x;
 +    src-= stride;
 +    for(x=0; x<BLOCK_SIZE; x++){
 +        const int middleEnergy= 5*(src[l5] - src[l4]) + 2*(src[l3] - src[l6]);
 +        if(FFABS(middleEnergy)< 8*QP){
 +            const int q=(src[l4] - src[l5])/2;
 +            const int leftEnergy=  5*(src[l3] - src[l2]) + 2*(src[l1] - src[l4]);
 +            const int rightEnergy= 5*(src[l7] - src[l6]) + 2*(src[l5] - src[l8]);
 +
 +            int d= FFABS(middleEnergy) - FFMIN( FFABS(leftEnergy), FFABS(rightEnergy) );
 +            d= FFMAX(d, 0);
 +
 +            d= (5*d + 32) >> 6;
 +            d*= FFSIGN(-middleEnergy);
 +
 +            if(q>0){
 +                d= d<0 ? 0 : d;
 +                d= d>q ? q : d;
 +            }else{
 +                d= d>0 ? 0 : d;
 +                d= d<q ? q : d;
 +            }
 +
 +            src[l4]-= d;
 +            src[l5]+= d;
 +        }
 +        src++;
 +    }
 +    src-=8;
 +    for(x=0; x<8; x++){
 +        int y;
 +        for(y=4; y<6; y++){
 +            int d= src[x+y*stride] - tmp[x+(y-4)*8];
 +            int ad= FFABS(d);
 +            static int max=0;
 +            static int sum=0;
 +            static int num=0;
 +            static int bias=0;
 +
 +            if(max<ad) max=ad;
 +            sum+= ad>3 ? 1 : 0;
 +            if(ad>3){
 +                src[0] = src[7] = src[stride*7] = src[(stride+1)*7]=255;
 +            }
 +            if(y==4) bias+=d;
 +            num++;
 +            if(num%1000000 == 0){
 +                av_log(c, AV_LOG_INFO, " %d %d %d %d\n", num, sum, max, bias);
 +            }
 +        }
 +    }
 +}
 +*/
 +#elif HAVE_MMX
 +    DECLARE_ALIGNED(8, uint64_t, tmp)[4]; // make space for 4 8-byte vars
 +    src+= stride*4;
 +    __asm__ volatile(
 +        "pxor %%mm7, %%mm7                      \n\t"
 +//      0       1       2       3       4       5       6       7
 +//      %0      %0+%1   %0+2%1  eax+2%1 %0+4%1  eax+4%1 edx+%1  edx+2%1
 +//      %0      eax     eax+%1  eax+2%1 %0+4%1  edx     edx+%1  edx+2%1
 +
 +        "movq (%0), %%mm0                       \n\t"
 +        "movq %%mm0, %%mm1                      \n\t"
 +        "punpcklbw %%mm7, %%mm0                 \n\t" // low part of line 0
 +        "punpckhbw %%mm7, %%mm1                 \n\t" // high part of line 0
 +
 +        "movq (%0, %1), %%mm2                   \n\t"
 +        "lea (%0, %1, 2), %%"REG_a"             \n\t"
 +        "movq %%mm2, %%mm3                      \n\t"
 +        "punpcklbw %%mm7, %%mm2                 \n\t" // low part of line 1
 +        "punpckhbw %%mm7, %%mm3                 \n\t" // high part of line 1
 +
 +        "movq (%%"REG_a"), %%mm4                \n\t"
 +        "movq %%mm4, %%mm5                      \n\t"
 +        "punpcklbw %%mm7, %%mm4                 \n\t" // low part of line 2
 +        "punpckhbw %%mm7, %%mm5                 \n\t" // high part of line 2
 +
 +        "paddw %%mm0, %%mm0                     \n\t" // 2L0
 +        "paddw %%mm1, %%mm1                     \n\t" // 2H0
 +        "psubw %%mm4, %%mm2                     \n\t" // L1 - L2
 +        "psubw %%mm5, %%mm3                     \n\t" // H1 - H2
 +        "psubw %%mm2, %%mm0                     \n\t" // 2L0 - L1 + L2
 +        "psubw %%mm3, %%mm1                     \n\t" // 2H0 - H1 + H2
 +
 +        "psllw $2, %%mm2                        \n\t" // 4L1 - 4L2
 +        "psllw $2, %%mm3                        \n\t" // 4H1 - 4H2
 +        "psubw %%mm2, %%mm0                     \n\t" // 2L0 - 5L1 + 5L2
 +        "psubw %%mm3, %%mm1                     \n\t" // 2H0 - 5H1 + 5H2
 +
 +        "movq (%%"REG_a", %1), %%mm2            \n\t"
 +        "movq %%mm2, %%mm3                      \n\t"
 +        "punpcklbw %%mm7, %%mm2                 \n\t" // L3
 +        "punpckhbw %%mm7, %%mm3                 \n\t" // H3
 +
 +        "psubw %%mm2, %%mm0                     \n\t" // 2L0 - 5L1 + 5L2 - L3
 +        "psubw %%mm3, %%mm1                     \n\t" // 2H0 - 5H1 + 5H2 - H3
 +        "psubw %%mm2, %%mm0                     \n\t" // 2L0 - 5L1 + 5L2 - 2L3
 +        "psubw %%mm3, %%mm1                     \n\t" // 2H0 - 5H1 + 5H2 - 2H3
 +        "movq %%mm0, (%3)                       \n\t" // 2L0 - 5L1 + 5L2 - 2L3
 +        "movq %%mm1, 8(%3)                      \n\t" // 2H0 - 5H1 + 5H2 - 2H3
 +
 +        "movq (%%"REG_a", %1, 2), %%mm0         \n\t"
 +        "movq %%mm0, %%mm1                      \n\t"
 +        "punpcklbw %%mm7, %%mm0                 \n\t" // L4
 +        "punpckhbw %%mm7, %%mm1                 \n\t" // H4
 +
 +        "psubw %%mm0, %%mm2                     \n\t" // L3 - L4
 +        "psubw %%mm1, %%mm3                     \n\t" // H3 - H4
 +        "movq %%mm2, 16(%3)                     \n\t" // L3 - L4
 +        "movq %%mm3, 24(%3)                     \n\t" // H3 - H4
 +        "paddw %%mm4, %%mm4                     \n\t" // 2L2
 +        "paddw %%mm5, %%mm5                     \n\t" // 2H2
 +        "psubw %%mm2, %%mm4                     \n\t" // 2L2 - L3 + L4
 +        "psubw %%mm3, %%mm5                     \n\t" // 2H2 - H3 + H4
 +
 +        "lea (%%"REG_a", %1), %0                \n\t"
 +        "psllw $2, %%mm2                        \n\t" // 4L3 - 4L4
 +        "psllw $2, %%mm3                        \n\t" // 4H3 - 4H4
 +        "psubw %%mm2, %%mm4                     \n\t" // 2L2 - 5L3 + 5L4
 +        "psubw %%mm3, %%mm5                     \n\t" // 2H2 - 5H3 + 5H4
 +//50 opcodes so far
 +        "movq (%0, %1, 2), %%mm2                \n\t"
 +        "movq %%mm2, %%mm3                      \n\t"
 +        "punpcklbw %%mm7, %%mm2                 \n\t" // L5
 +        "punpckhbw %%mm7, %%mm3                 \n\t" // H5
 +        "psubw %%mm2, %%mm4                     \n\t" // 2L2 - 5L3 + 5L4 - L5
 +        "psubw %%mm3, %%mm5                     \n\t" // 2H2 - 5H3 + 5H4 - H5
 +        "psubw %%mm2, %%mm4                     \n\t" // 2L2 - 5L3 + 5L4 - 2L5
 +        "psubw %%mm3, %%mm5                     \n\t" // 2H2 - 5H3 + 5H4 - 2H5
 +
 +        "movq (%%"REG_a", %1, 4), %%mm6         \n\t"
 +        "punpcklbw %%mm7, %%mm6                 \n\t" // L6
 +        "psubw %%mm6, %%mm2                     \n\t" // L5 - L6
 +        "movq (%%"REG_a", %1, 4), %%mm6         \n\t"
 +        "punpckhbw %%mm7, %%mm6                 \n\t" // H6
 +        "psubw %%mm6, %%mm3                     \n\t" // H5 - H6
 +
 +        "paddw %%mm0, %%mm0                     \n\t" // 2L4
 +        "paddw %%mm1, %%mm1                     \n\t" // 2H4
 +        "psubw %%mm2, %%mm0                     \n\t" // 2L4 - L5 + L6
 +        "psubw %%mm3, %%mm1                     \n\t" // 2H4 - H5 + H6
 +
 +        "psllw $2, %%mm2                        \n\t" // 4L5 - 4L6
 +        "psllw $2, %%mm3                        \n\t" // 4H5 - 4H6
 +        "psubw %%mm2, %%mm0                     \n\t" // 2L4 - 5L5 + 5L6
 +        "psubw %%mm3, %%mm1                     \n\t" // 2H4 - 5H5 + 5H6
 +
 +        "movq (%0, %1, 4), %%mm2                \n\t"
 +        "movq %%mm2, %%mm3                      \n\t"
 +        "punpcklbw %%mm7, %%mm2                 \n\t" // L7
 +        "punpckhbw %%mm7, %%mm3                 \n\t" // H7
 +
 +        "paddw %%mm2, %%mm2                     \n\t" // 2L7
 +        "paddw %%mm3, %%mm3                     \n\t" // 2H7
 +        "psubw %%mm2, %%mm0                     \n\t" // 2L4 - 5L5 + 5L6 - 2L7
 +        "psubw %%mm3, %%mm1                     \n\t" // 2H4 - 5H5 + 5H6 - 2H7
 +
 +        "movq (%3), %%mm2                       \n\t" // 2L0 - 5L1 + 5L2 - 2L3
 +        "movq 8(%3), %%mm3                      \n\t" // 2H0 - 5H1 + 5H2 - 2H3
 +
 +#if HAVE_MMX2
 +        "movq %%mm7, %%mm6                      \n\t" // 0
 +        "psubw %%mm0, %%mm6                     \n\t"
 +        "pmaxsw %%mm6, %%mm0                    \n\t" // |2L4 - 5L5 + 5L6 - 2L7|
 +        "movq %%mm7, %%mm6                      \n\t" // 0
 +        "psubw %%mm1, %%mm6                     \n\t"
 +        "pmaxsw %%mm6, %%mm1                    \n\t" // |2H4 - 5H5 + 5H6 - 2H7|
 +        "movq %%mm7, %%mm6                      \n\t" // 0
 +        "psubw %%mm2, %%mm6                     \n\t"
 +        "pmaxsw %%mm6, %%mm2                    \n\t" // |2L0 - 5L1 + 5L2 - 2L3|
 +        "movq %%mm7, %%mm6                      \n\t" // 0
 +        "psubw %%mm3, %%mm6                     \n\t"
 +        "pmaxsw %%mm6, %%mm3                    \n\t" // |2H0 - 5H1 + 5H2 - 2H3|
 +#else
 +        "movq %%mm7, %%mm6                      \n\t" // 0
 +        "pcmpgtw %%mm0, %%mm6                   \n\t"
 +        "pxor %%mm6, %%mm0                      \n\t"
 +        "psubw %%mm6, %%mm0                     \n\t" // |2L4 - 5L5 + 5L6 - 2L7|
 +        "movq %%mm7, %%mm6                      \n\t" // 0
 +        "pcmpgtw %%mm1, %%mm6                   \n\t"
 +        "pxor %%mm6, %%mm1                      \n\t"
 +        "psubw %%mm6, %%mm1                     \n\t" // |2H4 - 5H5 + 5H6 - 2H7|
 +        "movq %%mm7, %%mm6                      \n\t" // 0
 +        "pcmpgtw %%mm2, %%mm6                   \n\t"
 +        "pxor %%mm6, %%mm2                      \n\t"
 +        "psubw %%mm6, %%mm2                     \n\t" // |2L0 - 5L1 + 5L2 - 2L3|
 +        "movq %%mm7, %%mm6                      \n\t" // 0
 +        "pcmpgtw %%mm3, %%mm6                   \n\t"
 +        "pxor %%mm6, %%mm3                      \n\t"
 +        "psubw %%mm6, %%mm3                     \n\t" // |2H0 - 5H1 + 5H2 - 2H3|
 +#endif
 +
 +#if HAVE_MMX2
 +        "pminsw %%mm2, %%mm0                    \n\t"
 +        "pminsw %%mm3, %%mm1                    \n\t"
 +#else
 +        "movq %%mm0, %%mm6                      \n\t"
 +        "psubusw %%mm2, %%mm6                   \n\t"
 +        "psubw %%mm6, %%mm0                     \n\t"
 +        "movq %%mm1, %%mm6                      \n\t"
 +        "psubusw %%mm3, %%mm6                   \n\t"
 +        "psubw %%mm6, %%mm1                     \n\t"
 +#endif
 +
 +        "movd %2, %%mm2                         \n\t" // QP
 +        "punpcklbw %%mm7, %%mm2                 \n\t"
 +
 +        "movq %%mm7, %%mm6                      \n\t" // 0
 +        "pcmpgtw %%mm4, %%mm6                   \n\t" // sign(2L2 - 5L3 + 5L4 - 2L5)
 +        "pxor %%mm6, %%mm4                      \n\t"
 +        "psubw %%mm6, %%mm4                     \n\t" // |2L2 - 5L3 + 5L4 - 2L5|
 +        "pcmpgtw %%mm5, %%mm7                   \n\t" // sign(2H2 - 5H3 + 5H4 - 2H5)
 +        "pxor %%mm7, %%mm5                      \n\t"
 +        "psubw %%mm7, %%mm5                     \n\t" // |2H2 - 5H3 + 5H4 - 2H5|
 +// 100 opcodes
 +        "psllw $3, %%mm2                        \n\t" // 8QP
 +        "movq %%mm2, %%mm3                      \n\t" // 8QP
 +        "pcmpgtw %%mm4, %%mm2                   \n\t"
 +        "pcmpgtw %%mm5, %%mm3                   \n\t"
 +        "pand %%mm2, %%mm4                      \n\t"
 +        "pand %%mm3, %%mm5                      \n\t"
 +
 +
 +        "psubusw %%mm0, %%mm4                   \n\t" // hd
 +        "psubusw %%mm1, %%mm5                   \n\t" // ld
 +
 +
 +        "movq "MANGLE(w05)", %%mm2              \n\t" // 5
 +        "pmullw %%mm2, %%mm4                    \n\t"
 +        "pmullw %%mm2, %%mm5                    \n\t"
 +        "movq "MANGLE(w20)", %%mm2              \n\t" // 32
 +        "paddw %%mm2, %%mm4                     \n\t"
 +        "paddw %%mm2, %%mm5                     \n\t"
 +        "psrlw $6, %%mm4                        \n\t"
 +        "psrlw $6, %%mm5                        \n\t"
 +
 +        "movq 16(%3), %%mm0                     \n\t" // L3 - L4
 +        "movq 24(%3), %%mm1                     \n\t" // H3 - H4
 +
 +        "pxor %%mm2, %%mm2                      \n\t"
 +        "pxor %%mm3, %%mm3                      \n\t"
 +
 +        "pcmpgtw %%mm0, %%mm2                   \n\t" // sign (L3-L4)
 +        "pcmpgtw %%mm1, %%mm3                   \n\t" // sign (H3-H4)
 +        "pxor %%mm2, %%mm0                      \n\t"
 +        "pxor %%mm3, %%mm1                      \n\t"
 +        "psubw %%mm2, %%mm0                     \n\t" // |L3-L4|
 +        "psubw %%mm3, %%mm1                     \n\t" // |H3-H4|
 +        "psrlw $1, %%mm0                        \n\t" // |L3 - L4|/2
 +        "psrlw $1, %%mm1                        \n\t" // |H3 - H4|/2
 +
 +        "pxor %%mm6, %%mm2                      \n\t"
 +        "pxor %%mm7, %%mm3                      \n\t"
 +        "pand %%mm2, %%mm4                      \n\t"
 +        "pand %%mm3, %%mm5                      \n\t"
 +
 +#if HAVE_MMX2
 +        "pminsw %%mm0, %%mm4                    \n\t"
 +        "pminsw %%mm1, %%mm5                    \n\t"
 +#else
 +        "movq %%mm4, %%mm2                      \n\t"
 +        "psubusw %%mm0, %%mm2                   \n\t"
 +        "psubw %%mm2, %%mm4                     \n\t"
 +        "movq %%mm5, %%mm2                      \n\t"
 +        "psubusw %%mm1, %%mm2                   \n\t"
 +        "psubw %%mm2, %%mm5                     \n\t"
 +#endif
 +        "pxor %%mm6, %%mm4                      \n\t"
 +        "pxor %%mm7, %%mm5                      \n\t"
 +        "psubw %%mm6, %%mm4                     \n\t"
 +        "psubw %%mm7, %%mm5                     \n\t"
 +        "packsswb %%mm5, %%mm4                  \n\t"
 +        "movq (%0), %%mm0                       \n\t"
 +        "paddb   %%mm4, %%mm0                   \n\t"
 +        "movq %%mm0, (%0)                       \n\t"
 +        "movq (%0, %1), %%mm0                   \n\t"
 +        "psubb %%mm4, %%mm0                     \n\t"
 +        "movq %%mm0, (%0, %1)                   \n\t"
 +
 +        : "+r" (src)
 +        : "r" ((x86_reg)stride), "m" (c->pQPb), "r"(tmp)
 +        : "%"REG_a
 +    );
 +#else //HAVE_MMX2 || HAVE_AMD3DNOW
 +    const int l1= stride;
 +    const int l2= stride + l1;
 +    const int l3= stride + l2;
 +    const int l4= stride + l3;
 +    const int l5= stride + l4;
 +    const int l6= stride + l5;
 +    const int l7= stride + l6;
 +    const int l8= stride + l7;
 +//    const int l9= stride + l8;
 +    int x;
 +    src+= stride*3;
 +    for(x=0; x<BLOCK_SIZE; x++){
 +        const int middleEnergy= 5*(src[l5] - src[l4]) + 2*(src[l3] - src[l6]);
 +        if(FFABS(middleEnergy) < 8*c->QP){
 +            const int q=(src[l4] - src[l5])/2;
 +            const int leftEnergy=  5*(src[l3] - src[l2]) + 2*(src[l1] - src[l4]);
 +            const int rightEnergy= 5*(src[l7] - src[l6]) + 2*(src[l5] - src[l8]);
 +
 +            int d= FFABS(middleEnergy) - FFMIN( FFABS(leftEnergy), FFABS(rightEnergy) );
 +            d= FFMAX(d, 0);
 +
 +            d= (5*d + 32) >> 6;
 +            d*= FFSIGN(-middleEnergy);
 +
 +            if(q>0){
 +                d= d<0 ? 0 : d;
 +                d= d>q ? q : d;
 +            }else{
 +                d= d>0 ? 0 : d;
 +                d= d<q ? q : d;
 +            }
 +
 +            src[l4]-= d;
 +            src[l5]+= d;
 +        }
 +        src++;
 +    }
 +#endif //HAVE_MMX2 || HAVE_AMD3DNOW
 +}
 +#endif //HAVE_ALTIVEC
 +
 +#if !HAVE_ALTIVEC
 +static inline void RENAME(dering)(uint8_t src[], int stride, PPContext *c)
 +{
 +#if HAVE_MMX2 || HAVE_AMD3DNOW
 +    DECLARE_ALIGNED(8, uint64_t, tmp)[3];
 +    __asm__ volatile(
 +        "pxor %%mm6, %%mm6                      \n\t"
 +        "pcmpeqb %%mm7, %%mm7                   \n\t"
 +        "movq %2, %%mm0                         \n\t"
 +        "punpcklbw %%mm6, %%mm0                 \n\t"
 +        "psrlw $1, %%mm0                        \n\t"
 +        "psubw %%mm7, %%mm0                     \n\t"
 +        "packuswb %%mm0, %%mm0                  \n\t"
 +        "movq %%mm0, %3                         \n\t"
 +
 +        "lea (%0, %1), %%"REG_a"                \n\t"
 +        "lea (%%"REG_a", %1, 4), %%"REG_d"      \n\t"
 +
 +//        0        1        2        3        4        5        6        7        8        9
 +//        %0        eax        eax+%1        eax+2%1        %0+4%1        edx        edx+%1        edx+2%1        %0+8%1        edx+4%1
 +
 +#undef REAL_FIND_MIN_MAX
 +#undef FIND_MIN_MAX
 +#if HAVE_MMX2
 +#define REAL_FIND_MIN_MAX(addr)\
 +        "movq " #addr ", %%mm0                  \n\t"\
 +        "pminub %%mm0, %%mm7                    \n\t"\
 +        "pmaxub %%mm0, %%mm6                    \n\t"
 +#else
 +#define REAL_FIND_MIN_MAX(addr)\
 +        "movq " #addr ", %%mm0                  \n\t"\
 +        "movq %%mm7, %%mm1                      \n\t"\
 +        "psubusb %%mm0, %%mm6                   \n\t"\
 +        "paddb %%mm0, %%mm6                     \n\t"\
 +        "psubusb %%mm0, %%mm1                   \n\t"\
 +        "psubb %%mm1, %%mm7                     \n\t"
 +#endif
 +#define FIND_MIN_MAX(addr)  REAL_FIND_MIN_MAX(addr)
 +
 +FIND_MIN_MAX((%%REGa))
 +FIND_MIN_MAX((%%REGa, %1))
 +FIND_MIN_MAX((%%REGa, %1, 2))
 +FIND_MIN_MAX((%0, %1, 4))
 +FIND_MIN_MAX((%%REGd))
 +FIND_MIN_MAX((%%REGd, %1))
 +FIND_MIN_MAX((%%REGd, %1, 2))
 +FIND_MIN_MAX((%0, %1, 8))
 +
 +        "movq %%mm7, %%mm4                      \n\t"
 +        "psrlq $8, %%mm7                        \n\t"
 +#if HAVE_MMX2
 +        "pminub %%mm4, %%mm7                    \n\t" // min of pixels
 +        "pshufw $0xF9, %%mm7, %%mm4             \n\t"
 +        "pminub %%mm4, %%mm7                    \n\t" // min of pixels
 +        "pshufw $0xFE, %%mm7, %%mm4             \n\t"
 +        "pminub %%mm4, %%mm7                    \n\t"
 +#else
 +        "movq %%mm7, %%mm1                      \n\t"
 +        "psubusb %%mm4, %%mm1                   \n\t"
 +        "psubb %%mm1, %%mm7                     \n\t"
 +        "movq %%mm7, %%mm4                      \n\t"
 +        "psrlq $16, %%mm7                       \n\t"
 +        "movq %%mm7, %%mm1                      \n\t"
 +        "psubusb %%mm4, %%mm1                   \n\t"
 +        "psubb %%mm1, %%mm7                     \n\t"
 +        "movq %%mm7, %%mm4                      \n\t"
 +        "psrlq $32, %%mm7                       \n\t"
 +        "movq %%mm7, %%mm1                      \n\t"
 +        "psubusb %%mm4, %%mm1                   \n\t"
 +        "psubb %%mm1, %%mm7                     \n\t"
 +#endif
 +
 +
 +        "movq %%mm6, %%mm4                      \n\t"
 +        "psrlq $8, %%mm6                        \n\t"
 +#if HAVE_MMX2
 +        "pmaxub %%mm4, %%mm6                    \n\t" // max of pixels
 +        "pshufw $0xF9, %%mm6, %%mm4             \n\t"
 +        "pmaxub %%mm4, %%mm6                    \n\t"
 +        "pshufw $0xFE, %%mm6, %%mm4             \n\t"
 +        "pmaxub %%mm4, %%mm6                    \n\t"
 +#else
 +        "psubusb %%mm4, %%mm6                   \n\t"
 +        "paddb %%mm4, %%mm6                     \n\t"
 +        "movq %%mm6, %%mm4                      \n\t"
 +        "psrlq $16, %%mm6                       \n\t"
 +        "psubusb %%mm4, %%mm6                   \n\t"
 +        "paddb %%mm4, %%mm6                     \n\t"
 +        "movq %%mm6, %%mm4                      \n\t"
 +        "psrlq $32, %%mm6                       \n\t"
 +        "psubusb %%mm4, %%mm6                   \n\t"
 +        "paddb %%mm4, %%mm6                     \n\t"
 +#endif
 +        "movq %%mm6, %%mm0                      \n\t" // max
 +        "psubb %%mm7, %%mm6                     \n\t" // max - min
 +        "push %4                              \n\t"
 +        "movd %%mm6, %k4                        \n\t"
 +        "cmpb "MANGLE(deringThreshold)", %b4    \n\t"
 +        "pop %4                               \n\t"
 +        " jb 1f                                 \n\t"
 +        PAVGB(%%mm0, %%mm7)                           // a=(max + min)/2
 +        "punpcklbw %%mm7, %%mm7                 \n\t"
 +        "punpcklbw %%mm7, %%mm7                 \n\t"
 +        "punpcklbw %%mm7, %%mm7                 \n\t"
 +        "movq %%mm7, (%4)                       \n\t"
 +
 +        "movq (%0), %%mm0                       \n\t" // L10
 +        "movq %%mm0, %%mm1                      \n\t" // L10
 +        "movq %%mm0, %%mm2                      \n\t" // L10
 +        "psllq $8, %%mm1                        \n\t"
 +        "psrlq $8, %%mm2                        \n\t"
 +        "movd -4(%0), %%mm3                     \n\t"
 +        "movd 8(%0), %%mm4                      \n\t"
 +        "psrlq $24, %%mm3                       \n\t"
 +        "psllq $56, %%mm4                       \n\t"
 +        "por %%mm3, %%mm1                       \n\t" // L00
 +        "por %%mm4, %%mm2                       \n\t" // L20
 +        "movq %%mm1, %%mm3                      \n\t" // L00
 +        PAVGB(%%mm2, %%mm1)                           // (L20 + L00)/2
 +        PAVGB(%%mm0, %%mm1)                           // (L20 + L00 + 2L10)/4
 +        "psubusb %%mm7, %%mm0                   \n\t"
 +        "psubusb %%mm7, %%mm2                   \n\t"
 +        "psubusb %%mm7, %%mm3                   \n\t"
 +        "pcmpeqb "MANGLE(b00)", %%mm0           \n\t" // L10 > a ? 0 : -1
 +        "pcmpeqb "MANGLE(b00)", %%mm2           \n\t" // L20 > a ? 0 : -1
 +        "pcmpeqb "MANGLE(b00)", %%mm3           \n\t" // L00 > a ? 0 : -1
 +        "paddb %%mm2, %%mm0                     \n\t"
 +        "paddb %%mm3, %%mm0                     \n\t"
 +
 +        "movq (%%"REG_a"), %%mm2                \n\t" // L11
 +        "movq %%mm2, %%mm3                      \n\t" // L11
 +        "movq %%mm2, %%mm4                      \n\t" // L11
 +        "psllq $8, %%mm3                        \n\t"
 +        "psrlq $8, %%mm4                        \n\t"
 +        "movd -4(%%"REG_a"), %%mm5              \n\t"
 +        "movd 8(%%"REG_a"), %%mm6               \n\t"
 +        "psrlq $24, %%mm5                       \n\t"
 +        "psllq $56, %%mm6                       \n\t"
 +        "por %%mm5, %%mm3                       \n\t" // L01
 +        "por %%mm6, %%mm4                       \n\t" // L21
 +        "movq %%mm3, %%mm5                      \n\t" // L01
 +        PAVGB(%%mm4, %%mm3)                           // (L21 + L01)/2
 +        PAVGB(%%mm2, %%mm3)                           // (L21 + L01 + 2L11)/4
 +        "psubusb %%mm7, %%mm2                   \n\t"
 +        "psubusb %%mm7, %%mm4                   \n\t"
 +        "psubusb %%mm7, %%mm5                   \n\t"
 +        "pcmpeqb "MANGLE(b00)", %%mm2           \n\t" // L11 > a ? 0 : -1
 +        "pcmpeqb "MANGLE(b00)", %%mm4           \n\t" // L21 > a ? 0 : -1
 +        "pcmpeqb "MANGLE(b00)", %%mm5           \n\t" // L01 > a ? 0 : -1
 +        "paddb %%mm4, %%mm2                     \n\t"
 +        "paddb %%mm5, %%mm2                     \n\t"
 +// 0, 2, 3, 1
 +#define REAL_DERING_CORE(dst,src,ppsx,psx,sx,pplx,plx,lx,t0,t1) \
 +        "movq " #src ", " #sx "                 \n\t" /* src[0] */\
 +        "movq " #sx ", " #lx "                  \n\t" /* src[0] */\
 +        "movq " #sx ", " #t0 "                  \n\t" /* src[0] */\
 +        "psllq $8, " #lx "                      \n\t"\
 +        "psrlq $8, " #t0 "                      \n\t"\
 +        "movd -4" #src ", " #t1 "               \n\t"\
 +        "psrlq $24, " #t1 "                     \n\t"\
 +        "por " #t1 ", " #lx "                   \n\t" /* src[-1] */\
 +        "movd 8" #src ", " #t1 "                \n\t"\
 +        "psllq $56, " #t1 "                     \n\t"\
 +        "por " #t1 ", " #t0 "                   \n\t" /* src[+1] */\
 +        "movq " #lx ", " #t1 "                  \n\t" /* src[-1] */\
 +        PAVGB(t0, lx)                                 /* (src[-1] + src[+1])/2 */\
 +        PAVGB(sx, lx)                                 /* (src[-1] + 2src[0] + src[+1])/4 */\
 +        PAVGB(lx, pplx)                                     \
 +        "movq " #lx ", 8(%4)                    \n\t"\
 +        "movq (%4), " #lx "                     \n\t"\
 +        "psubusb " #lx ", " #t1 "               \n\t"\
 +        "psubusb " #lx ", " #t0 "               \n\t"\
 +        "psubusb " #lx ", " #sx "               \n\t"\
 +        "movq "MANGLE(b00)", " #lx "            \n\t"\
 +        "pcmpeqb " #lx ", " #t1 "               \n\t" /* src[-1] > a ? 0 : -1*/\
 +        "pcmpeqb " #lx ", " #t0 "               \n\t" /* src[+1] > a ? 0 : -1*/\
 +        "pcmpeqb " #lx ", " #sx "               \n\t" /* src[0]  > a ? 0 : -1*/\
 +        "paddb " #t1 ", " #t0 "                 \n\t"\
 +        "paddb " #t0 ", " #sx "                 \n\t"\
 +\
 +        PAVGB(plx, pplx)                              /* filtered */\
 +        "movq " #dst ", " #t0 "                 \n\t" /* dst */\
 +        "movq " #t0 ", " #t1 "                  \n\t" /* dst */\
 +        "psubusb %3, " #t0 "                    \n\t"\
 +        "paddusb %3, " #t1 "                    \n\t"\
 +        PMAXUB(t0, pplx)\
 +        PMINUB(t1, pplx, t0)\
 +        "paddb " #sx ", " #ppsx "               \n\t"\
 +        "paddb " #psx ", " #ppsx "              \n\t"\
 +        "#paddb "MANGLE(b02)", " #ppsx "        \n\t"\
 +        "pand "MANGLE(b08)", " #ppsx "          \n\t"\
 +        "pcmpeqb " #lx ", " #ppsx "             \n\t"\
 +        "pand " #ppsx ", " #pplx "              \n\t"\
 +        "pandn " #dst ", " #ppsx "              \n\t"\
 +        "por " #pplx ", " #ppsx "               \n\t"\
 +        "movq " #ppsx ", " #dst "               \n\t"\
 +        "movq 8(%4), " #lx "                    \n\t"
 +
 +#define DERING_CORE(dst,src,ppsx,psx,sx,pplx,plx,lx,t0,t1) \
 +   REAL_DERING_CORE(dst,src,ppsx,psx,sx,pplx,plx,lx,t0,t1)
 +/*
 +0000000
 +1111111
 +
 +1111110
 +1111101
 +1111100
 +1111011
 +1111010
 +1111001
 +
 +1111000
 +1110111
 +
 +*/
 +//DERING_CORE(dst          ,src            ,ppsx ,psx  ,sx   ,pplx ,plx  ,lx   ,t0   ,t1)
 +DERING_CORE((%%REGa)       ,(%%REGa, %1)   ,%%mm0,%%mm2,%%mm4,%%mm1,%%mm3,%%mm5,%%mm6,%%mm7)
 +DERING_CORE((%%REGa, %1)   ,(%%REGa, %1, 2),%%mm2,%%mm4,%%mm0,%%mm3,%%mm5,%%mm1,%%mm6,%%mm7)
 +DERING_CORE((%%REGa, %1, 2),(%0, %1, 4)    ,%%mm4,%%mm0,%%mm2,%%mm5,%%mm1,%%mm3,%%mm6,%%mm7)
 +DERING_CORE((%0, %1, 4)    ,(%%REGd)       ,%%mm0,%%mm2,%%mm4,%%mm1,%%mm3,%%mm5,%%mm6,%%mm7)
 +DERING_CORE((%%REGd)       ,(%%REGd, %1)   ,%%mm2,%%mm4,%%mm0,%%mm3,%%mm5,%%mm1,%%mm6,%%mm7)
 +DERING_CORE((%%REGd, %1)   ,(%%REGd, %1, 2),%%mm4,%%mm0,%%mm2,%%mm5,%%mm1,%%mm3,%%mm6,%%mm7)
 +DERING_CORE((%%REGd, %1, 2),(%0, %1, 8)    ,%%mm0,%%mm2,%%mm4,%%mm1,%%mm3,%%mm5,%%mm6,%%mm7)
 +DERING_CORE((%0, %1, 8)    ,(%%REGd, %1, 4),%%mm2,%%mm4,%%mm0,%%mm3,%%mm5,%%mm1,%%mm6,%%mm7)
 +
 +        "1:                        \n\t"
 +        : : "r" (src), "r" ((x86_reg)stride), "m" (c->pQPb), "m"(c->pQPb2), "q"(tmp)
 +        : "%"REG_a, "%"REG_d
 +    );
 +#else //HAVE_MMX2 || HAVE_AMD3DNOW
 +    int y;
 +    int min=255;
 +    int max=0;
 +    int avg;
 +    uint8_t *p;
 +    int s[10];
 +    const int QP2= c->QP/2 + 1;
 +
 +    for(y=1; y<9; y++){
 +        int x;
 +        p= src + stride*y;
 +        for(x=1; x<9; x++){
 +            p++;
 +            if(*p > max) max= *p;
 +            if(*p < min) min= *p;
 +        }
 +    }
 +    avg= (min + max + 1)>>1;
 +
 +    if(max - min <deringThreshold) return;
 +
 +    for(y=0; y<10; y++){
 +        int t = 0;
 +
 +        if(src[stride*y + 0] > avg) t+= 1;
 +        if(src[stride*y + 1] > avg) t+= 2;
 +        if(src[stride*y + 2] > avg) t+= 4;
 +        if(src[stride*y + 3] > avg) t+= 8;
 +        if(src[stride*y + 4] > avg) t+= 16;
 +        if(src[stride*y + 5] > avg) t+= 32;
 +        if(src[stride*y + 6] > avg) t+= 64;
 +        if(src[stride*y + 7] > avg) t+= 128;
 +        if(src[stride*y + 8] > avg) t+= 256;
 +        if(src[stride*y + 9] > avg) t+= 512;
 +
 +        t |= (~t)<<16;
 +        t &= (t<<1) & (t>>1);
 +        s[y] = t;
 +    }
 +
 +    for(y=1; y<9; y++){
 +        int t = s[y-1] & s[y] & s[y+1];
 +        t|= t>>16;
 +        s[y-1]= t;
 +    }
 +
 +    for(y=1; y<9; y++){
 +        int x;
 +        int t = s[y-1];
 +
 +        p= src + stride*y;
 +        for(x=1; x<9; x++){
 +            p++;
 +            if(t & (1<<x)){
 +                int f= (*(p-stride-1)) + 2*(*(p-stride)) + (*(p-stride+1))
 +                      +2*(*(p     -1)) + 4*(*p         ) + 2*(*(p     +1))
 +                      +(*(p+stride-1)) + 2*(*(p+stride)) + (*(p+stride+1));
 +                f= (f + 8)>>4;
 +
 +#ifdef DEBUG_DERING_THRESHOLD
 +                    __asm__ volatile("emms\n\t":);
 +                    {
 +                    static long long numPixels=0;
 +                    if(x!=1 && x!=8 && y!=1 && y!=8) numPixels++;
 +//                    if((max-min)<20 || (max-min)*QP<200)
 +//                    if((max-min)*QP < 500)
 +//                    if(max-min<QP/2)
 +                    if(max-min < 20){
 +                        static int numSkipped=0;
 +                        static int errorSum=0;
 +                        static int worstQP=0;
 +                        static int worstRange=0;
 +                        static int worstDiff=0;
 +                        int diff= (f - *p);
 +                        int absDiff= FFABS(diff);
 +                        int error= diff*diff;
 +
 +                        if(x==1 || x==8 || y==1 || y==8) continue;
 +
 +                        numSkipped++;
 +                        if(absDiff > worstDiff){
 +                            worstDiff= absDiff;
 +                            worstQP= QP;
 +                            worstRange= max-min;
 +                        }
 +                        errorSum+= error;
 +
 +                        if(1024LL*1024LL*1024LL % numSkipped == 0){
 +                            av_log(c, AV_LOG_INFO, "sum:%1.3f, skip:%d, wQP:%d, "
 +                                   "wRange:%d, wDiff:%d, relSkip:%1.3f\n",
 +                                   (float)errorSum/numSkipped, numSkipped, worstQP, worstRange,
 +                                   worstDiff, (float)numSkipped/numPixels);
 +                        }
 +                    }
 +                    }
 +#endif
 +                    if     (*p + QP2 < f) *p= *p + QP2;
 +                    else if(*p - QP2 > f) *p= *p - QP2;
 +                    else *p=f;
 +            }
 +        }
 +    }
 +#ifdef DEBUG_DERING_THRESHOLD
 +    if(max-min < 20){
 +        for(y=1; y<9; y++){
 +            int x;
 +            int t = 0;
 +            p= src + stride*y;
 +            for(x=1; x<9; x++){
 +                p++;
 +                *p = FFMIN(*p + 20, 255);
 +            }
 +        }
 +//        src[0] = src[7]=src[stride*7]=src[stride*7 + 7]=255;
 +    }
 +#endif
 +#endif //HAVE_MMX2 || HAVE_AMD3DNOW
 +}
 +#endif //HAVE_ALTIVEC
 +
 +/**
 + * Deinterlace the given block by linearly interpolating every second line.
 + * will be called for every 8x8 block and can read & write from line 4-15
 + * lines 0-3 have been passed through the deblock / dering filters already, but can be read, too.
 + * lines 4-12 will be read into the deblocking filter and should be deinterlaced
 + */
 +static inline void RENAME(deInterlaceInterpolateLinear)(uint8_t src[], int stride)
 +{
 +#if HAVE_MMX2 || HAVE_AMD3DNOW
 +    src+= 4*stride;
 +    __asm__ volatile(
 +        "lea (%0, %1), %%"REG_a"                \n\t"
 +        "lea (%%"REG_a", %1, 4), %%"REG_c"      \n\t"
 +//      0       1       2       3       4       5       6       7       8       9
 +//      %0      eax     eax+%1  eax+2%1 %0+4%1  ecx     ecx+%1  ecx+2%1 %0+8%1  ecx+4%1
 +
 +        "movq (%0), %%mm0                       \n\t"
 +        "movq (%%"REG_a", %1), %%mm1            \n\t"
 +        PAVGB(%%mm1, %%mm0)
 +        "movq %%mm0, (%%"REG_a")                \n\t"
 +        "movq (%0, %1, 4), %%mm0                \n\t"
 +        PAVGB(%%mm0, %%mm1)
 +        "movq %%mm1, (%%"REG_a", %1, 2)         \n\t"
 +        "movq (%%"REG_c", %1), %%mm1            \n\t"
 +        PAVGB(%%mm1, %%mm0)
 +        "movq %%mm0, (%%"REG_c")                \n\t"
 +        "movq (%0, %1, 8), %%mm0                \n\t"
 +        PAVGB(%%mm0, %%mm1)
 +        "movq %%mm1, (%%"REG_c", %1, 2)         \n\t"
 +
 +        : : "r" (src), "r" ((x86_reg)stride)
 +        : "%"REG_a, "%"REG_c
 +    );
 +#else
 +    int a, b, x;
 +    src+= 4*stride;
 +
 +    for(x=0; x<2; x++){
 +        a= *(uint32_t*)&src[stride*0];
 +        b= *(uint32_t*)&src[stride*2];
 +        *(uint32_t*)&src[stride*1]= (a|b) - (((a^b)&0xFEFEFEFEUL)>>1);
 +        a= *(uint32_t*)&src[stride*4];
 +        *(uint32_t*)&src[stride*3]= (a|b) - (((a^b)&0xFEFEFEFEUL)>>1);
 +        b= *(uint32_t*)&src[stride*6];
 +        *(uint32_t*)&src[stride*5]= (a|b) - (((a^b)&0xFEFEFEFEUL)>>1);
 +        a= *(uint32_t*)&src[stride*8];
 +        *(uint32_t*)&src[stride*7]= (a|b) - (((a^b)&0xFEFEFEFEUL)>>1);
 +        src += 4;
 +    }
 +#endif
 +}
 +
 +/**
 + * Deinterlace the given block by cubic interpolating every second line.
 + * will be called for every 8x8 block and can read & write from line 4-15
 + * lines 0-3 have been passed through the deblock / dering filters already, but can be read, too.
 + * lines 4-12 will be read into the deblocking filter and should be deinterlaced
 + * this filter will read lines 3-15 and write 7-13
 + */
 +static inline void RENAME(deInterlaceInterpolateCubic)(uint8_t src[], int stride)
 +{
 +#if HAVE_MMX2 || HAVE_AMD3DNOW
 +    src+= stride*3;
 +    __asm__ volatile(
 +        "lea (%0, %1), %%"REG_a"                \n\t"
 +        "lea (%%"REG_a", %1, 4), %%"REG_d"      \n\t"
 +        "lea (%%"REG_d", %1, 4), %%"REG_c"      \n\t"
 +        "add %1, %%"REG_c"                      \n\t"
 +        "pxor %%mm7, %%mm7                      \n\t"
 +//      0       1       2       3       4       5       6       7       8       9       10
 +//      %0      eax     eax+%1  eax+2%1 %0+4%1  edx     edx+%1  edx+2%1 %0+8%1  edx+4%1 ecx
 +
 +#define REAL_DEINT_CUBIC(a,b,c,d,e)\
 +        "movq " #a ", %%mm0                     \n\t"\
 +        "movq " #b ", %%mm1                     \n\t"\
 +        "movq " #d ", %%mm2                     \n\t"\
 +        "movq " #e ", %%mm3                     \n\t"\
 +        PAVGB(%%mm2, %%mm1)                             /* (b+d) /2 */\
 +        PAVGB(%%mm3, %%mm0)                             /* a(a+e) /2 */\
 +        "movq %%mm0, %%mm2                      \n\t"\
 +        "punpcklbw %%mm7, %%mm0                 \n\t"\
 +        "punpckhbw %%mm7, %%mm2                 \n\t"\
 +        "movq %%mm1, %%mm3                      \n\t"\
 +        "punpcklbw %%mm7, %%mm1                 \n\t"\
 +        "punpckhbw %%mm7, %%mm3                 \n\t"\
 +        "psubw %%mm1, %%mm0                     \n\t"   /* L(a+e - (b+d))/2 */\
 +        "psubw %%mm3, %%mm2                     \n\t"   /* H(a+e - (b+d))/2 */\
 +        "psraw $3, %%mm0                        \n\t"   /* L(a+e - (b+d))/16 */\
 +        "psraw $3, %%mm2                        \n\t"   /* H(a+e - (b+d))/16 */\
 +        "psubw %%mm0, %%mm1                     \n\t"   /* L(9b + 9d - a - e)/16 */\
 +        "psubw %%mm2, %%mm3                     \n\t"   /* H(9b + 9d - a - e)/16 */\
 +        "packuswb %%mm3, %%mm1                  \n\t"\
 +        "movq %%mm1, " #c "                     \n\t"
 +#define DEINT_CUBIC(a,b,c,d,e)  REAL_DEINT_CUBIC(a,b,c,d,e)
 +
 +DEINT_CUBIC((%0)        , (%%REGa, %1), (%%REGa, %1, 2), (%0, %1, 4) , (%%REGd, %1))
 +DEINT_CUBIC((%%REGa, %1), (%0, %1, 4) , (%%REGd)       , (%%REGd, %1), (%0, %1, 8))
 +DEINT_CUBIC((%0, %1, 4) , (%%REGd, %1), (%%REGd, %1, 2), (%0, %1, 8) , (%%REGc))
 +DEINT_CUBIC((%%REGd, %1), (%0, %1, 8) , (%%REGd, %1, 4), (%%REGc)    , (%%REGc, %1, 2))
 +
 +        : : "r" (src), "r" ((x86_reg)stride)
 +        : "%"REG_a, "%"REG_d, "%"REG_c
 +    );
 +#else //HAVE_MMX2 || HAVE_AMD3DNOW
 +    int x;
 +    src+= stride*3;
 +    for(x=0; x<8; x++){
 +        src[stride*3] = CLIP((-src[0]        + 9*src[stride*2] + 9*src[stride*4] - src[stride*6])>>4);
 +        src[stride*5] = CLIP((-src[stride*2] + 9*src[stride*4] + 9*src[stride*6] - src[stride*8])>>4);
 +        src[stride*7] = CLIP((-src[stride*4] + 9*src[stride*6] + 9*src[stride*8] - src[stride*10])>>4);
 +        src[stride*9] = CLIP((-src[stride*6] + 9*src[stride*8] + 9*src[stride*10] - src[stride*12])>>4);
 +        src++;
 +    }
 +#endif //HAVE_MMX2 || HAVE_AMD3DNOW
 +}
 +
 +/**
 + * Deinterlace the given block by filtering every second line with a (-1 4 2 4 -1) filter.
 + * will be called for every 8x8 block and can read & write from line 4-15
 + * lines 0-3 have been passed through the deblock / dering filters already, but can be read, too.
 + * lines 4-12 will be read into the deblocking filter and should be deinterlaced
 + * this filter will read lines 4-13 and write 5-11
 + */
 +static inline void RENAME(deInterlaceFF)(uint8_t src[], int stride, uint8_t *tmp)
 +{
 +#if HAVE_MMX2 || HAVE_AMD3DNOW
 +    src+= stride*4;
 +    __asm__ volatile(
 +        "lea (%0, %1), %%"REG_a"                \n\t"
 +        "lea (%%"REG_a", %1, 4), %%"REG_d"      \n\t"
 +        "pxor %%mm7, %%mm7                      \n\t"
 +        "movq (%2), %%mm0                       \n\t"
 +//      0       1       2       3       4       5       6       7       8       9       10
 +//      %0      eax     eax+%1  eax+2%1 %0+4%1  edx     edx+%1  edx+2%1 %0+8%1  edx+4%1 ecx
 +
 +#define REAL_DEINT_FF(a,b,c,d)\
 +        "movq " #a ", %%mm1                     \n\t"\
 +        "movq " #b ", %%mm2                     \n\t"\
 +        "movq " #c ", %%mm3                     \n\t"\
 +        "movq " #d ", %%mm4                     \n\t"\
 +        PAVGB(%%mm3, %%mm1)                          \
 +        PAVGB(%%mm4, %%mm0)                          \
 +        "movq %%mm0, %%mm3                      \n\t"\
 +        "punpcklbw %%mm7, %%mm0                 \n\t"\
 +        "punpckhbw %%mm7, %%mm3                 \n\t"\
 +        "movq %%mm1, %%mm4                      \n\t"\
 +        "punpcklbw %%mm7, %%mm1                 \n\t"\
 +        "punpckhbw %%mm7, %%mm4                 \n\t"\
 +        "psllw $2, %%mm1                        \n\t"\
 +        "psllw $2, %%mm4                        \n\t"\
 +        "psubw %%mm0, %%mm1                     \n\t"\
 +        "psubw %%mm3, %%mm4                     \n\t"\
 +        "movq %%mm2, %%mm5                      \n\t"\
 +        "movq %%mm2, %%mm0                      \n\t"\
 +        "punpcklbw %%mm7, %%mm2                 \n\t"\
 +        "punpckhbw %%mm7, %%mm5                 \n\t"\
 +        "paddw %%mm2, %%mm1                     \n\t"\
 +        "paddw %%mm5, %%mm4                     \n\t"\
 +        "psraw $2, %%mm1                        \n\t"\
 +        "psraw $2, %%mm4                        \n\t"\
 +        "packuswb %%mm4, %%mm1                  \n\t"\
 +        "movq %%mm1, " #b "                     \n\t"\
 +
 +#define DEINT_FF(a,b,c,d)  REAL_DEINT_FF(a,b,c,d)
 +
 +DEINT_FF((%0)        , (%%REGa)       , (%%REGa, %1), (%%REGa, %1, 2))
 +DEINT_FF((%%REGa, %1), (%%REGa, %1, 2), (%0, %1, 4) , (%%REGd)       )
 +DEINT_FF((%0, %1, 4) , (%%REGd)       , (%%REGd, %1), (%%REGd, %1, 2))
 +DEINT_FF((%%REGd, %1), (%%REGd, %1, 2), (%0, %1, 8) , (%%REGd, %1, 4))
 +
 +        "movq %%mm0, (%2)                       \n\t"
 +        : : "r" (src), "r" ((x86_reg)stride), "r"(tmp)
 +        : "%"REG_a, "%"REG_d
 +    );
 +#else //HAVE_MMX2 || HAVE_AMD3DNOW
 +    int x;
 +    src+= stride*4;
 +    for(x=0; x<8; x++){
 +        int t1= tmp[x];
 +        int t2= src[stride*1];
 +
 +        src[stride*1]= CLIP((-t1 + 4*src[stride*0] + 2*t2 + 4*src[stride*2] - src[stride*3] + 4)>>3);
 +        t1= src[stride*4];
 +        src[stride*3]= CLIP((-t2 + 4*src[stride*2] + 2*t1 + 4*src[stride*4] - src[stride*5] + 4)>>3);
 +        t2= src[stride*6];
 +        src[stride*5]= CLIP((-t1 + 4*src[stride*4] + 2*t2 + 4*src[stride*6] - src[stride*7] + 4)>>3);
 +        t1= src[stride*8];
 +        src[stride*7]= CLIP((-t2 + 4*src[stride*6] + 2*t1 + 4*src[stride*8] - src[stride*9] + 4)>>3);
 +        tmp[x]= t1;
 +
 +        src++;
 +    }
 +#endif //HAVE_MMX2 || HAVE_AMD3DNOW
 +}
 +
 +/**
 + * Deinterlace the given block by filtering every line with a (-1 2 6 2 -1) filter.
 + * will be called for every 8x8 block and can read & write from line 4-15
 + * lines 0-3 have been passed through the deblock / dering filters already, but can be read, too.
 + * lines 4-12 will be read into the deblocking filter and should be deinterlaced
 + * this filter will read lines 4-13 and write 4-11
 + */
 +static inline void RENAME(deInterlaceL5)(uint8_t src[], int stride, uint8_t *tmp, uint8_t *tmp2)
 +{
 +#if HAVE_MMX2 || HAVE_AMD3DNOW
 +    src+= stride*4;
 +    __asm__ volatile(
 +        "lea (%0, %1), %%"REG_a"                \n\t"
 +        "lea (%%"REG_a", %1, 4), %%"REG_d"      \n\t"
 +        "pxor %%mm7, %%mm7                      \n\t"
 +        "movq (%2), %%mm0                       \n\t"
 +        "movq (%3), %%mm1                       \n\t"
 +//      0       1       2       3       4       5       6       7       8       9       10
 +//      %0      eax     eax+%1  eax+2%1 %0+4%1  edx     edx+%1  edx+2%1 %0+8%1  edx+4%1 ecx
 +
 +#define REAL_DEINT_L5(t1,t2,a,b,c)\
 +        "movq " #a ", %%mm2                     \n\t"\
 +        "movq " #b ", %%mm3                     \n\t"\
 +        "movq " #c ", %%mm4                     \n\t"\
 +        PAVGB(t2, %%mm3)                             \
 +        PAVGB(t1, %%mm4)                             \
 +        "movq %%mm2, %%mm5                      \n\t"\
 +        "movq %%mm2, " #t1 "                    \n\t"\
 +        "punpcklbw %%mm7, %%mm2                 \n\t"\
 +        "punpckhbw %%mm7, %%mm5                 \n\t"\
 +        "movq %%mm2, %%mm6                      \n\t"\
 +        "paddw %%mm2, %%mm2                     \n\t"\
 +        "paddw %%mm6, %%mm2                     \n\t"\
 +        "movq %%mm5, %%mm6                      \n\t"\
 +        "paddw %%mm5, %%mm5                     \n\t"\
 +        "paddw %%mm6, %%mm5                     \n\t"\
 +        "movq %%mm3, %%mm6                      \n\t"\
 +        "punpcklbw %%mm7, %%mm3                 \n\t"\
 +        "punpckhbw %%mm7, %%mm6                 \n\t"\
 +        "paddw %%mm3, %%mm3                     \n\t"\
 +        "paddw %%mm6, %%mm6                     \n\t"\
 +        "paddw %%mm3, %%mm2                     \n\t"\
 +        "paddw %%mm6, %%mm5                     \n\t"\
 +        "movq %%mm4, %%mm6                      \n\t"\
 +        "punpcklbw %%mm7, %%mm4                 \n\t"\
 +        "punpckhbw %%mm7, %%mm6                 \n\t"\
 +        "psubw %%mm4, %%mm2                     \n\t"\
 +        "psubw %%mm6, %%mm5                     \n\t"\
 +        "psraw $2, %%mm2                        \n\t"\
 +        "psraw $2, %%mm5                        \n\t"\
 +        "packuswb %%mm5, %%mm2                  \n\t"\
 +        "movq %%mm2, " #a "                     \n\t"\
 +
 +#define DEINT_L5(t1,t2,a,b,c)  REAL_DEINT_L5(t1,t2,a,b,c)
 +
 +DEINT_L5(%%mm0, %%mm1, (%0)           , (%%REGa)       , (%%REGa, %1)   )
 +DEINT_L5(%%mm1, %%mm0, (%%REGa)       , (%%REGa, %1)   , (%%REGa, %1, 2))
 +DEINT_L5(%%mm0, %%mm1, (%%REGa, %1)   , (%%REGa, %1, 2), (%0, %1, 4)   )
 +DEINT_L5(%%mm1, %%mm0, (%%REGa, %1, 2), (%0, %1, 4)    , (%%REGd)       )
 +DEINT_L5(%%mm0, %%mm1, (%0, %1, 4)    , (%%REGd)       , (%%REGd, %1)   )
 +DEINT_L5(%%mm1, %%mm0, (%%REGd)       , (%%REGd, %1)   , (%%REGd, %1, 2))
 +DEINT_L5(%%mm0, %%mm1, (%%REGd, %1)   , (%%REGd, %1, 2), (%0, %1, 8)   )
 +DEINT_L5(%%mm1, %%mm0, (%%REGd, %1, 2), (%0, %1, 8)    , (%%REGd, %1, 4))
 +
 +        "movq %%mm0, (%2)                       \n\t"
 +        "movq %%mm1, (%3)                       \n\t"
 +        : : "r" (src), "r" ((x86_reg)stride), "r"(tmp), "r"(tmp2)
 +        : "%"REG_a, "%"REG_d
 +    );
 +#else //HAVE_MMX2 || HAVE_AMD3DNOW
 +    int x;
 +    src+= stride*4;
 +    for(x=0; x<8; x++){
 +        int t1= tmp[x];
 +        int t2= tmp2[x];
 +        int t3= src[0];
 +
 +        src[stride*0]= CLIP((-(t1 + src[stride*2]) + 2*(t2 + src[stride*1]) + 6*t3 + 4)>>3);
 +        t1= src[stride*1];
 +        src[stride*1]= CLIP((-(t2 + src[stride*3]) + 2*(t3 + src[stride*2]) + 6*t1 + 4)>>3);
 +        t2= src[stride*2];
 +        src[stride*2]= CLIP((-(t3 + src[stride*4]) + 2*(t1 + src[stride*3]) + 6*t2 + 4)>>3);
 +        t3= src[stride*3];
 +        src[stride*3]= CLIP((-(t1 + src[stride*5]) + 2*(t2 + src[stride*4]) + 6*t3 + 4)>>3);
 +        t1= src[stride*4];
 +        src[stride*4]= CLIP((-(t2 + src[stride*6]) + 2*(t3 + src[stride*5]) + 6*t1 + 4)>>3);
 +        t2= src[stride*5];
 +        src[stride*5]= CLIP((-(t3 + src[stride*7]) + 2*(t1 + src[stride*6]) + 6*t2 + 4)>>3);
 +        t3= src[stride*6];
 +        src[stride*6]= CLIP((-(t1 + src[stride*8]) + 2*(t2 + src[stride*7]) + 6*t3 + 4)>>3);
 +        t1= src[stride*7];
 +        src[stride*7]= CLIP((-(t2 + src[stride*9]) + 2*(t3 + src[stride*8]) + 6*t1 + 4)>>3);
 +
 +        tmp[x]= t3;
 +        tmp2[x]= t1;
 +
 +        src++;
 +    }
 +#endif //HAVE_MMX2 || HAVE_AMD3DNOW
 +}
 +
 +/**
 + * Deinterlace the given block by filtering all lines with a (1 2 1) filter.
 + * will be called for every 8x8 block and can read & write from line 4-15
 + * lines 0-3 have been passed through the deblock / dering filters already, but can be read, too.
 + * lines 4-12 will be read into the deblocking filter and should be deinterlaced
 + * this filter will read lines 4-13 and write 4-11
 + */
 +static inline void RENAME(deInterlaceBlendLinear)(uint8_t src[], int stride, uint8_t *tmp)
 +{
 +#if HAVE_MMX2 || HAVE_AMD3DNOW
 +    src+= 4*stride;
 +    __asm__ volatile(
 +        "lea (%0, %1), %%"REG_a"                \n\t"
 +        "lea (%%"REG_a", %1, 4), %%"REG_d"      \n\t"
 +//      0       1       2       3       4       5       6       7       8       9
 +//      %0      eax     eax+%1  eax+2%1 %0+4%1  edx     edx+%1  edx+2%1 %0+8%1  edx+4%1
 +
 +        "movq (%2), %%mm0                       \n\t" // L0
 +        "movq (%%"REG_a"), %%mm1                \n\t" // L2
 +        PAVGB(%%mm1, %%mm0)                           // L0+L2
 +        "movq (%0), %%mm2                       \n\t" // L1
 +        PAVGB(%%mm2, %%mm0)
 +        "movq %%mm0, (%0)                       \n\t"
 +        "movq (%%"REG_a", %1), %%mm0            \n\t" // L3
 +        PAVGB(%%mm0, %%mm2)                           // L1+L3
 +        PAVGB(%%mm1, %%mm2)                           // 2L2 + L1 + L3
 +        "movq %%mm2, (%%"REG_a")                \n\t"
 +        "movq (%%"REG_a", %1, 2), %%mm2         \n\t" // L4
 +        PAVGB(%%mm2, %%mm1)                           // L2+L4
 +        PAVGB(%%mm0, %%mm1)                           // 2L3 + L2 + L4
 +        "movq %%mm1, (%%"REG_a", %1)            \n\t"
 +        "movq (%0, %1, 4), %%mm1                \n\t" // L5
 +        PAVGB(%%mm1, %%mm0)                           // L3+L5
 +        PAVGB(%%mm2, %%mm0)                           // 2L4 + L3 + L5
 +        "movq %%mm0, (%%"REG_a", %1, 2)         \n\t"
 +        "movq (%%"REG_d"), %%mm0                \n\t" // L6
 +        PAVGB(%%mm0, %%mm2)                           // L4+L6
 +        PAVGB(%%mm1, %%mm2)                           // 2L5 + L4 + L6
 +        "movq %%mm2, (%0, %1, 4)                \n\t"
 +        "movq (%%"REG_d", %1), %%mm2            \n\t" // L7
 +        PAVGB(%%mm2, %%mm1)                           // L5+L7
 +        PAVGB(%%mm0, %%mm1)                           // 2L6 + L5 + L7
 +        "movq %%mm1, (%%"REG_d")                \n\t"
 +        "movq (%%"REG_d", %1, 2), %%mm1         \n\t" // L8
 +        PAVGB(%%mm1, %%mm0)                           // L6+L8
 +        PAVGB(%%mm2, %%mm0)                           // 2L7 + L6 + L8
 +        "movq %%mm0, (%%"REG_d", %1)            \n\t"
 +        "movq (%0, %1, 8), %%mm0                \n\t" // L9
 +        PAVGB(%%mm0, %%mm2)                           // L7+L9
 +        PAVGB(%%mm1, %%mm2)                           // 2L8 + L7 + L9
 +        "movq %%mm2, (%%"REG_d", %1, 2)         \n\t"
 +        "movq %%mm1, (%2)                       \n\t"
 +
 +        : : "r" (src), "r" ((x86_reg)stride), "r" (tmp)
 +        : "%"REG_a, "%"REG_d
 +    );
 +#else //HAVE_MMX2 || HAVE_AMD3DNOW
 +    int a, b, c, x;
 +    src+= 4*stride;
 +
 +    for(x=0; x<2; x++){
 +        a= *(uint32_t*)&tmp[stride*0];
 +        b= *(uint32_t*)&src[stride*0];
 +        c= *(uint32_t*)&src[stride*1];
 +        a= (a&c) + (((a^c)&0xFEFEFEFEUL)>>1);
 +        *(uint32_t*)&src[stride*0]= (a|b) - (((a^b)&0xFEFEFEFEUL)>>1);
 +
 +        a= *(uint32_t*)&src[stride*2];
 +        b= (a&b) + (((a^b)&0xFEFEFEFEUL)>>1);
 +        *(uint32_t*)&src[stride*1]= (c|b) - (((c^b)&0xFEFEFEFEUL)>>1);
 +
 +        b= *(uint32_t*)&src[stride*3];
 +        c= (b&c) + (((b^c)&0xFEFEFEFEUL)>>1);
 +        *(uint32_t*)&src[stride*2]= (c|a) - (((c^a)&0xFEFEFEFEUL)>>1);
 +
 +        c= *(uint32_t*)&src[stride*4];
 +        a= (a&c) + (((a^c)&0xFEFEFEFEUL)>>1);
 +        *(uint32_t*)&src[stride*3]= (a|b) - (((a^b)&0xFEFEFEFEUL)>>1);
 +
 +        a= *(uint32_t*)&src[stride*5];
 +        b= (a&b) + (((a^b)&0xFEFEFEFEUL)>>1);
 +        *(uint32_t*)&src[stride*4]= (c|b) - (((c^b)&0xFEFEFEFEUL)>>1);
 +
 +        b= *(uint32_t*)&src[stride*6];
 +        c= (b&c) + (((b^c)&0xFEFEFEFEUL)>>1);
 +        *(uint32_t*)&src[stride*5]= (c|a) - (((c^a)&0xFEFEFEFEUL)>>1);
 +
 +        c= *(uint32_t*)&src[stride*7];
 +        a= (a&c) + (((a^c)&0xFEFEFEFEUL)>>1);
 +        *(uint32_t*)&src[stride*6]= (a|b) - (((a^b)&0xFEFEFEFEUL)>>1);
 +
 +        a= *(uint32_t*)&src[stride*8];
 +        b= (a&b) + (((a^b)&0xFEFEFEFEUL)>>1);
 +        *(uint32_t*)&src[stride*7]= (c|b) - (((c^b)&0xFEFEFEFEUL)>>1);
 +
 +        *(uint32_t*)&tmp[stride*0]= c;
 +        src += 4;
 +        tmp += 4;
 +    }
 +#endif //HAVE_MMX2 || HAVE_AMD3DNOW
 +}
 +
 +/**
 + * Deinterlace the given block by applying a median filter to every second line.
 + * will be called for every 8x8 block and can read & write from line 4-15,
 + * lines 0-3 have been passed through the deblock / dering filters already, but can be read, too.
 + * lines 4-12 will be read into the deblocking filter and should be deinterlaced
 + */
 +static inline void RENAME(deInterlaceMedian)(uint8_t src[], int stride)
 +{
 +#if HAVE_MMX
 +    src+= 4*stride;
 +#if HAVE_MMX2
 +    __asm__ volatile(
 +        "lea (%0, %1), %%"REG_a"                \n\t"
 +        "lea (%%"REG_a", %1, 4), %%"REG_d"      \n\t"
 +//      0       1       2       3       4       5       6       7       8       9
 +//      %0      eax     eax+%1  eax+2%1 %0+4%1  edx     edx+%1  edx+2%1 %0+8%1  edx+4%1
 +
 +        "movq (%0), %%mm0                       \n\t" //
 +        "movq (%%"REG_a", %1), %%mm2            \n\t" //
 +        "movq (%%"REG_a"), %%mm1                \n\t" //
 +        "movq %%mm0, %%mm3                      \n\t"
 +        "pmaxub %%mm1, %%mm0                    \n\t" //
 +        "pminub %%mm3, %%mm1                    \n\t" //
 +        "pmaxub %%mm2, %%mm1                    \n\t" //
 +        "pminub %%mm1, %%mm0                    \n\t"
 +        "movq %%mm0, (%%"REG_a")                \n\t"
 +
 +        "movq (%0, %1, 4), %%mm0                \n\t" //
 +        "movq (%%"REG_a", %1, 2), %%mm1         \n\t" //
 +        "movq %%mm2, %%mm3                      \n\t"
 +        "pmaxub %%mm1, %%mm2                    \n\t" //
 +        "pminub %%mm3, %%mm1                    \n\t" //
 +        "pmaxub %%mm0, %%mm1                    \n\t" //
 +        "pminub %%mm1, %%mm2                    \n\t"
 +        "movq %%mm2, (%%"REG_a", %1, 2)         \n\t"
 +
 +        "movq (%%"REG_d"), %%mm2                \n\t" //
 +        "movq (%%"REG_d", %1), %%mm1            \n\t" //
 +        "movq %%mm2, %%mm3                      \n\t"
 +        "pmaxub %%mm0, %%mm2                    \n\t" //
 +        "pminub %%mm3, %%mm0                    \n\t" //
 +        "pmaxub %%mm1, %%mm0                    \n\t" //
 +        "pminub %%mm0, %%mm2                    \n\t"
 +        "movq %%mm2, (%%"REG_d")                \n\t"
 +
 +        "movq (%%"REG_d", %1, 2), %%mm2         \n\t" //
 +        "movq (%0, %1, 8), %%mm0                \n\t" //
 +        "movq %%mm2, %%mm3                      \n\t"
 +        "pmaxub %%mm0, %%mm2                    \n\t" //
 +        "pminub %%mm3, %%mm0                    \n\t" //
 +        "pmaxub %%mm1, %%mm0                    \n\t" //
 +        "pminub %%mm0, %%mm2                    \n\t"
 +        "movq %%mm2, (%%"REG_d", %1, 2)         \n\t"
 +
 +
 +        : : "r" (src), "r" ((x86_reg)stride)
 +        : "%"REG_a, "%"REG_d
 +    );
 +
 +#else // MMX without MMX2
 +    __asm__ volatile(
 +        "lea (%0, %1), %%"REG_a"                \n\t"
 +        "lea (%%"REG_a", %1, 4), %%"REG_d"      \n\t"
 +//      0       1       2       3       4       5       6       7       8       9
 +//      %0      eax     eax+%1  eax+2%1 %0+4%1  edx     edx+%1  edx+2%1 %0+8%1  edx+4%1
 +        "pxor %%mm7, %%mm7                      \n\t"
 +
 +#define REAL_MEDIAN(a,b,c)\
 +        "movq " #a ", %%mm0                     \n\t"\
 +        "movq " #b ", %%mm2                     \n\t"\
 +        "movq " #c ", %%mm1                     \n\t"\
 +        "movq %%mm0, %%mm3                      \n\t"\
 +        "movq %%mm1, %%mm4                      \n\t"\
 +        "movq %%mm2, %%mm5                      \n\t"\
 +        "psubusb %%mm1, %%mm3                   \n\t"\
 +        "psubusb %%mm2, %%mm4                   \n\t"\
 +        "psubusb %%mm0, %%mm5                   \n\t"\
 +        "pcmpeqb %%mm7, %%mm3                   \n\t"\
 +        "pcmpeqb %%mm7, %%mm4                   \n\t"\
 +        "pcmpeqb %%mm7, %%mm5                   \n\t"\
 +        "movq %%mm3, %%mm6                      \n\t"\
 +        "pxor %%mm4, %%mm3                      \n\t"\
 +        "pxor %%mm5, %%mm4                      \n\t"\
 +        "pxor %%mm6, %%mm5                      \n\t"\
 +        "por %%mm3, %%mm1                       \n\t"\
 +        "por %%mm4, %%mm2                       \n\t"\
 +        "por %%mm5, %%mm0                       \n\t"\
 +        "pand %%mm2, %%mm0                      \n\t"\
 +        "pand %%mm1, %%mm0                      \n\t"\
 +        "movq %%mm0, " #b "                     \n\t"
 +#define MEDIAN(a,b,c)  REAL_MEDIAN(a,b,c)
 +
 +MEDIAN((%0)        , (%%REGa)       , (%%REGa, %1))
 +MEDIAN((%%REGa, %1), (%%REGa, %1, 2), (%0, %1, 4))
 +MEDIAN((%0, %1, 4) , (%%REGd)       , (%%REGd, %1))
 +MEDIAN((%%REGd, %1), (%%REGd, %1, 2), (%0, %1, 8))
 +
 +        : : "r" (src), "r" ((x86_reg)stride)
 +        : "%"REG_a, "%"REG_d
 +    );
 +#endif //HAVE_MMX2
 +#else //HAVE_MMX
 +    int x, y;
 +    src+= 4*stride;
 +    // FIXME - there should be a way to do a few columns in parallel like w/mmx
 +    for(x=0; x<8; x++){
 +        uint8_t *colsrc = src;
 +        for (y=0; y<4; y++){
 +            int a, b, c, d, e, f;
 +            a = colsrc[0       ];
 +            b = colsrc[stride  ];
 +            c = colsrc[stride*2];
 +            d = (a-b)>>31;
 +            e = (b-c)>>31;
 +            f = (c-a)>>31;
 +            colsrc[stride  ] = (a|(d^f)) & (b|(d^e)) & (c|(e^f));
 +            colsrc += stride*2;
 +        }
 +        src++;
 +    }
 +#endif //HAVE_MMX
 +}
 +
 +#if HAVE_MMX
 +/**
 + * Transpose and shift the given 8x8 Block into dst1 and dst2.
 + */
 +static inline void RENAME(transpose1)(uint8_t *dst1, uint8_t *dst2, uint8_t *src, int srcStride)
 +{
 +    __asm__(
 +        "lea (%0, %1), %%"REG_a"                \n\t"
 +//      0       1       2       3       4       5       6       7       8       9
 +//      %0      eax     eax+%1  eax+2%1 %0+4%1  edx     edx+%1  edx+2%1 %0+8%1  edx+4%1
 +        "movq (%0), %%mm0                       \n\t" // 12345678
 +        "movq (%%"REG_a"), %%mm1                \n\t" // abcdefgh
 +        "movq %%mm0, %%mm2                      \n\t" // 12345678
 +        "punpcklbw %%mm1, %%mm0                 \n\t" // 1a2b3c4d
 +        "punpckhbw %%mm1, %%mm2                 \n\t" // 5e6f7g8h
 +
 +        "movq (%%"REG_a", %1), %%mm1            \n\t"
 +        "movq (%%"REG_a", %1, 2), %%mm3         \n\t"
 +        "movq %%mm1, %%mm4                      \n\t"
 +        "punpcklbw %%mm3, %%mm1                 \n\t"
 +        "punpckhbw %%mm3, %%mm4                 \n\t"
 +
 +        "movq %%mm0, %%mm3                      \n\t"
 +        "punpcklwd %%mm1, %%mm0                 \n\t"
 +        "punpckhwd %%mm1, %%mm3                 \n\t"
 +        "movq %%mm2, %%mm1                      \n\t"
 +        "punpcklwd %%mm4, %%mm2                 \n\t"
 +        "punpckhwd %%mm4, %%mm1                 \n\t"
 +
 +        "movd %%mm0, 128(%2)                    \n\t"
 +        "psrlq $32, %%mm0                       \n\t"
 +        "movd %%mm0, 144(%2)                    \n\t"
 +        "movd %%mm3, 160(%2)                    \n\t"
 +        "psrlq $32, %%mm3                       \n\t"
 +        "movd %%mm3, 176(%2)                    \n\t"
 +        "movd %%mm3, 48(%3)                     \n\t"
 +        "movd %%mm2, 192(%2)                    \n\t"
 +        "movd %%mm2, 64(%3)                     \n\t"
 +        "psrlq $32, %%mm2                       \n\t"
 +        "movd %%mm2, 80(%3)                     \n\t"
 +        "movd %%mm1, 96(%3)                     \n\t"
 +        "psrlq $32, %%mm1                       \n\t"
 +        "movd %%mm1, 112(%3)                    \n\t"
 +
 +        "lea (%%"REG_a", %1, 4), %%"REG_a"      \n\t"
 +
 +        "movq (%0, %1, 4), %%mm0                \n\t" // 12345678
 +        "movq (%%"REG_a"), %%mm1                \n\t" // abcdefgh
 +        "movq %%mm0, %%mm2                      \n\t" // 12345678
 +        "punpcklbw %%mm1, %%mm0                 \n\t" // 1a2b3c4d
 +        "punpckhbw %%mm1, %%mm2                 \n\t" // 5e6f7g8h
 +
 +        "movq (%%"REG_a", %1), %%mm1            \n\t"
 +        "movq (%%"REG_a", %1, 2), %%mm3         \n\t"
 +        "movq %%mm1, %%mm4                      \n\t"
 +        "punpcklbw %%mm3, %%mm1                 \n\t"
 +        "punpckhbw %%mm3, %%mm4                 \n\t"
 +
 +        "movq %%mm0, %%mm3                      \n\t"
 +        "punpcklwd %%mm1, %%mm0                 \n\t"
 +        "punpckhwd %%mm1, %%mm3                 \n\t"
 +        "movq %%mm2, %%mm1                      \n\t"
 +        "punpcklwd %%mm4, %%mm2                 \n\t"
 +        "punpckhwd %%mm4, %%mm1                 \n\t"
 +
 +        "movd %%mm0, 132(%2)                    \n\t"
 +        "psrlq $32, %%mm0                       \n\t"
 +        "movd %%mm0, 148(%2)                    \n\t"
 +        "movd %%mm3, 164(%2)                    \n\t"
 +        "psrlq $32, %%mm3                       \n\t"
 +        "movd %%mm3, 180(%2)                    \n\t"
 +        "movd %%mm3, 52(%3)                     \n\t"
 +        "movd %%mm2, 196(%2)                    \n\t"
 +        "movd %%mm2, 68(%3)                     \n\t"
 +        "psrlq $32, %%mm2                       \n\t"
 +        "movd %%mm2, 84(%3)                     \n\t"
 +        "movd %%mm1, 100(%3)                    \n\t"
 +        "psrlq $32, %%mm1                       \n\t"
 +        "movd %%mm1, 116(%3)                    \n\t"
 +
 +
 +        :: "r" (src), "r" ((x86_reg)srcStride), "r" (dst1), "r" (dst2)
 +        : "%"REG_a
 +    );
 +}
 +
 +/**
 + * Transpose the given 8x8 block.
 + */
 +static inline void RENAME(transpose2)(uint8_t *dst, int dstStride, uint8_t *src)
 +{
 +    __asm__(
 +        "lea (%0, %1), %%"REG_a"                \n\t"
 +        "lea (%%"REG_a",%1,4), %%"REG_d"        \n\t"
 +//      0       1       2       3       4       5       6       7       8       9
 +//      %0      eax     eax+%1  eax+2%1 %0+4%1  edx     edx+%1  edx+2%1 %0+8%1  edx+4%1
 +        "movq (%2), %%mm0                       \n\t" // 12345678
 +        "movq 16(%2), %%mm1                     \n\t" // abcdefgh
 +        "movq %%mm0, %%mm2                      \n\t" // 12345678
 +        "punpcklbw %%mm1, %%mm0                 \n\t" // 1a2b3c4d
 +        "punpckhbw %%mm1, %%mm2                 \n\t" // 5e6f7g8h
 +
 +        "movq 32(%2), %%mm1                     \n\t"
 +        "movq 48(%2), %%mm3                     \n\t"
 +        "movq %%mm1, %%mm4                      \n\t"
 +        "punpcklbw %%mm3, %%mm1                 \n\t"
 +        "punpckhbw %%mm3, %%mm4                 \n\t"
 +
 +        "movq %%mm0, %%mm3                      \n\t"
 +        "punpcklwd %%mm1, %%mm0                 \n\t"
 +        "punpckhwd %%mm1, %%mm3                 \n\t"
 +        "movq %%mm2, %%mm1                      \n\t"
 +        "punpcklwd %%mm4, %%mm2                 \n\t"
 +        "punpckhwd %%mm4, %%mm1                 \n\t"
 +
 +        "movd %%mm0, (%0)                       \n\t"
 +        "psrlq $32, %%mm0                       \n\t"
 +        "movd %%mm0, (%%"REG_a")                \n\t"
 +        "movd %%mm3, (%%"REG_a", %1)            \n\t"
 +        "psrlq $32, %%mm3                       \n\t"
 +        "movd %%mm3, (%%"REG_a", %1, 2)         \n\t"
 +        "movd %%mm2, (%0, %1, 4)                \n\t"
 +        "psrlq $32, %%mm2                       \n\t"
 +        "movd %%mm2, (%%"REG_d")                \n\t"
 +        "movd %%mm1, (%%"REG_d", %1)            \n\t"
 +        "psrlq $32, %%mm1                       \n\t"
 +        "movd %%mm1, (%%"REG_d", %1, 2)         \n\t"
 +
 +
 +        "movq 64(%2), %%mm0                     \n\t" // 12345678
 +        "movq 80(%2), %%mm1                     \n\t" // abcdefgh
 +        "movq %%mm0, %%mm2                      \n\t" // 12345678
 +        "punpcklbw %%mm1, %%mm0                 \n\t" // 1a2b3c4d
 +        "punpckhbw %%mm1, %%mm2                 \n\t" // 5e6f7g8h
 +
 +        "movq 96(%2), %%mm1                     \n\t"
 +        "movq 112(%2), %%mm3                    \n\t"
 +        "movq %%mm1, %%mm4                      \n\t"
 +        "punpcklbw %%mm3, %%mm1                 \n\t"
 +        "punpckhbw %%mm3, %%mm4                 \n\t"
 +
 +        "movq %%mm0, %%mm3                      \n\t"
 +        "punpcklwd %%mm1, %%mm0                 \n\t"
 +        "punpckhwd %%mm1, %%mm3                 \n\t"
 +        "movq %%mm2, %%mm1                      \n\t"
 +        "punpcklwd %%mm4, %%mm2                 \n\t"
 +        "punpckhwd %%mm4, %%mm1                 \n\t"
 +
 +        "movd %%mm0, 4(%0)                      \n\t"
 +        "psrlq $32, %%mm0                       \n\t"
 +        "movd %%mm0, 4(%%"REG_a")               \n\t"
 +        "movd %%mm3, 4(%%"REG_a", %1)           \n\t"
 +        "psrlq $32, %%mm3                       \n\t"
 +        "movd %%mm3, 4(%%"REG_a", %1, 2)        \n\t"
 +        "movd %%mm2, 4(%0, %1, 4)               \n\t"
 +        "psrlq $32, %%mm2                       \n\t"
 +        "movd %%mm2, 4(%%"REG_d")               \n\t"
 +        "movd %%mm1, 4(%%"REG_d", %1)           \n\t"
 +        "psrlq $32, %%mm1                       \n\t"
 +        "movd %%mm1, 4(%%"REG_d", %1, 2)        \n\t"
 +
 +        :: "r" (dst), "r" ((x86_reg)dstStride), "r" (src)
 +        : "%"REG_a, "%"REG_d
 +    );
 +}
 +#endif //HAVE_MMX
 +//static long test=0;
 +
 +#if !HAVE_ALTIVEC
 +static inline void RENAME(tempNoiseReducer)(uint8_t *src, int stride,
 +                                    uint8_t *tempBlurred, uint32_t *tempBlurredPast, int *maxNoise)
 +{
 +    // to save a register (FIXME do this outside of the loops)
 +    tempBlurredPast[127]= maxNoise[0];
 +    tempBlurredPast[128]= maxNoise[1];
 +    tempBlurredPast[129]= maxNoise[2];
 +
 +#define FAST_L2_DIFF
 +//#define L1_DIFF //u should change the thresholds too if u try that one
 +#if HAVE_MMX2 || HAVE_AMD3DNOW
 +    __asm__ volatile(
 +        "lea (%2, %2, 2), %%"REG_a"             \n\t" // 3*stride
 +        "lea (%2, %2, 4), %%"REG_d"             \n\t" // 5*stride
 +        "lea (%%"REG_d", %2, 2), %%"REG_c"      \n\t" // 7*stride
 +//      0       1       2       3       4       5       6       7       8       9
 +//      %x      %x+%2   %x+2%2  %x+eax  %x+4%2  %x+edx  %x+2eax %x+ecx  %x+8%2
 +//FIXME reorder?
 +#ifdef L1_DIFF //needs mmx2
 +        "movq (%0), %%mm0                       \n\t" // L0
 +        "psadbw (%1), %%mm0                     \n\t" // |L0-R0|
 +        "movq (%0, %2), %%mm1                   \n\t" // L1
 +        "psadbw (%1, %2), %%mm1                 \n\t" // |L1-R1|
 +        "movq (%0, %2, 2), %%mm2                \n\t" // L2
 +        "psadbw (%1, %2, 2), %%mm2              \n\t" // |L2-R2|
 +        "movq (%0, %%"REG_a"), %%mm3            \n\t" // L3
 +        "psadbw (%1, %%"REG_a"), %%mm3          \n\t" // |L3-R3|
 +
 +        "movq (%0, %2, 4), %%mm4                \n\t" // L4
 +        "paddw %%mm1, %%mm0                     \n\t"
 +        "psadbw (%1, %2, 4), %%mm4              \n\t" // |L4-R4|
 +        "movq (%0, %%"REG_d"), %%mm5            \n\t" // L5
 +        "paddw %%mm2, %%mm0                     \n\t"
 +        "psadbw (%1, %%"REG_d"), %%mm5          \n\t" // |L5-R5|
 +        "movq (%0, %%"REG_a", 2), %%mm6         \n\t" // L6
 +        "paddw %%mm3, %%mm0                     \n\t"
 +        "psadbw (%1, %%"REG_a", 2), %%mm6       \n\t" // |L6-R6|
 +        "movq (%0, %%"REG_c"), %%mm7            \n\t" // L7
 +        "paddw %%mm4, %%mm0                     \n\t"
 +        "psadbw (%1, %%"REG_c"), %%mm7          \n\t" // |L7-R7|
 +        "paddw %%mm5, %%mm6                     \n\t"
 +        "paddw %%mm7, %%mm6                     \n\t"
 +        "paddw %%mm6, %%mm0                     \n\t"
 +#else //L1_DIFF
 +#if defined (FAST_L2_DIFF)
 +        "pcmpeqb %%mm7, %%mm7                   \n\t"
 +        "movq "MANGLE(b80)", %%mm6              \n\t"
 +        "pxor %%mm0, %%mm0                      \n\t"
 +#define REAL_L2_DIFF_CORE(a, b)\
 +        "movq " #a ", %%mm5                     \n\t"\
 +        "movq " #b ", %%mm2                     \n\t"\
 +        "pxor %%mm7, %%mm2                      \n\t"\
 +        PAVGB(%%mm2, %%mm5)\
 +        "paddb %%mm6, %%mm5                     \n\t"\
 +        "movq %%mm5, %%mm2                      \n\t"\
 +        "psllw $8, %%mm5                        \n\t"\
 +        "pmaddwd %%mm5, %%mm5                   \n\t"\
 +        "pmaddwd %%mm2, %%mm2                   \n\t"\
 +        "paddd %%mm2, %%mm5                     \n\t"\
 +        "psrld $14, %%mm5                       \n\t"\
 +        "paddd %%mm5, %%mm0                     \n\t"
 +
 +#else //defined (FAST_L2_DIFF)
 +        "pxor %%mm7, %%mm7                      \n\t"
 +        "pxor %%mm0, %%mm0                      \n\t"
 +#define REAL_L2_DIFF_CORE(a, b)\
 +        "movq " #a ", %%mm5                     \n\t"\
 +        "movq " #b ", %%mm2                     \n\t"\
 +        "movq %%mm5, %%mm1                      \n\t"\
 +        "movq %%mm2, %%mm3                      \n\t"\
 +        "punpcklbw %%mm7, %%mm5                 \n\t"\
 +        "punpckhbw %%mm7, %%mm1                 \n\t"\
 +        "punpcklbw %%mm7, %%mm2                 \n\t"\
 +        "punpckhbw %%mm7, %%mm3                 \n\t"\
 +        "psubw %%mm2, %%mm5                     \n\t"\
 +        "psubw %%mm3, %%mm1                     \n\t"\
 +        "pmaddwd %%mm5, %%mm5                   \n\t"\
 +        "pmaddwd %%mm1, %%mm1                   \n\t"\
 +        "paddd %%mm1, %%mm5                     \n\t"\
 +        "paddd %%mm5, %%mm0                     \n\t"
 +
 +#endif //defined (FAST_L2_DIFF)
 +
 +#define L2_DIFF_CORE(a, b)  REAL_L2_DIFF_CORE(a, b)
 +
 +L2_DIFF_CORE((%0)          , (%1))
 +L2_DIFF_CORE((%0, %2)      , (%1, %2))
 +L2_DIFF_CORE((%0, %2, 2)   , (%1, %2, 2))
 +L2_DIFF_CORE((%0, %%REGa)  , (%1, %%REGa))
 +L2_DIFF_CORE((%0, %2, 4)   , (%1, %2, 4))
 +L2_DIFF_CORE((%0, %%REGd)  , (%1, %%REGd))
 +L2_DIFF_CORE((%0, %%REGa,2), (%1, %%REGa,2))
 +L2_DIFF_CORE((%0, %%REGc)  , (%1, %%REGc))
 +
 +#endif //L1_DIFF
 +
 +        "movq %%mm0, %%mm4                      \n\t"
 +        "psrlq $32, %%mm0                       \n\t"
 +        "paddd %%mm0, %%mm4                     \n\t"
 +        "movd %%mm4, %%ecx                      \n\t"
 +        "shll $2, %%ecx                         \n\t"
 +        "mov %3, %%"REG_d"                      \n\t"
 +        "addl -4(%%"REG_d"), %%ecx              \n\t"
 +        "addl 4(%%"REG_d"), %%ecx               \n\t"
 +        "addl -1024(%%"REG_d"), %%ecx           \n\t"
 +        "addl $4, %%ecx                         \n\t"
 +        "addl 1024(%%"REG_d"), %%ecx            \n\t"
 +        "shrl $3, %%ecx                         \n\t"
 +        "movl %%ecx, (%%"REG_d")                \n\t"
 +
 +//        "mov %3, %%"REG_c"                      \n\t"
 +//        "mov %%"REG_c", test                    \n\t"
 +//        "jmp 4f                                 \n\t"
 +        "cmpl 512(%%"REG_d"), %%ecx             \n\t"
 +        " jb 2f                                 \n\t"
 +        "cmpl 516(%%"REG_d"), %%ecx             \n\t"
 +        " jb 1f                                 \n\t"
 +
 +        "lea (%%"REG_a", %2, 2), %%"REG_d"      \n\t" // 5*stride
 +        "lea (%%"REG_d", %2, 2), %%"REG_c"      \n\t" // 7*stride
 +        "movq (%0), %%mm0                       \n\t" // L0
 +        "movq (%0, %2), %%mm1                   \n\t" // L1
 +        "movq (%0, %2, 2), %%mm2                \n\t" // L2
 +        "movq (%0, %%"REG_a"), %%mm3            \n\t" // L3
 +        "movq (%0, %2, 4), %%mm4                \n\t" // L4
 +        "movq (%0, %%"REG_d"), %%mm5            \n\t" // L5
 +        "movq (%0, %%"REG_a", 2), %%mm6         \n\t" // L6
 +        "movq (%0, %%"REG_c"), %%mm7            \n\t" // L7
 +        "movq %%mm0, (%1)                       \n\t" // L0
 +        "movq %%mm1, (%1, %2)                   \n\t" // L1
 +        "movq %%mm2, (%1, %2, 2)                \n\t" // L2
 +        "movq %%mm3, (%1, %%"REG_a")            \n\t" // L3
 +        "movq %%mm4, (%1, %2, 4)                \n\t" // L4
 +        "movq %%mm5, (%1, %%"REG_d")            \n\t" // L5
 +        "movq %%mm6, (%1, %%"REG_a", 2)         \n\t" // L6
 +        "movq %%mm7, (%1, %%"REG_c")            \n\t" // L7
 +        "jmp 4f                                 \n\t"
 +
 +        "1:                                     \n\t"
 +        "lea (%%"REG_a", %2, 2), %%"REG_d"      \n\t" // 5*stride
 +        "lea (%%"REG_d", %2, 2), %%"REG_c"      \n\t" // 7*stride
 +        "movq (%0), %%mm0                       \n\t" // L0
 +        PAVGB((%1), %%mm0)                            // L0
 +        "movq (%0, %2), %%mm1                   \n\t" // L1
 +        PAVGB((%1, %2), %%mm1)                        // L1
 +        "movq (%0, %2, 2), %%mm2                \n\t" // L2
 +        PAVGB((%1, %2, 2), %%mm2)                     // L2
 +        "movq (%0, %%"REG_a"), %%mm3            \n\t" // L3
 +        PAVGB((%1, %%REGa), %%mm3)                    // L3
 +        "movq (%0, %2, 4), %%mm4                \n\t" // L4
 +        PAVGB((%1, %2, 4), %%mm4)                     // L4
 +        "movq (%0, %%"REG_d"), %%mm5            \n\t" // L5
 +        PAVGB((%1, %%REGd), %%mm5)                    // L5
 +        "movq (%0, %%"REG_a", 2), %%mm6         \n\t" // L6
 +        PAVGB((%1, %%REGa, 2), %%mm6)                 // L6
 +        "movq (%0, %%"REG_c"), %%mm7            \n\t" // L7
 +        PAVGB((%1, %%REGc), %%mm7)                    // L7
 +        "movq %%mm0, (%1)                       \n\t" // R0
 +        "movq %%mm1, (%1, %2)                   \n\t" // R1
 +        "movq %%mm2, (%1, %2, 2)                \n\t" // R2
 +        "movq %%mm3, (%1, %%"REG_a")            \n\t" // R3
 +        "movq %%mm4, (%1, %2, 4)                \n\t" // R4
 +        "movq %%mm5, (%1, %%"REG_d")            \n\t" // R5
 +        "movq %%mm6, (%1, %%"REG_a", 2)         \n\t" // R6
 +        "movq %%mm7, (%1, %%"REG_c")            \n\t" // R7
 +        "movq %%mm0, (%0)                       \n\t" // L0
 +        "movq %%mm1, (%0, %2)                   \n\t" // L1
 +        "movq %%mm2, (%0, %2, 2)                \n\t" // L2
 +        "movq %%mm3, (%0, %%"REG_a")            \n\t" // L3
 +        "movq %%mm4, (%0, %2, 4)                \n\t" // L4
 +        "movq %%mm5, (%0, %%"REG_d")            \n\t" // L5
 +        "movq %%mm6, (%0, %%"REG_a", 2)         \n\t" // L6
 +        "movq %%mm7, (%0, %%"REG_c")            \n\t" // L7
 +        "jmp 4f                                 \n\t"
 +
 +        "2:                                     \n\t"
 +        "cmpl 508(%%"REG_d"), %%ecx             \n\t"
 +        " jb 3f                                 \n\t"
 +
 +        "lea (%%"REG_a", %2, 2), %%"REG_d"      \n\t" // 5*stride
 +        "lea (%%"REG_d", %2, 2), %%"REG_c"      \n\t" // 7*stride
 +        "movq (%0), %%mm0                       \n\t" // L0
 +        "movq (%0, %2), %%mm1                   \n\t" // L1
 +        "movq (%0, %2, 2), %%mm2                \n\t" // L2
 +        "movq (%0, %%"REG_a"), %%mm3            \n\t" // L3
 +        "movq (%1), %%mm4                       \n\t" // R0
 +        "movq (%1, %2), %%mm5                   \n\t" // R1
 +        "movq (%1, %2, 2), %%mm6                \n\t" // R2
 +        "movq (%1, %%"REG_a"), %%mm7            \n\t" // R3
 +        PAVGB(%%mm4, %%mm0)
 +        PAVGB(%%mm5, %%mm1)
 +        PAVGB(%%mm6, %%mm2)
 +        PAVGB(%%mm7, %%mm3)
 +        PAVGB(%%mm4, %%mm0)
 +        PAVGB(%%mm5, %%mm1)
 +        PAVGB(%%mm6, %%mm2)
 +        PAVGB(%%mm7, %%mm3)
 +        "movq %%mm0, (%1)                       \n\t" // R0
 +        "movq %%mm1, (%1, %2)                   \n\t" // R1
 +        "movq %%mm2, (%1, %2, 2)                \n\t" // R2
 +        "movq %%mm3, (%1, %%"REG_a")            \n\t" // R3
 +        "movq %%mm0, (%0)                       \n\t" // L0
 +        "movq %%mm1, (%0, %2)                   \n\t" // L1
 +        "movq %%mm2, (%0, %2, 2)                \n\t" // L2
 +        "movq %%mm3, (%0, %%"REG_a")            \n\t" // L3
 +
 +        "movq (%0, %2, 4), %%mm0                \n\t" // L4
 +        "movq (%0, %%"REG_d"), %%mm1            \n\t" // L5
 +        "movq (%0, %%"REG_a", 2), %%mm2         \n\t" // L6
 +        "movq (%0, %%"REG_c"), %%mm3            \n\t" // L7
 +        "movq (%1, %2, 4), %%mm4                \n\t" // R4
 +        "movq (%1, %%"REG_d"), %%mm5            \n\t" // R5
 +        "movq (%1, %%"REG_a", 2), %%mm6         \n\t" // R6
 +        "movq (%1, %%"REG_c"), %%mm7            \n\t" // R7
 +        PAVGB(%%mm4, %%mm0)
 +        PAVGB(%%mm5, %%mm1)
 +        PAVGB(%%mm6, %%mm2)
 +        PAVGB(%%mm7, %%mm3)
 +        PAVGB(%%mm4, %%mm0)
 +        PAVGB(%%mm5, %%mm1)
 +        PAVGB(%%mm6, %%mm2)
 +        PAVGB(%%mm7, %%mm3)
 +        "movq %%mm0, (%1, %2, 4)                \n\t" // R4
 +        "movq %%mm1, (%1, %%"REG_d")            \n\t" // R5
 +        "movq %%mm2, (%1, %%"REG_a", 2)         \n\t" // R6
 +        "movq %%mm3, (%1, %%"REG_c")            \n\t" // R7
 +        "movq %%mm0, (%0, %2, 4)                \n\t" // L4
 +        "movq %%mm1, (%0, %%"REG_d")            \n\t" // L5
 +        "movq %%mm2, (%0, %%"REG_a", 2)         \n\t" // L6
 +        "movq %%mm3, (%0, %%"REG_c")            \n\t" // L7
 +        "jmp 4f                                 \n\t"
 +
 +        "3:                                     \n\t"
 +        "lea (%%"REG_a", %2, 2), %%"REG_d"      \n\t" // 5*stride
 +        "lea (%%"REG_d", %2, 2), %%"REG_c"      \n\t" // 7*stride
 +        "movq (%0), %%mm0                       \n\t" // L0
 +        "movq (%0, %2), %%mm1                   \n\t" // L1
 +        "movq (%0, %2, 2), %%mm2                \n\t" // L2
 +        "movq (%0, %%"REG_a"), %%mm3            \n\t" // L3
 +        "movq (%1), %%mm4                       \n\t" // R0
 +        "movq (%1, %2), %%mm5                   \n\t" // R1
 +        "movq (%1, %2, 2), %%mm6                \n\t" // R2
 +        "movq (%1, %%"REG_a"), %%mm7            \n\t" // R3
 +        PAVGB(%%mm4, %%mm0)
 +        PAVGB(%%mm5, %%mm1)
 +        PAVGB(%%mm6, %%mm2)
 +        PAVGB(%%mm7, %%mm3)
 +        PAVGB(%%mm4, %%mm0)
 +        PAVGB(%%mm5, %%mm1)
 +        PAVGB(%%mm6, %%mm2)
 +        PAVGB(%%mm7, %%mm3)
 +        PAVGB(%%mm4, %%mm0)
 +        PAVGB(%%mm5, %%mm1)
 +        PAVGB(%%mm6, %%mm2)
 +        PAVGB(%%mm7, %%mm3)
 +        "movq %%mm0, (%1)                       \n\t" // R0
 +        "movq %%mm1, (%1, %2)                   \n\t" // R1
 +        "movq %%mm2, (%1, %2, 2)                \n\t" // R2
 +        "movq %%mm3, (%1, %%"REG_a")            \n\t" // R3
 +        "movq %%mm0, (%0)                       \n\t" // L0
 +        "movq %%mm1, (%0, %2)                   \n\t" // L1
 +        "movq %%mm2, (%0, %2, 2)                \n\t" // L2
 +        "movq %%mm3, (%0, %%"REG_a")            \n\t" // L3
 +
 +        "movq (%0, %2, 4), %%mm0                \n\t" // L4
 +        "movq (%0, %%"REG_d"), %%mm1            \n\t" // L5
 +        "movq (%0, %%"REG_a", 2), %%mm2         \n\t" // L6
 +        "movq (%0, %%"REG_c"), %%mm3            \n\t" // L7
 +        "movq (%1, %2, 4), %%mm4                \n\t" // R4
 +        "movq (%1, %%"REG_d"), %%mm5            \n\t" // R5
 +        "movq (%1, %%"REG_a", 2), %%mm6         \n\t" // R6
 +        "movq (%1, %%"REG_c"), %%mm7            \n\t" // R7
 +        PAVGB(%%mm4, %%mm0)
 +        PAVGB(%%mm5, %%mm1)
 +        PAVGB(%%mm6, %%mm2)
 +        PAVGB(%%mm7, %%mm3)
 +        PAVGB(%%mm4, %%mm0)
 +        PAVGB(%%mm5, %%mm1)
 +        PAVGB(%%mm6, %%mm2)
 +        PAVGB(%%mm7, %%mm3)
 +        PAVGB(%%mm4, %%mm0)
 +        PAVGB(%%mm5, %%mm1)
 +        PAVGB(%%mm6, %%mm2)
 +        PAVGB(%%mm7, %%mm3)
 +        "movq %%mm0, (%1, %2, 4)                \n\t" // R4
 +        "movq %%mm1, (%1, %%"REG_d")            \n\t" // R5
 +        "movq %%mm2, (%1, %%"REG_a", 2)         \n\t" // R6
 +        "movq %%mm3, (%1, %%"REG_c")            \n\t" // R7
 +        "movq %%mm0, (%0, %2, 4)                \n\t" // L4
 +        "movq %%mm1, (%0, %%"REG_d")            \n\t" // L5
 +        "movq %%mm2, (%0, %%"REG_a", 2)         \n\t" // L6
 +        "movq %%mm3, (%0, %%"REG_c")            \n\t" // L7
 +
 +        "4:                                     \n\t"
 +
 +        :: "r" (src), "r" (tempBlurred), "r"((x86_reg)stride), "m" (tempBlurredPast)
 +        : "%"REG_a, "%"REG_d, "%"REG_c, "memory"
 +    );
 +#else //HAVE_MMX2 || HAVE_AMD3DNOW
 +{
 +    int y;
 +    int d=0;
 +//    int sysd=0;
 +    int i;
 +
 +    for(y=0; y<8; y++){
 +        int x;
 +        for(x=0; x<8; x++){
 +            int ref= tempBlurred[ x + y*stride ];
 +            int cur= src[ x + y*stride ];
 +            int d1=ref - cur;
 +//            if(x==0 || x==7) d1+= d1>>1;
 +//            if(y==0 || y==7) d1+= d1>>1;
 +//            d+= FFABS(d1);
 +            d+= d1*d1;
 +//            sysd+= d1;
 +        }
 +    }
 +    i=d;
 +    d=  (
 +        4*d
 +        +(*(tempBlurredPast-256))
 +        +(*(tempBlurredPast-1))+ (*(tempBlurredPast+1))
 +        +(*(tempBlurredPast+256))
 +        +4)>>3;
 +    *tempBlurredPast=i;
 +//    ((*tempBlurredPast)*3 + d + 2)>>2;
 +
 +/*
 +Switch between
 + 1  0  0  0  0  0  0  (0)
 +64 32 16  8  4  2  1  (1)
 +64 48 36 27 20 15 11 (33) (approx)
 +64 56 49 43 37 33 29 (200) (approx)
 +*/
 +    if(d > maxNoise[1]){
 +        if(d < maxNoise[2]){
 +            for(y=0; y<8; y++){
 +                int x;
 +                for(x=0; x<8; x++){
 +                    int ref= tempBlurred[ x + y*stride ];
 +                    int cur= src[ x + y*stride ];
 +                    tempBlurred[ x + y*stride ]=
 +                    src[ x + y*stride ]=
 +                        (ref + cur + 1)>>1;
 +                }
 +            }
 +        }else{
 +            for(y=0; y<8; y++){
 +                int x;
 +                for(x=0; x<8; x++){
 +                    tempBlurred[ x + y*stride ]= src[ x + y*stride ];
 +                }
 +            }
 +        }
 +    }else{
 +        if(d < maxNoise[0]){
 +            for(y=0; y<8; y++){
 +                int x;
 +                for(x=0; x<8; x++){
 +                    int ref= tempBlurred[ x + y*stride ];
 +                    int cur= src[ x + y*stride ];
 +                    tempBlurred[ x + y*stride ]=
 +                    src[ x + y*stride ]=
 +                        (ref*7 + cur + 4)>>3;
 +                }
 +            }
 +        }else{
 +            for(y=0; y<8; y++){
 +                int x;
 +                for(x=0; x<8; x++){
 +                    int ref= tempBlurred[ x + y*stride ];
 +                    int cur= src[ x + y*stride ];
 +                    tempBlurred[ x + y*stride ]=
 +                    src[ x + y*stride ]=
 +                        (ref*3 + cur + 2)>>2;
 +                }
 +            }
 +        }
 +    }
 +}
 +#endif //HAVE_MMX2 || HAVE_AMD3DNOW
 +}
 +#endif //HAVE_ALTIVEC
 +
 +#if HAVE_MMX
 +/**
 + * accurate deblock filter
 + */
 +static av_always_inline void RENAME(do_a_deblock)(uint8_t *src, int step, int stride, PPContext *c){
 +    int64_t dc_mask, eq_mask, both_masks;
 +    int64_t sums[10*8*2];
 +    src+= step*3; // src points to begin of the 8x8 Block
 +    //{ START_TIMER
 +    __asm__ volatile(
 +        "movq %0, %%mm7                         \n\t"
 +        "movq %1, %%mm6                         \n\t"
 +        : : "m" (c->mmxDcOffset[c->nonBQP]),  "m" (c->mmxDcThreshold[c->nonBQP])
 +        );
 +
 +    __asm__ volatile(
 +        "lea (%2, %3), %%"REG_a"                \n\t"
 +//      0       1       2       3       4       5       6       7       8       9
 +//      %1      eax     eax+%2  eax+2%2 %1+4%2  ecx     ecx+%2  ecx+2%2 %1+8%2  ecx+4%2
 +
 +        "movq (%2), %%mm0                       \n\t"
 +        "movq (%%"REG_a"), %%mm1                \n\t"
 +        "movq %%mm1, %%mm3                      \n\t"
 +        "movq %%mm1, %%mm4                      \n\t"
 +        "psubb %%mm1, %%mm0                     \n\t" // mm0 = differnece
 +        "paddb %%mm7, %%mm0                     \n\t"
 +        "pcmpgtb %%mm6, %%mm0                   \n\t"
 +
 +        "movq (%%"REG_a",%3), %%mm2             \n\t"
 +        PMAXUB(%%mm2, %%mm4)
 +        PMINUB(%%mm2, %%mm3, %%mm5)
 +        "psubb %%mm2, %%mm1                     \n\t"
 +        "paddb %%mm7, %%mm1                     \n\t"
 +        "pcmpgtb %%mm6, %%mm1                   \n\t"
 +        "paddb %%mm1, %%mm0                     \n\t"
 +
 +        "movq (%%"REG_a", %3, 2), %%mm1         \n\t"
 +        PMAXUB(%%mm1, %%mm4)
 +        PMINUB(%%mm1, %%mm3, %%mm5)
 +        "psubb %%mm1, %%mm2                     \n\t"
 +        "paddb %%mm7, %%mm2                     \n\t"
 +        "pcmpgtb %%mm6, %%mm2                   \n\t"
 +        "paddb %%mm2, %%mm0                     \n\t"
 +
 +        "lea (%%"REG_a", %3, 4), %%"REG_a"      \n\t"
 +
 +        "movq (%2, %3, 4), %%mm2                \n\t"
 +        PMAXUB(%%mm2, %%mm4)
 +        PMINUB(%%mm2, %%mm3, %%mm5)
 +        "psubb %%mm2, %%mm1                     \n\t"
 +        "paddb %%mm7, %%mm1                     \n\t"
 +        "pcmpgtb %%mm6, %%mm1                   \n\t"
 +        "paddb %%mm1, %%mm0                     \n\t"
 +
 +        "movq (%%"REG_a"), %%mm1                \n\t"
 +        PMAXUB(%%mm1, %%mm4)
 +        PMINUB(%%mm1, %%mm3, %%mm5)
 +        "psubb %%mm1, %%mm2                     \n\t"
 +        "paddb %%mm7, %%mm2                     \n\t"
 +        "pcmpgtb %%mm6, %%mm2                   \n\t"
 +        "paddb %%mm2, %%mm0                     \n\t"
 +
 +        "movq (%%"REG_a", %3), %%mm2            \n\t"
 +        PMAXUB(%%mm2, %%mm4)
 +        PMINUB(%%mm2, %%mm3, %%mm5)
 +        "psubb %%mm2, %%mm1                     \n\t"
 +        "paddb %%mm7, %%mm1                     \n\t"
 +        "pcmpgtb %%mm6, %%mm1                   \n\t"
 +        "paddb %%mm1, %%mm0                     \n\t"
 +
 +        "movq (%%"REG_a", %3, 2), %%mm1         \n\t"
 +        PMAXUB(%%mm1, %%mm4)
 +        PMINUB(%%mm1, %%mm3, %%mm5)
 +        "psubb %%mm1, %%mm2                     \n\t"
 +        "paddb %%mm7, %%mm2                     \n\t"
 +        "pcmpgtb %%mm6, %%mm2                   \n\t"
 +        "paddb %%mm2, %%mm0                     \n\t"
 +
 +        "movq (%2, %3, 8), %%mm2                \n\t"
 +        PMAXUB(%%mm2, %%mm4)
 +        PMINUB(%%mm2, %%mm3, %%mm5)
 +        "psubb %%mm2, %%mm1                     \n\t"
 +        "paddb %%mm7, %%mm1                     \n\t"
 +        "pcmpgtb %%mm6, %%mm1                   \n\t"
 +        "paddb %%mm1, %%mm0                     \n\t"
 +
 +        "movq (%%"REG_a", %3, 4), %%mm1         \n\t"
 +        "psubb %%mm1, %%mm2                     \n\t"
 +        "paddb %%mm7, %%mm2                     \n\t"
 +        "pcmpgtb %%mm6, %%mm2                   \n\t"
 +        "paddb %%mm2, %%mm0                     \n\t"
 +        "psubusb %%mm3, %%mm4                   \n\t"
 +
 +        "pxor %%mm6, %%mm6                      \n\t"
 +        "movq %4, %%mm7                         \n\t" // QP,..., QP
 +        "paddusb %%mm7, %%mm7                   \n\t" // 2QP ... 2QP
 +        "psubusb %%mm4, %%mm7                   \n\t" // Diff >=2QP -> 0
 +        "pcmpeqb %%mm6, %%mm7                   \n\t" // Diff < 2QP -> 0
 +        "pcmpeqb %%mm6, %%mm7                   \n\t" // Diff < 2QP -> 0
 +        "movq %%mm7, %1                         \n\t"
 +
 +        "movq %5, %%mm7                         \n\t"
 +        "punpcklbw %%mm7, %%mm7                 \n\t"
 +        "punpcklbw %%mm7, %%mm7                 \n\t"
 +        "punpcklbw %%mm7, %%mm7                 \n\t"
 +        "psubb %%mm0, %%mm6                     \n\t"
 +        "pcmpgtb %%mm7, %%mm6                   \n\t"
 +        "movq %%mm6, %0                         \n\t"
 +
 +        : "=m" (eq_mask), "=m" (dc_mask)
 +        : "r" (src), "r" ((x86_reg)step), "m" (c->pQPb), "m"(c->ppMode.flatnessThreshold)
 +        : "%"REG_a
 +    );
 +
 +    both_masks = dc_mask & eq_mask;
 +
 +    if(both_masks){
 +        x86_reg offset= -8*step;
 +        int64_t *temp_sums= sums;
 +
 +        __asm__ volatile(
 +            "movq %2, %%mm0                         \n\t"  // QP,..., QP
 +            "pxor %%mm4, %%mm4                      \n\t"
 +
 +            "movq (%0), %%mm6                       \n\t"
 +            "movq (%0, %1), %%mm5                   \n\t"
 +            "movq %%mm5, %%mm1                      \n\t"
 +            "movq %%mm6, %%mm2                      \n\t"
 +            "psubusb %%mm6, %%mm5                   \n\t"
 +            "psubusb %%mm1, %%mm2                   \n\t"
 +            "por %%mm5, %%mm2                       \n\t" // ABS Diff of lines
 +            "psubusb %%mm2, %%mm0                   \n\t" // diff >= QP -> 0
 +            "pcmpeqb %%mm4, %%mm0                   \n\t" // diff >= QP -> FF
 +
 +            "pxor %%mm6, %%mm1                      \n\t"
 +            "pand %%mm0, %%mm1                      \n\t"
 +            "pxor %%mm1, %%mm6                      \n\t"
 +            // 0:QP  6:First
 +
 +            "movq (%0, %1, 8), %%mm5                \n\t"
 +            "add %1, %0                             \n\t" // %0 points to line 1 not 0
 +            "movq (%0, %1, 8), %%mm7                \n\t"
 +            "movq %%mm5, %%mm1                      \n\t"
 +            "movq %%mm7, %%mm2                      \n\t"
 +            "psubusb %%mm7, %%mm5                   \n\t"
 +            "psubusb %%mm1, %%mm2                   \n\t"
 +            "por %%mm5, %%mm2                       \n\t" // ABS Diff of lines
 +            "movq %2, %%mm0                         \n\t"  // QP,..., QP
 +            "psubusb %%mm2, %%mm0                   \n\t" // diff >= QP -> 0
 +            "pcmpeqb %%mm4, %%mm0                   \n\t" // diff >= QP -> FF
 +
 +            "pxor %%mm7, %%mm1                      \n\t"
 +            "pand %%mm0, %%mm1                      \n\t"
 +            "pxor %%mm1, %%mm7                      \n\t"
 +
 +            "movq %%mm6, %%mm5                      \n\t"
 +            "punpckhbw %%mm4, %%mm6                 \n\t"
 +            "punpcklbw %%mm4, %%mm5                 \n\t"
 +            // 4:0 5/6:First 7:Last
 +
 +            "movq %%mm5, %%mm0                      \n\t"
 +            "movq %%mm6, %%mm1                      \n\t"
 +            "psllw $2, %%mm0                        \n\t"
 +            "psllw $2, %%mm1                        \n\t"
 +            "paddw "MANGLE(w04)", %%mm0             \n\t"
 +            "paddw "MANGLE(w04)", %%mm1             \n\t"
 +
 +#define NEXT\
 +            "movq (%0), %%mm2                       \n\t"\
 +            "movq (%0), %%mm3                       \n\t"\
 +            "add %1, %0                             \n\t"\
 +            "punpcklbw %%mm4, %%mm2                 \n\t"\
 +            "punpckhbw %%mm4, %%mm3                 \n\t"\
 +            "paddw %%mm2, %%mm0                     \n\t"\
 +            "paddw %%mm3, %%mm1                     \n\t"
 +
 +#define PREV\
 +            "movq (%0), %%mm2                       \n\t"\
 +            "movq (%0), %%mm3                       \n\t"\
 +            "add %1, %0                             \n\t"\
 +            "punpcklbw %%mm4, %%mm2                 \n\t"\
 +            "punpckhbw %%mm4, %%mm3                 \n\t"\
 +            "psubw %%mm2, %%mm0                     \n\t"\
 +            "psubw %%mm3, %%mm1                     \n\t"
 +
 +
 +            NEXT //0
 +            NEXT //1
 +            NEXT //2
 +            "movq %%mm0, (%3)                       \n\t"
 +            "movq %%mm1, 8(%3)                      \n\t"
 +
 +            NEXT //3
 +            "psubw %%mm5, %%mm0                     \n\t"
 +            "psubw %%mm6, %%mm1                     \n\t"
 +            "movq %%mm0, 16(%3)                     \n\t"
 +            "movq %%mm1, 24(%3)                     \n\t"
 +
 +            NEXT //4
 +            "psubw %%mm5, %%mm0                     \n\t"
 +            "psubw %%mm6, %%mm1                     \n\t"
 +            "movq %%mm0, 32(%3)                     \n\t"
 +            "movq %%mm1, 40(%3)                     \n\t"
 +
 +            NEXT //5
 +            "psubw %%mm5, %%mm0                     \n\t"
 +            "psubw %%mm6, %%mm1                     \n\t"
 +            "movq %%mm0, 48(%3)                     \n\t"
 +            "movq %%mm1, 56(%3)                     \n\t"
 +
 +            NEXT //6
 +            "psubw %%mm5, %%mm0                     \n\t"
 +            "psubw %%mm6, %%mm1                     \n\t"
 +            "movq %%mm0, 64(%3)                     \n\t"
 +            "movq %%mm1, 72(%3)                     \n\t"
 +
 +            "movq %%mm7, %%mm6                      \n\t"
 +            "punpckhbw %%mm4, %%mm7                 \n\t"
 +            "punpcklbw %%mm4, %%mm6                 \n\t"
 +
 +            NEXT //7
 +            "mov %4, %0                             \n\t"
 +            "add %1, %0                             \n\t"
 +            PREV //0
 +            "movq %%mm0, 80(%3)                     \n\t"
 +            "movq %%mm1, 88(%3)                     \n\t"
 +
 +            PREV //1
 +            "paddw %%mm6, %%mm0                     \n\t"
 +            "paddw %%mm7, %%mm1                     \n\t"
 +            "movq %%mm0, 96(%3)                     \n\t"
 +            "movq %%mm1, 104(%3)                    \n\t"
 +
 +            PREV //2
 +            "paddw %%mm6, %%mm0                     \n\t"
 +            "paddw %%mm7, %%mm1                     \n\t"
 +            "movq %%mm0, 112(%3)                    \n\t"
 +            "movq %%mm1, 120(%3)                    \n\t"
 +
 +            PREV //3
 +            "paddw %%mm6, %%mm0                     \n\t"
 +            "paddw %%mm7, %%mm1                     \n\t"
 +            "movq %%mm0, 128(%3)                    \n\t"
 +            "movq %%mm1, 136(%3)                    \n\t"
 +
 +            PREV //4
 +            "paddw %%mm6, %%mm0                     \n\t"
 +            "paddw %%mm7, %%mm1                     \n\t"
 +            "movq %%mm0, 144(%3)                    \n\t"
 +            "movq %%mm1, 152(%3)                    \n\t"
 +
 +            "mov %4, %0                             \n\t" //FIXME
 +
 +            : "+&r"(src)
 +            : "r" ((x86_reg)step), "m" (c->pQPb), "r"(sums), "g"(src)
 +        );
 +
 +        src+= step; // src points to begin of the 8x8 Block
 +
 +        __asm__ volatile(
 +            "movq %4, %%mm6                         \n\t"
 +            "pcmpeqb %%mm5, %%mm5                   \n\t"
 +            "pxor %%mm6, %%mm5                      \n\t"
 +            "pxor %%mm7, %%mm7                      \n\t"
 +
 +            "1:                                     \n\t"
 +            "movq (%1), %%mm0                       \n\t"
 +            "movq 8(%1), %%mm1                      \n\t"
 +            "paddw 32(%1), %%mm0                    \n\t"
 +            "paddw 40(%1), %%mm1                    \n\t"
 +            "movq (%0, %3), %%mm2                   \n\t"
 +            "movq %%mm2, %%mm3                      \n\t"
 +            "movq %%mm2, %%mm4                      \n\t"
 +            "punpcklbw %%mm7, %%mm2                 \n\t"
 +            "punpckhbw %%mm7, %%mm3                 \n\t"
 +            "paddw %%mm2, %%mm0                     \n\t"
 +            "paddw %%mm3, %%mm1                     \n\t"
 +            "paddw %%mm2, %%mm0                     \n\t"
 +            "paddw %%mm3, %%mm1                     \n\t"
 +            "psrlw $4, %%mm0                        \n\t"
 +            "psrlw $4, %%mm1                        \n\t"
 +            "packuswb %%mm1, %%mm0                  \n\t"
 +            "pand %%mm6, %%mm0                      \n\t"
 +            "pand %%mm5, %%mm4                      \n\t"
 +            "por %%mm4, %%mm0                       \n\t"
 +            "movq %%mm0, (%0, %3)                   \n\t"
 +            "add $16, %1                            \n\t"
 +            "add %2, %0                             \n\t"
 +            " js 1b                                 \n\t"
 +
 +            : "+r"(offset), "+r"(temp_sums)
 +            : "r" ((x86_reg)step), "r"(src - offset), "m"(both_masks)
 +        );
 +    }else
 +        src+= step; // src points to begin of the 8x8 Block
 +
 +    if(eq_mask != -1LL){
 +        uint8_t *temp_src= src;
 +        DECLARE_ALIGNED(8, uint64_t, tmp)[4]; // make space for 4 8-byte vars
 +        __asm__ volatile(
 +            "pxor %%mm7, %%mm7                      \n\t"
 +//      0       1       2       3       4       5       6       7       8       9
 +//      %0      eax     eax+%1  eax+2%1 %0+4%1  ecx     ecx+%1  ecx+2%1 %1+8%1  ecx+4%1
 +
 +            "movq (%0), %%mm0                       \n\t"
 +            "movq %%mm0, %%mm1                      \n\t"
 +            "punpcklbw %%mm7, %%mm0                 \n\t" // low part of line 0
 +            "punpckhbw %%mm7, %%mm1                 \n\t" // high part of line 0
 +
 +            "movq (%0, %1), %%mm2                   \n\t"
 +            "lea (%0, %1, 2), %%"REG_a"             \n\t"
 +            "movq %%mm2, %%mm3                      \n\t"
 +            "punpcklbw %%mm7, %%mm2                 \n\t" // low part of line 1
 +            "punpckhbw %%mm7, %%mm3                 \n\t" // high part of line 1
 +
 +            "movq (%%"REG_a"), %%mm4                \n\t"
 +            "movq %%mm4, %%mm5                      \n\t"
 +            "punpcklbw %%mm7, %%mm4                 \n\t" // low part of line 2
 +            "punpckhbw %%mm7, %%mm5                 \n\t" // high part of line 2
 +
 +            "paddw %%mm0, %%mm0                     \n\t" // 2L0
 +            "paddw %%mm1, %%mm1                     \n\t" // 2H0
 +            "psubw %%mm4, %%mm2                     \n\t" // L1 - L2
 +            "psubw %%mm5, %%mm3                     \n\t" // H1 - H2
 +            "psubw %%mm2, %%mm0                     \n\t" // 2L0 - L1 + L2
 +            "psubw %%mm3, %%mm1                     \n\t" // 2H0 - H1 + H2
 +
 +            "psllw $2, %%mm2                        \n\t" // 4L1 - 4L2
 +            "psllw $2, %%mm3                        \n\t" // 4H1 - 4H2
 +            "psubw %%mm2, %%mm0                     \n\t" // 2L0 - 5L1 + 5L2
 +            "psubw %%mm3, %%mm1                     \n\t" // 2H0 - 5H1 + 5H2
 +
 +            "movq (%%"REG_a", %1), %%mm2            \n\t"
 +            "movq %%mm2, %%mm3                      \n\t"
 +            "punpcklbw %%mm7, %%mm2                 \n\t" // L3
 +            "punpckhbw %%mm7, %%mm3                 \n\t" // H3
 +
 +            "psubw %%mm2, %%mm0                     \n\t" // 2L0 - 5L1 + 5L2 - L3
 +            "psubw %%mm3, %%mm1                     \n\t" // 2H0 - 5H1 + 5H2 - H3
 +            "psubw %%mm2, %%mm0                     \n\t" // 2L0 - 5L1 + 5L2 - 2L3
 +            "psubw %%mm3, %%mm1                     \n\t" // 2H0 - 5H1 + 5H2 - 2H3
 +            "movq %%mm0, (%4)                       \n\t" // 2L0 - 5L1 + 5L2 - 2L3
 +            "movq %%mm1, 8(%4)                      \n\t" // 2H0 - 5H1 + 5H2 - 2H3
 +
 +            "movq (%%"REG_a", %1, 2), %%mm0         \n\t"
 +            "movq %%mm0, %%mm1                      \n\t"
 +            "punpcklbw %%mm7, %%mm0                 \n\t" // L4
 +            "punpckhbw %%mm7, %%mm1                 \n\t" // H4
 +
 +            "psubw %%mm0, %%mm2                     \n\t" // L3 - L4
 +            "psubw %%mm1, %%mm3                     \n\t" // H3 - H4
 +            "movq %%mm2, 16(%4)                     \n\t" // L3 - L4
 +            "movq %%mm3, 24(%4)                     \n\t" // H3 - H4
 +            "paddw %%mm4, %%mm4                     \n\t" // 2L2
 +            "paddw %%mm5, %%mm5                     \n\t" // 2H2
 +            "psubw %%mm2, %%mm4                     \n\t" // 2L2 - L3 + L4
 +            "psubw %%mm3, %%mm5                     \n\t" // 2H2 - H3 + H4
 +
 +            "lea (%%"REG_a", %1), %0                \n\t"
 +            "psllw $2, %%mm2                        \n\t" // 4L3 - 4L4
 +            "psllw $2, %%mm3                        \n\t" // 4H3 - 4H4
 +            "psubw %%mm2, %%mm4                     \n\t" // 2L2 - 5L3 + 5L4
 +            "psubw %%mm3, %%mm5                     \n\t" // 2H2 - 5H3 + 5H4
 +//50 opcodes so far
 +            "movq (%0, %1, 2), %%mm2                \n\t"
 +            "movq %%mm2, %%mm3                      \n\t"
 +            "punpcklbw %%mm7, %%mm2                 \n\t" // L5
 +            "punpckhbw %%mm7, %%mm3                 \n\t" // H5
 +            "psubw %%mm2, %%mm4                     \n\t" // 2L2 - 5L3 + 5L4 - L5
 +            "psubw %%mm3, %%mm5                     \n\t" // 2H2 - 5H3 + 5H4 - H5
 +            "psubw %%mm2, %%mm4                     \n\t" // 2L2 - 5L3 + 5L4 - 2L5
 +            "psubw %%mm3, %%mm5                     \n\t" // 2H2 - 5H3 + 5H4 - 2H5
 +
 +            "movq (%%"REG_a", %1, 4), %%mm6         \n\t"
 +            "punpcklbw %%mm7, %%mm6                 \n\t" // L6
 +            "psubw %%mm6, %%mm2                     \n\t" // L5 - L6
 +            "movq (%%"REG_a", %1, 4), %%mm6         \n\t"
 +            "punpckhbw %%mm7, %%mm6                 \n\t" // H6
 +            "psubw %%mm6, %%mm3                     \n\t" // H5 - H6
 +
 +            "paddw %%mm0, %%mm0                     \n\t" // 2L4
 +            "paddw %%mm1, %%mm1                     \n\t" // 2H4
 +            "psubw %%mm2, %%mm0                     \n\t" // 2L4 - L5 + L6
 +            "psubw %%mm3, %%mm1                     \n\t" // 2H4 - H5 + H6
 +
 +            "psllw $2, %%mm2                        \n\t" // 4L5 - 4L6
 +            "psllw $2, %%mm3                        \n\t" // 4H5 - 4H6
 +            "psubw %%mm2, %%mm0                     \n\t" // 2L4 - 5L5 + 5L6
 +            "psubw %%mm3, %%mm1                     \n\t" // 2H4 - 5H5 + 5H6
 +
 +            "movq (%0, %1, 4), %%mm2                \n\t"
 +            "movq %%mm2, %%mm3                      \n\t"
 +            "punpcklbw %%mm7, %%mm2                 \n\t" // L7
 +            "punpckhbw %%mm7, %%mm3                 \n\t" // H7
 +
 +            "paddw %%mm2, %%mm2                     \n\t" // 2L7
 +            "paddw %%mm3, %%mm3                     \n\t" // 2H7
 +            "psubw %%mm2, %%mm0                     \n\t" // 2L4 - 5L5 + 5L6 - 2L7
 +            "psubw %%mm3, %%mm1                     \n\t" // 2H4 - 5H5 + 5H6 - 2H7
 +
 +            "movq (%4), %%mm2                       \n\t" // 2L0 - 5L1 + 5L2 - 2L3
 +            "movq 8(%4), %%mm3                      \n\t" // 2H0 - 5H1 + 5H2 - 2H3
 +
 +#if HAVE_MMX2
 +            "movq %%mm7, %%mm6                      \n\t" // 0
 +            "psubw %%mm0, %%mm6                     \n\t"
 +            "pmaxsw %%mm6, %%mm0                    \n\t" // |2L4 - 5L5 + 5L6 - 2L7|
 +            "movq %%mm7, %%mm6                      \n\t" // 0
 +            "psubw %%mm1, %%mm6                     \n\t"
 +            "pmaxsw %%mm6, %%mm1                    \n\t" // |2H4 - 5H5 + 5H6 - 2H7|
 +            "movq %%mm7, %%mm6                      \n\t" // 0
 +            "psubw %%mm2, %%mm6                     \n\t"
 +            "pmaxsw %%mm6, %%mm2                    \n\t" // |2L0 - 5L1 + 5L2 - 2L3|
 +            "movq %%mm7, %%mm6                      \n\t" // 0
 +            "psubw %%mm3, %%mm6                     \n\t"
 +            "pmaxsw %%mm6, %%mm3                    \n\t" // |2H0 - 5H1 + 5H2 - 2H3|
 +#else
 +            "movq %%mm7, %%mm6                      \n\t" // 0
 +            "pcmpgtw %%mm0, %%mm6                   \n\t"
 +            "pxor %%mm6, %%mm0                      \n\t"
 +            "psubw %%mm6, %%mm0                     \n\t" // |2L4 - 5L5 + 5L6 - 2L7|
 +            "movq %%mm7, %%mm6                      \n\t" // 0
 +            "pcmpgtw %%mm1, %%mm6                   \n\t"
 +            "pxor %%mm6, %%mm1                      \n\t"
 +            "psubw %%mm6, %%mm1                     \n\t" // |2H4 - 5H5 + 5H6 - 2H7|
 +            "movq %%mm7, %%mm6                      \n\t" // 0
 +            "pcmpgtw %%mm2, %%mm6                   \n\t"
 +            "pxor %%mm6, %%mm2                      \n\t"
 +            "psubw %%mm6, %%mm2                     \n\t" // |2L0 - 5L1 + 5L2 - 2L3|
 +            "movq %%mm7, %%mm6                      \n\t" // 0
 +            "pcmpgtw %%mm3, %%mm6                   \n\t"
 +            "pxor %%mm6, %%mm3                      \n\t"
 +            "psubw %%mm6, %%mm3                     \n\t" // |2H0 - 5H1 + 5H2 - 2H3|
 +#endif
 +
 +#if HAVE_MMX2
 +            "pminsw %%mm2, %%mm0                    \n\t"
 +            "pminsw %%mm3, %%mm1                    \n\t"
 +#else
 +            "movq %%mm0, %%mm6                      \n\t"
 +            "psubusw %%mm2, %%mm6                   \n\t"
 +            "psubw %%mm6, %%mm0                     \n\t"
 +            "movq %%mm1, %%mm6                      \n\t"
 +            "psubusw %%mm3, %%mm6                   \n\t"
 +            "psubw %%mm6, %%mm1                     \n\t"
 +#endif
 +
 +            "movd %2, %%mm2                         \n\t" // QP
 +            "punpcklbw %%mm7, %%mm2                 \n\t"
 +
 +            "movq %%mm7, %%mm6                      \n\t" // 0
 +            "pcmpgtw %%mm4, %%mm6                   \n\t" // sign(2L2 - 5L3 + 5L4 - 2L5)
 +            "pxor %%mm6, %%mm4                      \n\t"
 +            "psubw %%mm6, %%mm4                     \n\t" // |2L2 - 5L3 + 5L4 - 2L5|
 +            "pcmpgtw %%mm5, %%mm7                   \n\t" // sign(2H2 - 5H3 + 5H4 - 2H5)
 +            "pxor %%mm7, %%mm5                      \n\t"
 +            "psubw %%mm7, %%mm5                     \n\t" // |2H2 - 5H3 + 5H4 - 2H5|
 +// 100 opcodes
 +            "psllw $3, %%mm2                        \n\t" // 8QP
 +            "movq %%mm2, %%mm3                      \n\t" // 8QP
 +            "pcmpgtw %%mm4, %%mm2                   \n\t"
 +            "pcmpgtw %%mm5, %%mm3                   \n\t"
 +            "pand %%mm2, %%mm4                      \n\t"
 +            "pand %%mm3, %%mm5                      \n\t"
 +
 +
 +            "psubusw %%mm0, %%mm4                   \n\t" // hd
 +            "psubusw %%mm1, %%mm5                   \n\t" // ld
 +
 +
 +            "movq "MANGLE(w05)", %%mm2              \n\t" // 5
 +            "pmullw %%mm2, %%mm4                    \n\t"
 +            "pmullw %%mm2, %%mm5                    \n\t"
 +            "movq "MANGLE(w20)", %%mm2              \n\t" // 32
 +            "paddw %%mm2, %%mm4                     \n\t"
 +            "paddw %%mm2, %%mm5                     \n\t"
 +            "psrlw $6, %%mm4                        \n\t"
 +            "psrlw $6, %%mm5                        \n\t"
 +
 +            "movq 16(%4), %%mm0                     \n\t" // L3 - L4
 +            "movq 24(%4), %%mm1                     \n\t" // H3 - H4
 +
 +            "pxor %%mm2, %%mm2                      \n\t"
 +            "pxor %%mm3, %%mm3                      \n\t"
 +
 +            "pcmpgtw %%mm0, %%mm2                   \n\t" // sign (L3-L4)
 +            "pcmpgtw %%mm1, %%mm3                   \n\t" // sign (H3-H4)
 +            "pxor %%mm2, %%mm0                      \n\t"
 +            "pxor %%mm3, %%mm1                      \n\t"
 +            "psubw %%mm2, %%mm0                     \n\t" // |L3-L4|
 +            "psubw %%mm3, %%mm1                     \n\t" // |H3-H4|
 +            "psrlw $1, %%mm0                        \n\t" // |L3 - L4|/2
 +            "psrlw $1, %%mm1                        \n\t" // |H3 - H4|/2
 +
 +            "pxor %%mm6, %%mm2                      \n\t"
 +            "pxor %%mm7, %%mm3                      \n\t"
 +            "pand %%mm2, %%mm4                      \n\t"
 +            "pand %%mm3, %%mm5                      \n\t"
 +
 +#if HAVE_MMX2
 +            "pminsw %%mm0, %%mm4                    \n\t"
 +            "pminsw %%mm1, %%mm5                    \n\t"
 +#else
 +            "movq %%mm4, %%mm2                      \n\t"
 +            "psubusw %%mm0, %%mm2                   \n\t"
 +            "psubw %%mm2, %%mm4                     \n\t"
 +            "movq %%mm5, %%mm2                      \n\t"
 +            "psubusw %%mm1, %%mm2                   \n\t"
 +            "psubw %%mm2, %%mm5                     \n\t"
 +#endif
 +            "pxor %%mm6, %%mm4                      \n\t"
 +            "pxor %%mm7, %%mm5                      \n\t"
 +            "psubw %%mm6, %%mm4                     \n\t"
 +            "psubw %%mm7, %%mm5                     \n\t"
 +            "packsswb %%mm5, %%mm4                  \n\t"
 +            "movq %3, %%mm1                         \n\t"
 +            "pandn %%mm4, %%mm1                     \n\t"
 +            "movq (%0), %%mm0                       \n\t"
 +            "paddb   %%mm1, %%mm0                   \n\t"
 +            "movq %%mm0, (%0)                       \n\t"
 +            "movq (%0, %1), %%mm0                   \n\t"
 +            "psubb %%mm1, %%mm0                     \n\t"
 +            "movq %%mm0, (%0, %1)                   \n\t"
 +
 +            : "+r" (temp_src)
 +            : "r" ((x86_reg)step), "m" (c->pQPb), "m"(eq_mask), "r"(tmp)
 +            : "%"REG_a
 +        );
 +    }
 +/*if(step==16){
 +    STOP_TIMER("step16")
 +}else{
 +    STOP_TIMER("stepX")
 +}
 +    } */
 +}
 +#endif //HAVE_MMX
 +
 +static void RENAME(postProcess)(const uint8_t src[], int srcStride, uint8_t dst[], int dstStride, int width, int height,
 +                                const QP_STORE_T QPs[], int QPStride, int isColor, PPContext *c);
 +
 +/**
 + * Copy a block from src to dst and fixes the blacklevel.
 + * levelFix == 0 -> do not touch the brighness & contrast
 + */
 +#undef REAL_SCALED_CPY
 +#undef SCALED_CPY
 +
 +static inline void RENAME(blockCopy)(uint8_t dst[], int dstStride, const uint8_t src[], int srcStride,
 +                                     int levelFix, int64_t *packedOffsetAndScale)
 +{
 +#if !HAVE_MMX
 +    int i;
 +#endif
 +    if(levelFix){
 +#if HAVE_MMX
 +    __asm__ volatile(
 +        "movq (%%"REG_a"), %%mm2        \n\t" // packedYOffset
 +        "movq 8(%%"REG_a"), %%mm3       \n\t" // packedYScale
 +        "lea (%2,%4), %%"REG_a"         \n\t"
 +        "lea (%3,%5), %%"REG_d"         \n\t"
 +        "pxor %%mm4, %%mm4              \n\t"
 +#if HAVE_MMX2
 +#define REAL_SCALED_CPY(src1, src2, dst1, dst2)                                                \
 +        "movq " #src1 ", %%mm0          \n\t"\
 +        "movq " #src1 ", %%mm5          \n\t"\
 +        "movq " #src2 ", %%mm1          \n\t"\
 +        "movq " #src2 ", %%mm6          \n\t"\
 +        "punpcklbw %%mm0, %%mm0         \n\t"\
 +        "punpckhbw %%mm5, %%mm5         \n\t"\
 +        "punpcklbw %%mm1, %%mm1         \n\t"\
 +        "punpckhbw %%mm6, %%mm6         \n\t"\
 +        "pmulhuw %%mm3, %%mm0           \n\t"\
 +        "pmulhuw %%mm3, %%mm5           \n\t"\
 +        "pmulhuw %%mm3, %%mm1           \n\t"\
 +        "pmulhuw %%mm3, %%mm6           \n\t"\
 +        "psubw %%mm2, %%mm0             \n\t"\
 +        "psubw %%mm2, %%mm5             \n\t"\
 +        "psubw %%mm2, %%mm1             \n\t"\
 +        "psubw %%mm2, %%mm6             \n\t"\
 +        "packuswb %%mm5, %%mm0          \n\t"\
 +        "packuswb %%mm6, %%mm1          \n\t"\
 +        "movq %%mm0, " #dst1 "          \n\t"\
 +        "movq %%mm1, " #dst2 "          \n\t"\
 +
 +#else //HAVE_MMX2
 +#define REAL_SCALED_CPY(src1, src2, dst1, dst2)                                        \
 +        "movq " #src1 ", %%mm0          \n\t"\
 +        "movq " #src1 ", %%mm5          \n\t"\
 +        "punpcklbw %%mm4, %%mm0         \n\t"\
 +        "punpckhbw %%mm4, %%mm5         \n\t"\
 +        "psubw %%mm2, %%mm0             \n\t"\
 +        "psubw %%mm2, %%mm5             \n\t"\
 +        "movq " #src2 ", %%mm1          \n\t"\
 +        "psllw $6, %%mm0                \n\t"\
 +        "psllw $6, %%mm5                \n\t"\
 +        "pmulhw %%mm3, %%mm0            \n\t"\
 +        "movq " #src2 ", %%mm6          \n\t"\
 +        "pmulhw %%mm3, %%mm5            \n\t"\
 +        "punpcklbw %%mm4, %%mm1         \n\t"\
 +        "punpckhbw %%mm4, %%mm6         \n\t"\
 +        "psubw %%mm2, %%mm1             \n\t"\
 +        "psubw %%mm2, %%mm6             \n\t"\
 +        "psllw $6, %%mm1                \n\t"\
 +        "psllw $6, %%mm6                \n\t"\
 +        "pmulhw %%mm3, %%mm1            \n\t"\
 +        "pmulhw %%mm3, %%mm6            \n\t"\
 +        "packuswb %%mm5, %%mm0          \n\t"\
 +        "packuswb %%mm6, %%mm1          \n\t"\
 +        "movq %%mm0, " #dst1 "          \n\t"\
 +        "movq %%mm1, " #dst2 "          \n\t"\
 +
 +#endif //HAVE_MMX2
 +#define SCALED_CPY(src1, src2, dst1, dst2)\
 +   REAL_SCALED_CPY(src1, src2, dst1, dst2)
 +
 +SCALED_CPY((%2)       , (%2, %4)      , (%3)       , (%3, %5))
 +SCALED_CPY((%2, %4, 2), (%%REGa, %4, 2), (%3, %5, 2), (%%REGd, %5, 2))
 +SCALED_CPY((%2, %4, 4), (%%REGa, %4, 4), (%3, %5, 4), (%%REGd, %5, 4))
 +        "lea (%%"REG_a",%4,4), %%"REG_a"        \n\t"
 +        "lea (%%"REG_d",%5,4), %%"REG_d"        \n\t"
 +SCALED_CPY((%%REGa, %4), (%%REGa, %4, 2), (%%REGd, %5), (%%REGd, %5, 2))
 +
 +
 +        : "=&a" (packedOffsetAndScale)
 +        : "0" (packedOffsetAndScale),
 +        "r"(src),
 +        "r"(dst),
 +        "r" ((x86_reg)srcStride),
 +        "r" ((x86_reg)dstStride)
 +        : "%"REG_d
 +    );
 +#else //HAVE_MMX
 +    for(i=0; i<8; i++)
 +        memcpy( &(dst[dstStride*i]),
 +                &(src[srcStride*i]), BLOCK_SIZE);
 +#endif //HAVE_MMX
 +    }else{
 +#if HAVE_MMX
 +    __asm__ volatile(
 +        "lea (%0,%2), %%"REG_a"                 \n\t"
 +        "lea (%1,%3), %%"REG_d"                 \n\t"
 +
 +#define REAL_SIMPLE_CPY(src1, src2, dst1, dst2)                              \
 +        "movq " #src1 ", %%mm0          \n\t"\
 +        "movq " #src2 ", %%mm1          \n\t"\
 +        "movq %%mm0, " #dst1 "          \n\t"\
 +        "movq %%mm1, " #dst2 "          \n\t"\
 +
 +#define SIMPLE_CPY(src1, src2, dst1, dst2)\
 +   REAL_SIMPLE_CPY(src1, src2, dst1, dst2)
 +
 +SIMPLE_CPY((%0)       , (%0, %2)       , (%1)       , (%1, %3))
 +SIMPLE_CPY((%0, %2, 2), (%%REGa, %2, 2), (%1, %3, 2), (%%REGd, %3, 2))
 +SIMPLE_CPY((%0, %2, 4), (%%REGa, %2, 4), (%1, %3, 4), (%%REGd, %3, 4))
 +        "lea (%%"REG_a",%2,4), %%"REG_a"        \n\t"
 +        "lea (%%"REG_d",%3,4), %%"REG_d"        \n\t"
 +SIMPLE_CPY((%%REGa, %2), (%%REGa, %2, 2), (%%REGd, %3), (%%REGd, %3, 2))
 +
 +        : : "r" (src),
 +        "r" (dst),
 +        "r" ((x86_reg)srcStride),
 +        "r" ((x86_reg)dstStride)
 +        : "%"REG_a, "%"REG_d
 +    );
 +#else //HAVE_MMX
 +    for(i=0; i<8; i++)
 +        memcpy( &(dst[dstStride*i]),
 +                &(src[srcStride*i]), BLOCK_SIZE);
 +#endif //HAVE_MMX
 +    }
 +}
 +
 +/**
 + * Duplicate the given 8 src pixels ? times upward
 + */
 +static inline void RENAME(duplicate)(uint8_t src[], int stride)
 +{
 +#if HAVE_MMX
 +    __asm__ volatile(
 +        "movq (%0), %%mm0               \n\t"
 +        "add %1, %0                     \n\t"
 +        "movq %%mm0, (%0)               \n\t"
 +        "movq %%mm0, (%0, %1)           \n\t"
 +        "movq %%mm0, (%0, %1, 2)        \n\t"
 +        : "+r" (src)
 +        : "r" ((x86_reg)-stride)
 +    );
 +#else
 +    int i;
 +    uint8_t *p=src;
 +    for(i=0; i<3; i++){
 +        p-= stride;
 +        memcpy(p, src, 8);
 +    }
 +#endif
 +}
 +
 +/**
 + * Filter array of bytes (Y or U or V values)
 + */
 +static void RENAME(postProcess)(const uint8_t src[], int srcStride, uint8_t dst[], int dstStride, int width, int height,
 +                                const QP_STORE_T QPs[], int QPStride, int isColor, PPContext *c2)
 +{
 +    DECLARE_ALIGNED(8, PPContext, c)= *c2; //copy to stack for faster access
 +    int x,y;
 +#ifdef COMPILE_TIME_MODE
 +    const int mode= COMPILE_TIME_MODE;
 +#else
 +    const int mode= isColor ? c.ppMode.chromMode : c.ppMode.lumMode;
 +#endif
 +    int black=0, white=255; // blackest black and whitest white in the picture
 +    int QPCorrecture= 256*256;
 +
 +    int copyAhead;
 +#if HAVE_MMX
 +    int i;
 +#endif
 +
 +    const int qpHShift= isColor ? 4-c.hChromaSubSample : 4;
 +    const int qpVShift= isColor ? 4-c.vChromaSubSample : 4;
 +
 +    //FIXME remove
 +    uint64_t * const yHistogram= c.yHistogram;
 +    uint8_t * const tempSrc= srcStride > 0 ? c.tempSrc : c.tempSrc - 23*srcStride;
 +    uint8_t * const tempDst= dstStride > 0 ? c.tempDst : c.tempDst - 23*dstStride;
 +    //const int mbWidth= isColor ? (width+7)>>3 : (width+15)>>4;
 +
 +#if HAVE_MMX
 +    for(i=0; i<57; i++){
 +        int offset= ((i*c.ppMode.baseDcDiff)>>8) + 1;
 +        int threshold= offset*2 + 1;
 +        c.mmxDcOffset[i]= 0x7F - offset;
 +        c.mmxDcThreshold[i]= 0x7F - threshold;
 +        c.mmxDcOffset[i]*= 0x0101010101010101LL;
 +        c.mmxDcThreshold[i]*= 0x0101010101010101LL;
 +    }
 +#endif
 +
 +    if(mode & CUBIC_IPOL_DEINT_FILTER) copyAhead=16;
 +    else if(   (mode & LINEAR_BLEND_DEINT_FILTER)
 +            || (mode & FFMPEG_DEINT_FILTER)
 +            || (mode & LOWPASS5_DEINT_FILTER)) copyAhead=14;
 +    else if(   (mode & V_DEBLOCK)
 +            || (mode & LINEAR_IPOL_DEINT_FILTER)
 +            || (mode & MEDIAN_DEINT_FILTER)
 +            || (mode & V_A_DEBLOCK)) copyAhead=13;
 +    else if(mode & V_X1_FILTER) copyAhead=11;
 +//    else if(mode & V_RK1_FILTER) copyAhead=10;
 +    else if(mode & DERING) copyAhead=9;
 +    else copyAhead=8;
 +
 +    copyAhead-= 8;
 +
 +    if(!isColor){
 +        uint64_t sum= 0;
 +        int i;
 +        uint64_t maxClipped;
 +        uint64_t clipped;
 +        double scale;
 +
 +        c.frameNum++;
 +        // first frame is fscked so we ignore it
 +        if(c.frameNum == 1) yHistogram[0]= width*height/64*15/256;
 +
 +        for(i=0; i<256; i++){
 +            sum+= yHistogram[i];
 +        }
 +
 +        /* We always get a completely black picture first. */
 +        maxClipped= (uint64_t)(sum * c.ppMode.maxClippedThreshold);
 +
 +        clipped= sum;
 +        for(black=255; black>0; black--){
 +            if(clipped < maxClipped) break;
 +            clipped-= yHistogram[black];
 +        }
 +
 +        clipped= sum;
 +        for(white=0; white<256; white++){
 +            if(clipped < maxClipped) break;
 +            clipped-= yHistogram[white];
 +        }
 +
 +        scale= (double)(c.ppMode.maxAllowedY - c.ppMode.minAllowedY) / (double)(white-black);
 +
 +#if HAVE_MMX2
 +        c.packedYScale= (uint16_t)(scale*256.0 + 0.5);
 +        c.packedYOffset= (((black*c.packedYScale)>>8) - c.ppMode.minAllowedY) & 0xFFFF;
 +#else
 +        c.packedYScale= (uint16_t)(scale*1024.0 + 0.5);
 +        c.packedYOffset= (black - c.ppMode.minAllowedY) & 0xFFFF;
 +#endif
 +
 +        c.packedYOffset|= c.packedYOffset<<32;
 +        c.packedYOffset|= c.packedYOffset<<16;
 +
 +        c.packedYScale|= c.packedYScale<<32;
 +        c.packedYScale|= c.packedYScale<<16;
 +
 +        if(mode & LEVEL_FIX)        QPCorrecture= (int)(scale*256*256 + 0.5);
 +        else                        QPCorrecture= 256*256;
 +    }else{
 +        c.packedYScale= 0x0100010001000100LL;
 +        c.packedYOffset= 0;
 +        QPCorrecture= 256*256;
 +    }
 +
 +    /* copy & deinterlace first row of blocks */
 +    y=-BLOCK_SIZE;
 +    {
 +        const uint8_t *srcBlock= &(src[y*srcStride]);
 +        uint8_t *dstBlock= tempDst + dstStride;
 +
 +        // From this point on it is guaranteed that we can read and write 16 lines downward
 +        // finish 1 block before the next otherwise we might have a problem
 +        // with the L1 Cache of the P4 ... or only a few blocks at a time or soemthing
 +        for(x=0; x<width; x+=BLOCK_SIZE){
 +
 +#if HAVE_MMX2
 +/*
 +            prefetchnta(srcBlock + (((x>>2)&6) + 5)*srcStride + 32);
 +            prefetchnta(srcBlock + (((x>>2)&6) + 6)*srcStride + 32);
 +            prefetcht0(dstBlock + (((x>>2)&6) + 5)*dstStride + 32);
 +            prefetcht0(dstBlock + (((x>>2)&6) + 6)*dstStride + 32);
 +*/
 +
 +            __asm__(
 +                "mov %4, %%"REG_a"              \n\t"
 +                "shr $2, %%"REG_a"              \n\t"
 +                "and $6, %%"REG_a"              \n\t"
 +                "add %5, %%"REG_a"              \n\t"
 +                "mov %%"REG_a", %%"REG_d"       \n\t"
 +                "imul %1, %%"REG_a"             \n\t"
 +                "imul %3, %%"REG_d"             \n\t"
 +                "prefetchnta 32(%%"REG_a", %0)  \n\t"
 +                "prefetcht0 32(%%"REG_d", %2)   \n\t"
 +                "add %1, %%"REG_a"              \n\t"
 +                "add %3, %%"REG_d"              \n\t"
 +                "prefetchnta 32(%%"REG_a", %0)  \n\t"
 +                "prefetcht0 32(%%"REG_d", %2)   \n\t"
 +                :: "r" (srcBlock), "r" ((x86_reg)srcStride), "r" (dstBlock), "r" ((x86_reg)dstStride),
 +                "g" ((x86_reg)x), "g" ((x86_reg)copyAhead)
 +                : "%"REG_a, "%"REG_d
 +            );
 +
 +#elif HAVE_AMD3DNOW
 +//FIXME check if this is faster on an 3dnow chip or if it is faster without the prefetch or ...
 +/*          prefetch(srcBlock + (((x>>3)&3) + 5)*srcStride + 32);
 +            prefetch(srcBlock + (((x>>3)&3) + 9)*srcStride + 32);
 +            prefetchw(dstBlock + (((x>>3)&3) + 5)*dstStride + 32);
 +            prefetchw(dstBlock + (((x>>3)&3) + 9)*dstStride + 32);
 +*/
 +#endif
 +
 +            RENAME(blockCopy)(dstBlock + dstStride*8, dstStride,
 +                              srcBlock + srcStride*8, srcStride, mode & LEVEL_FIX, &c.packedYOffset);
 +
 +            RENAME(duplicate)(dstBlock + dstStride*8, dstStride);
 +
 +            if(mode & LINEAR_IPOL_DEINT_FILTER)
 +                RENAME(deInterlaceInterpolateLinear)(dstBlock, dstStride);
 +            else if(mode & LINEAR_BLEND_DEINT_FILTER)
 +                RENAME(deInterlaceBlendLinear)(dstBlock, dstStride, c.deintTemp + x);
 +            else if(mode & MEDIAN_DEINT_FILTER)
 +                RENAME(deInterlaceMedian)(dstBlock, dstStride);
 +            else if(mode & CUBIC_IPOL_DEINT_FILTER)
 +                RENAME(deInterlaceInterpolateCubic)(dstBlock, dstStride);
 +            else if(mode & FFMPEG_DEINT_FILTER)
 +                RENAME(deInterlaceFF)(dstBlock, dstStride, c.deintTemp + x);
 +            else if(mode & LOWPASS5_DEINT_FILTER)
 +                RENAME(deInterlaceL5)(dstBlock, dstStride, c.deintTemp + x, c.deintTemp + width + x);
 +/*          else if(mode & CUBIC_BLEND_DEINT_FILTER)
 +                RENAME(deInterlaceBlendCubic)(dstBlock, dstStride);
 +*/
 +            dstBlock+=8;
 +            srcBlock+=8;
 +        }
 +        if(width==FFABS(dstStride))
 +            linecpy(dst, tempDst + 9*dstStride, copyAhead, dstStride);
 +        else{
 +            int i;
 +            for(i=0; i<copyAhead; i++){
 +                memcpy(dst + i*dstStride, tempDst + (9+i)*dstStride, width);
 +            }
 +        }
 +    }
 +
 +    for(y=0; y<height; y+=BLOCK_SIZE){
 +        //1% speedup if these are here instead of the inner loop
 +        const uint8_t *srcBlock= &(src[y*srcStride]);
 +        uint8_t *dstBlock= &(dst[y*dstStride]);
 +#if HAVE_MMX
 +        uint8_t *tempBlock1= c.tempBlocks;
 +        uint8_t *tempBlock2= c.tempBlocks + 8;
 +#endif
 +        const int8_t *QPptr= &QPs[(y>>qpVShift)*QPStride];
 +        int8_t *nonBQPptr= &c.nonBQPTable[(y>>qpVShift)*FFABS(QPStride)];
 +        int QP=0;
 +        /* can we mess with a 8x16 block from srcBlock/dstBlock downwards and 1 line upwards
 +           if not than use a temporary buffer */
 +        if(y+15 >= height){
 +            int i;
 +            /* copy from line (copyAhead) to (copyAhead+7) of src, these will be copied with
 +               blockcopy to dst later */
 +            linecpy(tempSrc + srcStride*copyAhead, srcBlock + srcStride*copyAhead,
 +                    FFMAX(height-y-copyAhead, 0), srcStride);
 +
 +            /* duplicate last line of src to fill the void up to line (copyAhead+7) */
 +            for(i=FFMAX(height-y, 8); i<copyAhead+8; i++)
 +                    memcpy(tempSrc + srcStride*i, src + srcStride*(height-1), FFABS(srcStride));
 +
 +            /* copy up to (copyAhead+1) lines of dst (line -1 to (copyAhead-1))*/
 +            linecpy(tempDst, dstBlock - dstStride, FFMIN(height-y+1, copyAhead+1), dstStride);
 +
 +            /* duplicate last line of dst to fill the void up to line (copyAhead) */
 +            for(i=height-y+1; i<=copyAhead; i++)
 +                    memcpy(tempDst + dstStride*i, dst + dstStride*(height-1), FFABS(dstStride));
 +
 +            dstBlock= tempDst + dstStride;
 +            srcBlock= tempSrc;
 +        }
 +
 +        // From this point on it is guaranteed that we can read and write 16 lines downward
 +        // finish 1 block before the next otherwise we might have a problem
 +        // with the L1 Cache of the P4 ... or only a few blocks at a time or soemthing
 +        for(x=0; x<width; x+=BLOCK_SIZE){
 +            const int stride= dstStride;
 +#if HAVE_MMX
 +            uint8_t *tmpXchg;
 +#endif
 +            if(isColor){
 +                QP= QPptr[x>>qpHShift];
 +                c.nonBQP= nonBQPptr[x>>qpHShift];
 +            }else{
 +                QP= QPptr[x>>4];
 +                QP= (QP* QPCorrecture + 256*128)>>16;
 +                c.nonBQP= nonBQPptr[x>>4];
 +                c.nonBQP= (c.nonBQP* QPCorrecture + 256*128)>>16;
 +                yHistogram[ srcBlock[srcStride*12 + 4] ]++;
 +            }
 +            c.QP= QP;
 +#if HAVE_MMX
 +            __asm__ volatile(
 +                "movd %1, %%mm7         \n\t"
 +                "packuswb %%mm7, %%mm7  \n\t" // 0, 0, 0, QP, 0, 0, 0, QP
 +                "packuswb %%mm7, %%mm7  \n\t" // 0,QP, 0, QP, 0,QP, 0, QP
 +                "packuswb %%mm7, %%mm7  \n\t" // QP,..., QP
 +                "movq %%mm7, %0         \n\t"
 +                : "=m" (c.pQPb)
 +                : "r" (QP)
 +            );
 +#endif
 +
 +
 +#if HAVE_MMX2
 +/*
 +            prefetchnta(srcBlock + (((x>>2)&6) + 5)*srcStride + 32);
 +            prefetchnta(srcBlock + (((x>>2)&6) + 6)*srcStride + 32);
 +            prefetcht0(dstBlock + (((x>>2)&6) + 5)*dstStride + 32);
 +            prefetcht0(dstBlock + (((x>>2)&6) + 6)*dstStride + 32);
 +*/
 +
 +            __asm__(
 +                "mov %4, %%"REG_a"              \n\t"
 +                "shr $2, %%"REG_a"              \n\t"
 +                "and $6, %%"REG_a"              \n\t"
 +                "add %5, %%"REG_a"              \n\t"
 +                "mov %%"REG_a", %%"REG_d"       \n\t"
 +                "imul %1, %%"REG_a"             \n\t"
 +                "imul %3, %%"REG_d"             \n\t"
 +                "prefetchnta 32(%%"REG_a", %0)  \n\t"
 +                "prefetcht0 32(%%"REG_d", %2)   \n\t"
 +                "add %1, %%"REG_a"              \n\t"
 +                "add %3, %%"REG_d"              \n\t"
 +                "prefetchnta 32(%%"REG_a", %0)  \n\t"
 +                "prefetcht0 32(%%"REG_d", %2)   \n\t"
 +                :: "r" (srcBlock), "r" ((x86_reg)srcStride), "r" (dstBlock), "r" ((x86_reg)dstStride),
 +                "g" ((x86_reg)x), "g" ((x86_reg)copyAhead)
 +                : "%"REG_a, "%"REG_d
 +            );
 +
 +#elif HAVE_AMD3DNOW
 +//FIXME check if this is faster on an 3dnow chip or if it is faster without the prefetch or ...
 +/*          prefetch(srcBlock + (((x>>3)&3) + 5)*srcStride + 32);
 +            prefetch(srcBlock + (((x>>3)&3) + 9)*srcStride + 32);
 +            prefetchw(dstBlock + (((x>>3)&3) + 5)*dstStride + 32);
 +            prefetchw(dstBlock + (((x>>3)&3) + 9)*dstStride + 32);
 +*/
 +#endif
 +
 +            RENAME(blockCopy)(dstBlock + dstStride*copyAhead, dstStride,
 +                              srcBlock + srcStride*copyAhead, srcStride, mode & LEVEL_FIX, &c.packedYOffset);
 +
 +            if(mode & LINEAR_IPOL_DEINT_FILTER)
 +                RENAME(deInterlaceInterpolateLinear)(dstBlock, dstStride);
 +            else if(mode & LINEAR_BLEND_DEINT_FILTER)
 +                RENAME(deInterlaceBlendLinear)(dstBlock, dstStride, c.deintTemp + x);
 +            else if(mode & MEDIAN_DEINT_FILTER)
 +                RENAME(deInterlaceMedian)(dstBlock, dstStride);
 +            else if(mode & CUBIC_IPOL_DEINT_FILTER)
 +                RENAME(deInterlaceInterpolateCubic)(dstBlock, dstStride);
 +            else if(mode & FFMPEG_DEINT_FILTER)
 +                RENAME(deInterlaceFF)(dstBlock, dstStride, c.deintTemp + x);
 +            else if(mode & LOWPASS5_DEINT_FILTER)
 +                RENAME(deInterlaceL5)(dstBlock, dstStride, c.deintTemp + x, c.deintTemp + width + x);
 +/*          else if(mode & CUBIC_BLEND_DEINT_FILTER)
 +                RENAME(deInterlaceBlendCubic)(dstBlock, dstStride);
 +*/
 +
 +            /* only deblock if we have 2 blocks */
 +            if(y + 8 < height){
 +                if(mode & V_X1_FILTER)
 +                    RENAME(vertX1Filter)(dstBlock, stride, &c);
 +                else if(mode & V_DEBLOCK){
 +                    const int t= RENAME(vertClassify)(dstBlock, stride, &c);
 +
 +                    if(t==1)
 +                        RENAME(doVertLowPass)(dstBlock, stride, &c);
 +                    else if(t==2)
 +                        RENAME(doVertDefFilter)(dstBlock, stride, &c);
 +                }else if(mode & V_A_DEBLOCK){
 +                    RENAME(do_a_deblock)(dstBlock, stride, 1, &c);
 +                }
 +            }
 +
 +#if HAVE_MMX
 +            RENAME(transpose1)(tempBlock1, tempBlock2, dstBlock, dstStride);
 +#endif
 +            /* check if we have a previous block to deblock it with dstBlock */
 +            if(x - 8 >= 0){
 +#if HAVE_MMX
 +                if(mode & H_X1_FILTER)
 +                        RENAME(vertX1Filter)(tempBlock1, 16, &c);
 +                else if(mode & H_DEBLOCK){
 +//START_TIMER
 +                    const int t= RENAME(vertClassify)(tempBlock1, 16, &c);
 +//STOP_TIMER("dc & minmax")
 +                    if(t==1)
 +                        RENAME(doVertLowPass)(tempBlock1, 16, &c);
 +                    else if(t==2)
 +                        RENAME(doVertDefFilter)(tempBlock1, 16, &c);
 +                }else if(mode & H_A_DEBLOCK){
 +                        RENAME(do_a_deblock)(tempBlock1, 16, 1, &c);
 +                }
 +
 +                RENAME(transpose2)(dstBlock-4, dstStride, tempBlock1 + 4*16);
 +
 +#else
 +                if(mode & H_X1_FILTER)
 +                    horizX1Filter(dstBlock-4, stride, QP);
 +                else if(mode & H_DEBLOCK){
 +#if HAVE_ALTIVEC
 +                    DECLARE_ALIGNED(16, unsigned char, tempBlock)[272];
 +                    int t;
 +                    transpose_16x8_char_toPackedAlign_altivec(tempBlock, dstBlock - (4 + 1), stride);
 +
 +                    t = vertClassify_altivec(tempBlock-48, 16, &c);
 +                    if(t==1) {
 +                        doVertLowPass_altivec(tempBlock-48, 16, &c);
 +                        transpose_8x16_char_fromPackedAlign_altivec(dstBlock - (4 + 1), tempBlock, stride);
 +                    }
 +                    else if(t==2) {
 +                        doVertDefFilter_altivec(tempBlock-48, 16, &c);
 +                        transpose_8x16_char_fromPackedAlign_altivec(dstBlock - (4 + 1), tempBlock, stride);
 +                    }
 +#else
 +                    const int t= RENAME(horizClassify)(dstBlock-4, stride, &c);
 +
 +                    if(t==1)
 +                        RENAME(doHorizLowPass)(dstBlock-4, stride, &c);
 +                    else if(t==2)
 +                        RENAME(doHorizDefFilter)(dstBlock-4, stride, &c);
 +#endif
 +                }else if(mode & H_A_DEBLOCK){
 +                    RENAME(do_a_deblock)(dstBlock-8, 1, stride, &c);
 +                }
 +#endif //HAVE_MMX
 +                if(mode & DERING){
 +                //FIXME filter first line
 +                    if(y>0) RENAME(dering)(dstBlock - stride - 8, stride, &c);
 +                }
 +
 +                if(mode & TEMP_NOISE_FILTER)
 +                {
 +                    RENAME(tempNoiseReducer)(dstBlock-8, stride,
 +                            c.tempBlurred[isColor] + y*dstStride + x,
 +                            c.tempBlurredPast[isColor] + (y>>3)*256 + (x>>3) + 256,
 +                            c.ppMode.maxTmpNoise);
 +                }
 +            }
 +
 +            dstBlock+=8;
 +            srcBlock+=8;
 +
 +#if HAVE_MMX
 +            tmpXchg= tempBlock1;
 +            tempBlock1= tempBlock2;
 +            tempBlock2 = tmpXchg;
 +#endif
 +        }
 +
 +        if(mode & DERING){
 +            if(y > 0) RENAME(dering)(dstBlock - dstStride - 8, dstStride, &c);
 +        }
 +
 +        if((mode & TEMP_NOISE_FILTER)){
 +            RENAME(tempNoiseReducer)(dstBlock-8, dstStride,
 +                    c.tempBlurred[isColor] + y*dstStride + x,
 +                    c.tempBlurredPast[isColor] + (y>>3)*256 + (x>>3) + 256,
 +                    c.ppMode.maxTmpNoise);
 +        }
 +
 +        /* did we use a tmp buffer for the last lines*/
 +        if(y+15 >= height){
 +            uint8_t *dstBlock= &(dst[y*dstStride]);
 +            if(width==FFABS(dstStride))
 +                linecpy(dstBlock, tempDst + dstStride, height-y, dstStride);
 +            else{
 +                int i;
 +                for(i=0; i<height-y; i++){
 +                    memcpy(dstBlock + i*dstStride, tempDst + (i+1)*dstStride, width);
 +                }
 +            }
 +        }
 +/*
 +        for(x=0; x<width; x+=32){
 +            volatile int i;
 +            i+=   dstBlock[x + 7*dstStride] + dstBlock[x + 8*dstStride]
 +                + dstBlock[x + 9*dstStride] + dstBlock[x +10*dstStride]
 +                + dstBlock[x +11*dstStride] + dstBlock[x +12*dstStride];
 +                + dstBlock[x +13*dstStride]
 +                + dstBlock[x +14*dstStride] + dstBlock[x +15*dstStride];
 +        }*/
 +    }
 +#if   HAVE_AMD3DNOW
 +    __asm__ volatile("femms");
 +#elif HAVE_MMX
 +    __asm__ volatile("emms");
 +#endif
 +
 +#ifdef DEBUG_BRIGHTNESS
 +    if(!isColor){
 +        int max=1;
 +        int i;
 +        for(i=0; i<256; i++)
 +            if(yHistogram[i] > max) max=yHistogram[i];
 +
 +        for(i=1; i<256; i++){
 +            int x;
 +            int start=yHistogram[i-1]/(max/256+1);
 +            int end=yHistogram[i]/(max/256+1);
 +            int inc= end > start ? 1 : -1;
 +            for(x=start; x!=end+inc; x+=inc)
 +                dst[ i*dstStride + x]+=128;
 +        }
 +
 +        for(i=0; i<100; i+=2){
 +            dst[ (white)*dstStride + i]+=128;
 +            dst[ (black)*dstStride + i]+=128;
 +        }
 +    }
 +#endif
 +
 +    *c2= c; //copy local context back
 +
 +}
index a48d6ea,0000000..d96fd5a
mode 100644,000000..100644
--- /dev/null
@@@ -1,70 -1,0 +1,70 @@@
- #include "libavutil/x86_cpu.h"
 +/*
 + * Copyright (c) 2012 Michael Niedermayer <michaelni@gmx.at>
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
++#include "libavutil/x86/asm.h"
 +#include "libavutil/cpu.h"
 +#include "libswresample/swresample_internal.h"
 +
 +int swri_resample_int16_mmx2 (struct ResampleContext *c, int16_t *dst, const int16_t *src, int *consumed, int src_size, int dst_size, int update_ctx);
 +int swri_resample_int16_ssse3(struct ResampleContext *c, int16_t *dst, const int16_t *src, int *consumed, int src_size, int dst_size, int update_ctx);
 +
 +DECLARE_ALIGNED(16, const uint64_t, ff_resample_int16_rounder)[2]    = { 0x0000000000004000ULL, 0x0000000000000000ULL};
 +
 +#define COMMON_CORE_INT16_MMX2 \
 +    x86_reg len= -2*c->filter_length;\
 +__asm__ volatile(\
 +    "movq "MANGLE(ff_resample_int16_rounder)", %%mm0 \n\t"\
 +    "1:                         \n\t"\
 +    "movq    (%1, %0), %%mm1    \n\t"\
 +    "pmaddwd (%2, %0), %%mm1    \n\t"\
 +    "paddd  %%mm1, %%mm0        \n\t"\
 +    "add       $8, %0           \n\t"\
 +    " js 1b                     \n\t"\
 +    "pshufw $0x0E, %%mm0, %%mm1 \n\t"\
 +    "paddd %%mm1, %%mm0         \n\t"\
 +    "psrad    $15, %%mm0        \n\t"\
 +    "packssdw %%mm0, %%mm0      \n\t"\
 +    "movd %%mm0, (%3)           \n\t"\
 +    : "+r" (len)\
 +    : "r" (((uint8_t*)(src+sample_index))-len),\
 +      "r" (((uint8_t*)filter)-len),\
 +      "r" (dst+dst_index)\
 +);
 +
 +#define COMMON_CORE_INT16_SSSE3 \
 +    x86_reg len= -2*c->filter_length;\
 +__asm__ volatile(\
 +    "movdqa "MANGLE(ff_resample_int16_rounder)", %%xmm0 \n\t"\
 +    "1:                           \n\t"\
 +    "movdqu  (%1, %0), %%xmm1     \n\t"\
 +    "pmaddwd (%2, %0), %%xmm1     \n\t"\
 +    "paddd  %%xmm1, %%xmm0        \n\t"\
 +    "add       $16, %0            \n\t"\
 +    " js 1b                       \n\t"\
 +    "phaddd %%xmm0, %%xmm0        \n\t"\
 +    "phaddd %%xmm0, %%xmm0        \n\t"\
 +    "psrad    $15, %%xmm0         \n\t"\
 +    "packssdw %%xmm0, %%xmm0      \n\t"\
 +    "movd %%xmm0, (%3)            \n\t"\
 +    : "+r" (len)\
 +    : "r" (((uint8_t*)(src+sample_index))-len),\
 +      "r" (((uint8_t*)filter)-len),\
 +      "r" (dst+dst_index)\
 +);
Simple merge
Simple merge
@@@ -23,9 -23,8 +23,9 @@@
  #include "libswscale/swscale.h"
  #include "libswscale/swscale_internal.h"
  #include "libavutil/attributes.h"
 +#include "libavutil/avassert.h"
  #include "libavutil/intreadwrite.h"
- #include "libavutil/x86_cpu.h"
+ #include "libavutil/x86/asm.h"
  #include "libavutil/cpu.h"
  #include "libavutil/pixdesc.h"
  
Simple merge