### Dynamic YAML Configuration with Templating

Source: https://context7.com/xaionaro-go/avd/llms.txt

Example of a YAML configuration file utilizing Go template syntax to inject environment variables. This allows for flexible deployment across different environments.

```yaml
# ~/.avd.conf
ports_service:
- address: tcp:0.0.0.0:1722
  service:
    management:
      protocol: "grpc"

ports_streaming:
# Use environment variables with fallback defaults
- address: tcp:0.0.0.0:{{ firstNonEmpty .env.AVD_PORT_PUBLISHERS "1936" }}
  mode: "publishers"
  protocol_handler:
    rtmp: {}
  custom_options:
  - key: "probesize"
    value: 32768
  - key: "analyzeduration"
    value: 200000

- address: tcp:0.0.0.0:{{ firstNonEmpty .env.AVD_PORT_CONSUMERS "1935" }}
  mode: "consumers"
  protocol_handler:
    rtmp: {}
  wait_until:
    video_track_count: 1
    audio_track_count: 1

endpoints:
  livestream:
    on_publisher_added:
      command: ["echo", "Publisher connected"]
      restart: never
    on_publisher_removed:
      command: ["echo", "Publisher disconnected"]
    forwardings:
    - destination:
        url: "rtmp://backup-server:1935/backup"
      transcoding:
        output:
          video_track_configs:
          - input_track_ids: [0,1,2,3,4,5,6,7]
            output_track_ids: [0]
            codec_name: copy
          audio_track_configs:
          - input_track_ids: [0,1,2,3,4,5,6,7]
            output_track_ids: [1]
            codec_name: copy
```

--------------------------------

### Run AVD Daemon (Bash)

Source: https://context7.com/xaionaro-go/avd/llms.txt

These commands demonstrate how to run the AVD streaming server daemon. It covers generating a default configuration file, starting the daemon with default or custom configurations, enabling debug logging, and activating network profiling. The `avd` command is the primary executable for starting the server.

```bash
# Generate default configuration
avd --generate-config > ~/.avd.conf

# Start the daemon with default config paths
avd

# Start with custom config path
avd --config-path /etc/avd/custom.conf

# Start with debug logging
avd --log-level debug

# Start with profiling enabled
avd --go-net-pprof-addr localhost:6060
```

--------------------------------

### Querying Supported Protocols in Go

Source: https://context7.com/xaionaro-go/avd/llms.txt

Example of how to programmatically list supported streaming protocols using the AVD Go package. This allows developers to verify available formats like RTMP, RTSP, and SRT.

```go
package main

import (
    "fmt"
    "github.com/xaionaro-go/avd/pkg/avd"
)

func main() {
    // List supported protocols
    protocols := avd.SupportedProtocols()
    for _, p := range protocols {
        fmt.Printf("Protocol: %s (format: %s)\n", p.String(), p.FormatName())
    }
}
```

--------------------------------

### Run AVD Daemon with Default Configuration

Source: https://github.com/xaionaro-go/avd/blob/main/README.md

Starts the AVD daemon using the default configuration file. This command assumes a configuration file (e.g., ~/.avd.conf) is present and correctly set up.

```shell
$ avd
```

--------------------------------

### Server.Listen - Start Listening on a Port

Source: https://context7.com/xaionaro-go/avd/llms.txt

Starts listening on a specified address with a given protocol and port mode (publishers or consumers). This is the primary method for accepting incoming streams or serving streams to viewers.

```APIDOC
## Server.Listen

### Description
Starts listening on a specified address with a given protocol and port mode (publishers or consumers). This is the primary method for accepting incoming streams or serving streams to viewers.

### Method
`Listen`

### Endpoint
N/A (Method on server instance)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **ctx** (context.Context) - The context for the operation.
- **address** (string) - The address to listen on, in the format "protocol:host:port" (e.g., "tcp:127.0.0.1:1936").
- **protocol** (avd.Protocol) - The streaming protocol to use (e.g., `avd.ProtocolRTMP`).
- **portMode** (avd.PortMode) - Specifies whether the port is for publishers (`avd.PortModePublishers`) or consumers (`avd.PortModeConsumers`).

### Request Example
```go
package main

