[FFmpeg-cvslog] dnn/native: rename struct ConvolutionalNetwork to NativeModel
Ting Fu
git at videolan.org
Fri Aug 21 05:45:59 EEST 2020
ffmpeg | branch: master | Ting Fu <ting.fu at intel.com> | Wed Aug 19 21:43:13 2020 +0800| [a6e830ae7fb6d5204e3827ef5180b7ce32586072] | committer: Guo, Yejun
dnn/native: rename struct ConvolutionalNetwork to NativeModel
Signed-off-by: Ting Fu <ting.fu at intel.com>
Reviewed-by: Guo, Yejun <yejun.guo at intel.com>
> http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=a6e830ae7fb6d5204e3827ef5180b7ce32586072
---
libavfilter/dnn/dnn_backend_native.c | 112 +++++++++++++++++------------------
libavfilter/dnn/dnn_backend_native.h | 4 +-
libavfilter/dnn/dnn_backend_tf.c | 24 ++++----
3 files changed, 70 insertions(+), 70 deletions(-)
diff --git a/libavfilter/dnn/dnn_backend_native.c b/libavfilter/dnn/dnn_backend_native.c
index adc652a2c4..0be9c0b53c 100644
--- a/libavfilter/dnn/dnn_backend_native.c
+++ b/libavfilter/dnn/dnn_backend_native.c
@@ -30,10 +30,10 @@
static DNNReturnType get_input_native(void *model, DNNData *input, const char *input_name)
{
- ConvolutionalNetwork *network = (ConvolutionalNetwork *)model;
+ NativeModel *native_model = (NativeModel *)model;
- for (int i = 0; i < network->operands_num; ++i) {
- DnnOperand *oprd = &network->operands[i];
+ for (int i = 0; i < native_model->operands_num; ++i) {
+ DnnOperand *oprd = &native_model->operands[i];
if (strcmp(oprd->name, input_name) == 0) {
if (oprd->type != DOT_INPUT)
return DNN_ERROR;
@@ -52,15 +52,15 @@ static DNNReturnType get_input_native(void *model, DNNData *input, const char *i
static DNNReturnType set_input_output_native(void *model, DNNData *input, const char *input_name, const char **output_names, uint32_t nb_output)
{
- ConvolutionalNetwork *network = (ConvolutionalNetwork *)model;
+ NativeModel *native_model = (NativeModel *)model;
DnnOperand *oprd = NULL;
- if (network->layers_num <= 0 || network->operands_num <= 0)
+ if (native_model->layers_num <= 0 || native_model->operands_num <= 0)
return DNN_ERROR;
/* inputs */
- for (int i = 0; i < network->operands_num; ++i) {
- oprd = &network->operands[i];
+ for (int i = 0; i < native_model->operands_num; ++i) {
+ oprd = &native_model->operands[i];
if (strcmp(oprd->name, input_name) == 0) {
if (oprd->type != DOT_INPUT)
return DNN_ERROR;
@@ -88,24 +88,24 @@ static DNNReturnType set_input_output_native(void *model, DNNData *input, const
input->data = oprd->data;
/* outputs */
- network->nb_output = 0;
- av_freep(&network->output_indexes);
- network->output_indexes = av_mallocz_array(nb_output, sizeof(*network->output_indexes));
- if (!network->output_indexes)
+ native_model->nb_output = 0;
+ av_freep(&native_model->output_indexes);
+ native_model->output_indexes = av_mallocz_array(nb_output, sizeof(*native_model->output_indexes));
+ if (!native_model->output_indexes)
return DNN_ERROR;
for (uint32_t i = 0; i < nb_output; ++i) {
const char *output_name = output_names[i];
- for (int j = 0; j < network->operands_num; ++j) {
- oprd = &network->operands[j];
+ for (int j = 0; j < native_model->operands_num; ++j) {
+ oprd = &native_model->operands[j];
if (strcmp(oprd->name, output_name) == 0) {
- network->output_indexes[network->nb_output++] = j;
+ native_model->output_indexes[native_model->nb_output++] = j;
break;
}
}
}
- if (network->nb_output != nb_output)
+ if (native_model->nb_output != nb_output)
return DNN_ERROR;
return DNN_SUCCESS;
@@ -122,7 +122,7 @@ DNNModel *ff_dnn_load_model_native(const char *model_filename, const char *optio
char *buf;
size_t size;
int version, header_size, major_version_expected = 1;
- ConvolutionalNetwork *network = NULL;
+ NativeModel *native_model = NULL;
AVIOContext *model_file_context;
int file_size, dnn_size, parsed_size;
int32_t layer;
@@ -167,29 +167,29 @@ DNNModel *ff_dnn_load_model_native(const char *model_filename, const char *optio
dnn_size += 4;
header_size = dnn_size;
- network = av_mallocz(sizeof(ConvolutionalNetwork));
- if (!network){
+ native_model = av_mallocz(sizeof(NativeModel));
+ if (!native_model){
goto fail;
}
- model->model = (void *)network;
+ model->model = (void *)native_model;
avio_seek(model_file_context, file_size - 8, SEEK_SET);
- network->layers_num = (int32_t)avio_rl32(model_file_context);
- network->operands_num = (int32_t)avio_rl32(model_file_context);
+ native_model->layers_num = (int32_t)avio_rl32(model_file_context);
+ native_model->operands_num = (int32_t)avio_rl32(model_file_context);
dnn_size += 8;
avio_seek(model_file_context, header_size, SEEK_SET);
- network->layers = av_mallocz(network->layers_num * sizeof(Layer));
- if (!network->layers){
+ native_model->layers = av_mallocz(native_model->layers_num * sizeof(Layer));
+ if (!native_model->layers){
goto fail;
}
- network->operands = av_mallocz(network->operands_num * sizeof(DnnOperand));
- if (!network->operands){
+ native_model->operands = av_mallocz(native_model->operands_num * sizeof(DnnOperand));
+ if (!native_model->operands){
goto fail;
}
- for (layer = 0; layer < network->layers_num; ++layer){
+ for (layer = 0; layer < native_model->layers_num; ++layer){
layer_type = (int32_t)avio_rl32(model_file_context);
dnn_size += 4;
@@ -197,25 +197,25 @@ DNNModel *ff_dnn_load_model_native(const char *model_filename, const char *optio
goto fail;
}
- network->layers[layer].type = layer_type;
- parsed_size = layer_funcs[layer_type].pf_load(&network->layers[layer], model_file_context, file_size, network->operands_num);
+ native_model->layers[layer].type = layer_type;
+ parsed_size = layer_funcs[layer_type].pf_load(&native_model->layers[layer], model_file_context, file_size, native_model->operands_num);
if (!parsed_size) {
goto fail;
}
dnn_size += parsed_size;
}
- for (int32_t i = 0; i < network->operands_num; ++i){
+ for (int32_t i = 0; i < native_model->operands_num; ++i){
DnnOperand *oprd;
int32_t name_len;
int32_t operand_index = (int32_t)avio_rl32(model_file_context);
dnn_size += 4;
- if (operand_index >= network->operands_num) {
+ if (operand_index >= native_model->operands_num) {
goto fail;
}
- oprd = &network->operands[operand_index];
+ oprd = &native_model->operands[operand_index];
name_len = (int32_t)avio_rl32(model_file_context);
dnn_size += 4;
@@ -257,25 +257,25 @@ fail:
DNNReturnType ff_dnn_execute_model_native(const DNNModel *model, DNNData *outputs, uint32_t nb_output)
{
- ConvolutionalNetwork *network = (ConvolutionalNetwork *)model->model;
+ NativeModel *native_model = (NativeModel *)model->model;
int32_t layer;
- uint32_t nb = FFMIN(nb_output, network->nb_output);
+ uint32_t nb = FFMIN(nb_output, native_model->nb_output);
- if (network->layers_num <= 0 || network->operands_num <= 0)
+ if (native_model->layers_num <= 0 || native_model->operands_num <= 0)
return DNN_ERROR;
- if (!network->operands[0].data)
+ if (!native_model->operands[0].data)
return DNN_ERROR;
- for (layer = 0; layer < network->layers_num; ++layer){
- DNNLayerType layer_type = network->layers[layer].type;
- layer_funcs[layer_type].pf_exec(network->operands,
- network->layers[layer].input_operand_indexes,
- network->layers[layer].output_operand_index,
- network->layers[layer].params);
+ for (layer = 0; layer < native_model->layers_num; ++layer){
+ DNNLayerType layer_type = native_model->layers[layer].type;
+ layer_funcs[layer_type].pf_exec(native_model->operands,
+ native_model->layers[layer].input_operand_indexes,
+ native_model->layers[layer].output_operand_index,
+ native_model->layers[layer].params);
}
for (uint32_t i = 0; i < nb; ++i) {
- DnnOperand *oprd = &network->operands[network->output_indexes[i]];
+ DnnOperand *oprd = &native_model->operands[native_model->output_indexes[i]];
outputs[i].data = oprd->data;
outputs[i].height = oprd->dims[1];
outputs[i].width = oprd->dims[2];
@@ -309,34 +309,34 @@ int32_t calculate_operand_data_length(const DnnOperand* oprd)
void ff_dnn_free_model_native(DNNModel **model)
{
- ConvolutionalNetwork *network;
+ NativeModel *native_model;
ConvolutionalParams *conv_params;
int32_t layer;
if (*model)
{
if ((*model)->model) {
- network = (ConvolutionalNetwork *)(*model)->model;
- if (network->layers) {
- for (layer = 0; layer < network->layers_num; ++layer){
- if (network->layers[layer].type == DLT_CONV2D){
- conv_params = (ConvolutionalParams *)network->layers[layer].params;
+ native_model = (NativeModel *)(*model)->model;
+ if (native_model->layers) {
+ for (layer = 0; layer < native_model->layers_num; ++layer){
+ if (native_model->layers[layer].type == DLT_CONV2D){
+ conv_params = (ConvolutionalParams *)native_model->layers[layer].params;
av_freep(&conv_params->kernel);
av_freep(&conv_params->biases);
}
- av_freep(&network->layers[layer].params);
+ av_freep(&native_model->layers[layer].params);
}
- av_freep(&network->layers);
+ av_freep(&native_model->layers);
}
- if (network->operands) {
- for (uint32_t operand = 0; operand < network->operands_num; ++operand)
- av_freep(&network->operands[operand].data);
- av_freep(&network->operands);
+ if (native_model->operands) {
+ for (uint32_t operand = 0; operand < native_model->operands_num; ++operand)
+ av_freep(&native_model->operands[operand].data);
+ av_freep(&native_model->operands);
}
- av_freep(&network->output_indexes);
- av_freep(&network);
+ av_freep(&native_model->output_indexes);
+ av_freep(&native_model);
}
av_freep(model);
}
diff --git a/libavfilter/dnn/dnn_backend_native.h b/libavfilter/dnn/dnn_backend_native.h
index b455e44992..228d5b742b 100644
--- a/libavfilter/dnn/dnn_backend_native.h
+++ b/libavfilter/dnn/dnn_backend_native.h
@@ -107,14 +107,14 @@ typedef struct InputParams{
} InputParams;
// Represents simple feed-forward convolutional network.
-typedef struct ConvolutionalNetwork{
+typedef struct NativeModel{
Layer *layers;
int32_t layers_num;
DnnOperand *operands;
int32_t operands_num;
int32_t *output_indexes;
uint32_t nb_output;
-} ConvolutionalNetwork;
+} NativeModel;
DNNModel *ff_dnn_load_model_native(const char *model_filename, const char *options);
diff --git a/libavfilter/dnn/dnn_backend_tf.c b/libavfilter/dnn/dnn_backend_tf.c
index 9099d2b812..9d079aa92e 100644
--- a/libavfilter/dnn/dnn_backend_tf.c
+++ b/libavfilter/dnn/dnn_backend_tf.c
@@ -487,15 +487,15 @@ static DNNReturnType load_native_model(TFModel *tf_model, const char *model_file
int64_t transpose_perm_shape[] = {4};
int64_t input_shape[] = {1, -1, -1, -1};
DNNReturnType layer_add_res;
- DNNModel *native_model = NULL;
- ConvolutionalNetwork *conv_network;
+ DNNModel *model = NULL;
+ NativeModel *native_model;
- native_model = ff_dnn_load_model_native(model_filename, NULL);
- if (!native_model){
+ model = ff_dnn_load_model_native(model_filename, NULL);
+ if (!model){
return DNN_ERROR;
}
- conv_network = (ConvolutionalNetwork *)native_model->model;
+ native_model = (NativeModel *)model->model;
tf_model->graph = TF_NewGraph();
tf_model->status = TF_NewStatus();
@@ -528,26 +528,26 @@ static DNNReturnType load_native_model(TFModel *tf_model, const char *model_file
}
transpose_op = TF_FinishOperation(op_desc, tf_model->status);
- for (layer = 0; layer < conv_network->layers_num; ++layer){
- switch (conv_network->layers[layer].type){
+ for (layer = 0; layer < native_model->layers_num; ++layer){
+ switch (native_model->layers[layer].type){
case DLT_INPUT:
layer_add_res = DNN_SUCCESS;
break;
case DLT_CONV2D:
layer_add_res = add_conv_layer(tf_model, transpose_op, &op,
- (ConvolutionalParams *)conv_network->layers[layer].params, layer);
+ (ConvolutionalParams *)native_model->layers[layer].params, layer);
break;
case DLT_DEPTH_TO_SPACE:
layer_add_res = add_depth_to_space_layer(tf_model, &op,
- (DepthToSpaceParams *)conv_network->layers[layer].params, layer);
+ (DepthToSpaceParams *)native_model->layers[layer].params, layer);
break;
case DLT_MIRROR_PAD:
layer_add_res = add_pad_layer(tf_model, &op,
- (LayerPadParams *)conv_network->layers[layer].params, layer);
+ (LayerPadParams *)native_model->layers[layer].params, layer);
break;
case DLT_MAXIMUM:
layer_add_res = add_maximum_layer(tf_model, &op,
- (DnnLayerMaximumParams *)conv_network->layers[layer].params, layer);
+ (DnnLayerMaximumParams *)native_model->layers[layer].params, layer);
break;
default:
CLEANUP_ON_ERROR(tf_model);
@@ -567,7 +567,7 @@ static DNNReturnType load_native_model(TFModel *tf_model, const char *model_file
CLEANUP_ON_ERROR(tf_model);
}
- ff_dnn_free_model_native(&native_model);
+ ff_dnn_free_model_native(&model);
return DNN_SUCCESS;
}
More information about the ffmpeg-cvslog
mailing list