Merge commit 'e253a9e2b3d683eb51db7c776326eb07de10ad4c'
authorMichael Niedermayer <michaelni@gmx.at>
Tue, 29 Jul 2014 17:55:15 +0000 (19:55 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Tue, 29 Jul 2014 18:02:09 +0000 (20:02 +0200)
* commit 'e253a9e2b3d683eb51db7c776326eb07de10ad4c':
  avformat: Move av_probe_input* to format.c

Conflicts:
libavformat/format.c
libavformat/utils.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavformat/format.c
libavformat/utils.c

   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
+ #include "libavutil/avstring.h"
+ #include "avio_internal.h"
  #include "avformat.h"
+ #include "id3v2.h"
  #include "internal.h"
- #include "libavutil/avstring.h"
 +#include "libavutil/atomic.h"
++#include "libavutil/bprint.h"
++#include "libavutil/opt.h"
  
  /**
   * @file
@@@ -187,3 -184,137 +192,164 @@@ AVInputFormat *av_find_input_format(con
              return fmt;
      return NULL;
  }
 -AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened,
 -                                      int *score_max)
 -    int score, id3 = 0;
++AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened,
++                                      int *score_ret)
+ {
+     AVProbeData lpd = *pd;
+     AVInputFormat *fmt1 = NULL, *fmt;
 -        }
 -        id3 = 1;
++    int score, nodat = 0, score_max = 0;
++    const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
++
++    if (!lpd.buf)
++        lpd.buf = zerobuffer;
+     if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
+         int id3len = ff_id3v2_tag_len(lpd.buf);
+         if (lpd.buf_size > id3len + 16) {
+             lpd.buf      += id3len;
+             lpd.buf_size -= id3len;
 -        if (score > *score_max) {
 -            *score_max = score;
 -            fmt        = fmt1;
 -        } else if (score == *score_max)
++        } else if (id3len >= PROBE_BUF_MAX) {
++            nodat = 2;
++        } else
++            nodat = 1;
+     }
+     fmt = NULL;
+     while ((fmt1 = av_iformat_next(fmt1))) {
+         if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
+             continue;
+         score = 0;
+         if (fmt1->read_probe) {
+             score = fmt1->read_probe(&lpd);
++            if (fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions)) {
++                if      (nodat == 0) score = FFMAX(score, 1);
++                else if (nodat == 1) score = FFMAX(score, AVPROBE_SCORE_EXTENSION / 2 - 1);
++                else                 score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
++            }
+         } else if (fmt1->extensions) {
+             if (av_match_ext(lpd.filename, fmt1->extensions))
+                 score = AVPROBE_SCORE_EXTENSION;
+         }
 -
 -    // A hack for files with huge id3v2 tags -- try to guess by file extension.
 -    if (!fmt && is_opened && *score_max < AVPROBE_SCORE_EXTENSION / 2) {
 -        while ((fmt = av_iformat_next(fmt)))
 -            if (fmt->extensions &&
 -                av_match_ext(lpd.filename, fmt->extensions)) {
 -                *score_max = AVPROBE_SCORE_EXTENSION / 2;
 -                break;
 -            }
 -    }
 -
 -    if (!fmt && id3 && *score_max < AVPROBE_SCORE_EXTENSION / 2 - 1) {
 -        while ((fmt = av_iformat_next(fmt)))
 -            if (fmt->extensions && av_match_ext("mp3", fmt->extensions)) {
 -                *score_max = AVPROBE_SCORE_EXTENSION / 2 - 1;
 -                break;
 -            }
 -    }
++        if (score > score_max) {
++            score_max = score;
++            fmt       = fmt1;
++        } else if (score == score_max)
+             fmt = NULL;
+     }
 -/* size of probe buffer, for guessing file type from file contents */
 -#define PROBE_BUF_MIN 2048
 -#define PROBE_BUF_MAX (1 << 20)
 -
 -int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
++    if (nodat == 1)
++        score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
++    *score_ret = score_max;
+     return fmt;
+ }
++AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
++{
++    int score_ret;
++    AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);
++    if (score_ret > *score_max) {
++        *score_max = score_ret;
++        return fmt;
++    } else
++        return NULL;
++}
++
+ AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
+ {
+     int score = 0;
+     return av_probe_input_format2(pd, is_opened, &score);
+ }
 -    int ret = 0, probe_size;
