mirror of
https://github.com/Genymobile/scrcpy.git
synced 2026-04-21 01:33:36 +00:00
00a002e139
This flag forced the decoder to wait for the previous frame to be
consumed by the display.
It was initially implemented as a compilation flag for testing, not
intended to be exposed at runtime. But to remove ifdefs and to allow
users to test this flag easily, it had finally been exposed by commit
ebccb9f6cc.
In practice, it turned out to be useless: it had no practical impact,
and it did not solve or mitigate any performance issues causing frame
skipping.
But that added some complexity to the codebase: it required an
additional condition variable, and made video buffer calls possibly
blocking, which in turn required code to interrupt it on exit.
To prepare support for multiple sinks plugged to the decoder (display
and v4l2 for example), the blocking call used for pacing the decoder
output becomes unacceptable, so just remove this useless "feature".
75 lines
2.2 KiB
C
75 lines
2.2 KiB
C
#ifndef VIDEO_BUFFER_H
|
|
#define VIDEO_BUFFER_H
|
|
|
|
#include "common.h"
|
|
|
|
#include <stdbool.h>
|
|
|
|
#include "fps_counter.h"
|
|
#include "util/thread.h"
|
|
|
|
// forward declarations
|
|
typedef struct AVFrame AVFrame;
|
|
|
|
/**
|
|
* There are 3 frames in memory:
|
|
* - one frame is held by the producer (producer_frame)
|
|
* - one frame is held by the consumer (consumer_frame)
|
|
* - one frame is shared between the producer and the consumer (pending_frame)
|
|
*
|
|
* The producer generates a frame into the producer_frame (it may takes time).
|
|
*
|
|
* Once the frame is produced, it calls video_buffer_producer_offer_frame(),
|
|
* which swaps the producer and pending frames.
|
|
*
|
|
* When the consumer is notified that a new frame is available, it calls
|
|
* video_buffer_consumer_take_frame() to retrieve it, which swaps the pending
|
|
* and consumer frames. The frame is valid until the next call, without
|
|
* blocking the producer.
|
|
*/
|
|
|
|
struct video_buffer {
|
|
AVFrame *producer_frame;
|
|
AVFrame *pending_frame;
|
|
AVFrame *consumer_frame;
|
|
|
|
sc_mutex mutex;
|
|
|
|
bool pending_frame_consumed;
|
|
|
|
const struct video_buffer_callbacks *cbs;
|
|
void *cbs_userdata;
|
|
};
|
|
|
|
struct video_buffer_callbacks {
|
|
// Called when a new frame can be consumed by
|
|
// video_buffer_consumer_take_frame(vb)
|
|
// This callback is mandatory (it must not be NULL).
|
|
void (*on_frame_available)(struct video_buffer *vb, void *userdata);
|
|
|
|
// Called when a pending frame has been overwritten by the producer
|
|
// This callback is optional (it may be NULL).
|
|
void (*on_frame_skipped)(struct video_buffer *vb, void *userdata);
|
|
};
|
|
|
|
bool
|
|
video_buffer_init(struct video_buffer *vb);
|
|
|
|
void
|
|
video_buffer_destroy(struct video_buffer *vb);
|
|
|
|
void
|
|
video_buffer_set_consumer_callbacks(struct video_buffer *vb,
|
|
const struct video_buffer_callbacks *cbs,
|
|
void *cbs_userdata);
|
|
|
|
// set the producer frame as ready for consuming
|
|
void
|
|
video_buffer_producer_offer_frame(struct video_buffer *vb);
|
|
|
|
// mark the consumer frame as consumed and return it
|
|
// the frame is valid until the next call to this function
|
|
const AVFrame *
|
|
video_buffer_consumer_take_frame(struct video_buffer *vb);
|
|
|
|
#endif
|