1 use super::Indeo3Writer;
3 use super::cell::{CellEncoder, MAX_CELL_SIZE};
5 pub enum Indeo3PrimaryTree {
6 VSplit(Box<Indeo3PrimaryTree>, Box<Indeo3PrimaryTree>),
7 HSplit(Box<Indeo3PrimaryTree>, Box<Indeo3PrimaryTree>),
8 RelFill(MV, Box<Indeo3SecondaryTree>),
9 AbsFill(Box<Indeo3SecondaryTree>),
12 impl Indeo3PrimaryTree {
14 println!("Plane tree:");
17 fn print1(&self, depth: u8) {
22 Indeo3PrimaryTree::VSplit(t1, t2) => {
23 println!("vertical split");
27 Indeo3PrimaryTree::HSplit(t1, t2) => {
28 println!("horizontal split");
32 Indeo3PrimaryTree::RelFill(mv, sec) => {
33 println!("relative fill {},{}", mv.x, mv.y);
34 sec.print1(depth + 1);
36 Indeo3PrimaryTree::AbsFill(sec) => {
37 println!("absolute fill");
38 sec.print1(depth + 1);
44 pub enum Indeo3SecondaryTree {
45 VSplit(Box<Indeo3SecondaryTree>, Box<Indeo3SecondaryTree>),
46 HSplit(Box<Indeo3SecondaryTree>, Box<Indeo3SecondaryTree>),
51 impl Indeo3SecondaryTree {
52 fn print1(&self, depth: u8) {
57 Indeo3SecondaryTree::VSplit(t1, t2) => {
58 println!("vertical split");
62 Indeo3SecondaryTree::HSplit(t1, t2) => {
63 println!("horizontal split");
67 Indeo3SecondaryTree::VQData(mode) => {
68 println!("VQ data ({})", mode);
70 Indeo3SecondaryTree::VQNull(mode) => {
71 println!("VQ Null ({})", mode);
77 const THRESHOLD: u32 = 64;
79 #[derive(Clone, Copy)]
80 pub struct Indeo3Cell {
89 pub fn new(width: usize, height: usize, intra: bool) -> Self {
94 h: (height / 4) as u8,
99 pub fn get_x(&self) -> usize { usize::from(self.x) * 4 }
100 pub fn get_y(&self) -> usize { usize::from(self.y) * 4 }
101 pub fn get_width(&self) -> usize { usize::from(self.w) * 4 }
102 pub fn get_height(&self) -> usize { usize::from(self.h) * 4 }
103 pub fn is_intra(&self) -> bool { self.intra }
105 fn split_h(&self) -> (Self, Self) {
106 let h1 = if self.h > 2 { ((self.h + 2) >> 2) << 1 } else { 1 };
107 let h2 = self.h - h1;
108 let mut cell1 = *self;
110 let mut cell2 = *self;
115 fn split_v(&self, stripw: u8) -> (Self, Self) {
116 let w1 = if self.w > stripw {
117 if self.w > stripw * 2 { stripw * 2 } else { stripw }
119 if self.w > 2 { ((self.w + 2) >> 2) << 1 } else { 1 }
121 let w2 = self.w - w1;
122 let mut cell1 = *self;
124 let mut cell2 = *self;
131 impl std::fmt::Display for Indeo3Cell {
132 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
133 write!(f, "[{}x{} @ {},{}{}]", self.get_width(), self.get_height(), self.get_x(), self.get_y(), if self.intra { " intra" } else { "" })
143 pub mvs: Vec<(MV, u16)>,
146 fn ssd(a: u8, b: u8) -> u32 {
147 let diff = i32::from(a) - i32::from(b);
152 pub fn alloc(&mut self, width: usize, height: usize, stripw: u8) {
153 self.data.resize(width * height, 0);
155 self.height = height;
156 self.stripw = stripw;
157 if self.mvs.capacity() < 256 {
158 self.mvs.reserve(256);
161 pub fn fill(&mut self, src: &[u8], stride: usize) {
162 for (dline, sline) in self.data.chunks_mut(self.width).zip(src.chunks(stride)) {
163 for (dst, &src) in dline.iter_mut().zip(sline.iter()) {
168 pub fn clear_mvs(&mut self){
171 pub fn checksum(&self) -> u16 {
172 let xors = self.data[self.width..].chunks(2).fold([0u8; 2], |acc, pair| [acc[0] ^ pair[0], acc[1] ^ pair[1]]);
173 u16::from(xors[0]) | (u16::from(xors[1]) * 256)
175 pub fn find_cells(&mut self, is_intra: bool, pplane: &Plane, mv_est: &MotionEstimator) -> Box<Indeo3PrimaryTree> {
176 let cell = Indeo3Cell::new(self.width, self.height, is_intra);
177 self.split_pri(cell, pplane, mv_est)
179 fn split_pri(&mut self, cell: Indeo3Cell, pplane: &Plane, mv_est: &MotionEstimator) -> Box<Indeo3PrimaryTree> {
180 let width = cell.get_width();
181 let height = cell.get_height();
182 if width * height > MAX_CELL_SIZE {
183 let (hsplit, vsplit) = if width != height {
184 (width > (self.stripw as usize) * 4 || width > height, height > width)
186 let (hdiff, vdiff) = self.calculate_diffs(cell);
187 (vdiff > THRESHOLD && vdiff > hdiff,
188 hdiff > THRESHOLD && hdiff > vdiff)
190 match (hsplit, vsplit) {
192 let (cell1, cell2) = cell.split_v(self.stripw);
193 let tree1 = self.split_pri(cell1, pplane, mv_est);
194 let tree2 = self.split_pri(cell2, pplane, mv_est);
195 Box::new(Indeo3PrimaryTree::VSplit(tree1, tree2))
198 let (cell1, cell2) = cell.split_h();
199 let tree1 = self.split_pri(cell1, pplane, mv_est);
200 let tree2 = self.split_pri(cell2, pplane, mv_est);
201 Box::new(Indeo3PrimaryTree::HSplit(tree1, tree2))
204 let sec = self.split_sec(cell);
205 Box::new(Indeo3PrimaryTree::AbsFill(sec))
210 if let Some((mv, flat)) = mv_est.mv_search(self, pplane, cell) {
211 return self.add_mv_tree(mv, flat);
214 // try splitting once to see if it improves situation
215 if width >= 16 && height >= 16 {
216 let vsplit = width > height;
217 let (cell1, cell2) = if vsplit {
218 cell.split_v(self.stripw)
222 let search1 = mv_est.mv_search(self, pplane, cell1);
223 let search2 = mv_est.mv_search(self, pplane, cell2);
224 if search1.is_some() || search2.is_some() {
225 let tree1 = if let Some((mv, flat)) = search1 {
226 self.add_mv_tree(mv, flat)
228 let sec = self.split_sec(cell1);
229 Box::new(Indeo3PrimaryTree::AbsFill(sec))
231 let tree2 = if let Some((mv, flat)) = search2 {
232 self.add_mv_tree(mv, flat)
234 let sec = self.split_sec(cell2);
235 Box::new(Indeo3PrimaryTree::AbsFill(sec))
238 Box::new(Indeo3PrimaryTree::VSplit(tree1, tree2))
240 Box::new(Indeo3PrimaryTree::HSplit(tree1, tree2))
245 let sec = self.split_sec(cell);
246 Box::new(Indeo3PrimaryTree::AbsFill(sec))
249 fn add_mv_tree(&mut self, mv: MV, flat: bool) -> Box<Indeo3PrimaryTree> {
251 Box::new(Indeo3SecondaryTree::VQNull(0))
253 Box::new(Indeo3SecondaryTree::VQData(0))
256 let mut found = false;
257 for (ref cmv, ref mut count) in self.mvs.iter_mut() {
265 self.mvs.push((mv, 1));
268 Box::new(Indeo3PrimaryTree::RelFill(mv, sec))
270 fn split_sec(&mut self, cell: Indeo3Cell) -> Box<Indeo3SecondaryTree> {
271 let (hdiff, vdiff) = self.calculate_diffs(cell);
272 if hdiff == 0 && vdiff == 0 {
274 return Box::new(Indeo3SecondaryTree::VQNull(0));
276 return Box::new(Indeo3SecondaryTree::VQData(0));
279 if cell.get_width() > 16 && cell.get_height() > 16 {
280 let hsplit = vdiff > THRESHOLD && vdiff > hdiff * 2;
281 let vsplit = hdiff > THRESHOLD && hdiff > vdiff * 2;
282 match (vsplit, hsplit) {
284 let (cell1, cell2) = cell.split_v(self.stripw);
285 let tree1 = self.split_sec(cell1);
286 let tree2 = self.split_sec(cell2);
287 Box::new(Indeo3SecondaryTree::VSplit(tree1, tree2))
290 let (cell1, cell2) = cell.split_h();
291 let tree1 = self.split_sec(cell1);
292 let tree2 = self.split_sec(cell2);
293 Box::new(Indeo3SecondaryTree::HSplit(tree1, tree2))
296 Box::new(Indeo3SecondaryTree::VQData(0))
300 let is_w8 = (cell.get_width() & 7) == 0;
301 let is_h8 = (cell.get_height() & 7) == 0;
302 let mode = match (hdiff > THRESHOLD, vdiff > THRESHOLD) {
303 (false, false) if is_w8 && is_h8 => 10,
304 (_, true) if is_h8 => 3,
307 Box::new(Indeo3SecondaryTree::VQData(mode))
310 fn calculate_diffs(&self, cell: Indeo3Cell) -> (u32, u32) {
311 let offset = cell.get_x() + cell.get_y() * self.width;
312 let mut w = cell.get_width();
313 if cell.get_x() + w == self.width { w -= 1; }
314 let mut h = cell.get_height();
315 if cell.get_y() + h == self.height { h -= 1; }
319 let src0 = &self.data[offset..];
320 let src1 = &self.data[offset + self.width..];
321 for (line0, line1) in src0.chunks(self.width).zip(src1.chunks(self.width)).take(h) {
322 for ((&cur, &right), &bottom) in line0.iter().zip(line0[1..].iter()).zip(line1.iter()).take(w) {
323 hdiff += ssd(cur, right);
324 vdiff += ssd(cur, bottom);
327 let area = (w * h) as u32;
328 (hdiff * 16 / area, vdiff * 16 / area)
330 pub fn encode_tree(&mut self, iw: &mut Indeo3Writer, tree: &Indeo3PrimaryTree, cenc: &mut CellEncoder, is_intra: bool, refp: &Plane) {
331 let cell = Indeo3Cell::new(self.width, self.height, is_intra);
332 self.encode_pri(iw, cell, tree, cenc, refp);
334 fn encode_pri(&mut self, iw: &mut Indeo3Writer, mut cell: Indeo3Cell, tree: &Indeo3PrimaryTree, cenc: &mut CellEncoder, refp: &Plane) {
336 Indeo3PrimaryTree::HSplit(t1, t2) => {
338 let (cell1, cell2) = cell.split_h();
339 self.encode_pri(iw, cell1, t1, cenc, refp);
340 self.encode_pri(iw, cell2, t2, cenc, refp);
342 Indeo3PrimaryTree::VSplit(t1, t2) => {
344 let (cell1, cell2) = cell.split_v(self.stripw);
345 self.encode_pri(iw, cell1, t1, cenc, refp);
346 self.encode_pri(iw, cell2, t2, cenc, refp);
348 Indeo3PrimaryTree::AbsFill(sec) => {
351 self.encode_sec(iw, cell, sec, cenc);
353 Indeo3PrimaryTree::RelFill(mv, sec) => {
354 if let Some(mv_idx) = find_mv(*mv, &self.mvs) {
358 let real_mv = self.mvs[usize::from(mv_idx)].0;
359 self.encode_sec_inter(iw, cell, sec, cenc, real_mv, refp);
363 self.encode_sec(iw, cell, sec, cenc);
368 fn encode_sec(&mut self, iw: &mut Indeo3Writer, cell: Indeo3Cell, tree: &Indeo3SecondaryTree, cenc: &mut CellEncoder) {
370 Indeo3SecondaryTree::HSplit(t1, t2) => {
372 let (cell1, cell2) = cell.split_h();
373 self.encode_sec(iw, cell1, t1, cenc);
374 self.encode_sec(iw, cell2, t2, cenc);
376 Indeo3SecondaryTree::VSplit(t1, t2) => {
378 let (cell1, cell2) = cell.split_v(self.stripw);
379 self.encode_sec(iw, cell1, t1, cenc);
380 self.encode_sec(iw, cell2, t2, cenc);
382 Indeo3SecondaryTree::VQNull(mode) => {
386 Indeo3SecondaryTree::VQData(mode) => {
388 self.encode_cell_data_intra(iw, cell, cenc, *mode);
392 fn encode_sec_inter(&mut self, iw: &mut Indeo3Writer, cell: Indeo3Cell, tree: &Indeo3SecondaryTree, cenc: &mut CellEncoder, mv: MV, refp: &Plane) {
394 Indeo3SecondaryTree::HSplit(_t1, _t2) => {
397 Indeo3SecondaryTree::VSplit(_t1, _t2) => {
400 Indeo3SecondaryTree::VQNull(mode) => {
403 cenc.read_mv_buffer(refp, cell, mv);
405 cenc.put_buffer(self);
407 Indeo3SecondaryTree::VQData(_mode) => {
409 self.encode_cell_data_inter(iw, cell, cenc, mv, refp);
413 fn encode_cell_data_intra(&mut self, iw: &mut Indeo3Writer, cell: Indeo3Cell, cenc: &mut CellEncoder, mode: u8) {
414 cenc.read_buffer(self, cell);
415 cenc.gen_diffs_intra();
416 cenc.compress_intra(mode);
417 cenc.put_buffer(self);
418 for &b in cenc.out[..cenc.osize].iter() {
422 fn encode_cell_data_inter(&mut self, iw: &mut Indeo3Writer, cell: Indeo3Cell, cenc: &mut CellEncoder, mv: MV, refp: &Plane) {
423 cenc.read_buffer(self, cell);
424 cenc.read_mv_buffer(refp, cell, mv);
425 cenc.gen_diffs_inter();
426 cenc.compress_inter();
427 cenc.put_buffer(self);
428 for &b in cenc.out[..cenc.osize].iter() {