obs-studio/plugins/mac-avcapture/av-capture.mm

#import <AVFoundation/AVFoundation.h>
#import <CoreFoundation/CoreFoundation.h>
#import <CoreMedia/CoreMedia.h>
#import <CoreVideo/CoreVideo.h>
#import <CoreMediaIO/CMIOHardware.h>
#include <AvailabilityMacros.h>

#include <obs-module.h>
#include <obs.hpp>
#include <media-io/video-io.h>

#include <util/dstr.hpp>

#include <algorithm>
#include <initializer_list>
#include <cinttypes>
#include <limits>
#include <memory>
#include <vector>

#include "left-right.hpp"
#include "scope-guard.hpp"

#define NBSP "\xC2\xA0"

using namespace std;

namespace std {

    template<> struct default_delete<obs_data_t> {
        void operator()(obs_data_t *data)
        {
            obs_data_release(data);
        }
    };

    template<> struct default_delete<obs_data_item_t> {
        void operator()(obs_data_item_t *item)
        {
            obs_data_item_release(&item);
        }
    };

}  // namespace std

#define TEXT_AVCAPTURE     obs_module_text("AVCapture")
#define TEXT_DEVICE        obs_module_text("Device")
#define TEXT_USE_PRESET    obs_module_text("UsePreset")
#define TEXT_PRESET        obs_module_text("Preset")
#define TEXT_RESOLUTION    obs_module_text("Resolution")
#define TEXT_FRAME_RATE    obs_module_text("FrameRate")
#define TEXT_MATCH_OBS     obs_module_text("MatchOBS")
#define TEXT_INPUT_FORMAT  obs_module_text("InputFormat")
#define TEXT_COLOR_SPACE   obs_module_text("ColorSpace")
#define TEXT_VIDEO_RANGE   obs_module_text("VideoRange")
#define TEXT_RANGE_PARTIAL obs_module_text("VideoRange.Partial")
#define TEXT_RANGE_FULL    obs_module_text("VideoRange.Full")
#define TEXT_AUTO          obs_module_text("Auto")

#define TEXT_COLOR_UNKNOWN_NAME "Unknown"
#define TEXT_RANGE_UNKNOWN_NAME "Unknown"

static const FourCharCode INPUT_FORMAT_AUTO = -1;
static const int COLOR_SPACE_AUTO = -1;
static const int VIDEO_RANGE_AUTO = -1;

#define MILLI_TIMESCALE 1000
#define MICRO_TIMESCALE (MILLI_TIMESCALE * 1000)
#define NANO_TIMESCALE  (MICRO_TIMESCALE * 1000)

#define AV_FOURCC_STR(code)                                                             \
    (char[5])                                                                           \
    {                                                                                   \
        static_cast<char>((code >> 24) & 0xFF), static_cast<char>((code >> 16) & 0xFF), \
            static_cast<char>((code >> 8) & 0xFF), static_cast<char>(code & 0xFF), 0    \
    }

struct av_capture;

#define AVLOG(level, format, ...) blog(level, "%s: " format, obs_source_get_name(capture->source), ##__VA_ARGS__)

@interface OBSAVCaptureDelegate
    : NSObject <AVCaptureVideoDataOutputSampleBufferDelegate, AVCaptureAudioDataOutputSampleBufferDelegate> {
      @public
    struct av_capture *capture;
}
- (void)captureOutput:(AVCaptureOutput *)out
    didDropSampleBuffer:(CMSampleBufferRef)sampleBuffer
         fromConnection:(AVCaptureConnection *)connection;
- (void)captureOutput:(AVCaptureOutput *)captureOutput
    didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
           fromConnection:(AVCaptureConnection *)connection;
@end

namespace {

    static auto remove_observer = [](id observer) {
        [[NSNotificationCenter defaultCenter] removeObserver:observer];
    };

    struct observer_handle : unique_ptr<remove_pointer<id>::type, decltype(remove_observer)> {
        using base = unique_ptr<remove_pointer<id>::type, decltype(remove_observer)>;

        explicit observer_handle(id observer = nullptr) : base(observer, remove_observer)
        {}
    };

    struct av_video_info {
        video_colorspace colorspace;
        video_range_type video_range;
        bool video_params_valid = false;
    };

}  // namespace

struct av_capture {
    OBSAVCaptureDelegate *delegate;
    dispatch_queue_t queue;
    dispatch_queue_t audioQueue;
    bool has_clock;

    bool device_locked;

    left_right::left_right<av_video_info> video_info;

    AVCaptureVideoDataOutput *out;
    AVCaptureAudioDataOutput *audioOut;
    AVCaptureDevice *device;
    AVCaptureDeviceInput *device_input;
    AVCaptureSession *session;

    NSString *uid;
    observer_handle connect_observer;
    observer_handle disconnect_observer;

    FourCharCode fourcc;
    video_format video_format;

    bool use_preset = false;
    int requested_colorspace = COLOR_SPACE_AUTO;
    int requested_video_range = VIDEO_RANGE_AUTO;
    bool enable_audio;

    obs_source_t *source;

    obs_source_frame frame;
    obs_source_audio audio;
};

static NSString *get_string(obs_data_t *data, char const *name)
{
    return @(obs_data_get_string(data, name));
}

static AVCaptureDevice *get_device(obs_data_t *settings)
{
    auto uid = get_string(settings, "device");
    return [AVCaptureDevice deviceWithUniqueID:uid];
}

template<typename T, typename U>
static void clamp(T &store, U val, T low = numeric_limits<T>::min(), T high = numeric_limits<T>::max())
{
    store = static_cast<intmax_t>(val) < static_cast<intmax_t>(low)
                ? low
                : (static_cast<intmax_t>(val) > static_cast<intmax_t>(high) ? high : static_cast<T>(val));
}

static bool get_resolution(obs_data_t *settings, CMVideoDimensions &dims)
{
    using item_ptr = unique_ptr<obs_data_item_t>;
    item_ptr item {obs_data_item_byname(settings, "resolution")};
    if (!item)
        return false;

    auto res_str = obs_data_item_get_string(item.get());
    unique_ptr<obs_data_t> res {obs_data_create_from_json(res_str)};
    if (!res)
        return false;

    item_ptr width {obs_data_item_byname(res.get(), "width")};
    item_ptr height {obs_data_item_byname(res.get(), "height")};

    if (!width || !height)
        return false;

    clamp(dims.width, obs_data_item_get_int(width.get()), 0);
    clamp(dims.height, obs_data_item_get_int(height.get()), 0);

    if (!dims.width || !dims.height)
        return false;

    return true;
}

static bool get_input_format(obs_data_t *settings, FourCharCode &fourcc)
{
    auto item = unique_ptr<obs_data_item_t> {obs_data_item_byname(settings, "input_format")};
    if (!item)
        return false;

    fourcc = (FourCharCode) obs_data_item_get_int(item.get());
    return true;
}

namespace {

    struct config_helper {
        obs_data_t *settings = nullptr;

        AVCaptureDevice *dev_ = nullptr;

        bool dims_valid : 1;
        bool fr_valid : 1;
        bool fps_valid : 1;
        bool if_valid : 1;

        CMVideoDimensions dims_ {};

        const char *frame_rate_ = nullptr;
        media_frames_per_second fps_ {};

        FourCharCode input_format_ = INPUT_FORMAT_AUTO;

        explicit config_helper(obs_data_t *settings) : settings(settings)
        {
            dev_ = get_device(settings);

            dims_valid = get_resolution(settings, dims_);

            fr_valid = obs_data_get_frames_per_second(settings, "frame_rate", nullptr, &frame_rate_);
            fps_valid = obs_data_get_frames_per_second(settings, "frame_rate", &fps_, nullptr);

            if_valid = get_input_format(settings, input_format_);
        }

        AVCaptureDevice *dev() const
        {
            return dev_;
        }

        const CMVideoDimensions *dims() const
        {
            return dims_valid ? &dims_ : nullptr;
        }

        const char *frame_rate() const
        {
            return fr_valid ? frame_rate_ : nullptr;
        }

        const media_frames_per_second *fps() const
        {
            return fps_valid ? &fps_ : nullptr;
        }

        const FourCharCode *input_format() const
        {
            return if_valid ? &input_format_ : nullptr;
        }
    };

    struct av_capture_ref {
        av_capture *capture = nullptr;
        OBSSource source;

        av_capture_ref() = default;

        av_capture_ref(av_capture *capture_, obs_weak_source_t *weak_source) : source(OBSGetStrongRef(weak_source))
        {
            if (!source)
                return;

            capture = capture_;
        }

        operator av_capture *()
        {
            return capture;
        }

        av_capture *operator->()
        {
            return capture;
        }
    };

    struct properties_param {
        av_capture *capture = nullptr;
        OBSWeakSource weak_source;

        properties_param(av_capture *capture) : capture(capture)
        {
            if (!capture)
                return;

            weak_source = OBSGetWeakRef(capture->source);
        }

        av_capture_ref get_ref()
        {
            return {capture, weak_source};
        }
    };

}  // namespace

static av_capture_ref get_ref(obs_properties_t *props)
{
    void *param = obs_properties_get_param(props);
    if (!param)
        return {};

    return static_cast<properties_param *>(param)->get_ref();
}

