/* --- @mode_2@ --- *
*
* Arguments: @file_ptrs *fptrs@ = pointer struct of source and destination file
* @off_t n_fptr_pos@ = the position of byte from where to be read
* @off_t n_iso_block_no@ = the current block number being written
*
* Returns: the number of bytes read, @-1@ otherwise
*
* Use: Reads into the buffer and writes the buffer to destination file.
*/
off_t mode_2 ( file_ptrs* fptrs, off_t n_fptr_pos, off_t n_iso_block_no )
{
int n_mode = 0;
sub_header_block sub_header; /* Sub Header */
off_t (* mode_form [ 3 ] ) ( file_ptrs* fptrs, off_t n_fptr_pos, off_t n_iso_block_no ) = { &mode_2_form_1, &mode_2_form_2, &mode_0 };
memset ( &sub_header, 0, sizeof ( sub_header_block ) );
/* Move the file pointer to read the sub-header info */
set_file_pointer ( fptrs -> fsource, ( n_fptr_pos += ( off_t ) sizeof ( sync_header_block ) ) );
fread ( &sub_header, 1, sizeof ( sub_header_block ), fptrs -> fsource );
/* Revert back the file pointer as it has moved
* till the sub-header (read 16 + 8 bytes of data) */
set_file_pointer ( fptrs -> fsource, ( n_fptr_pos -= ( off_t ) sizeof ( sync_header_block ) ) );
/*print ( ( void* ) &sub_header, sizeof ( sub_header_block ) );*/
if ( !memcmp ( sub_header.first_copy, sub_header.second_copy, 4 ) ) {
/* Values { 0, 32, etc.. } 32 (5th bit set - Form 2), 0 - (5th bit not set - Form 1)*/
n_mode = ( ( n_mode = ( ( (int) *( sub_header.first_copy + 2 ) ) & 0x20 ) ) == 32 ) ? 1 : ( n_mode == 0 ) ? 0 : 2;
n_fptr_pos = ( *( mode_form [ n_mode ] ) ) ( fptrs, n_fptr_pos, n_iso_block_no );
} else {
/* It is Formless */
/* Mode 2 (2352): Syncheader (12), MSF / BCD (3), Mode (1), Data (2336) */
n_fptr_pos = ( *( mode_form [ 2 ] ) ) ( fptrs, n_fptr_pos, n_iso_block_no );
}
return ( n_fptr_pos );
}
bool BufferedFile::open(const PathChar *name, const char *mode)
{
set_file_pointer(OsFile_open(name, mode));
OsFile_Handle fh = file_pointer();
set_file_size(fh == NULL ? 0 : OsFile_length(fh));
return (fh != NULL);
}
PJ_DEF(pj_status_t) pj_file_getpos( pj_oshandle_t fd,
pj_off_t *pos)
{
if (set_file_pointer(fd, 0, pos, FILE_CURRENT) != PJ_SUCCESS) {
return PJ_RETURN_OS_ERROR(GetLastError());
}
return PJ_SUCCESS;
}
int BufferedFile::close()
{
if (file_pointer() != NULL) {
int result = OsFile_close(file_pointer());
set_file_pointer(0);
set_file_size(0);
set_file_pos(0);
set_index(0);
set_count(0);
return result;
} else {
return -1;
}
}
Tchannel
OS_open_append_file (const char * filename)
{
Tchannel channel =
(open_file (filename,
FILE_NORMAL,
(OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW),
CHANNEL_WRITE));
transaction_begin ();
OS_channel_close_on_abort (channel);
(void) set_file_pointer (channel, FILE_END, 0);
transaction_commit ();
return (channel);
}
/* writes data to fcell file for either full or partial rows */
static void put_fp_data(int fd, char *null_buf, const void *rast,
int row, int n, RASTER_MAP_TYPE data_type)
{
struct fileinfo *fcb = &R__.fileinfo[fd];
int compressed = (fcb->open_mode == OPEN_NEW_COMPRESSED);
XDR *xdrs = &fcb->xdrstream;
void *work_buf;
if (row < 0 || row >= fcb->cellhd.rows)
return;
if (n <= 0)
return;
work_buf = G__alloca(fcb->cellhd.cols * fcb->nbytes + 1);
if (compressed)
set_file_pointer(fd, row);
xdrmem_create(xdrs, work_buf,
(unsigned int)fcb->nbytes * fcb->cellhd.cols, XDR_ENCODE);
xdr_setpos(xdrs, 0);
if (data_type == FCELL_TYPE)
convert_float(xdrs, null_buf, rast, row, n);
else
convert_double(xdrs, null_buf, rast, row, n);
xdr_destroy(&fcb->xdrstream);
if (compressed)
write_data_compressed(fd, row, work_buf, n);
else
write_data(fd, row, work_buf, n);
G__freea(work_buf);
}
PJ_DEF(pj_status_t) pj_file_setpos( pj_oshandle_t fd,
pj_off_t offset,
enum pj_file_seek_type whence)
{
DWORD dwMoveMethod;
pj_off_t newPos;
if (whence == PJ_SEEK_SET)
dwMoveMethod = FILE_BEGIN;
else if (whence == PJ_SEEK_CUR)
dwMoveMethod = FILE_CURRENT;
else if (whence == PJ_SEEK_END)
dwMoveMethod = FILE_END;
else {
pj_assert(!"Invalid whence in file_setpos");
return PJ_EINVAL;
}
if (set_file_pointer(fd, offset, &newPos, dwMoveMethod) != PJ_SUCCESS) {
return PJ_RETURN_OS_ERROR(GetLastError());
}
return PJ_SUCCESS;
}
CAMLprim value unix_lockf(value fd, value cmd, value span)
{
CAMLparam3(fd, cmd, span);
OVERLAPPED overlap;
intnat l_len;
HANDLE h;
OSVERSIONINFO version;
LARGE_INTEGER cur_position;
LARGE_INTEGER beg_position;
LARGE_INTEGER lock_len;
LARGE_INTEGER zero;
DWORD err = NO_ERROR;
version.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
if(GetVersionEx(&version) == 0) {
invalid_argument("lockf only supported on WIN32_NT platforms: could not determine current platform.");
}
if(version.dwPlatformId != VER_PLATFORM_WIN32_NT) {
invalid_argument("lockf only supported on WIN32_NT platforms");
}
h = Handle_val(fd);
l_len = Long_val(span);
/* No matter what, we need the current position in the file */
zero.HighPart = zero.LowPart = 0;
set_file_pointer(h, zero, &cur_position, FILE_CURRENT);
/* All unused fields must be set to zero */
memset(&overlap, 0, sizeof(overlap));
if(l_len == 0) {
/* Lock from cur to infinity */
lock_len.QuadPart = -1;
overlap.OffsetHigh = cur_position.HighPart;
overlap.Offset = cur_position.LowPart ;
}
else if(l_len > 0) {
/* Positive file offset */
lock_len.QuadPart = l_len;
overlap.OffsetHigh = cur_position.HighPart;
overlap.Offset = cur_position.LowPart ;
}
else {
/* Negative file offset */
lock_len.QuadPart = - l_len;
if (lock_len.QuadPart > cur_position.QuadPart) {
errno = EINVAL;
uerror("lockf", Nothing);
}
beg_position.QuadPart = cur_position.QuadPart - lock_len.QuadPart;
overlap.OffsetHigh = beg_position.HighPart;
overlap.Offset = beg_position.LowPart ;
}
switch(Int_val(cmd)) {
case 0: /* F_ULOCK - unlock */
if (! UnlockFileEx(h, 0,
lock_len.LowPart, lock_len.HighPart, &overlap))
err = GetLastError();
break;
case 1: /* F_LOCK - blocking write lock */
enter_blocking_section();
if (! LockFileEx(h, LOCKFILE_EXCLUSIVE_LOCK, 0,
lock_len.LowPart, lock_len.HighPart, &overlap))
err = GetLastError();
leave_blocking_section();
break;
case 2: /* F_TLOCK - non-blocking write lock */
if (! LockFileEx(h, LOCKFILE_FAIL_IMMEDIATELY | LOCKFILE_EXCLUSIVE_LOCK, 0,
lock_len.LowPart, lock_len.HighPart, &overlap))
err = GetLastError();
break;
case 3: /* F_TEST - check whether a write lock can be obtained */
/* I'm doing this by aquiring an immediate write
* lock and then releasing it. It is not clear that
* this behavior matches anything in particular, but
* it is not clear the nature of the lock test performed
* by ocaml (unix) currently. */
if (LockFileEx(h, LOCKFILE_FAIL_IMMEDIATELY | LOCKFILE_EXCLUSIVE_LOCK, 0,
lock_len.LowPart, lock_len.HighPart, &overlap)) {
UnlockFileEx(h, 0, lock_len.LowPart, lock_len.HighPart, &overlap);
} else {
err = GetLastError();
}
break;
case 4: /* F_RLOCK - blocking read lock */
enter_blocking_section();
if (! LockFileEx(h, 0, 0,
lock_len.LowPart, lock_len.HighPart, &overlap))
err = GetLastError();
leave_blocking_section();
break;
case 5: /* F_TRLOCK - non-blocking read lock */
if (! LockFileEx(h, LOCKFILE_FAIL_IMMEDIATELY, 0,
lock_len.LowPart, lock_len.HighPart, &overlap))
err = GetLastError();
break;
default:
errno = EINVAL;
uerror("lockf", Nothing);
}
if (err != NO_ERROR) {
win32_maperr(err);
uerror("lockf", Nothing);
}
CAMLreturn(Val_unit);
}
void
OS_file_set_position (Tchannel channel, off_t position)
{
if ((set_file_pointer (channel, FILE_BEGIN, position)) != position)
OS2_error_anonymous ();
}
off_t
OS_file_position (Tchannel channel)
{
return (set_file_pointer (channel, FILE_CURRENT, 0));
}
/* --- @bin_2_iso@ --- *
*
* Arguments: @file_ptrs *fptrs@ = pointer struct of source and destination file
* @image_struct *img_struct@ = struct of image pregap
*
* Returns: Zeor on success, @-1@ on error.
*
* Use: Return the detection of the image.
*/
int bin_2_iso ( file_ptrs* fptrs, image_struct* img_struct )
{
off_t n_loop = 0;
off_t n_loop_incrementer = 0;
off_t n_img_size = 0;
int n_return_value = ERROR;
int n_mode = 0;
long n_iso_block_no = 0;
unsigned const char synch_pattern [ 12 ] = { 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00 };
sync_header_block header; /* Sync Header Block */
off_t (* mode [ 5 ] ) ( file_ptrs* fptrs, off_t n_fptr_pos, off_t n_iso_block_no )
= { &mode_0, &mode_1, &mode_2, &mode_2_form_1_headerless, &mode_2_form_2_headerless };
if ( NULL== fptrs -> fsource ) return ( n_return_value ); /* The source file pointer is empty */
if ( ( n_img_size = get_file_size ( fptrs -> fsource ) ) < 1 ) return ( n_return_value ); /* The image file is empty */
for ( n_loop = ( off_t ) img_struct -> pregap; n_loop < n_img_size; ) {
progress_bar ( ( int ) ( ( ( n_loop + 1 ) * 100 ) / n_img_size ) );
/* Initalize for the loop */
memset ( &header, 0, sizeof ( sync_header_block ) );
/* Initialize the file pointer to the start point */
set_file_pointer ( fptrs -> fsource, n_loop );
fread ( &header, 1, sizeof ( sync_header_block ), fptrs -> fsource );
/*printf ("Image size :%ld\n", n_img_size );
printf ( "LOOP NO :%d\n", n_loop );
print ( ( void* ) &header, 16 );*/
/* Revert back the file pointer as it has moved the
* file pointer till the header (read 16 bytes of data) */
set_file_pointer ( fptrs -> fsource, n_loop );
if ( !memcmp ( &synch_pattern, &header, 12 ) ) {
n_iso_block_no++;
/* Image has 12 BYTE SYNC HEADER */
n_mode = ( (char) ( *( header.msf_block.mode ) ) );
if ( ( n_mode > -1 ) && ( n_mode < 3 ) )
/* Mode { 0, 1, 2 } */
n_loop_incrementer = ( *( mode [ n_mode ] ) ) ( fptrs, n_loop, n_iso_block_no ); /* Increment to the next block */
else printf ( "Weird Mode \n" );
if ( 0 < n_loop_incrementer ) {
if ( ( 2448 == img_struct -> block ) || ( 2368 == img_struct -> block ) ) {
n_loop += n_loop_incrementer;
n_loop += ( ( off_t ) img_struct -> block - n_loop_incrementer );
n_loop_incrementer = 0;
} else n_loop += n_loop_incrementer;
}
} else if ( ( !memcmp ( &header, ( ( (unsigned char*) (&header) ) + 4 ), 4 ) ) && ( 2336 == img_struct -> block ) ) {
int n_mode_no_header = 0;
n_iso_block_no++;
/*print ( ( void* ) &header, 8 );*/
n_mode_no_header = ( (int) *( ( (unsigned char*) (&header) ) + 2 ) ) & 0x20;
n_mode_no_header = ( n_mode_no_header == 32 ) ? 1 : 0;
n_loop += ( *( mode [ 3 + n_mode_no_header ] ) ) ( fptrs, n_loop, n_iso_block_no ); /* Increment to the next block */
} else {
/* Image does not have any standard header */
/*print ( ( void* ) &header, 16 );*/
n_loop++; /* Increment to the next location */
/*n_loop += img_struct -> block;*/ /* Increment to the next block */
}
}
set_file_pointer ( fptrs -> fsource, ( off_t ) 0 );
n_return_value = AOK;
progress_bar ( 100 );
printf ( "\n" );
return ( n_return_value );
}
static void put_data(int fd, char *null_buf, const CELL * cell,
int row, int n, int zeros_r_nulls)
{
struct fileinfo *fcb = &R__.fileinfo[fd];
int compressed = fcb->cellhd.compressed;
int len = compressed ? sizeof(CELL) : fcb->nbytes;
unsigned char *work_buf, *wk;
ssize_t nwrite;
if (row < 0 || row >= fcb->cellhd.rows)
return;
if (n <= 0)
return;
work_buf = G__alloca(fcb->cellhd.cols * sizeof(CELL) + 1);
wk = work_buf;
if (compressed)
set_file_pointer(fd, row);
if (compressed)
wk++;
convert_int(wk, null_buf, cell, n, len, zeros_r_nulls);
if (compressed) {
unsigned char *wk = work_buf + 1;
int nbytes = count_bytes(wk, n, len);
unsigned char *compressed_buf;
int total;
if (fcb->nbytes < nbytes)
fcb->nbytes = nbytes;
/* first trim away zero high bytes */
if (nbytes < len)
trim_bytes(wk, n, len, len - nbytes);
total = nbytes * n;
compressed_buf = G__alloca(total + 1);
compressed_buf[0] = work_buf[0] = nbytes;
/* then compress the data */
nwrite = compressed == 1
? rle_compress(compressed_buf + 1, work_buf + 1, n, nbytes)
: zlib_compress(compressed_buf + 1, work_buf + 1, n, nbytes);
if (nwrite > 0) {
nwrite++;
if (write(fd, compressed_buf, nwrite) != nwrite)
G_fatal_error(_("Error writing compressed data for row %d of <%s>"),
row, fcb->name);
}
else {
nwrite = nbytes * n + 1;
if (write(fd, work_buf, nwrite) != nwrite)
G_fatal_error(_("Error writing compressed data for row %d of <%s>"),
row, fcb->name);
}
G__freea(compressed_buf);
}
else {
nwrite = fcb->nbytes * n;
if (write(fd, work_buf, nwrite) != nwrite)
G_fatal_error(_("Error writing uncompressed data for row %d of <%s>"),
row, fcb->name);
}
G__freea(work_buf);
}
