header={
  "chef": "BeatRig",
  "dependencies": "ffmpeg,afconvert,ffprobe",
  "title": "Album Master",
  "description": "Create music master deliverables.",
  "instructions": "",
  "recipe_version": "0.394",
  "tags": "Audio",
  "type": "default",
  "os": "windows,macOS",
  "palette": "Clean Slate",
  "spice": "BQ==:G+Hy36kJcnQQYYavb/JV2Il6eCYr6h4hRJHCF9rRbhX5BcazL6cuTgUMdz0xA50VWA5PmmV0Q7aWkiUtNFtbk991l+t0e8IBXMReMIT1GNjnZZDv7n2YRAo0xcSQbY0ixjG6LLH4wGKnspKAoA/v69iLn6N2IH0XzIZwTGdHSo4=",
  "flavour": "E3LWc9pL/h2b4EuoT8ULHsJHyrhuYqn3w5B7BEDLnEgxZma5aE8njC+Y9U4AsB4VJyqQXel3ffm2eOYHwvZ3AP9Qru+t0yJGu7uSs8mvWUdRnw87D0Vnl00/YRJDELE6mHkwAxXh89Y5+hCZOrvzFNIAIBx4YR5WSZrz5IBydnE=",
  "time": 1737203663,
  "core_version": "0.7.2",
  "magnetron_version": "1.0.333",
  "functions": "main",
  "uuid": "a7b150f1d3e14bc7b3da4baecfc491c7",
  "ignore_dependencies": "afconvert"
};


// GLOBAL FOR THE DURATION OF THE CURRENT FILE
var curDuration = 0;

// GLOBAL TO INDICATE IF FFMPEG CAN HANDLE LIBSOXR RESAMPLING
var libsoxr = false;

// GLOBAL TO INDICATE IF AFCONVCERT IS AVAILABLE
var afconvert = false;

var files = [];

