openjp2 0.3.4

Rust port of Openjpeg.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

#[inline]
pub(crate) fn opj_int_max(mut a: i32, mut b: i32) -> i32 {
  a.max(b)
}

#[inline]
pub(crate) fn opj_int_min(mut a: i32, mut b: i32) -> i32 {
  a.min(b)
}

#[inline]
pub(crate) fn opj_uint_min(mut a: u32, mut b: u32) -> u32 {
  a.min(b)
}

#[inline]
pub(crate) fn opj_uint_max(mut a: u32, mut b: u32) -> u32 {
  a.max(b)
}

#[inline]
pub(crate) fn opj_int_floordivpow2(mut a: i32, mut b: i32) -> i32 {
  a >> b
}

#[inline]
pub(crate) fn opj_int_floorlog2(mut a: i32) -> i32 {
  let mut l: i32 = 0;
  l = 0;
  while a > 1 {
    a >>= 1;
    l += 1
  }
  l
}

#[inline]
pub(crate) fn opj_uint_floordivpow2(mut a: u32, mut b: u32) -> u32 {
  a >> b
}

#[inline]
pub(crate) fn opj_uint_floorlog2(mut a: u32) -> u32 {
  let mut l: u32 = 0;
  l = 0_u32;
  while a > 1 {
    a >>= 1;
    l += 1;
  }
  l
}

#[inline]
pub(crate) fn opj_uint_ceildivpow2(mut a: u32, mut b: u32) -> u32 {
  ((a as u64).wrapping_add(1_u64 << b).wrapping_sub(1_u64) >> b) as u32
}

#[inline]
pub(crate) fn opj_uint_ceildiv(mut a: u32, mut b: u32) -> u32 {
  assert!(b != 0);
  (a as u64)
    .wrapping_add(b as u64)
    .wrapping_sub(1_u64)
    .wrapping_div(b as u64) as u32
}

#[inline]
pub(crate) fn opj_int64_ceildivpow2(mut a: i64, mut b: i32) -> i32 {
  ((a + (1_i64 << b) - 1_i64) >> b) as i32
}

#[inline]
pub(crate) fn opj_int_ceildiv(mut a: i32, mut b: i32) -> i32 {
  assert!(b != 0);
  ((a as i64 + b as i64 - 1_i64) / b as i64) as i32
}

#[inline]
pub(crate) fn opj_uint64_ceildiv_res_uint32(mut a: u64, mut b: u64) -> u32 {
  assert!(b != 0);
  ((a + b - 1) / b) as u32
}

#[inline]
pub(crate) fn opj_int_ceildivpow2(mut a: i32, mut b: i32) -> i32 {
  ((a as i64 + (1_i64 << b) - 1_i64) >> b) as i32
}

#[inline]
pub(crate) fn opj_uint_adds(mut a: u32, mut b: u32) -> u32 {
  a.saturating_add(b)
}

#[inline]
pub(crate) fn opj_int_abs(mut a: i32) -> i32 {
  a.abs()
}

#[inline]
pub(crate) fn opj_uint_subs(mut a: u32, mut b: u32) -> u32 {
  a.saturating_sub(b)
}

#[inline]
pub(crate) fn opj_lrintf(mut f: f32) -> i64 {
  f.round_ties_even() as i64
}

#[inline]
pub(crate) fn opj_int64_clamp(mut a: i64, mut min: i64, mut max: i64) -> i64 {
  a.clamp(min, max)
}

#[inline]
pub(crate) fn opj_int_clamp(mut a: i32, mut min: i32, mut max: i32) -> i32 {
  a.clamp(min, max)
}

#[inline]
pub(crate) fn opj_int_sub_no_overflow(mut a: i32, mut b: i32) -> i32 {
  a.wrapping_sub(b)
}

#[inline]
pub(crate) fn opj_int_add_no_overflow(mut a: i32, mut b: i32) -> i32 {
  a.wrapping_add(b)
}