FFmpeg: libavfilter/af_volume.c Source File

FFmpeg

[フレーム]

libavfilter

af_volume.c

Go to the documentation of this file.

1 /*

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

23 * @file

24 * audio volume filter

25 */

27 #include "libavutil/channel_layout.h"

28 #include "libavutil/common.h"

29 #include "libavutil/eval.h"

30 #include "libavutil/float_dsp.h"

31 #include "libavutil/opt.h"

32 #include "audio.h"

33 #include "avfilter.h"

34 #include "formats.h"

35 #include "internal.h"

36 #include "af_volume.h"

38 static const char *precision_str[] = {

39 "fixed", "float", "double"

40 };

42 #define OFFSET(x) offsetof(VolumeContext, x)

43 #define A AV_OPT_FLAG_AUDIO_PARAM

44 #define F AV_OPT_FLAG_FILTERING_PARAM

46 static const AVOption volume_options[] = {

47 { "volume", "set volume adjustment",

48 OFFSET(volume), AV_OPT_TYPE_DOUBLE, { .dbl = 1.0 }, 0, 0x7fffff, A|F },

49 { "precision", "select mathematical precision",

50 OFFSET(precision), AV_OPT_TYPE_INT, { .i64 = PRECISION_FLOAT }, PRECISION_FIXED, PRECISION_DOUBLE, A|F, "precision" },

51 { "fixed", "select 8-bit fixed-point", 0, AV_OPT_TYPE_CONST, { .i64 = PRECISION_FIXED }, INT_MIN, INT_MAX, A|F, "precision" },

52 { "float", "select 32-bit floating-point", 0, AV_OPT_TYPE_CONST, { .i64 = PRECISION_FLOAT }, INT_MIN, INT_MAX, A|F, "precision" },

53 { "double", "select 64-bit floating-point", 0, AV_OPT_TYPE_CONST, { .i64 = PRECISION_DOUBLE }, INT_MIN, INT_MAX, A|F, "precision" },

54 { NULL }

55 };

57 AVFILTER_DEFINE_CLASS(volume);

59 static av_cold int init(AVFilterContext *ctx)

60 {

61 VolumeContext *vol = ctx->priv;

63 if (vol->precision == PRECISION_FIXED) {

64 vol->volume_i = (int)(vol->volume * 256 + 0.5);

65 vol->volume = vol->volume_i / 256.0;

66 av_log(ctx, AV_LOG_VERBOSE, "volume:(%d/256)(%f)(%1.2fdB) precision:fixed\n",

67 vol->volume_i, vol->volume, 20.0*log(vol->volume)/M_LN10);

68 } else {

69 av_log(ctx, AV_LOG_VERBOSE, "volume:(%f)(%1.2fdB) precision:%s\n",

70 vol->volume, 20.0*log(vol->volume)/M_LN10,

71 precision_str[vol->precision]);

72 }

74 return 0;

75 }

77 static int query_formats(AVFilterContext *ctx)

78 {

79 VolumeContext *vol = ctx->priv;

80 AVFilterFormats *formats = NULL;

81 AVFilterChannelLayouts *layouts;

82 static const enum AVSampleFormat sample_fmts[][7] = {

83 [PRECISION_FIXED] = {

84 AV_SAMPLE_FMT_U8,

85 AV_SAMPLE_FMT_U8P,

86 AV_SAMPLE_FMT_S16,

87 AV_SAMPLE_FMT_S16P,

88 AV_SAMPLE_FMT_S32,

89 AV_SAMPLE_FMT_S32P,

90 AV_SAMPLE_FMT_NONE

91 },

92 [PRECISION_FLOAT] = {

93 AV_SAMPLE_FMT_FLT,

94 AV_SAMPLE_FMT_FLTP,

95 AV_SAMPLE_FMT_NONE

96 },

97 [PRECISION_DOUBLE] = {

98 AV_SAMPLE_FMT_DBL,

99 AV_SAMPLE_FMT_DBLP,

100 AV_SAMPLE_FMT_NONE

101 }

102 };

103

104 layouts = ff_all_channel_layouts();

105 if (!layouts)

106 return AVERROR(ENOMEM);

107 ff_set_common_channel_layouts(ctx, layouts);

108

109 formats = ff_make_format_list(sample_fmts[vol->precision]);

110 if (!formats)

111 return AVERROR(ENOMEM);

112 ff_set_common_formats(ctx, formats);

113

114 formats = ff_all_samplerates();

115 if (!formats)

116 return AVERROR(ENOMEM);

117 ff_set_common_samplerates(ctx, formats);

118

119 return 0;

120 }

