Examples of org.jpedal.jbig2.decoders.DecodeIntResult

org.jpedal.jbig2.segment.Segment

    while (i < patternDictionarySegment.getSize()) {
      bitsPerValue++;
      i <<= 1;
    }
    
    JBIG2Bitmap bitmap = patternDictionarySegment.getBitmaps()[0];
    int patternWidth = bitmap.getWidth();
    int patternHeight = bitmap.getHeight();


    if (JBIG2StreamDecoder.debug)
      System.out.println("pattern size = " + patternWidth + ',' + patternHeight);


    boolean useMMR = halftoneRegionFlags.getFlagValue(HalftoneRegionFlags.H_MMR) != 0;
    int template = halftoneRegionFlags.getFlagValue(HalftoneRegionFlags.H_TEMPLATE);
    
    if (!useMMR) {
      arithmeticDecoder.resetGenericStats(template, null);
      arithmeticDecoder.start();
    }


    int halftoneDefaultPixel = halftoneRegionFlags.getFlagValue(HalftoneRegionFlags.H_DEF_PIXEL);
    bitmap = new JBIG2Bitmap(regionBitmapWidth, regionBitmapHeight, arithmeticDecoder, huffmanDecoder, mmrDecoder);
    bitmap.clear(halftoneDefaultPixel);


    boolean enableSkip = halftoneRegionFlags.getFlagValue(HalftoneRegionFlags.H_ENABLE_SKIP) != 0;
    
    JBIG2Bitmap skipBitmap = null;
    if (enableSkip) {
      skipBitmap = new JBIG2Bitmap(gridWidth, gridHeight, arithmeticDecoder, huffmanDecoder, mmrDecoder);
      skipBitmap.clear(0);
      for (int y = 0; y < gridHeight; y++) {
        for (int x = 0; x < gridWidth; x++) {
          int xx = gridX + y * stepY + x * stepX;
          int yy = gridY + y * stepX - x * stepY;
          
          if (((xx + patternWidth) >> 8) <= 0 || (xx >> 8) >= regionBitmapWidth || ((yy + patternHeight) >> 8) <= 0 || (yy >> 8) >= regionBitmapHeight) {
            skipBitmap.setPixel(y, x, 1);
          }
        }
      }
    }


    int[] grayScaleImage = new int[gridWidth * gridHeight];


    short[] genericBAdaptiveTemplateX = new short[4], genericBAdaptiveTemplateY = new short[4];


    genericBAdaptiveTemplateX[0] = (short) (template <= 1 ? 3 : 2);
    genericBAdaptiveTemplateY[0] = -1;
    genericBAdaptiveTemplateX[1] = -3;
    genericBAdaptiveTemplateY[1] = -1;
    genericBAdaptiveTemplateX[2] = 2;
    genericBAdaptiveTemplateY[2] = -2;
    genericBAdaptiveTemplateX[3] = -2;
    genericBAdaptiveTemplateY[3] = -2;


        JBIG2Bitmap grayBitmap ;


        for (int j = bitsPerValue - 1; j >= 0; --j) {
      grayBitmap = new JBIG2Bitmap(gridWidth, gridHeight, arithmeticDecoder, huffmanDecoder, mmrDecoder);


      grayBitmap.readBitmap(useMMR, template, false, enableSkip, skipBitmap, genericBAdaptiveTemplateX, genericBAdaptiveTemplateY, -1);


      i = 0;
      for (int row = 0; row < gridHeight; row++) {
        for (int col = 0; col < gridWidth; col++) {
          int bit = grayBitmap.getPixel(col, row) ^ (grayScaleImage[i] & 1);
          grayScaleImage[i] = (grayScaleImage[i] << 1) | bit;
          i++;
        }
      }
    }


    int combinationOperator = halftoneRegionFlags.getFlagValue(HalftoneRegionFlags.H_COMB_OP);


    i = 0;
    for (int col = 0; col < gridHeight; col++) {
      int xx = gridX + col * stepY;
      int yy = gridY + col * stepX;
      for (int row = 0; row < gridWidth; row++) {
        if (!(enableSkip && skipBitmap.getPixel(col, row) == 1)) {
          JBIG2Bitmap patternBitmap = patternDictionarySegment.getBitmaps()[grayScaleImage[i]];
          bitmap.combine(patternBitmap, xx >> 8, yy >> 8, combinationOperator);
        }
        
        xx += stepX;
        yy -= stepY;
        
        i++;
      }
    }


    if (inlineImage) {
      PageInformationSegment pageSegment = decoder.findPageSegement(segmentHeader.getPageAssociation());
      JBIG2Bitmap pageBitmap = pageSegment.getPageBitmap();


      int externalCombinationOperator = regionFlags.getFlagValue(RegionFlags.EXTERNAL_COMBINATION_OPERATOR);
      pageBitmap.combine(bitmap, regionBitmapXLocation, regionBitmapYLocation, externalCombinationOperator);
    } else {
      bitmap.setBitmapNumber(getSegmentHeader().getSegmentNumber());
      decoder.appendBitmap(bitmap);
    }

