ExrPart constructor

ExrPart(bool _tiled, InputBuffer input)

Implementation

ExrPart(this._tiled, InputBuffer input) {
  //_type = _tiled ? ExrPart.TYPE_TILE : ExrPart.TYPE_SCANLINE;

  while (true) {
    final name = input.readString();
    if (name.isEmpty) {
      break;
    }

    final type = input.readString();
    final size = input.readUint32();
    final value = input.readBytes(size);

    attributes[name] = ExrAttribute(name, type, size, value);

    switch (name) {
      case 'channels':
        while (true) {
          final channel = ExrChannel(value);
          if (!channel.isValid) {
            break;
          }
          channels.add(channel);
        }
        break;
      case 'chromaticities':
        chromaticities = Float32List(8);
        chromaticities[0] = value.readFloat32();
        chromaticities[1] = value.readFloat32();
        chromaticities[2] = value.readFloat32();
        chromaticities[3] = value.readFloat32();
        chromaticities[4] = value.readFloat32();
        chromaticities[5] = value.readFloat32();
        chromaticities[6] = value.readFloat32();
        chromaticities[7] = value.readFloat32();
        break;
      case 'compression':
        _compressionType = value.readByte();
        if (_compressionType > 7) {
          throw ImageException('EXR Invalid compression type');
        }
        break;
      case 'dataWindow':
        dataWindow = [
          value.readInt32(),
          value.readInt32(),
          value.readInt32(),
          value.readInt32()
        ];
        width = (dataWindow[2] - dataWindow[0]) + 1;
        height = (dataWindow[3] - dataWindow[1]) + 1;
        break;
      case 'displayWindow':
        displayWindow = [
          value.readInt32(),
          value.readInt32(),
          value.readInt32(),
          value.readInt32()
        ];
        break;
      case 'lineOrder':
        //_lineOrder = value.readByte();
        break;
      case 'pixelAspectRatio':
        pixelAspectRatio = value.readFloat32();
        break;
      case 'screenWindowCenter':
        screenWindowCenterX = value.readFloat32();
        screenWindowCenterY = value.readFloat32();
        break;
      case 'screenWindowWidth':
        screenWindowWidth = value.readFloat32();
        break;
      case 'tiles':
        _tileWidth = value.readUint32();
        _tileHeight = value.readUint32();
        final mode = value.readByte();
        _tileLevelMode = mode & 0xf;
        _tileRoundingMode = (mode >> 4) & 0xf;
        break;
      case 'type':
        final s = value.readString();
        if (s == 'deepscanline') {
          //this._type = TYPE_DEEP_SCANLINE;
        } else if (s == 'deeptile') {
          //this._type = TYPE_DEEP_TILE;
        } else {
          throw ImageException('EXR Invalid type: $s');
        }
        break;
      default:
        break;
    }
  }

  if (_tiled) {
    _numXLevels = _calculateNumXLevels(left, right, top, bottom);
    _numYLevels = _calculateNumYLevels(left, right, top, bottom);
    if (_tileLevelMode != RIPMAP_LEVELS) {
      _numYLevels = 1;
    }

    _numXTiles = _calculateNumTiles(
        _numXLevels!, left, right, _tileWidth, _tileRoundingMode);
    _numYTiles = _calculateNumTiles(
        _numYLevels!, top, bottom, _tileHeight, _tileRoundingMode);

    _bytesPerPixel = _calculateBytesPerPixel();
    _maxBytesPerTileLine = _bytesPerPixel * _tileWidth!;
    //_tileBufferSize = _maxBytesPerTileLine * _tileHeight;

    _compressor = ExrCompressor(
        _compressionType, this, _maxBytesPerTileLine, _tileHeight);

    var lx = 0;
    var ly = 0;
    _offsets = List<Uint32List>.generate(_numXLevels! * _numYLevels!, (l) {
      final result = Uint32List(_numXTiles![lx]! * _numYTiles![ly]!);
      ++lx;
      if (lx == _numXLevels) {
        lx = 0;
        ++ly;
      }
      return result;
    });
  } else {
    _bytesPerLine = Uint32List(height! + 1);
    for (var ch in channels) {
      final nBytes = ch.size * width! ~/ ch.xSampling;
      for (var y = 0; y < height!; ++y) {
        if ((y + top) % ch.ySampling == 0) {
          _bytesPerLine[y] += nBytes;
        }
      }
    }

    var maxBytesPerLine = 0;
    for (var y = 0; y < height!; ++y) {
      maxBytesPerLine = max(maxBytesPerLine, _bytesPerLine[y]);
    }

    _compressor = ExrCompressor(_compressionType, this, maxBytesPerLine);

    _linesInBuffer = _compressor!.numScanLines();
    //_lineBufferSize = maxBytesPerLine * _linesInBuffer;

    _offsetInLineBuffer = Uint32List(_bytesPerLine.length);

    var offset = 0;
    for (var i = 0; i <= _bytesPerLine.length - 1; ++i) {
      if (i % _linesInBuffer! == 0) {
        offset = 0;
      }
      _offsetInLineBuffer![i] = offset;
      offset += _bytesPerLine[i];
    }

    final numOffsets = ((height! + _linesInBuffer!) ~/ _linesInBuffer!) - 1;
    _offsets = [Uint32List(numOffsets)];
  }
}