long syllable_break(char *cluster)
{
char *left_cluster, *right_cluster, temp[MAX_LEN];
long offset, length;
/* GET LENGTH OF CLUSTER */
length = strlen(cluster);
/* INITIALLY WE SHALL RETURN THE FIRST 'POSSIBLE' MATCH */
for (offset = -1; (offset <= length); offset++) {
if (offset == -1 || offset == length || cluster[offset] == '_' || cluster[offset] == '.') {
strcpy(temp, cluster);
if (offset >= 0)
temp[offset] = 0;
left_cluster = (offset < 0 ? temp : offset == length ? temp + length : temp + (offset + 1));
/* POINTS TO BEGINNING OR NULL */
right_cluster = (offset >= 0 ? temp : temp + length);
/* NOW THEY POINT TO EITHER A LEFT/RIGHT HANDED CLUSTER OR A NULL STRING */
if (check_cluster(left_cluster, LEFT) && check_cluster(right_cluster, RIGHT)) {
/* IF THIS IS A POSSIBLE BREAK */
/* TEMPORARY: WILL STORE LIST OF POSSIBLES AND PICK A 'BEST' ONE */
return(offset);
}
}
}
/* IF HERE, RETURN ERROR */
return(-2);
}
errcode_t ocfs2_set_backup_super_list(ocfs2_filesys *fs,
uint64_t *blocks, size_t len)
{
size_t i;
errcode_t ret = 0;
char *buf = NULL;
uint64_t *blkno = blocks;
uint32_t cluster, bpc = fs->fs_clustersize / fs->fs_blocksize;
if (!len || !blocks || !*blocks)
goto bail;
len = ocfs2_min(len,(size_t)OCFS2_MAX_BACKUP_SUPERBLOCKS);
if (!OCFS2_HAS_COMPAT_FEATURE(OCFS2_RAW_SB(fs->fs_super),
OCFS2_FEATURE_COMPAT_BACKUP_SB)) {
/* check all the blkno to see whether it is used. */
for (i = 0; i < len; i++, blkno++) {
ret = check_cluster(fs,
ocfs2_blocks_to_clusters(fs, *blkno));
if (ret)
goto bail;
}
}
ret = ocfs2_malloc_blocks(fs->fs_io, bpc, &buf);
if (ret)
goto bail;
memset(buf, 0, fs->fs_clustersize);
/* zero all the clusters at first */
blkno = blocks;
for (i = 0; i < len; i++, blkno++) {
cluster = ocfs2_blocks_to_clusters(fs, *blkno);
ret = io_write_block(fs->fs_io, cluster*bpc, bpc, buf);
if (ret)
goto bail;
}
ret = ocfs2_refresh_backup_super_list(fs, blocks, len);
if (ret)
goto bail;
/* We just tested the clusters, so the allocation can't fail */
blkno = blocks;
for (i = 0; i < len; i++, blkno++)
ocfs2_new_specific_cluster(fs, ocfs2_blocks_to_clusters(fs, *blkno));
bail:
if (buf)
ocfs2_free(&buf);
return ret;
}
int
main(int argc, char **argv)
{
TIFF *tif;
static const char *srcfilerel = "images/quad-tile.jpg.tiff";
char *srcdir = NULL;
char srcfile[1024];
unsigned short h, v;
int status;
unsigned char *buffer;
uint32 *rgba_buffer;
tsize_t sz, szout;
unsigned int pixel_status = 0;
(void) argc;
(void) argv;
if ((srcdir = getenv("srcdir")) == NULL) {
srcdir = ".";
}
if ((strlen(srcdir) + 1 + strlen(srcfilerel)) >= sizeof(srcfile)) {
fprintf( stderr, "srcdir too long %s\n", srcdir);
exit( 1 );
}
strcpy(srcfile,srcdir);
strcat(srcfile,"/");
strcat(srcfile,srcfilerel);
tif = TIFFOpen(srcfile,"r");
if ( tif == NULL ) {
fprintf( stderr, "Could not open %s\n", srcfile);
exit( 1 );
}
status = TIFFGetField(tif,TIFFTAG_YCBCRSUBSAMPLING, &h, &v);
if ( status == 0 || h != 2 || v != 2) {
fprintf( stderr, "Could not retrieve subsampling tag.\n" );
exit(1);
}
/*
* What is the appropriate size of a YCbCr encoded tile?
*/
sz = TIFFTileSize(tif);
if( sz != 24576) {
fprintf(stderr, "tiles are %d bytes\n", (int)sz);
exit(1);
}
buffer = (unsigned char *) malloc(sz);
/*
* Read a tile in decompressed form, but still YCbCr subsampled.
*/
szout = TIFFReadEncodedTile(tif,9,buffer,sz);
if (szout != sz) {
fprintf( stderr,
"Did not get expected result code from TIFFReadEncodedTile()(%d instead of %d)\n",
(int) szout, (int) sz );
return 1;
}
if( check_cluster( 0, buffer, cluster_0 )
|| check_cluster( 64, buffer, cluster_64 )
|| check_cluster( 128, buffer, cluster_128 ) ) {
exit(1);
}
free(buffer);
/*
* Read a tile using the built-in conversion to RGB format provided by the JPEG library.
*/
TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
sz = TIFFTileSize(tif);
if( sz != 128*128*3) {
fprintf(stderr, "tiles are %d bytes\n", (int)sz);
exit(1);
}
buffer = (unsigned char *) malloc(sz);
szout = TIFFReadEncodedTile(tif,9,buffer,sz);
if (szout != sz) {
fprintf( stderr,
"Did not get expected result code from TIFFReadEncodedTile()(%d instead of %d)\n",
(int) szout, (int) sz );
return 1;
}
#if JPEG_LIB_VERSION >= 70
pixel_status |= check_rgb_pixel( 0, 18, 0, 41, buffer );
pixel_status |= check_rgb_pixel( 64, 0, 0, 0, buffer );
pixel_status |= check_rgb_pixel( 512, 5, 34, 196, buffer );
#else
pixel_status |= check_rgb_pixel( 0, 15, 0, 18, buffer );
pixel_status |= check_rgb_pixel( 64, 0, 0, 2, buffer );
pixel_status |= check_rgb_pixel( 512, 6, 36, 182, buffer );
#endif
free( buffer );
TIFFClose(tif);
/*
* Reopen and test reading using the RGBA interface.
*/
tif = TIFFOpen(srcfile,"r");
sz = 128 * 128 * sizeof(uint32);
rgba_buffer = (uint32 *) malloc(sz);
if (!TIFFReadRGBATile( tif, 1*128, 2*128, rgba_buffer )) {
fprintf( stderr, "TIFFReadRGBATile() returned failure code.\n" );
return 1;
}
/*
* Currently TIFFReadRGBATile() just uses JPEGCOLORMODE_RGB so this
* trivally matches the last results. Eventually we should actually
* accomplish it from the YCbCr subsampled buffer ourselves in which
* case the results may be subtly different but similar.
*/
#if JPEG_LIB_VERSION >= 70
pixel_status |= check_rgba_pixel( 0, 18, 0, 41, 255, rgba_buffer );
pixel_status |= check_rgba_pixel( 64, 0, 0, 0, 255, rgba_buffer );
pixel_status |= check_rgba_pixel( 512, 5, 34, 196, 255, rgba_buffer );
#else
pixel_status |= check_rgba_pixel( 0, 15, 0, 18, 255, rgba_buffer );
pixel_status |= check_rgba_pixel( 64, 0, 0, 2, 255, rgba_buffer );
pixel_status |= check_rgba_pixel( 512, 6, 36, 182, 255, rgba_buffer );
#endif
free( rgba_buffer );
TIFFClose(tif);
if (pixel_status) {
exit(1);
}
exit( 0 );
}
int
main(int argc, char **argv)
{
TIFF *tif;
static const char *srcfilerel = "images/quad-tile.jpg.tiff";
char *srcdir = NULL;
char srcfile[1024];
unsigned short h, v;
int status;
unsigned char *buffer;
uint32 *rgba_buffer;
tsize_t sz, szout;
unsigned int pixel_status = 0;
(void) argc;
(void) argv;
if ((srcdir = getenv("srcdir")) == NULL) {
srcdir = ".";
}
printf("XXXXXXXX %s",srcdir);
if ((strlen(srcdir) + 1 + strlen(srcfilerel)) >= sizeof(srcfile)) {
fprintf( stderr, "srcdir too long %s\n", srcdir);
exit( 1 );
}
strcpy(srcfile,srcdir);
strcat(srcfile,"/");
strcat(srcfile,srcfilerel);
tif = TIFFOpen(srcfile,"r");
if ( tif == NULL ) {
fprintf( stderr, "Could not open %s\n", srcfile);
exit( 1 );
}
status = TIFFGetField(tif,TIFFTAG_YCBCRSUBSAMPLING, &h, &v);
if ( status == 0 || h != 2 || v != 2) {
fprintf( stderr, "Could not retrieve subsampling tag.\n" );
exit(1);
}
/*
* What is the appropriate size of a YCbCr encoded tile?
*/
sz = TIFFTileSize(tif);
if( sz != 24576) {
fprintf(stderr, "tiles are %d bytes\n", (int)sz);
exit(1);
}
buffer = (unsigned char *) malloc(sz);
/*
* Read a tile in decompressed form, but still YCbCr subsampled.
*/
szout = TIFFReadEncodedTile(tif,9,buffer,sz);
if (szout != sz) {
fprintf( stderr,
"Did not get expected result code from TIFFReadEncodedTile()(%d instead of %d)\n",
(int) szout, (int) sz );
return 1;
}
if( check_cluster( 0, buffer, cluster_0 )
|| check_cluster( 64, buffer, cluster_64 )
|| check_cluster( 128, buffer, cluster_128 ) ) {
exit(1);
}
free(buffer);
/*
* Read a tile using the built-in conversion to RGB format provided by the JPEG library.
*/
TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
sz = TIFFTileSize(tif);
if( sz != 128*128*3) {
fprintf(stderr, "tiles are %d bytes\n", (int)sz);
exit(1);
}
buffer = (unsigned char *) malloc(sz);
szout = TIFFReadEncodedTile(tif,9,buffer,sz);
if (szout != sz) {
fprintf( stderr,
"Did not get expected result code from TIFFReadEncodedTile()(%d instead of %d)\n",
(int) szout, (int) sz );
return 1;
}
/*
* JPEG decoding is inherently inexact, so we can't test for exact
* pixel values. (Well, if we knew exactly which libjpeg version
* we were using, and with what settings, we could expect specific
* values ... but it's not worth the trouble to keep track of.)
* Hence, use ranges of expected values. The ranges may need to be
* widened over time as more versions of libjpeg appear.
*/
pixel_status |= check_rgb_pixel( 0, 15, 18, 0, 0, 18, 41, buffer );
pixel_status |= check_rgb_pixel( 64, 0, 0, 0, 0, 0, 2, buffer );
pixel_status |= check_rgb_pixel( 512, 5, 6, 34, 36, 182, 196, buffer );
free( buffer );
TIFFClose(tif);
/*
* Reopen and test reading using the RGBA interface.
*/
tif = TIFFOpen(srcfile,"r");
sz = 128 * 128 * sizeof(uint32);
rgba_buffer = (uint32 *) malloc(sz);
if (!TIFFReadRGBATile( tif, 1*128, 2*128, rgba_buffer )) {
fprintf( stderr, "TIFFReadRGBATile() returned failure code.\n" );
return 1;
}
/*
* Currently TIFFReadRGBATile() just uses JPEGCOLORMODE_RGB so this
* trivally matches the last results. Eventually we should actually
* accomplish it from the YCbCr subsampled buffer ourselves in which
* case the results may be subtly different but similar.
*/
pixel_status |= check_rgba_pixel( 0, 15, 18, 0, 0, 18, 41, 255, 255,
rgba_buffer );
pixel_status |= check_rgba_pixel( 64, 0, 0, 0, 0, 0, 2, 255, 255,
rgba_buffer );
pixel_status |= check_rgba_pixel( 512, 5, 6, 34, 36, 182, 196, 255, 255,
rgba_buffer );
free( rgba_buffer );
TIFFClose(tif);
if (pixel_status) {
exit(1);
}
exit( 0 );
}
