Center the window on resize-to-fit

When removing the black borders (by double-clicking on them, or by
pressing MOD+w), the window is resized to fit the device screen, but its
top-left position was left unchanged.

Instead, move the window so that the new window area is at the center of
the old window area.

Refs #2387 <https://github.com/Genymobile/scrcpy/issues/2387>

README.md

@@ -303,7 +303,8 @@ To start scrcpy using a v4l2 sink:
 
 ```bash
 scrcpy --v4l2-sink=/dev/videoN
-scrcpy --v4l2-sink=/dev/videoN -N  # --no-display to disable mirroring window
+scrcpy --v4l2-sink=/dev/videoN --no-display  # disable mirroring window
+scrcpy --v4l2-sink=/dev/videoN -N            # short version
 ```
 
 (replace `N` by the device ID, check with `ls /dev/video*`)

app/src/recorder.c

@@ -35,11 +35,14 @@ record_packet_new(const AVPacket *packet) {
         return NULL;
     }
 
-    // av_packet_ref() does not initialize all fields in old FFmpeg versions
-    // See <https://github.com/Genymobile/scrcpy/issues/707>
-    av_init_packet(&rec->packet);
+    rec->packet = av_packet_alloc();
+    if (!rec->packet) {
+        free(rec);
+        return NULL;
+    }
 
