scrcpy/app/src/decoder.c

#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 "compat.h"
#include "config.h"
#include "buffer_util.h"
#include "events.h"
#include "lock_util.h"
#include "log.h"
#include "recorder.h"
#include "video_buffer.h"

// set the decoded frame as ready for rendering, and notify
static void
push_frame(struct decoder *decoder) {
    SDL_bool previous_frame_consumed =
            video_buffer_offer_decoded_frame(decoder->video_buffer);
    if (!previous_frame_consumed) {
        // the previous EVENT_NEW_FRAME will consume this frame
        return;
    }
    static SDL_Event new_frame_event = {
        .type = EVENT_NEW_FRAME,
    };
    SDL_PushEvent(&new_frame_event);
}

void
decoder_init(struct decoder *decoder, struct video_buffer *vb) {
    decoder->video_buffer = vb;
}

SDL_bool
decoder_open(struct decoder *decoder, AVCodec *codec) {
    decoder->codec_ctx = avcodec_alloc_context3(codec);
    if (!decoder->codec_ctx) {
        LOGC("Could not allocate decoder context");
        return SDL_FALSE;
    }

    if (avcodec_open2(decoder->codec_ctx, codec, NULL) < 0) {
        LOGE("Could not open codec");
        avcodec_free_context(&decoder->codec_ctx);
        return SDL_FALSE;
    }

    return SDL_TRUE;
}

void
decoder_close(struct decoder *decoder) {
    avcodec_close(decoder->codec_ctx);
    avcodec_free_context(&decoder->codec_ctx);
}

SDL_bool
decoder_push(struct decoder *decoder, AVPacket *packet) {
// the new decoding/encoding API has been introduced by:
// <http://git.videolan.org/?p=ffmpeg.git;a=commitdiff;h=7fc329e2dd6226dfecaa4a1d7adf353bf2773726>
#ifdef SCRCPY_LAVF_HAS_NEW_ENCODING_DECODING_API
    int ret;
    if ((ret = avcodec_send_packet(decoder->codec_ctx, packet)) < 0) {
        LOGE("Could not send video packet: %d", ret);
        return SDL_FALSE;
    }
    ret = avcodec_receive_frame(decoder->codec_ctx,
                                decoder->video_buffer->decoding_frame);
    if (!ret) {
        // a frame was received
        push_frame(decoder);
    } else if (ret != AVERROR(EAGAIN)) {
        LOGE("Could not receive video frame: %d", ret);
        return SDL_FALSE;
    }
#else
    int got_picture;
    int len = avcodec_decode_video2(decoder->codec_ctx,
                                    decoder->video_buffer->decoding_frame,
                                    &got_picture,
                                    packet);
    if (len < 0) {
        LOGE("Could not decode video packet: %d", len);
        return SDL_FALSE;
    }
    if (got_picture) {
        push_frame(decoder);
    }
#endif
    return SDL_TRUE;
}

void
decoder_interrupt(struct decoder *decoder) {
    video_buffer_interrupt(decoder->video_buffer);
}
Initial commit Start a new clean history from here. 7 years ago			`#include "decoder.h"`

			`#include <libavformat/avformat.h>`
Enable video output file, with pts set by server 6 years ago			`#include <libavutil/time.h>`
Avoid partial header reads Use net_recv_all() to avoid partial reads for the "meta" header (this would break the whole stream). 6 years ago			`#include <SDL2/SDL_assert.h>`
Replace SDL_net by custom implementation SDL_net is not very suitable for scrcpy. For example, SDLNet_TCP_Accept() is non-blocking, so we have to wrap it by calling many SDL_Net-specific functions to make it blocking. But above all, SDLNet_TCP_Open() is a server socket only when no IP is provided; otherwise, it's a client socket. Therefore, it is not possible to create a server socket bound to localhost, so it accepts connections from anywhere. This is a problem for scrcpy, because on start, the application listens for nearly 1 second until it accepts the first connection, supposedly from the device. If someone on the local network manages to connect to the server socket first, then they can stream arbitrary H.264 video. This may be troublesome, for example during a public presentation ;-) Provide our own simplified API (net.h) instead, implemented for the different platforms. 6 years ago			`#include <SDL2/SDL_events.h>`
Initial commit Start a new clean history from here. 7 years ago			`#include <SDL2/SDL_mutex.h>`
			`#include <SDL2/SDL_thread.h>`
			`#include <unistd.h>`

