run code formatters

CCExtractor · Dec 25, 2024 · c3a91a6 · c3a91a6
1 parent 83fb2d7
commit c3a91a6
Show file tree

Hide file tree

Showing 8 changed files with 53 additions and 38 deletions.
diff --git a/src/lib_ccx/asf_functions.c b/src/lib_ccx/asf_functions.c
@@ -561,7 +561,7 @@ int asf_get_more_data(struct lib_ccx_ctx *ctx, struct demuxer_data **ppdata)
 		dbg_print(CCX_DMT_PARSE, "Number of data packets: %ld\n", (long)asf_data_container.TotalDataPackets);
 
 		reentry = 0; // Make sure we read the Data Packet Headers
-	}		     // End of if (firstcall)
+	} // End of if (firstcall)
 	firstcall = 0;
 
 	// Start loop over Data Packets

diff --git a/src/lib_ccx/cc_bitstream.c b/src/lib_ccx/cc_bitstream.c
@@ -4,15 +4,15 @@
 // plus some data related helper functions.
 
 #ifndef DISABLE_RUST
-extern void* ccxr_init_bitstream(const uint8_t *start, const uint8_t *end);
+extern void *ccxr_init_bitstream(const uint8_t *start, const uint8_t *end);
 extern void ccxr_free_bitstream(void *bs);
 extern uint64_t ccxr_next_bits(void *bs, uint32_t bnum);
 extern uint64_t ccxr_read_bits(void *bs, uint32_t bnum);
 extern int ccxr_skip_bits(void *bs, uint32_t bnum);
 extern int ccxr_is_byte_aligned(const void *bs);
 extern void ccxr_make_byte_aligned(void *bs);
-extern const uint8_t* ccxr_next_bytes(void *bs, size_t bynum);
-extern const uint8_t* ccxr_read_bytes(void *bs, size_t bynum);
+extern const uint8_t *ccxr_next_bytes(void *bs, size_t bynum);
+extern const uint8_t *ccxr_read_bytes(void *bs, size_t bynum);
 extern uint64_t ccxr_read_exp_golomb_unsigned(void *bs);
 extern int64_t ccxr_read_exp_golomb(void *bs);
 extern uint8_t ccxr_reverse8(uint8_t data);

diff --git a/src/lib_ccx/ccx_decoders_common.c b/src/lib_ccx/ccx_decoders_common.c
@@ -219,7 +219,7 @@ int do_cb(struct lib_cc_decode *ctx, unsigned char *cc_block, struct cc_subtitle
 			default:
 				fatal(CCX_COMMON_EXIT_BUG_BUG, "In do_cb: Impossible value for cc_type, Please file a bug report on GitHub.\n");
 		} // switch (cc_type)
-	}	  // cc_valid
+	} // cc_valid
 	else
 	{
 		dbg_print(CCX_DMT_CBRAW, "    ..   ..   ..\n");

diff --git a/src/lib_ccx/ccx_encoders_spupng.c b/src/lib_ccx/ccx_encoders_spupng.c
@@ -704,7 +704,7 @@ uint32_t *utf8_to_utf32(char *src)
 }
 
 // Convert big-endian and little-endian
-#define BigtoLittle32(A) ((((uint32_t)(A)&0xff000000) >> 24) | (((uint32_t)(A)&0x00ff0000) >> 8) | (((uint32_t)(A)&0x0000ff00) << 8) | (((uint32_t)(A)&0x000000ff) << 24))
+#define BigtoLittle32(A) ((((uint32_t)(A) & 0xff000000) >> 24) | (((uint32_t)(A) & 0x00ff0000) >> 8) | (((uint32_t)(A) & 0x0000ff00) << 8) | (((uint32_t)(A) & 0x000000ff) << 24))
 
 // Generate PNG file from an UTF-8 string (str)
 // PNG file will be stored at output

diff --git a/src/lib_ccx/dvb_subtitle_decoder.c b/src/lib_ccx/dvb_subtitle_decoder.c
@@ -39,20 +39,20 @@
 
 #define YUV_TO_RGB1_CCIR(cb1, cr1)                                                               \
 	{                                                                                        \
-		cb = (cb1)-128;                                                                  \
-		cr = (cr1)-128;                                                                  \
+		cb = (cb1) - 128;                                                                \
+		cr = (cr1) - 128;                                                                \
 		r_add = FIX(1.40200 * 255.0 / 224.0) * cr + ONE_HALF;                            \
 		g_add = -FIX(0.34414 * 255.0 / 224.0) * cb - FIX(0.71414 * 255.0 / 224.0) * cr + \
 			ONE_HALF;                                                                \
 		b_add = FIX(1.77200 * 255.0 / 224.0) * cb + ONE_HALF;                            \
 	}
 
