irqreturn_t px_timer_isr(unsigned int pid, unsigned int tid, unsigned int pc, unsigned long long ts) { bool buffer_full = false; PXD32_Hotspot_Sample_V2 sample_rec; if (tbs_running) { /* write sample record to sample buffer */ sample_rec.pc = pc; sample_rec.pid = pid; sample_rec.tid = tid; sample_rec.registerId = COUNTER_PJ1_OS_TIMER; memcpy(sample_rec.timestamp, &ts, sizeof(sample_rec.timestamp)); buffer_full = write_sample(0, &sample_rec); if (buffer_full) { tbs_running = false; } else { tbs_running = true; } } return 0; }
static irqreturn_t px_timer_isr(unsigned int pid, unsigned int tid, struct pt_regs * const regs, unsigned int cpu, unsigned long long ts) { bool buffer_full = false; if (tbs_running) { PXD32_Hotspot_Sample_V2 sample_rec; /* write sample record to sample buffer */ sample_rec.pc = regs->ARM_pc; sample_rec.pid = pid; sample_rec.tid = tid; sample_rec.registerId = COUNTER_PJ4B_OS_TIMER; memcpy(sample_rec.timestamp, &ts, sizeof(sample_rec.timestamp)); buffer_full = write_sample(cpu, &sample_rec); if (buffer_full) { tbs_running = false; } else { tbs_running = true; } } return IRQ_HANDLED; }
static void write_callback(struct SoundIoOutStream *outstream, int frame_count_min, int frame_count_max) { UNUSED(frame_count_min); double float_sample_rate = outstream->sample_rate; double seconds_per_frame = 1.0 / float_sample_rate; struct SoundIoChannelArea *areas; int err; int frames_left = frame_count_max; for (;;) { int frame_count = frames_left; if ((err = soundio_outstream_begin_write(outstream, &areas, &frame_count))) { fprintf(stderr, "unrecoverable stream error: %s\n", soundio_strerror(err)); exit(1); } if (!frame_count) break; const struct SoundIoChannelLayout *layout = &outstream->layout; double pitch = 440.0; double radians_per_second = pitch * 2.0 * PI; for (int frame = 0; frame < frame_count; frame += 1) { double sample = (float) sin((seconds_offset + frame * seconds_per_frame) * radians_per_second); for (int channel = 0; channel < layout->channel_count; channel += 1) { write_sample(areas[channel].ptr, sample); areas[channel].ptr += areas[channel].step; } } seconds_offset += seconds_per_frame * frame_count; if ((err = soundio_outstream_end_write(outstream))) { if (err == SoundIoErrorUnderflow) return; fprintf(stderr, "unrecoverable stream error: %s\n", soundio_strerror(err)); exit(1); } frames_left -= frame_count; if (frames_left <= 0) break; } soundio_outstream_pause(outstream, want_pause); }
void do_work(int *samples) { int i; // A busy loop. (In a real system this would do something // more interesting such as an FFT or a particle filter, // etc...) volatile int dummy; // A compiler warning is ok here for(i=0; i < 20000000;i++){ dummy=i; } // Write out the samples. for(i=0; i < PROCESSING_INTERVAL; i++){ write_sample(0,samples[i]); } }
irqreturn_t px_timer_isr(unsigned int pid, unsigned int tid, unsigned int pc, unsigned long long ts) { bool buffer_full = false; PXD32_Hotspot_Sample_V2 sample_rec; // disable the interrupt TMR_IERn(timer_group, timer_no) = 0; // clear the interrupt flag TMR_ICRn(timer_group, timer_no) = 1; // set next match TMR_Tn_Mm(timer_group, timer_no, 0) = g_tbs_settings.interval * get_timer_freq() / 1000; //TMR_Tn_Mm(timer_group, timer_no, 0) += g_tbs_settings.interval * get_timer_freq() / 1000; if (tbs_running) { /* write sample record to sample buffer */ sample_rec.pc = pc; sample_rec.pid = pid; sample_rec.tid = tid; sample_rec.registerId = COUNTER_PJ1_OS_TIMER; memcpy(sample_rec.timestamp, &ts, sizeof(sample_rec.timestamp)); buffer_full = write_sample(0, &sample_rec); if (buffer_full) { tbs_running = false; } else { tbs_running = true; } } // enable the interrupt TMR_IERn(timer_group, timer_no) = 1; return IRQ_HANDLED; }
static irqreturn_t px_timer_isr(unsigned int pid, unsigned int tid, unsigned int pc, unsigned int ts) { bool buffer_full = false; if (OSSR & OSSR_PX_INTERRUPT) { PXD32_Hotspot_Sample sample_rec; /* disable the counter */ OMCR5 &= ~0x7; /* clear the interrupt flag */ OSSR = OSSR_PX_INTERRUPT; /* write sample record to sample buffer */ sample_rec.pc = pc; sample_rec.pid = pid; sample_rec.tid = tid; sample_rec.registerId = COUNTER_PXA2_OS_TIMER; memcpy(sample_rec.timestamp, &ts, 3); buffer_full = write_sample(&sample_rec); if (buffer_full) { /* if sample buffer is full, pause sampling */ OMCR5 &= ~0x7; } else { /* enable the counter */ OMCR5 |= OMCR_FREQ_32K; } return IRQ_HANDLED; } return IRQ_NONE; }
static int encode(aacenc_param_ex_t *params, pcm_reader_t *reader, HANDLE_AACENCODER encoder, uint32_t frame_length, m4af_ctx_t *m4af) { int16_t *ibuf = 0, *ip; aacenc_frame_t obuf[2] = {{ 0 }}, *obp; unsigned flip = 0; int nread = 1; int rc = -1; int remaining, consumed; int frames_written = 0, encoded = 0; aacenc_progress_t progress = { 0 }; const pcm_sample_description_t *fmt = pcm_get_format(reader); ibuf = malloc(frame_length * fmt->bytes_per_frame); aacenc_progress_init(&progress, pcm_get_length(reader), fmt->sample_rate); for (;;) { /* * Since we delay the write, we cannot just exit loop when interrupted. * Instead, we regard it as EOF. */ if (g_interrupted) nread = 0; if (nread > 0) { if ((nread = pcm_read_frames(reader, ibuf, frame_length)) < 0) { fprintf(stderr, "ERROR: read failed\n"); goto END; } if (!params->silent) aacenc_progress_update(&progress, pcm_get_position(reader), fmt->sample_rate * 2); } ip = ibuf; remaining = nread; do { obp = &obuf[flip]; consumed = aac_encode_frame(encoder, fmt, ip, remaining, obp); if (consumed < 0) goto END; if (consumed == 0 && obp->size == 0) goto DONE; if (obp->size == 0) break; remaining -= consumed; ip += consumed * fmt->channels_per_frame; flip ^= 1; /* * As we pad 1 frame at beginning and ending by our extrapolator, * we want to drop them. * We delay output by 1 frame by double buffering, and discard * second frame and final frame from the encoder. * Since sbr_header is included in the first frame (in case of * SBR), we cannot discard first frame. So we pick second instead. */ ++encoded; if (encoded == 1 || encoded == 3) continue; obp = &obuf[flip]; if (write_sample(params->output_fp, m4af, obp) < 0) goto END; ++frames_written; } while (remaining > 0); } DONE: if (!params->silent) aacenc_progress_finish(&progress, pcm_get_position(reader)); rc = frames_written; END: if (ibuf) free(ibuf); if (obuf[0].data) free(obuf[0].data); if (obuf[1].data) free(obuf[1].data); return rc; }
int main(int argc, char *argv[]) { if(argc <= 1) { printf("Usage: [options] wav2smp in1.wav in1_name in2.wav in2_name...\n\n"); printf("Flags:\n"); printf("\t-w\tWAV file to write to (default: out.wav)\n"); printf("\t-o\tINI file to write to (default: out.ini)\n"); printf("\t-r\tSet samplerate. (default: 96000)\n"); return 0; } int argpos = 1; int i; int sr = 96000; char wavfile[30] = "out.wav"; char inifile[30] = "out.ini"; float buf[4096]; argv++; while(argv[0][0] == '-') { switch(argv[0][1]) { case 'w': strncpy(wavfile, argv[1], 30); argv++; argpos++; break; case 'o': strncpy(inifile, argv[1], 30); argv++; argpos++; break; case 'r': sr = atoi(argv[1]); argv++; argpos++; break; default: fprintf(stderr, "Uknown option '%c'\n", argv[0][1]); break; } argv++; argpos++; } SF_INFO info; info.samplerate = sr; info.channels = 1; info.format = SF_FORMAT_WAV | SF_FORMAT_FLOAT; SNDFILE *snd = sf_open(wavfile, SFM_WRITE, &info); FILE *fp = fopen(inifile, "w"); uint32_t pos = 0; for(i = argpos; i < argc; ) { write_sample(snd, fp, argv[0], argv[1], buf, 4096, &pos, sr); argv += 2; i += 2; } fclose(fp); sf_close(snd); return 0; }
void write_log_file (char *filename) { scope_data_t *dptr, *start; scope_horiz_t *horiz; int sample_len, chan_num, sample_period_ns, samples, n; char *label[16]; //scope_disp_t *disp; scope_log_t *log; scope_chan_t *chan; hal_type_t type[16]; FILE *fp; fp = fopen(filename, "w"); if ( fp == NULL ) { fprintf(stderr, "ERROR: log file '%s' could not be created\n", filename ); return; } /* fill in local variables */ for (chan_num=0; chan_num<16; chan_num++) { chan = &(ctrl_usr->chan[chan_num]); label[chan_num] = chan->name; type[chan_num] = chan->data_type; } /* sample_len is really the number of channels, don't let it fool you */ sample_len = ctrl_shm->sample_len; //disp = &(ctrl_usr->disp); n=0; samples = ctrl_usr->samples*sample_len ; //fprintf(stderr, "maxsamples = %p \n", maxsamples); log = &(ctrl_usr->log); horiz = &(ctrl_usr->horiz); sample_period_ns = horiz->thread_period_ns * ctrl_shm->mult; //for testing, this will be a check box or something eventually log->order=INTERLACED; /* write data */ fprintf(fp, "Sampling period is %i nSec \n", sample_period_ns ); /* point to the first sample in the display buffer */ start = ctrl_usr->disp_buf ; switch (log->order) { case INTERLACED: while (n <= samples) { for (chan_num=0; chan_num<sample_len; chan_num++) { dptr=start+n; if ((n%sample_len)==0){ fprintf( fp, "\n"); } write_sample( fp, label[chan_num], dptr, type[chan_num]); /* point to next sample */ n++; } } break; case NOT_INTERLACED: for (chan_num=0; chan_num<sample_len; chan_num++) { n=chan_num; while (n <= samples) { dptr=start+n; write_sample( fp, label[chan_num], dptr, type[chan_num]); fprintf( fp, "\n"); /* point to next sample */ n += sample_len; } } break; } fclose(fp); fprintf(stderr, "Log file '%s' written.\n", filename ); }
/* Function to be called from R */ void R_epidemics(int *seqLength, double *mutRate, int *npop, int *nHostPerPop, double *beta, int *nStart, int *t1, int *t2, int *Nsample, int *Tsample, int *duration, int *nbnb, int *listnb, double *pdisp){ int i, nstep, counter_sample = 0, tabidx; /* Initialize random number generator */ int j; time_t t; t = time(NULL); // time in seconds, used to change the seed of the random generator gsl_rng * rng; const gsl_rng_type *typ; gsl_rng_env_setup(); typ=gsl_rng_default; rng=gsl_rng_alloc(typ); gsl_rng_set(rng,t); // changes the seed of the random generator /* transfer simulation parameters */ struct param * par; par = (struct param *) malloc(sizeof(struct param)); par->L = *seqLength; par->mu = *mutRate; par->muL = par->mu * par->L; par->rng = rng; par->npop = *npop; par->popsizes = nHostPerPop; par->beta = *beta; par->nstart = *nStart; par->t1 = *t1; par->t2 = *t2; par->t_sample = Tsample; par->n_sample = *Nsample; par->duration = *duration; par->cn_nb_nb = nbnb; par->cn_list_nb = listnb; par->cn_weights = pdisp; /* check/print parameters */ check_param(par); print_param(par); /* dispersal matrix */ struct network *cn = create_network(par); /* print_network(cn, TRUE); */ /* group sizes */ struct ts_groupsizes * grpsizes = create_ts_groupsizes(par); /* initiate population */ struct metapopulation * metapop; metapop = create_metapopulation(par); /* get sampling schemes (timestep+effectives) */ translate_dates(par); struct table_int *tabdates = get_table_int(par->t_sample, par->n_sample); printf("\n\nsampling at timesteps:"); print_table_int(tabdates); /* create sample */ struct sample ** samplist = (struct sample **) malloc(tabdates->n * sizeof(struct sample *)); struct sample *samp; /* MAKE METAPOPULATION EVOLVE */ nstep = 0; while(get_total_nsus(metapop)>0 && (get_total_ninf(metapop)+get_total_nexp(metapop))>0 && nstep<par->duration){ nstep++; /* age metapopulation */ age_metapopulation(metapop, par); /* process infections */ for(j=0;j<get_npop(metapop);j++){ process_infections(get_populations(metapop)[j], metapop, cn, par); } /* draw samples */ if((tabidx = int_in_vec(nstep, tabdates->items, tabdates->n)) > -1){ /* TRUE if step must be sampled */ samplist[counter_sample++] = draw_sample(metapop, tabdates->times[tabidx], par); } fill_ts_groupsizes(grpsizes, metapop, nstep); } /* we stopped after 'nstep' steps */ if(nstep < par->duration){ printf("\nEpidemics ended at time %d, before last sampling time (%d).\n", nstep, par->duration); } else { /* printf("\n\n-- FINAL METAPOPULATION --"); */ /* print_metapopulation(metapop, FALSE); */ /* merge samples */ samp = merge_samples(samplist, tabdates->n, par); /* write sample to file */ printf("\n\nWriting sample to file 'out-sample.txt'\n"); write_sample(samp); /* free memory */ free_sample(samp); } /* write group sizes to file */ printf("\n\nPrinting group sizes to file 'out-popsize.txt'\n"); write_ts_groupsizes(grpsizes); /* free memory */ free_metapopulation(metapop); free_param(par); for(i=0;i<counter_sample;i++) free_sample(samplist[i]); free(samplist); free_table_int(tabdates); free_network(cn); free_ts_groupsizes(grpsizes); }
static irqreturn_t px_pmu_isr(unsigned int pid, unsigned int tid, unsigned int pc, unsigned int timestamp) { u32 pmnc_value; u32 flag_value; unsigned int i; bool buffer_full = false; PXD32_Hotspot_Sample sample_rec; /* disable the counters */ pmnc_value = PJ4_Read_PMNC(); pmnc_value &= ~0x1; PJ4_Write_PMNC(pmnc_value); /* clear the overflow flag */ flag_value = PJ4_Read_FLAG(); PJ4_Write_FLAG(0x8000000f); sample_rec.pc = pc; sample_rec.pid = pid; sample_rec.tid = tid; memcpy(sample_rec.timestamp, ×tamp, 3); if ((flag_value & 0x80000000) && es[COUNTER_PJ4_PMU_CCNT].enabled) { sample_rec.registerId = COUNTER_PJ4_PMU_CCNT; /* ccnt overflow */ if (es[sample_rec.registerId].calibration == false) { /* write sample record in non-calibration mode */ buffer_full |= write_sample(&sample_rec); } else { /* calculate the overflow count in calibration mode */ es[sample_rec.registerId].overflow++; } PJ4_WritePMUCounter(sample_rec.registerId, es[sample_rec.registerId].reset_value); } for (i=0; i<4; i++) { if (flag_value & (0x1 << i)) { switch (i) { case 0: sample_rec.registerId = COUNTER_PJ4_PMU_PMN0; break; case 1: sample_rec.registerId = COUNTER_PJ4_PMU_PMN1; break; case 2: sample_rec.registerId = COUNTER_PJ4_PMU_PMN2; break; case 3: sample_rec.registerId = COUNTER_PJ4_PMU_PMN3; break; default: break; } if (es[sample_rec.registerId].calibration == false) { /* write sample record in non-calibration mode */ buffer_full |= write_sample(&sample_rec); } else { /* calculate the overflow count in calibration mode */ es[sample_rec.registerId].overflow++; } PJ4_WritePMUCounter(sample_rec.registerId, es[sample_rec.registerId].reset_value); } } if (!buffer_full) { /* enable the counters */ pmnc_value |= 0x1; PJ4_Write_PMNC(pmnc_value); } return IRQ_HANDLED; }
static irqreturn_t px_pmu_isr(unsigned int pid, unsigned int tid, unsigned int pc, unsigned int timestamp) { int i; int reg = 0; unsigned long flag_value; unsigned long pmnc_value; PXD32_Hotspot_Sample sample_rec; bool buffer_full = false; /* disable the timer interrupt */ //disable_irq(PX_IRQ_PXA2_TIMER); /* disable the counters */ pmnc_value = ReadPMUReg(PXA2_PMU_PMNC); WritePMUReg(PXA2_PMU_PMNC, pmnc_value & ~PMNC_ENABLE_BIT); /* clear the overflow flag */ flag_value = ReadPMUReg(PXA2_PMU_FLAG); WritePMUReg(PXA2_PMU_FLAG, FLAG_OVERFLOW_BITS); /* write sample record to sample buffer */ sample_rec.pc = pc; sample_rec.pid = pid; sample_rec.tid = tid; memcpy(sample_rec.timestamp, ×tamp, 3); if (flag_value & CCNT_OVERFLAG_BIT && es[COUNTER_PXA2_PMU_CCNT].enabled) { sample_rec.registerId = COUNTER_PXA2_PMU_CCNT; if (es[COUNTER_PXA2_PMU_CCNT].calibration == false) { /* write sample record in non-calibration mode */ buffer_full |= write_sample(&sample_rec); } else { /* calculate the overflow count in calibration mode */ es[sample_rec.registerId].overflow++; } /* reset the counter value */ WritePMUReg(PXA2_PMU_CCNT, es[COUNTER_PXA2_PMU_CCNT].reset_value); } for (i=0; i<4; i++) { if (flag_value & (PMN0_OVERFLAG_BIT << i)) { switch (i) { case 0: sample_rec.registerId = COUNTER_PXA2_PMU_PMN0; reg = PXA2_PMU_PMN0; break; case 1: sample_rec.registerId = COUNTER_PXA2_PMU_PMN1; reg = PXA2_PMU_PMN1; break; case 2: sample_rec.registerId = COUNTER_PXA2_PMU_PMN2; reg = PXA2_PMU_PMN2; break; case 3: sample_rec.registerId = COUNTER_PXA2_PMU_PMN3; reg = PXA2_PMU_PMN3; break; default: break; } if (es[sample_rec.registerId].calibration == false) { /* write sample record in non-calibration mode */ buffer_full |= write_sample(&sample_rec); } else { /* calculate the overflow count in calibration mode */ es[sample_rec.registerId].overflow++; } /* reset the counter value */ WritePMUReg(reg, es[sample_rec.registerId].reset_value); } } if (!buffer_full) { /* enable the counters if buffer is not full */ WritePMUReg(PXA2_PMU_PMNC, pmnc_value | PMNC_ENABLE_BIT); } /* enable the timer interrupt */ //enable_irq(PX_IRQ_PXA2_TIMER); return IRQ_HANDLED; }
static irqreturn_t px_pmu_isr(unsigned int pid, unsigned int tid, struct pt_regs * const regs, unsigned int cpu, unsigned long long ts) { u32 pmcr_value; u32 flag_value; unsigned int i; bool buffer_full = false; bool found = false; PXD32_Hotspot_Sample_V2 sample_rec; /* disable the counters */ pmcr_value = A9_Read_PMCR(); pmcr_value &= ~0x1; //pmcr_value |= 0x6; A9_Write_PMCR(pmcr_value); /* clear the overflow flag */ flag_value = A9_Read_OVSR(); A9_Write_OVSR(0xffffffff); /* add for PXA988 platform, Need to init CTI irq line */ #ifdef PX_SOC_PXA988 pxa988_ack_ctiint_func = (pxa988_ack_ctiint_t)kallsyms_lookup_name_func("pxa988_ack_ctiint"); pxa988_ack_ctiint_func(); //printk(KERN_EMERG "%s:%d, kallsyms_lookup_name_func is : 0x%x, pxa988_ack_ctiint_func is : 0x%x\n", __FILE__, __LINE__, (unsigned long)kallsyms_lookup_name_func, (unsigned long)pxa988_ack_ctiint_func); #endif if (flag_value == 0) { return IRQ_NONE; } sample_rec.pc = regs->ARM_pc; sample_rec.pid = pid; sample_rec.tid = tid; memcpy(sample_rec.timestamp, &ts, sizeof(sample_rec.timestamp)); if ((flag_value & 0x80000000) && es[COUNTER_A9_PMU_CCNT].enabled) { found = true; sample_rec.registerId = COUNTER_A9_PMU_CCNT; /* ccnt overflow */ if (es[sample_rec.registerId].calibration == false) { /* write sample record in non-calibration mode */ buffer_full |= write_sample(cpu, &sample_rec); } else { /* calculate the overflow count in calibration mode */ es[sample_rec.registerId].overflow++; } A9_WritePMUCounter(sample_rec.registerId, es[sample_rec.registerId].reset_value); } for (i=0; i<A9_PMN_NUM; i++) { if (flag_value & (0x1 << i)) { found = true; switch (i) { case 0: sample_rec.registerId = COUNTER_A9_PMU_PMN0; break; case 1: sample_rec.registerId = COUNTER_A9_PMU_PMN1; break; case 2: sample_rec.registerId = COUNTER_A9_PMU_PMN2; break; case 3: sample_rec.registerId = COUNTER_A9_PMU_PMN3; break; case 4: sample_rec.registerId = COUNTER_A9_PMU_PMN4; break; case 5: sample_rec.registerId = COUNTER_A9_PMU_PMN5; break; default: break; } if (es[sample_rec.registerId].calibration == false) { /* write sample record in non-calibration mode */ buffer_full |= write_sample(cpu, &sample_rec); } else { /* calculate the overflow count in calibration mode */ es[sample_rec.registerId].overflow++; } A9_WritePMUCounter(sample_rec.registerId, es[sample_rec.registerId].reset_value); } } if (!buffer_full) { /* enable the counters */ pmcr_value |= 0x1; pmcr_value &= ~0x6; A9_Write_PMCR(pmcr_value); } return IRQ_HANDLED; }
static int encode_sndfile(SNDFILE* snd, SF_INFO* info, pcm_sample_description_t* format, HANDLE_AACENCODER encoder, uint32_t frame_length, FILE *ofp, m4af_ctx_t *m4af, int show_progress) { #ifdef USE_LIBSAMPLERATE //short *resamplebuf = 0; SRC_STATE* srcstate = NULL; SRC_DATA srcdata; int srcerror = 0; float *ibuf = 0; #else short *ibuf = 0; #endif int16_t *pcmbuf = 0; uint32_t pcmsize = 0; uint8_t *obuf = 0; uint32_t olen; uint32_t osize = 0; int nread = 1; int consumed, written; int rc = -1; int frames_written = 0; aacenc_progress_t progress = { 0 }; ibuf = malloc(frame_length * format->bytes_per_frame); #ifdef USE_LIBSAMPLERATE if(format->sample_rate != info->samplerate) { /* set up resampler */ srcstate = src_new(SRC_SINC_MEDIUM_QUALITY, info->channels, &srcerror); srcdata.src_ratio = format->sample_rate; srcdata.src_ratio /= info->samplerate; srcdata.data_in = ibuf; srcdata.data_out = malloc(frame_length * format->bytes_per_frame * srcdata.src_ratio); srcdata.end_of_input = 0; } #endif aacenc_progress_init(&progress, info->frames, info->samplerate); do { if (g_interrupted) nread = 0; else if (nread) { #ifdef USE_LIBSAMPLERATE if ((nread = sf_readf_float(snd, ibuf, frame_length)) < 0) { #else if ((nread = sf_readf_short(snd, ibuf, frame_length)) < 0) { #endif fprintf(stderr, "ERROR: read failed\n"); goto END; } else if (nread > 0) { float* in_buf = ibuf; #ifdef USE_LIBSAMPLERATE if(srcstate) { /* run converstion */ srcdata.input_frames = nread; srcdata.output_frames = frame_length; if(srcerror = src_process(srcstate, &srcdata)) { fprintf(stderr, "resample error: %s\n", src_strerror(srcerror)); goto END; } //printf("resampled %d samples to %d samples\n", srcdata.input_frames_used, srcdata.output_frames_gen); in_buf = srcdata.data_out; nread = srcdata.output_frames_gen; } #endif if (pcm_convert_to_native_sint16(format, in_buf, nread, &pcmbuf, &pcmsize) < 0) { fprintf(stderr, "ERROR: unsupported sample format\n"); goto END; } } if (show_progress) aacenc_progress_update(&progress, sf_seek(snd, 0, SEEK_CUR), info->samplerate * 2); } written = nread; do { if ((consumed = aac_encode_frame(encoder, format, pcmbuf + (nread-written)*info->channels, written, &obuf, &olen, &osize)) < 0) goto END; //printf("nread: %d consumed: %d olen: %d\n", nread, consumed, olen); written -= (consumed / info->channels); if (olen > 0) { if (write_sample(ofp, m4af, obuf, olen, frame_length) < 0) goto END; ++frames_written; //printf("wrote frame %d\n", frames_written); } } while (written > 0); } while (nread > 0 || olen > 0); if (show_progress) aacenc_progress_finish(&progress, sf_seek(snd, 0, SEEK_CUR)); rc = frames_written; END: if (ibuf) free(ibuf); if (pcmbuf) free(pcmbuf); if (obuf) free(obuf); #ifdef USE_SAMPLERATE if (srcstate) { free(srcdata.data_out); src_delete(srcstate); } #endif return rc; } #endif static int encode(wav_reader_t *wavf, HANDLE_AACENCODER encoder, uint32_t frame_length, FILE *ofp, m4af_ctx_t *m4af, int show_progress) { uint8_t *ibuf = 0; int16_t *pcmbuf = 0; uint32_t pcmsize = 0; uint8_t *obuf = 0; uint32_t olen; uint32_t osize = 0; int nread = 1; int consumed; int rc = -1; int frames_written = 0; aacenc_progress_t progress = { 0 }; const pcm_sample_description_t *format = wav_get_format(wavf); ibuf = malloc(frame_length * format->bytes_per_frame); aacenc_progress_init(&progress, wav_get_length(wavf), format->sample_rate); do { if (g_interrupted) nread = 0; else if (nread) { if ((nread = wav_read_frames(wavf, ibuf, frame_length)) < 0) { fprintf(stderr, "ERROR: read failed\n"); goto END; } else if (nread > 0) { if (pcm_convert_to_native_sint16(format, ibuf, nread, &pcmbuf, &pcmsize) < 0) { fprintf(stderr, "ERROR: unsupported sample format\n"); goto END; } } if (show_progress) aacenc_progress_update(&progress, wav_get_position(wavf), format->sample_rate * 2); } if ((consumed = aac_encode_frame(encoder, format, pcmbuf, nread, &obuf, &olen, &osize)) < 0) goto END; if (olen > 0) { if (write_sample(ofp, m4af, obuf, olen, frame_length) < 0) goto END; ++frames_written; } } while (nread > 0 || olen > 0); if (show_progress) aacenc_progress_finish(&progress, wav_get_position(wavf)); rc = frames_written; END: if (ibuf) free(ibuf); if (pcmbuf) free(pcmbuf); if (obuf) free(obuf); return rc; }