Splitting tracks into mono

Here's the evolution of the script from part 2 of the video:

It now analyses the audio content on all stereo audio tracks in the session, and only splits those tracks with identical content on the left and right channels.
It also ensures to delete one of the split tracks (no need to keep both the left and right channels if they're identical).

function areChannelsIdentical(audioFilePath) {
    var commandLine = `ffmpeg -i "${audioFilePath}" -filter_complex "[0:a]channelsplit=channel_layout=stereo[left][right]; [left][right]amix=inputs=2:weights='1 -1'[diff]; [diff]astats=metadata=1" -f null - 2>&1 | grep "Max level"`;

    var ffmpegResult = sf.system.exec({
        commandLine: commandLine,
    }).result;

    var maxLevel = Number(ffmpegResult.match(/Max level: ([\d\.]+)/)[1]);

    if (maxLevel <= 0.0001) {
        //log(`Left and Right are identical`);
        return true;
    } else {
        //log(`Left and Right are different`);
        return false;
    }
}

function splitTracksIntoMonoAndDeleteOriginals(trackNames) {
    // Make sure the tracks in question are selected
    sf.app.proTools.selectTracksByName({
        selectionMode: 'Replace',
        trackNames: trackNames,
    });

    // 
    var tracksToDelete = trackNames.slice();

    // Remember all tracks in the session
    var trackNamesBefore = sf.app.proTools.tracks.invalidate().allItems.map(t => t.name);

    // Click the menu item "Track" -> "Split into Mono"
    sf.ui.proTools.menuClick({
        menuPath: ['Track', 'Split into Mono'],
    });

    alert('Click OK when all tracks are split');

    var trackNamesAfter = sf.app.proTools.tracks.invalidate().allItems.map(t => t.name);

    // Let's get the names of all the newly added tracks
    var newlyCreatedTrackNames = trackNamesAfter.filter(t => !trackNamesBefore.some(b => t === b));

    for (var i = 0; i < newlyCreatedTrackNames.length; i++) {
        if (i % 2 === 1) {
            tracksToDelete.push(newlyCreatedTrackNames[i]);
        }
    }

    // Select the tracks to delete
    sf.app.proTools.selectTracksByName({
        selectionMode: 'Replace',
        trackNames: tracksToDelete,
    });

    // Call "Track" -> "Delete..."
    sf.ui.proTools.menuClick({
        menuPath: ['Track', 'Delete...'],
    });

    // Wait for the confirmation dialog to appear
    sf.ui.proTools.confirmationButtonDialog.elementWaitFor();

    // Click "Delete"
    sf.ui.proTools.confirmationButtonDialog.buttons.whoseTitle.is("Delete").first.elementClick();
}

function getAudioFilePathOfFirstClipOnTrack(trackName) {
    sf.app.proTools.selectTracksByName({
        trackNames: [trackName],
        selectionMode: 'Replace',
    });

    sf.keyboard.press({
        keys: "return, shift+quote",
    });

    var audioFilePath = sf.app.proTools.getFileLocation({
        fileFilters: ['SelectedClipsTimeline'],
    }).fileLocations[0].path;

    return audioFilePath;
}

function main() {

    // Invalidate the PT tracks (in the PT SDK part of SoundFlow)
    sf.app.proTools.tracks.invalidate();

    // Get stereo audio tracks
    var stereoTracks = sf.app.proTools.tracks.allItems.filter(t => t.format === 'TFStereo' && t.type === 'Audio');

    // Get their names
    var stereoTrackNames = stereoTracks.map(t => t.name);

    // Figure out, which of those stereo tracks should be processed
    // We want to only process those tracks, where the first clip of the track
    // contains identical content on the left and right channels
    var trackNamesToProcess = [];
    for (let stereoTrackName of stereoTrackNames) {
        var audioFilePath = getAudioFilePathOfFirstClipOnTrack(stereoTrackName);

        if (areChannelsIdentical(audioFilePath)) {
            trackNamesToProcess.push(stereoTrackName);
        }
    }

    // Clear the timeline selection
    sf.keyboard.press({ keys: 'return' });

    // Select the tracks we want to process
    sf.app.proTools.selectTracksByName({
        selectionMode: 'Replace',
        trackNames: trackNamesToProcess,
    });

    // Split the tracks and delete the originals
    splitTracksIntoMonoAndDeleteOriginals(trackNamesToProcess);

}

main();

Hi @chrscheuer !
Thanks a lot for this script idea which would be a real time savior! As for info, same issue is happening here as @danielkassulke and @Adam_Lilienfeldt mentionned.
Testing without the "| grep..." part didn’t help so far. As for ffmpeg, last version should be installed (via homebrew as far as I’m concerned).
Running Ventura :)

