FFmpeg: libavfilter/af_channelmap.c Source File

FFmpeg

[フレーム]

libavfilter

af_channelmap.c

Go to the documentation of this file.

1 /*

3 *

4 * This file is part of FFmpeg.

5 *

6 * FFmpeg is free software; you can redistribute it and/or

7 * modify it under the terms of the GNU Lesser General Public

8 * License as published by the Free Software Foundation; either

9 * version 2.1 of the License, or (at your option) any later version.

10 *

11 * FFmpeg is distributed in the hope that it will be useful,

12 * but WITHOUT ANY WARRANTY; without even the implied warranty of

13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

14 * Lesser General Public License for more details.

15 *

16 * You should have received a copy of the GNU Lesser General Public

17 * License along with FFmpeg; if not, write to the Free Software

18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

19 */

21 /**

22 * @file

23 * audio channel mapping filter

24 */

26 #include <ctype.h>

28 #include "libavutil/avstring.h"

29 #include "libavutil/channel_layout.h"

30 #include "libavutil/common.h"

31 #include "libavutil/mathematics.h"

32 #include "libavutil/opt.h"

33 #include "libavutil/samplefmt.h"

35 #include "audio.h"

36 #include "avfilter.h"

37 #include "formats.h"

38 #include "internal.h"

40 struct ChannelMap {

41 uint64_t in_channel;

42 uint64_t out_channel;

43 int in_channel_idx;

44 int out_channel_idx;

45 };

47 enum MappingMode {

48 MAP_NONE,

49 MAP_ONE_INT,

50 MAP_ONE_STR,

51 MAP_PAIR_INT_INT,

52 MAP_PAIR_INT_STR,

53 MAP_PAIR_STR_INT,

54 MAP_PAIR_STR_STR

55 };

57 #define MAX_CH 64

58 typedef struct ChannelMapContext {

59 const AVClass *class;

60 AVFilterChannelLayouts *channel_layouts;

61 char *mapping_str;

62 char *channel_layout_str;

63 uint64_t output_layout;

64 struct ChannelMap map[MAX_CH];

65 int nch;

66 enum MappingMode mode;

67 } ChannelMapContext;

69 #define OFFSET(x) offsetof(ChannelMapContext, x)

70 #define A AV_OPT_FLAG_AUDIO_PARAM

71 #define F AV_OPT_FLAG_FILTERING_PARAM

72 static const AVOption channelmap_options[] = {

73 { "map", "A comma-separated list of input channel numbers in output order.",

74 OFFSET(mapping_str), AV_OPT_TYPE_STRING, .flags = A|F },

75 { "channel_layout", "Output channel layout.",

76 OFFSET(channel_layout_str), AV_OPT_TYPE_STRING, .flags = A|F },

77 { NULL }

78 };

80 AVFILTER_DEFINE_CLASS(channelmap);

82 static char* split(char *message, char delim) {

83 char *next = strchr(message, delim);

84 if (next)

85 *next++ = '0円';

86 return next;

87 }

89 static int get_channel_idx(char **map, int *ch, char delim, int max_ch)

90 {

91 char *next = split(*map, delim);

92 int len;

93 int n = 0;

94 if (!next && delim == '-')

95 return AVERROR(EINVAL);

96 len = strlen(*map);

97 sscanf(*map, "%d%n", ch, &n);

98 if (n != len)

99 return AVERROR(EINVAL);

100 if (*ch < 0 || *ch > max_ch)

101 return AVERROR(EINVAL);

102 *map = next;

103 return 0;

104 }

105

106 static int get_channel(char **map, uint64_t *ch, char delim)

107 {

108 char *next = split(*map, delim);

109 if (!next && delim == '-')

110 return AVERROR(EINVAL);

111 *ch = av_get_channel_layout(*map);

112 if (av_get_channel_layout_nb_channels(*ch) != 1)

113 return AVERROR(EINVAL);

114 *map = next;

115 return 0;

116 }

117

