Blame - aom_dsp/x86/fwd_dct32x32_impl_avx2.h - avm

Yaowu Xu

c27fc14

2016-08-22 16:08:15 -0700

[diff] [blame]

1

/*

Yaowu Xu

9c01aa1

2016-09-01 14:32:49 -0700

[diff] [blame]

2

Yaowu Xu

c27fc14

2016-08-22 16:08:15 -0700

[diff] [blame]

3

*

Yaowu Xu

9c01aa1

2016-09-01 14:32:49 -0700

[diff] [blame]

4

* This source code is subject to the terms of the BSD 2 Clause License and

5

* the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License

6

* was not distributed with this source code in the LICENSE file, you can

7

* obtain it at www.aomedia.org/license/software. If the Alliance for Open

8

* Media Patent License 1.0 was not distributed with this source code in the

9

* PATENTS file, you can obtain it at www.aomedia.org/license/patent.

Yaowu Xu

c27fc14

2016-08-22 16:08:15 -0700

[diff] [blame]

10

*/

11

12

#include <immintrin.h> // AVX2

13

Yaowu Xu

c27fc14

2016-08-22 16:08:15 -0700

[diff] [blame]

14

#include "aom_dsp/txfm_common.h"

Yi Luo

0c552df

2016-10-24 16:30:55 -0700

[diff] [blame]

15

#include "aom_dsp/x86/txfm_common_intrin.h"

Yi Luo

e8e8cd8

2016-09-21 10:45:01 -0700

[diff] [blame]

16

#include "aom_dsp/x86/txfm_common_avx2.h"

Yaowu Xu

c27fc14

2016-08-22 16:08:15 -0700

[diff] [blame]

17

18

#if FDCT32x32_HIGH_PRECISION

19

static INLINE __m256i k_madd_epi32_avx2(__m256i a, __m256i b) {

20

__m256i buf0, buf1;

21

buf0 = _mm256_mul_epu32(a, b);

22

a = _mm256_srli_epi64(a, 32);

23

b = _mm256_srli_epi64(b, 32);

24

buf1 = _mm256_mul_epu32(a, b);

25

return _mm256_add_epi64(buf0, buf1);

26

}

27

28

static INLINE __m256i k_packs_epi64_avx2(__m256i a, __m256i b) {

29

__m256i buf0 = _mm256_shuffle_epi32(a, _MM_SHUFFLE(0, 0, 2, 0));

30

__m256i buf1 = _mm256_shuffle_epi32(b, _MM_SHUFFLE(0, 0, 2, 0));

31

return _mm256_unpacklo_epi64(buf0, buf1);

}

#endif

Yi Luo

2016-10-24 16:30:55 -0700

[diff] [blame]

35

#ifndef STORE_COEFF_FUNC

36

#define STORE_COEFF_FUNC

37

static void store_coeff(const __m256i *coeff, tran_low_t *curr,

38

tran_low_t *next) {

39

__m128i u = _mm256_castsi256_si128(*coeff);

40

storeu_output(&u, curr);

41

u = _mm256_extractf128_si256(*coeff, 1);

42

storeu_output(&u, next);

}

#endif

