cros_codecs/decoder/stateless/vp8/

vaapi.rs

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

use std::convert::TryFrom;
use std::rc::Rc;

use anyhow::Context;
use libva::BufferType;
use libva::Display;
use libva::IQMatrix;
use libva::IQMatrixBufferVP8;
use libva::Picture as VaPicture;
use libva::ProbabilityDataBufferVP8;
use libva::SurfaceMemoryDescriptor;

use crate::backend::vaapi::decoder::va_surface_id;
use crate::backend::vaapi::decoder::PoolCreationMode;
use crate::backend::vaapi::decoder::VaStreamInfo;
use crate::backend::vaapi::decoder::VaapiBackend;
use crate::backend::vaapi::decoder::VaapiPicture;
use crate::codec::vp8::parser::Header;
use crate::codec::vp8::parser::MbLfAdjustments;
use crate::codec::vp8::parser::Segmentation;
use crate::decoder::stateless::vp8::StatelessVp8DecoderBackend;
use crate::decoder::stateless::vp8::Vp8;
use crate::decoder::stateless::NewPictureError;
use crate::decoder::stateless::NewPictureResult;
use crate::decoder::stateless::NewStatelessDecoderError;
use crate::decoder::stateless::StatelessBackendResult;
use crate::decoder::stateless::StatelessDecoder;
use crate::decoder::stateless::StatelessDecoderBackendPicture;
use crate::decoder::BlockingMode;
use crate::decoder::FramePool;
use crate::Resolution;

/// The number of surfaces to allocate for this codec. Same as GStreamer's vavp8dec.
const NUM_SURFACES: usize = 7;

impl VaStreamInfo for &Header {
    fn va_profile(&self) -> anyhow::Result<i32> {
        Ok(libva::VAProfile::VAProfileVP8Version0_3)
    }

    fn rt_format(&self) -> anyhow::Result<u32> {
        Ok(libva::constants::VA_RT_FORMAT_YUV420)
    }

    fn min_num_surfaces(&self) -> usize {
        NUM_SURFACES
    }

    fn coded_size(&self) -> (u32, u32) {
        (self.width as u32, self.height as u32)
    }

    fn visible_rect(&self) -> ((u32, u32), (u32, u32)) {
        ((0, 0), self.coded_size())
    }
}

/// A clamp such that min <= x <= max
fn clamp<T: PartialOrd>(x: T, low: T, high: T) -> T {
    if x > high {
        high
    } else if x < low {
        low
    } else {
        x
    }
}

fn build_iq_matrix(
    frame_hdr: &Header,
    segmentation: &Segmentation,
) -> anyhow::Result<libva::BufferType> {
    let mut quantization_index: [[u16; 6]; 4] = Default::default();

    for (i, quantization_index) in quantization_index.iter_mut().enumerate() {
        let mut qi_base: i16;

        if segmentation.segmentation_enabled {
            qi_base = i16::from(segmentation.quantizer_update_value[i]);
            if !segmentation.segment_feature_mode {
                qi_base += i16::from(frame_hdr.quant_indices.y_ac_qi);
            }
        } else {
            qi_base = i16::from(frame_hdr.quant_indices.y_ac_qi);
        }

        let mut qi = qi_base;
        quantization_index[0] = u16::try_from(clamp(qi, 0, 127))?;
        qi = qi_base + i16::from(frame_hdr.quant_indices.y_dc_delta);
        quantization_index[1] = u16::try_from(clamp(qi, 0, 127))?;
        qi = qi_base + i16::from(frame_hdr.quant_indices.y2_dc_delta);
        quantization_index[2] = u16::try_from(clamp(qi, 0, 127))?;
        qi = qi_base + i16::from(frame_hdr.quant_indices.y2_ac_delta);
        quantization_index[3] = u16::try_from(clamp(qi, 0, 127))?;
        qi = qi_base + i16::from(frame_hdr.quant_indices.uv_dc_delta);
        quantization_index[4] = u16::try_from(clamp(qi, 0, 127))?;
        qi = qi_base + i16::from(frame_hdr.quant_indices.uv_ac_delta);
        quantization_index[5] = u16::try_from(clamp(qi, 0, 127))?;
    }

    Ok(BufferType::IQMatrix(IQMatrix::VP8(IQMatrixBufferVP8::new(
        quantization_index,
    ))))
}

