[RSDK-9458] Remove Stream from Go camera interface

components/camera/camera.go

@@ -78,12 +78,6 @@ type ImageMetadata struct {
 }
 
 // A Camera is a resource that can capture frames.
-type Camera interface {
-	resource.Resource
-	VideoSource
-}
-
-// VideoSource represents anything that can capture frames.
 // For more information, see the [camera component docs].
 //
 // Image example:
@@ -102,17 +96,6 @@ type Camera interface {
 //
 //	images, metadata, err := myCamera.Images(context.Background())
 //
-// Stream example:
-//
-//	myCamera, err := camera.FromRobot(machine, "my_camera")
-//
-//	// gets the stream from a camera
-//	stream, err := myCamera.Stream(context.Background())
-//
-//	// gets an image from the camera stream
-//	img, release, err := stream.Next(context.Background())
-//	defer release()
-//
 // NextPointCloud example:
 //
 //	myCamera, err := camera.FromRobot(machine, "my_camera")
@@ -127,7 +110,8 @@ type Camera interface {
 //	err = myCamera.Close(context.Background())
 //
 // [camera component docs]: https://docs.viam.com/components/camera/
-type VideoSource interface {
+type Camera interface {
+	resource.Resource
 	// Image returns a byte slice representing an image that tries to adhere to the MIME type hint.
 	// Image also may return metadata about the frame.
 	Image(ctx context.Context, mimeType string, extra map[string]interface{}) ([]byte, ImageMetadata, error)
@@ -136,20 +120,20 @@ type VideoSource interface {
 	// along with associated metadata (just timestamp for now). It's not for getting a time series of images from the same imager.
 	Images(ctx context.Context) ([]NamedImage, resource.ResponseMetadata, error)
 
-	// Stream returns a stream that makes a best effort to return consecutive images
-	// that may have a MIME type hint dictated in the context via gostream.WithMIMETypeHint.
-	Stream(ctx context.Context, errHandlers ...gostream.ErrorHandler) (gostream.VideoStream, error)
-
 	// NextPointCloud returns the next immediately available point cloud, not necessarily one
 	// a part of a sequence. In the future, there could be streaming of point clouds.
 	NextPointCloud(ctx context.Context) (pointcloud.PointCloud, error)
 
 	// Properties returns properties that are intrinsic to the particular
 	// implementation of a camera.
 	Properties(ctx context.Context) (Properties, error)
+}
 
-	// Close shuts down the resource and prevents further use.
-	Close(ctx context.Context) error
+// StreamCamera is a camera that has `Stream` embedded to directly integrate with gostream.
+// Note that generally, when writing camera components from scratch, embedding `Stream` is an anti-pattern.
+type StreamCamera interface {
+	Camera
+	Stream(ctx context.Context, errHandlers ...gostream.ErrorHandler) (gostream.VideoStream, error)
 }
 
 // ReadImage reads an image from the given source that is immediately available.

components/camera/client_test.go

@@ -178,7 +178,6 @@ func TestClient(t *testing.T) {
 		test.That(t, err, test.ShouldBeNil)
 		camera1Client, err := camera.NewClientFromConn(context.Background(), conn, "", camera.Named(testCameraName), logger)
 		test.That(t, err, test.ShouldBeNil)
-
 		frame, err := camera.DecodeImageFromCamera(context.Background(), rutils.MimeTypeRawRGBA, nil, camera1Client)
 		test.That(t, err, test.ShouldBeNil)
 		compVal, _, err := rimage.CompareImages(img, frame)
@@ -245,10 +244,6 @@ func TestClient(t *testing.T) {
 		client2, err := resourceAPI.RPCClient(context.Background(), conn, "", camera.Named(failCameraName), logger)
 		test.That(t, err, test.ShouldBeNil)
 
-		_, _, err = camera.ReadImage(context.Background(), client2)
-		test.That(t, err, test.ShouldNotBeNil)
-		test.That(t, err.Error(), test.ShouldContainSubstring, errGetImageFailed.Error())
-
 		_, _, err = client2.Image(context.Background(), "", nil)
 		test.That(t, err, test.ShouldNotBeNil)
 		test.That(t, err.Error(), test.ShouldContainSubstring, errGetImageFailed.Error())
@@ -547,78 +542,6 @@ func TestClientWithInterceptor(t *testing.T) {
 	test.That(t, conn.Close(), test.ShouldBeNil)
 }
 
-func TestClientStreamAfterClose(t *testing.T) {
-	// Set up gRPC server
-	logger := logging.NewTestLogger(t)
-	listener, err := net.Listen("tcp", "localhost:0")
-	test.That(t, err, test.ShouldBeNil)
-	rpcServer, err := rpc.NewServer(logger, rpc.WithUnauthenticated())
-	test.That(t, err, test.ShouldBeNil)
-
-	// Set up camera that can stream images
-	img := image.NewNRGBA(image.Rect(0, 0, 4, 4))
-	injectCamera := &inject.Camera{}
-	injectCamera.PropertiesFunc = func(ctx context.Context) (camera.Properties, error) {
-		return camera.Properties{}, nil
-	}
-	injectCamera.ImageFunc = func(ctx context.Context, mimeType string, extra map[string]interface{}) ([]byte, camera.ImageMetadata, error) {
-		imgBytes, err := rimage.EncodeImage(ctx, img, mimeType)
-		test.That(t, err, test.ShouldBeNil)
-		return imgBytes, camera.ImageMetadata{MimeType: mimeType}, nil
-	}
-
-	// Register CameraService API in our gRPC server.
-	resources := map[resource.Name]camera.Camera{
-		camera.Named(testCameraName): injectCamera,
-	}
-	cameraSvc, err := resource.NewAPIResourceCollection(camera.API, resources)
-	test.That(t, err, test.ShouldBeNil)
-	resourceAPI, ok, err := resource.LookupAPIRegistration[camera.Camera](camera.API)
-	test.That(t, err, test.ShouldBeNil)
-	test.That(t, ok, test.ShouldBeTrue)
-	test.That(t, resourceAPI.RegisterRPCService(context.Background(), rpcServer, cameraSvc), test.ShouldBeNil)
-
-	// Start serving requests.
-	go rpcServer.Serve(listener)
-	defer rpcServer.Stop()
-
-	// Make client connection
-	conn, err := viamgrpc.Dial(context.Background(), listener.Addr().String(), logger)
-	test.That(t, err, test.ShouldBeNil)
-	client, err := camera.NewClientFromConn(context.Background(), conn, "", camera.Named(testCameraName), logger)
-	test.That(t, err, test.ShouldBeNil)
-
-	// Get a stream
-	stream, err := client.Stream(context.Background())
-	test.That(t, stream, test.ShouldNotBeNil)
-	test.That(t, err, test.ShouldBeNil)
-
-	// Read from stream
-	media, _, err := stream.Next(context.Background())
-	test.That(t, media, test.ShouldNotBeNil)
-	test.That(t, err, test.ShouldBeNil)
-
-	// Close client and read from stream
-	test.That(t, client.Close(context.Background()), test.ShouldBeNil)
-	media, _, err = stream.Next(context.Background())
-	test.That(t, media, test.ShouldBeNil)
-	test.That(t, err.Error(), test.ShouldContainSubstring, "context canceled")
-
-	// Get a new stream
-	stream, err = client.Stream(context.Background())
-	test.That(t, stream, test.ShouldNotBeNil)
-	test.That(t, err, test.ShouldBeNil)
-
-	// Read from the new stream
-	media, _, err = stream.Next(context.Background())
-	test.That(t, media, test.ShouldNotBeNil)
-	test.That(t, err, test.ShouldBeNil)
-
-	// Close client and connection
-	test.That(t, client.Close(context.Background()), test.ShouldBeNil)
-	test.That(t, conn.Close(), test.ShouldBeNil)
-}
-
 // See modmanager_test.go for the happy path (aka, when the
 // client has a webrtc connection).
 func TestRTPPassthroughWithoutWebRTC(t *testing.T) {

components/camera/ffmpeg/ffmpeg.go

@@ -73,7 +73,6 @@ func init() {
 }
 
 type ffmpegCamera struct {
-	resource.Named
 	gostream.VideoReader
 	cancelFunc              context.CancelFunc
 	activeBackgroundWorkers sync.WaitGroup
@@ -92,7 +91,7 @@ func (writer stderrWriter) Write(p []byte) (n int, err error) {
 }
 
 // NewFFMPEGCamera instantiates a new camera which leverages ffmpeg to handle a variety of potential video types.
-func NewFFMPEGCamera(ctx context.Context, conf *Config, logger logging.Logger) (camera.VideoSource, error) {
+func NewFFMPEGCamera(ctx context.Context, conf *Config, logger logging.Logger) (camera.StreamCamera, error) {
 	// make sure ffmpeg is in the path before doing anything else
 	if _, err := exec.LookPath("ffmpeg"); err != nil {
 		return nil, err

components/camera/ffmpeg/ffmpeg_test.go

@@ -8,6 +8,7 @@ import (
 	"go.viam.com/test"
 	"go.viam.com/utils/artifact"
 
+	"go.viam.com/rdk/components/camera"
 	"go.viam.com/rdk/logging"
 	"go.viam.com/rdk/utils"
 )
@@ -20,7 +21,7 @@ func TestFFMPEGCamera(t *testing.T) {
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, err, test.ShouldBeNil)
 	for i := 0; i < 5; i++ {
-		_, _, err = cam.Image(ctx, utils.MimeTypeJPEG, nil)
+		_, err = camera.DecodeImageFromCamera(ctx, utils.MimeTypeJPEG, nil, cam)
 		test.That(t, err, test.ShouldBeNil)
 	}
 	test.That(t, cam.Close(context.Background()), test.ShouldBeNil)

components/camera/replaypcd/replaypcd_test.go

@@ -660,11 +660,6 @@ func TestReplayPCDUnimplementedFunctions(t *testing.T) {
 	replayCamera, _, serverClose, err := createNewReplayPCDCamera(ctx, t, replayCamCfg, true)
 	test.That(t, err, test.ShouldBeNil)
 
-	t.Run("Stream", func(t *testing.T) {
-		_, err := replayCamera.Stream(ctx, nil)
-		test.That(t, err.Error(), test.ShouldEqual, "Stream is unimplemented")
-	})
-
 	err = replayCamera.Close(ctx)
 	test.That(t, err, test.ShouldBeNil)
 

components/camera/server.go

@@ -33,7 +33,11 @@ type serviceServer struct {
 func NewRPCServiceServer(coll resource.APIResourceCollection[Camera]) interface{} {
 	logger := logging.NewLogger("camserver")
 	imgTypes := make(map[string]ImageType)
-	return &serviceServer{coll: coll, logger: logger, imgTypes: imgTypes}
+	return &serviceServer{
+		coll:     coll,
+		logger:   logger,
+		imgTypes: imgTypes,
+	}
 }
 
 // GetImage returns an image from a camera of the underlying robot. If a specific MIME type

components/camera/transformpipeline/classifier.go

@@ -27,7 +27,7 @@ type classifierConfig struct {
 
 // classifierSource takes an image from the camera, and overlays labels from the classifier.
 type classifierSource struct {
-	src                camera.VideoSource
+	src                camera.StreamCamera
 	classifierName     string
 	maxClassifications uint32
 	labelFilter        classification.Postprocessor
@@ -37,8 +37,8 @@ type classifierSource struct {
 
 func newClassificationsTransform(
 	ctx context.Context,
-	source camera.VideoSource, r robot.Robot, am utils.AttributeMap,
-) (camera.VideoSource, camera.ImageType, error) {
+	source camera.StreamCamera, r robot.Robot, am utils.AttributeMap,
+) (camera.StreamCamera, camera.ImageType, error) {
 	conf, err := resource.TransformAttributeMap[*classifierConfig](am)
 	if err != nil {
 		return nil, camera.UnspecifiedStream, err

components/camera/transformpipeline/classifier_test.go

@@ -82,7 +82,6 @@ func buildRobotWithClassifier(logger logging.Logger) (robot.Robot, error) {
 	return r, nil
 }
 
-//nolint:dupl
 func TestClassifierSource(t *testing.T) {
 	logger := logging.NewTestLogger(t)
 	ctx, cancel := context.WithCancel(context.Background())
@@ -99,7 +98,9 @@ func TestClassifierSource(t *testing.T) {
 	test.That(t, err, test.ShouldBeNil)
 	defer classifier.Close(ctx)
 
-	resImg, _, err := camera.ReadImage(ctx, classifier)
+	streamClassifier, ok := classifier.(camera.StreamCamera)
+	test.That(t, ok, test.ShouldBeTrue)
+	resImg, _, err := camera.ReadImage(ctx, streamClassifier)
 	test.That(t, err, test.ShouldBeNil)
 	ovImg := rimage.ConvertImage(resImg)
 

components/camera/transformpipeline/composed.go

@@ -18,28 +18,25 @@ import (
 // depthToPretty takes a depth image and turns into a colorful image, with blue being
 // farther away, and red being closest. Actual depth information is lost in the transform.
 type depthToPretty struct {
-	src         camera.VideoSource
+	src         camera.StreamCamera
 	cameraModel *transform.PinholeCameraModel
 }
 
-func propsFromVideoSource(ctx context.Context, source camera.VideoSource) (camera.Properties, error) {
+func propsFromVideoSource(ctx context.Context, source camera.Camera) (camera.Properties, error) {
 	var camProps camera.Properties
-
-	if cameraSrc, ok := source.(camera.Camera); ok {
-		props, err := cameraSrc.Properties(ctx)
-		if err != nil {
-			return camProps, err
-		}
-		camProps = props
+	props, err := source.Properties(ctx)
+	if err != nil {
+		return camProps, err
 	}
+	camProps = props
 	return camProps, nil
 }
 
 func newDepthToPrettyTransform(
 	ctx context.Context,
-	source camera.VideoSource,
+	source camera.StreamCamera,
 	stream camera.ImageType,
-) (camera.VideoSource, camera.ImageType, error) {
+) (camera.StreamCamera, camera.ImageType, error) {
 	if stream != camera.DepthStream {
 		return nil, camera.UnspecifiedStream,
 			errors.Errorf("source has stream type %s, depth_to_pretty only supports depth stream inputs", stream)
@@ -109,16 +106,16 @@ type overlayConfig struct {
 
 // overlaySource overlays the depth and color 2D images in order to debug the alignment of the two images.
 type overlaySource struct {
-	src         camera.VideoSource
+	src         camera.StreamCamera
 	cameraModel *transform.PinholeCameraModel
 }
 
 func newOverlayTransform(
 	ctx context.Context,
-	src camera.VideoSource,
+	src camera.StreamCamera,
 	stream camera.ImageType,
 	am utils.AttributeMap,
-) (camera.VideoSource, camera.ImageType, error) {
+) (camera.StreamCamera, camera.ImageType, error) {
 	conf, err := resource.TransformAttributeMap[*overlayConfig](am)
 	if err != nil {
 		return nil, camera.UnspecifiedStream, err

components/camera/transformpipeline/composed_test.go

@@ -63,22 +63,23 @@ func TestComposed(t *testing.T) {
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, pc.Size(), test.ShouldEqual, 1)
 
-	myOverlay, stream, err := newOverlayTransform(context.Background(), cloudSource, camera.ColorStream, am)
+	streamedCloudSource := streamCameraFromCamera(context.Background(), cloudSource)
+	myOverlay, stream, err := newOverlayTransform(context.Background(), streamedCloudSource, camera.ColorStream, am)
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, stream, test.ShouldEqual, camera.ColorStream)
 	pic, _, err := camera.ReadImage(context.Background(), myOverlay)
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, pic.Bounds(), test.ShouldResemble, image.Rect(0, 0, 1280, 720))
 
-	myPipeline, err := newTransformPipeline(context.Background(), cloudSource, conf, robot, logger)
+	myPipeline, err := newTransformPipeline(context.Background(), streamedCloudSource, nil, conf, robot, logger)
 	test.That(t, err, test.ShouldBeNil)
 	defer myPipeline.Close(context.Background())
-	pic, _, err = camera.ReadImage(context.Background(), myPipeline)
+	pic, err = camera.DecodeImageFromCamera(context.Background(), utils.MimeTypeJPEG, nil, myPipeline)
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, pic.Bounds(), test.ShouldResemble, image.Rect(0, 0, 1280, 720))
 
 	// wrong result with bad config
-	_, _, err = newOverlayTransform(context.Background(), cloudSource, camera.ColorStream, utils.AttributeMap{})
+	_, _, err = newOverlayTransform(context.Background(), streamedCloudSource, camera.ColorStream, utils.AttributeMap{})
 	test.That(t, err, test.ShouldNotBeNil)
 	test.That(t, err, test.ShouldWrap, transform.ErrNoIntrinsics)
 	// wrong config, still no intrinsics
@@ -88,7 +89,7 @@ func TestComposed(t *testing.T) {
 			Height: 720,
 		},
 	}
-	_, _, err = newOverlayTransform(context.Background(), cloudSource, camera.ColorStream, am)
+	_, _, err = newOverlayTransform(context.Background(), streamedCloudSource, camera.ColorStream, am)
 	test.That(t, err, test.ShouldNotBeNil)
 	test.That(t, err, test.ShouldWrap, transform.ErrNoIntrinsics)
 	// wrong config, no attributes
@@ -99,7 +100,7 @@ func TestComposed(t *testing.T) {
 			},
 		},
 	}
-	_, err = newTransformPipeline(context.Background(), cloudSource, conf, robot, logger)
+	_, err = newTransformPipeline(context.Background(), streamedCloudSource, nil, conf, robot, logger)
 	test.That(t, err, test.ShouldNotBeNil)
 	test.That(t, err, test.ShouldWrap, transform.ErrNoIntrinsics)
 }

components/camera/transformpipeline/depth_edges.go

@@ -22,13 +22,13 @@ type depthEdgesConfig struct {
 
 // depthEdgesSource applies a Canny Edge Detector to the depth map.
 type depthEdgesSource struct {
-	src        camera.VideoSource
+	src        camera.StreamCamera
 	detector   *rimage.CannyEdgeDetector
 	blurRadius float64
 }
 
-func newDepthEdgesTransform(ctx context.Context, source camera.VideoSource, am utils.AttributeMap,
-) (camera.VideoSource, camera.ImageType, error) {
+func newDepthEdgesTransform(ctx context.Context, source camera.StreamCamera, am utils.AttributeMap,
+) (camera.StreamCamera, camera.ImageType, error) {
 	conf, err := resource.TransformAttributeMap[*depthEdgesConfig](am)
 	if err != nil {
 		return nil, camera.UnspecifiedStream, err