forked from mindspore-Ecosystem/mindspore
!4648 optimize fp16 conv3x3 input transform
Merge pull request !4648 from fuzhiye/tmp
This commit is contained in:
Gitee
commit
7c0db5e22b
|
|
@ -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<float16_t *>(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<float16_t *>(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<float16_t *>(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<float16_t *>(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<void *>(execute_input_), nhwc4_input_, in_batch, in_h * in_w, in_channel);
|
||||
PackNHWCToNHWC8Fp16(reinterpret_cast<void *>(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) {
|
||||
|
|
|
|||
|
|
@ -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<float16_t *>(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<float16_t *>(malloc(thread_count_ * C4NUM * input_unit_ * input_unit_ * sizeof(float16_t)));
|
||||
reinterpret_cast<float16_t *>(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) {
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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++) {
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
Loading…
Reference in New Issue