// =============================================================================
function main()
{

    // ------------------------------------
    // CHECK IF FFMPEG IS AVAILABLE
    if(getAllowedApps("ffmpeg") == '')
    {
        setMainMessage("");
        abort("Could not start FFMPEG. Install it by from the settings." );
    }

    // ------------------------------------
    // CHECK IF FFPROBE IS AVAILABLE
    if(getAllowedApps("ffprobe") == '')
    {
        setMainMessage("");
        abort("Could not start FFPROBE. Install it by from the settings." );
    }
    
    // ------------------------------------
    //  CHECK IF FFMPEG CONTAINS LIBSOXR
    libsoxr = cmd("ffmpeg", ['-version']);
    libsoxr = libsoxr.includes('--enable-libsoxr');

    // ------------------------------------
    //  CHECK IF AFCONVERT IS AVAILABLE
    if( getAllowedApps("afconvert") != '' )
    {
        afconvert = true;
    }
    else
    {
        // TRY TO INSTALL
        if (gvar.isWindows == 0)
        {
            var loc = gvar.pss+'usr'+gvar.pss+'bin'+gvar.pss+'afconvert';
            if(fileExists(loc))
            {
                setAllowedApps('afconvert', loc);
                afconvert = true;
            }
        }
    }

    // ------------------------------------
    // LOUDNES SPECS
    var album_max_lufs  = -99.;
    var album_max_tp    = -99.;
    var adjust          = 0.;


    var fileTypes = [
        'wav',
        'aif',
        'aiff',
        ];

    // ------------------------------------
    setMainMessage("analysing");
    setProgress(0);

    // ------------------------------------
    // CLEANUP THE LIST AND CHECK EXTENSION
    files = getFiles();
    var failed = 0;

    for (let i=0;i<files.length;i++)
    {

        var path = getPathInfo( files[i].path );

        // fail
        var fail = ( fileTypes.indexOf( toLowerCase(path.ext) ) == -1 ? true: false);

        files[i]['file_icon_color'] = (fail ? "FFff0000" : "FFbbbbbb");
        files[i]['file_icon']       = (fail ? "Exclamation" : "SquareO");
        files[i]['file_status']     = '';
        files[i]['lufs']            = -99.;
        files[i]['peaks']           = -99.;
        files[i]['tooltip']         = '';
        files[i]['status']          = (fail ? "Invalid file" : "");

        if(fail){ failed++; }
    }

    // UPDATE FILES LIST
    setFiles(files);

    // SOME FILES ARE JUST WRONG
    if(failed > 0){
        abort("One or more files could not be analysed.");
        return;
        }

    // ------------------------------------
    // GET ALL FILES FROM THE APP
    files = getFiles();

    // CHECK IF THERE IS AT LEAST ONE FILE
    if(files.length < 1){
        abort("Please add some files first.");
        setMainMessage("");
        return;
        }

    // ------------------------------------
    // START PATH FOR DIALOG
    var path = getPathInfo( files[0].path );

    // ------------------------------------
    // DIALOG
    var r = showDialog(path.folder);

    // ------------------------------------
    // IF CANCELLED
    if(r.cancel){
        setMainMessage("");
        return;
        }

    // ------------------------------------
    // ANALYSE LOUDNESS OF ALL AUDIO FILES INDIVIDUALLY
    var args = {
        "AdjustTargetType": "LUFS",
        "AdjustTargetLevel":  0.
        };

    // ------------------------------------
    // ANALYSE FILES
    var maxLoudFile = 0;
    var maxPeakFile = 0;

    for (let i=0;i<files.length;i++)
    {
        // CHECK IF NOT CANCELED IN THE MEANTINE
        if( isCanceled() ) return;

        //
        setMainMessage("Analysing file "+i+"/"+files.length);

        // FILE PROPERTIES
        var f = files[i];

        // SET STATUS
        files[i]['file_icon_color'] = "FFFF8800";
        files[i]['file_icon'] = "CaretSquareORight";
        files[i]['file_status'] = 'Analyzing...';//toFixed(fileLevels.LUFS,1)+"LUFS";
        setFiles(files);

        // FILE SPECS
        var specs = filespecs(f.path);

        // DURTATION FOR PROGRESS BAR
        curDuration = specs.duration;

        // FILE LOUDNESS AND PEAK
        var fileLevels = levelFileAnalyse( f.path, args);

        // KEEP TRACK OF MAX ALBUM LOUDNESS AND PEAK
        if(fileLevels.LUFS > album_max_lufs) maxLoudFile = i;
        if(fileLevels.TruePeak > album_max_tp) maxPeakFile = i;

        album_max_lufs = Math.max(fileLevels.LUFS, album_max_lufs );
        album_max_tp = Math.max(fileLevels.TruePeak, album_max_tp );

        // SET STATUS
        files[i]['file_icon_color'] = "FFBBBBBB";
        files[i]['file_icon']       = "square";
        files[i]['file_status']     = '';

        // LEVELS
        files[i]['lufs']            = Math.round( fileLevels.LUFS * 100. ) / 100.;
        files[i]['peaks']           = Math.round( fileLevels.TruePeak * 100. ) / 100.;
        files[i]['plr']             = Math.round( fileLevels.PeakLoudness * 100. ) / 100.;

        // SPECS
        files[i]['duration']        = specs.duration;

        var durationHuman = humanTime(specs.duration);
        files[i]['durationHuman']   = durationHuman.time;

        files[i]['codec']           = specs.codec_name;
        files[i]['samplerate']      = specs.sample_rate;
        files[i]['channels']        = specs.channels;
        files[i]['bitrate']         = specs.bits_per_sample;

        // CHECK SOURCE FILE
        files[i]['sourceSpecsValid'] = (
            files[i].samplerate == 176400 &&
            files[i].channels == 2 &&
            files[i].codec == "pcm_s24le" && 
            toLowerCase(path.ext) == 'wav'
            ? true : false);

        setFiles(files);
    }

    // ------------------------------------
    // CALCULATE REF FILE AND ADJUSTMENT
    var refFile = maxLoudFile;
    adjust = -14. - album_max_lufs;

    // CHECK IF ADJUSTING IS NOT CAUSING CLIPPING
    if( album_max_tp + adjust > -1. ){
        refFile = maxPeakFile;
        adjust = -1.1 - album_max_tp; 
        }

    // UPDATE LIST
    files = getFiles();
    files[refFile]['file_icon_color'] = "FFBBBBBB";
    files[refFile]['file_icon'] = "square";
    files[refFile]['file_status'] = '(REF. FILE)';
    setFiles(files);

    // ------------------------------------
    // SET THE TOOLTIPS
    files = getFiles();

    for (let i=0;i<files.length;i++)
    {
        var tooltip = "";
        tooltip  += "[Source File]";
        tooltip  += "\n- Loudness : "+toFixed(files[i].lufs, 1)+'LUFS';
        tooltip  += "\n- Peak : "+toFixed(files[i].peak, 1)+'dBTP';
        tooltip  += "\n- PLR : "+toFixed(files[i].plr, 1)+'LUFS';
        tooltip  += "\n- Codec : "+files[i].codec;
        tooltip  += "\n- Samplerate : "+(parseInt(files[i].samplerate)/1000.)+"kHz";
        tooltip  += "\n- Channels : "+files[i].channels;
        tooltip  += "\n- Bitrate : "+files[i].bitrate+'bits per sample';
        tooltip  += "\n- Duration : "+files[i].durationHuman;


        if( !files[i].sourceSpecsValid ){ tooltip += "\n\nWe'll convert your highres master,\nas it doesnt match the specs.";}

        tooltip  += "\n\n[Loudness Processing]";
        tooltip  += "\n- Adjust : "+toFixed(adjust, 1)+'dB';
        tooltip  += "\n- Loundess : "+toFixed(files[i].lufs+adjust, 1)+'LUFS';
        tooltip  += "\n- Peak : "+toFixed(files[i].peak+adjust, 1)+'dBTP';

        // 
        files[i]['tooltip'] = tooltip;
        setFileTooltip(files[i].path, files[i].index, tooltip);
    }
    

    // ------------------------------------
    // WARN WHEN LOUDNESS IS OUT OF RANGE
    if(album_max_lufs == 0){
        abort("One or more files could not be analysed.");
        }

    // ------------------------------------
    // PROCESS THE FILES
    setProgress(50);
    setMainMessage("processing");

    // ------------------------------------
    // ASK WHERE TO EXPORT
    // var export_folder = openFolderDialog("Select folder", folders.home);
    var export_folder = r.folder;

    // ------------------------------------
    // PROCESS THE FILES
    files = getFiles();

    for (let i=0;i<files.length;i++)
    {
        // CURRENT FILE
        setMainMessage("Processing file "+i+"/"+files.length);

        // SET STATUS
        files[i]['file_icon_color'] = "FFFF8800";
        files[i]['file_icon'] = "CaretSquareORight";
        files[i]['file_status'] = 'Processing...';
        files[i]['lufs'] = fileLevels.LUFS;
        setFiles(files);


        // OUTPUT FILE
        var path = getPathInfo( files[i].path );


        // ----------------------------------------------------------------
        if( isCanceled() ) return;

        if(r.hires)
        {

            setMainMessage("Processing file "+i+"/"+files.length+" (high res)");

            // CREATE FOLDER
            if(!fileExists(export_folder+gvar.pss+"HighRes"+gvar.pss)) makeFolder(export_folder+gvar.pss+"HighRes"+gvar.pss);
            var outFile = export_folder+gvar.pss+"HighRes"+gvar.pss+path.basename+'.wav';

            // CHECK IF ALLREADY THE RIGHT FORMAT, IF SO JUST COPY
            if(files[i].sourceSpecsValid){
                copyFile(files[i].path, outFile);
                }

            // OTHER WISE CONVERT TO THE RIGHT FORMAT
            else{
                cmd("ffmpeg", [
                    '-i', files[i].path,
                    '-f', 'wav',
                    '-c:a', 'pcm_s24le',
                    '-ac', '2',
                    ...(libsoxr ? ['-af', 'aresample=resampler=soxr'] : []),
                    '-ar', '176400',
                    '-y', outFile,
                    '-loglevel', 'error',
                    '-progress', 'pipe:1',
                    '-nostats'
                    ]);
                }

        }

        // ----------------------------------------------------------------
        if( isCanceled() ) return;

        if(r.flac)
        {
            setMainMessage("Processing file "+i+"/"+files.length+" (FLAC)");

            // CREATE FOLDER
            if(!fileExists(export_folder+gvar.pss+"FLAC"+gvar.pss)) makeFolder(export_folder+gvar.pss+"FLAC"+gvar.pss);

            cmd("ffmpeg", [
                '-i', files[i].path,
                '-sample_fmt', 's16',
                '-ar', '44100',
                '-compression_level', '8',
                ...(libsoxr 
                    ? ['-af', `aresample=resampler=soxr,volume=${adjust}dB`] 
                    : ['-filter:a', `volume=${adjust}dB`]),
                `${export_folder}${gvar.pss}FLAC${gvar.pss}${path.basename}.flac`,
                '-y',
                '-loglevel', 'error',
                '-progress', 'pipe:1',
                '-nostats'
                ]);
        }

        // ----------------------------------------------------------------
        if( isCanceled() ) return;

        if(r.redbook)
        {
            setMainMessage("Processing file "+i+"/"+files.length+" (redbook)");

            // CREATE FOLDER
            if(!fileExists(export_folder+gvar.pss+"redbook"+gvar.pss)) makeFolder(export_folder+gvar.pss+"redbook"+gvar.pss);

            cmd("ffmpeg", [
                '-i', files[i].path,
                '-sample_fmt', 's16',
                '-ar', '44100',
                '-compression_level', '8',

                // IF LIBSOXR IS AVAILABLE USE IT, OTHERWISE USE BUILT IN RESAMPLER
                ...(libsoxr 
                    ? ['-af', `aresample=resampler=soxr,volume=${adjust}dB`] 
                    : ['-filter:a', `volume=${adjust}dB`]),

                `${export_folder}${gvar.pss}FLAC${gvar.pss}${path.basename}.flac`,
                '-y',
                '-loglevel', 'error',
                '-progress', 'pipe:1',
                '-nostats'
            ]);
        }


        // ----------------------------------------------------------------
        if( isCanceled() ) return;

        if(r.reference)
        {
            setMainMessage("Processing file "+i+"/"+files.length+" (reference)");

            // CREATE FOLDER
            if(!fileExists(export_folder+gvar.pss+"reference"+gvar.pss)) makeFolder(export_folder+gvar.pss+"reference"+gvar.pss);

            cmd("ffmpeg", [
                '-i', files[i].path,
                '-vn',
                '-ar', '44100',
                '-ac', '2',
                ...(libsoxr ? ['-af', 'aresample=resampler=soxr'] : []),
                '-b:a', '192k',
                '-filter:a', `volume=${adjust}dB`,
                `${export_folder}${gvar.pss}reference${gvar.pss}${path.basename}.mp3`,
                '-y',
                '-loglevel', 'error',
                '-progress', 'pipe:1',
                '-nostats'
            ]);
        }

        // ----------------------------------------------------------------
        if( isCanceled() ) return;

        if(afconvert && r.itunes)
        {
            setMainMessage("Processing file "+i+"/"+files.length+" (iTunes)");

            // CREATE FOLDER
            if(!fileExists(export_folder+gvar.pss+"iTunes"+gvar.pss)) makeFolder(export_folder+gvar.pss+"iTunes"+gvar.pss);

            // OUTPUT FILE
            var outfile = export_folder+gvar.pss+"iTunes"+gvar.pss+path.basename+'.m4a';
            if( fileExists(outfile) ) deleteFile(outfile);

            // LOCATION FOR INTERMEDIATE FILES
            if(!fileExists(folders.temp)) makeFolder(folders.temp);

            // INTERMEDIATE FILES
            var intermediateCaf = folders.temp+gvar.pss+"intermediate.caf";
            if(fileExists(intermediateCaf)) deleteFile(intermediateCaf);

            var intermediateWav = folders.temp+gvar.pss+"intermediate.wav";
            if(fileExists(intermediateWav)) deleteFile(intermediateWav);

            // INTERMEDIATE .WAV
            // CONVERT SAMPLE RATE AND ADJUST LOUDNESS
            // IF REDBOOK IS ALSO CREATED, JUST USE THAT FILE
            if( fileExists(redbookFile) ){
                intermediateWav = redbookFile;
                }

            // IF NOT CREATE AN INTEMEDIATE FILE
            else{

                cmd("ffmpeg", [
                    '-i', files[i].path,
                    '-f', 'wav',
                    '-c:a', 'pcm_s16le',
                    '-ac', '2',
                    ...(libsoxr ? ['-af', 'aresample=resampler=soxr'] : []),
                    '-ar', '44100',
                    '-filter:a', `volume=${adjust}dB`,
                    intermediateWav,
                    '-y',
                    '-loglevel', 'error',
                    '-progress', 'pipe:1',
                    '-nostats'
                    ]);
                }

            // CONVERT TO INTERMEDIATE
            var afconvert = cmd("afconvert", [
                intermediateWav,
                intermediateCaf,
                '-d','0',
                '-f','caff',
                '--soundcheck-generate'
                ]);

            var afconvert = cmd("afconvert", [
                intermediateCaf,
                '-d','aac',
                '-f','m4af',
                '-u','pgcm','2',
                '--soundcheck-read',
                '-b','256000',
                '-q','127',
                '-s','2',
                outfile,
                '-y',
                '-loglevel', 'error',
                '-progress', 'pipe:1',
                '-nostats',
                ]);

            // REMOVE INTERMEDIATE FILE
            if(fileExists(intermediateCaf)) deleteFile(intermediateCaf);
            if(fileExists(intermediateWav)) deleteFile(intermediateWav);

        }


        // ----------------------------------------------------------------
        // ALMOST DONE
        setProgress( 100 );

        // SET STATUS
        files[i]['file_icon'] = "CheckSquare";
        files[i]['file_icon_color'] = "FF00aa00";
        files[i]['file_status'] = 'Done'+(i == refFile ? " (REF. FILE)" : "");

        // UPDATE LIST
        setFiles(files);
    }

    // ------------------------------------
    // ALL DONE
    setProgress(100);
    setMainMessage( (isCanceled() ? "Canceled" : " ") );

    // ------------------------------------

}


