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; }