libvpx: Pull from upstream

source/libvpx/vpx_dsp/x86/inv_txfm_sse2.c

 /*
  *  Copyright (c) 2015 The WebM project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include "./vpx_dsp_rtcd.h"
 #include "vpx_dsp/x86/inv_txfm_sse2.h"
 #include "vpx_dsp/x86/txfm_common_sse2.h"
 
 #define RECON_AND_STORE4X4(dest, in_x) \
 {                                                     \
   __m128i d0 = _mm_cvtsi32_si128(*(const int *)(dest)); \
   d0 = _mm_unpacklo_epi8(d0, zero); \
   d0 = _mm_add_epi16(in_x, d0); \
   d0 = _mm_packus_epi16(d0, d0); \
   *(int *)(dest) = _mm_cvtsi128_si32(d0); \
 }
 
-void vp9_idct4x4_16_add_sse2(const int16_t *input, uint8_t *dest, int stride) {
+void vpx_idct4x4_16_add_sse2(const int16_t *input, uint8_t *dest, int stride) {
   const __m128i zero = _mm_setzero_si128();
   const __m128i eight = _mm_set1_epi16(8);
   const __m128i cst = _mm_setr_epi16(
       (int16_t)cospi_16_64, (int16_t)cospi_16_64, (int16_t)cospi_16_64,
       (int16_t)-cospi_16_64, (int16_t)cospi_24_64, (int16_t)-cospi_8_64,
       (int16_t)cospi_8_64, (int16_t)cospi_24_64);
   const __m128i rounding = _mm_set1_epi32(DCT_CONST_ROUNDING);
   __m128i input0, input1, input2, input3;
 
   // Rows
@@ skipping 109 matching lines @@
     *(int *)(dest + stride) = _mm_cvtsi128_si32(d0);
     // store input2
     d0 = _mm_srli_si128(d0, 4);
     *(int *)(dest + stride * 3) = _mm_cvtsi128_si32(d0);
     // store input3
     d0 = _mm_srli_si128(d0, 4);
     *(int *)(dest + stride * 2) = _mm_cvtsi128_si32(d0);
   }
 }
 
-void vp9_idct4x4_1_add_sse2(const int16_t *input, uint8_t *dest, int stride) {
+void vpx_idct4x4_1_add_sse2(const int16_t *input, uint8_t *dest, int stride) {
   __m128i dc_value;
   const __m128i zero = _mm_setzero_si128();
   int a;
 
   a = dct_const_round_shift(input[0] * cospi_16_64);
   a = dct_const_round_shift(a * cospi_16_64);
   a = ROUND_POWER_OF_TWO(a, 4);
 
   dc_value = _mm_set1_epi16(a);
 
@@ skipping 277 matching lines @@
   out0 = _mm_adds_epi16(stp1_0, stp2_7); \
   out1 = _mm_adds_epi16(stp1_1, stp1_6); \
   out2 = _mm_adds_epi16(stp1_2, stp1_5); \
   out3 = _mm_adds_epi16(stp1_3, stp2_4); \
   out4 = _mm_subs_epi16(stp1_3, stp2_4); \
   out5 = _mm_subs_epi16(stp1_2, stp1_5); \
   out6 = _mm_subs_epi16(stp1_1, stp1_6); \
   out7 = _mm_subs_epi16(stp1_0, stp2_7); \
   }
 
-void vp9_idct8x8_64_add_sse2(const int16_t *input, uint8_t *dest, int stride) {
+void vpx_idct8x8_64_add_sse2(const int16_t *input, uint8_t *dest, int stride) {
   const __m128i zero = _mm_setzero_si128();
   const __m128i rounding = _mm_set1_epi32(DCT_CONST_ROUNDING);
   const __m128i final_rounding = _mm_set1_epi16(1 << 4);
   const __m128i stg1_0 = pair_set_epi16(cospi_28_64, -cospi_4_64);
   const __m128i stg1_1 = pair_set_epi16(cospi_4_64, cospi_28_64);
   const __m128i stg1_2 = pair_set_epi16(-cospi_20_64, cospi_12_64);
   const __m128i stg1_3 = pair_set_epi16(cospi_12_64, cospi_20_64);
   const __m128i stg2_0 = pair_set_epi16(cospi_16_64, cospi_16_64);
   const __m128i stg2_1 = pair_set_epi16(cospi_16_64, -cospi_16_64);
   const __m128i stg2_2 = pair_set_epi16(cospi_24_64, -cospi_8_64);
@@ skipping 10 matching lines @@
   in1 = _mm_load_si128((const __m128i *)(input + 8 * 1));
   in2 = _mm_load_si128((const __m128i *)(input + 8 * 2));
   in3 = _mm_load_si128((const __m128i *)(input + 8 * 3));
   in4 = _mm_load_si128((const __m128i *)(input + 8 * 4));
   in5 = _mm_load_si128((const __m128i *)(input + 8 * 5));
   in6 = _mm_load_si128((const __m128i *)(input + 8 * 6));
   in7 = _mm_load_si128((const __m128i *)(input + 8 * 7));
 
   // 2-D
   for (i = 0; i < 2; i++) {
-    // 8x8 Transpose is copied from vp9_fdct8x8_sse2()
+    // 8x8 Transpose is copied from vpx_fdct8x8_sse2()
     TRANSPOSE_8X8(in0, in1, in2, in3, in4, in5, in6, in7,
                   in0, in1, in2, in3, in4, in5, in6, in7);
 
     // 4-stage 1D idct8x8
     IDCT8(in0, in1, in2, in3, in4, in5, in6, in7,
           in0, in1, in2, in3, in4, in5, in6, in7);
   }
 
   // Final rounding and shift
   in0 = _mm_adds_epi16(in0, final_rounding);
@@ skipping 17 matching lines @@
   RECON_AND_STORE(dest + 0 * stride, in0);
   RECON_AND_STORE(dest + 1 * stride, in1);
   RECON_AND_STORE(dest + 2 * stride, in2);
   RECON_AND_STORE(dest + 3 * stride, in3);
   RECON_AND_STORE(dest + 4 * stride, in4);
   RECON_AND_STORE(dest + 5 * stride, in5);
   RECON_AND_STORE(dest + 6 * stride, in6);
   RECON_AND_STORE(dest + 7 * stride, in7);
 }
 
-void vp9_idct8x8_1_add_sse2(const int16_t *input, uint8_t *dest, int stride) {
+void vpx_idct8x8_1_add_sse2(const int16_t *input, uint8_t *dest, int stride) {
   __m128i dc_value;
   const __m128i zero = _mm_setzero_si128();
   int a;
 
   a = dct_const_round_shift(input[0] * cospi_16_64);
   a = dct_const_round_shift(a * cospi_16_64);
   a = ROUND_POWER_OF_TWO(a, 5);
 
   dc_value = _mm_set1_epi16(a);
 
@@ skipping 16 matching lines @@
   const __m128i stg2_0 = pair_set_epi16(cospi_16_64, cospi_16_64);
   const __m128i stg2_1 = pair_set_epi16(cospi_16_64, -cospi_16_64);
   const __m128i stg2_2 = pair_set_epi16(cospi_24_64, -cospi_8_64);
   const __m128i stg2_3 = pair_set_epi16(cospi_8_64, cospi_24_64);
 
   __m128i in0, in1, in2, in3, in4, in5, in6, in7;
   __m128i stp1_0, stp1_1, stp1_2, stp1_3, stp1_4, stp1_5, stp1_6, stp1_7;
   __m128i stp2_0, stp2_1, stp2_2, stp2_3, stp2_4, stp2_5, stp2_6, stp2_7;
   __m128i tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
 
-  // 8x8 Transpose is copied from vp9_fdct8x8_sse2()
+  // 8x8 Transpose is copied from vpx_fdct8x8_sse2()
   TRANSPOSE_8X8(in[0], in[1], in[2], in[3], in[4], in[5], in[6], in[7],
                 in0, in1, in2, in3, in4, in5, in6, in7);
 
   // 4-stage 1D idct8x8
   IDCT8(in0, in1, in2, in3, in4, in5, in6, in7,
         in[0], in[1], in[2], in[3], in[4], in[5], in[6], in[7]);
 }
 
 void iadst8_sse2(__m128i *in) {
   const __m128i k__cospi_p02_p30 = pair_set_epi16(cospi_2_64, cospi_30_64);
@@ skipping 216 matching lines @@
   in[0] = s0;
   in[1] = _mm_sub_epi16(k__const_0, s4);
   in[2] = s6;
   in[3] = _mm_sub_epi16(k__const_0, s2);
   in[4] = s3;
   in[5] = _mm_sub_epi16(k__const_0, s7);
   in[6] = s5;
   in[7] = _mm_sub_epi16(k__const_0, s1);
 }
 
-void vp9_idct8x8_12_add_sse2(const int16_t *input, uint8_t *dest, int stride) {
+void vpx_idct8x8_12_add_sse2(const int16_t *input, uint8_t *dest, int stride) {
   const __m128i zero = _mm_setzero_si128();
   const __m128i rounding = _mm_set1_epi32(DCT_CONST_ROUNDING);
   const __m128i final_rounding = _mm_set1_epi16(1 << 4);
   const __m128i stg1_0 = pair_set_epi16(cospi_28_64, -cospi_4_64);
   const __m128i stg1_1 = pair_set_epi16(cospi_4_64, cospi_28_64);
   const __m128i stg1_2 = pair_set_epi16(-cospi_20_64, cospi_12_64);
   const __m128i stg1_3 = pair_set_epi16(cospi_12_64, cospi_20_64);
   const __m128i stg2_0 = pair_set_epi16(cospi_16_64, cospi_16_64);
   const __m128i stg2_1 = pair_set_epi16(cospi_16_64, -cospi_16_64);
   const __m128i stg2_2 = pair_set_epi16(cospi_24_64, -cospi_8_64);
@@ skipping 356 matching lines @@
       stp2_4 = _mm_sub_epi16(stp1_3, stp2_4); \
       stp2_5 = _mm_sub_epi16(stp1_2, stp1_5); \
       stp2_6 = _mm_sub_epi16(stp1_1, stp1_6); \
       stp2_7 = _mm_sub_epi16(stp1_0, stp2_7); \
       \
       MULTIPLICATION_AND_ADD(lo_10_13, hi_10_13, lo_11_12, hi_11_12, \
                              stg6_0, stg4_0, stg6_0, stg4_0, \
                              stp2_10, stp2_13, stp2_11, stp2_12) \
     }
 
-void vp9_idct16x16_256_add_sse2(const int16_t *input, uint8_t *dest,
+void vpx_idct16x16_256_add_sse2(const int16_t *input, uint8_t *dest,
                                 int stride) {
   const __m128i rounding = _mm_set1_epi32(DCT_CONST_ROUNDING);
   const __m128i final_rounding = _mm_set1_epi16(1 << 5);
   const __m128i zero = _mm_setzero_si128();
 
   const __m128i stg2_0 = pair_set_epi16(cospi_30_64, -cospi_2_64);
   const __m128i stg2_1 = pair_set_epi16(cospi_2_64, cospi_30_64);
   const __m128i stg2_2 = pair_set_epi16(cospi_14_64, -cospi_18_64);
   const __m128i stg2_3 = pair_set_epi16(cospi_18_64, cospi_14_64);
   const __m128i stg2_4 = pair_set_epi16(cospi_22_64, -cospi_10_64);
@@ skipping 104 matching lines @@
       // Final rounding and shift
       in[j] = _mm_adds_epi16(in[j], final_rounding);
       in[j] = _mm_srai_epi16(in[j], 6);
       RECON_AND_STORE(dest + j * stride, in[j]);
     }
 
     dest += 8;
   }
 }
 
-void vp9_idct16x16_1_add_sse2(const int16_t *input, uint8_t *dest, int stride) {
+void vpx_idct16x16_1_add_sse2(const int16_t *input, uint8_t *dest, int stride) {
   __m128i dc_value;
   const __m128i zero = _mm_setzero_si128();
   int a, i;
 
   a = dct_const_round_shift(input[0] * cospi_16_64);
   a = dct_const_round_shift(a * cospi_16_64);
   a = ROUND_POWER_OF_TWO(a, 6);
 
   dc_value = _mm_set1_epi16(a);
 
@@ skipping 837 matching lines @@
   idct16_8col(in0);
   idct16_8col(in1);
 }
 
 void iadst16_sse2(__m128i *in0, __m128i *in1) {
   array_transpose_16x16(in0, in1);
   iadst16_8col(in0);
   iadst16_8col(in1);
 }
 
-void vp9_idct16x16_10_add_sse2(const int16_t *input, uint8_t *dest,
+void vpx_idct16x16_10_add_sse2(const int16_t *input, uint8_t *dest,
                                int stride) {
   const __m128i rounding = _mm_set1_epi32(DCT_CONST_ROUNDING);
   const __m128i final_rounding = _mm_set1_epi16(1 << 5);
   const __m128i zero = _mm_setzero_si128();
 
   const __m128i stg2_0 = pair_set_epi16(cospi_30_64, -cospi_2_64);
   const __m128i stg2_1 = pair_set_epi16(cospi_2_64, cospi_30_64);
   const __m128i stg2_6 = pair_set_epi16(cospi_6_64, -cospi_26_64);
   const __m128i stg2_7 = pair_set_epi16(cospi_26_64, cospi_6_64);
 
@@ skipping 856 matching lines @@
                          stg4_0, stg6_0, stg4_0, stp1_22, stp1_25, \
                          stp1_23, stp1_24) \
   \
   stp1_28 = stp2_28; \
   stp1_29 = stp2_29; \
   stp1_30 = stp2_30; \
   stp1_31 = stp2_31; \
 }
 
 // Only upper-left 8x8 has non-zero coeff
-void vp9_idct32x32_34_add_sse2(const int16_t *input, uint8_t *dest,
+void vpx_idct32x32_34_add_sse2(const int16_t *input, uint8_t *dest,
                                int stride) {
   const __m128i rounding = _mm_set1_epi32(DCT_CONST_ROUNDING);
   const __m128i final_rounding = _mm_set1_epi16(1<<5);
 
   // idct constants for each stage
   const __m128i stg1_0 = pair_set_epi16(cospi_31_64, -cospi_1_64);
   const __m128i stg1_1 = pair_set_epi16(cospi_1_64, cospi_31_64);
   const __m128i stg1_6 = pair_set_epi16(cospi_7_64, -cospi_25_64);
   const __m128i stg1_7 = pair_set_epi16(cospi_25_64, cospi_7_64);
   const __m128i stg1_8 = pair_set_epi16(cospi_27_64, -cospi_5_64);
@@ skipping 138 matching lines @@
       // Final rounding and shift
       in[j] = _mm_adds_epi16(in[j], final_rounding);
       in[j] = _mm_srai_epi16(in[j], 6);
       RECON_AND_STORE(dest + j * stride, in[j]);
     }
 
     dest += 8;
   }
 }
 
-void vp9_idct32x32_1024_add_sse2(const int16_t *input, uint8_t *dest,
+void vpx_idct32x32_1024_add_sse2(const int16_t *input, uint8_t *dest,
                                  int stride) {
   const __m128i rounding = _mm_set1_epi32(DCT_CONST_ROUNDING);
   const __m128i final_rounding = _mm_set1_epi16(1 << 5);
   const __m128i zero = _mm_setzero_si128();
 
   // idct constants for each stage
   const __m128i stg1_0 = pair_set_epi16(cospi_31_64, -cospi_1_64);
   const __m128i stg1_1 = pair_set_epi16(cospi_1_64, cospi_31_64);
   const __m128i stg1_2 = pair_set_epi16(cospi_15_64, -cospi_17_64);
   const __m128i stg1_3 = pair_set_epi16(cospi_17_64, cospi_15_64);
@@ skipping 255 matching lines @@
       // Final rounding and shift
       in[j] = _mm_adds_epi16(in[j], final_rounding);
       in[j] = _mm_srai_epi16(in[j], 6);
       RECON_AND_STORE(dest + j * stride, in[j]);
     }
 
     dest += 8;
   }
 }
 
-void vp9_idct32x32_1_add_sse2(const int16_t *input, uint8_t *dest, int stride) {
+void vpx_idct32x32_1_add_sse2(const int16_t *input, uint8_t *dest, int stride) {
   __m128i dc_value;
   const __m128i zero = _mm_setzero_si128();
   int a, i;
 
   a = dct_const_round_shift(input[0] * cospi_16_64);
   a = dct_const_round_shift(a * cospi_16_64);
   a = ROUND_POWER_OF_TWO(a, 6);
 
   dc_value = _mm_set1_epi16(a);
 
@@ skipping 13 matching lines @@
   const __m128i one = _mm_set1_epi16(1);
   const __m128i max = _mm_subs_epi16(_mm_slli_epi16(one, bd), one);
   ubounded = _mm_cmpgt_epi16(value, max);
   retval = _mm_andnot_si128(ubounded, value);
   ubounded = _mm_and_si128(ubounded, max);
   retval = _mm_or_si128(retval, ubounded);
   retval = _mm_and_si128(retval, _mm_cmpgt_epi16(retval, zero));
   return retval;
 }
 
-void vp9_highbd_idct4x4_16_add_sse2(const tran_low_t *input, uint8_t *dest8,
+void vpx_highbd_idct4x4_16_add_sse2(const tran_low_t *input, uint8_t *dest8,
                                     int stride, int bd) {
   tran_low_t out[4 * 4];
   tran_low_t *outptr = out;
   int i, j;
   __m128i inptr[4];
   __m128i sign_bits[2];
   __m128i temp_mm, min_input, max_input;
   int test;
   uint16_t *dest = CONVERT_TO_SHORTPTR(dest8);
   int optimised_cols = 0;
@@ skipping 42 matching lines @@
       _mm_storeu_si128((__m128i *)(outptr + 4), inptr[1]);
       _mm_storeu_si128((__m128i *)(outptr + 8), inptr[2]);
       _mm_storeu_si128((__m128i *)(outptr + 12), inptr[3]);
     } else {
       // Set to use the optimised transform for the column
       optimised_cols = 1;
     }
   } else {
     // Run the un-optimised row transform
     for (i = 0; i < 4; ++i) {
-      vp9_highbd_idct4_c(input, outptr, bd);
+      vpx_highbd_idct4_c(input, outptr, bd);
       input += 4;
       outptr += 4;
     }
   }
 
   if (optimised_cols) {
     idct4_sse2(inptr);
 
     // Final round and shift
     inptr[0] = _mm_add_epi16(inptr[0], eight);
@@ skipping 23 matching lines @@
       d2 = _mm_srli_si128(d2, 8);
       _mm_storel_epi64((__m128i *)(dest + stride * 3), d2);
     }
   } else {
     // Run the un-optimised column transform
     tran_low_t temp_in[4], temp_out[4];
     // Columns
     for (i = 0; i < 4; ++i) {
       for (j = 0; j < 4; ++j)
         temp_in[j] = out[j * 4 + i];
-      vp9_highbd_idct4_c(temp_in, temp_out, bd);
+      vpx_highbd_idct4_c(temp_in, temp_out, bd);
       for (j = 0; j < 4; ++j) {
         dest[j * stride + i] = highbd_clip_pixel_add(
             dest[j * stride + i], ROUND_POWER_OF_TWO(temp_out[j], 4), bd);
       }
     }
   }
 }
 
-void vp9_highbd_idct8x8_64_add_sse2(const tran_low_t *input, uint8_t *dest8,
+void vpx_highbd_idct8x8_64_add_sse2(const tran_low_t *input, uint8_t *dest8,
                                     int stride, int bd) {
   tran_low_t out[8 * 8];
   tran_low_t *outptr = out;
   int i, j, test;
   __m128i inptr[8];
   __m128i min_input, max_input, temp1, temp2, sign_bits;
   uint16_t *dest = CONVERT_TO_SHORTPTR(dest8);
   const __m128i zero = _mm_set1_epi16(0);
   const __m128i sixteen = _mm_set1_epi16(16);
   const __m128i max = _mm_set1_epi16(6201);
@@ skipping 44 matching lines @@
         _mm_storeu_si128((__m128i *)(outptr + 4 * (2 * i + 1)), temp1);
         _mm_storeu_si128((__m128i *)(outptr + 4 * (2 * i)), temp2);
       }
     } else {
       // Set to use the optimised transform for the column
       optimised_cols = 1;
     }
   } else {
     // Run the un-optimised row transform
     for (i = 0; i < 8; ++i) {
-      vp9_highbd_idct8_c(input, outptr, bd);
+      vpx_highbd_idct8_c(input, outptr, bd);
       input += 8;
       outptr += 8;
     }
   }
 
   if (optimised_cols) {
     idct8_sse2(inptr);
 
     // Final round & shift and Reconstruction and Store
     {
       __m128i d[8];
       for (i = 0; i < 8; i++) {
         inptr[i] = _mm_add_epi16(inptr[i], sixteen);
         d[i] = _mm_loadu_si128((const __m128i *)(dest + stride*i));
         inptr[i] = _mm_srai_epi16(inptr[i], 5);
         d[i] = clamp_high_sse2(_mm_adds_epi16(d[i], inptr[i]), bd);
         // Store
         _mm_storeu_si128((__m128i *)(dest + stride*i), d[i]);
       }
     }
   } else {
     // Run the un-optimised column transform
     tran_low_t temp_in[8], temp_out[8];
     for (i = 0; i < 8; ++i) {
       for (j = 0; j < 8; ++j)
         temp_in[j] = out[j * 8 + i];
-      vp9_highbd_idct8_c(temp_in, temp_out, bd);
+      vpx_highbd_idct8_c(temp_in, temp_out, bd);
       for (j = 0; j < 8; ++j) {
         dest[j * stride + i] = highbd_clip_pixel_add(
             dest[j * stride + i], ROUND_POWER_OF_TWO(temp_out[j], 5), bd);
       }
     }
   }
 }
 
-void vp9_highbd_idct8x8_10_add_sse2(const tran_low_t *input, uint8_t *dest8,
+void vpx_highbd_idct8x8_10_add_sse2(const tran_low_t *input, uint8_t *dest8,
                                     int stride, int bd) {
   tran_low_t out[8 * 8] = { 0 };
   tran_low_t *outptr = out;
   int i, j, test;
   __m128i inptr[8];
   __m128i min_input, max_input, temp1, temp2, sign_bits;
   uint16_t *dest = CONVERT_TO_SHORTPTR(dest8);
   const __m128i zero = _mm_set1_epi16(0);
   const __m128i sixteen = _mm_set1_epi16(16);
   const __m128i max = _mm_set1_epi16(6201);
@@ skipping 47 matching lines @@
         _mm_storeu_si128((__m128i *)(outptr + 4 * (2 * i + 1)), temp1);
         _mm_storeu_si128((__m128i *)(outptr + 4 * (2 * i)), temp2);
       }
     } else {
       // Set to use the optimised transform for the column
       optimised_cols = 1;
     }
   } else {
     // Run the un-optimised row transform
     for (i = 0; i < 4; ++i) {
-      vp9_highbd_idct8_c(input, outptr, bd);
+      vpx_highbd_idct8_c(input, outptr, bd);
       input += 8;
       outptr += 8;
     }
   }
 
   if (optimised_cols) {
     idct8_sse2(inptr);
 
     // Final round & shift and Reconstruction and Store
     {
       __m128i d[8];
       for (i = 0; i < 8; i++) {
         inptr[i] = _mm_add_epi16(inptr[i], sixteen);
         d[i] = _mm_loadu_si128((const __m128i *)(dest + stride*i));
         inptr[i] = _mm_srai_epi16(inptr[i], 5);
         d[i] = clamp_high_sse2(_mm_adds_epi16(d[i], inptr[i]), bd);
         // Store
         _mm_storeu_si128((__m128i *)(dest + stride*i), d[i]);
       }
     }
   } else {
     // Run the un-optimised column transform
     tran_low_t temp_in[8], temp_out[8];
     for (i = 0; i < 8; ++i) {
       for (j = 0; j < 8; ++j)
         temp_in[j] = out[j * 8 + i];
-      vp9_highbd_idct8_c(temp_in, temp_out, bd);
+      vpx_highbd_idct8_c(temp_in, temp_out, bd);
       for (j = 0; j < 8; ++j) {
         dest[j * stride + i] = highbd_clip_pixel_add(
             dest[j * stride + i], ROUND_POWER_OF_TWO(temp_out[j], 5), bd);
       }
     }
   }
 }
 
-void vp9_highbd_idct16x16_256_add_sse2(const tran_low_t *input, uint8_t *dest8,
+void vpx_highbd_idct16x16_256_add_sse2(const tran_low_t *input, uint8_t *dest8,
                                        int stride, int bd) {
   tran_low_t out[16 * 16];
   tran_low_t *outptr = out;
   int i, j, test;
   __m128i inptr[32];
   __m128i min_input, max_input, temp1, temp2, sign_bits;
   uint16_t *dest = CONVERT_TO_SHORTPTR(dest8);
   const __m128i zero = _mm_set1_epi16(0);
   const __m128i rounding = _mm_set1_epi16(32);
   const __m128i max = _mm_set1_epi16(3155);
@@ skipping 52 matching lines @@
         _mm_storeu_si128((__m128i *)(outptr + 4 * (i * 4 + 2)), temp1);
         _mm_storeu_si128((__m128i *)(outptr + 4 * (i * 4 + 3)), temp2);
       }
     } else {
       // Set to use the optimised transform for the column
       optimised_cols = 1;
     }
   } else {
     // Run the un-optimised row transform
     for (i = 0; i < 16; ++i) {
-      vp9_highbd_idct16_c(input, outptr, bd);
+      vpx_highbd_idct16_c(input, outptr, bd);
       input += 16;
       outptr += 16;
     }
   }
 
   if (optimised_cols) {
     idct16_sse2(inptr, inptr + 16);
 
     // Final round & shift and Reconstruction and Store
     {
@@ skipping 11 matching lines @@
         _mm_storeu_si128((__m128i *)(dest + stride*i), d[0]);
         _mm_storeu_si128((__m128i *)(dest + stride*i + 8), d[1]);
       }
     }
   } else {
     // Run the un-optimised column transform
     tran_low_t temp_in[16], temp_out[16];
     for (i = 0; i < 16; ++i) {
       for (j = 0; j < 16; ++j)
         temp_in[j] = out[j * 16 + i];
-      vp9_highbd_idct16_c(temp_in, temp_out, bd);
+      vpx_highbd_idct16_c(temp_in, temp_out, bd);
       for (j = 0; j < 16; ++j) {
         dest[j * stride + i] = highbd_clip_pixel_add(
             dest[j * stride + i], ROUND_POWER_OF_TWO(temp_out[j], 6), bd);
       }
     }
   }
 }
 
-void vp9_highbd_idct16x16_10_add_sse2(const tran_low_t *input, uint8_t *dest8,
+void vpx_highbd_idct16x16_10_add_sse2(const tran_low_t *input, uint8_t *dest8,
                                       int stride, int bd) {
   tran_low_t out[16 * 16] = { 0 };
   tran_low_t *outptr = out;
   int i, j, test;
   __m128i inptr[32];
   __m128i min_input, max_input, temp1, temp2, sign_bits;
   uint16_t *dest = CONVERT_TO_SHORTPTR(dest8);
   const __m128i zero = _mm_set1_epi16(0);
   const __m128i rounding = _mm_set1_epi16(32);
   const __m128i max = _mm_set1_epi16(3155);
@@ skipping 57 matching lines @@
         _mm_storeu_si128((__m128i *)(outptr + 4 * (i * 4 + 2)), temp1);
         _mm_storeu_si128((__m128i *)(outptr + 4 * (i * 4 + 3)), temp2);
       }
     } else {
       // Set to use the optimised transform for the column
       optimised_cols = 1;
     }
   } else {
     // Run the un-optimised row transform
     for (i = 0; i < 4; ++i) {
-      vp9_highbd_idct16_c(input, outptr, bd);
+      vpx_highbd_idct16_c(input, outptr, bd);
       input += 16;
       outptr += 16;
     }
   }
 
   if (optimised_cols) {
     idct16_sse2(inptr, inptr + 16);
 
     // Final round & shift and Reconstruction and Store
     {
@@ skipping 11 matching lines @@
         _mm_storeu_si128((__m128i *)(dest + stride*i), d[0]);
         _mm_storeu_si128((__m128i *)(dest + stride*i + 8), d[1]);
       }
     }
   } else {
     // Run the un-optimised column transform
     tran_low_t temp_in[16], temp_out[16];
     for (i = 0; i < 16; ++i) {
       for (j = 0; j < 16; ++j)
         temp_in[j] = out[j * 16 + i];
-      vp9_highbd_idct16_c(temp_in, temp_out, bd);
+      vpx_highbd_idct16_c(temp_in, temp_out, bd);
       for (j = 0; j < 16; ++j) {
         dest[j * stride + i] = highbd_clip_pixel_add(
             dest[j * stride + i], ROUND_POWER_OF_TWO(temp_out[j], 6), bd);
       }
     }
   }
 }
 #endif  // CONFIG_VP9_HIGHBITDEPTH