Move all compat ifdefs definitions to compat.h This allows to give a proper name to features requirements. 5 years ago			`#include "compat.h"`
Make SKIP_FRAMES a compilation flag The skip_frames flag was a non-configurable runtime flag. Since it is not exposed to the user, there is no need for a (possible) runtime cost. For testing purpose, we still want it to be configurable, so make it a compilation flag. 6 years ago			`#include "config.h"`
Move buffer reader functions to buffer_util.h 6 years ago			`#include "buffer_util.h"`
Initial commit Start a new clean history from here. 7 years ago			`#include "events.h"`
Separate multi-words filenames by '_' Rename foobar.ext to foo_bar.ext. <https://github.com/Genymobile/scrcpy/pull/226#discussion_r209454865> 6 years ago			`#include "lock_util.h"`
Define macros wrappers for logs Use macros to wrap SDL_Log* functions with the "application" category. 6 years ago			`#include "log.h"`
Add recorder Implement recording in a separate "class". 6 years ago			`#include "recorder.h"`
Rename "frames" to "video_buffer" It better describes the purpose of the structure. 5 years ago			`#include "video_buffer.h"`
Initial commit Start a new clean history from here. 7 years ago
			`// set the decoded frame as ready for rendering, and notify`
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.) 5 years ago			`static void`
			`push_frame(struct decoder *decoder) {`
			`SDL_bool previous_frame_consumed =`
			`video_buffer_offer_decoded_frame(decoder->video_buffer);`
Move frame swapping logic to frame.c Expose frames_offer_decoded_frame() and frames_consume_rendered_frame() so that callers are not exposed to frame swapping (between the decoding and rendering frames) details. 6 years ago			`if (!previous_frame_consumed) {`
			`// the previous EVENT_NEW_FRAME will consume this frame`
			`return;`
Make SKIP_FRAMES a compilation flag The skip_frames flag was a non-configurable runtime flag. Since it is not exposed to the user, there is no need for a (possible) runtime cost. For testing purpose, we still want it to be configurable, so make it a compilation flag. 6 years ago			`}`
Initial commit Start a new clean history from here. 7 years ago			`static SDL_Event new_frame_event = {`
			`.type = EVENT_NEW_FRAME,`
			`};`
			`SDL_PushEvent(&new_frame_event);`
			`}`

Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.) 5 years ago			`void`
			`decoder_init(struct decoder decoder, struct video_buffer vb) {`
Add stream layer The decoder initially read from the socket, decoded the video and sent the decoded frames to the screen: +---------+ +----------+ socket ---> \| decoder \| ---> \| screen \| +---------+ +----------+ The design was simple, but the decoder had several responsabilities. Then we added the recording feature, so we added a recorder, which reused the packets received from the socket managed by the decoder: +----------+ ---> \| screen \| +---------+ / +----------+ socket ---> \| decoder \| ---- +---------+ \ +----------+ ---> \| recorder \| +----------+ This lack of separation of concerns now have concrete implications: we could not (properly) disable the decoder/display to only record the video. Therefore, split the decoder to extract the stream: +----------+ +----------+ ---> \| decoder \| ---> \| screen \| +---------+ / +----------+ +----------+ socket ---> \| stream \| ---- +---------+ \ +----------+ ---> \| recorder \| +----------+ This will allow to record the stream without decoding the video. 5 years ago			`decoder->video_buffer = vb;`
Improve decoder stopped event The syntax was correct, but less readable, and it unnecessarily zeroed the fields other than "type". Create the event properly, from a separate method. 6 years ago			`}`

Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.) 5 years ago			`SDL_bool`
			`decoder_open(struct decoder decoder, AVCodec codec) {`