-#define YUV_TO_RGB2_CCIR(r, g, b, y1)               \
-	{                                           \
-		y = ((y1)-16) * FIX(255.0 / 219.0); \
-		r = cm[(y + r_add) >> SCALEBITS];   \
-		g = cm[(y + g_add) >> SCALEBITS];   \
-		b = cm[(y + b_add) >> SCALEBITS];   \
+#define YUV_TO_RGB2_CCIR(r, g, b, y1)                 \
+	{                                             \
+		y = ((y1) - 16) * FIX(255.0 / 219.0); \
+		r = cm[(y + r_add) >> SCALEBITS];     \
+		g = cm[(y + g_add) >> SCALEBITS];     \
+		b = cm[(y + b_add) >> SCALEBITS];     \
 	}
 
 #define times4(x) x, x, x, x

diff --git a/src/lib_ccx/general_loop.c b/src/lib_ccx/general_loop.c
@@ -993,7 +993,7 @@ int general_loop(struct lib_ccx_ctx *ctx)
 	enum ccx_stream_mode_enum stream_mode;
 	struct demuxer_data *datalist = NULL;
 	struct demuxer_data *data_node = NULL;
-	int (*get_more_data)(struct lib_ccx_ctx * c, struct demuxer_data * *d);
+	int (*get_more_data)(struct lib_ccx_ctx *c, struct demuxer_data **d);
 	int ret;
 	int caps = 0;
 

diff --git a/src/lib_ccx/hardsubx_decoder.c b/src/lib_ccx/hardsubx_decoder.c
@@ -552,7 +552,7 @@ void process_hardsubx_linear_frames_and_normal_subs(struct lib_hardsubx_ctx *har
 	enum ccx_stream_mode_enum stream_mode;
 	struct demuxer_data *datalist = NULL;
 	struct demuxer_data *data_node = NULL;
-	int (*get_more_data)(struct lib_ccx_ctx * c, struct demuxer_data * *d);
+	int (*get_more_data)(struct lib_ccx_ctx *c, struct demuxer_data **d);
 	int ret;
 	int caps = 0;
 

diff --git a/src/rust/lib_ccxr/src/common/bitstream.rs b/src/rust/lib_ccxr/src/common/bitstream.rs
@@ -48,7 +48,9 @@ impl<'a> Bitstream<'a> {
         }
 
         // Calculate remaining bits
-        self.bits_left = (self.pos.len() as i64 - self.current_pos as i64 - 1) * 8 + self.bpos as i64 - bnum as i64;
+        self.bits_left = (self.pos.len() as i64 - self.current_pos as i64 - 1) * 8
+            + self.bpos as i64
+            - bnum as i64;
         if self.bits_left < 0 {
             return Ok(0);
         }
@@ -72,8 +74,12 @@ impl<'a> Bitstream<'a> {
             }
 
             let current_byte = self.pos[vpos];
-            res |= if (current_byte & (1 << (vbit - 1))) != 0 { 1 } else { 0 };
-
+            res |= if (current_byte & (1 << (vbit - 1))) != 0 {
+                1
+            } else {
+                0
+            };
+
             vbit -= 1;
             bits_to_read -= 1;
 
@@ -114,7 +120,9 @@ impl<'a> Bitstream<'a> {
             return Ok(false);
         }
 
-        self.bits_left = (self.pos.len() as i64 - self.current_pos as i64 - 1) * 8 + self.bpos as i64 - bnum as i64;
+        self.bits_left = (self.pos.len() as i64 - self.current_pos as i64 - 1) * 8
+            + self.bpos as i64
+            - bnum as i64;
         if self.bits_left < 0 {
             return Ok(false);
         }
@@ -161,7 +169,8 @@ impl<'a> Bitstream<'a> {
             self.current_pos += 1;
         }
 
-        self.bits_left = (self.pos.len() as i64 - self.current_pos as i64 - 1) * 8 + self.bpos as i64;
+        self.bits_left =
+            (self.pos.len() as i64 - self.current_pos as i64 - 1) * 8 + self.bpos as i64;
         Ok(())
     }
 
@@ -171,7 +180,9 @@ impl<'a> Bitstream<'a> {
             return Ok(None);
         }
 
-        self.bits_left = (self.pos.len() as i64 - self.current_pos as i64 - 1) * 8 + self.bpos as i64 - (bynum * 8) as i64;
+        self.bits_left = (self.pos.len() as i64 - self.current_pos as i64 - 1) * 8
+            + self.bpos as i64
+            - (bynum * 8) as i64;
 
         if !self.is_byte_aligned()? || self.bits_left < 0 || bynum < 1 {
             return Ok(None);
@@ -180,7 +191,9 @@ impl<'a> Bitstream<'a> {
         self._i_bpos = 8;
         self._i_pos = self.current_pos + bynum;
 
-        Ok(Some(&self.pos[self.current_pos..min(self.current_pos + bynum, self.pos.len())]))
+        Ok(Some(
+            &self.pos[self.current_pos..min(self.current_pos + bynum, self.pos.len())],
+        ))
     }
 
     pub fn read_bytes(&mut self, bynum: usize) -> Result<Option<&[u8]>, BitstreamError> {
@@ -193,17 +206,19 @@ impl<'a> Bitstream<'a> {
             return Ok(None);
         }
 
-        self.bits_left = (self.pos.len() as i64 - self.current_pos as i64 - 1) * 8 + self.bpos as i64 - (bynum * 8) as i64;
+        self.bits_left = (self.pos.len() as i64 - self.current_pos as i64 - 1) * 8
+            + self.bpos as i64
+            - (bynum * 8) as i64;
         if self.bits_left < 0 {
             return Ok(None);
         }
 
         let new_pos = self.current_pos + bynum;
         let slice = &self.pos[self.current_pos..min(new_pos, self.pos.len())];
-        
+
         self.bpos = 8;
         self.current_pos = new_pos;
-        
+
         Ok(Some(slice))
     }
 
@@ -245,7 +260,7 @@ pub extern "C" fn ccxr_init_bitstream(start: *const u8, end: *const u8) -> *mut
         let slice = std::slice::from_raw_parts(start, len);
         match Bitstream::new(slice) {
             Ok(bs) => Box::into_raw(Box::new(bs)),
-            Err(_) => std::ptr::null_mut()
+            Err(_) => std::ptr::null_mut(),
         }
     }
 }
