Port C code changes to Rust

include/dav1d/picture.rs

@@ -32,7 +32,8 @@ pub struct Dav1dPicture {
     pub content_light: *mut Dav1dContentLightLevel,
     pub mastering_display: *mut Dav1dMasteringDisplay,
     pub itut_t35: *mut Dav1dITUTT35,
-    pub reserved: [uintptr_t; 4],
+    pub n_itut_t35: usize,
+    pub reserved: [uintptr_t; 3],
     pub frame_hdr_ref: *mut Dav1dRef,
     pub seq_hdr_ref: *mut Dav1dRef,
     pub content_light_ref: *mut Dav1dRef,

src/internal.rs

@@ -181,6 +181,7 @@ pub struct Dav1dContext {
     pub(crate) mastering_display: *mut Dav1dMasteringDisplay,
     pub(crate) itut_t35_ref: *mut Dav1dRef,
     pub(crate) itut_t35: *mut Dav1dITUTT35,
+    pub(crate) n_itut_t35: c_int,
     pub(crate) in_0: Dav1dData,
     pub(crate) out: Dav1dThreadPicture,
     pub(crate) cache: Dav1dThreadPicture,

src/lib.rs

@@ -1062,6 +1062,7 @@ pub unsafe extern "C" fn dav1d_flush(c: *mut Dav1dContext) {
     (*c).mastering_display = 0 as *mut Dav1dMasteringDisplay;
     (*c).content_light = 0 as *mut Dav1dContentLightLevel;
     (*c).itut_t35 = 0 as *mut Dav1dITUTT35;
+    (*c).n_itut_t35 = 0;
     dav1d_ref_dec(&mut (*c).mastering_display_ref);
     dav1d_ref_dec(&mut (*c).content_light_ref);
     dav1d_ref_dec(&mut (*c).itut_t35_ref);

src/obu.rs

@@ -92,9 +92,11 @@ use crate::src::levels::OBU_META_SCALABILITY;
 use crate::src::levels::OBU_META_TIMECODE;
 use crate::src::log::dav1d_log;
 use crate::src::picture::dav1d_picture_copy_props;
+use crate::src::picture::dav1d_picture_free_itut_t35;
 use crate::src::picture::dav1d_picture_get_event_flags;
 use crate::src::picture::dav1d_thread_picture_ref;
 use crate::src::picture::dav1d_thread_picture_unref;
+use crate::src::picture::itut_t35_ctx_context;
 use crate::src::picture::Dav1dThreadPicture;
 use crate::src::picture::PictureFlags;
 use crate::src::picture::PICTURE_FLAG_NEW_OP_PARAMS_INFO;
@@ -105,9 +107,12 @@ use crate::src::r#ref::dav1d_ref_create_using_pool;
 use crate::src::r#ref::dav1d_ref_dec;
 use crate::src::r#ref::dav1d_ref_inc;
 use crate::src::r#ref::dav1d_ref_is_writable;
+use crate::src::r#ref::dav1d_ref_wrap;
 use crate::src::r#ref::Dav1dRef;
 use crate::src::tables::dav1d_default_wm_params;
 use crate::src::thread_task::FRAME_ERROR;
+use libc::free;
+use libc::malloc;
 use libc::memcmp;
 use libc::memset;
 use libc::pthread_cond_wait;
@@ -1848,18 +1853,67 @@ pub unsafe fn dav1d_parse_obus(c: *mut Dav1dContext, in_0: *mut Dav1dData, globa
                                 as *const c_char,
                         );
                     } else {
-                        let ref_3: *mut Dav1dRef = dav1d_ref_create(
-                            (::core::mem::size_of::<Dav1dITUTT35>()).wrapping_add(
-                                (payload_size as usize).wrapping_mul(::core::mem::size_of::<u8>()),
-                            ),
+                        if (*c).n_itut_t35 + 1
+                            > c_int::MAX / ::core::mem::size_of::<Dav1dITUTT35>() as c_int
+                        {
+                            return dav1d_parse_obus_error(c, in_0);
+                        }
+
+                        let itut_t35 = realloc(
+                            (*c).itut_t35 as *mut c_void,
+                            ((*c).n_itut_t35 + 1) as usize * ::core::mem::size_of::<Dav1dITUTT35>(),
+                        ) as *mut Dav1dITUTT35;
+                        if itut_t35.is_null() {
+                            return dav1d_parse_obus_error(c, in_0);
+                        }
+                        (*c).itut_t35 = itut_t35;
+                        memset(
+                            (*c).itut_t35.offset((*c).n_itut_t35 as isize) as *mut c_void,
+                            0,
+                            ::core::mem::size_of::<Dav1dITUTT35>(),
                         );
-                        if ref_3.is_null() {
-                            return -(12 as c_int);
+                        let itut_t35_ctx: *mut itut_t35_ctx_context;
+                        if (*c).n_itut_t35 == 0 {
+                            if !(*c).itut_t35_ref.is_null() {
+                                unreachable!();
+                            }
+                            itut_t35_ctx = malloc(::core::mem::size_of::<itut_t35_ctx_context>())
+                                as *mut itut_t35_ctx_context;
+                            if itut_t35_ctx.is_null() {
+                                return dav1d_parse_obus_error(c, in_0);
+                            }
+                            (*c).itut_t35_ref = dav1d_ref_wrap(
+                                (*c).itut_t35 as *mut u8,
+                                Some(dav1d_picture_free_itut_t35),
+                                itut_t35_ctx as *mut c_void,
+                            );
+                            if (*c).itut_t35_ref.is_null() {
+                                free(itut_t35_ctx as *mut c_void);
+                                return dav1d_parse_obus_error(c, in_0);
+                            }
+                        } else {
+                            if !(!(*c).itut_t35_ref.is_null()
+                                && ::core::intrinsics::atomic_load_seqcst(
+                                    &(*(*c).itut_t35_ref).ref_cnt,
+                                ) == 1)
+                            {
+                                unreachable!();
+                            }
+                            itut_t35_ctx =
+                                (*(*c).itut_t35_ref).user_data as *mut itut_t35_ctx_context;
+                            (*(*c).itut_t35_ref).const_data = (*c).itut_t35 as *mut c_void;
                         }
-                        let itut_t35_metadata: *mut Dav1dITUTT35 =
-                            (*ref_3).data as *mut Dav1dITUTT35;
-                        (*itut_t35_metadata).payload =
-                            &mut *itut_t35_metadata.offset(1) as *mut Dav1dITUTT35 as *mut u8;
+
+                        (*itut_t35_ctx).itut_t35 = (*c).itut_t35;
+                        (*itut_t35_ctx).n_itut_t35 = ((*c).n_itut_t35 + 1) as usize;
+
+                        let itut_t35_metadata =
+                            (*c).itut_t35.offset((*c).n_itut_t35 as isize) as *mut Dav1dITUTT35;
+                        (*itut_t35_metadata).payload = malloc(payload_size as usize) as *mut u8;
+                        if (*itut_t35_metadata).payload.is_null() {
+                            return dav1d_parse_obus_error(c, in_0);
+                        }
+
                         (*itut_t35_metadata).country_code = country_code as u8;
                         (*itut_t35_metadata).country_code_extension_byte =
                             country_code_extension_byte as u8;
@@ -1870,9 +1924,7 @@ pub unsafe fn dav1d_parse_obus(c: *mut Dav1dContext, in_0: *mut Dav1dData, globa
                             i_2 += 1;
                         }
                         (*itut_t35_metadata).payload_size = payload_size as usize;
-                        dav1d_ref_dec(&mut (*c).itut_t35_ref);
-                        (*c).itut_t35 = itut_t35_metadata;
-                        (*c).itut_t35_ref = ref_3;
+                        (*c).n_itut_t35 += 1;
                     }
                 }
                 OBU_META_SCALABILITY | OBU_META_TIMECODE => {}
@@ -2111,11 +2163,13 @@ pub unsafe fn dav1d_parse_obus(c: *mut Dav1dContext, in_0: *mut Dav1dData, globa
                     (*c).mastering_display_ref,
                     (*c).itut_t35,
                     (*c).itut_t35_ref,
+                    (*c).n_itut_t35 as usize,
                     &mut (*in_0).m,
                 );
                 // Must be removed from the context after being attached to the frame
                 dav1d_ref_dec(&mut (*c).itut_t35_ref);
                 (*c).itut_t35 = 0 as *mut Dav1dITUTT35;
+                (*c).n_itut_t35 = 0;
                 (*c).event_flags = ::core::mem::transmute::<c_uint, Dav1dEventFlags>(
                     (*c).event_flags as c_uint
                         | dav1d_picture_get_event_flags(
@@ -2210,11 +2264,13 @@ pub unsafe fn dav1d_parse_obus(c: *mut Dav1dContext, in_0: *mut Dav1dData, globa
                     (*c).mastering_display_ref,
                     (*c).itut_t35,
                     (*c).itut_t35_ref,
+                    (*c).n_itut_t35 as usize,
                     &mut (*in_0).m,
                 );
                 // Must be removed from the context after being attached to the frame
                 dav1d_ref_dec(&mut (*c).itut_t35_ref);
                 (*c).itut_t35 = 0 as *mut Dav1dITUTT35;
+                (*c).n_itut_t35 = 0;
                 pthread_mutex_unlock(&mut (*c).task_thread.lock);
             }
             if (*(*c).refs[(*(*c).frame_hdr).existing_frame_idx as usize]

src/picture.rs

@@ -62,6 +62,12 @@ pub struct pic_ctx_context {
     pub extra_ptr: *mut c_void,
 }
 
+#[repr(C)]
+pub struct itut_t35_ctx_context {
+    pub itut_t35: *mut Dav1dITUTT35,
+    pub n_itut_t35: usize,
+}
+
 pub unsafe extern "C" fn dav1d_default_picture_alloc(
     p: *mut Dav1dPicture,
     cookie: *mut c_void,
@@ -134,6 +140,16 @@ unsafe extern "C" fn free_buffer(_data: *const u8, user_data: *mut c_void) {
     free(pic_ctx as *mut c_void);
 }
 
+pub unsafe extern "C" fn dav1d_picture_free_itut_t35(_data: *const u8, user_data: *mut c_void) {
+    let itut_t35_ctx: *mut itut_t35_ctx_context = user_data as *mut itut_t35_ctx_context;
+
+    for i in 0..(*itut_t35_ctx).n_itut_t35 {
+        free((*(*itut_t35_ctx).itut_t35.offset(i as isize)).payload as *mut c_void)
+    }
+    free((*itut_t35_ctx).itut_t35 as *mut c_void);
+    free(itut_t35_ctx as *mut c_void);
+}
+
 unsafe extern "C" fn picture_alloc_with_edges(
     c: *mut Dav1dContext,
     p: *mut Dav1dPicture,
@@ -143,14 +159,8 @@ unsafe extern "C" fn picture_alloc_with_edges(
     seq_hdr_ref: *mut Dav1dRef,
     frame_hdr: *mut Dav1dFrameHeader,
     frame_hdr_ref: *mut Dav1dRef,
-    content_light: *mut Dav1dContentLightLevel,
-    content_light_ref: *mut Dav1dRef,
-    mastering_display: *mut Dav1dMasteringDisplay,
-    mastering_display_ref: *mut Dav1dRef,
-    itut_t35: *mut Dav1dITUTT35,
-    itut_t35_ref: *mut Dav1dRef,
     bpc: c_int,
-    props: *const Dav1dDataProps,
+    _props: *const Dav1dDataProps,
     p_allocator: *mut Dav1dPicAllocator,
     extra: usize,
     extra_ptr: *mut *mut c_void,
@@ -214,16 +224,6 @@ unsafe extern "C" fn picture_alloc_with_edges(
     if !frame_hdr_ref.is_null() {
         dav1d_ref_inc(frame_hdr_ref);
     }
-    dav1d_picture_copy_props(
-        p,
-        content_light,
-        content_light_ref,
-        mastering_display,
-        mastering_display_ref,
-        itut_t35,
-        itut_t35_ref,
-        props,
-    );
 
     if extra != 0 && !extra_ptr.is_null() {
         *extra_ptr = &mut (*pic_ctx).extra_ptr as *mut *mut c_void as *mut c_void;
@@ -240,6 +240,7 @@ pub unsafe fn dav1d_picture_copy_props(
     mastering_display_ref: *mut Dav1dRef,
     itut_t35: *mut Dav1dITUTT35,
     itut_t35_ref: *mut Dav1dRef,
+    n_itut_t35: usize,
     props: *const Dav1dDataProps,
 ) {
     dav1d_data_props_copy(&mut (*p).m, props);
@@ -261,6 +262,7 @@ pub unsafe fn dav1d_picture_copy_props(
     dav1d_ref_dec(&mut (*p).itut_t35_ref);
     (*p).itut_t35_ref = itut_t35_ref;
     (*p).itut_t35 = itut_t35;
+    (*p).n_itut_t35 = n_itut_t35;
     if !itut_t35_ref.is_null() {
         dav1d_ref_inc(itut_t35_ref);
     }
@@ -282,12 +284,6 @@ pub unsafe fn dav1d_thread_picture_alloc(
         (*f).seq_hdr_ref,
         (*f).frame_hdr,
         (*f).frame_hdr_ref,
-        (*c).content_light,
-        (*c).content_light_ref,
-        (*c).mastering_display,
-        (*c).mastering_display_ref,
-        (*c).itut_t35,
-        (*c).itut_t35_ref,
         bpc,
         &mut (*((*f).tile).offset(0)).data.m,
         &mut (*c).allocator,
@@ -301,8 +297,22 @@ pub unsafe fn dav1d_thread_picture_alloc(
     if res != 0 {
         return res;
     }
+
+    dav1d_picture_copy_props(
+        &mut (*p).p,
+        (*c).content_light,
+        (*c).content_light_ref,
+        (*c).mastering_display,
+        (*c).mastering_display_ref,
+        (*c).itut_t35,
+        (*c).itut_t35_ref,
+        (*c).n_itut_t35 as usize,
+        &mut (*((*f).tile).offset(0)).data.m,
+    );
+
     dav1d_ref_dec(&mut (*c).itut_t35_ref);
     (*c).itut_t35 = 0 as *mut Dav1dITUTT35;
+    (*c).n_itut_t35 = 0;
     let flags_mask = if (*(*f).frame_hdr).show_frame != 0 || (*c).output_invisible_frames != 0 {
         0 as c_int
     } else {
@@ -337,19 +347,29 @@ pub unsafe fn dav1d_picture_alloc_copy(
         (*src).seq_hdr_ref,
         (*src).frame_hdr,
         (*src).frame_hdr_ref,
-        (*src).content_light,
-        (*src).content_light_ref,
-        (*src).mastering_display,
-        (*src).mastering_display_ref,
-        (*src).itut_t35,
-        (*src).itut_t35_ref,
         (*src).p.bpc,
         &(*src).m,
         &mut (*pic_ctx).allocator,
         0 as c_int as usize,
         0 as *mut *mut c_void,
     );
-    return res;
+    if res != 0 {
+        return res;
+    }
+
+    dav1d_picture_copy_props(
+        dst,
+        (*c).content_light,
+        (*c).content_light_ref,
+        (*c).mastering_display,
+        (*c).mastering_display_ref,
+        (*c).itut_t35,
+        (*c).itut_t35_ref,
+        (*c).n_itut_t35 as usize,
+        &(*src).m,
+    );
+
+    return 0 as c_int;
 }
 
 pub unsafe fn dav1d_picture_ref(dst: *mut Dav1dPicture, src: *const Dav1dPicture) {

tests/seek_stress.rs

@@ -169,7 +169,8 @@ unsafe extern "C" fn decode_rand(
         content_light: 0 as *mut Dav1dContentLightLevel,
         mastering_display: 0 as *mut Dav1dMasteringDisplay,
         itut_t35: 0 as *mut Dav1dITUTT35,
-        reserved: [0; 4],
+        n_itut_t35: 0,
+        reserved: [0; 3],
         frame_hdr_ref: 0 as *mut Dav1dRef,
         seq_hdr_ref: 0 as *mut Dav1dRef,
         content_light_ref: 0 as *mut Dav1dRef,
@@ -224,7 +225,8 @@ unsafe extern "C" fn decode_all(
         content_light: 0 as *mut Dav1dContentLightLevel,
         mastering_display: 0 as *mut Dav1dMasteringDisplay,
         itut_t35: 0 as *mut Dav1dITUTT35,
-        reserved: [0; 4],
+        n_itut_t35: 0,
+        reserved: [0; 3],
         frame_hdr_ref: 0 as *mut Dav1dRef,
         seq_hdr_ref: 0 as *mut Dav1dRef,
         content_light_ref: 0 as *mut Dav1dRef,

tools/dav1d.rs

@@ -330,7 +330,8 @@ unsafe fn main_0(argc: c_int, argv: *const *mut c_char) -> c_int {
         content_light: 0 as *mut Dav1dContentLightLevel,
         mastering_display: 0 as *mut Dav1dMasteringDisplay,
         itut_t35: 0 as *mut Dav1dITUTT35,
-        reserved: [0; 4],
+        n_itut_t35: 0,
+        reserved: [0; 3],
         frame_hdr_ref: 0 as *mut Dav1dRef,
         seq_hdr_ref: 0 as *mut Dav1dRef,
         content_light_ref: 0 as *mut Dav1dRef,