118 static av_cold int channelmap_init(AVFilterContext *ctx)

119 {

120 ChannelMapContext *s = ctx->priv;

121 char *mapping, separator = '|';

122 int map_entries = 0;

123 char buf[256];

124 enum MappingMode mode;

125 uint64_t out_ch_mask = 0;

126 int i;

127

128 mapping = s->mapping_str;

129

130 if (!mapping) {

131 mode = MAP_NONE;

132 } else {

133 char *dash = strchr(mapping, '-');

134 if (!dash) { // short mapping

135 if (av_isdigit(*mapping))

136 mode = MAP_ONE_INT;

137 else

138 mode = MAP_ONE_STR;

139 } else if (av_isdigit(*mapping)) {

140 if (av_isdigit(*(dash+1)))

141 mode = MAP_PAIR_INT_INT;

142 else

143 mode = MAP_PAIR_INT_STR;

144 } else {

145 if (av_isdigit(*(dash+1)))

146 mode = MAP_PAIR_STR_INT;

147 else

148 mode = MAP_PAIR_STR_STR;

149 }

150 #if FF_API_OLD_FILTER_OPTS

151 if (strchr(mapping, ',')) {

152 av_log(ctx, AV_LOG_WARNING, "This syntax is deprecated, use "

153 "'|' to separate the mappings.\n");

154 separator = ',';

155 }

156 #endif

157 }

158

159 if (mode != MAP_NONE) {

160 char *sep = mapping;

161 map_entries = 1;

162 while ((sep = strchr(sep, separator))) {

163 if (*++sep) // Allow trailing comma

164 map_entries++;

165 }

166 }

167

168 if (map_entries > MAX_CH) {

169 av_log(ctx, AV_LOG_ERROR, "Too many channels mapped: '%d'.\n", map_entries);

170 return AVERROR(EINVAL);

171 }

172

173 for (i = 0; i < map_entries; i++) {

174 int in_ch_idx = -1, out_ch_idx = -1;

175 uint64_t in_ch = 0, out_ch = 0;

176 static const char err[] = "Failed to parse channel map\n";

177 switch (mode) {

178 case MAP_ONE_INT:

179 if (get_channel_idx(&mapping, &in_ch_idx, separator, MAX_CH) < 0) {

180 av_log(ctx, AV_LOG_ERROR, err);

181 return AVERROR(EINVAL);

182 }

183 s->map[i].in_channel_idx = in_ch_idx;

184 s->map[i].out_channel_idx = i;

185 break;

186 case MAP_ONE_STR:

187 if (!get_channel(&mapping, &in_ch, separator)) {

188 av_log(ctx, AV_LOG_ERROR, err);

189 return AVERROR(EINVAL);

190 }

191 s->map[i].in_channel = in_ch;

192 s->map[i].out_channel_idx = i;

193 break;

194 case MAP_PAIR_INT_INT:

195 if (get_channel_idx(&mapping, &in_ch_idx, '-', MAX_CH) < 0 ||

196 get_channel_idx(&mapping, &out_ch_idx, separator, MAX_CH) < 0) {

197 av_log(ctx, AV_LOG_ERROR, err);

198 return AVERROR(EINVAL);

199 }

200 s->map[i].in_channel_idx = in_ch_idx;

201 s->map[i].out_channel_idx = out_ch_idx;

202 break;

203 case MAP_PAIR_INT_STR:

204 if (get_channel_idx(&mapping, &in_ch_idx, '-', MAX_CH) < 0 ||

205 get_channel(&mapping, &out_ch, separator) < 0 ||

206 out_ch & out_ch_mask) {

207 av_log(ctx, AV_LOG_ERROR, err);

208 return AVERROR(EINVAL);

209 }

210 s->map[i].in_channel_idx = in_ch_idx;

211 s->map[i].out_channel = out_ch;

212 out_ch_mask |= out_ch;

213 break;

214 case MAP_PAIR_STR_INT:

215 if (get_channel(&mapping, &in_ch, '-') < 0 ||

216 get_channel_idx(&mapping, &out_ch_idx, separator, MAX_CH) < 0) {

217 av_log(ctx, AV_LOG_ERROR, err);

218 return AVERROR(EINVAL);

219 }

220 s->map[i].in_channel = in_ch;

221 s->map[i].out_channel_idx = out_ch_idx;

222 break;

223 case MAP_PAIR_STR_STR:

224 if (get_channel(&mapping, &in_ch, '-') < 0 ||

225 get_channel(&mapping, &out_ch, separator) < 0 ||

226 out_ch & out_ch_mask) {

227 av_log(ctx, AV_LOG_ERROR, err);

228 return AVERROR(EINVAL);

229 }

230 s->map[i].in_channel = in_ch;

231 s->map[i].out_channel = out_ch;

232 out_ch_mask |= out_ch;

233 break;

234 }

235 }

236 s->mode = mode;

237 s->nch = map_entries;

238 s->output_layout = out_ch_mask ? out_ch_mask :

239 av_get_default_channel_layout(map_entries);

240

241 if (s->channel_layout_str) {

242 uint64_t fmt;

243 if ((fmt = av_get_channel_layout(s->channel_layout_str)) == 0) {

244 av_log(ctx, AV_LOG_ERROR, "Error parsing channel layout: '%s'.\n",

245 s->channel_layout_str);

246 return AVERROR(EINVAL);

247 }

248 if (mode == MAP_NONE) {

249 int i;

250 s->nch = av_get_channel_layout_nb_channels(fmt);

251 for (i = 0; i < s->nch; i++) {

252 s->map[i].in_channel_idx = i;

253 s->map[i].out_channel_idx = i;

254 }

255 } else if (out_ch_mask && out_ch_mask != fmt) {

256 av_get_channel_layout_string(buf, sizeof(buf), 0, out_ch_mask);

257 av_log(ctx, AV_LOG_ERROR,

258 "Output channel layout '%s' does not match the list of channel mapped: '%s'.\n",

259 s->channel_layout_str, buf);

260 return AVERROR(EINVAL);

261 } else if (s->nch != av_get_channel_layout_nb_channels(fmt)) {

262 av_log(ctx, AV_LOG_ERROR,

263 "Output channel layout %s does not match the number of channels mapped %d.\n",

264 s->channel_layout_str, s->nch);

265 return AVERROR(EINVAL);

266 }

267 s->output_layout = fmt;

268 }

269 if (!s->output_layout) {

270 av_log(ctx, AV_LOG_ERROR, "Output channel layout is not set and "

271 "cannot be guessed from the maps.\n");

272 return AVERROR(EINVAL);

273 }

274

275 ff_add_channel_layout(&s->channel_layouts, s->output_layout);

276

277 if (mode == MAP_PAIR_INT_STR || mode == MAP_PAIR_STR_STR) {

278 for (i = 0; i < s->nch; i++) {

279 s->map[i].out_channel_idx = av_get_channel_layout_channel_index(

280 s->output_layout, s->map[i].out_channel);

281 }

282 }

283

284 return 0;

285 }

