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