ajp_anton/media-batch-tools
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
media-batch-tools/tools/avisynth_runner/mbt_avs_runner.c
T

854 lines
26 KiB
C
Raw Permalink Blame History

#ifdef _WIN32
#define AVSC_NO_DECLSPEC
#include <fcntl.h>
#include <io.h>
#include <windows.h>
#endif
#include <avisynth_c.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#ifdef _WIN32
static AVS_Library* avs_library = NULL;
#define avs_clip_get_error avs_library->avs_clip_get_error
#define avs_create_script_environment avs_library->avs_create_script_environment
#define avs_delete_script_environment avs_library->avs_delete_script_environment
#define avs_get_audio avs_library->avs_get_audio
#define avs_get_frame avs_library->avs_get_frame
#define avs_get_frame_props_ro avs_library->avs_get_frame_props_ro
#define avs_get_height_p avs_library->avs_get_height_p
#define avs_get_pitch_p avs_library->avs_get_pitch_p
#define avs_get_read_ptr_p avs_library->avs_get_read_ptr_p
#define avs_get_row_size_p avs_library->avs_get_row_size_p
#define avs_get_video_info avs_library->avs_get_video_info
#define avs_invoke avs_library->avs_invoke
#define avs_bits_per_component avs_library->avs_bits_per_component
#define avs_is_420 avs_library->avs_is_420
#define avs_is_422 avs_library->avs_is_422
#define avs_is_444 avs_library->avs_is_444
#define avs_is_yv12 avs_library->avs_is_yv12
#define avs_is_yv16 avs_library->avs_is_yv16
#define avs_is_yv24 avs_library->avs_is_yv24
#define avs_prop_get_int avs_library->avs_prop_get_int
#define avs_release_clip avs_library->avs_release_clip
#define avs_release_value avs_library->avs_release_value
#define avs_release_video_frame avs_library->avs_release_video_frame
#define avs_set_var avs_library->avs_set_var
#define avs_take_clip avs_library->avs_take_clip
#endif
enum RunnerMode {
MODE_VALIDATE,
MODE_VALIDATE_REAL,
MODE_Y4M,
MODE_Y4M_SKIP_DROP,
MODE_WAV,
MODE_CHECK_SOURCE,
};
#define MBT_AVISYNTH_ENV_VERSION 8
static void usage(void) {
fprintf(stderr, "usage: mbt_avs_runner --validate script.avs [frames.csv]\n");
fprintf(stderr, " mbt_avs_runner --validate-real script.avs [frames.csv]\n");
fprintf(stderr, " mbt_avs_runner --check-source expected_source_id script.avs\n");
fprintf(stderr, " mbt_avs_runner --y4m script.avs\n");
fprintf(stderr, " mbt_avs_runner --y4m-skip-drop fps_num fps_den script.avs\n");
fprintf(stderr, " mbt_avs_runner --wav script.avs\n");
}
static int is_validation_mode(enum RunnerMode mode) {
return mode == MODE_VALIDATE || mode == MODE_VALIDATE_REAL;
}
static int is_y4m_mode(enum RunnerMode mode) {
return mode == MODE_Y4M || mode == MODE_Y4M_SKIP_DROP;
}
static int configure_binary_stdout(enum RunnerMode mode) {
#ifdef _WIN32
if (
(mode == MODE_Y4M || mode == MODE_Y4M_SKIP_DROP || mode == MODE_WAV)
&& _setmode(_fileno(stdout), _O_BINARY) == -1
) {
fprintf(stderr, "failed to set binary stdout mode\n");
return 0;
}
#else
(void)mode;
#endif
return 1;
}
static int set_validation_blank_source(
AVS_ScriptEnvironment* env,
enum RunnerMode mode
) {
if (!is_validation_mode(mode)) {
return 1;
}
AVS_Value value = avs_new_value_bool(mode == MODE_VALIDATE);
if (!avs_set_var(env, "mbt_validation_blank", value)) {
fprintf(stderr, "failed to set validation source mode\n");
return 0;
}
return 1;
}
static double now_seconds(void) {
#ifdef _WIN32
static LARGE_INTEGER frequency;
LARGE_INTEGER counter;
if (frequency.QuadPart == 0) {
QueryPerformanceFrequency(&frequency);
}
QueryPerformanceCounter(&counter);
return (double)counter.QuadPart / (double)frequency.QuadPart;
#else
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return (double)ts.tv_sec + (double)ts.tv_nsec / 1000000000.0;
#endif
}
static void write_progress(
const char* kind,
int processed,
int total,
double elapsed,
double eta
) {
double percent = total > 0 ? (100.0 * (double)processed / (double)total) : 100.0;
fprintf(
stderr,
"%s,%d,%d,%.2f,%.3f,%.3f\n",
kind,
processed,
total,
percent,
elapsed,
eta
);
fflush(stderr);
}
static FILE* open_validation_log(const char* validation_csv_path) {
if (!validation_csv_path) {
return 0;
}
size_t length = strlen(validation_csv_path) + strlen(".runner.log") + 1;
char* path = (char*)malloc(length);
if (!path) {
return 0;
}
snprintf(path, length, "%s.runner.log", validation_csv_path);
FILE* log = fopen(path, "wb");
free(path);
return log;
}
static void log_checkpoint(FILE* log, const char* message) {
if (!log) {
return;
}
fputs(message, log);
fputc('\n', log);
fflush(log);
}
static void log_checkpoint_int(FILE* log, const char* message, int value) {
if (!log) {
return;
}
fprintf(log, "%s%d\n", message, value);
fflush(log);
}
static void log_runner_arch(FILE* log) {
#if defined(_WIN64)
log_checkpoint(log, "runner: windows 64-bit");
#elif defined(_WIN32)
log_checkpoint(log, "runner: windows 32-bit");
#else
log_checkpoint(log, "runner: non-windows");
#endif
}
static AVS_Value initialized_string_value(const char* value) {
AVS_Value avs_value = avs_void;
avs_value.type = 's';
avs_value.array_size = 0;
avs_value.d.string = value;
return avs_value;
}
#ifdef _WIN32
static void log_loaded_dll_path(FILE* log, const char* dll_name) {
if (!log) {
return;
}
HMODULE module = GetModuleHandleA(dll_name);
if (!module) {
fprintf(log, "dll: %s loaded, path unavailable\n", dll_name);
fflush(log);
return;
}
char path[MAX_PATH];
DWORD length = GetModuleFileNameA(module, path, sizeof(path));
if (length == 0 || length >= sizeof(path)) {
fprintf(log, "dll: %s loaded, path unavailable\n", dll_name);
fflush(log);
return;
}
fprintf(log, "dll: %s\n", path);
fflush(log);
}
#endif
static int require_frame_property_api(FILE* log) {
#ifdef _WIN32
if (
avs_get_frame_props_ro
&& avs_prop_get_int
) {
return 1;
}
log_checkpoint(log, "failed: frame property API unavailable");
fprintf(stderr, "loaded AviSynth does not expose the frame property C API required by media-batch-tools\n");
return 0;
#else
(void)log;
return 1;
#endif
}
static void write_plane(const AVS_VideoFrame* frame, int plane) {
const unsigned char* ptr = avs_get_read_ptr_p(frame, plane);
int pitch = avs_get_pitch_p(frame, plane);
int row_size = avs_get_row_size_p(frame, plane);
int height = avs_get_height_p(frame, plane);
for (int y = 0; y < height; y++) {
fwrite(ptr + y * pitch, 1, row_size, stdout);
}
}
static int video_bit_depth(const AVS_VideoInfo* vi) {
#ifdef _WIN32
if (!avs_bits_per_component) {
return 8;
}
#endif
int depth = avs_bits_per_component(vi);
return depth > 0 ? depth : 8;
}
static const char* y4m_chroma_tag(int family, int bit_depth) {
if (family == 420) {
if (bit_depth <= 8) return "C420jpeg";
if (bit_depth == 10) return "C420p10";
if (bit_depth == 12) return "C420p12";
if (bit_depth == 14) return "C420p14";
if (bit_depth == 16) return "C420p16";
}
if (family == 422) {
if (bit_depth <= 8) return "C422";
if (bit_depth == 10) return "C422p10";
if (bit_depth == 12) return "C422p12";
if (bit_depth == 14) return "C422p14";
if (bit_depth == 16) return "C422p16";
}
if (family == 444) {
if (bit_depth <= 8) return "C444";
if (bit_depth == 10) return "C444p10";
if (bit_depth == 12) return "C444p12";
if (bit_depth == 14) return "C444p14";
if (bit_depth == 16) return "C444p16";
}
return 0;
}
static const char* chroma_tag(const AVS_VideoInfo* vi) {
int depth = video_bit_depth(vi);
#ifdef _WIN32
if (avs_is_420 && avs_is_420(vi)) return y4m_chroma_tag(420, depth);
if (avs_is_422 && avs_is_422(vi)) return y4m_chroma_tag(422, depth);
if (avs_is_444 && avs_is_444(vi)) return y4m_chroma_tag(444, depth);
#else
if (avs_is_420(vi)) return y4m_chroma_tag(420, depth);
if (avs_is_422(vi)) return y4m_chroma_tag(422, depth);
if (avs_is_444(vi)) return y4m_chroma_tag(444, depth);
#endif
if (avs_is_yv12(vi)) return y4m_chroma_tag(420, 8);
if (avs_is_yv16(vi)) return y4m_chroma_tag(422, 8);
if (avs_is_yv24(vi)) return y4m_chroma_tag(444, 8);
return 0;
}
static void write_le16(uint16_t value) {
unsigned char bytes[2];
bytes[0] = (unsigned char)(value & 0xff);
bytes[1] = (unsigned char)((value >> 8) & 0xff);
fwrite(bytes, 1, 2, stdout);
}
static void write_le32(uint32_t value) {
unsigned char bytes[4];
bytes[0] = (unsigned char)(value & 0xff);
bytes[1] = (unsigned char)((value >> 8) & 0xff);
bytes[2] = (unsigned char)((value >> 16) & 0xff);
bytes[3] = (unsigned char)((value >> 24) & 0xff);
fwrite(bytes, 1, 4, stdout);
}
static int wav_format_tag(const AVS_VideoInfo* vi) {
return avs_sample_type(vi) == AVS_SAMPLE_FLOAT ? 3 : 1;
}
static int wav_bits_per_sample(const AVS_VideoInfo* vi) {
return avs_bytes_per_channel_sample(vi) * 8;
}
static int read_int_frame_prop(
AVS_ScriptEnvironment* env,
const AVS_VideoFrame* frame,
const char* name,
int64_t* value_out
);
static int write_wav(AVS_Clip* clip, const AVS_VideoInfo* vi) {
if (!avs_has_audio(vi)) {
fprintf(stderr, "script has no audio\n");
return 6;
}
if (
avs_sample_type(vi) != AVS_SAMPLE_INT16
&& avs_sample_type(vi) != AVS_SAMPLE_INT24
&& avs_sample_type(vi) != AVS_SAMPLE_INT32
&& avs_sample_type(vi) != AVS_SAMPLE_FLOAT
) {
fprintf(stderr, "unsupported Avisynth audio sample type for WAV output: %d\n", avs_sample_type(vi));
return 7;
}
int channels = avs_audio_channels(vi);
int sample_rate = avs_samples_per_second(vi);
int bytes_per_sample = avs_bytes_per_audio_sample(vi);
int bits_per_sample = wav_bits_per_sample(vi);
int64_t total_samples = vi->num_audio_samples;
int64_t data_size_64 = total_samples * bytes_per_sample;
if (data_size_64 > 0xffffffffLL - 36) {
fprintf(stderr, "WAV output would exceed RIFF size limit\n");
return 8;
}
uint32_t data_size = (uint32_t)data_size_64;
uint32_t byte_rate = (uint32_t)(sample_rate * bytes_per_sample);
uint16_t block_align = (uint16_t)bytes_per_sample;
fwrite("RIFF", 1, 4, stdout);
write_le32(36 + data_size);
fwrite("WAVE", 1, 4, stdout);
fwrite("fmt ", 1, 4, stdout);
write_le32(16);
write_le16((uint16_t)wav_format_tag(vi));
write_le16((uint16_t)channels);
write_le32((uint32_t)sample_rate);
write_le32(byte_rate);
write_le16(block_align);
write_le16((uint16_t)bits_per_sample);
fwrite("data", 1, 4, stdout);
write_le32(data_size);
const int64_t chunk_samples = 65536;
unsigned char* buffer = (unsigned char*)malloc((size_t)(chunk_samples * bytes_per_sample));
if (!buffer) {
fprintf(stderr, "failed to allocate audio buffer\n");
return 10;
}
for (int64_t start = 0; start < total_samples; start += chunk_samples) {
int64_t count = total_samples - start;
if (count > chunk_samples) {
count = chunk_samples;
}
int byte_count = (int)(count * bytes_per_sample);
int error = avs_get_audio(clip, buffer, start, count);
if (error) {
const char* err = avs_clip_get_error(clip);
fprintf(stderr, "failed to get audio at sample %lld%s%s\n", (long long)start, err ? ": " : "", err ? err : "");
free(buffer);
return 9;
}
fwrite(buffer, 1, byte_count, stdout);
}
free(buffer);
return 0;
}
static int frame_is_marked_drop(AVS_ScriptEnvironment* env, const AVS_VideoFrame* frame) {
int64_t value = 0;
return read_int_frame_prop(env, frame, "mbt_drop_frame", &value) == 1 && value != 0;
}
static int check_source_id(
AVS_ScriptEnvironment* env,
AVS_Clip* clip,
const AVS_VideoInfo* vi,
int64_t expected_source_id
) {
if (vi->num_frames <= 0) {
fprintf(stderr, "script has no video frames\n");
return 13;
}
AVS_VideoFrame* frame = avs_get_frame(clip, 0);
if (!frame) {
const char* err = avs_clip_get_error(clip);
fprintf(stderr, "failed to get frame 0%s%s\n", err ? ": " : "", err ? err : "");
return 5;
}
int64_t source_id = 0;
int status = read_int_frame_prop(env, frame, "mbt_source_id", &source_id);
avs_release_video_frame(frame);
if (status < 0) {
fprintf(stderr, "failed to read mbt_source_id at frame 0\n");
return 12;
}
if (status == 0) {
fprintf(stderr, "frame 0 is missing mbt_source_id\n");
return 14;
}
if (source_id != expected_source_id) {
fprintf(
stderr,
"frame 0 has mbt_source_id %lld, expected %lld\n",
(long long)source_id,
(long long)expected_source_id
);
return 15;
}
printf("source_id=%lld\n", (long long)source_id);
fflush(stdout);
return 0;
}
static int read_int_frame_prop(
AVS_ScriptEnvironment* env,
const AVS_VideoFrame* frame,
const char* name,
int64_t* value_out
) {
const AVS_Map* props = avs_get_frame_props_ro(env, frame);
if (!props) {
return 0;
}
int error = AVS_GETPROPERROR_SUCCESS;
int64_t value = avs_prop_get_int(env, props, name, 0, &error);
if (error == AVS_GETPROPERROR_UNSET || error == AVS_GETPROPERROR_INDEX) {
return 0;
}
if (error != AVS_GETPROPERROR_SUCCESS) {
return -1;
}
*value_out = value;
return 1;
}
static int write_validation_row(
FILE* csv,
AVS_ScriptEnvironment* env,
const AVS_VideoFrame* frame,
int output_frame
) {
int64_t source_id = 0;
int64_t source_frame = 0;
int64_t drop_frame = 0;
int64_t matrix = 0;
int source_id_status = read_int_frame_prop(env, frame, "mbt_source_id", &source_id);
int source_frame_status = read_int_frame_prop(env, frame, "mbt_source_frame", &source_frame);
int drop_frame_status = read_int_frame_prop(env, frame, "mbt_drop_frame", &drop_frame);
int matrix_status = read_int_frame_prop(env, frame, "_Matrix", &matrix);
if (source_id_status < 0 || source_frame_status < 0 || drop_frame_status < 0 || matrix_status < 0) {
fprintf(stderr, "failed to read media-batch-tools frame properties at frame %d\n", output_frame);
return 12;
}
fprintf(csv, "%d,", output_frame);
if (source_id_status > 0) {
fprintf(csv, "%lld", (long long)source_id);
}
fputc(',', csv);
if (source_frame_status > 0) {
fprintf(csv, "%lld", (long long)source_frame);
}
fprintf(csv, ",%lld,", drop_frame_status > 0 ? (long long)drop_frame : 0LL);
if (matrix_status > 0) {
fprintf(csv, "%lld", (long long)matrix);
}
fputc('\n', csv);
return 0;
}
static int render_clip(
AVS_ScriptEnvironment* env,
AVS_Clip* clip,
const AVS_VideoInfo* vi,
enum RunnerMode mode,
unsigned int y4m_fps_num,
unsigned int y4m_fps_den,
const char* validation_csv_path,
FILE* diagnostic_log
) {
if (mode == MODE_WAV) {
return write_wav(clip, vi);
}
const char* chroma = 0;
FILE* validation_csv = 0;
double* progress_times = 0;
double progress_start = 0.0;
double last_progress = 0.0;
int report_progress = is_validation_mode(mode) || is_y4m_mode(mode);
const char* progress_kind = is_validation_mode(mode)
? "mbt_progress"
: "mbt_render";
if (is_validation_mode(mode)) {
const char* clip_chroma = chroma_tag(vi);
log_checkpoint(diagnostic_log, "render: clip_info");
printf(
"clip_info,width=%d,height=%d,chroma=%s,bit_depth=%d,frames=%d,fps_num=%u,fps_den=%u,has_audio=%d,audio_rate=%d,audio_channels=%d,audio_samples=%lld\n",
vi->width,
vi->height,
clip_chroma ? clip_chroma : "unknown",
video_bit_depth(vi),
vi->num_frames,
vi->fps_numerator,
vi->fps_denominator,
avs_has_audio(vi) ? 1 : 0,
vi->audio_samples_per_second,
vi->nchannels,
(long long)vi->num_audio_samples
);
fflush(stdout);
if (validation_csv_path) {
log_checkpoint(diagnostic_log, "render: open validation csv");
validation_csv = fopen(validation_csv_path, "wb");
if (!validation_csv) {
fprintf(stderr, "failed to open validation CSV for writing: %s\n", validation_csv_path);
return 11;
}
fputs("output_frame,source_id,source_frame,drop_frame,matrix\n", validation_csv);
fflush(validation_csv);
}
}
if (report_progress) {
progress_times = (double*)calloc((size_t)vi->num_frames + 1, sizeof(double));
progress_start = now_seconds();
last_progress = progress_start;
if (progress_times) {
progress_times[0] = progress_start;
}
write_progress(progress_kind, 0, vi->num_frames, 0.0, 0.0);
}
if (mode == MODE_Y4M || mode == MODE_Y4M_SKIP_DROP) {
chroma = chroma_tag(vi);
if (!chroma) {
fprintf(stderr, "unsupported Avisynth pixel format for Y4M output: %d\n", vi->pixel_type);
free(progress_times);
return 4;
}
fprintf(
stdout,
"YUV4MPEG2 W%d H%d F%u:%u Ip A0:0 %s\n",
vi->width,
vi->height,
y4m_fps_num,
y4m_fps_den,
chroma
);
fflush(stdout);
}
for (int n = 0; n < vi->num_frames; n++) {
if (is_validation_mode(mode) && (n == 0 || n == vi->num_frames - 1 || n % 1000 == 0)) {
log_checkpoint_int(diagnostic_log, "render: frame ", n);
}
AVS_VideoFrame* frame = avs_get_frame(clip, n);
if (!frame) {
const char* err = avs_clip_get_error(clip);
fprintf(stderr, "failed to get frame %d%s%s\n", n, err ? ": " : "", err ? err : "");
return 5;
}
int skip_output = mode == MODE_Y4M_SKIP_DROP && frame_is_marked_drop(env, frame);
if (!skip_output && is_y4m_mode(mode)) {
fputs("FRAME\n", stdout);
write_plane(frame, AVS_PLANAR_Y);
write_plane(frame, AVS_PLANAR_U);
write_plane(frame, AVS_PLANAR_V);
}
if (is_validation_mode(mode) && validation_csv) {
int csv_status = write_validation_row(validation_csv, env, frame, n);
if (csv_status != 0) {
fclose(validation_csv);
free(progress_times);
avs_release_video_frame(frame);
return csv_status;
}
}
avs_release_video_frame(frame);
if (report_progress) {
int processed = n + 1;
double current_time = now_seconds();
if (progress_times) {
progress_times[processed] = current_time;
}
if (processed == vi->num_frames || current_time - last_progress >= 0.5) {
int window = processed / 2;
int window_start = processed - window;
double window_elapsed = 0.0;
double eta = 0.0;
if (window > 0 && progress_times) {
window_elapsed = current_time - progress_times[window_start];
eta = window_elapsed * (double)(vi->num_frames - processed) / (double)window;
} else if (processed > 0) {
window_elapsed = current_time - progress_start;
eta = window_elapsed * (double)(vi->num_frames - processed) / (double)processed;
}
write_progress(
progress_kind,
processed,
vi->num_frames,
current_time - progress_start,
eta
);
last_progress = current_time;
}
}
}
if (is_validation_mode(mode)) {
if (validation_csv) {
log_checkpoint(diagnostic_log, "render: close validation csv");
fclose(validation_csv);
}
log_checkpoint(diagnostic_log, "render: complete");
printf("rendered=%d\n", vi->num_frames);
fflush(stdout);
}
free(progress_times);
return 0;
}
int main(int argc, char** argv) {
enum RunnerMode mode;
const char* script_path;
const char* validation_csv_path = 0;
FILE* diagnostic_log = 0;
unsigned int y4m_fps_num = 0;
unsigned int y4m_fps_den = 0;
int64_t expected_source_id = 0;
if (argc != 3 && argc != 4 && argc != 5) {
usage();
return 2;
}
if (strcmp(argv[1], "--validate") == 0) {
if (argc != 3 && argc != 4) {
usage();
return 2;
}
mode = MODE_VALIDATE;
if (argc == 4) {
validation_csv_path = argv[3];
}
} else if (strcmp(argv[1], "--validate-real") == 0) {
if (argc != 3 && argc != 4) {
usage();
return 2;
}
mode = MODE_VALIDATE_REAL;
if (argc == 4) {
validation_csv_path = argv[3];
}
} else if (strcmp(argv[1], "--check-source") == 0) {
if (argc != 4) {
usage();
return 2;
}
mode = MODE_CHECK_SOURCE;
expected_source_id = (int64_t)strtoll(argv[2], 0, 10);
} else if (strcmp(argv[1], "--y4m") == 0) {
if (argc != 3) {
usage();
return 2;
}
mode = MODE_Y4M;
} else if (strcmp(argv[1], "--y4m-skip-drop") == 0) {
if (argc != 5) {
usage();
return 2;
}
mode = MODE_Y4M_SKIP_DROP;
y4m_fps_num = (unsigned int)strtoul(argv[2], 0, 10);
y4m_fps_den = (unsigned int)strtoul(argv[3], 0, 10);
if (y4m_fps_num == 0 || y4m_fps_den == 0) {
fprintf(stderr, "Y4M fps numerator and denominator must be positive\n");
return 2;
}
} else if (strcmp(argv[1], "--wav") == 0) {
if (argc != 3) {
usage();
return 2;
}
mode = MODE_WAV;
} else {
usage();
return 2;
}
if (!configure_binary_stdout(mode)) {
return 2;
}
script_path = is_validation_mode(mode) ? argv[2] : argv[argc - 1];
diagnostic_log = open_validation_log(validation_csv_path);
log_checkpoint(diagnostic_log, "start");
log_runner_arch(diagnostic_log);
log_checkpoint(diagnostic_log, script_path);
#ifdef _WIN32
log_checkpoint(diagnostic_log, "load: AviSynth.dll");
avs_library = avs_load_library();
if (!avs_library) {
log_checkpoint(diagnostic_log, "failed: AviSynth.dll");
fprintf(stderr, "failed to load AviSynth.dll. Install 64-bit AviSynth+ and make sure AviSynth.dll can be found.\n");
if (diagnostic_log) {
fclose(diagnostic_log);
}
return 2;
}
log_loaded_dll_path(diagnostic_log, "AviSynth.dll");
#endif
log_checkpoint_int(diagnostic_log, "create: script environment v", MBT_AVISYNTH_ENV_VERSION);
AVS_ScriptEnvironment* env = avs_create_script_environment(MBT_AVISYNTH_ENV_VERSION);
if (!env) {
log_checkpoint(diagnostic_log, "failed: script environment");
fprintf(stderr, "failed to create Avisynth environment\n");
#ifdef _WIN32
avs_free_library(avs_library);
#endif
if (diagnostic_log) {
fclose(diagnostic_log);
}
return 2;
}
if (!require_frame_property_api(diagnostic_log)) {
avs_delete_script_environment(env);
#ifdef _WIN32
avs_free_library(avs_library);
#endif
if (diagnostic_log) {
fclose(diagnostic_log);
}
return 2;
}
if (!set_validation_blank_source(env, mode)) {
avs_delete_script_environment(env);
#ifdef _WIN32
avs_free_library(avs_library);
#endif
if (diagnostic_log) {
fclose(diagnostic_log);
}
return 2;
}
log_checkpoint(diagnostic_log, "import: script");
AVS_Value import_arg = initialized_string_value(script_path);
AVS_Value result = avs_invoke(env, "Import", import_arg, 0);
if (avs_is_error(result)) {
log_checkpoint(diagnostic_log, "failed: import");
fprintf(stderr, "%s\n", avs_as_string(result));
avs_release_value(result);
avs_delete_script_environment(env);
#ifdef _WIN32
avs_free_library(avs_library);
#endif
if (diagnostic_log) {
fclose(diagnostic_log);
}
return 1;
}
if (!avs_is_clip(result)) {
log_checkpoint(diagnostic_log, "failed: script did not return clip");
fprintf(stderr, "script did not return a clip\n");
avs_release_value(result);
avs_delete_script_environment(env);
#ifdef _WIN32
avs_free_library(avs_library);
#endif
if (diagnostic_log) {
fclose(diagnostic_log);
}
return 3;
}
log_checkpoint(diagnostic_log, "take: clip");
AVS_Clip* clip = avs_take_clip(result, env);
avs_release_value(result);
log_checkpoint(diagnostic_log, "get: video info");
const AVS_VideoInfo* vi = avs_get_video_info(clip);
log_checkpoint_int(diagnostic_log, "info: frames ", vi->num_frames);
if (y4m_fps_num == 0) {
y4m_fps_num = vi->fps_numerator;
}
if (y4m_fps_den == 0) {
y4m_fps_den = vi->fps_denominator;
}
int status = mode == MODE_CHECK_SOURCE
? check_source_id(env, clip, vi, expected_source_id)
: render_clip(
env,
clip,
vi,
mode,
y4m_fps_num,
y4m_fps_den,
validation_csv_path,
diagnostic_log
);
#ifdef _WIN32
/*
* Some Windows AviSynth/plugin combinations can crash during final
* teardown after all frames have rendered. Let the OS reclaim process
* resources so validation/encoding results are not lost to cleanup.
*/
fflush(stdout);
fflush(stderr);
if (diagnostic_log) {
log_checkpoint_int(diagnostic_log, "exit: ", status);
fclose(diagnostic_log);
}
ExitProcess((UINT)status);
#else
avs_release_clip(clip);
avs_delete_script_environment(env);
#endif
if (diagnostic_log) {
log_checkpoint_int(diagnostic_log, "exit: ", status);
fclose(diagnostic_log);
}
return status;
}
Reference in New Issue View Git Blame Copy Permalink