import (
    "context"
    "fmt"
    "log"

    "github.com/xaionaro-go/avd/pkg/avd"
)

func main() {
    ctx := context.Background()
    srv := avd.NewServer(ctx)
    defer srv.Close(ctx)

    // Listen for RTMP publishers on localhost:1936
    publishersPort, err := srv.Listen(
        ctx,
        "tcp:127.0.0.1:1936",    // Address in format "protocol:host:port"
        avd.ProtocolRTMP,         // Streaming protocol
        avd.PortModePublishers,   // Accept incoming streams
    )
    if err != nil {
        log.Fatalf("Failed to listen for publishers: %v", err)
    }
    fmt.Printf("Publishers listening on: %s\n", publishersPort)

    // Listen for RTMP consumers on all interfaces:1935
    consumersPort, err := srv.Listen(
        ctx,
        "tcp:0.0.0.0:1935",
        avd.ProtocolRTMP,
        avd.PortModeConsumers,    // Serve streams to viewers
    )
    if err != nil {
        log.Fatalf("Failed to listen for consumers: %v", err)
    }
    fmt.Printf("Consumers listening on: %s\n", consumersPort)

    srv.Wait(ctx)
}
```

### Response
#### Success Response (200)
- **string** (string) - The actual address the server is listening on.

#### Response Example
```
Publishers listening on: tcp://127.0.0.1:1936
Consumers listening on: tcp://0.0.0.0:1935
```
```

--------------------------------

### Manage AVD Server with CLI (Bash)

Source: https://context7.com/xaionaro-go/avd/llms.txt

The `avcli` command-line tool provides administrative access to a running AVD server. These examples show how to list publishers, consumers, and routes, as well as monitor specific nodes in real-time. Options include specifying the remote server address, monitoring directions (send/receive), output formatting (JSON), and including packet payloads.

```bash
# List all active publishers
avcli --remote-addr localhost:1722 publishers list

# List all active consumers
avcli --remote-addr localhost:1722 consumers list

# List all configured routes
avcli --remote-addr localhost:1722 routes list

# Monitor a specific node in real-time
avcli --remote-addr localhost:1722 monitor 12345 send

# Monitor with JSON output
avcli --remote-addr localhost:1722 monitor 12345 receive --format json

# Monitor with packet payloads
avcli --remote-addr localhost:1722 monitor 12345 send --include-packet-payload
```

--------------------------------

### Start Listening on a Port for RTMP Streams

Source: https://context7.com/xaionaro-go/avd/llms.txt

Configures the AVD server to listen for incoming RTMP streams (publishers) or to serve RTMP streams to viewers (consumers) on a specified address and port. It supports different port modes and requires a context, address, protocol, and port mode.

```go
package main

import (
    "context"
    "fmt"
    "log"

    "github.com/xaionaro-go/avd/pkg/avd"
)

func main() {
    ctx := context.Background()
    srv := avd.NewServer(ctx)
    defer srv.Close(ctx)

    // Listen for RTMP publishers on localhost:1936
    publishersPort, err := srv.Listen(
        ctx,
        "tcp:127.0.0.1:1936",    // Address in format "protocol:host:port"
        avd.ProtocolRTMP,         // Streaming protocol
        avd.PortModePublishers,   // Accept incoming streams
    )
    if err != nil {
        log.Fatalf("Failed to listen for publishers: %v", err)
    }
    fmt.Printf("Publishers listening on: %s\n", publishersPort)

    // Listen for RTMP consumers on all interfaces:1935
    consumersPort, err := srv.Listen(
        ctx,
        "tcp:0.0.0.0:1935",
        avd.ProtocolRTMP,
        avd.PortModeConsumers,    // Serve streams to viewers
    )
    if err != nil {
        log.Fatalf("Failed to listen for consumers: %v", err)
    }
    fmt.Printf("Consumers listening on: %s\n", consumersPort)

    srv.Wait(ctx)
}
```