Hi @julien_creu! Here is a code that combines everything above with the beautiful code that @danielkassulke and @Adam_Lilienfeldt wrote. I additionally just changed the panning method to be done in one go rather than each track. The code detects if the signal is Mono, Left, Right or Stereo, splits the relevant tracks, deletes the tracks not needed, renames and pans the remaining new ones to the center.

I used @chrscheuer 's idea of the channel weightage. If the result of summing 1 and -1 are zero then its mono. If the sum of weightage of 1 0 has signal and 0 1 doesn't, it is a left channel. If the sum of weightage of 1 0 doesn't have a signal and 0 1 has a signal, then its a right channel. If none of these are the conditions then it is stereo. Using this, and mapping the tracks accordingly, it proceeds to do the importing. You can choose to have a confirmation asking if only the mono tracks have to be panned to the center or all the new tracks have to. If its just the mono tracks it will only pan them. Else it will pan all the tracks to center. Hope it helps!

PS: It only processes the selected tracks. I updated the code for deletion in one go and renaming in one go.

// Determines whether the file is mono (both channels identical),
// or if one channel is silent. Returns "mono", "left", "right", or "stereo".
function areChannelsIdentical(audioFilePath) {
    var cmdFFMPEG = `
        audioFilePath="${audioFilePath}";
        mono=$(/opt/homebrew/bin/ffmpeg -hide_banner -i "$audioFilePath" \
        -filter_complex "[0:a]channelsplit=channel_layout=stereo[left][right];[left][right]amix=inputs=2:weights='1 -1'[diff];[diff]astats=metadata=1" \
         -f null - 2>&1 | grep "Max level" | head -n1 | awk '{print $NF}');
        if [ $(echo "$mono <= 0.0001" | bc -l) -eq 1 ]; then 
            echo "mono"; 
        else
            left=$(/opt/homebrew/bin/ffmpeg -hide_banner -i "$audioFilePath" \
            -filter_complex "[0:a]channelsplit=channel_layout=stereo[left][right];[left][right]amix=inputs=2:weights='1 0'[diff];[diff]astats=metadata=1" \
            -f null - 2>&1 | grep "Max level" | head -n1 | awk '{print $NF}');
            right=$(/opt/homebrew/bin/ffmpeg -hide_banner -i "$audioFilePath" \
            -filter_complex "[0:a]channelsplit=channel_layout=stereo[left][right];[left][right]amix=inputs=2:weights='0 1'[diff];[diff]astats=metadata=1" \
            -f null - 2>&1 | grep "Max level" | head -n1 | awk '{print $NF}');
            if [ $(echo "$left > 0.0001" | bc -l) -eq 1 ] && [ $(echo "$right <= 0.0001" | bc -l) -eq 1 ]; then 
                echo "left";
            elif [ $(echo "$left <= 0.0001" | bc -l) -eq 1 ] && [ $(echo "$right > 0.0001" | bc -l) -eq 1 ]; then 
                echo "right";
            else 
                echo "stereo"; 
            fi;
        fi
    `;
    // (Optionally, you can remove extra whitespace.)
    var result = sf.system.exec({ commandLine: cmdFFMPEG }).result.trim();
    // log("areChannelsIdentical(" + audioFilePath + ") -> " + result);
    return result;
}

//Unified Split/Delete Function

