mirror of
https://git.videolan.org/git/ffmpeg.git
synced 2024-08-14 21:35:06 +02:00
49f10c9cb1
Reviewed-by: Stefano Sabatini Signed-off-by: Michael Niedermayer <michaelni@gmx.at>
190 lines
5.2 KiB
C
190 lines
5.2 KiB
C
/*
|
|
* Format register and lookup
|
|
* Copyright (c) 2000, 2001, 2002 Fabrice Bellard
|
|
*
|
|
* This file is part of FFmpeg.
|
|
*
|
|
* FFmpeg is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with FFmpeg; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#include "avformat.h"
|
|
#include "internal.h"
|
|
#include "libavutil/atomic.h"
|
|
#include "libavutil/avstring.h"
|
|
|
|
/**
|
|
* @file
|
|
* Format register and lookup
|
|
*/
|
|
/** head of registered input format linked list */
|
|
static AVInputFormat *first_iformat = NULL;
|
|
/** head of registered output format linked list */
|
|
static AVOutputFormat *first_oformat = NULL;
|
|
|
|
static AVInputFormat **last_iformat = &first_iformat;
|
|
static AVOutputFormat **last_oformat = &first_oformat;
|
|
|
|
AVInputFormat *av_iformat_next(AVInputFormat *f)
|
|
{
|
|
if (f)
|
|
return f->next;
|
|
else
|
|
return first_iformat;
|
|
}
|
|
|
|
AVOutputFormat *av_oformat_next(AVOutputFormat *f)
|
|
{
|
|
if (f)
|
|
return f->next;
|
|
else
|
|
return first_oformat;
|
|
}
|
|
|
|
void av_register_input_format(AVInputFormat *format)
|
|
{
|
|
AVInputFormat **p = last_iformat;
|
|
|
|
format->next = NULL;
|
|
while(*p || avpriv_atomic_ptr_cas((void * volatile *)p, NULL, format))
|
|
p = &(*p)->next;
|
|
last_iformat = &format->next;
|
|
}
|
|
|
|
void av_register_output_format(AVOutputFormat *format)
|
|
{
|
|
AVOutputFormat **p = last_oformat;
|
|
|
|
format->next = NULL;
|
|
while(*p || avpriv_atomic_ptr_cas((void * volatile *)p, NULL, format))
|
|
p = &(*p)->next;
|
|
last_oformat = &format->next;
|
|
}
|
|
|
|
int av_match_ext(const char *filename, const char *extensions)
|
|
{
|
|
const char *ext, *p;
|
|
char ext1[32], *q;
|
|
|
|
if (!filename)
|
|
return 0;
|
|
|
|
ext = strrchr(filename, '.');
|
|
if (ext) {
|
|
ext++;
|
|
p = extensions;
|
|
for (;;) {
|
|
q = ext1;
|
|
while (*p != '\0' && *p != ',' && q - ext1 < sizeof(ext1) - 1)
|
|
*q++ = *p++;
|
|
*q = '\0';
|
|
if (!av_strcasecmp(ext1, ext))
|
|
return 1;
|
|
if (*p == '\0')
|
|
break;
|
|
p++;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int match_format(const char *name, const char *names)
|
|
{
|
|
const char *p;
|
|
int len, namelen;
|
|
|
|
if (!name || !names)
|
|
return 0;
|
|
|
|
namelen = strlen(name);
|
|
while ((p = strchr(names, ','))) {
|
|
len = FFMAX(p - names, namelen);
|
|
if (!av_strncasecmp(name, names, len))
|
|
return 1;
|
|
names = p + 1;
|
|
}
|
|
return !av_strcasecmp(name, names);
|
|
}
|
|
|
|
AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
|
|
const char *mime_type)
|
|
{
|
|
AVOutputFormat *fmt = NULL, *fmt_found;
|
|
int score_max, score;
|
|
|
|
/* specific test for image sequences */
|
|
#if CONFIG_IMAGE2_MUXER
|
|
if (!short_name && filename &&
|
|
av_filename_number_test(filename) &&
|
|
ff_guess_image2_codec(filename) != AV_CODEC_ID_NONE) {
|
|
return av_guess_format("image2", NULL, NULL);
|
|
}
|
|
#endif
|
|
/* Find the proper file type. */
|
|
fmt_found = NULL;
|
|
score_max = 0;
|
|
while ((fmt = av_oformat_next(fmt))) {
|
|
score = 0;
|
|
if (fmt->name && short_name && match_format(short_name, fmt->name))
|
|
score += 100;
|
|
if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
|
|
score += 10;
|
|
if (filename && fmt->extensions &&
|
|
av_match_ext(filename, fmt->extensions)) {
|
|
score += 5;
|
|
}
|
|
if (score > score_max) {
|
|
score_max = score;
|
|
fmt_found = fmt;
|
|
}
|
|
}
|
|
return fmt_found;
|
|
}
|
|
|
|
enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
|
|
const char *filename, const char *mime_type,
|
|
enum AVMediaType type)
|
|
{
|
|
if (!strcmp(fmt->name, "segment") || !strcmp(fmt->name, "ssegment")) {
|
|
fmt = av_guess_format(NULL, filename, NULL);
|
|
}
|
|
|
|
if (type == AVMEDIA_TYPE_VIDEO) {
|
|
enum AVCodecID codec_id = AV_CODEC_ID_NONE;
|
|
|
|
#if CONFIG_IMAGE2_MUXER
|
|
if (!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")) {
|
|
codec_id = ff_guess_image2_codec(filename);
|
|
}
|
|
#endif
|
|
if (codec_id == AV_CODEC_ID_NONE)
|
|
codec_id = fmt->video_codec;
|
|
return codec_id;
|
|
} else if (type == AVMEDIA_TYPE_AUDIO)
|
|
return fmt->audio_codec;
|
|
else if (type == AVMEDIA_TYPE_SUBTITLE)
|
|
return fmt->subtitle_codec;
|
|
else
|
|
return AV_CODEC_ID_NONE;
|
|
}
|
|
|
|
AVInputFormat *av_find_input_format(const char *short_name)
|
|
{
|
|
AVInputFormat *fmt = NULL;
|
|
while ((fmt = av_iformat_next(fmt)))
|
|
if (match_format(short_name, fmt->name))
|
|
return fmt;
|
|
return NULL;
|
|
}
|