Copy disabled (too large)
Download .txt
Showing preview only (14,394K chars total). Download the full file to get everything.
Repository: pinterf/AviSynthPlus
Branch: master
Commit: 23f0e3fa2c37
Files: 622
Total size: 13.5 MB
Directory structure:
gitextract_jlxsglop/
├── .editorconfig
├── .gitattributes
├── .github/
│ └── workflows/
│ └── build.yml
├── .gitignore
├── .gitmodules
├── .readthedocs.yaml
├── CMakeLists.txt
├── README.md
├── avs_core/
│ ├── CMakeLists.txt
│ ├── Files.cmake
│ ├── TargetArch.cmake
│ ├── Version.cmake
│ ├── avisynth.pc.in
│ ├── avisynth_conf.h.in
│ ├── convert/
│ │ ├── convert.cpp
│ │ ├── convert.h
│ │ ├── convert_audio.cpp
│ │ ├── convert_audio.h
│ │ ├── convert_audio_c.cpp
│ │ ├── convert_bits.cpp
│ │ ├── convert_bits.h
│ │ ├── convert_helper.cpp
│ │ ├── convert_helper.h
│ │ ├── convert_matrix.cpp
│ │ ├── convert_matrix.h
│ │ ├── convert_planar.cpp
│ │ ├── convert_planar.h
│ │ ├── convert_rgb.cpp
│ │ ├── convert_rgb.h
│ │ └── intel/
│ │ ├── convert_audio_avx2.cpp
│ │ ├── convert_audio_sse.cpp
│ │ ├── convert_bits_avx2.cpp
│ │ ├── convert_bits_avx2.h
│ │ ├── convert_bits_sse.cpp
│ │ ├── convert_bits_sse.h
│ │ ├── convert_planar_avx2.cpp
│ │ ├── convert_planar_avx2.h
│ │ ├── convert_planar_sse.cpp
│ │ ├── convert_planar_sse.h
│ │ ├── convert_rgb_avx2.cpp
│ │ ├── convert_rgb_avx2.h
│ │ ├── convert_rgb_avx512.cpp
│ │ ├── convert_rgb_avx512.h
│ │ ├── convert_rgb_sse.cpp
│ │ └── convert_rgb_sse.h
│ ├── core/
│ │ ├── AVSMap.h
│ │ ├── AviHelper.cpp
│ │ ├── AviHelper.h
│ │ ├── BufferPool.cpp
│ │ ├── BufferPool.h
│ │ ├── CompatEnvironment.h
│ │ ├── DeviceManager.cpp
│ │ ├── DeviceManager.h
│ │ ├── FilterConstructor.cpp
│ │ ├── FilterConstructor.h
│ │ ├── FilterGraph.cpp
│ │ ├── FilterGraph.h
│ │ ├── InternalEnvironment.h
│ │ ├── LruCache.h
│ │ ├── MTGuard.cpp
│ │ ├── MTGuard.h
│ │ ├── MappedList.h
│ │ ├── ObjectPool.h
│ │ ├── PluginManager.cpp
│ │ ├── PluginManager.h
│ │ ├── Prefetcher.cpp
│ │ ├── Prefetcher.h
│ │ ├── ScriptEnvironmentTLS.h
│ │ ├── SimpleLruCache.h
│ │ ├── ThreadPool.cpp
│ │ ├── ThreadPool.h
│ │ ├── alignplanar.cpp
│ │ ├── alignplanar.h
│ │ ├── arch.h.in
│ │ ├── audio.cpp
│ │ ├── audio.h
│ │ ├── avisynth.cpp
│ │ ├── avisynth.def
│ │ ├── avisynth.rc
│ │ ├── avisynth64.def
│ │ ├── avisynth_c.cpp
│ │ ├── avs_simd_c.h
│ │ ├── bitblt.cpp
│ │ ├── bitblt.h
│ │ ├── cache.cpp
│ │ ├── cache.h
│ │ ├── clip_info.h
│ │ ├── cpuid.cpp
│ │ ├── exception.cpp
│ │ ├── exception.h
│ │ ├── findfirst.h
│ │ ├── fonts/
│ │ │ ├── fixedfonts.cpp
│ │ │ └── fixedfonts.h
│ │ ├── function.h
│ │ ├── info.cpp
│ │ ├── info.h
│ │ ├── initguid.cpp
│ │ ├── interface.cpp
│ │ ├── internal.h
│ │ ├── main.cpp
│ │ ├── memcpy_amd.cpp
│ │ ├── memcpy_amd.h
│ │ ├── mpmc_bounded_queue.h
│ │ ├── parser/
│ │ │ ├── expression.cpp
│ │ │ ├── expression.h
│ │ │ ├── os/
│ │ │ │ ├── win32_string_compat.cpp
│ │ │ │ └── win32_string_compat.h
│ │ │ ├── script.cpp
│ │ │ ├── script.h
│ │ │ ├── scriptparser.cpp
│ │ │ ├── scriptparser.h
│ │ │ ├── tokenizer.cpp
│ │ │ └── tokenizer.h
│ │ ├── strings.cpp
│ │ ├── strings.h
│ │ ├── vartable.h
│ │ └── version.h.in
│ ├── filters/
│ │ ├── AviSource/
│ │ │ ├── AVIIndex.cpp
│ │ │ ├── AVIIndex.h
│ │ │ ├── AVIReadHandler.cpp
│ │ │ ├── AVIReadHandler.h
│ │ │ ├── AudioSource.cpp
│ │ │ ├── AudioSource.h
│ │ │ ├── DubSource.cpp
│ │ │ ├── DubSource.h
│ │ │ ├── Error.h
│ │ │ ├── FastReadStream.cpp
│ │ │ ├── FastReadStream.h
│ │ │ ├── File64.cpp
│ │ │ ├── File64.h
│ │ │ ├── Fixes.h
│ │ │ ├── VD_Audio.cpp
│ │ │ ├── VD_Audio.h
│ │ │ ├── avi_source.cpp
│ │ │ ├── avi_source.h
│ │ │ ├── clip_info.h
│ │ │ ├── list.cpp
│ │ │ └── list.h
│ │ ├── aarch64/
│ │ │ ├── turn_neon.cpp
│ │ │ └── turn_neon.h
│ │ ├── color.cpp
│ │ ├── color.h
│ │ ├── colorbars_const.h
│ │ ├── combine.cpp
│ │ ├── combine.h
│ │ ├── conditional/
│ │ │ ├── conditional.cpp
│ │ │ ├── conditional.h
│ │ │ ├── conditional_functions.cpp
│ │ │ ├── conditional_functions.h
│ │ │ ├── conditional_reader.cpp
│ │ │ ├── conditional_reader.h
│ │ │ └── intel/
│ │ │ ├── conditional_functions_sse.cpp
│ │ │ └── conditional_functions_sse.h
│ │ ├── convolution.cpp
│ │ ├── convolution.h
│ │ ├── debug.cpp
│ │ ├── debug.h
│ │ ├── edit.cpp
│ │ ├── edit.h
│ │ ├── exprfilter/
│ │ │ ├── exprfilter.cpp
│ │ │ ├── exprfilter.h
│ │ │ └── jitasm.h
│ │ ├── field.cpp
│ │ ├── field.h
│ │ ├── focus.cpp
│ │ ├── focus.h
│ │ ├── fps.cpp
│ │ ├── fps.h
│ │ ├── greyscale.cpp
│ │ ├── greyscale.h
│ │ ├── histogram.cpp
│ │ ├── histogram.h
│ │ ├── intel/
│ │ │ ├── check_avx512.h
│ │ │ ├── focus_avx2.cpp
│ │ │ ├── focus_avx2.h
│ │ │ ├── focus_sse.cpp
│ │ │ ├── focus_sse.h
│ │ │ ├── greyscale_sse.cpp
│ │ │ ├── greyscale_sse.h
│ │ │ ├── layer_avx2.cpp
│ │ │ ├── layer_avx2.h
│ │ │ ├── layer_sse.cpp
│ │ │ ├── layer_sse.h
│ │ │ ├── limiter_sse.cpp
│ │ │ ├── limiter_sse.h
│ │ │ ├── merge_avx2.cpp
│ │ │ ├── merge_avx2.h
│ │ │ ├── merge_sse.cpp
│ │ │ ├── merge_sse.h
│ │ │ ├── planeswap_sse.cpp
│ │ │ ├── planeswap_sse.h
│ │ │ ├── resample_avx2.cpp
│ │ │ ├── resample_avx2.h
│ │ │ ├── resample_avx512.cpp
│ │ │ ├── resample_avx512.h
│ │ │ ├── resample_avx512.hpp
│ │ │ ├── resample_avx512b.cpp
│ │ │ ├── resample_sse.cpp
│ │ │ ├── resample_sse.h
│ │ │ ├── resize_sse.cpp
│ │ │ ├── resize_sse.h
│ │ │ ├── text-overlay_sse.cpp
│ │ │ ├── text-overlay_sse.h
│ │ │ ├── turn_avx2.cpp
│ │ │ ├── turn_avx2.h
│ │ │ ├── turn_sse.cpp
│ │ │ └── turn_sse.h
│ │ ├── layer.cpp
│ │ ├── layer.h
│ │ ├── layer.hpp
│ │ ├── levels.cpp
│ │ ├── levels.h
│ │ ├── limiter.cpp
│ │ ├── limiter.h
│ │ ├── merge.cpp
│ │ ├── merge.h
│ │ ├── misc.cpp
│ │ ├── misc.h
│ │ ├── overlay/
│ │ │ ├── 444convert.cpp
│ │ │ ├── 444convert.h
│ │ │ ├── OF_add.cpp
│ │ │ ├── OF_blend.cpp
│ │ │ ├── OF_darken.cpp
│ │ │ ├── OF_difference.cpp
│ │ │ ├── OF_exclusion.cpp
│ │ │ ├── OF_multiply.cpp
│ │ │ ├── OF_softhardlight.cpp
│ │ │ ├── aarch64/
│ │ │ │ ├── blend_common_neon.cpp
│ │ │ │ └── blend_common_neon.h
│ │ │ ├── blend_common.cpp
│ │ │ ├── blend_common.h
│ │ │ ├── imghelpers.h
│ │ │ ├── intel/
│ │ │ │ ├── 444convert_sse.cpp
│ │ │ │ ├── 444convert_sse.h
│ │ │ │ ├── OF_multiply_avx2.cpp
│ │ │ │ ├── OF_multiply_avx2.h
│ │ │ │ ├── OF_multiply_sse.cpp
│ │ │ │ ├── OF_multiply_sse.h
│ │ │ │ ├── blend_common_avx2.cpp
│ │ │ │ ├── blend_common_avx2.h
│ │ │ │ ├── blend_common_sse.cpp
│ │ │ │ └── blend_common_sse.h
│ │ │ ├── overlay.cpp
│ │ │ ├── overlay.h
│ │ │ └── overlayfunctions.h
│ │ ├── planeswap.cpp
│ │ ├── planeswap.h
│ │ ├── resample.cpp
│ │ ├── resample.h
│ │ ├── resample_functions.cpp
│ │ ├── resample_functions.h
│ │ ├── resize.cpp
│ │ ├── resize.h
│ │ ├── source.cpp
│ │ ├── text-overlay.cpp
│ │ ├── text-overlay.h
│ │ ├── transform.cpp
│ │ ├── transform.h
│ │ ├── turn.cpp
│ │ └── turn.h
│ └── include/
│ ├── avisynth.h
│ ├── avisynth_c.h
│ └── avs/
│ ├── alignment.h
│ ├── capi.h
│ ├── config.h
│ ├── cpuid.h
│ ├── filesystem.h
│ ├── minmax.h
│ ├── posix.h
│ ├── types.h
│ └── win.h
├── cmake_uninstall.cmake.in
├── distrib/
│ ├── AviSynth_Template.reg
│ ├── ColorPresets/
│ │ ├── colors_rgb.avsi
│ │ └── colors_rgb.txt
│ ├── Examples/
│ │ ├── Audio.avs
│ │ ├── Authors.avs
│ │ ├── Editing.avs
│ │ ├── Equalizer Presets/
│ │ │ ├── 1965.feq
│ │ │ ├── Air.feq
│ │ │ ├── Brittle.feq
│ │ │ ├── Car Stereo.feq
│ │ │ ├── Classic V.feq
│ │ │ ├── Clear.feq
│ │ │ ├── DEATH.feq
│ │ │ ├── Dark.feq
│ │ │ ├── Drums.feq
│ │ │ ├── Flat.feq
│ │ │ ├── Home Theater.feq
│ │ │ ├── Loudness.feq
│ │ │ ├── Pop.feq
│ │ │ ├── Premaster.feq
│ │ │ ├── Presence.feq
│ │ │ ├── Punch & Sparkle.feq
│ │ │ ├── Shimmer.feq
│ │ │ ├── Soft Bass.feq
│ │ │ └── Strings.feq
│ │ ├── Processing.avs
│ │ ├── Syntax.avs
│ │ └── Version.avs
│ ├── OFL.TXT
│ ├── Prerequisites/
│ │ └── keep.me
│ ├── Readme/
│ │ └── readme_history.txt
│ ├── WinInstaller/
│ │ ├── Translations/
│ │ │ ├── cs.isl
│ │ │ ├── de.isl
│ │ │ ├── en.isl
│ │ │ ├── fr.isl
│ │ │ ├── it.isl
│ │ │ ├── ja.isl
│ │ │ ├── pl.isl
│ │ │ ├── pt.isl
│ │ │ ├── pt_br.isl
│ │ │ └── ru.isl
│ │ ├── avisynth+.iss
│ │ ├── avisynth+_arm64.iss
│ │ └── update_git_rev.ps1
│ ├── docs/
│ │ └── english/
│ │ ├── make.bat
│ │ └── source/
│ │ ├── avisynthdoc/
│ │ │ ├── FilterSDK/
│ │ │ │ ├── AMDOptimizationGuide.rst
│ │ │ │ ├── AVSLinkage.rst
│ │ │ │ ├── AssemblerOptimizing.rst
│ │ │ │ ├── AviSynthInterfaceVersion.rst
│ │ │ │ ├── AviSynthTwoFiveAudio.rst
│ │ │ │ ├── AviSynthTwoFivePixelType.rst
│ │ │ │ ├── AviSynthTwoFiveSDK.rst
│ │ │ │ ├── BensAviSynthDocs.rst
│ │ │ │ ├── C_api.rst
│ │ │ │ ├── ChangeFrameSize.rst
│ │ │ │ ├── ColorSpaces.rst
│ │ │ │ ├── ColorspaceProperties.rst
│ │ │ │ ├── CompilingAvisynthPlugins.rst
│ │ │ │ ├── Cplusplus_api.rst
│ │ │ │ ├── DataAlignment.rst
│ │ │ │ ├── DataStorageInAviSynth.rst
│ │ │ │ ├── DebuggingAvisynthPlugins.rst
│ │ │ │ ├── DualPlugins.rst
│ │ │ │ ├── EnvInvoke.rst
│ │ │ │ ├── EnvSaveString.rst
│ │ │ │ ├── FilterSDK.rst
│ │ │ │ ├── GeneralPurposeToMMXRegisters.rst
│ │ │ │ ├── GettingStartedWithAudio.rst
│ │ │ │ ├── GradientMask.rst
│ │ │ │ ├── InstructionPairing.rst
│ │ │ │ ├── IntegerSSE.rst
│ │ │ │ ├── IntelOptimizationGuide.rst
│ │ │ │ ├── InterleavedImageFormat.rst
│ │ │ │ ├── IntermediateMmxOptimization.rst
│ │ │ │ ├── InternalFunctions.rst
│ │ │ │ ├── InvertNeg.rst
│ │ │ │ ├── IsMovntqFaster.rst
│ │ │ │ ├── MMX.rst
│ │ │ │ ├── Non-ClipSample.rst
│ │ │ │ ├── PlanarImageFormat.rst
│ │ │ │ ├── SDKHistory.rst
│ │ │ │ ├── SDKLicense.rst
│ │ │ │ ├── SDKNecessaries.rst
│ │ │ │ ├── SimpleMmxOptimization.rst
│ │ │ │ ├── SimpleSample.rst
│ │ │ │ ├── SimpleSample10b.rst
│ │ │ │ ├── SimpleSample11.rst
│ │ │ │ ├── SimpleSample12.rst
│ │ │ │ ├── SimpleSample13a.rst
│ │ │ │ ├── SimpleSample14.rst
│ │ │ │ ├── SimpleSample15a.rst
│ │ │ │ ├── SimpleSample16.rst
│ │ │ │ ├── SimpleSample17.rst
│ │ │ │ ├── SimpleSample26.rst
│ │ │ │ ├── SimpleSampleClass.rst
│ │ │ │ ├── TwoFiveFastInvert.rst
│ │ │ │ ├── TwoFiveInvert.rst
│ │ │ │ ├── VideoInfo.rst
│ │ │ │ ├── WorkingWithImages.rst
│ │ │ │ ├── WorkingWithPlanarImages.rst
│ │ │ │ ├── avs2pcm.rst
│ │ │ │ └── avs2yuv.rst
│ │ │ ├── advancedtopics/
│ │ │ │ ├── color_conversions.rst
│ │ │ │ ├── colorimetry.rst
│ │ │ │ ├── hybrid_video.rst
│ │ │ │ ├── importing_media.rst
│ │ │ │ ├── interlaced_fieldbased.rst
│ │ │ │ ├── luminance_levels.rst
│ │ │ │ └── sampling.rst
│ │ │ ├── advancedtopics.rst
│ │ │ ├── avisynthplus.rst
│ │ │ ├── changelist.rst
│ │ │ ├── changelist26.rst
│ │ │ ├── changelist34.rst
│ │ │ ├── changelist34pre.rst
│ │ │ ├── changelist35.rst
│ │ │ ├── changelist36.rst
│ │ │ ├── changelist37.rst
│ │ │ ├── changelist371.rst
│ │ │ ├── changelist372.rst
│ │ │ ├── changelist373.rst
│ │ │ ├── changelist374.rst
│ │ │ ├── changelist375.rst
│ │ │ ├── changelist376.rst
│ │ │ ├── contributing/
│ │ │ │ ├── avsplus_external_deps_guide_manual.rst
│ │ │ │ ├── avsplus_external_deps_guide_manual_arm.rst
│ │ │ │ ├── compiling_avsplus.rst
│ │ │ │ ├── contributing_with_git.rst
│ │ │ │ └── posix.rst
│ │ │ ├── corefilters/
│ │ │ │ ├── addborders.rst
│ │ │ │ ├── adjust.rst
│ │ │ │ ├── amplify.rst
│ │ │ │ ├── animate.rst
│ │ │ │ ├── assumerate.rst
│ │ │ │ ├── audiodub.rst
│ │ │ │ ├── avisource.rst
│ │ │ │ ├── blankclip.rst
│ │ │ │ ├── blur.rst
│ │ │ │ ├── bob.rst
│ │ │ │ ├── colorbars.rst
│ │ │ │ ├── colorbarsuhd.rst
│ │ │ │ ├── coloryuv.rst
│ │ │ │ ├── combineplanes.rst
│ │ │ │ ├── compare.rst
│ │ │ │ ├── conditionalfilter.rst
│ │ │ │ ├── conditionalreader.rst
│ │ │ │ ├── convert.rst
│ │ │ │ ├── convertaudio.rst
│ │ │ │ ├── convertbits.rst
│ │ │ │ ├── convertstacked.rst
│ │ │ │ ├── converttomono.rst
│ │ │ │ ├── convolution.rst
│ │ │ │ ├── crop.rst
│ │ │ │ ├── delayaudio.rst
│ │ │ │ ├── deleteframe.rst
│ │ │ │ ├── directshowsource.rst
│ │ │ │ ├── dissolve.rst
│ │ │ │ ├── doubleweave.rst
│ │ │ │ ├── duplicateframe.rst
│ │ │ │ ├── echo.rst
│ │ │ │ ├── ensuresync.rst
│ │ │ │ ├── expr.rst
│ │ │ │ ├── extract.rst
│ │ │ │ ├── fade.rst
│ │ │ │ ├── fixbrokenchromaupsampling.rst
│ │ │ │ ├── fixluminance.rst
│ │ │ │ ├── flip.rst
│ │ │ │ ├── fps.rst
│ │ │ │ ├── freezeframe.rst
│ │ │ │ ├── getchannel.rst
│ │ │ │ ├── greyscale.rst
│ │ │ │ ├── histogram.rst
│ │ │ │ ├── imagesource.rst
│ │ │ │ ├── imagewriter.rst
│ │ │ │ ├── import.rst
│ │ │ │ ├── info.rst
│ │ │ │ ├── interleave.rst
│ │ │ │ ├── invert.rst
│ │ │ │ ├── killaudio.rst
│ │ │ │ ├── layer.rst
│ │ │ │ ├── letterbox.rst
│ │ │ │ ├── levels.rst
│ │ │ │ ├── limiter.rst
│ │ │ │ ├── loop.rst
│ │ │ │ ├── mask.rst
│ │ │ │ ├── maskhs.rst
│ │ │ │ ├── merge.rst
│ │ │ │ ├── mergechannels.rst
│ │ │ │ ├── mergergb.rst
│ │ │ │ ├── message.rst
│ │ │ │ ├── mixaudio.rst
│ │ │ │ ├── monotostereo.rst
│ │ │ │ ├── multioverlay.rst
│ │ │ │ ├── normalize.rst
│ │ │ │ ├── overlay.rst
│ │ │ │ ├── parity.rst
│ │ │ │ ├── peculiar.rst
│ │ │ │ ├── preroll.rst
│ │ │ │ ├── propShow.rst
│ │ │ │ ├── pulldown.rst
│ │ │ │ ├── reduceby2.rst
│ │ │ │ ├── resampleaudio.rst
│ │ │ │ ├── resize.rst
│ │ │ │ ├── reverse.rst
│ │ │ │ ├── segmentedsource.rst
│ │ │ │ ├── select.rst
│ │ │ │ ├── selectevery.rst
│ │ │ │ ├── selectrangeevery.rst
│ │ │ │ ├── separatefields.rst
│ │ │ │ ├── setchannelmask.rst
│ │ │ │ ├── setfilterprop.rst
│ │ │ │ ├── showalpha.rst
│ │ │ │ ├── showfive.rst
│ │ │ │ ├── showframes.rst
│ │ │ │ ├── skewrows.rst
│ │ │ │ ├── soften.rst
│ │ │ │ ├── soundout.rst
│ │ │ │ ├── splice.rst
│ │ │ │ ├── ssrc.rst
│ │ │ │ ├── stack.rst
│ │ │ │ ├── subtitle.rst
│ │ │ │ ├── subtract.rst
│ │ │ │ ├── supereq.rst
│ │ │ │ ├── swap.rst
│ │ │ │ ├── swapfields.rst
│ │ │ │ ├── tcpdeliver.rst
│ │ │ │ ├── timestretch.rst
│ │ │ │ ├── tone.rst
│ │ │ │ ├── trim.rst
│ │ │ │ ├── turn.rst
│ │ │ │ ├── tweak.rst
│ │ │ │ ├── version.rst
│ │ │ │ ├── weave.rst
│ │ │ │ └── write.rst
│ │ │ ├── corefilters.rst
│ │ │ ├── externalplugins.rst
│ │ │ ├── faq/
│ │ │ │ ├── faq.rst
│ │ │ │ ├── faq_common_errors.rst
│ │ │ │ ├── faq_different_types_content.rst
│ │ │ │ ├── faq_frameserving.rst
│ │ │ │ ├── faq_general_info.rst
│ │ │ │ ├── faq_loading_clips.rst
│ │ │ │ ├── faq_sections.rst
│ │ │ │ ├── faq_using_virtualdub_plugins.rst
│ │ │ │ ├── faq_yv12.rst
│ │ │ │ └── troubleshooting.rst
│ │ │ ├── filters_mult_input_clips.rst
│ │ │ ├── getting_started.rst
│ │ │ ├── index.rst
│ │ │ ├── license.rst
│ │ │ ├── links.rst
│ │ │ ├── overview.rst
│ │ │ ├── quick_ref.rst
│ │ │ ├── releasenotes.rst
│ │ │ ├── script_ref/
│ │ │ │ ├── script_ref.rst
│ │ │ │ ├── script_ref_arrays.rst
│ │ │ │ ├── script_ref_block_statements.rst
│ │ │ │ ├── script_ref_execution_model.rst
│ │ │ │ ├── script_ref_execution_model_eval_scripts.rst
│ │ │ │ ├── script_ref_execution_model_fetching_frames.rst
│ │ │ │ ├── script_ref_execution_model_filter_graph.rst
│ │ │ │ ├── script_ref_execution_model_lifetime_variables.rst
│ │ │ │ ├── script_ref_execution_model_perf_cons.rst
│ │ │ │ ├── script_ref_execution_model_sequence_events.rst
│ │ │ │ └── script_ref_user_functions.rst
│ │ │ ├── syntax/
│ │ │ │ ├── syntax.rst
│ │ │ │ ├── syntax_clip_properties.rst
│ │ │ │ ├── syntax_colors.rst
│ │ │ │ ├── syntax_control_structures.rst
│ │ │ │ ├── syntax_formal_avisynth_grammar.rst
│ │ │ │ ├── syntax_function_objects.rst
│ │ │ │ ├── syntax_internal_functions.rst
│ │ │ │ ├── syntax_internal_functions_bit.rst
│ │ │ │ ├── syntax_internal_functions_boolean.rst
│ │ │ │ ├── syntax_internal_functions_control.rst
│ │ │ │ ├── syntax_internal_functions_conversion.rst
│ │ │ │ ├── syntax_internal_functions_debug.rst
│ │ │ │ ├── syntax_internal_functions_frame_properties.rst
│ │ │ │ ├── syntax_internal_functions_function_object.rst
│ │ │ │ ├── syntax_internal_functions_global_options.rst
│ │ │ │ ├── syntax_internal_functions_multithreading.rst
│ │ │ │ ├── syntax_internal_functions_multithreading_new.rst
│ │ │ │ ├── syntax_internal_functions_numeric.rst
│ │ │ │ ├── syntax_internal_functions_runtime.rst
│ │ │ │ ├── syntax_internal_functions_script.rst
│ │ │ │ ├── syntax_internal_functions_string.rst
│ │ │ │ ├── syntax_internal_functions_trig.rst
│ │ │ │ ├── syntax_internal_functions_version.rst
│ │ │ │ ├── syntax_operators.rst
│ │ │ │ ├── syntax_plugins.rst
│ │ │ │ ├── syntax_ref.rst
│ │ │ │ ├── syntax_runtime_environment.rst
│ │ │ │ ├── syntax_script_variables.rst
│ │ │ │ ├── syntax_sections.rst
│ │ │ │ ├── syntax_the_full_grammar.rst
│ │ │ │ └── syntax_userdefined_scriptfunctions.rst
│ │ │ ├── twopointfive.rst
│ │ │ └── twopointsix.rst
│ │ ├── conf.py
│ │ └── index.rst
│ ├── gpl-cs.txt
│ ├── gpl-de.txt
│ ├── gpl-el.txt
│ ├── gpl-fr.txt
│ ├── gpl-it.txt
│ ├── gpl-ja.txt
│ ├── gpl-pl.txt
│ ├── gpl-pt.txt
│ ├── gpl-pt_br.txt
│ ├── gpl-ru.txt
│ ├── gpl.txt
│ ├── lgpl_for_used_libs.txt
│ └── rst_migration_notes.txt
└── plugins/
├── CMakeLists.txt
├── ConvertStacked/
│ ├── CMakeLists.txt
│ └── ConvertStacked.cpp
├── DirectShowSource/
│ ├── CMakeLists.txt
│ ├── directshow_source.cpp
│ └── directshow_source.h
├── ImageSeq/
│ ├── CMakeLists.txt
│ ├── ImageReader.cpp
│ ├── ImageSeq.cpp
│ ├── ImageSeq.h
│ └── ImageWriter.cpp
├── Shibatch/
│ ├── CMakeLists.txt
│ ├── dbesi0.c
│ ├── fft.h
│ ├── mem_block.cpp
│ ├── mem_block.h
│ ├── paramlist.h
│ ├── shibatch.cpp
│ ├── ssrc-convert.cpp
│ ├── ssrc-convert.h
│ ├── ssrc.cpp
│ ├── ssrc.h
│ ├── supereq.cpp
│ ├── supereq.h
│ └── whence.txt
├── TimeStretch/
│ ├── CMakeLists.txt
│ └── TimeStretch.cpp
├── VDubFilter/
│ ├── CMakeLists.txt
│ ├── GetCPUFlags.cpp
│ ├── ScriptInterpreter.h
│ ├── ScriptValue.h
│ ├── VBitmap.h
│ ├── VDubFilter.cpp
│ ├── vdplugin.h
│ └── vdvideofilt.h
└── VFAPIFilter/
├── CMakeLists.txt
└── VFAPIFilter.cpp
================================================
FILE CONTENTS
================================================
================================================
FILE: .editorconfig
================================================
root = true
# NOTE: editorconfig-core-c has a hardcoded limitation of 50 chars per .ini section name
[*.{cpp,h,hpp,c,asm}]
indent_style = space
indent_size = 2
trim_trailing_whitespace = true
end_of_line = lf
insert_final_newline = true
charset = utf-8
[*.md]
indent_style = space
trim_trailing_whitespace = false
charset = utf-8
================================================
FILE: .gitattributes
================================================
# Set the default behavior, in case people don't have core.autocrlf set.
* text eol=lf
distrib/**/*.css linguist-documentation
distrib/**/*.htm linguist-documentation
distrib/**/*.html linguist-documentation
# Denote all files that are truly binary and should not be modified.
*.bmp binary
*.dll binary
*.exe binary
*.gif binary
*.ico binary
*.jpg binary
*.lib binary
*.png binary
*.ps1 binary
*.svg binary
================================================
FILE: .github/workflows/build.yml
================================================
name: Build AviSynth+
on: [push]
jobs:
build:
name: ${{ matrix.config.name }}
runs-on: ${{ matrix.config.os }}
strategy:
matrix:
config:
- {name: "Windows Latest x64", os: windows-latest, cmake-parameters: "-A x64"}
- {name: "Windows Latest x86", os: windows-latest, cmake-parameters: "-A Win32"}
- {name: "Ubuntu 22.04 x64", os: ubuntu-22.04}
- {name: "Ubuntu 24.04 x64", os: ubuntu-24.04}
- {name: "macOS Latest x64", os: macos-latest}
steps:
- uses: actions/checkout@v3
with:
submodules: ${{ matrix.config.checkout-submodules }}
fetch-depth: 0
- name: configure
run: |
cmake -S . -B avisynth-build ${{ matrix.config.cmake-parameters }}
- name: build
run: |
cmake --build avisynth-build --config Release -j 2
================================================
FILE: .gitignore
================================================
avisynth-build/*
CMakeCache.txt
CMakeFiles/*
distrib/docs/english/build/
distrib/WinInstaller/git_rev.ini
distrib/WinInstaller/*.exe
distrib/WinInstaller/*.bak
distrib/WinInstaller/x86/*
distrib/WinInstaller/x64/*
distrib/Prerequisites/VC_redist.x64.exe
distrib/Prerequisites/VC_redist.x86.exe
distrib/Prerequisites/vcredist_x64.exe
distrib/Prerequisites/vcredist_x86.exe
distrib/Prerequisites/VC_redist_14.27.29114.0.x86.exe
distrib/Prerequisites/VC_redist_14.27.29114.0.x64.exe
avs_core/CMakeCache.txt
avs_core/CMakeFiles/*
# Intel Profiler
avs_core/VTune Profiler Results/*
GPUCache/*
*.db3
avs_core/core/version.h
plugins/CMakeCache.txt
plugins/CMakeFiles/*
plugins/ConvertStacked/CMakeCache.txt
plugins/ConvertStacked/CMakeFiles/*
plugins/ConvertStacked/debug/*
plugins/ConvertStacked/release/*
plugins/DirectShowSource/CMakeCache.txt
plugins/DirectShowSource/CMakeFiles/*
plugins/DirectShowSource/debug/*
plugins/DirectShowSource/release/*
plugins/ImageSeq/CMakeCache.txt
plugins/ImageSeq/CMakeFiles/*
plugins/ImageSeq/debug/*
plugins/ImageSeq/release/*
plugins/Shibatch/CMakeCache.txt
plugins/Shibatch/CMakeFiles/*
plugins/Shibatch/debug/*
plugins/Shibatch/release/*
plugins/Shibatch/PFC/CMakeCache.txt
plugins/Shibatch/PFC/CMakeFiles/*
plugins/Shibatch/PFC/debug/*
plugins/Shibatch/PFC/release/*
plugins/TimeStretch/CMakeCache.txt
plugins/TimeStretch/CMakeFiles/*
plugins/TimeStretch/debug/*
plugins/TimeStretch/release/*
plugins/TimeStretch/SoundTouch/CMakeCache.txt
plugins/TimeStretch/SoundTouch/CMakeFiles/*
plugins/TimeStretch/SoundTouch/debug/*
plugins/TimeStretch/SoundTouch/release/*
plugins/VDubFilter/CMakeCache.txt
plugins/VDubFilter/CMakeFiles/*
plugins/VDubFilter/debug/*
plugins/VDubFilter/release/*
plugins/VFAPIFilter/CMakeCache.txt
plugins/VFAPIFilter/CMakeFiles/*
plugins/VFAPIFilter/debug/*
plugins/VFAPIFilter/release/*
#cmake generated files
*.sln
*.slnx
*.vcxproj
*.vcxproj.filters
arch.c
avs_core/arch.h
avs_core/avisynth_conf.h
avs_core/version.h
avs_core/avisynth.pc
cmake_install.cmake
generate.stamp
generate.stamp.depend
out/*
debug/*
output/*
release/*
win32/*
x64/*
avscore/debug
avscore/release/*
avscore/win32/*
avscore/x64/*
# User-specific files
*.suo
*.user
*.userosscache
*.sln.docstates
# Build results
[Dd]ebug/
[Dd]ebugPublic/
[Rr]elease/
[Rr]eleases/
[Rr]elWithDebInfo/
x64/
x86/
bld/
[Bb]in/
[Oo]bj/
[Ll]og/
# Visual C++ cache files
ipch/
*.aps
*.ncb
*.opendb
*.opensdf
*.sdf
*.cachefile
*.VC.db
*.VC.VC.opendb
*.VC.db-shm
*.VC.db-wal
# Visual Studio profiler
*.psess
*.vsp
*.vspx
*.sap
#Visual Studio other
.vs/
*.rej
*.orig
*_BACKUP_*
*_BASE_*
*_LOCAL_*
*_REMOTE_*
# Assorted build generator files
Makefile
build.ninja
rules.ninja
.ninja_deps
.ninja_log
cmake_uninstall.cmake
*.pc
*.so
================================================
FILE: .gitmodules
================================================
[submodule "filesystem"]
path = filesystem
url = https://github.com/gulrak/filesystem
================================================
FILE: .readthedocs.yaml
================================================
# Read the Docs configuration file for Sphinx projects
# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
# Required
version: 2
# Set the OS, Python version and other tools you might need
build:
os: ubuntu-22.04
tools:
python: "3.12"
# You can also specify other tool versions:
# nodejs: "20"
# rust: "1.70"
# golang: "1.20"
# Build documentation in the "docs/" directory with Sphinx
sphinx:
configuration: distrib/docs/english/source/conf.py
# You can configure Sphinx to use a different builder, for instance use the dirhtml builder for simpler URLs
# builder: "dirhtml"
# Fail on all warnings to avoid broken references
# fail_on_warning: true
# Optionally build your docs in additional formats such as PDF and ePub
formats: all
# - pdf
# - epub
# Optional but recommended, declare the Python requirements required
# to build your documentation
# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
# python:
# install:
# - requirements: docs/requirements.txt
================================================
FILE: CMakeLists.txt
================================================
# Tested generators:
# Command line makefile generator
# "MinGW Makefiles": MSYS2/Mingw32 GCC 8.3, 10.3 build
# IDE project file generators
# "Visual Studio 15 2017" optional platform generator Win32 and x64
# "Visual Studio 16 2019" optional platform generator Win32 and x64. optional toolset "v141_xp"
# "Visual Studio 17 2022" optional platform generator Win32 and x64. optional toolset "v141_xp" or "clangcl"
# "Visual Studio 18 2026" optional platform generator Win32 and x64. optional toolset "v141_xp" or "clangcl"
# Intel C++ Compilers
# Minimum Cmake version for Intel C++ Compiler 2023: 3.22.3 (Win) 3.20 (Linux)
# Howto: https://www.intel.com/content/www/us/en/developer/articles/technical/using-oneapi-compilers-with-cmake-in-visual-studio.html
# "Intel(R) oneAPI DPC++ Compiler", two flavours. DPCPP is not compatible with Avisynth.
# - Intel® NextGen Compiler (in base kit, LLVM based): TOOLSET = "Intel C++ Compiler 2023", COMPILER EXE NAME = icx.exe
# - Intel® Classic Compiler (in extra HPC kit): TOOLSET = "Intel C++ Compiler 19.2", COMPILER EXE NAME = icl.exe
# CMake support files.
# - Info from: c:\Program Files (x86)\Intel\oneAPI\compiler\latest\windows\IntelDPCPP\ReadMe.txt
# - copy c:\Program Files (x86)\Intel\oneAPI\compiler\latest\windows\IntelDPCPP\IntelDPCPPConfig.cmake to c:\Program Files\CMake\share\cmake-3.20\Modules\
# CMake GUI:
# - Generator: "Visual Studio 17 2022"
# - Optional toolset to use (-T option):
# For LLVM based icx: Intel C++ Compiler 2023 (or earlier 2022, 2021)
# For classic icl: Intel C++ Compiler 19.2
# - Specify native compilers: browse for the appropriate compiler executable path.
# icx: C:\Program Files (x86)\Intel\oneAPI\compiler\latest\windows\bin\icx.exe
# icl: C:\Program Files (x86)\Intel\oneAPI\compiler\latest\windows\bin\intel64\icl.exe
# If you have errors like "xilink: : error : Assertion failed (shared/driver/drvutils.c, line 312" then
# as a workaround you must copy clang.exe (by default it is located in C:\Program Files (x86)\Intel\oneAPI\compiler\latest\windows\bin)
# to the folder beside xilink (for x64 configuration it is in C:\Program Files (x86)\Intel\oneAPI\compiler\latest\windows\bin\intel64).
# Successful log looks like:
# The CXX compiler identification is IntelLLVM 2023.0.0 with MSVC-like command-line
# Check for working CXX compiler: C:/Program Files (x86)/Intel/oneAPI/compiler/2023.0.0/windows/bin/icx.exe - skipped
# or
# The CXX compiler identification is IntelLLVM 2021.4.0 with MSVC-like command-line
# Check for working CXX compiler: C:/Program Files (x86)/Intel/oneAPI/compiler/2021.4.0/windows/bin/icx.exe
# or
# The CXX compiler identification is Intel 2021.4.0.20210910
# Check for working CXX compiler: C:/Program Files (x86)/Intel/oneAPI/compiler/2021.4.0/windows/bin/intel64/icl.exe
#
# command line:
# run "C:\Program Files (x86)\Intel\oneAPI\setvars.bat" to configure the environment
# cmake -T "Intel C++ Compiler 2023" -DCMAKE_CXX_COMPILER="icx.exe" ../
# or
# cmake -T "Intel C++ Compiler 19.2" -DCMAKE_CXX_COMPILER="icl.exe" ../
# "Visual Studio 16 2019" + LLVM 8.0 (clang) optional platform generator Win32 and x64
CMAKE_MINIMUM_REQUIRED( VERSION 3.6.2...3.11 )
# VS2019: 3.14.1
# Intel 2023: 3.22.3 (Win) 3.20 (Linux)
# VS2022: 3.21
# VS2026: 4.2
# Get PROJECT_VERSION property from 'avs_core/core/version.h.in'
file(READ "avs_core/core/version.h.in" versioning)
string(REGEX MATCH "AVS_MAJOR_VER[ \\t]+([0-9]*)" _ ${versioning})
set(version_major ${CMAKE_MATCH_1})
string(REGEX MATCH "AVS_MINOR_VER[ \\t]+([0-9]*)" _ ${versioning})
set(version_minor ${CMAKE_MATCH_1})
string(REGEX MATCH "AVS_BUGFIX_VER[ \\t]+([0-9]*)" _ ${versioning})
set(version_bugfix ${CMAKE_MATCH_1})
# Combine version variables for use in the project command
set(PROJECT_VERSION_STRING "${version_major}.${version_minor}.${version_bugfix}")
# Get AVISYNTH_INTERFACE_VERSION from avs_core/include/avisynth.h
file(READ "avs_core/include/avisynth.h" versioning)
string(REGEX MATCH "AVISYNTH_INTERFACE_VERSION = ([0-9]*)" _ ${versioning})
set(AVISYNTH_INTERFACE_VERSION ${CMAKE_MATCH_1})
option(BUILD_SHARED_LIBS "Build shared libraries instead of static ones." ON)
if(NOT ${BUILD_SHARED_LIBS})
message(WARNING "You must satisfy the conditions of the GPL license when linking against the AviSynth library.")
endif()
option(HEADERS_ONLY "Install only the Headers" ${INSTALL_ONLY_HEADER})
if(${INSTALL_ONLY_HEADER})
set(INSTALL_ONLY_HEADER OFF)
endif()
if(NOT HEADERS_ONLY)
project("AviSynth+" VERSION ${PROJECT_VERSION_STRING} LANGUAGES CXX)
# message("Compiler ID: ${CMAKE_CXX_COMPILER_ID} ")
include(GNUInstallDirs)
# Avoid uselessly linking to unused libraries
set(CMAKE_STANDARD_LIBRARIES "" CACHE STRING "" FORCE)
set(CMAKE_C_STANDARD_LIBRARIES "" CACHE STRING "" FORCE)
set(CMAKE_CXX_STANDARD_LIBRARIES "" CACHE STRING "" FORCE)
# We require C++17 or higher.
if(CMAKE_VERSION VERSION_GREATER 3.7)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
set(CMAKE_CXX_EXTENSIONS FALSE)
endif()
# Detect Intel processors and turn Intel SIMD on or off automatically.
# Detect AArch64 processors and turn AArch64 NEON SIMD on or off automatically.
# Old logic relied on the host processor: ${CMAKE_SYSTEM_PROCESSOR}
set(INTEL_SIMD "OFF")
set(NEON_SIMD "OFF")
# Use a list of known Intel-compatible/aarch64 architecture names for the default ON state.
set(INTEL_ARCH_NAMES "win32" "x64" "x86" "i386" "amd64" "x86_64" "i686")
set(ARM_ARCH_NAMES "arm64" "aarch64")
# Check the TARGET architecture using the most reliable variables (CMAKE_GENERATOR_PLATFORM and PLATFORMID_LOWER)
string(TOLOWER "${PLATFORMID}" PLATFORMID_LOWER)
string(TOLOWER "${CMAKE_GENERATOR_PLATFORM}" GEN_PLATFORM_LOWER) # Often holds x64, ARM64, etc.
string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" HOST_ARCH_LOWER) # ninja with ative aarch64 gcc: probably only this exists
# --- DEBUG OUTPUT START ---
# message(STATUS "--- SIMD Detection Variables ---")
# message(STATUS "CMAKE_SYSTEM_PROCESSOR (Host Arch): ${CMAKE_SYSTEM_PROCESSOR}")
# message(STATUS "Host Arch Lower: ${HOST_ARCH_LOWER}")
# message(STATUS "PLATFORMID_LOWER (VS Target Platform): ${PLATFORMID_LOWER}")
# message(STATUS "CMAKE_GENERATOR_PLATFORM (Generator Target): ${CMAKE_GENERATOR_PLATFORM}")
# message(STATUS "INTEL_ARCH_NAMES: ${INTEL_ARCH_NAMES}")
# message(STATUS "------------------------------------")
# --- DEBUG OUTPUT END ---
# e.g. ARM64 cross-compile on x64 machine:
# CMAKE_SYSTEM_PROCESSOR (Host Arch): AMD64
# Host Arch Lower: amd64
# PLATFORMID_LOWER (VS Target Platform):
# CMAKE_GENERATOR_PLATFORM (Generator Target): ARM64
# check aarch64 variants
list(FIND ARM_ARCH_NAMES "${HOST_ARCH_LOWER}" _found_arm_host) # New check
list(FIND ARM_ARCH_NAMES "${PLATFORMID_LOWER}" _found_arm_platform_id)
list(FIND ARM_ARCH_NAMES "${GEN_PLATFORM_LOWER}" _found_arm_gen)
# check intel variants
list(FIND INTEL_ARCH_NAMES "${HOST_ARCH_LOWER}" _found_arch)
list(FIND INTEL_ARCH_NAMES "${PLATFORMID_LOWER}" _found_target_platform_id)
list(FIND INTEL_ARCH_NAMES "${GEN_PLATFORM_LOWER}" _found_target_gen)
# 1. Check if the target platform is explicitly known non-Intel (ARM64, AARCH64)
if(_found_arm_platform_id GREATER -1 OR _found_arm_gen GREATER -1 OR _found_arm_host GREATER -1)
set(INTEL_SIMD "OFF")
set(NEON_SIMD "ON")
message(STATUS "Target is aarch64, turn NEON_SIMD ON.")
else()
# 2. Inclusion Check: We are NOT targeting ARM64.
# Define a boolean check: Did we find a match in the explicit target variables OR the host architecture?
if(_found_target_gen GREATER -1 OR _found_target_platform_id GREATER -1)
# Found a match in a generator-set variable (e.g., Win32, x64 when explicitly chosen)
set(INTEL_SIMD "ON")
message(STATUS "Target architecture is explicitly set and Intel-compatible, INTEL_SIMD set ON.")
elseif(_found_arch GREATER -1 AND "${GEN_PLATFORM_LOWER}" STREQUAL "")
# FALLBACK: Target platform is NOT set (Default Configuration), but the Host is Intel-compatible.
# The default target platform for a multi-config generator on a bare x64 host is x64.
set(INTEL_SIMD "ON")
message(STATUS "Target platform not specified; defaulting to Host (${CMAKE_SYSTEM_PROCESSOR}), INTEL_SIMD set ON.")
endif()
endif()
# message(STATUS "Final INTEL_SIMD initial assumption: ${INTEL_SIMD}")
option(ENABLE_INTEL_SIMD "Enable SIMD intrinsics for Intel processors" "${INTEL_SIMD}")
option(ENABLE_NEON_SIMD "Enable SIMD intrinsics for AArch64 processors" "${NEON_SIMD}")
option(ENABLE_PLUGINS "Build set of default external plugins" ON)
set(USER_AVS_PLUGINDIR_LOCATION ".local/lib/avisynth" CACHE STRING "Override path for user-local plugins, with $HOME omitted (default: .local/lib/avisynth)")
option(ENABLE_CUDA "Enable CUDA support" OFF)
set(CORE_PLUGIN_INSTALL_PATH "${CMAKE_INSTALL_FULL_LIBDIR}" CACHE STRING "Set system plugin install parent directory (default: value of CMAKE_INSTALL_FULL_LIBDIR)")
if(CMAKE_VERSION VERSION_GREATER 3.9)
get_cmake_property(MULTI_CONFIG GENERATOR_IS_MULTI_CONFIG)
if(MULTI_CONFIG)
if(CMAKE_CONFIGURATION_TYPES)
set(CMAKE_CONFIGURATION_TYPES Debug Release RelWithDebInfo)
set(CMAKE_CONFIGURATION_TYPES "${CMAKE_CONFIGURATION_TYPES}" CACHE STRING "Reset the configurations to what we need" FORCE)
endif()
message("-- Build type: Multi-configuration (${CMAKE_CONFIGURATION_TYPES})")
else()
# When CMAKE_BUILD_TYPE is not defined, CMake defaults to a simple -O0 configuration, no compiler optimizations
# and no debug symbols. For single-configuration generators (Makefiles, Ninja, etc.) we can make Release the
# assumed default if it isn't explicitly set by the user. Multi-config generators like Visual Studio ignore
# CMAKE_BUILD_TYPE.
# Unfortunately, this is not visible in CMakeCache, but it can be seen to take effect in build.ninja or running
# make with VERBOSE=1 adding the appropriate Release flags.
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE "Release")
endif()
message("-- Build type: ${CMAKE_BUILD_TYPE}")
endif()
endif()
# Use this one to be safe:
# Check for the Visual Studio generator OR the MSVC compiler/toolchain on Windows
# (which includes Ninja with cl.exe).
# We use the MSVC variable to ensure the configuration block runs when cl.exe is detected.
if( CMAKE_GENERATOR MATCHES "Visual Studio" OR (MSVC AND WIN32) )
## IF( MSVC ) # Check for Visual Studio
#1910-1919 = VS 15.0 (v141 toolset) Visual Studio 2017
#1920-1929 = VS 16.0 (v142 toolset) Visual Studio 2019
#1930-1949 = VS 17.x (v143 toolset) Visual Studio 2022
# ( 1940-1949 = VS v17.10+: Toolset v143 (Still!) | Compiler 19.4x)
#1950-1959 = VS 18.0 (v145 toolset) Visual Studio 2026
# --- Determine MSVC target platform, Ninja makes a bit more work for us
# Since CMAKE_VS_PLATFORM_NAME is empty, only valid for Visual Studio generators.
# Detect the target platform based on the most reliable variables for MSVC/Ninja:
# 1. start with the VS Generator's specific variable. If it's not set, it will be empty.
set(TARGET_PLATFORM_TO_CHECK "${CMAKE_VS_PLATFORM_NAME}")
# message(STATUS "DEBUG: CMAKE_VS_PLATFORM_NAME = '${CMAKE_VS_PLATFORM_NAME}'")
# message(STATUS "DEBUG: CMAKE_GENERATOR_PLATFORM = '${CMAKE_GENERATOR_PLATFORM}'")
# message(STATUS "DEBUG: CMAKE_SIZEOF_VOID_P = '${CMAKE_SIZEOF_VOID_P}'")
# 2. If CMAKE_VS_PLATFORM_NAME is empty (e.g., Ninja generator), try to infer from pointer size.
if(NOT TARGET_PLATFORM_TO_CHECK)
# 3. Check the pointer size (most reliable indicator for x64/Win32)
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
# 64-bit target
set(TARGET_PLATFORM_TO_CHECK "x64")
elseif(CMAKE_SIZEOF_VOID_P EQUAL 4)
# 32-bit target
set(TARGET_PLATFORM_TO_CHECK "Win32")
endif()
endif()
# 4. final attempt: If CMAKE_GENERATOR_PLATFORM has a value and TARGET_PLATFORM_TO_CHECK is still empty
if(NOT TARGET_PLATFORM_TO_CHECK AND CMAKE_GENERATOR_PLATFORM)
set(TARGET_PLATFORM_TO_CHECK "${CMAKE_GENERATOR_PLATFORM}")
endif()
# detect if the target is for x86
# PLATFORMID_LOWER is just a lowercase copy of CMAKE_VS_PLATFORM_NAME
string(TOLOWER "${TARGET_PLATFORM_TO_CHECK}" PLATFORMID_LOWER)
# message("-- PLATFORMID_LOWER: ${PLATFORMID_LOWER}")
if(("${PLATFORMID_LOWER}" STREQUAL "win32") OR
("${PLATFORMID_LOWER}" STREQUAL "x64") OR
("${PLATFORMID_LOWER}" STREQUAL "arm64")) # allow arm64 targets
set(SUPPORTED_MSVC_PLATFORM "ON")
else()
set(SUPPORTED_MSVC_PLATFORM "OFF")
endif()
if(SUPPORTED_MSVC_PLATFORM STREQUAL "OFF")
message(FATAL_ERROR "MSVC/ClangCL only supported on Win32, x64, or ARM64 targets. Use MinGW (llvm-mingw or gcc). Unsupported target: ${CMAKE_VS_PLATFORM_NAME}.")
endif()
#[[
# check to disable ARM64 by default
# PF: re-allowed; VS2026 can build ARM64 even with LLVM
if(("${PLATFORMID_LOWER}" STREQUAL "arm64") AND (NOT DEFINED ENABLE_ARM64_WITH_MSVC_TESTING))
# This FATAL_ERROR can be commented out or protected by the ENABLE_ARM64_TESTING cache variable.
# To enable the build, define -DENABLE_ARM64_TESTING=ON when running cmake.
message(FATAL_ERROR "MSVC ARM64 platform is currently disabled by default. Define ENABLE_ARM64_WITH_MSVC_TESTING=ON to proceed or use MinGW (llvm-mingw or gcc).")
endif()
#]]
IF( MSVC_VERSION VERSION_LESS 1910 )
MESSAGE(FATAL_ERROR "Visual C++ 2017 or newer required.")
ENDIF()
# Milestones
# C++17 COMPLETENESS: Compiler versions 19.10-19.19 (VS 2017) had incomplete C++17 support.
# Full C++17 support: starting with compiler version 19.20 (VS 2019 RTM).
# C++20 COMPLETENESS: Compiler version 19.29 (VS 2019 v16.10+): full C++20 standard library support.
# VS 2022 (v19.30+) is generally recommended for best C++20 stability and language feature compliance.
# Damn XP support prevents defining a minimum.
# When v141_xp toolset is used, MSVC_VERSION is 1916
# So we temporarily inactivate the minimum version check:
IF(FALSE)
IF( MSVC_VERSION VERSION_LESS 1929 )
message("--MSVC_VERSION is (${MSVC_VERSION})")
MESSAGE(FATAL_ERROR "Visual C++ 2019 (v16.10+) or newer is required for C++20 support. Recommended: Visual Studio 2022.")
ENDIF()
ENDIF()
file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/Output/plugins")
file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/Output/system")
file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/Output/c_api")
IF(MSVC_IDE)
message("MSVC_IDE support found, reported CMAKE_GENERATOR_TOOLSET is: ${CMAKE_GENERATOR_TOOLSET}")
string( TOLOWER "${CMAKE_GENERATOR_TOOLSET}" cmake_gentoolset_lower)
IF(cmake_gentoolset_lower STREQUAL "intel c++ compiler 2021" OR
cmake_gentoolset_lower STREQUAL "intel c++ compiler 2022" OR
cmake_gentoolset_lower STREQUAL "intel c++ compiler 2023" OR
cmake_gentoolset_lower STREQUAL "intel c++ compiler 2024" OR
cmake_gentoolset_lower STREQUAL "intel c++ compiler 2025" OR
cmake_gentoolset_lower STREQUAL "intel c++ compiler 2026"
)
# IntelLLVM
set(IntelLLVM_IN_VS "1")
ELSEIF(cmake_gentoolset_lower STREQUAL "intel c++ compiler 19.2")
# Intel Classic
set(IntelClassic_IN_VS "1")
ELSEIF(cmake_gentoolset_lower MATCHES "intel")
MESSAGE(FATAL_ERROR "Possibly unknown or unsupported Intel compiler") # version update needed in the above lines
ELSEIF(cmake_gentoolset_lower STREQUAL "llvm" OR cmake_gentoolset_lower STREQUAL "clangcl")
if(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang") # hope: always
message("LLVM toolset was specified via -T. Compiler ID is: ${CMAKE_CXX_COMPILER_ID}; CMAKE_CXX_COMPILER_VERSION is: ${CMAKE_CXX_COMPILER_VERSION}")
# Clang; 9.0.0
# These are probably not supported when clang is downloaded as a ready-made binary: CLANG_VERSION_MAJOR CLANG_VERSION_MINOR CLANG_VERSION_STRING
# string (REGEX REPLACE ".*clang version ([0-9]+\\.[0-9]+).*" "\\1" CLANG_VERSION_STRING ${clang_full_version_string})
if( CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.0.1 )
MESSAGE(FATAL_ERROR "Clang 7.0.1 or newer required") # as of November 2021 actually we are using 12.0
endif()
endif()
set(CLANG_IN_VS "1")
ELSEIF(cmake_gentoolset_lower STREQUAL "v141_clang_c2")
#1900 is reported
message("v141_clang_c2 toolset was specified via -T. Reported MSVC_VERSION is: ${MSVC_VERSION}")
message("May not work, try clangcl or LLVM")
set(CLANG_IN_VS "1")
# For LLVM Clang installed separately, specify llvm
# Since Visual Studio 2019 v16.4, LLVM 9.0 or newer is integrated, for this use Toolset: clangcl
ENDIF()
option(WINXP_SUPPORT "Make binaries compatible with Windows XP and Vista" OFF)
if(WINXP_SUPPORT)
# We want our project to also run on Windows XP
# Not for LLVM: Clang stopped XP support in 2016
IF(NOT CLANG_IN_VS STREQUAL "1")
# Setting CMAKE_GENERATOR_TOOLSET here has no effect, only when passed (-T option) or set directly, so we just check it
IF(CMAKE_GENERATOR_TOOLSET STREQUAL "v141_xp")
# v141_xp is still available in Visual Studio 2022 and 2026.
message("CMAKE_GENERATOR_TOOLSET is XP compatible: ${CMAKE_GENERATOR_TOOLSET}, extra XP options added")
# https://connect.microsoft.com/VisualStudio/feedback/details/1789709/visual-c-2015-runtime-broken-on-windows-server-2003-c-11-magic-statics
# later done: add_definitions("/Zc:threadSafeInit-")
ELSE()
message(FATAL_ERROR "For XP you must specify v141_xp toolset with -T option (or 'Optional toolset to use' in CMake GUI)!")
ENDIF()
ENDIF()
endif()
ENDIF()
if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
set(CLANG_IN_VS "1")
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM" AND CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
set(IntelLLVM_IN_VS "1")
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel" AND CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
set(IntelClassic_IN_VS "1")
endif()
IF(IntelClassic_IN_VS STREQUAL "1")
# Intel C++ Compiler 19.2
message("Intel Classic chosen, setting additional flags")
set(DELETE_THIS "/std:c++17") # if it would co-exist with /Qstd=c++17
STRING( REPLACE "${DELETE_THIS}" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
STRING( REPLACE "${DELETE_THIS}" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
# Workaround as of 19.2:
# Statically link with /MT instead of /MD against linker error message
# "unresolved external symbol wmemcmp referenced in function std::filesystem ... lexically_normal"
# Linker bug?
set(CompilerFlags
CMAKE_CXX_FLAGS
CMAKE_CXX_FLAGS_DEBUG
CMAKE_CXX_FLAGS_RELEASE
CMAKE_CXX_FLAGS_MINSIZEREL
CMAKE_CXX_FLAGS_RELWITHDEBINFO
CMAKE_C_FLAGS
CMAKE_C_FLAGS_DEBUG
CMAKE_C_FLAGS_RELEASE
CMAKE_C_FLAGS_MINSIZEREL
CMAKE_C_FLAGS_RELWITHDEBINFO
)
foreach(CompilerFlag ${CompilerFlags})
string(REPLACE "/MD" "/MT" ${CompilerFlag} "${${CompilerFlag}}")
set(${CompilerFlag} "${${CompilerFlag}}" CACHE STRING "msvc compiler flags" FORCE)
message("MSVC flags: ${CompilerFlag}:${${CompilerFlag}}")
endforeach()
ELSE()
# Plain MSVC branch continues; per-target options are applied later
ENDIF()
# CPU_ARCH can be overridden with the corresponding values when using MSVC:
# IA32 (disabled),
# SSE (Pentium III and higher, 1999),
# SSE2 (Pentium 4 and higher, 2000/2001),
# AVX (Sandy Bridge and higher, 2011),
# AVX2 (Haswell and higher, 2013)
if(CMAKE_SIZEOF_VOID_P EQUAL 4)
set(MSVC_CPU_ARCH "SSE2" CACHE STRING "Set MSVC architecture optimization level (default: SSE2)")
# /arch: applied later per-target
endif()
ELSE()
# not MS Visual Studio IDE
if(WIN32)
SET( CMAKE_SHARED_LINKER_FLAGS "-Wl,--enable-stdcall-fixup" )
# __CRT__NO_INLINE: moved to per-target definitions
elseif(APPLE)
# macOS uses Clang's linker, doesn't like --no-undefined
SET( CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-undefined,error" )
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
# make sure there are no undefined symbols
SET( CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined" )
endif()
ENDIF()
add_subdirectory("avs_core")
# Start tracking targets before the plugins subdirectory is processed
get_property(_targets_before_plugins GLOBAL PROPERTY BUILT_TARGETS)
if(ENABLE_PLUGINS)
add_subdirectory("plugins")
endif()
# End tracking targets and apply fixes here
get_property(_targets_after_plugins GLOBAL PROPERTY BUILT_TARGETS)
# Calculate targets added in the plugins subdirectory
list(REMOVE_ITEM _targets_after_plugins ${_targets_before_plugins})
set(NEW_PLUGIN_TARGETS ${_targets_after_plugins})
# Combine AvsCore and the newly discovered plugins into one list for fixing
set(ALL_AFFECTED_TARGETS)
if(TARGET AvsCore)
list(APPEND ALL_AFFECTED_TARGETS AvsCore)
endif()
list(APPEND ALL_AFFECTED_TARGETS ${NEW_PLUGIN_TARGETS})
# -----------------------------------------------------------------------
# Per-target, modern & safe application of options/defines (CORE and PLUGINS)
# -----------------------------------------------------------------------
foreach(AFFECTED_TARGET ${ALL_AFFECTED_TARGETS})
if(TARGET ${AFFECTED_TARGET})
message(STATUS "Applying compiler fixes to target: ${AFFECTED_TARGET}")
# Check if the target is a library or executable (exclude INTERFACE targets)
get_target_property(_target_type ${AFFECTED_TARGET} TYPE)
if(NOT (
${_target_type} STREQUAL "SHARED_LIBRARY" OR
${_target_type} STREQUAL "STATIC_LIBRARY" OR
${_target_type} STREQUAL "MODULE_LIBRARY"
))
# Skip if it's not a compileable target (e.g., if it was an interface target)
continue()
endif()
# Use a compound check: If the generator is Visual Studio, or the compiler ID
# is MSVC AND we are on Windows, run the MSVC-specific logic.
if( CMAKE_GENERATOR MATCHES "Visual Studio" OR (MSVC AND WIN32) )
# Using only if(MSVC) will fail with MinGW if the compiler ID is MSVC but the generator is not VS.
# This robust check ensures that the MSVC block only runs in an MSVC environment.
# Handle ARM64 soft intrinsics if requested (for AvsCore logic)
# Was experimental, never true
if("${PLATFORMID}" STREQUAL "ARM64" AND ENABLE_INTEL_SIMD)
target_compile_definitions(${AFFECTED_TARGET} PRIVATE USE_SOFT_INTRINSICS)
endif()
# Needed to properly handle __has_include(<filesystem>) in avs_core/filesystem.h
# See note in filesystem/README.md
target_compile_options(${AFFECTED_TARGET} PRIVATE /Zc:__cplusplus)
# Prevent VC++ secure CRT warnings, and add __SSE2__ flag. (Why?)
target_compile_definitions(${AFFECTED_TARGET} PRIVATE
_CRT_SECURE_NO_WARNINGS
_SECURE_SCL=0
_CRTDBG_MAP_ALLOC
__SSE2__
)
# INTEL intrinsics master switch (if enabled)
if(ENABLE_INTEL_SIMD)
target_compile_definitions(${AFFECTED_TARGET} PRIVATE INTEL_INTRINSICS)
endif()
# NEON intrinsics master switch (if enabled)
if(ENABLE_NEON_SIMD)
target_compile_definitions(${AFFECTED_TARGET} PRIVATE NEON_INTRINSICS)
endif()
# FIXME: With Ninja, we can see cl : Command line warning D9025 : overriding '/EHs' with '/EHa'
# Compiler-specific options for IntelLLVM / Clang
if(CLANG_IN_VS STREQUAL "1")
target_compile_options(${AFFECTED_TARGET} PRIVATE /EHa -Wno-inconsistent-missing-override)
target_compile_options(${AFFECTED_TARGET} PRIVATE -Wno-unused-function -Wno-reorder -Wno-unused-value -Wno-gcc-compat)
elseif(IntelLLVM_IN_VS STREQUAL "1")
target_compile_options(${AFFECTED_TARGET} PRIVATE -Wno-inconsistent-missing-override /EHa /fp:precise)
target_compile_options(${AFFECTED_TARGET} PRIVATE -Wno-unused-function -Wno-reorder -Wno-unused-value -Wno-gcc-compat)
elseif(IntelClassic_IN_VS STREQUAL "1")
target_compile_options(${AFFECTED_TARGET} PRIVATE /EHa)
else()
# Plain MSVC
target_compile_options(${AFFECTED_TARGET} PRIVATE /EHa)
if (NOT (MSVC_VERSION LESS 1930)) # VS2022+
target_compile_options(${AFFECTED_TARGET} PRIVATE /fp:contract)
endif()
endif()
# Enable standards-conformance mode for MSVC compilers that support this
# flag (Visual C++ 2017 and later). Default. DirectShowSource will remove if needed.
# The headers in the XP-side SDK also have errors if built in conformance mode,
# so if we're building for XP, don't turn that on.
# Plus check: Skip /permissive- if the target (e.g. DirectShowSource) requests it.
# Filled in plugin's CMakeLists.txt
get_target_property(_skip_permissive ${AFFECTED_TARGET} SKIP_PERMISSIVE_FLAG)
if(NOT _skip_permissive) # old DirectShowSource
if (NOT WINXP_SUPPORT)
if (NOT (MSVC_VERSION LESS 1910))
target_compile_options(${AFFECTED_TARGET} PRIVATE /permissive-)
endif()
endif()
endif()
# Check if XP support is enabled AND if the XP toolset is used (v141_xp)
if (WINXP_SUPPORT)
if (CMAKE_GENERATOR_TOOLSET STREQUAL "v141_xp")
# C++11 static initialization fix for XP/Server 2003
target_compile_options(${AFFECTED_TARGET} PRIVATE "/Zc:threadSafeInit-")
endif()
endif()
# 32-bit arch tuning
if(CMAKE_SIZEOF_VOID_P EQUAL 4)
target_compile_options(${AFFECTED_TARGET} PRIVATE /arch:${MSVC_CPU_ARCH})
endif()
else()
# CMAKE_CXX_STANDARD doesn't cover the use-case of pre-final C++17 support,
# but I'd assume most setups with a new enough version of CMake to use
# CMAKE_CXX_STANDARD 17 would also be running a version of GCC/Clang new enough
# to not need this. So this will most likely only ever be used by setups running
# older versions of CMake; regardless, it shouldn't be necessary to force a
# CMAKE_VERSION check on this part unless the mere presence of CMAKE_CXX_STANDARD 17
# ends up causing problems for the older compilers here.
# Legacy C++17 support for older GCC/Clang
if( ((CMAKE_CXX_COMPILER_ID STREQUAL "GNU") AND (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8)) OR
((CMAKE_CXX_COMPILER_ID STREQUAL "Clang") AND (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5)) )
target_compile_options(${AFFECTED_TARGET} PRIVATE -std=c++1z)
endif()
if(ENABLE_INTEL_SIMD)
target_compile_options(${AFFECTED_TARGET} PRIVATE -msse2)
target_compile_definitions(${AFFECTED_TARGET} PRIVATE INTEL_INTRINSICS)
endif()
if(ENABLE_NEON_SIMD)
target_compile_definitions(${AFFECTED_TARGET} PRIVATE NEON_INTRINSICS)
endif()
if(WIN32)
target_compile_definitions(${AFFECTED_TARGET} PRIVATE __CRT__NO_INLINE=1)
endif()
endif()
endif()
endforeach()
else()
# HEADERS_ONLY is ON
project(AviSynth-Headers VERSION ${PROJECT_VERSION_STRING} LANGUAGES CXX)
message(STATUS "Install Only Headers: ON")
add_library(${PROJECT_NAME} INTERFACE)
target_include_directories(${PROJECT_NAME} INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/avs_core/include")
add_library(AviSynth::Headers ALIAS ${PROJECT_NAME})
# Determine target architecture
include("${CMAKE_CURRENT_LIST_DIR}/avs_core/TargetArch.cmake")
target_architecture(AVS_ARCH)
CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/avs_core/core/arch.h.in ${CMAKE_CURRENT_BINARY_DIR}/arch.h @ONLY)
# Dynamically generate the sequential version info from Git
# Based on the example here: http://www.cmake.org/pipermail/cmake/2010-July/038015.html
FIND_PACKAGE(Git)
INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
ADD_CUSTOM_TARGET(
VersionGen ALL
${CMAKE_COMMAND} -D SRC=${CMAKE_CURRENT_SOURCE_DIR}/avs_core/core/version.h.in
-D DST=${CMAKE_CURRENT_BINARY_DIR}/version.h
-D GIT=${GIT_EXECUTABLE}
-D REPO=${CMAKE_SOURCE_DIR}
-P ${CMAKE_CURRENT_SOURCE_DIR}/avs_core/Version.cmake
)
include(GNUInstallDirs)
install(
FILES ${CMAKE_CURRENT_SOURCE_DIR}/avs_core/include/avisynth.h
${CMAKE_CURRENT_SOURCE_DIR}/avs_core/include/avisynth_c.h
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/avisynth
)
install(
DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/avs_core/include/avs
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/avisynth
)
install(
FILES "${CMAKE_CURRENT_BINARY_DIR}/version.h"
"${CMAKE_CURRENT_BINARY_DIR}/arch.h"
DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/avisynth/avs"
)
endif()
# uninstall target
configure_file(
"${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
"${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
IMMEDIATE @ONLY)
add_custom_target(uninstall
COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
================================================
FILE: README.md
================================================
AviSynth+
=========
**AviSynth+** is an improved version of the [AviSynth frameserver](http://avisynth.nl/index.php/Main_Page), with improved
features and developer friendliness.
Visit our [forum thread](http://forum.doom9.org/showthread.php?t=181351) for compilation instructions and support.
Platform availability
---------------------
| Supported OSes |
|----------------|
| Windows |
| macOS |
| Linux |
| *BSD |
| Haiku |
| Supported CPU architectures |
|-----------------------------|
| x86(-64) |
| ARM |
| PowerPC |
| SPARC |
| RISC-V |
| MIPS |
| LoongArch |
| z/Architecture |
Not all OS/CPU combinations possible from either the OS' standpoint or AviSynth+'s.
MIPS, LoongArch, and z/Architecture enabled by request to allow source compilation to succeed, but not tested on either hardware or VM
Packaging status
----------------
[](https://repology.org/project/avisynthplus/versions)
Headers for applications which dynamically load AviSynth+:
----------------------------------------------------------
The expected use-case of AviSynth+ is as a dynamically
loaded library (using LoadLibrary on Windows or dlopen
everywhere else).
Due to this, it's not actually necessary to build the
AviSynth+ library itself in order for applications using
it this way to find it.
To facilitate this, we support using CMake to do a
limited, headers-only install.
### Using CMake:
#### To install:
> mkdir avisynth-build && cd avisynth-build
> <br>cmake ../ -DHEADERS_ONLY:bool=on
> <br>make install
`-DCMAKE_INSTALL_PREFIX` can be used to override the
install location if need be.
#### To uninstall:
>make uninstall
Building the documentation:
---------------------------
(Note: the bundled documentation lags behind the descriptions found in the wiki.
You can always check the online documentation at http://avisynth.nl/index.php/Main_Page)
AviSynth+'s documentation can be generated into HTML by using Sphinx.
### Set-up:
Make sure that Sphinx is installed. This requires that Python is already
installed and the pip tool is available.
>pip install sphinx
For various Linux distributions, a Sphinx package should be available
in the distro's repositories. Often under the name 'python-sphinx'
(as it is in Ubuntu's repositories).
### Building the documentation
Once Sphinx is installed, we can build the documentation.
> cd distrib/docs/english
> <br>make html
================================================
FILE: avs_core/CMakeLists.txt
================================================
CMAKE_MINIMUM_REQUIRED( VERSION 3.6.2...3.11 )
if (WIN32)
if(BUILD_SHARED_LIBS)
set(CoreName "AviSynth")
else()
set(CoreName "avisynth")
endif()
else()
set(CoreName "avisynth")
endif()
# Create library
project("AvsCore" VERSION "${PROJECT_VERSION}" LANGUAGES CXX)
Include("Files.cmake")
# Initialize a variable to control INTEL_INTRINSICS_AVX512 definition
# AVX512 support is only available on Intel architectures and 64-bit builds and specific compilers
set(DEFINE_AVX512 FALSE)
if(ENABLE_INTEL_SIMD)
if(CMAKE_SIZEOF_VOID_P EQUAL 8) # 64-bit build
if(MSVC_IDE AND
NOT CLANG_IN_VS AND
NOT IntelLLVM_IN_VS AND
NOT IntelClassic_IN_VS) # Native MSVC, need to check version
string(REGEX MATCH "^19\\.([0-9]+)\\.([0-9]+)" MSVC_VERSION_MATCH "${CMAKE_CXX_COMPILER_VERSION}")
if(MSVC_VERSION_MATCH)
set(MSVC_MAJOR 19)
set(MSVC_MINOR ${CMAKE_MATCH_1})
set(MSVC_PATCH ${CMAKE_MATCH_2})
if(MSVC_MAJOR GREATER_EQUAL 19 AND MSVC_MINOR GREATER_EQUAL 22) # MSVC 2019 16.2 (19.22) or newer
set(DEFINE_AVX512 TRUE)
else()
# set(DEFINE_AVX512 TRUE) # perhaps compiles but not recommended
message(STATUS "Disabling AVX-512: MSVC version ${CMAKE_CXX_COMPILER_VERSION} is too old (MSVC 2019 16.2 (19.22) or newer).")
endif()
else()
message(WARNING "Could not parse native 64-bit MSVC version. AVX-512 support might be incomplete.")
endif()
else() # Not native old MSVC (likely GCC, Clang, or newer MSVC via Clang/IntelLLVM)
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
# GCC 9.0 is a reasonable safe minimum for VNNI/VBMI/VBMI2/BITALG
if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 9.0)
set(DEFINE_AVX512 TRUE)
else()
message(STATUS "Disabling AVX-512: GCC version ${CMAKE_CXX_COMPILER_VERSION} is too old (requires 9.0+).")
endif()
elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
# Clang 9.0 is a reasonable safe minimum for VNNI/VBMI/VBMI2/BITALG
if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 9.0)
set(DEFINE_AVX512 TRUE)
else()
message(STATUS "Disabling AVX-512: Clang version ${CMAKE_CXX_COMPILER_VERSION} is too old (requires 9.0+).")
endif()
elseif(CMAKE_CXX_COMPILER_ID MATCHES "Intel")
# Assume modern Intel compilers (icc, icx) support it
set(DEFINE_AVX512 TRUE)
else()
# Default case for unknown/other compilers (like Clang/Intel in VS)
# Since we exclude native MSVC, we assume modern compiler support.
set(DEFINE_AVX512 TRUE)
endif()
endif()
endif()
# Note: AVX512 related source must be guarded with #ifdef INTEL_INTRINSICS_AVX512 within the
# already existing #ifdef INTEL_INTRINSICS
# Though INTEL_INTRINSICS conditional directive can exist for 32 bit and old compiler versions,
# but INTEL_INTRINSICS_AVX512 exists only on x64 platforms for compilers supporting AVX512 features required by Avisynth
endif()
if(NOT DEFINE_AVX512)
# Remove AVX512 specific files if it's a 32-bit build
# or not supported compiler version
list(FILTER AvsCore_Sources EXCLUDE REGEX ".*_avx512\\.(cpp|hpp|h)$")
list(FILTER AvsCore_Sources EXCLUDE REGEX ".*_avx512b\\.(cpp|hpp|h)$")
endif()
add_library("AvsCore" ${AvsCore_Sources})
if(DEFINE_AVX512)
# dont' use add_definitions(-DINTEL_INTRINSICS_AVX512)
target_compile_definitions("AvsCore" PRIVATE INTEL_INTRINSICS_AVX512)
endif()
set_target_properties("AvsCore" PROPERTIES "OUTPUT_NAME" "${CoreName}")
if (NOT WIN32)
set_target_properties("AvsCore" PROPERTIES VERSION "${PROJECT_VERSION}" SOVERSION "${AVISYNTH_INTERFACE_VERSION}")
endif()
if (MINGW)
if(BUILD_SHARED_LIBS)
set_target_properties("AvsCore" PROPERTIES PREFIX "")
set_target_properties("AvsCore" PROPERTIES IMPORT_PREFIX "")
endif()
endif()
# Automatically group source files according to directory structure
foreach(FILE ${AvsCore_Sources})
get_filename_component(PARENT_DIR "${FILE}" PATH)
string(REGEX REPLACE "(\\./)" "" GROUP "${PARENT_DIR}")
string(REPLACE "/" "\\" GROUP "${GROUP}")
# group into "Source Files" and "Header Files"
if ("${FILE}" MATCHES ".*\\.cpp")
set(GROUP "Source Files\\${GROUP}")
elseif("${FILE}" MATCHES ".*\\.(h|hpp)$")
set(GROUP "Header Files\\${GROUP}")
endif()
source_group("${GROUP}" FILES "${FILE}")
endforeach()
function(handle_arch_flags ARCH_SUFFIX GCC_FLAGS MSVC_FLAGS)
string(TOLOWER "${ARCH_SUFFIX}" ARCH_SUFFIX_LOWER)
file(GLOB_RECURSE SRCS_${ARCH_SUFFIX} "*_${ARCH_SUFFIX_LOWER}.cpp")
if(SRCS_${ARCH_SUFFIX})
# Check for any MSVC-based toolchain (VS IDE or cl.exe with Ninja) on Windows.
if (MSVC) # MSVC can do Win32 and ARM64 as well.
# not this: if (MSVC_IDE), Ninja leaves MSVC_IDE off
# Check for MSVC-frontends that use GCC/Clang-like flags (e.g., ClangCL, IntelLLVM)
IF(CLANG_IN_VS STREQUAL "1" OR IntelLLVM_IN_VS STREQUAL "1" OR IntelClassic_IN_VS STREQUAL "1")
set_source_files_properties(${SRCS_${ARCH_SUFFIX}} PROPERTIES COMPILE_FLAGS "${GCC_FLAGS}")
ELSE()
# Native MSVC (cl.exe, including when used with Ninja)
IF(WIN32)
# MSVC gives warning in x64 when SSE2 flag is added, it's just required as a minimum
if(NOT (CMAKE_SIZEOF_VOID_P EQUAL 8 AND "${MSVC_FLAGS}" STREQUAL " /arch:SSE2 "))
set_source_files_properties(${SRCS_${ARCH_SUFFIX}} PROPERTIES COMPILE_FLAGS "${MSVC_FLAGS}")
endif()
endif()
ENDIF()
else()
# Fallback for all non-MSVC compilers (GCC, Clang on Linux/macOS, MinGW)
set_source_files_properties(${SRCS_${ARCH_SUFFIX}} PROPERTIES COMPILE_FLAGS "${GCC_FLAGS}")
endif()
list(APPEND AvsCore_Sources ${SRCS_${ARCH_SUFFIX}})
endif()
endfunction()
if(ENABLE_NEON_SIMD)
# =========================================================================
# AArch64 (ARM64) SIMD Flags
# =========================================================================
# See: Arch64 SIMD Compilation and Source Code Rules
# Files must be located in 'aarch64' subdirectory.
# Baseline NEON (ASIMD)
# GCC/Clang: Implicit (or -march=armv8-a) MSVC: /arch:armv8.0
# asm output debug, leave it here pls.: handle_arch_flags(NEON " -march=armv8-a -S -g -fverbose-asm -Wa,-adhln " " /arch:armv8.0 ")
handle_arch_flags(NEON " -march=armv8-a " " /arch:armv8.0 ")
# Dot Product (FEAT_DotProd / ARMv8.1-A) compulsory from ARMv8.4-A
handle_arch_flags(DP " -march=armv8.1-a+dotprod " " /arch:armv8.1 ")
# Int8 Matrix Multiply (FEAT_I8MM / ARMv8.2-A) Compulsory from ARMv8.6-A
# Use the base arch flag to enable the features, relying on modern toolchain support.
handle_arch_flags(I8MM " -march=armv8.2-a+i8mm " " /arch:armv8.2 ")
# SVE2 (Scalable Vector Extension 2) (FEAT_SVE2 / ARMv8.5-A) Compulsory from ARMv9.0-A
handle_arch_flags(SVE2 " -march=armv8.5-a+sve2 " " /arch:armv8.5 ")
# SVE2.1 (FEAT_SVE2p1 / ARMv9.1-A)
handle_arch_flags(SVE2_1 " -march=armv9.1-a+sve2.1 " " /arch:armv9.1 ")
else()
# =========================================================================
# Intel (x86/x64) SIMD Flags
# =========================================================================
# gcc/llvm/clang-like flags, MSVC flags
handle_arch_flags(SSSE3 " -mssse3 " " /arch:SSE2 ") # no special SSSE3 option in MSVC
handle_arch_flags(SSE41 " -msse4.1 " " /arch:SSE2 ") # no special SSE4.1 option in MSVC
handle_arch_flags(AVX " -mavx " " /arch:AVX ")
handle_arch_flags(AVX2 " -mavx2 -mfma " " /arch:AVX2 ")
if(DEFINE_AVX512)
# Similar to AVX2, FMA must be added explicitly for GCC/Clang.
# We also enable BMI2, as it is standard since AVX2 and useful for
# AVX-512 mask operations like _bzhi_u64/u32.
# The core subsets (F, CD, BW, DQ, VL) comprising the CPUF_AVX512_BASE
# flag are present on all AVX-512-capable architectures.
#
# Note: Early Xeon (e.g., Skylake-X/Cascadelake) may exhibit severe
# thermal throttling even on a single thread. In AviSynth+, AVX512_BASE
# must be manually enabled in-script unless CPUF_AVX512_FAST is also detected.
# Functions in *_avx512b.cpp should be dispatched on CPUF_AVX512_BASE.
set(AVX512_BASE_GCC_FLAGS
" -mfma -mbmi2 -mavx512f -mavx512cd -mavx512bw -mavx512dq -mavx512vl "
)
# CPUF_AVX512_FAST indicates a modern, low-throttling architecture (ICL/RKL/AVX10.x).
# This set represents the intersection of Icelake and AVX10.1 features:
# (F, CD, BW, DQ, VL, VNNI, VBMI, VBMI2, BITALG, VPOPCNTDQ).
# Functions in *_avx512.cpp should be dispatched on CPUF_AVX512_FAST.
set(AVX512_FAST_GCC_FLAGS
#" -march=icelake-client " # PF test
#" -march=graniterapids " # PF test avx10.1
" -mfma -mbmi2 -mavx512f -mavx512cd -mavx512bw -mavx512dq -mavx512vl -mavx512vnni -mavx512vbmi -mavx512vbmi2 -mavx512bitalg -mavx512vpopcntdq "
)
# Note: MSVC's /arch:AVX512 enables the basic subset (F, CD, BW, DQ, VL).
# Unlike GCC/Clang, MSVC does not require individual flags for extensions
# like VBMI or VNNI; if the intrinsic is used, it is compiled directly.
# GCC/Clang require either file-level flags (set here) or function-level
# target attributes.
# GCC/Clang/Intel compilers will use -mavx512... flags via handle_arch_flags
# even when running within the MSVC_IDE.
handle_arch_flags(AVX512B "${AVX512_BASE_GCC_FLAGS}" " /arch:AVX512 ") # *_avx512b.cpp
handle_arch_flags(AVX512 "${AVX512_FAST_GCC_FLAGS}" " /arch:AVX512 ") # *_avx512.cpp
endif()
ENDIF()
# Specify include directories
target_include_directories("AvsCore" PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
# Specify preprocessor definitions
target_compile_definitions("AvsCore" PRIVATE BUILDING_AVSCORE)
if(NOT ${BUILD_SHARED_LIBS})
target_compile_definitions("AvsCore" PRIVATE AVS_STATIC_LIB)
endif()
# If checked out with compat filesystem submodule, add that to system include directories
get_filename_component(
GHS_FILESYSTEM_INCLUDE_DIR
${CMAKE_CURRENT_SOURCE_DIR}/../filesystem/include
ABSOLUTE
)
if (EXISTS ${GHS_FILESYSTEM_INCLUDE_DIR})
target_include_directories("AvsCore" SYSTEM PRIVATE ${GHS_FILESYSTEM_INCLUDE_DIR})
endif()
if (CMAKE_SYSTEM_NAME STREQUAL "Haiku")
set(SYSLIB "root")
elseif(CMAKE_SYSTEM_NAME STREQUAL "OpenBSD")
set(SYSLIB "pthread")
elseif(MSVC OR MINGW)
set(SYSLIB "uuid" "winmm" "vfw32" "msacm32" "gdi32" "user32" "advapi32" "ole32" "imagehlp")
else()
set(SYSLIB "pthread" "dl" "m")
endif()
if(MINGW)
set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
set(THREADS_PREFER_PTHREAD_FLAG TRUE)
find_package(Threads REQUIRED)
list(APPEND SYSLIB "pthread")
endif()
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
list(APPEND SYSLIB "stdc++")
# stdc++fs was mainlined into stdc++ in GCC 9, but GCC 8 can build it too
if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9)
list(APPEND SYSLIB "stdc++fs")
endif()
elseif(NOT MSVC AND CMAKE_CXX_COMPILER_ID MATCHES "Clang")
list(APPEND SYSLIB "c++")
endif()
target_link_libraries("AvsCore" ${SYSLIB})
if(ENABLE_CUDA)
if(${CMAKE_VERSION} VERSION_LESS "3.19.5")
# deprecated since 3.10 but works
find_package(CUDA)
if(CUDA_FOUND)
target_include_directories("AvsCore" PRIVATE ${CUDA_INCLUDE_DIRS})
#target_link_libraries ("AvsCore" ${CUDA_LIBRARIES})
target_link_libraries ("AvsCore" ${CUDA_cudart_static_LIBRARY})
target_compile_definitions("AvsCore" PUBLIC ENABLE_CUDA)
list(APPEND SYSLIB "cudart_static")
endif()
else()
# Fixed in 3.19.5: https://gitlab.kitware.com/cmake/cmake/-/issues/21740
include(FindCUDAToolkit)
# FIXME: check supported compiler/platform/CUDA SDK version combinations
if(CUDAToolkit_FOUND)
target_include_directories("AvsCore" PRIVATE ${CUDAToolkit_INCLUDE_DIRS})
target_link_libraries ("AvsCore" CUDA::cudart_static)
target_compile_definitions("AvsCore" PUBLIC ENABLE_CUDA)
list(APPEND SYSLIB "cudart_static")
endif()
endif()
endif()
if (MSVC_IDE)
# Copy output to a common folder for easy deployment
add_custom_command(
TARGET AvsCore
POST_BUILD
COMMAND xcopy /Y \"$(TargetPath)\" \"${CMAKE_BINARY_DIR}/Output\"
)
IF(NOT CLANG_IN_VS STREQUAL "1" AND
NOT IntelLLVM_IN_VS STREQUAL "1" AND
NOT IntelClassic_IN_VS STREQUAL "1")
# LLVM does not generate exp or don't know how to do it
add_custom_command(
TARGET AvsCore
POST_BUILD
COMMAND xcopy /Y \"$(TargetDir)AviSynth.exp\" \"${CMAKE_BINARY_DIR}/Output/c_api\"
)
ENDIF()
add_custom_command(
TARGET AvsCore
POST_BUILD
COMMAND xcopy /Y \"$(TargetDir)AviSynth.lib\" \"${CMAKE_BINARY_DIR}/Output/c_api\"
)
add_custom_command(
TARGET AvsCore
POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/include ${CMAKE_BINARY_DIR}/Output/include
)
endif()
# Determine target architecture
include("${CMAKE_CURRENT_LIST_DIR}/TargetArch.cmake")
target_architecture(AVS_ARCH)
CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/core/arch.h.in ${CMAKE_CURRENT_BINARY_DIR}/arch.h @ONLY)
# Dynamically generate the sequential version info from Git
# Based on the example here: http://www.cmake.org/pipermail/cmake/2010-July/038015.html
FIND_PACKAGE(Git)
INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
ADD_CUSTOM_TARGET(
VersionGen
${CMAKE_COMMAND} -D SRC=${CMAKE_CURRENT_SOURCE_DIR}/core/version.h.in
-D DST=${CMAKE_CURRENT_BINARY_DIR}/version.h
-D GIT=${GIT_EXECUTABLE}
-D REPO=${CMAKE_SOURCE_DIR}
-P ${CMAKE_CURRENT_SOURCE_DIR}/Version.cmake
)
ADD_DEPENDENCIES("AvsCore" VersionGen)
IF(MSVC_IDE)
add_custom_command(
TARGET AvsCore
POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/avs_core/version.h ${CMAKE_BINARY_DIR}/avs_core/arch.h ${CMAKE_BINARY_DIR}/Output/include/avs
)
endif()
if (NOT EXISTS "${CMAKE_SOURCE_DIR}/.git" OR NOT GIT_FOUND)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DRELEASE_TARBALL")
endif()
# Generate pkg-config file
get_target_property(LIB_NAME AvsCore OUTPUT_NAME)
set(LIBS "-l${LIB_NAME}")
set(_SYSLIBS_ITEMS ${SYSLIB})
list(TRANSFORM _SYSLIBS_ITEMS PREPEND "-l")
list(JOIN _SYSLIBS_ITEMS " " SYSLIBS)
if(MINGW)
set(SYSLIBS "${SYSLIBS} -static")
endif()
CONFIGURE_FILE("avisynth.pc.in" "avisynth.pc" @ONLY)
# Generate avisynth.conf
CONFIGURE_FILE("avisynth_conf.h.in" "avisynth_conf.h" @ONLY)
INSTALL(TARGETS AvsCore
RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}")
INSTALL(DIRECTORY "include/"
DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/avisynth")
INSTALL(FILES "${CMAKE_CURRENT_BINARY_DIR}/version.h"
"${CMAKE_CURRENT_BINARY_DIR}/arch.h"
DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/avisynth/avs")
INSTALL(FILES "${CMAKE_CURRENT_BINARY_DIR}/avisynth.pc"
DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
================================================
FILE: avs_core/Files.cmake
================================================
FILE(GLOB AvsCore_Sources RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
"*.c"
"*.cpp"
"*.h"
"include/*.h"
"include/avs/*.h"
"convert/*.c"
"convert/*.cpp"
"convert/*.h"
"core/*.c"
"core/*.cpp"
"core/*.h"
"core/parser/*.c"
"core/parser/*.cpp"
"core/parser/*.h"
"core/fonts/*.cpp"
"core/fonts/*.h"
"filters/*.c"
"filters/*.cpp"
"filters/*.h"
"filters/conditional/*.c"
"filters/conditional/*.cpp"
"filters/conditional/*.h"
"filters/overlay/*.c"
"filters/overlay/*.cpp"
"filters/overlay/*.h"
"filters/exprfilter/*.cpp"
"filters/exprfilter/*.h"
)
IF(ENABLE_NEON_SIMD)
FILE(GLOB Conditional_Filter_Cpu_Sources RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
"filters/conditional/aarch64/*.cpp"
"filters/conditional/aarch64/*.h")
LIST(APPEND AvsCore_Sources "${Conditional_Filter_Cpu_Sources}")
FILE(GLOB Convert_Cpu_Sources RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
"convert/aarch64/*.cpp"
"convert/aarch64/*.h")
LIST(APPEND AvsCore_Sources "${Convert_Cpu_Sources}")
FILE(GLOB Filters_Cpu_Sources RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
"filters/aarch64/*.cpp"
"filters/aarch64/*.h")
LIST(REMOVE_ITEM AvsCore_Sources "")
LIST(APPEND AvsCore_Sources "${Filters_Cpu_Sources}")
FILE(GLOB Overlay_Cpu_Sources RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
"filters/overlay/aarch64/*.cpp"
"filters/overlay/aarch64/*.h")
#not removing yet, unlike for Intel, no SIMD replacement
#LIST(REMOVE_ITEM AvsCore_Sources "filters/overlay/444convert.cpp"
# "filters/overlay/444convert.h")
LIST(APPEND AvsCore_Sources "${Overlay_Cpu_Sources}")
ENDIF()
IF(ENABLE_INTEL_SIMD)
FILE(GLOB Conditional_Filter_Cpu_Sources RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
"filters/conditional/intel/*.cpp"
"filters/conditional/intel/*.hpp"
"filters/conditional/intel/*.h")
LIST(APPEND AvsCore_Sources "${Conditional_Filter_Cpu_Sources}")
FILE(GLOB Convert_Cpu_Sources RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
"convert/intel/*.cpp"
"convert/intel/*.hpp"
"convert/intel/*.h")
LIST(APPEND AvsCore_Sources "${Convert_Cpu_Sources}")
FILE(GLOB Filters_Cpu_Sources RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
"filters/intel/*.cpp"
"filters/intel/*.hpp"
"filters/intel/*.h")
LIST(REMOVE_ITEM AvsCore_Sources "")
LIST(APPEND AvsCore_Sources "${Filters_Cpu_Sources}")
FILE(GLOB Overlay_Cpu_Sources RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
"filters/overlay/intel/*.cpp"
"filters/overlay/intel/*.hpp"
"filters/overlay/intel/*.h")
LIST(REMOVE_ITEM AvsCore_Sources "filters/overlay/444convert.cpp"
"filters/overlay/444convert.h")
LIST(APPEND AvsCore_Sources "${Overlay_Cpu_Sources}")
ENDIF()
IF( MSVC OR MINGW )
# AviSource is Windows-only, because it depends on Video for Windows
FILE(GLOB AvsCore_Sources_AviSource RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
"filters/AviSource/*.c"
"filters/AviSource/*.cpp"
"filters/AviSource/*.h")
LIST(APPEND AvsCore_Sources "${AvsCore_Sources_AviSource}")
ELSE()
LIST(APPEND AvsCore_Sources "core/parser/os/win32_string_compat.cpp")
LIST(APPEND AvsCore_Sources "core/parser/os/win32_string_compat.h")
ENDIF()
IF( MSVC )
# Export definitions in general are not needed on x64 and only cause warnings,
# unfortunately we still must need a .def file for some COM functions.
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
LIST(APPEND AvsCore_Sources "core/avisynth64.def")
else()
LIST(APPEND AvsCore_Sources "core/avisynth.def")
endif()
ENDIF()
IF( MSVC_IDE )
# Ninja, unfortunately, seems to have some issues with using rc.exe
LIST(APPEND AvsCore_Sources "core/avisynth.rc")
ENDIF()
================================================
FILE: avs_core/TargetArch.cmake
================================================
# http://stackoverflow.com/questions/11944060/how-to-detect-target-architecture-using-cmake
# https://github.com/petroules/solar-cmake/blob/master/TargetArch.cmake
# Based on the Qt 5 processor detection code, so should be very accurate
# https://qt.gitorious.org/qt/qtbase/blobs/master/src/corelib/global/qprocessordetection.h
# Currently handles arm (v5, v6, v7), x86 (32/64), ia64, and ppc (32/64)
# Regarding POWER/PowerPC, just as is noted in the Qt source,
# "There are many more known variants/revisions that we do not handle/detect."
set(archdetect_c_code "
#if defined(__arm__) || defined(__TARGET_ARCH_ARM) || defined(_M_ARM) || defined(_M_ARM64) || defined(__aarch64__) || defined(__ARM64__)
#if defined(__ARM64_ARCH_8__) \
|| defined(__aarch64__) \
|| defined(__ARMv8__) \
|| defined(__ARMv8_A__) \
|| defined(_M_ARM64)
#error cmake_ARCH aarch64
#elif defined(__ARM_ARCH_7__) \\
|| defined(__ARM_ARCH_7A__) \\
|| defined(__ARM_ARCH_7R__) \\
|| defined(__ARM_ARCH_7M__) \\
|| (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM-0 >= 7)
#error cmake_ARCH armv7
#elif defined(__ARM_ARCH_6__) \\
|| defined(__ARM_ARCH_6J__) \\
|| defined(__ARM_ARCH_6T2__) \\
|| defined(__ARM_ARCH_6Z__) \\
|| defined(__ARM_ARCH_6K__) \\
|| defined(__ARM_ARCH_6ZK__) \\
|| defined(__ARM_ARCH_6M__) \\
|| (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM-0 >= 6)
#error cmake_ARCH armv6
#elif defined(__ARM_ARCH_5TEJ__) \\
|| (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM-0 >= 5)
#error cmake_ARCH armv5
#else
#error cmake_ARCH arm
#endif
#elif defined(__i386) || defined(__i386__) || defined(_M_IX86)
#error cmake_ARCH i386
#elif defined(__x86_64) || defined(__x86_64__) || defined(__amd64) || defined(_M_X64)
#error cmake_ARCH x86_64
#elif defined(__ia64) || defined(__ia64__) || defined(_M_IA64)
#error cmake_ARCH ia64
#elif defined(__ppc__) || defined(__ppc) || defined(__powerpc__) \\
|| defined(_ARCH_COM) || defined(_ARCH_PWR) || defined(_ARCH_PPC) \\
|| defined(_M_MPPC) || defined(_M_PPC)
#if defined(__ppc64__) || defined(__powerpc64__) || defined(__64BIT__)
#error cmake_ARCH ppc64
#else
#error cmake_ARCH ppc
#endif
#elif defined(__riscv)
#error cmake_ARCH riscv
#elif defined(__sparc_v9__)
#error cmake_ARCH sparc
#elif defined(__mips__)
#error cmake_ARCH mips
#elif defined(__s390x__)
#error cmake_ARCH s390x
#endif
#error cmake_ARCH unknown
")
# Set ppc_support to TRUE before including this file or ppc and ppc64
# will be treated as invalid architectures since they are no longer supported by Apple
function(target_architecture output_var)
if(APPLE AND CMAKE_OSX_ARCHITECTURES)
# On OS X we use CMAKE_OSX_ARCHITECTURES *if* it was set
# First let's normalize the order of the values
# Note that it's not possible to compile PowerPC applications if you are using
# the OS X SDK version 10.6 or later - you'll need 10.4/10.5 for that, so we
# disable it by default
# See this page for more information:
# http://stackoverflow.com/questions/5333490/how-can-we-restore-ppc-ppc64-as-well-as-full-10-4-10-5-sdk-support-to-xcode-4
# Architecture defaults to i386 or ppc on OS X 10.5 and earlier, depending on the CPU type detected at runtime.
# On OS X 10.6+ the default is x86_64 if the CPU supports it, i386 otherwise.
foreach(osx_arch ${CMAKE_OSX_ARCHITECTURES})
if("${osx_arch}" STREQUAL "ppc" AND ppc_support)
set(osx_arch_ppc TRUE)
elseif("${osx_arch}" STREQUAL "i386")
set(osx_arch_i386 TRUE)
elseif("${osx_arch}" STREQUAL "x86_64")
set(osx_arch_x86_64 TRUE)
elseif("${osx_arch}" STREQUAL "ppc64" AND ppc_support)
set(osx_arch_ppc64 TRUE)
elseif("${osx_arch}" STREQUAL "arm64")
set(osx_arch_arm64 TRUE)
else()
message(FATAL_ERROR "Invalid OS X arch name: ${osx_arch}")
endif()
endforeach()
# Now add all the architectures in our normalized order
if(osx_arch_ppc)
list(APPEND ARCH ppc)
endif()
if(osx_arch_i386)
list(APPEND ARCH i386)
endif()
if(osx_arch_x86_64)
list(APPEND ARCH x86_64)
endif()
if(osx_arch_ppc64)
list(APPEND ARCH ppc64)
endif()
if(osx_arch_arm64)
list(APPEND ARCH arm64)
endif()
else()
file(WRITE "${CMAKE_BINARY_DIR}/arch.c" "${archdetect_c_code}")
enable_language(C)
# Detect the architecture in a rather creative way...
# This compiles a small C program which is a series of ifdefs that selects a
# particular #error preprocessor directive whose message string contains the
# target architecture. The program will always fail to compile (both because
# file is not a valid C program, and obviously because of the presence of the
# #error preprocessor directives... but by exploiting the preprocessor in this
# way, we can detect the correct target architecture even when cross-compiling,
# since the program itself never needs to be run (only the compiler/preprocessor)
try_run(
run_result_unused
compile_result_unused
"${CMAKE_BINARY_DIR}"
"${CMAKE_BINARY_DIR}/arch.c"
COMPILE_OUTPUT_VARIABLE ARCH
CMAKE_FLAGS CMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
)
# Parse the architecture name from the compiler output
string(REGEX MATCH "cmake_ARCH ([a-zA-Z0-9_]+)" ARCH "${ARCH}")
# Get rid of the value marker leaving just the architecture name
string(REPLACE "cmake_ARCH " "" ARCH "${ARCH}")
# If we are compiling with an unknown architecture this variable should
# already be set to "unknown" but in the case that it's empty (i.e. due
# to a typo in the code), then set it to unknown
if (NOT ARCH)
set(ARCH unknown)
endif()
endif()
set(${output_var} "${ARCH}" PARENT_SCOPE)
endfunction()
================================================
FILE: avs_core/Version.cmake
================================================
FIND_PACKAGE(Git)
if (EXISTS "${REPO}/.git" AND GIT_FOUND)
EXECUTE_PROCESS(
COMMAND "${GIT}" --git-dir=${REPO}/.git rev-list --count HEAD
OUTPUT_VARIABLE AVS_SEQREV
OUTPUT_STRIP_TRAILING_WHITESPACE
)
EXECUTE_PROCESS(
COMMAND "${GIT}" --git-dir=${REPO}/.git rev-parse --abbrev-ref HEAD
OUTPUT_VARIABLE AVS_BRANCH
OUTPUT_STRIP_TRAILING_WHITESPACE
)
# find the newest created tag, which will hopefully only be relevant to
# release tags (which themselves only apply to the release branches)
EXECUTE_PROCESS(
COMMAND "${GIT}" --git-dir=${REPO}/.git describe --tags --abbrev=0
OUTPUT_VARIABLE AVS_NEWEST_TAG
)
string(STRIP ${AVS_NEWEST_TAG} AVS_NEWEST_TAG)
# count the number of commits since the most recently created tag.
# if an older-than-tag commit has been checked out as HEAD, then this
# will report '0', which shouldn't be a problem because this is entirely
# intended for the purposes of current development and not as an
# arbitrary meter between release tags.
EXECUTE_PROCESS(
COMMAND "${GIT}" --git-dir=${REPO}/.git rev-list --count ${AVS_NEWEST_TAG}..HEAD
OUTPUT_VARIABLE AVS_DEVNEXT_REV
OUTPUT_STRIP_TRAILING_WHITESPACE
)
# date of last git commit to branch
EXECUTE_PROCESS(
COMMAND "${GIT}" --git-dir=${REPO}/.git log -1 HEAD --format=%cd --date=unix
OUTPUT_VARIABLE AVS_DEV_REVDATE
OUTPUT_STRIP_TRAILING_WHITESPACE
)
set(ENV{SOURCE_DATE_EPOCH} ${AVS_DEV_REVDATE})
string(TIMESTAMP AVS_DEV_REVDATE %Y-%m-%d UTC)
unset(ENV{SOURCE_DATE_EPOCH})
# abbreviated git commit hash
EXECUTE_PROCESS(
COMMAND "${GIT}" --git-dir=${REPO}/.git describe --tags
OUTPUT_VARIABLE AVS_DEV_GITHASH
OUTPUT_STRIP_TRAILING_WHITESPACE
)
endif()
CONFIGURE_FILE(${SRC} ${DST} @ONLY)
================================================
FILE: avs_core/avisynth.pc.in
================================================
prefix=@CMAKE_INSTALL_PREFIX@
exec_prefix=@CMAKE_INSTALL_PREFIX@
libdir=@CMAKE_INSTALL_FULL_LIBDIR@
includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@/avisynth
Name: AviSynth+
Description: A powerful nonlinear scripting language for video.
Version: @PROJECT_VERSION@
Libs: -L${libdir} @LIBS@
Libs.private: @SYSLIBS@
Cflags: -I${includedir}
Cflags.private: -DAVS_STATIC_LIB
================================================
FILE: avs_core/avisynth_conf.h.in
================================================
#ifndef _AVS_CONF_H_
#define _AVS_CONF_H_
#include <avs/config.h>
#ifdef AVS_POSIX
#define user_avs_plugindir_configurable "@USER_AVS_PLUGINDIR_LOCATION@"
#define system_avs_plugindir "@CORE_PLUGIN_INSTALL_PATH@/avisynth"
#endif
#endif // _AVS_CONF_H_
================================================
FILE: avs_core/convert/convert.cpp
================================================
// Avisynth v2.5. Copyright 2002-2009 Ben Rudiak-Gould et al.
// http://avisynth.nl
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA, or visit
// http://www.gnu.org/copyleft/gpl.html .
//
// Linking Avisynth statically or dynamically with other modules is making a
// combined work based on Avisynth. Thus, the terms and conditions of the GNU
// General Public License cover the whole combination.
//
// As a special exception, the copyright holders of Avisynth give you
// permission to link Avisynth with independent modules that communicate with
// Avisynth solely through the interfaces defined in avisynth.h, regardless of the license
// terms of these independent modules, and to copy and distribute the
// resulting combined work under terms of your choice, provided that
// every copy of the combined work is accompanied by a complete copy of
// the source code of Avisynth (the version of Avisynth used to produce the
// combined work), being distributed under the terms of the GNU General
// Public License plus this exception. An independent module is a module
// which is not derived from or based on Avisynth, such as 3rd-party filters,
// import and export plugins, or graphical user interfaces.
#include "convert.h"
#include "convert_matrix.h"
#include "convert_helper.h"
#include "convert_bits.h"
#include "convert_planar.h"
#include "convert_rgb.h"
#include <avs/alignment.h>
#include <avs/minmax.h>
#include <avs/config.h>
#include <tuple>
#include <map>
#include <algorithm>
#include <cassert>
#ifdef AVS_WINDOWS
#include <avs/win.h>
#else
#include <avs/posix.h>
#endif
/********************************************************************
***** Declare index of new filters for Avisynth's filter engine *****
********************************************************************/
extern const AVSFunction Convert_filters[] = {
{ "ConvertToRGB", BUILTIN_FUNC_PREFIX, "c[matrix]s[interlaced]b[ChromaInPlacement]s[chromaresample]s[param1]f[param2]f[param3]f[bits]i[quality]b", CreateConvertToAdaptivePackedRGB, (void *)0 },
{ "ConvertToRGB24", BUILTIN_FUNC_PREFIX, "c[matrix]s[interlaced]b[ChromaInPlacement]s[chromaresample]s[param1]f[param2]f[param3]f[bits]i[quality]b", CreateConvertToPackedRGB, (void *)24 },
{ "ConvertToRGB32", BUILTIN_FUNC_PREFIX, "c[matrix]s[interlaced]b[ChromaInPlacement]s[chromaresample]s[param1]f[param2]f[param3]f[bits]i[quality]b", CreateConvertToPackedRGB, (void *)32 },
{ "ConvertToRGB48", BUILTIN_FUNC_PREFIX, "c[matrix]s[interlaced]b[ChromaInPlacement]s[chromaresample]s[param1]f[param2]f[param3]f[bits]i[quality]b", CreateConvertToPackedRGB, (void *)48 },
{ "ConvertToRGB64", BUILTIN_FUNC_PREFIX, "c[matrix]s[interlaced]b[ChromaInPlacement]s[chromaresample]s[param1]f[param2]f[param3]f[bits]i[quality]b", CreateConvertToPackedRGB, (void *)64 },
{ "ConvertToPlanarRGB", BUILTIN_FUNC_PREFIX, "c[matrix]s[interlaced]b[ChromaInPlacement]s[chromaresample]s[param1]f[param2]f[param3]f[bits]i[quality]b", CreateConvertToRGB, (void *)-1 },
{ "ConvertToPlanarRGBA", BUILTIN_FUNC_PREFIX, "c[matrix]s[interlaced]b[ChromaInPlacement]s[chromaresample]s[param1]f[param2]f[param3]f[bits]i[quality]b", CreateConvertToRGB, (void *)-2 },
{ "ConvertToY8", BUILTIN_FUNC_PREFIX, "c[matrix]s[bits]i[quality]b", ConvertToPlanarGeneric::CreateY, (void*)0 }, // user_data == 0 -> only 8 bit sources
{ "ConvertToYV12", BUILTIN_FUNC_PREFIX, "c[interlaced]b[matrix]s[ChromaInPlacement]s[chromaresample]s[ChromaOutPlacement]s[param1]f[param2]f[param3]f[bits]i[quality]b", ConvertToPlanarGeneric::CreateYUV420, (void*)0 },
{ "ConvertToYV24", BUILTIN_FUNC_PREFIX, "c[interlaced]b[matrix]s[ChromaInPlacement]s[chromaresample]s[param1]f[param2]f[param3]f[bits]i[quality]b", ConvertToPlanarGeneric::CreateYUV444, (void*)0},
{ "ConvertToYV16", BUILTIN_FUNC_PREFIX, "c[interlaced]b[matrix]s[ChromaInPlacement]s[chromaresample]s[ChromaOutPlacement]s[param1]f[param2]f[param3]f[bits]i[quality]b", ConvertToPlanarGeneric::CreateYUV422, (void*)0},
{ "ConvertToYV411", BUILTIN_FUNC_PREFIX, "c[interlaced]b[matrix]s[ChromaInPlacement]s[chromaresample]s[param1]f[param2]f[param3]f[bits]i[quality]b", ConvertToPlanarGeneric::CreateYV411, (void*)0},
{ "ConvertToYUY2", BUILTIN_FUNC_PREFIX, "c[interlaced]b[matrix]s[ChromaInPlacement]s[chromaresample]s[ChromaOutPlacement]s[param1]f[param2]f[param3]f[bits]i[quality]b", ConvertToPlanarGeneric::CreateConvertToYUY2 },
{ "ConvertBackToYUY2", BUILTIN_FUNC_PREFIX, "c[matrix]s", ConvertToPlanarGeneric::CreateConvertBackToYUY2 },
{ "ConvertToY", BUILTIN_FUNC_PREFIX, "c[matrix]s[bits]i[quality]b", ConvertToPlanarGeneric::CreateY, (void*)1 }, // user_data == 1 -> any bit depth sources
{ "ConvertToYUV411", BUILTIN_FUNC_PREFIX, "c[interlaced]b[matrix]s[ChromaInPlacement]s[chromaresample]s[param1]f[param2]f[param3]f[bits]i[quality]b", ConvertToPlanarGeneric::CreateYV411, (void*)1}, // alias for ConvertToYV411, 8 bit check later
{ "ConvertToYUV420", BUILTIN_FUNC_PREFIX, "c[interlaced]b[matrix]s[ChromaInPlacement]s[chromaresample]s[ChromaOutPlacement]s[param1]f[param2]f[param3]f[bits]i[quality]b", ConvertToPlanarGeneric::CreateYUV420, (void*)1},
{ "ConvertToYUV422", BUILTIN_FUNC_PREFIX, "c[interlaced]b[matrix]s[ChromaInPlacement]s[chromaresample]s[ChromaOutPlacement]s[param1]f[param2]f[param3]f[bits]i[quality]b", ConvertToPlanarGeneric::CreateYUV422, (void*)1},
{ "ConvertToYUV444", BUILTIN_FUNC_PREFIX, "c[interlaced]b[matrix]s[ChromaInPlacement]s[chromaresample]s[param1]f[param2]f[param3]f[bits]i[quality]b", ConvertToPlanarGeneric::CreateYUV444, (void*)1},
{ "ConvertToYUVA420", BUILTIN_FUNC_PREFIX, "c[interlaced]b[matrix]s[ChromaInPlacement]s[chromaresample]s[ChromaOutPlacement]s[param1]f[param2]f[param3]f[bits]i[quality]b", ConvertToPlanarGeneric::CreateYUV420, (void*)2},
{ "ConvertToYUVA422", BUILTIN_FUNC_PREFIX, "c[interlaced]b[matrix]s[ChromaInPlacement]s[chromaresample]s[ChromaOutPlacement]s[param1]f[param2]f[param3]f[bits]i[quality]b", ConvertToPlanarGeneric::CreateYUV422, (void*)2},
{ "ConvertToYUVA444", BUILTIN_FUNC_PREFIX, "c[interlaced]b[matrix]s[ChromaInPlacement]s[chromaresample]s[param1]f[param2]f[param3]f[bits]i[quality]b", ConvertToPlanarGeneric::CreateYUV444, (void*)2},
{ "ConvertTo8bit", BUILTIN_FUNC_PREFIX, "c[bits]i[truerange]b[dither]i[dither_bits]i[fulls]b[fulld]b", ConvertBits::Create, (void *)8 },
{ "ConvertTo16bit", BUILTIN_FUNC_PREFIX, "c[bits]i[truerange]b[dither]i[dither_bits]i[fulls]b[fulld]b", ConvertBits::Create, (void *)16 },
{ "ConvertToFloat", BUILTIN_FUNC_PREFIX, "c[bits]i[truerange]b[dither]i[dither_bits]i[fulls]b[fulld]b", ConvertBits::Create, (void *)32 },
{ "ConvertBits", BUILTIN_FUNC_PREFIX, "c[bits]i[truerange]b[dither]i[dither_bits]i[fulls]b[fulld]b", ConvertBits::Create, (void *)0 },
{ "AddAlphaPlane", BUILTIN_FUNC_PREFIX, "c[mask].[opacity]f", AddAlphaPlane::Create},
{ "RemoveAlphaPlane", BUILTIN_FUNC_PREFIX, "c", RemoveAlphaPlane::Create},
{ 0 }
};
/****************************************
******* Convert to RGB / RGBA ******
***************************************/
// 0 1 2 3 4 5 6 7 8 9
// c[matrix]s[interlaced]b[ChromaInPlacement]s[chromaresample]s[param1]f[param2]f[param3]f[bits]i[quality]b
// Special syntax: adaptive packed target format: ConvertToRGB
AVSValue __cdecl CreateConvertToAdaptivePackedRGB(AVSValue args, void* user_data, IScriptEnvironment* env)
{
const PClip clip = args[0].AsClip();
const VideoInfo& vi = clip->GetVideoInfo();
// bits= if given must be 8 or 16 (only valid packed RGB channel depths)
int target_bits_per_channel;
if (args[8].Defined()) {
target_bits_per_channel = args[8].AsInt();
if (target_bits_per_channel != 8 && target_bits_per_channel != 16)
env->ThrowError("ConvertToRGB: bits must be 8 or 16 if specified. "
"Use ConvertToPlanarRGB for other bit depths.");
}
else {
const int src_bits = vi.BitsPerComponent();
if (src_bits != 8 && src_bits != 16)
env->ThrowError("ConvertToRGB: source bit depth must be 8 or 16. "
"Use ConvertToPlanarRGB or ConvertBits(8)/ConvertBits(16) first.");
target_bits_per_channel = src_bits;
}
// Decide target format based on source type and alpha capability (and the optional bits= override):
// - YUV/YUY2 source: always alpha-capable (RGB32 or RGB64)
// - RGB-like source: preserve alpha capability of source format
// RGB32/RGB64/PlanarRGBA -> RGB32/RGB64 (with alpha)
// RGB24/RGB48/PlanarRGB -> RGB24/RGB48 (without alpha)
const bool hasAlpha = vi.IsYUV() || vi.IsYUVA() // YUV always gets alpha target
|| vi.IsRGB32() || vi.IsRGB64()
|| vi.IsPlanarRGBA();
// 8-bit: RGB24 or RGB32, 16-bit: RGB48 or RGB64
const intptr_t target_rgbtype = (target_bits_per_channel == 8)
? (hasAlpha ? 32 : 24)
: (hasAlpha ? 64 : 48);
return CreateConvertToPackedRGB(args, reinterpret_cast<void*>(target_rgbtype), env);
}
// Registration names with implied fixed bit depth:
// ConvertToRGB24 -> 24-bit only (bits must be 24 if specified)
// ConvertToRGB32 -> 32-bit only (bits must be 32 if specified)
// ConvertToRGB48 -> 48-bit only (bits must be 48 if specified)
// ConvertToRGB64 -> 64-bit only (bits must be 64 if specified)
AVSValue __cdecl CreateConvertToPackedRGB(AVSValue args, void* user_data, IScriptEnvironment* env)
{
const int target_bits = (int)reinterpret_cast<intptr_t>(user_data); // 24, 32, 48, 64
const int target_bytes = target_bits / 8; // 3, 4, 6, 8
const int bits_per_channel = (target_bytes <= 4) ? 8 : 16; // RGB24/32=8bit, RGB48/64=16bit
// bits= must match the implied depth if specified
if (args[8].Defined() && args[8].AsInt() != bits_per_channel)
env->ThrowError("ConvertToRGB%d: bits must be %d if specified.",
target_bits, bits_per_channel);
// Rebuild args with bits forced to the correct value
AVSValue new_args[10] = {
args[0], args[1], args[2], args[3], args[4],
args[5], args[6], args[7],
AVSValue(bits_per_channel), // bits forced
args[9] // quality
};
AVSValue new_args_val(new_args, 10);
return CreateConvertToRGB(new_args_val, user_data, env);
}
// Dispatch hub for all ConvertToRGB variants.
// Since 3.7.6 YUY2 is pre-converted to YV16 before dispatch, so no class is needed.
// Called from ConvertToRGB24/32/48/64 and ConvertToPlanarRGB(A) registrations,
// and from any internal env->Invoke("ConvertToRGB",...) calls.
// All ToRGB variants has bits and quality parameters, bit the quality=true and on-the-fly bit depth
// conversion logic is only implemented for YUV->PlanarRGB path.
// Note: when you add new parameters, find all places env->Invoke("ConvertToRGB",...)
// and check parameter count!
AVSValue __cdecl CreateConvertToRGB(AVSValue args, void* user_data, IScriptEnvironment* env)
{
PClip clip = args[0].AsClip();
VideoInfo vi = clip->GetVideoInfo();
// Before any conversions, convert YUY2 to YV16
if (vi.IsYUY2()) {
clip = new ConvertYUY2ToYV16_or_Y(clip, false /*to_y*/, env);
vi = clip->GetVideoInfo();
}
const char* const matrix_name = args[1].AsString(0);
const bool haveOpts = args[3].Defined() || args[4].Defined();
// common Create for all CreateRGB24/32/48/64/Planar(RGBP:-1, RGPAP:-2) using user_data
int target_rgbtype = (int)reinterpret_cast<intptr_t>(user_data);
// can be overridden later
// -1,-2: Planar RGB(A)
// 24,32,48,64: RGB24/32/48/64
const bool original_target_is_packed = target_rgbtype > 0; // 24,32,48,64
const int target_bits_per_pixel = args[8].AsInt(vi.BitsPerComponent());
// for legacy packed formats it's 8 for target_rgbtype==24,32, and 16 for target_rgbtype==48,64
// for planar RGB(A) target, it can be any bit depth supported by the source and the conversion logic (8,10,12,14,16,32)
const bool quality = args[9].AsBool(false); // yuv-planarrgb float workflow
// planar YUV-like source
if (vi.IsPlanar() && (vi.IsYUV() || vi.IsYUVA())) {
// here we keep the bit depth, later, the RGB conversion will take target_bits_per_pixel into account
AVSValue new_args[10] = { clip, args[2], args[1], args[3], args[4], args[5], args[6], args[7], vi.BitsPerComponent(), quality };
// conversion to planar or packed RGB is always from 444
// clip, interlaced, matrix, chromainplacement, chromaresample, param1, param2, param3, bits, quality Check for ConvertToYUV444 param list!!!! Count must match!
clip = ConvertToPlanarGeneric::CreateYUV444(AVSValue(new_args, 10), (void*)1, env).AsClip(); // (void *)1: not restricted to 8 bits
// planar RGB(A) target or packed needing intermediate: set finalBitdepth if conversion needed
// also: when quality==true, we need to use the float workflow which requires a planar RGB(A) intermediate
if (target_rgbtype > 0) {
// packed RGB target: redirect to planar rgb(a) intermediate if bit-depth mismatch or quality mode
const bool hasAlpha = (target_rgbtype == 32 || target_rgbtype == 64);
if (vi.BitsPerComponent() != target_bits_per_pixel || quality)
target_rgbtype = hasAlpha ? -2 : -1;
}
if (target_rgbtype == 48 || target_rgbtype == 64) {
// Unlike parameter-less RGB24/32, 16 bit packed format have no direct conversions at all.
// 1.) YUV->PlanarRGB first (recursive call),
// 2.) then fall through to the planar RGB->packed RGB path below for the final repack
// So instead of unoptimized code of YUV(A)444P16->RGB48/64 we convert to PlanarRGB(A) then to RGB48/64
// Also: when quality=true or bit-depth conversion is needed, the planar RGB intermediate is required anyway
AVSValue new_args2[10] = { clip, args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]/*bits*/, args[9]/*quality*/ };
const intptr_t target_planar_rgb_type =
(target_rgbtype == 24 || target_rgbtype == 48) ? -1 : // no-alpha target: skip alpha even if source has it
vi.IsYUVA() ? -2 : // alpha target + alpha source: preserve it
-1; // alpha target + no alpha source: no alpha to copy
// Note: target_rgbtype == 24 is currently never reached here (24/32 use direct conversion path),
// but kept for when 24/32-bit packed is also redirected to the planar intermediate path in the future.
clip = CreateConvertToRGB(AVSValue(new_args2, 10), (void*)target_planar_rgb_type, env).AsClip();
vi = clip->GetVideoInfo(); // must update vi for fall-through
// Fall through to planar RGB source path below to do the final pack
// reuses the same PlanarRGBtoPackedRGB logic.
}
else {
// Direct YUV444->RGB conversion path
bool bitdepthConverted = false;
const int finalBitdepth = (vi.BitsPerComponent() != target_bits_per_pixel) ?
target_bits_per_pixel : -1; // -1 means: no need to convert
// Optional bit-depth conversion in PackedRGBtoPlanarRGB.
// Note: all formats are bit-depth-converted if finalBitdepth != -1
// (historically there were cases and bit-depths which were not implemented to have in-line bit-depth conversion)
// pass -1 as finalBitdepth, signing that no bit-depth conversion required
const int rgbtype_param = (target_rgbtype == -1 || target_rgbtype == -2) ? target_rgbtype : // planar RGB(A)
target_rgbtype == 24 ? 3 : 4; // RGB24 or RGB32 "pixel_step" parameter for legacy direct YUV444->RGB24/32 conversion
clip = new ConvertYUV444ToRGB(clip, matrix_name, rgbtype_param,
finalBitdepth, // -1 if no conversion needed
quality, /*ref*/bitdepthConverted, env);
vi = clip->GetVideoInfo();
// When direct YUV-RGB24/32 conversion happens, the result is not planar!
const bool needConvertFinalBitdepth = finalBitdepth != -1;
if (needConvertFinalBitdepth && !bitdepthConverted) {
AVSValue new_args[] = { clip, finalBitdepth };
clip = env->Invoke("ConvertBits", AVSValue(new_args, 2)).AsClip();
vi = clip->GetVideoInfo();
}
// We can still have RGB24/32 here, YV24->24/32 is still valid
if (original_target_is_packed && vi.IsPlanar()) {
// from any planar rgb(a) -> rgb24/32/48/64
// source here is always a 8/16bit planar RGB(A), but we used
// planar intermediate.
// finally it has to be converted to RGB24/32/48/64
clip = new PlanarRGBtoPackedRGB(clip, target_rgbtype == -2);
vi = clip->GetVideoInfo();
}
return clip;
}
} // end of YUV->RGB path
else {
if (haveOpts)
env->ThrowError("ConvertToRGB: ChromaPlacement and ChromaResample options are not supported.");
}
// This part can fallthrough from the YUV path when target is packed RGB
// RGB->RGB paths (planar or packed) do not support ChromaPlacement and ChromaResample options, as they are meaningless for RGB formats.
// Planar RGB(A) source
if (vi.IsPlanarRGB() || vi.IsPlanarRGBA())
{
// Handle alpha channel add/remove for planar-to-planar
if (target_rgbtype < 0) {
if (vi.IsPlanarRGB() && target_rgbtype == -2)
clip = new AddAlphaPlane(clip, nullptr, 0.0f, false, env);
else if (vi.IsPlanarRGBA() && target_rgbtype == -1)
clip = new RemoveAlphaPlane(clip, env);
}
// Convert bit depth if needed
if (vi.BitsPerComponent() != target_bits_per_pixel) {
AVSValue args[] = { clip, target_bits_per_pixel };
// plain Invoke instead of "new ConvertBits", this detects and keeps source and target ranges
clip = env->Invoke("ConvertBits", AVSValue(args, 2)).AsClip();
}
// Convert planar to packed
if (target_rgbtype >= 0) {
bool hasAlpha = (target_rgbtype == 32 || target_rgbtype == 64);
clip = new PlanarRGBtoPackedRGB(clip, hasAlpha);
}
return clip;
} // Planar RGB(A) source
// YUV source is done
// Planar RGB(A) source is done
// Now remains packed RGB source
// Conversions from packed RGB
// Packed to Packed
if (target_rgbtype >= 0) {
// target bit depth (8-bit for 24/32, 16-bit for 48/64)
// target_bits_per_pixel is same as target_rgbtype
if (vi.BitsPerComponent() != target_bits_per_pixel) {
AVSValue args[] = { clip, target_bits_per_pixel };
// using Invoke instead of new ConvertBits, this detects and keeps source and target ranges
clip = env->Invoke("ConvertBits", AVSValue(args, 2)).AsClip();
vi = clip->GetVideoInfo();
}
bool target_has_alpha = (target_rgbtype == 32 || target_rgbtype == 64);
bool source_has_alpha = (vi.IsRGB32() || vi.IsRGB64());
// between packed RGB types, alpha add/remove
if (target_has_alpha && !source_has_alpha)
return new RGBtoRGBA(clip);
if (!target_has_alpha && source_has_alpha)
return new RGBAtoRGB(clip);
return clip;
}
// Packed to Planar
// RGB24/32/48/64 ->
const bool isSrcRGBA = vi.IsRGB32() || vi.IsRGB64();
const bool isTargetRGBA = target_rgbtype == -2; // -2 planar RGBA, -1 planar RGB
clip = new PackedRGBtoPlanarRGB(clip, isSrcRGBA, isTargetRGBA);
vi = clip->GetVideoInfo(); // new format
// no embedded bitdepth conversion in PackedRGBtoPlanarRGB
if (target_bits_per_pixel != vi.BitsPerComponent()) {
AVSValue new_args[2] = { clip, target_bits_per_pixel };
clip = env->Invoke("ConvertBits", AVSValue(new_args, 2)).AsClip();
vi = clip->GetVideoInfo(); // new format
}
return clip;
}
AVSValue AddAlphaPlane::Create(AVSValue args, void*, IScriptEnvironment* env)
{
bool isMaskDefined = args[1].Defined();
bool isOpacityDefined = args[2].Defined();
bool maskIsClip = false;
// if mask is not defined and videoformat has Alpha then we return
if (isMaskDefined && !args[1].IsClip() && !args[1].IsFloat())
env->ThrowError("AddAlphaPlane: mask parameter should be clip or number");
if (isOpacityDefined && !args[2].IsFloat())
env->ThrowError("AddAlphaPlane: opacity parameter should be a number");
if (isMaskDefined && isOpacityDefined)
env->ThrowError("AddAlphaPlane: cannot specify both mask and opacity parameters");
const VideoInfo& vi = args[0].AsClip()->GetVideoInfo();
if (!isMaskDefined && !isOpacityDefined && (vi.IsPlanarRGBA() || vi.IsYUVA() || vi.IsRGB32() || vi.IsRGB64()))
return args[0].AsClip();
PClip alphaClip = nullptr;
if (isMaskDefined && args[1].IsClip()) {
const VideoInfo& viAlphaClip = args[1].AsClip()->GetVideoInfo();
maskIsClip = true;
if (viAlphaClip.BitsPerComponent() != vi.BitsPerComponent())
env->ThrowError("AddAlphaPlane: alpha clip is of different bit depth");
if (viAlphaClip.width != vi.width || viAlphaClip.height != vi.height)
env->ThrowError("AddAlphaPlane: alpha clip is of different size");
if (viAlphaClip.IsY())
alphaClip = args[1].AsClip();
else if (viAlphaClip.NumComponents() == 4) {
AVSValue new_args[1] = { args[1].AsClip() };
alphaClip = env->Invoke("ExtractA", AVSValue(new_args, 1)).AsClip();
}
else {
env->ThrowError("AddAlphaPlane: alpha clip should be greyscale or should have alpha plane");
}
// alphaClip is always greyscale here
}
float maskAsFloat = -1.0f;
if (!maskIsClip) {
if (isOpacityDefined) {
// Handle opacity parameter (0.0 to 1.0)
float opacity = args[2].AsFloatf(1.0f);
if (opacity < 0.0f || opacity > 1.0f)
env->ThrowError("AddAlphaPlane: opacity must be between 0.0 and 1.0");
if (vi.BitsPerComponent() <= 16) {
int max_pixel_value = (1 << vi.BitsPerComponent()) - 1;
maskAsFloat = opacity * max_pixel_value;
}
else {
maskAsFloat = opacity;
}
}
else {
// Handle mask parameter (direct value)
maskAsFloat = (float)args[1].AsFloat(-1.0f);
}
}
if (vi.IsRGB24()) {
AVSValue new_args[1] = { args[0].AsClip() };
PClip child = env->Invoke("ConvertToRGB32", AVSValue(new_args, 1)).AsClip();
return new AddAlphaPlane(child, alphaClip, maskAsFloat, isMaskDefined || isOpacityDefined, env);
}
else if (vi.IsRGB48()) {
AVSValue new_args[1] = { args[0].AsClip() };
PClip child = env->Invoke("ConvertToRGB64", AVSValue(new_args, 1)).AsClip();
return new AddAlphaPlane(child, alphaClip, maskAsFloat, isMaskDefined || isOpacityDefined, env);
}
return new AddAlphaPlane(args[0].AsClip(), alphaClip, maskAsFloat, isMaskDefined || isOpacityDefined, env);
}
AddAlphaPlane::AddAlphaPlane(PClip _child, PClip _alphaClip, float _mask_f, bool isMaskDefined, IScriptEnvironment* env)
: GenericVideoFilter(_child), alphaClip(_alphaClip)
, mask(0), mask_f(0.0f), pixelsize(0), bits_per_pixel(0)
{
if(vi.IsYUY2())
env->ThrowError("AddAlphaPlane: YUY2 is not allowed");
if(vi.IsY())
env->ThrowError("AddAlphaPlane: greyscale source is not allowed");
if(vi.IsYUV() && !vi.Is420() && !vi.Is422() && !vi.Is444()) // e.g. 410
env->ThrowError("AddAlphaPlane: YUV format not supported, must be 420, 422 or 444");
if(!vi.IsYUV() && !vi.IsYUVA() && !vi.IsRGB())
env->ThrowError("AddAlphaPlane: format not supported");
pixelsize = vi.ComponentSize();
bits_per_pixel = vi.BitsPerComponent();
if (vi.IsYUV()) {
int pixel_type = vi.pixel_type;
if (vi.IsYV12())
pixel_type = VideoInfo::CS_YV12;
int new_pixel_type = (pixel_type & ~VideoInfo::CS_YUV) | VideoInfo::CS_YUVA;
vi.pixel_type = new_pixel_type;
} else if(vi.IsPlanarRGB()) {
int pixel_type = vi.pixel_type;
int new_pixel_type = (pixel_type & ~VideoInfo::CS_RGB_TYPE) | VideoInfo::CS_RGBA_TYPE;
vi.pixel_type = new_pixel_type;
}
// RGB24 and RGB48 already converted to 32/64
// RGB32, RGB64, YUVA and RGBA: no change
// mask parameter. If none->max opacity
if (!alphaClip) {
int max_pixel_value = (1 << bits_per_pixel) - 1; // n/a for float
if (!isMaskDefined) {
mask_f = 1.0f;
mask = max_pixel_value;
}
else {
mask_f = _mask_f;
mask = (mask_f < 0) ? 0 : (mask_f > max_pixel_value) ? max_pixel_value : (int)(mask_f + 0.5f);
mask = clamp(mask, 0, max_pixel_value);
// no clamp for float
}
}
}
PVideoFrame AddAlphaPlane::GetFrame(int n, IScriptEnvironment* env)
{
PVideoFrame src = child->GetFrame(n, env);
PVideoFrame dst = env->NewVideoFrameP(vi, &src);
if(vi.IsPlanar())
{
int planes_y[4] = { PLANAR_Y, PLANAR_U, PLANAR_V, PLANAR_A };
int planes_r[4] = { PLANAR_G, PLANAR_B, PLANAR_R, PLANAR_A };
int *planes = (vi.IsYUV() || vi.IsYUVA()) ? planes_y : planes_r;
// copy existing 3 planes
for (int p = 0; p < 3; ++p) {
const int plane = planes[p];
env->BitBlt(dst->GetWritePtr(plane), dst->GetPitch(plane), src->GetReadPtr(plane),
src->GetPitch(plane), src->GetRowSize(plane), src->GetHeight(plane));
}
} else {
// Packed RGB, already converted to RGB32 or RGB64
env->BitBlt(dst->GetWritePtr(), dst->GetPitch(), src->GetReadPtr(),
src->GetPitch(), src->GetRowSize(), src->GetHeight());
}
if (vi.IsPlanarRGBA() || vi.IsYUVA()) {
if (alphaClip) {
PVideoFrame srcAlpha = alphaClip->GetFrame(n, env);
env->BitBlt(dst->GetWritePtr(PLANAR_A), dst->GetPitch(PLANAR_A), srcAlpha->GetReadPtr(PLANAR_Y),
srcAlpha->GetPitch(PLANAR_Y), srcAlpha->GetRowSize(PLANAR_Y), srcAlpha->GetHeight(PLANAR_Y));
}
else {
// default constant
const int rowsizeA = dst->GetRowSize(PLANAR_A);
const int dst_pitchA = dst->GetPitch(PLANAR_A);
BYTE* dstp_a = dst->GetWritePtr(PLANAR_A);
const int heightA = dst->GetHeight(PLANAR_A);
switch (vi.ComponentSize())
{
case 1:
fill_plane<BYTE>(dstp_a, heightA, rowsizeA, dst_pitchA, mask);
break;
case 2:
fill_plane<uint16_t>(dstp_a, heightA, rowsizeA, dst_pitchA, mask);
break;
case 4:
fill_plane<float>(dstp_a, heightA, rowsizeA, dst_pitchA, mask_f);
break;
}
}
return dst;
}
// RGB32 and RGB64
BYTE* pf = dst->GetWritePtr();
int pitch = dst->GetPitch();
int rowsize = dst->GetRowSize();
int height = dst->GetHeight();
int width = vi.width;
if (alphaClip) {
// fill by alpha clip already converted to grey-only
PVideoFrame srcAlpha = alphaClip->GetFrame(n, env);
const BYTE* srcp_a = srcAlpha->GetReadPtr(PLANAR_Y);
size_t pitch_a = srcAlpha->GetPitch(PLANAR_Y);
pf += pitch * (vi.height - 1); // start from bottom: packed RGB is upside down
if (vi.IsRGB32()) {
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x ++) {
pf[x*4+3] = srcp_a[x];
}
pf -= pitch; // packed RGB is upside down
srcp_a += pitch_a;
}
}
else if (vi.IsRGB64()) {
rowsize /= sizeof(uint16_t);
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x ++) {
reinterpret_cast<uint16_t *>(pf)[x*4+3] = reinterpret_cast<const uint16_t *>(srcp_a)[x];
}
pf -= pitch; // packed RGB is upside down
srcp_a += pitch_a;
}
}
}
else {
// fill with constant
if (vi.IsRGB32()) {
for (int y = 0; y < height; y++) {
for (int x = 3; x < rowsize; x += 4) {
pf[x] = mask;
}
pf += pitch;
}
}
else if (vi.IsRGB64()) {
rowsize /= sizeof(uint16_t);
for (int y = 0; y < height; y++) {
for (int x = 3; x < rowsize; x += 4) {
reinterpret_cast<uint16_t *>(pf)[x] = mask;
}
pf += pitch;
}
}
}
return dst;
}
AVSValue RemoveAlphaPlane::Create(AVSValue args, void*, IScriptEnvironment* env)
{
// if videoformat has no Alpha then we return
const VideoInfo& vi = args[0].AsClip()->GetVideoInfo();
if(vi.IsPlanar() && (vi.IsYUV() || vi.IsPlanarRGB())) // planar and no alpha
return args[0].AsClip();
if (vi.IsYUY2()) // YUY2: no alpha
return args[0].AsClip();
if(vi.IsRGB24() || vi.IsRGB48()) // packed RGB and no alpha
return args[0].AsClip();
if (vi.IsRGB32()) {
AVSValue new_args[1] = { args[0].AsClip() };
return env->Invoke("ConvertToRGB24", AVSValue(new_args, 1)).AsClip();
}
if (vi.IsRGB64()) {
AVSValue new_args[1] = { args[0].AsClip() };
return env->Invoke("ConvertToRGB48", AVSValue(new_args, 1)).AsClip();
}
return new RemoveAlphaPlane(args[0].AsClip(), env);
}
RemoveAlphaPlane::RemoveAlphaPlane(PClip _child, IScriptEnvironment* env)
: GenericVideoFilter(_child)
{
if(vi.IsYUY2())
env->ThrowError("RemoveAlphaPlane: YUY2 is not allowed");
if(vi.IsY())
env->ThrowError("RemoveAlphaPlane: greyscale source is not allowed");
if (vi.IsYUVA()) {
int pixel_type = vi.pixel_type;
int new_pixel_type = (pixel_type & ~VideoInfo::CS_YUVA) | VideoInfo::CS_YUV;
vi.pixel_type = new_pixel_type;
} else if(vi.IsPlanarRGBA()) {
int pixel_type = vi.pixel_type;
int new_pixel_type = (pixel_type & ~VideoInfo::CS_RGBA_TYPE) | VideoInfo::CS_RGB_TYPE;
vi.pixel_type = new_pixel_type;
}
}
PVideoFrame RemoveAlphaPlane::GetFrame(int n, IScriptEnvironment* env)
{
PVideoFrame src = child->GetFrame(n, env);
// Packed RGB: already handled in ::Create through Invoke 32->24 or 64->48 conversion
// only planar here
int planes_y[4] = { PLANAR_Y, PLANAR_U, PLANAR_V, PLANAR_A };
int planes_r[4] = { PLANAR_G, PLANAR_B, PLANAR_R, PLANAR_A };
int *planes = (vi.IsYUV() || vi.IsYUVA()) ? planes_y : planes_r;
// Abuse Subframe to snatch the YUV/GBR planes
return env->SubframePlanar(src, 0, src->GetPitch(planes[0]), src->GetRowSize(planes[0]), src->GetHeight(planes[0]), 0, 0, src->GetPitch(planes[1]));
#if 0
// BitBlt version. Kept for reference
PVideoFrame dst = env->NewVideoFrameP(vi, &src);
// copy 3 planes w/o alpha
for (int p = 0; p < 3; ++p) {
const int plane = planes[p];
env->BitBlt(dst->GetWritePtr(plane), dst->GetPitch(plane), src->GetReadPtr(plane),
src->GetPitch(plane), src->GetRowSize(plane), src->GetHeight(plane));
}
return dst;
#endif
}
================================================
FILE: avs_core/convert/convert.h
================================================
// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.
// http://avisynth.nl
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA, or visit
// http://www.gnu.org/copyleft/gpl.html .
//
// Linking Avisynth statically or dynamically with other modules is making a
// combined work based on Avisynth. Thus, the terms and conditions of the GNU
// General Public License cover the whole combination.
//
// As a special exception, the copyright holders of Avisynth give you
// permission to link Avisynth with independent modules that communicate with
// Avisynth solely through the interfaces defined in avisynth.h, regardless of the license
// terms of these independent modules, and to copy and distribute the
// resulting combined work under terms of your choice, provided that
// every copy of the combined work is accompanied by a complete copy of
// the source code of Avisynth (the version of Avisynth used to produce the
// combined work), being distributed under the terms of the GNU General
// Public License plus this exception. An independent module is a module
// which is not derived from or based on Avisynth, such as 3rd-party filters,
// import and export plugins, or graphical user interfaces.
#ifndef __Convert_H__
#define __Convert_H__
#include <avisynth.h>
AVSValue __cdecl CreateConvertToAdaptivePackedRGB(AVSValue args, void* user_data, IScriptEnvironment* env);
AVSValue __cdecl CreateConvertToPackedRGB(AVSValue args, void* user_data, IScriptEnvironment* env);
AVSValue __cdecl CreateConvertToRGB(AVSValue args, void* user_data, IScriptEnvironment* env);
#endif // __Convert_H__
================================================
FILE: avs_core/convert/convert_audio.cpp
================================================
// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.
// http://avisynth.nl
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA, or visit
// http://www.gnu.org/copyleft/gpl.html .
//
// Linking Avisynth statically or dynamically with other modules is making a
// combined work based on Avisynth. Thus, the terms and conditions of the GNU
// General Public License cover the whole combination.
//
// As a special exception, the copyright holders of Avisynth give you
// permission to link Avisynth with independent modules that communicate with
// Avisynth solely through the interfaces defined in avisynth.h, regardless of the license
// terms of these independent modules, and to copy and distribute the
// resulting combined work under terms of your choice, provided that
// every copy of the combined work is accompanied by a complete copy of
// the source code of Avisynth (the version of Avisynth used to produce the
// combined work), being distributed under the terms of the GNU General
// Public License plus this exception. An independent module is a module
// which is not derived from or based on Avisynth, such as 3rd-party filters,
// import and export plugins, or graphical user interfaces.
// ConvertAudio classes
// Copyright (c) Klaus Post 2001 - 2004
// Copyright (c) Ian Brabham 2005
// Copyright (c) 2020 Xinyue Lu
// Copyright (c) 2021 pinterf
#include <avisynth.h>
#include <avs/alignment.h>
#include "convert_audio.h"
#if defined(AVS_BSD) || defined(AVS_MACOS)
#include <stdlib.h>
#else
#include <malloc.h>
#endif
// There are two type parameters. Acceptable sample types and a prefered sample type.
// If the current clip is already one of the defined types in sampletype, this will be returned.
// If not, the current clip will be converted to the prefered type.
PClip ConvertAudio::Create(PClip clip, int sample_type, int prefered_type) {
if ((!clip->GetVideoInfo().HasAudio()) || clip->GetVideoInfo().SampleType() & (sample_type | prefered_type)) {
// Sample type is already ok!
return clip;
} else
return new ConvertAudio(clip, prefered_type);
}
int __stdcall ConvertAudio::SetCacheHints(int cachehints, int frame_range) {
// We do pass cache requests upwards, to the next filter.
return child->SetCacheHints(cachehints, frame_range);
}
ConvertAudio::ConvertAudio(PClip _clip, int _sample_type)
: GenericVideoFilter(_clip) {
dst_format = _sample_type;
src_format = vi.SampleType();
// Set up convertion matrix
src_bps = vi.BytesPerChannelSample(); // Store old size
vi.sample_type = dst_format;
tempbuffer_size = 0;
#define PAIR(src, dst) ((src << 16) | dst)
switch(PAIR(src_format, dst_format)) {
case PAIR(SAMPLE_INT32, SAMPLE_INT16): convert_c = convert32To16; break;
case PAIR(SAMPLE_INT16, SAMPLE_INT32): convert_c = convert16To32; break;
case PAIR(SAMPLE_INT32, SAMPLE_INT8 ): convert_c = convert32To8; break;
case PAIR(SAMPLE_INT8 , SAMPLE_INT32): convert_c = convert8To32; break;
case PAIR(SAMPLE_INT16, SAMPLE_INT8 ): convert_c = convert16To8; break;
case PAIR(SAMPLE_INT8 , SAMPLE_INT16): convert_c = convert8To16; break;
case PAIR(SAMPLE_FLOAT, SAMPLE_INT24): two_stage = true; // no-break;
case PAIR(SAMPLE_INT32, SAMPLE_INT24): convert_c = convert32To24; break;
case PAIR(SAMPLE_INT24, SAMPLE_FLOAT): two_stage = true; // no-break;
case PAIR(SAMPLE_INT24, SAMPLE_INT32): convert_c = convert24To32; break;
case PAIR(SAMPLE_INT24, SAMPLE_INT16): convert_c = convert24To16; break;
case PAIR(SAMPLE_INT16, SAMPLE_INT24): convert_c = convert16To24; break;
case PAIR(SAMPLE_INT24, SAMPLE_INT8 ): convert_c = convert24To8; break;
case PAIR(SAMPLE_INT8 , SAMPLE_INT24): convert_c = convert8To24; break;
case PAIR(SAMPLE_INT8 , SAMPLE_FLOAT): convert_c = convert8ToFLT; break;
case PAIR(SAMPLE_FLOAT, SAMPLE_INT8): convert_c = convertFLTTo8; break;
case PAIR(SAMPLE_INT16, SAMPLE_FLOAT): convert_c = convert16ToFLT; break;
case PAIR(SAMPLE_FLOAT, SAMPLE_INT16): convert_c = convertFLTTo16; break;
case PAIR(SAMPLE_INT32, SAMPLE_FLOAT): convert_c = convert32ToFLT; break;
case PAIR(SAMPLE_FLOAT, SAMPLE_INT32): convert_c = convertFLTTo32; break;
}
#ifdef INTEL_INTRINSICS
switch(PAIR(src_format, dst_format)) {
case PAIR(SAMPLE_INT32, SAMPLE_INT16): convert_sse2 = convert32To16_SSE2; convert_avx2 = convert32To16_AVX2; break;
case PAIR(SAMPLE_INT16, SAMPLE_INT32): convert_sse2 = convert16To32_SSE2; convert_avx2 = convert16To32_AVX2; break;
case PAIR(SAMPLE_INT32, SAMPLE_INT8 ): convert_sse2 = convert32To8_SSE2; break;
case PAIR(SAMPLE_INT8 , SAMPLE_INT32): convert_sse2 = convert8To32_SSE2; break;
case PAIR(SAMPLE_INT16, SAMPLE_INT8 ): convert_sse2 = convert16To8_SSE2; break;
case PAIR(SAMPLE_INT8 , SAMPLE_INT16): convert_sse2 = convert8To16_SSE2; break;
case PAIR(SAMPLE_FLOAT, SAMPLE_INT24):
case PAIR(SAMPLE_INT32, SAMPLE_INT24): convert_ssse3 = convert32To24_SSSE3; break;
case PAIR(SAMPLE_INT24, SAMPLE_FLOAT):
case PAIR(SAMPLE_INT24, SAMPLE_INT32): convert_ssse3 = convert24To32_SSSE3; break;
case PAIR(SAMPLE_INT24, SAMPLE_INT16): convert_ssse3 = convert24To16_SSSE3; break;
case PAIR(SAMPLE_INT16, SAMPLE_INT24): convert_ssse3 = convert16To24_SSSE3; break;
case PAIR(SAMPLE_INT24, SAMPLE_INT8 ): convert_ssse3 = convert24To8_SSSE3; break;
case PAIR(SAMPLE_INT8 , SAMPLE_INT24): convert_ssse3 = convert8To24_SSSE3; break;
case PAIR(SAMPLE_INT8 , SAMPLE_FLOAT): convert_sse41 = convert8ToFLT_SSE41; convert_avx2 = convert8ToFLT_AVX2; break;
case PAIR(SAMPLE_FLOAT, SAMPLE_INT8) : convert_sse2 = convertFLTTo8_SSE2; convert_avx2 = convertFLTTo8_AVX2; break;
case PAIR(SAMPLE_INT16, SAMPLE_FLOAT): convert_sse41 = convert16ToFLT_SSE41; convert_avx2 = convert16ToFLT_AVX2; break;
case PAIR(SAMPLE_FLOAT, SAMPLE_INT16): convert_sse2 = convertFLTTo16_SSE2; convert_avx2 = convertFLTTo16_AVX2; break;
case PAIR(SAMPLE_INT32, SAMPLE_FLOAT): convert_sse2 = convert32ToFLT_SSE2; convert_avx2 = convert32ToFLT_AVX2; break;
case PAIR(SAMPLE_FLOAT, SAMPLE_INT32): convert_sse41 = convertFLTTo32_SSE41; convert_avx2 = convertFLTTo32_AVX2; break;
}
#endif
#undef PAIR
}
ConvertAudio::~ConvertAudio() {
if (tempbuffer_size) {
avs_free(tempbuffer);
tempbuffer_size = 0;
}
}
void __stdcall ConvertAudio::GetAudio(void *buf, int64_t start, int64_t count, IScriptEnvironment *env) {
if (src_format == dst_format) {
// Shouldn't happen, but just in case
child->GetAudio(buf, start, count, env);
return;
}
int channels = vi.AudioChannels();
if (tempbuffer_size < count) {
if (tempbuffer_size)
avs_free(tempbuffer);
tempbuffer = (char *)avs_malloc((int)count * src_bps * channels, 16);
tempbuffer_size = (int)count;
}
child->GetAudio(tempbuffer, start, count, env);
if (convert == nullptr) {
convert = convert_c;
convert_float = src_format == SAMPLE_FLOAT ? convertFLTTo32 : convert32ToFLT; // for two-stage
#ifdef INTEL_INTRINSICS
int cpu_flags = env->GetCPUFlags();
if ((cpu_flags & CPUF_SSE2)) {
if (convert_sse2)
convert = convert_sse2;
if (src_format != SAMPLE_FLOAT)
convert_float = convert32ToFLT_SSE2;
}
if ((cpu_flags & CPUF_SSSE3)) {
if (convert_ssse3)
convert = convert_ssse3;
}
if ((cpu_flags & CPUF_SSE4_1)) {
if (convert_sse41)
convert = convert_sse41;
if (src_format == SAMPLE_FLOAT)
convert_float = convertFLTTo32_SSE41;
}
if ((cpu_flags & CPUF_AVX2)) {
if (convert_avx2)
convert = convert_avx2;
convert_float = src_format == SAMPLE_FLOAT ? convertFLTTo32_AVX2 : convert32ToFLT_AVX2;
}
#endif
}
int sample_count = static_cast<int>(count * channels);
// Direct conversion cases
if (!two_stage) {
convert(tempbuffer, buf, sample_count);
return;
}
// Floating point cases
if (src_format == SAMPLE_FLOAT) {
convert_float(tempbuffer, tempbuffer, sample_count);
convert(tempbuffer, buf, sample_count);
return;
}
if (dst_format == SAMPLE_FLOAT) {
convert(tempbuffer, buf, sample_count);
convert_float(buf, buf, sample_count);
return;
}
}
================================================
FILE: avs_core/convert/convert_audio.h
================================================
// Avisynth v2.5. Copyright 2009 Ben Rudiak-Gould et al.
// http://avisynth.nl
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA, or visit
// http://www.gnu.org/copyleft/gpl.html .
//
// Linking Avisynth statically or dynamically with other modules is making a
// combined work based on Avisynth. Thus, the terms and conditions of the GNU
// General Public License cover the whole combination.
//
// As a special exception, the copyright holders of Avisynth give you
// permission to link Avisynth with independent modules that communicate with
// Avisynth solely through the interfaces defined in avisynth.h, regardless of the license
// terms of these independent modules, and to copy and distribute the
// resulting combined work under terms of your choice, provided that
// every copy of the combined work is accompanied by a complete copy of
// the source code of Avisynth (the version of Avisynth used to produce the
// combined work), being distributed under the terms of the GNU General
// Public License plus this exception. An independent module is a module
// which is not derived from or based on Avisynth, such as 3rd-party filters,
// import and export plugins, or graphical user interfaces.
#ifndef __Convert_Audio_H__
#define __Convert_Audio_H__
#include <avs/types.h>
#define CONVERT_DECLARE(func) void (func)(void *, void *, int);
typedef CONVERT_DECLARE(*convert_proc);
CONVERT_DECLARE(convert32To16);
CONVERT_DECLARE(convert16To32);
CONVERT_DECLARE(convert32To8);
CONVERT_DECLARE(convert8To32);
CONVERT_DECLARE(convert16To8);
CONVERT_DECLARE(convert8To16);
CONVERT_DECLARE(convert32To24);
CONVERT_DECLARE(convert24To32);
CONVERT_DECLARE(convert24To16);
CONVERT_DECLARE(convert16To24);
CONVERT_DECLARE(convert24To8);
CONVERT_DECLARE(convert8To24);
CONVERT_DECLARE(convert8ToFLT);
CONVERT_DECLARE(convertFLTTo8);
CONVERT_DECLARE(convert16ToFLT);
CONVERT_DECLARE(convertFLTTo16);
CONVERT_DECLARE(convert32ToFLT);
CONVERT_DECLARE(convertFLTTo32);
#ifdef INTEL_INTRINSICS
CONVERT_DECLARE(convert32To16_SSE2);
CONVERT_DECLARE(convert16To32_SSE2);
CONVERT_DECLARE(convert32To8_SSE2);
CONVERT_DECLARE(convert8To32_SSE2);
CONVERT_DECLARE(convert16To8_SSE2);
CONVERT_DECLARE(convert8To16_SSE2);
CONVERT_DECLARE(convert32To24_SSSE3);
CONVERT_DECLARE(convert24To32_SSSE3);
CONVERT_DECLARE(convert24To16_SSSE3);
CONVERT_DECLARE(convert16To24_SSSE3);
CONVERT_DECLARE(convert24To8_SSSE3);
CONVERT_DECLARE(convert8To24_SSSE3);
CONVERT_DECLARE(convert8ToFLT_SSE41);
CONVERT_DECLARE(convertFLTTo8_SSE2);
CONVERT_DECLARE(convert16ToFLT_SSE41);
CONVERT_DECLARE(convertFLTTo16_SSE2);
CONVERT_DECLARE(convert32ToFLT_SSE2);
CONVERT_DECLARE(convertFLTTo32_SSE41);
CONVERT_DECLARE(convert32To16_AVX2);
CONVERT_DECLARE(convert16To32_AVX2);
CONVERT_DECLARE(convert8ToFLT_AVX2);
CONVERT_DECLARE(convertFLTTo8_AVX2);
CONVERT_DECLARE(convert16ToFLT_AVX2);
CONVERT_DECLARE(convertFLTTo16_AVX2);
CONVERT_DECLARE(convert32ToFLT_AVX2);
CONVERT_DECLARE(convertFLTTo32_AVX2);
#endif
#undef CONVERT_DECLARE
class ConvertAudio : public GenericVideoFilter
/**
* Helper class to convert audio to any format
**/
{
public:
ConvertAudio(PClip _clip, int prefered_format);
void __stdcall GetAudio(void* buf, int64_t start, int64_t count, IScriptEnvironment* env);
int __stdcall SetCacheHints(int cachehints,int frame_range); // We do pass cache requests upwards, to the cache!
static PClip Create(PClip clip, int sample_type, int prefered_type);
static AVSValue __cdecl Create_float(AVSValue args, void*, IScriptEnvironment*);
static AVSValue __cdecl Create_32bit(AVSValue args, void*, IScriptEnvironment*);
static AVSValue __cdecl Create_24bit(AVSValue args, void*, IScriptEnvironment*);
static AVSValue __cdecl Create_16bit(AVSValue args, void*, IScriptEnvironment*);
static AVSValue __cdecl Create_8bit (AVSValue args, void*, IScriptEnvironment*);
static AVSValue __cdecl Create_Any (AVSValue args, void*, IScriptEnvironment*);
virtual ~ConvertAudio();
private:
int src_format;
int dst_format;
int src_bps;
int tempbuffer_size {0};
char *tempbuffer {nullptr};
bool two_stage {false};
convert_proc convert {nullptr};
convert_proc convert_float {nullptr};
convert_proc convert_c {nullptr};
#ifdef INTEL_INTRINSICS
convert_proc convert_sse2 {nullptr};
convert_proc convert_ssse3 {nullptr};
convert_proc convert_sse41 { nullptr };
convert_proc convert_avx2 {nullptr};
#endif
};
#endif //__Convert_Audio_H__
================================================
FILE: avs_core/convert/convert_audio_c.cpp
================================================
// Avisynth+
// https://avs-plus.net
//
// This file is part of Avisynth+ which is released under GPL2+ with exception.
// Convert Audio helper functions (Pure C)
// Copyright (c) 2020 Xinyue Lu, (c) 2021 pinterf
#include <avs/types.h>
/* Supported fast route conversions:
*
* | From: | U 8 | S16 | S24 | S32 | FLT |
* | To: | | | | | |
* | U 8 | - | CS | CS | CS | CSA |
* | S16 | CS | - | CS | CSA | CSA |
* | S24 | CS | CS | - | CS | |
* | S32 | CS | CSA | CS | - | CSA |
* | FLT | CSA | CSA | | CSA | - |
*
* * C = C, S = SSE2+, A = AVX2
*/
/*
8 bit: unsigned (middle point 128)
16,24,32 bit: signed
32 bit float: -1.0 .. 1.0
Assymetric range considerations.
Android: It is implementation dependent whether the positive maximum of 1.0 is included in the interval
when converting to integer representation
Method 1 (e.g. Android): smallest number is full scale, 1.0 is clamped to 1.0 minus one LSB
-0x8000 - 0x7FFF is valid, nominally +1.0 (top of range) is not part of the range [-1.0..1.0)
Method 2: largest number is full scale
-0x7FFF - 0x7FFF, while -8000 exceeds lower limit. [-1.0..1.0] + smallest value is theoretically invalid
*/
// until 3.6.1: S16 = (S32 + 0x8000) >> 16 (plain round-before shift)
// Actual: S16 = S32 >> 16
void convert32To16(void *inbuf, void *outbuf, int count) {
auto in16 = reinterpret_cast<int16_t *>(inbuf);
auto out = reinterpret_cast<int16_t *>(outbuf);
for (int i = 0; i < count; i++)
out[i] = in16[i * 2 + 1];
}
// until 3.6.1: S32 = (S16 << 16) + (unsigned short)(S16 + 32768)
// 0x7fff -> 0x7fffffff, 0x8000 -> 0x80000000
// Actual: S32 = S16 << 16
void convert16To32(void *inbuf, void *outbuf, int count) {
auto in = reinterpret_cast<int16_t *>(inbuf);
auto out16 = reinterpret_cast<int16_t *>(outbuf);
for (int i = 0; i < count; i++) {
out16[i * 2] = 0;
out16[i * 2 + 1] = in[i];
}
}
void convert32To8(void* inbuf, void* outbuf, int count) {
auto in8 = reinterpret_cast<int8_t*>(inbuf);
auto out = reinterpret_cast<uint8_t*>(outbuf);
for (int i = 0; i < count; i++)
out[i] = in8[i * 4 + 3] + 128;
}
void convert8To32(void *inbuf, void *outbuf, int count) {
auto in = reinterpret_cast<uint8_t *>(inbuf);
auto out8 = reinterpret_cast<int8_t *>(outbuf);
for (int i = 0; i < count; i++) {
out8[i * 4] = 0;
out8[i * 4 + 1] = 0;
out8[i * 4 + 2] = 0;
out8[i * 4 + 3] = in[i] - 128;
}
}
void convert16To8(void *inbuf, void *outbuf, int count) {
auto in8 = reinterpret_cast<int8_t *>(inbuf);
auto out = reinterpret_cast<uint8_t *>(outbuf);
for (int i = 0; i < count; i++)
out[i] = in8[i * 2 + 1] + 128;
}
// until 3.6.1: S16 = (S8 << 8) + (unsigned short)(S8 + 128)
// This make 0x7f(255-128) -> 0x7fff & 0x80(0-128) -> 0x8000
// Actual: S16 = (U8-128) << 8
void convert8To16(void *inbuf, void *outbuf, int count) {
auto in = reinterpret_cast<uint8_t *>(inbuf);
auto out8 = reinterpret_cast<int8_t *>(outbuf);
for (int i = 0; i < count; i++) {
out8[i * 2] = 0;
out8[i * 2 + 1] = in[i] - 128;
}
}
void convert32To24(void *inbuf, void *outbuf, int count) {
auto in8 = reinterpret_cast<int8_t *>(inbuf);
auto out8 = reinterpret_cast<int8_t *>(outbuf);
for (int i = 0; i < count; i++) {
out8[i * 3 + 0] = in8[i * 4 + 1];
out8[i * 3 + 1] = in8[i * 4 + 2];
out8[i * 3 + 2] = in8[i * 4 + 3];
}
}
void convert24To32(void *inbuf, void *outbuf, int count) {
auto in8 = reinterpret_cast<int8_t *>(inbuf);
auto out8 = reinterpret_cast<int8_t *>(outbuf);
for (int i = 0; i < count; i++) {
out8[i * 4] = 0;
out8[i * 4 + 1] = in8[i * 3 + 0];
out8[i * 4 + 2] = in8[i * 3 + 1];
out8[i * 4 + 3] = in8[i * 3 + 2];
}
}
void convert24To16(void *inbuf, void *outbuf, int count) {
auto in8 = reinterpret_cast<int8_t *>(inbuf);
auto out8 = reinterpret_cast<int8_t *>(outbuf);
for (int i = 0; i < count; i++) {
out8[i * 2 + 0] = in8[i * 3 + 1];
out8[i * 2 + 1] = in8[i * 3 + 2];
}
}
void convert16To24(void *inbuf, void *outbuf, int count) {
auto in8 = reinterpret_cast<int8_t *>(inbuf);
auto out8 = reinterpret_cast<int8_t *>(outbuf);
for (int i = 0; i < count; i++) {
out8[i * 3] = 0;
out8[i * 3 + 1] = in8[i * 2 + 0];
out8[i * 3 + 2] = in8[i * 2 + 1];
}
}
void convert24To8(void *inbuf, void *outbuf, int count) {
auto in8 = reinterpret_cast<int8_t *>(inbuf);
auto out = reinterpret_cast<uint8_t *>(outbuf);
for (int i = 0; i < count; i++)
out[i] = in8[i * 3 + 2] + 128;
}
void convert8To24(void *inbuf, void *outbuf, int count) {
auto in = reinterpret_cast<uint8_t *>(inbuf);
auto out8 = reinterpret_cast<int8_t *>(outbuf);
for (int i = 0; i < count; i++) {
out8[i * 3] = 0;
out8[i * 3 + 1] = 0;
out8[i * 3 + 2] = in[i] - 128;
}
}
void convert8ToFLT(void* inbuf, void* outbuf, int count) {
auto in = reinterpret_cast<uint8_t*>(inbuf);
auto out = reinterpret_cast<SFLOAT*>(outbuf);
constexpr float divisor = 1.0f / 128.f; // 1 << 7
for (int i = 0; i < count; i++)
out[i] = (in[i] - 128) * divisor;
}
void convertFLTTo8(void* inbuf, void* outbuf, int count) {
auto in = reinterpret_cast<SFLOAT*>(inbuf);
auto out = reinterpret_cast<uint8_t*>(outbuf);
constexpr float multiplier = 128.f;
constexpr float max8 = 127.f;
constexpr float min8 = -128.f;
for (int i = 0; i < count; i++) {
float val = in[i] * multiplier;
uint8_t result;
if (val >= max8) result = 255;
else if (val <= min8) result = 0;
else result = static_cast<int8_t>(val) + 128;
out[i] = result;
}
}
void convert16ToFLT(void* inbuf, void* outbuf, int count) {
auto in = reinterpret_cast<int16_t*>(inbuf);
auto out = reinterpret_cast<SFLOAT*>(outbuf);
constexpr float divisor = 1.0f / 32768.f; // 1 << 15
for (int i = 0; i < count; i++)
out[i] = in[i] * divisor;
}
void convertFLTTo16(void* inbuf, void* outbuf, int count) {
auto in = reinterpret_cast<SFLOAT*>(inbuf);
auto out = reinterpret_cast<int16_t*>(outbuf);
constexpr float multiplier = 32768.f;
constexpr float max16 = 32767.f;
constexpr float min16 = -32768.f;
for (int i = 0; i < count; i++) {
float val = in[i] * multiplier;
int16_t result;
if (val >= max16) result = 32767;
else if (val <= min16) result = (int16_t)-32768;
else result = static_cast<int16_t>(val);
out[i] = result;
}
}
// not yet used directly, 24 bit has 32 bit 2nd stage
void convert24ToFLT(void* inbuf, void* outbuf, int count) {
auto in = reinterpret_cast<uint8_t*>(inbuf);
auto out = reinterpret_cast<SFLOAT*>(outbuf);
constexpr float divisor = 1.0f / 8388608.f; // 1 << 23
for (int i = 0; i < count; i++)
out[i] = (in[i * 3] | (in[i * 3 + 1] << 8) | (in[i * 3 + 2] << 16)) * divisor;
}
// not yet used directly, 24 bit has 32 bit 2nd stage
void convertFLTTo24(void* inbuf, void* outbuf, int count) {
auto in = reinterpret_cast<SFLOAT*>(inbuf);
auto out = reinterpret_cast<uint8_t*>(outbuf);
constexpr float multiplier = 8388608.f;
constexpr float max24 = 8388607.f;
constexpr float min24 = -8388608.f;
for (int i = 0; i < count; i++) {
float val = in[i] * multiplier;
int32_t result;
if (val >= max24) result = 0x7FFFFF; // 8388607
else if (val <= min24) result = 0x800000; // -8388608
else result = static_cast<int32_t>(val);
out[i * 3 + 0] = result & 0xFF;
out[i * 3 + 1] = (result >> 8) & 0xFF;
out[i * 3 + 2] = (result >> 16) & 0xFF;
}
}
// note for 32 bit conversions: 32 bit integer cannot be represented in float
// 2147483647.0f is 2147483648.0f in reality
void convert32ToFLT(void *inbuf, void *outbuf, int count) {
auto in = reinterpret_cast<int32_t *>(inbuf);
auto out = reinterpret_cast<SFLOAT *>(outbuf);
constexpr float divisor = 1.0f/2147483648.0f;
for (int i = 0; i < count; i++)
out[i] = in[i] * divisor;
}
void convertFLTTo32(void *inbuf, void *outbuf, int count) {
auto in = reinterpret_cast<SFLOAT *>(inbuf);
auto out = reinterpret_cast<int32_t *>(outbuf);
constexpr float multiplier = 2147483648.0f;
constexpr float max32 = 2147483647.0f;
constexpr float min32 = -2147483648.0f;
for (int i = 0; i < count; i++) {
float val = in[i] * multiplier;
int32_t result;
if (val >= max32) result = 0x7FFFFFFF; // 2147483647
else if (val <= min32) result = 0x80000000; // -2147483648
else result = static_cast<int32_t>(val);
out[i] = result;
}
}
================================================
FILE: avs_core/convert/convert_bits.cpp
================================================
// Avisynth v2.5. Copyright 2002-2009 Ben Rudiak-Gould et al.
// http://avisynth.nl
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA, or visit
// http://www.gnu.org/copyleft/gpl.html .
//
// Linking Avisynth statically or dynamically with other modules is making a
// combined work based on Avisynth. Thus, the terms and conditions of the GNU
// General Public License cover the whole combination.
//
// As a special exception, the copyright holders of Avisynth give you
// permission to link Avisynth with independent modules that communicate with
// Avisynth solely through the interfaces defined in avisynth.h, regardless of the license
// terms of these independent modules, and to copy and distribute the
// resulting combined work under terms of your choice, provided that
// every copy of the combined work is accompanied by a complete copy of
// the source code of Avisynth (the version of Avisynth used to produce the
// combined work), being distributed under the terms of the GNU General
// Public License plus this exception. An independent module is a module
// which is not derived from or based on Avisynth, such as 3rd-party filters,
// import and export plugins, or graphical user interfaces.
#include "convert_bits.h"
#ifdef INTEL_INTRINSICS
#include "intel/convert_bits_sse.h"
#include "intel/convert_bits_avx2.h"
#endif
#include "convert_helper.h"
#include <avs/alignment.h>
#include <avs/minmax.h>
#include <avs/config.h>
#include <tuple>
#include <map>
#include <algorithm>
#include <vector>
#ifdef AVS_WINDOWS
#include <avs/win.h>
#else
#include <avs/posix.h>
#endif
// for odd dither bit differences, we still take even size but
// correction values are halved (shifted by 1)
// repeated 8x for sse size 16
const BYTE dither2x2a_data[4] = {
0, 1,
1, 0,
};
// cycle: 2
alignas(16) const BYTE dither2x2a_data_sse2[2 * 16] = {
0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0
};
// e.g. 10->8 bits
// repeated 8x for sse size 16
const BYTE dither2x2_data[4] = {
0, 2,
3, 1,
};
// cycle: 2
alignas(16) const BYTE dither2x2_data_sse2[2 * 16] = {
0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2,
3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1
};
// e.g. 8->5 bits
const BYTE dither4x4a_data[16] = {
0, 4, 1, 5,
6, 2, 7, 3,
1, 5, 0, 4,
7, 3, 6, 2
};
// cycle: 4
alignas(16) const BYTE dither4x4a_data_sse2[4 * 16] = {
0, 4, 1, 5, 0, 4, 1, 5, 0, 4, 1, 5, 0, 4, 1, 5,
6, 2, 7, 3, 6, 2, 7, 3, 6, 2, 7, 3, 6, 2, 7, 3,
1, 5, 0, 4, 1, 5, 0, 4, 1, 5, 0, 4, 1, 5, 0, 4,
7, 3, 6, 2, 7, 3, 6, 2, 7, 3, 6, 2, 7, 3, 6, 2,
};
// e.g. 12->8 bits
const BYTE dither4x4_data[16] = {
0, 8, 2, 10,
12, 4, 14, 6,
3, 11, 1, 9,
15, 7, 13, 5
};
// cycle: 4
alignas(16) const BYTE dither4x4_data_sse2[4 * 16] = {
0, 8, 2, 10, 0, 8, 2, 10, 0, 8, 2, 10, 0, 8, 2, 10,
12, 4, 14, 6, 12, 4, 14, 6, 12, 4, 14, 6, 12, 4, 14, 6,
3, 11, 1, 9, 3, 11, 1, 9, 3, 11, 1, 9, 3, 11, 1, 9,
15, 7, 13, 5, 15, 7, 13, 5, 15, 7, 13, 5, 15, 7, 13, 5
};
// e.g. 14->9 bits
extern const BYTE dither8x8a_data[8][8] = {
{ 0, 16, 4, 20, 1, 17, 5, 21}, /* 8x8 Bayer ordered dithering pattern */
{24, 8, 28, 12, 25, 9, 29, 13},
{ 6, 22, 2, 18, 7, 23, 3, 19},
{30, 14, 26, 10, 31, 15, 27, 11},
{ 1, 17, 5, 21, 0, 16, 4, 20},
{25, 9, 29, 13, 24, 8, 28, 12},
{ 7, 23, 3, 19, 6, 22, 2, 18},
{31, 15, 27, 11, 30, 14, 26, 10}
};
// cycle: 8
alignas(16) const BYTE dither8x8a_data_sse2[8][16] = {
{ 0, 16, 4, 20, 1, 17, 5, 21, 0, 16, 4, 20, 1, 17, 5, 21 },
{ 24, 8, 28, 12, 25, 9, 29, 13, 24, 8, 28, 12, 25, 9, 29, 13 },
{ 6, 22, 2, 18, 7, 23, 3, 19, 6, 22, 2, 18, 7, 23, 3, 19 },
{ 30, 14, 26, 10, 31, 15, 27, 11, 30, 14, 26, 10, 31, 15, 27, 11 },
{ 1, 17, 5, 21, 0, 16, 4, 20, 1, 17, 5, 21, 0, 16, 4, 20 },
{ 25, 9, 29, 13, 24, 8, 28, 12, 25, 9, 29, 13, 24, 8, 28, 12 },
{ 7, 23, 3, 19, 6, 22, 2, 18, 7, 23, 3, 19, 6, 22, 2, 18 },
{ 31, 15, 27, 11, 30, 14, 26, 10, 31, 15, 27, 11, 30, 14, 26, 10 }
};
// e.g. 14->8 bits
extern const BYTE dither8x8_data[8][8] = {
{ 0, 32, 8, 40, 2, 34, 10, 42},
{48, 16, 56, 24, 50, 18, 58, 26},
{12, 44, 4, 36, 14, 46, 6, 38},
{60, 28, 52, 20, 62, 30, 54, 22},
{ 3, 35, 11, 43, 1, 33, 9, 41},
{51, 19, 59, 27, 49, 17, 57, 25},
{15, 47, 7, 39, 13, 45, 5, 37},
{63, 31, 55, 23, 61, 29, 53, 21}
};
// cycle: 8
alignas(16) const BYTE dither8x8_data_sse2[8][16] = {
{ 0, 32, 8, 40, 2, 34, 10, 42, 0, 32, 8, 40, 2, 34, 10, 42 },
{ 48, 16, 56, 24, 50, 18, 58, 26, 48, 16, 56, 24, 50, 18, 58, 26 },
{ 12, 44, 4, 36, 14, 46, 6, 38, 12, 44, 4, 36, 14, 46, 6, 38 },
{ 60, 28, 52, 20, 62, 30, 54, 22, 60, 28, 52, 20, 62, 30, 54, 22 },
{ 3, 35, 11, 43, 1, 33, 9, 41, 3, 35, 11, 43, 1, 33, 9, 41 },
{ 51, 19, 59, 27, 49, 17, 57, 25, 51, 19, 59, 27, 49, 17, 57, 25 },
{ 15, 47, 7, 39, 13, 45, 5, 37, 15, 47, 7, 39, 13, 45, 5, 37 },
{ 63, 31, 55, 23, 61, 29, 53, 21, 63, 31, 55, 23, 61, 29, 53, 21 }
};
// e.g. 16->9 or 8->1 bits
// cycle: 16x. No special 16 byte sse2
alignas(16) const BYTE dither16x16a_data[16][16] = {
{ 0, 96, 24,120, 6,102, 30,126, 1, 97, 25,121, 7,103, 31,127 },
{ 64, 32, 88, 56, 70, 38, 94, 62, 65, 33, 89, 57, 71, 39, 95, 63 },
{ 16,112, 8,104, 22,118, 14,110, 17,113, 9,105, 23,119, 15,111 },
{ 80, 48, 72, 40, 86, 54, 78, 46, 81, 49, 73, 41, 87, 55, 79, 47 },
{ 4,100, 28,124, 2, 98, 26,122, 5,101, 29,125, 3, 99, 27,123 },
{ 68, 36, 92, 60, 66, 34, 90, 58, 69, 37, 93, 61, 67, 35, 91, 59 },
{ 20,116, 12,108, 18,114, 10,106, 21,117, 13,109, 19,115, 11,107 },
{ 84, 52, 76, 44, 82, 50, 74, 42, 85, 53, 77, 45, 83, 51, 75, 43 },
{ 1, 97, 25,121, 7,103, 31,127, 0, 96, 24,120, 6,102, 30,126 },
{ 75, 33, 89, 57, 71, 39, 95, 63, 64, 32, 88, 56, 70, 38, 94, 62 },
{ 17,113, 9,105, 23,119, 15,111, 16,112, 8,104, 22,118, 14,110 },
{ 81, 49, 73, 41, 87, 55, 79, 47, 80, 48, 72, 40, 86, 54, 78, 46 },
{ 5,101, 29,125, 3, 99, 27,123, 4,100, 28,124, 2, 98, 26,122 },
{ 69, 37, 93, 61, 67, 35, 91, 59, 68, 36, 92, 60, 66, 34, 90, 58 },
{ 21,117, 13,109, 19,115, 11,107, 20,116, 12,108, 18,114, 10,106 },
{ 85, 53, 77, 45, 83, 51, 75, 43, 84, 52, 76, 44, 82, 50, 74, 42 }
};
// 16->8
// cycle: 16x. No special 16 byte sse2
alignas(16) const BYTE dither16x16_data[16][16] = {
{ 0,192, 48,240, 12,204, 60,252, 3,195, 51,243, 15,207, 63,255 },
{ 128, 64,176,112,140, 76,188,124,131, 67,179,115,143, 79,191,127 },
{ 32,224, 16,208, 44,236, 28,220, 35,227, 19,211, 47,239, 31,223 },
{ 160, 96,144, 80,172,108,156, 92,163, 99,147, 83,175,111,159, 95 },
{ 8,200, 56,248, 4,196, 52,244, 11,203, 59,251, 7,199, 55,247 },
{ 136, 72,184,120,132, 68,180,116,139, 75,187,123,135, 71,183,119 },
{ 40,232, 24,216, 36,228, 20,212, 43,235, 27,219, 39,231, 23,215 },
{ 168,104,152, 88,164,100,148, 84,171,107,155, 91,167,103,151, 87 },
{ 2,194, 50,242, 14,206, 62,254, 1,193, 49,241, 13,205, 61,253 },
{ 130, 66,178,114,142, 78,190,126,129, 65,177,113,141, 77,189,125 },
{ 34,226, 18,210, 46,238, 30,222, 33,225, 17,209, 45,237, 29,221 },
{ 162, 98,146, 82,174,110,158, 94,161, 97,145, 81,173,109,157, 93 },
{ 10,202, 58,250, 6,198, 54,246, 9,201, 57,249, 5,197, 53,245 },
{ 138, 74,186,122,134, 70,182,118,137, 73,185,121,133, 69,181,117 },
{ 42,234, 26,218, 38,230, 22,214, 41,233, 25,217, 37,229, 21,213 },
{ 170,106,154, 90,166,102,150, 86,169,105,153, 89,165,101,149, 85 }
};
template<typename pixel_t_s, typename pixel_t_d, bool chroma, bool fulls, bool fulld, bool TEMPLATE_NEED_BACKSCALE, bool TEMPLATE_LOW_DITHER_BITDEPTH>
static void do_convert_ordered_dither_uint_c(const BYTE* srcp8, BYTE* dstp8, int src_rowsize, int src_height, int src_pitch, int dst_pitch, int source_bitdepth, int target_bitdepth, int dither_target_bitdepth)
{
const pixel_t_s* srcp = reinterpret_cast<const pixel_t_s*>(srcp8);
pixel_t_d* dstp = reinterpret_cast<pixel_t_d*>(dstp8);
dst_pitch = dst_pitch / sizeof(pixel_t_d);
src_pitch = src_pitch / sizeof(pixel_t_s);
const int src_width = src_rowsize / sizeof(pixel_t_s);
// helps compiler optimization
if constexpr (sizeof(pixel_t_s) == 1)
source_bitdepth = 8;
if constexpr (sizeof(pixel_t_d) == 1) {
target_bitdepth = 8;
if (!TEMPLATE_NEED_BACKSCALE) {
dither_target_bitdepth = 8;
}
}
const int max_pixel_value_target = (1 << target_bitdepth) - 1;
const int max_pixel_value_dithered = (1 << dither_target_bitdepth) - 1;
// precheck ensures:
// target_bitdepth >= dither_target_bitdepth
// source_bitdepth - dither_target_bitdepth <= 8 (max precalculated table is 16x16)
const bool odd_diff = (source_bitdepth - dither_target_bitdepth) & 1;
const int dither_bit_diff = (source_bitdepth - dither_target_bitdepth);
const int dither_order = (dither_bit_diff + 1) / 2;
const int dither_mask = (1 << dither_order) - 1; // 9,10=2 11,12=4 13,14=8 15,16=16
// 10->8: 0x01 (2x2)
// 11->8: 0x03 (4x4)
// 12->8: 0x03 (4x4)
// 14->8: 0x07 (8x8)
// 16->8: 0x0F (16x16)
const BYTE* matrix;
switch (dither_order) {
case 1: matrix = reinterpret_cast<const BYTE*>(odd_diff ? dither2x2a_data : dither2x2_data); break;
case 2: matrix = reinterpret_cast<const BYTE*>(odd_diff ? dither4x4a_data : dither4x4_data); break;
case 3: matrix = reinterpret_cast<const BYTE*>(odd_diff ? dither8x8a_data : dither8x8_data); break;
case 4: matrix = reinterpret_cast<const BYTE*>(odd_diff ? dither16x16a_data : dither16x16_data); break;
default: return; // n/a
}
const int bitdiff_between_dither_and_target = target_bitdepth - dither_target_bitdepth;
assert(TEMPLATE_NEED_BACKSCALE == (target_bitdepth != dither_target_bitdepth)); // dither to x, target to y
assert(TEMPLATE_LOW_DITHER_BITDEPTH == (dither_target_bitdepth < 8));
// e.g. instead of 0,1 => -0.5,+0.5; 0,1,2,3 => -1.5,-0.5,0.5,1.5
const float half_maxcorr_value = ((1 << dither_bit_diff) - 1) / 2.0f;
const int source_max = (1 << source_bitdepth) - 1;
//-----------------------
// When calculating src_pixel, src and dst are of the same bit depth
bits_conv_constants d;
get_bits_conv_constants(d, chroma, fulls, fulld, source_bitdepth, source_bitdepth);
auto dst_offset_plus_round = d.dst_offset + 0.5f;
constexpr auto src_pixel_min = 0;
const auto src_pixel_max = source_max;
const float mul_factor_backfromlowdither = (float)max_pixel_value_target / max_pixel_value_dithered;
//-----------------------
for (int y = 0; y < src_height; y++)
{
int _y = (y & dither_mask) << dither_order; // ordered dither
for (int x = 0; x < src_width; x++)
{
const int corr = matrix[_y | (x & dither_mask)];
int src_pixel = srcp[x];
if constexpr(fulls != fulld) {
const float val = (srcp[x] - d.src_offset_i) * d.mul_factor + dst_offset_plus_round;
src_pixel = clamp((int)val, src_pixel_min, src_pixel_max);
}
int new_pixel;
if (TEMPLATE_LOW_DITHER_BITDEPTH) {
// accurate dither: +/-
// accurately positioned to the center
const float corr_f = corr - half_maxcorr_value;
new_pixel = (int)(src_pixel + corr_f) >> dither_bit_diff;
}
else
new_pixel = ((src_pixel + corr) >> dither_bit_diff);
// scale back to the required bit depth
if constexpr (TEMPLATE_NEED_BACKSCALE) { // dither to x, target to y
new_pixel = min(new_pixel, max_pixel_value_dithered);
// Interesting problem of dither_bits==1 (or in general at small dither_bits)
// After simple slli 0,1 becomes 0,128, we'd expect 0,255 instead. So we make cosmetics.
if (TEMPLATE_LOW_DITHER_BITDEPTH) {
new_pixel = (int)(new_pixel * mul_factor_backfromlowdither + 0.5f);
}
else {
new_pixel = new_pixel << bitdiff_between_dither_and_target;
}
// dither_bits
// 1 0,1 => 0,128 => 0,255
// 2 0,1,2,3 => 0,64,128,192 => 0,?,?,255
// 3 0,...,7 => 0,32,...,224 => 0,?,?,255
// 4 0,..,15 => 0,16,...,240 => 0,?,?,255
// 5 0,..,31 => 0,8,....,248 => 0,?,?,255
// 6 0,..,63 => 0,4,....,252 => 0,?,?,255
// 7 0,.,127 => 0,2. ..,254 => 0,?,?,255
}
dstp[x] = (pixel_t_d)(max(min((int)new_pixel, max_pixel_value_target),0));
}
dstp += dst_pitch;
srcp += src_pitch;
}
}
template<typename pixel_t_s, typename pixel_t_d, bool chroma, bool fulls, bool fulld>
static void convert_ordered_dither_uint_c(const BYTE* srcp8, BYTE* dstp8, int src_rowsize, int src_height, int src_pitch, int dst_pitch, int source_bitdepth, int target_bitdepth, int dither_target_bitdepth)
{
const bool need_backscale = target_bitdepth != dither_target_bitdepth; // dither to x, target to y
const bool low_dither_bitdepth = dither_target_bitdepth < 8; // 1-7 bits dither targets, need_backscale is always true, since 8 bit format is the minimum
if (need_backscale) {
if (low_dither_bitdepth)
do_convert_ordered_dither_uint_c<pixel_t_s, pixel_t_d, chroma, fulls, fulld, true, true>(srcp8, dstp8, src_rowsize, src_height, src_pitch, dst_pitch, source_bitdepth, target_bitdepth, dither_target_bitdepth);
else
do_convert_ordered_dither_uint_c<pixel_t_s, pixel_t_d, chroma, fulls, fulld, true, false>(srcp8, dstp8, src_rowsize, src_height, src_pitch, dst_pitch, source_bitdepth, target_bitdepth, dither_target_bitdepth);
}
else {
do_convert_ordered_dither_uint_c<pixel_t_s, pixel_t_d, chroma, fulls, fulld, false, false>(srcp8, dstp8, src_rowsize, src_height, src_pitch, dst_pitch, source_bitdepth, target_bitdepth, dither_target_bitdepth);
}
}
// idea borrowed from fmtConv
#define FS_OPTIMIZED_SERPENTINE_COEF
template<int direction>
static AVS_FORCEINLINE void diffuse_floyd(int err, int &nextError, int *error_ptr)
{
#if defined (FS_OPTIMIZED_SERPENTINE_COEF)
const int e1 = 0;
const int e3 = (err * 4 + 8) >> 4;
#else
const int e1 = (err + 8) >> 4;
const int e3 = (err * 3 + 8) >> 4;
#endif
const int e5 = (err * 5 + 8) >> 4;
const int e7 = err - e1 - e3 - e5;
nextError = error_ptr[direction];
error_ptr[-direction] += e3;
error_ptr[0] += e5;
error_ptr[direction] = e1;
nextError += e7;
}
#if 0
template<int direction>
static AVS_FORCEINLINE void diffuse_floyd_f(float err, float& nextError, float* error_ptr)
{
#if defined (FS_OPTIMIZED_SERPENTINE_COEF)
const float e1 = 0;
const float e3 = err * (4.0f / 16);
#else
const float e1 = err * (1.0f / 16);
const float e3 = err * (3.0f / 16);
#endif
const float e5 = err * (5.0f / 16);
const float e7 = err * (7.0f / 16);
nextError = error_ptr[direction];
error_ptr[-direction] += e3;
error_ptr[0] += e5;
error_ptr[direction] = e1;
nextError += e7;
}
#endif
// optimization helper: TEMPLATE_DITHER_BIT_DIFF if not <0 then hold value for frequently used differences from 16->8
// 2nd helper: TEMPLATE_LOW_DITHER_BITDEPTH
// 3rd helper: source_bitdepth_special
template<typename pixel_t_s, typename pixel_t_d, bool chroma, bool fulls, bool fulld, int TEMPLATE_DITHER_BIT_DIFF, bool TEMPLATE_LOW_DITHER_BITDEPTH, int SOURCE_BITDEPTH_SPECIAL>
static void do_convert_uint_floyd_c(const BYTE* srcp8, BYTE* dstp8, int src_rowsize, int src_height, int src_pitch, int dst_pitch, int source_bitdepth, int target_bitdepth, int dither_target_bitdepth)
{
if constexpr (SOURCE_BITDEPTH_SPECIAL > 0) {
// called with >0 values only for special cases like 16 to 8, 16 to 10 and 10 to 8
// Hugely helps the optimizers
source_bitdepth = SOURCE_BITDEPTH_SPECIAL;
}
if constexpr (TEMPLATE_DITHER_BIT_DIFF > 0) {
assert(TEMPLATE_DITHER_BIT_DIFF == (source_bitdepth - dither_target_bitdepth));
assert(target_bitdepth == dither_target_bitdepth);
dither_target_bitdepth = source_bitdepth - TEMPLATE_DITHER_BIT_DIFF;
target_bitdepth = dither_target_bitdepth;
// seems that direct shift with known constant bits is really quicker than shift by 'cl'.
// Dithering from 16 to 10 bit: 109 vs 101 fps
// PF note: experienced the same with SIMD _mm_srl and _mm_srli in the other bit converter
}
const int DITHER_BIT_DIFF = TEMPLATE_DITHER_BIT_DIFF > 0 ? TEMPLATE_DITHER_BIT_DIFF : (source_bitdepth - dither_target_bitdepth);
assert(TEMPLATE_LOW_DITHER_BITDEPTH == (dither_target_bitdepth < 8)); // must match with dispatcher
const pixel_t_s* srcp = reinterpret_cast<const pixel_t_s*>(srcp8);
src_pitch = src_pitch / sizeof(pixel_t_s);
const int src_width = src_rowsize / sizeof(pixel_t_s);
pixel_t_d* dstp = reinterpret_cast<pixel_t_d*>(dstp8);
dst_pitch = dst_pitch / sizeof(pixel_t_d);
// perhaps helps compiler to optimize
if constexpr (sizeof(pixel_t_s) == 1)
source_bitdepth = 8;
if constexpr (sizeof(pixel_t_d) == 1)
target_bitdepth = 8;
const int max_pixel_value_target = (1 << target_bitdepth) - 1;
const int BITDIFF_BETWEEN_DITHER_AND_TARGET = DITHER_BIT_DIFF - (source_bitdepth - target_bitdepth);
const int max_pixel_value_dithered = (1 << dither_target_bitdepth) - 1;
std::vector<int> error_ptr_safe(1 + src_width + 1); // accumulated errors
int *error_ptr = &error_ptr_safe[1];
const int ROUNDER = 1 << (DITHER_BIT_DIFF - 1); // rounding
const int source_max = (1 << source_bitdepth) - 1;
//-----------------------
bits_conv_constants d;
get_bits_conv_constants(d, chroma, fulls, fulld, source_bitdepth, source_bitdepth);
auto dst_offset_plus_round = d.dst_offset + 0.5f;
constexpr auto src_pixel_min = 0;
const auto src_pixel_max = source_max;
const float mul_factor_backfromlowdither = (float)max_pixel_value_target / max_pixel_value_dithered;
int nextError = 0; // zero
for (int y = 0; y < src_height; y++)
{
// serpentine forward
if ((y & 1) == 0)
{
for (int x = 0; x < src_width; x++)
{
int err = nextError;
int src_pixel = srcp[x];
if constexpr (fulls != fulld) {
const float val = (src_pixel - d.src_offset_i) * d.mul_factor + dst_offset_plus_round;
src_pixel = clamp((int)val, src_pixel_min, src_pixel_max);
}
if (TEMPLATE_LOW_DITHER_BITDEPTH) {
// accurate dither: +/-
// accurately positioned to the center
err = err - (1 << (DITHER_BIT_DIFF - 1)); // signed
}
int sum = src_pixel + err;
int quantized = (sum + ROUNDER) >> (DITHER_BIT_DIFF);
err = sum - (quantized << DITHER_BIT_DIFF);
// Interesting problem of dither_bits==1 (or in general at small dither_bits)
// After simple slli 0,1 becomes 0,128, we'd expect 0,255 instead. So we make cosmetics.
if (TEMPLATE_LOW_DITHER_BITDEPTH) {
quantized = min(quantized, max_pixel_value_dithered);
quantized = (int)(quantized * mul_factor_backfromlowdither + 0.5f);
}
else {
quantized <<= BITDIFF_BETWEEN_DITHER_AND_TARGET;
}
int pix = max(min(max_pixel_value_target, quantized), 0); // clamp to target bit
dstp[x] = (pixel_t_d)pix;
diffuse_floyd<1>(err, nextError, &error_ptr[x]);
}
}
else {
// serpentine backward
for (int x = src_width - 1; x >= 0; --x)
{
int err = nextError;
int src_pixel = srcp[x];
if constexpr (fulls != fulld) {
const float val = (src_pixel - d.src_offset_i) * d.mul_factor + dst_offset_plus_round;
src_pixel = clamp((int)val, src_pixel_min, src_pixel_max);
}
if (TEMPLATE_LOW_DITHER_BITDEPTH) {
// accurate dither: +/-
// accurately positioned to the center
err = err - (1 << (DITHER_BIT_DIFF - 1)); // signed
}
int sum = src_pixel + err;
int quantized = (sum + ROUNDER) >> (DITHER_BIT_DIFF);
err = sum - (quantized << DITHER_BIT_DIFF);
// Interesting problem of dither_bits==1 (or in general at small dither_bits)
// After simple slli 0,1 becomes 0,128, we'd expect 0,255 instead. So we make cosmetics.
if (TEMPLATE_LOW_DITHER_BITDEPTH) {
quantized = min(quantized, max_pixel_value_dithered);
quantized = (int)(quantized * mul_factor_backfromlowdither + 0.5f);
}
else {
quantized <<= BITDIFF_BETWEEN_DITHER_AND_TARGET;
}
int pix = max(min(max_pixel_value_target, quantized), 0); // clamp to target bit
dstp[x] = (pixel_t_d)pix;
diffuse_floyd<-1>(err, nextError, &error_ptr[x]);
}
}
dstp += dst_pitch;
srcp += src_pitch;
}
}
template<typename pixel_t_s, typename pixel_t_d, bool chroma, bool fulls, bool fulld>
static void convert_uint_floyd_c(const BYTE* srcp8, BYTE* dstp8, int src_rowsize, int src_height, int src_pitch, int dst_pitch, int source_bitdepth, int target_bitdepth, int dither_target_bitdepth)
{
const int dither_bit_diff = source_bitdepth - dither_target_bitdepth;
const bool low_dither_bitdepth = dither_target_bitdepth < 8;
// extra internal template makes it quicker for ordinary non-artistic cases
// do not make templates for all 1-16 target bit combinations
if (low_dither_bitdepth) {
do_convert_uint_floyd_c<pixel_t_s, pixel_t_d, chroma, fulls, fulld, -1, true, -1>(srcp8, dstp8, src_rowsize, src_height, src_pitch, dst_pitch, source_bitdepth, target_bitdepth, dither_target_bitdepth);
}
else {
if (target_bitdepth == dither_target_bitdepth) {
// Specifically when source_bitdepth is known as well, it hugely helps optimization
// We treat special use cases 10->8, 16->10 and 16->8
switch (dither_bit_diff) {
case 2: // e.g. 10->8
if (source_bitdepth == 10)
do_convert_uint_floyd_c<pixel_t_s, pixel_t_d, chroma, fulls, fulld, 2, false, 10>(srcp8, dstp8, src_rowsize, src_height, src_pitch, dst_pitch, source_bitdepth, target_bitdepth, dither_target_bitdepth);
else
do_convert_uint_floyd_c<pixel_t_s, pixel_t_d, chroma, fulls, fulld, 2, false, -1>(srcp8, dstp8, src_rowsize, src_height, src_pitch, dst_pitch, source_bitdepth, target_bitdepth, dither_target_bitdepth);
break;
case 4: // e.g. 12->8
do_convert_uint_floyd_c<pixel_t_s, pixel_t_d, chroma, fulls, fulld, 4, false, -1>(srcp8, dstp8, src_rowsize, src_height, src_pitch, dst_pitch, source_bitdepth, target_bitdepth, dither_target_bitdepth);
break;
case 6: // e.g. 16->10, 14->8
// prevent invalid templates to generate
// like do_convert_uint_floyd_c<unsigned short,unsigned char,0,0,1,6,0,16> which would do 16->8 but dither to 10 bit.
if constexpr (sizeof(pixel_t_s) == 2 && sizeof(pixel_t_d) == 2) {
if (source_bitdepth == 16)
do_convert_uint_floyd_c<pixel_t_s, pixel_t_d, chroma, fulls, fulld, 6, false, 16>(srcp8, dstp8, src_rowsize, src_height, src_pitch, dst_pitch, source_bitdepth, target_bitdepth, dither_target_bitdepth);
else
do_convert_uint_floyd_c<pixel_t_s, pixel_t_d, chroma, fulls, fulld, 6, false, -1>(srcp8, dstp8, src_rowsize, src_height, src_pitch, dst_pitch, source_bitdepth, target_bitdepth, dither_target_bitdepth);
} else
do_convert_uint_floyd_c<pixel_t_s, pixel_t_d, chroma, fulls, fulld, 6, false, -1>(srcp8, dstp8, src_rowsize, src_height, src_pitch, dst_pitch, source_bitdepth, target_bitdepth, dither_target_bitdepth);
break;
case 8: // e.g. 16->8
if (sizeof(pixel_t_s) == 2 && source_bitdepth == 16)
do_convert_uint_floyd_c<pixel_t_s, pixel_t_d, chroma, fulls, fulld, 8, false, 16>(srcp8, dstp8, src_rowsize, src_height, src_pitch, dst_pitch, source_bitdepth, target_bitdepth, dither_target_bitdepth);
else
do_convert_uint_floyd_c<pixel_t_s, pixel_t_d, chroma, fulls, fulld, 8, false, -1>(srcp8, dstp8, src_rowsize, src_height, src_pitch, dst_pitch, source_bitdepth, target_bitdepth, dither_target_bitdepth);
break;
default: // difference is more than 8 or exotic dither to less than 8 bits, we accept 10-15% speed minus
do_convert_uint_floyd_c<pixel_t_s, pixel_t_d, chroma, fulls, fulld, -1, false, -1>(srcp8, dstp8, src_rowsize, src_height, src_pitch, dst_pitch, source_bitdepth, target_bitdepth, dither_target_bitdepth);
}
}
else {
do_convert_uint_floyd_c<pixel_t_s, pixel_t_d, chroma, fulls, fulld, -1, false, -1>(srcp8, dstp8, src_rowsize, src_height, src_pitch, dst_pitch, source_bitdepth, target_bitdepth, dither_target_bitdepth);
}
}
}
// float to 8-16 bits
template<typename pixel_t, bool chroma, bool fulls, bool fulld>
static void convert_32_to_uintN_c(const BYTE *srcp, BYTE *dstp, int src_rowsize, int src_height, int src_pitch, int dst_pitch, int source_bitdepth, int target_bitdepth, int dither_target_bitdepth)
{
const float *srcp0 = reinterpret_cast<const float *>(srcp);
pixel_t *dstp0 = reinterpret_cast<pixel_t *>(dstp);
src_pitch = src_pitch / sizeof(float);
dst_pitch = dst_pitch / sizeof(pixel_t);
const int src_width = src_rowsize / sizeof(float);
//-----------------------
bits_conv_constants d;
get_bits_conv_constants(d, chroma, fulls, fulld, source_bitdepth, target_bitdepth);
auto dst_offset_plus_round = d.dst_offset + 0.5f;
constexpr auto dst_pixel_min = 0;
const auto dst_pixel_max = (1 << target_bitdepth) - 1;
for(int y=0; y<src_height; y++)
{
for (int x = 0; x < src_width; x++)
{
const int pixel = (int)((srcp0[x] - d.src_offset) * d.mul_factor + dst_offset_plus_round);
dstp0[x] = pixel_t(clamp(pixel, dst_pixel_min, dst_pixel_max));
}
dstp0 += dst_pitch;
srcp0 += src_pitch;
}
}
// YUV: bit shift 8-16 <=> 8-16 bits
// shift right or left, depending on expandrange
template<typename pixel_t_s, typename pixel_t_d>
static void convert_uint_limited_c(const BYTE* srcp, BYTE* dstp, int src_rowsize, int src_height, int src_pitch, int dst_pitch, int source_bitdepth, int target_bitdepth, int dither_target_bitdepth)
{
const pixel_t_s* srcp0 = reinterpret_cast<const pixel_t_s*>(srcp);
pixel_t_d* dstp0 = reinterpret_cast<pixel_t_d*>(dstp);
src_pitch = src_pitch / sizeof(pixel_t_s);
dst_pitch = dst_pitch / sizeof(pixel_t_d);
const int src_width = src_rowsize / sizeof(pixel_t_s);
if (target_bitdepth > source_bitdepth) // expandrange
{
const int shift_bits = target_bitdepth - source_bitdepth;
for (int y = 0; y < src_height; y++)
{
for (int x = 0; x < src_width; x++) {
dstp0[x] = (pixel_t_d)(srcp0[x]) << shift_bits; // expand range. No clamp before, source is assumed to have valid range
}
dstp0 += dst_pitch;
srcp0 += src_pitch;
}
}
else
{
// reduce range
const int shift_bits = source_bitdepth - target_bitdepth;
const int round = 1 << (shift_bits - 1);
const int target_max = (1 << target_bitdepth) - 1;
constexpr auto target_min = 0;
for (int y = 0; y < src_height; y++)
{
for (int x = 0; x < src_width; x++) {
dstp0[x] = clamp((srcp0[x] + round) >> shift_bits, target_min, target_max);; // reduce range
}
dstp0 += dst_pitch;
srcp0 += src_pitch;
}
}
}
// chroma is special in full range
template<typename pixel_t_s, typename pixel_t_d, bool chroma, bool fulls, bool fulld>
static void convert_uint_c(const BYTE* srcp, BYTE* dstp, int src_rowsize, int src_height, int src_pitch, int dst_pitch, int source_bitdepth, int target_bitdepth, int dither_target_bitdepth)
{
// limited to limited is bitshift, see in other function
if constexpr (!fulls && !fulld) {
convert_uint_limited_c< pixel_t_s, pixel_t_d>(srcp, dstp, src_rowsize, src_height, src_pitch, dst_pitch, source_bitdepth, target_bitdepth, dither_target_bitdepth);
return;
}
const pixel_t_s* srcp0 = reinterpret_cast<const pixel_t_s*>(srcp);
pixel_t_d* dstp0 = reinterpret_cast<pixel_t_d*>(dstp);
src_pitch = src_pitch / sizeof(pixel_t_s);
dst_pitch = dst_pitch / sizeof(pixel_t_d);
const int src_width = src_rowsize / sizeof(pixel_t_s);
if constexpr (sizeof(pixel_t_s) == 1 && sizeof(pixel_t_d) == 2) {
if (fulls && fulld && !chroma && source_bitdepth == 8 && target_bitdepth == 16) {
// special case * 65535 / 255 = *257 exactly
for (int y = 0; y < src_height; y++)
{
for (int x = 0; x < src_width; x++)
{
dstp0[x] = (pixel_t_d)(srcp0[x] * 257);
}
dstp0 += dst_pitch;
srcp0 += src_pitch;
}
return;
}
}
const int target_max = (1 << target_bitdepth) - 1;
bits_conv_constants d;
get_bits_conv_constants(d, chroma, fulls, fulld, source_bitdepth, target_bitdepth);
auto dst_offset_plus_round = d.dst_offset + 0.5f;
constexpr auto target_min = 0;
for (int y = 0; y < src_height; y++) {
for (int x = 0; x < src_width; x++)
{
const float val = (srcp0[x] - d.src_offset_i) * d.mul_factor + dst_offset_plus_round;
dstp0[x] = clamp((int)val, target_min, target_max);
}
dstp0 += dst_pitch;
srcp0 += src_pitch;
}
}
// 8 bit to float, 16/14/12/10 bits to float
template<typename pixel_t, bool chroma, bool fulls, bool fulld>
static void convert_uintN_to_float_c(const BYTE *srcp, BYTE *dstp, int src_rowsize, int src_height, int src_pitch, int dst_pitch, int source_bitdepth, int target_bitdepth, int dither_target_bitdepth)
{
const pixel_t *srcp0 = reinterpret_cast<const pixel_t *>(srcp);
float *dstp0 = reinterpret_cast<float *>(dstp);
src_pitch = src_pitch / sizeof(pixel_t);
dst_pitch = dst_pitch / sizeof(float);
const int src_width = src_rowsize / sizeof(pixel_t);
//-----------------------
bits_conv_constants d;
get_bits_conv_constants(d, chroma, fulls, fulld, source_bitdepth, target_bitdepth);
for (int y = 0; y < src_height; y++)
{
for (int x = 0; x < src_width; x++)
{
const float pixel = (srcp0[x] - d.src_offset_i) * d.mul_factor + d.dst_offset;
dstp0[x] = pixel; // no clamp
}
dstp0 += dst_pitch;
srcp0 += src_pitch;
}
}
// float to float
template<bool chroma, bool fulls, bool fulld>
static void convert_float_to_float_c(const BYTE* srcp, BYTE* dstp, int src_rowsize, int src_height, int src_pitch, int dst_pitch, int source_bitdepth, int target_bitdepth, int dither_target_bitdepth)
{
// float is good if always full range. For historical reasons Avisynth has "limited" range float,
// which is simply a /255.0 reduction of original byte pixels
const float* srcp0 = reinterpret_cast<const float*>(srcp);
float* dstp0 = reinterpret_cast<float*>(dstp);
src_pitch = src_pitch / sizeof(float);
dst_pitch = dst_pitch / sizeof(float);
const int src_width = src_rowsize / sizeof(float);
//-----------------------
bits_conv_constants d;
get_bits_conv_constants(d, chroma, fulls, fulld, source_bitdepth, target_bitdepth);
for (int y = 0; y < src_height; y++)
{
for (int x = 0; x < src_width; x++)
{
const float pixel = (srcp0[x] - d.src_offset) * d.mul_factor + d.dst_offset;
dstp0[x] = pixel; // no clamp
}
dstp0 += dst_pitch;
srcp0 += src_pitch;
}
}
static void get_convert_32_to_uintN_functions(int target_bitdepth, bool fulls, bool fulld,
#ifdef INTEL_INTRINSICS
bool sse2, bool sse4, bool avx2,
#endif
BitDepthConvFuncPtr& conv_function, BitDepthConvFuncPtr& conv_function_chroma, BitDepthConvFuncPtr& conv_function_a)
{
// 32bit->8-16bits support fulls fulld
// pure C
#define convert_32_to_uintN_functions(uint_X_t) \
conv_function_a = convert_32_to_uintN_c<uint_X_t, false, true, true>; /* full-full */ \
if (fulls && fulld) { \
conv_function = convert_32_to_uintN_c<uint_X_t, false, true, true>; \
conv_function_chroma = convert_32_to_uintN_c<uint_X_t, true, true, true>; \
} \
else if (fulls && !fulld) { \
conv_function = convert_32_to_uintN_c<uint_X_t, false, true, false>; \
conv_function_chroma = convert_32_to_uintN_c<uint_X_t, true, true, false>; \
} \
else if (!fulls && fulld) { \
conv_function = convert_32_to_uintN_c<uint_X_t, false, false, true>; \
conv_function_chroma = convert_32_to_uintN_c<uint_X_t, true, false, true>; \
} \
else if (!fulls && !fulld) { \
conv_function = convert_32_to_uintN_c<uint_X_t, false, false, false>; \
conv_function_chroma = convert_32_to_uintN_c<uint_X_t, true, false, false>; \
}
#ifdef INTEL_INTRINSICS
#undef convert_32_to_uintN_functions
#define convert_32_to_uintN_functions(uint_X_t) \
conv_function_a = avx2 ? convert_32_to_uintN_avx2<uint_X_t, false, true, true> : sse4 ? convert_32_to_uintN_sse41<uint_X_t, false, true, true> : convert_32_to_uintN_c<uint_X_t, false, true, true>; /* full-full */ \
if (fulls && fulld) { \
conv_function = avx2 ? convert_32_to_uintN_avx2<uint_X_t, false, true, true> : sse4 ? convert_32_to_uintN_sse41<uint_X_t, false, true, true> : convert_32_to_uintN_c<uint_X_t, false, true, true>; \
conv_function_chroma = avx2 ? convert_32_to_uintN_avx2<uint_X_t, true, true, true> : sse4 ? convert_32_to_uintN_sse41<uint_X_t, true, true, true> : convert_32_to_uintN_c<uint_X_t, true, true, true>; \
} \
else if (fulls && !fulld) { \
conv_function = avx2 ? convert_32_to_uintN_avx2<uint_X_t, false, true, false> : sse4 ? convert_32_to_uintN_sse41<uint_X_t, false, true, false> : convert_32_to_uintN_c<uint_X_t, false, true, false>; \
conv_function_chroma = avx2 ? convert_32_to_uintN_avx2<uint_X_t, true, true, false> : sse4 ? convert_32_to_uintN_sse41<uint_X_t, true, true, false> : convert_32_to_uintN_c<uint_X_t, true, true, false>; \
} \
else if (!fulls && fulld) { \
conv_function = avx2 ? convert_32_to_uintN_avx2<uint_X_t, false, false, true> : sse4 ? convert_32_to_uintN_sse41<uint_X_t, false, false, true> : convert_32_to_uintN_c<uint_X_t, false, false, true>; \
conv_function_chroma = avx2 ? convert_32_to_uintN_avx2<uint_X_t, true, false, true> : sse4 ? convert_32_to_uintN_sse41<uint_X_t, true, false, true> : convert_32_to_uintN_c<uint_X_t, true, false, true>; \
} \
else if (!fulls && !fulld) { \
conv_function = avx2 ? convert_32_to_uintN_avx2<uint_X_t, false, false, false> : sse4 ? convert_32_to_uintN_sse41<uint_X_t, false, false, false> : convert_32_to_uintN_c<uint_X_t, false, false, false>; \
conv_function_chroma = avx2 ? convert_32_to_uintN_avx2<uint_X_t, true, false, false> : sse4 ? convert_32_to_uintN_sse41<uint_X_t, true, false, false> : convert_32_to_uintN_c<uint_X_t, true, false, false>; \
}
#endif
switch (target_bitdepth)
{
case 8:
convert_32_to_uintN_functions(uint8_t); // all variations of fulls fulld
break;
default:
// 10-16 bits
convert_32_to_uintN_functions(uint16_t); // all variations of fulls fulld
break;
}
#undef convert_32_to_uintN_functions
}
static void get_convert_float_to_float_functions(bool fulls, bool fulld,
BitDepthConvFuncPtr& conv_function, BitDepthConvFuncPtr& conv_function_chroma, BitDepthConvFuncPtr& conv_function_a)
{
// 32bit->32bits support fulls fulld, alpha is always full-full
conv_function_a = convert_float_to_float_c<false, true, true>; /* full-full */
if (fulls && fulld) {
conv_function = convert_float_to_float_c<false, true, true>;
conv_function_chroma = convert_float_to_float_c<true, true, true>;
}
else if (fulls && !fulld) {
conv_function = convert_float_to_float_c<false, true, false>;
conv_function_chroma = convert_float_to_float_c<true, true, false>;
}
else if (!fulls && fulld) { \
conv_function = convert_float_to_float_c<false, false, true>;
conv_function_chroma = convert_float_to_float_c<true, false, true>;
}
else if (!fulls && !fulld) {
conv_function = convert_float_to_float_c<false, false, false>;
conv_function_chroma = convert_float_to_float_c<true, false, false>;
}
}
static void get_convert_uintN_to_float_functions(int bits_per_pixel, bool fulls, bool fulld,
#ifdef INTEL_INTRINSICS
bool sse2, bool sse4, bool avx2,
#endif
BitDepthConvFuncPtr& conv_function, BitDepthConvFuncPtr& conv_function_chroma, BitDepthConvFuncPtr& conv_function_a)
{
// 8-16bit->32bits support fulls fulld, alpha is always full-full
#define convert_uintN_to_float_functions(uint_X_t) \
conv_function_a = convert_uintN_to_float_c<uint_X_t, false, true, true>; /* full-full */ \
if (fulls && fulld) { \
conv_function = convert_uintN_to_float_c<uint_X_t, false, true, true>; \
conv_function_chroma = convert_uintN_to_float_c<uint_X_t, true, true, true>; \
} \
else if (fulls && !fulld) { \
conv_function = convert_uintN_to_float_c<uint_X_t, false, true, false>; \
conv_function_chroma = convert_uintN_to_float_c<uint_X_t, true, true, false>; \
} \
else if (!fulls && fulld) { \
conv_function = convert_uintN_to_float_c<uint_X_t, false, false, true>; \
conv_function_chroma = convert_uintN_to_float_c<uint_X_t, true, false, true>; \
} \
else if (!fulls && !fulld) { \
conv_function = convert_uintN_to_float_c<uint_X_t, false, false, false>; \
conv_function_chroma = convert_uintN_to_float_c<uint_X_t, true, false, false>; \
}
#define convert_uintN_to_float_functions_avx2(uint_X_t) \
conv_function_a = convert_uintN_to_float_avx2<uint_X_t, false, true, true>; /* full-full */ \
if (fulls && fulld) { \
conv_function = convert_uintN_to_float_avx2<uint_X_t, false, true, true>; \
conv_function_chroma = convert_uintN_to_float_avx2<uint_X_t, true, true, true>; \
} \
else if (fulls && !fulld) { \
conv_function = convert_uintN_to_float_avx2<uint_X_t, false, true, false>; \
conv_function_chroma = convert_uintN_to_float_avx2<uint_X_t, true, true, false>; \
} \
else if (!fulls && fulld) { \
conv_function = convert_uintN_to_float_avx2<uint_X_t, false, false, true>; \
conv_function_chroma = convert_uintN_to_float_avx2<uint_X_t, true, false, true>; \
} \
else if (!fulls && !fulld) { \
conv_function = convert_uintN_to_float_avx2<uint_X_t, false, false, false>; \
conv_function_chroma = convert_uintN_to_float_avx2<uint_X_t, true, false, false>; \
}
switch (bits_per_pixel) {
case 8:
convert_uintN_to_float_functions(uint8_t);
break;
default: // 10-16 bits
convert_uintN_to_float_functions(uint16_t);
break;
}
#ifdef INTEL_INTRINSICS
if (avx2) {
switch (bits_per_pixel) {
case 8:
convert_uintN_to_float_functions_avx2(uint8_t);
break;
default: // 10-16 bits
convert_uintN_to_float_functions_avx2(uint16_t);
break;
}
}
#endif
#undef convert_uintN_to_float_functions
}
static void get_convert_uintN_to_uintN_ordered_dither_functions(int source_bitdepth, int target_bitdepth, bool fulls, bool fulld,
#ifdef INTEL_INTRINSICS
bool sse2, bool sse4, bool avx2,
#endif
BitDepthConvFuncPtr& conv_function, BitDepthConvFuncPtr& conv_function_chroma)
{
// 8-16->8-16 bits support any fulls fulld combination
// dither has no "conv_function_a"
// pure C
#define convert_uintN_to_uintN_ordered_dither_functions(uint_X_t, uint_X_dest_t) \
if (fulls && fulld) { \
conv_function = convert_ordered_dither_uint_c<uint_X_t, uint_X_dest_t, false, true, true>; \
conv_function_chroma = convert_ordered_dither_uint_c<uint_X_t, uint_X_dest_t, true, true, true>; \
} \
else if (fulls && !fulld) { \
conv_function = convert_ordered_dither_uint_c<uint_X_t, uint_X_dest_t, false, true, false>; \
conv_function_chroma = convert_ordered_dither_uint_c<uint_X_t, uint_X_dest_t, true, true, false>; \
} \
else if (!fulls && fulld) { \
conv_function = convert_ordered_dither_uint_c<uint_X_t, uint_X_dest_t, false, false, true>; \
conv_function_chroma = convert_ordered_dither_uint_c<uint_X_t, uint_X_dest_t, true, false, true>; \
} \
else if (!fulls && !fulld) { \
conv_function = convert_ordered_dither_uint_c<uint_X_t, uint_X_dest_t, false, false, false>; \
conv_function_chroma = convert_ordered_dither_uint_c<uint_X_t, uint_X_dest_t, true, false, false>; \
}
#ifdef INTEL_INTRINSICS
#undef convert_uintN_to_uintN_ordered_dither_functions
// dither has no "conv_function_a"
#define convert_uintN_to_uintN_ordered_dither_functions(uint_X_t, uint_X_dest_t) \
if (fulls && fulld) { \
conv_function = avx2 ? convert_ordered_dither_uint_avx2<uint_X_t, uint_X_dest_t, false, true, true> : sse4 ? convert_ordered_dither_uint_sse41<uint_X_t, uint_X_dest_t, false, true, true> : convert_ordered_dither_uint_c<uint_X_t, uint_X_dest_t, false, true, true>; \
conv_function_chroma = avx2 ? convert_ordered_dither_uint_avx2<uint_X_t, uint_X_dest_t, true, true, true> : sse4 ? convert_ordered_dither_uint_sse41<uint_X_t, uint_X_dest_t, true, true, true> : convert_ordered_dither_uint_c<uint_X_t, uint_X_dest_t, true, true, true>; \
} \
else if (fulls && !fulld) { \
conv_function = avx2 ? convert_ordered_dither_uint_avx2<uint_X_t, uint_X_dest_t, false, true, false> : sse4 ? convert_ordered_dither_uint_sse41<uint_X_t, uint_X_dest_t, false, true, false> : convert_ordered_dither_uint_c<uint_X_t, uint_X_dest_t, false, true, false>; \
conv_function_chroma = avx2 ? convert_ordered_dither_uint_avx2<uint_X_t, uint_X_dest_t, true, true, false> : sse4 ? convert_ordered_dither_uint_sse41<uint_X_t, uint_X_dest_t, true, true, false> : convert_ordered_dither_uint_c<uint_X_t, uint_X_dest_t, true, true, false>; \
} \
else if (!fulls && fulld) { \
conv_function = avx2 ? convert_ordered_dither_uint_avx2<uint_X_t, uint_X_dest_t, false, false, true> : sse4 ? convert_ordered_dither_uint_sse41<uint_X_t, uint_X_dest_t, false, false, true> : convert_ordered_dither_uint_c<uint_X_t, uint_X_dest_t, false, false, true>; \
conv_function_chroma = avx2 ? convert_ordered_dither_uint_avx2<uint_X_t, uint_X_dest_t, true, false, true> : sse4 ? convert_ordered_dither_uint_sse41<uint_X_t, uint_X_dest_t, true, false, true> : convert_ordered_dither_uint_c<uint_X_t, uint_X_dest_t, true, false, true>; \
} \
else if (!fulls && !fulld) { \
conv_function = avx2 ? convert_ordered_dither_uint_avx2<uint_X_t, uint_X_dest_t, false, false, false> : sse4 ? convert_ordered_dither_uint_sse41<uint_X_t, uint_X_dest_t, false, false, false> : convert_ordered_dither_uint_c<uint_X_t, uint_X_dest_t, false, false, false>; \
conv_function_chroma = avx2 ? convert_ordered_dither_uint_avx2<uint_X_t, uint_X_dest_t, true, false, false> : sse4 ? convert_ordered_dither_uint_sse41<uint_X_t, uint_X_dest_t, true, false, false> : convert_ordered_dither_uint_c<uint_X_t, uint_X_dest_t, true, false, false>; \
}
#endif
// all variations of fulls fulld byte/word source/target
switch (target_bitdepth)
{
case 8:
if (source_bitdepth == 8) {
convert_uintN_to_uintN_ordered_dither_functions(uint8_t, uint8_t);
}
else {
convert_uintN_to_uintN_ordered_dither_functions(uint16_t, uint8_t);
}
break;
default:
// uint16_t target is always uint16_t source
convert_uintN_to_uintN_ordered_dither_functions(uint16_t, uint16_t);
break;
}
#undef convert_uintN_to_uintN_ordered_dither_functions
}
static void get_convert_uintN_to_uintN_floyd_dither_functions(int source_bitdepth, int target_bitdepth, bool fulls, bool fulld,
BitDepthConvFuncPtr& conv_function, BitDepthConvFuncPtr& conv_function_chroma)
{
// 8-16->8-16 bits support any fulls fulld combination
// dither has no "conv_function_a"
// pure C
#define convert_uintN_to_uintN_floyd_dither_functions(uint_X_t, uint_X_dest_t) \
if (fulls && fulld) { \
conv_function = convert_uint_floyd_c<uint_X_t, uint_X_dest_t, false, true, true>; \
conv_function_chroma = convert_uint_floyd_c<uint_X_t, uint_X_dest_t, true, true, true>; \
} \
else if (fulls && !fulld) { \
conv_function = convert_uint_floyd_c<uint_X_t, uint_X_dest_t, false, true, false>; \
conv_function_chroma = convert_uint_floyd_c<uint_X_t, uint_X_dest_t, true, true, false>; \
} \
else if (!fulls && fulld) { \
conv_function = convert_uint_floyd_c<uint_X_t, uint_X_dest_t, false, false, true>; \
conv_function_chroma = convert_uint_floyd_c<uint_X_t, uint_X_dest_t, true, false, true>; \
} \
else if (!fulls && !fulld) { \
conv_function = convert_uint_floyd_c<uint_X_t, uint_X_dest_t, false, false, false>; \
conv_function_chroma = convert_uint_floyd_c<uint_X_t, uint_X_dest_t, true, false, false>; \
}
// all variations of fulls fulld byte/word source/target
switch (target_bitdepth)
{
case 8:
if (source_bitdepth == 8) {
convert_uintN_to_uintN_floyd_dither_functions(uint8_t, uint8_t);
}
else {
convert_uintN_to_uintN_floyd_dither_functions(uint16_t, uint8_t);
}
break;
default:
// uint16_t target is always uint16_t source
convert_uintN_to_uintN_floyd_dither_functions(uint16_t, uint16_t);
break;
}
#undef convert_uintN_to_uintN_floyd_dither_functions
}
static void get_convert_uintN_to_uintN_functions(int source_bitdepth, int target_bitdepth, bool fulls, bool fulld,
#ifdef INTEL_INTRINSICS
bool sse2, bool sse4, bool avx2,
#endif
BitDepthConvFuncPtr& conv_function, BitDepthConvFuncPtr& conv_function_chroma, BitDepthConvFuncPtr& conv_function_a)
{
// 8-16->8-16 bits support any fulls fulld combination
// pure C
#define convert_uintN_to_uintN_functions(uint_X_t, uint_X_dest_t) \
conv_function_a = convert_uint_c<uint_X_t, uint_X_dest_t, false, true, true>; /* full-full */ \
if (fulls && fulld) { \
conv_function = convert_uint_c<uint_X_t, uint_X_dest_t, false, true, true>; \
conv_function_chroma = convert_uint_c<uint_X_t, uint_X_dest_t, true, true, true>; \
} \
else if (fulls && !fulld) { \
conv_function = convert_uint_c<uint_X_t, uint_X_dest_t, false, true, false>; \
conv_function_chroma = convert_uint_c<uint_X_t, uint_X_dest_t, true, true, false>; \
} \
else if (!fulls && fulld) { \
conv_function = convert_uint_c<uint_X_t, uint_X_dest_t, false, false, true>; \
conv_function_chroma = convert_uint_c<uint_X_t, uint_X_dest_t, true, false, true>; \
} \
else if (!fulls && !fulld) { \
conv_function = convert_uint_c<uint_X_t, uint_X_dest_t, false, false, false>; \
conv_function_chroma = convert_uint_c<uint_X_t, uint_X_dest_t, true, false, false>; \
}
#ifdef INTEL_INTRINSICS
#undef convert_uintN_to_uintN_functions
#define convert_uintN_to_uintN_functions(uint_X_t, uint_X_dest_t) \
conv_function_a = avx2 ? convert_uint_avx2<uint_X_t, uint_X_dest_t, false, true, true> : sse4 ? convert_uint_sse41<uint_X_t, uint_X_dest_t, false, true, true> : convert_uint_c<uint_X_t, uint_X_dest_t, false, true, true>; /* full-full */ \
if (fulls && fulld) { \
conv_function = avx2 ? convert_uint_avx2<uint_X_t, uint_X_dest_t, false, true, true> : sse4 ? convert_uint_sse41<uint_X_t, uint_X_dest_t, false, true, true> : convert_uint_c<uint_X_t, uint_X_dest_t, false, true, true>; \
conv_function_chroma = avx2 ? convert_uint_avx2<uint_X_t, uint_X_dest_t, true, true, true> : sse4 ? convert_uint_sse41<uint_X_t, uint_X_dest_t, true, true, true> : convert_uint_c<uint_X_t, uint_X_dest_t, true, true, true>; \
} \
else if (fulls && !fulld) { \
conv_function = avx2 ? convert_uint_avx2<uint_X_t, uint_X_dest_t, false, true, false> : sse4 ? convert_uint_sse41<uint_X_t, uint_X_dest_t, false, true, false> : convert_uint_c<uint_X_t, uint_X_dest_t, false, true, false>; \
conv_function_chroma = avx2 ? convert_uint_avx2<uint_X_t, uint_X_dest_t, true, true, false> : sse4 ? convert_uint_sse41<uint_X_t, uint_X_dest_t, true, true, false> : convert_uint_c<uint_X_t, uint_X_dest_t, true, true, false>; \
} \
else if (!fulls && fulld) { \
conv_function = avx2 ? convert_uint_avx2<uint_X_t, uint_X_dest_t, false, false, true> : sse4 ? convert_uint_sse41<uint_X_t, uint_X_dest_t, false, false, true> : convert_uint_c<uint_X_t, uint_X_dest_t, false, false, true>; \
conv_function_chroma = avx2 ? convert_uint_avx2<uint_X_t, uint_X_dest_t, true, false, true> : sse4 ? convert_uint_sse41<uint_X_t, uint_X_dest_t, true, false, true> : convert_uint_c<uint_X_t, uint_X_dest_t, true, false, true>; \
} \
else if (!fulls && !fulld) { \
conv_function = avx2 ? convert_uint_avx2<uint_X_t, uint_X_dest_t, false, false, false> : sse4 ? convert_uint_sse41<uint_X_t, uint_X_dest_t, false, false, false> : convert_uint_c<uint_X_t, uint_X_dest_t, false, false, false>; \
conv_function_chroma = avx2 ? convert_uint_avx2<uint_X_t, uint_X_dest_t, true, false, false> : sse4 ? convert_uint_sse41<uint_X_t, uint_X_dest_t, true, false, false> : convert_uint_c<uint_X_t, uint_X_dest_t, true, false, false>; \
}
#endif
// all variations of fulls fulld byte/word source/target
switch (target_bitdepth)
{
case 8:
if (source_bitdepth == 8) {
convert_uintN_to_uintN_functions(uint8_t, uint8_t);
}
else {
convert_uintN_to_uintN_functions(uint16_t, uint8_t);
}
break;
default:
// 10-16 bits
if (source_bitdepth == 8)
{
convert_uintN_to_uintN_functions(uint8_t, uint16_t);
}
else {
convert_uintN_to_uintN_functions(uint16_t, uint16_t);
}
break;
}
#undef convert_uintN_to_uintN_functions
}
void get_convert_any_bits_functions(int dither_mode, int source_bitdepth, int target_bitdepth, bool fulls, bool fulld,
#ifdef INTEL_INTRINSICS
bool sse2, bool sse4, bool avx2,
#endif
BitDepthConvFuncPtr& conv_function, BitDepthConvFuncPtr& conv_function_chroma, BitDepthConvFuncPtr& conv_function_a)
{
if (source_bitdepth <= 16 && target_bitdepth <= 16)
{
// get basic non-dithered versions
#ifdef INTEL_INTRINSICS
get_convert_uintN_to_uintN_functions(source_bitdepth, target_bitdepth, fulls, fulld, sse2, sse4, avx2, conv_function, conv_function_chroma, conv_function_a);
#else
get_convert_uintN_to_uintN_functions(source_bitdepth, target_bitdepth, fulls, fulld, conv_function, conv_function_chroma, conv_function_a);
#endif
if (target_bitdepth <= source_bitdepth) {
// dither is only down
if (dither_mode == 0) {
// ordered dither
#ifdef INTEL_INTRINSICS
get_convert_uintN_to_uintN_ordered_dither_functions(source_bitdepth, target_bitdepth, fulls, fulld, sse2, sse4, avx2, conv_function, conv_function_chroma);
#else
get_convert_uintN_to_uintN_ordered_dither_functions(source_bitdepth, target_bitdepth, fulls, fulld, conv_function, conv_function_chroma);
#endif
}
else if (dither_mode == 1) {
// Floyd, no SIMD there
get_convert_uintN_to_uintN_floyd_dither_functions(source_bitdepth, target_bitdepth, fulls, fulld, conv_function, conv_function_chroma);
}
}
}
// 32->8-16 bit
if (source_bitdepth == 32 && target_bitdepth <= 16) {
#ifdef INTEL_INTRINSICS
get_convert_32_to_uintN_functions(target_bitdepth, fulls, fulld, sse2, sse4, avx2, conv_function, conv_function_chroma, conv_function_a);
#else
get_convert_32_to_uintN_functions(target_bitdepth, fulls, fulld, conv_function, conv_function_chroma, conv_function_a);
#endif
}
// 8-32->32
if (target_bitdepth == 32) {
if (source_bitdepth <= 16) // 8-16->32 bit
#ifdef INTEL_INTRINSICS
get_convert_uintN_to_float_functions(source_bitdepth, fulls, fulld, sse2, sse4, avx2, conv_function, conv_function_chroma, conv_function_a);
#else
get_convert_uintN_to_float_functions(source_bitdepth, fulls, fulld, conv_function, conv_function_chroma, conv_function_a);
#endif
else
get_convert_float_to_float_functions(fulls, fulld, conv_function, conv_function_chroma, conv_function_a);
}
}
ConvertBits::ConvertBits(PClip _child, const int _dither_mode, const int _target_bitdepth, bool _truerange,
int _ColorRange_src, int _ColorRange_dest,
int _dither_bitdepth, IScriptEnvironment* env) :
GenericVideoFilter(_child),
conv_function(nullptr), conv_function_chroma(nullptr), conv_function_a(nullptr),
target_bitdepth(_target_bitdepth), dither_mode(_dither_mode), dither_bitdepth(_dither_bitdepth),
fulls(false), fulld(false), truerange(_truerange)
{
pixelsize = vi.ComponentSize();
bits_per_pixel = vi.BitsPerComponent();
format_change_only = false;
#ifdef INTEL_INTRINSICS
const bool sse2 = !!(env->GetCPUFlags() & CPUF_SSE2);
const bool sse4 = !!(env->GetCPUFlags() & CPUF_SSE4_1);
const bool avx2 = !!(env->GetCPUFlags() & CPUF_AVX2);
#endif
// full or limited decision
// dest: if undefined, use src
if (_ColorRange_dest != ColorRange_Compat_e::AVS_COLORRANGE_LIMITED && _ColorRange_dest != ColorRange_Compat_e::AVS_COLORRANGE_FULL) {
_ColorRange_dest = _ColorRange_src;
}
//
fulls = _ColorRange_src == ColorRange_Compat_e::AVS_COLORRANGE_FULL;
fulld = _ColorRange_dest == ColorRange_Compat_e::AVS_COLORRANGE_FULL;
if (!truerange) {
if ((target_bitdepth == 8 || target_bitdepth == 32) && pixelsize == 2)
bits_per_pixel = 16;
if (target_bitdepth > 8 && target_bitdepth <= 16 && (bits_per_pixel == 8 || bits_per_pixel == 32))
target_bitdepth = 16;
if (target_bitdepth > 8 && target_bitdepth <= 16 && bits_per_pixel > 8 && bits_per_pixel <= 16)
format_change_only = true;
}
#ifdef INTEL_INTRINSICS
get_convert_any_bits_functions(dither_mode, bits_per_pixel, target_bitdepth, fulls, fulld, sse2, sse4, avx2, conv_function, conv_function_chroma, conv_function_a);
#else
get_convert_any_bits_functions(dither_mode, bits_per_pixel, target_bitdepth, fulls, fulld, conv_function, conv_function_chroma, conv_function_a);
#endif
// Set VideoInfo
if (target_bitdepth == 8) {
if (vi.NumComponents() == 1)
vi.pixel_type = VideoInfo::CS_Y8;
else if (vi.IsYV411())
vi.pixel_type = VideoInfo::CS_YV411;
else if (vi.Is420() || vi.IsYV12())
vi.pixel_type = vi.IsYUVA() ? VideoInfo::CS_YUVA420 : VideoInfo::CS_YV12;
else if (vi.Is422())
vi.pixel_type = vi.IsYUVA() ? VideoInfo::CS_YUVA422 : VideoInfo::CS_YV16;
else if (vi.Is444())
vi.pixel_type = vi.IsYUVA() ? VideoInfo::CS_YUVA444 : VideoInfo::CS_YV24;
else if (vi.IsRGB48() || vi.IsRGB24())
vi.pixel_type = VideoInfo::CS_BGR24;
else if (vi.IsRGB64() || vi.IsRGB32())
vi.pixel_type = VideoInfo::CS_BGR32;
else if (vi.IsPlanarRGB())
vi.pixel_type = VideoInfo::CS_RGBP;
else if (vi.IsPlanarRGBA())
vi.pixel_type = VideoInfo::CS_RGBAP;
else
env->ThrowError("ConvertTo8bit: unsupported color space");
return;
}
else if (target_bitdepth > 8 && target_bitdepth <= 16) {
// set output vi format
if (vi.IsRGB24() || vi.IsRGB48()) {
vi.pixel_type = VideoInfo::CS_BGR48;
}
else if (vi.IsRGB32() || vi.IsRGB64()) {
vi.pixel_type = VideoInfo::CS_BGR64;
}
else {
// Y or YUV(A) or PlanarRGB(A)
if (vi.IsYV12()) // YV12 can have an exotic compatibility constant
vi.pixel_type = VideoInfo::CS_YV12; // override for known
int new_bitdepth_bits;
switch (target_bitdepth) {
case 8: new_bitdepth_bits = VideoInfo::CS_Sample_Bits_8; break;
case 10: new_bitdepth_bits = VideoInfo::CS_Sample_Bits_10; break;
case 12: new_bitdepth_bits = VideoInfo::CS_Sample_Bits_12; break;
case 14: new_bitdepth_bits = VideoInfo::CS_Sample_Bits_14; break;
case 16: new_bitdepth_bits = VideoInfo::CS_Sample_Bits_16; break;
case 32: new_bitdepth_bits = VideoInfo::CS_Sample_Bits_32; break;
}
vi.pixel_type = (vi.pixel_type & ~VideoInfo::CS_Sample_Bits_Mask) | new_bitdepth_bits;
}
return;
}
else if (target_bitdepth == 32) {
if (vi.NumComponents() == 1)
vi.pixel_type = VideoInfo::CS_Y32;
else if (vi.Is420())
vi.pixel_type = vi.IsYUVA() ? VideoInfo::CS_YUVA420PS : VideoInfo::CS_YUV420PS;
else if (vi.Is422())
vi.pixel_type = vi.IsYUVA() ? VideoInfo::CS_YUVA422PS : VideoInfo::CS_YUV422PS;
else if (vi.Is444())
vi.pixel_type = vi.IsYUVA() ? VideoInfo::CS_YUVA444PS : VideoInfo::CS_YUV444PS;
else if (vi.IsPlanarRGB())
vi.pixel_type = VideoInfo::CS_RGBPS;
else if (vi.IsPlanarRGBA())
vi.pixel_type = VideoInfo::CS_RGBAPS;
else
env->ThrowError("ConvertToFloat: unsupported color space");
return;
}
env->ThrowError("ConvertBits: unsupported target bit-depth (%d)", target_bitdepth);
}
AVSValue __cdecl ConvertBits::Create(AVSValue args, void* user_data, IScriptEnvironment* env) {
PClip clip = args[0].AsClip();
//0 1 2 3 4 5 6
//c[bits]i[truerange]b[dither]i[dither_bits]i[fulls]b[fulld]b
const VideoInfo &vi = clip->GetVideoInfo();
int create_param = (int)reinterpret_cast<intptr_t>(user_data);
// when converting from/true 10-16 bit formats, truerange=false indicates bitdepth of 16 bits regardless of the 10-12-14 bit format
// FIXME: stop supporting this parameter (a workaround in the dawn of hbd?)
bool assume_truerange = args[2].AsBool(true); // n/a for non planar formats
int source_bitdepth = vi.BitsPerComponent();
// default comes from old legacy To8,To16,ToFloat functions
// or the clip's actual bit depth
const int default_target_bitdepth = create_param == 0 ? source_bitdepth : create_param;
int target_bitdepth = args[1].AsInt(default_target_bitdepth); // "bits" parameter
int dither_bitdepth = args[4].AsInt(target_bitdepth); // "dither_bits" parameter
if(target_bitdepth!=8 && target_bitdepth!=10 && target_bitdepth!=12 && target_bitdepth!=14 && target_bitdepth!=16 && target_bitdepth!=32)
env->ThrowError("ConvertBits: invalid bit depth: %d", target_bitdepth);
if(create_param == 8 && target_bitdepth !=8)
env->ThrowError("ConvertTo8Bit: invalid bit depth: %d", target_bitdepth);
if(create_param == 32 && target_bitdepth !=32)
env->ThrowError("ConvertToFloat: invalid bit depth: %d", target_bitdepth);
if(create_param == 16 && (target_bitdepth == 8 || target_bitdepth ==32))
env->ThrowError("ConvertTo16bit: invalid bit depth: %d", target_bitdepth);
if (args[2].Defined()) {
if (!vi.IsPlanar())
env->ThrowError("ConvertBits: truerange specified for non-planar source");
}
// retrieve full/limited
int ColorRange_src;
int ColorRange_dest;
if (args[5].Defined())
ColorRange_src = args[5].AsBool() ? ColorRange_Compat_e::AVS_COLORRANGE_FULL : ColorRange_Compat_e::AVS_COLORRANGE_LIMITED;
else
ColorRange_src = -1; // undefined. A frame property may override
if (args[6].Defined())
ColorRange_dest = args[6].AsBool() ? ColorRange_Compat_e::AVS_COLORRANGE_FULL : ColorRange_Compat_e::AVS_COLORRANGE_LIMITED;
else
ColorRange_dest = -1; // undefined. A frame property or ColorRange_src may override
if (ColorRange_src != ColorRange_Compat_e::AVS_COLORRANGE_LIMITED && ColorRange_src != ColorRange_Compat_e::AVS_COLORRANGE_FULL) {
// try getting frame props if parameter is not specified
auto frame0 = clip->GetFrame(0, env);
const AVSMap* props = env->getFramePropsRO(frame0);
if (env->propNumElements(props, "_ColorRange") > 0) {
ColorRange_src = (int)env->propGetIntSaturated(props, "_ColorRange", 0, nullptr);
}
else {
// no param, no frame property -> rgb is full others are limited
ColorRange_src = vi.IsRGB() ? ColorRange_Compat_e::AVS_COLORRANGE_FULL : ColorRange_Compat_e::AVS_COLORRANGE_LIMITED;
}
}
// cr_dest = cr_source if not specified
if (ColorRange_dest != ColorRange_Compat_e::AVS_COLORRANGE_LIMITED && ColorRange_dest != ColorRange_Compat_e::AVS_COLORRANGE_FULL) {
ColorRange_dest = ColorRange_src;
}
bool fulls = ColorRange_src == ColorRange_Compat_e::AVS_COLORRANGE_FULL;
bool fulld = ColorRange_dest == ColorRange_Compat_e::AVS_COLORRANGE_FULL;
int dither_type = args[3].AsInt(-1);
bool dither_defined = args[3].Defined();
if(dither_defined && dither_type != 1 && dither_type != 0 && dither_type != -1)
env->ThrowError("ConvertBits: invalid dither type parameter. Only -1 (disabled), 0 (ordered dither) or 1 (Floyd-S) is allowed");
if (dither_type >= 0) {
if (source_bitdepth < target_bitdepth)
env->ThrowError("ConvertBits: dithering is allowed only for scale down");
if (dither_bitdepth > target_bitdepth)
env->ThrowError("ConvertBits: dither_bits must be <= target bitdepth");
if (target_bitdepth == 32)
env->ThrowError("ConvertBits: dithering is not allowed into 32 bit float target");
}
// 3.7.1 t25
// Unfortunately 32 bit float dithering is not implemented, thus we convert to 16 bit
// intermediate clip
if (source_bitdepth == 32 && (dither_type == 0 || dither_type == 1)) {
// c[bits]i[truerange]b[dither]i[dither_bits]i[fulls]b[fulld]b
source_bitdepth = 16;
// solving ordered dither maximum bit depth difference of 8 problem
// by automatic preconversion
if (dither_type == 0 && source_bitdepth - dither_bitdepth > 8) {
source_bitdepth = dither_bitdepth + 8;
if (source_bitdepth % 2)
source_bitdepth--; // must be even
}
AVSValue new_args[7] = { clip, source_bitdepth, true, -1 /* no dither */, AVSValue() /*dither_bits*/, fulls, fulld };
clip = env->Invoke("ConvertBits", AVSValue(new_args, 7)).AsClip();
clip = env->Invoke("Cache", AVSValue(clip)).AsClip();
// and now the source range becomes the previous target
fulls = fulld;
ColorRange_src = ColorRange_dest;
}
// solving ordered dither maximum bit depth difference of 8 problem
// by automatic preconversion
if (source_bitdepth <= 16 && dither_type == 0 && source_bitdepth - dither_bitdepth > 8) {
// c[bits]i[truerange]b[dither]i[dither_bits]i[fulls]b[fulld]b
source_bitdepth = dither_bitdepth + 8;
if (source_bitdepth % 2)
source_bitdepth--; // must be even
AVSValue new_args[7] = { clip, source_bitdepth, true, -1 /* no dither */, AVSValue() /*dither_bits*/, fulls, fulld };
clip = env->Invoke("ConvertBits", AVSValue(new_args, 7)).AsClip();
clip = env->Invoke("Cache", AVSValue(clip)).AsClip();
// and now the source range becomes the previous target
fulls = fulld;
ColorRange_src = ColorRange_dest;
}
if (source_bitdepth == dither_bitdepth)
dither_type = -1; // ignore dithering
if(dither_type == 0) {
if (dither_bitdepth < 1 || dither_bitdepth > 16)
env->ThrowError("ConvertBits: ordered dither: invalid dither_bits specified (1-16 allowed)");
// this error message cannot appear if the automatic bit depth reducing conversions above are done
if(source_bitdepth - dither_bitdepth > 8)
env->ThrowError("ConvertBits: dither_bits cannot differ with more than 8 bits from source");
}
// floyd
if (dither_type == 1) {
if (dither_bitdepth < 1 || dither_bitdepth > 16)
env->ThrowError("ConvertBits: Floyd-S: invalid dither_bits specified (1-16 allowed)");
}
// no change -> return unmodified if no transform required
if (source_bitdepth == target_bitdepth) { // 10->10 .. 16->16
if((dither_type < 0 || dither_bitdepth == target_bitdepth) && fulls == fulld)
return clip;
}
// YUY2 conversion is limited
if (vi.IsYUY2()) {
if (target_bitdepth != 8)
env->ThrowError("ConvertBits: YUY2 input must stay in 8 bits");
}
if (vi.IsYV411()) {
if (target_bitdepth != 8)
env->ThrowError("ConvertBits: YV411 input must stay in 8 bits");
}
// packed RGB conversion is limited
if (vi.IsRGB() && !vi.IsPlanar()) {
if (target_bitdepth != 8 && target_bitdepth != 16)
env->ThrowError("ConvertBits: invalid bit-depth for packed RGB formats, only 8 or 16 possible");
}
// remark
// source_10_bit.ConvertTo16bit(truerange=true) : upscale range
// source_10_bit.ConvertTo16bit(truerange=false) : leaves data, only format conversion
// source_10_bit.ConvertTo16bit(bits=12,truerange=true) : upscale range from 10 to 12
// source_10_bit.ConvertTo16bit(bits=12,truerange=false) : leaves data, only format conversion
// source_16_bit.ConvertTo16bit(bits=10, truerange=true) : downscale range
// source_16_bit.ConvertTo16bit(bits=10, truerange=false) : leaves data, only format conversion
// yuy2 is autoconverted to/from YV16. fulls-fulld and dither to lower bit depths are supported
bool need_convert_yuy2 = vi.IsYUY2();
// for dither, planar rgb conversion happens
bool need_convert_24 = vi.IsRGB24() && dither_type >= 0;
bool need_convert_32 = vi.IsRGB32() && dither_type >= 0;
bool need_convert_48 = vi.IsRGB48() && dither_type >= 0;
bool need_convert_64 = vi.IsRGB64() && dither_type >= 0;
// convert to planar on the fly if dither was asked
if (need_convert_24 || need_convert_48) {
AVSValue new_args[1] = { clip };
clip = env->Invoke("ConvertToPlanarRGB", AVSValue(new_args, 1)).AsClip();
}
else if (need_convert_32 || need_convert_64) {
AVSValue new_args[1] = { clip };
clip = env->Invoke("ConvertToPlanarRGBA", AVSValue(new_args, 1)).AsClip();
}
else if (need_convert_yuy2) {
AVSValue new_args[1] = { clip };
clip = env->Invoke("ConvertToYV16", AVSValue(new_args, 1)).AsClip();
}
AVSValue result = new ConvertBits(clip, dither_type, target_bitdepth, assume_truerange, ColorRange_src, ColorRange_dest, dither_bitdepth, env);
// convert back to packed rgb from planar on the fly
if (need_convert_24 || need_convert_48) {
AVSValue new_args[1] = { result };
if(target_bitdepth == 8)
result = env->Invoke("ConvertToRGB24", AVSValue(new_args, 1)).AsClip();
else
result = env->Invoke("ConvertToRGB48", AVSValue(new_args, 1)).AsClip();
} else if (need_convert_32 || need_convert_64) {
AVSValue new_args[1] = { result };
if (target_bitdepth == 8)
result = env->Invoke("ConvertToRGB32", AVSValue(new_args, 1)).AsClip();
else
result = env->Invoke("ConvertToRGB64", AVSValue(new_args, 1)).AsClip();
}
else if (need_convert_yuy2) {
AVSValue new_args[1] = { result };
result = env->Invoke("ConvertToYUY2", AVSValue(new_args, 1)).AsClip();
}
return result;
}
PVideoFrame __stdcall ConvertBits::GetFrame(int n, IScriptEnvironment* env) {
PVideoFrame src = child->GetFrame(n, env);
if (format_change_only)
{
// for 10-16 bit: simple format override in constructor
env->MakeWritable(&src);
src->AmendPixelType(vi.pixel_type);
return src;
}
PVideoFrame dst = env->NewVideoFrameP(vi, &src);
auto props = env->getFramePropsRW(dst);
update_ColorRange(props, fulld ? ColorRange_Compat_e::AVS_COLORRANGE_FULL : ColorRange_Compat_e::AVS_COLORRANGE_LIMITED, env);
if(vi.IsPlanar())
{
int planes_y[4] = { PLANAR_Y, PLANAR_U, PLANAR_V, PLANAR_A };
int planes_r[4] = { PLANAR_G, PLANAR_B, PLANAR_R, PLANAR_A };
int *planes = (vi.IsYUV() || vi.IsYUVA()) ? planes_y : planes_r;
for (int p = 0; p < vi.NumComponents(); ++p) {
const int plane = planes[p];
if (plane == PLANAR_A) {
if (conv_function_a == nullptr)
env->BitBlt(dst->GetWritePtr(plane), dst->GetPitch(plane), src->GetReadPtr(plane), src->GetPitch(plane), src->GetRowSize(plane), src->GetHeight(plane));
else
conv_function_a(src->GetReadPtr(plane), dst->GetWritePtr(plane),
src->GetRowSize(plane), src->GetHeight(plane),
src->GetPitch(plane), dst->GetPitch(plane),
bits_per_pixel, target_bitdepth, dither_bitdepth
);
}
else if (conv_function == nullptr)
env->BitBlt(dst->GetWritePtr(plane), dst->GetPitch(plane), src->GetReadPtr(plane), src->GetPitch(plane), src->GetRowSize(plane), src->GetHeight(plane));
else {
const bool chroma = (plane == PLANAR_U || plane == PLANAR_V);
if (chroma && conv_function_chroma != nullptr)
// 32bit float and 8-16 when full-range involved needs separate signed-aware conversion
conv_function_chroma(src->GetReadPtr(plane), dst->GetWritePtr(plane),
src->GetRowSize(plane), src->GetHeight(plane),
src->GetPitch(plane), dst->GetPitch(plane),
bits_per_pixel, target_bitdepth, dither_bitdepth);
else
conv_function(src->GetReadPtr(plane), dst->GetWritePtr(plane),
src->GetRowSize(plane), src->GetHeight(plane),
src->GetPitch(plane), dst->GetPitch(plane),
bits_per_pixel, target_bitdepth, dither_bitdepth);
}
}
}
else {
// packed RGBs
conv_function(src->GetReadPtr(), dst->GetWritePtr(),
src->GetRowSize(), src->GetHeight(),
src->GetPitch(), dst->GetPitch(),
bits_per_pixel, target_bitdepth, dither_bitdepth);
}
return dst;
}
================================================
FILE: avs_core/convert/convert_bits.h
================================================
// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.
// http://avisynth.nl
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA, or visit
// http://www.gnu.org/copyleft/gpl.html .
//
// Linking Avisynth statically or dynamically with other modules is making a
// combined work based on Avisynth. Thus, the terms and conditions of the GNU
// General Public License cover the whole combination.
//
// As a special exception, the copyright holders of Avisynth give you
// permission to link Avisynth with independent modules that communicate with
// Avisynth solely through the interfaces defined in avisynth.h, regardless of the license
// terms of these independent modules, and to copy and distribute the
// resulting combined work under terms of your choice, provided that
// every copy of the combined work is accompanied by a complete copy of
// the source code of Avisynth (the version of Avisynth used to produce the
// combined work), being distributed under the terms of the GNU General
// Public License plus this exception. An independent module is a module
// which is not derived from or based on Avisynth, such as 3rd-party filters,
// import and export plugins, or graphical user interfaces.
#ifndef __Convert_bits_H__
#define __Convert_bits_H__
#include <avisynth.h>
#include <stdint.h>
#include "convert.h"
// in convert_bits.cpp
// repeated 8x for sse size 16
extern const BYTE dither2x2a_data[4];
// cycle: 2
extern const BYTE dither2x2a_data_sse2[2 * 16];
// e.g. 10->8 bits
// repeated 8x for sse size 16
extern const BYTE dither2x2_data[4];
// cycle: 2
extern const BYTE dither2x2_data_sse2[2 * 16];
// e.g. 8->5 bits
extern const BYTE dither4x4a_data[16];
// cycle: 4
extern const BYTE dither4x4a_data_sse2[4 * 16];
// e.g. 12->8 bits
extern const BYTE dither4x4_data[16];
// cycle: 4
extern const BYTE dither4x4_data_sse2[4 * 16];
// e.g. 14->9 bits
extern const BYTE dither8x8a_data[8][8];
// cycle: 8
extern const BYTE dither8x8a_data_sse2[8][16];
// e.g. 14->8 bits
extern const BYTE dither8x8_data[8][8];
// cycle: 8
extern const BYTE dither8x8_data_sse2[8][16];
// e.g. 16->9 or 8->1 bits
// cycle: 16x. No special 16 byte sse2
extern const BYTE dither16x16a_data[16][16];
// 16->8
// cycle: 16x. No special 16 byte sse2
extern const BYTE dither16x16_data[16][16];
typedef void (*BitDepthConvFuncPtr)(const BYTE *srcp, BYTE *dstp, int src_rowsize, int src_height, int src_pitch, int dst_pitch, int source_bitdepth, int target_bitdepth, int dither_target_bitdepth);
class ConvertBits : public GenericVideoFilter
{
public:
ConvertBits(PClip _child, const int _dither_mode, const int _target_bitdepth, bool _truerange, int _ColorRange_src, int _ColorRange_dest, int _dither_bitdepth, IScriptEnvironment* env);
PVideoFrame __stdcall GetFrame(int n,IScriptEnvironment* env) override;
int __stdcall SetCacheHints(int cachehints, int frame_range) override {
AVS_UNUSED(frame_range);
return cachehints == CACHE_GET_MTMODE ? MT_NICE_FILTER : 0;
}
static AVSValue __cdecl Create(AVSValue args, void*, IScriptEnvironment* env);
private:
BitDepthConvFuncPtr conv_function;
BitDepthConvFuncPtr conv_function_chroma; // 32bit float YUV chroma
BitDepthConvFuncPtr conv_function_a;
int target_bitdepth;
int dither_mode;
int dither_bitdepth;
bool fulls; // source is full range (defaults: rgb=true, yuv=false (bit shift))
bool fulld; // destination is full range (defaults: rgb=true, yuv=false (bit shift))
bool truerange; // if 16->10 range reducing or e.g. 14->16 bit range expansion needed
int pixelsize;
int bits_per_pixel;
bool format_change_only;
};
void get_convert_any_bits_functions(int dither_mode, int source_bitdepth, int target_bitdepth, bool fulls, bool fulld,
#ifdef INTEL_INTRINSICS
bool sse2, bool sse4, bool avx2,
#endif
BitDepthConvFuncPtr& conv_function, BitDepthConvFuncPtr& conv_function_chroma, BitDepthConvFuncPtr& conv_function_a);
/**********************************
****** Bitdepth conversions *****
**********************************/
#endif // __Convert_bits_H__
=========================
gitextract_jlxsglop/
├── .editorconfig
├── .gitattributes
├── .github/
│ └── workflows/
│ └── build.yml
├── .gitignore
├── .gitmodules
├── .readthedocs.yaml
├── CMakeLists.txt
├── README.md
├── avs_core/
│ ├── CMakeLists.txt
│ ├── Files.cmake
│ ├── TargetArch.cmake
│ ├── Version.cmake
│ ├── avisynth.pc.in
│ ├── avisynth_conf.h.in
│ ├── convert/
│ │ ├── convert.cpp
│ │ ├── convert.h
│ │ ├── convert_audio.cpp
│ │ ├── convert_audio.h
│ │ ├── convert_audio_c.cpp
│ │ ├── convert_bits.cpp
│ │ ├── convert_bits.h
│ │ ├── convert_helper.cpp
│ │ ├── convert_helper.h
│ │ ├── convert_matrix.cpp
│ │ ├── convert_matrix.h
│ │ ├── convert_planar.cpp
│ │ ├── convert_planar.h
│ │ ├── convert_rgb.cpp
│ │ ├── convert_rgb.h
│ │ └── intel/
│ │ ├── convert_audio_avx2.cpp
│ │ ├── convert_audio_sse.cpp
│ │ ├── convert_bits_avx2.cpp
│ │ ├── convert_bits_avx2.h
│ │ ├── convert_bits_sse.cpp
│ │ ├── convert_bits_sse.h
│ │ ├── convert_planar_avx2.cpp
│ │ ├── convert_planar_avx2.h
│ │ ├── convert_planar_sse.cpp
│ │ ├── convert_planar_sse.h
│ │ ├── convert_rgb_avx2.cpp
│ │ ├── convert_rgb_avx2.h
│ │ ├── convert_rgb_avx512.cpp
│ │ ├── convert_rgb_avx512.h
│ │ ├── convert_rgb_sse.cpp
│ │ └── convert_rgb_sse.h
│ ├── core/
│ │ ├── AVSMap.h
│ │ ├── AviHelper.cpp
│ │ ├── AviHelper.h
│ │ ├── BufferPool.cpp
│ │ ├── BufferPool.h
│ │ ├── CompatEnvironment.h
│ │ ├── DeviceManager.cpp
│ │ ├── DeviceManager.h
│ │ ├── FilterConstructor.cpp
│ │ ├── FilterConstructor.h
│ │ ├── FilterGraph.cpp
│ │ ├── FilterGraph.h
│ │ ├── InternalEnvironment.h
│ │ ├── LruCache.h
│ │ ├── MTGuard.cpp
│ │ ├── MTGuard.h
│ │ ├── MappedList.h
│ │ ├── ObjectPool.h
│ │ ├── PluginManager.cpp
│ │ ├── PluginManager.h
│ │ ├── Prefetcher.cpp
│ │ ├── Prefetcher.h
│ │ ├── ScriptEnvironmentTLS.h
│ │ ├── SimpleLruCache.h
│ │ ├── ThreadPool.cpp
│ │ ├── ThreadPool.h
│ │ ├── alignplanar.cpp
│ │ ├── alignplanar.h
│ │ ├── arch.h.in
│ │ ├── audio.cpp
│ │ ├── audio.h
│ │ ├── avisynth.cpp
│ │ ├── avisynth.def
│ │ ├── avisynth.rc
│ │ ├── avisynth64.def
│ │ ├── avisynth_c.cpp
│ │ ├── avs_simd_c.h
│ │ ├── bitblt.cpp
│ │ ├── bitblt.h
│ │ ├── cache.cpp
│ │ ├── cache.h
│ │ ├── clip_info.h
│ │ ├── cpuid.cpp
│ │ ├── exception.cpp
│ │ ├── exception.h
│ │ ├── findfirst.h
│ │ ├── fonts/
│ │ │ ├── fixedfonts.cpp
│ │ │ └── fixedfonts.h
│ │ ├── function.h
│ │ ├── info.cpp
│ │ ├── info.h
│ │ ├── initguid.cpp
│ │ ├── interface.cpp
│ │ ├── internal.h
│ │ ├── main.cpp
│ │ ├── memcpy_amd.cpp
│ │ ├── memcpy_amd.h
│ │ ├── mpmc_bounded_queue.h
│ │ ├── parser/
│ │ │ ├── expression.cpp
│ │ │ ├── expression.h
│ │ │ ├── os/
│ │ │ │ ├── win32_string_compat.cpp
│ │ │ │ └── win32_string_compat.h
│ │ │ ├── script.cpp
│ │ │ ├── script.h
│ │ │ ├── scriptparser.cpp
│ │ │ ├── scriptparser.h
│ │ │ ├── tokenizer.cpp
│ │ │ └── tokenizer.h
│ │ ├── strings.cpp
│ │ ├── strings.h
│ │ ├── vartable.h
│ │ └── version.h.in
│ ├── filters/
│ │ ├── AviSource/
│ │ │ ├── AVIIndex.cpp
│ │ │ ├── AVIIndex.h
│ │ │ ├── AVIReadHandler.cpp
│ │ │ ├── AVIReadHandler.h
│ │ │ ├── AudioSource.cpp
│ │ │ ├── AudioSource.h
│ │ │ ├── DubSource.cpp
│ │ │ ├── DubSource.h
│ │ │ ├── Error.h
│ │ │ ├── FastReadStream.cpp
│ │ │ ├── FastReadStream.h
│ │ │ ├── File64.cpp
│ │ │ ├── File64.h
│ │ │ ├── Fixes.h
│ │ │ ├── VD_Audio.cpp
│ │ │ ├── VD_Audio.h
│ │ │ ├── avi_source.cpp
│ │ │ ├── avi_source.h
│ │ │ ├── clip_info.h
│ │ │ ├── list.cpp
│ │ │ └── list.h
│ │ ├── aarch64/
│ │ │ ├── turn_neon.cpp
│ │ │ └── turn_neon.h
│ │ ├── color.cpp
│ │ ├── color.h
│ │ ├── colorbars_const.h
│ │ ├── combine.cpp
│ │ ├── combine.h
│ │ ├── conditional/
│ │ │ ├── conditional.cpp
│ │ │ ├── conditional.h
│ │ │ ├── conditional_functions.cpp
│ │ │ ├── conditional_functions.h
│ │ │ ├── conditional_reader.cpp
│ │ │ ├── conditional_reader.h
│ │ │ └── intel/
│ │ │ ├── conditional_functions_sse.cpp
│ │ │ └── conditional_functions_sse.h
│ │ ├── convolution.cpp
│ │ ├── convolution.h
│ │ ├── debug.cpp
│ │ ├── debug.h
│ │ ├── edit.cpp
│ │ ├── edit.h
│ │ ├── exprfilter/
│ │ │ ├── exprfilter.cpp
│ │ │ ├── exprfilter.h
│ │ │ └── jitasm.h
│ │ ├── field.cpp
│ │ ├── field.h
│ │ ├── focus.cpp
│ │ ├── focus.h
│ │ ├── fps.cpp
│ │ ├── fps.h
│ │ ├── greyscale.cpp
│ │ ├── greyscale.h
│ │ ├── histogram.cpp
│ │ ├── histogram.h
│ │ ├── intel/
│ │ │ ├── check_avx512.h
│ │ │ ├── focus_avx2.cpp
│ │ │ ├── focus_avx2.h
│ │ │ ├── focus_sse.cpp
│ │ │ ├── focus_sse.h
│ │ │ ├── greyscale_sse.cpp
│ │ │ ├── greyscale_sse.h
│ │ │ ├── layer_avx2.cpp
│ │ │ ├── layer_avx2.h
│ │ │ ├── layer_sse.cpp
│ │ │ ├── layer_sse.h
│ │ │ ├── limiter_sse.cpp
│ │ │ ├── limiter_sse.h
│ │ │ ├── merge_avx2.cpp
│ │ │ ├── merge_avx2.h
│ │ │ ├── merge_sse.cpp
│ │ │ ├── merge_sse.h
│ │ │ ├── planeswap_sse.cpp
│ │ │ ├── planeswap_sse.h
│ │ │ ├── resample_avx2.cpp
│ │ │ ├── resample_avx2.h
│ │ │ ├── resample_avx512.cpp
│ │ │ ├── resample_avx512.h
│ │ │ ├── resample_avx512.hpp
│ │ │ ├── resample_avx512b.cpp
│ │ │ ├── resample_sse.cpp
│ │ │ ├── resample_sse.h
│ │ │ ├── resize_sse.cpp
│ │ │ ├── resize_sse.h
│ │ │ ├── text-overlay_sse.cpp
│ │ │ ├── text-overlay_sse.h
│ │ │ ├── turn_avx2.cpp
│ │ │ ├── turn_avx2.h
│ │ │ ├── turn_sse.cpp
│ │ │ └── turn_sse.h
│ │ ├── layer.cpp
│ │ ├── layer.h
│ │ ├── layer.hpp
│ │ ├── levels.cpp
│ │ ├── levels.h
│ │ ├── limiter.cpp
│ │ ├── limiter.h
│ │ ├── merge.cpp
│ │ ├── merge.h
│ │ ├── misc.cpp
│ │ ├── misc.h
│ │ ├── overlay/
│ │ │ ├── 444convert.cpp
│ │ │ ├── 444convert.h
│ │ │ ├── OF_add.cpp
│ │ │ ├── OF_blend.cpp
│ │ │ ├── OF_darken.cpp
│ │ │ ├── OF_difference.cpp
│ │ │ ├── OF_exclusion.cpp
│ │ │ ├── OF_multiply.cpp
│ │ │ ├── OF_softhardlight.cpp
│ │ │ ├── aarch64/
│ │ │ │ ├── blend_common_neon.cpp
│ │ │ │ └── blend_common_neon.h
│ │ │ ├── blend_common.cpp
│ │ │ ├── blend_common.h
│ │ │ ├── imghelpers.h
│ │ │ ├── intel/
│ │ │ │ ├── 444convert_sse.cpp
│ │ │ │ ├── 444convert_sse.h
│ │ │ │ ├── OF_multiply_avx2.cpp
│ │ │ │ ├── OF_multiply_avx2.h
│ │ │ │ ├── OF_multiply_sse.cpp
│ │ │ │ ├── OF_multiply_sse.h
│ │ │ │ ├── blend_common_avx2.cpp
│ │ │ │ ├── blend_common_avx2.h
│ │ │ │ ├── blend_common_sse.cpp
│ │ │ │ └── blend_common_sse.h
│ │ │ ├── overlay.cpp
│ │ │ ├── overlay.h
│ │ │ └── overlayfunctions.h
│ │ ├── planeswap.cpp
│ │ ├── planeswap.h
│ │ ├── resample.cpp
│ │ ├── resample.h
│ │ ├── resample_functions.cpp
│ │ ├── resample_functions.h
│ │ ├── resize.cpp
│ │ ├── resize.h
│ │ ├── source.cpp
│ │ ├── text-overlay.cpp
│ │ ├── text-overlay.h
│ │ ├── transform.cpp
│ │ ├── transform.h
│ │ ├── turn.cpp
│ │ └── turn.h
│ └── include/
│ ├── avisynth.h
│ ├── avisynth_c.h
│ └── avs/
│ ├── alignment.h
│ ├── capi.h
│ ├── config.h
│ ├── cpuid.h
│ ├── filesystem.h
│ ├── minmax.h
│ ├── posix.h
│ ├── types.h
│ └── win.h
├── cmake_uninstall.cmake.in
├── distrib/
│ ├── AviSynth_Template.reg
│ ├── ColorPresets/
│ │ ├── colors_rgb.avsi
│ │ └── colors_rgb.txt
│ ├── Examples/
│ │ ├── Audio.avs
│ │ ├── Authors.avs
│ │ ├── Editing.avs
│ │ ├── Equalizer Presets/
│ │ │ ├── 1965.feq
│ │ │ ├── Air.feq
│ │ │ ├── Brittle.feq
│ │ │ ├── Car Stereo.feq
│ │ │ ├── Classic V.feq
│ │ │ ├── Clear.feq
│ │ │ ├── DEATH.feq
│ │ │ ├── Dark.feq
│ │ │ ├── Drums.feq
│ │ │ ├── Flat.feq
│ │ │ ├── Home Theater.feq
│ │ │ ├── Loudness.feq
│ │ │ ├── Pop.feq
│ │ │ ├── Premaster.feq
│ │ │ ├── Presence.feq
│ │ │ ├── Punch & Sparkle.feq
│ │ │ ├── Shimmer.feq
│ │ │ ├── Soft Bass.feq
│ │ │ └── Strings.feq
│ │ ├── Processing.avs
│ │ ├── Syntax.avs
│ │ └── Version.avs
│ ├── OFL.TXT
│ ├── Prerequisites/
│ │ └── keep.me
│ ├── Readme/
│ │ └── readme_history.txt
│ ├── WinInstaller/
│ │ ├── Translations/
│ │ │ ├── cs.isl
│ │ │ ├── de.isl
│ │ │ ├── en.isl
│ │ │ ├── fr.isl
│ │ │ ├── it.isl
│ │ │ ├── ja.isl
│ │ │ ├── pl.isl
│ │ │ ├── pt.isl
│ │ │ ├── pt_br.isl
│ │ │ └── ru.isl
│ │ ├── avisynth+.iss
│ │ ├── avisynth+_arm64.iss
│ │ └── update_git_rev.ps1
│ ├── docs/
│ │ └── english/
│ │ ├── make.bat
│ │ └── source/
│ │ ├── avisynthdoc/
│ │ │ ├── FilterSDK/
│ │ │ │ ├── AMDOptimizationGuide.rst
│ │ │ │ ├── AVSLinkage.rst
│ │ │ │ ├── AssemblerOptimizing.rst
│ │ │ │ ├── AviSynthInterfaceVersion.rst
│ │ │ │ ├── AviSynthTwoFiveAudio.rst
│ │ │ │ ├── AviSynthTwoFivePixelType.rst
│ │ │ │ ├── AviSynthTwoFiveSDK.rst
│ │ │ │ ├── BensAviSynthDocs.rst
│ │ │ │ ├── C_api.rst
│ │ │ │ ├── ChangeFrameSize.rst
│ │ │ │ ├── ColorSpaces.rst
│ │ │ │ ├── ColorspaceProperties.rst
│ │ │ │ ├── CompilingAvisynthPlugins.rst
│ │ │ │ ├── Cplusplus_api.rst
│ │ │ │ ├── DataAlignment.rst
│ │ │ │ ├── DataStorageInAviSynth.rst
│ │ │ │ ├── DebuggingAvisynthPlugins.rst
│ │ │ │ ├── DualPlugins.rst
│ │ │ │ ├── EnvInvoke.rst
│ │ │ │ ├── EnvSaveString.rst
│ │ │ │ ├── FilterSDK.rst
│ │ │ │ ├── GeneralPurposeToMMXRegisters.rst
│ │ │ │ ├── GettingStartedWithAudio.rst
│ │ │ │ ├── GradientMask.rst
│ │ │ │ ├── InstructionPairing.rst
│ │ │ │ ├── IntegerSSE.rst
│ │ │ │ ├── IntelOptimizationGuide.rst
│ │ │ │ ├── InterleavedImageFormat.rst
│ │ │ │ ├── IntermediateMmxOptimization.rst
│ │ │ │ ├── InternalFunctions.rst
│ │ │ │ ├── InvertNeg.rst
│ │ │ │ ├── IsMovntqFaster.rst
│ │ │ │ ├── MMX.rst
│ │ │ │ ├── Non-ClipSample.rst
│ │ │ │ ├── PlanarImageFormat.rst
│ │ │ │ ├── SDKHistory.rst
│ │ │ │ ├── SDKLicense.rst
│ │ │ │ ├── SDKNecessaries.rst
│ │ │ │ ├── SimpleMmxOptimization.rst
│ │ │ │ ├── SimpleSample.rst
│ │ │ │ ├── SimpleSample10b.rst
│ │ │ │ ├── SimpleSample11.rst
│ │ │ │ ├── SimpleSample12.rst
│ │ │ │ ├── SimpleSample13a.rst
│ │ │ │ ├── SimpleSample14.rst
│ │ │ │ ├── SimpleSample15a.rst
│ │ │ │ ├── SimpleSample16.rst
│ │ │ │ ├── SimpleSample17.rst
│ │ │ │ ├── SimpleSample26.rst
│ │ │ │ ├── SimpleSampleClass.rst
│ │ │ │ ├── TwoFiveFastInvert.rst
│ │ │ │ ├── TwoFiveInvert.rst
│ │ │ │ ├── VideoInfo.rst
│ │ │ │ ├── WorkingWithImages.rst
│ │ │ │ ├── WorkingWithPlanarImages.rst
│ │ │ │ ├── avs2pcm.rst
│ │ │ │ └── avs2yuv.rst
│ │ │ ├── advancedtopics/
│ │ │ │ ├── color_conversions.rst
│ │ │ │ ├── colorimetry.rst
│ │ │ │ ├── hybrid_video.rst
│ │ │ │ ├── importing_media.rst
│ │ │ │ ├── interlaced_fieldbased.rst
│ │ │ │ ├── luminance_levels.rst
│ │ │ │ └── sampling.rst
│ │ │ ├── advancedtopics.rst
│ │ │ ├── avisynthplus.rst
│ │ │ ├── changelist.rst
│ │ │ ├── changelist26.rst
│ │ │ ├── changelist34.rst
│ │ │ ├── changelist34pre.rst
│ │ │ ├── changelist35.rst
│ │ │ ├── changelist36.rst
│ │ │ ├── changelist37.rst
│ │ │ ├── changelist371.rst
│ │ │ ├── changelist372.rst
│ │ │ ├── changelist373.rst
│ │ │ ├── changelist374.rst
│ │ │ ├── changelist375.rst
│ │ │ ├── changelist376.rst
│ │ │ ├── contributing/
│ │ │ │ ├── avsplus_external_deps_guide_manual.rst
│ │ │ │ ├── avsplus_external_deps_guide_manual_arm.rst
│ │ │ │ ├── compiling_avsplus.rst
│ │ │ │ ├── contributing_with_git.rst
│ │ │ │ └── posix.rst
│ │ │ ├── corefilters/
│ │ │ │ ├── addborders.rst
│ │ │ │ ├── adjust.rst
│ │ │ │ ├── amplify.rst
│ │ │ │ ├── animate.rst
│ │ │ │ ├── assumerate.rst
│ │ │ │ ├── audiodub.rst
│ │ │ │ ├── avisource.rst
│ │ │ │ ├── blankclip.rst
│ │ │ │ ├── blur.rst
│ │ │ │ ├── bob.rst
│ │ │ │ ├── colorbars.rst
│ │ │ │ ├── colorbarsuhd.rst
│ │ │ │ ├── coloryuv.rst
│ │ │ │ ├── combineplanes.rst
│ │ │ │ ├── compare.rst
│ │ │ │ ├── conditionalfilter.rst
│ │ │ │ ├── conditionalreader.rst
│ │ │ │ ├── convert.rst
│ │ │ │ ├── convertaudio.rst
│ │ │ │ ├── convertbits.rst
│ │ │ │ ├── convertstacked.rst
│ │ │ │ ├── converttomono.rst
│ │ │ │ ├── convolution.rst
│ │ │ │ ├── crop.rst
│ │ │ │ ├── delayaudio.rst
│ │ │ │ ├── deleteframe.rst
│ │ │ │ ├── directshowsource.rst
│ │ │ │ ├── dissolve.rst
│ │ │ │ ├── doubleweave.rst
│ │ │ │ ├── duplicateframe.rst
│ │ │ │ ├── echo.rst
│ │ │ │ ├── ensuresync.rst
│ │ │ │ ├── expr.rst
│ │ │ │ ├── extract.rst
│ │ │ │ ├── fade.rst
│ │ │ │ ├── fixbrokenchromaupsampling.rst
│ │ │ │ ├── fixluminance.rst
│ │ │ │ ├── flip.rst
│ │ │ │ ├── fps.rst
│ │ │ │ ├── freezeframe.rst
│ │ │ │ ├── getchannel.rst
│ │ │ │ ├── greyscale.rst
│ │ │ │ ├── histogram.rst
│ │ │ │ ├── imagesource.rst
│ │ │ │ ├── imagewriter.rst
│ │ │ │ ├── import.rst
│ │ │ │ ├── info.rst
│ │ │ │ ├── interleave.rst
│ │ │ │ ├── invert.rst
│ │ │ │ ├── killaudio.rst
│ │ │ │ ├── layer.rst
│ │ │ │ ├── letterbox.rst
│ │ │ │ ├── levels.rst
│ │ │ │ ├── limiter.rst
│ │ │ │ ├── loop.rst
│ │ │ │ ├── mask.rst
│ │ │ │ ├── maskhs.rst
│ │ │ │ ├── merge.rst
│ │ │ │ ├── mergechannels.rst
│ │ │ │ ├── mergergb.rst
│ │ │ │ ├── message.rst
│ │ │ │ ├── mixaudio.rst
│ │ │ │ ├── monotostereo.rst
│ │ │ │ ├── multioverlay.rst
│ │ │ │ ├── normalize.rst
│ │ │ │ ├── overlay.rst
│ │ │ │ ├── parity.rst
│ │ │ │ ├── peculiar.rst
│ │ │ │ ├── preroll.rst
│ │ │ │ ├── propShow.rst
│ │ │ │ ├── pulldown.rst
│ │ │ │ ├── reduceby2.rst
│ │ │ │ ├── resampleaudio.rst
│ │ │ │ ├── resize.rst
│ │ │ │ ├── reverse.rst
│ │ │ │ ├── segmentedsource.rst
│ │ │ │ ├── select.rst
│ │ │ │ ├── selectevery.rst
│ │ │ │ ├── selectrangeevery.rst
│ │ │ │ ├── separatefields.rst
│ │ │ │ ├── setchannelmask.rst
│ │ │ │ ├── setfilterprop.rst
│ │ │ │ ├── showalpha.rst
│ │ │ │ ├── showfive.rst
│ │ │ │ ├── showframes.rst
│ │ │ │ ├── skewrows.rst
│ │ │ │ ├── soften.rst
│ │ │ │ ├── soundout.rst
│ │ │ │ ├── splice.rst
│ │ │ │ ├── ssrc.rst
│ │ │ │ ├── stack.rst
│ │ │ │ ├── subtitle.rst
│ │ │ │ ├── subtract.rst
│ │ │ │ ├── supereq.rst
│ │ │ │ ├── swap.rst
│ │ │ │ ├── swapfields.rst
│ │ │ │ ├── tcpdeliver.rst
│ │ │ │ ├── timestretch.rst
│ │ │ │ ├── tone.rst
│ │ │ │ ├── trim.rst
│ │ │ │ ├── turn.rst
│ │ │ │ ├── tweak.rst
│ │ │ │ ├── version.rst
│ │ │ │ ├── weave.rst
│ │ │ │ └── write.rst
│ │ │ ├── corefilters.rst
│ │ │ ├── externalplugins.rst
│ │ │ ├── faq/
│ │ │ │ ├── faq.rst
│ │ │ │ ├── faq_common_errors.rst
│ │ │ │ ├── faq_different_types_content.rst
│ │ │ │ ├── faq_frameserving.rst
│ │ │ │ ├── faq_general_info.rst
│ │ │ │ ├── faq_loading_clips.rst
│ │ │ │ ├── faq_sections.rst
│ │ │ │ ├── faq_using_virtualdub_plugins.rst
│ │ │ │ ├── faq_yv12.rst
│ │ │ │ └── troubleshooting.rst
│ │ │ ├── filters_mult_input_clips.rst
│ │ │ ├── getting_started.rst
│ │ │ ├── index.rst
│ │ │ ├── license.rst
│ │ │ ├── links.rst
│ │ │ ├── overview.rst
│ │ │ ├── quick_ref.rst
│ │ │ ├── releasenotes.rst
│ │ │ ├── script_ref/
│ │ │ │ ├── script_ref.rst
│ │ │ │ ├── script_ref_arrays.rst
│ │ │ │ ├── script_ref_block_statements.rst
│ │ │ │ ├── script_ref_execution_model.rst
│ │ │ │ ├── script_ref_execution_model_eval_scripts.rst
│ │ │ │ ├── script_ref_execution_model_fetching_frames.rst
│ │ │ │ ├── script_ref_execution_model_filter_graph.rst
│ │ │ │ ├── script_ref_execution_model_lifetime_variables.rst
│ │ │ │ ├── script_ref_execution_model_perf_cons.rst
│ │ │ │ ├── script_ref_execution_model_sequence_events.rst
│ │ │ │ └── script_ref_user_functions.rst
│ │ │ ├── syntax/
│ │ │ │ ├── syntax.rst
│ │ │ │ ├── syntax_clip_properties.rst
│ │ │ │ ├── syntax_colors.rst
│ │ │ │ ├── syntax_control_structures.rst
│ │ │ │ ├── syntax_formal_avisynth_grammar.rst
│ │ │ │ ├── syntax_function_objects.rst
│ │ │ │ ├── syntax_internal_functions.rst
│ │ │ │ ├── syntax_internal_functions_bit.rst
│ │ │ │ ├── syntax_internal_functions_boolean.rst
│ │ │ │ ├── syntax_internal_functions_control.rst
│ │ │ │ ├── syntax_internal_functions_conversion.rst
│ │ │ │ ├── syntax_internal_functions_debug.rst
│ │ │ │ ├── syntax_internal_functions_frame_properties.rst
│ │ │ │ ├── syntax_internal_functions_function_object.rst
│ │ │ │ ├── syntax_internal_functions_global_options.rst
│ │ │ │ ├── syntax_internal_functions_multithreading.rst
│ │ │ │ ├── syntax_internal_functions_multithreading_new.rst
│ │ │ │ ├── syntax_internal_functions_numeric.rst
│ │ │ │ ├── syntax_internal_functions_runtime.rst
│ │ │ │ ├── syntax_internal_functions_script.rst
│ │ │ │ ├── syntax_internal_functions_string.rst
│ │ │ │ ├── syntax_internal_functions_trig.rst
│ │ │ │ ├── syntax_internal_functions_version.rst
│ │ │ │ ├── syntax_operators.rst
│ │ │ │ ├── syntax_plugins.rst
│ │ │ │ ├── syntax_ref.rst
│ │ │ │ ├── syntax_runtime_environment.rst
│ │ │ │ ├── syntax_script_variables.rst
│ │ │ │ ├── syntax_sections.rst
│ │ │ │ ├── syntax_the_full_grammar.rst
│ │ │ │ └── syntax_userdefined_scriptfunctions.rst
│ │ │ ├── twopointfive.rst
│ │ │ └── twopointsix.rst
│ │ ├── conf.py
│ │ └── index.rst
│ ├── gpl-cs.txt
│ ├── gpl-de.txt
│ ├── gpl-el.txt
│ ├── gpl-fr.txt
│ ├── gpl-it.txt
│ ├── gpl-ja.txt
│ ├── gpl-pl.txt
│ ├── gpl-pt.txt
│ ├── gpl-pt_br.txt
│ ├── gpl-ru.txt
│ ├── gpl.txt
│ ├── lgpl_for_used_libs.txt
│ └── rst_migration_notes.txt
└── plugins/
├── CMakeLists.txt
├── ConvertStacked/
│ ├── CMakeLists.txt
│ └── ConvertStacked.cpp
├── DirectShowSource/
│ ├── CMakeLists.txt
│ ├── directshow_source.cpp
│ └── directshow_source.h
├── ImageSeq/
│ ├── CMakeLists.txt
│ ├── ImageReader.cpp
│ ├── ImageSeq.cpp
│ ├── ImageSeq.h
│ └── ImageWriter.cpp
├── Shibatch/
│ ├── CMakeLists.txt
│ ├── dbesi0.c
│ ├── fft.h
│ ├── mem_block.cpp
│ ├── mem_block.h
│ ├── paramlist.h
│ ├── shibatch.cpp
│ ├── ssrc-convert.cpp
│ ├── ssrc-convert.h
│ ├── ssrc.cpp
│ ├── ssrc.h
│ ├── supereq.cpp
│ ├── supereq.h
│ └── whence.txt
├── TimeStretch/
│ ├── CMakeLists.txt
│ └── TimeStretch.cpp
├── VDubFilter/
│ ├── CMakeLists.txt
│ ├── GetCPUFlags.cpp
│ ├── ScriptInterpreter.h
│ ├── ScriptValue.h
│ ├── VBitmap.h
│ ├── VDubFilter.cpp
│ ├── vdplugin.h
│ └── vdvideofilt.h
└── VFAPIFilter/
├── CMakeLists.txt
└── VFAPIFilter.cpp
Showing preview only (754K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (7263 symbols across 225 files)
FILE: avs_core/convert/convert.cpp
function AVSValue (line 102) | AVSValue __cdecl CreateConvertToAdaptivePackedRGB(AVSValue args, void* u...
function AVSValue (line 145) | AVSValue __cdecl CreateConvertToPackedRGB(AVSValue args, void* user_data...
function AVSValue (line 176) | AVSValue __cdecl CreateConvertToRGB(AVSValue args, void* user_data, IScr...
function AVSValue (line 362) | AVSValue AddAlphaPlane::Create(AVSValue args, void*, IScriptEnvironment*...
function PVideoFrame (line 483) | PVideoFrame AddAlphaPlane::GetFrame(int n, IScriptEnvironment* env)
function AVSValue (line 592) | AVSValue RemoveAlphaPlane::Create(AVSValue args, void*, IScriptEnvironme...
function PVideoFrame (line 632) | PVideoFrame RemoveAlphaPlane::GetFrame(int n, IScriptEnvironment* env)
FILE: avs_core/convert/convert_audio.cpp
function PClip (line 53) | PClip ConvertAudio::Create(PClip clip, int sample_type, int prefered_typ...
FILE: avs_core/convert/convert_audio.h
type CONVERT_DECLARE (line 43) | typedef CONVERT_DECLARE(*convert_proc);
function tempbuffer_size (line 119) | int tempbuffer_size {0}
function convert_proc (line 130) | convert_proc convert_avx2 {nullptr};
FILE: avs_core/convert/convert_audio_c.cpp
function convert32To16 (line 43) | void convert32To16(void *inbuf, void *outbuf, int count) {
function convert16To32 (line 54) | void convert16To32(void *inbuf, void *outbuf, int count) {
function convert32To8 (line 64) | void convert32To8(void* inbuf, void* outbuf, int count) {
function convert8To32 (line 72) | void convert8To32(void *inbuf, void *outbuf, int count) {
function convert16To8 (line 84) | void convert16To8(void *inbuf, void *outbuf, int count) {
function convert8To16 (line 95) | void convert8To16(void *inbuf, void *outbuf, int count) {
function convert32To24 (line 105) | void convert32To24(void *inbuf, void *outbuf, int count) {
function convert24To32 (line 116) | void convert24To32(void *inbuf, void *outbuf, int count) {
function convert24To16 (line 128) | void convert24To16(void *inbuf, void *outbuf, int count) {
function convert16To24 (line 138) | void convert16To24(void *inbuf, void *outbuf, int count) {
function convert24To8 (line 149) | void convert24To8(void *inbuf, void *outbuf, int count) {
function convert8To24 (line 157) | void convert8To24(void *inbuf, void *outbuf, int count) {
function convert8ToFLT (line 168) | void convert8ToFLT(void* inbuf, void* outbuf, int count) {
function convertFLTTo8 (line 177) | void convertFLTTo8(void* inbuf, void* outbuf, int count) {
function convert16ToFLT (line 194) | void convert16ToFLT(void* inbuf, void* outbuf, int count) {
function convertFLTTo16 (line 203) | void convertFLTTo16(void* inbuf, void* outbuf, int count) {
function convert24ToFLT (line 221) | void convert24ToFLT(void* inbuf, void* outbuf, int count) {
function convertFLTTo24 (line 231) | void convertFLTTo24(void* inbuf, void* outbuf, int count) {
function convert32ToFLT (line 253) | void convert32ToFLT(void *inbuf, void *outbuf, int count) {
function convertFLTTo32 (line 262) | void convertFLTTo32(void *inbuf, void *outbuf, int count) {
FILE: avs_core/convert/convert_bits.cpp
function do_convert_ordered_dither_uint_c (line 202) | static void do_convert_ordered_dither_uint_c(const BYTE* srcp8, BYTE* ds...
function convert_ordered_dither_uint_c (line 315) | static void convert_ordered_dither_uint_c(const BYTE* srcp8, BYTE* dstp8...
function AVS_FORCEINLINE (line 334) | static AVS_FORCEINLINE void diffuse_floyd(int err, int &nextError, int *...
function AVS_FORCEINLINE (line 355) | static AVS_FORCEINLINE void diffuse_floyd_f(float err, float& nextError,...
function do_convert_uint_floyd_c (line 379) | static void do_convert_uint_floyd_c(const BYTE* srcp8, BYTE* dstp8, int ...
function convert_uint_floyd_c (line 511) | static void convert_uint_floyd_c(const BYTE* srcp8, BYTE* dstp8, int src...
function convert_32_to_uintN_c (line 563) | static void convert_32_to_uintN_c(const BYTE *srcp, BYTE *dstp, int src_...
function convert_uint_limited_c (line 597) | static void convert_uint_limited_c(const BYTE* srcp, BYTE* dstp, int src...
function convert_uint_c (line 641) | static void convert_uint_c(const BYTE* srcp, BYTE* dstp, int src_rowsize...
function convert_uintN_to_float_c (line 697) | static void convert_uintN_to_float_c(const BYTE *srcp, BYTE *dstp, int s...
function convert_float_to_float_c (line 725) | static void convert_float_to_float_c(const BYTE* srcp, BYTE* dstp, int s...
function get_convert_32_to_uintN_functions (line 753) | static void get_convert_32_to_uintN_functions(int target_bitdepth, bool ...
function get_convert_float_to_float_functions (line 817) | static void get_convert_float_to_float_functions(bool fulls, bool fulld,
function get_convert_uintN_to_float_functions (line 840) | static void get_convert_uintN_to_float_functions(int bits_per_pixel, boo...
function get_convert_uintN_to_uintN_ordered_dither_functions (line 911) | static void get_convert_uintN_to_uintN_ordered_dither_functions(int sour...
function get_convert_uintN_to_uintN_floyd_dither_functions (line 979) | static void get_convert_uintN_to_uintN_floyd_dither_functions(int source...
function get_convert_uintN_to_uintN_functions (line 1024) | static void get_convert_uintN_to_uintN_functions(int source_bitdepth, in...
function get_convert_any_bits_functions (line 1100) | void get_convert_any_bits_functions(int dither_mode, int source_bitdepth...
function AVSValue (line 1271) | AVSValue __cdecl ConvertBits::Create(AVSValue args, void* user_data, ISc...
function PVideoFrame (line 1488) | PVideoFrame __stdcall ConvertBits::GetFrame(int n, IScriptEnvironment* e...
FILE: avs_core/convert/convert_bits.h
function class (line 78) | class ConvertBits : public GenericVideoFilter
FILE: avs_core/convert/convert_helper.cpp
function lookup_table (line 148) | auto lookup_table(const std::vector<std::pair<const char *, T>>& table, ...
function getPrimaries (line 156) | bool getPrimaries(const char* primaries_name, IScriptEnvironment* env, i...
function getMatrix (line 170) | static bool getMatrix(const char* matrix_name, IScriptEnvironment* env, ...
function getChromaLocation (line 184) | static bool getChromaLocation(const char* chromaloc_name, IScriptEnviron...
function getColorRange (line 198) | bool getColorRange(const char* color_range_name, IScriptEnvironment* env...
function getOldMatrix (line 217) | static bool getOldMatrix(const char* matrix_name, int &_Matrix, int &_Co...
function is_paramstring_auto (line 256) | static bool is_paramstring_auto(const std::string ¶m) {
function is_paramstring_same (line 260) | static bool is_paramstring_same(const std::string& param) {
function is_paramstring_empty_or_auto (line 264) | static bool is_paramstring_empty_or_auto(const std::string& param) {
function is_paramstring_empty_or_auto (line 268) | static bool is_paramstring_empty_or_auto(const char* param) {
function matrix_parse_merge_with_props_def (line 275) | void matrix_parse_merge_with_props_def(bool rgb_in, bool rgb_out, const ...
function matrix_parse_merge_with_props (line 375) | void matrix_parse_merge_with_props(bool rgb_in, bool rgb_out, const char...
function chromaloc_parse_merge_with_props (line 381) | void chromaloc_parse_merge_with_props(VideoInfo& vi, const char* chromal...
function export_frame_props (line 402) | void export_frame_props(VideoInfo& vi, AVSMap* props, int _Matrix, int _...
function update_Matrix_and_ColorRange (line 425) | void update_Matrix_and_ColorRange(AVSMap* props, int theMatrix, int theC...
function update_Transfer_and_Primaries (line 445) | void update_Transfer_and_Primaries(AVSMap* props, int theTransfer, int t...
function update_ChromaLocation (line 458) | void update_ChromaLocation(AVSMap* props, int theChromaLocation, IScript...
function update_ColorRange (line 471) | void update_ColorRange(AVSMap* props, int theColorRange, IScriptEnvironm...
FILE: avs_core/convert/convert_helper.h
type ColorRange_e (line 43) | typedef enum ColorRange_e {
type ColorRange_Compat_e (line 50) | typedef enum ColorRange_Compat_e {
type ChromaLocation_e (line 55) | typedef enum ChromaLocation_e {
type FieldBased_e (line 66) | typedef enum FieldBased_e {
type Matrix_e (line 74) | typedef enum Matrix_e {
type Old_Avs_Matrix_e (line 105) | typedef enum Old_Avs_Matrix_e {
type Transfer_e (line 116) | typedef enum Transfer_e {
type Primaries_e (line 135) | typedef enum Primaries_e {
type bits_conv_constants (line 159) | typedef struct bits_conv_constants {
function ConversionDirection (line 239) | enum class ConversionDirection {
FILE: avs_core/convert/convert_matrix.cpp
function BuildMatrix_Rgb2Yuv_core (line 67) | static void BuildMatrix_Rgb2Yuv_core(double Kr, double Kb, int int_arith...
function BuildMatrix_Yuv2Rgb_core (line 209) | static void BuildMatrix_Yuv2Rgb_core(double Kr, double Kb, int int_arith...
function GetKrKb (line 313) | bool GetKrKb(int matrix, double& Kr, double& Kb)
function do_BuildMatrix_Rgb2Yuv (line 328) | bool do_BuildMatrix_Rgb2Yuv(int _Matrix, int _ColorRange, int _ColorRang...
function do_BuildMatrix_Yuv2Rgb (line 355) | bool do_BuildMatrix_Yuv2Rgb(int _Matrix, int _ColorRange, int _ColorRang...
FILE: avs_core/convert/convert_matrix.h
type ConversionMatrix (line 40) | struct ConversionMatrix {
function RGB2YUV_Rec601 (line 78) | inline int RGB2YUV_Rec601(int rgb) // limited range
FILE: avs_core/convert/convert_planar.cpp
function DISABLE_WARNING_PUSH (line 62) | DISABLE_WARNING_PUSH
function fill_plane (line 85) | void fill_plane(uint8_t * dstp, int height, int row_size, int pitch, pix...
function AVSValue (line 111) | AVSValue __cdecl ConvertToPlanarGeneric::CreateY(AVSValue args, void* us...
function convert_rgb24or32_to_yuv444_c (line 257) | static void convert_rgb24or32_to_yuv444_c(BYTE* dstY, BYTE* dstU, BYTE* ...
function PVideoFrame (line 298) | PVideoFrame __stdcall ConvertRGBToYUV444::GetFrame(int n, IScriptEnviron...
function convert_yv24_to_rgb_c (line 553) | static void convert_yv24_to_rgb_c(BYTE* dstp, const BYTE* srcY, const BY...
function convert_yuv_to_planarrgb_c_internal (line 605) | static void convert_yuv_to_planarrgb_c_internal(BYTE* dstp[3], int dstPi...
function convert_yuv_to_planarrgb_c (line 893) | void convert_yuv_to_planarrgb_c(BYTE* dstp[3], int dstPitch[3], const BY...
function PVideoFrame (line 972) | PVideoFrame __stdcall ConvertYUV444ToRGB::GetFrame(int n, IScriptEnviron...
function convert_yuy2_to_y8_c (line 1190) | static void convert_yuy2_to_y8_c(const BYTE* srcp, BYTE* dstp, size_t sr...
function convert_yuy2_to_yv16_c (line 1202) | static void convert_yuy2_to_yv16_c(const BYTE *srcp, BYTE *dstp_y, BYTE ...
function PVideoFrame (line 1221) | PVideoFrame __stdcall ConvertYUY2ToYV16_or_Y::GetFrame(int n, IScriptEnv...
function AVSValue (line 1267) | AVSValue __cdecl ConvertYUY2ToYV16_or_Y::Create(AVSValue args, void*, IS...
function convert_yv16_to_yuy2_c (line 1286) | static void convert_yv16_to_yuy2_c(const BYTE *srcp_y, const BYTE *srcp_...
function PVideoFrame (line 1301) | PVideoFrame __stdcall ConvertYV16ToYUY2::GetFrame(int n, IScriptEnvironm...
function AVSValue (line 1330) | AVSValue __cdecl ConvertYV16ToYUY2::Create(AVSValue args, void*, IScript...
function PVideoFrame (line 1603) | PVideoFrame __stdcall ConvertToPlanarGeneric::GetFrame(int n, IScriptEnv...
function AVSValue (line 1693) | AVSValue ConvertToPlanarGeneric::Create(AVSValue& args, const char* filt...
function AVSValue (line 1964) | AVSValue __cdecl ConvertToPlanarGeneric::CreateYUV420(AVSValue args, voi...
function AVSValue (line 1984) | AVSValue __cdecl ConvertToPlanarGeneric::CreateYUV422(AVSValue args, voi...
function AVSValue (line 2004) | AVSValue __cdecl ConvertToPlanarGeneric::CreateYUV444(AVSValue args, voi...
function AVSValue (line 2025) | AVSValue __cdecl ConvertToPlanarGeneric::CreateYV411(AVSValue args, void...
function AVSValue (line 2042) | AVSValue __cdecl ConvertToPlanarGeneric::CreateConvertToYUY2(AVSValue ar...
function AVSValue (line 2097) | AVSValue __cdecl ConvertToPlanarGeneric::CreateConvertBackToYUY2(AVSValu...
function ResamplingFunction (line 2147) | ResamplingFunction* getResampler(const char* resampler, AVSValue param1,...
FILE: avs_core/convert/convert_planar.h
type YuvRgbConversionType (line 48) | enum YuvRgbConversionType {
function class (line 70) | class ConvertRGBToYUV444 : public GenericVideoFilter
function class (line 99) | class ConvertYUY2ToYV16_or_Y : public GenericVideoFilter
function class (line 116) | class ConvertYUV444ToRGB : public GenericVideoFilter
function class (line 145) | class ConvertYV16ToYUY2 : public GenericVideoFilter
function class (line 159) | class ConvertToPlanarGeneric : public GenericVideoFilter
function class (line 196) | class AddAlphaPlane : public GenericVideoFilter
function class (line 216) | class RemoveAlphaPlane : public GenericVideoFilter
FILE: avs_core/convert/convert_rgb.cpp
function convert_rgb24_to_rgb32_c (line 57) | static void convert_rgb24_to_rgb32_c(const BYTE *srcp, BYTE *dstp, size_...
function convert_rgb48_to_rgb64_c (line 67) | static void convert_rgb48_to_rgb64_c(const BYTE *srcp, BYTE *dstp, size_...
function PVideoFrame (line 77) | PVideoFrame __stdcall RGBtoRGBA::GetFrame(int n, IScriptEnvironment* env)
function convert_rgb32_to_rgb24_c (line 111) | static void convert_rgb32_to_rgb24_c(const BYTE *srcp, BYTE *dstp, size_...
function convert_rgb64_to_rgb48_c (line 127) | static void convert_rgb64_to_rgb48_c(const BYTE *srcp, BYTE *dstp, size_...
function PVideoFrame (line 143) | PVideoFrame __stdcall RGBAtoRGB::GetFrame(int n, IScriptEnvironment* env)
function convert_rgb_to_rgbp_c (line 180) | static void convert_rgb_to_rgbp_c(const BYTE* srcp, BYTE* (&dstp)[4], in...
function PVideoFrame (line 208) | PVideoFrame __stdcall PackedRGBtoPlanarRGB::GetFrame(int n, IScriptEnvir...
function convert_rgbp_to_rgb_c (line 313) | static void convert_rgbp_to_rgb_c(const BYTE *(&srcp)[4], BYTE * dstp, i...
function PVideoFrame (line 346) | PVideoFrame __stdcall PlanarRGBtoPackedRGB::GetFrame(int n, IScriptEnvir...
FILE: avs_core/convert/convert_rgb.h
function class (line 41) | class RGBtoRGBA : public GenericVideoFilter
function class (line 57) | class RGBAtoRGB : public GenericVideoFilter
function class (line 72) | class PackedRGBtoPlanarRGB : public GenericVideoFilter
function class (line 90) | class PlanarRGBtoPackedRGB : public GenericVideoFilter
FILE: avs_core/convert/intel/convert_audio_avx2.cpp
function convert32To16_AVX2 (line 24) | void convert32To16_AVX2(void *inbuf, void *outbuf, int count) {
function convert16To32_AVX2 (line 45) | void convert16To32_AVX2(void *inbuf, void *outbuf, int count) {
function convert8ToFLT_AVX2 (line 68) | void convert8ToFLT_AVX2(void* inbuf, void* outbuf, int count) {
function convertFLTTo8_AVX2 (line 89) | void convertFLTTo8_AVX2(void* inbuf, void* outbuf, int count) {
function convert16ToFLT_AVX2 (line 128) | void convert16ToFLT_AVX2(void* inbuf, void* outbuf, int count) {
function convertFLTTo16_AVX2 (line 148) | void convertFLTTo16_AVX2(void* inbuf, void* outbuf, int count) {
function convert32ToFLT_AVX2 (line 183) | void convert32ToFLT_AVX2(void *inbuf, void *outbuf, int count) {
function convertFLTTo32_AVX2 (line 202) | void convertFLTTo32_AVX2(void *inbuf, void *outbuf, int count) {
FILE: avs_core/convert/intel/convert_audio_sse.cpp
function SSE2 (line 34) | SSE2 void convert32To16_SSE2(void *inbuf, void *outbuf, int count) {
function SSE2 (line 54) | SSE2 void convert16To32_SSE2(void *inbuf, void *outbuf, int count) {
function SSE2 (line 76) | SSE2 void convert32To8_SSE2(void *inbuf, void *outbuf, int count) {
function SSE2 (line 107) | SSE2 void convert8To32_SSE2(void *inbuf, void *outbuf, int count) {
function SSE2 (line 139) | SSE2 void convert16To8_SSE2(void *inbuf, void *outbuf, int count) {
function SSE2 (line 160) | SSE2 void convert8To16_SSE2(void *inbuf, void *outbuf, int count) {
function SSSE3 (line 184) | SSSE3 void convert32To24_SSSE3(void *inbuf, void *outbuf, int count) {
function SSSE3 (line 256) | SSSE3 void convert24To32_SSSE3(void *inbuf, void *outbuf, int count) {
function SSSE3 (line 327) | SSSE3 void convert24To16_SSSE3(void *inbuf, void *outbuf, int count) {
function SSSE3 (line 382) | SSSE3 void convert16To24_SSSE3(void *inbuf, void *outbuf, int count) {
function SSSE3 (line 436) | SSSE3 void convert24To8_SSSE3(void *inbuf, void *outbuf, int count) {
function SSSE3 (line 483) | SSSE3 void convert8To24_SSSE3(void *inbuf, void *outbuf, int count) {
function SSE41 (line 528) | SSE41 void convert8ToFLT_SSE41(void* inbuf, void* outbuf, int count) {
function SSE2 (line 548) | SSE2 void convertFLTTo8_SSE2(void* inbuf, void* outbuf, int count) {
function SSE41 (line 580) | SSE41 void convert16ToFLT_SSE41(void* inbuf, void* outbuf, int count) {
function SSE2 (line 599) | SSE2 void convertFLTTo16_SSE2(void* inbuf, void* outbuf, int count) {
function SSE2 (line 629) | SSE2 void convert32ToFLT_SSE2(void *inbuf, void *outbuf, int count) {
function SSE41 (line 648) | SSE41 void convertFLTTo32_SSE41(void *inbuf, void *outbuf, int count) {
FILE: avs_core/convert/intel/convert_bits_avx2.cpp
function convert_32_to_uintN_avx2 (line 64) | void convert_32_to_uintN_avx2(const BYTE *srcp, BYTE *dstp, int src_rows...
function convert_uint_limited_avx2 (line 211) | static void convert_uint_limited_avx2(const BYTE* srcp, BYTE* dstp, int ...
function convert_uint_avx2 (line 294) | void convert_uint_avx2(const BYTE* srcp, BYTE* dstp, int src_rowsize, in...
function do_convert_ordered_dither_uint_avx2 (line 465) | static void do_convert_ordered_dither_uint_avx2(const BYTE* srcp8, BYTE*...
function convert_ordered_dither_uint_avx2 (line 710) | void convert_ordered_dither_uint_avx2(const BYTE* srcp8, BYTE* dstp8, in...
function convert_uintN_to_float_avx2 (line 746) | void convert_uintN_to_float_avx2(const BYTE* srcp, BYTE* dstp, int src_r...
FILE: avs_core/convert/intel/convert_bits_sse.cpp
function convert_32_to_uintN_sse41 (line 65) | __attribute__((__target__("sse4.1")))
function convert_uint_limited_sse41 (line 150) | __attribute__((__target__("sse4.1")))
function convert_uint_sse41 (line 232) | __attribute__((__target__("sse4.1")))
function do_convert_ordered_dither_uint_sse41 (line 396) | __attribute__((__target__("sse4.1")))
function convert_ordered_dither_uint_sse41 (line 684) | __attribute__((__target__("sse4.1")))
FILE: avs_core/convert/intel/convert_planar_avx2.cpp
function DISABLE_WARNING_PUSH (line 52) | DISABLE_WARNING_PUSH
function convert_yv24_to_rgb_avx2 (line 88) | void convert_yv24_to_rgb_avx2(BYTE* dstp, const BYTE* srcY, const BYTE* ...
function convert_yuv_to_planarrgb_avx2 (line 1345) | void convert_yuv_to_planarrgb_avx2(BYTE* (&dstp)[3], int(&dstPitch)[3], ...
FILE: avs_core/convert/intel/convert_planar_sse.cpp
function DISABLE_WARNING_PUSH (line 62) | DISABLE_WARNING_PUSH
function AVS_FORCEINLINE (line 86) | static AVS_FORCEINLINE __m128i convert_rgb_to_y8_sse2_core(const __m128i...
function convert_rgb32_to_y8_sse2 (line 117) | void convert_rgb32_to_y8_sse2(const BYTE *srcp, BYTE *dstp, size_t src_p...
function convert_yuv_to_planarrgb_sse2 (line 633) | void convert_yuv_to_planarrgb_sse2(BYTE* (&dstp)[3], int(&dstPitch)[3], ...
function AVS_FORCEINLINE (line 716) | static AVS_FORCEINLINE __m128i convert_yuv_to_rgb_sse2_core(const __m128...
function convert_yv24_to_rgb_ssse3 (line 748) | __attribute__((__target__("ssse3")))
function convert_yv24_to_rgb_sse2 (line 871) | void convert_yv24_to_rgb_sse2(BYTE* dstp, const BYTE* srcY, const BYTE* ...
function AVS_FORCEINLINE (line 985) | static AVS_FORCEINLINE __m64 convert_yuv_to_rgb_mmx_core(const __m64 &px...
function convert_yv24_to_rgb_mmx (line 1016) | void convert_yv24_to_rgb_mmx(BYTE* dstp, const BYTE* srcY, const BYTE* s...
function convert_yuy2_to_yv16_sse2 (line 1120) | void convert_yuy2_to_yv16_sse2(const BYTE *srcp, BYTE *dstp_y, BYTE *dst...
function convert_yuy2_to_yv16_mmx (line 1153) | void convert_yuy2_to_yv16_mmx(const BYTE *srcp, BYTE *dstp_y, BYTE *dstp...
function convert_yv16_to_yuy2_sse2 (line 1184) | void convert_yv16_to_yuy2_sse2(const BYTE *srcp_y, const BYTE *srcp_u, c...
function convert_yv16_to_yuy2_mmx (line 1211) | void convert_yv16_to_yuy2_mmx(const BYTE *srcp_y, const BYTE *srcp_u, co...
FILE: avs_core/convert/intel/convert_rgb_avx2.cpp
function convert_rgb_to_rgbp_avx2 (line 55) | void convert_rgb_to_rgbp_avx2(const BYTE *srcp, BYTE * (&dstp)[4], int s...
function convert_rgba_to_rgbp_avx2 (line 188) | void convert_rgba_to_rgbp_avx2(const BYTE* srcp, BYTE* (&dstp)[4],
FILE: avs_core/convert/intel/convert_rgb_avx512.cpp
function convert_rgba_to_rgbp_avx512vbmi (line 45) | void convert_rgba_to_rgbp_avx512vbmi(const BYTE *srcp, BYTE * (&dstp)[4],
FILE: avs_core/convert/intel/convert_rgb_sse.cpp
function convert_rgb48_to_rgb64_ssse3 (line 52) | __attribute__((__target__("ssse3")))
function convert_rgb24_to_rgb32_ssse3 (line 98) | __attribute__((__target__("ssse3")))
function convert_rgb64_to_rgb48_ssse3 (line 141) | __attribute__((__target__("ssse3")))
function convert_rgb32_to_rgb24_ssse3 (line 184) | __attribute__((__target__("ssse3")))
function convert_rgb32_to_rgb24_sse2 (line 225) | void convert_rgb32_to_rgb24_sse2(const BYTE* srcp, BYTE* dstp, size_t sr...
function AVS_FORCEINLINE (line 274) | static AVS_FORCEINLINE __m128i sse2_alignr(__m128i hi, __m128i lo) {
function AVS_FORCEINLINE (line 290) | static AVS_FORCEINLINE void gather_bgr8_4px(__m128i grp,
function AVS_FORCEINLINE (line 319) | static AVS_FORCEINLINE void deinterleave_bgr8_16px(
function AVS_FORCEINLINE (line 372) | static AVS_FORCEINLINE void gather_bgr16_2px(__m128i grp,
function AVS_FORCEINLINE (line 394) | static AVS_FORCEINLINE void deinterleave_bgr16_8px(
function convert_rgb_to_rgbp_sse2 (line 431) | void convert_rgb_to_rgbp_sse2(const BYTE* srcp, BYTE* (&dstp)[4],
function convert_rgb_to_rgbp_ssse3 (line 503) | __attribute__((__target__("ssse3")))
function convert_rgba_to_rgbp_sse2 (line 608) | void convert_rgba_to_rgbp_sse2(const BYTE* srcp, BYTE* (&dstp)[4],
function convert_rgba_to_rgbp_ssse3 (line 670) | __attribute__((__target__("ssse3")))
function convert_rgbp_to_rgba_sse2 (line 714) | void convert_rgbp_to_rgba_sse2(const BYTE* (&srcp)[4], BYTE* dstp, int(&...
FILE: avs_core/core/AVSMap.h
function noexcept (line 47) | vs_intrusive_ptr(const vs_intrusive_ptr& ptr) noexcept {
function noexcept (line 72) | const noexcept {
type AVSPropertyType (line 105) | enum AVSPropertyType {
function explicit (line 122) | explicit VSArrayBase(AVSPropertyType type) : refcount(1), ftype(type) {}
function virtual (line 123) | virtual ~VSArrayBase() {}
function add_ref (line 137) | void add_ref() noexcept {
function release (line 141) | void release() noexcept {
type vs_intrusive_ptr (line 150) | typedef vs_intrusive_ptr<VSArrayBase> PVSArrayBase;
function VSArray (line 153) | VSArray final : public VSArrayBase {
function class (line 217) | class VSMapData {
type VSArray (line 223) | typedef VSArray<int64_t, AVSPropertyType::PROPERTYTYPE_INT> VSIntArray;
type VSArray (line 224) | typedef VSArray<double, AVSPropertyType::PROPERTYTYPE_FLOAT> VSFloatArray;
type VSArray (line 225) | typedef VSArray<VSMapData, AVSPropertyType::PROPERTYTYPE_DATA> VSDataArray;
type VSArray (line 226) | typedef VSArray<PClip, AVSPropertyType::PROPERTYTYPE_CLIP> VSVideoNodeAr...
type VSArray (line 227) | typedef VSArray<PVideoFrame, AVSPropertyType::PROPERTYTYPE_FRAME> VSVide...
type std (line 231) | typedef std::vector<int64_t> IntList;
type std (line 232) | typedef std::vector<double> FloatList;
type std (line 233) | typedef std::vector<VSMapData> DataList;
type std (line 234) | typedef std::vector<PClip> ClipList;
type std (line 235) | typedef std::vector<PVideoFrame> FrameList;
function class (line 239) | class VSMapStorage {
type vs_intrusive_ptr (line 271) | typedef vs_intrusive_ptr<VSMapStorage> PVSMapStorage;
function detach (line 275) | struct AVSMap {
function VSArrayBase (line 295) | VSArrayBase* find(const std::string& key) const {
function VSArrayBase (line 300) | VSArrayBase* detach(const std::string& key) {
function erase (line 311) | bool erase(const std::string& key) {
function insert (line 322) | void insert(const std::string& key, VSArrayBase* val) {
function copy (line 333) | void copy(const AVSMap* src) {
FILE: avs_core/core/AviHelper.cpp
function AviHelper_ImageSize (line 48) | int AviHelper_ImageSize(const VideoInfo *vi, bool AVIPadScanlines, bool ...
function ToY416_sse2 (line 110) | void ToY416_sse2(uint8_t *outbuf, int out_pitch, const uint8_t *yptr, in...
function ToY416_c (line 155) | void ToY416_c(uint8_t *outbuf8, int out_pitch, const uint8_t *yptr, int ...
function FromY416_c (line 179) | void FromY416_c(uint8_t *yptr, int ypitch, uint8_t *uptr, uint8_t *vptr,...
function ToY410_c (line 206) | void ToY410_c(uint8_t* outbuf8, int out_pitch, const uint8_t* yptr, int ...
function FromY410_c (line 235) | void FromY410_c(uint8_t* yptr, int ypitch, uint8_t* uptr, uint8_t* vptr,...
function AVS_FORCEINLINE (line 267) | static AVS_FORCEINLINE uint32_t avs_swap32(uint32_t x) {
function From_r210_c (line 273) | void From_r210_c(uint8_t *rptr, uint8_t *gptr, uint8_t *bptr, int pitch,...
function From_R10k_c (line 294) | void From_R10k_c(uint8_t *rptr, uint8_t *gptr, uint8_t *bptr, int pitch,...
function AVS_FORCEINLINE (line 317) | static AVS_FORCEINLINE uint64_t avs_swap64(uint64_t x) {
function AVS_FORCEINLINE (line 326) | __attribute__((__target__("ssse3")))
function AVS_FORCEINLINE (line 334) | static AVS_FORCEINLINE __m128i _mm_bswap_epi64_sse2(__m128i x)
function AVS_FORCEINLINE (line 350) | static AVS_FORCEINLINE uint16_t avs_swap16(uint16_t x) {
function bgr_to_rgbBE_c (line 355) | void bgr_to_rgbBE_c(uint8_t* pdst, int dstpitch, const uint8_t *src, int...
function bgra_to_argbBE_ssse3 (line 379) | __attribute__((__target__("ssse3")))
function bgra_to_argbBE_sse2 (line 401) | void bgra_to_argbBE_sse2(uint8_t* pdst, int dstpitch, const uint8_t *src...
function bgra_to_argbBE_c (line 423) | void bgra_to_argbBE_c(uint8_t* pdst, int dstpitch, const uint8_t *src, i...
function prepare_luma_shift6_c (line 439) | static void prepare_luma_shift6_c(uint8_t* pdst, int dstpitch, const uin...
function prepare_luma_shift6_sse2 (line 455) | static void prepare_luma_shift6_sse2(uint8_t* pdst, int dstpitch, const ...
function prepare_to_interleaved_uv_c (line 482) | static void prepare_to_interleaved_uv_c(uint8_t* pdst, int dstpitch, con...
function prepare_to_interleaved_uv_sse2 (line 506) | static void prepare_to_interleaved_uv_sse2(uint8_t* pdst, int dstpitch, ...
function prepare_from_interleaved_uv_c (line 546) | static void prepare_from_interleaved_uv_c(uint8_t* pdstu, uint8_t* pdstv...
function prepare_from_interleaved_uv_sse2 (line 568) | static void prepare_from_interleaved_uv_sse2(uint8_t* pdstu, uint8_t* pd...
function prepare_from_interleaved_uv_sse41 (line 612) | __attribute__((__target__("sse4.1")))
function yuv422p10_to_v210 (line 658) | void yuv422p10_to_v210(BYTE *dstp, const BYTE *srcp_y, int srcpitch, con...
function v210_to_yuv422p10 (line 690) | void v210_to_yuv422p10(BYTE *dstp_y, int dstpitch, BYTE *dstp_u, BYTE *d...
function v408_to_yuva444p8 (line 781) | void v408_to_yuva444p8(BYTE* dstp_y, int dstpitch, BYTE* dstp_u, BYTE* d...
function v308_to_yuv444p8 (line 815) | void v308_to_yuv444p8(BYTE* dstp_y, int dstpitch, BYTE* dstp_u, BYTE* ds...
function v410_to_yuv444p10 (line 843) | void v410_to_yuv444p10(BYTE* dstp_y, int dstpitch, BYTE* dstp_u, BYTE* d...
FILE: avs_core/core/BufferPool.cpp
type BufferPool::BufferDesc (line 10) | struct BufferPool::BufferDesc
function CheckGuards (line 19) | static inline void CheckGuards(void* ptr)
function GetRealSize (line 34) | static inline size_t GetRealSize(void* ptr)
FILE: avs_core/core/BufferPool.h
function class (line 9) | class BufferPool
FILE: avs_core/core/CompatEnvironment.h
function class (line 58) | class IScriptEnvironment_Avs25 {
function class (line 141) | class IScriptEnvironment_AvsPreV11C {
FILE: avs_core/core/DeviceManager.cpp
function GetDeviceTypes (line 35) | int GetDeviceTypes(const PClip& child)
function GetTargetDeviceTypes (line 48) | int GetTargetDeviceTypes(const PClip& clip)
function DeviceTypesString (line 64) | std::string DeviceTypesString(int devicetypes)
function CheckDeviceTypes (line 81) | static void CheckDeviceTypes(const char* name, int devicetypes, const AV...
function CheckChildDeviceTypes (line 102) | void CheckChildDeviceTypes(const PClip& clip, const char* name, const AV...
function GetFrameHead (line 113) | size_t GetFrameHead(const PVideoFrame& vf)
function GetFrameTail (line 128) | size_t GetFrameTail(const PVideoFrame& vf)
class CPUDevice (line 143) | class CPUDevice : public Device {
method CPUDevice (line 145) | CPUDevice(InternalEnvironment* env)
method SetMemoryMax (line 149) | virtual int SetMemoryMax(int mem)
method BYTE (line 156) | virtual BYTE* Allocate(size_t size, int margin)
method Free (line 189) | virtual void Free(BYTE* ptr)
method AddCompleteCallback (line 198) | virtual void AddCompleteCallback(DeviceCompleteCallbackData cbdata)
method GetAndClearCallbacks (line 204) | virtual std::unique_ptr<std::vector<DeviceCompleteCallbackData>> GetAn...
method SetActiveToCurrentThread (line 209) | virtual void SetActiveToCurrentThread(InternalEnvironment* env)
method SetDeviceOpt (line 219) | virtual void SetDeviceOpt(DeviceOpt opt, int val, InternalEnvironment*...
method GetAlignmentRequirement (line 224) | virtual void GetAlignmentRequirement(int* memoryAlignment, int* pitchA...
class CUDACPUDevice (line 232) | class CUDACPUDevice : public CPUDevice {
method CUDACPUDevice (line 237) | CUDACPUDevice(InternalEnvironment* env, int num_cuda_devices)
method BYTE (line 244) | virtual BYTE* Allocate(size_t size, int margin)
method Free (line 287) | virtual void Free(BYTE* ptr)
method SetDeviceOpt (line 301) | void SetDeviceOpt(DeviceOpt opt, int val, InternalEnvironment* env)
method GetAlignmentRequirement (line 316) | virtual void GetAlignmentRequirement(int* memoryAlignment, int* pitchA...
class CUDADevice (line 325) | class CUDADevice : public Device {
class ScopedCUDADevice (line 326) | class ScopedCUDADevice
method ScopedCUDADevice (line 331) | ScopedCUDADevice(int device_index, IScriptEnvironment* env)
method CUDADevice (line 360) | CUDADevice(int id, int n, InternalEnvironment* env) :
method SetMemoryMax (line 384) | virtual int SetMemoryMax(int mem)
method BYTE (line 394) | virtual BYTE* Allocate(size_t size, int margin)
method Free (line 402) | virtual void Free(BYTE* ptr)
method AddCompleteCallback (line 412) | virtual void AddCompleteCallback(DeviceCompleteCallbackData cbdata)
method GetAndClearCallbacks (line 419) | virtual std::unique_ptr<std::vector<DeviceCompleteCallbackData>> GetAn...
method SetActiveToCurrentThread (line 432) | virtual void SetActiveToCurrentThread(InternalEnvironment* env)
method MakeStreamWaitCompute (line 445) | void MakeStreamWaitCompute(cudaStream_t stream, InternalEnvironment* env)
method SetDeviceOpt (line 455) | void SetDeviceOpt(DeviceOpt opt, int val, InternalEnvironment* env) {
method GetAlignmentRequirement (line 461) | virtual void GetAlignmentRequirement(int* memoryAlignment, int* pitchA...
function Device (line 514) | Device* DeviceManager::GetDevice(AvsDeviceType device_type, int device_i...
class QueuePrefetcher (line 582) | class QueuePrefetcher
method AVSValue (line 603) | static AVSValue ThreadWorker_(IScriptEnvironment2* env, void* data)
method AVSValue (line 609) | AVSValue ThreadWorker(InternalEnvironment* env)
method SchedulePrefetch (line 645) | void SchedulePrefetch(int currentN, InternalEnvironment* env)
method QueuePrefetcher (line 686) | QueuePrefetcher(PClip child, int prefetchFrames, int numThreads, Devic...
method VideoInfo (line 720) | VideoInfo GetVideoInfo() const { return vi; }
method PVideoFrame (line 722) | PVideoFrame GetFrame(int n, InternalEnvironment* env)
class FrameTransferEngine (line 772) | class FrameTransferEngine
method FrameTransferEngine (line 781) | FrameTransferEngine(QueuePrefetcher& child, Device* upstreamDevice, De...
class CUDAFrameTransferEngine (line 794) | class CUDAFrameTransferEngine : public FrameTransferEngine
type QueueItem (line 798) | struct QueueItem {
method cudaMemcpyKind (line 814) | cudaMemcpyKind GetMemcpyKind()
method ExecuteCallbacks (line 832) | void ExecuteCallbacks(const std::vector<DeviceCompleteCallbackData>* c...
method TransferFrameData (line 841) | void TransferFrameData(PVideoFrame& dst, PVideoFrame& src, bool async,...
method PVideoFrame (line 857) | PVideoFrame GetFrameImmediate(int n, InternalEnvironment* env)
method QueueItem (line 907) | QueueItem SetupTransfer(int n, CacheType::handle& cacheHandle, Interna...
method SchedulePrefetch (line 966) | int SchedulePrefetch(int currentN, int prefetchStart, InternalEnvironm...
method FinishCompleted (line 1003) | void FinishCompleted(InternalEnvironment* env)
method PVideoFrame (line 1028) | PVideoFrame WaitUntil(int n, InternalEnvironment* env)
method CheckDevicePair (line 1057) | void CheckDevicePair(InternalEnvironment* env)
method CUDAFrameTransferEngine (line 1076) | CUDAFrameTransferEngine(QueuePrefetcher& child, Device* upstreamDevice...
method PVideoFrame (line 1102) | virtual PVideoFrame GetFrame(int n, InternalEnvironment* env)
function FrameTransferEngine (line 1160) | FrameTransferEngine* CreateTransferEngine(QueuePrefetcher& child,
method FrameTransferEngine (line 781) | FrameTransferEngine(QueuePrefetcher& child, Device* upstreamDevice, De...
class OnDevice (line 1182) | class OnDevice : public GenericVideoFilter
method FrameTransferEngine (line 1192) | FrameTransferEngine* GetOrCreateTransferEngine(Device* downstreamDevic...
method OnDevice (line 1206) | OnDevice(PClip child, int prefetchFrames, Device* upstreamDevice, Inte...
method PVideoFrame (line 1213) | PVideoFrame __stdcall GetFrame(int n, IScriptEnvironment* env_)
method GetAudio (line 1234) | void __stdcall GetAudio(void* buf, int64_t start, int64_t count, IScri...
method SetCacheHints (line 1248) | int __stdcall SetCacheHints(int cachehints, int frame_range)
method AVSValue (line 1262) | static AVSValue __cdecl Create(AVSValue args, void* user_data, IScript...
function CopyCUDAFrame (line 1324) | void CopyCUDAFrame(const PVideoFrame& dst, const PVideoFrame& src, Inter...
function PVideoFrame (line 1357) | PVideoFrame GetFrameOnDevice(PClip& c, int n, const PDevice& device, Int...
FILE: avs_core/core/DeviceManager.h
type DeviceOpt (line 9) | enum DeviceOpt: int
type DeviceCompleteCallbackData (line 11) | struct DeviceCompleteCallbackData {
function class (line 16) | class Device {
function class (line 54) | class DeviceManager {
function class (line 75) | class DeviceSetter {
FILE: avs_core/core/FilterConstructor.cpp
function AVSValue (line 24) | AVSValue FilterConstructor::InstantiateFilter() const
FILE: avs_core/core/FilterConstructor.h
function class (line 7) | class FilterConstructor
FILE: avs_core/core/FilterGraph.cpp
function AVSValue (line 21) | static AVSValue DeepCopyValue(std::vector<std::unique_ptr<AVSValue[]>>& ...
type ScopedGraphNode (line 71) | struct ScopedGraphNode {
method ScopedGraphNode (line 74) | ScopedGraphNode(FilterGraphNode*& target, FilterGraphNode* node) : tar...
function PVideoFrame (line 83) | PVideoFrame __stdcall FilterGraphNode::GetFrame(int n, IScriptEnvironmen...
class FilterGraph (line 113) | class FilterGraph
type NodeInfo (line 118) | struct NodeInfo {
method NodeInfo (line 129) | NodeInfo() { }
method NodeInfo (line 130) | NodeInfo(int number) : number(number) { }
method DoClip (line 135) | int DoClip(IClip* pclip) {
method DoFunc (line 153) | int DoFunc(IFunction* pfunc) {
method DoArray (line 168) | std::string DoArray(NodeInfo& info, const char** argnames_c, std::stri...
method Construct (line 230) | int Construct(FilterGraphNode* root, IScriptEnvironment* env_)
method Construct (line 236) | void Construct(const std::vector<FilterGraphNode*>& roots, IScriptEnvi...
function ReplaceAll (line 248) | static void ReplaceAll(std::string& str, const std::string& from, const ...
class AvsScriptFilterGraph (line 256) | class AvsScriptFilterGraph : private FilterGraph
method OutClip (line 261) | virtual void OutClip(const NodeInfo& info) {
method OutFunc (line 272) | virtual void OutFunc(const NodeInfo& info) {
method OutArray (line 280) | virtual std::string OutArray(const std::string& args) {
method Construct (line 288) | void Construct(FilterGraphNode* root, IScriptEnvironment* env) {
method GetOutput (line 293) | std::string GetOutput() {
class DotFilterGraph (line 298) | class DotFilterGraph : private FilterGraph
method printfcomma (line 306) | void printfcomma(size_t n) {
method OutClip (line 315) | virtual void OutClip(const NodeInfo& info) {
method OutFunc (line 357) | virtual void OutFunc(const NodeInfo& info) {
method OutArray (line 383) | virtual std::string OutArray(const std::string& args) {
method Construct (line 391) | void Construct(FilterGraphNode* root, bool enableArgs, bool enableMemo...
method Construct (line 402) | void Construct(const std::vector<FilterGraphNode*>& roots, bool enable...
method GetOutput (line 411) | std::string GetOutput() {
function FILE (line 418) | static FILE* OpenFileUtf8(const std::string& path_utf8, const char* mode) {
function DoDumpGraph (line 436) | void DoDumpGraph(const std::vector<FilterGraphNode*>& roots, const char*...
function DoDumpGraph (line 450) | static void DoDumpGraph(PClip clip, int mode, const char* path_utf8, ISc...
class DelayedDump (line 478) | class DelayedDump : public GenericVideoFilter
method DelayedDump (line 486) | DelayedDump(PClip clip, const std::string& outpath_utf8, int mode, int...
method PVideoFrame (line 501) | PVideoFrame __stdcall GetFrame(int n, IScriptEnvironment* env)
function AVSValue (line 529) | static AVSValue DumpFilterGraph(AVSValue args, void* user_data, IScriptE...
function AVSValue (line 565) | static AVSValue __cdecl SetGraphAnalysis(AVSValue args, void* user_data,...
FILE: avs_core/core/FilterGraph.h
function class (line 15) | class GraphMemoryNode {
function class (line 31) | class PGraphMemoryNode
function class (line 51) | class FilterGraphNode : public IClip
FILE: avs_core/core/InternalEnvironment.h
type ELogLevel (line 13) | typedef enum _ELogLevel
type ELogTicketType (line 22) | typedef enum _ELogTicketType
type CacheMode (line 38) | enum CacheMode {
type DeviceOpt (line 46) | enum DeviceOpt: int {
function class (line 51) | class OneTimeLogTicket
function class (line 69) | class ScopedCounter {
function namespace (line 86) | namespace VFBHelper {
type IScriptEnvironment (line 110) | typedef IScriptEnvironment::ApplyFunc ApplyFunc;
function virtual (line 306) | virtual IScriptEnvironment2* __stdcall GetEnv2() final { return static_c...
function virtual (line 307) | virtual IScriptEnvironment_Avs25* __stdcall GetEnv25() final { return st...
function virtual (line 308) | virtual IScriptEnvironment_AvsPreV11C* __stdcall GetEnvPreV11C() final {...
type InternalEnvironmentDeleter (line 356) | struct InternalEnvironmentDeleter {
type std (line 361) | typedef std::unique_ptr<InternalEnvironment, InternalEnvironmentDeleter>...
FILE: avs_core/core/LruCache.h
type LruLookupResult (line 12) | enum LruLookupResult
type LruEntryState (line 24) | enum LruEntryState
type LruEntry (line 47) | struct LruEntry
type LruEntry (line 76) | typedef LruEntry entry_type;
type entry_type (line 77) | typedef entry_type* entry_ptr;
type SimpleLruCache (line 78) | typedef SimpleLruCache<K, entry_ptr> CacheType;
type SimpleLruCache (line 79) | typedef SimpleLruCache<K, LruGhostEntry> GhostCacheType;
type size_type (line 81) | typedef size_t size_type;
function MainEvictEvent (line 89) | static bool MainEvictEvent(CacheType* cache, const typename CacheType::E...
function limits (line 139) | void limits(size_t* min, size_t* max) const
function set_limits (line 146) | void set_limits(size_t min, size_t max)
function commit_value (line 278) | void commit_value(handle *hndl)
function rollback (line 294) | void rollback(handle *hndl)
FILE: avs_core/core/MTGuard.cpp
type MTGuardChildFilter (line 47) | struct MTGuardChildFilter {
function PVideoFrame (line 162) | PVideoFrame __stdcall MTGuard::GetFrame(int n, IScriptEnvironment* env_)
function VideoInfo (line 276) | const VideoInfo& __stdcall MTGuard::GetVideoInfo()
function PClip (line 315) | PClip MTGuard::Create(MtMode mode, PClip filterInstance, std::unique_ptr...
FILE: avs_core/core/MTGuard.h
type MTGuardChildFilter (line 12) | struct MTGuardChildFilter
function class (line 13) | class MTGuard : public IClip
FILE: avs_core/core/MappedList.h
function push_back (line 20) | void push_back(const T& elem)
function push_front (line 26) | void push_front(const T& elem)
function remove (line 42) | void remove(const T& elem)
function move_to_back (line 52) | void move_to_back(const T& elem)
function iterator (line 61) | iterator begin()
function iterator (line 66) | iterator end()
FILE: avs_core/core/ObjectPool.h
type std (line 18) | typedef std::unordered_map<char*, typename
function DestructList (line 21) | static void DestructList(ListType* list, bool call_dtor)
function Free (line 63) | void Free(char* obj)
function Destruct (line 117) | void Destruct(T* obj)
FILE: avs_core/core/PluginManager.cpp
function GetLastErrorText (line 74) | static std::string GetLastErrorText(DWORD nErrorCode)
function GetRegString (line 90) | static bool GetRegString(HKEY rootKey, const char path[], const char ent...
function IsParameterTypeSpecifier (line 189) | static bool IsParameterTypeSpecifier(char c) {
function IsParameterTypeModifier (line 202) | static bool IsParameterTypeModifier(char c) {
function IsValidParameterString (line 211) | static bool IsValidParameterString(const char* p) {
type PluginFile (line 560) | struct PluginFile
function PathFromUtf8 (line 629) | static fs::path PathFromUtf8(const std::string& utf8)
function Is64BitDLL (line 981) | static bool Is64BitDLL(std::string sDLL, bool &bIs64BitDLL)
function AVSFunction (line 1101) | const AVSFunction* PluginManager::Lookup(const FunctionMap& map, const c...
function AVSFunction (line 1124) | const AVSFunction* PluginManager::Lookup(const char* search_name, const ...
function FunctionListHasDll (line 1143) | static bool FunctionListHasDll(const FunctionList &list, const char *dll...
function AVSValue (line 1524) | AVSValue LoadPlugin(AVSValue args, void*, IScriptEnvironment* env)
FILE: avs_core/core/PluginManager.h
type PluginFile (line 10) | struct PluginFile
type StdStriComparer (line 12) | struct StdStriComparer
type std (line 24) | typedef std::vector<const AVSFunction*> FunctionList;
type std (line 25) | typedef std::map<std::string,FunctionList,StdStriComparer> FunctionMap;
function class (line 26) | class PluginManager
FILE: avs_core/core/Prefetcher.cpp
type PrefetcherJobParams (line 16) | struct PrefetcherJobParams
type PrefetcherPimpl (line 23) | struct PrefetcherPimpl
method PrefetcherPimpl (line 64) | PrefetcherPimpl(const PClip& _child, int _nThreads, int _nPrefetchFram...
function AVSValue (line 97) | AVSValue Prefetcher::ThreadWorker(IScriptEnvironment2* env, void* data)
function PVideoFrame (line 205) | PVideoFrame __stdcall Prefetcher::GetFrame(int n, IScriptEnvironment* env_)
function VideoInfo (line 360) | const VideoInfo& __stdcall Prefetcher::GetVideoInfo()
function AVSValue (line 365) | AVSValue Prefetcher::Create(AVSValue args, void*, IScriptEnvironment* env)
FILE: avs_core/core/Prefetcher.h
type PrefetcherPimpl (line 6) | struct PrefetcherPimpl
function class (line 9) | class Prefetcher : public IClip
FILE: avs_core/core/SimpleLruCache.h
type Entry (line 13) | struct Entry
function limits (line 66) | void limits(size_t* min, size_t* max) const
function set_limits (line 72) | void set_limits(size_t min, size_t max)
function remove (line 131) | void remove(const K& key)
function trim (line 148) | void trim()
function resize (line 183) | void resize(size_t new_cap)
FILE: avs_core/core/ThreadPool.cpp
type ThreadPoolGenericItemData (line 6) | struct ThreadPoolGenericItemData
class ThreadPoolPimpl (line 17) | class ThreadPoolPimpl
method ThreadPoolPimpl (line 26) | ThreadPoolPimpl(size_t nThreads) :
FILE: avs_core/core/ThreadPool.h
type std (line 8) | typedef std::future<AVSValue> AVSFuture;
type std (line 9) | typedef std::promise<AVSValue> AVSPromise;
function class (line 13) | class JobCompletion : public IJobCompletion
function AVSPromise (line 35) | AVSPromise* Add()
function virtual (line 45) | virtual ~JobCompletion()
function Wait (line 51) | void __stdcall Wait()
function Size (line 56) | size_t __stdcall Size() const
function Capacity (line 60) | size_t __stdcall Capacity() const
function AVSValue (line 64) | AVSValue __stdcall Get(size_t i)
function Reset (line 77) | void __stdcall Reset()
function Destroy (line 98) | void __stdcall Destroy()
function class (line 105) | class ThreadPool
FILE: avs_core/core/alignplanar.cpp
function PVideoFrame (line 48) | PVideoFrame __stdcall AlignPlanar::GetFrame(int n, IScriptEnvironment* e...
function PClip (line 69) | PClip AlignPlanar::Create(PClip clip)
FILE: avs_core/core/alignplanar.h
function class (line 39) | class AlignPlanar : public GenericVideoFilter
FILE: avs_core/core/audio.cpp
function signed_saturated_add64 (line 74) | static int64_t signed_saturated_add64(int64_t x, int64_t y) {
type channel_name_t (line 100) | struct channel_name_t {
type channel_name_t (line 105) | struct channel_name_t
type channel_layout_name (line 128) | struct channel_layout_name {
type channel_layout_name (line 133) | struct channel_layout_name
function av_get_default_channel_layout (line 169) | static unsigned int av_get_default_channel_layout(int nb_channels) {
function get_channel_layout_single (line 177) | static unsigned int get_channel_layout_single(const char* name, size_t n...
function av_get_channel_layout (line 213) | unsigned int av_get_channel_layout(const char* name)
function GetDefaultChannelLayout (line 232) | unsigned int GetDefaultChannelLayout(int nChannels) {
function channelcount_from_mask (line 263) | static int channelcount_from_mask(unsigned int mask)
function av_channel_layout_channel_from_index (line 276) | enum AVSChannel av_channel_layout_channel_from_index(const unsigned int ...
function channel_layout_to_str (line 291) | std::string channel_layout_to_str(const unsigned int channel_layout_mask)
function AVSValue (line 373) | AVSValue __cdecl ConvertAudio::Create_Any(AVSValue args, void*, IScriptE...
function AVSValue (line 379) | AVSValue __cdecl ConvertAudio::Create_16bit(AVSValue args, void*, IScrip...
function AVSValue (line 383) | AVSValue __cdecl ConvertAudio::Create_8bit(AVSValue args, void*, IScript...
function AVSValue (line 388) | AVSValue __cdecl ConvertAudio::Create_32bit(AVSValue args, void*, IScrip...
function AVSValue (line 392) | AVSValue __cdecl ConvertAudio::Create_float(AVSValue args, void*, IScrip...
function AVSValue (line 396) | AVSValue __cdecl ConvertAudio::Create_24bit(AVSValue args, void*, IScrip...
function AVSValue (line 420) | AVSValue __cdecl AssumeRate::Create(AVSValue args, void*, IScriptEnviron...
function PClip (line 496) | PClip ConvertToMono::Create(PClip clip) {
function AVSValue (line 505) | AVSValue __cdecl ConvertToMono::Create(AVSValue args, void*, IScriptEnvi...
function AVSValue (line 580) | AVSValue __cdecl EnsureVBRMP3Sync::Create(AVSValue args, void*, IScriptE...
function AVSValue (line 1134) | AVSValue __cdecl Amplify::Create(AVSValue args, void*, IScriptEnvironmen...
function AVSValue (line 1152) | AVSValue __cdecl Amplify::Create_dB(AVSValue args, void*, IScriptEnviron...
function PVideoFrame (line 1380) | PVideoFrame __stdcall Normalize::GetFrame(int n, IScriptEnvironment* env) {
function AVSValue (line 1401) | AVSValue __cdecl Normalize::Create(AVSValue args, void*, IScriptEnvironm...
function AVSValue (line 1520) | AVSValue __cdecl MixAudio::Create(AVSValue args, void*, IScriptEnvironme...
function deposit (line 1722) | deposit 1 output sample
function AVSValue (line 1839) | AVSValue __cdecl ResampleAudio::Create(AVSValue args, void*, IScriptEnvi...
function SFLOAT (line 1950) | SFLOAT ResampleAudio::FilterUD(SFLOAT *Xp, short Ph, short Inc) {
function Izero (line 1979) | double Izero(double x) {
function LpFilter (line 1996) | void LpFilter(double c[], int N, double frq, double Beta, int Num) {
function makeFilter (line 2031) | int makeFilter( short Imp[], double &dLpScl, unsigned short Nwing, doubl...
function makeFilter (line 2079) | int makeFilter( SFLOAT fImp[], double dLpScl, unsigned short Nwing, doub...
FILE: avs_core/core/audio.h
type AVSChannel (line 41) | enum AVSChannel {
type ChannelLayoutDescriptor_t (line 95) | typedef struct ChannelLayoutDescriptor_t {
function IntToShort (line 162) | static __inline short IntToShort(int v, const int scl)
function class (line 183) | class AssumeRate : public NonCachedGenericVideoFilter
function class (line 195) | class ConvertToMono : public GenericVideoFilter
function class (line 216) | class EnsureVBRMP3Sync : public GenericVideoFilter
function class (line 232) | class MergeChannels : public GenericVideoFilter
function class (line 255) | class GetChannel : public GenericVideoFilter
function class (line 287) | class KillVideo : public GenericVideoFilter
function class (line 299) | class KillAudio : public NonCachedGenericVideoFilter
function class (line 310) | class SetChannelMask : public NonCachedGenericVideoFilter
function class (line 320) | class DelayAudio : public GenericVideoFilter
function class (line 337) | class Amplify : public GenericVideoFilter
function class (line 363) | class Normalize : public GenericVideoFilter
function class (line 384) | class MixAudio : public GenericVideoFilter
function class (line 406) | class ResampleAudio : public GenericVideoFilter
FILE: avs_core/core/avisynth.cpp
class ScriptEnvironment (line 102) | class ScriptEnvironment
method SetGraphAnalysis (line 958) | void SetGraphAnalysis(bool enable) { graphAnalysisEnable = enable; }
method IncEnvCount (line 962) | void IncEnvCount() { InterlockedIncrement(&EnvCount); }
method DecEnvCount (line 963) | void DecEnvCount() { InterlockedDecrement(&EnvCount); }
method ConcurrentVarStringFrame (line 965) | ConcurrentVarStringFrame* GetTopFrame() { return &top_frame; }
method SetCacheMode (line 966) | void SetCacheMode(CacheMode mode) { cacheMode = mode; }
method CacheMode (line 967) | CacheMode GetCacheMode() { return cacheMode; }
method GetInvokeStackSize (line 969) | size_t GetInvokeStackSize() { return invoke_stack.size(); }
method ThreadScriptEnvironment (line 976) | ThreadScriptEnvironment* GetMainThreadEnv() { return threadEnv.get(); }
class VFBStorage (line 978) | class VFBStorage : public VideoFrameBuffer {
method UpdateVFBFreeTimestamp (line 986) | static void UpdateVFBFreeTimestamp(VideoFrameBuffer* vfb) {
method VFBStorage (line 991) | VFBStorage()
method VFBStorage (line 998) | VFBStorage(int size, int margin, Device* device)
method Attach (line 1005) | void Attach(FilterGraphNode* node) {
type DebugTimestampedFrame (line 1072) | struct DebugTimestampedFrame
method DebugTimestampedFrame (line 1080) | DebugTimestampedFrame(VideoFrame* _frame)
type PropEntry (line 1164) | struct PropEntry {
class GlobalLockManager (line 105) | class GlobalLockManager
method GlobalLockManager (line 119) | GlobalLockManager() = delete;
function CountSetBits (line 271) | static uint32_t CountSetBits(T bitMask)
function GetNumPhysicalCPUs (line 288) | static size_t GetNumPhysicalCPUs()
function FormatString (line 443) | static std::string FormatString(const char* fmt, va_list args)
function FormatString (line 461) | static std::string FormatString(const char* fmt, va_list args)
function VideoFrame (line 540) | VideoFrame* VideoFrame::Subframe(int rel_offset, int new_pitch, int new_...
function VideoFrame (line 552) | VideoFrame* VideoFrame::Subframe(int rel_offset, int new_pitch, int new_...
function VideoFrame (line 573) | VideoFrame* VideoFrame::Subframe(int rel_offset, int new_pitch, int new_...
class AtExiter (line 614) | class AtExiter {
type AtExitRec (line 615) | struct AtExitRec {
method AtExitRec (line 619) | AtExitRec(IScriptEnvironment::ShutdownFunc _func, void* _user_data, ...
method AtExiter (line 625) | AtExiter() {
method Add (line 629) | void Add(IScriptEnvironment::ShutdownFunc f, void* d) {
method Execute (line 633) | void Execute(IScriptEnvironment* env) {
function NormalizeString (line 644) | static std::string NormalizeString(const std::string& str)
type _MtWeight (line 664) | enum class _MtWeight
class ClipDataStore (line 672) | class ClipDataStore
method ClipDataStore (line 682) | ClipDataStore(IClip* clip) : Clip(clip) {}
class MtModeEvaluator (line 685) | class MtModeEvaluator
method MtMode (line 692) | MtMode GetFinalMode(MtMode topInvokeMode)
method Accumulate (line 715) | void Accumulate(const MtModeEvaluator& other)
method Accumulate (line 722) | void Accumulate(MtMode mode)
method ClipSpecifiesMtMode (line 741) | static bool ClipSpecifiesMtMode(const PClip& clip)
method MtMode (line 747) | static MtMode GetInstanceMode(const PClip& clip, MtMode defaultMode)
method MtMode (line 752) | static MtMode GetInstanceMode(const PClip& clip)
method MtMode (line 757) | static MtMode GetMtMode(const PClip& clip, const Function* invokeCall,...
method UsesDefaultMtMode (line 775) | static bool UsesDefaultMtMode(const PClip& clip, const Function* invok...
method AddChainedFilter (line 780) | void AddChainedFilter(const PClip& clip, MtMode defaultMode)
type std (line 807) | namespace std
type hash<OneTimeLogTicket> (line 810) | struct hash<OneTimeLogTicket>
class ThreadScriptEnvironment (line 833) | class ThreadScriptEnvironment
method ThreadScriptEnvironment (line 1417) | ThreadScriptEnvironment(int thread_id, ScriptEnvironment* core, Script...
method ScriptEnvironmentTLS (line 1448) | ScriptEnvironmentTLS* GetTLS() { return &myTLS; }
method AVSValue (line 1459) | AVSValue __stdcall GetVar(const char* name)
method SetVar (line 1469) | bool __stdcall SetVar(const char* name, const AVSValue& val)
method SetGlobalVar (line 1475) | bool __stdcall SetGlobalVar(const char* name, const AVSValue& val)
method PushContext (line 1481) | void __stdcall PushContext(int level = 0)
method PopContext (line 1486) | void __stdcall PopContext()
method PushContextGlobal (line 1491) | void __stdcall PushContextGlobal()
method PopContextGlobal (line 1496) | void __stdcall PopContextGlobal()
method GetVarTry (line 1501) | bool __stdcall GetVarTry(const char* name, AVSValue* val) const
method AVSValue (line 1507) | AVSValue __stdcall GetVarDef(const char* name, const AVSValue& def)
method GetVarBool (line 1517) | bool __stdcall GetVarBool(const char* name, bool def) const
method GetVarInt (line 1527) | int __stdcall GetVarInt(const char* name, int def) const
method GetVarDouble (line 1537) | double __stdcall GetVarDouble(const char* name, double def) const
method GetVarLong (line 1561) | int64_t __stdcall GetVarLong(const char* name, int64_t def) const
method Free (line 1581) | void __stdcall Free(void* ptr)
method Device (line 1586) | Device* __stdcall GetCurrentDevice() const
method Device (line 1591) | Device* __stdcall SetCurrentDevice(Device* device)
method PVideoFrame (line 1598) | PVideoFrame __stdcall NewVideoFrame(const VideoInfo& vi, int align)
method PVideoFrame (line 1603) | PVideoFrame __stdcall NewVideoFrameP(const VideoInfo& vi, const PVideo...
method DeviceAddCallback (line 1613) | void __stdcall DeviceAddCallback(void(*cb)(void*), void* user_data)
method PVideoFrame (line 1619) | PVideoFrame __stdcall GetFrame(PClip c, int n, const PDevice& device)
method InternalFunctionExists (line 1631) | bool __stdcall InternalFunctionExists(const char* name)
method AdjustMemoryConsumption (line 1636) | void __stdcall AdjustMemoryConsumption(size_t amount, bool minus)
method CheckVersion (line 1641) | void __stdcall CheckVersion(int version)
method GetCPUFlags (line 1646) | int __stdcall GetCPUFlags()
method GetCPUFlagsEx (line 1651) | int64_t __stdcall GetCPUFlagsEx()
method ThrowError (line 1687) | void ThrowError(const char* fmt, ...)
method VThrowError (line 1695) | void __stdcall VThrowError(const char* fmt, va_list va)
method PVideoFrame (line 1712) | PVideoFrame __stdcall SubframePlanarA(PVideoFrame src, int rel_offset,...
method MakePropertyWritable (line 1717) | bool __stdcall MakePropertyWritable(PVideoFrame* pvf)
method copyFrameProps (line 1722) | void __stdcall copyFrameProps(const PVideoFrame& src, PVideoFrame& dst)
method AVSMap (line 1727) | const AVSMap* __stdcall getFramePropsRO(const PVideoFrame& frame)
method AVSMap (line 1731) | AVSMap* __stdcall getFramePropsRW(PVideoFrame& frame)
method propNumKeys (line 1735) | int __stdcall propNumKeys(const AVSMap* map)
method propNumElements (line 1743) | int __stdcall propNumElements(const AVSMap* map, const char* key)
method propGetType (line 1747) | char __stdcall propGetType(const AVSMap* map, const char* key)
method propDeleteKey (line 1751) | int __stdcall propDeleteKey(AVSMap* map, const char* key)
method propGetInt (line 1755) | int64_t __stdcall propGetInt(const AVSMap* map, const char* key, int i...
method propGetIntSaturated (line 1759) | int __stdcall propGetIntSaturated(const AVSMap* map, const char* key, ...
method propGetFloat (line 1763) | double __stdcall propGetFloat(const AVSMap* map, const char* key, int ...
method propGetFloatSaturated (line 1767) | float __stdcall propGetFloatSaturated(const AVSMap* map, const char* k...
method propGetDataSize (line 1775) | int __stdcall propGetDataSize(const AVSMap* map, const char* key, int ...
method propGetDataTypeHint (line 1779) | int __stdcall propGetDataTypeHint(const AVSMap* map, const char* key, ...
method PClip (line 1783) | PClip __stdcall propGetClip(const AVSMap* map, const char* key, int in...
method PVideoFrame (line 1787) | const PVideoFrame __stdcall propGetFrame(const AVSMap* map, const char...
method propSetInt (line 1791) | int __stdcall propSetInt(AVSMap* map, const char* key, int64_t i, int ...
method propSetFloat (line 1795) | int __stdcall propSetFloat(AVSMap* map, const char* key, double d, int...
method propSetData (line 1799) | int __stdcall propSetData(AVSMap* map, const char* key, const char* d,...
method propSetDataH (line 1803) | int __stdcall propSetDataH(AVSMap* map, const char* key, const char* d...
method propSetClip (line 1807) | int __stdcall propSetClip(AVSMap* map, const char* key, PClip& clip, i...
method propSetFrame (line 1811) | int __stdcall propSetFrame(AVSMap* map, const char* key, const PVideoF...
method propSetIntArray (line 1826) | int __stdcall propSetIntArray(AVSMap* map, const char* key, const int6...
method propSetFloatArray (line 1831) | int __stdcall propSetFloatArray(AVSMap* map, const char* key, const do...
method AVSMap (line 1836) | AVSMap* __stdcall createMap()
method freeMap (line 1841) | void __stdcall freeMap(AVSMap* map)
method clearMap (line 1846) | void __stdcall clearMap(AVSMap* map)
method AddFunction (line 1851) | void __stdcall AddFunction(const char* name, const char* params, Apply...
method AddFunction25 (line 1856) | void __stdcall AddFunction25(const char* name, const char* params, App...
method AddFunctionPreV11C (line 1861) | void __stdcall AddFunctionPreV11C(const char* name, const char* params...
method FunctionExists (line 1866) | bool __stdcall FunctionExists(const char* name)
method IsRuntime (line 1871) | bool IsRuntime() {
method AVSValue (line 1888) | AVSValue __stdcall Invoke(const char* name,
method AVSValue (line 1900) | AVSValue __stdcall Invoke25(const char* name,
method AVSValue (line 1926) | AVSValue __stdcall InvokePreV11C(const char* name,
method InvokeTry (line 1955) | bool __stdcall InvokeTry(AVSValue* result,
method AVSValue (line 1963) | AVSValue __stdcall Invoke2(const AVSValue& implicit_last,
method Invoke2Try (line 1976) | bool __stdcall Invoke2Try(AVSValue* result, const AVSValue& implicit_l...
method AVSValue (line 1984) | AVSValue __stdcall Invoke3(const AVSValue& implicit_last,
method Invoke3Try (line 1997) | bool __stdcall Invoke3Try(AVSValue *result, const AVSValue& implicit_l...
method Invoke_ (line 2005) | bool __stdcall Invoke_(AVSValue *result, const AVSValue& implicit_last,
method MakeWritable (line 2011) | bool __stdcall MakeWritable(PVideoFrame* pvf)
method BitBlt (line 2016) | void __stdcall BitBlt(BYTE* dstp, int dst_pitch, const BYTE* srcp, int...
method AtExit (line 2021) | void __stdcall AtExit(IScriptEnvironment::ShutdownFunc function, void*...
method PVideoFrame (line 2026) | PVideoFrame __stdcall Subframe(PVideoFrame src, int rel_offset, int ne...
method SetMemoryMax (line 2031) | int __stdcall SetMemoryMax(int mem)
method SetWorkingDir (line 2036) | int __stdcall SetWorkingDir(const char* newdir)
method AcquireGlobalLock (line 2041) | bool __stdcall AcquireGlobalLock(const char* name) {
method ReleaseGlobalLock (line 2045) | void __stdcall ReleaseGlobalLock(const char* name) {
method PlanarChromaAlignment (line 2077) | bool __stdcall PlanarChromaAlignment(IScriptEnvironment::PlanarChromaA...
method PVideoFrame (line 2082) | PVideoFrame __stdcall SubframePlanar(PVideoFrame src, int rel_offset, ...
method DeleteScriptEnvironment (line 2087) | void __stdcall DeleteScriptEnvironment()
method ApplyMessage (line 2098) | void __stdcall ApplyMessage(PVideoFrame* frame, const VideoInfo& vi, c...
method ApplyMessageEx (line 2103) | void __stdcall ApplyMessageEx(PVideoFrame* frame, const VideoInfo& vi,...
method AVS_Linkage (line 2108) | const AVS_Linkage* __stdcall GetAVSLinkage()
method LoadPlugin (line 2114) | bool __stdcall LoadPlugin(const char* filePath, bool throwOnError, AVS...
method AddAutoloadDir (line 2119) | void __stdcall AddAutoloadDir(const char* dirPath, bool toFront)
method ClearAutoloadDirs (line 2124) | void __stdcall ClearAutoloadDirs()
method AutoloadPlugins (line 2129) | void __stdcall AutoloadPlugins()
method AddFunction (line 2134) | void __stdcall AddFunction(const char* name, const char* params, Apply...
method SetFilterProp (line 2144) | void __stdcall SetFilterProp(const char* filter, const char* key, cons...
method SetFilterPropConditional (line 2149) | void __stdcall SetFilterPropConditional(const char* filter, const char...
method SetFilterPropPassthrough (line 2160) | void __stdcall SetFilterPropPassthrough(const char* filter)
method IncrImportDepth (line 2165) | int __stdcall IncrImportDepth()
method DecrImportDepth (line 2170) | int __stdcall DecrImportDepth()
method GetEnvProperty (line 2175) | size_t __stdcall GetEnvProperty(AvsEnvProperty prop)
method SetFilterMTMode (line 2190) | void __stdcall SetFilterMTMode(const char* filter, MtMode mode, bool f...
method MtMode (line 2195) | MtMode __stdcall GetFilterMTMode(const Function* filter, bool* is_forc...
method FilterHasMtMode (line 2200) | bool __stdcall FilterHasMtMode(const Function* filter) const
method IJobCompletion (line 2205) | IJobCompletion* __stdcall NewCompletion(size_t capacity)
method ParallelJob (line 2210) | void __stdcall ParallelJob(ThreadWorkerFuncPtr jobFunc, void* jobData,...
method ParallelJob (line 2215) | void __stdcall ParallelJob(ThreadWorkerFuncPtr jobFunc, void* jobData,...
method ClipDataStore (line 2220) | ClipDataStore* __stdcall ClipData(IClip* clip)
method MtMode (line 2225) | MtMode __stdcall GetDefaultMtMode() const
method SetLogParams (line 2230) | void __stdcall SetLogParams(const char* target, int level)
method LogMsg (line 2236) | void LogMsg(int level, const char* fmt, ...)
method LogMsg_valist (line 2244) | void __stdcall LogMsg_valist(int level, const char* fmt, va_list va)
method LogMsgOnce (line 2250) | void LogMsgOnce(const OneTimeLogTicket& ticket, int level, const char*...
method LogMsgOnce_valist (line 2258) | void __stdcall LogMsgOnce_valist(const OneTimeLogTicket& ticket, int l...
method SetMaxCPU (line 2263) | void __stdcall SetMaxCPU(const char *features)
method SetGraphAnalysis (line 2268) | void __stdcall SetGraphAnalysis(bool enable)
method SetMemoryMax (line 2273) | int __stdcall SetMemoryMax(AvsDeviceType type, int index, int mem)
method PDevice (line 2278) | PDevice __stdcall GetDevice(AvsDeviceType device_type, int device_inde...
method PDevice (line 2283) | PDevice __stdcall GetDevice() const
method AvsDeviceType (line 2288) | AvsDeviceType __stdcall GetDeviceType() const
method GetDeviceId (line 2293) | int __stdcall GetDeviceId() const
method GetDeviceIndex (line 2298) | int __stdcall GetDeviceIndex() const
method PVideoFrame (line 2308) | PVideoFrame __stdcall NewVideoFrameOnDevice(const VideoInfo& vi, int a...
method PVideoFrame (line 2314) | PVideoFrame __stdcall NewVideoFrame(const VideoInfo& vi)
method PVideoFrame (line 2320) | PVideoFrame __stdcall NewVideoFrame(const VideoInfo& vi, const PDevice...
method PVideoFrame (line 2326) | PVideoFrame __stdcall NewVideoFrameOnDevice(const VideoInfo& vi, int a...
method PVideoFrame (line 2332) | PVideoFrame __stdcall NewVideoFrame(const VideoInfo& vi, const PVideoF...
method PVideoFrame (line 2338) | PVideoFrame __stdcall NewVideoFrame(const VideoInfo& vi, const PDevice...
method PVideoFrame (line 2343) | PVideoFrame __stdcall GetOnDeviceFrame(const PVideoFrame& src, Device*...
method ThreadPool (line 2349) | ThreadPool* __stdcall NewThreadPool(size_t nThreads)
method AddRef (line 2355) | void __stdcall AddRef() {
method Release (line 2359) | void __stdcall Release() {
method IncEnvCount (line 2365) | void __stdcall IncEnvCount() {
method DecEnvCount (line 2369) | void __stdcall DecEnvCount() {
method ConcurrentVarStringFrame (line 2373) | ConcurrentVarStringFrame* __stdcall GetTopFrame()
method SetCacheMode (line 2378) | void __stdcall SetCacheMode(CacheMode mode)
method CacheMode (line 2383) | CacheMode __stdcall GetCacheMode()
method GetInvokeStackSize (line 2393) | size_t __stdcall GetInvokeStackSize()
method SetDeviceOpt (line 2398) | void __stdcall SetDeviceOpt(DeviceOpt opt, int val)
method UpdateFunctionExports (line 2403) | void __stdcall UpdateFunctionExports(const char* funcName, const char*...
method InternalEnvironment (line 2413) | InternalEnvironment* __stdcall NewThreadScriptEnvironment(int thread_id)
method GetThreadId (line 2418) | int __stdcall GetThreadId() {
method FilterGraphNode (line 2430) | FilterGraphNode*& GetCurrentGraphNode() {
class ScriptEnvironment (line 836) | class ScriptEnvironment {
method SetGraphAnalysis (line 958) | void SetGraphAnalysis(bool enable) { graphAnalysisEnable = enable; }
method IncEnvCount (line 962) | void IncEnvCount() { InterlockedIncrement(&EnvCount); }
method DecEnvCount (line 963) | void DecEnvCount() { InterlockedDecrement(&EnvCount); }
method ConcurrentVarStringFrame (line 965) | ConcurrentVarStringFrame* GetTopFrame() { return &top_frame; }
method SetCacheMode (line 966) | void SetCacheMode(CacheMode mode) { cacheMode = mode; }
method CacheMode (line 967) | CacheMode GetCacheMode() { return cacheMode; }
method GetInvokeStackSize (line 969) | size_t GetInvokeStackSize() { return invoke_stack.size(); }
method ThreadScriptEnvironment (line 976) | ThreadScriptEnvironment* GetMainThreadEnv() { return threadEnv.get(); }
class VFBStorage (line 978) | class VFBStorage : public VideoFrameBuffer {
method UpdateVFBFreeTimestamp (line 986) | static void UpdateVFBFreeTimestamp(VideoFrameBuffer* vfb) {
method VFBStorage (line 991) | VFBStorage()
method VFBStorage (line 998) | VFBStorage(int size, int margin, Device* device)
method Attach (line 1005) | void Attach(FilterGraphNode* node) {
type DebugTimestampedFrame (line 1072) | struct DebugTimestampedFrame
method DebugTimestampedFrame (line 1080) | DebugTimestampedFrame(VideoFrame* _frame)
type PropEntry (line 1164) | struct PropEntry {
type VFBHelper (line 1196) | namespace VFBHelper {
function UpdateVFBFreeTimestamp (line 1197) | void UpdateVFBFreeTimestamp(VideoFrameBuffer* vfb) {
class MinimumScriptEnvironment (line 1206) | class MinimumScriptEnvironment : public IScriptEnvironment {
method MinimumScriptEnvironment (line 1209) | MinimumScriptEnvironment(ConcurrentVarStringFrame* top_frame) : var_ta...
method GetCPUFlags (line 1211) | virtual int __stdcall GetCPUFlags() {
method ThrowError (line 1233) | __declspec(noreturn) virtual void ThrowError(const char* fmt, ...) {
method VThrowError (line 1243) | void __stdcall VThrowError(const char* fmt, va_list va)
method AddFunction (line 1255) | virtual void __stdcall AddFunction(const char* name, const char* param...
method FunctionExists (line 1258) | virtual bool __stdcall FunctionExists(const char* name) {
method AVSValue (line 1261) | virtual AVSValue __stdcall Invoke(const char* name, const AVSValue arg...
method AVSValue (line 1264) | virtual AVSValue __stdcall GetVar(const char* name) {
method SetVar (line 1267) | virtual bool __stdcall SetVar(const char* name, const AVSValue& val) {
method SetGlobalVar (line 1270) | virtual bool __stdcall SetGlobalVar(const char* name, const AVSValue& ...
method PushContext (line 1273) | virtual void __stdcall PushContext(int level = 0) {
method PopContext (line 1276) | virtual void __stdcall PopContext() {
method PVideoFrame (line 1279) | virtual PVideoFrame __stdcall NewVideoFrame(const VideoInfo& vi, int a...
method MakeWritable (line 1282) | virtual bool __stdcall MakeWritable(PVideoFrame* pvf) {
method BitBlt (line 1285) | virtual void __stdcall BitBlt(BYTE* dstp, int dst_pitch, const BYTE* s...
method AtExit (line 1288) | virtual void __stdcall AtExit(ShutdownFunc function, void* user_data) {
method CheckVersion (line 1291) | virtual void __stdcall CheckVersion(int version = AVISYNTH_INTERFACE_V...
method PVideoFrame (line 1294) | virtual PVideoFrame __stdcall Subframe(PVideoFrame src, int rel_offset...
method SetMemoryMax (line 1297) | virtual int __stdcall SetMemoryMax(int mem) {
method SetWorkingDir (line 1300) | virtual int __stdcall SetWorkingDir(const char * newdir) {
method PlanarChromaAlignment (line 1306) | virtual bool __stdcall PlanarChromaAlignment(PlanarChromaAlignmentMode...
method PVideoFrame (line 1309) | virtual PVideoFrame __stdcall SubframePlanar(PVideoFrame src, int rel_...
method DeleteScriptEnvironment (line 1313) | virtual void __stdcall DeleteScriptEnvironment() {
method ApplyMessage (line 1316) | virtual void __stdcall ApplyMessage(PVideoFrame* frame, const VideoInf...
method AVS_Linkage (line 1320) | virtual const AVS_Linkage* __stdcall GetAVSLinkage() {
method AVSValue (line 1323) | virtual AVSValue __stdcall GetVarDef(const char* name, const AVSValue&...
function InternalEnvironment (line 1332) | InternalEnvironment* GetAndRevealCamouflagedEnv(IScriptEnvironment* env) {
type ScriptEnvironmentTLS (line 1359) | struct ScriptEnvironmentTLS
method ScriptEnvironmentTLS (line 1380) | ScriptEnvironmentTLS(int thread_id, InternalEnvironment* core)
class ThreadScriptEnvironment (line 1410) | class ThreadScriptEnvironment : public InternalEnvironment
method ThreadScriptEnvironment (line 1417) | ThreadScriptEnvironment(int thread_id, ScriptEnvironment* core, Script...
method ScriptEnvironmentTLS (line 1448) | ScriptEnvironmentTLS* GetTLS() { return &myTLS; }
method AVSValue (line 1459) | AVSValue __stdcall GetVar(const char* name)
method SetVar (line 1469) | bool __stdcall SetVar(const char* name, const AVSValue& val)
method SetGlobalVar (line 1475) | bool __stdcall SetGlobalVar(const char* name, const AVSValue& val)
method PushContext (line 1481) | void __stdcall PushContext(int level = 0)
method PopContext (line 1486) | void __stdcall PopContext()
method PushContextGlobal (line 1491) | void __stdcall PushContextGlobal()
method PopContextGlobal (line 1496) | void __stdcall PopContextGlobal()
method GetVarTry (line 1501) | bool __stdcall GetVarTry(const char* name, AVSValue* val) const
method AVSValue (line 1507) | AVSValue __stdcall GetVarDef(const char* name, const AVSValue& def)
method GetVarBool (line 1517) | bool __stdcall GetVarBool(const char* name, bool def) const
method GetVarInt (line 1527) | int __stdcall GetVarInt(const char* name, int def) const
method GetVarDouble (line 1537) | double __stdcall GetVarDouble(const char* name, double def) const
method GetVarLong (line 1561) | int64_t __stdcall GetVarLong(const char* name, int64_t def) const
method Free (line 1581) | void __stdcall Free(void* ptr)
method Device (line 1586) | Device* __stdcall GetCurrentDevice() const
method Device (line 1591) | Device* __stdcall SetCurrentDevice(Device* device)
method PVideoFrame (line 1598) | PVideoFrame __stdcall NewVideoFrame(const VideoInfo& vi, int align)
method PVideoFrame (line 1603) | PVideoFrame __stdcall NewVideoFrameP(const VideoInfo& vi, const PVideo...
method DeviceAddCallback (line 1613) | void __stdcall DeviceAddCallback(void(*cb)(void*), void* user_data)
method PVideoFrame (line 1619) | PVideoFrame __stdcall GetFrame(PClip c, int n, const PDevice& device)
method InternalFunctionExists (line 1631) | bool __stdcall InternalFunctionExists(const char* name)
method AdjustMemoryConsumption (line 1636) | void __stdcall AdjustMemoryConsumption(size_t amount, bool minus)
method CheckVersion (line 1641) | void __stdcall CheckVersion(int version)
method GetCPUFlags (line 1646) | int __stdcall GetCPUFlags()
method GetCPUFlagsEx (line 1651) | int64_t __stdcall GetCPUFlagsEx()
method ThrowError (line 1687) | void ThrowError(const char* fmt, ...)
method VThrowError (line 1695) | void __stdcall VThrowError(const char* fmt, va_list va)
method PVideoFrame (line 1712) | PVideoFrame __stdcall SubframePlanarA(PVideoFrame src, int rel_offset,...
method MakePropertyWritable (line 1717) | bool __stdcall MakePropertyWritable(PVideoFrame* pvf)
method copyFrameProps (line 1722) | void __stdcall copyFrameProps(const PVideoFrame& src, PVideoFrame& dst)
method AVSMap (line 1727) | const AVSMap* __stdcall getFramePropsRO(const PVideoFrame& frame)
method AVSMap (line 1731) | AVSMap* __stdcall getFramePropsRW(PVideoFrame& frame)
method propNumKeys (line 1735) | int __stdcall propNumKeys(const AVSMap* map)
method propNumElements (line 1743) | int __stdcall propNumElements(const AVSMap* map, const char* key)
method propGetType (line 1747) | char __stdcall propGetType(const AVSMap* map, const char* key)
method propDeleteKey (line 1751) | int __stdcall propDeleteKey(AVSMap* map, const char* key)
method propGetInt (line 1755) | int64_t __stdcall propGetInt(const AVSMap* map, const char* key, int i...
method propGetIntSaturated (line 1759) | int __stdcall propGetIntSaturated(const AVSMap* map, const char* key, ...
method propGetFloat (line 1763) | double __stdcall propGetFloat(const AVSMap* map, const char* key, int ...
method propGetFloatSaturated (line 1767) | float __stdcall propGetFloatSaturated(const AVSMap* map, const char* k...
method propGetDataSize (line 1775) | int __stdcall propGetDataSize(const AVSMap* map, const char* key, int ...
method propGetDataTypeHint (line 1779) | int __stdcall propGetDataTypeHint(const AVSMap* map, const char* key, ...
method PClip (line 1783) | PClip __stdcall propGetClip(const AVSMap* map, const char* key, int in...
method PVideoFrame (line 1787) | const PVideoFrame __stdcall propGetFrame(const AVSMap* map, const char...
method propSetInt (line 1791) | int __stdcall propSetInt(AVSMap* map, const char* key, int64_t i, int ...
method propSetFloat (line 1795) | int __stdcall propSetFloat(AVSMap* map, const char* key, double d, int...
method propSetData (line 1799) | int __stdcall propSetData(AVSMap* map, const char* key, const char* d,...
method propSetDataH (line 1803) | int __stdcall propSetDataH(AVSMap* map, const char* key, const char* d...
method propSetClip (line 1807) | int __stdcall propSetClip(AVSMap* map, const char* key, PClip& clip, i...
method propSetFrame (line 1811) | int __stdcall propSetFrame(AVSMap* map, const char* key, const PVideoF...
method propSetIntArray (line 1826) | int __stdcall propSetIntArray(AVSMap* map, const char* key, const int6...
method propSetFloatArray (line 1831) | int __stdcall propSetFloatArray(AVSMap* map, const char* key, const do...
method AVSMap (line 1836) | AVSMap* __stdcall createMap()
method freeMap (line 1841) | void __stdcall freeMap(AVSMap* map)
method clearMap (line 1846) | void __stdcall clearMap(AVSMap* map)
method AddFunction (line 1851) | void __stdcall AddFunction(const char* name, const char* params, Apply...
method AddFunction25 (line 1856) | void __stdcall AddFunction25(const char* name, const char* params, App...
method AddFunctionPreV11C (line 1861) | void __stdcall AddFunctionPreV11C(const char* name, const char* params...
method FunctionExists (line 1866) | bool __stdcall FunctionExists(const char* name)
method IsRuntime (line 1871) | bool IsRuntime() {
method AVSValue (line 1888) | AVSValue __stdcall Invoke(const char* name,
method AVSValue (line 1900) | AVSValue __stdcall Invoke25(const char* name,
method AVSValue (line 1926) | AVSValue __stdcall InvokePreV11C(const char* name,
method InvokeTry (line 1955) | bool __stdcall InvokeTry(AVSValue* result,
method AVSValue (line 1963) | AVSValue __stdcall Invoke2(const AVSValue& implicit_last,
method Invoke2Try (line 1976) | bool __stdcall Invoke2Try(AVSValue* result, const AVSValue& implicit_l...
method AVSValue (line 1984) | AVSValue __stdcall Invoke3(const AVSValue& implicit_last,
method Invoke3Try (line 1997) | bool __stdcall Invoke3Try(AVSValue *result, const AVSValue& implicit_l...
method Invoke_ (line 2005) | bool __stdcall Invoke_(AVSValue *result, const AVSValue& implicit_last,
method MakeWritable (line 2011) | bool __stdcall MakeWritable(PVideoFrame* pvf)
method BitBlt (line 2016) | void __stdcall BitBlt(BYTE* dstp, int dst_pitch, const BYTE* srcp, int...
method AtExit (line 2021) | void __stdcall AtExit(IScriptEnvironment::ShutdownFunc function, void*...
method PVideoFrame (line 2026) | PVideoFrame __stdcall Subframe(PVideoFrame src, int rel_offset, int ne...
method SetMemoryMax (line 2031) | int __stdcall SetMemoryMax(int mem)
method SetWorkingDir (line 2036) | int __stdcall SetWorkingDir(const char* newdir)
method AcquireGlobalLock (line 2041) | bool __stdcall AcquireGlobalLock(const char* name) {
method ReleaseGlobalLock (line 2045) | void __stdcall ReleaseGlobalLock(const char* name) {
method PlanarChromaAlignment (line 2077) | bool __stdcall PlanarChromaAlignment(IScriptEnvironment::PlanarChromaA...
method PVideoFrame (line 2082) | PVideoFrame __stdcall SubframePlanar(PVideoFrame src, int rel_offset, ...
method DeleteScriptEnvironment (line 2087) | void __stdcall DeleteScriptEnvironment()
method ApplyMessage (line 2098) | void __stdcall ApplyMessage(PVideoFrame* frame, const VideoInfo& vi, c...
method ApplyMessageEx (line 2103) | void __stdcall ApplyMessageEx(PVideoFrame* frame, const VideoInfo& vi,...
method AVS_Linkage (line 2108) | const AVS_Linkage* __stdcall GetAVSLinkage()
method LoadPlugin (line 2114) | bool __stdcall LoadPlugin(const char* filePath, bool throwOnError, AVS...
method AddAutoloadDir (line 2119) | void __stdcall AddAutoloadDir(const char* dirPath, bool toFront)
method ClearAutoloadDirs (line 2124) | void __stdcall ClearAutoloadDirs()
method AutoloadPlugins (line 2129) | void __stdcall AutoloadPlugins()
method AddFunction (line 2134) | void __stdcall AddFunction(const char* name, const char* params, Apply...
method SetFilterProp (line 2144) | void __stdcall SetFilterProp(const char* filter, const char* key, cons...
method SetFilterPropConditional (line 2149) | void __stdcall SetFilterPropConditional(const char* filter, const char...
method SetFilterPropPassthrough (line 2160) | void __stdcall SetFilterPropPassthrough(const char* filter)
method IncrImportDepth (line 2165) | int __stdcall IncrImportDepth()
method DecrImportDepth (line 2170) | int __stdcall DecrImportDepth()
method GetEnvProperty (line 2175) | size_t __stdcall GetEnvProperty(AvsEnvProperty prop)
method SetFilterMTMode (line 2190) | void __stdcall SetFilterMTMode(const char* filter, MtMode mode, bool f...
method MtMode (line 2195) | MtMode __stdcall GetFilterMTMode(const Function* filter, bool* is_forc...
method FilterHasMtMode (line 2200) | bool __stdcall FilterHasMtMode(const Function* filter) const
method IJobCompletion (line 2205) | IJobCompletion* __stdcall NewCompletion(size_t capacity)
method ParallelJob (line 2210) | void __stdcall ParallelJob(ThreadWorkerFuncPtr jobFunc, void* jobData,...
method ParallelJob (line 2215) | void __stdcall ParallelJob(ThreadWorkerFuncPtr jobFunc, void* jobData,...
method ClipDataStore (line 2220) | ClipDataStore* __stdcall ClipData(IClip* clip)
method MtMode (line 2225) | MtMode __stdcall GetDefaultMtMode() const
method SetLogParams (line 2230) | void __stdcall SetLogParams(const char* target, int level)
method LogMsg (line 2236) | void LogMsg(int level, const char* fmt, ...)
method LogMsg_valist (line 2244) | void __stdcall LogMsg_valist(int level, const char* fmt, va_list va)
method LogMsgOnce (line 2250) | void LogMsgOnce(const OneTimeLogTicket& ticket, int level, const char*...
method LogMsgOnce_valist (line 2258) | void __stdcall LogMsgOnce_valist(const OneTimeLogTicket& ticket, int l...
method SetMaxCPU (line 2263) | void __stdcall SetMaxCPU(const char *features)
method SetGraphAnalysis (line 2268) | void __stdcall SetGraphAnalysis(bool enable)
method SetMemoryMax (line 2273) | int __stdcall SetMemoryMax(AvsDeviceType type, int index, int mem)
method PDevice (line 2278) | PDevice __stdcall GetDevice(AvsDeviceType device_type, int device_inde...
method PDevice (line 2283) | PDevice __stdcall GetDevice() const
method AvsDeviceType (line 2288) | AvsDeviceType __stdcall GetDeviceType() const
method GetDeviceId (line 2293) | int __stdcall GetDeviceId() const
method GetDeviceIndex (line 2298) | int __stdcall GetDeviceIndex() const
method PVideoFrame (line 2308) | PVideoFrame __stdcall NewVideoFrameOnDevice(const VideoInfo& vi, int a...
method PVideoFrame (line 2314) | PVideoFrame __stdcall NewVideoFrame(const VideoInfo& vi)
method PVideoFrame (line 2320) | PVideoFrame __stdcall NewVideoFrame(const VideoInfo& vi, const PDevice...
method PVideoFrame (line 2326) | PVideoFrame __stdcall NewVideoFrameOnDevice(const VideoInfo& vi, int a...
method PVideoFrame (line 2332) | PVideoFrame __stdcall NewVideoFrame(const VideoInfo& vi, const PVideoF...
method PVideoFrame (line 2338) | PVideoFrame __stdcall NewVideoFrame(const VideoInfo& vi, const PDevice...
method PVideoFrame (line 2343) | PVideoFrame __stdcall GetOnDeviceFrame(const PVideoFrame& src, Device*...
method ThreadPool (line 2349) | ThreadPool* __stdcall NewThreadPool(size_t nThreads)
method AddRef (line 2355) | void __stdcall AddRef() {
method Release (line 2359) | void __stdcall Release() {
method IncEnvCount (line 2365) | void __stdcall IncEnvCount() {
method DecEnvCount (line 2369) | void __stdcall DecEnvCount() {
method ConcurrentVarStringFrame (line 2373) | ConcurrentVarStringFrame* __stdcall GetTopFrame()
method SetCacheMode (line 2378) | void __stdcall SetCacheMode(CacheMode mode)
method CacheMode (line 2383) | CacheMode __stdcall GetCacheMode()
method GetInvokeStackSize (line 2393) | size_t __stdcall GetInvokeStackSize()
method SetDeviceOpt (line 2398) | void __stdcall SetDeviceOpt(DeviceOpt opt, int val)
method UpdateFunctionExports (line 2403) | void __stdcall UpdateFunctionExports(const char* funcName, const char*...
method InternalEnvironment (line 2413) | InternalEnvironment* __stdcall NewThreadScriptEnvironment(int thread_id)
method GetThreadId (line 2418) | int __stdcall GetThreadId() {
method FilterGraphNode (line 2430) | FilterGraphNode*& GetCurrentGraphNode() {
function posix_get_physical_memory (line 2439) | static uint64_t posix_get_physical_memory() {
function posix_get_available_memory (line 2475) | static int64_t posix_get_available_memory() {
function ConstrainMemoryRequest (line 2506) | static uint64_t ConstrainMemoryRequest(uint64_t requested)
function IJobCompletion (line 2587) | IJobCompletion* ScriptEnvironment::NewCompletion(size_t capacity)
function MtMode (line 2748) | MtMode ScriptEnvironment::GetDefaultMtMode() const
type CPUlevel (line 3018) | enum CPUlevel {
type CPUlevel (line 3027) | enum CPUlevel {
type CPUlevel (line 3042) | enum CPUlevel {
function ClipDataStore (line 3208) | ClipDataStore* ScriptEnvironment::ClipData(IClip *clip)
method ClipDataStore (line 682) | ClipDataStore(IClip* clip) : Clip(clip) {}
function MtMode (line 3440) | MtMode ScriptEnvironment::GetFilterMTMode(const Function* filter, bool* ...
function VideoFrame (line 3623) | VideoFrame* ScriptEnvironment::AllocateFrame(size_t vfb_size, size_t mar...
function DebugOut (line 3665) | static void DebugOut(char* s)
function VideoFrame (line 3768) | VideoFrame* ScriptEnvironment::GetFrameFromRegistry(size_t vfb_size, Dev...
function VideoFrame (line 3885) | VideoFrame* ScriptEnvironment::GetFrameFromRegistry(size_t vfb_size, Dev...
function VideoFrame (line 3998) | VideoFrame* ScriptEnvironment::GetNewFrame(size_t vfb_size, size_t margi...
function PVideoFrame (line 4241) | PVideoFrame ScriptEnvironment::NewPlanarVideoFrame(int row_size, int hei...
function PVideoFrame (line 4247) | PVideoFrame ScriptEnvironment::NewPlanarVideoFrame(int row_size, int hei...
function PVideoFrame (line 4308) | PVideoFrame ScriptEnvironment::NewVideoFrameOnDevice(int row_size, int h...
function PVideoFrame (line 4347) | PVideoFrame ScriptEnvironment::NewVideoFrameOnDevice(int row_size, int h...
function PVideoFrame (line 4358) | PVideoFrame ScriptEnvironment::NewVideoFrame(const VideoInfo& vi, const ...
function PVideoFrame (line 4363) | PVideoFrame ScriptEnvironment::NewVideoFrame(const VideoInfo& vi, const ...
function PVideoFrame (line 4374) | PVideoFrame ScriptEnvironment::NewVideoFrameOnDevice(const VideoInfo& vi...
function PVideoFrame (line 4485) | PVideoFrame ScriptEnvironment::NewVideoFrameOnDevice(const VideoInfo& vi...
function PVideoFrame (line 4611) | PVideoFrame ScriptEnvironment::Subframe(PVideoFrame src, int rel_offset,...
function PVideoFrame (line 4634) | PVideoFrame ScriptEnvironment::SubframePlanar(PVideoFrame src, int rel_o...
function PVideoFrame (line 4658) | PVideoFrame ScriptEnvironment::SubframePlanar(PVideoFrame src, int rel_o...
function Flatten (line 4843) | static size_t Flatten(const AVSValue& src, AVSValue* dst, size_t index, ...
function Function (line 4861) | const Function* ScriptEnvironment::Lookup(const char* search_name, const...
function ListArguments (line 4942) | static void ListArguments(const char *name, const AVSValue& args, int &l...
function ListArguments2 (line 4984) | static void ListArguments2(const char* name, const AVSValue* args, int& ...
function PVideoFrame (line 5833) | PVideoFrame ScriptEnvironment::SubframePlanarA(PVideoFrame src, int rel_...
function AVSMap (line 5887) | const AVSMap* ScriptEnvironment::getFramePropsRO(const PVideoFrame& fram...
function AVSMap (line 5892) | AVSMap* ScriptEnvironment::getFramePropsRW(PVideoFrame &frame) AVS_NOEXC...
function VSArrayBase (line 5939) | static VSArrayBase* propGetShared(const AVSMap* map, const char* key, in...
function PClip (line 6065) | PClip ScriptEnvironment::propGetClip(const AVSMap* map, const char* key,...
function PVideoFrame (line 6079) | const PVideoFrame ScriptEnvironment::propGetFrame(const AVSMap* map, con...
function isAlphaUnderscore (line 6093) | static inline bool isAlphaUnderscore(char c) {
function isAlphaNumUnderscore (line 6097) | static inline bool isAlphaNumUnderscore(char c) {
function isValidVSMapKey (line 6101) | static bool isValidVSMapKey(const std::string& s) {
function mapSetEmpty (line 6114) | static int mapSetEmpty(AVSMap* map, const char* key, int type) AVS_NOEXC...
function propSetShared (line 6161) | bool propSetShared(AVSMap* map, const char* key, const T& val, int appen...
function PDevice (line 6281) | PDevice ScriptEnvironment::GetDevice(AvsDeviceType device_type, int devi...
function PVideoFrame (line 6310) | PVideoFrame ScriptEnvironment::GetOnDeviceFrame(const PVideoFrame& src, ...
function ThreadPool (line 6347) | ThreadPool* ScriptEnvironment::NewThreadPool(size_t nThreads)
function AVS_Linkage (line 6425) | const AVS_Linkage* ScriptEnvironment::GetAVSLinkage() {
function IScriptEnvironment2 (line 6465) | IScriptEnvironment2* CreateScriptEnvironment2_internal(int version, bool...
FILE: avs_core/core/avisynth_c.cpp
type AVS_Clip (line 25) | struct AVS_Clip
method AVS_Clip (line 30) | AVS_Clip() : env(0), error(0) {}
class C_VideoFilter (line 33) | class C_VideoFilter : public IClip {
method C_VideoFilter (line 39) | C_VideoFilter() { memset(&d, 0, sizeof(d)); }
function avs_is_rgb48 (line 54) | int AVSC_CC avs_is_rgb48(const AVS_VideoInfo * p)
function avs_is_rgb64 (line 60) | int AVSC_CC avs_is_rgb64(const AVS_VideoInfo * p)
function avs_is_yv24 (line 66) | int AVSC_CC avs_is_yv24(const AVS_VideoInfo * p)
function avs_is_yv16 (line 72) | int AVSC_CC avs_is_yv16(const AVS_VideoInfo * p)
function avs_is_yv12 (line 78) | int AVSC_CC avs_is_yv12(const AVS_VideoInfo * p)
function avs_is_yv411 (line 84) | int AVSC_CC avs_is_yv411(const AVS_VideoInfo * p)
function avs_is_y8 (line 90) | int AVSC_CC avs_is_y8(const AVS_VideoInfo * p)
function avs_is_yuv444p16 (line 96) | int AVSC_CC avs_is_yuv444p16(const AVS_VideoInfo * p)
function avs_is_yuv422p16 (line 102) | int AVSC_CC avs_is_yuv422p16(const AVS_VideoInfo * p)
function avs_is_yuv420p16 (line 108) | int AVSC_CC avs_is_yuv420p16(const AVS_VideoInfo * p)
function avs_is_y16 (line 114) | int AVSC_CC avs_is_y16(const AVS_VideoInfo * p)
function avs_is_yuv444ps (line 120) | int AVSC_CC avs_is_yuv444ps(const AVS_VideoInfo * p)
function avs_is_yuv422ps (line 126) | int AVSC_CC avs_is_yuv422ps(const AVS_VideoInfo * p)
function avs_is_yuv420ps (line 132) | int AVSC_CC avs_is_yuv420ps(const AVS_VideoInfo * p)
function avs_is_y32 (line 138) | int AVSC_CC avs_is_y32(const AVS_VideoInfo * p)
function avs_is_444 (line 144) | int AVSC_CC avs_is_444(const AVS_VideoInfo * p)
function avs_is_422 (line 151) | int AVSC_CC avs_is_422(const AVS_VideoInfo * p)
function avs_is_420 (line 158) | int AVSC_CC avs_is_420(const AVS_VideoInfo * p)
function avs_is_y (line 165) | int AVSC_CC avs_is_y(const AVS_VideoInfo * p)
function avs_is_color_space (line 171) | int AVSC_CC avs_is_color_space(const AVS_VideoInfo * p, int c_space)
function avs_is_yuva (line 181) | int AVSC_CC avs_is_yuva(const AVS_VideoInfo * p)
function avs_is_planar_rgb (line 187) | int AVSC_CC avs_is_planar_rgb(const AVS_VideoInfo * p)
function avs_is_planar_rgba (line 193) | int AVSC_CC avs_is_planar_rgba(const AVS_VideoInfo * p)
function avs_get_plane_width_subsampling (line 199) | int AVSC_CC avs_get_plane_width_subsampling(const AVS_VideoInfo * p, int...
function avs_get_plane_height_subsampling (line 211) | int AVSC_CC avs_get_plane_height_subsampling(const AVS_VideoInfo * p, in...
function avs_bits_per_pixel (line 223) | int AVSC_CC avs_bits_per_pixel(const AVS_VideoInfo * p)
function avs_bytes_from_pixels (line 229) | int AVSC_CC avs_bytes_from_pixels(const AVS_VideoInfo * p, int pixels)
function avs_row_size (line 238) | int AVSC_CC avs_row_size(const AVS_VideoInfo * p, int plane)
function avs_bmp_size (line 244) | int AVSC_CC avs_bmp_size(const AVS_VideoInfo * vi)
function avs_get_pitch_p (line 256) | int AVSC_CC avs_get_pitch_p(const AVS_VideoFrame * p, int plane)
function avs_get_row_size_p (line 268) | int AVSC_CC avs_get_row_size_p(const AVS_VideoFrame * p, int plane)
function avs_get_height_p (line 274) | int AVSC_CC avs_get_height_p(const AVS_VideoFrame * p, int plane)
function BYTE (line 280) | const BYTE * AVSC_CC avs_get_read_ptr_p(const AVS_VideoFrame * p, int pl...
function avs_is_writable (line 286) | int AVSC_CC avs_is_writable(const AVS_VideoFrame * p)
function avs_is_property_writable (line 293) | int AVSC_CC avs_is_property_writable(const AVS_VideoFrame * p)
function avs_video_frame_get_pixel_type (line 300) | int AVSC_CC avs_video_frame_get_pixel_type(const AVS_VideoFrame * p)
function avs_video_frame_amend_pixel_type (line 306) | void AVSC_CC avs_video_frame_amend_pixel_type(AVS_VideoFrame* p, int new...
function BYTE (line 312) | BYTE * AVSC_CC avs_get_write_ptr_p(const AVS_VideoFrame * p, int plane)
function avs_release_video_frame (line 318) | void AVSC_CC avs_release_video_frame(AVS_VideoFrame * f)
function AVS_VideoFrame (line 324) | AVS_VideoFrame * AVSC_CC avs_copy_video_frame(AVS_VideoFrame * f)
function avs_num_components (line 333) | int AVSC_CC avs_num_components(const AVS_VideoInfo * p)
function avs_component_size (line 339) | int AVSC_CC avs_component_size(const AVS_VideoInfo * p)
function avs_bits_per_component (line 345) | int AVSC_CC avs_bits_per_component(const AVS_VideoInfo * p)
function avs_is_channel_mask_known (line 352) | bool AVSC_CC avs_is_channel_mask_known(const AVS_VideoInfo * p)
function avs_set_channel_mask (line 358) | void AVSC_CC avs_set_channel_mask(const AVS_VideoInfo * p, bool isChanne...
function avs_get_channel_mask (line 364) | unsigned int AVSC_CC avs_get_channel_mask(const AVS_VideoInfo * p)
function avs_copy_frame_props (line 374) | void AVSC_CC avs_copy_frame_props(AVS_ScriptEnvironment * p, const AVS_V...
function AVS_Map (line 386) | const AVS_Map * AVSC_CC avs_get_frame_props_ro(AVS_ScriptEnvironment * p...
function AVS_Map (line 399) | AVS_Map * AVSC_CC avs_get_frame_props_rw(AVS_ScriptEnvironment * p, AVS_...
function avs_prop_num_keys (line 412) | int AVSC_CC avs_prop_num_keys(AVS_ScriptEnvironment * p, const AVS_Map *...
function avs_prop_num_elements (line 439) | int AVSC_CC avs_prop_num_elements(AVS_ScriptEnvironment * p, const AVS_M...
function avs_prop_get_type (line 452) | char AVSC_CC avs_prop_get_type(AVS_ScriptEnvironment * p, const AVS_Map ...
function avs_prop_delete_key (line 465) | int AVSC_CC avs_prop_delete_key(AVS_ScriptEnvironment * p, AVS_Map * map...
function avs_prop_get_int (line 478) | int64_t AVSC_CC avs_prop_get_int(AVS_ScriptEnvironment * p, const AVS_Ma...
function avs_prop_get_int_saturated (line 491) | int AVSC_CC avs_prop_get_int_saturated(AVS_ScriptEnvironment* p, const A...
function avs_prop_get_float (line 504) | double AVSC_CC avs_prop_get_float(AVS_ScriptEnvironment * p, const AVS_M...
function avs_prop_get_float_saturated (line 518) | float AVSC_CC avs_prop_get_float_saturated(AVS_ScriptEnvironment* p, con...
function avs_prop_get_data_size (line 548) | int AVSC_CC avs_prop_get_data_size(AVS_ScriptEnvironment * p, const AVS_...
function avs_prop_get_data_type_hint (line 561) | int AVSC_CC avs_prop_get_data_type_hint(AVS_ScriptEnvironment* p, const ...
function AVS_Clip (line 574) | AVS_Clip* AVSC_CC avs_prop_get_clip(AVS_ScriptEnvironment* p, const AVS_...
method AVS_Clip (line 30) | AVS_Clip() : env(0), error(0) {}
function AVS_VideoFrame (line 590) | const AVS_VideoFrame * AVSC_CC avs_prop_get_frame(AVS_ScriptEnvironment ...
function avs_prop_set_int (line 606) | int AVSC_CC avs_prop_set_int(AVS_ScriptEnvironment * p, AVS_Map * map, c...
function avs_prop_set_float (line 619) | int AVSC_CC avs_prop_set_float(AVS_ScriptEnvironment * p, AVS_Map * map,...
function avs_prop_set_data (line 632) | int AVSC_CC avs_prop_set_data(AVS_ScriptEnvironment * p, AVS_Map * map, ...
function avs_prop_set_data_h (line 646) | int AVSC_CC avs_prop_set_data_h(AVS_ScriptEnvironment* p, AVS_Map* map, ...
function avs_prop_set_clip (line 660) | int AVSC_CC avs_prop_set_clip(AVS_ScriptEnvironment * p, AVS_Map * map, ...
function avs_prop_set_frame (line 673) | int AVSC_CC avs_prop_set_frame(AVS_ScriptEnvironment * p, AVS_Map * map,...
function avs_prop_set_int_array (line 713) | int AVSC_CC avs_prop_set_int_array(AVS_ScriptEnvironment * p, AVS_Map * ...
function avs_prop_set_float_array (line 726) | int AVSC_CC avs_prop_set_float_array(AVS_ScriptEnvironment * p, AVS_Map ...
function avs_clear_map (line 739) | void AVSC_CC avs_clear_map(AVS_ScriptEnvironment * p, AVS_Map * map)
function PVideoFrame (line 757) | PVideoFrame C_VideoFilter::GetFrame(int n, IScriptEnvironment* env)
function VideoInfo (line 788) | const VideoInfo& __stdcall C_VideoFilter::GetVideoInfo()
function avs_release_clip (line 832) | void AVSC_CC avs_release_clip(AVS_Clip * p)
function avs_get_version (line 849) | int AVSC_CC avs_get_version(AVS_Clip * p)
function AVS_VideoInfo (line 855) | const AVS_VideoInfo * AVSC_CC avs_get_video_info(AVS_Clip * p)
function AVS_VideoFrame (line 862) | AVS_VideoFrame * AVSC_CC avs_get_frame(AVS_Clip * p, int n)
function avs_get_parity (line 878) | int AVSC_CC avs_get_parity(AVS_Clip * p, int n) // return field parity i...
function avs_get_audio (line 891) | int AVSC_CC avs_get_audio(AVS_Clip * p, void* buf, int64_t start, int64_...
function avs_set_cache_hints (line 905) | int AVSC_CC avs_set_cache_hints(AVS_Clip * p, int cachehints, int frame_...
function AVS_Clip (line 922) | AVS_Clip * AVSC_CC avs_take_clip(AVS_Value v, AVS_ScriptEnvironment * env)
method AVS_Clip (line 30) | AVS_Clip() : env(0), error(0) {}
function avs_val_defined (line 932) | int AVSC_CC avs_val_defined(AVS_Value v) { return ((const AVSValue*)(&v)...
function avs_val_is_clip (line 934) | int AVSC_CC avs_val_is_clip(AVS_Value v) { return ((const AVSValue*)(&v)...
function avs_val_is_bool (line 936) | int AVSC_CC avs_val_is_bool(AVS_Value v) { return ((const AVSValue*)(&v)...
function avs_val_is_int (line 938) | int AVSC_CC avs_val_is_int(AVS_Value v) { return ((const AVSValue*)(&v))...
function avs_val_is_long_strict (line 940) | int AVSC_CC avs_val_is_long_strict(AVS_Value v) { return ((const AVSValu...
function avs_val_is_float (line 942) | int AVSC_CC avs_val_is_float(AVS_Value v) { return ((const AVSValue*)(&v...
function avs_val_is_floatf_strict (line 944) | int AVSC_CC avs_val_is_floatf_strict(AVS_Value v) { return ((const AVSVa...
function avs_val_is_string (line 946) | int AVSC_CC avs_val_is_string(AVS_Value v) { return ((const AVSValue*)(&...
function avs_val_is_array (line 948) | int AVSC_CC avs_val_is_array(AVS_Value v) { return ((const AVSValue*)(&v...
function avs_val_is_error (line 950) | int AVSC_CC avs_val_is_error(AVS_Value v) { return v.type == 'e' ? 1 : 0; }
function avs_set_to_error (line 955) | void AVSC_CC avs_set_to_error(AVS_Value* v, const char* v0) { new(v) AVS...
function avs_set_to_bool (line 957) | void AVSC_CC avs_set_to_bool(AVS_Value* v, int v0) { new(v) AVSValue(v0 ...
function avs_set_to_int (line 959) | void AVSC_CC avs_set_to_int(AVS_Value* v, int v0) { new(v) AVSValue(v0); }
function avs_set_to_float (line 961) | void AVSC_CC avs_set_to_float(AVS_Value* v, float v0) { new(v) AVSValue(...
function avs_set_to_string (line 963) | void AVSC_CC avs_set_to_string(AVS_Value* v, const char* v0) { new(v) AV...
function avs_set_to_double (line 965) | void AVSC_CC avs_set_to_double(AVS_Value* v, double d) { new(v) AVSValue...
function avs_set_to_long (line 967) | void AVSC_CC avs_set_to_long(AVS_Value* v, int64_t l) { new(v) AVSValue(...
function avs_set_to_array (line 969) | void AVSC_CC avs_set_to_array(AVS_Value* v, AVS_Value* src, int size) { ...
function avs_set_to_void (line 971) | void AVSC_CC avs_set_to_void(AVS_Value* v) { new(v) AVSValue(); }
function avs_set_to_clip (line 974) | void AVSC_CC avs_set_to_clip(AVS_Value* v, AVS_Clip* c) { new(v) AVSValu...
function avs_copy_value (line 977) | void AVSC_CC avs_copy_value(AVS_Value * dest, AVS_Value src)
function avs_release_value (line 1014) | void AVSC_CC avs_release_value(AVS_Value v)
function avs_get_as_bool (line 1032) | int AVSC_CC avs_get_as_bool(AVS_Value v) { return ((AVSValue*)&v)->AsBoo...
function AVS_Clip (line 1035) | AVS_Clip* AVSC_CC avs_get_as_clip(AVS_Value v, AVS_ScriptEnvironment* en...
method AVS_Clip (line 30) | AVS_Clip() : env(0), error(0) {}
function avs_get_as_int (line 1044) | int AVSC_CC avs_get_as_int(AVS_Value v) { return ((AVSValue*)&v)->AsInt(...
function avs_get_as_long (line 1046) | int64_t AVSC_CC avs_get_as_long(AVS_Value v) { return ((AVSValue*)&v)->A...
function avs_get_as_float (line 1050) | double AVSC_CC avs_get_as_float(AVS_Value v) { return ((AVSValue*)&v)->A...
function AVS_Value (line 1060) | const AVS_Value * AVSC_CC avs_get_as_array(AVS_Value v) { return v.d.arr...
function AVS_Value (line 1062) | AVS_Value AVSC_CC avs_get_array_elt(AVS_Value v, int index)
function avs_get_array_size (line 1067) | int AVSC_CC avs_get_array_size(AVS_Value v) { return ((AVSValue*)&v)->Ar...
function AVS_Clip (line 1076) | AVS_Clip * AVSC_CC avs_new_c_filter(AVS_ScriptEnvironment * e,
method AVS_Clip (line 30) | AVS_Clip() : env(0), error(0) {}
type C_VideoFilter_UserData (line 1107) | struct C_VideoFilter_UserData {
function AVSValue (line 1113) | AVSValue __cdecl create_c_video_filter(AVSValue args, void* user_data,
function avs_add_function (line 1138) | int AVSC_CC
function avs_add_function_r (line 1161) | int AVSC_CC
function avs_get_cpu_flags (line 1194) | int AVSC_CC avs_get_cpu_flags(AVS_ScriptEnvironment * p)
function avs_get_cpu_flags_ex (line 1201) | int64_t AVSC_CC avs_get_cpu_flags_ex(AVS_ScriptEnvironment* p)
function avs_function_exists (line 1234) | int AVSC_CC avs_function_exists(AVS_ScriptEnvironment * p, const char* n...
function AVS_Value (line 1241) | AVS_Value AVSC_CC avs_invoke(AVS_ScriptEnvironment* p, const char* name,...
function AVS_Value (line 1266) | AVS_Value AVSC_CC avs_get_var(AVS_ScriptEnvironment * p, const char* name)
function avs_set_var (line 1283) | int AVSC_CC avs_set_var(AVS_ScriptEnvironment * p, const char* name, AVS...
function avs_set_global_var (line 1296) | int AVSC_CC avs_set_global_var(AVS_ScriptEnvironment * p, const char* na...
function AVS_VideoFrame (line 1309) | AVS_VideoFrame * AVSC_CC avs_new_video_frame_a(AVS_ScriptEnvironment * p...
function AVS_VideoFrame (line 1327) | AVS_VideoFrame * AVSC_CC avs_new_video_frame_p_a(AVS_ScriptEnvironment *...
function AVS_VideoFrame (line 1344) | AVS_VideoFrame * AVSC_CC avs_new_video_frame_p(AVS_ScriptEnvironment * p...
function avs_make_writable (line 1361) | int AVSC_CC avs_make_writable(AVS_ScriptEnvironment * p, AVS_VideoFrame ...
function avs_make_property_writable (line 1375) | int AVSC_CC avs_make_property_writable(AVS_ScriptEnvironment * p, AVS_Vi...
function avs_bit_blt (line 1388) | void AVSC_CC avs_bit_blt(AVS_ScriptEnvironment * p, BYTE * dstp, int dst...
type ShutdownFuncData (line 1399) | struct ShutdownFuncData
function shutdown_func_bridge (line 1405) | void __cdecl shutdown_func_bridge(void* user_data, IScriptEnvironment* env)
function avs_at_exit (line 1415) | void AVSC_CC avs_at_exit(AVS_ScriptEnvironment * p,
function avs_check_version (line 1428) | int AVSC_CC avs_check_version(AVS_ScriptEnvironment * p, int version)
function AVS_VideoFrame (line 1442) | AVS_VideoFrame * AVSC_CC avs_subframe(AVS_ScriptEnvironment * p, AVS_Vid...
function AVS_VideoFrame (line 1459) | AVS_VideoFrame * AVSC_CC avs_subframe_planar(AVS_ScriptEnvironment * p, ...
function AVS_VideoFrame (line 1479) | AVS_VideoFrame * AVSC_CC avs_subframe_planar_a(AVS_ScriptEnvironment * p...
function avs_set_memory_max (line 1498) | int AVSC_CC avs_set_memory_max(AVS_ScriptEnvironment * p, int mem)
function avs_set_working_dir (line 1511) | int AVSC_CC avs_set_working_dir(AVS_ScriptEnvironment * p, const char* n...
function avs_acquire_global_lock (line 1525) | int AVSC_CC avs_acquire_global_lock(AVS_ScriptEnvironment* p, const char...
function avs_release_global_lock (line 1539) | void AVSC_CC avs_release_global_lock(AVS_ScriptEnvironment* p, const cha...
function avs_get_env_property (line 1552) | size_t AVSC_CC avs_get_env_property(AVS_ScriptEnvironment * p, int avs_a...
function avs_pool_free (line 1580) | void AVSC_CC avs_pool_free(AVS_ScriptEnvironment * p, void* ptr)
function avs_get_var_try (line 1595) | int AVSC_CC avs_get_var_try(AVS_ScriptEnvironment * p, const char* name,...
function avs_get_var_bool (line 1611) | int AVSC_CC avs_get_var_bool(AVS_ScriptEnvironment * p, const char* name...
function avs_get_var_int (line 1618) | int AVSC_CC avs_get_var_int(AVS_ScriptEnvironment * p, const char* name,...
function avs_get_var_double (line 1625) | double AVSC_CC avs_get_var_double(AVS_ScriptEnvironment * p, const char*...
function avs_get_var_long (line 1639) | int64_t AVSC_CC avs_get_var_long(AVS_ScriptEnvironment * p, const char* ...
function AVS_ScriptEnvironment (line 1654) | AVS_ScriptEnvironment * AVSC_CC avs_create_script_environment(int version)
function avs_delete_script_environment (line 1677) | void AVSC_CC avs_delete_script_environment(AVS_ScriptEnvironment * e)
FILE: avs_core/core/avs_simd_c.h
function Avs_SimdArray (line 95) | alignas(N * sizeof(T)) Avs_SimdArray {
function AVS_FORCEINLINE (line 196) | static AVS_FORCEINLINE VecType subtract(const VecType& a, const VecType&...
function AVS_FORCEINLINE (line 204) | static AVS_FORCEINLINE VecType multiply(const VecType& a, const VecType&...
function AVS_FORCEINLINE (line 212) | static AVS_FORCEINLINE VecType scalar_multiply(const VecType& a, ScalarT...
function AVS_FORCEINLINE (line 231) | static AVS_FORCEINLINE VecType left_shift(const VecType& a, int shift) {
function AVS_FORCEINLINE (line 239) | static AVS_FORCEINLINE VecType right_shift(const VecType& a, int shift) {
function AVS_FORCEINLINE (line 270) | AVS_FORCEINLINE explicit VectorWrapper(ElementType val) {
function AVS_FORCEINLINE (line 318) | AVS_FORCEINLINE explicit VectorWrapper(const VecType& vec) {
function AVS_FORCEINLINE (line 336) | AVS_FORCEINLINE VectorWrapper(const VectorWrapper& other) : data(other.d...
function AVS_FORCEINLINE (line 338) | AVS_FORCEINLINE VectorWrapper(const VectorWrapper& other) {
function AVS_FORCEINLINE (line 361) | AVS_FORCEINLINE VectorWrapper(std::initializer_list<ElementType> values) {
function AVS_FORCEINLINE (line 372) | AVS_FORCEINLINE void load_lo(const ElementType* ptr) {
function VectorWrapper (line 392) | static VectorWrapper convert_from(const VectorWrapper<OtherDerived, Othe...
function VectorWrapper (line 411) | static VectorWrapper convert_from_lo(const VectorWrapper<OtherDerived, O...
function VectorWrapper (line 425) | static VectorWrapper convert_from_hi(const VectorWrapper<OtherDerived, O...
function AVS_FORCEINLINE (line 440) | AVS_FORCEINLINE void load_from_any_intptr(const uint8_t* ptr) {
function AVS_FORCEINLINE (line 454) | AVS_FORCEINLINE void load_from_any_intptr(const short* ptr) {
function AVS_FORCEINLINE (line 468) | AVS_FORCEINLINE void load_from_any_intptr(const uint16_t* ptr) {
function AVS_FORCEINLINE (line 482) | AVS_FORCEINLINE void load_from_any_intptr(const int32_t* ptr) {
function AVS_FORCEINLINE (line 498) | AVS_FORCEINLINE void load(const ElementType* ptr) {
function AVS_FORCEINLINE (line 510) | AVS_FORCEINLINE static VectorWrapper from_ptr(const ElementType* ptr) {
function AVS_FORCEINLINE (line 557) | AVS_FORCEINLINE static VectorWrapper from_ptr_lo(const ElementType* ptr) {
function AVS_FORCEINLINE (line 597) | AVS_FORCEINLINE void store(ElementType* ptr) const {
function VectorWrapper (line 644) | VectorWrapper operator<<(int shift) const {
function AVS_FORCEINLINE (line 662) | AVS_FORCEINLINE VectorWrapper shift_right_logical(int shift) const {
function AVS_FORCEINLINE (line 723) | AVS_FORCEINLINE VectorWrapper min(ElementType scalar) const {
function AVS_FORCEINLINE (line 740) | AVS_FORCEINLINE VectorWrapper max(ElementType scalar) const {
function AVS_FORCEINLINE (line 804) | AVS_FORCEINLINE VecType& raw() { return data; }
function AVS_FORCEINLINE (line 807) | AVS_FORCEINLINE ElementType operator[](size_t idx) const {
function AVS_FORCEINLINE (line 813) | AVS_FORCEINLINE void set(size_t idx, ElementType value) {
function size (line 885) | static constexpr size_t size() { return N; }
function AVS_FORCEINLINE (line 1025) | [[maybe_unused]] static AVS_FORCEINLINE void convert_and_saturate_int32x...
function AVS_FORCEINLINE (line 1054) | [[maybe_unused]] static AVS_FORCEINLINE void convert_and_saturate_int32x...
function AVS_FORCEINLINE (line 1081) | [[maybe_unused]] static AVS_FORCEINLINE void convert_and_saturate_int32x...
function AVS_FORCEINLINE (line 1089) | [[maybe_unused]] static AVS_FORCEINLINE void convert_and_saturate_int32x...
function AVS_FORCEINLINE (line 1125) | [[maybe_unused]] static AVS_FORCEINLINE void convert_and_saturate_int32x...
function AVS_FORCEINLINE (line 1153) | [[maybe_unused]]
function AVS_FORCEINLINE (line 1194) | [[maybe_unused]]
function AVS_FORCEINLINE (line 1227) | [[maybe_unused]]
function AVS_FORCEINLINE (line 1267) | [[maybe_unused]]
function AVS_FORCEINLINE (line 1305) | [[maybe_unused]]
function AVS_FORCEINLINE (line 1332) | [[maybe_unused]]
function AVS_FORCEINLINE (line 1346) | [[maybe_unused]]
FILE: avs_core/core/bitblt.cpp
function asm_BitBlt_ISSE (line 43) | static void asm_BitBlt_ISSE(BYTE* dstp, int dst_pitch, const BYTE* srcp,...
function BitBlt (line 261) | void BitBlt(BYTE* dstp, int dst_pitch, const BYTE* srcp, int src_pitch, ...
FILE: avs_core/core/bitblt.h
type BYTE (line 35) | typedef unsigned char BYTE;
FILE: avs_core/core/cache.cpp
class CacheStack (line 62) | class CacheStack
method CacheStack (line 67) | CacheStack(InternalEnvironment* env)
type CachePimpl (line 76) | struct CachePimpl
method CachePimpl (line 95) | CachePimpl(const PClip& _child, CacheMode mode) :
function VideoInfo (line 442) | const VideoInfo& __stdcall AvsCache::GetVideoInfo()
function PClip (line 624) | PClip CacheGuard::GetCache(IScriptEnvironment* env_, bool use_child_if_n...
function PVideoFrame (line 675) | PVideoFrame __stdcall CacheGuard::GetFrame(int n, IScriptEnvironment* env_)
function VideoInfo (line 707) | const VideoInfo& __stdcall CacheGuard::GetVideoInfo()
function AVSValue (line 889) | AVSValue __cdecl CacheGuard::Create(AVSValue args, void*, IScriptEnviron...
FILE: avs_core/core/cache.h
type CachePimpl (line 43) | struct CachePimpl
function class (line 46) | class AvsCache : public IClip
type CacheHints (line 79) | struct CacheHints {
FILE: avs_core/core/clip_info.h
function IUnknown (line 43) | struct IAvisynthClipInfo : IUnknown {
FILE: avs_core/core/cpuid.cpp
function __cpuid (line 50) | static inline void __cpuid(int cpuinfo[4], int leaf) {
function get_xcr0 (line 82) | static uint32_t get_xcr0()
function __cpuid_count_wrapper (line 95) | static void __cpuid_count_wrapper(int info[4], int leaf, int subleaf) {
function get_avx10_minor_version (line 110) | static int get_avx10_minor_version() {
function ARMCheckForExtensions (line 147) | static int64_t ARMCheckForExtensions()
function X86CheckForExtensions (line 264) | static int64_t X86CheckForExtensions()
function CPUCheckForExtensions (line 454) | static int64_t CPUCheckForExtensions()
function parse_sysfs_size_string (line 470) | static size_t parse_sysfs_size_string(const char* size_str) {
function DetectL2CacheSize (line 497) | static size_t DetectL2CacheSize()
class _CPUFlags (line 606) | class _CPUFlags
method _CPUFlags (line 611) | _CPUFlags() {
method _CPUFlags (line 617) | static _CPUFlags& getInstance() {
method GetCPUFlags (line 622) | int GetCPUFlags() {
method GetCPUFlagsEx (line 626) | int64_t GetCPUFlagsEx() {
method SetCPUFlags (line 630) | void SetCPUFlags(int64_t new_flags) {
method GetL2CacheSize (line 634) | size_t GetL2CacheSize() {
function GetCPUFlags (line 639) | int GetCPUFlags() {
function GetCPUFlagsEx (line 643) | int64_t GetCPUFlagsEx() {
function GetL2CacheSize (line 647) | size_t GetL2CacheSize() {
FILE: avs_core/core/exception.cpp
function SehTranslatorFunction (line 122) | void SehTranslatorFunction(unsigned int code, struct _EXCEPTION_POINTERS...
FILE: avs_core/core/exception.h
type _EXCEPTION_POINTERS (line 42) | struct _EXCEPTION_POINTERS
function class (line 44) | class SehGuard
function class (line 63) | class SehGuard
function class (line 73) | class SehException
FILE: avs_core/core/findfirst.h
type _finddata_t (line 33) | struct _finddata_t {
type _finddata_t (line 50) | struct _finddata_t
type _finddata_t (line 60) | struct _finddata_t
FILE: avs_core/core/fonts/fixedfonts.cpp
type fixed_font_12n (line 36) | namespace fixed_font_12n {
type fixed_font_12b (line 1498) | namespace fixed_font_12b {
type fixed_font_14n (line 1520) | namespace fixed_font_14n {
type fixed_font_14b (line 2982) | namespace fixed_font_14b {
type fixed_font_16n (line 4444) | namespace fixed_font_16n {
type fixed_font_16b (line 5906) | namespace fixed_font_16b {
type fixed_font_18n (line 7368) | namespace fixed_font_18n {
type fixed_font_18b (line 10184) | namespace fixed_font_18b {
type fixed_font_20n (line 13000) | namespace fixed_font_20n {
type fixed_font_20b (line 15816) | namespace fixed_font_20b {
type fixed_font_22n (line 18632) | namespace fixed_font_22n {
type fixed_font_22b (line 21448) | namespace fixed_font_22b {
type fixed_font_24n (line 24264) | namespace fixed_font_24n {
type fixed_font_24b (line 27080) | namespace fixed_font_24b {
type fixed_font_28n (line 29896) | namespace fixed_font_28n {
type fixed_font_28b (line 32712) | namespace fixed_font_28b {
type fixed_font_32n (line 35528) | namespace fixed_font_32n {
type fixed_font_32b (line 38344) | namespace fixed_font_32b {
type fixed_font_info_h (line 41160) | namespace fixed_font_info_h {
type fixed_font_info_h_bold (line 41589) | namespace fixed_font_info_h_bold {
FILE: avs_core/core/fonts/fixedfonts.h
type FixedFont_info_t (line 6) | typedef struct {
FILE: avs_core/core/function.h
type Function (line 5) | struct Function {
type CaptureVars (line 20) | struct CaptureVars {
function class (line 26) | class IFunction {
function class (line 44) | class AVSFunction : public Function {
FILE: avs_core/core/info.cpp
type CharInfo (line 204) | struct CharInfo { // STARTCHAR charname
type FontProperties (line 216) | struct FontProperties {
type FontInfo (line 227) | struct FontInfo {
class BdfFont (line 236) | class BdfFont {
function UnQuote (line 249) | std::string UnQuote(std::string s) {
function vector_shl (line 255) | static void vector_shl(uint8_t* buf, const size_t size, const size_t bit...
function vector_shr (line 281) | static void vector_shr(uint8_t* buf, const size_t size, const size_t bit...
function BdfFont (line 309) | static BdfFont LoadBMF(std::string name, bool bold) {
function alignToBitmask (line 718) | static int alignToBitmask(int align_1_to_9)
function getColorForPlane (line 738) | static int getColorForPlane(int plane, int color)
function LightOneUVPixel (line 817) | static void LightOneUVPixel(pixel_t* dstpU, int j, pixel_t* dstpV, pixel...
function adjustWriteLimits (line 901) | static void adjustWriteLimits(std::vector<int>& s, const std::vector<BBX...
function insert_from_msb_bit (line 996) | static void insert_from_msb_bit(uint8_t *dst, int bitposition, const uin...
function get_bit (line 1036) | static uint8_t get_bit(uint8_t* src, const int bitposition)
function get_bits (line 1044) | static int get_bits(uint8_t* src, int bitposition, int count)
function getHBDColor_UV (line 1324) | static auto getHBDColor_UV(int color, int bits_per_pixel)
function getHBDColor_Y (line 1334) | static auto getHBDColor_Y(int color, int bits_per_pixel)
function getHBDColor_RGB (line 1343) | static auto getHBDColor_RGB(int color, int bits_per_pixel)
function Render1by1Planes (line 1354) | void Render1by1Planes(int bits_per_pixel, int color, int halocolor, int*...
function RenderUV (line 1419) | void RenderUV(int bits_per_pixel, int color, int halocolor, int* pitches...
function do_DrawStringPlanar (line 1608) | void do_DrawStringPlanar(
function RenderYUY2 (line 1694) | void RenderYUY2(int color, int halocolor, int pitch, BYTE* _dstp, PreRen...
function do_DrawStringYUY2 (line 1815) | static void do_DrawStringYUY2(
function RenderPackedRGB (line 1846) | static void RenderPackedRGB(int color, int halocolor, BYTE* _dstp, int p...
function do_DrawStringPackedRGB (line 1891) | static void do_DrawStringPackedRGB(
function strequals_i (line 1911) | static bool strequals_i(const std::string& a, const std::string& b)
function GetBitmapFont (line 1925) | std::unique_ptr<BitmapFont> GetBitmapFont(int size, const char *name, bo...
function DrawString_internal (line 2017) | static void DrawString_internal(BitmapFont* current_font, const VideoInf...
function SimpleTextOutW (line 2175) | void SimpleTextOutW(BitmapFont *current_font, const VideoInfo& vi, PVide...
function SimpleTextOutW_multi (line 2182) | void SimpleTextOutW_multi(BitmapFont *current_font, const VideoInfo& vi,...
function DrawStringPlanar (line 2225) | void DrawStringPlanar(VideoInfo& vi, PVideoFrame& dst, int x, int y, con...
function DrawStringYUY2 (line 2255) | void DrawStringYUY2(VideoInfo& vi, PVideoFrame& dst, int x, int y, const...
function DrawStringRGB24 (line 2261) | void DrawStringRGB24(VideoInfo &vi, PVideoFrame& dst, int x, int y, cons...
function DrawStringRGB32 (line 2267) | void DrawStringRGB32(VideoInfo& vi, PVideoFrame& dst, int x, int y, cons...
FILE: avs_core/core/info.h
type ChromaLocationMode (line 50) | enum ChromaLocationMode {
type BBX (line 58) | typedef struct BBX {
function class (line 65) | class PreRendered {
function class (line 101) | class BitmapFont {
FILE: avs_core/core/interface.cpp
function BYTE (line 440) | const BYTE* VideoFrameBuffer::GetReadPtr() const { return data; }
function BYTE (line 444) | BYTE* VideoFrameBuffer::GetWritePtr() { InterlockedIncrement(&sequence_n...
function VideoFrameBuffer (line 570) | VideoFrameBuffer* VideoFrame::GetFrameBuffer() const { return vfb; }
function BYTE (line 580) | const BYTE* VideoFrame::GetReadPtr(int plane) const { return vfb->GetRea...
function BYTE (line 594) | BYTE* VideoFrame::GetWritePtr(int plane) const {
function AVSMap (line 605) | AVSMap& VideoFrame::getProperties() {
function AVSMap (line 609) | const AVSMap& VideoFrame::getConstProperties() {
function PDevice (line 617) | PDevice VideoFrame::GetDevice() const {
function IClip (line 671) | IClip* PClip::GetPointerWithAddRef() const { if (p) p->AddRef(); return ...
function AVSValue (line 853) | AVSValue& AVSValue::operator=(const AVSValue& v) { return OPERAT...
function AVSValue (line 854) | AVSValue& AVSValue::OPERATOR_ASSIGN(const AVSValue& v) { Assign(&v, fa...
function PClip (line 879) | PClip AVSValue::AsClip() const { _ASSERTE(IsClip()); return IsClip()?cli...
function PFunction (line 977) | PFunction AVSValue::AsFunction() const { _ASSERTE(IsFunction()); return ...
function AVSValue (line 981) | const AVSValue& AVSValue::operator[](int index) const { return OPERA...
function AVSValue (line 982) | const AVSValue& AVSValue::OPERATOR_INDEX(int index) const {
function AvsValueType (line 1062) | AvsValueType AVSValue::GetType() const { return (AvsValueType)type; }
function PFunction (line 1077) | PFunction& PFunction::operator=(IFunction* p) { return OPERATOR_ASSIGN0(...
function PFunction (line 1078) | PFunction& PFunction::OPERATOR_ASSIGN0(IFunction* p) { Set(p); return *t...
function PFunction (line 1080) | PFunction& PFunction::operator=(const PFunction& p) { return OPERATOR_AS...
function PFunction (line 1081) | PFunction& PFunction::OPERATOR_ASSIGN1(const PFunction& p) { Set(p.e); r...
function IFunction (line 1086) | IFunction * PFunction::GetPointerWithAddRef() const { if (e) e->AddRef()...
function PDevice (line 1099) | PDevice& PDevice::operator=(Device* p) { return OPERATOR_ASSIGN0(p); }
function PDevice (line 1100) | PDevice& PDevice::OPERATOR_ASSIGN0(Device* p) { e = p; return *this; }
function PDevice (line 1102) | PDevice& PDevice::operator=(const PDevice& p) { return OPERATOR_ASSIGN1(...
function PDevice (line 1103) | PDevice& PDevice::OPERATOR_ASSIGN1(const PDevice& p) { e = p.e; return *...
function AvsDeviceType (line 1108) | AvsDeviceType PDevice::GetType() const { return e ? e->device_type : DEV...
FILE: avs_core/core/internal.h
type MANAGE_CACHE_KEYS (line 76) | enum MANAGE_CACHE_KEYS
function class (line 114) | class _PixelClip {
function Relink (line 130) | __inline void Relink(ListNode* newprev, ListNode* me, ListNode* newnext) {
function class (line 139) | class CWDChanger
function class (line 165) | class DllDirChanger
function class (line 176) | class NonCachedGenericVideoFilter : public GenericVideoFilter
function AVS_FORCEINLINE (line 192) | [[maybe_unused]] static AVS_FORCEINLINE float uv8tof(int color) {
function AVS_FORCEINLINE (line 197) | [[maybe_unused]] static AVS_FORCEINLINE float c8tof(int color) {
function AVS_FORCEINLINE (line 201) | [[maybe_unused]] static AVS_FORCEINLINE uint8_t Scaled15bitPixelClip(int...
function AVS_FORCEINLINE (line 205) | [[maybe_unused]] static AVS_FORCEINLINE uint8_t ScaledPixelClip(int i) {
function AVS_FORCEINLINE (line 211) | [[maybe_unused]] static AVS_FORCEINLINE uint16_t ScaledPixelClip(int64_t...
function AVS_FORCEINLINE (line 215) | [[maybe_unused]] static AVS_FORCEINLINE uint16_t ScaledPixelClipEx(int64...
function AVS_FORCEINLINE (line 219) | [[maybe_unused]] static AVS_FORCEINLINE bool IsClose(int a, int b, unsig...
function AVS_FORCEINLINE (line 222) | [[maybe_unused]] static AVS_FORCEINLINE bool IsCloseFloat(float a, float...
function AVS_FORCEINLINE (line 230) | [[maybe_unused]] static AVS_FORCEINLINE __m128i _MM_MULLO_EPI32(const __...
function AVS_FORCEINLINE (line 240) | [[maybe_unused]] static AVS_FORCEINLINE __m128i _MM_PACKUS_EPI32( __m128...
function AVS_FORCEINLINE (line 254) | [[maybe_unused]] static AVS_FORCEINLINE __m128i _MM_PACKUS_EPI32_SRC_TRU...
function AVS_FORCEINLINE (line 264) | [[maybe_unused]] static AVS_FORCEINLINE __m128i _MM_CMPLE_EPU16(__m128i ...
function AVS_FORCEINLINE (line 270) | [[maybe_unused]] static AVS_FORCEINLINE __m128i _MM_BLENDV_SI128(__m128i...
function AVS_FORCEINLINE (line 277) | [[maybe_unused]] static AVS_FORCEINLINE __m128i _MM_BLENDV_EPI8(__m128i ...
function AVS_FORCEINLINE (line 282) | [[maybe_unused]] static AVS_FORCEINLINE __m128i _MM_MIN_EPU16(__m128i x,...
function AVS_FORCEINLINE (line 289) | [[maybe_unused]] static AVS_FORCEINLINE __m128i _MM_MAX_EPU16(__m128i x,...
function class (line 302) | class GlobalVarFrame
FILE: avs_core/core/main.cpp
function ReportMe (line 92) | void ReportMe(const char * msg, ...) {
type IAvisynthClipInfo (line 143) | struct IAvisynthClipInfo : IUnknown {
class CAVIFileSynth (line 162) | class CAVIFileSynth final: public IAVIFile, public IPersistFile, public ...
class CAVIStreamSynth (line 251) | class CAVIStreamSynth
class CAVIStreamSynth (line 255) | class CAVIStreamSynth final: public IAVIStream, public IAVIStreaming {
function BOOL (line 310) | BOOL APIENTRY DllMain(HANDLE hModule, ULONG ulReason, LPVOID lpReserved) {
function STDAPI (line 331) | STDAPI DllGetClassObject(IN REFCLSID rclsid, IN REFIID riid, OUT LPVOID ...
function STDAPI (line 346) | STDAPI DllCanUnloadNow() {
function STDMETHODIMP (line 360) | STDMETHODIMP CAVIFileSynth::CreateInstance (LPUNKNOWN pUnkOuter, REFIID ...
function STDMETHODIMP (line 375) | STDMETHODIMP CAVIFileSynth::LockServer (BOOL fLock) {
function STDMETHODIMP (line 383) | STDMETHODIMP CAVIFileSynth::GetClassID(LPCLSID lpClassID) { // IPersist
function STDMETHODIMP (line 393) | STDMETHODIMP CAVIFileSynth::IsDirty() {
function STDMETHODIMP (line 398) | STDMETHODIMP CAVIFileSynth::Load(LPCOLESTR lpszFileName, DWORD grfMode) {
function STDMETHODIMP (line 408) | STDMETHODIMP CAVIFileSynth::Save(LPCOLESTR lpszFileName, BOOL fRemember) {
function STDMETHODIMP (line 413) | STDMETHODIMP CAVIFileSynth::SaveCompleted(LPCOLESTR lpszFileName) {
function STDMETHODIMP (line 418) | STDMETHODIMP CAVIFileSynth::GetCurFile(LPOLESTR *lplpszFileName) {
function HRESULT (line 429) | HRESULT CAVIFileSynth::Create(const CLSID& rclsid, const IID& riid, void...
function STDMETHODIMP (line 449) | STDMETHODIMP CAVIFileSynth::QueryInterface(const IID& iid, void **ppv) {
function STDMETHODIMP (line 518) | STDMETHODIMP CAVIStreamSynth::QueryInterface(const IID& iid, void **ppv) {
function STDMETHODIMP (line 578) | STDMETHODIMP CAVIFileSynth::CreateStream(PAVISTREAM *ppStream, AVISTREAM...
function STDMETHODIMP (line 584) | STDMETHODIMP CAVIFileSynth::EndRecord() {
function STDMETHODIMP (line 589) | STDMETHODIMP CAVIFileSynth::Save(LPCSTR szFile, AVICOMPRESSOPTIONS FAR *...
function STDMETHODIMP (line 595) | STDMETHODIMP CAVIFileSynth::ReadData(DWORD fcc, LPVOID lp, LONG *lpcb) {
function STDMETHODIMP (line 600) | STDMETHODIMP CAVIFileSynth::WriteData(DWORD fcc, LPVOID lpBuffer, LONG c...
function STDMETHODIMP (line 605) | STDMETHODIMP CAVIFileSynth::DeleteStream(DWORD fccType, LONG lParam) {
function STDMETHODIMP (line 651) | STDMETHODIMP CAVIFileSynth::Open(LPCSTR szFile, UINT mode, LPCOLESTR lps...
function STDMETHODIMP (line 855) | STDMETHODIMP CAVIFileSynth::Info(AVIFILEINFOW *pfi, LONG lSize) {
function BePrintable (line 893) | static inline char BePrintable(int ch) {
function STDMETHODIMP (line 899) | STDMETHODIMP CAVIFileSynth::GetStream(PAVISTREAM *ppStream, DWORD fccTyp...
function STDMETHODIMP (line 986) | STDMETHODIMP CAVIStreamSynth::Begin(LONG lStart, LONG lEnd, LONG lRate) {
function STDMETHODIMP (line 991) | STDMETHODIMP CAVIStreamSynth::End() {
function STDMETHODIMP (line 998) | STDMETHODIMP CAVIStreamSynth::Create(LPARAM lParam1, LPARAM lParam2) {
function STDMETHODIMP (line 1003) | STDMETHODIMP CAVIStreamSynth::Delete(LONG lStart, LONG lSamples) {
function STDMETHODIMP (line 1008) | STDMETHODIMP CAVIStreamSynth::ReadData(DWORD fcc, LPVOID lp, LONG *lpcb) {
function STDMETHODIMP (line 1013) | STDMETHODIMP CAVIStreamSynth::SetFormat(LONG lPos, LPVOID lpFormat, LONG...
function STDMETHODIMP (line 1018) | STDMETHODIMP CAVIStreamSynth::WriteData(DWORD fcc, LPVOID lpBuffer, LONG...
function STDMETHODIMP (line 1023) | STDMETHODIMP CAVIStreamSynth::SetInfo(AVISTREAMINFOW *psi, LONG lSize) {
function STDMETHODIMP (line 1420) | STDMETHODIMP CAVIStreamSynth::Read(LONG lStart, LONG lSamples, LPVOID lp...
function HRESULT (line 1440) | HRESULT CAVIStreamSynth::Read2(LONG lStart, LONG lSamples, LPVOID lpBuff...
function STDMETHODIMP (line 1565) | STDMETHODIMP CAVIStreamSynth::ReadFormat(LONG lPos, LPVOID lpFormat, LON...
function STDMETHODIMP (line 1741) | STDMETHODIMP CAVIStreamSynth::Write(LONG lStart, LONG lSamples, LPVOID l...
FILE: avs_core/core/mpmc_bounded_queue.h
type T (line 9) | typedef T value_type;
function push_front (line 40) | bool push_front(T&& item)
function pop_back (line 52) | bool pop_back(T* pItem)
type typename (line 78) | typedef typename container_type::size_type size_type;
type typename (line 79) | typedef typename container_type::value_type value_type;
function finish (line 103) | void finish()
function is_finished (line 113) | bool is_finished()
function push_front (line 119) | bool push_front(T&& item)
function pop_back (line 138) | bool pop_back(value_type* pItem)
function pop_remain (line 157) | bool pop_remain(value_type* pItem)
FILE: avs_core/core/parser/expression.cpp
class BreakStmtException (line 50) | class BreakStmtException
class ContinueStmtException (line 54) | class ContinueStmtException
function AVSValue (line 58) | AVSValue ExpRootBlock::Evaluate(IScriptEnvironment* env)
function AVSValue (line 72) | AVSValue ExpSequence::Evaluate(IScriptEnvironment* env)
function AVSValue (line 79) | AVSValue ExpExceptionTranslator::Evaluate(IScriptEnvironment* env)
function AVSValue (line 113) | AVSValue ExpTryCatch::Evaluate(IScriptEnvironment* env)
function AVSValue (line 126) | AVSValue ExpLine::Evaluate(IScriptEnvironment* env)
function AVSValue (line 137) | AVSValue ExpBlockConditional::Evaluate(IScriptEnvironment* env)
function AVSValue (line 159) | AVSValue ExpWhileLoop::Evaluate(IScriptEnvironment* env)
function AVSValue (line 203) | AVSValue ExpForLoop::Evaluate(IScriptEnvironment* env)
function AVSValue (line 266) | AVSValue ExpBreak::Evaluate(IScriptEnvironment* env)
function AVSValue (line 271) | AVSValue ExpContinue::Evaluate(IScriptEnvironment* env)
function AVSValue (line 276) | AVSValue ExpConditional::Evaluate(IScriptEnvironment* env)
function AVSValue (line 284) | AVSValue ExpReturn::Evaluate(IScriptEnvironment* env)
function AVSValue (line 295) | AVSValue ExpOr::Evaluate(IScriptEnvironment* env)
function AVSValue (line 309) | AVSValue ExpAnd::Evaluate(IScriptEnvironment* env)
function AVSValue (line 323) | AVSValue ExpEqual::Evaluate(IScriptEnvironment* env)
function AVSValue (line 355) | AVSValue ExpLess::Evaluate(IScriptEnvironment* env)
function AVSValue (line 377) | AVSValue ExpPlus::Evaluate(IScriptEnvironment* env)
function AVSValue (line 405) | AVSValue ExpDoublePlus::Evaluate(IScriptEnvironment* env)
function AVSValue (line 420) | AVSValue ExpMinus::Evaluate(IScriptEnvironment* env)
function AVSValue (line 442) | AVSValue ExpMult::Evaluate(IScriptEnvironment* env)
function AVSValue (line 464) | AVSValue ExpDiv::Evaluate(IScriptEnvironment* env)
function AVSValue (line 488) | AVSValue ExpMod::Evaluate(IScriptEnvironment* env)
function AVSValue (line 508) | AVSValue ExpNegate::Evaluate(IScriptEnvironment* env)
function AVSValue (line 532) | AVSValue ExpNot::Evaluate(IScriptEnvironment* env)
function AVSValue (line 544) | AVSValue ExpVariableReference::Evaluate(IScriptEnvironment* env)
function AVSValue (line 577) | AVSValue ExpAssignment::Evaluate(IScriptEnvironment* env)
function AVSValue (line 598) | AVSValue ExpGlobalAssignment::Evaluate(IScriptEnvironment* env)
function AVSValue (line 623) | AVSValue ExpFunctionCall::Evaluate(IScriptEnvironment* env)
class WrappedFunction (line 708) | class WrappedFunction : public IFunction
method WrappedFunction (line 711) | WrappedFunction(const char* const name)
method Function (line 717) | virtual const Function* GetDefinition() { return nullptr; }
method CaptureVars (line 718) | virtual CaptureVars GetCaptures() { return CaptureVars(); }
function AVSValue (line 727) | AVSValue ExpFunctionWrapper::Evaluate(IScriptEnvironment* env) {
function AVSValue (line 765) | AVSValue ExpFunctionDefinition::Evaluate(IScriptEnvironment* env)
function is_within_int_in_float32_range (line 818) | static bool is_within_int_in_float32_range(int64_t value) {
function AVSValue (line 823) | AVSValue FunctionInstance::Execute(const AVSValue& args, IScriptEnvironm...
function AVSValue (line 853) | AVSValue FunctionInstance::Execute_(AVSValue args, void* user_data, IScr...
FILE: avs_core/core/parser/expression.h
type ReturnExprException (line 48) | struct ReturnExprException
function class (line 55) | class Expression {
function class (line 69) | class PExpression
function class (line 97) | class ExpRootBlock : public Expression
function class (line 107) | class ExpConstant : public Expression
function class (line 127) | class ExpSequence : public Expression
function class (line 137) | class ExpExceptionTranslator : public Expression
function class (line 149) | class ExpTryCatch : public ExpExceptionTranslator
function class (line 161) | class ExpLine : public ExpExceptionTranslator
function class (line 174) | class ExpBlockConditional : public Expression
function class (line 186) | class ExpWhileLoop : public Expression
function class (line 198) | class ExpForLoop : public Expression
function class (line 211) | class ExpBreak : public Expression
function class (line 218) | class ExpContinue : public Expression
function class (line 225) | class ExpConditional : public Expression
function class (line 236) | class ExpReturn : public Expression
function class (line 250) | class ExpOr : public Expression
function class (line 261) | class ExpAnd : public Expression
function class (line 272) | class ExpEqual : public Expression
function class (line 283) | class ExpLess : public Expression
function class (line 294) | class ExpPlus : public Expression
function class (line 305) | class ExpDoublePlus : public Expression
function class (line 316) | class ExpMinus : public Expression
function class (line 327) | class ExpMult : public Expression
function class (line 338) | class ExpDiv : public Expression
function class (line 349) | class ExpMod : public Expression
function class (line 360) | class ExpNegate : public Expression
function class (line 371) | class ExpNot : public Expression
function class (line 382) | class ExpVariableReference : public Expression
function class (line 395) | class ExpAssignment : public Expression
function class (line 410) | class ExpGlobalAssignment : public Expression
function class (line 422) | class ExpFunctionCall : public Expression
function class (line 441) | class ExpLegacyFunctionDefinition : public Expression {
function class (line 447) | class ExpFunctionWrapper : public Expression
FILE: avs_core/core/parser/os/win32_string_compat.h
type _finddata_t (line 17) | struct _finddata_t
type _finddata_t (line 27) | struct _finddata_t
FILE: avs_core/core/parser/script.cpp
function is_within_int_in_float32_range (line 382) | static bool is_within_int_in_float32_range(int64_t value) {
function AVSValue (line 386) | AVSValue ScriptFunction::Execute(AVSValue args, void* user_data, IScript...
function AVSValue (line 513) | AVSValue Assert(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 520) | AVSValue AssertEval(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 532) | AVSValue Eval(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 541) | AVSValue Apply(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 546) | AVSValue EvalOop(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 563) | AVSValue Import(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 739) | AVSValue ScriptName(AVSValue args, void*, IScriptEnvironment* env) { ret...
function AVSValue (line 740) | AVSValue ScriptFile(AVSValue args, void*, IScriptEnvironment* env) { ret...
function AVSValue (line 741) | AVSValue ScriptDir (AVSValue args, void*, IScriptEnvironment* env) { ret...
function AVSValue (line 742) | AVSValue ScriptNameUtf8(AVSValue args, void*, IScriptEnvironment* env) {...
function AVSValue (line 743) | AVSValue ScriptFileUtf8(AVSValue args, void*, IScriptEnvironment* env) {...
function AVSValue (line 744) | AVSValue ScriptDirUtf8(AVSValue args, void*, IScriptEnvironment* env) { ...
function AVSValue (line 745) | AVSValue SetWorkingDir(AVSValue args, void*, IScriptEnvironment* env) { ...
function AVSValue (line 747) | AVSValue Muldiv(AVSValue args, void*, IScriptEnvironment* ) {
function AVSValue (line 755) | AVSValue Floor(AVSValue args, void*, IScriptEnvironment* ) {
function AVSValue (line 762) | AVSValue Ceil(AVSValue args, void*, IScriptEnvironment* ) {
function AVSValue (line 769) | AVSValue Round(AVSValue args, void*, IScriptEnvironment* ) {
function AVSValue (line 776) | AVSValue Acos(AVSValue args, void* , IScriptEnvironment* ) { return acos...
function AVSValue (line 777) | AVSValue Asin(AVSValue args, void* , IScriptEnvironment* ) { return asin...
function AVSValue (line 778) | AVSValue Atan(AVSValue args, void* , IScriptEnvironment* ) { return atan...
function AVSValue (line 779) | AVSValue Atan2(AVSValue args, void* , IScriptEnvironment* ) { return ata...
function AVSValue (line 780) | AVSValue Cos(AVSValue args, void* , IScriptEnvironment* ) { return cos(a...
function AVSValue (line 781) | AVSValue Cosh(AVSValue args, void* , IScriptEnvironment* ) { return cosh...
function AVSValue (line 782) | AVSValue Exp(AVSValue args, void* , IScriptEnvironment* ) { return exp(a...
function AVSValue (line 783) | AVSValue Fmod(AVSValue args, void* , IScriptEnvironment* ) { return fmod...
function AVSValue (line 784) | AVSValue Log(AVSValue args, void* , IScriptEnvironment* ) { return log(a...
function AVSValue (line 785) | AVSValue Log10(AVSValue args, void* , IScriptEnvironment* ) { return log...
function AVSValue (line 786) | AVSValue Pow(AVSValue args, void* , IScriptEnvironment* ) { return pow(a...
function AVSValue (line 787) | AVSValue Sin(AVSValue args, void* , IScriptEnvironment* ) { return sin(a...
function AVSValue (line 788) | AVSValue Sinh(AVSValue args, void* , IScriptEnvironment* ) { return sinh...
function AVSValue (line 789) | AVSValue Tan(AVSValue args, void* , IScriptEnvironment* ) { return tan(a...
function AVSValue (line 790) | AVSValue Tanh(AVSValue args, void* , IScriptEnvironment* ) { return tanh...
function AVSValue (line 791) | AVSValue Sqrt(AVSValue args, void* , IScriptEnvironment* ) { return sqrt...
function AVSValue (line 794) | AVSValue Abs(AVSValue args, void* , IScriptEnvironment* ) {
function AVSValue (line 800) | AVSValue FAbs(AVSValue args, void* , IScriptEnvironment* ) { return fabs...
function AVSValue (line 801) | AVSValue Pi(AVSValue args, void* , IScriptEnvironment* ) { return 3.141...
function AVSValue (line 803) | AVSValue Tau(AVSValue args, void* , IScriptEnvironment* ) { return 6.283...
function AVSValue (line 805) | AVSValue Sign(AVSValue args, void*, IScriptEnvironment* ) { return args[...
function AVSValue (line 809) | AVSValue BitAnd(AVSValue args, void*, IScriptEnvironment* ) { return arg...
function AVSValue (line 810) | AVSValue BitNot(AVSValue args, void*, IScriptEnvironment* ) { return ~ar...
function AVSValue (line 811) | AVSValue BitOr(AVSValue args, void*, IScriptEnvironment* ) { return arg...
function AVSValue (line 812) | AVSValue BitXor(AVSValue args, void*, IScriptEnvironment* ) { return arg...
function AVSValue (line 814) | AVSValue BitAnd64(AVSValue args, void*, IScriptEnvironment*) { return ar...
function AVSValue (line 815) | AVSValue BitNot64(AVSValue args, void*, IScriptEnvironment*) { return ~a...
function AVSValue (line 816) | AVSValue BitOr64(AVSValue args, void*, IScriptEnvironment*) { return arg...
function AVSValue (line 817) | AVSValue BitXor64(AVSValue args, void*, IScriptEnvironment*) { return ar...
function AVSValue (line 819) | AVSValue BitLShift(AVSValue args, void*, IScriptEnvironment* ) { return ...
function AVSValue (line 820) | AVSValue BitRShiftL(AVSValue args, void*, IScriptEnvironment* ) { return...
function AVSValue (line 821) | AVSValue BitRShiftA(AVSValue args, void*, IScriptEnvironment* ) { return...
function AVSValue (line 823) | AVSValue BitLShift64(AVSValue args, void*, IScriptEnvironment*) { return...
function AVSValue (line 824) | AVSValue BitRShift64L(AVSValue args, void*, IScriptEnvironment*) { retur...
function AVSValue (line 825) | AVSValue BitRShift64A(AVSValue args, void*, IScriptEnvironment*) { retur...
function a_rol (line 827) | static unsigned int a_rol(unsigned int value, int shift) {
function a_rol (line 832) | static uint64_t a_rol(uint64_t value, int shift) {
function a_ror (line 838) | static unsigned int a_ror(unsigned int value, int shift) {
function a_ror (line 843) | static uint64_t a_ror(uint64_t value, int shift) {
function a_btc (line 849) | static int a_btc(int value, int bit) {
function a_btc (line 853) | static int64_t a_btc(int64_t value, int bit) {
function a_btr (line 858) | static int a_btr(int value, int bit) {
function a_btr (line 862) | static int64_t a_btr(int64_t value, int bit) {
function a_bts (line 867) | static int a_bts(int value, int bit) {
function a_bts (line 871) | static int64_t a_bts(int64_t value, int bit) {
function a_bt (line 876) | static bool a_bt(int value, int bit) {
function a_bt (line 879) | static bool a_bt(int64_t value, int bit) {
function AVSValue (line 883) | AVSValue BitRotateL(AVSValue args, void*, IScriptEnvironment* ) { return...
function AVSValue (line 884) | AVSValue BitRotateR(AVSValue args, void*, IScriptEnvironment* ) { return...
function AVSValue (line 885) | AVSValue BitRotate64L(AVSValue args, void*, IScriptEnvironment*) { retur...
function AVSValue (line 886) | AVSValue BitRotate64R(AVSValue args, void*, IScriptEnvironment*) { retur...
function AVSValue (line 888) | AVSValue BitChg(AVSValue args, void*, IScriptEnvironment* ) { return a_b...
function AVSValue (line 889) | AVSValue BitClr(AVSValue args, void*, IScriptEnvironment* ) { return a_b...
function AVSValue (line 890) | AVSValue BitSet(AVSValue args, void*, IScriptEnvironment* ) { return a_b...
function AVSValue (line 891) | AVSValue BitTst(AVSValue args, void*, IScriptEnvironment* ) { return a_b...
function AVSValue (line 892) | AVSValue BitChg64(AVSValue args, void*, IScriptEnvironment*) { return a_...
function AVSValue (line 893) | AVSValue BitClr64(AVSValue args, void*, IScriptEnvironment*) { return a_...
function AVSValue (line 894) | AVSValue BitSet64(AVSValue args, void*, IScriptEnvironment*) { return a_...
function AVSValue (line 895) | AVSValue BitTst64(AVSValue args, void*, IScriptEnvironment*) { return a_...
function numberOfSetBits (line 897) | static int numberOfSetBits(uint32_t i)
function numberOfSetBits64 (line 904) | static int numberOfSetBits64(uint64_t i) {
function AVSValue (line 908) | AVSValue BitSetCount(AVSValue args, void*, IScriptEnvironment*) {
function AVSValue (line 918) | AVSValue BitSetCount64(AVSValue args, void*, IScriptEnvironment*) {
function AVSValue (line 938) | AVSValue UCase(AVSValue args, void*, IScriptEnvironment* env) {
function AVSValue (line 956) | AVSValue LCase(AVSValue args, void*, IScriptEnvironment* env) {
function AVSValue (line 965) | AVSValue StrLen(AVSValue args, void*, IScriptEnvironment* ) {
function AVSValue (line 983) | AVSValue RevStr(AVSValue args, void*, IScriptEnvironment* env) {
function AVSValue (line 992) | AVSValue LeftStr(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 1012) | AVSValue MidStr(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 1046) | AVSValue RightStr(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 1074) | AVSValue ReplaceStr(AVSValue args, void*, IScriptEnvironment* env) {
function AVSValue (line 1183) | AVSValue TrimLeft(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 1198) | AVSValue TrimRight(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 1232) | AVSValue TrimAll(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 1277) | AVSValue StrCmp(AVSValue args, void*, IScriptEnvironment*)
function AVSValue (line 1282) | AVSValue StrCmpi(AVSValue args, void*, IScriptEnvironment*)
function AVSValue (line 1287) | AVSValue FindStr(AVSValue args, void*, IScriptEnvironment*)
function AVSValue (line 1296) | AVSValue Rand(AVSValue args, void*, IScriptEnvironment*)
function AVSValue (line 1313) | AVSValue Select(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 1322) | AVSValue NOP(AVSValue args, void*, IScriptEnvironment*) { return 0;}
function AVSValue (line 1324) | AVSValue Undefined(AVSValue args, void*, IScriptEnvironment*) { return A...
function AVSValue (line 1326) | AVSValue Exist(AVSValue args, void*, IScriptEnvironment*nv) {
function spline (line 1354) | void spline(float x[], float y[], int n, float y2[])
function splint (line 1379) | int splint(float xa[], float ya[], float y2a[], int n, float x, float& y...
function AVSValue (line 1409) | AVSValue AVSChr(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 1418) | AVSValue AVSOrd(AVSValue args, void*, IScriptEnvironment*)
function AVSValue (line 1423) | AVSValue FillStr(AVSValue args, void*, IScriptEnvironment* env )
function AVSValue (line 1460) | AVSValue AVSTime(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 1473) | AVSValue Spline(AVSValue args, void*, IScriptEnvironment* env)
function VideoInfo (line 1516) | static inline const VideoInfo& VI(const AVSValue& arg) { return arg.AsCl...
function GetPixelTypeFromName (line 1615) | int GetPixelTypeFromName(const char *pixeltypename)
function AVSValue (line 1634) | AVSValue PixelType (AVSValue args, void*, IScriptEnvironment*) {
function AVSValue (line 1639) | AVSValue ColorSpaceNameToPixelType (AVSValue args, void*, IScriptEnviron...
function AVSValue (line 1643) | AVSValue Width(AVSValue args, void*, IScriptEnvironment*) { return VI(ar...
function AVSValue (line 1644) | AVSValue Height(AVSValue args, void*, IScriptEnvironment*) { return VI(a...
function AVSValue (line 1645) | AVSValue FrameCount(AVSValue args, void*, IScriptEnvironment*) { return ...
function AVSValue (line 1646) | AVSValue FrameRate(AVSValue args, void*, IScriptEnvironment*) { const Vi...
function AVSValue (line 1647) | AVSValue FrameRateNumerator(AVSValue args, void*, IScriptEnvironment*) {...
function AVSValue (line 1648) | AVSValue FrameRateDenominator(AVSValue args, void*, IScriptEnvironment*)...
function AVSValue (line 1649) | AVSValue AudioRate(AVSValue args, void*, IScriptEnvironment*) { return V...
function AVSValue (line 1650) | AVSValue AudioLength(AVSValue args, void*, IScriptEnvironment*) { return...
function AVSValue (line 1651) | AVSValue AudioLengthLo(AVSValue args, void*, IScriptEnvironment*) { retu...
function AVSValue (line 1652) | AVSValue AudioLengthHi(AVSValue args, void*, IScriptEnvironment*) { retu...
function AVSValue (line 1653) | AVSValue AudioLengthS(AVSValue args, void*, IScriptEnvironment* env) {
function AVSValue (line 1662) | AVSValue AudioLengthF(AVSValue args, void*, IScriptEnvironment*) { retur...
function AVSValue (line 1666) | AVSValue AudioDuration(AVSValue args, void*, IScriptEnvironment*) {
function AVSValue (line 1671) | AVSValue AudioChannels(AVSValue args, void*, IScriptEnvironment*) { ret...
function AVSValue (line 1672) | AVSValue AudioBits(AVSValue args, void*, IScriptEnvironment*) { return ...
function AVSValue (line 1673) | AVSValue IsAudioFloat(AVSValue args, void*, IScriptEnvironment*) { retu...
function AVSValue (line 1674) | AVSValue IsAudioInt(AVSValue args, void*, IScriptEnvironment*) { return...
function AVSValue (line 1675) | AVSValue IsChannelMaskKnown(AVSValue args, void*, IScriptEnvironment*) {...
function AVSValue (line 1676) | AVSValue GetChannelMask(AVSValue args, void*, IScriptEnvironment*) { ret...
function AVSValue (line 1678) | AVSValue IsRGB(AVSValue args, void*, IScriptEnvironment*) { return VI(a...
function AVSValue (line 1679) | AVSValue IsRGB24(AVSValue args, void*, IScriptEnvironment*) { return VI...
function AVSValue (line 1680) | AVSValue IsRGB32(AVSValue args, void*, IScriptEnvironment*) { return VI...
function AVSValue (line 1681) | AVSValue IsYUV(AVSValue args, void*, IScriptEnvironment*) { return VI(a...
function AVSValue (line 1682) | AVSValue IsYUY2(AVSValue args, void*, IScriptEnvironment*) { return VI(...
function AVSValue (line 1683) | AVSValue IsY8(AVSValue args, void*, IScriptEnvironment*) { return VI(ar...
function AVSValue (line 1684) | AVSValue IsYV12(AVSValue args, void*, IScriptEnvironment*) { return VI(...
function AVSValue (line 1685) | AVSValue IsYV16(AVSValue args, void*, IScriptEnvironment*) { return VI(...
function AVSValue (line 1686) | AVSValue IsYV24(AVSValue args, void*, IScriptEnvironment*) { return VI(...
function AVSValue (line 1687) | AVSValue IsYV411(AVSValue args, void*, IScriptEnvironment*) { return VI...
function AVSValue (line 1688) | AVSValue IsPlanar(AVSValue args, void*, IScriptEnvironment*) { return V...
function AVSValue (line 1689) | AVSValue IsInterleaved(AVSValue args, void*, IScriptEnvironment*) { ret...
function AVSValue (line 1690) | AVSValue IsFieldBased(AVSValue args, void*, IScriptEnvironment*) { retu...
function AVSValue (line 1691) | AVSValue IsFrameBased(AVSValue args, void*, IScriptEnvironment*) { retu...
function AVSValue (line 1692) | AVSValue GetParity(AVSValue args, void*, IScriptEnvironment*) { return ...
function AVSValue (line 1694) | AVSValue HasVideo(AVSValue args, void*, IScriptEnvironment*) { return V...
function AVSValue (line 1695) | AVSValue HasAudio(AVSValue args, void*, IScriptEnvironment*) { return V...
function AVSValue (line 1697) | AVSValue String(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 1745) | AVSValue Hex(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue_to_string (line 1755) | static std::string AVSValue_to_string(AVSValue v, IScriptEnvironment* en...
function AVSValue (line 1766) | AVSValue FormatString(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 1924) | AVSValue Func(AVSValue args, void*, IScriptEnvironment*) { return args[0...
function AVSValue (line 1926) | AVSValue IsBool(AVSValue args, void*, IScriptEnvironment*) { return arg...
function AVSValue (line 1927) | AVSValue IsInt(AVSValue args, void*, IScriptEnvironment*) { return args...
function AVSValue (line 1928) | AVSValue IsLongStrict(AVSValue args, void*, IScriptEnvironment*) { retur...
function AVSValue (line 1929) | AVSValue IsFloat(AVSValue args, void*, IScriptEnvironment*) { return ar...
function AVSValue (line 1930) | AVSValue IsFloatfStrict(AVSValue args, void*, IScriptEnvironment*) { ret...
function AVSValue (line 1931) | AVSValue IsString(AVSValue args, void*, IScriptEnvironment*) { return a...
function AVSValue (line 1932) | AVSValue IsClip(AVSValue args, void*, IScriptEnvironment*) { return arg...
function AVSValue (line 1933) | AVSValue IsFunction(AVSValue args, void*, IScriptEnvironment*) { return ...
function AVSValue (line 1934) | AVSValue Defined(AVSValue args, void*, IScriptEnvironment*) { return ar...
function AVSValue (line 1961) | AVSValue TypeName(AVSValue args, void*, IScriptEnvironment*) { return Ge...
function AVSValue (line 1963) | AVSValue Default(AVSValue args, void*, IScriptEnvironment*) { return ar...
function find_next_valid_float (line 1965) | static float find_next_valid_float(const double version) {
function AVSValue (line 1985) | AVSValue VersionNumber(AVSValue args, void*, IScriptEnvironment*) {
function AVSValue (line 2002) | AVSValue VersionString(AVSValue args, void*, IScriptEnvironment*) { ret...
function AVSValue (line 2003) | AVSValue IsVersionOrGreater(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2018) | AVSValue Frac(AVSValue args, void*, IScriptEnvironment*) {
function AVSValue (line 2026) | AVSValue Int(AVSValue args, void*, IScriptEnvironment*) {
function AVSValue (line 2036) | AVSValue IntI(AVSValue args, void*, IScriptEnvironment*) {
function AVSValue (line 2043) | AVSValue Long(AVSValue args, void*, IScriptEnvironment*) {
function AVSValue (line 2050) | AVSValue Float(AVSValue args, void*, IScriptEnvironment*) {
function AVSValue (line 2059) | AVSValue Double(AVSValue args, void*, IScriptEnvironment*) {
function AVSValue (line 2064) | AVSValue Floatf(AVSValue args, void*, IScriptEnvironment*) {
function AVSValue (line 2068) | AVSValue Value(AVSValue args, void*, IScriptEnvironment*) { char *stops...
function AVSValue (line 2070) | AVSValue HexValue(AVSValue args, void*, IScriptEnvironment*)
function AVSValue (line 2087) | AVSValue HexValue64(AVSValue args, void*, IScriptEnvironment*)
function AVSValue (line 2104) | AVSValue AvsMin(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2145) | AVSValue AvsMax(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2193) | AVSValue AddAutoloadDir (AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2203) | AVSValue ClearAutoloadDirs (AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2210) | AVSValue ListAutoloadDirs(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2227) | AVSValue AutoloadPlugins (AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2234) | AVSValue FunctionExists (AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2239) | AVSValue InternalFunctionExists (AVSValue args, void*, IScriptEnvironmen...
function AVSValue (line 2245) | AVSValue SetFilterMTMode (AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2252) | AVSValue SetLogParams(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2262) | AVSValue LogMsg(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2276) | AVSValue SetCacheMode(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2283) | AVSValue SetDeviceOpt(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2290) | AVSValue SetFilterProp(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2340) | AVSValue GetFilterProps(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2346) | AVSValue SetFilterPropPassthrough(AVSValue args, void*, IScriptEnvironme...
function AVSValue (line 2354) | AVSValue SetMemoryMax(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2368) | AVSValue SetMaxCPU(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2375) | AVSValue IsY(AVSValue args, void*, IScriptEnvironment*) { return VI(arg...
function AVSValue (line 2376) | AVSValue Is420(AVSValue args, void*, IScriptEnvironment*) { return VI(a...
function AVSValue (line 2377) | AVSValue Is422(AVSValue args, void*, IScriptEnvironment*) { return VI(a...
function AVSValue (line 2378) | AVSValue Is444(AVSValue args, void*, IScriptEnvironment*) { return VI(a...
function AVSValue (line 2379) | AVSValue IsRGB48(AVSValue args, void*, IScriptEnvironment*) { return VI...
function AVSValue (line 2380) | AVSValue IsRGB64(AVSValue args, void*, IScriptEnvironment*) { return VI...
function AVSValue (line 2381) | AVSValue ComponentSize(AVSValue args, void*, IScriptEnvironment*) { ret...
function AVSValue (line 2382) | AVSValue BitsPerComponent(AVSValue args, void*, IScriptEnvironment*) { ...
function AVSValue (line 2383) | AVSValue IsYUVA(AVSValue args, void*, IScriptEnvironment*) { return VI(...
function AVSValue (line 2384) | AVSValue IsPlanarRGB(AVSValue args, void*, IScriptEnvironment*) { retur...
function AVSValue (line 2385) | AVSValue IsPlanarRGBA(AVSValue args, void*, IScriptEnvironment*) { retu...
function AVSValue (line 2386) | AVSValue NumComponents(AVSValue args, void*, IScriptEnvironment*) { ret...
function AVSValue (line 2387) | AVSValue HasAlpha(AVSValue args, void*, IScriptEnvironment*) { return V...
function AVSValue (line 2388) | AVSValue IsPackedRGB(AVSValue args, void*, IScriptEnvironment*) { retur...
function AVSValue (line 2389) | AVSValue IsVideoFloat(AVSValue args, void*, IScriptEnvironment*) { retu...
function ProcessType (line 2392) | static int ProcessType() {
function AVSValue (line 2427) | AVSValue GetProcessInfo(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2440) | AVSValue StrToUtf8(AVSValue args, void*, IScriptEnvironment* env) {
function AVSValue (line 2450) | AVSValue StrFromUtf8(AVSValue args, void*, IScriptEnvironment* env) {
function AVSValue (line 2462) | AVSValue IsFloatUvZeroBased(AVSValue args, void*, IScriptEnvironment*)
function AVSValue (line 2471) | AVSValue BuildPixelType(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2625) | AVSValue VarExist(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2652) | AVSValue ArrayCreate(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2657) | AVSValue IsArray(AVSValue args, void*, IScriptEnvironment* env) { return...
function AVSValue (line 2659) | AVSValue ArrayGet(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2706) | AVSValue ArraySize(AVSValue args, void*, IScriptEnvironment* env)
function AVSValue (line 2714) | AVSValue ArrayIns(AVSValue args, void* user_data, IScriptEnvironment* env)
function customCompareBool (line 2804) | bool customCompareBool(const std::pair<const AVSValue*, int>& a, const s...
function customCompareInt (line 2809) | bool customCompareInt(const std::pair<const AVSValue *, int>& a, const s...
function customCompareFloat (line 2814) | bool customCompareFloat(const std::pair<const AVSValue*, int>& a, const ...
function customCompareString (line 2818) | bool customCompareString(const std::pair<const AVSValue*, int>& a, const...
function AVSValue (line 2822) | AVSValue ArraySort(AVSValue args, void* user_data, IScriptEnvironment* env)
FILE: avs_core/core/parser/script.h
function class (line 54) | class ScriptFunction
FILE: avs_core/core/parser/scriptparser.cpp
function PExpression (line 48) | PExpression ScriptParser::Parse(void)
function PExpression (line 82) | PExpression ScriptParser::ParseFunctionDefinition(void)
function PExpression (line 268) | PExpression ScriptParser::ParseBlock(bool braced, bool *empty)
function PExpression (line 351) | PExpression ScriptParser::ParseStatement(bool* stop)
function PExpression (line 421) | PExpression ScriptParser::ParseIf(void)
function PExpression (line 454) | PExpression ScriptParser::ParseWhile(void)
function PExpression (line 471) | PExpression ScriptParser::ParseFor(void)
function PExpression (line 503) | PExpression ScriptParser::ParseAssignment(void)
function PExpression (line 528) | PExpression ScriptParser::ParseAssignmentWithRet(void)
function PExpression (line 542) | PExpression ScriptParser::ParseConditional(void)
function PExpression (line 555) | PExpression ScriptParser::ParseOr(void)
function PExpression (line 566) | PExpression ScriptParser::ParseAnd(void)
function PExpression (line 578) | PExpression ScriptParser::ParseComparison(void)
function PExpression (line 604) | PExpression ScriptParser::ParseAddition(bool negationOnHold) //update ex...
function PExpression (line 621) | PExpression ScriptParser::ParseMultiplication(bool negationOnHold)
function PExpression (line 649) | PExpression ScriptParser::ParseUnary(void) {
function PExpression (line 667) | PExpression ScriptParser::ParseOOP(void)
function PExpression (line 691) | PExpression ScriptParser::ParseArray(PExpression context)
function PExpression (line 702) | PExpression ScriptParser::ParseFunction(PExpression context)
function PExpression (line 730) | PExpression ScriptParser::ParseCall(PExpression left, PExpression contex...
function PExpression (line 815) | PExpression ScriptParser::ParseAtom(void)
FILE: avs_core/core/parser/scriptparser.h
function class (line 49) | class ScriptParser
FILE: avs_core/core/parser/tokenizer.cpp
function ThrowTypeMismatch (line 447) | void ThrowTypeMismatch(char expected, char actual, IScriptEnvironment* env)
FILE: avs_core/core/parser/tokenizer.h
function class (line 46) | class Tokenizer
FILE: avs_core/core/strings.cpp
function tolower (line 51) | static inline char tolower(char c)
function streqi (line 57) | bool streqi(const char* s1, const char* s2)
function concat (line 79) | std::string concat(const std::string &s1, const std::string &s2)
function replace (line 85) | bool replace(std::string &haystack, const std::string &needle, const std...
function replace_beginning (line 102) | bool replace_beginning(std::string &haystack, const std::string &needle,...
function replace (line 116) | bool replace(std::string &haystack, char needle, char newChar)
function trim (line 125) | std::string trim(const std::string& s)
function AnsiToUtf8 (line 137) | std::unique_ptr<char[]> AnsiToUtf8(const char* input)
function WideCharToUtf8 (line 152) | std::unique_ptr<char[]> WideCharToUtf8(const wchar_t* w_string)
function WideCharToAnsi (line 160) | std::unique_ptr<char[]> WideCharToAnsi(const wchar_t* w_string)
function WideCharToAnsiACP (line 170) | std::unique_ptr<char[]> WideCharToAnsiACP(const wchar_t* w_string)
function WideCharToUtf8_maxn (line 180) | std::unique_ptr<char[]> WideCharToUtf8_maxn(const wchar_t* w_string, siz...
function WideCharToAnsi_maxn (line 189) | std::unique_ptr<char[]> WideCharToAnsi_maxn(const wchar_t* w_string, siz...
function AnsiToWideChar (line 197) | std::unique_ptr<wchar_t[]> AnsiToWideChar(const char* s_ansi)
function AnsiToWideCharACP (line 206) | std::unique_ptr<wchar_t[]> AnsiToWideCharACP(const char* s_ansi)
function Utf8ToWideChar (line 215) | std::unique_ptr<wchar_t[]> Utf8ToWideChar(const char* s_utf8)
function Utf8ToAnsi (line 224) | std::string Utf8ToAnsi(const char* s_utf8)
function double_to_string (line 235) | std::string double_to_string(double d)
function GetFullPathNameWrapUtf8 (line 248) | std::string GetFullPathNameWrapUtf8(const std::string& f)
function str_utf8_size (line 262) | size_t str_utf8_size(const std::string& s) {
function U16_to_utf8 (line 278) | std::string U16_to_utf8(uint16_t u16)
function charToUtf8 (line 307) | std::string charToUtf8(const char* text, bool utf8)
FILE: avs_core/core/vartable.h
type iequal_to_ascii (line 45) | struct iequal_to_ascii
type ihash_ascii (line 53) | struct ihash_ascii
type CompositeKeyDjb2Hash (line 70) | struct CompositeKeyDjb2Hash {
type CompositeKeyEqual (line 85) | struct CompositeKeyEqual {
function class (line 94) | class StringDump {
function class (line 207) | class VarFrame
function class (line 242) | class VarStringFrame : public VarFrame
function Clear (line 250) | void Clear()
function class (line 257) | class ConcurrentVarStringFrame : protected VarStringFrame
function Clear (line 281) | void Clear()
function class (line 288) | class VarTable
FILE: avs_core/filters/AviSource/AVIIndex.cpp
class AVIIndexChainNode (line 28) | class AVIIndexChainNode {
method AVIIndexChainNode (line 37) | AVIIndexChainNode() {
method add (line 42) | bool add(FOURCC ckid, __int64 pos, long size, bool is_keyframe) {
method put (line 53) | void put(AVIINDEXENTRY *&avieptr) {
method put (line 66) | void put(AVIIndexEntry2 *&avie2ptr) {
method put (line 73) | void put(AVIIndexEntry3 *&avie3ptr, __int64 offset) {
FILE: avs_core/filters/AviSource/AVIIndex.h
function class (line 29) | class AVIIndexEntry2 {
function class (line 39) | class AVIIndexEntry3 {
function class (line 45) | class AVIIndexChain {
function class (line 64) | class AVIIndex : public AVIIndexChain {
FILE: avs_core/filters/AviSource/AVIReadHandler.cpp
function AvisynthError (line 43) | AvisynthError MyError(const char* fmt, ...) {
function AvisynthError (line 51) | AvisynthError MyWin32Error(const char *format, DWORD err, ...) {
function isValidFOURCC (line 76) | static bool isValidFOURCC(FOURCC fcc) {
type _avisuperindex_entry (line 112) | struct _avisuperindex_entry {
type _avistdindex_entry (line 118) | struct _avistdindex_entry {
type _avifieldindex_entry (line 122) | struct _avifieldindex_entry {
type _avisuperindex_chunk (line 134) | struct _avisuperindex_chunk {
type _avisuperindex_entry (line 144) | struct _avisuperindex_entry
type _avistdindex_chunk (line 147) | struct _avistdindex_chunk {
type _avistdindex_entry (line 158) | struct _avistdindex_entry
type _avifieldindex_chunk (line 161) | struct _avifieldindex_chunk {
type _avifieldindex_entry (line 171) | struct _avifieldindex_entry
class AVIStreamNode (line 185) | class AVIStreamNode
class AVIReadCache (line 229) | class AVIReadCache
class AVIReadStream (line 236) | class AVIReadStream
class AVIReadHandler (line 186) | class AVIReadHandler
class AVIReadStream (line 352) | class AVIReadStream
class AVIReadCache (line 188) | class AVIReadCache {
method getMaxRead (line 202) | long getMaxRead() {
class AVIStreamNode (line 216) | class AVIStreamNode : public ListNode2<AVIStreamNode> {
class AVIReadCache (line 229) | class AVIReadCache
class AVIReadStream (line 236) | class AVIReadStream
class AVIFileDesc (line 320) | class AVIFileDesc : public ListNode2<AVIFileDesc> {
class AVIStreamNode (line 327) | class AVIStreamNode
class AVIReadCache (line 229) | class AVIReadCache
class AVIReadStream (line 236) | class AVIReadStream
class AVIReadHandler (line 329) | class AVIReadHandler final: public IAVIReadHandler, private File64 {
class AVIReadStream (line 352) | class AVIReadStream
function IAVIReadHandler (line 396) | IAVIReadHandler *CreateAVIReadHandler(PAVIFILE paf) {
function IAVIReadHandler (line 400) | IAVIReadHandler *CreateAVIReadHandler(const wchar_t *pszFile_w) {
class AVIReadTunnelStream (line 582) | class AVIReadTunnelStream : public IAVIReadStream {
method getVBRInfo (line 601) | bool getVBRInfo(double& bitrate_mean, double& bitrate_stddev, double& ...
function HRESULT (line 624) | HRESULT AVIReadTunnelStream::BeginStreaming(long lStart, long lEnd, long...
function HRESULT (line 628) | HRESULT AVIReadTunnelStream::EndStreaming() {
function HRESULT (line 632) | HRESULT AVIReadTunnelStream::Info(AVISTREAMINFO *pasi, long lSize) {
function HRESULT (line 640) | HRESULT AVIReadTunnelStream::Read(long lStart, long lSamples, void *lpBu...
function HRESULT (line 675) | HRESULT AVIReadTunnelStream::FormatSize(long lFrame, long *plSize) {
function HRESULT (line 679) | HRESULT AVIReadTunnelStream::ReadFormat(long lFrame, void *pFormat, long...
class AVIReadStream (line 693) | class AVIReadStream : public IAVIReadStream, public ListNode2<AVIReadStr...
function HRESULT (line 783) | HRESULT AVIReadStream::BeginStreaming(long lStart, long lEnd, long lRate) {
function HRESULT (line 816) | HRESULT AVIReadStream::EndStreaming() {
function HRESULT (line 836) | HRESULT AVIReadStream::Info(AVISTREAMINFO *pasi, long lSize) {
function HRESULT (line 880) | HRESULT AVIReadStream::Read(long lStart, long lSamples, void *lpBuffer, ...
function HRESULT (line 1214) | HRESULT AVIReadStream::FormatSize(long lFrame, long *plSize) {
function HRESULT (line 1219) | HRESULT AVIReadStream::ReadFormat(long lFrame, void *pFormat, long *plSi...
type _avisuperindex_entry (line 2041) | struct _avisuperindex_entry
function IAVIReadStream (line 2177) | IAVIReadStream *AVIReadHandler::GetStream(DWORD fccType, LONG lParam) {
function __int64 (line 2458) | __int64 AVIReadHandler::getStreamPtr() {
FILE: avs_core/filters/AviSource/AVIReadHandler.h
function class (line 27) | class IAVIReadStream {
function class (line 49) | class IAVIReadHandler {
FILE: avs_core/filters/AviSource/AudioSource.cpp
function BOOL (line 39) | BOOL AudioSourceWAV::init() {
function BOOL (line 117) | BOOL AudioSourceAVI::init() {
function BOOL (line 173) | BOOL AudioSourceAVI::_isKey(LONG lSample) {
FILE: avs_core/filters/AviSource/AudioSource.h
function class (line 26) | class AudioSource : public DubSource {
function class (line 33) | class AudioSourceWAV : public AudioSource {
function class (line 49) | class AudioSourceAVI : public AudioSource {
FILE: avs_core/filters/AviSource/DubSource.cpp
function BOOL (line 28) | BOOL DubSource::init() {
function BOOL (line 58) | BOOL DubSource::isKey(LONG lSample) {
function BOOL (line 64) | BOOL DubSource::_isKey(LONG lSample) {
function LONG (line 68) | LONG DubSource::nearestKey(LONG lSample) {
function LONG (line 72) | LONG DubSource::prevKey(LONG lSample) {
function LONG (line 76) | LONG DubSource::nextKey(LONG lSample) {
FILE: avs_core/filters/AviSource/DubSource.h
function class (line 26) | class DubSource {
FILE: avs_core/filters/AviSource/Error.h
function AvisynthError (line 10) | static inline AvisynthError MyMemoryError() {
FILE: avs_core/filters/AviSource/FastReadStream.cpp
class FastReadStreamHeader (line 32) | class FastReadStreamHeader {
FILE: avs_core/filters/AviSource/FastReadStream.h
function class (line 28) | class FastReadStream {
FILE: avs_core/filters/AviSource/File64.cpp
function __int64 (line 150) | __int64 File64::_posFile() {
function __int64 (line 154) | __int64 File64::_sizeFile() {
FILE: avs_core/filters/AviSource/File64.h
function class (line 28) | class File64 {
FILE: avs_core/filters/AviSource/Fixes.h
type RECT16 (line 30) | typedef struct {
type AVIStreamHeader_fixed (line 37) | typedef struct {
FILE: avs_core/filters/AviSource/VD_Audio.cpp
function convert_audio_nochange8 (line 42) | static void convert_audio_nochange8(void *dest, void *src, long count) {
function convert_audio_nochange16 (line 46) | static void convert_audio_nochange16(void *dest, void *src, long count) {
function convert_audio_nochange32 (line 50) | static void convert_audio_nochange32(void *dest, void *src, long count) {
function convert_audio_mono8_to_mono16 (line 56) | static void convert_audio_mono8_to_mono16(void *dest, void *src, long co...
function convert_audio_mono8_to_stereo8 (line 65) | static void convert_audio_mono8_to_stereo8(void *dest, void *src, long c...
function convert_audio_mono8_to_stereo16 (line 76) | static void convert_audio_mono8_to_stereo16(void *dest, void *src, long ...
function convert_audio_mono16_to_mono8 (line 86) | static void convert_audio_mono16_to_mono8(void *dest, void *src, long co...
function convert_audio_mono16_to_stereo8 (line 95) | static void convert_audio_mono16_to_stereo8(void *dest, void *src, long ...
function convert_audio_mono16_to_stereo16 (line 106) | static void convert_audio_mono16_to_stereo16(void *dest, void *src, long...
function convert_audio_stereo8_to_mono8 (line 116) | static void convert_audio_stereo8_to_mono8(void *dest, void *src, long c...
function convert_audio_stereo8_to_mono16 (line 127) | static void convert_audio_stereo8_to_mono16(void *dest, void *src, long ...
function convert_audio_stereo8_to_stereo16 (line 138) | static void convert_audio_stereo8_to_stereo16(void *dest, void *src, lon...
function convert_audio_stereo16_to_mono8 (line 148) | static void convert_audio_stereo16_to_mono8(void *dest, void *src, long ...
function convert_audio_stereo16_to_mono16 (line 158) | static void convert_audio_stereo16_to_mono16(void *dest, void *src, long...
function convert_audio_stereo16_to_stereo8 (line 168) | static void convert_audio_stereo16_to_stereo8(void *dest, void *src, lon...
function convert_audio_dual8_to_mono8 (line 179) | static void convert_audio_dual8_to_mono8(void *dest, void *src, long cou...
function convert_audio_dual8_to_mono16 (line 189) | static void convert_audio_dual8_to_mono16(void *dest, void *src, long co...
function convert_audio_dual16_to_mono8 (line 199) | static void convert_audio_dual16_to_mono8(void *dest, void *src, long co...
function convert_audio_dual16_to_mono16 (line 209) | static void convert_audio_dual16_to_mono16(void *dest, void *src, long c...
function AudioFormatConverter (line 251) | AudioFormatConverter AudioPickConverter(WAVEFORMATEX *src, BOOL to_16bit...
function AudioFormatConverter (line 260) | AudioFormatConverter AudioPickConverterSingleChannel(WAVEFORMATEX *src, ...
function WAVEFORMATEX (line 281) | WAVEFORMATEX *AudioStream::AllocFormat(long len) {
function WAVEFORMATEX (line 292) | WAVEFORMATEX *AudioStream::GetFormat() {
function BOOL (line 347) | BOOL AudioStream::isEnd() {
function BOOL (line 357) | BOOL AudioStream::_isEnd() {
function BOOL (line 802) | BOOL AudioStreamSource::_isEnd() {
function BOOL (line 892) | BOOL AudioStreamConverter::_isEnd() {
function audio_pointsample_8 (line 910) | static long audio_pointsample_8(void *dst, void *src, long accum, long s...
function audio_pointsample_16 (line 922) | static long audio_pointsample_16(void *dst, void *src, long accum, long ...
function audio_pointsample_32 (line 934) | static long audio_pointsample_32(void *dst, void *src, long accum, long ...
function audio_downsample_mono8 (line 946) | static long audio_downsample_mono8(void *dst, void *src, long *filter_ba...
function audio_downsample_mono16 (line 976) | static long audio_downsample_mono16(void *dst, void *src, long *filter_b...
function audio_downsample_stereo8 (line 1006) | static long audio_downsample_stereo8(void *dst, void *src, long *filter_...
function audio_downsample_stereo16 (line 1046) | static long audio_downsample_stereo16(void *dst, void *src, long *filter...
function audio_upsample_mono8 (line 1086) | static long audio_upsample_mono8(void *dst, void *src, long accum, long ...
function audio_upsample_mono16 (line 1101) | static long audio_upsample_mono16(void *dst, void *src, long accum, long...
function audio_upsample_stereo8 (line 1116) | static long audio_upsample_stereo8(void *dst, void *src, long accum, lon...
function audio_upsample_stereo16 (line 1132) | static long audio_upsample_stereo16(void *dst, void *src, long accum, lo...
function permute_index (line 1148) | static int permute_index(int a, int b) {
function make_downsample_filter (line 1152) | static void make_downsample_filter(long *filter_bank, int filter_width, ...
function BOOL (line 1475) | BOOL AudioStreamResampler::_isEnd() {
type FrustratedACMOpenData (line 1490) | struct FrustratedACMOpenData {
function BOOL (line 1499) | BOOL CALLBACK ACMStreamOpenCallback(HACMDRIVERID hadid, DWORD_PTR dwInst...
type FrustratedACMOpenData (line 1573) | struct FrustratedACMOpenData
function BOOL (line 1773) | BOOL AudioCompressor::isEnd() {
function amplify8 (line 2011) | static void amplify8(unsigned char *dst, int count, long lFactor) {
function amplify16 (line 2024) | static void amplify16(signed short *dst, int count, long lFactor) {
function BOOL (line 2068) | BOOL AudioStreamAmplifier::_isEnd() {
FILE: avs_core/filters/AviSource/VD_Audio.h
function class (line 34) | class AudioStream {
function class (line 64) | class AudioStreamSource : public AudioStream {
function class (line 91) | class AudioStreamConverter : public AudioStream {
function class (line 110) | class AudioStreamResampler : public AudioStream {
function class (line 137) | class AudioCompressor : public AudioStream {
function class (line 166) | class AudioL3Corrector {
function class (line 195) | class AudioStreamAmplifier : public AudioStream {
FILE: avs_core/filters/AviSource/avi_source.cpp
function free_buffer (line 61) | static void __cdecl free_buffer(void* buff, IScriptEnvironment* env)
function PVideoFrame (line 188) | static PVideoFrame AdjustFrameAlignment(TemporalBuffer* frame, const Vid...
function LRESULT (line 308) | static __inline LRESULT
function LRESULT (line 328) | static __inline LRESULT
function LRESULT (line 349) | LRESULT AVISource::DecompressBegin(LPBITMAPINFOHEADER lpbiSrc, LPBITMAPI...
function LRESULT (line 363) | LRESULT AVISource::DecompressFrame(int n, bool preroll, IScriptEnvironme...
function fourCCtoString (line 446) | static std::string fourCCtoString(DWORD fourCC) {
function setInternalFormat_b64a (line 619) | static bool setInternalFormat_b64a(VideoInfo& vi, HIC& hic, BITMAPINFOHE...
function setInternalFormat_BRA64 (line 628) | static bool setInternalFormat_BRA64(VideoInfo& vi, HIC& hic, BITMAPINFOH...
function setInternalFormat_BGR48 (line 637) | static bool setInternalFormat_BGR48(VideoInfo& vi, HIC& hic, BITMAPINFOH...
function setInternalFormat_b48r (line 646) | static bool setInternalFormat_b48r(VideoInfo& vi, HIC& hic, BITMAPINFOHE...
function setInternalFormat_v210 (line 655) | static bool setInternalFormat_v210(VideoInfo& vi, HIC& hic, BITMAPINFOHE...
function setInternalFormat_P210 (line 664) | static bool setInternalFormat_P210(VideoInfo& vi, HIC& hic, BITMAPINFOHE...
function setInternalFormat_P010 (line 673) | static bool setInternalFormat_P010(VideoInfo& vi, HIC& hic, BITMAPINFOHE...
function setInternalFormat_P016 (line 682) | static bool setInternalFormat_P016(VideoInfo& vi, HIC& hic, BITMAPINFOHE...
function setInternalFormat_Y416 (line 691) | static bool setInternalFormat_Y416(VideoInfo& vi, HIC& hic, BITMAPINFOHE...
function setInternalFormat_Y410 (line 700) | static bool setInternalFormat_Y410(VideoInfo& vi, HIC& hic, BITMAPINFOHE...
function setInternalFormat_P216 (line 709) | static bool setInternalFormat_P216(VideoInfo& vi, HIC& hic, BITMAPINFOHE...
function setInternalFormat_v410 (line 718) | static bool setInternalFormat_v410(VideoInfo& vi, HIC& hic, BITMAPINFOHE...
function setInternalFormat_r210 (line 727) | static bool setInternalFormat_r210(VideoInfo& vi, HIC& hic, BITMAPINFOHE...
function setInternalFormat_R10k (line 736) | static bool setInternalFormat_R10k(VideoInfo& vi, HIC& hic, BITMAPINFOHE...
function setInternalFormat_v308 (line 745) | static bool setInternalFormat_v308(VideoInfo& vi, HIC& hic, BITMAPINFOHE...
function setInternalFormat_v408 (line 754) | static bool setInternalFormat_v408(VideoInfo& vi, HIC& hic, BITMAPINFOHE...
function VideoInfo (line 1629) | const VideoInfo& AVISource::GetVideoInfo() { return vi; }
function PVideoFrame (line 1631) | PVideoFrame AVISource::GetFrame(int n, IScriptEnvironment* env) {
FILE: avs_core/filters/AviSource/avi_source.h
type _AVI_SpecialFormats (line 44) | typedef enum class _AVI_SpecialFormats
function class (line 52) | class TemporalBuffer {
function class (line 84) | class AVISource : public IClip {
FILE: avs_core/filters/AviSource/clip_info.h
function IUnknown (line 43) | struct IAvisynthClipInfo : IUnknown {
FILE: avs_core/filters/AviSource/list.cpp
function ListNode (line 37) | ListNode *List::RemoveHead() {
function ListNode (line 48) | ListNode *List::RemoveTail() {
FILE: avs_core/filters/AviSource/list.h
function class (line 24) | class ListNode {
function class (line 59) | class List {
FILE: avs_core/filters/aarch64/turn_neon.cpp
function AVS_FORCEINLINE (line 59) | static AVS_FORCEINLINE void transpose_8x8x8_neon(const BYTE* AVS_RESTRIC...
function AVS_FORCEINLINE (line 115) | static AVS_FORCEINLINE void transpose_8x8x16_neon(const BYTE* AVS_RESTRI...
function turn_right_plane_8_neon (line 184) | void turn_right_plane_8_neon(const BYTE* srcp, BYTE* dstp, int src_rowsi...
function turn_left_plane_8_neon (line 213) | void turn_left_plane_8_neon(const BYTE* srcp, BYTE* dstp, int src_rowsiz...
function AVS_FORCEINLINE (line 220) | static AVS_FORCEINLINE void transpose_16x4x8_neon(const BYTE* srcp, BYTE...
function turn_right_plane_16_neon (line 281) | void turn_right_plane_16_neon(const BYTE* srcp, BYTE* dstp, int src_rows...
function turn_left_plane_16_neon (line 310) | void turn_left_plane_16_neon(const BYTE* srcp, BYTE* dstp, int src_rowsi...
function AVS_FORCEINLINE (line 318) | static AVS_FORCEINLINE void transpose_32x4x4_neon(const BYTE* srcp, BYTE...
function turn_right_plane_32_neon (line 346) | void turn_right_plane_32_neon(const BYTE* srcp, BYTE* dstp, int src_rows...
function turn_left_plane_32_neon (line 375) | void turn_left_plane_32_neon(const BYTE* srcp, BYTE* dstp, int src_rowsi...
function turn_right_plane_64_neon (line 383) | static inline void turn_right_plane_64_neon(const BYTE* srcp, BYTE* dstp...
function turn_left_rgb64_neon (line 423) | void turn_left_rgb64_neon(const BYTE* srcp, BYTE* dstp, int src_rowsize,...
function turn_right_rgb64_neon (line 429) | void turn_right_rgb64_neon(const BYTE* srcp, BYTE* dstp, int src_rowsize...
function AVS_FORCEINLINE (line 437) | AVS_FORCEINLINE static uint8x16_t swap64_u8(uint8x16_t v) {
function turn_180_plane_neon (line 446) | void turn_180_plane_neon(const BYTE* srcp, BYTE* dstp,
function turn_left_rgb32_neon (line 556) | void turn_left_rgb32_neon(const BYTE* srcp, BYTE* dstp, int src_rowsize,...
function turn_right_rgb32_neon (line 562) | void turn_right_rgb32_neon(const BYTE* srcp, BYTE* dstp, int src_rowsize...
FILE: avs_core/filters/color.cpp
function coloryuv_showyuv (line 60) | static void coloryuv_showyuv(BYTE* pY, BYTE* pU, BYTE* pV, int y_pitch, ...
function coloryuv_create_lut (line 234) | static void coloryuv_create_lut(BYTE* lut8, const ColorYUVPlaneConfig* c...
function coloryuv_create_lut_expr (line 328) | static std::string coloryuv_create_lut_expr(const ColorYUVPlaneConfig* c...
function coloryuv_analyse_core (line 440) | static void coloryuv_analyse_core(const int* freq, const int pixel_num, ...
function coloryuv_analyse_planar (line 507) | static void coloryuv_analyse_planar(const BYTE* pSrc, int src_pitch, int...
function coloryuv_analyse_yuy2 (line 618) | static void coloryuv_analyse_yuy2(const BYTE* pSrc, int src_pitch, int w...
function coloryuv_autogain (line 643) | static void coloryuv_autogain(const ColorYUVPlaneData* dY, const ColorYU...
function coloryuv_autowhite (line 663) | static void coloryuv_autowhite(const ColorYUVPlaneData* dY, const ColorY...
function coloryuv_apply_lut_planar (line 685) | static void coloryuv_apply_lut_planar(BYTE* pDst, const BYTE* pSrc, int ...
function coloryuv_apply_lut_yuy2 (line 731) | static void coloryuv_apply_lut_yuy2(BYTE* pDst, const BYTE* pSrc, int ds...
function coloryuv_read_conditional (line 760) | static void coloryuv_read_conditional(IScriptEnvironment* env, ColorYUVP...
function PVideoFrame (line 977) | PVideoFrame __stdcall ColorYUV::GetFrame(int n, IScriptEnvironment* env)
function AVSValue (line 1217) | AVSValue __cdecl ColorYUV::Create(AVSValue args, void* , IScriptEnvironm...
FILE: avs_core/filters/color.h
type ColorYUVPlaneData (line 49) | struct ColorYUVPlaneData
type ColorYUVPlaneConfig (line 56) | struct ColorYUVPlaneConfig
function class (line 65) | class ColorYUV : public GenericVideoFilter
FILE: avs_core/filters/combine.cpp
function PVideoFrame (line 112) | PVideoFrame __stdcall StackVertical::GetFrame(int n, IScriptEnvironment*...
function AVSValue (line 159) | AVSValue __cdecl StackVertical::Create(AVSValue args, void*, IScriptEnvi...
function PVideoFrame (line 261) | PVideoFrame __stdcall MultiOverlay::GetFrame(int n, IScriptEnvironment* ...
function AVSValue (line 379) | AVSValue __cdecl MultiOverlay::Create(AVSValue args, void*, IScriptEnvir...
function PVideoFrame (line 444) | PVideoFrame __stdcall StackHorizontal::GetFrame(int n, IScriptEnvironmen...
function AVSValue (line 490) | AVSValue __cdecl StackHorizontal::Create(AVSValue args, void*, IScriptEn...
function PVideoFrame (line 540) | PVideoFrame __stdcall ShowFiveVersions::GetFrame(int n, IScriptEnvironme...
function AVSValue (line 626) | AVSValue __cdecl ShowFiveVersions::Create(AVSValue args, void*, IScriptE...
type my_int128_t (line 796) | struct my_int128_t {
function my_int128_t (line 802) | static inline my_int128_t mul_64_64_to_128(int64_t a, int64_t b) {
function my_int128_t (line 842) | static inline my_int128_t add_128(my_int128_t a, my_int128_t b) {
function shift_right_128 (line 853) | static inline int64_t shift_right_128(my_int128_t a, int shift) {
function Muldiv_64_32_integer_arithm (line 871) | static int64_t Muldiv_64_32_integer_arithm(int64_t a, int64_t b, uint64_...
function PVideoFrame (line 898) | PVideoFrame __stdcall Animate::GetFrame(int n, IScriptEnvironment* env)
function AVSValue (line 1038) | AVSValue __cdecl Animate::Create(AVSValue args, void* user_data, IScript...
function AVSValue (line 1065) | AVSValue __cdecl Animate::Create_Range(AVSValue args, void*, IScriptEnvi...
FILE: avs_core/filters/combine.h
function class (line 43) | class MultiOverlay : public IClip
function class (line 79) | class StackVertical : public IClip
function class (line 115) | class StackHorizontal : public IClip
function class (line 151) | class ShowFiveVersions : public IClip
function class (line 181) | class Animate : public IClip
FILE: avs_core/filters/conditional/conditional.cpp
function PVideoFrame (line 160) | PVideoFrame __stdcall ConditionalSelect::GetFrame(int n, IScriptEnvironm...
function AVSValue (line 256) | AVSValue __cdecl ConditionalSelect::Create(AVSValue args, void* , IScrip...
function PVideoFrame (line 361) | PVideoFrame __stdcall ConditionalFilter::GetFrame(int n, IScriptEnvironm...
function AVSValue (line 551) | AVSValue __cdecl ConditionalFilter::Create(AVSValue args, void* user_dat...
function PVideoFrame (line 590) | PVideoFrame __stdcall ScriptClip::GetFrame(int n, IScriptEnvironment* env_)
function AVSValue (line 723) | AVSValue __cdecl ScriptClip::Create(AVSValue args, void* , IScriptEnviro...
function AVSValue (line 731) | AVSValue __cdecl ScriptClip::Create_eval(AVSValue args, void* , IScriptE...
FILE: avs_core/filters/conditional/conditional.h
function class (line 40) | class ConditionalSelect : public GenericVideoFilter
function class (line 59) | class ConditionalFilter : public GenericVideoFilter
function class (line 89) | class ScriptClip : public GenericVideoFilter
FILE: avs_core/filters/conditional/conditional_functions.cpp
function AVSValue (line 145) | AVSValue AveragePlane::Create(AVSValue args, void* user_data, IScriptEnv...
function get_sum_of_pixels_c (line 152) | static double get_sum_of_pixels_c(const BYTE* srcp8, size_t height, size...
function AVSValue (line 166) | AVSValue AveragePlane::AvgPlane(AVSValue clip, void* , int plane, int of...
function AVSValue (line 264) | AVSValue ComparePlane::Create(AVSValue args, void* user_data, IScriptEnv...
function AVSValue (line 269) | AVSValue ComparePlane::Create_prev(AVSValue args, void* user_data, IScri...
function AVSValue (line 274) | AVSValue ComparePlane::Create_next(AVSValue args, void* user_data, IScri...
function get_sad_c (line 281) | static double get_sad_c(const BYTE* c_plane8, const BYTE* t_plane8, size...
function get_sad_rgb_c (line 301) | static double get_sad_rgb_c(const BYTE* c_plane8, const BYTE* t_plane8, ...
function AVSValue (line 320) | AVSValue ComparePlane::CmpPlane(AVSValue clip, AVSValue clip2, void* , i...
function AVSValue (line 446) | AVSValue ComparePlane::CmpPlaneSame(AVSValue clip, void* , int offset, i...
function AVSValue (line 551) | AVSValue MinMaxPlane::Create_minmax_stats(AVSValue args, void* user_data...
function AVSValue (line 572) | AVSValue MinMaxPlane::Create_max(AVSValue args, void* user_data, IScript...
function AVSValue (line 577) | AVSValue MinMaxPlane::Create_min(AVSValue args, void* user_data, IScript...
function AVSValue (line 582) | AVSValue MinMaxPlane::Create_median(AVSValue args, void* user_data, IScr...
function AVSValue (line 588) | AVSValue MinMaxPlane::Create_minmax(AVSValue args, void* user_data, IScr...
function get_minmax_float_c (line 594) | void get_minmax_float_c(const BYTE* srcp, int pitch, int w, int h, float...
function get_minmax_int_c (line 613) | void get_minmax_int_c(const BYTE* srcp, int pitch, int w, int h, int& mi...
function AVSValue (line 634) | AVSValue MinMaxPlane::MinMax(AVSValue clip, void* , double threshold, in...
function AVSValue (line 923) | AVSValue GetProperty::Create(AVSValue args, void* user_data, IScriptEnvi...
function AVSValue (line 1017) | AVSValue GetPropertyAsArray::Create(AVSValue args, void* , IScriptEnviro...
function AVSValue (line 1113) | AVSValue GetAllProperties::Create(AVSValue args, void*, IScriptEnvironme...
function AVSValue (line 1207) | AVSValue GetPropertyDataSize::Create(AVSValue args, void* , IScriptEnvir...
function AVSValue (line 1255) | AVSValue GetPropertyNumElements::Create(AVSValue args, void*, IScriptEnv...
function AVSValue (line 1291) | AVSValue GetPropertyType::Create(AVSValue args, void*, IScriptEnvironmen...
function AVSValue (line 1339) | AVSValue GetPropertyNumKeys::Create(AVSValue args, void*, IScriptEnviron...
function AVSValue (line 1373) | AVSValue GetPropertyKeyByIndex::Create(AVSValue args, void*, IScriptEnvi...
FILE: avs_core/filters/conditional/conditional_functions.h
function class (line 39) | class AveragePlane {
function class (line 46) | class ComparePlane {
function class (line 58) | class MinMaxPlane {
function class (line 75) | class GetProperty {
function class (line 80) | class GetPropertyAsArray {
function class (line 85) | class GetAllProperties {
function class (line 90) | class GetPropertyDataSize {
function class (line 95) | class GetPropertyType {
function class (line 100) | class GetPropertyNumElements {
function class (line 105) | class GetPropertyNumKeys {
function class (line 110) | class GetPropertyKeyByIndex {
FILE: avs_core/filters/conditional/conditional_reader.cpp
function iscomment (line 147) | static int
function AVSValue (line 349) | AVSValue ConditionalReader::ConvertType(const char* content, int line, I...
function AVSValue (line 486) | AVSValue ConditionalReader::GetFrameValue(int framenumber) {
function PVideoFrame (line 548) | PVideoFrame __stdcall ConditionalReader::GetFrame(int n, IScriptEnvironm...
function AVSValue (line 593) | AVSValue __cdecl ConditionalReader::Create(AVSValue args, void*, IScript...
function PVideoFrame (line 676) | PVideoFrame __stdcall Write::GetFrame(int n, IScriptEnvironment* env_) {
function AVSValue (line 800) | AVSValue __cdecl Write::Create(AVSValue args, void*, IScriptEnvironment*...
function AVSValue (line 811) | AVSValue __cdecl Write::Create_If(AVSValue args, void*, IScriptEnvironme...
function AVSValue (line 822) | AVSValue __cdecl Write::Create_Start(AVSValue args, void*, IScriptEnviro...
function AVSValue (line 834) | AVSValue __cdecl Write::Create_End(AVSValue args, void*, IScriptEnvironm...
function PVideoFrame (line 862) | PVideoFrame __stdcall UseVar::GetFrame(int n, IScriptEnvironment* env_)
function AVSValue (line 888) | AVSValue __cdecl UseVar::Create(AVSValue args, void* user_data, IScriptE...
function PVideoFrame (line 911) | PVideoFrame __stdcall SetProperty::GetFrame(int n, IScriptEnvironment* env)
function AVSValue (line 1143) | AVSValue __cdecl SetProperty::Create(AVSValue args, void* user_data, ISc...
function PropNamesToArray (line 1163) | static bool PropNamesToArray(const char* filtername, AVSValue& _propName...
function PVideoFrame (line 1219) | PVideoFrame __stdcall DeleteProperty::GetFrame(int n, IScriptEnvironment...
function AVSValue (line 1280) | AVSValue __cdecl DeleteProperty::Create(AVSValue args, void*, IScriptEnv...
function PVideoFrame (line 1294) | PVideoFrame __stdcall ClearProperties::GetFrame(int n, IScriptEnvironmen...
function AVSValue (line 1325) | AVSValue __cdecl ClearProperties::Create(AVSValue args, void*, IScriptEn...
function PVideoFrame (line 1337) | PVideoFrame __stdcall PropPassthrough::GetFrame(int n, IScriptEnvironmen...
function AVSValue (line 1373) | AVSValue __cdecl CopyProperties::Create(AVSValue args, void*, IScriptEnv...
function CopyOneFrameProp (line 1391) | static void CopyOneFrameProp(const char* key, AVSMap* mapv, const AVSMap...
function PVideoFrame (line 1434) | PVideoFrame __stdcall CopyProperties::GetFrame(int n, IScriptEnvironment...
function PVideoFrame (line 1573) | PVideoFrame __stdcall ShowProperties::GetFrame(int n, IScriptEnvironment...
function AVSValue (line 1749) | AVSValue __cdecl ShowProperties::Create(AVSValue args, void*, IScriptEnv...
FILE: avs_core/filters/conditional/conditional_reader.h
type StringCache (line 40) | struct StringCache {
function class (line 45) | class ConditionalReader : public GenericVideoFilter
function class (line 83) | class Write : public GenericVideoFilter
function class (line 119) | class UseVar : public GenericVideoFilter
function class (line 138) | class SetProperty : public GenericVideoFilter
function class (line 154) | class DeleteProperty : public GenericVideoFilter
function class (line 168) | class ClearProperties : public GenericVideoFilter
function class (line 184) | class PropPassthrough : public GenericVideoFilter
function class (line 195) | class CopyProperties : public GenericVideoFilter
function class (line 212) | class ShowProperties : public GenericVideoFilter
FILE: avs_core/filters/conditional/intel/conditional_functions_sse.cpp
function get_sum_of_pixels_sse2 (line 49) | double get_sum_of_pixels_sse2(const uint8_t* srcp, size_t height, size_t...
function get_sum_of_pixels_isse (line 75) | double get_sum_of_pixels_isse(const uint8_t* srcp, size_t height, size_t...
function get_sad_isse (line 99) | size_t get_sad_isse(const uint8_t* src_ptr, const uint8_t* other_ptr, si...
function get_sad_rgb_isse (line 124) | size_t get_sad_rgb_isse(const uint8_t* src_ptr, const uint8_t* other_ptr...
FILE: avs_core/filters/convolution.cpp
function AVS_FORCEINLINE (line 80) | AVS_FORCEINLINE int static_clip(int value) {
function do_conv_integer (line 96) | static void do_conv_integer(BYTE* dstp8, int dst_pitch, const BYTE *srcp...
function do_conv_float (line 232) | static void do_conv_float(BYTE* dstp8, int dst_pitch, const BYTE *srcp8,...
function AVSValue (line 464) | AVSValue __cdecl GeneralConvolution::Create(AVSValue args, void*, IScrip...
function PVideoFrame (line 571) | PVideoFrame __stdcall GeneralConvolution::GetFrame(int n, IScriptEnviron...
FILE: avs_core/filters/convolution.h
function class (line 52) | class GeneralConvolution : public GenericVideoFilter
FILE: avs_core/filters/debug.cpp
class PlanarLegacyAlignment (line 54) | class PlanarLegacyAlignment : public GenericVideoFilter
method PlanarLegacyAlignment (line 60) | PlanarLegacyAlignment( PClip _child, const bool _mode, IScriptEnvironm...
method PVideoFrame (line 68) | PVideoFrame __stdcall GetFrame(int n, IScriptEnvironment* env)
method AVSValue (line 82) | static AVSValue __cdecl Create(AVSValue args, void*, IScriptEnvironmen...
class Echo (line 96) | class Echo : public GenericVideoFilter
method Echo (line 103) | Echo( PClip _child, const AVSValue _clips, IScriptEnvironment* env )
method PVideoFrame (line 117) | PVideoFrame __stdcall GetFrame(int n, IScriptEnvironment* env) {
method AVSValue (line 127) | static AVSValue __cdecl Create(AVSValue args, void*, IScriptEnvironmen...
class Preroll (line 139) | class Preroll : public GenericVideoFilter
method Preroll (line 149) | Preroll( PClip _child, const int _videopr, const double _audiopr, IScr...
method PVideoFrame (line 162) | PVideoFrame __stdcall GetFrame(int n, IScriptEnvironment* env) {
method GetAudio (line 180) | void __stdcall GetAudio(void* buf, int64_t start, int64_t count, IScri...
method AVSValue (line 201) | static AVSValue __cdecl Create(AVSValue args, void*, IScriptEnvironmen...
function PVideoFrame (line 239) | PVideoFrame __stdcall Null::GetFrame(int n, IScriptEnvironment* env)
function AVSValue (line 292) | AVSValue __cdecl Null::Create(AVSValue args, void*, IScriptEnvironment* ...
FILE: avs_core/filters/debug.h
function class (line 45) | class Null : public GenericVideoFilter
function class (line 62) | class MemDebug
FILE: avs_core/filters/edit.cpp
function AVSValue (line 187) | AVSValue __cdecl Trim::CreateA(AVSValue args, void* user_arg, IScriptEnv...
function PVideoFrame (line 275) | PVideoFrame Trim::GetFrame(int n, IScriptEnvironment* env)
function AVSValue (line 293) | AVSValue __cdecl Trim::Create(AVSValue args, void* user_arg, IScriptEnvi...
function PVideoFrame (line 320) | PVideoFrame FreezeFrame::GetFrame(int n, IScriptEnvironment* env)
function AVSValue (line 332) | AVSValue __cdecl FreezeFrame::Create(AVSValue args, void*, IScriptEnviro...
function PVideoFrame (line 347) | PVideoFrame DeleteFrame::GetFrame(int n, IScriptEnvironment* env)
function AVSValue (line 359) | AVSValue __cdecl DeleteFrame::Create(AVSValue args, void*, IScriptEnviro...
function PVideoFrame (line 402) | PVideoFrame DuplicateFrame::GetFrame(int n, IScriptEnvironment* env)
function AVSValue (line 414) | AVSValue __cdecl DuplicateFrame::Create(AVSValue args, void*, IScriptEnv...
function PVideoFrame (line 508) | PVideoFrame Splice::GetFrame(int n, IScriptEnvironment* env)
function A
Copy disabled (too large)
Download .json
Condensed preview — 622 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (14,691K chars).
[
{
"path": ".editorconfig",
"chars": 334,
"preview": "root = true\n\n# NOTE: editorconfig-core-c has a hardcoded limitation of 50 chars per .ini section name\n\n[*.{cpp,h,hpp,c,a"
},
{
"path": ".gitattributes",
"chars": 410,
"preview": "# Set the default behavior, in case people don't have core.autocrlf set.\n* text eol=lf\n\ndistrib/**/*.css linguist-docume"
},
{
"path": ".github/workflows/build.yml",
"chars": 850,
"preview": "name: Build AviSynth+\n\non: [push]\n\njobs:\n build:\n name: ${{ matrix.config.name }}\n runs-on: ${{ matrix.config.os "
},
{
"path": ".gitignore",
"chars": 2759,
"preview": "avisynth-build/*\nCMakeCache.txt\nCMakeFiles/*\ndistrib/docs/english/build/\ndistrib/WinInstaller/git_rev.ini\ndistrib/WinIns"
},
{
"path": ".gitmodules",
"chars": 88,
"preview": "[submodule \"filesystem\"]\n\tpath = filesystem\n\turl = https://github.com/gulrak/filesystem\n"
},
{
"path": ".readthedocs.yaml",
"chars": 1061,
"preview": "# Read the Docs configuration file for Sphinx projects\n# See https://docs.readthedocs.io/en/stable/config-file/v2.html f"
},
{
"path": "CMakeLists.txt",
"chars": 30318,
"preview": "# Tested generators:\n# Command line makefile generator\n# \"MinGW Makefiles\": MSYS2/Mingw32 GCC 8.3, 10.3 build\n# IDE proj"
},
{
"path": "README.md",
"chars": 2679,
"preview": "AviSynth+\n=========\n\n**AviSynth+** is an improved version of the [AviSynth frameserver](http://avisynth.nl/index.php/Mai"
},
{
"path": "avs_core/CMakeLists.txt",
"chars": 15789,
"preview": "CMAKE_MINIMUM_REQUIRED( VERSION 3.6.2...3.11 )\n\nif (WIN32)\n if(BUILD_SHARED_LIBS)\n set(CoreName \"AviSynth\")\n else()"
},
{
"path": "avs_core/Files.cmake",
"chars": 3734,
"preview": "FILE(GLOB AvsCore_Sources RELATIVE \"${CMAKE_CURRENT_SOURCE_DIR}\"\n \"*.c\"\n \"*.cpp\"\n \"*.h\"\n\n \"include/*.h\"\n \"include/a"
},
{
"path": "avs_core/TargetArch.cmake",
"chars": 6385,
"preview": "# http://stackoverflow.com/questions/11944060/how-to-detect-target-architecture-using-cmake\n# https://github.com/petroul"
},
{
"path": "avs_core/Version.cmake",
"chars": 1745,
"preview": "FIND_PACKAGE(Git)\nif (EXISTS \"${REPO}/.git\" AND GIT_FOUND)\nEXECUTE_PROCESS(\n COMMAND \"${GIT}\" --git-dir=${REPO}/.git "
},
{
"path": "avs_core/avisynth.pc.in",
"chars": 367,
"preview": "prefix=@CMAKE_INSTALL_PREFIX@\nexec_prefix=@CMAKE_INSTALL_PREFIX@\nlibdir=@CMAKE_INSTALL_FULL_LIBDIR@\nincludedir=@CMAKE_IN"
},
{
"path": "avs_core/avisynth_conf.h.in",
"chars": 255,
"preview": "#ifndef _AVS_CONF_H_\n#define _AVS_CONF_H_\n\n#include <avs/config.h>\n\n#ifdef AVS_POSIX\n#define user_avs_plugindir_configur"
},
{
"path": "avs_core/convert/convert.cpp",
"chars": 30721,
"preview": "// Avisynth v2.5. Copyright 2002-2009 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; "
},
{
"path": "avs_core/convert/convert.h",
"chars": 2253,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/convert_audio.cpp",
"chars": 9012,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/convert_audio.h",
"chars": 5152,
"preview": "// Avisynth v2.5. Copyright 2009 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/convert_audio_c.cpp",
"chars": 8555,
"preview": "// Avisynth+\n// https://avs-plus.net\n//\n// This file is part of Avisynth+ which is released under GPL2+ with exception.\n"
},
{
"path": "avs_core/convert/convert_bits.cpp",
"chars": 70074,
"preview": "// Avisynth v2.5. Copyright 2002-2009 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; "
},
{
"path": "avs_core/convert/convert_bits.h",
"chars": 4712,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/convert_helper.cpp",
"chars": 19611,
"preview": "// Avisynth v2.5. Copyright 2002-2009 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; "
},
{
"path": "avs_core/convert/convert_helper.h",
"chars": 10751,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/convert_matrix.cpp",
"chars": 15210,
"preview": "// Avisynth v2.5. Copyright 2002-2009 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; "
},
{
"path": "avs_core/convert/convert_matrix.h",
"chars": 3915,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/convert_planar.cpp",
"chars": 106092,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/convert_planar.h",
"chars": 9095,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/convert_rgb.cpp",
"chars": 16668,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/convert_rgb.h",
"chars": 3648,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/intel/convert_audio_avx2.cpp",
"chars": 8338,
"preview": "// Avisynth+\n// https://avs-plus.net\n//\n// This file is part of Avisynth+ which is released under GPL2+ with exception.\n"
},
{
"path": "avs_core/convert/intel/convert_audio_sse.cpp",
"chars": 21789,
"preview": "// Avisynth+\n// https://avs-plus.net\n//\n// This file is part of Avisynth+ which is released under GPL2+ with exception.\n"
},
{
"path": "avs_core/convert/intel/convert_bits_avx2.cpp",
"chars": 47610,
"preview": "// Avisynth v2.5. Copyright 2002-2009 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; "
},
{
"path": "avs_core/convert/intel/convert_bits_avx2.h",
"chars": 3067,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/intel/convert_bits_sse.cpp",
"chars": 38736,
"preview": "// Avisynth v2.5. Copyright 2002-2009 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; "
},
{
"path": "avs_core/convert/intel/convert_bits_sse.h",
"chars": 3045,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/intel/convert_planar_avx2.cpp",
"chars": 87930,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/intel/convert_planar_avx2.h",
"chars": 2641,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/intel/convert_planar_sse.cpp",
"chars": 69860,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/intel/convert_planar_sse.h",
"chars": 4222,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/intel/convert_rgb_avx2.cpp",
"chars": 13273,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/intel/convert_rgb_avx2.h",
"chars": 2328,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/intel/convert_rgb_avx512.cpp",
"chars": 6022,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/intel/convert_rgb_avx512.h",
"chars": 2164,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/intel/convert_rgb_sse.cpp",
"chars": 37102,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/convert/intel/convert_rgb_sse.h",
"chars": 3980,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/core/AVSMap.h",
"chars": 8732,
"preview": "#pragma once\n/*\nThis program is free software; you can redistribute it and /or modify\nit under the terms of the GNU Gene"
},
{
"path": "avs_core/core/AviHelper.cpp",
"chars": 35922,
"preview": "// Avisynth v2.5. Copyright 2007 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/core/AviHelper.h",
"chars": 5055,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/core/BufferPool.cpp",
"chars": 3543,
"preview": "#include \"BufferPool.h\"\n#include <map>\n#include <avisynth.h>\n#include <avs/alignment.h>\n#include <avs/minmax.h>\n#include"
},
{
"path": "avs_core/core/BufferPool.h",
"chars": 558,
"preview": "#ifndef _AVS_BUFFERPOOL_H\n#define _AVS_BUFFERPOOL_H\n\n#include <map>\n#include <avs/types.h>\n\nclass InternalEnvironment;\n\n"
},
{
"path": "avs_core/core/CompatEnvironment.h",
"chars": 16281,
"preview": "// Avisynth v2.5. Copyright 2002-2009 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; "
},
{
"path": "avs_core/core/DeviceManager.cpp",
"chars": 39545,
"preview": "\n#include \"DeviceManager.h\"\n#include \"internal.h\"\n#include \"InternalEnvironment.h\"\n#include <avs/minmax.h>\n#include <deq"
},
{
"path": "avs_core/core/DeviceManager.h",
"chars": 2461,
"preview": "#pragma once\n\n#include <avisynth.h>\n#include <vector>\n#include <atomic>\n#include <memory>\n\nclass InternalEnvironment;\nen"
},
{
"path": "avs_core/core/FilterConstructor.cpp",
"chars": 4181,
"preview": "#include \"FilterConstructor.h\"\n#include \"avisynth.h\"\n\nFilterConstructor::FilterConstructor(IScriptEnvironment2 * env,\n "
},
{
"path": "avs_core/core/FilterConstructor.h",
"chars": 923,
"preview": "#ifndef _AVS_FILTER_CONSTRUCTOR_H\n#define _AVS_FILTER_CONSTRUCTOR_H\n\n#include \"internal.h\"\n#include <vector>\n\nclass Filt"
},
{
"path": "avs_core/core/FilterGraph.cpp",
"chars": 16527,
"preview": "#include \"avs/config.h\"\n#include \"FilterGraph.h\"\n#include \"DeviceManager.h\"\n#include \"InternalEnvironment.h\"\n#include \"s"
},
{
"path": "avs_core/core/FilterGraph.h",
"chars": 2558,
"preview": "#ifndef _AVS_FILTER_GRAPH_H\n#define _AVS_FILTER_GRAPH_H\n\n#include \"internal.h\"\n#include <vector>\n#include <map>\n#include"
},
{
"path": "avs_core/core/InternalEnvironment.h",
"chars": 19214,
"preview": "#ifndef _AVS_SCRIPTENVIRONMENT_H_INCLUDED\n#define _AVS_SCRIPTENVIRONMENT_H_INCLUDED\n\n#include <avisynth.h>\n#include <alg"
},
{
"path": "avs_core/core/LruCache.h",
"chars": 8767,
"preview": "#ifndef AVS_LRUCACHE_H\n#define AVS_LRUCACHE_H\n\n#include <mutex>\n#include <condition_variable>\n#include <memory>\n#include"
},
{
"path": "avs_core/core/MTGuard.cpp",
"chars": 12021,
"preview": "// Avisynth v2.6. Copyright 2002-2009 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; "
},
{
"path": "avs_core/core/MTGuard.h",
"chars": 1710,
"preview": "#ifndef _AVS_MTGUARD_H\n#define _AVS_MTGUARD_H\n\n#include \"internal.h\"\n#include <vector>\n#include <memory>\n#include <mutex"
},
{
"path": "avs_core/core/MappedList.h",
"chars": 1183,
"preview": "#ifndef _AVS_MAPPED_LIST\n#define _AVS_MAPPED_LIST\n\n#include <list>\n#include <unordered_map>\n\ntemplate <typename T>\nclass"
},
{
"path": "avs_core/core/ObjectPool.h",
"chars": 2409,
"preview": "#ifndef _AVS_OBJECTPOOL_H\n#define _AVS_OBJECTPOOL_H\n\n#include <list>\n#include <unordered_map>\n#include <new>\n#include <c"
},
{
"path": "avs_core/core/PluginManager.cpp",
"chars": 52265,
"preview": "#include \"PluginManager.h\"\n#include <avisynth.h>\n#include <unordered_set>\n#include <avisynth_c.h>\n#include \"strings.h\"\n#"
},
{
"path": "avs_core/core/PluginManager.h",
"chars": 2579,
"preview": "#ifndef AVSCORE_PLUGINS_H\n#define AVSCORE_PLUGINS_H\n\n#include <string>\n#include <map>\n#include <vector>\n#include \"intern"
},
{
"path": "avs_core/core/Prefetcher.cpp",
"chars": 9830,
"preview": "#include \"Prefetcher.h\"\n\n#include <vector>\n#include <mutex>\n#include <atomic>\n#ifdef INTEL_INTRINSICS\n#include <mmintrin"
},
{
"path": "avs_core/core/Prefetcher.h",
"chars": 1010,
"preview": "#ifndef _AVS_FILT_PREFETCHER_H\n#define _AVS_FILT_PREFETCHER_H\n\n#include <avisynth.h>\n\nstruct PrefetcherPimpl;\nclass Inte"
},
{
"path": "avs_core/core/ScriptEnvironmentTLS.h",
"chars": 380,
"preview": "#ifndef _ThreadScriptEnvironment_H\n#define _ThreadScriptEnvironment_H\n\n#include <avisynth.h>\n#ifdef AVS_WINDOWS\n#include"
},
{
"path": "avs_core/core/SimpleLruCache.h",
"chars": 3691,
"preview": "#ifndef AVS_SIMPLELRUCACHE_H\n#define AVS_SIMPLELRUCACHE_H\n\n#include <list>\n#include <functional>\n#include <limits>\n#incl"
},
{
"path": "avs_core/core/ThreadPool.cpp",
"chars": 3690,
"preview": "#include \"ThreadPool.h\"\n#include \"internal.h\"\n#include <cassert>\n#include <thread>\n\nstruct ThreadPoolGenericItemData\n{\n "
},
{
"path": "avs_core/core/ThreadPool.h",
"chars": 2807,
"preview": "#ifndef _AVS_THREADPOOL_H\n#define _AVS_THREADPOOL_H\n\n#include <avisynth.h>\n#include <future>\n#include <vector>\n\ntypedef "
},
{
"path": "avs_core/core/alignplanar.cpp",
"chars": 3315,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/core/alignplanar.h",
"chars": 2131,
"preview": "// Avisynth v2.5. Copyright 2009 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/core/arch.h.in",
"chars": 129,
"preview": "#ifndef _AVS_ARCH_H_\n#define _AVS_ARCH_H_\n\n#define AVS_ARCH @AVS_ARCH@\t \t// e.g. i386\n\n#endif // _AV"
},
{
"path": "avs_core/core/audio.cpp",
"chars": 72598,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/core/audio.h",
"chars": 19451,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/core/avisynth.cpp",
"chars": 231410,
"preview": "// Avisynth v2.6. Copyright 2002-2009 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; "
},
{
"path": "avs_core/core/avisynth.def",
"chars": 7024,
"preview": "LIBRARY AviSynth.dll\nEXPORTS\n DllGetClassObject PRIVATE\n DllCanUnloadNow PRIVATE\n CreateScriptEnvironment = _CreateSc"
},
{
"path": "avs_core/core/avisynth.rc",
"chars": 2825,
"preview": "#include <windows.h>\n#include \"version.h\"\n\n#define VER_FILEVERSION AVS_MAJOR_VER,AVS_MINOR_VER,AVS_BUGFIX_VE"
},
{
"path": "avs_core/core/avisynth64.def",
"chars": 83,
"preview": "LIBRARY AviSynth.dll\nEXPORTS\n DllGetClassObject PRIVATE\n DllCanUnloadNow PRIVATE\n"
},
{
"path": "avs_core/core/avisynth_c.cpp",
"chars": 43460,
"preview": "// Avisynth C Interface\n// Based on Copyright 2003 Kevin Atkinson\n//\n// This program is free software; you can redistrib"
},
{
"path": "avs_core/core/avs_simd_c.h",
"chars": 48692,
"preview": "// AviSynth+. Copyright 2025 AviSynth+ Project\n// https://avs-plus.net\n// http://avisynth.nl\n// This program is free so"
},
{
"path": "avs_core/core/bitblt.cpp",
"chars": 9203,
"preview": "// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU General Public "
},
{
"path": "avs_core/core/bitblt.h",
"chars": 1983,
"preview": "// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU General Public "
},
{
"path": "avs_core/core/cache.cpp",
"chars": 34082,
"preview": "// Avisynth v2.6. Copyright 2002-2009 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; "
},
{
"path": "avs_core/core/cache.h",
"chars": 4666,
"preview": "// Avisynth v2.6. Copyright 2002-2009 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; "
},
{
"path": "avs_core/core/clip_info.h",
"chars": 2290,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/core/cpuid.cpp",
"chars": 21126,
"preview": "// Avisynth v1.0 beta. Copyright 2000 Ben Rudiak-Gould.\n// http://www.math.berkeley.edu/~benrg/avisynth.html\n\n//\tVirtua"
},
{
"path": "avs_core/core/exception.cpp",
"chars": 5792,
"preview": "// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU General Public "
},
{
"path": "avs_core/core/exception.h",
"chars": 2605,
"preview": "// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU General Public "
},
{
"path": "avs_core/core/findfirst.h",
"chars": 2552,
"preview": "/*\n * Copyright (C) 2011 Mathieu Turcotte (mathieuturcotte.ca)\n *\n * This program is free software: you can redistribute"
},
{
"path": "avs_core/core/fonts/fixedfonts.cpp",
"chars": 3952417,
"preview": "/*\nFont set #1\n-----------\nCopyright (c) 2019 Dimitar Toshkov Zhekov,\nwith Reserved Font Name \"Terminus Font\".\n\nThis Fon"
},
{
"path": "avs_core/core/fonts/fixedfonts.h",
"chars": 415,
"preview": "#ifndef __FIXEDFONTS_H__\n#define __FIXEDFONTS_H__\n\n#include <cstdint>\n\ntypedef struct {\n const char* const fontname;\n "
},
{
"path": "avs_core/core/function.h",
"chars": 2145,
"preview": "#pragma once\n\n#include <avisynth.h>\n\nstruct Function {\n\n typedef AVSValue(__cdecl *apply_func_t)(AVSValue args, void* u"
},
{
"path": "avs_core/core/info.cpp",
"chars": 85599,
"preview": "// Avisynth+\n// https://avs-plus.net\n//\n// This program is free software; you can redistribute it and/or modify\n// it un"
},
{
"path": "avs_core/core/info.h",
"chars": 7696,
"preview": "// Avisynth+\n// https://avs-plus.net\n//\n// This program is free software; you can redistribute it and/or modify\n// it un"
},
{
"path": "avs_core/core/initguid.cpp",
"chars": 2135,
"preview": "// Avisynth v2.5. Copyright 2007 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/core/interface.cpp",
"chars": 61362,
"preview": "// Avisynth v2.5. Copyright 2002, 2005 Ben Rudiak-Gould et al.\n// Avisynth v2.6. Copyright 2006 Klaus Post.\n// Avisynt"
},
{
"path": "avs_core/core/internal.h",
"chars": 10272,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/core/main.cpp",
"chars": 60539,
"preview": "// Avisynth v2.5. Copyright 2007 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/core/memcpy_amd.cpp",
"chars": 10469,
"preview": "/******************************************************************************\n\n Copyright (c) 2001 Advanced Micro Devi"
},
{
"path": "avs_core/core/memcpy_amd.h",
"chars": 2366,
"preview": "/******************************************************************************\n\n Copyright (c) 2001 Advanced Micro Devi"
},
{
"path": "avs_core/core/mpmc_bounded_queue.h",
"chars": 2873,
"preview": "#include <vector>\n\ntemplate <typename T>\nclass circular_buffer\n{\npublic:\n\n typedef size_t size_type;\n typedef T value_"
},
{
"path": "avs_core/core/parser/expression.cpp",
"chars": 24293,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/core/parser/expression.h",
"chars": 12535,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/core/parser/os/win32_string_compat.cpp",
"chars": 928,
"preview": "// Copy of AvxSynth's windowsPorts.cpp; it was missing the licensing\n// header there, too.\n\n#include \"win32_string_compa"
},
{
"path": "avs_core/core/parser/os/win32_string_compat.h",
"chars": 707,
"preview": "// Copy of AvxSynth's windowsPorts.h; it was missing the licensing\n// header there, too.\n\n#ifndef __WIN32_STRING_COMPAT_"
},
{
"path": "avs_core/core/parser/script.cpp",
"chars": 109137,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/core/parser/script.h",
"chars": 16870,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/core/parser/scriptparser.cpp",
"chars": 27003,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/core/parser/scriptparser.h",
"chars": 4001,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/core/parser/tokenizer.cpp",
"chars": 12335,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/core/parser/tokenizer.h",
"chars": 4674,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/core/strings.cpp",
"chars": 10946,
"preview": "// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU General Public "
},
{
"path": "avs_core/core/strings.h",
"chars": 3393,
"preview": "// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU General Public "
},
{
"path": "avs_core/core/vartable.h",
"chars": 11444,
"preview": "// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU General Public "
},
{
"path": "avs_core/core/version.h.in",
"chars": 1023,
"preview": "#ifndef _AVS_VERSION_H_\n#define _AVS_VERSION_H_\n\n#include \"arch.h\"\n\n#define AVS_PPSTR_(x) \t#x\n#define AVS"
},
{
"path": "avs_core/filters/AviSource/AVIIndex.cpp",
"chars": 4794,
"preview": "// Packaged with Avisynth v1.0 beta.\n// http://www.math.berkeley.edu/~benrg/avisynth.html\n\n//\tVirtualDub - Video process"
},
{
"path": "avs_core/filters/AviSource/AVIIndex.h",
"chars": 2570,
"preview": "// Packaged with Avisynth v1.0 beta.\n// http://www.math.berkeley.edu/~benrg/avisynth.html\n\n//\tVirtualDub - Video process"
},
{
"path": "avs_core/filters/AviSource/AVIReadHandler.cpp",
"chars": 63398,
"preview": "//\tVirtualDub - Video processing and capture application\n//\tCopyright (C) 1998-2001 Avery Lee\n//\n//\tThis program is fre"
},
{
"path": "avs_core/filters/AviSource/AVIReadHandler.h",
"chars": 2382,
"preview": "//\tVirtualDub - Video processing and capture application\n//\tCopyright (C) 1998-2001 Avery Lee\n//\n//\tThis program is free"
},
{
"path": "avs_core/filters/AviSource/AudioSource.cpp",
"chars": 6592,
"preview": "//\tVirtualDub - Video processing and capture application\n//\tCopyright (C) 1998-2001 Avery Lee\n//\n//\tThis program is free"
},
{
"path": "avs_core/filters/AviSource/AudioSource.h",
"chars": 1921,
"preview": "//\tVirtualDub - Video processing and capture application\n//\tCopyright (C) 1998-2001 Avery Lee\n//\n//\tThis program is free"
},
{
"path": "avs_core/filters/AviSource/DubSource.cpp",
"chars": 2121,
"preview": "//\tVirtualDub - Video processing and capture application\n//\tCopyright (C) 1998-2001 Avery Lee\n//\n//\tThis program is free"
},
{
"path": "avs_core/filters/AviSource/DubSource.h",
"chars": 2605,
"preview": "//\tVirtualDub - Video processing and capture application\n//\tCopyright (C) 1998-2001 Avery Lee\n//\n//\tThis program is free"
},
{
"path": "avs_core/filters/AviSource/Error.h",
"chars": 447,
"preview": "// Avisynth v1.0 beta. Copyright 2000 Ben Rudiak-Gould.\n// http://www.math.berkeley.edu/~benrg/avisynth.html\n\n#ifndef f"
},
{
"path": "avs_core/filters/AviSource/FastReadStream.cpp",
"chars": 6879,
"preview": "// Packaged with Avisynth v1.0 beta.\n// http://www.math.berkeley.edu/~benrg/avisynth.html\n\n//\tVirtualDub - Video process"
},
{
"path": "avs_core/filters/AviSource/FastReadStream.h",
"chars": 1577,
"preview": "// Packaged with Avisynth v1.0 beta.\n// http://www.math.berkeley.edu/~benrg/avisynth.html\n\n//\tVirtualDub - Video process"
},
{
"path": "avs_core/filters/AviSource/File64.cpp",
"chars": 4089,
"preview": "// Packaged with Avisynth v1.0 beta.\n// http://www.math.berkeley.edu/~benrg/avisynth.html\n\n//\tVirtualDub - Video process"
},
{
"path": "avs_core/filters/AviSource/File64.h",
"chars": 1531,
"preview": "// Packaged with Avisynth v1.0 beta.\n// http://www.math.berkeley.edu/~benrg/avisynth.html\n\n//\tVirtualDub - Video process"
},
{
"path": "avs_core/filters/AviSource/Fixes.h",
"chars": 1661,
"preview": "// Packaged with Avisynth v1.0 beta.\n// http://www.math.berkeley.edu/~benrg/avisynth.html\n\n//\tVirtualDub - Video process"
},
{
"path": "avs_core/filters/AviSource/VD_Audio.cpp",
"chars": 54543,
"preview": "//\tVirtualDub - Video processing and capture application\n//\tCopyright (C) 1998-2001 Avery Lee\n//\n//\tThis program is free"
},
{
"path": "avs_core/filters/AviSource/VD_Audio.h",
"chars": 5293,
"preview": "//\tVirtualDub - Video processing and capture application\n//\tCopyright (C) 1998-2001 Avery Lee\n//\n//\tThis program is free"
},
{
"path": "avs_core/filters/AviSource/avi_source.cpp",
"chars": 73276,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/AviSource/avi_source.h",
"chars": 5872,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/AviSource/clip_info.h",
"chars": 2290,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/AviSource/list.cpp",
"chars": 1600,
"preview": "// Packaged with Avisynth v1.0 beta.\n// http://www.math.berkeley.edu/~benrg/avisynth.html\n\n//\tVirtualDub - Video process"
},
{
"path": "avs_core/filters/AviSource/list.h",
"chars": 2829,
"preview": "// Packaged with Avisynth v1.0 beta.\n// http://www.math.berkeley.edu/~benrg/avisynth.html\n\n//\tVirtualDub - Video process"
},
{
"path": "avs_core/filters/aarch64/turn_neon.cpp",
"chars": 24060,
"preview": "// AviSynth+. Copyright 2025 AviSynth+ Project\n// https://avs-plus.net\n// http://avisynth.nl\n// This program is free so"
},
{
"path": "avs_core/filters/aarch64/turn_neon.h",
"chars": 3417,
"preview": "// AviSynth+. Copyright 2025 AviSynth+ Project\n// https://avs-plus.net\n// http://avisynth.nl\n// This program is free so"
},
{
"path": "avs_core/filters/color.cpp",
"chars": 48727,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/color.h",
"chars": 3855,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/colorbars_const.h",
"chars": 3752,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/combine.cpp",
"chars": 37341,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/combine.h",
"chars": 6995,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/conditional/conditional.cpp",
"chars": 29536,
"preview": "\n// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you "
},
{
"path": "avs_core/filters/conditional/conditional.h",
"chars": 3967,
"preview": "\n// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you "
},
{
"path": "avs_core/filters/conditional/conditional_functions.cpp",
"chars": 53194,
"preview": "\n// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you "
},
{
"path": "avs_core/filters/conditional/conditional_functions.h",
"chars": 4268,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/conditional/conditional_reader.cpp",
"chars": 56842,
"preview": "/*\n ConditionalReader (c) 2004 by Klaus Post\n\n This program is free software; you can redistribute it and/or modify\n "
},
{
"path": "avs_core/filters/conditional/conditional_reader.h",
"chars": 7307,
"preview": "/*\n ConditionalReader (c) 2004 by Klaus Post\n\n This program is free software; you can redistribute it and/or modify\n "
},
{
"path": "avs_core/filters/conditional/intel/conditional_functions_sse.cpp",
"chars": 5260,
"preview": "\n// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you "
},
{
"path": "avs_core/filters/conditional/intel/conditional_functions_sse.h",
"chars": 2372,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/convolution.cpp",
"chars": 26497,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/convolution.h",
"chars": 3996,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/debug.cpp",
"chars": 9865,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/debug.h",
"chars": 2676,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/edit.cpp",
"chars": 37050,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/edit.h",
"chars": 9039,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/exprfilter/exprfilter.cpp",
"chars": 283435,
"preview": "/*\n*\n* Avisynth+ Expression filter, ported from the VapourSynth project\n* Copyright (c) 2012-2015 Fredrik Mellbin\n*\n* Ad"
},
{
"path": "avs_core/filters/exprfilter/exprfilter.h",
"chars": 7315,
"preview": "#ifndef __Exprfilter_h\n#define __Exprfilter_h\n\n#include <avisynth.h>\n#include <mutex>\n#ifdef AVS_POSIX\n#include <sys/mma"
},
{
"path": "avs_core/filters/exprfilter/jitasm.h",
"chars": 687307,
"preview": "// Copyright (c) 2009-2011, Hikaru Inoue, Akihiro Yamasaki,\n// All rights reserved.\n//\n// Redistribution and use in sour"
},
{
"path": "avs_core/filters/field.cpp",
"chars": 37056,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/field.h",
"chars": 12019,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/focus.cpp",
"chars": 47385,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/focus.h",
"chars": 5001,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/fps.cpp",
"chars": 28188,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/fps.h",
"chars": 5475,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/greyscale.cpp",
"chars": 12609,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/greyscale.h",
"chars": 2678,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/histogram.cpp",
"chars": 110450,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/histogram.h",
"chars": 4975,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/check_avx512.h",
"chars": 4659,
"preview": "// Avisynth+\n// https://avs-plus.net\n\n// This program is free software; you can redistribute it and/or modify\n// it unde"
},
{
"path": "avs_core/filters/intel/focus_avx2.cpp",
"chars": 19003,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/focus_avx2.h",
"chars": 2402,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/focus_sse.cpp",
"chars": 72504,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/focus_sse.h",
"chars": 5756,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/greyscale_sse.cpp",
"chars": 10985,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/greyscale_sse.h",
"chars": 2591,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/layer_avx2.cpp",
"chars": 29849,
"preview": "// AviSynth+. Copyright 2026- AviSynth+ Project\n// https://avs-plus.net\n// http://avisynth.nl\n// This program is free s"
},
{
"path": "avs_core/filters/intel/layer_avx2.h",
"chars": 4772,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/layer_sse.cpp",
"chars": 32601,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/layer_sse.h",
"chars": 4325,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/limiter_sse.cpp",
"chars": 4878,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/limiter_sse.h",
"chars": 2484,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/merge_avx2.cpp",
"chars": 14123,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/merge_avx2.h",
"chars": 585,
"preview": "#ifndef __Merge_AVX2_H__\n#define __Merge_AVX2_H__\n\n#include <avs/types.h>\n\ntemplate<typename pixel_t>\nvoid average_plane"
},
{
"path": "avs_core/filters/intel/merge_sse.cpp",
"chars": 21880,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/merge_sse.h",
"chars": 4013,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/planeswap_sse.cpp",
"chars": 7755,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/planeswap_sse.h",
"chars": 2876,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/resample_avx2.cpp",
"chars": 131154,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/resample_avx2.h",
"chars": 7171,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/resample_avx512.cpp",
"chars": 7542,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/resample_avx512.h",
"chars": 11871,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/resample_avx512.hpp",
"chars": 246423,
"preview": "// AviSynth+. Copyright 2026- AviSynth+ Project\n// https://avs-plus.net\n// http://avisynth.nl\n// This program is free s"
},
{
"path": "avs_core/filters/intel/resample_avx512b.cpp",
"chars": 211963,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/resample_sse.cpp",
"chars": 56225,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/resample_sse.h",
"chars": 3493,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
},
{
"path": "avs_core/filters/intel/resize_sse.cpp",
"chars": 7505,
"preview": "// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.\n// http://avisynth.nl\n\n// This program is free software; you c"
}
]
// ... and 422 more files (download for full content)
About this extraction
This page contains the full source code of the pinterf/AviSynthPlus GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 622 files (13.5 MB), approximately 3.6M tokens, and a symbol index with 7263 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.