Publishing pre-encoded video

use livekit::options::{TrackPublishOptions, VideoCodec, VideoEncoderBackend};
use livekit::prelude::*;
use livekit::webrtc::{
  video_frame::{EncodedFrameType, EncodedVideoCodec, EncodedVideoFrame},
  video_source::{native::NativeVideoSource, RtcVideoSource, VideoResolution}
};

const WIDTH: u32 = 1920;
const HEIGHT: u32 = 1080;

let resolution = VideoResolution { width: WIDTH, height: HEIGHT };
let source = NativeVideoSource::new_encoded(resolution.clone());
let track = LocalVideoTrack::create_video_track(
    "camera",
    RtcVideoSource::Native(source.clone()),
);

let options = TrackPublishOptions {
    video_codec: VideoCodec::H264,
    video_encoder: VideoEncoderBackend::PreEncoded,
    simulcast: false,
    source: TrackSource::Camera,
    ..Default::default()
};

room.local_participant()
    .publish_track(LocalTrack::Video(track), options)
    .await?;

loop {
    // Read one complete access unit from your encoder.
    let (payload, timestamp_us, is_keyframe) = next_access_unit()?;
    let frame = EncodedVideoFrame {
        codec: EncodedVideoCodec::H264,
        payload: &payload,
        timestamp_us,
        frame_type: if is_keyframe {
            EncodedFrameType::Key
        } else {
            EncodedFrameType::Delta
        },
        resolution: resolution.clone(),
        frame_metadata: None,
    };

    if !source.capture_encoded_frame(&frame) {
        // The source did not accept this frame.
        continue;
    }

    if source.take_keyframe_request() {
        // Ask your encoder to produce a key frame.
    }
    if let Some(target) = source.take_rate_control_request() {
        // Update your encoder with target.target_bitrate_bps
        // and target.framerate_fps.
    }
}

#include "livekit/encoded_video_source.h"
#include "livekit/livekit.h"

#include <memory>
#include <utility>

constexpr int kWidth = 1920;
constexpr int kHeight = 1080;

auto source = std::make_shared<livekit::EncodedVideoSource>(
    livekit::VideoCodec::H264, kWidth, kHeight);

auto local_participant = room->localParticipant().lock();
if (!local_participant) {
  return;
}

// This helper selects the pre-encoded backend, matches the source codec,
// and disables simulcast.
auto track = local_participant->publishVideoTrack(
    "camera", source, livekit::TrackSource::SOURCE_CAMERA);

while (true) {
  // Read one complete access unit from your encoder.
  auto access_unit = nextAccessUnit();

  livekit::EncodedVideoSource::Frame frame;
  frame.data = std::move(access_unit.data);
  frame.is_keyframe = access_unit.is_keyframe;
  frame.timestamp_us = access_unit.timestamp_us;

  if (!source->captureFrame(frame)) {
    // The source did not accept this frame.
    continue;
  }

  const auto feedback = source->takeFeedback();
  if (feedback.keyframe_requested) {
    // Ask your encoder to produce a key frame.
  }
  if (feedback.rate_control) {
    // Update your encoder with target_bitrate_bps and framerate_fps.
  }
}

import (
	"time"

	"github.com/pion/rtcp"
	"github.com/pion/webrtc/v4"
	"github.com/pion/webrtc/v4/pkg/media"

	lksdk "github.com/livekit/server-sdk-go/v2"
)

codec := webrtc.RTPCodecCapability{
	MimeType:  webrtc.MimeTypeH264,
	ClockRate: 90000,
}

track, err := lksdk.NewLocalSampleTrack(
	codec,
	lksdk.WithRTCPHandler(func(packet rtcp.Packet) {
		switch packet.(type) {
		case *rtcp.PictureLossIndication, *rtcp.FullIntraRequest:
			// Ask your encoder to produce a key frame.
		}
	}),
)
if err != nil {
	return err
}

_, err = room.LocalParticipant.PublishTrack(
	track,
	&lksdk.TrackPublicationOptions{
		Name:        "camera",
		VideoWidth:  1920,
		VideoHeight: 1080,
	},
)
if err != nil {
	return err
}

for {
	// Read one complete access unit from your encoder.
	payload := nextAccessUnit()
	err = track.WriteSample(media.Sample{
		Data:     payload,
		Duration: time.Second / 30,
	}, nil)
	if err != nil {
		return err
	}
}