static inline video_format format_from_subtype(FourCharCode subtype)
{
    //TODO: uncomment VIDEO_FORMAT_NV12 and VIDEO_FORMAT_ARGB once libobs
    //      gains matching GPU conversions or a CPU fallback is implemented
    switch (subtype) {
        case kCVPixelFormatType_422YpCbCr8:
            return VIDEO_FORMAT_UYVY;
        case kCVPixelFormatType_422YpCbCr8_yuvs:
            return VIDEO_FORMAT_YUY2;
        /* case kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange:
         * case kCVPixelFormatType_420YpCbCr8BiPlanarFullRange:
		 *    return VIDEO_FORMAT_NV12;
         * case kCVPixelFormatType_32ARGB:
		 *    return VIDEO_FORMAT_ARGB;
         */
        case kCVPixelFormatType_32BGRA:
            return VIDEO_FORMAT_BGRA;
        default:
            return VIDEO_FORMAT_NONE;
    }
}

static const char *fourcc_subtype_name(FourCharCode fourcc);

static const char *format_description_subtype_name(CMFormatDescriptionRef desc, FourCharCode *fourcc_ = nullptr)
{
    FourCharCode fourcc = CMFormatDescriptionGetMediaSubType(desc);
    if (fourcc_)
        *fourcc_ = fourcc;

    return fourcc_subtype_name(fourcc);
}

static const char *fourcc_subtype_name(FourCharCode fourcc)
{
    switch (fourcc) {
        case kCVPixelFormatType_422YpCbCr8:
            return "UYVY - 422YpCbCr8";  //VIDEO_FORMAT_UYVY;
        case kCVPixelFormatType_422YpCbCr8_yuvs:
            return "YUY2 - 422YpCbCr8_yuvs";  //VIDEO_FORMAT_YUY2;
        case kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange:
        case kCVPixelFormatType_420YpCbCr8BiPlanarFullRange:
            return "NV12 - 420YpCbCr8BiPlanar";  //VIDEO_FORMAT_NV12;
        case kCVPixelFormatType_32ARGB:
            return "ARGB - 32ARGB";  //VIDEO_FORMAT_ARGB;*/
        case kCVPixelFormatType_32BGRA:
            return "BGRA - 32BGRA";  //VIDEO_FORMAT_BGRA;

        case kCMVideoCodecType_Animation:
            return "Apple Animation";
        case kCMVideoCodecType_Cinepak:
            return "Cinepak";
        case kCMVideoCodecType_JPEG:
            return "JPEG";
        case kCMVideoCodecType_JPEG_OpenDML:
            return "MJPEG - JPEG OpenDML";
        case kCMVideoCodecType_SorensonVideo:
            return "Sorenson Video";
        case kCMVideoCodecType_SorensonVideo3:
            return "Sorenson Video 3";
        case kCMVideoCodecType_H263:
            return "H.263";
        case kCMVideoCodecType_H264:
            return "H.264";
        case kCMVideoCodecType_MPEG4Video:
            return "MPEG-4";
        case kCMVideoCodecType_MPEG2Video:
            return "MPEG-2";
        case kCMVideoCodecType_MPEG1Video:
            return "MPEG-1";

        case kCMVideoCodecType_DVCNTSC:
            return "DV NTSC";
        case kCMVideoCodecType_DVCPAL:
            return "DV PAL";
        case kCMVideoCodecType_DVCProPAL:
            return "Panasonic DVCPro PAL";
        case kCMVideoCodecType_DVCPro50NTSC:
            return "Panasonic DVCPro-50 NTSC";
        case kCMVideoCodecType_DVCPro50PAL:
            return "Panasonic DVCPro-50 PAL";
        case kCMVideoCodecType_DVCPROHD720p60:
            return "Panasonic DVCPro-HD 720p60";
        case kCMVideoCodecType_DVCPROHD720p50:
            return "Panasonic DVCPro-HD 720p50";
        case kCMVideoCodecType_DVCPROHD1080i60:
            return "Panasonic DVCPro-HD 1080i60";
        case kCMVideoCodecType_DVCPROHD1080i50:
            return "Panasonic DVCPro-HD 1080i50";
        case kCMVideoCodecType_DVCPROHD1080p30:
            return "Panasonic DVCPro-HD 1080p30";
        case kCMVideoCodecType_DVCPROHD1080p25:
            return "Panasonic DVCPro-HD 1080p25";

        case kCMVideoCodecType_AppleProRes4444:
            return "Apple ProRes 4444";
        case kCMVideoCodecType_AppleProRes422HQ:
            return "Apple ProRes 422 HQ";
        case kCMVideoCodecType_AppleProRes422:
            return "Apple ProRes 422";
        case kCMVideoCodecType_AppleProRes422LT:
            return "Apple ProRes 422 LT";
        case kCMVideoCodecType_AppleProRes422Proxy:
            return "Apple ProRes 422 Proxy";

        default:
            blog(LOG_INFO, "Unknown format %s", AV_FOURCC_STR(fourcc));
            return "unknown";
    }
}

static inline bool is_fullrange_yuv(FourCharCode pixel_format)
{
    switch (pixel_format) {
        case kCVPixelFormatType_420YpCbCr8PlanarFullRange:
        case kCVPixelFormatType_420YpCbCr8BiPlanarFullRange:
        case kCVPixelFormatType_422YpCbCr8FullRange:
            return true;

        default:
            return false;
    }
}

static inline video_colorspace get_colorspace(CMFormatDescriptionRef desc)
{
    CFPropertyListRef matrix = CMFormatDescriptionGetExtension(desc, kCMFormatDescriptionExtension_YCbCrMatrix);

    if (!matrix)
        return VIDEO_CS_DEFAULT;

    if (CFStringCompare(static_cast<CFStringRef>(matrix), kCVImageBufferYCbCrMatrix_ITU_R_601_4, 0) ==
        kCFCompareEqualTo)
        return VIDEO_CS_601;

    return VIDEO_CS_709;
}

static inline bool update_colorspace(av_capture *capture, obs_source_frame *frame, CMFormatDescriptionRef desc,
                                     bool full_range, av_video_info &vi)
{
    auto cs_auto = capture->use_preset || capture->requested_colorspace == COLOR_SPACE_AUTO;
    auto vr_auto = capture->use_preset || capture->requested_video_range == VIDEO_RANGE_AUTO;

    video_colorspace colorspace = get_colorspace(desc);
    video_range_type range = full_range ? VIDEO_RANGE_FULL : VIDEO_RANGE_PARTIAL;

    bool cs_matches = false;
    if (cs_auto) {
        cs_matches = colorspace == vi.colorspace;
    } else {
        colorspace = static_cast<video_colorspace>(capture->requested_colorspace);
        cs_matches = colorspace == vi.colorspace;
    }

    bool vr_matches = false;
    if (vr_auto) {
        vr_matches = range == vi.video_range;
    } else {
        range = static_cast<video_range_type>(capture->requested_video_range);
        vr_matches = range == vi.video_range;
        full_range = range == VIDEO_RANGE_FULL;
    }

    if (cs_matches && vr_matches) {
        if (!vi.video_params_valid)
            capture->video_info.update([&](av_video_info &vi_) {
                vi_.video_params_valid = vi.video_params_valid = true;
            });
        return true;
    }

    frame->full_range = full_range;

    if (!video_format_get_parameters_for_format(colorspace, range, frame->format, frame->color_matrix,
                                                frame->color_range_min, frame->color_range_max)) {
        AVLOG(LOG_ERROR,
              "Failed to get colorspace parameters for "
              "colorspace %u range %u",
              colorspace, range);

        if (vi.video_params_valid)
            capture->video_info.update([&](av_video_info &vi_) {
                vi_.video_params_valid = vi.video_params_valid = false;
            });

        return false;
    }

    capture->video_info.update([&](av_video_info &vi_) {
        vi_.colorspace = colorspace;
        vi_.video_range = range;
        vi_.video_params_valid = vi.video_params_valid = true;
    });

    return true;
}

static inline bool update_frame(av_capture *capture, obs_source_frame *frame, CMSampleBufferRef sample_buffer)
{
    CMFormatDescriptionRef desc = CMSampleBufferGetFormatDescription(sample_buffer);

    FourCharCode fourcc = CMFormatDescriptionGetMediaSubType(desc);
    video_format format = format_from_subtype(fourcc);
    CMVideoDimensions dims = CMVideoFormatDescriptionGetDimensions(desc);

    CVImageBufferRef img = CMSampleBufferGetImageBuffer(sample_buffer);

    auto vi = capture->video_info.read();

    bool video_params_were_valid = vi.video_params_valid;
    SCOPE_EXIT
    {
        if (video_params_were_valid != vi.video_params_valid)
            obs_source_update_properties(capture->source);
    };

    if (format == VIDEO_FORMAT_NONE) {
        if (capture->fourcc == fourcc)
            return false;

        capture->fourcc = fourcc;
        AVLOG(LOG_ERROR, "Unhandled fourcc: %s (0x%x) (%zu planes)", AV_FOURCC_STR(fourcc), fourcc,
              CVPixelBufferGetPlaneCount(img));
        return false;
    }

    if (frame->format != format)
        AVLOG(LOG_DEBUG,
              "Switching fourcc: "
              "'%s' (0x%x) -> '%s' (0x%x)",
              AV_FOURCC_STR(capture->fourcc), capture->fourcc, AV_FOURCC_STR(fourcc), fourcc);

    bool was_yuv = format_is_yuv(frame->format);

    capture->fourcc = fourcc;
    frame->format = format;
    frame->width = dims.width;
    frame->height = dims.height;

    if (format_is_yuv(format) && !update_colorspace(capture, frame, desc, is_fullrange_yuv(fourcc), vi)) {
        return false;
    } else if (was_yuv == format_is_yuv(format)) {
        capture->video_info.update([&](av_video_info &vi_) {
            vi_.video_params_valid = vi.video_params_valid = true;
        });
    }

    CVPixelBufferLockBaseAddress(img, kCVPixelBufferLock_ReadOnly);

    if (!CVPixelBufferIsPlanar(img)) {
        frame->linesize[0] = (uint32_t) CVPixelBufferGetBytesPerRow(img);
        frame->data[0] = static_cast<uint8_t *>(CVPixelBufferGetBaseAddress(img));
        return true;
    }

    size_t count = CVPixelBufferGetPlaneCount(img);
    for (size_t i = 0; i < count; i++) {
        frame->linesize[i] = (uint32_t) CVPixelBufferGetBytesPerRowOfPlane(img, i);
        frame->data[i] = static_cast<uint8_t *>(CVPixelBufferGetBaseAddressOfPlane(img, i));
    }
    return true;
}