Add stream layer The decoder initially read from the socket, decoded the video and sent the decoded frames to the screen: +---------+ +----------+ socket ---> \| decoder \| ---> \| screen \| +---------+ +----------+ The design was simple, but the decoder had several responsabilities. Then we added the recording feature, so we added a recorder, which reused the packets received from the socket managed by the decoder: +----------+ ---> \| screen \| +---------+ / +----------+ socket ---> \| decoder \| ---- +---------+ \ +----------+ ---> \| recorder \| +----------+ This lack of separation of concerns now have concrete implications: we could not (properly) disable the decoder/display to only record the video. Therefore, split the decoder to extract the stream: +----------+ +----------+ ---> \| decoder \| ---> \| screen \| +---------+ / +----------+ +----------+ socket ---> \| stream \| ---- +---------+ \ +----------+ ---> \| recorder \| +----------+ This will allow to record the stream without decoding the video. 5 years ago			`decoder->codec_ctx = avcodec_alloc_context3(codec);`
			`if (!decoder->codec_ctx) {`
Define macros wrappers for logs Use macros to wrap SDL_Log* functions with the "application" category. 6 years ago			`LOGC("Could not allocate decoder context");`
Add stream layer The decoder initially read from the socket, decoded the video and sent the decoded frames to the screen: +---------+ +----------+ socket ---> \| decoder \| ---> \| screen \| +---------+ +----------+ The design was simple, but the decoder had several responsabilities. Then we added the recording feature, so we added a recorder, which reused the packets received from the socket managed by the decoder: +----------+ ---> \| screen \| +---------+ / +----------+ socket ---> \| decoder \| ---- +---------+ \ +----------+ ---> \| recorder \| +----------+ This lack of separation of concerns now have concrete implications: we could not (properly) disable the decoder/display to only record the video. Therefore, split the decoder to extract the stream: +----------+ +----------+ ---> \| decoder \| ---> \| screen \| +---------+ / +----------+ +----------+ socket ---> \| stream \| ---- +---------+ \ +----------+ ---> \| recorder \| +----------+ This will allow to record the stream without decoding the video. 5 years ago			`return SDL_FALSE;`
Initial commit Start a new clean history from here. 7 years ago			`}`

Add stream layer The decoder initially read from the socket, decoded the video and sent the decoded frames to the screen: +---------+ +----------+ socket ---> \| decoder \| ---> \| screen \| +---------+ +----------+ The design was simple, but the decoder had several responsabilities. Then we added the recording feature, so we added a recorder, which reused the packets received from the socket managed by the decoder: +----------+ ---> \| screen \| +---------+ / +----------+ socket ---> \| decoder \| ---- +---------+ \ +----------+ ---> \| recorder \| +----------+ This lack of separation of concerns now have concrete implications: we could not (properly) disable the decoder/display to only record the video. Therefore, split the decoder to extract the stream: +----------+ +----------+ ---> \| decoder \| ---> \| screen \| +---------+ / +----------+ +----------+ socket ---> \| stream \| ---- +---------+ \ +----------+ ---> \| recorder \| +----------+ This will allow to record the stream without decoding the video. 5 years ago			`if (avcodec_open2(decoder->codec_ctx, codec, NULL) < 0) {`
			`LOGE("Could not open codec");`
			`avcodec_free_context(&decoder->codec_ctx);`
			`return SDL_FALSE;`
Initial commit Start a new clean history from here. 7 years ago			`}`

Add stream layer The decoder initially read from the socket, decoded the video and sent the decoded frames to the screen: +---------+ +----------+ socket ---> \| decoder \| ---> \| screen \| +---------+ +----------+ The design was simple, but the decoder had several responsabilities. Then we added the recording feature, so we added a recorder, which reused the packets received from the socket managed by the decoder: +----------+ ---> \| screen \| +---------+ / +----------+ socket ---> \| decoder \| ---- +---------+ \ +----------+ ---> \| recorder \| +----------+ This lack of separation of concerns now have concrete implications: we could not (properly) disable the decoder/display to only record the video. Therefore, split the decoder to extract the stream: +----------+ +----------+ ---> \| decoder \| ---> \| screen \| +---------+ / +----------+ +----------+ socket ---> \| stream \| ---- +---------+ \ +----------+ ---> \| recorder \| +----------+ This will allow to record the stream without decoding the video. 5 years ago			`return SDL_TRUE;`
			`}`
