Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

libavfilter: Code style fixes for pointers in DNN module and sr filter.

Browse Source 
Signed-off-by: Pedro Arthur <bygrandao@gmail.com>
pull/293/merge
Sergey Lavrushkin 7 years ago committed by Pedro Arthur
parent 4eb63efbda
commit 9d87897ba8
9 changed files with 150 additions and 150 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 84
      libavfilter/dnn_backend_native.c
  2. 8
      libavfilter/dnn_backend_native.h
  3. 108
      libavfilter/dnn_backend_tf.c
  4. 8
      libavfilter/dnn_backend_tf.h
  5. 6
      libavfilter/dnn_espcn.h
  6. 4
      libavfilter/dnn_interface.c
  7. 16
      libavfilter/dnn_interface.h
  8. 6
      libavfilter/dnn_srcnn.h
  9. 60
      libavfilter/vf_sr.c

84
libavfilter/dnn_backend_native.c
Unescape View File

@ -34,15 +34,15 @@ typedef enum {RELU, TANH, SIGMOID} ActivationFunc;
typedef struct Layer{
LayerType type;
float* output;
void* params;
float *output;
void *params;
} Layer;
typedef struct ConvolutionalParams{
int32_t input_num, output_num, kernel_size;
ActivationFunc activation;
float* kernel;
float* biases;
float *kernel;
float *biases;
} ConvolutionalParams;
typedef struct InputParams{
@ -55,16 +55,16 @@ typedef struct DepthToSpaceParams{
// Represents simple feed-forward convolutional network.
typedef struct ConvolutionalNetwork{
Layer* layers;
Layer *layers;
int32_t layers_num;
} ConvolutionalNetwork;
static DNNReturnType set_input_output_native(void* model, DNNData* input, DNNData* output)
static DNNReturnType set_input_output_native(void *model, DNNData *input, DNNData *output)
{
ConvolutionalNetwork* network = (ConvolutionalNetwork*)model;
InputParams* input_params;
ConvolutionalParams* conv_params;
DepthToSpaceParams* depth_to_space_params;
ConvolutionalNetwork *network = (ConvolutionalNetwork *)model;
InputParams *input_params;
ConvolutionalParams *conv_params;
DepthToSpaceParams *depth_to_space_params;
int cur_width, cur_height, cur_channels;
int32_t layer;
@ -72,7 +72,7 @@ static DNNReturnType set_input_output_native(void* model, DNNData* input, DNNDat
return DNN_ERROR;
}
else{
input_params = (InputParams*)network->layers[0].params;
input_params = (InputParams *)network->layers[0].params;
input_params->width = cur_width = input->width;
input_params->height = cur_height = input->height;
input_params->channels = cur_channels = input->channels;
@ -88,14 +88,14 @@ static DNNReturnType set_input_output_native(void* model, DNNData* input, DNNDat
for (layer = 1; layer < network->layers_num; ++layer){
switch (network->layers[layer].type){
case CONV:
conv_params = (ConvolutionalParams*)network->layers[layer].params;
conv_params = (ConvolutionalParams *)network->layers[layer].params;
if (conv_params->input_num != cur_channels){
return DNN_ERROR;
}
cur_channels = conv_params->output_num;
break;
case DEPTH_TO_SPACE:
depth_to_space_params = (DepthToSpaceParams*)network->layers[layer].params;
depth_to_space_params = (DepthToSpaceParams *)network->layers[layer].params;
if (cur_channels % (depth_to_space_params->block_size * depth_to_space_params->block_size) != 0){
return DNN_ERROR;
}
@ -127,16 +127,16 @@ static DNNReturnType set_input_output_native(void* model, DNNData* input, DNNDat
// layers_num,layer_type,layer_parameterss,layer_type,layer_parameters...
// For CONV layer: activation_function, input_num, output_num, kernel_size, kernel, biases
// For DEPTH_TO_SPACE layer: block_size
DNNModel* ff_dnn_load_model_native(const char* model_filename)
DNNModel *ff_dnn_load_model_native(const char *model_filename)
{
DNNModel* model = NULL;
ConvolutionalNetwork* network = NULL;
AVIOContext* model_file_context;
DNNModel *model = NULL;
ConvolutionalNetwork *network = NULL;
AVIOContext *model_file_context;
int file_size, dnn_size, kernel_size, i;
int32_t layer;
LayerType layer_type;
ConvolutionalParams* conv_params;
DepthToSpaceParams* depth_to_space_params;
ConvolutionalParams *conv_params;
DepthToSpaceParams *depth_to_space_params;
model = av_malloc(sizeof(DNNModel));
if (!model){
@ -155,7 +155,7 @@ DNNModel* ff_dnn_load_model_native(const char* model_filename)
av_freep(&model);
return NULL;
}
model->model = (void*)network;
model->model = (void *)network;
network->layers_num = 1 + (int32_t)avio_rl32(model_file_context);
dnn_size = 4;
@ -251,10 +251,10 @@ DNNModel* ff_dnn_load_model_native(const char* model_filename)
return model;
}
static int set_up_conv_layer(Layer* layer, const float* kernel, const float* biases, ActivationFunc activation,
static int set_up_conv_layer(Layer *layer, const float *kernel, const float *biases, ActivationFunc activation,
int32_t input_num, int32_t output_num, int32_t size)
{
ConvolutionalParams* conv_params;
ConvolutionalParams *conv_params;
int kernel_size;
conv_params = av_malloc(sizeof(ConvolutionalParams));
@ -282,11 +282,11 @@ static int set_up_conv_layer(Layer* layer, const float* kernel, const float* bia
return DNN_SUCCESS;
}
DNNModel* ff_dnn_load_default_model_native(DNNDefaultModel model_type)
DNNModel *ff_dnn_load_default_model_native(DNNDefaultModel model_type)
{
DNNModel* model = NULL;
ConvolutionalNetwork* network = NULL;
DepthToSpaceParams* depth_to_space_params;
DNNModel *model = NULL;
ConvolutionalNetwork *network = NULL;
DepthToSpaceParams *depth_to_space_params;
int32_t layer;
model = av_malloc(sizeof(DNNModel));
@ -299,7 +299,7 @@ DNNModel* ff_dnn_load_default_model_native(DNNDefaultModel model_type)
av_freep(&model);
return NULL;
}
model->model = (void*)network;
model->model = (void *)network;
switch (model_type){
case DNN_SRCNN:
@ -365,7 +365,7 @@ DNNModel* ff_dnn_load_default_model_native(DNNDefaultModel model_type)
#define CLAMP_TO_EDGE(x, w) ((x) < 0 ? 0 : ((x) >= (w) ? (w - 1) : (x)))
static void convolve(const float* input, float* output, const ConvolutionalParams* conv_params, int width, int height)
static void convolve(const float *input, float *output, const ConvolutionalParams *conv_params, int width, int height)
{
int y, x, n_filter, ch, kernel_y, kernel_x;
int radius = conv_params->kernel_size >> 1;
@ -403,7 +403,7 @@ static void convolve(const float* input, float* output, const ConvolutionalParam
}
}
static void depth_to_space(const float* input, float* output, int block_size, int width, int height, int channels)
static void depth_to_space(const float *input, float *output, int block_size, int width, int height, int channels)
{
int y, x, by, bx, ch;
int new_channels = channels / (block_size * block_size);
@ -426,20 +426,20 @@ static void depth_to_space(const float* input, float* output, int block_size, in
}
}
DNNReturnType ff_dnn_execute_model_native(const DNNModel* model)
DNNReturnType ff_dnn_execute_model_native(const DNNModel *model)
{
ConvolutionalNetwork* network = (ConvolutionalNetwork*)model->model;
ConvolutionalNetwork *network = (ConvolutionalNetwork *)model->model;
int cur_width, cur_height, cur_channels;
int32_t layer;
InputParams* input_params;
ConvolutionalParams* conv_params;
DepthToSpaceParams* depth_to_space_params;
InputParams *input_params;
ConvolutionalParams *conv_params;
DepthToSpaceParams *depth_to_space_params;
if (network->layers_num <= 0 || network->layers[0].type != INPUT || !network->layers[0].output){
return DNN_ERROR;
}
else{
input_params = (InputParams*)network->layers[0].params;
input_params = (InputParams *)network->layers[0].params;
cur_width = input_params->width;
cur_height = input_params->height;
cur_channels = input_params->channels;
@ -451,12 +451,12 @@ DNNReturnType ff_dnn_execute_model_native(const DNNModel* model)
}
switch (network->layers[layer].type){
case CONV:
conv_params = (ConvolutionalParams*)network->layers[layer].params;
conv_params = (ConvolutionalParams *)network->layers[layer].params;
convolve(network->layers[layer - 1].output, network->layers[layer].output, conv_params, cur_width, cur_height);
cur_channels = conv_params->output_num;
break;
case DEPTH_TO_SPACE:
depth_to_space_params = (DepthToSpaceParams*)network->layers[layer].params;
depth_to_space_params = (DepthToSpaceParams *)network->layers[layer].params;
depth_to_space(network->layers[layer - 1].output, network->layers[layer].output,
depth_to_space_params->block_size, cur_width, cur_height, cur_channels);
cur_height *= depth_to_space_params->block_size;
@ -471,19 +471,19 @@ DNNReturnType ff_dnn_execute_model_native(const DNNModel* model)
return DNN_SUCCESS;
}
void ff_dnn_free_model_native(DNNModel** model)
void ff_dnn_free_model_native(DNNModel **model)
{
ConvolutionalNetwork* network;
ConvolutionalParams* conv_params;
ConvolutionalNetwork *network;
ConvolutionalParams *conv_params;
int32_t layer;
if (*model)
{
network = (ConvolutionalNetwork*)(*model)->model;
network = (ConvolutionalNetwork *)(*model)->model;
for (layer = 0; layer < network->layers_num; ++layer){
av_freep(&network->layers[layer].output);
if (network->layers[layer].type == CONV){
conv_params = (ConvolutionalParams*)network->layers[layer].params;
conv_params = (ConvolutionalParams *)network->layers[layer].params;
av_freep(&conv_params->kernel);
av_freep(&conv_params->biases);
}

8
libavfilter/dnn_backend_native.h
Unescape View File

@ -29,12 +29,12 @@
#include "dnn_interface.h"
DNNModel* ff_dnn_load_model_native(const char* model_filename);
DNNModel *ff_dnn_load_model_native(const char *model_filename);
DNNModel* ff_dnn_load_default_model_native(DNNDefaultModel model_type);
DNNModel *ff_dnn_load_default_model_native(DNNDefaultModel model_type);
DNNReturnType ff_dnn_execute_model_native(const DNNModel* model);
DNNReturnType ff_dnn_execute_model_native(const DNNModel *model);
void ff_dnn_free_model_native(DNNModel** model);
void ff_dnn_free_model_native(DNNModel **model);
#endif

108
libavfilter/dnn_backend_tf.c
Unescape View File

@ -31,24 +31,24 @@
#include <tensorflow/c/c_api.h>
typedef struct TFModel{
TF_Graph* graph;
TF_Session* session;
TF_Status* status;
TF_Graph *graph;
TF_Session *session;
TF_Status *status;
TF_Output input, output;
TF_Tensor* input_tensor;
DNNData* output_data;
TF_Tensor *input_tensor;
DNNData *output_data;
} TFModel;
static void free_buffer(void* data, size_t length)
static void free_buffer(void *data, size_t length)
{
av_freep(&data);
}
static TF_Buffer* read_graph(const char* model_filename)
static TF_Buffer *read_graph(const char *model_filename)
{
TF_Buffer* graph_buf;
unsigned char* graph_data = NULL;
AVIOContext* model_file_context;
TF_Buffer *graph_buf;
unsigned char *graph_data = NULL;
AVIOContext *model_file_context;
long size, bytes_read;
if (avio_open(&model_file_context, model_filename, AVIO_FLAG_READ) < 0){
@ -70,20 +70,20 @@ static TF_Buffer* read_graph(const char* model_filename)
}
graph_buf = TF_NewBuffer();
graph_buf->data = (void*)graph_data;
graph_buf->data = (void *)graph_data;
graph_buf->length = size;
graph_buf->data_deallocator = free_buffer;
return graph_buf;
}
static DNNReturnType set_input_output_tf(void* model, DNNData* input, DNNData* output)
static DNNReturnType set_input_output_tf(void *model, DNNData *input, DNNData *output)
{
TFModel* tf_model = (TFModel*)model;
TFModel *tf_model = (TFModel *)model;
int64_t input_dims[] = {1, input->height, input->width, input->channels};
TF_SessionOptions* sess_opts;
const TF_Operation* init_op = TF_GraphOperationByName(tf_model->graph, "init");
TF_Tensor* output_tensor;
TF_SessionOptions *sess_opts;
const TF_Operation *init_op = TF_GraphOperationByName(tf_model->graph, "init");
TF_Tensor *output_tensor;
// Input operation should be named 'x'
tf_model->input.oper = TF_GraphOperationByName(tf_model->graph, "x");
@ -99,7 +99,7 @@ static DNNReturnType set_input_output_tf(void* model, DNNData* input, DNNData* o
if (!tf_model->input_tensor){
return DNN_ERROR;
}
input->data = (float*)TF_TensorData(tf_model->input_tensor);
input->data = (float *)TF_TensorData(tf_model->input_tensor);
// Output operation should be named 'y'
tf_model->output.oper = TF_GraphOperationByName(tf_model->graph, "y");
@ -156,12 +156,12 @@ static DNNReturnType set_input_output_tf(void* model, DNNData* input, DNNData* o
return DNN_SUCCESS;
}
DNNModel* ff_dnn_load_model_tf(const char* model_filename)
DNNModel *ff_dnn_load_model_tf(const char *model_filename)
{
DNNModel* model = NULL;
TFModel* tf_model = NULL;
TF_Buffer* graph_def;
TF_ImportGraphDefOptions* graph_opts;
DNNModel *model = NULL;
TFModel *tf_model = NULL;
TF_Buffer *graph_def;
TF_ImportGraphDefOptions *graph_opts;
model = av_malloc(sizeof(DNNModel));
if (!model){
@ -197,25 +197,25 @@ DNNModel* ff_dnn_load_model_tf(const char* model_filename)
return NULL;
}
model->model = (void*)tf_model;
model->model = (void *)tf_model;
model->set_input_output = &set_input_output_tf;
return model;
}
static TF_Operation* add_pad_op(TFModel* tf_model, TF_Operation* input_op, int32_t pad)
static TF_Operation *add_pad_op(TFModel *tf_model, TF_Operation *input_op, int32_t pad)
{
TF_OperationDescription* op_desc;
TF_Operation* op;
TF_Tensor* tensor;
TF_OperationDescription *op_desc;
TF_Operation *op;
TF_Tensor *tensor;
TF_Output input;
int32_t* pads;
int32_t *pads;
int64_t pads_shape[] = {4, 2};
op_desc = TF_NewOperation(tf_model->graph, "Const", "pads");
TF_SetAttrType(op_desc, "dtype", TF_INT32);
tensor = TF_AllocateTensor(TF_INT32, pads_shape, 2, 4 * 2 * sizeof(int32_t));
pads = (int32_t*)TF_TensorData(tensor);
pads = (int32_t *)TF_TensorData(tensor);
pads[0] = 0; pads[1] = 0;
pads[2] = pad; pads[3] = pad;
pads[4] = pad; pads[5] = pad;
@ -246,11 +246,11 @@ static TF_Operation* add_pad_op(TFModel* tf_model, TF_Operation* input_op, int32
return op;
}
static TF_Operation* add_const_op(TFModel* tf_model, const float* values, const int64_t* dims, int dims_len, const char* name)
static TF_Operation *add_const_op(TFModel *tf_model, const float *values, const int64_t *dims, int dims_len, const char *name)
{
int dim;
TF_OperationDescription* op_desc;
TF_Tensor* tensor;
TF_OperationDescription *op_desc;
TF_Tensor *tensor;
size_t len;
op_desc = TF_NewOperation(tf_model->graph, "Const", name);
@ -269,18 +269,18 @@ static TF_Operation* add_const_op(TFModel* tf_model, const float* values, const
return TF_FinishOperation(op_desc, tf_model->status);
}
static TF_Operation* add_conv_layers(TFModel* tf_model, const float** consts, const int64_t** consts_dims,
const int* consts_dims_len, const char** activations,
TF_Operation* input_op, int layers_num)
static TF_Operation* add_conv_layers(TFModel *tf_model, const float **consts, const int64_t **consts_dims,
const int *consts_dims_len, const char **activations,
TF_Operation *input_op, int layers_num)
{
int i;
TF_OperationDescription* op_desc;
TF_Operation* op;
TF_Operation* transpose_op;
TF_OperationDescription *op_desc;
TF_Operation *op;
TF_Operation *transpose_op;
TF_Output input;
int64_t strides[] = {1, 1, 1, 1};
int32_t* transpose_perm;
TF_Tensor* tensor;
int32_t *transpose_perm;
TF_Tensor *tensor;
int64_t transpose_perm_shape[] = {4};
#define NAME_BUFF_SIZE 256
char name_buffer[NAME_BUFF_SIZE];
@ -288,7 +288,7 @@ static TF_Operation* add_conv_layers(TFModel* tf_model, const float** consts, co
op_desc = TF_NewOperation(tf_model->graph, "Const", "transpose_perm");
TF_SetAttrType(op_desc, "dtype", TF_INT32);
tensor = TF_AllocateTensor(TF_INT32, transpose_perm_shape, 1, 4 * sizeof(int32_t));
transpose_perm = (int32_t*)TF_TensorData(tensor);
transpose_perm = (int32_t *)TF_TensorData(tensor);
transpose_perm[0] = 1;
transpose_perm[1] = 2;
transpose_perm[2] = 3;
@ -369,13 +369,13 @@ static TF_Operation* add_conv_layers(TFModel* tf_model, const float** consts, co
return input_op;
}
DNNModel* ff_dnn_load_default_model_tf(DNNDefaultModel model_type)
DNNModel *ff_dnn_load_default_model_tf(DNNDefaultModel model_type)
{
DNNModel* model = NULL;
TFModel* tf_model = NULL;
TF_OperationDescription* op_desc;
TF_Operation* op;
TF_Operation* const_ops_buffer[6];
DNNModel *model = NULL;
TFModel *tf_model = NULL;
TF_OperationDescription *op_desc;
TF_Operation *op;
TF_Operation *const_ops_buffer[6];
TF_Output input;
int64_t input_shape[] = {1, -1, -1, 1};
@ -461,16 +461,16 @@ DNNModel* ff_dnn_load_default_model_tf(DNNDefaultModel model_type)
CLEANUP_ON_ERROR(tf_model, model);
}
model->model = (void*)tf_model;
model->model = (void *)tf_model;
model->set_input_output = &set_input_output_tf;
return model;
}
DNNReturnType ff_dnn_execute_model_tf(const DNNModel* model)
DNNReturnType ff_dnn_execute_model_tf(const DNNModel *model)
{
TFModel* tf_model = (TFModel*)model->model;
TF_Tensor* output_tensor;
TFModel *tf_model = (TFModel *)model->model;
TF_Tensor *output_tensor;
TF_SessionRun(tf_model->session, NULL,
&tf_model->input, &tf_model->input_tensor, 1,
@ -490,12 +490,12 @@ DNNReturnType ff_dnn_execute_model_tf(const DNNModel* model)
}
}
void ff_dnn_free_model_tf(DNNModel** model)
void ff_dnn_free_model_tf(DNNModel **model)
{
TFModel* tf_model;
TFModel *tf_model;
if (*model){
tf_model = (TFModel*)(*model)->model;
tf_model = (TFModel *)(*model)->model;
if (tf_model->graph){
TF_DeleteGraph(tf_model->graph);
}

8
libavfilter/dnn_backend_tf.h
Unescape View File

@ -29,12 +29,12 @@
#include "dnn_interface.h"
DNNModel* ff_dnn_load_model_tf(const char* model_filename);
DNNModel *ff_dnn_load_model_tf(const char *model_filename);
DNNModel* ff_dnn_load_default_model_tf(DNNDefaultModel model_type);
DNNModel *ff_dnn_load_default_model_tf(DNNDefaultModel model_type);
DNNReturnType ff_dnn_execute_model_tf(const DNNModel* model);
DNNReturnType ff_dnn_execute_model_tf(const DNNModel *model);
void ff_dnn_free_model_tf(DNNModel** model);
void ff_dnn_free_model_tf(DNNModel **model);
#endif

6
libavfilter/dnn_espcn.h
Unescape View File

@ -5398,7 +5398,7 @@ static const long int espcn_conv3_bias_dims[] = {
4
};
static const float* espcn_consts[] = {
static const float *espcn_consts[] = {
espcn_conv1_kernel,
espcn_conv1_bias,
espcn_conv2_kernel,
@ -5407,7 +5407,7 @@ static const float* espcn_consts[] = {
espcn_conv3_bias
};
static const long int* espcn_consts_dims[] = {
static const long int *espcn_consts_dims[] = {
espcn_conv1_kernel_dims,
espcn_conv1_bias_dims,
espcn_conv2_kernel_dims,
@ -5429,7 +5429,7 @@ static const char espcn_tanh[] = "Tanh";
static const char espcn_sigmoid[] = "Sigmoid";
static const char* espcn_activations[] = {
static const char *espcn_activations[] = {
espcn_tanh,
espcn_tanh,
espcn_sigmoid

4
libavfilter/dnn_interface.c
Unescape View File

@ -28,9 +28,9 @@
#include "dnn_backend_tf.h"
#include "libavutil/mem.h"
DNNModule* ff_get_dnn_module(DNNBackendType backend_type)
DNNModule *ff_get_dnn_module(DNNBackendType backend_type)
{
DNNModule* dnn_module;
DNNModule *dnn_module;
dnn_module = av_malloc(sizeof(DNNModule));
if(!dnn_module){

16
libavfilter/dnn_interface.h
Unescape View File

@ -33,31 +33,31 @@ typedef enum {DNN_NATIVE, DNN_TF} DNNBackendType;
typedef enum {DNN_SRCNN, DNN_ESPCN} DNNDefaultModel;
typedef struct DNNData{
float* data;
float *data;
int width, height, channels;
} DNNData;
typedef struct DNNModel{
// Stores model that can be different for different backends.
void* model;
void *model;
// Sets model input and output, while allocating additional memory for intermediate calculations.
// Should be called at least once before model execution.
DNNReturnType (*set_input_output)(void* model, DNNData* input, DNNData* output);
DNNReturnType (*set_input_output)(void *model, DNNData *input, DNNData *output);
} DNNModel;
// Stores pointers to functions for loading, executing, freeing DNN models for one of the backends.
typedef struct DNNModule{
// Loads model and parameters from given file. Returns NULL if it is not possible.
DNNModel* (*load_model)(const char* model_filename);
DNNModel *(*load_model)(const char *model_filename);
// Loads one of the default models
DNNModel* (*load_default_model)(DNNDefaultModel model_type);
DNNModel *(*load_default_model)(DNNDefaultModel model_type);
// Executes model with specified input and output. Returns DNN_ERROR otherwise.
DNNReturnType (*execute_model)(const DNNModel* model);
DNNReturnType (*execute_model)(const DNNModel *model);
// Frees memory allocated for model.
void (*free_model)(DNNModel** model);
void (*free_model)(DNNModel **model);
} DNNModule;
// Initializes DNNModule depending on chosen backend.
DNNModule* ff_get_dnn_module(DNNBackendType backend_type);
DNNModule *ff_get_dnn_module(DNNBackendType backend_type);
#endif

6
libavfilter/dnn_srcnn.h
Unescape View File

@ -2110,7 +2110,7 @@ static const long int srcnn_conv3_bias_dims[] = {
1
};
static const float* srcnn_consts[] = {
static const float *srcnn_consts[] = {
srcnn_conv1_kernel,
srcnn_conv1_bias,
srcnn_conv2_kernel,
@ -2119,7 +2119,7 @@ static const float* srcnn_consts[] = {
srcnn_conv3_bias
};
static const long int* srcnn_consts_dims[] = {
static const long int *srcnn_consts_dims[] = {
srcnn_conv1_kernel_dims,
srcnn_conv1_bias_dims,
srcnn_conv2_kernel_dims,
@ -2139,7 +2139,7 @@ static const int srcnn_consts_dims_len[] = {
static const char srcnn_relu[] = "Relu";
static const char* srcnn_activations[] = {
static const char *srcnn_activations[] = {
srcnn_relu,
srcnn_relu,
srcnn_relu

60
libavfilter/vf_sr.c
Unescape View File

@ -39,13 +39,13 @@ typedef struct SRContext {
const AVClass *class;
SRModel model_type;
char* model_filename;
char *model_filename;
DNNBackendType backend_type;
DNNModule* dnn_module;
DNNModel* model;
DNNModule *dnn_module;
DNNModel *model;
DNNData input, output;
int scale_factor;
struct SwsContext* sws_context;
struct SwsContext *sws_context;
int sws_slice_h;
} SRContext;
@ -67,9 +67,9 @@ static const AVOption sr_options[] = {
AVFILTER_DEFINE_CLASS(sr);
static av_cold int init(AVFilterContext* context)
static av_cold int init(AVFilterContext *context)
{
SRContext* sr_context = context->priv;
SRContext *sr_context = context->priv;
sr_context->dnn_module = ff_get_dnn_module(sr_context->backend_type);
if (!sr_context->dnn_module){
@ -98,12 +98,12 @@ static av_cold int init(AVFilterContext* context)
return 0;
}
static int query_formats(AVFilterContext* context)
static int query_formats(AVFilterContext *context)
{
const enum AVPixelFormat pixel_formats[] = {AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P,
AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_GRAY8,
AV_PIX_FMT_NONE};
AVFilterFormats* formats_list;
AVFilterFormats *formats_list;
formats_list = ff_make_format_list(pixel_formats);
if (!formats_list){
@ -113,11 +113,11 @@ static int query_formats(AVFilterContext* context)
return ff_set_common_formats(context, formats_list);
}
static int config_props(AVFilterLink* inlink)
static int config_props(AVFilterLink *inlink)
{
AVFilterContext* context = inlink->dst;
SRContext* sr_context = context->priv;
AVFilterLink* outlink = context->outputs[0];
AVFilterContext *context = inlink->dst;
SRContext *sr_context = context->priv;
AVFilterLink *outlink = context->outputs[0];
DNNReturnType result;
int sws_src_h, sws_src_w, sws_dst_h, sws_dst_w;
@ -202,18 +202,18 @@ static int config_props(AVFilterLink* inlink)
}
typedef struct ThreadData{
uint8_t* data;
uint8_t *data;
int data_linesize, height, width;
} ThreadData;
static int uint8_to_float(AVFilterContext* context, void* arg, int jobnr, int nb_jobs)
static int uint8_to_float(AVFilterContext *context, void *arg, int jobnr, int nb_jobs)
{
SRContext* sr_context = context->priv;
const ThreadData* td = arg;
SRContext *sr_context = context->priv;
const ThreadData *td = arg;
const int slice_start = (td->height * jobnr ) / nb_jobs;
const int slice_end = (td->height * (jobnr + 1)) / nb_jobs;
const uint8_t* src = td->data + slice_start * td->data_linesize;
float* dst = sr_context->input.data + slice_start * td->width;
const uint8_t *src = td->data + slice_start * td->data_linesize;
float *dst = sr_context->input.data + slice_start * td->width;
int y, x;
for (y = slice_start; y < slice_end; ++y){
@ -227,14 +227,14 @@ static int uint8_to_float(AVFilterContext* context, void* arg, int jobnr, int nb
return 0;
}
static int float_to_uint8(AVFilterContext* context, void* arg, int jobnr, int nb_jobs)
static int float_to_uint8(AVFilterContext *context, void *arg, int jobnr, int nb_jobs)
{
SRContext* sr_context = context->priv;
const ThreadData* td = arg;
SRContext *sr_context = context->priv;
const ThreadData *td = arg;
const int slice_start = (td->height * jobnr ) / nb_jobs;
const int slice_end = (td->height * (jobnr + 1)) / nb_jobs;
const float* src = sr_context->output.data + slice_start * td->width;
uint8_t* dst = td->data + slice_start * td->data_linesize;
const float *src = sr_context->output.data + slice_start * td->width;
uint8_t *dst = td->data + slice_start * td->data_linesize;
int y, x;
for (y = slice_start; y < slice_end; ++y){
@ -248,12 +248,12 @@ static int float_to_uint8(AVFilterContext* context, void* arg, int jobnr, int nb
return 0;
}
static int filter_frame(AVFilterLink* inlink, AVFrame* in)
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
{
AVFilterContext* context = inlink->dst;
SRContext* sr_context = context->priv;
AVFilterLink* outlink = context->outputs[0];
AVFrame* out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
AVFilterContext *context = inlink->dst;
SRContext *sr_context = context->priv;
AVFilterLink *outlink = context->outputs[0];
AVFrame *out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
ThreadData td;
int nb_threads;
DNNReturnType dnn_result;
@ -307,9 +307,9 @@ static int filter_frame(AVFilterLink* inlink, AVFrame* in)
return ff_filter_frame(outlink, out);
}
static av_cold void uninit(AVFilterContext* context)
static av_cold void uninit(AVFilterContext *context)
{
SRContext* sr_context = context->priv;
SRContext *sr_context = context->priv;
if (sr_context->dnn_module){
(sr_context->dnn_module->free_model)(&sr_context->model);

Write Preview
Loading…
Cancel
Save