fn build_probability_table(frame_hdr: &Header) -> libva::BufferType {
    BufferType::Probability(ProbabilityDataBufferVP8::new(frame_hdr.coeff_prob))
}

fn build_pic_param(
    frame_hdr: &Header,
    resolution: &Resolution,
    seg: &Segmentation,
    adj: &MbLfAdjustments,
    last: u32,
    golden: u32,
    alt: u32,
) -> anyhow::Result<libva::BufferType> {
    let mut loop_filter_level: [u8; 4] = Default::default();
    let mut loop_filter_deltas_ref_frame: [i8; 4] = Default::default();
    let mut loop_filter_deltas_mode: [i8; 4] = Default::default();

    for i in 0..4 {
        let mut level;
        if seg.segmentation_enabled {
            level = seg.lf_update_value[i];
            if !seg.segment_feature_mode {
                level += i8::try_from(frame_hdr.loop_filter_level)?;
            }
        } else {
            level = i8::try_from(frame_hdr.loop_filter_level)?;
        }

        loop_filter_level[i] = clamp(u8::try_from(level)?, 0, 63);
        loop_filter_deltas_ref_frame[i] = adj.ref_frame_delta[i];
        loop_filter_deltas_mode[i] = adj.mb_mode_delta[i];
    }

    let pic_fields = libva::VP8PicFields::new(
        u32::from(!frame_hdr.key_frame),
        u32::from(frame_hdr.version),
        u32::from(seg.segmentation_enabled),
        u32::from(seg.update_mb_segmentation_map),
        u32::from(seg.update_segment_feature_data),
        u32::from(frame_hdr.filter_type),
        u32::from(frame_hdr.sharpness_level),
        u32::from(adj.loop_filter_adj_enable),
        u32::from(adj.mode_ref_lf_delta_update),
        u32::from(frame_hdr.sign_bias_golden),
        u32::from(frame_hdr.sign_bias_alternate),
        u32::from(frame_hdr.mb_no_coeff_skip),
        u32::from(frame_hdr.loop_filter_level == 0),
    );

    let bool_coder_ctx = libva::BoolCoderContextVPX::new(
        u8::try_from(frame_hdr.bd_range)?,
        u8::try_from(frame_hdr.bd_value)?,
        u8::try_from(frame_hdr.bd_count)?,
    );

    let pic_param = libva::PictureParameterBufferVP8::new(
        resolution.width,
        resolution.height,
        last,
        golden,
        alt,
        &pic_fields,
        seg.segment_prob,
        loop_filter_level,
        loop_filter_deltas_ref_frame,
        loop_filter_deltas_mode,
        frame_hdr.prob_skip_false,
        frame_hdr.prob_intra,
        frame_hdr.prob_last,
        frame_hdr.prob_golden,
        frame_hdr.mode_probs.intra_16x16_prob,
        frame_hdr.mode_probs.intra_chroma_prob,
        frame_hdr.mv_prob,
        &bool_coder_ctx,
    );

    Ok(libva::BufferType::PictureParameter(
        libva::PictureParameter::VP8(pic_param),
    ))
}

fn build_slice_param(frame_hdr: &Header, slice_size: usize) -> anyhow::Result<libva::BufferType> {
    let mut partition_size: [u32; 9] = Default::default();
    let num_of_partitions = frame_hdr.num_dct_partitions() + 1;

    partition_size[0] = frame_hdr.first_part_size - ((frame_hdr.header_size + 7) >> 3);

    partition_size[1..num_of_partitions]
        .clone_from_slice(&frame_hdr.partition_size[..(num_of_partitions - 1)]);

    Ok(libva::BufferType::SliceParameter(
        libva::SliceParameter::VP8(libva::SliceParameterBufferVP8::new(
            u32::try_from(slice_size)?,
            u32::from(frame_hdr.data_chunk_size),
            0,
            frame_hdr.header_size,
            u8::try_from(num_of_partitions)?,
            partition_size,
        )),
    ))
}

impl<M: SurfaceMemoryDescriptor + 'static> StatelessDecoderBackendPicture<Vp8> for VaapiBackend<M> {
    type Picture = VaapiPicture<M>;
}