static inline bool update_audio(obs_source_audio *audio, CMSampleBufferRef sample_buffer)
{
    size_t requiredSize;
    OSStatus status = CMSampleBufferGetAudioBufferListWithRetainedBlockBuffer(
        sample_buffer, &requiredSize, nullptr, 0, nullptr, nullptr,
        kCMSampleBufferFlag_AudioBufferList_Assure16ByteAlignment, nullptr);

    if (status != noErr) {
        blog(LOG_WARNING, "[mac-avcapture]: Error while getting size of sample buffer");
        return false;
    }

    AudioBufferList *list = (AudioBufferList *) bmalloc(requiredSize);
    CMBlockBufferRef buffer;

    status = CMSampleBufferGetAudioBufferListWithRetainedBlockBuffer(
        sample_buffer, nullptr, list, requiredSize, nullptr, nullptr,
        kCMSampleBufferFlag_AudioBufferList_Assure16ByteAlignment, &buffer);

    if (status != noErr || !list) {
        if (list)
            bfree(list);

        blog(LOG_WARNING, "[mac-avcapture]: Error while copying sample buffer to audio buffer list");
        return false;
    }

    for (size_t i = 0; i < list->mNumberBuffers; i++)
        audio->data[i] = (uint8_t *) list->mBuffers[i].mData;

    audio->frames = (uint32_t) CMSampleBufferGetNumSamples(sample_buffer);
    CMFormatDescriptionRef desc = CMSampleBufferGetFormatDescription(sample_buffer);
    const AudioStreamBasicDescription *asbd = CMAudioFormatDescriptionGetStreamBasicDescription(desc);
    audio->samples_per_sec = (uint32_t) asbd->mSampleRate;
    audio->speakers = (enum speaker_layout) asbd->mChannelsPerFrame;
    switch (asbd->mBitsPerChannel) {
        case 8:
            audio->format = AUDIO_FORMAT_U8BIT;
            break;
        case 16:
            audio->format = AUDIO_FORMAT_16BIT;
            break;
        case 32:
            audio->format = AUDIO_FORMAT_32BIT;
            break;
        default:
            audio->format = AUDIO_FORMAT_UNKNOWN;
    }

    if (buffer)
        CFRelease(buffer);

    bfree(list);

    return true;
}

@implementation OBSAVCaptureDelegate
- (void)captureOutput:(AVCaptureOutput *)out
    didDropSampleBuffer:(CMSampleBufferRef)sampleBuffer
         fromConnection:(AVCaptureConnection *)connection
{
    UNUSED_PARAMETER(out);
    UNUSED_PARAMETER(sampleBuffer);
    UNUSED_PARAMETER(connection);
}

- (void)captureOutput:(AVCaptureOutput *)captureOutput
    didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
           fromConnection:(AVCaptureConnection *)connection
{
    UNUSED_PARAMETER(captureOutput);
    UNUSED_PARAMETER(connection);

    CMItemCount count = CMSampleBufferGetNumSamples(sampleBuffer);
    if (count < 1 || !capture)
        return;

    CMTime target_pts = CMSampleBufferGetOutputPresentationTimeStamp(sampleBuffer);
    CMTime target_pts_nano = CMTimeConvertScale(target_pts, NANO_TIMESCALE, kCMTimeRoundingMethod_Default);

    CMFormatDescriptionRef desc = CMSampleBufferGetFormatDescription(sampleBuffer);
    CMMediaType type = CMFormatDescriptionGetMediaType(desc);
    if (type == kCMMediaType_Video) {
        obs_source_frame *frame = &capture->frame;
        frame->timestamp = target_pts_nano.value;

        if (!update_frame(capture, frame, sampleBuffer)) {
            obs_source_output_video(capture->source, nullptr);
            return;
        }

        obs_source_output_video(capture->source, frame);

        CVImageBufferRef img = CMSampleBufferGetImageBuffer(sampleBuffer);
        CVPixelBufferUnlockBaseAddress(img, kCVPixelBufferLock_ReadOnly);
    } else if (type == kCMMediaType_Audio) {
        if (!capture->enable_audio)
            return;

        obs_source_audio *audio = &capture->audio;
        audio->timestamp = target_pts_nano.value;

        if (!update_audio(audio, sampleBuffer)) {
            obs_source_output_audio(capture->source, nullptr);
            return;
        }
        obs_source_output_audio(capture->source, audio);
    }
}
@end

static void av_capture_enable_buffering(av_capture *capture, bool enabled)
{
    obs_source_set_async_unbuffered(capture->source, !enabled);
}

static const char *av_capture_getname(void *)
{
    return TEXT_AVCAPTURE;
}

static void unlock_device(av_capture *capture, AVCaptureDevice *dev = nullptr)
{
    if (!dev)
        dev = capture->device;

    if (dev && capture->device_locked)
        [dev unlockForConfiguration];

    capture->device_locked = false;
}

static void start_capture(av_capture *capture)
{
    if (capture->session && !capture->session.running)
        [capture->session startRunning];
}

static void clear_capture(av_capture *capture)
{
    if (capture->session && capture->session.running)
        [capture->session stopRunning];

    obs_source_output_video(capture->source, nullptr);
    obs_source_output_audio(capture->source, nullptr);
}

static void remove_device(av_capture *capture)
{
    clear_capture(capture);

    [capture->session removeInput:capture->device_input];

    unlock_device(capture);

    capture->device_input = nullptr;
    capture->device = nullptr;
}

static void av_capture_destroy(void *data)
{
    auto capture = static_cast<av_capture *>(data);

    delete capture;
}

static bool init_session(av_capture *capture)
{
    auto session = [[AVCaptureSession alloc] init];
    if (!session) {
        AVLOG(LOG_ERROR, "Could not create AVCaptureSession");
        return false;
    }

    auto delegate = [[OBSAVCaptureDelegate alloc] init];
    if (!delegate) {
        AVLOG(LOG_ERROR, "Could not create OBSAVCaptureDelegate");
        return false;
    }

    delegate->capture = capture;

    auto out = [[AVCaptureVideoDataOutput alloc] init];
    if (!out) {
        AVLOG(LOG_ERROR, "Could not create AVCaptureVideoDataOutput");
        return false;
    }

    auto audioOut = [[AVCaptureAudioDataOutput alloc] init];
    if (!audioOut) {
        AVLOG(LOG_ERROR, "Could not create AVCaptureAudioDataOutput");
        return false;
    }

    auto queue = dispatch_queue_create(NULL, NULL);
    if (!queue) {
        AVLOG(LOG_ERROR, "Could not create dispatch queue");
        return false;
    }

    auto audioQueue = dispatch_queue_create(NULL, NULL);
    if (!queue) {
        AVLOG(LOG_ERROR, "Could not create dispatch queue for audio");
        return false;
    }

    capture->session = session;
    capture->delegate = delegate;
    capture->out = out;
    capture->audioOut = audioOut;
    capture->queue = queue;
    capture->audioQueue = audioQueue;

    [capture->session addOutput:capture->out];
    [capture->out setSampleBufferDelegate:capture->delegate queue:capture->queue];
    [capture->session addOutput:capture->audioOut];
    [capture->audioOut setSampleBufferDelegate:capture->delegate queue:capture->audioQueue];

    return true;
}

static bool init_format(av_capture *capture, AVCaptureDevice *dev);

static bool init_device_input(av_capture *capture, AVCaptureDevice *dev)
{
    NSError *err = nil;
    AVCaptureDeviceInput *device_input = [AVCaptureDeviceInput deviceInputWithDevice:dev error:&err];
    if (!device_input) {
        AVLOG(LOG_ERROR, "Error while initializing device input: %s", err.localizedFailureReason.UTF8String);
        return false;
    }

    [capture->session addInput:device_input];

    if (!init_format(capture, dev)) {
        [capture->session removeInput:device_input];
        return false;
    }

    capture->device_input = device_input;

    return true;
}

static uint32_t uint_from_dict(NSDictionary *dict, CFStringRef key)
{
    return ((NSNumber *) dict[(__bridge NSString *) key]).unsignedIntValue;
}

