Add --camera-facing

Add an option to select the camera by its lens facing (any, front, back
or external).

Co-authored-by: Romain Vimont <rom@rom1v.com>
Signed-off-by: Romain Vimont <rom@rom1v.com>

app/data/bash-completion/scrcpy

@@ -10,6 +10,9 @@ _scrcpy() {
         --audio-source=
         --audio-output-buffer=
         -b --video-bit-rate=
+        --camera-id=
+        --camera-facing=
+        --camera-size=
         --crop=
         -d --select-usb
         --disable-screensaver
@@ -74,6 +77,7 @@ _scrcpy() {
         --video-codec=
         --video-codec-options=
         --video-encoder=
+        --video-source=
         -w --stay-awake
         --window-borderless
         --window-title=
@@ -93,10 +97,18 @@ _scrcpy() {
             COMPREPLY=($(compgen -W 'opus aac raw' -- "$cur"))
             return
             ;;
+        --video-source)
+            COMPREPLY=($(compgen -W 'display camera' -- "$cur"))
+            return
+            ;;
         --audio-source)
             COMPREPLY=($(compgen -W 'output mic' -- "$cur"))
             return
             ;;
+        --camera-facing)
+            COMPREPLY=($(compgen -W 'front back external' -- "$cur"))
+            return
+            ;;
         --lock-video-orientation)
             COMPREPLY=($(compgen -W 'unlocked initial 0 1 2 3' -- "$cur"))
             return
