tirtc-devtools-cli 0.0.9 → 0.0.11

package/vendor/app-server/bin/runtime/macos-arm64/include/tirtc/av.h

@@ -1,6 +1,8 @@
 #ifndef TIRTC_FACADE_AV_H_
 #define TIRTC_FACADE_AV_H_
 
+#include <stdint.h>
+
 #include "tirtc/audio.h"
 #include "tirtc/media_codec.h"
 #include "tirtc/video_io.h"
@@ -13,37 +15,34 @@ extern "C" {
  * @file tirtc/av.h
  * @brief Audio-video facade layer built on top of `tirtc/audio.h`.
  *
- * This header adds local video input, remote video output, preview binding,
- * and video-specific control helpers to the transport-plus-audio facade.
+ * This header adds media-object owned video producer, preview, view, and
+ * remote-consumer contracts to the transport-plus-audio facade.
  *
  * Typical uplink flow:
  * 1. Create a ::TirtcVideoInput.
  * 2. Bind a concrete capture backend with ::tirtc_video_input_set_vin.
  * 3. Optionally configure encoding options and observers.
- * 4. Optionally bind a preview output with
- *    ::tirtc_video_input_set_preview_output.
- * 5. Start the input and attach it to a connection stream.
- * 6. Detach, stop, clear preview, and destroy the input during shutdown.
+ * 4. Optionally bind a preview output with ::tirtc_video_input_attach_preview.
+ * 5. Start or stop the local producer lifecycle with
+ *    ::tirtc_video_input_start and ::tirtc_video_input_stop.
+ * 6. Attach or detach the input to individual connections with
+ *    ::tirtc_video_input_attach and ::tirtc_video_input_detach.
+ * 7. Destroy the input when the object is no longer needed.
  *
  * Typical downlink flow:
  * 1. Create a ::TirtcVideoOutput.
- * 2. Bind a concrete render backend with ::tirtc_video_output_set_vout.
+ * 2. Bind a local render backend with ::tirtc_video_output_attach_view.
  * 3. Optionally install an observer.
- * 4. Attach the output to a connection stream.
- * 5. Detach and destroy the output during shutdown.
- *
- * Important exclusivity rule:
- * one ::TirtcVideoOutput can serve only one consumer at a time. It may be used
- * either as a local preview target for one ::TirtcVideoInput or as a remote
- * display target for one connection stream, but not both at once.
+ * 4. Attach or detach the output to select which remote stream it consumes.
+ * 5. Destroy the output when the object is no longer needed.
  *
  * Ownership model:
  * - The caller owns all video input and output handles.
- * - Attaching to a connection or binding a preview output is non-owning.
- * - Destroying a connection detaches remote-bound video objects but does not
- *   destroy them.
- * - Destroying a video input clears its preview binding but does not destroy
- *   the preview output object.
+ * - Remote attach relationships and preview/view relationships are non-owning.
+ * - Destroying a connection clears the binds that reference that connection but
+ *   does not destroy media objects.
+ * - Destroying a media object is strong cleanup: it releases attach-state,
+ *   preview-state, view-state, observer state, and internal pipeline state.
  */
 
 /** @brief Opaque video uplink handle. */
@@ -56,31 +55,25 @@ typedef struct TirtcVideoOutput TirtcVideoOutput;
  * @brief Video output state reported through ::TirtcVideoOutputObserver.
  */
 typedef enum TirtcVideoOutputState {
-  /** Output is attached but not currently rendering frames. */
+  /** Output currently is not consuming or rendering a remote route. */
   TIRTC_VIDEO_OUTPUT_STATE_IDLE = 0,
 
-  /** Output is actively rendering frames. */
-  TIRTC_VIDEO_OUTPUT_STATE_RENDERING = 1,
-
-  /** Output is waiting for frames or recovering from a transient failure. */
-  TIRTC_VIDEO_OUTPUT_STATE_BUFFERING = 2,
-
-  /** Reserved paused state. */
-  TIRTC_VIDEO_OUTPUT_STATE_PAUSED = 3,
+  /** Output is waiting for frames or sink readiness. */
+  TIRTC_VIDEO_OUTPUT_STATE_BUFFERING = 1,
 
-  /** Reserved completed state. */
-  TIRTC_VIDEO_OUTPUT_STATE_COMPLETED = 4,
+  /** Output is actively rendering frames. */
+  TIRTC_VIDEO_OUTPUT_STATE_RENDERING = 2,
 
   /** Output encountered repeated rendering failures. */
-  TIRTC_VIDEO_OUTPUT_STATE_FAILED = 5,
+  TIRTC_VIDEO_OUTPUT_STATE_FAILED = 3,
 } TirtcVideoOutputState;
 
 /**
  * @brief Video input encoding options.
  *
- * These options are consumed when the internal video uplink pipeline is first
- * created. Configure them before the first successful start for predictable
- * behavior.
+ * These options are consumed when the internal video uplink pipeline is
+ * created or restarted. Configure them before the next
+ * ::tirtc_video_input_start when predictable start behavior matters.
  */
 typedef struct TirtcVideoInputOptions {
   /**
@@ -125,32 +118,29 @@ typedef struct TirtcVideoInputOptions {
  * @brief Optional observer for a video input object.
  *
  * The implementation stores a copy of this structure. Installing or replacing
- * an observer does not replay prior state; callbacks describe subsequent local
- * start and stop transitions.
+ * an observer does not replay prior state; callbacks describe subsequent input
+ * lifecycle transitions, output-size changes, and failures.
  *
- * Callback delivery is not guaranteed to be on a fixed thread. In the current
- * implementation, input state notifications may be dispatched synchronously by
- * API calls such as ::tirtc_video_input_start and ::tirtc_video_input_stop.
- * Callers must therefore make callback logic safe for reentrant delivery.
+ * Callback delivery is not guaranteed to be on a fixed thread. Callers must
+ * therefore make callback logic safe for reentrant delivery and perform their
+ * own thread handoff when thread affinity is required.
  */
 typedef struct TirtcVideoInputObserver {
   /**
-   * @brief Called when the input starts or stops.
-   *
-   * In the current implementation, a start failure is reported as STOPPED with
-   * a non-OK ::error value.
+   * @brief Called when the input lifecycle state changes.
    */
-  void (*on_state_changed)(TirtcVideoInput* input, TirtcInputState state, TirtcError error,
-                           void* user_data);
+  void (*on_state_changed)(TirtcVideoInput* input, TirtcInputState state, void* user_data);
 
   /**
-   * @brief Reserved callback for output-size updates.
-   *
-   * The current facade implementation exposes this callback in the contract but
-   * does not currently emit it.
+   * @brief Called when the effective encoded output size changes.
    */
   void (*on_output_size_changed)(TirtcVideoInput* input, uint32_t width, uint32_t height,
                                  void* user_data);
+
+  /**
+   * @brief Called when the input encounters an error.
+   */
+  void (*on_error)(TirtcVideoInput* input, TirtcError error, const char* message, void* user_data);
 } TirtcVideoInputObserver;
 
 /**
@@ -159,30 +149,29 @@ typedef struct TirtcVideoInputObserver {
  * The implementation stores a copy of this structure. Installing or replacing
  * an observer does not replay the current output state.
  *
- * Callback delivery is not guaranteed to be on a fixed thread. State changes
- * may be reported synchronously by attach, detach, or backend-clear paths, or
- * asynchronously from the internal downlink pipeline. Callers must therefore
- * make callback logic safe for reentrant delivery and perform their own thread
- * handoff when thread affinity is required.
+ * Callback delivery is not guaranteed to be on a fixed thread. State changes,
+ * output-size changes, and failures may be reported synchronously by local API
+ * paths or asynchronously from the internal downlink pipeline. Callers must
+ * therefore make callback logic safe for reentrant delivery and perform their
+ * own thread handoff when thread affinity is required.
  */
 typedef struct TirtcVideoOutputObserver {
   /**
    * @brief Called when the output state changes.
-   *
-   * A common sequence is IDLE after attach, then BUFFERING, then RENDERING,
-   * and IDLE again after detach or backend removal.
    */
-  void (*on_state_changed)(TirtcVideoOutput* output, TirtcVideoOutputState state, TirtcError error,
-                           void* user_data);
+  void (*on_state_changed)(TirtcVideoOutput* output, TirtcVideoOutputState state, void* user_data);
 
   /**
-   * @brief Reserved callback for output-size updates.
-   *
-   * The current facade implementation exposes this callback in the contract but
-   * does not currently emit it.
+   * @brief Called when the effective rendered output size changes.
    */
   void (*on_output_size_changed)(TirtcVideoOutput* output, uint32_t width, uint32_t height,
                                  void* user_data);
+
+  /**
+   * @brief Called when the output encounters an error.
+   */
+  void (*on_error)(TirtcVideoOutput* output, TirtcError error, const char* message,
+                   void* user_data);
 } TirtcVideoOutputObserver;
 
 /**
@@ -204,73 +193,34 @@ TirtcError tirtc_set_media_trace_enabled(int enabled);
 TirtcError tirtc_get_media_trace_enabled(int* out_enabled);
 
 /**
- * @brief Request an I-frame from the remote sender for a video stream.
- *
- * This is typically used by a receiver after join, decoder recovery, or severe
- * packet loss when waiting for the next natural key frame would be too slow.
- *
- * @param connection Target connection.
- * @param stream_id Video stream identifier.
- * @return ::TIRTC_ERROR_OK on success.
- */
-TirtcError tirtc_conn_request_iframe(TirtcConn* connection, uint8_t stream_id);
-
-/**
- * @brief Attach a local video input to a connection stream.
- *
- * This bind is non-owning. The same input cannot be attached to more than one
- * connection at a time. The selected ::stream_id must be unique across all
- * currently attached input and output streams on the same connection.
- *
- * @param connection Target connection.
- * @param stream_id Stream identifier that will carry this video route.
- * @param input Video input to bind.
- * @return ::TIRTC_ERROR_OK on success.
- */
-TirtcError tirtc_conn_attach_video_input(TirtcConn* connection, uint8_t stream_id,
-                                         TirtcVideoInput* input);
-
-/**
- * @brief Attach a remote video output to a connection stream.
- *
- * The output must not currently be used as a preview target. A video output
- * can be either a preview sink or a remote sink, but never both at the same
- * time.
- *
- * If an observer is already installed, a successful attach typically reports an
- * initial IDLE state before decoded frames begin to render.
- * Attach is a local bind only; it does not send a remote request for this
- * stream.
+ * @brief Request the remote sender to start sending a video stream.
  *
  * @param connection Target connection.
- * @param stream_id Remote video stream identifier to render.
- * @param output Video output to bind.
+ * @param stream_id Remote video stream identifier.
  * @return ::TIRTC_ERROR_OK on success.
  */
-TirtcError tirtc_conn_attach_video_output(TirtcConn* connection, uint8_t stream_id,
-                                          TirtcVideoOutput* output);
+TirtcError tirtc_conn_subscribe_video(TirtcConn* connection, uint8_t stream_id);
 
 /**
- * @brief Detach a video input from a connection stream.
- *
- * This call is idempotent.
+ * @brief Request the remote sender to stop sending a video stream.
  *
  * @param connection Target connection.
- * @param stream_id Stream identifier to detach.
+ * @param stream_id Remote video stream identifier.
  * @return ::TIRTC_ERROR_OK on success.
  */
-TirtcError tirtc_conn_detach_video_input(TirtcConn* connection, uint8_t stream_id);
+TirtcError tirtc_conn_unsubscribe_video(TirtcConn* connection, uint8_t stream_id);
 
 /**
- * @brief Detach a video output from a connection stream.
+ * @brief Request a key frame from the remote sender for a video stream.
  *
- * This call is idempotent.
+ * This is typically used by a receiver after join, decoder recovery, or severe
+ * packet loss when waiting for the next natural key frame would be too slow.
  *
  * @param connection Target connection.
- * @param stream_id Stream identifier to detach.
+ * @param stream_id Video stream identifier.
  * @return ::TIRTC_ERROR_OK on success.
  */
-TirtcError tirtc_conn_detach_video_output(TirtcConn* connection, uint8_t stream_id);
+TirtcError tirtc_conn_request_key_frame(TirtcConn* connection, uint8_t stream_id);
 
 /**
  * @brief Create a video input object.
@@ -282,22 +232,12 @@ TirtcError tirtc_conn_detach_video_output(TirtcConn* connection, uint8_t stream_
  */
 TirtcError tirtc_video_input_create(TirtcVideoInput** out_input);
 
-/**
- * @brief Destroy a video input object.
- *
- * The input must already be detached from any connection. Any preview binding
- * is cleared during destruction.
- *
- * @param input Input handle to destroy.
- */
-void tirtc_video_input_destroy(TirtcVideoInput* input);
-
 /**
  * @brief Bind a concrete video capture backend to an input object.
  *
- * This must be done while the input is stopped and detached, before the next
- * successful start. The backend pointer is non-owning and should remain valid
- * while the input may still use it.
+ * This must be done before the backend is needed by the producer pipeline. The
+ * backend pointer is non-owning and should remain valid while the input may
+ * still use it.
  *
  * @param input Target video input.
  * @param vin Capture backend to bind.
@@ -308,9 +248,9 @@ TirtcError tirtc_video_input_set_vin(TirtcVideoInput* input, TirtcVideoVin* vin)
 /**
  * @brief Store video encoding options.
  *
- * Best practice is to call this before the first successful start. Updating
- * options after the internal uplink pipeline has already been created does not
- * retroactively rebuild that running pipeline.
+ * Best practice is to call this before the next ::tirtc_video_input_start.
+ * Updating options after the internal uplink pipeline has already been created
+ * does not retroactively rebuild that running pipeline.
  *
  * @param input Target video input.
  * @param options Options to copy into the facade object.
@@ -335,101 +275,114 @@ TirtcError tirtc_video_input_set_observer(TirtcVideoInput* input,
                                           const TirtcVideoInputObserver* observer, void* user_data);
 
 /**
- * @brief Bind a preview output to a video input.
+ * @brief Start the local video producer lifecycle.
  *
- * Use this when local camera frames should also be rendered locally, for
- * example in a self-preview view.
+ * This only manages the producer pipeline. It does not create, remove, or
+ * replace any connection binding relationship.
  *
- * The supplied output must already have a non-NULL render backend configured
- * by ::tirtc_video_output_set_vout, and it must not currently be attached to a
- * remote connection stream or owned by another preview input.
- *
- * This preview relationship is non-owning and may be established before or
- * after ::tirtc_video_input_start. Rebinding to a different output
- * automatically releases the previous preview relationship held by this input.
- * When the input is already running, the new preview sink is applied to the
- * live uplink immediately.
+ * Calling start on an already-running input is idempotent.
  *
  * @param input Target video input.
- * @param output Video output to use for preview.
  * @return ::TIRTC_ERROR_OK on success.
  */
-TirtcError tirtc_video_input_set_preview_output(TirtcVideoInput* input, TirtcVideoOutput* output);
+TirtcError tirtc_video_input_start(TirtcVideoInput* input);
 
 /**
- * @brief Clear the preview output currently associated with a video input.
+ * @brief Stop the local video producer lifecycle.
+ *
+ * This stops capture, processing, and encoding for the input but keeps all
+ * existing attach relationships intact. Future ::tirtc_video_input_start calls
+ * may resume the same attach set.
  *
- * This call is idempotent and is the normal pairing call for
- * ::tirtc_video_input_set_preview_output when a preview surface is being
- * released or repurposed for remote display. Clearing the preview relationship
- * does not destroy the output object.
+ * Calling stop on an already-stopped input is idempotent.
  *
  * @param input Target video input.
  * @return ::TIRTC_ERROR_OK on success.
  */
-TirtcError tirtc_video_input_clear_preview_output(TirtcVideoInput* input);
+TirtcError tirtc_video_input_stop(TirtcVideoInput* input);
 
 /**
- * @brief Start local video capture and encoding for an input object.
+ * @brief Attach a video input to a connection stream.
  *
- * A capture backend must already be bound with ::tirtc_video_input_set_vin.
+ * This bind is non-owning. The same input may be attached to multiple
+ * connections at the same time, but only one stream id per connection is kept.
+ * Re-attaching the same input to the same connection replaces the prior stream
+ * id without requiring an explicit detach first.
  *
- * @param input Target video input.
+ * Attach only manages the binding relationship. It does not implicitly start
+ * the producer lifecycle.
+ *
+ * @param input Video input to bind.
+ * @param connection Target connection.
+ * @param stream_id Stream identifier that will carry this video route.
  * @return ::TIRTC_ERROR_OK on success.
  */
-TirtcError tirtc_video_input_start(TirtcVideoInput* input);
+TirtcError tirtc_video_input_attach(TirtcVideoInput* input, TirtcConn* connection,
+                                    uint8_t stream_id);
 
 /**
- * @brief Stop local video capture and encoding for an input object.
+ * @brief Detach a video input from one connection.
  *
- * This is the normal pairing call for ::tirtc_video_input_start. The current
- * implementation also tolerates stopping an already stopped input.
+ * This call is idempotent. It only removes the binding for the specified
+ * connection and does not implicitly stop the input lifecycle.
  *
- * @param input Target video input.
+ * @param input Video input to unbind.
+ * @param connection Connection whose video route should be removed.
  * @return ::TIRTC_ERROR_OK on success.
  */
-TirtcError tirtc_video_input_stop(TirtcVideoInput* input);
+TirtcError tirtc_video_input_detach(TirtcVideoInput* input, TirtcConn* connection);
 
 /**
- * @brief Create a video output object.
+ * @brief Bind a preview output to a video input.
  *
- * The runtime must already be initialized.
+ * Use this when local camera frames should also be rendered locally, for
+ * example in a self-preview view.
  *
- * @param out_output Receives the created output handle on success.
+ * The supplied output must not currently be attached to a remote connection
+ * stream or owned by another preview input. This preview relationship is
+ * non-owning and may be established before or after ::tirtc_video_input_start.
+ * Rebinding to a different output automatically releases the previous preview
+ * relationship held by this input.
+ *
+ * @param input Target video input.
+ * @param preview_output Video output to use for preview.
  * @return ::TIRTC_ERROR_OK on success.
  */
-TirtcError tirtc_video_output_create(TirtcVideoOutput** out_output);
+TirtcError tirtc_video_input_attach_preview(TirtcVideoInput* input,
+                                            TirtcVideoOutput* preview_output);
 
 /**
- * @brief Destroy a video output object.
+ * @brief Clear the preview output currently associated with a video input.
  *
- * The output must already be detached from any connection stream and must not
- * be owned by a preview input. If it is still active, the current
- * implementation keeps it alive and ignores the destroy request.
+ * This call is idempotent. Clearing the preview relationship does not destroy
+ * the output object and does not affect remote connection binds owned by the
+ * input.
  *
- * @param output Output handle to destroy.
+ * @param input Target video input.
+ * @return ::TIRTC_ERROR_OK on success.
  */
-void tirtc_video_output_destroy(TirtcVideoOutput* output);
+TirtcError tirtc_video_input_detach_preview(TirtcVideoInput* input);
 
 /**
- * @brief Bind or clear a concrete video render backend for an output object.
+ * @brief Destroy a video input object.
  *
- * Passing a non-NULL backend is allowed only while the output is inactive.
- * That means it must be neither attached to a remote stream nor serving as a
- * preview output.
+ * Destroy is strong cleanup. The runtime stops the input lifecycle, clears
+ * every connection bind and preview relationship owned by this input, and then
+ * releases the object.
  *
- * Passing NULL clears the current backend. When a remote output is already
- * attached, clearing the backend stops rendering and returns the output to the
- * IDLE state. When the output is currently used for preview, clearing the
- * backend stops the live preview sink but does not clear the preview
- * relationship itself. The output remains owned by that preview binding until
- * ::tirtc_video_input_clear_preview_output is called.
+ * @param input Input handle to destroy.
+ */
+void tirtc_video_input_destroy(TirtcVideoInput* input);
+
+/**
+ * @brief Create a video output object.
  *
- * @param output Target video output.
- * @param vout Render backend to bind, or NULL to clear.
+ * The runtime must already be initialized.
+ *
+ * @param out_output Receives the created output handle on success.
  * @return ::TIRTC_ERROR_OK on success.
  */
-TirtcError tirtc_video_output_set_vout(TirtcVideoOutput* output, TirtcVideoVout* vout);
+TirtcError tirtc_video_output_create(TirtcVideoOutput** out_output);
 
 /**
  * @brief Install, replace, or clear the video output observer.
@@ -447,6 +400,94 @@ TirtcError tirtc_video_output_set_observer(TirtcVideoOutput* output,
                                            const TirtcVideoOutputObserver* observer,
                                            void* user_data);
 
+/**
+ * @brief Attach a local render backend to a video output.
+ *
+ * This establishes the local view/render sink relationship. It is independent
+ * from the remote route relationship managed by ::tirtc_video_output_attach.
+ * Re-attaching replaces the current local view relationship.
+ *
+ * @param output Target video output.
+ * @param view_sink Render backend to bind.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_video_output_attach_view(TirtcVideoOutput* output, TirtcVideoVout* view_sink);
+
+/**
+ * @brief Detach the local render backend from a video output.
+ *
+ * This call is idempotent and does not implicitly detach the current remote
+ * route.
+ *
+ * @param output Target video output.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_video_output_detach_view(TirtcVideoOutput* output);
+
+/**
+ * @brief Attach a video output to a remote connection stream.
+ *
+ * This bind is non-owning. The same output can consume only one remote route at
+ * a time. Re-attaching replaces the prior route without requiring an explicit
+ * detach first.
+ *
+ * Attach only manages the remote consume route. It does not change local view
+ * ownership.
+ *
+ * @param output Video output to bind.
+ * @param connection Target connection.
+ * @param stream_id Remote video stream identifier to render.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_video_output_attach(TirtcVideoOutput* output, TirtcConn* connection,
+                                     uint8_t stream_id);
+
+/**
+ * @brief Detach the current remote route from a video output.
+ *
+ * This call is idempotent. Detach only stops consuming the current remote
+ * route. It does not clear the current local view relationship.
+ *
+ * @param output Target video output.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_video_output_detach(TirtcVideoOutput* output);
+
+/**
+ * @brief Destroy a video output object.
+ *
+ * Destroy is strong cleanup. The runtime detaches the current remote route,
+ * clears the local view relationship, clears observer state, and releases
+ * internal render pipeline state before the object is destroyed.
+ *
+ * @param output Output handle to destroy.
+ */
+void tirtc_video_output_destroy(TirtcVideoOutput* output);
+
+/**
+ * @brief Start encoded raw dump for the media downlink currently owned by this output.
+ *
+ * The output must already be attached to a connection stream and have an active
+ * media downlink. The runtime records received encoded payload into the fixed
+ * logging-owned media raw dump directory and derives the dump prefix from the
+ * bound route as `<peer_id>-<stream_id>`.
+ *
+ * @param output Target video output.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_video_output_start_raw_dump(TirtcVideoOutput* output);
+
+/**
+ * @brief Stop encoded raw dump for the media downlink currently owned by this output.
+ *
+ * This call is idempotent. Stopping seals the current dump directory and keeps
+ * collected raw data on disk.
+ *
+ * @param output Target video output.
+ * @return ::TIRTC_ERROR_OK on success.
+ */
+TirtcError tirtc_video_output_stop_raw_dump(TirtcVideoOutput* output);
+
 #ifdef __cplusplus
 }
 #endif

package/vendor/app-server/bin/runtime/macos-arm64/include/tirtc/error.h

@@ -22,6 +22,8 @@ typedef enum TirtcError {
   TIRTC_ERROR_TRANSPORT_REMOTE_CLOSED = 13,
   TIRTC_ERROR_TRANSPORT_CONNECTION_OTHER_ERROR = 14,
   TIRTC_ERROR_TRANSPORT_TOKEN_EXPIRED = 15,
+  TIRTC_ERROR_DUMP_ROOT_UNAVAILABLE = 16,
+  TIRTC_ERROR_DUMP_ALREADY_ACTIVE = 17,
 } TirtcError;
 
 #ifdef __cplusplus

package/vendor/app-server/bin/runtime/macos-arm64/include/tirtc/media_downlink.h

@@ -62,6 +62,9 @@ TirtcError tirtc_media_downlink_audio_get_current_pts(TirtcMediaDownlinkAudio* d
                                                       int64_t* out_pts_us);
 TirtcError tirtc_media_downlink_audio_start(TirtcMediaDownlinkAudio* downlink);
 TirtcError tirtc_media_downlink_audio_stop(TirtcMediaDownlinkAudio* downlink);
+TirtcError tirtc_media_downlink_audio_start_raw_dump(TirtcMediaDownlinkAudio* downlink,
+                                                     const char* prefix);
+TirtcError tirtc_media_downlink_audio_stop_raw_dump(TirtcMediaDownlinkAudio* downlink);
 
 TirtcError tirtc_media_downlink_video_create(TirtcMediaDownlinkVideo** out_downlink);
 void tirtc_media_downlink_video_retain(TirtcMediaDownlinkVideo* downlink);
@@ -87,6 +90,9 @@ TirtcError tirtc_media_downlink_video_follow_video(TirtcMediaDownlinkVideo* foll
 TirtcError tirtc_media_downlink_video_use_self_timing(TirtcMediaDownlinkVideo* downlink);
 TirtcError tirtc_media_downlink_video_start(TirtcMediaDownlinkVideo* downlink);
 TirtcError tirtc_media_downlink_video_stop(TirtcMediaDownlinkVideo* downlink);
+TirtcError tirtc_media_downlink_video_start_raw_dump(TirtcMediaDownlinkVideo* downlink,
+                                                     const char* prefix);
+TirtcError tirtc_media_downlink_video_stop_raw_dump(TirtcMediaDownlinkVideo* downlink);
 
 #ifdef __cplusplus
 }