View Full Code Here

   * @param page
   * @return
   */
  public BufferedImage getPageAsBufferedImage(int page) {
    page++;
    JBIG2Bitmap pageBitmap = streamDecoder.findPageSegement(page).getPageBitmap();


    byte[] bytes = pageBitmap.getData(true);


    if (bytes == null)
      return null;


    // make a a DEEP copy so we cant alter
    int len = bytes.length;
    byte[] copy = new byte[len];
    System.arraycopy(bytes, 0, copy, 0, len);


    // byte[] data = pageBitmap.getData(true).clone();
    int width = pageBitmap.getWidth();
    int height = pageBitmap.getHeight();


    BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_BINARY);
    // <start-me>
    /** create an image from the raw data */
    DataBuffer db = new DataBufferByte(copy, copy.length);

View Full Code Here

      height = pageStriping & 0x7fff;
    } else {
      height = pageBitmapHeight;
    }


    pageBitmap = new JBIG2Bitmap(pageBitmapWidth, height, arithmeticDecoder, huffmanDecoder, mmrDecoder);
    pageBitmap.clear(defPix);
  }

View Full Code Here

              symbolID = (int) arithmeticDecoder.decodeIAID(symbolCodeLength, arithmeticDecoder.iaidStats);
              referenceDX = arithmeticDecoder.decodeInt(arithmeticDecoder.iardxStats).intResult();
              referenceDY = arithmeticDecoder.decodeInt(arithmeticDecoder.iardyStats).intResult();
            }
            
            JBIG2Bitmap referredToBitmap = bitmaps[symbolID];


            JBIG2Bitmap bitmap = new JBIG2Bitmap(symbolWidth, deltaHeight, arithmeticDecoder, huffmanDecoder, mmrDecoder);
            bitmap.readGenericRefinementRegion(sdRefinementTemplate, false, referredToBitmap, referenceDX, referenceDY, symbolDictionaryRAdaptiveTemplateX, 
                symbolDictionaryRAdaptiveTemplateY);


            bitmaps[numberOfInputSymbols + i] = bitmap;


          } else {
            JBIG2Bitmap bitmap = new JBIG2Bitmap(symbolWidth, deltaHeight, arithmeticDecoder, huffmanDecoder, mmrDecoder);
            bitmap.readTextRegion(sdHuffman, true, refAggNum, 0, numberOfInputSymbols + i, null, symbolCodeLength, bitmaps, 0, 0, false, 1, 0, 
                HuffmanDecoder.huffmanTableF, HuffmanDecoder.huffmanTableH, HuffmanDecoder.huffmanTableK, HuffmanDecoder.huffmanTableO, HuffmanDecoder.huffmanTableO, 
                HuffmanDecoder.huffmanTableO, HuffmanDecoder.huffmanTableO, HuffmanDecoder.huffmanTableA, sdRefinementTemplate, symbolDictionaryRAdaptiveTemplateX, 
                symbolDictionaryRAdaptiveTemplateY, decoder);
            
            bitmaps[numberOfInputSymbols + i] = bitmap;
          }
        } else {
          JBIG2Bitmap bitmap = new JBIG2Bitmap(symbolWidth, deltaHeight, arithmeticDecoder, huffmanDecoder, mmrDecoder);
          bitmap.readBitmap(false, sdTemplate, false, false, null, symbolDictionaryAdaptiveTemplateX, symbolDictionaryAdaptiveTemplateY, 0);
          bitmaps[numberOfInputSymbols + i] = bitmap;
        }


        i++;
      }


      if (sdHuffman && sdRefinementAggregate == 0) {
        int bmSize = huffmanDecoder.decodeInt(huffmanBMSizeTable).intResult();
        decoder.consumeRemainingBits();


        JBIG2Bitmap collectiveBitmap = new JBIG2Bitmap(totalWidth, deltaHeight, arithmeticDecoder, huffmanDecoder, mmrDecoder);


        if (bmSize == 0) {


          int padding = totalWidth % 8;
          int bytesPerRow = (int) Math.ceil(totalWidth / 8d);


          //short[] bitmap = new short[totalWidth];
          //decoder.readByte(bitmap);
                    int size = deltaHeight * ((totalWidth + 7) >> 3);
                    short[] bitmap = new short[size];
                    decoder.readByte(bitmap);


          short[][] logicalMap = new short[deltaHeight][bytesPerRow];
          int count = 0;
          for (int row = 0; row < deltaHeight; row++) {
            for (int col = 0; col < bytesPerRow; col++) {
              logicalMap[row][col] = bitmap[count];
              count++;
            }
          }


          int collectiveBitmapRow = 0, collectiveBitmapCol = 0;


          for (int row = 0; row < deltaHeight; row++) {
            for (int col = 0; col < bytesPerRow; col++) {
              if (col == (bytesPerRow - 1)) { // this is the last
                // byte in the row
                short currentByte = logicalMap[row][col];
                for (int bitPointer = 7; bitPointer >= padding; bitPointer--) {
                  short mask = (short) (1 << bitPointer);
                  int bit = (currentByte & mask) >> bitPointer;
                  
                  collectiveBitmap.setPixel(collectiveBitmapCol, collectiveBitmapRow, bit);
                  collectiveBitmapCol++;
                }
                collectiveBitmapRow++;
                collectiveBitmapCol = 0;
              } else {
                short currentByte = logicalMap[row][col];
                for (int bitPointer = 7; bitPointer >= 0; bitPointer--) {
                  short mask = (short) (1 << bitPointer);
                  int bit = (currentByte & mask) >> bitPointer;
                  
                  collectiveBitmap.setPixel(collectiveBitmapCol, collectiveBitmapRow, bit);
                  collectiveBitmapCol++;
                }
              }
            }
          }


        } else {
          collectiveBitmap.readBitmap(true, 0, false, false, null, null, null, bmSize);
        }


        int x = 0;
        while (j < i){
          bitmaps[numberOfInputSymbols + j] = collectiveBitmap.getSlice(x, 0, deltaWidths[j], deltaHeight);
          x += deltaWidths[j];
          
          j++;
        }
      }

