RX 11 Progress Bar UI element BUG - Automating "Music Rebalance" Stem Splitting from Finder

Awesome idea as usual!

A few notes for you, @Jake_Morton.

Instead of using actions like

sf.keyboard.press({
    keys: "tab, tab, tab, tab, tab, tab, tab, tab, tab",
});

sf.wait({ intervalMs: 500 });
sf.keyboard.press({ keys: "up" }); // Adjust bit depth
sf.wait({ intervalMs: 500 });

to navigate the Export Dialog, you can use the pick button to select the popup menu, and, in iZotope RX at least, you can use something like this to directly assign a value:

izotopeRX.mainWindow.popupButtons.whoseTitle.is("Bit depth").first.value.value = '24-bit';

Similarly, with the "Music Rebalance" module, you can set the quality like this:

 izotopeRX.windows.whoseTitle.is("Music Rebalance").first.groups.whoseDescription.is("EffectPanel Music Rebalance")
        .first.popupButtons.whoseTitle.is("Quality").first.value.value = 'Best';

instead of using mouse clicks and relative position! This also ensures that the popup window doesn't get in the way of clicking the "Stem split" button - which removes the need to force click or try multiple times.

And then, finally, instead of relying on the clipboard to copy the file path, I'm just pulling the file path from the selected file in Finder directly using:

let filePath = sf.ui.finder.selectedPaths[0]
let fileName = filePath.split('/').slice(-1)[0]

Hi, @Jake_Morton,

I'm not 100% sure on that. I THINK you could set this up by changing the functions to use type SMS. However, you may still need to have that set up via the Apple Messages app on your computer, and I'm not 100% sure on how that would work.

Let me know if it does work for you with Android, though. If not, maybe I can find some other approaches.

sendText({
contact: phoneNumber,
type: 'SMS',
message: `Music Rebalance Processing Hit an Error`,
})

Hi, @The_Balance_King,

Here's a more generic version of the script (omitting the playRandomChime() function that was referencing files on Jake's machine).

This version should accept song titles in the format: "Artist(s) - Song Title - Key - BPM" OR in the format Jake was using ("My Track_85BPM_v2.wav" or "Something_else_100BPM_final.WAV").

It still outputs the name fairly similarly to the last version. Let me know if you need it to change the output naming convention at all.

let sendTextMessages = false;
let phoneNumber = `xxxxxxxxxx`

// Defining iZotope RX is required if you have multiple versions of RX installed
let izotopeRX = sf.ui.app("com.izotope.RX11");

////////////////////////////////////////////////////////////////////////////////

/** 
 * WAIT FOR MODALS - Wait for RX Modal
 */
function waitForModals() {
    try {
        // Get the title of the current Audio File in iZotope RX
        const audioFileName = izotopeRX.mainWindow.getElement("AXTitleUIElement").value.invalidate().value;

        // Possible modal window titles
        const modalWindowNames = [audioFileName, "Composite"];

        // If any modal with this title exists, then wait
        while (modalWindowNames.some(modalWindowName => izotopeRX.floatingWindows.getByTitle(modalWindowName).exists)) {
            sf.wait({ intervalMs: 100 });
        }
    } catch (err) {

        throw `Wait for Modals Failed`;
    }
}

/** 
 * Send Text Message
 * @param {Object} messageObject - The message Object
 * @param {string} messageObject.type - 'SMS' or 'iMessage'
 * @param {string} messageObject.contact - Phone Number
 * @param {string} messageObject.message - The Text Message
 */
function sendText(messageObject) {
    sf.system.execAppleScript({
        script: `
            tell application "Messages"
                set a to first account whose service type = ${messageObject.type} and enabled is true
                set p to participant "${messageObject.contact}" of a
	            send "${messageObject.message}" to p
            end tell
       `,
        implementation: "NSAppleScript",
    });
}

/** 
 * Export Navigate to Path 
 * @param {string} path
*/
function navigateTo(path) {
    //Get a reference to the focused window in the frontmost app:
    var win = sf.ui.frontmostApp.focusedWindow;

    //Sanity check - make sure window is either Save or Open dialog
    if (!(win.title.value.indexOf('Export File') >= 0 || win.title.value.indexOf('Open') >= 0 || win.title.value.indexOf('Save As') >= 0))
        throw 'Focused window is not an Open or Save dialog. Title: ' + win.title.value;

    // Open the Go to... sheet
    sf.keyboard.type({ text: '/' });

    // Wait for the sheet to appear
    win.sheets.first.elementWaitFor({ timeout: 500 }, 'Could not find "Go to" sheet in the Save/Open dialog').element;

    // Set the value of the combo box
    sf.keyboard.type({
        text: path,
    }, 'Could not paste the path');

    // Press return
    sf.keyboard.press({
        keys: "return",
    }, "Could not hit return");

    //Wait for sheet to close
    win.sheets.first.elementWaitFor({ waitForNoElement: true, timeout: 500 }, '"Go to" sheet didn\'t close in time');
}

