Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Format register and lookup
  3.  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
  4.  *
  5.  * This file is part of FFmpeg.
  6.  *
  7.  * FFmpeg is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Lesser General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2.1 of the License, or (at your option) any later version.
  11.  *
  12.  * FFmpeg is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * Lesser General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Lesser General Public
  18.  * License along with FFmpeg; if not, write to the Free Software
  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20.  */
  21.  
  22. #include "libavutil/atomic.h"
  23. #include "libavutil/avstring.h"
  24. #include "libavutil/bprint.h"
  25. #include "libavutil/opt.h"
  26.  
  27. #include "avio_internal.h"
  28. #include "avformat.h"
  29. #include "id3v2.h"
  30. #include "internal.h"
  31.  
  32.  
  33. /**
  34.  * @file
  35.  * Format register and lookup
  36.  */
  37. /** head of registered input format linked list */
  38. static AVInputFormat *first_iformat = NULL;
  39. /** head of registered output format linked list */
  40. static AVOutputFormat *first_oformat = NULL;
  41.  
  42. static AVInputFormat **last_iformat = &first_iformat;
  43. static AVOutputFormat **last_oformat = &first_oformat;
  44.  
  45. AVInputFormat *av_iformat_next(const AVInputFormat *f)
  46. {
  47.     if (f)
  48.         return f->next;
  49.     else
  50.         return first_iformat;
  51. }
  52.  
  53. AVOutputFormat *av_oformat_next(const AVOutputFormat *f)
  54. {
  55.     if (f)
  56.         return f->next;
  57.     else
  58.         return first_oformat;
  59. }
  60.  
  61. void av_register_input_format(AVInputFormat *format)
  62. {
  63.     AVInputFormat **p = last_iformat;
  64.  
  65.     format->next = NULL;
  66.     while(*p || avpriv_atomic_ptr_cas((void * volatile *)p, NULL, format))
  67.         p = &(*p)->next;
  68.     last_iformat = &format->next;
  69. }
  70.  
  71. void av_register_output_format(AVOutputFormat *format)
  72. {
  73.     AVOutputFormat **p = last_oformat;
  74.  
  75.     format->next = NULL;
  76.     while(*p || avpriv_atomic_ptr_cas((void * volatile *)p, NULL, format))
  77.         p = &(*p)->next;
  78.     last_oformat = &format->next;
  79. }
  80.  
  81. int av_match_ext(const char *filename, const char *extensions)
  82. {
  83.     const char *ext;
  84.  
  85.     if (!filename)
  86.         return 0;
  87.  
  88.     ext = strrchr(filename, '.');
  89.     if (ext)
  90.         return av_match_name(ext + 1, extensions);
  91.     return 0;
  92. }
  93.  
  94. AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
  95.                                 const char *mime_type)
  96. {
  97.     AVOutputFormat *fmt = NULL, *fmt_found;
  98.     int score_max, score;
  99.  
  100.     /* specific test for image sequences */
  101. #if CONFIG_IMAGE2_MUXER
  102.     if (!short_name && filename &&
  103.         av_filename_number_test(filename) &&
  104.         ff_guess_image2_codec(filename) != AV_CODEC_ID_NONE) {
  105.         return av_guess_format("image2", NULL, NULL);
  106.     }
  107. #endif
  108.     /* Find the proper file type. */
  109.     fmt_found = NULL;
  110.     score_max = 0;
  111.     while ((fmt = av_oformat_next(fmt))) {
  112.         score = 0;
  113.         if (fmt->name && short_name && av_match_name(short_name, fmt->name))
  114.             score += 100;
  115.         if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
  116.             score += 10;
  117.         if (filename && fmt->extensions &&
  118.             av_match_ext(filename, fmt->extensions)) {
  119.             score += 5;
  120.         }
  121.         if (score > score_max) {
  122.             score_max = score;
  123.             fmt_found = fmt;
  124.         }
  125.     }
  126.     return fmt_found;
  127. }
  128.  
  129. enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
  130.                               const char *filename, const char *mime_type,
  131.                               enum AVMediaType type)
  132. {
  133.     if (av_match_name("segment", fmt->name) || av_match_name("ssegment", fmt->name)) {
  134.         AVOutputFormat *fmt2 = av_guess_format(NULL, filename, NULL);
  135.         if (fmt2)
  136.             fmt = fmt2;
  137.     }
  138.  
  139.     if (type == AVMEDIA_TYPE_VIDEO) {
  140.         enum AVCodecID codec_id = AV_CODEC_ID_NONE;
  141.  
  142. #if CONFIG_IMAGE2_MUXER
  143.         if (!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")) {
  144.             codec_id = ff_guess_image2_codec(filename);
  145.         }
  146. #endif
  147.         if (codec_id == AV_CODEC_ID_NONE)
  148.             codec_id = fmt->video_codec;
  149.         return codec_id;
  150.     } else if (type == AVMEDIA_TYPE_AUDIO)
  151.         return fmt->audio_codec;
  152.     else if (type == AVMEDIA_TYPE_SUBTITLE)
  153.         return fmt->subtitle_codec;
  154.     else if (type == AVMEDIA_TYPE_DATA)
  155.         return fmt->data_codec;
  156.     else
  157.         return AV_CODEC_ID_NONE;
  158. }
  159.  
  160. AVInputFormat *av_find_input_format(const char *short_name)
  161. {
  162.     AVInputFormat *fmt = NULL;
  163.     while ((fmt = av_iformat_next(fmt)))
  164.         if (av_match_name(short_name, fmt->name))
  165.             return fmt;
  166.     return NULL;
  167. }
  168.  
  169. AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened,
  170.                                       int *score_ret)
  171. {
  172.     AVProbeData lpd = *pd;
  173.     AVInputFormat *fmt1 = NULL, *fmt;
  174.     int score, nodat = 0, score_max = 0;
  175.     const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
  176.  
  177.     if (!lpd.buf)
  178.         lpd.buf = zerobuffer;
  179.  
  180.     if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
  181.         int id3len = ff_id3v2_tag_len(lpd.buf);
  182.         if (lpd.buf_size > id3len + 16) {
  183.             lpd.buf      += id3len;
  184.             lpd.buf_size -= id3len;
  185.         } else if (id3len >= PROBE_BUF_MAX) {
  186.             nodat = 2;
  187.         } else
  188.             nodat = 1;
  189.     }
  190.  
  191.     fmt = NULL;
  192.     while ((fmt1 = av_iformat_next(fmt1))) {
  193.         if (!is_opened == !(fmt1->flags & AVFMT_NOFILE) && strcmp(fmt1->name, "image2"))
  194.             continue;
  195.         score = 0;
  196.         if (fmt1->read_probe) {
  197.             score = fmt1->read_probe(&lpd);
  198.             if (score)
  199.                 av_log(NULL, AV_LOG_TRACE, "Probing %s score:%d size:%d\n", fmt1->name, score, lpd.buf_size);
  200.             if (fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions)) {
  201.                 if      (nodat == 0) score = FFMAX(score, 1);
  202.                 else if (nodat == 1) score = FFMAX(score, AVPROBE_SCORE_EXTENSION / 2 - 1);
  203.                 else                 score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
  204.             }
  205.         } else if (fmt1->extensions) {
  206.             if (av_match_ext(lpd.filename, fmt1->extensions))
  207.                 score = AVPROBE_SCORE_EXTENSION;
  208.         }
  209.         if (av_match_name(lpd.mime_type, fmt1->mime_type))
  210.             score = FFMAX(score, AVPROBE_SCORE_MIME);
  211.         if (score > score_max) {
  212.             score_max = score;
  213.             fmt       = fmt1;
  214.         } else if (score == score_max)
  215.             fmt = NULL;
  216.     }
  217.     if (nodat == 1)
  218.         score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
  219.     *score_ret = score_max;
  220.  
  221.     return fmt;
  222. }
  223.  
  224. AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
  225. {
  226.     int score_ret;
  227.     AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);
  228.     if (score_ret > *score_max) {
  229.         *score_max = score_ret;
  230.         return fmt;
  231.     } else
  232.         return NULL;
  233. }
  234.  
  235. AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
  236. {
  237.     int score = 0;
  238.     return av_probe_input_format2(pd, is_opened, &score);
  239. }
  240.  
  241. int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt,
  242.                           const char *filename, void *logctx,
  243.                           unsigned int offset, unsigned int max_probe_size)
  244. {
  245.     AVProbeData pd = { filename ? filename : "" };
  246.     uint8_t *buf = NULL;
  247.     int ret = 0, probe_size, buf_offset = 0;
  248.     int score = 0;
  249.     int ret2;
  250.  
  251.     if (!max_probe_size)
  252.         max_probe_size = PROBE_BUF_MAX;
  253.     else if (max_probe_size < PROBE_BUF_MIN) {
  254.         av_log(logctx, AV_LOG_ERROR,
  255.                "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
  256.         return AVERROR(EINVAL);
  257.     }
  258.  
  259.     if (offset >= max_probe_size)
  260.         return AVERROR(EINVAL);
  261.  
  262.     if (pb->av_class) {
  263.         uint8_t *mime_type_opt = NULL;
  264.         av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type_opt);
  265.         pd.mime_type = (const char *)mime_type_opt;
  266.     }
  267. #if 0
  268.     if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) {
  269.         if (!av_strcasecmp(mime_type, "audio/aacp")) {
  270.             *fmt = av_find_input_format("aac");
  271.         }
  272.         av_freep(&mime_type);
  273.     }
  274. #endif
  275.  
  276.     for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt;
  277.          probe_size = FFMIN(probe_size << 1,
  278.                             FFMAX(max_probe_size, probe_size + 1))) {
  279.         score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
  280.  
  281.         /* Read probe data. */
  282.         if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
  283.             goto fail;
  284.         if ((ret = avio_read(pb, buf + buf_offset,
  285.                              probe_size - buf_offset)) < 0) {
  286.             /* Fail if error was not end of file, otherwise, lower score. */
  287.             if (ret != AVERROR_EOF)
  288.                 goto fail;
  289.  
  290.             score = 0;
  291.             ret   = 0;          /* error was end of file, nothing read */
  292.         }
  293.         buf_offset += ret;
  294.         if (buf_offset < offset)
  295.             continue;
  296.         pd.buf_size = buf_offset - offset;
  297.         pd.buf = &buf[offset];
  298.  
  299.         memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
  300.  
  301.         /* Guess file format. */
  302.         *fmt = av_probe_input_format2(&pd, 1, &score);
  303.         if (*fmt) {
  304.             /* This can only be true in the last iteration. */
  305.             if (score <= AVPROBE_SCORE_RETRY) {
  306.                 av_log(logctx, AV_LOG_WARNING,
  307.                        "Format %s detected only with low score of %d, "
  308.                        "misdetection possible!\n", (*fmt)->name, score);
  309.             } else
  310.                 av_log(logctx, AV_LOG_DEBUG,
  311.                        "Format %s probed with size=%d and score=%d\n",
  312.                        (*fmt)->name, probe_size, score);
  313. #if 0
  314.             FILE *f = fopen("probestat.tmp", "ab");
  315.             fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
  316.             fclose(f);
  317. #endif
  318.         }
  319.     }
  320.  
  321.     if (!*fmt)
  322.         ret = AVERROR_INVALIDDATA;
  323.  
  324. fail:
  325.     /* Rewind. Reuse probe buffer to avoid seeking. */
  326.     ret2 = ffio_rewind_with_probe_data(pb, &buf, buf_offset);
  327.     if (ret >= 0)
  328.         ret = ret2;
  329.  
  330.     av_freep(&pd.mime_type);
  331.     return ret < 0 ? ret : score;
  332. }
  333.  
  334. int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
  335.                           const char *filename, void *logctx,
  336.                           unsigned int offset, unsigned int max_probe_size)
  337. {
  338.     int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
  339.     return ret < 0 ? ret : 0;
  340. }
  341.