/** * test_basic - check volume re-size capability. * * @type volume type (%UBI_DYNAMIC_VOLUME or %UBI_STATIC_VOLUME) * * Thus function returns %0 in case of success and %-1 in case of failure. */ static int test_basic(int type) { struct ubi_mkvol_request req; const char *name = PROGRAM_NAME ":test_basic()"; req.vol_id = UBI_VOL_NUM_AUTO; req.alignment = 1; req.bytes = MIN_AVAIL_EBS * dev_info.leb_size; req.vol_type = type; req.name = name; if (ubi_mkvol(libubi, node, &req)) { failed("ubi_mkvol"); return -1; } req.bytes = dev_info.leb_size; if (ubi_rsvol(libubi, node, req.vol_id, req.bytes)) { failed("ubi_rsvol"); goto remove; } if (check_volume(req.vol_id, &req)) goto remove; req.bytes = (MIN_AVAIL_EBS + 1) * dev_info.leb_size; if (ubi_rsvol(libubi, node, req.vol_id, req.bytes)) { failed("ubi_rsvol"); goto remove; } if (check_volume(req.vol_id, &req)) goto remove; req.bytes -= 1; if (ubi_rsvol(libubi, node, req.vol_id, req.bytes)) { failed("ubi_rsvol"); goto remove; } if (check_volume(req.vol_id, &req)) goto remove; if (ubi_rmvol(libubi, node, req.vol_id)) { failed("ubi_rmvol"); return -1; } return 0; remove: ubi_rmvol(libubi, node, req.vol_id); return -1; }
/** * mkvol_multiple - test multiple volumes creation * * Thus function returns %0 if the test passed and %-1 if not. */ static int mkvol_multiple(void) { struct ubi_mkvol_request req; int i, ret, max = dev_info.max_vol_count; const char *name = PROGRAM_NAME ":mkvol_multiple()"; /* Create maximum number of volumes */ for (i = 0; i < max; i++) { char nm[strlen(name) + 50]; req.vol_id = UBI_VOL_NUM_AUTO; req.alignment = 1; req.bytes = 1; req.vol_type = UBI_STATIC_VOLUME; sprintf(nm, "%s:%d", name, i); req.name = nm; if (ubi_mkvol(libubi, node, &req)) { if (errno == ENFILE) { max = i; break; } failed("ubi_mkvol"); errorm("vol_id %d", i); goto remove; } if (check_volume(req.vol_id, &req)) { errorm("vol_id %d", i); goto remove; } } for (i = 0; i < max; i++) { struct ubi_vol_info vol_info; if (ubi_rmvol(libubi, node, i)) { failed("ubi_rmvol"); return -1; } /* Make sure volume does not exist */ ret = ubi_get_vol_info1(libubi, dev_info.dev_num, i, &vol_info); if (ret == 0) { errorm("removed volume %d exists", i); goto remove; } } return 0; remove: for (i = 0; i < dev_info.max_vol_count + 1; i++) ubi_rmvol(libubi, node, i); return -1; }
int main() { vofi_cint nx=NMX,ny=NMY,nz=NMZ,ndim0=N3D; int i,j,k,itrue; vofi_real cc[NMX][NMY][NMZ],x0[NDIM],xloc[NDIM]; double h0,fh,vol_n; //* -------------------------------------------------------------------------- * //* initialization of the color function with local Gauss integration * //* -------------------------------------------------------------------------- * h0 = H/nx; //* grid spacing * itrue = 1; //* starting point to get fh * x0[0] = 0.5; x0[1] = 0.5; x0[2] = 0.5; //* get the characteristic value fh of the implicit function * fh = vofi_Get_fh(impl_func,x0,h0,ndim0,itrue); //* put now starting point in (X0,Y0,Z0) to initialize the color function * x0[0] = X0; x0[1] = Y0; x0[2] = Z0; //* xloc: minor vertex of each cell of the grid * for (i=0; i<nx; i++) for (j=0; j<ny; j++) for (k=0; k<nz; k++) { xloc[0] = x0[0] + i*h0; xloc[1] = x0[1] + j*h0; xloc[2] = x0[2] + k*h0; cc[i][j][k] = vofi_Get_cc(impl_func,xloc,h0,fh,ndim0); } //* final global check * vol_n = 0.0; for (i=0;i<nx; i++) for (j=0;j<ny; j++) for (k=0;k<nz; k++) vol_n += cc[i][j][k]; vol_n = vol_n*h0*h0*h0; check_volume(vol_n); return 0; }
/** * mkvol_alignment - create volumes with different alignments. * * Thus function returns %0 in case of success and %-1 in case of failure. */ static int mkvol_alignment(void) { struct ubi_mkvol_request req; int i, vol_id, ebsz; const char *name = PROGRAM_NAME ":mkvol_alignment()"; int alignments[] = ALIGNMENTS(dev_info.leb_size); for (i = 0; i < sizeof(alignments)/sizeof(int); i++) { req.vol_id = UBI_VOL_NUM_AUTO; /* Alignment should actually be multiple of min. I/O size */ req.alignment = alignments[i]; req.alignment -= req.alignment % dev_info.min_io_size; if (req.alignment == 0) req.alignment = dev_info.min_io_size; /* Bear in mind alignment reduces EB size */ ebsz = dev_info.leb_size - dev_info.leb_size % req.alignment; req.bytes = (long long)dev_info.avail_lebs * ebsz; req.vol_type = UBI_DYNAMIC_VOLUME; req.name = name; if (ubi_mkvol(libubi, node, &req)) { failed("ubi_mkvol"); errorm("alignment %d", req.alignment); return -1; } vol_id = req.vol_id; if (check_volume(vol_id, &req)) goto remove; if (ubi_rmvol(libubi, node, vol_id)) { failed("ubi_rmvol"); return -1; } } return 0; remove: ubi_rmvol(libubi, node, vol_id); return -1; }
void sound_buffer_data(LPWAVEHDR p) { current_sound_fill--; if (!submit_sound_buffer()) { lost_sound++; display_lost_sound(); fill_sound_buffer(p); /* reuse buffer without encoding it */ return; } if (!sound_recording) p->dwBytesRecorded = 0; check_volume(p,wavefmtex.nChannels == 2, wavefmtex.nSamplesPerSec); volume_compression(p, wavefmtex.nChannels == 2, wavefmtex.nSamplesPerSec); submit_encoder_input(p); current_sound_bytes = current_sound_bytes + p->dwBytesRecorded; }
/** * mkvol_basic - simple test that checks basic volume creation capability. * * Thus function returns %0 in case of success and %-1 in case of failure. */ static int mkvol_basic(void) { struct ubi_mkvol_request req; struct ubi_vol_info vol_info; int vol_id, ret; const char *name = PROGRAM_NAME ":mkvol_basic()"; /* Create dynamic volume of maximum size */ req.vol_id = UBI_VOL_NUM_AUTO; req.alignment = 1; req.bytes = dev_info.avail_bytes; req.vol_type = UBI_DYNAMIC_VOLUME; req.name = name; if (ubi_mkvol(libubi, node, &req)) { failed("ubi_mkvol"); return -1; } vol_id = req.vol_id; if (check_volume(vol_id, &req)) goto remove; if (ubi_rmvol(libubi, node, vol_id)) { failed("ubi_rmvol"); return -1; } /* Create static volume of maximum size */ req.vol_id = UBI_VOL_NUM_AUTO; req.alignment = 1; req.bytes = dev_info.avail_bytes; req.vol_type = UBI_STATIC_VOLUME; req.name = name; if (ubi_mkvol(libubi, node, &req)) { failed("ubi_mkvol"); return -1; } vol_id = req.vol_id; if (check_volume(vol_id, &req)) goto remove; if (ubi_rmvol(libubi, node, vol_id)) { failed("ubi_rmvol"); return -1; } /* Make sure volume does not exist */ ret = ubi_get_vol_info1(libubi, dev_info.dev_num, vol_id, &vol_info); if (ret == 0) { errorm("removed volume %d exists", vol_id); goto remove; } return 0; remove: ubi_rmvol(libubi, node, vol_id); return -1; }
int main(int ac, char **av) { uint32_t status; hammer2_off_t total_space; hammer2_off_t free_space; hammer2_off_t reserved_space; int ch; int fd = -1; char *fsidstr; char *spfsidstr; char *rpfsidstr; /* * Sanity check basic filesystem structures. No cookies for us * if it gets broken! */ assert(sizeof(hammer2_volume_data_t) == HAMMER2_VOLUME_BYTES); assert(sizeof(hammer2_inode_data_t) == HAMMER2_INODE_BYTES); assert(sizeof(hammer2_blockref_t) == HAMMER2_BLOCKREF_BYTES); /* * Generate a filesystem id and lookup the filesystem type */ srandomdev(); uuidgen(&Hammer2_FSId, 1); uuidgen(&Hammer2_SPFSId, 1); uuidgen(&Hammer2_RPFSId, 1); uuid_from_string(HAMMER2_UUID_STRING, &Hammer2_FSType, &status); /*uuid_name_lookup(&Hammer2_FSType, "DragonFly HAMMER2", &status);*/ if (status != uuid_s_ok) { errx(1, "uuids file does not have the DragonFly " "HAMMER filesystem type"); } /* * Parse arguments */ while ((ch = getopt(ac, av, "fL:b:m:r:V:")) != -1) { switch(ch) { case 'f': ForceOpt = 1; break; case 'L': Label = optarg; if (strlen(Label) > HAMMER2_INODE_MAXNAME) { errx(1, "Root directory label too long " "(64 chars max)\n"); } break; case 'b': BootAreaSize = getsize(optarg, HAMMER2_NEWFS_ALIGN, HAMMER2_BOOT_MAX_BYTES, 2); break; case 'r': AuxAreaSize = getsize(optarg, HAMMER2_NEWFS_ALIGN, HAMMER2_REDO_MAX_BYTES, 2); break; case 'V': Hammer2Version = strtol(optarg, NULL, 0); if (Hammer2Version < HAMMER2_VOL_VERSION_MIN || Hammer2Version >= HAMMER2_VOL_VERSION_WIP) { errx(1, "I don't understand how to format " "HAMMER2 version %d\n", Hammer2Version); } break; default: usage(); break; } } if (Hammer2Version < 0) { size_t olen = sizeof(Hammer2Version); Hammer2Version = HAMMER2_VOL_VERSION_DEFAULT; if (sysctlbyname("vfs.hammer2.supported_version", &Hammer2Version, &olen, NULL, 0) == 0) { if (Hammer2Version >= HAMMER2_VOL_VERSION_WIP) { Hammer2Version = HAMMER2_VOL_VERSION_WIP - 1; fprintf(stderr, "newfs_hammer: WARNING: HAMMER2 VFS " "supports higher version than I " "understand,\n" "using version %d\n", Hammer2Version); } } else { fprintf(stderr, "newfs_hammer: WARNING: HAMMER2 VFS not " "loaded, cannot get version info.\n" "Using version %d\n", HAMMER2_VOL_VERSION_DEFAULT); } } /* * Collect volume information. */ ac -= optind; av += optind; if (ac != 1) { fprintf(stderr, "Exactly one disk device must be specified\n"); exit(1); } total_space = check_volume(av[0], &fd); /* * ~typically 8MB alignment to avoid edge cases for reserved blocks * and so raid stripes (if any) operate efficiently. */ total_space &= ~HAMMER2_VOLUME_ALIGNMASK64; /* * Calculate defaults for the boot area size and round to the * volume alignment boundary. */ if (BootAreaSize == 0) { BootAreaSize = HAMMER2_BOOT_NOM_BYTES; while (BootAreaSize > total_space / 20) BootAreaSize >>= 1; if (BootAreaSize < HAMMER2_BOOT_MIN_BYTES) BootAreaSize = HAMMER2_BOOT_MIN_BYTES; } else if (BootAreaSize < HAMMER2_BOOT_MIN_BYTES) {
int main(int argc, char *argv[]) { vofi_cint nx=NMX,ny=NMY,nz=NMZ,ndim0=N3D; int i,j,k,itrue; vofi_real cc[NMX][NMY][NMZ],x0[NDIM],xloc[NDIM]; double h0,fh,vol_n; int randominput = 0; int count; for (count = 1; count < argc; ++count) { if (!strcmp(argv[count], "-r") || !strcmp(argv[count], "--randominput")) { randominput = 1; } } /* -------------------------------------------------------------------------- * * initialization of the color function with local Gauss integration * * -------------------------------------------------------------------------- */ h0 = H/nx; /* grid spacing */ itrue = 1; /* starting point to get fh */ x0[0] = 0.5; x0[1] = 0.5; x0[2] = 0.5; init(randominput); /* get the characteristic value fh of the implicit function */ fh = vofi_Get_fh(impl_func,x0,h0,ndim0,itrue); /* put now starting point in (X0,Y0,Z0) to initialize the color function */ x0[0] = X0; x0[1] = Y0; x0[2] = Z0; /* xloc: minor vertex of each cell of the grid */ for (i=0; i<nx; i++) for (j=0; j<ny; j++) for (k=0; k<nz; k++) { xloc[0] = x0[0] + i*h0; xloc[1] = x0[1] + j*h0; xloc[2] = x0[2] + k*h0; cc[i][j][k] = vofi_Get_cc(impl_func,xloc,h0,fh,ndim0); } /* final global check */ vol_n = 0.0; for (i=0;i<nx; i++) for (j=0;j<ny; j++) for (k=0;k<nz; k++) vol_n += cc[i][j][k]; vol_n = vol_n*h0*h0*h0; check_volume(vol_n, randominput); return 0; }
PalFileMenu *PalFile::config_tree_build_children( ldh_tSession ldhses, ifstream *fp, int *line_cnt, const char *filename, PalFileMenu *parent) { PalFileMenu *menu_p, *prev, *mp; PalFileMenu *return_menu = NULL; int first = 1; int nr; char line[140]; char type[120]; char name[120]; char p1[120]; char p2[120]; int found; int hide_children = 0; // Children might already exist if ( parent) { for ( menu_p = parent->child_list; menu_p; menu_p = menu_p->next) { prev = menu_p; first = 0; } } menu_p = 0; while ( 1) { if ( !fp->getline( line, sizeof( line))) break; dcli_remove_blank( line, line); (*line_cnt)++; if ( line[0] == 0) continue; if ( line[0] == '!' || line[0] == '#') continue; nr = sscanf( line, "%s %s %s %s", type, name, p1, p2); if ( nr < 1 ) printf( "** Syntax error in file %s, line %d\n", filename, *line_cnt); if ( strcmp( type, "{") == 0) { if ( !hide_children) { if ( nr != 1 || !menu_p) printf( "** Syntax error in file %s, line %d\n", filename, *line_cnt); else mp = config_tree_build_children( ldhses, fp, line_cnt, filename, menu_p); if ( !menu_p->child_list) menu_p->child_list = mp; } else hide_children = 0; } else if ( strcmp( type, "}") == 0) { if ( nr != 1 ) printf( "** Syntax error in file %s, line %d\n", filename, *line_cnt); return return_menu; } else if ( cdh_NoCaseStrcmp( type, "menu") == 0) { if ( !(nr == 2 || nr == 3)) printf( "** Syntax error in file %s, line %d\n", filename, *line_cnt); if ( nr == 3 && ( ldhses && !check_volume( ldhses, p1))) { hide_children = 1; break; } // Check if it already exist found = 0; for ( menu_p = parent->child_list; menu_p; menu_p = menu_p->next) { if ( strcmp( menu_p->title, name) == 0) { found = 1; break; } } if ( !found) { menu_p = new PalFileMenu( name, pal_eMenuType_Menu, parent); if ( first) { return_menu = menu_p; first = 0; } else prev->next = menu_p; prev = menu_p; } } else if ( cdh_NoCaseStrcmp( type, "class") == 0) { if ( !( nr == 2 || nr == 3)) printf( "** Syntax error in file %s, line %d\n", filename, *line_cnt); if ( nr == 2 || ( nr == 3 && (!ldhses || check_volume( ldhses, p1)))) { menu_p = new PalFileMenu( name, pal_eMenuType_Class, parent); if ( first) { return_menu = menu_p; first = 0; } else prev->next = menu_p; prev = menu_p; } } else if ( cdh_NoCaseStrcmp( type, "classvolume") == 0) { if ( !(nr == 2 || nr == 3)) printf( "** Syntax error in file %s, line %d\n", filename, *line_cnt); if ( nr == 2 || ( nr == 3 && (!ldhses || check_volume( ldhses, p1)))) { menu_p = new PalFileMenu( name, pal_eMenuType_ClassVolume, parent); if ( first) { return_menu = menu_p; first = 0; } else prev->next = menu_p; prev = menu_p; } } } return return_menu; }
int main (int argc, char ** argv) { int opts = 0; int delay = 8000; short volume = 4; // Get the arguments while((opts = getopt(argc, argv,"d:v: tt")) != -1) { if (opts == 'd') { delay = atoi(optarg); } else if (opts == 'v') { volume = atoi(optarg); } } // Make sure delay is not negative // Make sure volume scale is at least 1 check_delay(&delay); check_volume(&volume); // Open the files in binary mode to read, or write FILE *source = fopen(argv[optind], "rb"); FILE *dest = fopen(argv[optind+1], "wb"); // Handle incorrect source file input check_source(&source); // READ header from source - first 44 bytes as 11 ints int header[11] = {0}; fread(header, sizeof(int), 11, source); // Change file size in the header header[1] += delay*2; header[10] += delay*2; // WRITE header to output file fwrite(header, sizeof(int), 11, dest); // Allocate mem to store delay number of shorts short *buffer; buffer = malloc((sizeof(short) * delay)); // Copy samples before DELAY num of samples into buffer fseek(source, 44, SEEK_SET); // 44 bytes from start of file fread(buffer, sizeof(short), delay, source); // START READING THE SAMPLES ONE AT A TIME. fseek(source, 44, SEEK_SET); // 44 bytes from start of file short smp = 0; // This will hold the sample being read int s = 0; // Keeps track of the NUMBER OF samples read while (fread(&smp, sizeof(short), 1, source)) { if (s < delay) { // If not at sample number DELAY yet, just write as they are... fwrite(&smp, sizeof(short), 1, dest); } else { // At sample number DELAY, write mixed in buffer[0] scaled by volume short temp = smp + (buffer[0] / volume); fwrite(&temp, sizeof(short), 1, dest); } // START OF BUFFER CODE // Append smp to the buffer AFTER "popping it" int i = 0; for (i = 0; i < delay-1; i++) { buffer[i] = buffer[i+1]; } buffer[delay-1] = smp; // EOF BUFFER CODE s++; // Increment the number of samples } // Write the rest of the buffer scaled by volume to dest int i = 0; for (i = 0; i < delay; i++) { buffer[i] /= volume; } fwrite(buffer, sizeof(short), delay, dest); return 0; }