void FDCT32x32_2D_AVX2(const int16_t *input, tran_low_t *output_org,

47

int stride) {

Yaowu Xu

c27fc14

2016-08-22 16:08:15 -0700

[diff] [blame]

48

// Calculate pre-multiplied strides

49

const int str1 = stride;

50

const int str2 = 2 * stride;

51

const int str3 = 2 * stride + str1;

52

// We need an intermediate buffer between passes.

53

DECLARE_ALIGNED(32, int16_t, intermediate[32 * 32]);

54

// Constants

55

// When we use them, in one case, they are all the same. In all others

56

// it's a pair of them that we need to repeat four times. This is done

57

// by constructing the 32 bit constant corresponding to that pair.

58

const __m256i k__cospi_p16_p16 = _mm256_set1_epi16((int16_t)cospi_16_64);

59

const __m256i k__cospi_p16_m16 =

60

pair256_set_epi16(+cospi_16_64, -cospi_16_64);

61

const __m256i k__cospi_m08_p24 = pair256_set_epi16(-cospi_8_64, cospi_24_64);

62

const __m256i k__cospi_m24_m08 = pair256_set_epi16(-cospi_24_64, -cospi_8_64);

63

const __m256i k__cospi_p24_p08 = pair256_set_epi16(+cospi_24_64, cospi_8_64);

64

const __m256i k__cospi_p12_p20 = pair256_set_epi16(+cospi_12_64, cospi_20_64);

65

const __m256i k__cospi_m20_p12 = pair256_set_epi16(-cospi_20_64, cospi_12_64);

66

const __m256i k__cospi_m04_p28 = pair256_set_epi16(-cospi_4_64, cospi_28_64);

67

const __m256i k__cospi_p28_p04 = pair256_set_epi16(+cospi_28_64, cospi_4_64);

68

const __m256i k__cospi_m28_m04 = pair256_set_epi16(-cospi_28_64, -cospi_4_64);

69

const __m256i k__cospi_m12_m20 =

70

pair256_set_epi16(-cospi_12_64, -cospi_20_64);

71

const __m256i k__cospi_p30_p02 = pair256_set_epi16(+cospi_30_64, cospi_2_64);

72

const __m256i k__cospi_p14_p18 = pair256_set_epi16(+cospi_14_64, cospi_18_64);

73

const __m256i k__cospi_p22_p10 = pair256_set_epi16(+cospi_22_64, cospi_10_64);

74

const __m256i k__cospi_p06_p26 = pair256_set_epi16(+cospi_6_64, cospi_26_64);

75

const __m256i k__cospi_m26_p06 = pair256_set_epi16(-cospi_26_64, cospi_6_64);

76

const __m256i k__cospi_m10_p22 = pair256_set_epi16(-cospi_10_64, cospi_22_64);

77

const __m256i k__cospi_m18_p14 = pair256_set_epi16(-cospi_18_64, cospi_14_64);

78

const __m256i k__cospi_m02_p30 = pair256_set_epi16(-cospi_2_64, cospi_30_64);

79

const __m256i k__cospi_p31_p01 = pair256_set_epi16(+cospi_31_64, cospi_1_64);

80

const __m256i k__cospi_p15_p17 = pair256_set_epi16(+cospi_15_64, cospi_17_64);

81

const __m256i k__cospi_p23_p09 = pair256_set_epi16(+cospi_23_64, cospi_9_64);

82

const __m256i k__cospi_p07_p25 = pair256_set_epi16(+cospi_7_64, cospi_25_64);

83

const __m256i k__cospi_m25_p07 = pair256_set_epi16(-cospi_25_64, cospi_7_64);

84

const __m256i k__cospi_m09_p23 = pair256_set_epi16(-cospi_9_64, cospi_23_64);

85

const __m256i k__cospi_m17_p15 = pair256_set_epi16(-cospi_17_64, cospi_15_64);

86

const __m256i k__cospi_m01_p31 = pair256_set_epi16(-cospi_1_64, cospi_31_64);

87

const __m256i k__cospi_p27_p05 = pair256_set_epi16(+cospi_27_64, cospi_5_64);

88

const __m256i k__cospi_p11_p21 = pair256_set_epi16(+cospi_11_64, cospi_21_64);

89

const __m256i k__cospi_p19_p13 = pair256_set_epi16(+cospi_19_64, cospi_13_64);

90

const __m256i k__cospi_p03_p29 = pair256_set_epi16(+cospi_3_64, cospi_29_64);

91

const __m256i k__cospi_m29_p03 = pair256_set_epi16(-cospi_29_64, cospi_3_64);

92

const __m256i k__cospi_m13_p19 = pair256_set_epi16(-cospi_13_64, cospi_19_64);

93

const __m256i k__cospi_m21_p11 = pair256_set_epi16(-cospi_21_64, cospi_11_64);

94

const __m256i k__cospi_m05_p27 = pair256_set_epi16(-cospi_5_64, cospi_27_64);

95

const __m256i k__DCT_CONST_ROUNDING = _mm256_set1_epi32(DCT_CONST_ROUNDING);

96

const __m256i kZero = _mm256_set1_epi16(0);

97

const __m256i kOne = _mm256_set1_epi16(1);

98

// Do the two transform/transpose passes

99

int pass;

100

for (pass = 0; pass < 2; ++pass) {

101

// We process sixteen columns (transposed rows in second pass) at a time.

102

int column_start;

103

for (column_start = 0; column_start < 32; column_start += 16) {

__m256i step1[32];

__m256i step2[32];

__m256i step3[32];

__m256i out[32];

// Stage 1

// Note: even though all the loads below are aligned, using the aligned

110

// intrinsic make the code slightly slower.

111

if (0 == pass) {

112

const int16_t *in = &input[column_start];

113

// step1[i] = (in[ 0 * stride] + in[(32 - 1) * stride]) << 2;

114

// Note: the next four blocks could be in a loop. That would help the

115

// instruction cache but is actually slower.

116

{

117

const int16_t *ina = in + 0 * str1;

118

const int16_t *inb = in + 31 * str1;

119

__m256i *step1a = &step1[0];

120

__m256i *step1b = &step1[31];

121

const __m256i ina0 = _mm256_loadu_si256((const __m256i *)(ina));

122

const __m256i ina1 =

123

_mm256_loadu_si256((const __m256i *)(ina + str1));

124

const __m256i ina2 =

125

_mm256_loadu_si256((const __m256i *)(ina + str2));

126

const __m256i ina3 =

127

_mm256_loadu_si256((const __m256i *)(ina + str3));

128

const __m256i inb3 =

129

_mm256_loadu_si256((const __m256i *)(inb - str3));

130

const __m256i inb2 =

131

_mm256_loadu_si256((const __m256i *)(inb - str2));

132

const __m256i inb1 =

133

_mm256_loadu_si256((const __m256i *)(inb - str1));

134

const __m256i inb0 = _mm256_loadu_si256((const __m256i *)(inb));

135

step1a[0] = _mm256_add_epi16(ina0, inb0);

136

step1a[1] = _mm256_add_epi16(ina1, inb1);

137

step1a[2] = _mm256_add_epi16(ina2, inb2);

138

step1a[3] = _mm256_add_epi16(ina3, inb3);

139

step1b[-3] = _mm256_sub_epi16(ina3, inb3);

140

step1b[-2] = _mm256_sub_epi16(ina2, inb2);

141

step1b[-1] = _mm256_sub_epi16(ina1, inb1);

142

step1b[-0] = _mm256_sub_epi16(ina0, inb0);

143

step1a[0] = _mm256_slli_epi16(step1a[0], 2);

144

step1a[1] = _mm256_slli_epi16(step1a[1], 2);

145

step1a[2] = _mm256_slli_epi16(step1a[2], 2);

146

step1a[3] = _mm256_slli_epi16(step1a[3], 2);

147

step1b[-3] = _mm256_slli_epi16(step1b[-3], 2);

148

step1b[-2] = _mm256_slli_epi16(step1b[-2], 2);

149

step1b[-1] = _mm256_slli_epi16(step1b[-1], 2);

150

step1b[-0] = _mm256_slli_epi16(step1b[-0], 2);

151

}

152

{

153

const int16_t *ina = in + 4 * str1;

154

const int16_t *inb = in + 27 * str1;

155

__m256i *step1a = &step1[4];

156

__m256i *step1b = &step1[27];

157

const __m256i ina0 = _mm256_loadu_si256((const __m256i *)(ina));

158

const __m256i ina1 =

159

_mm256_loadu_si256((const __m256i *)(ina + str1));

160

const __m256i ina2 =

161

_mm256_loadu_si256((const __m256i *)(ina + str2));

162

const __m256i ina3 =

163

_mm256_loadu_si256((const __m256i *)(ina + str3));

164

const __m256i inb3 =

165

_mm256_loadu_si256((const __m256i *)(inb - str3));

166

const __m256i inb2 =

167

_mm256_loadu_si256((const __m256i *)(inb - str2));

168

const __m256i inb1 =

169

_mm256_loadu_si256((const __m256i *)(inb - str1));

170

const __m256i inb0 = _mm256_loadu_si256((const __m256i *)(inb));

171

step1a[0] = _mm256_add_epi16(ina0, inb0);

172

step1a[1] = _mm256_add_epi16(ina1, inb1);

173

step1a[2] = _mm256_add_epi16(ina2, inb2);

174

step1a[3] = _mm256_add_epi16(ina3, inb3);

175

step1b[-3] = _mm256_sub_epi16(ina3, inb3);

176

step1b[-2] = _mm256_sub_epi16(ina2, inb2);

177

step1b[-1] = _mm256_sub_epi16(ina1, inb1);

178

step1b[-0] = _mm256_sub_epi16(ina0, inb0);

179

step1a[0] = _mm256_slli_epi16(step1a[0], 2);

180

step1a[1] = _mm256_slli_epi16(step1a[1], 2);

181

step1a[2] = _mm256_slli_epi16(step1a[2], 2);

182

step1a[3] = _mm256_slli_epi16(step1a[3], 2);

183

step1b[-3] = _mm256_slli_epi16(step1b[-3], 2);

184

step1b[-2] = _mm256_slli_epi16(step1b[-2], 2);

185

step1b[-1] = _mm256_slli_epi16(step1b[-1], 2);

186

step1b[-0] = _mm256_slli_epi16(step1b[-0], 2);

187

}

188

{

189

const int16_t *ina = in + 8 * str1;

190

const int16_t *inb = in + 23 * str1;

191

__m256i *step1a = &step1[8];

192

__m256i *step1b = &step1[23];

193

const __m256i ina0 = _mm256_loadu_si256((const __m256i *)(ina));

194

const __m256i ina1 =

195

_mm256_loadu_si256((const __m256i *)(ina + str1));

196

const __m256i ina2 =

197

_mm256_loadu_si256((const __m256i *)(ina + str2));

198

const __m256i ina3 =

199

_mm256_loadu_si256((const __m256i *)(ina + str3));

200

const __m256i inb3 =

201

_mm256_loadu_si256((const __m256i *)(inb - str3));

202

const __m256i inb2 =

203

_mm256_loadu_si256((const __m256i *)(inb - str2));

204

const __m256i inb1 =

205

_mm256_loadu_si256((const __m256i *)(inb - str1));

206

const __m256i inb0 = _mm256_loadu_si256((const __m256i *)(inb));

207

step1a[0] = _mm256_add_epi16(ina0, inb0);

208

step1a[1] = _mm256_add_epi16(ina1, inb1);

209

step1a[2] = _mm256_add_epi16(ina2, inb2);

210

step1a[3] = _mm256_add_epi16(ina3, inb3);

211

step1b[-3] = _mm256_sub_epi16(ina3, inb3);

212

step1b[-2] = _mm256_sub_epi16(ina2, inb2);

213

step1b[-1] = _mm256_sub_epi16(ina1, inb1);

214

step1b[-0] = _mm256_sub_epi16(ina0, inb0);

215

step1a[0] = _mm256_slli_epi16(step1a[0], 2);

216

step1a[1] = _mm256_slli_epi16(step1a[1], 2);

217

step1a[2] = _mm256_slli_epi16(step1a[2], 2);

218

step1a[3] = _mm256_slli_epi16(step1a[3], 2);

219

step1b[-3] = _mm256_slli_epi16(step1b[-3], 2);

220

step1b[-2] = _mm256_slli_epi16(step1b[-2], 2);

221

step1b[-1] = _mm256_slli_epi16(step1b[-1], 2);

222

step1b[-0] = _mm256_slli_epi16(step1b[-0], 2);

223

}

224

{

225

const int16_t *ina = in + 12 * str1;

226

const int16_t *inb = in + 19 * str1;

227

__m256i *step1a = &step1[12];

228

__m256i *step1b = &step1[19];

229

const __m256i ina0 = _mm256_loadu_si256((const __m256i *)(ina));

230

const __m256i ina1 =

231

_mm256_loadu_si256((const __m256i *)(ina + str1));

232

const __m256i ina2 =

233

_mm256_loadu_si256((const __m256i *)(ina + str2));

234

const __m256i ina3 =

235

_mm256_loadu_si256((const __m256i *)(ina + str3));

236

const __m256i inb3 =

237

_mm256_loadu_si256((const __m256i *)(inb - str3));

238

const __m256i inb2 =

239

_mm256_loadu_si256((const __m256i *)(inb - str2));

240

const __m256i inb1 =

241

_mm256_loadu_si256((const __m256i *)(inb - str1));

242

const __m256i inb0 = _mm256_loadu_si256((const __m256i *)(inb));

243

step1a[0] = _mm256_add_epi16(ina0, inb0);

244

step1a[1] = _mm256_add_epi16(ina1, inb1);

245

step1a[2] = _mm256_add_epi16(ina2, inb2);

246

step1a[3] = _mm256_add_epi16(ina3, inb3);

247

step1b[-3] = _mm256_sub_epi16(ina3, inb3);

248

step1b[-2] = _mm256_sub_epi16(ina2, inb2);

249

step1b[-1] = _mm256_sub_epi16(ina1, inb1);

250

step1b[-0] = _mm256_sub_epi16(ina0, inb0);

251

step1a[0] = _mm256_slli_epi16(step1a[0], 2);

252

step1a[1] = _mm256_slli_epi16(step1a[1], 2);

253

step1a[2] = _mm256_slli_epi16(step1a[2], 2);

254

step1a[3] = _mm256_slli_epi16(step1a[3], 2);

255

step1b[-3] = _mm256_slli_epi16(step1b[-3], 2);

256

step1b[-2] = _mm256_slli_epi16(step1b[-2], 2);

257

step1b[-1] = _mm256_slli_epi16(step1b[-1], 2);

258

step1b[-0] = _mm256_slli_epi16(step1b[-0], 2);

259

}

260

} else {

261

int16_t *in = &intermediate[column_start];

262

// step1[i] = in[ 0 * 32] + in[(32 - 1) * 32];

263

// Note: using the same approach as above to have common offset is

264

// counter-productive as all offsets can be calculated at compile

265

// time.

266

// Note: the next four blocks could be in a loop. That would help the

267

// instruction cache but is actually slower.

268

{

269

__m256i in00 = _mm256_loadu_si256((const __m256i *)(in + 0 * 32));

270

__m256i in01 = _mm256_loadu_si256((const __m256i *)(in + 1 * 32));

271

__m256i in02 = _mm256_loadu_si256((const __m256i *)(in + 2 * 32));

272

__m256i in03 = _mm256_loadu_si256((const __m256i *)(in + 3 * 32));

273

__m256i in28 = _mm256_loadu_si256((const __m256i *)(in + 28 * 32));

274

__m256i in29 = _mm256_loadu_si256((const __m256i *)(in + 29 * 32));

275

__m256i in30 = _mm256_loadu_si256((const __m256i *)(in + 30 * 32));

276

__m256i in31 = _mm256_loadu_si256((const __m256i *)(in + 31 * 32));

277

step1[0] = _mm256_add_epi16(in00, in31);

278

step1[1] = _mm256_add_epi16(in01, in30);

279

step1[2] = _mm256_add_epi16(in02, in29);

280

step1[3] = _mm256_add_epi16(in03, in28);

281

step1[28] = _mm256_sub_epi16(in03, in28);

282

step1[29] = _mm256_sub_epi16(in02, in29);

283

step1[30] = _mm256_sub_epi16(in01, in30);

284

step1[31] = _mm256_sub_epi16(in00, in31);

285

}

286

{

287

__m256i in04 = _mm256_loadu_si256((const __m256i *)(in + 4 * 32));

288

__m256i in05 = _mm256_loadu_si256((const __m256i *)(in + 5 * 32));

289

__m256i in06 = _mm256_loadu_si256((const __m256i *)(in + 6 * 32));

290

__m256i in07 = _mm256_loadu_si256((const __m256i *)(in + 7 * 32));

291

__m256i in24 = _mm256_loadu_si256((const __m256i *)(in + 24 * 32));

292

__m256i in25 = _mm256_loadu_si256((const __m256i *)(in + 25 * 32));

293

__m256i in26 = _mm256_loadu_si256((const __m256i *)(in + 26 * 32));

294

__m256i in27 = _mm256_loadu_si256((const __m256i *)(in + 27 * 32));

295

step1[4] = _mm256_add_epi16(in04, in27);

296

step1[5] = _mm256_add_epi16(in05, in26);

297

step1[6] = _mm256_add_epi16(in06, in25);

298

step1[7] = _mm256_add_epi16(in07, in24);

299

step1[24] = _mm256_sub_epi16(in07, in24);

300

step1[25] = _mm256_sub_epi16(in06, in25);

301

step1[26] = _mm256_sub_epi16(in05, in26);

302

step1[27] = _mm256_sub_epi16(in04, in27);

303

}

304

{

305

__m256i in08 = _mm256_loadu_si256((const __m256i *)(in + 8 * 32));

306

__m256i in09 = _mm256_loadu_si256((const __m256i *)(in + 9 * 32));

307

__m256i in10 = _mm256_loadu_si256((const __m256i *)(in + 10 * 32));

308

__m256i in11 = _mm256_loadu_si256((const __m256i *)(in + 11 * 32));

309

__m256i in20 = _mm256_loadu_si256((const __m256i *)(in + 20 * 32));

310

__m256i in21 = _mm256_loadu_si256((const __m256i *)(in + 21 * 32));

311

__m256i in22 = _mm256_loadu_si256((const __m256i *)(in + 22 * 32));

312

__m256i in23 = _mm256_loadu_si256((const __m256i *)(in + 23 * 32));

313

step1[8] = _mm256_add_epi16(in08, in23);

314

step1[9] = _mm256_add_epi16(in09, in22);

315

step1[10] = _mm256_add_epi16(in10, in21);

316

step1[11] = _mm256_add_epi16(in11, in20);

317

step1[20] = _mm256_sub_epi16(in11, in20);

318

step1[21] = _mm256_sub_epi16(in10, in21);

319

step1[22] = _mm256_sub_epi16(in09, in22);

320

step1[23] = _mm256_sub_epi16(in08, in23);

321

}

322

{

323

__m256i in12 = _mm256_loadu_si256((const __m256i *)(in + 12 * 32));

324

__m256i in13 = _mm256_loadu_si256((const __m256i *)(in + 13 * 32));

325

__m256i in14 = _mm256_loadu_si256((const __m256i *)(in + 14 * 32));

326

__m256i in15 = _mm256_loadu_si256((const __m256i *)(in + 15 * 32));

327

__m256i in16 = _mm256_loadu_si256((const __m256i *)(in + 16 * 32));

328

__m256i in17 = _mm256_loadu_si256((const __m256i *)(in + 17 * 32));

329

__m256i in18 = _mm256_loadu_si256((const __m256i *)(in + 18 * 32));

330

__m256i in19 = _mm256_loadu_si256((const __m256i *)(in + 19 * 32));

331

step1[12] = _mm256_add_epi16(in12, in19);

332

step1[13] = _mm256_add_epi16(in13, in18);

333

step1[14] = _mm256_add_epi16(in14, in17);

334

step1[15] = _mm256_add_epi16(in15, in16);

335

step1[16] = _mm256_sub_epi16(in15, in16);

336

step1[17] = _mm256_sub_epi16(in14, in17);

337

step1[18] = _mm256_sub_epi16(in13, in18);

338

step1[19] = _mm256_sub_epi16(in12, in19);

}

}

// Stage 2

{

step2[0] = _mm256_add_epi16(step1[0], step1[15]);

344

step2[1] = _mm256_add_epi16(step1[1], step1[14]);

345

step2[2] = _mm256_add_epi16(step1[2], step1[13]);

346

step2[3] = _mm256_add_epi16(step1[3], step1[12]);

347

step2[4] = _mm256_add_epi16(step1[4], step1[11]);

348

step2[5] = _mm256_add_epi16(step1[5], step1[10]);

349

step2[6] = _mm256_add_epi16(step1[6], step1[9]);

350

step2[7] = _mm256_add_epi16(step1[7], step1[8]);

351

step2[8] = _mm256_sub_epi16(step1[7], step1[8]);

352

step2[9] = _mm256_sub_epi16(step1[6], step1[9]);

353

step2[10] = _mm256_sub_epi16(step1[5], step1[10]);

354

step2[11] = _mm256_sub_epi16(step1[4], step1[11]);

355

step2[12] = _mm256_sub_epi16(step1[3], step1[12]);

356

step2[13] = _mm256_sub_epi16(step1[2], step1[13]);

357

step2[14] = _mm256_sub_epi16(step1[1], step1[14]);

358

step2[15] = _mm256_sub_epi16(step1[0], step1[15]);

359

}

360

{

361

const __m256i s2_20_0 = _mm256_unpacklo_epi16(step1[27], step1[20]);

362

const __m256i s2_20_1 = _mm256_unpackhi_epi16(step1[27], step1[20]);

363

const __m256i s2_21_0 = _mm256_unpacklo_epi16(step1[26], step1[21]);

364

const __m256i s2_21_1 = _mm256_unpackhi_epi16(step1[26], step1[21]);

365

const __m256i s2_22_0 = _mm256_unpacklo_epi16(step1[25], step1[22]);

366

const __m256i s2_22_1 = _mm256_unpackhi_epi16(step1[25], step1[22]);

367

const __m256i s2_23_0 = _mm256_unpacklo_epi16(step1[24], step1[23]);

368

const __m256i s2_23_1 = _mm256_unpackhi_epi16(step1[24], step1[23]);

369

const __m256i s2_20_2 = _mm256_madd_epi16(s2_20_0, k__cospi_p16_m16);

370

const __m256i s2_20_3 = _mm256_madd_epi16(s2_20_1, k__cospi_p16_m16);

371

const __m256i s2_21_2 = _mm256_madd_epi16(s2_21_0, k__cospi_p16_m16);

372

const __m256i s2_21_3 = _mm256_madd_epi16(s2_21_1, k__cospi_p16_m16);

373

const __m256i s2_22_2 = _mm256_madd_epi16(s2_22_0, k__cospi_p16_m16);

374

const __m256i s2_22_3 = _mm256_madd_epi16(s2_22_1, k__cospi_p16_m16);

375

const __m256i s2_23_2 = _mm256_madd_epi16(s2_23_0, k__cospi_p16_m16);

376

const __m256i s2_23_3 = _mm256_madd_epi16(s2_23_1, k__cospi_p16_m16);

377

const __m256i s2_24_2 = _mm256_madd_epi16(s2_23_0, k__cospi_p16_p16);

378

const __m256i s2_24_3 = _mm256_madd_epi16(s2_23_1, k__cospi_p16_p16);

379

const __m256i s2_25_2 = _mm256_madd_epi16(s2_22_0, k__cospi_p16_p16);

380

const __m256i s2_25_3 = _mm256_madd_epi16(s2_22_1, k__cospi_p16_p16);

381

const __m256i s2_26_2 = _mm256_madd_epi16(s2_21_0, k__cospi_p16_p16);

382

const __m256i s2_26_3 = _mm256_madd_epi16(s2_21_1, k__cospi_p16_p16);

383

const __m256i s2_27_2 = _mm256_madd_epi16(s2_20_0, k__cospi_p16_p16);

384

const __m256i s2_27_3 = _mm256_madd_epi16(s2_20_1, k__cospi_p16_p16);

385

// dct_const_round_shift

386

const __m256i s2_20_4 =

387

_mm256_add_epi32(s2_20_2, k__DCT_CONST_ROUNDING);

388

const __m256i s2_20_5 =

389

_mm256_add_epi32(s2_20_3, k__DCT_CONST_ROUNDING);

390

const __m256i s2_21_4 =

391

_mm256_add_epi32(s2_21_2, k__DCT_CONST_ROUNDING);

392

const __m256i s2_21_5 =

393

_mm256_add_epi32(s2_21_3, k__DCT_CONST_ROUNDING);

394

const __m256i s2_22_4 =

395

_mm256_add_epi32(s2_22_2, k__DCT_CONST_ROUNDING);

396

const __m256i s2_22_5 =

397

_mm256_add_epi32(s2_22_3, k__DCT_CONST_ROUNDING);

398

const __m256i s2_23_4 =

399

_mm256_add_epi32(s2_23_2, k__DCT_CONST_ROUNDING);

400

const __m256i s2_23_5 =

401

_mm256_add_epi32(s2_23_3, k__DCT_CONST_ROUNDING);

402

const __m256i s2_24_4 =

403

_mm256_add_epi32(s2_24_2, k__DCT_CONST_ROUNDING);

404

const __m256i s2_24_5 =

405

_mm256_add_epi32(s2_24_3, k__DCT_CONST_ROUNDING);

406

const __m256i s2_25_4 =

407

_mm256_add_epi32(s2_25_2, k__DCT_CONST_ROUNDING);

408

const __m256i s2_25_5 =

409

_mm256_add_epi32(s2_25_3, k__DCT_CONST_ROUNDING);

410

const __m256i s2_26_4 =

411

_mm256_add_epi32(s2_26_2, k__DCT_CONST_ROUNDING);

412

const __m256i s2_26_5 =

413

_mm256_add_epi32(s2_26_3, k__DCT_CONST_ROUNDING);

414

const __m256i s2_27_4 =

415

_mm256_add_epi32(s2_27_2, k__DCT_CONST_ROUNDING);

416

const __m256i s2_27_5 =

417

_mm256_add_epi32(s2_27_3, k__DCT_CONST_ROUNDING);

418

const __m256i s2_20_6 = _mm256_srai_epi32(s2_20_4, DCT_CONST_BITS);

419

const __m256i s2_20_7 = _mm256_srai_epi32(s2_20_5, DCT_CONST_BITS);

420

const __m256i s2_21_6 = _mm256_srai_epi32(s2_21_4, DCT_CONST_BITS);

421

const __m256i s2_21_7 = _mm256_srai_epi32(s2_21_5, DCT_CONST_BITS);

422

const __m256i s2_22_6 = _mm256_srai_epi32(s2_22_4, DCT_CONST_BITS);

423

const __m256i s2_22_7 = _mm256_srai_epi32(s2_22_5, DCT_CONST_BITS);

424

const __m256i s2_23_6 = _mm256_srai_epi32(s2_23_4, DCT_CONST_BITS);

425

const __m256i s2_23_7 = _mm256_srai_epi32(s2_23_5, DCT_CONST_BITS);

426

const __m256i s2_24_6 = _mm256_srai_epi32(s2_24_4, DCT_CONST_BITS);

427

const __m256i s2_24_7 = _mm256_srai_epi32(s2_24_5, DCT_CONST_BITS);

428

const __m256i s2_25_6 = _mm256_srai_epi32(s2_25_4, DCT_CONST_BITS);

429

const __m256i s2_25_7 = _mm256_srai_epi32(s2_25_5, DCT_CONST_BITS);

430

const __m256i s2_26_6 = _mm256_srai_epi32(s2_26_4, DCT_CONST_BITS);

431

const __m256i s2_26_7 = _mm256_srai_epi32(s2_26_5, DCT_CONST_BITS);

432

const __m256i s2_27_6 = _mm256_srai_epi32(s2_27_4, DCT_CONST_BITS);

433

const __m256i s2_27_7 = _mm256_srai_epi32(s2_27_5, DCT_CONST_BITS);

434

// Combine

435

step2[20] = _mm256_packs_epi32(s2_20_6, s2_20_7);

436

step2[21] = _mm256_packs_epi32(s2_21_6, s2_21_7);

437

step2[22] = _mm256_packs_epi32(s2_22_6, s2_22_7);

438

step2[23] = _mm256_packs_epi32(s2_23_6, s2_23_7);

439

step2[24] = _mm256_packs_epi32(s2_24_6, s2_24_7);

440

step2[25] = _mm256_packs_epi32(s2_25_6, s2_25_7);

441

step2[26] = _mm256_packs_epi32(s2_26_6, s2_26_7);

442

step2[27] = _mm256_packs_epi32(s2_27_6, s2_27_7);

443

}

444

445

#if !FDCT32x32_HIGH_PRECISION

446

// dump the magnitude by half, hence the intermediate values are within

447

// the range of 16 bits.

448

if (1 == pass) {

449

__m256i s3_00_0 = _mm256_cmpgt_epi16(kZero, step2[0]);

450

__m256i s3_01_0 = _mm256_cmpgt_epi16(kZero, step2[1]);

451

__m256i s3_02_0 = _mm256_cmpgt_epi16(kZero, step2[2]);

452

__m256i s3_03_0 = _mm256_cmpgt_epi16(kZero, step2[3]);

453

__m256i s3_04_0 = _mm256_cmpgt_epi16(kZero, step2[4]);

454

__m256i s3_05_0 = _mm256_cmpgt_epi16(kZero, step2[5]);

455

__m256i s3_06_0 = _mm256_cmpgt_epi16(kZero, step2[6]);

456

__m256i s3_07_0 = _mm256_cmpgt_epi16(kZero, step2[7]);

457

__m256i s2_08_0 = _mm256_cmpgt_epi16(kZero, step2[8]);

458

__m256i s2_09_0 = _mm256_cmpgt_epi16(kZero, step2[9]);

459

__m256i s3_10_0 = _mm256_cmpgt_epi16(kZero, step2[10]);

460

__m256i s3_11_0 = _mm256_cmpgt_epi16(kZero, step2[11]);

461

__m256i s3_12_0 = _mm256_cmpgt_epi16(kZero, step2[12]);

462

__m256i s3_13_0 = _mm256_cmpgt_epi16(kZero, step2[13]);

463

__m256i s2_14_0 = _mm256_cmpgt_epi16(kZero, step2[14]);

464

__m256i s2_15_0 = _mm256_cmpgt_epi16(kZero, step2[15]);

465

__m256i s3_16_0 = _mm256_cmpgt_epi16(kZero, step1[16]);

466

__m256i s3_17_0 = _mm256_cmpgt_epi16(kZero, step1[17]);

467

__m256i s3_18_0 = _mm256_cmpgt_epi16(kZero, step1[18]);

468

__m256i s3_19_0 = _mm256_cmpgt_epi16(kZero, step1[19]);

469

__m256i s3_20_0 = _mm256_cmpgt_epi16(kZero, step2[20]);

470

__m256i s3_21_0 = _mm256_cmpgt_epi16(kZero, step2[21]);

471

__m256i s3_22_0 = _mm256_cmpgt_epi16(kZero, step2[22]);

472

__m256i s3_23_0 = _mm256_cmpgt_epi16(kZero, step2[23]);

473

__m256i s3_24_0 = _mm256_cmpgt_epi16(kZero, step2[24]);

474

__m256i s3_25_0 = _mm256_cmpgt_epi16(kZero, step2[25]);

475

__m256i s3_26_0 = _mm256_cmpgt_epi16(kZero, step2[26]);

476

__m256i s3_27_0 = _mm256_cmpgt_epi16(kZero, step2[27]);

477

__m256i s3_28_0 = _mm256_cmpgt_epi16(kZero, step1[28]);

478

__m256i s3_29_0 = _mm256_cmpgt_epi16(kZero, step1[29]);

479

__m256i s3_30_0 = _mm256_cmpgt_epi16(kZero, step1[30]);

480

__m256i s3_31_0 = _mm256_cmpgt_epi16(kZero, step1[31]);

481

482

step2[0] = _mm256_sub_epi16(step2[0], s3_00_0);

483

step2[1] = _mm256_sub_epi16(step2[1], s3_01_0);

484

step2[2] = _mm256_sub_epi16(step2[2], s3_02_0);

485

step2[3] = _mm256_sub_epi16(step2[3], s3_03_0);

486

step2[4] = _mm256_sub_epi16(step2[4], s3_04_0);

487

step2[5] = _mm256_sub_epi16(step2[5], s3_05_0);

488

step2[6] = _mm256_sub_epi16(step2[6], s3_06_0);

489

step2[7] = _mm256_sub_epi16(step2[7], s3_07_0);

490

step2[8] = _mm256_sub_epi16(step2[8], s2_08_0);

491

step2[9] = _mm256_sub_epi16(step2[9], s2_09_0);

492

step2[10] = _mm256_sub_epi16(step2[10], s3_10_0);

493

step2[11] = _mm256_sub_epi16(step2[11], s3_11_0);

494

step2[12] = _mm256_sub_epi16(step2[12], s3_12_0);

495

step2[13] = _mm256_sub_epi16(step2[13], s3_13_0);

496

step2[14] = _mm256_sub_epi16(step2[14], s2_14_0);

497

step2[15] = _mm256_sub_epi16(step2[15], s2_15_0);

498

step1[16] = _mm256_sub_epi16(step1[16], s3_16_0);

499

step1[17] = _mm256_sub_epi16(step1[17], s3_17_0);

500

step1[18] = _mm256_sub_epi16(step1[18], s3_18_0);

501

step1[19] = _mm256_sub_epi16(step1[19], s3_19_0);

502

step2[20] = _mm256_sub_epi16(step2[20], s3_20_0);

503

step2[21] = _mm256_sub_epi16(step2[21], s3_21_0);

504

step2[22] = _mm256_sub_epi16(step2[22], s3_22_0);

505

step2[23] = _mm256_sub_epi16(step2[23], s3_23_0);

506

step2[24] = _mm256_sub_epi16(step2[24], s3_24_0);

507

step2[25] = _mm256_sub_epi16(step2[25], s3_25_0);

508

step2[26] = _mm256_sub_epi16(step2[26], s3_26_0);

509

step2[27] = _mm256_sub_epi16(step2[27], s3_27_0);

510

step1[28] = _mm256_sub_epi16(step1[28], s3_28_0);

511

step1[29] = _mm256_sub_epi16(step1[29], s3_29_0);

512

step1[30] = _mm256_sub_epi16(step1[30], s3_30_0);

513

step1[31] = _mm256_sub_epi16(step1[31], s3_31_0);

514

515

step2[0] = _mm256_add_epi16(step2[0], kOne);

516

step2[1] = _mm256_add_epi16(step2[1], kOne);

517

step2[2] = _mm256_add_epi16(step2[2], kOne);

518

step2[3] = _mm256_add_epi16(step2[3], kOne);

519

step2[4] = _mm256_add_epi16(step2[4], kOne);

520

step2[5] = _mm256_add_epi16(step2[5], kOne);

521

step2[6] = _mm256_add_epi16(step2[6], kOne);

522

step2[7] = _mm256_add_epi16(step2[7], kOne);

523

step2[8] = _mm256_add_epi16(step2[8], kOne);

524

step2[9] = _mm256_add_epi16(step2[9], kOne);

525

step2[10] = _mm256_add_epi16(step2[10], kOne);

526

step2[11] = _mm256_add_epi16(step2[11], kOne);

527

step2[12] = _mm256_add_epi16(step2[12], kOne);

528

step2[13] = _mm256_add_epi16(step2[13], kOne);

529

step2[14] = _mm256_add_epi16(step2[14], kOne);

530

step2[15] = _mm256_add_epi16(step2[15], kOne);

531

step1[16] = _mm256_add_epi16(step1[16], kOne);

532

step1[17] = _mm256_add_epi16(step1[17], kOne);

533

step1[18] = _mm256_add_epi16(step1[18], kOne);

534

step1[19] = _mm256_add_epi16(step1[19], kOne);

535

step2[20] = _mm256_add_epi16(step2[20], kOne);

536

step2[21] = _mm256_add_epi16(step2[21], kOne);

537

step2[22] = _mm256_add_epi16(step2[22], kOne);

538

step2[23] = _mm256_add_epi16(step2[23], kOne);

539

step2[24] = _mm256_add_epi16(step2[24], kOne);

540

step2[25] = _mm256_add_epi16(step2[25], kOne);

541

step2[26] = _mm256_add_epi16(step2[26], kOne);

542

step2[27] = _mm256_add_epi16(step2[27], kOne);

543

step1[28] = _mm256_add_epi16(step1[28], kOne);

544

step1[29] = _mm256_add_epi16(step1[29], kOne);

545

step1[30] = _mm256_add_epi16(step1[30], kOne);

546

step1[31] = _mm256_add_epi16(step1[31], kOne);

547

548

step2[0] = _mm256_srai_epi16(step2[0], 2);

549

step2[1] = _mm256_srai_epi16(step2[1], 2);

550

step2[2] = _mm256_srai_epi16(step2[2], 2);

551

step2[3] = _mm256_srai_epi16(step2[3], 2);

552

step2[4] = _mm256_srai_epi16(step2[4], 2);

553

step2[5] = _mm256_srai_epi16(step2[5], 2);

554

step2[6] = _mm256_srai_epi16(step2[6], 2);

555

step2[7] = _mm256_srai_epi16(step2[7], 2);

556

step2[8] = _mm256_srai_epi16(step2[8], 2);

557

step2[9] = _mm256_srai_epi16(step2[9], 2);

558

step2[10] = _mm256_srai_epi16(step2[10], 2);

559

step2[11] = _mm256_srai_epi16(step2[11], 2);

560

step2[12] = _mm256_srai_epi16(step2[12], 2);

561

step2[13] = _mm256_srai_epi16(step2[13], 2);

562

step2[14] = _mm256_srai_epi16(step2[14], 2);

563

step2[15] = _mm256_srai_epi16(step2[15], 2);

564

step1[16] = _mm256_srai_epi16(step1[16], 2);

565

step1[17] = _mm256_srai_epi16(step1[17], 2);

566

step1[18] = _mm256_srai_epi16(step1[18], 2);

567

step1[19] = _mm256_srai_epi16(step1[19], 2);

568

step2[20] = _mm256_srai_epi16(step2[20], 2);

569

step2[21] = _mm256_srai_epi16(step2[21], 2);

570

step2[22] = _mm256_srai_epi16(step2[22], 2);

571

step2[23] = _mm256_srai_epi16(step2[23], 2);

572

step2[24] = _mm256_srai_epi16(step2[24], 2);

573

step2[25] = _mm256_srai_epi16(step2[25], 2);

574

step2[26] = _mm256_srai_epi16(step2[26], 2);

575

step2[27] = _mm256_srai_epi16(step2[27], 2);

576

step1[28] = _mm256_srai_epi16(step1[28], 2);

577

step1[29] = _mm256_srai_epi16(step1[29], 2);

578

step1[30] = _mm256_srai_epi16(step1[30], 2);

579

step1[31] = _mm256_srai_epi16(step1[31], 2);

}

#endif

#if FDCT32x32_HIGH_PRECISION

if (pass == 0) {

#endif

// Stage 3

{

step3[0] = _mm256_add_epi16(step2[(8 - 1)], step2[0]);

589

step3[1] = _mm256_add_epi16(step2[(8 - 2)], step2[1]);

590

step3[2] = _mm256_add_epi16(step2[(8 - 3)], step2[2]);

591

step3[3] = _mm256_add_epi16(step2[(8 - 4)], step2[3]);

592

step3[4] = _mm256_sub_epi16(step2[(8 - 5)], step2[4]);

593

step3[5] = _mm256_sub_epi16(step2[(8 - 6)], step2[5]);

594

step3[6] = _mm256_sub_epi16(step2[(8 - 7)], step2[6]);

595

step3[7] = _mm256_sub_epi16(step2[(8 - 8)], step2[7]);

596

}

597

{

598

const __m256i s3_10_0 = _mm256_unpacklo_epi16(step2[13], step2[10]);

599

const __m256i s3_10_1 = _mm256_unpackhi_epi16(step2[13], step2[10]);

600

const __m256i s3_11_0 = _mm256_unpacklo_epi16(step2[12], step2[11]);

601

const __m256i s3_11_1 = _mm256_unpackhi_epi16(step2[12], step2[11]);

602

const __m256i s3_10_2 = _mm256_madd_epi16(s3_10_0, k__cospi_p16_m16);

603

const __m256i s3_10_3 = _mm256_madd_epi16(s3_10_1, k__cospi_p16_m16);

604

const __m256i s3_11_2 = _mm256_madd_epi16(s3_11_0, k__cospi_p16_m16);

605

const __m256i s3_11_3 = _mm256_madd_epi16(s3_11_1, k__cospi_p16_m16);

606

const __m256i s3_12_2 = _mm256_madd_epi16(s3_11_0, k__cospi_p16_p16);

607

const __m256i s3_12_3 = _mm256_madd_epi16(s3_11_1, k__cospi_p16_p16);

608

const __m256i s3_13_2 = _mm256_madd_epi16(s3_10_0, k__cospi_p16_p16);

609

const __m256i s3_13_3 = _mm256_madd_epi16(s3_10_1, k__cospi_p16_p16);

610

// dct_const_round_shift

611

const __m256i s3_10_4 =

612

_mm256_add_epi32(s3_10_2, k__DCT_CONST_ROUNDING);

613

const __m256i s3_10_5 =

614

_mm256_add_epi32(s3_10_3, k__DCT_CONST_ROUNDING);

615

const __m256i s3_11_4 =

616

_mm256_add_epi32(s3_11_2, k__DCT_CONST_ROUNDING);

617

const __m256i s3_11_5 =

618

_mm256_add_epi32(s3_11_3, k__DCT_CONST_ROUNDING);

619

const __m256i s3_12_4 =

620

_mm256_add_epi32(s3_12_2, k__DCT_CONST_ROUNDING);

621

const __m256i s3_12_5 =

622

_mm256_add_epi32(s3_12_3, k__DCT_CONST_ROUNDING);

623

const __m256i s3_13_4 =

624

_mm256_add_epi32(s3_13_2, k__DCT_CONST_ROUNDING);

625

const __m256i s3_13_5 =

626

_mm256_add_epi32(s3_13_3, k__DCT_CONST_ROUNDING);

627

const __m256i s3_10_6 = _mm256_srai_epi32(s3_10_4, DCT_CONST_BITS);

628

const __m256i s3_10_7 = _mm256_srai_epi32(s3_10_5, DCT_CONST_BITS);

629

const __m256i s3_11_6 = _mm256_srai_epi32(s3_11_4, DCT_CONST_BITS);

630

const __m256i s3_11_7 = _mm256_srai_epi32(s3_11_5, DCT_CONST_BITS);

631

const __m256i s3_12_6 = _mm256_srai_epi32(s3_12_4, DCT_CONST_BITS);

632

const __m256i s3_12_7 = _mm256_srai_epi32(s3_12_5, DCT_CONST_BITS);

633

const __m256i s3_13_6 = _mm256_srai_epi32(s3_13_4, DCT_CONST_BITS);

634

const __m256i s3_13_7 = _mm256_srai_epi32(s3_13_5, DCT_CONST_BITS);

635

// Combine

636

step3[10] = _mm256_packs_epi32(s3_10_6, s3_10_7);

637

step3[11] = _mm256_packs_epi32(s3_11_6, s3_11_7);

638

step3[12] = _mm256_packs_epi32(s3_12_6, s3_12_7);

639

step3[13] = _mm256_packs_epi32(s3_13_6, s3_13_7);

640

}

641

{

642

step3[16] = _mm256_add_epi16(step2[23], step1[16]);

643

step3[17] = _mm256_add_epi16(step2[22], step1[17]);

644

step3[18] = _mm256_add_epi16(step2[21], step1[18]);

645

step3[19] = _mm256_add_epi16(step2[20], step1[19]);

646

step3[20] = _mm256_sub_epi16(step1[19], step2[20]);

647

step3[21] = _mm256_sub_epi16(step1[18], step2[21]);

648

step3[22] = _mm256_sub_epi16(step1[17], step2[22]);

649

step3[23] = _mm256_sub_epi16(step1[16], step2[23]);

650

step3[24] = _mm256_sub_epi16(step1[31], step2[24]);

651

step3[25] = _mm256_sub_epi16(step1[30], step2[25]);

652

step3[26] = _mm256_sub_epi16(step1[29], step2[26]);

653

step3[27] = _mm256_sub_epi16(step1[28], step2[27]);

654

step3[28] = _mm256_add_epi16(step2[27], step1[28]);

655

step3[29] = _mm256_add_epi16(step2[26], step1[29]);

656

step3[30] = _mm256_add_epi16(step2[25], step1[30]);

657

step3[31] = _mm256_add_epi16(step2[24], step1[31]);

}

// Stage 4

{

step1[0] = _mm256_add_epi16(step3[3], step3[0]);

663

step1[1] = _mm256_add_epi16(step3[2], step3[1]);

664

step1[2] = _mm256_sub_epi16(step3[1], step3[2]);

665

step1[3] = _mm256_sub_epi16(step3[0], step3[3]);

666

step1[8] = _mm256_add_epi16(step3[11], step2[8]);

667

step1[9] = _mm256_add_epi16(step3[10], step2[9]);

668

step1[10] = _mm256_sub_epi16(step2[9], step3[10]);

669

step1[11] = _mm256_sub_epi16(step2[8], step3[11]);

670

step1[12] = _mm256_sub_epi16(step2[15], step3[12]);

671

step1[13] = _mm256_sub_epi16(step2[14], step3[13]);

672

step1[14] = _mm256_add_epi16(step3[13], step2[14]);

673

step1[15] = _mm256_add_epi16(step3[12], step2[15]);

674

}

675

{

676

const __m256i s1_05_0 = _mm256_unpacklo_epi16(step3[6], step3[5]);

677

const __m256i s1_05_1 = _mm256_unpackhi_epi16(step3[6], step3[5]);

678

const __m256i s1_05_2 = _mm256_madd_epi16(s1_05_0, k__cospi_p16_m16);

679

const __m256i s1_05_3 = _mm256_madd_epi16(s1_05_1, k__cospi_p16_m16);

680

const __m256i s1_06_2 = _mm256_madd_epi16(s1_05_0, k__cospi_p16_p16);

681

const __m256i s1_06_3 = _mm256_madd_epi16(s1_05_1, k__cospi_p16_p16);

682

// dct_const_round_shift

683

const __m256i s1_05_4 =

684

_mm256_add_epi32(s1_05_2, k__DCT_CONST_ROUNDING);

685

const __m256i s1_05_5 =

686

_mm256_add_epi32(s1_05_3, k__DCT_CONST_ROUNDING);

687

const __m256i s1_06_4 =

688

_mm256_add_epi32(s1_06_2, k__DCT_CONST_ROUNDING);

689

const __m256i s1_06_5 =

690

_mm256_add_epi32(s1_06_3, k__DCT_CONST_ROUNDING);

691

const __m256i s1_05_6 = _mm256_srai_epi32(s1_05_4, DCT_CONST_BITS);

692

const __m256i s1_05_7 = _mm256_srai_epi32(s1_05_5, DCT_CONST_BITS);

693

const __m256i s1_06_6 = _mm256_srai_epi32(s1_06_4, DCT_CONST_BITS);

694

const __m256i s1_06_7 = _mm256_srai_epi32(s1_06_5, DCT_CONST_BITS);

695

// Combine

696

step1[5] = _mm256_packs_epi32(s1_05_6, s1_05_7);

697

step1[6] = _mm256_packs_epi32(s1_06_6, s1_06_7);

698

}

699

{

700

const __m256i s1_18_0 = _mm256_unpacklo_epi16(step3[18], step3[29]);

701

const __m256i s1_18_1 = _mm256_unpackhi_epi16(step3[18], step3[29]);

702

const __m256i s1_19_0 = _mm256_unpacklo_epi16(step3[19], step3[28]);

703

const __m256i s1_19_1 = _mm256_unpackhi_epi16(step3[19], step3[28]);

704

const __m256i s1_20_0 = _mm256_unpacklo_epi16(step3[20], step3[27]);

705

const __m256i s1_20_1 = _mm256_unpackhi_epi16(step3[20], step3[27]);

706

const __m256i s1_21_0 = _mm256_unpacklo_epi16(step3[21], step3[26]);

707

const __m256i s1_21_1 = _mm256_unpackhi_epi16(step3[21], step3[26]);

708

const __m256i s1_18_2 = _mm256_madd_epi16(s1_18_0, k__cospi_m08_p24);

709

const __m256i s1_18_3 = _mm256_madd_epi16(s1_18_1, k__cospi_m08_p24);

710

const __m256i s1_19_2 = _mm256_madd_epi16(s1_19_0, k__cospi_m08_p24);

711

const __m256i s1_19_3 = _mm256_madd_epi16(s1_19_1, k__cospi_m08_p24);

712

const __m256i s1_20_2 = _mm256_madd_epi16(s1_20_0, k__cospi_m24_m08);

713

const __m256i s1_20_3 = _mm256_madd_epi16(s1_20_1, k__cospi_m24_m08);

714

const __m256i s1_21_2 = _mm256_madd_epi16(s1_21_0, k__cospi_m24_m08);

715

const __m256i s1_21_3 = _mm256_madd_epi16(s1_21_1, k__cospi_m24_m08);

716

const __m256i s1_26_2 = _mm256_madd_epi16(s1_21_0, k__cospi_m08_p24);

717

const __m256i s1_26_3 = _mm256_madd_epi16(s1_21_1, k__cospi_m08_p24);

718

const __m256i s1_27_2 = _mm256_madd_epi16(s1_20_0, k__cospi_m08_p24);

719

const __m256i s1_27_3 = _mm256_madd_epi16(s1_20_1, k__cospi_m08_p24);

720

const __m256i s1_28_2 = _mm256_madd_epi16(s1_19_0, k__cospi_p24_p08);

721

const __m256i s1_28_3 = _mm256_madd_epi16(s1_19_1, k__cospi_p24_p08);

722

const __m256i s1_29_2 = _mm256_madd_epi16(s1_18_0, k__cospi_p24_p08);

723

const __m256i s1_29_3 = _mm256_madd_epi16(s1_18_1, k__cospi_p24_p08);

724

// dct_const_round_shift

725

const __m256i s1_18_4 =

726

_mm256_add_epi32(s1_18_2, k__DCT_CONST_ROUNDING);

727

const __m256i s1_18_5 =

728

_mm256_add_epi32(s1_18_3, k__DCT_CONST_ROUNDING);

729

const __m256i s1_19_4 =

730

_mm256_add_epi32(s1_19_2, k__DCT_CONST_ROUNDING);

731

const __m256i s1_19_5 =

732

_mm256_add_epi32(s1_19_3, k__DCT_CONST_ROUNDING);

733

const __m256i s1_20_4 =

734

_mm256_add_epi32(s1_20_2, k__DCT_CONST_ROUNDING);

735

const __m256i s1_20_5 =

736

_mm256_add_epi32(s1_20_3, k__DCT_CONST_ROUNDING);

737

const __m256i s1_21_4 =

738

_mm256_add_epi32(s1_21_2, k__DCT_CONST_ROUNDING);

739

const __m256i s1_21_5 =

740

_mm256_add_epi32(s1_21_3, k__DCT_CONST_ROUNDING);

741

const __m256i s1_26_4 =

742

_mm256_add_epi32(s1_26_2, k__DCT_CONST_ROUNDING);

743

const __m256i s1_26_5 =

744

_mm256_add_epi32(s1_26_3, k__DCT_CONST_ROUNDING);

745

const __m256i s1_27_4 =

746

_mm256_add_epi32(s1_27_2, k__DCT_CONST_ROUNDING);

747

const __m256i s1_27_5 =

748

_mm256_add_epi32(s1_27_3, k__DCT_CONST_ROUNDING);

749

const __m256i s1_28_4 =

750

_mm256_add_epi32(s1_28_2, k__DCT_CONST_ROUNDING);

751

const __m256i s1_28_5 =

752

_mm256_add_epi32(s1_28_3, k__DCT_CONST_ROUNDING);

753

const __m256i s1_29_4 =

754

_mm256_add_epi32(s1_29_2, k__DCT_CONST_ROUNDING);

755

const __m256i s1_29_5 =

756

_mm256_add_epi32(s1_29_3, k__DCT_CONST_ROUNDING);

757

const __m256i s1_18_6 = _mm256_srai_epi32(s1_18_4, DCT_CONST_BITS);

758

const __m256i s1_18_7 = _mm256_srai_epi32(s1_18_5, DCT_CONST_BITS);

759

const __m256i s1_19_6 = _mm256_srai_epi32(s1_19_4, DCT_CONST_BITS);

760

const __m256i s1_19_7 = _mm256_srai_epi32(s1_19_5, DCT_CONST_BITS);

761

const __m256i s1_20_6 = _mm256_srai_epi32(s1_20_4, DCT_CONST_BITS);

762

const __m256i s1_20_7 = _mm256_srai_epi32(s1_20_5, DCT_CONST_BITS);

763

const __m256i s1_21_6 = _mm256_srai_epi32(s1_21_4, DCT_CONST_BITS);

764

const __m256i s1_21_7 = _mm256_srai_epi32(s1_21_5, DCT_CONST_BITS);

765

const __m256i s1_26_6 = _mm256_srai_epi32(s1_26_4, DCT_CONST_BITS);

766

const __m256i s1_26_7 = _mm256_srai_epi32(s1_26_5, DCT_CONST_BITS);

767

const __m256i s1_27_6 = _mm256_srai_epi32(s1_27_4, DCT_CONST_BITS);

768

const __m256i s1_27_7 = _mm256_srai_epi32(s1_27_5, DCT_CONST_BITS);

769

const __m256i s1_28_6 = _mm256_srai_epi32(s1_28_4, DCT_CONST_BITS);

770

const __m256i s1_28_7 = _mm256_srai_epi32(s1_28_5, DCT_CONST_BITS);

771

const __m256i s1_29_6 = _mm256_srai_epi32(s1_29_4, DCT_CONST_BITS);

772

const __m256i s1_29_7 = _mm256_srai_epi32(s1_29_5, DCT_CONST_BITS);

773

// Combine

774

step1[18] = _mm256_packs_epi32(s1_18_6, s1_18_7);

775

step1[19] = _mm256_packs_epi32(s1_19_6, s1_19_7);

776

step1[20] = _mm256_packs_epi32(s1_20_6, s1_20_7);

777

step1[21] = _mm256_packs_epi32(s1_21_6, s1_21_7);

778

step1[26] = _mm256_packs_epi32(s1_26_6, s1_26_7);

779

step1[27] = _mm256_packs_epi32(s1_27_6, s1_27_7);

780

step1[28] = _mm256_packs_epi32(s1_28_6, s1_28_7);

781

step1[29] = _mm256_packs_epi32(s1_29_6, s1_29_7);

}

// Stage 5

{

step2[4] = _mm256_add_epi16(step1[5], step3[4]);

786

step2[5] = _mm256_sub_epi16(step3[4], step1[5]);

787

step2[6] = _mm256_sub_epi16(step3[7], step1[6]);

788

step2[7] = _mm256_add_epi16(step1[6], step3[7]);

789

}

790

{

791

const __m256i out_00_0 = _mm256_unpacklo_epi16(step1[0], step1[1]);

792

const __m256i out_00_1 = _mm256_unpackhi_epi16(step1[0], step1[1]);

793

const __m256i out_08_0 = _mm256_unpacklo_epi16(step1[2], step1[3]);

794

const __m256i out_08_1 = _mm256_unpackhi_epi16(step1[2], step1[3]);

795

const __m256i out_00_2 =

796

_mm256_madd_epi16(out_00_0, k__cospi_p16_p16);

797

const __m256i out_00_3 =

798

_mm256_madd_epi16(out_00_1, k__cospi_p16_p16);

799

const __m256i out_16_2 =

800

_mm256_madd_epi16(out_00_0, k__cospi_p16_m16);

801

const __m256i out_16_3 =

802

_mm256_madd_epi16(out_00_1, k__cospi_p16_m16);

803

const __m256i out_08_2 =

804

_mm256_madd_epi16(out_08_0, k__cospi_p24_p08);

805

const __m256i out_08_3 =

806

_mm256_madd_epi16(out_08_1, k__cospi_p24_p08);

807

const __m256i out_24_2 =

808

_mm256_madd_epi16(out_08_0, k__cospi_m08_p24);

809

const __m256i out_24_3 =

810

_mm256_madd_epi16(out_08_1, k__cospi_m08_p24);

811

// dct_const_round_shift

812

const __m256i out_00_4 =

813

_mm256_add_epi32(out_00_2, k__DCT_CONST_ROUNDING);

814

const __m256i out_00_5 =

815

_mm256_add_epi32(out_00_3, k__DCT_CONST_ROUNDING);

816

const __m256i out_16_4 =

817

_mm256_add_epi32(out_16_2, k__DCT_CONST_ROUNDING);

818

const __m256i out_16_5 =

819

_mm256_add_epi32(out_16_3, k__DCT_CONST_ROUNDING);

820

const __m256i out_08_4 =

821

_mm256_add_epi32(out_08_2, k__DCT_CONST_ROUNDING);

822

const __m256i out_08_5 =

823

_mm256_add_epi32(out_08_3, k__DCT_CONST_ROUNDING);

824

const __m256i out_24_4 =

825

_mm256_add_epi32(out_24_2, k__DCT_CONST_ROUNDING);

826

const __m256i out_24_5 =

827

_mm256_add_epi32(out_24_3, k__DCT_CONST_ROUNDING);

828

const __m256i out_00_6 = _mm256_srai_epi32(out_00_4, DCT_CONST_BITS);

829

const __m256i out_00_7 = _mm256_srai_epi32(out_00_5, DCT_CONST_BITS);

830

const __m256i out_16_6 = _mm256_srai_epi32(out_16_4, DCT_CONST_BITS);

831

const __m256i out_16_7 = _mm256_srai_epi32(out_16_5, DCT_CONST_BITS);

832

const __m256i out_08_6 = _mm256_srai_epi32(out_08_4, DCT_CONST_BITS);

833

const __m256i out_08_7 = _mm256_srai_epi32(out_08_5, DCT_CONST_BITS);

834

const __m256i out_24_6 = _mm256_srai_epi32(out_24_4, DCT_CONST_BITS);

835

const __m256i out_24_7 = _mm256_srai_epi32(out_24_5, DCT_CONST_BITS);

836

// Combine

837

out[0] = _mm256_packs_epi32(out_00_6, out_00_7);

838

out[16] = _mm256_packs_epi32(out_16_6, out_16_7);

839

out[8] = _mm256_packs_epi32(out_08_6, out_08_7);

840

out[24] = _mm256_packs_epi32(out_24_6, out_24_7);

841

}

842

{

843

const __m256i s2_09_0 = _mm256_unpacklo_epi16(step1[9], step1[14]);

844

const __m256i s2_09_1 = _mm256_unpackhi_epi16(step1[9], step1[14]);

845

const __m256i s2_10_0 = _mm256_unpacklo_epi16(step1[10], step1[13]);

846

const __m256i s2_10_1 = _mm256_unpackhi_epi16(step1[10], step1[13]);

847

const __m256i s2_09_2 = _mm256_madd_epi16(s2_09_0, k__cospi_m08_p24);

848

const __m256i s2_09_3 = _mm256_madd_epi16(s2_09_1, k__cospi_m08_p24);

849

const __m256i s2_10_2 = _mm256_madd_epi16(s2_10_0, k__cospi_m24_m08);

850

const __m256i s2_10_3 = _mm256_madd_epi16(s2_10_1, k__cospi_m24_m08);

851

const __m256i s2_13_2 = _mm256_madd_epi16(s2_10_0, k__cospi_m08_p24);

852

const __m256i s2_13_3 = _mm256_madd_epi16(s2_10_1, k__cospi_m08_p24);

853

const __m256i s2_14_2 = _mm256_madd_epi16(s2_09_0, k__cospi_p24_p08);

854

const __m256i s2_14_3 = _mm256_madd_epi16(s2_09_1, k__cospi_p24_p08);

855

// dct_const_round_shift

856

const __m256i s2_09_4 =

857

_mm256_add_epi32(s2_09_2, k__DCT_CONST_ROUNDING);

858

const __m256i s2_09_5 =

859

_mm256_add_epi32(s2_09_3, k__DCT_CONST_ROUNDING);

860

const __m256i s2_10_4 =

861

_mm256_add_epi32(s2_10_2, k__DCT_CONST_ROUNDING);

862

const __m256i s2_10_5 =

863

_mm256_add_epi32(s2_10_3, k__DCT_CONST_ROUNDING);

864

const __m256i s2_13_4 =

865

_mm256_add_epi32(s2_13_2, k__DCT_CONST_ROUNDING);

866

const __m256i s2_13_5 =

867

_mm256_add_epi32(s2_13_3, k__DCT_CONST_ROUNDING);

868

const __m256i s2_14_4 =

869

_mm256_add_epi32(s2_14_2, k__DCT_CONST_ROUNDING);

870

const __m256i s2_14_5 =

871

_mm256_add_epi32(s2_14_3, k__DCT_CONST_ROUNDING);

872

const __m256i s2_09_6 = _mm256_srai_epi32(s2_09_4, DCT_CONST_BITS);

873

const __m256i s2_09_7 = _mm256_srai_epi32(s2_09_5, DCT_CONST_BITS);

874

const __m256i s2_10_6 = _mm256_srai_epi32(s2_10_4, DCT_CONST_BITS);

875

const __m256i s2_10_7 = _mm256_srai_epi32(s2_10_5, DCT_CONST_BITS);

876

const __m256i s2_13_6 = _mm256_srai_epi32(s2_13_4, DCT_CONST_BITS);

877

const __m256i s2_13_7 = _mm256_srai_epi32(s2_13_5, DCT_CONST_BITS);

878

const __m256i s2_14_6 = _mm256_srai_epi32(s2_14_4, DCT_CONST_BITS);

879

const __m256i s2_14_7 = _mm256_srai_epi32(s2_14_5, DCT_CONST_BITS);

880

// Combine

881

step2[9] = _mm256_packs_epi32(s2_09_6, s2_09_7);

882

step2[10] = _mm256_packs_epi32(s2_10_6, s2_10_7);

883

step2[13] = _mm256_packs_epi32(s2_13_6, s2_13_7);

884

step2[14] = _mm256_packs_epi32(s2_14_6, s2_14_7);

885

}

886

{

887

step2[16] = _mm256_add_epi16(step1[19], step3[16]);

888

step2[17] = _mm256_add_epi16(step1[18], step3[17]);

889

step2[18] = _mm256_sub_epi16(step3[17], step1[18]);

890

step2[19] = _mm256_sub_epi16(step3[16], step1[19]);

891

step2[20] = _mm256_sub_epi16(step3[23], step1[20]);

892

step2[21] = _mm256_sub_epi16(step3[22], step1[21]);

893

step2[22] = _mm256_add_epi16(step1[21], step3[22]);

894

step2[23] = _mm256_add_epi16(step1[20], step3[23]);

895

step2[24] = _mm256_add_epi16(step1[27], step3[24]);

896

step2[25] = _mm256_add_epi16(step1[26], step3[25]);

897

step2[26] = _mm256_sub_epi16(step3[25], step1[26]);

898

step2[27] = _mm256_sub_epi16(step3[24], step1[27]);

899

step2[28] = _mm256_sub_epi16(step3[31], step1[28]);

900

step2[29] = _mm256_sub_epi16(step3[30], step1[29]);

901

step2[30] = _mm256_add_epi16(step1[29], step3[30]);

902

step2[31] = _mm256_add_epi16(step1[28], step3[31]);

}

// Stage 6

{

const __m256i out_04_0 = _mm256_unpacklo_epi16(step2[4], step2[7]);

907

const __m256i out_04_1 = _mm256_unpackhi_epi16(step2[4], step2[7]);

908

const __m256i out_20_0 = _mm256_unpacklo_epi16(step2[5], step2[6]);

909

const __m256i out_20_1 = _mm256_unpackhi_epi16(step2[5], step2[6]);

910

const __m256i out_12_0 = _mm256_unpacklo_epi16(step2[5], step2[6]);

911

const __m256i out_12_1 = _mm256_unpackhi_epi16(step2[5], step2[6]);

912

const __m256i out_28_0 = _mm256_unpacklo_epi16(step2[4], step2[7]);

913

const __m256i out_28_1 = _mm256_unpackhi_epi16(step2[4], step2[7]);

914

const __m256i out_04_2 =

915

_mm256_madd_epi16(out_04_0, k__cospi_p28_p04);

916

const __m256i out_04_3 =

917

_mm256_madd_epi16(out_04_1, k__cospi_p28_p04);

918

const __m256i out_20_2 =

919

_mm256_madd_epi16(out_20_0, k__cospi_p12_p20);

920

const __m256i out_20_3 =

921

_mm256_madd_epi16(out_20_1, k__cospi_p12_p20);

922

const __m256i out_12_2 =

923

_mm256_madd_epi16(out_12_0, k__cospi_m20_p12);

924

const __m256i out_12_3 =

925

_mm256_madd_epi16(out_12_1, k__cospi_m20_p12);

926

const __m256i out_28_2 =

927

_mm256_madd_epi16(out_28_0, k__cospi_m04_p28);

928

const __m256i out_28_3 =

929

_mm256_madd_epi16(out_28_1, k__cospi_m04_p28);

930

// dct_const_round_shift

931

const __m256i out_04_4 =

932

_mm256_add_epi32(out_04_2, k__DCT_CONST_ROUNDING);

933

const __m256i out_04_5 =

934

_mm256_add_epi32(out_04_3, k__DCT_CONST_ROUNDING);

935

const __m256i out_20_4 =

936

_mm256_add_epi32(out_20_2, k__DCT_CONST_ROUNDING);

937

const __m256i out_20_5 =

938

_mm256_add_epi32(out_20_3, k__DCT_CONST_ROUNDING);

939

const __m256i out_12_4 =

940

_mm256_add_epi32(out_12_2, k__DCT_CONST_ROUNDING);

941

const __m256i out_12_5 =

942

_mm256_add_epi32(out_12_3, k__DCT_CONST_ROUNDING);

943

const __m256i out_28_4 =

944

_mm256_add_epi32(out_28_2, k__DCT_CONST_ROUNDING);

945

const __m256i out_28_5 =

946

_mm256_add_epi32(out_28_3, k__DCT_CONST_ROUNDING);

947

const __m256i out_04_6 = _mm256_srai_epi32(out_04_4, DCT_CONST_BITS);

948

const __m256i out_04_7 = _mm256_srai_epi32(out_04_5, DCT_CONST_BITS);

949

const __m256i out_20_6 = _mm256_srai_epi32(out_20_4, DCT_CONST_BITS);

950

const __m256i out_20_7 = _mm256_srai_epi32(out_20_5, DCT_CONST_BITS);

951

const __m256i out_12_6 = _mm256_srai_epi32(out_12_4, DCT_CONST_BITS);

952

const __m256i out_12_7 = _mm256_srai_epi32(out_12_5, DCT_CONST_BITS);

953

const __m256i out_28_6 = _mm256_srai_epi32(out_28_4, DCT_CONST_BITS);

954

const __m256i out_28_7 = _mm256_srai_epi32(out_28_5, DCT_CONST_BITS);

955

// Combine

956

out[4] = _mm256_packs_epi32(out_04_6, out_04_7);

957

out[20] = _mm256_packs_epi32(out_20_6, out_20_7);

958

out[12] = _mm256_packs_epi32(out_12_6, out_12_7);

959

out[28] = _mm256_packs_epi32(out_28_6, out_28_7);

960

}

961

{

962

step3[8] = _mm256_add_epi16(step2[9], step1[8]);

963

step3[9] = _mm256_sub_epi16(step1[8], step2[9]);

964

step3[10] = _mm256_sub_epi16(step1[11], step2[10]);

965

step3[11] = _mm256_add_epi16(step2[10], step1[11]);

966

step3[12] = _mm256_add_epi16(step2[13], step1[12]);

967

step3[13] = _mm256_sub_epi16(step1[12], step2[13]);

968

step3[14] = _mm256_sub_epi16(step1[15], step2[14]);

969

step3[15] = _mm256_add_epi16(step2[14], step1[15]);

970

}

971

{

972

const __m256i s3_17_0 = _mm256_unpacklo_epi16(step2[17], step2[30]);

973

const __m256i s3_17_1 = _mm256_unpackhi_epi16(step2[17], step2[30]);

974

const __m256i s3_18_0 = _mm256_unpacklo_epi16(step2[18], step2[29]);

975

const __m256i s3_18_1 = _mm256_unpackhi_epi16(step2[18], step2[29]);

976

const __m256i s3_21_0 = _mm256_unpacklo_epi16(step2[21], step2[26]);

977

const __m256i s3_21_1 = _mm256_unpackhi_epi16(step2[21], step2[26]);

978

const __m256i s3_22_0 = _mm256_unpacklo_epi16(step2[22], step2[25]);

979

const __m256i s3_22_1 = _mm256_unpackhi_epi16(step2[22], step2[25]);

980

const __m256i s3_17_2 = _mm256_madd_epi16(s3_17_0, k__cospi_m04_p28);

981

const __m256i s3_17_3 = _mm256_madd_epi16(s3_17_1, k__cospi_m04_p28);

982

const __m256i s3_18_2 = _mm256_madd_epi16(s3_18_0, k__cospi_m28_m04);

983

const __m256i s3_18_3 = _mm256_madd_epi16(s3_18_1, k__cospi_m28_m04);

984

const __m256i s3_21_2 = _mm256_madd_epi16(s3_21_0, k__cospi_m20_p12);

985

const __m256i s3_21_3 = _mm256_madd_epi16(s3_21_1, k__cospi_m20_p12);

986

const __m256i s3_22_2 = _mm256_madd_epi16(s3_22_0, k__cospi_m12_m20);

987

const __m256i s3_22_3 = _mm256_madd_epi16(s3_22_1, k__cospi_m12_m20);

988

const __m256i s3_25_2 = _mm256_madd_epi16(s3_22_0, k__cospi_m20_p12);

989

const __m256i s3_25_3 = _mm256_madd_epi16(s3_22_1, k__cospi_m20_p12);

990

const __m256i s3_26_2 = _mm256_madd_epi16(s3_21_0, k__cospi_p12_p20);

991

const __m256i s3_26_3 = _mm256_madd_epi16(s3_21_1, k__cospi_p12_p20);

992

const __m256i s3_29_2 = _mm256_madd_epi16(s3_18_0, k__cospi_m04_p28);

993

const __m256i s3_29_3 = _mm256_madd_epi16(s3_18_1, k__cospi_m04_p28);

994

const __m256i s3_30_2 = _mm256_madd_epi16(s3_17_0, k__cospi_p28_p04);

995

const __m256i s3_30_3 = _mm256_madd_epi16(s3_17_1, k__cospi_p28_p04);

996

// dct_const_round_shift

997

const __m256i s3_17_4 =

998

_mm256_add_epi32(s3_17_2, k__DCT_CONST_ROUNDING);

999

const __m256i s3_17_5 =

1000

_mm256_add_epi32(s3_17_3, k__DCT_CONST_ROUNDING);

1001

const __m256i s3_18_4 =

1002

_mm256_add_epi32(s3_18_2, k__DCT_CONST_ROUNDING);

1003

const __m256i s3_18_5 =

1004

_mm256_add_epi32(s3_18_3, k__DCT_CONST_ROUNDING);

1005

const __m256i s3_21_4 =

1006

_mm256_add_epi32(s3_21_2, k__DCT_CONST_ROUNDING);

1007

const __m256i s3_21_5 =

1008

_mm256_add_epi32(s3_21_3, k__DCT_CONST_ROUNDING);

1009

const __m256i s3_22_4 =

1010

_mm256_add_epi32(s3_22_2, k__DCT_CONST_ROUNDING);

1011

const __m256i s3_22_5 =

1012

_mm256_add_epi32(s3_22_3, k__DCT_CONST_ROUNDING);

1013

const __m256i s3_17_6 = _mm256_srai_epi32(s3_17_4, DCT_CONST_BITS);

1014

const __m256i s3_17_7 = _mm256_srai_epi32(s3_17_5, DCT_CONST_BITS);

1015

const __m256i s3_18_6 = _mm256_srai_epi32(s3_18_4, DCT_CONST_BITS);

1016

const __m256i s3_18_7 = _mm256_srai_epi32(s3_18_5, DCT_CONST_BITS);

1017

const __m256i s3_21_6 = _mm256_srai_epi32(s3_21_4, DCT_CONST_BITS);

1018

const __m256i s3_21_7 = _mm256_srai_epi32(s3_21_5, DCT_CONST_BITS);

1019

const __m256i s3_22_6 = _mm256_srai_epi32(s3_22_4, DCT_CONST_BITS);

1020

const __m256i s3_22_7 = _mm256_srai_epi32(s3_22_5, DCT_CONST_BITS);

1021

const __m256i s3_25_4 =

1022

_mm256_add_epi32(s3_25_2, k__DCT_CONST_ROUNDING);

1023

const __m256i s3_25_5 =

1024

_mm256_add_epi32(s3_25_3, k__DCT_CONST_ROUNDING);

1025

const __m256i s3_26_4 =

1026

_mm256_add_epi32(s3_26_2, k__DCT_CONST_ROUNDING);

1027

const __m256i s3_26_5 =

1028

_mm256_add_epi32(s3_26_3, k__DCT_CONST_ROUNDING);

1029

const __m256i s3_29_4 =

1030

_mm256_add_epi32(s3_29_2, k__DCT_CONST_ROUNDING);

1031

const __m256i s3_29_5 =

1032

_mm256_add_epi32(s3_29_3, k__DCT_CONST_ROUNDING);

1033

const __m256i s3_30_4 =

1034

_mm256_add_epi32(s3_30_2, k__DCT_CONST_ROUNDING);

1035

const __m256i s3_30_5 =

1036

_mm256_add_epi32(s3_30_3, k__DCT_CONST_ROUNDING);

1037

const __m256i s3_25_6 = _mm256_srai_epi32(s3_25_4, DCT_CONST_BITS);

1038

const __m256i s3_25_7 = _mm256_srai_epi32(s3_25_5, DCT_CONST_BITS);

1039

const __m256i s3_26_6 = _mm256_srai_epi32(s3_26_4, DCT_CONST_BITS);

1040

const __m256i s3_26_7 = _mm256_srai_epi32(s3_26_5, DCT_CONST_BITS);

1041

const __m256i s3_29_6 = _mm256_srai_epi32(s3_29_4, DCT_CONST_BITS);

1042

const __m256i s3_29_7 = _mm256_srai_epi32(s3_29_5, DCT_CONST_BITS);

1043

const __m256i s3_30_6 = _mm256_srai_epi32(s3_30_4, DCT_CONST_BITS);

1044

const __m256i s3_30_7 = _mm256_srai_epi32(s3_30_5, DCT_CONST_BITS);

1045

// Combine

1046

step3[17] = _mm256_packs_epi32(s3_17_6, s3_17_7);

1047

step3[18] = _mm256_packs_epi32(s3_18_6, s3_18_7);

1048

step3[21] = _mm256_packs_epi32(s3_21_6, s3_21_7);

1049

step3[22] = _mm256_packs_epi32(s3_22_6, s3_22_7);

1050

// Combine

1051

step3[25] = _mm256_packs_epi32(s3_25_6, s3_25_7);

1052

step3[26] = _mm256_packs_epi32(s3_26_6, s3_26_7);

1053

step3[29] = _mm256_packs_epi32(s3_29_6, s3_29_7);

1054

step3[30] = _mm256_packs_epi32(s3_30_6, s3_30_7);

}

// Stage 7

{

const __m256i out_02_0 = _mm256_unpacklo_epi16(step3[8], step3[15]);

1059

const __m256i out_02_1 = _mm256_unpackhi_epi16(step3[8], step3[15]);

1060

const __m256i out_18_0 = _mm256_unpacklo_epi16(step3[9], step3[14]);

1061

const __m256i out_18_1 = _mm256_unpackhi_epi16(step3[9], step3[14]);

1062

const __m256i out_10_0 = _mm256_unpacklo_epi16(step3[10], step3[13]);

1063

const __m256i out_10_1 = _mm256_unpackhi_epi16(step3[10], step3[13]);

1064

const __m256i out_26_0 = _mm256_unpacklo_epi16(step3[11], step3[12]);

1065

const __m256i out_26_1 = _mm256_unpackhi_epi16(step3[11], step3[12]);

1066

const __m256i out_02_2 =

1067

_mm256_madd_epi16(out_02_0, k__cospi_p30_p02);

1068

const __m256i out_02_3 =

1069

_mm256_madd_epi16(out_02_1, k__cospi_p30_p02);

1070

const __m256i out_18_2 =

1071

_mm256_madd_epi16(out_18_0, k__cospi_p14_p18);

1072

const __m256i out_18_3 =

1073

_mm256_madd_epi16(out_18_1, k__cospi_p14_p18);

1074

const __m256i out_10_2 =

1075

_mm256_madd_epi16(out_10_0, k__cospi_p22_p10);

1076

const __m256i out_10_3 =

1077

_mm256_madd_epi16(out_10_1, k__cospi_p22_p10);

1078

const __m256i out_26_2 =

1079

_mm256_madd_epi16(out_26_0, k__cospi_p06_p26);

1080

const __m256i out_26_3 =

1081

_mm256_madd_epi16(out_26_1, k__cospi_p06_p26);

1082

const __m256i out_06_2 =

1083

_mm256_madd_epi16(out_26_0, k__cospi_m26_p06);

1084

const __m256i out_06_3 =

1085

_mm256_madd_epi16(out_26_1, k__cospi_m26_p06);

1086

const __m256i out_22_2 =

1087

_mm256_madd_epi16(out_10_0, k__cospi_m10_p22);

1088

const __m256i out_22_3 =

1089

_mm256_madd_epi16(out_10_1, k__cospi_m10_p22);

1090

const __m256i out_14_2 =

1091

_mm256_madd_epi16(out_18_0, k__cospi_m18_p14);

1092

const __m256i out_14_3 =

1093

_mm256_madd_epi16(out_18_1, k__cospi_m18_p14);

1094

const __m256i out_30_2 =

1095

_mm256_madd_epi16(out_02_0, k__cospi_m02_p30);

1096

const __m256i out_30_3 =

1097

_mm256_madd_epi16(out_02_1, k__cospi_m02_p30);

1098

// dct_const_round_shift

1099

const __m256i out_02_4 =

1100

_mm256_add_epi32(out_02_2, k__DCT_CONST_ROUNDING);

1101

const __m256i out_02_5 =

1102

_mm256_add_epi32(out_02_3, k__DCT_CONST_ROUNDING);

1103

const __m256i out_18_4 =

1104

_mm256_add_epi32(out_18_2, k__DCT_CONST_ROUNDING);

1105

const __m256i out_18_5 =

1106

_mm256_add_epi32(out_18_3, k__DCT_CONST_ROUNDING);

1107

const __m256i out_10_4 =

1108

_mm256_add_epi32(out_10_2, k__DCT_CONST_ROUNDING);

1109

const __m256i out_10_5 =

1110

_mm256_add_epi32(out_10_3, k__DCT_CONST_ROUNDING);

1111

const __m256i out_26_4 =

1112

_mm256_add_epi32(out_26_2, k__DCT_CONST_ROUNDING);

1113

const __m256i out_26_5 =

1114

_mm256_add_epi32(out_26_3, k__DCT_CONST_ROUNDING);

1115

const __m256i out_06_4 =

1116

_mm256_add_epi32(out_06_2, k__DCT_CONST_ROUNDING);

1117

const __m256i out_06_5 =

1118

_mm256_add_epi32(out_06_3, k__DCT_CONST_ROUNDING);

1119

const __m256i out_22_4 =

1120

_mm256_add_epi32(out_22_2, k__DCT_CONST_ROUNDING);

1121

const __m256i out_22_5 =

1122

_mm256_add_epi32(out_22_3, k__DCT_CONST_ROUNDING);

1123

const __m256i out_14_4 =

1124

_mm256_add_epi32(out_14_2, k__DCT_CONST_ROUNDING);

1125

const __m256i out_14_5 =

1126

_mm256_add_epi32(out_14_3, k__DCT_CONST_ROUNDING);

1127

const __m256i out_30_4 =

1128

_mm256_add_epi32(out_30_2, k__DCT_CONST_ROUNDING);

1129

const __m256i out_30_5 =

1130

_mm256_add_epi32(out_30_3, k__DCT_CONST_ROUNDING);

1131

const __m256i out_02_6 = _mm256_srai_epi32(out_02_4, DCT_CONST_BITS);

1132

const __m256i out_02_7 = _mm256_srai_epi32(out_02_5, DCT_CONST_BITS);

1133

const __m256i out_18_6 = _mm256_srai_epi32(out_18_4, DCT_CONST_BITS);

1134

const __m256i out_18_7 = _mm256_srai_epi32(out_18_5, DCT_CONST_BITS);

1135

const __m256i out_10_6 = _mm256_srai_epi32(out_10_4, DCT_CONST_BITS);

1136

const __m256i out_10_7 = _mm256_srai_epi32(out_10_5, DCT_CONST_BITS);

1137

const __m256i out_26_6 = _mm256_srai_epi32(out_26_4, DCT_CONST_BITS);

1138

const __m256i out_26_7 = _mm256_srai_epi32(out_26_5, DCT_CONST_BITS);

1139

const __m256i out_06_6 = _mm256_srai_epi32(out_06_4, DCT_CONST_BITS);

1140

const __m256i out_06_7 = _mm256_srai_epi32(out_06_5, DCT_CONST_BITS);

1141

const __m256i out_22_6 = _mm256_srai_epi32(out_22_4, DCT_CONST_BITS);

1142

const __m256i out_22_7 = _mm256_srai_epi32(out_22_5, DCT_CONST_BITS);

1143

const __m256i out_14_6 = _mm256_srai_epi32(out_14_4, DCT_CONST_BITS);

1144

const __m256i out_14_7 = _mm256_srai_epi32(out_14_5, DCT_CONST_BITS);

1145

const __m256i out_30_6 = _mm256_srai_epi32(out_30_4, DCT_CONST_BITS);

1146

const __m256i out_30_7 = _mm256_srai_epi32(out_30_5, DCT_CONST_BITS);

1147

// Combine

1148

out[2] = _mm256_packs_epi32(out_02_6, out_02_7);

1149

out[18] = _mm256_packs_epi32(out_18_6, out_18_7);

1150

out[10] = _mm256_packs_epi32(out_10_6, out_10_7);

1151

out[26] = _mm256_packs_epi32(out_26_6, out_26_7);

1152

out[6] = _mm256_packs_epi32(out_06_6, out_06_7);

1153

out[22] = _mm256_packs_epi32(out_22_6, out_22_7);

1154

out[14] = _mm256_packs_epi32(out_14_6, out_14_7);

1155

out[30] = _mm256_packs_epi32(out_30_6, out_30_7);

1156

}

1157

{

1158

step1[16] = _mm256_add_epi16(step3[17], step2[16]);

1159

step1[17] = _mm256_sub_epi16(step2[16], step3[17]);

1160

step1[18] = _mm256_sub_epi16(step2[19], step3[18]);

1161

step1[19] = _mm256_add_epi16(step3[18], step2[19]);

1162

step1[20] = _mm256_add_epi16(step3[21], step2[20]);

1163

step1[21] = _mm256_sub_epi16(step2[20], step3[21]);

1164

step1[22] = _mm256_sub_epi16(step2[23], step3[22]);

1165

step1[23] = _mm256_add_epi16(step3[22], step2[23]);

1166

step1[24] = _mm256_add_epi16(step3[25], step2[24]);

1167

step1[25] = _mm256_sub_epi16(step2[24], step3[25]);

1168

step1[26] = _mm256_sub_epi16(step2[27], step3[26]);

1169

step1[27] = _mm256_add_epi16(step3[26], step2[27]);

1170

step1[28] = _mm256_add_epi16(step3[29], step2[28]);

1171

step1[29] = _mm256_sub_epi16(step2[28], step3[29]);

1172

step1[30] = _mm256_sub_epi16(step2[31], step3[30]);

1173

step1[31] = _mm256_add_epi16(step3[30], step2[31]);

1174

}

1175

// Final stage --- outputs indices are bit-reversed.

1176

{

1177

const __m256i out_01_0 = _mm256_unpacklo_epi16(step1[16], step1[31]);

1178

const __m256i out_01_1 = _mm256_unpackhi_epi16(step1[16], step1[31]);

1179

const __m256i out_17_0 = _mm256_unpacklo_epi16(step1[17], step1[30]);

1180

const __m256i out_17_1 = _mm256_unpackhi_epi16(step1[17], step1[30]);

1181

const __m256i out_09_0 = _mm256_unpacklo_epi16(step1[18], step1[29]);

1182

const __m256i out_09_1 = _mm256_unpackhi_epi16(step1[18], step1[29]);

1183

const __m256i out_25_0 = _mm256_unpacklo_epi16(step1[19], step1[28]);

1184

const __m256i out_25_1 = _mm256_unpackhi_epi16(step1[19], step1[28]);

1185

const __m256i out_01_2 =

1186

_mm256_madd_epi16(out_01_0, k__cospi_p31_p01);

1187

const __m256i out_01_3 =

1188

_mm256_madd_epi16(out_01_1, k__cospi_p31_p01);

1189

const __m256i out_17_2 =

1190

_mm256_madd_epi16(out_17_0, k__cospi_p15_p17);

1191

const __m256i out_17_3 =

1192

_mm256_madd_epi16(out_17_1, k__cospi_p15_p17);

1193

const __m256i out_09_2 =

1194

_mm256_madd_epi16(out_09_0, k__cospi_p23_p09);

1195

const __m256i out_09_3 =

1196

_mm256_madd_epi16(out_09_1, k__cospi_p23_p09);

1197

const __m256i out_25_2 =

1198

_mm256_madd_epi16(out_25_0, k__cospi_p07_p25);

1199

const __m256i out_25_3 =

1200

_mm256_madd_epi16(out_25_1, k__cospi_p07_p25);

1201

const __m256i out_07_2 =

1202

_mm256_madd_epi16(out_25_0, k__cospi_m25_p07);

1203

const __m256i out_07_3 =

1204

_mm256_madd_epi16(out_25_1, k__cospi_m25_p07);

1205

const __m256i out_23_2 =

1206

_mm256_madd_epi16(out_09_0, k__cospi_m09_p23);

1207

const __m256i out_23_3 =

1208

_mm256_madd_epi16(out_09_1, k__cospi_m09_p23);

1209

const __m256i out_15_2 =

1210

_mm256_madd_epi16(out_17_0, k__cospi_m17_p15);

1211

const __m256i out_15_3 =

1212

_mm256_madd_epi16(out_17_1, k__cospi_m17_p15);

1213

const __m256i out_31_2 =

1214

_mm256_madd_epi16(out_01_0, k__cospi_m01_p31);

1215

const __m256i out_31_3 =

1216

_mm256_madd_epi16(out_01_1, k__cospi_m01_p31);

1217

// dct_const_round_shift

1218

const __m256i out_01_4 =

1219

_mm256_add_epi32(out_01_2, k__DCT_CONST_ROUNDING);

1220

const __m256i out_01_5 =

1221

_mm256_add_epi32(out_01_3, k__DCT_CONST_ROUNDING);

1222

const __m256i out_17_4 =

1223

_mm256_add_epi32(out_17_2, k__DCT_CONST_ROUNDING);

1224

const __m256i out_17_5 =

1225

_mm256_add_epi32(out_17_3, k__DCT_CONST_ROUNDING);

1226

const __m256i out_09_4 =

1227

_mm256_add_epi32(out_09_2, k__DCT_CONST_ROUNDING);

1228

const __m256i out_09_5 =

1229

_mm256_add_epi32(out_09_3, k__DCT_CONST_ROUNDING);

1230

const __m256i out_25_4 =

1231

_mm256_add_epi32(out_25_2, k__DCT_CONST_ROUNDING);

1232

const __m256i out_25_5 =

1233

_mm256_add_epi32(out_25_3, k__DCT_CONST_ROUNDING);

1234

const __m256i out_07_4 =

1235

_mm256_add_epi32(out_07_2, k__DCT_CONST_ROUNDING);

1236

const __m256i out_07_5 =

1237

_mm256_add_epi32(out_07_3, k__DCT_CONST_ROUNDING);

1238

const __m256i out_23_4 =

1239

_mm256_add_epi32(out_23_2, k__DCT_CONST_ROUNDING);

1240

const __m256i out_23_5 =

1241

_mm256_add_epi32(out_23_3, k__DCT_CONST_ROUNDING);

1242

const __m256i out_15_4 =

1243

_mm256_add_epi32(out_15_2, k__DCT_CONST_ROUNDING);

1244

const __m256i out_15_5 =

1245

_mm256_add_epi32(out_15_3, k__DCT_CONST_ROUNDING);

1246

const __m256i out_31_4 =

1247

_mm256_add_epi32(out_31_2, k__DCT_CONST_ROUNDING);

1248

const __m256i out_31_5 =

1249

_mm256_add_epi32(out_31_3, k__DCT_CONST_ROUNDING);

1250

const __m256i out_01_6 = _mm256_srai_epi32(out_01_4, DCT_CONST_BITS);

1251

const __m256i out_01_7 = _mm256_srai_epi32(out_01_5, DCT_CONST_BITS);

1252

const __m256i out_17_6 = _mm256_srai_epi32(out_17_4, DCT_CONST_BITS);

1253

const __m256i out_17_7 = _mm256_srai_epi32(out_17_5, DCT_CONST_BITS);

1254

const __m256i out_09_6 = _mm256_srai_epi32(out_09_4, DCT_CONST_BITS);

1255

const __m256i out_09_7 = _mm256_srai_epi32(out_09_5, DCT_CONST_BITS);

1256

const __m256i out_25_6 = _mm256_srai_epi32(out_25_4, DCT_CONST_BITS);

1257

const __m256i out_25_7 = _mm256_srai_epi32(out_25_5, DCT_CONST_BITS);

1258

const __m256i out_07_6 = _mm256_srai_epi32(out_07_4, DCT_CONST_BITS);

1259

const __m256i out_07_7 = _mm256_srai_epi32(out_07_5, DCT_CONST_BITS);

1260

const __m256i out_23_6 = _mm256_srai_epi32(out_23_4, DCT_CONST_BITS);

1261

const __m256i out_23_7 = _mm256_srai_epi32(out_23_5, DCT_CONST_BITS);

1262

const __m256i out_15_6 = _mm256_srai_epi32(out_15_4, DCT_CONST_BITS);

1263

const __m256i out_15_7 = _mm256_srai_epi32(out_15_5, DCT_CONST_BITS);

1264

const __m256i out_31_6 = _mm256_srai_epi32(out_31_4, DCT_CONST_BITS);

1265

const __m256i out_31_7 = _mm256_srai_epi32(out_31_5, DCT_CONST_BITS);

1266

// Combine

1267

out[1] = _mm256_packs_epi32(out_01_6, out_01_7);

1268

out[17] = _mm256_packs_epi32(out_17_6, out_17_7);

1269

out[9] = _mm256_packs_epi32(out_09_6, out_09_7);

1270

out[25] = _mm256_packs_epi32(out_25_6, out_25_7);

1271

out[7] = _mm256_packs_epi32(out_07_6, out_07_7);

1272

out[23] = _mm256_packs_epi32(out_23_6, out_23_7);

1273

out[15] = _mm256_packs_epi32(out_15_6, out_15_7);

1274

out[31] = _mm256_packs_epi32(out_31_6, out_31_7);

1275

}

1276

{

1277

const __m256i out_05_0 = _mm256_unpacklo_epi16(step1[20], step1[27]);

1278

const __m256i out_05_1 = _mm256_unpackhi_epi16(step1[20], step1[27]);

1279

const __m256i out_21_0 = _mm256_unpacklo_epi16(step1[21], step1[26]);

1280

const __m256i out_21_1 = _mm256_unpackhi_epi16(step1[21], step1[26]);

1281

const __m256i out_13_0 = _mm256_unpacklo_epi16(step1[22], step1[25]);

1282

const __m256i out_13_1 = _mm256_unpackhi_epi16(step1[22], step1[25]);

1283

const __m256i out_29_0 = _mm256_unpacklo_epi16(step1[23], step1[24]);

1284

const __m256i out_29_1 = _mm256_unpackhi_epi16(step1[23], step1[24]);

1285

const __m256i out_05_2 =

1286

_mm256_madd_epi16(out_05_0, k__cospi_p27_p05);

1287

const __m256i out_05_3 =

1288

_mm256_madd_epi16(out_05_1, k__cospi_p27_p05);

1289

const __m256i out_21_2 =

1290

_mm256_madd_epi16(out_21_0, k__cospi_p11_p21);

1291

const __m256i out_21_3 =

1292

_mm256_madd_epi16(out_21_1, k__cospi_p11_p21);

1293

const __m256i out_13_2 =

1294

_mm256_madd_epi16(out_13_0, k__cospi_p19_p13);

1295

const __m256i out_13_3 =

1296

_mm256_madd_epi16(out_13_1, k__cospi_p19_p13);

1297

const __m256i out_29_2 =

1298

_mm256_madd_epi16(out_29_0, k__cospi_p03_p29);

1299

const __m256i out_29_3 =

1300

_mm256_madd_epi16(out_29_1, k__cospi_p03_p29);

1301

const __m256i out_03_2 =

1302

_mm256_madd_epi16(out_29_0, k__cospi_m29_p03);

1303

const __m256i out_03_3 =

1304

_mm256_madd_epi16(out_29_1, k__cospi_m29_p03);

1305

const __m256i out_19_2 =

1306

_mm256_madd_epi16(out_13_0, k__cospi_m13_p19);

1307

const __m256i out_19_3 =

1308

_mm256_madd_epi16(out_13_1, k__cospi_m13_p19);

1309

const __m256i out_11_2 =

1310

_mm256_madd_epi16(out_21_0, k__cospi_m21_p11);

1311

const __m256i out_11_3 =

1312

_mm256_madd_epi16(out_21_1, k__cospi_m21_p11);

1313

const __m256i out_27_2 =

1314

_mm256_madd_epi16(out_05_0, k__cospi_m05_p27);

1315

const __m256i out_27_3 =

1316

_mm256_madd_epi16(out_05_1, k__cospi_m05_p27);

1317

// dct_const_round_shift

1318

const __m256i out_05_4 =

1319

_mm256_add_epi32(out_05_2, k__DCT_CONST_ROUNDING);

1320

const __m256i out_05_5 =

1321

_mm256_add_epi32(out_05_3, k__DCT_CONST_ROUNDING);

1322

const __m256i out_21_4 =

1323

_mm256_add_epi32(out_21_2, k__DCT_CONST_ROUNDING);

1324

const __m256i out_21_5 =

1325

_mm256_add_epi32(out_21_3, k__DCT_CONST_ROUNDING);

1326

const __m256i out_13_4 =

1327

_mm256_add_epi32(out_13_2, k__DCT_CONST_ROUNDING);

1328

const __m256i out_13_5 =

1329

_mm256_add_epi32(out_13_3, k__DCT_CONST_ROUNDING);

1330

const __m256i out_29_4 =

1331

_mm256_add_epi32(out_29_2, k__DCT_CONST_ROUNDING);

1332

const __m256i out_29_5 =

1333

_mm256_add_epi32(out_29_3, k__DCT_CONST_ROUNDING);

1334

const __m256i out_03_4 =

1335

_mm256_add_epi32(out_03_2, k__DCT_CONST_ROUNDING);

1336

const __m256i out_03_5 =

1337

_mm256_add_epi32(out_03_3, k__DCT_CONST_ROUNDING);

1338

const __m256i out_19_4 =

1339

_mm256_add_epi32(out_19_2, k__DCT_CONST_ROUNDING);

1340

const __m256i out_19_5 =

1341

_mm256_add_epi32(out_19_3, k__DCT_CONST_ROUNDING);

1342

const __m256i out_11_4 =

1343

_mm256_add_epi32(out_11_2, k__DCT_CONST_ROUNDING);

1344

const __m256i out_11_5 =

1345

_mm256_add_epi32(out_11_3, k__DCT_CONST_ROUNDING);

1346

const __m256i out_27_4 =

1347

_mm256_add_epi32(out_27_2, k__DCT_CONST_ROUNDING);

1348

const __m256i out_27_5 =

1349

_mm256_add_epi32(out_27_3, k__DCT_CONST_ROUNDING);

1350

const __m256i out_05_6 = _mm256_srai_epi32(out_05_4, DCT_CONST_BITS);

1351

const __m256i out_05_7 = _mm256_srai_epi32(out_05_5, DCT_CONST_BITS);

1352

const __m256i out_21_6 = _mm256_srai_epi32(out_21_4, DCT_CONST_BITS);

1353

const __m256i out_21_7 = _mm256_srai_epi32(out_21_5, DCT_CONST_BITS);

1354

const __m256i out_13_6 = _mm256_srai_epi32(out_13_4, DCT_CONST_BITS);

1355

const __m256i out_13_7 = _mm256_srai_epi32(out_13_5, DCT_CONST_BITS);

1356

const __m256i out_29_6 = _mm256_srai_epi32(out_29_4, DCT_CONST_BITS);

1357

const __m256i out_29_7 = _mm256_srai_epi32(out_29_5, DCT_CONST_BITS);

1358

const __m256i out_03_6 = _mm256_srai_epi32(out_03_4, DCT_CONST_BITS);

1359

const __m256i out_03_7 = _mm256_srai_epi32(out_03_5, DCT_CONST_BITS);

1360

const __m256i out_19_6 = _mm256_srai_epi32(out_19_4, DCT_CONST_BITS);

1361

const __m256i out_19_7 = _mm256_srai_epi32(out_19_5, DCT_CONST_BITS);

1362

const __m256i out_11_6 = _mm256_srai_epi32(out_11_4, DCT_CONST_BITS);

1363

const __m256i out_11_7 = _mm256_srai_epi32(out_11_5, DCT_CONST_BITS);

1364

const __m256i out_27_6 = _mm256_srai_epi32(out_27_4, DCT_CONST_BITS);

1365

const __m256i out_27_7 = _mm256_srai_epi32(out_27_5, DCT_CONST_BITS);

1366

// Combine

1367

out[5] = _mm256_packs_epi32(out_05_6, out_05_7);

1368

out[21] = _mm256_packs_epi32(out_21_6, out_21_7);

1369

out[13] = _mm256_packs_epi32(out_13_6, out_13_7);

1370

out[29] = _mm256_packs_epi32(out_29_6, out_29_7);

1371

out[3] = _mm256_packs_epi32(out_03_6, out_03_7);

1372

out[19] = _mm256_packs_epi32(out_19_6, out_19_7);

1373

out[11] = _mm256_packs_epi32(out_11_6, out_11_7);

1374

out[27] = _mm256_packs_epi32(out_27_6, out_27_7);

1375

}

1376

#if FDCT32x32_HIGH_PRECISION

1377

} else {

1378

__m256i lstep1[64], lstep2[64], lstep3[64];

1379

__m256i u[32], v[32], sign[16];

1380

const __m256i K32One = _mm256_set_epi32(1, 1, 1, 1, 1, 1, 1, 1);

1381

// start using 32-bit operations

1382

// stage 3

1383

{

1384

// expanding to 32-bit length priori to addition operations

1385

lstep2[0] = _mm256_unpacklo_epi16(step2[0], kZero);

1386

lstep2[1] = _mm256_unpackhi_epi16(step2[0], kZero);

1387

lstep2[2] = _mm256_unpacklo_epi16(step2[1], kZero);

1388

lstep2[3] = _mm256_unpackhi_epi16(step2[1], kZero);

1389

lstep2[4] = _mm256_unpacklo_epi16(step2[2], kZero);

1390

lstep2[5] = _mm256_unpackhi_epi16(step2[2], kZero);

1391

lstep2[6] = _mm256_unpacklo_epi16(step2[3], kZero);

1392

lstep2[7] = _mm256_unpackhi_epi16(step2[3], kZero);

1393

lstep2[8] = _mm256_unpacklo_epi16(step2[4], kZero);

1394

lstep2[9] = _mm256_unpackhi_epi16(step2[4], kZero);

1395

lstep2[10] = _mm256_unpacklo_epi16(step2[5], kZero);

1396

lstep2[11] = _mm256_unpackhi_epi16(step2[5], kZero);

1397

lstep2[12] = _mm256_unpacklo_epi16(step2[6], kZero);

1398

lstep2[13] = _mm256_unpackhi_epi16(step2[6], kZero);

1399

lstep2[14] = _mm256_unpacklo_epi16(step2[7], kZero);

1400

lstep2[15] = _mm256_unpackhi_epi16(step2[7], kZero);

1401

lstep2[0] = _mm256_madd_epi16(lstep2[0], kOne);

1402

lstep2[1] = _mm256_madd_epi16(lstep2[1], kOne);

1403

lstep2[2] = _mm256_madd_epi16(lstep2[2], kOne);

1404

lstep2[3] = _mm256_madd_epi16(lstep2[3], kOne);

1405

lstep2[4] = _mm256_madd_epi16(lstep2[4], kOne);

1406

lstep2[5] = _mm256_madd_epi16(lstep2[5], kOne);

1407

lstep2[6] = _mm256_madd_epi16(lstep2[6], kOne);

1408

lstep2[7] = _mm256_madd_epi16(lstep2[7], kOne);

1409

lstep2[8] = _mm256_madd_epi16(lstep2[8], kOne);

1410

lstep2[9] = _mm256_madd_epi16(lstep2[9], kOne);

1411

lstep2[10] = _mm256_madd_epi16(lstep2[10], kOne);

1412

lstep2[11] = _mm256_madd_epi16(lstep2[11], kOne);

1413

lstep2[12] = _mm256_madd_epi16(lstep2[12], kOne);

1414

lstep2[13] = _mm256_madd_epi16(lstep2[13], kOne);

1415

lstep2[14] = _mm256_madd_epi16(lstep2[14], kOne);

1416

lstep2[15] = _mm256_madd_epi16(lstep2[15], kOne);

1417

1418

lstep3[0] = _mm256_add_epi32(lstep2[14], lstep2[0]);

1419

lstep3[1] = _mm256_add_epi32(lstep2[15], lstep2[1]);

1420

lstep3[2] = _mm256_add_epi32(lstep2[12], lstep2[2]);

1421

lstep3[3] = _mm256_add_epi32(lstep2[13], lstep2[3]);

1422

lstep3[4] = _mm256_add_epi32(lstep2[10], lstep2[4]);

1423

lstep3[5] = _mm256_add_epi32(lstep2[11], lstep2[5]);

1424

lstep3[6] = _mm256_add_epi32(lstep2[8], lstep2[6]);

1425

lstep3[7] = _mm256_add_epi32(lstep2[9], lstep2[7]);

1426

lstep3[8] = _mm256_sub_epi32(lstep2[6], lstep2[8]);

1427

lstep3[9] = _mm256_sub_epi32(lstep2[7], lstep2[9]);

1428

lstep3[10] = _mm256_sub_epi32(lstep2[4], lstep2[10]);

1429

lstep3[11] = _mm256_sub_epi32(lstep2[5], lstep2[11]);

1430

lstep3[12] = _mm256_sub_epi32(lstep2[2], lstep2[12]);

1431

lstep3[13] = _mm256_sub_epi32(lstep2[3], lstep2[13]);

1432

lstep3[14] = _mm256_sub_epi32(lstep2[0], lstep2[14]);

1433

lstep3[15] = _mm256_sub_epi32(lstep2[1], lstep2[15]);

1434

}

1435

{

1436

const __m256i s3_10_0 = _mm256_unpacklo_epi16(step2[13], step2[10]);

1437

const __m256i s3_10_1 = _mm256_unpackhi_epi16(step2[13], step2[10]);

1438

const __m256i s3_11_0 = _mm256_unpacklo_epi16(step2[12], step2[11]);

1439

const __m256i s3_11_1 = _mm256_unpackhi_epi16(step2[12], step2[11]);

1440

const __m256i s3_10_2 = _mm256_madd_epi16(s3_10_0, k__cospi_p16_m16);

1441

const __m256i s3_10_3 = _mm256_madd_epi16(s3_10_1, k__cospi_p16_m16);

1442

const __m256i s3_11_2 = _mm256_madd_epi16(s3_11_0, k__cospi_p16_m16);

1443

const __m256i s3_11_3 = _mm256_madd_epi16(s3_11_1, k__cospi_p16_m16);

1444

const __m256i s3_12_2 = _mm256_madd_epi16(s3_11_0, k__cospi_p16_p16);

1445

const __m256i s3_12_3 = _mm256_madd_epi16(s3_11_1, k__cospi_p16_p16);

1446

const __m256i s3_13_2 = _mm256_madd_epi16(s3_10_0, k__cospi_p16_p16);

1447

const __m256i s3_13_3 = _mm256_madd_epi16(s3_10_1, k__cospi_p16_p16);

1448

// dct_const_round_shift

1449

const __m256i s3_10_4 =

1450

_mm256_add_epi32(s3_10_2, k__DCT_CONST_ROUNDING);

1451

const __m256i s3_10_5 =

1452

_mm256_add_epi32(s3_10_3, k__DCT_CONST_ROUNDING);

1453

const __m256i s3_11_4 =

1454

_mm256_add_epi32(s3_11_2, k__DCT_CONST_ROUNDING);

1455

const __m256i s3_11_5 =

1456

_mm256_add_epi32(s3_11_3, k__DCT_CONST_ROUNDING);

1457

const __m256i s3_12_4 =

1458

_mm256_add_epi32(s3_12_2, k__DCT_CONST_ROUNDING);

1459

const __m256i s3_12_5 =

1460

_mm256_add_epi32(s3_12_3, k__DCT_CONST_ROUNDING);

1461

const __m256i s3_13_4 =

1462

_mm256_add_epi32(s3_13_2, k__DCT_CONST_ROUNDING);

1463

const __m256i s3_13_5 =

1464

_mm256_add_epi32(s3_13_3, k__DCT_CONST_ROUNDING);

1465

lstep3[20] = _mm256_srai_epi32(s3_10_4, DCT_CONST_BITS);

1466

lstep3[21] = _mm256_srai_epi32(s3_10_5, DCT_CONST_BITS);

1467

lstep3[22] = _mm256_srai_epi32(s3_11_4, DCT_CONST_BITS);

1468

lstep3[23] = _mm256_srai_epi32(s3_11_5, DCT_CONST_BITS);

1469

lstep3[24] = _mm256_srai_epi32(s3_12_4, DCT_CONST_BITS);

1470

lstep3[25] = _mm256_srai_epi32(s3_12_5, DCT_CONST_BITS);

1471

lstep3[26] = _mm256_srai_epi32(s3_13_4, DCT_CONST_BITS);

1472

lstep3[27] = _mm256_srai_epi32(s3_13_5, DCT_CONST_BITS);

1473

}

1474

{

1475

lstep2[40] = _mm256_unpacklo_epi16(step2[20], kZero);

1476

lstep2[41] = _mm256_unpackhi_epi16(step2[20], kZero);

1477

lstep2[42] = _mm256_unpacklo_epi16(step2[21], kZero);

1478

lstep2[43] = _mm256_unpackhi_epi16(step2[21], kZero);

1479

lstep2[44] = _mm256_unpacklo_epi16(step2[22], kZero);

1480

lstep2[45] = _mm256_unpackhi_epi16(step2[22], kZero);

1481

lstep2[46] = _mm256_unpacklo_epi16(step2[23], kZero);

1482

lstep2[47] = _mm256_unpackhi_epi16(step2[23], kZero);

1483

lstep2[48] = _mm256_unpacklo_epi16(step2[24], kZero);

1484

lstep2[49] = _mm256_unpackhi_epi16(step2[24], kZero);

1485

lstep2[50] = _mm256_unpacklo_epi16(step2[25], kZero);

1486

lstep2[51] = _mm256_unpackhi_epi16(step2[25], kZero);

1487

lstep2[52] = _mm256_unpacklo_epi16(step2[26], kZero);

1488

lstep2[53] = _mm256_unpackhi_epi16(step2[26], kZero);

1489

lstep2[54] = _mm256_unpacklo_epi16(step2[27], kZero);

1490

lstep2[55] = _mm256_unpackhi_epi16(step2[27], kZero);

1491

lstep2[40] = _mm256_madd_epi16(lstep2[40], kOne);

1492

lstep2[41] = _mm256_madd_epi16(lstep2[41], kOne);

1493

lstep2[42] = _mm256_madd_epi16(lstep2[42], kOne);

1494

lstep2[43] = _mm256_madd_epi16(lstep2[43], kOne);

1495

lstep2[44] = _mm256_madd_epi16(lstep2[44], kOne);

1496

lstep2[45] = _mm256_madd_epi16(lstep2[45], kOne);

1497

lstep2[46] = _mm256_madd_epi16(lstep2[46], kOne);

1498

lstep2[47] = _mm256_madd_epi16(lstep2[47], kOne);

1499

lstep2[48] = _mm256_madd_epi16(lstep2[48], kOne);

1500

lstep2[49] = _mm256_madd_epi16(lstep2[49], kOne);

1501

lstep2[50] = _mm256_madd_epi16(lstep2[50], kOne);

1502

lstep2[51] = _mm256_madd_epi16(lstep2[51], kOne);

1503

lstep2[52] = _mm256_madd_epi16(lstep2[52], kOne);

1504

lstep2[53] = _mm256_madd_epi16(lstep2[53], kOne);

1505

lstep2[54] = _mm256_madd_epi16(lstep2[54], kOne);

1506

lstep2[55] = _mm256_madd_epi16(lstep2[55], kOne);

1507

1508

lstep1[32] = _mm256_unpacklo_epi16(step1[16], kZero);

1509

lstep1[33] = _mm256_unpackhi_epi16(step1[16], kZero);

1510

lstep1[34] = _mm256_unpacklo_epi16(step1[17], kZero);

1511

lstep1[35] = _mm256_unpackhi_epi16(step1[17], kZero);

1512

lstep1[36] = _mm256_unpacklo_epi16(step1[18], kZero);

1513

lstep1[37] = _mm256_unpackhi_epi16(step1[18], kZero);

1514

lstep1[38] = _mm256_unpacklo_epi16(step1[19], kZero);

1515

lstep1[39] = _mm256_unpackhi_epi16(step1[19], kZero);

1516

lstep1[56] = _mm256_unpacklo_epi16(step1[28], kZero);

1517

lstep1[57] = _mm256_unpackhi_epi16(step1[28], kZero);

1518

lstep1[58] = _mm256_unpacklo_epi16(step1[29], kZero);

1519

lstep1[59] = _mm256_unpackhi_epi16(step1[29], kZero);

1520

lstep1[60] = _mm256_unpacklo_epi16(step1[30], kZero);

1521

lstep1[61] = _mm256_unpackhi_epi16(step1[30], kZero);

1522

lstep1[62] = _mm256_unpacklo_epi16(step1[31], kZero);

1523

lstep1[63] = _mm256_unpackhi_epi16(step1[31], kZero);

1524

lstep1[32] = _mm256_madd_epi16(lstep1[32], kOne);

1525

lstep1[33] = _mm256_madd_epi16(lstep1[33], kOne);

1526

lstep1[34] = _mm256_madd_epi16(lstep1[34], kOne);

1527

lstep1[35] = _mm256_madd_epi16(lstep1[35], kOne);

1528

lstep1[36] = _mm256_madd_epi16(lstep1[36], kOne);

1529

lstep1[37] = _mm256_madd_epi16(lstep1[37], kOne);

1530

lstep1[38] = _mm256_madd_epi16(lstep1[38], kOne);

1531

lstep1[39] = _mm256_madd_epi16(lstep1[39], kOne);

1532

lstep1[56] = _mm256_madd_epi16(lstep1[56], kOne);

1533

lstep1[57] = _mm256_madd_epi16(lstep1[57], kOne);

1534

lstep1[58] = _mm256_madd_epi16(lstep1[58], kOne);

1535

lstep1[59] = _mm256_madd_epi16(lstep1[59], kOne);

1536

lstep1[60] = _mm256_madd_epi16(lstep1[60], kOne);

1537

lstep1[61] = _mm256_madd_epi16(lstep1[61], kOne);

1538

lstep1[62] = _mm256_madd_epi16(lstep1[62], kOne);

1539

lstep1[63] = _mm256_madd_epi16(lstep1[63], kOne);

1540

1541

lstep3[32] = _mm256_add_epi32(lstep2[46], lstep1[32]);

1542

lstep3[33] = _mm256_add_epi32(lstep2[47], lstep1[33]);

1543

1544

lstep3[34] = _mm256_add_epi32(lstep2[44], lstep1[34]);

1545

lstep3[35] = _mm256_add_epi32(lstep2[45], lstep1[35]);

1546

lstep3[36] = _mm256_add_epi32(lstep2[42], lstep1[36]);

1547

lstep3[37] = _mm256_add_epi32(lstep2[43], lstep1[37]);

1548

lstep3[38] = _mm256_add_epi32(lstep2[40], lstep1[38]);

1549

lstep3[39] = _mm256_add_epi32(lstep2[41], lstep1[39]);

1550

lstep3[40] = _mm256_sub_epi32(lstep1[38], lstep2[40]);

1551

lstep3[41] = _mm256_sub_epi32(lstep1[39], lstep2[41]);

1552

lstep3[42] = _mm256_sub_epi32(lstep1[36], lstep2[42]);

1553

lstep3[43] = _mm256_sub_epi32(lstep1[37], lstep2[43]);

1554

lstep3[44] = _mm256_sub_epi32(lstep1[34], lstep2[44]);

1555

lstep3[45] = _mm256_sub_epi32(lstep1[35], lstep2[45]);

1556

lstep3[46] = _mm256_sub_epi32(lstep1[32], lstep2[46]);

1557

lstep3[47] = _mm256_sub_epi32(lstep1[33], lstep2[47]);

1558

lstep3[48] = _mm256_sub_epi32(lstep1[62], lstep2[48]);

1559

lstep3[49] = _mm256_sub_epi32(lstep1[63], lstep2[49]);

1560

lstep3[50] = _mm256_sub_epi32(lstep1[60], lstep2[50]);

1561

lstep3[51] = _mm256_sub_epi32(lstep1[61], lstep2[51]);

1562

lstep3[52] = _mm256_sub_epi32(lstep1[58], lstep2[52]);

1563

lstep3[53] = _mm256_sub_epi32(lstep1[59], lstep2[53]);

1564

lstep3[54] = _mm256_sub_epi32(lstep1[56], lstep2[54]);

1565

lstep3[55] = _mm256_sub_epi32(lstep1[57], lstep2[55]);

1566

lstep3[56] = _mm256_add_epi32(lstep2[54], lstep1[56]);

1567

lstep3[57] = _mm256_add_epi32(lstep2[55], lstep1[57]);

1568

lstep3[58] = _mm256_add_epi32(lstep2[52], lstep1[58]);

1569

lstep3[59] = _mm256_add_epi32(lstep2[53], lstep1[59]);

1570

lstep3[60] = _mm256_add_epi32(lstep2[50], lstep1[60]);

1571

lstep3[61] = _mm256_add_epi32(lstep2[51], lstep1[61]);

1572

lstep3[62] = _mm256_add_epi32(lstep2[48], lstep1[62]);

1573

lstep3[63] = _mm256_add_epi32(lstep2[49], lstep1[63]);

}

// stage 4

{

// expanding to 32-bit length priori to addition operations

1579

lstep2[16] = _mm256_unpacklo_epi16(step2[8], kZero);

1580

lstep2[17] = _mm256_unpackhi_epi16(step2[8], kZero);

1581

lstep2[18] = _mm256_unpacklo_epi16(step2[9], kZero);

1582

lstep2[19] = _mm256_unpackhi_epi16(step2[9], kZero);

1583

lstep2[28] = _mm256_unpacklo_epi16(step2[14], kZero);

1584

lstep2[29] = _mm256_unpackhi_epi16(step2[14], kZero);

1585

lstep2[30] = _mm256_unpacklo_epi16(step2[15], kZero);

1586

lstep2[31] = _mm256_unpackhi_epi16(step2[15], kZero);

1587

lstep2[16] = _mm256_madd_epi16(lstep2[16], kOne);

1588

lstep2[17] = _mm256_madd_epi16(lstep2[17], kOne);

1589

lstep2[18] = _mm256_madd_epi16(lstep2[18], kOne);

1590

lstep2[19] = _mm256_madd_epi16(lstep2[19], kOne);

1591

lstep2[28] = _mm256_madd_epi16(lstep2[28], kOne);

1592

lstep2[29] = _mm256_madd_epi16(lstep2[29], kOne);

1593

lstep2[30] = _mm256_madd_epi16(lstep2[30], kOne);

1594

lstep2[31] = _mm256_madd_epi16(lstep2[31], kOne);

1595

1596

lstep1[0] = _mm256_add_epi32(lstep3[6], lstep3[0]);

1597

lstep1[1] = _mm256_add_epi32(lstep3[7], lstep3[1]);

1598

lstep1[2] = _mm256_add_epi32(lstep3[4], lstep3[2]);

1599

lstep1[3] = _mm256_add_epi32(lstep3[5], lstep3[3]);

1600

lstep1[4] = _mm256_sub_epi32(lstep3[2], lstep3[4]);

1601

lstep1[5] = _mm256_sub_epi32(lstep3[3], lstep3[5]);

1602

lstep1[6] = _mm256_sub_epi32(lstep3[0], lstep3[6]);

1603

lstep1[7] = _mm256_sub_epi32(lstep3[1], lstep3[7]);

1604

lstep1[16] = _mm256_add_epi32(lstep3[22], lstep2[16]);

1605

lstep1[17] = _mm256_add_epi32(lstep3[23], lstep2[17]);

1606

lstep1[18] = _mm256_add_epi32(lstep3[20], lstep2[18]);

1607

lstep1[19] = _mm256_add_epi32(lstep3[21], lstep2[19]);

1608

lstep1[20] = _mm256_sub_epi32(lstep2[18], lstep3[20]);

1609

lstep1[21] = _mm256_sub_epi32(lstep2[19], lstep3[21]);

1610

lstep1[22] = _mm256_sub_epi32(lstep2[16], lstep3[22]);

1611

lstep1[23] = _mm256_sub_epi32(lstep2[17], lstep3[23]);

1612

lstep1[24] = _mm256_sub_epi32(lstep2[30], lstep3[24]);

1613

lstep1[25] = _mm256_sub_epi32(lstep2[31], lstep3[25]);

1614

lstep1[26] = _mm256_sub_epi32(lstep2[28], lstep3[26]);

1615

lstep1[27] = _mm256_sub_epi32(lstep2[29], lstep3[27]);

1616

lstep1[28] = _mm256_add_epi32(lstep3[26], lstep2[28]);

1617

lstep1[29] = _mm256_add_epi32(lstep3[27], lstep2[29]);

1618

lstep1[30] = _mm256_add_epi32(lstep3[24], lstep2[30]);

1619

lstep1[31] = _mm256_add_epi32(lstep3[25], lstep2[31]);

1620

}

1621

{

1622

// to be continued...

1623

//

1624

const __m256i k32_p16_p16 =

1625

pair256_set_epi32(cospi_16_64, cospi_16_64);

1626

const __m256i k32_p16_m16 =

1627

pair256_set_epi32(cospi_16_64, -cospi_16_64);

1628

1629

u[0] = _mm256_unpacklo_epi32(lstep3[12], lstep3[10]);

1630

u[1] = _mm256_unpackhi_epi32(lstep3[12], lstep3[10]);

1631

u[2] = _mm256_unpacklo_epi32(lstep3[13], lstep3[11]);

1632

u[3] = _mm256_unpackhi_epi32(lstep3[13], lstep3[11]);

1633

1634

// TODO(jingning): manually inline k_madd_epi32_avx2_ to further hide

1635

// instruction latency.

1636

v[0] = k_madd_epi32_avx2(u[0], k32_p16_m16);

1637

v[1] = k_madd_epi32_avx2(u[1], k32_p16_m16);

1638

v[2] = k_madd_epi32_avx2(u[2], k32_p16_m16);

1639

v[3] = k_madd_epi32_avx2(u[3], k32_p16_m16);

1640

v[4] = k_madd_epi32_avx2(u[0], k32_p16_p16);

1641

v[5] = k_madd_epi32_avx2(u[1], k32_p16_p16);

1642

v[6] = k_madd_epi32_avx2(u[2], k32_p16_p16);

1643

v[7] = k_madd_epi32_avx2(u[3], k32_p16_p16);

1644

1645

u[0] = k_packs_epi64_avx2(v[0], v[1]);

1646

u[1] = k_packs_epi64_avx2(v[2], v[3]);

1647

u[2] = k_packs_epi64_avx2(v[4], v[5]);

1648

u[3] = k_packs_epi64_avx2(v[6], v[7]);

1649

1650

v[0] = _mm256_add_epi32(u[0], k__DCT_CONST_ROUNDING);

1651

v[1] = _mm256_add_epi32(u[1], k__DCT_CONST_ROUNDING);

1652

v[2] = _mm256_add_epi32(u[2], k__DCT_CONST_ROUNDING);

1653

v[3] = _mm256_add_epi32(u[3], k__DCT_CONST_ROUNDING);

1654

1655

lstep1[10] = _mm256_srai_epi32(v[0], DCT_CONST_BITS);

1656

lstep1[11] = _mm256_srai_epi32(v[1], DCT_CONST_BITS);

1657

lstep1[12] = _mm256_srai_epi32(v[2], DCT_CONST_BITS);

1658

lstep1[13] = _mm256_srai_epi32(v[3], DCT_CONST_BITS);

1659

}

1660

{

1661

const __m256i k32_m08_p24 =

1662

pair256_set_epi32(-cospi_8_64, cospi_24_64);

1663

const __m256i k32_m24_m08 =

1664

pair256_set_epi32(-cospi_24_64, -cospi_8_64);

1665

const __m256i k32_p24_p08 =

1666

pair256_set_epi32(cospi_24_64, cospi_8_64);

1667

1668

u[0] = _mm256_unpacklo_epi32(lstep3[36], lstep3[58]);

1669

u[1] = _mm256_unpackhi_epi32(lstep3[36], lstep3[58]);

1670

u[2] = _mm256_unpacklo_epi32(lstep3[37], lstep3[59]);

1671

u[3] = _mm256_unpackhi_epi32(lstep3[37], lstep3[59]);

1672

u[4] = _mm256_unpacklo_epi32(lstep3[38], lstep3[56]);

1673

u[5] = _mm256_unpackhi_epi32(lstep3[38], lstep3[56]);

1674

u[6] = _mm256_unpacklo_epi32(lstep3[39], lstep3[57]);

1675

u[7] = _mm256_unpackhi_epi32(lstep3[39], lstep3[57]);

1676

u[8] = _mm256_unpacklo_epi32(lstep3[40], lstep3[54]);

1677

u[9] = _mm256_unpackhi_epi32(lstep3[40], lstep3[54]);

1678

u[10] = _mm256_unpacklo_epi32(lstep3[41], lstep3[55]);

1679

u[11] = _mm256_unpackhi_epi32(lstep3[41], lstep3[55]);

1680

u[12] = _mm256_unpacklo_epi32(lstep3[42], lstep3[52]);

1681

u[13] = _mm256_unpackhi_epi32(lstep3[42], lstep3[52]);

1682

u[14] = _mm256_unpacklo_epi32(lstep3[43], lstep3[53]);

1683

u[15] = _mm256_unpackhi_epi32(lstep3[43], lstep3[53]);

1684

1685

v[0] = k_madd_epi32_avx2(u[0], k32_m08_p24);

1686

v[1] = k_madd_epi32_avx2(u[1], k32_m08_p24);

1687

v[2] = k_madd_epi32_avx2(u[2], k32_m08_p24);

1688

v[3] = k_madd_epi32_avx2(u[3], k32_m08_p24);

1689

v[4] = k_madd_epi32_avx2(u[4], k32_m08_p24);

1690

v[5] = k_madd_epi32_avx2(u[5], k32_m08_p24);

1691

v[6] = k_madd_epi32_avx2(u[6], k32_m08_p24);

1692

v[7] = k_madd_epi32_avx2(u[7], k32_m08_p24);

1693

v[8] = k_madd_epi32_avx2(u[8], k32_m24_m08);

1694

v[9] = k_madd_epi32_avx2(u[9], k32_m24_m08);

1695

v[10] = k_madd_epi32_avx2(u[10], k32_m24_m08);

1696

v[11] = k_madd_epi32_avx2(u[11], k32_m24_m08);

1697

v[12] = k_madd_epi32_avx2(u[12], k32_m24_m08);

1698

v[13] = k_madd_epi32_avx2(u[13], k32_m24_m08);

1699

v[14] = k_madd_epi32_avx2(u[14], k32_m24_m08);

1700

v[15] = k_madd_epi32_avx2(u[15], k32_m24_m08);

1701

v[16] = k_madd_epi32_avx2(u[12], k32_m08_p24);

1702

v[17] = k_madd_epi32_avx2(u[13], k32_m08_p24);

1703

v[18] = k_madd_epi32_avx2(u[14], k32_m08_p24);

1704

v[19] = k_madd_epi32_avx2(u[15], k32_m08_p24);

1705

v[20] = k_madd_epi32_avx2(u[8], k32_m08_p24);

1706

v[21] = k_madd_epi32_avx2(u[9], k32_m08_p24);

1707

v[22] = k_madd_epi32_avx2(u[10], k32_m08_p24);

1708

v[23] = k_madd_epi32_avx2(u[11], k32_m08_p24);

1709

v[24] = k_madd_epi32_avx2(u[4], k32_p24_p08);

1710

v[25] = k_madd_epi32_avx2(u[5], k32_p24_p08);

1711

v[26] = k_madd_epi32_avx2(u[6], k32_p24_p08);

1712

v[27] = k_madd_epi32_avx2(u[7], k32_p24_p08);

1713

v[28] = k_madd_epi32_avx2(u[0], k32_p24_p08);

1714

v[29] = k_madd_epi32_avx2(u[1], k32_p24_p08);

1715

v[30] = k_madd_epi32_avx2(u[2], k32_p24_p08);

1716

v[31] = k_madd_epi32_avx2(u[3], k32_p24_p08);

1717

1718

u[0] = k_packs_epi64_avx2(v[0], v[1]);

1719

u[1] = k_packs_epi64_avx2(v[2], v[3]);

1720

u[2] = k_packs_epi64_avx2(v[4], v[5]);

1721

u[3] = k_packs_epi64_avx2(v[6], v[7]);

1722

u[4] = k_packs_epi64_avx2(v[8], v[9]);

1723

u[5] = k_packs_epi64_avx2(v[10], v[11]);

1724

u[6] = k_packs_epi64_avx2(v[12], v[13]);

1725

u[7] = k_packs_epi64_avx2(v[14], v[15]);

1726

u[8] = k_packs_epi64_avx2(v[16], v[17]);

1727

u[9] = k_packs_epi64_avx2(v[18], v[19]);

1728

u[10] = k_packs_epi64_avx2(v[20], v[21]);

1729

u[11] = k_packs_epi64_avx2(v[22], v[23]);

1730

u[12] = k_packs_epi64_avx2(v[24], v[25]);

1731

u[13] = k_packs_epi64_avx2(v[26], v[27]);

1732

u[14] = k_packs_epi64_avx2(v[28], v[29]);

1733

u[15] = k_packs_epi64_avx2(v[30], v[31]);

1734

1735

v[0] = _mm256_add_epi32(u[0], k__DCT_CONST_ROUNDING);

1736

v[1] = _mm256_add_epi32(u[1], k__DCT_CONST_ROUNDING);

1737

v[2] = _mm256_add_epi32(u[2], k__DCT_CONST_ROUNDING);

1738

v[3] = _mm256_add_epi32(u[3], k__DCT_CONST_ROUNDING);

1739

v[4] = _mm256_add_epi32(u[4], k__DCT_CONST_ROUNDING);

1740

v[5] = _mm256_add_epi32(u[5], k__DCT_CONST_ROUNDING);

1741

v[6] = _mm256_add_epi32(u[6], k__DCT_CONST_ROUNDING);

1742

v[7] = _mm256_add_epi32(u[7], k__DCT_CONST_ROUNDING);

1743

v[8] = _mm256_add_epi32(u[8], k__DCT_CONST_ROUNDING);

1744

v[9] = _mm256_add_epi32(u[9], k__DCT_CONST_ROUNDING);

1745

v[10] = _mm256_add_epi32(u[10], k__DCT_CONST_ROUNDING);

1746

v[11] = _mm256_add_epi32(u[11], k__DCT_CONST_ROUNDING);

1747

v[12] = _mm256_add_epi32(u[12], k__DCT_CONST_ROUNDING);

1748

v[13] = _mm256_add_epi32(u[13], k__DCT_CONST_ROUNDING);

1749

v[14] = _mm256_add_epi32(u[14], k__DCT_CONST_ROUNDING);

1750

v[15] = _mm256_add_epi32(u[15], k__DCT_CONST_ROUNDING);

1751

1752

lstep1[36] = _mm256_srai_epi32(v[0], DCT_CONST_BITS);

1753

lstep1[37] = _mm256_srai_epi32(v[1], DCT_CONST_BITS);

1754

lstep1[38] = _mm256_srai_epi32(v[2], DCT_CONST_BITS);

1755

lstep1[39] = _mm256_srai_epi32(v[3], DCT_CONST_BITS);

1756

lstep1[40] = _mm256_srai_epi32(v[4], DCT_CONST_BITS);

1757

lstep1[41] = _mm256_srai_epi32(v[5], DCT_CONST_BITS);

1758

lstep1[42] = _mm256_srai_epi32(v[6], DCT_CONST_BITS);

1759

lstep1[43] = _mm256_srai_epi32(v[7], DCT_CONST_BITS);

1760

lstep1[52] = _mm256_srai_epi32(v[8], DCT_CONST_BITS);

1761

lstep1[53] = _mm256_srai_epi32(v[9], DCT_CONST_BITS);

1762

lstep1[54] = _mm256_srai_epi32(v[10], DCT_CONST_BITS);

1763

lstep1[55] = _mm256_srai_epi32(v[11], DCT_CONST_BITS);

1764

lstep1[56] = _mm256_srai_epi32(v[12], DCT_CONST_BITS);

1765

lstep1[57] = _mm256_srai_epi32(v[13], DCT_CONST_BITS);

1766

lstep1[58] = _mm256_srai_epi32(v[14], DCT_CONST_BITS);

1767

lstep1[59] = _mm256_srai_epi32(v[15], DCT_CONST_BITS);

}

// stage 5

{

lstep2[8] = _mm256_add_epi32(lstep1[10], lstep3[8]);

1772

lstep2[9] = _mm256_add_epi32(lstep1[11], lstep3[9]);

1773

lstep2[10] = _mm256_sub_epi32(lstep3[8], lstep1[10]);

1774

lstep2[11] = _mm256_sub_epi32(lstep3[9], lstep1[11]);

1775

lstep2[12] = _mm256_sub_epi32(lstep3[14], lstep1[12]);

1776

lstep2[13] = _mm256_sub_epi32(lstep3[15], lstep1[13]);

1777

lstep2[14] = _mm256_add_epi32(lstep1[12], lstep3[14]);

1778

lstep2[15] = _mm256_add_epi32(lstep1[13], lstep3[15]);

1779

}

1780

{

1781

const __m256i k32_p16_p16 =

1782

pair256_set_epi32(cospi_16_64, cospi_16_64);

1783

const __m256i k32_p16_m16 =

1784

pair256_set_epi32(cospi_16_64, -cospi_16_64);

1785

const __m256i k32_p24_p08 =

1786

pair256_set_epi32(cospi_24_64, cospi_8_64);

1787

const __m256i k32_m08_p24 =

1788

pair256_set_epi32(-cospi_8_64, cospi_24_64);

1789

1790

u[0] = _mm256_unpacklo_epi32(lstep1[0], lstep1[2]);

1791

u[1] = _mm256_unpackhi_epi32(lstep1[0], lstep1[2]);

1792

u[2] = _mm256_unpacklo_epi32(lstep1[1], lstep1[3]);

1793

u[3] = _mm256_unpackhi_epi32(lstep1[1], lstep1[3]);

1794

u[4] = _mm256_unpacklo_epi32(lstep1[4], lstep1[6]);

1795

u[5] = _mm256_unpackhi_epi32(lstep1[4], lstep1[6]);

1796

u[6] = _mm256_unpacklo_epi32(lstep1[5], lstep1[7]);

1797

u[7] = _mm256_unpackhi_epi32(lstep1[5], lstep1[7]);

1798

1799

// TODO(jingning): manually inline k_madd_epi32_avx2_ to further hide

1800

// instruction latency.

1801

v[0] = k_madd_epi32_avx2(u[0], k32_p16_p16);

1802

v[1] = k_madd_epi32_avx2(u[1], k32_p16_p16);

1803

v[2] = k_madd_epi32_avx2(u[2], k32_p16_p16);

1804

v[3] = k_madd_epi32_avx2(u[3], k32_p16_p16);

1805

v[4] = k_madd_epi32_avx2(u[0], k32_p16_m16);

1806

v[5] = k_madd_epi32_avx2(u[1], k32_p16_m16);

1807

v[6] = k_madd_epi32_avx2(u[2], k32_p16_m16);

1808

v[7] = k_madd_epi32_avx2(u[3], k32_p16_m16);

1809

v[8] = k_madd_epi32_avx2(u[4], k32_p24_p08);

1810

v[9] = k_madd_epi32_avx2(u[5], k32_p24_p08);

1811

v[10] = k_madd_epi32_avx2(u[6], k32_p24_p08);

1812

v[11] = k_madd_epi32_avx2(u[7], k32_p24_p08);

1813

v[12] = k_madd_epi32_avx2(u[4], k32_m08_p24);

1814

v[13] = k_madd_epi32_avx2(u[5], k32_m08_p24);

1815

v[14] = k_madd_epi32_avx2(u[6], k32_m08_p24);

1816

v[15] = k_madd_epi32_avx2(u[7], k32_m08_p24);

1817

1818

u[0] = k_packs_epi64_avx2(v[0], v[1]);

1819

u[1] = k_packs_epi64_avx2(v[2], v[3]);

1820

u[2] = k_packs_epi64_avx2(v[4], v[5]);

1821

u[3] = k_packs_epi64_avx2(v[6], v[7]);

1822

u[4] = k_packs_epi64_avx2(v[8], v[9]);

1823

u[5] = k_packs_epi64_avx2(v[10], v[11]);

1824

u[6] = k_packs_epi64_avx2(v[12], v[13]);

1825

u[7] = k_packs_epi64_avx2(v[14], v[15]);

1826

1827

v[0] = _mm256_add_epi32(u[0], k__DCT_CONST_ROUNDING);

1828

v[1] = _mm256_add_epi32(u[1], k__DCT_CONST_ROUNDING);

1829

v[2] = _mm256_add_epi32(u[2], k__DCT_CONST_ROUNDING);

1830

v[3] = _mm256_add_epi32(u[3], k__DCT_CONST_ROUNDING);

1831

v[4] = _mm256_add_epi32(u[4], k__DCT_CONST_ROUNDING);

1832

v[5] = _mm256_add_epi32(u[5], k__DCT_CONST_ROUNDING);

1833

v[6] = _mm256_add_epi32(u[6], k__DCT_CONST_ROUNDING);

1834

v[7] = _mm256_add_epi32(u[7], k__DCT_CONST_ROUNDING);

1835

1836

u[0] = _mm256_srai_epi32(v[0], DCT_CONST_BITS);

1837

u[1] = _mm256_srai_epi32(v[1], DCT_CONST_BITS);

1838

u[2] = _mm256_srai_epi32(v[2], DCT_CONST_BITS);

1839

u[3] = _mm256_srai_epi32(v[3], DCT_CONST_BITS);

1840

u[4] = _mm256_srai_epi32(v[4], DCT_CONST_BITS);

1841

u[5] = _mm256_srai_epi32(v[5], DCT_CONST_BITS);

1842

u[6] = _mm256_srai_epi32(v[6], DCT_CONST_BITS);

1843

u[7] = _mm256_srai_epi32(v[7], DCT_CONST_BITS);

1844

1845

sign[0] = _mm256_cmpgt_epi32(kZero, u[0]);

1846

sign[1] = _mm256_cmpgt_epi32(kZero, u[1]);

1847

sign[2] = _mm256_cmpgt_epi32(kZero, u[2]);

1848

sign[3] = _mm256_cmpgt_epi32(kZero, u[3]);

1849

sign[4] = _mm256_cmpgt_epi32(kZero, u[4]);

1850

sign[5] = _mm256_cmpgt_epi32(kZero, u[5]);

1851

sign[6] = _mm256_cmpgt_epi32(kZero, u[6]);

1852

sign[7] = _mm256_cmpgt_epi32(kZero, u[7]);

1853

1854

u[0] = _mm256_sub_epi32(u[0], sign[0]);

1855

u[1] = _mm256_sub_epi32(u[1], sign[1]);

1856

u[2] = _mm256_sub_epi32(u[2], sign[2]);

1857

u[3] = _mm256_sub_epi32(u[3], sign[3]);

1858

u[4] = _mm256_sub_epi32(u[4], sign[4]);

1859

u[5] = _mm256_sub_epi32(u[5], sign[5]);

1860

u[6] = _mm256_sub_epi32(u[6], sign[6]);

1861

u[7] = _mm256_sub_epi32(u[7], sign[7]);

1862

1863

u[0] = _mm256_add_epi32(u[0], K32One);

1864

u[1] = _mm256_add_epi32(u[1], K32One);

1865

u[2] = _mm256_add_epi32(u[2], K32One);

1866

u[3] = _mm256_add_epi32(u[3], K32One);

1867

u[4] = _mm256_add_epi32(u[4], K32One);

1868

u[5] = _mm256_add_epi32(u[5], K32One);

1869

u[6] = _mm256_add_epi32(u[6], K32One);

1870

u[7] = _mm256_add_epi32(u[7], K32One);

1871

1872

u[0] = _mm256_srai_epi32(u[0], 2);

1873

u[1] = _mm256_srai_epi32(u[1], 2);

1874

u[2] = _mm256_srai_epi32(u[2], 2);

1875

u[3] = _mm256_srai_epi32(u[3], 2);

1876

u[4] = _mm256_srai_epi32(u[4], 2);

1877

u[5] = _mm256_srai_epi32(u[5], 2);

1878

u[6] = _mm256_srai_epi32(u[6], 2);

1879

u[7] = _mm256_srai_epi32(u[7], 2);

1880

1881

// Combine

1882

out[0] = _mm256_packs_epi32(u[0], u[1]);

1883

out[16] = _mm256_packs_epi32(u[2], u[3]);

1884

out[8] = _mm256_packs_epi32(u[4], u[5]);

1885

out[24] = _mm256_packs_epi32(u[6], u[7]);

1886

}

1887

{

1888

const __m256i k32_m08_p24 =

1889

pair256_set_epi32(-cospi_8_64, cospi_24_64);

1890

const __m256i k32_m24_m08 =

1891

pair256_set_epi32(-cospi_24_64, -cospi_8_64);

1892

const __m256i k32_p24_p08 =

1893

pair256_set_epi32(cospi_24_64, cospi_8_64);

1894

1895

u[0] = _mm256_unpacklo_epi32(lstep1[18], lstep1[28]);

1896

u[1] = _mm256_unpackhi_epi32(lstep1[18], lstep1[28]);

1897

u[2] = _mm256_unpacklo_epi32(lstep1[19], lstep1[29]);

1898

u[3] = _mm256_unpackhi_epi32(lstep1[19], lstep1[29]);

1899

u[4] = _mm256_unpacklo_epi32(lstep1[20], lstep1[26]);

1900

u[5] = _mm256_unpackhi_epi32(lstep1[20], lstep1[26]);

1901

u[6] = _mm256_unpacklo_epi32(lstep1[21], lstep1[27]);

1902

u[7] = _mm256_unpackhi_epi32(lstep1[21], lstep1[27]);

1903

1904

v[0] = k_madd_epi32_avx2(u[0], k32_m08_p24);

1905

v[1] = k_madd_epi32_avx2(u[1], k32_m08_p24);

1906

v[2] = k_madd_epi32_avx2(u[2], k32_m08_p24);

1907

v[3] = k_madd_epi32_avx2(u[3], k32_m08_p24);

1908

v[4] = k_madd_epi32_avx2(u[4], k32_m24_m08);

1909

v[5] = k_madd_epi32_avx2(u[5], k32_m24_m08);

1910

v[6] = k_madd_epi32_avx2(u[6], k32_m24_m08);

1911

v[7] = k_madd_epi32_avx2(u[7], k32_m24_m08);

1912

v[8] = k_madd_epi32_avx2(u[4], k32_m08_p24);

1913

v[9] = k_madd_epi32_avx2(u[5], k32_m08_p24);

1914

v[10] = k_madd_epi32_avx2(u[6], k32_m08_p24);

1915

v[11] = k_madd_epi32_avx2(u[7], k32_m08_p24);

1916

v[12] = k_madd_epi32_avx2(u[0], k32_p24_p08);

1917

v[13] = k_madd_epi32_avx2(u[1], k32_p24_p08);

1918

v[14] = k_madd_epi32_avx2(u[2], k32_p24_p08);

1919

v[15] = k_madd_epi32_avx2(u[3], k32_p24_p08);

1920

1921

u[0] = k_packs_epi64_avx2(v[0], v[1]);

1922

u[1] = k_packs_epi64_avx2(v[2], v[3]);

1923

u[2] = k_packs_epi64_avx2(v[4], v[5]);

1924

u[3] = k_packs_epi64_avx2(v[6], v[7]);

1925

u[4] = k_packs_epi64_avx2(v[8], v[9]);

1926

u[5] = k_packs_epi64_avx2(v[10], v[11]);

1927

u[6] = k_packs_epi64_avx2(v[12], v[13]);

1928

u[7] = k_packs_epi64_avx2(v[14], v[15]);

1929

1930

u[0] = _mm256_add_epi32(u[0], k__DCT_CONST_ROUNDING);

1931

u[1] = _mm256_add_epi32(u[1], k__DCT_CONST_ROUNDING);

1932

u[2] = _mm256_add_epi32(u[2], k__DCT_CONST_ROUNDING);

1933

u[3] = _mm256_add_epi32(u[3], k__DCT_CONST_ROUNDING);

1934

u[4] = _mm256_add_epi32(u[4], k__DCT_CONST_ROUNDING);

1935

u[5] = _mm256_add_epi32(u[5], k__DCT_CONST_ROUNDING);

1936

u[6] = _mm256_add_epi32(u[6], k__DCT_CONST_ROUNDING);

1937

u[7] = _mm256_add_epi32(u[7], k__DCT_CONST_ROUNDING);

1938

1939

lstep2[18] = _mm256_srai_epi32(u[0], DCT_CONST_BITS);

1940

lstep2[19] = _mm256_srai_epi32(u[1], DCT_CONST_BITS);

1941

lstep2[20] = _mm256_srai_epi32(u[2], DCT_CONST_BITS);

1942

lstep2[21] = _mm256_srai_epi32(u[3], DCT_CONST_BITS);

1943

lstep2[26] = _mm256_srai_epi32(u[4], DCT_CONST_BITS);

1944

lstep2[27] = _mm256_srai_epi32(u[5], DCT_CONST_BITS);

1945

lstep2[28] = _mm256_srai_epi32(u[6], DCT_CONST_BITS);

1946

lstep2[29] = _mm256_srai_epi32(u[7], DCT_CONST_BITS);

1947

}

1948

{

1949

lstep2[32] = _mm256_add_epi32(lstep1[38], lstep3[32]);

1950

lstep2[33] = _mm256_add_epi32(lstep1[39], lstep3[33]);

1951

lstep2[34] = _mm256_add_epi32(lstep1[36], lstep3[34]);

1952

lstep2[35] = _mm256_add_epi32(lstep1[37], lstep3[35]);

1953

lstep2[36] = _mm256_sub_epi32(lstep3[34], lstep1[36]);

1954

lstep2[37] = _mm256_sub_epi32(lstep3[35], lstep1[37]);

1955

lstep2[38] = _mm256_sub_epi32(lstep3[32], lstep1[38]);

1956

lstep2[39] = _mm256_sub_epi32(lstep3[33], lstep1[39]);

1957

lstep2[40] = _mm256_sub_epi32(lstep3[46], lstep1[40]);

1958

lstep2[41] = _mm256_sub_epi32(lstep3[47], lstep1[41]);

1959

lstep2[42] = _mm256_sub_epi32(lstep3[44], lstep1[42]);

1960

lstep2[43] = _mm256_sub_epi32(lstep3[45], lstep1[43]);

1961

lstep2[44] = _mm256_add_epi32(lstep1[42], lstep3[44]);

1962

lstep2[45] = _mm256_add_epi32(lstep1[43], lstep3[45]);

1963

lstep2[46] = _mm256_add_epi32(lstep1[40], lstep3[46]);

1964

lstep2[47] = _mm256_add_epi32(lstep1[41], lstep3[47]);

1965

lstep2[48] = _mm256_add_epi32(lstep1[54], lstep3[48]);

1966

lstep2[49] = _mm256_add_epi32(lstep1[55], lstep3[49]);

1967

lstep2[50] = _mm256_add_epi32(lstep1[52], lstep3[50]);

1968

lstep2[51] = _mm256_add_epi32(lstep1[53], lstep3[51]);

1969

lstep2[52] = _mm256_sub_epi32(lstep3[50], lstep1[52]);

1970

lstep2[53] = _mm256_sub_epi32(lstep3[51], lstep1[53]);

1971

lstep2[54] = _mm256_sub_epi32(lstep3[48], lstep1[54]);

1972

lstep2[55] = _mm256_sub_epi32(lstep3[49], lstep1[55]);

1973

lstep2[56] = _mm256_sub_epi32(lstep3[62], lstep1[56]);

1974

lstep2[57] = _mm256_sub_epi32(lstep3[63], lstep1[57]);

1975

lstep2[58] = _mm256_sub_epi32(lstep3[60], lstep1[58]);

1976

lstep2[59] = _mm256_sub_epi32(lstep3[61], lstep1[59]);

1977

lstep2[60] = _mm256_add_epi32(lstep1[58], lstep3[60]);

1978

lstep2[61] = _mm256_add_epi32(lstep1[59], lstep3[61]);

1979

lstep2[62] = _mm256_add_epi32(lstep1[56], lstep3[62]);

1980

lstep2[63] = _mm256_add_epi32(lstep1[57], lstep3[63]);

}

// stage 6

{

const __m256i k32_p28_p04 =

1985

pair256_set_epi32(cospi_28_64, cospi_4_64);

1986

const __m256i k32_p12_p20 =

1987

pair256_set_epi32(cospi_12_64, cospi_20_64);

1988

const __m256i k32_m20_p12 =

1989

pair256_set_epi32(-cospi_20_64, cospi_12_64);

1990

const __m256i k32_m04_p28 =

1991

pair256_set_epi32(-cospi_4_64, cospi_28_64);

1992

1993

u[0] = _mm256_unpacklo_epi32(lstep2[8], lstep2[14]);

1994

u[1] = _mm256_unpackhi_epi32(lstep2[8], lstep2[14]);

1995

u[2] = _mm256_unpacklo_epi32(lstep2[9], lstep2[15]);

1996

u[3] = _mm256_unpackhi_epi32(lstep2[9], lstep2[15]);

1997

u[4] = _mm256_unpacklo_epi32(lstep2[10], lstep2[12]);

1998

u[5] = _mm256_unpackhi_epi32(lstep2[10], lstep2[12]);

1999

u[6] = _mm256_unpacklo_epi32(lstep2[11], lstep2[13]);

2000

u[7] = _mm256_unpackhi_epi32(lstep2[11], lstep2[13]);

2001

u[8] = _mm256_unpacklo_epi32(lstep2[10], lstep2[12]);

2002

u[9] = _mm256_unpackhi_epi32(lstep2[10], lstep2[12]);

2003

u[10] = _mm256_unpacklo_epi32(lstep2[11], lstep2[13]);

2004

u[11] = _mm256_unpackhi_epi32(lstep2[11], lstep2[13]);

2005

u[12] = _mm256_unpacklo_epi32(lstep2[8], lstep2[14]);

2006

u[13] = _mm256_unpackhi_epi32(lstep2[8], lstep2[14]);

2007

u[14] = _mm256_unpacklo_epi32(lstep2[9], lstep2[15]);

2008

u[15] = _mm256_unpackhi_epi32(lstep2[9], lstep2[15]);

2009

2010

v[0] = k_madd_epi32_avx2(u[0], k32_p28_p04);

2011

v[1] = k_madd_epi32_avx2(u[1], k32_p28_p04);

2012

v[2] = k_madd_epi32_avx2(u[2], k32_p28_p04);

2013

v[3] = k_madd_epi32_avx2(u[3], k32_p28_p04);

2014

v[4] = k_madd_epi32_avx2(u[4], k32_p12_p20);

2015

v[5] = k_madd_epi32_avx2(u[5], k32_p12_p20);

2016

v[6] = k_madd_epi32_avx2(u[6], k32_p12_p20);

2017

v[7] = k_madd_epi32_avx2(u[7], k32_p12_p20);

2018

v[8] = k_madd_epi32_avx2(u[8], k32_m20_p12);

2019

v[9] = k_madd_epi32_avx2(u[9], k32_m20_p12);

2020

v[10] = k_madd_epi32_avx2(u[10], k32_m20_p12);

2021

v[11] = k_madd_epi32_avx2(u[11], k32_m20_p12);

2022

v[12] = k_madd_epi32_avx2(u[12], k32_m04_p28);

2023

v[13] = k_madd_epi32_avx2(u[13], k32_m04_p28);

2024

v[14] = k_madd_epi32_avx2(u[14], k32_m04_p28);

2025

v[15] = k_madd_epi32_avx2(u[15], k32_m04_p28);

2026

2027

u[0] = k_packs_epi64_avx2(v[0], v[1]);

2028

u[1] = k_packs_epi64_avx2(v[2], v[3]);

2029

u[2] = k_packs_epi64_avx2(v[4], v[5]);

2030

u[3] = k_packs_epi64_avx2(v[6], v[7]);

2031

u[4] = k_packs_epi64_avx2(v[8], v[9]);

2032

u[5] = k_packs_epi64_avx2(v[10], v[11]);

2033

u[6] = k_packs_epi64_avx2(v[12], v[13]);

2034

u[7] = k_packs_epi64_avx2(v[14], v[15]);

2035

2036

v[0] = _mm256_add_epi32(u[0], k__DCT_CONST_ROUNDING);

2037

v[1] = _mm256_add_epi32(u[1], k__DCT_CONST_ROUNDING);

2038

v[2] = _mm256_add_epi32(u[2], k__DCT_CONST_ROUNDING);

2039

v[3] = _mm256_add_epi32(u[3], k__DCT_CONST_ROUNDING);

2040

v[4] = _mm256_add_epi32(u[4], k__DCT_CONST_ROUNDING);

2041

v[5] = _mm256_add_epi32(u[5], k__DCT_CONST_ROUNDING);

2042

v[6] = _mm256_add_epi32(u[6], k__DCT_CONST_ROUNDING);

2043

v[7] = _mm256_add_epi32(u[7], k__DCT_CONST_ROUNDING);

2044

2045

u[0] = _mm256_srai_epi32(v[0], DCT_CONST_BITS);

2046

u[1] = _mm256_srai_epi32(v[1], DCT_CONST_BITS);

2047

u[2] = _mm256_srai_epi32(v[2], DCT_CONST_BITS);

2048

u[3] = _mm256_srai_epi32(v[3], DCT_CONST_BITS);

2049

u[4] = _mm256_srai_epi32(v[4], DCT_CONST_BITS);

2050

u[5] = _mm256_srai_epi32(v[5], DCT_CONST_BITS);

2051

u[6] = _mm256_srai_epi32(v[6], DCT_CONST_BITS);

2052

u[7] = _mm256_srai_epi32(v[7], DCT_CONST_BITS);

2053

2054

sign[0] = _mm256_cmpgt_epi32(kZero, u[0]);

2055

sign[1] = _mm256_cmpgt_epi32(kZero, u[1]);

2056

sign[2] = _mm256_cmpgt_epi32(kZero, u[2]);

2057

sign[3] = _mm256_cmpgt_epi32(kZero, u[3]);

2058

sign[4] = _mm256_cmpgt_epi32(kZero, u[4]);

2059

sign[5] = _mm256_cmpgt_epi32(kZero, u[5]);

2060

sign[6] = _mm256_cmpgt_epi32(kZero, u[6]);

2061

sign[7] = _mm256_cmpgt_epi32(kZero, u[7]);

2062

2063

u[0] = _mm256_sub_epi32(u[0], sign[0]);

2064

u[1] = _mm256_sub_epi32(u[1], sign[1]);

2065

u[2] = _mm256_sub_epi32(u[2], sign[2]);

2066

u[3] = _mm256_sub_epi32(u[3], sign[3]);

2067

u[4] = _mm256_sub_epi32(u[4], sign[4]);

2068

u[5] = _mm256_sub_epi32(u[5], sign[5]);

2069

u[6] = _mm256_sub_epi32(u[6], sign[6]);

2070

u[7] = _mm256_sub_epi32(u[7], sign[7]);

2071

2072

u[0] = _mm256_add_epi32(u[0], K32One);

2073

u[1] = _mm256_add_epi32(u[1], K32One);

2074

u[2] = _mm256_add_epi32(u[2], K32One);

2075

u[3] = _mm256_add_epi32(u[3], K32One);

2076

u[4] = _mm256_add_epi32(u[4], K32One);

2077

u[5] = _mm256_add_epi32(u[5], K32One);

2078

u[6] = _mm256_add_epi32(u[6], K32One);

2079

u[7] = _mm256_add_epi32(u[7], K32One);

2080

2081

u[0] = _mm256_srai_epi32(u[0], 2);

2082

u[1] = _mm256_srai_epi32(u[1], 2);

2083

u[2] = _mm256_srai_epi32(u[2], 2);

2084

u[3] = _mm256_srai_epi32(u[3], 2);

2085

u[4] = _mm256_srai_epi32(u[4], 2);

2086

u[5] = _mm256_srai_epi32(u[5], 2);

2087

u[6] = _mm256_srai_epi32(u[6], 2);

2088

u[7] = _mm256_srai_epi32(u[7], 2);

2089

2090

out[4] = _mm256_packs_epi32(u[0], u[1]);

2091

out[20] = _mm256_packs_epi32(u[2], u[3]);

2092

out[12] = _mm256_packs_epi32(u[4], u[5]);

2093

out[28] = _mm256_packs_epi32(u[6], u[7]);

2094

}

2095

{

2096

lstep3[16] = _mm256_add_epi32(lstep2[18], lstep1[16]);

2097

lstep3[17] = _mm256_add_epi32(lstep2[19], lstep1[17]);

2098

lstep3[18] = _mm256_sub_epi32(lstep1[16], lstep2[18]);

2099

lstep3[19] = _mm256_sub_epi32(lstep1[17], lstep2[19]);

2100

lstep3[20] = _mm256_sub_epi32(lstep1[22], lstep2[20]);

2101

lstep3[21] = _mm256_sub_epi32(lstep1[23], lstep2[21]);

2102

lstep3[22] = _mm256_add_epi32(lstep2[20], lstep1[22]);

2103

lstep3[23] = _mm256_add_epi32(lstep2[21], lstep1[23]);

2104

lstep3[24] = _mm256_add_epi32(lstep2[26], lstep1[24]);

2105

lstep3[25] = _mm256_add_epi32(lstep2[27], lstep1[25]);

2106

lstep3[26] = _mm256_sub_epi32(lstep1[24], lstep2[26]);

2107

lstep3[27] = _mm256_sub_epi32(lstep1[25], lstep2[27]);

2108

lstep3[28] = _mm256_sub_epi32(lstep1[30], lstep2[28]);

2109

lstep3[29] = _mm256_sub_epi32(lstep1[31], lstep2[29]);

2110

lstep3[30] = _mm256_add_epi32(lstep2[28], lstep1[30]);

2111

lstep3[31] = _mm256_add_epi32(lstep2[29], lstep1[31]);

2112

}

2113

{

2114

const __m256i k32_m04_p28 =

2115

pair256_set_epi32(-cospi_4_64, cospi_28_64);

2116

const __m256i k32_m28_m04 =

2117

pair256_set_epi32(-cospi_28_64, -cospi_4_64);

2118

const __m256i k32_m20_p12 =

2119

pair256_set_epi32(-cospi_20_64, cospi_12_64);

2120

const __m256i k32_m12_m20 =

2121

pair256_set_epi32(-cospi_12_64, -cospi_20_64);

2122

const __m256i k32_p12_p20 =

2123

pair256_set_epi32(cospi_12_64, cospi_20_64);

2124

const __m256i k32_p28_p04 =

2125

pair256_set_epi32(cospi_28_64, cospi_4_64);

2126

2127

u[0] = _mm256_unpacklo_epi32(lstep2[34], lstep2[60]);

2128

u[1] = _mm256_unpackhi_epi32(lstep2[34], lstep2[60]);

2129

u[2] = _mm256_unpacklo_epi32(lstep2[35], lstep2[61]);

2130

u[3] = _mm256_unpackhi_epi32(lstep2[35], lstep2[61]);

2131

u[4] = _mm256_unpacklo_epi32(lstep2[36], lstep2[58]);

2132

u[5] = _mm256_unpackhi_epi32(lstep2[36], lstep2[58]);

2133

u[6] = _mm256_unpacklo_epi32(lstep2[37], lstep2[59]);

2134

u[7] = _mm256_unpackhi_epi32(lstep2[37], lstep2[59]);

2135

u[8] = _mm256_unpacklo_epi32(lstep2[42], lstep2[52]);

2136

u[9] = _mm256_unpackhi_epi32(lstep2[42], lstep2[52]);

2137

u[10] = _mm256_unpacklo_epi32(lstep2[43], lstep2[53]);

2138

u[11] = _mm256_unpackhi_epi32(lstep2[43], lstep2[53]);

2139

u[12] = _mm256_unpacklo_epi32(lstep2[44], lstep2[50]);

2140

u[13] = _mm256_unpackhi_epi32(lstep2[44], lstep2[50]);

2141

u[14] = _mm256_unpacklo_epi32(lstep2[45], lstep2[51]);

2142

u[15] = _mm256_unpackhi_epi32(lstep2[45], lstep2[51]);

2143

2144

v[0] = k_madd_epi32_avx2(u[0], k32_m04_p28);

2145

v[1] = k_madd_epi32_avx2(u[1], k32_m04_p28);

2146

v[2] = k_madd_epi32_avx2(u[2], k32_m04_p28);

2147

v[3] = k_madd_epi32_avx2(u[3], k32_m04_p28);

2148

v[4] = k_madd_epi32_avx2(u[4], k32_m28_m04);

2149

v[5] = k_madd_epi32_avx2(u[5], k32_m28_m04);

2150

v[6] = k_madd_epi32_avx2(u[6], k32_m28_m04);

2151

v[7] = k_madd_epi32_avx2(u[7], k32_m28_m04);

2152

v[8] = k_madd_epi32_avx2(u[8], k32_m20_p12);

2153

v[9] = k_madd_epi32_avx2(u[9], k32_m20_p12);

2154

v[10] = k_madd_epi32_avx2(u[10], k32_m20_p12);

2155

v[11] = k_madd_epi32_avx2(u[11], k32_m20_p12);

2156

v[12] = k_madd_epi32_avx2(u[12], k32_m12_m20);

2157

v[13] = k_madd_epi32_avx2(u[13], k32_m12_m20);

2158

v[14] = k_madd_epi32_avx2(u[14], k32_m12_m20);

2159

v[15] = k_madd_epi32_avx2(u[15], k32_m12_m20);

2160

v[16] = k_madd_epi32_avx2(u[12], k32_m20_p12);

2161

v[17] = k_madd_epi32_avx2(u[13], k32_m20_p12);

2162

v[18] = k_madd_epi32_avx2(u[14], k32_m20_p12);

2163

v[19] = k_madd_epi32_avx2(u[15], k32_m20_p12);

2164

v[20] = k_madd_epi32_avx2(u[8], k32_p12_p20);

2165

v[21] = k_madd_epi32_avx2(u[9], k32_p12_p20);

2166

v[22] = k_madd_epi32_avx2(u[10], k32_p12_p20);

2167

v[23] = k_madd_epi32_avx2(u[11], k32_p12_p20);

2168

v[24] = k_madd_epi32_avx2(u[4], k32_m04_p28);

2169

v[25] = k_madd_epi32_avx2(u[5], k32_m04_p28);

2170

v[26] = k_madd_epi32_avx2(u[6], k32_m04_p28);

2171

v[27] = k_madd_epi32_avx2(u[7], k32_m04_p28);

2172

v[28] = k_madd_epi32_avx2(u[0], k32_p28_p04);

2173

v[29] = k_madd_epi32_avx2(u[1], k32_p28_p04);

2174

v[30] = k_madd_epi32_avx2(u[2], k32_p28_p04);

2175

v[31] = k_madd_epi32_avx2(u[3], k32_p28_p04);

2176

2177

u[0] = k_packs_epi64_avx2(v[0], v[1]);

2178

u[1] = k_packs_epi64_avx2(v[2], v[3]);

2179

u[2] = k_packs_epi64_avx2(v[4], v[5]);

2180

u[3] = k_packs_epi64_avx2(v[6], v[7]);

2181

u[4] = k_packs_epi64_avx2(v[8], v[9]);

2182

u[5] = k_packs_epi64_avx2(v[10], v[11]);

2183

u[6] = k_packs_epi64_avx2(v[12], v[13]);

2184

u[7] = k_packs_epi64_avx2(v[14], v[15]);

2185

u[8] = k_packs_epi64_avx2(v[16], v[17]);

2186

u[9] = k_packs_epi64_avx2(v[18], v[19]);

2187

u[10] = k_packs_epi64_avx2(v[20], v[21]);

2188

u[11] = k_packs_epi64_avx2(v[22], v[23]);

2189

u[12] = k_packs_epi64_avx2(v[24], v[25]);

2190

u[13] = k_packs_epi64_avx2(v[26], v[27]);

2191

u[14] = k_packs_epi64_avx2(v[28], v[29]);

2192

u[15] = k_packs_epi64_avx2(v[30], v[31]);

2193

2194

v[0] = _mm256_add_epi32(u[0], k__DCT_CONST_ROUNDING);

2195

v[1] = _mm256_add_epi32(u[1], k__DCT_CONST_ROUNDING);

2196

v[2] = _mm256_add_epi32(u[2], k__DCT_CONST_ROUNDING);

2197

v[3] = _mm256_add_epi32(u[3], k__DCT_CONST_ROUNDING);

2198

v[4] = _mm256_add_epi32(u[4], k__DCT_CONST_ROUNDING);

2199

v[5] = _mm256_add_epi32(u[5], k__DCT_CONST_ROUNDING);

2200

v[6] = _mm256_add_epi32(u[6], k__DCT_CONST_ROUNDING);

2201

v[7] = _mm256_add_epi32(u[7], k__DCT_CONST_ROUNDING);

2202

v[8] = _mm256_add_epi32(u[8], k__DCT_CONST_ROUNDING);

2203

v[9] = _mm256_add_epi32(u[9], k__DCT_CONST_ROUNDING);

2204

v[10] = _mm256_add_epi32(u[10], k__DCT_CONST_ROUNDING);

2205

v[11] = _mm256_add_epi32(u[11], k__DCT_CONST_ROUNDING);

2206

v[12] = _mm256_add_epi32(u[12], k__DCT_CONST_ROUNDING);

2207

v[13] = _mm256_add_epi32(u[13], k__DCT_CONST_ROUNDING);

2208

v[14] = _mm256_add_epi32(u[14], k__DCT_CONST_ROUNDING);

2209

v[15] = _mm256_add_epi32(u[15], k__DCT_CONST_ROUNDING);

2210

2211

lstep3[34] = _mm256_srai_epi32(v[0], DCT_CONST_BITS);

2212

lstep3[35] = _mm256_srai_epi32(v[1], DCT_CONST_BITS);

2213

lstep3[36] = _mm256_srai_epi32(v[2], DCT_CONST_BITS);

2214

lstep3[37] = _mm256_srai_epi32(v[3], DCT_CONST_BITS);

2215

lstep3[42] = _mm256_srai_epi32(v[4], DCT_CONST_BITS);

2216

lstep3[43] = _mm256_srai_epi32(v[5], DCT_CONST_BITS);

2217

lstep3[44] = _mm256_srai_epi32(v[6], DCT_CONST_BITS);

2218

lstep3[45] = _mm256_srai_epi32(v[7], DCT_CONST_BITS);

2219

lstep3[50] = _mm256_srai_epi32(v[8], DCT_CONST_BITS);

2220

lstep3[51] = _mm256_srai_epi32(v[9], DCT_CONST_BITS);

2221

lstep3[52] = _mm256_srai_epi32(v[10], DCT_CONST_BITS);

2222

lstep3[53] = _mm256_srai_epi32(v[11], DCT_CONST_BITS);

2223

lstep3[58] = _mm256_srai_epi32(v[12], DCT_CONST_BITS);

2224

lstep3[59] = _mm256_srai_epi32(v[13], DCT_CONST_BITS);

2225

lstep3[60] = _mm256_srai_epi32(v[14], DCT_CONST_BITS);

2226

lstep3[61] = _mm256_srai_epi32(v[15], DCT_CONST_BITS);

}

// stage 7

{

const __m256i k32_p30_p02 =

2231

pair256_set_epi32(cospi_30_64, cospi_2_64);

2232

const __m256i k32_p14_p18 =

2233

pair256_set_epi32(cospi_14_64, cospi_18_64);

2234

const __m256i k32_p22_p10 =

2235

pair256_set_epi32(cospi_22_64, cospi_10_64);

2236

const __m256i k32_p06_p26 =

2237

pair256_set_epi32(cospi_6_64, cospi_26_64);

2238

const __m256i k32_m26_p06 =

2239

pair256_set_epi32(-cospi_26_64, cospi_6_64);

2240

const __m256i k32_m10_p22 =

2241

pair256_set_epi32(-cospi_10_64, cospi_22_64);

2242

const __m256i k32_m18_p14 =

2243

pair256_set_epi32(-cospi_18_64, cospi_14_64);

2244

const __m256i k32_m02_p30 =

2245

pair256_set_epi32(-cospi_2_64, cospi_30_64);

2246

2247

u[0] = _mm256_unpacklo_epi32(lstep3[16], lstep3[30]);

2248

u[1] = _mm256_unpackhi_epi32(lstep3[16], lstep3[30]);

2249

u[2] = _mm256_unpacklo_epi32(lstep3[17], lstep3[31]);

2250

u[3] = _mm256_unpackhi_epi32(lstep3[17], lstep3[31]);

2251

u[4] = _mm256_unpacklo_epi32(lstep3[18], lstep3[28]);

2252

u[5] = _mm256_unpackhi_epi32(lstep3[18], lstep3[28]);

2253

u[6] = _mm256_unpacklo_epi32(lstep3[19], lstep3[29]);

2254

u[7] = _mm256_unpackhi_epi32(lstep3[19], lstep3[29]);

2255

u[8] = _mm256_unpacklo_epi32(lstep3[20], lstep3[26]);

2256

u[9] = _mm256_unpackhi_epi32(lstep3[20], lstep3[26]);

2257

u[10] = _mm256_unpacklo_epi32(lstep3[21], lstep3[27]);

2258

u[11] = _mm256_unpackhi_epi32(lstep3[21], lstep3[27]);

2259

u[12] = _mm256_unpacklo_epi32(lstep3[22], lstep3[24]);

2260

u[13] = _mm256_unpackhi_epi32(lstep3[22], lstep3[24]);

2261

u[14] = _mm256_unpacklo_epi32(lstep3[23], lstep3[25]);

2262

u[15] = _mm256_unpackhi_epi32(lstep3[23], lstep3[25]);

2263

2264

v[0] = k_madd_epi32_avx2(u[0], k32_p30_p02);

2265

v[1] = k_madd_epi32_avx2(u[1], k32_p30_p02);

2266

v[2] = k_madd_epi32_avx2(u[2], k32_p30_p02);

2267

v[3] = k_madd_epi32_avx2(u[3], k32_p30_p02);

2268

v[4] = k_madd_epi32_avx2(u[4], k32_p14_p18);

2269

v[5] = k_madd_epi32_avx2(u[5], k32_p14_p18);

2270

v[6] = k_madd_epi32_avx2(u[6], k32_p14_p18);

2271

v[7] = k_madd_epi32_avx2(u[7], k32_p14_p18);

2272

v[8] = k_madd_epi32_avx2(u[8], k32_p22_p10);

2273

v[9] = k_madd_epi32_avx2(u[9], k32_p22_p10);

2274

v[10] = k_madd_epi32_avx2(u[10], k32_p22_p10);

2275

v[11] = k_madd_epi32_avx2(u[11], k32_p22_p10);

2276

v[12] = k_madd_epi32_avx2(u[12], k32_p06_p26);

2277

v[13] = k_madd_epi32_avx2(u[13], k32_p06_p26);

2278

v[14] = k_madd_epi32_avx2(u[14], k32_p06_p26);

2279

v[15] = k_madd_epi32_avx2(u[15], k32_p06_p26);

2280

v[16] = k_madd_epi32_avx2(u[12], k32_m26_p06);

2281

v[17] = k_madd_epi32_avx2(u[13], k32_m26_p06);

2282

v[18] = k_madd_epi32_avx2(u[14], k32_m26_p06);

2283

v[19] = k_madd_epi32_avx2(u[15], k32_m26_p06);

2284

v[20] = k_madd_epi32_avx2(u[8], k32_m10_p22);

2285

v[21] = k_madd_epi32_avx2(u[9], k32_m10_p22);

2286

v[22] = k_madd_epi32_avx2(u[10], k32_m10_p22);

2287

v[23] = k_madd_epi32_avx2(u[11], k32_m10_p22);

2288

v[24] = k_madd_epi32_avx2(u[4], k32_m18_p14);

2289

v[25] = k_madd_epi32_avx2(u[5], k32_m18_p14);

2290

v[26] = k_madd_epi32_avx2(u[6], k32_m18_p14);

2291

v[27] = k_madd_epi32_avx2(u[7], k32_m18_p14);

2292

v[28] = k_madd_epi32_avx2(u[0], k32_m02_p30);

2293

v[29] = k_madd_epi32_avx2(u[1], k32_m02_p30);

2294

v[30] = k_madd_epi32_avx2(u[2], k32_m02_p30);

2295

v[31] = k_madd_epi32_avx2(u[3], k32_m02_p30);

2296

2297

u[0] = k_packs_epi64_avx2(v[0], v[1]);

2298

u[1] = k_packs_epi64_avx2(v[2], v[3]);

2299

u[2] = k_packs_epi64_avx2(v[4], v[5]);

2300

u[3] = k_packs_epi64_avx2(v[6], v[7]);

2301

u[4] = k_packs_epi64_avx2(v[8], v[9]);

2302

u[5] = k_packs_epi64_avx2(v[10], v[11]);

2303

u[6] = k_packs_epi64_avx2(v[12], v[13]);

2304

u[7] = k_packs_epi64_avx2(v[14], v[15]);

2305

u[8] = k_packs_epi64_avx2(v[16], v[17]);

2306

u[9] = k_packs_epi64_avx2(v[18], v[19]);

2307

u[10] = k_packs_epi64_avx2(v[20], v[21]);

2308

u[11] = k_packs_epi64_avx2(v[22], v[23]);

2309

u[12] = k_packs_epi64_avx2(v[24], v[25]);

2310

u[13] = k_packs_epi64_avx2(v[26], v[27]);

2311

u[14] = k_packs_epi64_avx2(v[28], v[29]);

2312

u[15] = k_packs_epi64_avx2(v[30], v[31]);

2313

2314

v[0] = _mm256_add_epi32(u[0], k__DCT_CONST_ROUNDING);

2315

v[1] = _mm256_add_epi32(u[1], k__DCT_CONST_ROUNDING);

2316

v[2] = _mm256_add_epi32(u[2], k__DCT_CONST_ROUNDING);

2317

v[3] = _mm256_add_epi32(u[3], k__DCT_CONST_ROUNDING);

2318

v[4] = _mm256_add_epi32(u[4], k__DCT_CONST_ROUNDING);

2319

v[5] = _mm256_add_epi32(u[5], k__DCT_CONST_ROUNDING);

2320

v[6] = _mm256_add_epi32(u[6], k__DCT_CONST_ROUNDING);

2321

v[7] = _mm256_add_epi32(u[7], k__DCT_CONST_ROUNDING);

2322

v[8] = _mm256_add_epi32(u[8], k__DCT_CONST_ROUNDING);

2323

v[9] = _mm256_add_epi32(u[9], k__DCT_CONST_ROUNDING);

2324

v[10] = _mm256_add_epi32(u[10], k__DCT_CONST_ROUNDING);

2325

v[11] = _mm256_add_epi32(u[11], k__DCT_CONST_ROUNDING);

2326

v[12] = _mm256_add_epi32(u[12], k__DCT_CONST_ROUNDING);

2327

v[13] = _mm256_add_epi32(u[13], k__DCT_CONST_ROUNDING);

2328

v[14] = _mm256_add_epi32(u[14], k__DCT_CONST_ROUNDING);

2329

v[15] = _mm256_add_epi32(u[15], k__DCT_CONST_ROUNDING);

2330

2331

u[0] = _mm256_srai_epi32(v[0], DCT_CONST_BITS);

2332

u[1] = _mm256_srai_epi32(v[1], DCT_CONST_BITS);

2333

u[2] = _mm256_srai_epi32(v[2], DCT_CONST_BITS);

2334

u[3] = _mm256_srai_epi32(v[3], DCT_CONST_BITS);

2335

u[4] = _mm256_srai_epi32(v[4], DCT_CONST_BITS);

2336

u[5] = _mm256_srai_epi32(v[5], DCT_CONST_BITS);

2337

u[6] = _mm256_srai_epi32(v[6], DCT_CONST_BITS);

2338

u[7] = _mm256_srai_epi32(v[7], DCT_CONST_BITS);

2339

u[8] = _mm256_srai_epi32(v[8], DCT_CONST_BITS);

2340

u[9] = _mm256_srai_epi32(v[9], DCT_CONST_BITS);

2341

u[10] = _mm256_srai_epi32(v[10], DCT_CONST_BITS);

2342

u[11] = _mm256_srai_epi32(v[11], DCT_CONST_BITS);

2343

u[12] = _mm256_srai_epi32(v[12], DCT_CONST_BITS);

2344

u[13] = _mm256_srai_epi32(v[13], DCT_CONST_BITS);

2345

u[14] = _mm256_srai_epi32(v[14], DCT_CONST_BITS);

2346

u[15] = _mm256_srai_epi32(v[15], DCT_CONST_BITS);

2347

2348

v[0] = _mm256_cmpgt_epi32(kZero, u[0]);

2349

v[1] = _mm256_cmpgt_epi32(kZero, u[1]);

2350

v[2] = _mm256_cmpgt_epi32(kZero, u[2]);

2351

v[3] = _mm256_cmpgt_epi32(kZero, u[3]);

2352

v[4] = _mm256_cmpgt_epi32(kZero, u[4]);

2353

v[5] = _mm256_cmpgt_epi32(kZero, u[5]);

2354

v[6] = _mm256_cmpgt_epi32(kZero, u[6]);

2355

v[7] = _mm256_cmpgt_epi32(kZero, u[7]);

2356

v[8] = _mm256_cmpgt_epi32(kZero, u[8]);

2357

v[9] = _mm256_cmpgt_epi32(kZero, u[9]);

2358

v[10] = _mm256_cmpgt_epi32(kZero, u[10]);

2359

v[11] = _mm256_cmpgt_epi32(kZero, u[11]);

2360

v[12] = _mm256_cmpgt_epi32(kZero, u[12]);

2361

v[13] = _mm256_cmpgt_epi32(kZero, u[13]);

2362

v[14] = _mm256_cmpgt_epi32(kZero, u[14]);

2363

v[15] = _mm256_cmpgt_epi32(kZero, u[15]);

2364

2365

u[0] = _mm256_sub_epi32(u[0], v[0]);

2366

u[1] = _mm256_sub_epi32(u[1], v[1]);

2367

u[2] = _mm256_sub_epi32(u[2], v[2]);

2368

u[3] = _mm256_sub_epi32(u[3], v[3]);

2369

u[4] = _mm256_sub_epi32(u[4], v[4]);

2370

u[5] = _mm256_sub_epi32(u[5], v[5]);

2371

u[6] = _mm256_sub_epi32(u[6], v[6]);

2372

u[7] = _mm256_sub_epi32(u[7], v[7]);

2373

u[8] = _mm256_sub_epi32(u[8], v[8]);

2374

u[9] = _mm256_sub_epi32(u[9], v[9]);

2375

u[10] = _mm256_sub_epi32(u[10], v[10]);

2376

u[11] = _mm256_sub_epi32(u[11], v[11]);

2377

u[12] = _mm256_sub_epi32(u[12], v[12]);

2378

u[13] = _mm256_sub_epi32(u[13], v[13]);

2379

u[14] = _mm256_sub_epi32(u[14], v[14]);

2380

u[15] = _mm256_sub_epi32(u[15], v[15]);

2381

2382

v[0] = _mm256_add_epi32(u[0], K32One);

2383

v[1] = _mm256_add_epi32(u[1], K32One);

2384

v[2] = _mm256_add_epi32(u[2], K32One);

2385

v[3] = _mm256_add_epi32(u[3], K32One);

2386

v[4] = _mm256_add_epi32(u[4], K32One);

2387

v[5] = _mm256_add_epi32(u[5], K32One);

2388

v[6] = _mm256_add_epi32(u[6], K32One);

2389

v[7] = _mm256_add_epi32(u[7], K32One);

2390

v[8] = _mm256_add_epi32(u[8], K32One);

2391

v[9] = _mm256_add_epi32(u[9], K32One);

2392

v[10] = _mm256_add_epi32(u[10], K32One);

2393

v[11] = _mm256_add_epi32(u[11], K32One);

2394

v[12] = _mm256_add_epi32(u[12], K32One);

2395

v[13] = _mm256_add_epi32(u[13], K32One);

2396

v[14] = _mm256_add_epi32(u[14], K32One);

2397

v[15] = _mm256_add_epi32(u[15], K32One);

2398

2399

u[0] = _mm256_srai_epi32(v[0], 2);

2400

u[1] = _mm256_srai_epi32(v[1], 2);

2401

u[2] = _mm256_srai_epi32(v[2], 2);

2402

u[3] = _mm256_srai_epi32(v[3], 2);

2403

u[4] = _mm256_srai_epi32(v[4], 2);

2404

u[5] = _mm256_srai_epi32(v[5], 2);

2405

u[6] = _mm256_srai_epi32(v[6], 2);

2406

u[7] = _mm256_srai_epi32(v[7], 2);

2407

u[8] = _mm256_srai_epi32(v[8], 2);

2408

u[9] = _mm256_srai_epi32(v[9], 2);

2409

u[10] = _mm256_srai_epi32(v[10], 2);

2410

u[11] = _mm256_srai_epi32(v[11], 2);

2411

u[12] = _mm256_srai_epi32(v[12], 2);

2412

u[13] = _mm256_srai_epi32(v[13], 2);

2413

u[14] = _mm256_srai_epi32(v[14], 2);

2414

u[15] = _mm256_srai_epi32(v[15], 2);

2415

2416

out[2] = _mm256_packs_epi32(u[0], u[1]);

2417

out[18] = _mm256_packs_epi32(u[2], u[3]);

2418

out[10] = _mm256_packs_epi32(u[4], u[5]);

2419

out[26] = _mm256_packs_epi32(u[6], u[7]);

2420

out[6] = _mm256_packs_epi32(u[8], u[9]);

2421

out[22] = _mm256_packs_epi32(u[10], u[11]);

2422

out[14] = _mm256_packs_epi32(u[12], u[13]);

2423

out[30] = _mm256_packs_epi32(u[14], u[15]);

2424

}

2425

{

2426

lstep1[32] = _mm256_add_epi32(lstep3[34], lstep2[32]);

2427

lstep1[33] = _mm256_add_epi32(lstep3[35], lstep2[33]);

2428

lstep1[34] = _mm256_sub_epi32(lstep2[32], lstep3[34]);

2429

lstep1[35] = _mm256_sub_epi32(lstep2[33], lstep3[35]);

2430

lstep1[36] = _mm256_sub_epi32(lstep2[38], lstep3[36]);

2431

lstep1[37] = _mm256_sub_epi32(lstep2[39], lstep3[37]);

2432

lstep1[38] = _mm256_add_epi32(lstep3[36], lstep2[38]);

2433

lstep1[39] = _mm256_add_epi32(lstep3[37], lstep2[39]);

2434

lstep1[40] = _mm256_add_epi32(lstep3[42], lstep2[40]);

2435

lstep1[41] = _mm256_add_epi32(lstep3[43], lstep2[41]);

2436

lstep1[42] = _mm256_sub_epi32(lstep2[40], lstep3[42]);

2437

lstep1[43] = _mm256_sub_epi32(lstep2[41], lstep3[43]);

2438

lstep1[44] = _mm256_sub_epi32(lstep2[46], lstep3[44]);

2439

lstep1[45] = _mm256_sub_epi32(lstep2[47], lstep3[45]);

2440

lstep1[46] = _mm256_add_epi32(lstep3[44], lstep2[46]);

2441

lstep1[47] = _mm256_add_epi32(lstep3[45], lstep2[47]);

2442

lstep1[48] = _mm256_add_epi32(lstep3[50], lstep2[48]);

2443

lstep1[49] = _mm256_add_epi32(lstep3[51], lstep2[49]);

2444

lstep1[50] = _mm256_sub_epi32(lstep2[48], lstep3[50]);

2445

lstep1[51] = _mm256_sub_epi32(lstep2[49], lstep3[51]);

2446

lstep1[52] = _mm256_sub_epi32(lstep2[54], lstep3[52]);

2447

lstep1[53] = _mm256_sub_epi32(lstep2[55], lstep3[53]);

2448

lstep1[54] = _mm256_add_epi32(lstep3[52], lstep2[54]);

2449

lstep1[55] = _mm256_add_epi32(lstep3[53], lstep2[55]);

2450

lstep1[56] = _mm256_add_epi32(lstep3[58], lstep2[56]);

2451

lstep1[57] = _mm256_add_epi32(lstep3[59], lstep2[57]);

2452

lstep1[58] = _mm256_sub_epi32(lstep2[56], lstep3[58]);

2453

lstep1[59] = _mm256_sub_epi32(lstep2[57], lstep3[59]);

2454

lstep1[60] = _mm256_sub_epi32(lstep2[62], lstep3[60]);

2455

lstep1[61] = _mm256_sub_epi32(lstep2[63], lstep3[61]);

2456

lstep1[62] = _mm256_add_epi32(lstep3[60], lstep2[62]);

2457

lstep1[63] = _mm256_add_epi32(lstep3[61], lstep2[63]);

}

// stage 8

{

const __m256i k32_p31_p01 =

2462

pair256_set_epi32(cospi_31_64, cospi_1_64);

2463

const __m256i k32_p15_p17 =

2464

pair256_set_epi32(cospi_15_64, cospi_17_64);

2465

const __m256i k32_p23_p09 =

2466

pair256_set_epi32(cospi_23_64, cospi_9_64);

2467

const __m256i k32_p07_p25 =

2468

pair256_set_epi32(cospi_7_64, cospi_25_64);

2469

const __m256i k32_m25_p07 =

2470

pair256_set_epi32(-cospi_25_64, cospi_7_64);

2471

const __m256i k32_m09_p23 =

2472

pair256_set_epi32(-cospi_9_64, cospi_23_64);

2473

const __m256i k32_m17_p15 =

2474

pair256_set_epi32(-cospi_17_64, cospi_15_64);

2475

const __m256i k32_m01_p31 =

2476

pair256_set_epi32(-cospi_1_64, cospi_31_64);

2477

2478

u[0] = _mm256_unpacklo_epi32(lstep1[32], lstep1[62]);

2479

u[1] = _mm256_unpackhi_epi32(lstep1[32], lstep1[62]);

2480

u[2] = _mm256_unpacklo_epi32(lstep1[33], lstep1[63]);

2481

u[3] = _mm256_unpackhi_epi32(lstep1[33], lstep1[63]);

2482

u[4] = _mm256_unpacklo_epi32(lstep1[34], lstep1[60]);

2483

u[5] = _mm256_unpackhi_epi32(lstep1[34], lstep1[60]);

2484

u[6] = _mm256_unpacklo_epi32(lstep1[35], lstep1[61]);

2485

u[7] = _mm256_unpackhi_epi32(lstep1[35], lstep1[61]);

2486

u[8] = _mm256_unpacklo_epi32(lstep1[36], lstep1[58]);

2487

u[9] = _mm256_unpackhi_epi32(lstep1[36], lstep1[58]);

2488

u[10] = _mm256_unpacklo_epi32(lstep1[37], lstep1[59]);

2489

u[11] = _mm256_unpackhi_epi32(lstep1[37], lstep1[59]);

2490

u[12] = _mm256_unpacklo_epi32(lstep1[38], lstep1[56]);

2491

u[13] = _mm256_unpackhi_epi32(lstep1[38], lstep1[56]);

2492

u[14] = _mm256_unpacklo_epi32(lstep1[39], lstep1[57]);

2493

u[15] = _mm256_unpackhi_epi32(lstep1[39], lstep1[57]);

2494

2495

v[0] = k_madd_epi32_avx2(u[0], k32_p31_p01);

2496

v[1] = k_madd_epi32_avx2(u[1], k32_p31_p01);

2497

v[2] = k_madd_epi32_avx2(u[2], k32_p31_p01);

2498

v[3] = k_madd_epi32_avx2(u[3], k32_p31_p01);

2499

v[4] = k_madd_epi32_avx2(u[4], k32_p15_p17);

2500

v[5] = k_madd_epi32_avx2(u[5], k32_p15_p17);

2501

v[6] = k_madd_epi32_avx2(u[6], k32_p15_p17);

2502

v[7] = k_madd_epi32_avx2(u[7], k32_p15_p17);

2503

v[8] = k_madd_epi32_avx2(u[8], k32_p23_p09);

2504

v[9] = k_madd_epi32_avx2(u[9], k32_p23_p09);

2505

v[10] = k_madd_epi32_avx2(u[10], k32_p23_p09);

2506

v[11] = k_madd_epi32_avx2(u[11], k32_p23_p09);

2507

v[12] = k_madd_epi32_avx2(u[12], k32_p07_p25);

2508

v[13] = k_madd_epi32_avx2(u[13], k32_p07_p25);

2509

v[14] = k_madd_epi32_avx2(u[14], k32_p07_p25);

2510

v[15] = k_madd_epi32_avx2(u[15], k32_p07_p25);

2511

v[16] = k_madd_epi32_avx2(u[12], k32_m25_p07);

2512

v[17] = k_madd_epi32_avx2(u[13], k32_m25_p07);

2513

v[18] = k_madd_epi32_avx2(u[14], k32_m25_p07);

2514

v[19] = k_madd_epi32_avx2(u[15], k32_m25_p07);

2515

v[20] = k_madd_epi32_avx2(u[8], k32_m09_p23);

2516

v[21] = k_madd_epi32_avx2(u[9], k32_m09_p23);

2517

v[22] = k_madd_epi32_avx2(u[10], k32_m09_p23);

2518

v[23] = k_madd_epi32_avx2(u[11], k32_m09_p23);

2519

v[24] = k_madd_epi32_avx2(u[4], k32_m17_p15);

2520

v[25] = k_madd_epi32_avx2(u[5], k32_m17_p15);

2521

v[26] = k_madd_epi32_avx2(u[6], k32_m17_p15);

2522

v[27] = k_madd_epi32_avx2(u[7], k32_m17_p15);

2523

v[28] = k_madd_epi32_avx2(u[0], k32_m01_p31);

2524

v[29] = k_madd_epi32_avx2(u[1], k32_m01_p31);

2525

v[30] = k_madd_epi32_avx2(u[2], k32_m01_p31);

2526

v[31] = k_madd_epi32_avx2(u[3], k32_m01_p31);

2527

2528

u[0] = k_packs_epi64_avx2(v[0], v[1]);

2529

u[1] = k_packs_epi64_avx2(v[2], v[3]);

2530

u[2] = k_packs_epi64_avx2(v[4], v[5]);

2531

u[3] = k_packs_epi64_avx2(v[6], v[7]);

2532

u[4] = k_packs_epi64_avx2(v[8], v[9]);

2533

u[5] = k_packs_epi64_avx2(v[10], v[11]);

2534

u[6] = k_packs_epi64_avx2(v[12], v[13]);

2535

u[7] = k_packs_epi64_avx2(v[14], v[15]);

2536

u[8] = k_packs_epi64_avx2(v[16], v[17]);

2537

u[9] = k_packs_epi64_avx2(v[18], v[19]);

2538

u[10] = k_packs_epi64_avx2(v[20], v[21]);

2539

u[11] = k_packs_epi64_avx2(v[22], v[23]);

2540

u[12] = k_packs_epi64_avx2(v[24], v[25]);

2541

u[13] = k_packs_epi64_avx2(v[26], v[27]);

2542

u[14] = k_packs_epi64_avx2(v[28], v[29]);

2543

u[15] = k_packs_epi64_avx2(v[30], v[31]);

2544

2545

v[0] = _mm256_add_epi32(u[0], k__DCT_CONST_ROUNDING);

2546

v[1] = _mm256_add_epi32(u[1], k__DCT_CONST_ROUNDING);

2547

v[2] = _mm256_add_epi32(u[2], k__DCT_CONST_ROUNDING);

2548

v[3] = _mm256_add_epi32(u[3], k__DCT_CONST_ROUNDING);

2549

v[4] = _mm256_add_epi32(u[4], k__DCT_CONST_ROUNDING);

2550

v[5] = _mm256_add_epi32(u[5], k__DCT_CONST_ROUNDING);

2551

v[6] = _mm256_add_epi32(u[6], k__DCT_CONST_ROUNDING);

2552

v[7] = _mm256_add_epi32(u[7], k__DCT_CONST_ROUNDING);

2553

v[8] = _mm256_add_epi32(u[8], k__DCT_CONST_ROUNDING);

2554

v[9] = _mm256_add_epi32(u[9], k__DCT_CONST_ROUNDING);

2555

v[10] = _mm256_add_epi32(u[10], k__DCT_CONST_ROUNDING);

2556

v[11] = _mm256_add_epi32(u[11], k__DCT_CONST_ROUNDING);

2557

v[12] = _mm256_add_epi32(u[12], k__DCT_CONST_ROUNDING);

2558

v[13] = _mm256_add_epi32(u[13], k__DCT_CONST_ROUNDING);

2559

v[14] = _mm256_add_epi32(u[14], k__DCT_CONST_ROUNDING);

2560

v[15] = _mm256_add_epi32(u[15], k__DCT_CONST_ROUNDING);

2561

2562

u[0] = _mm256_srai_epi32(v[0], DCT_CONST_BITS);

2563

u[1] = _mm256_srai_epi32(v[1], DCT_CONST_BITS);

2564

u[2] = _mm256_srai_epi32(v[2], DCT_CONST_BITS);

2565

u[3] = _mm256_srai_epi32(v[3], DCT_CONST_BITS);

2566

u[4] = _mm256_srai_epi32(v[4], DCT_CONST_BITS);

2567

u[5] = _mm256_srai_epi32(v[5], DCT_CONST_BITS);

2568

u[6] = _mm256_srai_epi32(v[6], DCT_CONST_BITS);

2569

u[7] = _mm256_srai_epi32(v[7], DCT_CONST_BITS);

2570

u[8] = _mm256_srai_epi32(v[8], DCT_CONST_BITS);

2571

u[9] = _mm256_srai_epi32(v[9], DCT_CONST_BITS);

2572

u[10] = _mm256_srai_epi32(v[10], DCT_CONST_BITS);

2573

u[11] = _mm256_srai_epi32(v[11], DCT_CONST_BITS);

2574

u[12] = _mm256_srai_epi32(v[12], DCT_CONST_BITS);

2575

u[13] = _mm256_srai_epi32(v[13], DCT_CONST_BITS);

2576

u[14] = _mm256_srai_epi32(v[14], DCT_CONST_BITS);

2577

u[15] = _mm256_srai_epi32(v[15], DCT_CONST_BITS);

2578

2579

v[0] = _mm256_cmpgt_epi32(kZero, u[0]);

2580

v[1] = _mm256_cmpgt_epi32(kZero, u[1]);

2581

v[2] = _mm256_cmpgt_epi32(kZero, u[2]);

2582

v[3] = _mm256_cmpgt_epi32(kZero, u[3]);

2583

v[4] = _mm256_cmpgt_epi32(kZero, u[4]);

2584

v[5] = _mm256_cmpgt_epi32(kZero, u[5]);

2585

v[6] = _mm256_cmpgt_epi32(kZero, u[6]);

2586

v[7] = _mm256_cmpgt_epi32(kZero, u[7]);

2587

v[8] = _mm256_cmpgt_epi32(kZero, u[8]);

2588

v[9] = _mm256_cmpgt_epi32(kZero, u[9]);

2589

v[10] = _mm256_cmpgt_epi32(kZero, u[10]);

2590

v[11] = _mm256_cmpgt_epi32(kZero, u[11]);

2591

v[12] = _mm256_cmpgt_epi32(kZero, u[12]);

2592

v[13] = _mm256_cmpgt_epi32(kZero, u[13]);

2593

v[14] = _mm256_cmpgt_epi32(kZero, u[14]);

2594

v[15] = _mm256_cmpgt_epi32(kZero, u[15]);

2595

2596

u[0] = _mm256_sub_epi32(u[0], v[0]);

2597

u[1] = _mm256_sub_epi32(u[1], v[1]);

2598

u[2] = _mm256_sub_epi32(u[2], v[2]);

2599

u[3] = _mm256_sub_epi32(u[3], v[3]);

2600

u[4] = _mm256_sub_epi32(u[4], v[4]);

2601

u[5] = _mm256_sub_epi32(u[5], v[5]);

2602

u[6] = _mm256_sub_epi32(u[6], v[6]);

2603

u[7] = _mm256_sub_epi32(u[7], v[7]);

2604

u[8] = _mm256_sub_epi32(u[8], v[8]);

2605

u[9] = _mm256_sub_epi32(u[9], v[9]);

2606

u[10] = _mm256_sub_epi32(u[10], v[10]);

2607

u[11] = _mm256_sub_epi32(u[11], v[11]);

2608

u[12] = _mm256_sub_epi32(u[12], v[12]);

2609

u[13] = _mm256_sub_epi32(u[13], v[13]);

2610

u[14] = _mm256_sub_epi32(u[14], v[14]);

2611

u[15] = _mm256_sub_epi32(u[15], v[15]);

2612

2613

v[0] = _mm256_add_epi32(u[0], K32One);

2614

v[1] = _mm256_add_epi32(u[1], K32One);

2615

v[2] = _mm256_add_epi32(u[2], K32One);

2616

v[3] = _mm256_add_epi32(u[3], K32One);

2617

v[4] = _mm256_add_epi32(u[4], K32One);

2618

v[5] = _mm256_add_epi32(u[5], K32One);

2619

v[6] = _mm256_add_epi32(u[6], K32One);

2620

v[7] = _mm256_add_epi32(u[7], K32One);

2621

v[8] = _mm256_add_epi32(u[8], K32One);

2622

v[9] = _mm256_add_epi32(u[9], K32One);

2623

v[10] = _mm256_add_epi32(u[10], K32One);

2624

v[11] = _mm256_add_epi32(u[11], K32One);

2625

v[12] = _mm256_add_epi32(u[12], K32One);

2626

v[13] = _mm256_add_epi32(u[13], K32One);

2627

v[14] = _mm256_add_epi32(u[14], K32One);

2628

v[15] = _mm256_add_epi32(u[15], K32One);

2629

2630

u[0] = _mm256_srai_epi32(v[0], 2);

2631

u[1] = _mm256_srai_epi32(v[1], 2);

2632

u[2] = _mm256_srai_epi32(v[2], 2);

2633

u[3] = _mm256_srai_epi32(v[3], 2);

2634

u[4] = _mm256_srai_epi32(v[4], 2);

2635

u[5] = _mm256_srai_epi32(v[5], 2);

2636

u[6] = _mm256_srai_epi32(v[6], 2);

2637

u[7] = _mm256_srai_epi32(v[7], 2);

2638

u[8] = _mm256_srai_epi32(v[8], 2);

2639

u[9] = _mm256_srai_epi32(v[9], 2);

2640

u[10] = _mm256_srai_epi32(v[10], 2);

2641

u[11] = _mm256_srai_epi32(v[11], 2);

2642

u[12] = _mm256_srai_epi32(v[12], 2);

2643

u[13] = _mm256_srai_epi32(v[13], 2);

2644

u[14] = _mm256_srai_epi32(v[14], 2);

2645

u[15] = _mm256_srai_epi32(v[15], 2);

2646

2647

out[1] = _mm256_packs_epi32(u[0], u[1]);

2648

out[17] = _mm256_packs_epi32(u[2], u[3]);

2649

out[9] = _mm256_packs_epi32(u[4], u[5]);

2650

out[25] = _mm256_packs_epi32(u[6], u[7]);

2651

out[7] = _mm256_packs_epi32(u[8], u[9]);

2652

out[23] = _mm256_packs_epi32(u[10], u[11]);

2653

out[15] = _mm256_packs_epi32(u[12], u[13]);

2654

out[31] = _mm256_packs_epi32(u[14], u[15]);

2655

}

2656

{

2657

const __m256i k32_p27_p05 =

2658

pair256_set_epi32(cospi_27_64, cospi_5_64);

2659

const __m256i k32_p11_p21 =

2660

pair256_set_epi32(cospi_11_64, cospi_21_64);

2661

const __m256i k32_p19_p13 =

2662

pair256_set_epi32(cospi_19_64, cospi_13_64);

2663

const __m256i k32_p03_p29 =

2664

pair256_set_epi32(cospi_3_64, cospi_29_64);

2665

const __m256i k32_m29_p03 =

2666

pair256_set_epi32(-cospi_29_64, cospi_3_64);

2667

const __m256i k32_m13_p19 =

2668

pair256_set_epi32(-cospi_13_64, cospi_19_64);

2669

const __m256i k32_m21_p11 =

2670

pair256_set_epi32(-cospi_21_64, cospi_11_64);

2671

const __m256i k32_m05_p27 =

2672

pair256_set_epi32(-cospi_5_64, cospi_27_64);

2673

2674

u[0] = _mm256_unpacklo_epi32(lstep1[40], lstep1[54]);

2675

u[1] = _mm256_unpackhi_epi32(lstep1[40], lstep1[54]);

2676

u[2] = _mm256_unpacklo_epi32(lstep1[41], lstep1[55]);

2677

u[3] = _mm256_unpackhi_epi32(lstep1[41], lstep1[55]);

2678

u[4] = _mm256_unpacklo_epi32(lstep1[42], lstep1[52]);

2679

u[5] = _mm256_unpackhi_epi32(lstep1[42], lstep1[52]);

2680

u[6] = _mm256_unpacklo_epi32(lstep1[43], lstep1[53]);

2681

u[7] = _mm256_unpackhi_epi32(lstep1[43], lstep1[53]);

2682

u[8] = _mm256_unpacklo_epi32(lstep1[44], lstep1[50]);

2683

u[9] = _mm256_unpackhi_epi32(lstep1[44], lstep1[50]);

2684

u[10] = _mm256_unpacklo_epi32(lstep1[45], lstep1[51]);

2685

u[11] = _mm256_unpackhi_epi32(lstep1[45], lstep1[51]);

2686

u[12] = _mm256_unpacklo_epi32(lstep1[46], lstep1[48]);

2687

u[13] = _mm256_unpackhi_epi32(lstep1[46], lstep1[48]);

2688

u[14] = _mm256_unpacklo_epi32(lstep1[47], lstep1[49]);

2689

u[15] = _mm256_unpackhi_epi32(lstep1[47], lstep1[49]);

2690

2691

v[0] = k_madd_epi32_avx2(u[0], k32_p27_p05);

2692

v[1] = k_madd_epi32_avx2(u[1], k32_p27_p05);

2693

v[2] = k_madd_epi32_avx2(u[2], k32_p27_p05);

2694

v[3] = k_madd_epi32_avx2(u[3], k32_p27_p05);

2695

v[4] = k_madd_epi32_avx2(u[4], k32_p11_p21);

2696

v[5] = k_madd_epi32_avx2(u[5], k32_p11_p21);

2697

v[6] = k_madd_epi32_avx2(u[6], k32_p11_p21);

2698

v[7] = k_madd_epi32_avx2(u[7], k32_p11_p21);

2699

v[8] = k_madd_epi32_avx2(u[8], k32_p19_p13);

2700

v[9] = k_madd_epi32_avx2(u[9], k32_p19_p13);

2701

v[10] = k_madd_epi32_avx2(u[10], k32_p19_p13);

2702

v[11] = k_madd_epi32_avx2(u[11], k32_p19_p13);

2703

v[12] = k_madd_epi32_avx2(u[12], k32_p03_p29);

2704

v[13] = k_madd_epi32_avx2(u[13], k32_p03_p29);

2705

v[14] = k_madd_epi32_avx2(u[14], k32_p03_p29);

2706

v[15] = k_madd_epi32_avx2(u[15], k32_p03_p29);

2707

v[16] = k_madd_epi32_avx2(u[12], k32_m29_p03);

2708

v[17] = k_madd_epi32_avx2(u[13], k32_m29_p03);

2709

v[18] = k_madd_epi32_avx2(u[14], k32_m29_p03);

2710

v[19] = k_madd_epi32_avx2(u[15], k32_m29_p03);

2711

v[20] = k_madd_epi32_avx2(u[8], k32_m13_p19);

2712

v[21] = k_madd_epi32_avx2(u[9], k32_m13_p19);

2713

v[22] = k_madd_epi32_avx2(u[10], k32_m13_p19);

2714

v[23] = k_madd_epi32_avx2(u[11], k32_m13_p19);

2715

v[24] = k_madd_epi32_avx2(u[4], k32_m21_p11);

2716

v[25] = k_madd_epi32_avx2(u[5], k32_m21_p11);

2717

v[26] = k_madd_epi32_avx2(u[6], k32_m21_p11);

2718

v[27] = k_madd_epi32_avx2(u[7], k32_m21_p11);

2719

v[28] = k_madd_epi32_avx2(u[0], k32_m05_p27);

2720

v[29] = k_madd_epi32_avx2(u[1], k32_m05_p27);

2721

v[30] = k_madd_epi32_avx2(u[2], k32_m05_p27);

2722

v[31] = k_madd_epi32_avx2(u[3], k32_m05_p27);

2723

2724

u[0] = k_packs_epi64_avx2(v[0], v[1]);

2725

u[1] = k_packs_epi64_avx2(v[2], v[3]);

2726

u[2] = k_packs_epi64_avx2(v[4], v[5]);

2727

u[3] = k_packs_epi64_avx2(v[6], v[7]);

2728

u[4] = k_packs_epi64_avx2(v[8], v[9]);

2729

u[5] = k_packs_epi64_avx2(v[10], v[11]);

2730

u[6] = k_packs_epi64_avx2(v[12], v[13]);

2731

u[7] = k_packs_epi64_avx2(v[14], v[15]);

2732

u[8] = k_packs_epi64_avx2(v[16], v[17]);

2733

u[9] = k_packs_epi64_avx2(v[18], v[19]);

2734

u[10] = k_packs_epi64_avx2(v[20], v[21]);

2735

u[11] = k_packs_epi64_avx2(v[22], v[23]);

2736

u[12] = k_packs_epi64_avx2(v[24], v[25]);

2737

u[13] = k_packs_epi64_avx2(v[26], v[27]);

2738

u[14] = k_packs_epi64_avx2(v[28], v[29]);

2739

u[15] = k_packs_epi64_avx2(v[30], v[31]);

2740

2741

v[0] = _mm256_add_epi32(u[0], k__DCT_CONST_ROUNDING);

2742

v[1] = _mm256_add_epi32(u[1], k__DCT_CONST_ROUNDING);

2743

v[2] = _mm256_add_epi32(u[2], k__DCT_CONST_ROUNDING);

2744

v[3] = _mm256_add_epi32(u[3], k__DCT_CONST_ROUNDING);

2745

v[4] = _mm256_add_epi32(u[4], k__DCT_CONST_ROUNDING);

2746

v[5] = _mm256_add_epi32(u[5], k__DCT_CONST_ROUNDING);

2747

v[6] = _mm256_add_epi32(u[6], k__DCT_CONST_ROUNDING);

2748

v[7] = _mm256_add_epi32(u[7], k__DCT_CONST_ROUNDING);

2749

v[8] = _mm256_add_epi32(u[8], k__DCT_CONST_ROUNDING);

2750

v[9] = _mm256_add_epi32(u[9], k__DCT_CONST_ROUNDING);

2751

v[10] = _mm256_add_epi32(u[10], k__DCT_CONST_ROUNDING);

2752

v[11] = _mm256_add_epi32(u[11], k__DCT_CONST_ROUNDING);

2753

v[12] = _mm256_add_epi32(u[12], k__DCT_CONST_ROUNDING);

2754

v[13] = _mm256_add_epi32(u[13], k__DCT_CONST_ROUNDING);

2755

v[14] = _mm256_add_epi32(u[14], k__DCT_CONST_ROUNDING);

2756

v[15] = _mm256_add_epi32(u[15], k__DCT_CONST_ROUNDING);

2757

2758

u[0] = _mm256_srai_epi32(v[0], DCT_CONST_BITS);

2759

u[1] = _mm256_srai_epi32(v[1], DCT_CONST_BITS);

2760

u[2] = _mm256_srai_epi32(v[2], DCT_CONST_BITS);

2761

u[3] = _mm256_srai_epi32(v[3], DCT_CONST_BITS);

2762

u[4] = _mm256_srai_epi32(v[4], DCT_CONST_BITS);

2763

u[5] = _mm256_srai_epi32(v[5], DCT_CONST_BITS);

2764

u[6] = _mm256_srai_epi32(v[6], DCT_CONST_BITS);

2765

u[7] = _mm256_srai_epi32(v[7], DCT_CONST_BITS);

2766

u[8] = _mm256_srai_epi32(v[8], DCT_CONST_BITS);

2767

u[9] = _mm256_srai_epi32(v[9], DCT_CONST_BITS);

2768

u[10] = _mm256_srai_epi32(v[10], DCT_CONST_BITS);

2769

u[11] = _mm256_srai_epi32(v[11], DCT_CONST_BITS);

2770

u[12] = _mm256_srai_epi32(v[12], DCT_CONST_BITS);

2771

u[13] = _mm256_srai_epi32(v[13], DCT_CONST_BITS);

2772

u[14] = _mm256_srai_epi32(v[14], DCT_CONST_BITS);

2773

u[15] = _mm256_srai_epi32(v[15], DCT_CONST_BITS);

2774

2775

v[0] = _mm256_cmpgt_epi32(kZero, u[0]);

2776

v[1] = _mm256_cmpgt_epi32(kZero, u[1]);

2777

v[2] = _mm256_cmpgt_epi32(kZero, u[2]);

2778

v[3] = _mm256_cmpgt_epi32(kZero, u[3]);

2779

v[4] = _mm256_cmpgt_epi32(kZero, u[4]);

2780

v[5] = _mm256_cmpgt_epi32(kZero, u[5]);

2781

v[6] = _mm256_cmpgt_epi32(kZero, u[6]);

2782

v[7] = _mm256_cmpgt_epi32(kZero, u[7]);

2783

v[8] = _mm256_cmpgt_epi32(kZero, u[8]);

2784

v[9] = _mm256_cmpgt_epi32(kZero, u[9]);

2785

v[10] = _mm256_cmpgt_epi32(kZero, u[10]);

2786

v[11] = _mm256_cmpgt_epi32(kZero, u[11]);

2787

v[12] = _mm256_cmpgt_epi32(kZero, u[12]);

2788

v[13] = _mm256_cmpgt_epi32(kZero, u[13]);

2789

v[14] = _mm256_cmpgt_epi32(kZero, u[14]);

2790

v[15] = _mm256_cmpgt_epi32(kZero, u[15]);

2791

2792

u[0] = _mm256_sub_epi32(u[0], v[0]);

2793

u[1] = _mm256_sub_epi32(u[1], v[1]);

2794

u[2] = _mm256_sub_epi32(u[2], v[2]);

2795

u[3] = _mm256_sub_epi32(u[3], v[3]);

2796

u[4] = _mm256_sub_epi32(u[4], v[4]);

2797

u[5] = _mm256_sub_epi32(u[5], v[5]);

2798

u[6] = _mm256_sub_epi32(u[6], v[6]);

2799

u[7] = _mm256_sub_epi32(u[7], v[7]);

2800

u[8] = _mm256_sub_epi32(u[8], v[8]);

2801

u[9] = _mm256_sub_epi32(u[9], v[9]);

2802

u[10] = _mm256_sub_epi32(u[10], v[10]);

2803

u[11] = _mm256_sub_epi32(u[11], v[11]);

2804

u[12] = _mm256_sub_epi32(u[12], v[12]);

2805

u[13] = _mm256_sub_epi32(u[13], v[13]);

2806

u[14] = _mm256_sub_epi32(u[14], v[14]);

2807

u[15] = _mm256_sub_epi32(u[15], v[15]);

2808

2809

v[0] = _mm256_add_epi32(u[0], K32One);

2810

v[1] = _mm256_add_epi32(u[1], K32One);

2811

v[2] = _mm256_add_epi32(u[2], K32One);

2812

v[3] = _mm256_add_epi32(u[3], K32One);

2813

v[4] = _mm256_add_epi32(u[4], K32One);

2814

v[5] = _mm256_add_epi32(u[5], K32One);

2815

v[6] = _mm256_add_epi32(u[6], K32One);

2816

v[7] = _mm256_add_epi32(u[7], K32One);

2817

v[8] = _mm256_add_epi32(u[8], K32One);

2818

v[9] = _mm256_add_epi32(u[9], K32One);

2819

v[10] = _mm256_add_epi32(u[10], K32One);

2820

v[11] = _mm256_add_epi32(u[11], K32One);

2821

v[12] = _mm256_add_epi32(u[12], K32One);

2822

v[13] = _mm256_add_epi32(u[13], K32One);

2823

v[14] = _mm256_add_epi32(u[14], K32One);

2824

v[15] = _mm256_add_epi32(u[15], K32One);

2825

2826

u[0] = _mm256_srai_epi32(v[0], 2);

2827

u[1] = _mm256_srai_epi32(v[1], 2);

2828

u[2] = _mm256_srai_epi32(v[2], 2);

2829

u[3] = _mm256_srai_epi32(v[3], 2);

2830

u[4] = _mm256_srai_epi32(v[4], 2);

2831

u[5] = _mm256_srai_epi32(v[5], 2);

2832

u[6] = _mm256_srai_epi32(v[6], 2);

2833

u[7] = _mm256_srai_epi32(v[7], 2);

2834

u[8] = _mm256_srai_epi32(v[8], 2);

2835

u[9] = _mm256_srai_epi32(v[9], 2);

2836

u[10] = _mm256_srai_epi32(v[10], 2);

2837

u[11] = _mm256_srai_epi32(v[11], 2);

2838

u[12] = _mm256_srai_epi32(v[12], 2);

2839

u[13] = _mm256_srai_epi32(v[13], 2);

2840

u[14] = _mm256_srai_epi32(v[14], 2);

2841

u[15] = _mm256_srai_epi32(v[15], 2);

2842

2843

out[5] = _mm256_packs_epi32(u[0], u[1]);

2844

out[21] = _mm256_packs_epi32(u[2], u[3]);

2845

out[13] = _mm256_packs_epi32(u[4], u[5]);

2846

out[29] = _mm256_packs_epi32(u[6], u[7]);

2847

out[3] = _mm256_packs_epi32(u[8], u[9]);

2848

out[19] = _mm256_packs_epi32(u[10], u[11]);

2849

out[11] = _mm256_packs_epi32(u[12], u[13]);

2850

out[27] = _mm256_packs_epi32(u[14], u[15]);

}

}

#endif

// Transpose the results, do it as four 8x8 transposes.

2855

{

2856

int transpose_block;

2857

int16_t *output_currStep, *output_nextStep;

Yi Luo

0c552df

2016-10-24 16:30:55 -0700

[diff] [blame]

2858

tran_low_t *curr_out, *next_out;

2859

// Pass 0

2860

output_currStep = &intermediate[column_start * 32];

2861

output_nextStep = &intermediate[(column_start + 8) * 32];

2862

// Pass 1

2863

curr_out = &output_org[column_start * 32];

2864

next_out = &output_org[(column_start + 8) * 32];

2865

Yaowu Xu

c27fc14

2016-08-22 16:08:15 -0700

[diff] [blame]

2866

for (transpose_block = 0; transpose_block < 4; ++transpose_block) {

2867

__m256i *this_out = &out[8 * transpose_block];

2868

// 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15

2869

// 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

2870

// 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

2871

// 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

2872

// 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95

2873

// 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115

2874

// 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135

2875

// 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155

2876

const __m256i tr0_0 = _mm256_unpacklo_epi16(this_out[0], this_out[1]);

2877

const __m256i tr0_1 = _mm256_unpacklo_epi16(this_out[2], this_out[3]);

2878

const __m256i tr0_2 = _mm256_unpackhi_epi16(this_out[0], this_out[1]);

2879

const __m256i tr0_3 = _mm256_unpackhi_epi16(this_out[2], this_out[3]);

2880

const __m256i tr0_4 = _mm256_unpacklo_epi16(this_out[4], this_out[5]);

2881

const __m256i tr0_5 = _mm256_unpacklo_epi16(this_out[6], this_out[7]);

2882

const __m256i tr0_6 = _mm256_unpackhi_epi16(this_out[4], this_out[5]);

2883

const __m256i tr0_7 = _mm256_unpackhi_epi16(this_out[6], this_out[7]);

2884

// 00 20 01 21 02 22 03 23 08 28 09 29 10 30 11 31

2885

// 40 60 41 61 42 62 43 63 48 68 49 69 50 70 51 71

2886

// 04 24 05 25 06 26 07 27 12 32 13 33 14 34 15 35

2887

// 44 64 45 65 46 66 47 67 52 72 53 73 54 74 55 75

2888

// 80 100 81 101 82 102 83 103 88 108 89 109 90 110 91 101

2889

// 120 140 121 141 122 142 123 143 128 148 129 149 130 150 131 151

2890

// 84 104 85 105 86 106 87 107 92 112 93 113 94 114 95 115

2891

// 124 144 125 145 126 146 127 147 132 152 133 153 134 154 135 155

2892

2893

const __m256i tr1_0 = _mm256_unpacklo_epi32(tr0_0, tr0_1);

2894

const __m256i tr1_1 = _mm256_unpacklo_epi32(tr0_2, tr0_3);

2895

const __m256i tr1_2 = _mm256_unpackhi_epi32(tr0_0, tr0_1);

2896

const __m256i tr1_3 = _mm256_unpackhi_epi32(tr0_2, tr0_3);

2897

const __m256i tr1_4 = _mm256_unpacklo_epi32(tr0_4, tr0_5);

2898

const __m256i tr1_5 = _mm256_unpacklo_epi32(tr0_6, tr0_7);

2899

const __m256i tr1_6 = _mm256_unpackhi_epi32(tr0_4, tr0_5);

2900

const __m256i tr1_7 = _mm256_unpackhi_epi32(tr0_6, tr0_7);

2901

// 00 20 40 60 01 21 41 61 08 28 48 68 09 29 49 69

2902

// 04 24 44 64 05 25 45 65 12 32 52 72 13 33 53 73

2903

// 02 22 42 62 03 23 43 63 10 30 50 70 11 31 51 71

2904

// 06 26 46 66 07 27 47 67 14 34 54 74 15 35 55 75

2905

// 80 100 120 140 81 101 121 141 88 108 128 148 89 109 129 149

2906

// 84 104 124 144 85 105 125 145 92 112 132 152 93 113 133 153

2907

// 82 102 122 142 83 103 123 143 90 110 130 150 91 101 131 151

2908

// 86 106 126 146 87 107 127 147 94 114 134 154 95 115 135 155

2909

__m256i tr2_0 = _mm256_unpacklo_epi64(tr1_0, tr1_4);

2910

__m256i tr2_1 = _mm256_unpackhi_epi64(tr1_0, tr1_4);

2911

__m256i tr2_2 = _mm256_unpacklo_epi64(tr1_2, tr1_6);

2912

__m256i tr2_3 = _mm256_unpackhi_epi64(tr1_2, tr1_6);

2913

__m256i tr2_4 = _mm256_unpacklo_epi64(tr1_1, tr1_5);

2914

__m256i tr2_5 = _mm256_unpackhi_epi64(tr1_1, tr1_5);

2915

__m256i tr2_6 = _mm256_unpacklo_epi64(tr1_3, tr1_7);

2916

__m256i tr2_7 = _mm256_unpackhi_epi64(tr1_3, tr1_7);

2917

// 00 20 40 60 80 100 120 140 08 28 48 68 88 108 128 148

2918

// 01 21 41 61 81 101 121 141 09 29 49 69 89 109 129 149

2919

// 02 22 42 62 82 102 122 142 10 30 50 70 90 110 130 150

2920

// 03 23 43 63 83 103 123 143 11 31 51 71 91 101 131 151

2921

// 04 24 44 64 84 104 124 144 12 32 52 72 92 112 132 152

2922

// 05 25 45 65 85 105 125 145 13 33 53 73 93 113 133 153

2923

// 06 26 46 66 86 106 126 146 14 34 54 74 94 114 134 154

2924

// 07 27 47 67 87 107 127 147 15 35 55 75 95 115 135 155

2925

if (0 == pass) {

2926

// output[j] = (output[j] + 1 + (output[j] > 0)) >> 2;

2927

// TODO(cd): see quality impact of only doing

2928

// output[j] = (output[j] + 1) >> 2;

2929

// which would remove the code between here ...

2930

__m256i tr2_0_0 = _mm256_cmpgt_epi16(tr2_0, kZero);

2931

__m256i tr2_1_0 = _mm256_cmpgt_epi16(tr2_1, kZero);

2932

__m256i tr2_2_0 = _mm256_cmpgt_epi16(tr2_2, kZero);

2933

__m256i tr2_3_0 = _mm256_cmpgt_epi16(tr2_3, kZero);

2934

__m256i tr2_4_0 = _mm256_cmpgt_epi16(tr2_4, kZero);

2935

__m256i tr2_5_0 = _mm256_cmpgt_epi16(tr2_5, kZero);

2936

__m256i tr2_6_0 = _mm256_cmpgt_epi16(tr2_6, kZero);

2937

__m256i tr2_7_0 = _mm256_cmpgt_epi16(tr2_7, kZero);

2938

tr2_0 = _mm256_sub_epi16(tr2_0, tr2_0_0);

2939

tr2_1 = _mm256_sub_epi16(tr2_1, tr2_1_0);

2940

tr2_2 = _mm256_sub_epi16(tr2_2, tr2_2_0);

2941

tr2_3 = _mm256_sub_epi16(tr2_3, tr2_3_0);

2942

tr2_4 = _mm256_sub_epi16(tr2_4, tr2_4_0);

2943

tr2_5 = _mm256_sub_epi16(tr2_5, tr2_5_0);

2944

tr2_6 = _mm256_sub_epi16(tr2_6, tr2_6_0);

2945

tr2_7 = _mm256_sub_epi16(tr2_7, tr2_7_0);

2946

// ... and here.

Yaowu Xu

f883b42

2016-08-30 14:01:10 -0700

[diff] [blame]

2947

// PS: also change code in av1/encoder/av1_dct.c

Yaowu Xu

c27fc14

2016-08-22 16:08:15 -0700

[diff] [blame]

2948

tr2_0 = _mm256_add_epi16(tr2_0, kOne);

2949

tr2_1 = _mm256_add_epi16(tr2_1, kOne);

2950

tr2_2 = _mm256_add_epi16(tr2_2, kOne);

2951

tr2_3 = _mm256_add_epi16(tr2_3, kOne);

2952

tr2_4 = _mm256_add_epi16(tr2_4, kOne);

2953

tr2_5 = _mm256_add_epi16(tr2_5, kOne);

2954

tr2_6 = _mm256_add_epi16(tr2_6, kOne);

2955

tr2_7 = _mm256_add_epi16(tr2_7, kOne);

2956

tr2_0 = _mm256_srai_epi16(tr2_0, 2);

2957

tr2_1 = _mm256_srai_epi16(tr2_1, 2);

2958

tr2_2 = _mm256_srai_epi16(tr2_2, 2);

2959

tr2_3 = _mm256_srai_epi16(tr2_3, 2);

2960

tr2_4 = _mm256_srai_epi16(tr2_4, 2);

2961

tr2_5 = _mm256_srai_epi16(tr2_5, 2);

2962

tr2_6 = _mm256_srai_epi16(tr2_6, 2);

2963

tr2_7 = _mm256_srai_epi16(tr2_7, 2);

2964

}

Yi Luo

0c552df

2016-10-24 16:30:55 -0700

[diff] [blame]

2965

if (0 == pass) {

2966

// Note: even though all these stores are aligned, using the aligned

2967

// intrinsic make the code slightly slower.

2968

_mm_storeu_si128((__m128i *)(output_currStep + 0 * 32),

2969

_mm256_castsi256_si128(tr2_0));

2970

_mm_storeu_si128((__m128i *)(output_currStep + 1 * 32),

2971

_mm256_castsi256_si128(tr2_1));

2972

_mm_storeu_si128((__m128i *)(output_currStep + 2 * 32),

2973

_mm256_castsi256_si128(tr2_2));

2974

_mm_storeu_si128((__m128i *)(output_currStep + 3 * 32),

2975

_mm256_castsi256_si128(tr2_3));

2976

_mm_storeu_si128((__m128i *)(output_currStep + 4 * 32),

2977

_mm256_castsi256_si128(tr2_4));

2978

_mm_storeu_si128((__m128i *)(output_currStep + 5 * 32),

2979

_mm256_castsi256_si128(tr2_5));

2980

_mm_storeu_si128((__m128i *)(output_currStep + 6 * 32),

2981

_mm256_castsi256_si128(tr2_6));

2982

_mm_storeu_si128((__m128i *)(output_currStep + 7 * 32),

2983

_mm256_castsi256_si128(tr2_7));

Yaowu Xu

c27fc14

2016-08-22 16:08:15 -0700

[diff] [blame]

2984

Yi Luo

0c552df

2016-10-24 16:30:55 -0700

[diff] [blame]

2985

_mm_storeu_si128((__m128i *)(output_nextStep + 0 * 32),

2986

_mm256_extractf128_si256(tr2_0, 1));

2987

_mm_storeu_si128((__m128i *)(output_nextStep + 1 * 32),

2988

_mm256_extractf128_si256(tr2_1, 1));

2989

_mm_storeu_si128((__m128i *)(output_nextStep + 2 * 32),

2990

_mm256_extractf128_si256(tr2_2, 1));

2991

_mm_storeu_si128((__m128i *)(output_nextStep + 3 * 32),

2992

_mm256_extractf128_si256(tr2_3, 1));

2993

_mm_storeu_si128((__m128i *)(output_nextStep + 4 * 32),

2994

_mm256_extractf128_si256(tr2_4, 1));

2995

_mm_storeu_si128((__m128i *)(output_nextStep + 5 * 32),

2996

_mm256_extractf128_si256(tr2_5, 1));

2997

_mm_storeu_si128((__m128i *)(output_nextStep + 6 * 32),

2998

_mm256_extractf128_si256(tr2_6, 1));

2999

_mm_storeu_si128((__m128i *)(output_nextStep + 7 * 32),

3000

_mm256_extractf128_si256(tr2_7, 1));

3001

// Process next 8x8

3002

output_currStep += 8;

3003

output_nextStep += 8;

3004

}

3005

if (1 == pass) {

3006

store_coeff(&tr2_0, curr_out + 0 * 32, next_out + 0 * 32);

3007

store_coeff(&tr2_1, curr_out + 1 * 32, next_out + 1 * 32);

3008

store_coeff(&tr2_2, curr_out + 2 * 32, next_out + 2 * 32);

3009

store_coeff(&tr2_3, curr_out + 3 * 32, next_out + 3 * 32);

3010

store_coeff(&tr2_4, curr_out + 4 * 32, next_out + 4 * 32);

3011

store_coeff(&tr2_5, curr_out + 5 * 32, next_out + 5 * 32);

3012

store_coeff(&tr2_6, curr_out + 6 * 32, next_out + 6 * 32);

3013

store_coeff(&tr2_7, curr_out + 7 * 32, next_out + 7 * 32);

3014

curr_out += 8;

3015

next_out += 8;

3016

}

Yaowu Xu

c27fc14

2016-08-22 16:08:15 -0700

[diff] [blame]

}

}

}

}

Yi Luo

e9fde26

2016-10-07 15:02:33 -0700

[diff] [blame]

3021

_mm256_zeroupper();

Yaowu Xu

c27fc14

2016-08-22 16:08:15 -0700

[diff] [blame]

3022

} // NOLINT