mirror of
https://github.com/obsproject/obs-studio.git
synced 2024-07-14 23:34:08 +00:00
6377fe3177
The virtual camera adds the ability to use the output of OBS itself as a camera that can be selected within other Windows applications. This is very loosely based upon the catxfish virtual camera plugin design. There is a shared memory queue, but instead of having 10-20 frames in the queue, there are now only 3 frames in the queue to minimize latency and reduce memory usage. The third frame is mostly to ensure that writing does not occur on the same frame being read; the delay is merely one frame at all times. The frames of the shared memory queue are NV12 instead of YUYV, which reduces the memory and data copied, as well as eliminate unnecessary conversion from NV12. Some programs (such as chrome, which uses webrtc to capture) do not support NV12 however, so an I420 conversion is provided, which is far less expensive than YUYV. The CPU cost of NV12 -> I420 is negligible in comparison. The virtual camera filter itself is based upon the output filter within the libdshowcapture library, which was originally implemented for other purposes. This is more ideal than the Microsoft example code because for one, it's far less convoluted, two, allows us to be able to customize the filter to our needs a bit more easily, and three, has much better RAII. The Microsoft CBaseFilter/etc code comprised of about 30 source files, where as the output filter comprises of two or three required source files which we already had, so it's a huge win to compile time. Scaling is avoided whenever possible to minimize CPU usage. When the virtual camera is activated in OBS, the width, height, and frame interval are saved, that way if the filter is activated, it will always remember the last OBS resolution/interval that the virtual camera was activated with, even if OBS is not active. If for some reason the filter activates before OBS starts up, and OBS starts up with a different resolution, it will use simple point scaling intermittently, and then will remember the new scaling in the future. The scaler could use some optimization. FFmpeg was not opted for because the FFmpeg DLLs would have to be provided for both architectures, which would be about 30 megabytes in total, and would make writing the plugin much more painful. Thus a simple point scaling algorithm is used, and scaling is avoided whenever possible. (If another willing participant wants to have a go at improving the scaling then go for it. But otherwise, it avoids scaling whenever possible anyway, so it's not a huge deal)
38 lines
958 B
C
38 lines
958 B
C
#pragma once
|
|
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
struct video_queue;
|
|
struct nv12_scale;
|
|
typedef struct video_queue video_queue_t;
|
|
typedef struct nv12_scale nv12_scale_t;
|
|
|
|
enum queue_state {
|
|
SHARED_QUEUE_STATE_INVALID,
|
|
SHARED_QUEUE_STATE_STARTING,
|
|
SHARED_QUEUE_STATE_READY,
|
|
SHARED_QUEUE_STATE_STOPPING,
|
|
};
|
|
|
|
extern video_queue_t *video_queue_create(uint32_t cx, uint32_t cy,
|
|
uint64_t interval);
|
|
extern video_queue_t *video_queue_open();
|
|
extern void video_queue_close(video_queue_t *vq);
|
|
|
|
extern void video_queue_get_info(video_queue_t *vq, uint32_t *cx, uint32_t *cy,
|
|
uint64_t *interval);
|
|
extern void video_queue_write(video_queue_t *vq, uint8_t **data,
|
|
uint32_t *linesize, uint64_t timestamp);
|
|
extern enum queue_state video_queue_state(video_queue_t *vq);
|
|
extern bool video_queue_read(video_queue_t *vq, nv12_scale_t *scale, void *dst,
|
|
uint64_t *ts);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|