header={
  "chef": "BeatRig",
  "dependencies": "ffmpeg,afconvert,ffprobe",
  "title": "Album Master",
  "description": "Create music master deliverables.",
  "instructions": "",
  "recipe_version": "0.372",
  "tags": "Audio",
  "type": "default",
  "os": "windows,macOS",
  "palette": "Clean Slate",
  "spice": "BQ==:G+Hy36kJcnQQYYavb/JV2Il6eCYr6h4hRJHCF9rRbhX5BcazL6cuTgUMdz0xA50VWA5PmmV0Q7aWkiUtNFtbk991l+t0e8IBXMReMIT1GNjnZZDv7n2YRAo0xcSQbY0ixjG6LLH4wGKnspKAoA/v69iLn6N2IH0XzIZwTGdHSo4=",
  "flavour": "ukFI2pecbv5MisUtfFWR6HeDWBbNapDeqfF9VQJjRxM2c60oq4RROmBdKYWvfmiJu3RpwwMQCknxYEtcf8w+/mONXVeSAkFpEHWTn5kmarjsoe/zXUlnUyYMMSN5xVbFadKffuH5fV2qIGl2SQ3cAXE5ArJu2BaLYDQ/GCxdWgc=",
  "time": 1723863789,
  "core_version": "0.6.4",
  "magnetron_version": "1.0.317",
  "functions": "main",
  "uuid": "a7b150f1d3e14bc7b3da4baecfc491c7",
  "ignore_dependencies": "afconvert"
};


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

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

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