View Full Code Here

    genericBAdaptiveTemplateX[3] = -2;
    genericBAdaptiveTemplateY[3] = -2;


    size = grayMax + 1;


    JBIG2Bitmap bitmap = new JBIG2Bitmap(size * width, height, arithmeticDecoder, huffmanDecoder, mmrDecoder);
    bitmap.clear(0);
    bitmap.readBitmap(useMMR, template, false, false, null, genericBAdaptiveTemplateX, genericBAdaptiveTemplateY, segmentHeader.getSegmentDataLength() - 7);


    JBIG2Bitmap bitmaps[] = new JBIG2Bitmap[size];


    int x = 0;
    for (int i = 0; i < size; i++) {
      bitmaps[i] = bitmap.getSlice(x, 0, width, height);
      x += width;

View Full Code Here

  public void setGlobalData(byte[] data) {
    globalData = data;
  }


  public void decodeJBIG2(byte[] data) throws IOException, JBIG2Exception {
    reader = new StreamReader(data);


    resetDecoder();


    boolean validFile = checkHeader();
    if (JBIG2StreamDecoder.debug)
      System.out.println("validFile = " + validFile);


    if (!validFile) {
      /**
       * Assume this is a stream from a PDF so there is no file header,
       * end of page segments, or end of file segments. Organisation must
       * be sequential, and the number of pages is assumed to be 1.
       */


      noOfPagesKnown = true;
      randomAccessOrganisation = false;
      noOfPages = 1;


      /** check to see if there is any global data to be read */
      if (globalData != null) {
        /** set the reader to read from the global data */
        reader = new StreamReader(globalData);


        huffmanDecoder = new HuffmanDecoder(reader);
        mmrDecoder = new MMRDecoder(reader);
        arithmeticDecoder = new ArithmeticDecoder(reader);
        
        /** read in the global data segments */
        readSegments();


        /** set the reader back to the main data */
        reader = new StreamReader(data);
      } else {
        /**
         * There's no global data, so move the file pointer back to the
         * start of the stream
         */

View Full Code Here


    if (JBIG2StreamDecoder.debug)
      System.out.println("noOfReferredToSegments = " + noOfReferredToSegments);


    for (int i = 0; i < noOfReferredToSegments; i++) {
      Segment seg = decoder.findSegment(referredToSegments[i]);
      int type = seg.getSegmentHeader().getSegmentType();


      if (type == Segment.SYMBOL_DICTIONARY) {
        segmentsReferenced.add(seg);
        noOfSymbols += ((SymbolDictionarySegment) seg).getNoOfExportedSymbols();
      } else if (type == Segment.TABLES) {
        codeTables.add(seg);
      }
    }


    int symbolCodeLength = 0;
    int count = 1;


    while (count < noOfSymbols) {
      symbolCodeLength++;
      count <<= 1;
    }


    int currentSymbol = 0;
    JBIG2Bitmap[] symbols = new JBIG2Bitmap[noOfSymbols];
    for (Iterator it = segmentsReferenced.iterator(); it.hasNext();) {
      Segment seg = (Segment) it.next();
      if (seg.getSegmentHeader().getSegmentType() == Segment.SYMBOL_DICTIONARY) {
        JBIG2Bitmap[] bitmaps = ((SymbolDictionarySegment) seg).getBitmaps();
        for (int j = 0; j < bitmaps.length; j++) {
          symbols[currentSymbol] = bitmaps[j];
          currentSymbol++;
        }

View Full Code Here

    int numberOfInputSymbols = 0;
    int noOfReferredToSegments = segmentHeader.getReferredToSegmentCount();
    int[] referredToSegments = segmentHeader.getReferredToSegments();


    for (int i = 0; i < noOfReferredToSegments; i++) {
      Segment seg = decoder.findSegment(referredToSegments[i]);
      int type = seg.getSegmentHeader().getSegmentType();


      if (type == Segment.SYMBOL_DICTIONARY) {
        numberOfInputSymbols += ((SymbolDictionarySegment) seg).noOfExportedSymbols;
      } else if (type == Segment.TABLES) {
        codeTables.add(seg);
      }
    }


    int symbolCodeLength = 0;
    int i = 1;
    while (i < numberOfInputSymbols + noOfNewSymbols) {
      symbolCodeLength++;
      i <<= 1;
    }


    JBIG2Bitmap[] bitmaps = new JBIG2Bitmap[numberOfInputSymbols + noOfNewSymbols];


    int k = 0;
    SymbolDictionarySegment inputSymbolDictionary = null;
    for (i = 0; i < noOfReferredToSegments; i++) {
      Segment seg = decoder.findSegment(referredToSegments[i]);
      if (seg.getSegmentHeader().getSegmentType() == Segment.SYMBOL_DICTIONARY) {
        inputSymbolDictionary = (SymbolDictionarySegment) seg;
        for (int j = 0; j < inputSymbolDictionary.noOfExportedSymbols; j++) {
          bitmaps[k++] = inputSymbolDictionary.bitmaps[j];
        }
      }

View Full Code Here

        System.out.println("==== Segment Header ====");


      readSegmentHeader(segmentHeader);


      // read the Segment data
      Segment segment = null;


      int segmentType = segmentHeader.getSegmentType();
      int[] referredToSegments = segmentHeader.getReferredToSegments();
      int noOfReferredToSegments = segmentHeader.getReferredToSegmentCount();


      switch (segmentType) {
      case Segment.SYMBOL_DICTIONARY:
        if (JBIG2StreamDecoder.debug)
          System.out.println("==== Segment Symbol Dictionary ====");


        segment = new SymbolDictionarySegment(this);


        segment.setSegmentHeader(segmentHeader);


        break;


      case Segment.INTERMEDIATE_TEXT_REGION:
        if (JBIG2StreamDecoder.debug)
          System.out.println("==== Intermediate Text Region ====");


        segment = new TextRegionSegment(this, false);


        segment.setSegmentHeader(segmentHeader);


        break;


      case Segment.IMMEDIATE_TEXT_REGION:
        if (JBIG2StreamDecoder.debug)
          System.out.println("==== Immediate Text Region ====");


        segment = new TextRegionSegment(this, true);


        segment.setSegmentHeader(segmentHeader);


        break;


      case Segment.IMMEDIATE_LOSSLESS_TEXT_REGION:
        if (JBIG2StreamDecoder.debug)
          System.out.println("==== Immediate Lossless Text Region ====");


        segment = new TextRegionSegment(this, true);


        segment.setSegmentHeader(segmentHeader);


        break;


      case Segment.PATTERN_DICTIONARY:
        if (JBIG2StreamDecoder.debug)
          System.out.println("==== Pattern Dictionary ====");


        segment = new PatternDictionarySegment(this);


        segment.setSegmentHeader(segmentHeader);


        break;


      case Segment.INTERMEDIATE_HALFTONE_REGION:
        if (JBIG2StreamDecoder.debug)
          System.out.println("==== Intermediate Halftone Region ====");


        segment = new HalftoneRegionSegment(this, false);


        segment.setSegmentHeader(segmentHeader);


        break;


      case Segment.IMMEDIATE_HALFTONE_REGION:
        if (JBIG2StreamDecoder.debug)
          System.out.println("==== Immediate Halftone Region ====");


        segment = new HalftoneRegionSegment(this, true);


        segment.setSegmentHeader(segmentHeader);


        break;


      case Segment.IMMEDIATE_LOSSLESS_HALFTONE_REGION:
        if (JBIG2StreamDecoder.debug)
          System.out.println("==== Immediate Lossless Halftone Region ====");


        segment = new HalftoneRegionSegment(this, true);


        segment.setSegmentHeader(segmentHeader);


        break;


      case Segment.INTERMEDIATE_GENERIC_REGION:
        if (JBIG2StreamDecoder.debug)
          System.out.println("==== Intermediate Generic Region ====");


        segment = new GenericRegionSegment(this, false);


        segment.setSegmentHeader(segmentHeader);


        break;


      case Segment.IMMEDIATE_GENERIC_REGION:
        if (JBIG2StreamDecoder.debug)
          System.out.println("==== Immediate Generic Region ====");


        segment = new GenericRegionSegment(this, true);


        segment.setSegmentHeader(segmentHeader);


        break;


      case Segment.IMMEDIATE_LOSSLESS_GENERIC_REGION:
        if (JBIG2StreamDecoder.debug)
          System.out.println("==== Immediate Lossless Generic Region ====");


        segment = new GenericRegionSegment(this, true);


        segment.setSegmentHeader(segmentHeader);


        break;


      case Segment.INTERMEDIATE_GENERIC_REFINEMENT_REGION:
        if (JBIG2StreamDecoder.debug)
          System.out.println("==== Intermediate Generic Refinement Region ====");


        segment = new RefinementRegionSegment(this, false, referredToSegments, noOfReferredToSegments);


        segment.setSegmentHeader(segmentHeader);


        break;


      case Segment.IMMEDIATE_GENERIC_REFINEMENT_REGION:
        if (JBIG2StreamDecoder.debug)
          System.out.println("==== Immediate Generic Refinement Region ====");


        segment = new RefinementRegionSegment(this, true, referredToSegments, noOfReferredToSegments);


        segment.setSegmentHeader(segmentHeader);


        break;


      case Segment.IMMEDIATE_LOSSLESS_GENERIC_REFINEMENT_REGION:
        if (JBIG2StreamDecoder.debug)
          System.out.println("==== Immediate lossless Generic Refinement Region ====");


        segment = new RefinementRegionSegment(this, true, referredToSegments, noOfReferredToSegments);


        segment.setSegmentHeader(segmentHeader);


        break;


      case Segment.PAGE_INFORMATION:
        if (JBIG2StreamDecoder.debug)
          System.out.println("==== Page Information Dictionary ====");


        segment = new PageInformationSegment(this);


        segment.setSegmentHeader(segmentHeader);


        break;


      case Segment.END_OF_PAGE:
        continue;


      case Segment.END_OF_STRIPE:
        if (JBIG2StreamDecoder.debug)
          System.out.println("==== End of Stripes ====");


        segment = new EndOfStripeSegment(this);


        segment.setSegmentHeader(segmentHeader);
        break;


      case Segment.END_OF_FILE:
        if (JBIG2StreamDecoder.debug)
          System.out.println("==== End of File ====");


        finished = true;


        continue;


      case Segment.PROFILES:
        if (JBIG2StreamDecoder.debug)
          System.out.println("PROFILES UNIMPLEMENTED");
        break;


      case Segment.TABLES:
        if (JBIG2StreamDecoder.debug)
          System.out.println("TABLES UNIMPLEMENTED");
        break;


      case Segment.EXTENSION:
        if (JBIG2StreamDecoder.debug)
          System.out.println("==== Extensions ====");


        segment = new ExtensionSegment(this);


        segment.setSegmentHeader(segmentHeader);


        break;


      default:
        System.out.println("Unknown Segment type in JBIG2 stream");


        break;
      }
      
      if (!randomAccessOrganisation) {
        segment.readSegment();
      }


      segments.add(segment);
    }


    if (randomAccessOrganisation) {
      for (Iterator it = segments.iterator(); it.hasNext();) {
        Segment segment = (Segment) it.next();
        segment.readSegment();
      }
    }
  }

View Full Code Here

    }
  }


  public PageInformationSegment findPageSegement(int page) {
    for (Iterator it = segments.iterator(); it.hasNext();) {
      Segment segment = (Segment) it.next();
      SegmentHeader segmentHeader = segment.getSegmentHeader();
      if (segmentHeader.getSegmentType() == segment.PAGE_INFORMATION && segmentHeader.getPageAssociation() == page) {
        return (PageInformationSegment) segment;
      }
    }

View Full Code Here

0 1 2 3

TOP

Related Classes of org.jpedal.jbig2.decoders.DecodeIntResult

com.sun.pdfview.decode.JBig2Decode

org.jpedal.jbig2.decoders.DecodeIntResult

org.jpedal.jbig2.decoders.JBIG2StreamDecoder

org.jpedal.jbig2.image.JBIG2Bitmap

org.jpedal.jbig2.io.StreamReader

org.jpedal.jbig2.JBIG2Decoder

org.jpedal.jbig2.segment.extensions.ExtensionSegment

org.jpedal.jbig2.segment.pageinformation.PageInformationSegment

org.jpedal.jbig2.segment.pattern.PatternDictionarySegment

org.jpedal.jbig2.segment.region.generic.GenericRegionSegment

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.