let step_idx = br.read(2)? as usize;
blk.y_avg = br.read(5)? as u8 * 2;
for (dst, &sign) in blk.y.iter_mut().zip(E130_Y_SIGNS[sign_idx].iter()) {
- *dst = (i16::from(blk.y_avg) + i16::from(sign) * Y_STEPS[step_idx]).max(0).min(0x3F) as u8;
+ *dst = (i16::from(blk.y_avg) + i16::from(sign) * Y_STEPS[step_idx]).clamp(0, 0x3F) as u8;
}
} else if br.read_bool()? {
blk.y_avg = if br.read_bool()? {
];
// generated the same way as 15-bit YUV2RGB table but with an additional bit of luma
-const YUV655TAB: [u16; 65536] = [
+static YUV655TAB: [u16; 65536] = [
0x0000, 0x0000, 0x0421, 0x0421, 0x0842, 0x0842, 0x0C63, 0x0C63,
0x1084, 0x1084, 0x14A5, 0x14A5, 0x18C6, 0x18C6, 0x1CE7, 0x1CE7,
0x2108, 0x2108, 0x2529, 0x2529, 0x294A, 0x294A, 0x2D6B, 0x2D6B,
*el = r | (g << 5) | (b << 10);
}
*/
-pub const YUV2RGB: [u16; 32768] = [
+pub static YUV2RGB: [u16; 32768] = [
0x0000, 0x0421, 0x0842, 0x0C63, 0x1084, 0x14A5, 0x18C6, 0x1CE7,
0x2108, 0x2529, 0x294A, 0x2D6B, 0x318C, 0x35AD, 0x39CE, 0x3DEF,
0x4210, 0x4631, 0x4A52, 0x4E73, 0x5294, 0x56B5, 0x5AD6, 0x5EF7,
let mut counts = [0; 256];
for entry in arr.iter() {
let idx = match component {
- 0 | 1 | 2 | 3 => entry.y[component],
+ 0..=3 => entry.y[component],
4 => entry.u,
_ => entry.v,
} as usize;
let mut dst = vec![YUVCode::default(); arr.len()];
for entry in arr.iter() {
let idx = match component {
- 0 | 1 | 2 | 3 => entry.y[component],
+ 0..=3 => entry.y[component],
4 => entry.u,
_ => entry.v,
} as usize;
if let Some(ref vbuf) = buf.get_vbuf() {
if self.nstrips == 0 {
let (w, h) = vbuf.get_dimensions(0);
- self.nstrips = ((((w * h) >> 4) + 1200) / 2400).max(1).min(3);
+ self.nstrips = ((((w * h) >> 4) + 1200) / 2400).clamp(1, 3);
let strip_h = ((h + self.nstrips - 1) / self.nstrips + 3) & !3;
self.nstrips = (h + strip_h - 1) / strip_h;
}
for j in 0..8 {
for k in 0..8 {
- let mut v = blk[0][k + j * 8] + 128;
- if v < 0 { v = 0; } else if v > 255 { v = 255; }
- framebuf[idxy + k] = v as u8;
+ framebuf[idxy + k] = (blk[0][k + j * 8] + 128).clamp(0, 255) as u8;
}
for k in 0..8 {
- let mut v = blk[1][k + j * 8] + 128;
- if v < 0 { v = 0; } else if v > 255 { v = 255; }
- framebuf[idxy + k + 8] = v as u8;
+ framebuf[idxy + k + 8] = (blk[1][k + j * 8] + 128).clamp(0, 255) as u8;
}
idxy += stridey;
}
for j in 0..8 {
for k in 0..8 {
- let mut v = blk[2][k + j * 8] + 128;
- if v < 0 { v = 0; } else if v > 255 { v = 255; }
- framebuf[idxy + k] = v as u8;
+ framebuf[idxy + k] = (blk[2][k + j * 8] + 128).clamp(0, 255) as u8;
}
for k in 0..8 {
- let mut v = blk[3][k + j * 8] + 128;
- if v < 0 { v = 0; } else if v > 255 { v = 255; }
- framebuf[idxy + k + 8] = v as u8;
+ framebuf[idxy + k + 8] = (blk[3][k + j * 8] + 128).clamp(0, 255) as u8;
}
idxy += stridey;
}
for j in 0..8 {
for k in 0..8 {
- let mut v = blk[4][k + j * 8] + 128;
- if v < 0 { v = 0; } else if v > 255 { v = 255; }
- framebuf[idxu + k] = v as u8;
+ framebuf[idxu + k] = (blk[4][k + j * 8] + 128).clamp(0, 255) as u8;
}
for k in 0..8 {
- let mut v = blk[5][k + j * 8] + 128;
- if v < 0 { v = 0; } else if v > 255 { v = 255; }
- framebuf[idxv + k] = v as u8;
+ framebuf[idxv + k] = (blk[5][k + j * 8] + 128).clamp(0, 255) as u8;
}
idxu += strideu;
idxv += stridev;
for _y in 0..blk_h {
for x in 0..blk_w {
let scale = u32::from(*cur_w.next().unwrap());
- let val = (i16::from(sbuf[soff + x]) + bias).max(0).min(255) as u32;
+ let val = (i16::from(sbuf[soff + x]) + bias).clamp(0, 255) as u32;
dbuf[doff + x] += scale | ((val * scale) << 8);
}
soff += sstride;
}
fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
let src = pkt.get_buffer();
- validate!(src.len() > 0);
+ validate!(!src.is_empty());
for sd in pkt.side_data.iter() {
if let NASideData::Palette(true, ref pal) = sd {
fn put_block(blk: &[i16; 64], dst: &mut [u8], stride: usize) {
for (drow, srow) in dst.chunks_mut(stride).zip(blk.chunks(8)) {
for (del, &pix) in drow.iter_mut().zip(srow.iter()) {
- *del = pix.max(0).min(255) as u8;
+ *del = pix.clamp(0, 255) as u8;
}
}
}
}
} else {
if idx < 62 {
- (self.prev_pitch - 10).max(30).min(281 - 19) * 3 + idx - 2
+ (self.prev_pitch - 10).clamp(30, 281 - 19) * 3 + idx - 2
} else {
self.prev_pitch * 3
}
idx * 3 - 335
}
} else {
- idx + (self.prev_pitch - 5).max(20).min(134) * 3 - 1
+ idx + (self.prev_pitch - 5).clamp(20, 134) * 3 - 1
};
self.pitch_int = (pitch_idx * 10923) >> 15;
let pitch_frac = (pitch_idx as i32) - (self.pitch_int as i32) * 3 - 1;
mask[band] = (mask[band] - self.snroffset - i32::from(floor)).max(0) & 0x1FE0;
mask[band] += i32::from(floor);
while bin < lastbin {
- let addr = ((i32::from(self.psd[bin]) - mask[band]) >> 5).min(63).max(0) as usize;
+ let addr = ((i32::from(self.psd[bin]) - mask[band]) >> 5).clamp(0, 63) as usize;
self.bap[bin] = TS102366_BAPTAB[addr];
bin += 1;
}
let b = f32::from(src[boff + x]);
let (y, u, v) = matrix_mul(&self.matrix, r, g, b);
- dst[yoff + x] = (y as i16).max(0).min(255) as u8;
- dst[uoff + x] = ((u as i16).max(-128).min(127) + 128) as u8;
- dst[voff + x] = ((v as i16).max(-128).min(127) + 128) as u8;
+ dst[yoff + x] = (y as i16).clamp(0, 255) as u8;
+ dst[uoff + x] = ((u as i16).clamp(-128, 127) + 128) as u8;
+ dst[voff + x] = ((v as i16).clamp(-128, 127) + 128) as u8;
}
roff += istrides[0];
goff += istrides[1];
let b = f32::from(src[boff + x]);
let (y, _u, _v) = matrix_mul(&self.matrix, r, g, b);
- dst[yoff + x] = (y as i16).max(0).min(255) as u8;
+ dst[yoff + x] = (y as i16).clamp(0, 255) as u8;
}
roff += istrides[0];
goff += istrides[1];
let r = y + self.r_chr[v];
let g = y + self.g_u[u] + self.g_v[v];
let b = y + self.b_chr[u];
- dst[roff + x] = r.max(0).min(255) as u8;
- dst[goff + x] = g.max(0).min(255) as u8;
- dst[boff + x] = b.max(0).min(255) as u8;
+ dst[roff + x] = r.clamp(0, 255) as u8;
+ dst[goff + x] = g.clamp(0, 255) as u8;
+ dst[boff + x] = b.clamp(0, 255) as u8;
}
roff += dstrides[0];
goff += dstrides[1];
let v = f32::from(i16::from(src[voff + (x >> sv1)]) - 128);
let (r, g, b) = matrix_mul(&self.matrix, y, u, v);
- dst[roff + x] = (r as i16).max(0).min(255) as u8;
- dst[goff + x] = (g as i16).max(0).min(255) as u8;
- dst[boff + x] = (b as i16).max(0).min(255) as u8;
+ dst[roff + x] = (r as i16).clamp(0, 255) as u8;
+ dst[goff + x] = (g as i16).clamp(0, 255) as u8;
+ dst[boff + x] = (b as i16).clamp(0, 255) as u8;
}
roff += dstrides[0];
goff += dstrides[1];
let r = y + self.r_chr[128];
let g = y + self.g_u[128] + self.g_v[128];
let b = y + self.b_chr[128];
- dst[roff + x] = r.max(0).min(255) as u8;
- dst[goff + x] = g.max(0).min(255) as u8;
- dst[boff + x] = b.max(0).min(255) as u8;
+ dst[roff + x] = r.clamp(0, 255) as u8;
+ dst[goff + x] = g.clamp(0, 255) as u8;
+ dst[boff + x] = b.clamp(0, 255) as u8;
}
roff += dstrides[0];
goff += dstrides[1];
for x in 0..w {
let y = f32::from(src[yoff + x]);
let (r, g, b) = matrix_mul(&self.matrix, y, 0.0, 0.0);
- dst[roff + x] = (r as i16).max(0).min(255) as u8;
- dst[goff + x] = (g as i16).max(0).min(255) as u8;
- dst[boff + x] = (b as i16).max(0).min(255) as u8;
+ dst[roff + x] = (r as i16).clamp(0, 255) as u8;
+ dst[goff + x] = (g as i16).clamp(0, 255) as u8;
+ dst[boff + x] = (b as i16).clamp(0, 255) as u8;
}
roff += dstrides[0];
goff += dstrides[1];
}
pub fn make_pal(&self, pal: &mut [[u8; 3]; 256]) {
for (pal, node) in pal.iter_mut().zip(self.weights.iter()) {
- pal[0] = (node[0] + 0.5).max(0.0).min(255.0) as u8;
- pal[1] = (node[1] + 0.5).max(0.0).min(255.0) as u8;
- pal[2] = (node[2] + 0.5).max(0.0).min(255.0) as u8;
+ pal[0] = (node[0] + 0.5).clamp(0.0, 255.0) as u8;
+ pal[1] = (node[1] + 0.5).clamp(0.0, 255.0) as u8;
+ pal[2] = (node[2] + 0.5).clamp(0.0, 255.0) as u8;
}
}
}
fn cvt_from(val: u16) -> Self { usize::from(val) }
}
impl CustomFrom<f32> for u8 {
- fn cvt_from(val: f32) -> Self { val.max(0.0).min(255.0) as u8 }
+ fn cvt_from(val: f32) -> Self { val.clamp(0.0, 255.0) as u8 }
}
impl CustomFrom<f32> for u16 {
- fn cvt_from(val: f32) -> Self { val.max(0.0).min(65535.0) as u16 }
+ fn cvt_from(val: f32) -> Self { val.clamp(0.0, 65535.0) as u16 }
}
impl CustomFrom<u8> for f32 {
fn cvt_from(val: u8) -> Self { val as f32 }
}
impl FromFmt<i16> for u8 {
- fn cvt_from(val: i16) -> u8 { ((val >> 8) + 128).min(255).max(0) as u8 }
+ fn cvt_from(val: i16) -> u8 { ((val >> 8) + 128).clamp(0, 255) as u8 }
}
impl FromFmt<i16> for i16 {
fn cvt_from(val: i16) -> i16 { val }
}
impl FromFmt<i32> for u8 {
- fn cvt_from(val: i32) -> u8 { ((val >> 24) + 128).min(255).max(0) as u8 }
+ fn cvt_from(val: i32) -> u8 { ((val >> 24) + 128).clamp(0, 255) as u8 }
}
impl FromFmt<i32> for i16 {
fn cvt_from(val: i32) -> i16 { (val >> 16) as i16 }
}
impl FromFmt<f32> for u8 {
- fn cvt_from(val: f32) -> u8 { ((val * 128.0) + 128.0).min(255.0).max(0.0) as u8 }
+ fn cvt_from(val: f32) -> u8 { ((val * 128.0) + 128.0).clamp(0.0, 255.0) as u8 }
}
impl FromFmt<f32> for i16 {
- fn cvt_from(val: f32) -> i16 { (val * 32768.0).min(32767.0).max(-32768.0) as i16 }
+ fn cvt_from(val: f32) -> i16 { (val * 32768.0).clamp(-32768.0, 32767.0) as i16 }
}
impl FromFmt<f32> for i32 {
fn cvt_from(val: f32) -> i32 {
*coef = norm;
continue;
}
- let wval = f64::from((pos * win_scale).max(-1.0).min(1.0));
+ let wval = f64::from((pos * win_scale).clamp(-1.0, 1.0));
let win = bessel_i0(BESSEL_BETA - (1.0 - wval * wval).sqrt()) as f32;
*coef = norm * (pos * sinc_scale).sinc() * win;
}
for x in 0..4 {
d += ydeltas[x + y * 4];
last[x] += d;
- dst[yoff + x] = last[x].max(0).min(255) as u8;
+ dst[yoff + x] = last[x].clamp(0, 255) as u8;
}
self.dy[y] = d;
yoff += ystride;
let y = i16::from(self.cur_frame.ydata[ysrc + x]);
let u = self.cur_frame.udata[csrc + (x >> 1)];
let v = self.cur_frame.vdata[csrc + (x >> 1)];
- pic[offs[0]] = (y + u).max(0).min(255) as u8;
- pic[offs[1]] = y.max(0).min(255) as u8;
- pic[offs[2]] = (y + v).max(0).min(255) as u8;
+ pic[offs[0]] = (y + u).clamp(0, 255) as u8;
+ pic[offs[1]] = y.clamp(0, 255) as u8;
+ pic[offs[2]] = (y + v).clamp(0, 255) as u8;
}
off += stride;
ysrc += self.cur_frame.ystride;
let y = self.cur_frame.ydata[pos + x];
let u = self.cur_frame.udata[pos + x];
let v = self.cur_frame.vdata[pos + x];
- dst[offs[0] + x] = y.max(0).min(255) as u8;
- dst[offs[1] + x] = u.max(0).min(255) as u8;
- dst[offs[2] + x] = v.max(0).min(255) as u8;
+ dst[offs[0] + x] = y.clamp(0, 255) as u8;
+ dst[offs[1] + x] = u.clamp(0, 255) as u8;
+ dst[offs[2] + x] = v.clamp(0, 255) as u8;
}
for c in 0..3 {
offs[c] += strides[c];
let delta = delta_tab[br.read(dbits)? as usize];
diff += delta;
let pred = if y > 0 { dst[off + x - stride].into() } else if !is_chroma { 0 } else { 0x80 };
- dst[off + x] = (pred + diff).min(255).max(0) as u8;
+ dst[off + x] = (pred + diff).clamp(0, 255) as u8;
if hscale {
dst[off + x + 1] = dst[off + x];
}
bw.write(idx as u32, self.dbits);
hor_pred += ndelta;
- *pred = (i16::from(*pred) + hor_pred).max(0).min(255) as u8;
+ *pred = (i16::from(*pred) + hor_pred).clamp(0, 255) as u8;
}
}
if src.err == ERR_MAX {
continue;
}
- let nval = i32::from((top_val + src.hpred + delta).max(0).min(255));
+ let nval = i32::from((top_val + src.hpred + delta).clamp(0, 255));
let new_err = src.err + (((nval - pix_val) * (nval - pix_val)) as u32);
if new_err < dst.err {
dst.err = new_err;
for (pred, &idx) in self.top_line.iter_mut().step_by(step).zip(self.indices.iter()) {
bw.write(u32::from(idx), self.dbits);
hor_pred += delta_tab[usize::from(idx)];
- *pred = (i16::from(*pred) + hor_pred).max(0).min(255) as u8;
+ *pred = (i16::from(*pred) + hor_pred).clamp(0, 255) as u8;
}
}
fn expand_token(blk: &mut Block, br: &mut BitReader, eob_run: &mut usize, token: u8) -> DecoderResult<()> {
match token {
// EOBs
- 0 | 1 | 2 => { *eob_run = (token as usize) + 1; },
- 3 | 4 | 5 => {
+ 0..=2 => { *eob_run = (token as usize) + 1; },
+ 3..=5 => {
let bits = token - 1;
*eob_run = (br.read(bits)? as usize) + (1 << bits);
},
validate!(blk.idx <= 64);
},
// single coefficients
- 9 | 10 | 11 | 12 => {
+ 9..=12 => {
let val = (i16::from(token) - 7) >> 1;
if (token & 1) == 1 {
blk.coeffs[ZIGZAG[blk.idx]] = val;
}
blk.idx += 1;
},
- 13 | 14 | 15 | 16 => {
+ 13..= 16 => {
let val = i16::from(token) - 10;
if !br.read_bool()? {
blk.coeffs[ZIGZAG[blk.idx]] = val;
}
blk.idx += 1;
},
- 17 | 18 | 19 | 20 | 21 | 22 => {
+ 17..=22 => {
let add_bits = if token == 22 { 9 } else { token - 16 };
let sign = br.read_bool()?;
let val = (br.read(add_bits)? as i16) + VP3_LITERAL_BASE[(token - 17) as usize];
blk.idx += 1;
}
// zero run plus coefficient
- 23 | 24 | 25 | 26 | 27 => {
+ 23..=27 => {
blk.idx += (token - 22) as usize;
validate!(blk.idx < 64);
if !br.read_bool()? {
#[allow(clippy::collapsible_else_if)]
fn decode(&mut self, supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
let src = pkt.get_buffer();
- validate!(src.len() > 0);
+ validate!(!src.is_empty());
let mut br = BitReader::new(&src, BitReaderMode::BE);
self.parse_header(&mut br)?;
let tok = br.read_huff(huff)?;
match tok {
0 => Ok((0, false)),
- 1 | 2 | 3 | 4 => {
+ 1..=4 => {
if !br.read_bool()? {
Ok((i16::from(tok), false))
} else {
Ok((-i16::from(tok), false))
}
},
- 5 | 6 | 7 | 8 | 9 | 10 => {
+ 5..=10 => {
let base = (tok - 5) as usize;
let add_bits = br.read(VP6_COEF_ADD_BITS[base])? as i16;
let val = VP56_COEF_BASE[base] + add_bits;
if mb_type.is_intra() {
for (dblk, sblk) in blocks.iter_mut().zip(mb.coeffs.iter()) {
for (dcoef, &scoef) in dblk.iter_mut().zip(sblk.iter()) {
- *dcoef = (scoef + 128).max(0).min(255) as u8;
+ *dcoef = (scoef + 128).clamp(0, 255) as u8;
}
}
} else {
for (dblk, (sblk1, sblk2)) in blocks.iter_mut().zip(mb.coeffs.iter().zip(res_mb.iter())) {
for (dcoef, (&scoef1, &scoef2)) in dblk.iter_mut().zip(sblk1.iter().zip(sblk2.iter())) {
- *dcoef = (scoef1 + scoef2).max(0).min(255) as u8;
+ *dcoef = (scoef1 + scoef2).clamp(0, 255) as u8;
}
}
}
tmp_mb.idct();
for blk in tmp_mb.coeffs.iter_mut() {
for coef in blk.iter_mut() {
- *coef = (*coef + 128).max(0).min(255);
+ *coef = (*coef + 128).clamp(0, 255);
}
}
let intra_dist = calc_mb_dist(&self.src_mbs[mb_idx], &tmp_mb);
tmp_mb.idct();
for (blk, res) in tmp_mb.coeffs.iter_mut().zip(self.inter_mbs[mb_idx].reference.iter()) {
for (coef, add) in blk.iter_mut().zip(res.iter()) {
- *coef = (*coef + add).max(0).min(255);
+ *coef = (*coef + add).clamp(0, 255);
}
}
let inter_dist = calc_mb_dist(&self.src_mbs[mb_idx], &tmp_mb);
tmp_mb.idct();
for (blk, res) in tmp_mb.coeffs.iter_mut().zip(self.fourmv_mbs[mb_idx].reference.iter()) {
for (coef, add) in blk.iter_mut().zip(res.iter()) {
- *coef = (*coef + add).max(0).min(255);
+ *coef = (*coef + add).clamp(0, 255);
}
}
let fourmv_dist = calc_mb_dist(&self.src_mbs[mb_idx], &tmp_mb);
tmp_mb.idct();
for (blk, res) in tmp_mb.coeffs.iter_mut().zip(self.golden_mbs[mb_idx].reference.iter()) {
for (coef, add) in blk.iter_mut().zip(res.iter()) {
- *coef = (*coef + add).max(0).min(255);
+ *coef = (*coef + add).clamp(0, 255);
}
}
let golden_dist = calc_mb_dist(&self.src_mbs[mb_idx], &tmp_mb);
tmp_mb.idct();
for (blk, res) in tmp_mb.coeffs.iter_mut().zip(inter_mb.reference.iter()) {
for (coef, add) in blk.iter_mut().zip(res.iter()) {
- *coef = (*coef + add).max(0).min(255);
+ *coef = (*coef + add).clamp(0, 255);
}
}
let mut best_dist = calc_mb_dist(smb, &tmp_mb);
tmp_mb.idct();
for (blk, res) in tmp_mb.coeffs.iter_mut().zip(self.fourmv_mbs[mb_idx].reference.iter()) {
for (coef, add) in blk.iter_mut().zip(res.iter()) {
- *coef = (*coef + add).max(0).min(255);
+ *coef = (*coef + add).clamp(0, 255);
}
}
let fourmv_dist = calc_mb_dist(smb, &tmp_mb);
tmp_mb.idct();
for (blk, res) in tmp_mb.coeffs.iter_mut().zip(gold_mb.reference.iter()) {
for (coef, add) in blk.iter_mut().zip(res.iter()) {
- *coef = (*coef + add).max(0).min(255);
+ *coef = (*coef + add).clamp(0, 255);
}
}
let golden_dist = calc_mb_dist(smb, &tmp_mb);
tmp_mb.idct();
for blk in tmp_mb.coeffs.iter_mut() {
for coef in blk.iter_mut() {
- *coef = (*coef + 128).max(0).min(255);
+ *coef = (*coef + 128).clamp(0, 255);
}
}
let intra_dist = calc_mb_dist(smb, &tmp_mb);
use nihav_codec_support::codecs::blockdsp::edge_emu;
fn clip_u8(val: i16) -> u8 {
- val.max(0).min(255) as u8
+ val.clamp(0, 255) as u8
}
pub struct IPredContext {
use nihav_core::frame::*;
fn clip_u8(val: i16) -> u8 {
- val.max(0).min(255) as u8
+ val.clamp(0, 255) as u8
}
const DCT_COEFFS: [i32; 16] = [
let mut fade_lut = [0u8; 256];
for (i, el) in fade_lut.iter_mut().enumerate() {
let y = i as u16;
- *el = (y + ((y * beta) >> 8) + alpha).max(0).min(255) as u8;
+ *el = (y + ((y * beta) >> 8) + alpha).clamp(0, 255) as u8;
}
let (w, h) = srcfrm.get_dimensions(0);
pub fn get_difference_dist(old: &[u8; 16], new: &[u8; 16], diff: &[i16; 16]) -> u32 {
let mut dist = 0;
for ((&old, &new), &diff) in old.iter().zip(new.iter()).zip(diff.iter()) {
- let nval = (i16::from(new) + diff).max(0).min(255);
+ let nval = (i16::from(new) + diff).clamp(0, 255);
let oval = i16::from(old);
dist += (i32::from(nval - oval) * i32::from(nval - oval)) as u32;
}
for (x, blk) in src.iter().enumerate() {
for (drow, srow) in dst[x * 4..].chunks_mut(16).zip(blk.chunks(4)) {
for (del, &sel) in drow.iter_mut().zip(srow.iter()) {
- *del = (i16::from(*del) + sel).max(0).min(255) as u8;
+ *del = (i16::from(*del) + sel).clamp(0, 255) as u8;
}
}
}
for (x, blk) in src.iter().enumerate() {
for (drow, srow) in dst[x * 4..].chunks_mut(8).zip(blk.chunks(4)) {
for (del, &sel) in drow.iter_mut().zip(srow.iter()) {
- *del = (i16::from(*del) + sel).max(0).min(255) as u8;
+ *del = (i16::from(*del) + sel).clamp(0, 255) as u8;
}
}
}
blk.idct();
for (drow, srow) in dst[x * 4..].chunks_mut(8).zip(blk.chunks(4)) {
for (del, &sel) in drow.iter_mut().zip(srow.iter()) {
- *del = (i16::from(*del) + sel).max(0).min(255) as u8;
+ *del = (i16::from(*del) + sel).clamp(0, 255) as u8;
}
}
}
let nblk = &mut new[x * 4 + y * 4 * 16..];
for (dst, (src, res)) in nblk.chunks_mut(16).zip(yblk.chunks(4).zip(diff.chunks(4))) {
for (del, (&sel, &rel)) in dst.iter_mut().zip(src.iter().zip(res.iter())) {
- *del = (i16::from(sel) + rel).max(0).min(255) as u8;
+ *del = (i16::from(sel) + rel).clamp(0, 255) as u8;
}
}
impl VP7ProbCounter for ProbCounter {
fn to_prob8(self) -> u8 {
if self.total > 0 {
- ((self.zeroes << 8) / self.total).min(255).max(1) as u8
+ ((self.zeroes << 8) / self.total).clamp(1, 255) as u8
} else {
128
}
}
q
} else {
- ((((800.0 - nits_per_mb) / 155.0).exp() + 6.0) as usize).max(10).min(127)
+ ((((800.0 - nits_per_mb) / 155.0).exp() + 6.0) as usize).clamp(10, 127)
}
}
}
let loop_str = if self.dstate.seg_feature_mode {
segment.lf as u8
} else {
- (i16::from(self.dstate.loop_filter_level) + i16::from(segment.lf)).max(0).min(63) as u8
+ (i16::from(self.dstate.loop_filter_level) + i16::from(segment.lf)).clamp(0, 63) as u8
};
self.dstate.force_loop_str = Some(loop_str);
}
let q = if self.dstate.seg_feature_mode {
seg.quant.max(0) as usize
} else {
- ((y_ac_q as i16) + i16::from(seg.quant)).max(0).min(127) as usize
+ ((y_ac_q as i16) + i16::from(seg.quant)).clamp(0, 127) as usize
};
Self::set_single_qmat(qmat, q, q, q, q, q, q);
}
if self.mb_info[mb_idx].mb_type != VPMBType::Intra || self.mb_info[mb_idx].ymode == PredMode::BPred {
loop_str += self.dstate.lf_mode_delta[idx];
}
- self.mb_info[mb_idx].loop_str = loop_str.max(0).min(63) as u8;
+ self.mb_info[mb_idx].loop_str = loop_str.clamp(0, 63) as u8;
}
self.mb_info[mb_idx].inner_filt = has_coeffs || (self.mb_info[mb_idx].ymode == PredMode::BPred) || (self.mb_info[mb_idx].mb_type == VPMBType::InterFourMV);
}
use nihav_codec_support::codecs::blockdsp::edge_emu;
fn clip_u8(val: i16) -> u8 {
- val.max(0).min(255) as u8
+ val.clamp(0, 255) as u8
}
fn delta(p1: i16, p0: i16, q0: i16, q1: i16) -> i16 {
- ((p1 - q1).max(-128).min(127) + 3 * (q0 - p0)).max(-128).min(127)
+ ((p1 - q1).clamp(-128, 127) + 3 * (q0 - p0)).clamp(-128, 127)
}
pub type LoopFilterFunc = fn(buf: &mut [u8], off: usize, step: usize, stride: usize, len: usize, thr: i16, thr_inner: i16, thr_hev: i16);
buf[off - step * 3] = clip_u8(p2 + diff2);
buf[off + step * 2] = clip_u8(q2 - diff2);
} else {
- let diff = (3 * (q0 - p0)).max(-128).min(127);
+ let diff = (3 * (q0 - p0)).clamp(-128, 127);
let diffq0 = (diff + 4).min(127) >> 3;
let diffp0 = (diff + 3).min(127) >> 3;
buf[off - step * 1] = clip_u8(p0 + diffp0);
let s1 = i32::from($src[$off + 1 * $step]);
let a = (8 - $mode) as i32;
let b = $mode as i32;
- ((a * s0 + b * s1 + 4) >> 3).max(0).min(255) as u8
+ ((a * s0 + b * s1 + 4) >> 3).clamp(0, 255) as u8
}}
}
let mut off = frm.offset[plane] + bx * 8 + by * 8 * frm.stride[plane];
for y in 0..8 {
for x in 0..8 {
- frm.data[off + x] = (coeffs[x + y * 8] + 128).min(255).max(0) as u8;
+ frm.data[off + x] = (coeffs[x + y * 8] + 128).clamp(0, 255) as u8;
}
off += frm.stride[plane];
}
let mut off = frm.offset[plane] + bx * 8 + ((by & !1) * 8 + (by & 1)) * frm.stride[plane];
for y in 0..8 {
for x in 0..8 {
- frm.data[off + x] = (coeffs[x + y * 8] + 128).min(255).max(0) as u8;
+ frm.data[off + x] = (coeffs[x + y * 8] + 128).clamp(0, 255) as u8;
}
off += frm.stride[plane] * 2;
}
pub fn vp_put_block_dc(coeffs: &mut [i16; 64], bx: usize, by: usize, plane: usize, frm: &mut NASimpleVideoFrame<u8>) {
vp_idct_dc(coeffs);
- let dc = (coeffs[0] + 128).min(255).max(0) as u8;
+ let dc = (coeffs[0] + 128).clamp(0, 255) as u8;
let mut off = frm.offset[plane] + bx * 8 + by * 8 * frm.stride[plane];
for _ in 0..8 {
for x in 0..8 {
let mut off = frm.offset[plane] + bx * 8 + by * 8 * frm.stride[plane];
for y in 0..8 {
for x in 0..8 {
- frm.data[off + x] = (coeffs[x + y * 8] + i16::from(frm.data[off + x])).min(255).max(0) as u8;
+ frm.data[off + x] = (coeffs[x + y * 8] + i16::from(frm.data[off + x])).clamp(0, 255) as u8;
}
off += frm.stride[plane];
}
let mut off = frm.offset[plane] + bx * 8 + ((by & !1) * 8 + (by & 1)) * frm.stride[plane];
for y in 0..8 {
for x in 0..8 {
- frm.data[off + x] = (coeffs[x + y * 8] + i16::from(frm.data[off + x])).min(255).max(0) as u8;
+ frm.data[off + x] = (coeffs[x + y * 8] + i16::from(frm.data[off + x])).clamp(0, 255) as u8;
}
off += frm.stride[plane] * 2;
}
let mut off = frm.offset[plane] + bx * 8 + by * 8 * frm.stride[plane];
for _ in 0..8 {
for x in 0..8 {
- frm.data[off + x] = (dc + i16::from(frm.data[off + x])).min(255).max(0) as u8;
+ frm.data[off + x] = (dc + i16::from(frm.data[off + x])).clamp(0, 255) as u8;
}
off += frm.stride[plane];
}
}
}
if diff != 0 {
- data[off - step] = (b + diff).max(0).min(255) as u8;
- data[off] = (c - diff).max(0).min(255) as u8;
+ data[off - step] = (b + diff).clamp(0, 255) as u8;
+ data[off] = (c - diff).clamp(0, 255) as u8;
}
off += stride;
NACodecTypeInfo::Video(_) => Err(EncoderError::FormatError),
NACodecTypeInfo::Audio(ainfo) => {
let mut outinfo = ainfo;
- outinfo.channels = outinfo.channels.max(1).min(2);
+ outinfo.channels = outinfo.channels.clamp(1, 2);
if outinfo.format != SND_S16P_FORMAT && outinfo.format != SND_S16_FORMAT {
outinfo.format = SND_S16_FORMAT;
}
let mut sum = 0;
for &el in src[..CODED_LEN].iter() {
let val = (((el - off) >> (shift - 1)) + 1) >> 1;
- sum += val.max(0).min(MAX_CBITS);
+ sum += val.clamp(0, MAX_CBITS);
}
sum
}
}
for (bits, &val) in bits.iter_mut().zip(tmp.iter()).take(CODED_LEN) {
- *bits = ((((val - offset) >> (ref_shift - 1)) + 1) >> 1).max(0).min(MAX_CBITS) as i8;
+ *bits = ((((val - offset) >> (ref_shift - 1)) + 1) >> 1).clamp(0, MAX_CBITS) as i8;
}
if bitsum > SUBPART_BITS {
let mut sum = 0;
} else {
level = (level * q) - q_add;
}
- if level < -2048 { level = -2048; }
- if level > 2047 { level = 2047; }
+ level = level.clamp(-2048, 2047);
} else {
let fmt_bit = br.read_bool()?;
last = br.read_bool()?;
} else {
level = (level * q) - q_add;
}
- if level < -2048 { level = -2048; }
- if level > 2047 { level = 2047; }
+ level = level.clamp(-2048, 2047);
}
idx += run;
validate!(idx < 64);
}
fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
let src = pkt.get_buffer();
- validate!(src.len() > 0);
+ validate!(!src.is_empty());
for sd in pkt.side_data.iter() {
if let NASideData::Palette(true, ref pal) = sd {
match btype {
0 | 1 => {
let fill_val = if btype == 0 { 0x80 } else {
- ((dequant(coeffs[0], qmat[0]) >> 5) + 128).max(0).min(255) as u8
+ ((dequant(coeffs[0], qmat[0]) >> 5) + 128).clamp(0, 255) as u8
};
for line in dst.chunks_mut(stride).take(8) {
for el in line.iter_mut().take(8) {
idct(&mut blk);
for (line, row) in dst.chunks_mut(stride).zip(blk.chunks(8)).take(8) {
for (dst, coef) in line.iter_mut().zip(row.iter()).take(8) {
- *dst = (*coef + 128).max(0).min(255) as u8;
+ *dst = (*coef + 128).clamp(0, 255) as u8;
}
}
},
idct(&mut blk);
for (line, row) in dst.chunks_mut(stride).zip(blk.chunks(8)).take(8) {
for (dst, coef) in line.iter_mut().zip(row.iter()).take(8) {
- *dst = (*coef + 128).max(0).min(255) as u8;
+ *dst = (*coef + 128).clamp(0, 255) as u8;
}
}
},
let dc = dequant(coeffs[0], qmat[0]) >> 5;
for line in dst.chunks_mut(stride).take(8) {
for el in line.iter_mut().take(8) {
- *el = (i32::from(*el) + dc).max(0).min(255) as u8;
+ *el = (i32::from(*el) + dc).clamp(0, 255) as u8;
}
}
},
idct(&mut blk);
for (line, row) in dst.chunks_mut(stride).zip(blk.chunks(8)).take(8) {
for (dst, coef) in line.iter_mut().zip(row.iter()).take(8) {
- *dst = (i32::from(*dst) + *coef).max(0).min(255) as u8;
+ *dst = (i32::from(*dst) + *coef).clamp(0, 255) as u8;
}
}
},
idct(&mut blk);
for (line, row) in dst.chunks_mut(stride).zip(blk.chunks(8)).take(8) {
for (dst, coef) in line.iter_mut().zip(row.iter()).take(8) {
- *dst = (i32::from(*dst) + *coef).max(0).min(255) as u8;
+ *dst = (i32::from(*dst) + *coef).clamp(0, 255) as u8;
}
}
},
i32::from((100 - quant.min(100)) * 2)
};
for (inq, (outq, scale)) in base_qmat.iter().zip(qmat.iter_mut().zip(QUANT_MATRIX.iter())) {
- let val = ((i32::from(*inq) * q + 50) / 100).max(1).min(0x7FFF);
+ let val = ((i32::from(*inq) * q + 50) / 100).clamp(1, 0x7FFF);
*outq = ((val * i32::from(*scale) + 0x800) >> 12) as i16;
}
}
diff = -diff;
}
- (sample + diff).max(-32768).min(32767)
+ (sample + diff).clamp(-32768, 32767)
} else {
br.read_s(16)?
};
cur_bits = 0;
let mut acc = 0;
for band in start..BANDS {
- let mut len = (ch_data.bit_est[band] * 0.5 - pool + 0.5) as i32;
- if len < 0 { len = 0; }
- if len > 6 { len = 6; }
+ let len = ((ch_data.bit_est[band] * 0.5 - pool + 0.5) as i32).clamp(0, 6);
self.band_bits[band] = len as u8;
cur_bits += (self.band_width[band] as i32) * len;
if len > 0 {
let d1a = (diff.abs() - 2 * (diff.abs() - i16::from(strength)).max(0)).max(0);
let d1 = if diff < 0 { -d1a } else { d1a };
- buf[off - 1 * stride + x] = (b + d1).max(0).min(255) as u8;
- buf[off + 0 * stride + x] = (c - d1).max(0).min(255) as u8;
+ buf[off - 1 * stride + x] = (b + d1).clamp(0, 255) as u8;
+ buf[off + 0 * stride + x] = (c - d1).clamp(0, 255) as u8;
}
}
}
let d1a = (diff.abs() - 2 * (diff.abs() - i16::from(strength)).max(0)).max(0);
let d1 = if diff < 0 { -d1a } else { d1a };
- buf[off - 1 + y * stride] = (b + d1).max(0).min(255) as u8;
- buf[off + y * stride] = (c - d1).max(0).min(255) as u8;
+ buf[off - 1 + y * stride] = (b + d1).clamp(0, 255) as u8;
+ buf[off + y * stride] = (c - d1).clamp(0, 255) as u8;
}
}
}
} else {
level = (level * q) - q_add;
}
- if level < -2048 { level = -2048; }
- if level > 2047 { level = 2047; }
+ level = level.clamp(-2048, 2047);
}
idx += run;
validate!(idx < 64);
if delta == ESCAPE {
delta = br.read(8)? as u8;
}
- pred = ((i16::from(*top) - last_top + i16::from(pred)).max(0).min(255) as u8).wrapping_add(delta << 1);
+ pred = ((i16::from(*top) - last_top + i16::from(pred)).clamp(0, 255) as u8).wrapping_add(delta << 1);
last_top = i16::from(*top);
*dst = pred;
*top = pred;
1
} else {
let cur_ctx = 227 + coef_off + (coef_ctx + 2).max(5);
- coef_ctx = (coef_ctx + 1).max(4).min(7);
+ coef_ctx = (coef_ctx + 1).clamp(4, 7);
let mut coef = 2;
while coef < 15 && cabac.decode_bit(cur_ctx) {
1
} else {
let cur_ctx = 426 + coef_off + (coef_ctx + 2).max(5);
- coef_ctx = (coef_ctx + 1).max(4).min(7);
+ coef_ctx = (coef_ctx + 1).clamp(4, 7);
let mut coef = 2;
while coef < 15 && cabac.decode_bit(cur_ctx) {
impl<'a> CABAC<'a> {
fn calc_state(qp: u8, m: i8, n: i8) -> u8 {
- let pre_ctx_state = (((i16::from(m) * i16::from(qp)) >> 4) + i16::from(n)).max(1).min(126) as u8;
+ let pre_ctx_state = (((i16::from(m) * i16::from(qp)) >> 4) + i16::from(n)).clamp(1, 126) as u8;
if pre_ctx_state < 64 {
63 - pre_ctx_state
} else {
#[allow(clippy::cognitive_complexity)]
fn handle_macroblock(&mut self, slice_hdr: &SliceHeader, mb_info: &mut CurrentMBInfo, refs: &SimplifiedSliceRefs, frm: &mut NASimpleVideoFrame<u8>) -> DecoderResult<()> {
let qp_y = mb_info.qp_y;
- let qpr = ((qp_y as i8) + self.pps.chroma_qp_index_offset).max(0).min(51) as usize;
+ let qpr = ((qp_y as i8) + self.pps.chroma_qp_index_offset).clamp(0, 51) as usize;
let qp_u = CHROMA_QUANTS[qpr];
- let qpb = ((qp_y as i8) + self.pps.second_chroma_qp_index_offset).max(0).min(51) as usize;
+ let qpb = ((qp_y as i8) + self.pps.second_chroma_qp_index_offset).clamp(0, 51) as usize;
let qp_v = CHROMA_QUANTS[qpb];
let tx_bypass = qp_y == 0 && self.sps.qpprime_y_zero_transform_bypass;
let pps = &self.pps[self.cur_pps];
let qp_y = mb_info.qp_y;
- let qpr = ((qp_y as i8) + pps.chroma_qp_index_offset).max(0).min(51) as usize;
+ let qpr = ((qp_y as i8) + pps.chroma_qp_index_offset).clamp(0, 51) as usize;
let qp_u = CHROMA_QUANTS[qpr];
- let qpb = ((qp_y as i8) + pps.second_chroma_qp_index_offset).max(0).min(51) as usize;
+ let qpb = ((qp_y as i8) + pps.second_chroma_qp_index_offset).clamp(0, 51) as usize;
let qp_v = CHROMA_QUANTS[qpb];
let tx_bypass = qp_y == 0 && self.sps[self.cur_sps].qpprime_y_zero_transform_bypass;
type MCFunc = fn (dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, h: usize);
-fn clip_u8(val: i16) -> u8 { val.max(0).min(255) as u8 }
+fn clip_u8(val: i16) -> u8 { val.clamp(0, 255) as u8 }
trait RegisterSIMD {
fn register_simd(&mut self);
let out = &mut dst[offset..][..stride * 3 + 4];
for (line, src) in out.chunks_mut(stride).take(4).zip(coeffs.chunks_exact(4)) {
for (dst, src) in line.iter_mut().take(4).zip(src.iter()) {
- *dst = (i32::from(*dst) + i32::from(*src)).max(0).min(255) as u8;
+ *dst = (i32::from(*dst) + i32::from(*src)).clamp(0, 255) as u8;
}
}
}
let out = &mut dst[offset..];
for (line, src) in out.chunks_mut(stride).take(8).zip(coeffs.chunks_exact(8)) {
for (dst, src) in line.iter_mut().take(8).zip(src.iter()) {
- *dst = (i32::from(*dst) + i32::from(*src)).max(0).min(255) as u8;
+ *dst = (i32::from(*dst) + i32::from(*src)).clamp(0, 255) as u8;
}
}
}
-fn clip8(val: i16) -> u8 { val.max(0).min(255) as u8 }
+fn clip8(val: i16) -> u8 { val.clamp(0, 255) as u8 }
fn ipred_dc128(buf: &mut [u8], stride: usize, bsize: usize) {
for row in buf.chunks_mut(stride).take(bsize) {
];
fn get_lf_idx(qp0: u8, qp1: u8, off: i8) -> usize {
- (i16::from((qp0 + qp1 + 1) >> 1) + i16::from(off)).max(0).min(51) as usize
+ (i16::from((qp0 + qp1 + 1) >> 1) + i16::from(off)).clamp(0, 51) as usize
}
macro_rules! filter_edge_func {
return (DEF_WEIGHT_INFO, DEF_WEIGHT_INFO);
}
- let td = (i32::from(r1_poc) - i32::from(r0_poc)).max(-128).min(127);
+ let td = (i32::from(r1_poc) - i32::from(r0_poc)).clamp(-128, 127);
let tx = (16384 + (td / 2).abs()) / td;
- let tb = (i32::from(cur_id) - i32::from(r0_poc)).max(-128).min(127);
- let scale = ((tb * tx + 32) >> 6).max(-1024).min(1023);
+ let tb = (i32::from(cur_id) - i32::from(r0_poc)).clamp(-128, 127);
+ let scale = ((tb * tx + 32) >> 6).clamp(-1024, 1023);
if scale == 128 || (scale >> 2) < -64 || (scale >> 2) > 128 {
return (DEF_WEIGHT_INFO, DEF_WEIGHT_INFO);
}
("MR1_BT_A.h264", [0x617BF915, 0x48E89440, 0xC899A917, 0xC73CF171]),
("MR2_TANDBERG_E.264", [0x69C17B20, 0xDF6E89E6, 0x82BD82F1, 0x93B6D282]),
("MR3_TANDBERG_B.264", [0xC8AAC175, 0xE5E73C68, 0x87EE02FF, 0x6DEA0F64]),
- ("MR4_TANDBERG_C.264", [0xA40042BC, 0xAB00C341, 0xA9651725, 0x46d31A2C]),
+ ("MR4_TANDBERG_C.264", [0xA40042BC, 0xAB00C341, 0xA9651725, 0x46D31A2C]),
("MR5_TANDBERG_C.264", [0x999EAE2E, 0x016DB374, 0x708B00E4, 0x335AE723]),
("MR1_MW_A.264", [0xDD56DC8E, 0x403B18EC, 0x57EB5B3A, 0xD834FFDE]),
("MR2_MW_A.264", [0xE1E93E65, 0x96AF2EFD, 0x0E7D0FE5, 0x94D5BE85]),
let vhdr = NAVideoInfo::new(width, height, false, YUV420_FORMAT);
let vinfo = NACodecInfo::new("h264", NACodecTypeInfo::Video(vhdr), Some(edata));
- if let None = strmgr.add_stream(NAStream::new(StreamType::Video, 0, vinfo, 1, 25, 0)) {
+ if strmgr.add_stream(NAStream::new(StreamType::Video, 0, vinfo, 1, 25, 0)).is_none() {
return Err(DemuxerError::InvalidData);
}
self.cur_frame = 0;
};
let (col_ref, r0_long) = frame_refs.map_ref0(r0_poc);
if temporal_mv {
- let td = (i32::from(r1_poc) - i32::from(r0_poc)).max(-128).min(127);
+ let td = (i32::from(r1_poc) - i32::from(r0_poc)).clamp(-128, 127);
if r0_long || td == 0 {
(col_mv, col_ref, ZERO_MV, ZERO_REF)
} else {
let tx = (16384 + (td / 2).abs()) / td;
- let tb = (i32::from(cur_id) - i32::from(r0_poc)).max(-128).min(127);
- let scale = ((tb * tx + 32) >> 6).max(-1024).min(1023);
+ let tb = (i32::from(cur_id) - i32::from(r0_poc)).clamp(-128, 127);
+ let scale = ((tb * tx + 32) >> 6).clamp(-1024, 1023);
let mv0 = MV {
x: ((i32::from(col_mv.x) * scale + 128) >> 8) as i16,
y: ((i32::from(col_mv.y) * scale + 128) >> 8) as i16,
let pred = (sum + (1 << (self.bits - 1))) >> self.bits;
let val = *el + pred;
*el = val;
- self.buf[delay_pos] = val.min(32767).max(-32768) as i16;
+ self.buf[delay_pos] = val.clamp(-32768, 32767) as i16;
if self.new {
let aval = val.abs();
let sign = val2sign(val) as i16;
NACodecTypeInfo::Video(_) => Err(EncoderError::FormatError),
NACodecTypeInfo::Audio(ainfo) => {
let mut outinfo = ainfo;
- outinfo.channels = outinfo.channels.max(1).min(8);
+ outinfo.channels = outinfo.channels.clamp(1, 8);
if outinfo.format != SND_S16P_FORMAT && outinfo.format != SND_S16_FORMAT {
outinfo.format = SND_S16P_FORMAT;
}
if outinfo.block_len == 0 {
outinfo.block_len = DEFAULT_BLOCK_LEN;
}
- outinfo.block_len = outinfo.block_len.max(2).min(65535);
+ outinfo.block_len = outinfo.block_len.clamp(2, 65535);
let mut ofmt = *encinfo;
ofmt.format = NACodecTypeInfo::Audio(outinfo);
Ok(ofmt)
}
impl MVClipPixel for i8 {
- fn clip_y(self) -> Self { self.max(0).min(31) }
- fn clip_c(self) -> Self { self.max(-31).min(31) }
+ fn clip_y(self) -> Self { self.clamp(0, 31) }
+ fn clip_c(self) -> Self { self.clamp(-31, 31) }
}
impl MVClipPixel for i16 {
- fn clip_y(self) -> Self { self.max(0).min(31) }
- fn clip_c(self) -> Self { self.max(-31).min(31) }
+ fn clip_y(self) -> Self { self.clamp(0, 31) }
+ fn clip_c(self) -> Self { self.clamp(-31, 31) }
}
impl MVClipPixel for i32 {
- fn clip_y(self) -> Self { self.max(0).min(31) }
- fn clip_c(self) -> Self { self.max(-31).min(31) }
+ fn clip_y(self) -> Self { self.clamp(0, 31) }
+ fn clip_c(self) -> Self { self.clamp(-31, 31) }
}
#[derive(Clone,Copy,Debug,Default)]
printf("];\n");
}
*/
-const RGB2YUV: [YuvPixel; 32768] = [
+static RGB2YUV: [YuvPixel; 32768] = [
pix!( 0, -1, -1), pix!( 0, 2, -1), pix!( 0, 3, -1), pix!( 0, 4, -1),
pix!( 0, 5, -1), pix!( 0, 6, -1), pix!( 0, 7, -1), pix!( 1, 7, -2),
pix!( 1, 8, -2), pix!( 1, 10, -2), pix!( 1, 11, -2), pix!( 1, 12, -2),
esc + 0x8FC
}
},
- 0xFC | 0xFD | 0xFE | 0xFF => {
+ 0xFC..=0xFF => {
zero_run = u32::from(val - 0xFC);
if zero_skip {
continue;
let dst = &mut frm.data[frm.offset[plane]..];
for (drow, srow) in dst.chunks_mut(frm.stride[plane]).zip(self.plane[plane].chunks(self.stride[plane])) {
for (dst, &src) in drow.iter_mut().zip(srow.iter()) {
- *dst = (src + 128.0).max(0.0).min(255.0) as u8;
+ *dst = (src + 128.0).clamp(0.0, 255.0) as u8;
}
}
}
fn put_block(blk: &[i16; 64], dst: &mut [u8], stride: usize) {
for (drow, srow) in dst.chunks_mut(stride).zip(blk.chunks(8)) {
for (del, &pix) in drow.iter_mut().zip(srow.iter()) {
- *del = pix.max(0).min(255) as u8;
+ *del = pix.clamp(0, 255) as u8;
}
}
}
];
for (i, (&luma_q, &chroma_q)) in DEF_LUMA_QUANT.iter().zip(DEF_CHROMA_QUANT.iter()).enumerate() {
- self.quant[0][ZIGZAG[i]] = ((i16::from(quant) * i16::from(luma_q) + 25) / 50).max(1).min(255);
- self.quant[1][ZIGZAG[i]] = ((i16::from(quant) * i16::from(chroma_q) + 25) / 50).max(1).min(255);
+ self.quant[0][ZIGZAG[i]] = ((i16::from(quant) * i16::from(luma_q) + 25) / 50).clamp(1, 255);
+ self.quant[1][ZIGZAG[i]] = ((i16::from(quant) * i16::from(chroma_q) + 25) / 50).clamp(1, 255);
}
if let Some(buf) = bufinfo.get_vbuf() {
}
}
-const MVS: [(i8, i8); 225] = [
+static MVS: [(i8, i8); 225] = [
( 0,-16), ( 3,-16),
( -6,-14), ( 6,-14),
( -2,-13), ( 0,-13), ( 2,-13),
( -3, 16)
];
-const PATTERNS: [u64; 256] = [
+static PATTERNS: [u64; 256] = [
0x0000000080808000, 0x0000008080808000, 0x0000808080808000, 0x0080808080808000,
0xC080808080808000, 0xE0C0C0C080808000, 0xF0E0E0C0C0808000, 0xF8F0E0E0C0808000,
0xFCF8F0E0C0808000, 0xFEFCF8F0E0C08000, 0xFFFFFEFCF8E0C000, 0xFFFFFFFEFCF0C000,
0x0000000000000070, 0x55AA55AA55AA55AA, 0xE7E7E7E7E7E7E7E7, 0xFFFFFF0000FFFFFF
];
-const BLOCK4_PATTERNS: [u16; 256] = [
+static BLOCK4_PATTERNS: [u16; 256] = [
0x0008, 0x00FF, 0x0FFF, 0x7FFF, 0x37FF, 0xFEC8, 0xFFEC, 0xFFFE,
0xEEEE, 0xCCCC, 0xCCC8, 0x07FF, 0xEEC8, 0xEEEC, 0x0088, 0x0080,
0x0FF0, 0xFFF0, 0x7FF0, 0xEC80, 0xFEC0, 0xFFE0, 0xFFF0, 0xFFF1,
0x0066, 0x0466, 0x0EE0, 0x0020, 0xA954, 0x6561, 0x6C50, 0x6E74
];
-const RGB_TAB: [[u16; 32768]; 2] = [
+static RGB_TAB: [[u16; 32768]; 2] = [
[
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
let mut bottom = self.get_num_bands();
for f in 0..tns_data.n_filt[w] {
let top = bottom;
- bottom = if top >= tns_data.coeffs[w][f].length { top - tns_data.coeffs[w][f].length } else { 0 };
+ bottom = top.saturating_sub(tns_data.coeffs[w][f].length);
let order = tns_data.coeffs[w][f].order;
if order == 0 { continue; }
let start = w * 128 + self.get_band_start(tns_max_bands.min(bottom));
match self.qmode {
QuantMode::Single => {
for (env_no, &env_end) in self.env_border[1..=self.num_env].iter().enumerate() {
- let env_end = env_end;
let mut noise_env_no = 0;
for nenv in 0..self.num_noise {
if (start >= noise_env[nenv]) && (env_end <= noise_env[nenv + 1]) {
},
QuantMode::Left => {
for (env_no, &env_end) in self.env_border[1..=self.num_env].iter().enumerate() {
- let env_end = env_end;
let mut noise_env_no = 0;
for nenv in 0..self.num_noise {
if (start >= noise_env[nenv]) && (env_end <= noise_env[nenv + 1]) {
},
QuantMode::Right => {
for (env_no, &env_end) in self.env_border[1..=self.num_env].iter().enumerate() {
- let env_end = env_end;
let mut noise_env_no = 0;
for nenv in 0..self.num_noise {
if (start >= noise_env[nenv]) && (env_end <= noise_env[nenv + 1]) {
}
impl Clip8 for i16 {
- fn clip8(self) -> u8 { self.max(0).min(255) as u8 }
+ fn clip8(self) -> u8 { self.clamp(0, 255) as u8 }
}
trait ClipCoef {
}
impl ClipCoef for i32 {
- fn clip_coef(self) -> i16 { self.max(-2048).min(2047) as i16 }
+ fn clip_coef(self) -> i16 { self.clamp(-2048, 2047) as i16 }
}
pub fn get_dc_scales(quant: u8) -> [u8; 2] {
0..=3 => {
let cur_addr = mb_x * 2 + (n & 1) + (n / 2) * self.y_dc.stride;
let (diff, dir) = Self::dc_pred(&self.y_dc, cur_addr);
- let dc = ((cur_dc + (diff + i16::from(dc_scale >> 1)) / i16::from(dc_scale)) * i16::from(dc_scale)).max(-2048).min(2047);
+ let dc = ((cur_dc + (diff + i16::from(dc_scale >> 1)) / i16::from(dc_scale)) * i16::from(dc_scale)).clamp(-2048, 2047);
self.y_dc.data[self.y_dc.xpos + cur_addr] = dc;
(dc, dir)
},
4 => {
let (diff, dir) = Self::dc_pred(&self.u_dc, mb_x);
- let dc = ((cur_dc + (diff + i16::from(dc_scale >> 1)) / i16::from(dc_scale)) * i16::from(dc_scale)).max(-2048).min(2047);
+ let dc = ((cur_dc + (diff + i16::from(dc_scale >> 1)) / i16::from(dc_scale)) * i16::from(dc_scale)).clamp(-2048, 2047);
self.u_dc.data[self.u_dc.xpos + mb_x] = dc;
(dc, dir)
},
5 => {
let (diff, dir) = Self::dc_pred(&self.v_dc, mb_x);
- let dc = ((cur_dc + (diff + i16::from(dc_scale >> 1)) / i16::from(dc_scale)) * i16::from(dc_scale)).max(-2048).min(2047);
+ let dc = ((cur_dc + (diff + i16::from(dc_scale >> 1)) / i16::from(dc_scale)) * i16::from(dc_scale)).clamp(-2048, 2047);
self.v_dc.data[self.v_dc.xpos + mb_x] = dc;
(dc, dir)
},
- 8 * i32::from(sblk_gain)
- if gr.scalefac_scale { 4 } else { 2 } * (i32::from(gr.scalefac[ssb])
+ if gr.preflag { i32::from(MP3_PREEMP_SCALES[sb]) } else { 0 })
- ).min(127).max(-124) as i8
+ ).clamp(-124, 127) as i8
}
fn read_mp3_coeffs(&mut self, br: &mut BitReader, end: usize, gr_no: usize, ch: usize, coeffs: &mut [f32]) -> DecoderResult<()> {
let mut scales = [0; SAMPLES / 2];
fn expand_nibble(&mut self, nibble: u8) -> i16 {
let mul = if (nibble & 8) == 0 { i32::from(nibble) } else { i32::from(nibble) - 16 };
let pred = self.calc_pred() + self.delta.wrapping_mul(mul);
- self.update(pred.max(-0x8000).min(0x7FFF));
+ self.update(pred.clamp(-0x8000, 0x7FFF));
self.delta = (ADAPT_TABLE[nibble as usize].wrapping_mul(self.delta) >> 8).max(16);
self.sample1 as i16
}
dist
}
fn calculate_mul(delta: i32, diff: i32) -> u8 {
- ((diff / delta).max(-8).min(7) & 0xF) as u8
+ ((diff / delta).clamp(-8, 7) & 0xF) as u8
}
fn calc_block_size(nsamps: usize, channels: usize) -> usize {
(nsamps - 2) * channels / 2 + 7 * channels
}
fn to_sample(val: i32) -> u8 {
- ((val >> 8) + 128).max(0).min(255) as u8
+ ((val >> 8) + 128).clamp(0, 255) as u8
}
impl ChannelPredictor {
}
for (dline, sline) in dst[off..].chunks_mut(dstride).zip(blk.chunks_exact(w)).take(h) {
for (dst, &src) in dline.iter_mut().zip(sline.iter()) {
- *dst = src.max(0).min(255) as u8;
+ *dst = src.clamp(0, 255) as u8;
}
}
} else {
for (dline, sline) in dst[off..].chunks_mut(dstride).zip(blk.chunks_exact(w)).take(h) {
for (dst, &src) in dline.iter_mut().zip(sline.iter()) {
- *dst = src.max(0).min(255) as u8;
+ *dst = src.clamp(0, 255) as u8;
}
}
}
}
fn decode(&mut self, supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
let src = pkt.get_buffer();
- validate!(src.len() > 0);
+ validate!(!src.is_empty());
if src.len() == 1 {
validate!(src[0] == 0xFF);
let out = &mut dst[offset..][..stride * 3 + 4];
for (line, src) in out.chunks_mut(stride).take(4).zip(coeffs.chunks(4)) {
for (dst, src) in line.iter_mut().take(4).zip(src.iter()) {
- *dst = (i32::from(*dst) + i32::from(*src)).max(0).min(255) as u8;
+ *dst = (i32::from(*dst) + i32::from(*src)).clamp(0, 255) as u8;
}
}
}
}
}
-fn clip8(val: i16) -> u8 { val.max(0).min(255) as u8 }
+fn clip8(val: i16) -> u8 { val.clamp(0, 255) as u8 }
fn ipred_dc128(buf: &mut [u8], mut idx: usize, stride: usize, bsize: usize) {
for _ in 0..bsize {
struct Bink2DSP { }
fn clip8(val: i32) -> u8 {
- val.min(255).max(0) as u8
+ val.clamp(0, 255) as u8
}
macro_rules! el {
NACodecTypeInfo::Video(_) => Err(EncoderError::FormatError),
NACodecTypeInfo::Audio(ainfo) => {
let mut outinfo = ainfo;
- outinfo.channels = if !self.use_dct { 2 } else { ainfo.channels.min(2).max(1) };
+ outinfo.channels = if !self.use_dct { 2 } else { ainfo.channels.clamp(1, 2) };
outinfo.format = SND_F32P_FORMAT;
let mut ofmt = *encinfo;
ofmt.format = NACodecTypeInfo::Audio(outinfo);
} else {
pos >>= 1;
}
- let ipos = ((pos as i8) - 1).max(0).min(12);
+ let ipos = ((pos as i8) - 1).clamp(0, 12);
let cb = &codebooks.quant_cb[ipos as usize];
self.qindex[i] = (br.read_cb(cb)? as i8) + self.qindex[i - 1] - 12;
validate!((self.qindex[i] >= -63) && (self.qindex[i] <= 63));
} else {
nrg0 *= std::f32::consts::SQRT_2;
}
- nrg0.log2().max(-31.0).min(47.0) as i8
+ nrg0.log2().clamp(-31.0, 47.0) as i8
}
impl CookChannelPair {
if params.js_bits == 0 {
for (i, qscale) in qindex[..total_bands].iter_mut().enumerate().skip(1) {
let cb_idx = (i - 1).min(12);
- let diff = (*qscale - last_q).max(-12).min(11);
+ let diff = (*qscale - last_q).clamp(-12, 11);
*qscale = last_q + diff;
last_q = *qscale;
for (i, qscale) in qindex[..total_bands].iter_mut().enumerate().skip(1) {
let band_no = if i < params.js_start * 2 { i >> 1 } else { i - params.js_start };
let cb_idx = band_no.saturating_sub(1).min(12);
- let diff = (*qscale - last_q).max(-12).min(11);
+ let diff = (*qscale - last_q).clamp(-12, 11);
*qscale = last_q + diff;
last_q = *qscale;
}
fn clip_out(sample: i16) -> i16 {
- sample.max(-16384 >> 2).min(16383 >> 2)
+ sample.clamp(-16384 >> 2, 16383 >> 2)
}
impl NADecoder for RA144Decoder {
let sum = self.gain_hist[GAIN_START..].iter().rev()
.zip(self.gain_lpc.iter())
.fold(32.0f32, |acc, (&a, &b)| acc - a * b)
- .max(0.0).min(60.0);
+ .clamp(0.0, 60.0);
let scale = (sum * 0.1151292546497).exp() * gain * (1.0 / ((1 << 23) as f32));
let mut buf: [f32; BLOCKSIZE] = [0.0; BLOCKSIZE];
let code_params = br.read_cb(&cset.coding_mode_cb).unwrap();
let (add_bits, range, range2, codes_cb) = if code_params >= 15 {
- let mut add_bits = ((code_params / 5 - 3) / 2).max(0).min(10) as u8;
+ let mut add_bits = ((code_params / 5 - 3) / 2).clamp(0, 10) as u8;
if add_bits > 9 && ((code_params % 5) != 2) {
add_bits -= 1;
}
const RALF_SHORT_CODES_LEN: usize = 169;
const RALF_LONG_CODES_LEN: usize = 441;
-const RALF_FILTER_PARAM_TAB: [[u8; 324]; 3] = [
+static RALF_FILTER_PARAM_TAB: [[u8; 324]; 3] = [
[
0x48, 0x86, 0x66, 0x8A, 0xBB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
]
];
-const RALF_BIAS_TAB: [[u8; 128]; 3] = [
+static RALF_BIAS_TAB: [[u8; 128]; 3] = [
[
0x4A, 0xAA, 0xAA, 0xAA, 0xBA, 0xBA, 0xBA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
0xAA, 0xAA, 0xAA, 0xAB, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x9A, 0xA9, 0xA9,
]
];
-const RALF_CODING_MODE_TAB: [[u8; 72]; 3] = [
+static RALF_CODING_MODE_TAB: [[u8; 72]; 3] = [
[
0xAA, 0x99, 0xAC, 0xB9, 0xBD, 0xAA, 0x7A, 0xA8, 0xA8, 0xA8, 0x79, 0x79,
0x77, 0xA8, 0x97, 0x79, 0x89, 0x77, 0x87, 0x87, 0x68, 0x78, 0x66, 0x86,
]
];
-const RALF_FILTER_COEFFS_TAB: [[[[u8; 24]; 11]; 10]; 3] = [
+static RALF_FILTER_COEFFS_TAB: [[[[u8; 24]; 11]; 10]; 3] = [
[
[
[
],
];
-const RALF_SHORT_CODES_TAB: [[[u8; 88]; 15]; 3] = [
+static RALF_SHORT_CODES_TAB: [[[u8; 88]; 15]; 3] = [
[
[
0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0xCF, 0xFF,
],
];
-const RALF_LONG_CODES_TAB: [[[u8; 224]; 125]; 3] = [
+static RALF_LONG_CODES_TAB: [[[u8; 224]; 125]; 3] = [
[
[
0xBE, 0xED, 0xDD, 0xDD, 0xDD, 0xDD, 0xFF, 0xFF, 0xFF, 0xFF, 0xBF, 0xFF,
} else {
level = (level * q) - q_add;
}
- if level < -2048 { level = -2048; }
- if level > 2047 { level = 2047; }
+ level = level.clamp(-2048, 2047);
}
idx += run;
validate!(idx < 64);
} else {
level = (level * q) - q_add;
}
- if level < -2048 { level = -2048; }
- if level > 2047 { level = 2047; }
+ level = level.clamp(-2048, 2047);
}
idx += run;
validate!(idx < 64);
for (i, el) in self.coeffs.iter_mut().enumerate() {
if *el != 0 {
let q = if matches!(i, 0 | 1 | 4) { q_dc } else { q_ac };
- *el = (i32::from(*el) * 16 / q).max(-511).min(511) as i16;
+ *el = (i32::from(*el) * 16 / q).clamp(-511, 511) as i16;
}
}
}
for line in dst.chunks_mut(stride).take(16) {
let mut oval = a;
for el in line[..16].iter_mut() {
- *el = (oval >> 5).max(0).min(255) as u8;
+ *el = (oval >> 5).clamp(0, 255) as u8;
oval += b;
}
a += c;
let mut dist = 0u32;
for (diffs, (pred, refsrc)) in blk.coeffs.chunks(4).zip(pred.chunks(stride).zip(refsrc.chunks(stride))) {
for (&diff, (&p, &r)) in diffs.iter().zip(pred.iter().zip(refsrc.iter())) {
- let new = (i32::from(p) + i32::from(diff)).max(0).min(255);
+ let new = (i32::from(p) + i32::from(diff)).clamp(0, 255);
let expected = i32::from(r);
dist += ((new - expected) * (new - expected)) as u32;
}
if size > 0 {
48.13080360867910341240 - 10.0 * ((sum as f64) / (size as f64)).log10()
} else {
- std::f64::INFINITY
+ f64::INFINITY
}
}
use nihav_codec_support::codecs::MV;
use nihav_codec_support::codecs::blockdsp::edge_emu;
-fn clip8(val: i16) -> u8 { val.min(255).max(0) as u8 }
+fn clip8(val: i16) -> u8 { val.clamp(0, 255) as u8 }
macro_rules! el {
($s: ident, $o: expr) => ( $s[$o] as i16 )
}
};
let shift = shift + 1;
- let x = (if shift >= 0 { x << shift } else { x >> -shift }).min(10000).max(-10000);
+ let x = (if shift >= 0 { x << shift } else { x >> -shift }).clamp(-10000, 10000);
for j in 0..11 {
let val = (x * signs[i / 2][j]) >> 15;
buf[pos[i / 2 * 11 + j]] = buf[pos[i / 2 * 11 + j]].saturating_add(val as i16);
let bits2 = norm_bits(den, 31);
num = num << bits1 >> 1;
den <<= bits2;
- let shift = (5 + bits1 - bits2).max(0);
+ let shift = (5 + bits1).saturating_sub(bits2);
gain = square_root_i32(((num >> 1) / (den >> 16)) << 16 >> shift);
} else {
for i in 1..NUM_REGIONS {
let diff = br.read_cb(&self.diff_cb[i - 1])?;
- self.pow_index[i] = (self.pow_index[i - 1] + i32::from(diff)).max(-24).min(39);
+ self.pow_index[i] = (self.pow_index[i - 1] + i32::from(diff)).clamp(-24, 39);
}
for i in 0..NUM_REGIONS {
self.region_quant[i] = self.quant_tab[(self.pow_index[i] + 24) as usize];
while delta > 0 {
let mut bitpool = 0;
for reg in 0..NUM_REGIONS {
- let cat = ((delta + offset - self.pow_index[reg]) >> 1).max(0).min(7) as usize;
+ let cat = ((delta + offset - self.pow_index[reg]) >> 1).clamp(0, 7) as usize;
//self.power_cat[reg] = cat;
bitpool += CATEGORY_BITS[cat];
}
let mut max_rate_cat = [0; NUM_REGIONS];
let mut min_rate_cat = [0; NUM_REGIONS];
for reg in 0..NUM_REGIONS {
- let cat = ((offset - self.pow_index[reg]) >> 1).max(0).min(7) as usize;
+ let cat = ((offset - self.pow_index[reg]) >> 1).clamp(0, 7) as usize;
max_rate_cat[reg] = cat;
min_rate_cat[reg] = cat;
self.power_cat[reg] = cat;
let diff = (3 * (p1 - q1) + 8 * (q0 - p0)) >> 4;
if (diff != 0) && (diff > -32) && (diff < 32) {
let delta = clip_tab[(diff + 32) as usize];
- buf[off - 1 * stride + x] = (p0 + delta).max(0).min(255) as u8;
- buf[off + 0 * stride + x] = (q0 - delta).max(0).min(255) as u8;
+ buf[off - 1 * stride + x] = (p0 + delta).clamp(0, 255) as u8;
+ buf[off + 0 * stride + x] = (q0 - delta).clamp(0, 255) as u8;
}
}
}
let diff = (3 * (p1 - q1) + 8 * (q0 - p0)) >> 4;
if (diff != 0) && (diff > -32) && (diff < 32) {
let delta = clip_tab[(diff + 32) as usize];
- buf[off - 1 + y * stride] = (p0 + delta).max(0).min(255) as u8;
- buf[off + y * stride] = (q0 - delta).max(0).min(255) as u8;
+ buf[off - 1 + y * stride] = (p0 + delta).clamp(0, 255) as u8;
+ buf[off + y * stride] = (q0 - delta).clamp(0, 255) as u8;
}
}
}
} else {
level = (level * q) - q_add;
}
- if level < -2048 { level = -2048; }
- if level > 2047 { level = 2047; }
+ level = level.clamp(-2048, 2047);
}
}
idx += run;
fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
let src = pkt.get_buffer();
- if src.len() == 0 {
+ if src.is_empty() {
let buftype;
let ftype;
if self.lastframe.is_none() {
};
},
b"Duration" => {
- self.duration = if let Ok(val) = valstr.parse() {
- val
- } else { 0 };
+ self.duration = valstr.parse().unwrap_or_default();
},
/* b"TimeUnitNumerator" => {
self.v_num = if let Ok(val) = valstr.parse() {
projects / nihav.git / commitdiff