Java LittleEndian.getInt方法代码示例

import org.apache.poi.util.LittleEndian; //导入方法依赖的package包/类
/**
 * creates the List data
 *
 * @param tableStream Main table stream buffer.
 */
private void createListTables(byte[] tableStream)
{


  int lfoOffset = LittleEndian.getInt(_header, 0x2ea);
  int lfoSize = LittleEndian.getInt(_header, 0x2ee);
  byte[] plflfo = new byte[lfoSize];

  System.arraycopy(tableStream, lfoOffset, plflfo, 0, lfoSize);

  int lstOffset = LittleEndian.getInt(_header, 0x2e2);
  int lstSize = LittleEndian.getInt(_header, 0x2e2);
  if(lstOffset > 0 && lstSize > 0)
  {
    lstSize = lfoOffset - lstOffset;
    byte[] plcflst = new byte[lstSize];
    System.arraycopy(tableStream, lstOffset, plcflst, 0, lstSize);
    _listTables = new ListTables(plcflst, plflfo);
  }

}
 

import org.apache.poi.util.LittleEndian; //导入方法依赖的package包/类
public void fillFields( byte[] data, int offset )
{
    int lcb = LittleEndian.getInt( data, offset );
    int cbHeader = LittleEndian.getUShort( data, offset
            + LittleEndian.INT_SIZE );

    if ( cbHeader != 0x44 )
    {
        log.log( POILogger.WARN, "NilPICFAndBinData at offset ", offset,
                " cbHeader 0x" + Integer.toHexString( cbHeader )
                        + " != 0x44" );
    }

    // skip the 62 ignored bytes
    int binaryLength = lcb - cbHeader;
    this._binData = ArrayUtil.copyOfRange( data, offset + cbHeader,
            offset + cbHeader + binaryLength );
}
 

import org.apache.poi.util.LittleEndian; //导入方法依赖的package包/类
public PieceDescriptor(byte[] buf, int offset)
{
  descriptor = LittleEndian.getShort(buf, offset);
  offset += LittleEndian.SHORT_SIZE;
  fc = LittleEndian.getInt(buf, offset);
  offset += LittleEndian.INT_SIZE;
  prm = new PropertyModifier( LittleEndian.getShort(buf, offset));

  // see if this piece uses unicode.
  if ((fc & 0x40000000) == 0)
  {
      unicode = true;
  }
  else
  {
      unicode = false;
      fc &= ~(0x40000000);//gives me FC in doc stream
      fc /= 2;
  }

}
 

import org.apache.poi.util.LittleEndian; //导入方法依赖的package包/类
public boolean extractText( OutputStreamWriter out, byte[] paramArrayOfByte ) throws Exception
{
	int i = LittleEndian.getInt(paramArrayOfByte, 24);
	int j = LittleEndian.getInt(paramArrayOfByte, 28);

	int k = LittleEndian.getInt(paramArrayOfByte, 184);
	int m = LittleEndian.getInt(paramArrayOfByte, 188);

	Word6CHPBinTable localWord6CHPBinTable = new Word6CHPBinTable( paramArrayOfByte, k, m, i );

	List localList = localWord6CHPBinTable.getTextRuns();

	Iterator localIterator = localList.iterator();
	while( localIterator.hasNext() )
	{
		CHPX localCHPX = (CHPX)localIterator.next();
		int n = localCHPX.getStart() + i;
		int i1 = localCHPX.getEnd() + i;

		if( !isDeleted(localCHPX.getGrpprl()) )
		{
			String str = new String(paramArrayOfByte, n, Math.min(i1, j) - n, "Cp1252");
			str = str.replaceAll("\r\n", "\n");
			str = str.replaceAll("\r", "\n");
			out.write(str);
			if( i1 >= j )
			{
				break;
			}
		}
	}

	return true;
}
 

import org.apache.poi.util.LittleEndian; //导入方法依赖的package包/类
/**
 * Tree walking way of finding Escher Child Records
 */
