/**
* Stops the recording, and sets the state to STOPPED. In case of further usage, a reset is
* needed. Also finalizes the wave file in case of uncompressed recording.
*/
public void stop() {
if (state == State.RECORDING) {
if (rUncompressed) {
audioRecorder.stop();
try {
randomAccessWriter.seek(4); // Write size to RIFF header
randomAccessWriter.writeInt(Integer.reverseBytes(36 + payloadSize));
randomAccessWriter.seek(40); // Write size to Subchunk2Size field
randomAccessWriter.writeInt(Integer.reverseBytes(payloadSize));
randomAccessWriter.close();
} catch (IOException e) {
Log.e(
ExtAudioRecorder.class.getName(), "I/O exception occured while closing output file");
state = State.ERROR;
}
} else {
mediaRecorder.stop();
}
state = State.STOPPED;
} else {
Log.e(ExtAudioRecorder.class.getName(), "stop() called on illegal state");
state = State.ERROR;
}
}
/**
* Prepares the recorder for recording, in case the recorder is not in the INITIALIZING state and
* the file path was not set the recorder is set to the ERROR state, which makes a reconstruction
* necessary. In case uncompressed recording is toggled, the header of the wave file is written.
* In case of an exception, the state is changed to ERROR
*/
public void prepare() {
try {
if (state == State.INITIALIZING) {
if (rUncompressed) {
if ((audioRecorder.getState() == AudioRecord.STATE_INITIALIZED) & (filePath != null)) {
// write file header
randomAccessWriter = new RandomAccessFile(filePath, "rw");
randomAccessWriter.setLength(
0); // Set file length to 0, to prevent unexpected behavior in case the file already
// existed
randomAccessWriter.writeBytes("RIFF");
randomAccessWriter.writeInt(0); // Final file size not known yet, write 0
randomAccessWriter.writeBytes("WAVE");
randomAccessWriter.writeBytes("fmt ");
randomAccessWriter.writeInt(Integer.reverseBytes(16)); // Sub-chunk size, 16 for PCM
randomAccessWriter.writeShort(Short.reverseBytes((short) 1)); // AudioFormat, 1 for PCM
randomAccessWriter.writeShort(
Short.reverseBytes(nChannels)); // Number of channels, 1 for mono, 2 for stereo
randomAccessWriter.writeInt(Integer.reverseBytes(sRate)); // Sample rate
randomAccessWriter.writeInt(
Integer.reverseBytes(
sRate * bSamples * nChannels
/ 8)); // Byte rate, SampleRate*NumberOfChannels*BitsPerSample/8
randomAccessWriter.writeShort(
Short.reverseBytes(
(short)
(nChannels * bSamples
/ 8))); // Block align, NumberOfChannels*BitsPerSample/8
randomAccessWriter.writeShort(Short.reverseBytes(bSamples)); // Bits per sample
randomAccessWriter.writeBytes("data");
randomAccessWriter.writeInt(0); // Data chunk size not known yet, write 0
buffer = new byte[framePeriod * bSamples / 8 * nChannels];
state = State.READY;
} else {
Log.e(
ExtAudioRecorder.class.getName(),
"prepare() method called on uninitialized recorder");
state = State.ERROR;
}
} else {
mediaRecorder.prepare();
state = State.READY;
}
} else {
Log.e(ExtAudioRecorder.class.getName(), "prepare() method called on illegal state");
release();
state = State.ERROR;
}
} catch (Exception e) {
if (e.getMessage() != null) {
Log.e(ExtAudioRecorder.class.getName(), e.getMessage());
} else {
Log.e(ExtAudioRecorder.class.getName(), "Unknown error occured in prepare()");
}
state = State.ERROR;
}
}
/*
* Writes WAV header into new file.
*/
private void writeWavHeader() {
try {
randomAccessWriter = new RandomAccessFile(filePath, "rw");
randomAccessWriter.setLength(0);
randomAccessWriter.writeBytes("RIFF");
randomAccessWriter.writeInt(0); // Final file size not known yet, write 0
randomAccessWriter.writeBytes("WAVE");
randomAccessWriter.writeBytes("fmt ");
randomAccessWriter.writeInt(Integer.reverseBytes(16)); // Sub-chunk size, 16 for PCM
randomAccessWriter.writeShort(Short.reverseBytes((short) 1)); // AudioFormat, 1 for PCM
randomAccessWriter.writeShort(
Short.reverseBytes((short) 1)); // Number of channels, 1 for mono, 2 for stereo
randomAccessWriter.writeInt(Integer.reverseBytes(RECORDER_SAMPLE_RATE)); // Sample rate
randomAccessWriter.writeInt(
Integer.reverseBytes(
RECORDER_SAMPLE_RATE
* 16
* 1
/ 8)); // Byte rate, SampleRate*NumberOfChannels*BitsPerSample/8
randomAccessWriter.writeShort(
Short.reverseBytes(
(short) (1 * 16 / 8))); // Block align, NumberOfChannels*BitsPerSample/8
randomAccessWriter.writeShort(Short.reverseBytes((short) 16)); // Bits per sample
randomAccessWriter.writeBytes("data");
randomAccessWriter.writeInt(0); // Data chunk size not known yet, write 0
} catch (Exception e) {
Log.e("Microphone", "Error writing WAV header.");
}
}
public void saveMetaData() throws IOException {
pageFile.seek(offset);
pageFile.writeInt(nextPageId);
pageFile.writeInt(currentFill);
pageFile.writeInt(bloomfilter);
pageFile.writeByte(type);
}
public void writeTo(final RandomAccessFile raf) throws IOException {
raf.write(type.getBytes(Charsets.US_ASCII));
raf.writeInt(version);
raf.writeInt(metaData.length);
if (metaData.length > 0) {
raf.write(metaData);
}
}
private static RegionFile fixNegativeOffset(File regionFileFile) {
FMLLog.log(
Level.WARNING,
"Region file " + regionFileFile + " is corrupted: negative offset. Attempting to fix.");
try {
Files.copy(
regionFileFile,
new File(regionFileFile.getParentFile(), regionFileFile.getName() + ".bak"));
} catch (IOException e) {
FMLLog.log(Level.SEVERE, e, "Failed to back up corrupt region file.");
}
try {
RandomAccessFile dataFile = new RandomAccessFile(regionFileFile, "rw");
try {
int length;
if (dataFile.length() < 4096L) {
for (length = 0; length < 1024; ++length) {
dataFile.writeInt(0);
}
for (length = 0; length < 1024; ++length) {
dataFile.writeInt(0);
}
}
if ((dataFile.length() & 4095L) != 0L) {
for (length = 0; (long) length < (dataFile.length() & 4095L); ++length) {
dataFile.write(0);
}
}
length = (int) dataFile.length() / 4096;
dataFile.seek(0L);
for (int i = 0; i < 1024; ++i) {
int offset = dataFile.readInt();
if (offset != 0 && (offset >> 8) + (offset & 255) <= length) {
for (int var5 = 0; var5 < (offset & 255); ++var5) {
if ((offset >> 8) + var5 < 0) {
dataFile.seek(dataFile.getFilePointer() - 4);
dataFile.writeInt(0);
break;
}
}
}
}
} finally {
dataFile.close();
}
} catch (Throwable t) {
FMLLog.log(Level.SEVERE, t, "Failed to fix negative offset index in " + regionFileFile);
throw UnsafeUtil.throwIgnoreChecked(t);
}
return new RegionFile(regionFileFile);
}
public void write(RandomAccessFile raf) throws IOException {
raf.writeUTF(token);
raf.writeInt(startRow);
raf.writeInt(numRows);
final boolean hasNormalizedForm = !token.equals(normalizedToken);
raf.writeBoolean(hasNormalizedForm);
if (hasNormalizedForm) {
raf.writeUTF(normalizedToken);
}
RAFList.write(raf, htmlEntries, index.dict.htmlEntryIndexSerializer);
}
/** @return the remaining space in bytes */
protected void writeHeader(RandomAccessFile file, long length, int segmentSize)
throws IOException {
file.seek(0);
file.writeUTF("GH");
// make changes to file format only with major version changes
file.writeInt(version());
file.writeLong(length);
file.writeInt(segmentSize);
for (int i = 0; i < header.length; i++) {
file.writeInt(header[i]);
}
}
// "parent" is the AbstractID3-derived instance making use of this frame.
public void write(final RandomAccessFile file, AbstractID3 parent) throws IOException {
final String str;
final Iterator<?> iterator;
final byte[] buffer = new byte[6];
final MP3File mp3 = new MP3File();
mp3.seekMP3Frame(file);
final long mp3start = file.getFilePointer();
file.seek(0);
ID3v2_3Frame frame;
str = "ID3";
for (int i = 0; i < str.length(); i++) {
buffer[i] = (byte) str.charAt(i);
}
buffer[3] = 3;
buffer[4] = 0;
if (this.unsynchronization) {
buffer[5] |= TagConstant.MASK_V23_UNSYNCHRONIZATION;
}
if (this.extended) {
buffer[5] |= TagConstant.MASK_V23_EXTENDED_HEADER;
}
if (this.experimental) {
buffer[5] |= TagConstant.MASK_V23_EXPERIMENTAL;
}
file.write(buffer);
// write size
file.write(sizeToByteArray((int) mp3start - 10));
if (this.extended) {
if (this.crcDataFlag) {
file.writeInt(10);
buffer[0] = 0;
buffer[0] |= TagConstant.MASK_V23_CRC_DATA_PRESENT;
file.write(buffer, 0, 2);
file.writeInt(this.paddingSize);
file.writeInt(this.crcData);
} else {
file.writeInt(6);
file.write(buffer, 0, 2);
file.writeInt(this.paddingSize);
}
}
// write all frames
iterator = this.getFrameIterator();
while (iterator.hasNext()) {
frame = (ID3v2_3Frame) iterator.next();
frame.write(file, parent);
}
}
/* write a chunk data to the region file at specified sector number */
private void write(int sectorNumber, byte[] data, int length) throws IOException {
debugln(" " + sectorNumber);
file.seek(sectorNumber * SECTOR_BYTES);
file.writeInt(length + 1); // chunk length
file.writeByte(VERSION_DEFLATE); // chunk version number
file.write(data, 0, length); // chunk data
}
private int internalWriteElement(RandomAccessFile randomSerializeFile, long offset, E element)
throws IOException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
GZIPOutputStream gos = new GZIPOutputStream(bos);
ObjectOutputStream out = new ObjectOutputStream(gos);
out.writeObject(element);
out.flush();
out.close();
gos.finish();
byte[] buffer = bos.toByteArray();
// int uncompressed=cos.getCount();
int bufferSize = buffer.length;
/*
if(logger.isDebugEnabled())
{
int packedPercent=(int)(((double)bufferSize/(double)uncompressed)*100f);
logger.debug("Uncompressed size: {}", uncompressed);
logger.debug("Compressed size : {} ({}%)", bufferSize, packedPercent);
}
*/
randomSerializeFile.seek(offset);
randomSerializeFile.writeInt(bufferSize);
randomSerializeFile.write(buffer);
return bufferSize;
}
public int bubbleSort() throws Exception {
boolean swapped = true;
int j = 0;
int counter = 0;
while (swapped) {
swapped = false;
j++;
for (int i = 0; i < length() - j; i++) {
file.seek(i * 4);
int one = file.readInt();
int two = file.readInt();
if (one > two) {
file.seek(i * 4);
file.writeInt(two);
file.writeInt(one);
swapped = true;
counter++;
}
}
}
return counter;
}
/**
* Writes the Item ID to the Items Random Access File
*
* @param file - the Items Random Access File
*/
private void writeIDToFile(RandomAccessFile file) {
try {
file.getFilePointer();
file.writeInt(getID());
} catch (Exception e) {
}
}
public static void writeArray(String s, int[] x) {
try {
RandomAccessFile output = new RandomAccessFile(s, "rw");
for (int i = 0; i < x.length; i++) output.writeInt(x[i]);
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
private void append(SingleHit[] hits, String prefix, int chrom) throws IOException {
RandomAccessFile positionsRAF = new RandomAccessFile(getPositionsFname(prefix, chrom), "rw");
RandomAccessFile weightsRAF = new RandomAccessFile(getWeightsFname(prefix, chrom), "rw");
RandomAccessFile lasRAF = new RandomAccessFile(getLaSFname(prefix, chrom), "rw");
positionsRAF.seek(positionsRAF.length());
weightsRAF.seek(weightsRAF.length());
lasRAF.seek(lasRAF.length());
for (int i = 0; i < hits.length; i++) {
SingleHit h = hits[i];
positionsRAF.writeInt(h.pos);
weightsRAF.writeFloat(h.weight);
lasRAF.writeInt(makeLAS(h.length, h.strand));
}
positionsRAF.close();
weightsRAF.close();
lasRAF.close();
}
private void writeToDataBase(final RandomAccessFile dbFile, final String word) throws MapExcept {
try {
dbFile.writeInt(word.getBytes("UTF-8").length);
dbFile.write(word.getBytes("UTF-8"));
} catch (Exception ex) {
throw new MapExcept("can't write in file");
}
}
/** Corrupt an edit log file after the start segment transaction */
private void corruptAfterStartSegment(File f) throws IOException {
RandomAccessFile raf = new RandomAccessFile(f, "rw");
raf.seek(0x16); // skip version and first tranaction and a bit of next transaction
for (int i = 0; i < 1000; i++) {
raf.writeInt(0xdeadbeef);
}
raf.close();
}
private void write(String partnum, String partdesc, int qty, int ucost) throws IOException {
StringBuffer sb = new StringBuffer(partnum);
if (sb.length() > PNUMLEN) sb.setLength(PNUMLEN);
else if (sb.length() < PNUMLEN) {
int len = PNUMLEN - sb.length();
for (int i = 0; i < len; i++) sb.append(" ");
}
raf.writeChars(sb.toString());
sb = new StringBuffer(partdesc);
if (sb.length() > DESCLEN) sb.setLength(DESCLEN);
else if (sb.length() < DESCLEN) {
int len = DESCLEN - sb.length();
for (int i = 0; i < len; i++) sb.append(" ");
}
raf.writeChars(sb.toString());
raf.writeInt(qty);
raf.writeInt(ucost);
}
private void writeIntoFile(int numOfDir, int numOfFile) {
String dirString = String.valueOf(numOfDir) + ".dir";
String fileString = String.valueOf(numOfFile) + ".dat";
File dbDir = tableDir.toPath().resolve(dirString).normalize().toFile();
if (!dbDir.isDirectory()) {
dbDir.mkdir();
}
File dbFile = dbDir.toPath().resolve(fileString).normalize().toFile();
if (list[numOfDir][numOfFile].isEmpty()) {
dbFile.delete();
if (dbDir.list().length == 0) {
dbDir.delete();
}
return;
}
RandomAccessFile db;
try {
db = new RandomAccessFile(dbFile, "rw");
try {
db.setLength(0);
Iterator<Map.Entry<String, String>> it;
it = list[numOfDir][numOfFile].entrySet().iterator();
long[] pointers = new long[list[numOfDir][numOfFile].size()];
int counter = 0;
while (it.hasNext()) {
Map.Entry<String, String> m = (Map.Entry<String, String>) it.next();
String key = m.getKey();
db.write(key.getBytes("UTF-8"));
db.write("\0".getBytes("UTF-8"));
pointers[counter] = db.getFilePointer();
db.seek(pointers[counter] + 4);
++counter;
}
it = list[numOfDir][numOfFile].entrySet().iterator();
counter = 0;
while (it.hasNext()) {
Map.Entry<String, String> m = (Map.Entry<String, String>) it.next();
String value = m.getValue();
int curPointer = (int) db.getFilePointer();
db.seek(pointers[counter]);
db.writeInt(curPointer);
db.seek(curPointer);
db.write(value.getBytes("UTF-8"));
++counter;
}
} catch (Exception e) {
db.close();
throw new Exception(e);
}
db.close();
if (dbDir.list().length == 0) {
dbDir.delete();
}
} catch (Exception e) {
throw new IllegalArgumentException();
}
}
@Override
public void run() {
Database database = input.getDatabase();
Relation<O> relation = database.getRelation(distance.getInputTypeRestriction());
DistanceQuery<O> distanceQuery = database.getDistanceQuery(relation, distance);
KNNQuery<O> knnQ = database.getKNNQuery(distanceQuery, DatabaseQuery.HINT_HEAVY_USE);
// open file.
try (RandomAccessFile file = new RandomAccessFile(out, "rw");
FileChannel channel = file.getChannel();
// and acquire a file write lock
FileLock lock = channel.lock()) {
// write magic header
file.writeInt(KNN_CACHE_MAGIC);
int bufsize = k * 12 * 2 + 10; // Initial size, enough for 2 kNN.
ByteBuffer buffer = ByteBuffer.allocateDirect(bufsize);
FiniteProgress prog =
LOG.isVerbose() ? new FiniteProgress("Computing kNN", relation.size(), LOG) : null;
for (DBIDIter it = relation.iterDBIDs(); it.valid(); it.advance()) {
final KNNList nn = knnQ.getKNNForDBID(it, k);
final int nnsize = nn.size();
// Grow the buffer when needed:
if (nnsize * 12 + 10 > bufsize) {
while (nnsize * 12 + 10 > bufsize) {
bufsize <<= 1;
}
buffer = ByteBuffer.allocateDirect(bufsize);
}
buffer.clear();
ByteArrayUtil.writeUnsignedVarint(buffer, it.internalGetIndex());
ByteArrayUtil.writeUnsignedVarint(buffer, nnsize);
int c = 0;
for (DoubleDBIDListIter ni = nn.iter(); ni.valid(); ni.advance(), c++) {
ByteArrayUtil.writeUnsignedVarint(buffer, ni.internalGetIndex());
buffer.putDouble(ni.doubleValue());
}
if (c != nn.size()) {
throw new AbortException("Sizes did not agree. Cache is invalid.");
}
buffer.flip();
channel.write(buffer);
LOG.incrementProcessed(prog);
}
LOG.ensureCompleted(prog);
lock.release();
} catch (IOException e) {
LOG.exception(e);
}
// FIXME: close!
}
/*
* Writes file size in WAV header (called only when recording stopped).
*/
private void writeFileSize() {
try {
RandomAccessFile sizeWriter = new RandomAccessFile(filePath, "rw");
Log.d("Microphone", "File size: " + Integer.toString(fileSize));
sizeWriter.seek(4); // write new file size + RIFF header size
sizeWriter.writeInt(Integer.reverseBytes(fileSize + 36));
sizeWriter.seek(40); // write new file size
sizeWriter.writeInt(Integer.reverseBytes(fileSize));
sizeWriter.close();
} catch (Exception e) {
Log.e("Microphone", "Error writing file size.");
}
// HACK: tags file with modification time 0, should differentiate a file in
// "recordings" that is in progress from one that is done but with the same
// name
if (subFolder.equals("recordings")) (new File(filePath)).setLastModified(0);
}
public void saveAllOpenLevels(RandomAccessFile savefile) throws IOException {
System.out.printf("Entering map saver at %d!\n", savefile.getFilePointer());
int mapsToSave = loadedMaps.size();
savefile.writeInt(mapsToSave);
saveMap(1, savefile);
saveMap(0, savefile);
saveMap(-1, savefile);
saveMap(-2, savefile);
saveMap(-100, savefile);
}
/**
* This constructor is called by the log manager to create the file. A writer is created at the
* same time, and its presence indicates that the file is open for writing.
*
* @throws IOException
*/
public HALogFile(final IRootBlockView rbv, final IHALogManagerCallback callback)
throws IOException {
m_callback = callback;
m_haLogFile = getHALogFileName(m_callback.getHALogDir(), rbv.getCommitCounter());
if (m_haLogFile.exists())
throw new IllegalStateException("File already exists: " + m_haLogFile.getAbsolutePath());
final File parentDir = m_haLogFile.getParentFile();
// Make sure the parent directory(ies) exist.
if (!parentDir.exists())
if (!parentDir.mkdirs()) throw new IOException("Could not create directory: " + parentDir);
m_raf = new RandomAccessFile(m_haLogFile, "rw");
m_channel = m_raf.getChannel();
m_storeType = rbv.getStoreType();
m_openRootBlock = rbv;
m_closeRootBlock = null; // file NOT closed
m_magic = MAGIC;
m_version = VERSION1;
/*
* Write the MAGIC and version on the file.
*/
m_raf.seek(0);
m_raf.writeInt(m_magic);
m_raf.writeInt(m_version);
// Write opening rootblock as both BLOCK0 and BLOCK1
writeRootBlock(true, rbv); // as BLOCK0
writeRootBlock(false, rbv); // as BLOCK1
m_writePosition = START_DATA;
m_writer = new HALogWriter();
if (log.isInfoEnabled()) log.info("Opening HALogFile: " + m_haLogFile.getAbsolutePath());
}
/**
* Close the I/O stream and save any unsaved data.
*
* @exception IOException from library call
*/
public void close() throws IOException {
if (headerSize > 0) {
// write number of rows, CRC
outStream.seek(NUMROWS_OFFSET);
outStream.writeLong(numRows);
outStream.seek(headerSize - CRC_SIZE);
outStream.writeInt(CRC);
}
outStream.close();
}
protected void writeCorruptedData(RandomAccessFile file) throws IOException {
final String messageForPreUpgradeVersion =
"\nThis file is INTENTIONALLY CORRUPTED so that versions\n"
+ "of Hadoop prior to 0.13 (which are incompatible\n"
+ "with this directory layout) will fail to start.\n";
file.seek(0);
file.writeInt(FSConstants.LAYOUT_VERSION);
org.apache.hadoop.io.UTF8.writeString(file, "");
file.writeBytes(messageForPreUpgradeVersion);
file.getFD().sync();
}
public static void main(String args[]) {
try {
String fname = "d:\\q.txt";
String mode;
// mode = "r";//r : file must exist
mode = "rw"; // rw : file will be created or opened
// open the file
RandomAccessFile raf = new RandomAccessFile(fname, mode);
/*
//seek and write demo
raf.seek(10);//position file r/w pointer at index 10 wrt BOF
//a seek beyond file size causes file to grow upto the seek value
raf.write(65);//raf.write('A');
*/
// r/w java datatypes
int i1, i2;
float f1, f2;
char c1, c2;
String s1, s2;
i1 = -10;
f1 = 1234.5678F;
c1 = 'q';
s1 = "hello files";
raf.seek(0); // reach BOF
raf.writeInt(i1);
raf.writeFloat(f1);
raf.writeChar(c1);
raf.writeUTF(s1);
raf.seek(0); // reach BOF
i2 = raf.readInt();
f2 = raf.readFloat();
c2 = raf.readChar();
s2 = raf.readUTF();
System.out.println(i2);
System.out.println(f2);
System.out.println(c2);
System.out.println(s2);
// close the file
raf.close();
} catch (IOException ex) {
System.out.println(ex); // ex converts into ex.toString()
}
} // main
public void post(long timestamp, float value) throws IOException {
File file = getFile();
RandomAccessFile rdf = null;
try {
rdf = new RandomAccessFile(file, "rw");
// On vérifie que la longueur est cohérente
long len = rdf.length();
if (len > 0) {
int mod = (int) (len % DATA_LEN);
if (mod != 0) {
logger.warning(
"Taille de fichier incoherence ("
+ len / DATA_LEN
+ "x"
+ DATA_LEN
+ ", reste "
+ mod
+ "). retour a "
+ (len - mod));
len = len - mod;
}
if (timestamp < getLast(rdf).timestamp) {
logger.warning(
"la nouvelle valeur anterieure a la derniere (prev:"
+ sdf.format(new Date((long) last.timestamp * 1000))
+ " new:"
+ sdf.format(new Date((long) timestamp * 1000))
+ ")");
}
// Positionnement en fin de fichier
rdf.seek(len);
}
// On écrit l'enregistrement
if (timestamp > Integer.MAX_VALUE) {
logger.warning("timestamp tronqué : " + timestamp + "/" + (int) timestamp);
}
if (last == null) last = new Entry();
last.timestamp = (int) timestamp;
last.value = value;
logger.fine("write: " + value + "(" + sdf.format(new Date(timestamp * 1000)) + ")");
rdf.writeInt((int) last.timestamp);
rdf.writeFloat(last.value);
} finally {
if (rdf != null) rdf.close();
}
}
public static void main(String[] args) throws IOException {
try ( // Create a random access file
RandomAccessFile inout = new RandomAccessFile("inout.dat", "rw"); ) {
// Clear the file to destroy the old contents if exists
inout.setLength(0);
// Write new integers to the file
for (int i = 0; i < 200; i++) inout.writeInt(i);
// Display the current length of the file
System.out.println("Current file length is " + inout.length());
// Retrieve the first number
inout.seek(0); // Move the file pointer to the beginning
System.out.println("The first number is " + inout.readInt());
// Retrieve the second number
inout.seek(1 * 4); // Move the file pointer to the second number
System.out.println("The second number is " + inout.readInt());
// Retrieve the tenth number
inout.seek(9 * 4); // Move the file pointer to the tenth number
System.out.println("The tenth number is " + inout.readInt());
// Modify the eleventh number
inout.writeInt(555);
// Append a new number
inout.seek(inout.length()); // Move the file pointer to the end
inout.writeInt(999);
// Display the new length
System.out.println("The new length is " + inout.length());
// Retrieve the new eleventh number
inout.seek(10 * 4); // Move the file pointer to the eleventh number
System.out.println("The eleventh number is " + inout.readInt());
}
}
private void writeNameIdEntry(NameFileIdEntry nameFileIdEntry, boolean sync) throws IOException {
nameIdMapHolder.seek(nameIdMapHolder.length());
final int nameSize = OStringSerializer.INSTANCE.getObjectSize(nameFileIdEntry.name);
byte[] serializedName = new byte[nameSize];
OStringSerializer.INSTANCE.serialize(nameFileIdEntry.name, serializedName, 0);
nameIdMapHolder.writeInt(nameSize);
nameIdMapHolder.write(serializedName);
nameIdMapHolder.writeLong(nameFileIdEntry.fileId);
if (sync) nameIdMapHolder.getFD().sync();
}
@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;
}
