// Copyright 2023 The ChromiumOS Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

//! Wrappers around H264 `VABuffer` types.

use crate::bindings;

/// Wrapper over the `VAPictureH264` FFI type.
pub struct PictureH264(bindings::VAPictureH264);

impl PictureH264 {
    /// Creates the wrapper
    pub fn new(
        picture_id: bindings::VASurfaceID,
        frame_idx: u32,
        flags: u32,
        top_field_order_cnt: i32,
        bottom_field_order_cnt: i32,
    ) -> Self {
        Self(bindings::VAPictureH264 {
            picture_id,
            frame_idx,
            flags,
            TopFieldOrderCnt: top_field_order_cnt,
            BottomFieldOrderCnt: bottom_field_order_cnt,
            va_reserved: Default::default(),
        })
    }
}

/// Wrapper over the `seq_fields` bindgen field in `VAPictureParameterBufferH264`.
pub struct H264SeqFields(bindings::_VAPictureParameterBufferH264__bindgen_ty_1);

impl H264SeqFields {
    /// Creates the bindgen field
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        chroma_format_idc: u32,
        residual_colour_transform_flag: u32,
        gaps_in_frame_num_value_allowed_flag: u32,
        frame_mbs_only_flag: u32,
        mb_adaptive_frame_field_flag: u32,
        direct_8x8_inference_flag: u32,
        min_luma_bi_pred_size8x8: u32,
        log2_max_frame_num_minus4: u32,
        pic_order_cnt_type: u32,
        log2_max_pic_order_cnt_lsb_minus4: u32,
        delta_pic_order_always_zero_flag: u32,
    ) -> Self {
        let _bitfield_1 =
            bindings::_VAPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1::new_bitfield_1(
                chroma_format_idc,
                residual_colour_transform_flag,
                gaps_in_frame_num_value_allowed_flag,
                frame_mbs_only_flag,
                mb_adaptive_frame_field_flag,
                direct_8x8_inference_flag,
                min_luma_bi_pred_size8x8,
                log2_max_frame_num_minus4,
                pic_order_cnt_type,
                log2_max_pic_order_cnt_lsb_minus4,
                delta_pic_order_always_zero_flag,
            );

        Self(bindings::_VAPictureParameterBufferH264__bindgen_ty_1 {
            bits: bindings::_VAPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
                _bitfield_align_1: Default::default(),
                _bitfield_1,
                __bindgen_padding_0: Default::default(),
            },
        })
    }

    /// Returns the inner FFI type. Useful for testing purposes.
    pub fn inner(&mut self) -> &bindings::_VAPictureParameterBufferH264__bindgen_ty_1 {
        &self.0
    }
}

/// Wrapper over the `pic_fields` bindgen field in `VAPictureParameterBufferH264`.
pub struct H264PicFields(bindings::_VAPictureParameterBufferH264__bindgen_ty_2);

impl H264PicFields {
    /// Creates the bindgen field
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        entropy_coding_mode_flag: u32,
        weighted_pred_flag: u32,
        weighted_bipred_idc: u32,
        transform_8x8_mode_flag: u32,
        field_pic_flag: u32,
        constrained_intra_pred_flag: u32,
        pic_order_present_flag: u32,
        deblocking_filter_control_present_flag: u32,
        redundant_pic_cnt_present_flag: u32,
        reference_pic_flag: u32,
    ) -> Self {
        let _bitfield_1 =
            bindings::_VAPictureParameterBufferH264__bindgen_ty_2__bindgen_ty_1::new_bitfield_1(
                entropy_coding_mode_flag,
                weighted_pred_flag,
                weighted_bipred_idc,
                transform_8x8_mode_flag,
                field_pic_flag,
                constrained_intra_pred_flag,
                pic_order_present_flag,
                deblocking_filter_control_present_flag,
                redundant_pic_cnt_present_flag,
                reference_pic_flag,
            );

        Self(bindings::_VAPictureParameterBufferH264__bindgen_ty_2 {
            bits: bindings::_VAPictureParameterBufferH264__bindgen_ty_2__bindgen_ty_1 {
                _bitfield_align_1: Default::default(),
                _bitfield_1,
                __bindgen_padding_0: Default::default(),
            },
        })
    }

    /// Returns the inner FFI type. Useful for testing purposes.
    pub fn inner(&mut self) -> &bindings::_VAPictureParameterBufferH264__bindgen_ty_2 {
        &self.0
    }
}