++int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt,
+                           const char *filename, void *logctx,
+                           unsigned int offset, unsigned int max_probe_size)
+ {
+     AVProbeData pd = { filename ? filename : "" };
+     uint8_t *buf = NULL;
 -    else if (max_probe_size > PROBE_BUF_MAX)
 -        max_probe_size = PROBE_BUF_MAX;
 -    else if (max_probe_size < PROBE_BUF_MIN)
++    uint8_t *mime_type;
++    int ret = 0, probe_size, buf_offset = 0;
++    int score = 0;
+     if (!max_probe_size)
+         max_probe_size = PROBE_BUF_MAX;
 -    avio_skip(pb, offset);
 -    max_probe_size -= offset;
++    else if (max_probe_size < PROBE_BUF_MIN) {
++        av_log(logctx, AV_LOG_ERROR,
++               "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
+         return AVERROR(EINVAL);
++    }
+     if (offset >= max_probe_size)
+         return AVERROR(EINVAL);
 -        int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX / 4 : 0;
++
++    if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) {
++        if (!av_strcasecmp(mime_type, "audio/aacp")) {
++            *fmt = av_find_input_format("aac");
++        }
++        av_freep(&mime_type);
++    }
+     for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt;
+          probe_size = FFMIN(probe_size << 1,
+                             FFMAX(max_probe_size, probe_size + 1))) {
 -        if ((ret = avio_read(pb, buf + pd.buf_size,
 -                             probe_size - pd.buf_size)) < 0) {
++        score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
+         /* Read probe data. */
+         if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
+             return ret;
 -        pd.buf_size += ret;
 -        pd.buf       = buf;
++        if ((ret = avio_read(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;
+             ret   = 0;          /* error was end of file, nothing read */
+         }
 -            if (score <= AVPROBE_SCORE_MAX / 4) {
++        buf_offset += ret;
++        if (buf_offset < offset)
++            continue;
++        pd.buf_size = buf_offset - offset;
++        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) {
+             /* This can only be true in the last iteration. */
 -                       "Format detected only with low score of %d, "
 -                       "misdetection possible!\n", score);
++            if (score <= AVPROBE_SCORE_RETRY) {
+                 av_log(logctx, AV_LOG_WARNING,
 -                       "Probed with size=%d and score=%d\n", probe_size, score);
++                       "Format %s detected only with low score of %d, "
++                       "misdetection possible!\n", (*fmt)->name, score);
+             } else
+                 av_log(logctx, AV_LOG_DEBUG,
 -    if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
 -        av_free(buf);
++                       "Format %s probed with size=%d and score=%d\n",
++                       (*fmt)->name, probe_size, score);
++#if 0
++            FILE *f = fopen("probestat.tmp", "ab");
++            fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
++            fclose(f);
++#endif
+         }
+     }
+     if (!*fmt) {
+         av_free(buf);
+         return AVERROR_INVALIDDATA;
+     }
+     /* Rewind. Reuse probe buffer to avoid seeking. */
 -    return ret;
++    ret = ffio_rewind_with_probe_data(pb, &buf, buf_offset);
++
++    return ret < 0 ? ret : score;
++}
++int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
++                          const char *filename, void *logctx,
++                          unsigned int offset, unsigned int max_probe_size)
++{
++    int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
++    return ret < 0 ? ret : 0;
+ }
@@@ -245,76 -138,8 +245,8 @@@ int av_filename_number_test(const char 
             (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
  }
  
- AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened,
-                                       int *score_ret)
- {
-     AVProbeData lpd = *pd;
-     AVInputFormat *fmt1 = NULL, *fmt;
-     int score, nodat = 0, score_max = 0;
-     const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
-     if (!lpd.buf)
-         lpd.buf = zerobuffer;
-     if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
-         int id3len = ff_id3v2_tag_len(lpd.buf);
-         if (lpd.buf_size > id3len + 16) {
-             lpd.buf      += id3len;
-             lpd.buf_size -= id3len;
-         } else if (id3len >= PROBE_BUF_MAX) {
-             nodat = 2;
-         } else
-             nodat = 1;
-     }
-     fmt = NULL;
-     while ((fmt1 = av_iformat_next(fmt1))) {
-         if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
-             continue;
-         score = 0;
-         if (fmt1->read_probe) {
-             score = fmt1->read_probe(&lpd);
-             if (fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions)) {
-                 if      (nodat == 0) score = FFMAX(score, 1);
-                 else if (nodat == 1) score = FFMAX(score, AVPROBE_SCORE_EXTENSION / 2 - 1);
-                 else                 score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
-             }
-         } else if (fmt1->extensions) {
-             if (av_match_ext(lpd.filename, fmt1->extensions))
-                 score = AVPROBE_SCORE_EXTENSION;
-         }
-         if (score > score_max) {
-             score_max = score;
-             fmt       = fmt1;
-         } else if (score == score_max)
-             fmt = NULL;
-     }
-     if (nodat == 1)
-         score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
-     *score_ret = score_max;
-     return fmt;
- }
- AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
- {
-     int score_ret;
-     AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);
-     if (score_ret > *score_max) {
-         *score_max = score_ret;
-         return fmt;
-     } else
-         return NULL;
- }
- AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
- {
-     int score = 0;
-     return av_probe_input_format2(pd, is_opened, &score);
- }
  static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
 -                                     AVProbeData *pd, int score)
 +                                     AVProbeData *pd)
  {
      static const struct {
          const char *name;
  /************************************************************/
  /* input media file */
  
- int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt,
-                           const char *filename, void *logctx,
-                           unsigned int offset, unsigned int max_probe_size)
- {
-     AVProbeData pd = { filename ? filename : "" };
-     uint8_t *buf = NULL;
-     uint8_t *mime_type;
-     int ret = 0, probe_size, buf_offset = 0;
-     int score = 0;
-     if (!max_probe_size)
-         max_probe_size = PROBE_BUF_MAX;
-     else if (max_probe_size < PROBE_BUF_MIN) {
-         av_log(logctx, AV_LOG_ERROR,
-                "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
-         return AVERROR(EINVAL);
-     }
-     if (offset >= max_probe_size)
-         return AVERROR(EINVAL);
-     if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) {
-         if (!av_strcasecmp(mime_type, "audio/aacp")) {
-             *fmt = av_find_input_format("aac");
-         }
-         av_freep(&mime_type);
-     }
-     for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt;
-          probe_size = FFMIN(probe_size << 1,
-                             FFMAX(max_probe_size, probe_size + 1))) {
-         score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
-         /* Read probe data. */
-         if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
-             return ret;
-         if ((ret = avio_read(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;
-             ret   = 0;          /* error was end of file, nothing read */
-         }
-         buf_offset += ret;
-         if (buf_offset < offset)
-             continue;
-         pd.buf_size = buf_offset - offset;
-         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) {
-             /* This can only be true in the last iteration. */
-             if (score <= AVPROBE_SCORE_RETRY) {
-                 av_log(logctx, AV_LOG_WARNING,
-                        "Format %s detected only with low score of %d, "
-                        "misdetection possible!\n", (*fmt)->name, score);
-             } else
-                 av_log(logctx, AV_LOG_DEBUG,
-                        "Format %s probed with size=%d and score=%d\n",
-                        (*fmt)->name, probe_size, score);
- #if 0
-             FILE *f = fopen("probestat.tmp", "ab");
-             fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
-             fclose(f);
- #endif
-         }
-     }
-     if (!*fmt) {
-         av_free(buf);
-         return AVERROR_INVALIDDATA;
-     }
-     /* Rewind. Reuse probe buffer to avoid seeking. */
-     ret = ffio_rewind_with_probe_data(pb, &buf, buf_offset);
-     return ret < 0 ? ret : score;
- }
- int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
-                           const char *filename, void *logctx,
-                           unsigned int offset, unsigned int max_probe_size)
- {
-     int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
-     return ret < 0 ? ret : 0;
- }
 +int av_demuxer_open(AVFormatContext *ic) {
 +    int err;
 +
 +    if (ic->iformat->read_header) {
 +        err = ic->iformat->read_header(ic);
 +        if (err < 0)
 +            return err;
 +    }
 +
 +    if (ic->pb && !ic->data_offset)
 +        ic->data_offset = avio_tell(ic->pb);
 +
 +    return 0;
 +}
 +
  /* Open input file and probe the format if necessary. */
  static int init_input(AVFormatContext *s, const char *filename,
                        AVDictionary **options)