int write_flag,
void *opaque,
int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
- void (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
+ int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
int (*seek)(void *opaque, offset_t offset, int whence))
{
s->buffer = buffer;
s->pos = 0;
s->must_flush = 0;
s->eof_reached = 0;
+ s->error = 0;
s->is_streamed = 0;
s->max_packet_size = 0;
+ s->update_checksum= NULL;
return 0;
}
static void flush_buffer(ByteIOContext *s)
{
if (s->buf_ptr > s->buffer) {
- if (s->write_packet)
- s->write_packet(s->opaque, s->buffer, s->buf_ptr - s->buffer);
+ if (s->write_packet && !s->error){
+ int ret= s->write_packet(s->opaque, s->buffer, s->buf_ptr - s->buffer);
+ if(ret < 0){
+ s->error = ret;
+ }
+ }
+ if(s->update_checksum){
+ s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_ptr - s->checksum_ptr);
+ s->checksum_ptr= s->buffer;
+ }
s->pos += s->buf_ptr - s->buffer;
}
s->buf_ptr = s->buffer;
return -EPIPE;
s->buf_ptr = s->buffer;
s->buf_end = s->buffer;
- s->seek(s->opaque, offset, SEEK_SET);
+ if (s->seek(s->opaque, offset, SEEK_SET) == (offset_t)-EPIPE)
+ return -EPIPE;
s->pos = offset;
}
s->eof_reached = 0;
return s->eof_reached;
}
+int url_ferror(ByteIOContext *s)
+{
+ return s->error;
+}
+
#ifdef CONFIG_ENCODERS
void put_le32(ByteIOContext *s, unsigned int val)
{
/* no need to do anything if EOF already reached */
if (s->eof_reached)
return;
+
+ if(s->update_checksum){
+ s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_end - s->checksum_ptr);
+ s->checksum_ptr= s->buffer;
+ }
+
len = s->read_packet(s->opaque, s->buffer, s->buffer_size);
if (len <= 0) {
/* do not modify buffer if EOF reached so that a seek back can
be done without rereading data */
s->eof_reached = 1;
+ if(len<0)
+ s->error= len;
} else {
s->pos += len;
s->buf_ptr = s->buffer;
}
}
+unsigned long get_checksum(ByteIOContext *s){
+ s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_ptr - s->checksum_ptr);
+ s->update_checksum= NULL;
+ return s->checksum;
+}
+
+void init_checksum(ByteIOContext *s, unsigned long (*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len), unsigned long checksum){
+ s->update_checksum= update_checksum;
+ if(s->update_checksum){
+ s->checksum= s->update_checksum(checksum, NULL, 0);
+ s->checksum_ptr= s->buf_ptr;
+ }
+}
+
/* NOTE: return 0 if EOF, so you cannot use it if EOF handling is
necessary */
/* XXX: put an inline version */
return size1 - size;
}
+int get_partial_buffer(ByteIOContext *s, unsigned char *buf, int size)
+{
+ int len;
+
+ len = s->buf_end - s->buf_ptr;
+ if (len == 0) {
+ fill_buffer(s);
+ len = s->buf_end - s->buf_ptr;
+ }
+ if (len > size)
+ len = size;
+ memcpy(buf, s->buf_ptr, len);
+ s->buf_ptr += len;
+ return len;
+}
+
unsigned int get_le16(ByteIOContext *s)
{
unsigned int val;
/* link with avio functions */
#ifdef CONFIG_ENCODERS
-static void url_write_packet(void *opaque, uint8_t *buf, int buf_size)
+static int url_write_packet(void *opaque, uint8_t *buf, int buf_size)
{
URLContext *h = opaque;
- url_write(h, buf, buf_size);
+ return url_write(h, buf, buf_size);
}
#else
#define url_write_packet NULL
static int url_seek_packet(void *opaque, int64_t offset, int whence)
{
URLContext *h = opaque;
- url_seek(h, offset, whence);
- return 0;
+ return url_seek(h, offset, whence);
+ //return 0;
}
int url_fdopen(ByteIOContext *s, URLContext *h)
return -ENOMEM;
if (init_put_byte(s, buffer, buffer_size,
- (h->flags & URL_WRONLY) != 0, h,
+ (h->flags & URL_WRONLY || h->flags & URL_RDWR), h,
url_read_packet, url_write_packet, url_seek_packet) < 0) {
av_free(buffer);
- return -EIO;
+ return AVERROR_IO;
}
s->is_streamed = h->is_streamed;
s->max_packet_size = max_packet_size;
int url_open_buf(ByteIOContext *s, uint8_t *buf, int buf_size, int flags)
{
return init_put_byte(s, buf, buf_size,
- (flags & URL_WRONLY) != 0, NULL, NULL, NULL, NULL);
+ (flags & URL_WRONLY || flags & URL_RDWR),
+ NULL, NULL, NULL, NULL);
}
/* return the written or read size */
uint8_t io_buffer[1];
} DynBuffer;
-static void dyn_buf_write(void *opaque, uint8_t *buf, int buf_size)
+static int dyn_buf_write(void *opaque, uint8_t *buf, int buf_size)
{
DynBuffer *d = opaque;
int new_size, new_allocated_size;
if (new_allocated_size > d->allocated_size) {
d->buffer = av_realloc(d->buffer, new_allocated_size);
if(d->buffer == NULL)
- return ;
+ return -1234;
d->allocated_size = new_allocated_size;
}
memcpy(d->buffer + d->pos, buf, buf_size);
d->pos = new_size;
if (d->pos > d->size)
d->size = d->pos;
+ return buf_size;
}
-static void dyn_packet_buf_write(void *opaque, uint8_t *buf, int buf_size)
+static int dyn_packet_buf_write(void *opaque, uint8_t *buf, int buf_size)
{
unsigned char buf1[4];
+ int ret;
/* packetized write: output the header */
buf1[0] = (buf_size >> 24);
buf1[1] = (buf_size >> 16);
buf1[2] = (buf_size >> 8);
buf1[3] = (buf_size);
- dyn_buf_write(opaque, buf1, 4);
+ ret= dyn_buf_write(opaque, buf1, 4);
+ if(ret < 0)
+ return ret;
/* then the data */
- dyn_buf_write(opaque, buf, buf_size);
+ return dyn_buf_write(opaque, buf, buf_size);
}
static int dyn_buf_seek(void *opaque, offset_t offset, int whence)