static bool init_format(av_capture *capture, AVCaptureDevice *dev)
{
    AVCaptureDeviceFormat *format = dev.activeFormat;

    CMMediaType mtype = CMFormatDescriptionGetMediaType(format.formatDescription);
    // TODO: support other media types
    if (mtype != kCMMediaType_Video && mtype != kCMMediaType_Muxed) {
        AVLOG(LOG_ERROR, "CMMediaType '%s' is unsupported", AV_FOURCC_STR(mtype));
        return false;
    }

    capture->out.videoSettings = nil;
    FourCharCode subtype = uint_from_dict(capture->out.videoSettings, kCVPixelBufferPixelFormatTypeKey);
    if (format_from_subtype(subtype) != VIDEO_FORMAT_NONE) {
        AVLOG(LOG_DEBUG, "Using native fourcc '%s'", AV_FOURCC_STR(subtype));
        return true;
    }

    AVLOG(LOG_DEBUG, "Using fallback fourcc '%s' ('%s' 0x%08x unsupported)", AV_FOURCC_STR(kCVPixelFormatType_32BGRA),
          AV_FOURCC_STR(subtype), subtype);

    capture->out.videoSettings =
        @{(__bridge NSString *) kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_32BGRA)};
    return true;
}

static NSArray *presets(void);
static NSString *preset_names(NSString *preset);

static NSString *select_preset(AVCaptureDevice *dev, NSString *cur_preset)
{
    NSString *new_preset = nil;
    bool found_previous_preset = false;
    for (NSString *preset in presets().reverseObjectEnumerator) {
        if (!found_previous_preset)
            found_previous_preset = [cur_preset isEqualToString:preset];

        if (![dev supportsAVCaptureSessionPreset:preset])
            continue;

        if (!new_preset || !found_previous_preset)
            new_preset = preset;
    }

    return new_preset;
}

static bool init_preset(av_capture *capture, AVCaptureDevice *dev, obs_data_t *settings)
{
    clear_capture(capture);

    unlock_device(capture, dev);

    NSString *preset = get_string(settings, "preset");
    if (![dev supportsAVCaptureSessionPreset:preset]) {
        AVLOG(LOG_WARNING, "Preset %s not available", preset_names(preset).UTF8String);
        preset = select_preset(dev, preset);
    }

    if (!preset) {
        AVLOG(LOG_WARNING, "Could not select a preset, "
                           "initialization failed");
        return false;
    }

    capture->session.sessionPreset = preset;
    AVLOG(LOG_INFO, "Using preset %s", preset_names(preset).UTF8String);

    return true;
}

static bool operator==(const CMVideoDimensions &a, const CMVideoDimensions &b);
static CMVideoDimensions get_dimensions(AVCaptureDeviceFormat *format);

static AVCaptureDeviceFormat *find_format(AVCaptureDevice *dev, CMVideoDimensions dims)
{
    for (AVCaptureDeviceFormat *format in dev.formats) {
        if (get_dimensions(format) == dims)
            return format;
    }

    return nullptr;
}

static CMTime convert(media_frames_per_second fps)
{
    CMTime time {};
    time.value = fps.denominator;
    time.timescale = fps.numerator;
    time.flags = 1;
    return time;
}

static bool lock_device(av_capture *capture, AVCaptureDevice *dev)
{
    if (!dev)
        dev = capture->device;

    NSError *err;
    if (![dev lockForConfiguration:&err]) {
        AVLOG(LOG_WARNING,
              "Could not lock device for configuration: "
              "%s",
              err.localizedDescription.UTF8String);
        return false;
    }

    capture->device_locked = true;
    return true;
}

template<typename Func>
static void find_formats(media_frames_per_second fps, AVCaptureDevice *dev, const CMVideoDimensions *dims, Func &&f)
{
    auto time = convert(fps);

    for (AVCaptureDeviceFormat *format in dev.formats) {
        if (!(get_dimensions(format) == *dims))
            continue;

        for (AVFrameRateRange *range in format.videoSupportedFrameRateRanges) {
            if (CMTimeCompare(range.maxFrameDuration, time) >= 0 && CMTimeCompare(range.minFrameDuration, time) <= 0)
                if (f(format))
                    return;
        }
    }
}

static bool color_space_valid(int color_space)
{
    switch (color_space) {
        case COLOR_SPACE_AUTO:
        case VIDEO_CS_DEFAULT:
        case VIDEO_CS_601:
        case VIDEO_CS_709:
            return true;
    }

    return false;
}

static const char *color_space_name(int color_space)
{
    switch (color_space) {
        case COLOR_SPACE_AUTO:
            return "Auto";
        case VIDEO_CS_DEFAULT:
            return "Default";
        case VIDEO_CS_601:
            return "CS 601";
        case VIDEO_CS_709:
            return "CS 709";
    }

    return "Unknown";
}

static bool video_range_valid(int video_range)
{
    switch (video_range) {
        case VIDEO_RANGE_AUTO:
        case VIDEO_RANGE_DEFAULT:
        case VIDEO_RANGE_PARTIAL:
        case VIDEO_RANGE_FULL:
            return true;
    }

    return false;
}

static const char *video_range_name(int video_range)
{
    switch (video_range) {
        case VIDEO_RANGE_AUTO:
            return "Auto";
        case VIDEO_RANGE_DEFAULT:
            return "Default";
        case VIDEO_RANGE_PARTIAL:
            return "Partial";
        case VIDEO_RANGE_FULL:
            return "Full";
    }

    return "Unknown";
}

static bool init_manual(av_capture *capture, AVCaptureDevice *dev, obs_data_t *settings)
{
    clear_capture(capture);

    auto input_format = obs_data_get_int(settings, "input_format");
    FourCharCode actual_format = (FourCharCode) input_format;

    SCOPE_EXIT
    {
        bool refresh = false;
        if (input_format != actual_format) {
            refresh = obs_data_get_autoselect_int(settings, "input_format") != actual_format;
            obs_data_set_autoselect_int(settings, "input_format", actual_format);
        } else {
            refresh = obs_data_has_autoselect_value(settings, "input_format");
            obs_data_unset_autoselect_value(settings, "input_format");
        }

        if (refresh)
            obs_source_update_properties(capture->source);
    };

    capture->requested_colorspace = (int) obs_data_get_int(settings, "color_space");
    if (!color_space_valid(capture->requested_colorspace)) {
        AVLOG(LOG_WARNING, "Unsupported color space: %d", capture->requested_colorspace);
        return false;
    }

    capture->requested_video_range = (int) obs_data_get_int(settings, "video_range");
    if (!video_range_valid(capture->requested_video_range)) {
        AVLOG(LOG_WARNING, "Unsupported color range: %d", capture->requested_video_range);
        return false;
    }

    CMVideoDimensions dims {};
    if (!get_resolution(settings, dims)) {
        AVLOG(LOG_WARNING, "Could not load resolution");
        return false;
    }

    media_frames_per_second fps {};
    if (!obs_data_get_frames_per_second(settings, "frame_rate", &fps, nullptr)) {
        AVLOG(LOG_WARNING, "Could not load frame rate");
        return false;
    }

    AVCaptureDeviceFormat *format = nullptr;
    find_formats(fps, dev, &dims, [&](AVCaptureDeviceFormat *format_) {
        auto desc = format_.formatDescription;
        auto fourcc = CMFormatDescriptionGetMediaSubType(desc);
        if (input_format != INPUT_FORMAT_AUTO && fourcc != input_format)
            return false;

        actual_format = fourcc;
        format = format_;
        return true;
    });

    if (!format) {
        AVLOG(LOG_WARNING,
              "Frame rate is not supported: %g FPS "
              "(%u/%u)",
              media_frames_per_second_to_fps(fps), fps.numerator, fps.denominator);
        return false;
    }

    if (!lock_device(capture, dev))
        return false;

    const char *if_name = input_format == INPUT_FORMAT_AUTO ? "Auto" : fourcc_subtype_name((FourCharCode) input_format);

#define IF_AUTO(x) (input_format != INPUT_FORMAT_AUTO ? "" : x)
    AVLOG(LOG_INFO,
          "Capturing '%s' (%s):\n"
          "	Resolution: %ux%u\n"
          "	FPS: %g (%" PRIu32 "/%" PRIu32 ")\n"
          "	Frame interval: %g" NBSP "s\n"
          "	Input format: %s%s%s (%s)%s\n"
          "	Requested color space: %s (%d)\n"
          "	Requested video range: %s (%d)\n"
          "	Using format: %s",
          dev.localizedName.UTF8String, dev.uniqueID.UTF8String, dims.width, dims.height,
          media_frames_per_second_to_fps(fps), fps.numerator, fps.denominator,
          media_frames_per_second_to_frame_interval(fps), if_name, IF_AUTO(" (actual: "),
          IF_AUTO(fourcc_subtype_name(actual_format)), AV_FOURCC_STR(actual_format), IF_AUTO(")"),
          color_space_name(capture->requested_colorspace), capture->requested_colorspace,
          video_range_name(capture->requested_video_range), capture->requested_video_range,
          format.description.UTF8String);
#undef IF_AUTO

    dev.activeFormat = format;
    dev.activeVideoMinFrameDuration = convert(fps);
    dev.activeVideoMaxFrameDuration = convert(fps);

    capture->video_info.update([&](av_video_info &vi) {
        vi.video_params_valid = false;
    });

    return true;
}

