X-Git-Url: https://rtime.felk.cvut.cz/gitweb/frescor/ffmpeg.git/blobdiff_plain/648cc6644622e8dd8ee4ccbed06fd10c3cf91946..e6b000b4e52e685bc6387faa806f36b5f56716e8:/libavformat/aviobuf.c diff --git a/libavformat/aviobuf.c b/libavformat/aviobuf.c index 328b53d33..04e519916 100644 --- a/libavformat/aviobuf.c +++ b/libavformat/aviobuf.c @@ -18,10 +18,14 @@ * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ + +#include "libavutil/crc.h" +#include "libavutil/intreadwrite.h" #include "avformat.h" #include "avio.h" -#include "crc.h" #include +#include +#include #define IO_BUFFER_SIZE 32768 @@ -34,13 +38,13 @@ int init_put_byte(ByteIOContext *s, void *opaque, int (*read_packet)(void *opaque, uint8_t *buf, int buf_size), int (*write_packet)(void *opaque, uint8_t *buf, int buf_size), - offset_t (*seek)(void *opaque, offset_t offset, int whence)) + int64_t (*seek)(void *opaque, int64_t offset, int whence)) { s->buffer = buffer; s->buffer_size = buffer_size; s->buf_ptr = buffer; - url_resetbuf(s, write_flag ? URL_WRONLY : URL_RDONLY); s->opaque = opaque; + url_resetbuf(s, write_flag ? URL_WRONLY : URL_RDONLY); s->write_packet = write_packet; s->read_packet = read_packet; s->seek = seek; @@ -55,28 +59,65 @@ int init_put_byte(ByteIOContext *s, s->pos = buffer_size; s->buf_end = s->buffer + buffer_size; } - s->read_play = NULL; s->read_pause = NULL; s->read_seek = NULL; return 0; } +ByteIOContext *av_alloc_put_byte( + unsigned char *buffer, + int buffer_size, + int write_flag, + void *opaque, + int (*read_packet)(void *opaque, uint8_t *buf, int buf_size), + int (*write_packet)(void *opaque, uint8_t *buf, int buf_size), + int64_t (*seek)(void *opaque, int64_t offset, int whence)) +{ + ByteIOContext *s = av_mallocz(sizeof(ByteIOContext)); + init_put_byte(s, buffer, buffer_size, write_flag, opaque, + read_packet, write_packet, seek); + return s; +} + +#define BLOCK_SIZE 512 + static void flush_buffer(ByteIOContext *s) { - if (s->buf_ptr > s->buffer) { + size_t data_len = s->buf_ptr - s->buffer; + + /* Write all the data in the buffer to the disk together with any + * additional space at the end of the buffer up to the first + * multiple of BLOCK_SIZE. The last block is always written to the + * disk despite not being fully filled. If the last block is not + * fully filled, we keep it (moved to the begginig of the buffer) + * and any subsequent call to this function will rewrite the block + * together with the additional data added to the buffer. */ + size_t to_write = (data_len + BLOCK_SIZE - 1) & ~(BLOCK_SIZE - 1); + size_t whole_blocks = data_len & ~(BLOCK_SIZE - 1); + int64_t res = AVERROR(EPIPE); + av_log(NULL, AV_LOG_ERROR, "YYY dl=%zd, tw=%zd\n", data_len, to_write); + if (data_len > 0) { if (s->write_packet && !s->error){ - int ret= s->write_packet(s->opaque, s->buffer, s->buf_ptr - s->buffer); + int ret= s->write_packet(s->opaque, s->buffer, to_write); if(ret < 0){ s->error = ret; } } if(s->update_checksum){ + av_log(NULL, AV_LOG_ERROR, "Checksumming not implemented in O_DIRECT patch\n"); 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->pos += whole_blocks; + memcpy(s->buffer, &s->buffer[whole_blocks], data_len - whole_blocks); + s->buf_ptr -= whole_blocks; + + if (s->seek) + res = s->seek(s->opaque, s->pos, SEEK_SET); + if (res < 0) + av_log(NULL, AV_LOG_ERROR, "seek error inside flush_buffer: %lld\n", res); + av_log(NULL, AV_LOG_ERROR, "ZZZ tw=%zu, pos=%zd\n", to_write, s->pos); } - s->buf_ptr = s->buffer; } void put_byte(ByteIOContext *s, int b) @@ -111,10 +152,10 @@ void put_flush_packet(ByteIOContext *s) s->must_flush = 0; } -offset_t url_fseek(ByteIOContext *s, offset_t offset, int whence) +int64_t url_fseek(ByteIOContext *s, int64_t offset, int whence) { - offset_t offset1; - offset_t pos; + int64_t offset1; + int64_t pos; if(!s) return AVERROR(EINVAL); @@ -130,50 +171,54 @@ offset_t url_fseek(ByteIOContext *s, offset_t offset, int whence) return offset1; offset += offset1; } + av_log(NULL, AV_LOG_ERROR, "SEEK to %llu\n", offset); + offset1 = offset - pos; if (!s->must_flush && - offset1 >= 0 && offset1 < (s->buf_end - s->buffer)) { + 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); + int64_t res = AVERROR(EPIPE); -#if defined(CONFIG_MUXERS) || defined(CONFIG_NETWORK) +#if CONFIG_MUXERS || 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; +#endif /* CONFIG_MUXERS || CONFIG_NETWORK */ +#warning TODO read the whole block from the file to the buffer if (!s->seek || (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; } -void url_fskip(ByteIOContext *s, offset_t offset) +void url_fskip(ByteIOContext *s, int64_t offset) { url_fseek(s, offset, SEEK_CUR); } -offset_t url_ftell(ByteIOContext *s) +int64_t url_ftell(ByteIOContext *s) { return url_fseek(s, 0, SEEK_CUR); } -offset_t url_fsize(ByteIOContext *s) +int64_t url_fsize(ByteIOContext *s) { - offset_t size; + int64_t size; if(!s) return AVERROR(EINVAL); @@ -275,20 +320,25 @@ void put_tag(ByteIOContext *s, const char *tag) static void fill_buffer(ByteIOContext *s) { - int len=0; + uint8_t *dst= !s->max_packet_size && s->buf_end - s->buffer < s->buffer_size ? s->buf_ptr : s->buffer; + int len= s->buffer_size - (dst - s->buffer); + + assert(s->buf_ptr == s->buf_end); /* no need to do anything if EOF already reached */ if (s->eof_reached) return; - if(s->update_checksum){ + if(s->update_checksum && dst == s->buffer){ if(s->buf_end > s->checksum_ptr) s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_end - s->checksum_ptr); s->checksum_ptr= s->buffer; } if(s->read_packet) - len = s->read_packet(s->opaque, s->buffer, s->buffer_size); + len = s->read_packet(s->opaque, dst, len); + else + len = 0; if (len <= 0) { /* do not modify buffer if EOF reached so that a seek back can be done without rereading data */ @@ -297,22 +347,28 @@ static void fill_buffer(ByteIOContext *s) s->error= len; } else { s->pos += len; - s->buf_ptr = s->buffer; - s->buf_end = s->buffer + len; + s->buf_ptr = dst; + s->buf_end = dst + len; } } -unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf, unsigned int len){ - return av_crc(av_crc04C11DB7, checksum, buf, len); +unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf, + unsigned int len) +{ + return av_crc(av_crc_get_table(AV_CRC_32_IEEE), checksum, buf, len); } -unsigned long get_checksum(ByteIOContext *s){ +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){ +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= checksum; @@ -498,31 +554,6 @@ uint64_t ff_get_v(ByteIOContext *bc){ return val; } -/* link with avio functions */ - -#ifdef CONFIG_MUXERS -static int url_write_packet(void *opaque, uint8_t *buf, int buf_size) -{ - URLContext *h = opaque; - return url_write(h, buf, buf_size); -} -#else -#define url_write_packet NULL -#endif //CONFIG_MUXERS - -static int url_read_packet(void *opaque, uint8_t *buf, int buf_size) -{ - URLContext *h = opaque; - return url_read(h, buf, buf_size); -} - -static offset_t url_seek_packet(void *opaque, offset_t offset, int whence) -{ - URLContext *h = opaque; - return url_seek(h, offset, whence); - //return 0; -} - int url_fdopen(ByteIOContext **s, URLContext *h) { uint8_t *buffer; @@ -535,7 +566,8 @@ int url_fdopen(ByteIOContext **s, URLContext *h) } else { buffer_size = IO_BUFFER_SIZE; } - buffer = av_malloc(buffer_size); + buffer_size = 2*buffer_size+BLOCK_SIZE; + buffer = memalign(sysconf(_SC_PAGESIZE), buffer_size); if (!buffer) return AVERROR(ENOMEM); @@ -547,7 +579,7 @@ int url_fdopen(ByteIOContext **s, URLContext *h) 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) { + url_read, url_write, url_seek) < 0) { av_free(buffer); av_freep(s); return AVERROR(EIO); @@ -555,9 +587,8 @@ int url_fdopen(ByteIOContext **s, URLContext *h) (*s)->is_streamed = h->is_streamed; (*s)->max_packet_size = max_packet_size; if(h->prot) { - (*s)->read_play = (int (*)(void *))h->prot->url_read_play; - (*s)->read_pause = (int (*)(void *))h->prot->url_read_pause; - (*s)->read_seek = (int (*)(void *, int, int64_t, int))h->prot->url_read_seek; + (*s)->read_pause = (int (*)(void *, int))h->prot->url_read_pause; + (*s)->read_seek = (int64_t (*)(void *, int, int64_t, int))h->prot->url_read_seek; } return 0; } @@ -623,7 +654,7 @@ URLContext *url_fileno(ByteIOContext *s) return s->opaque; } -#ifdef CONFIG_MUXERS +#if CONFIG_MUXERS int url_fprintf(ByteIOContext *s, const char *fmt, ...) { va_list ap; @@ -664,25 +695,18 @@ int url_fget_max_packet_size(ByteIOContext *s) return s->max_packet_size; } -int av_url_read_fplay(ByteIOContext *s) -{ - if (!s->read_play) - return AVERROR(ENOSYS); - return s->read_play(s->opaque); -} - -int av_url_read_fpause(ByteIOContext *s) +int av_url_read_fpause(ByteIOContext *s, int pause) { if (!s->read_pause) return AVERROR(ENOSYS); - return s->read_pause(s->opaque); + return s->read_pause(s->opaque, pause); } -int av_url_read_fseek(ByteIOContext *s, - int stream_index, int64_t timestamp, int flags) +int64_t av_url_read_fseek(ByteIOContext *s, int stream_index, + int64_t timestamp, int flags) { URLContext *h = s->opaque; - int ret; + int64_t ret; if (!s->read_seek) return AVERROR(ENOSYS); ret = s->read_seek(h, stream_index, timestamp, flags); @@ -694,8 +718,8 @@ int av_url_read_fseek(ByteIOContext *s, } /* url_open_dyn_buf and url_close_dyn_buf are used in rtp.c to send a response - * back to the server even if CONFIG_MUXERS is not set. */ -#if defined(CONFIG_MUXERS) || defined(CONFIG_NETWORK) + * back to the server even if CONFIG_MUXERS is false. */ +#if CONFIG_MUXERS || CONFIG_NETWORK /* buffer handling */ int url_open_buf(ByteIOContext **s, uint8_t *buf, int buf_size, int flags) { @@ -729,7 +753,7 @@ typedef struct DynBuffer { static int dyn_buf_write(void *opaque, uint8_t *buf, int buf_size) { DynBuffer *d = opaque; - int new_size, new_allocated_size; + unsigned new_size, new_allocated_size; /* reallocate buffer if needed */ new_size = d->pos + buf_size; @@ -746,7 +770,7 @@ static int dyn_buf_write(void *opaque, uint8_t *buf, int buf_size) if (new_allocated_size > d->allocated_size) { d->buffer = av_realloc(d->buffer, new_allocated_size); if(d->buffer == NULL) - return -1234; + return AVERROR(ENOMEM); d->allocated_size = new_allocated_size; } memcpy(d->buffer + d->pos, buf, buf_size); @@ -762,10 +786,7 @@ static int dyn_packet_buf_write(void *opaque, uint8_t *buf, int buf_size) 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); + AV_WB32(buf1, buf_size); ret= dyn_buf_write(opaque, buf1, 4); if(ret < 0) return ret; @@ -774,7 +795,7 @@ static int dyn_packet_buf_write(void *opaque, uint8_t *buf, int buf_size) return dyn_buf_write(opaque, buf, buf_size); } -static offset_t dyn_buf_seek(void *opaque, offset_t offset, int whence) +static int64_t dyn_buf_seek(void *opaque, int64_t offset, int whence) { DynBuffer *d = opaque; @@ -791,28 +812,20 @@ static offset_t dyn_buf_seek(void *opaque, offset_t offset, int whence) static int url_open_dyn_buf_internal(ByteIOContext **s, int max_packet_size) { DynBuffer *d; - int io_buffer_size, ret; - - if (max_packet_size) - io_buffer_size = max_packet_size; - else - io_buffer_size = 1024; + int ret; + unsigned io_buffer_size = max_packet_size ? max_packet_size : 1024; if(sizeof(DynBuffer) + io_buffer_size < io_buffer_size) return -1; - d = av_malloc(sizeof(DynBuffer) + io_buffer_size); + d = av_mallocz(sizeof(DynBuffer) + io_buffer_size); if (!d) - return -1; + return AVERROR(ENOMEM); *s = av_mallocz(sizeof(ByteIOContext)); if(!*s) { av_free(d); return AVERROR(ENOMEM); } d->io_buffer_size = io_buffer_size; - d->buffer = NULL; - d->pos = 0; - d->size = 0; - d->allocated_size = 0; ret = init_put_byte(*s, d->io_buffer, io_buffer_size, 1, d, NULL, max_packet_size ? dyn_packet_buf_write : dyn_buf_write,