va_enc_vp9.h

Go to the documentation of this file.

/*
 * Copyright (c) 2007-2015 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_ENC_VP9_H
#define VA_ENC_VP9_H

#ifdef __cplusplus
extern "C" {
#endif

typedef struct  _VACodedBufferVP9Status {
    uint16_t    base_qp_index;

    uint8_t     loop_filter_level;

    uint8_t     long_term_indication;

    /* suggested next frame width */
    uint16_t    next_frame_width;

    /* suggested next frame height */
    uint16_t    next_frame_height;

    uint32_t                va_reserved[VA_PADDING_LOW];
} VACodedBufferVP9Status;

typedef struct  _VAEncSequenceParameterBufferVP9 {
    /* maximum frame width in pixels for the whole sequence */
    uint32_t    max_frame_width;

    /* maximum frame height in pixels for the whole sequence */
    uint32_t    max_frame_height;

    /* auto keyframe placement, non-zero means enable auto keyframe placement */
    uint32_t    kf_auto;

    /* keyframe minimum interval */
    uint32_t    kf_min_dist;

    /* keyframe maximum interval */
    uint32_t    kf_max_dist;


    /* RC related fields. RC modes are set with VAConfigAttribRateControl */
    /* For VP9, CBR implies HRD conformance and VBR implies no HRD conformance */

    uint32_t    bits_per_second;

    /* Period between key frames */
    uint32_t    intra_period;

    uint32_t                va_reserved[VA_PADDING_LOW];
} VAEncSequenceParameterBufferVP9;


typedef struct  _VAEncPictureParameterBufferVP9 {
    /* raw source frame width in pixels */
    uint32_t    frame_width_src;
    /* raw source frame height in pixels */
    uint32_t    frame_height_src;

    /* to be encoded frame width in pixels */
    uint32_t    frame_width_dst;
    /* to be encoded frame height in pixels */
    uint32_t    frame_height_dst;

    /* surface to store reconstructed frame, not used for enc only case */
    VASurfaceID reconstructed_frame;

    VASurfaceID reference_frames[8];

    /* buffer to store coded data */
    VABufferID  coded_buf;

    union {
        struct {
            /* force this frame to be a keyframe */
            uint32_t    force_kf                       : 1;

            uint32_t    ref_frame_ctrl_l0              : 3;
            uint32_t    ref_frame_ctrl_l1              : 3;

            uint32_t    ref_last_idx                   : 3;

            uint32_t    ref_last_sign_bias             : 1;

            uint32_t    ref_gf_idx                     : 3;

            uint32_t    ref_gf_sign_bias               : 1;

            uint32_t    ref_arf_idx                    : 3;

            uint32_t    ref_arf_sign_bias              : 1;

            /* The temporal id the frame belongs to */
            uint32_t    temporal_id                    : 8;

            uint32_t    reserved                       : 5;
        } bits;
        uint32_t value;
    } ref_flags;

    union {
        struct {
            uint32_t    frame_type                     : 1;

            uint32_t    show_frame                     : 1;

            uint32_t    error_resilient_mode           : 1;

            uint32_t    intra_only                     : 1;

            uint32_t    allow_high_precision_mv        : 1;

            uint32_t    mcomp_filter_type              : 3;
            uint32_t    frame_parallel_decoding_mode   : 1;
            uint32_t    reset_frame_context            : 2;
            uint32_t    refresh_frame_context          : 1;
            uint32_t    frame_context_idx              : 2;
            uint32_t    segmentation_enabled           : 1;

            /* corresponds to variable temporal_update in VP9 code.
             * Indicates whether Segment ID is from bitstream or from previous
             * frame.
             * 0: Segment ID from bitstream
             * 1: Segment ID from previous frame
             */
            uint32_t    segmentation_temporal_update   : 1;

            /* corresponds to variable update_mb_segmentation_map in VP9 code.
             * Indicates how hardware determines segmentation ID
             * 0: intra block - segment id is 0;
             *    inter block - segment id from previous frame
             * 1: intra block - segment id from bitstream (app or GPU decides)
             *    inter block - depends on segmentation_temporal_update
             */
            uint32_t    segmentation_update_map        : 1;

            uint32_t    lossless_mode                  : 1;

            uint32_t    comp_prediction_mode           : 2;

            uint32_t    auto_segmentation              : 1;

            uint32_t    super_frame_flag               : 1;

            uint32_t    reserved                       : 10;
        } bits;
        uint32_t    value;
    } pic_flags;

    uint8_t     refresh_frame_flags;

    uint8_t     luma_ac_qindex;

    int8_t      luma_dc_qindex_delta;

    int8_t      chroma_ac_qindex_delta;

    int8_t      chroma_dc_qindex_delta;

    uint8_t     filter_level;

    uint8_t     sharpness_level;

    int8_t      ref_lf_delta[4];

    int8_t      mode_lf_delta[2];

    uint16_t    bit_offset_ref_lf_delta;

    uint16_t    bit_offset_mode_lf_delta;

    uint16_t    bit_offset_lf_level;

    uint16_t    bit_offset_qindex;

    uint16_t    bit_offset_first_partition_size;

    uint16_t    bit_offset_segmentation;

    uint16_t    bit_size_segmentation;


    uint8_t     log2_tile_rows;

    uint8_t     log2_tile_columns;

    uint8_t     skip_frame_flag;

    uint8_t     number_skip_frames;

    uint32_t    skip_frames_size;

    uint32_t    va_reserved[VA_PADDING_MEDIUM];
} VAEncPictureParameterBufferVP9;


typedef struct _VAEncSegParamVP9 {
    union {
        struct {
            uint8_t     segment_reference_enabled       : 1;

            uint8_t     segment_reference               : 2;

            uint8_t     segment_reference_skipped       : 1;

            uint8_t     reserved                        : 4;

        } bits;
        uint8_t value;
    } seg_flags;

    int8_t      segment_lf_level_delta;

    int16_t     segment_qindex_delta;

    uint32_t                va_reserved[VA_PADDING_LOW];
} VAEncSegParamVP9;

typedef struct _VAEncMiscParameterTypeVP9PerSegmantParam {
    VAEncSegParamVP9    seg_data[8];

    uint32_t                va_reserved[VA_PADDING_LOW];
} VAEncMiscParameterTypeVP9PerSegmantParam;


#ifdef __cplusplus
}
#endif

#endif /* VA_ENC_VP9_H */