static inline void av_capture_set_audio_active(av_capture *capture, bool active)
{
    obs_source_set_audio_active(capture->source, active);
    capture->enable_audio = active;
}

static void capture_device(av_capture *capture, AVCaptureDevice *dev, obs_data_t *settings)
{
    const char *name = dev.localizedName.UTF8String;
    obs_data_set_string(settings, "device_name", name);
    obs_data_set_string(settings, "device", dev.uniqueID.UTF8String);
    AVLOG(LOG_INFO, "Selected device '%s'", name);

    if ((capture->use_preset = obs_data_get_bool(settings, "use_preset"))) {
        if (!init_preset(capture, dev, settings))
            return;

    } else {
        if (!init_manual(capture, dev, settings))
            return;
    }

    av_capture_set_audio_active(capture,
                                obs_data_get_bool(settings, "enable_audio") &&
                                    ([dev hasMediaType:AVMediaTypeAudio] || [dev hasMediaType:AVMediaTypeMuxed]));

    if (!init_device_input(capture, dev))
        return;

    AVCaptureInputPort *port = capture->device_input.ports[0];
    capture->has_clock = [port respondsToSelector:@selector(clock)];

    capture->device = dev;
    start_capture(capture);
    return;
}

static inline void handle_disconnect_capture(av_capture *capture, AVCaptureDevice *dev)
{
    if (![dev.uniqueID isEqualTo:capture->uid])
        return;

    if (!capture->device) {
        AVLOG(LOG_INFO, "Received disconnect for inactive device '%s'", capture->uid.UTF8String);
        return;
    }

    AVLOG(LOG_WARNING, "Device with unique ID '%s' disconnected", dev.uniqueID.UTF8String);

    remove_device(capture);
}

static inline void handle_disconnect(av_capture *capture, AVCaptureDevice *dev)
{
    if (!dev)
        return;

    handle_disconnect_capture(capture, dev);
    obs_source_update_properties(capture->source);
}

static inline void handle_connect_capture(av_capture *capture, AVCaptureDevice *dev, obs_data_t *settings)
{
    if (![dev.uniqueID isEqualTo:capture->uid])
        return;

    if (capture->device) {
        AVLOG(LOG_ERROR, "Received connect for in-use device '%s'", capture->uid.UTF8String);
        return;
    }

    AVLOG(LOG_INFO,
          "Device with unique ID '%s' connected, "
          "resuming capture",
          dev.uniqueID.UTF8String);

    capture_device(capture, dev, settings);
}

static inline void handle_connect(av_capture *capture, AVCaptureDevice *dev, obs_data_t *settings)
{
    if (!dev)
        return;

    handle_connect_capture(capture, dev, settings);
    obs_source_update_properties(capture->source);
}

static bool av_capture_init(av_capture *capture, obs_data_t *settings)
{
    if (!init_session(capture))
        return false;

    capture->uid = get_string(settings, "device");

    NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
    capture->disconnect_observer.reset([nc addObserverForName:AVCaptureDeviceWasDisconnectedNotification object:nil
                                                        queue:[NSOperationQueue mainQueue]
                                                   usingBlock:^(NSNotification *note) {
                                                       handle_disconnect(capture, note.object);
                                                   }]);

    capture->connect_observer.reset([nc addObserverForName:AVCaptureDeviceWasConnectedNotification object:nil
                                                     queue:[NSOperationQueue mainQueue]
                                                usingBlock:^(NSNotification *note) {
                                                    handle_connect(capture, note.object, settings);
                                                }]);

    AVCaptureDevice *dev = [AVCaptureDevice deviceWithUniqueID:capture->uid];

    if (!dev) {
        if (capture->uid.length < 1)
            AVLOG(LOG_INFO, "No device selected");
        else
            AVLOG(LOG_WARNING,
                  "Could not initialize device "
                  "with unique ID '%s'",
                  capture->uid.UTF8String);
        return true;
    }

    capture_device(capture, dev, settings);

    return true;
}

static void *av_capture_create(obs_data_t *settings, obs_source_t *source)
{
    unique_ptr<av_capture> capture;

    try {
        capture.reset(new av_capture());
    } catch (...) {
        return capture.release();
    }

    capture->source = source;

    if (!av_capture_init(capture.get(), settings)) {
        AVLOG(LOG_ERROR, "av_capture_init failed");
        return nullptr;
    }

    av_capture_enable_buffering(capture.get(), obs_data_get_bool(settings, "buffering"));

    return capture.release();
}

static NSArray *presets(void)
{
    return @[
        //AVCaptureSessionPresetiFrame1280x720,
        //AVCaptureSessionPresetiFrame960x540,
        AVCaptureSessionPreset3840x2160, AVCaptureSessionPreset1920x1080, AVCaptureSessionPreset1280x720,
        AVCaptureSessionPreset960x540, AVCaptureSessionPreset640x480, AVCaptureSessionPreset352x288,
        AVCaptureSessionPreset320x240, AVCaptureSessionPresetHigh,
        //AVCaptureSessionPresetMedium,
        //AVCaptureSessionPresetLow,
        //AVCaptureSessionPresetPhoto,
    ];
}

static NSString *preset_names(NSString *preset)
{
    NSDictionary *preset_names = nil;
    preset_names = @ {
        AVCaptureSessionPresetLow: @"Low",
        AVCaptureSessionPresetMedium: @"Medium",
        AVCaptureSessionPresetHigh: @"High",
        AVCaptureSessionPreset320x240: @"320x240",
        AVCaptureSessionPreset352x288: @"352x288",
        AVCaptureSessionPreset640x480: @"640x480",
        AVCaptureSessionPreset960x540: @"960x540",
        AVCaptureSessionPreset1280x720: @"1280x720",
        AVCaptureSessionPreset1920x1080: @"1920x1080",
        AVCaptureSessionPreset3840x2160: @"3840x2160",
        AVCaptureSessionPresetHigh: @"High",
    };
    NSString *name = preset_names[preset];
    if (name)
        return name;
    return [NSString stringWithFormat:@"Unknown (%@)", preset];
}

inline static void av_capture_defaults(obs_data_t *settings, bool enable_audio_and_high_preset)
{
    obs_data_set_default_string(settings, "uid", "");
    obs_data_set_default_bool(settings, "use_preset", true);

    obs_data_set_default_string(settings, "preset",
                                enable_audio_and_high_preset ? AVCaptureSessionPresetHigh.UTF8String
                                                             : AVCaptureSessionPreset1280x720.UTF8String);

    obs_data_set_default_int(settings, "input_format", INPUT_FORMAT_AUTO);
    obs_data_set_default_int(settings, "color_space", COLOR_SPACE_AUTO);
    obs_data_set_default_int(settings, "video_range", VIDEO_RANGE_AUTO);

    obs_data_set_default_bool(settings, "enable_audio", enable_audio_and_high_preset);
}

static void av_capture_defaults_v1(obs_data_t *settings)
{
    av_capture_defaults(settings, false);
}

static void av_capture_defaults_v2(obs_data_t *settings)
{
    av_capture_defaults(settings, true);
}

static bool update_device_list(obs_property_t *list, NSString *uid, NSString *name, bool disconnected)
{
    bool dev_found = false;
    bool list_modified = false;

    size_t size = obs_property_list_item_count(list);
    for (size_t i = 0; i < size;) {
        const char *uid_ = obs_property_list_item_string(list, i);
        bool found = [uid isEqualToString:@(uid_ ? uid_ : "")];
        bool disabled = obs_property_list_item_disabled(list, i);
        if (!found && !disabled) {
            i += 1;
            continue;
        }

        if (disabled && !found) {
            list_modified = true;
            obs_property_list_item_remove(list, i);
            continue;
        }

        if (disabled != disconnected)
            list_modified = true;

        dev_found = true;
        obs_property_list_item_disable(list, i, disconnected);
        i += 1;
    }

    if (dev_found)
        return list_modified;

    size_t idx = obs_property_list_add_string(list, name.UTF8String, uid.UTF8String);
    obs_property_list_item_disable(list, idx, disconnected);

    return true;
}

static void fill_presets(AVCaptureDevice *dev, obs_property_t *list, NSString *current_preset)
{
    obs_property_list_clear(list);

    bool preset_found = false;
    for (NSString *preset in presets()) {
        bool is_current = [preset isEqualToString:current_preset];
        bool supported = dev && [dev supportsAVCaptureSessionPreset:preset];

        if (is_current)
            preset_found = true;

        if (!supported && !is_current)
            continue;

        size_t idx = obs_property_list_add_string(list, preset_names(preset).UTF8String, preset.UTF8String);
        obs_property_list_item_disable(list, idx, !supported);
    }

    if (preset_found)
        return;

    size_t idx = obs_property_list_add_string(list, preset_names(current_preset).UTF8String, current_preset.UTF8String);
    obs_property_list_item_disable(list, idx, true);
}

static bool check_preset(AVCaptureDevice *dev, obs_property_t *list, obs_data_t *settings)
{
    NSString *current_preset = get_string(settings, "preset");

    size_t size = obs_property_list_item_count(list);
    NSMutableSet *listed = [NSMutableSet setWithCapacity:size];

    for (size_t i = 0; i < size; i++)
        [listed addObject:@(obs_property_list_item_string(list, i))];

    bool presets_changed = false;
    for (NSString *preset in presets()) {
        bool is_listed = [listed member:preset] != nil;
        bool supported = dev && [dev supportsAVCaptureSessionPreset:preset];

        if (supported == is_listed)
            continue;

        presets_changed = true;
    }

    if (!presets_changed && [listed member:current_preset] != nil)
        return false;

    fill_presets(dev, list, current_preset);
    return true;
}