Enable video output file, with pts set by server 6 years ago
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.) 5 years ago			`void`
			`decoder_close(struct decoder *decoder) {`
Add stream layer The decoder initially read from the socket, decoded the video and sent the decoded frames to the screen: +---------+ +----------+ socket ---> \| decoder \| ---> \| screen \| +---------+ +----------+ The design was simple, but the decoder had several responsabilities. Then we added the recording feature, so we added a recorder, which reused the packets received from the socket managed by the decoder: +----------+ ---> \| screen \| +---------+ / +----------+ socket ---> \| decoder \| ---- +---------+ \ +----------+ ---> \| recorder \| +----------+ This lack of separation of concerns now have concrete implications: we could not (properly) disable the decoder/display to only record the video. Therefore, split the decoder to extract the stream: +----------+ +----------+ ---> \| decoder \| ---> \| screen \| +---------+ / +----------+ +----------+ socket ---> \| stream \| ---- +---------+ \ +----------+ ---> \| recorder \| +----------+ This will allow to record the stream without decoding the video. 5 years ago			`avcodec_close(decoder->codec_ctx);`
			`avcodec_free_context(&decoder->codec_ctx);`
			`}`
Initial commit Start a new clean history from here. 7 years ago
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.) 5 years ago			`SDL_bool`
			`decoder_push(struct decoder decoder, AVPacket packet) {`
Initial commit Start a new clean history from here. 7 years ago			`// the new decoding/encoding API has been introduced by:`
			`// <http://git.videolan.org/?p=ffmpeg.git;a=commitdiff;h=7fc329e2dd6226dfecaa4a1d7adf353bf2773726>`
Move all compat ifdefs definitions to compat.h This allows to give a proper name to features requirements. 5 years ago			`#ifdef SCRCPY_LAVF_HAS_NEW_ENCODING_DECODING_API`
Add stream layer The decoder initially read from the socket, decoded the video and sent the decoded frames to the screen: +---------+ +----------+ socket ---> \| decoder \| ---> \| screen \| +---------+ +----------+ The design was simple, but the decoder had several responsabilities. Then we added the recording feature, so we added a recorder, which reused the packets received from the socket managed by the decoder: +----------+ ---> \| screen \| +---------+ / +----------+ socket ---> \| decoder \| ---- +---------+ \ +----------+ ---> \| recorder \| +----------+ This lack of separation of concerns now have concrete implications: we could not (properly) disable the decoder/display to only record the video. Therefore, split the decoder to extract the stream: +----------+ +----------+ ---> \| decoder \| ---> \| screen \| +---------+ / +----------+ +----------+ socket ---> \| stream \| ---- +---------+ \ +----------+ ---> \| recorder \| +----------+ This will allow to record the stream without decoding the video. 5 years ago			`int ret;`
			`if ((ret = avcodec_send_packet(decoder->codec_ctx, packet)) < 0) {`
			`LOGE("Could not send video packet: %d", ret);`
			`return SDL_FALSE;`
