diff --git a/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_3x3_fp16.cc b/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_3x3_fp16.cc index 7a64945fd46..687d6273f28 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_3x3_fp16.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_3x3_fp16.cc @@ -36,15 +36,15 @@ void ProcessFilterFp16(float16_t *origin_weight, float16_t *dst_weight, ConvPara auto input_channel = conv_param->input_channel_; auto output_channel = conv_param->output_channel_; auto kernel_plane = conv_param->kernel_w_ * conv_param->kernel_h_; - int iC4 = UP_DIV(input_channel, C4NUM); + int iC8 = UP_DIV(input_channel, C8NUM); int oC8 = UP_DIV(output_channel, C8NUM); - size_t tmp_size = oC8 * C8NUM * iC4 * C4NUM * kernel_plane * sizeof(float16_t); + size_t tmp_size = oC8 * C8NUM * iC8 * C8NUM * kernel_plane * sizeof(float16_t); auto tmp_addr = reinterpret_cast(malloc(tmp_size)); memset(tmp_addr, 0, tmp_size); PackWeightToC4Fp16(origin_weight, tmp_addr, conv_param); - Conv3x3Fp16FilterTransform(tmp_addr, dst_weight, iC4, output_channel, kernel_plane); + Conv3x3Fp16FilterTransform(tmp_addr, dst_weight, iC8 * 2, output_channel, kernel_plane); free(tmp_addr); } @@ -52,10 +52,10 @@ void ProcessFilterFp16(float16_t *origin_weight, float16_t *dst_weight, ConvPara int Convolution3x3FP16CPUKernel::InitWeightBias() { auto input_channel = conv_param_->input_channel_; int output_channel = conv_param_->output_channel_; - int iC4 = UP_DIV(input_channel, C4NUM); + int iC8 = UP_DIV(input_channel, C8NUM); int oC8 = UP_DIV(output_channel, C8NUM); // init weight - size_t transformed_size = iC4 * C4NUM * oC8 * C8NUM * 36 * sizeof(float16_t); + size_t transformed_size = iC8 * C8NUM * oC8 * C8NUM * 36 * sizeof(float16_t); transformed_filter_addr_ = reinterpret_cast(malloc(transformed_size)); if (transformed_filter_addr_ == nullptr) { MS_LOG(ERROR) << "malloc transformed_filter_addr_ failed."; @@ -92,11 +92,11 @@ int Convolution3x3FP16CPUKernel::InitWeightBias() { int Convolution3x3FP16CPUKernel::InitTmpBuffer() { const int tile_num = 16; const int k_plane = 36; - int iC4 = UP_DIV(conv_param_->input_channel_, C4NUM); + int iC8 = UP_DIV(conv_param_->input_channel_, C8NUM); int oC8 = UP_DIV(conv_param_->output_channel_, C8NUM); /*=============================tile_buffer_============================*/ - size_t tile_buffer_size = thread_count_ * tile_num * k_plane * iC4 * C4NUM * sizeof(float16_t); + size_t tile_buffer_size = thread_count_ * tile_num * k_plane * iC8 * C8NUM * sizeof(float16_t); tile_buffer_ = reinterpret_cast(malloc(tile_buffer_size)); if (tile_buffer_ == nullptr) { MS_LOG(ERROR) << "malloc tile_buffer_ failed."; @@ -105,7 +105,7 @@ int Convolution3x3FP16CPUKernel::InitTmpBuffer() { memset(tile_buffer_, 0, tile_buffer_size); /*=============================block_unit_buffer_============================*/ - size_t block_unit_buffer_size = thread_count_ * k_plane * C4NUM * sizeof(float16_t); + size_t block_unit_buffer_size = thread_count_ * k_plane * C8NUM * sizeof(float16_t); block_unit_buffer_ = reinterpret_cast(malloc(block_unit_buffer_size)); if (block_unit_buffer_ == nullptr) { MS_LOG(ERROR) << "malloc block_unit_buffer_ failed."; @@ -133,14 +133,14 @@ int Convolution3x3FP16CPUKernel::InitTmpBuffer() { memset(tmp_out_, 0, tmp_out_size); /*=============================nhwc4_input_============================*/ - size_t nhwc4_input_size = - iC4 * C4NUM * conv_param_->input_batch_ * conv_param_->input_h_ * conv_param_->input_w_ * sizeof(float16_t); - nhwc4_input_ = malloc(nhwc4_input_size); + size_t nhwc8_input_size = + iC8 * C8NUM * conv_param_->input_batch_ * conv_param_->input_h_ * conv_param_->input_w_ * sizeof(float16_t); + nhwc4_input_ = malloc(nhwc8_input_size); if (nhwc4_input_ == nullptr) { MS_LOG(ERROR) << "malloc nhwc4_input_ failed."; return RET_ERROR; } - memset(nhwc4_input_, 0, nhwc4_input_size); + memset(nhwc4_input_, 0, nhwc8_input_size); return RET_OK; } @@ -189,7 +189,6 @@ int Convolution3x3FP16CPUKernel::ReSize() { MS_LOG(ERROR) << "Init tmp buffer failed."; return RET_ERROR; } - ConfigInputOutput(); return RET_OK; } @@ -225,7 +224,7 @@ int Convolution3x3FP16CPUKernel::Run() { int in_h = conv_param_->input_h_; int in_w = conv_param_->input_w_; int in_channel = conv_param_->input_channel_; - convert_func_(reinterpret_cast(execute_input_), nhwc4_input_, in_batch, in_h * in_w, in_channel); + PackNHWCToNHWC8Fp16(reinterpret_cast(execute_input_), nhwc4_input_, in_batch, in_h * in_w, in_channel); int error_code = LiteBackendParallelLaunch(Convolution3x3Fp16Impl, this, thread_count_); if (error_code != RET_OK) { diff --git a/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_winograd_fp16.cc b/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_winograd_fp16.cc index e2fd3d5f1d7..e16b5b26c5b 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_winograd_fp16.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_winograd_fp16.cc @@ -150,10 +150,11 @@ int ConvolutionWinogradFP16CPUKernel::InitWeightBias() { int ConvolutionWinogradFP16CPUKernel::MallocFilterMatrix(int oc_block, int oc_block_num) { int channel_in = conv_param_->input_channel_; - int ic4 = UP_DIV(channel_in, BLOCK); + int ic8 = UP_DIV(channel_in, C8NUM); + int ic4 = ic8 * 2; // set data - auto trans_matrix_data_size = input_unit_ * input_unit_ * ic4 * C4NUM * oc_block_num * oc_block * sizeof(float); + auto trans_matrix_data_size = input_unit_ * input_unit_ * ic8 * C8NUM * oc_block_num * oc_block * sizeof(float); auto matrix_buffer = malloc(trans_matrix_data_size); if (matrix_buffer == nullptr) { MS_LOG(ERROR) << "malloc matrix_buffer failed."; @@ -191,11 +192,11 @@ int ConvolutionWinogradFP16CPUKernel::InitTmpBuffer() { int channel_out = conv_param_->output_channel_; int output_h = conv_param_->output_h_; int output_w = conv_param_->output_w_; - int ic4 = UP_DIV(channel_in, C4NUM); + int ic8 = UP_DIV(channel_in, C8NUM); int oc8 = UP_DIV(channel_out, C8NUM); /*=============================trans_input_============================*/ - size_t tile_buffer_size = thread_count_ * cal_num * input_unit_ * input_unit_ * ic4 * C4NUM * sizeof(float16_t); + size_t tile_buffer_size = thread_count_ * cal_num * input_unit_ * input_unit_ * ic8 * C8NUM * sizeof(float16_t); trans_input_ = reinterpret_cast(malloc(tile_buffer_size)); if (trans_input_ == nullptr) { MS_LOG(ERROR) << "malloc trans_input_ failed."; @@ -223,12 +224,12 @@ int ConvolutionWinogradFP16CPUKernel::InitTmpBuffer() { /*=============================tmp_data_============================*/ tmp_data_ = - reinterpret_cast(malloc(thread_count_ * C4NUM * input_unit_ * input_unit_ * sizeof(float16_t))); + reinterpret_cast(malloc(thread_count_ * C8NUM * input_unit_ * input_unit_ * sizeof(float16_t))); if (tmp_data_ == nullptr) { MS_LOG(ERROR) << "malloc tmp_data_ failed."; return RET_ERROR; } - memset(tmp_data_, 0, C4NUM * input_unit_ * input_unit_ * sizeof(float16_t)); + memset(tmp_data_, 0, C8NUM * input_unit_ * input_unit_ * sizeof(float16_t)); tmp_buffer_address_list_[0] = trans_input_; tmp_buffer_address_list_[1] = gemm_out_; @@ -236,24 +237,18 @@ int ConvolutionWinogradFP16CPUKernel::InitTmpBuffer() { tmp_buffer_address_list_[3] = tmp_data_; /*=============================nhwc4_input_============================*/ - size_t nhwc4_input_size = - ic4 * C4NUM * conv_param_->input_batch_ * conv_param_->input_h_ * conv_param_->input_w_ * sizeof(float16_t); - nhwc4_input_ = malloc(nhwc4_input_size); + size_t nhwc8_input_size = + ic8 * C8NUM * conv_param_->input_batch_ * conv_param_->input_h_ * conv_param_->input_w_ * sizeof(float16_t); + nhwc4_input_ = malloc(nhwc8_input_size); if (nhwc4_input_ == nullptr) { MS_LOG(ERROR) << "malloc nhwc4_input_ failed."; return RET_ERROR; } - memset(nhwc4_input_, 0, nhwc4_input_size); + memset(nhwc4_input_, 0, nhwc8_input_size); return RET_OK; } int ConvolutionWinogradFP16CPUKernel::ConfigInputOutput() { - auto input_tensor = in_tensors_.at(kInputIndex); - auto ret = CheckLayout(input_tensor); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Check layout failed."; - return RET_ERROR; - } auto output_tensor = out_tensors_.at(kOutputIndex); output_tensor->SetFormat(schema::Format_NHWC); @@ -348,7 +343,7 @@ int ConvolutionWinogradFP16CPUKernel::Run() { int in_h = conv_param_->input_h_; int in_w = conv_param_->input_w_; int in_channel = conv_param_->input_channel_; - convert_func_(execute_input_, nhwc4_input_, in_batch, in_h * in_w, in_channel); + PackNHWCToNHWC8Fp16(execute_input_, nhwc4_input_, in_batch, in_h * in_w, in_channel); int error_code = LiteBackendParallelLaunch(ConvolutionWinogradFp16Impl, this, thread_count_); if (error_code != RET_OK) { diff --git a/mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/conv_fp16.c b/mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/conv_fp16.c index d0e1b98f893..2975f48e081 100644 --- a/mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/conv_fp16.c +++ b/mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/conv_fp16.c @@ -382,7 +382,8 @@ void Conv3x3Fp16(float16_t *input_data, float16_t *transed_weight, const float16 const int tile_num = 16; const int output_unit = 4; const int k_plane = 36; - int ic4 = UP_DIV(conv_param->input_channel_, C4NUM); + int ic8 = UP_DIV(conv_param->input_channel_, C8NUM); + int ic4 = ic8 * 2; int oc8 = UP_DIV(conv_param->output_channel_, C8NUM); int out_w_block = UP_DIV(conv_param->output_w_, C4NUM); @@ -390,7 +391,7 @@ void Conv3x3Fp16(float16_t *input_data, float16_t *transed_weight, const float16 int output_count = out_w_block * out_h_block; int output_tile_count = UP_DIV(output_count, tile_num); int tile_buffer_offset = tile_num * k_plane * ic4 * C4NUM; - int block_unit_buffer_offset = k_plane * C4NUM; + int block_unit_buffer_offset = k_plane * C8NUM; int tmp_dst_buffer_offset = tile_num * k_plane * oc8 * C8NUM; int input_batch = conv_param->input_batch_; @@ -541,7 +542,7 @@ void ConvWinogardFp16(float16_t *input_data, float16_t *trans_weight, const floa int input_unit = conv_param->input_unit_; int in_batch = conv_param->input_batch_; int in_channel = conv_param->input_channel_; - int ic4 = UP_DIV(in_channel, C4NUM); + int ic8 = UP_DIV(in_channel, C8NUM); int out_unit = conv_param->output_unit_; int out_w_block = UP_DIV(conv_param->output_w_, out_unit); int out_h_block = UP_DIV(conv_param->output_h_, out_unit); @@ -557,16 +558,16 @@ void ConvWinogardFp16(float16_t *input_data, float16_t *trans_weight, const floa float16_t *gemm_out = buffer_list[1]; float16_t *tmp_out_data = buffer_list[2]; float16_t *tmp_data = buffer_list[3]; - int trans_input_offset = tile_num * input_unit_square * ic4 * C4NUM; + int trans_input_offset = tile_num * input_unit_square * ic8 * C8NUM; int gemm_out_offset = tile_num * input_unit_square * oc8 * C8NUM; - int tmp_data_offset = input_unit_square * C4NUM; + int tmp_data_offset = input_unit_square * C8NUM; // step 1 : filter transform (pre-processed offline) // step 2 : input transform (online) for (int b = 0; b < in_batch; b++) { - int in_batch_offset = b * ic4 * C4NUM * conv_param->input_h_ * conv_param->input_w_; + int in_batch_offset = b * ic8 * C8NUM * conv_param->input_h_ * conv_param->input_w_; int tmp_out_batch_offset = b * out_w_block * out_h_block * out_unit * out_unit * oc8 * C8NUM; for (int thread_id = task_id; thread_id < output_tile_count; thread_id += thread_num) { - int out_tile_index = thread_id * TILE_NUM; + int out_tile_index = thread_id * tile_num; int cal_num = output_count - thread_id * tile_num; cal_num = cal_num > tile_num ? tile_num : cal_num; WinogradInputTransformFp16(input_data + in_batch_offset, trans_input + task_id * trans_input_offset, @@ -574,7 +575,7 @@ void ConvWinogardFp16(float16_t *input_data, float16_t *trans_weight, const floa input_trans_func); // step 3 : gemm IndirectGemmFp16_16x8(gemm_out + task_id * gemm_out_offset, trans_input + task_id * trans_input_offset, - trans_weight, NULL, input_unit_square, ic4, oc8 * C8NUM, output_offset, 1, 1, 0, 0); + trans_weight, NULL, input_unit_square, ic8 * 2, oc8 * C8NUM, output_offset, 1, 1, 0, 0); // step 4 : output transform WinogradOutputTransformFp16(gemm_out + task_id * gemm_out_offset, tmp_out_data + tmp_out_batch_offset, bias_data, diff --git a/mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/pack_fp16.c b/mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/pack_fp16.c index b4e4ad89eab..6039528fdcb 100644 --- a/mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/pack_fp16.c +++ b/mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/pack_fp16.c @@ -161,7 +161,8 @@ void PackWeightToC8Fp16(const float16_t *origin_weight_data, float16_t *packed_w void PackWeightToC4Fp16(const float16_t *origin_weight_data, float16_t *packed_weight_data, ConvParameter *conv_param) { // origin weight format : ohwi int input_channel = conv_param->input_channel_; - int ic4 = UP_DIV(input_channel, C4NUM); + int ic8 = UP_DIV(input_channel, C8NUM); + int ic4 = ic8 * 2; int output_channel = conv_param->output_channel_; int kernel_plane = conv_param->kernel_h_ * conv_param->kernel_w_; @@ -240,6 +241,26 @@ void PackNHWCToNHWC4Fp16(const void *src, void *dst, int batch, int plane, int c } } +void PackNHWCToNHWC8Fp16(const void *src, void *dst, int batch, int plane, int channel) { + int ic8 = UP_DIV(channel, C8NUM); + int nhwc8_batch_unit_offset = ic8 * C8NUM * plane; + int ic_remainder_ = channel % C8NUM; + if (ic_remainder_ != 0) { + int nhwc8_batch_offset = 0; + for (int b = 0; b < batch; b++) { + int batch_offset = b * channel * plane; + for (int i = 0; i < plane; i++) { + memcpy((float16_t *)dst + nhwc8_batch_offset + i * ic8 * C8NUM, (float16_t *)src + batch_offset + i * channel, + channel * sizeof(float16_t)); + } + nhwc8_batch_offset += nhwc8_batch_unit_offset; + } + } else { + size_t ori_input_size = batch * plane * channel * sizeof(float16_t); + memcpy(dst, src, ori_input_size); + } +} + void PackNHWC4ToNHWCFp16(const void *src, void *dst, int batch, int plane, int channel) { int c4 = UP_DIV(channel, C4NUM); int ic_remainder_ = channel % C4NUM; @@ -399,19 +420,6 @@ void PackNHWC8Fp16ToNHWCFp32(float16_t *src, float *dst, int batch, int plane, i } } -void PackNHWCToNHWC8Fp16(float16_t *src, float16_t *dst, int batch, int plane, int channel) { - int c8_channel = UP_DIV(channel, C8NUM) * C8NUM; - for (int b = 0; b < batch; b++) { - float16_t *dst_batch = dst + b * plane * c8_channel; - float16_t *src_batch = src + b * plane * channel; - for (int i = 0; i < plane; i++) { - float16_t *dst_plane = dst_batch + i * c8_channel; - float16_t *src_plane = src_batch + i * channel; - memcpy(dst_plane, src_plane, channel * sizeof(float16_t)); - } - } -} - void PackNHWC8ToNHWCFp16(float16_t *src, float16_t *dst, int batch, int plane, int channel) { int c8_channel = UP_DIV(channel, C8NUM) * C8NUM; for (int b = 0; b < batch; b++) { diff --git a/mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/pack_fp16.h b/mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/pack_fp16.h index f84cacafb00..5bdb254858e 100644 --- a/mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/pack_fp16.h +++ b/mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/pack_fp16.h @@ -43,6 +43,8 @@ void PackNCHWToNC4HW4Fp16(const void *src, void *dst, int batch, int plane, int void PackNHWCToNHWC4Fp16(const void *src, void *dst, int batch, int plane, int channel); +void PackNHWCToNHWC8Fp16(const void *src, void *dst, int batch, int plane, int channel); + void PackNHWC4ToNHWCFp16(const void *src, void *dst, int batch, int plane, int channel); void PackNCHWToNHWC4Fp16(const void *src, void *dst, int batch, int plane, int channel); @@ -63,8 +65,6 @@ void PackNHWCFp32ToC8HWN8Fp16(float *src, float16_t *dst, int batch, int plane, void PackNHWC8Fp16ToNHWCFp32(float16_t *src, float *dst, int batch, int plane, int channel); -void PackNHWCToNHWC8Fp16(float16_t *src, float16_t *dst, int batch, int plane, int channel); - void PackNHWC8ToNHWCFp16(float16_t *src, float16_t *dst, int batch, int plane, int channel); #ifdef __cplusplus } diff --git a/mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/winograd_transform_fp16.c b/mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/winograd_transform_fp16.c index e115b006dd1..6702c494ca6 100644 --- a/mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/winograd_transform_fp16.c +++ b/mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/winograd_transform_fp16.c @@ -18,173 +18,209 @@ // for fp16 convolution 3x3 filter/input/output transform F(4,3) void Conv3x3Fp16InputUnit(float16_t *tmp_data, float16_t *trans_input_data, size_t step) { - float16x4_t d00 = vld1_f16(tmp_data); - float16x4_t d01 = vld1_f16(tmp_data + 4); - float16x4_t d02 = vld1_f16(tmp_data + 2 * 4); - float16x4_t d03 = vld1_f16(tmp_data + 3 * 4); - float16x4_t d04 = vld1_f16(tmp_data + 4 * 4); - float16x4_t d05 = vld1_f16(tmp_data + 5 * 4); + float16x8_t d00 = vld1q_f16(tmp_data); + float16x8_t d01 = vld1q_f16(tmp_data + 8); + float16x8_t d02 = vld1q_f16(tmp_data + 2 * 8); + float16x8_t d03 = vld1q_f16(tmp_data + 3 * 8); + float16x8_t d04 = vld1q_f16(tmp_data + 4 * 8); + float16x8_t d05 = vld1q_f16(tmp_data + 5 * 8); - float16x4_t d10 = vld1_f16(tmp_data + 6 * 4); - float16x4_t d11 = vld1_f16(tmp_data + 7 * 4); - float16x4_t d12 = vld1_f16(tmp_data + 8 * 4); - float16x4_t d13 = vld1_f16(tmp_data + 9 * 4); - float16x4_t d14 = vld1_f16(tmp_data + 10 * 4); - float16x4_t d15 = vld1_f16(tmp_data + 11 * 4); + float16x8_t d10 = vld1q_f16(tmp_data + 6 * 8); + float16x8_t d11 = vld1q_f16(tmp_data + 7 * 8); + float16x8_t d12 = vld1q_f16(tmp_data + 8 * 8); + float16x8_t d13 = vld1q_f16(tmp_data + 9 * 8); + float16x8_t d14 = vld1q_f16(tmp_data + 10 * 8); + float16x8_t d15 = vld1q_f16(tmp_data + 11 * 8); - float16x4_t d20 = vld1_f16(tmp_data + 12 * 4); - float16x4_t d21 = vld1_f16(tmp_data + 13 * 4); - float16x4_t d22 = vld1_f16(tmp_data + 14 * 4); - float16x4_t d23 = vld1_f16(tmp_data + 15 * 4); - float16x4_t d24 = vld1_f16(tmp_data + 16 * 4); - float16x4_t d25 = vld1_f16(tmp_data + 17 * 4); + float16x8_t d20 = vld1q_f16(tmp_data + 12 * 8); + float16x8_t d21 = vld1q_f16(tmp_data + 13 * 8); + float16x8_t d22 = vld1q_f16(tmp_data + 14 * 8); + float16x8_t d23 = vld1q_f16(tmp_data + 15 * 8); + float16x8_t d24 = vld1q_f16(tmp_data + 16 * 8); + float16x8_t d25 = vld1q_f16(tmp_data + 17 * 8); - float16x4_t d30 = vld1_f16(tmp_data + 18 * 4); - float16x4_t d31 = vld1_f16(tmp_data + 19 * 4); - float16x4_t d32 = vld1_f16(tmp_data + 20 * 4); - float16x4_t d33 = vld1_f16(tmp_data + 21 * 4); - float16x4_t d34 = vld1_f16(tmp_data + 22 * 4); - float16x4_t d35 = vld1_f16(tmp_data + 23 * 4); + float16x8_t d30 = vld1q_f16(tmp_data + 18 * 8); + float16x8_t d31 = vld1q_f16(tmp_data + 19 * 8); + float16x8_t d32 = vld1q_f16(tmp_data + 20 * 8); + float16x8_t d33 = vld1q_f16(tmp_data + 21 * 8); + float16x8_t d34 = vld1q_f16(tmp_data + 22 * 8); + float16x8_t d35 = vld1q_f16(tmp_data + 23 * 8); - float16x4_t d40 = vld1_f16(tmp_data + 24 * 4); - float16x4_t d41 = vld1_f16(tmp_data + 25 * 4); - float16x4_t d42 = vld1_f16(tmp_data + 26 * 4); - float16x4_t d43 = vld1_f16(tmp_data + 27 * 4); - float16x4_t d44 = vld1_f16(tmp_data + 28 * 4); - float16x4_t d45 = vld1_f16(tmp_data + 29 * 4); + float16x8_t d40 = vld1q_f16(tmp_data + 24 * 8); + float16x8_t d41 = vld1q_f16(tmp_data + 25 * 8); + float16x8_t d42 = vld1q_f16(tmp_data + 26 * 8); + float16x8_t d43 = vld1q_f16(tmp_data + 27 * 8); + float16x8_t d44 = vld1q_f16(tmp_data + 28 * 8); + float16x8_t d45 = vld1q_f16(tmp_data + 29 * 8); - float16x4_t d50 = vld1_f16(tmp_data + 30 * 4); - float16x4_t d51 = vld1_f16(tmp_data + 31 * 4); - float16x4_t d52 = vld1_f16(tmp_data + 32 * 4); - float16x4_t d53 = vld1_f16(tmp_data + 33 * 4); - float16x4_t d54 = vld1_f16(tmp_data + 34 * 4); - float16x4_t d55 = vld1_f16(tmp_data + 35 * 4); + float16x8_t d50 = vld1q_f16(tmp_data + 30 * 8); + float16x8_t d51 = vld1q_f16(tmp_data + 31 * 8); + float16x8_t d52 = vld1q_f16(tmp_data + 32 * 8); + float16x8_t d53 = vld1q_f16(tmp_data + 33 * 8); + float16x8_t d54 = vld1q_f16(tmp_data + 34 * 8); + float16x8_t d55 = vld1q_f16(tmp_data + 35 * 8); - float16x4_t t00 = vadd_f16(vsub_f16(vmul_n_f16(d00, 4), vmul_n_f16(d20, 5)), d40); - float16x4_t t01 = vadd_f16(vsub_f16(vmul_n_f16(d01, 4), vmul_n_f16(d21, 5)), d41); - float16x4_t t02 = vadd_f16(vsub_f16(vmul_n_f16(d02, 4), vmul_n_f16(d22, 5)), d42); - float16x4_t t03 = vadd_f16(vsub_f16(vmul_n_f16(d03, 4), vmul_n_f16(d23, 5)), d43); - float16x4_t t04 = vadd_f16(vsub_f16(vmul_n_f16(d04, 4), vmul_n_f16(d24, 5)), d44); - float16x4_t t05 = vadd_f16(vsub_f16(vmul_n_f16(d05, 4), vmul_n_f16(d25, 5)), d45); + float16x8_t t00 = vaddq_f16(vsubq_f16(vmulq_n_f16(d00, 4), vmulq_n_f16(d20, 5)), d40); + float16x8_t t01 = vaddq_f16(vsubq_f16(vmulq_n_f16(d01, 4), vmulq_n_f16(d21, 5)), d41); + float16x8_t t02 = vaddq_f16(vsubq_f16(vmulq_n_f16(d02, 4), vmulq_n_f16(d22, 5)), d42); + float16x8_t t03 = vaddq_f16(vsubq_f16(vmulq_n_f16(d03, 4), vmulq_n_f16(d23, 5)), d43); + float16x8_t t04 = vaddq_f16(vsubq_f16(vmulq_n_f16(d04, 4), vmulq_n_f16(d24, 5)), d44); + float16x8_t t05 = vaddq_f16(vsubq_f16(vmulq_n_f16(d05, 4), vmulq_n_f16(d25, 5)), d45); - float16x4_t t10 = vadd_f16(vadd_f16(d30, d40), vmul_n_f16(vadd_f16(d10, d20), -4)); - float16x4_t t11 = vadd_f16(vadd_f16(d31, d41), vmul_n_f16(vadd_f16(d11, d21), -4)); - float16x4_t t12 = vadd_f16(vadd_f16(d32, d42), vmul_n_f16(vadd_f16(d12, d22), -4)); - float16x4_t t13 = vadd_f16(vadd_f16(d33, d43), vmul_n_f16(vadd_f16(d13, d23), -4)); - float16x4_t t14 = vadd_f16(vadd_f16(d34, d44), vmul_n_f16(vadd_f16(d14, d24), -4)); - float16x4_t t15 = vadd_f16(vadd_f16(d35, d45), vmul_n_f16(vadd_f16(d15, d25), -4)); + float16x8_t t10 = vaddq_f16(vaddq_f16(d30, d40), vmulq_n_f16(vaddq_f16(d10, d20), -4)); + float16x8_t t11 = vaddq_f16(vaddq_f16(d31, d41), vmulq_n_f16(vaddq_f16(d11, d21), -4)); + float16x8_t t12 = vaddq_f16(vaddq_f16(d32, d42), vmulq_n_f16(vaddq_f16(d12, d22), -4)); + float16x8_t t13 = vaddq_f16(vaddq_f16(d33, d43), vmulq_n_f16(vaddq_f16(d13, d23), -4)); + float16x8_t t14 = vaddq_f16(vaddq_f16(d34, d44), vmulq_n_f16(vaddq_f16(d14, d24), -4)); + float16x8_t t15 = vaddq_f16(vaddq_f16(d35, d45), vmulq_n_f16(vaddq_f16(d15, d25), -4)); - float16x4_t t20 = vadd_f16(vsub_f16(d40, d30), vmul_n_f16(vsub_f16(d10, d20), 4)); - float16x4_t t21 = vadd_f16(vsub_f16(d41, d31), vmul_n_f16(vsub_f16(d11, d21), 4)); - float16x4_t t22 = vadd_f16(vsub_f16(d42, d32), vmul_n_f16(vsub_f16(d12, d22), 4)); - float16x4_t t23 = vadd_f16(vsub_f16(d43, d33), vmul_n_f16(vsub_f16(d13, d23), 4)); - float16x4_t t24 = vadd_f16(vsub_f16(d44, d34), vmul_n_f16(vsub_f16(d14, d24), 4)); - float16x4_t t25 = vadd_f16(vsub_f16(d45, d35), vmul_n_f16(vsub_f16(d15, d25), 4)); + float16x8_t t20 = vaddq_f16(vsubq_f16(d40, d30), vmulq_n_f16(vsubq_f16(d10, d20), 4)); + float16x8_t t21 = vaddq_f16(vsubq_f16(d41, d31), vmulq_n_f16(vsubq_f16(d11, d21), 4)); + float16x8_t t22 = vaddq_f16(vsubq_f16(d42, d32), vmulq_n_f16(vsubq_f16(d12, d22), 4)); + float16x8_t t23 = vaddq_f16(vsubq_f16(d43, d33), vmulq_n_f16(vsubq_f16(d13, d23), 4)); + float16x8_t t24 = vaddq_f16(vsubq_f16(d44, d34), vmulq_n_f16(vsubq_f16(d14, d24), 4)); + float16x8_t t25 = vaddq_f16(vsubq_f16(d45, d35), vmulq_n_f16(vsubq_f16(d15, d25), 4)); - float16x4_t t30 = vadd_f16(vsub_f16(d40, d20), vmul_n_f16(vsub_f16(d30, d10), 2)); - float16x4_t t31 = vadd_f16(vsub_f16(d41, d21), vmul_n_f16(vsub_f16(d31, d11), 2)); - float16x4_t t32 = vadd_f16(vsub_f16(d42, d22), vmul_n_f16(vsub_f16(d32, d12), 2)); - float16x4_t t33 = vadd_f16(vsub_f16(d43, d23), vmul_n_f16(vsub_f16(d33, d13), 2)); - float16x4_t t34 = vadd_f16(vsub_f16(d44, d24), vmul_n_f16(vsub_f16(d34, d14), 2)); - float16x4_t t35 = vadd_f16(vsub_f16(d45, d25), vmul_n_f16(vsub_f16(d35, d15), 2)); + float16x8_t t30 = vaddq_f16(vsubq_f16(d40, d20), vmulq_n_f16(vsubq_f16(d30, d10), 2)); + float16x8_t t31 = vaddq_f16(vsubq_f16(d41, d21), vmulq_n_f16(vsubq_f16(d31, d11), 2)); + float16x8_t t32 = vaddq_f16(vsubq_f16(d42, d22), vmulq_n_f16(vsubq_f16(d32, d12), 2)); + float16x8_t t33 = vaddq_f16(vsubq_f16(d43, d23), vmulq_n_f16(vsubq_f16(d33, d13), 2)); + float16x8_t t34 = vaddq_f16(vsubq_f16(d44, d24), vmulq_n_f16(vsubq_f16(d34, d14), 2)); + float16x8_t t35 = vaddq_f16(vsubq_f16(d45, d25), vmulq_n_f16(vsubq_f16(d35, d15), 2)); - float16x4_t t40 = vadd_f16(vsub_f16(d40, d20), vmul_n_f16(vsub_f16(d10, d30), 2)); - float16x4_t t41 = vadd_f16(vsub_f16(d41, d21), vmul_n_f16(vsub_f16(d11, d31), 2)); - float16x4_t t42 = vadd_f16(vsub_f16(d42, d22), vmul_n_f16(vsub_f16(d12, d32), 2)); - float16x4_t t43 = vadd_f16(vsub_f16(d43, d23), vmul_n_f16(vsub_f16(d13, d33), 2)); - float16x4_t t44 = vadd_f16(vsub_f16(d44, d24), vmul_n_f16(vsub_f16(d14, d34), 2)); - float16x4_t t45 = vadd_f16(vsub_f16(d45, d25), vmul_n_f16(vsub_f16(d15, d35), 2)); + float16x8_t t40 = vaddq_f16(vsubq_f16(d40, d20), vmulq_n_f16(vsubq_f16(d10, d30), 2)); + float16x8_t t41 = vaddq_f16(vsubq_f16(d41, d21), vmulq_n_f16(vsubq_f16(d11, d31), 2)); + float16x8_t t42 = vaddq_f16(vsubq_f16(d42, d22), vmulq_n_f16(vsubq_f16(d12, d32), 2)); + float16x8_t t43 = vaddq_f16(vsubq_f16(d43, d23), vmulq_n_f16(vsubq_f16(d13, d33), 2)); + float16x8_t t44 = vaddq_f16(vsubq_f16(d44, d24), vmulq_n_f16(vsubq_f16(d14, d34), 2)); + float16x8_t t45 = vaddq_f16(vsubq_f16(d45, d25), vmulq_n_f16(vsubq_f16(d15, d35), 2)); - float16x4_t t50 = vadd_f16(vsub_f16(vmul_n_f16(d10, 4), vmul_n_f16(d30, 5)), d50); - float16x4_t t51 = vadd_f16(vsub_f16(vmul_n_f16(d11, 4), vmul_n_f16(d31, 5)), d51); - float16x4_t t52 = vadd_f16(vsub_f16(vmul_n_f16(d12, 4), vmul_n_f16(d32, 5)), d52); - float16x4_t t53 = vadd_f16(vsub_f16(vmul_n_f16(d13, 4), vmul_n_f16(d33, 5)), d53); - float16x4_t t54 = vadd_f16(vsub_f16(vmul_n_f16(d14, 4), vmul_n_f16(d34, 5)), d54); - float16x4_t t55 = vadd_f16(vsub_f16(vmul_n_f16(d15, 4), vmul_n_f16(d35, 5)), d55); + float16x8_t t50 = vaddq_f16(vsubq_f16(vmulq_n_f16(d10, 4), vmulq_n_f16(d30, 5)), d50); + float16x8_t t51 = vaddq_f16(vsubq_f16(vmulq_n_f16(d11, 4), vmulq_n_f16(d31, 5)), d51); + float16x8_t t52 = vaddq_f16(vsubq_f16(vmulq_n_f16(d12, 4), vmulq_n_f16(d32, 5)), d52); + float16x8_t t53 = vaddq_f16(vsubq_f16(vmulq_n_f16(d13, 4), vmulq_n_f16(d33, 5)), d53); + float16x8_t t54 = vaddq_f16(vsubq_f16(vmulq_n_f16(d14, 4), vmulq_n_f16(d34, 5)), d54); + float16x8_t t55 = vaddq_f16(vsubq_f16(vmulq_n_f16(d15, 4), vmulq_n_f16(d35, 5)), d55); - float16x4_t m00 = vadd_f16(vsub_f16(vmul_n_f16(t00, 4), vmul_n_f16(t02, 5)), t04); - float16x4_t m01 = vadd_f16(vadd_f16(t03, t04), vmul_n_f16(vadd_f16(t01, t02), -4)); - float16x4_t m02 = vadd_f16(vsub_f16(t04, t03), vmul_n_f16(vsub_f16(t01, t02), 4)); - float16x4_t m03 = vadd_f16(vsub_f16(t04, t02), vmul_n_f16(vsub_f16(t03, t01), 2)); - float16x4_t m04 = vadd_f16(vsub_f16(t04, t02), vmul_n_f16(vsub_f16(t01, t03), 2)); - float16x4_t m05 = vadd_f16(vsub_f16(vmul_n_f16(t01, 4), vmul_n_f16(t03, 5)), t05); + float16x8_t m00 = vaddq_f16(vsubq_f16(vmulq_n_f16(t00, 4), vmulq_n_f16(t02, 5)), t04); + float16x8_t m01 = vaddq_f16(vaddq_f16(t03, t04), vmulq_n_f16(vaddq_f16(t01, t02), -4)); + float16x8_t m02 = vaddq_f16(vsubq_f16(t04, t03), vmulq_n_f16(vsubq_f16(t01, t02), 4)); + float16x8_t m03 = vaddq_f16(vsubq_f16(t04, t02), vmulq_n_f16(vsubq_f16(t03, t01), 2)); + float16x8_t m04 = vaddq_f16(vsubq_f16(t04, t02), vmulq_n_f16(vsubq_f16(t01, t03), 2)); + float16x8_t m05 = vaddq_f16(vsubq_f16(vmulq_n_f16(t01, 4), vmulq_n_f16(t03, 5)), t05); - float16x4_t m10 = vadd_f16(vsub_f16(vmul_n_f16(t10, 4), vmul_n_f16(t12, 5)), t14); - float16x4_t m11 = vadd_f16(vadd_f16(t13, t14), vmul_n_f16(vadd_f16(t11, t12), -4)); - float16x4_t m12 = vadd_f16(vsub_f16(t14, t13), vmul_n_f16(vsub_f16(t11, t12), 4)); - float16x4_t m13 = vadd_f16(vsub_f16(t14, t12), vmul_n_f16(vsub_f16(t13, t11), 2)); - float16x4_t m14 = vadd_f16(vsub_f16(t14, t12), vmul_n_f16(vsub_f16(t11, t13), 2)); - float16x4_t m15 = vadd_f16(vsub_f16(vmul_n_f16(t11, 4), vmul_n_f16(t13, 5)), t15); + float16x8_t m10 = vaddq_f16(vsubq_f16(vmulq_n_f16(t10, 4), vmulq_n_f16(t12, 5)), t14); + float16x8_t m11 = vaddq_f16(vaddq_f16(t13, t14), vmulq_n_f16(vaddq_f16(t11, t12), -4)); + float16x8_t m12 = vaddq_f16(vsubq_f16(t14, t13), vmulq_n_f16(vsubq_f16(t11, t12), 4)); + float16x8_t m13 = vaddq_f16(vsubq_f16(t14, t12), vmulq_n_f16(vsubq_f16(t13, t11), 2)); + float16x8_t m14 = vaddq_f16(vsubq_f16(t14, t12), vmulq_n_f16(vsubq_f16(t11, t13), 2)); + float16x8_t m15 = vaddq_f16(vsubq_f16(vmulq_n_f16(t11, 4), vmulq_n_f16(t13, 5)), t15); - float16x4_t m20 = vadd_f16(vsub_f16(vmul_n_f16(t20, 4), vmul_n_f16(t22, 5)), t24); - float16x4_t m21 = vadd_f16(vadd_f16(t23, t24), vmul_n_f16(vadd_f16(t21, t22), -4)); - float16x4_t m22 = vadd_f16(vsub_f16(t24, t23), vmul_n_f16(vsub_f16(t21, t22), 4)); - float16x4_t m23 = vadd_f16(vsub_f16(t24, t22), vmul_n_f16(vsub_f16(t23, t21), 2)); - float16x4_t m24 = vadd_f16(vsub_f16(t24, t22), vmul_n_f16(vsub_f16(t21, t23), 2)); - float16x4_t m25 = vadd_f16(vsub_f16(vmul_n_f16(t21, 4), vmul_n_f16(t23, 5)), t25); + float16x8_t m20 = vaddq_f16(vsubq_f16(vmulq_n_f16(t20, 4), vmulq_n_f16(t22, 5)), t24); + float16x8_t m21 = vaddq_f16(vaddq_f16(t23, t24), vmulq_n_f16(vaddq_f16(t21, t22), -4)); + float16x8_t m22 = vaddq_f16(vsubq_f16(t24, t23), vmulq_n_f16(vsubq_f16(t21, t22), 4)); + float16x8_t m23 = vaddq_f16(vsubq_f16(t24, t22), vmulq_n_f16(vsubq_f16(t23, t21), 2)); + float16x8_t m24 = vaddq_f16(vsubq_f16(t24, t22), vmulq_n_f16(vsubq_f16(t21, t23), 2)); + float16x8_t m25 = vaddq_f16(vsubq_f16(vmulq_n_f16(t21, 4), vmulq_n_f16(t23, 5)), t25); - float16x4_t m30 = vadd_f16(vsub_f16(vmul_n_f16(t30, 4), vmul_n_f16(t32, 5)), t34); - float16x4_t m31 = vadd_f16(vadd_f16(t33, t34), vmul_n_f16(vadd_f16(t31, t32), -4)); - float16x4_t m32 = vadd_f16(vsub_f16(t34, t33), vmul_n_f16(vsub_f16(t31, t32), 4)); - float16x4_t m33 = vadd_f16(vsub_f16(t34, t32), vmul_n_f16(vsub_f16(t33, t31), 2)); - float16x4_t m34 = vadd_f16(vsub_f16(t34, t32), vmul_n_f16(vsub_f16(t31, t33), 2)); - float16x4_t m35 = vadd_f16(vsub_f16(vmul_n_f16(t31, 4), vmul_n_f16(t33, 5)), t35); + float16x8_t m30 = vaddq_f16(vsubq_f16(vmulq_n_f16(t30, 4), vmulq_n_f16(t32, 5)), t34); + float16x8_t m31 = vaddq_f16(vaddq_f16(t33, t34), vmulq_n_f16(vaddq_f16(t31, t32), -4)); + float16x8_t m32 = vaddq_f16(vsubq_f16(t34, t33), vmulq_n_f16(vsubq_f16(t31, t32), 4)); + float16x8_t m33 = vaddq_f16(vsubq_f16(t34, t32), vmulq_n_f16(vsubq_f16(t33, t31), 2)); + float16x8_t m34 = vaddq_f16(vsubq_f16(t34, t32), vmulq_n_f16(vsubq_f16(t31, t33), 2)); + float16x8_t m35 = vaddq_f16(vsubq_f16(vmulq_n_f16(t31, 4), vmulq_n_f16(t33, 5)), t35); - float16x4_t m40 = vadd_f16(vsub_f16(vmul_n_f16(t40, 4), vmul_n_f16(t42, 5)), t44); - float16x4_t m41 = vadd_f16(vadd_f16(t43, t44), vmul_n_f16(vadd_f16(t41, t42), -4)); - float16x4_t m42 = vadd_f16(vsub_f16(t44, t43), vmul_n_f16(vsub_f16(t41, t42), 4)); - float16x4_t m43 = vadd_f16(vsub_f16(t44, t42), vmul_n_f16(vsub_f16(t43, t41), 2)); - float16x4_t m44 = vadd_f16(vsub_f16(t44, t42), vmul_n_f16(vsub_f16(t41, t43), 2)); - float16x4_t m45 = vadd_f16(vsub_f16(vmul_n_f16(t41, 4), vmul_n_f16(t43, 5)), t45); + float16x8_t m40 = vaddq_f16(vsubq_f16(vmulq_n_f16(t40, 4), vmulq_n_f16(t42, 5)), t44); + float16x8_t m41 = vaddq_f16(vaddq_f16(t43, t44), vmulq_n_f16(vaddq_f16(t41, t42), -4)); + float16x8_t m42 = vaddq_f16(vsubq_f16(t44, t43), vmulq_n_f16(vsubq_f16(t41, t42), 4)); + float16x8_t m43 = vaddq_f16(vsubq_f16(t44, t42), vmulq_n_f16(vsubq_f16(t43, t41), 2)); + float16x8_t m44 = vaddq_f16(vsubq_f16(t44, t42), vmulq_n_f16(vsubq_f16(t41, t43), 2)); + float16x8_t m45 = vaddq_f16(vsubq_f16(vmulq_n_f16(t41, 4), vmulq_n_f16(t43, 5)), t45); - float16x4_t m50 = vadd_f16(vsub_f16(vmul_n_f16(t50, 4), vmul_n_f16(t52, 5)), t54); - float16x4_t m51 = vadd_f16(vadd_f16(t53, t54), vmul_n_f16(vadd_f16(t51, t52), -4)); - float16x4_t m52 = vadd_f16(vsub_f16(t54, t53), vmul_n_f16(vsub_f16(t51, t52), 4)); - float16x4_t m53 = vadd_f16(vsub_f16(t54, t52), vmul_n_f16(vsub_f16(t53, t51), 2)); - float16x4_t m54 = vadd_f16(vsub_f16(t54, t52), vmul_n_f16(vsub_f16(t51, t53), 2)); - float16x4_t m55 = vadd_f16(vsub_f16(vmul_n_f16(t51, 4), vmul_n_f16(t53, 5)), t55); + float16x8_t m50 = vaddq_f16(vsubq_f16(vmulq_n_f16(t50, 4), vmulq_n_f16(t52, 5)), t54); + float16x8_t m51 = vaddq_f16(vaddq_f16(t53, t54), vmulq_n_f16(vaddq_f16(t51, t52), -4)); + float16x8_t m52 = vaddq_f16(vsubq_f16(t54, t53), vmulq_n_f16(vsubq_f16(t51, t52), 4)); + float16x8_t m53 = vaddq_f16(vsubq_f16(t54, t52), vmulq_n_f16(vsubq_f16(t53, t51), 2)); + float16x8_t m54 = vaddq_f16(vsubq_f16(t54, t52), vmulq_n_f16(vsubq_f16(t51, t53), 2)); + float16x8_t m55 = vaddq_f16(vsubq_f16(vmulq_n_f16(t51, 4), vmulq_n_f16(t53, 5)), t55); - vst1_f16(trans_input_data, m00); - vst1_f16(trans_input_data + step, m01); - vst1_f16(trans_input_data + 2 * step, m02); - vst1_f16(trans_input_data + 3 * step, m03); - vst1_f16(trans_input_data + 4 * step, m04); - vst1_f16(trans_input_data + 5 * step, m05); + vst1_f16(trans_input_data, vget_low_f16(m00)); + vst1_f16(trans_input_data + 64, vget_high_f16(m00)); + vst1_f16(trans_input_data + step, vget_low_f16(m01)); + vst1_f16(trans_input_data + step + 64, vget_high_f16(m01)); + vst1_f16(trans_input_data + 2 * step, vget_low_f16(m02)); + vst1_f16(trans_input_data + 2 * step + 64, vget_high_f16(m02)); + vst1_f16(trans_input_data + 3 * step, vget_low_f16(m03)); + vst1_f16(trans_input_data + 3 * step + 64, vget_high_f16(m03)); + vst1_f16(trans_input_data + 4 * step, vget_low_f16(m04)); + vst1_f16(trans_input_data + 4 * step + 64, vget_high_f16(m04)); + vst1_f16(trans_input_data + 5 * step, vget_low_f16(m05)); + vst1_f16(trans_input_data + 5 * step + 64, vget_high_f16(m05)); - vst1_f16(trans_input_data + 6 * step, m10); - vst1_f16(trans_input_data + 7 * step, m11); - vst1_f16(trans_input_data + 8 * step, m12); - vst1_f16(trans_input_data + 9 * step, m13); - vst1_f16(trans_input_data + 10 * step, m14); - vst1_f16(trans_input_data + 11 * step, m15); + vst1_f16(trans_input_data + 6 * step, vget_low_f16(m10)); + vst1_f16(trans_input_data + 6 * step + 64, vget_high_f16(m10)); + vst1_f16(trans_input_data + 7 * step, vget_low_f16(m11)); + vst1_f16(trans_input_data + 7 * step + 64, vget_high_f16(m11)); + vst1_f16(trans_input_data + 8 * step, vget_low_f16(m12)); + vst1_f16(trans_input_data + 8 * step + 64, vget_high_f16(m12)); + vst1_f16(trans_input_data + 9 * step, vget_low_f16(m13)); + vst1_f16(trans_input_data + 9 * step + 64, vget_high_f16(m13)); + vst1_f16(trans_input_data + 10 * step, vget_low_f16(m14)); + vst1_f16(trans_input_data + 10 * step + 64, vget_high_f16(m14)); + vst1_f16(trans_input_data + 11 * step, vget_low_f16(m15)); + vst1_f16(trans_input_data + 11 * step + 64, vget_high_f16(m15)); - vst1_f16(trans_input_data + 12 * step, m20); - vst1_f16(trans_input_data + 13 * step, m21); - vst1_f16(trans_input_data + 14 * step, m22); - vst1_f16(trans_input_data + 15 * step, m23); - vst1_f16(trans_input_data + 16 * step, m24); - vst1_f16(trans_input_data + 17 * step, m25); + vst1_f16(trans_input_data + 12 * step, vget_low_f16(m20)); + vst1_f16(trans_input_data + 12 * step + 64, vget_high_f16(m20)); + vst1_f16(trans_input_data + 13 * step, vget_low_f16(m21)); + vst1_f16(trans_input_data + 13 * step + 64, vget_high_f16(m21)); + vst1_f16(trans_input_data + 14 * step, vget_low_f16(m22)); + vst1_f16(trans_input_data + 14 * step + 64, vget_high_f16(m22)); + vst1_f16(trans_input_data + 15 * step, vget_low_f16(m23)); + vst1_f16(trans_input_data + 15 * step + 64, vget_high_f16(m23)); + vst1_f16(trans_input_data + 16 * step, vget_low_f16(m24)); + vst1_f16(trans_input_data + 16 * step + 64, vget_high_f16(m24)); + vst1_f16(trans_input_data + 17 * step, vget_low_f16(m25)); + vst1_f16(trans_input_data + 17 * step + 64, vget_high_f16(m25)); - vst1_f16(trans_input_data + 18 * step, m30); - vst1_f16(trans_input_data + 19 * step, m31); - vst1_f16(trans_input_data + 20 * step, m32); - vst1_f16(trans_input_data + 21 * step, m33); - vst1_f16(trans_input_data + 22 * step, m34); - vst1_f16(trans_input_data + 23 * step, m35); + vst1_f16(trans_input_data + 18 * step, vget_low_f16(m30)); + vst1_f16(trans_input_data + 18 * step + 64, vget_high_f16(m30)); + vst1_f16(trans_input_data + 19 * step, vget_low_f16(m31)); + vst1_f16(trans_input_data + 19 * step + 64, vget_high_f16(m31)); + vst1_f16(trans_input_data + 20 * step, vget_low_f16(m32)); + vst1_f16(trans_input_data + 20 * step + 64, vget_high_f16(m32)); + vst1_f16(trans_input_data + 21 * step, vget_low_f16(m33)); + vst1_f16(trans_input_data + 21 * step + 64, vget_high_f16(m33)); + vst1_f16(trans_input_data + 22 * step, vget_low_f16(m34)); + vst1_f16(trans_input_data + 22 * step + 64, vget_high_f16(m34)); + vst1_f16(trans_input_data + 23 * step, vget_low_f16(m35)); + vst1_f16(trans_input_data + 23 * step + 64, vget_high_f16(m35)); - vst1_f16(trans_input_data + 24 * step, m40); - vst1_f16(trans_input_data + 25 * step, m41); - vst1_f16(trans_input_data + 26 * step, m42); - vst1_f16(trans_input_data + 27 * step, m43); - vst1_f16(trans_input_data + 28 * step, m44); - vst1_f16(trans_input_data + 29 * step, m45); + vst1_f16(trans_input_data + 24 * step, vget_low_f16(m40)); + vst1_f16(trans_input_data + 24 * step + 64, vget_high_f16(m40)); + vst1_f16(trans_input_data + 25 * step, vget_low_f16(m41)); + vst1_f16(trans_input_data + 25 * step + 64, vget_high_f16(m41)); + vst1_f16(trans_input_data + 26 * step, vget_low_f16(m42)); + vst1_f16(trans_input_data + 26 * step + 64, vget_high_f16(m42)); + vst1_f16(trans_input_data + 27 * step, vget_low_f16(m43)); + vst1_f16(trans_input_data + 27 * step + 64, vget_high_f16(m43)); + vst1_f16(trans_input_data + 28 * step, vget_low_f16(m44)); + vst1_f16(trans_input_data + 28 * step + 64, vget_high_f16(m44)); + vst1_f16(trans_input_data + 29 * step, vget_low_f16(m45)); + vst1_f16(trans_input_data + 29 * step + 64, vget_high_f16(m45)); - vst1_f16(trans_input_data + 30 * step, m50); - vst1_f16(trans_input_data + 31 * step, m51); - vst1_f16(trans_input_data + 32 * step, m52); - vst1_f16(trans_input_data + 33 * step, m53); - vst1_f16(trans_input_data + 34 * step, m54); - vst1_f16(trans_input_data + 35 * step, m55); + vst1_f16(trans_input_data + 30 * step, vget_low_f16(m50)); + vst1_f16(trans_input_data + 30 * step + 64, vget_high_f16(m50)); + vst1_f16(trans_input_data + 31 * step, vget_low_f16(m51)); + vst1_f16(trans_input_data + 31 * step + 64, vget_high_f16(m51)); + vst1_f16(trans_input_data + 32 * step, vget_low_f16(m52)); + vst1_f16(trans_input_data + 32 * step + 64, vget_high_f16(m52)); + vst1_f16(trans_input_data + 33 * step, vget_low_f16(m53)); + vst1_f16(trans_input_data + 33 * step + 64, vget_high_f16(m53)); + vst1_f16(trans_input_data + 34 * step, vget_low_f16(m54)); + vst1_f16(trans_input_data + 34 * step + 64, vget_high_f16(m54)); + vst1_f16(trans_input_data + 35 * step, vget_low_f16(m55)); + vst1_f16(trans_input_data + 35 * step + 64, vget_high_f16(m55)); } void Conv3x3Fp16InputTransform(const float16_t *input_data, float16_t *trans_input, float16_t *tmp_data, @@ -196,7 +232,7 @@ void Conv3x3Fp16InputTransform(const float16_t *input_data, float16_t *trans_inp int input_height = conv_param->input_h_; int pad_w = conv_param->pad_w_; int pad_h = conv_param->pad_h_; - int ic4 = UP_DIV(input_channel, C4NUM); + int ic8 = UP_DIV(input_channel, C8NUM); if (out_w_block == 0) { return; } @@ -209,33 +245,29 @@ void Conv3x3Fp16InputTransform(const float16_t *input_data, float16_t *trans_inp int real_y_start = origin_y > 0 ? 0 : -origin_y; int real_y_end = (origin_y + 6) < input_height ? 6 : (input_height - origin_y); - int src_plane_offset = ic4 * C4NUM * (origin_y * input_width + origin_x); + int src_plane_offset = ic8 * C8NUM * (origin_y * input_width + origin_x); int dst_plane_offset = cal_id * C4NUM; - for (int ic = 0; ic < ic4; ic++) { + for (int ic = 0; ic < ic8; ic++) { // clear tmp buffer - memset(tmp_data, 0, 6 * 6 * C4NUM * sizeof(float16_t)); + memset(tmp_data, 0, 6 * 6 * C8NUM * sizeof(float16_t)); // get real input block with padding - int src_ic4_offset = src_plane_offset + ic * C4NUM; + int src_ic4_offset = src_plane_offset + ic * C8NUM; for (int interval = real_y_start; interval < real_y_end; interval++) { - int src_y_offset = src_ic4_offset + (interval * input_width + real_x_start) * ic4 * C4NUM; - int dst_y_offset = interval * 6 * C4NUM + real_x_start * C4NUM; + int src_y_offset = src_ic4_offset + (interval * input_width + real_x_start) * ic8 * C8NUM; + int dst_y_offset = interval * 6 * C8NUM + real_x_start * C8NUM; for (int j = 0; j < (real_x_end - real_x_start); j++) { - int src_x_offset = src_y_offset + j * ic4 * C4NUM; - int dst_x_offset = dst_y_offset + j * C4NUM; + int src_x_offset = src_y_offset + j * ic8 * C8NUM; + int dst_x_offset = dst_y_offset + j * C8NUM; float16_t *src_addr = (float16_t *)(input_data) + src_x_offset; float16_t *dst_addr = tmp_data + dst_x_offset; - dst_addr[0] = src_addr[0]; - dst_addr[1] = src_addr[1]; - dst_addr[2] = src_addr[2]; - dst_addr[3] = src_addr[3]; + vst1q_f16(dst_addr, vld1q_f16(src_addr)); } } - // todo // input transform - int dst_ic4_offset = dst_plane_offset + ic * 16 * C4NUM; - size_t dst_step = ic4 * C4NUM * 16; + int dst_ic4_offset = dst_plane_offset + ic * 16 * C8NUM; + size_t dst_step = ic8 * C8NUM * 16; float16_t *trans_input_ptr = trans_input + dst_ic4_offset; Conv3x3Fp16InputUnit(tmp_data, trans_input_ptr, dst_step); } @@ -543,7 +575,7 @@ void WinogradInputTransformFp16(const float16_t *input_data, float16_t *trans_in int input_unit = conv_param->input_unit_; int output_unit = conv_param->output_unit_; int in_channel = conv_param->input_channel_; - int ic4 = UP_DIV(in_channel, C4NUM); + int ic8 = UP_DIV(in_channel, C8NUM); int pad_h = conv_param->pad_h_; int pad_w = conv_param->pad_w_; int input_h = conv_param->input_h_; @@ -561,36 +593,36 @@ void WinogradInputTransformFp16(const float16_t *input_data, float16_t *trans_in int interval_x_e = src_x_e < input_w ? input_unit : (input_w - src_x_s); int interval_y_e = src_y_e < input_h ? input_unit : (input_h - src_y_s); - int src_plane_offset = ic4 * C4NUM * (src_y_s * input_w + src_x_s); + int src_plane_offset = ic8 * C8NUM * (src_y_s * input_w + src_x_s); int dst_plane_offset = c * C4NUM; - for (int ic = 0; ic < ic4; ic++) { + for (int ic = 0; ic < ic8; ic++) { // clear tmp buffer - memset(tmp_data, 0, input_unit * input_unit * C4NUM * sizeof(float16_t)); + memset(tmp_data, 0, input_unit * input_unit * C8NUM * sizeof(float16_t)); // get real input block with padding - int src_ic4_offset = src_plane_offset + ic * C4NUM; + int src_ic8_offset = src_plane_offset + ic * C8NUM; for (int interval = interval_y_s; interval < interval_y_e; interval++) { - int src_y_offset = src_ic4_offset + (interval * input_w + interval_x_s) * ic4 * C4NUM; - int dst_y_offset = interval * input_unit * C4NUM + interval_x_s * C4NUM; + int src_y_offset = src_ic8_offset + (interval * input_w + interval_x_s) * ic8 * C8NUM; + int dst_y_offset = interval * input_unit * C8NUM + interval_x_s * C8NUM; for (int j = 0; j < (interval_x_e - interval_x_s); j++) { - int src_x_offset = src_y_offset + j * ic4 * C4NUM; - int dst_x_offset = dst_y_offset + j * C4NUM; + int src_x_offset = src_y_offset + j * ic8 * C8NUM; + int dst_x_offset = dst_y_offset + j * C8NUM; float16_t *src_addr = input_data + src_x_offset; float16_t *dst_addr = tmp_data + dst_x_offset; #ifdef ENABLE_NEON - vst1_f16(dst_addr, vld1_f16(src_addr)); + vst1q_f16(dst_addr, vld1q_f16(src_addr)); #else - for (int k = 0; k < C4NUM; k++) { + for (int k = 0; k < C8NUM; k++) { dst_addr[k] = src_addr[k]; } #endif } } // input transform - int dst_ic4_offset = dst_plane_offset + ic * tile_num * C4NUM; - size_t dst_step = ic4 * C4NUM * tile_num; - float16_t *trans_input_ptr = trans_input + dst_ic4_offset; - input_trans_func(tmp_data, trans_input_ptr, C4NUM, dst_step); + int dst_ic8_offset = dst_plane_offset + ic * tile_num * C8NUM; + size_t dst_step = ic8 * C8NUM * tile_num; + float16_t *trans_input_ptr = trans_input + dst_ic8_offset; + input_trans_func(tmp_data, trans_input_ptr, C8NUM, dst_step); } out_tile_index++; } // cal_tile_num loop @@ -612,7 +644,7 @@ void WinogradOutputTransformFp16(const float16_t *gemm_out, float16_t *tmp_out_d int dst_x_s = out_tile_index % output_unit_num; int dst_y_s = out_tile_index / output_unit_num; int src_tile_offset = i * oc8 * C8NUM * input_unit * input_unit; - int dst_tile_offset = C4NUM * output_unit * (dst_x_s + dst_y_s * output_unit_block * output_unit); + int dst_tile_offset = C8NUM * output_unit * (dst_x_s + dst_y_s * output_unit_block * output_unit); for (int j = 0; j < oc8; j++) { int src_oc8_offset = src_tile_offset + j * input_unit * input_unit * C8NUM; @@ -620,7 +652,7 @@ void WinogradOutputTransformFp16(const float16_t *gemm_out, float16_t *tmp_out_d dst_tile_offset + j * C8NUM * output_unit_block * output_unit_block * output_unit * output_unit; const float16_t *src_ptr = gemm_out + src_oc8_offset; const float16_t *bias_ptr = bias_data + j * C8NUM; - float16_t *dst_ptr = tmp_out_data + dst_oc8_offset; + float16_t *dst_ptr = tmp_out_data + dst_oc8_offset; output_trans_func(src_ptr, dst_ptr, bias_ptr, C8NUM, output_unit_block * output_unit); } out_tile_index++; diff --git a/mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/winograd_utils_fp16.c b/mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/winograd_utils_fp16.c index b38cc91f3ef..1df0f538010 100644 --- a/mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/winograd_utils_fp16.c +++ b/mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/winograd_utils_fp16.c @@ -31,7 +31,6 @@ static OutputTransformUnitFp16Func outputTransformUnitFp16[] = { }; void InputTransform4x4UnitFp16(const float16_t *src_data, float16_t *dst_data, int src_step, int dst_step) { -#ifdef ENABLE_ARM float16x8_t src_data_00 = vld1q_f16(src_data + 0 * src_step); float16x8_t src_data_01 = vld1q_f16(src_data + 1 * src_step); float16x8_t src_data_02 = vld1q_f16(src_data + 2 * src_step); @@ -89,106 +88,41 @@ void InputTransform4x4UnitFp16(const float16_t *src_data, float16_t *dst_data, i float16x8_t m32 = vsubq_f16(vmulq_n_f16(t32, 2), t31); float16x8_t m33 = vsubq_f16(t33, vmulq_n_f16(t31, 0.25)); - vst1q_f16(dst_data + 0 * dst_step, m00); - vst1q_f16(dst_data + 1 * dst_step, m01); - vst1q_f16(dst_data + 2 * dst_step, m02); - vst1q_f16(dst_data + 3 * dst_step, m03); - vst1q_f16(dst_data + 4 * dst_step, m10); - vst1q_f16(dst_data + 5 * dst_step, m11); - vst1q_f16(dst_data + 6 * dst_step, m12); - vst1q_f16(dst_data + 7 * dst_step, m13); - vst1q_f16(dst_data + 8 * dst_step, m20); - vst1q_f16(dst_data + 9 * dst_step, m21); - vst1q_f16(dst_data + 10 * dst_step, m22); - vst1q_f16(dst_data + 11 * dst_step, m23); - vst1q_f16(dst_data + 12 * dst_step, m30); - vst1q_f16(dst_data + 13 * dst_step, m31); - vst1q_f16(dst_data + 14 * dst_step, m32); - vst1q_f16(dst_data + 15 * dst_step, m33); -#else - for (int i = 0; i < C8NUM; i++) { - float16_t src_data_00 = src_data[i]; - float16_t src_data_01 = src_data[i + src_step]; - float16_t src_data_02 = src_data[i + 2 * src_step]; - float16_t src_data_03 = src_data[i + 3 * src_step]; - float16_t src_data_10 = src_data[i + 4 * src_step]; - float16_t src_data_11 = src_data[i + 5 * src_step]; - float16_t src_data_12 = src_data[i + 6 * src_step]; - float16_t src_data_13 = src_data[i + 7 * src_step]; - float16_t src_data_20 = src_data[i + 8 * src_step]; - float16_t src_data_21 = src_data[i + 9 * src_step]; - float16_t src_data_22 = src_data[i + 10 * src_step]; - float16_t src_data_23 = src_data[i + 11 * src_step]; - float16_t src_data_30 = src_data[i + 12 * src_step]; - float16_t src_data_31 = src_data[i + 13 * src_step]; - float16_t src_data_32 = src_data[i + 14 * src_step]; - float16_t src_data_33 = src_data[i + 15 * src_step]; - - float16_t t00 = src_data_00 - 4 * src_data_20; - float16_t t01 = src_data_01 - 4 * src_data_21; - float16_t t02 = src_data_02 - 4 * src_data_22; - float16_t t03 = src_data_03 - 4 * src_data_23; - - float16_t t10 = src_data_10 + 2 * src_data_20; - float16_t t11 = src_data_11 + 2 * src_data_21; - float16_t t12 = src_data_12 + 2 * src_data_22; - float16_t t13 = src_data_13 + 2 * src_data_23; - - const float16_t t20 = 2 * src_data_20 - src_data_10; - const float16_t t21 = 2 * src_data_21 - src_data_11; - const float16_t t22 = 2 * src_data_22 - src_data_12; - const float16_t t23 = 2 * src_data_23 - src_data_13; - - float16_t t30 = src_data_30 - 0.25f * src_data_10; - float16_t t31 = src_data_31 - 0.25f * src_data_11; - float16_t t32 = src_data_32 - 0.25f * src_data_12; - float16_t t33 = src_data_33 - 0.25f * src_data_13; - - float16_t m00 = t00 - 4 * t02; - float16_t m01 = t01 + 2 * t02; - const float16_t m02 = 2 * t02 - t01; - float16_t m03 = t03 - 0.25f * t01; - - float16_t m10 = t10 - 4 * t12; - float16_t m11 = t11 + 2 * t12; - const float16_t m12 = 2 * t12 - t11; - float16_t m13 = t13 - 0.25f * t11; - - float16_t m20 = t20 - 4 * t22; - float16_t m21 = t21 + 2 * t22; - const float16_t m22 = 2 * t22 - t21; - float16_t m23 = t23 - 0.25f * t21; - - float16_t m30 = t30 - 4 * t32; - const float16_t m31 = t31 + 2 * t32; - float16_t m32 = 2 * t32 - t31; - float16_t m33 = t33 - 0.25f * t31; - - (dst_data + i)[0] = m00; - (dst_data + i + dst_step)[0] = m01; - (dst_data + i + 2 * dst_step)[0] = m02; - (dst_data + i + 3 * dst_step)[0] = m03; - - (dst_data + i + 4 * dst_step)[0] = m10; - (dst_data + i + 5 * dst_step)[0] = m11; - (dst_data + i + 6 * dst_step)[0] = m12; - (dst_data + i + 7 * dst_step)[0] = m13; - - (dst_data + i + 8 * dst_step)[0] = m20; - (dst_data + i + 9 * dst_step)[0] = m21; - (dst_data + i + 10 * dst_step)[0] = m22; - (dst_data + i + 11 * dst_step)[0] = m23; - - (dst_data + i + 12 * dst_step)[0] = m30; - (dst_data + i + 13 * dst_step)[0] = m31; - (dst_data + i + 14 * dst_step)[0] = m32; - (dst_data + i + 15 * dst_step)[0] = m33; - } -#endif + vst1_f16(dst_data, vget_low_f16(m00)); + vst1_f16(dst_data + 64, vget_high_f16(m00)); + vst1_f16(dst_data + 1 * dst_step, vget_low_f16(m01)); + vst1_f16(dst_data + 1 * dst_step + 64, vget_high_f16(m01)); + vst1_f16(dst_data + 2 * dst_step, vget_low_f16(m02)); + vst1_f16(dst_data + 2 * dst_step + 64, vget_high_f16(m02)); + vst1_f16(dst_data + 3 * dst_step, vget_low_f16(m03)); + vst1_f16(dst_data + 3 * dst_step + 64, vget_high_f16(m03)); + vst1_f16(dst_data + 4 * dst_step, vget_low_f16(m10)); + vst1_f16(dst_data + 4 * dst_step + 64, vget_high_f16(m10)); + vst1_f16(dst_data + 5 * dst_step, vget_low_f16(m11)); + vst1_f16(dst_data + 5 * dst_step + 64, vget_high_f16(m11)); + vst1_f16(dst_data + 6 * dst_step, vget_low_f16(m12)); + vst1_f16(dst_data + 6 * dst_step + 64, vget_high_f16(m12)); + vst1_f16(dst_data + 7 * dst_step, vget_low_f16(m13)); + vst1_f16(dst_data + 7 * dst_step + 64, vget_high_f16(m13)); + vst1_f16(dst_data + 8 * dst_step, vget_low_f16(m20)); + vst1_f16(dst_data + 8 * dst_step + 64, vget_high_f16(m20)); + vst1_f16(dst_data + 9 * dst_step, vget_low_f16(m21)); + vst1_f16(dst_data + 9 * dst_step + 64, vget_high_f16(m21)); + vst1_f16(dst_data + 10 * dst_step, vget_low_f16(m22)); + vst1_f16(dst_data + 10 * dst_step + 64, vget_high_f16(m22)); + vst1_f16(dst_data + 11 * dst_step, vget_low_f16(m23)); + vst1_f16(dst_data + 11 * dst_step + 64, vget_high_f16(m23)); + vst1_f16(dst_data + 12 * dst_step, vget_low_f16(m30)); + vst1_f16(dst_data + 12 * dst_step + 64, vget_high_f16(m30)); + vst1_f16(dst_data + 13 * dst_step, vget_low_f16(m31)); + vst1_f16(dst_data + 13 * dst_step + 64, vget_high_f16(m31)); + vst1_f16(dst_data + 14 * dst_step, vget_low_f16(m32)); + vst1_f16(dst_data + 14 * dst_step + 64, vget_high_f16(m32)); + vst1_f16(dst_data + 15 * dst_step, vget_low_f16(m33)); + vst1_f16(dst_data + 15 * dst_step + 64, vget_high_f16(m33)); } void InputTransform8x8UnitFp16(const float16_t *src_data, float16_t *dst_data, int src_step, int dst_step) { -#ifdef ENABLE_ARM float16x8_t src_data_00 = vld1q_f16(src_data + 0 * src_step); float16x8_t src_data_01 = vld1q_f16(src_data + 1 * src_step); float16x8_t src_data_02 = vld1q_f16(src_data + 2 * src_step); @@ -838,461 +772,134 @@ void InputTransform8x8UnitFp16(const float16_t *src_data, float16_t *dst_data, i float16x8_t m77 = vaddq_f16(vsubq_f16(vaddq_f16(vmulq_n_f16(t71, -0.5625), vmulq_n_f16(t73, 3.0625)), vmulq_n_f16(t75, 3.5)), t77); - vst1q_f16(dst_data + 0 * dst_step, m00); - vst1q_f16(dst_data + 1 * dst_step, m01); - vst1q_f16(dst_data + 2 * dst_step, m02); - vst1q_f16(dst_data + 3 * dst_step, m03); - vst1q_f16(dst_data + 4 * dst_step, m04); - vst1q_f16(dst_data + 5 * dst_step, m05); - vst1q_f16(dst_data + 6 * dst_step, m06); - vst1q_f16(dst_data + 7 * dst_step, m07); - vst1q_f16(dst_data + 8 * dst_step, m10); - vst1q_f16(dst_data + 9 * dst_step, m11); - vst1q_f16(dst_data + 10 * dst_step, m12); - vst1q_f16(dst_data + 11 * dst_step, m13); - vst1q_f16(dst_data + 12 * dst_step, m14); - vst1q_f16(dst_data + 13 * dst_step, m15); - vst1q_f16(dst_data + 14 * dst_step, m16); - vst1q_f16(dst_data + 15 * dst_step, m17); - vst1q_f16(dst_data + 16 * dst_step, m20); - vst1q_f16(dst_data + 17 * dst_step, m21); - vst1q_f16(dst_data + 18 * dst_step, m22); - vst1q_f16(dst_data + 19 * dst_step, m23); - vst1q_f16(dst_data + 20 * dst_step, m24); - vst1q_f16(dst_data + 21 * dst_step, m25); - vst1q_f16(dst_data + 22 * dst_step, m26); - vst1q_f16(dst_data + 23 * dst_step, m27); - vst1q_f16(dst_data + 24 * dst_step, m30); - vst1q_f16(dst_data + 25 * dst_step, m31); - vst1q_f16(dst_data + 26 * dst_step, m32); - vst1q_f16(dst_data + 27 * dst_step, m33); - vst1q_f16(dst_data + 28 * dst_step, m34); - vst1q_f16(dst_data + 29 * dst_step, m35); - vst1q_f16(dst_data + 30 * dst_step, m36); - vst1q_f16(dst_data + 31 * dst_step, m37); - vst1q_f16(dst_data + 32 * dst_step, m40); - vst1q_f16(dst_data + 33 * dst_step, m41); - vst1q_f16(dst_data + 34 * dst_step, m42); - vst1q_f16(dst_data + 35 * dst_step, m43); - vst1q_f16(dst_data + 36 * dst_step, m44); - vst1q_f16(dst_data + 37 * dst_step, m45); - vst1q_f16(dst_data + 38 * dst_step, m46); - vst1q_f16(dst_data + 39 * dst_step, m47); - vst1q_f16(dst_data + 40 * dst_step, m50); - vst1q_f16(dst_data + 41 * dst_step, m51); - vst1q_f16(dst_data + 42 * dst_step, m52); - vst1q_f16(dst_data + 43 * dst_step, m53); - vst1q_f16(dst_data + 44 * dst_step, m54); - vst1q_f16(dst_data + 45 * dst_step, m55); - vst1q_f16(dst_data + 46 * dst_step, m56); - vst1q_f16(dst_data + 47 * dst_step, m57); - vst1q_f16(dst_data + 48 * dst_step, m60); - vst1q_f16(dst_data + 49 * dst_step, m61); - vst1q_f16(dst_data + 50 * dst_step, m62); - vst1q_f16(dst_data + 51 * dst_step, m63); - vst1q_f16(dst_data + 52 * dst_step, m64); - vst1q_f16(dst_data + 53 * dst_step, m65); - vst1q_f16(dst_data + 54 * dst_step, m66); - vst1q_f16(dst_data + 55 * dst_step, m67); - vst1q_f16(dst_data + 56 * dst_step, m70); - vst1q_f16(dst_data + 57 * dst_step, m71); - vst1q_f16(dst_data + 58 * dst_step, m72); - vst1q_f16(dst_data + 59 * dst_step, m73); - vst1q_f16(dst_data + 60 * dst_step, m74); - vst1q_f16(dst_data + 61 * dst_step, m75); - vst1q_f16(dst_data + 62 * dst_step, m76); - vst1q_f16(dst_data + 63 * dst_step, m77); -#else - for (int i = 0; i < C8NUM; i++) { - float16_t src_data_00 = src_data[i]; - float16_t src_data_01 = src_data[i + src_step]; - float16_t src_data_02 = src_data[i + 2 * src_step]; - float16_t src_data_03 = src_data[i + 3 * src_step]; - float16_t src_data_04 = src_data[i + 4 * src_step]; - float16_t src_data_05 = src_data[i + 5 * src_step]; - float16_t src_data_06 = src_data[i + 6 * src_step]; - float16_t src_data_07 = src_data[i + 7 * src_step]; - float16_t src_data_10 = src_data[i + 8 * src_step]; - float16_t src_data_11 = src_data[i + 9 * src_step]; - float16_t src_data_12 = src_data[i + 10 * src_step]; - float16_t src_data_13 = src_data[i + 11 * src_step]; - float16_t src_data_14 = src_data[i + 12 * src_step]; - float16_t src_data_15 = src_data[i + 13 * src_step]; - float16_t src_data_16 = src_data[i + 14 * src_step]; - float16_t src_data_17 = src_data[i + 15 * src_step]; - float16_t src_data_20 = src_data[i + 16 * src_step]; - float16_t src_data_21 = src_data[i + 17 * src_step]; - float16_t src_data_22 = src_data[i + 18 * src_step]; - float16_t src_data_23 = src_data[i + 19 * src_step]; - float16_t src_data_24 = src_data[i + 20 * src_step]; - float16_t src_data_25 = src_data[i + 21 * src_step]; - float16_t src_data_26 = src_data[i + 22 * src_step]; - float16_t src_data_27 = src_data[i + 23 * src_step]; - float16_t src_data_30 = src_data[i + 24 * src_step]; - float16_t src_data_31 = src_data[i + 25 * src_step]; - float16_t src_data_32 = src_data[i + 26 * src_step]; - float16_t src_data_33 = src_data[i + 27 * src_step]; - float16_t src_data_34 = src_data[i + 28 * src_step]; - float16_t src_data_35 = src_data[i + 29 * src_step]; - float16_t src_data_36 = src_data[i + 30 * src_step]; - float16_t src_data_37 = src_data[i + 31 * src_step]; - float16_t src_data_40 = src_data[i + 32 * src_step]; - float16_t src_data_41 = src_data[i + 33 * src_step]; - float16_t src_data_42 = src_data[i + 34 * src_step]; - float16_t src_data_43 = src_data[i + 35 * src_step]; - float16_t src_data_44 = src_data[i + 36 * src_step]; - float16_t src_data_45 = src_data[i + 37 * src_step]; - float16_t src_data_46 = src_data[i + 38 * src_step]; - float16_t src_data_47 = src_data[i + 39 * src_step]; - float16_t src_data_50 = src_data[i + 40 * src_step]; - float16_t src_data_51 = src_data[i + 41 * src_step]; - float16_t src_data_52 = src_data[i + 42 * src_step]; - float16_t src_data_53 = src_data[i + 43 * src_step]; - float16_t src_data_54 = src_data[i + 44 * src_step]; - float16_t src_data_55 = src_data[i + 45 * src_step]; - float16_t src_data_56 = src_data[i + 46 * src_step]; - float16_t src_data_57 = src_data[i + 47 * src_step]; - float16_t src_data_60 = src_data[i + 48 * src_step]; - float16_t src_data_61 = src_data[i + 49 * src_step]; - float16_t src_data_62 = src_data[i + 50 * src_step]; - float16_t src_data_63 = src_data[i + 51 * src_step]; - float16_t src_data_64 = src_data[i + 52 * src_step]; - float16_t src_data_65 = src_data[i + 53 * src_step]; - float16_t src_data_66 = src_data[i + 54 * src_step]; - float16_t src_data_67 = src_data[i + 55 * src_step]; - float16_t src_data_70 = src_data[i + 56 * src_step]; - float16_t src_data_71 = src_data[i + 57 * src_step]; - float16_t src_data_72 = src_data[i + 58 * src_step]; - float16_t src_data_73 = src_data[i + 59 * src_step]; - float16_t src_data_74 = src_data[i + 60 * src_step]; - float16_t src_data_75 = src_data[i + 61 * src_step]; - float16_t src_data_76 = src_data[i + 62 * src_step]; - float16_t src_data_77 = src_data[i + 63 * src_step]; - - float16_t t00 = src_data_00 - 5.444444444444444445125f * src_data_20 + 6.222222222222222222223f * src_data_40 - - 1.77777777777777778f * src_data_60; - float16_t t01 = src_data_01 - 5.444444444444444445125f * src_data_21 + 6.222222222222222222223f * src_data_41 - - 1.77777777777777778f * src_data_61; - float16_t t02 = src_data_02 - 5.444444444444444445125f * src_data_22 + 6.222222222222222222223f * src_data_42 - - 1.77777777777777778f * src_data_62; - float16_t t03 = src_data_03 - 5.444444444444444445125f * src_data_23 + 6.222222222222222222223f * src_data_43 - - 1.77777777777777778f * src_data_63; - float16_t t04 = src_data_04 - 5.444444444444444445125f * src_data_24 + 6.222222222222222222223f * src_data_44 - - 1.77777777777777778f * src_data_64; - float16_t t05 = src_data_05 - 5.444444444444444445125f * src_data_25 + 6.222222222222222222223f * src_data_45 - - 1.77777777777777778f * src_data_65; - float16_t t06 = src_data_06 - 5.444444444444444445125f * src_data_26 + 6.222222222222222222223f * src_data_46 - - 1.77777777777777778f * src_data_66; - float16_t t07 = src_data_07 - 5.444444444444444445125f * src_data_27 + 6.222222222222222222223f * src_data_47 - - 1.77777777777777778f * src_data_67; - - const float16_t t10 = 1.5f * src_data_10 + 3.0f * src_data_20 - 2.1666666666666667f * src_data_30 - - 4.333333333333333333f * src_data_40 + 0.66666666666666667f * src_data_50 + - 1.333333333333333f * src_data_60; - const float16_t t11 = 1.5f * src_data_11 + 3.0f * src_data_21 - 2.1666666666666667f * src_data_31 - - 4.333333333333333333f * src_data_41 + 0.66666666666666667f * src_data_51 + - 1.333333333333333f * src_data_61; - const float16_t t12 = 1.5f * src_data_12 + 3.0f * src_data_22 - 2.1666666666666667f * src_data_32 - - 4.333333333333333333f * src_data_42 + 0.66666666666666667f * src_data_52 + - 1.333333333333333f * src_data_62; - const float16_t t13 = 1.5f * src_data_13 + 3.0f * src_data_23 - 2.1666666666666667f * src_data_33 - - 4.333333333333333333f * src_data_43 + 0.66666666666666667f * src_data_53 + - 1.333333333333333f * src_data_63; - const float16_t t14 = 1.5f * src_data_14 + 3.0f * src_data_24 - 2.1666666666666667f * src_data_34 - - 4.333333333333333333f * src_data_44 + 0.66666666666666667f * src_data_54 + - 1.333333333333333f * src_data_64; - const float16_t t15 = 1.5f * src_data_15 + 3.0f * src_data_25 - 2.1666666666666667f * src_data_35 - - 4.333333333333333333f * src_data_45 + 0.66666666666666667f * src_data_55 + - 1.333333333333333f * src_data_65; - const float16_t t16 = 1.5f * src_data_16 + 3.0f * src_data_26 - 2.1666666666666667f * src_data_36 - - 4.333333333333333333f * src_data_46 + 0.66666666666666667f * src_data_56 + - 1.333333333333333f * src_data_66; - const float16_t t17 = 1.5f * src_data_17 + 3.0f * src_data_27 - 2.1666666666666667f * src_data_37 - - 4.333333333333333333f * src_data_47 + 0.66666666666666667f * src_data_57 + - 1.333333333333333f * src_data_67; - - const float16_t t20 = -1.5f * src_data_10 + 3.0f * src_data_20 + 2.1666666666666667f * src_data_30 - - 4.333333333333333333f * src_data_40 - 0.66666666666666667f * src_data_50 + - 1.333333333333333f * src_data_60; - const float16_t t21 = -1.5f * src_data_11 + 3.0f * src_data_21 + 2.1666666666666667f * src_data_31 - - 4.333333333333333333f * src_data_41 - 0.66666666666666667f * src_data_51 + - 1.333333333333333f * src_data_61; - const float16_t t22 = -1.5f * src_data_12 + 3.0f * src_data_22 + 2.1666666666666667f * src_data_32 - - 4.333333333333333333f * src_data_42 - 0.66666666666666667f * src_data_52 + - 1.333333333333333f * src_data_62; - const float16_t t23 = -1.5f * src_data_13 + 3.0f * src_data_23 + 2.1666666666666667f * src_data_33 - - 4.333333333333333333f * src_data_43 - 0.66666666666666667f * src_data_53 + - 1.333333333333333f * src_data_63; - const float16_t t24 = -1.5f * src_data_14 + 3.0f * src_data_24 + 2.1666666666666667f * src_data_34 - - 4.333333333333333333f * src_data_44 - 0.66666666666666667f * src_data_54 + - 1.333333333333333f * src_data_64; - const float16_t t25 = -1.5f * src_data_15 + 3.0f * src_data_25 + 2.1666666666666667f * src_data_35 - - 4.333333333333333333f * src_data_45 - 0.66666666666666667f * src_data_55 + - 1.333333333333333f * src_data_65; - const float16_t t26 = -1.5f * src_data_16 + 3.0f * src_data_26 + 2.1666666666666667f * src_data_36 - - 4.333333333333333333f * src_data_46 - 0.66666666666666667f * src_data_56 + - 1.333333333333333f * src_data_66; - const float16_t t27 = -1.5f * src_data_17 + 3.0f * src_data_27 + 2.1666666666666667f * src_data_37 - - 4.333333333333333333f * src_data_47 - 0.66666666666666667f * src_data_57 + - 1.333333333333333f * src_data_67; - - const float16_t t30 = -0.3f * (src_data_10 + src_data_20) + 1.33333333333333f * (src_data_30 + src_data_40) - - 0.53333333333f * (src_data_50 + src_data_60); - const float16_t t31 = -0.3f * (src_data_11 + src_data_21) + 1.33333333333333f * (src_data_31 + src_data_41) - - 0.53333333333f * (src_data_51 + src_data_61); - const float16_t t32 = -0.3f * (src_data_12 + src_data_22) + 1.33333333333333f * (src_data_32 + src_data_42) - - 0.53333333333f * (src_data_52 + src_data_62); - const float16_t t33 = -0.3f * (src_data_13 + src_data_23) + 1.33333333333333f * (src_data_33 + src_data_43) - - 0.53333333333f * (src_data_53 + src_data_63); - const float16_t t34 = -0.3f * (src_data_14 + src_data_24) + 1.33333333333333f * (src_data_34 + src_data_44) - - 0.53333333333f * (src_data_54 + src_data_64); - const float16_t t35 = -0.3f * (src_data_15 + src_data_25) + 1.33333333333333f * (src_data_35 + src_data_45) - - 0.53333333333f * (src_data_55 + src_data_65); - const const float16_t t36 = -0.3f * (src_data_16 + src_data_26) + 1.33333333333333f * (src_data_36 + src_data_46) - - 0.53333333333f * (src_data_56 + src_data_66); - const const float16_t t37 = -0.3f * (src_data_17 + src_data_27) + 1.33333333333333f * (src_data_37 + src_data_47) - - 0.53333333333f * (src_data_57 + src_data_67); - - const float16_t t40 = 0.3f * (src_data_10 - src_data_20) + 1.33333333333333f * (src_data_40 - src_data_30) + - 0.53333333333f * (src_data_50 - src_data_60); - const float16_t t41 = 0.3f * (src_data_11 - src_data_21) + 1.33333333333333f * (src_data_41 - src_data_31) + - 0.53333333333f * (src_data_51 - src_data_61); - const float16_t t42 = 0.3f * (src_data_12 - src_data_22) + 1.33333333333333f * (src_data_42 - src_data_32) + - 0.53333333333f * (src_data_52 - src_data_62); - const float16_t t43 = 0.3f * (src_data_13 - src_data_23) + 1.33333333333333f * (src_data_43 - src_data_33) + - 0.53333333333f * (src_data_53 - src_data_63); - const float16_t t44 = 0.3f * (src_data_14 - src_data_24) + 1.33333333333333f * (src_data_44 - src_data_34) + - 0.53333333333f * (src_data_54 - src_data_64); - const float16_t t45 = 0.3f * (src_data_15 - src_data_25) + 1.33333333333333f * (src_data_45 - src_data_35) + - 0.53333333333f * (src_data_55 - src_data_65); - const float16_t t46 = 0.3f * (src_data_16 - src_data_26) + 1.33333333333333f * (src_data_46 - src_data_36) + - 0.53333333333f * (src_data_56 - src_data_66); - const float16_t t47 = 0.3f * (src_data_17 - src_data_27) + 1.33333333333333f * (src_data_47 - src_data_37) + - 0.53333333333f * (src_data_57 - src_data_67); - - const float16_t t50 = 0.0333333333f * src_data_10 + 0.02222222f * src_data_20 - 0.1666666666f * src_data_30 - - 0.1111111111f * src_data_40 + 0.1333333f * src_data_50 + 0.0888888f * src_data_60; - const float16_t t51 = 0.0333333333f * src_data_11 + 0.02222222f * src_data_21 - 0.1666666666f * src_data_31 - - 0.1111111111f * src_data_41 + 0.1333333f * src_data_51 + 0.0888888f * src_data_61; - const float16_t t52 = 0.0333333333f * src_data_12 + 0.02222222f * src_data_22 - 0.1666666666f * src_data_32 - - 0.1111111111f * src_data_42 + 0.1333333f * src_data_52 + 0.0888888f * src_data_62; - const float16_t t53 = 0.0333333333f * src_data_13 + 0.02222222f * src_data_23 - 0.1666666666f * src_data_33 - - 0.1111111111f * src_data_43 + 0.1333333f * src_data_53 + 0.0888888f * src_data_63; - const float16_t t54 = 0.0333333333f * src_data_14 + 0.02222222f * src_data_24 - 0.1666666666f * src_data_34 - - 0.1111111111f * src_data_44 + 0.1333333f * src_data_54 + 0.0888888f * src_data_64; - const float16_t t55 = 0.0333333333f * src_data_15 + 0.02222222f * src_data_25 - 0.1666666666f * src_data_35 - - 0.1111111111f * src_data_45 + 0.1333333f * src_data_55 + 0.0888888f * src_data_65; - const float16_t t56 = 0.0333333333f * src_data_16 + 0.02222222f * src_data_26 - 0.1666666666f * src_data_36 - - 0.1111111111f * src_data_46 + 0.1333333f * src_data_56 + 0.0888888f * src_data_66; - const float16_t t57 = 0.0333333333f * src_data_17 + 0.02222222f * src_data_27 - 0.1666666666f * src_data_37 - - 0.1111111111f * src_data_47 + 0.1333333f * src_data_57 + 0.0888888f * src_data_67; - - const float16_t t60 = -0.0333333333f * src_data_10 + 0.02222222f * src_data_20 + 0.1666666666f * src_data_30 - - 0.1111111111f * src_data_40 - 0.1333333f * src_data_50 + 0.0888888f * src_data_60; - const float16_t t61 = -0.0333333333f * src_data_11 + 0.02222222f * src_data_21 + 0.1666666666f * src_data_31 - - 0.1111111111f * src_data_41 - 0.1333333f * src_data_51 + 0.0888888f * src_data_61; - const float16_t t62 = -0.0333333333f * src_data_12 + 0.02222222f * src_data_22 + 0.1666666666f * src_data_32 - - 0.1111111111f * src_data_42 - 0.1333333f * src_data_52 + 0.0888888f * src_data_62; - const float16_t t63 = -0.0333333333f * src_data_13 + 0.02222222f * src_data_23 + 0.1666666666f * src_data_33 - - 0.1111111111f * src_data_43 - 0.1333333f * src_data_53 + 0.0888888f * src_data_63; - const float16_t t64 = -0.0333333333f * src_data_14 + 0.02222222f * src_data_24 + 0.1666666666f * src_data_34 - - 0.1111111111f * src_data_44 - 0.1333333f * src_data_54 + 0.0888888f * src_data_64; - const float16_t t65 = -0.0333333333f * src_data_15 + 0.02222222f * src_data_25 + 0.1666666666f * src_data_35 - - 0.1111111111f * src_data_45 - 0.1333333f * src_data_55 + 0.0888888f * src_data_65; - const float16_t t66 = -0.0333333333f * src_data_16 + 0.02222222f * src_data_26 + 0.1666666666f * src_data_36 - - 0.1111111111f * src_data_46 - 0.1333333f * src_data_56 + 0.0888888f * src_data_66; - const float16_t t67 = -0.0333333333f * src_data_17 + 0.02222222f * src_data_27 + 0.1666666666f * src_data_37 - - 0.1111111111f * src_data_47 - 0.1333333f * src_data_57 + 0.0888888f * src_data_67; - - const float16_t t70 = -0.5625f * src_data_10 + 3.0625f * src_data_30 - 3.5f * src_data_50 + src_data_70; - const float16_t t71 = -0.5625f * src_data_11 + 3.0625f * src_data_31 - 3.5f * src_data_51 + src_data_71; - const float16_t t72 = -0.5625f * src_data_12 + 3.0625f * src_data_32 - 3.5f * src_data_52 + src_data_72; - const float16_t t73 = -0.5625f * src_data_13 + 3.0625f * src_data_33 - 3.5f * src_data_53 + src_data_73; - const float16_t t74 = -0.5625f * src_data_14 + 3.0625f * src_data_34 - 3.5f * src_data_54 + src_data_74; - const float16_t t75 = -0.5625f * src_data_15 + 3.0625f * src_data_35 - 3.5f * src_data_55 + src_data_75; - const float16_t t76 = -0.5625f * src_data_16 + 3.0625f * src_data_36 - 3.5f * src_data_56 + src_data_76; - const float16_t t77 = -0.5625f * src_data_17 + 3.0625f * src_data_37 - 3.5f * src_data_57 + src_data_77; - - const float16_t m00 = - t00 - 5.444444444444444445125f * t02 + 6.222222222222222222223f * t04 - 1.77777777777777778f * t06; - const float16_t m01 = 1.5f * t01 + 3.0f * t02 - 2.1666666666666667f * t03 - 4.333333333333333333f * t04 + - 0.66666666666666667f * t05 + 1.333333333333333f * t06; - const float16_t m02 = -1.5f * t01 + 3.0f * t02 + 2.1666666666666667f * t03 - 4.333333333333333333f * t04 - - 0.66666666666666667f * t05 + 1.333333333333333f * t06; - const float16_t m03 = -0.3f * (t01 + t02) + 1.33333333333333f * (t03 + t04) - 0.53333333333f * (t05 + t06); - const float16_t m04 = 0.3f * (t01 - t02) + 1.33333333333333f * (t04 - t03) + 0.53333333333f * (t05 - t06); - const float16_t m05 = 0.0333333333f * t01 + 0.02222222f * t02 - 0.1666666666f * t03 - 0.1111111111f * t04 + - 0.1333333f * t05 + 0.0888888f * t06; - const float16_t m06 = -0.0333333333f * t01 + 0.02222222f * t02 + 0.1666666666f * t03 - 0.1111111111f * t04 - - 0.1333333f * t05 + 0.0888888f * t06; - const float16_t m07 = -0.5625f * t01 + 3.0625f * t03 - 3.5f * t05 + t07; - - float16_t m10 = t10 - 5.444444444444444445125f * t12 + 6.222222222222222222223f * t14 - 1.77777777777777778f * t16; - const float16_t m11 = 1.5f * t11 + 3.0f * t12 - 2.1666666666666667f * t13 - 4.333333333333333333f * t14 + - 0.66666666666666667f * t15 + 1.333333333333333f * t16; - const float16_t m12 = -1.5f * t11 + 3.0f * t12 + 2.1666666666666667f * t13 - 4.333333333333333333f * t14 - - 0.66666666666666667f * t15 + 1.333333333333333f * t16; - const float16_t m13 = -0.3f * (t11 + t12) + 1.33333333333333f * (t13 + t14) - 0.53333333333f * (t15 + t16); - const float16_t m14 = 0.3f * (t11 - t12) + 1.33333333333333f * (t14 - t13) + 0.53333333333f * (t15 - t16); - const float16_t m15 = 0.0333333333f * t11 + 0.02222222f * t12 - 0.1666666666f * t13 - 0.1111111111f * t14 + - 0.1333333f * t15 + 0.0888888f * t16; - const float16_t m16 = -0.0333333333f * t11 + 0.02222222f * t12 + 0.1666666666f * t13 - 0.1111111111f * t14 - - 0.1333333f * t15 + 0.0888888f * t16; - const float16_t m17 = -0.5625f * t11 + 3.0625f * t13 - 3.5f * t15 + t17; - - const float16_t m20 = - t20 - 5.444444444444444445125f * t22 + 6.222222222222222222223f * t24 - 1.77777777777777778f * t26; - const float16_t m21 = 1.5f * t21 + 3.0f * t22 - 2.1666666666666667f * t23 - 4.333333333333333333f * t24 + - 0.66666666666666667f * t25 + 1.333333333333333f * t26; - const float16_t m22 = -1.5f * t21 + 3.0f * t22 + 2.1666666666666667f * t23 - 4.333333333333333333f * t24 - - 0.66666666666666667f * t25 + 1.333333333333333f * t26; - const float16_t m23 = -0.3f * (t21 + t22) + 1.33333333333333f * (t23 + t24) - 0.53333333333f * (t25 + t26); - const float16_t m24 = 0.3f * (t21 - t22) + 1.33333333333333f * (t24 - t23) + 0.53333333333f * (t25 - t26); - const float16_t m25 = 0.0333333333f * t21 + 0.02222222f * t22 - 0.1666666666f * t23 - 0.1111111111f * t24 + - 0.1333333f * t25 + 0.0888888f * t26; - const float16_t m26 = -0.0333333333f * t21 + 0.02222222f * t22 + 0.1666666666f * t23 - 0.1111111111f * t24 - - 0.1333333f * t25 + 0.0888888f * t26; - const float16_t m27 = -0.5625f * t21 + 3.0625f * t23 - 3.5f * t25 + t27; - - float16_t m30 = t30 - 5.444444444444444445125f * t32 + 6.222222222222222222223f * t34 - 1.77777777777777778f * t36; - const float16_t m31 = 1.5f * t31 + 3.0f * t32 - 2.1666666666666667f * t33 - 4.333333333333333333f * t34 + - 0.66666666666666667f * t35 + 1.333333333333333f * t36; - const float16_t m32 = -1.5f * t31 + 3.0f * t32 + 2.1666666666666667f * t33 - 4.333333333333333333f * t34 - - 0.66666666666666667f * t35 + 1.333333333333333f * t36; - const float16_t m33 = -0.3f * (t31 + t32) + 1.33333333333333f * (t33 + t34) - 0.53333333333f * (t35 + t36); - const float16_t m34 = 0.3f * (t31 - t32) + 1.33333333333333f * (t34 - t33) + 0.53333333333f * (t35 - t36); - const float16_t m35 = 0.0333333333f * t31 + 0.02222222f * t32 - 0.1666666666f * t33 - 0.1111111111f * t34 + - 0.1333333f * t35 + 0.0888888f * t36; - const float16_t m36 = -0.0333333333f * t31 + 0.02222222f * t32 + 0.1666666666f * t33 - 0.1111111111f * t34 - - 0.1333333f * t35 + 0.0888888f * t36; - const float16_t m37 = -0.5625f * t31 + 3.0625f * t33 - 3.5f * t35 + t37; - - const float16_t m40 = - t40 - 5.444444444444444445125f * t42 + 6.222222222222222222223f * t44 - 1.77777777777777778f * t46; - const float16_t m41 = 1.5f * t41 + 3.0f * t42 - 2.1666666666666667f * t43 - 4.333333333333333333f * t44 + - 0.66666666666666667f * t45 + 1.333333333333333f * t46; - const float16_t m42 = -1.5f * t41 + 3.0f * t42 + 2.1666666666666667f * t43 - 4.333333333333333333f * t44 - - 0.66666666666666667f * t45 + 1.333333333333333f * t46; - const float16_t m43 = -0.3f * (t41 + t42) + 1.33333333333333f * (t43 + t44) - 0.53333333333f * (t45 + t46); - const float16_t m44 = 0.3f * (t41 - t42) + 1.33333333333333f * (t44 - t43) + 0.53333333333f * (t45 - t46); - const float16_t m45 = 0.0333333333f * t41 + 0.02222222f * t42 - 0.1666666666f * t43 - 0.1111111111f * t44 + - 0.1333333f * t45 + 0.0888888f * t46; - const float16_t m46 = -0.0333333333f * t41 + 0.02222222f * t42 + 0.1666666666f * t43 - 0.1111111111f * t44 - - 0.1333333f * t45 + 0.0888888f * t46; - const float16_t m47 = -0.5625f * t41 + 3.0625f * t43 - 3.5f * t45 + t47; - - float16_t m50 = t50 - 5.444444444444444445125f * t52 + 6.222222222222222222223f * t54 - 1.77777777777777778f * t56; - const float16_t m51 = 1.5f * t51 + 3.0f * t52 - 2.1666666666666667f * t53 - 4.333333333333333333f * t54 + - 0.66666666666666667f * t55 + 1.333333333333333f * t56; - const float16_t m52 = -1.5f * t51 + 3.0f * t52 + 2.1666666666666667f * t53 - 4.333333333333333333f * t54 - - 0.66666666666666667f * t55 + 1.333333333333333f * t56; - const float16_t m53 = -0.3f * (t51 + t52) + 1.33333333333333f * (t53 + t54) - 0.53333333333f * (t55 + t56); - const float16_t m54 = 0.3f * (t51 - t52) + 1.33333333333333f * (t54 - t53) + 0.53333333333f * (t55 - t56); - const float16_t m55 = 0.0333333333f * t51 + 0.02222222f * t52 - 0.1666666666f * t53 - 0.1111111111f * t54 + - 0.1333333f * t55 + 0.0888888f * t56; - const float16_t m56 = -0.0333333333f * t51 + 0.02222222f * t52 + 0.1666666666f * t53 - 0.1111111111f * t54 - - 0.1333333f * t55 + 0.0888888f * t56; - const float16_t m57 = -0.5625f * t51 + 3.0625f * t53 - 3.5f * t55 + t57; - - float16_t m60 = t60 - 5.444444444444444445125f * t62 + 6.222222222222222222223f * t64 - 1.77777777777777778f * t66; - const float16_t m61 = 1.5f * t61 + 3.0f * t62 - 2.1666666666666667f * t63 - 4.333333333333333333f * t64 + - 0.66666666666666667f * t65 + 1.333333333333333f * t66; - const float16_t m62 = -1.5f * t61 + 3.0f * t62 + 2.1666666666666667f * t63 - 4.333333333333333333f * t64 - - 0.66666666666666667f * t65 + 1.333333333333333f * t66; - const float16_t m63 = -0.3f * (t61 + t62) + 1.33333333333333f * (t63 + t64) - 0.53333333333f * (t65 + t66); - const float16_t m64 = 0.3f * (t61 - t62) + 1.33333333333333f * (t64 - t63) + 0.53333333333f * (t65 - t66); - const float16_t m65 = 0.0333333333f * t61 + 0.02222222f * t62 - 0.1666666666f * t63 - 0.1111111111f * t64 + - 0.1333333f * t65 + 0.0888888f * t66; - const float16_t m66 = -0.0333333333f * t61 + 0.02222222f * t62 + 0.1666666666f * t63 - 0.1111111111f * t64 - - 0.1333333f * t65 + 0.0888888f * t66; - const float16_t m67 = -0.5625f * t61 + 3.0625f * t63 - 3.5f * t65 + t67; - - float16_t m70 = t70 - 5.444444444444444445125f * t72 + 6.222222222222222222223f * t74 - 1.77777777777777778f * t76; - const float16_t m71 = 1.5f * t71 + 3.0f * t72 - 2.1666666666666667f * t73 - 4.333333333333333333f * t74 + - 0.66666666666666667f * t75 + 1.333333333333333f * t76; - const float16_t m72 = -1.5f * t71 + 3.0f * t72 + 2.1666666666666667f * t73 - 4.333333333333333333f * t74 - - 0.66666666666666667f * t75 + 1.333333333333333f * t76; - const float16_t m73 = -0.3f * (t71 + t72) + 1.33333333333333f * (t73 + t74) - 0.53333333333f * (t75 + t76); - const float16_t m74 = 0.3f * (t71 - t72) + 1.33333333333333f * (t74 - t73) + 0.53333333333f * (t75 - t76); - const float16_t m75 = 0.0333333333f * t71 + 0.02222222f * t72 - 0.1666666666f * t73 - 0.1111111111f * t74 + - 0.1333333f * t75 + 0.0888888f * t76; - const float16_t m76 = -0.0333333333f * t71 + 0.02222222f * t72 + 0.1666666666f * t73 - 0.1111111111f * t74 - - 0.1333333f * t75 + 0.0888888f * t76; - const float16_t m77 = -0.5625f * t71 + 3.0625f * t73 - 3.5f * t75 + t77; - - (dst_data + i)[0] = m00; - (dst_data + i + dst_step)[0] = m01; - (dst_data + i + 2 * dst_step)[0] = m02; - (dst_data + i + 3 * dst_step)[0] = m03; - (dst_data + i + 4 * dst_step)[0] = m04; - (dst_data + i + 5 * dst_step)[0] = m05; - (dst_data + i + 6 * dst_step)[0] = m06; - (dst_data + i + 7 * dst_step)[0] = m07; - - (dst_data + i + 8 * dst_step)[0] = m10; - (dst_data + i + 9 * dst_step)[0] = m11; - (dst_data + i + 10 * dst_step)[0] = m12; - (dst_data + i + 11 * dst_step)[0] = m13; - (dst_data + i + 12 * dst_step)[0] = m14; - (dst_data + i + 13 * dst_step)[0] = m15; - (dst_data + i + 14 * dst_step)[0] = m16; - (dst_data + i + 15 * dst_step)[0] = m17; - - (dst_data + i + 16 * dst_step)[0] = m20; - (dst_data + i + 17 * dst_step)[0] = m21; - (dst_data + i + 18 * dst_step)[0] = m22; - (dst_data + i + 19 * dst_step)[0] = m23; - (dst_data + i + 20 * dst_step)[0] = m24; - (dst_data + i + 21 * dst_step)[0] = m25; - (dst_data + i + 22 * dst_step)[0] = m26; - (dst_data + i + 23 * dst_step)[0] = m27; - - (dst_data + i + 24 * dst_step)[0] = m30; - (dst_data + i + 25 * dst_step)[0] = m31; - (dst_data + i + 26 * dst_step)[0] = m32; - (dst_data + i + 27 * dst_step)[0] = m33; - (dst_data + i + 28 * dst_step)[0] = m34; - (dst_data + i + 29 * dst_step)[0] = m35; - (dst_data + i + 30 * dst_step)[0] = m36; - (dst_data + i + 31 * dst_step)[0] = m37; - - (dst_data + i + 32 * dst_step)[0] = m40; - (dst_data + i + 33 * dst_step)[0] = m41; - (dst_data + i + 34 * dst_step)[0] = m42; - (dst_data + i + 35 * dst_step)[0] = m43; - (dst_data + i + 36 * dst_step)[0] = m44; - (dst_data + i + 37 * dst_step)[0] = m45; - (dst_data + i + 38 * dst_step)[0] = m46; - (dst_data + i + 39 * dst_step)[0] = m47; - - (dst_data + i + 40 * dst_step)[0] = m50; - (dst_data + i + 41 * dst_step)[0] = m51; - (dst_data + i + 42 * dst_step)[0] = m52; - (dst_data + i + 43 * dst_step)[0] = m53; - (dst_data + i + 44 * dst_step)[0] = m54; - (dst_data + i + 45 * dst_step)[0] = m55; - (dst_data + i + 46 * dst_step)[0] = m56; - (dst_data + i + 47 * dst_step)[0] = m57; - - (dst_data + i + 48 * dst_step)[0] = m60; - (dst_data + i + 49 * dst_step)[0] = m61; - (dst_data + i + 50 * dst_step)[0] = m62; - (dst_data + i + 51 * dst_step)[0] = m63; - (dst_data + i + 52 * dst_step)[0] = m64; - (dst_data + i + 53 * dst_step)[0] = m65; - (dst_data + i + 54 * dst_step)[0] = m66; - (dst_data + i + 55 * dst_step)[0] = m67; - - (dst_data + i + 56 * dst_step)[0] = m70; - (dst_data + i + 57 * dst_step)[0] = m71; - (dst_data + i + 58 * dst_step)[0] = m72; - (dst_data + i + 59 * dst_step)[0] = m73; - (dst_data + i + 60 * dst_step)[0] = m74; - (dst_data + i + 61 * dst_step)[0] = m75; - (dst_data + i + 62 * dst_step)[0] = m76; - (dst_data + i + 63 * dst_step)[0] = m77; - } -#endif + vst1_f16(dst_data, vget_low_f16(m00)); + vst1_f16(dst_data + 64, vget_high_f16(m00)); + vst1_f16(dst_data + 1 * dst_step, vget_low_f16(m01)); + vst1_f16(dst_data + 1 * dst_step + 64, vget_high_f16(m01)); + vst1_f16(dst_data + 2 * dst_step, vget_low_f16(m02)); + vst1_f16(dst_data + 2 * dst_step + 64, vget_high_f16(m02)); + vst1_f16(dst_data + 3 * dst_step, vget_low_f16(m03)); + vst1_f16(dst_data + 3 * dst_step + 64, vget_high_f16(m03)); + vst1_f16(dst_data + 4 * dst_step, vget_low_f16(m04)); + vst1_f16(dst_data + 4 * dst_step + 64, vget_high_f16(m04)); + vst1_f16(dst_data + 5 * dst_step, vget_low_f16(m05)); + vst1_f16(dst_data + 5 * dst_step + 64, vget_high_f16(m05)); + vst1_f16(dst_data + 6 * dst_step, vget_low_f16(m06)); + vst1_f16(dst_data + 6 * dst_step + 64, vget_high_f16(m06)); + vst1_f16(dst_data + 7 * dst_step, vget_low_f16(m07)); + vst1_f16(dst_data + 7 * dst_step + 64, vget_high_f16(m07)); + vst1_f16(dst_data + 8 * dst_step, vget_low_f16(m10)); + vst1_f16(dst_data + 8 * dst_step + 64, vget_high_f16(m10)); + vst1_f16(dst_data + 9 * dst_step, vget_low_f16(m11)); + vst1_f16(dst_data + 9 * dst_step + 64, vget_high_f16(m11)); + vst1_f16(dst_data + 10 * dst_step, vget_low_f16(m12)); + vst1_f16(dst_data + 10 * dst_step + 64, vget_high_f16(m12)); + vst1_f16(dst_data + 11 * dst_step, vget_low_f16(m13)); + vst1_f16(dst_data + 11 * dst_step + 64, vget_high_f16(m13)); + vst1_f16(dst_data + 12 * dst_step, vget_low_f16(m14)); + vst1_f16(dst_data + 12 * dst_step + 64, vget_high_f16(m14)); + vst1_f16(dst_data + 13 * dst_step, vget_low_f16(m15)); + vst1_f16(dst_data + 13 * dst_step + 64, vget_high_f16(m15)); + vst1_f16(dst_data + 14 * dst_step, vget_low_f16(m16)); + vst1_f16(dst_data + 14 * dst_step + 64, vget_high_f16(m16)); + vst1_f16(dst_data + 15 * dst_step, vget_low_f16(m17)); + vst1_f16(dst_data + 15 * dst_step + 64, vget_high_f16(m17)); + vst1_f16(dst_data + 16 * dst_step, vget_low_f16(m20)); + vst1_f16(dst_data + 16 * dst_step + 64, vget_high_f16(m20)); + vst1_f16(dst_data + 17 * dst_step, vget_low_f16(m21)); + vst1_f16(dst_data + 17 * dst_step + 64, vget_high_f16(m21)); + vst1_f16(dst_data + 18 * dst_step, vget_low_f16(m22)); + vst1_f16(dst_data + 18 * dst_step + 64, vget_high_f16(m22)); + vst1_f16(dst_data + 19 * dst_step, vget_low_f16(m23)); + vst1_f16(dst_data + 19 * dst_step + 64, vget_high_f16(m23)); + vst1_f16(dst_data + 20 * dst_step, vget_low_f16(m24)); + vst1_f16(dst_data + 20 * dst_step + 64, vget_high_f16(m24)); + vst1_f16(dst_data + 21 * dst_step, vget_low_f16(m25)); + vst1_f16(dst_data + 21 * dst_step + 64, vget_high_f16(m25)); + vst1_f16(dst_data + 22 * dst_step, vget_low_f16(m26)); + vst1_f16(dst_data + 22 * dst_step + 64, vget_high_f16(m26)); + vst1_f16(dst_data + 23 * dst_step, vget_low_f16(m27)); + vst1_f16(dst_data + 23 * dst_step + 64, vget_high_f16(m27)); + vst1_f16(dst_data + 24 * dst_step, vget_low_f16(m30)); + vst1_f16(dst_data + 24 * dst_step + 64, vget_high_f16(m30)); + vst1_f16(dst_data + 25 * dst_step, vget_low_f16(m31)); + vst1_f16(dst_data + 25 * dst_step + 64, vget_high_f16(m31)); + vst1_f16(dst_data + 26 * dst_step, vget_low_f16(m32)); + vst1_f16(dst_data + 26 * dst_step + 64, vget_high_f16(m32)); + vst1_f16(dst_data + 27 * dst_step, vget_low_f16(m33)); + vst1_f16(dst_data + 27 * dst_step + 64, vget_high_f16(m33)); + vst1_f16(dst_data + 28 * dst_step, vget_low_f16(m34)); + vst1_f16(dst_data + 28 * dst_step + 64, vget_high_f16(m34)); + vst1_f16(dst_data + 29 * dst_step, vget_low_f16(m35)); + vst1_f16(dst_data + 29 * dst_step + 64, vget_high_f16(m35)); + vst1_f16(dst_data + 30 * dst_step, vget_low_f16(m36)); + vst1_f16(dst_data + 30 * dst_step + 64, vget_high_f16(m36)); + vst1_f16(dst_data + 31 * dst_step, vget_low_f16(m37)); + vst1_f16(dst_data + 31 * dst_step + 64, vget_high_f16(m37)); + vst1_f16(dst_data + 32 * dst_step, vget_low_f16(m40)); + vst1_f16(dst_data + 32 * dst_step + 64, vget_high_f16(m40)); + vst1_f16(dst_data + 33 * dst_step, vget_low_f16(m41)); + vst1_f16(dst_data + 33 * dst_step + 64, vget_high_f16(m41)); + vst1_f16(dst_data + 34 * dst_step, vget_low_f16(m42)); + vst1_f16(dst_data + 34 * dst_step + 64, vget_high_f16(m42)); + vst1_f16(dst_data + 35 * dst_step, vget_low_f16(m43)); + vst1_f16(dst_data + 35 * dst_step + 64, vget_high_f16(m43)); + vst1_f16(dst_data + 36 * dst_step, vget_low_f16(m44)); + vst1_f16(dst_data + 36 * dst_step + 64, vget_high_f16(m44)); + vst1_f16(dst_data + 37 * dst_step, vget_low_f16(m45)); + vst1_f16(dst_data + 37 * dst_step + 64, vget_high_f16(m45)); + vst1_f16(dst_data + 38 * dst_step, vget_low_f16(m46)); + vst1_f16(dst_data + 38 * dst_step + 64, vget_high_f16(m46)); + vst1_f16(dst_data + 39 * dst_step, vget_low_f16(m47)); + vst1_f16(dst_data + 39 * dst_step + 64, vget_high_f16(m47)); + vst1_f16(dst_data + 40 * dst_step, vget_low_f16(m50)); + vst1_f16(dst_data + 40 * dst_step + 64, vget_high_f16(m50)); + vst1_f16(dst_data + 41 * dst_step, vget_low_f16(m51)); + vst1_f16(dst_data + 41 * dst_step + 64, vget_high_f16(m51)); + vst1_f16(dst_data + 42 * dst_step, vget_low_f16(m52)); + vst1_f16(dst_data + 42 * dst_step + 64, vget_high_f16(m52)); + vst1_f16(dst_data + 43 * dst_step, vget_low_f16(m53)); + vst1_f16(dst_data + 43 * dst_step + 64, vget_high_f16(m53)); + vst1_f16(dst_data + 44 * dst_step, vget_low_f16(m54)); + vst1_f16(dst_data + 44 * dst_step + 64, vget_high_f16(m54)); + vst1_f16(dst_data + 45 * dst_step, vget_low_f16(m55)); + vst1_f16(dst_data + 45 * dst_step + 64, vget_high_f16(m55)); + vst1_f16(dst_data + 46 * dst_step, vget_low_f16(m56)); + vst1_f16(dst_data + 46 * dst_step + 64, vget_high_f16(m56)); + vst1_f16(dst_data + 47 * dst_step, vget_low_f16(m57)); + vst1_f16(dst_data + 47 * dst_step + 64, vget_high_f16(m57)); + vst1_f16(dst_data + 48 * dst_step, vget_low_f16(m60)); + vst1_f16(dst_data + 48 * dst_step + 64, vget_high_f16(m60)); + vst1_f16(dst_data + 49 * dst_step, vget_low_f16(m61)); + vst1_f16(dst_data + 49 * dst_step + 64, vget_high_f16(m61)); + vst1_f16(dst_data + 50 * dst_step, vget_low_f16(m62)); + vst1_f16(dst_data + 50 * dst_step + 64, vget_high_f16(m62)); + vst1_f16(dst_data + 51 * dst_step, vget_low_f16(m63)); + vst1_f16(dst_data + 51 * dst_step + 64, vget_high_f16(m63)); + vst1_f16(dst_data + 52 * dst_step, vget_low_f16(m64)); + vst1_f16(dst_data + 52 * dst_step + 64, vget_high_f16(m64)); + vst1_f16(dst_data + 53 * dst_step, vget_low_f16(m65)); + vst1_f16(dst_data + 53 * dst_step + 64, vget_high_f16(m65)); + vst1_f16(dst_data + 54 * dst_step, vget_low_f16(m66)); + vst1_f16(dst_data + 54 * dst_step + 64, vget_high_f16(m66)); + vst1_f16(dst_data + 55 * dst_step, vget_low_f16(m67)); + vst1_f16(dst_data + 55 * dst_step + 64, vget_high_f16(m67)); + vst1_f16(dst_data + 56 * dst_step, vget_low_f16(m70)); + vst1_f16(dst_data + 56 * dst_step + 64, vget_high_f16(m70)); + vst1_f16(dst_data + 57 * dst_step, vget_low_f16(m71)); + vst1_f16(dst_data + 57 * dst_step + 64, vget_high_f16(m71)); + vst1_f16(dst_data + 58 * dst_step, vget_low_f16(m72)); + vst1_f16(dst_data + 58 * dst_step + 64, vget_high_f16(m72)); + vst1_f16(dst_data + 59 * dst_step, vget_low_f16(m73)); + vst1_f16(dst_data + 59 * dst_step + 64, vget_high_f16(m73)); + vst1_f16(dst_data + 60 * dst_step, vget_low_f16(m74)); + vst1_f16(dst_data + 60 * dst_step + 64, vget_high_f16(m74)); + vst1_f16(dst_data + 61 * dst_step, vget_low_f16(m75)); + vst1_f16(dst_data + 61 * dst_step + 64, vget_high_f16(m75)); + vst1_f16(dst_data + 62 * dst_step, vget_low_f16(m76)); + vst1_f16(dst_data + 62 * dst_step + 64, vget_high_f16(m76)); + vst1_f16(dst_data + 63 * dst_step, vget_low_f16(m77)); + vst1_f16(dst_data + 63 * dst_step + 64, vget_high_f16(m77)); } void OutputTransform4x2UnitFp16(const float16_t *src_data, float16_t *dst_data, const float16_t *bias_data,