295 lines
7.3 KiB
Java
295 lines
7.3 KiB
Java
/*
|
|
* Track.java
|
|
*
|
|
* Copyright (c) 2007 Vreixo Formoso
|
|
*
|
|
* This library is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
* See COPYING file for details.
|
|
*/
|
|
|
|
package org.pykix.libburnia.libburn;
|
|
|
|
import java.util.EnumSet;
|
|
|
|
import org.pykix.libburnia.bindings.Proxy;
|
|
|
|
/**
|
|
* References a single track on a disc.
|
|
*
|
|
* @author Vreixo Formoso
|
|
* @since 0.1
|
|
*/
|
|
public class Track extends Proxy {
|
|
|
|
/** wether is needed to free or not the track when no more needed */
|
|
private boolean free;
|
|
|
|
/**
|
|
* Create a new Track, to use in TAO recording or to put in a
|
|
* {@link Session}
|
|
*/
|
|
public Track() {
|
|
super( burn_track_create() );
|
|
free = true;
|
|
}
|
|
|
|
/* package protected */
|
|
Track(long ptr) {
|
|
super(ptr);
|
|
free = false;
|
|
}
|
|
|
|
/**
|
|
* Define the data in a track.
|
|
*
|
|
* @param offset
|
|
* The number of 0s to write before start of data.
|
|
* @param tail
|
|
* The number of extra 0s to write after data.
|
|
* @param pad
|
|
* If <code>true</code>, the lib should pad the last sector with 0s
|
|
* if the track isn't exactly sector sized. (otherwise the lib will
|
|
* begin reading from the next track)
|
|
* @param mode
|
|
* data format
|
|
*/
|
|
public void defineData(int offset, int tail, boolean pad,
|
|
EnumSet<BurnMode> mode) {
|
|
|
|
int modebm = 0;
|
|
for ( BurnMode m : mode ) {
|
|
modebm |= m.bm;
|
|
}
|
|
|
|
burn_track_define_data( pointerOf(this), offset, tail, pad, modebm );
|
|
}
|
|
|
|
/**
|
|
* Define wether a track shall swap bytes of its input stream.
|
|
*
|
|
* @param swapSourceBytes
|
|
* <code>false</code> to do not swap, <code>true</code> to swap byte
|
|
* pairs
|
|
*/
|
|
public void setByteSwap(boolean swapSourceBytes) {
|
|
burn_track_set_byte_swap( pointerOf(this), swapSourceBytes ? 1 : 0);
|
|
}
|
|
|
|
/**
|
|
* Set the ISRC details for the track.
|
|
*
|
|
* @param country
|
|
* the 2 char country code. Each character must be only numbers or
|
|
* letters.
|
|
* @param owner
|
|
* 3 char owner code. Each character must be only numbers
|
|
* or letters.
|
|
* @param year
|
|
* 2 digit year. A number in 0-99 (Yep, not Y2K friendly).
|
|
* @param serial
|
|
* 5 digit serial number. A number in 0-99999.
|
|
* @throws IllegalArgumentException
|
|
* If some of restrictions given above are wrong.
|
|
*
|
|
* TODO add more restriction checks in java code. We need to check that
|
|
* characters are valid.
|
|
*/
|
|
public void setIsrc(String country, String owner, int year, int serial) {
|
|
|
|
if ( country.length() != 2 ) {
|
|
throw new IllegalArgumentException("Country must be 2 characters " +
|
|
"length");
|
|
}
|
|
|
|
if ( owner.length() != 3 ) {
|
|
throw new IllegalArgumentException("owner must be 3 characters " +
|
|
"length");
|
|
}
|
|
|
|
if ( (year > 99) || (year < 0) ) {
|
|
throw new IllegalArgumentException("year must be a number in 0-99");
|
|
}
|
|
|
|
if ( (serial > 99999) || (serial < 0) ) {
|
|
throw new IllegalArgumentException("99999 must be a number in " +
|
|
"0-99999");
|
|
}
|
|
|
|
burn_track_set_isrc( pointerOf(this), country, owner, (byte)year, serial );
|
|
|
|
}
|
|
|
|
/**
|
|
* Disable ISRC parameters for the track.
|
|
*/
|
|
public void clearIsrc() {
|
|
burn_track_clear_isrc( pointerOf(this) );
|
|
}
|
|
|
|
/**
|
|
* Set the track's data source.
|
|
*
|
|
* @param src
|
|
* The data source to use for the contents of the track.
|
|
* @return
|
|
* A status code stating if the source is ready for use for
|
|
* writing the track, or if an error occured
|
|
*/
|
|
public SourceStatus setSource(BurnSource src) {
|
|
|
|
long ptr;
|
|
if (src instanceof Proxy) {
|
|
Proxy source = (Proxy) src;
|
|
ptr = pointerOf(source);
|
|
} else {
|
|
//FIXME add support for java-based sources
|
|
throw new ClassCastException("Only Proxy sources supported");
|
|
}
|
|
|
|
int s = burn_track_set_source( pointerOf(this), ptr);
|
|
switch (s) {
|
|
case 0:
|
|
return SourceStatus.OK;
|
|
case 1:
|
|
return SourceStatus.EOF;
|
|
case 2:
|
|
return SourceStatus.FAILED;
|
|
default:
|
|
throw new RuntimeException("Unexpected return state");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set a default track size to be used only if the track turns out to be of
|
|
* unpredictable length and if the effective write type demands a fixed
|
|
* size.
|
|
*
|
|
* <p>
|
|
* This can be useful to enable write types CD SAO or DVD DAO together with
|
|
* a track source like stdin. If the track source delivers fewer bytes than
|
|
* announced then the track will be padded up with zeros.
|
|
*
|
|
* @param size
|
|
* The size to set in bytes
|
|
* @return
|
|
* <code>true</code> on success, <code>false</code> if failure
|
|
*/
|
|
public boolean setDefaultSize(long size) {
|
|
return burn_track_set_default_size( pointerOf(this), size);
|
|
}
|
|
|
|
/**
|
|
* Tells how long the track will be on disc.
|
|
* <i>Not reliable with tracks of undefined length. Should never
|
|
* be called in this case.</i>
|
|
*
|
|
* @return
|
|
* Number of sectors the track will need.
|
|
*/
|
|
public int getSectors() {
|
|
return burn_track_get_sectors( pointerOf(this) );
|
|
}
|
|
|
|
/**
|
|
* Gets a copy of the {@link TocEntry} structure associated with the track.
|
|
*
|
|
* @return
|
|
* A {@link TocEntry} object.
|
|
*/
|
|
public TocEntry getEntry() {
|
|
return burn_track_get_entry( pointerOf(this) );
|
|
}
|
|
|
|
/**
|
|
* Gets the mode of the track.
|
|
*
|
|
* @return
|
|
* The track's mode
|
|
*/
|
|
public EnumSet<BurnMode> getMode() {
|
|
|
|
int modebm = burn_track_get_mode( pointerOf(this) );
|
|
|
|
EnumSet<BurnMode> mode = EnumSet.noneOf(BurnMode.class);
|
|
|
|
for ( BurnMode m : EnumSet.allOf(BurnMode.class) ) {
|
|
|
|
if ( (modebm & m.bm) != 0 ) {
|
|
mode.add(m);
|
|
}
|
|
}
|
|
|
|
return mode;
|
|
}
|
|
|
|
/**
|
|
* Tells how many source bytes have been read by the track during burn.
|
|
*
|
|
* @return
|
|
* Bytes already read.
|
|
*/
|
|
public long getReadBytes() {
|
|
return burn_track_get_read_bytes( pointerOf(this) );
|
|
}
|
|
|
|
/**
|
|
* Tells how many source bytes have been written by the track during burn.
|
|
*
|
|
* @return
|
|
* Bytes already written.
|
|
*/
|
|
public long getWrittenBytes() {
|
|
return burn_track_get_written_bytes( pointerOf(this) );
|
|
}
|
|
|
|
@Override
|
|
protected void finalize() throws Throwable {
|
|
super.finalize();
|
|
|
|
/*
|
|
* When retrieved from Session.getTrack we haven't to
|
|
* free the C object because we don't own a reference
|
|
*/
|
|
if ( free ) {
|
|
burn_track_free( pointerOf(this) );
|
|
}
|
|
}
|
|
|
|
private static native long burn_track_create();
|
|
|
|
private static native void burn_track_free(long t);
|
|
|
|
private static native void burn_track_define_data(long t, int offset,
|
|
int tail, boolean pad, int mode);
|
|
|
|
private static native int burn_track_set_byte_swap(long t,
|
|
int swapSourceBytes);
|
|
|
|
private static native void burn_track_set_isrc(long t, String country,
|
|
String owner, byte year, int serial);
|
|
|
|
private static native void burn_track_clear_isrc(long t);
|
|
|
|
private static native int burn_track_set_source(long t, long s);
|
|
|
|
private static native boolean burn_track_set_default_size(long t, long size);
|
|
|
|
private static native int burn_track_get_sectors(long t);
|
|
|
|
private static native TocEntry burn_track_get_entry(long t);
|
|
|
|
private static native int burn_track_get_mode(long track);
|
|
|
|
/*
|
|
* The two methods are the java version of the single libburn method
|
|
* int burn_track_get_counters(struct burn_track *t,
|
|
* off_t *read_bytes, off_t *written_bytes);
|
|
*/
|
|
private static native long burn_track_get_read_bytes(long t);
|
|
private static native long burn_track_get_written_bytes(long t);
|
|
|
|
}
|