Merge commit '95c0cec03acec0a80cc1c7db48f3b2355d9e767b'
authorMichael Niedermayer <michaelni@gmx.at>
Wed, 3 Sep 2014 01:18:07 +0000 (03:18 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 3 Sep 2014 01:19:40 +0000 (03:19 +0200)
* commit '95c0cec03acec0a80cc1c7db48f3b2355d9e767b':
  idctdsp: Add global function pointers for {add|put}_pixels_clamped functions

Conflicts:
libavcodec/arm/idctdsp_init_arm.c
libavcodec/dct.h
libavcodec/idctdsp.c
libavcodec/jrevdct.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/arm/idctdsp_init_arm.c
libavcodec/dct.h
libavcodec/idctdsp.c
libavcodec/idctdsp.h
libavcodec/jrevdct.c
libavcodec/x86/simple_idct.c

@@@ -67,11 -63,8 +63,8 @@@ av_cold void ff_idctdsp_init_arm(IDCTDS
  {
      int cpu_flags = av_get_cpu_flags();
  
-     put_pixels_clamped = c->put_pixels_clamped;
-     add_pixels_clamped = c->add_pixels_clamped;
 -    if (!high_bit_depth) {
 -        if (avctx->idct_algo == FF_IDCT_AUTO ||
 +    if (!avctx->lowres && !high_bit_depth) {
 +        if ((avctx->idct_algo == FF_IDCT_AUTO && !(avctx->flags & CODEC_FLAG_BITEXACT)) ||
              avctx->idct_algo == FF_IDCT_ARM) {
              c->idct_put  = j_rev_dct_arm_put;
              c->idct_add  = j_rev_dct_arm_add;
@@@ -59,8 -59,7 +59,10 @@@ void ff_fdct248_islow_8(int16_t *data)
  void ff_fdct248_islow_10(int16_t *data);
  
  void ff_j_rev_dct(int16_t *data);
 +void ff_j_rev_dct4(int16_t *data);
 +void ff_j_rev_dct2(int16_t *data);
 +void ff_j_rev_dct1(int16_t *data);
+ void ff_jref_idct_put(uint8_t *dest, int line_size, int16_t *block);
+ void ff_jref_idct_add(uint8_t *dest, int line_size, int16_t *block);
  
  #endif /* AVCODEC_DCT_H */
@@@ -80,8 -79,11 +80,11 @@@ av_cold void ff_init_scantable_permutat
      }
  }
  
- void ff_put_pixels_clamped(const int16_t *block, uint8_t *av_restrict pixels,
-                            int line_size)
+ void (*ff_put_pixels_clamped)(const int16_t *block, uint8_t *pixels, int line_size);
+ void (*ff_add_pixels_clamped)(const int16_t *block, uint8_t *pixels, int line_size);
 -static void put_pixels_clamped_c(const int16_t *block, uint8_t *restrict pixels,
++static void put_pixels_clamped_c(const int16_t *block, uint8_t *av_restrict pixels,
+                                  int line_size)
  {
      int i;
  
@@@ -154,8 -124,8 +157,8 @@@ static void put_signed_pixels_clamped_c
      }
  }
  
- void ff_add_pixels_clamped(const int16_t *block, uint8_t *av_restrict pixels,
-                            int line_size)
 -static void add_pixels_clamped_c(const int16_t *block, uint8_t *restrict pixels,
++static void add_pixels_clamped_c(const int16_t *block, uint8_t *av_restrict pixels,
+                                  int line_size)
  {
      int i;
  
      }
  }
  
- static void jref_idct_put(uint8_t *dest, int line_size, int16_t *block)
- {
-     ff_j_rev_dct(block);
-     ff_put_pixels_clamped(block, dest, line_size);
- }
- static void jref_idct_add(uint8_t *dest, int line_size, int16_t *block)
- {
-     ff_j_rev_dct(block);
-     ff_add_pixels_clamped(block, dest, line_size);
- }
 +static void add_pixels_clamped4_c(const int16_t *block, uint8_t *av_restrict pixels,
 +                          int line_size)
 +{
 +    int i;
 +
 +    /* read the pixels */
 +    for(i=0;i<4;i++) {
 +        pixels[0] = av_clip_uint8(pixels[0] + block[0]);
 +        pixels[1] = av_clip_uint8(pixels[1] + block[1]);
 +        pixels[2] = av_clip_uint8(pixels[2] + block[2]);
 +        pixels[3] = av_clip_uint8(pixels[3] + block[3]);
 +        pixels += line_size;
 +        block += 8;
 +    }
 +}
 +
 +static void add_pixels_clamped2_c(const int16_t *block, uint8_t *av_restrict pixels,
 +                          int line_size)
 +{
 +    int i;
 +
 +    /* read the pixels */
 +    for(i=0;i<2;i++) {
 +        pixels[0] = av_clip_uint8(pixels[0] + block[0]);
 +        pixels[1] = av_clip_uint8(pixels[1] + block[1]);
 +        pixels += line_size;
 +        block += 8;
 +    }
 +}
 +
 +static void ff_jref_idct4_put(uint8_t *dest, int line_size, int16_t *block)
 +{
 +    ff_j_rev_dct4 (block);
 +    put_pixels_clamped4_c(block, dest, line_size);
 +}
 +static void ff_jref_idct4_add(uint8_t *dest, int line_size, int16_t *block)
 +{
 +    ff_j_rev_dct4 (block);
 +    add_pixels_clamped4_c(block, dest, line_size);
 +}
 +
 +static void ff_jref_idct2_put(uint8_t *dest, int line_size, int16_t *block)
 +{
 +    ff_j_rev_dct2 (block);
 +    put_pixels_clamped2_c(block, dest, line_size);
 +}
 +static void ff_jref_idct2_add(uint8_t *dest, int line_size, int16_t *block)
 +{
 +    ff_j_rev_dct2 (block);
 +    add_pixels_clamped2_c(block, dest, line_size);
 +}
 +
 +static void ff_jref_idct1_put(uint8_t *dest, int line_size, int16_t *block)
 +{
 +    dest[0] = av_clip_uint8((block[0] + 4)>>3);
 +}
 +static void ff_jref_idct1_add(uint8_t *dest, int line_size, int16_t *block)
 +{
 +    dest[0] = av_clip_uint8(dest[0] + ((block[0] + 4)>>3));
 +}
 +
  av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
  {
      const unsigned high_bit_depth = avctx->bits_per_raw_sample > 8;
  
 -    if (avctx->bits_per_raw_sample == 10) {
 -        c->idct_put  = ff_simple_idct_put_10;
 -        c->idct_add  = ff_simple_idct_add_10;
 -        c->idct      = ff_simple_idct_10;
 +    if (avctx->lowres==1) {
 +        c->idct_put  = ff_jref_idct4_put;
 +        c->idct_add  = ff_jref_idct4_add;
 +        c->idct      = ff_j_rev_dct4;
          c->perm_type = FF_IDCT_PERM_NONE;
 -    } else if (avctx->idct_algo == FF_IDCT_INT) {
 -        c->idct_put  = ff_jref_idct_put;
 -        c->idct_add  = ff_jref_idct_add;
 -        c->idct      = ff_j_rev_dct;
 -        c->perm_type = FF_IDCT_PERM_LIBMPEG2;
 -    } else if (avctx->idct_algo == FF_IDCT_FAAN) {
 -        c->idct_put  = ff_faanidct_put;
 -        c->idct_add  = ff_faanidct_add;
 -        c->idct      = ff_faanidct;
 +    } else if (avctx->lowres==2) {
 +        c->idct_put  = ff_jref_idct2_put;
 +        c->idct_add  = ff_jref_idct2_add;
 +        c->idct      = ff_j_rev_dct2;
          c->perm_type = FF_IDCT_PERM_NONE;
 -    } else { // accurate/default
 -        c->idct_put  = ff_simple_idct_put_8;
 -        c->idct_add  = ff_simple_idct_add_8;
 -        c->idct      = ff_simple_idct_8;
 +    } else if (avctx->lowres==3) {
 +        c->idct_put  = ff_jref_idct1_put;
 +        c->idct_add  = ff_jref_idct1_add;
 +        c->idct      = ff_j_rev_dct1;
          c->perm_type = FF_IDCT_PERM_NONE;
-                 c->idct_put  = jref_idct_put;
-                 c->idct_add  = jref_idct_add;
 +    } else {
 +        if (avctx->bits_per_raw_sample == 10) {
 +            c->idct_put              = ff_simple_idct_put_10;
 +            c->idct_add              = ff_simple_idct_add_10;
 +            c->idct                  = ff_simple_idct_10;
 +            c->perm_type             = FF_IDCT_PERM_NONE;
 +        } else if (avctx->bits_per_raw_sample == 12) {
 +            c->idct_put              = ff_simple_idct_put_12;
 +            c->idct_add              = ff_simple_idct_add_12;
 +            c->idct                  = ff_simple_idct_12;
 +            c->perm_type             = FF_IDCT_PERM_NONE;
 +        } else {
 +            if (avctx->idct_algo == FF_IDCT_INT) {
++                c->idct_put  = ff_jref_idct_put;
++                c->idct_add  = ff_jref_idct_add;
 +                c->idct      = ff_j_rev_dct;
 +                c->perm_type = FF_IDCT_PERM_LIBMPEG2;
 +            } else if (avctx->idct_algo == FF_IDCT_FAAN) {
 +                c->idct_put  = ff_faanidct_put;
 +                c->idct_add  = ff_faanidct_add;
 +                c->idct      = ff_faanidct;
 +                c->perm_type = FF_IDCT_PERM_NONE;
 +            } else { // accurate/default
 +                c->idct_put  = ff_simple_idct_put_8;
 +                c->idct_add  = ff_simple_idct_add_8;
 +                c->idct      = ff_simple_idct_8;
 +                c->perm_type = FF_IDCT_PERM_NONE;
 +            }
 +        }
      }
  
-     c->put_pixels_clamped        = ff_put_pixels_clamped;
+     c->put_pixels_clamped        = put_pixels_clamped_c;
      c->put_signed_pixels_clamped = put_signed_pixels_clamped_c;
-     c->add_pixels_clamped        = ff_add_pixels_clamped;
+     c->add_pixels_clamped        = add_pixels_clamped_c;
+     ff_put_pixels_clamped = c->put_pixels_clamped;
+     ff_add_pixels_clamped = c->add_pixels_clamped;
  
 +    if (CONFIG_MPEG4_DECODER && avctx->idct_algo == FF_IDCT_XVID)
 +        ff_xvid_idct_init(c, avctx);
 +
 +    if (ARCH_ALPHA)
 +        ff_idctdsp_init_alpha(c, avctx, high_bit_depth);
      if (ARCH_ARM)
          ff_idctdsp_init_arm(c, avctx, high_bit_depth);
      if (ARCH_PPC)
@@@ -100,10 -95,11 +95,13 @@@ typedef struct IDCTDSPContext 
      enum idct_permutation_type perm_type;
  } IDCTDSPContext;
  
+ extern void (*ff_put_pixels_clamped)(const int16_t *block, uint8_t *pixels, int line_size);
+ extern void (*ff_add_pixels_clamped)(const int16_t *block, uint8_t *pixels, int line_size);
  void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx);
  
 +void ff_idctdsp_init_alpha(IDCTDSPContext *c, AVCodecContext *avctx,
 +                           unsigned high_bit_depth);
  void ff_idctdsp_init_arm(IDCTDSPContext *c, AVCodecContext *avctx,
                           unsigned high_bit_depth);
  void ff_idctdsp_init_ppc(IDCTDSPContext *c, AVCodecContext *avctx,
@@@ -941,215 -943,14 +943,227 @@@ void ff_j_rev_dct(DCTBLOCK data
    }
  }
  
 +#undef DCTSIZE
 +#define DCTSIZE 4
 +#define DCTSTRIDE 8
 +
 +void ff_j_rev_dct4(DCTBLOCK data)
 +{
 +  int32_t tmp0, tmp1, tmp2, tmp3;
 +  int32_t tmp10, tmp11, tmp12, tmp13;
 +  int32_t z1;
 +  int32_t d0, d2, d4, d6;
 +  register int16_t *dataptr;
 +  int rowctr;
 +
 +  /* Pass 1: process rows. */
 +  /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
 +  /* furthermore, we scale the results by 2**PASS1_BITS. */
 +
 +  data[0] += 4;
 +
 +  dataptr = data;
 +
 +  for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) {
 +    /* Due to quantization, we will usually find that many of the input
 +     * coefficients are zero, especially the AC terms.  We can exploit this
 +     * by short-circuiting the IDCT calculation for any row in which all
 +     * the AC terms are zero.  In that case each output is equal to the
 +     * DC coefficient (with scale factor as needed).
 +     * With typical images and quantization tables, half or more of the
 +     * row DCT calculations can be simplified this way.
 +     */
 +
 +    register int *idataptr = (int*)dataptr;
 +
 +    d0 = dataptr[0];
 +    d2 = dataptr[1];
 +    d4 = dataptr[2];
 +    d6 = dataptr[3];
 +
 +    if ((d2 | d4 | d6) == 0) {
 +      /* AC terms all zero */
 +      if (d0) {
 +          /* Compute a 32 bit value to assign. */
 +          int16_t dcval = (int16_t) (d0 << PASS1_BITS);
 +          register int v = (dcval & 0xffff) | ((dcval << 16) & 0xffff0000);
 +
 +          idataptr[0] = v;
 +          idataptr[1] = v;
 +      }
 +
 +      dataptr += DCTSTRIDE;     /* advance pointer to next row */
 +      continue;
 +    }
 +
 +    /* Even part: reverse the even part of the forward DCT. */
 +    /* The rotator is sqrt(2)*c(-6). */
 +    if (d6) {
 +            if (d2) {
 +                    /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
 +                    z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
 +                    tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
 +                    tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
 +
 +                    tmp0 = (d0 + d4) << CONST_BITS;
 +                    tmp1 = (d0 - d4) << CONST_BITS;
 +
 +                    tmp10 = tmp0 + tmp3;
 +                    tmp13 = tmp0 - tmp3;
 +                    tmp11 = tmp1 + tmp2;
 +                    tmp12 = tmp1 - tmp2;
 +            } else {
 +                    /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
 +                    tmp2 = MULTIPLY(-d6, FIX_1_306562965);
 +                    tmp3 = MULTIPLY(d6, FIX_0_541196100);
 +
 +                    tmp0 = (d0 + d4) << CONST_BITS;
 +                    tmp1 = (d0 - d4) << CONST_BITS;
 +
 +                    tmp10 = tmp0 + tmp3;
 +                    tmp13 = tmp0 - tmp3;
 +                    tmp11 = tmp1 + tmp2;
 +                    tmp12 = tmp1 - tmp2;
 +            }
 +    } else {
 +            if (d2) {
 +                    /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
 +                    tmp2 = MULTIPLY(d2, FIX_0_541196100);
 +                    tmp3 = MULTIPLY(d2, FIX_1_306562965);
 +
 +                    tmp0 = (d0 + d4) << CONST_BITS;
 +                    tmp1 = (d0 - d4) << CONST_BITS;
 +
 +                    tmp10 = tmp0 + tmp3;
 +                    tmp13 = tmp0 - tmp3;
 +                    tmp11 = tmp1 + tmp2;
 +                    tmp12 = tmp1 - tmp2;
 +            } else {
 +                    /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
 +                    tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
 +                    tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
 +            }
 +      }
 +
 +    /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
 +
 +    dataptr[0] = (int16_t) DESCALE(tmp10, CONST_BITS-PASS1_BITS);
 +    dataptr[1] = (int16_t) DESCALE(tmp11, CONST_BITS-PASS1_BITS);
 +    dataptr[2] = (int16_t) DESCALE(tmp12, CONST_BITS-PASS1_BITS);
 +    dataptr[3] = (int16_t) DESCALE(tmp13, CONST_BITS-PASS1_BITS);
 +
 +    dataptr += DCTSTRIDE;       /* advance pointer to next row */
 +  }
 +
 +  /* Pass 2: process columns. */
 +  /* Note that we must descale the results by a factor of 8 == 2**3, */
 +  /* and also undo the PASS1_BITS scaling. */
 +
 +  dataptr = data;
 +  for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) {
 +    /* Columns of zeroes can be exploited in the same way as we did with rows.
 +     * However, the row calculation has created many nonzero AC terms, so the
 +     * simplification applies less often (typically 5% to 10% of the time).
 +     * On machines with very fast multiplication, it's possible that the
 +     * test takes more time than it's worth.  In that case this section
 +     * may be commented out.
 +     */
 +
 +    d0 = dataptr[DCTSTRIDE*0];
 +    d2 = dataptr[DCTSTRIDE*1];
 +    d4 = dataptr[DCTSTRIDE*2];
 +    d6 = dataptr[DCTSTRIDE*3];
 +
 +    /* Even part: reverse the even part of the forward DCT. */
 +    /* The rotator is sqrt(2)*c(-6). */
 +    if (d6) {
 +            if (d2) {
 +                    /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
 +                    z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
 +                    tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
 +                    tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
 +
 +                    tmp0 = (d0 + d4) << CONST_BITS;
 +                    tmp1 = (d0 - d4) << CONST_BITS;
 +
 +                    tmp10 = tmp0 + tmp3;
 +                    tmp13 = tmp0 - tmp3;
 +                    tmp11 = tmp1 + tmp2;
 +                    tmp12 = tmp1 - tmp2;
 +            } else {
 +                    /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
 +                    tmp2 = MULTIPLY(-d6, FIX_1_306562965);
 +                    tmp3 = MULTIPLY(d6, FIX_0_541196100);
 +
 +                    tmp0 = (d0 + d4) << CONST_BITS;
 +                    tmp1 = (d0 - d4) << CONST_BITS;
 +
 +                    tmp10 = tmp0 + tmp3;
 +                    tmp13 = tmp0 - tmp3;
 +                    tmp11 = tmp1 + tmp2;
 +                    tmp12 = tmp1 - tmp2;
 +            }
 +    } else {
 +            if (d2) {
 +                    /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
 +                    tmp2 = MULTIPLY(d2, FIX_0_541196100);
 +                    tmp3 = MULTIPLY(d2, FIX_1_306562965);
 +
 +                    tmp0 = (d0 + d4) << CONST_BITS;
 +                    tmp1 = (d0 - d4) << CONST_BITS;
 +
 +                    tmp10 = tmp0 + tmp3;
 +                    tmp13 = tmp0 - tmp3;
 +                    tmp11 = tmp1 + tmp2;
 +                    tmp12 = tmp1 - tmp2;
 +            } else {
 +                    /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
 +                    tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
 +                    tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
 +            }
 +    }
 +
 +    /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
 +
 +    dataptr[DCTSTRIDE*0] = tmp10 >> (CONST_BITS+PASS1_BITS+3);
 +    dataptr[DCTSTRIDE*1] = tmp11 >> (CONST_BITS+PASS1_BITS+3);
 +    dataptr[DCTSTRIDE*2] = tmp12 >> (CONST_BITS+PASS1_BITS+3);
 +    dataptr[DCTSTRIDE*3] = tmp13 >> (CONST_BITS+PASS1_BITS+3);
 +
 +    dataptr++;                  /* advance pointer to next column */
 +  }
 +}
 +
 +void ff_j_rev_dct2(DCTBLOCK data){
 +  int d00, d01, d10, d11;
 +
 +  data[0] += 4;
 +  d00 = data[0+0*DCTSTRIDE] + data[1+0*DCTSTRIDE];
 +  d01 = data[0+0*DCTSTRIDE] - data[1+0*DCTSTRIDE];
 +  d10 = data[0+1*DCTSTRIDE] + data[1+1*DCTSTRIDE];
 +  d11 = data[0+1*DCTSTRIDE] - data[1+1*DCTSTRIDE];
 +
 +  data[0+0*DCTSTRIDE]= (d00 + d10)>>3;
 +  data[1+0*DCTSTRIDE]= (d01 + d11)>>3;
 +  data[0+1*DCTSTRIDE]= (d00 - d10)>>3;
 +  data[1+1*DCTSTRIDE]= (d01 - d11)>>3;
 +}
 +
 +void ff_j_rev_dct1(DCTBLOCK data){
 +  data[0] = (data[0] + 4)>>3;
 +}
 +
 +#undef FIX
 +#undef CONST_BITS
++
+ void ff_jref_idct_put(uint8_t *dest, int line_size, int16_t *block)
+ {
+     ff_j_rev_dct(block);
+     ff_put_pixels_clamped(block, dest, line_size);
+ }
+ void ff_jref_idct_add(uint8_t *dest, int line_size, int16_t *block)
+ {
+     ff_j_rev_dct(block);
+     ff_add_pixels_clamped(block, dest, line_size);
+ }
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
 -#include "libavutil/internal.h"
  #include "libavutil/mem.h"
  #include "libavutil/x86/asm.h"
+ #include "libavcodec/idctdsp.h"
  #include "idctdsp.h"
  #include "simple_idct.h"