git.sesse.net Git - ffmpeg/blob - libavfilter/dnn/dnn_backend_native_layer_depth2space.c

   1 /*
   2  * Copyright (c) 2018 Sergey Lavrushkin
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 /**
  22  * @file
  23  * DNN native backend implementation.
  24  */
  25
  26 #include "dnn_backend_native.h"
  27 #include "libavutil/avassert.h"
  28 #include "dnn_backend_native_layer_depth2space.h"
  29
  30 int dnn_load_layer_depth2space(Layer *layer, AVIOContext *model_file_context, int file_size)
  31 {
  32     DepthToSpaceParams *params;
  33     int dnn_size = 0;
  34     params = av_malloc(sizeof(*params));
  35     if (!params)
  36         return 0;
  37
  38     params->block_size = (int32_t)avio_rl32(model_file_context);
  39     dnn_size += 4;
  40     layer->input_operand_indexes[0] = (int32_t)avio_rl32(model_file_context);
  41     layer->output_operand_index = (int32_t)avio_rl32(model_file_context);
  42     dnn_size += 8;
  43     layer->params = params;
  44
  45     return dnn_size;
  46 }
  47
  48 int dnn_execute_layer_depth2space(DnnOperand *operands, const int32_t *input_operand_indexes,
  49                                   int32_t output_operand_index, const void *parameters)
  50 {
  51     float *output;
  52     const DepthToSpaceParams *params = (const DepthToSpaceParams *)parameters;
  53     int block_size = params->block_size;
  54     int32_t input_operand_index = input_operand_indexes[0];
  55     int number = operands[input_operand_index].dims[0];
  56     int height = operands[input_operand_index].dims[1];
  57     int width = operands[input_operand_index].dims[2];
  58     int channels = operands[input_operand_index].dims[3];
  59     const float *input = operands[input_operand_index].data;
  60
  61     int y, x, by, bx, ch;
  62     int new_channels = channels / (block_size * block_size);
  63     int output_linesize = width * channels;
  64     int by_linesize = output_linesize / block_size;
  65     int x_linesize = new_channels * block_size;
  66
  67     DnnOperand *output_operand = &operands[output_operand_index];
  68     output_operand->dims[0] = number;
  69     output_operand->dims[1] = height * block_size;
  70     output_operand->dims[2] = width * block_size;
  71     output_operand->dims[3] = new_channels;
  72     output_operand->data_type = operands[input_operand_index].data_type;
  73     output_operand->length = calculate_operand_data_length(output_operand);
  74     output_operand->data = av_realloc(output_operand->data, output_operand->length);
  75     if (!output_operand->data)
  76         return -1;
  77     output = output_operand->data;
  78
  79     for (y = 0; y < height; ++y){
  80         for (x = 0; x < width; ++x){
  81             for (by = 0; by < block_size; ++by){
  82                 for (bx = 0; bx < block_size; ++bx){
  83                     for (ch = 0; ch < new_channels; ++ch){
  84                         output[by * by_linesize + x * x_linesize + bx * new_channels + ch] = input[ch];
  85                     }
  86                     input += new_channels;
  87                 }
  88             }
  89         }
  90         output += output_linesize;
  91     }
  92     return 0;
  93 }