--------------------------------

### Apply Configuration to Server in Go

Source: https://context7.com/xaionaro-go/avd/llms.txt

Shows the process of reading a configuration file from disk and applying it to an avd server instance. It includes logic to fallback to default settings if the configuration file is missing.

```go
package main

import (
    "context"
    "log"

    "github.com/xaionaro-go/avd/pkg/avd"
    "github.com/xaionaro-go/avd/pkg/config"
    "github.com/xaionaro-go/avd/pkg/configapplier"
    "github.com/xaionaro-go/avd/pkg/configfile"
)

func main() {
    ctx := context.Background()

    // Read configuration from file
    var cfg config.Config
    exists, err := configfile.Read(ctx, "~/.avd.conf", &cfg, nil)
    if err != nil {
        log.Fatalf("Failed to read config: %v", err)
    }
    if !exists {
        // Use default configuration if file doesn't exist
        cfg = config.Default()
    }

    // Create server and apply configuration
    srv := avd.NewServer(ctx)
    err = configapplier.ApplyConfig(ctx, cfg, srv)
    if err != nil {
        log.Fatalf("Failed to apply config: %v", err)
    }

    log.Println("Server started...")
    srv.Wait(ctx)
}
```

--------------------------------

### Create New AVD Server Instance

Source: https://context7.com/xaionaro-go/avd/llms.txt

Initializes a new AVD server instance with an internal router. This is the foundational step for setting up the streaming server. It requires a context and returns a server instance that should be closed when no longer needed.

```go
package main

import (
    "context"
    "log"

    "github.com/xaionaro-go/avd/pkg/avd"
)

func main() {
    ctx := context.Background()

    // Create a new server instance
    srv := avd.NewServer(ctx)

    // Server is now ready to accept listeners
    // Don't forget to close when done
    defer srv.Close(ctx)

    // Wait for the server to finish
    err := srv.Wait(ctx)
    if err != nil {
        log.Printf("Server exited with error: %v", err)
    }
}
```

--------------------------------

### Generate Default Configuration in Go

Source: https://context7.com/xaionaro-go/avd/llms.txt

Demonstrates how to initialize a default avd configuration structure and output it as YAML. This is useful for bootstrapping new server instances with standard protocol settings.

```go
package main

import (
    "os"

    "github.com/xaionaro-go/avd/pkg/config"
)

func main() {
    // Generate default configuration
    cfg := config.Default()

    // Write configuration to stdout in YAML format
    cfg.WriteTo(os.Stdout)
}
```

--------------------------------

### Connect to AVD Management Service (Go)

Source: https://context7.com/xaionaro-go/avd/llms.txt

This Go program demonstrates how to connect to the AVD management service using gRPC. It retrieves and prints lists of active publishers, consumers, and routes. Error handling is included for connection and data retrieval operations. The `client.New` function establishes the connection, and `defer avdClient.Close()` ensures the connection is closed upon function exit.

```go
package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "os"

    "github.com/xaionaro-go/avd/pkg/management/grpc/client"
)

func main() {
    ctx := context.Background()

    // Connect to the AVD management service
    avdClient, err := client.New(ctx, "localhost:1722")
    if err != nil {
        log.Fatalf("Failed to connect: %v", err)
    }
    defer avdClient.Close()

    // List all active publishers
    publishers, err := avdClient.ListPublishers(ctx)
    if err != nil {
        log.Fatalf("Failed to list publishers: %v", err)
    }
    fmt.Println("=== Publishers ===")
    json.NewEncoder(os.Stdout).Encode(publishers)

    // List all active consumers
    consumers, err := avdClient.ListConsumers(ctx)
    if err != nil {
        log.Fatalf("Failed to list consumers: %v", err)
    }
    fmt.Println("\n=== Consumers ===")
    json.NewEncoder(os.Stdout).Encode(consumers)

    // List all routes
    routes, err := avdClient.ListRoutes(ctx)
    if err != nil {
        log.Fatalf("Failed to list routes: %v", err)
    }
    fmt.Println("\n=== Routes ===")
    json.NewEncoder(os.Stdout).Encode(routes)
}
```

