[RSDK-10100, RSDK-10111] - Add utils to lazy encoded image to decode and return errors instead of panic-ing always (viamrobotics#4826)

Author: hexbabe

components/camera/transformpipeline/mods_test.go

@@ -608,7 +608,8 @@ func BenchmarkColorRotate(b *testing.B) {
 	am := utils.AttributeMap{
 		"angle_degs": 180,
 	}
-	vs := videoSourceFromCamera(context.Background(), src)
+	vs, err := videoSourceFromCamera(context.Background(), src)
+	test.That(b, err, test.ShouldBeNil)
 	rs, stream, err := newRotateTransform(context.Background(), vs, camera.ColorStream, am)
 	test.That(b, err, test.ShouldBeNil)
 	test.That(b, stream, test.ShouldEqual, camera.ColorStream)
@@ -634,7 +635,8 @@ func BenchmarkDepthRotate(b *testing.B) {
 	am := utils.AttributeMap{
 		"angle_degs": 180,
 	}
-	vs := videoSourceFromCamera(context.Background(), src)
+	vs, err := videoSourceFromCamera(context.Background(), src)
+	test.That(b, err, test.ShouldBeNil)
 	rs, stream, err := newRotateTransform(context.Background(), vs, camera.DepthStream, am)
 	test.That(b, err, test.ShouldBeNil)
 	test.That(b, stream, test.ShouldEqual, camera.DepthStream)

components/camera/transformpipeline/pipeline.go

@@ -25,6 +25,9 @@ import (
 
 var model = resource.DefaultModelFamily.WithModel("transform")
 
+// ErrVideoSourceCreation is returned when creating a video source from a camera fails.
+var ErrVideoSourceCreation = errors.New("failed to create video source from camera")
+
 func init() {
 	resource.RegisterComponent(
 		camera.API,
@@ -49,7 +52,10 @@ func init() {
 				if err != nil {
 					return nil, fmt.Errorf("no source camera for transform pipeline (%s): %w", sourceName, err)
 				}
-				vs := videoSourceFromCamera(ctx, source)
+				vs, err := videoSourceFromCamera(ctx, source)
+				if err != nil {
+					return nil, fmt.Errorf("failed to create video source from camera: %w", err)
+				}
 				src, err := newTransformPipeline(ctx, vs, conf.ResourceName().AsNamed(), newConf, actualR, logger)
 				if err != nil {
 					return nil, err
@@ -103,14 +109,18 @@ func (sc *videoSource) Stream(ctx context.Context, errHandlers ...gostream.Error
 // and still implement a camera resource.
 // We prefer this methodology over passing Image bytes because each transform desires a image.Image over
 // a raw byte slice. To use Image would be to wastefully encode and decode the frame multiple times.
-func videoSourceFromCamera(ctx context.Context, cam camera.Camera) camera.VideoSource {
+func videoSourceFromCamera(ctx context.Context, cam camera.Camera) (camera.VideoSource, error) {
 	if streamCam, ok := cam.(camera.VideoSource); ok {
-		return streamCam
+		return streamCam, nil
+	}
+	vs, err := camerautils.VideoSourceFromCamera(ctx, cam)
+	if err != nil {
+		return nil, fmt.Errorf("%w: %w", ErrVideoSourceCreation, err)
 	}
 	return &videoSource{
 		Camera: cam,
-		vs:     camerautils.VideoSourceFromCamera(ctx, cam),
-	}
+		vs:     vs,
+	}, nil
 }
 
 func newTransformPipeline(
@@ -142,13 +152,19 @@ func newTransformPipeline(
 	}
 	// loop through the pipeline and create the image flow
 	pipeline := make([]camera.VideoSource, 0, len(cfg.Pipeline))
-	lastSource := videoSourceFromCamera(ctx, source)
+	lastSource, err := videoSourceFromCamera(ctx, source)
+	if err != nil {
+		return nil, err
+	}
 	for _, tr := range cfg.Pipeline {
 		src, newStreamType, err := buildTransform(ctx, r, lastSource, streamType, tr)
 		if err != nil {
 			return nil, err
 		}
-		streamSrc := videoSourceFromCamera(ctx, src)
+		streamSrc, err := videoSourceFromCamera(ctx, src)
+		if err != nil {
+			return nil, err
+		}
 		pipeline = append(pipeline, streamSrc)
 		lastSource = streamSrc
 		streamType = newStreamType

components/camera/transformpipeline/pipeline_test.go

@@ -2,6 +2,7 @@ package transformpipeline
 
 import (
 	"context"
+	"errors"
 	"testing"
 
 	"github.com/pion/mediadevices/pkg/prop"
@@ -34,7 +35,8 @@ func TestTransformPipelineColor(t *testing.T) {
 	test.That(t, err, test.ShouldBeNil)
 	source := gostream.NewVideoSource(&fake.StaticSource{ColorImg: img}, prop.Video{})
 	src, err := camera.WrapVideoSourceWithProjector(context.Background(), source, nil, camera.ColorStream)
-	vs := videoSourceFromCamera(context.Background(), src)
+	test.That(t, err, test.ShouldBeNil)
+	vs, err := videoSourceFromCamera(context.Background(), src)
 	test.That(t, err, test.ShouldBeNil)
 	inImg, err := camera.DecodeImageFromCamera(context.Background(), "", nil, src)
 	test.That(t, err, test.ShouldBeNil)
@@ -87,7 +89,8 @@ func TestTransformPipelineDepth(t *testing.T) {
 	test.That(t, inImg.Bounds().Dx(), test.ShouldEqual, 128)
 	test.That(t, inImg.Bounds().Dy(), test.ShouldEqual, 72)
 
-	vs := videoSourceFromCamera(context.Background(), src)
+	vs, err := videoSourceFromCamera(context.Background(), src)
+	test.That(t, err, test.ShouldBeNil)
 	depth, err := newTransformPipeline(context.Background(), vs, nil, transformConf, r, logger)
 	test.That(t, err, test.ShouldBeNil)
 
@@ -201,3 +204,16 @@ func TestTransformPipelineValidateFail(t *testing.T) {
 	test.That(t, resource.GetFieldFromFieldRequiredError(err), test.ShouldEqual, "source")
 	test.That(t, deps, test.ShouldBeNil)
 }
+
+func TestVideoSourceFromCameraError(t *testing.T) {
+	malformedCam := &inject.Camera{
+		ImageFunc: func(ctx context.Context, mimeType string, extra map[string]interface{}) ([]byte, camera.ImageMetadata, error) {
+			return []byte("not a valid image"), camera.ImageMetadata{MimeType: utils.MimeTypePNG}, nil
+		},
+	}
+
+	vs, err := videoSourceFromCamera(context.Background(), malformedCam)
+	test.That(t, err, test.ShouldNotBeNil)
+	test.That(t, errors.Is(err, ErrVideoSourceCreation), test.ShouldBeTrue)
+	test.That(t, vs, test.ShouldBeNil)
+}

rimage/depth_map_raw.go

@@ -312,9 +312,9 @@ func WriteRawDepthMapTo(img image.Image, out io.Writer) (int64, error) {
 // the Viam custom depth type writes 8 bytes of "magic number", 8 bytes of width, 8 bytes of height, and 2 bytes per pixel.
 func WriteViamDepthMapTo(img image.Image, out io.Writer) (int64, error) {
 	if lazy, ok := img.(*LazyEncodedImage); ok {
-		lazy.decode()
-		if lazy.decodeErr != nil {
-			return 0, errors.Errorf("could not decode LazyEncodedImage to a depth image: %v", lazy.decodeErr)
+		err := lazy.DecodeImage()
+		if err != nil {
+			return 0, errors.Errorf("could not decode LazyEncodedImage to a depth image: %v", err)
 		}
 		img = lazy.decodedImage
 	}

rimage/image_file.go

@@ -179,19 +179,24 @@ func WriteImageToFile(path string, img image.Image) (err error) {
 	}
 }
 
-// ConvertImage converts a go image into our Image type.
-func ConvertImage(img image.Image) *Image {
+// ConvertImageSafe converts a go image into our Image type with error handling.
+// This is a safer alternative to ConvertImage as it returns errors instead of panicking.
+func ConvertImageSafe(img image.Image) (*Image, error) {
 	if lazyImg, ok := img.(*LazyEncodedImage); ok {
-		img = lazyImg.DecodedImage()
+		decodedImg, err := lazyImg.DecodedImage()
+		if err != nil {
+			return nil, err
+		}
+		img = decodedImg
 	}
 	ii, ok := img.(*Image)
 	if ok {
-		return ii
+		return ii, nil
 	}
 
 	iwd, ok := img.(*imageWithDepth)
 	if ok {
-		return iwd.Color
+		return iwd.Color, nil
 	}
 
 	b := img.Bounds()
@@ -211,7 +216,18 @@ func ConvertImage(img image.Image) *Image {
 			}
 		}
 	}
-	return ii
+	return ii, nil
+}
+
+// ConvertImage converts a go image into our Image type.
+// This function panics if there's an error during conversion.
+// For a safer alternative that returns errors, use ConvertImageSafe.
+func ConvertImage(img image.Image) *Image {
+	result, err := ConvertImageSafe(img)
+	if err != nil {
+		panic(err)
+	}
+	return result
 }
 
 // CloneImage creates a copy of the input image.
@@ -241,7 +257,11 @@ func SaveImage(pic image.Image, loc string) error {
 		}
 	}()
 	if lazyImg, ok := pic.(*LazyEncodedImage); ok {
-		pic = lazyImg.DecodedImage()
+		decodedPic, err := lazyImg.DecodedImage()
+		if err != nil {
+			return err
+		}
+		pic = decodedPic
 	}
 	if err = jpeg.Encode(f, pic, &jpeg.Options{Quality: 75}); err != nil {
 		return errors.Wrapf(err, "the 'image' will not encode")
@@ -290,9 +310,9 @@ func EncodeImage(ctx context.Context, img image.Image, mimeType string) ([]byte,
 			return lazy.imgBytes, nil
 		}
 		// LazyImage holds bytes different from requested mime type: decode and re-encode
-		lazy.decode()
-		if lazy.decodeErr != nil {
-			return nil, errors.Errorf("could not decode LazyEncodedImage: %v", lazy.decodeErr)
+		err := lazy.DecodeImage()
+		if err != nil {
+			return nil, errors.Errorf("could not decode LazyEncodedImage: %v", err)
 		}
 		return EncodeImage(ctx, lazy.decodedImage, actualOutMIME)
 	}