From 25139d2c328267de81412757056093dcb75bf8ac Mon Sep 17 00:00:00 2001 From: Khyber Sen Date: Sat, 2 Dec 2023 04:04:40 -0500 Subject: [PATCH 1/2] `const DEBUG_{SEQ_HDR,FRAME_HDR,OBU_METADATA}`: Add back debug `#define`s and their debugging/logging code. --- src/obu.rs | 246 ++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 244 insertions(+), 2 deletions(-) diff --git a/src/obu.rs b/src/obu.rs index 1f0374e27..9e63ef695 100644 --- a/src/obu.rs +++ b/src/obu.rs @@ -137,6 +137,13 @@ unsafe fn parse_seq_hdr( return Err(EINVAL); } + const DEBUG_SEQ_HDR: bool = false; + let init_bit_pos = if DEBUG_SEQ_HDR { + rav1d_get_bits_pos(gb) + } else { + 0 + }; + memset( hdr as *mut Rav1dSequenceHeader as *mut c_void, 0, @@ -146,12 +153,24 @@ unsafe fn parse_seq_hdr( if hdr.profile > 2 { return error(c); } + if DEBUG_SEQ_HDR { + println!( + "SEQHDR: post-profile: off={}", + rav1d_get_bits_pos(gb) - init_bit_pos + ); + } hdr.still_picture = rav1d_get_bit(gb) as c_int; hdr.reduced_still_picture_header = rav1d_get_bit(gb) as c_int; if hdr.reduced_still_picture_header != 0 && hdr.still_picture == 0 { return error(c); } + if DEBUG_SEQ_HDR { + println!( + "SEQHDR: post-stillpicture_flags: off={}", + rav1d_get_bits_pos(gb) - init_bit_pos + ); + } if hdr.reduced_still_picture_header != 0 { hdr.num_operating_points = 1; @@ -186,6 +205,12 @@ unsafe fn parse_seq_hdr( hdr.frame_presentation_delay_length = rav1d_get_bits(gb, 5) as c_int + 1; } } + if DEBUG_SEQ_HDR { + println!( + "SEQHDR: post-timinginfo: off={}", + rav1d_get_bits_pos(gb) - init_bit_pos + ); + } hdr.display_model_info_present = rav1d_get_bit(gb) as c_int; hdr.num_operating_points = rav1d_get_bits(gb, 5) as c_int + 1; @@ -220,6 +245,12 @@ unsafe fn parse_seq_hdr( 10 }; } + if DEBUG_SEQ_HDR { + println!( + "SEQHDR: post-operating-points: off={}", + rav1d_get_bits_pos(gb) - init_bit_pos + ); + } } let op_idx = if c.operating_point < hdr.num_operating_points { @@ -239,6 +270,12 @@ unsafe fn parse_seq_hdr( hdr.height_n_bits = rav1d_get_bits(gb, 4) as c_int + 1; hdr.max_width = rav1d_get_bits(gb, hdr.width_n_bits) as c_int + 1; hdr.max_height = rav1d_get_bits(gb, hdr.height_n_bits) as c_int + 1; + if DEBUG_SEQ_HDR { + println!( + "SEQHDR: post-size: off={}", + rav1d_get_bits_pos(gb) - init_bit_pos + ); + } if hdr.reduced_still_picture_header == 0 { hdr.frame_id_numbers_present = rav1d_get_bit(gb) as c_int; if hdr.frame_id_numbers_present != 0 { @@ -246,6 +283,12 @@ unsafe fn parse_seq_hdr( hdr.frame_id_n_bits = rav1d_get_bits(gb, 3) as c_int + hdr.delta_frame_id_n_bits + 1; } } + if DEBUG_SEQ_HDR { + println!( + "SEQHDR: post-frame-id-numbers-present: off={}", + rav1d_get_bits_pos(gb) - init_bit_pos + ); + } hdr.sb128 = rav1d_get_bit(gb) as c_int; hdr.filter_intra = rav1d_get_bit(gb) as c_int; @@ -268,6 +311,12 @@ unsafe fn parse_seq_hdr( } else { rav1d_get_bit(gb) as Rav1dAdaptiveBoolean }; + if DEBUG_SEQ_HDR { + println!( + "SEQHDR: post-screentools: off={}", + rav1d_get_bits_pos(gb) - init_bit_pos + ); + } hdr.force_integer_mv = if hdr.screen_content_tools as c_uint != 0 { if rav1d_get_bit(gb) != 0 { RAV1D_ADAPTIVE @@ -284,6 +333,12 @@ unsafe fn parse_seq_hdr( hdr.super_res = rav1d_get_bit(gb) as c_int; hdr.cdef = rav1d_get_bit(gb) as c_int; hdr.restoration = rav1d_get_bit(gb) as c_int; + if DEBUG_SEQ_HDR { + println!( + "SEQHDR: post-featurebits: off={}", + rav1d_get_bits_pos(gb) - init_bit_pos + ); + } hdr.hbd = rav1d_get_bit(gb) as c_int; if hdr.profile == 2 && hdr.hbd != 0 { @@ -364,8 +419,20 @@ unsafe fn parse_seq_hdr( if hdr.monochrome == 0 { hdr.separate_uv_delta_q = rav1d_get_bit(gb) as c_int; } + if DEBUG_SEQ_HDR { + println!( + "SEQHDR: post-colorinfo: off={}", + rav1d_get_bits_pos(gb) - init_bit_pos + ); + } hdr.film_grain_present = rav1d_get_bit(gb) as c_int; + if DEBUG_SEQ_HDR { + println!( + "SEQHDR: post-filmgrain: off={}", + rav1d_get_bits_pos(gb) - init_bit_pos + ); + } rav1d_get_bit(gb); // dummy bit @@ -462,9 +529,17 @@ unsafe fn parse_frame_hdr(c: &mut Rav1dContext, gb: &mut GetBits) -> Rav1dResult return Err(EINVAL); } + const DEBUG_FRAME_HDR: bool = false; + let init_ptr = gb.ptr; + let seqhdr = &*c.seq_hdr; let hdr = &mut *c.frame_hdr; - + if DEBUG_FRAME_HDR { + println!( + "HDR: post-show_existing_frame: off={}", + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } hdr.show_existing_frame = (seqhdr.reduced_still_picture_header == 0 && rav1d_get_bit(gb) != 0) as c_int; if hdr.show_existing_frame != 0 { @@ -502,6 +577,12 @@ unsafe fn parse_frame_hdr(c: &mut Rav1dContext, gb: &mut GetBits) -> Rav1dResult || hdr.frame_type == RAV1D_FRAME_TYPE_SWITCH || seqhdr.reduced_still_picture_header != 0 || rav1d_get_bit(gb) != 0) as c_int; + if DEBUG_FRAME_HDR { + println!( + "HDR: post-frametype_bits: off={}", + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } hdr.disable_cdf_update = rav1d_get_bit(gb) as c_int; hdr.allow_screen_content_tools = (if seqhdr.screen_content_tools == RAV1D_ADAPTIVE { rav1d_get_bit(gb) @@ -533,6 +614,12 @@ unsafe fn parse_frame_hdr(c: &mut Rav1dContext, gb: &mut GetBits) -> Rav1dResult } else { rav1d_get_bit(gb) }) as c_int; + if DEBUG_FRAME_HDR { + println!( + "HDR: post-frame_size_override_flag: off={}", + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } hdr.frame_offset = if seqhdr.order_hint != 0 { rav1d_get_bits(gb, seqhdr.order_hint_n_bits) as c_int } else { @@ -742,10 +829,22 @@ unsafe fn parse_frame_hdr(c: &mut Rav1dContext, gb: &mut GetBits) -> Rav1dResult && is_inter_or_switch(hdr) && rav1d_get_bit(gb) != 0) as c_int; } + if DEBUG_FRAME_HDR { + println!( + "HDR: post-frametype-specific-bits: off={}", + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } hdr.refresh_context = (seqhdr.reduced_still_picture_header == 0 && hdr.disable_cdf_update == 0 && rav1d_get_bit(gb) == 0) as c_int; + if DEBUG_FRAME_HDR { + println!( + "HDR: post-refresh_context: off={}", + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } // tile data hdr.tiling.uniform = rav1d_get_bit(gb) as c_int; @@ -840,6 +939,12 @@ unsafe fn parse_frame_hdr(c: &mut Rav1dContext, gb: &mut GetBits) -> Rav1dResult hdr.tiling.update = 0; hdr.tiling.n_bytes = hdr.tiling.update as c_uint; } + if DEBUG_FRAME_HDR { + println!( + "HDR: post-tiling: off={}", + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } // quant data hdr.quant.yac = rav1d_get_bits(gb, 8) as c_int; @@ -883,6 +988,12 @@ unsafe fn parse_frame_hdr(c: &mut Rav1dContext, gb: &mut GetBits) -> Rav1dResult hdr.quant.vac_delta = hdr.quant.uac_delta; } } + if DEBUG_FRAME_HDR { + println!( + "HDR: post-quant: off={}", + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } hdr.quant.qm = rav1d_get_bit(gb) as c_int; if hdr.quant.qm != 0 { hdr.quant.qm_y = rav1d_get_bits(gb, 4) as c_int; @@ -893,6 +1004,12 @@ unsafe fn parse_frame_hdr(c: &mut Rav1dContext, gb: &mut GetBits) -> Rav1dResult hdr.quant.qm_u }; } + if DEBUG_FRAME_HDR { + println!( + "HDR: post-qm: off={}", + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } // segmentation data hdr.segmentation.enabled = rav1d_get_bit(gb) as c_int; @@ -987,6 +1104,12 @@ unsafe fn parse_frame_hdr(c: &mut Rav1dContext, gb: &mut GetBits) -> Rav1dResult hdr.segmentation.seg_data.d[i as usize].r#ref = -1; } } + if DEBUG_FRAME_HDR { + println!( + "HDR: post-segmentation: off={}", + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } // delta q hdr.delta.q.present = if hdr.quant.yac != 0 { @@ -1011,6 +1134,12 @@ unsafe fn parse_frame_hdr(c: &mut Rav1dContext, gb: &mut GetBits) -> Rav1dResult } else { 0 }; + if DEBUG_FRAME_HDR { + println!( + "HDR: post-delta_q_lf_flags: off={}", + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } // derive lossless flags let delta_lossless = (hdr.quant.ydc_delta == 0 @@ -1082,6 +1211,12 @@ unsafe fn parse_frame_hdr(c: &mut Rav1dContext, gb: &mut GetBits) -> Rav1dResult } } } + if DEBUG_FRAME_HDR { + println!( + "HDR: post-lpf: off={}", + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } // cdef if hdr.all_lossless == 0 && seqhdr.cdef != 0 && hdr.allow_intrabc == 0 { @@ -1098,6 +1233,12 @@ unsafe fn parse_frame_hdr(c: &mut Rav1dContext, gb: &mut GetBits) -> Rav1dResult hdr.cdef.y_strength[0] = 0; hdr.cdef.uv_strength[0] = 0; } + if DEBUG_FRAME_HDR { + println!( + "HDR: post-cdef: off={}", + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } // restoration if (hdr.all_lossless == 0 || hdr.super_res.enabled != 0) @@ -1140,6 +1281,12 @@ unsafe fn parse_frame_hdr(c: &mut Rav1dContext, gb: &mut GetBits) -> Rav1dResult hdr.restoration.r#type[1] = RAV1D_RESTORATION_NONE; hdr.restoration.r#type[2] = RAV1D_RESTORATION_NONE; } + if DEBUG_FRAME_HDR { + println!( + "HDR: post-restoration: off={}", + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } hdr.txfm_mode = if hdr.all_lossless != 0 { RAV1D_TX_4X4_ONLY @@ -1148,11 +1295,23 @@ unsafe fn parse_frame_hdr(c: &mut Rav1dContext, gb: &mut GetBits) -> Rav1dResult } else { RAV1D_TX_LARGEST }; + if DEBUG_FRAME_HDR { + println!( + "HDR: post-txfmmode: off={}", + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } hdr.switchable_comp_refs = if is_inter_or_switch(hdr) { rav1d_get_bit(gb) as c_int } else { 0 }; + if DEBUG_FRAME_HDR { + println!( + "HDR: post-refmode: off={}", + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } hdr.skip_mode_allowed = 0; if hdr.switchable_comp_refs != 0 && is_inter_or_switch(hdr) && seqhdr.order_hint != 0 { let poc = hdr.frame_offset as c_uint; @@ -1237,11 +1396,29 @@ unsafe fn parse_frame_hdr(c: &mut Rav1dContext, gb: &mut GetBits) -> Rav1dResult } else { 0 }; + if DEBUG_FRAME_HDR { + println!( + "HDR: post-extskip: off={}", + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } hdr.warp_motion = (hdr.error_resilient_mode == 0 && is_inter_or_switch(hdr) && seqhdr.warped_motion != 0 && rav1d_get_bit(gb) != 0) as c_int; + if DEBUG_FRAME_HDR { + println!( + "HDR: post-warpmotionbit: off={}", + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } hdr.reduced_txtp_set = rav1d_get_bit(gb) as c_int; + if DEBUG_FRAME_HDR { + println!( + "HDR: post-reducedtxtpset: off={}", + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } for i in 0..7 { hdr.gmv[i as usize] = dav1d_default_wm_params.clone(); @@ -1302,6 +1479,12 @@ unsafe fn parse_frame_hdr(c: &mut Rav1dContext, gb: &mut GetBits) -> Rav1dResult } } } + if DEBUG_FRAME_HDR { + println!( + "HDR: post-gmv: off={}", + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } hdr.film_grain.present = (seqhdr.film_grain_present != 0 && (hdr.show_frame != 0 || hdr.showable_frame != 0) @@ -1418,6 +1601,12 @@ unsafe fn parse_frame_hdr(c: &mut Rav1dContext, gb: &mut GetBits) -> Rav1dResult ::core::mem::size_of::(), ); } + if DEBUG_FRAME_HDR { + println!( + "HDR: post-filmgrain: off={}", + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } (*(*c.frame_hdr_ref) .data @@ -1669,6 +1858,9 @@ pub(crate) unsafe fn rav1d_parse_obus( current_block_188 = 17787701279558130514; } RAV1D_OBU_METADATA => { + const DEBUG_OBU_METADATA: bool = false; + let init_ptr = gb.ptr; + // obu metadta type field let meta_type = rav1d_get_uleb128(&mut gb) as ObuMetaType; let meta_type_len = ((rav1d_get_bits_pos(&mut gb) - init_bit_pos) >> 3) as c_int; @@ -1686,8 +1878,22 @@ pub(crate) unsafe fn rav1d_parse_obus( let content_light = (*r#ref).data as *mut Rav1dContentLightLevel; (*content_light).max_content_light_level = rav1d_get_bits(&mut gb, 16) as c_int; + if DEBUG_OBU_METADATA { + println!( + "CLLOBU: max-content-light-level: {} [off={}]", + (*content_light).max_content_light_level, + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } (*content_light).max_frame_average_light_level = rav1d_get_bits(&mut gb, 16) as c_int; + if DEBUG_OBU_METADATA { + println!( + "CLLOBU: max-frame-average-light-level: {} [off={}]", + (*content_light).max_frame_average_light_level, + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } // Skip the trailing bit, align to the next byte boundary and check for overrun. rav1d_get_bit(&mut gb); @@ -1714,12 +1920,48 @@ pub(crate) unsafe fn rav1d_parse_obus( rav1d_get_bits(&mut gb, 16) as u16; (*mastering_display).primaries[i as usize][1] = rav1d_get_bits(&mut gb, 16) as u16; + if DEBUG_OBU_METADATA { + println!( + "MDCVOBU: primaries[{}]: ({}, {}) [off={}]", + i, + (*mastering_display).primaries[i as usize][0], + (*mastering_display).primaries[i as usize][1], + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } } (*mastering_display).white_point[0] = rav1d_get_bits(&mut gb, 16) as u16; + if DEBUG_OBU_METADATA { + println!( + "CLLOBU: white-point-x: {} [off={}]", + (*mastering_display).white_point[0], + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } (*mastering_display).white_point[1] = rav1d_get_bits(&mut gb, 16) as u16; + if DEBUG_OBU_METADATA { + println!( + "CLLOBU: white-point-y: {} [off={}]", + (*mastering_display).white_point[1], + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } (*mastering_display).max_luminance = rav1d_get_bits(&mut gb, 32); + if DEBUG_OBU_METADATA { + println!( + "CLLOBU: max-luminance: {} [off={}]", + (*mastering_display).max_luminance, + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } (*mastering_display).min_luminance = rav1d_get_bits(&mut gb, 32); - + if DEBUG_OBU_METADATA { + println!( + "CLLOBU: min-luminance: {} [off={}]", + (*mastering_display).min_luminance, + gb.ptr.offset_from(init_ptr) * 8 - gb.bits_left as isize + ); + } // Skip the trailing bit, align to the next byte boundary and check for overrun. rav1d_get_bit(&mut gb); rav1d_bytealign_get_bits(&mut gb); From 6571bb775c186e7962975f4a8950fc728bbbe9ec Mon Sep 17 00:00:00 2001 From: Khyber Sen Date: Sat, 2 Dec 2023 04:42:55 -0500 Subject: [PATCH 2/2] `fn rav1d_parse_obus`: Fix comment typo (from `dav1d`). --- src/obu.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/obu.rs b/src/obu.rs index 9e63ef695..892ad8aec 100644 --- a/src/obu.rs +++ b/src/obu.rs @@ -1861,7 +1861,7 @@ pub(crate) unsafe fn rav1d_parse_obus( const DEBUG_OBU_METADATA: bool = false; let init_ptr = gb.ptr; - // obu metadta type field + // obu metadata type field let meta_type = rav1d_get_uleb128(&mut gb) as ObuMetaType; let meta_type_len = ((rav1d_get_bits_pos(&mut gb) - init_bit_pos) >> 3) as c_int; if gb.error != 0 {