1pub struct LfMi {
30 pub skip: bool,
31 pub is_inter: bool,
32 pub tx_size_y: u8,
34 pub bw_mi: u8,
36 pub bh_mi: u8,
37 pub bsize_idx: usize,
39 pub block_origin: bool,
41 pub level: u8,
43}
44
45pub const DEFAULT_LF_REF_DELTAS: [i8; 4] = [1, 0, -1, -1];
48
49pub const DEFAULT_LF_MODE_DELTAS: [i8; 2] = [0, 0];
51
52pub fn mode_lf_delta_idx(mode: i8) -> usize {
54 match mode {
55 12 => 0, 10 | 11 | 13 => 1,
58 _ => 0, }
60}
61
62pub fn lf_level_for_mi(base: u8, ref_frame: i8, mode: i8) -> u8 {
64 if base == 0 {
65 return 0;
66 }
67 let scale = 1i32 << (base >> 5);
68 let rf = ref_frame.clamp(0, 3) as usize;
69 let md = mode_lf_delta_idx(mode);
70 let lvl = i32::from(base)
71 + i32::from(DEFAULT_LF_REF_DELTAS[rf]) * scale
72 + i32::from(DEFAULT_LF_MODE_DELTAS[md]) * scale;
73 lvl.clamp(0, 63) as u8
74}
75
76const MI_BLOCK_SIZE: usize = 8; const MAX_LOOP_FILTER: usize = 63;
78
79#[derive(Clone, Copy, Default)]
85struct LoopFilterThresh {
86 mblim: u8,
87 lim: u8,
88 hev_thr: u8,
89}
90
91fn build_thresholds(sharpness: u8) -> [LoopFilterThresh; MAX_LOOP_FILTER + 1] {
92 let mut out = [LoopFilterThresh::default(); MAX_LOOP_FILTER + 1];
93 let sharpness = sharpness as i32;
94 for lvl in 0..=MAX_LOOP_FILTER {
95 let lvl_i = lvl as i32;
96 let mut block_inside_limit = lvl_i >> ((sharpness > 0) as i32 + (sharpness > 4) as i32);
97 if sharpness > 0 && block_inside_limit > 9 - sharpness {
98 block_inside_limit = 9 - sharpness;
99 }
100 if block_inside_limit < 1 {
101 block_inside_limit = 1;
102 }
103 out[lvl].lim = block_inside_limit as u8;
104 out[lvl].mblim = (2 * (lvl_i + 2) + block_inside_limit) as u8;
105 out[lvl].hev_thr = (lvl_i >> 4) as u8;
106 }
107 out
108}
109
110const LEFT_PRED_MASK_Y: [u64; 13] = [
116 0x0000_0000_0000_0001, 0x0000_0000_0000_0001, 0x0000_0000_0000_0001, 0x0000_0000_0000_0001, 0x0000_0000_0000_0101, 0x0000_0000_0000_0001, 0x0000_0000_0000_0101, 0x0000_0000_0101_0101, 0x0000_0000_0000_0101, 0x0000_0000_0101_0101, 0x0101_0101_0101_0101, 0x0000_0000_0101_0101, 0x0101_0101_0101_0101, ];
130const ABOVE_PRED_MASK_Y: [u64; 13] = [
131 0x1, 0x1, 0x1, 0x1, 0x1, 0x3, 0x3, 0x3, 0xf, 0xf, 0xf, 0xff, 0xff,
132];
133const SIZE_MASK_Y: [u64; 13] = [
134 0x0000_0000_0000_0001,
135 0x0000_0000_0000_0001,
136 0x0000_0000_0000_0001,
137 0x0000_0000_0000_0001, 0x0000_0000_0000_0101, 0x0000_0000_0000_0003, 0x0000_0000_0000_0303, 0x0000_0000_0303_0303, 0x0000_0000_0000_0f0f, 0x0000_0000_0f0f_0f0f, 0x0f0f_0f0f_0f0f_0f0f, 0x0000_0000_ffff_ffff, 0xffff_ffff_ffff_ffff, ];
148
149const LEFT_PRED_MASK_UV: [u16; 13] = [
150 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0011, 0x0001, 0x0011, 0x1111, 0x0011,
151 0x1111,
152];
153const ABOVE_PRED_MASK_UV: [u16; 13] = [
154 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0003, 0x0003, 0x0003, 0x000f,
155 0x000f,
156];
157const SIZE_MASK_UV: [u16; 13] = [
158 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0011, 0x0003, 0x0033, 0x3333, 0x00ff,
159 0xffff,
160];
161
162const LEFT_TXFORM_MASK_Y: [u64; 4] = [
164 0xffff_ffff_ffff_ffff,
165 0xffff_ffff_ffff_ffff,
166 0x5555_5555_5555_5555,
167 0x1111_1111_1111_1111,
168];
169const ABOVE_TXFORM_MASK_Y: [u64; 4] = [
170 0xffff_ffff_ffff_ffff,
171 0xffff_ffff_ffff_ffff,
172 0x00ff_00ff_00ff_00ff,
173 0x0000_00ff_0000_00ff,
174];
175const LEFT_TXFORM_MASK_UV: [u16; 4] = [0xffff, 0xffff, 0x5555, 0x1111];
176const ABOVE_TXFORM_MASK_UV: [u16; 4] = [0xffff, 0xffff, 0x0f0f, 0x000f];
177
178const LEFT_BORDER_Y: u64 = 0x1111_1111_1111_1111;
179const ABOVE_BORDER_Y: u64 = 0x0000_00ff_0000_00ff;
180const LEFT_BORDER_UV: u16 = 0x1111;
181const ABOVE_BORDER_UV: u16 = 0x000f;
182
183#[inline]
185fn first_block_in_16x16(row_in_sb: usize, col_in_sb: usize) -> bool {
186 row_in_sb.is_multiple_of(2) && col_in_sb.is_multiple_of(2)
187}
188
189#[derive(Clone)]
191struct LoopFilterMask {
192 left_y: [u64; 4],
193 above_y: [u64; 4],
194 int_4x4_y: u64,
195 lfl_y: [u8; 64],
196 left_uv: [u16; 4],
197 above_uv: [u16; 4],
198 int_4x4_uv: u16,
199}
200
201impl Default for LoopFilterMask {
202 fn default() -> Self {
203 LoopFilterMask {
204 left_y: [0; 4],
205 above_y: [0; 4],
206 int_4x4_y: 0,
207 lfl_y: [0; 64],
208 left_uv: [0; 4],
209 above_uv: [0; 4],
210 int_4x4_uv: 0,
211 }
212 }
213}
214
215#[allow(clippy::too_many_arguments)]
217fn build_mask(
218 level: u8,
219 is_inter: bool,
220 skip: bool,
221 tx_size_y: u8,
222 bsize_idx: usize,
223 bw_mi: usize,
224 bh_mi: usize,
225 row_in_sb: usize,
226 col_in_sb: usize,
227 lfm: &mut LoopFilterMask,
228) {
229 if level == 0 {
230 return;
231 }
232 let tx_cap = (bw_mi.min(bh_mi).trailing_zeros()) as u8;
234 let tx_size_uv = tx_size_y.min(tx_cap);
235
236 let shift_y = col_in_sb + (row_in_sb << 3);
237 let shift_uv = (col_in_sb >> 1) + ((row_in_sb >> 1) << 2);
238 let build_uv = first_block_in_16x16(row_in_sb, col_in_sb);
239
240 let mut index = shift_y;
241 for _ in 0..bh_mi {
242 for k in 0..bw_mi {
243 lfm.lfl_y[index + k] = level;
244 }
245 index += 8;
246 }
247
248 lfm.above_y[tx_size_y as usize] |= ABOVE_PRED_MASK_Y[bsize_idx] << shift_y;
249 lfm.left_y[tx_size_y as usize] |= LEFT_PRED_MASK_Y[bsize_idx] << shift_y;
250 if build_uv {
251 lfm.above_uv[tx_size_uv as usize] |= ABOVE_PRED_MASK_UV[bsize_idx] << shift_uv;
252 lfm.left_uv[tx_size_uv as usize] |= LEFT_PRED_MASK_UV[bsize_idx] << shift_uv;
253 }
254
255 if skip && is_inter {
256 return;
257 }
258
259 lfm.above_y[tx_size_y as usize] |=
260 (SIZE_MASK_Y[bsize_idx] & ABOVE_TXFORM_MASK_Y[tx_size_y as usize]) << shift_y;
261 lfm.left_y[tx_size_y as usize] |=
262 (SIZE_MASK_Y[bsize_idx] & LEFT_TXFORM_MASK_Y[tx_size_y as usize]) << shift_y;
263 if build_uv {
264 lfm.above_uv[tx_size_uv as usize] |=
265 (SIZE_MASK_UV[bsize_idx] & ABOVE_TXFORM_MASK_UV[tx_size_uv as usize]) << shift_uv;
266 lfm.left_uv[tx_size_uv as usize] |=
267 (SIZE_MASK_UV[bsize_idx] & LEFT_TXFORM_MASK_UV[tx_size_uv as usize]) << shift_uv;
268 }
269
270 if tx_size_y == 0 {
271 lfm.int_4x4_y |= SIZE_MASK_Y[bsize_idx] << shift_y;
272 }
273 if build_uv && tx_size_uv == 0 {
274 lfm.int_4x4_uv |= SIZE_MASK_UV[bsize_idx] << shift_uv;
275 }
276}
277
278fn adjust_mask(
280 mi_rows: usize,
281 mi_cols: usize,
282 sb_row: usize,
283 sb_col: usize,
284 lfm: &mut LoopFilterMask,
285) {
286 lfm.left_y[2] |= lfm.left_y[3];
287 lfm.above_y[2] |= lfm.above_y[3];
288 lfm.left_uv[2] |= lfm.left_uv[3];
289 lfm.above_uv[2] |= lfm.above_uv[3];
290
291 lfm.left_y[1] |= lfm.left_y[0] & LEFT_BORDER_Y;
292 lfm.left_y[0] &= !LEFT_BORDER_Y;
293 lfm.above_y[1] |= lfm.above_y[0] & ABOVE_BORDER_Y;
294 lfm.above_y[0] &= !ABOVE_BORDER_Y;
295 lfm.left_uv[1] |= lfm.left_uv[0] & LEFT_BORDER_UV;
296 lfm.left_uv[0] &= !LEFT_BORDER_UV;
297 lfm.above_uv[1] |= lfm.above_uv[0] & ABOVE_BORDER_UV;
298 lfm.above_uv[0] &= !ABOVE_BORDER_UV;
299
300 if sb_row + MI_BLOCK_SIZE > mi_rows {
301 let rows = (mi_rows - sb_row) as u32;
302 let mask_y: u64 = (1u64 << (rows * 8)) - 1;
303 let mask_uv: u16 = (((1u32 << (((rows + 1) >> 1) * 4)) - 1) & 0xffff) as u16;
304
305 for i in 0..3 {
306 lfm.left_y[i] &= mask_y;
307 lfm.above_y[i] &= mask_y;
308 lfm.left_uv[i] &= mask_uv;
309 lfm.above_uv[i] &= mask_uv;
310 }
311 lfm.int_4x4_y &= mask_y;
312 lfm.int_4x4_uv &= mask_uv;
313
314 if rows == 1 {
315 lfm.above_uv[1] |= lfm.above_uv[2];
316 lfm.above_uv[2] = 0;
317 }
318 if rows == 5 {
319 lfm.above_uv[1] |= lfm.above_uv[2] & 0xff00;
320 lfm.above_uv[2] &= !0xff00u16;
321 }
322 }
323
324 if sb_col + MI_BLOCK_SIZE > mi_cols {
325 let columns = (mi_cols - sb_col) as u32;
326 let mask_y: u64 = ((1u64 << columns) - 1).wrapping_mul(0x0101_0101_0101_0101);
327 let mask_uv: u16 =
328 (((1u32 << ((columns + 1) >> 1)) - 1).wrapping_mul(0x1111) & 0xffff) as u16;
329 let mask_uv_int: u16 =
330 (((1u32 << (columns >> 1)) - 1).wrapping_mul(0x1111) & 0xffff) as u16;
331
332 for i in 0..3 {
333 lfm.left_y[i] &= mask_y;
334 lfm.above_y[i] &= mask_y;
335 lfm.left_uv[i] &= mask_uv;
336 lfm.above_uv[i] &= mask_uv;
337 }
338 lfm.int_4x4_y &= mask_y;
339 lfm.int_4x4_uv &= mask_uv_int;
340
341 if columns == 1 {
342 lfm.left_uv[1] |= lfm.left_uv[2];
343 lfm.left_uv[2] = 0;
344 }
345 if columns == 5 {
346 lfm.left_uv[1] |= lfm.left_uv[2] & 0xcccc;
347 lfm.left_uv[2] &= !0xccccu16;
348 }
349 }
350
351 if sb_col == 0 {
352 for i in 0..3 {
353 lfm.left_y[i] &= 0xfefe_fefe_fefe_fefe;
354 lfm.left_uv[i] &= 0xeeee;
355 }
356 }
357}
358
359#[inline]
364fn signed_char_clamp(t: i32) -> i32 {
365 t.clamp(-128, 127)
366}
367
368#[inline]
369fn round_pow2_i(v: i32, n: u32) -> i32 {
370 (v + (1 << (n - 1))) >> n
371}
372
373#[inline]
374fn round_pow2_u(v: u32, n: u32) -> u32 {
375 (v + (1 << (n - 1))) >> n
376}
377
378#[inline]
379fn filter_mask(
380 limit: u8,
381 blimit: u8,
382 p3: u8,
383 p2: u8,
384 p1: u8,
385 p0: u8,
386 q0: u8,
387 q1: u8,
388 q2: u8,
389 q3: u8,
390) -> bool {
391 let limit = limit as i32;
392 let blimit = blimit as i32;
393 let d = |a: u8, b: u8| (a as i32 - b as i32).abs();
394 d(p3, p2) <= limit
395 && d(p2, p1) <= limit
396 && d(p1, p0) <= limit
397 && d(q1, q0) <= limit
398 && d(q2, q1) <= limit
399 && d(q3, q2) <= limit
400 && d(p0, q0) * 2 + d(p1, q1) / 2 <= blimit
401}
402
403#[inline]
404fn flat_mask4(thresh: u8, p3: u8, p2: u8, p1: u8, p0: u8, q0: u8, q1: u8, q2: u8, q3: u8) -> bool {
405 let thresh = thresh as i32;
406 let d = |a: u8, b: u8| (a as i32 - b as i32).abs();
407 d(p1, p0) <= thresh
408 && d(q1, q0) <= thresh
409 && d(p2, p0) <= thresh
410 && d(q2, q0) <= thresh
411 && d(p3, p0) <= thresh
412 && d(q3, q0) <= thresh
413}
414
415#[inline]
416#[allow(clippy::too_many_arguments)]
417fn flat_mask5(
418 thresh: u8,
419 p4: u8,
420 p3: u8,
421 p2: u8,
422 p1: u8,
423 p0: u8,
424 q0: u8,
425 q1: u8,
426 q2: u8,
427 q3: u8,
428 q4: u8,
429) -> bool {
430 let thresh_i = thresh as i32;
431 flat_mask4(thresh, p3, p2, p1, p0, q0, q1, q2, q3)
432 && (p4 as i32 - p0 as i32).abs() <= thresh_i
433 && (q4 as i32 - q0 as i32).abs() <= thresh_i
434}
435
436#[inline]
437fn hev_mask(thresh: u8, p1: u8, p0: u8, q0: u8, q1: u8) -> bool {
438 let thresh = thresh as i32;
439 (p1 as i32 - p0 as i32).abs() > thresh || (q1 as i32 - q0 as i32).abs() > thresh
440}
441
442fn filter4(mask: bool, thresh: u8, buf: &mut [u8], op1: usize, op0: usize, oq0: usize, oq1: usize) {
444 let (p1, p0, q0, q1) = (buf[op1], buf[op0], buf[oq0], buf[oq1]);
445 let (ps1, ps0, qs0, qs1) = (
446 p1 as i32 - 128,
447 p0 as i32 - 128,
448 q0 as i32 - 128,
449 q1 as i32 - 128,
450 );
451 let hev = hev_mask(thresh, p1, p0, q0, q1);
452
453 let mut filter = signed_char_clamp(ps1 - qs1);
454 filter = if hev { filter } else { 0 };
455
456 filter = signed_char_clamp(filter + 3 * (qs0 - ps0));
457 filter = if mask { filter } else { 0 };
458
459 let filter1 = signed_char_clamp(filter + 4) >> 3;
460 let filter2 = signed_char_clamp(filter + 3) >> 3;
461
462 buf[oq0] = (signed_char_clamp(qs0 - filter1) + 128) as u8;
463 buf[op0] = (signed_char_clamp(ps0 + filter2) + 128) as u8;
464
465 let outer = round_pow2_i(filter1, 1);
466 let outer = if hev { 0 } else { outer };
467
468 buf[oq1] = (signed_char_clamp(qs1 - outer) + 128) as u8;
469 buf[op1] = (signed_char_clamp(ps1 + outer) + 128) as u8;
470}
471
472#[allow(clippy::too_many_arguments)]
474fn filter8(
475 mask: bool,
476 thresh: u8,
477 flat: bool,
478 buf: &mut [u8],
479 op3: usize,
480 op2: usize,
481 op1: usize,
482 op0: usize,
483 oq0: usize,
484 oq1: usize,
485 oq2: usize,
486 oq3: usize,
487) {
488 if flat && mask {
489 let p3 = buf[op3] as u32;
490 let p2 = buf[op2] as u32;
491 let p1 = buf[op1] as u32;
492 let p0 = buf[op0] as u32;
493 let q0 = buf[oq0] as u32;
494 let q1 = buf[oq1] as u32;
495 let q2 = buf[oq2] as u32;
496 let q3 = buf[oq3] as u32;
497
498 buf[op2] = round_pow2_u(p3 + p3 + p3 + 2 * p2 + p1 + p0 + q0, 3) as u8;
499 buf[op1] = round_pow2_u(p3 + p3 + p2 + 2 * p1 + p0 + q0 + q1, 3) as u8;
500 buf[op0] = round_pow2_u(p3 + p2 + p1 + 2 * p0 + q0 + q1 + q2, 3) as u8;
501 buf[oq0] = round_pow2_u(p2 + p1 + p0 + 2 * q0 + q1 + q2 + q3, 3) as u8;
502 buf[oq1] = round_pow2_u(p1 + p0 + q0 + 2 * q1 + q2 + q3 + q3, 3) as u8;
503 buf[oq2] = round_pow2_u(p0 + q0 + q1 + 2 * q2 + q3 + q3 + q3, 3) as u8;
504 } else {
505 filter4(mask, thresh, buf, op1, op0, oq0, oq1);
506 }
507}
508
509#[allow(clippy::too_many_arguments)]
511fn filter16(
512 mask: bool,
513 thresh: u8,
514 flat: bool,
515 flat2: bool,
516 buf: &mut [u8],
517 idx: [usize; 16], ) {
519 let [op7, op6, op5, op4, op3, op2, op1, op0, oq0, oq1, oq2, oq3, oq4, oq5, oq6, oq7] = idx;
520 if flat2 && flat && mask {
521 let p7 = buf[op7] as u32;
522 let p6 = buf[op6] as u32;
523 let p5 = buf[op5] as u32;
524 let p4 = buf[op4] as u32;
525 let p3 = buf[op3] as u32;
526 let p2 = buf[op2] as u32;
527 let p1 = buf[op1] as u32;
528 let p0 = buf[op0] as u32;
529 let q0 = buf[oq0] as u32;
530 let q1 = buf[oq1] as u32;
531 let q2 = buf[oq2] as u32;
532 let q3 = buf[oq3] as u32;
533 let q4 = buf[oq4] as u32;
534 let q5 = buf[oq5] as u32;
535 let q6 = buf[oq6] as u32;
536 let q7 = buf[oq7] as u32;
537
538 buf[op6] = round_pow2_u(p7 * 7 + p6 * 2 + p5 + p4 + p3 + p2 + p1 + p0 + q0, 4) as u8;
539 buf[op5] = round_pow2_u(p7 * 6 + p6 + p5 * 2 + p4 + p3 + p2 + p1 + p0 + q0 + q1, 4) as u8;
540 buf[op4] = round_pow2_u(
541 p7 * 5 + p6 + p5 + p4 * 2 + p3 + p2 + p1 + p0 + q0 + q1 + q2,
542 4,
543 ) as u8;
544 buf[op3] = round_pow2_u(
545 p7 * 4 + p6 + p5 + p4 + p3 * 2 + p2 + p1 + p0 + q0 + q1 + q2 + q3,
546 4,
547 ) as u8;
548 buf[op2] = round_pow2_u(
549 p7 * 3 + p6 + p5 + p4 + p3 + p2 * 2 + p1 + p0 + q0 + q1 + q2 + q3 + q4,
550 4,
551 ) as u8;
552 buf[op1] = round_pow2_u(
553 p7 * 2 + p6 + p5 + p4 + p3 + p2 + p1 * 2 + p0 + q0 + q1 + q2 + q3 + q4 + q5,
554 4,
555 ) as u8;
556 buf[op0] = round_pow2_u(
557 p7 + p6 + p5 + p4 + p3 + p2 + p1 + p0 * 2 + q0 + q1 + q2 + q3 + q4 + q5 + q6,
558 4,
559 ) as u8;
560 buf[oq0] = round_pow2_u(
561 p6 + p5 + p4 + p3 + p2 + p1 + p0 + q0 * 2 + q1 + q2 + q3 + q4 + q5 + q6 + q7,
562 4,
563 ) as u8;
564 buf[oq1] = round_pow2_u(
565 p5 + p4 + p3 + p2 + p1 + p0 + q0 + q1 * 2 + q2 + q3 + q4 + q5 + q6 + q7 * 2,
566 4,
567 ) as u8;
568 buf[oq2] = round_pow2_u(
569 p4 + p3 + p2 + p1 + p0 + q0 + q1 + q2 * 2 + q3 + q4 + q5 + q6 + q7 * 3,
570 4,
571 ) as u8;
572 buf[oq3] = round_pow2_u(
573 p3 + p2 + p1 + p0 + q0 + q1 + q2 + q3 * 2 + q4 + q5 + q6 + q7 * 4,
574 4,
575 ) as u8;
576 buf[oq4] = round_pow2_u(
577 p2 + p1 + p0 + q0 + q1 + q2 + q3 + q4 * 2 + q5 + q6 + q7 * 5,
578 4,
579 ) as u8;
580 buf[oq5] = round_pow2_u(p1 + p0 + q0 + q1 + q2 + q3 + q4 + q5 * 2 + q6 + q7 * 6, 4) as u8;
581 buf[oq6] = round_pow2_u(p0 + q0 + q1 + q2 + q3 + q4 + q5 + q6 * 2 + q7 * 7, 4) as u8;
582 } else {
583 filter8(
584 mask, thresh, flat, buf, op3, op2, op1, op0, oq0, oq1, oq2, oq3,
585 );
586 }
587}
588
589fn lpf_vertical_4(buf: &mut [u8], stride: usize, pos: usize, blimit: u8, limit: u8, thresh: u8) {
599 for i in 0..8 {
600 let s = pos + i * stride;
601 let (p3, p2, p1, p0) = (buf[s - 4], buf[s - 3], buf[s - 2], buf[s - 1]);
602 let (q0, q1, q2, q3) = (buf[s], buf[s + 1], buf[s + 2], buf[s + 3]);
603 let mask = filter_mask(limit, blimit, p3, p2, p1, p0, q0, q1, q2, q3);
604 filter4(mask, thresh, buf, s - 2, s - 1, s, s + 1);
605 }
606}
607
608fn lpf_vertical_8(buf: &mut [u8], stride: usize, pos: usize, blimit: u8, limit: u8, thresh: u8) {
609 for i in 0..8 {
610 let s = pos + i * stride;
611 let (p3, p2, p1, p0) = (buf[s - 4], buf[s - 3], buf[s - 2], buf[s - 1]);
612 let (q0, q1, q2, q3) = (buf[s], buf[s + 1], buf[s + 2], buf[s + 3]);
613 let mask = filter_mask(limit, blimit, p3, p2, p1, p0, q0, q1, q2, q3);
614 let flat = flat_mask4(1, p3, p2, p1, p0, q0, q1, q2, q3);
615 filter8(
616 mask,
617 thresh,
618 flat,
619 buf,
620 s - 4,
621 s - 3,
622 s - 2,
623 s - 1,
624 s,
625 s + 1,
626 s + 2,
627 s + 3,
628 );
629 }
630}
631
632fn lpf_vertical_16(buf: &mut [u8], stride: usize, pos: usize, blimit: u8, limit: u8, thresh: u8) {
633 for i in 0..8 {
634 let s = pos + i * stride;
635 let (p3, p2, p1, p0) = (buf[s - 4], buf[s - 3], buf[s - 2], buf[s - 1]);
636 let (q0, q1, q2, q3) = (buf[s], buf[s + 1], buf[s + 2], buf[s + 3]);
637 let mask = filter_mask(limit, blimit, p3, p2, p1, p0, q0, q1, q2, q3);
638 let flat = flat_mask4(1, p3, p2, p1, p0, q0, q1, q2, q3);
639 let flat2 = flat_mask5(
640 1,
641 buf[s - 8],
642 buf[s - 7],
643 buf[s - 6],
644 buf[s - 5],
645 p0,
646 q0,
647 buf[s + 4],
648 buf[s + 5],
649 buf[s + 6],
650 buf[s + 7],
651 );
652 filter16(
653 mask,
654 thresh,
655 flat,
656 flat2,
657 buf,
658 [
659 s - 8,
660 s - 7,
661 s - 6,
662 s - 5,
663 s - 4,
664 s - 3,
665 s - 2,
666 s - 1,
667 s,
668 s + 1,
669 s + 2,
670 s + 3,
671 s + 4,
672 s + 5,
673 s + 6,
674 s + 7,
675 ],
676 );
677 }
678}
679
680fn lpf_horizontal_4(buf: &mut [u8], stride: usize, pos: usize, blimit: u8, limit: u8, thresh: u8) {
681 for i in 0..8 {
682 let s = pos + i;
683 let (p3, p2, p1, p0) = (
684 buf[s - 4 * stride],
685 buf[s - 3 * stride],
686 buf[s - 2 * stride],
687 buf[s - stride],
688 );
689 let (q0, q1, q2, q3) = (
690 buf[s],
691 buf[s + stride],
692 buf[s + 2 * stride],
693 buf[s + 3 * stride],
694 );
695 let mask = filter_mask(limit, blimit, p3, p2, p1, p0, q0, q1, q2, q3);
696 filter4(mask, thresh, buf, s - 2 * stride, s - stride, s, s + stride);
697 }
698}
699
700fn lpf_horizontal_8(buf: &mut [u8], stride: usize, pos: usize, blimit: u8, limit: u8, thresh: u8) {
701 for i in 0..8 {
702 let s = pos + i;
703 let (p3, p2, p1, p0) = (
704 buf[s - 4 * stride],
705 buf[s - 3 * stride],
706 buf[s - 2 * stride],
707 buf[s - stride],
708 );
709 let (q0, q1, q2, q3) = (
710 buf[s],
711 buf[s + stride],
712 buf[s + 2 * stride],
713 buf[s + 3 * stride],
714 );
715 let mask = filter_mask(limit, blimit, p3, p2, p1, p0, q0, q1, q2, q3);
716 let flat = flat_mask4(1, p3, p2, p1, p0, q0, q1, q2, q3);
717 filter8(
718 mask,
719 thresh,
720 flat,
721 buf,
722 s - 4 * stride,
723 s - 3 * stride,
724 s - 2 * stride,
725 s - stride,
726 s,
727 s + stride,
728 s + 2 * stride,
729 s + 3 * stride,
730 );
731 }
732}
733
734fn lpf_horizontal_16(buf: &mut [u8], stride: usize, pos: usize, blimit: u8, limit: u8, thresh: u8) {
735 for i in 0..8 {
736 let s = pos + i;
737 let (p3, p2, p1, p0) = (
738 buf[s - 4 * stride],
739 buf[s - 3 * stride],
740 buf[s - 2 * stride],
741 buf[s - stride],
742 );
743 let (q0, q1, q2, q3) = (
744 buf[s],
745 buf[s + stride],
746 buf[s + 2 * stride],
747 buf[s + 3 * stride],
748 );
749 let mask = filter_mask(limit, blimit, p3, p2, p1, p0, q0, q1, q2, q3);
750 let flat = flat_mask4(1, p3, p2, p1, p0, q0, q1, q2, q3);
751 let flat2 = flat_mask5(
752 1,
753 buf[s - 8 * stride],
754 buf[s - 7 * stride],
755 buf[s - 6 * stride],
756 buf[s - 5 * stride],
757 p0,
758 q0,
759 buf[s + 4 * stride],
760 buf[s + 5 * stride],
761 buf[s + 6 * stride],
762 buf[s + 7 * stride],
763 );
764 filter16(
765 mask,
766 thresh,
767 flat,
768 flat2,
769 buf,
770 [
771 s - 8 * stride,
772 s - 7 * stride,
773 s - 6 * stride,
774 s - 5 * stride,
775 s - 4 * stride,
776 s - 3 * stride,
777 s - 2 * stride,
778 s - stride,
779 s,
780 s + stride,
781 s + 2 * stride,
782 s + 3 * stride,
783 s + 4 * stride,
784 s + 5 * stride,
785 s + 6 * stride,
786 s + 7 * stride,
787 ],
788 );
789 }
790}
791
792#[allow(clippy::too_many_arguments)]
799fn filter_selectively_vert(
800 buf: &mut [u8],
801 stride: usize,
802 pos: usize,
803 mask16: u32,
804 mask8: u32,
805 mask4: u32,
806 mask4i: u32,
807 thr: &[LoopFilterThresh; MAX_LOOP_FILTER + 1],
808 lfl: &[u8],
809 num_cols: usize,
810) {
811 let (mut m16, mut m8, mut m4, mut m4i) = (mask16, mask8, mask4, mask4i);
812 for c in 0..num_cols {
813 let p = pos + c * 8;
814 let t = &thr[lfl[c] as usize];
815 if m16 & 1 != 0 {
816 lpf_vertical_16(buf, stride, p, t.mblim, t.lim, t.hev_thr);
817 } else if m8 & 1 != 0 {
818 lpf_vertical_8(buf, stride, p, t.mblim, t.lim, t.hev_thr);
819 } else if m4 & 1 != 0 {
820 lpf_vertical_4(buf, stride, p, t.mblim, t.lim, t.hev_thr);
821 }
822 if m4i & 1 != 0 {
823 lpf_vertical_4(buf, stride, p + 4, t.mblim, t.lim, t.hev_thr);
824 }
825 m16 >>= 1;
826 m8 >>= 1;
827 m4 >>= 1;
828 m4i >>= 1;
829 }
830}
831
832#[allow(clippy::too_many_arguments)]
833fn filter_selectively_horiz(
834 buf: &mut [u8],
835 stride: usize,
836 pos: usize,
837 mask16: u32,
838 mask8: u32,
839 mask4: u32,
840 mask4i: u32,
841 thr: &[LoopFilterThresh; MAX_LOOP_FILTER + 1],
842 lfl: &[u8],
843 num_cols: usize,
844) {
845 let (mut m16, mut m8, mut m4, mut m4i) = (mask16, mask8, mask4, mask4i);
846 for c in 0..num_cols {
847 let p = pos + c * 8;
848 let t = &thr[lfl[c] as usize];
849 if m16 & 1 != 0 {
850 lpf_horizontal_16(buf, stride, p, t.mblim, t.lim, t.hev_thr);
851 } else if m8 & 1 != 0 {
852 lpf_horizontal_8(buf, stride, p, t.mblim, t.lim, t.hev_thr);
853 } else if m4 & 1 != 0 {
854 lpf_horizontal_4(buf, stride, p, t.mblim, t.lim, t.hev_thr);
855 }
856 if m4i & 1 != 0 {
857 lpf_horizontal_4(buf, stride, p + 4 * stride, t.mblim, t.lim, t.hev_thr);
858 }
859 m16 >>= 1;
860 m8 >>= 1;
861 m4 >>= 1;
862 m4i >>= 1;
863 }
864}
865
866fn filter_plane_ss00(
872 buf: &mut [u8],
873 stride: usize,
874 base: usize,
875 sb_row: usize,
876 mi_rows: usize,
877 lfm: &LoopFilterMask,
878 thr: &[LoopFilterThresh; MAX_LOOP_FILTER + 1],
879) {
880 for r in 0..MI_BLOCK_SIZE {
881 if sb_row + r >= mi_rows {
882 break;
883 }
884 let m16 = ((lfm.left_y[2] >> (r * 8)) & 0xff) as u32;
885 let m8 = ((lfm.left_y[1] >> (r * 8)) & 0xff) as u32;
886 let m4 = ((lfm.left_y[0] >> (r * 8)) & 0xff) as u32;
887 let m4i = ((lfm.int_4x4_y >> (r * 8)) & 0xff) as u32;
888 let pos = base + r * 8 * stride;
889 filter_selectively_vert(
890 buf,
891 stride,
892 pos,
893 m16,
894 m8,
895 m4,
896 m4i,
897 thr,
898 &lfm.lfl_y[r * 8..r * 8 + 8],
899 8,
900 );
901 }
902
903 for r in 0..MI_BLOCK_SIZE {
904 if sb_row + r >= mi_rows {
905 break;
906 }
907 let (m16, m8, m4) = if sb_row + r == 0 {
908 (0, 0, 0)
909 } else {
910 (
911 ((lfm.above_y[2] >> (r * 8)) & 0xff) as u32,
912 ((lfm.above_y[1] >> (r * 8)) & 0xff) as u32,
913 ((lfm.above_y[0] >> (r * 8)) & 0xff) as u32,
914 )
915 };
916 let m4i = ((lfm.int_4x4_y >> (r * 8)) & 0xff) as u32;
917 let pos = base + r * 8 * stride;
918 filter_selectively_horiz(
919 buf,
920 stride,
921 pos,
922 m16,
923 m8,
924 m4,
925 m4i,
926 thr,
927 &lfm.lfl_y[r * 8..r * 8 + 8],
928 8,
929 );
930 }
931}
932
933fn filter_plane_ss11(
935 buf: &mut [u8],
936 stride: usize,
937 base: usize,
938 sb_row: usize,
939 mi_rows: usize,
940 lfm: &LoopFilterMask,
941 thr: &[LoopFilterThresh; MAX_LOOP_FILTER + 1],
942) {
943 for r_uv in 0..4 {
944 let mi_r = r_uv * 2;
945 if sb_row + mi_r >= mi_rows {
946 break;
947 }
948 let m16 = ((lfm.left_uv[2] >> (r_uv * 4)) & 0xf) as u32;
949 let m8 = ((lfm.left_uv[1] >> (r_uv * 4)) & 0xf) as u32;
950 let m4 = ((lfm.left_uv[0] >> (r_uv * 4)) & 0xf) as u32;
951 let m4i = ((lfm.int_4x4_uv >> (r_uv * 4)) & 0xf) as u32;
952 let mut lfl_uv = [0u8; 4];
953 for c in 0..4 {
954 lfl_uv[c] = lfm.lfl_y[mi_r * 8 + c * 2];
955 }
956 let pos = base + r_uv * 8 * stride;
957 filter_selectively_vert(buf, stride, pos, m16, m8, m4, m4i, thr, &lfl_uv, 4);
958 }
959
960 for r_uv in 0..4 {
961 let mi_r = r_uv * 2;
962 if sb_row + mi_r >= mi_rows {
963 break;
964 }
965 let skip_border = sb_row + mi_r == mi_rows - 1;
966 let m4i_full = ((lfm.int_4x4_uv >> (r_uv * 4)) & 0xf) as u32;
967 let m4i = if skip_border { 0 } else { m4i_full };
968 let (m16, m8, m4) = if sb_row + mi_r == 0 {
969 (0, 0, 0)
970 } else {
971 (
972 ((lfm.above_uv[2] >> (r_uv * 4)) & 0xf) as u32,
973 ((lfm.above_uv[1] >> (r_uv * 4)) & 0xf) as u32,
974 ((lfm.above_uv[0] >> (r_uv * 4)) & 0xf) as u32,
975 )
976 };
977 let mut lfl_uv = [0u8; 4];
978 for c in 0..4 {
979 lfl_uv[c] = lfm.lfl_y[mi_r * 8 + c * 2];
980 }
981 let pos = base + r_uv * 8 * stride;
982 filter_selectively_horiz(buf, stride, pos, m16, m8, m4, m4i, thr, &lfl_uv, 4);
983 }
984}
985
986pub fn loop_filter_frame(
1006 y: &mut [u8],
1007 y_stride: usize,
1008 u: &mut [u8],
1009 v: &mut [u8],
1010 uv_stride: usize,
1011 _width: usize,
1012 _height: usize,
1013 mi: &[LfMi],
1014 mi_rows: usize,
1015 mi_cols: usize,
1016 filter_level: u8,
1017 sharpness: u8,
1018) {
1019 if filter_level == 0 || mi_rows == 0 || mi_cols == 0 {
1020 return;
1021 }
1022 debug_assert_eq!(mi.len(), mi_rows * mi_cols);
1023
1024 let thresholds = build_thresholds(sharpness);
1025
1026 let mut sb_row = 0;
1027 while sb_row < mi_rows {
1028 let mut sb_col = 0;
1029 while sb_col < mi_cols {
1030 let mut lfm = LoopFilterMask::default();
1031
1032 for r in 0..MI_BLOCK_SIZE {
1033 let row = sb_row + r;
1034 if row >= mi_rows {
1035 break;
1036 }
1037 for c in 0..MI_BLOCK_SIZE {
1038 let col = sb_col + c;
1039 if col >= mi_cols {
1040 break;
1041 }
1042 let m = &mi[row * mi_cols + col];
1043 if !m.block_origin {
1044 continue;
1045 }
1046 build_mask(
1047 m.level,
1048 m.is_inter,
1049 m.skip,
1050 m.tx_size_y,
1051 m.bsize_idx,
1052 m.bw_mi as usize,
1053 m.bh_mi as usize,
1054 r,
1055 c,
1056 &mut lfm,
1057 );
1058 }
1059 }
1060
1061 adjust_mask(mi_rows, mi_cols, sb_row, sb_col, &mut lfm);
1062
1063 let y_base = sb_row * 8 * y_stride + sb_col * 8;
1064 filter_plane_ss00(y, y_stride, y_base, sb_row, mi_rows, &lfm, &thresholds);
1065
1066 let uv_base = sb_row * 4 * uv_stride + sb_col * 4;
1067 filter_plane_ss11(u, uv_stride, uv_base, sb_row, mi_rows, &lfm, &thresholds);
1068 filter_plane_ss11(v, uv_stride, uv_base, sb_row, mi_rows, &lfm, &thresholds);
1069
1070 sb_col += MI_BLOCK_SIZE;
1071 }
1072 sb_row += MI_BLOCK_SIZE;
1073 }
1074}
1075
1076#[cfg(test)]
1077mod tests {
1078 use super::*;
1079
1080 fn make_step_frame(w: usize, h: usize) -> (Vec<u8>, usize) {
1084 let stride = w;
1085 let mut y = vec![0u8; stride * h];
1086 for row in 0..h {
1087 for col in 0..w {
1088 y[row * stride + col] = if col < w / 2 { 100 } else { 150 };
1089 }
1090 }
1091 (y, stride)
1092 }
1093
1094 fn flat_mi(mi_rows: usize, mi_cols: usize, level: u8) -> Vec<LfMi> {
1095 (0..mi_rows * mi_cols)
1096 .map(|_| LfMi {
1097 skip: false,
1098 is_inter: false,
1099 tx_size_y: 0,
1100 bw_mi: 1,
1101 bh_mi: 1,
1102 bsize_idx: 3, block_origin: true, level,
1105 })
1106 .collect()
1107 }
1108
1109 fn sb_align(n: usize) -> usize {
1110 n.div_ceil(64) * 64
1111 }
1112
1113 #[test]
1114 fn filter_level_zero_is_noop() {
1115 let (w, h) = (64, 64);
1116 let (mut y, y_stride) = make_step_frame(w, h);
1117 let y_orig = y.clone();
1118 let mut u = vec![128u8; (w / 2) * (h / 2)];
1119 let mut v = vec![128u8; (w / 2) * (h / 2)];
1120 let uv_stride = w / 2;
1121 let mi_rows = h / 8;
1122 let mi_cols = w / 8;
1123 let mi = flat_mi(mi_rows, mi_cols, 10);
1124
1125 loop_filter_frame(
1126 &mut y, y_stride, &mut u, &mut v, uv_stride, w, h, &mi, mi_rows, mi_cols, 0, 0,
1127 );
1128
1129 assert_eq!(y, y_orig, "filter_level=0 must not modify the luma plane");
1130 }
1131
1132 #[test]
1133 fn synthetic_edge_is_modified_when_level_positive() {
1134 let (w, h) = (64, 64);
1135 let (mut y, y_stride) = make_step_frame(w, h);
1136 let y_orig = y.clone();
1137 let mut u = vec![128u8; (w / 2) * (h / 2)];
1138 let mut v = vec![128u8; (w / 2) * (h / 2)];
1139 let uv_stride = w / 2;
1140 let mi_rows = h / 8;
1141 let mi_cols = w / 8;
1142 let mi = flat_mi(mi_rows, mi_cols, 63);
1143
1144 loop_filter_frame(
1145 &mut y, y_stride, &mut u, &mut v, uv_stride, w, h, &mi, mi_rows, mi_cols, 63, 0,
1146 );
1147
1148 assert_ne!(
1149 y, y_orig,
1150 "filter_level>0 should modify pixels near the synthetic edge"
1151 );
1152
1153 let mid_row = h / 2;
1157 let mut changed = false;
1158 for col in (w / 2 - 4)..(w / 2 + 4) {
1159 if y[mid_row * y_stride + col] != y_orig[mid_row * y_stride + col] {
1160 changed = true;
1161 }
1162 }
1163 assert!(
1164 changed,
1165 "expected pixels around the synthetic step edge to change"
1166 );
1167 }
1168
1169 #[test]
1170 fn no_panic_on_partial_superblock_frame() {
1171 let (w, h) = (40usize, 24usize);
1175 let mi_rows = h.div_ceil(8);
1176 let mi_cols = w.div_ceil(8);
1177 let mi = flat_mi(mi_rows, mi_cols, 30);
1178
1179 let (pad_w, pad_h) = (sb_align(w), sb_align(h));
1180 let (mut y, y_stride) = make_step_frame(pad_w, pad_h);
1181 let uv_stride = pad_w / 2;
1182 let mut u = vec![128u8; uv_stride * (pad_h / 2)];
1183 let mut v = vec![128u8; uv_stride * (pad_h / 2)];
1184
1185 loop_filter_frame(
1186 &mut y, y_stride, &mut u, &mut v, uv_stride, w, h, &mi, mi_rows, mi_cols, 30, 2,
1187 );
1188 }
1189
1190 #[test]
1191 fn lf_level_applies_default_ref_deltas() {
1192 assert_eq!(lf_level_for_mi(10, 1, 12), 10); assert_eq!(lf_level_for_mi(10, 2, 10), 9); assert_eq!(lf_level_for_mi(10, 3, 13), 9); assert_eq!(lf_level_for_mi(10, 0, 0), 11); assert_eq!(lf_level_for_mi(0, 1, 12), 0);
1198 }
1199}