s->buffer = buffer;
s->buffer_size = buffer_size;
s->buf_ptr = buffer;
- s->write_flag = write_flag;
- if (!s->write_flag)
- s->buf_end = buffer;
- else
- s->buf_end = buffer + buffer_size;
+ url_resetbuf(s, write_flag ? URL_WRONLY : URL_RDONLY);
s->opaque = opaque;
s->write_packet = write_packet;
s->read_packet = read_packet;
offset_t pos= s->pos - (s->write_flag ? 0 : (s->buf_end - s->buffer));
if (whence != SEEK_CUR && whence != SEEK_SET)
- return -EINVAL;
+ return AVERROR(EINVAL);
if (whence == SEEK_CUR) {
offset1 = pos + (s->buf_ptr - s->buffer);
fill_buffer(s);
s->buf_ptr = s->buf_end + offset - s->pos;
} else {
- offset_t res = -EPIPE;
+ offset_t res = AVERROR(EPIPE);
#if defined(CONFIG_MUXERS) || defined(CONFIG_NETWORK)
if (s->write_flag) {
offset_t size;
if (!s->seek)
- return -EPIPE;
+ return AVERROR(EPIPE);
size = s->seek(s->opaque, 0, AVSEEK_SIZE);
if(size<0){
if ((size = s->seek(s->opaque, -1, SEEK_END)) < 0)
static void fill_buffer(ByteIOContext *s)
{
- int len;
+ int len=0;
/* no need to do anything if EOF already reached */
if (s->eof_reached)
s->checksum_ptr= s->buffer;
}
- len = s->read_packet(s->opaque, s->buffer, s->buffer_size);
+ if(s->read_packet)
+ 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;
+ if(len<0)
+ s->error= len;
} else {
s->pos += len;
s->buf_ptr = s->buffer;
}
}
-/* NOTE: return 0 if EOF, so you cannot use it if EOF handling is
- necessary */
/* XXX: put an inline version */
int get_byte(ByteIOContext *s)
{
}
}
-/* NOTE: return URL_EOF (-1) if EOF */
int url_fgetc(ByteIOContext *s)
{
if (s->buf_ptr < s->buf_end) {
len = size;
if (len == 0) {
if(size > s->buffer_size && !s->update_checksum){
- len = s->read_packet(s->opaque, buf, size);
+ if(s->read_packet)
+ len = s->read_packet(s->opaque, buf, size);
if (len <= 0) {
/* do not modify buffer if EOF reached so that a seek back can
be done without rereading data */
}
buffer = av_malloc(buffer_size);
if (!buffer)
- return -ENOMEM;
+ return AVERROR(ENOMEM);
if (init_put_byte(s, buffer, buffer_size,
(h->flags & URL_WRONLY || h->flags & URL_RDWR), h,
url_read_packet, url_write_packet, url_seek_packet) < 0) {
av_free(buffer);
- return AVERROR_IO;
+ return AVERROR(EIO);
}
s->is_streamed = h->is_streamed;
s->max_packet_size = max_packet_size;
return 0;
}
-/* XXX: must be called before any I/O */
int url_setbufsize(ByteIOContext *s, int buf_size)
{
uint8_t *buffer;
buffer = av_malloc(buf_size);
if (!buffer)
- return -ENOMEM;
+ return AVERROR(ENOMEM);
av_free(s->buffer);
s->buffer = buffer;
s->buffer_size = buf_size;
s->buf_ptr = buffer;
- if (!s->write_flag)
- s->buf_end = buffer;
- else
- s->buf_end = buffer + buf_size;
+ url_resetbuf(s, s->write_flag ? URL_WRONLY : URL_RDONLY);
+ return 0;
+}
+
+int url_resetbuf(ByteIOContext *s, int flags)
+{
+ URLContext *h = s->opaque;
+ if ((flags & URL_RDWR) || (h && h->flags != flags && !h->flags & URL_RDWR))
+ return AVERROR(EINVAL);
+
+ if (flags & URL_WRONLY) {
+ s->buf_end = s->buffer + s->buffer_size;
+ s->write_flag = 1;
+ } else {
+ s->buf_end = s->buffer;
+ s->write_flag = 0;
+ }
return 0;
}
-/* NOTE: when opened as read/write, the buffers are only used for
- reading */
int url_fopen(ByteIOContext *s, const char *filename, int flags)
{
URLContext *h;
}
#ifdef CONFIG_MUXERS
-/* XXX: currently size is limited */
int url_fprintf(ByteIOContext *s, const char *fmt, ...)
{
va_list ap;
}
#endif //CONFIG_MUXERS
-/* note: unlike fgets, the EOL character is not returned and a whole
- line is parsed. return NULL if first char read was EOF */
char *url_fgets(ByteIOContext *s, char *buf, int buf_size)
{
int c;
return buf;
}
-/*
- * Return the maximum packet size associated to packetized buffered file
- * handle. If the file is not packetized (stream like http or file on
- * disk), then 0 is returned.
- *
- * @param h buffered file handle
- * @return maximum packet size in bytes
- */
int url_fget_max_packet_size(ByteIOContext *s)
{
return s->max_packet_size;
NULL, NULL, NULL, NULL);
}
-/* return the written or read size */
int url_close_buf(ByteIOContext *s)
{
put_flush_packet(s);
return ret;
}
-/*
- * Open a write only memory stream.
- *
- * @param s new IO context
- * @return zero if no error.
- */
int url_open_dyn_buf(ByteIOContext *s)
{
return url_open_dyn_buf_internal(s, 0);
}
-/*
- * Open a write only packetized memory stream with a maximum packet
- * size of 'max_packet_size'. The stream is stored in a memory buffer
- * with a big endian 4 byte header giving the packet size in bytes.
- *
- * @param s new IO context
- * @param max_packet_size maximum packet size (must be > 0)
- * @return zero if no error.
- */
int url_open_dyn_packet_buf(ByteIOContext *s, int max_packet_size)
{
if (max_packet_size <= 0)
return url_open_dyn_buf_internal(s, max_packet_size);
}
-/*
- * Return the written size and a pointer to the buffer. The buffer
- * must be freed with av_free().
- * @param s IO context
- * @param pointer to a byte buffer
- * @return the length of the byte buffer
- */
int url_close_dyn_buf(ByteIOContext *s, uint8_t **pbuffer)
{
DynBuffer *d = s->opaque;
projects / ffmpeg / blobdiff