impl: add codec metadata in rtmp frame

Author: yuki-uchida

moqt-ingest-gateway/src/audio.rs

@@ -8,14 +8,12 @@ pub struct AacState {
     audio_specific_config: Option<Vec<u8>>,
     sample_rate: Option<u32>,
     channels: Option<u8>,
-    config_sent: bool,
 }
 
 pub struct AudioFrame {
     pub data: Vec<u8>,
     pub sample_rate: u32,
     pub channels: u8,
-    pub include_config: bool,
     pub audio_specific_config: Vec<u8>,
 }
 
@@ -29,21 +27,17 @@ pub fn pack_audio_chunk_payload(
     duration_us: Option<u64>,
     sent_at_ms: u64,
 ) -> Vec<u8> {
-    let description_b64 = if frame.include_config {
-        Some(general_purpose::STANDARD.encode(&frame.audio_specific_config))
-    } else {
-        None
-    };
+    let description_b64 = general_purpose::STANDARD.encode(&frame.audio_specific_config);
 
     let meta = serde_json::json!({
         "type": "key",
         "timestamp": timestamp_us as i64,
         "duration": duration_us.map(|d| d as i64),
         "sentAt": sent_at_ms as i64,
-        "codec": description_b64.as_ref().map(|_| "mp4a.40.2"),
+        "codec": "mp4a.40.2",
         "descriptionBase64": description_b64,
-        "sampleRate": frame.include_config.then_some(frame.sample_rate as i64),
-        "channels": frame.include_config.then_some(frame.channels as i64),
+        "sampleRate": frame.sample_rate as i64,
+        "channels": frame.channels as i64,
     });
     let meta_bytes = meta.to_string().into_bytes();
     let meta_len = meta_bytes.len() as u32;
@@ -71,7 +65,6 @@ impl AacState {
         match packet_type {
             0 => {
                 self.parse_audio_specific_config(payload)?;
-                self.config_sent = false;
                 Ok(None)
             }
             1 => {
@@ -83,13 +76,10 @@ impl AacState {
                     (Some(sr), Some(ch), Some(asc)) => (sr, ch, asc.clone()),
                     _ => return Ok(None),
                 };
-                let include_config = !self.config_sent;
-                self.config_sent = true;
                 Ok(Some(AudioFrame {
                     data: payload.to_vec(),
                     sample_rate,
                     channels,
-                    include_config,
                     audio_specific_config: asc,
                 }))
             }

moqt-ingest-gateway/src/rtmp/session.rs

@@ -22,7 +22,6 @@ pub struct RtmpState {
     pub moqt: Option<MoqtManager>,
     pub video_states: HashMap<(String, String), AvcState>,
     pub audio_states: HashMap<(String, String), AacState>,
-    pub video_codec_sent: HashMap<(String, String), bool>,
 }
 
 impl RtmpState {
@@ -33,7 +32,6 @@ impl RtmpState {
             moqt: Some(moqt),
             video_states: HashMap::new(),
             audio_states: HashMap::new(),
-            video_codec_sent: HashMap::new(),
         }
     }
 }
@@ -89,8 +87,6 @@ pub async fn handle_event(
             println!("[rtmp {label}] publish finished app={app_name} stream={stream_key}");
             let (namespace_path, _cleaned_stream_key) =
                 split_namespace_and_key(&app_name, &stream_key);
-            let key = (namespace_path.clone(), "video".to_string());
-            state.video_codec_sent.remove(&key);
             let audio_key = (namespace_path, "audio".to_string());
             state.audio_states.remove(&audio_key);
         }
@@ -199,13 +195,7 @@ pub async fn handle_event(
                         .duration_since(std::time::UNIX_EPOCH)
                         .unwrap_or_default()
                         .as_millis() as u64;
-                    let codec_key = (namespace_path.clone(), track_name.clone());
-                    let already_sent = state
-                        .video_codec_sent
-                        .get(&codec_key)
-                        .copied()
-                        .unwrap_or(false);
-                    let include_codec = frame.is_key && !already_sent;
+                    let include_codec = frame.is_key;
                     let payload = pack_video_chunk_payload(
                         frame.is_key,
                         timestamp_us,
@@ -218,13 +208,12 @@ pub async fn handle_event(
                         },
                         None,
                     );
-                    if frame.is_key && include_codec {
+                    if frame.is_key {
                         if let Some(codec) = frame.codec.as_deref() {
                             println!(
                                 "[rtmp {label}] detected video codec from SPS: {codec} ns={:?} track={}",
                                 namespace, track_name
                             );
-                            state.video_codec_sent.insert(codec_key.clone(), true);
                         } else {
                             println!(
                                 "[rtmp {label}] video codec from SPS unavailable ns={:?} track={}",