121

122 static inline void scale_samples_u8(uint8_t *dst, const uint8_t *src,

123 int nb_samples, int volume)

124 {

125 int i;

126 for (i = 0; i < nb_samples; i++)

127 dst[i] = av_clip_uint8(((((int64_t)src[i] - 128) * volume + 128) >> 8) + 128);

128 }

129

130 static inline void scale_samples_u8_small(uint8_t *dst, const uint8_t *src,

131 int nb_samples, int volume)

132 {

133 int i;

134 for (i = 0; i < nb_samples; i++)

135 dst[i] = av_clip_uint8((((src[i] - 128) * volume + 128) >> 8) + 128);

136 }

137

138 static inline void scale_samples_s16(uint8_t *dst, const uint8_t *src,

139 int nb_samples, int volume)

140 {

141 int i;

142 int16_t *smp_dst = (int16_t *)dst;

143 const int16_t *smp_src = (const int16_t *)src;

144 for (i = 0; i < nb_samples; i++)

145 smp_dst[i] = av_clip_int16(((int64_t)smp_src[i] * volume + 128) >> 8);

146 }

147

148 static inline void scale_samples_s16_small(uint8_t *dst, const uint8_t *src,

149 int nb_samples, int volume)

150 {

151 int i;

152 int16_t *smp_dst = (int16_t *)dst;

153 const int16_t *smp_src = (const int16_t *)src;

154 for (i = 0; i < nb_samples; i++)

155 smp_dst[i] = av_clip_int16((smp_src[i] * volume + 128) >> 8);

156 }

157

158 static inline void scale_samples_s32(uint8_t *dst, const uint8_t *src,

159 int nb_samples, int volume)

160 {

161 int i;

162 int32_t *smp_dst = (int32_t *)dst;

163 const int32_t *smp_src = (const int32_t *)src;

164 for (i = 0; i < nb_samples; i++)

165 smp_dst[i] = av_clipl_int32((((int64_t)smp_src[i] * volume + 128) >> 8));

166 }

167

168 static av_cold void volume_init(VolumeContext *vol)

169 {

170 vol->samples_align = 1;

171

172 switch (av_get_packed_sample_fmt(vol->sample_fmt)) {

173 case AV_SAMPLE_FMT_U8:

174 if (vol->volume_i < 0x1000000)

175 vol->scale_samples = scale_samples_u8_small;

176 else

177 vol->scale_samples = scale_samples_u8;

178 break;

179 case AV_SAMPLE_FMT_S16:

180 if (vol->volume_i < 0x10000)

181 vol->scale_samples = scale_samples_s16_small;

182 else

183 vol->scale_samples = scale_samples_s16;

184 break;

185 case AV_SAMPLE_FMT_S32:

186 vol->scale_samples = scale_samples_s32;

187 break;

188 case AV_SAMPLE_FMT_FLT:

189 avpriv_float_dsp_init(&vol->fdsp, 0);

190 vol->samples_align = 4;

191 break;

192 case AV_SAMPLE_FMT_DBL:

193 avpriv_float_dsp_init(&vol->fdsp, 0);

194 vol->samples_align = 8;

195 break;

196 }

197

198 if (ARCH_X86)

199 ff_volume_init_x86(vol);

200 }