--------------------------------

### Create and Listen with AVD RTMP Server (Go)

Source: https://github.com/xaionaro-go/avd/blob/main/README.md

Demonstrates how to create a new AVD server instance in Go and configure it to listen for RTMP publishers on tcp:127.0.0.1:1936 and RTMP consumers on tcp:0.0.0.0:1935. This code snippet sets up the basic RTMP server functionality.

```go
import (
	"context"
	"fmt"

	"github.com/xaionaro-go/avd/pkg/avd"
)

func serveRTMP(ctx context.Context) error {
	srv := avd.NewServer()

	_, err = srv.Listen(ctx, "tcp:127.0.0.1:1936", avd.ProtocolRTMP, avd.RTMPModePublishers)
	if err != nil {
		return fmt.Errorf("unable to listen %s with the RTMP-publishers handler: %w", publishersListener.Addr(), err)
	}

	_, err = srv.Listen(ctx, "tcp:0.0.0.0:1935", avd.ProtocolRTMP, avd.RTMPModeConsumers)
	if err != nil {
		return fmt.Errorf("unable to listen %s with the RTMP-consumers handler: %w", consumersListener.Addr(), err)
	}

	srv.Wait(ctx)
	return nil
}
```

--------------------------------

### Server.Listen with Options - Advanced Listening Configuration

Source: https://context7.com/xaionaro-go/avd/llms.txt

Provides fine-grained control over listening behavior including on-end actions, publish modes, route paths, and protocol-specific settings.

```APIDOC
## Server.Listen with Options

### Description
Provides fine-grained control over listening behavior including on-end actions, publish modes, route paths, and protocol-specific settings.

### Method
`Listen`

### Endpoint
N/A (Method on server instance)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **ctx** (context.Context) - The context for the operation.
- **address** (string) - The address to listen on, in the format "protocol:host:port" (e.g., "tcp:0.0.0.0:1937").
- **protocol** (avd.Protocol) - The streaming protocol to use (e.g., `avd.ProtocolRTMP`).
- **portMode** (avd.PortMode) - Specifies whether the port is for publishers (`avd.PortModePublishers`) or consumers (`avd.PortModeConsumers`).
- **options** ([]types.ListenOption) - A variadic list of options to configure the listener.
  - `types.ListenOptionOnEndAction(types.OnEndAction)`: Specifies the action to take when a publisher disconnects (e.g., `types.OnEndActionWaitForNewPublisher`).
  - `types.ListenOptionDefaultRoutePath(string)`: Sets a default route path for streams on this listener.
  - `types.ListenOptionCustomOptions(types.DictionaryItems)`: Provides custom libav options as a slice of key-value pairs.

### Request Example
```go
package main

import (
    "context"
    "log"

    "github.com/xaionaro-go/avd/pkg/avd"
    "github.com/xaionaro-go/avd/pkg/avd/types"
)

func main() {
    ctx := context.Background()
    srv := avd.NewServer(ctx)
    defer srv.Close(ctx)

    // Listen with advanced options
    _, err := srv.Listen(
        ctx,
        "tcp:0.0.0.0:1937",
        avd.ProtocolRTMP,
        avd.PortModeConsumers,
        // Keep consumers connected when publisher disconnects
        types.ListenOptionOnEndAction(types.OnEndActionWaitForNewPublisher),
        // Set default route path for streams
        types.ListenOptionDefaultRoutePath("mystream"),
        // Custom libav options
        types.ListenOptionCustomOptions(types.DictionaryItems{
            {Key: "probesize", Value: "32768"},
            {Key: "analyzeduration", Value: "200000"},
        }),
    )
    if err != nil {
        log.Fatalf("Failed to listen: %v", err)
    }

    // Listen for RTSP publishers with TCP transport
    _, err = srv.Listen(
        ctx,
        "tcp:127.0.0.1:8555",
        avd.ProtocolRTSP,
        avd.PortModePublishers,
    )
    if err != nil {
        log.Fatalf("Failed to listen for RTSP: %v", err)
    }

    // Listen for MPEG-TS over UDP
    _, err = srv.Listen(
        ctx,
        "udp:127.0.0.1:4445",
        avd.ProtocolMPEGTSUDP,
        avd.PortModePublishers,
        types.ListenOptionDefaultRoutePath("udpstream"),
    )
    if err != nil {
        log.Fatalf("Failed to listen for MPEG-TS: %v", err)
    }

    srv.Wait(ctx)
}
```

### Response
#### Success Response (200)
- **string** (string) - The actual address the server is listening on.

#### Response Example
```
(No direct output for this example, but the server will be configured as specified)
```
```