/// A wrapper over `VAPictureParameterBufferH264` FFI type
pub struct PictureParameterBufferH264(Box<bindings::VAPictureParameterBufferH264>);

impl PictureParameterBufferH264 {
    /// Creates the wrapper
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        curr_pic: PictureH264,
        reference_frames: [PictureH264; 16],
        picture_width_in_mbs_minus1: u16,
        picture_height_in_mbs_minus1: u16,
        bit_depth_luma_minus8: u8,
        bit_depth_chroma_minus8: u8,
        num_ref_frames: u8,
        seq_fields: &H264SeqFields,
        num_slice_groups_minus1: u8,
        slice_group_map_type: u8,
        slice_group_change_rate_minus1: u16,
        pic_init_qp_minus26: i8,
        pic_init_qs_minus26: i8,
        chroma_qp_index_offset: i8,
        second_chroma_qp_index_offset: i8,
        pic_fields: &H264PicFields,
        frame_num: u16,
    ) -> Self {
        let reference_frames = (0..16usize)
            .map(|i| reference_frames[i].0)
            .collect::<Vec<_>>()
            .try_into()
            // try_into is guaranteed to work because the iterator and target array have the same
            // size.
            .unwrap();

        let seq_fields = seq_fields.0;
        let pic_fields = pic_fields.0;

        Self(Box::new(bindings::VAPictureParameterBufferH264 {
            CurrPic: curr_pic.0,
            ReferenceFrames: reference_frames,
            picture_width_in_mbs_minus1,
            picture_height_in_mbs_minus1,
            bit_depth_luma_minus8,
            bit_depth_chroma_minus8,
            num_ref_frames,
            seq_fields,
            num_slice_groups_minus1,
            slice_group_map_type,
            slice_group_change_rate_minus1,
            pic_init_qp_minus26,
            pic_init_qs_minus26,
            chroma_qp_index_offset,
            second_chroma_qp_index_offset,
            pic_fields,
            frame_num,
            va_reserved: Default::default(),
        }))
    }

    pub(crate) fn inner_mut(&mut self) -> &mut bindings::VAPictureParameterBufferH264 {
        self.0.as_mut()
    }

    /// Returns the inner FFI type. Useful for testing purposes.
    pub fn inner(&self) -> &bindings::VAPictureParameterBufferH264 {
        self.0.as_ref()
    }
}

/// Wrapper over the `VASliceParameterBufferH264` FFI type.
pub struct SliceParameterBufferH264(Vec<bindings::VASliceParameterBufferH264>);

impl SliceParameterBufferH264 {
    pub fn new_array() -> Self {
        Self(Vec::new())
    }

