/* * This file is part of FFmpeg. * * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef AVCODEC_VAAPI_ENCODE_H#define AVCODEC_VAAPI_ENCODE_H #include <stdint.h> #include <va/va.h> #if VA_CHECK_VERSION(1, 0, 0)#include <va/va_str.h>#endif #include "libavutil/hwcontext.h"#include "libavutil/hwcontext_vaapi.h" #include "avcodec.h" struct VAAPIEncodeType;struct VAAPIEncodePicture; enum {    MAX_CONFIG_ATTRIBUTES  = 4,    MAX_GLOBAL_PARAMS      = 4,    MAX_PICTURE_REFERENCES = 2,    MAX_REORDER_DELAY      = 16,    MAX_PARAM_BUFFER_SIZE  = 1024,}; enum {    PICTURE_TYPE_IDR = 0,    PICTURE_TYPE_I   = 1,    PICTURE_TYPE_P   = 2,    PICTURE_TYPE_B   = 3,}; typedef struct VAAPIEncodeSlice {    int             index;    int             row_start;    int             row_size;    int             block_start;    int             block_size;    void           *priv_data;    void           *codec_slice_params;} VAAPIEncodeSlice; typedef struct VAAPIEncodePicture {    struct VAAPIEncodePicture *next;     int64_t         display_order;    int64_t         encode_order;    int64_t         pts;     int             type;    int             input_available;    int             encode_issued;    int             encode_complete;     AVFrame        *input_image;    VASurfaceID     input_surface;     AVFrame        *recon_image;    VASurfaceID     recon_surface;     int          nb_param_buffers;    VABufferID     *param_buffers;     AVBufferRef    *output_buffer_ref;    VABufferID      output_buffer;     void           *priv_data;    void           *codec_picture_params;     int          nb_refs;    struct VAAPIEncodePicture *refs[MAX_PICTURE_REFERENCES];     int          nb_slices;    VAAPIEncodeSlice *slices;} VAAPIEncodePicture; typedef struct VAAPIEncodeProfile {    // lavc profile value (FF_PROFILE_*).    int       av_profile;    // Supported bit depth.    int       depth;    // Number of components.    int       nb_components;    // Chroma subsampling in width dimension.    int       log2_chroma_w;    // Chroma subsampling in height dimension.    int       log2_chroma_h;    // VAAPI profile value.    VAProfile va_profile;} VAAPIEncodeProfile; typedef struct VAAPIEncodeContext {    const AVClass *class;     // Codec-specific hooks.    const struct VAAPIEncodeType *codec;     // Global options.     // Use low power encoding mode.    int             low_power;     // Desired packed headers.    unsigned int    desired_packed_headers;     // The required size of surfaces.  This is probably the input    // size (AVCodecContext.width|height) aligned up to whatever    // block size is required by the codec.    int             surface_width;    int             surface_height;     // The block size for slice calculations.    int             slice_block_width;    int             slice_block_height;     // Everything above this point must be set before calling    // ff_vaapi_encode_init().     // Chosen encoding profile details.    const VAAPIEncodeProfile *profile;     // Encoding profile (VAProfile*).    VAProfile       va_profile;    // Encoding entrypoint (VAEntryoint*).    VAEntrypoint    va_entrypoint;    // Rate control mode.    unsigned int    va_rc_mode;    // Bitrate for codec-specific encoder parameters.    unsigned int    va_bit_rate;    // Packed headers which will actually be sent.    unsigned int    va_packed_headers;     // Configuration attributes to use when creating va_config.    VAConfigAttrib  config_attributes[MAX_CONFIG_ATTRIBUTES];    int          nb_config_attributes;     VAConfigID      va_config;    VAContextID     va_context;     AVBufferRef    *device_ref;    AVHWDeviceContext *device;    AVVAAPIDeviceContext *hwctx;     // The hardware frame context containing the input frames.    AVBufferRef    *input_frames_ref;    AVHWFramesContext *input_frames;     // The hardware frame context containing the reconstructed frames.    AVBufferRef    *recon_frames_ref;    AVHWFramesContext *recon_frames;     // Pool of (reusable) bitstream output buffers.    AVBufferPool   *output_buffer_pool;     // Global parameters which will be applied at the start of the    // sequence (includes rate control parameters below).    VAEncMiscParameterBuffer *global_params[MAX_GLOBAL_PARAMS];    size_t          global_params_size[MAX_GLOBAL_PARAMS];    int          nb_global_params;     // Rate control parameters.    struct {        VAEncMiscParameterBuffer misc;        VAEncMiscParameterRateControl rc;    } rc_params;    struct {        VAEncMiscParameterBuffer misc;        VAEncMiscParameterHRD hrd;    } hrd_params;    struct {        VAEncMiscParameterBuffer misc;        VAEncMiscParameterFrameRate fr;    } fr_params;#if VA_CHECK_VERSION(0, 36, 0)    struct {        VAEncMiscParameterBuffer misc;        VAEncMiscParameterBufferQualityLevel quality;    } quality_params;#endif     // Per-sequence parameter structure (VAEncSequenceParameterBuffer*).    void           *codec_sequence_params;     // Per-sequence parameters found in the per-picture parameter    // structure (VAEncPictureParameterBuffer*).    void           *codec_picture_params;     // Current encoding window, in display (input) order.    VAAPIEncodePicture *pic_start, *pic_end;     // Next input order index (display order).    int64_t         input_order;    // Number of frames that output is behind input.    int64_t         output_delay;    // Number of frames decode output will need to be delayed.    int64_t         decode_delay;    // Next output order index (encode order).    int64_t         output_order;     enum {        // All encode operations are done independently (synchronise        // immediately after every operation).        ISSUE_MODE_SERIALISE_EVERYTHING = 0,        // Overlap as many operations as possible.        ISSUE_MODE_MAXIMISE_THROUGHPUT,        // Overlap operations only when satisfying parallel dependencies.        ISSUE_MODE_MINIMISE_LATENCY,    } issue_mode;     // Timestamp handling.    int64_t         first_pts;    int64_t         dts_pts_diff;    int64_t         ts_ring[MAX_REORDER_DELAY * 3];     // Slice structure.    int slice_block_rows;    int slice_block_cols;    int nb_slices;    int slice_size;     // Frame type decision.    int gop_size;    int p_per_i;    int b_per_p;    int force_idr;    int gop_counter;    int p_counter;    int end_of_stream;} VAAPIEncodeContext; enum {    // Codec supports controlling the subdivision of pictures into slices.    FLAG_SLICE_CONTROL         = 1 << 0,    // Codec only supports constant quality (no rate control).    FLAG_CONSTANT_QUALITY_ONLY = 1 << 1,}; typedef struct VAAPIEncodeType {    // List of supported profiles and corresponding VAAPI profiles.    // (Must end with FF_PROFILE_UNKNOWN.)    const VAAPIEncodeProfile *profiles;     // Codec feature flags.    int flags;     // Perform any extra codec-specific configuration after the    // codec context is initialised (set up the private data and    // add any necessary global parameters).    int (*configure)(AVCodecContext *avctx);     // The size of the parameter structures:    // sizeof(VAEnc{type}ParameterBuffer{codec}).    size_t sequence_params_size;    size_t picture_params_size;    size_t slice_params_size;     // Fill the parameter structures.    int  (*init_sequence_params)(AVCodecContext *avctx);    int   (*init_picture_params)(AVCodecContext *avctx,                                 VAAPIEncodePicture *pic);    int     (*init_slice_params)(AVCodecContext *avctx,                                 VAAPIEncodePicture *pic,                                 VAAPIEncodeSlice *slice);     // The type used by the packed header: this should look like    // VAEncPackedHeader{something}.    int sequence_header_type;    int picture_header_type;    int slice_header_type;     // Write the packed header data to the provided buffer.    // The sequence header is also used to fill the codec extradata    // when the encoder is starting.    int (*write_sequence_header)(AVCodecContext *avctx,                                 char *data, size_t *data_len);    int  (*write_picture_header)(AVCodecContext *avctx,                                 VAAPIEncodePicture *pic,                                 char *data, size_t *data_len);    int    (*write_slice_header)(AVCodecContext *avctx,                                 VAAPIEncodePicture *pic,                                 VAAPIEncodeSlice *slice,                                 char *data, size_t *data_len);     // Fill an extra parameter structure, which will then be    // passed to vaRenderPicture().  Will be called repeatedly    // with increasing index argument until AVERROR_EOF is    // returned.    int    (*write_extra_buffer)(AVCodecContext *avctx,                                 VAAPIEncodePicture *pic,                                 int index, int *type,                                 char *data, size_t *data_len);     // Write an extra packed header.  Will be called repeatedly    // with increasing index argument until AVERROR_EOF is    // returned.    int    (*write_extra_header)(AVCodecContext *avctx,                                 VAAPIEncodePicture *pic,                                 int index, int *type,                                 char *data, size_t *data_len);} VAAPIEncodeType;  int ff_vaapi_encode2(AVCodecContext *avctx, AVPacket *pkt,                     const AVFrame *input_image, int *got_packet); int ff_vaapi_encode_init(AVCodecContext *avctx);int ff_vaapi_encode_close(AVCodecContext *avctx);  #define VAAPI_ENCODE_COMMON_OPTIONS \    { "low_power", \      "Use low-power encoding mode (only available on some platforms; " \      "may not support all encoding features)", \      OFFSET(common.low_power), AV_OPT_TYPE_BOOL, \      { .i64 = 0 }, 0, 1, FLAGS }  #endif /* AVCODEC_VAAPI_ENCODE_H */