libvmaf.h

Go to the documentation of this file.

 
#ifndef __VMAF_H__
#define __VMAF_H__
 
#include <stdint.h>
#include <stdio.h>
 
#include "libvmaf/model.h"
#include "libvmaf/picture.h"
#include "libvmaf/feature.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum VmafLogLevel {
    VMAF_LOG_LEVEL_NONE = 0,
    VMAF_LOG_LEVEL_ERROR,
    VMAF_LOG_LEVEL_WARNING,
    VMAF_LOG_LEVEL_INFO,
    VMAF_LOG_LEVEL_DEBUG,
};
 
enum VmafOutputFormat {
    VMAF_OUTPUT_FORMAT_NONE = 0,
    VMAF_OUTPUT_FORMAT_XML,
    VMAF_OUTPUT_FORMAT_JSON,
    VMAF_OUTPUT_FORMAT_CSV,
    VMAF_OUTPUT_FORMAT_SUB,
};
 
enum VmafPoolingMethod {
    VMAF_POOL_METHOD_UNKNOWN = 0,
    VMAF_POOL_METHOD_MIN,
    VMAF_POOL_METHOD_MAX,
    VMAF_POOL_METHOD_MEAN,
    VMAF_POOL_METHOD_HARMONIC_MEAN,
    VMAF_POOL_METHOD_NB
};

typedef struct VmafConfiguration {
    enum VmafLogLevel log_level;
    unsigned n_threads;
    unsigned n_subsample;
    uint64_t cpumask;
    uint64_t gpumask;
} VmafConfiguration;
 
typedef struct VmafContext VmafContext;

int vmaf_init(VmafContext **vmaf, VmafConfiguration cfg);

int vmaf_use_features_from_model(VmafContext *vmaf, VmafModel *model);

int vmaf_use_features_from_model_collection(VmafContext *vmaf,
                                            VmafModelCollection *model_collection);

int vmaf_use_feature(VmafContext *vmaf, const char *feature_name,
                     VmafFeatureDictionary *opts_dict);

int vmaf_import_feature_score(VmafContext *vmaf, const char *feature_name,
                              double value, unsigned index);

int vmaf_read_pictures(VmafContext *vmaf, VmafPicture *ref, VmafPicture *dist,
                       unsigned index);

int vmaf_score_at_index(VmafContext *vmaf, VmafModel *model, double *score,
                        unsigned index);

int vmaf_score_at_index_model_collection(VmafContext *vmaf,
                                         VmafModelCollection *model_collection,
                                         VmafModelCollectionScore *score,
                                         unsigned index);

int vmaf_feature_score_at_index(VmafContext *vmaf, const char *feature_name,
                                double *score, unsigned index);

int vmaf_score_pooled(VmafContext *vmaf, VmafModel *model,
                      enum VmafPoolingMethod pool_method, double *score,
                      unsigned index_low, unsigned index_high);

int vmaf_score_pooled_model_collection(VmafContext *vmaf,
                                       VmafModelCollection *model_collection,
                                       enum VmafPoolingMethod pool_method,
                                       VmafModelCollectionScore *score,
                                       unsigned index_low, unsigned index_high);

int vmaf_feature_score_pooled(VmafContext *vmaf, const char *feature_name,
                              enum VmafPoolingMethod pool_method, double *score,
                              unsigned index_low, unsigned index_high);

typedef struct VmafPictureConfiguration {
    struct {
        unsigned w, h;
        unsigned bpc;
        enum VmafPixelFormat pix_fmt;
    } pic_params;
    unsigned pic_cnt;
} VmafPictureConfiguration;

int vmaf_preallocate_pictures(VmafContext *vmaf,
                              VmafPictureConfiguration cfg);

int vmaf_fetch_preallocated_picture(VmafContext *vmaf, VmafPicture *pic);

int vmaf_close(VmafContext *vmaf);

int vmaf_write_output(VmafContext *vmaf, const char *output_path,
                      enum VmafOutputFormat fmt);

const char *vmaf_version(void);
 
#ifdef __cplusplus
}
#endif
 
#endif /* __VMAF_H__ */