Merge commit 'e74433a8e6fc00c8dbde293c97a3e45384c2c1d9'
authorMichael Niedermayer <michaelni@gmx.at>
Thu, 19 Jun 2014 02:41:48 +0000 (04:41 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Thu, 19 Jun 2014 02:54:38 +0000 (04:54 +0200)
* commit 'e74433a8e6fc00c8dbde293c97a3e45384c2c1d9':
  dsputil: Split clear_block*/fill_block* off into a separate context

Conflicts:
configure
libavcodec/asvdec.c
libavcodec/dnxhddec.c
libavcodec/dnxhdenc.c
libavcodec/dsputil.h
libavcodec/eamad.c
libavcodec/intrax8.c
libavcodec/mjpegdec.c
libavcodec/ppc/dsputil_ppc.c
libavcodec/vc1dec.c
libavcodec/x86/dsputil_init.c
libavcodec/x86/dsputil_mmx.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
55 files changed:
1  2 
configure
libavcodec/4xm.c
libavcodec/Makefile
libavcodec/arm/Makefile
libavcodec/arm/blockdsp_arm.h
libavcodec/arm/blockdsp_init_arm.c
libavcodec/arm/blockdsp_init_neon.c
libavcodec/arm/blockdsp_neon.S
libavcodec/arm/dsputil_init_neon.c
libavcodec/arm/dsputil_neon.S
libavcodec/asv.h
libavcodec/asvdec.c
libavcodec/bink.c
libavcodec/blockdsp.c
libavcodec/blockdsp.h
libavcodec/cavs.c
libavcodec/cavs.h
libavcodec/cavsdec.c
libavcodec/dnxhddec.c
libavcodec/dnxhdenc.c
libavcodec/dnxhdenc.h
libavcodec/dsputil.c
libavcodec/dsputil.h
libavcodec/eamad.c
libavcodec/eatqi.c
libavcodec/g2meet.c
libavcodec/h261dec.c
libavcodec/h263.h
libavcodec/intrax8.c
libavcodec/ituh263dec.c
libavcodec/jvdec.c
libavcodec/mdec.c
libavcodec/mimic.c
libavcodec/mjpegdec.c
libavcodec/mjpegdec.h
libavcodec/mpeg12dec.c
libavcodec/mpeg4videodec.c
libavcodec/mpeg4videoenc.c
libavcodec/mpegvideo.c
libavcodec/mpegvideo.h
libavcodec/msmpeg4dec.c
libavcodec/ppc/Makefile
libavcodec/ppc/blockdsp.c
libavcodec/ppc/dsputil_altivec.c
libavcodec/ppc/dsputil_ppc.c
libavcodec/proresdec.h
libavcodec/proresdec2.c
libavcodec/vc1dec.c
libavcodec/wmv2.c
libavcodec/wmv2dec.c
libavcodec/x86/Makefile
libavcodec/x86/blockdsp_mmx.c
libavcodec/x86/dsputil_init.c
libavcodec/x86/dsputil_mmx.c
libavcodec/x86/dsputil_x86.h

diff --cc configure
+++ b/configure
@@@ -1796,10 -1530,9 +1796,11 @@@ CONFIG_EXTRA=
      aandcttables
      ac3dsp
      audio_frame_queue
+     blockdsp
      cabac
      dsputil
 +    exif
 +    frame_thread_encoder
      gcrypt
      golomb
      gplv3
@@@ -1995,7 -1706,7 +1996,7 @@@ mdct_select="fft
  rdft_select="fft"
  mpegaudio_select="mpegaudiodsp"
  mpegaudiodsp_select="dct"
- mpegvideo_select="dsputil h264chroma hpeldsp videodsp"
 -mpegvideo_select="blockdsp dsputil hpeldsp videodsp"
++mpegvideo_select="blockdsp dsputil h264chroma hpeldsp videodsp"
  mpegvideoenc_select="dsputil mpegvideo qpeldsp"
  
  # decoders / encoders
@@@ -2011,39 -1721,36 +2012,39 @@@ alac_encoder_select="lpc
  als_decoder_select="dsputil"
  amrnb_decoder_select="lsp"
  amrwb_decoder_select="lsp"
 -amv_decoder_select="sp5x_decoder"
 -ape_decoder_select="dsputil"
 +amv_decoder_select="sp5x_decoder exif"
 +amv_encoder_select="aandcttables"
 +ape_decoder_select="dsputil llauddsp"
- asv1_decoder_select="dsputil"
+ asv1_decoder_select="blockdsp dsputil"
  asv1_encoder_select="dsputil"
- asv2_decoder_select="dsputil"
+ asv2_decoder_select="blockdsp dsputil"
  asv2_encoder_select="dsputil"
  atrac1_decoder_select="mdct sinewin"
  atrac3_decoder_select="mdct"
  atrac3p_decoder_select="mdct sinewin"
- bink_decoder_select="dsputil hpeldsp"
 +avrn_decoder_select="exif"
+ bink_decoder_select="blockdsp hpeldsp"
  binkaudio_dct_decoder_select="mdct rdft dct sinewin"
  binkaudio_rdft_decoder_select="mdct rdft sinewin"
- cavs_decoder_select="dsputil golomb h264chroma qpeldsp videodsp"
+ cavs_decoder_select="blockdsp dsputil golomb h264chroma qpeldsp videodsp"
  cllc_decoder_select="dsputil"
  comfortnoise_encoder_select="lpc"
  cook_decoder_select="dsputil mdct sinewin"
  cscd_decoder_select="lzo"
  cscd_decoder_suggest="zlib"
  dca_decoder_select="mdct"
- dnxhd_decoder_select="dsputil"
- dnxhd_encoder_select="aandcttables dsputil mpegvideoenc"
 +dirac_decoder_select="dsputil dwt golomb videodsp"
+ dnxhd_decoder_select="blockdsp dsputil"
+ dnxhd_encoder_select="aandcttables blockdsp dsputil mpegvideoenc"
  dvvideo_decoder_select="dsputil"
  dvvideo_encoder_select="dsputil"
 -dxa_decoder_deps="zlib"
 +dxa_decoder_select="zlib"
  eac3_decoder_select="ac3_decoder"
  eac3_encoder_select="ac3_encoder"
- eamad_decoder_select="aandcttables dsputil mpegvideo"
+ eamad_decoder_select="aandcttables blockdsp dsputil mpegvideo"
 -eatgq_decoder_select="aandcttables dsputil"
 +eatgq_decoder_select="aandcttables"
- eatqi_decoder_select="aandcttables dsputil error_resilience mpegvideo"
+ eatqi_decoder_select="aandcttables blockdsp dsputil error_resilience mpegvideo"
 -exr_decoder_deps="zlib"
 +exr_decoder_select="zlib"
  ffv1_decoder_select="golomb rangecoder"
  ffv1_encoder_select="rangecoder"
  ffvhuff_decoder_select="huffyuv_decoder"
@@@ -2051,16 -1758,15 +2052,16 @@@ ffvhuff_encoder_select="huffyuv_encoder
  fic_decoder_select="golomb"
  flac_decoder_select="golomb"
  flac_encoder_select="dsputil golomb lpc"
 -flashsv_decoder_deps="zlib"
 -flashsv_encoder_deps="zlib"
 -flashsv2_decoder_deps="zlib"
 +flashsv_decoder_select="zlib"
 +flashsv_encoder_select="zlib"
 +flashsv2_encoder_select="zlib"
 +flashsv2_decoder_select="zlib"
  flv_decoder_select="h263_decoder"
  flv_encoder_select="h263_encoder"
- fourxm_decoder_select="dsputil"
+ fourxm_decoder_select="blockdsp dsputil"
  fraps_decoder_select="dsputil huffman"
- g2m_decoder_select="dsputil zlib"
 -g2m_decoder_deps="zlib"
 -g2m_decoder_select="blockdsp dsputil"
++g2m_decoder_select="blockdsp dsputil zlib"
 +g729_decoder_select="dsputil"
  h261_decoder_select="error_resilience mpegvideo"
  h261_encoder_select="aandcttables mpegvideoenc"
  h263_decoder_select="error_resilience h263_parser h263dsp mpegvideo qpeldsp"
@@@ -2082,10 -1788,10 +2083,10 @@@ jv_decoder_select="blockdsp
  lagarith_decoder_select="huffyuvdsp"
  ljpeg_encoder_select="aandcttables mpegvideoenc"
  loco_decoder_select="golomb"
- mdec_decoder_select="dsputil error_resilience mpegvideo"
+ mdec_decoder_select="blockdsp dsputil error_resilience mpegvideo"
  metasound_decoder_select="lsp mdct sinewin"
- mimic_decoder_select="dsputil hpeldsp"
- mjpeg_decoder_select="dsputil hpeldsp exif"
+ mimic_decoder_select="blockdsp dsputil hpeldsp"
 -mjpeg_decoder_select="blockdsp dsputil hpeldsp"
++mjpeg_decoder_select="blockdsp dsputil hpeldsp exif"
  mjpeg_encoder_select="aandcttables mpegvideoenc"
  mjpegb_decoder_select="mjpeg_decoder"
  mlp_decoder_select="mlp_parser"
@@@ -2121,10 -1827,11 +2122,10 @@@ nellymoser_decoder_select="mdct sinewin
  nellymoser_encoder_select="audio_frame_queue mdct sinewin"
  nuv_decoder_select="dsputil lzo"
  on2avc_decoder_select="mdct"
 -opus_decoder_deps="avresample"
 -png_decoder_deps="zlib"
 -png_encoder_deps="zlib"
 -png_encoder_select="huffyuvencdsp"
 -prores_decoder_select="dsputil"
 +opus_decoder_deps="swresample"
 +png_decoder_select="zlib"
 +png_encoder_select="huffyuvencdsp zlib"
- prores_decoder_select="dsputil"
++prores_decoder_select="blockdsp dsputil"
  prores_encoder_select="dsputil"
  qcelp_decoder_select="lsp"
  qdm2_decoder_select="mdct rdft mpegaudiodsp"
Simple merge
@@@ -33,8 -28,8 +33,9 @@@ OBJS = allcodecs.
  OBJS-$(CONFIG_AANDCTTABLES)            += aandcttab.o
  OBJS-$(CONFIG_AC3DSP)                  += ac3dsp.o
  OBJS-$(CONFIG_AUDIO_FRAME_QUEUE)       += audio_frame_queue.o
+ OBJS-$(CONFIG_BLOCKDSP)                += blockdsp.o
  OBJS-$(CONFIG_CABAC)                   += cabac.o
 +OBJS-$(CONFIG_CRYSTALHD)               += crystalhd.o
  OBJS-$(CONFIG_DCT)                     += dct.o dct32_fixed.o dct32_float.o
  OBJS-$(CONFIG_DXVA2)                   += dxva2.o
  OBJS-$(CONFIG_DSPUTIL)                 += dsputil.o faanidct.o          \
Simple merge
index 0000000,6d9c2c3..2688d36
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,26 +1,26 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * FFmpeg is free software; you can redistribute it and/or
+  * modify it under the terms of the GNU Lesser General Public
+  * License as published by the Free Software Foundation; either
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #ifndef AVCODEC_ARM_BLOCKDSP_ARM_H
+ #define AVCODEC_ARM_BLOCKDSP_ARM_H
+ #include "libavcodec/blockdsp.h"
+ void ff_blockdsp_init_neon(BlockDSPContext *c, unsigned high_bit_depth);
+ #endif /* AVCODEC_ARM_BLOCKDSP_ARM_H */
index 0000000,a0c0367..3b86a71
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,33 +1,33 @@@
 - * This file is part of Libav.
+ /*
+  * ARM optimized block operations
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * FFmpeg is free software; you can redistribute it and/or
+  * modify it under the terms of the GNU Lesser General Public
+  * License as published by the Free Software Foundation; either
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #include "libavutil/attributes.h"
+ #include "libavutil/cpu.h"
+ #include "libavutil/arm/cpu.h"
+ #include "libavcodec/blockdsp.h"
+ #include "blockdsp_arm.h"
+ av_cold void ff_blockdsp_init_arm(BlockDSPContext *c, unsigned high_bit_depth)
+ {
+     int cpu_flags = av_get_cpu_flags();
+     if (have_neon(cpu_flags))
+         ff_blockdsp_init_neon(c, high_bit_depth);
+ }
index 0000000,5081cf0..62b51fc
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,37 +1,37 @@@
 - * This file is part of Libav.
+ /*
+  * ARM NEON optimised block operations
+  * Copyright (c) 2008 Mans Rullgard <mans@mansr.com>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * FFmpeg is free software; you can redistribute it and/or
+  * modify it under the terms of the GNU Lesser General Public
+  * License as published by the Free Software Foundation; either
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #include <stdint.h>
+ #include "libavutil/attributes.h"
+ #include "libavcodec/blockdsp.h"
+ #include "blockdsp_arm.h"
+ void ff_clear_block_neon(int16_t *block);
+ void ff_clear_blocks_neon(int16_t *blocks);
+ av_cold void ff_blockdsp_init_neon(BlockDSPContext *c, unsigned high_bit_depth)
+ {
+     if (!high_bit_depth) {
+         c->clear_block  = ff_clear_block_neon;
+         c->clear_blocks = ff_clear_blocks_neon;
+     }
+ }
index 0000000,98df2c6..9fc63cb
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,38 +1,38 @@@
 - * This file is part of Libav.
+ /*
+  * ARM NEON optimised block functions
+  * Copyright (c) 2008 Mans Rullgard <mans@mansr.com>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * FFmpeg is free software; you can redistribute it and/or
+  * modify it under the terms of the GNU Lesser General Public
+  * License as published by the Free Software Foundation; either
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #include "libavutil/arm/asm.S"
+ function ff_clear_block_neon, export=1
+         vmov.i16        q0,  #0
+         .rept           8
+         vst1.16         {q0}, [r0,:128]!
+         .endr
+         bx              lr
+ endfunc
+ function ff_clear_blocks_neon, export=1
+         vmov.i16        q0,  #0
+         .rept           8*6
+         vst1.16         {q0}, [r0,:128]!
+         .endr
+         bx              lr
+ endfunc
Simple merge
Simple merge
Simple merge
@@@ -28,6 -28,8 +28,7 @@@
  
  #include "asv.h"
  #include "avcodec.h"
 -#include "put_bits.h"
+ #include "blockdsp.h"
  #include "internal.h"
  #include "mathops.h"
  #include "mpeg12data.h"
Simple merge
index 0000000,e3d2ca1..6335b60
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,78 +1,78 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * FFmpeg is free software; you can redistribute it and/or
+  * modify it under the terms of the GNU Lesser General Public
+  * License as published by the Free Software Foundation; either
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #include <stdint.h>
+ #include <string.h>
+ #include "config.h"
+ #include "libavutil/attributes.h"
+ #include "avcodec.h"
+ #include "blockdsp.h"
+ #include "version.h"
+ static void clear_block_8_c(int16_t *block)
+ {
+     memset(block, 0, sizeof(int16_t) * 64);
+ }
+ static void clear_blocks_8_c(int16_t *blocks)
+ {
+     memset(blocks, 0, sizeof(int16_t) * 6 * 64);
+ }
+ static void fill_block16_c(uint8_t *block, uint8_t value, int line_size, int h)
+ {
+     int i;
+     for (i = 0; i < h; i++) {
+         memset(block, value, 16);
+         block += line_size;
+     }
+ }
+ static void fill_block8_c(uint8_t *block, uint8_t value, int line_size, int h)
+ {
+     int i;
+     for (i = 0; i < h; i++) {
+         memset(block, value, 8);
+         block += line_size;
+     }
+ }
+ av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
+ {
+     const unsigned high_bit_depth = avctx->bits_per_raw_sample > 8;
+     c->clear_block  = clear_block_8_c;
+     c->clear_blocks = clear_blocks_8_c;
+     c->fill_block_tab[0] = fill_block16_c;
+     c->fill_block_tab[1] = fill_block8_c;
+     if (ARCH_ARM)
+         ff_blockdsp_init_arm(c, high_bit_depth);
+     if (ARCH_PPC)
+         ff_blockdsp_init_ppc(c, high_bit_depth);
+     if (ARCH_X86)
+ #if FF_API_XVMC
+         ff_blockdsp_init_x86(c, high_bit_depth, avctx);
+ #else
+         ff_blockdsp_init_x86(c, high_bit_depth);
+ #endif /* FF_API_XVMC */
+ }
index 0000000,32c671c..47212f7
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,52 +1,52 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * FFmpeg is free software; you can redistribute it and/or
+  * modify it under the terms of the GNU Lesser General Public
+  * License as published by the Free Software Foundation; either
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #ifndef AVCODEC_BLOCKDSP_H
+ #define AVCODEC_BLOCKDSP_H
+ #include <stdint.h>
+ #include "avcodec.h"
+ #include "version.h"
+ /* add and put pixel (decoding)
+  * Block sizes for op_pixels_func are 8x4,8x8 16x8 16x16.
+  * h for op_pixels_func is limited to { width / 2, width },
+  * but never larger than 16 and never smaller than 4. */
+ typedef void (*op_fill_func)(uint8_t *block /* align width (8 or 16) */,
+                              uint8_t value, int line_size, int h);
+ typedef struct BlockDSPContext {
+     void (*clear_block)(int16_t *block /* align 16 */);
+     void (*clear_blocks)(int16_t *blocks /* align 16 */);
+     op_fill_func fill_block_tab[2];
+ } BlockDSPContext;
+ void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx);
+ void ff_blockdsp_init_arm(BlockDSPContext *c, unsigned high_bit_depth);
+ void ff_blockdsp_init_ppc(BlockDSPContext *c, unsigned high_bit_depth);
+ #if FF_API_XVMC
+ void ff_blockdsp_init_x86(BlockDSPContext *c, unsigned high_bit_depth,
+                           AVCodecContext *avctx);
+ #else
+ void ff_blockdsp_init_x86(BlockDSPContext *c, unsigned high_bit_depth);
+ #endif /* FF_API_XVMC */
+ #endif /* AVCODEC_BLOCKDSP_H */
Simple merge
Simple merge
Simple merge
@@@ -34,7 -34,8 +35,8 @@@
  typedef struct DNXHDContext {
      AVCodecContext *avctx;
      GetBitContext gb;
 -    int cid;                            ///< compression id
+     BlockDSPContext bdsp;
 +    int64_t cid;                        ///< compression id
      unsigned int width, height;
      unsigned int mb_width, mb_height;
      uint32_t mb_scan_index[68];         /* max for 1080p */
@@@ -329,16 -311,8 +334,16 @@@ static int dnxhd_decode_macroblock(DNXH
      qscale = get_bits(&ctx->gb, 11);
      skip_bits1(&ctx->gb);
  
 +    if (qscale != ctx->last_qscale) {
 +        for (i = 0; i < 64; i++) {
 +            ctx->luma_scale[i]   = qscale * ctx->cid_table->luma_weight[i];
 +            ctx->chroma_scale[i] = qscale * ctx->cid_table->chroma_weight[i];
 +        }
 +        ctx->last_qscale = qscale;
 +    }
 +
      for (i = 0; i < 8; i++) {
-         ctx->dsp.clear_block(ctx->blocks[i]);
+         ctx->bdsp.clear_block(ctx->blocks[i]);
          ctx->decode_dct_block(ctx, ctx->blocks[i], i, qscale);
      }
      if (ctx->is_444) {
@@@ -320,9 -306,9 +321,10 @@@ static av_cold int dnxhd_encode_init(AV
  
      avctx->bits_per_raw_sample = ctx->cid_table->bit_depth;
  
 -    ff_dsputil_init(&ctx->m.dsp, avctx);
+     ff_blockdsp_init(&ctx->bdsp, avctx);
      ff_dct_common_init(&ctx->m);
 +    ff_dct_encode_init(&ctx->m);
 +
      if (!ctx->m.dct_quantize)
          ctx->m.dct_quantize = ff_dct_quantize_c;
  
Simple merge
Simple merge
@@@ -38,26 -38,6 +38,19 @@@ void ff_gmc_c(uint8_t *dst, uint8_t *sr
                int dxx, int dxy, int dyx, int dyy, int shift, int r,
                int width, int height);
  
- /* add and put pixel (decoding)
-  * Block sizes for op_pixels_func are 8x4,8x8 16x8 16x16.
-  * h for op_pixels_func is limited to { width / 2, width },
-  * but never larger than 16 and never smaller than 4. */
- typedef void (*op_fill_func)(uint8_t *block /* align width (8 or 16) */,
-                              uint8_t value, int line_size, int h);
 +/* minimum alignment rules ;)
 + * If you notice errors in the align stuff, need more alignment for some ASM code
 + * for some CPU or need to use a function with less aligned data then send a mail
 + * to the ffmpeg-devel mailing list, ...
 + *
 + * !warning These alignments might not match reality, (missing attribute((align))
 + * stuff somewhere possible).
 + * I (Michael) did not check them, these are just the alignments which I think
 + * could be reached easily ...
 + *
 + * !future video codecs might need functions with less strict alignment
 + */
 +
  struct MpegEncContext;
  /* Motion estimation:
   * h is limited to { width / 2, width, 2 * width },
@@@ -210,12 -207,10 +212,12 @@@ static int decode_mb(MadContext *s, AVF
      for (j=0; j<6; j++) {
          if (mv_map & (1<<j)) {  // mv_x and mv_y are guarded by mv_map
              int add = 2*decode_motion(&s->gb);
 -            comp_block(s, frame, s->mb_x, s->mb_y, j, mv_x, mv_y, add);
 +            if (s->last_frame->data[0])
 +                comp_block(s, frame, s->mb_x, s->mb_y, j, mv_x, mv_y, add);
          } else {
-             s->dsp.clear_block(s->block);
+             s->bdsp.clear_block(s->block);
 -            decode_block_intra(s, s->block);
 +            if(decode_block_intra(s, s->block) < 0)
 +                return -1;
              idct_put(s, frame, s->block, s->mb_x, s->mb_y, j);
          }
      }
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -534,8 -537,8 +534,8 @@@ static int x8_decode_intra_mb(IntraX8Co
      int use_quant_matrix;
      int sign;
  
 -    assert(w->orient<12);
 +    av_assert2(w->orient<12);
-     s->dsp.clear_block(s->block[0]);
+     s->bdsp.clear_block(s->block[0]);
  
      if(chroma){
          dc_mode=2;
Simple merge
Simple merge
@@@ -121,9 -123,9 +123,9 @@@ static inline int mdec_decode_block_int
  static inline int decode_mb(MDECContext *a, int16_t block[6][64])
  {
      int i, ret;
 -    const int block_index[6] = { 5, 4, 0, 1, 2, 3 };
 +    static const int block_index[6] = { 5, 4, 0, 1, 2, 3 };
  
-     a->dsp.clear_blocks(block[0]);
+     a->bdsp.clear_blocks(block[0]);
  
      for (i = 0; i < 6; i++) {
          if ((ret = mdec_decode_block_intra(a, block[block_index[i]],
Simple merge
   * MJPEG decoder.
   */
  
 -#include <assert.h>
 -
  #include "libavutil/imgutils.h"
 +#include "libavutil/avassert.h"
  #include "libavutil/opt.h"
  #include "avcodec.h"
+ #include "blockdsp.h"
 +#include "copy_block.h"
  #include "internal.h"
  #include "mjpeg.h"
  #include "mjpegdec.h"
@@@ -652,9 -488,9 +654,9 @@@ static int decode_dc_progressive(MJpegD
                                   int16_t *quant_matrix, int Al)
  {
      int val;
-     s->dsp.clear_block(block);
+     s->bdsp.clear_block(block);
      val = mjpeg_decode_dc(s, dc_index);
 -    if (val == 0xffff) {
 +    if (val == 0xfffff) {
          av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
          return AVERROR_INVALIDDATA;
      }
@@@ -1213,14 -876,14 +1215,14 @@@ static int mjpeg_decode_scan(MJpegDecod
                      ptr = data[c] + block_offset;
                      if (!s->progressive) {
                          if (copy_mb)
 -                            s->hdsp.put_pixels_tab[1][0](ptr,
 -                                reference_data[c] + block_offset,
 -                                linesize[c], 8);
 +                            mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
 +                                             linesize[c], s->avctx->lowres);
 +
                          else {
-                             s->dsp.clear_block(s->block);
+                             s->bdsp.clear_block(s->block);
                              if (decode_block(s, s->block, i,
                                               s->dc_index[i], s->ac_index[i],
 -                                             s->quant_matrixes[s->quant_index[c]]) < 0) {
 +                                             s->quant_matrixes[s->quant_sindex[i]]) < 0) {
                                  av_log(s->avctx, AV_LOG_ERROR,
                                         "error y=%d x=%d\n", mb_y, mb_x);
                                  return AVERROR_INVALIDDATA;
  
  #include "libavutil/log.h"
  #include "libavutil/pixdesc.h"
 +#include "libavutil/stereo3d.h"
  
  #include "avcodec.h"
+ #include "blockdsp.h"
  #include "get_bits.h"
  #include "dsputil.h"
  #include "hpeldsp.h"
@@@ -102,8 -95,8 +103,9 @@@ typedef struct MJpegDecodeContext 
      int16_t (*blocks[MAX_COMPONENTS])[64]; ///< intermediate sums (progressive mode)
      uint8_t *last_nnz[MAX_COMPONENTS];
      uint64_t coefs_finished[MAX_COMPONENTS]; ///< bitmask of which coefs have been completely decoded (progressive mode)
 +    int palette_index;
      ScanTable scantable;
+     BlockDSPContext bdsp;
      DSPContext dsp;
      HpelDSPContext hdsp;
  
Simple merge
Simple merge
Simple merge
@@@ -33,8 -33,8 +33,9 @@@
  #include "libavutil/internal.h"
  #include "libavutil/timer.h"
  #include "avcodec.h"
+ #include "blockdsp.h"
  #include "dsputil.h"
 +#include "h264chroma.h"
  #include "internal.h"
  #include "mathops.h"
  #include "mpegutils.h"
@@@ -378,8 -377,8 +379,9 @@@ static void gray8(uint8_t *dst, const u
  /* init common dct for both encoder and decoder */
  av_cold int ff_dct_common_init(MpegEncContext *s)
  {
+     ff_blockdsp_init(&s->bdsp, s->avctx);
      ff_dsputil_init(&s->dsp, s->avctx);
 +    ff_h264chroma_init(&s->h264chroma, 8); //for lowres
      ff_hpeldsp_init(&s->hdsp, s->avctx->flags);
      ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
  
@@@ -356,8 -348,8 +357,9 @@@ typedef struct MpegEncContext 
      int unrestricted_mv;        ///< mv can point outside of the coded picture
      int h263_long_vectors;      ///< use horrible h263v1 long vector mode
  
+     BlockDSPContext bdsp;
      DSPContext dsp;             ///< pointers for accelerated dsp functions
 +    H264ChromaContext h264chroma;
      HpelDSPContext hdsp;
      QpelDSPContext qdsp;
      VideoDSPContext vdsp;
@@@ -176,10 -172,9 +176,10 @@@ static int msmpeg4v12_decode_mb(MpegEnc
              cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
              if(s->pict_type==AV_PICTURE_TYPE_P) cbp^=0x3C;
          }
 +        *mb_type_ptr = MB_TYPE_INTRA;
      }
  
-     s->dsp.clear_blocks(s->block[0]);
+     s->bdsp.clear_blocks(s->block[0]);
      for (i = 0; i < 6; i++) {
          if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
          {
Simple merge
index 0000000,679bc04..0059b3b
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,169 +1,169 @@@
 - * This file is part of Libav.
+ /*
+  * Copyright (c) 2002 Brian Foley
+  * Copyright (c) 2002 Dieter Shirley
+  * Copyright (c) 2003-2004 Romain Dolbeau <romain@dolbeau.org>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * FFmpeg is free software; you can redistribute it and/or
+  * modify it under the terms of the GNU Lesser General Public
+  * License as published by the Free Software Foundation; either
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #include "config.h"
+ #if HAVE_ALTIVEC_H
+ #include <altivec.h>
+ #endif
+ #include <string.h>
+ #include "libavutil/attributes.h"
+ #include "libavutil/cpu.h"
+ #include "libavutil/mem.h"
+ #include "libavutil/ppc/cpu.h"
+ #include "libavutil/ppc/types_altivec.h"
+ #include "libavcodec/blockdsp.h"
+ /* ***** WARNING ***** WARNING ***** WARNING ***** */
+ /*
+  * clear_blocks_dcbz32_ppc will not work properly on PowerPC processors with
+  * a cache line size not equal to 32 bytes. Fortunately all processors used
+  * by Apple up to at least the 7450 (AKA second generation G4) use 32-byte
+  * cache lines. This is due to the use of the 'dcbz' instruction. It simply
+  * clears a single cache line to zero, so you need to know the cache line
+  * size to use it! It's absurd, but it's fast...
+  *
+  * update 24/06/2003: Apple released the G5 yesterday, with a PPC970.
+  * cache line size: 128 bytes. Oups.
+  * The semantics of dcbz was changed, it always clears 32 bytes. So the function
+  * below will work, but will be slow. So I fixed check_dcbz_effect to use dcbzl,
+  * which is defined to clear a cache line (as dcbz before). So we can still
+  * distinguish, and use dcbz (32 bytes) or dcbzl (one cache line) as required.
+  *
+  * see <http://developer.apple.com/technotes/tn/tn2087.html>
+  * and <http://developer.apple.com/technotes/tn/tn2086.html>
+  */
+ static void clear_blocks_dcbz32_ppc(int16_t *blocks)
+ {
+     register int misal = (unsigned long) blocks & 0x00000010, i = 0;
+     if (misal) {
+         ((unsigned long *) blocks)[0] = 0L;
+         ((unsigned long *) blocks)[1] = 0L;
+         ((unsigned long *) blocks)[2] = 0L;
+         ((unsigned long *) blocks)[3] = 0L;
+         i += 16;
+     }
+     for (; i < sizeof(int16_t) * 6 * 64 - 31; i += 32)
+         __asm__ volatile ("dcbz %0,%1" :: "b" (blocks), "r" (i) : "memory");
+     if (misal) {
+         ((unsigned long *) blocks)[188] = 0L;
+         ((unsigned long *) blocks)[189] = 0L;
+         ((unsigned long *) blocks)[190] = 0L;
+         ((unsigned long *) blocks)[191] = 0L;
+         i += 16;
+     }
+ }
+ /* Same as above, when dcbzl clears a whole 128 bytes cache line
+  * i.e. the PPC970 AKA G5. */
+ static void clear_blocks_dcbz128_ppc(int16_t *blocks)
+ {
+ #if HAVE_DCBZL
+     register int misal = (unsigned long) blocks & 0x0000007f, i = 0;
+     if (misal) {
+         /* We could probably also optimize this case,
+          * but there's not much point as the machines
+          * aren't available yet (2003-06-26). */
+         memset(blocks, 0, sizeof(int16_t) * 6 * 64);
+     } else {
+         for (; i < sizeof(int16_t) * 6 * 64; i += 128)
+             __asm__ volatile ("dcbzl %0,%1" :: "b" (blocks), "r" (i) : "memory");
+     }
+ #else
+     memset(blocks, 0, sizeof(int16_t) * 6 * 64);
+ #endif
+ }
+ /* Check dcbz report how many bytes are set to 0 by dcbz. */
+ /* update 24/06/2003: Replace dcbz by dcbzl to get the intended effect
+  * (Apple "fixed" dcbz). Unfortunately this cannot be used unless the
+  * assembler knows about dcbzl ... */
+ static long check_dcbzl_effect(void)
+ {
+     long count = 0;
+ #if HAVE_DCBZL
+     register char *fakedata = av_malloc(1024);
+     register char *fakedata_middle;
+     register long zero = 0, i = 0;
+     if (!fakedata)
+         return 0L;
+     fakedata_middle = fakedata + 512;
+     memset(fakedata, 0xFF, 1024);
+     /* Below the constraint "b" seems to mean "address base register"
+      * in gcc-3.3 / RS/6000 speaks. Seems to avoid using r0, so.... */
+     __asm__ volatile ("dcbzl %0, %1" :: "b" (fakedata_middle), "r" (zero));
+     for (i = 0; i < 1024; i++)
+         if (fakedata[i] == (char) 0)
+             count++;
+     av_free(fakedata);
+ #endif
+     return count;
+ }
+ #if HAVE_ALTIVEC
+ static void clear_block_altivec(int16_t *block)
+ {
+     LOAD_ZERO;
+     vec_st(zero_s16v,   0, block);
+     vec_st(zero_s16v,  16, block);
+     vec_st(zero_s16v,  32, block);
+     vec_st(zero_s16v,  48, block);
+     vec_st(zero_s16v,  64, block);
+     vec_st(zero_s16v,  80, block);
+     vec_st(zero_s16v,  96, block);
+     vec_st(zero_s16v, 112, block);
+ }
+ #endif /* HAVE_ALTIVEC */
+ av_cold void ff_blockdsp_init_ppc(BlockDSPContext *c, unsigned high_bit_depth)
+ {
+     // common optimizations whether AltiVec is available or not
+     if (!high_bit_depth) {
+         switch (check_dcbzl_effect()) {
+         case 32:
+             c->clear_blocks = clear_blocks_dcbz32_ppc;
+             break;
+         case 128:
+             c->clear_blocks = clear_blocks_dcbz128_ppc;
+             break;
+         default:
+             break;
+         }
+     }
+ #if HAVE_ALTIVEC
+     if (!PPC_ALTIVEC(av_get_cpu_flags()))
+         return;
+     if (!high_bit_depth)
+         c->clear_block = clear_block_altivec;
+ #endif /* HAVE_ALTIVEC */
+ }
Simple merge
  av_cold void ff_dsputil_init_ppc(DSPContext *c, AVCodecContext *avctx,
                                   unsigned high_bit_depth)
  {
 -    if (PPC_ALTIVEC(av_get_cpu_flags())) {
 +    int mm_flags = av_get_cpu_flags();
-     // common optimizations whether AltiVec is available or not
-     if (!high_bit_depth) {
-         switch (check_dcbzl_effect()) {
-         case 32:
-             c->clear_blocks = clear_blocks_dcbz32_ppc;
-             break;
-         case 128:
-             c->clear_blocks = clear_blocks_dcbz128_ppc;
-             break;
-         default:
-             break;
-         }
-     }
 +    if (PPC_ALTIVEC(mm_flags)) {
          ff_dsputil_init_altivec(c, avctx, high_bit_depth);
          ff_int_init_altivec(c, avctx);
          c->gmc1 = ff_gmc1_altivec;
index de50dae,0000000..cb72979
mode 100644,000000..100644
--- /dev/null
@@@ -1,55 -1,0 +1,57 @@@
 +/*
 + * Copyright (c) 2010-2011 Maxim Poliakovski
 + * Copyright (c) 2010-2011 Elvis Presley
 + *
 + * 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 AVCODEC_PRORESDEC_H
 +#define AVCODEC_PRORESDEC_H
 +
 +#include "dsputil.h"
++#include "blockdsp.h"
 +#include "proresdsp.h"
 +
 +typedef struct {
 +    const uint8_t *data;
 +    unsigned mb_x;
 +    unsigned mb_y;
 +    unsigned mb_count;
 +    unsigned data_size;
 +    int ret;
 +} SliceContext;
 +
 +typedef struct {
 +    DSPContext dsp;
++    BlockDSPContext bdsp;
 +    ProresDSPContext prodsp;
 +    AVFrame *frame;
 +    int frame_type;              ///< 0 = progressive, 1 = tff, 2 = bff
 +    uint8_t qmat_luma[64];
 +    uint8_t qmat_chroma[64];
 +    SliceContext *slices;
 +    int slice_count;             ///< number of slices in the current picture
 +    unsigned mb_width;           ///< width of the current picture in mb
 +    unsigned mb_height;          ///< height of the current picture in mb
 +    uint8_t progressive_scan[64];
 +    uint8_t interlaced_scan[64];
 +    const uint8_t *scan;
 +    int first_field;
 +    int alpha_info;
 +} ProresContext;
 +
 +#endif /* AVCODEC_PRORESDEC_H */
index add9908,0000000..fb0c484
mode 100644,000000..100644
--- /dev/null
@@@ -1,688 -1,0 +1,689 @@@
-         ctx->dsp.clear_block(blocks+(i<<6));
 +/*
 + * Copyright (c) 2010-2011 Maxim Poliakovski
 + * Copyright (c) 2010-2011 Elvis Presley
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +/**
 + * @file
 + * Known FOURCCs: 'apch' (HQ), 'apcn' (SD), 'apcs' (LT), 'acpo' (Proxy), 'ap4h' (4444)
 + */
 +
 +//#define DEBUG
 +
 +#define LONG_BITSTREAM_READER
 +
 +#include "avcodec.h"
 +#include "get_bits.h"
 +#include "internal.h"
 +#include "simple_idct.h"
 +#include "proresdec.h"
 +#include "proresdata.h"
 +
 +static void permute(uint8_t *dst, const uint8_t *src, const uint8_t permutation[64])
 +{
 +    int i;
 +    for (i = 0; i < 64; i++)
 +        dst[i] = permutation[src[i]];
 +}
 +
 +static av_cold int decode_init(AVCodecContext *avctx)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    uint8_t idct_permutation[64];
 +
 +    avctx->bits_per_raw_sample = 10;
 +
 +    ff_dsputil_init(&ctx->dsp, avctx);
++    ff_blockdsp_init(&ctx->bdsp, avctx);
 +    ff_proresdsp_init(&ctx->prodsp, avctx);
 +
 +    ff_init_scantable_permutation(idct_permutation,
 +                                  ctx->prodsp.idct_permutation_type);
 +
 +    permute(ctx->progressive_scan, ff_prores_progressive_scan, idct_permutation);
 +    permute(ctx->interlaced_scan, ff_prores_interlaced_scan, idct_permutation);
 +
 +    return 0;
 +}
 +
 +static int decode_frame_header(ProresContext *ctx, const uint8_t *buf,
 +                               const int data_size, AVCodecContext *avctx)
 +{
 +    int hdr_size, width, height, flags;
 +    int version;
 +    const uint8_t *ptr;
 +
 +    hdr_size = AV_RB16(buf);
 +    av_dlog(avctx, "header size %d\n", hdr_size);
 +    if (hdr_size > data_size) {
 +        av_log(avctx, AV_LOG_ERROR, "error, wrong header size\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    version = AV_RB16(buf + 2);
 +    av_dlog(avctx, "%.4s version %d\n", buf+4, version);
 +    if (version > 1) {
 +        av_log(avctx, AV_LOG_ERROR, "unsupported version: %d\n", version);
 +        return AVERROR_PATCHWELCOME;
 +    }
 +
 +    width  = AV_RB16(buf + 8);
 +    height = AV_RB16(buf + 10);
 +    if (width != avctx->width || height != avctx->height) {
 +        av_log(avctx, AV_LOG_ERROR, "picture resolution change: %dx%d -> %dx%d\n",
 +               avctx->width, avctx->height, width, height);
 +        return AVERROR_PATCHWELCOME;
 +    }
 +
 +    ctx->frame_type = (buf[12] >> 2) & 3;
 +    ctx->alpha_info = buf[17] & 0xf;
 +
 +    if (ctx->alpha_info > 2) {
 +        av_log(avctx, AV_LOG_ERROR, "Invalid alpha mode %d\n", ctx->alpha_info);
 +        return AVERROR_INVALIDDATA;
 +    }
 +    if (avctx->skip_alpha) ctx->alpha_info = 0;
 +
 +    av_dlog(avctx, "frame type %d\n", ctx->frame_type);
 +
 +    if (ctx->frame_type == 0) {
 +        ctx->scan = ctx->progressive_scan; // permuted
 +    } else {
 +        ctx->scan = ctx->interlaced_scan; // permuted
 +        ctx->frame->interlaced_frame = 1;
 +        ctx->frame->top_field_first = ctx->frame_type == 1;
 +    }
 +
 +    if (ctx->alpha_info) {
 +        avctx->pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUVA444P10 : AV_PIX_FMT_YUVA422P10;
 +    } else {
 +        avctx->pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUV444P10 : AV_PIX_FMT_YUV422P10;
 +    }
 +
 +    ptr   = buf + 20;
 +    flags = buf[19];
 +    av_dlog(avctx, "flags %x\n", flags);
 +
 +    if (flags & 2) {
 +        if(buf + data_size - ptr < 64) {
 +            av_log(avctx, AV_LOG_ERROR, "Header truncated\n");
 +            return AVERROR_INVALIDDATA;
 +        }
 +        permute(ctx->qmat_luma, ctx->prodsp.idct_permutation, ptr);
 +        ptr += 64;
 +    } else {
 +        memset(ctx->qmat_luma, 4, 64);
 +    }
 +
 +    if (flags & 1) {
 +        if(buf + data_size - ptr < 64) {
 +            av_log(avctx, AV_LOG_ERROR, "Header truncated\n");
 +            return AVERROR_INVALIDDATA;
 +        }
 +        permute(ctx->qmat_chroma, ctx->prodsp.idct_permutation, ptr);
 +    } else {
 +        memset(ctx->qmat_chroma, 4, 64);
 +    }
 +
 +    return hdr_size;
 +}
 +
 +static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, const int buf_size)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    int i, hdr_size, slice_count;
 +    unsigned pic_data_size;
 +    int log2_slice_mb_width, log2_slice_mb_height;
 +    int slice_mb_count, mb_x, mb_y;
 +    const uint8_t *data_ptr, *index_ptr;
 +
 +    hdr_size = buf[0] >> 3;
 +    if (hdr_size < 8 || hdr_size > buf_size) {
 +        av_log(avctx, AV_LOG_ERROR, "error, wrong picture header size\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    pic_data_size = AV_RB32(buf + 1);
 +    if (pic_data_size > buf_size) {
 +        av_log(avctx, AV_LOG_ERROR, "error, wrong picture data size\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    log2_slice_mb_width  = buf[7] >> 4;
 +    log2_slice_mb_height = buf[7] & 0xF;
 +    if (log2_slice_mb_width > 3 || log2_slice_mb_height) {
 +        av_log(avctx, AV_LOG_ERROR, "unsupported slice resolution: %dx%d\n",
 +               1 << log2_slice_mb_width, 1 << log2_slice_mb_height);
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    ctx->mb_width  = (avctx->width  + 15) >> 4;
 +    if (ctx->frame_type)
 +        ctx->mb_height = (avctx->height + 31) >> 5;
 +    else
 +        ctx->mb_height = (avctx->height + 15) >> 4;
 +
 +    slice_count = AV_RB16(buf + 5);
 +
 +    if (ctx->slice_count != slice_count || !ctx->slices) {
 +        av_freep(&ctx->slices);
 +        ctx->slices = av_mallocz_array(slice_count, sizeof(*ctx->slices));
 +        if (!ctx->slices)
 +            return AVERROR(ENOMEM);
 +        ctx->slice_count = slice_count;
 +    }
 +
 +    if (!slice_count)
 +        return AVERROR(EINVAL);
 +
 +    if (hdr_size + slice_count*2 > buf_size) {
 +        av_log(avctx, AV_LOG_ERROR, "error, wrong slice count\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    // parse slice information
 +    index_ptr = buf + hdr_size;
 +    data_ptr  = index_ptr + slice_count*2;
 +
 +    slice_mb_count = 1 << log2_slice_mb_width;
 +    mb_x = 0;
 +    mb_y = 0;
 +
 +    for (i = 0; i < slice_count; i++) {
 +        SliceContext *slice = &ctx->slices[i];
 +
 +        slice->data = data_ptr;
 +        data_ptr += AV_RB16(index_ptr + i*2);
 +
 +        while (ctx->mb_width - mb_x < slice_mb_count)
 +            slice_mb_count >>= 1;
 +
 +        slice->mb_x = mb_x;
 +        slice->mb_y = mb_y;
 +        slice->mb_count = slice_mb_count;
 +        slice->data_size = data_ptr - slice->data;
 +
 +        if (slice->data_size < 6) {
 +            av_log(avctx, AV_LOG_ERROR, "error, wrong slice data size\n");
 +            return AVERROR_INVALIDDATA;
 +        }
 +
 +        mb_x += slice_mb_count;
 +        if (mb_x == ctx->mb_width) {
 +            slice_mb_count = 1 << log2_slice_mb_width;
 +            mb_x = 0;
 +            mb_y++;
 +        }
 +        if (data_ptr > buf + buf_size) {
 +            av_log(avctx, AV_LOG_ERROR, "error, slice out of bounds\n");
 +            return AVERROR_INVALIDDATA;
 +        }
 +    }
 +
 +    if (mb_x || mb_y != ctx->mb_height) {
 +        av_log(avctx, AV_LOG_ERROR, "error wrong mb count y %d h %d\n",
 +               mb_y, ctx->mb_height);
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    return pic_data_size;
 +}
 +
 +#define DECODE_CODEWORD(val, codebook)                                  \
 +    do {                                                                \
 +        unsigned int rice_order, exp_order, switch_bits;                \
 +        unsigned int q, buf, bits;                                      \
 +                                                                        \
 +        UPDATE_CACHE(re, gb);                                           \
 +        buf = GET_CACHE(re, gb);                                        \
 +                                                                        \
 +        /* number of bits to switch between rice and exp golomb */      \
 +        switch_bits =  codebook & 3;                                    \
 +        rice_order  =  codebook >> 5;                                   \
 +        exp_order   = (codebook >> 2) & 7;                              \
 +                                                                        \
 +        q = 31 - av_log2(buf);                                          \
 +                                                                        \
 +        if (q > switch_bits) { /* exp golomb */                         \
 +            bits = exp_order - switch_bits + (q<<1);                    \
 +            val = SHOW_UBITS(re, gb, bits) - (1 << exp_order) +         \
 +                ((switch_bits + 1) << rice_order);                      \
 +            SKIP_BITS(re, gb, bits);                                    \
 +        } else if (rice_order) {                                        \
 +            SKIP_BITS(re, gb, q+1);                                     \
 +            val = (q << rice_order) + SHOW_UBITS(re, gb, rice_order);   \
 +            SKIP_BITS(re, gb, rice_order);                              \
 +        } else {                                                        \
 +            val = q;                                                    \
 +            SKIP_BITS(re, gb, q+1);                                     \
 +        }                                                               \
 +    } while (0)
 +
 +#define TOSIGNED(x) (((x) >> 1) ^ (-((x) & 1)))
 +
 +#define FIRST_DC_CB 0xB8
 +
 +static const uint8_t dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};
 +
 +static av_always_inline void decode_dc_coeffs(GetBitContext *gb, int16_t *out,
 +                                              int blocks_per_slice)
 +{
 +    int16_t prev_dc;
 +    int code, i, sign;
 +
 +    OPEN_READER(re, gb);
 +
 +    DECODE_CODEWORD(code, FIRST_DC_CB);
 +    prev_dc = TOSIGNED(code);
 +    out[0] = prev_dc;
 +
 +    out += 64; // dc coeff for the next block
 +
 +    code = 5;
 +    sign = 0;
 +    for (i = 1; i < blocks_per_slice; i++, out += 64) {
 +        DECODE_CODEWORD(code, dc_codebook[FFMIN(code, 6U)]);
 +        if(code) sign ^= -(code & 1);
 +        else     sign  = 0;
 +        prev_dc += (((code + 1) >> 1) ^ sign) - sign;
 +        out[0] = prev_dc;
 +    }
 +    CLOSE_READER(re, gb);
 +}
 +
 +// adaptive codebook switching lut according to previous run/level values
 +static const uint8_t run_to_cb[16] = { 0x06, 0x06, 0x05, 0x05, 0x04, 0x29, 0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x4C };
 +static const uint8_t lev_to_cb[10] = { 0x04, 0x0A, 0x05, 0x06, 0x04, 0x28, 0x28, 0x28, 0x28, 0x4C };
 +
 +static av_always_inline int decode_ac_coeffs(AVCodecContext *avctx, GetBitContext *gb,
 +                                             int16_t *out, int blocks_per_slice)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    int block_mask, sign;
 +    unsigned pos, run, level;
 +    int max_coeffs, i, bits_left;
 +    int log2_block_count = av_log2(blocks_per_slice);
 +
 +    OPEN_READER(re, gb);
 +    UPDATE_CACHE(re, gb);                                           \
 +    run   = 4;
 +    level = 2;
 +
 +    max_coeffs = 64 << log2_block_count;
 +    block_mask = blocks_per_slice - 1;
 +
 +    for (pos = block_mask;;) {
 +        bits_left = gb->size_in_bits - re_index;
 +        if (!bits_left || (bits_left < 32 && !SHOW_UBITS(re, gb, bits_left)))
 +            break;
 +
 +        DECODE_CODEWORD(run, run_to_cb[FFMIN(run,  15)]);
 +        pos += run + 1;
 +        if (pos >= max_coeffs) {
 +            av_log(avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", pos, max_coeffs);
 +            return AVERROR_INVALIDDATA;
 +        }
 +
 +        DECODE_CODEWORD(level, lev_to_cb[FFMIN(level, 9)]);
 +        level += 1;
 +
 +        i = pos >> log2_block_count;
 +
 +        sign = SHOW_SBITS(re, gb, 1);
 +        SKIP_BITS(re, gb, 1);
 +        out[((pos & block_mask) << 6) + ctx->scan[i]] = ((level ^ sign) - sign);
 +    }
 +
 +    CLOSE_READER(re, gb);
 +    return 0;
 +}
 +
 +static int decode_slice_luma(AVCodecContext *avctx, SliceContext *slice,
 +                             uint16_t *dst, int dst_stride,
 +                             const uint8_t *buf, unsigned buf_size,
 +                             const int16_t *qmat)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    LOCAL_ALIGNED_16(int16_t, blocks, [8*4*64]);
 +    int16_t *block;
 +    GetBitContext gb;
 +    int i, blocks_per_slice = slice->mb_count<<2;
 +    int ret;
 +
 +    for (i = 0; i < blocks_per_slice; i++)
-         ctx->dsp.clear_block(blocks+(i<<6));
++        ctx->bdsp.clear_block(blocks+(i<<6));
 +
 +    init_get_bits(&gb, buf, buf_size << 3);
 +
 +    decode_dc_coeffs(&gb, blocks, blocks_per_slice);
 +    if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0)
 +        return ret;
 +
 +    block = blocks;
 +    for (i = 0; i < slice->mb_count; i++) {
 +        ctx->prodsp.idct_put(dst, dst_stride, block+(0<<6), qmat);
 +        ctx->prodsp.idct_put(dst             +8, dst_stride, block+(1<<6), qmat);
 +        ctx->prodsp.idct_put(dst+4*dst_stride  , dst_stride, block+(2<<6), qmat);
 +        ctx->prodsp.idct_put(dst+4*dst_stride+8, dst_stride, block+(3<<6), qmat);
 +        block += 4*64;
 +        dst += 16;
 +    }
 +    return 0;
 +}
 +
 +static int decode_slice_chroma(AVCodecContext *avctx, SliceContext *slice,
 +                               uint16_t *dst, int dst_stride,
 +                               const uint8_t *buf, unsigned buf_size,
 +                               const int16_t *qmat, int log2_blocks_per_mb)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    LOCAL_ALIGNED_16(int16_t, blocks, [8*4*64]);
 +    int16_t *block;
 +    GetBitContext gb;
 +    int i, j, blocks_per_slice = slice->mb_count << log2_blocks_per_mb;
 +    int ret;
 +
 +    for (i = 0; i < blocks_per_slice; i++)
-         ctx->dsp.clear_block(blocks+(i<<6));
++        ctx->bdsp.clear_block(blocks+(i<<6));
 +
 +    init_get_bits(&gb, buf, buf_size << 3);
 +
 +    decode_dc_coeffs(&gb, blocks, blocks_per_slice);
 +    if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0)
 +        return ret;
 +
 +    block = blocks;
 +    for (i = 0; i < slice->mb_count; i++) {
 +        for (j = 0; j < log2_blocks_per_mb; j++) {
 +            ctx->prodsp.idct_put(dst,              dst_stride, block+(0<<6), qmat);
 +            ctx->prodsp.idct_put(dst+4*dst_stride, dst_stride, block+(1<<6), qmat);
 +            block += 2*64;
 +            dst += 8;
 +        }
 +    }
 +    return 0;
 +}
 +
 +static void unpack_alpha(GetBitContext *gb, uint16_t *dst, int num_coeffs,
 +                         const int num_bits)
 +{
 +    const int mask = (1 << num_bits) - 1;
 +    int i, idx, val, alpha_val;
 +
 +    idx       = 0;
 +    alpha_val = mask;
 +    do {
 +        do {
 +            if (get_bits1(gb)) {
 +                val = get_bits(gb, num_bits);
 +            } else {
 +                int sign;
 +                val  = get_bits(gb, num_bits == 16 ? 7 : 4);
 +                sign = val & 1;
 +                val  = (val + 2) >> 1;
 +                if (sign)
 +                    val = -val;
 +            }
 +            alpha_val = (alpha_val + val) & mask;
 +            if (num_bits == 16) {
 +                dst[idx++] = alpha_val >> 6;
 +            } else {
 +                dst[idx++] = (alpha_val << 2) | (alpha_val >> 6);
 +            }
 +            if (idx >= num_coeffs)
 +                break;
 +        } while (get_bits_left(gb)>0 && get_bits1(gb));
 +        val = get_bits(gb, 4);
 +        if (!val)
 +            val = get_bits(gb, 11);
 +        if (idx + val > num_coeffs)
 +            val = num_coeffs - idx;
 +        if (num_bits == 16) {
 +            for (i = 0; i < val; i++)
 +                dst[idx++] = alpha_val >> 6;
 +        } else {
 +            for (i = 0; i < val; i++)
 +                dst[idx++] = (alpha_val << 2) | (alpha_val >> 6);
 +
 +        }
 +    } while (idx < num_coeffs);
 +}
 +
 +/**
 + * Decode alpha slice plane.
 + */
 +static void decode_slice_alpha(ProresContext *ctx,
 +                               uint16_t *dst, int dst_stride,
 +                               const uint8_t *buf, int buf_size,
 +                               int blocks_per_slice)
 +{
 +    GetBitContext gb;
 +    int i;
 +    LOCAL_ALIGNED_16(int16_t, blocks, [8*4*64]);
 +    int16_t *block;
 +
 +    for (i = 0; i < blocks_per_slice<<2; i++)
++        ctx->bdsp.clear_block(blocks+(i<<6));
 +
 +    init_get_bits(&gb, buf, buf_size << 3);
 +
 +    if (ctx->alpha_info == 2) {
 +        unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 16);
 +    } else {
 +        unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 8);
 +    }
 +
 +    block = blocks;
 +    for (i = 0; i < 16; i++) {
 +        memcpy(dst, block, 16 * blocks_per_slice * sizeof(*dst));
 +        dst   += dst_stride >> 1;
 +        block += 16 * blocks_per_slice;
 +    }
 +}
 +
 +static int decode_slice_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    SliceContext *slice = &ctx->slices[jobnr];
 +    const uint8_t *buf = slice->data;
 +    AVFrame *pic = ctx->frame;
 +    int i, hdr_size, qscale, log2_chroma_blocks_per_mb;
 +    int luma_stride, chroma_stride;
 +    int y_data_size, u_data_size, v_data_size, a_data_size;
 +    uint8_t *dest_y, *dest_u, *dest_v, *dest_a;
 +    int16_t qmat_luma_scaled[64];
 +    int16_t qmat_chroma_scaled[64];
 +    int mb_x_shift;
 +    int ret;
 +
 +    slice->ret = -1;
 +    //av_log(avctx, AV_LOG_INFO, "slice %d mb width %d mb x %d y %d\n",
 +    //       jobnr, slice->mb_count, slice->mb_x, slice->mb_y);
 +
 +    // slice header
 +    hdr_size = buf[0] >> 3;
 +    qscale = av_clip(buf[1], 1, 224);
 +    qscale = qscale > 128 ? qscale - 96 << 2: qscale;
 +    y_data_size = AV_RB16(buf + 2);
 +    u_data_size = AV_RB16(buf + 4);
 +    v_data_size = slice->data_size - y_data_size - u_data_size - hdr_size;
 +    if (hdr_size > 7) v_data_size = AV_RB16(buf + 6);
 +    a_data_size = slice->data_size - y_data_size - u_data_size -
 +                  v_data_size - hdr_size;
 +
 +    if (y_data_size < 0 || u_data_size < 0 || v_data_size < 0
 +        || hdr_size+y_data_size+u_data_size+v_data_size > slice->data_size){
 +        av_log(avctx, AV_LOG_ERROR, "invalid plane data size\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    buf += hdr_size;
 +
 +    for (i = 0; i < 64; i++) {
 +        qmat_luma_scaled  [i] = ctx->qmat_luma  [i] * qscale;
 +        qmat_chroma_scaled[i] = ctx->qmat_chroma[i] * qscale;
 +    }
 +
 +    if (ctx->frame_type == 0) {
 +        luma_stride   = pic->linesize[0];
 +        chroma_stride = pic->linesize[1];
 +    } else {
 +        luma_stride   = pic->linesize[0] << 1;
 +        chroma_stride = pic->linesize[1] << 1;
 +    }
 +
 +    if (avctx->pix_fmt == AV_PIX_FMT_YUV444P10 || avctx->pix_fmt == AV_PIX_FMT_YUVA444P10) {
 +        mb_x_shift = 5;
 +        log2_chroma_blocks_per_mb = 2;
 +    } else {
 +        mb_x_shift = 4;
 +        log2_chroma_blocks_per_mb = 1;
 +    }
 +
 +    dest_y = pic->data[0] + (slice->mb_y << 4) * luma_stride + (slice->mb_x << 5);
 +    dest_u = pic->data[1] + (slice->mb_y << 4) * chroma_stride + (slice->mb_x << mb_x_shift);
 +    dest_v = pic->data[2] + (slice->mb_y << 4) * chroma_stride + (slice->mb_x << mb_x_shift);
 +    dest_a = pic->data[3] + (slice->mb_y << 4) * luma_stride + (slice->mb_x << 5);
 +
 +    if (ctx->frame_type && ctx->first_field ^ ctx->frame->top_field_first) {
 +        dest_y += pic->linesize[0];
 +        dest_u += pic->linesize[1];
 +        dest_v += pic->linesize[2];
 +        dest_a += pic->linesize[3];
 +    }
 +
 +    ret = decode_slice_luma(avctx, slice, (uint16_t*)dest_y, luma_stride,
 +                            buf, y_data_size, qmat_luma_scaled);
 +    if (ret < 0)
 +        return ret;
 +
 +    if (!(avctx->flags & CODEC_FLAG_GRAY)) {
 +        ret = decode_slice_chroma(avctx, slice, (uint16_t*)dest_u, chroma_stride,
 +                                  buf + y_data_size, u_data_size,
 +                                  qmat_chroma_scaled, log2_chroma_blocks_per_mb);
 +        if (ret < 0)
 +            return ret;
 +
 +        ret = decode_slice_chroma(avctx, slice, (uint16_t*)dest_v, chroma_stride,
 +                                  buf + y_data_size + u_data_size, v_data_size,
 +                                  qmat_chroma_scaled, log2_chroma_blocks_per_mb);
 +        if (ret < 0)
 +            return ret;
 +    }
 +    /* decode alpha plane if available */
 +    if (ctx->alpha_info && pic->data[3] && a_data_size)
 +        decode_slice_alpha(ctx, (uint16_t*)dest_a, luma_stride,
 +                           buf + y_data_size + u_data_size + v_data_size,
 +                           a_data_size, slice->mb_count);
 +
 +    slice->ret = 0;
 +    return 0;
 +}
 +
 +static int decode_picture(AVCodecContext *avctx)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    int i;
 +
 +    avctx->execute2(avctx, decode_slice_thread, NULL, NULL, ctx->slice_count);
 +
 +    for (i = 0; i < ctx->slice_count; i++)
 +        if (ctx->slices[i].ret < 0)
 +            return ctx->slices[i].ret;
 +
 +    return 0;
 +}
 +
 +static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 +                        AVPacket *avpkt)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    AVFrame *frame = data;
 +    const uint8_t *buf = avpkt->data;
 +    int buf_size = avpkt->size;
 +    int frame_hdr_size, pic_size, ret;
 +
 +    if (buf_size < 28 || AV_RL32(buf + 4) != AV_RL32("icpf")) {
 +        av_log(avctx, AV_LOG_ERROR, "invalid frame header\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    ctx->frame = frame;
 +    ctx->frame->pict_type = AV_PICTURE_TYPE_I;
 +    ctx->frame->key_frame = 1;
 +    ctx->first_field = 1;
 +
 +    buf += 8;
 +    buf_size -= 8;
 +
 +    frame_hdr_size = decode_frame_header(ctx, buf, buf_size, avctx);
 +    if (frame_hdr_size < 0)
 +        return frame_hdr_size;
 +
 +    buf += frame_hdr_size;
 +    buf_size -= frame_hdr_size;
 +
 +    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
 +        return ret;
 +
 + decode_picture:
 +    pic_size = decode_picture_header(avctx, buf, buf_size);
 +    if (pic_size < 0) {
 +        av_log(avctx, AV_LOG_ERROR, "error decoding picture header\n");
 +        return pic_size;
 +    }
 +
 +    if ((ret = decode_picture(avctx)) < 0) {
 +        av_log(avctx, AV_LOG_ERROR, "error decoding picture\n");
 +        return ret;
 +    }
 +
 +    buf += pic_size;
 +    buf_size -= pic_size;
 +
 +    if (ctx->frame_type && buf_size > 0 && ctx->first_field) {
 +        ctx->first_field = 0;
 +        goto decode_picture;
 +    }
 +
 +    *got_frame      = 1;
 +
 +    return avpkt->size;
 +}
 +
 +static av_cold int decode_close(AVCodecContext *avctx)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +
 +    av_freep(&ctx->slices);
 +
 +    return 0;
 +}
 +
 +AVCodec ff_prores_decoder = {
 +    .name           = "prores",
 +    .long_name      = NULL_IF_CONFIG_SMALL("ProRes"),
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_PRORES,
 +    .priv_data_size = sizeof(ProresContext),
 +    .init           = decode_init,
 +    .close          = decode_close,
 +    .decode         = decode_frame,
 +    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
 +};
@@@ -5614,20 -5601,12 +5614,21 @@@ static av_cold int vc1_decode_init(AVCo
          avctx->pix_fmt = AV_PIX_FMT_GRAY8;
      v->s.avctx = avctx;
  
 -    if (ff_vc1_init_common(v) < 0)
 -        return -1;
 +    if ((ret = ff_vc1_init_common(v)) < 0)
 +        return ret;
 +    // ensure static VLC tables are initialized
 +    if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
 +        return ret;
 +    if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
 +        return ret;
 +    // Hack to ensure the above functions will be called
 +    // again once we know all necessary settings.
 +    // That this is necessary might indicate a bug.
 +    ff_vc1_decode_end(avctx);
 +
+     ff_blockdsp_init(&s->bdsp, avctx);
      ff_h264chroma_init(&v->h264chroma, 8);
      ff_qpeldsp_init(&s->qdsp);
 -    ff_vc1dsp_init(&v->vc1dsp);
  
      if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
          int count = 0;
Simple merge
Simple merge
@@@ -51,8 -43,8 +51,9 @@@ OBJS-$(CONFIG_VP6_DECODER)             
  OBJS-$(CONFIG_VP7_DECODER)             += x86/vp8dsp_init.o
  OBJS-$(CONFIG_VP8_DECODER)             += x86/vp8dsp_init.o
  OBJS-$(CONFIG_VP9_DECODER)             += x86/vp9dsp_init.o
 +OBJS-$(CONFIG_WEBP_DECODER)            += x86/vp8dsp_init.o
  
+ MMX-OBJS-$(CONFIG_BLOCKDSP)            += x86/blockdsp_mmx.o
  MMX-OBJS-$(CONFIG_DSPUTIL)             += x86/dsputil_mmx.o             \
                                            x86/idct_mmx_xvid.o           \
                                            x86/idct_sse2_xvid.o          \
index 0000000,b529424..53baad3
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,120 +1,61 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * FFmpeg is free software; you can redistribute it and/or
+  * modify it under the terms of the GNU Lesser General Public
+  * License as published by the Free Software Foundation; either
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
 -#if HAVE_INLINE_ASM
 -
 -#define CLEAR_BLOCKS(name, n)                           \
 -static void name(int16_t *blocks)                       \
 -{                                                       \
 -    __asm__ volatile (                                  \
 -        "pxor %%mm7, %%mm7              \n\t"           \
 -        "mov     %1,        %%"REG_a"   \n\t"           \
 -        "1:                             \n\t"           \
 -        "movq %%mm7,   (%0, %%"REG_a")  \n\t"           \
 -        "movq %%mm7,  8(%0, %%"REG_a")  \n\t"           \
 -        "movq %%mm7, 16(%0, %%"REG_a")  \n\t"           \
 -        "movq %%mm7, 24(%0, %%"REG_a")  \n\t"           \
 -        "add    $32, %%"REG_a"          \n\t"           \
 -        "js      1b                     \n\t"           \
 -        :: "r"(((uint8_t *) blocks) + 128 * n),         \
 -           "i"(-128 * n)                                \
 -        : "%"REG_a);                                    \
 -}
 -CLEAR_BLOCKS(clear_blocks_mmx, 6)
 -CLEAR_BLOCKS(clear_block_mmx, 1)
 -
 -static void clear_block_sse(int16_t *block)
 -{
 -    __asm__ volatile (
 -        "xorps  %%xmm0, %%xmm0          \n"
 -        "movaps %%xmm0,    (%0)         \n"
 -        "movaps %%xmm0,  16(%0)         \n"
 -        "movaps %%xmm0,  32(%0)         \n"
 -        "movaps %%xmm0,  48(%0)         \n"
 -        "movaps %%xmm0,  64(%0)         \n"
 -        "movaps %%xmm0,  80(%0)         \n"
 -        "movaps %%xmm0,  96(%0)         \n"
 -        "movaps %%xmm0, 112(%0)         \n"
 -        :: "r" (block)
 -        : "memory");
 -}
 -
 -static void clear_blocks_sse(int16_t *blocks)
 -{
 -    __asm__ volatile (
 -        "xorps  %%xmm0, %%xmm0              \n"
 -        "mov        %1,         %%"REG_a"   \n"
 -        "1:                                 \n"
 -        "movaps %%xmm0,    (%0, %%"REG_a")  \n"
 -        "movaps %%xmm0,  16(%0, %%"REG_a")  \n"
 -        "movaps %%xmm0,  32(%0, %%"REG_a")  \n"
 -        "movaps %%xmm0,  48(%0, %%"REG_a")  \n"
 -        "movaps %%xmm0,  64(%0, %%"REG_a")  \n"
 -        "movaps %%xmm0,  80(%0, %%"REG_a")  \n"
 -        "movaps %%xmm0,  96(%0, %%"REG_a")  \n"
 -        "movaps %%xmm0, 112(%0, %%"REG_a")  \n"
 -        "add      $128,         %%"REG_a"   \n"
 -        "js         1b                      \n"
 -        :: "r"(((uint8_t *) blocks) + 128 * 6), "i"(-128 * 6)
 -        : "%"REG_a);
 -}
 -
 -#endif /* HAVE_INLINE_ASM */
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #include <stdint.h>
+ #include "config.h"
+ #include "libavutil/attributes.h"
+ #include "libavutil/internal.h"
+ #include "libavutil/cpu.h"
+ #include "libavutil/x86/asm.h"
+ #include "libavutil/x86/cpu.h"
+ #include "libavcodec/blockdsp.h"
+ #include "libavcodec/version.h"
 -#if HAVE_INLINE_ASM
++void ff_clear_block_mmx(int16_t *block);
++void ff_clear_block_sse(int16_t *block);
++void ff_clear_blocks_mmx(int16_t *blocks);
++void ff_clear_blocks_sse(int16_t *blocks);
+ #if FF_API_XVMC
+ av_cold void ff_blockdsp_init_x86(BlockDSPContext *c, unsigned high_bit_depth,
+                                   AVCodecContext *avctx)
+ #else
+ av_cold void ff_blockdsp_init_x86(BlockDSPContext *c, unsigned high_bit_depth)
+ #endif /* FF_API_XVMC */
+ {
 -            c->clear_block  = clear_block_mmx;
 -            c->clear_blocks = clear_blocks_mmx;
++#if HAVE_YASM
+     int cpu_flags = av_get_cpu_flags();
+     if (!high_bit_depth) {
+         if (INLINE_MMX(cpu_flags)) {
 -#if FF_API_XVMC
 -FF_DISABLE_DEPRECATION_WARNINGS
++            c->clear_block  = ff_clear_block_mmx;
++            c->clear_blocks = ff_clear_blocks_mmx;
+         }
 -    if (CONFIG_MPEG_XVMC_DECODER && avctx->xvmc_acceleration > 1)
+     /* XvMCCreateBlocks() may not allocate 16-byte aligned blocks */
 -FF_ENABLE_DEPRECATION_WARNINGS
 -#endif /* FF_API_XVMC */
++    if (CONFIG_XVMC && avctx->hwaccel && avctx->hwaccel->decode_mb)
+         return;
 -            c->clear_block  = clear_block_sse;
 -            c->clear_blocks = clear_blocks_sse;
+         if (INLINE_SSE(cpu_flags)) {
 -#endif /* HAVE_INLINE_ASM */
++            c->clear_block  = ff_clear_block_sse;
++            c->clear_blocks = ff_clear_blocks_sse;
+         }
+     }
++#endif /* HAVE_YASM */
+ }
@@@ -82,12 -74,7 +80,8 @@@ static av_cold void dsputil_init_mmx(DS
  #endif /* HAVE_MMX_INLINE */
  
  #if HAVE_MMX_EXTERNAL
-     if (!high_bit_depth) {
-         c->clear_block  = ff_clear_block_mmx;
-         c->clear_blocks = ff_clear_blocks_mmx;
-     }
      c->vector_clip_int32 = ff_vector_clip_int32_mmx;
 +    c->put_signed_pixels_clamped = ff_put_signed_pixels_clamped_mmx;
  #endif /* HAVE_MMX_EXTERNAL */
  }
  
@@@ -110,23 -97,9 +104,14 @@@ static av_cold void dsputil_init_mmxext
  static av_cold void dsputil_init_sse(DSPContext *c, AVCodecContext *avctx,
                                       int cpu_flags, unsigned high_bit_depth)
  {
 -#if HAVE_SSE_INLINE
 +#if HAVE_YASM
 +#if HAVE_SSE_EXTERNAL
      c->vector_clipf = ff_vector_clipf_sse;
-     /* XvMCCreateBlocks() may not allocate 16-byte aligned blocks */
-     if (CONFIG_XVMC && avctx->hwaccel && avctx->hwaccel->decode_mb)
-         return;
-     if (!high_bit_depth) {
-         c->clear_block  = ff_clear_block_sse;
-         c->clear_blocks = ff_clear_blocks_sse;
-     }
 -#endif /* HAVE_SSE_INLINE */
 +#endif
 +#if HAVE_INLINE_ASM && CONFIG_VIDEODSP
 +    c->gmc = ff_gmc_sse;
 +#endif
 +#endif /* HAVE_YASM */
  }
  
  static av_cold void dsputil_init_sse2(DSPContext *c, AVCodecContext *avctx,
Simple merge
@@@ -37,14 -37,7 +37,9 @@@ void ff_put_pixels_clamped_mmx(const in
                                 int line_size);
  void ff_put_signed_pixels_clamped_mmx(const int16_t *block, uint8_t *pixels,
                                        int line_size);
 +void ff_put_signed_pixels_clamped_sse2(const int16_t *block, uint8_t *pixels,
 +                                       int line_size);
  
- void ff_clear_block_mmx(int16_t *block);
- void ff_clear_block_sse(int16_t *block);
- void ff_clear_blocks_mmx(int16_t *blocks);
- void ff_clear_blocks_sse(int16_t *blocks);
  void ff_draw_edges_mmx(uint8_t *buf, int wrap, int width, int height,
                         int w, int h, int sides);