--------------------------------

### Advanced Server Listening Configuration

Source: https://context7.com/xaionaro-go/avd/llms.txt

Enables advanced configuration for AVD server listeners, including setting on-end actions, default route paths, custom libav options, and supporting various protocols like RTMP, RTSP, and MPEG-TS over UDP. This provides fine-grained control over stream handling.

```go
package main

import (
    "context"
    "log"

    "github.com/xaionaro-go/avd/pkg/avd"
    "github.com/xaionaro-go/avd/pkg/avd/types"
)

func main() {
    ctx := context.Background()
    srv := avd.NewServer(ctx)
    defer srv.Close(ctx)

    // Listen with advanced options
    _, err := srv.Listen(
        ctx,
        "tcp:0.0.0.0:1937",
        avd.ProtocolRTMP,
        avd.PortModeConsumers,
        // Keep consumers connected when publisher disconnects
        types.ListenOptionOnEndAction(types.OnEndActionWaitForNewPublisher),
        // Set default route path for streams
        types.ListenOptionDefaultRoutePath("mystream"),
        // Custom libav options
        types.ListenOptionCustomOptions(types.DictionaryItems{
            {Key: "probesize", Value: "32768"},
            {Key: "analyzeduration", Value: "200000"},
        }),
    )
    if err != nil {
        log.Fatalf("Failed to listen: %v", err)
    }

    // Listen for RTSP publishers with TCP transport
    _, err = srv.Listen(
        ctx,
        "tcp:127.0.0.1:8555",
        avd.ProtocolRTSP,
        avd.PortModePublishers,
    )
    if err != nil {
        log.Fatalf("Failed to listen for RTSP: %v", err)
    }

    // Listen for MPEG-TS over UDP
    _, err = srv.Listen(
        ctx,
        "udp:127.0.0.1:4445",
        avd.ProtocolMPEGTSUDP,
        avd.PortModePublishers,
        types.ListenOptionDefaultRoutePath("udpstream"),
    )
    if err != nil {
        log.Fatalf("Failed to listen for MPEG-TS: %v", err)
    }

    srv.Wait(ctx)
}
```

--------------------------------

### Monitor AVD Streams in Real-time (Go)

Source: https://context7.com/xaionaro-go/avd/llms.txt

This Go program subscribes to real-time stream events from a specific AVD node using the gRPC management API. It allows for debugging and analysis by capturing events like packet transmissions. The `avdClient.Monitor` function initiates the monitoring, and the subsequent loop processes incoming events, printing details such as PTS, DTS, and data size for each packet. Dependencies include the `client` package from `github.com/xaionaro-go/avd` and `avpipeline_proto` from `github.com/xaionaro-go/avpipeline`.