static bool autoselect_preset(AVCaptureDevice *dev, obs_data_t *settings)
{
    NSString *preset = get_string(settings, "preset");
    if (!dev || [dev supportsAVCaptureSessionPreset:preset]) {
        if (obs_data_has_autoselect_value(settings, "preset")) {
            obs_data_unset_autoselect_value(settings, "preset");
            return true;
        }

    } else {
        preset = select_preset(dev, preset);
        const char *autoselect = obs_data_get_autoselect_string(settings, "preset");
        if (![preset isEqualToString:@(autoselect)]) {
            obs_data_set_autoselect_string(settings, "preset", preset.UTF8String);
            return true;
        }
    }

    return false;
}

static CMVideoDimensions get_dimensions(AVCaptureDeviceFormat *format)
{
    auto desc = format.formatDescription;
    return CMVideoFormatDescriptionGetDimensions(desc);
}

using resolutions_t = vector<CMVideoDimensions>;

static resolutions_t enumerate_resolutions(AVCaptureDevice *dev)
{
    resolutions_t res;

    if (!dev)
        return res;

    res.reserve(dev.formats.count + 1);

    for (AVCaptureDeviceFormat *format in dev.formats) {
        auto dims = get_dimensions(format);

        if (find(begin(res), end(res), dims) == end(res))
            res.push_back(dims);
    }

    return res;
}

static void sort_resolutions(vector<CMVideoDimensions> &resolutions)
{
    auto cmp = [](const CMVideoDimensions &a, const CMVideoDimensions &b) {
        return a.width * a.height > b.width * b.height;
    };

    sort(begin(resolutions), end(resolutions), cmp);
}

static void data_set_resolution(obs_data_t *data, const CMVideoDimensions &dims)
{
    obs_data_set_int(data, "width", dims.width);
    obs_data_set_int(data, "height", dims.height);
}

static void data_set_resolution(const unique_ptr<obs_data_t> &data, const CMVideoDimensions &dims)
{
    data_set_resolution(data.get(), dims);
}

static bool add_resolution_to_list(vector<CMVideoDimensions> &res, const CMVideoDimensions &dims)
{
    if (find(begin(res), end(res), dims) != end(res))
        return false;

    res.push_back(dims);
    return true;
}

static const char *obs_data_get_json(const unique_ptr<obs_data_t> &data)
{
    return obs_data_get_json(data.get());
}

static bool operator==(const CMVideoDimensions &a, const CMVideoDimensions &b)
{
    return a.width == b.width && a.height == b.height;
}

static bool resolution_property_needs_update(obs_property_t *p, const resolutions_t &resolutions)
{
    vector<bool> res_found(resolutions.size());

    auto num = obs_property_list_item_count(p);
    for (size_t i = 1; i < num; i++) {  // skip empty entry
        const char *json = obs_property_list_item_string(p, i);
        unique_ptr<obs_data_t> buffer {obs_data_create_from_json(json)};

        CMVideoDimensions dims {};
        if (!get_resolution(buffer.get(), dims))
            return true;

        auto pos = find(begin(resolutions), end(resolutions), dims);
        if (pos == end(resolutions))
            return true;

        res_found[pos - begin(resolutions)] = true;
    }

    return any_of(begin(res_found), end(res_found), [](bool b) {
        return !b;
    });
}

static bool update_resolution_property(obs_properties_t *props, const config_helper &conf, obs_property_t *p = nullptr)
{
    if (!p)
        p = obs_properties_get(props, "resolution");

    if (!p)
        return false;

    auto valid_dims = conf.dims();
    auto resolutions = enumerate_resolutions(conf.dev());

    bool unsupported = true;
    if (valid_dims)
        unsupported = add_resolution_to_list(resolutions, *valid_dims);

    bool was_enabled = obs_property_enabled(p);
    obs_property_set_enabled(p, !!conf.dev());

    if (!resolution_property_needs_update(p, resolutions))
        return was_enabled != obs_property_enabled(p);

    sort_resolutions(resolutions);

    obs_property_list_clear(p);
    obs_property_list_add_string(p, "", "{}");

    DStr name;
    unique_ptr<obs_data_t> buffer {obs_data_create()};
    for (const CMVideoDimensions &dims : resolutions) {
        data_set_resolution(buffer, dims);
        auto json = obs_data_get_json(buffer);
        dstr_printf(name, "%dx%d", dims.width, dims.height);
        size_t idx = obs_property_list_add_string(p, name->array, json);

        if (unsupported && valid_dims && dims == *valid_dims)
            obs_property_list_item_disable(p, idx, true);
    }

    return true;
}

static media_frames_per_second convert(CMTime time_)
{
    media_frames_per_second res {};
    clamp(res.numerator, time_.timescale);
    clamp(res.denominator, time_.value);
    return res;
}

using frame_rates_t = vector<pair<media_frames_per_second, media_frames_per_second>>;
static frame_rates_t enumerate_frame_rates(AVCaptureDevice *dev, const CMVideoDimensions *dims = nullptr)
{
    frame_rates_t res;

    if (!dev || !dims)
        return res;

    auto add_unique_frame_rate_range = [&](AVFrameRateRange *range) {
        auto min = convert(range.maxFrameDuration);
        auto max = convert(range.minFrameDuration);

        auto pair = make_pair(min, max);

        if (find(begin(res), end(res), pair) != end(res))
            return;

        res.push_back(pair);
    };

    for (AVCaptureDeviceFormat *format in dev.formats) {
        if (!(get_dimensions(format) == *dims))
            continue;

        for (AVFrameRateRange *range in format.videoSupportedFrameRateRanges) {
            add_unique_frame_rate_range(range);

            if (CMTimeCompare(range.minFrameDuration, range.maxFrameDuration) != 0) {
                blog(LOG_WARNING,
                     "Got actual frame rate range:"
                     " %g - %g "
                     "({%lld, %d} - {%lld, %d})",
                     range.minFrameRate, range.maxFrameRate, range.maxFrameDuration.value,
                     range.maxFrameDuration.timescale, range.minFrameDuration.value, range.minFrameDuration.timescale);
            }
        }
    }

    return res;
}

static bool operator==(const media_frames_per_second &a, const media_frames_per_second &b)
{
    return a.numerator == b.numerator && a.denominator == b.denominator;
}

static bool operator!=(const media_frames_per_second &a, const media_frames_per_second &b)
{
    return !(a == b);
}

static bool frame_rate_property_needs_update(obs_property_t *p, const frame_rates_t &frame_rates)
{
    auto fps_num = frame_rates.size();
    auto num = obs_property_frame_rate_fps_ranges_count(p);
    if (fps_num != num)
        return true;

    vector<bool> fps_found(fps_num);
    for (size_t i = 0; i < num; i++) {
        auto min_ = obs_property_frame_rate_fps_range_min(p, i);
        auto max_ = obs_property_frame_rate_fps_range_max(p, i);

        auto it = find(begin(frame_rates), end(frame_rates), make_pair(min_, max_));
        if (it == end(frame_rates))
            return true;

        fps_found[it - begin(frame_rates)] = true;
    }

    return any_of(begin(fps_found), end(fps_found), [](bool b) {
        return !b;
    });
}

static bool update_frame_rate_property(obs_properties_t *props, const config_helper &conf, obs_property_t *p = nullptr)
{
    if (!p)
        p = obs_properties_get(props, "frame_rate");

    if (!p)
        return false;

    auto valid_dims = conf.dims();
    auto frame_rates = enumerate_frame_rates(conf.dev(), valid_dims);

    bool was_enabled = obs_property_enabled(p);
    obs_property_set_enabled(p, !frame_rates.empty());

    if (!frame_rate_property_needs_update(p, frame_rates))
        return was_enabled != obs_property_enabled(p);

    obs_property_frame_rate_fps_ranges_clear(p);
    for (auto &pair : frame_rates)
        obs_property_frame_rate_fps_range_add(p, pair.first, pair.second);

    return true;
}

static vector<AVCaptureDeviceFormat *> enumerate_formats(AVCaptureDevice *dev, const CMVideoDimensions &dims,
                                                         const media_frames_per_second &fps)
{
    vector<AVCaptureDeviceFormat *> result;

    find_formats(fps, dev, &dims, [&](AVCaptureDeviceFormat *format) {
        result.push_back(format);
        return false;
    });

    return result;
}

static bool input_format_property_needs_update(obs_property_t *p, const vector<AVCaptureDeviceFormat *> &formats,
                                               const FourCharCode *fourcc_)
{
    bool fourcc_found = !fourcc_;
    vector<bool> if_found(formats.size());

    auto num = obs_property_list_item_count(p);
    for (size_t i = 1; i < num; i++) {  // skip auto entry
        FourCharCode fourcc = (FourCharCode) obs_property_list_item_int(p, i);
        fourcc_found = fourcc_found || fourcc == *fourcc_;

        auto pos = find_if(begin(formats), end(formats), [&](AVCaptureDeviceFormat *format) {
            FourCharCode fourcc_ = 0;
            format_description_subtype_name(format.formatDescription, &fourcc_);
            return fourcc_ == fourcc;
        });
        if (pos == end(formats))
            return true;

        if_found[pos - begin(formats)] = true;
    }

    return fourcc_found || any_of(begin(if_found), end(if_found), [](bool b) {
               return !b;
           });
}

