public BitmapPointer(JBIG2Bitmap bitmap) { this.bitmap = bitmap; this.height = bitmap.getHeight(); this.width = bitmap.getWidth(); }
public JBIG2Bitmap GetPageAsJBIG2Bitmap(int i) { JBIG2Bitmap pageBitmap = FindPageSegement(1).GetPageBitmap(); return(pageBitmap); }
public override void ReadSegment() { if (JBIG2StreamDecoder.debug) { Console.WriteLine("==== Read Segment Symbol Dictionary ===="); } /** read symbol dictionary flags */ ReadSymbolDictionaryFlags(); //List codeTables = new ArrayList(); int numberOfInputSymbols = 0; int noOfReferredToSegments = segmentHeader.GetReferredToSegmentCount(); int[] referredToSegments = segmentHeader.GetReferredToSegments(); long i; // i = 0; for (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; i = 1; while (i < numberOfInputSymbols + noOfNewSymbols) { symbolCodeLength++; i <<= 1; } JBIG2Bitmap[] bitmaps = new JBIG2Bitmap[numberOfInputSymbols + noOfNewSymbols]; long j, 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 (j = 0; j < inputSymbolDictionary.noOfExportedSymbols; j++) { bitmaps[k++] = inputSymbolDictionary.bitmaps[j]; } } } long[,] huffmanDHTable = null; long[,] huffmanDWTable = null; long[,] huffmanBMSizeTable = null; long[,] huffmanAggInstTable = null; bool sdHuffman = symbolDictionaryFlags.GetFlagValue(SymbolDictionaryFlags.SD_HUFF) != 0; int sdHuffmanDifferenceHeight = symbolDictionaryFlags.GetFlagValue(SymbolDictionaryFlags.SD_HUFF_DH); int sdHuffmanDiferrenceWidth = symbolDictionaryFlags.GetFlagValue(SymbolDictionaryFlags.SD_HUFF_DW); int sdHuffBitmapSize = symbolDictionaryFlags.GetFlagValue(SymbolDictionaryFlags.SD_HUFF_BM_SIZE); int sdHuffAggregationInstances = symbolDictionaryFlags.GetFlagValue(SymbolDictionaryFlags.SD_HUFF_AGG_INST); i = 0; if (sdHuffman) { if (sdHuffmanDifferenceHeight == 0) { huffmanDHTable = HuffmanDecoder.huffmanTableD; } else if (sdHuffmanDifferenceHeight == 1) { huffmanDHTable = HuffmanDecoder.huffmanTableE; } else { //huffmanDHTable = ((JBIG2CodeTable) codeTables.get(i++)).getHuffTable(); } if (sdHuffmanDiferrenceWidth == 0) { huffmanDWTable = HuffmanDecoder.huffmanTableB; } else if (sdHuffmanDiferrenceWidth == 1) { huffmanDWTable = HuffmanDecoder.huffmanTableC; } else { //huffmanDWTable = ((JBIG2CodeTable) codeTables.get(i++)).getHuffTable(); } if (sdHuffBitmapSize == 0) { huffmanBMSizeTable = HuffmanDecoder.huffmanTableA; } else { //huffmanBMSizeTable = ((JBIG2CodeTable) codeTables.get(i++)).getHuffTable(); } if (sdHuffAggregationInstances == 0) { huffmanAggInstTable = HuffmanDecoder.huffmanTableA; } else { //huffmanAggInstTable = ((JBIG2CodeTable) codeTables.get(i++)).getHuffTable(); } } int contextUsed = symbolDictionaryFlags.GetFlagValue(SymbolDictionaryFlags.BITMAP_CC_USED); int sdTemplate = symbolDictionaryFlags.GetFlagValue(SymbolDictionaryFlags.SD_TEMPLATE); if (!sdHuffman) { if (contextUsed != 0 && inputSymbolDictionary != null) { arithmeticDecoder.ResetGenericStats(sdTemplate, inputSymbolDictionary.genericRegionStats); } else { arithmeticDecoder.ResetGenericStats(sdTemplate, null); } arithmeticDecoder.ResetIntStats(symbolCodeLength); arithmeticDecoder.Start(); } int sdRefinementAggregate = symbolDictionaryFlags.GetFlagValue(SymbolDictionaryFlags.SD_REF_AGG); int sdRefinementTemplate = symbolDictionaryFlags.GetFlagValue(SymbolDictionaryFlags.SD_R_TEMPLATE); if (sdRefinementAggregate != 0) { if (contextUsed != 0 && inputSymbolDictionary != null) { arithmeticDecoder.ResetRefinementStats(sdRefinementTemplate, inputSymbolDictionary.refinementRegionStats); } else { arithmeticDecoder.ResetRefinementStats(sdRefinementTemplate, null); } } long[] deltaWidths = new long[noOfNewSymbols]; long deltaHeight = 0; i = 0; while (i < noOfNewSymbols) { long instanceDeltaHeight; // instanceDeltaHeight = 0; if (sdHuffman) { instanceDeltaHeight = huffmanDecoder.DecodeInt(huffmanDHTable).IntResult(); } else { instanceDeltaHeight = arithmeticDecoder.DecodeInt(arithmeticDecoder.iadhStats).IntResult(); } if (instanceDeltaHeight < 0 && -instanceDeltaHeight >= deltaHeight) { if (JBIG2StreamDecoder.debug) { Console.WriteLine("Bad delta-height value in JBIG2 symbol dictionary"); } } deltaHeight += instanceDeltaHeight; long symbolWidth = 0; long totalWidth = 0; j = i; while (true) { long deltaWidth = 0; DecodeIntResult decodeIntResult; if (sdHuffman) { decodeIntResult = huffmanDecoder.DecodeInt(huffmanDWTable); } else { decodeIntResult = arithmeticDecoder.DecodeInt(arithmeticDecoder.iadwStats); } if (!decodeIntResult.BooleanResult()) { break; } deltaWidth = decodeIntResult.IntResult(); if (deltaWidth < 0 && -deltaWidth >= symbolWidth) { if (JBIG2StreamDecoder.debug) { Console.WriteLine("Bad delta-width value in JBIG2 symbol dictionary"); } } symbolWidth += deltaWidth; if (sdHuffman && sdRefinementAggregate == 0) { deltaWidths[i] = symbolWidth; totalWidth += symbolWidth; } else if (sdRefinementAggregate == 1) { long refAggNum; //refAggNum = 0; if (sdHuffman) { refAggNum = huffmanDecoder.DecodeInt(huffmanAggInstTable).IntResult(); } else { refAggNum = arithmeticDecoder.DecodeInt(arithmeticDecoder.iaaiStats).IntResult(); } if (refAggNum == 1) { //long symbolID = 0, referenceDX = 0, referenceDY = 0; long symbolID, referenceDX, referenceDY; if (sdHuffman) { symbolID = decoder.ReadBits(symbolCodeLength); referenceDX = huffmanDecoder.DecodeInt(HuffmanDecoder.huffmanTableO).IntResult(); referenceDY = huffmanDecoder.DecodeInt(HuffmanDecoder.huffmanTableO).IntResult(); decoder.ConsumeRemainingBits(); arithmeticDecoder.Start(); } else { 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) { long bmSize = huffmanDecoder.DecodeInt(huffmanBMSizeTable).IntResult(); decoder.ConsumeRemainingBits(); JBIG2Bitmap collectiveBitmap = new JBIG2Bitmap(totalWidth, deltaHeight, arithmeticDecoder, huffmanDecoder, mmrDecoder); if (bmSize == 0) { long padding = totalWidth % 8; long bytesPerRow = (int)Math.Ceiling(totalWidth / 8d); //short[] bitmap = new short[totalWidth]; //decoder.readbyte(bitmap); long size = deltaHeight * ((totalWidth + 7) >> 3); short[] bitmap = new short[size]; decoder.Readbyte(bitmap); short[][] logicalMap = new short[deltaHeight][]; 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); } long x = 0; while (j < i) { bitmaps[numberOfInputSymbols + j] = collectiveBitmap.GetSlice(x, 0, deltaWidths[j], deltaHeight); x += deltaWidths[j]; j++; } } } this.bitmaps = new JBIG2Bitmap[noOfExportedSymbols]; j = i = 0; bool export = false; while (i < numberOfInputSymbols + noOfNewSymbols) { //long run = 0; long run; if (sdHuffman) { run = huffmanDecoder.DecodeInt(HuffmanDecoder.huffmanTableA).IntResult(); } else { run = arithmeticDecoder.DecodeInt(arithmeticDecoder.iaexStats).IntResult(); } if (export) { for (int cnt = 0; cnt < run; cnt++) { this.bitmaps[j++] = bitmaps[i++]; } } else { i += run; } export = !export; } int contextRetained = symbolDictionaryFlags.GetFlagValue(SymbolDictionaryFlags.BITMAP_CC_RETAINED); if (!sdHuffman && contextRetained == 1) { genericRegionStats = genericRegionStats.Copy(); if (sdRefinementAggregate == 1) { refinementRegionStats = refinementRegionStats.Copy(); } } /** consume any remaining bits */ decoder.ConsumeRemainingBits(); }
public override void ReadSegment() { /** read text region Segment flags */ ReadPatternDictionaryFlags(); width = decoder.Readbyte(); height = decoder.Readbyte(); if (JBIG2StreamDecoder.debug) { Console.WriteLine("pattern dictionary size = " + width + " , " + height); } short[] buf = new short[4]; decoder.Readbyte(buf); grayMax = BinaryOperation.GetInt32(buf); if (JBIG2StreamDecoder.debug) { Console.WriteLine("grey max = " + grayMax); } bool useMMR = patternDictionaryFlags.GetFlagValue(PatternDictionaryFlags.HD_MMR) == 1; int template = patternDictionaryFlags.GetFlagValue(PatternDictionaryFlags.HD_TEMPLATE); if (!useMMR) { arithmeticDecoder.ResetGenericStats(template, null); arithmeticDecoder.Start(); } short[] genericBAdaptiveTemplateX = new short[4], genericBAdaptiveTemplateY = new short[4]; genericBAdaptiveTemplateX[0] = (short)-width; genericBAdaptiveTemplateY[0] = 0; genericBAdaptiveTemplateX[1] = -3; genericBAdaptiveTemplateY[1] = -1; genericBAdaptiveTemplateX[2] = 2; genericBAdaptiveTemplateY[2] = -2; 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; } this.bitmaps = bitmaps; }
public void AppendBitmap(JBIG2Bitmap bitmap) { bitmaps.Add(bitmap); }
public override void readSegment() { if (JBIG2StreamDecoder.debug) { Console.WriteLine("==== Reading Text Region ===="); } base.readSegment(); /** read text region Segment flags */ readTextRegionFlags(); short[] buff = new short[4]; decoder.readbyte(buff); long noOfSymbolInstances = BinaryOperation.getInt32(buff); if (JBIG2StreamDecoder.debug) { Console.WriteLine("noOfSymbolInstances = " + noOfSymbolInstances); } int noOfReferredToSegments = segmentHeader.getReferredToSegmentCount(); int[] referredToSegments = segmentHeader.getReferredToSegments(); //List codeTables = new ArrayList(); List <Segment> segmentsReferenced = new List <Segment>(); long noOfSymbols = 0; if (JBIG2StreamDecoder.debug) { Console.WriteLine("noOfReferredToSegments = " + noOfReferredToSegments); } int i = 0; for (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); } } long symbolCodeLength = 0; int count = 1; while (count < noOfSymbols) { symbolCodeLength++; count <<= 1; } int currentSymbol = 0; JBIG2Bitmap[] symbols = new JBIG2Bitmap[noOfSymbols]; foreach (Segment it in segmentsReferenced) { if (it.getSegmentHeader().getSegmentType() == Segment.SYMBOL_DICTIONARY) { JBIG2Bitmap[] bitmaps = ((SymbolDictionarySegment)it).getBitmaps(); for (int j = 0; j < bitmaps.Length; j++) { symbols[currentSymbol] = bitmaps[j]; currentSymbol++; } } } long[,] huffmanFSTable = null; long[,] huffmanDSTable = null; long[,] huffmanDTTable = null; long[,] huffmanRDWTable = null; long[,] huffmanRDHTable = null; long[,] huffmanRDXTable = null; long[,] huffmanRDYTable = null; long[,] huffmanRSizeTable = null; bool sbHuffman = textRegionFlags.getFlagValue(TextRegionFlags.SB_HUFF) != 0; i = 0; if (sbHuffman) { int sbHuffFS = textRegionHuffmanFlags.getFlagValue(TextRegionHuffmanFlags.SB_HUFF_FS); if (sbHuffFS == 0) { huffmanFSTable = HuffmanDecoder.huffmanTableF; } else if (sbHuffFS == 1) { huffmanFSTable = HuffmanDecoder.huffmanTableG; } else { } int sbHuffDS = textRegionHuffmanFlags.getFlagValue(TextRegionHuffmanFlags.SB_HUFF_DS); if (sbHuffDS == 0) { huffmanDSTable = HuffmanDecoder.huffmanTableH; } else if (sbHuffDS == 1) { huffmanDSTable = HuffmanDecoder.huffmanTableI; } else if (sbHuffDS == 2) { huffmanDSTable = HuffmanDecoder.huffmanTableJ; } else { } int sbHuffDT = textRegionHuffmanFlags.getFlagValue(TextRegionHuffmanFlags.SB_HUFF_DT); if (sbHuffDT == 0) { huffmanDTTable = HuffmanDecoder.huffmanTableK; } else if (sbHuffDT == 1) { huffmanDTTable = HuffmanDecoder.huffmanTableL; } else if (sbHuffDT == 2) { huffmanDTTable = HuffmanDecoder.huffmanTableM; } else { } int sbHuffRDW = textRegionHuffmanFlags.getFlagValue(TextRegionHuffmanFlags.SB_HUFF_RDW); if (sbHuffRDW == 0) { huffmanRDWTable = HuffmanDecoder.huffmanTableN; } else if (sbHuffRDW == 1) { huffmanRDWTable = HuffmanDecoder.huffmanTableO; } else { } int sbHuffRDH = textRegionHuffmanFlags.getFlagValue(TextRegionHuffmanFlags.SB_HUFF_RDH); if (sbHuffRDH == 0) { huffmanRDHTable = HuffmanDecoder.huffmanTableN; } else if (sbHuffRDH == 1) { huffmanRDHTable = HuffmanDecoder.huffmanTableO; } else { } int sbHuffRDX = textRegionHuffmanFlags.getFlagValue(TextRegionHuffmanFlags.SB_HUFF_RDX); if (sbHuffRDX == 0) { huffmanRDXTable = HuffmanDecoder.huffmanTableN; } else if (sbHuffRDX == 1) { huffmanRDXTable = HuffmanDecoder.huffmanTableO; } else { } int sbHuffRDY = textRegionHuffmanFlags.getFlagValue(TextRegionHuffmanFlags.SB_HUFF_RDY); if (sbHuffRDY == 0) { huffmanRDYTable = HuffmanDecoder.huffmanTableN; } else if (sbHuffRDY == 1) { huffmanRDYTable = HuffmanDecoder.huffmanTableO; } else { } int sbHuffRSize = textRegionHuffmanFlags.getFlagValue(TextRegionHuffmanFlags.SB_HUFF_RSIZE); if (sbHuffRSize == 0) { huffmanRSizeTable = HuffmanDecoder.huffmanTableA; } else { } } long[][] runLengthTable = new long[36][]; long[][] symbolCodeTable = new long[noOfSymbols + 1][]; if (sbHuffman) { decoder.consumeRemainingBits(); for (i = 0; i < 32; i++) { runLengthTable[i] = new long[] { i, decoder.readBits(4), 0, 0 }; } runLengthTable[32] = new long[] { 0x103, decoder.readBits(4), 2, 0 }; runLengthTable[33] = new long[] { 0x203, decoder.readBits(4), 3, 0 }; runLengthTable[34] = new long[] { 0x20b, decoder.readBits(4), 7, 0 }; runLengthTable[35] = new long[] { 0, 0, HuffmanDecoder.jbig2HuffmanEOT }; runLengthTable = HuffmanDecoder.buildTable(runLengthTable, 35); for (i = 0; i < noOfSymbols; i++) { symbolCodeTable[i] = new long[] { i, 0, 0, 0 }; } i = 0; while (i < noOfSymbols) { long j = huffmanDecoder.decodeInt(runLengthTable).intResult(); if (j > 0x200) { for (j -= 0x200; j != 0 && i < noOfSymbols; j--) { symbolCodeTable[i++][1] = 0; } } else if (j > 0x100) { for (j -= 0x100; j != 0 && i < noOfSymbols; j--) { symbolCodeTable[i][1] = symbolCodeTable[i - 1][1]; i++; } } else { symbolCodeTable[i++][1] = j; } } symbolCodeTable[noOfSymbols][1] = 0; symbolCodeTable[noOfSymbols][2] = HuffmanDecoder.jbig2HuffmanEOT; symbolCodeTable = HuffmanDecoder.buildTable(symbolCodeTable, (int)noOfSymbols); decoder.consumeRemainingBits(); } else { symbolCodeTable = null; arithmeticDecoder.resetIntStats((int)symbolCodeLength); arithmeticDecoder.start(); } bool symbolRefine = textRegionFlags.getFlagValue(TextRegionFlags.SB_REFINE) != 0; long logStrips = textRegionFlags.getFlagValue(TextRegionFlags.LOG_SB_STRIPES); int defaultPixel = textRegionFlags.getFlagValue(TextRegionFlags.SB_DEF_PIXEL); int combinationOperator = textRegionFlags.getFlagValue(TextRegionFlags.SB_COMB_OP); bool transposed = textRegionFlags.getFlagValue(TextRegionFlags.TRANSPOSED) != 0; int referenceCorner = textRegionFlags.getFlagValue(TextRegionFlags.REF_CORNER); int sOffset = textRegionFlags.getFlagValue(TextRegionFlags.SB_DS_OFFSET); int template = textRegionFlags.getFlagValue(TextRegionFlags.SB_R_TEMPLATE); if (symbolRefine) { arithmeticDecoder.resetRefinementStats(template, null); } JBIG2Bitmap bitmap = new JBIG2Bitmap(regionBitmapWidth, regionBitmapHeight, arithmeticDecoder, huffmanDecoder, mmrDecoder); bitmap.readTextRegion2(sbHuffman, symbolRefine, noOfSymbolInstances, logStrips, noOfSymbols, symbolCodeTable, symbolCodeLength, symbols, defaultPixel, combinationOperator, transposed, referenceCorner, sOffset, huffmanFSTable, huffmanDSTable, huffmanDTTable, huffmanRDWTable, huffmanRDHTable, huffmanRDXTable, huffmanRDYTable, huffmanRSizeTable, template, symbolRegionAdaptiveTemplateX, symbolRegionAdaptiveTemplateY, decoder); if (inlineImage) { PageInformationSegment pageSegment = decoder.findPageSegement(segmentHeader.getPageAssociation()); JBIG2Bitmap pageBitmap = pageSegment.getPageBitmap(); if (JBIG2StreamDecoder.debug) { Console.WriteLine(pageBitmap + " " + bitmap); } int externalCombinationOperator = regionFlags.getFlagValue(RegionFlags.EXTERNAL_COMBINATION_OPERATOR); pageBitmap.combine(bitmap, regionBitmapXLocation, regionBitmapYLocation, externalCombinationOperator); } else { bitmap.setBitmapNumber(getSegmentHeader().getSegmentNumber()); decoder.appendBitmap(bitmap); } decoder.consumeRemainingBits(); }
public override void ReadSegment() { if (JBIG2StreamDecoder.debug) { Console.WriteLine("==== Reading Page Information Dictionary ===="); } short[] buff = new short[4]; decoder.Readbyte(buff); pageBitmapWidth = BinaryOperation.GetInt32(buff); buff = new short[4]; decoder.Readbyte(buff); pageBitmapHeight = BinaryOperation.GetInt32(buff); if (JBIG2StreamDecoder.debug) { Console.WriteLine("Bitmap size = " + pageBitmapWidth + 'x' + pageBitmapHeight); } buff = new short[4]; decoder.Readbyte(buff); xResolution = BinaryOperation.GetInt32(buff); buff = new short[4]; decoder.Readbyte(buff); yResolution = BinaryOperation.GetInt32(buff); if (JBIG2StreamDecoder.debug) { Console.WriteLine("Resolution = " + xResolution + 'x' + yResolution); } /** extract page information flags */ short pageInformationFlagsField = decoder.Readbyte(); pageInformationFlags.SetFlags(pageInformationFlagsField); if (JBIG2StreamDecoder.debug) { Console.WriteLine("symbolDictionaryFlags = " + pageInformationFlagsField); } buff = new short[2]; decoder.Readbyte(buff); pageStriping = BinaryOperation.GetInt16(buff); if (JBIG2StreamDecoder.debug) { Console.WriteLine("Page Striping = " + pageStriping); } int defPix = pageInformationFlags.GetFlagValue(PageInformationFlags.DEFAULT_PIXEL_VALUE); int height; if (pageBitmapHeight == -1) { height = pageStriping & 0x7fff; } else { height = pageBitmapHeight; } pageBitmap = new JBIG2Bitmap(pageBitmapWidth, height, arithmeticDecoder, huffmanDecoder, mmrDecoder); pageBitmap.Clear(defPix); }
public void ReadSegment() { if (JBIG2StreamDecoder.debug) { Console.WriteLine("==== Reading Generic Refinement Region ===="); } base.ReadSegment(); /** read text region segment flags */ ReadGenericRegionFlags(); short[] genericRegionAdaptiveTemplateX = new short[2]; short[] genericRegionAdaptiveTemplateY = new short[2]; int template = refinementRegionFlags.GetFlagValue(RefinementRegionFlags.GR_TEMPLATE); if (template == 0) { genericRegionAdaptiveTemplateX[0] = ReadATValue(); genericRegionAdaptiveTemplateY[0] = ReadATValue(); genericRegionAdaptiveTemplateX[1] = ReadATValue(); genericRegionAdaptiveTemplateY[1] = ReadATValue(); } if (noOfReferedToSegments == 0 || inlineImage) { PageInformationSegment pageSegment = decoder.FindPageSegement(segmentHeader.GetPageAssociation()); JBIG2Bitmap pageBitmap = pageSegment.GetPageBitmap(); if (pageSegment.GetPageBitmapHeight() == -1 && regionBitmapYLocation + regionBitmapHeight > pageBitmap.GetHeight()) { pageBitmap.Expand(regionBitmapYLocation + regionBitmapHeight, pageSegment.GetPageInformationFlags().GetFlagValue(PageInformationFlags.DEFAULT_PIXEL_VALUE)); } } if (noOfReferedToSegments > 1) { if (JBIG2StreamDecoder.debug) { Console.WriteLine("Bad reference in JBIG2 generic refinement Segment"); } return; } JBIG2Bitmap referedToBitmap; if (noOfReferedToSegments == 1) { referedToBitmap = decoder.FindBitmap(referedToSegments[0]); } else { PageInformationSegment pageSegment = decoder.FindPageSegement(segmentHeader.GetPageAssociation()); JBIG2Bitmap pageBitmap = pageSegment.GetPageBitmap(); referedToBitmap = pageBitmap.GetSlice(regionBitmapXLocation, regionBitmapYLocation, regionBitmapWidth, regionBitmapHeight); } arithmeticDecoder.ResetRefinementStats(template, null); arithmeticDecoder.Start(); bool typicalPredictionGenericRefinementOn = refinementRegionFlags.GetFlagValue(RefinementRegionFlags.TPGDON) != 0; JBIG2Bitmap bitmap = new JBIG2Bitmap(regionBitmapWidth, regionBitmapHeight, arithmeticDecoder, huffmanDecoder, mmrDecoder); bitmap.ReadGenericRefinementRegion(template, typicalPredictionGenericRefinementOn, referedToBitmap, 0, 0, genericRegionAdaptiveTemplateX, genericRegionAdaptiveTemplateY); if (inlineImage) { PageInformationSegment pageSegment = decoder.FindPageSegement(segmentHeader.GetPageAssociation()); JBIG2Bitmap pageBitmap = pageSegment.GetPageBitmap(); int extCombOp = regionFlags.GetFlagValue(RegionFlags.EXTERNAL_COMBINATION_OPERATOR); pageBitmap.Combine(bitmap, regionBitmapXLocation, regionBitmapYLocation, extCombOp); } else { bitmap.SetBitmapNumber(GetSegmentHeader().GetSegmentNumber()); decoder.AppendBitmap(bitmap); } }
public override void ReadSegment() { base.ReadSegment(); /** read text region Segment flags */ ReadHalftoneRegionFlags(); short[] buf = new short[4]; decoder.Readbyte(buf); int gridWidth = BinaryOperation.GetInt32(buf); buf = new short[4]; decoder.Readbyte(buf); int gridHeight = BinaryOperation.GetInt32(buf); buf = new short[4]; decoder.Readbyte(buf); int gridX = BinaryOperation.GetInt32(buf); buf = new short[4]; decoder.Readbyte(buf); int gridY = BinaryOperation.GetInt32(buf); if (JBIG2StreamDecoder.debug) { Console.WriteLine("grid pos and size = " + gridX + ',' + gridY + ' ' + gridWidth + ',' + gridHeight); } buf = new short[2]; decoder.Readbyte(buf); int stepX = BinaryOperation.GetInt16(buf); buf = new short[2]; decoder.Readbyte(buf); int stepY = BinaryOperation.GetInt16(buf); if (JBIG2StreamDecoder.debug) { Console.WriteLine("step size = " + stepX + ',' + stepY); } int[] referedToSegments = segmentHeader.GetReferredToSegments(); if (referedToSegments.Length != 1) { Console.WriteLine("Error in halftone Segment. refSegs should == 1"); } Segment segment = decoder.FindSegment(referedToSegments[0]); if (segment.GetSegmentHeader().GetSegmentType() != Segment.PATTERN_DICTIONARY) { if (JBIG2StreamDecoder.debug) { Console.WriteLine("Error in halftone Segment. bad symbol dictionary reference"); } } PatternDictionarySegment patternDictionarySegment = (PatternDictionarySegment)segment; int bitsPerValue = 0, i = 1; while (i < patternDictionarySegment.GetSize()) { bitsPerValue++; i <<= 1; } JBIG2Bitmap bitmap = patternDictionarySegment.GetBitmaps()[0]; long patternWidth = bitmap.GetWidth(); long patternHeight = bitmap.GetHeight(); if (JBIG2StreamDecoder.debug) { Console.WriteLine("pattern size = " + patternWidth + ',' + patternHeight); } bool 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); bool 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); } }
public override void ReadSegment() { if (JBIG2StreamDecoder.debug) { Console.WriteLine("==== Reading Immediate Generic Region ===="); } base.ReadSegment(); /** read text region Segment flags */ ReadGenericRegionFlags(); bool useMMR = genericRegionFlags.GetFlagValue(GenericRegionFlags.MMR) != 0; int template = genericRegionFlags.GetFlagValue(GenericRegionFlags.GB_TEMPLATE); short[] genericBAdaptiveTemplateX = new short[4]; short[] genericBAdaptiveTemplateY = new short[4]; if (!useMMR) { if (template == 0) { genericBAdaptiveTemplateX[0] = ReadATValue(); genericBAdaptiveTemplateY[0] = ReadATValue(); genericBAdaptiveTemplateX[1] = ReadATValue(); genericBAdaptiveTemplateY[1] = ReadATValue(); genericBAdaptiveTemplateX[2] = ReadATValue(); genericBAdaptiveTemplateY[2] = ReadATValue(); genericBAdaptiveTemplateX[3] = ReadATValue(); genericBAdaptiveTemplateY[3] = ReadATValue(); } else { genericBAdaptiveTemplateX[0] = ReadATValue(); genericBAdaptiveTemplateY[0] = ReadATValue(); } arithmeticDecoder.ResetGenericStats(template, null); arithmeticDecoder.Start(); } bool typicalPredictionGenericDecodingOn = genericRegionFlags.GetFlagValue(GenericRegionFlags.TPGDON) != 0; int length = segmentHeader.GetSegmentDataLength(); if (length == -1) { /** * length of data is unknown, so it needs to be determined through examination of the data. * See 7.2.7 - Segment data length of the JBIG2 specification. */ unknownLength = true; short match1; short match2; if (useMMR) { // look for 0x00 0x00 (0, 0) match1 = 0; match2 = 0; } else { // look for 0xFF 0xAC (255, 172) match1 = 255; match2 = 172; } int bytesRead = 0; while (true) { short bite1 = decoder.Readbyte(); bytesRead++; if (bite1 == match1) { short bite2 = decoder.Readbyte(); bytesRead++; if (bite2 == match2) { length = bytesRead - 2; break; } } } decoder.MovePointer(-bytesRead); } JBIG2Bitmap bitmap = new JBIG2Bitmap(regionBitmapWidth, regionBitmapHeight, arithmeticDecoder, huffmanDecoder, mmrDecoder); bitmap.Clear(0); bitmap.ReadBitmap(useMMR, template, typicalPredictionGenericDecodingOn, false, null, genericBAdaptiveTemplateX, genericBAdaptiveTemplateY, useMMR ? 0 : length - 18); if (inlineImage) { PageInformationSegment pageSegment = decoder.FindPageSegement(segmentHeader.GetPageAssociation()); JBIG2Bitmap pageBitmap = pageSegment.GetPageBitmap(); int extCombOp = regionFlags.GetFlagValue(RegionFlags.EXTERNAL_COMBINATION_OPERATOR); if (pageSegment.GetPageBitmapHeight() == -1 && regionBitmapYLocation + regionBitmapHeight > pageBitmap.GetHeight()) { pageBitmap.Expand(regionBitmapYLocation + regionBitmapHeight, pageSegment.GetPageInformationFlags().GetFlagValue(PageInformationFlags.DEFAULT_PIXEL_VALUE)); } pageBitmap.Combine(bitmap, regionBitmapXLocation, regionBitmapYLocation, extCombOp); } else { bitmap.SetBitmapNumber(GetSegmentHeader().GetSegmentNumber()); decoder.AppendBitmap(bitmap); } if (unknownLength) { decoder.MovePointer(4); } }