```go
package main

import (
    "context"
    "fmt"
    "log"

    "github.com/xaionaro-go/avd/pkg/management/grpc/client"
    avpipeline_proto "github.com/xaionaro-go/avpipeline/protobuf/avpipeline"
)

func main() {
    ctx := context.Background()

    avdClient, err := client.New(ctx, "localhost:1722")
    if err != nil {
        log.Fatalf("Failed to connect: %v", err)
    }
    defer avdClient.Close()

    // Monitor a specific node (nodeID obtained from ListPublishers/ListConsumers)
    nodeID := uint64(12345)

    eventsCh, err := avdClient.Monitor(
        ctx,
        nodeID,
        avpipeline_proto.MonitorEventType_EVENT_TYPE_SEND,
        false,  // includePacketPayload
        false,  // includeFramePayload
        false,  // doDecode
    )
    if err != nil {
        log.Fatalf("Failed to start monitoring: %v", err)
    }

    fmt.Println("Monitoring stream events...")
    for event := range eventsCh {
        if event.Packet != nil {
            fmt.Printf("Stream %d: PTS=%d DTS=%d Size=%d\n",
                event.Stream.Index,
                event.Packet.Pts,
                event.Packet.Dts,
                event.Packet.DataSize,
            )
        }
    }
}
```

--------------------------------

### NewServer - Create a New Streaming Server

Source: https://context7.com/xaionaro-go/avd/llms.txt

Creates and initializes a new AVD server instance with an internal router for managing stream routes. The server handles multiple listening ports, connections, and stream forwarding.

```APIDOC
## NewServer

### Description
Creates and initializes a new AVD server instance with an internal router for managing stream routes. The server handles multiple listening ports, connections, and stream forwarding.

### Method
`NewServer`

### Endpoint
N/A (Constructor function)

### Parameters
None

### Request Example
```go
package main

import (
    "context"
    "log"

    "github.com/xaionaro-go/avd/pkg/avd"
)

func main() {
    ctx := context.Background()

    // Create a new server instance
    srv := avd.NewServer(ctx)

    // Server is now ready to accept listeners
    // Don't forget to close when done
    defer srv.Close(ctx)

    // Wait for the server to finish
    err := srv.Wait(ctx)
    if err != nil {
        log.Printf("Server exited with error: %v", err)
    }
}
```

### Response
#### Success Response (200)
N/A (Returns a server instance)

#### Response Example
N/A
```

--------------------------------

### Publishing Streams with FFmpeg

Source: https://context7.com/xaionaro-go/avd/llms.txt

Commands to publish video files, webcam input, or screen captures as RTMP streams using FFmpeg. These commands utilize various input formats and encoding presets to stream to an AVD server.

```bash
# Publish a video file as RTMP stream
ffmpeg -re -i /path/to/video.mp4 -c copy -f flv rtmp://127.0.0.1:1936/mystream

# Publish webcam with encoding
ffmpeg -f v4l2 -i /dev/video0 -f alsa -i default \
    -c:v libx264 -preset ultrafast -tune zerolatency \
    -c:a aac -b:a 128k \
    -f flv rtmp://127.0.0.1:1936/webcam

# Publish screen capture
ffmpeg -f x11grab -video_size 1920x1080 -i :0.0 \
    -c:v libx264 -preset ultrafast \
    -f flv rtmp://127.0.0.1:1936/screencast
```

--------------------------------

### Hardware-Accelerated Stream Transcoding Configuration

Source: https://context7.com/xaionaro-go/avd/llms.txt

Configures stream forwarding between local routes with NVIDIA hardware-accelerated transcoding. Defines specific codecs and performance tuning options for high-efficiency processing.

```yaml
# Configuration for hardware-accelerated transcoding
endpoints:
  input-stream:
    forwardings:
    - destination:
        local:
          route: output-stream
          publish_mode: shared-takeover
      transcoding:
        input:
          video_track_configs:
          - codec_name: h264_cuvid    # NVIDIA hardware decoder
            resolution:
              width: 1920
              height: 1080
        output:
          video_track_configs:
          - input_track_ids: [0,1,2,3,4,5,6,7]
            output_track_ids: [0]
            codec_name: h264_nvenc    # NVIDIA hardware encoder
            average_bit_rate: 8000000
            resolution:
              width: 1920
              height: 1080
            custom_options:
            - key: "gpu"
              value: 0
            - key: "zerolatency"
              value: "1"
            - key: "tune"
              value: "ll"
            - key: "rc"
              value: "cbr_ld_hq"
          audio_track_configs:
          - input_track_ids: [0,1,2,3,4,5,6,7]
            output_track_ids: [1]
            codec_name: aac
            average_bit_rate: 192000
```

