LCOV - code coverage report
Current view: top level - libavformat - format.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 164 190 86.3 %
Date: 2017-12-17 04:34:43 Functions: 12 13 92.3 %

          Line data    Source code
       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  2031341057 : AVInputFormat *av_iformat_next(const AVInputFormat *f)
      46             : {
      47  2031341057 :     if (f)
      48  2021483896 :         return f->next;
      49             :     else
      50     9857161 :         return first_iformat;
      51             : }
      52             : 
      53   288327188 : AVOutputFormat *av_oformat_next(const AVOutputFormat *f)
      54             : {
      55   288327188 :     if (f)
      56   284630975 :         return f->next;
      57             :     else
      58     3696213 :         return first_oformat;
      59             : }
      60             : 
      61     1610304 : void av_register_input_format(AVInputFormat *format)
      62             : {
      63     1610304 :     AVInputFormat **p = last_iformat;
      64             : 
      65             :     // Note, format could be added after the first 2 checks but that implies that *p is no longer NULL
      66     3220608 :     while(p != &format->next && !format->next && avpriv_atomic_ptr_cas((void * volatile *)p, NULL, format))
      67           0 :         p = &(*p)->next;
      68             : 
      69     1610304 :     if (!format->next)
      70     1610304 :         last_iformat = &format->next;
      71     1610304 : }
      72             : 
      73      888935 : void av_register_output_format(AVOutputFormat *format)
      74             : {
      75      888935 :     AVOutputFormat **p = last_oformat;
      76             : 
      77             :     // Note, format could be added after the first 2 checks but that implies that *p is no longer NULL
      78     1777870 :     while(p != &format->next && !format->next && avpriv_atomic_ptr_cas((void * volatile *)p, NULL, format))
      79           0 :         p = &(*p)->next;
      80             : 
      81      888935 :     if (!format->next)
      82      888935 :         last_oformat = &format->next;
      83      888935 : }
      84             : 
      85      769838 : int av_match_ext(const char *filename, const char *extensions)
      86             : {
      87             :     const char *ext;
      88             : 
      89      769838 :     if (!filename)
      90      333576 :         return 0;
      91             : 
      92      436262 :     ext = strrchr(filename, '.');
      93      436262 :     if (ext)
      94      433616 :         return av_match_name(ext + 1, extensions);
      95        2646 :     return 0;
      96             : }
      97             : 
      98        5490 : AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
      99             :                                 const char *mime_type)
     100             : {
     101        5490 :     AVOutputFormat *fmt = NULL, *fmt_found;
     102             :     int score_max, score;
     103             : 
     104             :     /* specific test for image sequences */
     105             : #if CONFIG_IMAGE2_MUXER
     106        5653 :     if (!short_name && filename &&
     107         201 :         av_filename_number_test(filename) &&
     108          38 :         ff_guess_image2_codec(filename) != AV_CODEC_ID_NONE) {
     109          33 :         return av_guess_format("image2", NULL, NULL);
     110             :     }
     111             : #endif
     112             :     /* Find the proper file type. */
     113        5457 :     fmt_found = NULL;
     114        5457 :     score_max = 0;
     115      878445 :     while ((fmt = av_oformat_next(fmt))) {
     116      867531 :         score = 0;
     117      867531 :         if (fmt->name && short_name && av_match_name(short_name, fmt->name))
     118        5333 :             score += 100;
     119      867531 :         if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
     120           0 :             score += 10;
     121      882899 :         if (filename && fmt->extensions &&
     122       15368 :             av_match_ext(filename, fmt->extensions)) {
     123         140 :             score += 5;
     124             :         }
     125      867531 :         if (score > score_max) {
     126        5457 :             score_max = score;
     127        5457 :             fmt_found = fmt;
     128             :         }
     129             :     }
     130        5457 :     return fmt_found;
     131             : }
     132             : 
     133       18326 : enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
     134             :                               const char *filename, const char *mime_type,
     135             :                               enum AVMediaType type)
     136             : {
     137       18326 :     if (av_match_name("segment", fmt->name) || av_match_name("ssegment", fmt->name)) {
     138           0 :         AVOutputFormat *fmt2 = av_guess_format(NULL, filename, NULL);
     139           0 :         if (fmt2)
     140           0 :             fmt = fmt2;
     141             :     }
     142             : 
     143       18326 :     if (type == AVMEDIA_TYPE_VIDEO) {
     144        7169 :         enum AVCodecID codec_id = AV_CODEC_ID_NONE;
     145             : 
     146             : #if CONFIG_IMAGE2_MUXER
     147        7169 :         if (!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")) {
     148          72 :             codec_id = ff_guess_image2_codec(filename);
     149             :         }
     150             : #endif
     151        7169 :         if (codec_id == AV_CODEC_ID_NONE)
     152        7097 :             codec_id = fmt->video_codec;
     153        7169 :         return codec_id;
     154       11157 :     } else if (type == AVMEDIA_TYPE_AUDIO)
     155        5751 :         return fmt->audio_codec;
     156        5406 :     else if (type == AVMEDIA_TYPE_SUBTITLE)
     157          26 :         return fmt->subtitle_codec;
     158        5380 :     else if (type == AVMEDIA_TYPE_DATA)
     159        5380 :         return fmt->data_codec;
     160             :     else
     161           0 :         return AV_CODEC_ID_NONE;
     162             : }
     163             : 
     164        2510 : AVInputFormat *av_find_input_format(const char *short_name)
     165             : {
     166        2510 :     AVInputFormat *fmt = NULL;
     167      315997 :     while ((fmt = av_iformat_next(fmt)))
     168      313487 :         if (av_match_name(short_name, fmt->name))
     169        2510 :             return fmt;
     170           0 :     return NULL;
     171             : }
     172             : 
     173        9339 : AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened,
     174             :                                       int *score_ret)
     175             : {
     176        9339 :     AVProbeData lpd = *pd;
     177        9339 :     AVInputFormat *fmt1 = NULL, *fmt;
     178        9339 :     int score, score_max = 0;
     179             :     const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
     180             :     enum nodat {
     181             :         NO_ID3,
     182             :         ID3_ALMOST_GREATER_PROBE,
     183             :         ID3_GREATER_PROBE,
     184             :         ID3_GREATER_MAX_PROBE,
     185        9339 :     } nodat = NO_ID3;
     186             : 
     187        9339 :     if (!lpd.buf)
     188        3209 :         lpd.buf = (unsigned char *) zerobuffer;
     189             : 
     190        9339 :     if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
     191          27 :         int id3len = ff_id3v2_tag_len(lpd.buf);
     192          27 :         if (lpd.buf_size > id3len + 16) {
     193          22 :             if (lpd.buf_size < 2LL*id3len + 16)
     194          10 :                 nodat = ID3_ALMOST_GREATER_PROBE;
     195          22 :             lpd.buf      += id3len;
     196          22 :             lpd.buf_size -= id3len;
     197           5 :         } else if (id3len >= PROBE_BUF_MAX) {
     198           0 :             nodat = ID3_GREATER_MAX_PROBE;
     199             :         } else
     200           5 :             nodat = ID3_GREATER_PROBE;
     201             :     }
     202             : 
     203        9339 :     fmt = NULL;
     204     2706552 :     while ((fmt1 = av_iformat_next(fmt1))) {
     205     2687874 :         if (!is_opened == !(fmt1->flags & AVFMT_NOFILE) && strcmp(fmt1->name, "image2"))
     206      946282 :             continue;
     207     1741592 :         score = 0;
     208     1741592 :         if (fmt1->read_probe) {
     209     1450337 :             score = fmt1->read_probe(&lpd);
     210     1450337 :             if (score)
     211        6906 :                 av_log(NULL, AV_LOG_TRACE, "Probing %s score:%d size:%d\n", fmt1->name, score, lpd.buf_size);
     212     1450337 :             if (fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions)) {
     213        1641 :                 switch (nodat) {
     214        1630 :                 case NO_ID3:
     215        1630 :                     score = FFMAX(score, 1);
     216        1630 :                     break;
     217          11 :                 case ID3_GREATER_PROBE:
     218             :                 case ID3_ALMOST_GREATER_PROBE:
     219          11 :                     score = FFMAX(score, AVPROBE_SCORE_EXTENSION / 2 - 1);
     220          11 :                     break;
     221           0 :                 case ID3_GREATER_MAX_PROBE:
     222           0 :                     score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
     223           0 :                     break;
     224             :                 }
     225             :             }
     226      291255 :         } else if (fmt1->extensions) {
     227      153250 :             if (av_match_ext(lpd.filename, fmt1->extensions))
     228          31 :                 score = AVPROBE_SCORE_EXTENSION;
     229             :         }
     230     1741592 :         if (av_match_name(lpd.mime_type, fmt1->mime_type)) {
     231           0 :             if (AVPROBE_SCORE_MIME > score) {
     232           0 :                 av_log(NULL, AV_LOG_DEBUG, "Probing %s score:%d increased to %d due to MIME type\n", fmt1->name, score, AVPROBE_SCORE_MIME);
     233           0 :                 score = AVPROBE_SCORE_MIME;
     234             :             }
     235             :         }
     236     1741592 :         if (score > score_max) {
     237        6040 :             score_max = score;
     238        6040 :             fmt       = fmt1;
     239     1735552 :         } else if (score == score_max)
     240      843930 :             fmt = NULL;
     241             :     }
     242        9339 :     if (nodat == ID3_GREATER_PROBE)
     243           5 :         score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
     244        9339 :     *score_ret = score_max;
     245             : 
     246        9339 :     return fmt;
     247             : }
     248             : 
     249        6627 : AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
     250             : {
     251             :     int score_ret;
     252        6627 :     AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);
     253        6627 :     if (score_ret > *score_max) {
     254        3213 :         *score_max = score_ret;
     255        3213 :         return fmt;
     256             :     } else
     257        3414 :         return NULL;
     258             : }
     259             : 
     260           0 : AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
     261             : {
     262           0 :     int score = 0;
     263           0 :     return av_probe_input_format2(pd, is_opened, &score);
     264             : }
     265             : 
     266        3053 : int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt,
     267             :                           const char *filename, void *logctx,
     268             :                           unsigned int offset, unsigned int max_probe_size)
     269             : {
     270        3053 :     AVProbeData pd = { filename ? filename : "" };
     271        3053 :     uint8_t *buf = NULL;
     272        3053 :     int ret = 0, probe_size, buf_offset = 0;
     273        3053 :     int score = 0;
     274             :     int ret2;
     275             : 
     276        3053 :     if (!max_probe_size)
     277           4 :         max_probe_size = PROBE_BUF_MAX;
     278        3049 :     else if (max_probe_size < PROBE_BUF_MIN) {
     279           0 :         av_log(logctx, AV_LOG_ERROR,
     280             :                "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
     281           0 :         return AVERROR(EINVAL);
     282             :     }
     283             : 
     284        3053 :     if (offset >= max_probe_size)
     285           0 :         return AVERROR(EINVAL);
     286             : 
     287        3053 :     if (pb->av_class) {
     288        3049 :         uint8_t *mime_type_opt = NULL;
     289             :         char *semi;
     290        3049 :         av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type_opt);
     291        3049 :         pd.mime_type = (const char *)mime_type_opt;
     292        3049 :         semi = pd.mime_type ? strchr(pd.mime_type, ';') : NULL;
     293        3049 :         if (semi) {
     294           0 :             *semi = '\0';
     295             :         }
     296             :     }
     297             : #if 0
     298             :     if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) {
     299             :         if (!av_strcasecmp(mime_type, "audio/aacp")) {
     300             :             *fmt = av_find_input_format("aac");
     301             :         }
     302             :         av_freep(&mime_type);
     303             :     }
     304             : #endif
     305             : 
     306        9524 :     for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt;
     307        3418 :          probe_size = FFMIN(probe_size << 1,
     308             :                             FFMAX(max_probe_size, probe_size + 1))) {
     309        3418 :         score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
     310             : 
     311             :         /* Read probe data. */
     312        3418 :         if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
     313           0 :             goto fail;
     314        3418 :         if ((ret = avio_read(pb, buf + buf_offset,
     315             :                              probe_size - buf_offset)) < 0) {
     316             :             /* Fail if error was not end of file, otherwise, lower score. */
     317           6 :             if (ret != AVERROR_EOF)
     318           0 :                 goto fail;
     319             : 
     320           6 :             score = 0;
     321           6 :             ret   = 0;          /* error was end of file, nothing read */
     322             :         }
     323        3418 :         buf_offset += ret;
     324        3418 :         if (buf_offset < offset)
     325           0 :             continue;
     326        3418 :         pd.buf_size = buf_offset - offset;
     327        3418 :         pd.buf = &buf[offset];
     328             : 
     329        3418 :         memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
     330             : 
     331             :         /* Guess file format. */
     332        3418 :         *fmt = av_probe_input_format2(&pd, 1, &score);
     333        3418 :         if (*fmt) {
     334             :             /* This can only be true in the last iteration. */
     335        3053 :             if (score <= AVPROBE_SCORE_RETRY) {
     336          14 :                 av_log(logctx, AV_LOG_WARNING,
     337             :                        "Format %s detected only with low score of %d, "
     338           7 :                        "misdetection possible!\n", (*fmt)->name, score);
     339             :             } else
     340        6092 :                 av_log(logctx, AV_LOG_DEBUG,
     341             :                        "Format %s probed with size=%d and score=%d\n",
     342        3046 :                        (*fmt)->name, probe_size, score);
     343             : #if 0
     344             :             FILE *f = fopen("probestat.tmp", "ab");
     345             :             fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
     346             :             fclose(f);
     347             : #endif
     348             :         }
     349             :     }
     350             : 
     351        3053 :     if (!*fmt)
     352           0 :         ret = AVERROR_INVALIDDATA;
     353             : 
     354        6106 : fail:
     355             :     /* Rewind. Reuse probe buffer to avoid seeking. */
     356        3053 :     ret2 = ffio_rewind_with_probe_data(pb, &buf, buf_offset);
     357        3053 :     if (ret >= 0)
     358        3053 :         ret = ret2;
     359             : 
     360        3053 :     av_freep(&pd.mime_type);
     361        3053 :     return ret < 0 ? ret : score;
     362             : }
     363             : 
     364           4 : int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
     365             :                           const char *filename, void *logctx,
     366             :                           unsigned int offset, unsigned int max_probe_size)
     367             : {
     368           4 :     int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
     369           4 :     return ret < 0 ? ret : 0;
     370             : }

Generated by: LCOV version 1.13