static bool update_input_format_property(obs_properties_t *props, const config_helper &conf,
                                         obs_property_t *p = nullptr)
{
    if (!p)
        p = obs_properties_get(props, "input_format");

    if (!p)
        return false;

    auto update_enabled = [&](bool enabled) {
        bool was_enabled = obs_property_enabled(p);
        obs_property_set_enabled(p, enabled);
        return was_enabled != enabled;
    };

    auto valid_dims = conf.dims();
    auto valid_fps = conf.fps();
    auto valid_if = conf.input_format();

    if (!valid_dims || !valid_fps)
        return update_enabled(false);

    auto formats = enumerate_formats(conf.dev(), *valid_dims, *valid_fps);
    if (!input_format_property_needs_update(p, formats, valid_if))
        return update_enabled(!formats.empty());

    while (obs_property_list_item_count(p) > 1)
        obs_property_list_item_remove(p, 1);

    bool fourcc_found = !valid_if || *valid_if == INPUT_FORMAT_AUTO;
    for (auto &format : formats) {
        FourCharCode fourcc = 0;
        const char *name = format_description_subtype_name(format.formatDescription, &fourcc);
        obs_property_list_add_int(p, name, fourcc);
        fourcc_found = fourcc_found || fourcc == *valid_if;
    }

    if (!fourcc_found) {
        const char *name = fourcc_subtype_name(*valid_if);
        obs_property_list_add_int(p, name, *valid_if);
    }

    return update_enabled(!formats.empty());
}

static bool update_int_list_property(obs_property_t *p, const int *val, const size_t count,
                                     const char *localization_name)
{
    size_t num = obs_property_list_item_count(p);
    if (num > count) {
        if (!val || obs_property_list_item_int(p, count) != *val) {
            obs_property_list_item_remove(p, count);

            if (!val)
                return true;
        } else {
            return false;
        }
    }

    if (!val)
        return false;

    DStr buf, label;
    dstr_printf(buf, "%d", *val);
    dstr_init_copy(label, obs_module_text(localization_name));
    dstr_replace(label, "%1", buf->array);
    size_t idx = obs_property_list_add_int(p, label->array, *val);
    obs_property_list_item_disable(p, idx, true);

    return true;
}

template<typename Func>
static bool update_int_list_property(const char *prop_name, const char *localization_name, size_t count, int auto_val,
                                     bool (*valid_func)(int), obs_properties_t *props, const config_helper &conf,
                                     obs_property_t *p, Func get_val)
{
    auto ref = get_ref(props);
    if (!p)
        p = obs_properties_get(props, prop_name);

    int val = (int) obs_data_get_int(conf.settings, prop_name);

    av_video_info vi;
    if (ref)
        vi = ref->video_info.read();

    bool params_valid = vi.video_params_valid;
    bool enabled = obs_property_enabled(p);
    bool should_enable = false;
    bool has_autoselect = obs_data_has_autoselect_value(conf.settings, prop_name);

    if ((params_valid && format_is_yuv(ref->frame.format)) || !valid_func(val))
        should_enable = true;

    obs_property_set_enabled(p, should_enable);
    bool updated = enabled != should_enable;

    updated = update_int_list_property(p, valid_func(val) ? nullptr : &val, count, localization_name) || updated;

    if (!should_enable) {
        if (has_autoselect)
            obs_data_unset_autoselect_value(conf.settings, prop_name);
        return updated || has_autoselect;
    }

    bool use_autoselect = ref && val == auto_val;
    if (!use_autoselect) {
        if (has_autoselect)
            obs_data_unset_autoselect_value(conf.settings, prop_name);
        return updated || has_autoselect;
    }

    if (params_valid && get_val(vi) != obs_data_get_autoselect_int(conf.settings, prop_name)) {
        obs_data_set_autoselect_int(conf.settings, prop_name, get_val(vi));
        return true;
    }

    return updated;
}

static bool update_color_space_property(obs_properties_t *props, const config_helper &conf, obs_property_t *p = nullptr)
{
    return update_int_list_property("color_space", TEXT_COLOR_UNKNOWN_NAME, 4, COLOR_SPACE_AUTO, color_space_valid,
                                    props, conf, p, [](av_video_info vi) {
                                        return vi.colorspace;
                                    });
}

static bool update_video_range_property(obs_properties_t *props, const config_helper &conf, obs_property_t *p = nullptr)
{
    return update_int_list_property("video_range", TEXT_RANGE_UNKNOWN_NAME, 5, VIDEO_RANGE_AUTO, video_range_valid,
                                    props, conf, p, [](av_video_info vi) {
                                        return vi.video_range;
                                    });
}

static bool properties_device_changed(obs_properties_t *props, obs_property_t *p, obs_data_t *settings)
{
    NSString *uid = get_string(settings, "device");
    AVCaptureDevice *dev = [AVCaptureDevice deviceWithUniqueID:uid];

    NSString *name = get_string(settings, "device_name");
    bool dev_list_updated = update_device_list(p, uid, name, !dev && uid.length);

    p = obs_properties_get(props, "preset");
    bool preset_list_changed = check_preset(dev, p, settings);
    bool autoselect_changed = autoselect_preset(dev, settings);

    config_helper conf {settings};
    bool res_changed = update_resolution_property(props, conf);
    bool fps_changed = update_frame_rate_property(props, conf);
    bool if_changed = update_input_format_property(props, conf);

    return preset_list_changed || autoselect_changed || dev_list_updated || res_changed || fps_changed || if_changed;
}

static bool properties_use_preset_changed(obs_properties_t *props, obs_property_t *, obs_data_t *settings)
{
    auto use_preset = obs_data_get_bool(settings, "use_preset");

    config_helper conf {settings};

    bool updated = false;
    bool visible = false;
    obs_property_t *p = nullptr;

    auto noop = [](obs_properties_t *, const config_helper &, obs_property_t *) {
        return false;
    };

#define UPDATE_PROPERTY(prop, uses_preset, func)             \
    p = obs_properties_get(props, prop);                     \
    visible = use_preset == uses_preset;                     \
    updated = obs_property_visible(p) != visible || updated; \
    obs_property_set_visible(p, visible);                    \
    updated = func(props, conf, p) || updated;

    UPDATE_PROPERTY("preset", true, noop);
    UPDATE_PROPERTY("resolution", false, update_resolution_property);
    UPDATE_PROPERTY("frame_rate", false, update_frame_rate_property);
    UPDATE_PROPERTY("input_format", false, update_input_format_property);
    UPDATE_PROPERTY("color_space", false, update_color_space_property);
    UPDATE_PROPERTY("video_range", false, update_video_range_property);

    return updated;
}

static bool properties_preset_changed(obs_properties_t *, obs_property_t *p, obs_data_t *settings)
{
    NSString *uid = get_string(settings, "device");
    AVCaptureDevice *dev = [AVCaptureDevice deviceWithUniqueID:uid];

    bool preset_list_changed = check_preset(dev, p, settings);
    bool autoselect_changed = autoselect_preset(dev, settings);

    return preset_list_changed || autoselect_changed;
}

static bool properties_resolution_changed(obs_properties_t *props, obs_property_t *p, obs_data_t *settings)
{
    config_helper conf {settings};

    bool res_updated = update_resolution_property(props, conf, p);
    bool fps_updated = update_frame_rate_property(props, conf);
    bool if_updated = update_input_format_property(props, conf);
    bool cs_updated = update_color_space_property(props, conf);
    bool cr_updated = update_video_range_property(props, conf);

    return res_updated || fps_updated || if_updated || cs_updated || cr_updated;
}

static bool properties_frame_rate_changed(obs_properties_t *props, obs_property_t *p, obs_data_t *settings)
{
    config_helper conf {settings};

    bool fps_updated = update_frame_rate_property(props, conf, p);
    bool if_updated = update_input_format_property(props, conf);
    bool cs_updated = update_color_space_property(props, conf);
    bool cr_updated = update_video_range_property(props, conf);

    return fps_updated || if_updated || cs_updated || cr_updated;
}

static bool properties_input_format_changed(obs_properties_t *props, obs_property_t *p, obs_data_t *settings)
{
    config_helper conf {settings};

    bool if_updated = update_input_format_property(props, conf, p);
    bool cs_updated = update_color_space_property(props, conf);
    bool cr_updated = update_video_range_property(props, conf);

    return if_updated || cs_updated || cr_updated;
}

static bool properties_color_space_changed(obs_properties_t *props, obs_property_t *p, obs_data_t *settings)
{
    config_helper conf {settings};

    return update_color_space_property(props, conf, p);
}

static bool properties_video_range_changed(obs_properties_t *props, obs_property_t *p, obs_data_t *settings)
{
    config_helper conf {settings};

    return update_video_range_property(props, conf, p);
}

static void add_properties_param(obs_properties_t *props, av_capture *capture)
{
    auto param = unique_ptr<properties_param>(new properties_param(capture));

    obs_properties_set_param(props, param.release(), [](void *param) {
        delete static_cast<properties_param *>(param);
    });
}

