* unsigned int num_filters = VAProcFilterCount;
*
* // num_filters shall be initialized to the length of the array
- * vaQueryVideoProcFilters(va_dpy, vpp_ctx, &pipe_caps, &num_filters);
+ * vaQueryVideoProcFilters(va_dpy, vpp_ctx, &filters, &num_filters);
* \endcode
*
* Finally, individual filter capabilities can be checked with
* VAProcFilterParameterBufferDeinterlacing deint;
* deint.type = VAProcFilterDeinterlacing;
* deint.algorithm = VAProcDeinterlacingMotionAdaptive;
- * deint.forward_references =
- * malloc(cap->num_forward_references * sizeof(VASurfaceID));
- * deint.num_forward_references = 0; // none for now
- * deint.backward_references =
- * malloc(cap->num_backward_references * sizeof(VASurfaceID));
- * deint.num_backward_references = 0; // none for now
* vaCreateBuffer(va_dpy, vpp_ctx,
* VAProcFilterParameterBufferType, sizeof(deint), 1,
* &deint, &deint_filter
* }
* \endcode
*
+ * Once the video processing pipeline is set up, the caller shall check the
+ * implied capabilities and requirements with vaQueryVideoProcPipelineCaps().
+ * This function can be used to validate the number of reference frames are
+ * needed by the specified deinterlacing algorithm, the supported color
+ * primaries, etc.
+ * \code
+ * // Create filters
+ * VAProcPipelineCaps pipeline_caps;
+ * VASurfaceID *forward_references;
+ * unsigned int num_forward_references;
+ * VASurfaceID *backward_references;
+ * unsigned int num_backward_references;
+ * VAProcColorStandardType in_color_standards[VAProcColorStandardCount];
+ * VAProcColorStandardType out_color_standards[VAProcColorStandardCount];
+ *
+ * pipeline_caps.input_color_standards = NULL;
+ * pipeline_caps.num_input_color_standards = ARRAY_ELEMS(in_color_standards);
+ * pipeline_caps.output_color_standards = NULL;
+ * pipeline_caps.num_output_color_standards = ARRAY_ELEMS(out_color_standards);
+ * vaQueryVideoProcPipelineCaps(va_dpy, vpp_ctx,
+ * filter_bufs, num_filter_bufs,
+ * &pipeline_caps
+ * );
+ *
+ * num_forward_references = pipeline_caps.num_forward_references;
+ * forward_references =
+ * malloc(num__forward_references * sizeof(VASurfaceID));
+ * num_backward_references = pipeline_caps.num_backward_references;
+ * backward_references =
+ * malloc(num_backward_references * sizeof(VASurfaceID));
+ * \endcode
+ *
* \section api_vpp_submit Send video processing parameters through VA buffers
*
* Video processing pipeline parameters are submitted for each source
*
* vaCreateBuffer(va_dpy, vpp_ctx,
* VAProcPipelineParameterBuffer, sizeof(*pipeline_param), 1,
- * NULL, &pipeline_param
+ * NULL, &pipeline_buf
* );
*
* // Setup output region for this surface
* pipeline_param->output_background_color = 0;
* if (first surface to render)
* pipeline_param->output_background_color = 0xff000000; // black
- * pipeline_param->flags = VA_FILTER_SCALING_HQ;
+ * pipeline_param->filter_flags = VA_FILTER_SCALING_HQ;
* pipeline_param->filters = filter_bufs;
* pipeline_param->num_filters = num_filter_bufs;
* vaUnmapBuffer(va_dpy, pipeline_buf);
*
- * VAProcFilterParameterBufferDeinterlacing *deint_param;
- * vaMapBuffer(va_dpy, deint_filter, &deint_param);
- * // Update deinterlacing parameters, if necessary
- * ...
- * vaUnmapBuffer(va_dpy, deint_filter);
+ * // Update reference frames for deinterlacing, if necessary
+ * pipeline_param->forward_references = forward_references;
+ * pipeline_param->num_forward_references = num_forward_references_used;
+ * pipeline_param->backward_references = backward_references;
+ * pipeline_param->num_backward_references = num_bacward_references_used;
*
* // Apply filters
* vaRenderPicture(va_dpy, vpp_ctx, &pipeline_buf, 1);
VAProcFilterSharpening,
/** \brief Color balance parameters. */
VAProcFilterColorBalance,
- /** \brief Color standard conversion. */
- VAProcFilterColorStandard,
- /** \brief Max number of video filters. */
+ /** \brief Skin Tone Enhancement. */
+ VAProcFilterSkinToneEnhancement,
+ /** \brief Total Color Correction. */
+ VAProcFilterTotalColorCorrection,
+ /** \brief Human Vision System(HVS) Noise reduction filter. */
+ VAProcFilterHVSNoiseReduction,
+ /** \brief High Dynamic Range Tone Mapping. */
+ VAProcFilterHighDynamicRangeToneMapping,
+ /** \brief Number of video filters. */
VAProcFilterCount
} VAProcFilterType;
VAProcDeinterlacingMotionAdaptive,
/** \brief Motion compensated deinterlacing algorithm. */
VAProcDeinterlacingMotionCompensated,
- /** \brief Max number of deinterlacing algorithms. */
+ /** \brief Number of deinterlacing algorithms. */
VAProcDeinterlacingCount
} VAProcDeinterlacingType;
VAProcColorBalanceBrightness,
/** \brief Contrast. */
VAProcColorBalanceContrast,
- /** \brief Max number of color balance operations. */
+ /** \brief Automatically adjusted saturation. */
+ VAProcColorBalanceAutoSaturation,
+ /** \brief Automatically adjusted brightness. */
+ VAProcColorBalanceAutoBrightness,
+ /** \brief Automatically adjusted contrast. */
+ VAProcColorBalanceAutoContrast,
+ /** \brief Number of color balance attributes. */
VAProcColorBalanceCount
} VAProcColorBalanceType;
-/** \brief Color standard types. */
+/** \brief Color standard types.
+ *
+ * These define a set of color properties corresponding to particular
+ * video standards.
+ *
+ * Where matrix_coefficients is specified, it applies only to YUV data -
+ * RGB data always use the identity matrix (matrix_coefficients = 0).
+ */
typedef enum _VAProcColorStandardType {
VAProcColorStandardNone = 0,
- /** \brief ITU-R BT.601. */
+ /** \brief ITU-R BT.601.
+ *
+ * It is unspecified whether this will use 525-line or 625-line values;
+ * specify the colour primaries and matrix coefficients explicitly if
+ * it is known which one is required.
+ *
+ * Equivalent to:
+ * colour_primaries = 5 or 6
+ * transfer_characteristics = 6
+ * matrix_coefficients = 5 or 6
+ */
VAProcColorStandardBT601,
- /** \brief ITU-R BT.709. */
+ /** \brief ITU-R BT.709.
+ *
+ * Equivalent to:
+ * colour_primaries = 1
+ * transfer_characteristics = 1
+ * matrix_coefficients = 1
+ */
VAProcColorStandardBT709,
- /** \brief ITU-R BT.470-2 System M. */
+ /** \brief ITU-R BT.470-2 System M.
+ *
+ * Equivalent to:
+ * colour_primaries = 4
+ * transfer_characteristics = 4
+ * matrix_coefficients = 4
+ */
VAProcColorStandardBT470M,
- /** \brief ITU-R BT.470-2 System B, G. */
+ /** \brief ITU-R BT.470-2 System B, G.
+ *
+ * Equivalent to:
+ * colour_primaries = 5
+ * transfer_characteristics = 5
+ * matrix_coefficients = 5
+ */
VAProcColorStandardBT470BG,
- /** \brief SMPTE-170M. */
+ /** \brief SMPTE-170M.
+ *
+ * Equivalent to:
+ * colour_primaries = 6
+ * transfer_characteristics = 6
+ * matrix_coefficients = 6
+ */
VAProcColorStandardSMPTE170M,
- /** \brief SMPTE-240M. */
+ /** \brief SMPTE-240M.
+ *
+ * Equivalent to:
+ * colour_primaries = 7
+ * transfer_characteristics = 7
+ * matrix_coefficients = 7
+ */
VAProcColorStandardSMPTE240M,
- /** \brief Generic film. */
+ /** \brief Generic film.
+ *
+ * Equivalent to:
+ * colour_primaries = 8
+ * transfer_characteristics = 1
+ * matrix_coefficients = 1
+ */
VAProcColorStandardGenericFilm,
+ /** \brief sRGB.
+ *
+ * Equivalent to:
+ * colour_primaries = 1
+ * transfer_characteristics = 13
+ * matrix_coefficients = 0
+ */
+ VAProcColorStandardSRGB,
+ /** \brief stRGB.
+ *
+ * ???
+ */
+ VAProcColorStandardSTRGB,
+ /** \brief xvYCC601.
+ *
+ * Equivalent to:
+ * colour_primaries = 1
+ * transfer_characteristics = 11
+ * matrix_coefficients = 5
+ */
+ VAProcColorStandardXVYCC601,
+ /** \brief xvYCC709.
+ *
+ * Equivalent to:
+ * colour_primaries = 1
+ * transfer_characteristics = 11
+ * matrix_coefficients = 1
+ */
+ VAProcColorStandardXVYCC709,
+ /** \brief ITU-R BT.2020.
+ *
+ * Equivalent to:
+ * colour_primaries = 9
+ * transfer_characteristics = 14
+ * matrix_coefficients = 9
+ */
+ VAProcColorStandardBT2020,
+ /** \brief Explicitly specified color properties.
+ *
+ * Use corresponding color properties section.
+ * For example, HDR10 content:
+ * colour_primaries = 9 (BT2020)
+ * transfer_characteristics = 16 (SMPTE ST2084)
+ * matrix_coefficients = 9
+ */
+ VAProcColorStandardExplicit,
+ /** \brief Number of color standards. */
+ VAProcColorStandardCount
} VAProcColorStandardType;
+/** \brief Total color correction types. */
+typedef enum _VAProcTotalColorCorrectionType {
+ VAProcTotalColorCorrectionNone = 0,
+ /** \brief Red Saturation. */
+ VAProcTotalColorCorrectionRed,
+ /** \brief Green Saturation. */
+ VAProcTotalColorCorrectionGreen,
+ /** \brief Blue Saturation. */
+ VAProcTotalColorCorrectionBlue,
+ /** \brief Cyan Saturation. */
+ VAProcTotalColorCorrectionCyan,
+ /** \brief Magenta Saturation. */
+ VAProcTotalColorCorrectionMagenta,
+ /** \brief Yellow Saturation. */
+ VAProcTotalColorCorrectionYellow,
+ /** \brief Number of color correction attributes. */
+ VAProcTotalColorCorrectionCount
+} VAProcTotalColorCorrectionType;
+
+/** \brief High Dynamic Range Metadata types. */
+typedef enum _VAProcHighDynamicRangeMetadataType {
+ VAProcHighDynamicRangeMetadataNone = 0,
+ /** \brief Metadata type for HDR10. */
+ VAProcHighDynamicRangeMetadataHDR10
+} VAProcHighDynamicRangeMetadataType;
+
+/** \brief Video Processing Mode. */
+typedef enum _VAProcMode {
+ /**
+ * \brief Default Mode.
+ * In this mode, pipeline is decided in driver to the appropriate mode.
+ * e.g. a mode that's a balance between power and performance.
+ */
+ VAProcDefaultMode = 0,
+ /**
+ * \brief Power Saving Mode.
+ * In this mode, pipeline is optimized for power saving.
+ */
+ VAProcPowerSavingMode,
+ /**
+ * \brief Performance Mode.
+ * In this mode, pipeline is optimized for performance.
+ */
+ VAProcPerformanceMode
+} VAProcMode;
+
+/** @name Video blending flags */
+/**@{*/
+/** \brief Global alpha blending. */
+#define VA_BLEND_GLOBAL_ALPHA 0x0001
+/** \brief Premultiplied alpha blending (RGBA surfaces only). */
+#define VA_BLEND_PREMULTIPLIED_ALPHA 0x0002
+/** \brief Luma color key (YUV surfaces only). */
+#define VA_BLEND_LUMA_KEY 0x0010
+/**@}*/
+
+/** \brief Video blending state definition. */
+typedef struct _VABlendState {
+ /** \brief Video blending flags. */
+ unsigned int flags;
+ /**
+ * \brief Global alpha value.
+ *
+ * Valid if \flags has VA_BLEND_GLOBAL_ALPHA.
+ * Valid range is 0.0 to 1.0 inclusive.
+ */
+ float global_alpha;
+ /**
+ * \brief Minimum luma value.
+ *
+ * Valid if \flags has VA_BLEND_LUMA_KEY.
+ * Valid range is 0.0 to 1.0 inclusive.
+ * \ref min_luma shall be set to a sensible value lower than \ref max_luma.
+ */
+ float min_luma;
+ /**
+ * \brief Maximum luma value.
+ *
+ * Valid if \flags has VA_BLEND_LUMA_KEY.
+ * Valid range is 0.0 to 1.0 inclusive.
+ * \ref max_luma shall be set to a sensible value larger than \ref min_luma.
+ */
+ float max_luma;
+} VABlendState;
+
+/** @name Video pipeline flags */
+/**@{*/
+/** \brief Specifies whether to apply subpictures when processing a surface. */
+#define VA_PROC_PIPELINE_SUBPICTURES 0x00000001
+/**
+ * \brief Specifies whether to apply power or performance
+ * optimizations to a pipeline.
+ *
+ * When processing several surfaces, it may be necessary to prioritize
+ * more certain pipelines than others. This flag is only a hint to the
+ * video processor so that it can omit certain filters to save power
+ * for example. Typically, this flag could be used with video surfaces
+ * decoded from a secondary bitstream.
+ */
+#define VA_PROC_PIPELINE_FAST 0x00000002
+/**@}*/
+
/** @name Video filter flags */
/**@{*/
/** \brief Specifies whether the filter shall be present in the pipeline. */
#define VA_PROC_FILTER_MANDATORY 0x00000001
/**@}*/
+/** @name Pipeline end flags */
+/**@{*/
+/** \brief Specifies the pipeline is the last. */
+#define VA_PIPELINE_FLAG_END 0x00000004
+/**@}*/
+
+/** @name Chroma Siting flag */
+/**@{*/
+/** vertical chroma sitting take bit 0-1, horizontal chroma sitting take bit 2-3
+ * vertical chromma siting | horizontal chroma sitting to be chroma sitting */
+#define VA_CHROMA_SITING_UNKNOWN 0x00
+/** \brief Chroma samples are co-sited vertically on the top with the luma samples. */
+#define VA_CHROMA_SITING_VERTICAL_TOP 0x01
+/** \brief Chroma samples are not co-sited vertically with the luma samples. */
+#define VA_CHROMA_SITING_VERTICAL_CENTER 0x02
+/** \brief Chroma samples are co-sited vertically on the bottom with the luma samples. */
+#define VA_CHROMA_SITING_VERTICAL_BOTTOM 0x03
+/** \brief Chroma samples are co-sited horizontally on the left with the luma samples. */
+#define VA_CHROMA_SITING_HORIZONTAL_LEFT 0x04
+/** \brief Chroma samples are not co-sited horizontally with the luma samples. */
+#define VA_CHROMA_SITING_HORIZONTAL_CENTER 0x08
+/**@}*/
+
+/**
+ * This is to indicate that the color-space conversion uses full range or reduced range.
+ * VA_SOURCE_RANGE_FULL(Full range): Y/Cb/Cr is in [0, 255]. It is mainly used
+ * for JPEG/JFIF formats. The combination with the BT601 flag means that
+ * JPEG/JFIF color-space conversion matrix is used.
+ * VA_SOURCE_RANGE_REDUCED(Reduced range): Y is in [16, 235] and Cb/Cr is in [16, 240].
+ * It is mainly used for the YUV->RGB color-space conversion in SDTV/HDTV/UHDTV.
+ */
+#define VA_SOURCE_RANGE_UNKNOWN 0
+#define VA_SOURCE_RANGE_REDUCED 1
+#define VA_SOURCE_RANGE_FULL 2
+
+/** @name Tone Mapping flags multiple HDR mode*/
+/**@{*/
+/** \brief Tone Mapping from HDR content to HDR display. */
+#define VA_TONE_MAPPING_HDR_TO_HDR 0x0001
+/** \brief Tone Mapping from HDR content to SDR display. */
+#define VA_TONE_MAPPING_HDR_TO_SDR 0x0002
+/** \brief Tone Mapping from HDR content to EDR display. */
+#define VA_TONE_MAPPING_HDR_TO_EDR 0x0004
+/** \brief Tone Mapping from SDR content to HDR display. */
+#define VA_TONE_MAPPING_SDR_TO_HDR 0x0008
+/**@}*/
+
/** \brief Video processing pipeline capabilities. */
typedef struct _VAProcPipelineCaps {
- /** \brief Video filter flags. See video pipeline flags. */
- unsigned int flags;
+ /** \brief Pipeline flags. See VAProcPipelineParameterBuffer::pipeline_flags. */
+ uint32_t pipeline_flags;
+ /** \brief Extra filter flags. See VAProcPipelineParameterBuffer::filter_flags. */
+ uint32_t filter_flags;
/** \brief Number of forward reference frames that are needed. */
- unsigned int num_forward_references;
+ uint32_t num_forward_references;
/** \brief Number of backward reference frames that are needed. */
- unsigned int num_backward_references;
+ uint32_t num_backward_references;
+ /** \brief List of color standards supported on input. */
+ VAProcColorStandardType *input_color_standards;
+ /** \brief Number of elements in \ref input_color_standards array. */
+ uint32_t num_input_color_standards;
+ /** \brief List of color standards supported on output. */
+ VAProcColorStandardType *output_color_standards;
+ /** \brief Number of elements in \ref output_color_standards array. */
+ uint32_t num_output_color_standards;
+
+ /**
+ * \brief Rotation flags.
+ *
+ * For each rotation angle supported by the underlying hardware,
+ * the corresponding bit is set in \ref rotation_flags. See
+ * "Rotation angles" for a description of rotation angles.
+ *
+ * A value of 0 means the underlying hardware does not support any
+ * rotation. Otherwise, a check for a specific rotation angle can be
+ * performed as follows:
+ *
+ * \code
+ * VAProcPipelineCaps pipeline_caps;
+ * ...
+ * vaQueryVideoProcPipelineCaps(va_dpy, vpp_ctx,
+ * filter_bufs, num_filter_bufs,
+ * &pipeline_caps
+ * );
+ * ...
+ * if (pipeline_caps.rotation_flags & (1 << VA_ROTATION_xxx)) {
+ * // Clockwise rotation by xxx degrees is supported
+ * ...
+ * }
+ * \endcode
+ */
+ uint32_t rotation_flags;
+ /** \brief Blend flags. See "Video blending flags". */
+ uint32_t blend_flags;
+ /**
+ * \brief Mirroring flags.
+ *
+ * For each mirroring direction supported by the underlying hardware,
+ * the corresponding bit is set in \ref mirror_flags. See
+ * "Mirroring directions" for a description of mirroring directions.
+ *
+ */
+ uint32_t mirror_flags;
+ /** \brief Number of additional output surfaces supported by the pipeline */
+ uint32_t num_additional_outputs;
+
+ /** \brief Number of elements in \ref input_pixel_format array. */
+ uint32_t num_input_pixel_formats;
+ /** \brief List of input pixel formats in fourcc. */
+ uint32_t *input_pixel_format;
+ /** \brief Number of elements in \ref output_pixel_format array. */
+ uint32_t num_output_pixel_formats;
+ /** \brief List of output pixel formats in fourcc. */
+ uint32_t *output_pixel_format;
+
+ /** \brief Max supported input width in pixels. */
+ uint32_t max_input_width;
+ /** \brief Max supported input height in pixels. */
+ uint32_t max_input_height;
+ /** \brief Min supported input width in pixels. */
+ uint32_t min_input_width;
+ /** \brief Min supported input height in pixels. */
+ uint32_t min_input_height;
+
+ /** \brief Max supported output width in pixels. */
+ uint32_t max_output_width;
+ /** \brief Max supported output height in pixels. */
+ uint32_t max_output_height;
+ /** \brief Min supported output width in pixels. */
+ uint32_t min_output_width;
+ /** \brief Min supported output height in pixels. */
+ uint32_t min_output_height;
+ /** \brief Reserved bytes for future use, must be zero */
+ #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;
/** \brief Specification of values supported by the filter. */
float default_value;
/** \brief Step value that alters the filter behaviour in a sensible way. */
float step;
+
+ /** \brief Reserved bytes for future use, must be zero */
+ uint32_t va_reserved[VA_PADDING_LOW];
} VAProcFilterValueRange;
+typedef struct _VAProcColorProperties {
+ /** Chroma sample location.\c VA_CHROMA_SITING_VERTICAL_XXX | VA_CHROMA_SITING_HORIZONTAL_XXX */
+ uint8_t chroma_sample_location;
+ /** Chroma sample location. \c VA_SOURCE_RANGE_XXX*/
+ uint8_t color_range;
+ /** Colour primaries.
+ *
+ * See ISO/IEC 23001-8 or ITU H.273, section 8.1 and table 2.
+ * Only used if the color standard in use is \c VAColorStandardExplicit.
+ */
+ uint8_t colour_primaries;
+ /** Transfer characteristics.
+ *
+ * See ISO/IEC 23001-8 or ITU H.273, section 8.2 and table 3.
+ * Only used if the color standard in use is \c VAColorStandardExplicit.
+ */
+ uint8_t transfer_characteristics;
+ /** Matrix coefficients.
+ *
+ * See ISO/IEC 23001-8 or ITU H.273, section 8.3 and table 4.
+ * Only used if the color standard in use is \c VAColorStandardExplicit.
+ */
+ uint8_t matrix_coefficients;
+ /** Reserved bytes for future use, must be zero. */
+ uint8_t reserved[3];
+} VAProcColorProperties;
+
+/** \berief Describes High Dynamic Range Meta Data for HDR10. */
+typedef struct _VAHdrMetaDataHDR10
+{
+ /**
+ * \brief X chromaticity coordinate of the mastering display.
+ *
+ * Index value c equal to 0 should correspond to the green primary.
+ * Index value c equal to 1 should correspond to the blue primary.
+ * Index value c equal to 2 should correspond to the red primary.
+ * The value for display_primaries_x shall be in the range of 0 to 50000 inclusive.
+ */
+ uint16_t display_primaries_x[3];
+ /**
+ * \brief Y chromaticity coordinate of the mastering display.
+ *
+ * Index value c equal to 0 should correspond to the green primary.
+ * Index value c equal to 1 should correspond to the blue primary.
+ * Index value c equal to 2 should correspond to the red primary.
+ * The value for display_primaries_y shall be in the range of 0 to 50000 inclusive.
+ */
+ uint16_t display_primaries_y[3];
+ /**
+ * \brief X chromaticity coordinate of the white point of the mastering display.
+ *
+ * The value for white_point_x shall be in the range of 0 to 50000 inclusive.
+ */
+ uint16_t white_point_x;
+ /**
+ * \brief Y chromaticity coordinate of the white point of the mastering display.
+ *
+ * The value for white_point_y shall be in the range of 0 to 50000 inclusive.
+ */
+ uint16_t white_point_y;
+ /**
+ * \brief The maximum display luminance of the mastering display.
+ *
+ * The value is in units of 0.0001 candelas per square metre.
+ */
+ uint32_t max_display_mastering_luminance;
+ /**
+ * \brief The minumum display luminance of the mastering display.
+ *
+ * The value is in units of 0.0001 candelas per square metre.
+ */
+ uint32_t min_display_mastering_luminance;
+ /**
+ * \brief The maximum content light level.
+ *
+ * The value is in units of 0.0001 candelas per square metre.
+ */
+ uint16_t max_content_light_level;
+ /**
+ * \brief The maximum picture average light level.
+ *
+ * The value is in units of 0.0001 candelas per square metre.
+ */
+ uint16_t max_pic_average_light_level;
+ /** Resevered */
+ uint16_t reserved[VA_PADDING_HIGH];
+} VAHdrMetaDataHDR10;
+
+/** \brief Capabilities specification for the High Dynamic Range filter. */
+typedef struct _VAProcFilterCapHighDynamicRange {
+ /** \brief high dynamic range type. */
+ VAProcHighDynamicRangeMetadataType metadata_type;
+ /**
+ * \brief flag for high dynamic range tone mapping
+ *
+ * The flag is the combination of VA_TONE_MAPPING_XXX_TO_XXX.
+ * It could be VA_TONE_MAPPING_HDR_TO_HDR | VA_TONE_MAPPING_HDR_TO_SDR.
+ * SDR content to SDR display is always supported by default since it is legacy path.
+ */
+ uint16_t caps_flag;
+ /** \brief Reserved bytes for future use, must be zero */
+ uint16_t va_reserved[VA_PADDING_HIGH];
+} VAProcFilterCapHighDynamicRange;
+
+/** \brief High Dynamic Range Meta Data. */
+typedef struct _VAHdrMetaData
+{
+ /** \brief high dynamic range metadata type, HDR10 etc. */
+ VAProcHighDynamicRangeMetadataType metadata_type;
+ /**
+ * \brief Pointer to high dynamic range metadata.
+ *
+ * The pointer could point to VAHdrMetaDataHDR10 or other HDR meta data.
+ */
+ void* metadata;
+ /**
+ * \brief Size of high dynamic range metadata.
+ */
+ uint32_t metadata_size;
+ /** \brief Reserved bytes for future use, must be zero */
+ uint32_t reserved[VA_PADDING_LOW];
+} VAHdrMetaData;
+
/**
* \brief Video processing pipeline configuration.
*
- * This buffers defines a video processing pipeline. As for any buffer
- * passed to \c vaRenderPicture(), this is one-time usage model. However,
- * the actual filters to be applied are provided in the \c filters field,
- * so they can be re-used in other processing pipelines.
+ * This buffer defines a video processing pipeline. The actual filters to
+ * be applied are provided in the \c filters field, they can be re-used
+ * in other processing pipelines.
*
* The target surface is specified by the \c render_target argument of
* \c vaBeginPicture(). The general usage model is described as follows:
/**
* \brief Source surface ID.
*
- * ID of the source surface to process. If subpictures are associated with
- * the video surfaces then they shall be rendered to the target surface.
+ * ID of the source surface to process. If subpictures are associated
+ * with the video surfaces then they shall be rendered to the target
+ * surface, if the #VA_PROC_PIPELINE_SUBPICTURES pipeline flag is set.
*/
VASurfaceID surface;
/**
*/
const VARectangle *surface_region;
/**
+ * \brief Requested input color standard.
+ *
+ * Color properties are implicitly converted throughout the processing
+ * pipeline. The video processor chooses the best moment to apply
+ * this conversion. The set of supported color standards for input shall
+ * be queried with vaQueryVideoProcPipelineCaps().
+ *
+ * If this is set to VAProcColorStandardExplicit, the color properties
+ * are specified explicitly in surface_color_properties instead.
+ */
+ VAProcColorStandardType surface_color_standard;
+ /**
* \brief Region within the output surface.
*
* Pointer to a #VARectangle defining the region within the output
* surface that receives the processed pixels. If NULL, \c output_region
- * implies the whole surface.
+ * implies the whole surface.
*
* Note that any pixels residing outside the specified region will
* be filled in with the \ref output_background_color.
* Background color used to fill in pixels that reside outside of the
* specified \ref output_region. The color is specified in ARGB format:
* [31:24] alpha, [23:16] red, [15:8] green, [7:0] blue.
+ *
+ * Unless the alpha value is zero or the \ref output_region represents
+ * the whole target surface size, implementations shall not render the
+ * source surface to the target surface directly. Rather, in order to
+ * maintain the exact semantics of \ref output_background_color, the
+ * driver shall use a temporary surface and fill it in with the
+ * appropriate background color. Next, the driver will blend this
+ * temporary surface into the target surface.
+ */
+ uint32_t output_background_color;
+ /**
+ * \brief Requested output color standard.
+ *
+ * If this is set to VAProcColorStandardExplicit, the color properties
+ * are specified explicitly in output_color_properties instead.
*/
- unsigned int output_background_color;
+ VAProcColorStandardType output_color_standard;
/**
- * \brief Pipeline flags. See vaPutSurface() flags.
+ * \brief Pipeline filters. See video pipeline flags.
*
- * Pipeline flags:
+ * Flags to control the pipeline, like whether to apply subpictures
+ * or not, notify the driver that it can opt for power optimizations,
+ * should this be needed.
+ */
+ uint32_t pipeline_flags;
+ /**
+ * \brief Extra filter flags. See vaPutSurface() flags.
+ *
+ * Filter flags are used as a fast path, wherever possible, to use
+ * vaPutSurface() flags instead of explicit filter parameter buffers.
+ *
+ * Allowed filter flags API-wise. Use vaQueryVideoProcPipelineCaps()
+ * to check for implementation details:
* - Bob-deinterlacing: \c VA_FRAME_PICTURE, \c VA_TOP_FIELD,
* \c VA_BOTTOM_FIELD. Note that any deinterlacing filter
* (#VAProcFilterDeinterlacing) will override those flags.
* - Color space conversion: \c VA_SRC_BT601, \c VA_SRC_BT709,
- * \c VA_SRC_SMPTE_240. Note that any color standard filter
- * (#VAProcFilterColorStandard) will override those flags.
+ * \c VA_SRC_SMPTE_240.
* - Scaling: \c VA_FILTER_SCALING_DEFAULT, \c VA_FILTER_SCALING_FAST,
* \c VA_FILTER_SCALING_HQ, \c VA_FILTER_SCALING_NL_ANAMORPHIC.
*/
- unsigned int flags;
+ uint32_t filter_flags;
/**
* \brief Array of filters to apply to the surface.
*
* #VA_STATUS_ERROR_UNSUPPORTED_FILTER is returned if the list
* contains an unsupported filter.
*
- * Note: no filter buffer is destroyed after a call to vaRenderPicture(),
- * only this pipeline buffer will be destroyed as per the core API
- * specification. This allows for flexibility in re-using the filter for
- * other surfaces to be processed.
*/
VABufferID *filters;
/** \brief Actual number of filters. */
- unsigned int num_filters;
+ uint32_t num_filters;
+ /** \brief Array of forward reference frames. */
+ VASurfaceID *forward_references;
+ /** \brief Number of forward reference frames that were supplied. */
+ uint32_t num_forward_references;
+ /** \brief Array of backward reference frames. */
+ VASurfaceID *backward_references;
+ /** \brief Number of backward reference frames that were supplied. */
+ uint32_t num_backward_references;
+ /**
+ * \brief Rotation state. See rotation angles.
+ *
+ * The rotation angle is clockwise. There is no specific rotation
+ * center for this operation. Rather, The source \ref surface is
+ * first rotated by the specified angle and then scaled to fit the
+ * \ref output_region.
+ *
+ * This means that the top-left hand corner (0,0) of the output
+ * (rotated) surface is expressed as follows:
+ * - \ref VA_ROTATION_NONE: (0,0) is the top left corner of the
+ * source surface -- no rotation is performed ;
+ * - \ref VA_ROTATION_90: (0,0) is the bottom-left corner of the
+ * source surface ;
+ * - \ref VA_ROTATION_180: (0,0) is the bottom-right corner of the
+ * source surface -- the surface is flipped around the X axis ;
+ * - \ref VA_ROTATION_270: (0,0) is the top-right corner of the
+ * source surface.
+ *
+ * Check VAProcPipelineCaps::rotation_flags first prior to
+ * defining a specific rotation angle. Otherwise, the hardware can
+ * perfectly ignore this variable if it does not support any
+ * rotation.
+ */
+ uint32_t rotation_state;
+ /**
+ * \brief blending state. See "Video blending state definition".
+ *
+ * If \ref blend_state is NULL, then default operation mode depends
+ * on the source \ref surface format:
+ * - RGB: per-pixel alpha blending ;
+ * - YUV: no blending, i.e override the underlying pixels.
+ *
+ * Otherwise, \ref blend_state is a pointer to a #VABlendState
+ * structure that shall be live until vaEndPicture().
+ *
+ * Implementation note: the driver is responsible for checking the
+ * blend state flags against the actual source \ref surface format.
+ * e.g. premultiplied alpha blending is only applicable to RGB
+ * surfaces, and luma keying is only applicable to YUV surfaces.
+ * If a mismatch occurs, then #VA_STATUS_ERROR_INVALID_BLEND_STATE
+ * is returned.
+ */
+ const VABlendState *blend_state;
+ /**
+ * \bried mirroring state. See "Mirroring directions".
+ *
+ * Mirroring of an image can be performed either along the
+ * horizontal or vertical axis. It is assumed that the rotation
+ * operation is always performed before the mirroring operation.
+ */
+ uint32_t mirror_state;
+ /** \brief Array of additional output surfaces. */
+ VASurfaceID *additional_outputs;
+ /** \brief Number of additional output surfaces. */
+ uint32_t num_additional_outputs;
+ /**
+ * \brief Flag to indicate the input surface flag
+ *
+ * bit0: 0 non-protected 1: protected
+ * bit 1~31 for future
+ */
+ uint32_t input_surface_flag;
+ /**
+ * \brief Flag to indicate the output surface flag
+ *
+ * bit0: 0 non-protected 1: protected
+ * bit 1~31 for future
+ */
+ uint32_t output_surface_flag;
+ /**
+ * \brief Input Color Properties. See "VAProcColorProperties".
+ */
+ VAProcColorProperties input_color_properties;
+ /**
+ * \brief Output Color Properties. See "VAProcColorProperties".
+ */
+ VAProcColorProperties output_color_properties;
+ /**
+ * \brief Processing mode. See "VAProcMode".
+ */
+ VAProcMode processing_mode;
+ /**
+ * \brief Output High Dynamic Metadata.
+ *
+ * If output_metadata is NULL, then output default to SDR.
+ */
+ VAHdrMetaData *output_hdr_metadata;
+
+ /** \brief Reserved bytes for future use, must be zero */
+ #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;
/**
/** \brief Filter type. */
VAProcFilterType type;
/** \brief Value. */
- /* XXX: use VAGenericValue? */
float value;
+
+ /** \brief Reserved bytes for future use, must be zero */
+ uint32_t va_reserved[VA_PADDING_LOW];
} VAProcFilterParameterBuffer;
+/** @name De-interlacing flags */
+/**@{*/
+/**
+ * \brief Bottom field first in the input frame.
+ * if this is not set then assumes top field first.
+ */
+#define VA_DEINTERLACING_BOTTOM_FIELD_FIRST 0x0001
+/**
+ * \brief Bottom field used in deinterlacing.
+ * if this is not set then assumes top field is used.
+ */
+#define VA_DEINTERLACING_BOTTOM_FIELD 0x0002
+/**
+ * \brief A single field is stored in the input frame.
+ * if this is not set then assumes the frame contains two interleaved fields.
+ */
+#define VA_DEINTERLACING_ONE_FIELD 0x0004
+/**
+ * \brief Film Mode Detection is enabled. If enabled, driver performs inverse
+ * of various pulldowns, such as 3:2 pulldown.
+ * if this is not set then assumes FMD is disabled.
+ */
+#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
+
+/**@}*/
+
/** \brief Deinterlacing filter parametrization. */
typedef struct _VAProcFilterParameterBufferDeinterlacing {
/** \brief Filter type. Shall be set to #VAProcFilterDeinterlacing. */
VAProcFilterType type;
/** \brief Deinterlacing algorithm. */
VAProcDeinterlacingType algorithm;
- /** \brief Array of forward reference frames. */
- VASurfaceID *forward_references;
- /** \brief Number of forward reference frames that were supplied. */
- unsigned int num_forward_references;
- /** \brief Array of backward reference frames. */
- VASurfaceID *backward_references;
- /** \brief Number of backward reference frames that were supplied. */
- unsigned int num_backward_references;
+ /** \brief Deinterlacing flags. */
+ uint32_t flags;
+
+ /** \brief Reserved bytes for future use, must be zero */
+ uint32_t va_reserved[VA_PADDING_LOW];
} VAProcFilterParameterBufferDeinterlacing;
/**
VAProcFilterType type;
/** \brief Color balance attribute. */
VAProcColorBalanceType attrib;
- /** \brief Color balance value. */
+ /**
+ * \brief Color balance value.
+ *
+ * Special case for automatically adjusted attributes. e.g.
+ * #VAProcColorBalanceAutoSaturation,
+ * #VAProcColorBalanceAutoBrightness,
+ * #VAProcColorBalanceAutoContrast.
+ * - If \ref value is \c 1.0 +/- \c FLT_EPSILON, the attribute is
+ * automatically adjusted and overrides any other attribute of
+ * the same type that would have been set explicitly;
+ * - If \ref value is \c 0.0 +/- \c FLT_EPSILON, the attribute is
+ * disabled and other attribute of the same type is used instead.
+ */
float value;
+
+ /** \brief Reserved bytes for future use, must be zero */
+ uint32_t va_reserved[VA_PADDING_LOW];
} VAProcFilterParameterBufferColorBalance;
-/** \brief Color standard filter parametrization. */
-typedef struct _VAProcFilterParameterBufferColorStandard {
- /** \brief Filter type. Shall be set to #VAProcFilterColorStandard. */
- VAProcFilterType type;
- /** \brief Color standard to use. */
- VAProcColorStandardType standard;
-} VAProcFilterParameterBufferColorStandard;
+/** \brief Total color correction filter parametrization. */
+typedef struct _VAProcFilterParameterBufferTotalColorCorrection {
+ /** \brief Filter type. Shall be set to #VAProcFilterTotalColorCorrection. */
+ VAProcFilterType type;
+ /** \brief Color to correct. */
+ VAProcTotalColorCorrectionType attrib;
+ /** \brief Color correction value. */
+ float value;
+} VAProcFilterParameterBufferTotalColorCorrection;
+
+/** \brief Human Vision System(HVS) Noise reduction filter parametrization. */
+typedef struct _VAProcFilterParameterBufferHVSNoiseReduction {
+ /** \brief Filter type. Shall be set to #VAProcFilterHVSNoiseReduction. */
+ VAProcFilterType type;
+ /** \brief QP for encoding, used for HVS Denoise */
+ uint16_t qp;
+ /**
+ * \brief QP to Noise Reduction Strength Mode, used for Human Vision System Based Noise Reduction.
+ * Controls Noise Reduction strength of conservative and aggressive mode.
+ * It is an integer from [0-16].
+ * Value 0 means completely turn off Noise Reduction;
+ * Value 16 means the most aggressive mode of Noise Reduction;
+ * Value 10 is the default value.
+ */
+ uint16_t strength;
+ /** \brief Reserved bytes for future use, must be zero */
+ uint16_t va_reserved[VA_PADDING_HIGH];
+} VAProcFilterParameterBufferHVSNoiseReduction;
/**
* \brief Default filter cap specification (single range value).
typedef struct _VAProcFilterCap {
/** \brief Range of supported values for the filter. */
VAProcFilterValueRange range;
+
+ /** \brief Reserved bytes for future use, must be zero */
+ uint32_t va_reserved[VA_PADDING_LOW];
} VAProcFilterCap;
/** \brief Capabilities specification for the deinterlacing filter. */
typedef struct _VAProcFilterCapDeinterlacing {
/** \brief Deinterlacing algorithm. */
VAProcDeinterlacingType type;
- /** \brief Number of forward references needed for deinterlacing. */
- unsigned int num_forward_references;
- /** \brief Number of backward references needed for deinterlacing. */
- unsigned int num_backward_references;
+
+ /** \brief Reserved bytes for future use, must be zero */
+ uint32_t va_reserved[VA_PADDING_LOW];
} VAProcFilterCapDeinterlacing;
/** \brief Capabilities specification for the color balance filter. */
VAProcColorBalanceType type;
/** \brief Range of supported values for the specified operation. */
VAProcFilterValueRange range;
+
+ /** \brief Reserved bytes for future use, must be zero */
+ uint32_t va_reserved[VA_PADDING_LOW];
} VAProcFilterCapColorBalance;
-/** \brief Capabilities specification for the color standard filter. */
-typedef struct _VAProcFilterCapColorStandard {
- /** \brief Color standard type. */
- VAProcColorStandardType type;
-} VAProcFilterCapColorStandard;
+/** \brief Capabilities specification for the Total Color Correction filter. */
+typedef struct _VAProcFilterCapTotalColorCorrection {
+ /** \brief Color to correct. */
+ VAProcTotalColorCorrectionType type;
+ /** \brief Range of supported values for the specified color. */
+ VAProcFilterValueRange range;
+} VAProcFilterCapTotalColorCorrection;
/**
* \brief Queries video processing filters.
* \c filters array defines the video processing pipeline and is an array
* of buffers holding filter parameters.
*
+ * Note: the #VAProcPipelineCaps structure contains user-provided arrays.
+ * If non-NULL, the corresponding \c num_* fields shall be filled in on
+ * input with the number of elements allocated. Upon successful return,
+ * the actual number of elements will be overwritten into the \c num_*
+ * fields. Otherwise, \c VA_STATUS_ERROR_MAX_NUM_EXCEEDED is returned
+ * and \c num_* fields are adjusted to the number of elements that would
+ * be returned if enough space was available.
+ *
* @param[in] dpy the VA display
* @param[in] context the video processing context
* @param[in] filters the array of VA buffers defining the video
* processing pipeline
* @param[in] num_filters the number of elements in filters
- * @param[out] pipeline_caps the video processing pipeline capabilities
+ * @param[in,out] pipeline_caps the video processing pipeline capabilities
*/
VAStatus
vaQueryVideoProcPipelineCaps(
OSDN Git Service