private void findEscherChildren(DefaultEscherRecordFactory erf, byte[] source, int startPos, int lenToGo, Vector<EscherRecord> found) {

	int escherBytes = LittleEndian.getInt( source, startPos + 4 ) + 8;

	// Find the record
	EscherRecord r = erf.createRecord(source,startPos);
	// Fill it in
	r.fillFields( source, startPos, erf );
	// Save it
	found.add(r);

	// Wind on
	int size = r.getRecordSize();
	if(size < 8) {
		logger.log(POILogger.WARN, "Hit short DDF record at " + startPos + " - " + size);
	}

	/**
	 * Sanity check. Always advance the cursor by the correct value.
	 *
	 * getRecordSize() must return exactly the same number of bytes that was written in fillFields.
	 * Sometimes it is not so, see an example in bug #44770. Most likely reason is that one of ddf records calculates wrong size.
	 */
	if(size != escherBytes){
		logger.log(POILogger.WARN, "Record length=" + escherBytes + " but getRecordSize() returned " + r.getRecordSize() + "; record: " + r.getClass());
		size = escherBytes;
	}
	startPos += size;
	lenToGo -= size;
	if(lenToGo >= 8) {
		findEscherChildren(erf, source, startPos, lenToGo, found);
	}
}
 

import org.apache.poi.util.LittleEndian; //导入方法依赖的package包/类
/**
 * Opens an input stream which will decompress the data on the fly.
 *
 * @return the data input stream.
 */
public InputStream getData() {
    if (isCompressed()) {
        int size = LittleEndian.getInt(_data);

        InputStream compressedStream = new ByteArrayInputStream(_data, 4, _data.length);
        return new BoundedInputStream(new InflaterInputStream(compressedStream), size);
    } else {
        return new ByteArrayInputStream(_data, 0, _data.length);
    }
}
 

import org.apache.poi.util.LittleEndian; //导入方法依赖的package包/类
/**
 * For the SlidePersist Atom
 */
protected SlidePersistAtom(byte[] source, int start, int len) {
	// Sanity Checking
	if(len < 8) { len = 8; }

	// Get the header
	_header = new byte[8];
	System.arraycopy(source,start,_header,0,8);

	// Grab the reference ID
	refID = LittleEndian.getInt(source,start+8);

	// Next up is a set of flags, but only bit 3 is used!
	int flags = LittleEndian.getInt(source,start+12);
	if(flags == 4) {
		hasShapesOtherThanPlaceholders = true;
	} else {
		hasShapesOtherThanPlaceholders = false;
	}

	// Now the number of Placeholder Texts
	numPlaceholderTexts = LittleEndian.getInt(source,start+16);

	// Last useful one is the unique slide identifier
	slideIdentifier = LittleEndian.getInt(source,start+20);

	// Finally you have typically 4 or 8 bytes of reserved fields,
	//  all zero running from 24 bytes in to the end
	reservedFields = new byte[len-24];
	System.arraycopy(source,start+24,reservedFields,0,reservedFields.length);
}
 

import org.apache.poi.util.LittleEndian; //导入方法依赖的package包/类
protected void fillFields( byte[] data, int offset )
{
    field_1_spid                   = LittleEndian.getInt(data, 0x0 + offset);
    field_2_xaLeft                 = LittleEndian.getInt(data, 0x4 + offset);
    field_3_yaTop                  = LittleEndian.getInt(data, 0x8 + offset);
    field_4_xaRight                = LittleEndian.getInt(data, 0xc + offset);
    field_5_yaBottom               = LittleEndian.getInt(data, 0x10 + offset);
    field_6_flags                  = LittleEndian.getShort(data, 0x14 + offset);
    field_7_cTxbx                  = LittleEndian.getInt(data, 0x16 + offset);
}
 

import org.apache.poi.util.LittleEndian; //导入方法依赖的package包/类
/**
 * Constructs the ExControlAtom record from its source data.
 *
 * @param source the source data as a byte array.
 * @param start  the start offset into the byte array.
 * @param len    the length of the slice in the byte array.
 */
protected ExControlAtom(byte[] source, int start, int len) {
    // Get the header.
    _header = new byte[8];
    System.arraycopy(source, start, _header, 0, 8);

    _id = LittleEndian.getInt(source, start + 8);
}
 

