int main(int argc, char *argv[]) { init_mdata(); init_adata(); printf("Loading file 'bytecode'\n"); pc_t* pc = pc_new("bytecode"); while (pc_safe(pc)) { printf("ADDR: %x, OP: %x\n", pc->address, pc->line->op); pc_inc(pc, 1); pc_update(pc); } pc_inc(pc, -1); pc_branch(pc, 1); pc_update(pc); while (pc_safe(pc)) { printf("ADDR: %x, OP: %x\n", pc->address, pc->line->op); pc_inc(pc, 1); pc_update(pc); } pc_return(pc); pc_update(pc); printf("ADDR: %x, OP: %x\n", pc->address, pc->line->op); pc_del(pc); return 0; }
JNIEXPORT jfloatArray JNICALL Java_org_phash_AudioHash_readAudio (JNIEnv *env, jclass cl, jstring name, jint sr, jfloat nbsecs, jobject mdataObj){ jboolean iscopy; const char *filename = env->GetStringUTFChars(name, &iscopy); int error; unsigned int buflen = 0; AudioMetaData mdata; init_mdata(&mdata); float *buf = readaudio(filename, sr, NULL, &buflen, nbsecs, &mdata, &error); if (buf == NULL){ free_mdata(&mdata); env->ReleaseStringUTFChars(name, filename); return NULL; } jfloatArray buf2 = env->NewFloatArray((jint)buflen); env->SetFloatArrayRegion(buf2, 0, buflen, (jfloat*)buf); // get fieldIds jclass mdataclass = env->GetObjectClass(mdataObj); jfieldID composerfield = env->GetFieldID(mdataclass, "composer" , "Ljava/lang/String;" ); jfieldID title1field = env->GetFieldID(mdataclass, "title1" , "Ljava/lang/String;" ); jfieldID title2field = env->GetFieldID(mdataclass, "title2" , "Ljava/lang/String;" ); jfieldID title3field = env->GetFieldID(mdataclass, "title3" , "Ljava/lang/String;" ); jfieldID tpe1field = env->GetFieldID(mdataclass, "tpe1" , "Ljava/lang/String;" ); jfieldID tpe2field = env->GetFieldID(mdataclass, "tpe2" , "Ljava/lang/String;" ); jfieldID tpe3field = env->GetFieldID(mdataclass, "tpe3" , "Ljava/lang/String;" ); jfieldID tpe4field = env->GetFieldID(mdataclass, "tpe4" , "Ljava/lang/String;" ); jfieldID datefield = env->GetFieldID(mdataclass, "date" , "Ljava/lang/String;" ); jfieldID albumfield = env->GetFieldID(mdataclass, "album" , "Ljava/lang/String;" ); jfieldID genrefield = env->GetFieldID(mdataclass, "genre" , "Ljava/lang/String;" ); jfieldID yearfield = env->GetFieldID(mdataclass, "year" , "I"); jfieldID durationfield = env->GetFieldID(mdataclass, "duration" , "I"); jfieldID partofsetfield = env->GetFieldID(mdataclass, "partofset", "I"); // set AudioMetaData fields if (composerfield != 0) env->SetObjectField(mdataObj, composerfield, env->NewStringUTF(mdata.composer)); if (title1field != 0) env->SetObjectField(mdataObj, title1field, env->NewStringUTF(mdata.title1)); if (title2field != 0) env->SetObjectField(mdataObj, title2field, env->NewStringUTF(mdata.title2)); if (title3field != 0) env->SetObjectField(mdataObj, title3field, env->NewStringUTF(mdata.title3)); if (tpe1field != 0) env->SetObjectField(mdataObj, tpe1field, env->NewStringUTF(mdata.tpe1)); if (tpe2field != 0) env->SetObjectField(mdataObj, tpe2field, env->NewStringUTF(mdata.tpe2)); if (tpe3field != 0) env->SetObjectField(mdataObj, tpe3field, env->NewStringUTF(mdata.tpe3)); if (tpe4field != 0) env->SetObjectField(mdataObj, tpe4field, env->NewStringUTF(mdata.tpe4)); if (datefield != 0) env->SetObjectField(mdataObj, datefield, env->NewStringUTF(mdata.date)); if (albumfield != 0) env->SetObjectField(mdataObj, albumfield, env->NewStringUTF(mdata.album)); if (genrefield != 0) env->SetObjectField(mdataObj, genrefield, env->NewStringUTF(mdata.genre)); if (yearfield != 0) env->SetIntField(mdataObj , yearfield, mdata.year); if (durationfield != 0) env->SetIntField(mdataObj , durationfield, mdata.duration); if (partofsetfield != 0)env->SetIntField(mdataObj , partofsetfield, mdata.partofset); audiodata_free(buf); free_mdata(&mdata); env->ReleaseStringUTFChars(name, filename); return buf2; }
int main(int argc, char** argv) { ASSERT(argc > 1, "Specify a bytecode file in the first and only argument, please\n"); init_mdata(); // Initalize the instruction defs init_adata(); init_ins_def(); rt_t* runtime = proc_init(argv[1]); // Initalize process proc_run(runtime); // Execute runtime proc_clean(runtime); // Once `proc_run` returns, clean // what sort of mess it made. return 0; }
AUDIODATA_EXPORT void free_mdata(AudioMetaData *mdata){ if (mdata == NULL) return; if (mdata->composer) free(mdata->composer); if (mdata->title1) free(mdata->title1); if (mdata->title2) free(mdata->title2); if (mdata->title3) free(mdata->title3); if (mdata->tpe1) free(mdata->tpe1); if (mdata->tpe2) free(mdata->tpe2); if (mdata->tpe3) free(mdata->tpe3); if (mdata->tpe4) free(mdata->tpe4); if (mdata->date) free(mdata->date); if (mdata->album) free(mdata->album); if (mdata->genre) free(mdata->genre); init_mdata(mdata); return; }
AUDIODATA_EXPORT float* readaudio(const char *filename, const int sr, float *sigbuf, unsigned int *buflen,\ const float nbsecs, AudioMetaData *mdata, int *error) { long orig_sr; unsigned int orig_length = 0; float *inbuffer = NULL; *error = PHERR_SUCCESS; if (filename == NULL || buflen == NULL) { *error = PHERR_NULLARG; return NULL; } if (mdata) init_mdata(mdata); const char *suffix = strrchr(filename, '.'); if (*suffix != '\0' && !strncasecmp(suffix+1, "mp3",3)) { #ifdef HAVE_MPG123 inbuffer = readaudio_mp3(filename, &orig_sr, &orig_length, nbsecs, mdata, error); #endif /* HAVE_MPG123 */ } else { inbuffer = readaudio_snd(filename, &orig_sr, &orig_length, nbsecs, mdata, error); } if (inbuffer == NULL){ return NULL; } /* if no data extracted for title, use the file name */ if (mdata && mdata->title2 == NULL){ char *name = strrchr(filename, '/'); if (name == NULL) name = strchr(filename, '\\'); if (name) mdata->title2 = strdup(name+1); } /* resample float array */ /* set desired sr ratio */ double sr_ratio = (double)(sr)/(double)orig_sr; if (src_is_valid_ratio(sr_ratio) == 0){ *error = PHERR_BADSR; free(inbuffer); return NULL; } /* allocate output buffer for conversion */ unsigned int outbufferlength = sr_ratio*(orig_length); float *outbuffer = NULL; if (sigbuf && outbufferlength < *buflen){ outbuffer = sigbuf; } else { outbuffer = (float*)malloc(outbufferlength*sizeof(float)); } if (!outbuffer){ free(inbuffer); *error = PHERR_NOBUFALLOCD; return NULL; } SRC_STATE *src_state = src_new(SRC_LINEAR, 1, error); if (!src_state){ *error = PHERR_SRCCONTXT; free(inbuffer); if (outbuffer != sigbuf) free(outbuffer); return NULL; } SRC_DATA src_data; src_data.data_in = inbuffer; src_data.data_out = outbuffer; src_data.input_frames = orig_length; src_data.output_frames = outbufferlength; src_data.end_of_input = SF_TRUE; src_data.src_ratio = sr_ratio; /* sample rate conversion */ *error = src_process(src_state, &src_data); if (*error){ *error = PHERR_SRCPROC; free(inbuffer); if (outbuffer != sigbuf) free(outbuffer); src_delete(src_state); return NULL; } *buflen = outbufferlength; src_delete(src_state); free(inbuffer); return outbuffer; }
static float *readaudio_snd(const char *filename, long *sr, unsigned int *buflen,\ const float nbsecs, AudioMetaData *mdata, int *error){ SF_INFO sf_info; sf_info.format=0; SNDFILE *sndfile = sf_open(filename, SFM_READ, &sf_info); if (sndfile == NULL){ *error = PHERR_SNDFILEOPEN; return NULL; } /* normalize */ sf_command(sndfile, SFC_SET_NORM_FLOAT, NULL, SF_TRUE); if (mdata){ init_mdata(mdata); /* extract metadata from file */ const char *tmp = sf_get_string(sndfile, SF_STR_TITLE); mdata->title2 = (tmp) ? strdup(tmp): NULL; tmp = sf_get_string(sndfile,SF_STR_ARTIST); mdata->tpe1= (tmp) ? strdup(tmp) : NULL; mdata->composer = (tmp) ? strdup(tmp) : NULL; tmp = sf_get_string(sndfile,SF_STR_DATE); mdata->date = (tmp) ? strdup(tmp):NULL; } *sr = (long)sf_info.samplerate; /*allocate input buffer for signal*/ unsigned int src_frames = (nbsecs <= 0) ? sf_info.frames : (nbsecs*sf_info.samplerate); src_frames = (sf_info.frames < src_frames) ? sf_info.frames : src_frames; float *inbuf = (float*)malloc(src_frames*sf_info.channels*sizeof(float)); if (inbuf == NULL){ *error = PHERR_MEMALLOC; return NULL; } /*read frames */ sf_count_t cnt_frames = sf_readf_float(sndfile, inbuf, src_frames); float *buf = (float*)malloc(cnt_frames*sizeof(float)); if (buf == NULL){ *error = PHERR_MEMALLOC; return NULL; } *buflen = cnt_frames; /*average across all channels*/ int i,j,indx=0; for (i=0;i<cnt_frames*sf_info.channels;i+=sf_info.channels){ buf[indx] = 0; for (j=0;j<sf_info.channels;j++){ buf[indx] += inbuf[i+j]; } buf[indx++] /= sf_info.channels; } free(inbuf); return buf; }
float* readaudio_mp3(const char *filename,long *sr, unsigned int *buflen,\ const float nbsecs, AudioMetaData *mdata, int *error){ mpg123_handle *m; int ret = 0; mpg123_id3v1 *v1 = NULL; mpg123_id3v2 *v2 = NULL; if ((ret = mpg123_init()) != MPG123_OK || ((m = mpg123_new(NULL,&ret)) == NULL)|| \ (ret = mpg123_open(m, filename)) != MPG123_OK){ *error = (ret != 0) ? ret : PHERR_MP3NEW; return NULL; } /*turn off logging */ mpg123_param(m, MPG123_ADD_FLAGS, MPG123_QUIET, 0); off_t totalsamples; mpg123_scan(m); totalsamples = mpg123_length(m); if (totalsamples <= 0){ *error = PHERR_NOSAMPLES; return NULL; } int meta = mpg123_meta_check(m); if (mdata)init_mdata(mdata); if (mdata && (meta & MPG123_ID3) && mpg123_id3(m, &v1, &v2) == MPG123_OK){ if (v2){ get_v2_data(v2, mdata); } else if (v1){ get_v1_data(v1, mdata); } } int channels, encoding; if (mpg123_getformat(m, sr, &channels, &encoding) != MPG123_OK){ *error = PHERR_NOFORMAT; return NULL; } mpg123_format_none(m); mpg123_format(m, *sr, channels, encoding); if (channels <= 0 || encoding <= 0){ *error = PHERR_NOENCODING; return NULL; } size_t decbuflen = mpg123_outblock(m); if (decbuflen == 0){ /* take a guess */ decbuflen = 1<<16; } unsigned char *decbuf = (unsigned char*)malloc(decbuflen); if (decbuf == NULL){ *error = PHERR_MEMALLOC; return NULL; } unsigned int nbsamples = (nbsecs <= 0) ? totalsamples : nbsecs*(*sr); nbsamples = (nbsamples <= totalsamples) ? nbsamples : totalsamples; size_t i, j, index = 0, done; float *buffer = (float*)malloc(nbsamples*sizeof(float)); if (buffer == NULL){ *error = PHERR_MEMALLOC; return NULL; } *buflen = nbsamples; do { ret = mpg123_read(m, decbuf, decbuflen, &done); switch (encoding) { case MPG123_ENC_SIGNED_16 : for (i = 0; i < done/sizeof(short); i+=channels){ buffer[index] = 0.0f; for (j = 0; j < channels ; j++){ buffer[index] += (float)(((short*)decbuf)[i+j])/(float)SHRT_MAX; } buffer[index++] /= channels; if (index >= nbsamples) break; } break; case MPG123_ENC_SIGNED_8: for (i = 0; i < done/sizeof(char); i+=channels){ buffer[index] = 0.0f; for (j = 0; j < channels ; j++){ buffer[index] += (float)(((char*)decbuf)[i+j])/(float)SCHAR_MAX; } buffer[index++] /= channels; if (index >= nbsamples) break; } break; case MPG123_ENC_FLOAT_32: for (i = 0; i < done/sizeof(float); i+=channels){ buffer[index] = 0.0f; for (j = 0; j < channels; j++){ buffer[index] += ((float*)decbuf)[i+j]; } buffer[index++] /= channels; if (index >= nbsamples) break; } break; default: done = 0; } } while (ret == MPG123_OK && index < nbsamples); if (ret != MPG123_DONE && ret != MPG123_OK && index < nbsamples){ free(buffer); *error = ret; buffer=NULL; } free(decbuf); mpg123_close(m); mpg123_delete(m); mpg123_exit(); return buffer; }
int main(int argc, char **argv){ char addr[32]; if (argc < 8){ printf("not enough input args\n"); printf("usage: progname <cmd> <nbthreads> <server address> <nbquerys>\n"); printf(" cmd - 1 for query, 2 for file submission\n"); printf(" nbthreads - number of driver threads\n"); printf(" arr - ave inter-arrival time (millisecs)\n"); printf(" server address - address of auscoutd, e.g. \"localhost\"\n"); printf(" sink address - e.g. tcp://localhost:port\n"); printf(" port - port of the auscoutd server, e.g. 4005\n"); printf(" nbquerys - total number queries to submit\n"); return 0; } /*args [cmd | nbthreads | arr | server address | nbquerys ] */ const int cmd = (uint8_t)atoi(argv[1]); const int nbthreads = atoi(argv[2]); Arr = atoi(argv[3]); char *auscoutd_address = argv[4]; char *ausink_address = argv[5]; const int port = atoi(argv[6]); const int nbquerys = atoi(argv[7]); snprintf(addr, 32, "tcp://%s:%d", auscoutd_address, port); void *ctx = zmq_init(1); assert(ctx); unsigned int nb_files_per_thread = nbquerys/nbthreads; unsigned int nb_files_last_thread = nbquerys%nbthreads; fprintf(stdout,"\nfiles per thread %u\n" , nb_files_per_thread); fprintf(stdout, "files in last thread %u\n", nb_files_last_thread); fprintf(stdout, "nb threads %d\n\n" , nbthreads); uint32_t **hashes = (uint32_t**)malloc(nbquerys*sizeof(uint32_t*)); uint32_t *ptrNbframes = (uint32_t*)malloc(nbquerys*sizeof(uint32_t));; /* socket to send init signal to ausink */ void *prepskt = socket_connect(ctx, ZMQ_PAIR, ausink_address); assert(prepskt); struct timespec seed; clock_gettime(CLOCK_REALTIME, &seed); srand(seed.tv_nsec); struct timespec start_ts, end_ts; AudioMetaData phonymdata; init_mdata(&phonymdata); phonymdata.composer = "composer"; phonymdata.title2 = "title"; phonymdata.tpe1 = "performer"; phonymdata.date = "date"; phonymdata.year = 2010; phonymdata.album = "album"; phonymdata.genre = "genre"; phonymdata.duration = 1000000; phonymdata.partofset = 1; char mdata_inlinestr[512]; metadata_to_inlinestr(&phonymdata, mdata_inlinestr, 512); int i, err; if (cmd == 1 || cmd == 2){ /* querys */ for (i = 0;i < nbquerys;i++){ uint32_t nbframes = rand()%12500; uint32_t *hash = (uint32_t*)malloc(nbframes*sizeof(uint32_t)); assert(hash); hashes[i] = hash; ptrNbframes[i] = nbframes; } /* start of send time*/ clock_gettime(CLOCK_MONOTONIC, &start_ts); /* send init signal with number of files sending to ausc sink */ uint32_t nb = nbquerys; send_msg_vsm(prepskt, &nb, sizeof(uint32_t)); fprintf(stdout, "send to auscoutd\n"); ThrParam *thrparam; pthread_t *thrs = (pthread_t*)malloc((nbthreads+1)*sizeof(pthread_t)); assert(thrs); for (i=0;i<nbthreads;i++){ thrparam = (ThrParam*)malloc(sizeof(ThrParam)); assert(thrparam); thrparam->ctx = ctx; thrparam->cmd = cmd; thrparam->thrn = i; thrparam->mdatastr = mdata_inlinestr; thrparam->nbfiles = nb_files_per_thread; thrparam->address = addr; thrparam->hashes = hashes + i*nb_files_per_thread; thrparam->nbframes = ptrNbframes + i*nb_files_per_thread; assert(pthread_create(&thrs[i], NULL, query_thread, thrparam) == 0); } if (nb_files_last_thread){ thrparam = (ThrParam*)malloc(sizeof(ThrParam)); assert(thrparam); thrparam->ctx = ctx; thrparam->cmd = cmd; thrparam->thrn = nbthreads; thrparam->mdatastr = mdata_inlinestr; thrparam->nbfiles = nb_files_last_thread; thrparam->address = addr; thrparam->hashes = hashes + nbthreads*nb_files_per_thread; thrparam->nbframes = ptrNbframes + nbthreads*nb_files_per_thread; assert(pthread_create(&thrs[nbthreads], NULL, query_thread, thrparam) == 0); } /* wait for threads */ unsigned long long sum_ull, *ptr_ave = NULL; for (i=0;i < nbthreads;i++){ pthread_join(thrs[i], (void**)&ptr_ave); sum_ull += *ptr_ave; } if (nb_files_last_thread){ pthread_join(thrs[nbthreads], (void**)&ptr_ave); sum_ull += *ptr_ave; } /* end of sending */ clock_gettime(CLOCK_MONOTONIC, &end_ts); struct timespec total_ts = diff_timespec(start_ts, end_ts); unsigned long long total = 1000000000*total_ts.tv_sec + total_ts.tv_nsec; float total_secs = (float)total/1000000000.0f; float ave_latency = (float)sum_ull/(float)nbquerys/1000000000.0f; float rate = (float)nbquerys/total_secs; fprintf(stdout,"ave latency, %f secs\n", ave_latency); fprintf(stdout,"rate: %f querys/sec\n", rate); fprintf(stdout,"total time, %f secs\n", total_secs); } else { fprintf(stdout,"unrecognized cmd, %u\n", cmd); } zmq_close(prepskt); zmq_term(ctx); return 0; }
void SendThread::doSend(){ quint8 cmd; if (mode == QUERY_MODE) { cmd = 1; } else if (mode == SUBMIT_MODE){ cmd = 2; } else{ return; } QString delimStr(delim); emit activatedProgress(true); emit changedRange(0, fileList.size()); emit changedLevel(0); int error; float *sigbuf = new float[1<<24]; const unsigned int buflen = 1<<24; quint32 nbframes = 0, snbframes = 0, id = 0; char *data = NULL; char mdata_inlinestr[512]; AudioHashStInfo hash_st; hash_st.sr = 0; int index = 0; AudioMetaData mdata; init_mdata(&mdata); foreach(QString currentFile, fileList){ emit appendedText(tr("looking up ") + currentFile); unsigned int tmpbuflen = buflen; char *file = currentFile.toLocal8Bit().data(); float *buf = readaudio(file, 6000, sigbuf, &tmpbuflen, nbsecs, &mdata, &error); if (!buf){ QString errorString = QString("unable to read audio: err code %1").arg(error); qDebug() << "could not read file: " << errorString; emit postedError(errorString); continue; } quint32 *hash = NULL; int res = audiohash(buf,&hash,NULL,NULL,NULL,&nbframes,NULL,NULL,\ tmpbuflen,0,6000,&hash_st); if (res < 0){ QString errorString = QString("unable to extract a hash"); emit postedError(errorString); qDebug() << "could not get hash: " << errorString.toUtf8().data(); if (buf != sigbuf) ph_free(buf); continue; } try { zmq::message_t cmdmsg(&cmd, sizeof(quint8), NULL); snbframes = hosttonet32(nbframes); zmq::message_t framesmsg(&snbframes, sizeof(quint32), NULL); zmq::message_t hashmsg(hash, nbframes*sizeof(quint32), free_func); skt->send(cmdmsg, ZMQ_SNDMORE); skt->send(framesmsg, ZMQ_SNDMORE); if (cmd == 1){ //query skt->send(hashmsg, 0); } else { //query skt->send(hashmsg, ZMQ_SNDMORE); metadata_to_inlinestr(&mdata, mdata_inlinestr, 512); zmq::message_t metadata_msg(mdata_inlinestr, strlen(mdata_inlinestr)+1, NULL); skt->send(metadata_msg, 0); } zmq::message_t respmsg; skt->recv(&respmsg, 0); data = (char*)respmsg.data(); QString retdString(data); if (cmd == 1){ QStringList resultList = retdString.split(delimStr); int i = 0; foreach (QString resultStr, resultList){ if (i < fields.size()){ emit appendedText(fields[i] + ": " + resultStr); } i++; } resultList.clear(); } else if (cmd == 2){ if (respmsg.size() != sizeof(quint32)) { QString errorString = QString("recieved msg of incorrectsize, %1").arg(respmsg.size()); emit postedError(errorString); if (buf != sigbuf) ph_free(buf); continue; } memcpy(&id, data, sizeof(quint32)); id = nettohost32(id); QString line = QString("assigned id = %1").arg(id); emit appendedText(line); } } catch (zmq::error_t err){