static void add_preset_properties(obs_properties_t *props)
{
    obs_property_t *preset_list =
        obs_properties_add_list(props, "preset", TEXT_PRESET, OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
    for (NSString *preset in presets())
        obs_property_list_add_string(preset_list, preset_names(preset).UTF8String, preset.UTF8String);

    obs_property_set_modified_callback(preset_list, properties_preset_changed);
}

static void add_manual_properties(obs_properties_t *props)
{
    obs_property_t *resolutions =
        obs_properties_add_list(props, "resolution", TEXT_RESOLUTION, OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
    obs_property_set_enabled(resolutions, false);
    obs_property_set_modified_callback(resolutions, properties_resolution_changed);

    obs_property_t *frame_rates = obs_properties_add_frame_rate(props, "frame_rate", TEXT_FRAME_RATE);
    /*obs_property_frame_rate_option_add(frame_rates, "match obs",
			TEXT_MATCH_OBS);*/
    obs_property_set_enabled(frame_rates, false);
    obs_property_set_modified_callback(frame_rates, properties_frame_rate_changed);

    obs_property_t *input_format =
        obs_properties_add_list(props, "input_format", TEXT_INPUT_FORMAT, OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
    obs_property_list_add_int(input_format, TEXT_AUTO, INPUT_FORMAT_AUTO);
    obs_property_set_enabled(input_format, false);
    obs_property_set_modified_callback(input_format, properties_input_format_changed);

    obs_property_t *color_space =
        obs_properties_add_list(props, "color_space", TEXT_COLOR_SPACE, OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
    obs_property_list_add_int(color_space, TEXT_AUTO, COLOR_SPACE_AUTO);
    obs_property_list_add_int(color_space, "Rec. 601", VIDEO_CS_601);
    obs_property_list_add_int(color_space, "Rec. 709", VIDEO_CS_709);
    obs_property_set_enabled(color_space, false);
    obs_property_set_modified_callback(color_space, properties_color_space_changed);

#define ADD_RANGE(x) obs_property_list_add_int(video_range, TEXT_##x, VIDEO_##x)
    obs_property_t *video_range =
        obs_properties_add_list(props, "video_range", TEXT_VIDEO_RANGE, OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
    obs_property_list_add_int(video_range, TEXT_AUTO, VIDEO_RANGE_AUTO);
    ADD_RANGE(RANGE_PARTIAL);
    ADD_RANGE(RANGE_FULL);
    obs_property_set_enabled(video_range, false);
    obs_property_set_modified_callback(video_range, properties_video_range_changed);
#undef ADD_RANGE
}

static obs_properties_t *av_capture_properties(void *data)
{
    obs_properties_t *props = obs_properties_create();

    obs_property_t *dev_list =
        obs_properties_add_list(props, "device", TEXT_DEVICE, OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
    obs_property_list_add_string(dev_list, "", "");

    NSMutableArray *device_types = [NSMutableArray
        arrayWithObjects:AVCaptureDeviceTypeBuiltInWideAngleCamera, AVCaptureDeviceTypeExternalUnknown, nil];
#if __MAC_OS_X_VERSION_MAX_ALLOWED >= 130000
    if (__builtin_available(macOS 13.0, *)) {
        [device_types addObject:AVCaptureDeviceTypeDeskViewCamera];
    }
#endif
    AVCaptureDeviceDiscoverySession *video_discovery =
        [AVCaptureDeviceDiscoverySession discoverySessionWithDeviceTypes:device_types mediaType:AVMediaTypeVideo
                                                                position:AVCaptureDevicePositionUnspecified];
    for (AVCaptureDevice *dev in [video_discovery devices]) {
        obs_property_list_add_string(dev_list, dev.localizedName.UTF8String, dev.uniqueID.UTF8String);
    }

    AVCaptureDeviceDiscoverySession *muxed_discovery =
        [AVCaptureDeviceDiscoverySession discoverySessionWithDeviceTypes:device_types mediaType:AVMediaTypeMuxed
                                                                position:AVCaptureDevicePositionUnspecified];
    for (AVCaptureDevice *dev in [muxed_discovery devices]) {
        obs_property_list_add_string(dev_list, dev.localizedName.UTF8String, dev.uniqueID.UTF8String);
    }

    obs_property_set_modified_callback(dev_list, properties_device_changed);

    obs_property_t *use_preset = obs_properties_add_bool(props, "use_preset", TEXT_USE_PRESET);
    obs_property_set_modified_callback(use_preset, properties_use_preset_changed);

    add_preset_properties(props);

    add_manual_properties(props);

    obs_properties_add_bool(props, "buffering", obs_module_text("Buffering"));

    if (data) {
        struct av_capture *capture = static_cast<av_capture *>(data);

        add_properties_param(props, capture);

        OBSDataAutoRelease current_settings = obs_source_get_settings(capture->source);
        if (!obs_data_get_bool(current_settings, "enable_audio")) {
            auto cb = [](obs_properties_t *, obs_property_t *prop, void *data) {
                struct av_capture *capture = static_cast<av_capture *>(data);
                OBSDataAutoRelease settings = obs_data_create();
                obs_data_set_bool(settings, "enable_audio", true);
                obs_source_update(capture->source, settings);

                // Enable all audio tracks
                obs_source_set_audio_mixers(capture->source, 0x3F);
                obs_property_set_visible(prop, false);
                return true;
            };
            obs_properties_add_button2(props, "enable_audio_button", obs_module_text("EnableAudio"), cb, capture);
        }
    }

    return props;
}

static void switch_device(av_capture *capture, NSString *uid, obs_data_t *settings)
{
    if (!uid)
        return;

    if (capture->device)
        remove_device(capture);

    capture->uid = uid;

    if (!uid.length) {
        AVLOG(LOG_INFO, "No device selected, stopping capture");
        return;
    }

    AVCaptureDevice *dev = [AVCaptureDevice deviceWithUniqueID:uid];
    if (!dev) {
        AVLOG(LOG_WARNING, "Device with unique id '%s' not found", uid.UTF8String);
        return;
    }

    capture_device(capture, dev, settings);
}

static void update_preset(av_capture *capture, obs_data_t *settings)
{
    unlock_device(capture);

    NSString *preset = get_string(settings, "preset");
    if (![capture->device supportsAVCaptureSessionPreset:preset]) {
        AVLOG(LOG_WARNING, "Preset %s not available", preset.UTF8String);
        preset = select_preset(capture->device, preset);
    }

    capture->session.sessionPreset = preset;
    AVLOG(LOG_INFO, "Selected preset %s", preset.UTF8String);

    start_capture(capture);
}

static void update_manual(av_capture *capture, obs_data_t *settings)
{
    if (init_manual(capture, capture->device, settings))
        start_capture(capture);
}

static void av_capture_update(void *data, obs_data_t *settings)
{
    auto capture = static_cast<av_capture *>(data);

    NSString *uid = get_string(settings, "device");

    if (!capture->device || ![capture->device.uniqueID isEqualToString:uid])
        return switch_device(capture, uid, settings);

    if ((capture->use_preset = obs_data_get_bool(settings, "use_preset"))) {
        update_preset(capture, settings);
    } else {
        update_manual(capture, settings);
    }

    av_capture_enable_buffering(capture, obs_data_get_bool(settings, "buffering"));

    av_capture_set_audio_active(capture, obs_data_get_bool(settings, "enable_audio") &&
                                             ([capture->device hasMediaType:AVMediaTypeAudio] ||
                                              [capture->device hasMediaType:AVMediaTypeMuxed]));
}

OBS_DECLARE_MODULE()
OBS_MODULE_USE_DEFAULT_LOCALE("mac-avcapture", "en-US")
MODULE_EXPORT const char *obs_module_description(void)
{
    return "MacOS AVFoundation Capture source";
}

bool obs_module_load(void)
{
    // Enable iOS device to show up as AVCapture devices
    // From WWDC video 2014 #508 at 5:34
    // https://developer.apple.com/videos/wwdc/2014/#508
    CMIOObjectPropertyAddress prop = {kCMIOHardwarePropertyAllowScreenCaptureDevices, kCMIOObjectPropertyScopeGlobal,
                                      kCMIOObjectPropertyElementMaster};
    UInt32 allow = 1;
    CMIOObjectSetPropertyData(kCMIOObjectSystemObject, &prop, 0, NULL, sizeof(allow), &allow);

    obs_source_info av_capture_info = {
        .id = "av_capture_input",
        .type = OBS_SOURCE_TYPE_INPUT,
        .output_flags = OBS_SOURCE_ASYNC_VIDEO | OBS_SOURCE_AUDIO | OBS_SOURCE_DO_NOT_DUPLICATE |
                        OBS_SOURCE_CAP_OBSOLETE,
        .get_name = av_capture_getname,
        .create = av_capture_create,
        .destroy = av_capture_destroy,
        .get_defaults = av_capture_defaults_v1,
        .get_properties = av_capture_properties,
        .update = av_capture_update,
        .icon_type = OBS_ICON_TYPE_CAMERA,
    };
    obs_register_source(&av_capture_info);

    av_capture_info.version = 2;
    av_capture_info.output_flags = OBS_SOURCE_ASYNC_VIDEO | OBS_SOURCE_AUDIO | OBS_SOURCE_DO_NOT_DUPLICATE;
    av_capture_info.get_defaults = av_capture_defaults_v2;

    obs_register_source(&av_capture_info);
    return true;
}