Initial commit Start a new clean history from here. 7 years ago			`}`
Add stream layer The decoder initially read from the socket, decoded the video and sent the decoded frames to the screen: +---------+ +----------+ socket ---> \| decoder \| ---> \| screen \| +---------+ +----------+ The design was simple, but the decoder had several responsabilities. Then we added the recording feature, so we added a recorder, which reused the packets received from the socket managed by the decoder: +----------+ ---> \| screen \| +---------+ / +----------+ socket ---> \| decoder \| ---- +---------+ \ +----------+ ---> \| recorder \| +----------+ This lack of separation of concerns now have concrete implications: we could not (properly) disable the decoder/display to only record the video. Therefore, split the decoder to extract the stream: +----------+ +----------+ ---> \| decoder \| ---> \| screen \| +---------+ / +----------+ +----------+ socket ---> \| stream \| ---- +---------+ \ +----------+ ---> \| recorder \| +----------+ This will allow to record the stream without decoding the video. 5 years ago			`ret = avcodec_receive_frame(decoder->codec_ctx,`
			`decoder->video_buffer->decoding_frame);`
			`if (!ret) {`
			`// a frame was received`
			`push_frame(decoder);`
			`} else if (ret != AVERROR(EAGAIN)) {`
			`LOGE("Could not receive video frame: %d", ret);`
			`return SDL_FALSE;`
Enable video output file, with pts set by server 6 years ago			`}`
Add stream layer The decoder initially read from the socket, decoded the video and sent the decoded frames to the screen: +---------+ +----------+ socket ---> \| decoder \| ---> \| screen \| +---------+ +----------+ The design was simple, but the decoder had several responsabilities. Then we added the recording feature, so we added a recorder, which reused the packets received from the socket managed by the decoder: +----------+ ---> \| screen \| +---------+ / +----------+ socket ---> \| decoder \| ---- +---------+ \ +----------+ ---> \| recorder \| +----------+ This lack of separation of concerns now have concrete implications: we could not (properly) disable the decoder/display to only record the video. Therefore, split the decoder to extract the stream: +----------+ +----------+ ---> \| decoder \| ---> \| screen \| +---------+ / +----------+ +----------+ socket ---> \| stream \| ---- +---------+ \ +----------+ ---> \| recorder \| +----------+ This will allow to record the stream without decoding the video. 5 years ago			`#else`
			`int got_picture;`
			`int len = avcodec_decode_video2(decoder->codec_ctx,`
			`decoder->video_buffer->decoding_frame,`
			`&got_picture,`
			`packet);`
			`if (len < 0) {`
			`LOGE("Could not decode video packet: %d", len);`
Use SDL_bool return type instead of int Many functions returned an int to indicate their success. For clarity, use SDL_bool instead. 7 years ago			`return SDL_FALSE;`
Initial commit Start a new clean history from here. 7 years ago			`}`
Add stream layer The decoder initially read from the socket, decoded the video and sent the decoded frames to the screen: +---------+ +----------+ socket ---> \| decoder \| ---> \| screen \| +---------+ +----------+ The design was simple, but the decoder had several responsabilities. Then we added the recording feature, so we added a recorder, which reused the packets received from the socket managed by the decoder: +----------+ ---> \| screen \| +---------+ / +----------+ socket ---> \| decoder \| ---- +---------+ \ +----------+ ---> \| recorder \| +----------+ This lack of separation of concerns now have concrete implications: we could not (properly) disable the decoder/display to only record the video. Therefore, split the decoder to extract the stream: +----------+ +----------+ ---> \| decoder \| ---> \| screen \| +---------+ / +----------+ +----------+ socket ---> \| stream \| ---- +---------+ \ +----------+ ---> \| recorder \| +----------+ This will allow to record the stream without decoding the video. 5 years ago			`if (got_picture) {`
			`push_frame(decoder);`
			`}`
			`#endif`
Use SDL_bool return type instead of int Many functions returned an int to indicate their success. For clarity, use SDL_bool instead. 7 years ago			`return SDL_TRUE;`
Initial commit Start a new clean history from here. 7 years ago			`}`

Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.) 5 years ago			`void`
			`decoder_interrupt(struct decoder *decoder) {`
Rename "stop" to "interrupt" The purpose of video_buffer_stop() is to interrupt any blocking call, so rename it to video_buffer_interrupt(). 5 years ago			`video_buffer_interrupt(decoder->video_buffer);`
Fix deadlock on exit if SKIP_FRAMES disabled On exit, the renderer will not consume frames anymore, so signal the condition variable to wake up the decoder. 6 years ago			`}`