va_vpp.h

Go to the documentation of this file.

/*
 * Copyright (c) 2007-2011 Intel Corporation. All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sub license, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial portions
 * of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
 * IN NO EVENT SHALL INTEL AND/OR ITS SUPPLIERS BE LIABLE FOR
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#ifndef VA_VPP_H
#define VA_VPP_H

#ifdef __cplusplus
extern "C" {
#endif

typedef enum _VAProcFilterType {
    VAProcFilterNone = 0,
    VAProcFilterNoiseReduction,
    VAProcFilterDeinterlacing,
    VAProcFilterSharpening,
    VAProcFilterColorBalance,
    VAProcFilterSkinToneEnhancement,
    VAProcFilterTotalColorCorrection,
    VAProcFilterHVSNoiseReduction,
    VAProcFilterHighDynamicRangeToneMapping,
    VAProcFilter3DLUT,
    VAProcFilterCount
} VAProcFilterType;

typedef enum _VAProcDeinterlacingType {
    VAProcDeinterlacingNone = 0,
    VAProcDeinterlacingBob,
    VAProcDeinterlacingWeave,
    VAProcDeinterlacingMotionAdaptive,
    VAProcDeinterlacingMotionCompensated,
    VAProcDeinterlacingCount
} VAProcDeinterlacingType;

typedef enum _VAProcColorBalanceType {
    VAProcColorBalanceNone = 0,
    VAProcColorBalanceHue,
    VAProcColorBalanceSaturation,
    VAProcColorBalanceBrightness,
    VAProcColorBalanceContrast,
    VAProcColorBalanceAutoSaturation,
    VAProcColorBalanceAutoBrightness,
    VAProcColorBalanceAutoContrast,
    VAProcColorBalanceCount
} VAProcColorBalanceType;

typedef enum _VAProcColorStandardType {
    VAProcColorStandardNone = 0,
    VAProcColorStandardBT601,
    VAProcColorStandardBT709,
    VAProcColorStandardBT470M,
    VAProcColorStandardBT470BG,
    VAProcColorStandardSMPTE170M,
    VAProcColorStandardSMPTE240M,
    VAProcColorStandardGenericFilm,
    VAProcColorStandardSRGB,
    VAProcColorStandardSTRGB,
    VAProcColorStandardXVYCC601,
    VAProcColorStandardXVYCC709,
    VAProcColorStandardBT2020,
    VAProcColorStandardExplicit,
    VAProcColorStandardCount
} VAProcColorStandardType;

typedef enum _VAProcTotalColorCorrectionType {
    VAProcTotalColorCorrectionNone = 0,
    VAProcTotalColorCorrectionRed,
    VAProcTotalColorCorrectionGreen,
    VAProcTotalColorCorrectionBlue,
    VAProcTotalColorCorrectionCyan,
    VAProcTotalColorCorrectionMagenta,
    VAProcTotalColorCorrectionYellow,
    VAProcTotalColorCorrectionCount
} VAProcTotalColorCorrectionType;

typedef enum _VAProcHighDynamicRangeMetadataType {
    VAProcHighDynamicRangeMetadataNone = 0,
    VAProcHighDynamicRangeMetadataHDR10,
    VAProcHighDynamicRangeMetadataTypeCount
} VAProcHighDynamicRangeMetadataType;

typedef enum _VAProcMode {
    VAProcDefaultMode = 0,
    VAProcPowerSavingMode,
    VAProcPerformanceMode
} VAProcMode;

#define VA_BLEND_GLOBAL_ALPHA           0x0001

#define VA_BLEND_PREMULTIPLIED_ALPHA    0x0002

#define VA_BLEND_LUMA_KEY               0x0010

typedef struct _VABlendState {
    unsigned int        flags;
    float               global_alpha;
    float               min_luma;
    float               max_luma;
} VABlendState;

#define VA_PROC_PIPELINE_SUBPICTURES    0x00000001

#define VA_PROC_PIPELINE_FAST           0x00000002

#define VA_PROC_FILTER_MANDATORY        0x00000001

#define VA_PIPELINE_FLAG_END        0x00000004

#define VA_CHROMA_SITING_UNKNOWN              0x00

#define VA_CHROMA_SITING_VERTICAL_TOP         0x01

#define VA_CHROMA_SITING_VERTICAL_CENTER      0x02

#define VA_CHROMA_SITING_VERTICAL_BOTTOM      0x03

#define VA_CHROMA_SITING_HORIZONTAL_LEFT      0x04

#define VA_CHROMA_SITING_HORIZONTAL_CENTER    0x08

#define VA_SOURCE_RANGE_UNKNOWN         0
#define VA_SOURCE_RANGE_REDUCED         1
#define VA_SOURCE_RANGE_FULL            2

#define VA_TONE_MAPPING_HDR_TO_HDR      0x0001

#define VA_TONE_MAPPING_HDR_TO_SDR      0x0002

#define VA_TONE_MAPPING_HDR_TO_EDR      0x0004

#define VA_TONE_MAPPING_SDR_TO_HDR      0x0008

typedef struct _VAProcPipelineCaps {
    uint32_t        pipeline_flags;
    uint32_t        filter_flags;
    uint32_t        num_forward_references;
    uint32_t        num_backward_references;
    VAProcColorStandardType *input_color_standards;
    uint32_t        num_input_color_standards;
    VAProcColorStandardType *output_color_standards;
    uint32_t        num_output_color_standards;

    uint32_t        rotation_flags;
    uint32_t        blend_flags;
    uint32_t        mirror_flags;
    uint32_t        num_additional_outputs;

    uint32_t        num_input_pixel_formats;
    uint32_t        *input_pixel_format;
    uint32_t        num_output_pixel_formats;
    uint32_t        *output_pixel_format;

    uint32_t        max_input_width;
    uint32_t        max_input_height;
    uint32_t        min_input_width;
    uint32_t        min_input_height;

    uint32_t        max_output_width;
    uint32_t        max_output_height;
    uint32_t        min_output_width;
    uint32_t        min_output_height;
#if defined(__AMD64__) || defined(__x86_64__) || defined(__amd64__) || defined(__LP64__)
    uint32_t        va_reserved[VA_PADDING_HIGH - 2];
#else
    uint32_t        va_reserved[VA_PADDING_HIGH];
#endif
} VAProcPipelineCaps;

typedef struct _VAProcFilterValueRange {
    float               min_value;
    float               max_value;
    float               default_value;
    float               step;

    uint32_t            va_reserved[VA_PADDING_LOW];
} VAProcFilterValueRange;

typedef struct _VAProcColorProperties {
    uint8_t chroma_sample_location;
    uint8_t color_range;
    uint8_t colour_primaries;
    uint8_t transfer_characteristics;
    uint8_t matrix_coefficients;
    uint8_t reserved[3];
} VAProcColorProperties;

typedef struct _VAHdrMetaDataHDR10 {
    uint16_t    display_primaries_x[3];
    uint16_t    display_primaries_y[3];
    uint16_t    white_point_x;
    uint16_t    white_point_y;
    uint32_t    max_display_mastering_luminance;
    uint32_t    min_display_mastering_luminance;
    uint16_t    max_content_light_level;
    uint16_t    max_pic_average_light_level;
    uint16_t    reserved[VA_PADDING_HIGH];
} VAHdrMetaDataHDR10;

typedef struct _VAProcFilterCapHighDynamicRange {
    VAProcHighDynamicRangeMetadataType     metadata_type;
    uint16_t                               caps_flag;
    uint16_t                               va_reserved[VA_PADDING_HIGH];
} VAProcFilterCapHighDynamicRange;

typedef struct _VAHdrMetaData {
    VAProcHighDynamicRangeMetadataType       metadata_type;
    void*                                    metadata;
    uint32_t                                 metadata_size;
    uint32_t                                 reserved[VA_PADDING_LOW];
} VAHdrMetaData;

typedef struct _VAProcPipelineParameterBuffer {
    VASurfaceID         surface;
    const VARectangle  *surface_region;
    VAProcColorStandardType surface_color_standard;
    const VARectangle  *output_region;
    uint32_t        output_background_color;
    VAProcColorStandardType output_color_standard;
    uint32_t        pipeline_flags;
    uint32_t        filter_flags;
    VABufferID         *filters;
    uint32_t           num_filters;
    VASurfaceID        *forward_references;
    uint32_t           num_forward_references;
    VASurfaceID        *backward_references;
    uint32_t           num_backward_references;
    uint32_t        rotation_state;
    const VABlendState *blend_state;
    uint32_t      mirror_state;
    VASurfaceID        *additional_outputs;
    uint32_t        num_additional_outputs;
    uint32_t        input_surface_flag;
    uint32_t        output_surface_flag;
    VAProcColorProperties  input_color_properties;
    VAProcColorProperties  output_color_properties;
    VAProcMode             processing_mode;
    VAHdrMetaData          *output_hdr_metadata;

#if defined(__AMD64__) || defined(__x86_64__) || defined(__amd64__)|| defined(__LP64__)
    uint32_t                va_reserved[VA_PADDING_LARGE - 16];
#else
    uint32_t                va_reserved[VA_PADDING_LARGE - 13];
#endif
} VAProcPipelineParameterBuffer;

typedef struct _VAProcFilterParameterBufferBase {
    VAProcFilterType    type;
} VAProcFilterParameterBufferBase;

typedef struct _VAProcFilterParameterBuffer {
    VAProcFilterType    type;
    float               value;

    uint32_t                va_reserved[VA_PADDING_LOW];
} VAProcFilterParameterBuffer;

#define VA_DEINTERLACING_BOTTOM_FIELD_FIRST 0x0001

#define VA_DEINTERLACING_BOTTOM_FIELD       0x0002

#define VA_DEINTERLACING_ONE_FIELD      0x0004

#define VA_DEINTERLACING_FMD_ENABLE     0x0008

//Scene change parameter for ADI on Linux, if enabled, driver use spatial DI(Bob), instead of ADI. if not, use old behavior for ADI
//Input stream is TFF(set flags = 0), SRC0,1,2,3 are interlaced frame (top +bottom fields), DSTs are progressive frames
//30i->30p
//SRC0 -> BOBDI,  no reference, set flag = 0, output DST0
//SRC1 -> ADI, reference frame=SRC0, set flags = 0, call VP, output DST1
//SRC2 -> ADI, reference frame=SRC1, set flags = 0x0010(decimal 16), call VP, output DST2(T4)
//SRC3 -> ADI, reference frame=SRC2, set flags = 0, call VP, output DST3
//30i->60p
//SRC0 -> BOBDI, no reference, set flag = 0, output DST0
//SRC0 -> BOBDI, no reference, set flag =0x0002, output DST1

//SRC1 -> ADI, reference frame =SRC0, set flags = 0, call VP, output DST2
//SRC1 -> ADI, reference frame =SRC0, set flags = 0x0012(decimal18), call VP, output DST3(B3)

//SRC2 -> ADI, reference frame =SRC1, set flags =  0x0010(decimal 16), call VP, output DST4(T4)
//SRC2 -> ADI, reference frame =SRC1, set flags =  0x0002, call VP, output DST5

//SRC3 -> ADI, reference frame =SRC2, set flags =  0, call VP, output DST6
//SRC3 -> ADI, reference frame =SRC1, set flags = 0x0002, call VP, output DST7

#define VA_DEINTERLACING_SCD_ENABLE     0x0010

typedef struct _VAProcFilterParameterBufferDeinterlacing {
    VAProcFilterType            type;
    VAProcDeinterlacingType     algorithm;
    uint32_t            flags;

    uint32_t                va_reserved[VA_PADDING_LOW];
} VAProcFilterParameterBufferDeinterlacing;

typedef struct _VAProcFilterParameterBufferColorBalance {
    VAProcFilterType            type;
    VAProcColorBalanceType      attrib;
    float                       value;

    uint32_t                va_reserved[VA_PADDING_LOW];
} VAProcFilterParameterBufferColorBalance;

typedef struct _VAProcFilterParameterBufferTotalColorCorrection {
    VAProcFilterType                  type;
    VAProcTotalColorCorrectionType    attrib;
    float                             value;
} VAProcFilterParameterBufferTotalColorCorrection;

#define VA_PROC_HVS_DENOISE_DEFAULT               0x0000

#define VA_PROC_HVS_DENOISE_AUTO_BDRATE           0x0001

#define VA_PROC_HVS_DENOISE_AUTO_SUBJECTIVE       0x0002

#define VA_PROC_HVS_DENOISE_MANUAL                0x0003

typedef struct _VAProcFilterParameterBufferHVSNoiseReduction {
    VAProcFilterType    type;
    uint16_t            qp;
    uint16_t            strength;
    uint16_t            mode;
    uint16_t            va_reserved[VA_PADDING_HIGH - 1];
} VAProcFilterParameterBufferHVSNoiseReduction;

typedef struct _VAProcFilterParameterBufferHDRToneMapping {
    VAProcFilterType    type;
    VAHdrMetaData       data;
    uint32_t            va_reserved[VA_PADDING_HIGH];
} VAProcFilterParameterBufferHDRToneMapping;

#define VA_3DLUT_CHANNEL_UNKNOWN              0x00000000

#define VA_3DLUT_CHANNEL_RGB_RGB              0x00000001

#define VA_3DLUT_CHANNEL_YUV_RGB              0x00000002

#define VA_3DLUT_CHANNEL_VUY_RGB              0x00000004

typedef struct _VAProcFilterParameterBuffer3DLUT {
    VAProcFilterType    type;

    VASurfaceID         lut_surface;
    uint16_t            lut_size;
    uint16_t            lut_stride[3];
    uint16_t            bit_depth;
    uint16_t            num_channel;

    uint32_t            channel_mapping;

    uint32_t            va_reserved[VA_PADDING_HIGH];
} VAProcFilterParameterBuffer3DLUT;

typedef struct _VAProcFilterCap3DLUT {
    uint16_t            lut_size;
    uint16_t            lut_stride[3];
    uint16_t            bit_depth;
    uint16_t            num_channel;
    uint32_t            channel_mapping;

    uint32_t            va_reserved[VA_PADDING_HIGH];
} VAProcFilterCap3DLUT;

typedef struct _VAProcFilterCap {
    VAProcFilterValueRange      range;

    uint32_t                va_reserved[VA_PADDING_LOW];
} VAProcFilterCap;

typedef struct _VAProcFilterCapDeinterlacing {
    VAProcDeinterlacingType     type;

    uint32_t                va_reserved[VA_PADDING_LOW];
} VAProcFilterCapDeinterlacing;

typedef struct _VAProcFilterCapColorBalance {
    VAProcColorBalanceType      type;
    VAProcFilterValueRange      range;

    uint32_t                va_reserved[VA_PADDING_LOW];
} VAProcFilterCapColorBalance;

typedef struct _VAProcFilterCapTotalColorCorrection {
    VAProcTotalColorCorrectionType    type;
    VAProcFilterValueRange            range;
} VAProcFilterCapTotalColorCorrection;

VAStatus
vaQueryVideoProcFilters(
    VADisplay           dpy,
    VAContextID         context,
    VAProcFilterType   *filters,
    unsigned int       *num_filters
);

VAStatus
vaQueryVideoProcFilterCaps(
    VADisplay           dpy,
    VAContextID         context,
    VAProcFilterType    type,
    void               *filter_caps,
    unsigned int       *num_filter_caps
);

VAStatus
vaQueryVideoProcPipelineCaps(
    VADisplay           dpy,
    VAContextID         context,
    VABufferID         *filters,
    unsigned int        num_filters,
    VAProcPipelineCaps *pipeline_caps
);

#ifdef __cplusplus
}
#endif

#endif /* VA_VPP_H */