src/main/java/org/apache/pdfbox/jbig2/segments/PageInformation.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.io.IOException;

import org.apache.pdfbox.jbig2.SegmentData;
import org.apache.pdfbox.jbig2.SegmentHeader;
import org.apache.pdfbox.jbig2.err.InvalidHeaderValueException;
import org.apache.pdfbox.jbig2.io.SubInputStream;
import org.apache.pdfbox.jbig2.util.CombinationOperator;
import org.apache.pdfbox.jbig2.util.log.Logger;
import org.apache.pdfbox.jbig2.util.log.LoggerFactory;

/**
 * This class represents the segment type "Page information", 7.4.8 (page 73).
 */
public class PageInformation implements SegmentData {

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

  private SubInputStream subInputStream;

  /** Page bitmap width, four byte, 7.4.8.1 */
  private int bitmapWidth;

  /** Page bitmap height, four byte, 7.4.8.2 */
  private int bitmapHeight;

  /** Page X resolution, four byte, 7.4.8.3 */
  private int resolutionX;

  /** Page Y resolution, four byte, 7.4.8.4 */
  private int resolutionY;

  /** Page segment flags, one byte, 7.4.8.5 */
  private boolean combinationOperatorOverrideAllowed;
  private CombinationOperator combinationOperator;
  private boolean requiresAuxiliaryBuffer;
  private short defaultPixelValue;
  private boolean mightContainRefinements;
  private boolean isLossless;

  /** Page striping information, two byte, 7.4.8.6 */
  private boolean isStriped;
  private short maxStripeSize;

  private void parseHeader() throws IOException, InvalidHeaderValueException {

    readWidthAndHeight();
    readResolution();

    /* Bit 7 */
    subInputStream.readBit(); // dirty read

    /* Bit 6 */
    readCombinationOperatorOverrideAllowed();

    /* Bit 5 */
    readRequiresAuxiliaryBuffer();

    /* Bit 3-4 */
    readCombinationOperator();

    /* Bit 2 */
    readDefaultPixelvalue();

    /* Bit 1 */
    readContainsRefinement();

    /* Bit 0 */
    readIsLossless();

    /* Bit 15 */
    readIsStriped();

    /* Bit 0-14 */
    readMaxStripeSize();

    this.checkInput();

  }

  private void readResolution() throws IOException {
    resolutionX = (int) subInputStream.readBits(32) & 0xffffffff;
    resolutionY = (int) subInputStream.readBits(32) & 0xffffffff;
  }

  private void checkInput() throws InvalidHeaderValueException {
    if (bitmapHeight == 0xffffffffL)
      if (!isStriped)
        log.info("isStriped should contaion the value true");
  }

  private void readCombinationOperatorOverrideAllowed() throws IOException {
    /* Bit 6 */
    if (subInputStream.readBit() == 1) {
      combinationOperatorOverrideAllowed = true;
    }
  }

  private void readRequiresAuxiliaryBuffer() throws IOException {
    /* Bit 5 */
    if (subInputStream.readBit() == 1) {
      requiresAuxiliaryBuffer = true;
    }
  }

  private void readCombinationOperator() throws IOException {
    /* Bit 3-4 */
    combinationOperator = CombinationOperator.translateOperatorCodeToEnum((short) (subInputStream.readBits(2) & 0xf));
  }

  private void readDefaultPixelvalue() throws IOException {
    /* Bit 2 */
    defaultPixelValue = (short) subInputStream.readBit();
  }

  private void readContainsRefinement() throws IOException {
    /* Bit 1 */
    if (subInputStream.readBit() == 1) {
      mightContainRefinements = true;
    }
  }

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

  private void readIsStriped() throws IOException {
    /* Bit 15 */
    if (subInputStream.readBit() == 1) {
      isStriped = true;
    }
  }

  private void readMaxStripeSize() throws IOException {
    /* Bit 0-14 */
    maxStripeSize = (short) (subInputStream.readBits(15) & 0xffff);
  }

  private void readWidthAndHeight() throws IOException {
    bitmapWidth = (int) subInputStream.readBits(32); // & 0xffffffff;
    bitmapHeight = (int) subInputStream.readBits(32); // & 0xffffffff;
  }

  public void init(final SegmentHeader header, final SubInputStream sis) throws InvalidHeaderValueException, IOException {
    subInputStream = sis;

    parseHeader();
  }

  public int getWidth() {
    return bitmapWidth;
  }

  public int getHeight() {
    return bitmapHeight;
  }

  public int getResolutionX() {
    return resolutionX;
  }

  public int getResolutionY() {
    return resolutionY;
  }

  public short getDefaultPixelValue() {
    return defaultPixelValue;
  }

  public boolean isCombinationOperatorOverrideAllowed() {
    return combinationOperatorOverrideAllowed;
  }

  public CombinationOperator getCombinationOperator() {
    return combinationOperator;
  }

  public boolean isStriped() {
    return isStriped;
  }

  public short getMaxStripeSize() {
    return maxStripeSize;
  }

  public boolean isAuxiliaryBufferRequired() {
    return requiresAuxiliaryBuffer;
  }

  public boolean mightContainRefinements() {
    return mightContainRefinements;
  }

  public boolean isLossless() {
    return isLossless;
  }

  protected int getBitmapWidth() {
    return bitmapWidth;
  }

  protected int getBitmapHeight() {
    return bitmapHeight;
  }
}