diff --git a/src/gui/main.cpp b/src/gui/main.cpp index 1173dd3..471bf22 100644 --- a/src/gui/main.cpp +++ b/src/gui/main.cpp @@ -85,7 +85,7 @@ static std::atomic audio_buffer_fresh = false; static uint32_t last_ts = 0; char *out = "audio_old.pcm"; -// FILE *outfile = fopen(out, "wb+"); +FILE *outfile = fopen(out, "wb+"); int64_t src_ch_layout = AV_CH_LAYOUT_MONO; int src_rate = 48000; diff --git a/src/screen_capture/macosx/screen_capture_wgc.cpp b/src/screen_capture/macosx/screen_capture_wgc.cpp deleted file mode 100644 index 077e527..0000000 --- a/src/screen_capture/macosx/screen_capture_wgc.cpp +++ /dev/null @@ -1,26 +0,0 @@ -#include "screen_capture_wgc.h" - -#include - -ScreenCaptureWgc::ScreenCaptureWgc() {} - -ScreenCaptureWgc::~ScreenCaptureWgc() {} - -bool ScreenCaptureWgc::IsWgcSupported() { return false; } - -int ScreenCaptureWgc::Init(const RECORD_DESKTOP_RECT &rect, const int fps, - cb_desktop_data cb) { - return 0; -} - -int ScreenCaptureWgc::Start() { return 0; } - -int ScreenCaptureWgc::Pause() { return 0; } - -int ScreenCaptureWgc::Resume() { return 0; } - -int ScreenCaptureWgc::Stop() { return 0; } - -void ScreenCaptureWgc::OnFrame() {} - -void ScreenCaptureWgc::CleanUp() {} diff --git a/src/screen_capture/macosx/screen_capture_wgc.h b/src/screen_capture/macosx/screen_capture_wgc.h deleted file mode 100644 index 813bf09..0000000 --- a/src/screen_capture/macosx/screen_capture_wgc.h +++ /dev/null @@ -1,56 +0,0 @@ -#ifndef _SCREEN_CAPTURE_WGC_H_ -#define _SCREEN_CAPTURE_WGC_H_ - -#include -#include -#include -#include - -typedef struct { - int left; - int top; - int right; - int bottom; -} RECORD_DESKTOP_RECT; - -typedef std::function cb_desktop_data; -typedef std::function cb_desktop_error; - -class ScreenCaptureWgc { - public: - ScreenCaptureWgc(); - ~ScreenCaptureWgc(); - - public: - bool IsWgcSupported(); - - int Init(const RECORD_DESKTOP_RECT &rect, const int fps, cb_desktop_data cb); - - int Start(); - int Pause(); - int Resume(); - int Stop(); - - void OnFrame(); - - protected: - void CleanUp(); - - private: - std::atomic_bool _running; - std::atomic_bool _paused; - std::atomic_bool _inited; - - std::thread _thread; - - std::string _device_name; - - RECORD_DESKTOP_RECT _rect; - - int _fps; - - cb_desktop_data _on_data; - cb_desktop_error _on_error; -}; - -#endif \ No newline at end of file diff --git a/src/screen_capture/macosx/screen_capture_x11.cpp b/src/screen_capture/macosx/screen_capture_x11.cpp new file mode 100644 index 0000000..4fc91de --- /dev/null +++ b/src/screen_capture/macosx/screen_capture_x11.cpp @@ -0,0 +1,147 @@ +#include "screen_capture_x11.h" + +#include + +#include "log.h" + +#define NV12_BUFFER_SIZE 1280 * 720 * 3 / 2 +unsigned char nv12_buffer_[NV12_BUFFER_SIZE]; + +ScreenCaptureX11::ScreenCaptureX11() {} + +ScreenCaptureX11::~ScreenCaptureX11() +{ + if (capture_thread_->joinable()) + { + capture_thread_->join(); + } +} + +int ScreenCaptureX11::Init(const RECORD_DESKTOP_RECT &rect, const int fps, + cb_desktop_data cb) +{ + if (cb) + { + _on_data = cb; + } + + pFormatCtx_ = avformat_alloc_context(); + + avdevice_register_all(); + + // grabbing frame rate + av_dict_set(&options_, "framerate", "30", 0); + av_dict_set(&options_, "pixel_format", "nv12", 0); + // Make the grabbed area follow the mouse + // av_dict_set(&options_, "follow_mouse", "centered", 0); + // Video frame size. The default is to capture the full screen + // av_dict_set(&options_, "video_size", "1280x720", 0); + ifmt_ = (AVInputFormat *)av_find_input_format("avfoundation"); + if (!ifmt_) + { + printf("Couldn't find_input_format\n"); + } + + // Grab at position 10,20 + if (avformat_open_input(&pFormatCtx_, "Capture screen 0", ifmt_, &options_) != 0) + { + printf("Couldn't open input stream.\n"); + return -1; + } + + if (avformat_find_stream_info(pFormatCtx_, NULL) < 0) + { + printf("Couldn't find stream information.\n"); + return -1; + } + + videoindex_ = -1; + for (i_ = 0; i_ < pFormatCtx_->nb_streams; i_++) + if (pFormatCtx_->streams[i_]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) + { + videoindex_ = i_; + break; + } + if (videoindex_ == -1) + { + printf("Didn't find a video stream.\n"); + return -1; + } + + pCodecParam_ = pFormatCtx_->streams[videoindex_]->codecpar; + + pCodecCtx_ = avcodec_alloc_context3(NULL); + avcodec_parameters_to_context(pCodecCtx_, pCodecParam_); + + pCodec_ = const_cast(avcodec_find_decoder(pCodecCtx_->codec_id)); + if (pCodec_ == NULL) + { + printf("Codec not found.\n"); + return -1; + } + if (avcodec_open2(pCodecCtx_, pCodec_, NULL) < 0) + { + printf("Could not open codec.\n"); + return -1; + } + + const int screen_w = pFormatCtx_->streams[videoindex_]->codecpar->width; + const int screen_h = pFormatCtx_->streams[videoindex_]->codecpar->height; + + pFrame_ = av_frame_alloc(); + pFrameNv12_ = av_frame_alloc(); + + pFrame_->width = screen_w; + pFrame_->height = screen_h; + pFrameNv12_->width = 1280; + pFrameNv12_->height = 720; + + packet_ = (AVPacket *)av_malloc(sizeof(AVPacket)); + + img_convert_ctx_ = sws_getContext( + pFrame_->width, pFrame_->height, pCodecCtx_->pix_fmt, pFrameNv12_->width, + pFrameNv12_->height, AV_PIX_FMT_NV12, SWS_BICUBIC, NULL, NULL, NULL); + + return 0; +} + +int ScreenCaptureX11::Start() +{ + capture_thread_.reset(new std::thread([this]() + { + while (1) { + if (av_read_frame(pFormatCtx_, packet_) >= 0) { + if (packet_->stream_index == videoindex_) { + avcodec_send_packet(pCodecCtx_, packet_); + av_packet_unref(packet_); + got_picture_ = avcodec_receive_frame(pCodecCtx_, pFrame_); + + if (!got_picture_) { + av_image_fill_arrays(pFrameNv12_->data, pFrameNv12_->linesize, + nv12_buffer_, AV_PIX_FMT_NV12, + pFrameNv12_->width, pFrameNv12_->height, 1); + + sws_scale(img_convert_ctx_, pFrame_->data, pFrame_->linesize, 0, + pFrame_->height, pFrameNv12_->data, + pFrameNv12_->linesize); + + _on_data((unsigned char *)nv12_buffer_, + pFrameNv12_->width * pFrameNv12_->height * 3 / 2, + pFrameNv12_->width, pFrameNv12_->height); + } + } + } + } })); + + return 0; +} + +int ScreenCaptureX11::Pause() { return 0; } + +int ScreenCaptureX11::Resume() { return 0; } + +int ScreenCaptureX11::Stop() { return 0; } + +void ScreenCaptureX11::OnFrame() {} + +void ScreenCaptureX11::CleanUp() {} diff --git a/src/screen_capture/macosx/screen_capture_x11.h b/src/screen_capture/macosx/screen_capture_x11.h new file mode 100644 index 0000000..93b3719 --- /dev/null +++ b/src/screen_capture/macosx/screen_capture_x11.h @@ -0,0 +1,85 @@ +#ifndef _SCREEN_CAPTURE_X11_H_ +#define _SCREEN_CAPTURE_X11_H_ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif +#include +#include +#include +#include +#include +#ifdef __cplusplus +}; +#endif + +typedef struct { + int left; + int top; + int right; + int bottom; +} RECORD_DESKTOP_RECT; + +typedef std::function cb_desktop_data; +typedef std::function cb_desktop_error; + +class ScreenCaptureX11 { + public: + ScreenCaptureX11(); + ~ScreenCaptureX11(); + + public: + int Init(const RECORD_DESKTOP_RECT &rect, const int fps, cb_desktop_data cb); + + int Start(); + int Pause(); + int Resume(); + int Stop(); + + void OnFrame(); + + protected: + void CleanUp(); + + private: + std::atomic_bool _running; + std::atomic_bool _paused; + std::atomic_bool _inited; + + std::thread _thread; + + std::string _device_name; + + RECORD_DESKTOP_RECT _rect; + + int _fps; + + cb_desktop_data _on_data; + cb_desktop_error _on_error; + + private: + int i_ = 0; + int videoindex_ = 0; + int got_picture_ = 0; + // ffmpeg + AVFormatContext *pFormatCtx_ = nullptr; + AVCodecContext *pCodecCtx_ = nullptr; + AVCodec *pCodec_ = nullptr; + AVCodecParameters *pCodecParam_ = nullptr; + AVDictionary *options_ = nullptr; + AVInputFormat *ifmt_ = nullptr; + AVFrame *pFrame_ = nullptr; + AVFrame *pFrameNv12_ = nullptr; + AVPacket *packet_ = nullptr; + struct SwsContext *img_convert_ctx_ = nullptr; + + // thread + std::unique_ptr capture_thread_ = nullptr; +}; + +#endif \ No newline at end of file diff --git a/src/screen_capture/macosx/x11_session.h b/src/screen_capture/macosx/x11_session.h new file mode 100644 index 0000000..9225c09 --- /dev/null +++ b/src/screen_capture/macosx/x11_session.h @@ -0,0 +1,37 @@ +#ifndef _X11_SESSION_H_ +#define _X11_SESSION_H_ + +class X11Session { + public: + struct x11_session_frame { + unsigned int width; + unsigned int height; + unsigned int row_pitch; + + const unsigned char *data; + }; + + class x11_session_observer { + public: + virtual ~x11_session_observer() {} + virtual void OnFrame(const x11_session_frame &frame) = 0; + }; + + public: + virtual void Release() = 0; + + virtual int Initialize() = 0; + + virtual void RegisterObserver(x11_session_observer *observer) = 0; + + virtual int Start() = 0; + virtual int Stop() = 0; + + virtual int Pause() = 0; + virtual int Resume() = 0; + + protected: + virtual ~X11Session(){}; +}; + +#endif \ No newline at end of file diff --git a/src/screen_capture/macosx/x11_session_impl.cpp b/src/screen_capture/macosx/x11_session_impl.cpp new file mode 100644 index 0000000..54aa7e9 --- /dev/null +++ b/src/screen_capture/macosx/x11_session_impl.cpp @@ -0,0 +1,49 @@ +#include "x11_session_impl.h" + +#include +#include +#include +#include + +#define CHECK_INIT \ + if (!is_initialized_) { \ + std::cout << "AE_NEED_INIT" << std::endl; \ + return 4; \ + } + +X11SessionImpl::X11SessionImpl() {} + +X11SessionImpl::~X11SessionImpl() { + Stop(); + CleanUp(); +} + +void X11SessionImpl::Release() { delete this; } + +int X11SessionImpl::Initialize() { return 0; } + +void X11SessionImpl::RegisterObserver(x11_session_observer *observer) { + observer_ = observer; +} + +int X11SessionImpl::Start() { + if (is_running_) return 0; + + int error = 1; + + CHECK_INIT; + + return error; +} + +int X11SessionImpl::Stop() { return 0; } + +int X11SessionImpl::Pause() { return 0; } + +int X11SessionImpl::Resume() { return 0; } + +void X11SessionImpl::OnFrame() {} + +void X11SessionImpl::OnClosed() {} + +void X11SessionImpl::CleanUp() {} \ No newline at end of file diff --git a/src/screen_capture/macosx/x11_session_impl.h b/src/screen_capture/macosx/x11_session_impl.h new file mode 100644 index 0000000..075c174 --- /dev/null +++ b/src/screen_capture/macosx/x11_session_impl.h @@ -0,0 +1,44 @@ +#ifndef _WGC_SESSION_IMPL_H_ +#define _WGC_SESSION_IMPL_H_ + +#include +#include + +#include "x11_session.h" + +class X11SessionImpl : public X11Session { + public: + X11SessionImpl(); + ~X11SessionImpl() override; + + public: + void Release() override; + + int Initialize() override; + + void RegisterObserver(x11_session_observer *observer) override; + + int Start() override; + int Stop() override; + + int Pause() override; + int Resume() override; + + private: + void OnFrame(); + void OnClosed(); + + void CleanUp(); + + // void message_func(); + + private: + std::mutex lock_; + bool is_initialized_ = false; + bool is_running_ = false; + bool is_paused_ = false; + + x11_session_observer *observer_ = nullptr; +}; + +#endif \ No newline at end of file diff --git a/test/screen_capture/mac_capture.cpp b/test/screen_capture/mac_capture.cpp new file mode 100644 index 0000000..de15a33 --- /dev/null +++ b/test/screen_capture/mac_capture.cpp @@ -0,0 +1,286 @@ +#include + +#define __STDC_CONSTANT_MACROS + +#ifdef _WIN32 +// Windows +extern "C" { +#include "SDL/SDL.h" +#include "libavcodec/avcodec.h" +#include "libavdevice/avdevice.h" +#include "libavformat/avformat.h" +#include "libswscale/swscale.h" +}; +#else +// Linux... +#ifdef __cplusplus +extern "C" { +#endif +#include +#include +#include +#include +#include +#ifdef __cplusplus +}; +#endif +#endif + +// Output YUV420P +#define OUTPUT_YUV420P 0 +//'1' Use Dshow +//'0' Use GDIgrab +#define USE_DSHOW 0 + +// Refresh Event +#define SFM_REFRESH_EVENT (SDL_USEREVENT + 1) + +#define SFM_BREAK_EVENT (SDL_USEREVENT + 2) + +int thread_exit = 0; + +int sfp_refresh_thread(void *opaque) { + thread_exit = 0; + while (!thread_exit) { + SDL_Event event; + event.type = SFM_REFRESH_EVENT; + SDL_PushEvent(&event); + SDL_Delay(40); + } + thread_exit = 0; + // Break + SDL_Event event; + event.type = SFM_BREAK_EVENT; + SDL_PushEvent(&event); + + return 0; +} + +// Show AVFoundation Device +void show_avfoundation_device() { + AVFormatContext *pFormatCtx = avformat_alloc_context(); + AVDictionary *options = NULL; + av_dict_set(&options, "list_devices", "true", 0); + AVInputFormat *iformat = + (AVInputFormat *)av_find_input_format("avfoundation"); + printf("==AVFoundation Device Info===\n"); + avformat_open_input(&pFormatCtx, "", iformat, &options); + printf("=============================\n"); +} + +int main(int argc, char *argv[]) { + AVFormatContext *pFormatCtx; + int i, videoindex; + AVCodecContext *pCodecCtx; + AVCodec *pCodec; + + avformat_network_init(); + pFormatCtx = avformat_alloc_context(); + + // Open File + // char filepath[]="src01_480x272_22.h265"; + // avformat_open_input(&pFormatCtx,filepath,NULL,NULL) + + // Register Device + avdevice_register_all(); + // Windows +#ifdef _WIN32 +#if USE_DSHOW + // Use dshow + // + // Need to Install screen-capture-recorder + // screen-capture-recorder + // Website: http://sourceforge.net/projects/screencapturer/ + // + AVInputFormat *ifmt = av_find_input_format("dshow"); + if (avformat_open_input(&pFormatCtx, "video=screen-capture-recorder", ifmt, + NULL) != 0) { + printf("Couldn't open input stream.\n"); + return -1; + } +#else + // Use gdigrab + AVDictionary *options = NULL; + // Set some options + // grabbing frame rate + // av_dict_set(&options,"framerate","5",0); + // The distance from the left edge of the screen or desktop + // av_dict_set(&options,"offset_x","20",0); + // The distance from the top edge of the screen or desktop + // av_dict_set(&options,"offset_y","40",0); + // Video frame size. The default is to capture the full screen + // av_dict_set(&options,"video_size","640x480",0); + AVInputFormat *ifmt = av_find_input_format("gdigrab"); + if (avformat_open_input(&pFormatCtx, "desktop", ifmt, &options) != 0) { + printf("Couldn't open input stream.\n"); + return -1; + } + +#endif +#elif defined linux + // Linux + AVDictionary *options = NULL; + // Set some options + // grabbing frame rate + // av_dict_set(&options,"framerate","5",0); + // Make the grabbed area follow the mouse + // av_dict_set(&options,"follow_mouse","centered",0); + // Video frame size. The default is to capture the full screen + // av_dict_set(&options,"video_size","640x480",0); + AVInputFormat *ifmt = av_find_input_format("x11grab"); + // Grab at position 10,20 + if (avformat_open_input(&pFormatCtx, ":0.0+10,20", ifmt, &options) != 0) { + printf("Couldn't open input stream.\n"); + return -1; + } +#else + show_avfoundation_device(); + // Mac + AVInputFormat *ifmt = (AVInputFormat *)av_find_input_format("avfoundation"); + // Avfoundation + //[video]:[audio] + if (avformat_open_input(&pFormatCtx, "1", ifmt, NULL) != 0) { + printf("Couldn't open input stream.\n"); + return -1; + } +#endif + + if (avformat_find_stream_info(pFormatCtx, NULL) < 0) { + printf("Couldn't find stream information.\n"); + return -1; + } + videoindex = -1; + for (i = 0; i < pFormatCtx->nb_streams; i++) + if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) { + videoindex = i; + break; + } + if (videoindex == -1) { + printf("Didn't find a video stream.\n"); + return -1; + } + pCodecCtx = pFormatCtx->streams[videoindex]->codec; + pCodec = avcodec_find_decoder(pCodecCtx->codec_id); + if (pCodec == NULL) { + printf("Codec not found.\n"); + return -1; + } + if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0) { + printf("Could not open codec.\n"); + return -1; + } + AVFrame *pFrame, *pFrameYUV; + pFrame = av_frame_alloc(); + pFrameYUV = av_frame_alloc(); + // unsigned char *out_buffer=(unsigned char + // *)av_malloc(avpicture_get_size(AV_PIX_FMT_YUV420P, pCodecCtx->width, + // pCodecCtx->height)); avpicture_fill((AVPicture *)pFrameYUV, out_buffer, + // AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height); + // SDL---------------------------- + if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) { + printf("Could not initialize SDL - %s\n", SDL_GetError()); + return -1; + } + int screen_w = 640, screen_h = 360; + const SDL_VideoInfo *vi = SDL_GetVideoInfo(); + // Half of the Desktop's width and height. + screen_w = vi->current_w / 2; + screen_h = vi->current_h / 2; + SDL_Surface *screen; + screen = SDL_SetVideoMode(screen_w, screen_h, 0, 0); + + if (!screen) { + printf("SDL: could not set video mode - exiting:%s\n", SDL_GetError()); + return -1; + } + SDL_Overlay *bmp; + bmp = SDL_CreateYUVOverlay(pCodecCtx->width, pCodecCtx->height, + SDL_YV12_OVERLAY, screen); + SDL_Rect rect; + rect.x = 0; + rect.y = 0; + rect.w = screen_w; + rect.h = screen_h; + // SDL End------------------------ + int ret, got_picture; + + AVPacket *packet = (AVPacket *)av_malloc(sizeof(AVPacket)); + +#if OUTPUT_YUV420P + FILE *fp_yuv = fopen("output.yuv", "wb+"); +#endif + + struct SwsContext *img_convert_ctx; + img_convert_ctx = sws_getContext( + pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt, pCodecCtx->width, + pCodecCtx->height, AV_PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL); + //------------------------------ + SDL_Thread *video_tid = SDL_CreateThread(sfp_refresh_thread, NULL); + // + SDL_WM_SetCaption("Simplest FFmpeg Grab Desktop", NULL); + // Event Loop + SDL_Event event; + + for (;;) { + // Wait + SDL_WaitEvent(&event); + if (event.type == SFM_REFRESH_EVENT) { + //------------------------------ + if (av_read_frame(pFormatCtx, packet) >= 0) { + if (packet->stream_index == videoindex) { + ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, packet); + if (ret < 0) { + printf("Decode Error.\n"); + return -1; + } + if (got_picture) { + SDL_LockYUVOverlay(bmp); + pFrameYUV->data[0] = bmp->pixels[0]; + pFrameYUV->data[1] = bmp->pixels[2]; + pFrameYUV->data[2] = bmp->pixels[1]; + pFrameYUV->linesize[0] = bmp->pitches[0]; + pFrameYUV->linesize[1] = bmp->pitches[2]; + pFrameYUV->linesize[2] = bmp->pitches[1]; + sws_scale(img_convert_ctx, + (const unsigned char *const *)pFrame->data, + pFrame->linesize, 0, pCodecCtx->height, pFrameYUV->data, + pFrameYUV->linesize); + +#if OUTPUT_YUV420P + int y_size = pCodecCtx->width * pCodecCtx->height; + fwrite(pFrameYUV->data[0], 1, y_size, fp_yuv); // Y + fwrite(pFrameYUV->data[1], 1, y_size / 4, fp_yuv); // U + fwrite(pFrameYUV->data[2], 1, y_size / 4, fp_yuv); // V +#endif + SDL_UnlockYUVOverlay(bmp); + + SDL_DisplayYUVOverlay(bmp, &rect); + } + } + av_free_packet(packet); + } else { + // Exit Thread + thread_exit = 1; + } + } else if (event.type == SDL_QUIT) { + thread_exit = 1; + } else if (event.type == SFM_BREAK_EVENT) { + break; + } + } + + sws_freeContext(img_convert_ctx); + +#if OUTPUT_YUV420P + fclose(fp_yuv); +#endif + + SDL_Quit(); + + // av_free(out_buffer); + av_free(pFrameYUV); + avcodec_close(pCodecCtx); + avformat_close_input(&pFormatCtx); + + return 0; +} diff --git a/thirdparty/ffmpeg/xmake.lua b/thirdparty/ffmpeg/xmake.lua index 32b7e02..bf6a493 100644 --- a/thirdparty/ffmpeg/xmake.lua +++ b/thirdparty/ffmpeg/xmake.lua @@ -45,7 +45,7 @@ package("ffmpeg") add_configs("libopenh264", {description = "Enable libopenh264", default = false, type = "boolean"}) end - add_links("avfilter", "avdevice", "avformat", "avcodec", "swscale", "swresample", "avutil") + add_links("avfilter", "avdevice", "avformat", "avcodec", "swscale", "swresample", "avutil", "postproc") if is_plat("macosx") then add_frameworks("CoreFoundation", "Foundation", "CoreVideo", "CoreMedia", "AudioToolbox", "VideoToolbox", "Security") elseif is_plat("linux") then diff --git a/thirdparty/projectx b/thirdparty/projectx index 3eef1f8..f99a9be 160000 --- a/thirdparty/projectx +++ b/thirdparty/projectx @@ -1 +1 @@ -Subproject commit 3eef1f8d8490dae1b5d4e52b95ecc313e3d9931b +Subproject commit f99a9bea133d643bfa30707294a23ad2e1256368 diff --git a/xmake.lua b/xmake.lua index 06fe030..0d34a77 100644 --- a/xmake.lua +++ b/xmake.lua @@ -23,7 +23,6 @@ if is_os("windows") then elseif is_os("linux") then add_requires("ffmpeg 5.1.2", {system = false}) add_packages("ffmpeg") - add_links("SDL2") add_syslinks("pthread", "dl") add_links("SDL2") add_ldflags("-lavformat", "-lavdevice", "-lavfilter", "-lavcodec", @@ -33,8 +32,11 @@ elseif is_os("linux") then {force = true}) elseif is_os("macosx") then add_requires("ffmpeg 5.1.2", {system = false}) - add_packages("ffmpeg") - add_links("SDL2") + add_requires("brew::libxcb") + add_packages("ffmpeg", "brew::libxcb") + add_links("SDL2", "SDL2main", "postproc") + add_ldflags("-Wl,-ld_classic") + add_frameworks("OpenGL") end add_packages("spdlog", "sdl2", "imgui") @@ -55,7 +57,7 @@ target("screen_capture") add_includedirs("src/screen_capture/windows", {public = true}) elseif is_os("macosx") then add_files("src/screen_capture/macosx/*.cpp") - add_includedirs("ssrc/creen_capture/macosx", {public = true}) + add_includedirs("src/screen_capture/macosx", {public = true}) elseif is_os("linux") then add_files("src/screen_capture/linux/*.cpp") add_includedirs("src/screen_capture/linux", {public = true}) @@ -84,29 +86,39 @@ target("remote_desk") -- "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-lpthread", "-lSDL2", "-lopenh264", -- "-ldl", {force = true}) -target("audio_capture") - set_kind("binary") - add_packages("ffmpeg") - add_files("test/audio_capture/sdl2_audio_capture.cpp") - add_includedirs("test/audio_capture") - add_ldflags("-lavformat", "-lavdevice", "-lavfilter", "-lavcodec", - "-lswscale", "-lavutil", "-lswresample", - "-lasound", "-lxcb-shape", "-lxcb-xfixes", "-lsndio", "-lxcb", - "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-lpthread", "-lSDL2", "-lopenh264", - "-ldl", {force = true}) - add_links("Shlwapi", "Strmiids", "Vfw32", "Secur32", "Mfuuid") +-- target("screen_capture") +-- set_kind("binary") +-- add_packages("sdl2", "imgui", "ffmpeg", "openh264") +-- add_files("test/screen_capture/mac_capture.cpp") +-- add_ldflags("-lavformat", "-lavdevice", "-lavfilter", "-lavcodec", +-- "-lswscale", "-lavutil", "-lswresample", +-- "-lasound", "-lxcb-shape", "-lxcb-xfixes", "-lsndio", "-lxcb", +-- "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-lpthread", "-lSDL2", "-lopenh264", +-- "-ldl", {force = true}) -target("play_audio") - set_kind("binary") - add_packages("ffmpeg") - add_files("test/audio_capture/play_loopback.cpp") - add_includedirs("test/audio_capture") - add_ldflags("-lavformat", "-lavdevice", "-lavfilter", "-lavcodec", - "-lswscale", "-lavutil", "-lswresample", - "-lasound", "-lxcb-shape", "-lxcb-xfixes", "-lsndio", "-lxcb", - "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-lpthread", "-lSDL2", "-lopenh264", - "-ldl", {force = true}) - add_links("Shlwapi", "Strmiids", "Vfw32", "Secur32", "Mfuuid") +-- target("audio_capture") +-- set_kind("binary") +-- add_packages("ffmpeg") +-- add_files("test/audio_capture/sdl2_audio_capture.cpp") +-- add_includedirs("test/audio_capture") +-- add_ldflags("-lavformat", "-lavdevice", "-lavfilter", "-lavcodec", +-- "-lswscale", "-lavutil", "-lswresample", +-- "-lasound", "-lxcb-shape", "-lxcb-xfixes", "-lsndio", "-lxcb", +-- "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-lpthread", "-lSDL2", "-lopenh264", +-- "-ldl", {force = true}) +-- add_links("Shlwapi", "Strmiids", "Vfw32", "Secur32", "Mfuuid") + +-- target("play_audio") +-- set_kind("binary") +-- add_packages("ffmpeg") +-- add_files("test/audio_capture/play_loopback.cpp") +-- add_includedirs("test/audio_capture") +-- add_ldflags("-lavformat", "-lavdevice", "-lavfilter", "-lavcodec", +-- "-lswscale", "-lavutil", "-lswresample", +-- "-lasound", "-lxcb-shape", "-lxcb-xfixes", "-lsndio", "-lxcb", +-- "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-lpthread", "-lSDL2", "-lopenh264", +-- "-ldl", {force = true}) +-- add_links("Shlwapi", "Strmiids", "Vfw32", "Secur32", "Mfuuid") -- target("audio_capture") -- set_kind("binary")