Showing preview only (2,611K chars total). Download the full file or copy to clipboard to get everything.
Repository: WolfEngine/Wolf.Engine
Branch: main
Commit: cb407495a743
Files: 500
Total size: 2.4 MB
Directory structure:
gitextract_nyue42gt/
├── .dockerignore
├── .gitattributes
├── .github/
│ └── workflows/
│ ├── codeql.yml
│ └── msvc.yml
├── .gitignore
├── CHANGE_LOG.md
├── CMakeLists.txt
├── CMakePresets.json
├── CODE_OF_CONDUCT.md
├── LICENSE
├── README.md
├── TODO.md
├── coverage.bat
├── docker/
│ └── Dockerfile
├── docs/
│ ├── GCC.txt
│ ├── ProblemSolutions.txt
│ ├── git-commands.txt
│ ├── glslValidator.txt
│ ├── glslValidator_MoltenVK.txt
│ └── quic.md
├── manifest.manifest
├── wolf/
│ ├── .clang-format
│ ├── .clang-tidy
│ ├── .gitignore
│ ├── CMakeLists.txt
│ ├── DISABLE_ANALYSIS_BEGIN
│ ├── DISABLE_ANALYSIS_END
│ ├── cmake/
│ │ ├── media.cmake
│ │ ├── ml.cmake
│ │ ├── stream.cmake
│ │ ├── system.cmake
│ │ └── vcpkg.cmake
│ ├── media/
│ │ ├── ffmpeg/
│ │ │ ├── w_av_config.cpp
│ │ │ ├── w_av_config.hpp
│ │ │ ├── w_av_format.cpp
│ │ │ ├── w_av_format.hpp
│ │ │ ├── w_av_frame.cpp
│ │ │ ├── w_av_frame.hpp
│ │ │ ├── w_av_packet.cpp
│ │ │ ├── w_av_packet.hpp
│ │ │ ├── w_decoder.cpp
│ │ │ ├── w_decoder.hpp
│ │ │ ├── w_encoder.cpp
│ │ │ ├── w_encoder.hpp
│ │ │ ├── w_ffmpeg.cpp
│ │ │ ├── w_ffmpeg.hpp
│ │ │ ├── w_ffmpeg_ctx.cpp
│ │ │ └── w_ffmpeg_ctx.hpp
│ │ ├── gst/
│ │ │ ├── audio/
│ │ │ │ ├── w_audio_format.cpp
│ │ │ │ ├── w_audio_format.hpp
│ │ │ │ ├── w_audio_info.cpp
│ │ │ │ └── w_audio_info.hpp
│ │ │ ├── core/
│ │ │ │ ├── w_buffer.cpp
│ │ │ │ ├── w_buffer.hpp
│ │ │ │ ├── w_bus.cpp
│ │ │ │ ├── w_bus.hpp
│ │ │ │ ├── w_caps.cpp
│ │ │ │ ├── w_caps.hpp
│ │ │ │ ├── w_clock.cpp
│ │ │ │ ├── w_clock.hpp
│ │ │ │ ├── w_element.cpp
│ │ │ │ ├── w_element.hpp
│ │ │ │ ├── w_element_factory.cpp
│ │ │ │ ├── w_element_factory.hpp
│ │ │ │ ├── w_format.cpp
│ │ │ │ ├── w_format.hpp
│ │ │ │ ├── w_mainloop.cpp
│ │ │ │ ├── w_mainloop.hpp
│ │ │ │ ├── w_message.cpp
│ │ │ │ ├── w_message.hpp
│ │ │ │ ├── w_nonowning.cpp
│ │ │ │ ├── w_nonowning.hpp
│ │ │ │ ├── w_pad.cpp
│ │ │ │ ├── w_pad.hpp
│ │ │ │ ├── w_pipeline.cpp
│ │ │ │ ├── w_pipeline.hpp
│ │ │ │ ├── w_refptr.cpp
│ │ │ │ ├── w_refptr.hpp
│ │ │ │ ├── w_signal_handler.cpp
│ │ │ │ ├── w_signal_handler.hpp
│ │ │ │ ├── w_structure.cpp
│ │ │ │ └── w_structure.hpp
│ │ │ ├── elements/
│ │ │ │ ├── w_element_aacparse.cpp
│ │ │ │ ├── w_element_aacparse.hpp
│ │ │ │ ├── w_element_appsrc.cpp
│ │ │ │ ├── w_element_appsrc.hpp
│ │ │ │ ├── w_element_audioconvert.cpp
│ │ │ │ ├── w_element_audioconvert.hpp
│ │ │ │ ├── w_element_audioresample.cpp
│ │ │ │ ├── w_element_audioresample.hpp
│ │ │ │ ├── w_element_autovideosink.cpp
│ │ │ │ ├── w_element_autovideosink.hpp
│ │ │ │ ├── w_element_avencflv.cpp
│ │ │ │ ├── w_element_avencflv.hpp
│ │ │ │ ├── w_element_capsfilter.cpp
│ │ │ │ ├── w_element_capsfilter.hpp
│ │ │ │ ├── w_element_filesink.cpp
│ │ │ │ ├── w_element_filesink.hpp
│ │ │ │ ├── w_element_flvmux.cpp
│ │ │ │ ├── w_element_flvmux.hpp
│ │ │ │ ├── w_element_h264parse.cpp
│ │ │ │ ├── w_element_h264parse.hpp
│ │ │ │ ├── w_element_mp4mux.cpp
│ │ │ │ ├── w_element_mp4mux.hpp
│ │ │ │ ├── w_element_openh264enc.cpp
│ │ │ │ ├── w_element_openh264enc.hpp
│ │ │ │ ├── w_element_queue.cpp
│ │ │ │ ├── w_element_queue.hpp
│ │ │ │ ├── w_element_rtmpsink.cpp
│ │ │ │ ├── w_element_rtmpsink.hpp
│ │ │ │ ├── w_element_rtph264pay.cpp
│ │ │ │ ├── w_element_rtph264pay.hpp
│ │ │ │ ├── w_element_udpsink.cpp
│ │ │ │ ├── w_element_udpsink.hpp
│ │ │ │ ├── w_element_videoconvert.cpp
│ │ │ │ ├── w_element_videoconvert.hpp
│ │ │ │ ├── w_element_videoscale.cpp
│ │ │ │ ├── w_element_videoscale.hpp
│ │ │ │ ├── w_element_videotestsrc.cpp
│ │ │ │ ├── w_element_videotestsrc.hpp
│ │ │ │ ├── w_element_voaacenc.cpp
│ │ │ │ ├── w_element_voaacenc.hpp
│ │ │ │ ├── w_element_wasapisrc.cpp
│ │ │ │ ├── w_element_wasapisrc.hpp
│ │ │ │ ├── w_element_x264enc.cpp
│ │ │ │ └── w_element_x264enc.hpp
│ │ │ ├── internal/
│ │ │ │ ├── w_common.cpp
│ │ │ │ ├── w_common.hpp
│ │ │ │ ├── w_utils.cpp
│ │ │ │ ├── w_utils.hpp
│ │ │ │ ├── w_wrapper.cpp
│ │ │ │ └── w_wrapper.hpp
│ │ │ ├── video/
│ │ │ │ ├── w_video_format.cpp
│ │ │ │ ├── w_video_format.hpp
│ │ │ │ ├── w_video_info.cpp
│ │ │ │ └── w_video_info.hpp
│ │ │ ├── w_application.cpp
│ │ │ ├── w_application.hpp
│ │ │ ├── w_flow.cpp
│ │ │ └── w_flow.hpp
│ │ ├── test/
│ │ │ ├── avframe.hpp
│ │ │ ├── ffmpeg.hpp
│ │ │ ├── gstreamer.hpp
│ │ │ ├── image.hpp
│ │ │ └── openal.hpp
│ │ ├── w_image.cpp
│ │ ├── w_image.hpp
│ │ ├── w_image_data.cpp
│ │ ├── w_image_data.hpp
│ │ ├── w_openal.cpp
│ │ └── w_openal.hpp
│ ├── ml/
│ │ ├── nudity_detection/
│ │ │ ├── w_nudity_detection.cpp
│ │ │ └── w_nudity_detection.hpp
│ │ ├── referee_ocr/
│ │ │ ├── salieri.h
│ │ │ ├── w_image_processor.cpp
│ │ │ ├── w_image_processor.hpp
│ │ │ ├── w_ocr_engine.cpp
│ │ │ ├── w_ocr_engine.hpp
│ │ │ ├── w_read_video_frames.cpp
│ │ │ ├── w_read_video_frames.hpp
│ │ │ ├── w_referee.cpp
│ │ │ ├── w_referee.hpp
│ │ │ ├── w_soccer.cpp
│ │ │ ├── w_soccer.hpp
│ │ │ ├── w_utilities.cpp
│ │ │ └── w_utilities.hpp
│ │ ├── test/
│ │ │ ├── common_test_asset/
│ │ │ │ ├── soccer/
│ │ │ │ │ ├── .fill_stat_map
│ │ │ │ │ ├── .initial_match_result_struct
│ │ │ │ │ ├── .replace_team_names_with_most_similar_string
│ │ │ │ │ ├── .replace_team_names_with_most_similar_string_0_9
│ │ │ │ │ ├── .set_config
│ │ │ │ │ ├── .single_image_result_extraction
│ │ │ │ │ ├── .update_match_data
│ │ │ │ │ └── replace_team_names_with_most_similar_string.txt
│ │ │ │ └── utilities/
│ │ │ │ ├── .get_env_boolean
│ │ │ │ ├── .get_env_cv_rect
│ │ │ │ ├── .get_env_float
│ │ │ │ ├── .get_env_int
│ │ │ │ ├── .get_env_string
│ │ │ │ ├── .get_nearest_string_0_5
│ │ │ │ ├── .get_nearest_string_0_9
│ │ │ │ ├── .set_env
│ │ │ │ ├── get_nearest_string.txt
│ │ │ │ └── get_value_from_json_file_by_key.json
│ │ │ ├── w_image_processor_test.hpp
│ │ │ ├── w_ocr_engine_test.hpp
│ │ │ ├── w_referee_test.hpp
│ │ │ ├── w_soccer_test.hpp
│ │ │ └── w_utilities_test.hpp
│ │ ├── w_common.cpp
│ │ └── w_common.hpp
│ ├── protos/
│ │ └── raft.proto
│ ├── stream/
│ │ ├── grpc/
│ │ │ ├── w_grpc_client.cpp
│ │ │ ├── w_grpc_client.hpp
│ │ │ ├── w_grpc_server.cpp
│ │ │ └── w_grpc_server.hpp
│ │ ├── http/
│ │ │ ├── w_http_server.cpp
│ │ │ └── w_http_server.hpp
│ │ ├── janus/
│ │ │ ├── w_janus_api_emc.cpp
│ │ │ └── w_janus_api_emc.hpp
│ │ ├── quic/
│ │ │ ├── datatypes/
│ │ │ │ ├── common_flags.hpp
│ │ │ │ ├── w_address.cpp
│ │ │ │ ├── w_address.hpp
│ │ │ │ ├── w_alpn.hpp
│ │ │ │ ├── w_credential_config.cpp
│ │ │ │ ├── w_credential_config.hpp
│ │ │ │ ├── w_new_connection_info.cpp
│ │ │ │ ├── w_new_connection_info.hpp
│ │ │ │ ├── w_registration_config.cpp
│ │ │ │ ├── w_registration_config.hpp
│ │ │ │ ├── w_settings.cpp
│ │ │ │ ├── w_settings.hpp
│ │ │ │ ├── w_status.cpp
│ │ │ │ └── w_status.hpp
│ │ │ ├── events/
│ │ │ │ ├── w_connection_event.cpp
│ │ │ │ ├── w_connection_event.hpp
│ │ │ │ ├── w_listener_event.cpp
│ │ │ │ ├── w_listener_event.hpp
│ │ │ │ ├── w_stream_event.cpp
│ │ │ │ └── w_stream_event.hpp
│ │ │ ├── handles/
│ │ │ │ ├── w_configuration.cpp
│ │ │ │ ├── w_configuration.hpp
│ │ │ │ ├── w_connection.cpp
│ │ │ │ ├── w_connection.hpp
│ │ │ │ ├── w_listener.cpp
│ │ │ │ ├── w_listener.hpp
│ │ │ │ ├── w_registration.cpp
│ │ │ │ ├── w_registration.hpp
│ │ │ │ ├── w_stream.cpp
│ │ │ │ └── w_stream.hpp
│ │ │ ├── internal/
│ │ │ │ ├── common.cpp
│ │ │ │ ├── common.hpp
│ │ │ │ ├── w_msquic_api.cpp
│ │ │ │ └── w_msquic_api.hpp
│ │ │ ├── w_quic.cpp
│ │ │ ├── w_quic.hpp
│ │ │ ├── w_quic_client.cpp
│ │ │ ├── w_quic_client.hpp
│ │ │ ├── w_quic_server.cpp
│ │ │ └── w_quic_server.hpp
│ │ ├── rist/
│ │ │ ├── w_rist.cpp
│ │ │ ├── w_rist.hpp
│ │ │ ├── w_rist_data_block.cpp
│ │ │ └── w_rist_data_block.hpp
│ │ └── test/
│ │ ├── ffmpeg_stream.hpp
│ │ ├── grpc.hpp
│ │ ├── quic.hpp
│ │ └── rist.hpp
│ ├── system/
│ │ ├── compression/
│ │ │ ├── w_lz4.cpp
│ │ │ ├── w_lz4.hpp
│ │ │ ├── w_lzma.cpp
│ │ │ └── w_lzma.hpp
│ │ ├── db/
│ │ │ ├── w_postgresql.cpp
│ │ │ └── w_postgresql.hpp
│ │ ├── gamepad/
│ │ │ ├── w_gamepad_client.hpp
│ │ │ ├── w_gamepad_client_emc.cpp
│ │ │ ├── w_gamepad_client_keymap.hpp
│ │ │ ├── w_gamepad_client_sdl.cpp
│ │ │ ├── w_gamepad_client_types.hpp
│ │ │ ├── w_gamepad_virtual.cpp
│ │ │ ├── w_gamepad_virtual.hpp
│ │ │ ├── w_gamepad_virtual_bus.hpp
│ │ │ ├── w_gamepad_virtual_pool.cpp
│ │ │ └── w_gamepad_virtual_pool.hpp
│ │ ├── getopt.h
│ │ ├── invocable.h
│ │ ├── log/
│ │ │ ├── w_log.cpp
│ │ │ ├── w_log.hpp
│ │ │ └── w_log_config.hpp
│ │ ├── script/
│ │ │ ├── w_lua.cpp
│ │ │ ├── w_lua.hpp
│ │ │ ├── w_python.cpp
│ │ │ └── w_python.hpp
│ │ ├── socket/
│ │ │ ├── w_socket_options.hpp
│ │ │ ├── w_tcp_client.cpp
│ │ │ ├── w_tcp_client.hpp
│ │ │ ├── w_tcp_server.cpp
│ │ │ ├── w_tcp_server.hpp
│ │ │ ├── w_ws_client.cpp
│ │ │ ├── w_ws_client.hpp
│ │ │ ├── w_ws_client_emc.cpp
│ │ │ ├── w_ws_client_emc.hpp
│ │ │ ├── w_ws_server.cpp
│ │ │ └── w_ws_server.hpp
│ │ ├── test/
│ │ │ ├── compress.hpp
│ │ │ ├── coroutine.hpp
│ │ │ ├── gamepad.hpp
│ │ │ ├── gametime.hpp
│ │ │ ├── index.html
│ │ │ ├── log.hpp
│ │ │ ├── lua.hpp
│ │ │ ├── postgresql.hpp
│ │ │ ├── process.hpp
│ │ │ ├── python.hpp
│ │ │ ├── signal_slot.hpp
│ │ │ ├── tcp.hpp
│ │ │ ├── trace.hpp
│ │ │ ├── ws.hpp
│ │ │ └── ws_server.sh
│ │ ├── w_flags.hpp
│ │ ├── w_gametime.cpp
│ │ ├── w_gametime.hpp
│ │ ├── w_leak_detector.cpp
│ │ ├── w_leak_detector.hpp
│ │ ├── w_overloaded.hpp
│ │ ├── w_process.cpp
│ │ ├── w_process.hpp
│ │ ├── w_time.cpp
│ │ ├── w_time.hpp
│ │ └── w_trace.hpp
│ ├── tests.cpp
│ ├── third_party/
│ │ ├── ffmpeg/
│ │ │ ├── LICENSE
│ │ │ ├── README.txt
│ │ │ ├── include/
│ │ │ │ ├── libavcodec/
│ │ │ │ │ ├── ac3_parser.h
│ │ │ │ │ ├── adts_parser.h
│ │ │ │ │ ├── avcodec.h
│ │ │ │ │ ├── avdct.h
│ │ │ │ │ ├── avfft.h
│ │ │ │ │ ├── bsf.h
│ │ │ │ │ ├── codec.h
│ │ │ │ │ ├── codec_desc.h
│ │ │ │ │ ├── codec_id.h
│ │ │ │ │ ├── codec_par.h
│ │ │ │ │ ├── d3d11va.h
│ │ │ │ │ ├── defs.h
│ │ │ │ │ ├── dirac.h
│ │ │ │ │ ├── dv_profile.h
│ │ │ │ │ ├── dxva2.h
│ │ │ │ │ ├── jni.h
│ │ │ │ │ ├── mediacodec.h
│ │ │ │ │ ├── packet.h
│ │ │ │ │ ├── qsv.h
│ │ │ │ │ ├── vdpau.h
│ │ │ │ │ ├── version.h
│ │ │ │ │ ├── version_major.h
│ │ │ │ │ ├── videotoolbox.h
│ │ │ │ │ ├── vorbis_parser.h
│ │ │ │ │ └── xvmc.h
│ │ │ │ ├── libavdevice/
│ │ │ │ │ ├── avdevice.h
│ │ │ │ │ ├── version.h
│ │ │ │ │ └── version_major.h
│ │ │ │ ├── libavfilter/
│ │ │ │ │ ├── avfilter.h
│ │ │ │ │ ├── buffersink.h
│ │ │ │ │ ├── buffersrc.h
│ │ │ │ │ ├── version.h
│ │ │ │ │ └── version_major.h
│ │ │ │ ├── libavformat/
│ │ │ │ │ ├── avformat.h
│ │ │ │ │ ├── avio.h
│ │ │ │ │ ├── version.h
│ │ │ │ │ └── version_major.h
│ │ │ │ ├── libavutil/
│ │ │ │ │ ├── adler32.h
│ │ │ │ │ ├── aes.h
│ │ │ │ │ ├── aes_ctr.h
│ │ │ │ │ ├── attributes.h
│ │ │ │ │ ├── audio_fifo.h
│ │ │ │ │ ├── avassert.h
│ │ │ │ │ ├── avconfig.h
│ │ │ │ │ ├── avstring.h
│ │ │ │ │ ├── avutil.h
│ │ │ │ │ ├── base64.h
│ │ │ │ │ ├── blowfish.h
│ │ │ │ │ ├── bprint.h
│ │ │ │ │ ├── bswap.h
│ │ │ │ │ ├── buffer.h
│ │ │ │ │ ├── camellia.h
│ │ │ │ │ ├── cast5.h
│ │ │ │ │ ├── channel_layout.h
│ │ │ │ │ ├── common.h
│ │ │ │ │ ├── cpu.h
│ │ │ │ │ ├── crc.h
│ │ │ │ │ ├── csp.h
│ │ │ │ │ ├── des.h
│ │ │ │ │ ├── detection_bbox.h
│ │ │ │ │ ├── dict.h
│ │ │ │ │ ├── display.h
│ │ │ │ │ ├── dovi_meta.h
│ │ │ │ │ ├── downmix_info.h
│ │ │ │ │ ├── encryption_info.h
│ │ │ │ │ ├── error.h
│ │ │ │ │ ├── eval.h
│ │ │ │ │ ├── ffversion.h
│ │ │ │ │ ├── fifo.h
│ │ │ │ │ ├── file.h
│ │ │ │ │ ├── film_grain_params.h
│ │ │ │ │ ├── frame.h
│ │ │ │ │ ├── hash.h
│ │ │ │ │ ├── hdr_dynamic_metadata.h
│ │ │ │ │ ├── hdr_dynamic_vivid_metadata.h
│ │ │ │ │ ├── hmac.h
│ │ │ │ │ ├── hwcontext.h
│ │ │ │ │ ├── hwcontext_cuda.h
│ │ │ │ │ ├── hwcontext_d3d11va.h
│ │ │ │ │ ├── hwcontext_drm.h
│ │ │ │ │ ├── hwcontext_dxva2.h
│ │ │ │ │ ├── hwcontext_mediacodec.h
│ │ │ │ │ ├── hwcontext_opencl.h
│ │ │ │ │ ├── hwcontext_qsv.h
│ │ │ │ │ ├── hwcontext_vaapi.h
│ │ │ │ │ ├── hwcontext_vdpau.h
│ │ │ │ │ ├── hwcontext_videotoolbox.h
│ │ │ │ │ ├── hwcontext_vulkan.h
│ │ │ │ │ ├── imgutils.h
│ │ │ │ │ ├── intfloat.h
│ │ │ │ │ ├── intreadwrite.h
│ │ │ │ │ ├── lfg.h
│ │ │ │ │ ├── log.h
│ │ │ │ │ ├── lzo.h
│ │ │ │ │ ├── macros.h
│ │ │ │ │ ├── mastering_display_metadata.h
│ │ │ │ │ ├── mathematics.h
│ │ │ │ │ ├── md5.h
│ │ │ │ │ ├── mem.h
│ │ │ │ │ ├── motion_vector.h
│ │ │ │ │ ├── murmur3.h
│ │ │ │ │ ├── opt.h
│ │ │ │ │ ├── parseutils.h
│ │ │ │ │ ├── pixdesc.h
│ │ │ │ │ ├── pixelutils.h
│ │ │ │ │ ├── pixfmt.h
│ │ │ │ │ ├── random_seed.h
│ │ │ │ │ ├── rational.h
│ │ │ │ │ ├── rc4.h
│ │ │ │ │ ├── replaygain.h
│ │ │ │ │ ├── ripemd.h
│ │ │ │ │ ├── samplefmt.h
│ │ │ │ │ ├── sha.h
│ │ │ │ │ ├── sha512.h
│ │ │ │ │ ├── spherical.h
│ │ │ │ │ ├── stereo3d.h
│ │ │ │ │ ├── tea.h
│ │ │ │ │ ├── threadmessage.h
│ │ │ │ │ ├── time.h
│ │ │ │ │ ├── timecode.h
│ │ │ │ │ ├── timestamp.h
│ │ │ │ │ ├── tree.h
│ │ │ │ │ ├── twofish.h
│ │ │ │ │ ├── tx.h
│ │ │ │ │ ├── uuid.h
│ │ │ │ │ ├── version.h
│ │ │ │ │ ├── video_enc_params.h
│ │ │ │ │ └── xtea.h
│ │ │ │ ├── libpostproc/
│ │ │ │ │ ├── postprocess.h
│ │ │ │ │ ├── version.h
│ │ │ │ │ └── version_major.h
│ │ │ │ ├── libswresample/
│ │ │ │ │ ├── swresample.h
│ │ │ │ │ ├── version.h
│ │ │ │ │ └── version_major.h
│ │ │ │ └── libswscale/
│ │ │ │ ├── swscale.h
│ │ │ │ ├── version.h
│ │ │ │ └── version_major.h
│ │ │ ├── lib/
│ │ │ │ └── win/
│ │ │ │ ├── avcodec-59.def
│ │ │ │ ├── avcodec.lib
│ │ │ │ ├── avdevice-59.def
│ │ │ │ ├── avdevice.lib
│ │ │ │ ├── avfilter-8.def
│ │ │ │ ├── avfilter.lib
│ │ │ │ ├── avformat-59.def
│ │ │ │ ├── avformat.lib
│ │ │ │ ├── avutil-57.def
│ │ │ │ ├── avutil.lib
│ │ │ │ ├── postproc-56.def
│ │ │ │ ├── postproc.lib
│ │ │ │ ├── swresample-4.def
│ │ │ │ ├── swresample.lib
│ │ │ │ ├── swscale-6.def
│ │ │ │ └── swscale.lib
│ │ │ └── presets/
│ │ │ ├── libvpx-1080p.ffpreset
│ │ │ ├── libvpx-1080p50_60.ffpreset
│ │ │ ├── libvpx-360p.ffpreset
│ │ │ ├── libvpx-720p.ffpreset
│ │ │ └── libvpx-720p50_60.ffpreset
│ │ └── shells/
│ │ ├── ffmpeg/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── FFMPEG/
│ │ │ │ ├── CMakeLists-FFMPEG.txt.in
│ │ │ │ └── CMakeLists.txt
│ │ │ └── third_party/
│ │ │ ├── dav1d/
│ │ │ │ ├── CMakeLists-dav1d.txt.in
│ │ │ │ └── CMakeLists.txt
│ │ │ ├── svt-av1/
│ │ │ │ ├── CMakeLists-svtav1.txt.in
│ │ │ │ └── CMakeLists.txt
│ │ │ └── vpx/
│ │ │ ├── CMakeLists-vpx.txt.in
│ │ │ └── CMakeLists.txt
│ │ ├── janus/
│ │ │ └── setup.sh
│ │ ├── librist/
│ │ │ ├── android-arm.ini
│ │ │ ├── android-armv8.ini
│ │ │ ├── librist-android.sh
│ │ │ ├── librist.bat
│ │ │ └── librist.sh
│ │ └── webRTC/
│ │ ├── webRTC.bat
│ │ └── webRTC.sh
│ ├── wolf.cpp
│ ├── wolf.hpp
│ └── wolf.ruleset
└── wolf_demo/
└── wasm/
├── build.sh
├── run.sh
├── ssl_server.py
├── wolf.cpp
└── www/
├── index.html
├── janus.js
├── janus_env.js
├── wolf.js
└── wolf.wasm
================================================
FILE CONTENTS
================================================
================================================
FILE: .dockerignore
================================================
build
================================================
FILE: .gitattributes
================================================
#sources
*.c text
*.cc text
*.cxx text
*.cpp text
*.c++ text
*.hpp text
*.h text
*.h++ text
*.hh text
# Compiled Object files
*.slo binary
*.lo binary
*.o binary
*.obj binary
# Precompiled Headers
*.gch binary
*.pch binary
# Compiled Dynamic libraries
*.so binary
*.dylib binary
*.dll binary
# Compiled Static libraries
*.lai binary
*.la binary
*.a binary
*.lib binary
# Executables
*.exe binary
*.out binary
*.app binary
================================================
FILE: .github/workflows/codeql.yml
================================================
# For most projects, this workflow file will not need changing; you simply need
# to commit it to your repository.
#
# You may wish to alter this file to override the set of languages analyzed,
# or to provide custom queries or build logic.
#
# ******** NOTE ********
# We have attempted to detect the languages in your repository. Please check
# the `language` matrix defined below to confirm you have the correct set of
# supported CodeQL languages.
#
name: "CodeQL Analysis"
on:
push:
branches: [ "main" ]
pull_request:
# The branches below must be a subset of the branches above
branches: [ "main" ]
schedule:
- cron: '40 9 * * 0'
env:
# Path to the CMake build directory.
build: '${{ github.workspace }}/build'
jobs:
analyze:
name: Analyze
runs-on: ubuntu-latest
permissions:
actions: read
contents: read
security-events: write
strategy:
fail-fast: false
matrix:
language: [ 'cpp' ]
# CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
# Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
steps:
- name: Checkout repository
uses: actions/checkout@v3
- name: Setup VCPKG
uses: friendlyanon/setup-vcpkg@v1
with: { committish: 63aa65e65b9d2c08772ea15d25fb8fdb0d32e557 }
- name: Initialize CodeQL
uses: github/codeql-action/init@v2
with:
languages: ${{ matrix.language }}
# If you wish to specify custom queries, you can do so here or in a config file.
# By default, queries listed here will override any specified in a config file.
# Prefix the list here with "+" to use these queries and those in the config file.
# Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
# queries: security-extended,security-and-quality
# Autobuild attempts to build any compiled languages (C/C++, C#, Go, or Java).
# If this step fails, then you should remove it and run the build manually (see below)
#- name: Autobuild
#uses: github/codeql-action/autobuild@v2
- name: Configure CMake
run: cmake -B ${{ env.build }} --preset linux-x64-release
# Build is not required for MSVC Code Analysis and will be used for Codecov
- name: Build CMake
run: cmake --build ${{ env.build }} --preset linux-x64-release
# ℹ️ Command-line programs to run using the OS shell.
# 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
# If the Autobuild fails above, remove it and uncomment the following three lines.
# modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
# - run: |
# echo "Run, Build Application using script"
# ./location_of_script_within_repo/buildscript.sh
- name: Perform CodeQL Analysis
uses: github/codeql-action/analyze@v2
with:
category: "/language:${{matrix.language}}"
================================================
FILE: .github/workflows/msvc.yml
================================================
# This workflow uses actions that are not certified by GitHub.
# They are provided by a third-party and are governed by
# separate terms of service, privacy policy, and support
# documentation.
#
# Find more information at:
# https://github.com/microsoft/msvc-code-analysis-action
name: Microsoft C++ Code Analysis
on:
push:
branches: ["main"]
pull_request:
branches: ["main"]
schedule:
- cron: "41 16 * * 1"
env:
# Path to the CMake build directory.
build: "${{ github.workspace }}/build"
permissions:
contents: read
jobs:
analyze:
permissions:
contents: read # for actions/checkout to fetch code
security-events: write # for github/codeql-action/upload-sarif to upload SARIF results
actions: read # only required for a private repository by github/codeql-action/upload-sarif to get the Action run status
name: Analyze
runs-on: windows-latest
steps:
- name: Checkout repository
uses: actions/checkout@v3
- name: Setup VCPKG
uses: friendlyanon/setup-vcpkg@v1
with: { committish: 63aa65e65b9d2c08772ea15d25fb8fdb0d32e557 }
- name: Get SW
uses: egorpugin/sw-action@master
- name: SW setup and add to PATH
run: |
./sw setup
echo "D:\a\WolfEngine\WolfEngine" >> $env:GITHUB_PATH
- name: Setup OpenCppCoverage and add to PATh
id: setup_opencppcoverage
run: |
choco install OpenCppCoverage -y
echo "C:\Program Files\OpenCppCoverage" >> $env:GITHUB_PATH
- name: Configure CMake
run: cmake -DCMAKE_BUILD_TYPE=Debug -B ${{ env.build }}
# Build is not required for MSVC Code Analysis and will be used for Codecov
- name: Build CMake
run: cmake --build ${{ env.build }}
- name: Run MSVC Code Analysis
uses: microsoft/msvc-code-analysis-action@04825f6d9e00f87422d6bf04e1a38b1f3ed60d99
# Provide a unique ID to access the sarif output path
id: run-analysis
with:
cmakeBuildDirectory: ${{ env.build }}
# Ruleset file that will determine what checks will be run
ruleset: NativeRecommendedRules.ruleset
ignoredTargetPaths: ${{ env.build }}/_deps/boost_chrono-src;${{ env.build }}/_deps/boost_context-src;${{ env.build }}/_deps/boost_coroutine-src;${{ env.build }}/_deps/boost_date_time-src;${{ env.build }}/_deps/boost_exception-src;${{ env.build }}/_deps/fmt-src;${{ env.build }}/_deps/boost_container-src;${{ env.build }}/_deps/opencv-src;${{ env.build }}/_deps/rapidjson-src;${{ env.build }}/_deps/tesseract-src
- name: Generate Codecov Report
id: generate_test_report
shell: cmd
run: OpenCppCoverage.exe --continue_after_cpp_exception --export_type cobertura:WolfCov.xml --sources %CD% --excluded_sources %CD%\build\_deps -- %CD%\build\wolf\Debug\wolf_tests.exe
- name: Upload Report to Codecov
uses: codecov/codecov-action@v2
with:
files: ./WolfCov.xml
fail_ci_if_error: true
functionalities: fix
# Upload SARIF file to GitHub Code Scanning Alerts
#- name: Upload SARIF to GitHub
# uses: github/codeql-action/upload-sarif@v2
# with:
# sarif_file: ${{ steps.run-analysis.outputs.sarif }}
# Upload SARIF file as an Artifact to download and view
- name: Upload SARIF as an Artifact
uses: actions/upload-artifact@v3
with:
name: sarif-file
path: ${{ steps.run-analysis.outputs.sarif }}
================================================
FILE: .gitignore
================================================
*.log
*.tlog
*.wLog
*.idb
*.pdb
*.ipch
*.ilk
*.recipe
*.res
*.enc
*.vscode
*.advixeproj
*.advixeexp
*.dflgadvixe
*.infoadvixe
*.DS_Store
*.db
*.db-shm
*.db-wal
*.opendb
*.DS_Store
*.pem
/bin/*
/build/*
/coverage/*
/install/*
# Compiled Object files
*.slo
*.lo
*.o
*.obj
# Precompiled Headers
*.gch
*.pch
# Fortran module files
*.mod
# Executables
*.exe
*.out
*.app
================================================
FILE: CHANGE_LOG.md
================================================
# ToDos
- Dynamic lod creator for lod sample
- Forward+
- DirectX 12
- Realtime Raytracing
- DEBUG, RELEASE, MinSizeRelease(does not have assimp and just use wscene files)
# 2.1
A major release, rewrite most of wolf.system with pure C
- fixed some bugs
- improved memory pool
- executing python from c has been added
# 2.0.0.0
A major release, rewrite most of wolf.system with pure C
- Build for Win64
- Build for OSX
- Build for iOS
- Build for Android-armv7
- Build for Linux64
# 1.68.0.9 (2018-10-03)
A minor release with many compatibility-breaking changes.
New features:
- CMAKE added for building wolf for linux platform
# 1.65.0.0 (2018-06-04)
A minor release with many compatibility-breaking changes.
New features:
- system::w_logger optimized and integrated with spdlog
- framework::w_media_core optimized for streaming
- gpu occlusion culling has been added
# 1.63.1.0 (2018-04-19)
A minor release with many compatibility-breaking changes.
New features:
- Integrated with Vulkan SDK version 1.1.73.0
- Integrated with VulkanMemoryAllocator for better gpu memory managment
- The new coordinate system is Left handed Y-Up
- The function "contains" have been added to wolf::system::w_bounding_sphere
================================================
FILE: CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.22)
# set the name of the projects
project(wolf)
add_subdirectory(wolf)
================================================
FILE: CMakePresets.json
================================================
{
"version": 3,
"cmakeMinimumRequired": {
"major": 3,
"minor": 20
},
"configurePresets": [
{
"name": "base",
"hidden": true,
"description": "base project for other configurations.",
"binaryDir": "${sourceDir}/build/${presetName}",
"installDir": "${sourceDir}/install/${presetName}",
"generator": "Ninja",
"cacheVariables": {
"CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
"ARCH": "win64"
}
},
{
"name": "wasm32-unknown-emscripten-debug",
"displayName": "wasm32-unknown-emscripten",
"description": "Configure debug mode based on Emscripten",
"inherits": "base",
"cacheVariables": {
"CMAKE_TOOLCHAIN_FILE": "$env{EMSDK}/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake",
"CMAKE_BUILD_TYPE": "Debug"
}
},
{
"name": "wasm32-unknown-emscripten-release",
"displayName": "Win x64 Release",
"description": "Configure release mode based on Emscripten",
"inherits": "wasm32-unknown-emscripten-debug",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Release"
}
},
{
"name": "win-x64-debug",
"displayName": "Win x64 Debug",
"description": "Sets windows platform and debug build type for x64 arch",
"inherits": "base",
"architecture": {
"value": "x64",
"strategy": "external"
},
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug"
},
"condition": {
"type": "equals",
"lhs": "${hostSystemName}",
"rhs": "Windows"
}
},
{
"name": "win-x64-release",
"displayName": "Win x64 Release",
"description": "Sets windows platform and release build type for x64 arch",
"inherits": "win-x64-debug",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Release"
}
},
{
"name": "base-android",
"hidden": true,
"inherits": "base",
"environment": {
"ANDROID_NDK_HOME": "$env{NDK}",
"ANDROID_NDK": "$env{NDK}",
"ANDROID_NATIVE_API_LEVEL": "24",
"ANDROID_PLATFORM": "android-24"
},
"cacheVariables": {
"ANDROID": true,
"CMAKE_TOOLCHAIN_FILE": "$env{ANDROID_NDK_HOME}/build/cmake/android.toolchain.cmake",
"ANDROID_STL": "c++_shared",
"ANDROID_ABI": "arm64-v8a",
"CPU": "armv8",
"CMAKE_ANDROID_ARCH_ABI": "arm64-v8a",
"CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
"CMAKE_SYSTEM_NAME": "Android"
}
},
{
"name": "android-arm64-debug",
"inherits": "base-android",
"displayName": "Android ARM64 v8a Debug",
"description": "Sets android platform and debug build type for arm64-v8a arch",
"architecture": {
"value": "arm64-v8a",
"strategy": "external"
},
"environment": {
"ANDROID_ABI": "arm64-v8a",
"CPU": "armv8",
"ARCH": "aarch64",
"CMAKE_ANDROID_ARCH_ABI": "arm64-v8a",
"CMAKE_BUILD_TYPE": "Debug"
},
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug"
}
},
{
"name": "android-arm64-release",
"displayName": "Android ARM64 v8a Release",
"description": "Sets android platform and release build type for arm64-v8a arch",
"inherits": "android-arm64-debug",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Release"
},
"environment": {
"CMAKE_BUILD_TYPE": "Release"
}
},
{
"name": "android-arm-debug",
"inherits": "base-android",
"displayName": "Android ARM eabi v7a Debug",
"description": "Sets android platform and debug build type for armeabi-v7a arch",
"architecture": {
"value": "armeabi-v7a",
"strategy": "external"
},
"environment": {
"ANDROID_ABI": "armeabi-v7a",
"CPU": "arm",
"ARCH": "arm",
"CMAKE_ANDROID_ARCH_ABI": "armeabi-v7a",
"CMAKE_BUILD_TYPE": "Debug"
},
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug",
"ANDROID_ABI": "armeabi-v7a",
"CMAKE_ANDROID_ARCH_ABI": "armeabi-v7a",
"ARCH": "arm",
"CPU": "arm"
}
},
{
"name": "android-arm-release",
"displayName": "Android ARM eabi v7a Release",
"description": "Sets android platform and release build type for armeabi-v7a arch",
"inherits": "android-arm-debug",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Release"
},
"environment": {
"CMAKE_BUILD_TYPE": "Release"
}
},
{
"name": "linux-x64-debug",
"displayName": "GCC x64 linux gnu debug",
"description": "Using compilers: C = /usr/bin/gcc, CXX = /usr/bin/g++",
"binaryDir": "${sourceDir}/build/${presetName}",
"cacheVariables": {
"CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install/${presetName}",
"CMAKE_C_COMPILER": "gcc",
"CMAKE_CXX_COMPILER": "g++",
"CMAKE_BUILD_TYPE": "Debug"
}
},
{
"name": "linux-x64-release",
"displayName": "GCC x64 linux gnu release",
"inherits": "linux-x64-debug",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Release"
}
}
],
"buildPresets": [
{
"name": "wasm32-unknown-emscripten-debug",
"displayName": "wasm32-unknown-emscripten-debug",
"description": "Build WebAssembly with Emscripten",
"configurePreset": "wasm32-unknown-emscripten-debug"
},
{
"name": "wasm32-unknown-emscripten-release",
"displayName": "wasm32-unknown-emscripten-release",
"description": "Build WebAssembly with Emscripten",
"configurePreset": "wasm32-unknown-emscripten-release"
},
{
"name": "win-x64-release",
"displayName": "Win x64 Release",
"description": "Sets windows platform and debug build type for x64 arch in release mode",
"configurePreset": "win-x64-release"
},
{
"name": "win-x64-debug",
"displayName": "Win x64 Debug",
"description": "Sets windows platform and debug build type for x64 arch in debug mode",
"configurePreset": "win-x64-debug"
},
{
"name": "android-arm64-debug",
"displayName": "Android ARM64 v8a Debug",
"description": "Build Android",
"configurePreset": "android-arm64-debug"
},
{
"name": "android-arm64-release",
"displayName": "Android ARM64 v8a Release",
"description": "Build Android",
"configurePreset": "android-arm64-release"
},
{
"name": "android-arm-debug",
"displayName": "Android ARM eabi v7a Debug",
"description": "Build Android",
"configurePreset": "android-arm-debug"
},
{
"name": "android-arm-release",
"displayName": "Android ARM eabi v7a Release",
"description": "Build Android",
"configurePreset": "android-arm-release"
},
{
"name": "linux-x64-debug",
"displayName": "Sets linux platform and debug build type for x64 arch in debug mode",
"description": "linux x64 Debug",
"configurePreset": "linux-x64-debug"
},
{
"name": "linux-x64-release",
"displayName": "Sets linux platform and release build type for x64 arch in release mode",
"description": "linux x64 Release",
"configurePreset": "linux-x64-release"
},
{
"name": "wasm",
"description": "",
"displayName": "",
"configurePreset": "wasm32-unknown-emscripten-debug"
}
],
"testPresets": [
{
"name": "base-tests",
"hidden": true,
"output": {
"outputOnFailure": true
}
},
{
"name": "windows-tests",
"inherits": "base-tests",
"configurePreset": "win-x64-debug"
}
]
}
================================================
FILE: CODE_OF_CONDUCT.md
================================================
# Contributor Covenant Code of Conduct
## Our Pledge
We as members, contributors, and leaders pledge to make participation in our
community a harassment-free experience for everyone, regardless of age, body
size, visible or invisible disability, ethnicity, sex characteristics, gender
identity and expression, level of experience, education, socio-economic status,
nationality, personal appearance, race, caste, color, religion, or sexual identity
and orientation.
We pledge to act and interact in ways that contribute to an open, welcoming,
diverse, inclusive, and healthy community.
## Our Standards
Examples of behavior that contributes to a positive environment for our
community include:
* Demonstrating empathy and kindness toward other people
* Being respectful of differing opinions, viewpoints, and experiences
* Giving and gracefully accepting constructive feedback
* Accepting responsibility and apologizing to those affected by our mistakes,
and learning from the experience
* Focusing on what is best not just for us as individuals, but for the
overall community
Examples of unacceptable behavior include:
* The use of sexualized language or imagery, and sexual attention or
advances of any kind
* Trolling, insulting or derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or email
address, without their explicit permission
* Other conduct which could reasonably be considered inappropriate in a
professional setting
## Enforcement Responsibilities
Community leaders are responsible for clarifying and enforcing our standards of
acceptable behavior and will take appropriate and fair corrective action in
response to any behavior that they deem inappropriate, threatening, offensive,
or harmful.
Community leaders have the right and responsibility to remove, edit, or reject
comments, commits, code, wiki edits, issues, and other contributions that are
not aligned to this Code of Conduct, and will communicate reasons for moderation
decisions when appropriate.
## Scope
This Code of Conduct applies within all community spaces, and also applies when
an individual is officially representing the community in public spaces.
Examples of representing our community include using an official e-mail address,
posting via an official social media account, or acting as an appointed
representative at an online or offline event.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be
reported to the community leaders responsible for enforcement at
pooya{dot}eimandar{at}gmail{dot}com.
All complaints will be reviewed and investigated promptly and fairly.
All community leaders are obligated to respect the privacy and security of the
reporter of any incident.
## Enforcement Guidelines
Community leaders will follow these Community Impact Guidelines in determining
the consequences for any action they deem in violation of this Code of Conduct:
### 1. Correction
**Community Impact**: Use of inappropriate language or other behavior deemed
unprofessional or unwelcome in the community.
**Consequence**: A private, written warning from community leaders, providing
clarity around the nature of the violation and an explanation of why the
behavior was inappropriate. A public apology may be requested.
### 2. Warning
**Community Impact**: A violation through a single incident or series
of actions.
**Consequence**: A warning with consequences for continued behavior. No
interaction with the people involved, including unsolicited interaction with
those enforcing the Code of Conduct, for a specified period of time. This
includes avoiding interactions in community spaces as well as external channels
like social media. Violating these terms may lead to a temporary or
permanent ban.
### 3. Temporary Ban
**Community Impact**: A serious violation of community standards, including
sustained inappropriate behavior.
**Consequence**: A temporary ban from any sort of interaction or public
communication with the community for a specified period of time. No public or
private interaction with the people involved, including unsolicited interaction
with those enforcing the Code of Conduct, is allowed during this period.
Violating these terms may lead to a permanent ban.
### 4. Permanent Ban
**Community Impact**: Demonstrating a pattern of violation of community
standards, including sustained inappropriate behavior, harassment of an
individual, or aggression toward or disparagement of classes of individuals.
**Consequence**: A permanent ban from any sort of public interaction within
the community.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage],
version 2.1, available at
[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
Community Impact Guidelines were inspired by
[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
For answers to common questions about this code of conduct, see the FAQ at
[https://www.contributor-covenant.org/faq][FAQ]. Translations are available
at [https://www.contributor-covenant.org/translations][translations].
[homepage]: https://www.contributor-covenant.org
[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
[Mozilla CoC]: https://github.com/mozilla/diversity
[FAQ]: https://www.contributor-covenant.org/faq
[translations]: https://www.contributor-covenant.org/translations
================================================
FILE: LICENSE
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
================================================
FILE: README.md
================================================
# [Here is the Rust implementation of Wolf](https://github.com/WolfEngine/WolfEngine/tree/wolf-rs)
### Wolf Engine [](https://github.com/WolfEngine/Wolf.Engine/blob/main/LICENSE.md) [](https://codecov.io/github/WolfEngine/WolfEngine) [](https://github.com/WolfEngine/WolfEngine/actions/workflows/codeql.yml) [](https://github.com/WolfEngine/WolfEngine/actions/workflows/msvc.yml)
<img src="https://raw.githubusercontent.com/WolfEngine/WolfEngine/main/Logo.png" width="256" height="256" alt="WolfEngine"/>
<p><b>Welcome to the Wolf Engine source code.</b></p>
<p>The <b>Wolf Engine</b> is the next
generation of <a href="https://github.com/PooyaEimandar/PersianEngine">Persian Game Engine</a> which is a
cross-platform open source game engine created by <a href="https://pooyaeimandar.github.io/">Pooya Eimandar</a>.
The Wolf is a comprehensive set of C++ open source libraries for realtime rendering, realtime streaming and game developing, which is support <b>Lua</b> and <b>WASM</b> as an embedded scripting languages.</p>
# Build
- Prerequisites
- For windows, make sure install the latest Windows 11/10 SDK
- [git](https://git-scm.com/downloads)
- [CMake](https://cmake.org/download/)
- [vcpkg](https://vcpkg.io/)
- [Meson](https://github.com/mesonbuild/meson/releases)
- [Ninja](https://ninja-build.org/). Alternatively, setup [Python3](https://www.python.org/downloads/) and use "pip3 install ninja"
- [QT6](https://www.qt.io/download) for demos and examples
- [NDK](https://developer.android.com/ndk/downloads) for android.
then make sure get the main branch
`git clone https://github.com/WolfEngine/WolfEngine.git --branch main --depth 1`
## CMakePresets
To list configure presets: `cmake . --list-presets`
To list build presets: `cmake --build --list-presets`
To install wolf: `cmake --install <build-dir> --prefix <prefix>`
For example for building wolf for android:
```
cmake . --preset android-arm64-release
cmake --build --preset android-arm64-release
```
For example for building wolf for windows:
```
cmake . --preset win-x64-release
cmake --build --preset win-x64-release
cmake --install C:/WolfEngine/build/win-x64-release --prefix C:/wolf
```
## Recent Sample
<p>Dynamic LOD Generation using <a href="https://www.simplygon.com/" target="_blank">Simplygon</a></p>
<img src="https://raw.githubusercontent.com/WolfEngine/WolfEngine/wolf-2/samples/03_advances/07_lod/doc/view.gif" width="640" height="360" alt="Dynamic LOD Generation gif"/>
## Supported platforms
| Not Supported | Planned | In Progress | Done |
|:-----------:|:-----------:|:-----------:|:-----------:|
| :x: | :memo: | :construction: | :white_check_mark: |
### Supported platforms and APIs for render module
| API | Windows | Linux | macOS | iOS | Android | Wasm |
|:-----------:|:-----------:|:--------------------------:|:--------------:|:-------------:|:--------------:|:-------------:|
| GPU | Vulkan/OpenGL ES :construction: | Vulkan/OpenGL ES :memo: | MoltenVK :memo: | MoltenVK :memo: | Vulkan/OpenGL ES :memo: | WebGL/WebGPU :memo: |
### Supported platforms and APIs for media module
| API | Windows | Linux | macOS | iOS | Android | Wasm |
|:-----------:|:-----------:|:--------------------------:|:--------------:|:-------------:|:--------------:|:-------------:|
| [Bitmap](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/media/test/ffmpeg.hpp) | :white_check_mark: | :white_check_mark: | :memo: | :memo: | :memo: | :x: |
| [FFmpeg](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/stream/test/ffmpeg_stream.hpp) | :white_check_mark: | :white_check_mark: | :memo: | :memo: | :memo: | :x: |
| [JPEG](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/media/test/ffmpeg.hpp) | :white_check_mark: | :white_check_mark: | :memo: | :memo: | :memo: | :x: |
| [OpenAL](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/media/test/openal.hpp) | :white_check_mark: | :white_check_mark: | :memo: | :memo: | :memo: | :x: |
| [PNG](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/media/test/ffmpeg.hpp) | :white_check_mark: | :white_check_mark: | :memo: | :memo: | :memo: | :x: |
| WebP | :memo: | :memo: | :memo: | :memo: | :memo: | :x: |
### Supported platforms and APIs for stream module
| API | Windows | Linux | macOS | iOS | Android | Wasm |
|:-----------:|:-----------:|:--------------------------:|:--------------:|:-------------:|:--------------:|:-------------:|
| gRPC | :memo: | :x: | :x: | :x: | :x: | :x: |
| [Janus](https://github.com/WolfEngine/WolfEngine/tree/main/wolf_demo/wasm) | :construction: | :x: | :x: | :x: | :x: | :white_check_mark: |
| [QUIC](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/stream/test/quic.hpp) | :white_check_mark: | :memo: | :memo: | :memo: | :memo: | :x: |
| [RIST](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/stream/test/rist.hpp) | :white_check_mark: | :memo: | :memo: | :memo: | :white_check_mark: | :x: |
| RTMP | :memo: | :x: | :x: | :x: | :x: | :x: |
| [RTSP](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/stream/test/ffmpeg_stream.hpp) | :white_check_mark: | :memo: | :memo: | :memo: | :memo: | :x: |
| [SRT](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/stream/test/ffmpeg_stream.hpp) | :white_check_mark: | :memo: | :memo: | :memo: | :memo: | :x: |
| webRTC | :memo: | :memo: | :memo: | :memo: | :memo: | :memo: |
| [WebSocket](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/system/test/ws.hpp) | :white_check_mark: | :white_check_mark: | :memo: | :memo: | :memo: | :memo: |
### Supported platforms and APIs for system module
| API | Windows | Linux | macOS | iOS | Android | Wasm |
|:-----------:|:-----------:|:--------------------------:|:--------------:|:-------------:|:--------------:|:-------------:|
| [Coroutine](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/system/test/coroutine.hpp) | :white_check_mark: | :white_check_mark: | :memo: | :x: | :x: | :x: |
| [GameTime](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/system/test/gametime.hpp) | :white_check_mark: | :white_check_mark: | :memo: | :memo: | :memo: | :white_check_mark: |
| [Gamepad](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/system/test/gamepad.hpp) | :white_check_mark: | :white_check_mark: | :memo: | :memo: | :memo: | :white_check_mark: |
| [Virtual Gamepad](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/system/test/gamepad.hpp) | :white_check_mark: | :x: | :x: | :x: | :x: | :x: |
| [Log](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/system/test/log.hpp) | :white_check_mark: | :white_check_mark: | :construction: | :construction: | :construction: | :construction: |
| LuaJit | :memo: | :memo: | :memo: | :memo: | :memo: | :x: |
| [LZ4](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/system/test/compress.hpp) | :white_check_mark: | :white_check_mark: | :memo: | :memo: | :memo: | :x: |
| [LZMA](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/system/test/compress.hpp) | :white_check_mark: | :white_check_mark: | :memo: | :x: | :x: | :x: |
| OpenTelemetry | :memo: | :memo: | :memo: | :x: | :x: | :x: |
| RAFT | :memo: | :memo: | :memo: | :memo: | :memo: | :memo: |
| Screen Capture | :memo: | :construction: | :construction: | :x: | :x: | :x: |
| [Signal Slot](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/system/test/signal_slot.hpp) | :white_check_mark: | :white_check_mark: | :construction: | :x: | :x: | :x: |
| [Stacktrace](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/tests.cpp) | :white_check_mark: | :white_check_mark: | :construction: | :construction: | :construction: | :x: |
| Sycl | :memo: | :memo: | :memo: | :x: | :x: | :x: |
| [TCP](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/system/test/tcp.hpp) | :white_check_mark: | :white_check_mark: | :memo: | :memo: | :memo: | :x: |
| [Trace](https://github.com/WolfEngine/WolfEngine/blob/main/wolf/system/test/trace.hpp) | :white_check_mark: | :white_check_mark: | :memo: | :memo: | :memo: | :x: |
| UDP | :construction: | :memo: | :memo: | :memo: | :memo: | :x: |
| Wasm3 | :memo: | :memo: | :memo: | :memo: | :memo: | :memo: |
## Projects using Wolf</h2>
* [Wolf.Playout](https://www.youtube.com/watch?v=EZSdEjBvuGY), a playout automation software
* [Falcon](https://youtu.be/ygpz35ddZ_4), a real time 3D monitoring system
* [PlayPod](https://playpod.ir), the first cloud gaming platform launched in Middle East
* [RivalArium](https://rivalarium.com), play and rival other users via our leagues and duels from any device, any location and let your skills generate income
## [Youtube](https://www.youtube.com/c/WolfEngine)
## [Twitter](https://www.twitter.com/Wolf_Engine)
Wolf Engine © 2014-2023 [Pooya Eimandar](https://www.linkedin.com/in/pooyaeimandar/)
================================================
FILE: TODO.md
================================================
- support android
- support windows
- support linux
- support osx
- support ios
================================================
FILE: coverage.bat
================================================
OpenCppCoverage.exe --continue_after_cpp_exception --export_type=html:%CD%\coverage\ --sources %CD% --excluded_sources %CD%\build\_deps -- %CD%\build\wolf\Debug\wolf_tests.exe
================================================
FILE: docker/Dockerfile
================================================
ARG UBUNTU_VERSION="22.04"
FROM ubuntu:${UBUNTU_VERSION}
ENV VCPKG_ROOT=/opt/vcpkg
ARG VCPKG_GITHUB_REPOSITORY=https://github.com/microsoft/vcpkg/archive/master.tar.gz
ARG VCPKG_COMPRESSED_FILE_NAME=vcpkg.tar.gz
RUN set -eux \
&& export DEBIAN_FRONTEND="noninteractive" \
&& apt-get update \
&& apt-get install --yes --no-install-recommends \
build-essential \
ca-certificates \
cmake \
cpp \
curl \
git \
make \ls
pkg-config \
tar \
unzip \
wget \
zip
WORKDIR ${VCPKG_ROOT}
RUN wget -qO ${VCPKG_COMPRESSED_FILE_NAME} ${VCPKG_GITHUB_REPOSITORY} \
&& tar xf ${VCPKG_COMPRESSED_FILE_NAME} --strip-components=1 \
&& rm ${VCPKG_COMPRESSED_FILE_NAME} \
&& /opt/vcpkg/bootstrap-vcpkg.sh \
&& ln -s /opt/vcpkg/vcpkg /usr/local/bin/vcpkg
WORKDIR /workspace
COPY . .
RUN cmake -B build --preset linux-x64-release
RUN rm -rf ./*
================================================
FILE: docs/GCC.txt
================================================
cd /home/build
GCC_VERSION=10.2.0
wget https://ftp.gnu.org/gnu/gcc/gcc-${GCC_VERSION}/gcc-${GCC_VERSION}.tar.gz
tar xzvf gcc-${GCC_VERSION}.tar.gz
mkdir obj.gcc-${GCC_VERSION}
cd gcc-${GCC_VERSION}
./contrib/download_prerequisites
cd ../obj.gcc-${GCC_VERSION}
#RedHat base
sudo yum groupinstall "Development Tools"
#Debian
sudo apt-get install build-essential
../gcc-${GCC_VERSION}/configure --disable-multilib --enable-languages=c,c++
make -j $(nproc)
make install
================================================
FILE: docs/ProblemSolutions.txt
================================================
------------------------------------------------------- -------------------------------------------------------
-------------------- Problem ----------------------- -------------------- Solution -----------------------
------------------------------------------------------- -------------------------------------------------------
initializePlugin function could not be found in Add following command to the Liker->command Line
Maya plug-in "/export:initializePlugin /export:uninitializePlugin"
------------------------------------------------------- -------------------------------------------------------
No target architecture error at compile time use #include <windows.h> instead of #include <WinDef.h>
------------------------------------------------------- -------------------------------------------------------
Copy relative content to the execution directory $(OutDir)/%(RelativeDir)/%(filename).cso for more info
see following link
http://msdn.microsoft.com/en-us/library/ms164313.aspx
------------------------------------------------------- -------------------------------------------------------
Debug does not active, breakpoint disable Properties->Linker->debugging->GenerateDebugInfo->yes
Properties->Linker->debugging->DebuggingAssembly->yes
Properties->C/C++->Code Generation->Multi-threaded Debug DLL (/MDd)
------------------------------------------------------- -------------------------------------------------------
Could not find entry point First right click on
Solution->Properties->Configuration Manager
set the x64
Then check dllMain or main function
------------------------------------------------------- -------------------------------------------------------
error MSB6006: "icl.exe" exited with code 4 switch from intel c++ to microsoft visual c++ to check other errors,
alsoCheck precompiled headers
------------------------------------------------------- -------------------------------------------------------
error LNK2019: unresolved external symbol __imp___CrtDbgReportW Remove _DEBUG from preprocessor or somwhere in your code
referenced in function, when you add std::map or std::vector
------------------------------------------------------- -------------------------------------------------------
Can link constructor or destructor ot method of a class make sure add API(see W_Object.h) before declaration of method in class
from DLL
------------------------------------------------------- -------------------------------------------------------
eglGetPlatformDisplayEXT does not generate display device make sure copy libGLESv2.dll, libEGL.dll & d3dcompiler_47.dll in bin folder
in Angle project
------------------------------------------------------- -------------------------------------------------------
Error MSB6006 "fxc.exe" exited with code 1. check all *.hlsl codes and shader type in Properties->HLSL Compiler->General in your project
================================================
FILE: docs/git-commands.txt
================================================
//subtrees
git config commit.gpgsign false
git fetch git@github.com:g-truc/glm.git master
git subtree add --prefix=engine/dependencies/glm-master/ --squash git@github.com:g-truc/glm.git master
git subtree pull --prefix=engine/dependencies/glm-master/ --squash git@github.com:g-truc/glm.git master
git fetch git@github.com:dwd/rapidxml.git master
git subtree add --prefix=engine/dependencies/rapidxml-master/ --squash git@github.com:dwd/rapidxml.git master
git subtree pull --prefix=engine/dependencies/rapidxml-master/ --squash git@github.com:dwd/rapidxml.git master
git fetch git@github.com:miloyip/rapidjson.git master
git subtree add --prefix=engine/dependencies/rapidjson-master/ --squash git@github.com:miloyip/rapidjson.git master
git subtree pull --prefix=engine/dependencies/rapidjson-master/ --squash git@github.com:miloyip/rapidjson.git master
================================================
FILE: docs/glslValidator.txt
================================================
./glslangValidator.exe -V -t -o ~path/to/out.spv ~/path/to/in.vert
================================================
FILE: docs/glslValidator_MoltenVK.txt
================================================
cd /Users/pooyaeimandar/Documents/github/WolfSource/Wolf.Engine/engine/dependencies/vulkan/Mac/Molten/MoltenShaderConverter/Tools/
./MoltenShaderConverter -gi /Users/pooyaeimandar/Documents/github/WolfSource/Wolf.Engine/samples/02_basics/02_shader/src/content/shaders/shader.frag -t f -so /Users/pooyaeimandar/Documents/github/WolfSource/Wolf.Engine/samples/02_basics/02_shader/src/content/shaders/shader.frag.spv
./MoltenShaderConverter -gi /Users/pooyaeimandar/Documents/github/WolfSource/Wolf.Engine/samples/02_basics/02_shader/src/content/shaders/shader.vert -t v -so /Users/pooyaeimandar/Documents/github/WolfSource/Wolf.Engine/samples/02_basics/02_shader/src/content/shaders/shader.vert.spv
================================================
FILE: docs/quic.md
================================================
# Wolf QUIC
Wolf provides quic protocol as a submodule under stream module. Current implementation is mostly a C++ wrapper over msquic which is written in C, along with a few helpers to simplify and help with common usages such as client/server.
There are one to one C++ wrapper types for msquic types. including enums and flags, core data types to hold information, and handle types. public methods and member variables are also kind of one to one with similar name, sometimes with a little modification to ease the use.
Handle instances which are async and have callbacks (connection and stream) have internal refcounting, and when running an instance of them will be managed internally and won't be destroyed/closed until stopped or are shut down. this allows, for example, one to start running an instance of connection in a listener callback and not to worry of managing its lifetime. and if an instance wasn't started, once its out of scope, it will automatically be closed.
Due to the way msquic was designed, the parentship of instances like stream by connection and connection/listener by registration must be handled by user of this library. for example: when a connection is closed, the stream will automatically shut down and user must ensure that stream instances held by them will no longer be accessed or avilable.
So make sure dependent handles **DO NOT** outlive their dependencies. hopefully in the future this will be managed internally.
To understand these dependencies please refer to `API` overview documenetation of msquic: https://github.com/microsoft/msquic/blob/main/docs/API.md
## Base Data Types
Msquic enums/flags have an equivalent enum classes to be used. for bit flags, `w_flags` is used to handle bitwise operations.
The header `stream/quic/datatypes/common_flags.hpp` defines common enum flags used throughout the project.
For alpn name, since it is not forced to be a string, there is `w_alpn_view` in `stream/quic/datatypes/w_alpn.hpp` which represents an alpn name and is simply an alias to `std::span<uint8_t>`. it comes with `as_alpn_view` helper method to create view from string views and c strings.
Here is a list of C++ wrapper types and their corresponding msquic types:
- `w_address` represents `QUIC_ADDRESS`.
- `w_status` and `w_status_code` represent `QUIC_STATUS`. the first is for holding a status code and checking whether it succeeded or failed, and the latter is an enum representing different status codes defined by msquic.
- `w_settings` represents `QUIC_SETTINGS`, having each field as an `std::optional` so it can be easily aggregate initialized with specific field. e.g. `w_settings { .idle_timeout_ms = 2000 }`.
- `w_credential_config` represents `QUIC_CREDENTIAL_CONFIG`, and for convenience there are `w_certificate_<something>` alongside it to represent `QUIC_CERTIFICATE_<SOMETHING>` and be used with ease to construct a credential config with any certificate without worrying about value semantics.
- `w_registration_config` represents `QUIC_REGISTRATION_CONFIG`, and its fields are accessible through set/get methods.
- `w_new_connection_info` represents `QUIC_NEW_CONNECTION_INFO`, and its fields are readonly, accessible through const methods with same name.
## Events
Just as msquic uses callbacks with event as a parameter, those event types are wrapped and represented by classes.
Event types are similar to `std::variant`, and to access the underlying event value, it must be visited with an overload set. wolf library provides `system/w_overloaded` to overload lambdas to ease this.
All event types also have a `name` method to get the underlying type's name string.
There are no fields, but wrapper classes for each specific event, named as `w_<handle-name>_event_<event-name>`, e.g. `w_listener_event_new_connection`. these event classes hold the underlying data, and provide getter and helper methods to interact with them.
Events can not be created, copied, or moved. their lifetime is solely in hands of wolf library that passes them to callback/visitor.
- `w_listener_event` represents `QUIC_LISTENER_EVENT`. in `w_listener_event_new_connection` there are accept/reject methods which shouldn't be called more than once or over each other, and if neither is called then the connection will be rejected.
- `w_conection_event` represents `QUIC_CONNEcTION_EVENT`, and just like `w_listener_event_new_connection` there is `w_connection_event_peer_stream_started` that has accept/reject methods and by default rejects if neither is called.
- `w_stream_event` represents `QUIC_STREAM_EVENT`.
## Handles
The handles in msquic all have the type of `HQUIC`. but here are the common concepts and kinds of handles provided by msquic which have their own api, and wolf has wrapper for them:
- Registration: `w_registration` which on destruction waits on its children to be closed.
- Configuration: `w_configuration`.
- Listener: `w_listener` which starts and works async with callback, but it will shutdown when its last instance goes out of scope.
- Connection: `w_connection` which starts and works async with callback, and will be kept alive/running even if there are no instances of it kept by user. thus user can easily accept/open a new connection and not have to worry about its lifetime.
- Stream: `w_stream` which starts and works async with callbacks, and will be kept alive/running even if there are no instances of it kept by user. thus user can easily accept/open a new stream and not have to worry about its lifetime.
Handles can not be constructed and are created by (commonly named `open`) factory static methods, using boost::leaf for error report and handling.
Callbacks passed to create/set_callback of handle can be any callable and its storage will be internally managed.
Wolf doesn't provide the `context` pointer concept of msquic to user of this library, so instead use lambda captures or other C++-based alternatives.
## For Developer/Contributor (Internals)
Msquic's api table is created only once and is provided by singleton-style factory method `internal::w_msquic_api::api`.
As a C wrapper library there are many scenarios which one C function/type requires another C instance, and for this reason `internal::w_raw_access` pattern is used. classes which wrap a raw/C type declare that as `freind` class and provide desired private api so in any other part in the library if raw access is required, it can be gained via `internal::w_raw_access` can be used and these two types/methods need not to know of each other (necessary for generics). saving us tons of forward declarations and maintenance bookkeepings.
Handles are kept lightweight, only have the `HQUIC` pointer as data member, and all of their required shared data is allocated on heap (the type `context_bundle`) and saved in the handle's context. so the context pointer must never change/written and should be always read for concurrency safety.
================================================
FILE: manifest.manifest
================================================
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
<security>
<requestedPrivileges>
<requestedExecutionLevel level="asInvoker" uiAccess="false"></requestedExecutionLevel>
</requestedPrivileges>
</security>
</trustInfo>
<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
<application>
<!-- Windows 10 -->
<supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
<!-- Windows 8.1 -->
<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
<!-- Windows Vista -->
<supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
<!-- Windows 7 -->
<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
<!-- Windows 8 -->
<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
</application>
</compatibility>
</assembly>
================================================
FILE: wolf/.clang-format
================================================
# http://clang.llvm.org/docs/ClangFormatStyleOptions.html
BasedOnStyle: Google
# This defaults to 'Auto'. Explicitly set it for a while, so that
# 'vector<vector<int> >' in existing files gets formatted to
# 'vector<vector<int>>'. ('Auto' means that clang-format will only use
# 'int>>' if the file already contains at least one such instance.)
Standard: Cpp11
SortIncludes: true
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
BreakStringLiterals: false
DerivePointerAlignment: true
PointerAlignment: Left
ColumnLimit: 100
ForEachMacros: ['list_for_every_entry','list_for_every_entry_safe']
IncludeBlocks: Regroup
IncludeCategories:
# This specific header must come last in kernel source files. Its
# matching rule must come first so the lower-priority rules don't match.
- Regex: '^<ktl/enforce\.h>'
Priority: 1000
# C Header: <foo.h>, <net/foo.h>, etc
- Regex: '^(<((zircon/|lib/|fuchsia/|arpa/|net/|netinet/|sys/|fidl/)[a-zA-Z0-9_/\.-]+\.h|[a-zA-Z0-9_-]+\.h)>)'
Priority: 1
# Cpp Header: <foo> and <experimental/foo>
- Regex: '^(<(experimental/)*[a-zA-Z0-9_-]+>)'
Priority: 2
# Libraries: <foo/bar.h>
- Regex: '^(<[a-zA-Z0-9_/-]+\.h>)'
Priority: 3
# Local headers: "foo/bar.h"
- Regex: '^("[.a-zA-Z0-9_/-]+\.h")'
Priority: 4
================================================
FILE: wolf/.clang-tidy
================================================
---
Checks: >
-*,
bugprone-*,
clang-diagnostic-*,
-clang-diagnostic-unused-command-line-argument,
google-*,
-google-runtime-references,
misc-*,
-misc-noexcept*,
-misc-unused-parameters,
-misc-const-correctness,
modernize-*,
-modernize-avoid-c-arrays,
-modernize-deprecated-headers,
-modernize-raw-string-literal,
-modernize-return-braced-init-list,
-modernize-use-auto,
-modernize-use-equals-delete,
-modernize-use-nodiscard,
-modernize-use-trailing-return-type,
performance-*,
readability-*,
-readability-function-cognitive-complexity,
-readability-identifier-length,
-readability-implicit-bool-conversion,
-readability-isolate-declaration,
-readability-magic-numbers,
-readability-qualified-auto,
-readability-uppercase-literal-suffix,
-readability-identifier-length,
-readability-named-parameter,
WarningsAsErrors: false
AnalyzeTemporaryDtors: false
FormatStyle: file
CheckOptions:
- key: bugprone-signed-char-misuse.CharTypdefsToIgnore
value: 'int8_t'
- key: bugprone-assert-side-effect.AssertMacros
value: 'FXL_DCHECK'
- key: google-readability-braces-around-statements.ShortStatementLines
value: '2'
- key: google-readability-function-size.StatementThreshold
value: '800'
- key: google-readability-namespace-comments.ShortNamespaceLines
value: '10'
- key: google-readability-namespace-comments.SpacesBeforeComments
value: '2'
- key: misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic
value: '1'
- key: modernize-loop-convert.MaxCopySize
value: '16'
- key: modernize-loop-convert.MinConfidence
value: reasonable
- key: modernize-loop-convert.NamingStyle
value: CamelCase
- key: modernize-pass-by-value.IncludeStyle
value: llvm
- key: modernize-replace-auto-ptr.IncludeStyle
value: llvm
- key: modernize-use-default-member-init.UseAssignment
value: '1'
- key: modernize-use-emplace.IgnoreImplicitConstructors
value: '1'
- key: modernize-use-nullptr.NullMacros
value: 'NULL'
- key: readability-braces-around-statements.ShortStatementLines
value: '2'
================================================
FILE: wolf/.gitignore
================================================
*.DS_Store
*.suo
/build/*
/shells/ffmpeg/build/*
/rust/target/*
================================================
FILE: wolf/CMakeLists.txt
================================================
#cmake . -B build -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_HOME/build/cmake/android.toolchain.cmake -DANDROID_ABI=armeabi-v7a -DANDROID_NDK=$ANDROID_NDK_HOME -DANDROID_PLATFORM=android-21 -DCMAKE_ANDROID_ARCH_ABI=armeabi-v7a -DCMAKE_ANDROID_NDK=$ANDROID_NDK_HOME -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -DCMAKE_SYSTEM_NAME=Android -DCMAKE_SYSTEM_VERSION=21 -DCMAKE_BUILD_TYPE=Debug -GNinja
#cd build
#ninja
cmake_minimum_required(VERSION 3.22...3.23)
# set the name of the projects
project(wolf
DESCRIPTION "Wolf Engine"
LANGUAGES CXX
)
set(TEST_PROJECT_NAME "${PROJECT_NAME}_tests")
message("CXX Compiler ID is ${CMAKE_CXX_COMPILER_ID}")
# set the options and enviroment variables
#set(WEBRTC_SRC $ENV{WEBRTC_ROOT} CACHE STRING "path to the root folder of webrtc folder")
#define includes, libs and srcs
set(INCLUDES)
set(LIBS PARENT_SCOPE)
set(SRCS)
set(TESTS_SRCS)
# check the OS
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
if (WIN32)
set(WIN64 TRUE)
endif()
endif()
if(UNIX AND (NOT APPLE) AND (NOT EMSCRIPTEN))
set(LINUX TRUE)
endif()
if (MSVC AND NOT WIN64)
message( FATAL_ERROR "Only Window 64 bit is supported" )
endif()
# set target os
if (WIN64)
set(TARGET_OS "win")
set(LIB_EXT "lib")
set(SHARED_EXT "dll")
elseif(APPLE)
set(TARGET_OS "mac")
set(LIB_EXT "a")
set(SHARED_EXT "dylib")
elseif(LINUX)
set(TARGET_OS "linux")
set(LIB_EXT "a")
set(SHARED_EXT "so")
elseif (NOT EMSCRIPTEN)
message( FATAL_ERROR "Unsuported OS, please open an issue at https://github.com/WolfEngine/WolfEngine" )
endif()
# required packages
find_package(Git REQUIRED)
if (NOT EMSCRIPTEN)
find_package (Threads)
endif()
# use folders
set_property(GLOBAL PROPERTY USE_FOLDERS ON)
# FetchContent for cloning repositories, avaiable since CMAKE 3.11
include(FetchContent)
set(FETCHCONTENT_QUIET OFF)
# set type of library
if (LINUX OR ANDROID_ABI)
set(LIBRARY_TYPE "SHARED")
else()
set(LIBRARY_TYPE "STATIC")
endif()
set(LIBRARY_TYPE "${LIBRARY_TYPE}" CACHE STRING "Library type")
# Build options
set(LIB_INSTALL_DIR lib CACHE STRING "Install location of libraries")
set(BIN_INSTALL_DIR bin CACHE STRING "Install location of executables")
set(INCLUDE_INSTALL_DIR include CACHE STRING "Install location of executables")
# CMAKE GUI Options
set(EMSDK "$ENV{EMSDK}" CACHE STRING "Emscripten SDK path")
set(BOOST_VERSION "1.82.0" CACHE STRING "Boost version tag")
# render module
option(WOLF_RENDER "Enable cross platform render engine based on Vulkan / OpenGL ES" OFF)
# media modules
option(WOLF_MEDIA_FFMPEG "Enable ffmpeg encoding and decoding" OFF)
option(WOLF_MEDIA_OPENAL "Enable OpenAL soft" OFF)
option(WOLF_MEDIA_SCREEN_CAPTURE "Enable screen capture" OFF)
option(WOLF_MEDIA_STB "Enable stb headers" OFF)
option(WOLF_MEDIA_GSTREAMER "Enable gstreamer wrapper" OFF)
# stream modules
option(WOLF_STREAM_GRPC "Enable gRPC connection" ON)
option(WOLF_STREAM_QUIC "Enable QUIC" OFF)
option(WOLF_STREAM_RIST "Enable RIST streaming protocol" OFF)
option(WOLF_STREAM_WEBRTC "Enable webRTC" OFF)
# system modules
option(WOLF_SYSTEM_GAMEPAD_CLIENT "Enable gamepad input handling" OFF)
option(WOLF_SYSTEM_GAMEPAD_VIRTUAL "Enable virtual gamepad simulator" OFF)
option(WOLF_SYSTEM_HTTP_WS "Enable http1.1 and websocket client/server based on boost beast or Emscripten" OFF)
option(WOLF_SYSTEM_LOG "Enable log" OFF)
option(WOLF_SYSTEM_LZ4 "Enable lz4 for compression" OFF)
option(WOLF_SYSTEM_LZMA "Enable lzma for compression" OFF)
option(WOLF_SYSTEM_LUA "Enable lua scripting language" OFF)
option(WOLF_SYSTEM_MIMALLOC "Enable Microsoft's mimalloc memory allocator" OFF)
option(WOLF_SYSTEM_POSTGRESQL "Enable postgresql database client" OFF)
option(WOLF_SYSTEM_PYTHON "Enable embedded Python3 scripting" OFF)
option(WOLF_SYSTEM_SIG_SLOT "Enable signal/slot based on boost signals2" OFF)
option(WOLF_SYSTEM_SOCKET "Enable TCP/UDP protocol over socket" OFF)
option(WOLF_SYSTEM_OPENSSL "Enable openSSL" OFF)
option(WOLF_SYSTEM_STACKTRACE "Enable boost stacktrace" OFF)
option(WOLF_SYSTEM_ZLIB "Enable Zlib compression library" OFF)
# machine learing modules
option(WOLF_ML_NUDITY_DETECTION "Enable machine learning nudity detection" OFF)
option(WOLF_ML_OCR "Enable machine learning referee ocr" OFF)
#option(WOLF_ENABLE_LTO "Enable cross language linking time optimization" OFF)
option(WOLF_TEST "Enable tests" ON)
if (NOT MSVC)
option(WOLF_ENABLE_ASAN "Enable ASAN" OFF)
endif()
if(ENABLE_LTO)
include(CheckIPOSupported)
check_ipo_supported(RESULT supported OUTPUT error)
if(supported)
message(STATUS "IPO / LTO enabled")
set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
add_link_options(-fuse-ld=lld)
else()
message(STATUS "IPO / LTO not supported: <${error}>")
endif()
endif()
# set C/CXX standards
set(CMAKE_C_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS ON)
set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
set(THREADS_PREFER_PTHREAD_FLAG TRUE)
#set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
if ("${CMAKE_BUILD_TYPE}" STREQUAL "")
set(CMAKE_BUILD_TYPE "Debug")
endif()
# set C++ flags based on compiler
if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
# using Clang or AppleClang
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++2b -fexceptions -fcoroutines-ts")
set(CMAKE_CXX_FLAGS_DEBUG "-g")
set(CMAKE_CXX_FLAGS_RELEASE "-O3")
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
# using GCC
set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++2b -fexceptions -fcoroutines")
set(CMAKE_CXX_FLAGS_DEBUG "-g")
set(CMAKE_CXX_FLAGS_RELEASE "-O3")
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
# using Microsoft Visual C++
# set C++23 as the primary standard
set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_FLAGS "/EHsc /W3 /bigobj")
endif()
set(GETOPT_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/system)
# include cmakes
include(cmake/vcpkg.cmake)
include(cmake/system.cmake)
include(cmake/stream.cmake)
include(cmake/media.cmake)
include(cmake/ml.cmake)
if (EMSCRIPTEN)
message(WARNING "WOLF_TEST will be disabled for Emscripten")
set(WOLF_TEST OFF)
else()
# currently threads was not supported with WASM
list(APPEND LIBS Threads::Threads)
endif()
# disable build testing
set(BUILD_TESTING OFF CACHE BOOL "BUILD_TESTING")
if (WOLF_ENABLE_ASAN)
set(ENABLE_ASAN TRUE)
endif()
#add_compile_options(-fsanitize=address)
#add_link_options(-fsanitize=address)
# enabling clang-tidy
# can be enabled with .CLANG-TIDY from Visual Studio Code
# https://devblogs.microsoft.com/cppblog/visual-studio-code-c-december-2021-update-clang-tidy/
# can be enabled with .CLANG-TIDY from Visual Studio
# https://devblogs.microsoft.com/cppblog/code-analysis-with-clang-tidy-in-visual-studio/
#set(CMAKE_C_CLANG_TIDY
# clang-tidy;
# -format-style=file;)
#set(CMAKE_CXX_CLANG_TIDY
# clang-tidy;
# -format-style=file;)
# add definitions
add_definitions(
-DBOOST_ASIO_NO_DEPRECATED
-DBOOST_ASIO_HAS_CO_AWAIT
-DBOOST_ASIO_HAS_STD_COROUTINE
)
if (MSVC)
add_definitions(
-EHsc
-DNOMINMAX
-DWIN32_LEAN_AND_MEAN
-DWIN64
-DWIN32
)
elseif (EMSCRIPTEN)
add_definitions(
-DEMSCRIPTEN
)
elseif(APPLE)
add_definitions(-DNEED_XLOCALE_H=1)
endif()
if(CMAKE_BUILD_TYPE MATCHES Debug)
add_definitions(-DDEBUG -D_DEBUG)
else()
add_definitions(-DNDEBUG)
endif()
# setup Wolf definitions
get_cmake_property(_vars VARIABLES)
foreach (_var ${_vars})
string(FIND ${_var} "WOLF_" out)
if(("${out}" EQUAL 0) AND ("(${${_var}}" MATCHES ON))
add_definitions("-D${_var}")
endif()
endforeach()
# include sources
file(GLOB_RECURSE WOLF_SRCS
"${CMAKE_CURRENT_SOURCE_DIR}/wolf.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/wolf.hpp"
"${CMAKE_CURRENT_SOURCE_DIR}/DISABLE_ANALYSIS_BEGIN"
"${CMAKE_CURRENT_SOURCE_DIR}/DISABLE_ANALYSIS_END"
)
file(GLOB_RECURSE WOLF_PROTOS
"${CMAKE_CURRENT_SOURCE_DIR}/protos/*"
)
file(GLOB_RECURSE WOLF_CMAKES
"${CMAKE_CURRENT_SOURCE_DIR}/cmake/*"
)
# includes
include_directories(
${INCLUDES}
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/../
)
# add source codes
add_library(${PROJECT_NAME} ${LIBRARY_TYPE}
${SRCS}
${WOLF_SRCS}
${WOLF_CMAKES}
${WOLF_PROTOS}
)
if (WOLF_STREAM_RIST)
add_dependencies(${PROJECT_NAME} ${RIST_TARGET})
endif()
if (MSVC OR WIN32)
if (LIBRARY_TYPE STREQUAL "STATIC")
set_property(TARGET ${PROJECT_NAME} PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
else()
set_property(TARGET ${PROJECT_NAME} PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
endif()
endif()
# link libraries
target_link_libraries(${PROJECT_NAME} PUBLIC ${LIBS})
# create source group
source_group("wolf" FILES ${WOLF_SRCS})
source_group("cmake" FILES ${WOLF_CMAKES})
source_group("protos" FILES ${WOLF_PROTOS})
source_group("stream/grpc" FILES ${WOLF_STREAM_GRPC_SRC})
source_group("stream/janus" FILES ${WOLF_STREAM_JANUS_SRC})
source_group("stream/test" FILES ${WOLF_STREAM_TEST_SRC})
source_group("stream/quic" FILES ${WOLF_STREAM_QUIC_SRC})
source_group("stream/rist" FILES ${WOLF_STREAM_RIST_SRC})
source_group("stream/webrtc/capturer" FILES ${WOLF_STREAM_WEBRTC_CAPTURER_SRC})
source_group("stream/webrtc/data" FILES ${WOLF_STREAM_WEBRTC_DATA_SRC})
source_group("stream/webrtc/interceptor" FILES ${WOLF_STREAM_WEBRTC_INTERCEPTOR_SRC})
source_group("stream/webrtc/media" FILES ${WOLF_STREAM_WEBRTC_MEDIA_SRC})
source_group("stream/webrtc/peer" FILES ${WOLF_STREAM_WEBRTC_PEER_SRC})
source_group("stream/test" FILES ${WOLF_STREAM_QUIC_SRC})
source_group("stream" FILES ${WOLF_STREAM_SRC})
source_group("system/gamepad" FILES ${WOLF_SYSTEM_GAMEPAD_CLIENT_SRC} ${WOLF_SYSTEM_GAMEPAD_VIRTUAL_SRCS})
source_group("system/log" FILES ${WOLF_SYSTEM_LOG_SRC})
source_group("system/compression" FILES ${WOLF_SYSTEM_LZ4_SRCS} ${WOLF_SYSTEM_LZMA_SRCS})
source_group("system/script" FILES ${WOLF_SYSTEM_LUA_SRC})
source_group("system/script" FILES ${WOLF_SYSTEM_PYTHON_SRC})
source_group("system/socket" FILES ${WOLF_SYSTEM_SOCKET_SRC} ${WOLF_SYSTEM_HTTP_WS_SRC})
source_group("system/test" FILES ${WOLF_SYSTEM_TEST_SRC})
source_group("system" FILES ${WOLF_SYSTEM_SRC})
source_group("media/test" FILES ${WOLF_MEDIA_TEST_SRC})
source_group("media/ffmpeg" FILES ${WOLF_MEDIA_FFMPEG_SRC})
source_group("media" FILES ${WOLF_MEDIA_OPENAL_SRC} ${WOLF_MEDIA_STB_SRC})
source_group("ml/referee_ocr" FILES ${WOLF_ML_OCR_SRC})
source_group("ml/nudity_detection" FILES ${WOLF_ML_NUD_DET_SRC})
# add compile options
if (NOT WIN32)
target_compile_options(${PROJECT_NAME} PRIVATE -std=c++2b -fPIC)
endif()
if (WOLF_ENABLE_ASAN)
target_compile_options(${PROJECT_NAME} PRIVATE -fsanitize=address)
target_link_options(${PROJECT_NAME} PRIVATE -fsanitize=address)
endif()
# build tests
if (WOLF_TEST)
add_executable(${TEST_PROJECT_NAME}
tests.cpp
${TESTS_SRCS}
)
if (MSVC OR WIN32)
if (LIBRARY_TYPE STREQUAL "STATIC")
set_property(TARGET ${TEST_PROJECT_NAME} PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
else()
set_property(TARGET ${TEST_PROJECT_NAME} PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
endif()
endif()
if(WOLF_ML_OCR AND LINUX)
target_link_libraries(${TEST_PROJECT_NAME} PRIVATE ${PROJECT_NAME} ${leptonica_BINARY_DIR}/install/lib/libleptonica.so)
else()
target_link_libraries(${TEST_PROJECT_NAME} PRIVATE ${PROJECT_NAME})
endif()
if (NOT WIN32)
target_compile_options(${TEST_PROJECT_NAME} PRIVATE -std=c++2b)
endif()
include(CTest)
add_test(NAME ${TEST_PROJECT_NAME} COMMAND ${TEST_PROJECT_NAME})
endif()
if(WOLF_ML_OCR AND WIN64)
add_custom_command(TARGET ${TEST_PROJECT_NAME} POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_BINARY_DIR}/bin/${CMAKE_BUILD_TYPE} ${CMAKE_BINARY_DIR}/${PROJECT_NAME}/${CMAKE_BUILD_TYPE}
)
endif()
# install target
install(TARGETS ${PROJECT_NAME}
LIBRARY DESTINATION ${LIB_INSTALL_DIR}
ARCHIVE DESTINATION ${LIB_INSTALL_DIR})
foreach(ITEM ${INCLUDES})
install(DIRECTORY ${ITEM}/ DESTINATION ${INCLUDE_INSTALL_DIR})
endforeach()
install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/wolf.hpp DESTINATION ${INCLUDE_INSTALL_DIR})
if (WOLF_TEST)
install(TARGETS ${TEST_PROJECT_NAME} DESTINATION ${BIN_INSTALL_DIR})
endif()
================================================
FILE: wolf/DISABLE_ANALYSIS_BEGIN
================================================
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning (disable:ALL_CODE_ANALYSIS_WARNINGS)
#endif
// NOLINTBEGIN
================================================
FILE: wolf/DISABLE_ANALYSIS_END
================================================
#ifdef _MSC_VER
#pragma warning(pop)
#endif
// NOLINTEND
================================================
FILE: wolf/cmake/media.cmake
================================================
# link to ffmpeg
if (WOLF_MEDIA_FFMPEG)
file(GLOB_RECURSE WOLF_MEDIA_FFMPEG_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/media/ffmpeg/*"
)
list(APPEND SRCS ${WOLF_MEDIA_FFMPEG_SRC})
list(APPEND INCLUDES ${CMAKE_CURRENT_SOURCE_DIR}/third_party/ffmpeg/include)
list(APPEND FFMPEG_LIBS
avcodec
avdevice
avfilter
avformat
avutil
swresample
swscale
)
foreach (lib_name ${FFMPEG_LIBS})
list(APPEND LIBS ${CMAKE_CURRENT_SOURCE_DIR}/third_party/ffmpeg/lib/${TARGET_OS}/${lib_name}.${LIB_EXT})
endforeach()
endif()
# link openAL
if (WOLF_MEDIA_OPENAL)
message("fetching https://github.com/kcat/openal-soft.git")
FetchContent_Declare(
openal
GIT_REPOSITORY https://github.com/kcat/openal-soft.git
GIT_TAG master
)
set(ALSOFT_EXAMPLES OFF CACHE BOOL "ALSOFT_EXAMPLES")
set(ALSOFT_INSTALL_EXAMPLES OFF CACHE BOOL "ALSOFT_INSTALL_EXAMPLES")
set(LIBTYPE "STATIC" CACHE STRING "STATIC")
set(FETCHCONTENT_QUIET OFF)
FetchContent_MakeAvailable(openal)
file(GLOB_RECURSE WOLF_MEDIA_OPENAL_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/media/w_openal.hpp"
"${CMAKE_CURRENT_SOURCE_DIR}/media/w_openal.cpp"
)
list(APPEND SRCS ${WOLF_MEDIA_OPENAL_SRC})
list(APPEND INCLUDES ${openal_SOURCE_DIR}/include)
list(APPEND LIBS OpenAL::OpenAL)
set_target_properties(
build_version
common
ex-common
OpenAL
openal-info
PROPERTIES FOLDER "openAL")
endif()
if (WOLF_MEDIA_STB)
message("fetching https://github.com/nothings/stb.git")
FetchContent_Declare(
stb
GIT_REPOSITORY https://github.com/nothings/stb.git
GIT_TAG master
)
FetchContent_Populate(stb)
file(GLOB_RECURSE WOLF_MEDIA_STB_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/media/w_image.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/media/w_image.hpp"
)
list(APPEND SRCS ${WOLF_MEDIA_STB_SRC})
list(APPEND INCLUDES ${stb_SOURCE_DIR})
endif()
if (WOLF_MEDIA_GSTREAMER)
file(GLOB_RECURSE WOLF_MEDIA_GSTREAMER_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/media/gst/*"
"${CMAKE_CURRENT_SOURCE_DIR}/media/gst/audio/*"
"${CMAKE_CURRENT_SOURCE_DIR}/media/gst/core/*"
"${CMAKE_CURRENT_SOURCE_DIR}/media/gst/elements/*"
"${CMAKE_CURRENT_SOURCE_DIR}/media/gst/video/*"
)
find_package(PkgConfig REQUIRED)
pkg_check_modules(gstreamer REQUIRED IMPORTED_TARGET
gstreamer-1.0
gstreamer-video-1.0
gstreamer-audio-1.0)
add_library(gstreamer-lib INTERFACE)
target_compile_options(gstreamer-lib INTERFACE ${gstreamer_CFLAGS})
target_include_directories(gstreamer-lib INTERFACE ${gstreamer_INCLUDE_DIRS})
target_link_directories(gstreamer-lib BEFORE INTERFACE ${gstreamer_LIBRARY_DIRS})
target_link_libraries(gstreamer-lib INTERFACE ${gstreamer_LIBRARIES})
list(APPEND SRCS ${WOLF_MEDIA_GSTREAMER_SRC})
list(APPEND LIBS gstreamer-lib)
endif()
file(GLOB_RECURSE WOLF_MEDIA_TEST_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/media/test/*"
)
list(APPEND SRCS ${WOLF_MEDIA_TEST_SRC})
================================================
FILE: wolf/cmake/ml.cmake
================================================
if(WOLF_ML_OCR)
if(LINUX)
# fetch leptonica
message("fetching https://github.com/DanBloomberg/leptonica.git")
FetchContent_Declare(
leptonica
GIT_REPOSITORY https://github.com/DanBloomberg/leptonica.git
GIT_TAG 1.80.0
GIT_SHALLOW TRUE
GIT_PROGRESS TRUE
)
FetchContent_Populate(leptonica)
add_custom_command(OUTPUT lept_config.out COMMAND cmake -B ${leptonica_BINARY_DIR} -DBUILD_SHARED_LIBS=1 -DCMAKE_INSTALL_PREFIX:PATH=${leptonica_BINARY_DIR}/install ${leptonica_SOURCE_DIR})
add_custom_target(lept_config ALL DEPENDS lept_config.out)
add_custom_command(OUTPUT lept_build.out COMMAND cmake --build ${leptonica_BINARY_DIR} --target install)
add_custom_target(lept_build ALL DEPENDS lept_build.out)
endif()
# fetch tesseract
message("fetching https://github.com/tesseract-ocr/tesseract.git")
FetchContent_Declare(
tesseract
GIT_REPOSITORY https://github.com/tesseract-ocr/tesseract.git
GIT_TAG main
GIT_SHALLOW TRUE
GIT_PROGRESS TRUE
)
if(WIN64)
set(FETCHCONTENT_QUIET OFF)
set(BUILD_TESTS OFF CACHE BOOL "BUILD_TESTS")
set(BUILD_TRAINING_TOOLS OFF CACHE BOOL "BUILD_TRAINING_TOOLS")
set(DISABLE_ARCHIVE ON CACHE BOOL "DISABLE_ARCHIVE")
set(DISABLE_CURL ON CACHE BOOL "DISABLE_CURL")
set(FAST_FLOAT ON CACHE BOOL "FAST_FLOAT")
set(GRAPHICS_DISABLED ON CACHE BOOL "GRAPHICS_DISABLED")
set(INSTALL_CONFIGS OFF CACHE BOOL "INSTALL_CONFIGS")
set(SW_BUILD ON CACHE BOOL "SW_BUILD")
FetchContent_MakeAvailable(tesseract)
list(APPEND INCLUDES
${tesseract_SOURCE_DIR}/include
${tesseract_BINARY_DIR}/include
)
if("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
set(DEBUG_LIB_EXTENTION "d")
else()
set(DEBUG_LIB_EXTENTION "")
endif()
list(APPEND LIBS
${tesseract_BINARY_DIR}/${CMAKE_BUILD_TYPE}/tesseract53${DEBUG_LIB_EXTENTION}.lib
)
elseif(LINUX)
FetchContent_Populate(tesseract)
list(APPEND INCLUDES
${tesseract_SOURCE_DIR}/include
${tesseract_BINARY_DIR}/install/include
)
link_directories(${tesseract_BINARY_DIR}/install/lib)
list(APPEND LIBS
tesseract
)
add_custom_command(OUTPUT tess_config.out COMMAND cmake -B ${tesseract_BINARY_DIR} -DBUILD_SHARED_LIBS=1 -DBUILD_TESTS=OFF -DBUILD_TRAINING_TOOLS=OFF -DDISABLE_ARCHIVE=ON -DDISABLE_CURL=ON -DFAST_FLOAT=ON -DGRAPHICS_DISABLED=ON -DINSTALL_CONFIGS=OFF -DLeptonica_DIR=${leptonica_BINARY_DIR} -DCMAKE_INSTALL_PREFIX:PATH=${tesseract_BINARY_DIR}/install ${tesseract_SOURCE_DIR})
add_custom_target(tess_config ALL DEPENDS tess_config.out)
add_custom_command(OUTPUT tess_build.out COMMAND cmake --build ${tesseract_BINARY_DIR} --target install)
add_custom_target(tess_build ALL DEPENDS tess_build.out)
endif()
# fetch opencv
message("fetching https://github.com/opencv/opencv.git")
FetchContent_Declare(
opencv
GIT_REPOSITORY https://github.com/opencv/opencv.git
GIT_TAG 4.5.4
GIT_SHALLOW TRUE
GIT_PROGRESS TRUE
)
if(WIN64)
FetchContent_GetProperties(opencv)
set(BUILD_LIST core,highgui,videoio CACHE STRING "BUILD_LIST")
set(WITH_IPP OFF CACHE BOOL "WITH_IPP")
set(BUILD_EXAMPLES OFF CACHE BOOL "BUILD_EXAMPLES")
set(OPENCV_GENERATE_PKGCONFIG ON CACHE BOOL "OPENCV_GENERATE_PKGCONFIG")
FetchContent_MakeAvailable(opencv)
list(APPEND INCLUDES
${CMAKE_BINARY_DIR}
${opencv_SOURCE_DIR}/include
${opencv_SOURCE_DIR}/modules/core/include
${opencv_SOURCE_DIR}/modules/highgui/include
${opencv_SOURCE_DIR}/modules/imgcodecs/include
${opencv_SOURCE_DIR}/modules/imgproc/include
${opencv_SOURCE_DIR}/modules/videoio/include
)
list(APPEND LIBS
${opencv_BINARY_DIR}/lib/${CMAKE_BUILD_TYPE}/opencv_core454${DEBUG_LIB_EXTENTION}.lib
${opencv_BINARY_DIR}/lib/${CMAKE_BUILD_TYPE}/opencv_highgui454${DEBUG_LIB_EXTENTION}.lib
${opencv_BINARY_DIR}/lib/${CMAKE_BUILD_TYPE}/opencv_imgcodecs454${DEBUG_LIB_EXTENTION}.lib
${opencv_BINARY_DIR}/lib/${CMAKE_BUILD_TYPE}/opencv_imgproc454${DEBUG_LIB_EXTENTION}.lib
${opencv_BINARY_DIR}/lib/${CMAKE_BUILD_TYPE}/opencv_videoio454${DEBUG_LIB_EXTENTION}.lib
)
elseif(LINUX)
FetchContent_Populate(opencv)
list(APPEND INCLUDES
${opencv_BINARY_DIR}/install/include/opencv4
)
list(APPEND LIBS
${opencv_BINARY_DIR}/install/lib/libopencv_core.so
${opencv_BINARY_DIR}/install/lib/libopencv_highgui.so
${opencv_BINARY_DIR}/install/lib/libopencv_imgcodecs.so
${opencv_BINARY_DIR}/install/lib/libopencv_imgproc.so
${opencv_BINARY_DIR}/install/lib/libopencv_videoio.so
)
add_custom_command(OUTPUT opencv_config.out COMMAND cmake -B ${opencv_BINARY_DIR} -DBUILD_LIST=core,highgui,videoio -DBUILD_opencv_python3=OFF -DWITH_IPP=OFF -DBUILD_EXAMPLES=OFF -DOPENCV_GENERATE_PKGCONFIG=ON -DCMAKE_INSTALL_PREFIX:PATH=${opencv_BINARY_DIR}/install ${opencv_SOURCE_DIR})
add_custom_target(opencv_config ALL DEPENDS opencv_config.out)
add_custom_command(OUTPUT opencv_build.out COMMAND cmake --build ${opencv_BINARY_DIR} --target install)
add_custom_target(opencv_build ALL DEPENDS opencv_build.out)
endif()
# fetch rapidjson
message("fetching https://github.com/Tencent/rapidjson.git")
FetchContent_Declare(
rapidjson
GIT_REPOSITORY https://github.com/Tencent/rapidjson.git
GIT_SHALLOW TRUE
GIT_PROGRESS TRUE
)
FetchContent_Populate(rapidjson)
list(APPEND INCLUDES
${rapidjson_SOURCE_DIR}/include
)
file(GLOB_RECURSE WOLF_ML_OCR_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/ml/referee_ocr/*"
)
list(APPEND SRCS
${WOLF_ML_OCR_SRC}
)
endif()
if(WOLF_ML_NUDITY_DETECTION)
# Set the C++ standard for the rest of the project
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# Find Torch package
find_package(Torch REQUIRED)
# Set the C++ standard for the rest of the project
set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
find_package(OpenCV REQUIRED)
list(APPEND INCLUDES
${OpenCV_INCLUDE_DIRS}
)
list(APPEND LIBS
${TORCH_LIBRARIES}
${OpenCV_LIBS}
)
file(GLOB_RECURSE WOLF_ML_SHARED_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/ml/w_common.*"
)
list(APPEND SRCS
${WOLF_ML_SHARED_SRC}
)
file(GLOB_RECURSE WOLF_ML_NUD_DET_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/ml/nudity_detection/*"
)
list(APPEND SRCS
${WOLF_ML_NUD_DET_SRC}
)
endif()
================================================
FILE: wolf/cmake/stream.cmake
================================================
# fetch gRPC
if (WOLF_STREAM_GRPC)
if (EMSCRIPTEN)
message(FATAL_ERROR "the wasm32 target is not supported for WOLF_STREAM_GRPC")
endif()
vcpkg_install(asio-grpc asio-grpc TRUE)
list(APPEND LIBS asio-grpc::asio-grpc)
file(GLOB_RECURSE WOLF_STREAM_GRPC_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/stream/grpc/*"
)
list(APPEND SRCS
${WOLF_STREAM_GRPC_SRC}
)
if(WOLF_TEST)
add_library(generate-protos OBJECT)
target_link_libraries(generate-protos PUBLIC protobuf::libprotobuf gRPC::grpc++_unsecure)
set(PROTO_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/protos")
set(PROTO_IMPORT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/protos")
asio_grpc_protobuf_generate(
GENERATE_GRPC GENERATE_MOCK_CODE
TARGET generate-protos
USAGE_REQUIREMENT PUBLIC
IMPORT_DIRS ${PROTO_IMPORT_DIRS}
OUT_DIR "${PROTO_BINARY_DIR}"
PROTOS "${CMAKE_CURRENT_SOURCE_DIR}/protos/raft.proto")
list(APPEND INCLUDES "${PROTO_BINARY_DIR}")
list(APPEND TESTS_SRCS
"${PROTO_BINARY_DIR}/raft.grpc.pb.cc"
"${PROTO_BINARY_DIR}/raft.pb.cc"
)
endif()
endif()
if (WOLF_STREAM_JANUS)
file(GLOB_RECURSE WOLF_STREAM_JANUS_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/stream/janus/*"
)
list(APPEND SRCS
${WOLF_STREAM_JANUS_SRC}
)
endif()
# fetch msquic
if (WOLF_STREAM_QUIC)
if (EMSCRIPTEN)
message(FATAL_ERROR "WOLF_STREAM_QUIC is not supported for wasm32 target")
endif()
if (NOT WIN32)
message(FATAL_ERROR "WOLF_STREAM_QUIC feature is not avilable on non-windows yet.")
endif()
file(GLOB_RECURSE WOLF_STREAM_QUIC_SRCS
"${CMAKE_CURRENT_SOURCE_DIR}/stream/quic/*"
)
if (WIN32 OR WIN64)
FetchContent_Declare(
msquic
URL https://github.com/microsoft/msquic/releases/download/v2.2.0/msquic_windows_x64_Release_schannel.zip
DOWNLOAD_EXTRACT_TIMESTAMP TRUE
)
FetchContent_Populate(msquic)
else()
message(FATAL_ERROR "WOLF_STREAM_QUIC feature is not supported on target platform.")
endif()
add_library(msquic-lib INTERFACE)
add_library(msquic::msquic ALIAS msquic-lib)
target_include_directories(msquic-lib INTERFACE ${msquic_SOURCE_DIR}/include)
target_link_directories(msquic-lib INTERFACE BEFORE ${msquic_SOURCE_DIR}/bin)
target_link_directories(msquic-lib INTERFACE BEFORE ${msquic_SOURCE_DIR}/lib)
target_link_libraries(msquic-lib INTERFACE msquic)
list(APPEND SRCS ${WOLF_STREAM_QUIC_SRCS})
list(APPEND LIBS msquic::msquic)
endif()
if (WOLF_STREAM_RIST)
if (EMSCRIPTEN)
message(FATAL_ERROR "the wasm32 target is not supported for WOLF_STREAM_RIST")
endif()
set(RIST_TARGET "rist")
message("fetching https://code.videolan.org/rist/librist.git")
FetchContent_Declare(
${RIST_TARGET}
GIT_REPOSITORY https://code.videolan.org/rist/librist.git
GIT_TAG master
)
set(FETCHCONTENT_QUIET OFF)
FetchContent_MakeAvailable(${RIST_TARGET})
if (ANDROID)
add_custom_command(OUTPUT rist_command.out COMMAND
/bin/bash "${CMAKE_CURRENT_SOURCE_DIR}/third_party/shells/librist/librist-android.sh" --build_dir=${rist_BINARY_DIR}
WORKING_DIRECTORY ${rist_SOURCE_DIR})
add_custom_target(rist ALL DEPENDS rist_command.out)
list(APPEND LIBS
${rist_BINARY_DIR}/librist.a)
else ()
STRING(TOLOWER "${CMAKE_BUILD_TYPE}" CMAKE_BUILD_TYPE_LOWER)
add_custom_command(OUTPUT rist_command.out COMMAND cmd /c "meson setup ${rist_BINARY_DIR} --backend vs2022 --default-library static --buildtype ${CMAKE_BUILD_TYPE_LOWER} & meson compile -C ${rist_BINARY_DIR}" WORKING_DIRECTORY ${rist_SOURCE_DIR})
add_custom_target(rist ALL DEPENDS rist_command.out)
list(APPEND LIBS
ws2_32
${rist_BINARY_DIR}/librist.a)
endif()
list(APPEND INCLUDES
${rist_BINARY_DIR}
${rist_BINARY_DIR}/include
${rist_BINARY_DIR}/include/librist
${rist_SOURCE_DIR}/contrib
${rist_SOURCE_DIR}/contrib/mbedtls/include
${rist_SOURCE_DIR}/include
${rist_SOURCE_DIR}/include/librist
${rist_SOURCE_DIR}/src
)
file(GLOB_RECURSE WOLF_STREAM_RIST_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/stream/rist/*"
)
list(APPEND SRCS ${WOLF_STREAM_RIST_SRC})
endif()
if (WOLF_STREAM_WEBRTC)
if (EMSCRIPTEN)
message(FATAL_ERROR "the wasm32 target is not supported for WOLF_STREAM_WEBRTC")
endif()
# we need http & json for webrtc
if (NOT WOLF_SYSTEM_JSON)
message( FATAL_ERROR "'WOLF_STREAM_WEBRTC' needs 'WOLF_SYSTEM_JSON' = ON" )
endif()
if (NOT WOLF_STREAM_HTTP)
message( FATAL_ERROR "'WOLF_STREAM_WEBRTC' needs 'WOLF_STREAM_HTTP' = ON" )
endif()
list(APPEND INCLUDES
${WEBRTC_SRC}
${WEBRTC_SRC}/third_party/abseil-cpp
${WEBRTC_SRC}/third_party/libyuv/include
)
if (WIN32)
# enable/disable debug option
if(CMAKE_BUILD_TYPE MATCHES Debug)
add_definitions(
-D_HAS_ITERATOR_DEBUGGING=1
-D_ITERATOR_DEBUG_LEVEL=2
)
else()
add_definitions(
-D_HAS_ITERATOR_DEBUGGING=0
-D_ITERATOR_DEBUG_LEVEL=0
)
endif()
add_definitions(
-DWEBRTC_WIN
-D__PRETTY_FUNCTION__=__FUNCTION__
#-DUSE_X11
#-D_WINSOCKAPI_
-DHAVE_SOUND)
list(APPEND LIBS
d3d11
dmoguids
dwmapi
dxgi
iphlpapi
msdmo
secur32
strmiids
winmm
wmcodecdspuuid
)
elseif (APPLE)
add_definitions(
-DHAVE_SOUND
-DWEBRTC_MAC
-DWEBRTC_POSIX
-fno-rtti)
find_library(APPLICATION_SERVICES ApplicationServices)
find_library(AUDIO_TOOLBOX AudioToolBox)
find_library(CORE_AUDIO CoreAudio)
find_library(CORE_FOUNDATION CoreFoundation)
find_library(CORE_SERVICES CoreServices)
find_library(FOUNDATION Foundation)
list(APPEND LIBS
${APPLICATION_SERVICES}
${AUDIO_TOOLBOX}
${CORE_AUDIO}
${CORE_FOUNDATION}
${CORE_SERVICES}
${FOUNDATION}
)
endif()
add_definitions(-DHAVE_JPEG)
link_directories(${WEBRTC_SRC}/out/${TARGET_OS}/${CMAKE_BUILD_TYPE}/obj/)
list(APPEND LIBS webrtc)
file(GLOB_RECURSE WOLF_STREAM_WEBRTC_CAPTURER_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/stream/webrtc/capturer/*"
)
file(GLOB_RECURSE WOLF_STREAM_WEBRTC_DATA_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/stream/webrtc/data/*"
)
file(GLOB_RECURSE WOLF_STREAM_WEBRTC_INTERCEPTOR_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/stream/webrtc/interceptor/*"
)
file(GLOB_RECURSE WOLF_STREAM_WEBRTC_MEDIA_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/stream/webrtc/media/*"
)
file(GLOB_RECURSE WOLF_STREAM_WEBRTC_PEER_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/stream/webrtc/peer/*"
)
list(APPEND SRCS
${WOLF_STREAM_WEBRTC_CAPTURER_SRC}
${WOLF_STREAM_WEBRTC_DATA_SRC}
${WOLF_STREAM_WEBRTC_INTERCEPTOR_SRC}
${WOLF_STREAM_WEBRTC_MEDIA_SRC}
${WOLF_STREAM_WEBRTC_PEER_SRC}
)
endif()
file(GLOB_RECURSE WOLF_STREAM_TEST_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/stream/test/*"
)
list(APPEND SRCS ${WOLF_STREAM_TEST_SRC})
================================================
FILE: wolf/cmake/system.cmake
================================================
if (WOLF_SYSTEM_STACKTRACE)
if (EMSCRIPTEN)
message(FATAL_ERROR "the wasm32 target is not supported for WOLF_SYSTEM_STACKTRACE")
elseif(NOT MSVC)
message(FATAL_ERROR "WOLF_SYSTEM_STACKTRACE is only supported on Visual C++")
endif()
endif()
# fetch mimalloc
if (WOLF_SYSTEM_MIMALLOC)
if (EMSCRIPTEN)
message(FATAL_ERROR "the wasm32 target is not supported for WOLF_SYSTEM_MIMALLOC")
endif()
vcpkg_install(mimalloc mimalloc TRUE)
list(APPEND LIBS mimalloc)
endif()
# fetch boost components via vcpkg
if (EMSCRIPTEN)
execute_process(COMMAND vcpkg install
boost-leaf
boost-signals2 --triplet=${VCPKG_TARGET_TRIPLET})
elseif(WOLF_SYSTEM_PYTHON)
execute_process(COMMAND vcpkg install
boost-asio
boost-beast
boost-leaf
boost-python
boost-signals2
boost-test --triplet=${VCPKG_TARGET_TRIPLET})
else()
execute_process(COMMAND vcpkg install
boost-asio
boost-beast
boost-leaf
boost-signals2
boost-test --triplet=${VCPKG_TARGET_TRIPLET})
endif()
set(Boost_INCLUDE_DIR $ENV{VCPKG_ROOT}/installed/${VCPKG_TARGET_TRIPLET}/include CACHE STRING "boost include directory" FORCE)
list(APPEND INCLUDES ${Boost_INCLUDE_DIR})
find_package(Boost ${Boost_VERSION} REQUIRED)
# install gsl
vcpkg_install(Microsoft.GSL ms-gsl TRUE)
list(APPEND LIBS Microsoft.GSL::GSL)
if (NOT CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND NOT EMSCRIPTEN)
vcpkg_install(fmt fmt FALSE)
list(APPEND LIBS fmt::fmt-header-only)
endif()
if (WOLF_SYSTEM_GAMEPAD_CLIENT)
file(GLOB_RECURSE WOLF_SYSTEM_GAMEPAD_CLIENT_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/system/gamepad/w_gamepad_client_emc.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/gamepad/w_gamepad_client_keymap.hpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/gamepad/w_gamepad_client_sdl.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/gamepad/w_gamepad_client_types.hpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/gamepad/w_gamepad_client.hpp"
)
list(APPEND SRCS ${WOLF_SYSTEM_GAMEPAD_CLIENT_SRC})
if (NOT EMSCRIPTEN)
message("fetching https://github.com/libsdl-org/SDL")
FetchContent_Declare(
SDL3-static
GIT_REPOSITORY https://github.com/libsdl-org/SDL
GIT_TAG main
)
set(SDL_AUDIO OFF CACHE BOOL "SDL_AUDIO")
set(SDL_DIRECTX OFF CACHE BOOL "SDL_DIRECTX")
set(SDL_DISKAUDIO OFF CACHE BOOL "SDL_DISKAUDIO")
set(SDL_DUMMYAUDIO OFF CACHE BOOL "SDL_DUMMYAUDIO")
set(SDL_DUMMYVIDEO OFF CACHE BOOL "SDL_DUMMYVIDEO")
set(SDL_FILE OFF CACHE BOOL "SDL_FILE")
set(SDL_FILESYSTEM OFF CACHE BOOL "SDL_FILESYSTEM")
set(SDL_METAL OFF CACHE BOOL "SDL_METAL")
set(SDL_OFFSCREEN OFF CACHE BOOL "SDL_OFFSCREEN")
set(SDL_OPENGL OFF CACHE BOOL "SDL_OPENGL")
set(SDL_OPENGLES OFF CACHE BOOL "SDL_OPENGLES")
set(SDL_RENDER OFF CACHE BOOL "SDL_RENDER")
set(SDL_RENDER_D3D OFF CACHE BOOL "SDL_RENDER_D3D")
set(SDL_RENDER_METAL OFF CACHE BOOL "SDL_RENDER_METAL")
set(SDL_SHARED OFF CACHE BOOL "SDL_SHARED")
set(SDL_TEST OFF CACHE BOOL "SDL_TEST")
set(SDL_TESTS OFF CACHE BOOL "SDL_TESTS")
set(SDL_VIDEO OFF CACHE BOOL "SDL_VIDEO")
set(SDL_VULKAN OFF CACHE BOOL "SDL_VULKAN")
set(SDL_WASAPI OFF CACHE BOOL "SDL_WASAPI")
set(SDL_HIGHDAPI_JOYSTICK ON CACHE BOOL "SDL_HIGHDAPI_JOYSTICK")
set(SDL_JOYSTICK ON CACHE BOOL "SDL_JOYSTICK")
set(SDL_STATIC ON CACHE BOOL "SDL_STATIC")
set(SDL_XINPUT ON CACHE BOOL "SDL_XINPUT")
set(FETCHCONTENT_QUIET OFF)
FetchContent_MakeAvailable(SDL3-static)
list(APPEND INCLUDES
${SDL3-static_SOURCE_DIR}/include
)
list(APPEND LIBS SDL3-static)
set_target_properties(
SDL3-static
uninstall
PROPERTIES FOLDER "SDL")
endif()
endif()
if (WOLF_SYSTEM_GAMEPAD_VIRTUAL)
if (NOT WIN32)
message(SEND_ERROR "WOLF_SYSTEM_GAMEPAD_VIRTUAL can only build for Windows")
else()
message("fetching https://github.com/ViGEm/ViGEmClient.git")
FetchContent_Declare(
ViGEmClient
GIT_REPOSITORY https://github.com/ViGEm/ViGEmClient.git
GIT_TAG master
)
FetchContent_MakeAvailable(ViGEmClient)
file(GLOB_RECURSE WOLF_SYSTEM_GAMEPAD_VIRTUAL_SRCS
"${CMAKE_CURRENT_SOURCE_DIR}/system/gamepad/w_gamepad_virtual_pool.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/gamepad/w_gamepad_virtual_pool.hpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/gamepad/w_gamepad_virtual.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/gamepad/w_gamepad_virtual.hpp"
)
list(APPEND SRCS ${WOLF_SYSTEM_GAMEPAD_VIRTUAL_SRCS})
list(APPEND INCLUDES ${ViGEmClient_SOURCE_DIR}/include)
list(APPEND LIBS
ViGEmClient
Xinput.lib
SetupAPI.lib)
endif()
endif()
if (WOLF_SYSTEM_LOG)
if (EMSCRIPTEN)
message(FATAL_ERROR "the wasm32 target is not supported for WOLF_SYSTEM_LOG")
endif()
vcpkg_install(spdlog spdlog TRUE)
list(APPEND LIBS spdlog::spdlog spdlog::spdlog_header_only)
file(GLOB_RECURSE WOLF_SYSTEM_LOG_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/system/log/*"
)
list(APPEND SRCS ${WOLF_SYSTEM_LOG_SRC})
endif()
if (WOLF_SYSTEM_LZ4)
if (EMSCRIPTEN)
message(FATAL_ERROR "the wasm32 target is not supported for WOLF_SYSTEM_LZ4")
endif()
vcpkg_install(lz4 lz4 TRUE)
list(APPEND LIBS lz4::lz4)
file(GLOB_RECURSE WOLF_SYSTEM_LZ4_SRCS
"${CMAKE_CURRENT_SOURCE_DIR}/system/compression/w_lz4.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/compression/w_lz4.hpp"
)
list(APPEND SRCS ${WOLF_SYSTEM_LZ4_SRCS})
endif()
if (WOLF_SYSTEM_LZMA)
if (EMSCRIPTEN)
message(FATAL_ERROR "the wasm32 target is not supported for WOLF_SYSTEM_LZMA")
endif()
message("fetching https://github.com/WolfEngine/lzma.git")
FetchContent_Declare(
lzma
GIT_REPOSITORY https://github.com/WolfEngine/lzma.git
GIT_TAG main
)
set(FETCHCONTENT_QUIET OFF)
FetchContent_MakeAvailable(lzma)
file(GLOB_RECURSE WOLF_SYSTEM_LZMA_SRCS
"${CMAKE_CURRENT_SOURCE_DIR}/system/compression/w_lzma.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/compression/w_lzma.hpp"
)
list(APPEND SRCS ${WOLF_SYSTEM_LZMA_SRCS})
list(APPEND INCLUDES ${lzma_SOURCE_DIR}/src)
list(APPEND LIBS lzma)
endif()
# include openSSL
if (WOLF_SYSTEM_OPENSSL AND NOT EMSCRIPTEN)
vcpkg_install(OpenSSL openssl FALSE)
list(APPEND LIBS OpenSSL::SSL OpenSSL::Crypto)
endif()
# include socket/websocket sources
if (WOLF_SYSTEM_SOCKET AND NOT EMSCRIPTEN)
file(GLOB_RECURSE WOLF_SYSTEM_SOCKET_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/system/socket/w_socket_options.hpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/socket/w_tcp_client.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/socket/w_tcp_client.hpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/socket/w_tcp_server.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/socket/w_tcp_server.hpp"
)
list(APPEND SRCS ${WOLF_SYSTEM_SOCKET_SRC})
endif()
if (WOLF_SYSTEM_HTTP_WS)
if (EMSCRIPTEN)
file(GLOB_RECURSE WOLF_SYSTEM_HTTP_WS_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/system/socket/w_ws_client_emc.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/socket/w_ws_client_emc.hpp"
)
else()
file(GLOB_RECURSE WOLF_SYSTEM_HTTP_WS_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/system/socket/w_ws_client.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/socket/w_ws_client.hpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/socket/w_ws_server.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/socket/w_ws_server.hpp"
)
endif()
list(APPEND SRCS ${WOLF_SYSTEM_HTTP_WS_SRC})
endif()
if (WOLF_SYSTEM_ZLIB)
vcpkg_install(ZLIB zlib FALSE)
list(APPEND LIBS ZLIB::ZLIB)
endif()
if (WOLF_SYSTEM_POSTGRESQL)
vcpkg_install(libpq libpq TRUE)
list(APPEND LIBS libpq::libpq)
file(GLOB_RECURSE WOLF_SYSTEM_POSTGRESQL_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/system/db/w_postgresql.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/db/w_postgresql.hpp"
)
list(APPEND LIBS PostgreSQL::PostgreSQL)
endif()
if (WOLF_SYSTEM_LUA)
vcpkg_install(Lua lua FALSE)
vcpkg_install(sol2 sol2 TRUE)
list(APPEND LIBS lua sol2)
file(GLOB_RECURSE WOLF_SYSTEM_LUA_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/system/script/w_lua.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/script/w_lua.hpp"
)
list(APPEND SRCS
${WOLF_SYSTEM_LUA_SRC}
)
endif()
if (WOLF_SYSTEM_PYTHON)
find_package(Python3 REQUIRED COMPONENTS Development)
find_package(Boost REQUIRED COMPONENTS python${Python3_VERSION_MAJOR}${Python3_VERSION_MINOR})
file(GLOB_RECURSE WOLF_SYSTEM_PYTHON_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/system/script/w_python.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/script/w_python.hpp"
)
list(APPEND SRCS
${WOLF_SYSTEM_PYTHON_SRC}
)
list(APPEND INCLUDES ${Python3_INCLUDE_DIRS})
list(APPEND LIBS Python3::Python Boost::python${Python3_VERSION_MAJOR}${Python3_VERSION_MINOR})
get_filename_component(PYTHON_HOME ${Python3_EXECUTABLE} DIRECTORY)
add_definitions(
-DBOOST_PYTHON_STATIC_LIB
-DPYTHON_HOME="${PYTHON_HOME}"
)
endif()
if (EMSCRIPTEN)
file (GLOB_RECURSE WOLF_SYSTEM_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/system/w_gametime.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/w_gametime.hpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/w_trace.hpp"
)
else()
file (GLOB_RECURSE WOLF_SYSTEM_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/system/getopt.h"
"${CMAKE_CURRENT_SOURCE_DIR}/system/w_gametime.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/w_gametime.hpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/w_leak_detector.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/w_leak_detector.hpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/w_process.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/w_process.hpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/w_time.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/w_time.hpp"
"${CMAKE_CURRENT_SOURCE_DIR}/system/w_trace.hpp"
)
endif()
file(GLOB_RECURSE WOLF_SYSTEM_TEST_SRC
"${CMAKE_CURRENT_SOURCE_DIR}/system/test/*"
)
list(APPEND SRCS
${WOLF_SYSTEM_SRC}
${WOLF_SYSTEM_TEST_SRC}
)
================================================
FILE: wolf/cmake/vcpkg.cmake
================================================
if(NOT DEFINED ENV{VCPKG_ROOT})
message(FATAL_ERROR "VCPKG_ROOT environment variable is not set.")
endif()
if(QT_IS_ANDROID_MULTI_ABI_EXTERNAL_PROJECT)
if(CMAKE_TOOLCHAIN_FILE MATCHES "android_x86_64")
set(vcpkg_triplet "x64-android")
elseif(CMAKE_TOOLCHAIN_FILE MATCHES "android_x86")
set(vcpkg_triplet "x86-android")
elseif(CMAKE_TOOLCHAIN_FILE MATCHES "android_arm64_v8a")
set(vcpkg_triplet "arm64-android")
elseif(CMAKE_TOOLCHAIN_FILE MATCHES "android_armv7")
set(vcpkg_triplet "arm-neon-android")
endif()
elseif(ANDROID_ABI)
if(ANDROID_ABI STREQUAL "x86_64")
set(vcpkg_triplet "x64-android")
elseif(ANDROID_ABI STREQUAL "x86")
set(vcpkg_triplet "x86-android")
elseif(ANDROID_ABI STREQUAL "arm64-v8a")
set(vcpkg_triplet "arm64-android")
elseif(ANDROID_ABI STREQUAL "armeabi-v7a")
set(vcpkg_triplet "arm-neon-android")
endif()
elseif(EMSCRIPTEN)
set(vcpkg_triplet "wasm32-emscripten")
else() # desktop
if(WIN32)
set(vcpkg_triplet "x64-windows")
elseif(APPLE)
set(vcpkg_triplet "x64-osx")
elseif(UNIX)
set(vcpkg_triplet "x64-linux")
endif()
endif()
set(CMAKE_TOOLCHAIN_FILE "$ENV{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake")
if (LIBRARY_TYPE STREQUAL "STATIC" AND NOT EMSCRIPTEN)
set(VCPKG_TARGET_TRIPLET ${vcpkg_triplet}-static CACHE STRING "vcpkg target triplet" FORCE)
else()
set(VCPKG_TARGET_TRIPLET ${vcpkg_triplet} CACHE STRING "vcpkg target triplet" FORCE)
endif()
include("$ENV{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake")
function(vcpkg_install PACKAGE PACKAGE_NAME WITH_CONFIG)
message(STATUS "finding ${PACKAGE}")
if (WITH_CONFIG)
find_package(${PACKAGE} CONFIG)
else()
find_package(${PACKAGE})
endif()
if(NOT ${PACKAGE}_FOUND)
message(STATUS "installing ${PACKAGE} via vcpkg")
execute_process(COMMAND vcpkg install ${PACKAGE_NAME} --triplet=${VCPKG_TARGET_TRIPLET})
if (WITH_CONFIG)
find_package(${PACKAGE} CONFIG REQUIRED)
else()
find_package(${PACKAGE} REQUIRED)
endif()
endif()
endfunction()
================================================
FILE: wolf/media/ffmpeg/w_av_config.cpp
================================================
#include "w_av_config.hpp"
using w_av_config = wolf::media::ffmpeg::w_av_config;
w_av_config::w_av_config(_In_ AVPixelFormat p_format, _In_ int p_width, _In_ int p_height,
_In_ int p_alignment) noexcept
: format(p_format), width(p_width), height(p_height), alignment(p_alignment) {}
w_av_config::w_av_config(_In_ int p_nb_channels, _In_ AVSampleFormat p_sample_fmts,
_In_ int p_sample_rate) noexcept
: sample_rate(p_sample_rate), sample_fmts(p_sample_fmts), nb_channels(p_nb_channels) {}
int w_av_config::get_required_video_buffer_size() const noexcept {
return av_image_get_buffer_size(this->format, this->width, this->height, this->alignment);
}
================================================
FILE: wolf/media/ffmpeg/w_av_config.hpp
================================================
/*
Project: Wolf Engine. Copyright 2014-2023 Pooya Eimandar
https://github.com/WolfEngine/WolfEngine
*/
#ifdef WOLF_MEDIA_FFMPEG
#pragma once
#include <wolf/wolf.hpp>
extern "C" {
#include <libavformat/avformat.h>
#include <libavutil/imgutils.h>
}
namespace wolf::media::ffmpeg {
class w_av_config {
public:
#pragma region Constructors /Destructor
// default constructor
W_API w_av_config() noexcept = default;
// constructor for av video format
W_API w_av_config(_In_ AVPixelFormat p_format, _In_ int p_width, _In_ int p_height,
_In_ int p_alignment = 1) noexcept;
// constructor for av audio format
W_API w_av_config(_In_ int p_nb_channels, _In_ AVSampleFormat p_sample_fmts,
_In_ int p_sample_rate) noexcept;
// destructor
W_API virtual ~w_av_config() noexcept = default;
// move constructor.
W_API w_av_config(w_av_config &&p_other) noexcept = default;
// move assignment operator.
W_API w_av_config &operator=(w_av_config &&p_other) noexcept = default;
// copy constructor
w_av_config(const w_av_config &p_other) noexcept = default;
// copy assignment operator
w_av_config &operator=(const w_av_config &p_other) noexcept = default;
#pragma endregion
/**
* @returns the required buffer size for video frame
*/
W_API int get_required_video_buffer_size() const noexcept;
// the format of av frame
AVPixelFormat format = AVPixelFormat::AV_PIX_FMT_NONE;
// the width of av frame
int width = 0;
// the height of av frame
int height = 0;
// data alignment
int alignment = 0;
// the sample rate of the audio
int sample_rate = 0;
// the sample format of the audio
AVSampleFormat sample_fmts = AVSampleFormat::AV_SAMPLE_FMT_NONE;
// number of channels
int nb_channels = 0;
};
} // namespace wolf::media::ffmpeg
#endif // WOLF_MEDIA_FFMPEG
================================================
FILE: wolf/media/ffmpeg/w_av_format.cpp
================================================
#ifdef WOLF_MEDIA_FFMPEG
#include "w_av_format.hpp"
#include "w_av_frame.hpp"
using w_av_format = wolf::media::ffmpeg::w_av_format;
w_av_format::w_av_format() noexcept
: _stream_buffer(nullptr), _fmt_ctx(nullptr), _io_ctx(nullptr) {}
void w_av_format::_release() noexcept {
if (this->_stream_buffer != nullptr) {
auto _ptr = this->_stream_buffer.get();
free(_ptr);
this->_stream_buffer = nullptr;
}
if (this->_fmt_ctx != nullptr) {
auto _ptr = this->_fmt_ctx.get();
avformat_close_input(&_ptr);
this->_stream_buffer = nullptr;
}
if (this->_io_ctx != nullptr) {
auto _ptr = this->_io_ctx.get();
av_free(_ptr);
this->_stream_buffer = nullptr;
}
}
static int s_read_packet(void *p_opaque, _Inout_ uint8_t *p_buf, _In_ int p_buf_size) {
auto _av_fmt = gsl::narrow_cast<w_av_format *>(p_opaque);
if (_av_fmt) {
if (_av_fmt->on_read_callback) {
return _av_fmt->on_read_callback(p_buf, p_buf_size);
}
}
return -1; // failed
}
boost::leaf::result<int> w_av_format::init(_In_ int p_stream_buf_size) noexcept {
_release();
// alloc a buffer for the stream
auto _ptr = gsl::narrow_cast<uint8_t *>(malloc(p_stream_buf_size));
if (_ptr == nullptr) {
// out of memory
return W_FAILURE(std::errc::not_enough_memory, "could not allocate memory for stream buffer");
}
this->_stream_buffer.reset(_ptr);
// get a AVContext stream
auto _io_ctx_ptr =
avio_alloc_context(this->_stream_buffer.get(), // buffer
p_stream_buf_size, // buffer size
0, // buffer is only readable - set to 1 for read/write
this, // use your specified data
s_read_packet, // function - reading Packets (see example)
nullptr, // function - write Packets
nullptr // function - seek to position in stream (see example)
);
if (_io_ctx_ptr == nullptr) {
// out of memory
return W_FAILURE(std::errc::not_enough_memory, "could not allocate io context");
}
this->_io_ctx.reset(_io_ctx_ptr);
// allocate a AVContext
auto _fmt_ctx_ptr = avformat_alloc_context();
if (_fmt_ctx_ptr == nullptr) {
// out of memory
return W_FAILURE(std::errc::not_enough_memory, "could not allocate avformat context");
}
this->_fmt_ctx.reset(_fmt_ctx_ptr);
// Set up the format context based on custom IO
this->_fmt_ctx->pb = _io_ctx_ptr;
this->_fmt_ctx->flags |= AVFMT_FLAG_CUSTOM_IO;
// open "file" (open our custom IO)
// empty string is where filename would go. doesn't matter since we aren't
// reading a file NULL params are format and demuxer settings, respectively
if (avformat_open_input(&_fmt_ctx_ptr, "", nullptr, nullptr) < 0) {
// error on opening input
return W_FAILURE(std::errc::not_enough_memory, "could not allocate io context");
}
// find the stream info
if (avformat_find_stream_info(_fmt_ctx_ptr, nullptr) < 0) {
// Error on finding stream info
return W_FAILURE(std::errc::operation_canceled, "could not get stream info");
}
// find best stream
const auto _ret =
av_find_best_stream(_fmt_ctx_ptr, AVMediaType::AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0);
if (_ret < 0) {
// Error on finding stream info
return W_FAILURE(std::errc::operation_canceled, "could not find best stream");
}
return 0;
}
uint8_t *w_av_format::get_io_ctx_buffer() const {
if (this->_io_ctx) {
return this->_io_ctx->buffer;
}
return nullptr;
}
int w_av_format::get_io_ctx_size() const {
if (this->_io_ctx) {
return this->_io_ctx->buffer_size;
}
return -1;
}
#endif // WOLF_MEDIA_FFMPEG
================================================
FILE: wolf/media/ffmpeg/w_av_format.hpp
================================================
/*
Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar
https://github.com/WolfEngine/WolfEngine
*/
#ifdef WOLF_MEDIA_FFMPEG
#pragma once
#include <wolf/wolf.hpp>
extern "C" {
#include <libavformat/avformat.h>
}
namespace wolf::media::ffmpeg {
class w_av_format {
public:
#pragma region Constructors /Destructor
W_API w_av_format() noexcept;
W_API ~w_av_format() noexcept { _release(); };
// move constructor.
W_API w_av_format(w_av_format &&p_other) noexcept = default;
// move assignment operator.
W_API w_av_format &operator=(w_av_format &&p_other) noexcept = default;
#pragma endregion
boost::leaf::result<int> init(_In_ int p_stream_buf_size = 32'767) noexcept;
uint8_t *get_io_ctx_buffer() const;
int get_io_ctx_size() const;
std::function<int(_Inout_ uint8_t * /*p_buf*/, _In_ int /*p_buf_size*/)> on_read_callback;
private:
// copy constructor.
w_av_format(const w_av_format &) = delete;
// copy assignment operator.
w_av_format &operator=(const w_av_format &) = delete;
// release
void _release() noexcept;
std::unique_ptr<uint8_t[]> _stream_buffer = nullptr;
std::unique_ptr<AVFormatContext> _fmt_ctx = nullptr;
std::unique_ptr<AVIOContext> _io_ctx = nullptr;
};
} // namespace wolf::media::ffmpeg
#endif // WOLF_MEDIA_FFMPEG
================================================
FILE: wolf/media/ffmpeg/w_av_frame.cpp
================================================
#ifdef WOLF_MEDIA_FFMPEG
#include "w_av_frame.hpp"
#include "w_ffmpeg_ctx.hpp"
extern "C" {
#include <libavutil/imgutils.h>
#include <libswscale/swscale.h>
#include <libswresample/swresample.h>
}
#ifdef WOLF_MEDIA_STB
#include <stb_image.h>
#include <stb_image_write.h>
#endif //WOLF_MEDIA_STB
using w_av_frame = wolf::media::ffmpeg::w_av_frame;
using w_av_config = wolf::media::ffmpeg::w_av_config;
w_av_frame::w_av_frame(_In_ w_av_config &&p_config) noexcept : _config(std::move(p_config)) {}
void w_av_frame::_release() noexcept {
if (this->_av_frame != nullptr) {
av_frame_free(&this->_av_frame);
if (this->_config.nb_channels > 0) {
av_channel_layout_uninit(&this->_av_frame->ch_layout);
}
}
}
void w_av_frame::_move(w_av_frame &&p_other) noexcept {
if (this == &p_other) {
return;
}
this->_av_frame = std::exchange(p_other._av_frame, nullptr);
this->_config = std::move(p_other._config);
this->_data = std::move(p_other._data);
}
boost::leaf::result<int> w_av_frame::init() noexcept {
_release();
// allocate memory for AVFrame
this->_av_frame = av_frame_alloc();
if (this->_av_frame == nullptr) {
return W_FAILURE(std::errc::not_enough_memory, "could not allocate memory for AVFrame");
}
// set audio
this->_av_frame->sample_rate = this->_config.sample_rate;
if (this->_config.nb_channels > 0) {
av_channel_layout_default(&this->_av_frame->ch_layout, this->_config.nb_channels);
}
// set video
this->_av_frame->format = gsl::narrow_cast<int>(this->_config.format);
this->_av_frame->width = this->_config.width;
this->_av_frame->height = this->_config.height;
return 0;
}
boost::leaf::result<int> w_av_frame::set_video_frame(
_Inout_ std::vector<uint8_t> &&p_data) noexcept {
const auto _width = this->_config.width;
const auto _height = this->_config.height;
const auto _alignment = this->_config.alignment;
// check for width and height
if (_width <= 0 || _height <= 0) {
return W_FAILURE(std::errc::invalid_argument, "width or height of w_av_frame is zero");
}
// move the owenership of data to buffer
this->_data = std::forward<std::vector<uint8_t> &&>(p_data);
const auto _buffer_size = this->_config.get_required_video_buffer_size();
if (this->_data.empty()) {
this->_data.resize(_buffer_size, 0);
}
// if size does not fit
if (this->_data.size() != _buffer_size) {
return W_FAILURE(std::errc::invalid_argument,
wolf::format("w_av_frame video buffer size is expected {} but is {}",
_buffer_size, this->_data.size()));
}
const auto _ret = av_image_fill_arrays(this->_av_frame->data, this->_av_frame->linesize,
gsl::narrow_cast<const uint8_t *>(this->_data.data()),
this->_config.format, this->_av_frame->width,
this->_av_frame->height, _alignment);
if (_ret < 0) {
return W_FAILURE(std::errc::operation_canceled, "av_image_fill_arrays failed");
}
return _ret;
}
void w_av_frame::set_pts(_In_ int64_t p_pts) noexcept { this->_av_frame->pts = p_pts; }
std::tuple<uint8_t **, int> w_av_frame::get() const noexcept {
if (this->_av_frame) {
auto _buffer_size =
av_image_get_buffer_size(gsl::narrow_cast<AVPixelFormat>(this->_av_frame->format),
this->_av_frame->width, this->_av_frame->height, 4);
return std::make_tuple(this->_av_frame->data, _buffer_size);
}
return std::make_tuple(nullptr, 0);
}
w_av_config w_av_frame::get_config() const noexcept { return this->_config; }
boost::leaf::result<w_av_frame> w_av_frame::convert_audio(_In_ w_av_config &&p_dst_config) {
auto _ret = 0;
SwrContext *swr = nullptr;
auto _dst_frame = w_av_frame(std::move(p_dst_config));
_dst_frame.init();
DEFER {
if (_ret != S_OK) {
if (swr) {
if (swr_is_initialized(swr)) {
swr_close(swr);
}
swr_free(&swr);
}
}
});
swr_alloc_set_opts2(&swr, &this->_channel_layout, p_dst_config.sample_fmts,
p_dst_config.sample_rate, &this->_av_frame->ch_layout,
gsl::narrow_cast<AVSampleFormat>(this->_av_frame->format),
this->_av_frame->sample_rate, 0, nullptr);
if (swr == nullptr) {
_ret = -1;
return W_FAILURE(std::errc::operation_canceled, "could not create audio SwrContext");
}
_ret = swr_init(swr);
if (_ret < 0) {
return W_FAILURE(std::errc::operation_canceled, "could not initialize audio SwrContext");
}
// get number of samples
auto _sample_rate = gsl::narrow_cast<int64_t>(this->_av_frame->sample_rate);
auto _delay = swr_get_delay(swr, _sample_rate);
const auto _rescale_rnd =
av_rescale_rnd(_delay + _sample_rate, gsl::narrow_cast<int64_t>(p_dst_config.sample_rate),
_sample_rate, AV_ROUND_UP);
_dst_frame._av_frame->nb_samples = gsl::narrow_cast<int>(_rescale_rnd);
auto size = av_samples_alloc(gsl::narrow_cast<uint8_t **>(&_dst_frame._av_frame->data[0]),
&_dst_frame._av_frame->linesize[0],
this->_channel_layout.nb_channels, _dst_frame._config.nb_channels,
gsl::narrow_cast<AVSampleFormat>(p_dst_config.sample_fmts), 1);
if (size < 0) {
_ret = -1;
return W_FAILURE(std::errc::operation_canceled,
"could not allocate memory for buffer of audio");
}
/* convert to destination format */
size = swr_convert(swr, gsl::narrow_cast<uint8_t **>(&_dst_frame._av_frame->data[0]),
_dst_frame._av_frame->nb_samples,
(const uint8_t **)(&this->_av_frame->data[0]), this->_av_frame->nb_samples);
if (size < 0) {
_ret = -1;
return W_FAILURE(std::errc::operation_canceled, "error while audio converting\n");
}
const auto _buffer_size = av_samples_get_buffer_size(&_dst_frame._av_frame->linesize[0],
_dst_frame._av_frame->ch_layout.nb_channels,
size, p_dst_config.sample_fmts, 1);
if (_buffer_size < 0) {
_ret = -1;
return W_FAILURE(std::errc::operation_canceled, "could not get sample buffer size\n");
}
return _dst_frame;
}
boost::leaf::result<w_av_frame> w_av_frame::convert_video(_In_ w_av_config &&p_dst_config) {
// create a buffer and dst frame
auto _video_buffer = std::vector<uint8_t>();
auto _dst_frame = w_av_frame(std::move(p_dst_config));
BOOST_LEAF_CHECK(_dst_frame.init());
BOOST_LEAF_CHECK(_dst_frame.set_video_frame(std::move(_video_buffer)));
auto *_context = sws_getContext(
this->_config.width, this->_config.height, this->_config.format, _dst_frame._config.width,
_dst_frame._config.height, _dst_frame._config.format, SWS_BICUBIC, nullptr, nullptr, nullptr);
if (_context == nullptr) {
return W_FAILURE(std::errc::not_enough_memory, "could not create sws context");
}
auto _dst_frame_nn = gsl::not_null<AVFrame *>(_dst_frame._av_frame);
const auto _height =
sws_scale(_context, gsl::narrow_cast<const uint8_t *const *>(this->_av_frame->data),
gsl::narrow_cast<const int *>(this->_av_frame->linesize), 0, this->_config.height,
gsl::narrow_cast<uint8_t *const *>(_dst_frame_nn->data),
gsl::narrow_cast<const int *>(_dst_frame_nn->linesize));
// free context
sws_freeContext(_context);
if (_height < 0) {
return W_FAILURE(
std::errc::invalid_argument,
"w_av_frame sws_scale failed because: \"" + w_ffmpeg_ctx::get_av_error_str(_height) + "\"");
}
return _dst_frame;
}
boost::leaf::result<w_av_frame> w_av_frame::load_video_frame_from_img_file(
_In_ const std::filesystem::path &p_path, _In_ AVPixelFormat p_pixel_fmt) {
#ifdef WOLF_MEDIA_STB
// width, height, comp
int _width = 0;
int _height = 0;
int _comp = 0;
const auto _path = p_path.string();
if (!std::filesystem::exists(p_path)) {
return W_FAILURE(std::errc::invalid_argument, " path not exist for av_frame" + _path);
}
auto *_raw_img_data = stbi_load(_path.c_str(), &_width, &_height, &_comp, 0);
if (_raw_img_data == nullptr) {
return W_FAILURE(std::errc::invalid_argument, "could not load image file " + _path);
}
auto _len = gsl::narrow_cast<size_t>(_width * _height * _comp);
const auto _raw_img_data_span = gsl::span(_raw_img_data, _raw_img_data + _len);
auto _raw_img_data_vec =
std::vector<uint8_t>(_raw_img_data_span.begin(), _raw_img_data_span.end());
free(_raw_img_data);
auto _src_config = w_av_config(p_pixel_fmt, _width, _height);
// create an av_frame from image raw data
auto _src_frame = w_av_frame(std::move(_src_config));
BOOST_LEAF_CHECK(_src_frame.init());
BOOST_LEAF_CHECK(_src_frame.set_video_frame(std::move(_raw_img_data_vec)));
return _src_frame;
#else
return W_FAILURE(std::errc::not_supported, "WOLF_MEDIA_STB not defined");
#endif
}
boost::leaf::result<int> w_av_frame::save_video_frame_to_img_file(
_In_ const std::filesystem::path &p_path, int p_quality) noexcept {
try {
#ifdef WOLF_MEDIA_STB
if (this->_av_frame == nullptr || this->_av_frame->width == 0 || this->_av_frame->height == 0) {
return W_FAILURE(std::errc::invalid_argument, "bad parameters for avframe");
}
const auto _path = p_path.string();
auto _ext = p_path.extension().string();
std::transform(_ext.cbegin(), _ext.cend(), _ext.begin(), ::tolower);
const auto _comp = this->_av_frame->linesize[0] / this->_av_frame->width;
if (_ext == ".bmp") {
return stbi_write_bmp(_path.c_str(), this->_config.width, this->_config.height, _comp,
this->_av_frame->data[0]);
}
if (_ext == ".png") {
return stbi_write_png(_path.c_str(), this->_config.width, this->_config.height, _comp,
this->_av_frame->data[0], this->_av_frame->linesize[0]);
}
if (_ext == ".jpg" || _ext == ".jpeg") {
return stbi_write_jpg(_path.c_str(), this->_config.width, this->_config.height, _comp,
this->_av_frame->data[0], p_quality);
}
return W_FAILURE(std::errc::invalid_argument, "image format not supported for " + _path);
} catch (const std::exception &p_exc) {
return W_FAILURE(std::errc::invalid_argument,
"caught an esxception for " + std::string(p_exc.what()));
}
#else
return W_FAILURE(std::errc::not_supported, "WOLF_MEDIA_STB not defined");
#endif
}
#endif // WOLF_MEDIA_FFMPEG
================================================
FILE: wolf/media/ffmpeg/w_av_frame.hpp
================================================
/*
Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar
https://github.com/WolfEngine/WolfEngine
*/
#ifdef WOLF_MEDIA_FFMPEG
#pragma once
#include <wolf/wolf.hpp>
#include "w_av_config.hpp"
extern "C" {
#include <libavformat/avformat.h>
}
namespace wolf::media::ffmpeg {
class w_decoder;
class w_encoder;
class w_av_frame {
friend w_decoder;
friend w_encoder;
public:
/**
* constructor the av_frame with specific config
* @param p_config, the av audio config
*/
W_API explicit w_av_frame(_In_ w_av_config &&p_config) noexcept;
// destructor
W_API virtual ~w_av_frame() noexcept { _release(); }
// move constructor.
W_API w_av_frame(w_av_frame &&p_other) noexcept { _move(std::forward<w_av_frame &&>(p_other)); }
// move assignment operator.
W_API w_av_frame &operator=(w_av_frame &&p_other) noexcept {
_move(std::forward<w_av_frame &&>(p_other));
return *this;
}
/**
* initialize the avframe
* @returns zero on success
*/
W_API
boost::leaf::result<int> init() noexcept;
/**
* set the AVFrame data
* @param p_data, the initial data of ffmpeg AVFrame
* @param p_alignment, the alignment
* @returns zero on success
*/
W_API boost::leaf::result<int> set_video_frame(_Inout_ std::vector<uint8_t> &&p_data) noexcept;
/**
* set the AVFrame's pts
* @param p_pts, the pts data
* @returns void
*/
W_API void set_pts(_In_ int64_t p_pts) noexcept;
/**
* get data and linesize as a tuple
* @returns tuple<int*[8], int[8]>
*/
W_API
std::tuple<uint8_t **, int> get() const noexcept;
/**
* convert the ffmpeg video AVFrame
* @returns the converted instance of AVFrame
*/
W_API
boost::leaf::result<w_av_frame> convert_video(_In_ w_av_config &&p_dst_config);
/**
* convert the ffmpeg audio AVFrame
* @returns the converted instance of AVFrame
*/
W_API
boost::leaf::result<w_av_frame> convert_audio(_In_ w_av_config &&p_dst_config);
/**
* @returns config
*/
W_API w_av_config get_config() const noexcept;
#ifdef WOLF_MEDIA_STB
/**
* create w_av_frame from image file path
* @returns the AVFrame
*/
W_API
static boost::leaf::result<w_av_frame> load_video_frame_from_img_file(
_In_ const std::filesystem::path &p_path, _In_ AVPixelFormat p_pixel_fmt);
/**
* save to to the image file
* @param p_quality, quality will be used only for jpeg and is between 1 and
* 100
* @returns zero on success
*/
W_API
boost::leaf::result<int> save_video_frame_to_img_file(_In_ const std::filesystem::path &p_path,
int p_quality = 100) noexcept;
#endif
private:
// copy constructor.
w_av_frame(const w_av_frame &) = delete;
// copy assignment operator.
w_av_frame &operator=(const w_av_frame &) = delete;
// release
void _release() noexcept;
// move
void _move(w_av_frame &&p_other) noexcept;
// the channel layout of the audio
AVChannelLayout _channel_layout = {};
// the AVFrame config
w_av_config _config = {};
// the ffmpeg AVFrame
gsl::owner<AVFrame *> _av_frame = nullptr;
// the ffmpeg AVFrame data
std::vector<uint8_t> _data = {};
};
} // namespace wolf::media::ffmpeg
#endif // WOLF_MEDIA_FFMPEG
================================================
FILE: wolf/media/ffmpeg/w_av_packet.cpp
================================================
#ifdef WOLF_MEDIA_FFMPEG
#include "w_av_packet.hpp"
using w_av_packet = wolf::media::ffmpeg::w_av_packet;
w_av_packet::w_av_packet(_In_ AVPacket *p_av_packet) noexcept
: _packet(p_av_packet) {}
boost::leaf::result<int> w_av_packet::init() noexcept {
_release();
return init(nullptr, 0);
}
boost::leaf::result<int> w_av_packet::init(_Inout_ std::vector<uint8_t> &&p_data) noexcept {
_release();
this->_own_data = std::forward<std::vector<uint8_t> &&>(p_data);
return init(this->_own_data.data(), this->_own_data.size());
}
boost::leaf::result<int> w_av_packet::init(_In_ uint8_t *p_data, _In_ size_t p_data_len) noexcept {
this->_packet = av_packet_alloc();
if (this->_packet == nullptr) {
return W_FAILURE(std::errc::not_enough_memory, "could not allocate memory for av packet");
}
if (p_data && p_data_len) {
this->_packet->data = p_data;
this->_packet->size = gsl::narrow_cast<int>(p_data_len);
}
return 0;
}
void w_av_packet::unref() noexcept { av_packet_unref(this->_packet); }
uint8_t *w_av_packet::get_data() const noexcept {
return this->_packet->data;
}
int w_av_packet::get_size() const noexcept {
return this->_packet->size;
}
int w_av_packet::get_stream_index() const noexcept {
return this->_packet->stream_index;
}
void w_av_packet::_release() noexcept {
if (this->_packet != nullptr) {
av_packet_free(&this->_packet);
this->_packet = nullptr;
}
}
void w_av_packet::_move(_Inout_ w_av_packet &&p_other) noexcept {
if (this == &p_other) {
return;
}
this->_packet = std::exchange(p_other._packet, nullptr);
this->_own_data = std::move(p_other._own_data);
}
#endif // WOLF_MEDIA_FFMPEG
================================================
FILE: wolf/media/ffmpeg/w_av_packet.hpp
================================================
/*
Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar
https://github.com/WolfEngine/WolfEngine
*/
#ifdef WOLF_MEDIA_FFMPEG
#pragma once
#include <wolf/wolf.hpp>
extern "C" {
#include <libavcodec/packet.h>
}
namespace wolf::media::ffmpeg {
class w_decoder;
class w_encoder;
class w_ffmpeg;
class w_av_packet {
friend w_decoder;
friend w_encoder;
friend w_ffmpeg;
public:
// default construct an av_packet
W_API w_av_packet() noexcept = default;
/**
* construct an av_packet
*/
W_API explicit w_av_packet(_In_ AVPacket *p_av_packet) noexcept;
// move constructor.
W_API w_av_packet(w_av_packet &&p_other) noexcept {
_move(std::forward<w_av_packet &&>(p_other));
}
// move assignment operator.
W_API w_av_packet &operator=(w_av_packet &&p_other) noexcept {
_move(std::forward<w_av_packet &&>(p_other));
return *this;
}
// destructor
W_API virtual ~w_av_packet() noexcept { _release(); }
/**
* initialize the av_packet
* @returns zero on success
*/
W_API boost::leaf::result<int> init() noexcept;
/**
* initialize the av_packet from data
* @returns zero on success
*/
W_API boost::leaf::result<int> init(_In_ uint8_t *p_data, _In_ size_t p_data_len) noexcept;
/**
* initialize the av_packet
* @returns void
*/
W_API boost::leaf::result<int> init(_Inout_ std::vector<uint8_t> &&p_data) noexcept;
/**
* unref av_packet
*/
W_API void unref() noexcept;
// get packet data
W_API uint8_t *get_data() const noexcept;
// get packet size
W_API int get_size() const noexcept;
// get stream index
W_API int get_stream_index() const noexcept;
private:
// copy constructor.
w_av_packet(const w_av_packet &) = delete;
// copy assignment operator.
w_av_packet &operator=(const w_av_packet &) = delete;
// release the resources
void _release() noexcept;
// move the resources
void _move(_Inout_ w_av_packet && p_other) noexcept;
gsl::owner<AVPacket*> _packet = {};
std::vector<uint8_t> _own_data;
};
} // namespace wolf::media::ffmpeg
#endif
================================================
FILE: wolf/media/ffmpeg/w_decoder.cpp
================================================
#ifdef WOLF_MEDIA_FFMPEG
#include "w_decoder.hpp"
using w_decoder = wolf::media::ffmpeg::w_decoder;
boost::leaf::result<int> w_decoder::decode_frame_from_packet(_In_ AVPacket *p_packet,
_Inout_ w_av_frame &p_frame) {
// start decoding
auto _ret = avcodec_send_packet(this->ctx.codec_ctx, p_packet);
if (_ret < 0) {
return W_FAILURE(std::errc::operation_canceled,
"could not parse packet for decoding because:\"" +
w_ffmpeg_ctx::get_av_error_str(_ret) + "\"");
}
for (;;) {
_ret = avcodec_receive_frame(this->ctx.codec_ctx, p_frame._av_frame);
if (_ret == 0 || _ret == AVERROR(EAGAIN) || _ret == AVERROR_EOF) {
break;
}
if (_ret < 0) {
return W_FAILURE(std::errc::operation_canceled,
"error happened during the encoding because:\"" +
w_ffmpeg_ctx::get_av_error_str(_ret) + "\"");
}
}
return 0;
}
boost::leaf::result<int> w_decoder::decode(_In_ const w_av_packet &p_packet,
_Inout_ w_av_frame &p_frame,
_In_ bool p_flush) noexcept {
auto _dst_packet = w_av_packet();
_dst_packet.init();
for (;;) {
const auto _bytes =
av_parser_parse2(this->ctx.parser, this->ctx.codec_ctx, &_dst_packet._packet->data,
&_dst_packet._packet->size, p_packet._packet->data, p_packet._packet->size,
AV_NOPTS_VALUE, AV_NOPTS_VALUE, 0);
if (_bytes == 0) {
break;
}
if (_dst_packet._packet->size == 0) {
// try decode the inputed packet
BOOST_LEAF_CHECK(decode_frame_from_packet(p_packet._packet, p_frame));
} else {
if (_bytes < 0) {
return W_FAILURE(std::errc::operation_canceled, "could not parse packet for decoding");
}
p_packet._packet->data += _bytes;
p_packet._packet->size -= _bytes;
if (_dst_packet._packet->size > 0) {
BOOST_LEAF_CHECK(decode_frame_from_packet(_dst_packet._packet, p_frame));
}
}
}
if (p_flush) {
// flush the decoder
BOOST_LEAF_CHECK(decode_frame_from_packet(nullptr, p_frame));
}
return 0;
}
#endif // WOLF_MEDIA_FFMPEG
================================================
FILE: wolf/media/ffmpeg/w_decoder.hpp
================================================
/*
Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar
https://github.com/WolfEngine/WolfEngine
*/
#ifdef WOLF_MEDIA_FFMPEG
#pragma once
#include "w_av_frame.hpp"
#include "w_av_packet.hpp"
#include "w_ffmpeg_ctx.hpp"
#include <variant>
namespace wolf::media::ffmpeg {
class w_decoder {
public:
w_ffmpeg_ctx ctx = {};
// constructor
W_API w_decoder() = default;
// destructor
W_API virtual ~w_decoder() noexcept = default;
// move constructor.
W_API w_decoder(w_decoder &&p_other) noexcept = default;
// move assignment operator.
W_API w_decoder &operator=(w_decoder &&p_other) noexcept = default;
W_API boost::leaf::result<int> decode(_In_ const w_av_packet &p_packet,
_Inout_ w_av_frame &p_frame,
_In_ bool p_flush = false) noexcept;
private:
// copy constructor
w_decoder(const w_decoder &) = delete;
// copy operator
w_decoder &operator=(const w_decoder &) = delete;
boost::leaf::result<int> decode_frame_from_packet(_In_ AVPacket *p_packet,
_Inout_ w_av_frame &p_frame);
};
} // namespace wolf::media::ffmpeg
#endif // WOLF_MEDIA_FFMPEG
================================================
FILE: wolf/media/ffmpeg/w_encoder.cpp
================================================
#ifdef WOLF_MEDIA_FFMPEG
#include "w_encoder.hpp"
using w_encoder = wolf::media::ffmpeg::w_encoder;
using w_av_packet = wolf::media::ffmpeg::w_av_packet;
boost::leaf::result<int> w_encoder::_encode_frame_to_packet(
_In_ const AVFrame *p_frame, _Inout_ std::vector<uint8_t> &p_packet_data) const noexcept {
auto _packet = w_av_packet();
_packet.init();
for (;;) {
auto _ret = avcodec_send_frame(this->ctx.codec_ctx, p_frame);
if (_ret < 0) {
return W_FAILURE(std::errc::operation_canceled,
"failed to send the avframe for encoding because:\"" +
w_ffmpeg_ctx::get_av_error_str(_ret) + "\"");
}
for (;;) {
_ret = avcodec_receive_packet(this->ctx.codec_ctx, _packet._packet);
if (_ret == 0 || _ret == AVERROR_EOF) {
if (_packet._packet->size) {
std::copy(_packet._packet->data, _packet._packet->data + _packet._packet->size,
std::back_inserter(p_packet_data));
}
return 0;
}
_packet.unref();
if (_ret == AVERROR(EAGAIN)) {
break;
}
return W_FAILURE(std::errc::operation_canceled,
"error happened during the encoding because:\"" +
w_ffmpeg_ctx::get_av_error_str(_ret) + "\"");
}
}
return 0;
}
boost::leaf::result<int> w_encoder::encode(_In_ const w_av_frame &p_frame,
_Inout_ w_av_packet &p_packet,
_In_ bool p_flush) noexcept {
std::vector<uint8_t> _packet_data;
// encode frame to packet
BOOST_LEAF_CHECK(_encode_frame_to_packet(p_frame._av_frame, _packet_data));
if (p_flush) {
// flush
BOOST_LEAF_CHECK(_encode_frame_to_packet(nullptr, _packet_data));
}
// init packet
p_packet.init(std::move(_packet_data));
return {};
}
#endif // WOLF_MEDIA_FFMPEG
================================================
FILE: wolf/media/ffmpeg/w_encoder.hpp
================================================
/*
Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar
https://github.com/WolfEngine/WolfEngine
*/
#ifdef WOLF_MEDIA_FFMPEG
#pragma once
#include "w_av_frame.hpp"
#include "w_av_packet.hpp"
#include "w_ffmpeg_ctx.hpp"
#include <variant>
namespace wolf::media::ffmpeg {
class w_encoder {
public:
// constructor
W_API w_encoder() = default;
// destructor
W_API virtual ~w_encoder() noexcept = default;
// move constructor.
W_API w_encoder(w_encoder &&p_other) noexcept = default;
// move assignment operator.
W_API w_encoder &operator=(w_encoder &&p_other) noexcept = default;
W_API boost::leaf::result<int> encode(_In_ const w_av_frame &p_frame,
_Inout_ w_av_packet &p_packet,
_In_ bool p_flush = true) noexcept;
w_ffmpeg_ctx ctx = {};
private:
// copy constructor
w_encoder(const w_encoder &) = delete;
// copy operator
w_encoder &operator=(const w_encoder &) = delete;
boost::leaf::result<int>
_encode_frame_to_packet(_In_ const AVFrame *p_frame,
_Inout_ std::vector<uint8_t> &p_packet_data) const noexcept;
};
} // namespace wolf::media::ffmpeg
#endif // WOLF_MEDIA_FFMPEG
================================================
FILE: wolf/media/ffmpeg/w_ffmpeg.cpp
================================================
#ifdef WOLF_MEDIA_FFMPEG
#include "w_ffmpeg.hpp"
extern "C" {
#include <libavutil/opt.h>
}
using w_av_codec_opt = wolf::media::ffmpeg::w_av_codec_opt;
using w_av_config = wolf::media::ffmpeg::w_av_config;
using w_av_set_opt = wolf::media::ffmpeg::w_av_set_opt;
using w_decoder = wolf::media::ffmpeg::w_decoder;
using w_encoder = wolf::media::ffmpeg::w_encoder;
using w_ffmpeg = wolf::media::ffmpeg::w_ffmpeg;
using w_ffmpeg_ctx = wolf::media::ffmpeg::w_ffmpeg_ctx;
static boost::leaf::result<AVDictionary *> s_set_dict(
_In_ const std::vector<w_av_set_opt> &p_opts) noexcept {
AVDictionary *_dict = nullptr;
if (p_opts.empty()) {
return _dict;
}
auto _ret = av_dict_set(&_dict, nullptr, nullptr, 0);
if (_ret < 0) {
return W_FAILURE(std::errc::operation_canceled,
"could not allocate memory for AVDictionary because: " +
w_ffmpeg_ctx::get_av_error_str(_ret));
}
try {
for (const auto &_opt : p_opts) {
if (_opt.name.empty()) {
continue;
}
auto _name_str = _opt.name.c_str();
if (std::holds_alternative<int>(_opt.value)) {
// set an integer value
const auto _value = std::get<int>(_opt.value);
const auto _ret = av_dict_set_int(&_dict, _name_str, _value, 0);
if (_ret < 0) {
return W_FAILURE(std::errc::invalid_argument, "could not set int value for " + _opt.name +
":" + std::to_string(_value) +
" because " +
w_ffmpeg_ctx::get_av_error_str(_ret));
}
} else {
// set string value
const auto _value_str = &std::get<std::string>(_opt.value);
if (_value_str && !_value_str->empty()) {
const auto _ret = av_dict_set(&_dict, _opt.name.c_str(), _value_str->c_str(), 0);
if (_ret < 0) {
return W_FAILURE(std::errc::invalid_argument,
"could not set string value for " + _opt.name + ":" + *_value_str +
" because " + w_ffmpeg_ctx::get_av_error_str(_ret));
}
}
}
}
} catch (const std::exception &p_exc) {
return W_FAILURE(std::errc::operation_canceled,
"s_set_dict failed because: " + std::string(p_exc.what()));
}
return _dict;
}
static boost::leaf::result<int> s_create(_Inout_ w_ffmpeg_ctx &p_ctx,
_In_ const w_av_config &p_config,
_In_ const w_av_codec_opt &p_codec_opts,
_In_ const std::vector<w_av_set_opt> &p_opts) noexcept {
p_ctx.codec_ctx = avcodec_alloc_context3(p_ctx.codec);
if (p_ctx.codec_ctx == nullptr) {
return W_FAILURE(std::errc::not_enough_memory,
"could not allocate memory for avcodec context3");
}
bool _has_error = false;
DEFER {
if (_has_error && p_ctx.codec_ctx) {
auto _ptr = p_ctx.codec_ctx;
avcodec_free_context(&_ptr);
p_ctx.codec_ctx = nullptr;
}
});
p_ctx.codec_ctx->width = p_config.width;
p_ctx.codec_ctx->height = p_config.height;
p_ctx.codec_ctx->bit_rate = p_codec_opts.bitrate;
p_ctx.codec_ctx->time_base = AVRational{1, p_codec_opts.fps};
p_ctx.codec_ctx->framerate = AVRational{p_codec_opts.fps, 1};
p_ctx.codec_ctx->pix_fmt = p_config.format;
// set gop
if (p_codec_opts.gop >= 0) {
p_ctx.codec_ctx->gop_size = p_codec_opts.gop;
}
// set refs
if (p_codec_opts.refs >= 0) {
p_ctx.codec_ctx->refs = p_codec_opts.refs;
}
// set frames
if (p_codec_opts.max_b_frames >= 0) {
p_ctx.codec_ctx->max_b_frames = p_codec_opts.max_b_frames;
}
// set thread numbers
if (p_codec_opts.thread_count >= 0) {
p_ctx.codec_ctx->thread_count = p_codec_opts.thread_count;
}
// set level
if (p_codec_opts.level >= 0) {
p_ctx.codec_ctx->level = p_codec_opts.level;
}
// set flags
if (p_ctx.codec_ctx->flags & AVFMT_GLOBALHEADER) {
p_ctx.codec_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
}
try {
for (const auto &_opt : p_opts) {
if (_opt.name.empty()) {
continue;
}
auto _name_str = _opt.name.c_str();
if (std::holds_alternative<int>(_opt.value)) {
// set an integer value
const auto _value = std::get<int>(_opt.value);
const auto _ret = av_opt_set_int(p_ctx.codec_ctx->priv_data, _name_str, _value, 0);
if (_ret < 0) {
return W_FAILURE(std::errc::invalid_argument, "could not set int value for " + _opt.name +
":" + std::to_string(_value) +
" because " +
w_ffmpeg_ctx::get_av_error_str(_ret));
}
} else if (std::holds_alternative<double>(_opt.value)) {
// set double value
const auto _value = std::get<int>(_opt.value);
const auto _ret = av_opt_set_double(p_ctx.codec_ctx->priv_data, _name_str, _value, 0);
if (_ret < 0) {
return W_FAILURE(std::errc::invalid_argument, "could not set double value for " +
_opt.name + ":" +
std::to_string(_value) + " because " +
w_ffmpeg_ctx::get_av_error_str(_ret));
}
} else {
// set string value
const auto _value_str = &std::get<std::string>(_opt.value);
if (_value_str && !_value_str->empty()) {
const auto _ret =
av_opt_set(p_ctx.codec_ctx->priv_data, _opt.name.c_str(), _value_str->c_str(), 0);
if (_ret < 0) {
return W_FAILURE(std::errc::invalid_argument,
"could not set string value for " + _opt.name + ":" + *_value_str +
" because " + w_ffmpeg_ctx::get_av_error_str(_ret));
}
}
}
}
} catch (const std::exception &p_exc) {
return W_FAILURE(std::errc::operation_canceled,
"could not set av option because: " + std::string(p_exc.what()));
}
// open avcodec
const auto _ret = avcodec_open2(p_ctx.codec_ctx, p_ctx.codec_ctx->codec, nullptr);
if (_ret < 0) {
return W_FAILURE(std::errc::operation_canceled,
"could not open avcodec because " + w_ffmpeg_ctx::get_av_error_str(_ret));
}
return 0;
}
boost::leaf::result<w_encoder> w_ffmpeg::create_encoder(
_In_ const w_av_config &p_config, _In_ AVCodecID p_id, _In_ const w_av_codec_opt &p_codec_opts,
_In_ const std::vector<w_av_set_opt> &p_opts) noexcept {
w_encoder _encoder = {};
_encoder.ctx.codec = avcodec_find_encoder(p_id);
if (_encoder.ctx.codec == nullptr) {
return W_FAILURE(std::errc::invalid_argument,
"could not find encoder codec id: " + std::to_string(p_id));
}
BOOST_LEAF_CHECK(s_create(_encoder.ctx, p_config, p_codec_opts, p_opts));
return _encoder;
}
boost::leaf::result<w_encoder> w_ffmpeg::create_encoder(
_In_ const w_av_config &p_config, _In_ const std::string &p_id,
_In_ const w_av_codec_opt &p_codec_opts,
_In_ const std::vector<w_av_set_opt> &p_opts) noexcept {
w_encoder _encoder = {};
_encoder.ctx.codec = avcodec_find_encoder_by_name(p_id.c_str());
if (_encoder.ctx.codec == nullptr) {
return W_FAILURE(std::errc::invalid_argument, "could not find encoder codec id: " + p_id);
};
BOOST_LEAF_CHECK(s_create(_encoder.ctx, p_config, p_codec_opts, p_opts));
return _encoder;
}
boost::leaf::result<w_decoder> w_ffmpeg::create_decoder(
_In_ const w_av_config &p_config, _In_ const AVCodecID p_id,
_In_ const w_av_codec_opt &p_codec_opts,
_In_ const std::vector<w_av_set_opt> &p_opts) noexcept {
w_decoder _decoder = {};
_decoder.ctx.codec = avcodec_find_decoder(p_id);
if (_decoder.ctx.codec == nullptr) {
return W_FAILURE(std::errc::invalid_argument,
"could not find decoder codec id: " + std::to_string(p_id));
}
_decoder.ctx.parser = av_parser_init(_decoder.ctx.codec->id);
if (_decoder.ctx.parser == nullptr) {
return W_FAILURE(std::errc::invalid_argument,
"could not initialize parser for codec id: " + std::to_string(p_id));
}
BOOST_LEAF_CHECK(s_create(_decoder.ctx, p_config, p_codec_opts, p_opts));
return _decoder;
}
boost::leaf::result<w_decoder> w_ffmpeg::create_decoder(
_In_ const w_av_config &p_config, _In_ const std::string &p_id,
_In_ const w_av_codec_opt &p_codec_opts,
_In_ const std::vector<w_av_set_opt> &p_opts) noexcept {
w_decoder _decoder = {};
_decoder.ctx.codec = avcodec_find_decoder_by_name(p_id.c_str());
if (_decoder.ctx.codec == nullptr) {
return W_FAILURE(std::errc::invalid_argument, "could not find decoder codec id: " + p_id);
}
_decoder.ctx.parser = av_parser_init(_decoder.ctx.codec->id);
if (_decoder.ctx.parser == nullptr) {
return W_FAILURE(std::errc::invalid_argument,
"could not initialize parser for codec id: " + p_id);
}
BOOST_LEAF_CHECK(s_create(_decoder.ctx, p_config, p_codec_opts, p_opts));
return _decoder;
}
boost::leaf::result<int> w_ffmpeg::open_stream(
_In_ const std::string &p_url, _In_ const std::vector<w_av_set_opt> &p_opts,
_In_ const
std::function<bool(const w_av_packet & /*p_packet*/, const AVStream * /*p_audio_stream*/,
const AVStream * /*p_video_stream*/)> &p_on_frame) noexcept {
try {
// url is invalid
if (p_url.empty()) {
return W_FAILURE(std::errc::invalid_argument,
"could not allocate memory for av format context");
}
// allocate memory for avformat context
auto _fmt_ctx = avformat_alloc_context();
if (_fmt_ctx == nullptr) {
return W_FAILURE(std::errc::not_enough_memory,
"could not allocate memory for av format context from the url: " + p_url);
}
DEFER {
if (_fmt_ctx != nullptr) {
// free av format context
avformat_free_context(_fmt_ctx);
_fmt_ctx = nullptr;
}
});
// allocate memory for packet
auto _packet = w_av_packet();
BOOST_LEAF_CHECK(_packet.init());
// set options to av format context
BOOST_LEAF_AUTO(_dict, s_set_dict(p_opts));
// open input url
int _ret = avformat_open_input(&_fmt_ctx, p_url.c_str(), nullptr, &_dict);
if (_ret < 0) {
return W_FAILURE(std::errc::operation_canceled,
"could not open input url: " + p_url +
" because: " + w_ffmpeg_ctx::get_av_error_str(_ret));
}
// find the stream info
_ret = avformat_find_stream_info(_fmt_ctx, nullptr);
if (_ret < 0) {
return W_FAILURE(std::errc::operation_canceled,
"could not find stream info from the url: " + p_url);
}
if (_fmt_ctx->nb_streams == 0) {
return W_FAILURE(std::errc::operation_canceled, "missing stream for the url: " + p_url);
}
// search for audio & video stream
const auto _video_stream_index =
av_find_best_stream(_fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0);
const auto _audio_stream_index =
av_find_best_stream(_fmt_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, nullptr, 0);
if (_audio_stream_index < 0 && _video_stream_index < 0) {
return W_FAILURE(std::errc::operation_canceled,
"could not find any video or audio stream from the url: " + p_url);
}
AVStream *_audio_stream = nullptr;
AVStream *_video_stream = nullptr;
if (_audio_stream_index >= 0) {
_audio_stream = _fmt_ctx->streams[_audio_stream_index];
}
if (_video_stream_index >= 0) {
_video_stream = _fmt_ctx->streams[_video_stream_index];
}
for (;;) {
// unref packet
_packet.unref();
// read packet
_ret = av_read_frame(_fmt_ctx, _packet._packet);
if (_ret < 0) {
break;
}
if (p_on_frame && !p_on_frame(_packet, _audio_stream, _video_stream)) {
break;
}
}
return 0;
} catch (const std::exception &p_exc) {
return W_FAILURE(std::errc::operation_canceled,
"caught an exception: " + std::string(p_exc.what()));
}
}
#endif // WOLF_MEDIA_FFMPEG
================================================
FILE: wolf/media/ffmpeg/w_ffmpeg.hpp
================================================
/*
Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar
https://github.com/WolfEngine/WolfEngine
*/
#ifdef WOLF_MEDIA_FFMPEG
#pragma once
#include "w_av_packet.hpp"
#include "w_ffmpeg_ctx.hpp"
#include "w_encoder.hpp"
#include "w_decoder.hpp"
#include <variant>
#include <functional>
namespace wolf::media::ffmpeg {
struct w_av_codec_opt {
int64_t bitrate;
int fps;
int gop;
int level;
int max_b_frames;
int refs;
int thread_count;
};
struct w_av_set_opt {
// name of option
std::string name;
// value type
std::variant<int, double, std::string> value;
};
class w_ffmpeg {
public:
/*
* create ffmpeg encoder
* @param p_config, the video config
* @param p_id, the avcodec id
* @param p_codec_opts, the codec settings
* @param p_opts, the codec options
* @returns encoder object on success
*/
W_API static boost::leaf::result<w_encoder> create_encoder(
_In_ const w_av_config &p_config, _In_ AVCodecID p_id,
_In_ const w_av_codec_opt &p_codec_opts,
_In_ const std::vector<w_av_set_opt> &p_opts = {}) noexcept;
/*
* create ffmpeg encoder
* @param p_config, the video config
* @param p_id, the avcodec id in string (e.g. "libsvtav1", "libvpx")
* @param p_codec_opts, the codec settings
* @param p_opts, the codec options
* @returns encoder object on success
*/
W_API static boost::leaf::result<w_encoder> create_encoder(
_In_ const w_av_config &p_config, _In_ const std::string &p_id,
_In_ const w_av_codec_opt &p_codec_opts,
_In_ const std::vector<w_av_set_opt> &p_opts = {}) noexcept;
/*
* create ffmpeg decoder
* @param p_config, the avconfig
* @param p_id, the avcodec id in string (e.g. "libsvtav1", "libvpx")
* @param p_codec_opts, the codec options
* @param p_opts, the codec options
* @returns encoder object on success
*/
W_API static boost::leaf::result<w_decoder> create_decoder(
_In_ const w_av_config &p_config, _In_ AVCodecID p_id,
_In_ const w_av_codec_opt &p_codec_opts,
_In_ const std::vector<w_av_set_opt> &p_opts = {}) noexcept;
/*
* create ffmpeg decoder
* @param p_config, the avconfig
* @param p_id, the avcodec id in string (e.g. "libsvtav1", "libvpx")
* @param p_codec_opts, the codec settings
* @param p_opts, the codec options
* @returns encoder object on success
*/
W_API static boost::leaf::result<w_decoder> create_decoder(
_In_ const w_av_config &p_config, _In_ const std::string &p_id,
_In_ const w_av_codec_opt &p_codec_opts,
_In_ const std::vector<w_av_set_opt> &p_opts = {}) noexcept;
/*
* open and receive stream from file or url
* @param p_url, the url
* @param p_opts, the codec options
* @param p_on_frame, on frame data recieved callback
* @returns encoder object on success
*/
W_API static boost::leaf::result<int> open_stream(
_In_ const std::string &p_url, _In_ const std::vector<w_av_set_opt> &p_opts,
_In_ const
std::function<bool(const w_av_packet & /*p_packet*/, const AVStream * /*p_audio_stream*/,
const AVStream * /*p_video_stream*/)> &p_on_frame) noexcept;
};
} // namespace wolf::media::ffmpeg
#endif // WOLF_MEDIA_FFMPEG
================================================
FILE: wolf/media/ffmpeg/w_ffmpeg_ctx.cpp
================================================
#ifdef WOLF_MEDIA_FFMPEG
#include "w_ffmpeg_ctx.hpp"
using w_ffmpeg_ctx = wolf::media::ffmpeg::w_ffmpeg_ctx;
void w_ffmpeg_ctx::_release() noexcept {
if (this->parser != nullptr) {
av_parser_close(this->parser);
this->parser = nullptr;
}
if (this->codec_ctx != nullptr) {
if (avcodec_is_open(this->codec_ctx) > 0) {
avcodec_close(this->codec_ctx);
}
avcodec_free_context(&this->codec_ctx);
this->codec_ctx = nullptr;
}
}
void w_ffmpeg_ctx::_move(w_ffmpeg_ctx &&p_other) noexcept {
if (this == &p_other) {
return;
}
this->codec_ctx = std::exchange(p_other.codec_ctx, nullptr);
this->codec = std::exchange(p_other.codec, nullptr);
this->parser = std::exchange(p_other.parser, nullptr);
}
std::string w_ffmpeg_ctx::get_av_error_str(_In_ int p_error_code) noexcept {
std::array<char, W_MAX_PATH> _error[] = {'\0'};
try {
std::ignore = av_make_error_string(_error->data(), W_MAX_PATH, p_error_code);
return std::string(_error->data());
} catch (...) {
return std::string();
}
}
#endif // WOLF_MEDIA_FFMPEG
================================================
FILE: wolf/media/ffmpeg/w_ffmpeg_ctx.hpp
================================================
/*
Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar
https://github.com/WolfEngine/WolfEngine
*/
#ifdef WOLF_MEDIA_FFMPEG
#pragma once
#include <wolf.hpp>
extern "C" {
#include <libavcodec/avcodec.h>
}
namespace wolf::media::ffmpeg {
class w_ffmpeg_ctx {
public:
// constructor
W_API w_ffmpeg_ctx() = default;
// destructor
W_API virtual ~w_ffmpeg_ctx() noexcept { _release(); }
// move constructor.
W_API w_ffmpeg_ctx(w_ffmpeg_ctx &&p_other) noexcept {
_move(std::forward<w_ffmpeg_ctx &&>(p_other));
}
// move assignment operator.
W_API w_ffmpeg_ctx &operator=(w_ffmpeg_ctx &&p_other) noexcept {
_move(std::forward<w_ffmpeg_ctx &&>(p_other));
return *this;
}
W_API static std::string get_av_error_str(_In_ int p_error_code) noexcept;
gsl::owner<AVCodecContext*> codec_ctx = {};
gsl::owner<const AVCodec*> codec = {};
gsl::owner<AVCodecParserContext *> parser = {};
private:
// copy constructor
w_ffmpeg_ctx(const w_ffmpeg_ctx &) = delete;
// copy operator
w_ffmpeg_ctx &operator=(const w_ffmpeg_ctx &) = delete;
// release all resources
void _release() noexcept;
// move all resources
void _move(w_ffmpeg_ctx &&p_other) noexcept;
};
} // namespace wolf::media::ffmpeg
#endif // WOLF_MEDIA_FFMPEG
================================================
FILE: wolf/media/gst/audio/w_audio_format.cpp
================================================
#include "media/gst/audio/w_audio_format.hpp"
================================================
FILE: wolf/media/gst/audio/w_audio_format.hpp
================================================
#pragma once
#include <gst/audio/audio-format.h>
namespace wolf::media::gst {
/**
* enum same as GstAudioFormat.
*/
enum class w_audio_format
{
Unknonw = GST_AUDIO_FORMAT_UNKNOWN,
Encoded = GST_AUDIO_FORMAT_ENCODED,
S8 = GST_AUDIO_FORMAT_S8,
S16 = GST_AUDIO_FORMAT_S16,
S16LE = GST_AUDIO_FORMAT_S16LE,
S16BE = GST_AUDIO_FORMAT_S16BE,
S32 = GST_AUDIO_FORMAT_S32,
S32LE = GST_AUDIO_FORMAT_S32LE,
S32BE = GST_AUDIO_FORMAT_S32BE,
U8 = GST_AUDIO_FORMAT_U8,
U16 = GST_AUDIO_FORMAT_U16,
U16LE = GST_AUDIO_FORMAT_U16LE,
U16BE = GST_AUDIO_FORMAT_U16BE,
U32 = GST_AUDIO_FORMAT_U32,
U32LE = GST_AUDIO_FORMAT_U32LE,
U32BE = GST_AUDIO_FORMAT_U32BE,
F32 = GST_AUDIO_FORMAT_F32,
F32LE = GST_AUDIO_FORMAT_F32LE,
F32BE = GST_AUDIO_FORMAT_F32BE,
F64 = GST_AUDIO_FORMAT_F32,
F64LE = GST_AUDIO_FORMAT_F64LE,
F64BE = GST_AUDIO_FORMAT_F64BE
};
} // namespace wolf::media::gst
================================================
FILE: wolf/media/gst/audio/w_audio_info.cpp
================================================
#include "media/gst/audio/w_audio_info.hpp"
namespace wolf::media::gst {
auto w_audio_info::make(w_audio_format p_format, size_t p_channels, size_t p_samples)
-> boost::leaf::result<w_audio_info>
{
auto audioinfo_raw = gst_audio_info_new();
if (!audioinfo_raw) {
return W_FAILURE(std::errc::operation_canceled, "couldn't create audio info.");
}
auto format_raw = static_cast<GstAudioFormat>(p_format);
gst_audio_info_set_format(
audioinfo_raw,
format_raw,
gsl::narrow_cast<gint>(p_samples),
gsl::narrow_cast<gint>(p_channels),
nullptr
);
return w_audio_info(internal::w_raw_tag{}, audioinfo_raw);
}
} // namespace wolf::media::gst
================================================
FILE: wolf/media/gst/audio/w_audio_info.hpp
================================================
#pragma once
#include "wolf.hpp"
#include "media/gst/internal/w_common.hpp"
#include "media/gst/internal/w_wrapper.hpp"
#include "media/gst/core/w_caps.hpp"
#include "media/gst/audio/w_audio_format.hpp"
#include <gst/audio/audio-info.h>
#include <stdexcept>
#include <utility>
namespace wolf::media::gst {
/**
* wrapper of GstAudioInfo.
*/
class w_audio_info : public w_wrapper<w_audio_info, GstAudioInfo, void, gst_audio_info_free>
{
friend class internal::w_raw_access;
public:
/**
* @brief make a w_audio_info instance with given format and other info.
* @return a constructed audio info on success.
*/
[[nodiscard]] static auto make(w_audio_format p_format,
std::size_t p_channels = 2,
std::size_t p_samples = 44100)
-> boost::leaf::result<w_audio_info>;
/**
* @brief make a w_caps with info values.
*/
[[nodiscard]] w_caps to_caps()
{
auto caps_raw = gst_audio_info_to_caps(raw());
return internal::w_raw_access::from_raw<w_caps>(caps_raw);
}
/**
* @brief set sample rate.
* @param p_rate sample rate.
*/
void set_rate(std::size_t p_rate)
{
raw()->rate = gsl::narrow_cast<gint>(p_rate);
}
/**
* @brief set channels.
*/
void set_channels(std::size_t p_channels)
{
raw()->channels = gsl::narrow_cast<gint>(p_channels);
}
private:
w_audio_info(internal::w_raw_tag, GstAudioInfo* p_rawptr) noexcept
: w_wrapper(p_rawptr)
{}
};
} // namespace wolf::media::gst
================================================
FILE: wolf/media/gst/core/w_buffer.cpp
================================================
#include "media/gst/core/w_buffer.hpp"
#include "media/gst/internal/w_common.hpp"
namespace wolf::media::gst {
auto w_buffer::make(size_t p_size) -> boost::leaf::result<w_buffer>
{
auto buffer_raw = gst_buffer_new_and_alloc(p_size);
if (!buffer_raw) {
return W_FAILURE(std::errc::operation_canceled,
"couldn't create and allocate Buffer.");
}
return w_buffer(internal::w_raw_tag{}, buffer_raw);
}
} // namespace wolf::media::gst
================================================
FILE: wolf/media/gst/core/w_buffer.hpp
================================================
#pragma once
#include "wolf.hpp"
#include "media/gst/internal/w_wrapper.hpp"
#include <gst/gst.h>
#include <cstddef>
#include <stdexcept>
namespace wolf::media::gst {
/**
* @brief read/write map flags.
*/
enum class w_buffer_map_flags
{
Read = GST_MAP_READ,
Write = GST_MAP_WRITE,
ReadWrite = GST_MAP_READWRITE
};
class w_buffer;
/**
* helper class to map underlying data of w_buffer
* to an accessible memory region and unmap on destruction.
*/
class w_buffer_mapped_data
{
friend class w_buffer;
public:
w_buffer_mapped_data(const w_buffer_mapped_data&) = delete;
w_buffer_mapped_data(w_buffer_mapped_data&& p_other) noexcept
: _buffer(std::exchange(p_other._buffer, nullptr))
, _map(std::exchange(p_other._map, GstMapInfo{}))
{}
w_buffer_mapped_data& operator=(const w_buffer_mapped_data&) = delete;
w_buffer_mapped_data& operator=(w_buffer_mapped_data&& p_other) noexcept
{
std::swap(_buffer, p_other._buffer);
std::swap(_map, p_other._map);
return *this;
}
~w_buffer_mapped_data() noexcept
{
if (_buffer) {
gst_buffer_unmap(_buffer, &_map);
}
}
[[nodiscard]] std::size_t size() const noexcept { return _map.size; }
[[nodiscard]] guint8* begin() noexcept { return _map.data; }
[[nodiscard]] const guint8* begin() const noexcept { return _map.data; }
[[nodiscard]] guint8* end() noexcept { return _map.data + _map.size; }
[[nodiscard]] const guint8* end() const noexcept { return _map.data + _map.size; }
[[nodiscard]] guint8* data() noexcept { return _map.data; }
[[nodiscard]] const guint8* data() const noexcept { return _map.data; }
[[nodiscard]] guint8& operator[](std::size_t p_index) { return _map.data[p_index]; }
[[nodiscard]] const guint8& operator[](std::size_t p_index) const { return _map.data[p_index]; }
private:
w_buffer_mapped_data() noexcept {}
/**
* @brief helper method to map raw buffer to a normal accessible data region.
* @param p_buffer raw gstreamer buffer.
* @param p_flags read/write flags. defaults to read-write.
*/
[[nodiscard]] static auto make(internal::w_raw_tag,
GstBuffer* p_buffer,
w_buffer_map_flags p_flags = w_buffer_map_flags::ReadWrite)
-> boost::leaf::result<w_buffer_mapped_data>
{
auto ret = w_buffer_mapped_data();
auto flags_raw = static_cast<GstMapFlags>(p_flags);
if (!p_buffer || !gst_buffer_map(p_buffer, &ret._map, flags_raw)) {
return W_FAILURE(std::errc::operation_canceled, "couldn't map the buffer data.");
}
ret._buffer = p_buffer;
return ret;
}
GstBuffer* _buffer = nullptr;
GstMapInfo _map{};
};
/**
* wrapper of GstBuffer.
*/
class w_buffer : public w_wrapper<w_buffer, GstBuffer, void, gst_buffer_unref>
{
friend class internal::w_raw_access;
public:
/**
* @brief make a buffer with given size.
* @return buffer on success.
*/
[[nodiscard]] static auto make(std::size_t p_size) -> boost::leaf::result<w_buffer>;
/**
* @brief get timestamp in nanoseconds.
*/
[[nodiscard]] auto get_timestamp() const noexcept
{
return GST_BUFFER_TIMESTAMP(raw());
}
/**
* @brief get duration of this buffer's playback in nanoseconds.
*/
[[nodiscard]] auto get_duration() const noexcept
{
return raw()->duration;
}
/**
* @brief set timestamp in nanoseconds.
*/
void set_timestamp(std::size_t p_nanoseconds) noexcept
{
GST_BUFFER_TIMESTAMP(raw()) = static_cast<GstClockTime>(p_nanoseconds);
}
/**
* @brief set duration of this buffer's playback in nanoseconds.
*/
void set_duration(std::size_t p_nanoseconds) noexcept
{
raw()->duration = static_cast<GstClockTime>(p_nanoseconds);
}
/**
* @brief map to write-only data region.
*/
[[nodiscard]] auto map_data_write()
{
return w_buffer_mapped_data::make(
internal::w_raw_tag{},
raw(),
w_buffer_map_flags::Write
);
}
/**
* @brief map to read-only data region.
*/
[[nodiscard]] auto map_data_read() const
{
// NOTE unfortunately raw methods need pointer to non-const data, thus const_cast.
return w_buffer_mapped_data::make(
internal::w_raw_tag{},
const_cast<GstBuffer*>(raw()),
w_buffer_map_flags::Read
);
}
/**
* @brief map to readable-writable data region.
*/
[[nodiscard]] auto map_data()
{
return w_buffer_mapped_data::make(internal::w_raw_tag{}, raw());
}
/**
* @brief map to readable data region.
*/
[[nodiscard]] auto map_data() const
{
return map_data_read();
}
private:
explicit w_buffer(internal::w_raw_tag, GstBuffer* p_buffer) noexcept
: w_wrapper(p_buffer)
{}
};
} // namespace wolf::media::gst
================================================
FILE: wolf/media/gst/core/w_bus.cpp
================================================
#include "media/gst/core/w_bus.hpp"
================================================
FILE: wolf/media/gst/core/w_bus.hpp
================================================
#pragma once
#include "media/gst/core/w_signal_handler.hpp"
#include "media/gst/core/w_message.hpp"
#include "media/gst/internal/w_wrapper.hpp"
#include <gst/gst.h>
namespace wolf::media::gst {
/**
* @brief wrapper of GstBus. a bus to send messages to and notify listeners.
*/
class w_bus : public w_wrapper<w_bus, GstBus, void, gst_object_unref>
{
friend class internal::w_raw_access;
public:
w_bus() = delete;
w_bus(const w_bus&) = delete;
w_bus(w_bus&&) noexcept = default;
w_bus& operator=(const w_bus&) = delete;
w_bus& operator=(w_bus&&) noexcept = default;
~w_bus() noexcept
{
for (auto i = 0u; i < _watch_count; ++i) {
gst_bus_remove_signal_watch(raw());
}
}
/**
* @brief hook a listener handler on message signal.
* @param p_handler message listener handler. it will be passed `w_nonowning<w_message>`.
*/
template <typename F>
void hook_message(F&& p_handler)
{
ensure_watch();
constexpr auto invoker = +[](GstBus* /* p_self */, GstMessage* p_message, gpointer p_callee) {
auto& func = (*static_cast<decltype(_sighandlers.message)::handler_type*>(p_callee));
func(internal::w_raw_access::from_raw<w_nonowning<w_message>>(p_message));
};
_sighandlers.message.hook("message", invoker, std::forward<F>(p_handler));
}
/**
* @brief unhook the message listener handler on message signal.
*/
void unhook_message()
{
if (_sighandlers.message.unhook()) {
gst_bus_remove_signal_watch(raw());
--_watch_count;
}
}
private:
explicit w_bus(internal::w_raw_tag, GstBus* p_bus_raw) noexcept
: w_wrapper(p_bus_raw)
, _sighandlers(G_OBJECT(p_bus_raw))
{}
/**
* @brief make sure there is at least one signal watch.
*/
void ensure_watch() noexcept
{
if (_watch_count == 0) {
watch();
}
}
/**
* @brief add a signal watch so a listener can be added.
*/
void watch() noexcept
{
gst_bus_add_signal_watch(raw());
++_watch_count;
}
// signals
struct signal_handler_set {
w_signal_handler<w_nonowning<w_message>> message;
signal_handler_set(auto* p_rawptr) : message(p_rawptr) {}
} _sighandlers;
std::size_t _watch_count = 0;
};
} // namespace wolf::media::gst
================================================
FILE: wolf/media/gst/core/w_caps.cpp
================================================
#include "media/gst/core/w_caps.hpp"
================================================
FILE: wolf/media/gst/core/w_caps.hpp
================================================
#pragma once
#include "wolf.hpp"
#include "media/gst/internal/w_common.hpp"
#include "media/gst/internal/w_wrapper.hpp"
#include "media/gst/core/w_structure.hpp"
#include <gst/gst.h>
#include <string_view>
namespace wolf::media::gst {
/**
* @brief wrapper of GstCaps, gstreamer capabilities concept.
*/
class w_caps : public w_wrapper<w_caps, GstCaps, void, gst_caps_unref>
{
friend class internal::w_raw_access;
public:
/**
* @brief make an empty caps.
* @return an instance of w_caps on success.
*/
[[nodiscard]] static auto make() -> boost::leaf::result<w_caps>
{
auto caps_raw = gst_caps_new_empty();
if (!caps_raw) {
return W_FAILURE(std::errc::operation_canceled,
"couldn't make caps.");
}
return w_caps(internal::w_raw_tag{}, caps_raw);
}
/**
* @brief make a caps that acceps any kind of media.
* @return an instance of w_caps on success.
*/
[[nodiscard]] static auto make_any() -> boost::leaf::result<w_caps>
{
auto caps_raw = gst_caps_new_any();
if (!caps_raw) {
return W_FAILURE(std::errc::operation_canceled,
"couldn't make caps as any.");
}
return w_caps(internal::w_raw_tag{}, caps_raw);
}
/**
* @brief make an empty caps with media name.
* @return an instance of w_caps on success.
*/
[[nodiscard]] static auto make_simple(const char* p_media_name)
-> boost::leaf::result<w_caps>
{
auto caps_raw = gst_caps_new_empty_simple(p_media_name);
if (!caps_raw) {
return W_FAILURE(
std::errc::operation_canceled,
"couldn't make caps with given media name."
);
}
return w_caps(internal::w_raw_tag{}, caps_raw);
}
/**
* @brief add a capability structure.
* @param p_structure a capability structure.
*/
void add(w_structure&& p_structure)
{
gst_caps_append_structure(raw(), internal::w_raw_access::disown_raw(p_structure));
}
private:
w_caps(internal::w_raw_tag, GstCaps* p_caps_raw) noexcept
: w_wrapper(p_caps_raw)
{}
};
} // namespace wolf::media::gst
================================================
FILE: wolf/media/gst/core/w_clock.cpp
================================================
#include "media/gst/core/w_clock.hpp"
================================================
FILE: wolf/media/gst/core/w_clock.hpp
================================================
#pragma once
#include "media/gst/internal/w_wrapper.hpp"
#include <gst/gst.h>
namespace wolf::media::gst {
/**
* @brief wrapper of GstClock.
*
* @note this class is not user constructible. it's nonowning by default.
*/
class w_clock : public w_wrapper<w_clock, GstClock, void, +[](GstClock*){ /* do nothing */ }>
{
friend class internal::w_raw_access;
public:
w_clock() = delete;
/**
* @brief get time in nanoseconds.
* @return time in nanoseconds.
*/
std::size_t get_time() noexcept
{
return gst_clock_get_time(raw());
}
private:
explicit w_clock(internal::w_raw_tag, GstClock* p_clock_raw) noexcept
: w_wrapper(p_clock_raw)
{}
};
} // namespace wolf::media::gst
================================================
FILE: wolf/media/gst/core/w_element.cpp
================================================
#include "media/gst/core/w_element.hpp"
namespace wolf::media::gst {
auto w_element::make(const char *p_factory_name) -> boost::leaf::result<w_element>
{
auto element_factory_raw = gst_element_factory_find(p_factory_name);
if (!element_factory_raw) {
auto err_msg = wolf::format("couldn't find factory name: {}", p_factory_name);
return W_FAILURE(std::errc::operation_canceled, err_msg);
}
auto element_raw = gst_element_factory_create(element_factory_raw, nullptr);
if (!element_raw) {
auto err_msg = wolf::format(
"couldn't create the element with given factory name: {}",
p_factory_name
);
return W_FAILURE(std::errc::operation_canceled, err_msg);
}
if (G_IS_INITIALLY_UNOWNED(element_raw)) {
gst_object_ref_sink(element_raw);
}
return w_element(internal::w_raw_tag{}, element_raw);
}
} // namespace wolf::media::gst
================================================
FILE: wolf/media/gst/core/w_element.hpp
================================================
#pragma once
#include "wolf.hpp"
#include "media/gst/internal/w_common.hpp"
#include "media/gst/internal/w_wrapper.hpp"
#include "media/gst/core/w_pad.hpp"
#include "media/gst/core/w_clock.hpp"
#include <gst/gst.h>
#include <stdexcept>
namespace wolf::media::gst {
/**
* @brief wrapper of GstElement, gstreamer elements process stream data.
*
* elements combine to make dataflow pipeline graphs (DAG)
* to process one or more media stream(s).
*/
class w_element : public w_wrapper<w_element, GstElement, void, gst_object_unref>
{
friend class internal::w_raw_access;
public:
/**
* @brief make an element by given factory name.
* @param p_factory_name element's factory name.
* @return an instance of element of given name on success.
*/
[[nodiscard]] static auto make(const char* p_factory_name)
-> boost::leaf::result<w_element>;
w_element(const w_element&) = delete;
w_element(w_element&&) noexcept = default;
w_element& operator=(const w_element&) = delete;
w_element& operator=(w_element&&) noexcept = default;
virtual ~w_element() = default;
/**
* @brief get a request=pad with given name.
*/
[[nodiscard]] auto request_pad(const char* p_pad_name)
-> boost::leaf::result<w_pad>
{
auto raw_pad = gst_element_request_pad_simple(raw(), p_pad_name);
if (!raw_pad) {
auto err_msg = wolf::format("request for pad `{}` failed.", p_pad_name);
return W_FAILURE(std::errc::operation_canceled, err_msg);
}
return internal::w_raw_access::from_raw<w_pad>(raw_pad);
}
/**
* @brief get an always=pad with given name.
*/
[[nodiscard]] auto always_pad(const char* p_pad_name)
-> boost::leaf::result<w_pad>
{
auto raw_pad = gst_element_get_static_pad(raw(), p_pad_name);
if (!raw_pad) {
auto err_msg = wolf::format("couldn't find always pad: `{}`", p_pad_name);
return W_FAILURE(std::errc::operation_canceled, err_msg);
}
return internal::w_raw_access::from_raw<w_pad>(raw_pad);
}
/**
* @brief get element's clock.
*/
w_nonowning<w_clock> clock() noexcept
{
return internal::w_raw_access::from_raw<w_nonowning<w_clock>>(raw()->clock);
}
private:
explicit w_element(internal::w_raw_tag, GstElement* p_element) noexcept
: w_wrapper(p_element)
{}
};
} // namespace wolf::media::gst
================================================
FILE: wolf/media/gst/core/w_element_factory.cpp
================================================
#include "media/gst/core/w_element_factory.hpp"
================================================
FILE: wolf/media/gst/core/w_element_factory.hpp
================================================
#pragma once
#include "media/gst/internal/w_common.hpp"
#include "media/gst/core/w_element.hpp"
#include <gst/gst.h>
#include <optional>
#include <utility>
#include <stdexcept>
namespace wolf::media::gst {
/**
* @brief gstreamer's element factory to create elements.
*/
class w_element_factory
{
public:
w_element_factory() = delete;
/**
* @brief make an element from given gstreamer launch command.
* @param p_launch_str a gstreamer lauch command.
*/
[[nodiscard]] static auto make_from_launch_str(const char* p_launch_str)
-> boost::leaf::result<w_element>
{
auto element_raw = gst_parse_launch(p_launch_str, nullptr);
if (!element_raw) {
return W_FAILURE(std::errc::operation_canceled,
"couldn't create element from launch string.");
}
return internal::w_raw_access::from_raw<w_element>(element_raw);
}
/**
* @brief make a an element of given factory name, with given element name.
* @param p_factory_name name of element module.
* @param p_element_name custom name for element to reference later. (nullable)
* @return an element on success.
*/
[[nodiscard]] static auto make_simple(const char* p_factory_name, const char* p_element_name)
-> boost::leaf::result<w_element>
{
auto element_raw = gst_element_factory_make(p_factory_name, p_element_name);
if (!element_raw) {
auto err_msg = wolf::format("couldn't create element with factory name: {}", p_factory_name);
return W_FAILURE(std::errc::operation_canceled, err_msg);
}
return internal::w_raw_access::from_raw<w_element>(element_raw);
}
};
} // namespace wolf::media::gst
================================================
FILE: wolf/media/gst/core/w_format.cpp
================================================
#include "media/gst/core/w_format.hpp"
================================================
FILE: wolf/media/gst/core/w_format.hpp
================================================
#pragma once
#include <gst/gst.h>
namespace wolf::media::gst {
/** wrapper of GstFormat */
enum class w_format
{
Undefined = GST_FORMAT_UNDEFINED,
Default = GST_FORMAT_DEFAULT,
Bytes = GST_FORMAT_BYTES,
Time = GST_FORMAT_TIME,
Buffers = GST_FORMAT_BUFFERS,
Percent = GST_FORMAT_PERCENT
};
} // namespace wolf::media::gst
================================================
FILE: wolf/media/gst/core/w_mainloop.cpp
================================================
#include "media/gst/core/w_mainloop.hpp"
================================================
FILE: wolf/media/gst/core/w_mainloop.hpp
================================================
#pragma once
#include "wolf.hpp"
#include "media/gst/internal/w_wrapper.hpp"
#include <gst/gst.h>
#include <stdexcept>
#include <functional>
#include <utility>
#include <vector>
namespace wolf::media::gst {
/**
* @brief wrapper of GMainLoop, GLib's mainloop/eventloop facility.
*/
class w_mainloop : public w_wrapper<w_mainloop, GMainLoop, void, g_main_loop_unref>
{
public:
/**
* @brief create a simple instance of mainloop.
* @return a w_mainloop instance on success.
*/
[[nodiscard]] static auto make() -> boost::leaf::result<w_mainloop>
{
auto main_loop_raw = g_main_loop_new(nullptr, false);
if (!main_loop_raw) {
return W_FAILURE(std::errc::operation_canceled,
"mainloop construction error.");
}
return w_mainloop(internal::w_raw_tag{}, main_loop_raw);
}
/**
* @brief add a callable to be called on event loop idle times.
* @param p_func callable to be called on idle times.
* @return a sourceid to remove it later.
* @note `p_func` must have a consistent lifetime and address
* until either being removed by `idle_remove` or the instance
* of this class be destructed.
*/
template <typename F>
std::size_t idle_add(F& p_func)
{
constexpr auto invoker = +[](F* p_funcptr) { (*p_funcptr)(); };
return g_idle_add(GSourceFunc(invoker), std::addressof(p_func));
}
bool idle_remove(std::size_t p_sourceid)
{
if (!p_sourceid) {
return false;
}
return g_source_remove(gsl::narrow_cast<int>(p_sourceid));
}
/**
* @brief run the main/event loop.
*/
void run()
{
g_main_loop_run(raw());
}
/**
* @brief stop the main/event loop.
*/
void stop()
{
g_main_loop_quit(raw());
}
private:
w_mainloop(internal::w_raw_tag, GMainLoop* p_main_loop_raw) noexcept
: w_wrapper(p_main_loop_raw)
{}
};
} // namespace wolf::media::gst
================================================
FILE: wolf/media/gst/core/w_message.cpp
================================================
#include "media/gst/core/w_message.hpp"
================================================
FILE: wolf/media/gst/core/w_message.hpp
================================================
#pragma once
#include "media/gst/internal/w_common.hpp"
#include "media/gst/internal/w_wrapper.hpp"
#include <gst/gst.h>
#include <utility>
namespace wolf::media::gst {
class w_message;
/** type of GstMessage */
enum class w_message_type : std::size_t
{
Unknown = 0,
EOS,
Error,
Warning,
Info
};
//- message structs
/** the unknown variant of GstMessage */
struct w_message_unknown {};
/** the end-of-stream variant of GstMessage */
struct w_message_eos {};
/** the error message variant of GstMessage */
struct w_message_error
{
friend class w_message;
public:
w_message_error() = delete;
w_message_error(const w_message_error&) = delete;
~w_message_error() noexcept
{
if (_error) {
g_clear_error(&_error);
}
if (_debug_info) {
g_free(_debug_info);
}
}
/**
* @brief print the error message to standard output.
*/
void print() const
{
g_printerr(
"Error received from element %s: %s\n",
GST_OBJECT_NAME(_msg->src),
_error->message
);
g_printerr(
"Debugging information: %s\n",
_debug_info ? _debug_info : "none"
);
}
private:
/**
* @brief parse the message to extract error info.
*/
explicit w_message_error(internal::w_raw_tag, GstMessage* p_msg_raw)
: _msg(p_msg_raw)
{
gst_message_parse_error(p_msg_raw, &_error, &_debug_info);
}
GstMessage* _msg = nullptr; //< non-owning.
GError* _error = nullptr;
gchar* _debug_info = nullptr;
};
/**
* @brief wrapper of GstMessage. gstreamer's ultimate message struct.
*
* there are so many different kinds and variants of message,
* and all are represented by w_message.
*
* for ease of use, there are helper message representative classes,
* which on visit the appropriate one will be created and passed to
* given visitor.
*/
class w_message : public w_wrapper<w_message, GstMessage, void, gst_message_unref>
{
friend class internal::w_raw_access;
public:
// not supported yet.
w_message() = delete;
// w_message_type type() const noexcept
// {
// return convert_message_type(GST_MESSAGE_TYPE(msg_));
// }
/**
* @brief visit the message based on its type as the helper representative type.
* @param p_visitor visitor to visit message variant.
*/
template <typename VisitorF>
auto visit(VisitorF&& p_visitor)
{
return raw_visit(std::forward<VisitorF>(p_visitor), raw());
}
private:
explicit w_message(internal::w_raw_tag, GstMessage* p_msg_raw)
: w_wrapper(p_msg_raw)
{}
/**
* @brief create and visit appropriate repr variant by given raw message and visitor.
* @param p_visitor visitor to visit message variant.
* @param p_msg_raw raw message pointer.
*/
template <typename VisitorF>
static auto raw_visit(VisitorF&& p_visitor, GstMessage* p_msg_raw)
{
switch (GST_MESSAGE_TYPE(p_msg_raw)) {
case GST_MESSAGE_EOS:
return std::forward<VisitorF>(w_message_eos{});
case GST_MESSAGE_ERROR:
return std::forward<VisitorF>(p_visitor)(
w_message_error(internal::w_raw_tag{}, p_msg_raw)
);
default: // GST_MESSAGE_UNKNOWN
return std::forward<VisitorF>(p_visitor)(w_message_unknown{});
}
}
};
} // namespace wolf::media::gst
================================================
FILE: wolf/media/gst/core/w_nonowning.cpp
================================================
#include "media/gst/core/w_nonowning.hpp"
================================================
FILE: wolf/media/gst/core/w_nonowning.hpp
================================================
#pragma once
#include "media/gst/internal/w_common.hpp"
#include <utility>
namespace wolf::media::gst {
/**
* @brief nonowning view of `T` pointing to same resource
* given to make nonowning view of. similar to std::string_view/std::span.
*
* it's for sharing things like element.clock() returning Clock instance,
* which the instance does not own the clock's lifetime, but
* points to same resource to keep track of.
*
* this class is wrapper acting as a pointer to an instance of `T`
* with shared resource beneath.
*
* @tparam T underlying type of nonowning view.
*
* @note make sure the given object lives longer than this nonowning view of it,
* or any access will be undefined behavior.
* similar to std::string_view or std::span.
*/
template <typename T>
class w_nonowning
{
friend class internal::w_raw_access;
using value_type = std::remove_cvref_t<T>;
public:
/**
* @brief implicit constructor from a value of wrapping type.
* @param p_value value to make nonowing view of.
*/
w_nonowning(value_type& p_value)
: w_nonowning(internal::w_raw_access::raw(p_value))
{}
w_nonowning(const w_nonowning&) = default;
w_nonowning(w_nonowning&&) noexcept = default;
w_nonowning& operator=(const w_nonowning&) = default;
w_nonowning& operator=(w_nonowning&&) noexcept = default;
~w_nonowning() noexcept
{
// disown raw resource before resource
// be released/free'ed by T's destructor.
internal::w_raw_access::disown_raw(_value);
}
value_type* operator->() noexcept { return std::addressof(_value); }
const value_type* operator->() const noexcept { return std::addressof(_value); }
value_type& operator*() noexcept { return _value; }
const value_type& operator*() const noexcept { return _value; }
private:
template <typename RawT>
w_nonowning(internal::w_raw_tag, RawT* p_rawptr) noexcept
: _value(internal::w_raw_access::from_raw<value_type>(p_rawptr))
{}
value_type _value;
};
} // namespace wolf::media::gst
================================================
FILE: wolf/media/gst/core/w_pad.cpp
================================================
#include "media/gst/core/w_pad.hpp"
================================================
FILE: wolf/media/gst/core/w_pad.hpp
================================================
#pragma once
#include "media/gst/internal/w_common.hpp"
#include "media/gst/internal/w_wrapper.hpp"
#include <gst/gst.h>
#include <utility>
namespace wolf::media::gst {
/** gstreamer pad availablity */
enum class w_availability
{
Always,
Request,
Sometimes
};
/**
* @brief wrapper of GstPad.
*
* each gstreamer element has source and/or sink pads,
* which they connect by to each other with.
*/
class w_pad : public w_wrapper<w_pad, GstPad, void, gst_object_unref>
{
friend class internal::w_raw_access;
public:
// so far nothing...
private:
explicit w_pad(internal::w_raw_tag, GstPad* p_pad) noexcept
: w_wrapper(p_pad)
{}
};
} // namespace wolf::media::gst
================================================
FILE: wolf/media/gst/core/w_pipeline.cpp
================================================
#include "media/gst/core/w_pipeline.hpp"
namespace wolf::media::gst {
auto w_pipeline::make(const char *p_name)
-> boost::leaf::result<w_pipeline>
{
auto pipeline_raw = gst_pipeline_new(p_name);
if (!pipeline_raw) {
return W_FAILURE(std::errc::operation_canceled,
wolf::format("couldn't create pipeline: {}", p_name));
}
return w_pipeline(internal::w_raw_tag{}, pipeline_raw);
}
auto w_pipeline::get_bus() -> boost::leaf::result<w_bus>
{
auto bus_raw = gst_element_get_bus(raw());
if (!bus_raw) {
return W_FAILURE(std::errc::operation_canceled,
"couldn't get pipeline's bus.");
}
return internal::w_raw_access::from_raw<w_bus>(bus_raw);
}
bool w_pipeline::bin(w_flow_path &p_flow)
{
for (auto& element : p_flow) {
if (!bin(*element)) {
return false;
}
}
return true;
}
bool w_pipeline::link(w_flow_path &p_flow)
{
auto* last = p_flow.first().get();
for (int i = 1; i < p_flow.size(); ++i) {
if (!link(*last, *p_flow[i])) {
return false;
}
last = p_flow[i].get();
}
return true;
}
} // namespace wolf::media::gst
================================================
FILE: wolf/media/gst/core/w_pipeline.hpp
================================================
#pragma once
#include "wolf.hpp"
#include "media/gst/w_flow.hpp"
#include "media/gst/core/w_element.hpp"
#include "media/gst/core/w_bus.hpp"
#include "media/gst/internal/w_wrapper.hpp"
#include <gst/gst.h>
#include <string_view>
#include <stdexcept>
namespace wolf::media::gst {
/**
* @brief wrapper of GstElement, providing gstreamer pipeline concept.
*/
class w_pipeline : public w_wrapper<w_pipeline, GstElement, void, gst_object_unref>
{
public:
/**
* @brief make an instance of pipeline with given name.
* @param p_name pipeline's name.
* @return an instance of pipeline on success.
*/
[[nodiscard]] static auto make(const char* p_name)
-> boost::leaf::result<w_pipeline>;
/**
* @brief get pipeline's bus.
*/
[[nodiscard]] auto get_bus() -> boost::leaf::result<w_bus>;
/**
* @brief add given elements to pipeline's bin.
* @param p_args pack of elements.
* @return boolean indicating success or failure.
*/
template <typename ...Args>
requires (sizeof...(Args) > 1)
bool bin(Args&& ...p_args)
{
return (true && ... && bin(std::forward<Args>(p_args)));
}
/**
* @brief add elements from given flow path to pipeline's bin.
* @param p_flow elements flow path.
* @return boolean indicating success or failure.
*/
bool bin(w_flow_path& p_flow);
/**
* @brief add given single element to pipeline's bin.
* @param p_element single element.
* @return boolean indicating success or failure.
*/
bool bin(w_element& p_element)
{
auto element_raw = internal::w_raw_access::raw(p_element);
p_element.parented();
return gst_bin_add(GST_BIN(raw()), element_raw);
}
/**
* @brief link a pack of given linkables (element or pad) together after each other.
* @param p_a source linkable to link with `p_b`.
* @param p_b sink linkable to link with `p_a`.
* @param p_rest pack of rest of linkables to be linked after `p_b` as source.
* @return boolean indicating success or failure.
*/
template <typename T, typename U, typename ...Rest>
bool link(T&& p_a, U&& p_b, Rest&& ...p_rest)
{
auto raw_a = internal::w_raw_access::raw(p_a);
auto raw_b = internal::w_raw_access::raw(p_b);
if (!gst_element_link(raw_a, raw_b)) {
return false;
}
if constexpr (sizeof...(Rest) > 0) {
return link(std::forward<U>(p_b), std::forward<Rest>(p_rest)...);
}
return true;
}
/**
* @brief link two elements.
* @param p_src source element.
* @param p_sink sink element.
* @return boolean indicating success or failure.
*/
bool link(w_element& p_src, w_element& p_sink)
{
return gst_element_link(
internal::w_raw_access::raw(p_src),
internal::w_raw_access::raw(p_sink)
);
}
/**
* @brief link a flow path's elements after each other.
* @param p_flow flow path set of elements.
* @return boolean indicating success or failure.
*/
bool li
gitextract_nyue42gt/
├── .dockerignore
├── .gitattributes
├── .github/
│ └── workflows/
│ ├── codeql.yml
│ └── msvc.yml
├── .gitignore
├── CHANGE_LOG.md
├── CMakeLists.txt
├── CMakePresets.json
├── CODE_OF_CONDUCT.md
├── LICENSE
├── README.md
├── TODO.md
├── coverage.bat
├── docker/
│ └── Dockerfile
├── docs/
│ ├── GCC.txt
│ ├── ProblemSolutions.txt
│ ├── git-commands.txt
│ ├── glslValidator.txt
│ ├── glslValidator_MoltenVK.txt
│ └── quic.md
├── manifest.manifest
├── wolf/
│ ├── .clang-format
│ ├── .clang-tidy
│ ├── .gitignore
│ ├── CMakeLists.txt
│ ├── DISABLE_ANALYSIS_BEGIN
│ ├── DISABLE_ANALYSIS_END
│ ├── cmake/
│ │ ├── media.cmake
│ │ ├── ml.cmake
│ │ ├── stream.cmake
│ │ ├── system.cmake
│ │ └── vcpkg.cmake
│ ├── media/
│ │ ├── ffmpeg/
│ │ │ ├── w_av_config.cpp
│ │ │ ├── w_av_config.hpp
│ │ │ ├── w_av_format.cpp
│ │ │ ├── w_av_format.hpp
│ │ │ ├── w_av_frame.cpp
│ │ │ ├── w_av_frame.hpp
│ │ │ ├── w_av_packet.cpp
│ │ │ ├── w_av_packet.hpp
│ │ │ ├── w_decoder.cpp
│ │ │ ├── w_decoder.hpp
│ │ │ ├── w_encoder.cpp
│ │ │ ├── w_encoder.hpp
│ │ │ ├── w_ffmpeg.cpp
│ │ │ ├── w_ffmpeg.hpp
│ │ │ ├── w_ffmpeg_ctx.cpp
│ │ │ └── w_ffmpeg_ctx.hpp
│ │ ├── gst/
│ │ │ ├── audio/
│ │ │ │ ├── w_audio_format.cpp
│ │ │ │ ├── w_audio_format.hpp
│ │ │ │ ├── w_audio_info.cpp
│ │ │ │ └── w_audio_info.hpp
│ │ │ ├── core/
│ │ │ │ ├── w_buffer.cpp
│ │ │ │ ├── w_buffer.hpp
│ │ │ │ ├── w_bus.cpp
│ │ │ │ ├── w_bus.hpp
│ │ │ │ ├── w_caps.cpp
│ │ │ │ ├── w_caps.hpp
│ │ │ │ ├── w_clock.cpp
│ │ │ │ ├── w_clock.hpp
│ │ │ │ ├── w_element.cpp
│ │ │ │ ├── w_element.hpp
│ │ │ │ ├── w_element_factory.cpp
│ │ │ │ ├── w_element_factory.hpp
│ │ │ │ ├── w_format.cpp
│ │ │ │ ├── w_format.hpp
│ │ │ │ ├── w_mainloop.cpp
│ │ │ │ ├── w_mainloop.hpp
│ │ │ │ ├── w_message.cpp
│ │ │ │ ├── w_message.hpp
│ │ │ │ ├── w_nonowning.cpp
│ │ │ │ ├── w_nonowning.hpp
│ │ │ │ ├── w_pad.cpp
│ │ │ │ ├── w_pad.hpp
│ │ │ │ ├── w_pipeline.cpp
│ │ │ │ ├── w_pipeline.hpp
│ │ │ │ ├── w_refptr.cpp
│ │ │ │ ├── w_refptr.hpp
│ │ │ │ ├── w_signal_handler.cpp
│ │ │ │ ├── w_signal_handler.hpp
│ │ │ │ ├── w_structure.cpp
│ │ │ │ └── w_structure.hpp
│ │ │ ├── elements/
│ │ │ │ ├── w_element_aacparse.cpp
│ │ │ │ ├── w_element_aacparse.hpp
│ │ │ │ ├── w_element_appsrc.cpp
│ │ │ │ ├── w_element_appsrc.hpp
│ │ │ │ ├── w_element_audioconvert.cpp
│ │ │ │ ├── w_element_audioconvert.hpp
│ │ │ │ ├── w_element_audioresample.cpp
│ │ │ │ ├── w_element_audioresample.hpp
│ │ │ │ ├── w_element_autovideosink.cpp
│ │ │ │ ├── w_element_autovideosink.hpp
│ │ │ │ ├── w_element_avencflv.cpp
│ │ │ │ ├── w_element_avencflv.hpp
│ │ │ │ ├── w_element_capsfilter.cpp
│ │ │ │ ├── w_element_capsfilter.hpp
│ │ │ │ ├── w_element_filesink.cpp
│ │ │ │ ├── w_element_filesink.hpp
│ │ │ │ ├── w_element_flvmux.cpp
│ │ │ │ ├── w_element_flvmux.hpp
│ │ │ │ ├── w_element_h264parse.cpp
│ │ │ │ ├── w_element_h264parse.hpp
│ │ │ │ ├── w_element_mp4mux.cpp
│ │ │ │ ├── w_element_mp4mux.hpp
│ │ │ │ ├── w_element_openh264enc.cpp
│ │ │ │ ├── w_element_openh264enc.hpp
│ │ │ │ ├── w_element_queue.cpp
│ │ │ │ ├── w_element_queue.hpp
│ │ │ │ ├── w_element_rtmpsink.cpp
│ │ │ │ ├── w_element_rtmpsink.hpp
│ │ │ │ ├── w_element_rtph264pay.cpp
│ │ │ │ ├── w_element_rtph264pay.hpp
│ │ │ │ ├── w_element_udpsink.cpp
│ │ │ │ ├── w_element_udpsink.hpp
│ │ │ │ ├── w_element_videoconvert.cpp
│ │ │ │ ├── w_element_videoconvert.hpp
│ │ │ │ ├── w_element_videoscale.cpp
│ │ │ │ ├── w_element_videoscale.hpp
│ │ │ │ ├── w_element_videotestsrc.cpp
│ │ │ │ ├── w_element_videotestsrc.hpp
│ │ │ │ ├── w_element_voaacenc.cpp
│ │ │ │ ├── w_element_voaacenc.hpp
│ │ │ │ ├── w_element_wasapisrc.cpp
│ │ │ │ ├── w_element_wasapisrc.hpp
│ │ │ │ ├── w_element_x264enc.cpp
│ │ │ │ └── w_element_x264enc.hpp
│ │ │ ├── internal/
│ │ │ │ ├── w_common.cpp
│ │ │ │ ├── w_common.hpp
│ │ │ │ ├── w_utils.cpp
│ │ │ │ ├── w_utils.hpp
│ │ │ │ ├── w_wrapper.cpp
│ │ │ │ └── w_wrapper.hpp
│ │ │ ├── video/
│ │ │ │ ├── w_video_format.cpp
│ │ │ │ ├── w_video_format.hpp
│ │ │ │ ├── w_video_info.cpp
│ │ │ │ └── w_video_info.hpp
│ │ │ ├── w_application.cpp
│ │ │ ├── w_application.hpp
│ │ │ ├── w_flow.cpp
│ │ │ └── w_flow.hpp
│ │ ├── test/
│ │ │ ├── avframe.hpp
│ │ │ ├── ffmpeg.hpp
│ │ │ ├── gstreamer.hpp
│ │ │ ├── image.hpp
│ │ │ └── openal.hpp
│ │ ├── w_image.cpp
│ │ ├── w_image.hpp
│ │ ├── w_image_data.cpp
│ │ ├── w_image_data.hpp
│ │ ├── w_openal.cpp
│ │ └── w_openal.hpp
│ ├── ml/
│ │ ├── nudity_detection/
│ │ │ ├── w_nudity_detection.cpp
│ │ │ └── w_nudity_detection.hpp
│ │ ├── referee_ocr/
│ │ │ ├── salieri.h
│ │ │ ├── w_image_processor.cpp
│ │ │ ├── w_image_processor.hpp
│ │ │ ├── w_ocr_engine.cpp
│ │ │ ├── w_ocr_engine.hpp
│ │ │ ├── w_read_video_frames.cpp
│ │ │ ├── w_read_video_frames.hpp
│ │ │ ├── w_referee.cpp
│ │ │ ├── w_referee.hpp
│ │ │ ├── w_soccer.cpp
│ │ │ ├── w_soccer.hpp
│ │ │ ├── w_utilities.cpp
│ │ │ └── w_utilities.hpp
│ │ ├── test/
│ │ │ ├── common_test_asset/
│ │ │ │ ├── soccer/
│ │ │ │ │ ├── .fill_stat_map
│ │ │ │ │ ├── .initial_match_result_struct
│ │ │ │ │ ├── .replace_team_names_with_most_similar_string
│ │ │ │ │ ├── .replace_team_names_with_most_similar_string_0_9
│ │ │ │ │ ├── .set_config
│ │ │ │ │ ├── .single_image_result_extraction
│ │ │ │ │ ├── .update_match_data
│ │ │ │ │ └── replace_team_names_with_most_similar_string.txt
│ │ │ │ └── utilities/
│ │ │ │ ├── .get_env_boolean
│ │ │ │ ├── .get_env_cv_rect
│ │ │ │ ├── .get_env_float
│ │ │ │ ├── .get_env_int
│ │ │ │ ├── .get_env_string
│ │ │ │ ├── .get_nearest_string_0_5
│ │ │ │ ├── .get_nearest_string_0_9
│ │ │ │ ├── .set_env
│ │ │ │ ├── get_nearest_string.txt
│ │ │ │ └── get_value_from_json_file_by_key.json
│ │ │ ├── w_image_processor_test.hpp
│ │ │ ├── w_ocr_engine_test.hpp
│ │ │ ├── w_referee_test.hpp
│ │ │ ├── w_soccer_test.hpp
│ │ │ └── w_utilities_test.hpp
│ │ ├── w_common.cpp
│ │ └── w_common.hpp
│ ├── protos/
│ │ └── raft.proto
│ ├── stream/
│ │ ├── grpc/
│ │ │ ├── w_grpc_client.cpp
│ │ │ ├── w_grpc_client.hpp
│ │ │ ├── w_grpc_server.cpp
│ │ │ └── w_grpc_server.hpp
│ │ ├── http/
│ │ │ ├── w_http_server.cpp
│ │ │ └── w_http_server.hpp
│ │ ├── janus/
│ │ │ ├── w_janus_api_emc.cpp
│ │ │ └── w_janus_api_emc.hpp
│ │ ├── quic/
│ │ │ ├── datatypes/
│ │ │ │ ├── common_flags.hpp
│ │ │ │ ├── w_address.cpp
│ │ │ │ ├── w_address.hpp
│ │ │ │ ├── w_alpn.hpp
│ │ │ │ ├── w_credential_config.cpp
│ │ │ │ ├── w_credential_config.hpp
│ │ │ │ ├── w_new_connection_info.cpp
│ │ │ │ ├── w_new_connection_info.hpp
│ │ │ │ ├── w_registration_config.cpp
│ │ │ │ ├── w_registration_config.hpp
│ │ │ │ ├── w_settings.cpp
│ │ │ │ ├── w_settings.hpp
│ │ │ │ ├── w_status.cpp
│ │ │ │ └── w_status.hpp
│ │ │ ├── events/
│ │ │ │ ├── w_connection_event.cpp
│ │ │ │ ├── w_connection_event.hpp
│ │ │ │ ├── w_listener_event.cpp
│ │ │ │ ├── w_listener_event.hpp
│ │ │ │ ├── w_stream_event.cpp
│ │ │ │ └── w_stream_event.hpp
│ │ │ ├── handles/
│ │ │ │ ├── w_configuration.cpp
│ │ │ │ ├── w_configuration.hpp
│ │ │ │ ├── w_connection.cpp
│ │ │ │ ├── w_connection.hpp
│ │ │ │ ├── w_listener.cpp
│ │ │ │ ├── w_listener.hpp
│ │ │ │ ├── w_registration.cpp
│ │ │ │ ├── w_registration.hpp
│ │ │ │ ├── w_stream.cpp
│ │ │ │ └── w_stream.hpp
│ │ │ ├── internal/
│ │ │ │ ├── common.cpp
│ │ │ │ ├── common.hpp
│ │ │ │ ├── w_msquic_api.cpp
│ │ │ │ └── w_msquic_api.hpp
│ │ │ ├── w_quic.cpp
│ │ │ ├── w_quic.hpp
│ │ │ ├── w_quic_client.cpp
│ │ │ ├── w_quic_client.hpp
│ │ │ ├── w_quic_server.cpp
│ │ │ └── w_quic_server.hpp
│ │ ├── rist/
│ │ │ ├── w_rist.cpp
│ │ │ ├── w_rist.hpp
│ │ │ ├── w_rist_data_block.cpp
│ │ │ └── w_rist_data_block.hpp
│ │ └── test/
│ │ ├── ffmpeg_stream.hpp
│ │ ├── grpc.hpp
│ │ ├── quic.hpp
│ │ └── rist.hpp
│ ├── system/
│ │ ├── compression/
│ │ │ ├── w_lz4.cpp
│ │ │ ├── w_lz4.hpp
│ │ │ ├── w_lzma.cpp
│ │ │ └── w_lzma.hpp
│ │ ├── db/
│ │ │ ├── w_postgresql.cpp
│ │ │ └── w_postgresql.hpp
│ │ ├── gamepad/
│ │ │ ├── w_gamepad_client.hpp
│ │ │ ├── w_gamepad_client_emc.cpp
│ │ │ ├── w_gamepad_client_keymap.hpp
│ │ │ ├── w_gamepad_client_sdl.cpp
│ │ │ ├── w_gamepad_client_types.hpp
│ │ │ ├── w_gamepad_virtual.cpp
│ │ │ ├── w_gamepad_virtual.hpp
│ │ │ ├── w_gamepad_virtual_bus.hpp
│ │ │ ├── w_gamepad_virtual_pool.cpp
│ │ │ └── w_gamepad_virtual_pool.hpp
│ │ ├── getopt.h
│ │ ├── invocable.h
│ │ ├── log/
│ │ │ ├── w_log.cpp
│ │ │ ├── w_log.hpp
│ │ │ └── w_log_config.hpp
│ │ ├── script/
│ │ │ ├── w_lua.cpp
│ │ │ ├── w_lua.hpp
│ │ │ ├── w_python.cpp
│ │ │ └── w_python.hpp
│ │ ├── socket/
│ │ │ ├── w_socket_options.hpp
│ │ │ ├── w_tcp_client.cpp
│ │ │ ├── w_tcp_client.hpp
│ │ │ ├── w_tcp_server.cpp
│ │ │ ├── w_tcp_server.hpp
│ │ │ ├── w_ws_client.cpp
│ │ │ ├── w_ws_client.hpp
│ │ │ ├── w_ws_client_emc.cpp
│ │ │ ├── w_ws_client_emc.hpp
│ │ │ ├── w_ws_server.cpp
│ │ │ └── w_ws_server.hpp
│ │ ├── test/
│ │ │ ├── compress.hpp
│ │ │ ├── coroutine.hpp
│ │ │ ├── gamepad.hpp
│ │ │ ├── gametime.hpp
│ │ │ ├── index.html
│ │ │ ├── log.hpp
│ │ │ ├── lua.hpp
│ │ │ ├── postgresql.hpp
│ │ │ ├── process.hpp
│ │ │ ├── python.hpp
│ │ │ ├── signal_slot.hpp
│ │ │ ├── tcp.hpp
│ │ │ ├── trace.hpp
│ │ │ ├── ws.hpp
│ │ │ └── ws_server.sh
│ │ ├── w_flags.hpp
│ │ ├── w_gametime.cpp
│ │ ├── w_gametime.hpp
│ │ ├── w_leak_detector.cpp
│ │ ├── w_leak_detector.hpp
│ │ ├── w_overloaded.hpp
│ │ ├── w_process.cpp
│ │ ├── w_process.hpp
│ │ ├── w_time.cpp
│ │ ├── w_time.hpp
│ │ └── w_trace.hpp
│ ├── tests.cpp
│ ├── third_party/
│ │ ├── ffmpeg/
│ │ │ ├── LICENSE
│ │ │ ├── README.txt
│ │ │ ├── include/
│ │ │ │ ├── libavcodec/
│ │ │ │ │ ├── ac3_parser.h
│ │ │ │ │ ├── adts_parser.h
│ │ │ │ │ ├── avcodec.h
│ │ │ │ │ ├── avdct.h
│ │ │ │ │ ├── avfft.h
│ │ │ │ │ ├── bsf.h
│ │ │ │ │ ├── codec.h
│ │ │ │ │ ├── codec_desc.h
│ │ │ │ │ ├── codec_id.h
│ │ │ │ │ ├── codec_par.h
│ │ │ │ │ ├── d3d11va.h
│ │ │ │ │ ├── defs.h
│ │ │ │ │ ├── dirac.h
│ │ │ │ │ ├── dv_profile.h
│ │ │ │ │ ├── dxva2.h
│ │ │ │ │ ├── jni.h
│ │ │ │ │ ├── mediacodec.h
│ │ │ │ │ ├── packet.h
│ │ │ │ │ ├── qsv.h
│ │ │ │ │ ├── vdpau.h
│ │ │ │ │ ├── version.h
│ │ │ │ │ ├── version_major.h
│ │ │ │ │ ├── videotoolbox.h
│ │ │ │ │ ├── vorbis_parser.h
│ │ │ │ │ └── xvmc.h
│ │ │ │ ├── libavdevice/
│ │ │ │ │ ├── avdevice.h
│ │ │ │ │ ├── version.h
│ │ │ │ │ └── version_major.h
│ │ │ │ ├── libavfilter/
│ │ │ │ │ ├── avfilter.h
│ │ │ │ │ ├── buffersink.h
│ │ │ │ │ ├── buffersrc.h
│ │ │ │ │ ├── version.h
│ │ │ │ │ └── version_major.h
│ │ │ │ ├── libavformat/
│ │ │ │ │ ├── avformat.h
│ │ │ │ │ ├── avio.h
│ │ │ │ │ ├── version.h
│ │ │ │ │ └── version_major.h
│ │ │ │ ├── libavutil/
│ │ │ │ │ ├── adler32.h
│ │ │ │ │ ├── aes.h
│ │ │ │ │ ├── aes_ctr.h
│ │ │ │ │ ├── attributes.h
│ │ │ │ │ ├── audio_fifo.h
│ │ │ │ │ ├── avassert.h
│ │ │ │ │ ├── avconfig.h
│ │ │ │ │ ├── avstring.h
│ │ │ │ │ ├── avutil.h
│ │ │ │ │ ├── base64.h
│ │ │ │ │ ├── blowfish.h
│ │ │ │ │ ├── bprint.h
│ │ │ │ │ ├── bswap.h
│ │ │ │ │ ├── buffer.h
│ │ │ │ │ ├── camellia.h
│ │ │ │ │ ├── cast5.h
│ │ │ │ │ ├── channel_layout.h
│ │ │ │ │ ├── common.h
│ │ │ │ │ ├── cpu.h
│ │ │ │ │ ├── crc.h
│ │ │ │ │ ├── csp.h
│ │ │ │ │ ├── des.h
│ │ │ │ │ ├── detection_bbox.h
│ │ │ │ │ ├── dict.h
│ │ │ │ │ ├── display.h
│ │ │ │ │ ├── dovi_meta.h
│ │ │ │ │ ├── downmix_info.h
│ │ │ │ │ ├── encryption_info.h
│ │ │ │ │ ├── error.h
│ │ │ │ │ ├── eval.h
│ │ │ │ │ ├── ffversion.h
│ │ │ │ │ ├── fifo.h
│ │ │ │ │ ├── file.h
│ │ │ │ │ ├── film_grain_params.h
│ │ │ │ │ ├── frame.h
│ │ │ │ │ ├── hash.h
│ │ │ │ │ ├── hdr_dynamic_metadata.h
│ │ │ │ │ ├── hdr_dynamic_vivid_metadata.h
│ │ │ │ │ ├── hmac.h
│ │ │ │ │ ├── hwcontext.h
│ │ │ │ │ ├── hwcontext_cuda.h
│ │ │ │ │ ├── hwcontext_d3d11va.h
│ │ │ │ │ ├── hwcontext_drm.h
│ │ │ │ │ ├── hwcontext_dxva2.h
│ │ │ │ │ ├── hwcontext_mediacodec.h
│ │ │ │ │ ├── hwcontext_opencl.h
│ │ │ │ │ ├── hwcontext_qsv.h
│ │ │ │ │ ├── hwcontext_vaapi.h
│ │ │ │ │ ├── hwcontext_vdpau.h
│ │ │ │ │ ├── hwcontext_videotoolbox.h
│ │ │ │ │ ├── hwcontext_vulkan.h
│ │ │ │ │ ├── imgutils.h
│ │ │ │ │ ├── intfloat.h
│ │ │ │ │ ├── intreadwrite.h
│ │ │ │ │ ├── lfg.h
│ │ │ │ │ ├── log.h
│ │ │ │ │ ├── lzo.h
│ │ │ │ │ ├── macros.h
│ │ │ │ │ ├── mastering_display_metadata.h
│ │ │ │ │ ├── mathematics.h
│ │ │ │ │ ├── md5.h
│ │ │ │ │ ├── mem.h
│ │ │ │ │ ├── motion_vector.h
│ │ │ │ │ ├── murmur3.h
│ │ │ │ │ ├── opt.h
│ │ │ │ │ ├── parseutils.h
│ │ │ │ │ ├── pixdesc.h
│ │ │ │ │ ├── pixelutils.h
│ │ │ │ │ ├── pixfmt.h
│ │ │ │ │ ├── random_seed.h
│ │ │ │ │ ├── rational.h
│ │ │ │ │ ├── rc4.h
│ │ │ │ │ ├── replaygain.h
│ │ │ │ │ ├── ripemd.h
│ │ │ │ │ ├── samplefmt.h
│ │ │ │ │ ├── sha.h
│ │ │ │ │ ├── sha512.h
│ │ │ │ │ ├── spherical.h
│ │ │ │ │ ├── stereo3d.h
│ │ │ │ │ ├── tea.h
│ │ │ │ │ ├── threadmessage.h
│ │ │ │ │ ├── time.h
│ │ │ │ │ ├── timecode.h
│ │ │ │ │ ├── timestamp.h
│ │ │ │ │ ├── tree.h
│ │ │ │ │ ├── twofish.h
│ │ │ │ │ ├── tx.h
│ │ │ │ │ ├── uuid.h
│ │ │ │ │ ├── version.h
│ │ │ │ │ ├── video_enc_params.h
│ │ │ │ │ └── xtea.h
│ │ │ │ ├── libpostproc/
│ │ │ │ │ ├── postprocess.h
│ │ │ │ │ ├── version.h
│ │ │ │ │ └── version_major.h
│ │ │ │ ├── libswresample/
│ │ │ │ │ ├── swresample.h
│ │ │ │ │ ├── version.h
│ │ │ │ │ └── version_major.h
│ │ │ │ └── libswscale/
│ │ │ │ ├── swscale.h
│ │ │ │ ├── version.h
│ │ │ │ └── version_major.h
│ │ │ ├── lib/
│ │ │ │ └── win/
│ │ │ │ ├── avcodec-59.def
│ │ │ │ ├── avcodec.lib
│ │ │ │ ├── avdevice-59.def
│ │ │ │ ├── avdevice.lib
│ │ │ │ ├── avfilter-8.def
│ │ │ │ ├── avfilter.lib
│ │ │ │ ├── avformat-59.def
│ │ │ │ ├── avformat.lib
│ │ │ │ ├── avutil-57.def
│ │ │ │ ├── avutil.lib
│ │ │ │ ├── postproc-56.def
│ │ │ │ ├── postproc.lib
│ │ │ │ ├── swresample-4.def
│ │ │ │ ├── swresample.lib
│ │ │ │ ├── swscale-6.def
│ │ │ │ └── swscale.lib
│ │ │ └── presets/
│ │ │ ├── libvpx-1080p.ffpreset
│ │ │ ├── libvpx-1080p50_60.ffpreset
│ │ │ ├── libvpx-360p.ffpreset
│ │ │ ├── libvpx-720p.ffpreset
│ │ │ └── libvpx-720p50_60.ffpreset
│ │ └── shells/
│ │ ├── ffmpeg/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── FFMPEG/
│ │ │ │ ├── CMakeLists-FFMPEG.txt.in
│ │ │ │ └── CMakeLists.txt
│ │ │ └── third_party/
│ │ │ ├── dav1d/
│ │ │ │ ├── CMakeLists-dav1d.txt.in
│ │ │ │ └── CMakeLists.txt
│ │ │ ├── svt-av1/
│ │ │ │ ├── CMakeLists-svtav1.txt.in
│ │ │ │ └── CMakeLists.txt
│ │ │ └── vpx/
│ │ │ ├── CMakeLists-vpx.txt.in
│ │ │ └── CMakeLists.txt
│ │ ├── janus/
│ │ │ └── setup.sh
│ │ ├── librist/
│ │ │ ├── android-arm.ini
│ │ │ ├── android-armv8.ini
│ │ │ ├── librist-android.sh
│ │ │ ├── librist.bat
│ │ │ └── librist.sh
│ │ └── webRTC/
│ │ ├── webRTC.bat
│ │ └── webRTC.sh
│ ├── wolf.cpp
│ ├── wolf.hpp
│ └── wolf.ruleset
└── wolf_demo/
└── wasm/
├── build.sh
├── run.sh
├── ssl_server.py
├── wolf.cpp
└── www/
├── index.html
├── janus.js
├── janus_env.js
├── wolf.js
└── wolf.wasm
SYMBOL INDEX (1729 symbols across 288 files)
FILE: wolf/media/ffmpeg/w_av_config.hpp
type wolf::media::ffmpeg (line 17) | namespace wolf::media::ffmpeg {
class w_av_config (line 18) | class w_av_config {
method W_API (line 22) | W_API w_av_config() noexcept = default;
method W_API (line 33) | W_API virtual ~w_av_config() noexcept = default;
method W_API (line 36) | W_API w_av_config(w_av_config &&p_other) noexcept = default;
method W_API (line 38) | W_API w_av_config &operator=(w_av_config &&p_other) noexcept = default;
method w_av_config (line 41) | w_av_config(const w_av_config &p_other) noexcept = default;
method w_av_config (line 43) | w_av_config &operator=(const w_av_config &p_other) noexcept = default;
FILE: wolf/media/ffmpeg/w_av_format.cpp
function s_read_packet (line 29) | static int s_read_packet(void *p_opaque, _Inout_ uint8_t *p_buf, _In_ in...
FILE: wolf/media/ffmpeg/w_av_format.hpp
type wolf::media::ffmpeg (line 16) | namespace wolf::media::ffmpeg {
class w_av_format (line 17) | class w_av_format {
method W_API (line 21) | W_API ~w_av_format() noexcept { _release(); }
method W_API (line 23) | W_API w_av_format(w_av_format &&p_other) noexcept = default;
method W_API (line 25) | W_API w_av_format &operator=(w_av_format &&p_other) noexcept = default;
method w_av_format (line 37) | w_av_format(const w_av_format &) = delete;
method w_av_format (line 39) | w_av_format &operator=(const w_av_format &) = delete;
FILE: wolf/media/ffmpeg/w_av_frame.cpp
function w_av_config (line 112) | w_av_config w_av_frame::get_config() const noexcept { return this->_conf...
FILE: wolf/media/ffmpeg/w_av_frame.hpp
type wolf::media::ffmpeg (line 17) | namespace wolf::media::ffmpeg {
class w_decoder (line 19) | class w_decoder
class w_encoder (line 20) | class w_encoder
class w_av_frame (line 22) | class w_av_frame {
method W_API (line 34) | W_API virtual ~w_av_frame() noexcept { _release(); }
method W_API (line 37) | W_API w_av_frame(w_av_frame &&p_other) noexcept { _move(std::forward...
method W_API (line 39) | W_API w_av_frame &operator=(w_av_frame &&p_other) noexcept {
method w_av_frame (line 116) | w_av_frame(const w_av_frame &) = delete;
method w_av_frame (line 118) | w_av_frame &operator=(const w_av_frame &) = delete;
FILE: wolf/media/ffmpeg/w_av_packet.hpp
type wolf::media::ffmpeg (line 16) | namespace wolf::media::ffmpeg {
class w_decoder (line 18) | class w_decoder
class w_encoder (line 19) | class w_encoder
class w_ffmpeg (line 20) | class w_ffmpeg
class w_av_packet (line 22) | class w_av_packet {
method W_API (line 29) | W_API w_av_packet() noexcept = default;
method W_API (line 37) | W_API w_av_packet(w_av_packet &&p_other) noexcept {
method W_API (line 41) | W_API w_av_packet &operator=(w_av_packet &&p_other) noexcept {
method W_API (line 47) | W_API virtual ~w_av_packet() noexcept { _release(); }
method w_av_packet (line 83) | w_av_packet(const w_av_packet &) = delete;
method w_av_packet (line 85) | w_av_packet &operator=(const w_av_packet &) = delete;
FILE: wolf/media/ffmpeg/w_decoder.hpp
type wolf::media::ffmpeg (line 15) | namespace wolf::media::ffmpeg {
class w_decoder (line 17) | class w_decoder {
method W_API (line 22) | W_API w_decoder() = default;
method W_API (line 24) | W_API virtual ~w_decoder() noexcept = default;
method W_API (line 27) | W_API w_decoder(w_decoder &&p_other) noexcept = default;
method W_API (line 29) | W_API w_decoder &operator=(w_decoder &&p_other) noexcept = default;
method w_decoder (line 37) | w_decoder(const w_decoder &) = delete;
method w_decoder (line 39) | w_decoder &operator=(const w_decoder &) = delete;
FILE: wolf/media/ffmpeg/w_encoder.hpp
type wolf::media::ffmpeg (line 15) | namespace wolf::media::ffmpeg {
class w_encoder (line 17) | class w_encoder {
method W_API (line 20) | W_API w_encoder() = default;
method W_API (line 22) | W_API virtual ~w_encoder() noexcept = default;
method W_API (line 25) | W_API w_encoder(w_encoder &&p_other) noexcept = default;
method W_API (line 27) | W_API w_encoder &operator=(w_encoder &&p_other) noexcept = default;
method w_encoder (line 37) | w_encoder(const w_encoder &) = delete;
method w_encoder (line 39) | w_encoder &operator=(const w_encoder &) = delete;
FILE: wolf/media/ffmpeg/w_ffmpeg.cpp
function s_set_dict (line 17) | static boost::leaf::result<AVDictionary *> s_set_dict(
function s_create (line 68) | static boost::leaf::result<int> s_create(_Inout_ w_ffmpeg_ctx &p_ctx,
FILE: wolf/media/ffmpeg/w_ffmpeg.hpp
type wolf::media::ffmpeg (line 17) | namespace wolf::media::ffmpeg {
type w_av_codec_opt (line 19) | struct w_av_codec_opt {
type w_av_set_opt (line 29) | struct w_av_set_opt {
class w_ffmpeg (line 36) | class w_ffmpeg {
FILE: wolf/media/ffmpeg/w_ffmpeg_ctx.hpp
type wolf::media::ffmpeg (line 16) | namespace wolf::media::ffmpeg {
class w_ffmpeg_ctx (line 18) | class w_ffmpeg_ctx {
method W_API (line 21) | W_API w_ffmpeg_ctx() = default;
method W_API (line 23) | W_API virtual ~w_ffmpeg_ctx() noexcept { _release(); }
method W_API (line 26) | W_API w_ffmpeg_ctx(w_ffmpeg_ctx &&p_other) noexcept {
method W_API (line 30) | W_API w_ffmpeg_ctx &operator=(w_ffmpeg_ctx &&p_other) noexcept {
method w_ffmpeg_ctx (line 43) | w_ffmpeg_ctx(const w_ffmpeg_ctx &) = delete;
method w_ffmpeg_ctx (line 45) | w_ffmpeg_ctx &operator=(const w_ffmpeg_ctx &) = delete;
FILE: wolf/media/gst/audio/w_audio_format.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
type w_audio_format (line 10) | enum class w_audio_format
FILE: wolf/media/gst/audio/w_audio_info.cpp
type wolf::media::gst (line 3) | namespace wolf::media::gst {
FILE: wolf/media/gst/audio/w_audio_info.hpp
type wolf::media::gst (line 15) | namespace wolf::media::gst {
class w_audio_info (line 20) | class w_audio_info : public w_wrapper<w_audio_info, GstAudioInfo, void...
method w_caps (line 37) | [[nodiscard]] w_caps to_caps()
method set_rate (line 47) | void set_rate(std::size_t p_rate)
method set_channels (line 55) | void set_channels(std::size_t p_channels)
method w_audio_info (line 61) | w_audio_info(internal::w_raw_tag, GstAudioInfo* p_rawptr) noexcept
FILE: wolf/media/gst/core/w_buffer.cpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
FILE: wolf/media/gst/core/w_buffer.hpp
type wolf::media::gst (line 12) | namespace wolf::media::gst {
type w_buffer_map_flags (line 17) | enum class w_buffer_map_flags
class w_buffer (line 24) | class w_buffer
method get_timestamp (line 116) | [[nodiscard]] auto get_timestamp() const noexcept
method get_duration (line 124) | [[nodiscard]] auto get_duration() const noexcept
method set_timestamp (line 132) | void set_timestamp(std::size_t p_nanoseconds) noexcept
method set_duration (line 140) | void set_duration(std::size_t p_nanoseconds) noexcept
method map_data_write (line 148) | [[nodiscard]] auto map_data_write()
method map_data_read (line 160) | [[nodiscard]] auto map_data_read() const
method map_data (line 173) | [[nodiscard]] auto map_data()
method map_data (line 181) | [[nodiscard]] auto map_data() const
method w_buffer (line 187) | explicit w_buffer(internal::w_raw_tag, GstBuffer* p_buffer) noexcept
class w_buffer_mapped_data (line 30) | class w_buffer_mapped_data
method w_buffer_mapped_data (line 35) | w_buffer_mapped_data(const w_buffer_mapped_data&) = delete;
method w_buffer_mapped_data (line 36) | w_buffer_mapped_data(w_buffer_mapped_data&& p_other) noexcept
method w_buffer_mapped_data (line 41) | w_buffer_mapped_data& operator=(const w_buffer_mapped_data&) = delete;
method w_buffer_mapped_data (line 42) | w_buffer_mapped_data& operator=(w_buffer_mapped_data&& p_other) noex...
method size (line 56) | [[nodiscard]] std::size_t size() const noexcept { return _map.size; }
method guint8 (line 58) | [[nodiscard]] guint8* begin() noexcept { return _map.data; }
method guint8 (line 59) | [[nodiscard]] const guint8* begin() const noexcept { return _map.dat...
method guint8 (line 61) | [[nodiscard]] guint8* end() noexcept { return _map.data + _map.size; }
method guint8 (line 62) | [[nodiscard]] const guint8* end() const noexcept { return _map.data ...
method guint8 (line 64) | [[nodiscard]] guint8* data() noexcept { return _map.data; }
method guint8 (line 65) | [[nodiscard]] const guint8* data() const noexcept { return _map.data; }
method guint8 (line 67) | [[nodiscard]] guint8& operator[](std::size_t p_index) { return _map....
method guint8 (line 68) | [[nodiscard]] const guint8& operator[](std::size_t p_index) const { ...
method w_buffer_mapped_data (line 71) | w_buffer_mapped_data() noexcept {}
method make (line 78) | [[nodiscard]] static auto make(internal::w_raw_tag,
class w_buffer (line 102) | class w_buffer : public w_wrapper<w_buffer, GstBuffer, void, gst_buffe...
method get_timestamp (line 116) | [[nodiscard]] auto get_timestamp() const noexcept
method get_duration (line 124) | [[nodiscard]] auto get_duration() const noexcept
method set_timestamp (line 132) | void set_timestamp(std::size_t p_nanoseconds) noexcept
method set_duration (line 140) | void set_duration(std::size_t p_nanoseconds) noexcept
method map_data_write (line 148) | [[nodiscard]] auto map_data_write()
method map_data_read (line 160) | [[nodiscard]] auto map_data_read() const
method map_data (line 173) | [[nodiscard]] auto map_data()
method map_data (line 181) | [[nodiscard]] auto map_data() const
method w_buffer (line 187) | explicit w_buffer(internal::w_raw_tag, GstBuffer* p_buffer) noexcept
FILE: wolf/media/gst/core/w_bus.hpp
type wolf::media::gst (line 9) | namespace wolf::media::gst {
class w_bus (line 14) | class w_bus : public w_wrapper<w_bus, GstBus, void, gst_object_unref>
method w_bus (line 19) | w_bus() = delete;
method w_bus (line 21) | w_bus(const w_bus&) = delete;
method w_bus (line 22) | w_bus(w_bus&&) noexcept = default;
method w_bus (line 24) | w_bus& operator=(const w_bus&) = delete;
method w_bus (line 25) | w_bus& operator=(w_bus&&) noexcept = default;
method hook_message (line 39) | void hook_message(F&& p_handler)
method unhook_message (line 52) | void unhook_message()
method w_bus (line 61) | explicit w_bus(internal::w_raw_tag, GstBus* p_bus_raw) noexcept
method ensure_watch (line 69) | void ensure_watch() noexcept
method watch (line 79) | void watch() noexcept
type signal_handler_set (line 86) | struct signal_handler_set {
method signal_handler_set (line 89) | signal_handler_set(auto* p_rawptr) : message(p_rawptr) {}
FILE: wolf/media/gst/core/w_caps.hpp
type wolf::media::gst (line 13) | namespace wolf::media::gst {
class w_caps (line 18) | class w_caps : public w_wrapper<w_caps, GstCaps, void, gst_caps_unref>
method make (line 27) | [[nodiscard]] static auto make() -> boost::leaf::result<w_caps>
method make_any (line 42) | [[nodiscard]] static auto make_any() -> boost::leaf::result<w_caps>
method make_simple (line 57) | [[nodiscard]] static auto make_simple(const char* p_media_name)
method add (line 75) | void add(w_structure&& p_structure)
method w_caps (line 81) | w_caps(internal::w_raw_tag, GstCaps* p_caps_raw) noexcept
FILE: wolf/media/gst/core/w_clock.hpp
type wolf::media::gst (line 7) | namespace wolf::media::gst {
class w_clock (line 14) | class w_clock : public w_wrapper<w_clock, GstClock, void, +[](GstClock...
method w_clock (line 19) | w_clock() = delete;
method get_time (line 25) | std::size_t get_time() noexcept
method w_clock (line 31) | explicit w_clock(internal::w_raw_tag, GstClock* p_clock_raw) noexcept
FILE: wolf/media/gst/core/w_element.cpp
type wolf::media::gst (line 3) | namespace wolf::media::gst {
FILE: wolf/media/gst/core/w_element.hpp
type wolf::media::gst (line 14) | namespace wolf::media::gst {
class w_element (line 22) | class w_element : public w_wrapper<w_element, GstElement, void, gst_ob...
method w_element (line 35) | w_element(const w_element&) = delete;
method w_element (line 36) | w_element(w_element&&) noexcept = default;
method w_element (line 38) | w_element& operator=(const w_element&) = delete;
method w_element (line 39) | w_element& operator=(w_element&&) noexcept = default;
method request_pad (line 46) | [[nodiscard]] auto request_pad(const char* p_pad_name)
method always_pad (line 60) | [[nodiscard]] auto always_pad(const char* p_pad_name)
method clock (line 74) | w_nonowning<w_clock> clock() noexcept
method w_element (line 80) | explicit w_element(internal::w_raw_tag, GstElement* p_element) noexcept
FILE: wolf/media/gst/core/w_element_factory.hpp
type wolf::media::gst (line 12) | namespace wolf::media::gst {
class w_element_factory (line 17) | class w_element_factory
method w_element_factory (line 20) | w_element_factory() = delete;
method make_from_launch_str (line 26) | [[nodiscard]] static auto make_from_launch_str(const char* p_launch_...
method make_simple (line 44) | [[nodiscard]] static auto make_simple(const char* p_factory_name, co...
FILE: wolf/media/gst/core/w_format.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
type w_format (line 8) | enum class w_format
FILE: wolf/media/gst/core/w_mainloop.hpp
type wolf::media::gst (line 14) | namespace wolf::media::gst {
class w_mainloop (line 19) | class w_mainloop : public w_wrapper<w_mainloop, GMainLoop, void, g_mai...
method make (line 26) | [[nodiscard]] static auto make() -> boost::leaf::result<w_mainloop>
method idle_add (line 46) | std::size_t idle_add(F& p_func)
method idle_remove (line 52) | bool idle_remove(std::size_t p_sourceid)
method run (line 64) | void run()
method stop (line 72) | void stop()
method w_mainloop (line 78) | w_mainloop(internal::w_raw_tag, GMainLoop* p_main_loop_raw) noexcept
FILE: wolf/media/gst/core/w_message.hpp
type wolf::media::gst (line 10) | namespace wolf::media::gst {
class w_message (line 12) | class w_message
method w_message (line 100) | w_message() = delete;
method visit (line 112) | auto visit(VisitorF&& p_visitor)
method w_message (line 118) | explicit w_message(internal::w_raw_tag, GstMessage* p_msg_raw)
method raw_visit (line 128) | static auto raw_visit(VisitorF&& p_visitor, GstMessage* p_msg_raw)
type w_message_type (line 15) | enum class w_message_type : std::size_t
type w_message_unknown (line 27) | struct w_message_unknown {}
type w_message_eos (line 30) | struct w_message_eos {}
type w_message_error (line 33) | struct w_message_error
method w_message_error (line 38) | w_message_error() = delete;
method w_message_error (line 40) | w_message_error(const w_message_error&) = delete;
method print (line 56) | void print() const
method w_message_error (line 73) | explicit w_message_error(internal::w_raw_tag, GstMessage* p_msg_raw)
class w_message (line 94) | class w_message : public w_wrapper<w_message, GstMessage, void, gst_me...
method w_message (line 100) | w_message() = delete;
method visit (line 112) | auto visit(VisitorF&& p_visitor)
method w_message (line 118) | explicit w_message(internal::w_raw_tag, GstMessage* p_msg_raw)
method raw_visit (line 128) | static auto raw_visit(VisitorF&& p_visitor, GstMessage* p_msg_raw)
FILE: wolf/media/gst/core/w_nonowning.hpp
type wolf::media::gst (line 7) | namespace wolf::media::gst {
class w_nonowning (line 27) | class w_nonowning
method w_nonowning (line 38) | w_nonowning(value_type& p_value)
method w_nonowning (line 42) | w_nonowning(const w_nonowning&) = default;
method w_nonowning (line 43) | w_nonowning(w_nonowning&&) noexcept = default;
method w_nonowning (line 45) | w_nonowning& operator=(const w_nonowning&) = default;
method w_nonowning (line 46) | w_nonowning& operator=(w_nonowning&&) noexcept = default;
method value_type (line 55) | value_type* operator->() noexcept { return std::addressof(_value); }
method value_type (line 56) | const value_type* operator->() const noexcept { return std::addresso...
method value_type (line 58) | value_type& operator*() noexcept { return _value; }
method value_type (line 59) | const value_type& operator*() const noexcept { return _value; }
method w_nonowning (line 63) | w_nonowning(internal::w_raw_tag, RawT* p_rawptr) noexcept
FILE: wolf/media/gst/core/w_pad.hpp
type wolf::media::gst (line 10) | namespace wolf::media::gst {
type w_availability (line 13) | enum class w_availability
class w_pad (line 26) | class w_pad : public w_wrapper<w_pad, GstPad, void, gst_object_unref>
method w_pad (line 34) | explicit w_pad(internal::w_raw_tag, GstPad* p_pad) noexcept
FILE: wolf/media/gst/core/w_pipeline.cpp
type wolf::media::gst (line 3) | namespace wolf::media::gst {
FILE: wolf/media/gst/core/w_pipeline.hpp
type wolf::media::gst (line 15) | namespace wolf::media::gst {
class w_pipeline (line 20) | class w_pipeline : public w_wrapper<w_pipeline, GstElement, void, gst_...
method bin (line 43) | bool bin(Args&& ...p_args)
method bin (line 60) | bool bin(w_element& p_element)
method link (line 75) | bool link(T&& p_a, U&& p_b, Rest&& ...p_rest)
method link (line 97) | bool link(w_element& p_src, w_element& p_sink)
method play (line 116) | bool play()
method pause (line 125) | bool pause()
method stop (line 134) | bool stop() {
method w_pipeline (line 139) | w_pipeline(internal::w_raw_tag, GstElement* pipeline_raw) noexcept
FILE: wolf/media/gst/core/w_refptr.hpp
type wolf::media::gst (line 8) | namespace wolf::media::gst {
function to_refptr (line 24) | inline w_refptr<T> to_refptr(T&& p_value)
function to_refptr (line 36) | inline w_refptr<T> to_refptr(w_refptr<T> p_value)
FILE: wolf/media/gst/core/w_signal_handler.hpp
type wolf::media::gst (line 11) | namespace wolf::media::gst {
class w_signal_handler (line 22) | class w_signal_handler
method w_signal_handler (line 38) | explicit w_signal_handler(rawptr_type p_rawptr)
method w_signal_handler (line 47) | w_signal_handler(const w_signal_handler&) = delete;
method w_signal_handler (line 48) | w_signal_handler(w_signal_handler&&) noexcept = default;
method w_signal_handler (line 50) | w_signal_handler& operator=(const w_signal_handler&) = delete;
method w_signal_handler (line 51) | w_signal_handler& operator=(w_signal_handler&&) noexcept = default;
method hook (line 65) | bool hook(const char* p_name, auto* p_invoker, F&& p_handler)
method hook (line 92) | bool hook(const char* p_name, F&& p_handler)
method unhook (line 103) | bool unhook() noexcept
FILE: wolf/media/gst/core/w_structure.cpp
type wolf::media::gst (line 3) | namespace wolf::media::gst {
FILE: wolf/media/gst/core/w_structure.hpp
type wolf::media::gst (line 12) | namespace wolf::media::gst {
type w_fraction (line 14) | struct w_fraction
class w_structure (line 23) | class w_structure : public w_wrapper<w_structure, GstStructure, void, ...
method set_field_pairs (line 48) | void set_field_pairs(const char* p_fieldname, T&& p_fieldvalue, Rest...
method set_field (line 60) | void set_field(const char* p_fieldname, w_fraction p_fraction)
method set_field (line 75) | void set_field(const char* p_fieldname, std::size_t p_value)
method w_structure (line 81) | w_structure(internal::w_raw_tag, GstStructure* p_structure_raw)
FILE: wolf/media/gst/elements/w_element_aacparse.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
class w_element_aacparse (line 10) | class w_element_aacparse : public w_element
method make (line 15) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_aa...
method w_element_aacparse (line 22) | explicit w_element_aacparse(w_element&& p_base) noexcept
FILE: wolf/media/gst/elements/w_element_appsrc.hpp
type wolf::media::gst (line 10) | namespace wolf::media::gst {
class w_element_appsrc (line 15) | class w_element_appsrc : public w_element
method make (line 20) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_ap...
method set_block (line 28) | void set_block(bool p_block) {
method set_caps (line 32) | void set_caps(w_caps& p_caps)
method set_format (line 37) | void set_format(w_format p_format)
method set_live (line 42) | void set_live(bool p_is_live)
method set_max_buffer (line 47) | void set_max_buffer(std::size_t p_count)
method set_max_latency (line 52) | void set_max_latency(std::size_t p_nanoseconds)
method set_max_time (line 57) | void set_max_time(std::size_t p_nanoseconds)
method hook_enough_data (line 65) | void hook_enough_data(F&& p_callback)
method unhook_enough_data (line 70) | void unhook_enough_data()
method hook_need_data (line 76) | void hook_need_data(F&& p_callback)
method unhook_need_data (line 81) | void unhook_need_data()
method hook_seek_data (line 87) | void hook_seek_data(F&& p_callback)
method unhook_seek_data (line 92) | void unhook_seek_data()
method emit_eos (line 99) | bool emit_eos()
method emit_push_buffer (line 107) | bool emit_push_buffer(BufferT&& p_buffer)
method w_element_appsrc (line 115) | explicit w_element_appsrc(w_element&& p_base)
type signal_handler_set (line 121) | struct signal_handler_set {
method signal_handler_set (line 126) | signal_handler_set(auto* p_rawptr)
FILE: wolf/media/gst/elements/w_element_audioconvert.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
class w_element_audioconvert (line 10) | class w_element_audioconvert : public w_element
method make (line 15) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_au...
method w_element_audioconvert (line 22) | explicit w_element_audioconvert(w_element&& p_base) noexcept
FILE: wolf/media/gst/elements/w_element_audioresample.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
class w_element_audioresample (line 10) | class w_element_audioresample : public w_element
method make (line 15) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_au...
method w_element_audioresample (line 22) | explicit w_element_audioresample(w_element&& p_base) noexcept
FILE: wolf/media/gst/elements/w_element_autovideosink.hpp
type wolf::media::gst (line 7) | namespace wolf::media::gst {
class w_element_autovideosink (line 12) | class w_element_autovideosink : public w_element
method make (line 17) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_au...
method w_element_autovideosink (line 24) | explicit w_element_autovideosink(w_element&& p_base) noexcept
FILE: wolf/media/gst/elements/w_element_avencflv.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
class w_element_avencflv (line 10) | class w_element_avencflv : public w_element
method make (line 15) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_av...
method w_element_avencflv (line 22) | explicit w_element_avencflv(w_element&& p_base) noexcept
FILE: wolf/media/gst/elements/w_element_capsfilter.hpp
type wolf::media::gst (line 6) | namespace wolf::media::gst {
class w_element_capsfilter (line 11) | class w_element_capsfilter : public w_element
method make (line 16) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_ca...
method set_caps (line 22) | void set_caps(w_caps& p_caps)
method w_element_capsfilter (line 28) | explicit w_element_capsfilter(w_element&& p_base) noexcept
FILE: wolf/media/gst/elements/w_element_filesink.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
class w_element_filesink (line 10) | class w_element_filesink : public w_element
method make (line 15) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_fi...
method set_location (line 21) | void set_location(const char* p_location)
method w_element_filesink (line 27) | explicit w_element_filesink(w_element&& p_base) noexcept
FILE: wolf/media/gst/elements/w_element_flvmux.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
class w_element_flvmux (line 10) | class w_element_flvmux : public w_element
method make (line 15) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_fl...
method set_streamable (line 21) | void set_streamable(bool p_streamable)
method w_element_flvmux (line 27) | explicit w_element_flvmux(w_element&& p_base) noexcept
FILE: wolf/media/gst/elements/w_element_h264parse.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
class w_element_h264parse (line 10) | class w_element_h264parse : public w_element
method make (line 15) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_h2...
method w_element_h264parse (line 22) | explicit w_element_h264parse(w_element&& p_base) noexcept
FILE: wolf/media/gst/elements/w_element_mp4mux.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
class w_element_mp4mux (line 10) | class w_element_mp4mux : public w_element
method make (line 15) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_mp...
method w_element_mp4mux (line 22) | explicit w_element_mp4mux(w_element&& p_base) noexcept
FILE: wolf/media/gst/elements/w_element_openh264enc.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
class w_element_openh264enc (line 10) | class w_element_openh264enc : public w_element
method make (line 15) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_op...
method w_element_openh264enc (line 22) | explicit w_element_openh264enc(w_element&& p_base) noexcept
FILE: wolf/media/gst/elements/w_element_queue.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
class w_element_queue (line 10) | class w_element_queue : public w_element
method make (line 15) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_qu...
method w_element_queue (line 22) | explicit w_element_queue(w_element&& p_base) noexcept
FILE: wolf/media/gst/elements/w_element_rtmpsink.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
class w_element_rtmpsink (line 10) | class w_element_rtmpsink : public w_element
method make (line 15) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_rt...
method set_location (line 21) | void set_location(const char* p_location)
method w_element_rtmpsink (line 27) | explicit w_element_rtmpsink(w_element&& p_base) noexcept
FILE: wolf/media/gst/elements/w_element_rtph264pay.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
class w_element_rtph264pay (line 10) | class w_element_rtph264pay : public w_element
method make (line 15) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_rt...
method w_element_rtph264pay (line 22) | explicit w_element_rtph264pay(w_element&& p_base) noexcept
FILE: wolf/media/gst/elements/w_element_udpsink.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
class w_element_udpsink (line 10) | class w_element_udpsink : public w_element
method make (line 15) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_ud...
method set_host (line 21) | void set_host(const char* p_host)
method set_port (line 26) | void set_port(unsigned short p_port)
method w_element_udpsink (line 32) | explicit w_element_udpsink(w_element&& p_base) noexcept
FILE: wolf/media/gst/elements/w_element_videoconvert.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
class w_element_videoconvert (line 10) | class w_element_videoconvert : public w_element
method make (line 15) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_vi...
method w_element_videoconvert (line 22) | explicit w_element_videoconvert(w_element&& p_base) noexcept
FILE: wolf/media/gst/elements/w_element_videoscale.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
class w_element_videoscale (line 10) | class w_element_videoscale : public w_element
method make (line 15) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_vi...
method w_element_videoscale (line 22) | explicit w_element_videoscale(w_element&& p_base) noexcept
FILE: wolf/media/gst/elements/w_element_videotestsrc.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
class w_element_videotestsrc (line 10) | class w_element_videotestsrc : public w_element
method make (line 15) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_vi...
method w_element_videotestsrc (line 22) | explicit w_element_videotestsrc(w_element&& p_base) noexcept
FILE: wolf/media/gst/elements/w_element_voaacenc.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
class w_element_voaacenc (line 10) | class w_element_voaacenc : public w_element
method make (line 15) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_vo...
method set_bitrate (line 21) | void set_bitrate(std::size_t p_bitrate)
method w_element_voaacenc (line 27) | explicit w_element_voaacenc(w_element&& p_base) noexcept
FILE: wolf/media/gst/elements/w_element_wasapisrc.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
class w_element_wasapisrc (line 10) | class w_element_wasapisrc : public w_element
method make (line 15) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_wa...
method set_device (line 21) | void set_device(const char* p_device)
method set_low_latency (line 26) | void set_low_latency(bool p_enable)
method w_element_wasapisrc (line 32) | explicit w_element_wasapisrc(w_element&& p_base) noexcept
FILE: wolf/media/gst/elements/w_element_x264enc.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
class w_element_x264enc (line 10) | class w_element_x264enc : public w_element
method make (line 15) | [[nodiscard]] static auto make() -> boost::leaf::result<w_element_x2...
method set_bitrate (line 21) | void set_bitrate(std::size_t p_bitrate)
method set_pass (line 26) | void set_pass(std::size_t p_pass)
method set_quantizer (line 31) | void set_quantizer(std::size_t p_quantizer)
method set_qp_min (line 36) | void set_qp_min(std::size_t p_qp_min)
method set_qp_max (line 41) | void set_qp_max(std::size_t p_qp_max)
method set_speed_preset (line 46) | void set_speed_preset(std::size_t p_speed_preset)
method set_key_int_max (line 51) | void set_key_int_max(std::size_t p_key_int_max)
method set_b_adapt (line 56) | void set_b_adapt(bool p_b_adapt)
method set_bframes (line 61) | void set_bframes(std::size_t p_bframes)
method w_element_x264enc (line 67) | explicit w_element_x264enc(w_element&& p_base) noexcept
FILE: wolf/media/gst/internal/w_common.hpp
type wolf::media::gst::internal (line 5) | namespace wolf::media::gst::internal {
type w_raw_tag (line 8) | struct w_raw_tag {}
class w_raw_access (line 21) | class w_raw_access
method from_raw (line 30) | static auto from_raw(RawT* p_raw_ptr, Args&& ...p_args)
method raw (line 40) | static auto raw(T& p_obj) noexcept
method disown_raw (line 51) | static auto disown_raw(T&& p_obj) noexcept
FILE: wolf/media/gst/internal/w_utils.hpp
type wolf::media::gst::internal (line 5) | namespace wolf::media::gst::internal {
type w_overloaded (line 13) | struct w_overloaded : Fs... { using Fs::operator()...; }
type w_blackhole (line 38) | struct w_blackhole
method w_blackhole (line 41) | constexpr w_blackhole(Ts&& ...) noexcept {}
class w_functor (line 51) | class w_functor {
FILE: wolf/media/gst/internal/w_wrapper.hpp
type wolf::media::gst (line 10) | namespace wolf::media::gst {
class w_wrapper (line 28) | class w_wrapper
method w_wrapper (line 40) | w_wrapper(const w_wrapper& p_other)
method w_wrapper (line 46) | w_wrapper(w_wrapper&&) noexcept = default;
method w_wrapper (line 48) | w_wrapper& operator=(const w_wrapper& p_other)
method w_wrapper (line 56) | w_wrapper& operator=(w_wrapper&&) noexcept = default;
method nonowning_view (line 76) | auto nonowning_view() & -> w_nonowning<DerivedT>
method parented (line 91) | void parented() &
method w_wrapper (line 99) | explicit w_wrapper(underlying_type* ptr) : _ptr(ptr) {}
method underlying_type (line 101) | [[nodiscard]] underlying_type* raw() noexcept { return _ptr.get(); }
method underlying_type (line 102) | [[nodiscard]] const underlying_type* raw() const noexcept { return _...
method replace_raw (line 104) | void replace_raw(underlying_type* ptr = nullptr) { _ptr.reset(ptr); }
method disown_raw (line 106) | auto disown_raw() noexcept { return _ptr.release(); }
FILE: wolf/media/gst/video/w_video_format.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
type w_video_format (line 10) | enum class w_video_format
FILE: wolf/media/gst/video/w_video_info.cpp
type wolf::media::gst (line 3) | namespace wolf::media::gst {
FILE: wolf/media/gst/video/w_video_info.hpp
type wolf::media::gst (line 15) | namespace wolf::media::gst {
class w_video_info (line 20) | class w_video_info : public w_wrapper<w_video_info, GstVideoInfo, void...
method w_caps (line 37) | w_caps to_caps()
method set_fps (line 47) | void set_fps(std::size_t p_fps)
method set_fps (line 56) | void set_fps(std::size_t p_numerator, std::size_t p_denomirator)
method w_video_info (line 63) | w_video_info(internal::w_raw_tag, GstVideoInfo* video_info_raw) noex...
FILE: wolf/media/gst/w_application.hpp
type wolf::media::gst (line 5) | namespace wolf::media::gst {
class w_application (line 10) | class w_application
method w_application (line 13) | w_application() = delete;
method init (line 15) | static bool init(int* argc, char*** argv)
FILE: wolf/media/gst/w_flow.hpp
type wolf::media::gst (line 10) | namespace wolf::media::gst {
class w_flow_path (line 21) | class w_flow_path
method make (line 30) | static auto make(Ts&& ...elements) {
method size (line 39) | constexpr auto size() const noexcept -> std::size_t { return _vec.si...
method begin (line 47) | auto begin() noexcept { return std::begin(_vec); }
method begin (line 48) | auto begin() const noexcept { return std::begin(_vec); }
method end (line 50) | auto end() noexcept { return std::end(_vec); }
method end (line 51) | auto end() const noexcept { return std::end(_vec); }
method w_flow_path (line 57) | w_flow_path() {}
FILE: wolf/media/test/avframe.hpp
function BOOST_AUTO_TEST_CASE (line 14) | BOOST_AUTO_TEST_CASE(avframe_test) {
FILE: wolf/media/test/ffmpeg.hpp
function s_encode (line 21) | static boost::leaf::result<std::tuple<w_av_packet, w_av_config, w_av_con...
function s_decode (line 68) | static boost::leaf::result<void> s_decode(
function BOOST_AUTO_TEST_CASE (line 109) | BOOST_AUTO_TEST_CASE(av1_encode_decode_test) {
function BOOST_AUTO_TEST_CASE (line 153) | BOOST_AUTO_TEST_CASE(vp9_encode_decode_test) {
function BOOST_AUTO_TEST_CASE (line 193) | BOOST_AUTO_TEST_CASE(x264_encode_decode_test) {
FILE: wolf/media/test/gstreamer.hpp
function BOOST_AUTO_TEST_CASE (line 25) | BOOST_AUTO_TEST_CASE(gstreamer_wrapper) {
FILE: wolf/media/test/image.hpp
function BOOST_AUTO_TEST_CASE (line 13) | BOOST_AUTO_TEST_CASE(image_load_save_test) {
FILE: wolf/media/test/openal.hpp
function BOOST_AUTO_TEST_CASE (line 15) | BOOST_AUTO_TEST_CASE(openal_play_wav) {
FILE: wolf/media/w_image.cpp
function w_image_data (line 20) | w_image_data &w_image_data::operator=(w_image_data &&p_other) noexcept {
FILE: wolf/media/w_image.hpp
type wolf::media (line 13) | namespace wolf::media {
class w_image_data (line 15) | class w_image_data {
method W_API (line 18) | W_API w_image_data() noexcept = default;
method w_image_data (line 36) | w_image_data(const w_image_data &) = delete;
method w_image_data (line 38) | w_image_data &operator=(const w_image_data &) = delete;
class w_image (line 44) | class w_image {
FILE: wolf/media/w_image_data.cpp
function w_image_data (line 17) | w_image_data &w_image_data::operator=(w_image_data &&p_other) noexcept {
FILE: wolf/media/w_image_data.hpp
type wolf::media (line 12) | namespace wolf::media {}
FILE: wolf/media/w_openal.cpp
function ALsizei (line 10) | ALsizei AL_APIENTRY w_openal::s_openal_callback(_In_ void *p_user_ptr,
function w_openal_config (line 122) | w_openal_config w_openal::get_config() const { return this->_config; }
FILE: wolf/media/w_openal.hpp
type wolf::media (line 17) | namespace wolf::media {
type w_openal_config (line 19) | struct w_openal_config {
class w_openal (line 30) | class w_openal {
method W_API (line 33) | W_API w_openal() noexcept = default;
method W_API (line 38) | W_API w_openal &operator=(w_openal &&p_other) = default;
method W_API (line 60) | W_API boost::leaf::result<int>
method w_openal (line 206) | w_openal(const w_openal &) = delete;
method w_openal (line 208) | w_openal &operator=(const w_openal &) = delete;
FILE: wolf/ml/nudity_detection/w_nudity_detection.hpp
type wolf::ml::nudet (line 19) | namespace wolf::ml::nudet {
class w_nud_det (line 21) | class w_nud_det {
FILE: wolf/ml/referee_ocr/w_image_processor.cpp
type wolf::ml::ocr (line 17) | namespace wolf::ml::ocr {
function find_all_countors (line 19) | std::vector<std::vector<cv::Point>>
function gaussian_blur (line 30) | void gaussian_blur(_Inout_ cv::Mat &frame_box,
function make_contour_white_background (line 37) | void make_contour_white_background(_Inout_ cv::Mat &contour_image,
function negative_image (line 79) | void negative_image(_Inout_ cv::Mat &contour_image) {
function prepare_image_for_contour_detection (line 102) | cv::Mat
function resize_image (line 121) | void resize_image(_Inout_ cv::Mat &frame_box, _In_ int dest_height,
function threshold_image (line 148) | void threshold_image(_Inout_ cv::Mat &frame_box,
FILE: wolf/ml/referee_ocr/w_image_processor.hpp
type wolf::ml::ocr (line 21) | namespace wolf::ml::ocr {
type restrictions_struct (line 27) | struct restrictions_struct {
type config_for_ocr_struct (line 40) | struct config_for_ocr_struct {
FILE: wolf/ml/referee_ocr/w_ocr_engine.cpp
function get_tracer (line 23) | nostd::shared_ptr<trace::Tracer> get_tracer() {
function compare_char_by_x_position (line 86) | bool compare_char_by_x_position(
FILE: wolf/ml/referee_ocr/w_ocr_engine.hpp
type wolf::ml::ocr (line 20) | namespace wolf::ml::ocr {
class w_ocr_engine (line 30) | class w_ocr_engine {
type cluster_position (line 33) | enum cluster_position { left, right, middle }
type cluster_features (line 35) | struct cluster_features {
type characters_struct (line 64) | struct characters_struct {
type result_boxes (line 83) | struct result_boxes {
type character_and_center (line 92) | struct character_and_center {
type config_struct (line 107) | struct config_struct {
type result (line 124) | struct result {
FILE: wolf/ml/referee_ocr/w_read_video_frames.cpp
function get_tracer (line 11) | nostd::shared_ptr<trace::Tracer> get_tracer() {
FILE: wolf/ml/referee_ocr/w_read_video_frames.hpp
type wolf::ml::ocr (line 13) | namespace wolf::ml::ocr {
class w_read_video_frames (line 22) | class w_read_video_frames {
FILE: wolf/ml/referee_ocr/w_referee.hpp
type wolf::ml::ocr (line 15) | namespace wolf::ml::ocr {
class w_referee (line 24) | class w_referee {
type result_type (line 31) | enum result_type {
type frame_result_struct (line 45) | struct frame_result_struct {
type match_result_struct (line 73) | struct match_result_struct {
type vote_over_string_vector (line 125) | struct vote_over_string_vector {
type related_results (line 143) | struct related_results {
FILE: wolf/ml/referee_ocr/w_soccer.hpp
type wolf::ml::ocr (line 22) | namespace wolf::ml::ocr {
class w_soccer (line 30) | class w_soccer : public w_referee {
FILE: wolf/ml/referee_ocr/w_utilities.cpp
function get_tracer (line 34) | nostd::shared_ptr<trace::Tracer> get_tracer() {
type wolf::ml::ocr (line 41) | namespace wolf::ml::ocr {
function get_nearest_string (line 43) | auto get_nearest_string(_In_ std::string pInput, std::string pFilePath)
function get_nearest_string (line 74) | auto get_nearest_string(_In_ std::string pInput,
function get_value_from_json_file_by_key (line 106) | std::string get_value_from_json_file_by_key(std::string pJsonFilePath,
function line_of_numbers_in_string_to_vector_of_integers (line 130) | std::vector<int>
function normalized_levenshtein_similarity (line 146) | auto normalized_levenshtein_similarity(_In_ const std::string &s1,
function read_text_file_line_by_line (line 182) | auto read_text_file_line_by_line(_In_ std::string pFilePath)
function replace_string (line 205) | bool replace_string(std::string &str, const std::string &from,
function split_string (line 214) | std::vector<std::string> split_string(std::string input_string,
function string_2_boolean (line 231) | bool string_2_boolean(std::string pVariable) {
function store_image_in_folder (line 250) | auto store_image_in_folder(
function write_in_file_append (line 272) | void write_in_file_append(std::string file_path, std::string content) {
function write_in_file (line 288) | void write_in_file(std::string file_path, std::string content) {
function write_results_in_file (line 304) | auto write_results_in_file(
function is_line_contains_variable (line 336) | auto is_line_contains_variable(const std::string pStr) -> bool {
function set_env (line 350) | auto set_env(_In_ const char *pDotEnvFilePath) -> void {
function get_env_int (line 373) | auto get_env_int(_In_ const char *pKey) -> int {
function get_env_float (line 385) | auto get_env_float(_In_ const char *pKey) -> float {
function get_env_boolean (line 397) | auto get_env_boolean(_In_ const char *pKey) -> bool {
function get_env_string (line 409) | auto get_env_string(_In_ const char *pKey) -> std::string {
function get_env_cv_rect (line 420) | auto get_env_cv_rect(_In_ const char *pKey) -> cv::Rect {
function get_relative_path_to_root (line 434) | auto get_relative_path_to_root() -> std::string {
function get_first_character_of_string (line 453) | auto get_first_character_of_string(_In_ std::string pStr, _In_ bool pE...
FILE: wolf/ml/referee_ocr/w_utilities.hpp
type wolf::ml::ocr (line 18) | namespace wolf::ml::ocr {
FILE: wolf/ml/test/w_image_processor_test.hpp
function BOOST_AUTO_TEST_CASE (line 20) | BOOST_AUTO_TEST_CASE(prepare_image_for_contour_detection_with_default_ar...
function BOOST_AUTO_TEST_CASE (line 35) | BOOST_AUTO_TEST_CASE(negative_image_with_default_arguments) {
function BOOST_AUTO_TEST_CASE (line 45) | BOOST_AUTO_TEST_CASE(make_white_background_with_default_arguments) {
function BOOST_AUTO_TEST_CASE (line 57) | BOOST_AUTO_TEST_CASE(make_white_background_with_threshold_50) {
function BOOST_AUTO_TEST_CASE (line 70) | BOOST_AUTO_TEST_CASE(find_all_contours_on_image_with_contours) {
function BOOST_AUTO_TEST_CASE (line 81) | BOOST_AUTO_TEST_CASE(find_all_contours_on_image_without_contours) {
function BOOST_AUTO_TEST_CASE (line 93) | BOOST_AUTO_TEST_CASE(resize_function_with_only_height_argument) {
function BOOST_AUTO_TEST_CASE (line 100) | BOOST_AUTO_TEST_CASE(resize_function_with_only_width_argument) {
function BOOST_AUTO_TEST_CASE (line 107) | BOOST_AUTO_TEST_CASE(resize_function_without_argument) {
function BOOST_AUTO_TEST_CASE (line 117) | BOOST_AUTO_TEST_CASE(gaussian_filter_with_default_argument) {
function BOOST_AUTO_TEST_CASE (line 128) | BOOST_AUTO_TEST_CASE(gaussian_filter_with_win_size_7) {
function BOOST_AUTO_TEST_CASE (line 139) | BOOST_AUTO_TEST_CASE(threshold_filter_with_default_argument) {
function BOOST_AUTO_TEST_CASE (line 153) | BOOST_AUTO_TEST_CASE(threshold_filter_with_threshold_value_180) {
FILE: wolf/ml/test/w_ocr_engine_test.hpp
function BOOST_AUTO_TEST_CASE (line 23) | BOOST_AUTO_TEST_CASE(check_if_overlapped_with_default_arguments_on_overl...
function BOOST_AUTO_TEST_CASE (line 31) | BOOST_AUTO_TEST_CASE(check_if_overlapped_with_default_arguments_on_non_o...
function BOOST_AUTO_TEST_CASE (line 39) | BOOST_AUTO_TEST_CASE(check_if_overlapped_with_threshold_0_01) {
function BOOST_AUTO_TEST_CASE (line 48) | BOOST_AUTO_TEST_CASE(check_if_overlapped_with_threshold_0_009) {
function BOOST_AUTO_TEST_CASE (line 57) | BOOST_AUTO_TEST_CASE(contours_to_char_structs_with_default_arguments) {
function BOOST_AUTO_TEST_CASE (line 70) | BOOST_AUTO_TEST_CASE(contours_to_char_structs_with_default_arguments_on_...
function BOOST_AUTO_TEST_CASE (line 83) | BOOST_AUTO_TEST_CASE(enhance_contour_image_for_modelwithdefaultarguments) {
function BOOST_AUTO_TEST_CASE (line 93) | BOOST_AUTO_TEST_CASE(enhance_contour_image_for_model_with_resize) {
function BOOST_AUTO_TEST_CASE (line 106) | BOOST_AUTO_TEST_CASE(enhance_contour_image_for_modelwithmake_white) {
function BOOST_AUTO_TEST_CASE (line 119) | BOOST_AUTO_TEST_CASE(euclidean_distance_with_two_non_overlapped_chars) {
function BOOST_AUTO_TEST_CASE (line 130) | BOOST_AUTO_TEST_CASE(euclidean_distance_with_two_overlapped_chars) {
function BOOST_AUTO_TEST_CASE (line 141) | BOOST_AUTO_TEST_CASE(euclidean_distance_with_two_empty_chars) {
function BOOST_AUTO_TEST_CASE (line 148) | BOOST_AUTO_TEST_CASE(filter_chars_by_contour_size_without_restriction) {
function BOOST_AUTO_TEST_CASE (line 170) | BOOST_AUTO_TEST_CASE(filter_chars_by_contour_size_by_area_restriction) {
function BOOST_AUTO_TEST_CASE (line 192) | BOOST_AUTO_TEST_CASE(filter_chars_by_contour_size_by_width_restriction) {
function BOOST_AUTO_TEST_CASE (line 214) | BOOST_AUTO_TEST_CASE(merge_overlapped_contours_on_two_overlapped_contour...
function BOOST_AUTO_TEST_CASE (line 233) | BOOST_AUTO_TEST_CASE(merge_overlapped_contours_on_two_non_overlapped_con...
function BOOST_AUTO_TEST_CASE (line 252) | BOOST_AUTO_TEST_CASE(mask_contour_works) {
FILE: wolf/ml/test/w_referee_test.hpp
function BOOST_AUTO_TEST_CASE (line 22) | BOOST_AUTO_TEST_CASE(concatenate_name_result_function) {
function BOOST_AUTO_TEST_CASE (line 47) | BOOST_AUTO_TEST_CASE(if_the_string_is_in_the_vector_function) {
function BOOST_AUTO_TEST_CASE (line 65) | BOOST_AUTO_TEST_CASE(voting_over_results_and_names_function) {
FILE: wolf/ml/test/w_soccer_test.hpp
function BOOST_AUTO_TEST_CASE (line 26) | BOOST_AUTO_TEST_CASE(set_config_function) {
function ocr_result (line 45) | void ocr_result(char *pResultBuffer, int pResultBufferSize,
function BOOST_AUTO_TEST_CASE (line 63) | BOOST_AUTO_TEST_CASE(single_image_result_extraction_function) {
function BOOST_AUTO_TEST_CASE (line 105) | BOOST_AUTO_TEST_CASE(fill_stat_map_function) {
function BOOST_AUTO_TEST_CASE (line 121) | BOOST_AUTO_TEST_CASE(replace_team_names_with_most_similar_string_finds_s...
function BOOST_AUTO_TEST_CASE (line 138) | BOOST_AUTO_TEST_CASE(initial_match_result_struct_function) {
function BOOST_AUTO_TEST_CASE (line 166) | BOOST_AUTO_TEST_CASE(update_match_data_function) {
function BOOST_AUTO_TEST_CASE (line 203) | BOOST_AUTO_TEST_CASE(get_matches_data_function) {
function BOOST_AUTO_TEST_CASE (line 226) | BOOST_AUTO_TEST_CASE(replace_team_names_with_most_similar_string_finds_s...
FILE: wolf/ml/test/w_utilities_test.hpp
function BOOST_AUTO_TEST_CASE (line 20) | BOOST_AUTO_TEST_CASE(get_value_from_json_file_by_key_gives_value_by_key) {
function BOOST_AUTO_TEST_CASE (line 29) | BOOST_AUTO_TEST_CASE(string_2_boolean_on_capitalized_characters) {
function BOOST_AUTO_TEST_CASE (line 40) | BOOST_AUTO_TEST_CASE(line_of_numbers_in_string_to_vector_of_integers_fun...
function BOOST_AUTO_TEST_CASE (line 50) | BOOST_AUTO_TEST_CASE(store_image_in_folder_function) {
function BOOST_AUTO_TEST_CASE (line 81) | BOOST_AUTO_TEST_CASE(write_results_in_file_function) {
function BOOST_AUTO_TEST_CASE (line 118) | BOOST_AUTO_TEST_CASE(read_text_file_line_by_line_function) {
function BOOST_AUTO_TEST_CASE (line 133) | BOOST_AUTO_TEST_CASE(normalized_levenshtein_similarity_on_one_empty_argu...
function BOOST_AUTO_TEST_CASE (line 138) | BOOST_AUTO_TEST_CASE(normalized_levenshtein_similarity_on_two_empty_argu...
function BOOST_AUTO_TEST_CASE (line 143) | BOOST_AUTO_TEST_CASE(normalized_levenshtein_similarity_on_two_equal_stri...
function BOOST_AUTO_TEST_CASE (line 148) | BOOST_AUTO_TEST_CASE(normalized_levenshtein_similarity_with_similarity_0...
function BOOST_AUTO_TEST_CASE (line 153) | BOOST_AUTO_TEST_CASE(normalized_levenshtein_similarity_on_same_numbers) {
function BOOST_AUTO_TEST_CASE (line 158) | BOOST_AUTO_TEST_CASE(normalized_levenshtein_similarity_on_strings_with_d...
function BOOST_AUTO_TEST_CASE (line 163) | BOOST_AUTO_TEST_CASE(get_nearest_string_with_threshold_0_5_returns_simil...
function BOOST_AUTO_TEST_CASE (line 174) | BOOST_AUTO_TEST_CASE(get_nearest_string_with_threshold_0_9_returns_input) {
function BOOST_AUTO_TEST_CASE (line 185) | BOOST_AUTO_TEST_CASE(get_nearest_string_on_empty_string_returns_empty_st...
function BOOST_AUTO_TEST_CASE (line 196) | BOOST_AUTO_TEST_CASE(replace_string_first_phrase_exists_in_text) {
function BOOST_AUTO_TEST_CASE (line 202) | BOOST_AUTO_TEST_CASE(replace_string_returns_text_if_first_phrase_not_exi...
function BOOST_AUTO_TEST_CASE (line 208) | BOOST_AUTO_TEST_CASE(replace_string_returns_empty_text_if_input_text_was...
function BOOST_AUTO_TEST_CASE (line 214) | BOOST_AUTO_TEST_CASE(is_line_contains_variable_function_find_empty_line) {
function BOOST_AUTO_TEST_CASE (line 220) | BOOST_AUTO_TEST_CASE(is_line_contains_variable_function_find_line_starte...
function BOOST_AUTO_TEST_CASE (line 226) | BOOST_AUTO_TEST_CASE(set_env_function) {
function BOOST_AUTO_TEST_CASE (line 249) | BOOST_AUTO_TEST_CASE(get_env_int_function) {
function BOOST_AUTO_TEST_CASE (line 260) | BOOST_AUTO_TEST_CASE(get_env_float_function) {
function BOOST_AUTO_TEST_CASE (line 271) | BOOST_AUTO_TEST_CASE(get_env_boolean_function) {
function BOOST_AUTO_TEST_CASE (line 282) | BOOST_AUTO_TEST_CASE(get_env_string_function) {
function BOOST_AUTO_TEST_CASE (line 293) | BOOST_AUTO_TEST_CASE(get_env_cv_rect_function) {
function BOOST_AUTO_TEST_CASE (line 307) | BOOST_AUTO_TEST_CASE(get_relative_path_to_root_function) {
FILE: wolf/ml/w_common.cpp
type wolf::ml (line 17) | namespace wolf::ml {
function write_in_file_append (line 19) | auto write_in_file_append(_In_ std::string pFilePath, _In_ std::string...
function read_text_file_line_by_line (line 28) | auto read_text_file_line_by_line(_In_ std::string pFilePath) -> std::v...
function split_string (line 46) | auto split_string(_In_ std::string input_string, _In_ char reference) ...
function string_2_boolean (line 58) | auto string_2_boolean(_In_ std::string pVariable) -> bool {
function is_line_contains_variable (line 72) | auto is_line_contains_variable(const std::string pStr) -> bool {
function set_env (line 82) | auto set_env(_In_ const char* pDotEnvFilePath) -> void {
function get_env_int (line 105) | auto get_env_int(_In_ const char* pKey) -> int {
function get_env_float (line 117) | auto get_env_float(_In_ const char* pKey) -> float {
function get_env_boolean (line 129) | auto get_env_boolean(_In_ const char* pKey) -> bool {
function get_env_string (line 141) | auto get_env_string(_In_ const char* pKey) -> std::string {
FILE: wolf/ml/w_common.hpp
type wolf::ml (line 19) | namespace wolf::ml {
FILE: wolf/stream/grpc/w_grpc_client.hpp
type wolf::stream::rpc (line 23) | namespace wolf::stream::rpc {
class w_grpc_client (line 24) | class w_grpc_client {
method W_API (line 26) | W_API w_grpc_client() noexcept = default;
method W_API (line 27) | W_API ~w_grpc_client() noexcept = default;
method if (line 47) | if (this->_channel == nullptr) {
function W_API (line 119) | W_API void exec(_In_ std::chrono::steady_clock::duration&& p_timeout, ...
FILE: wolf/stream/grpc/w_grpc_server.hpp
type wolf::stream::rpc (line 22) | namespace wolf::stream::rpc {
class w_grpc_server (line 23) | class w_grpc_server {
FILE: wolf/stream/http/w_http_server.cpp
function log_message (line 6) | int log_message(const struct mg_connection *p_conn, const char *p_message)
function CivetCallbacks (line 14) | const CivetCallbacks *get_civet_callbacks()
FILE: wolf/stream/http/w_http_server.hpp
type wolf::stream::http (line 11) | namespace wolf::stream::http
class w_http_server (line 17) | class w_http_server
method w_http_server (line 25) | w_http_server(const w_http_server &) = delete;
method w_http_server (line 28) | w_http_server &operator=(const w_http_server &) = delete;
FILE: wolf/stream/janus/w_janus_api_emc.cpp
function EMSCRIPTEN_KEEPALIVE (line 14) | EMSCRIPTEN_KEEPALIVE
function EMSCRIPTEN_KEEPALIVE (line 21) | EMSCRIPTEN_KEEPALIVE
function EMSCRIPTEN_KEEPALIVE (line 28) | EMSCRIPTEN_KEEPALIVE
function else (line 207) | else if (p_msg["error"]) {
FILE: wolf/stream/janus/w_janus_api_emc.hpp
type wolf::stream::janus (line 13) | namespace wolf::stream::janus {
class w_janus_api_emc (line 14) | class w_janus_api_emc {
FILE: wolf/stream/quic/datatypes/common_flags.hpp
type wolf::stream::quic (line 5) | namespace wolf::stream::quic {
type w_connection_shutdown_flag (line 10) | enum class w_connection_shutdown_flag {
type w_stream_open_flag (line 18) | enum class w_stream_open_flag {
type w_stream_start_flag (line 27) | enum class w_stream_start_flag {
type w_stream_shutdown_flag (line 38) | enum class w_stream_shutdown_flag {
type w_receive_flag (line 50) | enum class w_receive_flag {
type w_send_flag (line 59) | enum class w_send_flag {
FILE: wolf/stream/quic/datatypes/w_address.hpp
type wolf::stream::quic (line 9) | namespace wolf::stream::quic {
type w_address_family (line 14) | enum class w_address_family {
function w_address (line 25) | class W_API w_address {
function raw (line 69) | auto raw() const noexcept { return &_address; }
function w_address (line 71) | w_address(internal::w_raw_tag, const QUIC_ADDR& p_raw_addr)
FILE: wolf/stream/quic/datatypes/w_alpn.hpp
type wolf::stream::quic (line 6) | namespace wolf::stream::quic {
function w_alpn_view (line 10) | inline w_alpn_view as_alpn_view(w_alpn_view p_alpn_view)
function w_alpn_view (line 15) | inline w_alpn_view as_alpn_view(const std::string_view p_str)
FILE: wolf/stream/quic/datatypes/w_credential_config.hpp
type wolf::stream::quic (line 15) | namespace wolf::stream::quic {
type w_credential_flag (line 20) | enum class w_credential_flag {
class W_API (line 48) | class W_API
function w_certificate_hash (line 55) | class W_API w_certificate_hash {
function raw (line 84) | auto raw() const noexcept { return &_cert; }
class w_certificate_file (line 96) | class w_certificate_file {
method w_certificate_file (line 100) | w_certificate_file(std::string p_cert_file_path, std::string p_key_fil...
method w_certificate_file (line 108) | w_certificate_file(const w_certificate_file& p_other)
method w_certificate_file (line 112) | w_certificate_file(w_certificate_file&& p_other)
method w_certificate_file (line 116) | w_certificate_file& operator=(const w_certificate_file& p_other)
method w_certificate_file (line 125) | w_certificate_file& operator=(w_certificate_file&& p_other)
method raw (line 137) | auto raw() noexcept { return &_cert; }
method raw (line 138) | auto raw() const noexcept { return &_cert; }
class w_credential_config (line 151) | class w_credential_config {
method w_credential_config (line 164) | explicit w_credential_config(
method w_credential_config (line 176) | w_credential_config(const w_credential_config& p_other)
method w_credential_config (line 181) | w_credential_config(w_credential_config&& p_other)
method w_credential_config (line 186) | w_credential_config& operator=(const w_credential_config& p_other)
method w_credential_config (line 193) | w_credential_config& operator=(w_credential_config&& p_other)
method setup_raw_config_from_variant (line 203) | void setup_raw_config_from_variant(cert_variant_type& p_cert_variant)
method raw (line 220) | auto raw() noexcept { return &_config; }
method raw (line 221) | auto raw() const noexcept { return &_config; }
FILE: wolf/stream/quic/datatypes/w_new_connection_info.hpp
type wolf::stream::quic (line 11) | namespace wolf::stream::quic {
function w_new_connection_info (line 18) | class W_API w_new_connection_info {
FILE: wolf/stream/quic/datatypes/w_registration_config.hpp
type wolf::stream::quic (line 9) | namespace wolf::stream::quic {
type w_execution_profile (line 16) | enum class w_execution_profile {
class w_registration_config (line 26) | class w_registration_config {
method w_registration_config (line 33) | w_registration_config(std::string p_app_name,
method w_execution_profile (line 52) | [[nodiscard]] w_execution_profile get_execution_profile() const noex...
method set_execution_profile (line 60) | void set_execution_profile(w_execution_profile p_profile) noexcept
method raw (line 66) | auto raw() noexcept { return &_config; }
method raw (line 67) | auto raw() const noexcept { return &_config; }
FILE: wolf/stream/quic/datatypes/w_settings.hpp
type wolf::stream::quic (line 10) | namespace wolf::stream::quic {
type w_server_resumption_level (line 17) | enum class w_server_resumption_level {
type w_congestion_control_algorithm (line 26) | enum class w_congestion_control_algorithm {
class w_settings (line 45) | class w_settings {
method raw (line 85) | auto raw() const noexcept
FILE: wolf/stream/quic/datatypes/w_status.hpp
type wolf::stream::quic (line 9) | namespace wolf::stream::quic {
type internal (line 11) | namespace internal {
type w_status_code (line 59) | enum class w_status_code {
function w_status (line 102) | class W_API w_status {
function status_to_str (line 145) | inline std::string_view status_to_str(w_status_code p_status_code)
function status_to_str (line 153) | inline std::string_view status_to_str(w_status p_status)
FILE: wolf/stream/quic/events/w_connection_event.hpp
type wolf::stream::quic (line 18) | namespace wolf::stream::quic {
function w_connection_event_connected (line 27) | class W_API w_connection_event_connected {
function w_connection_event_shutdown_initiated_by_peer (line 67) | class W_API w_connection_event_shutdown_initiated_by_peer {
function w_connection_event_local_address_changed (line 99) | class W_API w_connection_event_local_address_changed {
function w_connection_event_streams_available (line 238) | class W_API w_connection_event_streams_available {
function w_connection_event_ideal_processor_changed (line 275) | class W_API w_connection_event_ideal_processor_changed {
function w_connection_event_datagram_send_state_changed (line 474) | class W_API w_connection_event_datagram_send_state_changed {
function w_connection_event (line 570) | class W_API w_connection_event {
FILE: wolf/stream/quic/events/w_listener_event.hpp
type wolf::stream::quic (line 14) | namespace wolf::stream::quic {
function w_listener_event_new_connection (line 25) | class W_API w_listener_event_new_connection {
function w_listener_event_stop_complete (line 110) | class W_API w_listener_event_stop_complete {
function w_listener_event (line 145) | class W_API w_listener_event {
FILE: wolf/stream/quic/events/w_stream_event.hpp
type wolf::stream::quic (line 13) | namespace wolf::stream::quic {
function w_stream_event_start_complete (line 22) | class W_API w_stream_event_start_complete {
function w_stream_event_receive (line 64) | class W_API w_stream_event_receive {
function w_stream_event_send_complete (line 109) | class W_API w_stream_event_send_complete {
function w_stream_event_peer_send_shutdown (line 141) | class W_API w_stream_event_peer_send_shutdown {
function w_stream_event_peer_receive_aborted (line 200) | class W_API w_stream_event_peer_receive_aborted {
function w_stream_event_send_shutdown_complete (line 232) | class W_API w_stream_event_send_shutdown_complete {
function w_stream_event_shutdown_complete (line 264) | class W_API w_stream_event_shutdown_complete {
function w_stream_event_ideal_send_buffer_size (line 321) | class W_API w_stream_event_ideal_send_buffer_size {
function w_stream_event_peer_accepted (line 353) | class W_API w_stream_event_peer_accepted {
FILE: wolf/stream/quic/handles/w_configuration.cpp
type wolf::stream::quic (line 7) | namespace wolf::stream::quic {
function w_status (line 58) | w_status wolf::stream::quic::w_configuration::load_credential(const w_...
FILE: wolf/stream/quic/handles/w_configuration.hpp
type wolf::stream::quic (line 15) | namespace wolf::stream::quic {
function w_configuration (line 26) | class W_API w_configuration {
FILE: wolf/stream/quic/handles/w_connection.cpp
type wolf::stream::quic (line 9) | namespace wolf::stream::quic {
function QUIC_STATUS (line 11) | QUIC_STATUS w_connection::internal_raw_callback(HQUIC p_connection_raw,
function w_status (line 106) | w_status w_connection::start(w_configuration& p_config, const char* p_...
FILE: wolf/stream/quic/handles/w_connection.hpp
type wolf::stream::quic (line 16) | namespace wolf::stream::quic {
class w_connection_event (line 18) | class w_connection_event
class w_listener_event_new_connection (line 19) | class w_listener_event_new_connection
function w_connection (line 24) | class W_API w_connection {
FILE: wolf/stream/quic/handles/w_listener.cpp
type wolf::stream::quic (line 8) | namespace wolf::stream::quic {
function QUIC_STATUS (line 10) | QUIC_STATUS w_listener::internal_raw_callback(HQUIC p_listener_raw,
function w_status (line 101) | w_status w_listener::start(const w_address& p_address, w_alpn_view p_a...
FILE: wolf/stream/quic/handles/w_listener.hpp
type wolf::stream::quic (line 16) | namespace wolf::stream::quic {
function w_listener (line 21) | class W_API w_listener {
FILE: wolf/stream/quic/handles/w_registration.cpp
type wolf::stream::quic (line 8) | namespace wolf::stream::quic {
FILE: wolf/stream/quic/handles/w_registration.hpp
type wolf::stream::quic (line 11) | namespace wolf::stream::quic {
function w_registration (line 26) | class W_API w_registration {
FILE: wolf/stream/quic/handles/w_stream.cpp
type wolf::stream::quic (line 8) | namespace wolf::stream::quic {
function QUIC_STATUS (line 10) | QUIC_STATUS w_stream::internal_raw_callback(HQUIC stream_raw,
function w_status (line 110) | w_status w_stream::start(wolf::w_flags<w_stream_start_flag> p_flags)
function w_status (line 143) | w_status w_stream::send(std::string_view p_str, wolf::w_flags<w_send_f...
function w_status (line 148) | w_status w_stream::send(std::span<uint8_t> p_buffer, wolf::w_flags<w_s...
FILE: wolf/stream/quic/handles/w_stream.hpp
type wolf::stream::quic (line 14) | namespace wolf::stream::quic {
class w_stream_event (line 16) | class w_stream_event
class w_connection_event_peer_stream_started (line 17) | class w_connection_event_peer_stream_started
function w_stream (line 22) | class W_API w_stream {
FILE: wolf/stream/quic/internal/common.hpp
type wolf::stream::quic::internal (line 7) | namespace wolf::stream::quic::internal {
class W_API (line 12) | class W_API
function w_raw_access (line 28) | class W_API w_raw_access {
FILE: wolf/stream/quic/internal/w_msquic_api.cpp
type wolf::stream::quic::internal (line 5) | namespace wolf::stream::quic::internal {
FILE: wolf/stream/quic/internal/w_msquic_api.hpp
type wolf::stream::quic::internal (line 9) | namespace wolf::stream::quic::internal {
function w_msquic_api (line 14) | class W_API w_msquic_api {
FILE: wolf/stream/quic/w_quic_client.hpp
type wolf::stream::quic (line 16) | namespace wolf::stream::quic {
type w_quic_client_config (line 21) | struct w_quic_client_config {
class w_quic_client (line 38) | class w_quic_client {
method w_quic_client (line 40) | w_quic_client(const w_quic_client&) = delete;
method w_quic_client (line 41) | w_quic_client(w_quic_client&&) noexcept = default;
method w_quic_client (line 43) | w_quic_client& operator=(const w_quic_client&&) noexcept = delete;
method w_quic_client (line 44) | w_quic_client& operator=(w_quic_client&&) noexcept = default;
method make (line 59) | [[nodiscard]] static auto make(const w_quic_client_config& p_client_...
method run (line 88) | auto run(const char* p_host, std::uint16_t p_port, w_connection::cal...
method stop (line 109) | void stop()
method w_quic_client (line 120) | w_quic_client() {}
FILE: wolf/stream/quic/w_quic_server.hpp
type wolf::stream::quic (line 16) | namespace wolf::stream::quic {
type w_quic_server_config (line 21) | struct w_quic_server_config {
class w_quic_server (line 35) | class w_quic_server {
method w_quic_server (line 37) | w_quic_server(const w_quic_server&) = delete;
method w_quic_server (line 38) | w_quic_server(w_quic_server&&) noexcept = default;
method w_quic_server (line 40) | w_quic_server& operator=(const w_quic_server&&) noexcept = delete;
method w_quic_server (line 41) | w_quic_server& operator=(w_quic_server&&) noexcept = default;
method make (line 56) | [[nodiscard]] static auto make(const w_quic_server_config& p_server_...
method run (line 79) | auto run(std::uint16_t p_port, w_listener::callback_type p_listener_cb)
method stop (line 102) | void stop()
method w_quic_server (line 113) | w_quic_server() {}
FILE: wolf/stream/rist/w_rist.cpp
function s_on_log_callback (line 14) | static int s_on_log_callback(_In_ void *p_arg, _In_ rist_log_level p_log...
function s_on_auth_handler_connect_callback (line 23) | static int s_on_auth_handler_connect_callback(_In_ void *p_arg, _In_z_ c...
function s_on_auth_handler_disconnect_callback (line 36) | static int s_on_auth_handler_disconnect_callback(_In_ void *p_arg,
function s_on_receiver_data_callback (line 46) | static int s_on_receiver_data_callback(_In_ void *p_arg,
FILE: wolf/stream/rist/w_rist.hpp
type wolf::stream::rist (line 13) | namespace wolf::stream::rist {
class w_rist (line 14) | class w_rist {
method W_API (line 28) | W_API w_rist(w_rist &&p_other) noexcept = default;
method W_API (line 30) | W_API w_rist &operator=(w_rist &&p_other) noexcept = default;
method w_rist (line 83) | w_rist(const w_rist &) = delete;
method w_rist (line 84) | w_rist &operator=(const w_rist &) = delete;
FILE: wolf/stream/rist/w_rist_data_block.hpp
type wolf::stream::rist (line 17) | namespace wolf::stream::rist {
class w_rist_data_block (line 18) | class w_rist_data_block {
method W_API (line 26) | W_API w_rist_data_block(w_rist_data_block &&p_other) noexcept = defa...
method W_API (line 31) | W_API w_rist_data_block &
method w_rist_data_block (line 69) | w_rist_data_block(const w_rist_data_block &) = delete;
method w_rist_data_block (line 71) | w_rist_data_block &operator=(const w_rist_data_block &) = delete;
FILE: wolf/stream/test/ffmpeg_stream.hpp
function BOOST_AUTO_TEST_CASE (line 17) | BOOST_AUTO_TEST_CASE(ffmpeg_stream_test) {
FILE: wolf/stream/test/grpc.hpp
function BOOST_AUTO_TEST_CASE (line 20) | BOOST_AUTO_TEST_CASE(grpc_client_unary_test) {
FILE: wolf/stream/test/quic.hpp
function BOOST_AUTO_TEST_CASE (line 13) | BOOST_AUTO_TEST_CASE(msquic_base_types) {
function BOOST_AUTO_TEST_CASE (line 24) | BOOST_AUTO_TEST_CASE(msquic_server_client) {
FILE: wolf/system/compression/w_lz4.cpp
function s_check_input_len (line 11) | static boost::leaf::result<int>
function s_shrink_to_fit (line 27) | static std::vector<std::byte>
FILE: wolf/system/compression/w_lz4.hpp
type wolf::system::compression (line 12) | namespace wolf::system::compression {
type w_lz4 (line 14) | struct w_lz4 {
FILE: wolf/system/compression/w_lzma.cpp
function s_lzma_free (line 21) | static void s_lzma_free(ISzAllocPtr p_ptr, void *p_addr) noexcept {
function s_lzma_prop (line 28) | static void s_lzma_prop(_Inout_ CLzmaEncProps *p_prop, _In_ uint32_t p_l...
FILE: wolf/system/compression/w_lzma.hpp
type wolf::system::compression (line 12) | namespace wolf::system::compression {
type w_lzma (line 14) | struct w_lzma {
FILE: wolf/system/db/w_postgresql.hpp
type wolf::system::pgdb (line 13) | namespace wolf::system::pgdb {
type internal (line 15) | namespace internal {
type c_type_deleter (line 27) | struct c_type_deleter {
function dbconn_error_check (line 50) | inline auto dbconn_error_check(const dbconn& p_conn) -> boost::leaf:...
function dbresult_error_check (line 70) | inline auto dbresult_error_check(const dbresult& p_res) -> boost::le...
function to_string (line 91) | inline auto to_string(T p_value) -> std::string
function to_string (line 96) | inline auto to_string(const char* const p_value) -> std::string
function to_string (line 101) | inline auto to_string(const std::string& p_value) -> std::string
function to_string (line 106) | inline auto to_string(std::string&& p_value) -> std::string
function from_string (line 113) | inline auto from_string(T* p_ptr, const char* p_str) -> boost::leaf:...
function from_string (line 123) | inline auto from_string(std::string* p_ptr, const char* p_str) -> bo...
class w_pgdb_conection (line 132) | class w_pgdb_conection
method w_pgdb_conection (line 446) | w_pgdb_conection(const w_pgdb_conection&) = delete;
method w_pgdb_conection (line 447) | w_pgdb_conection(w_pgdb_conection&& other) noexcept
method w_pgdb_conection (line 451) | w_pgdb_conection& operator=(const w_pgdb_conection&) = delete;
method w_pgdb_conection (line 452) | w_pgdb_conection& operator=(w_pgdb_conection&& other) noexcept
method make (line 470) | static auto make(const std::pair<Ts, Us>& ...p_params) -> boost::lea...
method make (line 492) | static auto make(const char* p_conn_str) -> boost::leaf::result<w_pg...
method execute (line 512) | auto execute(const char* p_sqlstr, Args&& ...p_params) -> boost::lea...
method query (line 565) | auto query(const char* p_sqlstr, Args&& ...p_args) -> boost::leaf::r...
method stream_query (line 585) | auto stream_query(const char* p_sqlstr, Args&& ...p_args) -> boost::...
method w_pgdb_conection (line 597) | explicit w_pgdb_conection(internal::dbconn&& p_conn) : _conn_ptr(std...
method raw (line 599) | auto raw() noexcept -> internal::dbconn& { return _conn_ptr; }
method raw (line 600) | auto raw() const noexcept -> const internal::dbconn& { return _conn_...
class w_pgdb_execresult (line 133) | class w_pgdb_execresult
method w_pgdb_execresult (line 394) | w_pgdb_execresult(const w_pgdb_execresult&) = delete;
method w_pgdb_execresult (line 395) | w_pgdb_execresult(w_pgdb_execresult&& p_other) noexcept
method w_pgdb_execresult (line 400) | w_pgdb_execresult& operator=(const w_pgdb_execresult&) = delete;
method w_pgdb_execresult (line 401) | w_pgdb_execresult& operator=(w_pgdb_execresult&& p_other) noexcept
method as_query (line 410) | auto as_query() && -> w_pgdb_queryresult
method done (line 419) | void done()
method w_pgdb_execresult (line 427) | explicit w_pgdb_execresult(internal::dbconn& p_conn, internal::dbres...
method raw (line 432) | auto raw() noexcept -> internal::dbresult& { return _res_ptr; }
method raw (line 433) | auto raw() const noexcept -> const internal::dbresult& { return _res...
class w_pgdb_queryresult (line 134) | class w_pgdb_queryresult
method w_pgdb_queryresult (line 227) | w_pgdb_queryresult(const w_pgdb_queryresult&) = delete;
method w_pgdb_queryresult (line 228) | w_pgdb_queryresult(w_pgdb_queryresult&& p_other) noexcept
method w_pgdb_queryresult (line 234) | w_pgdb_queryresult& operator=(const w_pgdb_queryresult&) = delete;
method w_pgdb_queryresult (line 235) | w_pgdb_queryresult& operator=(w_pgdb_queryresult&& p_other) noexcept
method size (line 246) | auto size() const noexcept -> std::size_t
method field_count (line 254) | auto field_count() const noexcept -> std::size_t
method field_name_at (line 263) | auto field_name_at(std::size_t p_index) const noexcept -> const char*
method is_empty (line 271) | auto is_empty() -> bool
method on_each (line 286) | auto on_each(F&& p_handler) -> boost::leaf::result<std::size_t>
method on_single (line 317) | auto on_single(F&& p_handler) -> boost::leaf::result<void>
method cancel (line 341) | auto cancel() -> boost::leaf::result<void>
method done (line 363) | void done()
method w_pgdb_queryresult (line 371) | explicit w_pgdb_queryresult(internal::dbconn& p_conn, internal::dbre...
method raw (line 376) | auto raw() noexcept -> internal::dbresult& { return _res_ptr; }
method raw (line 377) | auto raw() const noexcept -> const internal::dbresult& { return _res...
class w_pgdb_record (line 139) | class w_pgdb_record {
method at (line 147) | auto at(std::size_t p_field_index) const noexcept -> const char*
method size (line 155) | auto size() const noexcept -> std::size_t
method scan (line 181) | auto scan(std::size_t p_field_index, T* p_ptr) -> boost::leaf::resul...
method scan (line 187) | auto scan(std::size_t p_field_index, T* p_first, U* p_second, Rest* ...
method scan_field_into (line 196) | auto scan_field_into(std::size_t p_field_index, T* p_ptr) -> boost::...
method w_pgdb_record (line 208) | w_pgdb_record(const internal::dbresult& p_res, std::size_t p_index) ...
class w_pgdb_queryresult (line 220) | class w_pgdb_queryresult {
method w_pgdb_queryresult (line 227) | w_pgdb_queryresult(const w_pgdb_queryresult&) = delete;
method w_pgdb_queryresult (line 228) | w_pgdb_queryresult(w_pgdb_queryresult&& p_other) noexcept
method w_pgdb_queryresult (line 234) | w_pgdb_queryresult& operator=(const w_pgdb_queryresult&) = delete;
method w_pgdb_queryresult (line 235) | w_pgdb_queryresult& operator=(w_pgdb_queryresult&& p_other) noexcept
method size (line 246) | auto size() const noexcept -> std::size_t
method field_count (line 254) | auto field_count() const noexcept -> std::size_t
method field_name_at (line 263) | auto field_name_at(std::size_t p_index) const noexcept -> const char*
method is_empty (line 271) | auto is_empty() -> bool
method on_each (line 286) | auto on_each(F&& p_handler) -> boost::leaf::result<std::size_t>
method on_single (line 317) | auto on_single(F&& p_handler) -> boost::leaf::result<void>
method cancel (line 341) | auto cancel() -> boost::leaf::result<void>
method done (line 363) | void done()
method w_pgdb_queryresult (line 371) | explicit w_pgdb_queryresult(internal::dbconn& p_conn, internal::dbre...
method raw (line 376) | auto raw() noexcept -> internal::dbresult& { return _res_ptr; }
method raw (line 377) | auto raw() const noexcept -> const internal::dbresult& { return _res...
class w_pgdb_execresult (line 387) | class w_pgdb_execresult {
method w_pgdb_execresult (line 394) | w_pgdb_execresult(const w_pgdb_execresult&) = delete;
method w_pgdb_execresult (line 395) | w_pgdb_execresult(w_pgdb_execresult&& p_other) noexcept
method w_pgdb_execresult (line 400) | w_pgdb_execresult& operator=(const w_pgdb_execresult&) = delete;
method w_pgdb_execresult (line 401) | w_pgdb_execresult& operator=(w_pgdb_execresult&& p_other) noexcept
method as_query (line 410) | auto as_query() && -> w_pgdb_queryresult
method done (line 419) | void done()
method w_pgdb_execresult (line 427) | explicit w_pgdb_execresult(internal::dbconn& p_conn, internal::dbres...
method raw (line 432) | auto raw() noexcept -> internal::dbresult& { return _res_ptr; }
method raw (line 433) | auto raw() const noexcept -> const internal::dbresult& { return _res...
class w_pgdb_conection (line 444) | class w_pgdb_conection {
method w_pgdb_conection (line 446) | w_pgdb_conection(const w_pgdb_conection&) = delete;
method w_pgdb_conection (line 447) | w_pgdb_conection(w_pgdb_conection&& other) noexcept
method w_pgdb_conection (line 451) | w_pgdb_conection& operator=(const w_pgdb_conection&) = delete;
method w_pgdb_conection (line 452) | w_pgdb_conection& operator=(w_pgdb_conection&& other) noexcept
method make (line 470) | static auto make(const std::pair<Ts, Us>& ...p_params) -> boost::lea...
method make (line 492) | static auto make(const char* p_conn_str) -> boost::leaf::result<w_pg...
method execute (line 512) | auto execute(const char* p_sqlstr, Args&& ...p_params) -> boost::lea...
method query (line 565) | auto query(const char* p_sqlstr, Args&& ...p_args) -> boost::leaf::r...
method stream_query (line 585) | auto stream_query(const char* p_sqlstr, Args&& ...p_args) -> boost::...
method w_pgdb_conection (line 597) | explicit w_pgdb_conection(internal::dbconn&& p_conn) : _conn_ptr(std...
method raw (line 599) | auto raw() noexcept -> internal::dbconn& { return _conn_ptr; }
method raw (line 600) | auto raw() const noexcept -> const internal::dbconn& { return _conn_...
FILE: wolf/system/gamepad/w_gamepad_client.hpp
type wolf::system::gamepad (line 9) | namespace wolf::system::gamepad {
class w_gamepad_client (line 10) | class w_gamepad_client {
method W_API (line 14) | W_API static bool
FILE: wolf/system/gamepad/w_gamepad_client_emc.cpp
function EM_BOOL (line 16) | EM_BOOL gamepadconnected_callback(int eventType, const EmscriptenGamepad...
function EM_BOOL (line 23) | EM_BOOL gamepaddisconnected_callback(int eventType, const EmscriptenGame...
FILE: wolf/system/gamepad/w_gamepad_client_keymap.hpp
type wolf::system::gamepad (line 7) | namespace wolf::system::gamepad {
FILE: wolf/system/gamepad/w_gamepad_client_sdl.cpp
function s_get_sdl_last_error_msg (line 15) | static std::string s_get_sdl_last_error_msg() noexcept {
FILE: wolf/system/gamepad/w_gamepad_client_types.hpp
type wolf::system::gamepad (line 7) | namespace wolf::system::gamepad {
type w_gamepad_client_event_type (line 9) | enum class w_gamepad_client_event_type { button, axis, max }
type w_gamepad_client_state_type (line 11) | enum class w_gamepad_client_state_type { released, pressed, max }
type w_gamepad_client_button_type (line 13) | enum class w_gamepad_client_button_type {
type w_gamepad_client_axis_type (line 45) | enum class w_gamepad_client_axis_type {
type w_gamepad_client_button (line 55) | struct w_gamepad_client_button {
type w_gamepad_client_axis (line 62) | struct w_gamepad_client_axis {
FILE: wolf/system/gamepad/w_gamepad_virtual.cpp
function w_gamepad_virtual (line 17) | w_gamepad_virtual &w_gamepad_virtual::operator=(_Inout_ w_gamepad_virtua...
FILE: wolf/system/gamepad/w_gamepad_virtual.hpp
type wolf::system::gamepad (line 17) | namespace wolf::system::gamepad {
type w_gamepad_virtual (line 18) | struct w_gamepad_virtual {
method w_gamepad_virtual (line 55) | w_gamepad_virtual(const w_gamepad_virtual &) = delete;
method w_gamepad_virtual (line 57) | w_gamepad_virtual &operator=(const w_gamepad_virtual &) = delete;
FILE: wolf/system/gamepad/w_gamepad_virtual_bus.hpp
type wolf::system::gamepad (line 12) | namespace wolf::system::gamepad {
type w_gamepad_virtual_bus (line 13) | struct w_gamepad_virtual_bus {
FILE: wolf/system/gamepad/w_gamepad_virtual_pool.hpp
type wolf::system::gamepad (line 12) | namespace wolf::system::gamepad {
class w_gamepad_virtual_pool (line 13) | class w_gamepad_virtual_pool {
FILE: wolf/system/getopt.h
type option (line 118) | struct option
type option (line 120) | struct option
function _vwarnx (line 138) | static void
function warnx (line 147) | static void
function gcd (line 159) | static int
function permute_args (line 179) | static void
function getopt (line 218) | int
type option (line 267) | struct option /* specification for a long form option... */
function parse_long_options (line 287) | static int parse_long_options(char *const *nargv, const char *options,
function getopt_internal (line 410) | static int getopt_internal(int nargc, char *const *nargv, const char *op...
function getopt_long (line 600) | int getopt_long(int nargc, char *const *nargv, const char *options,
function getopt_long_only (line 609) | int getopt_long_only(int nargc, char *const *nargv, const char *options,
FILE: wolf/system/invocable.h
function namespace (line 55) | namespace ofats {
function swap (line 186) | void swap(any_invocable_impl& rhs) noexcept {
function destroy (line 217) | void destroy() noexcept {
function R (line 224) | R call(ArgTypes... args) const noexcept(is_noexcept) {
FILE: wolf/system/log/w_log.cpp
function w_log_config (line 138) | w_log_config w_log::get_config() const { return this->_config; }
FILE: wolf/system/log/w_log.hpp
type wolf::system::log (line 27) | namespace wolf::system::log {
class w_log (line 28) | class w_log {
method W_API (line 34) | W_API w_log(w_log &&p_other) noexcept {
method W_API (line 38) | W_API w_log &operator=(w_log &&p_other) noexcept {
method W_API (line 56) | W_API void write(_In_ const std::string_view p_fmt, _In_ Args &&...p...
method W_API (line 62) | W_API void write(_In_ const spdlog::level::level_enum &p_level,
method W_API (line 70) | W_API void write(_In_ const fmt::v9::format_string<Args...> p_fmt,
method W_API (line 78) | W_API void write(_In_ const spdlog::level::level_enum &p_level,
method w_log (line 94) | w_log(const w_log &) = delete;
method w_log (line 96) | w_log &operator=(const w_log &) = delete;
FILE: wolf/system/log/w_log_config.hpp
type wolf::system::log (line 14) | namespace wolf::system::log {
type w_log_sink (line 19) | enum w_log_sink {
function w_log_sink (line 29) | inline w_log_sink operator|(w_log_sink p_left, w_log_sink p_right) {
type w_log_config (line 34) | struct w_log_config {
FILE: wolf/system/script/w_lua.hpp
type wolf::system::script (line 13) | namespace wolf::system::script {
class w_lua (line 15) | class w_lua {
method W_API (line 17) | W_API w_lua()
method W_API (line 27) | W_API w_lua(w_lua &&p_other) noexcept { _move(std::forward<w_lua &&>...
method W_API (line 29) | W_API w_lua &operator=(w_lua &&p_other) noexcept {
method W_API (line 39) | W_API void open_libraries(ARGS &&...p_libs) {
method if (line 49) | if (!_load_result.valid()) {
function W_API (line 60) | W_API boost::leaf::result<void> load_from_buffer(const std::string_view ...
function W_API (line 74) | W_API boost::leaf::result<std::tuple<RETYPES...>> run(ARGS &&...p_args) {
function W_API (line 98) | W_API boost::leaf::result<std::tuple<RETYPES...>> run_file(const std::fi...
function W_API (line 120) | W_API boost::leaf::result<std::tuple<RETYPES...>> run_from_buffer(const ...
function W_API (line 142) | W_API boost::leaf::result<void> bind_to_function(const std::string &p_lu...
function W_API (line 158) | W_API boost::leaf::result<std::tuple<RETYPES...>> call_function(const st...
function W_API (line 182) | W_API std::shared_ptr<sol::state> get_state() { return this->_lua; }
function W_API (line 191) | W_API boost::leaf::result<void> get_global_variable(const std::string_vi...
function W_API (line 207) | W_API boost::leaf::result<void> set_global_variable(std::string_view p_n...
function _release (line 223) | void _release() {
function _move (line 230) | void _move(w_lua &&p_other) noexcept {
function w_lua_panic (line 238) | inline void w_lua_panic(sol::optional<std::string> p_maybe_msg) {
FILE: wolf/system/script/w_python.hpp
type wolf::system::python (line 9) | namespace wolf::system::python {
class w_python (line 32) | class w_python {
method w_python (line 110) | w_python(const w_python&) = delete;
method w_python (line 112) | w_python& operator=(const w_python&) = delete;
FILE: wolf/system/socket/w_socket_options.hpp
type wolf::system::socket (line 23) | namespace wolf::system::socket {
function make_connection_id (line 25) | inline std::string make_connection_id() {
type w_socket_options (line 36) | struct w_socket_options {
method set_to_socket (line 42) | void set_to_socket(_Inout_ boost::asio::ip::tcp::socket &p_socket) {
method set_to_acceptor (line 58) | void
FILE: wolf/system/socket/w_tcp_client.hpp
type wolf::system::socket (line 18) | namespace wolf::system::socket {
class w_tcp_client (line 19) | class w_tcp_client {
method W_API (line 25) | W_API w_tcp_client(w_tcp_client &&p_other) = default;
method W_API (line 27) | W_API w_tcp_client &operator=(w_tcp_client &&p_other) = default;
method w_tcp_client (line 89) | w_tcp_client(const w_tcp_client &) = delete;
method w_tcp_client (line 91) | w_tcp_client &operator=(const w_tcp_client &) = delete;
FILE: wolf/system/socket/w_tcp_server.cpp
function watchdog (line 24) | static boost::asio::awaitable<std::errc>
function on_handle_session (line 40) | static boost::asio::awaitable<void> on_handle_session(
function s_session (line 73) | static boost::asio::awaitable<void>
function s_listen (line 95) | static boost::asio::awaitable<void> s_listen(
FILE: wolf/system/socket/w_tcp_server.hpp
type wolf::system::socket (line 12) | namespace wolf::system::socket {
class w_tcp_server (line 13) | class w_tcp_server {
FILE: wolf/system/socket/w_ws_client.hpp
type wolf::system::socket (line 8) | namespace wolf::system::socket {
class w_ws_client (line 9) | class w_ws_client {
method W_API (line 15) | W_API w_ws_client(w_ws_client &&p_other) = default;
method W_API (line 17) | W_API w_ws_client &operator=(w_ws_client &&p_other) = default;
method w_ws_client (line 97) | w_ws_client(const w_ws_client &) = delete;
method w_ws_client (line 99) | w_ws_client &operator=(const w_ws_client &) = delete;
FILE: wolf/system/socket/w_ws_client_emc.hpp
type wolf::system::socket (line 10) | namespace wolf::system::socket {
class w_ws_client_emc (line 14) | class w_ws_client_emc {
method W_API (line 16) | W_API w_ws_client_emc() noexcept = default;
method W_API (line 17) | W_API virtual ~w_ws_client_emc() noexcept { std::ignore = close(); }
method W_API (line 20) | W_API w_ws_client_emc(w_ws_client_emc &&p_other) noexcept {
method W_API (line 24) | W_API w_ws_client_emc &operator=(w_ws_client_emc &&p_other) noexcept {
method w_ws_client_emc (line 47) | w_ws_client_emc(const w_ws_client_emc &) = delete;
method w_ws_client_emc (line 49) | w_ws_client_emc &operator=(const w_ws_client_emc &) = delete;
FILE: wolf/system/socket/w_ws_server.cpp
function s_session (line 13) | static boost::asio::awaitable<void>
function s_listen (line 63) | static boost::asio::awaitable<void>
FILE: wolf/system/socket/w_ws_server.hpp
type wolf::system::socket (line 8) | namespace wolf::system::socket {
class w_ws_server (line 9) | class w_ws_server {
FILE: wolf/system/test/compress.hpp
function BOOST_AUTO_TEST_CASE (line 17) | BOOST_AUTO_TEST_CASE(compress_lz4_test) {
function BOOST_AUTO_TEST_CASE (line 61) | BOOST_AUTO_TEST_CASE(compress_lzma_test) {
FILE: wolf/system/test/coroutine.hpp
function BOOST_AUTO_TEST_CASE (line 17) | BOOST_AUTO_TEST_CASE(coroutine_test) {
FILE: wolf/system/test/gamepad.hpp
function BOOST_AUTO_TEST_CASE (line 16) | BOOST_AUTO_TEST_CASE(gamepad_test) {
function BOOST_AUTO_TEST_CASE (line 28) | BOOST_AUTO_TEST_CASE(gamepad_virtual_test) {
FILE: wolf/system/test/gametime.hpp
function BOOST_AUTO_TEST_CASE (line 15) | BOOST_AUTO_TEST_CASE(gametime_fixed_time_test) {
function BOOST_AUTO_TEST_CASE (line 45) | BOOST_AUTO_TEST_CASE(gametime_unfixed_time_test) {
FILE: wolf/system/test/log.hpp
function BOOST_AUTO_TEST_CASE (line 16) | BOOST_AUTO_TEST_CASE(log_stress_test) {
FILE: wolf/system/test/lua.hpp
function BOOST_AUTO_TEST_CASE (line 12) | BOOST_AUTO_TEST_CASE(lua_run_from_buffer_test) {
FILE: wolf/system/test/postgresql.hpp
function BOOST_AUTO_TEST_CASE (line 18) | BOOST_AUTO_TEST_CASE(postgresql_client_connection) {
function BOOST_AUTO_TEST_CASE (line 59) | BOOST_AUTO_TEST_CASE(postgresql_client_commands_and_queries) {
FILE: wolf/system/test/process.hpp
function BOOST_AUTO_TEST_CASE (line 14) | BOOST_AUTO_TEST_CASE(process_current_path_test) {
FILE: wolf/system/test/python.hpp
function BOOST_AUTO_TEST_CASE (line 12) | BOOST_AUTO_TEST_CASE(python_simple_script_test) {
function BOOST_AUTO_TEST_CASE (line 35) | BOOST_AUTO_TEST_CASE(python_get_variable_from_script_test) {
FILE: wolf/system/test/signal_slot.hpp
function BOOST_AUTO_TEST_CASE (line 14) | BOOST_AUTO_TEST_CASE(sig_slot_test) {
FILE: wolf/system/test/tcp.hpp
function BOOST_AUTO_TEST_CASE (line 16) | BOOST_AUTO_TEST_CASE(tcp_server_timeout_test) {
function BOOST_AUTO_TEST_CASE (line 67) | BOOST_AUTO_TEST_CASE(tcp_client_timeout_test) {
function BOOST_AUTO_TEST_CASE (line 116) | BOOST_AUTO_TEST_CASE(tcp_read_write_test) {
FILE: wolf/system/test/trace.hpp
function BOOST_AUTO_TEST_CASE (line 12) | BOOST_AUTO_TEST_CASE(trace_test) {
FILE: wolf/system/test/ws.hpp
function BOOST_AUTO_TEST_CASE (line 18) | BOOST_AUTO_TEST_CASE(ws_server_timeout_test) {
function BOOST_AUTO_TEST_CASE (line 62) | BOOST_AUTO_TEST_CASE(ws_client_timeout_test) {
FILE: wolf/system/w_flags.hpp
type wolf (line 7) | namespace wolf {
function w_flags (line 26) | class W_API w_flags {
FILE: wolf/system/w_gametime.hpp
type wolf::system (line 12) | namespace wolf::system {
class w_gametime (line 16) | class w_gametime {
method W_API (line 19) | W_API w_gametime() noexcept = default;
method W_API (line 22) | W_API virtual ~w_gametime() noexcept = default;
method W_API (line 25) | W_API w_gametime(w_gametime &&p_src) noexcept = default;
method W_API (line 28) | W_API w_gametime &operator=(w_gametime &&p_src) noexcept = default;
method W_API (line 47) | W_API void tick(F &&p_tick_function) {
method W_API (line 112) | W_API void tick() {
method w_gametime (line 118) | w_gametime(const w_gametime &) = delete;
method w_gametime (line 120) | w_gametime &operator=(const w_gametime &) = delete;
FILE: wolf/system/w_leak_detector.hpp
type wolf::system (line 14) | namespace wolf::system {
class w_leak_detector (line 15) | class w_leak_detector {
method w_leak_detector (line 24) | w_leak_detector(w_leak_detector &&p_src) noexcept = delete;
method w_leak_detector (line 26) | w_leak_detector &operator=(w_leak_detector &&p_src) noexcept = delete;
method w_leak_detector (line 28) | w_leak_detector(const w_leak_detector &) = delete;
method w_leak_detector (line 30) | w_leak_detector &operator=(const w_leak_detector &) = delete;
FILE: wolf/system/w_overloaded.hpp
type wolf (line 3) | namespace wolf {
type w_overloaded (line 22) | struct w_overloaded : public Fs... { using Fs::operator()...; }
type w_blackhole (line 53) | struct w_blackhole {
method w_blackhole (line 55) | constexpr w_blackhole(Ts&& ...) noexcept { /* nothing */ }
FILE: wolf/system/w_process.hpp
type wolf::system (line 9) | namespace wolf::system {
class w_process (line 10) | class w_process {
method W_API (line 13) | W_API w_process() noexcept = default;
method W_API (line 15) | W_API virtual ~w_process() noexcept = default;
method W_API (line 17) | W_API w_process(w_process &&p_src) noexcept = default;
method W_API (line 19) | W_API w_process &operator=(w_process &&p_src) noexcept = default;
method w_process (line 35) | w_process(const w_process &) = delete;
method w_process (line 37) | w_process &operator=(const w_process &) = delete;
FILE: wolf/system/w_time.hpp
type wolf::system (line 15) | namespace wolf::system {
class w_timer (line 19) | class w_timer : public boost::asio::high_resolution_timer {
method w_timer (line 21) | w_timer(boost::asio::io_context& p_io_context)
class w_time (line 25) | class w_time {
FILE: wolf/system/w_trace.hpp
class w_trace (line 17) | class w_trace {
type stack (line 19) | struct stack {
method w_trace (line 36) | w_trace() noexcept = default;
method w_trace (line 38) | explicit w_trace(_In_ stack &&p_stack) noexcept {
method w_trace (line 45) | w_trace(_In_ int64_t p_err_code, _In_ std::string p_err_msg, _In_ cons...
method w_trace (line 54) | w_trace(_In_ std::errc p_err_code, _In_ std::string p_err_msg, _In_ co...
method push (line 64) | void push(_In_ int64_t p_err_code, _In_ std::string p_err_msg, _In_ co...
method to_string (line 73) | std::string to_string() const noexcept {
function W_SUCCESS (line 104) | constexpr inline boost::leaf::result<T> W_SUCCESS(T &p_param) noexcept {
function get_last_win_error (line 112) | inline std::string get_last_win_error(_In_ DWORD p_error_id) {
FILE: wolf/tests.cpp
function BOOST_AUTO_TEST_CASE (line 12) | BOOST_AUTO_TEST_CASE(wolf_test) {
FILE: wolf/third_party/ffmpeg/include/libavcodec/avcodec.h
type RcOverride (line 196) | typedef struct RcOverride{
type AVCodecInternal (line 374) | struct AVCodecInternal
type AVCodecContext (line 389) | typedef struct AVCodecContext {
type AVHWAccel (line 2067) | typedef struct AVHWAccel {
type AVSubtitleType (line 2257) | enum AVSubtitleType {
type AVSubtitleRect (line 2277) | typedef struct AVSubtitleRect {
type AVSubtitle (line 2305) | typedef struct AVSubtitle {
type AVChromaLocation (line 2505) | enum AVChromaLocation
type AVChromaLocation (line 2516) | enum AVChromaLocation
type AVPixelFormat (line 2772) | enum AVPixelFormat
type AVPictureStructure (line 2782) | enum AVPictureStructure {
type AVCodecParserContext (line 2789) | typedef struct AVCodecParserContext {
type AVCodecParser (line 2948) | typedef struct AVCodecParser {
type AVPixelFormat (line 3054) | enum AVPixelFormat
type AVPixelFormat (line 3073) | enum AVPixelFormat
type AVPixelFormat (line 3073) | enum AVPixelFormat
type AVPixelFormat (line 3074) | enum AVPixelFormat
type AVPixelFormat (line 3077) | enum AVPixelFormat
type AVCodecContext (line 3077) | struct AVCodecContext
type AVPixelFormat (line 3077) | enum AVPixelFormat
type AVSampleFormat (line 3113) | enum AVSampleFormat
FILE: wolf/third_party/ffmpeg/include/libavcodec/avdct.h
type AVDCT (line 29) | typedef struct AVDCT {
FILE: wolf/third_party/ffmpeg/include/libavcodec/avfft.h
type FFTSample (line 35) | typedef float FFTSample;
type FFTComplex (line 37) | typedef struct FFTComplex {
type FFTContext (line 41) | typedef struct FFTContext FFTContext;
type RDFTransformType (line 71) | enum RDFTransformType {
type RDFTContext (line 78) | typedef struct RDFTContext RDFTContext;
type RDFTransformType (line 85) | enum RDFTransformType
type DCTContext (line 91) | typedef struct DCTContext DCTContext;
type DCTTransformType (line 93) | enum DCTTransformType {
type DCTTransformType (line 110) | enum DCTTransformType
FILE: wolf/third_party/ffmpeg/include/libavcodec/bsf.h
type AVBSFContext (line 68) | typedef struct AVBSFContext {
type AVBitStreamFilter (line 111) | typedef struct AVBitStreamFilter {
type AVBSFList (line 243) | typedef struct AVBSFList AVBSFList;
FILE: wolf/third_party/ffmpeg/include/libavcodec/codec.h
type AVProfile (line 188) | typedef struct AVProfile {
type AVCodec (line 196) | typedef struct AVCodec {
type AVCodecID (line 266) | enum AVCodecID
type AVCodecID (line 282) | enum AVCodecID
type AVCodecHWConfig (line 350) | typedef struct AVCodecHWConfig {
FILE: wolf/third_party/ffmpeg/include/libavcodec/codec_desc.h
type AVCodecDescriptor (line 38) | typedef struct AVCodecDescriptor {
type AVCodecID (line 107) | enum AVCodecID
FILE: wolf/third_party/ffmpeg/include/libavcodec/codec_id.h
type AVCodecID (line 47) | enum AVCodecID {
type AVMediaType (line 583) | enum AVMediaType
type AVCodecID (line 583) | enum AVCodecID
type AVCodecID (line 589) | enum AVCodecID
type AVCodecID (line 597) | enum AVCodecID
type AVCodecID (line 607) | enum AVCodecID
type AVCodecID (line 620) | enum AVCodecID
type AVCodecID (line 628) | enum AVCodecID
type AVSampleFormat (line 628) | enum AVSampleFormat
FILE: wolf/third_party/ffmpeg/include/libavcodec/codec_par.h
type AVFieldOrder (line 37) | enum AVFieldOrder {
type AVCodecParameters (line 53) | typedef struct AVCodecParameters {
FILE: wolf/third_party/ffmpeg/include/libavcodec/d3d11va.h
type AVD3D11VAContext (line 59) | typedef struct AVD3D11VAContext {
FILE: wolf/third_party/ffmpeg/include/libavcodec/defs.h
type AVDiscard (line 45) | enum AVDiscard{
type AVAudioServiceType (line 57) | enum AVAudioServiceType {
type AVPanScan (line 75) | typedef struct AVPanScan {
type AVCPBProperties (line 104) | typedef struct AVCPBProperties {
type AVProducerReferenceTime (line 153) | typedef struct AVProducerReferenceTime {
FILE: wolf/third_party/ffmpeg/include/libavcodec/dirac.h
type DiracParseCodes (line 57) | enum DiracParseCodes {
type DiracVersionInfo (line 76) | typedef struct DiracVersionInfo {
type AVDiracSeqHeader (line 81) | typedef struct AVDiracSeqHeader {
FILE: wolf/third_party/ffmpeg/include/libavcodec/dv_profile.h
type AVDVProfile (line 38) | typedef struct AVDVProfile {
type AVPixelFormat (line 74) | enum AVPixelFormat
type AVPixelFormat (line 80) | enum AVPixelFormat
FILE: wolf/third_party/ffmpeg/include/libavcodec/dxva2.h
type dxva_context (line 57) | struct dxva_context {
FILE: wolf/third_party/ffmpeg/include/libavcodec/mediacodec.h
type AVMediaCodecContext (line 33) | typedef struct AVMediaCodecContext {
type AVMediaCodecBuffer (line 73) | typedef struct MediaCodecBuffer AVMediaCodecBuffer;
FILE: wolf/third_party/ffmpeg/include/libavcodec/packet.h
type AVPacketSideDataType (line 41) | enum AVPacketSideDataType {
type AVPacketSideData (line 315) | typedef struct AVPacketSideData {
type AVPacket (line 351) | typedef struct AVPacket {
type AVPacketList (line 423) | struct AVPacketList {
type AVSideDataParamChangeFlags (line 450) | enum AVSideDataParamChangeFlags {
type AVPacketSideDataType (line 564) | enum AVPacketSideDataType
type AVPacketSideDataType (line 580) | enum AVPacketSideDataType
type AVPacketSideDataType (line 591) | enum AVPacketSideDataType
type AVPacketSideDataType (line 603) | enum AVPacketSideDataType
type AVPacketSideDataType (line 606) | enum AVPacketSideDataType
FILE: wolf/third_party/ffmpeg/include/libavcodec/qsv.h
type AVQSVContext (line 36) | typedef struct AVQSVContext {
FILE: wolf/third_party/ffmpeg/include/libavcodec/vdpau.h
type AVCodecContext (line 59) | struct AVCodecContext
type AVFrame (line 60) | struct AVFrame
type AVCodecContext (line 62) | struct AVCodecContext
type AVFrame (line 62) | struct AVFrame
type AVVDPAUContext (line 80) | typedef struct AVVDPAUContext {
FILE: wolf/third_party/ffmpeg/include/libavcodec/videotoolbox.h
type AVVideotoolboxContext (line 46) | typedef struct AVVideotoolboxContext {
FILE: wolf/third_party/ffmpeg/include/libavcodec/vorbis_parser.h
type AVVorbisParseContext (line 31) | typedef struct AVVorbisParseContext AVVorbisParseContext;
FILE: wolf/third_party/ffmpeg/include/libavcodec/xvmc.h
function xvmc_pix_fmt (line 47) | struct attribute_deprecated xvmc_pix_fmt {
FILE: wolf/third_party/ffmpeg/include/libavdevice/avdevice.h
type AVDeviceRect (line 115) | typedef struct AVDeviceRect {
type AVAppToDevMessageType (line 125) | enum AVAppToDevMessageType {
type AVDevToAppMessageType (line 204) | enum AVDevToAppMessageType {
type AVFormatContext (line 312) | struct AVFormatContext
type AVAppToDevMessageType (line 313) | enum AVAppToDevMessageType
type AVFormatContext (line 326) | struct AVFormatContext
type AVDevToAppMessageType (line 327) | enum AVDevToAppMessageType
type AVDeviceCapabilitiesQuery (line 407) | typedef struct AVDeviceCapabilitiesQuery {
type AVDeviceInfo (line 463) | typedef struct AVDeviceInfo {
type AVDeviceInfoList (line 473) | typedef struct AVDeviceInfoList {
type AVFormatContext (line 492) | struct AVFormatContext
FILE: wolf/third_party/ffmpeg/include/libavfilter/avfilter.h
type AVFilterContext (line 73) | typedef struct AVFilterContext AVFilterContext;
type AVFilterLink (line 74) | typedef struct AVFilterLink AVFilterLink;
type AVFilterPad (line 75) | typedef struct AVFilterPad AVFilterPad;
type AVFilterFormats (line 76) | typedef struct AVFilterFormats AVFilterFormats;
type AVFilterChannelLayouts (line 77) | typedef struct AVFilterChannelLayouts AVFilterChannelLayouts;
type AVMediaType (line 109) | enum AVMediaType
type AVFilter (line 171) | typedef struct AVFilter {
type AVFilterInternal (line 405) | typedef struct AVFilterInternal AVFilterInternal;
type AVFilterContext (line 408) | struct AVFilterContext {
type AVFilterFormatsConfig (line 507) | typedef struct AVFilterFormatsConfig {
type AVFilterLink (line 538) | struct AVFilterLink {
type AVFilterGraphInternal (line 840) | typedef struct AVFilterGraphInternal AVFilterGraphInternal;
type AVFilterGraph (line 871) | typedef struct AVFilterGraph {
type AVFilterInOut (line 1031) | typedef struct AVFilterInOut {
FILE: wolf/third_party/ffmpeg/include/libavfilter/buffersink.h
type AVBufferSinkParams (line 101) | typedef struct AVBufferSinkParams {
type AVABufferSinkParams (line 116) | typedef struct AVABufferSinkParams {
type AVMediaType (line 148) | enum AVMediaType
FILE: wolf/third_party/ffmpeg/include/libavfilter/buffersrc.h
type AVBufferSrcParameters (line 73) | typedef struct AVBufferSrcParameters {
FILE: wolf/third_party/ffmpeg/include/libavformat/avformat.h
type AVFormatContext (line 330) | struct AVFormatContext
type AVStream (line 331) | struct AVStream
type AVDeviceInfoList (line 333) | struct AVDeviceInfoList
type AVDeviceCapabilitiesQuery (line 334) | struct AVDeviceCapabilitiesQuery
type AVCodecTag (line 448) | struct AVCodecTag
type AVProbeData (line 453) | typedef struct AVProbeData {
type AVOutputFormat (line 509) | typedef struct AVOutputFormat {
type AVInputFormat (line 656) | typedef struct AVInputFormat {
type AVStreamParseType (line 796) | enum AVStreamParseType {
type AVIndexEntry (line 807) | typedef struct AVIndexEntry {
type AVStream (line 950) | typedef struct AVStream {
type AVCodecParserContext (line 1122) | struct AVCodecParserContext
type AVProgram (line 1139) | typedef struct AVProgram {
type AVChapter (line 1174) | typedef struct AVChapter {
type AVFormatContext (line 1185) | struct AVFormatContext
type AVFormatContext (line 1188) | struct AVFormatContext
type AVDurationEstimationMethod (line 1195) | enum AVDurationEstimationMethod {
type AVFormatContext (line 1215) | typedef struct AVFormatContext {
type AVDurationEstimationMethod (line 1836) | enum AVDurationEstimationMethod
type AVPacketSideDataType (line 1966) | enum AVPacketSideDataType
type AVPacketSideDataType (line 1978) | enum AVPacketSideDataType
type AVPacketSideDataType (line 1989) | enum AVPacketSideDataType
type AVMediaType (line 2172) | enum AVMediaType
type AVCodecID (line 2497) | enum AVCodecID
type AVMediaType (line 2499) | enum AVMediaType
type AVFormatContext (line 2516) | struct AVFormatContext
type AVCodecID (line 2592) | enum AVCodecID
type AVCodecTag (line 2592) | struct AVCodecTag
type AVCodecTag (line 2602) | struct AVCodecTag
type AVCodecID (line 2602) | enum AVCodecID
type AVCodecTag (line 2613) | struct AVCodecTag
type AVCodecID (line 2613) | enum AVCodecID
type AVCodecID (line 2790) | enum AVCodecID
type AVCodecTag (line 2808) | struct AVCodecTag
type AVCodecTag (line 2812) | struct AVCodecTag
type AVCodecTag (line 2816) | struct AVCodecTag
type AVCodecTag (line 2820) | struct AVCodecTag
type AVTimebaseSource (line 2873) | enum AVTimebaseSource {
type AVTimebaseSource (line 2894) | enum AVTimebaseSource
FILE: wolf/third_party/ffmpeg/include/libavformat/avio.h
type AVIOInterruptCB (line 59) | typedef struct AVIOInterruptCB {
type AVIODirEntryType (line 67) | enum AVIODirEntryType {
type AVIODirEntry (line 87) | typedef struct AVIODirEntry {
type AVIODirContext (line 104) | typedef struct AVIODirContext {
type AVIODataMarkerType (line 112) | enum AVIODataMarkerType {
type AVIOContext (line 162) | typedef struct AVIOContext {
type AVIODataMarkerType (line 472) | enum AVIODataMarkerType
function av_always_inline (line 505) | static av_always_inline int64_t avio_tell(AVIOContext *s)
type AVBPrint (line 803) | struct AVBPrint
type AVBPrint (line 811) | struct AVBPrint
FILE: wolf/third_party/ffmpeg/include/libavutil/adler32.h
type AVAdler (line 42) | typedef uint32_t AVAdler;
FILE: wolf/third_party/ffmpeg/include/libavutil/aes.h
type AVAES (line 36) | struct AVAES
type AVAES (line 41) | struct AVAES
type AVAES (line 48) | struct AVAES
type AVAES (line 58) | struct AVAES
FILE: wolf/third_party/ffmpeg/include/libavutil/aes_ctr.h
type AVAESCTR (line 32) | struct AVAESCTR
type AVAESCTR (line 37) | struct AVAESCTR
type AVAESCTR (line 43) | struct AVAESCTR
type AVAESCTR (line 48) | struct AVAESCTR
type AVAESCTR (line 56) | struct AVAESCTR
type AVAESCTR (line 61) | struct AVAESCTR
type AVAESCTR (line 66) | struct AVAESCTR
type AVAESCTR (line 71) | struct AVAESCTR
type AVAESCTR (line 76) | struct AVAESCTR
type AVAESCTR (line 81) | struct AVAESCTR
FILE: wolf/third_party/ffmpeg/include/libavutil/audio_fifo.h
type AVAudioFifo (line 48) | typedef struct AVAudioFifo AVAudioFifo;
type AVSampleFormat (line 65) | enum AVSampleFormat
FILE: wolf/third_party/ffmpeg/include/libavutil/avstring.h
function av_strnlen (line 141) | static inline size_t av_strnlen(const char *s, size_t len)
function av_const (line 211) | static inline av_const int av_isdigit(int c)
function av_const (line 219) | static inline av_const int av_isgraph(int c)
function av_const (line 227) | static inline av_const int av_isspace(int c)
function av_const (line 236) | static inline av_const int av_toupper(int c)
function av_const (line 246) | static inline av_const int av_tolower(int c)
function av_const (line 256) | static inline av_const int av_isxdigit(int c)
type AVEscapeMode (line 323) | enum AVEscapeMode {
type AVEscapeMode (line 378) | enum AVEscapeMode
FILE: wolf/third_party/ffmpeg/include/libavutil/avutil.h
type AVMediaType (line 199) | enum AVMediaType {
type AVMediaType (line 213) | enum AVMediaType
type AVPictureType (line 272) | enum AVPictureType {
type AVPictureType (line 290) | enum AVPictureType
FILE: wolf/third_party/ffmpeg/include/libavutil/blowfish.h
type AVBlowfish (line 35) | typedef struct AVBlowfish {
type AVBlowfish (line 52) | struct AVBlowfish
type AVBlowfish (line 62) | struct AVBlowfish
type AVBlowfish (line 75) | struct AVBlowfish
FILE: wolf/third_party/ffmpeg/include/libavutil/bprint.h
type tm (line 148) | struct tm
type tm (line 160) | struct tm
function av_bprint_is_complete (line 185) | static inline int av_bprint_is_complete(const AVBPrint *buf)
type AVEscapeMode (line 217) | enum AVEscapeMode
FILE: wolf/third_party/ffmpeg/include/libavutil/bswap.h
function av_bswap16 (line 58) | uint16_t av_bswap16(uint16_t x)
function av_bswap32 (line 66) | uint32_t av_bswap32(uint32_t x)
function av_bswap64 (line 73) | static inline uint64_t av_const av_bswap64(uint64_t x)
FILE: wolf/third_party/ffmpeg/include/libavutil/buffer.h
type AVBuffer (line 74) | typedef struct AVBuffer AVBuffer;
type AVBufferRef (line 82) | typedef struct AVBufferRef {
type AVBufferPool (line 255) | typedef struct AVBufferPool AVBufferPool;
FILE: wolf/third_party/ffmpeg/include/libavutil/camellia.h
type AVCAMELLIA (line 38) | struct AVCAMELLIA
type AVCAMELLIA (line 44) | struct AVCAMELLIA
type AVCAMELLIA (line 53) | struct AVCAMELLIA
type AVCAMELLIA (line 65) | struct AVCAMELLIA
FILE: wolf/third_party/ffmpeg/include/libavutil/cast5.h
type AVCAST5 (line 38) | struct AVCAST5
type AVCAST5 (line 44) | struct AVCAST5
type AVCAST5 (line 53) | struct AVCAST5
type AVCAST5 (line 64) | struct AVCAST5
type AVCAST5 (line 76) | struct AVCAST5
FILE: wolf/third_party/ffmpeg/include/libavutil/channel_layout.h
type AVChannel (line 41) | enum AVChannel {
type AVChannelOrder (line 101) | enum AVChannelOrder {
type AVMatrixEncoding (line 234) | enum AVMatrixEncoding {
type AVChannelCustom (line 257) | typedef struct AVChannelCustom {
type AVChannelLayout (line 290) | typedef struct AVChannelLayout {
type AVBPrint (line 385) | struct AVBPrint
type AVBPrint (line 442) | struct AVBPrint
type AVChannel (line 526) | enum AVChannel
type AVBPrint (line 533) | struct AVBPrint
type AVChannel (line 533) | enum AVChannel
type AVChannel (line 544) | enum AVChannel
type AVBPrint (line 551) | struct AVBPrint
type AVChannel (line 551) | enum AVChannel
type AVChannel (line 559) | enum AVChannel
type AVBPrint (line 655) | struct AVBPrint
type AVChannel (line 665) | enum AVChannel
type AVChannel (line 677) | enum AVChannel
type AVChannel (line 704) | enum AVChannel
FILE: wolf/third_party/ffmpeg/include/libavutil/common.h
function av_clip_c (line 173) | int av_clip_c(int a, int amin, int amax)
function av_clip64_c (line 190) | int64_t av_clip64_c(int64_t a, int64_t amin, int64_t amax)
function av_clip_uint8_c (line 205) | uint8_t av_clip_uint8_c(int a)
function av_clip_int8_c (line 216) | int8_t av_clip_int8_c(int a)
function av_clip_uint16_c (line 227) | uint16_t av_clip_uint16_c(int a)
function av_clip_int16_c (line 238) | int16_t av_clip_int16_c(int a)
function av_clipl_int32_c (line 249) | int32_t av_clipl_int32_c(int64_t a)
function av_clip_intp2_c (line 261) | int av_clip_intp2_c(int a, int p)
function av_clip_uintp2_c (line 275) | unsigned av_clip_uintp2_c(int a, int p)
function av_mod_uintp2_c (line 287) | unsigned av_mod_uintp2_c(unsigned a, unsigned p)
function av_always_inline (line 299) | static av_always_inline int av_sat_add32_c(int a, int b)
function av_always_inline (line 311) | static av_always_inline int av_sat_dadd32_c(int a, int b)
function av_always_inline (line 323) | static av_always_inline int av_sat_sub32_c(int a, int b)
function av_always_inline (line 335) | static av_always_inline int av_sat_dsub32_c(int a, int b)
function av_always_inline (line 347) | static av_always_inline int64_t av_sat_add64_c(int64_t a, int64_t b) {
function av_always_inline (line 366) | static av_always_inline int64_t av_sat_sub64_c(int64_t a, int64_t b) {
function av_clipf_c (line 388) | float av_clipf_c(float a, float amin, float amax)
function av_clipd_c (line 405) | double av_clipd_c(double a, double amin, double amax)
function av_ceil_log2_c (line 417) | int av_ceil_log2_c(int x)
function av_popcount_c (line 427) | int av_popcount_c(uint32_t x)
function av_popcount64_c (line 441) | int av_popcount64_c(uint64_t x)
function av_parity_c (line 446) | int av_parity_c(uint32_t v)
FILE: wolf/third_party/ffmpeg/include/libavutil/crc.h
type AVCRC (line 46) | typedef uint32_t AVCRC;
type AVCRCId (line 48) | typedef enum {
FILE: wolf/third_party/ffmpeg/include/libavutil/csp.h
type AVLumaCoefficients (line 39) | typedef struct AVLumaCoefficients {
type AVCIExy (line 47) | typedef struct AVCIExy {
type AVPrimaryCoefficients (line 55) | typedef struct AVPrimaryCoefficients {
type AVCIExy (line 63) | typedef AVCIExy AVWhitepointCoefficients;
type AVColorPrimariesDesc (line 69) | typedef struct AVColorPrimariesDesc {
type AVColorSpace (line 81) | enum AVColorSpace
type AVColorPrimaries (line 90) | enum AVColorPrimaries
type AVColorPrimaries (line 100) | enum AVColorPrimaries
FILE: wolf/third_party/ffmpeg/include/libavutil/des.h
type AVDES (line 33) | typedef struct AVDES {
type AVDES (line 50) | struct AVDES
type AVDES (line 62) | struct AVDES
type AVDES (line 71) | struct AVDES
FILE: wolf/third_party/ffmpeg/include/libavutil/detection_bbox.h
type AVDetectionBBox (line 26) | typedef struct AVDetectionBBox {
type AVDetectionBBoxHeader (line 56) | typedef struct AVDetectionBBoxHeader {
function av_always_inline (line 83) | static av_always_inline AVDetectionBBox *
FILE: wolf/third_party/ffmpeg/include/libavutil/dict.h
type AVDictionaryEntry (line 79) | typedef struct AVDictionaryEntry {
type AVDictionary (line 84) | typedef struct AVDictionary AVDictionary;
FILE: wolf/third_party/ffmpeg/include/libavutil/dovi_meta.h
type AVDOVIDecoderConfigurationRecord (line 52) | typedef struct AVDOVIDecoderConfigurationRecord {
type AVDOVIRpuDataHeader (line 76) | typedef struct AVDOVIRpuDataHeader {
type AVDOVIMappingMethod (line 94) | enum AVDOVIMappingMethod {
type AVDOVIReshapingCurve (line 104) | typedef struct AVDOVIReshapingCurve {
type AVDOVINLQMethod (line 117) | enum AVDOVINLQMethod {
type AVDOVINLQParams (line 126) | typedef struct AVDOVINLQParams {
type AVDOVIDataMapping (line 139) | typedef struct AVDOVIDataMapping {
type AVDOVIColorMetadata (line 157) | typedef struct AVDOVIColorMetadata {
type AVDOVIMetadata (line 197) | typedef struct AVDOVIMetadata {
function av_always_inline (line 207) | static av_always_inline AVDOVIRpuDataHeader *
function av_always_inline (line 213) | static av_always_inline AVDOVIDataMapping *
function av_always_inline (line 219) | static av_always_inline AVDOVIColorMetadata *
FILE: wolf/third_party/ffmpeg/include/libavutil/downmix_info.h
type AVDownmixType (line 44) | enum AVDownmixType {
type AVDownmixInfo (line 58) | typedef struct AVDownmixInfo {
FILE: wolf/third_party/ffmpeg/include/libavutil/encryption_info.h
type AVSubsampleEncryptionInfo (line 25) | typedef struct AVSubsampleEncryptionInfo {
type AVEncryptionInfo (line 43) | typedef struct AVEncryptionInfo {
type AVEncryptionInitInfo (line 88) | typedef struct AVEncryptionInitInfo {
FILE: wolf/third_party/ffmpeg/include/libavutil/eval.h
type AVExpr (line 29) | typedef struct AVExpr AVExpr;
FILE: wolf/third_party/ffmpeg/include/libavutil/fifo.h
type AVFifo (line 33) | typedef struct AVFifo AVFifo;
type AVFifoBuffer (line 226) | typedef struct AVFifoBuffer {
function attribute_deprecated (line 413) | attribute_deprecated
FILE: wolf/third_party/ffmpeg/include/libavutil/film_grain_params.h
type AVFilmGrainParamsType (line 24) | enum AVFilmGrainParamsType {
type AVFilmGrainAOMParams (line 44) | typedef struct AVFilmGrainAOMParams {
type AVFilmGrainH274Params (line 132) | typedef struct AVFilmGrainH274Params {
type AVFilmGrainParams (line 216) | typedef struct AVFilmGrainParams {
FILE: wolf/third_party/ffmpeg/include/libavutil/frame.h
type AVFrameSideDataType (line 49) | enum AVFrameSideDataType {
type AVActiveFormatDescription (line 214) | enum AVActiveFormatDescription {
type AVFrameSideData (line 231) | typedef struct AVFrameSideData {
type AVRegionOfInterest (line 250) | typedef struct AVRegionOfInterest {
type AVFrame (line 325) | typedef struct AVFrame {
type AVColorSpace (line 715) | enum AVColorSpace
type AVFrameSideDataType (line 873) | enum AVFrameSideDataType
type AVFrameSideDataType (line 889) | enum AVFrameSideDataType
type AVFrameSideDataType (line 897) | enum AVFrameSideDataType
type AVFrameSideDataType (line 902) | enum AVFrameSideDataType
type AVFrameSideDataType (line 941) | enum AVFrameSideDataType
FILE: wolf/third_party/ffmpeg/include/libavutil/hash.h
type AVHashContext (line 115) | struct AVHashContext
type AVHashContext (line 125) | struct AVHashContext
type AVHashContext (line 140) | struct AVHashContext
type AVHashContext (line 167) | struct AVHashContext
type AVHashContext (line 174) | struct AVHashContext
type AVHashContext (line 183) | struct AVHashContext
type AVHashContext (line 199) | struct AVHashContext
type AVHashContext (line 214) | struct AVHashContext
type AVHashContext (line 232) | struct AVHashContext
type AVHashContext (line 250) | struct AVHashContext
type AVHashContext (line 257) | struct AVHashContext
FILE: wolf/third_party/ffmpeg/include/libavutil/hdr_dynamic_metadata.h
type AVHDRPlusOverlapProcessOption (line 30) | enum AVHDRPlusOverlapProcessOption {
type AVHDRPlusPercentile (line 39) | typedef struct AVHDRPlusPercentile {
type AVHDRPlusColorTransformParams (line 59) | typedef struct AVHDRPlusColorTransformParams {
type AVDynamicHDRPlus (line 243) | typedef struct AVDynamicHDRPlus {
FILE: wolf/third_party/ffmpeg/include/libavutil/hdr_dynamic_vivid_metadata.h
type AVHDRVividColorToneMappingParams (line 31) | typedef struct AVHDRVividColorToneMappingParams {
type AVHDRVividColorTransformParams (line 172) | typedef struct AVHDRVividColorTransformParams {
type AVDynamicHDRVivid (line 249) | typedef struct AVDynamicHDRVivid {
FILE: wolf/third_party/ffmpeg/include/libavutil/hmac.h
type AVHMACType (line 32) | enum AVHMACType {
type AVHMAC (line 41) | typedef struct AVHMAC AVHMAC;
type AVHMACType (line 47) | enum AVHMACType
FILE: wolf/third_party/ffmpeg/include/libavutil/hwcontext.h
type AVHWDeviceType (line 27) | enum AVHWDeviceType {
type AVHWDeviceInternal (line 42) | typedef struct AVHWDeviceInternal AVHWDeviceInternal;
type AVHWDeviceContext (line 61) | typedef struct AVHWDeviceContext {
type AVHWFramesInternal (line 112) | typedef struct AVHWFramesInternal AVHWFramesInternal;
type AVHWFramesContext (line 124) | typedef struct AVHWFramesContext {
type AVHWDeviceType (line 239) | enum AVHWDeviceType
type AVHWDeviceType (line 247) | enum AVHWDeviceType
type AVHWDeviceType (line 257) | enum AVHWDeviceType
type AVHWDeviceType (line 257) | enum AVHWDeviceType
type AVHWDeviceType (line 266) | enum AVHWDeviceType
type AVHWDeviceType (line 303) | enum AVHWDeviceType
type AVHWDeviceType (line 328) | enum AVHWDeviceType
type AVHWDeviceType (line 348) | enum AVHWDeviceType
type AVHWFrameTransferDirection (line 415) | enum AVHWFrameTransferDirection {
type AVHWFrameTransferDirection (line 443) | enum AVHWFrameTransferDirection
type AVPixelFormat (line 444) | enum AVPixelFormat
type AVHWFramesConstraints (line 453) | typedef struct AVHWFramesConstraints {
type AVPixelFormat (line 604) | enum AVPixelFormat
FILE: wolf/third_party/ffmpeg/include/libavutil/hwcontext_cuda.h
type AVCUDADeviceContextInternal (line 37) | typedef struct AVCUDADeviceContextInternal AVCUDADeviceContextInternal;
type AVCUDADeviceContext (line 42) | typedef struct AVCUDADeviceContext {
FILE: wolf/third_party/ffmpeg/include/libavutil/hwcontext_d3d11va.h
type AVD3D11VADeviceContext (line 45) | typedef struct AVD3D11VADeviceContext {
type AVD3D11FrameDescriptor (line 109) | typedef struct AVD3D11FrameDescriptor {
type AVD3D11VAFramesContext (line 131) | typedef struct AVD3D11VAFramesContext {
FILE: wolf/third_party/ffmpeg/include/libavutil/hwcontext_drm.h
type AVDRMObjectDescriptor (line 48) | typedef struct AVDRMObjectDescriptor {
type AVDRMPlaneDescriptor (line 74) | typedef struct AVDRMPlaneDescriptor {
type AVDRMLayerDescriptor (line 96) | typedef struct AVDRMLayerDescriptor {
type AVDRMFrameDescriptor (line 133) | typedef struct AVDRMFrameDescriptor {
type AVDRMDeviceContext (line 157) | typedef struct AVDRMDeviceContext {
FILE: wolf/third_party/ffmpeg/include/libavutil/hwcontext_dxva2.h
type AVDXVA2DeviceContext (line 39) | typedef struct AVDXVA2DeviceContext {
type AVDXVA2FramesContext (line 46) | typedef struct AVDXVA2FramesContext {
FILE: wolf/third_party/ffmpeg/include/libavutil/hwcontext_mediacodec.h
type AVMediaCodecDeviceContext (line 27) | typedef struct AVMediaCodecDeviceContext {
FILE: wolf/third_party/ffmpeg/include/libavutil/hwcontext_opencl.h
type AVOpenCLFrameDescriptor (line 47) | typedef struct AVOpenCLFrameDescriptor {
type AVOpenCLDeviceContext (line 63) | typedef struct AVOpenCLDeviceContext {
type AVOpenCLFramesContext (line 89) | typedef struct AVOpenCLFramesContext {
FILE: wolf/third_party/ffmpeg/include/libavutil/hwcontext_qsv.h
type AVQSVDeviceContext (line 35) | typedef struct AVQSVDeviceContext {
type AVQSVFramesContext (line 42) | typedef struct AVQSVFramesContext {
FILE: wolf/third_party/ffmpeg/include/libavutil/hwcontext_vaapi.h
type AVVAAPIDeviceContext (line 68) | typedef struct AVVAAPIDeviceContext {
type AVVAAPIFramesContext (line 88) | typedef struct AVVAAPIFramesContext {
type AVVAAPIHWConfig (line 110) | typedef struct AVVAAPIHWConfig {
FILE: wolf/third_party/ffmpeg/include/libavutil/hwcontext_vdpau.h
type AVVDPAUDeviceContext (line 35) | typedef struct AVVDPAUDeviceContext {
FILE: wolf/third_party/ffmpeg/include/libavutil/hwcontext_videotoolbox.h
type AVPixelFormat (line 49) | enum AVPixelFormat
type AVPixelFormat (line 55) | enum AVPixelFormat
type AVPixelFormat (line 61) | enum AVPixelFormat
type AVChromaLocation (line 67) | enum AVChromaLocation
type AVColorSpace (line 73) | enum AVColorSpace
type AVColorPrimaries (line 79) | enum AVColorPrimaries
type AVColorTransferCharacteristic (line 86) | enum AVColorTransferCharacteristic
type AVFrame (line 93) | struct AVFrame
FILE: wolf/third_party/ffmpeg/include/libavutil/hwcontext_vulkan.h
type AVVulkanDeviceContext (line 42) | typedef struct AVVulkanDeviceContext {
type AVVkFrameFlags (line 143) | typedef enum AVVkFrameFlags {
type AVVulkanFramesContext (line 157) | typedef struct AVVulkanFramesContext {
type AVVkFrame (line 213) | typedef struct AVVkFrame {
type AVPixelFormat (line 279) | enum AVPixelFormat
FILE: wolf/third_party/ffmpeg/include/libavutil/imgutils.h
type AVPixelFormat (line 61) | enum AVPixelFormat
type AVPixelFormat (line 70) | enum AVPixelFormat
type AVPixelFormat (line 83) | enum AVPixelFormat
type AVPixelFormat (line 97) | enum AVPixelFormat
type AVPixelFormat (line 111) | enum AVPixelFormat
type AVPixelFormat (line 155) | enum AVPixelFormat
type AVPixelFormat (line 173) | enum AVPixelFormat
type AVPixelFormat (line 203) | enum AVPixelFormat
type AVPixelFormat (line 215) | enum AVPixelFormat
type AVPixelFormat (line 236) | enum AVPixelFormat
type AVPixelFormat (line 263) | enum AVPixelFormat
type AVPixelFormat (line 303) | enum AVPixelFormat
type AVColorRange (line 303) | enum AVColorRange
FILE: wolf/third_party/ffmpeg/include/libavutil/intfloat.h
function av_always_inline (line 40) | static av_always_inline float av_int2float(uint32_t i)
function av_always_inline (line 50) | static av_always_inline uint32_t av_float2int(float f)
function av_always_inline (line 60) | static av_always_inline double av_int2double(uint64_t i)
function av_always_inline (line 70) | static av_always_inline uint64_t av_double2int(double f)
FILE: wolf/third_party/ffmpeg/include/libavutil/intreadwrite.h
type av_alias64 (line 27) | typedef union {
type av_alias32 (line 36) | typedef union {
type av_alias16 (line 43) | typedef union {
FILE: wolf/third_party/ffmpeg/include/libavutil/lfg.h
type AVLFG (line 33) | typedef struct AVLFG {
function av_lfg_get (line 53) | static inline unsigned int av_lfg_get(AVLFG *c){
function av_mlfg_get (line 64) | static inline unsigned int av_mlfg_get(AVLFG *c){
FILE: wolf/third_party/ffmpeg/include/libavutil/log.h
type AVClassCategory (line 28) | typedef enum {
type AVOptionRanges (line 59) | struct AVOptionRanges
type AVClass (line 66) | typedef struct AVClass {
FILE: wolf/third_party/ffmpeg/include/libavutil/mastering_display_metadata.h
type AVMasteringDisplayMetadata (line 38) | typedef struct AVMasteringDisplayMetadata {
type AVContentLightMetadata (line 98) | typedef struct AVContentLightMetadata {
FILE: wolf/third_party/ffmpeg/include/libavutil/mathematics.h
type AVRounding (line 79) | enum AVRounding {
type AVRounding (line 141) | enum AVRounding
type AVRounding (line 162) | enum AVRounding
FILE: wolf/third_party/ffmpeg/include/libavutil/md5.h
type AVMD5 (line 45) | struct AVMD5
type AVMD5 (line 50) | struct AVMD5
type AVMD5 (line 57) | struct AVMD5
type AVMD5 (line 66) | struct AVMD5
type AVMD5 (line 74) | struct AVMD5
FILE: wolf/third_party/ffmpeg/include/libavutil/motion_vector.h
type AVMotionVector (line 24) | typedef struct AVMotionVector {
FILE: wolf/third_party/ffmpeg/include/libavutil/murmur3.h
type AVMurMur3 (line 67) | struct AVMurMur3
type AVMurMur3 (line 79) | struct AVMurMur3
type AVMurMur3 (line 92) | struct AVMurMur3
type AVMurMur3 (line 101) | struct AVMurMur3
type AVMurMur3 (line 109) | struct AVMurMur3
FILE: wolf/third_party/ffmpeg/include/libavutil/opt.h
type AVOptionType (line 223) | enum AVOptionType{
type AVOption (line 251) | typedef struct AVOption {
type AVOptionRange (line 313) | typedef struct AVOptionRange {
type AVOptionRanges (line 336) | typedef struct AVOptionRanges {
type AVDictionary (line 486) | struct AVDictionary
type AVDictionary (line 504) | struct AVDictionary
type AVPixelFormat (line 697) | enum AVPixelFormat
type AVSampleFormat (line 698) | enum AVSampleFormat
type AVPixelFormat (line 756) | enum AVPixelFormat
type AVSampleFormat (line 757) | enum AVSampleFormat
FILE: wolf/third_party/ffmpeg/include/libavutil/parseutils.h
type tm (line 186) | struct tm
type tm (line 191) | struct tm
FILE: wolf/third_party/ffmpeg/include/libavutil/pixdesc.h
type AVComponentDescriptor (line 30) | typedef struct AVComponentDescriptor {
type AVPixFmtDescriptor (line 69) | typedef struct AVPixFmtDescriptor {
type AVPixelFormat (line 181) | enum AVPixelFormat
type AVPixelFormat (line 196) | enum AVPixelFormat
type AVPixelFormat (line 208) | enum AVPixelFormat
type AVPixelFormat (line 215) | enum AVPixelFormat
type AVColorRange (line 220) | enum AVColorRange
type AVColorPrimaries (line 230) | enum AVColorPrimaries
type AVColorTransferCharacteristic (line 240) | enum AVColorTransferCharacteristic
type AVColorSpace (line 250) | enum AVColorSpace
type AVChromaLocation (line 260) | enum AVChromaLocation
type AVPixelFormat (line 278) | enum AVPixelFormat
type AVPixelFormat (line 286) | enum AVPixelFormat
type AVPixelFormat (line 299) | enum AVPixelFormat
type AVPixelFormat (line 358) | enum AVPixelFormat
type AVPixelFormat (line 358) | enum AVPixelFormat
type AVPixelFormat (line 385) | enum AVPixelFormat
type AVPixelFormat (line 386) | enum AVPixelFormat
type AVPixelFormat (line 407) | enum AVPixelFormat
type AVPixelFormat (line 407) | enum AVPixelFormat
type AVPixelFormat (line 407) | enum AVPixelFormat
type AVPixelFormat (line 408) | enum AVPixelFormat
FILE: wolf/third_party/ffmpeg/include/libavutil/pixfmt.h
type AVPixelFormat (line 64) | enum AVPixelFormat {
type AVColorPrimaries (line 471) | enum AVColorPrimaries {
type AVColorTransferCharacteristic (line 496) | enum AVColorTransferCharacteristic {
type AVColorSpace (line 525) | enum AVColorSpace {
type AVColorRange (line 564) | enum AVColorRange {
type AVChromaLocation (line 618) | enum AVChromaLocation {
FILE: wolf/third_party/ffmpeg/include/libavutil/rational.h
type AVRational (line 58) | typedef struct AVRational{
function AVRational (line 71) | static inline AVRational av_make_q(int num, int den)
function av_cmp_q (line 89) | static inline int av_cmp_q(AVRational a, AVRational b){
function av_q2d (line 104) | static inline double av_q2d(AVRational a){
function av_always_inline (line 159) | static av_always_inline AVRational av_inv_q(AVRational q)
FILE: wolf/third_party/ffmpeg/include/libavutil/rc4.h
type AVRC4 (line 32) | typedef struct AVRC4 {
type AVRC4 (line 49) | struct AVRC4
type AVRC4 (line 60) | struct AVRC4
FILE: wolf/third_party/ffmpeg/include/libavutil/replaygain.h
type AVReplayGain (line 29) | typedef struct AVReplayGain {
FILE: wolf/third_party/ffmpeg/include/libavutil/ripemd.h
type AVRIPEMD (line 46) | struct AVRIPEMD
type AVRIPEMD (line 51) | struct AVRIPEMD
type AVRIPEMD (line 60) | struct AVRIPEMD
type AVRIPEMD (line 69) | struct AVRIPEMD
type AVRIPEMD (line 77) | struct AVRIPEMD
FILE: wolf/third_party/ffmpeg/include/libavutil/samplefmt.h
type AVSampleFormat (line 55) | enum AVSampleFormat {
type AVSampleFormat (line 78) | enum AVSampleFormat
type AVSampleFormat (line 84) | enum AVSampleFormat
type AVSampleFormat (line 92) | enum AVSampleFormat
type AVSampleFormat (line 92) | enum AVSampleFormat
type AVSampleFormat (line 103) | enum AVSampleFormat
type AVSampleFormat (line 103) | enum AVSampleFormat
type AVSampleFormat (line 114) | enum AVSampleFormat
type AVSampleFormat (line 114) | enum AVSampleFormat
type AVSampleFormat (line 128) | enum AVSampleFormat
type AVSampleFormat (line 137) | enum AVSampleFormat
type AVSampleFormat (line 145) | enum AVSampleFormat
type AVSampleFormat (line 158) | enum AVSampleFormat
type AVSampleFormat (line 201) | enum AVSampleFormat
type AVSampleFormat (line 223) | enum AVSampleFormat
type AVSampleFormat (line 235) | enum AVSampleFormat
type AVSampleFormat (line 250) | enum AVSampleFormat
type AVSampleFormat (line 262) | enum AVSampleFormat
FILE: wolf/third_party/ffmpeg/include/libavutil/sha.h
type AVSHA (line 53) | struct AVSHA
type AVSHA (line 58) | struct AVSHA
type AVSHA (line 67) | struct AVSHA
type AVSHA (line 76) | struct AVSHA
type AVSHA (line 84) | struct AVSHA
FILE: wolf/third_party/ffmpeg/include/libavutil/sha512.h
type AVSHA512 (line 55) | struct AVSHA512
type AVSHA512 (line 60) | struct AVSHA512
type AVSHA512 (line 69) | struct AVSHA512
type AVSHA512 (line 78) | struct AVSHA512
type AVSHA512 (line 86) | struct AVSHA512
FILE: wolf/third_party/ffmpeg/include/libavutil/spherical.h
type AVSphericalProjection (line 51) | enum AVSphericalProjection {
type AVSphericalMapping (line 82) | typedef struct AVSphericalMapping {
type AVSphericalProjection (line 217) | enum AVSphericalProjection
FILE: wolf/third_party/ffmpeg/include/libavutil/stereo3d.h
type AVStereo3DType (line 51) | enum AVStereo3DType {
type AVStereo3DView (line 147) | enum AVStereo3DView {
type AVStereo3D (line 176) | typedef struct AVStereo3D {
FILE: wolf/third_party/ffmpeg/include/libavutil/tea.h
type AVTEA (line 37) | struct AVTEA
type AVTEA (line 43) | struct AVTEA
type AVTEA (line 52) | struct AVTEA
type AVTEA (line 64) | struct AVTEA
FILE: wolf/third_party/ffmpeg/include/libavutil/threadmessage.h
type AVThreadMessageQueue (line 22) | typedef struct AVThreadMessageQueue AVThreadMessageQueue;
type AVThreadMessageFlags (line 24) | typedef enum AVThreadMessageFlags {
FILE: wolf/third_party/ffmpeg/include/libavutil/timecode.h
type AVTimecodeFlag (line 35) | enum AVTimecodeFlag {
type AVTimecode (line 41) | typedef struct {
FILE: wolf/third_party/ffmpeg/include/libavutil/tree.h
type AVTreeNode (line 44) | struct AVTreeNode
type AVTreeNode (line 50) | struct AVTreeNode
type AVTreeNode (line 66) | struct AVTreeNode
type AVTreeNode (line 113) | struct AVTreeNode
type AVTreeNode (line 115) | struct AVTreeNode
type AVTreeNode (line 117) | struct AVTreeNode
type AVTreeNode (line 129) | struct AVTreeNode
FILE: wolf/third_party/ffmpeg/include/libavutil/twofish.h
type AVTWOFISH (line 38) | struct AVTWOFISH
type AVTWOFISH (line 44) | struct AVTWOFISH
type AVTWOFISH (line 53) | struct AVTWOFISH
type AVTWOFISH (line 65) | struct AVTWOFISH
FILE: wolf/third_party/ffmpeg/include/libavutil/tx.h
type AVTXContext (line 25) | typedef struct AVTXContext AVTXContext;
type AVComplexFloat (line 27) | typedef struct AVComplexFloat {
type AVComplexDouble (line 31) | typedef struct AVComplexDouble {
type AVComplexInt32 (line 35) | typedef struct AVComplexInt32 {
type AVTXType (line 39) | enum AVTXType {
type AVTXFlags (line 116) | enum AVTXFlags {
type AVTXType (line 153) | enum AVTXType
FILE: wolf/third_party/ffmpeg/include/libavutil/uuid.h
function av_uuid_equal (line 120) | static inline int av_uuid_equal(const AVUUID uu1, const AVUUID uu2)
function av_uuid_copy (line 131) | static inline void av_uuid_copy(AVUUID dest, const AVUUID src)
function av_uuid_nil (line 142) | static inline void av_uuid_nil(AVUUID uu)
FILE: wolf/third_party/ffmpeg/include/libavutil/video_enc_params.h
type AVVideoEncParamsType (line 28) | enum AVVideoEncParamsType {
type AVVideoEncParams (line 73) | typedef struct AVVideoEncParams {
type AVVideoBlockParams (line 120) | typedef struct AVVideoBlockParams {
function av_always_inline (line 142) | static av_always_inline AVVideoBlockParams*
type AVVideoEncParamsType (line 158) | enum AVVideoEncParamsType
type AVVideoEncParamsType (line 168) | enum AVVideoEncParamsType
FILE: wolf/third_party/ffmpeg/include/libavutil/xtea.h
type AVXTEA (line 35) | typedef struct AVXTEA {
type AVXTEA (line 51) | struct AVXTEA
type AVXTEA (line 60) | struct AVXTEA
type AVXTEA (line 73) | struct AVXTEA
type AVXTEA (line 87) | struct AVXTEA
FILE: wolf/third_party/ffmpeg/include/libpostproc/postprocess.h
type pp_context (line 64) | typedef void pp_context;
type pp_mode (line 65) | typedef void pp_mode;
FILE: wolf/third_party/ffmpeg/include/libswresample/swresample.h
type SwrDitherType (line 148) | enum SwrDitherType {
type SwrEngine (line 166) | enum SwrEngine {
type SwrFilterType (line 173) | enum SwrFilterType {
type SwrContext (line 189) | typedef struct SwrContext SwrContext;
type SwrContext (line 214) | struct SwrContext
type SwrContext (line 226) | struct SwrContext
type SwrContext (line 235) | struct SwrContext
type SwrContext (line 260) | struct SwrContext
type AVSampleFormat (line 261) | enum AVSampleFormat
type AVSampleFormat (line 262) | enum AVSampleFormat
type SwrContext (line 288) | struct SwrContext
type AVSampleFormat (line 289) | enum AVSampleFormat
type AVSampleFormat (line 290) | enum AVSampleFormat
type SwrContext (line 304) | struct SwrContext
type SwrContext (line 316) | struct SwrContext
type SwrContext (line 343) | struct SwrContext
type SwrContext (line 363) | struct SwrContext
type SwrContext (line 390) | struct SwrContext
type SwrContext (line 400) | struct SwrContext
type AVMatrixEncoding (line 432) | enum AVMatrixEncoding
type AVMatrixEncoding (line 463) | enum AVMatrixEncoding
type SwrContext (line 475) | struct SwrContext
type SwrContext (line 495) | struct SwrContext
type SwrContext (line 508) | struct SwrContext
type SwrContext (line 534) | struct SwrContext
type SwrContext (line 552) | struct SwrContext
FILE: wolf/third_party/ffmpeg/include/libswscale/swscale.h
type SwsVector (line 116) | typedef struct SwsVector {
type SwsFilter (line 122) | typedef struct SwsFilter {
type SwsContext (line 129) | struct SwsContext
type AVPixelFormat (line 135) | enum AVPixelFormat
type AVPixelFormat (line 141) | enum AVPixelFormat
type AVPixelFormat (line 148) | enum AVPixelFormat
type SwsContext (line 155) | struct SwsContext
type SwsContext (line 164) | struct SwsContext
type SwsContext (line 170) | struct SwsContext
type SwsContext (line 193) | struct SwsContext
type AVPixelFormat (line 193) | enum AVPixelFormat
type AVPixelFormat (line 194) | enum AVPixelFormat
type SwsContext (line 224) | struct SwsContext
type SwsContext (line 243) | struct SwsContext
type SwsContext (line 269) | struct SwsContext
type SwsContext (line 277) | struct SwsContext
type SwsContext (line 290) | struct SwsContext
type SwsContext (line 309) | struct SwsContext
type SwsContext (line 317) | struct SwsContext
type SwsContext (line 333) | struct SwsContext
type SwsContext (line 344) | struct SwsContext
type SwsContext (line 389) | struct SwsContext
type SwsContext (line 389) | struct SwsContext
type AVPixelFormat (line 390) | enum AVPixelFormat
type AVPixelFormat (line 391) | enum AVPixelFormat
FILE: wolf/wolf.cpp
function w_signal_handler (line 19) | static void w_signal_handler(int p_signum) {
FILE: wolf/wolf.hpp
type w_buffer (line 49) | struct w_buffer {
method w_buffer (line 50) | w_buffer() noexcept = default;
method w_buffer (line 52) | explicit w_buffer(const std::string_view p_str) { from_string(p_str); }
method w_buffer (line 54) | w_buffer(std::array<char, W_MAX_BUFFER_SIZE> &&p_array, const size_t p...
method from_string (line 59) | void from_string(const std::string_view p_str) {
method to_string (line 65) | std::string to_string() {
type wolf (line 113) | namespace wolf {
function W_API (line 133) | W_API std::string format(_In_ const std::string_view p_fmt, _In_ Args ...
function W_API (line 138) | W_API std::string format(_In_ const fmt::v9::format_string<Args...> p_...
FILE: wolf_demo/wasm/wolf.cpp
function main (line 10) | int main() {
FILE: wolf_demo/wasm/www/janus.js
function Janus (line 552) | function Janus(gatewayCallbacks) {
FILE: wolf_demo/wasm/www/wolf.js
function locateFile (line 56) | function locateFile(path) {
function logExceptionOnExit (line 76) | function logExceptionOnExit(e) {
function getNativeTypeSize (line 332) | function getNativeTypeSize(type) {
function legacyModuleProp (line 357) | function legacyModuleProp(prop, newName) {
function ignoredModuleProp (line 368) | function ignoredModuleProp(prop) {
function isExportedByForceFilesystem (line 375) | function isExportedByForceFilesystem(name) {
function missingGlobal (line 387) | function missingGlobal(sym, msg) {
function missingLibrarySymbol (line 399) | function missingLibrarySymbol(sym) {
function unexportedRuntimeSymbol (line 425) | function unexportedRuntimeSymbol(sym) {
function assert (line 481) | function assert(condition, text) {
function UTF8ArrayToString (line 507) | function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
function UTF8ToString (line 565) | function UTF8ToString(ptr, maxBytesToRead) {
function stringToUTF8Array (line 591) | function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
function stringToUTF8 (line 647) | function stringToUTF8(str, outPtr, maxBytesToWrite) {
function lengthBytesUTF8 (line 659) | function lengthBytesUTF8(str) {
function updateMemoryViews (line 701) | function updateMemoryViews() {
function writeStackCookie (line 739) | function writeStackCookie() {
function checkStackCookie (line 757) | function checkStackCookie() {
function keepRuntimeAlive (line 796) | function keepRuntimeAlive() {
function preRun (line 800) | function preRun() {
function initRuntime (line 812) | function initRuntime() {
function preMain (line 822) | function preMain() {
function postRun (line 828) | function postRun() {
function addOnPreRun (line 841) | function addOnPreRun(cb) {
function addOnInit (line 845) | function addOnInit(cb) {
function addOnPreMain (line 849) | function addOnPreMain(cb) {
function addOnExit (line 853) | function addOnExit(cb) {
function addOnPostRun (line 856) | function addOnPostRun(cb) {
function getUniqueRunDependency (line 889) | function getUniqueRunDependency(id) {
function addRunDependency (line 897) | function addRunDependency(id) {
function removeRunDependency (line 933) | function removeRunDependency(id) {
function abort (line 960) | function abort(what) {
function isDataURI (line 1028) | function isDataURI(filename) {
function isFileURI (line 1034) | function isFileURI(filename) {
function createExportWrapper (line 1040) | function createExportWrapper(name, fixedasm) {
function getBinary (line 1061) | function getBinary(file) {
function getBinaryPromise (line 1076) | function getBinaryPromise() {
function createWasm (line 1111) | function createWasm() {
function ExitStatus (line 1248) | function ExitStatus(status) {
function callRuntimeCallbacks (line 1254) | function callRuntimeCallbacks(callbacks) {
function getValue (line 1266) | function getValue(ptr, type = 'i8') {
function ptrToString (line 1282) | function ptrToString(ptr) {
function setValue (line 1293) | function setValue(ptr, value, type = 'i8') {
function warnOnce (line 1308) | function warnOnce(text) {
function ___assert_fail (line 1317) | function ___assert_fail(condition, filename, line, func) {
function exception_addRef (line 1323) | function exception_addRef(info) {
function ___cxa_begin_catch (line 1328) | function ___cxa_begin_catch(ptr) {
function getWasmTableEntry (line 1346) | function getWasmTableEntry(funcPtr) {
function exception_decRef (line 1355) | function exception_decRef(info) {
function ___cxa_end_catch (line 1368) | function ___cxa_end_catch() {
function ExceptionInfo (line 1381) | function ExceptionInfo(excPtr) {
function ___resumeException (line 1471) | function ___resumeException(ptr) {
function ___cxa_find_matching_catch_2 (line 1477) | function ___cxa_find_matching_catch_2() {
function ___cxa_find_matching_catch_3 (line 1518) | function ___cxa_find_matching_catch_3() {
function ___cxa_throw (line 1557) | function ___cxa_throw(ptr, type, destructor) {
function _abort (line 1567) | function _abort() {
function readEmAsmArgs (line 1572) | function readEmAsmArgs(sigPtr, buf) {
function runEmAsmFunction (line 1597) | function runEmAsmFunction(code, sigPtr, argbuf) {
function _emscripten_asm_const_int (line 1602) | function _emscripten_asm_const_int(code, sigPtr, argbuf) {
function reallyNegative (line 1606) | function reallyNegative(x) {
function convertI32PairToI53 (line 1610) | function convertI32PairToI53(lo, hi) {
function convertU32PairToI53 (line 1618) | function convertU32PairToI53(lo, hi) {
function reSign (line 1622) | function reSign(value, bits) {
function unSign (line 1640) | function unSign(value, bits) {
function strLen (line 1650) | function strLen(ptr) {
function intArrayFromString (line 1657) | function intArrayFromString(stringy, dontAddNull, length) {
function formatString (line 1664) | function formatString(format, varargs) {
function traverseStack (line 2072) | function traverseStack(args) {
function jsStackTrace (line 2101) | function jsStackTrace() {
function _emscripten_get_callstack_js (line 2119) | function _emscripten_get_callstack_js(flags) {
function _emscripten_log_js (line 2229) | function _emscripten_log_js(flags, str) {
function _emscripten_log (line 2253) | function _emscripten_log(flags, format, varargs) {
function _emscripten_memcpy_big (line 2259) | function _emscripten_memcpy_big(dest, src, num) {
function getHeapMax (line 2263) | function getHeapMax() {
function abortOnCannotGrowMemory (line 2267) | function abortOnCannotGrowMemory(requestedSize) {
function _emscripten_resize_heap (line 2270) | function _emscripten_resize_heap(requestedSize) {
function getExecutableName (line 2278) | function getExecutableName() {
function getEnvStrings (line 2281) | function getEnvStrings() {
function writeAsciiToMemory (line 2313) | function writeAsciiToMemory(str, buffer, dontAddNull) {
function _environ_get (line 2331) | function _environ_get(__environ, environ_buf) {
function _environ_sizes_get (line 2343) | function _environ_sizes_get(penviron_count, penviron_buf_size) {
function _fd_close (line 2354) | function _fd_close(fd) {
function convertI32PairToI53Checked (line 2358) | function convertI32PairToI53Checked(lo, hi) {
function _fd_seek (line 2367) | function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
function printChar (line 2372) | function printChar(stream, curr) {
function flush_NO_FILESYSTEM (line 2383) | function flush_NO_FILESYSTEM() {
function _fd_write (line 2391) | function _fd_write(fd, iov, iovcnt, pnum) {
function __isLeapYear (line 2407) | function __isLeapYear(year) {
function __arraySum (line 2411) | function __arraySum(array, index) {
function __addDays (line 2423) | function __addDays(date, days) {
function writeArrayToMemory (line 2453) | function writeArrayToMemory(array, buffer) {
function _strftime (line 2457) | function _strftime(s, maxsize, format, tm) {
function _strftime_l (line 2742) | function _strftime_l(s, maxsize, format, tm, loc) {
function _proc_exit (line 2747) | function _proc_exit(code) {
function exitJS (line 2756) | function exitJS(status, implicit) {
function handleException (line 2770) | function handleException(e) {
function checkIncomingModuleAPI (line 2790) | function checkIncomingModuleAPI() {
function invoke_iii (line 2957) | function invoke_iii(index,a1,a2) {
function invoke_v (line 2968) | function invoke_v(index) {
function invoke_i (line 2979) | function invoke_i(index) {
function invoke_iiii (line 2990) | function invoke_iiii(index,a1,a2,a3) {
function invoke_vii (line 3001) | function invoke_vii(index,a1,a2) {
function invoke_viii (line 3012) | function invoke_viii(index,a1,a2,a3) {
function invoke_vi (line 3023) | function invoke_vi(index,a1) {
function invoke_viiii (line 3034) | function invoke_viiii(index,a1,a2,a3,a4) {
function invoke_ii (line 3045) | function invoke_ii(index,a1) {
function invoke_iiiiiii (line 3056) | function invoke_iiiiiii(index,a1,a2,a3,a4,a5,a6) {
function invoke_iiiii (line 3067) | function invoke_iiiii(index,a1,a2,a3,a4) {
function invoke_iiiiii (line 3078) | function invoke_iiiiii(index,a1,a2,a3,a4,a5) {
function invoke_vdiii (line 3089) | function invoke_vdiii(index,a1,a2,a3,a4) {
function invoke_idiii (line 3100) | function invoke_idiii(index,a1,a2,a3,a4) {
function invoke_iij (line 3111) | function invoke_iij(index,a1,a2,a3) {
function invoke_iijiii (line 3122) | function invoke_iijiii(index,a1,a2,a3,a4,a5,a6) {
function invoke_iijjiii (line 3133) | function invoke_iijjiii(index,a1,a2,a3,a4,a5,a6,a7,a8) {
function invoke_j (line 3144) | function invoke_j(index) {
function invoke_iiji (line 3155) | function invoke_iiji(index,a1,a2,a3,a4) {
function invoke_vjjiii (line 3166) | function invoke_vjjiii(index,a1,a2,a3,a4,a5,a6,a7) {
function invoke_ijjiii (line 3177) | function invoke_ijjiii(index,a1,a2,a3,a4,a5,a6,a7) {
function invoke_vijj (line 3188) | function invoke_vijj(index,a1,a2,a3,a4,a5) {
function invoke_iijj (line 3199) | function invoke_iijj(index,a1,a2,a3,a4,a5) {
function invoke_vij (line 3210) | function invoke_vij(index,a1,a2,a3) {
function callMain (line 3626) | function callMain(args) {
function stackCheckInit (line 3650) | function stackCheckInit() {
function run (line 3660) | function run(args) {
function checkUnflushedContent (line 3711) | function checkUnflushedContent() {
Condensed preview — 500 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (2,644K chars).
[
{
"path": ".dockerignore",
"chars": 6,
"preview": "build\n"
},
{
"path": ".gitattributes",
"chars": 430,
"preview": "#sources\n*.c text\n*.cc text\n*.cxx text\n*.cpp text\n*.c++ text\n*.hpp text\n*.h text\n*.h++ text\n*.hh text\n\n# Compiled Object"
},
{
"path": ".github/workflows/codeql.yml",
"chars": 3236,
"preview": "# For most projects, this workflow file will not need changing; you simply need\n# to commit it to your repository.\n#\n# Y"
},
{
"path": ".github/workflows/msvc.yml",
"chars": 3560,
"preview": "# This workflow uses actions that are not certified by GitHub.\n# They are provided by a third-party and are governed by\n"
},
{
"path": ".gitignore",
"chars": 371,
"preview": "*.log\n*.tlog\n*.wLog\n*.idb\n*.pdb\n*.ipch\n*.ilk\n*.recipe\n*.res\n*.enc\n*.vscode\n*.advixeproj\n*.advixeexp\n*.dflgadvixe\n*.infoa"
},
{
"path": "CHANGE_LOG.md",
"chars": 1228,
"preview": "# ToDos\n- Dynamic lod creator for lod sample\n- Forward+\n- DirectX 12\n- Realtime Raytracing\n- DEBUG, RELEASE, MinSizeRele"
},
{
"path": "CMakeLists.txt",
"chars": 106,
"preview": "cmake_minimum_required(VERSION 3.22)\n\n# set the name of the projects\nproject(wolf)\nadd_subdirectory(wolf)\n"
},
{
"path": "CMakePresets.json",
"chars": 9342,
"preview": "{\n \"version\": 3,\n \"cmakeMinimumRequired\": {\n \"major\": 3,\n \"minor\": 20\n },\n \"configurePresets\":"
},
{
"path": "CODE_OF_CONDUCT.md",
"chars": 5501,
"preview": "# Contributor Covenant Code of Conduct\n\n## Our Pledge\n\nWe as members, contributors, and leaders pledge to make participa"
},
{
"path": "LICENSE",
"chars": 11357,
"preview": " Apache License\n Version 2.0, January 2004\n "
},
{
"path": "README.md",
"chars": 9197,
"preview": "# [Here is the Rust implementation of Wolf](https://github.com/WolfEngine/WolfEngine/tree/wolf-rs)\n\n### Wolf Engine [![A"
},
{
"path": "TODO.md",
"chars": 81,
"preview": "- support android\n- support windows\n- support linux\n- support osx\n- support ios\n\n"
},
{
"path": "coverage.bat",
"chars": 175,
"preview": "OpenCppCoverage.exe --continue_after_cpp_exception --export_type=html:%CD%\\coverage\\ --sources %CD% --excluded_sources %"
},
{
"path": "docker/Dockerfile",
"chars": 859,
"preview": "ARG UBUNTU_VERSION=\"22.04\"\nFROM ubuntu:${UBUNTU_VERSION}\n\nENV VCPKG_ROOT=/opt/vcpkg\nARG VCPKG_GITHUB_REPOSITORY=https://"
},
{
"path": "docs/GCC.txt",
"chars": 466,
"preview": "cd /home/build\nGCC_VERSION=10.2.0\nwget https://ftp.gnu.org/gnu/gcc/gcc-${GCC_VERSION}/gcc-${GCC_VERSION}.tar.gz\ntar xzvf"
},
{
"path": "docs/ProblemSolutions.txt",
"chars": 3696,
"preview": "-------------------------------------------------------\t\t\t\t\t\t-------------------------------------------------------\n---"
},
{
"path": "docs/git-commands.txt",
"chars": 857,
"preview": "//subtrees\n\ngit config commit.gpgsign false\ngit fetch git@github.com:g-truc/glm.git master\ngit subtree add --prefix=engi"
},
{
"path": "docs/glslValidator.txt",
"chars": 66,
"preview": "./glslangValidator.exe -V -t -o ~path/to/out.spv ~/path/to/in.vert"
},
{
"path": "docs/glslValidator_MoltenVK.txt",
"chars": 699,
"preview": "cd /Users/pooyaeimandar/Documents/github/WolfSource/Wolf.Engine/engine/dependencies/vulkan/Mac/Molten/MoltenShaderConver"
},
{
"path": "docs/quic.md",
"chars": 6956,
"preview": "# Wolf QUIC\n\nWolf provides quic protocol as a submodule under stream module. Current implementation is mostly a C++ wrap"
},
{
"path": "manifest.manifest",
"chars": 1042,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"yes\"?>\n<assembly manifestVersion=\"1.0\" xmlns=\"urn:schemas-microsoft-com"
},
{
"path": "wolf/.clang-format",
"chars": 1387,
"preview": "# http://clang.llvm.org/docs/ClangFormatStyleOptions.html\nBasedOnStyle: Google\n# This defaults to 'Auto'. Explicitly set"
},
{
"path": "wolf/.clang-tidy",
"chars": 2505,
"preview": "---\nChecks: >\n -*,\n bugprone-*,\n clang-diagnostic-*,\n -clang-diagnostic-unused-command-line-argument,\n google-*,\n "
},
{
"path": "wolf/.gitignore",
"chars": 63,
"preview": "*.DS_Store\n*.suo\n/build/*\n/shells/ffmpeg/build/*\n/rust/target/*"
},
{
"path": "wolf/CMakeLists.txt",
"chars": 12627,
"preview": "#cmake . -B build -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_HOME/build/cmake/android.toolchain.cmake -DANDROID_ABI=armeabi-v7a"
},
{
"path": "wolf/DISABLE_ANALYSIS_BEGIN",
"chars": 113,
"preview": "#ifdef _MSC_VER\n#pragma warning(push)\n#pragma warning (disable:ALL_CODE_ANALYSIS_WARNINGS)\n#endif\n// NOLINTBEGIN\n"
},
{
"path": "wolf/DISABLE_ANALYSIS_END",
"chars": 56,
"preview": "#ifdef _MSC_VER\n#pragma warning(pop)\n#endif\n// NOLINTEND"
},
{
"path": "wolf/cmake/media.cmake",
"chars": 2997,
"preview": " # link to ffmpeg\nif (WOLF_MEDIA_FFMPEG)\n file(GLOB_RECURSE WOLF_MEDIA_FFMPEG_SRC\n \"${CMAKE_CURRENT_SOURCE_DIR}/medi"
},
{
"path": "wolf/cmake/ml.cmake",
"chars": 7096,
"preview": "if(WOLF_ML_OCR)\n if(LINUX)\n # fetch leptonica\n message(\"fetching https://github.com/DanBloomberg/lepton"
},
{
"path": "wolf/cmake/stream.cmake",
"chars": 7793,
"preview": "# fetch gRPC\nif (WOLF_STREAM_GRPC)\n if (EMSCRIPTEN)\n message(FATAL_ERROR \"the wasm32 target is not supported f"
},
{
"path": "wolf/cmake/system.cmake",
"chars": 10502,
"preview": "if (WOLF_SYSTEM_STACKTRACE)\n if (EMSCRIPTEN)\n message(FATAL_ERROR \"the wasm32 target is not supported for WOLF"
},
{
"path": "wolf/cmake/vcpkg.cmake",
"chars": 2181,
"preview": "if(NOT DEFINED ENV{VCPKG_ROOT})\n message(FATAL_ERROR \"VCPKG_ROOT environment variable is not set.\")\nendif()\n\nif(QT_IS"
},
{
"path": "wolf/media/ffmpeg/w_av_config.cpp",
"chars": 712,
"preview": "#include \"w_av_config.hpp\"\n\nusing w_av_config = wolf::media::ffmpeg::w_av_config;\n\nw_av_config::w_av_config(_In_ AVPixel"
},
{
"path": "wolf/media/ffmpeg/w_av_config.hpp",
"chars": 1869,
"preview": "/*\n Project: Wolf Engine. Copyright 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#ifdef"
},
{
"path": "wolf/media/ffmpeg/w_av_format.cpp",
"chars": 3739,
"preview": "#ifdef WOLF_MEDIA_FFMPEG\n\n#include \"w_av_format.hpp\"\n#include \"w_av_frame.hpp\"\n\nusing w_av_format = wolf::media::ffmpeg:"
},
{
"path": "wolf/media/ffmpeg/w_av_format.hpp",
"chars": 1303,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#ifde"
},
{
"path": "wolf/media/ffmpeg/w_av_frame.cpp",
"chars": 10703,
"preview": "#ifdef WOLF_MEDIA_FFMPEG\n\n#include \"w_av_frame.hpp\"\n#include \"w_ffmpeg_ctx.hpp\"\n\nextern \"C\" {\n#include <libavutil/imguti"
},
{
"path": "wolf/media/ffmpeg/w_av_frame.hpp",
"chars": 3283,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#ifde"
},
{
"path": "wolf/media/ffmpeg/w_av_packet.cpp",
"chars": 1679,
"preview": "#ifdef WOLF_MEDIA_FFMPEG\n\n#include \"w_av_packet.hpp\"\n\nusing w_av_packet = wolf::media::ffmpeg::w_av_packet;\n\nw_av_packet"
},
{
"path": "wolf/media/ffmpeg/w_av_packet.hpp",
"chars": 2090,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#ifde"
},
{
"path": "wolf/media/ffmpeg/w_decoder.cpp",
"chars": 2302,
"preview": "#ifdef WOLF_MEDIA_FFMPEG\n\n#include \"w_decoder.hpp\"\n\nusing w_decoder = wolf::media::ffmpeg::w_decoder;\n\nboost::leaf::res"
},
{
"path": "wolf/media/ffmpeg/w_decoder.hpp",
"chars": 1229,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#ifde"
},
{
"path": "wolf/media/ffmpeg/w_encoder.cpp",
"chars": 1915,
"preview": "#ifdef WOLF_MEDIA_FFMPEG\n\n#include \"w_encoder.hpp\"\n\nusing w_encoder = wolf::media::ffmpeg::w_encoder;\nusing w_av_packet"
},
{
"path": "wolf/media/ffmpeg/w_encoder.hpp",
"chars": 1222,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#ifde"
},
{
"path": "wolf/media/ffmpeg/w_ffmpeg.cpp",
"chars": 12586,
"preview": "#ifdef WOLF_MEDIA_FFMPEG\n\n#include \"w_ffmpeg.hpp\"\n\nextern \"C\" {\n#include <libavutil/opt.h>\n}\n\nusing w_av_codec_opt = wo"
},
{
"path": "wolf/media/ffmpeg/w_ffmpeg.hpp",
"chars": 3263,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#ifde"
},
{
"path": "wolf/media/ffmpeg/w_ffmpeg_ctx.cpp",
"chars": 1079,
"preview": "#ifdef WOLF_MEDIA_FFMPEG\n\n#include \"w_ffmpeg_ctx.hpp\"\n\nusing w_ffmpeg_ctx = wolf::media::ffmpeg::w_ffmpeg_ctx;\n\nvoid w_"
},
{
"path": "wolf/media/ffmpeg/w_ffmpeg_ctx.hpp",
"chars": 1283,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#ifde"
},
{
"path": "wolf/media/gst/audio/w_audio_format.cpp",
"chars": 46,
"preview": "#include \"media/gst/audio/w_audio_format.hpp\"\n"
},
{
"path": "wolf/media/gst/audio/w_audio_format.hpp",
"chars": 952,
"preview": "#pragma once\n\n#include <gst/audio/audio-format.h>\n\nnamespace wolf::media::gst {\n\n/**\n * enum same as GstAudioFormat.\n */"
},
{
"path": "wolf/media/gst/audio/w_audio_info.cpp",
"chars": 769,
"preview": "#include \"media/gst/audio/w_audio_info.hpp\"\n\nnamespace wolf::media::gst {\n\nauto w_audio_info::make(w_audio_format p_form"
},
{
"path": "wolf/media/gst/audio/w_audio_info.hpp",
"chars": 1611,
"preview": "#pragma once\n\n#include \"wolf.hpp\"\n\n#include \"media/gst/internal/w_common.hpp\"\n#include \"media/gst/internal/w_wrapper.hpp"
},
{
"path": "wolf/media/gst/core/w_buffer.cpp",
"chars": 484,
"preview": "#include \"media/gst/core/w_buffer.hpp\"\n\n#include \"media/gst/internal/w_common.hpp\"\n\nnamespace wolf::media::gst {\n\nauto w"
},
{
"path": "wolf/media/gst/core/w_buffer.hpp",
"chars": 5097,
"preview": "#pragma once\n\n#include \"wolf.hpp\"\n\n#include \"media/gst/internal/w_wrapper.hpp\"\n\n#include <gst/gst.h>\n\n#include <cstddef>"
},
{
"path": "wolf/media/gst/core/w_bus.cpp",
"chars": 36,
"preview": "#include \"media/gst/core/w_bus.hpp\"\n"
},
{
"path": "wolf/media/gst/core/w_bus.hpp",
"chars": 2437,
"preview": "#pragma once\n\n#include \"media/gst/core/w_signal_handler.hpp\"\n#include \"media/gst/core/w_message.hpp\"\n#include \"media/gst"
},
{
"path": "wolf/media/gst/core/w_caps.cpp",
"chars": 37,
"preview": "#include \"media/gst/core/w_caps.hpp\"\n"
},
{
"path": "wolf/media/gst/core/w_caps.hpp",
"chars": 2271,
"preview": "#pragma once\n\n#include \"wolf.hpp\"\n\n#include \"media/gst/internal/w_common.hpp\"\n#include \"media/gst/internal/w_wrapper.hpp"
},
{
"path": "wolf/media/gst/core/w_clock.cpp",
"chars": 38,
"preview": "#include \"media/gst/core/w_clock.hpp\"\n"
},
{
"path": "wolf/media/gst/core/w_clock.hpp",
"chars": 740,
"preview": "#pragma once\n\n#include \"media/gst/internal/w_wrapper.hpp\"\n\n#include <gst/gst.h>\n\nnamespace wolf::media::gst {\n\n/**\n * @b"
},
{
"path": "wolf/media/gst/core/w_element.cpp",
"chars": 935,
"preview": "#include \"media/gst/core/w_element.hpp\"\n\nnamespace wolf::media::gst {\n\nauto w_element::make(const char *p_factory_name) "
},
{
"path": "wolf/media/gst/core/w_element.hpp",
"chars": 2477,
"preview": "#pragma once\n\n#include \"wolf.hpp\"\n\n#include \"media/gst/internal/w_common.hpp\"\n#include \"media/gst/internal/w_wrapper.hpp"
},
{
"path": "wolf/media/gst/core/w_element_factory.cpp",
"chars": 48,
"preview": "#include \"media/gst/core/w_element_factory.hpp\"\n"
},
{
"path": "wolf/media/gst/core/w_element_factory.hpp",
"chars": 1764,
"preview": "#pragma once\n\n#include \"media/gst/internal/w_common.hpp\"\n#include \"media/gst/core/w_element.hpp\"\n\n#include <gst/gst.h>\n\n"
},
{
"path": "wolf/media/gst/core/w_format.cpp",
"chars": 39,
"preview": "#include \"media/gst/core/w_format.hpp\"\n"
},
{
"path": "wolf/media/gst/core/w_format.hpp",
"chars": 350,
"preview": "#pragma once\n\n#include <gst/gst.h>\n\nnamespace wolf::media::gst {\n\n/** wrapper of GstFormat */\nenum class w_format\n{\n "
},
{
"path": "wolf/media/gst/core/w_mainloop.cpp",
"chars": 41,
"preview": "#include \"media/gst/core/w_mainloop.hpp\"\n"
},
{
"path": "wolf/media/gst/core/w_mainloop.hpp",
"chars": 2049,
"preview": "#pragma once\n\n#include \"wolf.hpp\"\n\n#include \"media/gst/internal/w_wrapper.hpp\"\n\n#include <gst/gst.h>\n\n#include <stdexcep"
},
{
"path": "wolf/media/gst/core/w_message.cpp",
"chars": 40,
"preview": "#include \"media/gst/core/w_message.hpp\"\n"
},
{
"path": "wolf/media/gst/core/w_message.hpp",
"chars": 3528,
"preview": "#pragma once\n\n#include \"media/gst/internal/w_common.hpp\"\n#include \"media/gst/internal/w_wrapper.hpp\"\n\n#include <gst/gst."
},
{
"path": "wolf/media/gst/core/w_nonowning.cpp",
"chars": 42,
"preview": "#include \"media/gst/core/w_nonowning.hpp\"\n"
},
{
"path": "wolf/media/gst/core/w_nonowning.hpp",
"chars": 2096,
"preview": "#pragma once\n\n#include \"media/gst/internal/w_common.hpp\"\n\n#include <utility>\n\nnamespace wolf::media::gst {\n\n/**\n * @brie"
},
{
"path": "wolf/media/gst/core/w_pad.cpp",
"chars": 36,
"preview": "#include \"media/gst/core/w_pad.hpp\"\n"
},
{
"path": "wolf/media/gst/core/w_pad.hpp",
"chars": 710,
"preview": "#pragma once\n\n#include \"media/gst/internal/w_common.hpp\"\n#include \"media/gst/internal/w_wrapper.hpp\"\n\n#include <gst/gst."
},
{
"path": "wolf/media/gst/core/w_pipeline.cpp",
"chars": 1216,
"preview": "#include \"media/gst/core/w_pipeline.hpp\"\n\nnamespace wolf::media::gst {\n\nauto w_pipeline::make(const char *p_name)\n ->"
},
{
"path": "wolf/media/gst/core/w_pipeline.hpp",
"chars": 4009,
"preview": "#pragma once\n\n#include \"wolf.hpp\"\n\n#include \"media/gst/w_flow.hpp\"\n#include \"media/gst/core/w_element.hpp\"\n#include \"med"
},
{
"path": "wolf/media/gst/core/w_refptr.cpp",
"chars": 39,
"preview": "#include \"media/gst/core/w_refptr.hpp\"\n"
},
{
"path": "wolf/media/gst/core/w_refptr.hpp",
"chars": 1137,
"preview": "#pragma once\n\n#include <boost/leaf.hpp>\n\n#include <type_traits>\n#include <memory>\n\nnamespace wolf::media::gst {\n\n/**\n * "
},
{
"path": "wolf/media/gst/core/w_signal_handler.cpp",
"chars": 47,
"preview": "#include \"media/gst/core/w_signal_handler.hpp\"\n"
},
{
"path": "wolf/media/gst/core/w_signal_handler.hpp",
"chars": 3520,
"preview": "#pragma once\n\n#include \"media/gst/internal/w_common.hpp\"\n\n#include <gst/gst.h>\n\n#include <functional>\n#include <utility>"
},
{
"path": "wolf/media/gst/core/w_structure.cpp",
"chars": 849,
"preview": "#include \"media/gst/core/w_structure.hpp\"\n\nnamespace wolf::media::gst {\n\nauto w_structure::make(const char *p_name)\n "
},
{
"path": "wolf/media/gst/core/w_structure.hpp",
"chars": 2193,
"preview": "#pragma once\n\n#include \"wolf.hpp\"\n\n#include \"media/gst/internal/w_wrapper.hpp\"\n\n#include <gst/gst.h> // use specific hea"
},
{
"path": "wolf/media/gst/elements/w_element_aacparse.cpp",
"chars": 53,
"preview": "#include \"media/gst/elements/w_element_aacparse.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_aacparse.hpp",
"chars": 634,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n\nnamespace wolf::media::gst {\n\n/**\n * @brief wrappper of aacparse "
},
{
"path": "wolf/media/gst/elements/w_element_appsrc.cpp",
"chars": 51,
"preview": "#include \"media/gst/elements/w_element_appsrc.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_appsrc.hpp",
"chars": 3254,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n#include \"media/gst/core/w_signal_handler.hpp\"\n#include \"media/gst"
},
{
"path": "wolf/media/gst/elements/w_element_audioconvert.cpp",
"chars": 57,
"preview": "#include \"media/gst/elements/w_element_audioconvert.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_audioconvert.hpp",
"chars": 658,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n\nnamespace wolf::media::gst {\n\n/**\n * @brief wrappper of audioconv"
},
{
"path": "wolf/media/gst/elements/w_element_audioresample.cpp",
"chars": 58,
"preview": "#include \"media/gst/elements/w_element_audioresample.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_audioresample.hpp",
"chars": 664,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n\nnamespace wolf::media::gst {\n\n/**\n * @brief wrappper of audioresa"
},
{
"path": "wolf/media/gst/elements/w_element_autovideosink.cpp",
"chars": 58,
"preview": "#include \"media/gst/elements/w_element_autovideosink.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_autovideosink.hpp",
"chars": 687,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n\n#include <gst/gst.h>\n\nnamespace wolf::media::gst {\n\n/**\n * @brief"
},
{
"path": "wolf/media/gst/elements/w_element_avencflv.cpp",
"chars": 53,
"preview": "#include \"media/gst/elements/w_element_avencflv.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_avencflv.hpp",
"chars": 635,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n\nnamespace wolf::media::gst {\n\n/**\n * @brief wrappper of avencflv "
},
{
"path": "wolf/media/gst/elements/w_element_capsfilter.cpp",
"chars": 55,
"preview": "#include \"media/gst/elements/w_element_capsfilter.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_capsfilter.hpp",
"chars": 813,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n#include \"media/gst/core/w_caps.hpp\"\n\nnamespace wolf::media::gst {"
},
{
"path": "wolf/media/gst/elements/w_element_filesink.cpp",
"chars": 53,
"preview": "#include \"media/gst/elements/w_element_filesink.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_filesink.hpp",
"chars": 755,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n\nnamespace wolf::media::gst {\n\n/**\n * @brief wrappper of filesink "
},
{
"path": "wolf/media/gst/elements/w_element_flvmux.cpp",
"chars": 51,
"preview": "#include \"media/gst/elements/w_element_flvmux.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_flvmux.hpp",
"chars": 744,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n\nnamespace wolf::media::gst {\n\n/**\n * @brief wrappper of flvmux gs"
},
{
"path": "wolf/media/gst/elements/w_element_h264parse.cpp",
"chars": 54,
"preview": "#include \"media/gst/elements/w_element_h264parse.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_h264parse.hpp",
"chars": 640,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n\nnamespace wolf::media::gst {\n\n/**\n * @brief wrappper of h264parse"
},
{
"path": "wolf/media/gst/elements/w_element_mp4mux.cpp",
"chars": 51,
"preview": "#include \"media/gst/elements/w_element_mp4mux.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_mp4mux.hpp",
"chars": 622,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n\nnamespace wolf::media::gst {\n\n/**\n * @brief wrappper of mp4mux gs"
},
{
"path": "wolf/media/gst/elements/w_element_openh264enc.cpp",
"chars": 56,
"preview": "#include \"media/gst/elements/w_element_openh264enc.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_openh264enc.hpp",
"chars": 652,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n\nnamespace wolf::media::gst {\n\n/**\n * @brief wrappper of openh264e"
},
{
"path": "wolf/media/gst/elements/w_element_queue.cpp",
"chars": 50,
"preview": "#include \"media/gst/elements/w_element_queue.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_queue.hpp",
"chars": 616,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n\nnamespace wolf::media::gst {\n\n/**\n * @brief wrappper of queue gst"
},
{
"path": "wolf/media/gst/elements/w_element_rtmpsink.cpp",
"chars": 53,
"preview": "#include \"media/gst/elements/w_element_rtmpsink.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_rtmpsink.hpp",
"chars": 755,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n\nnamespace wolf::media::gst {\n\n/**\n * @brief wrappper of rtmpsink "
},
{
"path": "wolf/media/gst/elements/w_element_rtph264pay.cpp",
"chars": 55,
"preview": "#include \"media/gst/elements/w_element_rtph264pay.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_rtph264pay.hpp",
"chars": 646,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n\nnamespace wolf::media::gst {\n\n/**\n * @brief wrappper of rtph264pa"
},
{
"path": "wolf/media/gst/elements/w_element_udpsink.cpp",
"chars": 52,
"preview": "#include \"media/gst/elements/w_element_udpsink.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_udpsink.hpp",
"chars": 860,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n\nnamespace wolf::media::gst {\n\n/**\n * @brief wrappper of udpsink g"
},
{
"path": "wolf/media/gst/elements/w_element_videoconvert.cpp",
"chars": 57,
"preview": "#include \"media/gst/elements/w_element_videoconvert.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_videoconvert.hpp",
"chars": 658,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n\nnamespace wolf::media::gst {\n\n/**\n * @brief wrappper of videoconv"
},
{
"path": "wolf/media/gst/elements/w_element_videoscale.cpp",
"chars": 55,
"preview": "#include \"media/gst/elements/w_element_videoscale.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_videoscale.hpp",
"chars": 646,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n\nnamespace wolf::media::gst {\n\n/**\n * @brief wrappper of videoscal"
},
{
"path": "wolf/media/gst/elements/w_element_videotestsrc.cpp",
"chars": 57,
"preview": "#include \"media/gst/elements/w_element_videotestsrc.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_videotestsrc.hpp",
"chars": 659,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n\nnamespace wolf::media::gst {\n\n/**\n * @brief wrappper of videotest"
},
{
"path": "wolf/media/gst/elements/w_element_voaacenc.cpp",
"chars": 53,
"preview": "#include \"media/gst/elements/w_element_voaacenc.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_voaacenc.hpp",
"chars": 751,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n\nnamespace wolf::media::gst {\n\n/**\n * @brief wrappper of voaacenc "
},
{
"path": "wolf/media/gst/elements/w_element_wasapisrc.cpp",
"chars": 54,
"preview": "#include \"media/gst/elements/w_element_wasapisrc.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_wasapisrc.hpp",
"chars": 869,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n\nnamespace wolf::media::gst {\n\n/**\n * @brief wrappper of wasapisrc"
},
{
"path": "wolf/media/gst/elements/w_element_x264enc.cpp",
"chars": 52,
"preview": "#include \"media/gst/elements/w_element_x264enc.hpp\"\n"
},
{
"path": "wolf/media/gst/elements/w_element_x264enc.hpp",
"chars": 1698,
"preview": "#pragma once\n\n#include \"media/gst/core/w_element.hpp\"\n\nnamespace wolf::media::gst {\n\n/**\n * @brief wrappper of x264enc g"
},
{
"path": "wolf/media/gst/internal/w_common.cpp",
"chars": 43,
"preview": "#include \"media/gst/internal/w_common.hpp\"\n"
},
{
"path": "wolf/media/gst/internal/w_common.hpp",
"chars": 1697,
"preview": "#pragma once\n\n#include <utility>\n\nnamespace wolf::media::gst::internal {\n\n/** tag to indicate having a raw pointer in th"
},
{
"path": "wolf/media/gst/internal/w_utils.cpp",
"chars": 42,
"preview": "#include \"media/gst/internal/w_utils.hpp\"\n"
},
{
"path": "wolf/media/gst/internal/w_utils.hpp",
"chars": 1455,
"preview": "#pragma once\n\n#include <utility>\n\nnamespace wolf::media::gst::internal {\n\n/**\n * @brief The famous overloaded pattern to"
},
{
"path": "wolf/media/gst/internal/w_wrapper.cpp",
"chars": 44,
"preview": "#include \"media/gst/internal/w_wrapper.hpp\"\n"
},
{
"path": "wolf/media/gst/internal/w_wrapper.hpp",
"chars": 3314,
"preview": "#pragma once\n\n#include \"media/gst/internal/w_common.hpp\"\n#include \"media/gst/internal/w_utils.hpp\"\n#include \"media/gst/c"
},
{
"path": "wolf/media/gst/video/w_video_format.cpp",
"chars": 46,
"preview": "#include \"media/gst/video/w_video_format.hpp\"\n"
},
{
"path": "wolf/media/gst/video/w_video_format.hpp",
"chars": 328,
"preview": "#pragma once\n\n#include <gst/video/video-format.h>\n\nnamespace wolf::media::gst {\n\n/**\n * enum same as GstVideoFormat.\n */"
},
{
"path": "wolf/media/gst/video/w_video_info.cpp",
"chars": 826,
"preview": "#include \"media/gst/video/w_video_info.hpp\"\n\nnamespace wolf::media::gst {\n\nauto w_video_info::make(w_video_format p_form"
},
{
"path": "wolf/media/gst/video/w_video_info.hpp",
"chars": 1746,
"preview": "#pragma once\n\n#include \"wolf.hpp\"\n\n#include \"media/gst/internal/w_common.hpp\"\n#include \"media/gst/internal/w_wrapper.hpp"
},
{
"path": "wolf/media/gst/w_application.cpp",
"chars": 39,
"preview": "#include \"media/gst/w_application.hpp\"\n"
},
{
"path": "wolf/media/gst/w_application.hpp",
"chars": 316,
"preview": "#pragma once\n\n#include <gst/gst.h>\n\nnamespace wolf::media::gst {\n\n/**\n * @brief a gstreamer application.\n */\nclass w_app"
},
{
"path": "wolf/media/gst/w_flow.cpp",
"chars": 32,
"preview": "#include \"media/gst/w_flow.hpp\"\n"
},
{
"path": "wolf/media/gst/w_flow.hpp",
"chars": 1647,
"preview": "#pragma once\n\n#include \"media/gst/core/w_refptr.hpp\"\n#include \"media/gst/core/w_element.hpp\"\n\n#include <vector>\n#include"
},
{
"path": "wolf/media/test/avframe.hpp",
"chars": 1813,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#if d"
},
{
"path": "wolf/media/test/ffmpeg.hpp",
"chars": 8887,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#if d"
},
{
"path": "wolf/media/test/gstreamer.hpp",
"chars": 5046,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#if d"
},
{
"path": "wolf/media/test/image.hpp",
"chars": 1721,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#if d"
},
{
"path": "wolf/media/test/openal.hpp",
"chars": 1225,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#if d"
},
{
"path": "wolf/media/w_image.cpp",
"chars": 4165,
"preview": "#ifdef WOLF_MEDIA_STB\n\n#include \"w_image.hpp\"\n\n#define STB_IMAGE_IMPLEMENTATION\n#include <stb_image.h>\n\n#define STB_IMAG"
},
{
"path": "wolf/media/w_image.hpp",
"chars": 2919,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#ifde"
},
{
"path": "wolf/media/w_image_data.cpp",
"chars": 896,
"preview": "#ifdef WOLF_MEDIA_STB\n\n#include \"w_image.hpp\"\n\n#include <DISABLE_ANALYSIS_BEGIN>\n#define STB_IMAGE_IMPLEMENTATION\n#inclu"
},
{
"path": "wolf/media/w_image_data.hpp",
"chars": 236,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#ifde"
},
{
"path": "wolf/media/w_openal.cpp",
"chars": 8232,
"preview": "#ifdef WOLF_MEDIA_OPENAL\n\n#include \"w_openal.hpp\"\n\n#include <iostream>\n\nusing w_openal = wolf::media::w_openal;\nusing w_"
},
{
"path": "wolf/media/w_openal.hpp",
"chars": 7002,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#ifde"
},
{
"path": "wolf/ml/nudity_detection/w_nudity_detection.cpp",
"chars": 2700,
"preview": "#include \"w_nudity_detection.hpp\"\n\n#include <iostream>\n\n#include <torch/script.h>\n#include <torch/torch.h>\n\n#include \".."
},
{
"path": "wolf/ml/nudity_detection/w_nudity_detection.hpp",
"chars": 1374,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#prag"
},
{
"path": "wolf/ml/referee_ocr/salieri.h",
"chars": 45020,
"preview": "/**\n * Salieri\n * v1\n *\n * Salieri is a header which contains definitions for the Microsoft\n * source-code annotation la"
},
{
"path": "wolf/ml/referee_ocr/w_image_processor.cpp",
"chars": 5649,
"preview": "#include \"w_image_processor.hpp\"\n\n#include \"salieri.h\"\n\n// using config_for_ocr_struct = wolf::ml::ocr::config_for_ocr_s"
},
{
"path": "wolf/ml/referee_ocr/w_image_processor.hpp",
"chars": 5456,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#prag"
},
{
"path": "wolf/ml/referee_ocr/w_ocr_engine.cpp",
"chars": 33098,
"preview": "#include \"w_ocr_engine.hpp\"\n\n#include <stdio.h>\n#include <string.h>\n#include <sys/stat.h>\n\n#include <cctype>\n#include <c"
},
{
"path": "wolf/ml/referee_ocr/w_ocr_engine.hpp",
"chars": 16750,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#prag"
},
{
"path": "wolf/ml/referee_ocr/w_read_video_frames.cpp",
"chars": 2949,
"preview": "#include \"w_read_video_frames.hpp\"\n#ifdef __TELEMETRY\n#include \"opentelemetry/logs/provider.h\"\n#include \"opentelemetry/s"
},
{
"path": "wolf/ml/referee_ocr/w_read_video_frames.hpp",
"chars": 2166,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#prag"
},
{
"path": "wolf/ml/referee_ocr/w_referee.cpp",
"chars": 4578,
"preview": "#include \"w_referee.hpp\"\n\n#include <chrono>\n#include <opencv2/opencv.hpp>\n\nusing w_referee = wolf::ml::ocr::w_referee;\nu"
},
{
"path": "wolf/ml/referee_ocr/w_referee.hpp",
"chars": 6530,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#prag"
},
{
"path": "wolf/ml/referee_ocr/w_soccer.cpp",
"chars": 23941,
"preview": "#include \"w_soccer.hpp\"\n\n#include <chrono>\n#include <cstdint>\n#include <filesystem>\n#include <fstream>\n#include <opencv2"
},
{
"path": "wolf/ml/referee_ocr/w_soccer.hpp",
"chars": 7383,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#prag"
},
{
"path": "wolf/ml/referee_ocr/w_utilities.cpp",
"chars": 12919,
"preview": "#include \"w_utilities.hpp\"\n\n#include <rapidjson/document.h>\n#include <rapidjson/istreamwrapper.h>\n#include <rapidjson/os"
},
{
"path": "wolf/ml/referee_ocr/w_utilities.hpp",
"chars": 7556,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#prag"
},
{
"path": "wolf/ml/test/common_test_asset/soccer/.fill_stat_map",
"chars": 4344,
"preview": "\nCONFIG_SIMILARITY_ALGORITHM=NormalizedLevenshtein\nCONFIG_USE_SIMILARITY=True\nSIMILAR_STRINGS_FILE_PATH=asset/team_names"
},
{
"path": "wolf/ml/test/common_test_asset/soccer/.initial_match_result_struct",
"chars": 4029,
"preview": "CONFIG_SIMILARITY_ALGORITHM=NormalizedLevenshtein\nCONFIG_USE_SIMILARITY=True\nSIMILARITY_THRESHOLD=0.5\nSOCCER_NAME_AWAY_D"
},
{
"path": "wolf/ml/test/common_test_asset/soccer/.replace_team_names_with_most_similar_string",
"chars": 140,
"preview": "SIMILAR_STRINGS_FILE_PATH=../wolf/ml/test/common_test_asset/soccer/replace_team_names_with_most_similar_string.txt\nSIMIL"
},
{
"path": "wolf/ml/test/common_test_asset/soccer/.replace_team_names_with_most_similar_string_0_9",
"chars": 140,
"preview": "SIMILAR_STRINGS_FILE_PATH=../wolf/ml/test/common_test_asset/soccer/replace_team_names_with_most_similar_string.txt\nSIMIL"
},
{
"path": "wolf/ml/test/common_test_asset/soccer/.set_config",
"chars": 883,
"preview": "SOCCER_SCREEN_IDENTITY=COMMENT\nSOCCER_SCREEN_IDENTITY_WINDOW_NAME=window_name_test\nSOCCER_SCREEN_IDENTITY_IS_TIME=FALSE\n"
},
{
"path": "wolf/ml/test/common_test_asset/soccer/.single_image_result_extraction",
"chars": 5117,
"preview": "\nCONFIG_SIMILARITY_ALGORITHM=NormalizedLevenshtein\nCONFIG_USE_SIMILARITY=True\nSIMILAR_STRINGS_FILE_PATH=asset/team_names"
},
{
"path": "wolf/ml/test/common_test_asset/soccer/.update_match_data",
"chars": 4029,
"preview": "CONFIG_SIMILARITY_ALGORITHM=NormalizedLevenshtein\nCONFIG_USE_SIMILARITY=True\nSIMILARITY_THRESHOLD=0.5\nSOCCER_NAME_AWAY_D"
},
{
"path": "wolf/ml/test/common_test_asset/soccer/replace_team_names_with_most_similar_string.txt",
"chars": 12,
"preview": "REAL MADRID\n"
},
{
"path": "wolf/ml/test/common_test_asset/utilities/.get_env_boolean",
"chars": 70,
"preview": "\n# Variables for testing get_env_boolean functions\nBOOLEAN_VALUE=True\n"
},
{
"path": "wolf/ml/test/common_test_asset/utilities/.get_env_cv_rect",
"chars": 79,
"preview": "\n# Variables for testing get_env_boolean functions\nCV_RECT_VALUE=313,110,72,14\n"
},
{
"path": "wolf/ml/test/common_test_asset/utilities/.get_env_float",
"chars": 65,
"preview": "\n# Variables for testing get_env_float functions\nFLOAT_VALUE=4.5\n"
},
{
"path": "wolf/ml/test/common_test_asset/utilities/.get_env_int",
"chars": 59,
"preview": "\n# Variables for testing get_env_int functions\nINT_VALUE=7\n"
},
{
"path": "wolf/ml/test/common_test_asset/utilities/.get_env_string",
"chars": 80,
"preview": "\n# Variables for testing get_env_boolean functions\nSTRING_VALUE=this is a test!\n"
},
{
"path": "wolf/ml/test/common_test_asset/utilities/.get_nearest_string_0_5",
"chars": 118,
"preview": "SIMILAR_STRINGS_FILE_PATH=../wolf/ml/test/common_test_asset/utilities/get_nearest_string.txt\nSIMILARITY_THRESHOLD=0.5\n"
},
{
"path": "wolf/ml/test/common_test_asset/utilities/.get_nearest_string_0_9",
"chars": 118,
"preview": "SIMILAR_STRINGS_FILE_PATH=../wolf/ml/test/common_test_asset/utilities/get_nearest_string.txt\nSIMILARITY_THRESHOLD=0.9\n"
},
{
"path": "wolf/ml/test/common_test_asset/utilities/.set_env",
"chars": 72,
"preview": "# This is a comment line\nV1=v1\nV2=v2\n# Another comment line\nV3=v3\nV4=v4\n"
},
{
"path": "wolf/ml/test/common_test_asset/utilities/get_nearest_string.txt",
"chars": 12,
"preview": "test1\nhello\n"
},
{
"path": "wolf/ml/test/common_test_asset/utilities/get_value_from_json_file_by_key.json",
"chars": 60,
"preview": "{\n \"cpp-test-json\": \"ready\",\n \"cpp-env-json\": \"OFF\"\n}\n"
},
{
"path": "wolf/ml/test/w_image_processor_test.hpp",
"chars": 7364,
"preview": "#ifdef WOLF_TEST\n\n#pragma once\n\n#ifdef WOLF_ML_OCR\n\n#define BOOST_TEST_MODULE ml_image_processor\n\n#include <ml/referee_o"
},
{
"path": "wolf/ml/test/w_ocr_engine_test.hpp",
"chars": 11695,
"preview": "#ifdef WOLF_TEST\n\n#pragma once\n\n#ifdef WOLF_ML_OCR\n\n#define BOOST_TEST_MODULE ml_ocr_engine\n\n#include <ml/referee_ocr/w_"
},
{
"path": "wolf/ml/test/w_referee_test.hpp",
"chars": 3649,
"preview": "#ifdef WOLF_TEST\n\n#pragma once\n\n#ifdef WOLF_ML_OCR\n\n#define BOOST_TEST_MODULE ml_referee\n\n#include <ml/referee_ocr/w_ref"
},
{
"path": "wolf/ml/test/w_soccer_test.hpp",
"chars": 8214,
"preview": "#ifdef WOLF_TEST\n\n#pragma once\n\n#ifdef WOLF_ML_OCR\n\n#define BOOST_TEST_MODULE ml_soccer\n\n#include <ml/referee_ocr/w_socc"
},
{
"path": "wolf/ml/test/w_utilities_test.hpp",
"chars": 9959,
"preview": "#ifdef WOLF_TEST\n\n#pragma once\n\n#ifdef WOLF_ML_OCR\n\n#define BOOST_TEST_MODULE ml_utilities\n\n#include <ml/referee_ocr/w_u"
},
{
"path": "wolf/ml/w_common.cpp",
"chars": 3544,
"preview": "#include \"w_common.hpp\"\n\n#include <algorithm>\n#include <cctype>\n#include <cstdlib>\n#include <filesystem>\n#include <fstre"
},
{
"path": "wolf/ml/w_common.hpp",
"chars": 2941,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#prag"
},
{
"path": "wolf/protos/raft.proto",
"chars": 1032,
"preview": "syntax = \"proto3\";\npackage wolf.raft;\n\nservice Raft {\n rpc BootstrapClientStreaming(stream RaftBootstrapReq) returns "
},
{
"path": "wolf/stream/grpc/w_grpc_client.cpp",
"chars": 30,
"preview": "//#include \"w_grpc_client.hpp\""
},
{
"path": "wolf/stream/grpc/w_grpc_client.hpp",
"chars": 5242,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#ifde"
},
{
"path": "wolf/stream/grpc/w_grpc_server.cpp",
"chars": 32,
"preview": "//#include \"w_grpc_server.hpp\"\n\n"
},
{
"path": "wolf/stream/grpc/w_grpc_server.hpp",
"chars": 1198,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#ifde"
},
{
"path": "wolf/stream/http/w_http_server.cpp",
"chars": 723,
"preview": "#include \"w_http_server.hpp\"\n#include <cstdio>\n\nusing w_http_server = wolf::stream::http::w_http_server;\n\nint log_messag"
},
{
"path": "wolf/stream/http/w_http_server.hpp",
"chars": 926,
"preview": "#pragma once\n\n#include <CivetServer.h>\n#include <functional>\n#include <json/json.h>\n#include <map>\n#include <memory>\n#in"
},
{
"path": "wolf/stream/janus/w_janus_api_emc.cpp",
"chars": 20162,
"preview": "#if defined(WOLF_STREAM_JANUS) && defined(EMSCRIPTEN)\n\n#include \"w_janus_api_emc.hpp\"\n#include <cstdio>\n#include <emscri"
},
{
"path": "wolf/stream/janus/w_janus_api_emc.hpp",
"chars": 1618,
"preview": "/*\n Project: Wolf Engine. Copyright © 2014-2023 Pooya Eimandar\n https://github.com/WolfEngine/WolfEngine\n*/\n\n#if d"
}
]
// ... and 300 more files (download for full content)
About this extraction
This page contains the full source code of the WolfEngine/Wolf.Engine GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 500 files (2.4 MB), approximately 654.5k tokens, and a symbol index with 1729 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.