mirror of
https://github.com/Genymobile/scrcpy.git
synced 2025-04-20 03:25:03 +00:00
feiser2016
GitHub
commit
5019813481
24 changed files with 607 additions and 95 deletions
15
BUILD.md
15
BUILD.md
|
|
@ -51,6 +51,15 @@ sudo apt install make gcc pkg-config meson \
|
|||
sudo apt install openjdk-8-jdk
|
||||
```
|
||||
|
||||
On old versions (like Ubuntu 16.04), `meson` is too old. In that case, install
|
||||
it from `pip3`:
|
||||
|
||||
```bash
|
||||
sudo apt install python3-pip
|
||||
pip3 install meson
|
||||
```
|
||||
|
||||
|
||||
#### Fedora
|
||||
|
||||
```bash
|
||||
|
|
@ -219,10 +228,10 @@ You can then [run](README.md#run) _scrcpy_.
|
|||
|
||||
## Prebuilt server
|
||||
|
||||
- [`scrcpy-server-v1.4.jar`][direct-scrcpy-server]
|
||||
_(SHA-256: 1ff7a72fcfe81dadccfab9d6f86c971cd7c7f38f17196748fe05480e301b443d)_
|
||||
- [`scrcpy-server-v1.5.jar`][direct-scrcpy-server]
|
||||
_(SHA-256: c827f566172a5c5946e63b8378ac93d374dff9e229083e5cd9980df57536947b)_
|
||||
|
||||
[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.4/scrcpy-server-v1.4.jar
|
||||
[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.5/scrcpy-server-v1.5.jar
|
||||
|
||||
Download the prebuilt server somewhere, and specify its path during the Meson
|
||||
configuration:
|
||||
|
|
|
|||
|
|
@ -107,7 +107,7 @@ dist-win32: build-server build-win32 build-win32-noconsole
|
|||
cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
|
||||
cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
|
||||
cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
|
||||
cp prebuilt-deps/SDL2-2.0.8/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
|
||||
cp prebuilt-deps/SDL2-2.0.9/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
|
||||
|
||||
dist-win64: build-server build-win64 build-win64-noconsole
|
||||
mkdir -p "$(DIST)/$(WIN64_TARGET_DIR)"
|
||||
|
|
@ -121,7 +121,7 @@ dist-win64: build-server build-win64 build-win64-noconsole
|
|||
cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
|
||||
cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
|
||||
cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
|
||||
cp prebuilt-deps/SDL2-2.0.8/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
|
||||
cp prebuilt-deps/SDL2-2.0.9/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
|
||||
|
||||
zip-win32: dist-win32
|
||||
cd "$(DIST)"; \
|
||||
|
|
|
|||
142
README.md
142
README.md
|
|
@ -1,4 +1,4 @@
|
|||
# scrcpy (v1.4)
|
||||
# scrcpy (v1.5)
|
||||
|
||||
This application provides display and control of Android devices connected on
|
||||
USB (or [over TCP/IP][article-tcpip]). It does not require any _root_ access.
|
||||
|
|
@ -42,13 +42,13 @@ For Gentoo, an [Ebuild] is available: [`scrcpy/`][ebuild-link].
|
|||
For Windows, for simplicity, prebuilt archives with all the dependencies
|
||||
(including `adb`) are available:
|
||||
|
||||
- [`scrcpy-win32-v1.4.zip`][direct-win32]
|
||||
_(SHA-256: 1f72fa520980727e8943b7214b64c66b00b9b5267f7cffefb64fa37c3ca803cf)_
|
||||
- [`scrcpy-win64-v1.4.zip`][direct-win64]
|
||||
_(SHA-256: 382f02bd8ed3db2cc7ab15aabdb83674744993b936d602b01e6959a150584a79)_
|
||||
- [`scrcpy-win32-v1.5.zip`][direct-win32]
|
||||
_(SHA-256: 9118d74655a3e2daf9c1db37caf578f0b5239ccb078dbcbdb451e8a0becfe19f)_
|
||||
- [`scrcpy-win64-v1.5.zip`][direct-win64]
|
||||
_(SHA-256: fcaf7d596e8829cbcc119d67ec055eef2ee14ee204f28b33b7794f225ce16463)_
|
||||
|
||||
[direct-win32]: https://github.com/Genymobile/scrcpy/releases/download/v1.4/scrcpy-win32-v1.4.zip
|
||||
[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.4/scrcpy-win64-v1.4.zip
|
||||
[direct-win32]: https://github.com/Genymobile/scrcpy/releases/download/v1.5/scrcpy-win32-v1.5.zip
|
||||
[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.5/scrcpy-win64-v1.5.zip
|
||||
|
||||
You can also [build the app manually][BUILD].
|
||||
|
||||
|
|
@ -86,43 +86,141 @@ It accepts command-line arguments, listed by:
|
|||
scrcpy --help
|
||||
```
|
||||
|
||||
For example, to decrease video bitrate to 2Mbps (default is 8Mbps):
|
||||
## Features
|
||||
|
||||
|
||||
### Reduce size
|
||||
|
||||
Sometimes, it is useful to mirror an Android device at a lower definition to
|
||||
increase performances.
|
||||
|
||||
To limit both width and height to some value (e.g. 1024):
|
||||
|
||||
```bash
|
||||
scrcpy -b 2M
|
||||
scrcpy --max-size 1024
|
||||
scrcpy -m 1024 # short version
|
||||
```
|
||||
|
||||
To limit the video dimensions (e.g. if the device is 2540×1440, but the host
|
||||
screen is smaller, or cannot decode such a high definition):
|
||||
The other dimension is computed to that the device aspect-ratio is preserved.
|
||||
That way, a device in 1920×1080 will be mirrored at 1024×576.
|
||||
|
||||
|
||||
### Change bit-rate
|
||||
|
||||
The default bit-rate is 8Mbps. To change the video bitrate (e.g. to 2Mbps):
|
||||
|
||||
```bash
|
||||
scrcpy -m 1024
|
||||
scrcpy --bit-rate 2M
|
||||
scrcpy -b 2M # short version
|
||||
```
|
||||
|
||||
The device screen may be cropped to mirror only part of the screen:
|
||||
|
||||
### Crop
|
||||
|
||||
The device screen may be cropped to mirror only part of the screen.
|
||||
|
||||
This is useful for example to mirror only 1 eye of the Oculus Go:
|
||||
|
||||
```bash
|
||||
scrcpy -c 1224:1440:0:0 # 1224x1440 at offset (0,0)
|
||||
scrcpy --crop 1224:1440:0:0 # 1224x1440 at offset (0,0)
|
||||
scrcpy -c 1224:1440:0:0 # short version
|
||||
```
|
||||
|
||||
If `--max-size` is also specified, resizing is applied after cropping.
|
||||
|
||||
|
||||
### Wireless
|
||||
|
||||
_Scrcpy_ uses `adb` to communicate with the device, and `adb` can [connect] to a
|
||||
device over TCP/IP:
|
||||
|
||||
1. Connect the device to the same Wi-Fi as your computer.
|
||||
2. Get your device IP address (in Settings → About phone → Status).
|
||||
3. Enable adb over TCP/IP on your device: `adb tcpip 5555`.
|
||||
4. Unplug your device.
|
||||
5. Connect to your device: `adb connect DEVICE_IP:5555` _(replace `DEVICE_IP`)_.
|
||||
6. Run `scrcpy` as usual.
|
||||
|
||||
It may be useful to decrease the bit-rate and the definition:
|
||||
|
||||
```bash
|
||||
scrcpy --bit-rate 2M --max-size 800
|
||||
scrcpy -b2M -m800 # short version
|
||||
```
|
||||
|
||||
[connect]: https://developer.android.com/studio/command-line/adb.html#wireless
|
||||
|
||||
|
||||
### Record screen
|
||||
|
||||
It is possible to record the screen while mirroring:
|
||||
|
||||
```bash
|
||||
scrcpy --record file.mp4
|
||||
scrcpy -r file.mp4
|
||||
```
|
||||
|
||||
"Skipped frames" are recorded, even if they are not displayed in real time (for
|
||||
performance reasons). Frames are _timestamped_ on the device, so [packet delay
|
||||
variation] does not impact the recorded file.
|
||||
|
||||
[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
|
||||
|
||||
|
||||
### Multi-devices
|
||||
|
||||
If several devices are listed in `adb devices`, you must specify the _serial_:
|
||||
|
||||
```bash
|
||||
scrcpy -s 0123456789abcdef
|
||||
scrcpy --serial 0123456789abcdef
|
||||
scrcpy -s 0123456789abcdef # short version
|
||||
```
|
||||
|
||||
To show physical touches while scrcpy is running:
|
||||
You can start several instances of _scrcpy_ for several devices.
|
||||
|
||||
```bash
|
||||
scrcpy -t
|
||||
```
|
||||
|
||||
### Fullscreen
|
||||
|
||||
The app may be started directly in fullscreen:
|
||||
|
||||
```bash
|
||||
scrcpy --fullscreen
|
||||
scrcpy -f # short version
|
||||
```
|
||||
scrcpy -f
|
||||
|
||||
Fullscreen can then be toggled dynamically with `Ctrl`+`f`.
|
||||
|
||||
|
||||
### Show touches
|
||||
|
||||
For presentations, it may be useful to show physical touches (on the physical
|
||||
device).
|
||||
|
||||
Android provides this feature in _Developers options_.
|
||||
|
||||
_Scrcpy_ provides an option to enable this feature on start and disable on exit:
|
||||
|
||||
```bash
|
||||
scrcpy --show-touches
|
||||
scrcpy -t
|
||||
```
|
||||
|
||||
Note that it only shows _physical_ touches (with the finger on the device).
|
||||
|
||||
|
||||
### Forward audio
|
||||
|
||||
Audio is not forwarded by _scrcpy_.
|
||||
|
||||
There is a limited solution using [AOA], implemented in the [`audio`] branch. If
|
||||
you are interested, see [issue 14].
|
||||
|
||||
|
||||
[AOA]: https://source.android.com/devices/accessories/aoa2
|
||||
[`audio`]: https://github.com/Genymobile/scrcpy/commits/audio
|
||||
[issue 14]: https://github.com/Genymobile/scrcpy/issues/14
|
||||
|
||||
|
||||
## Shortcuts
|
||||
|
||||
| Action | Shortcut |
|
||||
|
|
@ -134,8 +232,8 @@ scrcpy -f
|
|||
| click on `BACK` | `Ctrl`+`b` \| _Right-click²_ |
|
||||
| click on `APP_SWITCH` | `Ctrl`+`s` |
|
||||
| click on `MENU` | `Ctrl`+`m` |
|
||||
| click on `VOLUME_UP` | `Ctrl`+`↑` _(up)_ |
|
||||
| click on `VOLUME_DOWN` | `Ctrl`+`↓` _(down)_ |
|
||||
| click on `VOLUME_UP` | `Ctrl`+`↑` _(up)_ (`Cmd`+`↑` on MacOS) |
|
||||
| click on `VOLUME_DOWN` | `Ctrl`+`↓` _(down)_ (`Cmd`+`↓` on MacOS) |
|
||||
| click on `POWER` | `Ctrl`+`p` |
|
||||
| turn screen on | _Right-click²_ |
|
||||
| paste computer clipboard to device | `Ctrl`+`v` |
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ src = [
|
|||
'src/input_manager.c',
|
||||
'src/lock_util.c',
|
||||
'src/net.c',
|
||||
'src/recorder.c',
|
||||
'src/scrcpy.c',
|
||||
'src/screen.c',
|
||||
'src/server.c',
|
||||
|
|
|
|||
28
app/src/buffer_util.h
Normal file
28
app/src/buffer_util.h
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
#ifndef BUFFER_UTIL_H
|
||||
#define BUFFER_UTIL_H
|
||||
|
||||
#include <SDL2/SDL_stdinc.h>
|
||||
|
||||
static inline void buffer_write16be(Uint8 *buf, Uint16 value) {
|
||||
buf[0] = value >> 8;
|
||||
buf[1] = value;
|
||||
}
|
||||
|
||||
static inline void buffer_write32be(Uint8 *buf, Uint32 value) {
|
||||
buf[0] = value >> 24;
|
||||
buf[1] = value >> 16;
|
||||
buf[2] = value >> 8;
|
||||
buf[3] = value;
|
||||
}
|
||||
|
||||
static inline Uint32 buffer_read32be(Uint8 *buf) {
|
||||
return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
|
||||
}
|
||||
|
||||
static inline Uint64 buffer_read64be(Uint8 *buf) {
|
||||
Uint32 msb = buffer_read32be(buf);
|
||||
Uint32 lsb = buffer_read32be(&buf[4]);
|
||||
return ((Uint64) msb << 32) | lsb;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -3,26 +3,15 @@
|
|||
#include <SDL2/SDL_stdinc.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "buffer_util.h"
|
||||
#include "lock_util.h"
|
||||
#include "log.h"
|
||||
|
||||
static inline void write16(Uint8 *buf, Uint16 value) {
|
||||
buf[0] = value >> 8;
|
||||
buf[1] = value;
|
||||
}
|
||||
|
||||
static inline void write32(Uint8 *buf, Uint32 value) {
|
||||
buf[0] = value >> 24;
|
||||
buf[1] = value >> 16;
|
||||
buf[2] = value >> 8;
|
||||
buf[3] = value;
|
||||
}
|
||||
|
||||
static void write_position(Uint8 *buf, const struct position *position) {
|
||||
write16(&buf[0], position->point.x);
|
||||
write16(&buf[2], position->point.y);
|
||||
write16(&buf[4], position->screen_size.width);
|
||||
write16(&buf[6], position->screen_size.height);
|
||||
buffer_write16be(&buf[0], position->point.x);
|
||||
buffer_write16be(&buf[2], position->point.y);
|
||||
buffer_write16be(&buf[4], position->screen_size.width);
|
||||
buffer_write16be(&buf[6], position->screen_size.height);
|
||||
}
|
||||
|
||||
int control_event_serialize(const struct control_event *event, unsigned char *buf) {
|
||||
|
|
@ -30,8 +19,8 @@ int control_event_serialize(const struct control_event *event, unsigned char *bu
|
|||
switch (event->type) {
|
||||
case CONTROL_EVENT_TYPE_KEYCODE:
|
||||
buf[1] = event->keycode_event.action;
|
||||
write32(&buf[2], event->keycode_event.keycode);
|
||||
write32(&buf[6], event->keycode_event.metastate);
|
||||
buffer_write32be(&buf[2], event->keycode_event.keycode);
|
||||
buffer_write32be(&buf[6], event->keycode_event.metastate);
|
||||
return 10;
|
||||
case CONTROL_EVENT_TYPE_TEXT: {
|
||||
// write length (1 byte) + date (non nul-terminated)
|
||||
|
|
@ -40,19 +29,19 @@ int control_event_serialize(const struct control_event *event, unsigned char *bu
|
|||
// injecting a text takes time, so limit the text length
|
||||
len = TEXT_MAX_LENGTH;
|
||||
}
|
||||
write16(&buf[1], (Uint16) len);
|
||||
buffer_write16be(&buf[1], (Uint16) len);
|
||||
memcpy(&buf[3], event->text_event.text, len);
|
||||
return 3 + len;
|
||||
}
|
||||
case CONTROL_EVENT_TYPE_MOUSE:
|
||||
buf[1] = event->mouse_event.action;
|
||||
write32(&buf[2], event->mouse_event.buttons);
|
||||
buffer_write32be(&buf[2], event->mouse_event.buttons);
|
||||
write_position(&buf[6], &event->mouse_event.position);
|
||||
return 14;
|
||||
case CONTROL_EVENT_TYPE_SCROLL:
|
||||
write_position(&buf[1], &event->scroll_event.position);
|
||||
write32(&buf[9], (Uint32) event->scroll_event.hscroll);
|
||||
write32(&buf[13], (Uint32) event->scroll_event.vscroll);
|
||||
buffer_write32be(&buf[9], (Uint32) event->scroll_event.hscroll);
|
||||
buffer_write32be(&buf[13], (Uint32) event->scroll_event.vscroll);
|
||||
return 17;
|
||||
case CONTROL_EVENT_TYPE_COMMAND:
|
||||
buf[1] = event->command_event.action;
|
||||
|
|
|
|||
|
|
@ -1,20 +1,119 @@
|
|||
#include "decoder.h"
|
||||
|
||||
#include <libavformat/avformat.h>
|
||||
#include <libavutil/time.h>
|
||||
#include <SDL2/SDL_assert.h>
|
||||
#include <SDL2/SDL_events.h>
|
||||
#include <SDL2/SDL_mutex.h>
|
||||
#include <SDL2/SDL_thread.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "config.h"
|
||||
#include "buffer_util.h"
|
||||
#include "events.h"
|
||||
#include "frames.h"
|
||||
#include "lock_util.h"
|
||||
#include "log.h"
|
||||
#include "recorder.h"
|
||||
|
||||
#define BUFSIZE 0x10000
|
||||
|
||||
static int read_packet(void *opaque, uint8_t *buf, int buf_size) {
|
||||
#define HEADER_SIZE 12
|
||||
#define NO_PTS UINT64_C(-1)
|
||||
|
||||
static struct frame_meta *frame_meta_new(uint64_t pts) {
|
||||
struct frame_meta *meta = malloc(sizeof(*meta));
|
||||
if (!meta) {
|
||||
return meta;
|
||||
}
|
||||
meta->pts = pts;
|
||||
meta->next = NULL;
|
||||
return meta;
|
||||
}
|
||||
|
||||
static void frame_meta_delete(struct frame_meta *frame_meta) {
|
||||
free(frame_meta);
|
||||
}
|
||||
|
||||
static SDL_bool receiver_state_push_meta(struct receiver_state *state,
|
||||
uint64_t pts) {
|
||||
struct frame_meta *frame_meta = frame_meta_new(pts);
|
||||
if (!frame_meta) {
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
// append to the list
|
||||
// (iterate to find the last item, in practice the list should be tiny)
|
||||
struct frame_meta **p = &state->frame_meta_queue;
|
||||
while (*p) {
|
||||
p = &(*p)->next;
|
||||
}
|
||||
*p = frame_meta;
|
||||
return SDL_TRUE;
|
||||
}
|
||||
|
||||
static uint64_t receiver_state_take_meta(struct receiver_state *state) {
|
||||
struct frame_meta *frame_meta = state->frame_meta_queue; // first item
|
||||
SDL_assert(frame_meta); // must not be empty
|
||||
uint64_t pts = frame_meta->pts;
|
||||
state->frame_meta_queue = frame_meta->next; // remove the item
|
||||
frame_meta_delete(frame_meta);
|
||||
return pts;
|
||||
}
|
||||
|
||||
static int read_packet_with_meta(void *opaque, uint8_t *buf, int buf_size) {
|
||||
struct decoder *decoder = opaque;
|
||||
struct receiver_state *state = &decoder->receiver_state;
|
||||
|
||||
// The video stream contains raw packets, without time information. When we
|
||||
// record, we retrieve the timestamps separately, from a "meta" header
|
||||
// added by the server before each raw packet.
|
||||
//
|
||||
// The "meta" header length is 12 bytes:
|
||||
// [. . . . . . . .|. . . .]. . . . . . . . . . . . . . . ...
|
||||
// <-------------> <-----> <-----------------------------...
|
||||
// PTS packet raw packet
|
||||
// size
|
||||
//
|
||||
// It is followed by <packet_size> bytes containing the packet/frame.
|
||||
|
||||
if (!state->remaining) {
|
||||
#define HEADER_SIZE 12
|
||||
uint8_t header[HEADER_SIZE];
|
||||
ssize_t ret = net_recv_all(decoder->video_socket, header, HEADER_SIZE);
|
||||
if (ret <= 0) {
|
||||
return ret;
|
||||
}
|
||||
// no partial read (net_recv_all())
|
||||
SDL_assert_release(ret == HEADER_SIZE);
|
||||
|
||||
uint64_t pts = buffer_read64be(header);
|
||||
state->remaining = buffer_read32be(&header[8]);
|
||||
|
||||
if (pts != NO_PTS && !receiver_state_push_meta(state, pts)) {
|
||||
LOGE("Could not store PTS for recording");
|
||||
// we cannot save the PTS, the recording would be broken
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
SDL_assert(state->remaining);
|
||||
|
||||
if (buf_size > state->remaining)
|
||||
buf_size = state->remaining;
|
||||
|
||||
ssize_t ret = net_recv(decoder->video_socket, buf, buf_size);
|
||||
if (ret <= 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
SDL_assert(state->remaining >= ret);
|
||||
state->remaining -= ret;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int read_raw_packet(void *opaque, uint8_t *buf, int buf_size) {
|
||||
struct decoder *decoder = opaque;
|
||||
return net_recv(decoder->video_socket, buf, buf_size);
|
||||
}
|
||||
|
|
@ -70,7 +169,15 @@ static int run_decoder(void *data) {
|
|||
goto run_finally_free_format_ctx;
|
||||
}
|
||||
|
||||
AVIOContext *avio_ctx = avio_alloc_context(buffer, BUFSIZE, 0, decoder, read_packet, NULL, NULL);
|
||||
// initialize the receiver state
|
||||
decoder->receiver_state.frame_meta_queue = NULL;
|
||||
decoder->receiver_state.remaining = 0;
|
||||
|
||||
// if recording is enabled, a "header" is sent between raw packets
|
||||
int (*read_packet)(void *, uint8_t *, int) =
|
||||
decoder->recorder ? read_packet_with_meta : read_raw_packet;
|
||||
AVIOContext *avio_ctx = avio_alloc_context(buffer, BUFSIZE, 0, decoder,
|
||||
read_packet, NULL, NULL);
|
||||
if (!avio_ctx) {
|
||||
LOGC("Could not allocate avio context");
|
||||
// avformat_open_input takes ownership of 'buffer'
|
||||
|
|
@ -86,6 +193,12 @@ static int run_decoder(void *data) {
|
|||
goto run_finally_free_avio_ctx;
|
||||
}
|
||||
|
||||
if (decoder->recorder &&
|
||||
!recorder_open(decoder->recorder, codec)) {
|
||||
LOGE("Could not open recorder");
|
||||
goto run_finally_close_input;
|
||||
}
|
||||
|
||||
AVPacket packet;
|
||||
av_init_packet(&packet);
|
||||
packet.data = NULL;
|
||||
|
|
@ -115,6 +228,7 @@ static int run_decoder(void *data) {
|
|||
int len = avcodec_decode_video2(codec_ctx, decoder->frames->decoding_frame, &got_picture, &packet);
|
||||
if (len < 0) {
|
||||
LOGE("Could not decode video packet: %d", len);
|
||||
av_packet_unref(&packet);
|
||||
goto run_quit;
|
||||
}
|
||||
if (got_picture) {
|
||||
|
|
@ -124,6 +238,23 @@ static int run_decoder(void *data) {
|
|||
packet.data += len;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (decoder->recorder) {
|
||||
// we retrieve the PTS in order they were received, so they will
|
||||
// be assigned to the correct frame
|
||||
uint64_t pts = receiver_state_take_meta(&decoder->receiver_state);
|
||||
packet.pts = pts;
|
||||
packet.dts = pts;
|
||||
|
||||
// no need to rescale with av_packet_rescale_ts(), the timestamps
|
||||
// are in microseconds both in input and output
|
||||
if (!recorder_write(decoder->recorder, &packet)) {
|
||||
LOGE("Could not write frame to output file");
|
||||
av_packet_unref(&packet);
|
||||
goto run_quit;
|
||||
}
|
||||
}
|
||||
|
||||
av_packet_unref(&packet);
|
||||
|
||||
if (avio_ctx->eof_reached) {
|
||||
|
|
@ -134,6 +265,10 @@ static int run_decoder(void *data) {
|
|||
LOGD("End of frames");
|
||||
|
||||
run_quit:
|
||||
if (decoder->recorder) {
|
||||
recorder_close(decoder->recorder);
|
||||
}
|
||||
run_finally_close_input:
|
||||
avformat_close_input(&format_ctx);
|
||||
run_finally_free_avio_ctx:
|
||||
av_freep(&avio_ctx);
|
||||
|
|
@ -148,9 +283,11 @@ run_end:
|
|||
return 0;
|
||||
}
|
||||
|
||||
void decoder_init(struct decoder *decoder, struct frames *frames, socket_t video_socket) {
|
||||
void decoder_init(struct decoder *decoder, struct frames *frames,
|
||||
socket_t video_socket, struct recorder *recorder) {
|
||||
decoder->frames = frames;
|
||||
decoder->video_socket = video_socket;
|
||||
decoder->recorder = recorder;
|
||||
}
|
||||
|
||||
SDL_bool decoder_start(struct decoder *decoder) {
|
||||
|
|
@ -161,7 +298,6 @@ SDL_bool decoder_start(struct decoder *decoder) {
|
|||
LOGC("Could not start decoder thread");
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
return SDL_TRUE;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -4,18 +4,31 @@
|
|||
#include <SDL2/SDL_stdinc.h>
|
||||
#include <SDL2/SDL_thread.h>
|
||||
|
||||
#include "common.h"
|
||||
#include "net.h"
|
||||
|
||||
struct frames;
|
||||
|
||||
struct frame_meta {
|
||||
uint64_t pts;
|
||||
struct frame_meta *next;
|
||||
};
|
||||
|
||||
struct decoder {
|
||||
struct frames *frames;
|
||||
socket_t video_socket;
|
||||
SDL_Thread *thread;
|
||||
SDL_mutex *mutex;
|
||||
struct recorder *recorder;
|
||||
struct receiver_state {
|
||||
// meta (in order) for frames not consumed yet
|
||||
struct frame_meta *frame_meta_queue;
|
||||
size_t remaining; // remaining bytes to receive for the current frame
|
||||
} receiver_state;
|
||||
};
|
||||
|
||||
void decoder_init(struct decoder *decoder, struct frames *frames, socket_t video_socket);
|
||||
void decoder_init(struct decoder *decoder, struct frames *frames,
|
||||
socket_t video_socket, struct recorder *recoder);
|
||||
SDL_bool decoder_start(struct decoder *decoder);
|
||||
void decoder_stop(struct decoder *decoder);
|
||||
void decoder_join(struct decoder *decoder);
|
||||
|
|
|
|||
|
|
@ -155,14 +155,14 @@ void input_manager_process_key(struct input_manager *input_manager,
|
|||
SDL_bool alt = event->keysym.mod & (KMOD_LALT | KMOD_RALT);
|
||||
SDL_bool meta = event->keysym.mod & (KMOD_LGUI | KMOD_RGUI);
|
||||
|
||||
if (alt | meta) {
|
||||
if (alt) {
|
||||
// no shortcut involves Alt or Meta, and they should not be forwarded
|
||||
// to the device
|
||||
return;
|
||||
}
|
||||
|
||||
// capture all Ctrl events
|
||||
if (ctrl) {
|
||||
if (ctrl | meta) {
|
||||
SDL_bool shift = event->keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT);
|
||||
if (shift) {
|
||||
// currently, there is no shortcut involving SHIFT
|
||||
|
|
@ -174,61 +174,73 @@ void input_manager_process_key(struct input_manager *input_manager,
|
|||
SDL_bool repeat = event->repeat;
|
||||
switch (keycode) {
|
||||
case SDLK_h:
|
||||
if (!repeat) {
|
||||
if (ctrl && !meta && !repeat) {
|
||||
action_home(input_manager->controller, action);
|
||||
}
|
||||
return;
|
||||
case SDLK_b: // fall-through
|
||||
case SDLK_BACKSPACE:
|
||||
if (!repeat) {
|
||||
if (ctrl && !meta && !repeat) {
|
||||
action_back(input_manager->controller, action);
|
||||
}
|
||||
return;
|
||||
case SDLK_s:
|
||||
if (!repeat) {
|
||||
if (ctrl && !meta && !repeat) {
|
||||
action_app_switch(input_manager->controller, action);
|
||||
}
|
||||
return;
|
||||
case SDLK_m:
|
||||
if (!repeat) {
|
||||
if (ctrl && !meta && !repeat) {
|
||||
action_menu(input_manager->controller, action);
|
||||
}
|
||||
return;
|
||||
case SDLK_p:
|
||||
if (!repeat) {
|
||||
if (ctrl && !meta && !repeat) {
|
||||
action_power(input_manager->controller, action);
|
||||
}
|
||||
return;
|
||||
case SDLK_DOWN:
|
||||
// forward repeated events
|
||||
action_volume_down(input_manager->controller, action);
|
||||
#ifdef __APPLE__
|
||||
if (!ctrl && meta) {
|
||||
#else
|
||||
if (ctrl && !meta) {
|
||||
#endif
|
||||
// forward repeated events
|
||||
action_volume_down(input_manager->controller, action);
|
||||
}
|
||||
return;
|
||||
case SDLK_UP:
|
||||
// forward repeated events
|
||||
action_volume_up(input_manager->controller, action);
|
||||
#ifdef __APPLE__
|
||||
if (!ctrl && meta) {
|
||||
#else
|
||||
if (ctrl && !meta) {
|
||||
#endif
|
||||
// forward repeated events
|
||||
action_volume_up(input_manager->controller, action);
|
||||
}
|
||||
return;
|
||||
case SDLK_v:
|
||||
if (!repeat && event->type == SDL_KEYDOWN) {
|
||||
if (ctrl && !meta && !repeat && event->type == SDL_KEYDOWN) {
|
||||
clipboard_paste(input_manager->controller);
|
||||
}
|
||||
return;
|
||||
case SDLK_f:
|
||||
if (!repeat && event->type == SDL_KEYDOWN) {
|
||||
if (ctrl && !meta && !repeat && event->type == SDL_KEYDOWN) {
|
||||
screen_switch_fullscreen(input_manager->screen);
|
||||
}
|
||||
return;
|
||||
case SDLK_x:
|
||||
if (!repeat && event->type == SDL_KEYDOWN) {
|
||||
if (ctrl && !meta && !repeat && event->type == SDL_KEYDOWN) {
|
||||
screen_resize_to_fit(input_manager->screen);
|
||||
}
|
||||
return;
|
||||
case SDLK_g:
|
||||
if (!repeat && event->type == SDL_KEYDOWN) {
|
||||
if (ctrl && !meta && !repeat && event->type == SDL_KEYDOWN) {
|
||||
screen_resize_to_pixel_perfect(input_manager->screen);
|
||||
}
|
||||
return;
|
||||
case SDLK_i:
|
||||
if (!repeat && event->type == SDL_KEYDOWN) {
|
||||
if (ctrl && !meta && !repeat && event->type == SDL_KEYDOWN) {
|
||||
switch_fps_counter_state(input_manager->frames);
|
||||
}
|
||||
return;
|
||||
|
|
|
|||
|
|
@ -11,6 +11,7 @@
|
|||
struct args {
|
||||
const char *serial;
|
||||
const char *crop;
|
||||
const char *record_filename;
|
||||
SDL_bool fullscreen;
|
||||
SDL_bool help;
|
||||
SDL_bool version;
|
||||
|
|
@ -53,6 +54,9 @@ static void usage(const char *arg0) {
|
|||
" Set the TCP port the client listens on.\n"
|
||||
" Default is %d.\n"
|
||||
"\n"
|
||||
" -r, --record file.mp4\n"
|
||||
" Record screen to file.\n"
|
||||
"\n"
|
||||
" -s, --serial\n"
|
||||
" The device serial number. Mandatory only if several devices\n"
|
||||
" are connected to adb.\n"
|
||||
|
|
@ -208,13 +212,14 @@ static SDL_bool parse_args(struct args *args, int argc, char *argv[]) {
|
|||
{"help", no_argument, NULL, 'h'},
|
||||
{"max-size", required_argument, NULL, 'm'},
|
||||
{"port", required_argument, NULL, 'p'},
|
||||
{"record", required_argument, NULL, 'r'},
|
||||
{"serial", required_argument, NULL, 's'},
|
||||
{"show-touches", no_argument, NULL, 't'},
|
||||
{"version", no_argument, NULL, 'v'},
|
||||
{NULL, 0, NULL, 0 },
|
||||
};
|
||||
int c;
|
||||
while ((c = getopt_long(argc, argv, "b:c:fhm:p:s:tv", long_options, NULL)) != -1) {
|
||||
while ((c = getopt_long(argc, argv, "b:c:fhm:p:r:s:tv", long_options, NULL)) != -1) {
|
||||
switch (c) {
|
||||
case 'b':
|
||||
if (!parse_bit_rate(optarg, &args->bit_rate)) {
|
||||
|
|
@ -240,6 +245,9 @@ static SDL_bool parse_args(struct args *args, int argc, char *argv[]) {
|
|||
return SDL_FALSE;
|
||||
}
|
||||
break;
|
||||
case 'r':
|
||||
args->record_filename = optarg;
|
||||
break;
|
||||
case 's':
|
||||
args->serial = optarg;
|
||||
break;
|
||||
|
|
@ -273,6 +281,7 @@ int main(int argc, char *argv[]) {
|
|||
struct args args = {
|
||||
.serial = NULL,
|
||||
.crop = NULL,
|
||||
.record_filename = NULL,
|
||||
.help = SDL_FALSE,
|
||||
.version = SDL_FALSE,
|
||||
.show_touches = SDL_FALSE,
|
||||
|
|
@ -310,6 +319,7 @@ int main(int argc, char *argv[]) {
|
|||
.serial = args.serial,
|
||||
.crop = args.crop,
|
||||
.port = args.port,
|
||||
.record_filename = args.record_filename,
|
||||
.max_size = args.max_size,
|
||||
.bit_rate = args.bit_rate,
|
||||
.show_touches = args.show_touches,
|
||||
|
|
|
|||
118
app/src/recorder.c
Normal file
118
app/src/recorder.c
Normal file
|
|
@ -0,0 +1,118 @@
|
|||
#include "recorder.h"
|
||||
|
||||
#include <libavutil/time.h>
|
||||
|
||||
#include "config.h"
|
||||
#include "log.h"
|
||||
|
||||
static const AVOutputFormat *find_mp4_muxer(void) {
|
||||
#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(58, 9, 100)
|
||||
void *opaque = NULL;
|
||||
#endif
|
||||
const AVOutputFormat *oformat = NULL;
|
||||
do {
|
||||
#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(58, 9, 100)
|
||||
oformat = av_muxer_iterate(&opaque);
|
||||
#else
|
||||
oformat = av_oformat_next(oformat);
|
||||
#endif
|
||||
// until null or with name "mp4"
|
||||
} while (oformat && strcmp(oformat->name, "mp4"));
|
||||
return oformat;
|
||||
}
|
||||
|
||||
SDL_bool recorder_init(struct recorder *recorder, const char *filename,
|
||||
struct size declared_frame_size) {
|
||||
recorder->filename = SDL_strdup(filename);
|
||||
if (!recorder->filename) {
|
||||
LOGE("Cannot strdup filename");
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
recorder->declared_frame_size = declared_frame_size;
|
||||
|
||||
return SDL_TRUE;
|
||||
}
|
||||
|
||||
void recorder_destroy(struct recorder *recorder) {
|
||||
SDL_free(recorder->filename);
|
||||
}
|
||||
|
||||
SDL_bool recorder_open(struct recorder *recorder, AVCodec *input_codec) {
|
||||
const AVOutputFormat *mp4 = find_mp4_muxer();
|
||||
if (!mp4) {
|
||||
LOGE("Could not find mp4 muxer");
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
recorder->ctx = avformat_alloc_context();
|
||||
if (!recorder->ctx) {
|
||||
LOGE("Could not allocate output context");
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
// contrary to the deprecated API (av_oformat_next()), av_muxer_iterate()
|
||||
// returns (on purpose) a pointer-to-const, but AVFormatContext.oformat
|
||||
// still expects a pointer-to-non-const (it has not be updated accordingly)
|
||||
// <https://github.com/FFmpeg/FFmpeg/commit/0694d8702421e7aff1340038559c438b61bb30dd>
|
||||
recorder->ctx->oformat = (AVOutputFormat *) mp4;
|
||||
|
||||
AVStream *ostream = avformat_new_stream(recorder->ctx, input_codec);
|
||||
if (!ostream) {
|
||||
avformat_free_context(recorder->ctx);
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
// In ffmpeg/doc/APIchanges:
|
||||
// 2016-04-11 - 6f69f7a / 9200514 - lavf 57.33.100 / 57.5.0 - avformat.h
|
||||
// Add AVStream.codecpar, deprecate AVStream.codec.
|
||||
#if (LIBAVFORMAT_VERSION_MICRO >= 100 /* FFmpeg */ && \
|
||||
LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(57, 33, 100)) \
|
||||
|| (LIBAVFORMAT_VERSION_MICRO < 100 && /* Libav */ \
|
||||
LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(57, 5, 0))
|
||||
ostream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
|
||||
ostream->codecpar->codec_id = input_codec->id;
|
||||
ostream->codecpar->format = AV_PIX_FMT_YUV420P;
|
||||
ostream->codecpar->width = recorder->declared_frame_size.width;
|
||||
ostream->codecpar->height = recorder->declared_frame_size.height;
|
||||
#else
|
||||
ostream->codec->codec_type = AVMEDIA_TYPE_VIDEO;
|
||||
ostream->codec->codec_id = input_codec->id;
|
||||
ostream->codec->pix_fmt = AV_PIX_FMT_YUV420P;
|
||||
ostream->codec->width = recorder->declared_frame_size.width;
|
||||
ostream->codec->height = recorder->declared_frame_size.height;
|
||||
#endif
|
||||
ostream->time_base = (AVRational) {1, 1000000}; // timestamps in us
|
||||
|
||||
int ret = avio_open(&recorder->ctx->pb, recorder->filename,
|
||||
AVIO_FLAG_WRITE);
|
||||
if (ret < 0) {
|
||||
LOGE("Failed to open output file: %s", recorder->filename);
|
||||
// ostream will be cleaned up during context cleaning
|
||||
avformat_free_context(recorder->ctx);
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
ret = avformat_write_header(recorder->ctx, NULL);
|
||||
if (ret < 0) {
|
||||
LOGE("Failed to write header to %s", recorder->filename);
|
||||
avio_closep(&recorder->ctx->pb);
|
||||
avformat_free_context(recorder->ctx);
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
return SDL_TRUE;
|
||||
}
|
||||
|
||||
void recorder_close(struct recorder *recorder) {
|
||||
int ret = av_write_trailer(recorder->ctx);
|
||||
if (ret < 0) {
|
||||
LOGE("Failed to write trailer to %s", recorder->filename);
|
||||
}
|
||||
avio_close(recorder->ctx->pb);
|
||||
avformat_free_context(recorder->ctx);
|
||||
}
|
||||
|
||||
SDL_bool recorder_write(struct recorder *recorder, AVPacket *packet) {
|
||||
return av_write_frame(recorder->ctx, packet) >= 0;
|
||||
}
|
||||
24
app/src/recorder.h
Normal file
24
app/src/recorder.h
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
#ifndef RECORDER_H
|
||||
#define RECORDER_H
|
||||
|
||||
#include <libavformat/avformat.h>
|
||||
#include <SDL2/SDL_stdinc.h>
|
||||
|
||||
#include "common.h"
|
||||
|
||||
struct recorder {
|
||||
char *filename;
|
||||
AVFormatContext *ctx;
|
||||
struct size declared_frame_size;
|
||||
};
|
||||
|
||||
SDL_bool recorder_init(struct recorder *recoder, const char *filename,
|
||||
struct size declared_frame_size);
|
||||
void recorder_destroy(struct recorder *recorder);
|
||||
|
||||
SDL_bool recorder_open(struct recorder *recorder, AVCodec *input_codec);
|
||||
void recorder_close(struct recorder *recorder);
|
||||
|
||||
SDL_bool recorder_write(struct recorder *recorder, AVPacket *packet);
|
||||
|
||||
#endif
|
||||
|
|
@ -20,6 +20,7 @@
|
|||
#include "log.h"
|
||||
#include "lock_util.h"
|
||||
#include "net.h"
|
||||
#include "recorder.h"
|
||||
#include "screen.h"
|
||||
#include "server.h"
|
||||
#include "tiny_xpm.h"
|
||||
|
|
@ -30,6 +31,7 @@ static struct frames frames;
|
|||
static struct decoder decoder;
|
||||
static struct controller controller;
|
||||
static struct file_handler file_handler;
|
||||
static struct recorder recorder;
|
||||
|
||||
static struct input_manager input_manager = {
|
||||
.controller = &controller,
|
||||
|
|
@ -138,8 +140,10 @@ static void wait_show_touches(process_t process) {
|
|||
}
|
||||
|
||||
SDL_bool scrcpy(const struct scrcpy_options *options) {
|
||||
SDL_bool send_frame_meta = !!options->record_filename;
|
||||
if (!server_start(&server, options->serial, options->port,
|
||||
options->max_size, options->bit_rate, options->crop)) {
|
||||
options->max_size, options->bit_rate, options->crop,
|
||||
send_frame_meta)) {
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
|
|
@ -153,10 +157,6 @@ SDL_bool scrcpy(const struct scrcpy_options *options) {
|
|||
|
||||
SDL_bool ret = SDL_TRUE;
|
||||
|
||||
if (!SDL_SetHint(SDL_HINT_NO_SIGNAL_HANDLERS, "1")) {
|
||||
LOGW("Cannot request to keep default signal handlers");
|
||||
}
|
||||
|
||||
if (!sdl_init_and_configure()) {
|
||||
ret = SDL_FALSE;
|
||||
goto finally_destroy_server;
|
||||
|
|
@ -193,14 +193,24 @@ SDL_bool scrcpy(const struct scrcpy_options *options) {
|
|||
goto finally_destroy_frames;
|
||||
}
|
||||
|
||||
decoder_init(&decoder, &frames, device_socket);
|
||||
struct recorder *rec = NULL;
|
||||
if (options->record_filename) {
|
||||
if (!recorder_init(&recorder, options->record_filename, frame_size)) {
|
||||
ret = SDL_FALSE;
|
||||
server_stop(&server);
|
||||
goto finally_destroy_file_handler;
|
||||
}
|
||||
rec = &recorder;
|
||||
}
|
||||
|
||||
decoder_init(&decoder, &frames, device_socket, rec);
|
||||
|
||||
// now we consumed the header values, the socket receives the video stream
|
||||
// start the decoder
|
||||
if (!decoder_start(&decoder)) {
|
||||
ret = SDL_FALSE;
|
||||
server_stop(&server);
|
||||
goto finally_destroy_file_handler;
|
||||
goto finally_destroy_recorder;
|
||||
}
|
||||
|
||||
if (!controller_init(&controller, device_socket)) {
|
||||
|
|
@ -246,6 +256,10 @@ finally_destroy_file_handler:
|
|||
file_handler_stop(&file_handler);
|
||||
file_handler_join(&file_handler);
|
||||
file_handler_destroy(&file_handler);
|
||||
finally_destroy_recorder:
|
||||
if (options->record_filename) {
|
||||
recorder_destroy(&recorder);
|
||||
}
|
||||
finally_destroy_frames:
|
||||
frames_destroy(&frames);
|
||||
finally_destroy_server:
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@
|
|||
struct scrcpy_options {
|
||||
const char *serial;
|
||||
const char *crop;
|
||||
const char *record_filename;
|
||||
Uint16 port;
|
||||
Uint16 max_size;
|
||||
Uint32 bit_rate;
|
||||
|
|
|
|||
|
|
@ -78,7 +78,8 @@ static SDL_bool disable_tunnel(struct server *server) {
|
|||
|
||||
static process_t execute_server(const char *serial,
|
||||
Uint16 max_size, Uint32 bit_rate,
|
||||
const char *crop, SDL_bool tunnel_forward) {
|
||||
SDL_bool tunnel_forward, const char *crop,
|
||||
SDL_bool send_frame_meta) {
|
||||
char max_size_string[6];
|
||||
char bit_rate_string[11];
|
||||
sprintf(max_size_string, "%"PRIu16, max_size);
|
||||
|
|
@ -92,7 +93,8 @@ static process_t execute_server(const char *serial,
|
|||
max_size_string,
|
||||
bit_rate_string,
|
||||
tunnel_forward ? "true" : "false",
|
||||
crop ? crop : "",
|
||||
crop ? crop : "''",
|
||||
send_frame_meta ? "true" : "false",
|
||||
};
|
||||
return adb_execute(serial, cmd, sizeof(cmd) / sizeof(cmd[0]));
|
||||
}
|
||||
|
|
@ -148,8 +150,9 @@ void server_init(struct server *server) {
|
|||
*server = (struct server) SERVER_INITIALIZER;
|
||||
}
|
||||
|
||||
SDL_bool server_start(struct server *server, const char *serial, Uint16 local_port,
|
||||
Uint16 max_size, Uint32 bit_rate, const char *crop) {
|
||||
SDL_bool server_start(struct server *server, const char *serial,
|
||||
Uint16 local_port, Uint16 max_size, Uint32 bit_rate,
|
||||
const char *crop, SDL_bool send_frame_meta) {
|
||||
server->local_port = local_port;
|
||||
|
||||
if (serial) {
|
||||
|
|
@ -190,8 +193,10 @@ SDL_bool server_start(struct server *server, const char *serial, Uint16 local_po
|
|||
}
|
||||
|
||||
// server will connect to our server socket
|
||||
server->process = execute_server(serial, max_size, bit_rate, crop,
|
||||
server->tunnel_forward);
|
||||
server->process = execute_server(serial, max_size, bit_rate,
|
||||
server->tunnel_forward, crop,
|
||||
send_frame_meta);
|
||||
|
||||
if (server->process == PROCESS_NONE) {
|
||||
if (!server->tunnel_forward) {
|
||||
close_socket(&server->server_socket);
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ struct server {
|
|||
Uint16 local_port;
|
||||
SDL_bool tunnel_enabled;
|
||||
SDL_bool tunnel_forward; // use "adb forward" instead of "adb reverse"
|
||||
SDL_bool send_frame_meta; // request frame PTS to be able to record properly
|
||||
SDL_bool server_copied_to_device;
|
||||
};
|
||||
|
||||
|
|
@ -23,6 +24,7 @@ struct server {
|
|||
.local_port = 0, \
|
||||
.tunnel_enabled = SDL_FALSE, \
|
||||
.tunnel_forward = SDL_FALSE, \
|
||||
.send_frame_meta = SDL_FALSE, \
|
||||
.server_copied_to_device = SDL_FALSE, \
|
||||
}
|
||||
|
||||
|
|
@ -30,8 +32,9 @@ struct server {
|
|||
void server_init(struct server *server);
|
||||
|
||||
// push, enable tunnel et start the server
|
||||
SDL_bool server_start(struct server *server, const char *serial, Uint16 local_port,
|
||||
Uint16 max_size, Uint32 bit_rate, const char *crop);
|
||||
SDL_bool server_start(struct server *server, const char *serial,
|
||||
Uint16 local_port, Uint16 max_size, Uint32 bit_rate,
|
||||
const char *crop, SDL_bool send_frame_meta);
|
||||
|
||||
// block until the communication with the server is established
|
||||
socket_t server_connect_to(struct server *server);
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#define _POSIX_SOURCE // for kill()
|
||||
|
||||
#include "command.h"
|
||||
|
||||
#include <errno.h>
|
||||
|
|
|
|||
|
|
@ -17,4 +17,4 @@ endian = 'little'
|
|||
[properties]
|
||||
prebuilt_ffmpeg_shared = 'ffmpeg-4.0.2-win32-shared'
|
||||
prebuilt_ffmpeg_dev = 'ffmpeg-4.0.2-win32-dev'
|
||||
prebuilt_sdl2 = 'SDL2-2.0.8/i686-w64-mingw32'
|
||||
prebuilt_sdl2 = 'SDL2-2.0.9/i686-w64-mingw32'
|
||||
|
|
|
|||
|
|
@ -17,4 +17,4 @@ endian = 'little'
|
|||
[properties]
|
||||
prebuilt_ffmpeg_shared = 'ffmpeg-4.0.2-win64-shared'
|
||||
prebuilt_ffmpeg_dev = 'ffmpeg-4.0.2-win64-dev'
|
||||
prebuilt_sdl2 = 'SDL2-2.0.8/x86_64-w64-mingw32'
|
||||
prebuilt_sdl2 = 'SDL2-2.0.9/x86_64-w64-mingw32'
|
||||
|
|
|
|||
|
|
@ -15,3 +15,4 @@ org.gradle.jvmargs=-Xmx1536m
|
|||
# This option should only be used with decoupled projects. More details, visit
|
||||
# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
|
||||
# org.gradle.parallel=true
|
||||
|
||||
|
|
|
|||
|
|
@ -30,9 +30,9 @@ prepare-ffmpeg-dev-win64:
|
|||
ffmpeg-4.0.2-win64-dev
|
||||
|
||||
prepare-sdl2:
|
||||
@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.8-mingw.tar.gz \
|
||||
ffff7305d634aff5e1df5b7bb935435c3a02c8b03ad94a1a2be9169a558a7961 \
|
||||
SDL2-2.0.8
|
||||
@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.9-mingw.tar.gz \
|
||||
0f9f00d0f2a9a95dfb5cce929718210c3f85432cc2e9d4abade4adcb7f6bb39d \
|
||||
SDL2-2.0.9
|
||||
|
||||
prepare-adb:
|
||||
@./prepare-dep https://dl.google.com/android/repository/platform-tools_r28.0.1-windows.zip \
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ public class Options {
|
|||
private int bitRate;
|
||||
private boolean tunnelForward;
|
||||
private Rect crop;
|
||||
private boolean sendFrameMeta; // send PTS so that the client may record properly
|
||||
|
||||
public int getMaxSize() {
|
||||
return maxSize;
|
||||
|
|
@ -39,4 +40,12 @@ public class Options {
|
|||
public void setCrop(Rect crop) {
|
||||
this.crop = crop;
|
||||
}
|
||||
|
||||
public boolean getSendFrameMeta() {
|
||||
return sendFrameMeta;
|
||||
}
|
||||
|
||||
public void setSendFrameMeta(boolean sendFrameMeta) {
|
||||
this.sendFrameMeta = sendFrameMeta;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@ package com.genymobile.scrcpy;
|
|||
import com.genymobile.scrcpy.wrappers.SurfaceControl;
|
||||
|
||||
import android.graphics.Rect;
|
||||
import android.media.MediaMuxer;
|
||||
import android.media.MediaCodec;
|
||||
import android.media.MediaCodecInfo;
|
||||
import android.media.MediaFormat;
|
||||
|
|
@ -22,21 +23,26 @@ public class ScreenEncoder implements Device.RotationListener {
|
|||
private static final int REPEAT_FRAME_DELAY = 6; // repeat after 6 frames
|
||||
|
||||
private static final int MICROSECONDS_IN_ONE_SECOND = 1_000_000;
|
||||
private static final int NO_PTS = -1;
|
||||
|
||||
private final AtomicBoolean rotationChanged = new AtomicBoolean();
|
||||
private final ByteBuffer headerBuffer = ByteBuffer.allocate(12);
|
||||
|
||||
private int bitRate;
|
||||
private int frameRate;
|
||||
private int iFrameInterval;
|
||||
private boolean sendFrameMeta;
|
||||
private long ptsOrigin;
|
||||
|
||||
public ScreenEncoder(int bitRate, int frameRate, int iFrameInterval) {
|
||||
public ScreenEncoder(boolean sendFrameMeta, int bitRate, int frameRate, int iFrameInterval) {
|
||||
this.sendFrameMeta = sendFrameMeta;
|
||||
this.bitRate = bitRate;
|
||||
this.frameRate = frameRate;
|
||||
this.iFrameInterval = iFrameInterval;
|
||||
}
|
||||
|
||||
public ScreenEncoder(int bitRate) {
|
||||
this(bitRate, DEFAULT_FRAME_RATE, DEFAULT_I_FRAME_INTERVAL);
|
||||
public ScreenEncoder(boolean sendFrameMeta, int bitRate) {
|
||||
this(sendFrameMeta, bitRate, DEFAULT_FRAME_RATE, DEFAULT_I_FRAME_INTERVAL);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -80,6 +86,8 @@ public class ScreenEncoder implements Device.RotationListener {
|
|||
private boolean encode(MediaCodec codec, FileDescriptor fd) throws IOException {
|
||||
boolean eof = false;
|
||||
MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
|
||||
|
||||
|
||||
while (!consumeRotationChange() && !eof) {
|
||||
int outputBufferId = codec.dequeueOutputBuffer(bufferInfo, -1);
|
||||
eof = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0;
|
||||
|
|
@ -90,6 +98,11 @@ public class ScreenEncoder implements Device.RotationListener {
|
|||
}
|
||||
if (outputBufferId >= 0) {
|
||||
ByteBuffer codecBuffer = codec.getOutputBuffer(outputBufferId);
|
||||
|
||||
if (sendFrameMeta) {
|
||||
writeFrameMeta(fd, bufferInfo, codecBuffer.remaining());
|
||||
}
|
||||
|
||||
IO.writeFully(fd, codecBuffer);
|
||||
}
|
||||
} finally {
|
||||
|
|
@ -102,6 +115,25 @@ public class ScreenEncoder implements Device.RotationListener {
|
|||
return !eof;
|
||||
}
|
||||
|
||||
private void writeFrameMeta(FileDescriptor fd, MediaCodec.BufferInfo bufferInfo, int packetSize) throws IOException {
|
||||
headerBuffer.clear();
|
||||
|
||||
long pts;
|
||||
if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
|
||||
pts = NO_PTS; // non-media data packet
|
||||
} else {
|
||||
if (ptsOrigin == 0) {
|
||||
ptsOrigin = bufferInfo.presentationTimeUs;
|
||||
}
|
||||
pts = bufferInfo.presentationTimeUs - ptsOrigin;
|
||||
}
|
||||
|
||||
headerBuffer.putLong(pts);
|
||||
headerBuffer.putInt(packetSize);
|
||||
headerBuffer.flip();
|
||||
IO.writeFully(fd, headerBuffer);
|
||||
}
|
||||
|
||||
private static MediaCodec createCodec() throws IOException {
|
||||
return MediaCodec.createEncoderByType("video/avc");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@ package com.genymobile.scrcpy;
|
|||
import android.graphics.Rect;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.util.Arrays;
|
||||
|
||||
public final class Server {
|
||||
|
||||
|
|
@ -14,7 +15,7 @@ public final class Server {
|
|||
final Device device = new Device(options);
|
||||
boolean tunnelForward = options.isTunnelForward();
|
||||
try (DesktopConnection connection = DesktopConnection.open(device, tunnelForward)) {
|
||||
ScreenEncoder screenEncoder = new ScreenEncoder(options.getBitRate());
|
||||
ScreenEncoder screenEncoder = new ScreenEncoder(options.getSendFrameMeta(), options.getBitRate());
|
||||
|
||||
// asynchronous
|
||||
startEventController(device, connection);
|
||||
|
|
@ -71,6 +72,12 @@ public final class Server {
|
|||
Rect crop = parseCrop(args[3]);
|
||||
options.setCrop(crop);
|
||||
|
||||
if (args.length < 5) {
|
||||
return options;
|
||||
}
|
||||
boolean sendFrameMeta = Boolean.parseBoolean(args[4]);
|
||||
options.setSendFrameMeta(sendFrameMeta);
|
||||
|
||||
return options;
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue