#include "exprcpp/ast_action.h"

#include "exprcpp/jit_src_builder.h"

#include "exprcpp/support.h"

#include <iterator>

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wdeprecated-declarations"

#include <clang/Basic/Diagnostic.h>

#include <clang/Basic/DiagnosticFrontend.h>

#include <clang/Basic/DiagnosticIDs.h>

#include <clang/Basic/DiagnosticOptions.h>

#include <clang/CodeGen/CodeGenAction.h>

#include <clang/Driver/Compilation.h>

#include <clang/Driver/Driver.h>

#include <clang/Driver/Job.h>

#include <clang/Driver/Tool.h>

#include <clang/Frontend/CompilerInstance.h>

#include <clang/Frontend/CompilerInvocation.h>

#include <clang/Frontend/FrontendAction.h>

#include <clang/Frontend/TextDiagnosticPrinter.h>

#include <llvm/ADT/IntrusiveRefCntPtr.h>

#include <llvm/ADT/SmallVector.h>

#include <llvm/Bitcode/BitcodeWriter.h>

#include <llvm/ExecutionEngine/JITSymbol.h>

#include <llvm/ExecutionEngine/Orc/DebugUtils.h>

#include <llvm/ExecutionEngine/Orc/ExecutionUtils.h>

#include <llvm/ExecutionEngine/Orc/LLJIT.h>

#include <llvm/ExecutionEngine/Orc/ThreadSafeModule.h>

#include <llvm/IR/LLVMContext.h>

#include <llvm/IR/Module.h>

#include <llvm/Option/Option.h>

#include <llvm/Support/DynamicLibrary.h>

#include <llvm/Support/Host.h>

#include <llvm/Support/ManagedStatic.h>

#include <llvm/Support/raw_os_ostream.h>

#include <llvm/Support/TargetSelect.h>

#include <llvm/Support/VirtualFileSystem.h>

#pragma clang diagnostic pop

#include <gsl/gsl>

#include <vapoursynth/VapourSynth.h>

#include <bitset>

#include <cstdint>

#include <ctime>

#include <filesystem>

#include <fstream>

#include <iostream>

#include <memory>

#include <stdexcept>

#include <string>

#include <utility>

#include <vector>

using namespace std::literals;

namespace exprcpp {

class Dump_info {

};

struct Exprcpp_data {

};

void VS_CC init(VSMap*, VSMap*, void** instance_data, VSNode* node, VSCore*,

}

const VSFrameRef *VS_CC get_frame(

int n, int activationReason, void** instance_data, void**,

VSFrameContext* frame_ctx, VSCore* core, const VSAPI* vsapi)

{

const auto* data{static_cast<const Exprcpp_data*>(*instance_data)};

if (activationReason == arInitial) {

for (auto* src: data->srcs) {

vsapi->requestFrameFilter(n, src, frame_ctx);

}

} else if (activationReason == arAllFramesReady) {

Expects(!data->dst_init.empty());

Expects(!data->jit_funcs.empty());

auto src_frames{[&]() {

std::vector<const VSFrameRef*> src_frames;

src_frames.reserve(ssize(data->srcs));

for (auto* node: data->srcs) {

src_frames.push_back(vsapi->getFrameFilter(n, node, frame_ctx));

}

return src_frames;

}()};

auto src_frames_cleaner{gsl::finally(

[&]() { clean_frames(vsapi, src_frames); })};

VSFrameRef* const dst_frame{[&]() {

std::vector<const VSFrameRef*> copy_src_frames;

std::vector<int> copy_src_planes;

for (const auto& [node, plane]: data->dst_init) {

const VSFrameRef* frame{nullptr};

if (node) {

frame = vsapi->getFrameFilter(n, node, frame_ctx);

}

copy_src_frames.push_back(frame);

copy_src_planes.push_back(plane);

}

auto copy_src_frames_cleaner{gsl::finally(

[&]() { clean_frames(vsapi, copy_src_frames); })};

return vsapi->newVideoFrame2(

data->dst_info->format, vsapi->getFrameWidth(src_frames[0], 0),

vsapi->getFrameHeight(src_frames[0], 0), copy_src_frames.data(),

copy_src_planes.data(), src_frames[0], core);

}()};

for (gsl::index plane{0}; plane != data->dst_info->format->numPlanes;

++plane) {

const auto jit_func{data->jit_funcs[plane]};

if (!jit_func) { continue; }

const long pixel_count{vsapi->getFrameWidth(dst_frame, plane)

* vsapi->getFrameHeight(dst_frame, plane)};

for (gsl::index i{0}; i != ssize(src_frames); ++i) {

const long src_pixel_count{

vsapi->getFrameWidth(src_frames[i], plane)

* vsapi->getFrameHeight(src_frames[i], plane)};

if (src_pixel_count != pixel_count) {

throw std::runtime_error{

"Frame "s + std::to_string(n) + " of input clip #"s

+ std::to_string(i) + " has different number of pixels"s

"than output frame"s};

}

}

auto data_ptrs{[&]() {

std::vector<void*> data_ptrs{

vsapi->getWritePtr(dst_frame, plane)};

data_ptrs.reserve(ssize(data->srcs) + 1);

for (const auto* src_frame: src_frames) {

data_ptrs.push_back(const_cast<uint8_t*>(

vsapi->getReadPtr(src_frame, plane)));

}

return data_ptrs;

}()};

jit_func(pixel_count, data_ptrs.data());

}

return dst_frame;

}

return 0;

}

void VS_CC free(void* instance_data, VSCore*, const VSAPI* vsapi)

}

Jit_src_builder::entry_func_type process_source(

}

void VS_CC create(const VSMap* in, VSMap* out, void*, VSCore* core,

const VSAPI* vsapi) try

{

auto data{std::make_unique<Exprcpp_data>()};

std::vector<const VSFormat*> src_fmts;

int err{0};

for (gsl::index i{0}; i != vsapi->propNumElements(in, "clips"); ++i) {

VSNodeRef* const node{vsapi->propGetNode(in, "clips", i, &err)};

if (err) {

throw std::runtime_error{"Failed to get one of the inputs"s};

}

if (const VSFormat* fmt{vsapi->getVideoInfo(node)->format}) {

src_fmts.push_back(fmt);

} else {

throw std::runtime_error{

"Input clips with non-constant format aren't allowed"s};

}

data->srcs.push_back(node);

}

if (data->srcs.empty()) { throw std::runtime_error{"No input clips"s}; }

data->dst_info =

const_cast<VSVideoInfo*>(vsapi->getVideoInfo(data->srcs[0]));

if (int64_t fmt_idx{vsapi->propGetInt(in, "format", 0, &err)}; !err) {

// TODO: add format checks if necessary

data->dst_info->format = vsapi->getFormatPreset(fmt_idx, core);

}

for (const auto& fmt: src_fmts) {

if (fmt->numPlanes != data->dst_info->format->numPlanes) {

throw std::runtime_error{

"All inputs must have the same number of planes"s};

}

if (fmt->subSamplingH != data->dst_info->format->subSamplingH

|| fmt->subSamplingW != data->dst_info->format->subSamplingW) {

throw std::runtime_error{

"All inputs mush have the same subsampling"s};

}

}

Jit_src_builder src_builder_common{src_fmts};

src_builder_common.dst_fmt = data->dst_info->format;

const auto source_path{[&]() {

const char* path_c_str{vsapi->propGetData(in, "source_path", 0, &err)};

if (err) { return std::filesystem::path{}; }

const std::filesystem::path path{path_c_str};

const auto status{std::filesystem::status(path)};

if (!std::filesystem::exists(status)) {

throw std::runtime_error{"Source file doesn't exist"s};

}

if (!std::filesystem::is_regular_file(status)

&& !std::filesystem::is_character_file(status)

&& !std::filesystem::is_fifo(status)

&& !std::filesystem::is_symlink(status))

{

throw std::runtime_error{"Source file is not a file"s};

}

return path;

}()};

if (!source_path.empty()) {

src_builder_common.user_code(source_path);

}

Dump_info dump_info{*vsapi, *in};

bool user_cxxflags_present{false};

auto user_cxxflags{[&]() {

std::vector<const char*> user_cxxflags;

int64_t user_cxxflags_count{vsapi->propNumElements(in, "cxxflags")};

if (user_cxxflags_count == -1) { return user_cxxflags; }

for (gsl::index i{0}; i != user_cxxflags_count; ++i) {

const char* cxxflag{vsapi->propGetData(in, "cxxflags", i, &err)};

if (err) { throw std::runtime_error{"Failed to read cxxflag"s}; }

user_cxxflags.push_back(cxxflag);

}

user_cxxflags_present = true;

return user_cxxflags;

}()};

llvm::InitializeNativeTarget();

llvm::InitializeNativeTargetAsmPrinter();

auto jit{check_result(llvm::orc::LLJITBuilder().create(),

"Failed to create JIT"s)};

for (gsl::index i{0}; i != data->dst_info->format->numPlanes; ++i) {

const char* user_code_c_str{vsapi->propGetData(in, "code", i, &err)};

if (err) {

data->jit_funcs.push_back(

data->jit_funcs[ssize(data->jit_funcs) - 1]);

data->dst_init.push_back(

{data->dst_init[ssize(data->dst_init) - 1].first, i});

continue;

}

std::string user_code{user_code_c_str};

if (user_code.empty()) {

data->jit_funcs.emplace_back(nullptr);

data->dst_init.push_back({data->srcs[0], i});

continue;

}

Jit_src_builder src_builder{src_builder_common};

if (!source_path.empty()) {

src_builder.user_func_name = user_code;

} else {

src_builder.user_code(user_code);

}

auto jit_func{[&]() {

if (user_cxxflags_present) {

return process_source(*jit, src_builder, dump_info, i,

user_cxxflags);

}

return process_source(*jit, src_builder, dump_info, i);

}()};

data->jit_funcs.push_back(jit_func);

data->dst_init.push_back({nullptr, i});

}

data->jit = std::move(jit);

vsapi->createFilter(in, out, "expr_cpp", init, get_frame,

free, fmParallel, 0, data.release(), core);

} catch (const std::exception& ex) {

vsapi->setError(out, ("expr_cpp: "s + ex.what()).c_str());

}

} // namespace exprcpp

VS_EXTERNAL_API(void) VapourSynthPluginInit(VSConfigPlugin config_func,