// =============================================================================
// CALLBACK LOUDNESS ANALYSING
// this function gets called when busy LevelFileAnalyse. progress 0. to 1.
function LevelFileAnalyse_Progress(file, progress)
{
    setProgress(progress * 100);
}




// =============================================================================
function showDialog(path) {
    var form = {

        // REDBOOK
        "hires_label" : {
            "type" : "text",
            "label" : "high resolution",
            "just" : "l",
            "bounds" : { "x": 20, "w" : 150 },
            },


        "hires": { 
            "type": "togglebox", 
            "bounds" : { "y": -1,  "x": 150, "w" : 30 },
            "visible": true, 
            "toggle" : true,
            "label" : "" 
            },

        "hires_help" : {
            "type" : "texteditor",
            "default" : "Stereo WAV files, 176.4kHz, 24bit,\nwithout normalisation",
            "just" : "l",
            "enabled" : false,
            "bounds" : { "y": -1,  "x": 200, "w" : 350, "h" : 50},
            "multiline" : true, 
            "wordwrap" : true, 
            },

        // FLAC
        "flac_label" : {
            "type" : "text",
            "label" : "flac",
            "just" : "l",
            "bounds" : { "x": 20, "w" : 150 },
            },


        "flac": { 
            "type": "togglebox", 
            "bounds" : { "y": -1,  "x": 150, "w" : 30 },
            "visible": true, 
            "toggle" : true,
            "label" : "" 
            },

        "flac_help" : {
            "type" : "texteditor",
            "default" : "Stereo FLAC files, 44.1kHz, 16bit,\nwith the loudest file normalised at -14LUFS",
            "just" : "l",
            "enabled" : false,
            "bounds" : { "y": -1,  "x": 200, "w" : 350, "h" : 50},
            "multiline" : true, 
            "wordwrap" : true, 
            },


        // REDBOOK
        "redbook_label" : {
            "type" : "text",
            "label" : "redbook",
            "just" : "l",
            "bounds" : { "x": 20, "w" : 150 },
            },

        "redbook": { 
            "type": "togglebox", 
            "bounds" : { "y": -1, "x": 150, "w" : 30 },
            "visible": true, 
            "toggle" : true,
            "label" : "" 
            },

        "redbook_help" : {
            "type" : "texteditor",
            "default" : "Stereo WAV files, 44.1kHz, 16bit,\nwith the loudest file normalised at -14LUFS",
            "just" : "l",
            "enabled" : false,
            "bounds" : { "y": -1,  "x": 200, "w" : 350, "h" : 50},
            "multiline" : true, 
            "wordwrap" : true, 
            },

        // REDBOOK
        "itunes_label" : {
            "type" : "text",
            "label" : "iTunes",
            "just" : "l",
            "bounds" : { "x": 20, "w" : 150 },
            },

        "itunes": { 
            "type": "togglebox", 
            "bounds" : { "y": -1, "x": 150, "w" : 30 },
            "visible": true, 
            "toggle" : ( afconvert ? true : false),
            "label" : "",
            "enabled" : ( afconvert ? true: false),
            },

        "itunes_help" : {
            "type" : "texteditor",
            "default" : ( afconvert ? "Mastered for iTunes Plus AAC LC, 44.1kHz, 256k,\nwith the loudest file normalised at -14LUFS" : "afconvert not available"),
            "just" : "l",
            "enabled" : false,
            "bounds" : { "y": -1,  "x": 200, "w" : 350, "h" : 50},
            "multiline" : true, 
            "wordwrap" : true, 
            },

        // PREVIEW
        "reference_label" : {
            "type" : "text",
            "label" : "reference",
            "just" : "l",
            "bounds" : { "x": 20, "w" : 150 },
            },

        "reference": { 
            "type": "togglebox", 
            "bounds" : { "y": -1, "x": 150, "w" : 30 },
            "visible": true, 
            "toggle" : true,
            "label" : "" 
            },

        "reference_help" : {
            "type" : "texteditor",
            "default" : "Stereo MP3 files, 44.1kHz, 192k,\nwith the loudest file normalised at -14LUFS",
            "just" : "l",
            "enabled" : false,
            "bounds" : { "y": -1,  "x": 200, "w" : 350, "h" : 50},
            "multiline" : true, 
            "wordwrap" : true, 
            },

        // OUTPUT FOLDER
        "folder_spacer" : {
            "type" : "text",
            "label" : "",
            "just" : "l",
            "bounds" : { "x": 20, "w" : 400 },
            },

        "folder_label" : {
            "type" : "text",
            "label" : "folder",
            "just" : "l",
            "bounds" : { "x": 20, "w" : 150 },
            },

        "folder" : {
            "type" : "fileselect",
            "path" : path,
            "editable" : true,
            "dir" : true,
            "saving" : true,
            // "wildcard" : "*.txt",
            // "suffix" : "txt",
            "label" : "empty",
            "bounds" : { "y": -1,  "x": 150, "w" : 430 },
        },

        // BUTTONS
        "button_spacer" : {
            "type" : "text",
            "label" : "",
            "just" : "l",
            "bounds" : { "x": 20, "w" : 400, "h" : 25 },
            },

        "cancel" : {
            "type" : "button",
            "label" : "cancel",
            "bounds" : { "x": 370, "w" : 100, }, 
            "is_cancel" : true,
            "returns" : 0
            },

        "make" : {
            "type" : "button",
            "label" : "make",
            "bounds" : { "y" : -1, "x": 480, "w" : 100 }, 
            "is_okay" : true,
            "returns" : 1
            },

        // THIS IS THE END
        "bottom_spacer" : {
            "type" : "text",
            "label" : "",
            "just" : "l",
            "bounds" : { "x": 20, "w" : 400, "h" : 10 },
            },
        };

    var msg = "Select your output files.";
    if(libsoxr == false){ msg += '\nUsing built in resampler. (Your FFMPEG does not support the libsoxr library.)';}
    return dialog(header.title, msg, "w", form);
}


