🎥 Make videos programmatically with React
package lambda_go_sdk
import (
"github.com/go-playground/validator/v10"
)
func constructRenderInternals(options *RemotionOptions) (*renderInternalOptions, error) {
validate := validator.New()
validationErrors := validate.Struct(options)
if validationErrors != nil {
return nil, validationErrors
}
// Serialize (and, if too large, upload) inputProps only after validation so
// that an invalid request does not trigger S3 side effects.
inputProps, serializeError := serializeInputProps(options.InputProps, options.Region, "video-or-audio", options.ForceBucketName, options.ForcePathStyle)
if serializeError != nil {
return nil, serializeError
}
jpegQuality := 80
if options.JpegQuality != 0 {
jpegQuality = options.JpegQuality
}
internalParams := renderInternalOptions{
EnableCancellation: options.EnableCancellation,
ServeUrl: options.ServeUrl,
InputProps: inputProps,
Composition: options.Composition,
Version: VERSION,
FrameRange: options.FrameRange,
OutName: options.OutName,
SeparateAudioTo: options.SeparateAudioTo,
AudioBitrate: options.AudioBitrate,
VideoBitrate: options.VideoBitrate,
Webhook: options.Webhook,
ForceHeight: options.ForceHeight,
ForceFps: options.ForceFps,
ForceDurationInFrames: options.ForceDurationInFrames,
OffthreadVideoCacheSizeInBytes: options.OffthreadVideoCacheSizeInBytes,
MediaCacheSizeInBytes: options.MediaCacheSizeInBytes,
OffthreadVideoThreads: options.OffthreadVideoThreads,
X264Preset: options.X264Preset,
GopSize: options.GopSize,
DisableSharedMemoryCapture: options.DisableSharedMemoryCapture,
ForceWidth: options.ForceWidth,
BucketName: options.BucketName,
AudioCodec: options.AudioCodec,
ForceBucketName: options.ForceBucketName,
RendererFunctionName: &options.RendererFunctionName,
DeleteAfter: options.DeleteAfter,
Type: "start",
Output: map[string]interface{}{"type": "media"},
JpegQuality: jpegQuality,
}
internalParams.Muted = options.Muted
internalParams.PreferLossless = options.PreferLossless
internalParams.Overwrite = options.Overwrite
if options.RendererFunctionName == "" {
internalParams.RendererFunctionName = nil
}
codec := options.Codec
if codec == "" {
codec = "h264"
}
internalParams.Codec = &codec
if options.EveryNthFrame == 0 {
internalParams.EveryNthFrame = 1
} else {
internalParams.EveryNthFrame = options.EveryNthFrame
}
if options.ImageFormat == "" {
internalParams.ImageFormat = "jpeg"
} else {
internalParams.ImageFormat = options.ImageFormat
}
if options.Crf != 0 {
crf := options.Crf
internalParams.Crf = &crf
}
if options.Privacy == "" {
internalParams.Privacy = "public"
} else {
internalParams.Privacy = options.Privacy
}
if options.ColorSpace != "" {
colorSpace := options.ColorSpace
internalParams.ColorSpace = &colorSpace
}
if options.LogLevel == "" {
internalParams.LogLevel = "info"
} else {
internalParams.LogLevel = options.LogLevel
}
if options.Scale == 0 {
internalParams.Scale = 1
} else {
internalParams.Scale = float64(options.Scale)
}
if options.MaxRetries == 0 {
internalParams.MaxRetries = 1
} else {
internalParams.MaxRetries = options.MaxRetries
}
sampleRate := 48000
if options.SampleRate != 0 {
sampleRate = options.SampleRate
}
internalParams.SampleRate = sampleRate
if options.ConcurrencyPerLambda == 0 {
internalParams.ConcurrencyPerLambda = 1
} else {
internalParams.ConcurrencyPerLambda = options.ConcurrencyPerLambda
}
internalParams.Concurrency = options.Concurrency
if options.TimeoutInMilliseconds == 0 {
internalParams.TimeoutInMilliseconds = 30000
} else {
internalParams.TimeoutInMilliseconds = options.TimeoutInMilliseconds
}
if codec == "gif" {
internalParams.NumberOfGifLoops = &options.NumberOfGifLoops
}
if options.DownloadBehavior == nil {
internalParams.DownloadBehavior = map[string]interface{}{
"type": "play-in-browser",
}
} else {
internalParams.DownloadBehavior = options.DownloadBehavior
}
if options.ChromiumOptions == nil {
internalParams.ChromiumOptions = map[string]interface{}{}
} else {
internalParams.ChromiumOptions = options.ChromiumOptions
}
if options.EnvVariables == nil {
internalParams.EnvVariables = map[string]interface{}{}
} else {
internalParams.EnvVariables = options.EnvVariables
}
if options.Metadata == nil {
internalParams.Metadata = map[string]interface{}{}
} else {
internalParams.Metadata = options.Metadata
}
if options.LicenseKey != nil {
internalParams.LicenseKey = options.LicenseKey
} else {
internalParams.LicenseKey = options.ApiKey
}
return &internalParams, nil
}
func constructGetProgressInternals(options *RenderConfig) (*renderProgressInternalConfig, error) {
validate := validator.New()
validationErrors := validate.Struct(options)
if validationErrors != nil {
return nil, validationErrors
}
logLevel := "info"
if options.LogLevel != "" {
logLevel = options.LogLevel
}
internalParams := renderProgressInternalConfig{
RenderId: options.RenderId,
BucketName: options.BucketName,
LogLevel: logLevel,
Type: "status",
Version: VERSION,
}
return &internalParams, nil
}