    /// Creates the wrapper
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        slice_data_size: u32,
        slice_data_offset: u32,
        slice_data_flag: u32,
        slice_data_bit_offset: u16,
        first_mb_in_slice: u16,
        slice_type: u8,
        direct_spatial_mv_pred_flag: u8,
        num_ref_idx_l0_active_minus1: u8,
        num_ref_idx_l1_active_minus1: u8,
        cabac_init_idc: u8,
        slice_qp_delta: i8,
        disable_deblocking_filter_idc: u8,
        slice_alpha_c0_offset_div2: i8,
        slice_beta_offset_div2: i8,
        ref_pic_list_0: [PictureH264; 32usize],
        ref_pic_list_1: [PictureH264; 32usize],
        luma_log2_weight_denom: u8,
        chroma_log2_weight_denom: u8,
        luma_weight_l0_flag: u8,
        luma_weight_l0: [i16; 32usize],
        luma_offset_l0: [i16; 32usize],
        chroma_weight_l0_flag: u8,
        chroma_weight_l0: [[i16; 2usize]; 32usize],
        chroma_offset_l0: [[i16; 2usize]; 32usize],
        luma_weight_l1_flag: u8,
        luma_weight_l1: [i16; 32usize],
        luma_offset_l1: [i16; 32usize],
        chroma_weight_l1_flag: u8,
        chroma_weight_l1: [[i16; 2usize]; 32usize],
        chroma_offset_l1: [[i16; 2usize]; 32usize],
    ) -> Self {
        let mut array = Self::new_array();

        array.add_slice_parameter(
            slice_data_size,
            slice_data_offset,
            slice_data_flag,
            slice_data_bit_offset,
            first_mb_in_slice,
            slice_type,
            direct_spatial_mv_pred_flag,
            num_ref_idx_l0_active_minus1,
            num_ref_idx_l1_active_minus1,
            cabac_init_idc,
            slice_qp_delta,
            disable_deblocking_filter_idc,
            slice_alpha_c0_offset_div2,
            slice_beta_offset_div2,
            ref_pic_list_0,
            ref_pic_list_1,
            luma_log2_weight_denom,
            chroma_log2_weight_denom,
            luma_weight_l0_flag,
            luma_weight_l0,
            luma_offset_l0,
            chroma_weight_l0_flag,
            chroma_weight_l0,
            chroma_offset_l0,
            luma_weight_l1_flag,
            luma_weight_l1,
            luma_offset_l1,
            chroma_weight_l1_flag,
            chroma_weight_l1,
            chroma_offset_l1,
        );

        array
    }

    /// Creates the wrapper
    #[allow(clippy::too_many_arguments)]
    pub fn add_slice_parameter(
        &mut self,
        slice_data_size: u32,
        slice_data_offset: u32,
        slice_data_flag: u32,
        slice_data_bit_offset: u16,
        first_mb_in_slice: u16,
        slice_type: u8,
        direct_spatial_mv_pred_flag: u8,
        num_ref_idx_l0_active_minus1: u8,
        num_ref_idx_l1_active_minus1: u8,
        cabac_init_idc: u8,
        slice_qp_delta: i8,
        disable_deblocking_filter_idc: u8,
        slice_alpha_c0_offset_div2: i8,
        slice_beta_offset_div2: i8,
        ref_pic_list_0: [PictureH264; 32usize],
        ref_pic_list_1: [PictureH264; 32usize],
        luma_log2_weight_denom: u8,
        chroma_log2_weight_denom: u8,
        luma_weight_l0_flag: u8,
        luma_weight_l0: [i16; 32usize],
        luma_offset_l0: [i16; 32usize],
        chroma_weight_l0_flag: u8,
        chroma_weight_l0: [[i16; 2usize]; 32usize],
        chroma_offset_l0: [[i16; 2usize]; 32usize],
        luma_weight_l1_flag: u8,
        luma_weight_l1: [i16; 32usize],
        luma_offset_l1: [i16; 32usize],
        chroma_weight_l1_flag: u8,
        chroma_weight_l1: [[i16; 2usize]; 32usize],
        chroma_offset_l1: [[i16; 2usize]; 32usize],
    ) {
        let ref_pic_list_0 = ref_pic_list_0.map(|pic| pic.0);
        let ref_pic_list_1 = ref_pic_list_1.map(|pic| pic.0);

        let buf = bindings::VASliceParameterBufferH264 {
            slice_data_size,
            slice_data_offset,
            slice_data_flag,
            slice_data_bit_offset,
            first_mb_in_slice,
            slice_type,
            direct_spatial_mv_pred_flag,
            num_ref_idx_l0_active_minus1,
            num_ref_idx_l1_active_minus1,
            cabac_init_idc,
            slice_qp_delta,
            disable_deblocking_filter_idc,
            slice_alpha_c0_offset_div2,
            slice_beta_offset_div2,
            RefPicList0: ref_pic_list_0,
            RefPicList1: ref_pic_list_1,
            luma_log2_weight_denom,
            chroma_log2_weight_denom,
            luma_weight_l0_flag,
            luma_weight_l0,
            luma_offset_l0,
            chroma_weight_l0_flag,
            chroma_weight_l0,
            chroma_offset_l0,
            luma_weight_l1_flag,
            luma_weight_l1,
            luma_offset_l1,
            chroma_weight_l1_flag,
            chroma_weight_l1,
            chroma_offset_l1,
            va_reserved: Default::default(),
        };

        self.0.push(buf);
    }

    pub(crate) fn inner_mut(&mut self) -> &mut Vec<bindings::VASliceParameterBufferH264> {
        &mut self.0
    }

    /// Returns the inner FFI type. Useful for testing purposes.
    pub fn inner(&self) -> &Vec<bindings::VASliceParameterBufferH264> {
        &self.0
    }
}