import org.apache.poi.util.LittleEndian; //导入方法依赖的package包/类
public PAPBinTable( byte[] documentStream, byte[] tableStream,
        byte[] dataStream, int offset, int size,
        CharIndexTranslator charIndexTranslator )
{
    long start = System.currentTimeMillis();

    {
        PlexOfCps binTable = new PlexOfCps( tableStream, offset, size, 4 );

        int length = binTable.length();
        for ( int x = 0; x < length; x++ )
        {
            GenericPropertyNode node = binTable.getProperty( x );

            int pageNum = LittleEndian.getInt( node.getBytes() );
            int pageOffset = POIFSConstants.SMALLER_BIG_BLOCK_SIZE
                    * pageNum;

            PAPFormattedDiskPage pfkp = new PAPFormattedDiskPage(
                    documentStream, dataStream, pageOffset,
                    charIndexTranslator );

            for ( PAPX papx : pfkp.getPAPXs() )
            {
                if ( papx != null )
                    _paragraphs.add( papx );
            }
        }
    }

    logger.log( POILogger.DEBUG, "PAPX tables loaded in ",
            Long.valueOf( System.currentTimeMillis() - start ), " ms (",
            Integer.valueOf( _paragraphs.size() ), " elements)" );

    if ( _paragraphs.isEmpty() )
    {
        logger.log( POILogger.WARN, "PAPX FKPs are empty" );
        _paragraphs.add( new PAPX( 0, 0, new SprmBuffer( 2 ) ) );
    }
}
 

import org.apache.poi.util.LittleEndian; //导入方法依赖的package包/类
/**
 * Dumps the Pictures OLE stream into XML.
 *
 * @param data from the Pictures OLE data stream
 * @param padding
 * @throws java.io.IOException
 */
public void dumpPictures(byte[] data, int padding) throws IOException {
    int pos = 0;
    while (pos < data.length) {
        byte[] header = new byte[PICT_HEADER_SIZE];

        System.arraycopy(data, pos, header, 0, header.length);
        int size = LittleEndian.getInt(header, 4) - 17;
        byte[] pictdata = new byte[size];
        System.arraycopy(data, pos + PICT_HEADER_SIZE, pictdata, 0, pictdata.length);
        pos += PICT_HEADER_SIZE + size;

        padding++;
        write(out, "<picture size=\""+size+"\" type=\""+getPictureType(header)+"\">" + CR, padding);
        padding++;
        write(out, "<header>" + CR, padding);
        dump(out, header, 0, header.length, padding, true);
        write(out, "</header>" + CR, padding);
        write(out, "<imgdata>" + CR, padding);
        dump(out, pictdata, 0, Math.min(pictdata.length, 100), padding, true);
        write(out, "</imgdata>" + CR, padding);
        padding--;
        write(out, "</picture>" + CR, padding);
        padding--;

    }
}
 

import org.apache.poi.util.LittleEndian; //导入方法依赖的package包/类
/**
 * Goes through the piece table and parses out the info regarding the text
 * blocks. For Word 97 and greater all text is stored in the "complex" way
 * because of unicode.
 *
 * @param tableStream buffer containing the main table stream.
 * @param beginning of the complex data.
 * @throws IOException
 */
private void findText(byte[] tableStream, int complexOffset) throws IOException
{
  //actual text
  int pos = complexOffset;
  //skips through the prms before we reach the piece table. These contain data
  //for actual fast saved files
  while(tableStream[pos] == 1)
  {
      pos++;
      int skip = LittleEndian.getShort(tableStream, pos);
      pos += 2 + skip;
  }
  if(tableStream[pos] != 2)
  {
      throw new IOException("corrupted Word file");
  }
  //parse out the text pieces
  int pieceTableSize = LittleEndian.getInt(tableStream, ++pos);
  pos += 4;
  int pieces = (pieceTableSize - 4) / 12;
  for (int x = 0; x < pieces; x++)
  {
      int filePos = LittleEndian.getInt(tableStream, pos + ((pieces + 1) * 4) + (x * 8) + 2);
      boolean unicode = false;
      if ((filePos & 0x40000000) == 0)
      {
          unicode = true;
      }
      else
      {
          unicode = false;
          filePos &= ~(0x40000000);//gives me FC in doc stream
          filePos /= 2;
      }
      int totLength = LittleEndian.getInt(tableStream, pos + (x + 1) * 4) -
                      LittleEndian.getInt(tableStream, pos + (x * 4));

      TextPiece piece = new TextPiece(filePos, totLength, unicode);
      _text.add(piece);
  }
}
 