@@ -141,6 +153,8 @@ _scrcpy() {
         |--audio-codec-options \
         |--audio-encoder \
         |--audio-output-buffer \
+        |--camera-id \
+        |--camera-size \
         |--crop \
         |--display-id \
         |--display-buffer \

app/data/zsh-completion/_scrcpy

@@ -17,6 +17,9 @@ arguments=(
     '--audio-source=[Select the audio source]:source:(output mic)'
     '--audio-output-buffer=[Configure the size of the SDL audio output buffer (in milliseconds)]'
     {-b,--video-bit-rate=}'[Encode the video at the given bit-rate]'
+    '--camera-id=[Specify the camera id to mirror]'
+    '--camera-facing=[Select the device camera by its facing direction]:facing:(front back external)'
+    '--camera-size=[Specify an explicit camera capture size]'
     '--crop=[\[width\:height\:x\:y\] Crop the device screen on the server]'
     {-d,--select-usb}'[Use USB device]'
     '--disable-screensaver[Disable screensaver while scrcpy is running]'
@@ -78,6 +81,7 @@ arguments=(
     '--video-codec=[Select the video codec]:codec:(h264 h265 av1)'
     '--video-codec-options=[Set a list of comma-separated key\:type=value options for the device video encoder]'
     '--video-encoder=[Use a specific MediaCodec video encoder]'
+    '--video-source=[Select the video source]:source:(display camera)'
     {-w,--stay-awake}'[Keep the device on while scrcpy is running, when the device is plugged in]'
     '--window-borderless[Disable window decorations \(display borderless window\)]'
     '--window-title=[Set a custom window title]'

app/scrcpy.1

@@ -75,6 +75,22 @@ Encode the video at the given bit rate, expressed in bits/s. Unit suffixes are s
 
 Default is 8M (8000000).
 
+.TP
+.BI "\-\-camera\-id " id
+Specify the device camera id to mirror.
+
+The available camera ids can be listed by \-\-list\-cameras.
+
+.TP
+.BI "\-\-camera\-facing " facing
+Select the device camera by its facing direction.
+
+Possible values are "front", "back" and "external".
+
+.TP
+.BI "\-\-camera\-size " width\fRx\fIheight
+Specify an explicit camera capture size.
+
 .TP
 .BI "\-\-crop " width\fR:\fIheight\fR:\fIx\fR:\fIy
 Crop the device screen on the server.
@@ -432,6 +448,12 @@ Use a specific MediaCodec video encoder (depending on the codec provided by \fB\
 
 The available encoders can be listed by \-\-list\-encoders.
 
+.TP
+.BI "\-\-video\-source " source
+Select the video source (display or camera).
+
+Default is display.
+
 .TP
 .B \-w, \-\-stay-awake
 Keep the device on while scrcpy is running, when the device is plugged in.

app/src/cli.c

@@ -77,12 +77,16 @@ enum {
     OPT_NO_VIDEO,
     OPT_NO_AUDIO_PLAYBACK,
     OPT_NO_VIDEO_PLAYBACK,
+    OPT_VIDEO_SOURCE,
     OPT_AUDIO_SOURCE,
     OPT_KILL_ADB_ON_CLOSE,
     OPT_TIME_LIMIT,
     OPT_PAUSE_ON_EXIT,
     OPT_LIST_CAMERAS,
     OPT_LIST_CAMERA_SIZES,
+    OPT_CAMERA_ID,
+    OPT_CAMERA_SIZE,
+    OPT_CAMERA_FACING,
 };
 
 struct sc_option {
@@ -199,6 +203,27 @@ static const struct sc_option options[] = {
         .longopt = "bit-rate",
         .argdesc = "value",
     },
+    {
+        .longopt_id = OPT_CAMERA_ID,
+        .longopt = "camera-id",
+        .argdesc = "id",
+        .text = "Specify the device camera id to mirror.\n"
+                "The available camera ids can be listed by:\n"
+                "    scrcpy --list-cameras",
+    },
+    {
+        .longopt_id = OPT_CAMERA_FACING,
+        .longopt = "camera-facing",
+        .argdesc = "facing",
+        .text = "Select the device camera by its facing direction.\n"
+                "Possible values are \"front\", \"back\" and \"external\".",
+    },
+    {
+        .longopt_id = OPT_CAMERA_SIZE,
+        .longopt = "camera-size",
+        .argdesc = "<width>x<height>",
+        .text = "Specify an explicit camera capture size.",
+    },
     {
         // Not really deprecated (--codec has never been released), but without
         // declaring an explicit --codec option, getopt_long() partial matching
@@ -703,6 +728,13 @@ static const struct sc_option options[] = {
                 "codec provided by --video-codec).\n"
                 "The available encoders can be listed by --list-encoders.",
     },
+    {
+        .longopt_id = OPT_VIDEO_SOURCE,
+        .longopt = "video-source",
+        .argdesc = "source",
+        .text = "Select the video source (display or camera).\n"
+                "Default is display.",
+    },
     {
         .shortopt = 'w',
         .longopt = "stay-awake",
@@ -1643,6 +1675,22 @@ parse_audio_codec(const char *optarg, enum sc_codec *codec) {
     return false;
 }
 
+static bool
+parse_video_source(const char *optarg, enum sc_video_source *source) {
+    if (!strcmp(optarg, "display")) {
+        *source = SC_VIDEO_SOURCE_DISPLAY;
+        return true;
+    }
+
+    if (!strcmp(optarg, "camera")) {
+        *source = SC_VIDEO_SOURCE_CAMERA;
+        return true;
+    }
+
+    LOGE("Unsupported video source: %s (expected display or camera)", optarg);
+    return false;
+}
+
 static bool
 parse_audio_source(const char *optarg, enum sc_audio_source *source) {
     if (!strcmp(optarg, "mic")) {
@@ -1659,6 +1707,34 @@ parse_audio_source(const char *optarg, enum sc_audio_source *source) {
     return false;
 }
 
+static bool
+parse_camera_facing(const char *optarg, enum sc_camera_facing *facing) {
+    if (!strcmp(optarg, "front")) {
+        *facing = SC_CAMERA_FACING_FRONT;
+        return true;
+    }
+
+    if (!strcmp(optarg, "back")) {
+        *facing = SC_CAMERA_FACING_BACK;
+        return true;
+    }
+
+    if (!strcmp(optarg, "external")) {
+        *facing = SC_CAMERA_FACING_EXTERNAL;
+        return true;
+    }
+
+    if (*optarg == '\0') {
+        // Empty string is a valid value (equivalent to not passing the option)
+        *facing = SC_CAMERA_FACING_ANY;
+        return true;
+    }
+
+    LOGE("Unsupported camera facing: %s (expected front, back or external)",
+         optarg);
+    return false;
+}
+
 static bool
 parse_time_limit(const char *s, sc_tick *tick) {
     long value;
@@ -2030,6 +2106,11 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                     return false;
                 }
                 break;
+            case OPT_VIDEO_SOURCE:
+                if (!parse_video_source(optarg, &opts->video_source)) {
+                    return false;
+                }
+                break;
             case OPT_AUDIO_SOURCE:
                 if (!parse_audio_source(optarg, &opts->audio_source)) {
                     return false;
@@ -2048,6 +2129,17 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                     return false;
                 }
                 break;
+            case OPT_CAMERA_ID:
+                opts->camera_id = optarg;
+                break;
+            case OPT_CAMERA_SIZE:
+                opts->camera_size = optarg;
+                break;
+            case OPT_CAMERA_FACING:
+                if (!parse_camera_facing(optarg, &opts->camera_facing)) {
+                    return false;
+                }
+                break;
             default:
                 // getopt prints the error message on stderr
                 return false;
@@ -2141,6 +2233,49 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
         opts->force_adb_forward = true;
     }
 
+    if (opts->video_source == SC_VIDEO_SOURCE_CAMERA) {
+        if (opts->display_id) {
+            LOGE("--display-id is only available with --video-source=display");
+            return false;
+        }
+
+        if (opts->lock_video_orientation !=
+                SC_LOCK_VIDEO_ORIENTATION_UNLOCKED) {
+            LOGE("--lock-video-orientation is not supported for camera");
+            return false;
+        }
+
+        if (opts->camera_id && opts->camera_facing != SC_CAMERA_FACING_ANY) {
+            LOGE("Could not specify both --camera-id and --camera-facing");
+            return false;
+        }
+
+        if (!opts->camera_size) {
+            LOGE("Camera size must be specified by --camera-size=WIDTHxHEIGHT");
+            return false;
+        }
+
+        if (opts->control) {
+            LOGI("Camera video source: control disabled");
+            opts->control = false;
+        }
+    } else if (opts->camera_id
+            || opts->camera_facing != SC_CAMERA_FACING_ANY
+            || opts->camera_size) {
+        LOGE("Camera options are only available with --video-source=camera");
+        return false;
+    }
+
+    if (opts->audio && opts->audio_source == SC_AUDIO_SOURCE_AUTO) {
+        // Select the audio source according to the video source
+        if (opts->video_source == SC_VIDEO_SOURCE_DISPLAY) {
+            opts->audio_source = SC_AUDIO_SOURCE_OUTPUT;
+        } else {
+            opts->audio_source = SC_AUDIO_SOURCE_MIC;
+            LOGI("Camera video source: microphone audio source selected");
+        }
+    }
+
     if (opts->record_format && !opts->record_filename) {
         LOGE("Record format specified without recording");
         return false;

app/src/options.c

@@ -11,13 +11,17 @@ const struct scrcpy_options scrcpy_options_default = {
     .audio_codec_options = NULL,
     .video_encoder = NULL,
     .audio_encoder = NULL,
+    .camera_id = NULL,
+    .camera_size = NULL,
     .log_level = SC_LOG_LEVEL_INFO,
     .video_codec = SC_CODEC_H264,
     .audio_codec = SC_CODEC_OPUS,
-    .audio_source = SC_AUDIO_SOURCE_OUTPUT,
+    .video_source = SC_VIDEO_SOURCE_DISPLAY,
+    .audio_source = SC_AUDIO_SOURCE_AUTO,
     .record_format = SC_RECORD_FORMAT_AUTO,
     .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT,
     .mouse_input_mode = SC_MOUSE_INPUT_MODE_INJECT,
+    .camera_facing = SC_CAMERA_FACING_ANY,
     .port_range = {
         .first = DEFAULT_LOCAL_PORT_RANGE_FIRST,
         .last = DEFAULT_LOCAL_PORT_RANGE_LAST,

app/src/options.h

@@ -44,11 +44,24 @@ enum sc_codec {
     SC_CODEC_RAW,
 };
 
+enum sc_video_source {
+    SC_VIDEO_SOURCE_DISPLAY,
+    SC_VIDEO_SOURCE_CAMERA,
+};
+
 enum sc_audio_source {
+    SC_AUDIO_SOURCE_AUTO, // OUTPUT for video DISPLAY, MIC for video CAMERA
     SC_AUDIO_SOURCE_OUTPUT,
     SC_AUDIO_SOURCE_MIC,
 };
 
+enum sc_camera_facing {
+    SC_CAMERA_FACING_ANY,
+    SC_CAMERA_FACING_FRONT,
+    SC_CAMERA_FACING_BACK,
+    SC_CAMERA_FACING_EXTERNAL,
+};
+
 enum sc_lock_video_orientation {
     SC_LOCK_VIDEO_ORIENTATION_UNLOCKED = -1,
     // lock the current orientation when scrcpy starts
@@ -117,13 +130,17 @@ struct scrcpy_options {
     const char *audio_codec_options;
     const char *video_encoder;
     const char *audio_encoder;
+    const char *camera_id;
+    const char *camera_size;
     enum sc_log_level log_level;
     enum sc_codec video_codec;
     enum sc_codec audio_codec;
+    enum sc_video_source video_source;
     enum sc_audio_source audio_source;
     enum sc_record_format record_format;
     enum sc_keyboard_input_mode keyboard_input_mode;
     enum sc_mouse_input_mode mouse_input_mode;
+    enum sc_camera_facing camera_facing;
     struct sc_port_range port_range;
     uint32_t tunnel_host;
     uint16_t tunnel_port;

app/src/scrcpy.c

@@ -351,7 +351,9 @@ scrcpy(struct scrcpy_options *options) {
         .log_level = options->log_level,
         .video_codec = options->video_codec,
         .audio_codec = options->audio_codec,
+        .video_source = options->video_source,
         .audio_source = options->audio_source,
+        .camera_facing = options->camera_facing,
         .crop = options->crop,
         .port_range = options->port_range,
         .tunnel_host = options->tunnel_host,
@@ -371,6 +373,8 @@ scrcpy(struct scrcpy_options *options) {
         .audio_codec_options = options->audio_codec_options,
         .video_encoder = options->video_encoder,
         .audio_encoder = options->audio_encoder,
+        .camera_id = options->camera_id,
+        .camera_size = options->camera_size,
         .force_adb_forward = options->force_adb_forward,
         .power_off_on_close = options->power_off_on_close,
         .clipboard_autosync = options->clipboard_autosync,

app/src/server.c

@@ -76,6 +76,7 @@ sc_server_params_destroy(struct sc_server_params *params) {
     free((char *) params->video_encoder);
     free((char *) params->audio_encoder);
     free((char *) params->tcpip_dst);
+    free((char *) params->camera_id);
 }
 
 static bool
@@ -103,6 +104,7 @@ sc_server_params_copy(struct sc_server_params *dst,
     COPY(video_encoder);
     COPY(audio_encoder);
     COPY(tcpip_dst);
+    COPY(camera_id);
 #undef COPY
 
     return true;
@@ -181,6 +183,20 @@ sc_server_get_codec_name(enum sc_codec codec) {
     }
 }
 
+static const char *
+sc_server_get_camera_facing_name(enum sc_camera_facing camera_facing) {
+    switch (camera_facing) {
+        case SC_CAMERA_FACING_FRONT:
+            return "front";
+        case SC_CAMERA_FACING_BACK:
+            return "back";
+        case SC_CAMERA_FACING_EXTERNAL:
+            return "external";
+        default:
+            return NULL;
+    }
+}
+
 static sc_pid
 execute_server(struct sc_server *server,
                const struct sc_server_params *params) {
@@ -247,8 +263,11 @@ execute_server(struct sc_server *server,
         ADD_PARAM("audio_codec=%s",
             sc_server_get_codec_name(params->audio_codec));
     }
-    if (params->audio_source != SC_AUDIO_SOURCE_OUTPUT) {
-        assert(params->audio_source == SC_AUDIO_SOURCE_MIC);
+    if (params->video_source != SC_VIDEO_SOURCE_DISPLAY) {
+        assert(params->video_source == SC_VIDEO_SOURCE_CAMERA);
+        ADD_PARAM("video_source=camera");
+    }
+    if (params->audio_source == SC_AUDIO_SOURCE_MIC) {
         ADD_PARAM("audio_source=mic");
     }
     if (params->max_size) {
@@ -274,6 +293,16 @@ execute_server(struct sc_server *server,
     if (params->display_id) {
         ADD_PARAM("display_id=%" PRIu32, params->display_id);
     }
+    if (params->camera_id) {
+        ADD_PARAM("camera_id=%s", params->camera_id);
+    }
+    if (params->camera_size) {
+        ADD_PARAM("camera_size=%s", params->camera_size);
+    }
+    if (params->camera_facing != SC_CAMERA_FACING_ANY) {
+        ADD_PARAM("camera_facing=%s",
+            sc_server_get_camera_facing_name(params->camera_facing));
+    }
     if (params->show_touches) {
         ADD_PARAM("show_touches=true");
     }

app/src/server.h

@@ -26,12 +26,16 @@ struct sc_server_params {
     enum sc_log_level log_level;
     enum sc_codec video_codec;
     enum sc_codec audio_codec;
+    enum sc_video_source video_source;
     enum sc_audio_source audio_source;
+    enum sc_camera_facing camera_facing;
     const char *crop;
     const char *video_codec_options;
     const char *audio_codec_options;
     const char *video_encoder;
     const char *audio_encoder;
+    const char *camera_id;
+    const char *camera_size;
     struct sc_port_range port_range;
     uint32_t tunnel_host;
     uint16_t tunnel_port;

server/src/main/java/com/genymobile/scrcpy/CameraCapture.java

@@ -0,0 +1,255 @@
+package com.genymobile.scrcpy;
+
+import com.genymobile.scrcpy.wrappers.ServiceManager;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.hardware.camera2.CameraAccessException;
+import android.hardware.camera2.CameraCaptureSession;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraDevice;
+import android.hardware.camera2.CameraManager;
+import android.hardware.camera2.CaptureFailure;
+import android.hardware.camera2.CaptureRequest;
+import android.hardware.camera2.params.OutputConfiguration;
+import android.hardware.camera2.params.SessionConfiguration;
+import android.os.Build;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.view.Surface;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class CameraCapture extends SurfaceCapture {
+
+    public static class CameraSelection {
+        private String explicitCameraId;
+        private CameraFacing cameraFacing;
+
+        public CameraSelection(String explicitCameraId, CameraFacing cameraFacing) {
+            this.explicitCameraId = explicitCameraId;
+            this.cameraFacing = cameraFacing;
+        }
+
+        boolean hasId() {
+            return explicitCameraId != null;
+        }
+
+        boolean hasProperties() {
+            return cameraFacing != null;
+        }
+    }
+
+    private final CameraSelection cameraSelection;
+    private final Size explicitSize;
+
+    private HandlerThread cameraThread;
+    private Handler cameraHandler;
+    private CameraDevice cameraDevice;
+    private Executor cameraExecutor;
+
+    private final AtomicBoolean disconnected = new AtomicBoolean();
+
+    public CameraCapture(CameraSelection cameraSelection, Size explicitSize) {
+        this.cameraSelection = cameraSelection;
+        this.explicitSize = explicitSize;
+    }
+
+    @Override
+    public void init() throws IOException {
+        cameraThread = new HandlerThread("camera");
+        cameraThread.start();
+        cameraHandler = new Handler(cameraThread.getLooper());
+        cameraExecutor = new HandlerExecutor(cameraHandler);
+
+        try {
+            String cameraId = selectCamera(cameraSelection);
+            if (cameraId == null) {
+                throw new IOException("No matching camera found");
+            }
+
+            Ln.i("Using camera '" + cameraId + "'");
+            cameraDevice = openCamera(cameraId);
+        } catch (CameraAccessException | InterruptedException e) {
+            throw new IOException(e);
+        }
+    }
+
+    private String selectCamera(CameraSelection cameraSelection) throws CameraAccessException {
+        if (cameraSelection.hasId()) {
+            return cameraSelection.explicitCameraId;
+        }
+
+        CameraManager cameraManager = ServiceManager.getCameraManager();
+
+        String[] cameraIds = cameraManager.getCameraIdList();
+        if (!cameraSelection.hasProperties()) {
+            // Use the first one
+            return cameraIds.length > 0 ? cameraIds[0] : null;
+        }
+
+        for (String cameraId : cameraIds) {
+            CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
+
+            if (cameraSelection.cameraFacing != null) {
+                int facing = characteristics.get(CameraCharacteristics.LENS_FACING);
+                if (cameraSelection.cameraFacing.value() != facing) {
+                    // Does not match
+                    continue;
+                }
+            }
+
+            return cameraId;
+        }
+
+        // Not found
+        return null;
+    }
+
+    @Override
+    public void start(Surface surface) throws IOException {
+        try {
+            CameraCaptureSession session = createCaptureSession(cameraDevice, surface);
+            CaptureRequest.Builder requestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
+            requestBuilder.addTarget(surface);
+            CaptureRequest request = requestBuilder.build();
+            setRepeatingRequest(session, request);
+        } catch (CameraAccessException | InterruptedException e) {
+            throw new IOException(e);
+        }
+    }
+
+    @Override
+    public void release() {
+        if (cameraDevice != null) {
+            cameraDevice.close();
+        }
+        if (cameraThread != null) {
+            cameraThread.quitSafely();
+        }
+    }
+
+    @Override
+    public Size getSize() {
+        return explicitSize;
+    }
+
+    @Override
+    public boolean setMaxSize(int size) {
+        return false;
+    }
+
+    @SuppressLint("MissingPermission")
+    @TargetApi(Build.VERSION_CODES.S)
+    private CameraDevice openCamera(String id) throws CameraAccessException, InterruptedException {
+        Ln.v("Open Camera: " + id);
+
+        CompletableFuture<CameraDevice> future = new CompletableFuture<>();
+        ServiceManager.getCameraManager().openCamera(id, new CameraDevice.StateCallback() {
+            @Override
+            public void onOpened(CameraDevice camera) {
+                Ln.v("Open Camera Success");
+                future.complete(camera);
+            }
+
+            @Override
+            public void onDisconnected(CameraDevice camera) {
+                Ln.w("Camera disconnected");
+                disconnected.set(true);
+                requestReset();
+            }
+
+            @Override
+            public void onError(CameraDevice camera, int error) {
+                int cameraAccessExceptionErrorCode;
+                switch (error) {
+                    case CameraDevice.StateCallback.ERROR_CAMERA_IN_USE:
+                        cameraAccessExceptionErrorCode = CameraAccessException.CAMERA_IN_USE;
+                        break;
+                    case CameraDevice.StateCallback.ERROR_MAX_CAMERAS_IN_USE:
+                        cameraAccessExceptionErrorCode = CameraAccessException.MAX_CAMERAS_IN_USE;
+                        break;
+                    case CameraDevice.StateCallback.ERROR_CAMERA_DISABLED:
+                        cameraAccessExceptionErrorCode = CameraAccessException.CAMERA_DISABLED;
+                        break;
+                    case CameraDevice.StateCallback.ERROR_CAMERA_DEVICE:
+                    case CameraDevice.StateCallback.ERROR_CAMERA_SERVICE:
+                    default:
+                        cameraAccessExceptionErrorCode = CameraAccessException.CAMERA_ERROR;
+                        break;
+                }
+                future.completeExceptionally(new CameraAccessException(cameraAccessExceptionErrorCode));
+            }
+        }, cameraHandler);
+
+        try {
+            return future.get();
+        } catch (ExecutionException e) {
+            throw (CameraAccessException) e.getCause();
+        }
+    }
+
+    @TargetApi(Build.VERSION_CODES.S)
+    private CameraCaptureSession createCaptureSession(CameraDevice camera, Surface surface) throws CameraAccessException, InterruptedException {
+        Ln.d("Create Capture Session");
+
+        CompletableFuture<CameraCaptureSession> future = new CompletableFuture<>();
+        // replace by createCaptureSession(SessionConfiguration)
+        OutputConfiguration outputConfig = new OutputConfiguration(surface);
+        List<OutputConfiguration> outputs = Arrays.asList(outputConfig);
+        SessionConfiguration sessionConfig = new SessionConfiguration(SessionConfiguration.SESSION_REGULAR, outputs, cameraExecutor,
+                new CameraCaptureSession.StateCallback() {
+                    @Override
+                    public void onConfigured(CameraCaptureSession session) {
+                        Ln.d("Create Capture Session Success");
+                        future.complete(session);
+                    }
+
+                    @Override
+                    public void onConfigureFailed(CameraCaptureSession session) {
+                        future.completeExceptionally(new CameraAccessException(CameraAccessException.CAMERA_ERROR));
+                    }
+                });
+
+        camera.createCaptureSession(sessionConfig);
+
+        try {
+            return future.get();
+        } catch (ExecutionException e) {
+            throw (CameraAccessException) e.getCause();
+        }
+    }
+
+    @TargetApi(Build.VERSION_CODES.S)
+    private void setRepeatingRequest(CameraCaptureSession session, CaptureRequest request) throws CameraAccessException, InterruptedException {
+        CompletableFuture<Void> future = new CompletableFuture<>();
+        session.setRepeatingRequest(request, new CameraCaptureSession.CaptureCallback() {
+            @Override
+            public void onCaptureStarted(CameraCaptureSession session, CaptureRequest request, long timestamp, long frameNumber) {
+                future.complete(null);
+            }
+
+            @Override
+            public void onCaptureFailed(CameraCaptureSession session, CaptureRequest request, CaptureFailure failure) {
+                future.completeExceptionally(new CameraAccessException(CameraAccessException.CAMERA_ERROR));
+            }
+        }, cameraHandler);
+
+        try {
+            future.get();
+        } catch (ExecutionException e) {
+            throw (CameraAccessException) e.getCause();
+        }
+    }
+
+    @Override
+    public boolean isClosed() {
+        return disconnected.get();
+    }
+}

server/src/main/java/com/genymobile/scrcpy/CameraFacing.java

@@ -0,0 +1,31 @@
+package com.genymobile.scrcpy;
+
+import android.hardware.camera2.CameraCharacteristics;
+
+public enum CameraFacing {
+    FRONT("front", CameraCharacteristics.LENS_FACING_FRONT),
+    BACK("back", CameraCharacteristics.LENS_FACING_BACK),
+    EXTERNAL("external", CameraCharacteristics.LENS_FACING_EXTERNAL);
+
+    private final String name;
+    private final int value;
+
+    CameraFacing(String name, int value) {
+        this.name = name;
+        this.value = value;
+    }
+
+    int value() {
+        return value;
+    }
+
+    static CameraFacing findByName(String name) {
+        for (CameraFacing facing : CameraFacing.values()) {
+            if (name.equals(facing.name)) {
+                return facing;
+            }
+        }
+
+        return null;
+    }
+}

server/src/main/java/com/genymobile/scrcpy/HandlerExecutor.java

@@ -0,0 +1,23 @@
+package com.genymobile.scrcpy;
+
+import android.os.Handler;
+
+import java.util.concurrent.Executor;
+import java.util.concurrent.RejectedExecutionException;
+
+// Inspired from hidden android.os.HandlerExecutor
+
+public class HandlerExecutor implements Executor {
+    private final Handler handler;
+
+    public HandlerExecutor(Handler handler) {
+        this.handler = handler;
+    }
+
+    @Override
+    public void execute(Runnable command) {
+        if (!handler.post(command)) {
+            throw new RejectedExecutionException(handler + " is shutting down");
+        }
+    }
+}

server/src/main/java/com/genymobile/scrcpy/Options.java

@@ -14,6 +14,7 @@ public class Options {
     private int maxSize;
     private VideoCodec videoCodec = VideoCodec.H264;
     private AudioCodec audioCodec = AudioCodec.OPUS;
+    private VideoSource videoSource = VideoSource.DISPLAY;
     private AudioSource audioSource = AudioSource.OUTPUT;
     private int videoBitRate = 8000000;
     private int audioBitRate = 128000;
@@ -23,6 +24,9 @@ public class Options {
     private Rect crop;
     private boolean control = true;
     private int displayId;
+    private String cameraId;
+    private Size cameraSize;
+    private CameraFacing cameraFacing;
     private boolean showTouches;
     private boolean stayAwake;
     private List<CodecOption> videoCodecOptions;
@@ -75,6 +79,10 @@ public class Options {
         return audioCodec;
     }
 
+    public VideoSource getVideoSource() {
+        return videoSource;
+    }
+
     public AudioSource getAudioSource() {
         return audioSource;
     }
@@ -111,6 +119,18 @@ public class Options {
         return displayId;
     }
 
+    public String getCameraId() {
+        return cameraId;
+    }
+
+    public Size getCameraSize() {
+        return cameraSize;
+    }
+
+    public CameraFacing getCameraFacing() {
+        return cameraFacing;
+    }
+
     public boolean getShowTouches() {
         return showTouches;
     }
@@ -244,6 +264,13 @@ public class Options {
                     }
                     options.audioCodec = audioCodec;
                     break;
+                case "video_source":
+                    VideoSource videoSource = VideoSource.findByName(value);
+                    if (videoSource == null) {
+                        throw new IllegalArgumentException("Video source " + value + " not supported");
+                    }
+                    options.videoSource = videoSource;
+                    break;
                 case "audio_source":
                     AudioSource audioSource = AudioSource.findByName(value);
                     if (audioSource == null) {
@@ -328,6 +355,23 @@ public class Options {
                 case "list_camera_sizes":
                     options.listCameraSizes = Boolean.parseBoolean(value);
                     break;
+                case "camera_id":
+                    if (!value.isEmpty()) {
+                        options.cameraId = value;
+                    }
+                    break;
+                case "camera_size":
+                    options.cameraSize = parseSize(value);
+                    break;
+                case "camera_facing":
+                    if (!value.isEmpty()) {
+                        CameraFacing facing = CameraFacing.findByName(value);
+                        if (facing == null) {
+                            throw new IllegalArgumentException("Camera facing " + value + " not supported");
+                        }
+                        options.cameraFacing = facing;
+                    }
+                    break;
                 case "send_device_meta":
                     options.sendDeviceMeta = Boolean.parseBoolean(value);
                     break;
@@ -370,4 +414,18 @@ public class Options {
         int y = Integer.parseInt(tokens[3]);
         return new Rect(x, y, x + width, y + height);
     }
+
+    private static Size parseSize(String size) {
+        if (size.isEmpty()) {
+            return null;
+        }
+        // input format: "<width>x<height>"
+        String[] tokens = size.split("x");
+        if (tokens.length != 2) {
+            throw new IllegalArgumentException("Invalid size format (expected <width>x<height>): \"" + size + "\"");
+        }
+        int width = Integer.parseInt(tokens[0]);
+        int height = Integer.parseInt(tokens[1]);
+        return new Size(width, height);
+    }
 }

server/src/main/java/com/genymobile/scrcpy/ScreenCapture.java

@@ -48,8 +48,9 @@ public class ScreenCapture extends SurfaceCapture implements Device.RotationList
     }
 
     @Override
-    public void setMaxSize(int size) {
+    public boolean setMaxSize(int size) {
         device.setMaxSize(size);
+        return true;
     }
 
     @Override

server/src/main/java/com/genymobile/scrcpy/Server.java

@@ -134,10 +134,17 @@ public final class Server {
             if (video) {
                 Streamer videoStreamer = new Streamer(connection.getVideoFd(), options.getVideoCodec(), options.getSendCodecMeta(),
                         options.getSendFrameMeta());
-                ScreenCapture screenCapture = new ScreenCapture(device);
-                SurfaceEncoder screenEncoder = new SurfaceEncoder(screenCapture, videoStreamer, options.getVideoBitRate(), options.getMaxFps(),
+                SurfaceCapture surfaceCapture;
+                if (options.getVideoSource() == VideoSource.DISPLAY) {
+                    surfaceCapture = new ScreenCapture(device);
+                } else {
+                    CameraCapture.CameraSelection cameraSelection = new CameraCapture.CameraSelection(options.getCameraId(),
+                            options.getCameraFacing());
+                    surfaceCapture = new CameraCapture(cameraSelection, options.getCameraSize());
+                }
+                SurfaceEncoder surfaceEncoder = new SurfaceEncoder(surfaceCapture, videoStreamer, options.getVideoBitRate(), options.getMaxFps(),
                         options.getVideoCodecOptions(), options.getVideoEncoder(), options.getDownsizeOnError());
-                asyncProcessors.add(screenEncoder);
+                asyncProcessors.add(surfaceEncoder);
             }
 
             Completion completion = new Completion(asyncProcessors.size());

server/src/main/java/com/genymobile/scrcpy/SurfaceCapture.java

@@ -2,6 +2,7 @@ package com.genymobile.scrcpy;
 
 import android.view.Surface;
 
+import java.io.IOException;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
@@ -31,7 +32,7 @@ public abstract class SurfaceCapture {
     /**
      * Called once before the capture starts.
      */
-    public abstract void init();
+    public abstract void init() throws IOException;
 
     /**
      * Called after the capture ends (if and only if {@link #init()} has been called).
@@ -43,7 +44,7 @@ public abstract class SurfaceCapture {
      *
      * @param surface the surface which will be encoded
      */
-    public abstract void start(Surface surface);
+    public abstract void start(Surface surface) throws IOException;
 
     /**
      * Return the video size
@@ -57,5 +58,14 @@ public abstract class SurfaceCapture {
      *
      * @param size Maximum size
      */
-    public abstract void setMaxSize(int size);
+    public abstract boolean setMaxSize(int size);
+
+    /**
+     * Indicate if the capture has been closed internally.
+     *
+     * @return {@code true} is the capture is closed, {@code false} otherwise.
+     */
+    public boolean isClosed() {
+        return false;
+    }
 }

server/src/main/java/com/genymobile/scrcpy/SurfaceEncoder.java

@@ -122,9 +122,13 @@ public class SurfaceEncoder implements AsyncProcessor {
             return false;
         }
 
-        // Retry with a smaller device size
+        boolean accepted = capture.setMaxSize(newMaxSize);
+        if (!accepted) {
+            return false;
+        }
+
+        // Retry with a smaller size
         Ln.i("Retrying with -m" + newMaxSize + "...");
-        capture.setMaxSize(newMaxSize);
         return true;
     }
 
@@ -177,6 +181,11 @@ public class SurfaceEncoder implements AsyncProcessor {
             }
         }
 
+        if (capture.isClosed()) {
+            // The capture might have been closed internally (for example if the camera is disconnected)
+            alive = false;
+        }
+
         return !eof && alive;
     }
 

server/src/main/java/com/genymobile/scrcpy/VideoSource.java

@@ -0,0 +1,24 @@
+package com.genymobile.scrcpy;
+
+import android.media.MediaRecorder;
+
+public enum VideoSource {
+    DISPLAY("display"),
+    CAMERA("camera");
+
+    private final String name;
+
+    VideoSource(String name) {
+        this.name = name;
+    }
+
+    static VideoSource findByName(String name) {
+        for (VideoSource videoSource : VideoSource.values()) {
+            if (name.equals(videoSource.name)) {
+                return videoSource;
+            }
+        }
+
+        return null;
+    }
+}

server/src/main/java/com/genymobile/scrcpy/Workarounds.java

@@ -32,7 +32,7 @@ public final class Workarounds {
         Workarounds.prepareMainLooper();
 
         boolean mustFillAppInfo = false;
-        boolean mustFillBaseContext = false;
+        boolean mustFillBaseContext = true;
         boolean mustFillAppContext = false;
 
         if (Build.BRAND.equalsIgnoreCase("meizu")) {