adding av1 (#148)

Author: jamescyeh

provider/mediaconvert/av1.go

@@ -0,0 +1,52 @@
+package mediaconvert
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/aws/aws-sdk-go-v2/service/mediaconvert"
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/cbsinteractive/video-transcoding-api/db"
+	"github.com/pkg/errors"
+)
+
+func av1CodecSettingsFrom(preset db.Preset) (*mediaconvert.VideoCodecSettings, error) {
+	bitrate, err := strconv.ParseInt(preset.Video.Bitrate, 10, 64)
+	if err != nil {
+		return nil, errors.Wrapf(err, "parsing video bitrate %q to int64", preset.Video.Bitrate)
+	}
+
+	gopSize, err := av1GopSizeFrom(preset.Video.GopUnit, preset.Video.GopSize)
+	if err != nil {
+		return nil, err
+	}
+
+	return &mediaconvert.VideoCodecSettings{
+		Codec: mediaconvert.VideoCodecAv1,
+		Av1Settings: &mediaconvert.Av1Settings{
+			MaxBitrate: aws.Int64(bitrate),
+			GopSize:    aws.Float64(gopSize),
+			QvbrSettings: &mediaconvert.Av1QvbrSettings{
+				QvbrQualityLevel:         aws.Int64(7),
+				QvbrQualityLevelFineTune: aws.Float64(0),
+			},
+			RateControlMode: mediaconvert.Av1RateControlModeQvbr,
+		},
+	}, nil
+}
+
+func av1GopSizeFrom(gopUnit string, gopSize string) (float64, error) {
+	switch strings.ToLower(gopUnit) {
+	case "", db.GopUnitFrames:
+		f, err := strconv.ParseFloat(gopSize, 64)
+		if err != nil {
+			return 0, errors.Wrapf(err, "parsing gop size %q to float64", gopSize)
+		}
+		return f, nil
+	case db.GopUnitSeconds:
+		return 0, fmt.Errorf("gop unit %q is not supported with mediaconvert and AV1", gopUnit)
+	default:
+		return 0, fmt.Errorf("gop unit %q is not supported with mediaconvert", gopUnit)
+	}
+}

provider/mediaconvert/h264.go

@@ -19,7 +19,7 @@ func h264CodecSettingsFrom(preset db.Preset) (*mediaconvert.VideoCodecSettings,
 
 	gopSize, err := strconv.ParseFloat(preset.Video.GopSize, 64)
 	if err != nil {
-		return nil, errors.Wrapf(err, "parsing gop size %q to int64", preset.Video.GopSize)
+		return nil, errors.Wrapf(err, "parsing gop size %q to float64", preset.Video.GopSize)
 	}
 
 	gopUnit, err := h264GopUnitFrom(preset.Video.GopUnit)

provider/mediaconvert/h265.go

@@ -19,7 +19,7 @@ func h265CodecSettingsFrom(preset db.Preset) (*mediaconvert.VideoCodecSettings,
 
 	gopSize, err := strconv.ParseFloat(preset.Video.GopSize, 64)
 	if err != nil {
-		return nil, errors.Wrapf(err, "parsing gop size %q to int64", preset.Video.GopSize)
+		return nil, errors.Wrapf(err, "parsing gop size %q to float64", preset.Video.GopSize)
 	}
 
 	gopUnit, err := h265GopUnitFrom(preset.Video.GopUnit)

provider/mediaconvert/mediaconvert_test.go

@@ -56,6 +56,22 @@ var (
 		},
 	}
 
+	av1Preset = db.Preset{
+		Name:        "yet_another_preset_name",
+		Description: "test_desc",
+		Container:   "mp4",
+		TwoPass:     false,
+		Video: db.VideoPreset{
+			Width:         "300",
+			Height:        "400",
+			Codec:         "av1",
+			Bitrate:       "400000",
+			GopSize:       "120",
+			GopUnit:       "frames",
+			InterlaceMode: "progressive",
+		},
+	}
+
 	defaultJob = db.Job{
 		ID:           "jobID",
 		ProviderName: Name,
@@ -236,7 +252,7 @@ func Test_mcProvider_CreatePreset_fields(t *testing.T) {
 				p.Video.GopSize = "gop"
 				return p
 			},
-			wantErrMsg: `generating video preset: building h264 codec settings: parsing gop size "gop" to int64: strconv.ParseFloat: parsing "gop": invalid syntax`,
+			wantErrMsg: `generating video preset: building h264 codec settings: parsing gop size "gop" to float64: strconv.ParseFloat: parsing "gop": invalid syntax`,
 		},
 		{
 			name: "unrecognized rate control mode returns an error",
@@ -515,6 +531,75 @@ func Test_mcProvider_Transcode(t *testing.T) {
 				},
 			},
 		},