impl<M: SurfaceMemoryDescriptor + 'static> StatelessVp8DecoderBackend for VaapiBackend<M> {
    fn new_sequence(&mut self, header: &Header) -> StatelessBackendResult<()> {
        self.new_sequence(header, PoolCreationMode::Highest)
    }

    fn new_picture(&mut self, timestamp: u64) -> NewPictureResult<Self::Picture> {
        let highest_pool = self.highest_pool();
        let surface = highest_pool
            .get_surface()
            .ok_or(NewPictureError::OutOfOutputBuffers)?;

        let metadata = self.metadata_state.get_parsed()?;

        Ok(VaPicture::new(
            timestamp,
            Rc::clone(&metadata.context),
            surface,
        ))
    }

    fn submit_picture(
        &mut self,
        mut picture: Self::Picture,
        hdr: &Header,
        last_ref: &Option<Self::Handle>,
        golden_ref: &Option<Self::Handle>,
        alt_ref: &Option<Self::Handle>,
        bitstream: &[u8],
        segmentation: &Segmentation,
        mb_lf_adjust: &MbLfAdjustments,
    ) -> StatelessBackendResult<Self::Handle> {
        let highest_pool = self.highest_pool();
        let last_ref = va_surface_id(last_ref);
        let golden_ref = va_surface_id(golden_ref);
        let alt_ref = va_surface_id(alt_ref);

        let coded_resolution = highest_pool.coded_resolution();
        let metadata = self.metadata_state.get_parsed()?;
        let context = &metadata.context;

        let iq_buffer = context
            .create_buffer(build_iq_matrix(hdr, segmentation)?)
            .context("while creating IQ matrix buffer")?;

        let probs = context
            .create_buffer(build_probability_table(hdr))
            .context("while creating probability table buffer")?;

        let pic_param = context
            .create_buffer(build_pic_param(
                hdr,
                &coded_resolution,
                segmentation,
                mb_lf_adjust,
                last_ref,
                golden_ref,
                alt_ref,
            )?)
            .context("while creating pic params buffer")?;

        let slice_param = context
            .create_buffer(build_slice_param(hdr, bitstream.len())?)
            .context("while creating slice params buffer")?;

        let slice_data = context
            .create_buffer(libva::BufferType::SliceData(Vec::from(bitstream)))
            .context("while creating slice data buffer")?;

        // Add buffers with the parsed data.
        picture.add_buffer(iq_buffer);
        picture.add_buffer(probs);
        picture.add_buffer(pic_param);
        picture.add_buffer(slice_param);
        picture.add_buffer(slice_data);

        self.process_picture::<Vp8>(picture)
    }
}

impl<M: SurfaceMemoryDescriptor + 'static> StatelessDecoder<Vp8, VaapiBackend<M>> {
    // Creates a new instance of the decoder using the VAAPI backend.
    pub fn new_vaapi<S>(
        display: Rc<Display>,
        blocking_mode: BlockingMode,
    ) -> Result<Self, NewStatelessDecoderError>
    where
        M: From<S>,
        S: From<M>,
    {
        Self::new(VaapiBackend::new(display, false), blocking_mode)
    }
}

#[cfg(test)]
mod tests {
    use libva::BufferType;
    use libva::Display;
    use libva::IQMatrix;
    use libva::PictureParameter;
    use libva::SliceParameter;

    use crate::codec::vp8::parser::Parser;
    use crate::decoder::stateless::tests::test_decode_stream;
    use crate::decoder::stateless::tests::TestStream;
    use crate::decoder::stateless::StatelessDecoder;
    use crate::decoder::BlockingMode;
    use crate::utils::simple_playback_loop;
    use crate::utils::simple_playback_loop_owned_frames;
    use crate::utils::IvfIterator;
    use crate::DecodedFormat;
    use crate::Resolution;

    use super::*;

    /// Run `test` using the vaapi decoder, in both blocking and non-blocking modes.
    fn test_decoder_vaapi(
        test: &TestStream,
        output_format: DecodedFormat,
        blocking_mode: BlockingMode,
    ) {
        let display = Display::open().unwrap();
        let decoder = StatelessDecoder::<Vp8, _>::new_vaapi::<()>(display, blocking_mode).unwrap();

        test_decode_stream(
            |d, s, c| {
                simple_playback_loop(
                    d,
                    IvfIterator::new(s),
                    c,
                    &mut simple_playback_loop_owned_frames,
                    output_format,
                    blocking_mode,
                )
            },
            decoder,
            test,
            true,
            false,
        );
    }

