Hi,
I would like to process images from the camera while previewing the camera images using the camera plugin. I do not want to transform the preview image or draw anything on the previewed image.
From my understanding the function CameraController#startImageStream() is supposed to be used for such tasks.
This works as expected except of the point that the images send to the image stream only have 720p resolution or lower regardless what ResolutionPreset is set when constructing the CameraController

Steps to Reproduce

Goal: Process images from the camera in best available resolution (send to isolates to not block the main isolate) while previewing the camera images.

Most important parts of the implementation:

Create controller:

_controller = CameraController(
  cameraDescription,
  ResolutionPreset.max,
  enableAudio: false,
);

Show camera preview using widget:

CameraPreview(_controller)

Listen to image stream:

_controller.startImageStream((image) {
        print("Image size: ${image.width}x${image.height}");
      });

The CameraDescription is provided by onNewCameraSelected() as demonstrated in the example provided along with this camera plugin.
To reproduce this issue you can run the example provided in this package and listen to the image stream while previewing the camera images.

Expected results: Maximum available image resolution in the image stream. My devices should have 4k resolution (or at least Full-HD).

Actual results: Always 720p (or lower if requested).

Tested Devices: Samsung Galaxy S10 and S10e

The constructor parameter of CameraController defining ResolutionPreset is ignored/overwritten if it is greater than ResolutionPreset.high.
As already pointed out in issue #49420, the following function in the camera plugin is the reason for this behavior:

static Size computeBestPreviewSize(String cameraName, ResolutionPreset preset) {
    if (preset.ordinal() > ResolutionPreset.high.ordinal()) {
      preset = ResolutionPreset.high;
    }
    CamcorderProfile profile =
        getBestAvailableCamcorderProfileForResolutionPreset(cameraName, preset);
    return new Size(profile.videoFrameWidth, profile.videoFrameHeight);
  }

I see the point that the resolution has to be scaled down for preview.
However, there should be a possibility to process the camera images in the specified resolution.
It should be up to the developer to not block the main thread when listening to an image stream.

My current workaround is to build the camera plugin locally and change CameraUtils#computeBestPreviewSize() as follows:

static Size computeBestPreviewSize(String cameraName, ResolutionPreset preset) {
    //if (preset.ordinal() > ResolutionPreset.high.ordinal()) {
    //  preset = ResolutionPreset.high;
    //}
    CamcorderProfile profile =
        getBestAvailableCamcorderProfileForResolutionPreset(cameraName, preset);
    return new Size(profile.videoFrameWidth, profile.videoFrameHeight);
  }

Of course, this now slows down the camera preview on older devices or is really slow if 4K resolution is used.
Yet, I couldn't find a way to downscale the image before being previewed using above initialization.
I was able to improve performance for previewing a little by changing line 35 of camera_preview.dart from

CameraPlatform.instance.buildPreview(controller.cameraId)

to

Texture(textureId: controller.cameraId, filterQuality: FilterQuality.none)

The default setting of the parameter filterQuality is FilterQuality.low, which is currently used.
According to the documentation of FilterQuality the setting FilterQuality.none is faster.

Summary: Is it currently possible to process the camera images with the requested resolution while previewing the camera images in a lower resolution?

If this is not the case, I would like to request the feature to add another image stream to CameraController which is not used for previewing as described above. The images in the stream used for previewing can be downscaled, that's fine.
Alternatively, one might be able to add an additional constructor parameter and field to CameraController which defines the preview size (use to downscale before actual preview) while the images send to the single image stream have the requested resolution.
Of course, if I select a large preview size the performance is bad. But this decision should be adjustable and up to the developer.

The issue #58163 seems to be related as well.

Greetings,
Joshua