// =============================================================================
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
    var libsoxr = cmd("ffmpeg", ['-version']);
    libsoxr = containsString(libsoxr, '--enable-libsoxr') ? true : false;


    // ------------------------------------
    //  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 limiter         = false;


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

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

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

    for (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){
        dialog("Could not process", "One or more files could not be analysed.","w");
        break;
        }

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

    // CHECK IF THERE IS AT LEAST ONE FILE
    if(files.length < 1){
        dialog("No files ","Add files before running the recipe.","w");
        setMainMessage("");
        break;
        }

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

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

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

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

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

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

        //
        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";
        files[i]['lufs'] = fileLevels.LUFS;
        setFiles(files);

        // FILE SPECS
        var specs = filespecs(f.path);
        
        // DURTATION FOR PROGRESS BAR
        duration = 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.streams[0].codec_name;
        files[i]['samplerate']          = specs.streams[0].sample_rate;
        files[i]['channels']            = specs.streams[0].channels;
        files[i]['bitrate']             = specs.streams[0].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
    var files = getFiles();
    files[refFile]['file_icon_color'] = "FFBBBBBB";
    files[refFile]['file_icon'] = "square";
    files[refFile]['file_status'] = '(REF. FILE)';
    setFiles(files);

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

    for (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){
        dialog("Could not process", "One or more files could not be analysed.","w");
        break;
        }

    // ------------------------------------
    // 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
    var files = getFiles();

    for (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() ) break;

        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{
                var opts = [
                    '-i',files[i].path,
                    '-f','wav',
                    '-c:a','pcm_s24le',
                    '-ac','2'
                    ];
            
                if(libsoxr){ opts = concatArray(opts, [
                    '-af','aresample=resampler=soxr'
                    ]);}
            
                opts = concatArray(opts, [
                    '-ar','176400',
                    '-y', outFile                   
                    ]);

                var ffmpeg = cmd("ffmpeg", opts);
                }

        }

        // ----------------------------------------------------------------
        if( isCanceled() ) break;

        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);


            var opts = [
                '-i',files[i].path,
                '-sample_fmt','s16',
                '-ar','44100',
                '-compression_level','8',

                ];
            
            if(libsoxr){ opts = concatArray(opts, [
                '-af','aresample=resampler=soxr,volume='+ adjust +'dB',
                ]);}
            else{ opts = concatArray(opts, [
                '-filter:a','volume='+ adjust +'dB',
                ]);}
            
            opts = concatArray(opts, [
                '-y', export_folder+gvar.pss+"FLAC"+gvar.pss+path.basename+'.flac'
                ]);

            var ffmpeg = cmd("ffmpeg", opts);
        }

        // ----------------------------------------------------------------
        if( isCanceled() ) break;

        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);

            var opts = [
                '-i',files[i].path,
                '-f','wav',
                '-c:a','pcm_s16le',
                '-ac','2'
                ];
            
            if(libsoxr){ opts = concatArray(opts, [
                '-af','aresample=resampler=soxr'
                ]);}
            
            opts = concatArray(opts, [
                '-ar','44100',
                '-filter:a','volume='+ adjust +'dB',
                '-y', export_folder+gvar.pss+"redbook"+gvar.pss+path.basename+'.wav',
                ]);

            var ffmpeg = cmd("ffmpeg", opts);
        }


        // ----------------------------------------------------------------
        if( isCanceled() ) break;

        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);

            var opts = [
                '-i',files[i].path,
                '-vn',
                '-ar','44100',
                '-ac','2',
                ];
            
            if(libsoxr){ opts = concatArray(opts, [
                '-af','aresample=resampler=soxr',
                ]);}
            
            opts = concatArray(opts, [
                '-b:a','192k',
                '-filter:a','volume='+ adjust +'dB',
                '-y', export_folder+gvar.pss+"reference"+gvar.pss+path.basename+'.mp3',
                ]);

            var ffmpeg = cmd("ffmpeg", opts);
        }

        // ----------------------------------------------------------------
        if( isCanceled() ) break;

        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{

                var opts = [
                    '-i',files[i].path,
                    '-f','wav',
                    '-c:a','pcm_s16le',
                    '-ac','2',
                    ];
                
                if(libsoxr){ opts = concatArray(opts, [
                    '-af','aresample=resampler=soxr',
                    ]);}
                
                opts = concatArray(opts, [
                    '-ar','44100',
                    '-filter:a','volume='+ adjust +'dB',
                    '-y', intermediateWav,
                    ]);

                var ffmpeg = cmd("ffmpeg", opts);
                }

            // 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
                ]);

            // 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)
    {

        // FOR AUDIO GET THE DURATION
        if(cmd_name == "ffmpeg" && cmd_output.length > 0 && duration > 0.)
        {
            var progress = searchRegEx(cmd_output , "(?:time=)(.*?)(?:\ bitrate=)", "i", 1);
            progress = progress[progress.length-1].split(':');
            progress = (parseFloat(progress[0]) * 60. * 60.) + (parseFloat(progress[1])*60.) + parseFloat(progress[2]);
            Math.round( parseFloat(progress)/ duration  * 100. );
            setProgress( progress );
            // setMainMessage(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)
    {
        setProgress(101);

        // ----------------------------------------
        // GET VIDEO SPECS
        var ffprobe= cmd("ffprobe", [
            '-v','error',
            '-show_entries','stream=codec_type,codec_name,channels,sample_rate,bits_per_sample : format=duration',
            '-i',file
            ]);
            
        var streams = [];

        // DURATION
        var duration = parseFloat ( searchRegEx(ffprobe, "(?:duration=)(.*?)(?=[\n\r])", "i", 1)[0] );        

        // UGGLY FIX BECAUSE replaceRegEx DOESNT KNOW HOW TO HANDLE NEW LINES
        // EXPLODE INTO STREAMS
        ffprobe = replaceRegEx(ffprobe, '[\n\r]', ',', "i");
        var ffprobe_array = (getStringTokens(ffprobe, "\n\r"));


        // EXPLODE INTO STREAMS
        // STREAM DATA
        var ffprobe = searchRegEx(ffprobe, "(?:\\[STREAM\\],)(.*?)(?=,\\[\\/STREAM\\])", "i", -1);

        // LOOP OVER STREAMS
        for (var i = 0; i < ffprobe_array.length; i++) {
            // EXPLODE ENTRIES
            var entries = ffprobe_array[i].split(',');

            // STREAM DATA
            var stream = {};
            for (var j = 0; j < entries.length; j++)
            {
                if (containsString(entries[j], "="))
                {
                    if (containsString(entries[j], "=") == false)
                        continue;
    
                    var l = entries[j].split('='); 
                
                    if          ( l[0] == "codec_name" && l[0] != "unknown" ) stream = mergeObject( stream, { "codec_name" : l[1] });
                    else if     ( l[0] == "codec_type" ) stream = mergeObject( stream, { "codec_type" : l[1] });
                    else if     ( l[0] == "sample_rate" ) stream = mergeObject( stream, { "sample_rate" : l[1] });
                    else if     ( l[0] == "channels" ) stream = mergeObject( stream, { "channels" : l[1] });
                    else if     ( l[0] == "bits_per_sample" ) stream = mergeObject( stream, { "bits_per_sample" : l[1] });        
                }
            }

            // GROUP AUDIO AND VIDEO STREAMS 
            if( stream.codec_type == "audio") { streams.push(stream); }
            }
    
        setProgress(0);


        // ----------------------------------------
        return {
            'streams' : streams,
            'duration' : duration
            };


        // ----------------------------------------
    }

// =============================================================================
    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

}