Skip to content

🎥 Make videos programmatically with React

5.6 KB
Raw Blame
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
}