let sign = (nibble & 8) != 0;
let diff = (i32::from(nibble & 7) * IMA_STEP_TABLE[self.step]) >> 2;
let sample = if !sign { self.predictor + diff } else { self.predictor - diff };
- self.predictor = sample.max(i32::from(std::i16::MIN)).min(i32::from(std::i16::MAX));
+ self.predictor = sample.max(i32::from(i16::MIN)).min(i32::from(i16::MAX));
self.step = istep.max(0).min(IMA_MAX_STEP as isize) as usize;
self.predictor as i16
}
let sign = (nibble & 8) != 0;
let diff = (i32::from(2 * (nibble & 7) + 1) * IMA_STEP_TABLE[self.step]) >> 3;
let sample = if !sign { self.predictor + diff } else { self.predictor - diff };
- self.predictor = sample.max(i32::from(std::i16::MIN)).min(i32::from(std::i16::MAX));
+ self.predictor = sample.max(i32::from(i16::MIN)).min(i32::from(i16::MAX));
self.step = istep.max(0).min(IMA_MAX_STEP as isize) as usize;
self.predictor as i16
}
return 0;
}
let mut old_cb = vec![T::default(); self.clusters.len()];
- let mut prev_dist = std::u64::MAX;
- let mut dist = std::u64::MAX / 2;
+ let mut prev_dist = u64::MAX;
+ let mut dist = u64::MAX / 2;
let mut indices = Vec::with_capacity(src.len());
let mut elements = Vec::with_capacity(src.len());
elements.extend_from_slice(src);
indices.clear();
for entry in entries.iter() {
let mut bestidx = 0;
- let mut bestdist = std::u32::MAX;
+ let mut bestdist = u32::MAX;
for (i, cluster) in self.clusters.iter().enumerate() {
let dist = entry.val.dist(cluster.centroid);
if bestdist > dist {
let high_idx_idx = (rng.next() as usize) % high_u.len();
let high_idx = high_u[high_idx_idx];
let mut closest_idx = *low_idx;
- let mut closest_dist = std::u32::MAX;
+ let mut closest_dist = u32::MAX;
let low_centr = self.clusters[*low_idx].centroid;
for (i, (&used, cluster)) in used.iter().zip(self.clusters.iter()).take(dst.len()).enumerate() {
if i == *low_idx || used {
}
}
fn find_nearest(codebook: &[YUVCode], code: YUVCode) -> (u8, u32) {
- let mut min_dist = std::u32::MAX;
+ let mut min_dist = u32::MAX;
let mut idx = 0;
for (i, cw) in codebook.iter().enumerate() {
let dist = cw.dist(code);
validate!(version == 0);
let _flags = br.read_u24be()?;
let entries = br.read_u32be()? as usize;
- validate!(entries < ((std::u32::MAX >> 2) - 8) as usize);
+ validate!(entries < ((u32::MAX >> 2) - 8) as usize);
validate!((entries * 4 + 8) as u64 == size);
track.keyframes = Vec::with_capacity(entries);
let mut last_sample_no = 0;
validate!(version == 0);
let _flags = br.read_u24be()?;
let entries = br.read_u32be()? as usize;
- validate!(entries < ((std::u32::MAX / 12) - 8) as usize);
+ validate!(entries < ((u32::MAX / 12) - 8) as usize);
validate!((entries * 12 + 8) as u64 == size);
track.sample_map = Vec::with_capacity(entries);
let mut last_sample_no = 0;
track.ctts_map.reserve(sample_count);
}
- if track.chunk_offsets.len() < (std::u32::MAX as usize) {
+ if track.chunk_offsets.len() < (u32::MAX as usize) {
track.keyframes.push((track.chunk_offsets.len() + 1) as u32);
}
for _ in 0..sample_count {
return Err(DemuxerError::EOF);
}
let mut has_all_time = true;
- let mut min_ts = std::u64::MAX;
+ let mut min_ts = u64::MAX;
for trk in self.tracks.iter() {
if let Some(ts) = trk.cur_ts {
min_ts = min_ts.min(ts);
fn open(&mut self, strmgr: &mut StreamManager, seek_index: &mut SeekIndex) -> DemuxerResult<()> {
let riff = self.src.read_u32be()?;
let riff_size = self.src.read_u32le()? as usize;
- let riff_end = self.src.tell() + if riff_size > 0 { riff_size as u64 } else { u64::from(std::u32::MAX) };
+ let riff_end = self.src.tell() + if riff_size > 0 { riff_size as u64 } else { u64::from(u32::MAX) };
let wave = self.src.read_u32be()?;
validate!(riff == mktag!(b"RIFF"));
validate!(wave == mktag!(b"WAVE"));
impl Default for TNode {
fn default() -> Self {
Self {
- price: std::u32::MAX,
+ price: u32::MAX,
dist: 0,
link: 0,
}
return;
}
let mut old_cb: [Pixel; 256] = [Pixel::default(); 256];
- let mut prev_dist = std::u64::MAX;
- let mut dist = std::u64::MAX / 2;
+ let mut prev_dist = u64::MAX;
+ let mut dist = u64::MAX / 2;
let mut indices = Vec::with_capacity(src.len());
let mut pixels = Vec::with_capacity(src.len());
pixels.extend_from_slice(src);
indices.clear();
for entry in entries.iter() {
let mut bestidx = 0;
- let mut bestdist = std::u32::MAX;
+ let mut bestdist = u32::MAX;
for (i, cluster) in self.clusters.iter().enumerate() {
let dist = entry.pix.dist(cluster.centroid);
if bestdist > dist {
let high_idx_idx = (rng.next() as usize) % high_u.len();
let high_idx = high_u[high_idx_idx];
let mut closest_idx = *low_idx;
- let mut closest_dist = std::u32::MAX;
+ let mut closest_dist = u32::MAX;
let low_centr = self.clusters[*low_idx].centroid;
for (i, (cluster, &used)) in self.clusters.iter().zip(used.iter()).enumerate() {//low_u.iter() {
if i == *low_idx || used {
return i;
}
}
- let mut bestdist = std::f64::MAX;
+ let mut bestdist = f64::MAX;
let mut distidx = 0;
- let mut bestbias = std::f64::MAX;
+ let mut bestbias = f64::MAX;
let mut biasidx = 0;
for i in SPECIAL_NODES..256 {
let dist = (self.weights[i][0] - clr[0]) * (self.weights[i][0] - clr[0])
pub fn find_nearest(pix: &[u8], pal: &[[u8; 3]; 256]) -> usize {
let mut bestidx = 0;
- let mut bestdist = std::i32::MAX;
+ let mut bestdist = i32::MAX;
for (idx, entry) in pal.iter().enumerate() {
let dist0 = i32::from(pix[0]) - i32::from(entry[0]);
}
pub fn search(&self, pix: [u8; 3]) -> usize {
let idx = Self::quant(pix);
- let mut best_dist = std::u32::MAX;
+ let mut best_dist = u32::MAX;
let mut best_idx = 0;
let mut count = 0;
for clr in self.db[idx].iter() {
impl FromFmt<f32> for i32 {
fn cvt_from(val: f32) -> i32 {
if val >= 1.0 {
- std::i32::MAX
+ i32::MAX
} else if val <= -1.0 {
- std::i32::MIN
+ i32::MIN
} else {
let scale = (1u32 << 31) as f32;
(val * scale) as i32
}
}
-const MAX_DIFF: i32 = std::i32::MAX;
+const MAX_DIFF: i32 = i32::MAX;
fn luma15_delta(pix: &mut WorkPixel, pred: WorkPixel, tgt: WorkPixel, deltas: &[i32; 8], fat_deltas: &[i32; 8]) {
let mut tpix = *pix;
];
const FIRST_NODE: u8 = 255;
-const ERR_MAX: u32 = std::u32::MAX;
+const ERR_MAX: u32 = u32::MAX;
#[derive(Clone, Copy, Default)]
struct TrellisNode {
}
}
-const MAX_DIST: u32 = std::u32::MAX;
+const MAX_DIST: u32 = u32::MAX;
const DIST_THRESH: u32 = 256;
#[allow(clippy::wrong_self_convention)]
}
}
-const MAX_DIST: u32 = std::u32::MAX;
+const MAX_DIST: u32 = u32::MAX;
const DIST_THRESH: u32 = 256;
pub const LARGE_BLK8_DIST: u32 = 256;
bavg[chroma + 1] += blk.iter().fold(0u16, |acc, &x| acc + u16::from(x));
}
}
- let mut rough_dist = std::i32::MAX;
+ let mut rough_dist = i32::MAX;
for ytry in 0..mv_est.mv_range * 2 + 1 {
let dy = if (ytry & 1) == 0 { ytry >> 1 } else { -((ytry + 1) >> 1) };
let ypos = (mb_y as isize) * 16 + (dy as isize);
let (width, height) = mv_est.ref_frame.get_dimensions(0);
let bavg = ref_blk.iter().fold(0u16, |acc, &x| acc + u16::from(x));
- let mut rough_dist = std::i32::MAX;
+ let mut rough_dist = i32::MAX;
for ytry in 0..mv_est.mv_range * 2 + 1 {
let dy = if (ytry & 1) == 0 { ytry >> 1 } else { -((ytry + 1) >> 1) };
let ypos = (ypos_orig as isize) + (dy as isize);
let (width, height) = mv_est.ref_frame.get_dimensions(0);
let bavg = ref_blk.iter().fold(0u16, |acc, &x| acc + u16::from(x));
- let mut rough_dist = std::i32::MAX;
+ let mut rough_dist = i32::MAX;
for ytry in 0..mv_est.mv_range * 2 + 1 {
let dy = if (ytry & 1) == 0 { ytry >> 1 } else { -((ytry + 1) >> 1) };
let ypos = (ypos_orig as isize) + (dy as isize);
static mut COUNTER: usize = 0;
pub const SMALL_DIST: u32 = 256;
-pub const MAX_DIST: u32 = std::u32::MAX;
+pub const MAX_DIST: u32 = u32::MAX;
const INTER_TO_INTRA_RATIO: f32 = 0.85;
let sign = (nibble & self.smask) != 0;
let diff = (i32::from(2 * (nibble & !self.smask) + 1) * IMA_STEP_TABLE[self.step]) >> 3;
let sample = if !sign { self.predictor + diff } else { self.predictor - diff };
- self.predictor = sample.max(i32::from(std::i16::MIN)).min(i32::from(std::i16::MAX));
+ self.predictor = sample.max(i32::from(i16::MIN)).min(i32::from(i16::MAX));
self.step = istep.max(0).min(IMA_MAX_STEP as isize) as usize;
self.predictor as i16
}
fn new(bw: &'a mut ByteWriter<'a>) -> Self {
Self {
bw,
- maxpkt: std::usize::MAX, minpkt: 0,
- maxblk: std::u16::MAX, minblk: 0,
+ maxpkt: usize::MAX, minpkt: 0,
+ maxblk: u16::MAX, minblk: 0,
duration: 0,
bits: 0,
}
let mut best_idx = [0usize; 2];
for (ch, best_idx) in best_idx[..self.channels].iter_mut().enumerate() {
- let mut best_dist = std::i64::MAX;
+ let mut best_dist = i64::MAX;
for i in 0..ADAPT_COEFFS.len() {
let dist = self.calc_dist(ch, i, len);
if dist < best_dist {
fn find_nearest(pix: UnpackedPixel, pal: &[UnpackedPixel; 256]) -> usize {
let mut bestidx = 0;
- let mut bestdist = std::u32::MAX;
+ let mut bestdist = u32::MAX;
for (idx, entry) in pal.iter().enumerate() {
let dist = dist_core(pix, entry);
}
fn search(&self, pix: UnpackedPixel) -> usize {
let idx = Self::quant(pix);
- let mut best_dist = std::u32::MAX;
+ let mut best_dist = u32::MAX;
let mut best_idx = 0;
let mut count = 0;
for clr in self.db[idx].iter() {
}
}
if self.fill_dist == 0 {
- self.clr2_dist = std::u32::MAX;
- self.clr8_dist = std::u32::MAX;
+ self.clr2_dist = u32::MAX;
+ self.clr8_dist = u32::MAX;
return;
}
}
}
if self.clr2_dist == 0 {
- self.clr8_dist = std::u32::MAX;
+ self.clr8_dist = u32::MAX;
return;
}
use rc::*;
const THRESHOLD: u32 = 64;
-const MAX_DIST: u32 = std::u32::MAX;
+const MAX_DIST: u32 = u32::MAX;
#[derive(Clone,Copy,Default,PartialEq)]
enum DoublingMode {
self.mb.load(src, offsets, strides);
self.best_mbt = MacroblockType::default();
- self.best_dist = std::u32::MAX;
+ self.best_dist = u32::MAX;
self.best_bits = 0;
}
pub fn try_b_coding(&mut self, ref_p: &NAVideoBuffer<u8>, ref_n: &NAVideoBuffer<u8>, be: &mut BitsEstimator, me: &mut MotionEstimator, rdm: &RateDistMetric, mbstate: &MBState, refine: bool) {
let do_chroma = ((x & 1) == 0) && ((y & 1) == 0);
let mut best_mode = PRED4_DEF[0];
- let mut best_cdist = std::u32::MAX;
+ let mut best_cdist = u32::MAX;
let mut best_dist = 0;
let mut best_bits = 0;
for &try_mode in list.iter() {
}
}
-const MAX_DIST: u32 = std::u32::MAX;
+const MAX_DIST: u32 = u32::MAX;
const DIST_THRESH: u32 = 256;
#[allow(clippy::wrong_self_convention)]
impl MVSearch for DummySearcher {
fn search_mb(&mut self, _mv_est: &mut MVEstimator, _ref_mb: &RefMBData, _mb_x: usize, _mb_y: usize, _cand_mvs: &[MV]) -> (MV, u32) {
- (ZERO_MV, std::u32::MAX / 2)
+ (ZERO_MV, u32::MAX / 2)
}
fn search_blk8(&mut self, _mv_est: &mut MVEstimator, _ref_mb: &RefMBData, _xpos: usize, _ypos: usize, _cand_mvs: &[MV]) -> (MV, u32) {
- (ZERO_MV, std::u32::MAX / 2)
+ (ZERO_MV, u32::MAX / 2)
}
}
}
pub fn update_stats(&mut self, ftype: FrameType, fsize: usize, ts_diff: u32) {
if self.bitrate > 0 {
- if ts_diff > 0 && self.duration < std::u32::MAX / 2 {
+ if ts_diff > 0 && self.duration < u32::MAX / 2 {
self.duration += ts_diff;
self.dcount += 1;
}
}
fn clip16(a: i32) -> i16 {
- a.min(i32::from(std::i16::MAX)).max(i32::from(std::i16::MIN)) as i16
+ a.min(i32::from(i16::MAX)).max(i32::from(i16::MIN)) as i16
}
fn clip32(a: i64) -> i32 {
- a.min(i64::from(std::i32::MAX)).max(i64::from(std::i32::MIN)) as i32
+ a.min(i64::from(i32::MAX)).max(i64::from(i32::MIN)) as i32
}
fn mul16(a: i32, b: i16) -> i32 {
projects / nihav.git / commitdiff