dflt method

dynamic dflt(List<int> dat, int lvl, dynamic plvl, dynamic pre, int post, Map st,)

Implementation

dflt(List<int> dat, int lvl, plvl, pre, int post, Map st) {
  int s = st['z'] ?? dat.length;
  u8 o = u8(pre + s + 5 * (1 + (s / 7000)).ceil() + post);
  // writing to this writes to the output buffer
  u8 w = o.sublist(pre, o.length - post);
  var lst = st['l'];
  int pos = (st['r'] ?? 0) & 7;
  if (lvl != 0) {
    if (pos != 0){
      w[0] = st['r'] >> 3;
    }
    var opt = deo[lvl - 1];
    int n = opt >> 13, c = opt & 8191;
    int msk_1 = (1 << plvl) - 1;
    //    prev 2-byte val map    curr 2-byte val map
    u16 prev = st['p'] ?? u16(32768), head = st['h'] ?? u16(msk_1 + 1);
    int bs1_1 = (plvl / 3).ceil(), bs2_1 = 2 * bs1_1;
    int hsh(i) { return (dat[i] ^ (dat[i + 1] << bs1_1) ^ (dat[i + 2] << bs2_1)) & msk_1; };
    // 24576 is an arbitrary number of maximum symbols per block
    // 424 buffer for last block
    i32 syms = i32(25000);
    // length/literal freq   distance freq
    u16 lf = u16(288), df = u16(32);
    //  l/lcnt  exbits  index          l/lind  waitdx          blkpos
    int lc_1 = 0, eb = 0, i = st['i'] ?? 0, li = 0, wi = st['w'] ?? 0, bs = 0;
    for (; i + 2 < s; ++i) {
      // hash value
      int hv = hsh(i);
      // index mod 32768    previous index mod
      int imod = i & 32767;
      var pimod = head[hv];
      prev[imod] = pimod;
      head[hv] = imod;
      // We always should modify head and prev, but only add symbols if
      // this data is not yet processed ("wait" for wait index)
      if (wi <= i) {
        // bytes remaining
        int rem = s - i;
        if ((lc_1 > 7000 || li > 24576) && (rem > 423 || lst == null)) {
          pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);
          li = lc_1 = eb = 0; bs = i;
          for (int j = 0; j < 286; ++j){
            lf[j] = 0;
          }
          for (int j = 0; j < 30; ++j){
            df[j] = 0;
          }
        }
        //  len    dist   chain
        int l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;
        if (rem > 2 && hv == hsh(i - dif)) {
          int maxn = math.min<int>(n, rem) - 1;
          int maxd = math.min<int>(32767, i);
          // max possible length
          // not capped at dif because decompressors implement "rolling" index population
          int ml = math.min<int>(258, rem);
          while (dif <= maxd && --ch_1 >= 0 && imod != pimod) {
            if (dat[i + l] == dat[i + l - dif]) {
              int nl = 0;
              for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl);
              if (nl > l) {
                l = nl; d = dif;
                // break out early when we reach "nice" (we are satisfied enough)
                if (nl > maxn){
                  break;
                }
                // now, find the rarest 2-byte sequence within this
                // length of literals and search for that instead.
                // Much faster than just using the start
                int mmd = math.min<int>(dif, nl - 2);
                int md = 0;
                for (int j = 0; j < mmd; ++j) {
                  int ti = i - dif + j & 32767;
                  int pti = prev[ti];
                  int cd = ti - pti & 32767;
                  if (cd > md){
                    md = cd;
                    pimod = ti;
                  }
                }
              }
            }
            // check the previous match
            imod = pimod;
            pimod = prev[imod];
            dif += imod - pimod & 32767;
          }
        }
        // d will be nonzero only when a match was found
        if (d != 0) {
          // store both dist and len data in one int32
          // Make sure this is recognized as a len/dist with 28th bit (2^28)
          syms[li++] = 268435456 | (revfl[l] << 18) | revfd[d];
          int lin = revfl[l] & 31, din = revfd[d] & 31;
          eb += fleb[lin] + fdeb[din];
          ++lf[257 + lin];
          ++df[din];
          wi = i + l;
          ++lc_1;
        }
        else {
          syms[li++] = dat[i];
          ++lf[dat[i]];
        }
      }
    }
    for (i = math.max<int>(i, wi); i < s; ++i) {
        syms[li++] = dat[i];
        ++lf[dat[i]];
    }
    pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);
    if (lst == null) {
      st['r'] = (pos & 7) | w[(pos ~/ 8) | 0] << 3;
      // shft(pos) now 1 less if pos & 7 != 0
      pos -= 7;
      st['h'] = head;
      st['p'] = prev;
      st['i'] = i;
      st['w'] = wi;
    }
  }
  else {
    for (int i = st['w'] ?? 0; i < s + lst; i += 65535) {
      // end
      int e = i + 65535;
      if (e >= s) {
        // write final block
        w[(pos ~/ 8) | 0] = lst;
        e = s;
      }
      pos = wfblk(w, pos + 1, dat.sublist(i, e));
    }
    st['i'] = s;
  }
  return slc(o, 0, pre + shft(pos) + post);
}