aom_dsp/fwd_txfm.c - aom - Git at Google

 /*
  * Copyright (c) 2016, Alliance for Open Media. All rights reserved
  *
  * This source code is subject to the terms of the BSD 2 Clause License and
  * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
  * was not distributed with this source code in the LICENSE file, you can
  * obtain it at www.aomedia.org/license/software. If the Alliance for Open
  * Media Patent License 1.0 was not distributed with this source code in the
  * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
  */

 #include <assert.h>
 #include "aom_dsp/txfm_common.h"
 #include "config/aom_dsp_rtcd.h"

 void aom_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride) {
   // The 2D transform is done with two passes which are actually pretty
   // similar. In the first one, we transform the columns and transpose
   // the results. In the second one, we transform the rows.
   // We need an intermediate buffer between passes.
   tran_low_t intermediate[4 * 4];
   const tran_low_t *in_low = NULL;
   tran_low_t *out = intermediate;
   // Do the two transform passes
   for (int pass = 0; pass < 2; ++pass) {
     tran_high_t in_high[4];  // canbe16
     tran_high_t step[4];     // canbe16
     tran_low_t temp[4];
     for (int i = 0; i < 4; ++i) {
       // Load inputs.
       if (pass == 0) {
         in_high[0] = input[0 * stride] * 16;
         in_high[1] = input[1 * stride] * 16;
         in_high[2] = input[2 * stride] * 16;
         in_high[3] = input[3 * stride] * 16;
         if (i == 0 && in_high[0]) {
           ++in_high[0];
         }
         ++input;  // Next column
       } else {
         assert(in_low != NULL);
         in_high[0] = in_low[0 * 4];
         in_high[1] = in_low[1 * 4];
         in_high[2] = in_low[2 * 4];
         in_high[3] = in_low[3 * 4];
         ++in_low;  // Next column (which is a transposed row)
       }
       // Transform.
       step[0] = in_high[0] + in_high[3];
       step[1] = in_high[1] + in_high[2];
       step[2] = in_high[1] - in_high[2];
       step[3] = in_high[0] - in_high[3];
       temp[0] = (tran_low_t)fdct_round_shift((step[0] + step[1]) * cospi_16_64);
       temp[2] = (tran_low_t)fdct_round_shift((step[0] - step[1]) * cospi_16_64);
       temp[1] = (tran_low_t)fdct_round_shift(step[2] * cospi_24_64 +
                                              step[3] * cospi_8_64);
       temp[3] = (tran_low_t)fdct_round_shift(-step[2] * cospi_8_64 +
                                              step[3] * cospi_24_64);
       // Only transpose the first pass.
       if (pass == 0) {
         out[0] = temp[0];
         out[1] = temp[1];
         out[2] = temp[2];
         out[3] = temp[3];
         out += 4;
       } else {
         out[0 * 4] = temp[0];
         out[1 * 4] = temp[1];
         out[2 * 4] = temp[2];
         out[3 * 4] = temp[3];
         ++out;
       }
     }
     // Setup in/out for next pass.
     in_low = intermediate;
     out = output;
   }

   for (int i = 0; i < 4; ++i) {
     for (int j = 0; j < 4; ++j)
       output[j + i * 4] = (output[j + i * 4] + 1) >> 2;
   }
 }

 void aom_fdct4x4_lp_c(const int16_t *input, int16_t *output, int stride) {
   // The 2D transform is done with two passes which are actually pretty
   // similar. In the first one, we transform the columns and transpose
   // the results. In the second one, we transform the rows.
   // We need an intermediate buffer between passes.
   int16_t intermediate[4 * 4];
   const int16_t *in_low = NULL;
   int16_t *out = intermediate;
   // Do the two transform passes
   for (int pass = 0; pass < 2; ++pass) {
     int32_t in_high[4];  // canbe16
     int32_t step[4];     // canbe16
     int16_t temp[4];
     for (int i = 0; i < 4; ++i) {
       // Load inputs.
       if (pass == 0) {
         in_high[0] = input[0 * stride] * 16;
         in_high[1] = input[1 * stride] * 16;
         in_high[2] = input[2 * stride] * 16;
         in_high[3] = input[3 * stride] * 16;
         ++input;
         if (i == 0 && in_high[0]) {
           ++in_high[0];
         }
       } else {
         assert(in_low != NULL);
         in_high[0] = in_low[0 * 4];
         in_high[1] = in_low[1 * 4];
         in_high[2] = in_low[2 * 4];
         in_high[3] = in_low[3 * 4];
         ++in_low;
       }
       // Transform.
       step[0] = in_high[0] + in_high[3];
       step[1] = in_high[1] + in_high[2];
       step[2] = in_high[1] - in_high[2];
       step[3] = in_high[0] - in_high[3];
       temp[0] = (int16_t)fdct_round_shift((step[0] + step[1]) * cospi_16_64);
       temp[2] = (int16_t)fdct_round_shift((step[0] - step[1]) * cospi_16_64);
       temp[1] = (int16_t)fdct_round_shift(step[2] * cospi_24_64 +
                                           step[3] * cospi_8_64);
       temp[3] = (int16_t)fdct_round_shift(-step[2] * cospi_8_64 +
                                           step[3] * cospi_24_64);
       // Only transpose the first pass.
       if (pass == 0) {
         out[0] = temp[0];
         out[1] = temp[1];
         out[2] = temp[2];
         out[3] = temp[3];
         out += 4;
       } else {
         out[0 * 4] = temp[0];
         out[1 * 4] = temp[1];
         out[2 * 4] = temp[2];
         out[3 * 4] = temp[3];
         ++out;
       }
     }
     // Setup in/out for next pass.
     in_low = intermediate;
     out = output;
   }

   for (int i = 0; i < 4; ++i) {
     for (int j = 0; j < 4; ++j)
       output[j + i * 4] = (output[j + i * 4] + 1) >> 2;
   }
 }

 #if CONFIG_INTERNAL_STATS
 void aom_fdct8x8_c(const int16_t *input, tran_low_t *final_output, int stride) {
   int i, j;
   tran_low_t intermediate[64];
   int pass;
   tran_low_t *output = intermediate;
   const tran_low_t *in = NULL;

   // Transform columns
   for (pass = 0; pass < 2; ++pass) {
     tran_high_t s0, s1, s2, s3, s4, s5, s6, s7;  // canbe16
     tran_high_t t0, t1, t2, t3;                  // needs32
     tran_high_t x0, x1, x2, x3;                  // canbe16

     for (i = 0; i < 8; i++) {
       // stage 1
       if (pass == 0) {
         s0 = (input[0 * stride] + input[7 * stride]) * 4;
         s1 = (input[1 * stride] + input[6 * stride]) * 4;
         s2 = (input[2 * stride] + input[5 * stride]) * 4;
         s3 = (input[3 * stride] + input[4 * stride]) * 4;
         s4 = (input[3 * stride] - input[4 * stride]) * 4;
         s5 = (input[2 * stride] - input[5 * stride]) * 4;
         s6 = (input[1 * stride] - input[6 * stride]) * 4;
         s7 = (input[0 * stride] - input[7 * stride]) * 4;
         ++input;
       } else {
         s0 = in[0 * 8] + in[7 * 8];
         s1 = in[1 * 8] + in[6 * 8];
         s2 = in[2 * 8] + in[5 * 8];
         s3 = in[3 * 8] + in[4 * 8];
         s4 = in[3 * 8] - in[4 * 8];
         s5 = in[2 * 8] - in[5 * 8];
         s6 = in[1 * 8] - in[6 * 8];
         s7 = in[0 * 8] - in[7 * 8];
         ++in;
       }

       // fdct4(step, step);
       x0 = s0 + s3;
       x1 = s1 + s2;
       x2 = s1 - s2;
       x3 = s0 - s3;
       t0 = (x0 + x1) * cospi_16_64;
       t1 = (x0 - x1) * cospi_16_64;
       t2 = x2 * cospi_24_64 + x3 * cospi_8_64;
       t3 = -x2 * cospi_8_64 + x3 * cospi_24_64;
       output[0] = (tran_low_t)fdct_round_shift(t0);
       output[2] = (tran_low_t)fdct_round_shift(t2);
       output[4] = (tran_low_t)fdct_round_shift(t1);
       output[6] = (tran_low_t)fdct_round_shift(t3);

       // Stage 2
       t0 = (s6 - s5) * cospi_16_64;
       t1 = (s6 + s5) * cospi_16_64;
       t2 = fdct_round_shift(t0);
       t3 = fdct_round_shift(t1);

       // Stage 3
       x0 = s4 + t2;
       x1 = s4 - t2;
       x2 = s7 - t3;
       x3 = s7 + t3;

       // Stage 4
       t0 = x0 * cospi_28_64 + x3 * cospi_4_64;
       t1 = x1 * cospi_12_64 + x2 * cospi_20_64;
       t2 = x2 * cospi_12_64 + x1 * -cospi_20_64;
       t3 = x3 * cospi_28_64 + x0 * -cospi_4_64;
       output[1] = (tran_low_t)fdct_round_shift(t0);
       output[3] = (tran_low_t)fdct_round_shift(t2);
       output[5] = (tran_low_t)fdct_round_shift(t1);
       output[7] = (tran_low_t)fdct_round_shift(t3);
       output += 8;
     }
     in = intermediate;
     output = final_output;
   }

   // Rows
   for (i = 0; i < 8; ++i) {
     for (j = 0; j < 8; ++j) final_output[j + i * 8] /= 2;
   }
 }
 #endif  // CONFIG_INTERNAL_STATS

 #if CONFIG_AV1_HIGHBITDEPTH && CONFIG_INTERNAL_STATS
 void aom_highbd_fdct8x8_c(const int16_t *input, tran_low_t *final_output,
                           int stride) {
   aom_fdct8x8_c(input, final_output, stride);
 }
 #endif
	/*
	* Copyright (c) 2016, Alliance for Open Media. All rights reserved
	*
	* This source code is subject to the terms of the BSD 2 Clause License and
	* the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
	* was not distributed with this source code in the LICENSE file, you can
	* obtain it at www.aomedia.org/license/software. If the Alliance for Open
	* Media Patent License 1.0 was not distributed with this source code in the
	* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
	*/

	#include <assert.h>
	#include "aom_dsp/txfm_common.h"
	#include "config/aom_dsp_rtcd.h"

	void aom_fdct4x4_c(const int16_t input, tran_low_t output, int stride) {
	// The 2D transform is done with two passes which are actually pretty
	// similar. In the first one, we transform the columns and transpose
	// the results. In the second one, we transform the rows.
	// We need an intermediate buffer between passes.
	tran_low_t intermediate[4 * 4];
	const tran_low_t *in_low = NULL;
	tran_low_t *out = intermediate;
	// Do the two transform passes
	for (int pass = 0; pass < 2; ++pass) {
	tran_high_t in_high[4]; // canbe16
	tran_high_t step[4]; // canbe16
	tran_low_t temp[4];
	for (int i = 0; i < 4; ++i) {
	// Load inputs.
	if (pass == 0) {
	in_high[0] = input[0 * stride] * 16;
	in_high[1] = input[1 * stride] * 16;
	in_high[2] = input[2 * stride] * 16;
	in_high[3] = input[3 * stride] * 16;
	if (i == 0 && in_high[0]) {
	++in_high[0];
	}
	++input; // Next column
	} else {
	assert(in_low != NULL);
	in_high[0] = in_low[0 * 4];
	in_high[1] = in_low[1 * 4];
	in_high[2] = in_low[2 * 4];
	in_high[3] = in_low[3 * 4];
	++in_low; // Next column (which is a transposed row)
	}
	// Transform.
	step[0] = in_high[0] + in_high[3];
	step[1] = in_high[1] + in_high[2];
	step[2] = in_high[1] - in_high[2];
	step[3] = in_high[0] - in_high[3];
	temp[0] = (tran_low_t)fdct_round_shift((step[0] + step[1]) * cospi_16_64);
	temp[2] = (tran_low_t)fdct_round_shift((step[0] - step[1]) * cospi_16_64);
	temp[1] = (tran_low_t)fdct_round_shift(step[2] * cospi_24_64 +
	step[3] * cospi_8_64);
	temp[3] = (tran_low_t)fdct_round_shift(-step[2] * cospi_8_64 +
	step[3] * cospi_24_64);
	// Only transpose the first pass.
	if (pass == 0) {
	out[0] = temp[0];
	out[1] = temp[1];
	out[2] = temp[2];
	out[3] = temp[3];
	out += 4;
	} else {
	out[0 * 4] = temp[0];
	out[1 * 4] = temp[1];
	out[2 * 4] = temp[2];
	out[3 * 4] = temp[3];
	++out;
	}
	}
	// Setup in/out for next pass.
	in_low = intermediate;
	out = output;
	}

	for (int i = 0; i < 4; ++i) {
	for (int j = 0; j < 4; ++j)
	output[j + i * 4] = (output[j + i * 4] + 1) >> 2;
	}
	}

	void aom_fdct4x4_lp_c(const int16_t input, int16_t output, int stride) {
	// The 2D transform is done with two passes which are actually pretty
	// similar. In the first one, we transform the columns and transpose
	// the results. In the second one, we transform the rows.
	// We need an intermediate buffer between passes.
	int16_t intermediate[4 * 4];
	const int16_t *in_low = NULL;
	int16_t *out = intermediate;
	// Do the two transform passes
	for (int pass = 0; pass < 2; ++pass) {
	int32_t in_high[4]; // canbe16
	int32_t step[4]; // canbe16
	int16_t temp[4];
	for (int i = 0; i < 4; ++i) {
	// Load inputs.
	if (pass == 0) {
	in_high[0] = input[0 * stride] * 16;
	in_high[1] = input[1 * stride] * 16;
	in_high[2] = input[2 * stride] * 16;
	in_high[3] = input[3 * stride] * 16;
	++input;
	if (i == 0 && in_high[0]) {
	++in_high[0];
	}
	} else {
	assert(in_low != NULL);
	in_high[0] = in_low[0 * 4];
	in_high[1] = in_low[1 * 4];
	in_high[2] = in_low[2 * 4];
	in_high[3] = in_low[3 * 4];
	++in_low;
	}
	// Transform.
	step[0] = in_high[0] + in_high[3];
	step[1] = in_high[1] + in_high[2];
	step[2] = in_high[1] - in_high[2];
	step[3] = in_high[0] - in_high[3];
	temp[0] = (int16_t)fdct_round_shift((step[0] + step[1]) * cospi_16_64);
	temp[2] = (int16_t)fdct_round_shift((step[0] - step[1]) * cospi_16_64);
	temp[1] = (int16_t)fdct_round_shift(step[2] * cospi_24_64 +
	step[3] * cospi_8_64);
	temp[3] = (int16_t)fdct_round_shift(-step[2] * cospi_8_64 +
	step[3] * cospi_24_64);
	// Only transpose the first pass.
	if (pass == 0) {
	out[0] = temp[0];
	out[1] = temp[1];
	out[2] = temp[2];
	out[3] = temp[3];
	out += 4;
	} else {
	out[0 * 4] = temp[0];
	out[1 * 4] = temp[1];
	out[2 * 4] = temp[2];
	out[3 * 4] = temp[3];
	++out;
	}
	}
	// Setup in/out for next pass.
	in_low = intermediate;
	out = output;
	}

	for (int i = 0; i < 4; ++i) {
	for (int j = 0; j < 4; ++j)
	output[j + i * 4] = (output[j + i * 4] + 1) >> 2;
	}
	}

	#if CONFIG_INTERNAL_STATS
	void aom_fdct8x8_c(const int16_t input, tran_low_t final_output, int stride) {
	int i, j;
	tran_low_t intermediate[64];
	int pass;
	tran_low_t *output = intermediate;
	const tran_low_t *in = NULL;

	// Transform columns
	for (pass = 0; pass < 2; ++pass) {
	tran_high_t s0, s1, s2, s3, s4, s5, s6, s7; // canbe16
	tran_high_t t0, t1, t2, t3; // needs32
	tran_high_t x0, x1, x2, x3; // canbe16

	for (i = 0; i < 8; i++) {
	// stage 1
	if (pass == 0) {
	s0 = (input[0 * stride] + input[7 * stride]) * 4;
	s1 = (input[1 * stride] + input[6 * stride]) * 4;
	s2 = (input[2 * stride] + input[5 * stride]) * 4;
	s3 = (input[3 * stride] + input[4 * stride]) * 4;
	s4 = (input[3 * stride] - input[4 * stride]) * 4;
	s5 = (input[2 * stride] - input[5 * stride]) * 4;
	s6 = (input[1 * stride] - input[6 * stride]) * 4;
	s7 = (input[0 * stride] - input[7 * stride]) * 4;
	++input;
	} else {
	s0 = in[0 * 8] + in[7 * 8];
	s1 = in[1 * 8] + in[6 * 8];
	s2 = in[2 * 8] + in[5 * 8];
	s3 = in[3 * 8] + in[4 * 8];
	s4 = in[3 * 8] - in[4 * 8];
	s5 = in[2 * 8] - in[5 * 8];
	s6 = in[1 * 8] - in[6 * 8];
	s7 = in[0 * 8] - in[7 * 8];
	++in;
	}

	// fdct4(step, step);
	x0 = s0 + s3;
	x1 = s1 + s2;
	x2 = s1 - s2;
	x3 = s0 - s3;
	t0 = (x0 + x1) * cospi_16_64;
	t1 = (x0 - x1) * cospi_16_64;
	t2 = x2 * cospi_24_64 + x3 * cospi_8_64;
	t3 = -x2 * cospi_8_64 + x3 * cospi_24_64;
	output[0] = (tran_low_t)fdct_round_shift(t0);
	output[2] = (tran_low_t)fdct_round_shift(t2);
	output[4] = (tran_low_t)fdct_round_shift(t1);
	output[6] = (tran_low_t)fdct_round_shift(t3);

	// Stage 2
	t0 = (s6 - s5) * cospi_16_64;
	t1 = (s6 + s5) * cospi_16_64;
	t2 = fdct_round_shift(t0);
	t3 = fdct_round_shift(t1);

	// Stage 3
	x0 = s4 + t2;
	x1 = s4 - t2;
	x2 = s7 - t3;
	x3 = s7 + t3;

	// Stage 4
	t0 = x0 * cospi_28_64 + x3 * cospi_4_64;
	t1 = x1 * cospi_12_64 + x2 * cospi_20_64;
	t2 = x2 * cospi_12_64 + x1 * -cospi_20_64;
	t3 = x3 * cospi_28_64 + x0 * -cospi_4_64;
	output[1] = (tran_low_t)fdct_round_shift(t0);
	output[3] = (tran_low_t)fdct_round_shift(t2);
	output[5] = (tran_low_t)fdct_round_shift(t1);
	output[7] = (tran_low_t)fdct_round_shift(t3);
	output += 8;
	}
	in = intermediate;
	output = final_output;
	}

	// Rows
	for (i = 0; i < 8; ++i) {
	for (j = 0; j < 8; ++j) final_output[j + i * 8] /= 2;
	}
	}
	#endif // CONFIG_INTERNAL_STATS

	#if CONFIG_AV1_HIGHBITDEPTH && CONFIG_INTERNAL_STATS
	void aom_highbd_fdct8x8_c(const int16_t input, tran_low_t final_output,
	int stride) {
	aom_fdct8x8_c(input, final_output, stride);
	}
	#endif