Move the probe loop from av_open_input_file() into its own method
authorMicah F. Galizia <micahgalizia@gmail.com>
Sun, 14 Mar 2010 22:40:16 +0000 (22:40 +0000)
committerStefano Sabatini <stefano.sabatini-lala@poste.it>
Sun, 14 Mar 2010 22:40:16 +0000 (22:40 +0000)
av_probe_input_buffer() so that it can be reused. Here are a few
differences to the original way things were probed:

- maximum probe buffer size can be specified as a parameter.

- offset within the stream to probe from can be specified as a parameter.

- instead of seeking back to the start each time a probe fails, stream
  data is appended to the reallocated buffer. This lowers the amount
  of data read from the stream (there is no repetition) and results in
  fewer closed and reopened streams (when seeking fails).

New attempt after r22296, which was revert in r22315 due to a FATE
failure.

See the thread:
Subject: [FFmpeg-devel] [PATCH] Move av_open_input_file probe loop to its own method
Date: 2010-03-05 03:23:57 GMT

Patch by Micah F. Galizia printf("%s%s@%s.%s", "micah", "galizia", "gmail", "com").

Originally committed as revision 22532 to svn://svn.ffmpeg.org/ffmpeg/trunk

libavformat/internal.h
libavformat/utils.c

index 743ee98..be3fbb2 100644 (file)
@@ -40,4 +40,23 @@ void av_read_frame_flush(AVFormatContext *s);
 /** Gets the current time since NTP epoch in microseconds. */
 uint64_t ff_ntp_time(void);
 
 /** Gets the current time since NTP epoch in microseconds. */
 uint64_t ff_ntp_time(void);
 
+/**
+ * Probes a bytestream to determine the input format. Each time a probe returns
+ * with a score that is too low, the probe buffer size is increased and another
+ * attempt is made. When the maximum probe size is reached, the input format
+ * with the highest score is returned.
+ *
+ * @param pb the bytestream to probe, it may be closed and opened again
+ * @param fmt the input format is put here
+ * @param filename the filename of the stream
+ * @param logctx the log context
+ * @param offset the offset within the bytestream to probe from
+ * @param max_probe_size the maximum probe buffer size (zero for default)
+ * @return 0 in case of success, a negative value corresponding to an
+ * AVERROR code otherwise
+ */
+int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
+                          const char *filename, void *logctx,
+                          unsigned int offset, unsigned int max_probe_size);
+
 #endif /* AVFORMAT_INTERNAL_H */
 #endif /* AVFORMAT_INTERNAL_H */
index b2ecf13..f6cbbb4 100644 (file)
@@ -458,12 +458,75 @@ int av_open_input_stream(AVFormatContext **ic_ptr,
 #define PROBE_BUF_MIN 2048
 #define PROBE_BUF_MAX (1<<20)
 
 #define PROBE_BUF_MIN 2048
 #define PROBE_BUF_MAX (1<<20)
 
+int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
+                          const char *filename, void *logctx,
+                          unsigned int offset, unsigned int max_probe_size)
+{
+    AVProbeData pd = { filename ? filename : "", NULL, -offset };
+    unsigned char *buf = NULL;
+    int ret = 0, probe_size;
+
+    if (!max_probe_size) {
+        max_probe_size = PROBE_BUF_MAX;
+    } else if (max_probe_size > PROBE_BUF_MAX) {
+        max_probe_size = PROBE_BUF_MAX;
+    } else if (max_probe_size < PROBE_BUF_MIN) {
+        return AVERROR(EINVAL);
+    }
+
+    if (offset >= max_probe_size) {
+        return AVERROR(EINVAL);
+    }
+
+    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0; probe_size<<=1){
+        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
+        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
+
+        if (probe_size < offset) {
+            continue;
+        }
+
+        /* read probe data */
+        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
+        if ((ret = get_buffer(*pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
+            /* fail if error was not end of file, otherwise, lower score */
+            if (ret != AVERROR_EOF) {
+                av_free(buf);
+                return ret;
+            }
+            score = 0;
+        }
+        pd.buf_size += ret;
+        pd.buf = &buf[offset];
+
+        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
+
+        /* guess file format */
+        *fmt = av_probe_input_format2(&pd, 1, &score);
+        if(*fmt){
+            if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
+                av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
+            }else
+                av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
+        }
+    }
+
+    av_free(buf);
+    if (url_fseek(*pb, 0, SEEK_SET) < 0) {
+        url_fclose(*pb);
+        if (url_fopen(pb, filename, URL_RDONLY) < 0)
+            return AVERROR(EIO);
+    }
+
+    return 0;
+}
+
 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
                        AVInputFormat *fmt,
                        int buf_size,
                        AVFormatParameters *ap)
 {
 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
                        AVInputFormat *fmt,
                        int buf_size,
                        AVFormatParameters *ap)
 {
-    int err, probe_size;
+    int err;
     AVProbeData probe_data, *pd = &probe_data;
     ByteIOContext *pb = NULL;
     void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
     AVProbeData probe_data, *pd = &probe_data;
     ByteIOContext *pb = NULL;
     void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
@@ -489,37 +552,9 @@ int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
         if (buf_size > 0) {
             url_setbufsize(pb, buf_size);
         }
         if (buf_size > 0) {
             url_setbufsize(pb, buf_size);
         }
-
-        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
-            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
-            /* read probe data */
-            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
-            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
-
-            if ((int)pd->buf_size < 0) {
-                err = pd->buf_size;
-                goto fail;
-            }
-
-            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
-            if (url_fseek(pb, 0, SEEK_SET) < 0) {
-                url_fclose(pb);
-                if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
-                    pb = NULL;
-                    err = AVERROR(EIO);
-                    goto fail;
-                }
-            }
-            /* guess file format */
-            fmt = av_probe_input_format2(pd, 1, &score);
-            if(fmt){
-                if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
-                    av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
-                }else
-                    av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
-            }
+        if ((err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, 0)) < 0) {
+            goto fail;
         }
         }
-        av_freep(&pd->buf);
     }
 
     /* if still no format found, error */
     }
 
     /* if still no format found, error */