Cvirtual_binary Caud_file::decode()
{
Cvirtual_binary d;
int cb_audio = get_cb_sample() * get_c_samples();
switch (header().compression)
{
case 1:
{
byte* w = d.write_start(cb_audio);
for (int chunk_i = 0; w != d.data_end(); chunk_i++)
{
const t_aud_chunk_header& header = *get_chunk_header(chunk_i);
aud_decode_ws_chunk(get_chunk_data(chunk_i), reinterpret_cast<char*>(w), header.size_in, header.size_out);
w += header.size_out;
}
}
break;
case 0x63:
{
aud_decode decode;
decode.init();
byte* w = d.write_start(cb_audio);
for (int chunk_i = 0; w != d.data_end(); chunk_i++)
{
const t_aud_chunk_header* header = get_chunk_header(chunk_i);
if (!header)
break;
decode.decode_chunk(get_chunk_data(chunk_i), reinterpret_cast<short*>(w), header->size_out / get_cb_sample());
w += header->size_out;
}
}
break;
}
return d;
}
void save_binary_chunk(void const* address, std::size_t count) // override
{
if (filter_ || chunks_ == 0 || count < HPX_ZERO_COPY_SERIALIZATION_THRESHOLD) {
// fall back to serialization_chunk-less archive
this->output_container::save_binary(address, count);
}
else {
HPX_ASSERT(get_num_chunks() > current_chunk_);
HPX_ASSERT(
get_chunk_type(current_chunk_) == chunk_type_index ||
get_chunk_size(current_chunk_) != 0);
// complement current serialization_chunk by setting its length
if (get_chunk_type(current_chunk_) == chunk_type_index)
{
HPX_ASSERT(get_chunk_size(current_chunk_) == 0);
set_chunk_size(current_chunk_,
current_ - get_chunk_data(current_chunk_).index_);
}
// add a new serialization_chunk referring to the external buffer
chunks_->push_back(create_pointer_chunk(address, count));
++current_chunk_;
}
}
void load_binary_chunk(void* address, std::size_t count) // override
{
HPX_ASSERT((std::int64_t)count >= 0);
if (chunks_ == nullptr ||
count < HPX_ZERO_COPY_SERIALIZATION_THRESHOLD ||
filter_)
{
// fall back to serialization_chunk-less archive
this->input_container::load_binary(address, count);
}
else {
HPX_ASSERT(current_chunk_ != std::size_t(-1));
HPX_ASSERT(get_chunk_type(current_chunk_) == chunk_type_pointer);
if (get_chunk_size(current_chunk_) != count)
{
HPX_THROW_EXCEPTION(serialization_error
, "input_container::load_binary_chunk"
, "archive data bstream data chunk size mismatch");
return;
}
// unfortunately we can't implement a zero copy policy on
// the receiving end
// as the memory was already allocated by the serialization code
std::memcpy(address, get_chunk_data(current_chunk_).pos_, count);
++current_chunk_;
}
}
static void
set_first_body_data(client_t *client, char *data, size_t datalen)
{
write_bucket *bucket = client->bucket;
if(data){
if(client->chunked_response){
char *lendata = NULL;
Py_ssize_t len = 0;
PyObject *chunk_data = get_chunk_data(datalen);
//TODO CHECK ERROR
PyBytes_AsStringAndSize(chunk_data, &lendata, &len);
set_chunked_data(bucket, lendata, len, data, datalen);
bucket->chunk_data = chunk_data;
}else{
set2bucket(bucket, data, datalen);
}
}
}
~output_container()
{
if (filter_) {
std::size_t written = 0;
if (cont_.size() < current_)
cont_.resize(current_);
current_ = start_compressing_at_;
do {
bool flushed = filter_->flush(&cont_[current_],
cont_.size()-current_, written);
current_ += written;
if (flushed)
break;
// resize container
cont_.resize(cont_.size()*2);
} while (true);
cont_.resize(current_); // truncate container
}
else if (chunks_) {
HPX_ASSERT(get_num_chunks() > current_chunk_);
HPX_ASSERT(
get_chunk_type(current_chunk_) == chunk_type_index ||
get_chunk_size(current_chunk_) != 0);
// complement current serialization_chunk by setting its length
if (get_chunk_type(current_chunk_) == chunk_type_index)
{
HPX_ASSERT(get_chunk_size(current_chunk_) == 0);
set_chunk_size(current_chunk_,
current_ - get_chunk_data(current_chunk_).index_);
}
}
}
static response_status
process_write(client_t *client)
{
PyObject *iterator = NULL;
PyObject *item, *chunk_data = NULL;
char *buf = NULL, *lendata = NULL;
Py_ssize_t buflen, len;
write_bucket *bucket = NULL;
response_status ret;
DEBUG("process_write start");
iterator = client->response_iter;
if(iterator != NULL){
while((item = PyIter_Next(iterator))){
if(PyBytes_Check(item)){
//TODO CHECK
PyBytes_AsStringAndSize(item, &buf, &buflen);
//write
if(client->chunked_response){
bucket = new_write_bucket(client->fd, 4);
if(bucket == NULL){
/* write_error_log(__FILE__, __LINE__); */
call_error_logger();
Py_DECREF(item);
return STATUS_ERROR;
}
lendata = NULL;
len = 0;
chunk_data = get_chunk_data(buflen);
//TODO CHECK ERROR
PyBytes_AsStringAndSize(chunk_data, &lendata, &len);
set_chunked_data(bucket, lendata, len, buf, buflen);
bucket->chunk_data = chunk_data;
}else{
bucket = new_write_bucket(client->fd, 1);
if(bucket == NULL){
/* write_error_log(__FILE__, __LINE__); */
call_error_logger();
Py_DECREF(item);
return STATUS_ERROR;
}
set2bucket(bucket, buf, buflen);
}
bucket->temp1 = item;
ret = writev_bucket(bucket);
if(ret != STATUS_OK){
client->bucket = bucket;
/* Py_DECREF(item); */
return ret;
}
free_write_bucket(bucket);
//mark
client->write_bytes += buflen;
//check write_bytes/content_length
if(client->content_length_set){
if(client->content_length <= client->write_bytes){
// all done
/* Py_DECREF(item); */
break;
}
}
/* Py_DECREF(item); */
}else{
PyErr_SetString(PyExc_TypeError, "response item must be a byte string");
Py_DECREF(item);
if (PyErr_Occurred()){
/* client->bad_request_code = 500; */
client->status_code = 500;
/* write_error_log(__FILE__, __LINE__); */
call_error_logger();
return STATUS_ERROR;
}
}
}
if(PyErr_Occurred()){
return STATUS_ERROR;
}
if(client->chunked_response){
DEBUG("write last chunk");
//last packet
bucket = new_write_bucket(client->fd, 3);
if(bucket == NULL){
/* write_error_log(__FILE__, __LINE__); */
call_error_logger();
return STATUS_ERROR;
}
set_last_chunked_data(bucket);
writev_bucket(bucket);
free_write_bucket(bucket);
}
return close_response(client);
}
return STATUS_OK;
}
