src/main/java/org/apache/pdfbox/jbig2/segments/PatternDictionary.java

/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.pdfbox.jbig2.segments;

import java.awt.Rectangle;
import java.io.IOException;
import java.util.ArrayList;

import org.apache.pdfbox.jbig2.Bitmap;
import org.apache.pdfbox.jbig2.Dictionary;
import org.apache.pdfbox.jbig2.SegmentHeader;
import org.apache.pdfbox.jbig2.err.InvalidHeaderValueException;
import org.apache.pdfbox.jbig2.image.Bitmaps;
import org.apache.pdfbox.jbig2.io.SubInputStream;
import org.apache.pdfbox.jbig2.util.log.Logger;
import org.apache.pdfbox.jbig2.util.log.LoggerFactory;

/**
 * This class represents the segment type "Pattern dictionary", 7.4.4.
 */
public class PatternDictionary implements Dictionary {

  private final Logger log = LoggerFactory.getLogger(PatternDictionary.class);

  private SubInputStream subInputStream;

  /** Segment data structure (only necessary if MMR is used) */
  private long dataHeaderOffset;
  private long dataHeaderLength;
  private long dataOffset;
  private long dataLength;

  private short[] gbAtX = null;
  private short[] gbAtY = null;

  /** Pattern dictionary flags, 7.4.4.1.1 */
  private boolean isMMREncoded;
  private byte hdTemplate;

  /** Width of the patterns in the pattern dictionary, 7.4.4.1.2 */
  private short hdpWidth;

  /** Height of the patterns in the pattern dictionary, 7.4.4.1.3 */
  private short hdpHeight;

  /** Decoded bitmaps, stored to be used by segments, that refer to it */
  private ArrayList<Bitmap> patterns;

  /**
   * Largest gray-scale value, 7.4.4.1.4
   * 
   * Value: one less than the number of patterns defined in this pattern dictionary
   */
  private int grayMax;

  private void parseHeader() throws IOException, InvalidHeaderValueException {
    /* Bit 3-7 */
    subInputStream.readBits(5); // Dirty read ...

    /* Bit 1-2 */
    readTemplate();

    /* Bit 0 */
    readIsMMREncoded();

    readPatternWidthAndHeight();

    readGrayMax();

    /* Segment data structure */
    computeSegmentDataStructure();

    this.checkInput();
  }

  private void readTemplate() throws IOException {
    /* Bit 1-2 */
    hdTemplate = (byte) subInputStream.readBits(2);
  }

  private void readIsMMREncoded() throws IOException {
    /* Bit 0 */
    if (subInputStream.readBit() == 1) {
      isMMREncoded = true;
    }
  }

  private void readPatternWidthAndHeight() throws IOException {
    hdpWidth = subInputStream.readByte();
    hdpHeight = subInputStream.readByte();
  }

  private void readGrayMax() throws IOException {
    grayMax = (int) (subInputStream.readBits(32) & 0xffffffff);
  }

  private void computeSegmentDataStructure() throws IOException {
    dataOffset = subInputStream.getStreamPosition();
    dataHeaderLength = dataOffset - dataHeaderOffset;
    dataLength = subInputStream.length() - dataHeaderLength;
  }

  private void checkInput() throws InvalidHeaderValueException {
    if (hdpHeight < 1 || hdpWidth < 1) {
      throw new InvalidHeaderValueException("Width/Heigth must be greater than zero.");
    }

    if (isMMREncoded) {
      if (hdTemplate != 0) {
        log.info("hdTemplate should contain the value 0");
      }
    }
  }

  /**
   * This method decodes a pattern dictionary segment and returns an array of {@link Bitmap} s. Each
   * of this {@link Bitmap}s is a pattern.<br>
   * The procedure is described in 6.7.5 (page 43).
   * 
   * @return An array of {@link Bitmap}s as result of the decoding procedure.
   */
  public ArrayList<Bitmap> getDictionary() throws IOException, InvalidHeaderValueException {
    if (null == patterns) {

      if (!isMMREncoded) {
        setGbAtPixels();
      }

      // 2)
      final GenericRegion genericRegion = new GenericRegion(subInputStream);
      genericRegion.setParameters(isMMREncoded, dataOffset, dataLength, hdpHeight, (grayMax + 1) * hdpWidth,
          hdTemplate, false, false, gbAtX, gbAtY);

      final Bitmap collectiveBitmap = genericRegion.getRegionBitmap();

      // 4)
      extractPatterns(collectiveBitmap);
    }

    return patterns;
  }

  private void extractPatterns(Bitmap collectiveBitmap) {
    // 3)
    int gray = 0;
    patterns = new ArrayList<Bitmap>(grayMax + 1);

    // 4)
    while (gray <= grayMax) {
      // 4) a) Retrieve a pattern bitmap by extracting it out of the collective bitmap
      final Rectangle roi = new Rectangle(hdpWidth * gray, 0, hdpWidth, hdpHeight);
      final Bitmap patternBitmap = Bitmaps.extract(roi, collectiveBitmap);
      patterns.add(patternBitmap);

      // 4) b)
      gray++;
    }
  }

  private void setGbAtPixels() {
    if (hdTemplate == 0) {
      gbAtX = new short[4];
      gbAtY = new short[4];
      gbAtX[0] = (short) -hdpWidth;
      gbAtY[0] = 0;
      gbAtX[1] = -3;
      gbAtY[1] = -1;
      gbAtX[2] = 2;
      gbAtY[2] = -2;
      gbAtX[3] = -2;
      gbAtY[3] = -2;

    } else {
      gbAtX = new short[1];
      gbAtY = new short[1];
      gbAtX[0] = (short) -hdpWidth;
      gbAtY[0] = 0;
    }
  }

  public void init(SegmentHeader header, SubInputStream sis) throws InvalidHeaderValueException, IOException {
    this.subInputStream = sis;
    parseHeader();
  }

  protected boolean isMMREncoded() {
    return isMMREncoded;
  }

  protected byte getHdTemplate() {
    return hdTemplate;
  }

  protected short getHdpWidth() {
    return hdpWidth;
  }

  protected short getHdpHeight() {
    return hdpHeight;
  }

  protected int getGrayMax() {
    return grayMax;
  }
}