--------------------------------

### Configure Remote Destination Forwarding (YAML)

Source: https://context7.com/xaionaro-go/avd/llms.txt

This configuration defines how to forward streams to remote RTMP/RTSP servers. It includes settings for primary stream destinations like YouTube Live and Twitch, with options for video and audio track transcoding. The `codec_name: copy` indicates that streams are forwarded without re-encoding.

```yaml
endpoints:
  primary-stream:
    forwardings:
    # Forward to YouTube Live
    - destination:
        url: "rtmp://a.rtmp.youtube.com/live2/your-stream-key"
      transcoding:
        output:
          video_track_configs:
          - input_track_ids: [0]
            output_track_ids: [0]
            codec_name: copy
          audio_track_configs:
          - input_track_ids: [0]
            output_track_ids: [1]
            codec_name: copy

    # Forward to Twitch
    - destination:
        url: "rtmp://live.twitch.tv/app/your-stream-key"
      transcoding:
        output:
          video_track_configs:
          - input_track_ids: [0]
            output_track_ids: [0]
            codec_name: copy
          audio_track_configs:
          - input_track_ids: [0]
            output_track_ids: [1]
            codec_name: copy
```

--------------------------------

### Consuming and Transcoding Streams

Source: https://context7.com/xaionaro-go/avd/llms.txt

Methods for consuming RTMP streams using ffplay or saving/transcoding them to files using FFmpeg. These operations allow for real-time playback or offline processing of AVD-hosted streams.

```bash
# Play stream with ffplay
ffplay -f flv -listen 1 rtmp://127.0.0.1:1399/mystream

# Or connect to AVD's consumer port
ffplay rtmp://127.0.0.1:1935/mystream

# Save stream to file
ffmpeg -i rtmp://127.0.0.1:1935/mystream -c copy output.mp4

# Transcode while consuming
ffmpeg -i rtmp://127.0.0.1:1935/mystream \
    -c:v libx264 -preset fast -crf 23 \
    -c:a aac -b:a 128k \
    output_transcoded.mp4
```

--------------------------------

### Generate AVD Configuration

Source: https://github.com/xaionaro-go/avd/blob/main/README.md

Generates a default AVD configuration file and saves it to ~/.avd.conf. This configuration sets up various ports for RTMP, RTSP, and MPEG-TS protocols, defining modes for publishers and consumers, and specifying stream forwarding rules.

```shell
$ avd --generate-config | tee ~/.avd.conf
```

--------------------------------

### Configure AVD for RTMP Streaming

Source: https://github.com/xaionaro-go/avd/blob/main/README.md

Modifies the AVD configuration to set up an RTMP publisher on localhost:1936 and forward the 'mystream' endpoint to rtmp://127.0.0.1:1399/test-stream. This configuration is intended for testing stream forwarding.

```yaml
ports:
- address: tcp:127.0.0.1:1936
  rtmp:
    mode: "publishers"
endpoints:
  mystream:
    forwardings:
    - destination:
        url: "rtmp://127.0.0.1:1399/test-stream"
```

--------------------------------

### Play RTMP Stream with ffplay

Source: https://github.com/xaionaro-go/avd/blob/main/README.md

Uses ffplay to listen for an RTMP stream on rtmp://127.0.0.1:1399/test-stream. This command is used to receive and play the stream forwarded by AVD.

```shell
$ ffplay -f flv -listen 1 rtmp://127.0.0.1:1399/test-stream
```

--------------------------------

### Send RTMP Stream with ffmpeg

Source: https://github.com/xaionaro-go/avd/blob/main/README.md

Uses ffmpeg to send a local FLV file (/tmp/1.flv) as an RTMP stream to AVD's publisher port (rtmp://127.0.0.1:1936/mystream). This action triggers the stream forwarding configured in AVD.

```shell
$ ffmpeg -re -i /tmp/1.flv -c copy -f flv rtmp://127.0.0.1:1936/mystream
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.