prefer integer fps if possible when guessing

[ffmpeg] / libavformat / aviobuf.c

diff --git a/libavformat/aviobuf.c b/libavformat/aviobuf.c
index de140966c6b33ab49646aa2ad63c0ed9c7105c1a..31c6a7fec55d5e55e86fac8b63cf9d737edb5cde 100644 (file)
--- a/libavformat/aviobuf.c
+++ b/libavformat/aviobuf.c
@@ -28,7 +28,7 @@ int init_put_byte(ByteIOContext *s,
                   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;
@@ -46,8 +46,10 @@ int init_put_byte(ByteIOContext *s,
     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;
 }
                   
@@ -56,8 +58,16 @@ int init_put_byte(ByteIOContext *s,
 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;
@@ -143,7 +153,8 @@ offset_t url_fseek(ByteIOContext *s, offset_t offset, int whence)
                 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;
@@ -166,6 +177,11 @@ int url_feof(ByteIOContext *s)
     return s->eof_reached;
 }
 
+int url_ferror(ByteIOContext *s)
+{
+    return s->error;
+}
+
 #ifdef CONFIG_ENCODERS
 void put_le32(ByteIOContext *s, unsigned int val)
 {
@@ -243,11 +259,19 @@ static void fill_buffer(ByteIOContext *s)
     /* 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;
@@ -255,6 +279,20 @@ static void fill_buffer(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){
+    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 */
@@ -309,6 +347,22 @@ int get_buffer(ByteIOContext *s, unsigned char *buf, int size)
     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;
@@ -390,10 +444,10 @@ uint64_t get_be64(ByteIOContext *s)
 /* 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
@@ -408,8 +462,8 @@ static int url_read_packet(void *opaque, uint8_t *buf, int buf_size)
 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)
@@ -432,7 +486,7 @@ int url_fdopen(ByteIOContext *s, URLContext *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;
@@ -567,7 +621,7 @@ typedef struct DynBuffer {
     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;
@@ -585,28 +639,32 @@ static void 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 ;
+             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)