OBJS-$(CONFIG_DNN) += dnn/dnn_interface.o
OBJS-$(CONFIG_DNN) += dnn/dnn_backend_native.o
+OBJS-$(CONFIG_DNN) += dnn/dnn_backend_native_layers.o
OBJS-$(CONFIG_DNN) += dnn/dnn_backend_native_layer_pad.o
OBJS-$(CONFIG_DNN) += dnn/dnn_backend_native_layer_conv2d.o
OBJS-$(CONFIG_DNN) += dnn/dnn_backend_native_layer_depth2space.o
#include "dnn_backend_native_layer_conv2d.h"
#include "dnn_backend_native_layer_depth2space.h"
#include "dnn_backend_native_layer_maximum.h"
+#include "dnn_backend_native_layers.h"
static DNNReturnType set_input_output_native(void *model, DNNInputData *input, const char *input_name, const char **output_names, uint32_t nb_output)
{
{
ConvolutionalNetwork *network = (ConvolutionalNetwork *)model->model;
int32_t layer;
- ConvolutionalParams *conv_params;
- DepthToSpaceParams *depth_to_space_params;
- LayerPadParams *pad_params;
- DnnLayerMaximumParams *maximum_params;
uint32_t nb = FFMIN(nb_output, network->nb_output);
if (network->layers_num <= 0 || network->operands_num <= 0)
return DNN_ERROR;
for (layer = 0; layer < network->layers_num; ++layer){
- switch (network->layers[layer].type){
- case DLT_CONV2D:
- conv_params = (ConvolutionalParams *)network->layers[layer].params;
- convolve(network->operands, network->layers[layer].input_operand_indexes,
- network->layers[layer].output_operand_index, conv_params);
- break;
- case DLT_DEPTH_TO_SPACE:
- depth_to_space_params = (DepthToSpaceParams *)network->layers[layer].params;
- depth_to_space(network->operands, network->layers[layer].input_operand_indexes,
- network->layers[layer].output_operand_index, depth_to_space_params->block_size);
- break;
- case DLT_MIRROR_PAD:
- pad_params = (LayerPadParams *)network->layers[layer].params;
- dnn_execute_layer_pad(network->operands, network->layers[layer].input_operand_indexes,
- network->layers[layer].output_operand_index, pad_params);
- break;
- case DLT_MAXIMUM:
- maximum_params = (DnnLayerMaximumParams *)network->layers[layer].params;
- dnn_execute_layer_maximum(network->operands, network->layers[layer].input_operand_indexes,
- network->layers[layer].output_operand_index, maximum_params);
- break;
- case DLT_INPUT:
- return DNN_ERROR;
- }
+ DNNLayerType layer_type = network->layers[layer].type;
+ layer_funcs[layer_type](network->operands,
+ network->layers[layer].input_operand_indexes,
+ network->layers[layer].output_operand_index,
+ network->layers[layer].params);
}
for (uint32_t i = 0; i < nb; ++i) {
/**
* the enum value of DNNLayerType should not be changed,
* the same values are used in convert_from_tensorflow.py
+ * and, it is used to index the layer execution function pointer.
*/
typedef enum {
DLT_INPUT = 0,
DLT_CONV2D = 1,
DLT_DEPTH_TO_SPACE = 2,
DLT_MIRROR_PAD = 3,
- DLT_MAXIMUM = 4
+ DLT_MAXIMUM = 4,
+ DLT_COUNT
} DNNLayerType;
typedef enum {DOT_INPUT = 1, DOT_OUTPUT = 2, DOT_INTERMEDIATE = DOT_INPUT | DOT_INPUT} DNNOperandType;
#define CLAMP_TO_EDGE(x, w) ((x) < 0 ? 0 : ((x) >= (w) ? (w - 1) : (x)))
-int convolve(DnnOperand *operands, const int32_t *input_operand_indexes, int32_t output_operand_index, const ConvolutionalParams *conv_params)
+int dnn_execute_layer_conv2d(DnnOperand *operands, const int32_t *input_operand_indexes,
+ int32_t output_operand_index, const void *parameters)
{
float *output;
int32_t input_operand_index = input_operand_indexes[0];
int width = operands[input_operand_index].dims[2];
int channel = operands[input_operand_index].dims[3];
const float *input = operands[input_operand_index].data;
+ const ConvolutionalParams *conv_params = (const ConvolutionalParams *)parameters;
int radius = conv_params->kernel_size >> 1;
int src_linesize = width * conv_params->input_num;
float *biases;
} ConvolutionalParams;
-int convolve(DnnOperand *operands, const int32_t *input_operand_indexes, int32_t output_operand_index, const ConvolutionalParams *conv_params);
+int dnn_execute_layer_conv2d(DnnOperand *operands, const int32_t *input_operand_indexes,
+ int32_t output_operand_index, const void *parameters);
#endif
#include "libavutil/avassert.h"
#include "dnn_backend_native_layer_depth2space.h"
-int depth_to_space(DnnOperand *operands, const int32_t *input_operand_indexes, int32_t output_operand_index, int block_size)
+int dnn_execute_layer_depth2space(DnnOperand *operands, const int32_t *input_operand_indexes,
+ int32_t output_operand_index, const void *parameters)
{
float *output;
+ const DepthToSpaceParams *params = (const DepthToSpaceParams *)parameters;
+ int block_size = params->block_size;
int32_t input_operand_index = input_operand_indexes[0];
int number = operands[input_operand_index].dims[0];
int height = operands[input_operand_index].dims[1];
int block_size;
} DepthToSpaceParams;
-int depth_to_space(DnnOperand *operands, const int32_t *input_operand_indexes, int32_t output_operand_index, int block_size);
+int dnn_execute_layer_depth2space(DnnOperand *operands, const int32_t *input_operand_indexes,
+ int32_t output_operand_index, const void *parameters);
#endif
#include "libavutil/avassert.h"
#include "dnn_backend_native_layer_maximum.h"
-int dnn_execute_layer_maximum(DnnOperand *operands, const int32_t *input_operand_indexes, int32_t output_operand_index, const DnnLayerMaximumParams *params)
+int dnn_execute_layer_maximum(DnnOperand *operands, const int32_t *input_operand_indexes,
+ int32_t output_operand_index, const void *parameters)
{
const DnnOperand *input = &operands[input_operand_indexes[0]];
DnnOperand *output = &operands[output_operand_index];
+ const DnnLayerMaximumParams *params = (const DnnLayerMaximumParams *)parameters;
int dims_count;
const float *src;
float *dst;
}val;
} DnnLayerMaximumParams;
-int dnn_execute_layer_maximum(DnnOperand *operands, const int32_t *input_operand_indexes, int32_t output_operand_index, const DnnLayerMaximumParams *params);
+int dnn_execute_layer_maximum(DnnOperand *operands, const int32_t *input_operand_indexes,
+ int32_t output_operand_index, const void *parameters);
#endif
}
}
-int dnn_execute_layer_pad(DnnOperand *operands, const int32_t *input_operand_indexes, int32_t output_operand_index,
- const LayerPadParams *params)
+int dnn_execute_layer_pad(DnnOperand *operands, const int32_t *input_operand_indexes,
+ int32_t output_operand_index, const void *parameters)
{
int32_t before_paddings;
int32_t after_paddings;
float* output;
+ const LayerPadParams *params = (const LayerPadParams *)parameters;
// suppose format is <N, H, W, C>
int32_t input_operand_index = input_operand_indexes[0];
float constant_values;
} LayerPadParams;
-int dnn_execute_layer_pad(DnnOperand *operands, const int32_t *input_operand_indexes, int32_t output_operand_index,
- const LayerPadParams *params);
+int dnn_execute_layer_pad(DnnOperand *operands, const int32_t *input_operand_indexes,
+ int32_t output_operand_index, const void *parameters);
#endif
--- /dev/null
+/*
+ * Copyright (c) 2019 Guo Yejun
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <string.h>
+#include "dnn_backend_native_layers.h"
+#include "dnn_backend_native_layer_pad.h"
+#include "dnn_backend_native_layer_conv2d.h"
+#include "dnn_backend_native_layer_depth2space.h"
+#include "dnn_backend_native_layer_maximum.h"
+
+LAYER_EXEC_FUNC layer_funcs[DLT_COUNT] = {
+ NULL,
+ dnn_execute_layer_conv2d,
+ dnn_execute_layer_depth2space,
+ dnn_execute_layer_pad,
+ dnn_execute_layer_maximum,
+};
--- /dev/null
+/*
+ * Copyright (c) 2019 Guo Yejun
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVFILTER_DNN_DNN_BACKEND_NATIVE_LAYERS_H
+#define AVFILTER_DNN_DNN_BACKEND_NATIVE_LAYERS_H
+
+#include <stdint.h>
+#include "dnn_backend_native.h"
+
+typedef int (*LAYER_EXEC_FUNC)(DnnOperand *operands, const int32_t *input_operand_indexes,
+ int32_t output_operand_index, const void *parameters);
+
+extern LAYER_EXEC_FUNC layer_funcs[DLT_COUNT];
+
+#endif
operands[1].data = NULL;
input_indexes[0] = 0;
- convolve(operands, input_indexes, 1, ¶ms);
+ dnn_execute_layer_conv2d(operands, input_indexes, 1, ¶ms);
output = operands[1].data;
for (int i = 0; i < sizeof(expected_output) / sizeof(float); i++) {
operands[1].data = NULL;
input_indexes[0] = 0;
- convolve(operands, input_indexes, 1, ¶ms);
+ dnn_execute_layer_conv2d(operands, input_indexes, 1, ¶ms);
output = operands[1].data;
for (int i = 0; i < sizeof(expected_output) / sizeof(float); i++) {
print(list(output.flatten()))
*/
+ DepthToSpaceParams params;
DnnOperand operands[2];
int32_t input_indexes[1];
float input[1*5*3*4] = {
operands[1].data = NULL;
input_indexes[0] = 0;
- depth_to_space(operands, input_indexes, 1, 2);
+ params.block_size = 2;
+ dnn_execute_layer_depth2space(operands, input_indexes, 1, ¶ms);
output = operands[1].data;
for (int i = 0; i < sizeof(expected_output) / sizeof(float); i++) {