+		{
+			name: "a valid av1 video-only mp4 transcode job is mapped correctly to a mediaconvert job input",
+			job: &db.Job{
+				ID:           "jobID",
+				ProviderName: Name,
+				SourceMedia:  "s3://some/path.mp4",
+				Outputs:      []db.TranscodeOutput{{Preset: db.PresetMap{Name: av1Preset.Name}, FileName: "file1.mp4"}},
+			},
+			preset:      av1Preset,
+			destination: "s3://some/destination",
+			wantJobReq: mediaconvert.CreateJobInput{
+				Role:  aws.String(""),
+				Queue: aws.String(""),
+				Settings: &mediaconvert.JobSettings{
+					Inputs: []mediaconvert.Input{
+						{
+							AudioSelectors: map[string]mediaconvert.AudioSelector{
+								"Audio Selector 1": {
+									DefaultSelection: mediaconvert.AudioDefaultSelectionDefault,
+								},
+							},
+							FileInput: aws.String("s3://some/path.mp4"),
+							VideoSelector: &mediaconvert.VideoSelector{
+								ColorSpace: mediaconvert.ColorSpaceFollow,
+							},
+						},
+					},
+					OutputGroups: []mediaconvert.OutputGroup{
+						{
+							OutputGroupSettings: &mediaconvert.OutputGroupSettings{
+								Type: mediaconvert.OutputGroupTypeFileGroupSettings,
+								FileGroupSettings: &mediaconvert.FileGroupSettings{
+									Destination: aws.String("s3://some/destination/jobID/m"),
+								},
+							},
+							Outputs: []mediaconvert.Output{
+								{
+									NameModifier: aws.String("file1"),
+									ContainerSettings: &mediaconvert.ContainerSettings{
+										Container: mediaconvert.ContainerTypeMp4,
+									},
+									VideoDescription: &mediaconvert.VideoDescription{
+										Height:            aws.Int64(400),
+										Width:             aws.Int64(300),
+										RespondToAfd:      mediaconvert.RespondToAfdNone,
+										ScalingBehavior:   mediaconvert.ScalingBehaviorDefault,
+										TimecodeInsertion: mediaconvert.VideoTimecodeInsertionDisabled,
+										AntiAlias:         mediaconvert.AntiAliasEnabled,
+										CodecSettings: &mediaconvert.VideoCodecSettings{
+											Codec: mediaconvert.VideoCodecAv1,
+											Av1Settings: &mediaconvert.Av1Settings{
+												MaxBitrate: aws.Int64(400000),
+												GopSize:    aws.Float64(120),
+												QvbrSettings: &mediaconvert.Av1QvbrSettings{
+													QvbrQualityLevel:         aws.Int64(7),
+													QvbrQualityLevelFineTune: aws.Float64(0),
+												},
+												RateControlMode: mediaconvert.Av1RateControlModeQvbr,
+											},
+										},
+									},
+									Extension: aws.String("mp4"),
+								},
+							},
+						},
+					},
+				},
+			},
+		},
 	}
 
 	for _, tt := range tests {

provider/mediaconvert/preset_mapping.go

@@ -151,6 +151,13 @@ func videoPresetFrom(preset db.Preset) (*mediaconvert.VideoDescription, error) {
 			return nil, errors.Wrap(err, "building h265 codec settings")
 		}
 
+		videoPreset.CodecSettings = settings
+	case "av1":
+		settings, err := av1CodecSettingsFrom(preset)
+		if err != nil {
+			return nil, errors.Wrap(err, "building av1 codec settings")
+		}
+
 		videoPreset.CodecSettings = settings
 	default:
 		return nil, fmt.Errorf("video codec %q is not yet supported with mediaconvert", codec)