MacOS vs Linux discrepancy

devster · Post by **devster** » 18 Mar 2020, 00:06

I'm testing the recent 4.9.0 release.
I have a fairly complex format:

{
  def norm = { it.replaceAll(/[`´‘’ʻ""“”]/, "'")
                 .replaceAll(/[|]/, " - ")
                 .replaceAll(/[?]/, "\uFE56")
                 .replaceAll(/[*\p{Zs}]+/, " ")
                 .replaceAll(/\b[IiVvXx]+\b/, { it.upper() })
                 .replaceAll(/\b[0-9](?i:th|nd|rd)\b/, { it.lower() }) }

  def transl = { it.transliterate("Any-Latin; NFD; NFC; Title") }
  def isLatin = { java.text.Normalizer.normalize(it, java.text.Normalizer.Form.NFD)
                                      .replaceAll(/\p{InCombiningDiacriticalMarks}+/, "") ==~ /^\p{InBasicLatin}+$/ }

  Boolean isEng = any{ audio.language.first() ==~ /en/ }{ true }
  Boolean isJpn = any{ languages.first().ISO2 ==~ /ja/ || audio.language.first() ==~ /ja/ }{ false }

  // WARNING: any db.{AniDB,TheTVDB} binding requires FileBot 4.8.6 or above
  String mainTitle = any{ db.TheTVDB.n }{ norm(n).colon(" - ").replaceTrailingBrackets() }
  String primTitle = norm(primaryTitle).colon(" - ")

  public static String surround(String self, Character left = "(", Character right = ")") {
    return left + self + right
  }

allOf
  { "Anime" }
  { allOf
      { mainTitle }
      { db.TheTVDB.y.toString().surround() }
    .join(" ") }
  {
    if (episode.special) {
      "Specials"
    } else {
      allOf
        { ["Season", db.TheTVDB.s].join(" ") }
        { if (mainTitle != primTitle) primTitle.surround("[", "]") }
        { db.TheTVDB.sy.bounds().join("-").surround() }
      .join(" ")
    }
  }
  { allOf
  	{ allOf
        { def grp = net.filebot.media.MediaDetection.releaseInfo.getReleaseGroup(fn.replaceAll(/\[.*\]$/, ""))
          (grp) ? "[$grp]" : "[$group]" }
        { mainTitle }
      .join(" ") }
    {
      if (episode.special) {
        "S$special"
      } else {
        any
          { allOf
              { db.TheTVDB.sxe }
              { db.TheTVDB.absolute.pad(2).surround() }
            .join(" ") }
          { absolute.pad(2) }
      }
    }
    { allOf
      {
        def trLang = any{ if (isJpn) "x-jat" }{ if (isEng) "eng" }{ audio.language.first() }{"eng"}
        switch (trLang) {
          case { it == "x-jat" }:
          allOf
            { norm(localize."$trLang".t).colon(", ").slash("\u2571") }
            { "[" + norm(t).colon(", ").slash("\u2571") + "]" }
          .join(" ")
          break
        case { it == "eng" }:
          norm(t).colon(", ").slash("\u2571")
          break
        default:
          norm(localize."$trLang".t).colon(", ").slash("\u2571")
        }
      }
      { tags.join(", ").replaceAll(/^/, " - ") }
      { "PT $pi" }
      { allOf
        { allOf
          { allOf
              { vf }
              { vc }
              {
                def _HDRMap = [
                  "HDR10": "HDR10",
                  "SMPTE ST 2086": "HDR10",
                  "SMPTE ST 2094 App 4": "HDR10+",
                  "Dolby Vision / SMPTE ST 2086": "Dolby Vision",
                  "Dolby Vision / HDR10": "Dolby Vision",
                  "SL-HDR1": "SL-HDR1",
                  "SL-HDR2": "SL-HDR2",
                ]
                def vid = video.first()
                if (bitdepth > 8) {
                  String _HDR
                  switch (vid) {
                    case { it.findAll { p -> p.key =~ /^HDR_/ }.size() > 0 }:
                      _HDR = any
                        { vid["HDR_Format_Commercial"] }
                        { vid["HDR_Format"] }
                        { hdr }
                        { null }
                      _HDRMap.find { k, v ->
                        k =~ _HDR
                      }?.value
                      break
                    case { it["transfer_characteristics"].findMatch(/HLG/) }:
                      "HLG"
                      break
                    case { it["transfer_characteristics"] == "PQ" && it["colour_primaries"] == "BT.2020" }:
                      "HDR"
                      break
                    default:
                      "$bitdepth-bit"
                    break
                  }
                }
              }
            .join(" ")
          }
          {
            def mCFP = [
              "FLAC": "FLAC",
              "PCM": "PCM",
              "MPEG Audio Layer 3": "MP3",
              "AAC LC": "AAC LC",
              "AAC LC SBR": "HE-AAC",
              "AAC LC SBR PS": "HE-AACv2",
              "AC-3 Dep": "E-AC-3+Dep",
              "AC-3 Blu-ray Disc Dep": "E-AC-3+Dep",
              "E-AC-3 Blu-ray Disc Dep": "E-AC-3+Dep",
              "E-AC-3 Dep": "E-AC-3+Dep",
              "E-AC-3 JOC": "E-AC-3 JOC",
              "DTS XBR": "DTS-HD HRA",
              "DTS ES": "DTS-ES Matrix",
              "DTS ES XBR": "DTS-HD HRA",
              "DTS ES XXCH XBR": "DTS-HD HRA",
              "DTS ES XXCH": "DTS-ES Discrete",
              "DTS ES XXCH XLL": "DTS-HD MA",
              "DTS XLL": "DTS-HD MA",
              "DTS XLL X": "DTS-X",
              "MLP FBA": "TrueHD",
              "MLP FBA 16-ch": "TrueHD",
              "DTS 96/24": "DTS 96-24",
            ]

            audio.collect { au ->
              String _ac = any
                            { allOf
                                { any{ au["Format/String"] }{ au["Format"] } }
                                { au["Format_Profile"] }
                                { au["Format_AdditionalFeatures"] }
                              .collect{ it.tokenize() }.flatten().unique().join(" ") }
                            { au["Format_Commercial"] }
              String _aco = any{ au["Codec_Profile"] }{ au["Format_Profile"] }{ au["Format_Commercial"] }
              def _fAtmos = any{ audio.FormatCommercial =~ /(?i)atmos/ }{ false }
              def _oAtmos = any{ audio.NumberOfDynamicObjects }{ false }
              String isAtmos = (_fAtmos || _oAtmos) ? "Atmos" : null
              String    _channels = any
                                      { au["ChannelPositions/String2"] }
                                      { au["Channel(s)_Original"] }
                                      { au["Channel(s)"] }
              String    _ch
              Object    splitCh = _channels =~ /^(?i)object.based$/ ? "Object Based" :
                                  _channels.tokenize("\\/\\.")

              String    chSimple = any{ au["Channel(s)"] }{ au["Channel(s)/String"].replaceAll("channels", "") }

              switch (splitCh) {
                case { it instanceof String }:
                  _ch = allOf{ splitCh }{ chSimple + "ch" }.join(" ")
                  break

                case { it.size > 4 }:
                  def wide = splitCh.takeRight(1)
                  Double main = splitCh.take(4)*.toDouble().inject(0, { a, b -> a + b })
                  Double sub = Double.parseDouble("0." + wide.last())
                  _ch = (main + sub).toBigDecimal().setScale(1, java.math.RoundingMode.HALF_UP).toString()
                  break

                case { it.size > 1 }:
                  Double sub = Double.parseDouble(splitCh.takeRight(2).join("."))
                  _ch = splitCh.take(2)*.toDouble().plus(sub).inject(0, { a, b -> a + b })
                              .toBigDecimal().setScale(1, java.math.RoundingMode.HALF_UP).toString()
                  break

                default:
                  _ch = splitCh.first().toDouble()
              }

              def stream = allOf
                { allOf{ _ch }{ au["NumberOfDynamicObjects"] + "obj" }.join("+") }
                { allOf{ mCFP.get(_ac, _ac) }{isAtmos}.join("+") }
                { def _lang = any{ au["Language"] }{ video.first()["Language"] }
                  net.filebot.Language.findLanguage(_lang).ISO3.upperInitial() }
              def ret = [:]
              ret.id = any{ au["StreamKindId"] }{ au["StreamKindPos"] }{ au["ID"] }
              ret.data = stream
              return ret
            }.toSorted{ it.id }.collect{ it.data }*.join(" ").join(", ") }
            { def fileURL = new URL("file:///scripts/websources.txt")
              def file = new File(fileURL.toURI())
              def websources = file.exists() ? lines(file).join("|") : null
              def isWeb = (source ==~ /WEB.*/)
              def lfr = { if (isWeb) fn.match(/($websources)\.(?i)WEB/) }
              return allOf{ lfr }{ source }.join(".") }
          .join(" - ").surround("[", "]") }
        { "[$crc32]" }
        { def ed = fn.findAll(/(?i)repack|proper/)*.upper().join(".")
          if (ed) { ".$ed" } }
        {subt}
        .join("") }
      .join(" ") }
    .join(" - ") }
  .join("/") }

which I'm using on MacOS without issues, see link > https://dsc.cloud/d38828/Screen-Recordi ... -53-34.mp4
File I'm using to test is named

[HorribleSubs] Mob Psycho 100 II - EP01 - Biribiri, Dareka ga Mite Iru [Ripped Apart, Someone Is Watching] [720p x264 - 2.0 AAC LC Jpn][0AE0673C].mkv

which I can rename to:

Anime/Mob Psycho 100 (2016)/Season 2 [Mob Psycho 100 II] (2019)/[HorribleSubs] Mob Psycho 100 - 2x01 (13) - Biribiri, Dareka ga Mite Iru [Ripped Apart, Someone Is Watching] [720p x264 - 2.0 AAC LC Jpn][0AE0673C].mkv

again on MacOS.
However, when I try on Linux, this is what I get:

MacOS vs Linux discrepancy

MacOS vs Linux discrepancy

Re: MacOS vs Linux discrepancy

Re: MacOS vs Linux discrepancy

Re: MacOS vs Linux discrepancy

Re: MacOS vs Linux discrepancy

Re: MacOS vs Linux discrepancy