/// Wrapper over the `VAIQMatrixBufferH264` FFI type
pub struct IQMatrixBufferH264(Box<bindings::VAIQMatrixBufferH264>);

impl IQMatrixBufferH264 {
    /// Creates the wrapper.
    pub fn new(
        scaling_list4x4: [[u8; 16usize]; 6usize],
        scaling_list8x8: [[u8; 64usize]; 2usize],
    ) -> Self {
        Self(Box::new(bindings::VAIQMatrixBufferH264 {
            ScalingList4x4: scaling_list4x4,
            ScalingList8x8: scaling_list8x8,
            va_reserved: Default::default(),
        }))
    }

    pub(crate) fn inner_mut(&mut self) -> &mut bindings::VAIQMatrixBufferH264 {
        self.0.as_mut()
    }

    /// Returns the inner FFI type. Useful for testing purposes.
    pub fn inner(&self) -> &bindings::VAIQMatrixBufferH264 {
        self.0.as_ref()
    }
}

/// Wrapper over the `seq_fields` bindgen field in `VAEncSequenceParameterBufferH264`
pub struct H264EncSeqFields(bindings::_VAEncSequenceParameterBufferH264__bindgen_ty_1);

impl H264EncSeqFields {
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        chroma_format_idc: u32,
        frame_mbs_only_flag: u32,
        mb_adaptive_frame_field_flag: u32,
        seq_scaling_matrix_present_flag: u32,
        direct_8x8_inference_flag: u32,
        log2_max_frame_num_minus4: u32,
        pic_order_cnt_type: u32,
        log2_max_pic_order_cnt_lsb_minus4: u32,
        delta_pic_order_always_zero_flag: u32,
    ) -> Self {
        let _bitfield_1 =
            bindings::_VAEncSequenceParameterBufferH264__bindgen_ty_1__bindgen_ty_1::new_bitfield_1(
                chroma_format_idc,
                frame_mbs_only_flag,
                mb_adaptive_frame_field_flag,
                seq_scaling_matrix_present_flag,
                direct_8x8_inference_flag,
                log2_max_frame_num_minus4,
                pic_order_cnt_type,
                log2_max_pic_order_cnt_lsb_minus4,
                delta_pic_order_always_zero_flag,
            );

        Self(bindings::_VAEncSequenceParameterBufferH264__bindgen_ty_1 {
            bits: bindings::_VAEncSequenceParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
                _bitfield_align_1: Default::default(),
                _bitfield_1,
                __bindgen_padding_0: Default::default(),
            },
        })
    }

    pub fn inner(&self) -> &bindings::_VAEncSequenceParameterBufferH264__bindgen_ty_1 {
        &self.0
    }
}

#[derive(Default)]
pub struct H264VuiFields(bindings::_VAEncSequenceParameterBufferH264__bindgen_ty_2);

impl H264VuiFields {
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        aspect_ratio_info_present_flag: u32,
        timing_info_present_flag: u32,
        bitstream_restriction_flag: u32,
        log2_max_mv_length_horizontal: u32,
        log2_max_mv_length_vertical: u32,
        fixed_frame_rate_flag: u32,
        low_delay_hrd_flag: u32,
        motion_vectors_over_pic_boundaries_flag: u32,
    ) -> Self {
        let _bitfield_1 =
            bindings::_VAEncSequenceParameterBufferH264__bindgen_ty_2__bindgen_ty_1::new_bitfield_1(
                aspect_ratio_info_present_flag,
                timing_info_present_flag,
                bitstream_restriction_flag,
                log2_max_mv_length_horizontal,
                log2_max_mv_length_vertical,
                fixed_frame_rate_flag,
                low_delay_hrd_flag,
                motion_vectors_over_pic_boundaries_flag,
                Default::default(),
            );

        Self(bindings::_VAEncSequenceParameterBufferH264__bindgen_ty_2 {
            bits: bindings::_VAEncSequenceParameterBufferH264__bindgen_ty_2__bindgen_ty_1 {
                _bitfield_align_1: Default::default(),
                _bitfield_1,
            },
        })
    }
}

