////--- Write to buffer
int RingBuffer_write (RingBuffer* buffer, float* data, int length){
//buffer --> The buffer where to right
//data --> A pointer to the memory containing the data to be written
//length --> This is the total number of BYTES to be copied.(Used in memcpy)
// Length is defined by: [the number of elements in data]x[size of each element]
// First check if there is available data , if not, reset the indexes to 0
if(RingBuffer_available_data(buffer) == 0) {
buffer->start = buffer->end = 0;
//printf("start=end=0 from write\n");
}
//check if the number of input elements is greater thant the space left in buffer
if(length > RingBuffer_available_space(buffer)){
printf("Not enough space, ocuppied: %d of:%d, inputOf: %d",
RingBuffer_available_data(buffer), buffer->length,length);
return -1;
}
//if it is save to write you can proceed
void *result = memcpy(RingBuffer_ends_at(buffer), data, length*sizeof(float));
if (result==NULL) {
printf("Failed to write data into buffer.");
}
//Commit the write operation
RingBuffer_commit_write(buffer, length);
//return the number of elements written
return length;
}
bstring RingBuffer_gets(RingBuffer *buffer, int amount) {
check(amount > 0, "need more than 0 for gets, you gave: %d", amount);
check_debug(amount <= RingBuffer_available_data(buffer), "not enough in the buffer");
bstring result = blk2bstr(RingBuffer_starts_at(buffer), amount);
check(result != NULL, "failed to create result");
check(blength(result) == amount, "wrong result length");
RingBuffer_commit_read(buffer, amount);
assert(RingBuffer_available_data(buffer) >= 0 && "error in read_commit");
return result;
error:
return NULL;
}
int read_some(RingBuffer *buffer, int fd, int is_socket)
{
int rc = 0;
if (RingBuffer_available_data(buffer) == 0) {
buffer->start = buffer->end = 0;
}
if (is_socket) {
rc = recv(fd, RingBuffer_starts_at(buffer),
RingBuffer_available_space(buffer), 0);
} else {
rc = read(fd, RingBuffer_starts_at(buffer),
RingBuffer_available_space(buffer));
}
check(rc >= 0, "Failed to read from fd: %d", fd);
RingBuffer_commit_write(buffer, rc);
return rc;
error:
return -1;
}
int RingBuffer_read(RingBuffer *buffer, char *target, int amount) {
check_debug(amount <- RingBuffer_available_data(buffer),
"not enough in the buffer: has %d, needs %d",
RingBuffer_available_data(buffer), amount);
void *result = memcpy(target, RingBuffer_starts_at(buffer), amount);
check(result != NULL, "failed to write buffer into data");
RingBuffer_commit_read(buffer, amount);
if (buffer->end == buffer->start) {
buffer->start = buffer->end = 0;
}
return amount;
error:
return -1;
}
////--- Read buffer
int RingBuffer_read(RingBuffer *buffer, float *target, int amount){
if (amount > RingBuffer_available_data(buffer)) {
printf("Not enough in the buffer: has %d, needs %d", RingBuffer_available_data(buffer), amount);
return -1;
}
void *result = memcpy(target, RingBuffer_starts_at(buffer), amount*sizeof(float));
if (result==NULL) {
printf("Failed to write buffer into data.");
}
RingBuffer_commit_read(buffer, amount);
if(buffer->end == buffer->start) {
buffer->start = buffer->end = 0;
//printf("start=end=0 from read\n");
}
return amount;
}
int RingBuffer_write(RingBuffer* buffer, char* data, int length) {
if(RingBuffer_available_data(buffer) == 0) {
buffer->start = buffer->end = 0;
}
check(length <= RingBuffer_available_space(buffer),
"Not enough space: %d request, %d available",
RingBuffer_available_data(buffer), length);
void* result = memcpy(RingBuffer_ends_at(buffer), data, length);
check(result != NULL, "Failed to write data into buffer.");
RingBuffer_commit_write(buffer, length);
return length;
error:
return -1;
}
int read(char* dest, int length)
{
check_debug(amount <= RingBuffer_available_data(buffer),
"Not enough in the buffer: has %d, needs %d",
RingBuffer_available_data(buffer), amount);
void *result = memcpy(target, RingBuffer_starts_at(buffer), amount);
check(result != NULL, "Failed to write buffer into data.");
// commit read
this->start = (this->start + length) % this->size;
if (this->end == this->start)
{
this->start = this->end = 0;
}
return length;
}
bool RingBuffer_readbyte(RingBuffer *buffer, char* target){
if(RingBuffer_available_data(buffer) == 0)
return false;
*target = buffer->buffer[buffer->start];
RingBuffer_commit_read(buffer, 1);
if(buffer->end == buffer->start) {
buffer->start = buffer->end = 0;
}
return true;
}
bool RingBuffer_writebyte(RingBuffer *buffer, char byte){
if(RingBuffer_available_data(buffer) == 0) {
buffer->start = buffer->end = 0;
}
if(1 > RingBuffer_available_space(buffer))
return false;
buffer->buffer[buffer->end] = byte;
RingBuffer_commit_write(buffer, 1);
return true;
}
int RingBuffer_read(RingBuffer *buffer, char *target, int amount)
{
if(amount > RingBuffer_available_data(buffer)) {
debug("Available is: %d, amount: %d", RingBuffer_available_space(buffer), amount);
return -1;
}
void *result = memcpy(target, buffer->buffer + buffer->start, amount);
check(result != NULL, "Failed to write buffer into data.");
buffer->start = (buffer->start + amount) % buffer->length;
return amount;
error:
return -1;
}
int RingBuffer_read(RingBuffer *buffer, char *target, int amount)
{
if(amount > RingBuffer_available_data(buffer))
return -1;
unsigned int i;
int temp = buffer->start;
for(i = 0; i < amount; i++){
target[i] = buffer->buffer[temp];
temp++;
temp %= buffer->length;
}
RingBuffer_commit_read(buffer, amount);
if(buffer->end == buffer->start) {
buffer->start = buffer->end = 0;
}
return amount;
}
int RingBuffer_write(RingBuffer *buffer, char *data, int amount)
{
if(RingBuffer_available_data(buffer) == 0) {
buffer->start = buffer->end = 0;
}
if(amount > RingBuffer_available_space(buffer))
return -1;
unsigned int i;
int temp = buffer->end;
for(i = 0; i < amount; i++){
buffer->buffer[temp] = data[i];
temp++;
temp %= buffer->length;
}
RingBuffer_commit_write(buffer, amount);
return amount;
}
char *test_read_write()
{
RingBuffer_puts(rbuf, &test_data_0);
mu_assert(rbuf->end == 6, "ends at not reset correctly");
mu_assert(RingBuffer_empty(rbuf) == 0, "not actually empty");
RingBuffer_puts(rbuf, &test_data_1);
mu_assert(rbuf->end == 34, "ends at not reset correctly");
char *data_1 = malloc(sizeof(char) * 6);
RingBuffer_read(rbuf, data_1, 6);
mu_assert(bstrcmp(bfromcstr(data_1), &test_data_0) == 0,
"read did not return proper string"
);
mu_assert(rbuf->start == 6, "did not reset start correctly");
char *data_2 = malloc(sizeof(char) * 28);
RingBuffer_read(rbuf, data_2, 28);
mu_assert(bstrcmp(bfromcstr(data_2), &test_data_1) == 0,
"read did not return proper string"
);
mu_assert(rbuf->start == 0, "did not reset start correctly");
mu_assert(rbuf->end == 0, "did not reset end correctly");
RingBuffer_puts(rbuf, &test_data_2);
RingBuffer_puts(rbuf, &test_data_3);
mu_assert(rbuf->start == 0, "start not maintained");
mu_assert(rbuf->end == 64, "end not set correctly");
mu_assert(RingBuffer_full(rbuf) == 1, "RingBuffer actually full");
mu_assert(RingBuffer_available_space(rbuf) == 0, "RingBuffer has no space");
mu_assert(RingBuffer_available_data(rbuf) == 64, "RingBuffer has wrong available data");
bstring data_3 = RingBuffer_get_all(rbuf);
bstring expected = bformat("%s%s", bdata(&test_data_2), bdata(&test_data_3));
mu_assert(bstrcmp(data_3, expected) == 0, "data not returned correctly");
mu_assert(RingBuffer_empty(rbuf) == 1, "RingBuffer should be empty");
return NULL;
}
int getAvailableData(RingBuffer *buffer){
return RingBuffer_available_data(buffer);
}
void
do_read(evutil_socket_t fd, short events, void *arg)
{
(void) events;
struct fd_state *state = arg;
ssize_t result;
while (1) {
assert(state->write_event);
result = recv(fd, RingBuffer_ends_at(state->buffer), RingBuffer_available_space(state->buffer), 0);
if (result <= 0)
break;
state->rtmp->total_read += result;
RingBuffer_commit_write(state->buffer, result);
while (RingBuffer_available_data(state->buffer) > 0) {
RtmpOutputMessage *this_output = rtmp_create_output_message();
int result_multiplex = rtmp_multiplex(state->rtmp, state->buffer, this_output);
check(result_multiplex >= 0, "rtmp_multiplex error %d", result_multiplex);
if (state->rtmp->end == 1) {
event_del(state->write_event);
rtmp_destroy_output_message(this_output);
free_fd_state(state);
return;
}
if (this_output->length > 0) {
printf("Add block with length=%u\n", this_output->length);
List_push(state->outputs, this_output);
assert(state->write_event);
event_add(state->write_event, NULL);
} else {
rtmp_destroy_output_message(this_output);
}
if (result_multiplex == 0) break;
}
printf("total_read=%u, last_total_read=%u\n", state->rtmp->total_read, state->rtmp->last_total_read);
if (rtmp_should_acknowledge(state->rtmp) == 1) {
RtmpOutputMessage *ack = rtmp_create_output_message();
rtmp_allocate_output_message_content(ack, 16);
int i = 0;
unsigned char *msg = ack->message;
msg[i++] = 0x02;
msg[i++] = 0x00;msg[i++] = 0x00;msg[i++] = 0x00;
int_to_byte_array(4, msg, i, 3);i += 3;
msg[i++] = 0x03;
msg[i++] = 0x00;
msg[i++] = 0x00;
msg[i++] = 0x00;
msg[i++] = 0x00;
// msg[i++] = 0x03;
// msg[i++] = 0x00;msg[i++] = 0x00;msg[i++] = 0x04;
// msg[i++] = 0x00;msg[i++] = 0x00;msg[i++] = 0x00;msg[i++] = 0x00;
// msg[i++] = 0x00;msg[i++] = 0x00;msg[i++] = 0x00;
int_to_byte_array(state->rtmp->total_read, msg, i, 4);i += 4;
List_push(state->outputs, ack);
assert(state->write_event);
event_add(state->write_event, NULL);
state->rtmp->last_total_read = state->rtmp->total_read;
}
}
if (result == 0) {
free_fd_state(state);
} else if (result < 0) {
if (errno == EAGAIN) // XXXX use evutil macro
return;
perror("recv");
free_fd_state(state);
}
error:
free_fd_state(state);
return;
}