function splitAndDeleteTracksUnified(combinedTrackNames, trackChannelType) {
    // Select all original tracks.
    sf.app.proTools.selectTracksByName({ selectionMode: 'Replace', trackNames: combinedTrackNames });
    var namesBefore = sf.app.proTools.tracks.invalidate().allItems.map(t => t.name);

    // Execute the split command.
    sf.ui.proTools.menuClick({ menuPath: ['Track', 'Split into Mono'] });
    // alert('Click OK when all tracks are split');

    var namesAfter = sf.app.proTools.tracks.invalidate().allItems.map(t => t.name);
    // New names are those that did not exist before splitting.
    var newNames = namesAfter.filter(t => namesBefore.indexOf(t) === -1);

    // Build desired new names for each original track.
    var desiredNames = combinedTrackNames.map(function (orig) {
        var type = trackChannelType[orig];
        // For "mono" and "left" tracks, we want the left channel (.L); for "right" tracks, .R.
        var suffix = (type === "right") ? ".R" : ".L";
        return orig + suffix;
    });

    // Build the deletion list: delete all original tracks plus any new split that isn't desired.
    var deleteTracks = combinedTrackNames.slice(); // originals.
    deleteTracks = deleteTracks.concat(newNames.filter(function (n) {
        return desiredNames.indexOf(n) === -1;
    }));

    if (deleteTracks.length > 0) {
        sf.app.proTools.selectTracksByName({ selectionMode: 'Replace', trackNames: deleteTracks });
        sf.ui.proTools.menuClick({ menuPath: ['Track', 'Delete...'] });
        sf.ui.proTools.confirmationButtonDialog.elementWaitFor();
        sf.ui.proTools.confirmationButtonDialog.buttons.whoseTitle.is("Delete").first.elementClick();
    }
    // The kept tracks are the new splits that match one of the desired names.
    var keptTracks = newNames.filter(function (n) {
        return desiredNames.indexOf(n) !== -1;
    });
    return keptTracks;
}

/* 
Unified Rename Function:
  Removes any trailing ".L" or ".R" from each track name.
  Returns an array with the new (renamed) track names.
*/
function renameTracksWithoutSuffixUnified(trackNames) {
    var renamed = [];
    sf.app.proTools.selectTracksByName({ selectionMode: 'Replace', trackNames: trackNames });
    trackNames.forEach(function (name) {
        var newName = name.replace(/(\.L|\.R)$/, "");
        sf.app.proTools.renameTrack({ oldName: name, newName: newName });
        renamed.push(newName);
    });
    return renamed;
}

// Pans the provided tracks to center.
function panTracksToCenter(trackNames) {
    sf.ui.proTools.trackSelectByName({ names: trackNames });
    sf.ui.proTools.selectedTrack.trackScrollToView();
    sf.ui.proTools.selectedTrack.outputWindowButton.elementClick();
    sf.app.proTools.selectTracksByName({ selectionMode: 'Replace', trackNames: trackNames });
    sf.ui.proTools.mainTrackOutputWindow.sliders.whoseTitle.is("Front Pan Knob").first.mouseClickElement({ isOption: true, isShift: true });
    sf.ui.proTools.mainTrackOutputWindow.windowClose();
}

// Retrieves the audio file path of the first clip on the given track.
function getAudioFilePathOfFirstClipOnTrack(trackName) {
    sf.app.proTools.selectTracksByName({ trackNames: [trackName], selectionMode: 'Replace' });
    sf.keyboard.press({ keys: "return, control+tab" });
    return sf.app.proTools.getFileLocation({ fileFilters: ['SelectedClipsTimeline'] }).fileLocations[0].path;
}

