void Stream::WriteData(const StreamBuffer& value)
{
if (streamMode == SmMemory)
{
ExpandMemoryStream(value.size());
std::memcpy(buffer.data() + position, value.data(), value.size());
position += value.size();
}
else
fileStream.write(reinterpret_cast<const char*>(value.data()), value.size());
}
void Stream::ReadData(const StreamBuffer& value)
{
if (streamMode == SmMemory)
{
unsigned int size = std::max(static_cast<int>(value.size()), static_cast<int>(value.size() - buffer.size()));
std::memcpy((void*)value.data(), buffer.data() + position, size);
position += value.size();
}
else
fileStream.read(reinterpret_cast<char*>(const_cast<unsigned char*>(value.data())), value.size());
}
int main(int, char const* const*)
{
try
{
using libember::util::StreamBuffer;
StreamBuffer<unsigned short, 256> testStream;
for (unsigned int i = 0; i < 1000; ++i)
{
{
unsigned short writeBuffer[7];
for (unsigned int j = 0; j < 7; ++j)
{
writeBuffer[j] = static_cast<unsigned short>(i * 7 + j);
}
unsigned short const* const begin = writeBuffer;
unsigned short const* const end = writeBuffer + sizeof(writeBuffer) / sizeof(writeBuffer[0]);
testStream.append(begin, end);
}
for (unsigned int j = 0; j < 5; ++j)
{
unsigned short const current = testStream.front();
testStream.consume();
if (current != (i * 5 + j))
{
THROW_TEST_EXCEPTION("Invalid head of buffer! Expected " << (i * 5 + j) << ", found " << current);
}
}
std::size_t const size = testStream.size();
if (size != 2 * (i + 1))
{
THROW_TEST_EXCEPTION("Invalid size of buffer! Expected " << ((i + 1) * 2) << ", found " << size);
}
}
for (unsigned int i = 0; i < 1000; ++i)
{
for (unsigned int j = 0; j < 2; ++j)
{
unsigned short const current = testStream.front();
testStream.consume();
if (current != (5000 + i * 2 + j))
{
THROW_TEST_EXCEPTION("Invalid head of buffer! Expected " << ((i + 1000) * 5 + j) << ", found " << current);
}
}
}
}
catch (std::exception const& e)
{
std::cerr << "ERROR: " << e.what() << std::endl;
return 1;
}
return 0;
}
long ClientWriter::put_chunk(StreamBuffer entity){
PROFILE_ME;
if(entity.empty()){
LOG_POSEIDON_ERROR("You are not allowed to send an empty chunk");
DEBUG_THROW(BasicException, sslit("You are not allowed to send an empty chunk"));
}
StreamBuffer chunk;
char temp[64];
unsigned len = (unsigned)std::sprintf(temp, "%llx\r\n", (unsigned long long)entity.size());
chunk.put(temp, len);
chunk.splice(entity);
chunk.put("\r\n");
return on_encoded_data_avail(STD_MOVE(chunk));
}
int main(int argc, char **argv){
const int freq = 16000;
// declare stream buffer ------------------------------------------------------------
StreamBuffer<float> inBuffer;
StreamBuffer<float> Buffer_H_short;
StreamBuffer<float> Buffer_P_short;
StreamBuffer<float> Buffer_H_long;
StreamBuffer<float> Buffer_P_long;
StreamBuffer<float> Buffer_karaoke;
StreamBuffer<float> outBuffer;
// StreamBuffer<float> Buffer_H_long_tmp;
// Audio IO -------------------------------------------------------------------------
AudioDevice* audio_thread = AudioDevice::getInstance();
audio_thread->init(1, freq, 1024, &inBuffer, &outBuffer);
// HPSS short ------------------------------------------------------------------------
// HPSS_pipe HPSS_short(7, 256, 128, 10, 10);
HPSS_pipe HPSS_short(7, 512, 256, 10, 10);
// HPSS_short.setBuffer(&inBuffer, &Buffer_H_short, &Buffer_P_short);
HPSS_short.setBuffer(&Buffer_P_long, &Buffer_H_short, &Buffer_P_short);
// HPSS long --------------------------------------------------------------------------
// HPSS_pipe HPSS_long(10, 4096, 2048, 10, 10);
// HPSS_pipe_long HPSS_long(7, 4096, 2048, 10, 10);
// HPSS_pipe HPSS_long(7, 2048, 1024, 15, 10);
HPSS_pipe HPSS_long(7, 2048, 1024, 10, 10);
// HPSS_long.setBuffer(&Buffer_H_short, &Buffer_H_long, &Buffer_P_long);
HPSS_long.setBuffer(&inBuffer, &Buffer_H_long, &Buffer_P_long);
// HPSS_long.set_filter_a(400);
// GUI --------------------------------------------------------------------------------
GUI panel(argc, argv);
// Timbre changer ---------------------------------------------------------------------
// too heavy
/*
Filter equalizer_H(256, 128);
equalizer_H.setBuffer(&Buffer_H_long, &Buffer_H_long_tmp);
equalizer_H.set_filter_a(300.);
equalizer_H.set_filter_b(500.);
*/
// Adder ------------------------------------------------------------------------------
StreamAdder adder(2048, &panel); // GUIはパラメータではなくて逆にする。
adder.add_input_stream(&Buffer_P_short); adder.set_multiply(0, 1.0);
adder.add_input_stream(&Buffer_H_long); adder.set_multiply(1, 1.0);
// adder.add_input_stream(&Buffer_P_long); adder.set_multiply(2, 0.0); // control through GUI (todo)
adder.add_input_stream(&Buffer_H_short); adder.set_multiply(2, 0.0); // control through GUI (todo)
adder.set_output_stream(&Buffer_karaoke);
// PitchConversion ---------------------------------------------------------------------
TempoPitch converter;
// converter.init(1024, 128, 1, 7, 10, freq, &panel);//パラメータは？
// converter.init(1024, 128, 1 /* channel */, 7 /* block */, 12 /* coeff */, freq, &panel);//
converter.init(1024 * 2, 128 * 2, 1 /* channel */, 7 /* block */, 15 /* coeff */, freq, &panel);//param? // frame should be very long
// converter.init(1024 * 4, 128 * 4, 1 /* channel */, 7 /* block */, 12 /* coeff */, freq, &panel);//
//coeff 5, 7 change timbre. 12 OK. 40 too large
converter.setBuffer(&Buffer_karaoke, &outBuffer);
// start ---------------------------------------------------------------------------
// equalizer_H.start();
audio_thread->start();
HPSS_short.start();
HPSS_long.start();
adder.start();
converter.start();
panel.start();
// display something every 1[s] -----------------------------------------------------------------
int sec = 0;
while(1){
sec++;
usleep(1000000);
fprintf(stderr, "%3d[ms] %3d[ms] %3d[ms] \t HPSS: short %d[times/s] long %d[times/s] phase %d[times/s] audio trial %d \n",
(int)((double)inBuffer.size() / freq * 1000),
(int)((double)Buffer_karaoke.size() / freq * 1000),
(int)((double)outBuffer.size() / freq * 1000),
HPSS_short.get_exec_count_diff(),
HPSS_long. get_exec_count_diff(),
converter. get_exec_count_diff(),
audio_thread->get_exec_count()
);
fprintf(stderr, "sec: %d min %d sec \t ave: short %d[times/s] long %d[times/s] phase %d[times/s] \n\n",
sec / 60,
sec % 60,
HPSS_short.get_exec_count_ave(),
HPSS_long. get_exec_count_ave(),
converter. get_exec_count_ave()
);
if(panel.getstop()){audio_thread->stop();}
if(panel.getquit()){break;}
}
audio_thread->kill();
// GUI kill
return 0;
}
long ClientWriter::put_request(RequestHeaders request_headers, StreamBuffer entity){
PROFILE_ME;
StreamBuffer data;
data.put(get_string_from_verb(request_headers.verb));
data.put(' ');
data.put(request_headers.uri);
if(!request_headers.get_params.empty()){
data.put('?');
data.put(url_encoded_from_optional_map(request_headers.get_params));
}
char temp[64];
const unsigned ver_major = request_headers.version / 10000, ver_minor = request_headers.version % 10000;
unsigned len = (unsigned)std::sprintf(temp, " HTTP/%u.%u\r\n", ver_major, ver_minor);
data.put(temp, len);
AUTO_REF(headers, request_headers.headers);
if(entity.empty()){
headers.erase("Content-Type");
headers.erase("Transfer-Encoding");
if((request_headers.verb == V_POST) || (request_headers.verb == V_PUT)){
headers.set(sslit("Content-Length"), STR_0);
} else {
headers.erase("Content-Length");
}
} else {
if(!headers.has("Content-Type")){
headers.set(sslit("Content-Type"), "application/x-www-form-urlencoded; charset=utf-8");
}
AUTO(transfer_encoding, headers.get("Transfer-Encoding"));
AUTO(pos, transfer_encoding.find(';'));
if(pos != std::string::npos){
transfer_encoding.erase(pos);
}
transfer_encoding = to_lower_case(trim(STD_MOVE(transfer_encoding)));
if(transfer_encoding.empty() || (transfer_encoding == STR_IDENTITY)){
headers.set(sslit("Content-Length"), boost::lexical_cast<std::string>(entity.size()));
} else {
// 只有一个 chunk。
StreamBuffer chunk;
len = (unsigned)std::sprintf(temp, "%llx\r\n", (unsigned long long)entity.size());
chunk.put(temp, len);
chunk.splice(entity);
chunk.put("\r\n0\r\n\r\n");
entity.swap(chunk);
}
}
for(AUTO(it, headers.begin()); it != headers.end(); ++it){
data.put(it->first.get());
data.put(": ");
data.put(it->second);
data.put("\r\n");
}
data.put("\r\n");
data.splice(entity);
return on_encoded_data_avail(STD_MOVE(data));
}
