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