import org.apache.poi.util.LittleEndian; //导入方法依赖的package包/类
private void initParagraphProperties(int parOffset, PlexOfCps parPlcf, int charOffset, PlexOfCps charPlcf, int start, int end)
{
    //Initialize paragraph property stuff
    //int currentParPage = _parParsingState.getCurrentPage();
    int parPlcfLen = parPlcf.length();
    int currentPageIndex = _parParsingState.getCurrentPageIndex();
    FormattedDiskPage fkp = _parParsingState.getFkp();
    int currentPapxIndex = _parParsingState.getCurrentPropIndex();
    int currentArraySize = fkp.size();

    do
    {
      if (currentPapxIndex < currentArraySize)
      {
        int parStart = fkp.getStart(currentPapxIndex);
        int parEnd = fkp.getEnd(currentPapxIndex);
        byte[] papx = fkp.getGrpprl(currentPapxIndex);
        _listener.paragraph(new PapxNode(Math.max(parStart, start), Math.min(parEnd, end), papx));
        initCharacterProperties(charOffset, charPlcf, Math.max(start, parStart), Math.min(parEnd, end));
        if (parEnd < end)
        {
          currentPapxIndex++;
        }
        else
        {
          //save the state
          _parParsingState.setState(currentPageIndex, fkp, currentPapxIndex);
          break;
        }
      }
      else
      {
        int currentParPage = LittleEndian.getInt(_tableBuffer, parOffset + parPlcf.getStructOffset(++currentPageIndex));
        byte byteFkp[] = new byte[512];
        System.arraycopy(_mainDocument, (currentParPage * 512), byteFkp, 0, 512);
        fkp = new PAPFormattedDiskPage(byteFkp);
        currentPapxIndex = 0;
        currentArraySize = fkp.size();
      }
    }
    while(currentPageIndex < parPlcfLen);
}
 

import org.apache.poi.util.LittleEndian; //导入方法依赖的package包/类
private HeaderFooter createSectionHdrFtr(int index, int type)
{
  if(_hdrSize < 50)
  {
    return new HeaderFooter(0,0,0);
  }

  int start = _fcMin + _ccpText + _ccpFtn;
  int end = start;
  int arrayIndex = 0;

  switch(type)
  {
    case HeaderFooter.HEADER_EVEN:
         arrayIndex = (HEADER_EVEN_INDEX + (index * 6));
         break;
    case HeaderFooter.FOOTER_EVEN:
         arrayIndex = (FOOTER_EVEN_INDEX + (index * 6));
         break;
    case HeaderFooter.HEADER_ODD:
         arrayIndex = (HEADER_ODD_INDEX + (index * 6));
         break;
    case HeaderFooter.FOOTER_ODD:
         arrayIndex = (FOOTER_ODD_INDEX + (index * 6));
         break;
    case HeaderFooter.HEADER_FIRST:
         arrayIndex = (HEADER_FIRST_INDEX + (index * 6));
         break;
    case HeaderFooter.FOOTER_FIRST:
         arrayIndex = (FOOTER_FIRST_INDEX + (index * 6));
         break;
  }
  start += LittleEndian.getInt(_tableStream, _hdrOffset + (arrayIndex * 4));
  end += LittleEndian.getInt(_tableStream, _hdrOffset + (arrayIndex + 1) * 4);

  HeaderFooter retValue = new HeaderFooter(type, start, end);

  if((end - start) == 0 && index > 1)
  {
    retValue = createSectionHdrFtr(type, index - 1);
  }
  return retValue;
}
 

import org.apache.poi.util.LittleEndian; //导入方法依赖的package包/类
public Colorref( byte[] data, int offset )
{
    this.value = LittleEndian.getInt( data, offset );
}