Rust updates:- Update documentation (#1374)

* Fix warning

* Update documentation

* Fix typo

* fmt

Author: PunitLodha

src/lib_ccx/ccx_decoders_common.c

@@ -195,16 +195,16 @@ int do_cb(struct lib_cc_decode *ctx, unsigned char *cc_block, struct cc_subtitle
 					timeok = 0;
 					ctx->processed_enough = 1;
 				}
-				char temp[4];
-				temp[0] = cc_valid;
-				temp[1] = cc_type;
-				temp[2] = cc_block[1];
-				temp[3] = cc_block[2];
 				if (timeok)
 				{
 					if (ctx->write_format != CCX_OF_RCWT)
 					{
 #ifndef ENABLE_RUST
+						char temp[4];
+						temp[0] = cc_valid;
+						temp[1] = cc_type;
+						temp[2] = cc_block[1];
+						temp[3] = cc_block[2];
 						dtvcc_process_data(ctx->dtvcc, (const unsigned char *)temp);
 #endif
 					}

src/rust/src/decoder/commands.rs

@@ -1,6 +1,6 @@
 //! Different code sets as defined in CEA-708-E
 //!
-//! Refer section 7.1 CEA-708-E
+//! Refer section 7.1 CEA-708-E.
 //! Different code sets are:
 //!
 //! | Name | Description | Space |

src/rust/src/decoder/mod.rs

@@ -1,6 +1,6 @@
 //! CEA 708 decoder
 //!
-//! This module provides a CEA 708 decoder as defined by ANSI/CTA-708-E R-2018
+//! Provides a CEA 708 decoder as defined by ANSI/CTA-708-E R-2018
 
 mod commands;
 mod output;
@@ -20,7 +20,7 @@ const CCX_DTVCC_SCREENGRID_COLUMNS: u8 = 210;
 const CCX_DTVCC_MAX_ROWS: u8 = 15;
 const CCX_DTVCC_MAX_COLUMNS: u8 = 32 * 2;
 
-/// Stores the context required for processing 708 data
+/// Context required for processing 708 data
 pub struct Dtvcc<'a> {
     pub is_active: bool,
     pub active_services_count: u8,
@@ -60,7 +60,7 @@ impl<'a> Dtvcc<'a> {
             timing,
         }
     }
-    /// Process cc data to generate dtvcc packet
+    /// Process cc data and add it to the dtvcc packet
     pub fn process_cc_data(&mut self, cc_valid: u8, cc_type: u8, data1: u8, data2: u8) {
         if !self.is_active && !self.report_enabled {
             return;
@@ -86,6 +86,7 @@ impl<'a> Dtvcc<'a> {
                             max_len *= 2;
                         }
 
+                        // If packet is complete then process the packet
                         if self.packet_length >= max_len {
                             self.process_current_packet(max_len);
                         }
@@ -109,6 +110,7 @@ impl<'a> Dtvcc<'a> {
             ),
         }
     }
+    /// Add data to the packet
     pub fn add_data_to_packet(&mut self, data1: u8, data2: u8) {
         self.packet[self.packet_length as usize] = data1;
         self.packet_length += 1;
@@ -126,6 +128,8 @@ impl<'a> Dtvcc<'a> {
             return;
         }
 
+        // Check if current sequence is correct
+        // Sequence number is a 2 bit rolling sequence from (0-3)
         if self.last_sequence != CCX_DTVCC_NO_LAST_SEQUENCE
             && (self.last_sequence + 1) % 4 != seq as i32
         {
@@ -189,6 +193,10 @@ impl<'a> Dtvcc<'a> {
     }
 }
 
+/// A single character symbol
+///
+/// sym stores the symbol
+/// init is used to know if the symbol is initialized
 impl dtvcc_symbol {
     /// Create a new symbol
     pub fn new(sym: u16) -> Self {

src/rust/src/decoder/output.rs

@@ -1,3 +1,5 @@
+//! Utilty functions to write captions
+
 #[cfg(windows)]
 use std::os::windows::io::{FromRawHandle, IntoRawHandle, RawHandle};
 use std::{
@@ -23,6 +25,7 @@ pub struct Writer<'a> {
 }
 
 impl<'a> Writer<'a> {
+    /// Create a new writer context
     pub fn new(
         cea_708_counter: &'a mut u32,
         subs_delay: LLONG,
@@ -43,6 +46,11 @@ impl<'a> Writer<'a> {
             no_bom,
         }
     }
+    /// Write subtitles to the file
+    ///
+    /// File must already exist
+    /// On Unix Platforms, uses the raw fd from context to access the file
+    /// On Windows Platforms, uses the raw handle from context to access the file
     pub fn write_to_file(&mut self, buf: &[u8]) -> Result<(), String> {
         #[cfg(unix)]
         {
@@ -60,6 +68,10 @@ impl<'a> Writer<'a> {
     }
 }
 
+/// Write the symbol to the provided buffer
+///
+/// If symbol is 8-bit, then it's written to the buffer
+/// If symbol is 16-bit, then two 8-bit symbols are written to the buffer
 pub fn write_char(sym: &dtvcc_symbol, buf: &mut Vec<u8>) {
     if sym.sym >> 8 != 0 {
         buf.push((sym.sym >> 8) as u8);
@@ -69,6 +81,12 @@ pub fn write_char(sym: &dtvcc_symbol, buf: &mut Vec<u8>) {
     }
 }
 
+/// Convert from CEA-708 color representation to hex code
+///
+/// Two bits are specified for each red, green, and blue color value which defines the
+/// intensity of each individual color component.
+///
+/// Refer section 8.8 CEA-708-E
 pub fn color_to_hex(color: u8) -> (u8, u8, u8) {
     let red = color >> 4;
     let green = (color >> 2) & 0x3;