    #[test]
    // Ignore this test by default as it requires libva-compatible hardware.
    #[ignore]
    fn test_25fps_block() {
        use crate::decoder::stateless::vp8::tests::DECODE_TEST_25FPS;
        test_decoder_vaapi(
            &DECODE_TEST_25FPS,
            DecodedFormat::NV12,
            BlockingMode::Blocking,
        );
    }

    #[test]
    // Ignore this test by default as it requires libva-compatible hardware.
    #[ignore]
    fn test_25fps_nonblock() {
        use crate::decoder::stateless::vp8::tests::DECODE_TEST_25FPS;
        test_decoder_vaapi(
            &DECODE_TEST_25FPS,
            DecodedFormat::NV12,
            BlockingMode::NonBlocking,
        );
    }

    #[test]
    /// Check that we are able to build the VA picture parameters from the stream properly.
    fn build_pic_params() {
        const TEST_STREAM: &[u8] = include_bytes!("../../../codec/vp8/test_data/test-25fps.vp8");
        const TEST_25_FPS_VP8_STREAM_PROBABILITY_TABLE_0: &[u8] =
            include_bytes!("../../../codec/vp8/test_data/test-25fps-vp8-probability-table-0.bin");
        const TEST_25_FPS_VP8_STREAM_PROBABILITY_TABLE_1: &[u8] =
            include_bytes!("../../../codec/vp8/test_data/test-25fps-vp8-probability-table-1.bin");
        const TEST_25_FPS_VP8_STREAM_PROBABILITY_TABLE_2: &[u8] =
            include_bytes!("../../../codec/vp8/test_data/test-25fps-vp8-probability-table-2.bin");

        let mut parser: Parser = Default::default();
        let mut ivf_iter = IvfIterator::new(TEST_STREAM);

        // FRAME 0

        let packet = ivf_iter.next().unwrap();
        assert_eq!(packet.len(), 14788);

        let frame = parser.parse_frame(packet).unwrap();

        let resolution = Resolution {
            width: frame.header.width as u32,
            height: frame.header.height as u32,
        };

        let pic_param = build_pic_param(
            &frame.header,
            &resolution,
            parser.segmentation(),
            parser.mb_lf_adjust(),
            libva::constants::VA_INVALID_SURFACE,
            libva::constants::VA_INVALID_SURFACE,
            libva::constants::VA_INVALID_SURFACE,
        )
        .unwrap();
        let pic_param = match pic_param {
            BufferType::PictureParameter(PictureParameter::VP8(pic_param)) => pic_param,
            _ => panic!(),
        };

        let iq_matrix = build_iq_matrix(&frame.header, parser.segmentation()).unwrap();
        let iq_matrix = match iq_matrix {
            BufferType::IQMatrix(IQMatrix::VP8(iq_matrix)) => iq_matrix,
            _ => panic!(),
        };

        let prob_table = build_probability_table(&frame.header);
        let prob_table = match prob_table {
            BufferType::Probability(prob_table) => prob_table,
            _ => panic!(),
        };

        let slice_param = build_slice_param(&frame.header, packet.len()).unwrap();
        let slice_param = match slice_param {
            BufferType::SliceParameter(SliceParameter::VP8(slice_param)) => slice_param,
            _ => panic!(),
        };

        assert_eq!(iq_matrix.inner().quantization_index, [[4; 6]; 4]);
        for i in 0..4 {
            for j in 0..8 {
                for k in 0..3 {
                    for l in 0..11 {
                        const OFF_I: usize = 8 * 3 * 11;
                        const OFF_J: usize = 3 * 11;
                        const OFF_K: usize = 11;
                        // maybe std::transmute?
                        assert_eq!(
                            prob_table.inner().dct_coeff_probs[i][j][k][l],
                            TEST_25_FPS_VP8_STREAM_PROBABILITY_TABLE_0
                                [(i * OFF_I) + (j * OFF_J) + (k * OFF_K) + l]
                        );
                    }
                }
            }
        }

        assert_eq!(pic_param.inner().frame_width, 320);
        assert_eq!(pic_param.inner().frame_height, 240);
        assert_eq!(
            pic_param.inner().last_ref_frame,
            libva::constants::VA_INVALID_SURFACE
        );
        assert_eq!(
            pic_param.inner().golden_ref_frame,
            libva::constants::VA_INVALID_SURFACE
        );
        assert_eq!(
            pic_param.inner().alt_ref_frame,
            libva::constants::VA_INVALID_SURFACE
        );
        assert_eq!(
            pic_param.inner().out_of_loop_frame,
            libva::constants::VA_INVALID_SURFACE
        );

        // Safe because this bitfield is initialized by the decoder.
        assert_eq!(unsafe { pic_param.inner().pic_fields.value }, unsafe {
            libva::VP8PicFields::new(0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1)
                .inner()
                .value
        });

        assert_eq!(pic_param.inner().mb_segment_tree_probs, [0; 3]);
        assert_eq!(pic_param.inner().loop_filter_level, [0; 4]);
        assert_eq!(
            pic_param.inner().loop_filter_deltas_ref_frame,
            [2, 0, -2, -2]
        );
        assert_eq!(pic_param.inner().loop_filter_deltas_mode, [4, -2, 2, 4]);
        assert_eq!(pic_param.inner().prob_skip_false, 0xbe);
        assert_eq!(pic_param.inner().prob_intra, 0);
        assert_eq!(pic_param.inner().prob_last, 0);
        assert_eq!(pic_param.inner().prob_gf, 0);

        assert_eq!(pic_param.inner().y_mode_probs, [0x91, 0x9c, 0xa3, 0x80]);
        assert_eq!(pic_param.inner().uv_mode_probs, [0x8e, 0x72, 0xb7]);
        assert_eq!(
            pic_param.inner().mv_probs[0],
            [
                0xa2, 0x80, 0xe1, 0x92, 0xac, 0x93, 0xd6, 0x27, 0x9c, 0x80, 0x81, 0x84, 0x4b, 0x91,
                0xb2, 0xce, 0xef, 0xfe, 0xfe
            ]
        );
        assert_eq!(
            pic_param.inner().mv_probs[1],
            [
                0xa4, 0x80, 0xcc, 0xaa, 0x77, 0xeb, 0x8c, 0xe6, 0xe4, 0x80, 0x82, 0x82, 0x4a, 0x94,
                0xb4, 0xcb, 0xec, 0xfe, 0xfe,
            ]
        );

        assert_eq!(pic_param.inner().bool_coder_ctx.range, 0xfc);
        assert_eq!(pic_param.inner().bool_coder_ctx.value, 0x39);
        assert_eq!(pic_param.inner().bool_coder_ctx.count, 0x0);

        assert_eq!(
            slice_param.inner(),
            libva::SliceParameterBufferVP8::new(
                14788,
                10,
                0,
                3040,
                2,
                [926, 13472, 0, 0, 0, 0, 0, 0, 0],
            )
            .inner(),
        );

        // FRAME 1

        let packet = ivf_iter.next().unwrap();
        assert_eq!(packet.len(), 257);

        let frame = parser.parse_frame(packet).unwrap();

        let pic_param = build_pic_param(
            &frame.header,
            &resolution,
            parser.segmentation(),
            parser.mb_lf_adjust(),
            0,
            0,
            0,
        )
        .unwrap();
        let pic_param = match pic_param {
            BufferType::PictureParameter(PictureParameter::VP8(pic_param)) => pic_param,
            _ => panic!(),
        };

        let iq_matrix = build_iq_matrix(&frame.header, parser.segmentation()).unwrap();
        let iq_matrix = match iq_matrix {
            BufferType::IQMatrix(IQMatrix::VP8(iq_matrix)) => iq_matrix,
            _ => panic!(),
        };

        let prob_table = build_probability_table(&frame.header);
        let prob_table = match prob_table {
            BufferType::Probability(prob_table) => prob_table,
            _ => panic!(),
        };

        let slice_param = build_slice_param(&frame.header, packet.len()).unwrap();
        let slice_param = match slice_param {
            BufferType::SliceParameter(SliceParameter::VP8(slice_param)) => slice_param,
            _ => panic!(),
        };

        assert_eq!(iq_matrix.inner().quantization_index, [[0x7f; 6]; 4]);
        for i in 0..4 {
            for j in 0..8 {
                for k in 0..3 {
                    for l in 0..11 {
                        const OFF_I: usize = 8 * 3 * 11;
                        const OFF_J: usize = 3 * 11;
                        const OFF_K: usize = 11;
                        // maybe std::transmute?
                        assert_eq!(
                            prob_table.inner().dct_coeff_probs[i][j][k][l],
                            TEST_25_FPS_VP8_STREAM_PROBABILITY_TABLE_1
                                [(i * OFF_I) + (j * OFF_J) + (k * OFF_K) + l]
                        );
                    }
                }
            }
        }
        assert_eq!(pic_param.inner().frame_width, 320);
        assert_eq!(pic_param.inner().frame_height, 240);
        assert_eq!(pic_param.inner().last_ref_frame, 0);
        assert_eq!(pic_param.inner().golden_ref_frame, 0);
        assert_eq!(pic_param.inner().alt_ref_frame, 0);
        assert_eq!(
            pic_param.inner().out_of_loop_frame,
            libva::constants::VA_INVALID_SURFACE
        );

        // Safe because this bitfield is initialized by the decoder.
        assert_eq!(unsafe { pic_param.inner().pic_fields.value }, unsafe {
            libva::VP8PicFields::new(1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0)
                .inner()
                .value
        });

        assert_eq!(pic_param.inner().mb_segment_tree_probs, [0; 3]);
        assert_eq!(pic_param.inner().loop_filter_level, [44; 4]);
        assert_eq!(
            pic_param.inner().loop_filter_deltas_ref_frame,
            [2, 0, -2, -2]
        );
        assert_eq!(pic_param.inner().loop_filter_deltas_mode, [4, -2, 2, 4]);
        assert_eq!(pic_param.inner().prob_skip_false, 0x11);
        assert_eq!(pic_param.inner().prob_intra, 0x2a);
        assert_eq!(pic_param.inner().prob_last, 0xff);
        assert_eq!(pic_param.inner().prob_gf, 0x80);

        assert_eq!(pic_param.inner().y_mode_probs, [0x70, 0x56, 0x8c, 0x25]);
        assert_eq!(pic_param.inner().uv_mode_probs, [0xa2, 0x65, 0xcc]);
        assert_eq!(
            pic_param.inner().mv_probs[0],
            [
                0xa2, 0x80, 0xe1, 0x92, 0xac, 0x93, 0xd6, 0x27, 0x9c, 0x80, 0x81, 0x84, 0x4b, 0x91,
                0xb2, 0xce, 0xef, 0xfe, 0xfe,
            ]
        );
        assert_eq!(
            pic_param.inner().mv_probs[1],
            [
                0xa4, 0x80, 0xcc, 0xaa, 0x77, 0xeb, 0x8c, 0xe6, 0xe4, 0x80, 0x82, 0x82, 0x4a, 0x94,
                0xb4, 0xcb, 0xec, 0xfe, 0xfe,
            ]
        );

        assert_eq!(pic_param.inner().bool_coder_ctx.range, 0xde);
        assert_eq!(pic_param.inner().bool_coder_ctx.value, 0x39);
        assert_eq!(pic_param.inner().bool_coder_ctx.count, 0x7);

        assert_eq!(
            slice_param.inner(),
            libva::SliceParameterBufferVP8::new(257, 3, 0, 129, 2, [143, 94, 0, 0, 0, 0, 0, 0, 0],)
                .inner()
        );

        // FRAME 2

        let packet = ivf_iter.next().unwrap();
        assert_eq!(packet.len(), 131);

        let frame = parser.parse_frame(packet).unwrap();

        let pic_param = build_pic_param(
            &frame.header,
            &resolution,
            parser.segmentation(),
            parser.mb_lf_adjust(),
            1,
            0,
            0,
        )
        .unwrap();
        let pic_param = match pic_param {
            BufferType::PictureParameter(PictureParameter::VP8(pic_param)) => pic_param,
            _ => panic!(),
        };

        let iq_matrix = build_iq_matrix(&frame.header, parser.segmentation()).unwrap();
        let iq_matrix = match iq_matrix {
            BufferType::IQMatrix(IQMatrix::VP8(iq_matrix)) => iq_matrix,
            _ => panic!(),
        };

        let prob_table = build_probability_table(&frame.header);
        let prob_table = match prob_table {
            BufferType::Probability(prob_table) => prob_table,
            _ => panic!(),
        };

        let slice_param = build_slice_param(&frame.header, packet.len()).unwrap();
        let slice_param = match slice_param {
            BufferType::SliceParameter(SliceParameter::VP8(slice_param)) => slice_param,
            _ => panic!(),
        };

        assert_eq!(iq_matrix.inner().quantization_index, [[0x7f; 6]; 4]);
        for i in 0..4 {
            for j in 0..8 {
                for k in 0..3 {
                    for l in 0..11 {
                        const OFF_I: usize = 8 * 3 * 11;
                        const OFF_J: usize = 3 * 11;
                        const OFF_K: usize = 11;
                        // maybe std::transmute?
                        assert_eq!(
                            prob_table.inner().dct_coeff_probs[i][j][k][l],
                            TEST_25_FPS_VP8_STREAM_PROBABILITY_TABLE_2
                                [(i * OFF_I) + (j * OFF_J) + (k * OFF_K) + l]
                        );
                    }
                }
            }
        }
        assert_eq!(pic_param.inner().frame_width, 320);
        assert_eq!(pic_param.inner().frame_height, 240);
        assert_eq!(pic_param.inner().last_ref_frame, 1);
        assert_eq!(pic_param.inner().golden_ref_frame, 0);
        assert_eq!(pic_param.inner().alt_ref_frame, 0);
        assert_eq!(
            pic_param.inner().out_of_loop_frame,
            libva::constants::VA_INVALID_SURFACE
        );

        // Safe because this bitfield is initialized by the decoder.
        assert_eq!(unsafe { pic_param.inner().pic_fields.value }, unsafe {
            libva::VP8PicFields::new(1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0)
                .inner()
                .value
        });

        assert_eq!(pic_param.inner().mb_segment_tree_probs, [0; 3]);
        assert_eq!(pic_param.inner().loop_filter_level, [28; 4]);
        assert_eq!(
            pic_param.inner().loop_filter_deltas_ref_frame,
            [2, 0, -2, -2]
        );
        assert_eq!(pic_param.inner().loop_filter_deltas_mode, [4, -2, 2, 4]);
        assert_eq!(pic_param.inner().prob_skip_false, 0x6);
        assert_eq!(pic_param.inner().prob_intra, 0x1);
        assert_eq!(pic_param.inner().prob_last, 0xf8);
        assert_eq!(pic_param.inner().prob_gf, 0xff);

        assert_eq!(pic_param.inner().y_mode_probs, [0x70, 0x56, 0x8c, 0x25]);
        assert_eq!(pic_param.inner().uv_mode_probs, [0xa2, 0x65, 0xcc]);
        assert_eq!(
            pic_param.inner().mv_probs[0],
            [
                0xa2, 0x80, 0xe1, 0x92, 0xac, 0x93, 0xd6, 0x27, 0x9c, 0x80, 0x81, 0x84, 0x4b, 0x91,
                0xb2, 0xce, 0xef, 0xfe, 0xfe,
            ]
        );
        assert_eq!(
            pic_param.inner().mv_probs[1],
            [
                0xa4, 0x80, 0xcc, 0xaa, 0x77, 0xeb, 0x8c, 0xe6, 0xe4, 0x80, 0x82, 0x82, 0x4a, 0x94,
                0xb4, 0xcb, 0xec, 0xfe, 0xfe,
            ]
        );

        assert_eq!(pic_param.inner().bool_coder_ctx.range, 0xb1);
        assert_eq!(pic_param.inner().bool_coder_ctx.value, 0xd);
        assert_eq!(pic_param.inner().bool_coder_ctx.count, 0x2);

        assert_eq!(
            slice_param.inner(),
            libva::SliceParameterBufferVP8::new(131, 3, 0, 86, 2, [66, 51, 0, 0, 0, 0, 0, 0, 0],)
                .inner()
        );
    }
}