void benchFilter(const std::vector<byte>& data) {
CM<kCMTypeMax> comp(6);
// data = randomArray(kBenchDataSize);
check(!data.empty());
const uint64_t expected_sum = std::accumulate(data.begin(), data.end(), 0UL);
std::vector<byte> out_data;
out_data.resize(20 * MB + static_cast<uint32_t>(data.size() * FilterType::getMaxExpansion() * 1.2));
uint64_t start = clock();
uint64_t write_count;
uint64_t old_sum = 0;
uint32_t best_size = std::numeric_limits<uint32_t>::max();
uint32_t best_spec;
for (uint32_t i = 0; i < kIterations; ++i) {
WriteMemoryStream wms(&out_data[0]);
ReadMemoryStream rms(&data);
FilterType f(&rms); // , 1 + (i & 3), 1 + (i / 4));
// f.setSpecific(100 + i);
comp.setOpt(i);
clock_t start = clock();
comp.compress(&f, &wms, std::numeric_limits<uint64_t>::max());
write_count = wms.tell();
f.dumpInfo();
if (write_count < best_size) {
best_size = static_cast<uint32_t>(write_count);
best_spec = i;
}
std::cout << "Cur=" << i << " size=" << write_count << " best(" << best_spec << ")=" << best_size << " time=" << clock() - start << std::endl;
#if 0
uint64_t checksum = std::accumulate(&out_data[0], &out_data[write_count], 0UL);
if (old_sum != 0) {
check(old_sum == checksum);
}
old_sum = checksum;
#endif
}
std::cout << "Forward: " << data.size() << "->" << write_count << " rate=" << prettySize(computeRate(data.size() * kIterations, clock() - start)) << "/S" << std::endl;
std::vector<byte> result;
result.resize(data.size());
start = clock();
for (uint32_t i = 0; i < kIterations; ++i) {
WriteMemoryStream wvs(&result[0]);
FilterType reverse_filter(&wvs);
comp.decompress(&ReadMemoryStream(&out_data[0], &out_data[0] + write_count), &reverse_filter, std::numeric_limits<uint64_t>::max());
reverse_filter.flush();
}
uint64_t rate = computeRate(data.size() * kIterations, clock() - start);
std::cout << "Reverse: " << prettySize(rate) << "/S" << std::endl;
// Check tht the shit matches.
check(result.size() == data.size());
for (uint32_t i = 0; i < data.size(); ++i) {
check(result[i] == data[i]);
}
}
void testFilter() {
Store store_comp;
std::vector<byte> data;
uint32_t size = (rand() * 7654321 + rand()) % kDataSize;
for (uint32_t i = 0; i < size; ++i) {
data.push_back(rand() % 256);
}
std::vector<byte> out_data;
store_comp.compress(&FilterType(&ReadMemoryStream(&data)), &WriteVectorStream(&out_data), std::numeric_limits<uint64_t>::max());
std::vector<byte> result;
WriteVectorStream wvs(&result);
FilterType reverse_filter(&wvs);
store_comp.decompress(&ReadMemoryStream(&out_data), &reverse_filter, std::numeric_limits<uint64_t>::max());
reverse_filter.flush();
// Check tht the shit matches.
check(result.size() == data.size());
for (uint32_t i = 0; i < data.size(); ++i) {
byte a = result[i];
byte b = data[i];
check(a == b);
}
}
int main(int argc, char *argv[]) {
struct sockaddr_in addr_server, addr_client;
int socket_server;
int slen = sizeof(addr_server);
struct Firstmessage message;
struct WavInfos wav_infos;
struct WavData data;
struct Ack ack;
int timeoutcounter = 0;
int sample_size, sample_rate, channels;
char *filename;
char *filter;
int fd_wav;
if (argc!=1) {
printf("Le programme ne prends pas d'arguments en parametre");
return 1;
}
// creation du socket pour le server
if ((socket_server=socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
die("socket");
}
// construction de l'adresse du server
addr_server.sin_family = AF_INET;
addr_server.sin_port = htons(PORT);
addr_server.sin_addr.s_addr = htonl(INADDR_ANY);
// on lie le socket au port
if( bind(socket_server , (struct sockaddr*) &addr_server, sizeof(addr_server) ) == -1) {
die("bind");
}
printf("----------------------------\n");
printf("Serveur Streaming Audio SYR2\n");
printf("----------------------------\n");
printf("En attente de requetes...\n");
// Reception du premier paquet
if ((recvfrom(socket_server, &message, sizeof(struct Firstmessage), 0, (struct sockaddr*) &addr_client, (socklen_t *) &slen))<0) {
die("Erreur lors de la reception de la demande du client");
}
filename = message.filename;
filter = message.filter;
// Ouverture du fichier .wav
if ((fd_wav = aud_readinit (filename, &sample_rate, &sample_size, &channels)) < 0) {
die("Erreur lors de l'ouverture du fichier ");
}
printf("Demande du fichier : %s \n", filename);
/* On teste si le fichier a bien été trouvé:
* 0: Aucune erreur
* 1: Fichier introuvable
* 2: Filtre introuvable
*/
// Verifications pour le fichier
if(fd_wav < 0) {
printf("Le fichier %s est introuvable\n",filename);
wav_infos.errorcode=1;
if ((sendto(socket_server, &wav_infos, sizeof(struct WavInfos), 0, (struct sockaddr*) &addr_client, slen)) < 0) {
die("Impossible d'envoyer la réponse au client");
}
}
// Verifications pour le filtre
if(strcmp(filter,"")==0){
printf("Pas de filtre demandé\n");
} else if(strcmp(filter,"reverse")==0){
printf("Filtre reverse selectioné\n");
} else if(strcmp(filter,"bip")==0) {
printf("Filtre beep selectioné\n");
} else if(strcmp(filter,"mono")==0) {
printf("Filtre mono selectioné\n");
} else {
wav_infos.errorcode=2;
if ((sendto(socket_server, &wav_infos, sizeof(struct WavInfos), 0, (struct sockaddr*) &addr_client, slen)) < 0) {
die("Impossible d'envoyer la réponse au client");
}
printf("Le filte %s n'est pas pris en charge \n", filter);
return 1;
}
printf("Succes de l'ouverture de %s\n",filename);
// On prépare la réponse avec les informations necessaires
// Si le filtre mono a été demandé on l'applique directement
if(strcmp(filter,"mono")==0) {
wav_infos.channels = 1;
} else {
wav_infos.channels = channels;
wav_infos.sample_rate = sample_rate;
}
wav_infos.sample_rate = sample_rate;
wav_infos.sample_size = sample_size;
wav_infos.errorcode = 0;
// Envoi des informations concernant le .wav
if ((sendto(socket_server, &wav_infos, sizeof(struct WavInfos), 0, (struct sockaddr*) &addr_client, slen)) < 0) {
die("Impossible d'envoyer la réponse au client");
}
// On attend que le client soit pret pour la reception
if ((recvfrom(socket_server, &ack, sizeof(struct Ack), 0, (struct sockaddr*) &addr_client, (socklen_t *) &slen))<0) {
die("Erreur lors de la demande de début d'envoi");
}
int ret = 0;
fd_set read_set;
struct timeval timeout;
int bytesread;
data.endflag = 0;
bytesread = read(fd_wav, data.buf, sizeof(data.buf));
while (bytesread > 0){
// Initialisation du timeout
timeout.tv_sec = TIMEOUT;
timeout.tv_usec = 0;
FD_ZERO(&read_set);
FD_SET(socket_server, &read_set);
// On applique le filtre au buffer courant (si demandé)
if(strcmp(filter,"reverse")==0){
reverse_filter(data.buf);
} else if(strcmp(filter,"bip")==0) {
bip_filter(data.buf);
}
// On recupere le nombre d'octets lus
data.length = bytesread;
if ((sendto(socket_server, &data, sizeof(struct WavData), 0, (struct sockaddr*) &addr_client, slen))<0) {
die("Erreur lors de l'envoi du buffer");
}
// Attente de l'aquittement, renvoi si le timeout est atteint
ret = select(socket_server + 1, &read_set, NULL, NULL, &timeout);
if (ret<0) {
die("select()");
}
if (ret==0) {
// Si le nombre de timeouts a atteint le maximum
if (timeoutcounter==RESENDS) {
printf("Le client ne répond plus, arret du transfert\n");
return 0;
}
// Renvoi du paquet au client
timeoutcounter+=1;
printf("Aucune réponse de la part du client, renvoi numero %d\n", timeoutcounter);
}
if(FD_ISSET(socket_server, &read_set)) {
timeoutcounter=0;
// Attente de l'aquittement
if ((recvfrom(socket_server, &ack, sizeof(struct Ack), 0, (struct sockaddr*) &addr_client, (socklen_t *) &slen))<0) {
die("Erreur reception paquet d'aquittement");
}
// Si le dernier paquet envoyé n'a pas été recu par le client
if (ack.flag == 0) {
printf("Renvoi du dernier message");
// le server revient a la boucle while et renvoi le paquet
} else {
bytesread = read(fd_wav, data.buf, sizeof(data.buf));
}
}
}
// Fin de fichier atteinte
data.endflag = 1;
if ((sendto(socket_server, &data, sizeof(struct WavData), 0, (struct sockaddr*) &addr_client, slen))) {
die("Impossible d'envoyer le paquet de fin de fichier");
}
// Fermeture de la connexion
close(socket_server);
close(fd_wav);
return 0;
}