// =============================================================================
// CMD CALLBACK
function cmd_callback(cmd_name, cmd_output)
{
    // DUE TO A BUG IN THE FFMPEG CALLBACK THE MS IS SHOWN AS MICRO SECONDS,
    // NOT MILISECCONDS. SO WE NEED TO DIVIDE BY 1000000 TO GET THE CORRECT TIME
    if (cmd_name === "ffmpeg" && cmd_output.length > 0 && curDuration > 0) {
        const progress = Math.round((parseInt(cmd_output.match(/out_time_us=(\d+)/)?.pop() || 0, 10) / 1000000) / curDuration * 100);
        setProgress(progress);
    }

    return {
        "terminate": isCanceled(), // use this option to end the process if there is no better alternative
        "input": "" // send console input, like a quit signal (followed by a 'return' 0x0D)
    };
}


// =============================================================================
// FILE SPECS
function filespecs(file) 
{
    // FFPROBE COMMAND
    const ffprobe = cmd("ffprobe", [
        "-v", "error",
        "-print_format", "json",
        "-show_entries", "stream=codec_type,codec_name,bit_rate,channels,sample_rate,bits_per_sample : format=duration,size",
        "-i", file,
    ]);

    // Parse JSON output
    const specs = JSON.parse(ffprobe);

    // Extract audio stream information
    const audioStream = (specs.streams || []).find(stream => stream.codec_type === "audio");

    // If there is only one stream, return the audio stream information
    if( specs.streams.length == 1 && audioStream)
    {
        return {
            codec_name: audioStream?.codec_name || null,
            channels: parseInt(audioStream?.channels) || 0 ,
            sample_rate: parseInt(audioStream?.sample_rate) || 0,
            duration: parseFloat(specs.format?.duration) || 0,
            bits_per_sample: parseInt(audioStream?.bits_per_sample) || 0,
            bitrate: parseInt(audioStream?.bit_rate) || 0,
            filesize: parseInt(specs.format?.size) || 0,
        };
    }
    else
    {
        return false;
    }
}

// =============================================================================
function humanTime(totalSeconds) {
    var ms              = (totalSeconds - Math.floor(totalSeconds))*1000;
    var totalMinutes    = Math.floor(totalSeconds / 60);
    var seconds         = Math.floor(totalSeconds % 60);
    var hours           = Math.floor(totalMinutes / 60);
    var minutes         = totalMinutes % 60;

    return {
        h: parseInt(hours),
        m: parseInt(minutes),
        s: parseInt(seconds),
        ms : parseInt(ms),
        time : pad(hours,2) + ":" + pad(minutes,2) + ":"+ pad(seconds,2) + "."+ pad(ms,3),

        };
    }

// =============================================================================
function pad(num, size) {
    num = toFixed(parseInt(num), 0);
    while (num.length < size) num = "0" + num;
    return num;
    }

// ============================================================================
function dialog_callback(props)
{ // dummy

}