#[derive(Default)]
pub struct H264EncFrameCropOffsets {
    pub left: u32,
    pub right: u32,
    pub top: u32,
    pub bottom: u32,
}

impl H264EncFrameCropOffsets {
    pub fn new(
        frame_crop_left_offset: u32,
        frame_crop_right_offset: u32,
        frame_crop_top_offset: u32,
        frame_crop_bottom_offset: u32,
    ) -> Self {
        Self {
            left: frame_crop_left_offset,
            right: frame_crop_right_offset,
            top: frame_crop_top_offset,
            bottom: frame_crop_bottom_offset,
        }
    }
}

pub struct EncSequenceParameterBufferH264(Box<bindings::VAEncSequenceParameterBufferH264>);

impl EncSequenceParameterBufferH264 {
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        seq_parameter_set_id: u8,
        level_idc: u8,
        intra_period: u32,
        intra_idr_period: u32,
        ip_period: u32,
        bits_per_second: u32,
        max_num_ref_frames: u32,
        picture_width_in_mbs: u16,
        picture_height_in_mbs: u16,
        seq_fields: &H264EncSeqFields,
        bit_depth_luma_minus8: u8,
        bit_depth_chroma_minus8: u8,
        num_ref_frames_in_pic_order_cnt_cycle: u8,
        offset_for_non_ref_pic: i32,
        offset_for_top_to_bottom_field: i32,
        offset_for_ref_frame: [i32; 256usize],
        frame_crop: Option<H264EncFrameCropOffsets>,
        vui_fields: Option<H264VuiFields>,
        aspect_ratio_idc: u8,
        sar_width: u32,
        sar_height: u32,
        num_units_in_tick: u32,
        time_scale: u32,
    ) -> Self {
        let seq_fields = seq_fields.0;

        let frame_cropping_flag = if frame_crop.is_some() { 1 } else { 0 };
        let frame_crop = frame_crop.unwrap_or_default();

        let frame_crop_left_offset = frame_crop.left;
        let frame_crop_right_offset = frame_crop.right;
        let frame_crop_top_offset = frame_crop.top;
        let frame_crop_bottom_offset = frame_crop.bottom;

        let vui_parameters_present_flag = if vui_fields.is_some() { 1 } else { 0 };
        let vui_fields = vui_fields.unwrap_or_default().0;

        Self(Box::new(bindings::VAEncSequenceParameterBufferH264 {
            seq_parameter_set_id,
            level_idc,
            intra_period,
            intra_idr_period,
            ip_period,
            bits_per_second,
            max_num_ref_frames,
            picture_width_in_mbs,
            picture_height_in_mbs,
            seq_fields,
            bit_depth_luma_minus8,
            bit_depth_chroma_minus8,
            num_ref_frames_in_pic_order_cnt_cycle,
            offset_for_non_ref_pic,
            offset_for_top_to_bottom_field,
            offset_for_ref_frame,
            frame_cropping_flag,
            frame_crop_left_offset,
            frame_crop_right_offset,
            frame_crop_top_offset,
            frame_crop_bottom_offset,
            vui_parameters_present_flag,
            vui_fields,
            aspect_ratio_idc,
            sar_width,
            sar_height,
            num_units_in_tick,
            time_scale,
            ..Default::default()
        }))
    }

    pub(crate) fn inner_mut(&mut self) -> &mut bindings::VAEncSequenceParameterBufferH264 {
        self.0.as_mut()
    }
}

pub struct H264EncPicFields(bindings::_VAEncPictureParameterBufferH264__bindgen_ty_1);

