FFmpeg: libavformat/format.c Source File

FFmpeg

[フレーム]

libavformat

format.c

Go to the documentation of this file.

1 /*

2 * Format register and lookup

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 */

22 #include "avformat.h"

23 #include "internal.h"

24 #include "libavutil/atomic.h"

25 #include "libavutil/avstring.h"

27 /**

28 * @file

29 * Format register and lookup

30 */

31 /** head of registered input format linked list */

32 static AVInputFormat *first_iformat = NULL;

33 /** head of registered output format linked list */

34 static AVOutputFormat *first_oformat = NULL;

36 AVInputFormat *av_iformat_next(AVInputFormat *f)

37 {

38 if (f)

39 return f->next;

40 else

41 return first_iformat;

42 }

44 AVOutputFormat *av_oformat_next(AVOutputFormat *f)

45 {

46 if (f)

47 return f->next;

48 else

49 return first_oformat;

50 }

52 void av_register_input_format(AVInputFormat *format)

53 {

54 AVInputFormat **p = &first_iformat;

56 format->next = NULL;

57 while(*p || avpriv_atomic_ptr_cas((void * volatile *)p, NULL, format))

58 p = &(*p)->next;

59 }

61 void av_register_output_format(AVOutputFormat *format)

62 {

63 AVOutputFormat **p = &first_oformat;

65 format->next = NULL;

66 while(*p || avpriv_atomic_ptr_cas((void * volatile *)p, NULL, format))

67 p = &(*p)->next;

68 }

70 int av_match_ext(const char *filename, const char *extensions)

71 {

72 const char *ext, *p;

73 char ext1[32], *q;

75 if (!filename)

76 return 0;

78 ext = strrchr(filename, '.');

79 if (ext) {

80 ext++;

81 p = extensions;

82 for (;;) {

83 q = ext1;

84 while (*p != '0円' && *p != ',' && q - ext1 < sizeof(ext1) - 1)

85 *q++ = *p++;

86 *q = '0円';

87 if (!av_strcasecmp(ext1, ext))

88 return 1;

89 if (*p == '0円')

90 break;

91 p++;

92 }

93 }

94 return 0;

95 }

97 static int match_format(const char *name, const char *names)

98 {

99 const char *p;

100 int len, namelen;

101

102 if (!name || !names)

103 return 0;

104

105 namelen = strlen(name);

106 while ((p = strchr(names, ','))) {

107 len = FFMAX(p - names, namelen);

108 if (!av_strncasecmp(name, names, len))

109 return 1;

110 names = p + 1;

111 }

112 return !av_strcasecmp(name, names);

113 }

114

115 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,

116 const char *mime_type)

117 {

118 AVOutputFormat *fmt = NULL, *fmt_found;

119 int score_max, score;

120

121 /* specific test for image sequences */

122 #if CONFIG_IMAGE2_MUXER

123 if (!short_name && filename &&

124 av_filename_number_test(filename) &&

125 ff_guess_image2_codec(filename) != AV_CODEC_ID_NONE) {

126 return av_guess_format("image2", NULL, NULL);

127 }

128 #endif

129 /* Find the proper file type. */

130 fmt_found = NULL;

131 score_max = 0;

132 while ((fmt = av_oformat_next(fmt))) {

133 score = 0;

134 if (fmt->name && short_name && match_format(short_name, fmt->name))

135 score += 100;

136 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))

137 score += 10;

138 if (filename && fmt->extensions &&

139 av_match_ext(filename, fmt->extensions)) {

140 score += 5;

141 }

142 if (score > score_max) {

143 score_max = score;

144 fmt_found = fmt;

145 }

146 }

147 return fmt_found;

148 }

149

150 enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,

151 const char *filename, const char *mime_type,

152 enum AVMediaType type)

153 {

154 if (!strcmp(fmt->name, "segment") || !strcmp(fmt->name, "ssegment")) {

155 fmt = av_guess_format(NULL, filename, NULL);

156 }

157

158 if (type == AVMEDIA_TYPE_VIDEO) {

159 enum AVCodecID codec_id = AV_CODEC_ID_NONE;

160

161 #if CONFIG_IMAGE2_MUXER

162 if (!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")) {

163 codec_id = ff_guess_image2_codec(filename);

164 }

165 #endif

166 if (codec_id == AV_CODEC_ID_NONE)

167 codec_id = fmt->video_codec;

168 return codec_id;

169 } else if (type == AVMEDIA_TYPE_AUDIO)

170 return fmt->audio_codec;

171 else if (type == AVMEDIA_TYPE_SUBTITLE)

172 return fmt->subtitle_codec;

173 else

174 return AV_CODEC_ID_NONE;

175 }

176

177 AVInputFormat *av_find_input_format(const char *short_name)

178 {

179 AVInputFormat *fmt = NULL;

180 while ((fmt = av_iformat_next(fmt)))

181 if (match_format(short_name, fmt->name))

182 return fmt;

183 return NULL;

184 }

Generated on Sat Jan 25 2014 19:52:02 for FFmpeg by doxygen 1.8.2