286

287 static int channelmap_query_formats(AVFilterContext *ctx)

288 {

289 ChannelMapContext *s = ctx->priv;

290

291 ff_set_common_formats(ctx, ff_planar_sample_fmts());

292 ff_set_common_samplerates(ctx, ff_all_samplerates());

293 ff_channel_layouts_ref(ff_all_channel_layouts(), &ctx->inputs[0]->out_channel_layouts);

294 ff_channel_layouts_ref(s->channel_layouts, &ctx->outputs[0]->in_channel_layouts);

295

296 return 0;

297 }

298

299 static int channelmap_filter_frame(AVFilterLink *inlink, AVFrame *buf)

300 {

301 AVFilterContext *ctx = inlink->dst;

302 AVFilterLink *outlink = ctx->outputs[0];

303 const ChannelMapContext *s = ctx->priv;

304 const int nch_in = av_get_channel_layout_nb_channels(inlink->channel_layout);

305 const int nch_out = s->nch;

306 int ch;

307 uint8_t *source_planes[MAX_CH];

308

309 memcpy(source_planes, buf->extended_data,

310 nch_in * sizeof(source_planes[0]));

311

312 if (nch_out > nch_in) {

313 if (nch_out > FF_ARRAY_ELEMS(buf->data)) {

314 uint8_t **new_extended_data =

315 av_mallocz(nch_out * sizeof(*buf->extended_data));

316 if (!new_extended_data) {

317 av_frame_free(&buf);

318 return AVERROR(ENOMEM);

319 }

320 if (buf->extended_data == buf->data) {

321 buf->extended_data = new_extended_data;

322 } else {

323 av_free(buf->extended_data);

324 buf->extended_data = new_extended_data;

325 }

326 } else if (buf->extended_data != buf->data) {

327 av_free(buf->extended_data);

328 buf->extended_data = buf->data;

329 }

330 }

331

332 for (ch = 0; ch < nch_out; ch++) {

333 buf->extended_data[s->map[ch].out_channel_idx] =

334 source_planes[s->map[ch].in_channel_idx];

335 }

336

337 if (buf->data != buf->extended_data)

338 memcpy(buf->data, buf->extended_data,

339 FFMIN(FF_ARRAY_ELEMS(buf->data), nch_out) * sizeof(buf->data[0]));

340

341 return ff_filter_frame(outlink, buf);

342 }

