[RSDK-6469] Set x264 bitrate based on resolution and fps

gostream/codec/x264/encoder.go

@@ -19,9 +19,6 @@ type encoder struct {
 	logger logging.Logger
 }
 
-// Gives suitable results. Probably want to make this configurable this in the future.
-const bitrate = 3_200_000
-
 // NewEncoder returns an x264 encoder that can encode images of the given width and height. It will
 // also ensure that it produces key frames at the given interval.
 func NewEncoder(width, height, keyFrameInterval int, logger logging.Logger) (ourcodec.VideoEncoder, error) {
@@ -33,8 +30,8 @@ func NewEncoder(width, height, keyFrameInterval int, logger logging.Logger) (our
 		return nil, err
 	}
 	builder = &params
-	params.BitRate = bitrate
 	params.KeyFrameInterval = keyFrameInterval
+	params.BitRate = calcBitrateFromResolution(width, height, float32(params.KeyFrameInterval))
 
 	codec, err := builder.BuildVideoEncoder(enc, prop.Media{
 		Video: prop.Video{

gostream/codec/x264/utils.go

@@ -6,6 +6,17 @@ import (
 	"go.viam.com/rdk/logging"
 )
 
+const (
+	encodeCompressionRatio = 0.15 // bits per pixel when encoded
+	// For very small resolutions, we need to ensure that the vbv buffer size is large enough to
+	// handle frame bursts. This is the minimum bitrate that we can use without causing the encoder
+	// to spew out warnings about the buffer size being too small.
+	minBitrate = 300_000 // 300kbps
+	// Setting a reasonable max bitrate to prevent the encoder from using too much bandwidth.
+	// 4K resolution at 20fps is around 24.8Mbps.
+	maxBitrate = 25_000_000 // 25Mbps
+)
+
 // DefaultStreamConfig configures x264 as the encoder for a stream.
 var DefaultStreamConfig gostream.StreamConfig
 
@@ -27,3 +38,16 @@ func (f *factory) New(width, height, keyFrameInterval int, logger logging.Logger
 func (f *factory) MIMEType() string {
 	return "video/H264"
 }
+
+// calcBitrateFromResolution calculates the bitrate based on the given resolution and framerate.
+func calcBitrateFromResolution(width, height int, framerate float32) int {
+	bitrate := int(float32(width) * float32(height) * framerate * encodeCompressionRatio)
+	// This accounts for zero bitrates too.
+	if bitrate < minBitrate {
+		return minBitrate
+	}
+	if bitrate > maxBitrate {
+		return maxBitrate
+	}
+	return bitrate
+}

robot/web/stream/server.go

@@ -507,11 +507,18 @@ func (server *Server) AddNewStreams(ctx context.Context) error {
 			server.logger.Warn("video streaming not supported on Windows yet")
 			break
 		}
+		// Attempt to look up the framerate for the camera. If the framerate is not available, we'll
+		// end up with a framerate of 0. This is fine as gostream will default to 30fps in this case.
+		framerate, err := server.getFramerateFromCamera(name)
+		if err != nil {
+			server.logger.Debugf("error getting framerate from camera %q: %v", name, err)
+		}
 		// We walk the updated set of `videoSources` and ensure all of the sources are "created" and
 		// "started".
 		config := gostream.StreamConfig{
 			Name:                name,
 			VideoEncoderFactory: server.streamConfig.VideoEncoderFactory,
+			TargetFrameRate:     framerate,
 		}
 		// Call `createStream`. `createStream` is responsible for first checking if the stream
 		// already exists. If it does, it skips creating a new stream and we continue to the next source.
@@ -758,6 +765,18 @@ func (server *Server) startAudioStream(ctx context.Context, source gostream.Audi
 	})
 }
 
+func (server *Server) getFramerateFromCamera(name string) (int, error) {
+	cam, err := camera.FromRobot(server.robot, name)
+	if err != nil {
+		return 0, fmt.Errorf("failed to get camera from robot: %w", err)
+	}
+	props, err := cam.Properties(context.Background())
+	if err != nil {
+		return 0, fmt.Errorf("failed to get camera properties: %w", err)
+	}
+	return int(props.FrameRate), nil
+}
+
 // GenerateResolutions takes the original width and height of an image and returns
 // a list of the original resolution with 4 smaller width/height options that maintain
 // the same aspect ratio.