Untitled

mail@pastecode.io avatar
unknown
plain_text
2 years ago
46 kB
2
Indexable
Never
module.exports = /*syntax:js*/ `// Command line renderer for After Effects. (nexrender-patch-v1.0.2)

// This function constructs an AECommandLineRenderer object.
// One and only one of these will be created to perform rendering tasks
// at the end of this file.
//
// The constructor has 3 sections:
// [1] define all the variable-type attributes used by this class;
// [2] define all the functions used by this class;
// [3] assign all the functions to be method-type attributes.
//
function AECommandLineRenderer() {
    // [1] define all the variable-type attributes used by this class
    //
    // Input before parsing
    //
    this.inArgs = null;
    //
    // Input after parsing
    //
    this.in_project_path = null;
    this.in_comp_name = null;
    this.in_rq_index = null;
    this.in_RStemplate = null;
    this.in_OMtemplate = null;
    this.in_output_path = null;
    this.in_logfile_path = null;
    this.in_start_frame = null;
    this.in_end_frame = null;
    this.in_increment = null;
    this.in_image_cache_percent = null;
    this.in_max_mem_percent = null;
    this.in_verbose_flag = null;
    this.in_close_flag = null;
    this.in_sound_flag = null;
    this.in_port_address = null;
    this.in_stop_on_missing_frame = true;
    this.in_script_path = null;
    //
    // Exit codes:
    //
    this.EXIT_OK = 0;
    this.EXIT_FAILURE_CODE_FROM_APP = 1;
    this.EXIT_SHOW_USAGE = 2;
    this.EXIT_SYNTAX_ERROR = 3;
    this.EXIT_SYNTAX_ERROR_USER_LOG = 4;
    this.EXIT_OTHER_SCRIPTING_ERROR = 5;
    this.EXIT_OTHER_SCRIPTING_ERROR_USER_LOG = 6;
    this.EXIT_AERENDER_RUNTIME = 7;
    this.EXIT_AERENDER_RUNTIME_USER_LOG = 8;
    this.EXIT_AE_RUNTIME = 9;
    this.EXIT_AE_RUNTIME_USER_LOG = 10;
    this.EXIT_CANNOT_OPEN_SOCKET = 11;
    this.EXIT_CODE_NO_LONGER_IN_USE = 12;
    //
    // Exit code message prefixes:
    //
    this.EXIT_MSG_PREFIX = new Array(
        "", // EXIT_OK
        "ERROR: ", // EXIT_FAILURE_CODE_FROM_APP
        "USAGE: ", // EXIT_SHOW_USAGE
        "SYNTAX ERROR: ", // EXIT_SYNTAX_ERROR
        "SYNTAX ERROR: ", // EXIT_SYNTAX_ERROR_USER_LOG
        "ERROR: ", // EXIT_OTHER_SCRIPTING_ERROR
        "ERROR: ", // EXIT_OTHER_SCRIPTING_ERROR_USER_LOG
        "ERROR: ", // EXIT_AERENDER_ERROR
        "ERROR: ", // EXIT_AERENDER_ERROR_USER_LOG
        "ERROR: ", // EXIT_AE_RUNTIME
        "ERROR: ", // EXIT_AE_RUNTIME_USER_LOG
        "ERROR: ", // EXIT_CANNOT_OPEN_SOCKET
        "", // EXIT_CODE_NO_LONGER_IN_USE
    );
    //
    // Messages:
    //
    this.MSG_NONE = "";
    this.MSG_NOT_HANDLED_HERE = "reported by another script or AE runtime.";
    this.MSG_SHOW_USAGE = "";
    this.MSG_TRIED_TO_PARSE_UNDEFINED = "aerender tried to parse an undefined argument.";
    this.MSG_UNDEFINED_VALUE_FOR_FLAG = "no value given for flag: ";
    this.MSG_BAD_FLAG = "Illegal argument flag: ";
    this.MSG_NO_PROJECT = "No project provided and no project open.";
    this.MSG_BAD_VERBOSE_FLAG = "Bad value for -verbose.";
    this.MSG_BAD_CLOSE_FLAG = "Bad value for -close.";
    this.MSG_BAD_SOUND_FLAG = "Bad value for -sound.";
    this.MSG_BAD_INCREMENT = "Bad value for -increment. Must be between 1 and 100, inclusive.";
    this.MSG_COMP_NOT_FOUND = "No comp was found with the given name.";
    this.MSG_RQINDEX_NOT_FOUND = "No render queue item was found with the given index.";
    this.MSG_AE_RUNTIME = "Runtime error in After Effects.";
    this.MSG_ADDING_TO_RQ = "PROGRESS: Adding specified comp to Render Queue";
    this.MSG_NEEDS_OUTPUT = "Specified render queue item needs output file but none provided.";
    this.MSG_RS_TEMPLATE_NOT_FOUND = "No render settings template was found with the given name.";
    this.MSG_OM_TEMPLATE_NOT_FOUND = "No output module template was found with the given name.";
    this.MSG_CAN_NOT_OPEN_SOCKET = "Can not open socket.";
    this.MSG_NO_COMP_YES_TEMPLATE = "WARNING: -RStemplate argument ignored since no -comp or -rqindex provided.";
    this.MSG_NO_COMP_YES_OMTEMPLATE = "WARNING: -OMtemplate argument ignored since no -comp  or -rqindex provided.";
    this.MSG_NO_COMP_YES_OUTPUT = "WARNING: -output argument ignored since no -comp  or -rqindex provided.";
    this.MSG_NO_COMP_YES_START_OR_END = "WARNING: -s and/or -e arguments ignored since no -comp  or -rqindex provided.";
    this.MSG_NO_COMP_YES_INCREMENT = "WARNING: -i argument ignored since no -comp  or -rqindex provided.";
    this.MSG_SKIPPING_WILL_CONTINUE = "INFO: Skipping render queue item with correct comp name but marked to continue from a partly complete render.";
    this.MSG_RENDER_ABORTED = "INFO: Render aborted.";
    this.MSG_SCRIPT_CAN_NOT_EXEC = "aerender ERROR: Error executing script: ";
    this.MSG_SCRIPT_CAN_NOT_OPEN = "aerender ERROR: Can not open script file. Make sure path is correct: ";

    // These don't get the prefix printed since they are not exit messages
    this.MSG_LOG_DIR_NO_EXISTS = "aerender ERROR: Directory specified for log file does not exist: ";
    this.MSG_LOG_DIR_NOT_A_DIR = "aerender ERROR: Directory specified for log file is a file, not a directory: ";
    this.MSG_LOG_CAN_NOT_OPEN = "aerender ERROR: Can not open log file. Try checking write protection of directory: ";
    //
    // Variables for rendering
    //
    this.log_file = null;
    this.has_user_log_file = false;
    this.is_verbose_mode = true;
    this.saved_sound_setting = null;
    this.my_sound_setting = null;

    // [2] define all the functions used by this class
    //
    // Report an error. This writes errors to the log file, if present.
    // This is called from the context of the application, so we
    // need to precede variable names with gAECommandLineRenderer
    // 
    function checkParentDied() {
        var result = false;
        if (gAECommandLineRenderer.log_file instanceof Socket) {
            if (!gAECommandLineRenderer.log_file.connected) {
                app.project.renderQueue.stopRendering();
                result = true;
            }
        }
        return result;
    }

    function my_onError(error_string, severity_string) {
        // This method is called with a variety of types of messages.
        // The severity_string tells us what kind.
        // Choices are:
        // NAKED, INFO, WARNING, PROBLEM, FATAL, PROGRESS, and DEBUG

        // Two of these, PROBLEM and FATAL, are errors that should cause us to change
        // the exit code:
        checkParentDied();
        if (severity_string == "PROBLEM" || severity_string == "FATAL") {
            // These two errors cause us to change the exit code.
            // We don't write an error or throw here, because we got here as part of a thrown 
            // error already, and the message will be printed as part of the catch.
            gAECommandLineRenderer.SetExitCode(gAECommandLineRenderer.EXIT_AE_RUNTIME);
        } else {
            // PROBLEM and FATAL will throw exceptions, and so will be logged to the file
            // when we catch the exception.
            // All other errors (NAKED, INFO, WARNING, PROGRESS, and DEBUG) will not 
            // throw exceptions.  So we log them to the file right here:
            if (gAECommandLineRenderer.is_verbose_mode) {
                if (gAECommandLineRenderer.log_file != null) {
                    if (severity_string == "NAKED") {
                        // everybody is confused by this category.  Just use INFO instead.
                        gAECommandLineRenderer.log_file.writeln("INFO:" + error_string);
                    } else {
                        gAECommandLineRenderer.log_file.writeln(severity_string + ":" + error_string);
                    }
                }
            }
        }
        // call the error handler that was in place before we started rendering.
        if (gAECommandLineRenderer.oldErrorHandler) {
            gAECommandLineRenderer.oldErrorHandler(error_string, severity_string);
        }
    }

    // Report an error and throw an exception.
    // Causes the script to exit.
    function my_SetExitCodeAndThrowException(code, message) {
        this.SetExitCode(code);
        throw (this.EXIT_MSG_PREFIX[code] + message);
    }

    // Report an error. This establishes exitCodes for reporting errors from AfterFX.
    function my_SetExitCode(code) {
        // Some codes are set differently depending on whether we have a custom user 
        // log file.  Check for these and use the alternate if appropriate.
        var real_code = code;
        if (gAECommandLineRenderer.has_user_log_file) {
            switch (real_code) {
                case gAECommandLineRenderer.EXIT_SYNTAX_ERROR:
                    real_code = gAECommandLineRenderer.EXIT_SYNTAX_ERROR_USER_LOG;
                    break;
                case gAECommandLineRenderer.EXIT_OTHER_SCRIPTING_ERROR:
                    real_code = gAECommandLineRenderer.EXIT_OTHER_SCRIPTING_ERROR_USER_LOG;
                    break;
                case gAECommandLineRenderer.EXIT_AERENDER_RUNTIME:
                    real_code = gAECommandLineRenderer.EXIT_AERENDER_RUNTIME_USER_LOG;
                    break;
                case gAECommandLineRenderer.EXIT_AE_RUNTIME:
                    real_code = gAECommandLineRenderer.EXIT_AE_RUNTIME_USER_LOG;
                    break;
            }
        }

        // Always keep the first error. So only set if the exitCode is still EXIT_OK.
        if (app.exitCode == gAECommandLineRenderer.EXIT_OK) {
            app.exitCode = real_code;
        }
    }

    // Arguments may be enclosed in quotes.  This 
    // will remove them and return the result.
    function my_StripAnyEnclosingQuotes(inString) {
        var result = inString;
        if (inString &&
            inString.charAt(0) == '"' &&
            inString.charAt(inString.length - 1) == '"') {
            result = inString.substring(1, inString.length - 1);
        }
        return result;
    }

    // Make sure the value is there, and returns it, stripping away any enclosing quotes.
    //
    function my_GetValueForFlag(arg_num, the_flag) {
        if (!this.inArgs[arg_num]) {
            this.SetExitCodeAndThrowException(this.EXIT_SYNTAX_ERROR, (this.MSG_UNDEFINED_VALUE_FOR_FLAG + the_flag));
        }
        return this.StripAnyEnclosingQuotes(this.inArgs[arg_num]);
    }

    // Parse the parameter.
    // Return the number of arguments used in parsing the parameter.
    function my_ParseParamStartingAt(arg_num) {
        if (!this.inArgs[arg_num]) {
            this.SetExitCodeAndThrowException(this.EXIT_AERENDER_RUNTIME, this.MSG_TRIED_TO_PARSE_UNDEFINED);
        }

        var num_args_parsed = 0;

        // Check for a valid flag:
        var my_flag = this.inArgs[arg_num];
        if (my_flag == "-port") {
            // -port is used by aerender to specify a port address for a socket.
            //
            // Note: this value is sought/parsed earlier, in the SetupDefaultLog method.
            // We can just ignore here.
            var dummy = this.GetValueForFlag(arg_num + 1, my_flag);
            num_args_parsed = 2;
        }
        if (my_flag == "-project") {
            this.in_project_path = this.GetValueForFlag(arg_num + 1, my_flag);
            num_args_parsed = 2;
        }
        if (my_flag == "-comp") {
            this.in_comp_name = this.GetValueForFlag(arg_num + 1, my_flag);
            num_args_parsed = 2;
        }
        if (my_flag == "-rqindex") {
            this.in_rq_index = parseInt(this.GetValueForFlag(arg_num + 1, my_flag));
            num_args_parsed = 2;
        }
        if (my_flag == "-RStemplate") {
            this.in_RStemplate = this.GetValueForFlag(arg_num + 1, my_flag);
            num_args_parsed = 2;
        }
        if (my_flag == "-OMtemplate") {
            this.in_OMtemplate = this.GetValueForFlag(arg_num + 1, my_flag);
            num_args_parsed = 2;
        }
        if (my_flag == "-output") {
            this.in_output_path = this.GetValueForFlag(arg_num + 1, my_flag);
            num_args_parsed = 2;
        }
        if (my_flag == "-log") {
            this.in_logfile_path = this.GetValueForFlag(arg_num + 1, my_flag);
            num_args_parsed = 2;
        }
        if (my_flag == "-s") {
            this.in_start_frame = this.GetValueForFlag(arg_num + 1, my_flag);
            num_args_parsed = 2;
        }
        if (my_flag == "-e") {
            this.in_end_frame = this.GetValueForFlag(arg_num + 1, my_flag);
            num_args_parsed = 2;
        }
        if (my_flag == "-i") {
            this.in_increment = this.GetValueForFlag(arg_num + 1, my_flag);
            num_args_parsed = 2;
        }
        if (my_flag == "-mem_usage") {
            this.in_image_cache_percent = this.GetValueForFlag(arg_num + 1, my_flag);
            this.in_max_mem_percent = this.GetValueForFlag(arg_num + 2, my_flag);
            num_args_parsed = 3;
        }
        if (my_flag == "-v") {
            this.in_verbose_flag = this.GetValueForFlag(arg_num + 1, my_flag);
            num_args_parsed = 2;
        }

        if (my_flag == "-r") {
            this.in_script_path = this.GetValueForFlag(arg_num + 1, my_flag);
            num_args_parsed = 2;
        }

        if (my_flag == "-close") {
            this.in_close_flag = this.GetValueForFlag(arg_num + 1, my_flag);
            num_args_parsed = 2;
        }
        if (my_flag == "-sound") {
            this.in_sound_flag = this.GetValueForFlag(arg_num + 1, my_flag);
            num_args_parsed = 2;
        }
        if (my_flag == "-doSavePrefsOnQuit") {
            // The effect of this flag will be taken into account when we
            // exit the app. See comment in the "finally" block.
            // All we do here is increment the num_args_parsed count.
            num_args_parsed = 1;
        }
        if (my_flag == "-continueOnMissingFootage") {
            this.in_stop_on_missing_frame = false;
            num_args_parsed = 1;
        }

        if (num_args_parsed == 0) {
            this.SetExitCodeAndThrowException(this.EXIT_SYNTAX_ERROR, (this.MSG_BAD_FLAG + my_flag));
        }

        return num_args_parsed;
    }

    // This parses the inArgs array.  Assumes
    // the array has already been filled.
    function my_ParseInArgs() {
        // First, undefine all the inputs we're potentially looking for
        this.in_project_path = null;
        this.in_comp_name = null;
        this.in_rq_index = null;
        this.in_RStemplate = null;
        this.in_OMtemplate = null;
        this.in_output_path = null;
        this.in_logfile_path = null;
        this.in_start_frame = null;
        this.in_end_frame = null;
        this.in_increment = null;
        this.in_image_cache_percent = null;
        this.in_max_mem_percent = null;
        this.in_verbose_flag = null;
        this.in_close_flag = null;
        this.in_sound_flag = null;
        this.in_script_path = null;

        // Special case: check if any argument is "-help"
        for (var i = 0; i < this.inArgs.length; i++) {
            if (this.inArgs[i] == "-help") {
                this.SetExitCodeAndThrowException(this.EXIT_SHOW_USAGE, this.MSG_SHOW_USAGE);
            }
        }

        var arg_num = 0;
        while (arg_num < this.inArgs.length) {
            // ParseParamStartingAt returns the number of arguments used up parsing the param.
            arg_num += this.ParseParamStartingAt(arg_num);
        }
    }

    // This arg is treated differently than others because it's extra important
    // that we exit properly in the face of anything that might go wrong even
    // during initialization. So we don't parse the standard way, we check this
    // before exit...
    function my_IsSavePrefsArgGiven(arglist) {
        return this.IsInArray("-doSavePrefsOnQuit", arglist);
    }

    // Returns true if the item equals an item in the array, false if otherwise.
    function my_IsInArray(needle, haystack) {
        result = false;
        for (var i = 0; i < haystack.length; i++) {
            if (needle == haystack[i]) {
                result = true;
                break;
            }
        }
        return result;
    }

    function my_SetupDefaultLog(arg_list) {
        this.has_user_log_file = false;

        // Clean up after a potentially bad exit last time:
        if (this.log_file && this.log_file != null) {
            this.log_file.close();
            this.log_file = null;
        }

        // Open the socket.
        // It is used:
        // [a] to log errors if there is no user-specified log file (specified with a "-log" arg)
        // [b] to log errors encountered while opening any user-specified log file.

        // See if a -port argument was passed:
        this.log_file = null;
        for (var i = 0; i < arg_list.length; i++) {
            if (arg_list[i] == "-port") {
                if (arg_list.length > i + 1) {
                    // The argument value is the port address
                    this.in_port_address = arg_list[i + 1];
                    // Yes, the log_file variable is being used to hold a socket.
                    this.log_file = new Socket();

                    // cprosser [26961]
                    // could possibly use ISO-8856-1 for non japanese systems,
                    // but I am going for small changes now.
                    // and again cprosser 8/8/2005 [33884]
                    // CP_OEMCP means use the OEM code page, the default
                    // for the console.
                    // alas, it doens't understand that so we are hardcoding
                    // codepage 850. Not the default on windows for US systems
                    // but should be the default on european systems and will
                    // get the high ascii correct.
                    // Search for chcp at microsoft for info on changing
                    // the console.
                    // on the mac, leave as binary
                    var encoding_string = "binary";

                    if (system.osName.search("Windows") != -1) {
                        encoding_string = "WINDOWS-850";
                        //encoding_string = "CP_OEMCP";
                    }

                    if (app.language == Language.JAPANESE) {
                        encoding_string = "Shift-JIS";
                    }
                    if (app.isoLanguage == "ko_KR") {
                        encoding_string = "EUC-KR";
                    }
                    if (!this.log_file.open(this.in_port_address, encoding_string)) {
                        this.log_file = null;
                        this.SetExitCodeAndThrowException(this.EXIT_CANNOT_OPEN_SOCKET,
                            this.MSG_CAN_NOT_OPEN_SOCKET);
                    }
                }
            }
        }
        this.is_verbose_mode = true;
    }

    function my_CleanupDefaultLog() {
        // Close the log file
        if (this.log_file != null) {
            this.log_file.close();
            this.log_file = null;
        }
    }

    // This is the external entry point.
    // Bat files or executables may call this method.
    //
    // This function assumes that it has been passed all the arguments.
    // It parses the arguments and then renders.
    function my_Render() {
        app.beginSuppressDialogs();

        if (checkParentDied()) {
            return;
        }

        try {
            this.SetupDefaultLog(my_Render.arguments);

            // start by assuming successful execution, exit code 0.
            app.exitCode = 0;

            // Check number of arguments
            if (!my_Render.arguments || my_Render.arguments.length == 0) {
                this.SetExitCodeAndThrowException(this.EXIT_SHOW_USAGE, this.MSG_SHOW_USAGE);
            }

            var numArgs = my_Render.arguments.length;
            // Allocate the array of arguments:
            this.inArgs = new Array(numArgs);

            // Load the input arguments into the inArgs array.
            for (var i = 0; i < numArgs; i++) {
                this.inArgs[i] = my_Render.arguments[i];
            }

            // Parse the arguments, and render
            this.ParseInArgs();

            if (checkParentDied()) {
                return;
            }

            this.ReallyRender();
        } catch (error) {
            // Add any errors to the log file.
            if (this.log_file != null) {
                this.log_file.writeln("aerender " + error.toString());
            }
            this.SetExitCode(this.EXIT_AE_RUNTIME);
        } finally {
            // This arg is treated differently than others because it's extra important
            // that we exit properly in the face of anything that might go wrong even
            // during initialization. So we don't parse the standard way, we check this
            // before exit...
            app.setSavePreferencesOnQuit(this.IsSavePrefsArgGiven(my_Render.arguments));

            this.CleanupDefaultLog();
            app.endSuppressDialogs(false);
            app.reportErrorOnMissingFrame = false;
        }
    }

    function my_ReallyRender() {
        this.saved_sound_setting = null;
        app.reportErrorOnMissingFrame = this.in_stop_on_missing_frame;

        try {
            // While rendering we'll report errors to the log file.
            if (app.onError == this.onError) {
                // If the previous error handler is just this one, don't store it. 
                // That can happen in extreme cases where this script does not get a
                // chance to clean up and put back the oldErrorHandler when it's done.
                this.oldErrorHandler = null;
            } else {
                this.oldErrorHandler = app.onError;
            }
            app.onError = this.onError;
            // Open the user log file, if specified, and use it instead of the socket.
            if (this.in_logfile_path) {
                // Keep the socket open; errors we encounter while opening the
                // user log file will be logged to the socket.
                var user_log_file = new File(this.in_logfile_path);
                var parent_dir = user_log_file.parent;
                if (!parent_dir.exists) {
                    if (this.log_file) {
                        this.log_file.writeln(this.MSG_LOG_DIR_NO_EXISTS + this.in_logfile_path);
                    }
                    this.SetExitCodeAndThrowException(this.EXIT_AE_RUNTIME, this.MSG_AE_RUNTIME);
                }
                var test_folder = Folder(parent_dir);
                if (!(test_folder instanceof Folder)) {
                    if (this.log_file) {
                        this.log_file.writeln(this.MSG_LOG_DIR_NOT_A_DIR + this.in_logfile_path);
                    }
                    this.SetExitCodeAndThrowException(this.EXIT_AE_RUNTIME, this.MSG_AE_RUNTIME);
                }
                if (!user_log_file.open("w", 'TEXT', 'ttxt')) {
                    if (this.log_file) {
                        this.log_file.writeln(this.MSG_LOG_CAN_NOT_OPEN + this.in_logfile_path);
                    }
                    this.SetExitCodeAndThrowException(this.EXIT_AE_RUNTIME, this.MSG_AE_RUNTIME);
                }

                // no errors were encountered opening the file.
                // Close the socket and use this one instead.
                if (this.log_file != null) {
                    this.log_file.close();
                }
                this.log_file = user_log_file; // which is still open
                this.has_user_log_file = true;
            }

            if (this.in_verbose_flag) {
                if (this.in_verbose_flag == "ERRORS") {
                    this.is_verbose_mode = false;
                } else if (this.in_verbose_flag == "ERRORS_AND_PROGRESS") {
                    this.is_verbose_mode = true;
                } else {
                    this.SetExitCodeAndThrowException(this.EXIT_SYNTAX_ERROR, this.MSG_BAD_VERBOSE_FLAG);
                }
            }
            if (this.in_close_flag) {
                if (this.in_close_flag != "DO_NOT_CLOSE" &&
                    this.in_close_flag != "DO_NOT_SAVE_CHANGES" &&
                    this.in_close_flag != "SAVE_CHANGES") {
                    this.SetExitCodeAndThrowException(this.EXIT_SYNTAX_ERROR, this.MSG_BAD_CLOSE_FLAG);
                }
            }
            if (this.in_sound_flag) {
                if (this.in_sound_flag != "ON" &&
                    this.in_sound_flag != "OFF" &&
                    this.in_sound_flag != "on" &&
                    this.in_sound_flag != "off") {
                    this.SetExitCodeAndThrowException(this.EXIT_SYNTAX_ERROR, this.MSG_BAD_SOUND_FLAG);
                }
            }

            // Set the memory usage, if specified as an argument.
            if (this.in_image_cache_percent && this.in_max_mem_percent) {
                app.setMemoryUsageLimits(this.in_image_cache_percent, this.in_max_mem_percent);
            }

            // If the user provided a project, close the current project and open the project specified.
            // Else, leave the current project open.
            if (this.in_project_path) {
                // Close the current project
                if (app.project != null) {
                    app.project.close(CloseOptions.DO_NOT_SAVE_CHANGES);
                }

                // Open the specified project:
                var proj_file = new File(this.in_project_path);
                app.openFast(proj_file);
            }
            if (!app.project) {
                this.SetExitCodeAndThrowException(this.EXIT_AERENDER_RUNTIME, this.MSG_NO_PROJECT);
            }

            if (this.in_script_path) {
                this.log_file.writeln("Running Script: " + this.in_script_path);
                var scriptFile = new File(this.in_script_path);

                scriptFile.encoding = "UTF-8";
                if (!scriptFile.open("r")) {
                    if (this.log_file) {
                        this.log_file.writeln(this.MSG_SCRIPT_CAN_NOT_OPEN + this.in_script_path);
                    }
                    this.SetExitCodeAndThrowException(this.EXIT_AE_RUNTIME, this.MSG_AE_RUNTIME);
                }

                try {
                    // Use evalFile instead of eval to make the script path context
                    // the same as the scriptFile
                    //
                    // For example using eval(), the $.fileName would be the commandLineRenderer's
                    // path and we want the executing scriptFile's path for our fallback
                    // Using evalFile evaluates the file in another context


                    // Update v1.0.2: returning back to eval
                    // since there are issues with encoding caused by $.evalFile
                    eval(scriptFile.read());
                } catch (e) {
                    if (this.log_file) {
                        this.log_file.writeln(this.MSG_SCRIPT_CAN_NOT_EXEC + this.in_script_path);
                        this.log_file.writeln(e);
                    }
                    this.SetExitCodeAndThrowException(this.EXIT_AE_RUNTIME, this.MSG_AE_RUNTIME);
                }

                scriptFile.close();
            }

            // Get the RenderQueueItem for the specified comp, if specified.
            var rqi = null;
            if (this.in_comp_name) {
                rqi = this.GetFirstQueuedRQItemWithName(this.in_comp_name);
            } else if (this.in_rq_index != null) {
                this.log_file.writeln("rqindex " + this.in_rq_index + "num " + app.project.renderQueue.numItems);
                if (this.in_rq_index >= 1 && this.in_rq_index <= app.project.renderQueue.numItems) {
                    rqi = app.project.renderQueue.item(this.in_rq_index);
                } else {
                    this.SetExitCodeAndThrowException(this.EXIT_AERENDER_RUNTIME, this.MSG_RQINDEX_NOT_FOUND);
                }
            }
            if (this.in_comp_name && !rqi) {
                // Try to find the comp in the project and add to the render queue:
                rqi = this.AddCompToRenderQueue(this.in_comp_name);
                if (rqi) {
                    if (this.log_file != null) {
                        this.log_file.writeln(this.MSG_ADDING_TO_RQ);
                    }
                } else {
                    this.SetExitCodeAndThrowException(this.EXIT_AERENDER_RUNTIME, this.MSG_COMP_NOT_FOUND);
                }
            }

            // Apply the templates, if provided
            if (this.in_RStemplate) {
                if (!rqi) {
                    if (this.log_file != null) {
                        this.log_file.writeln(this.MSG_NO_COMP_YES_TEMPLATE);
                    }
                } else {
                    if (!this.IsInArray(this.in_RStemplate, rqi.templates)) {
                        this.SetExitCodeAndThrowException(this.EXIT_AERENDER_RUNTIME, this.MSG_RS_TEMPLATE_NOT_FOUND);
                    }
                    rqi.applyTemplate(this.in_RStemplate);
                }
            }
            if (this.in_OMtemplate) {
                if (!rqi) {
                    if (this.log_file != null) {
                        this.log_file.writeln(this.MSG_NO_COMP_YES_OMTEMPLATE);
                    }
                } else {
                    if (!this.IsInArray(this.in_OMtemplate, rqi.outputModule(1).templates)) {
                        this.SetExitCodeAndThrowException(this.EXIT_AERENDER_RUNTIME, this.MSG_OM_TEMPLATE_NOT_FOUND);
                    }
                    rqi.outputModule(1).applyTemplate(this.in_OMtemplate);
                }
            }

            // If a comp was specified, make it the only one to render.
            // If none was provided, leave everything alone so render queue renders as is.
            if (rqi) {
                this.EstablishAsOnlyQueuedItem(rqi);
            }

            if (rqi) {
                // If the user provided a path, set the output path on rqi's OutputModule
                if (rqi.status == RQItemStatus.NEEDS_OUTPUT && !this.in_output_path) {
                    this.SetExitCodeAndThrowException(this.EXIT_AERENDER_RUNTIME, this.MSG_NEEDS_OUTPUT);
                }
                if (this.in_output_path) {
                    var om = rqi.outputModule(1);
                    om.file = new File(this.in_output_path);
                }
            } else {
                if (this.in_output_path) {
                    if (this.log_file != null) {
                        this.log_file.writeln(this.MSG_NO_COMP_YES_OUTPUT);
                    }
                }
            }

            // Set the start and end frames.
            if (this.in_start_frame || this.in_end_frame) {
                if (!rqi) {
                    if (this.log_file != null) {
                        this.log_file.writeln(this.MSG_NO_COMP_YES_START_OR_END);
                    }
                } else {
                    // Render times are stored as timeSpanStart and timeSpanDuration.
                    // Setting only the timeSpanStart will not change the timeSpanDuration and 
                    // so will move the end time, but we want the end time unchanged if 
                    // it was not specified.
                    // So we must calculate both start_time and end_time, 
                    // then set both timeSpanStart and timeSpanDuration.
                    // Note: frameDuration is stored in the comp.
                    var start_time = rqi.timeSpanStart;
                    var end_time = rqi.timeSpanStart + rqi.timeSpanDuration;
                    if (this.in_start_frame) {
                        start_time = -rqi.comp.displayStartTime + ((parseInt(this.in_start_frame, 10) - app.project.displayStartFrame) * rqi.comp.frameDuration);
                    }
                    if (this.in_end_frame) {
                        // The way AE works, final frame is not included.
                        // But aerender wants final frame included.
                        // So, just add 1 to end frame right here before setting
                        // duration for AE:
                        // Note: must call parseInt() here, or the 1 will be added as if it
                        // were a string. For example, 35 would become 351, not 36. Hoo boy!
                        var end_frame_plus_one = parseInt(this.in_end_frame, 10) + 1.0 - app.project.displayStartFrame;
                        end_time = -rqi.comp.displayStartTime + (end_frame_plus_one * rqi.comp.frameDuration);
                    }
                    rqi.timeSpanStart = start_time;
                    rqi.timeSpanDuration = end_time - start_time;
                }
            }

            // Set the skipFrames (based on increment).
            if (this.in_increment) {
                if (this.in_increment < 1 || this.in_increment > 100) {
                    this.SetExitCodeAndThrowException(this.EXIT_SYNTAX_ERROR, this.MSG_BAD_INCREMENT);
                }
                if (!rqi) {
                    if (this.log_file != null) {
                        this.log_file.writeln(this.MSG_NO_COMP_YES_INCREMENT);
                    }
                } else {
                    // Set the skipFrames based on the increment.
                    //
                    // Increment as defined here is one greater then the
                    // the render queue item's skipFrames.
                    // skipFrames 0 is the same as increment of 1.
                    // 
                    rqi.skipFrames = (this.in_increment - 1);
                }
            }

            // If we are in verbose mode, set the log type to ERRORS_AND_PER_FRAME_INFO 
            // for all RQ items we are about to render.
            if (this.is_verbose_mode) {
                this.SetLogPerFrameInfoInRQ();
            }

            this.SaveAndSetRenderSoundSetting();

            // Render!
            // true skips the recursive check for footage files
            // and will only check the one's used

            if (checkParentDied()) {
                return;
            }
            //app.project.renderQueue.render(true);
            alert('I reached line number 784.');


            // Scripting support for Queue in AME.
            // Requires Adobe Media Encoder 11.0.
            {
            
                var curItem, myComp;
            
                for(var i = 1; i < app.project.items.length; i++){
                    alert('A');
                    curItem = app.project.items[i];
            
                    if(curItem instanceof CompItem){
                        alert('B');
                        if(curItem.name == "TEST_COMP_PREVIEW_FRAME"){  //Will grab only the first name match
                            alert('C');
                            var qItem = app.project.renderQueue.items.add(curItem);
                            qItem.outputModules[1].file = new File("C:/path/output.mp4");
            
                            break;
            
                        }
            
                    }
            
                }
            
                alert('D');
                if (app.project.renderQueue.canQueueInAME == true) { // Send queued items to AME, but do not start rendering.
                    app.project.renderQueue.queueInAME(true);
                    alert('E');
                } else {
                    alert("There are no queued item in the Render Queue.");
                }
            }


        } catch (error) {
            // Add any errors to the log file.
            if (this.log_file != null) {
                this.log_file.writeln("aerender " + error.toString());
            }

            // It's possible that errors were encountered while trying to render.
            // Stop the render if in progress for a clean exit from the application.
            if (app.project && app.project.renderQueue && app.project.renderQueue.rendering) {
                // This will prevent the message "render stopped by user" from showing up...
                app.onError = null;
                app.project.renderQueue.stopRendering();
                // This will print a better message:
                if (this.log_file != null) {
                    this.log_file.writeln(this.MSG_RENDER_ABORTED);
                }
                app.onError = this.onError;
            }

            this.SetExitCode(this.EXIT_AE_RUNTIME);
        } finally {
            // Close the project.
            this.CloseProjectIfDesired();

            // Put back the old error handler
            app.onError = this.oldErrorHandler;

            // Restore the setting for hearing the render-done sound.
            this.RestoreRenderSoundSetting()
        }
    }

    // Returns the first item on the render queue that:
    // [a] contains a comp named comp_name
    // [b] has a render status of QUEUED or UNQUEUED or NEEDS_OUTPUT
    //     Note that if the status is NEEDS_OUTPUT, one better be provided or
    //     an error will result.
    //
    // If not found, returns null.
    //
    function my_GetFirstQueuedRQItemWithName(comp_name) {
        var result = null;

        var rq = app.project.renderQueue;
        if (rq && rq.numItems > 0) {
            var cur_item;
            // the items are indexed from 1 to numItems.
            for (var i = 1; i <= rq.numItems; i++) {
                cur_item = rq.item(i);
                if (cur_item.comp.name == comp_name &&
                    cur_item.status == RQItemStatus.WILL_CONTINUE) {
                    if (this.log_file != null) {
                        this.log_file.writeln(this.MSG_SKIPPING_WILL_CONTINUE);
                    }
                }
                if (cur_item.comp.name == comp_name &&
                    (cur_item.status == RQItemStatus.QUEUED ||
                        // pmi 9/24/03 -- do not render unqueued items. Let a new
                        // one be added instead.
                        // cur_item.status == RQItemStatus.UNQUEUED ||
                        cur_item.status == RQItemStatus.NEEDS_OUTPUT)) {
                    // We found it!
                    result = cur_item;
                    break;
                }
            }
        }

        return result;
    }

    // Find a comp with the given name, and adds it to the render queue.
    // Returns the newly added render queue item
    //
    // If not found, returns null.
    //
    function my_AddCompToRenderQueue(comp_name) {
        var result = null;

        // Get the comp with the name we are after
        var cur_item;
        var desired_comp = null;
        // the items in the project are indexed from 1 to numItems
        for (var i = 1; i <= app.project.numItems; i++) {
            cur_item = app.project.item(i);
            if (cur_item instanceof CompItem && cur_item.name == comp_name) {
                desired_comp = cur_item;
                break;
            }
        }

        // Add the desired_comp to the render queue.  The add() method
        // returns the new render queue item.
        if (desired_comp) {
            result = app.project.renderQueue.items.add(desired_comp);
        }

        return result;
    }

    // Sets the render flag on all RenderQueueItems other than rqi to false,
    //
    function my_EstablishAsOnlyQueuedItem(rqi) {
        var rq = app.project.renderQueue;
        if (rq && rq.numItems > 0) {
            var cur_item;
            // the items are indexed from 1 to numItems.
            for (var i = 1; i <= rq.numItems; i++) {
                cur_item = rq.item(i);
                if (cur_item == rqi) {
                    cur_item.render = true;
                } else {
                    // You can only change the render flag when these are the current status value:
                    if (cur_item.status == RQItemStatus.QUEUED ||
                        cur_item.status == RQItemStatus.UNQUEUED ||
                        cur_item.status == RQItemStatus.NEEDS_OUTPUT ||
                        cur_item.status == RQItemStatus.WILL_CONTINUE) {
                        cur_item.render = false;
                    }
                }
            }
        }
    }

    // Sets the log type to be ERRORS_AND_PER_FRAME_INFO for all items that are going to render.
    //
    function my_SetLogPerFrameInfoInRQ() {
        var rq = app.project.renderQueue;
        if (rq && rq.numItems > 0) {
            var cur_item;
            // the items are indexed from 1 to numItems.
            for (var i = 1; i <= rq.numItems; i++) {
                cur_item = rq.item(i);
                if (cur_item.render == true) {
                    if (cur_item.status != RQItemStatus.USER_STOPPED &&
                        cur_item.status != RQItemStatus.ERR_STOPPED &&
                        cur_item.status != RQItemStatus.RENDERING &&
                        cur_item.status != RQItemStatus.DONE) {
                        cur_item.logType = LogType.ERRORS_AND_PER_FRAME_INFO;
                    }
                }
            }
        }
    }

    // Closes the project if the close flag specifies to do so
    //
    function my_CloseProjectIfDesired() {
        if (app.project) {
            // Close the project we just used, if desired
            if (!this.in_close_flag || this.in_close_flag == "DO_NOT_SAVE_CHANGES") {
                // If no flag provided, this is the default.
                app.project.close(CloseOptions.DO_NOT_SAVE_CHANGES);
            } else {
                if (this.in_close_flag == "SAVE_CHANGES") {
                    app.project.close(CloseOptions.SAVE_CHANGES);
                }
                // otherwise, flag is DO_NOT_CLOSE, so we do nothing.
            }
        }
    }

    function my_SaveAndSetRenderSoundSetting() {
        // Save the current setting for hearing the render-done sound, we'll restore it later.
        if (app.preferences.havePref("Misc Section",
                "Play sound when render finishes", PREFType.PREF_Type_MACHINE_INDEPENDENT)) {
            // Get the current value if the pref exists.
            this.saved_sound_setting = app.preferences.getPrefAsLong("Misc Section",
                "Play sound when render finishes", PREFType.PREF_Type_MACHINE_INDEPENDENT);
        } else {
            // default is to play the sound, value of 1.
            // Use this if the pref does not yet exist.
            this.saved_sound_setting = 1;
        }

        // Set the setting for hearing the render-done sound, based on the input, default is off.
        this.my_sound_setting = 0; // 0 is off
        if (this.in_sound_flag && (this.in_sound_flag == "ON" || this.in_sound_flag == "on")) {
            this.my_sound_setting = 1; // 1 is on
        }

        app.preferences.savePrefAsLong("Misc Section",
            "Play sound when render finishes",
            this.my_sound_setting, PREFType.PREF_Type_MACHINE_INDEPENDENT);
    }

    function my_RestoreRenderSoundSetting() {
        if (this.saved_sound_setting) {
            app.preferences.savePrefAsLong("Misc Section",
                "Play sound when render finishes",
                this.saved_sound_setting, PREFType.PREF_Type_MACHINE_INDEPENDENT);
        }
    }

    // [3] assign all the functions to be method-type attributes.
    //
    this.onError = my_onError;
    this.SetExitCodeAndThrowException = my_SetExitCodeAndThrowException;
    this.SetExitCode = my_SetExitCode;
    this.StripAnyEnclosingQuotes = my_StripAnyEnclosingQuotes;
    this.GetValueForFlag = my_GetValueForFlag;
    this.ParseParamStartingAt = my_ParseParamStartingAt;
    this.ParseInArgs = my_ParseInArgs;
    this.IsInArray = my_IsInArray;
    this.SetupDefaultLog = my_SetupDefaultLog;
    this.CleanupDefaultLog = my_CleanupDefaultLog;
    this.Render = my_Render;
    this.ReallyRender = my_ReallyRender;
    this.GetFirstQueuedRQItemWithName = my_GetFirstQueuedRQItemWithName;
    this.AddCompToRenderQueue = my_AddCompToRenderQueue;
    this.EstablishAsOnlyQueuedItem = my_EstablishAsOnlyQueuedItem;
    this.SetLogPerFrameInfoInRQ = my_SetLogPerFrameInfoInRQ;
    this.CloseProjectIfDesired = my_CloseProjectIfDesired;
    this.SaveAndSetRenderSoundSetting = my_SaveAndSetRenderSoundSetting;
    this.RestoreRenderSoundSetting = my_RestoreRenderSoundSetting;
    this.IsSavePrefsArgGiven = my_IsSavePrefsArgGiven;
}

var gAECommandLineRenderer = new AECommandLineRenderer();
`;