@@ -267,7 +282,7 @@ pub extern "C" fn ccxr_next_bits(bs: *mut Bitstream<'static>, bnum: u32) -> u64
     unsafe {
         match (*bs).next_bits(bnum) {
             Ok(val) => val,
-            Err(_) => 0
+            Err(_) => 0,
         }
     }
 }
@@ -280,7 +295,7 @@ pub extern "C" fn ccxr_read_bits(bs: *mut Bitstream<'static>, bnum: u32) -> u64
     unsafe {
         match (*bs).read_bits(bnum) {
             Ok(val) => val,
-            Err(_) => 0
+            Err(_) => 0,
         }
     }
 }
@@ -294,7 +309,7 @@ pub extern "C" fn ccxr_skip_bits(bs: *mut Bitstream<'static>, bnum: u32) -> i32
         match (*bs).skip_bits(bnum) {
             Ok(true) => 1,
             Ok(false) => 0,
-            Err(_) => 0
+            Err(_) => 0,
         }
     }
 }
@@ -308,7 +323,7 @@ pub extern "C" fn ccxr_is_byte_aligned(bs: *const Bitstream<'static>) -> i32 {
         match (*bs).is_byte_aligned() {
             Ok(true) => 1,
             Ok(false) => 0,
-            Err(_) => 0
+            Err(_) => 0,
         }
     }
 }
@@ -330,7 +345,7 @@ pub extern "C" fn ccxr_next_bytes(bs: *mut Bitstream<'static>, bynum: usize) ->
     unsafe {
         match (*bs).next_bytes(bynum) {
             Ok(Some(bytes)) => bytes.as_ptr(),
-            _ => std::ptr::null()
+            _ => std::ptr::null(),
         }
     }
 }
@@ -343,7 +358,7 @@ pub extern "C" fn ccxr_read_bytes(bs: *mut Bitstream<'static>, bynum: usize) ->
     unsafe {
         match (*bs).read_bytes(bynum) {
             Ok(Some(bytes)) => bytes.as_ptr(),
-            _ => std::ptr::null()
+            _ => std::ptr::null(),
         }
     }
 }
@@ -356,7 +371,7 @@ pub extern "C" fn ccxr_read_exp_golomb_unsigned(bs: *mut Bitstream<'static>) ->
     unsafe {
         match (*bs).read_exp_golomb_unsigned() {
             Ok(val) => val,
-            Err(_) => 0
+            Err(_) => 0,
         }
     }
 }
@@ -369,7 +384,7 @@ pub extern "C" fn ccxr_read_exp_golomb(bs: *mut Bitstream<'static>) -> i64 {
     unsafe {
         match (*bs).read_exp_golomb() {
             Ok(val) => val,
-            Err(_) => 0
+            Err(_) => 0,
         }
     }
 }
@@ -394,7 +409,7 @@ mod tests {
     fn test_read_bits() {
         let data = vec![0b10101010];
         let mut bs = Bitstream::new(&data).unwrap();
-        
+
         assert_eq!(bs.read_bits(1).unwrap(), 1);
         assert_eq!(bs.read_bits(1).unwrap(), 0);
         assert_eq!(bs.read_bits(1).unwrap(), 1);
@@ -404,11 +419,11 @@ mod tests {
     fn test_byte_alignment() {
         let data = vec![0xFF];
         let mut bs = Bitstream::new(&data).unwrap();
-        
+
         assert!(bs.is_byte_aligned().unwrap());
         bs.read_bits(1).unwrap();
         assert!(!bs.is_byte_aligned().unwrap());
         bs.make_byte_aligned().unwrap();
         assert!(bs.is_byte_aligned().unwrap());
     }
-} 
+}