private int readBytes(Entry entry, byte[] buffer) throws IOException {
byte[] header = getHeader(entry);
// entry is not compressed?
if (get2ByteLittleEndian(header, 8) == 0) {
zipRandomFile.skipBytes(get2ByteLittleEndian(header, 26) + get2ByteLittleEndian(header, 28));
int offset = 0;
int size = buffer.length;
while (offset < size) {
int count = zipRandomFile.read(buffer, offset, size - offset);
if (count == -1) break;
offset += count;
}
return entry.size;
}
int csize = entry.compressedSize;
byte[] cbuf = new byte[csize];
zipRandomFile.skipBytes(get2ByteLittleEndian(header, 26) + get2ByteLittleEndian(header, 28));
zipRandomFile.readFully(cbuf, 0, csize);
int count = inflate(cbuf, buffer);
if (count == -1) throw new ZipException("corrupted zip file");
return entry.size;
}
private boolean findSPSandPPS() {
/*
* SPS and PPS parameters are stored in the avcC box
* You may find really useful information about this box
* in the document ISO-IEC 14496-15, part 5.2.4.1.1
* The box's structure is described there
*
* aligned(8) class AVCDecoderConfigurationRecord {
* unsigned int(8) configurationVersion = 1;
* unsigned int(8) AVCProfileIndication;
* unsigned int(8) profile_compatibility;
* unsigned int(8) AVCLevelIndication;
* bit(6) reserved = ‘111111’b;
* unsigned int(2) lengthSizeMinusOne;
* bit(3) reserved = ‘111’b;
* unsigned int(5) numOfSequenceParameterSets;
* for (i=0; i< numOfSequenceParameterSets; i++) {
* unsigned int(16) sequenceParameterSetLength ;
* bit(8*sequenceParameterSetLength) sequenceParameterSetNALUnit;
* }
* unsigned int(8) numOfPictureParameterSets;
* for (i=0; i< numOfPictureParameterSets; i++) {
* unsigned int(16) pictureParameterSetLength;
* bit(8*pictureParameterSetLength) pictureParameterSetNALUnit;
* }
* }
*
*
*
*/
try {
// TODO: Here we assume that numOfSequenceParameterSets = 1, numOfPictureParameterSets = 1 !
// Here we extract the SPS parameter
fis.skipBytes(7);
spsLength = 0xFF & fis.readByte();
sps = new byte[spsLength];
fis.read(sps, 0, spsLength);
// Here we extract the PPS parameter
fis.skipBytes(2);
ppsLength = 0xFF & fis.readByte();
pps = new byte[ppsLength];
fis.read(pps, 0, ppsLength);
} catch (IOException e) {
return false;
}
return true;
}
@Override
protected void parseBody(final RandomAccessFile mpegFile) throws IOException {
final int size = (int) (super.seekToBodyStart(mpegFile) - 4);
mpegFile.skipBytes(4); // Reserved
rawBytes = new byte[size];
mpegFile.readFully(rawBytes);
}
/** {@inheritDoc} */
public int skipBytes(final int n) throws IOException {
fileSize -= n;
if (fileSize < 0) {
throw new EOFException();
}
return dataInput.skipBytes(n);
}
/**
* Seek for box with the specified id starting from the current location of filepointer,
*
* <p>Note it wont find the box if it is contained with a level below the current level, nor if we
* are at a parent atom that also contains data and we havent yet processed the data. It will work
* if we are at the start of a child box even if it not the required box as long as the box we are
* looking for is the same level (or the level above in some cases).
*
* @param raf
* @param id
* @throws java.io.IOException
*/
public static Mp4BoxHeader seekWithinLevel(RandomAccessFile raf, String id) throws IOException {
logger.finer("Started searching for:" + id + " in file at:" + raf.getChannel().position());
Mp4BoxHeader boxHeader = new Mp4BoxHeader();
ByteBuffer headerBuffer = ByteBuffer.allocate(HEADER_LENGTH);
int bytesRead = raf.getChannel().read(headerBuffer);
if (bytesRead != HEADER_LENGTH) {
return null;
}
headerBuffer.rewind();
boxHeader.update(headerBuffer);
while (!boxHeader.getId().equals(id)) {
logger.finer("Still searching for:" + id + " in file at:" + raf.getChannel().position());
// Something gone wrong probably not at the start of an atom so return null;
if (boxHeader.getLength() < Mp4BoxHeader.HEADER_LENGTH) {
return null;
}
int noOfBytesSkipped = raf.skipBytes(boxHeader.getDataLength());
logger.finer("Skipped:" + noOfBytesSkipped);
if (noOfBytesSkipped < boxHeader.getDataLength()) {
return null;
}
headerBuffer.rewind();
bytesRead = raf.getChannel().read(headerBuffer);
logger.finer("Header Bytes Read:" + bytesRead);
headerBuffer.rewind();
if (bytesRead == Mp4BoxHeader.HEADER_LENGTH) {
boxHeader.update(headerBuffer);
} else {
return null;
}
}
return boxHeader;
}
private static void alterLastIFDOffset(RandomAccessFile rFile, int fileLen) throws IOException {
rFile.seek(0);
rFile.skipBytes(4);
int offsetIFD = rFile.readInt();
while (true) {
rFile.seek(offsetIFD);
int dirs = rFile.readShort();
rFile.skipBytes(dirs * 12);
offsetIFD = rFile.readInt();
if (offsetIFD == 0) {
int pointer = (int) rFile.getFilePointer();
rFile.seek(pointer - 4);
rFile.writeInt(fileLen);
break;
}
}
}
public static ZipFile.EocdRecord parseZip64EocdRecord(
RandomAccessFile raf, long eocdRecordOffset, int commentLength) throws IOException {
raf.seek(eocdRecordOffset);
final int signature = Integer.reverseBytes(raf.readInt());
if (signature != ZIP64_EOCD_RECORD_SIGNATURE) {
throw new ZipException(
"Invalid zip64 eocd record offset, sig="
+ Integer.toHexString(signature)
+ " offset="
+ eocdRecordOffset);
}
// The zip64 eocd record specifies its own size as an 8 byte integral type. It is variable
// length because of the "zip64 extensible data sector" but that field is reserved for
// pkware's proprietary use. We therefore disregard it altogether and treat the end of
// central directory structure as fixed length.
//
// We also skip "version made by" (2 bytes) and "version needed to extract" (2 bytes)
// fields. We perform additional validation at the ZipEntry level, where applicable.
//
// That's a total of 12 bytes to skip
raf.skipBytes(12);
byte[] zip64Eocd = new byte[ZIP64_EOCD_RECORD_EFFECTIVE_SIZE];
raf.readFully(zip64Eocd);
ByteBuffer buf = ByteBuffer.wrap(zip64Eocd).order(ByteOrder.LITTLE_ENDIAN);
try {
int diskNumber = buf.getInt();
int diskWithCentralDirStart = buf.getInt();
long numEntries = buf.getLong();
long totalNumEntries = buf.getLong();
buf.getLong(); // Ignore the size of the central directory
long centralDirOffset = buf.getLong();
if (numEntries != totalNumEntries || diskNumber != 0 || diskWithCentralDirStart != 0) {
throw new ZipException(
"Spanned archives not supported :"
+ " numEntries="
+ numEntries
+ ", totalNumEntries="
+ totalNumEntries
+ ", diskNumber="
+ diskNumber
+ ", diskWithCentralDirStart="
+ diskWithCentralDirStart);
}
return new ZipFile.EocdRecord(numEntries, centralDirOffset, commentLength);
} catch (BufferUnderflowException bue) {
ZipException zipException = new ZipException("Error parsing zip64 eocd record.");
zipException.initCause(bue);
throw zipException;
}
}
private void parse(String path, long len) throws IOException {
ByteBuffer byteBuffer;
long sum = 0, newlen = 0;
byte[] buffer = new byte[8];
String name = "";
if (!path.equals("")) mBoxes.put(path, mPos - 8);
while (sum < len) {
mFile.read(buffer, 0, 8);
mPos += 8;
sum += 8;
if (validBoxName(buffer)) {
name = new String(buffer, 4, 4);
if (buffer[3] == 1) {
// 64 bits atom size
mFile.read(buffer, 0, 8);
mPos += 8;
sum += 8;
byteBuffer = ByteBuffer.wrap(buffer, 0, 8);
newlen = byteBuffer.getLong() - 16;
} else {
// 32 bits atom size
byteBuffer = ByteBuffer.wrap(buffer, 0, 4);
newlen = byteBuffer.getInt() - 8;
}
// 1061109559+8 correspond to "????" in ASCII the HTC Desire S seems to write that
// sometimes, maybe other phones do
// "wide" atom would produce a newlen == 0, and we shouldn't throw an exception because of
// that
if (newlen < 0 || newlen == 1061109559) throw new IOException();
Log.d(TAG, "Atom -> name: " + name + " position: " + mPos + ", length: " + newlen);
sum += newlen;
parse(path + '/' + name, newlen);
} else {
if (len < 8) {
mFile.seek(mFile.getFilePointer() - 8 + len);
sum += len - 8;
} else {
int skipped = mFile.skipBytes((int) (len - 8));
if (skipped < ((int) (len - 8))) {
throw new IOException();
}
mPos += len - 8;
sum += len - 8;
}
}
}
}
public void init() throws IOException {
mSound.skipBytes(8);
int count = readInt();
int type;
for (int i = 0; i < count; i++) {
type = readInt();
mapping.put(type, new Sound(readInt(), readInt()));
}
}
/* Package visible for testing */
static CentralDirectory findCentralDirectory(RandomAccessFile raf)
throws IOException, ZipException {
long scanOffset = raf.length() - ENDHDR;
if (scanOffset < 0) {
throw new ZipException("File too short to be a zip file: " + raf.length());
}
long stopOffset = scanOffset - 0x10000 /* ".ZIP file comment"'s max length */;
if (stopOffset < 0) {
stopOffset = 0;
}
int endSig = Integer.reverseBytes(ENDSIG);
while (true) {
raf.seek(scanOffset);
if (raf.readInt() == endSig) {
break;
}
scanOffset--;
if (scanOffset < stopOffset) {
throw new ZipException("End Of Central Directory signature not found");
}
}
// Read the End Of Central Directory. ENDHDR includes the signature
// bytes,
// which we've already read.
// Pull out the information we need.
raf.skipBytes(2); // diskNumber
raf.skipBytes(2); // diskWithCentralDir
raf.skipBytes(2); // numEntries
raf.skipBytes(2); // totalNumEntries
CentralDirectory dir = new CentralDirectory();
dir.size = Integer.reverseBytes(raf.readInt()) & 0xFFFFFFFFL;
dir.offset = Integer.reverseBytes(raf.readInt()) & 0xFFFFFFFFL;
return dir;
}
@Override
public int write(AudioInputStream stream, AudioFileFormat.Type fileType, File out)
throws IOException {
Objects.requireNonNull(stream);
Objects.requireNonNull(fileType);
Objects.requireNonNull(out);
// throws IllegalArgumentException if not supported
WaveFileFormat waveFileFormat = (WaveFileFormat) getAudioFileFormat(fileType, stream);
// first write the file without worrying about length fields
FileOutputStream fos = new FileOutputStream(out); // throws IOException
BufferedOutputStream bos = new BufferedOutputStream(fos, bisBufferSize);
int bytesWritten = writeWaveFile(stream, waveFileFormat, bos);
bos.close();
// now, if length fields were not specified, calculate them,
// open as a random access file, write the appropriate fields,
// close again....
if (waveFileFormat.getByteLength() == AudioSystem.NOT_SPECIFIED) {
int dataLength = bytesWritten - waveFileFormat.getHeaderSize();
int riffLength = dataLength + waveFileFormat.getHeaderSize() - 8;
RandomAccessFile raf = new RandomAccessFile(out, "rw");
// skip RIFF magic
raf.skipBytes(4);
raf.writeInt(big2little(riffLength));
// skip WAVE magic, fmt_ magic, fmt_ length, fmt_ chunk, data magic
raf.skipBytes(4 + 4 + 4 + WaveFileFormat.getFmtChunkSize(waveFileFormat.getWaveType()) + 4);
raf.writeInt(big2little(dataLength));
// that's all
raf.close();
}
return bytesWritten;
}
private void insertLine(File file, HttpSample httpSample) throws IOException {
RandomAccessFile randomAccessFile = null;
try {
randomAccessFile = new RandomAccessFile(file, "rw");
randomAccessFile.skipBytes((int) (file.length() - "\n</httpSamples>".getBytes().length));
randomAccessFile.write("\n".getBytes());
randomAccessFile.write(httpSample.toXML().getBytes());
randomAccessFile.write("\n".getBytes());
randomAccessFile.write("</httpSamples>".getBytes());
} finally {
if (randomAccessFile != null) {
randomAccessFile.close();
}
}
}
private byte[] readBytes(Entry entry) throws IOException {
byte[] header = getHeader(entry);
int csize = entry.compressedSize;
byte[] cbuf = new byte[csize];
zipRandomFile.skipBytes(get2ByteLittleEndian(header, 26) + get2ByteLittleEndian(header, 28));
zipRandomFile.readFully(cbuf, 0, csize);
// is this compressed - offset 8 in the ZipEntry header
if (get2ByteLittleEndian(header, 8) == 0) return cbuf;
int size = entry.size;
byte[] buf = new byte[size];
if (inflate(cbuf, buf) != size) throw new ZipException("corrupted zip file");
return buf;
}
public static void appendData(File outfile, float[] data) throws IOException {
RandomAccessFile raFile = new RandomAccessFile(outfile, "rw");
try {
SacHeader header = new SacHeader(raFile);
if (header.getLeven() == FALSE
|| header.getIftype() == IRLIM
|| header.getIftype() == IAMPH) {
raFile.close();
throw new IOException("Can only append to evenly sampled sac files, ie only Y");
}
int origNpts = header.getNpts();
header.setNpts(header.getNpts() + data.length);
header.setE((header.getNpts() - 1) * header.getDelta());
raFile.seek(0);
header.writeHeader(raFile);
raFile.skipBytes(origNpts * 4); // four bytes per float
if (header.getByteOrder() == LITTLE_ENDIAN) {
// Phil Crotwell's solution:
// careful here as dos.writeFloat() will collapse all NaN floats
// to
// a single NaN value. But we are trying to write out byte
// swapped values
// so different floats that are all NaN are different values in
// the
// other byte order. Solution is to swap on the integer bits,
// not the float.
for (int i = 0; i < data.length; i++) {
raFile.writeInt(SacHeader.swapBytes(Float.floatToRawIntBits(data[i])));
}
} else {
for (int i = 0; i < data.length; i++) {
raFile.writeFloat(data[i]);
}
}
} finally {
raFile.close();
}
}
@Override
public void write(OutputStream output) throws IOException, WebApplicationException {
RandomAccessFile raf = new RandomAccessFile(file, "r");
int length;
int totalWrittenLength = 0;
byte[] bytes = new byte[BLOCK_SIZE];
if (range != null) {
int lengthOfTheBytesRange = range.getlengthOfTheBytesRange();
raf.skipBytes((int) range.getMin());
while ((length = raf.read(bytes)) != -1) {
if (totalWrittenLength + length < lengthOfTheBytesRange) {
output.write(bytes, 0, length);
totalWrittenLength += length;
} else {
int lengthToWrite = lengthOfTheBytesRange - totalWrittenLength;
output.write(bytes, 0, lengthToWrite);
totalWrittenLength += lengthToWrite;
break;
}
}
} else {
while ((length = raf.read(bytes)) != -1) {
output.write(bytes, 0, length);
totalWrittenLength += length;
}
}
raf.close();
}
private long findNextEOLPosition(RandomAccessFile seeakable, long blocksize)
throws IOException, EndReachedException {
if (seeakable.skipBytes((int) blocksize) < blocksize) throw new EndReachedException();
else seeakable.readLine();
return seeakable.getFilePointer();
}
/**
* The Vorbis Setup Header may span multiple(2) pages, athough it doesnt normally. We pass the
* start of the file offset of the OggPage it belongs on, it probably won't be first packet, also
* returns any addditional packets that immediately follow the setup header in original file
*
* @param fileOffsetOfStartingOggPage
* @param raf
* @return
* @throws org.jaudiotagger.audio.exceptions.CannotReadException
* @throws java.io.IOException
*/
public byte[] convertToVorbisSetupHeaderPacketAndAdditionalPackets(
long fileOffsetOfStartingOggPage, RandomAccessFile raf)
throws IOException, CannotReadException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
// Seek to specified offset
raf.seek(fileOffsetOfStartingOggPage);
// Read Page
OggPageHeader setupPageHeader = OggPageHeader.read(raf);
// Assume that if multiple packets first packet is VorbisComment and second packet
// is setupheader
if (setupPageHeader.getPacketList().size() > 1) {
raf.skipBytes(setupPageHeader.getPacketList().get(0).getLength());
}
// Now should be at start of next packet, check this is the vorbis setup header
byte[] b =
new byte[VorbisHeader.FIELD_PACKET_TYPE_LENGTH + VorbisHeader.FIELD_CAPTURE_PATTERN_LENGTH];
raf.read(b);
if (!isVorbisSetupHeader(b)) {
throw new CannotReadException("Unable to find setup header(2), unable to write ogg file");
}
// Go back to start of setupheader data
raf.seek(
raf.getFilePointer()
- (VorbisHeader.FIELD_PACKET_TYPE_LENGTH + VorbisHeader.FIELD_CAPTURE_PATTERN_LENGTH));
// Read data
if (setupPageHeader.getPacketList().size() > 1) {
b = new byte[setupPageHeader.getPacketList().get(1).getLength()];
raf.read(b);
baos.write(b);
} else {
b = new byte[setupPageHeader.getPacketList().get(0).getLength()];
raf.read(b);
baos.write(b);
}
// Return Data
if (!setupPageHeader.isLastPacketIncomplete() || setupPageHeader.getPacketList().size() > 2) {
// //logger.info("Setupheader finishes on this page");
if (setupPageHeader.getPacketList().size() > 2) {
for (int i = 2; i < setupPageHeader.getPacketList().size(); i++) {
b = new byte[setupPageHeader.getPacketList().get(i).getLength()];
raf.read(b);
baos.write(b);
}
}
return baos.toByteArray();
}
// The Setupheader extends to the next page, so should be at end of page already
// so carry on reading pages until we get to the end of comment
while (true) {
// //logger.info("Reading another page");
OggPageHeader nextPageHeader = OggPageHeader.read(raf);
b = new byte[nextPageHeader.getPacketList().get(0).getLength()];
raf.read(b);
baos.write(b);
// Because there is at least one other packet this means the Setupheader Packet has finished
// on this page so thats all we need and we can return
if (nextPageHeader.getPacketList().size() > 1) {
// //logger.info("Setupheader finishes on this page");
return baos.toByteArray();
}
// There is only the Setupheader packet on page if it has completed on this page we can return
if (!nextPageHeader.isLastPacketIncomplete()) {
// //logger.info("Setupheader finish on Page because this packet is
// complete");
return baos.toByteArray();
}
}
}
/**
* Calculate the size of the packet data for the comment and setup headers
*
* @param raf
* @return
* @throws CannotReadException
* @throws IOException
*/
public OggVorbisHeaderSizes readOggVorbisHeaderSizes(RandomAccessFile raf)
throws CannotReadException, IOException {
// //logger.fine("Started to read comment and setup header sizes:");
// Stores filepointers so return file in same state
long filepointer = raf.getFilePointer();
// Extra Packets on same page as setup header
List<OggPageHeader.PacketStartAndLength> extraPackets =
new ArrayList<OggPageHeader.PacketStartAndLength>();
long commentHeaderStartPosition;
long setupHeaderStartPosition;
int commentHeaderSize = 0;
int setupHeaderSize;
// 1st page = codec infos
OggPageHeader pageHeader = OggPageHeader.read(raf);
// Skip over data to end of page header 1
raf.seek(raf.getFilePointer() + pageHeader.getPageLength());
// 2nd page = comment, may extend to additional pages or not , may also have setup header
pageHeader = OggPageHeader.read(raf);
commentHeaderStartPosition =
raf.getFilePointer()
- (OggPageHeader.OGG_PAGE_HEADER_FIXED_LENGTH + pageHeader.getSegmentTable().length);
// Now at start of packets on page 2 , check this is the vorbis comment header
byte[] b =
new byte[VorbisHeader.FIELD_PACKET_TYPE_LENGTH + VorbisHeader.FIELD_CAPTURE_PATTERN_LENGTH];
raf.read(b);
if (!isVorbisCommentHeader(b)) {
throw new CannotReadException("Cannot find comment block (no vorbiscomment header)");
}
raf.seek(
raf.getFilePointer()
- (VorbisHeader.FIELD_PACKET_TYPE_LENGTH + VorbisHeader.FIELD_CAPTURE_PATTERN_LENGTH));
// //logger.fine("Found start of comment header at:" + raf.getFilePointer());
// Calculate Comment Size (not inc header)
while (true) {
List<OggPageHeader.PacketStartAndLength> packetList = pageHeader.getPacketList();
commentHeaderSize += packetList.get(0).getLength();
raf.skipBytes(packetList.get(0).getLength());
// If this page contains multiple packets or if this last packet is complete then the Comment
// header
// end son this page and we can break
if (packetList.size() > 1 || !pageHeader.isLastPacketIncomplete()) {
// done comment size
// //logger.fine("Found end of comment:size:" + commentHeaderSize + "finishes
// at file position:" + raf.getFilePointer());
break;
}
pageHeader = OggPageHeader.read(raf);
}
// If there are no more packets on this page we need to go to next page to get the setup header
OggPageHeader.PacketStartAndLength packet;
if (pageHeader.getPacketList().size() == 1) {
pageHeader = OggPageHeader.read(raf);
List<OggPageHeader.PacketStartAndLength> packetList = pageHeader.getPacketList();
packet = pageHeader.getPacketList().get(0);
// Now at start of next packet , check this is the vorbis setup header
b =
new byte
[VorbisHeader.FIELD_PACKET_TYPE_LENGTH + VorbisHeader.FIELD_CAPTURE_PATTERN_LENGTH];
raf.read(b);
if (!isVorbisSetupHeader(b)) {
throw new CannotReadException(ErrorMessage.OGG_VORBIS_NO_VORBIS_HEADER_FOUND.getMsg());
}
raf.seek(
raf.getFilePointer()
- (VorbisHeader.FIELD_PACKET_TYPE_LENGTH
+ VorbisHeader.FIELD_CAPTURE_PATTERN_LENGTH));
// //logger.fine("Found start of vorbis setup header at file position:" +
// raf.getFilePointer());
// Set this to the start of the OggPage that setupheader was found on
setupHeaderStartPosition =
raf.getFilePointer()
- (OggPageHeader.OGG_PAGE_HEADER_FIXED_LENGTH + pageHeader.getSegmentTable().length);
// Add packet data to size to the setup header size
setupHeaderSize = packet.getLength();
// //logger.fine("Adding:" + packetList.get(1).getLength() + " to setup header size");
// Skip over the packet data
raf.skipBytes(packet.getLength());
// If there are other packets that follow this one, or if the last packet is complete then we
// must have
// got the size of the setup header.
if (packetList.size() > 1 || !pageHeader.isLastPacketIncomplete()) {
// logger.info("Found end of setupheader:size:" + setupHeaderSize + "finishes
// at:" + raf.getFilePointer());
if (packetList.size() > 1) {
extraPackets = packetList.subList(1, packetList.size());
}
}
// The setup header continues onto the next page
else {
pageHeader = OggPageHeader.read(raf);
packetList = pageHeader.getPacketList();
while (true) {
setupHeaderSize += packetList.get(0).getLength();
// logger.fine("Adding:" + packetList.get(0).getLength() + " to setup
// header size");
raf.skipBytes(packetList.get(0).getLength());
if (packetList.size() > 1 || !pageHeader.isLastPacketIncomplete()) {
// done setup size
// logger.fine("Found end of setupheader:size:" + setupHeaderSize
// + "finishes at:" + raf.getFilePointer());
if (packetList.size() > 1) {
extraPackets = packetList.subList(1, packetList.size());
}
break;
}
// Continues onto another page
pageHeader = OggPageHeader.read(raf);
}
}
}
// else its next packet on this page
else {
packet = pageHeader.getPacketList().get(1);
List<OggPageHeader.PacketStartAndLength> packetList = pageHeader.getPacketList();
// Now at start of next packet , check this is the vorbis setup header
b =
new byte
[VorbisHeader.FIELD_PACKET_TYPE_LENGTH + VorbisHeader.FIELD_CAPTURE_PATTERN_LENGTH];
raf.read(b);
if (!isVorbisSetupHeader(b)) {
// logger.warning("Expecting but got:" + new String(b) + "at " + (raf.getFilePointer() -
// b.length));
throw new CannotReadException(ErrorMessage.OGG_VORBIS_NO_VORBIS_HEADER_FOUND.getMsg());
}
raf.seek(
raf.getFilePointer()
- (VorbisHeader.FIELD_PACKET_TYPE_LENGTH
+ VorbisHeader.FIELD_CAPTURE_PATTERN_LENGTH));
// logger.info("Found start of vorbis setup header at file position:" +
// raf.getFilePointer());
// Set this to the start of the OggPage that setupheader was found on
setupHeaderStartPosition =
raf.getFilePointer()
- (OggPageHeader.OGG_PAGE_HEADER_FIXED_LENGTH + pageHeader.getSegmentTable().length)
- pageHeader.getPacketList().get(0).getLength();
// Add packet data to size to the setup header size
setupHeaderSize = packet.getLength();
// logger.fine("Adding:" + packet.getLength() + " to setup header size");
// Skip over the packet data
raf.skipBytes(packet.getLength());
// If there are other packets that follow this one, or if the last packet is complete then we
// must have
// got the size of the setup header.
if (packetList.size() > 2 || !pageHeader.isLastPacketIncomplete()) {
// logger.fine("Found end of setupheader:size:" + setupHeaderSize + "finishes
// at:" + raf.getFilePointer());
if (packetList.size() > 2) {
extraPackets = packetList.subList(2, packetList.size());
}
}
// The setup header continues onto the next page
else {
pageHeader = OggPageHeader.read(raf);
packetList = pageHeader.getPacketList();
while (true) {
setupHeaderSize += packetList.get(0).getLength();
// logger.fine("Adding:" + packetList.get(0).getLength() + " to setup
// header size");
raf.skipBytes(packetList.get(0).getLength());
if (packetList.size() > 1 || !pageHeader.isLastPacketIncomplete()) {
// done setup size
// logger.fine("Found end of setupheader:size:" + setupHeaderSize
// + "finishes at:" + raf.getFilePointer());
if (packetList.size() > 1) {
extraPackets = packetList.subList(1, packetList.size());
}
break;
}
// Continues onto another page
pageHeader = OggPageHeader.read(raf);
}
}
}
// Reset filepointer to location that it was in at start of method
raf.seek(filepointer);
return new OggVorbisHeaderSizes(
commentHeaderStartPosition,
setupHeaderStartPosition,
commentHeaderSize,
setupHeaderSize,
extraPackets);
}
/* @see java.io.DataInput.skipBytes(int) */
public int skipBytes(int n) throws IOException {
return raf.skipBytes(n);
}
public void skipBytes(int num) throws IOException {
raf.skipBytes(num);
}
public int skipBytes(int n) throws IOException {
return wrapper.skipBytes(n);
}
@Override
public long skip(long n) throws IOException {
return raf.skipBytes((int) n);
}
private void doRead(
long classId,
long testId,
boolean allClassOutput,
TestOutputEvent.Destination destination,
java.io.Writer writer) {
if (dataFile == null) {
return;
}
Index targetIndex = index.children.get(classId);
if (targetIndex != null && testId != 0) {
targetIndex = targetIndex.children.get(testId);
}
if (targetIndex == null) {
return;
}
boolean stdout = destination == TestOutputEvent.Destination.StdOut;
Region region = stdout ? targetIndex.stdOut : targetIndex.stdErr;
if (region.start < 0) {
return;
}
boolean ignoreClassLevel = !allClassOutput && testId != 0;
boolean ignoreTestLevel = !allClassOutput && testId == 0;
try {
dataFile.seek(region.start);
while (dataFile.getFilePointer() <= region.stop) {
dataFile.read(recordHeaderBuffer);
Input input = new Input(recordHeaderBuffer);
boolean readStdout = input.readBoolean();
long readClassId = input.readLong();
long readTestId = input.readLong();
int readLength = input.readInt();
input.close();
boolean isClassLevel = readTestId == 0;
if (stdout != readStdout || classId != readClassId) {
dataFile.skipBytes(readLength);
continue;
}
if (ignoreClassLevel && isClassLevel) {
dataFile.skipBytes(readLength);
continue;
}
if (ignoreTestLevel && !isClassLevel) {
dataFile.skipBytes(readLength);
continue;
}
if (testId == 0 || testId == readTestId) {
byte[] stringBytes = new byte[readLength];
dataFile.read(stringBytes);
String message;
try {
message = new String(stringBytes, messageStorageCharset.name());
} catch (UnsupportedEncodingException e) {
// shouldn't happen
throw UncheckedException.throwAsUncheckedException(e);
}
writer.write(message);
} else {
dataFile.skipBytes(readLength);
continue;
}
}
} catch (IOException e1) {
throw new UncheckedIOException(e1);
}
}
/** Reads a MIDI track without doing anything to the data */
private void skipATrack(RandomAccessFile dos) throws IOException {
if (VERBOSE) System.out.println("Skipping the tempo track . . .");
dos.readInt();
dos.skipBytes(dos.readInt());
}