impl H264EncPicFields {
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        idr_pic_flag: u32,
        reference_pic_flag: u32,
        entropy_coding_mode_flag: u32,
        weighted_pred_flag: u32,
        weighted_bipred_idc: u32,
        constrained_intra_pred_flag: u32,
        transform_8x8_mode_flag: u32,
        deblocking_filter_control_present_flag: u32,
        redundant_pic_cnt_present_flag: u32,
        pic_order_present_flag: u32,
        pic_scaling_matrix_present_flag: u32,
    ) -> Self {
        let _bitfield_1 =
            bindings::_VAEncPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1::new_bitfield_1(
                idr_pic_flag,
                reference_pic_flag,
                entropy_coding_mode_flag,
                weighted_pred_flag,
                weighted_bipred_idc,
                constrained_intra_pred_flag,
                transform_8x8_mode_flag,
                deblocking_filter_control_present_flag,
                redundant_pic_cnt_present_flag,
                pic_order_present_flag,
                pic_scaling_matrix_present_flag,
            );

        Self(bindings::_VAEncPictureParameterBufferH264__bindgen_ty_1 {
            bits: bindings::_VAEncPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
                _bitfield_align_1: Default::default(),
                _bitfield_1,
                __bindgen_padding_0: Default::default(),
            },
        })
    }
}

pub struct EncPictureParameterBufferH264(Box<bindings::VAEncPictureParameterBufferH264>);

impl EncPictureParameterBufferH264 {
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        curr_pic: PictureH264,
        reference_frames: [PictureH264; 16usize],
        coded_buf: bindings::VABufferID,
        pic_parameter_set_id: u8,
        seq_parameter_set_id: u8,
        last_picture: u8,
        frame_num: u16,
        pic_init_qp: u8,
        num_ref_idx_l0_active_minus1: u8,
        num_ref_idx_l1_active_minus1: u8,
        chroma_qp_index_offset: i8,
        second_chroma_qp_index_offset: i8,
        pic_fields: &H264EncPicFields,
    ) -> Self {
        let reference_frames = (0..16usize)
            .map(|i| reference_frames[i].0)
            .collect::<Vec<_>>()
            .try_into()
            // try_into is guaranteed to work because the iterator and target array have the same
            // size.
            .unwrap();

        let pic_fields = pic_fields.0;

        Self(Box::new(bindings::_VAEncPictureParameterBufferH264 {
            CurrPic: curr_pic.0,
            ReferenceFrames: reference_frames,
            coded_buf,
            pic_parameter_set_id,
            seq_parameter_set_id,
            last_picture,
            frame_num,
            pic_init_qp,
            num_ref_idx_l0_active_minus1,
            num_ref_idx_l1_active_minus1,
            chroma_qp_index_offset,
            second_chroma_qp_index_offset,
            pic_fields,
            ..Default::default()
        }))
    }

    pub(crate) fn inner_mut(&mut self) -> &mut bindings::VAEncPictureParameterBufferH264 {
        self.0.as_mut()
    }
}

pub struct EncSliceParameterBufferH264(Box<bindings::VAEncSliceParameterBufferH264>);