// Utility: Get Current Timestamp
function getCurrentTimestamp() {
    const now = new Date();
    const year = now.getFullYear();
    const month = String(now.getMonth() + 1).padStart(2, "0");
    const day = String(now.getDate()).padStart(2, "0");
    const hours = String(now.getHours()).padStart(2, "0");
    const minutes = String(now.getMinutes()).padStart(2, "0");
    const seconds = String(now.getSeconds()).padStart(2, "0");
    return `${year}${month}${day}_${hours}${minutes}${seconds}`;
}

function main() {

    try {
        log("🎬 Script started...");
        let defaultLocation = `~/Desktop/`
        if (sf.ui.finder.selectedPaths[0] != undefined) {
            defaultLocation = sf.ui.finder.selectedPaths[0];
        }

        // Step 1: Prompt the user for required inputs
        log("📥 Prompting the user for required inputs...");
        let filePathsToProcess = sf.interaction.selectFiles({
            prompt: `Please the files you'd like to process with Music Rebalance`,
            allowedFileTypes: ['wav', 'aif', 'aiff'],
            defaultLocation,
        });

        let destinationDirectory = sf.interaction.selectFolder({
            prompt: "Please choose the destination folder for exporting stems",
            defaultLocation: filePathsToProcess[0]
        }).path;

        let filesToProcess = [];

        // Regex to match Song Name and BPM by file name based on files like "My Track_85BPM_v2.wav", "Something_else_100BPM_final.mp3"
        let bpmAndFileNameRegex = /^(.+?)(?:\s*[-_]\s*(?:[A-G][#b]?\s?(?:Major|Minor|min|maj|M|m)))?\s*[-_]\s*(\d{2,3})BPM(?:[_\s-]*.*)?(?=\.|$)/;

        // For each path selected, push a new "files to process" object into the array
        filePathsToProcess.paths.forEach(path => {

            // Extract the file path
            let filePath = path;

            // Extract the File name 
            let fileName = filePath.split('/').slice(-1)[0];

            // Try to match for Song Name and BPM
            const match = fileName.match(bpmAndFileNameRegex);

            let songTitle, tempo;

            // If we matched, then extract song name and BPM
            if (match) {
                songTitle = match[1].trim();
                tempo = match[2];
            } else {
                throw (`Could Not Match Song Name and BPM in file: ${fileName}`)
            }

            // Push a new object with the file path, file name, song name, and bpm onto the queue 
            filesToProcess.push({
                filePath,
                fileName,
                songTitle,
                tempo
            })
        })

        if (filesToProcess.length === 0) {
            alert(`Rename File to include BPM like "My Track_85BPM_v2.wav" or "Something_else_100BPM_final.WAV" or "Artist(s) - Song Title - Key - 100BPM"`;)
            throw 0;
        }

        filesToProcess.forEach((file, index, allFiles) => {
            let { filePath, fileName, songTitle, tempo, } = file;

            log(`🎶 Full Filepath: ${filePath}`);
            log(`🎵 Song Title: ${songTitle}`);
            log(`🎚️ Tempo: ${tempo}`);
            log(`📂 Destination Directory: ${destinationDirectory}`);

            // Step 2: Create a uniquely timestamped folder for exporting all stems
            const timestamp = getCurrentTimestamp();

            // remove invalid characters from the songName
            const sanitizedSongTitle = songTitle.replace(/[\/:*?"<>|]/g, "_"); // Remove invalid characters

            // Step 4: Launch RX 11 and open the file directly
            log("🚀 Launching RX 11 and opening the file...");
            sf.file.open({
                path: filePath,
                applicationPath: "/Applications/iZotope RX 11 Audio Editor.app",
            });

            // Wait briefly to ensure the file is loaded
            log(`⏳ Waiting for RX 11 to load the file... ${fileName}`);

            izotopeRX.appWaitForActive({onError:"ThrowError"}, `Failed waiting for iZotope RX to activate`);

            // Wait for Currently Open File to Match the Selected File
            sf.waitFor({
                callback: () => {
                    izotopeRX.invalidate();
                    return izotopeRX.mainWindow.getElement("AXTitleUIElement").value.value == fileName;
                },
                timeout: 10000
            }, `Failed waiting for fileName to Match`);

            // Step 5: Process Music Rebalance
            log("🎛️ Processing Music Rebalance...");
            processMusicRebalance();

            log("⏳ Waiting for RX 11 to process the file...");
            // Use "Wait for Modals" function to wait
            waitForModals();

            // Define the Export Folder with songTitle, tempo and timestamp
            const exportFolder = `${destinationDirectory}/STEMS_${sanitizedSongTitle}_${tempo}bpm_${timestamp}`;
            log("📂 Creating a single uniquely timestamped folder for all stems...");
            sf.file.directoryCreate({ path: exportFolder });
            log(`📂 Export folder created: ${exportFolder}`);

            // Step 6: Export Files
            log("💾 Exporting files...");
            exportStems(songTitle, tempo, exportFolder);

            // Send an iMessage with Progress
            if (sendTextMessages) {
                // Send an iMessage of Progress Update
                sendText({
                    contact: phoneNumber,
                    type: 'iMessage',
                    message: `${index + 1}/${filesToProcess.length} - '${songTitle}_${tempo}' Finished Processing`,
                })
            }
        })

        // Send an SMS if we Finish all Files
        log("🎉 Script completed successfully!");
        if (sendTextMessages) {
            sendText({
                contact: phoneNumber,
                type: 'SMS',
                message: `🎉 All Files Finished Processing with Music Rebalance`,
            })
        }

    } catch (err) {
        // Send an SMS if we hit an Error
        if (sendTextMessages) {
            sendText({
                contact: phoneNumber,
                type: 'SMS',
                message: `Music Rebalance Processing Hit an Error`,
            })

            throw `🛑 Music Rebalance Processing Hit an Error: ${err}`
        }
    }

    // Music Rebalance Function
    function processMusicRebalance() {
        log("🎛️ Opening the Music Rebalance module...");

        // If the Music Balance Module is already active, then don't click the menu again - this would hide it. 
        if (!izotopeRX.getMenuItem("Modules", "Music Rebalance...").isMenuChecked) {
            izotopeRX.menuClick({ menuPath: ["Modules", "Music Rebalance..."] });
            log("⏳ Waiting for the Music Rebalance window to appear...");
            izotopeRX.windows.whoseTitle.is("Music Rebalance").first.elementWaitFor({
                waitType: "Appear",
                failIfNotFound: true,
            });
        }

        log("✅ Music Rebalance window is active.");

        log("🎚️ Selecting the quality option...");

        // Set the Quality of Music Rebalance to "Best"
        izotopeRX.windows.whoseTitle.is("Music Rebalance").first.groups.whoseDescription.is("EffectPanel Music Rebalance")
            .first.popupButtons.whoseTitle.is("Quality").first.value.value = 'Best';

        // Click "Split Stems" button with retry mechanism
        log("🔀 Attempting to click 'Split Stems' button...");

        // Click "Split Stems" Button on "Music Balance" module
        izotopeRX.windows.whoseTitle.is("Music Rebalance").first.groups.whoseDescription.is("EffectPanel Music Rebalance")
            .first.groups.whoseDescription.is("EffectPanel Music Rebalance").first.groups.whoseDescription.is("EffectPanel Music Rebalance Footer Background")
            .first.groups.whoseDescription.is("Apply Group Container").first.buttons.whoseDescription.is("Split Stems").first.elementClick();

        // Wait for "Music Re-balance" to finish processing
        izotopeRX.windows.first.getElement("AXTitleUIElement").elementWaitFor({
            waitType: "Disappear",
        });

        //Brute forced a wait to ensure no problems re: "additional processing"  occur when exporting files
        // sf.wait({
        //     intervalMs: 800,
        // });

        // CW - Use this to wait for processing or export to finished
        while (!izotopeRX.getMenuItem('Edit', 'Select All').isEnabled) {
            sf.wait({ intervalMs: 200 });
        }
    }
    // Handle Save Alert Function
    function handleSaveAlert() {
        try {
            izotopeRX.windows.whoseDescription.is("alert").first.elementWaitFor({
                waitType: "Appear",
                timeout: 1000
            });
            log("⚠️ Save alert appeared.");

            izotopeRX.windows.whoseDescription.is("alert").first.buttons.whoseTitle.is("No").first.elementClick();
            log("🛑 Clicked 'No' on save alert.");
        } catch (err) {
            log("✅ No save alert appeared, continuing...");
        }
    }

    // Handle Alert "additional processing unfinished" nuisance
    function handleAlertWindow() {
        try {
            izotopeRX.windows.whoseDescription.is("alert").first.elementWaitFor({
                waitType: "Appear",
                timeout: 1000
            });
        } catch (err) {
            log("Alert window did not appear, continuing...");
        }

        try {
            izotopeRX.windows.whoseDescription.is("alert").first.buttons.whoseTitle.is("Yes").first.elementClick();
        } catch (err) {
            log("Yes button not found or not clickable, continuing...");
        }
    }

    // Export Stems Function
    function exportStems(songTitle, tempo, exportFolder) {
        log("💾 Exporting stems...");

        const fileNames = [
            { prefix: "00", name: "Original Recording" },
            { prefix: "01", name: "Vocals" },
            { prefix: "02", name: "Bass" },
            { prefix: "03", name: "Percussion" },
            { prefix: "04", name: "Other Instruments" },
        ];

        const currentDate = getCurrentTimestamp();
        log(`🗓️ Current date: ${currentDate}`);

        // Track whether it's the first export
        let isFirstExport = true;

        fileNames.forEach((file, index) => {
            const exportFileName = `${file.prefix}_${file.name}_${songTitle}_${tempo}_${currentDate}.wav`;
            const exportPath = `${exportFolder}/${exportFileName}`;
            log(`🎙️ Processing file: ${file.name} (${index + 1}/${fileNames.length})`);
            log(`📂 Export path: ${exportPath}`);
            log("💾 Opening Export dialog...");

            izotopeRX.menuClick({ menuPath: ["File", "Export..."] });

            // Wait for the Export Module to Appear
            waitForExportPanelWithRetry();

            function waitForExportPanelWithRetry(attempts = 3) {
                for (let i = 0; i < attempts; i++) {
                    try {
                        izotopeRX.mainWindow.groups.whoseDescription.is("ExportPanel Module Wrapper").first.elementWaitFor({ timeout: 3000 });
                        log("✅ Export Panel detected.");
                        return true;
                    } catch (err) {
                        log(`⚠️ Attempt ${i + 1}: Export Panel not found.`);
                    }
                }
                log("⚠️ Export Panel did not appear after retries, continuing...");
                return false;
            }

            // We want the original file to be at the original bit-depth
            if (!isFirstExport) {
                log("🔧 Adjusting export bit depth (not required for the first file)...");

                // Select WAV File
                izotopeRX.mainWindow.buttons.whoseDescription.is("WAVButton").first.elementClick();

                // Set Bit Depth to '24-bit'
                izotopeRX.mainWindow.popupButtons.whoseTitle.is("Bit depth").first.value.value = '24-bit';
            }

            // Click "OK" in the Export Panel Window
            izotopeRX.mainWindow.groups.whoseDescription.is("ExportPanel Module Wrapper").first.groups.whoseDescription.is("ExportPanel Module Wrapper Footer Background")
                .first.buttons.whoseDescription.is("OK").first.elementClick({ asyncSwallow: true });

            log("⏳ Waiting for RX 11 export UI to load...");

            // Wait for "Save" button to be clickable, then Click "Save" Button, then wait for "Save" button to disappear
            sf.waitFor({
                callback: () => {
                    return izotopeRX.windows.whoseTitle.is('Export File').first.buttons.whoseTitle.is("Save").first.isEnabled;
                },
                timeout: 1000
            }, `Failed waiting for Save to Be Enabled before Navigating to Folder`);


            log("📁 Navigating to folder and typing export path...");

            // Using "Navigate To" utility function
            navigateTo(exportPath);

            // Wait for "Save" button to be clickable, then Click "Save" Button, then wait for "Save" button to disappear
            sf.waitFor({
                callback: () => {
                    return izotopeRX.windows.whoseTitle.is('Export File').first.buttons.whoseTitle.is("Save").first.isEnabled;
                },
                timeout: 1000
            }, `Failed waiting for Save to Be Enabled after Navigating to Folder`);

            izotopeRX.windows.whoseTitle.is('Export File').first.buttons.whoseTitle.is("Save").first.elementClick();

            izotopeRX.windows.whoseTitle.is('Export File').first.buttons.whoseTitle.is("Save").first.elementWaitFor({ waitType: "Disappear" });

            // Wait for Export Panel to Disappear
            izotopeRX.mainWindow.groups.whoseDescription.is("ExportPanel Module Wrapper").first.elementWaitFor({ waitType: "Disappear" });

            // Try and brute force a wait to see if it allows time for the export to occur and the close function to work.
            // sf.wait({
            //     intervalMs: 800,
            // });

            // CW - Use this to wait for processing or export to finished
            while (!izotopeRX.getMenuItem('Edit', 'Select All').isEnabled) {
                sf.wait({ intervalMs: 200 });
            }

            // Close the File 
            izotopeRX.menuClick({ menuPath: ['File', 'Close File'] });

            handleSaveAlert();

            handleAlertWindow();

            log(`✅ Export completed for file: ${file.name}`);

            // Mark the first export as complete after the first iteration
            isFirstExport = false;
        });

        log("🎉 All stems exported successfully.");
    }
}

// Run the main script
main();