use crate::partition::BlockSize;
use crate::predict::PREDICTION_MODES;
use crate::serialize::{Deserialize, Serialize};
use crate::transform::TX_TYPES;
#[cfg(feature = "serialize")]
use serde_big_array::BigArray;
use std::ops::{Add, AddAssign};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct EncoderStats {
pub block_size_counts: [usize; BlockSize::BLOCK_SIZES_ALL],
pub skip_block_count: usize,
pub tx_type_counts: [usize; TX_TYPES],
#[serde(with = "BigArray")]
pub luma_pred_mode_counts: [usize; PREDICTION_MODES],
#[serde(with = "BigArray")]
pub chroma_pred_mode_counts: [usize; PREDICTION_MODES],
}
impl Default for EncoderStats {
fn default() -> Self {
let luma_pred_mode_counts = [0; PREDICTION_MODES];
let chroma_pred_mode_counts = [0; PREDICTION_MODES];
EncoderStats {
block_size_counts: [0; BlockSize::BLOCK_SIZES_ALL],
skip_block_count: 0,
tx_type_counts: [0; TX_TYPES],
luma_pred_mode_counts,
chroma_pred_mode_counts,
}
}
}
impl Add<&Self> for EncoderStats {
type Output = Self;
fn add(self, rhs: &EncoderStats) -> Self::Output {
let mut lhs = self;
lhs += rhs;
lhs
}
}
impl AddAssign<&Self> for EncoderStats {
fn add_assign(&mut self, rhs: &EncoderStats) {
for (s, v) in
self.block_size_counts.iter_mut().zip(rhs.block_size_counts.iter())
{
*s += v;
}
for (s, v) in self
.chroma_pred_mode_counts
.iter_mut()
.zip(rhs.chroma_pred_mode_counts.iter())
{
*s += v;
}
for (s, v) in self
.luma_pred_mode_counts
.iter_mut()
.zip(rhs.luma_pred_mode_counts.iter())
{
*s += v;
}
for (s, v) in self.tx_type_counts.iter_mut().zip(rhs.tx_type_counts.iter())
{
*s += v;
}
self.skip_block_count += rhs.skip_block_count;
}
}