anchor.diff:      switch (components.length) {
         case 1:
           component1 = components[0];
  +        var lines = component1['lines'];
  +        var sy = component1['scaleY'];
  +        var sx =  component1['scaleX'];
           for (int y = 0; y < height; y++) {
  -          component1Line = component1['lines'][(y * component1['scaleY'] * scaleY).toInt()];
  +          component1Line = lines[(y * sy * scaleY).toInt()];
             for (int x = 0; x < width; x++) {
  -            Y = component1Line[(x * component1['scaleX'] * scaleX).toInt()];
  +            Y = component1Line[(x *sx * scaleX).toInt()];
               data[offset++] = Y;
             }
           }
           break;
         case 2:
  -        // PDF might compress two component data in custom colorspace
  +        // PDF might compress two component data in custom color-space
           component1 = components[0];
           component2 = components[1];
           for (int y = 0; y < height; y++) {
  
positive.code:         var sy3 = component3['scaleY'] * scaleY;
          var sy4 = component4['scaleY'] * scaleY;
  
          for (int y = 0; y < height; y++) {
            component1Line = component1['lines'][(y * sy1).toInt()];
            component2Line = component2['lines'][(y * sy2).toInt()];
            component3Line = component3['lines'][(y * sy3).toInt()];
            component4Line = component4['lines'][(y * sy4).toInt()];
            for (int x = 0; x < width; x++) {
              if (!colorTransform) {
                C = component1Line[(x * sx1).toInt()];
  
negative.code:                            Int32List dataIn) {
      Int32List p = dataIn;
  
      // de-quantize
      for (int i = 0; i < 64; i++) {
        p[i] = (coefBlock[i] * quantizationTable[i]);
      }
  
      const int w1 = 2841; // 2048*sqrt(2)*cos(1*pi/16)
      const int w2 = 2676; // 2048*sqrt(2)*cos(2*pi/16)
      const int w3 = 2408; // 2048*sqrt(2)*cos(3*pi/16)
      const int w5 = 1609; // 2048*sqrt(2)*cos(5*pi/16)
      const int w6 = 1108; // 2048*sqrt(2)*cos(6*pi/16)
      const int w7 = 565;  // 2048*sqrt(2)*cos(7*pi/16)
  
      const int w1pw7 = w1 + w7;
      const int w1mw7 = w1 - w7;
      const int w2pw6 = w2 + w6;
      const int w2mw6 = w2 - w6;
      const int w3pw5 = w3 + w5;
      const int w3mw5 = w3 - w5;
  
      const int r2 = 181; // 256/sqrt(2)
  
      // Horizontal 1-D IDCT.
      for (int y = 0, y8 = 0; y < 8; y++, y8 += 8) {
        // If all the AC components are zero, then the IDCT is trivial.
        if (p[y8 + 1] == 0 && p[y8 + 2] == 0 && p[y8 + 3] == 0 &&
            p[y8 + 4] == 0 && p[y8 + 5] == 0 && p[y8 + 6] == 0 && p[y8 + 7] == 0) {
          int dc = p[y8 + 0] << 3;
          p[y8 + 0] = dc;
          p[y8 + 1] = dc;
          p[y8 + 2] = dc;
          p[y8 + 3] = dc;
          p[y8 + 4] = dc;
          p[y8 + 5] = dc;
          p[y8 + 6] = dc;
          p[y8 + 7] = dc;
          continue;
        }
  
        // Prescale.
        int x0 = (p[y8 + 0] << 11) + 128;
        int x1 = p[y8 + 4] << 11;
        int x2 = p[y8 + 6];
        int x3 = p[y8 + 2];
        int x4 = p[y8 + 1];
        int x5 = p[y8 + 7];
        int x6 = p[y8 + 5];
        int x7 = p[y8 + 3];
  
        // Stage 1.
        int x8 = w7 * (x4 + x5);
        x4 = x8 + w1mw7 * x4;
        x5 = x8 - w1pw7 * x5;
        x8 = w3 * (x6 + x7);
        x6 = x8 - w3mw5 * x6;
        x7 = x8 - w3pw5 * x7;
  
        // Stage 2.
        x8 = x0 + x1;
        x0 -= x1;
        x1 = w6 * (x3 + x2);
        x2 = x1 - w2pw6 * x2;
        x3 = x1 + w2mw6 * x3;
        x1 = x4 + x6;
        x4 -= x6;
        x6 = x5 + x7;
        x5 -= x7;
  
        // Stage 3.
        x7 = x8 + x3;
        x8 -= x3;
        x3 = x0 + x2;
        x0 -= x2;
        x2 = (r2 * (x4 + x5) + 128) >> 8;
        x4 = (r2 * (x4 - x5) + 128) >> 8;
  
        // Stage 4.
        p[y8 + 0] = (x7 + x1) >> 8;
        p[y8 + 1] = (x3 + x2) >> 8;
        p[y8 + 2] = (x0 + x4) >> 8;
        p[y8 + 3] = (x8 + x6) >> 8;
        p[y8 + 4] = (x8 - x6) >> 8;
        p[y8 + 5] = (x0 - x4) >> 8;
        p[y8 + 6] = (x3 - x2) >> 8;
        p[y8 + 7] = (x7 - x1) >> 8;
      }
  
      // Vertical 1-D IDCT.
      for (int x = 0; x < 8; x++) {
        // Prescale.
        int y0 = (p[8 * 0 + x] << 8) + 8192;
        int y1 = p[8 * 4 + x] << 8;
        int y2 = p[8 * 6 + x];
        int y3 = p[8 * 2 + x];
        int y4 = p[8 * 1 + x];
        int y5 = p[8 * 7 + x];
        int y6 = p[8 * 5 + x];
        int y7 = p[8 * 3 + x];
  
        // Stage 1.
        int y8 = w7 * (y4 + y5) + 4;
        y4 = (y8 + w1mw7 * y4) >> 3;
        y5 = (y8 - w1pw7 * y5) >> 3;
        y8 = w3 * (y6 + y7) + 4;
        y6 = (y8 - w3mw5 * y6) >> 3;
        y7 = (y8 - w3pw5 * y7) >> 3;
  
        // Stage 2.
        y8 = y0 + y1;
        y0 -= y1;
        y1 = w6 * (y3 + y2) + 4;
        y2 = (y1 - w2pw6 * y2) >> 3;
        y3 = (y1 + w2mw6 * y3) >> 3;
        y1 = y4 + y6;
        y4 -= y6;
        y6 = y5 + y7;
        y5 -= y7;
  
        // Stage 3.
        y7 = y8 + y3;
        y8 -= y3;
        y3 = y0 + y2;
        y0 -= y2;
        y2 = (r2 * (y4 + y5) + 128) >> 8;
        y4 = (r2 * (y4 - y5) + 128) >> 8;
  
        // Stage 4.
        p[8 * 0 + x] = (y7 + y1) >> 14;
        p[8 * 1 + x] = (y3 + y2) >> 14;
        p[8 * 2 + x] = (y0 + y4) >> 14;
        p[8 * 3 + x] = (y8 + y6) >> 14;
        p[8 * 4 + x] = (y8 - y6) >> 14;
        p[8 * 5 + x] = (y0 - y4) >> 14;
        p[8 * 6 + x] = (y3 - y2) >> 14;
        p[8 * 7 + x] = (y7 - y1) >> 14;
      }
  
      // convert to 8-bit integers
      for (int i = 0; i < 64; ++i) {
        int b = p[i];
        dataOut[i] = b < -128 ? 0 : b > 128 ? 255 : b + 128;
      }
    }
  
  