void RNDEND_load_assets(void) { rndend_win_gfx = COMMON_load_texture(WIN_GFX_PATH); rndend_loss_gfx = COMMON_load_texture(LOSS_GFX_PATH); if (exists(WIN_CHIME_PATH)) rndend_win_chime = load_sample(WIN_CHIME_PATH); else { rndend_win_chime = create_sample(8, 0, 1, 1); OH_SMEG("missing sound: %s", WIN_CHIME_PATH); } if (exists(LOSS_CHIME_PATH)) rndend_loss_chime = load_sample(LOSS_CHIME_PATH); else { rndend_loss_chime = create_sample(8, 0, 1, 1); OH_SMEG("missing sound: %s", LOSS_CHIME_PATH); } RNDEND_reset(); rndend_uv_tmp[0].u = 0.0f; rndend_uv_tmp[0].v = 0.0f; rndend_uv_tmp[1].u = 1.0f; rndend_uv_tmp[1].v = 0.0f; rndend_uv_tmp[2].u = 1.0f; rndend_uv_tmp[2].v = 1.0f; rndend_uv_tmp[3].u = 0.0f; rndend_uv_tmp[3].v = 1.0f; }
int main(int argc, char **argv) { Database *db = create_sample(); check(argc == 3, "usage: %s <csvfile> <defindex>", argv[0]); char *csv_file = argv[1]; int def_idx = atoi(argv[2]); check(def_idx < db->def_size, "unknown def index: %d", def_idx); FILE* stream = fopen(csv_file, "r"); char line[1024]; while (fgets(line, 1024, stream)) { char *tmp = strdup(line); Record *record = parse_line(tmp, db->record_ds[def_idx], def_idx); free(tmp); Database_push(db, record); Record_destroy(record); } fclose(stream); Database_print(db); Database_destroy(db); return 0; error: return 1; }
void sinsp_table::flush(sinsp_evt* evt) { if(!m_paused) { if(m_next_flush_time_ns != 0) { // // Time to emit the sample! // Add the proctable as a sample at the end of the second // process_proctable(evt); // // If there is a merging step, switch the types to point to the merging ones. // if(m_do_merging) { m_types = &m_postmerge_types; m_table = &m_merge_table; m_n_fields = m_n_postmerge_fields; m_vals_array_sz = m_postmerge_vals_array_sz; m_fld_pointers = m_postmerge_fld_pointers; m_extractors = &m_postmerge_extractors; } // // Emit the sample // create_sample(); if(m_type == sinsp_table::TT_TABLE) { // // Switch the data storage so that the current one is still usable by the // consumers of the table. // switch_buffers(); // // Clear the current data storage // m_buffer->clear(); } // // Reinitialize the tables // m_premerge_table.clear(); m_merge_table.clear(); } } uint64_t ts = evt->get_ts(); m_prev_flush_time_ns = m_next_flush_time_ns; m_next_flush_time_ns = ts - (ts % m_refresh_interval_ns) + m_refresh_interval_ns; return; }
SAMPLE *alogg_create_sample_from_ogg(ALOGG_OGG *ogg) { SAMPLE *sample; char *data; int i, sample_len_bytes, sample_len, size_done, done; /* first we need to calculate the len of the sample in bytes */ sample_len = ov_pcm_total(&(ogg->vf), -1); sample_len_bytes = (sample_len * (ogg->stereo ? 2 : 1)) * 2; /* / 2 = 16 bits */ /* create the sample */ sample = create_sample(16, ogg->stereo, ogg->freq, sample_len); /* return NULL if we were not able to allocate the memory for it */ if (sample == NULL) return NULL; /* we need to stop and rewind the ogg */ alogg_stop_ogg(ogg); alogg_rewind_ogg(ogg); /* set our pointer */ data = (char *)sample->data; /* clear the sample buffer in unsigned format */ { int i; unsigned short *j = (unsigned short *)data; for (i = 0; i < (sample_len_bytes / 2); i++, j++) *j = 0x8000; } /* decode */ done = FALSE; size_done = 0; for (i = sample_len_bytes; !done && (i > 0); i -= size_done) { /* decode */ size_done = ov_read(&(ogg->vf), data, i, 0, 2, 0, &(ogg->current_section)); /* check if the decoding was not successful */ if (size_done < 0) { if (size_done == OV_HOLE) size_done = 0; else { alogg_rewind_ogg(ogg); destroy_sample(sample); return NULL; } } else if (size_done == 0) done = TRUE; data += size_done; } alogg_rewind_ogg(ogg); return sample; }
/* the metapopulation. */ struct sample * draw_sample(struct metapopulation *in, int n, struct param *par){ int i, j, *nIsolatesPerPop, count; double *nAvailPerPop; struct pathogen *ppat; /* create pointer to pathogens */ struct sample *out=create_sample(n); /* escape if no isolate available */ if(get_total_ninf(in) + get_total_nexp(in) < 1){ printf("\nMetapopulation without infections - sample will be empty.\n"); out->n = 0; out->pathogens = NULL; out->popid = NULL; return out; } /* get nb of isolates available in each population */ nAvailPerPop = (double *) calloc(get_npop(in), sizeof(double)); if(nAvailPerPop == NULL){ fprintf(stderr, "\n[in: population.c->draw_sample]\nNo memory left to isolate available pathogens. Exiting.\n"); exit(1); } for(j=0;j<get_npop(in);j++){ nAvailPerPop[j] = (double) get_nexp(get_populations(in)[j]) + get_ninf(get_populations(in)[j]); } /* get nb of isolates sampled in each population*/ nIsolatesPerPop = (int *) calloc(get_npop(in), sizeof(int)); if(nIsolatesPerPop == NULL){ fprintf(stderr, "\n[in: population.c->draw_sample]\nNo memory left to isolate available pathogens. Exiting.\n"); exit(1); } gsl_ran_multinomial(par->rng, get_npop(in), n, nAvailPerPop, (unsigned int *) nIsolatesPerPop); /* fill in the sample pathogens */ count = 0; for(j=0;j<get_npop(in);j++){ /* for each population */ for(i=0;i<nIsolatesPerPop[j];i++){ ppat = select_random_pathogen(get_populations(in)[j], par); /* free_pathogen(out->pathogens[count]); */ out->pathogens[count] = reconstruct_genome(ppat); out->popid[count++] = j; } } /* free local pointers */ free(nAvailPerPop); free(nIsolatesPerPop); return out; } /* end draw_sample */
int main(void) { create_sample(); test_flock(); test_flock64(); #ifdef TEST_F_OWNER_EX test_f_owner_ex(); #endif puts("+++ exited with 0 +++"); return 0; }
SAMPLE * create_silence_sample(unsigned long ms) { SAMPLE * sp = NULL; int bits; int stereo; int freq; unsigned long samples, i; unsigned channels; eof_log("create_silence_sample() entered", 1); if(eof_music_track) { bits = alogg_get_wave_bits_ogg(eof_music_track); stereo = alogg_get_wave_is_stereo_ogg(eof_music_track); freq = alogg_get_wave_freq_ogg(eof_music_track); samples = msec_to_samples(ms); channels = stereo ? 2 : 1; } else { bits = 16; stereo = 1; freq = 44100; samples = (double)(ms * freq) / 1000.0; channels = 2; } sp = create_sample(bits, stereo, freq, samples); if(!sp) return NULL; //Return error if(bits == 8) { for(i = 0; i < samples * channels; i++) { ((unsigned char *)(sp->data))[i] = 0x80; } } else { for(i = 0; i < samples * channels; i++) { ((unsigned short *)(sp->data))[i] = 0x8000; } } return sp; }
+=j!=I&&i!=J&&i!=I&&j!=J&&*c(I,J)&&q(p(i),p(j),p(I),p(J));return f;}main(){int i ,I,j,J,f,F,a,b,s=-1,X,Y,H,h;BITMAP*B;SAMPLE*S;allegro_init();*c(0,1)=*c(0,2)=*c( 0,3)=1;set_gfx_mode(GFX_AUTODETECT_WINDOWED,w,w,0,0);install_sound(DIGI_DIRECTX( 0),MIDI_NONE,0);B=create_bitmap(w,w);install_keyboard();install_mouse();*c(2,3)= *c(1,2)=*c(1,3)=1;text_mode(-1);S=create_sample(8,0,9999,9999);for(i=0;i<9999;i ++){((unsigned char*)S->data)[i]=(((i+(fixsin(i<<13)>>13))%100+(i)%152)*i)/9000; }for(l=4;l<99;l++){play_sample(S,255,55,1600,0);play_sample(S,255,200,1604,0); for(i=0;i<l;i++){x[i]=((fixcos((i<<24)/l)*w/3)>>16)+w/2;y[i]=((fixsin((i<<24)/l) *w/3)>>16)+w/2;}do{F=0;key[KEY_ESC]?exit(0):0;clear_to_color(B,15);for(i=0;i<l;i ++){for(j=0;j<l;j++){f=0;if(*c(j,i)){f=M(i,j);for(a=-1;a<2;a++)for(b=-1;b<2;b++) line(B,a+p(i)+b,a+p(j)+b,f?12:10);}F|=f;}}for(i=0;i<l;i++){circlefill(B,p(i),8,0 );circlefill(B,p(i),6,s==i?7:8);s=mouse_b?s:-1;if(mouse_b&&s<0&&_(mouse_x-x[i],- 7,7)&&_(mouse_y-y[i],-7,7))s=i;}if(s>=0){x[s]=mouse_x;y[s]=mouse_y;}textprintf(B ,font,10,10,0,"Level %d",l-3);draw_sprite(B,mouse_sprite,mouse_x,mouse_y);blit(B ,screen,0,0,0,0,w,w);}while(F||mouse_b);H=0;for(j=0;j<2000;j++){h=0;x[l]=rand()% w*2-w/2;y[l]=rand()%w*2-w/2;for(i=0;i<l;i++){h+=M(i,l)==0;}if(h>H){H=h;X=x[l];Y= y[l];}}x[l]=X;y[l]=Y;for(i=0;i<l;i++){*c(i,l)=M(i,l)==0;*c(rand()%l,rand()%l)=0; }}}END_OF_MAIN();///////////////////////////////////////////////////////////////
/* merge several samples together */ struct sample * merge_samples(struct sample **in, int nsamp, struct param *par){ int i, j, newsize=0, counter=0; /* create output */ for(i=0;i<nsamp;i++) newsize += get_n(in[i]); struct sample * out = create_sample(newsize); /* fill in output */ for(i=0;i<nsamp;i++){ for(j=0;j<get_n(in[i]);j++){ out->pathogens[counter] = copy_pathogen(in[i]->pathogens[j]); out->popid[counter++] = in[i]->popid[j]; } } out->n = newsize; return out; }
QVector<QVector<double> > createMatrix(int k, int n, double m, double g, QVector<double> trend_mean, QVector<double> trend_s) { QVector<QVector<double> > matrix; if((trend_mean.size()!=2)||(trend_s.size()!=2)) { qDebug() << "uncorrect number trend parametr"; return matrix; } double mi, gi; for(int i = 0; i<k; i++) { mi = m + trend_mean[0]*i + trend_mean[1]*i*i; gi = g + trend_s[0]*i + trend_s[1]*i*i; matrix.push_back(create_sample(n,mi,gi,i)); } return matrix; }
/* (`allegro_init()' is already defined by Allegro itself.) */ static int allegro_init_sound(const char *param, int *speed, int *fragsize, int *fragnr, int *channels) { unsigned int i; /* No stereo capability. */ *channels = 1; if (allegro_startup(*speed) < 0) return 1; fragment_size = *fragsize * sizeof(SWORD); buffer_len = fragment_size * *fragnr; buffer = create_sample(16, 0, *speed, buffer_len / sizeof(SWORD)); for (i = 0; i < buffer_len / 2; i++) *((WORD *)buffer->data + i) = 0x8000; voice = allocate_voice(buffer); if (voice < 0) { log_debug("Cannot allocate Allegro voice!\n"); destroy_sample(buffer); return 1; } buffer_offset = 0; been_suspended = 1; written_samples = 0; voice_set_playmode(voice, PLAYMODE_LOOP); voice_set_volume(voice, 255); voice_set_pan(voice, 128); return 0; }
int main(int argc, const char *argv[]) { if (create_sample(1,1000)) printf("write sample succeful\n"); return 0; }
static SAMPLE *load_ov(OggVorbis_File *vf) { int ret; vorbis_info *info; SAMPLE *sample=NULL; ogg_int64_t num_samples; size_t offset; AL_CONST size_t max_read=4096; size_t buffer_size; size_t buffer_inc=65536; int stereo; info=ov_info(vf,-1); if (!info) { TRACE("ov_info failed\n"); goto load_error_file; } stereo=(info->channels>1); num_samples=ov_pcm_total(vf,-1); TRACE("ov_pcm_total says %lld samples\n",num_samples); if (num_samples<0) { TRACE("ov_pcm_total failed: %lld - not fatal\n",(ogg_int64_t)num_samples); } TRACE( "ov_load: create sample: %d bits, %d channels (%s), %ld Hz, %lld samples\n", 16,info->channels,stereo?"stereo":"mono",info->rate,num_samples ); sample=create_sample(16,stereo,info->rate,num_samples>0?num_samples:1); if (!sample) { TRACE( "Failed creating a sample (%d channels, %ld Hz, %u samples", info->channels,info->rate,(size_t)num_samples ); goto load_error_file; } /* decode the encoded data */ for (offset=0,buffer_size=0;;) { if (num_samples<0) { /* If we could not determine the size of the sample, allocate as we go */ if (offset+max_read>buffer_size) { TRACE("Buffer too small: adding %u bytes\n",buffer_inc); buffer_size+=buffer_inc; buffer_inc+=buffer_inc/2; #ifdef FORTIFY { /* Fortify won't have seen the allocation which was done in Allegro */ void *tmpdata=malloc(buffer_size); memcpy(tmpdata,sample->data,offset); destroy_sample(sample); sample=create_sample(16,stereo,info->rate,buffer_size/(stereo?2:1)/2); memcpy(sample->data,tmpdata,offset); free(tmpdata); } #else sample->data=realloc(sample->data,buffer_size); #endif } if (!sample->data) { TRACE("Failed allocating sample data\n"); goto load_error_sample; } } ret=read_ogg_data(vf,((char*)sample->data)+offset,max_read,2,0,NULL); if (ret==0) break; if (ret<0) { TRACE("read_ogg_data failed: %d\n",ret); alogg_error_code=ret; goto load_error_sample; } offset+=ret; } TRACE("ov_load: clearing\n"); ov_clear(vf); /* ov_clear will have closed the PACKFILE, so no need to do it there */ /* If we couldn't allocate up front, update the size related fields */ if (num_samples<0) { ASSERT(offset%(stereo?2:1)/2==0); sample->len=offset/(stereo?2:1)/2; TRACE("Final size: %lu samples\n",sample->len); sample->loop_end=sample->len; lock_sample(sample); } return sample; load_error_sample: destroy_sample(sample); load_error_file: ov_clear(vf); return NULL; }
DATASET *read_seq_file( char *file_name, /* name of file to open */ char *alpha, /* alphabet used in sequences */ BOOLEAN use_comp, /* use complementary strands, too */ double seqfrac /* fraction of input sequences to use */ ) { int i, j; FILE *data_file; /* file with samples to read */ FILE *prior_file=NULL; /* file with positional priors to read */ char *sample_name; /* name of sample read */ char *sample_de; /* descriptor text for sample */ char *sequence; /* sequence read */ long length; /* length of sequence */ BOOLEAN error=FALSE; /* none yet */ SAMPLE *sample; /* sample created */ DATASET *dataset; /* dataset created */ int n_samples=0; /* number of samples read */ double *seq_weights=NULL; /* sequence weights */ int n_wgts=0; /* number of sequence weights given */ /* create a hash table of sequence names */ if (!ht_seq_names) ht_seq_names = hash_create(DATA_HASH_SIZE); /* create a dataset */ dataset = (DATASET *) mymalloc(sizeof(DATASET)); dataset->alength = strlen(alpha); dataset->alphabet = alpha; dataset->psp_w = 0; // indicates no PSP was read dataset->log_psp_w = 0; // so log_psp will get initialized /* open data file */ if (file_name == NULL) { fprintf(stderr, "You must specify a data file or `stdin'.\n"); exit(1); } else if (strcmp(file_name, "stdin")) { data_file = fopen(file_name, "r"); if (data_file == NULL) { fprintf(stderr, "Cannot open file `%s'.\n", file_name); exit(1); } } else { data_file = stdin; } /* initialize maximum length of sequences */ dataset->max_slength = 0; dataset->min_slength = 10000000; dataset->n_samples = 0; /* no samples yet */ dataset->samples = NULL; /* no samples */ while (read_sequence(data_file, &sample_name, &sample_de, &sequence, &length)) { /* skip sequence if an error occurred */ if (length < 0) continue; /* parse weights if given; make (more than enough) room in array */ if (strcmp(sample_name, "WEIGHTS")==0) { double wgt; char *wgt_str = sample_de; Resize(seq_weights, n_wgts+(int)strlen(wgt_str), double); while (sscanf(wgt_str, "%lf", &wgt) == 1) { if (wgt <= 0 || wgt > 1) { fprintf(stderr, "Weights must be larger than zero and no greater than 1.\n"); exit(1); } seq_weights[n_wgts++] = wgt; /* save weight */ wgt_str += strspn(wgt_str, " "); /* skip white */ wgt_str += strcspn(wgt_str, " "); /* skip token */ } myfree(sample_name); myfree(sample_de); myfree(sequence); continue; } /* ignore duplicate (same sample name) sequences */ if (hash_lookup_str(sample_name, ht_seq_names) != NULL) { fprintf(stderr, "Skipping sequence '%s'.\n", sample_name); myfree(sample_name); myfree(sample_de); myfree(sequence); continue; } hash_insert_str(sample_name, ht_seq_names); /* put name in hash table */ n_samples++; /* see if sequence will be used in random sample; store it if yes */ if (drand48() >= 1 - seqfrac) { HASH_TABLE_ENTRY *hash_entry; // needed to add pointer to sample /* create the sample */ sample = create_sample(alpha, length, sample_name, sequence, sample_de, use_comp); if (sample == NULL) {error = TRUE; continue;} /* record maximum length of actual sequences */ dataset->max_slength = MAX(sample->length, dataset->max_slength); dataset->min_slength = MIN(sample->length, dataset->min_slength); /* put the sample in the array of samples */ if ((dataset->n_samples % RCHUNK) == 0) { Resize(dataset->samples, dataset->n_samples + RCHUNK, SAMPLE *); }
int save_wav_with_silence_appended(const char * fn, SAMPLE * sp, unsigned long ms) { unsigned long i, samples, channels, index = 0; SAMPLE * silence, * combined; int retval; eof_log("save_wav_with_silence_appended() entered", 1); if(!fn || !sp) return 0; //Invalid parameters if(!ms) { //If the calling function specified writing the WAV with no silence appended return save_wav(fn, sp); //Write the audio normally } //Generate the silent audio to conform to the input sample's specifications samples = (double)ms * (double)sp->freq / 1000.0; channels = sp->stereo ? 2 : 1; silence = create_sample(sp->bits, sp->stereo, sp->freq, samples); if(!silence) return 0; //Return failure if(sp->bits == 8) { for(i = 0; i < samples * channels; i++) { ((unsigned char *)(silence->data))[i] = 0x80; } } else { for(i = 0; i < samples * channels; i++) { ((unsigned short *)(silence->data))[i] = 0x8000; } } //Combine the input audio and silence combined = create_sample(sp->bits, sp->stereo, sp->freq, sp->len + samples); if(!combined) { free(silence); return 0; //Return failure } if(sp->bits == 8) { for(i = 0; i < sp->len * channels; i++) { //For each sample in the input audio ((unsigned char *)(combined->data))[index++] = ((unsigned char *)(sp->data))[i]; //Copy it into the combined audio sample } for(i = 0; i < silence->len * channels; i++) { //For each sample in the silent audio ((unsigned char *)(combined->data))[index++] = ((unsigned char *)(silence->data))[i]; //Copy it into the combined audio sample } } else { for(i = 0; i < sp->len * channels; i++) { //For each sample in the input audio ((unsigned short *)(combined->data))[index++] = ((unsigned short *)(sp->data))[i]; //Copy it into the combined audio sample } for(i = 0; i < silence->len * channels; i++) { //For each sample in the silent audio ((unsigned short *)(combined->data))[index++] = ((unsigned short *)(silence->data))[i]; //Copy it into the combined audio sample } } //Write the combined audio to file and return retval = save_wav(fn, combined); //Write the combined audio destroy_sample(combined); destroy_sample(silence); return retval; }
int osd_start_audio_stream(int stereo) { #ifdef USE_SEAL int channel; #endif if (stereo) stereo = 1; /* make sure it's either 0 or 1 */ stream_cache_stereo = stereo; /* determine the number of samples per frame */ samples_per_frame = (double)Machine->sample_rate / (double)Machine->drv->frames_per_second; /* compute how many samples to generate this frame */ samples_left_over = samples_per_frame; samples_this_frame = (UINT32)samples_left_over; samples_left_over -= (double)samples_this_frame; audio_buffer_length = NUM_BUFFERS * samples_per_frame + 20; if (Machine->sample_rate == 0) return 0; #ifdef USE_SEAL for (channel = 0;channel <= stereo;channel++) { if (ACreateAudioVoice(&hVoice[channel]) != AUDIO_ERROR_NONE) return 0; if ((lpWave[channel] = (LPAUDIOWAVE)malloc(sizeof(AUDIOWAVE))) == 0) { ADestroyAudioVoice(hVoice[channel]); return 0; } lpWave[channel]->wFormat = AUDIO_FORMAT_16BITS | AUDIO_FORMAT_MONO | AUDIO_FORMAT_LOOP; lpWave[channel]->nSampleRate = nominal_sample_rate; lpWave[channel]->dwLength = 2*audio_buffer_length; lpWave[channel]->dwLoopStart = 0; lpWave[channel]->dwLoopEnd = lpWave[channel]->dwLength; if (ACreateAudioData(lpWave[channel]) != AUDIO_ERROR_NONE) { free(lpWave[channel]); lpWave[channel] = 0; return 0; } memset(lpWave[channel]->lpData,0,lpWave[channel]->dwLength); APrimeVoice(hVoice[channel],lpWave[channel]); ASetVoiceFrequency(hVoice[channel],nominal_sample_rate); } if (stereo) { /* SEAL doubles volume for panned channels, so we have to compensate */ ASetVoiceVolume(hVoice[0],32); ASetVoiceVolume(hVoice[1],32); ASetVoicePanning(hVoice[0],0); ASetVoicePanning(hVoice[1],255); AStartVoice(hVoice[0]); AStartVoice(hVoice[1]); } else { ASetVoiceVolume(hVoice[0],64); ASetVoicePanning(hVoice[0],128); AStartVoice(hVoice[0]); } #endif #ifdef USE_ALLEGRO mysample = create_sample(16,stereo,nominal_sample_rate,audio_buffer_length); if (mysample == 0) return 0; myvoice = allocate_voice(mysample); voice_set_playmode(myvoice,PLAYMODE_LOOP); if (stereo) { INT16 *buf = mysample->data; int p = 0; while (p != audio_buffer_length) { buf[2*p] = (INT16)0x8000; buf[2*p+1] = (INT16)0x8000; p++; } } else { INT16 *buf = mysample->data; int p = 0; while (p != audio_buffer_length) { buf[p] = (INT16)0x8000; p++; } } voice_start(myvoice); #endif stream_playing = 1; voice_pos = 0; return samples_this_frame; }
/* creates a new sample object */ static void *makenew_sample(long *size) { return create_sample(8, FALSE, 11025, 1024); }
extern DATASET *read_seq_file( AjPSeqall seqa, /* name of file to open */ char *alpha, /* alphabet used in sequences */ BOOLEAN use_comp, /* use complementary strands, too */ double seqfrac /* fraction of input sequences to use */ ) { int i, j, pcol; /*FILE *data_file;*/ /* file with samples to read */ char *sample_name; /* name of sample read */ char *sample_de; /* descriptor text for sample */ char *sequence; /* sequence read */ int length; /* length of sequence */ BOOLEAN error=FALSE; /* none yet */ SAMPLE *sample; /* sample created */ DATASET *dataset; /* dataset created */ int n_samples=0; /* number of samples read */ double *seq_weights=NULL; /* sequence weights */ int n_wgts=0; /* number of sequence weights given */ /* create a hash table of sequence names */ if (!ht_seq_names) ht_seq_names = hash_create(DATA_HASH_SIZE); /* create a dataset */ dataset = (DATASET *) malloc(sizeof(DATASET)); dataset->alength = strlen(alpha); dataset->alphabet = alpha; dataset->pal = 0; /* not looking for palindromes */ /* initialize maximum length of sequences */ dataset->max_slength = 0; dataset->min_slength = 10000000; dataset->n_samples = 0; /* no samples yet */ dataset->samples = NULL; /* no samples */ while (read_sequence(seqa, &sample_name, &sample_de, &sequence, &length)) { /* skip sequence if an error occurred */ if (length < 0) continue; /* parse weights if given; make (more than enough) room in array */ if (strcmp(sample_name, "WEIGHTS")==0) { double wgt; char *wgt_str = sample_de; Resize(seq_weights, n_wgts+strlen(wgt_str), double); while (sscanf(wgt_str, "%lf", &wgt) == 1) { if (wgt <= 0 || wgt > 1) { fprintf(stderr, "Weights must be larger than zero and no greater than 1.\n"); exit(1); } seq_weights[n_wgts++] = wgt; /* save weight */ wgt_str += strspn(wgt_str, " "); /* skip white */ wgt_str += strcspn(wgt_str, " "); /* skip token */ } myfree(sample_name); myfree(sample_de); myfree(sequence); continue; } /* ignore duplicate (same sample name) sequences */ if (hash_lookup(sample_name, 0, ht_seq_names)) { fprintf(stderr, "Skipping %s\n", sample_name); myfree(sample_name); myfree(sample_de); myfree(sequence); continue; } hash_insert(sample_name, 0, ht_seq_names); /* put name in hash table */ n_samples++; /* see if sequence will be used in random sample; store it if yes */ if (drand48() >= 1 - seqfrac) { /* create the sample */ sample = create_sample(alpha, length, sample_name, sequence); if (sample == NULL) {error = TRUE; continue;} /* record maximum length of actual sequences */ dataset->max_slength = MAX(sample->length, dataset->max_slength); dataset->min_slength = MIN(sample->length, dataset->min_slength); /* put the sample in the array of samples */ if ((dataset->n_samples % RCHUNK) == 0) { Resize(dataset->samples, dataset->n_samples + RCHUNK, SAMPLE *); }
ConfigurationSet *Sampler::get_sample() const { IMPKERNEL_DEPRECATED_METHOD_DEF(2.1, "Use create_sample instead"); return create_sample(); }
int main() { int audio, working_format, bitcap,stereocap,ratecap; int ofs = 0; int len; int interval; SAMPLE *sample; int foo; int size = 1024*1024; unsigned char *buf; init(); show_mouse(screen); bitcap = get_sound_input_cap_bits(); if (bitcap == 0) allegro_message("No Audio input capabilty?"); stereocap = get_sound_input_cap_stereo(); if (stereocap == 0) allegro_message("No Sterecordingreo "); ratecap = get_sound_input_cap_rate(bitcap, 0); working_format = get_sound_input_cap_parm(ratecap, bitcap, 0); if (working_format == 0) allegro_message("We Are not a go!"); else if (working_format == 1) allegro_message("We Are a go but can't record and playback at the same time!"); else if (working_format == 2) allegro_message("We Are a go!"); BITMAP *catli=NULL,*catmo=NULL,*catmc=NULL; catli=load_bitmap("listen.bmp",NULL); catmo=load_bitmap("mo.bmp",NULL); catmc=load_bitmap("mc.bmp",NULL); sample = create_sample(bitcap, 0, ratecap, size); buf=(unsigned char*)(sample->data); allegro_message("Start Recording"); len = start_sound_input(ratecap, 16, 0); masked_blit(catli,screen,0,0,200,50,500,500); interval = 1000 / ((len / 2) / ratecap); interval *= 9; interval /= 10; while (!keypressed() && ofs < size) { foo = read_sound_input(buf); if (foo > 0) { ofs += len; buf += len; } rest(interval); } if (keypressed()) { foo = read_sound_input(buf); if (foo > 0) { ofs += len; buf += len; } } stop_sound_input(); BITMAP *bit=NULL,*bit2=NULL; bit=load_bitmap("play.bmp",NULL); masked_blit(bit,screen,0,0,100,100,400,400); bit2=load_bitmap("pause.bmp",NULL); masked_blit(bit2,screen,0,0,100,200,400,400); audio= allocate_voice(sample); int u=0; while (!key[KEY_ESC]) { if((mouse_x>=100 && mouse_x<=200)&&(mouse_y>=100 && mouse_y<=200)&& mouse_b&0x1) { play_sample(sample,255,128,1400,0); //voice_start(audio); while(!((mouse_x>=100 && mouse_x<=200)&&(mouse_y>=200 && mouse_y<=300)&& mouse_b&0x1u<=10)&& u<size) { masked_blit(catmo,screen,0,0,200,100,500,500); rest(300); masked_blit(catmc,screen,0,0,200,100,500,500); rest(300); u++; } } if((mouse_x>=100 && mouse_x<=200)&&(mouse_y>=200 && mouse_y<=300)&& mouse_b&0x1) { voice_stop(audio); masked_blit(catmc,screen,0,0,200,100,500,500);} /* put your code here */ } deinit(); return 0; }
int _apeg_audio_reset_parameters(APEG_LAYER *layer) { int buffer_padding; _apeg_audio_close(layer); if(layer->stream.audio.freq <= 0) { snprintf(apeg_error, sizeof(apeg_error), "Illegal audio frequency (%dhz)", layer->stream.audio.freq); return APEG_ERROR; } if(layer->stream.audio.channels <= 0) { snprintf(apeg_error, sizeof(apeg_error), "Illegal channel count (%d)", layer->stream.audio.channels); return APEG_ERROR; } buffer_padding = 0; #ifndef DISABLE_MPEG_AUDIO if(layer->stream.audio.layer == 3) buffer_padding = (128>>layer->stream.audio.down_sample) * SSLIMIT * layer->stream.audio.channels; if(layer->stream.audio.layer == 2) buffer_padding = (128>>layer->stream.audio.down_sample) * 3 * layer->stream.audio.channels; if(layer->stream.audio.layer == 1) buffer_padding = (128>>layer->stream.audio.down_sample) * SCALE_BLOCK * layer->stream.audio.channels; #endif if(layer->audio.callback_init) { int channels = layer->stream.audio.channels; int freq = layer->stream.audio.freq; int ret; ret = layer->audio.callback_init((APEG_STREAM*)layer, &channels, &freq, layer->audio.callback_arg); if(ret < 0) { snprintf(apeg_error, sizeof(apeg_error), "Audio callback init failed (code: %d)", ret); return APEG_ERROR; } if(channels > layer->stream.audio.channels || channels <= 0 || freq <= 0) { snprintf(apeg_error, sizeof(apeg_error), "Illegal audio mode requested (%dhz %d channels)", freq, channels); return APEG_ERROR; } if(ret > 0) layer->audio.bufsize = (ret+255)&(~255); free(layer->audio.pcm.samples); layer->audio.pcm.samples = malloc(layer->audio.bufsize+buffer_padding); if(!layer->audio.pcm.samples) { snprintf(apeg_error, sizeof(apeg_error), "Error allocating %d bytes for audio buffer", layer->audio.bufsize+buffer_padding); return APEG_ERROR; } if(channels == 1 && layer->stream.audio.channels > 1) layer->stream.audio.down_channel = TRUE; layer->stream.audio.channels = channels; layer->stream.audio.freq = freq; layer->audio.samples_per_update = layer->audio.bufsize / 2 / layer->stream.audio.channels; layer->audio.last_pos = -1; layer->audio.pos = -layer->audio.samples_per_update*2; return APEG_OK; } free(layer->audio.pcm.samples); layer->audio.pcm.samples = malloc(layer->audio.bufsize+buffer_padding); if(!layer->audio.pcm.samples) { snprintf(apeg_error, sizeof(apeg_error), "Error allocating %d bytes for audio buffer", layer->audio.bufsize+buffer_padding); return APEG_ERROR; } if(layer->stream.audio.channels > 2) layer->stream.audio.channels = 2; layer->audio.samples_per_update = layer->audio.bufsize / 2 / layer->stream.audio.channels; /* Start the audio stream */ layer->audio.stream = create_sample(16, layer->stream.audio.channels != 1, layer->stream.audio.freq, layer->audio.samples_per_update*2); if(layer->audio.stream) { int i; for(i = 0;i < layer->audio.bufsize;++i) ((short*)layer->audio.stream->data)[i] = 0x8000; } else { snprintf(apeg_error, sizeof(apeg_error), "Error starting stream playback"); return APEG_ERROR; } layer->audio.voice = play_sample(layer->audio.stream, 255, 127, 1000, TRUE); voice_set_priority(layer->audio.voice, 255); layer->audio.last_pos = -1; layer->audio.pos = -layer->audio.samples_per_update*2; _apeg_audio_set_speed_multiple(layer, layer->multiple); return APEG_OK; }
int eof_add_silence_recode(char * oggfn, unsigned long ms) { char sys_command[1024] = {0}; char backupfn[1024] = {0}; char wavfn[1024] = {0}; char soggfn[1024] = {0}; ALOGG_OGG *oggfile = NULL; SAMPLE *decoded = NULL, *combined = NULL; int bits; int stereo; int freq; unsigned long samples; int channels; unsigned long ctr,index; void * oggbuffer = NULL; int bitrate; eof_log("eof_add_silence_recode() entered", 1); if(!oggfn || (ms == 0) || eof_silence_loaded) { return 41; //Return failure: Invalid parameters } set_window_title("Adjusting Silence..."); /* back up original file */ (void) snprintf(backupfn, sizeof(backupfn) - 1, "%s.backup", oggfn); if(!exists(backupfn)) { (void) eof_copy_file(oggfn, backupfn); } /* Decode the OGG file into memory */ //Load OGG file into memory oggbuffer = eof_buffer_file(oggfn, 0); //Decode the OGG from buffer instead of from file because the latter cannot support special characters in the file path due to limitations with fopen() if(!oggbuffer) { (void) snprintf(eof_log_string, sizeof(eof_log_string) - 1, "\tError reading OGG: \"%s\"", strerror(errno)); //Get the Operating System's reason for the failure eof_log(eof_log_string, 1); return 42; //Return failure: Could not buffer chart audio into memory } oggfile=alogg_create_ogg_from_buffer(oggbuffer, (int)file_size_ex(oggfn)); if(oggfile == NULL) { eof_log("ALOGG failed to open input audio file", 1); free(oggbuffer); return 43; //Return failure: Could not process buffered chart audio } //Decode OGG into memory decoded=alogg_create_sample_from_ogg(oggfile); if(decoded == NULL) { alogg_destroy_ogg(oggfile); free(oggbuffer); return 44; //Return failure: Could not decode chart audio to memory } /* Create a SAMPLE array large enough for the leading silence and the decoded OGG */ bits = alogg_get_wave_bits_ogg(oggfile); stereo = alogg_get_wave_is_stereo_ogg(oggfile); freq = alogg_get_wave_freq_ogg(oggfile); alogg_destroy_ogg(oggfile); //This is no longer needed oggfile = NULL; samples = msec_to_samples(ms); channels = stereo ? 2 : 1; combined = create_sample(bits,stereo,freq,samples+decoded->len); //Create a sample array long enough for the silence and the OGG file if(combined == NULL) { destroy_sample(decoded); return 45; //Return failure: Could not create a sample array for the combined audio } /* Add the PCM data for the silence */ if(bits == 8) { //Create 8 bit PCM data for(ctr=0,index=0;ctr < samples * channels;ctr++) { ((unsigned char *)(combined->data))[index++] = 0x80; } } else { //Create 16 bit PCM data for(ctr=0,index=0;ctr < samples * channels;ctr++) { ((unsigned short *)(combined->data))[index++] = 0x8000; } } /* Add the decoded OGG PCM data*/ if(bits == 8) { //Copy 8 bit PCM data for(ctr=0;ctr < decoded->len * channels;ctr++) { ((unsigned char *)(combined->data))[index++] = ((unsigned char *)(decoded->data))[ctr]; } } else { //Copy 16 bit PCM data for(ctr=0;ctr < decoded->len * channels;ctr++) { ((unsigned short *)(combined->data))[index++] = ((unsigned short *)(decoded->data))[ctr]; } } /* encode the audio */ destroy_sample(decoded); //This is no longer needed free(oggbuffer); (void) replace_filename(wavfn, eof_song_path, "encode.wav", 1024); (void) save_wav(wavfn, combined); destroy_sample(combined); //This is no longer needed (void) replace_filename(soggfn, eof_song_path, "encode.ogg", 1024); bitrate = alogg_get_bitrate_ogg(eof_music_track) / 1000; if(!bitrate) { //A user found that in an audio file with a really high sample rate (ie. 96KHz), alogg_get_bitrate_ogg() may return zero instead of an expected value bitrate = 256; //In case this happens, use a bitrate of 256Kbps, which should be good enough for a very high quality file } #ifdef ALLEGRO_WINDOWS (void) uszprintf(sys_command, (int) sizeof(sys_command) - 1, "oggenc2 -o \"%s\" -b %d \"%s\"", soggfn, bitrate, wavfn); #else (void) uszprintf(sys_command, (int) sizeof(sys_command) - 1, "oggenc -o \"%s\" -b %d \"%s\"", soggfn, bitrate, wavfn); #endif (void) snprintf(eof_log_string, sizeof(eof_log_string) - 1, "\tCalling oggenc as follows: %s", sys_command); eof_log(eof_log_string, 1); if(eof_system(sys_command)) { //If oggenc failed, retry again by specifying a quality level (specifying bitrate can fail in some circumstances) eof_log("\t\toggenc failed. Retrying by specifying a quality level instead of a target bitrate", 1); #ifdef ALLEGRO_WINDOWS (void) uszprintf(sys_command, (int) sizeof(sys_command) - 1, "oggenc2 -o \"%s\" -q 9 \"%s\"", soggfn, wavfn); #else (void) uszprintf(sys_command, (int) sizeof(sys_command) - 1, "oggenc -o \"%s\" -q 9 \"%s\"", soggfn, wavfn); #endif (void) snprintf(eof_log_string, sizeof(eof_log_string) - 1, "\tCalling oggenc as follows: %s", sys_command); eof_log(eof_log_string, 1); if(eof_system(sys_command)) { //If oggenc failed again char tempfname[30] = {0}; char redirect[35] = {0}; if(eof_validate_temp_folder()) { //Ensure the correct working directory and presence of the temporary folder eof_log("\tCould not validate working directory and temp folder", 1); return 46; //Return failure: Could not validate cwd and temp folder } (void) snprintf(tempfname, sizeof(tempfname) - 1, "%soggenc.log", eof_temp_path_s); (void) snprintf(redirect, sizeof(redirect) - 1, " 2> %s", tempfname); (void) ustrzcat(sys_command, (int) sizeof(sys_command) - 1, redirect); //Append a redirection to the command to capture the output of oggenc if(eof_system(sys_command)) { //Run one last time to catch the error output (void) snprintf(eof_log_string, sizeof(eof_log_string) - 1, "\tOggenc failed. Please see %s for any errors it gave.", tempfname); eof_log(eof_log_string, 1); eof_fix_window_title(); return 47; //Return failure: Could not encode combined audio } } } /* replace the current OGG file with the new file */ (void) eof_copy_file(soggfn, oggfn); //Copy encode.ogg to the filename of the original OGG /* clean up */ (void) delete_file(soggfn); //Delete encode.ogg (void) delete_file(wavfn); //Delete encode.wav if(eof_load_ogg(oggfn, 0)) { //If the combined audio was loaded eof_fix_waveform_graph(); eof_fix_spectrogram(); eof_fix_window_title(); eof_chart_length = eof_music_length; return 0; //Return success } eof_fix_window_title(); return 48; //Return error: Could not load new audio }
/* ------------------------------------- * LBFGS * IN * func: Function to be minimized. * nRow: Number of rows (length) of x. * N_max: Maximum number of CG iterates. * TOL: Minimum size for gradient of f. * OUT * x: Local minimum of func. * ------------------------------------- */ double * SLM_LBFGS(double (* func)(double*, int), int nRow, int m, double TOL, int N_max, int verbose){ // Variable declaration. double **s, **y; double *x, *grad, *p, *x_new, *grad_new; double alpha, norm_grad0; int i, k, MAX_ITER, exploredDataPoints; // Space allocation. x = (double *)malloc(nRow * sizeof(double)); s = (double **)malloc((nRow*m) * sizeof(double)); y = (double **)malloc((nRow*m) * sizeof(double)); // Initialize x. for(i = 0; i < nRow; i++){ x[i] = ((double) rand() / INT_MAX) ; } // Stochastic Mode if(stocMode){ exploredDataPoints = 0; //printf("\nRUNNING STOCASTIC MODE\n"); SAMPLE = rand() % (int)(MAX_FILE_ROWS * sampProp); create_sample(0); exploredDataPoints += SAMPLE; } // Until Convergence or MAX_ITER. MAX_ITER = 6e6; grad = gradCentralDiff(func, x, nRow); // Update s, y. k = 0; // Initial norm of gradient. norm_grad0 = norm(grad, nRow); while(norm(grad, nRow) > TOL*(1 + norm_grad0) && ((run_logistic*exploredDataPoints + ((1 - run_logistic)*k)) < MAX_ITER)){ if(stocMode){ printf("\nRUNNING STOCASTIC MODE\n"); SAMPLE = rand() % (int)(MAX_FILE_ROWS * sampProp); create_sample(k); exploredDataPoints += SAMPLE; } // p = -Hgrad(f) if(k > 0){ p = vProd(findHSLM(func, x, s, y, nRow, m, k, N_max), -1, nRow); }else{ p = vProd(grad, -1, nRow); } // Alpha that statifies Wolfe conditions. alpha = backTrack(func, x, p, nRow, verbose); x_new = vSum(x, vProd(p, alpha, nRow), nRow); //imprimeTit("X_NEW"); //imprimeMatriz(x_new, 1, nRow); grad_new = gradCentralDiff(func, x_new, nRow); //imprimeTit("GRAD_NEW"); //imprimeMatriz(grad_new, 1, nRow); // Update s, y. updateSY(s, y, vProd(p, alpha, nRow), vSum(grad_new, vProd(grad, -1, nRow), nRow), m, k); // ---------------- PRINT ------------------- // if(verbose){ if(stocMode){ printf("\n ITER = %d; f(x) = %.10e ; " "||x|| = %.10e ; ||grad|| = %.10e ; " "||p|| = %.10e ; sTy = %.10e ; " "alpha = %.10e; explored data points = %d; precision = %fl ", k, func(x, nRow), norm(x, nRow), norm(grad, nRow), norm(p, nRow), dotProd(s[(int)min(k , (m - 1))], y[(int)min(k , (m - 1))], nRow), alpha, exploredDataPoints, class_precision(x, nRow, 0)); }else{ printf("\n ITER = %d; f(x) = %.10e ; " "||x|| = %.10e ; ||grad|| = %.10e ; " "||p|| = %.10e ; sTy = %.10e ; " "alpha = %.10e", k, func(x, nRow), norm(x, nRow), norm(grad, nRow), norm(p, nRow), dotProd(s[(int)min(k , (m - 1))], y[(int)min(k , (m - 1))], nRow), alpha); } } // ---------------- PRINT ------------------- //y // Update k, x, grad. x = x_new; grad = grad_new; k = k + 1; } free(grad); free(s); free(y); return x; }
int eof_add_silence_recode_mp3(char * oggfn, unsigned long ms) { char sys_command[1024] = {0}; char backupfn[1024] = {0}; char wavfn[1024] = {0}; char soggfn[1024] = {0}; char mp3fn[1024] = {0}; SAMPLE * decoded = NULL; SAMPLE * combined = NULL; int bits; int stereo; int freq; unsigned long samples; int channels; unsigned long ctr,index; eof_log("eof_add_silence_recode_mp3() entered", 1); if(!oggfn || (ms == 0) || eof_silence_loaded) { return 21; //Return error: Invalid parameters } set_window_title("Adjusting Silence..."); /* back up original file */ (void) snprintf(backupfn, sizeof(backupfn) - 1, "%s.backup", oggfn); if(!exists(backupfn)) { (void) eof_copy_file(oggfn, backupfn); } /* decode MP3 */ (void) replace_filename(wavfn, eof_song_path, "decode.wav", 1024); (void) replace_filename(mp3fn, eof_song_path, "original.mp3", 1024); (void) uszprintf(sys_command, (int) sizeof(sys_command) - 1, "lame --decode \"%s\" \"%s\"", mp3fn, wavfn); (void) eof_system(sys_command); /* insert silence */ decoded = load_sample(wavfn); if(!decoded) { allegro_message("Error opening file.\nMake sure there are no Unicode or extended ASCII characters in this chart's file path."); return 22; //Return failure: Could not load decoded MP3 file } bits = decoded->bits; stereo = decoded->stereo; freq = decoded->freq; samples = (decoded->freq * ms) / 1000; //Calculate this manually instead of using msec_to_samples() because that function assumes the sample rate matches the current chart audio, and this may not be the case with the original MP3 file the user provided channels = stereo ? 2 : 1; combined = create_sample(bits,stereo,freq,samples+decoded->len); //Create a sample array long enough for the silence and the OGG file if(combined == NULL) { destroy_sample(decoded); return 23; //Return failure: Could not create a sample array for the combined audio } /* Add the PCM data for the silence */ if(bits == 8) { //Create 8 bit PCM data for(ctr=0,index=0;ctr < samples * channels;ctr++) { ((unsigned char *)(combined->data))[index++] = 0x80; } } else { //Create 16 bit PCM data for(ctr=0,index=0;ctr < samples * channels;ctr++) { ((unsigned short *)(combined->data))[index++] = 0x8000; } } /* Add the decoded OGG PCM data*/ if(bits == 8) { //Copy 8 bit PCM data for(ctr=0;ctr < decoded->len * channels;ctr++) { ((unsigned char *)(combined->data))[index++] = ((unsigned char *)(decoded->data))[ctr]; } } else { //Copy 16 bit PCM data for(ctr=0;ctr < decoded->len * channels;ctr++) { ((unsigned short *)(combined->data))[index++] = ((unsigned short *)(decoded->data))[ctr]; } } /* save combined WAV */ (void) replace_filename(wavfn, eof_song_path, "encode.wav", 1024); if(!save_wav(wavfn, combined)) { destroy_sample(decoded); //This is no longer needed destroy_sample(combined); //This is no longer needed return 24; //Return failure: Could not create the combined audio WAV file } /* destroy samples */ destroy_sample(decoded); //This is no longer needed destroy_sample(combined); //This is no longer needed /* encode the audio */ printf("%s\n%s\n", eof_song_path, wavfn); (void) replace_filename(soggfn, eof_song_path, "encode.ogg", 1024); #ifdef ALLEGRO_WINDOWS (void) uszprintf(sys_command, (int) sizeof(sys_command) - 1, "oggenc2 -o \"%s\" -b %d \"%s\"", soggfn, alogg_get_bitrate_ogg(eof_music_track) / 1000, wavfn); #else (void) uszprintf(sys_command, (int) sizeof(sys_command) - 1, "oggenc -o \"%s\" -b %d \"%s\"", soggfn, alogg_get_bitrate_ogg(eof_music_track) / 1000, wavfn); #endif (void) snprintf(eof_log_string, sizeof(eof_log_string) - 1, "\tCalling oggenc as follows: %s", sys_command); eof_log(eof_log_string, 1); if(eof_system(sys_command)) { //If oggenc failed, retry again by specifying a quality level (specifying bitrate can fail in some circumstances) eof_log("\t\toggenc failed. Retrying by specifying a quality level instead of a target bitrate", 1); #ifdef ALLEGRO_WINDOWS (void) uszprintf(sys_command, (int) sizeof(sys_command) - 1, "oggenc2 -o \"%s\" -q 9 \"%s\"", soggfn, wavfn); #else (void) uszprintf(sys_command, (int) sizeof(sys_command) - 1, "oggenc -o \"%s\" -q 9 \"%s\"", soggfn, wavfn); #endif (void) snprintf(eof_log_string, sizeof(eof_log_string) - 1, "\tCalling oggenc as follows: %s", sys_command); eof_log(eof_log_string, 1); if(eof_system(sys_command)) { //If oggenc failed again char tempfname[30] = {0}; char redirect[35] = {0}; if(eof_validate_temp_folder()) { //Ensure the correct working directory and presence of the temporary folder eof_log("\tCould not validate working directory and temp folder", 1); return 25; //Return failure: Could not validate cwd and temp folder } (void) snprintf(tempfname, sizeof(tempfname) - 1, "%soggenc.log", eof_temp_path_s); (void) snprintf(redirect, sizeof(redirect) - 1, " 2> %s", tempfname); (void) ustrzcat(sys_command, (int) sizeof(sys_command) - 1, redirect); //Append a redirection to the command to capture the output of oggenc if(eof_system(sys_command)) { //Run one last time to catch the error output (void) snprintf(eof_log_string, sizeof(eof_log_string) - 1, "\tOggenc failed. Please see %s for any errors it gave.", tempfname); eof_log(eof_log_string, 1); eof_fix_window_title(); return 26; //Return failure: Could not encode combined audio } } } /* replace the current OGG file with the new file */ (void) eof_copy_file(soggfn, oggfn); //Copy encode.ogg to the filename of the original OGG /* clean up */ (void) replace_filename(wavfn, eof_song_path, "decode.wav", 1024); (void) delete_file(wavfn); //Delete decode.wav (void) replace_filename(wavfn, eof_song_path, "encode.wav", 1024); (void) delete_file(wavfn); //Delete encode.wav (void) delete_file(soggfn); //Delete encode.ogg if(eof_load_ogg(oggfn, 0)) { //If the combined audio was loaded eof_fix_waveform_graph(); eof_fix_spectrogram(); eof_fix_window_title(); eof_chart_length = eof_music_length; return 0; //Return success } eof_fix_window_title(); return 27; //Return error: Could not load new audio }
void saPlayBufferedStreamedSampleBase( int channel, signed char *data, int len, int freq, int volume, int bits , int pan ){ /* This version works at low level, creating a sample, and following its advancement directly in the voice_position... */ int i; short *dout; short *dfin; signed short *din; //fprintf(stderr,"saPlayBuffer %d freq %d bits %d pan %d len %d\n",channel,freq,bits,pan,len); if( audio_sample_rate == 0 || channel >= NUMVOICES ) return; if( SndMachine == NULL ) return; if( !playing[channel] ){ #ifdef USE_COMPENS int fin = stream_buffer_max * freq * 2 / fps; #else int fin = stream_buffer_max * len; #endif if( lpWave[channel] ){ destroy_sample( lpWave[channel] ); lpWave[channel] = 0; } if (!(lpWave[channel] = create_sample(16,0,freq,fin/2))){ lpWave[channel] = 0; return; } // memset( lpWave[channel]->data, 0, fin ); dout=lpWave[channel]->data; dfin=(short*) (((char*)lpWave[channel]->data)+fin); // Fill the buffer with 0 (signed) in case the soundcards reads what // is after the sample... while (dout < dfin) *(dout++) = 0x8000; vend[channel] = dfin; counter[channel] = 0; hVoice[channel] = allocate_voice( lpWave[channel] ); if (hVoice[channel]<0) { allegro_message("allocate_voice failed !\n"); exit(1); } voice_set_playmode(hVoice[channel],PLAYMODE_LOOP); playing[channel] = 1; /* use front surface */ init_mixing_buff(len); /**** make sound temp. buffer ****/ if (enh_stereo && SamplePan[channel] == PAN_LEFT) dout=(short*) (((char*)lpWave[channel]->data)+len*(MODEB_UPDATE_COUNT+1)); //+len*MODEB_UPDATE_COUNT); else dout=(short*) (((char*)lpWave[channel]->data)+len*MODEB_UPDATE_COUNT); //+len*MODEB_UPDATE_COUNT); din = ((signed short*)data); // memcpy( dout, din, len ); for (i=0; i<len; i+=2){ *(dout++) = *(din++)^0x8000; } update_recording(channel,data); if (dout ==dfin){ dout=(short*) (((char*)lpWave[channel]->data)); } #ifdef DUMP_CHANNELS fwrite( lpWave[channel]->data+len*MODEB_UPDATE_COUNT, 1, len, stream_out[channel]); #endif vout[channel] = dout; saSetVolume(channel,SampleVol[channel]); saSetPan(channel,SamplePan[channel]); voice_set_position(hVoice[channel],0); voice_start(hVoice[channel]); pos_counter[channel] = 0; } else{ int pos = voice_get_position(hVoice[channel]); int th_pos; int count = (enh_stereo && SamplePan[channel] == PAN_LEFT ? MODEB_UPDATE_COUNT + 1 : MODEB_UPDATE_COUNT); // this difference between the theorical position and the actual // position is because clearly the reported position is directly // dependant of when the sound driver updated the voice for the // last time. Luckily the difference is big only when the voice // starts. After starting it gets more or less updated when it // should, depending on external factors too like the cpu load. dout=vout[channel]; th_pos = (dout - ((INT16 *)lpWave[channel]->data)- count*len/2); if (th_pos < 0) th_pos += stream_buffer_max * len/2; // if there is more than count frames between pos and th_pos, then // wait for the voice. if (pos < th_pos) { if (th_pos - pos < count * len/2) { more_stream = -1; // drop next frame } } din = ((signed short*)data); dfin = vend[channel]; // memcpy(dout,din,len); for (i=0; i<len; i+=2){ *(dout++) = *(din++)^0x8000; } update_recording(channel,data); if (dout >=dfin){ dout=(short*) (((char*)lpWave[channel]->data)); } #ifdef DUMP_CHANNELS fwrite( lpWave[channel]->data+len*s_pos, 1, len, stream_out[channel]); #endif vout[channel] = dout; // more than count frames of advance : more stream ! pos -= count*len/2; if (pos > th_pos && pos > 0) { // send more more_stream = 1; } } }
// return: 0: okay; 1: needs more sample; 2: needs reconfiguring; 3: more data available int receive_sample(IMFTransform *transform, DWORD out_stream_id, IMFSample** out_sample) { HRESULT hr; MFT_OUTPUT_DATA_BUFFER out_buffers; IMFSample *sample = NULL; MFT_OUTPUT_STREAM_INFO out_info; DWORD status = 0; bool mft_create_sample = false; if (!out_sample) { ReportError(L"NULL pointer passed to receive_sample()", MF_E_SAMPLE_NOT_WRITABLE); return -1; } SafeRelease(out_sample); hr = transform->GetOutputStreamInfo(out_stream_id, &out_info); if (FAILED(hr)) { ReportError(L"MFT: Failed to get stream info", hr); return -1; } mft_create_sample = (out_info.dwFlags & MFT_OUTPUT_STREAM_PROVIDES_SAMPLES) || (out_info.dwFlags & MFT_OUTPUT_STREAM_CAN_PROVIDE_SAMPLES); while (true) { sample = NULL; *out_sample = NULL; status = 0; if (!mft_create_sample) { sample = create_sample(NULL, out_info.cbSize, out_info.cbAlignment); if (!sample) { ReportError(L"MFT: Unable to allocate memory for samples", hr); return -1; } } out_buffers.dwStreamID = out_stream_id; out_buffers.pSample = sample; hr = transform->ProcessOutput(0, 1, &out_buffers, &status); if (!FAILED(hr)) { *out_sample = out_buffers.pSample; break; } if (hr == MF_E_TRANSFORM_NEED_MORE_INPUT) { // TODO: better handling try again and EOF cases using drain value return 1; } if (hr == MF_E_TRANSFORM_STREAM_CHANGE) { ReportError(L"MFT: stream format changed, re-configuration required", hr); return 2; } break; } if (out_buffers.dwStatus & MFT_OUTPUT_DATA_BUFFER_INCOMPLETE) { return 3; } // TODO: better handling try again and EOF cases using drain value if (*out_sample == NULL) { ReportError(L"MFT: decoding failure", hr); return -1; } return 0; }