-    if (av_packet_ref(&rec->packet, packet)) {
+    if (av_packet_ref(rec->packet, packet)) {
+        av_packet_free(&rec->packet);
         free(rec);
         return NULL;
     }
@@ -48,7 +51,8 @@ record_packet_new(const AVPacket *packet) {
 
 static void
 record_packet_delete(struct record_packet *rec) {
-    av_packet_unref(&rec->packet);
+    av_packet_unref(rec->packet);
+    av_packet_free(&rec->packet);
     free(rec);
 }
 
@@ -144,8 +148,8 @@ run_recorder(void *data) {
             struct record_packet *last = recorder->previous;
             if (last) {
                 // assign an arbitrary duration to the last packet
-                last->packet.duration = 100000;
-                bool ok = recorder_write(recorder, &last->packet);
+                last->packet->duration = 100000;
+                bool ok = recorder_write(recorder, last->packet);
                 if (!ok) {
                     // failing to write the last frame is not very serious, no
                     // future frame may depend on it, so the resulting file
@@ -172,13 +176,14 @@ run_recorder(void *data) {
         }
 
         // config packets have no PTS, we must ignore them
-        if (rec->packet.pts != AV_NOPTS_VALUE
-            && previous->packet.pts != AV_NOPTS_VALUE) {
+        if (rec->packet->pts != AV_NOPTS_VALUE
+            && previous->packet->pts != AV_NOPTS_VALUE) {
             // we now know the duration of the previous packet
-            previous->packet.duration = rec->packet.pts - previous->packet.pts;
+            previous->packet->duration =
+                rec->packet->pts - previous->packet->pts;
         }
 
-        bool ok = recorder_write(recorder, &previous->packet);
+        bool ok = recorder_write(recorder, previous->packet);
         record_packet_delete(previous);
         if (!ok) {
             LOGE("Could not record packet");

app/src/recorder.h

@@ -13,7 +13,7 @@
 #include "util/thread.h"
 
 struct record_packet {
-    AVPacket packet;
+    AVPacket *packet;
     struct record_packet *next;
 };
 

app/src/screen.c

@@ -41,6 +41,18 @@ get_window_size(const struct screen *screen) {
     return size;
 }
 
+static struct point
+get_window_position(const struct screen *screen) {
+    int x;
+    int y;
+    SDL_GetWindowPosition(screen->window, &x, &y);
+
+    struct point point;
+    point.x = x;
+    point.y = y;
+    return point;
+}
+
 // set the window size to be applied when fullscreen is disabled
 static void
 set_window_size(struct screen *screen, struct size new_size) {
@@ -122,13 +134,6 @@ get_optimal_size(struct size current_size, struct size content_size) {
     return window_size;
 }
 
-// same as get_optimal_size(), but read the current size from the window
-static inline struct size
-get_optimal_window_size(const struct screen *screen, struct size content_size) {
-    struct size window_size = get_window_size(screen);
-    return get_optimal_size(window_size, content_size);
-}
-
 // initially, there is no current size, so use the frame size as current size
 // req_width and req_height, if not 0, are the sizes requested by the user
 static inline struct size
@@ -662,9 +667,20 @@ screen_resize_to_fit(struct screen *screen) {
         return;
     }
 
+    struct point point = get_window_position(screen);
+    struct size window_size = get_window_size(screen);
+
     struct size optimal_size =
-        get_optimal_window_size(screen, screen->content_size);
+        get_optimal_size(window_size, screen->content_size);
+
+    // Center the window related to the device screen
+    assert(optimal_size.width <= window_size.width);
+    assert(optimal_size.height <= window_size.height);
+    uint32_t new_x = point.x + (window_size.width - optimal_size.width) / 2;
+    uint32_t new_y = point.y + (window_size.height - optimal_size.height) / 2;
+
     SDL_SetWindowSize(screen->window, optimal_size.width, optimal_size.height);
+    SDL_SetWindowPosition(screen->window, new_x, new_y);
     LOGD("Resized to optimal size: %ux%u", optimal_size.width,
                                            optimal_size.height);
 }
@@ -726,6 +742,7 @@ screen_handle_event(struct screen *screen, SDL_Event *event) {
                     }
                     screen->maximized = false;
                     apply_pending_resize(screen);
+                    screen_render(screen, true);
                     break;
             }
             return true;

app/src/stream.c

@@ -104,33 +104,38 @@ static bool
 stream_push_packet(struct stream *stream, AVPacket *packet) {
     bool is_config = packet->pts == AV_NOPTS_VALUE;
 
-    // A config packet must not be decoded immetiately (it contains no
+    // A config packet must not be decoded immediately (it contains no
     // frame); instead, it must be concatenated with the future data packet.
-    if (stream->has_pending || is_config) {
+    if (stream->pending || is_config) {
         size_t offset;
-        if (stream->has_pending) {
-            offset = stream->pending.size;
-            if (av_grow_packet(&stream->pending, packet->size)) {
+        if (stream->pending) {
+            offset = stream->pending->size;
+            if (av_grow_packet(stream->pending, packet->size)) {
                 LOGE("Could not grow packet");
                 return false;
             }
         } else {
             offset = 0;
-            if (av_new_packet(&stream->pending, packet->size)) {
-                LOGE("Could not create packet");
+            stream->pending = av_packet_alloc();
+            if (!stream->pending) {
+                LOGE("Could not allocate packet");
+                return false;
+            }
+            if (av_new_packet(stream->pending, packet->size)) {
+                LOGE("Could not create packet");
+                av_packet_free(&stream->pending);
                 return false;
             }
-            stream->has_pending = true;
         }
 
-        memcpy(stream->pending.data + offset, packet->data, packet->size);
+        memcpy(stream->pending->data + offset, packet->data, packet->size);
 
         if (!is_config) {
             // prepare the concat packet to send to the decoder
-            stream->pending.pts = packet->pts;
-            stream->pending.dts = packet->dts;
-            stream->pending.flags = packet->flags;
-            packet = &stream->pending;
+            stream->pending->pts = packet->pts;
+            stream->pending->dts = packet->dts;
+            stream->pending->flags = packet->flags;
+            packet = stream->pending;
         }
     }
 
@@ -144,10 +149,10 @@ stream_push_packet(struct stream *stream, AVPacket *packet) {
         // data packet
         bool ok = stream_parse(stream, packet);
 
-        if (stream->has_pending) {
+        if (stream->pending) {
             // the pending packet must be discarded (consumed or error)
-            stream->has_pending = false;
-            av_packet_unref(&stream->pending);
+            av_packet_unref(stream->pending);
+            av_packet_free(&stream->pending);
         }
 
         if (!ok) {
@@ -215,16 +220,21 @@ run_stream(void *data) {
     // It's more complicated, but this allows to reduce the latency by 1 frame!
     stream->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
 
+    AVPacket *packet = av_packet_alloc();
+    if (!packet) {
+        LOGE("Could not allocate packet");
+        goto finally_close_parser;
+    }
+
     for (;;) {
-        AVPacket packet;
-        bool ok = stream_recv_packet(stream, &packet);
+        bool ok = stream_recv_packet(stream, packet);
         if (!ok) {
             // end of stream
             break;
         }
 
-        ok = stream_push_packet(stream, &packet);
-        av_packet_unref(&packet);
+        ok = stream_push_packet(stream, packet);
+        av_packet_unref(packet);
         if (!ok) {
             // cannot process packet (error already logged)
             break;
@@ -233,10 +243,13 @@ run_stream(void *data) {
 
     LOGD("End of frames");
 
-    if (stream->has_pending) {
-        av_packet_unref(&stream->pending);
+    if (stream->pending) {
+        av_packet_unref(stream->pending);
+        av_packet_free(&stream->pending);
     }
 
+    av_packet_free(&packet);
+finally_close_parser:
     av_parser_close(stream->parser);
 finally_close_sinks:
     stream_close_sinks(stream);
@@ -252,7 +265,7 @@ void
 stream_init(struct stream *stream, socket_t socket,
             const struct stream_callbacks *cbs, void *cbs_userdata) {
     stream->socket = socket;
-    stream->has_pending = false;
+    stream->pending = NULL;
     stream->sink_count = 0;
 
     assert(cbs && cbs->on_eos);

app/src/stream.h

@@ -24,8 +24,7 @@ struct stream {
     AVCodecParserContext *parser;
     // successive packets may need to be concatenated, until a non-config
     // packet is available
-    bool has_pending;
-    AVPacket pending;
+    AVPacket *pending;
 
     const struct stream_callbacks *cbs;
     void *cbs_userdata;

app/src/v4l2_sink.c

@@ -86,7 +86,7 @@ encode_and_write_frame(struct sc_v4l2_sink *vs, const AVFrame *frame) {
         return false;
     }
 
-    AVPacket *packet = &vs->packet;
+    AVPacket *packet = vs->packet;
     ret = avcodec_receive_packet(vs->encoder_ctx, packet);
     if (ret == 0) {
         // A packet was received
@@ -181,16 +181,16 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
     // <https://github.com/FFmpeg/FFmpeg/commit/0694d8702421e7aff1340038559c438b61bb30dd>
     vs->format_ctx->oformat = (AVOutputFormat *) format;
 #ifdef SCRCPY_LAVF_HAS_AVFORMATCONTEXT_URL
-# define CTX_URL_FIELD url
-#else
-# define CTX_URL_FIELD filename
-#endif
-    vs->format_ctx->CTX_URL_FIELD = strdup(vs->device_name);
+    vs->format_ctx->url = strdup(vs->device_name);
     if (!vs->format_ctx->url) {
         LOGE("Could not strdup v4l2 device name");
         goto error_avformat_free_context;
         return false;
     }
+#else
+    strncpy(vs->format_ctx->filename, vs->device_name,
+            sizeof(vs->format_ctx->filename));
+#endif
 
     AVStream *ostream = avformat_new_stream(vs->format_ctx, encoder);
     if (!ostream) {
@@ -235,11 +235,17 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
         goto error_avcodec_close;
     }
 
+    vs->packet = av_packet_alloc();
+    if (!vs->packet) {
+        LOGE("Could not allocate packet");
+        goto error_av_frame_free;
+    }
+
     LOGD("Starting v4l2 thread");
     ok = sc_thread_create(&vs->thread, run_v4l2_sink, "v4l2", vs);
     if (!ok) {
         LOGC("Could not start v4l2 thread");
-        goto error_av_frame_free;
+        goto error_av_packet_free;
     }
 
     vs->header_written = false;
@@ -249,6 +255,8 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
 
     return true;
 
+error_av_packet_free:
+    av_packet_free(&vs->packet);
 error_av_frame_free:
     av_frame_free(&vs->frame);
 error_avcodec_close:
@@ -278,6 +286,7 @@ sc_v4l2_sink_close(struct sc_v4l2_sink *vs) {
 
     sc_thread_join(&vs->thread, NULL);
 
+    av_packet_free(&vs->packet);
     av_frame_free(&vs->frame);
     avcodec_close(vs->encoder_ctx);
     avcodec_free_context(&vs->encoder_ctx);

app/src/v4l2_sink.h

@@ -26,7 +26,7 @@ struct sc_v4l2_sink {
     bool header_written;
 
     AVFrame *frame;
-    AVPacket packet;
+    AVPacket *packet;
 };
 
 bool