201

202 static int config_output(AVFilterLink *outlink)

203 {

204 AVFilterContext *ctx = outlink->src;

205 VolumeContext *vol = ctx->priv;

206 AVFilterLink *inlink = ctx->inputs[0];

207

208 vol->sample_fmt = inlink->format;

209 vol->channels = av_get_channel_layout_nb_channels(inlink->channel_layout);

210 vol->planes = av_sample_fmt_is_planar(inlink->format) ? vol->channels : 1;

211

212 volume_init(vol);

213

214 return 0;

215 }

216

217 static int filter_frame(AVFilterLink *inlink, AVFrame *buf)

218 {

219 VolumeContext *vol = inlink->dst->priv;

220 AVFilterLink *outlink = inlink->dst->outputs[0];

221 int nb_samples = buf->nb_samples;

222 AVFrame *out_buf;

223

224 if (vol->volume == 1.0 || vol->volume_i == 256)

225 return ff_filter_frame(outlink, buf);

226

227 /* do volume scaling in-place if input buffer is writable */

228 if (av_frame_is_writable(buf)) {

229 out_buf = buf;

230 } else {

231 out_buf = ff_get_audio_buffer(inlink, nb_samples);

232 if (!out_buf)

233 return AVERROR(ENOMEM);

234 av_frame_copy_props(out_buf, buf);

235 }

236

237 if (vol->precision != PRECISION_FIXED || vol->volume_i > 0) {

238 int p, plane_samples;

239

240 if (av_sample_fmt_is_planar(buf->format))

241 plane_samples = FFALIGN(nb_samples, vol->samples_align);

242 else

243 plane_samples = FFALIGN(nb_samples * vol->channels, vol->samples_align);

244

245 if (vol->precision == PRECISION_FIXED) {

246 for (p = 0; p < vol->planes; p++) {

247 vol->scale_samples(out_buf->extended_data[p],

248 buf->extended_data[p], plane_samples,

249 vol->volume_i);

250 }

251 } else if (av_get_packed_sample_fmt(vol->sample_fmt) == AV_SAMPLE_FMT_FLT) {

252 for (p = 0; p < vol->planes; p++) {

253 vol->fdsp.vector_fmul_scalar((float *)out_buf->extended_data[p],

254 (const float *)buf->extended_data[p],

255 vol->volume, plane_samples);

256 }

257 } else {

258 for (p = 0; p < vol->planes; p++) {

259 vol->fdsp.vector_dmul_scalar((double *)out_buf->extended_data[p],

260 (const double *)buf->extended_data[p],

261 vol->volume, plane_samples);

262 }

263 }

264 }

265

266 if (buf != out_buf)

267 av_frame_free(&buf);

268

269 return ff_filter_frame(outlink, out_buf);

270 }

271

272 static const AVFilterPad avfilter_af_volume_inputs[] = {

273 {

274 .name = "default",

275 .type = AVMEDIA_TYPE_AUDIO,

276 .filter_frame = filter_frame,

277 },

278 { NULL }

279 };

280

281 static const AVFilterPad avfilter_af_volume_outputs[] = {

282 {

283 .name = "default",

284 .type = AVMEDIA_TYPE_AUDIO,

285 .config_props = config_output,

286 },

287 { NULL }

288 };

289

290 AVFilter avfilter_af_volume = {

291 .name = "volume",

292 .description = NULL_IF_CONFIG_SMALL("Change input volume."),

293 .query_formats = query_formats,

294 .priv_size = sizeof(VolumeContext),

295 .priv_class = &volume_class,

296 .init = init,

297 .inputs = avfilter_af_volume_inputs,

298 .outputs = avfilter_af_volume_outputs,

299 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,

300 };

Generated on Sat Jan 25 2014 19:51:59 for FFmpeg by doxygen 1.8.2