343

344 static int channelmap_config_input(AVFilterLink *inlink)

345 {

346 AVFilterContext *ctx = inlink->dst;

347 ChannelMapContext *s = ctx->priv;

348 int nb_channels = av_get_channel_layout_nb_channels(inlink->channel_layout);

349 int i, err = 0;

350 const char *channel_name;

351 char layout_name[256];

352

353 for (i = 0; i < s->nch; i++) {

354 struct ChannelMap *m = &s->map[i];

355

356 if (s->mode == MAP_PAIR_STR_INT || s->mode == MAP_PAIR_STR_STR) {

357 m->in_channel_idx = av_get_channel_layout_channel_index(

358 inlink->channel_layout, m->in_channel);

359 }

360

361 if (m->in_channel_idx < 0 || m->in_channel_idx >= nb_channels) {

362 av_get_channel_layout_string(layout_name, sizeof(layout_name),

363 0, inlink->channel_layout);

364 if (m->in_channel) {

365 channel_name = av_get_channel_name(m->in_channel);

366 av_log(ctx, AV_LOG_ERROR,

367 "input channel '%s' not available from input layout '%s'\n",

368 channel_name, layout_name);

369 } else {

370 av_log(ctx, AV_LOG_ERROR,

371 "input channel #%d not available from input layout '%s'\n",

372 m->in_channel_idx, layout_name);

373 }

374 err = AVERROR(EINVAL);

375 }

376 }

377

378 return err;

379 }

380

381 static const AVFilterPad avfilter_af_channelmap_inputs[] = {

382 {

383 .name = "default",

384 .type = AVMEDIA_TYPE_AUDIO,

385 .filter_frame = channelmap_filter_frame,

386 .config_props = channelmap_config_input,

387 .needs_writable = 1,

388 },

389 { NULL }

390 };

391

392 static const AVFilterPad avfilter_af_channelmap_outputs[] = {

393 {

394 .name = "default",

395 .type = AVMEDIA_TYPE_AUDIO

396 },

397 { NULL }

398 };

399

400 AVFilter avfilter_af_channelmap = {

401 .name = "channelmap",

402 .description = NULL_IF_CONFIG_SMALL("Remap audio channels."),

403 .init = channelmap_init,

404 .query_formats = channelmap_query_formats,

405 .priv_size = sizeof(ChannelMapContext),

406 .priv_class = &channelmap_class,

407 .inputs = avfilter_af_channelmap_inputs,

408 .outputs = avfilter_af_channelmap_outputs,

409 };

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