impl EncSliceParameterBufferH264 {
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        macroblock_address: u32,
        num_macroblocks: u32,
        macroblock_info: bindings::VABufferID,
        slice_type: u8,
        pic_parameter_set_id: u8,
        idr_pic_id: u16,
        pic_order_cnt_lsb: u16,
        delta_pic_order_cnt_bottom: i32,
        delta_pic_order_cnt: [i32; 2usize],
        direct_spatial_mv_pred_flag: u8,
        num_ref_idx_active_override_flag: u8,
        num_ref_idx_l0_active_minus1: u8,
        num_ref_idx_l1_active_minus1: u8,
        ref_pic_list_0: [PictureH264; 32usize],
        ref_pic_list_1: [PictureH264; 32usize],
        luma_log2_weight_denom: u8,
        chroma_log2_weight_denom: u8,
        luma_weight_l0_flag: u8,
        luma_weight_l0: [i16; 32usize],
        luma_offset_l0: [i16; 32usize],
        chroma_weight_l0_flag: u8,
        chroma_weight_l0: [[i16; 2usize]; 32usize],
        chroma_offset_l0: [[i16; 2usize]; 32usize],
        luma_weight_l1_flag: u8,
        luma_weight_l1: [i16; 32usize],
        luma_offset_l1: [i16; 32usize],
        chroma_weight_l1_flag: u8,
        chroma_weight_l1: [[i16; 2usize]; 32usize],
        chroma_offset_l1: [[i16; 2usize]; 32usize],
        cabac_init_idc: u8,
        slice_qp_delta: i8,
        disable_deblocking_filter_idc: u8,
        slice_alpha_c0_offset_div2: i8,
        slice_beta_offset_div2: i8,
    ) -> Self {
        let ref_pic_list_0 = ref_pic_list_0.map(|pic| pic.0);
        let ref_pic_list_1 = ref_pic_list_1.map(|pic| pic.0);

        Self(Box::new(bindings::VAEncSliceParameterBufferH264 {
            macroblock_address,
            num_macroblocks,
            macroblock_info,
            slice_type,
            pic_parameter_set_id,
            idr_pic_id,
            pic_order_cnt_lsb,
            delta_pic_order_cnt_bottom,
            delta_pic_order_cnt,
            direct_spatial_mv_pred_flag,
            num_ref_idx_active_override_flag,
            num_ref_idx_l0_active_minus1,
            num_ref_idx_l1_active_minus1,
            RefPicList0: ref_pic_list_0,
            RefPicList1: ref_pic_list_1,
            luma_log2_weight_denom,
            chroma_log2_weight_denom,
            luma_weight_l0_flag,
            luma_weight_l0,
            luma_offset_l0,
            chroma_weight_l0_flag,
            chroma_weight_l0,
            chroma_offset_l0,
            luma_weight_l1_flag,
            luma_weight_l1,
            luma_offset_l1,
            chroma_weight_l1_flag,
            chroma_weight_l1,
            chroma_offset_l1,
            cabac_init_idc,
            slice_qp_delta,
            disable_deblocking_filter_idc,
            slice_alpha_c0_offset_div2,
            slice_beta_offset_div2,
            ..Default::default()
        }))
    }

    pub(crate) fn inner_mut(&mut self) -> &mut bindings::VAEncSliceParameterBufferH264 {
        self.0.as_mut()
    }

    /// Returns the inner FFI type. Useful for testing purposes.
    pub fn inner(&self) -> &bindings::VAEncSliceParameterBufferH264 {
        self.0.as_ref()
    }
}

pub struct H264EncMacroblockInfo(bindings::_VAEncMacroblockParameterBufferH264__bindgen_ty_1);

impl H264EncMacroblockInfo {
    pub fn new_intra(pred_avail_override_flag: u32, pred_avail_flags: u32) -> Self {
        let _bitfield_1 =
            bindings::_VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::new_bitfield_1(pred_avail_override_flag, pred_avail_flags);

        Self(bindings::_VAEncMacroblockParameterBufferH264__bindgen_ty_1 {
            intra_fields: bindings::_VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
                bits:  bindings::_VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1  {
                    _bitfield_align_1: Default::default(),
                    _bitfield_1,
                    __bindgen_padding_0: Default::default(),
                }
            }
        })
    }

    pub fn new_inter() -> Self {
        Self(bindings::_VAEncMacroblockParameterBufferH264__bindgen_ty_1 {
            inter_fields: bindings::_VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2 {
                bits:  bindings::_VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1  {
                    reserved: Default::default()
                }
            }
        })
    }
}

pub struct EncMacroblockParameterBufferH264(Box<bindings::VAEncMacroblockParameterBufferH264>);

impl EncMacroblockParameterBufferH264 {
    pub fn new(qp: u8, info: &H264EncMacroblockInfo) -> Self {
        let info = info.0;

        Self(Box::new(bindings::VAEncMacroblockParameterBufferH264 {
            qp,
            info,
            ..Default::default()
        }))
    }

    pub(crate) fn inner_mut(&mut self) -> &mut bindings::VAEncMacroblockParameterBufferH264 {
        self.0.as_mut()
    }

    /// Returns the inner FFI type. Useful for testing purposes.
    pub fn inner(&self) -> &bindings::VAEncMacroblockParameterBufferH264 {
        self.0.as_ref()
    }
}