Untitled

package main

import (
    "bufio"
    "fmt"
    "os"
    "time"

    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/credentials"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/kinesisvideo"
    "github.com/aws/aws-sdk-go/service/kinesisvideomedia"
)

const (
    streamName  = "your_stream_name"
    awsRegion   = "your_region" // e.g., "us-west-2"
    accessKeyID = "your_access_key"
    secretKey   = "your_secret_key"
)

func main() {
    sess, err := session.NewSession(&aws.Config{
        Region:      aws.String(awsRegion),
        Credentials: credentials.NewStaticCredentials(accessKeyID, secretKey, ""),
    })
    if err != nil {
        fmt.Println("Error creating session:", err)
        return
    }

    kvsClient := kinesisvideo.New(sess)
    endpointResp, err := kvsClient.GetDataEndpoint(&kinesisvideo.GetDataEndpointInput{
        StreamName: aws.String(streamName),
        APIName:    aws.String("PUT_MEDIA"),
    })
    if err != nil {
        fmt.Println("Error getting data endpoint:", err)
        return
    }

    endpoint := *endpointResp.DataEndpoint
    kvsMediaClient := kinesisvideomedia.New(sess, aws.NewConfig().WithEndpoint(endpoint))

    filePath := "path/to/your/h264/file.h264"
    file, err := os.Open(filePath)
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close()

    reader := bufio.NewReader(file)

    // Set up media input parameters
    mediaInput := &kinesisvideomedia.PutMediaInput{
        StreamName:   aws.String(streamName),
        ContentType:  aws.String("video/h264"),
        FragmentTimecodeType: aws.String("PRODUCER_TIMESTAMP"),
        ProducerStartTimestamp: aws.Time(time.Now()),
    }

    // Open a stream to put media
    stream, err := kvsMediaClient.PutMediaRequest(mediaInput).Send()
    if err != nil {
        fmt.Println("Error starting media stream:", err)
        return
    }

    // Read and send frames
    for {
        frame, err := reader.ReadBytes(0) // Adjust the frame delimiter based on your H.264 format
        if err != nil {
            fmt.Println("Error reading frame:", err)
            break
        }

        _, err = stream.Payload.Write(frame)
        if err != nil {
            fmt.Println("Error writing frame to stream:", err)
            break
        }

        // Simulate frame timing
        time.Sleep(33 * time.Millisecond) // Assuming 30 FPS
    }

    err = stream.Payload.Close()
    if err != nil {
        fmt.Println("Error closing stream:", err)
    }

    fmt.Println("Successfully streamed H.264 data to Kinesis Video Streams")
}