userscripts/AnimeBytes/ab-mediainfo.user.js

// ==UserScript==
// @name AnimeBytes Mediainfo Improvements
// @author WeebDataHoarder
// @version 1.9.1
// @downloadURL https://git.gammaspectra.live/WeebDataHoarder/userscripts/raw/branch/master/AnimeBytes/ab-mediainfo.user.js
// @updateURL https://git.gammaspectra.live/WeebDataHoarder/userscripts/raw/branch/master/AnimeBytes/ab-mediainfo.user.js
// @description AnimeBytes Mediainfo Improvements. Adds several listing and matching releases against mediainfo utilities. MIT license
// @match https://animebytes.tv/torrents.php?*id=*
// @icon http://animebytes.tv/favicon.ico
// @run-at document-end
// ==/UserScript==

function parseMediaInfo(text){
    let ob = {};
    let currentKey = null;
    let currentOb = null;

    try{
        text.split("\n").forEach((line) => {
            const cleanLine = line.trim();
            if(cleanLine === ""){
                return;
            }else if(!cleanLine.includes(":")){
                if(currentOb !== null && Object.keys(currentOb).length === 0){
                    //Nothing added, error, invalid mediainfo
                    throw ("Invalid key " + currentKey);
                }
                currentKey = cleanLine.toLowerCase();
                let listMatch = currentKey.match(/^(?<kind>(video|audio|text))( #)?(?<number>[0-9]*)$/i);
                currentOb = {};
                if(listMatch !== null){
                    let k = listMatch.groups.kind;
                    if(!(k in ob)){
                        ob[k] = [];
                    }
                    ob[k].push(currentOb);
                }else{
                    ob[currentKey] = currentOb;
                }
            }else if(currentOb !== null){
                const matches = cleanLine.match(/^(?<key>((?!\s:).)+)[\s]*:(?<value>.+)$/);
                if(matches !== null){
                    let key = matches.groups.key.trim().toLowerCase().replace(/[ \/*]/g, "_").replace(/[(),]/g, "");
                    currentOb[key] = matches.groups.value.trim();
                }else{
                    throw "Invalid entry: " + cleanLine;
                }
            }else{
                throw "Invalid state: " + cleanLine;
            }
        });
    }catch (e){
        console.log(text);
        console.log(e);
        return null;
    }

    return ob;
}

/**
 * @param v
 * @param legacy
 * @returns String
 */
function getLineTagEntry(v, legacy){
    if(typeof v === 'object'){
        return legacy ? v.legacy : (v.name/* + ("lossless" in v ? " (Lossless)" : "")*/);
    }

    return v;
}

function getAudioChannels(a){
    if(a === 3){
        return "2.1";
    }else if(a === 5){
        return "4.1";
    }else if(a === 6){
        return "5.1";
    }else if(a === 8){
        return "7.1";
    }

    return a + ".0";
}

function getComparisonLine(tags){

    let entries = [];
    entries.push(getLineTagEntry(tags.source, true));
    entries.push(getLineTagEntry(tags.container, true) + ("region" in tags ? " (" + tags.region + ")" : ""));

    if("aspectRatio" in tags){
        entries.push(tags.aspectRatio);
    }

    if("videoCodec" in tags && !(
        getLineTagEntry(tags.source, true).match(/^DVD[59]$/) !== null
    )){
        entries.push(getLineTagEntry(tags.videoCodec, true));
    }
    entries.push(tags.resolution);

    entries.push(getLineTagEntry(tags.audioCodec, true) + " " + getAudioChannels(tags.audioChannels));
    if(tags.audioCount > 1){
        entries.push("Dual Audio");
    }
    entries.push(("subtitleType" in tags ? getLineTagEntry(tags.subtitleType, true) : "RAW") + ("group" in tags ? " (" + tags.group + ")" : ""));
    return entries.join(" | ");
}

function getEntryLine(tags, infoCount, warningCount, dangerCount){
    // Source + container + remux | Codec / Resolution / HDR | Audio + Dual + commentary | Text | OtherTags | icons
    let entries = {
        source: [],
        video: [],
        audio: [],
        text: [],
        other: [],
        icons: []
    };
    entries.source.push(getLineTagEntry(tags.source, false) + ("sourceName" in tags ? " (" + tags.sourceName + ")" : ""));
    entries.source.push(getLineTagEntry(tags.container, false) + ("region" in tags ? " (" + tags.region + ")" : ""));

    entries.video.push(getLineTagEntry(tags.videoCodec, false) + ("videoEncoder" in tags ? " (" + tags.videoEncoder  + ("videoCRF" in tags ? " " + tags.videoCRF : "") + ")" : ""));
    entries.video.push(tags.resolution + ("aspectRatio" in tags ? " " + tags.aspectRatio : "") /* + ("videoFrameRate" in tags ? " @ " + tags.videoFrameRate : "")*/);
    if("videoHDR" in tags){
        entries.video.push(getLineTagEntry(tags.videoHDR, false));
    }

    entries.audio.push(getLineTagEntry(tags.audioCodec, false) + " " + getAudioChannels(tags.audioChannels));
    if(tags.audioCount > 1){
        entries.audio.push("Dual");
    }

    if("audioCommentary" in tags && tags.audioCommentary){
        entries.audio.push("Commentary");
    }

    if("remux" in tags){
        if(tags.remux === true){
            entries.source.push("REMUX");
        }else if(tags.remux === "probably"){
            entries.source.push("REMUX*");
        }
    }

    if(tags.remastered){
        let img = document.createElement("img");
        img.src = "/static/common/rmstr.png";
        img.alt = "Remastered";
        img.title = "This torrent is from a remastered source!";
        entries.other.push(img);
    }

    entries.text.push(("subtitleCodec" in tags ? tags.subtitleCodec + " " : "") + ("subtitleType" in tags ? getLineTagEntry(tags.subtitleType, false) : "RAW") + ("group" in tags ? " (" + tags.group + ")" : ""));



    if(tags.freeleech){
        let img = document.createElement("img");
        img.src = "/static/common/flicon.png";
        img.alt = "Freeleech!";
        img.title = "This torrent is freeleech. Remember to seed!";
        entries.other.push(img);
    }

    if("chapters" in tags){
        entries.other.push(tags.chapters === "ordered" ? "Ordered Chapters" : "Chapters");
    }

    if(tags.snatched){
        entries.other.push("Snatched");
    }

    if(infoCount > 0 || warningCount > 0 || dangerCount > 0){

        let span = document.createElement("span");

        for(let i = 0; i < infoCount; ++i){
            span.append("★");
        }
        for(let i = 0; i < warningCount; ++i){
            let icon = document.createElement("img");
            icon.src = "/static/common/symbols/warned.png";
            span.append(icon);
        }
        for(let i = 0; i < dangerCount; ++i){
            let icon = document.createElement("img");
            icon.src = "/static/common/symbols/disabled.png";
            span.append(icon);
        }
        entries.icons.unshift(span);
    }


    return entries;
}

const allowedVideoTypes = [
    "Movie",
    "OVA",
    "ONA",
    "TV Series",
    "TV Special",
    "DVD Special",
    "BD Special"
];

const knownSources = [
    "TV",
    "DVD",
    "DVD5",
    "DVD9",
    "Blu-ray",
    "UHD Blu-ray",
    "HD DVD",
    "VHS",
    "LD",
    "Web"
];

const knownContainers = [
    "AVI",
    "MKV",
    "MP4",
    "OGM",
    "WMV",
    "MPG",
    "ISO",
    "VOB",
    "VOB IFO",
    "TS",
    "M2TS",
    "FLV",
    "RMVB"
];

const knownVideoCodecs = [
    "h264",
    "h264 10-bit",
    "h265",
    "h265 10-bit",
    "XviD",
    "DivX",
    "WMV",
    "MPEG-1/2",
    "VC-1",
    "MPEG-TS",
    "DVD5",
    "DVD9",
    "RealVideo",
    "VP6",
    "VP9",
    "AV1"
];

const knownAudioCodecs = [
    "MP3",
    "Vorbis",
    "Opus",
    "AAC",
    "AC3",
    "TrueHD",
    "DTS",
    "DTS-ES",
    "FLAC",
    "PCM",
    "WMA",
    "MP2",
    "WAV",
    "DTS-HD",
    "DTS-HD MA",
    "RealAudio"
];

const audioCodecs = [
    {
        name: "AAC-LC",
        match: {
            codec_id: /^A_AAC/,
            format_profile: "LC"
        },
        legacy: "AAC"
    },
    {
        name: "HE-AAC",
        match: {
            codec_id: /^A_AAC/,
            format_profile: /HE-AAC/
        },
        legacy: "AAC"
    },
    {
        name: "AAC-LC",
        match: {
            codec_id: "A_AAC-2"
        },
        legacy: "AAC"
    },

    {
        name: "AAC-Main",
        match: {
            codec_id: "A_AAC-1"
        },
        legacy: "AAC"
    },
    {
        name: "AAC-Main",
        match: {
            codec_id: "A_AAC",
            format_profile: "Main"
        },
        legacy: "AAC"
    },

    {
        name: "AC3",
        match: {
            codec_id: "A_AC3"
        },
        legacy: "AC3"
    },

    {
        name: "Opus",
        match: {
            codec_id: "A_OPUS"
        },
        legacy: "Opus"
    },

    {
        name: "Vorbis",
        match: {
            codec_id: "A_VORBIS"
        },
        legacy: "Vorbis"
    },

    {
        name: "WAV",
        match: {
            codec_id: "A_WAVPACK4"
        },
        legacy: "WAV"
    },

    {
        name: "MP2",
        match: {
            codec_id: "A_MPEG/L2"
        },
        legacy: "MP2"
    },

    {
        name: "MP3",
        match: {
            codec_id: "A_MPEG/L3"
        },
        legacy: "MP3"
    },

    {
        name: "FLAC",
        match: {
            codec_id: "A_FLAC"
        },
        legacy: "FLAC",
        lossless: true
    },

    {
        name: "PCM",
        match: {
            codec_id: "A_PCM/INT/LIT"
        },
        legacy: "PCM",
        lossless: true
    },

    {
        name: "E-AC3",
        match: {
            codec_id: "A_EAC3",
            number_of_dynamic_objects: null
        },
        legacy: "AC3"

    },
    {
        name: "E-AC3 Atmos",
        match: {
            codec_id: "A_EAC3",
            number_of_dynamic_objects: /^[0-9]+$/
        },
        legacy: "AC3"

    },
    {
        name: "TrueHD Atmos",
        match: {
            codec_id: "A_TRUEHD",
            number_of_dynamic_objects: /^[0-9]+$/
        },
        legacy: "TrueHD",
        lossless: true
    },
    {
        name: "TrueHD",
        match: {
            codec_id: "A_TRUEHD",
            number_of_dynamic_objects: null
        },
        legacy: "TrueHD",
        lossless: true
    },

    {
        name: "DTS:X MA",
        match: {
            codec_id: "A_DTS",
            format: "DTS XLL X",
            channels_original: "Object Based"
        },
        legacy: "DTS-HD MA",
        lossless: true
    },
    {
        name: "DTS-HD MA",
        match: {
            codec_id: "A_DTS",
            format: "DTS XLL",
            channels_original: null,
        },
        legacy: "DTS-HD MA",
        lossless: true
    },
    {
        name: "DTS-HD",
        match: {
            codec_id: "A_DTS",
            format: "DTS XBR",
        },
        legacy: "DTS-HD"
    },
    {
        name: "DTS",
        match: {
            codec_id: "A_DTS",
            format: "DTS",
            format_profile: null,
        },
        legacy: "DTS"
    },
    {
        name: "DTS-ES",
        match: {
            codec_id: "A_DTS",
            format: "DTS ES",
        },
        legacy: "DTS-ES"
    },
    {
        name: "DTS-HD MA",
        match: {
            codec_id: "A_DTS",
            format_profile: /^MA/,
            channels_original: null,
        },
        legacy: "DTS-HD MA",
        lossless: true
    },
    {   //Old way of identifying
        name: "DTS-ES",
        match: {
            codec_id: "A_DTS",
            format_profile: /^ES/,
        },
        legacy: "DTS-ES"
    },
    {   //Old way of identifying
        name: "DTS-HD MA",
        match: {
            codec_id: "A_DTS",
            format_profile: "MA / Core",
            channels_original: null,
        },
        legacy: "DTS-HD MA",
        lossless: true
    }
];

const videoCodecs = [

    {
        name: "MPEG-1",
        match: {
            codec_id: "V_MPEG1",
        },
        legacy: "MPEG-1/2"
    },
    {
        name: "MPEG-2",
        match: {
            codec_id: "V_MPEG2",
        },
        legacy: "MPEG-1/2"
    },
    {
        name: "MPEG-$version",
        match: {
            format: "MPEG Video",
            format_version: /^Version (?<version>[12])$/,
        },
        legacy: "MPEG-1/2"
    },

    {
        name: "h264",
        match: {
            codec_id: "V_MPEG4/ISO/AVC",
            bit_depth: "8 bits",
            chroma_subsampling: /^4:2:0/
        },
        legacy: "h264"
    },

    {
        name: "h264 $bitDepth-bit $chroma",
        match: {
            codec_id: "V_MPEG4/ISO/AVC",
            bit_depth: /^(?<bitDepth>10) bits/,
            chroma_subsampling: /^(4:2:0|(?<chroma>[0-9]:[0-9]:[0-9]))/
        },
        legacy: "h264 $bitDepth-bit"
    },

    {
        name: "VC-1 $codec",
        match: {
            codec_id: /^V_MS\/VFW\/FOURCC \/ (?<codec>WMV3|WMVA|WVC1)/,
            bit_depth: "8 bits"
        },
        legacy: "VC-1"
    },

    {
        name: "VP9 $chroma",
        match: {
            codec_id: "V_VP9",
            bit_depth: "8 bits",
            chroma_subsampling: /^(4:2:0|(?<chroma>[0-9]:[0-9]:[0-9]))/
        },
        legacy: "VP9"
    },

    {
        name: "VP9 $bitDepth-bit $chroma",
        match: {
            codec_id: "V_VP9",
            bit_depth: /^(?<bitDepth>10|12) bits/,
            chroma_subsampling: /^(4:2:0|(?<chroma>[0-9]:[0-9]:[0-9]))/
        },
        legacy: "VP9"
    },

    {
        name: "AV1 $chroma",
        match: {
            codec_id: "V_AV1",
            bit_depth: "8 bits",
            chroma_subsampling: /^(4:2:0|(?<chroma>[0-9]:[0-9]:[0-9]))/
        },
        legacy: "AV1"
    },

    {
        name: "AV1 $bitDepth-bit $chroma",
        match: {
            codec_id: "V_AV1",
            bit_depth: /^(?<bitDepth>10|12) bits/,
            chroma_subsampling: /^(4:2:0|(?<chroma>[0-9]:[0-9]:[0-9]))/
        },
        legacy: "AV1"
    },

    {
        name: "h265",
        match: {
            codec_id: "V_MPEGH/ISO/HEVC",
            bit_depth: "8 bits",
            chroma_subsampling: /^4:2:0/
        },
        legacy: "h265"
    },

    {
        name: "h265 $bitDepth-bit $chroma",
        match: {
            codec_id: "V_MPEGH/ISO/HEVC",
            bit_depth: /^(?<bitDepth>10|12) bits/,
            chroma_subsampling: /^(4:2:0|(?<chroma>[0-9]:[0-9]:[0-9]))/
        },
        legacy: "h265 $bitDepth-bit"
    },
];

const torrentType = document.querySelector("a.scaledImg > img").getAttribute("title");
const torrentTableColspan = 6;
if(allowedVideoTypes.indexOf(torrentType.replace("Live Action ", "")) !== -1){

    //Make page wider
    let contentStyle = document.getElementById("content").style;
    contentStyle["max-width"] = "1400px";
    contentStyle["width"] = "calc(100% - 50px)";

    let episodeCount = 0;
    document.querySelectorAll("ul.stats > li").forEach((item) => {
        let strongItem = item.querySelector("strong");
        if(strongItem !== null && strongItem.textContent === "Episodes:"){
            episodeCount = parseInt(item.querySelector("a").textContent);
        }
    });

    if(episodeCount === 0 && (torrentType === "Movie")){
        episodeCount = 1;
    }

    let torrentListing = [];

    document.querySelectorAll(".group_torrent").forEach((item) => {
        const linkSection = item.querySelector("td");
        const downloadLink = item.querySelector("a[title^='Download']");
        const [torrentEntry] = Array.from(linkSection.querySelectorAll("a")).slice(-1);

        const torrentId = parseInt(downloadLink.getAttribute("href").match(/\/torrent\/(?<torrent_id>[0-9]+)\/download/).groups.torrent_id);


        let tags = {
            audioCount: 1,
            freeleech: torrentEntry.querySelector("img[alt^='Freeleech!']") !== null,
            remastered: torrentEntry.querySelector("img[alt^='Remastered']") !== null,
            snatched: torrentEntry.textContent.match(/ - Snatched/) !== null
        };
        torrentEntry.textContent.replace("»", "").replace(" - Snatched", "").split(" | ").forEach((t) => {
            let tagEntry = t.trim();

            if(tagEntry === ""){
                return;
            }

            let match = null;

            if(!("source" in tags) && knownSources.indexOf(tagEntry) !== -1){
                tags.source = tagEntry;
            }else if(!("container" in tags) && knownContainers.some((i) => tagEntry.startsWith(i))){
                if((match = tagEntry.match(/^(?<container>[^(]+) \((?<region>[^)]+)\)$/)) !== null){
                    tags.container = match.groups.container;
                    tags.region = match.groups.region;
                }else{
                    tags.container = tagEntry;
                }
            }else if(!("videoCodec" in tags) && knownVideoCodecs.some((i) => tagEntry.startsWith(i))){
                tags.videoCodec = tagEntry;
            }else if(!("audioCodec" in tags) && knownAudioCodecs.some((i) => tagEntry.startsWith(i))){
                match = tagEntry.match(/^(?<codec>.+) (?<channels>[0-9.]+)$/)
                tags.audioCodec = match.groups.codec;
                tags.audioChannels = match.groups.channels.split(".").reduce((p, c) => parseInt(p) + parseInt(c));
            }else if(tagEntry.match(/^[0-9]+:[0-9]+$/) !== null){
                tags.aspectRatio = tagEntry;
            }else if(tagEntry.match(/^[0-9]+x[0-9]+$/) !== null || tagEntry.match(/^(720p|1080p|1080i|4K)$/) !== null){
                tags.resolution = tagEntry;
            }else if(tagEntry === "Dual Audio"){
                tags.audioCount = 2;
            }else if((match = tagEntry.match(/^(?<kind>(RAW|Hardsubs|Softsubs))( \()?(?<group>[^)]*)(\))?$/)) !== null){
                if(match.groups.kind !== "RAW"){
                    tags.subtitleType = match.groups.kind;
                }

                if(match.groups.group !== ""){
                    tags.group = match.groups.group;
                }
            }else{
                //console.log(tagEntry);
            }
        });

        let torrent = {
            id: torrentId,
            tags: tags,
            elements: {
                item: item,
                entry: torrentEntry,
                link: downloadLink,
            },
        };

       const dataSection = document.getElementById("torrent_" + torrentId);
       if(dataSection !== null){
           torrent.elements.data = dataSection;
           const descriptionSection = document.getElementById(torrentId + "_description");
           const filelistSection = document.getElementById(torrentId + "_filelist");
           const mediaInfoSection = document.getElementById(torrentId + "_mediainfo");

           if(descriptionSection !== null){
               torrent.elements.description = descriptionSection.querySelector("blockquote");
               torrent.description = torrent.elements.description.textContent;
           }
           if(filelistSection !== null){
               torrent.elements.filelist = filelistSection.querySelector("table");
               torrent.filelist = [];
               torrent.elements.filelist.querySelectorAll("tr").forEach((tableRow) => {
                   if(tableRow.querySelector("td > strong") !== null){
                       //Skip header
                       return;
                   }
                   torrent.filelist.push({
                       path: tableRow.querySelector("td").textContent,
                       size: tableRow.querySelector("td:last-of-type").textContent //TODO: convert back to bytes
                   })
               });
           }
           if(mediaInfoSection !== null){
               torrent.elements.mediainfo = mediaInfoSection;
               let m_list = [];
               torrent.elements.mediainfo.querySelectorAll("pre").forEach((mediainfoItem) => {
                   let m = parseMediaInfo(mediainfoItem.textContent);
                   if(m !== null){
                       m_list.push(m);
                   }
               });
               if(m_list.length > 0){
                   torrent.mediainfo = m_list;
                   torrent.mediainfoSource = "mediainfo";
               }
           }else if(descriptionSection !== null){
               //Find mediainfo tags
               torrent.elements.description.querySelectorAll("input.spoilerButton").forEach((e) => {
                   let t = e.parentElement.querySelector("div.spoiler").textContent.trim();
                   if(t.indexOf("General") === 0){
                       let m = parseMediaInfo(t);
                       if(m !== null){
                           if(!("mediainfo" in torrent)){
                               torrent.mediainfo = [];
                               torrent.mediainfoSource = "description spoiler";
                           }
                           torrent.mediainfo.push(m);
                       }
                   }
               });

               if(!("mediainfo" in torrent)){
                   //Fallback, find General tag
                   let t = torrent.elements.description.parentElement.textContent.trim();
                   let index = t.indexOf("General");
                   if(index !== -1){
                       let m = parseMediaInfo(t.substr(index));
                       if(m !== null){
                           if(!("mediainfo" in torrent)){
                               torrent.mediainfo = [];
                               torrent.mediainfoSource = "description";
                           }
                           torrent.mediainfo.push(m);
                       }
                   }
               }
           }

           torrentListing.push(torrent);
       }
    });

    {
        {
            let parentTd = document.querySelector("table.torrent_table tr > td");
            parentTd.insertAdjacentElement("beforebegin", document.createElement("td"));
            // Source + container + remux | Codec / Resolution / HDR | Audio + Dual + commentary | Text | OtherTags | Icons
            parentTd.setAttribute("colspan", torrentTableColspan.toString());

            document.querySelectorAll("table.torrent_table tr.edition_info > td").forEach((e) => {
                e.setAttribute("colspan", (torrentTableColspan + 1 + 4).toString());
            });
        }

        torrentListing.forEach((torrent) => {
            let parent = torrent.elements.link.parentElement;
            let td = document.createElement("td");

            torrent.elements.data.querySelector("td").setAttribute("colspan", (torrentTableColspan + 1 + 4).toString());

            parent.parentElement.insertAdjacentElement("beforebegin", td);
            parent.style["white-space"] = "nowrap";
            td.append(parent);

            Array.from(parent.childNodes).forEach((e) => {
                if(e.nodeType === Node.TEXT_NODE && ["[", "]"].includes(e.textContent.trim())){
                    e.remove();
                }
            });

        });
    }

    console.log(torrentListing);

    torrentListing.forEach((torrent) => {
        try {



            let infoCount = 0;
            let warningCount = 0;
            let dangerCount = 0;


            let tags = {

            };

            let warnings = {
                general: [],
                audio: [],
                video: [],
                text: []
            }

            let fileName = null;

            if("mediainfo" in torrent && torrent.mediainfo.length > 0 && "mediainfo.general.complete_name" in torrent.mediainfo[0].general){
                [fileName] = torrent.mediainfo[0].general.complete_name.split("/").slice(-1);
            }else{
                fileName = torrent.filelist[0].path;
            }

            //handle file tags
            fileName.split(".").forEach((p) => {
                if(p.toUpperCase() === "NF"){
                    tags.sourceName = "Netflix";
                }else if(p.toUpperCase() === "ATVP"){
                    tags.sourceName = "Apple TV+";
                }else if(p.toUpperCase() === "AMZN"){
                    tags.sourceName = "Amazon Video";
                }else if(p === "HDR"){
                    tags.videoHDR = "HDR";
                }else if(p === "HDR10"){
                    tags.videoHDR = "HDR10";
                }else if(p === "DV"){
                    tags.videoHDR = "HDR DV";
                }else if(p.toUpperCase() === "REMUX"){
                    tags.remux = true;
                }
            });

            fileName.split(/[ _\[\]]/).forEach((p) => {
                if(p.toUpperCase() === "NETFLIX"){
                    tags.sourceName = "Netflix";
                }else if(p === "HDR"){
                    tags.videoHDR = "HDR";
                }else if(p === "HDR10"){
                    tags.videoHDR = "HDR10";
                }else if(p === "DV"){
                    tags.videoHDR = "HDR DV";
                }else if(p.toUpperCase().indexOf("REMUX") !== -1){
                    tags.remux = true;
                }
            });

            let japaneseEpisodeMatch = fileName.match(/第[0-9.]+話/u);
            if(japaneseEpisodeMatch !== null){
                warnings.general.push(["warning", "Episode numbering is in Japanese format: example " + japaneseEpisodeMatch[0]]);
            }

            if("mediainfo" in torrent && torrent.mediainfo.length > 0){
                let mediainfo = torrent.mediainfo[0];

                let japaneseAudio = null;
                let otherAudio = null;
                let defaultAudio = null;

                let englishSubs = null;
                let defaultSubs = null;

                switch(mediainfo.general.format){
                    case "Matroska":
                        tags.container = "MKV";
                        break;
                    case "BDAV":
                        tags.container = "M2TS";
                        break;
                }

                if(torrent.mediainfoSource !== "mediainfo"){
                    warnings.general.push(["danger", "Mediainfo sourced from " + torrent.mediainfoSource + ". Consider reporting the torrent and providing it."])
                }


                let video = mediainfo.video[0];
                if(video !== null){
                    videoCodecs.every((codec) => {
                        let match = true;
                        let n = codec.name;
                        let l = codec.legacy;
                        let m = null;
                        for(const [key, value] of Object.entries(codec.match)){
                            if(value === null){
                                if(key in video){
                                    match = false;
                                    break;
                                }
                                continue;
                            }

                            if(!(key in video)){
                                match = false;
                                break;
                            }else if (value instanceof RegExp){
                                if((m = video[key].match(value)) === null){
                                    match = false;
                                    break;
                                }

                                if("groups" in m && typeof m.groups === "object"){
                                    for(const [k, v] of Object.entries(m.groups)){
                                        if(typeof v !== "undefined"){
                                            n = n.replace('$' + k, v);
                                            l = l.replace('$' + k, v);
                                        }else{
                                            n = n.replace('$' + k, "");
                                            l = l.replace('$' + k, "");
                                        }
                                    }
                                }
                            }else if (video[key] !== value){
                                match = false;
                                break;
                            }
                        }

                        if(match){
                            tags.videoCodec = Object.assign({}, codec);
                            tags.videoCodec.name = n.trim();
                            tags.videoCodec.legacy = l.trim();
                        }

                        return !match;
                    });

                    if("frame_rate" in video){
                        tags.videoFrameRate = video.frame_rate.split(" ")[0];
                    }else

                    if("original_frame_rate" in video){
                        tags.videoFrameRate = video.original_frame_rate.split(" ")[0];
                    }

                    let width = parseInt(video.width.replace(/[^0-9]/g, ""));
                    let height = parseInt(video.height.replace(/[^0-9]/g, ""));

                    if(((width <= 1280 && width >= 1200) || (width <= 960 && width >= 900)) && height > 480 && height <= 720){
                        tags.resolution = "720" + ((!("scan_type" in video) || video.scan_type === "Progressive") ? "p" : "i");
                    }else if(((width <= 1920 && width >= 1820) || (width <= 1440 && width >= 1340)) && height > 720 && height <= 1080){
                        tags.resolution = "1080" + ((!("scan_type" in video) || video.scan_type === "Progressive") ? "p" : "i");
                    }else if((width <= 3840 && width >= 3640) && height > 1080 && height <= 2160){
                        tags.resolution = "4K";
                    }else{
                        tags.resolution = width + "x" + height;
                    }

                    tags.aspectRatio = video.display_aspect_ratio;

                    if("color_primaries" in video && video.color_primaries === "BT.2020"){
                        tags.videoHDR = "HDR";
                    }

                    if("hdr_format" in video){
                        if(video.hdr_format.match(/Dolby Vision/) !== null){
                            tags.videoHDR = "HDR DV";
                        }else if(video.hdr_format.match(/SMPTE ST 2086/) !== null && video.hdr_format.match(/HDR10/) !== null){
                            tags.videoHDR = "HDR10";
                        }else if(video.hdr_format.match(/SMPTE ST 2094-40/) !== null && video.hdr_format.match(/HDR10/) !== null){
                            tags.videoHDR = "HDR10+";
                        }else if(video.hdr_format.match(/SL-HDR1/) !== null){
                            tags.videoHDR = "SL-HDR1";
                        }else if(video.hdr_format.match(/SL-HDR2/) !== null){
                            tags.videoHDR = "SL-HDR2";
                        }
                    }

                    if("writing_library" in video){
                        if(video.writing_library.match(/x265/) !== null){
                            tags.videoEncoder = "x265";
                        }else if(video.writing_library.match(/x264/) !== null){
                            tags.videoEncoder = "x264";
                            let versionMatch = video.writing_library.match(/ r(?<version>[0-9]+) /)
                            if(versionMatch !== null){
                                tags.videoEncoderVersion = parseInt(versionMatch.groups.version);
                            }
                        }else if(video.writing_library.match(/libaom/) !== null){
                            tags.videoEncoder = "libaom";
                        }else if(video.writing_library.match(/_nvenc/) !== null){
                            tags.videoEncoder = "NVENC";
                            warnings.video.push(["danger", "Found NVENC hardware-encoded stream"]);
                        }else if(video.writing_library.match(/_qsv/) !== null){
                            tags.videoEncoder = "QuickSync";
                            warnings.video.push(["danger", "Found QuickSync hardware-encoded stream"]);
                        }else if(video.writing_library.match(/_vaapi/) !== null){
                            tags.videoEncoder = "VAAPI";
                            warnings.video.push(["danger", "Found VAAPI hardware-encoded stream"]);
                        }else if(video.writing_library.match(/[^0-9A-F]/) !== null){
                            [tags.videoEncoder] = video.writing_library.split(" ");
                        }
                    }

                    //Detect probably H264 remuxes
                    try{
                        if(
                            !("remux" in tags) &&
                            !("encoding_settings" in video) && !("writing_library" in video) &&
                            video.codec_id === "V_MPEG4/ISO/AVC" && video.format_profile === "High@L4.1" &&
                            video.format_settings.match(/CABAC \/ [234] Ref Frames/) !== null && width === 1920 && height === 1080 &&
                            video.frame_rate_mode === "Constant" &&
                            (!("bits_pixel_frame" in video) || parseFloat(video.bits_pixel_frame) > 0.5)
                        ){
                            tags.remux = "probably";
                        }
                    }catch (e){

                    }

                    if("encoding_settings" in video){
                        let match = null;
                        if((match = video.encoding_settings.match(/crf=(?<crf>[0-9.]+)/)) !== null){
                            tags.videoCRF = parseFloat(match.groups.crf).toFixed(1);
                        }
                        if(video.encoding_settings.match(/rc=2pass/) !== null){
                            tags.videoCRF = "2pass";
                        }
                        if(!("remux" in tags) && video.codec_id === "V_MPEG4/ISO/AVC" && (match = video.format_profile.match(/(?<profile>(baseline|main)[ 0-9]*)@/i)) !== null){
                            warnings.video.push(["warning", "Found encode using profile=" + match.groups.profile + " on encoding settings"]);
                        }
                        if(video.encoding_settings.match(/cabac=0/) !== null){
                            warnings.video.push(["info", "Found encode with CABAC disabled"]);
                        }
                        if(video.encoding_settings.match(/mbtree=0/) !== null){
                            warnings.video.push(["info", "Found encode with mbtree disabled"]);
                        }
                        if(video.encoding_settings.match(/bframes=0/) !== null){
                            warnings.video.push(["info", "Found encode with bframes disabled"]);
                        }
                        if(video.encoding_settings.match(/me=dia/) !== null){
                            warnings.video.push(["info", "Found encode with me=dia"]);
                        }
                    }
                }

                mediainfo.audio.forEach((audio, index) => {
                    const isDefault = audio.default === "Yes";

                    if(isDefault){
                        defaultAudio = audio;
                    }
                    if("language" in audio && audio.language !== "Japanese" && audio.language !== "Unknown" && isDefault && torrentType.match(/Live Action/) === null){
                        warnings.audio.push(["info", "Default audio #"+(index+1)+" is not in Japanese"]);
                    }
                    if("title" in audio && audio.title.match(/comment/i) !== null){
                        tags.audioCommentary = true;
                    }


                    if(audio.language === "Japanese"){
                        if(japaneseAudio === null){ // Pick first
                            japaneseAudio = audio;
                        }else{
                            const oldChannels = parseInt(japaneseAudio.channels.replace(" channels", ""));
                            const channels = parseInt(audio.channels.replace(" channels", ""));
                            if(channels > oldChannels){
                                japaneseAudio = audio;
                            }
                        }
                    }else if(audio.language === "Unknown" || !("language" in audio)){
                        if(mediainfo.audio.length === 1){
                            japaneseAudio = audio;
                        }
                    }else{
                        if(otherAudio === null){ // Pick first
                            otherAudio = audio;
                        }else{
                            const oldChannels = parseInt(otherAudio.channels.replace(" channels", ""));
                            const channels = parseInt(audio.channels.replace(" channels", ""));
                            if(channels > oldChannels){
                                otherAudio = audio;
                            }
                        }
                    }

                    const ratio = ("stream_size" in audio) ? parseFloat(audio.stream_size.match(/\((?<percentage>[0-9.]+)%\)$/).groups.percentage) : null;

                    if(!("remux" in tags) && audio.format === "PCM"){
                        warnings.audio.push(["warning", "BLOAT: Audio track #"+(index+1)+" is uncompressed PCM."]);
                    }

                    if(!("remux" in tags) && (audio.format === "FLAC" || audio.format.match(/^DTS/) !== null) && (ratio === null || (ratio > 10))){
                        let bitDepth = parseInt(audio.bit_depth.replace(/[^0-9]/g, ""));
                        if(bitDepth > 16){
                            warnings.audio.push(["warning", "BLOAT: Audio track #"+(index+1)+" is "+audio.format+" with bit depth greater than 16-bit, found "+bitDepth+"-bit."]);
                        }
                    }
                });

                if(japaneseAudio !== otherAudio && otherAudio !== null && japaneseAudio !== null){
                    tags.audioCount = mediainfo.audio.length;
                }

                let audio = japaneseAudio !== null ? japaneseAudio : (defaultAudio !== null ? defaultAudio : otherAudio);
                if(audio !== null){
                    tags.audioChannels = parseInt(audio.channels.replace(" channels", ""));

                    audioCodecs.every((codec) => {
                        let match = true;
                        let n = codec.name;
                        let l = codec.legacy;
                        let m = null;
                        for(const [key, value] of Object.entries(codec.match)){
                            if(value === null){
                                if(key in audio){
                                    match = false;
                                    break;
                                }
                                continue;
                            }
                            if(!(key in audio)){
                                match = false;
                                break;
                            }else if (value instanceof RegExp){
                                if((m = audio[key].match(value)) === null){
                                    match = false;
                                    break;
                                }

                                if("groups" in m && typeof m.groups === "object"){
                                    for(const [k, v] of Object.entries(m.groups)){
                                        if(typeof v !== "undefined"){
                                            n = n.replace('$' + k, v);
                                            l = l.replace('$' + k, v);
                                        }else{
                                            n = n.replace('$' + k, "");
                                            l = l.replace('$' + k, "");
                                        }
                                    }
                                }
                            }else if (!(value instanceof RegExp) && audio[key] !== value){
                                match = false;
                                break;
                            }
                        }

                        if(match){
                            tags.audioCodec = Object.assign({}, codec);
                            tags.audioCodec.name = n.trim();
                            tags.audioCodec.legacy = l.trim();
                        }

                        return !match;
                    });
                }

                if("text" in mediainfo){
                    mediainfo.text.forEach((text) => {
                        const isSignsEntry = ("title" in text) ? text.title.match(/sign/i) !== null : false;
                        const isDefault = text.default === "Yes";
                        if(isSignsEntry && isDefault){
                            warnings.text.push(["warning", "Default subtitle is a Signs track"]);
                        }

                        if(isDefault){
                            defaultSubs = text;
                        }

                        if(!isSignsEntry && (text.language === "English" || ("title" in text && text.title.match(/english/i) !== null))){
                            if(englishSubs === null){
                                englishSubs = text;
                            }else{
                                if(text.codec_id === "S_TEXT/ASS" && englishSubs.codec_id !== "S_TEXT/ASS"){
                                    englishSubs = text;
                                }
                            }
                        }else if(mediainfo.text.length === 1 && (text.language === "Unknown" || !("language" in text))){
                            englishSubs = text;
                        }
                    });
                }


                let text = englishSubs !== null ? englishSubs : (defaultSubs !== null ? defaultSubs : (("text" in mediainfo && mediainfo.text.length > 0) ? mediainfo.text[0] : null));

                let isTrackExternal = false;
                let externalTrackFormat = null;
                torrent.filelist.every((file) => {
                    const ext = file.path.split(".").slice(-1)[0].toUpperCase();
                    if(ext === "ASS" || ext === "SRT" || ext === "SSA" || ext === "MKS" || ext === "VTT" || ext === "SUB"){
                        isTrackExternal = true;
                        externalTrackFormat = ext;
                    }
                    return !isTrackExternal;
                });

                if(text !== null){
                    tags.subtitleCodec = text.codec_id === "S_TEXT/UTF8" ? "SRT" : text.format;
                    tags.subtitleTitle = "title" in text ? text.title : "";

                    if(isTrackExternal === false && torrent.tags.subtitleType === "Softsubs" && englishSubs === null){
                        warnings.text.push(["warning", "Could not find English labeled subtitles, but labeled Softsubs"]);
                    }else{
                        tags.subtitleType = "Softsubs";
                    }
                }
                if((tags.subtitleType === "Softsubs" || torrent.tags.subtitleType === "Softsubs") && (text === null || englishSubs === null)){
                    if(isTrackExternal){
                        tags.subtitleType = "Softsubs";
                        tags.subtitleCodec = "External " + externalTrackFormat;
                        warnings.text.push(["info", "Subtitle track is external"]);
                    }else if("subtitleType" in torrent.tags && torrent.tags.subtitleType !== "Hardsubs"){
                        warnings.text.push(["warning", "Could not find subtitles either on file listing or disk, probably hardsubbed?"]);
                    }
                }

                if("menu" in mediainfo){
                    //Check for chapters and ordered chapters

                    let chapterCount = 0;
                    for(const [key, value] of Object.entries(mediainfo.menu)){
                        let entryCount = 0;
                        value.split(" / ").forEach((i) => {
                            i = i.trim();
                            if(i.indexOf(":") !== -1){
                                entryCount++;
                            }
                        });

                        if(entryCount > 1 && !("chapters" in tags)){
                            tags.chapters = "ordered";
                            warnings.general.push(["danger", "Found Ordered Chapters"]);
                        }
                        ++chapterCount;
                    }

                    if(!("chapters" in tags) && chapterCount > 1){
                        tags.chapters = chapterCount
                    }
                }

                //torrent.elements.entry.prepend("» ");

            }else{
                torrent.elements.item.style["font-style"] = "italic";
                //torrent.elements.item.style["text-decoration"] = "line-through";


                warnings.text.push(["danger", "No valid mediainfo section found. Report torrent with MediaInfo."]);
            }



            for(const [key, value] of Object.entries(torrent.tags)){
                if(!(key in tags)){
                    tags[key] = value;
                }
            }

            if(!("aspectRatio" in torrent.tags) && "aspectRatio" in tags){
                torrent.tags.aspectRatio = tags.aspectRatio;
            }

            let oldTagLine = getComparisonLine(torrent.tags);
            let newTagLine = getComparisonLine(tags);

            if(newTagLine !== oldTagLine){
                warnings.general.push(["danger", "Tag mismatch:\nold: " + oldTagLine + " !=\nnew: " + newTagLine]);
            }


            let messages = document.createElement("div");
            messages.append(document.createElement("br"));
            let h2 = document.createElement("h2");
            h2.textContent = "Warning Messages";
            messages.append(h2);

            for(const [key, value] of Object.entries(warnings)){
                if(value.length > 0){

                    let h3 = document.createElement("h3");
                    h3.textContent = key.toUpperCase();
                    messages.append(h3);

                    let messageList = document.createElement("ul");

                    for(let v of value){
                        let li = document.createElement("li");
                        li.style.float = "inherit";
                        let value = "";
                        if(Array.isArray(v)){

                            switch (v[0]){
                                case "info":
                                    infoCount++;
                                    value = "info: " + v[1];
                                    break;
                                case "warning":
                                    warningCount++;
                                    value = "warning: " + v[1];
                                    break;
                                case "danger":
                                    dangerCount++;
                                    value = "danger: " + v[1];
                                    break;
                            }
                        }else{
                            ++warningCount;
                            value = v;
                        }

                        if(value.includes("\n")){
                            let pre = document.createElement("pre");
                            pre.textContent = value;
                            li.append(pre);
                        }else{
                            li.textContent = value;
                        }

                        messageList.append(li);
                    }

                    messages.append(messageList);
                    messages.append(document.createElement("br"));
                }
            }
            messages.append(document.createElement("hr"));

            if(infoCount > 0 || warningCount > 0 || dangerCount > 0){
                if("description" in torrent.elements){
                    torrent.elements.description.prepend(messages);
                }
            }

            /*while(torrent.elements.entry.firstChild){
                torrent.elements.entry.firstChild.remove();
            }*/
            torrent.elements.entry.parentElement.remove();


            let entries = getEntryLine(tags, infoCount, warningCount, dangerCount);

            let lastTd = torrent.elements.item.querySelector("td");

            let onclickFn = (e) => {
                torrent.elements.data.classList.toggle("hide");
                e.preventDefault();
            };

            ["icons", "source", "video", "audio", "text", "other"].forEach((k) => {
                let td = document.createElement("td");
                td.style["white-space"] = "nowrap";
                if(k !== "other"){
                    td.style["width"] = "1%";
                }
                td.style["cursor"] = "pointer";

                let a = document.createElement("a");
                if(tags.snatched){
                    a.classList.add("snatched-torrent");
                }
                a.setAttribute("href", torrent.elements.entry.href);

                a.addEventListener("click", (e) => e.preventDefault());
                td.addEventListener("click", onclickFn);

                entries[k].forEach((e) => {
                    if(a.firstChild){
                        a.append(" / ");
                    }
                    a.append(e);
                });

                td.append(a);

                lastTd.insertAdjacentElement("afterend", td)
                lastTd = td;
            });


        }catch (e){
            console.log("Error:", e);
            console.log(torrent);
        }
    });
}

//21:28:16 <+AMM> subs, signage, chapters, titles, codecs, containers
// 21:28:20 <+AMM> What is good, what is bad