// Main processing function.
function main() {

    const notifID = sf.system.newGuid().guid;
    sf.ui.proTools.appActivate();
    sf.app.proTools.invalidate();

    // Process only selected stereo audio tracks.
    var stereoTracks = sf.app.proTools.tracks.allItems.filter(t =>
        t.format === 'TFStereo' && t.type === 'Audio' && t.isSelected
    );
    var stereoTrackNames = stereoTracks.map(t => t.name);

    // Build arrays for each channel type and record each track's detected type.
    var monoTracks = [], leftTracks = [], rightTracks = [];
    var trackChannelType = {};  // e.g. { "Track1": "mono", "Track2": "left", "Track3": "right" }

    stereoTrackNames.forEach(function (trackName) {
        var audioPath = getAudioFilePathOfFirstClipOnTrack(trackName);
        var type = areChannelsIdentical(audioPath);
        trackChannelType[trackName] = type;

        //Notification
        sf.interaction.notify({
            uid: notifID,
            title: "Detection",
            message: `Track ${trackName} detected as ${type}`,
            keepAliveMs: 1500
        });

        if (type === "mono") {
            monoTracks.push(trackName);
        } else if (type === "left") {
            leftTracks.push(trackName);
        } else if (type === "right") {
            rightTracks.push(trackName);
        }
    });

    // Clear timeline selection.
    sf.keyboard.press({ keys: 'return' });

    // Combine all tracks that need processing.
    var combinedTracks = monoTracks.concat(leftTracks, rightTracks);
    // Split-and-delete on the combined tracks in one go.
    var processedTracks = splitAndDeleteTracksUnified(combinedTracks, trackChannelType);
    // Rename (remove the trailing ".L" or ".R") in one go.
    var renamedTracks = renameTracksWithoutSuffixUnified(processedTracks);

    // Ask if only mono tracks should be panned.
    var allKeptTracks;
    if (confirm("Pan all tracks to center? Cancel will Pan only mono tracks.")) {
        allKeptTracks = renamedTracks;
    } else {
        // Since the rename function removes the suffix, filter by original names that were mono.
        allKeptTracks = renamedTracks.filter(function (name) {
            return monoTracks.indexOf(name) !== -1;
        });
    }
    // Ensure allKeptTracks is an array of strings.
    allKeptTracks = allKeptTracks.map(function (item) { return String(item); });

    panTracksToCenter(allKeptTracks);
}

main();

Whoh Wonderful @Sreejesh_Nair , thank you so much!!
If someone needs it, here's a snippet that keeps the leftTracks and rightTracks panned to left and right!
Thanks guys for this superb script!!

function panTracksToLeft(trackNames) {
    sf.app.proTools.selectTracksByName({
        selectionMode: 'Replace',
        trackNames: trackNames,
    });
    //Pan new mono tracks to the left
    sf.ui.proTools.selectedTrack.outputWindowButton.elementClick({ executionMode: 'Background' });
    sf.ui.proTools.mainTrackOutputWindow.elementWaitFor();
    sf.ui.proTools.mainTrackOutputWindow.textFields[1].elementClick();
    sf.keyboard.type({
        text: "-100"
    });
    sf.keyboard.press({
        keys: 'return'
    });
    sf.ui.proTools.mainTrackOutputWindow.windowClose();
    sf.ui.proTools.mainTrackOutputWindow.elementWaitFor({
        waitType: 'Disappear'
    });
}

function panTracksToRight(trackNames) {
    sf.app.proTools.selectTracksByName({
        selectionMode: 'Replace',
        trackNames: trackNames,
    });
    //Pan new mono tracks to the right
    sf.ui.proTools.selectedTrack.outputWindowButton.elementClick({ executionMode: 'Background' });
    sf.ui.proTools.mainTrackOutputWindow.elementWaitFor();
    sf.ui.proTools.mainTrackOutputWindow.textFields[1].elementClick();
    sf.keyboard.type({
        text: "+100"
    });
    sf.keyboard.press({
        keys: 'return'
    });
    sf.ui.proTools.mainTrackOutputWindow.windowClose();
    sf.ui.proTools.mainTrackOutputWindow.elementWaitFor({
        waitType: 'Disappear'
    });
}

////////replaces the panning function in the end of the original script//////
    panTracksToCenter(monoTracks);
    panTracksToLeft(leftTracks);
    panTracksToRight(rightTracks);