int
main ()
{
decoder_t* decoderPtr;
puts("Starting...");
decoderPtr = decoder_alloc();
assert(decoderPtr);
long numDataByte = 3;
long numPacketByte = PACKET_HEADER_LENGTH + numDataByte;
char* abcBytes = (char*)SEQ_MALLOC(numPacketByte);
assert(abcBytes);
packet_t* abcPacketPtr;
abcPacketPtr = (packet_t*)abcBytes;
abcPacketPtr->flowId = 1;
abcPacketPtr->fragmentId = 0;
abcPacketPtr->numFragment = 2;
abcPacketPtr->length = numDataByte;
abcPacketPtr->data[0] = 'a';
abcPacketPtr->data[1] = 'b';
abcPacketPtr->data[2] = 'c';
char* defBytes = (char*)SEQ_MALLOC(numPacketByte);
assert(defBytes);
packet_t* defPacketPtr;
defPacketPtr = (packet_t*)defBytes;
defPacketPtr->flowId = 1;
defPacketPtr->fragmentId = 1;
defPacketPtr->numFragment = 2;
defPacketPtr->length = numDataByte;
defPacketPtr->data[0] = 'd';
defPacketPtr->data[1] = 'e';
defPacketPtr->data[2] = 'f';
assert(decoder_process(decoderPtr, abcBytes, numDataByte) == ERROR_SHORT);
abcPacketPtr->flowId = -1;
assert(decoder_process(decoderPtr, abcBytes, numPacketByte) == ERROR_FLOWID);
abcPacketPtr->flowId = 1;
abcPacketPtr->fragmentId = -1;
assert(decoder_process(decoderPtr, abcBytes, numPacketByte) == ERROR_FRAGMENTID);
abcPacketPtr->fragmentId = 0;
abcPacketPtr->fragmentId = 2;
assert(decoder_process(decoderPtr, abcBytes, numPacketByte) == ERROR_FRAGMENTID);
abcPacketPtr->fragmentId = 0;
abcPacketPtr->fragmentId = 2;
assert(decoder_process(decoderPtr, abcBytes, numPacketByte) == ERROR_FRAGMENTID);
abcPacketPtr->fragmentId = 0;
abcPacketPtr->length = -1;
assert(decoder_process(decoderPtr, abcBytes, numPacketByte) == ERROR_LENGTH);
abcPacketPtr->length = numDataByte;
assert(decoder_process(decoderPtr, abcBytes, numPacketByte) == ERROR_NONE);
defPacketPtr->numFragment = 3;
assert(decoder_process(decoderPtr, defBytes, numPacketByte) == ERROR_NUMFRAGMENT);
defPacketPtr->numFragment = 2;
assert(decoder_process(decoderPtr, abcBytes, numPacketByte) == ERROR_NONE);
defPacketPtr->fragmentId = 0;
assert(decoder_process(decoderPtr, defBytes, numPacketByte) == ERROR_INCOMPLETE);
defPacketPtr->fragmentId = 1;
long flowId;
assert(decoder_process(decoderPtr, defBytes, numPacketByte) == ERROR_NONE);
assert(decoder_process(decoderPtr, abcBytes, numPacketByte) == ERROR_NONE);
char* str = decoder_getComplete(decoderPtr, &flowId);
assert(strcmp(str, "abcdef") == 0);
SEQ_FREE(str);
assert(flowId == 1);
abcPacketPtr->numFragment = 1;
assert(decoder_process(decoderPtr, abcBytes, numPacketByte) == ERROR_NONE);
str = decoder_getComplete(decoderPtr, &flowId);
assert(strcmp(str, "abc") == 0);
SEQ_FREE(str);
abcPacketPtr->numFragment = 2;
assert(flowId == 1);
str = decoder_getComplete(decoderPtr, &flowId);
assert(str == NULL);
assert(flowId == -1);
decoder_free(decoderPtr);
SEQ_FREE(abcBytes);
SEQ_FREE(defBytes);
puts("All tests passed.");
return 0;
}
/* =============================================================================
* main
* =============================================================================
*/
MAIN(argc, argv)
{
GOTO_REAL();
/*
* Initialization
*/
SETUP_NUMBER_TASKS(3);
parseArgs(argc, (char** const)argv);
long numThread = global_params[PARAM_THREAD];
SETUP_NUMBER_THREADS(numThread);
SIM_GET_NUM_CPU(numThread);
TM_STARTUP(numThread, 0);
P_MEMORY_STARTUP(numThread);
thread_startup(numThread);
long percentAttack = global_params[PARAM_ATTACK];
long maxDataLength = global_params[PARAM_LENGTH];
long numFlow = global_params[PARAM_NUM];
long randomSeed = global_params[PARAM_SEED];
/* printf("Percent attack = %li\n", percentAttack);
printf("Max data length = %li\n", maxDataLength);
printf("Num flow = %li\n", numFlow);
printf("Random seed = %li\n", randomSeed); */
double time_total = 0.0;
int repeats = global_params[PARAM_REPEAT];
for (; repeats > 0; --repeats) {
dictionary_t* dictionaryPtr = dictionary_alloc();
assert(dictionaryPtr);
stream_t* streamPtr = stream_alloc(percentAttack);
assert(streamPtr);
long numAttack = stream_generate(streamPtr,
dictionaryPtr,
numFlow,
randomSeed,
maxDataLength);
// printf("Num attack = %li\n", numAttack);
decoder_t* decoderPtr = decoder_alloc();
assert(decoderPtr);
vector_t** errorVectors = (vector_t**)malloc(numThread * sizeof(vector_t*));
assert(errorVectors);
long i;
for (i = 0; i < numThread; i++) {
vector_t* errorVectorPtr = vector_alloc(numFlow);
assert(errorVectorPtr);
errorVectors[i] = errorVectorPtr;
}
arg_t arg;
arg.streamPtr = streamPtr;
arg.decoderPtr = decoderPtr;
arg.errorVectors = errorVectors;
/*
* Run transactions
*/
TIMER_T startTime;
TIMER_READ(startTime);
tm_time_t start_clock=TM_TIMER_READ();
GOTO_SIM();
thread_start(processPackets, (void*)&arg);
GOTO_REAL();
TIMER_T stopTime;
tm_time_t end_clock=TM_TIMER_READ();
TIMER_READ(stopTime);
double time_tmp = TIMER_DIFF_SECONDS(startTime, stopTime);
time_total += time_tmp;
PRINT_STATS();
PRINT_CLOCK_THROUGHPUT(end_clock-start_clock);
/*
* Check solution
*/
long numFound = 0;
for (i = 0; i < numThread; i++) {
vector_t* errorVectorPtr = errorVectors[i];
long e;
long numError = vector_getSize(errorVectorPtr);
numFound += numError;
for (e = 0; e < numError; e++) {
long flowId = (long)vector_at(errorVectorPtr, e);
bool_t status = stream_isAttack(streamPtr, flowId);
assert(status);
}
}
// printf("Num found = %li\n", numFound);
assert(numFound == numAttack);
/*
* Clean up
*/
for (i = 0; i < numThread; i++) {
vector_free(errorVectors[i]);
}
free(errorVectors);
decoder_free(decoderPtr);
stream_free(streamPtr);
dictionary_free(dictionaryPtr);
}
printf("Time = %f\n", time_total);
TM_SHUTDOWN();
P_MEMORY_SHUTDOWN();
GOTO_SIM();
thread_shutdown();
MAIN_RETURN(0);
}
/* =============================================================================
* main
* =============================================================================
*/
MAIN(argc, argv)
{
GOTO_REAL();
/*
* Initialization
*/
parseArgs(argc, (char** const)argv);
long numThread = global_params[PARAM_THREAD];
SIM_GET_NUM_CPU(numThread);
TM_STARTUP(numThread);
P_MEMORY_STARTUP(numThread);
thread_startup(numThread);
long percentAttack = global_params[PARAM_ATTACK];
long maxDataLength = global_params[PARAM_LENGTH];
long numFlow = global_params[PARAM_NUM];
long randomSeed = global_params[PARAM_SEED];
printf("Percent attack = %li\n", percentAttack);
printf("Max data length = %li\n", maxDataLength);
printf("Num flow = %li\n", numFlow);
printf("Random seed = %li\n", randomSeed);
dictionary_t* dictionaryPtr = dictionary_alloc();
assert(dictionaryPtr);
stream_t* streamPtr = stream_alloc(percentAttack);
assert(streamPtr);
long numAttack = stream_generate(streamPtr,
dictionaryPtr,
numFlow,
randomSeed,
maxDataLength);
printf("Num attack = %li\n", numAttack);
decoder_t* decoderPtr = decoder_alloc();
assert(decoderPtr);
vector_t** errorVectors = (vector_t**)malloc(numThread * sizeof(vector_t*));
assert(errorVectors);
long i;
for (i = 0; i < numThread; i++) {
vector_t* errorVectorPtr = vector_alloc(numFlow);
assert(errorVectorPtr);
errorVectors[i] = errorVectorPtr;
}
arg_t arg;
arg.streamPtr = streamPtr;
arg.decoderPtr = decoderPtr;
arg.errorVectors = errorVectors;
/*
* Run transactions
*/
TIMER_T startTime;
TIMER_READ(startTime);
GOTO_SIM();
#ifdef OTM
#pragma omp parallel
{
processPackets((void*)&arg);
}
#else
thread_start(processPackets, (void*)&arg);
#endif
GOTO_REAL();
TIMER_T stopTime;
TIMER_READ(stopTime);
printf("\nTime = %lf\n", TIMER_DIFF_SECONDS(startTime, stopTime));
/*
* Check solution
*/
/*long numFound = 0;
for (i = 0; i < numThread; i++) {
vector_t* errorVectorPtr = errorVectors[i];
long e;
long numError = vector_getSize(errorVectorPtr);
numFound += numError;
for (e = 0; e < numError; e++) {
long flowId = (long)vector_at(errorVectorPtr, e);
bool_t status = stream_isAttack(streamPtr, flowId);
assert(status);
}
}*/
/*printf("Num found = %li\n", numFound);
assert(numFound == numAttack);*/
/*
* Clean up
*/
for (i = 0; i < numThread; i++) {
vector_free(errorVectors[i]);
}
free(errorVectors);
decoder_free(decoderPtr);
stream_free(streamPtr);
dictionary_free(dictionaryPtr);
TM_SHUTDOWN();
P_MEMORY_SHUTDOWN();
GOTO_SIM();
thread_shutdown();
MAIN_RETURN(0);
}
static DB_playItem_t *
example_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
// open file
DB_FILE *fp = deadbeef->fopen (fname);
if (!fp) {
trace ("example: failed to fopen %s\n", fname);
return NULL;
}
// decoder_* functions are imaginary -- you should replace them with real
// decoder library calls
decoder_info_t *di = decoder_open ();
if (!di) {
trace ("example: failed to init decoder\n");
return NULL;
}
// read track info/tags
track_info_t ti;
if (decoder_read_info (&ti) < 0) {
trace ("example: failed to read info\n");
decoder_free (di);
return NULL;
}
// replace "example" with your file type (e.g. MP3, WAV, etc)
const char *ft = "example";
// no cuesheet, prepare track for addition
DB_playItem_t *it = deadbeef->pl_item_alloc_init (fname, plugin.plugin.id);
deadbeef->pl_replace_meta (it, ":FILETYPE", ft);
deadbeef->plt_set_item_duration (plt, it, (float)ti.total_num_samples/ti.samplerate);
// now we should have track duration, and can try loading cuesheet
// 1st try embedded cuesheet
if (ti.embeddedcuesheet[0]) {
DB_playItem_t *cue = deadbeef->plt_insert_cue_from_buffer (plt, after, it, ti.embeddedcuesheet, strlen (ti.embeddedcuesheet), ti.total_num_samples, ti.samplerate);
if (cue) {
deadbeef->pl_item_unref (it);
deadbeef->pl_item_unref (cue);
// cuesheet loaded
decoder_free (di);
return cue;
}
}
// embedded cuesheet not found, try external one
DB_playItem_t *cue = deadbeef->plt_insert_cue (plt, after, it, ti.total_num_samples, ti.samplerate);
if (cue) {
// cuesheet loaded
deadbeef->pl_item_unref (it);
deadbeef->pl_item_unref (cue);
decoder_free (di);
return cue;
}
// add metainfo
if (!strlen (ti.title)) {
// title is empty, this call will set track title to filename without extension
deadbeef->pl_add_meta (it, "title", NULL);
}
else {
deadbeef->pl_add_meta (it, "title", ti.title);
}
deadbeef->pl_add_meta (it, "artist", ti.artist);
// ... etc ...
// free decoder
decoder_free (di);
// now the track is ready, insert into playlist
after = deadbeef->plt_insert_item (plt, after, it);
deadbeef->pl_item_unref (it);
return after;
}
