Enforce monotonical PTS

Audio PTS may come from two sources:
 - recorder.getTimestamp() if the call works;
 - an estimation from the previous PTS and the packet size as a
   fallback.

Therefore, the property that PTS are monotonically increasing is no
guaranteed in corner cases, so enforce it.

README.md

@@ -194,6 +194,18 @@ The other dimension is computed so that the Android device aspect ratio is
 preserved. That way, a device in 1920×1080 will be mirrored at 1024×576.
 
 
+#### Select codec
+
+The video codec can be selected. The possible values are `h264` (default),
+`h265` and `av1`:
+
+```bash
+scrcpy --codec=h264  # default
+scrcpy --codec=h265
+scrcpy --codec=av1
+```
+
+
 #### Change bit-rate
 
 The default bit-rate is 8 Mbps. To change the video bitrate (e.g. to 2 Mbps):
@@ -254,8 +266,8 @@ The [window may also be rotated](#rotation) independently.
 
 #### Encoder
 
-Some devices have more than one encoder, and some of them may cause issues or
-crash. It is possible to select a different encoder:
+Some devices have more than one encoder for a specific codec, and some of them
+may cause issues or crash. It is possible to select a different encoder:
 
 ```bash
 scrcpy --encoder=OMX.qcom.video.encoder.avc
@@ -268,6 +280,8 @@ error will give the available encoders:
 scrcpy --encoder=_
 ```
 
+Note that you can also select a different [codec](#select-codec).
+
 ### Capture
 
 #### Recording

app/scrcpy.1

@@ -25,6 +25,10 @@ Encode the video at the given bit\-rate, expressed in bits/s. Unit suffixes are
 
 Default is 8000000.
 
+.TP
+.BI "\-\-codec " name
+Select a video codec (h264, h265 or av1).
+
 .TP
 .BI "\-\-codec\-options " key\fR[:\fItype\fR]=\fIvalue\fR[,...]
 Set a list of comma-separated key:type=value options for the device encoder.

app/src/cli.c

@@ -57,6 +57,7 @@
 #define OPT_NO_CLEANUP             1037
 #define OPT_PRINT_FPS              1038
 #define OPT_NO_POWER_ON            1039
+#define OPT_CODEC                  1040
 
 struct sc_option {
     char shortopt;
@@ -105,6 +106,12 @@ static const struct sc_option options[] = {
                 "Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
                 "Default is " STR(DEFAULT_BIT_RATE) ".",
     },
+    {
+        .longopt_id = OPT_CODEC,
+        .longopt = "codec",
+        .argdesc = "name",
+        .text = "Select a video codec (h264, h265 or av1).",
+    },
     {
         .longopt_id = OPT_CODEC_OPTIONS,
         .longopt = "codec-options",
@@ -1377,6 +1384,24 @@ guess_record_format(const char *filename) {
     return 0;
 }
 
+static bool
+parse_codec(const char *optarg, enum sc_codec *codec) {
+    if (!strcmp(optarg, "h264")) {
+        *codec = SC_CODEC_H264;
+        return true;
+    }
+    if (!strcmp(optarg, "h265")) {
+        *codec = SC_CODEC_H265;
+        return true;
+    }
+    if (!strcmp(optarg, "av1")) {
+        *codec = SC_CODEC_AV1;
+        return true;
+    }
+    LOGE("Unsupported codec: %s (expected h264, h265 or av1)", optarg);
+    return false;
+}
+
 static bool
 parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                        const char *optstring, const struct option *longopts) {
@@ -1610,6 +1635,11 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
             case OPT_PRINT_FPS:
                 opts->start_fps_counter = true;
                 break;
+            case OPT_CODEC:
+                if (!parse_codec(optarg, &opts->codec)) {
+                    return false;
+                }
+                break;
             case OPT_OTG:
 #ifdef HAVE_USB
                 opts->otg = true;
@@ -1718,6 +1748,13 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
         }
     }
 
+    if (opts->record_format == SC_RECORD_FORMAT_MP4
+            && opts->codec == SC_CODEC_AV1) {
+        LOGE("Could not mux AV1 stream into MP4 container "
+             "(record to mkv or select another video codec)");
+        return false;
+    }
+
     if (!opts->control) {
         if (opts->turn_screen_off) {
             LOGE("Could not request to turn screen off if control is disabled");

app/src/demuxer.c

@@ -17,6 +17,31 @@
 
 #define SC_PACKET_PTS_MASK (SC_PACKET_FLAG_KEY_FRAME - 1)
 
+static enum AVCodecID
+sc_demuxer_recv_codec_id(struct sc_demuxer *demuxer) {
+    uint8_t data[4];
+    ssize_t r = net_recv_all(demuxer->socket, data, 4);
+    if (r < 4) {
+        return false;
+    }
+
+#define SC_CODEC_ID_H264 UINT32_C(0x68323634) // "h264" in ASCII
+#define SC_CODEC_ID_H265 UINT32_C(0x68323635) // "h265" in ASCII
+#define SC_CODEC_ID_AV1 UINT32_C(0x00617631) // "av1" in ASCII
+    uint32_t codec_id = sc_read32be(data);
+    switch (codec_id) {
+        case SC_CODEC_ID_H264:
+            return AV_CODEC_ID_H264;
+        case SC_CODEC_ID_H265:
+            return AV_CODEC_ID_HEVC;
+        case SC_CODEC_ID_AV1:
+            return AV_CODEC_ID_AV1;
+        default:
+            LOGE("Unknown codec id 0x%08" PRIx32, codec_id);
+            return AV_CODEC_ID_NONE;
+    }
+}
+
 static bool
 sc_demuxer_recv_packet(struct sc_demuxer *demuxer, AVPacket *packet) {
     // The video stream contains raw packets, without time information. When we
@@ -171,7 +196,13 @@ static int
 run_demuxer(void *data) {
     struct sc_demuxer *demuxer = data;
 
-    const AVCodec *codec = avcodec_find_decoder(AV_CODEC_ID_H264);
+    enum AVCodecID codec_id = sc_demuxer_recv_codec_id(demuxer);
+    if (codec_id == AV_CODEC_ID_NONE) {
+        // Error already logged
+        goto end;
+    }
+
+    const AVCodec *codec = avcodec_find_decoder(codec_id);
     if (!codec) {
         LOGE("H.264 decoder not found");
         goto end;
@@ -188,7 +219,7 @@ run_demuxer(void *data) {
         goto finally_free_codec_ctx;
     }
 
-    demuxer->parser = av_parser_init(AV_CODEC_ID_H264);
+    demuxer->parser = av_parser_init(codec_id);
     if (!demuxer->parser) {
         LOGE("Could not initialize parser");
         goto finally_close_sinks;

app/src/options.c

@@ -13,6 +13,7 @@ const struct scrcpy_options scrcpy_options_default = {
     .v4l2_device = NULL,
 #endif
     .log_level = SC_LOG_LEVEL_INFO,
+    .codec = SC_CODEC_H264,
     .record_format = SC_RECORD_FORMAT_AUTO,
     .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT,
     .port_range = {

app/src/options.h

@@ -23,6 +23,12 @@ enum sc_record_format {
     SC_RECORD_FORMAT_MKV,
 };
 
+enum sc_codec {
+    SC_CODEC_H264,
+    SC_CODEC_H265,
+    SC_CODEC_AV1,
+};
+
 enum sc_lock_video_orientation {
     SC_LOCK_VIDEO_ORIENTATION_UNLOCKED = -1,
     // lock the current orientation when scrcpy starts
@@ -93,6 +99,7 @@ struct scrcpy_options {
     const char *v4l2_device;
 #endif
     enum sc_log_level log_level;
+    enum sc_codec codec;
     enum sc_record_format record_format;
     enum sc_keyboard_input_mode keyboard_input_mode;
     enum sc_mouse_input_mode mouse_input_mode;

app/src/scrcpy.c

@@ -315,6 +315,7 @@ scrcpy(struct scrcpy_options *options) {
         .select_usb = options->select_usb,
         .select_tcpip = options->select_tcpip,
         .log_level = options->log_level,
+        .codec = options->codec,
         .crop = options->crop,
         .port_range = options->port_range,
         .tunnel_host = options->tunnel_host,

app/src/server.c

@@ -156,6 +156,20 @@ sc_server_sleep(struct sc_server *server, sc_tick deadline) {
     return !stopped;
 }
 
+static const char *
+sc_server_get_codec_name(enum sc_codec codec) {
+    switch (codec) {
+        case SC_CODEC_H264:
+            return "h264";
+        case SC_CODEC_H265:
+            return "h265";
+        case SC_CODEC_AV1:
+            return "av1";
+        default:
+            return NULL;
+    }
+}
+
 static sc_pid
 execute_server(struct sc_server *server,
                const struct sc_server_params *params) {
@@ -203,6 +217,9 @@ execute_server(struct sc_server *server,
     ADD_PARAM("log_level=%s", log_level_to_server_string(params->log_level));
     ADD_PARAM("bit_rate=%" PRIu32, params->bit_rate);
 
+    if (params->codec != SC_CODEC_H264) {
+        ADD_PARAM("codec=%s", sc_server_get_codec_name(params->codec));
+    }
     if (params->max_size) {
         ADD_PARAM("max_size=%" PRIu16, params->max_size);
     }

app/src/server.h

@@ -25,6 +25,7 @@ struct sc_server_params {
     uint32_t uid;
     const char *req_serial;
     enum sc_log_level log_level;
+    enum sc_codec codec;
     const char *crop;
     const char *codec_options;
     const char *encoder_name;

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

@@ -0,0 +1,207 @@
+package com.genymobile.scrcpy;
+
+import com.genymobile.scrcpy.wrappers.ServiceManager;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.content.ComponentName;
+import android.content.Intent;
+import android.media.AudioFormat;
+import android.media.AudioRecord;
+import android.media.AudioTimestamp;
+import android.media.MediaCodec;
+import android.media.MediaFormat;
+import android.media.MediaRecorder;
+import android.os.Build;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.SystemClock;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public final class AudioEncoder {
+
+    private static final String MIMETYPE = MediaFormat.MIMETYPE_AUDIO_OPUS;
+    private static final int SAMPLE_RATE = 48000;
+    private static final int CHANNELS = 2;
+    private static final int BIT_RATE = 128000;
+
+    private static int BUFFER_MS = 15; // milliseconds
+    private static final int BUFFER_SIZE = SAMPLE_RATE * CHANNELS * BUFFER_MS / 1000;
+
+    private AudioRecord recorder;
+    private MediaCodec mediaCodec;
+    private HandlerThread thread;
+    private final AtomicBoolean interrupted = new AtomicBoolean();
+    private final Semaphore endSemaphore = new Semaphore(0); // blocks until encoding is ended
+
+    private static AudioFormat createAudioFormat() {
+        AudioFormat.Builder builder = new AudioFormat.Builder();
+        builder.setEncoding(AudioFormat.ENCODING_PCM_16BIT);
+        builder.setSampleRate(SAMPLE_RATE);
+        builder.setChannelMask(CHANNELS == 2 ? AudioFormat.CHANNEL_IN_STEREO : AudioFormat.CHANNEL_IN_MONO);
+        return builder.build();
+    }
+
+    @TargetApi(Build.VERSION_CODES.M)
+    @SuppressLint({"WrongConstant", "MissingPermission"})
+    private static AudioRecord createAudioRecord() {
+        AudioRecord.Builder builder = new AudioRecord.Builder();
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            // On older APIs, Workarounds.fillAppInfo() must be called beforehand
+            builder.setContext(FakeContext.get());
+        }
+        builder.setAudioSource(MediaRecorder.AudioSource.REMOTE_SUBMIX);
+        builder.setAudioFormat(createAudioFormat());
+        builder.setBufferSizeInBytes(1024 * 1024);
+        return builder.build();
+    }
+
+    private static MediaFormat createFormat() {
+        MediaFormat format = new MediaFormat();
+        format.setString(MediaFormat.KEY_MIME, MIMETYPE);
+        format.setInteger(MediaFormat.KEY_BIT_RATE, BIT_RATE);
+        format.setInteger(MediaFormat.KEY_CHANNEL_COUNT, CHANNELS);
+        format.setInteger(MediaFormat.KEY_SAMPLE_RATE, SAMPLE_RATE);
+        return format;
+    }
+
+
+    @TargetApi(Build.VERSION_CODES.M)
+    public void start() throws IOException {
+        mediaCodec = MediaCodec.createEncoderByType(MIMETYPE); // may throw IOException
+
+        recorder = createAudioRecord();
+
+        MediaFormat format = createFormat();
+        mediaCodec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
+
+        recorder.startRecording();
+
+        thread = new HandlerThread("AudioEncoder");
+        thread.start();
+
+        class AudioEncoderCallbacks extends MediaCodec.Callback {
+
+            private final AudioTimestamp timestamp = new AudioTimestamp();
+            private long previousPts;
+            private long nextPts;
+            private boolean eofSignaled;
+            private boolean ended;
+
+            private void notifyEnded() {
+                assert !ended;
+                ended = true;
+                endSemaphore.release();
+            }
+
+            @TargetApi(Build.VERSION_CODES.N)
+            @Override
+            public void onInputBufferAvailable(MediaCodec codec, int index) {
+                if (eofSignaled) {
+                    return;
+                }
+
+                ByteBuffer inputBuffer = codec.getInputBuffer(index);
+                int r = recorder.read(inputBuffer, BUFFER_SIZE);
+
+                long pts;
+
+                int ret = recorder.getTimestamp(timestamp, AudioTimestamp.TIMEBASE_MONOTONIC);
+                if (ret == AudioRecord.SUCCESS) {
+                    pts = timestamp.nanoTime / 1000;
+                } else {
+                    if (nextPts == 0) {
+                        Ln.w("Could not get any audio timestamp");
+                    }
+                    // compute from previous timestamp and packet size
+                    pts = nextPts;
+                }
+
+                long durationMs = r * 1000 / CHANNELS / SAMPLE_RATE;
+                nextPts = pts + durationMs;
+
+                int flags = 0;
+                if (interrupted.get()) {
+                    flags = flags | MediaCodec.BUFFER_FLAG_END_OF_STREAM;
+                    eofSignaled = true;
+                }
+
+                if (previousPts != 0 && pts < previousPts) {
+                    // Audio PTS may come from two sources:
+                    //  - recorder.getTimestamp() if the call works;
+                    //  - an estimation from the previous PTS and the packet size as a fallback.
+                    //
+                    // Therefore, the property that PTS are monotonically increasing is no guaranteed in corner cases, so enforce it.
+                    pts = previousPts + 1;
+                }
+
+                codec.queueInputBuffer(index, 0, r, pts, flags);
+
+                previousPts = pts;
+            }
+
+            @Override
+            public void onOutputBufferAvailable(MediaCodec codec, int index, MediaCodec.BufferInfo bufferInfo) {
+                if (ended) {
+                    return;
+                }
+
+                ByteBuffer codecBuffer = codec.getOutputBuffer(index);
+                try {
+                    boolean isConfig = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0;
+                    long pts = bufferInfo.presentationTimeUs;
+                    Ln.i("Audio packet: pts=" + pts + " " + codecBuffer.remaining() + " bytes");
+                } finally {
+                    codec.releaseOutputBuffer(index, false);
+                }
+
+                boolean eof = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0;
+                if (eof) {
+                    notifyEnded();
+                }
+            }
+
+            @Override
+            public void onError(MediaCodec codec, MediaCodec.CodecException e) {
+                Ln.e("MediaCodec error", e);
+                if (!ended) {
+                    notifyEnded();
+                }
+            }
+
+            @Override
+            public void onOutputFormatChanged(MediaCodec codec, MediaFormat format) {
+                // ignore
+            }
+        }
+
+        mediaCodec.setCallback(new AudioEncoderCallbacks(), new Handler(thread.getLooper()));
+        mediaCodec.start();
+    }
+
+    private void waitEnded() {
+        try {
+            endSemaphore.acquire();
+        } catch (InterruptedException e) {
+            // ignore
+        }
+    }
+
+    public void stop() {
+        Ln.i("==== STOP");
+        if (thread != null) {
+            interrupted.set(true);
+            waitEnded();
+            thread.interrupt();
+            thread = null;
+            mediaCodec.stop();
+            mediaCodec.release();
+            recorder.stop();
+            Ln.i("==== STOPPED");
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+package com.genymobile.scrcpy;
+
+import android.annotation.TargetApi;
+import android.content.AttributionSource;
+import android.content.ContextWrapper;
+import android.os.Build;
+import android.os.Process;
+
+public final class FakeContext extends ContextWrapper {
+
+    public static final String PACKAGE_NAME = "com.android.shell";
+
+    private static final FakeContext INSTANCE = new FakeContext();
+
+    public static FakeContext get() {
+        return INSTANCE;
+    }
+
+    private FakeContext() {
+        super(null);
+    }
+
+    @Override
+    public String getPackageName() {
+        return PACKAGE_NAME;
+    }
+
+    @Override
+    public String getOpPackageName() {
+        return PACKAGE_NAME;
+    }
+
+    @TargetApi(Build.VERSION_CODES.S)
+    @Override
+    public AttributionSource getAttributionSource() {
+        AttributionSource.Builder builder = new AttributionSource.Builder(Process.SHELL_UID);
+        builder.setPackageName(PACKAGE_NAME);
+        return builder.build();
+    }
+}

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

@@ -5,9 +5,12 @@ import android.graphics.Rect;
 import java.util.List;
 
 public class Options {
+    private static final String VIDEO_CODEC_H264 = "h264";
+
     private Ln.Level logLevel = Ln.Level.DEBUG;
     private int uid = -1; // 31-bit non-negative value, or -1
     private int maxSize;
+    private VideoCodec codec = VideoCodec.H264;
     private int bitRate = 8000000;
     private int maxFps;
     private int lockVideoOrientation = -1;
@@ -29,6 +32,7 @@ public class Options {
     private boolean sendDeviceMeta = true; // send device name and size
     private boolean sendFrameMeta = true; // send PTS so that the client may record properly
     private boolean sendDummyByte = true; // write a byte on start to detect connection issues
+    private boolean sendCodecId = true; // write the codec ID (4 bytes) before the stream
 
     public Ln.Level getLogLevel() {
         return logLevel;
@@ -54,6 +58,14 @@ public class Options {
         this.maxSize = maxSize;
     }
 
+    public VideoCodec getCodec() {
+        return codec;
+    }
+
+    public void setCodec(VideoCodec codec) {
+        this.codec = codec;
+    }
+
     public int getBitRate() {
         return bitRate;
     }
@@ -205,4 +217,12 @@ public class Options {
     public void setSendDummyByte(boolean sendDummyByte) {
         this.sendDummyByte = sendDummyByte;
     }
+
+    public boolean getSendCodecId() {
+        return sendCodecId;
+    }
+
+    public void setSendCodecId(boolean sendCodecId) {
+        this.sendCodecId = sendCodecId;
+    }
 }

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

@@ -35,6 +35,7 @@ public class ScreenEncoder implements Device.RotationListener {
 
     private final AtomicBoolean rotationChanged = new AtomicBoolean();
 
+    private final String videoMimeType;
     private final String encoderName;
     private final List<CodecOption> codecOptions;
     private final int bitRate;
@@ -44,7 +45,8 @@ public class ScreenEncoder implements Device.RotationListener {
     private boolean firstFrameSent;
     private int consecutiveErrors;
 
-    public ScreenEncoder(int bitRate, int maxFps, List<CodecOption> codecOptions, String encoderName, boolean downsizeOnError) {
+    public ScreenEncoder(String videoMimeType, int bitRate, int maxFps, List<CodecOption> codecOptions, String encoderName, boolean downsizeOnError) {
+        this.videoMimeType = videoMimeType;
         this.bitRate = bitRate;
         this.maxFps = maxFps;
         this.codecOptions = codecOptions;
@@ -62,8 +64,8 @@ public class ScreenEncoder implements Device.RotationListener {
     }
 
     public void streamScreen(Device device, Callbacks callbacks) throws IOException {
-        MediaCodec codec = createCodec(encoderName);
-        MediaFormat format = createFormat(bitRate, maxFps, codecOptions);
+        MediaCodec codec = createCodec(videoMimeType, encoderName);
+        MediaFormat format = createFormat(videoMimeType, bitRate, maxFps, codecOptions);
         IBinder display = createDisplay();
         device.setRotationListener(this);
         boolean alive;
@@ -194,28 +196,28 @@ public class ScreenEncoder implements Device.RotationListener {
         return !eof;
     }
 
-    private static MediaCodecInfo[] listEncoders() {
+    private static MediaCodecInfo[] listEncoders(String videoMimeType) {
         List<MediaCodecInfo> result = new ArrayList<>();
         MediaCodecList list = new MediaCodecList(MediaCodecList.REGULAR_CODECS);
         for (MediaCodecInfo codecInfo : list.getCodecInfos()) {
-            if (codecInfo.isEncoder() && Arrays.asList(codecInfo.getSupportedTypes()).contains(MediaFormat.MIMETYPE_VIDEO_AVC)) {
+            if (codecInfo.isEncoder() && Arrays.asList(codecInfo.getSupportedTypes()).contains(videoMimeType)) {
                 result.add(codecInfo);
             }
         }
         return result.toArray(new MediaCodecInfo[result.size()]);
     }
 
-    private static MediaCodec createCodec(String encoderName) throws IOException {
+    private static MediaCodec createCodec(String videoMimeType, String encoderName) throws IOException {
         if (encoderName != null) {
             Ln.d("Creating encoder by name: '" + encoderName + "'");
             try {
                 return MediaCodec.createByCodecName(encoderName);
             } catch (IllegalArgumentException e) {
-                MediaCodecInfo[] encoders = listEncoders();
+                MediaCodecInfo[] encoders = listEncoders(videoMimeType);
                 throw new InvalidEncoderException(encoderName, encoders);
             }
         }
-        MediaCodec codec = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC);
+        MediaCodec codec = MediaCodec.createEncoderByType(videoMimeType);
         Ln.d("Using encoder: '" + codec.getName() + "'");
         return codec;
     }
@@ -237,9 +239,9 @@ public class ScreenEncoder implements Device.RotationListener {
         Ln.d("Codec option set: " + key + " (" + value.getClass().getSimpleName() + ") = " + value);
     }
 
-    private static MediaFormat createFormat(int bitRate, int maxFps, List<CodecOption> codecOptions) {
+    private static MediaFormat createFormat(String videoMimeType, int bitRate, int maxFps, List<CodecOption> codecOptions) {
         MediaFormat format = new MediaFormat();
-        format.setString(MediaFormat.KEY_MIME, MediaFormat.MIMETYPE_VIDEO_AVC);
+        format.setString(MediaFormat.KEY_MIME, videoMimeType);
         format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
         // must be present to configure the encoder, but does not impact the actual frame rate, which is variable
         format.setInteger(MediaFormat.KEY_FRAME_RATE, 60);

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

@@ -69,28 +69,38 @@ public final class Server {
         int uid = options.getUid();
         boolean tunnelForward = options.isTunnelForward();
         boolean control = options.getControl();
+        boolean audio = Build.VERSION.SDK_INT >= Build.VERSION_CODES.R; // TODO option
         boolean sendDummyByte = options.getSendDummyByte();
 
         Workarounds.prepareMainLooper();
-        if (Build.BRAND.equalsIgnoreCase("meizu")) {
-            // Workarounds must be applied for Meizu phones:
-            //  - <https://github.com/Genymobile/scrcpy/issues/240>
-            //  - <https://github.com/Genymobile/scrcpy/issues/365>
-            //  - <https://github.com/Genymobile/scrcpy/issues/2656>
-            //
-            // But only apply when strictly necessary, since workarounds can cause other issues:
-            //  - <https://github.com/Genymobile/scrcpy/issues/940>
-            //  - <https://github.com/Genymobile/scrcpy/issues/994>
+
+        // Workarounds must be applied for Meizu phones:
+        //  - <https://github.com/Genymobile/scrcpy/issues/240>
+        //  - <https://github.com/Genymobile/scrcpy/issues/365>
+        //  - <https://github.com/Genymobile/scrcpy/issues/2656>
+        //
+        // But only apply when strictly necessary, since workarounds can cause other issues:
+        //  - <https://github.com/Genymobile/scrcpy/issues/940>
+        //  - <https://github.com/Genymobile/scrcpy/issues/994>
+        boolean mustFillAppInfo = Build.BRAND.equalsIgnoreCase("meizu");
+
+        // Before Android 11, audio is not supported.
+        // Since Android 12, we can properly set a context on the AudioRecord.
+        // Only on Android 11 we must fill app info for the AudioRecord to work.
+        mustFillAppInfo |= audio && Build.VERSION.SDK_INT == Build.VERSION_CODES.R;
+
+        if (mustFillAppInfo) {
             Workarounds.fillAppInfo();
         }
 
         try (DesktopConnection connection = DesktopConnection.open(uid, tunnelForward, control, sendDummyByte)) {
+            VideoCodec codec = options.getCodec();
             if (options.getSendDeviceMeta()) {
                 Size videoSize = device.getScreenInfo().getVideoSize();
                 connection.sendDeviceMeta(Device.getDeviceName(), videoSize.getWidth(), videoSize.getHeight());
             }
-            ScreenEncoder screenEncoder = new ScreenEncoder(options.getBitRate(), options.getMaxFps(), codecOptions, options.getEncoderName(),
-                    options.getDownsizeOnError());
+            ScreenEncoder screenEncoder = new ScreenEncoder(codec.getMimeType(), options.getBitRate(), options.getMaxFps(), codecOptions,
+                    options.getEncoderName(), options.getDownsizeOnError());
 
             Controller controller = null;
             if (control) {
@@ -101,9 +111,18 @@ public final class Server {
                 device.setClipboardListener(text -> controllerRef.getSender().pushClipboardText(text));
             }
 
+            AudioEncoder audioEncoder = null;
+            if (audio) {
+                audioEncoder = new AudioEncoder();
+                audioEncoder.start();
+            }
+
             try {
                 // synchronous
                 VideoStreamer videoStreamer = new VideoStreamer(connection.getVideoFd(), options.getSendFrameMeta());
+                if (options.getSendCodecId()) {
+                    videoStreamer.writeHeader(codec.getId());
+                }
                 screenEncoder.streamScreen(device, videoStreamer);
             } catch (IOException e) {
                 // this is expected on close
@@ -113,6 +132,9 @@ public final class Server {
                 if (controller != null) {
                     controller.stop();
                 }
+                if (audioEncoder != null) {
+                    audioEncoder.stop();
+                }
             }
         }
     }
@@ -156,6 +178,13 @@ public final class Server {
                     Ln.Level level = Ln.Level.valueOf(value.toUpperCase(Locale.ENGLISH));
                     options.setLogLevel(level);
                     break;
+                case "codec":
+                    VideoCodec codec = VideoCodec.findByName(value);
+                    if (codec == null) {
+                        throw new IllegalArgumentException("Video codec " + value + " not supported");
+                    }
+                    options.setCodec(codec);
+                    break;
                 case "max_size":
                     int maxSize = Integer.parseInt(value) & ~7; // multiple of 8
                     options.setMaxSize(maxSize);
@@ -237,12 +266,17 @@ public final class Server {
                     boolean sendDummyByte = Boolean.parseBoolean(value);
                     options.setSendDummyByte(sendDummyByte);
                     break;
+                case "send_codec_id":
+                    boolean sendCodecId = Boolean.parseBoolean(value);
+                    options.setSendCodecId(sendCodecId);
+                    break;
                 case "raw_video_stream":
                     boolean rawVideoStream = Boolean.parseBoolean(value);
                     if (rawVideoStream) {
                         options.setSendDeviceMeta(false);
                         options.setSendFrameMeta(false);
                         options.setSendDummyByte(false);
+                        options.setSendCodecId(false);
                     }
                     break;
                 default:

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

@@ -0,0 +1,36 @@
+package com.genymobile.scrcpy;
+
+import android.media.MediaFormat;
+
+public enum VideoCodec {
+    H264(0x68_32_36_34, "h264", MediaFormat.MIMETYPE_VIDEO_AVC),
+    H265(0x68_32_36_35, "h265", MediaFormat.MIMETYPE_VIDEO_HEVC),
+    AV1(0x00_61_76_31, "av1", MediaFormat.MIMETYPE_VIDEO_AV1);
+
+    private final int id; // 4-byte ASCII representation of the name
+    private final String name;
+    private final String mimeType;
+
+    VideoCodec(int id, String name, String mimeType) {
+        this.id = id;
+        this.name = name;
+        this.mimeType = mimeType;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public String getMimeType() {
+        return mimeType;
+    }
+
+    public static VideoCodec findByName(String name) {
+        for (VideoCodec codec : values()) {
+            if (codec.name.equals(name)) {
+                return codec;
+            }
+        }
+        return null;
+    }
+}

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

@@ -21,6 +21,13 @@ public final class VideoStreamer implements ScreenEncoder.Callbacks {
         this.sendFrameMeta = sendFrameMeta;
     }
 
+    public void writeHeader(int codecId) throws IOException {
+        ByteBuffer buffer = ByteBuffer.allocate(4);
+        buffer.putInt(codecId);
+        buffer.flip();
+        IO.writeFully(fd, buffer);
+    }
+
     @Override
     public void onPacket(ByteBuffer codecBuffer, MediaCodec.BufferInfo bufferInfo) throws IOException {
         if (sendFrameMeta) {

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

@@ -3,13 +3,12 @@ package com.genymobile.scrcpy;
 import android.annotation.SuppressLint;
 import android.app.Application;
 import android.app.Instrumentation;
-import android.content.Context;
+import android.content.ContextWrapper;
 import android.content.pm.ApplicationInfo;
 import android.os.Looper;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
-import java.lang.reflect.Method;
 
 public final class Workarounds {
     private Workarounds() {
@@ -50,7 +49,7 @@ public final class Workarounds {
             Object appBindData = appBindDataConstructor.newInstance();
 
             ApplicationInfo applicationInfo = new ApplicationInfo();
-            applicationInfo.packageName = "com.genymobile.scrcpy";
+            applicationInfo.packageName = FakeContext.PACKAGE_NAME;
 
             // appBindData.appInfo = applicationInfo;
             Field appInfoField = appBindDataClass.getDeclaredField("appInfo");
@@ -62,11 +61,10 @@ public final class Workarounds {
             mBoundApplicationField.setAccessible(true);
             mBoundApplicationField.set(activityThread, appBindData);
 
-            // Context ctx = activityThread.getSystemContext();
-            Method getSystemContextMethod = activityThreadClass.getDeclaredMethod("getSystemContext");
-            Context ctx = (Context) getSystemContextMethod.invoke(activityThread);
-
-            Application app = Instrumentation.newApplication(Application.class, ctx);
+            Application app = Application.class.newInstance();
+            Field baseField = ContextWrapper.class.getDeclaredField("mBase");
+            baseField.setAccessible(true);
+            baseField.set(app, FakeContext.get());
 
             // activityThread.mInitialApplication = app;
             Field mInitialApplicationField = activityThreadClass.getDeclaredField("mInitialApplication");

server/src/main/java/com/genymobile/scrcpy/wrappers/ActivityManager.java

@@ -5,6 +5,7 @@ import com.genymobile.scrcpy.Ln;
 import android.os.Binder;
 import android.os.IBinder;
 import android.os.IInterface;
+import android.os.Process;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
@@ -48,10 +49,10 @@ public class ActivityManager {
             Object[] args;
             if (getContentProviderExternalMethodNewVersion) {
                 // new version
-                args = new Object[]{name, ServiceManager.USER_ID, token, null};
+                args = new Object[]{name, Process.ROOT_UID, token, null};
             } else {
                 // old version
-                args = new Object[]{name, ServiceManager.USER_ID, token};
+                args = new Object[]{name, Process.ROOT_UID, token};
             }
             // ContentProviderHolder providerHolder = getContentProviderExternal(...);
             Object providerHolder = method.invoke(manager, args);

server/src/main/java/com/genymobile/scrcpy/wrappers/ClipboardManager.java

@@ -1,11 +1,13 @@
 package com.genymobile.scrcpy.wrappers;
 
+import com.genymobile.scrcpy.FakeContext;
 import com.genymobile.scrcpy.Ln;
 
 import android.content.ClipData;
 import android.content.IOnPrimaryClipChangedListener;
 import android.os.Build;
 import android.os.IInterface;
+import android.os.Process;
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
@@ -58,22 +60,22 @@ public class ClipboardManager {
     private static ClipData getPrimaryClip(Method method, boolean alternativeMethod, IInterface manager)
             throws InvocationTargetException, IllegalAccessException {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-            return (ClipData) method.invoke(manager, ServiceManager.PACKAGE_NAME);
+            return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME);
         }
         if (alternativeMethod) {
-            return (ClipData) method.invoke(manager, ServiceManager.PACKAGE_NAME, null, ServiceManager.USER_ID);
+            return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME, null, Process.ROOT_UID);
         }
-        return (ClipData) method.invoke(manager, ServiceManager.PACKAGE_NAME, ServiceManager.USER_ID);
+        return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME, Process.ROOT_UID);
     }
 
     private static void setPrimaryClip(Method method, boolean alternativeMethod, IInterface manager, ClipData clipData)
             throws InvocationTargetException, IllegalAccessException {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-            method.invoke(manager, clipData, ServiceManager.PACKAGE_NAME);
+            method.invoke(manager, clipData, FakeContext.PACKAGE_NAME);
         } else if (alternativeMethod) {
-            method.invoke(manager, clipData, ServiceManager.PACKAGE_NAME, null, ServiceManager.USER_ID);
+            method.invoke(manager, clipData, FakeContext.PACKAGE_NAME, null, Process.ROOT_UID);
         } else {
-            method.invoke(manager, clipData, ServiceManager.PACKAGE_NAME, ServiceManager.USER_ID);
+            method.invoke(manager, clipData, FakeContext.PACKAGE_NAME, Process.ROOT_UID);
         }
     }
 
@@ -106,11 +108,11 @@ public class ClipboardManager {
     private static void addPrimaryClipChangedListener(Method method, boolean alternativeMethod, IInterface manager,
             IOnPrimaryClipChangedListener listener) throws InvocationTargetException, IllegalAccessException {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-            method.invoke(manager, listener, ServiceManager.PACKAGE_NAME);
+            method.invoke(manager, listener, FakeContext.PACKAGE_NAME);
         } else if (alternativeMethod) {
-            method.invoke(manager, listener, ServiceManager.PACKAGE_NAME, null, ServiceManager.USER_ID);
+            method.invoke(manager, listener, FakeContext.PACKAGE_NAME, null, Process.ROOT_UID);
         } else {
-            method.invoke(manager, listener, ServiceManager.PACKAGE_NAME, ServiceManager.USER_ID);
+            method.invoke(manager, listener, FakeContext.PACKAGE_NAME, Process.ROOT_UID);
         }
     }
 

server/src/main/java/com/genymobile/scrcpy/wrappers/ContentProvider.java

@@ -1,11 +1,15 @@
 package com.genymobile.scrcpy.wrappers;
 
+import com.genymobile.scrcpy.FakeContext;
 import com.genymobile.scrcpy.Ln;
 import com.genymobile.scrcpy.SettingsException;
 
 import android.annotation.SuppressLint;
+import android.content.AttributionSource;
+import android.os.Build;
 import android.os.Bundle;
 import android.os.IBinder;
+import android.os.Process;
 
 import java.io.Closeable;
 import java.lang.reflect.InvocationTargetException;
@@ -51,11 +55,10 @@ public class ContentProvider implements Closeable {
     @SuppressLint("PrivateApi")
     private Method getCallMethod() throws NoSuchMethodException {
         if (callMethod == null) {
-            try {
-                Class<?> attributionSourceClass = Class.forName("android.content.AttributionSource");
-                callMethod = provider.getClass().getMethod("call", attributionSourceClass, String.class, String.class, String.class, Bundle.class);
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                callMethod = provider.getClass().getMethod("call", AttributionSource.class, String.class, String.class, String.class, Bundle.class);
                 callMethodVersion = 0;
-            } catch (NoSuchMethodException | ClassNotFoundException e0) {
+            } else {
                 // old versions
                 try {
                     callMethod = provider.getClass()
@@ -75,40 +78,29 @@ public class ContentProvider implements Closeable {
         return callMethod;
     }
 
-    @SuppressLint("PrivateApi")
-    private Object getAttributionSource()
-            throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
-        if (attributionSource == null) {
-            Class<?> cl = Class.forName("android.content.AttributionSource$Builder");
-            Object builder = cl.getConstructor(int.class).newInstance(ServiceManager.USER_ID);
-            cl.getDeclaredMethod("setPackageName", String.class).invoke(builder, ServiceManager.PACKAGE_NAME);
-            attributionSource = cl.getDeclaredMethod("build").invoke(builder);
-        }
-
-        return attributionSource;
-    }
-
     private Bundle call(String callMethod, String arg, Bundle extras)
-            throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
+            throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
         try {
             Method method = getCallMethod();
             Object[] args;
-            switch (callMethodVersion) {
-                case 0:
-                    args = new Object[]{getAttributionSource(), "settings", callMethod, arg, extras};
-                    break;
-                case 1:
-                    args = new Object[]{ServiceManager.PACKAGE_NAME, null, "settings", callMethod, arg, extras};
-                    break;
-                case 2:
-                    args = new Object[]{ServiceManager.PACKAGE_NAME, "settings", callMethod, arg, extras};
-                    break;
-                default:
-                    args = new Object[]{ServiceManager.PACKAGE_NAME, callMethod, arg, extras};
-                    break;
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && callMethodVersion == 0) {
+                args = new Object[]{FakeContext.get().getAttributionSource(), "settings", callMethod, arg, extras};
+            } else {
+                switch (callMethodVersion) {
+                    case 1:
+                        args = new Object[]{FakeContext.PACKAGE_NAME, null, "settings", callMethod, arg, extras};
+                        break;
+                    case 2:
+                        args = new Object[]{FakeContext.PACKAGE_NAME, "settings", callMethod, arg, extras};
+                        break;
+                    default:
+                        args = new Object[]{FakeContext.PACKAGE_NAME, callMethod, arg, extras};
+                        break;
+                }
             }
             return (Bundle) method.invoke(provider, args);
-        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException | ClassNotFoundException | InstantiationException e) {
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
             Ln.e("Could not invoke method", e);
             throw e;
         }
@@ -147,7 +139,7 @@ public class ContentProvider implements Closeable {
     public String getValue(String table, String key) throws SettingsException {
         String method = getGetMethod(table);
         Bundle arg = new Bundle();
-        arg.putInt(CALL_METHOD_USER_KEY, ServiceManager.USER_ID);
+        arg.putInt(CALL_METHOD_USER_KEY, Process.ROOT_UID);
         try {
             Bundle bundle = call(method, key, arg);
             if (bundle == null) {
@@ -163,7 +155,7 @@ public class ContentProvider implements Closeable {
     public void putValue(String table, String key, String value) throws SettingsException {
         String method = getPutMethod(table);
         Bundle arg = new Bundle();
-        arg.putInt(CALL_METHOD_USER_KEY, ServiceManager.USER_ID);
+        arg.putInt(CALL_METHOD_USER_KEY, Process.ROOT_UID);
         arg.putString(NAME_VALUE_TABLE_VALUE, value);
         try {
             call(method, key, arg);

server/src/main/java/com/genymobile/scrcpy/wrappers/ServiceManager.java

@@ -10,9 +10,6 @@ import java.lang.reflect.Method;
 @SuppressLint("PrivateApi,DiscouragedPrivateApi")
 public final class ServiceManager {
 
-    public static final String PACKAGE_NAME = "com.android.shell";
-    public static final int USER_ID = 0;
-
     private static final Method GET_SERVICE_METHOD;
     static {
         try {