// Return <0 on error, 0 on need more input, 1 on success (and *frame set). // To actually advance the read pointer, set s->input->samples=0 afterwards. static int read_input_frame(struct af_instance *af, AVFrame *frame) { af_ac3enc_t *s = af->priv; if (!fill_buffer(af)) return 0; // need more input if (mp_audio_to_avframe(s->input, frame) < 0) return -1; return 1; }
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence) { int64_t offset1; int64_t pos; int force = whence & AVSEEK_FORCE; whence &= ~AVSEEK_FORCE; if(!s) return AVERROR(EINVAL); pos = s->pos - (s->write_flag ? 0 : (s->buf_end - s->buffer)); if (whence != SEEK_CUR && whence != SEEK_SET) return AVERROR(EINVAL); if (whence == SEEK_CUR) { offset1 = pos + (s->buf_ptr - s->buffer); if (offset == 0) return offset1; offset += offset1; } offset1 = offset - pos; if (!s->must_flush && offset1 >= 0 && offset1 <= (s->buf_end - s->buffer)) { /* can do the seek inside the buffer */ s->buf_ptr = s->buffer + offset1; } else if ((!s->seekable || offset1 <= s->buf_end + SHORT_SEEK_THRESHOLD - s->buffer) && !s->write_flag && offset1 >= 0 && (whence != SEEK_END || force)) { while(s->pos < offset && !s->eof_reached) fill_buffer(s); if (s->eof_reached) return AVERROR_EOF; s->buf_ptr = s->buf_end + offset - s->pos; } else { int64_t res; if (s->write_flag) { flush_buffer(s); s->must_flush = 1; } if (!s->seek) return AVERROR(EPIPE); if ((res = s->seek(s->opaque, offset, SEEK_SET)) < 0) return res; if (!s->write_flag) s->buf_end = s->buffer; s->buf_ptr = s->buffer; s->pos = offset; } s->eof_reached = 0; return offset; }
/** * Gets a character from the buffer. * * This version only gets a character, but doesn't consume it. * * @returns The character read. * @retval EOF The end of input has been read. */ int peek() { fill_buffer(); if(UNLIKELY(eof_)) { return EOF; } else { /* See get() */ return static_cast<unsigned char>(buffer_[buffer_offset_]); } }
/* Returns the next CRLF terminated line from the client */ static char *get_line(multipart_buffer *self) { char* ptr = next_line(self); if (!ptr) { fill_buffer(self); ptr = next_line(self); } return ptr; }
TreeIt& TreeIt::operator++() { if(buffer.size() > 1) buffer.pop_back(); else { buffer.clear(); while(buffer.empty() && l1_cur[0] < l1_size) fill_buffer(); if(buffer.empty()) move_to_end(); } return *this; }
ATF_TC_BODY(rewrite__too_long_with_newlines, tc) { char input[1000]; fill_buffer("failed: ", "line\n", input, sizeof(input)); // This is quite awful but is the price we have to pay for using fixed-size // buffers in the code for simplicity and speed... char exp_output[1024 + 8 /* strlen("failed: ") */ + 1]; fill_buffer("failed: ", "line<<NEWLINE>>", exp_output, sizeof(exp_output)); exp_output[sizeof(exp_output) - 2] = '\n'; bool success; atf_utils_create_file("in.txt", "%s", input); RE(kyua_atf_result_rewrite("in.txt", "out.txt", generate_wait_exitstatus(EXIT_FAILURE), false, &success)); atf_utils_cat_file("out.txt", "OUTPUT: "); printf("EXPECTED: %s", exp_output); ATF_REQUIRE(atf_utils_compare_file("out.txt", exp_output)); ATF_REQUIRE_EQ(false, success); }
int iobuf_getc(iofile_t file) { ssize_t partial_read = fill_buffer(file); if(partial_read < 0) return partial_read; else if(!partial_read) return GETC_EOF; file->read_buf++; file->read_size--; return *file->read_buf; }
void tcp_fragment_wrapper::on_receive(const void* data, size_t size) { while (size > 0) { bool reading_size = partial_msg_.size() < sizeof(size_hdr_t); if (reading_size) reading_size = !fill_buffer(sizeof(size_hdr_t) - partial_msg_.size(), data, size); if (!reading_size) { size_hdr_t sz = *reinterpret_cast<const size_hdr_t*>(&partial_msg_.front()); if(fill_buffer(sizeof(size_hdr_t) + sz - partial_msg_.size(), data, size)) { on_receive_(&partial_msg_.front() + sizeof(size_hdr_t), sz); partial_msg_.clear(); } } } }
/** * getfssec: Get multiple clusters from a file, given the starting cluster. * In this case, get multiple blocks from a specific TCP connection. * * @param: fs, the fs_info structure address, in pxe, we don't use this. * @param: buf, buffer to store the read data * @param: openfile, TFTP socket pointer * @param: blocks, 512-byte block count; 0FFFFh = until end of file * * @return: the bytes read * */ static uint32_t pxe_getfssec(struct file *file, char *buf, int blocks, bool *have_more) { struct inode *inode = file->inode; struct pxe_pvt_inode *socket = PVT(inode); int count = blocks; int chunk; int bytes_read = 0; count <<= TFTP_BLOCKSIZE_LG2; while (count) { fill_buffer(inode); /* If we have no 'fresh' buffer, get it */ if (!socket->tftp_bytesleft) break; chunk = count; if (chunk > socket->tftp_bytesleft) chunk = socket->tftp_bytesleft; socket->tftp_bytesleft -= chunk; memcpy(buf, socket->tftp_dataptr, chunk); socket->tftp_dataptr += chunk; buf += chunk; bytes_read += chunk; count -= chunk; } if (socket->tftp_bytesleft || (socket->tftp_filepos < inode->size)) { fill_buffer(inode); *have_more = 1; } else if (socket->tftp_goteof) { /* * The socket is closed and the buffer drained; the caller will * call close_file and therefore free the socket. */ *have_more = 0; } return bytes_read; }
bool init_pages (uint8_t file_id) { if (active_fid != INVALID_FID) save_pages(); active_fid = file_id; for (uint8_t i = 0; i < 4; i++) { page[i].num_bytes = 0; page[i].modified = false; page[i].file_offset = INVALID_OFFSET; } // get the file's size on disk if (!m_sd_seek (file_id, FILE_END_POS)) return false; if (!m_sd_get_seek_pos (file_id, &active_fid_disk_size)) { m_sd_seek (file_id, 0); return false; } // seek to the beginning of the file if (!m_sd_seek (file_id, 0)) return false; // set up the page pointers prevPage = &page[0]; currentPage = &page[1]; editOverflowPage = &page[2]; // initialize the "previous page" buffer prevPage->num_bytes = 0; prevPage->file_offset = 0; prevPage->modified = false; // initialize and read into the "current page" buffer currentPage->num_bytes = 0; currentPage->file_offset = 0; currentPage->modified = false; if (!fill_buffer (currentPage)) return false; // initialize the "edit overflow" buffer editOverflowPage->num_bytes = 0; editOverflowPage->file_offset = currentPage->num_bytes; editOverflowPage->modified = false; return true; }
static int myth_read(const char *path, char *buf, size_t size, off_t offset, struct fuse_file_info *fi) { int tot, len = 0; debug("%s(): path '%s' size %lld\n", __FUNCTION__, path, (long long)size); if (strcmp(path, README_PATH) == 0) { return readme_read(path, buf, size, offset, fi); } if (fi->fh < 0) { return -ENOENT; } if (files[fi->fh].offset != offset) { if (do_seek(fi->fh, offset, SEEK_SET) < 0) { goto fail; } } tot = 0; while (size > 0) { len = (size > MAX_BSIZE) ? MAX_BSIZE : size; if ((len=fill_buffer(fi->fh, buf+tot, len)) <= 0) break; size -= len; tot += len; } files[fi->fh].offset = offset + tot; debug("%s(): read %d bytes at %lld (len %d)\n", __FUNCTION__, tot, (long long)offset, len); if (len < 0) { goto fail; } return tot; fail: debug("%s(): shutting down file connection!\n", __FUNCTION__); pthread_mutex_lock(&mutex); ref_release(files[fi->fh].file); memset(files+fi->fh, 0, sizeof(files[0])); pthread_mutex_unlock(&mutex); return -ENOENT; }
char * url_fgets(char *ptr, int size, URL_FILE *file) { int want = size - 1;/* always need to leave room for zero termination */ int loop; switch(file->type) { case CFTYPE_FILE: ptr = fgets(ptr,size,file->handle.file); break; case CFTYPE_CURL: fill_buffer(file,want,1); /* check if theres data in the buffer - if not fill either errored or * EOF */ if(!file->buffer_pos) return NULL; /* ensure only available data is considered */ if(file->buffer_pos < want) want = file->buffer_pos; /*buffer contains data */ /* look for newline or eof */ for(loop=0;loop < want;loop++) { if(file->buffer[loop] == '\n') { want=loop+1;/* include newline */ break; } } /* xfer data to caller */ memcpy(ptr, file->buffer, want); ptr[want]=0;/* allways null terminate */ use_buffer(file,want); /*printf("(fgets) return %d bytes %d left\n", want,file->buffer_pos);*/ break; default: /* unknown or supported type - oh dear */ ptr=NULL; errno=EBADF; break; } return ptr;/*success */ }
extern void skip_buffered_space(void) { while ((*buf_ptr == ' ') || (*buf_ptr == TAB)) { buf_ptr++; if (buf_ptr >= buf_end) { fill_buffer(); } } }
static gboolean gz_handle_read (GZHandle *gz, guchar *buffer, gsize num_bytes, gsize * bytes_read) { z_stream *zstream; gboolean res; int z_result; *bytes_read = 0; zstream = &gz->zstream; if (gz->last_z_result != Z_OK) { if (gz->last_z_result == Z_STREAM_END) { *bytes_read = 0; return TRUE; } else { return result_from_z_result (gz->last_z_result); } } else if (gz->last_str_result == FALSE) { return FALSE; } zstream->next_out = buffer; zstream->avail_out = num_bytes; while (zstream->avail_out != 0) { res = fill_buffer (gz, num_bytes); if (!res) { return res; } z_result = inflate (zstream, Z_NO_FLUSH); if (z_result == Z_STREAM_END) { gz->last_z_result = z_result; break; } else if (z_result != Z_OK) { gz->last_z_result = z_result; } if (gz->last_z_result != Z_OK && zstream->avail_out == num_bytes) { return result_from_z_result (gz->last_z_result); } } *bytes_read = num_bytes - zstream->avail_out; return TRUE; }
static void * reader_thread (void * data) { struct neon_handle * h = data; pthread_mutex_lock (& h->reader_status.mutex); while (h->reader_status.reading) { /* Hit the network only if we have more than NEON_NETBLKSIZE of free buffer */ if (NEON_NETBLKSIZE < free_rb_locked (& h->rb)) { pthread_mutex_unlock (& h->reader_status.mutex); FillBufferResult ret = fill_buffer (h); pthread_mutex_lock (& h->reader_status.mutex); /* Wake up main thread if it is waiting. */ pthread_cond_broadcast (& h->reader_status.cond); if (ret == FILL_BUFFER_ERROR) { _ERROR ("<%p> Error while reading from the network. " "Terminating reader thread", (void *) h); h->reader_status.status = NEON_READER_ERROR; pthread_mutex_unlock (& h->reader_status.mutex); return NULL; } else if (ret == FILL_BUFFER_EOF) { _DEBUG ("<%p> EOF encountered while reading from the network. " "Terminating reader thread", (void *) h); h->reader_status.status = NEON_READER_EOF; pthread_mutex_unlock (& h->reader_status.mutex); return NULL; } } else { /* Not enough free space in the buffer. * Sleep until the main thread wakes us up. */ pthread_cond_wait (& h->reader_status.cond, & h->reader_status.mutex); } } _DEBUG ("<%p> Reader thread terminating gracefully", h); h->reader_status.status = NEON_READER_TERM; pthread_mutex_unlock (& h->reader_status.mutex); return NULL; }
offset_t url_fseek(ByteIOContext *s, offset_t offset, int whence) { offset_t offset1; offset_t pos; if(!s) return AVERROR(EINVAL); pos = s->pos - (s->write_flag ? 0 : (s->buf_end - s->buffer)); if (whence != SEEK_CUR && whence != SEEK_SET) return AVERROR(EINVAL); if (whence == SEEK_CUR) { offset1 = pos + (s->buf_ptr - s->buffer); if (offset == 0) return offset1; offset += offset1; } offset1 = offset - pos; if (!s->must_flush && offset1 >= 0 && offset1 < (s->buf_end - s->buffer)) { /* can do the seek inside the buffer */ s->buf_ptr = s->buffer + offset1; } else if(s->is_streamed && !s->write_flag && offset1 >= 0 && offset1 < (s->buf_end - s->buffer) + (1<<16)){ while(s->pos < offset && !s->eof_reached) fill_buffer(s); if (s->eof_reached) return AVERROR(EPIPE); s->buf_ptr = s->buf_end + offset - s->pos; } else { offset_t res = AVERROR(EPIPE); #if defined(CONFIG_MUXERS) || defined(CONFIG_NETWORK) if (s->write_flag) { flush_buffer(s); s->must_flush = 1; } else #endif /* defined(CONFIG_MUXERS) || defined(CONFIG_NETWORK) */ { s->buf_end = s->buffer; } s->buf_ptr = s->buffer; if (!s->seek || (res = s->seek(s->opaque, offset, SEEK_SET)) < 0) return res; s->pos = offset; } s->eof_reached = 0; return offset; }
int url_feof(AVIOContext *s) { if(!s) return 0; if(s->eof_reached){ s->eof_reached=0; fill_buffer(s); } if(s->eof_reached){ /*if end level eof,make sure the buffer have no data.*/ return (s->buf_ptr >= s->buf_end); } return s->eof_reached; }
int fill_task_pid(struct target *target, struct threads *t) { uint32_t pid_addr = t->base_addr + PID; uint8_t buffer[4]; int retval = fill_buffer(target, pid_addr, buffer); if (retval == ERROR_OK) { uint32_t val = get_buffer(target, buffer); t->pid = val; } else LOG_ERROR("fill_task_pid: unable to read memory"); return retval; }
int comment_start_end(t_lem *lem, char *line, int break_loop, int fd) { int start_end; start_end = 0; if (line[1] != '#') fill_buffer(lem, line); if (lem->colony == -1 && line[1] == '#' && line[2] != '#' && \ (ft_strcmp(line, "##start") || ft_strcmp(line, "##end"))) return(-1); else if (line[1] == '#' && line[2] != '#' && \ (ft_strcmp(line, "##start") == 0 || ft_strcmp(line, "##end") == 0)) { start_end = (line[2] == 's') ? 1 : 2; fill_buffer(lem, line); ft_memdel((void**)&line); get_next_line(fd, &line); fill_buffer(lem, line); room_specs(line, lem, start_end); } ft_memdel((void**)&line); return (0); }
bool w_bser_decode_pdu_info(w_jbuffer_t *jr, w_stm_t stm, uint32_t bser_version, json_int_t *len, json_int_t *bser_capabilities, json_error_t *jerr) { json_int_t needed; if (bser_version == 2) { while (!bunser_int(jr->buf + jr->rpos, jr->wpos - jr->rpos, &needed, bser_capabilities)) { if (needed == -1) { snprintf(jerr->text, sizeof(jerr->text), "failed to read BSER capabilities"); return false; } if (!fill_buffer(jr, stm)) { snprintf(jerr->text, sizeof(jerr->text), "unable to fill buffer"); return false; } } jr->rpos += (uint32_t)needed; } while (!bunser_int(jr->buf + jr->rpos, jr->wpos - jr->rpos, &needed, len)) { if (needed == -1) { snprintf(jerr->text, sizeof(jerr->text), "failed to read PDU size"); return false; } if (!fill_buffer(jr, stm)) { snprintf(jerr->text, sizeof(jerr->text), "unable to fill buffer"); return false; } } jr->rpos += (uint32_t)needed; return true; }
size_t gut_file_read1(gut_file *f, unsigned char *cptr) { gut_buffer *buf = f->buf; // for convenience size_t read = 0; do { if (gut_buffer_availr(buf) == 0) { int success = fill_buffer(f); if (!success) break; // eof or error } // Should contain at least one byte now read = gut_buffer_read1(buf, cptr); } while(0); return read; }
static size_t curl_file_fread(ALLEGRO_FILE *f, void *ptr, size_t size) { CURL_FILE *cf = al_get_file_userdata(f); fill_buffer(cf, size); if (!cf->buffer_pos) return 0; if (cf->buffer_pos < size) size = cf->buffer_pos; memcpy(ptr, cf->buffer, size); use_buffer(cf, size); return size; }
void read_unquoted_field(wchar_t * buffer, int & buffer_size, int & i) { while (true) { int start = i; while (buffer[i] != delimiter && buffer[i] != L'\n' && i < buffer_size) { i += 1; } field_buffer_p->write(buffer + start, i - start); if (i < buffer_size || input_stream_p->eof()) { add_field_from_field_buffer(); return; } fill_buffer(buffer, buffer_size, i); } }
bool start() { file_ = std::ifstream(filename_, std::ios_base::binary | std::ios_base::in); if(file_.is_open()) { file_.seekg(0, std::ios::end); file_length_ = file_.tellg(); file_.seekg(0, std::ios::beg); if(!read_header(header_) || !header_.is_valid()) { file_.close(); return false; } return fill_buffer(); } return false; }
/* * Bilinear Interpolate a file of pixels. * * This version preserves the outside pixels and interps inside only. */ void binterp(FILE *ofp, int ix, int iy, int ox, int oy) { int i, j; double x, y, dx, dy, mid1, mid2; double xstep, ystep; unsigned char *op, *up, *lp; xstep = (double)(ix - 1) / (double)ox - 1.0e-6; ystep = (double)(iy - 1) / (double)oy - 1.0e-6; /* For each output pixel */ for (j = 0; j < oy; j++) { size_t ret; y = j * ystep; /* * Make sure we have this row (and the one after it) * in the buffer */ bufy = (int)y - buf_start; if (bufy < 0 || bufy >= buflines-1) { fill_buffer((int)y); bufy = (int)y - buf_start; } op = outbuf; for (i = 0; i < ox; i++) { x = i * xstep; dx = x - (int)x; dy = y - (int)y; /* Note: (1-a)*foo + a*bar = foo + a*(bar-foo) */ lp = &buffer[bufy*scanlen+(int)x]; up = &buffer[(bufy+1)*scanlen+(int)x]; mid1 = lp[0] + dx * ((double)lp[1] - (double)lp[0]); mid2 = up[0] + dx * ((double)up[1] - (double)up[0]); *op++ = mid1 + dy * (mid2 - mid1); } ret = fwrite(outbuf, 1, ox, ofp); if (ret != (size_t)ox) perror("fwrite"); } }
int main( void ) { buffer_t *buffer = malloc(sizeof(buffer_t)); FILE *fd = fopen("tst.raw", "w"); struct voice_t voice; float *sinevals = malloc(sizeof(float)*(SINE_SIZE+1)); wave_generate_sine(sinevals, SINE_SIZE); struct wave_t sinetable; sinetable.vals = sinevals; sinetable.size = SINE_SIZE; float *sawvals = malloc(sizeof(float)*(SAW_SIZE+1)); wave_generate_saw(sawvals, SAW_SIZE); struct wave_t sawtable; sawtable.vals = sawvals; sawtable.size = SAW_SIZE; /* float *trivals = malloc(sizeof(float)*(TRI_SIZE+1)); wave_generate_triangle(trivals, TRI_SIZE); struct wave_t tritable; tritable.vals = trivals; tritable.size = TRI_SIZE; */ struct wavetable_t wt; struct wave_t *waves = malloc(sizeof(struct wave_t)*2); waves[0] = sinetable; waves[1] = sinetable; wavetable_init(&wt, waves, 2); voice_init(&voice, &wt); voice_trigger(&voice); while(1) { fill_buffer(*buffer, &voice); out(*buffer, fd); if (voice.ops[3].aenv.state == ENV_STOPPED) break; } return 0; }
bool BinaryFileReader::open(string file_name) { this->file_name = file_name; file = fopen(file_name.c_str(), "rb"); if (file == NULL) { cerr << "Cannot open file " << file_name << " for reading" << endl; LOGE("Cannot open file %s for reading", file_name.c_str()); opened = false; return false; } fill_buffer(); opened = true; return true; }
static void skip_input_data( jpeg_decompress_struct * cinfo, long num_bytes ) { gil_jpeg_source_mgr* src = reinterpret_cast< gil_jpeg_source_mgr* >( cinfo->src ); if( num_bytes > 0 ) { while( num_bytes > long( src->_jsrc.bytes_in_buffer )) { num_bytes -= (long) src->_jsrc.bytes_in_buffer; fill_buffer( cinfo ); } src->_jsrc.next_input_byte += num_bytes; src->_jsrc.bytes_in_buffer -= num_bytes; } }
int main(int argc, char* argv[]) { double x; int i; for (i=1; i < argc; i++) { x = atof(argv[i]); printf("printf => %f\n", x); printf("FBSTP => "); fill_buffer(x); print_buffer(); putchar('\n'); } return 0; }
void SND_StreamSetPos (sfxbuffer_t *buffer, unsigned int pos) { float stepscale; sfx_t *sfx = buffer->sfx; sfxstream_t *stream = sfx->data.stream; wavinfo_t *info = &stream->wavinfo; stepscale = (float) info->rate / snd_shm->speed; buffer->head = buffer->tail = 0; buffer->pos = pos; stream->pos = pos; stream->seek (stream, buffer->pos * stepscale); fill_buffer (sfx, stream, buffer, info, pos); }