FFmpeg: libavresample/resample.c Source File

FFmpeg

[フレーム]

libavresample

resample.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 #include "libavutil/common.h"

23 #include "libavutil/libm.h"

24 #include "libavutil/log.h"

25 #include "internal.h"

26 #include "resample.h"

27 #include "audio_data.h"

30 /* double template */

31 #define CONFIG_RESAMPLE_DBL

32 #include "resample_template.c"

33 #undef CONFIG_RESAMPLE_DBL

35 /* float template */

36 #define CONFIG_RESAMPLE_FLT

37 #include "resample_template.c"

38 #undef CONFIG_RESAMPLE_FLT

40 /* s32 template */

41 #define CONFIG_RESAMPLE_S32

42 #include "resample_template.c"

43 #undef CONFIG_RESAMPLE_S32

45 /* s16 template */

46 #include "resample_template.c"

49 /* 0th order modified bessel function of the first kind. */

50 static double bessel(double x)

51 {

52 double v = 1;

53 double lastv = 0;

54 double t = 1;

55 int i;

57 x = x * x / 4;

58 for (i = 1; v != lastv; i++) {

59 lastv = v;

60 t *= x / (i * i);

61 v += t;

62 }

63 return v;

64 }

66 /* Build a polyphase filterbank. */

67 static int build_filter(ResampleContext *c, double factor)

68 {

69 int ph, i;

70 double x, y, w;

71 double *tab;

72 int tap_count = c->filter_length;

73 int phase_count = 1 << c->phase_shift;

74 const int center = (tap_count - 1) / 2;

76 tab = av_malloc(tap_count * sizeof(*tab));

77 if (!tab)

78 return AVERROR(ENOMEM);

80 for (ph = 0; ph < phase_count; ph++) {

81 double norm = 0;

82 for (i = 0; i < tap_count; i++) {

83 x = M_PI * ((double)(i - center) - (double)ph / phase_count) * factor;

84 if (x == 0) y = 1.0;

85 else y = sin(x) / x;

86 switch (c->filter_type) {

87 case AV_RESAMPLE_FILTER_TYPE_CUBIC: {

88 const float d = -0.5; //first order derivative = -0.5

89 x = fabs(((double)(i - center) - (double)ph / phase_count) * factor);

90 if (x < 1.0) y = 1 - 3 * x*x + 2 * x*x*x + d * ( -x*x + x*x*x);

91 else y = d * (-4 + 8 * x - 5 * x*x + x*x*x);

92 break;

93 }

94 case AV_RESAMPLE_FILTER_TYPE_BLACKMAN_NUTTALL:

95 w = 2.0 * x / (factor * tap_count) + M_PI;

96 y *= 0.3635819 - 0.4891775 * cos( w) +

97 0.1365995 * cos(2 * w) -

98 0.0106411 * cos(3 * w);

99 break;

100 case AV_RESAMPLE_FILTER_TYPE_KAISER:

101 w = 2.0 * x / (factor * tap_count * M_PI);

102 y *= bessel(c->kaiser_beta * sqrt(FFMAX(1 - w * w, 0)));

103 break;

104 }

105

106 tab[i] = y;

107 norm += y;

108 }

109 /* normalize so that an uniform color remains the same */

110 for (i = 0; i < tap_count; i++)

111 tab[i] = tab[i] / norm;

112

113 c->set_filter(c->filter_bank, tab, ph, tap_count);

114 }

115

116 av_free(tab);

117 return 0;

118 }

119

120 ResampleContext *ff_audio_resample_init(AVAudioResampleContext *avr)

121 {

122 ResampleContext *c;

123 int out_rate = avr->out_sample_rate;

124 int in_rate = avr->in_sample_rate;

125 double factor = FFMIN(out_rate * avr->cutoff / in_rate, 1.0);

126 int phase_count = 1 << avr->phase_shift;

127 int felem_size;

128

129 if (avr->internal_sample_fmt != AV_SAMPLE_FMT_S16P &&

130 avr->internal_sample_fmt != AV_SAMPLE_FMT_S32P &&

131 avr->internal_sample_fmt != AV_SAMPLE_FMT_FLTP &&

132 avr->internal_sample_fmt != AV_SAMPLE_FMT_DBLP) {

133 av_log(avr, AV_LOG_ERROR, "Unsupported internal format for "

134 "resampling: %s\n",

135 av_get_sample_fmt_name(avr->internal_sample_fmt));

136 return NULL;

137 }

138 c = av_mallocz(sizeof(*c));

139 if (!c)

140 return NULL;

141

142 c->avr = avr;

143 c->phase_shift = avr->phase_shift;

144 c->phase_mask = phase_count - 1;

145 c->linear = avr->linear_interp;

146 c->filter_length = FFMAX((int)ceil(avr->filter_size / factor), 1);

147 c->filter_type = avr->filter_type;

148 c->kaiser_beta = avr->kaiser_beta;

149

150 switch (avr->internal_sample_fmt) {

151 case AV_SAMPLE_FMT_DBLP:

152 c->resample_one = c->linear ? resample_linear_dbl : resample_one_dbl;

153 c->resample_nearest = resample_nearest_dbl;

154 c->set_filter = set_filter_dbl;

155 break;

156 case AV_SAMPLE_FMT_FLTP:

157 c->resample_one = c->linear ? resample_linear_flt : resample_one_flt;

158 c->resample_nearest = resample_nearest_flt;

159 c->set_filter = set_filter_flt;

160 break;

161 case AV_SAMPLE_FMT_S32P:

162 c->resample_one = c->linear ? resample_linear_s32 : resample_one_s32;

163 c->resample_nearest = resample_nearest_s32;

164 c->set_filter = set_filter_s32;

165 break;

166 case AV_SAMPLE_FMT_S16P:

167 c->resample_one = c->linear ? resample_linear_s16 : resample_one_s16;

168 c->resample_nearest = resample_nearest_s16;

169 c->set_filter = set_filter_s16;

170 break;

171 }

172

173 if (ARCH_AARCH64)

174 ff_audio_resample_init_aarch64(c, avr->internal_sample_fmt);

175 if (ARCH_ARM)

176 ff_audio_resample_init_arm(c, avr->internal_sample_fmt);

177

178 felem_size = av_get_bytes_per_sample(avr->internal_sample_fmt);

179 c->filter_bank = av_mallocz(c->filter_length * (phase_count + 1) * felem_size);

180 if (!c->filter_bank)

181 goto error;

182

183 if (build_filter(c, factor) < 0)

184 goto error;

185

186 memcpy(&c->filter_bank[(c->filter_length * phase_count + 1) * felem_size],

187 c->filter_bank, (c->filter_length - 1) * felem_size);

188 memcpy(&c->filter_bank[c->filter_length * phase_count * felem_size],

189 &c->filter_bank[(c->filter_length - 1) * felem_size], felem_size);

190

191 c->compensation_distance = 0;

192 if (!av_reduce(&c->src_incr, &c->dst_incr, out_rate,

193 in_rate * (int64_t)phase_count, INT32_MAX / 2))

194 goto error;

195 c->ideal_dst_incr = c->dst_incr;

196

197 c->padding_size = (c->filter_length - 1) / 2;

198 c->initial_padding_filled = 0;

199 c->index = 0;

200 c->frac = 0;

201

202 /* allocate internal buffer */

203 c->buffer = ff_audio_data_alloc(avr->resample_channels, c->padding_size,

204 avr->internal_sample_fmt,

205 "resample buffer");

206 if (!c->buffer)

207 goto error;

208 c->buffer->nb_samples = c->padding_size;

209 c->initial_padding_samples = c->padding_size;

210

211 av_log(avr, AV_LOG_DEBUG, "resample: %s from %d Hz to %d Hz\n",

212 av_get_sample_fmt_name(avr->internal_sample_fmt),

213 avr->in_sample_rate, avr->out_sample_rate);

214

215 return c;

216

217 error:

218 ff_audio_data_free(&c->buffer);

219 av_free(c->filter_bank);

220 av_free(c);

221 return NULL;

222 }

223

224 void ff_audio_resample_free(ResampleContext **c)

225 {

226 if (!*c)

227 return;

228 ff_audio_data_free(&(*c)->buffer);

229 av_free((*c)->filter_bank);

230 av_freep(c);

231 }

232

233 int avresample_set_compensation(AVAudioResampleContext *avr, int sample_delta,

234 int compensation_distance)

235 {

236 ResampleContext *c;

237 AudioData *fifo_buf = NULL;

238 int ret = 0;

239

240 if (compensation_distance < 0)

241 return AVERROR(EINVAL);

242 if (!compensation_distance && sample_delta)

243 return AVERROR(EINVAL);

244

245 if (!avr->resample_needed) {

246 #if FF_API_RESAMPLE_CLOSE_OPEN

247 /* if resampling was not enabled previously, re-initialize the

248 AVAudioResampleContext and force resampling */

249 int fifo_samples;

250 int restore_matrix = 0;

251 double matrix[AVRESAMPLE_MAX_CHANNELS * AVRESAMPLE_MAX_CHANNELS] = { 0 };

252

253 /* buffer any remaining samples in the output FIFO before closing */

254 fifo_samples = av_audio_fifo_size(avr->out_fifo);

255 if (fifo_samples > 0) {

256 fifo_buf = ff_audio_data_alloc(avr->out_channels, fifo_samples,

257 avr->out_sample_fmt, NULL);

258 if (!fifo_buf)

259 return AVERROR(EINVAL);

260 ret = ff_audio_data_read_from_fifo(avr->out_fifo, fifo_buf,

261 fifo_samples);

262 if (ret < 0)

263 goto reinit_fail;

264 }

265 /* save the channel mixing matrix */

266 if (avr->am) {

267 ret = avresample_get_matrix(avr, matrix, AVRESAMPLE_MAX_CHANNELS);

268 if (ret < 0)

269 goto reinit_fail;

270 restore_matrix = 1;

271 }

272

273 /* close the AVAudioResampleContext */

274 avresample_close(avr);

275

276 avr->force_resampling = 1;

277

278 /* restore the channel mixing matrix */

279 if (restore_matrix) {

280 ret = avresample_set_matrix(avr, matrix, AVRESAMPLE_MAX_CHANNELS);

281 if (ret < 0)

282 goto reinit_fail;

283 }

284

285 /* re-open the AVAudioResampleContext */

286 ret = avresample_open(avr);

287 if (ret < 0)

288 goto reinit_fail;

289

290 /* restore buffered samples to the output FIFO */

291 if (fifo_samples > 0) {

292 ret = ff_audio_data_add_to_fifo(avr->out_fifo, fifo_buf, 0,

293 fifo_samples);

294 if (ret < 0)

295 goto reinit_fail;

296 ff_audio_data_free(&fifo_buf);

297 }

298 #else

299 av_log(avr, AV_LOG_ERROR, "Unable to set resampling compensation\n");

300 return AVERROR(EINVAL);

301 #endif

302 }

303 c = avr->resample;

304 c->compensation_distance = compensation_distance;

305 if (compensation_distance) {

306 c->dst_incr = c->ideal_dst_incr - c->ideal_dst_incr *

307 (int64_t)sample_delta / compensation_distance;

308 } else {

309 c->dst_incr = c->ideal_dst_incr;

310 }

311 return 0;

312

313 reinit_fail:

314 ff_audio_data_free(&fifo_buf);

315 return ret;

316 }

317

318 static int resample(ResampleContext *c, void *dst, const void *src,

319 int *consumed, int src_size, int dst_size, int update_ctx,

320 int nearest_neighbour)

321 {

322 int dst_index;

323 unsigned int index = c->index;

324 int frac = c->frac;

325 int dst_incr_frac = c->dst_incr % c->src_incr;

326 int dst_incr = c->dst_incr / c->src_incr;

327 int compensation_distance = c->compensation_distance;

328

329 if (!dst != !src)

330 return AVERROR(EINVAL);

331

332 if (nearest_neighbour) {

333 uint64_t index2 = ((uint64_t)index) << 32;

334 int64_t incr = (1LL << 32) * c->dst_incr / c->src_incr;

335 dst_size = FFMIN(dst_size,

336 (src_size-1-index) * (int64_t)c->src_incr /

337 c->dst_incr);

338

339 if (dst) {

340 for(dst_index = 0; dst_index < dst_size; dst_index++) {

341 c->resample_nearest(dst, dst_index, src, index2 >> 32);

342 index2 += incr;

343 }

344 } else {

345 dst_index = dst_size;

346 }

347 index += dst_index * dst_incr;

348 index += (frac + dst_index * (int64_t)dst_incr_frac) / c->src_incr;

349 frac = (frac + dst_index * (int64_t)dst_incr_frac) % c->src_incr;

350 } else {

351 for (dst_index = 0; dst_index < dst_size; dst_index++) {

352 int sample_index = index >> c->phase_shift;

353

354 if (sample_index + c->filter_length > src_size)

355 break;

356

357 if (dst)

358 c->resample_one(c, dst, dst_index, src, index, frac);

359

360 frac += dst_incr_frac;

361 index += dst_incr;

362 if (frac >= c->src_incr) {

363 frac -= c->src_incr;

364 index++;

365 }

366 if (dst_index + 1 == compensation_distance) {

367 compensation_distance = 0;

368 dst_incr_frac = c->ideal_dst_incr % c->src_incr;

369 dst_incr = c->ideal_dst_incr / c->src_incr;

370 }

371 }

372 }

373 if (consumed)

374 *consumed = index >> c->phase_shift;

375

376 if (update_ctx) {

377 index &= c->phase_mask;

378

379 if (compensation_distance) {

380 compensation_distance -= dst_index;

381 if (compensation_distance <= 0)

382 return AVERROR_BUG;

383 }

384 c->frac = frac;

385 c->index = index;

386 c->dst_incr = dst_incr_frac + c->src_incr*dst_incr;

387 c->compensation_distance = compensation_distance;

388 }

389

390 return dst_index;

391 }

392

393 int ff_audio_resample(ResampleContext *c, AudioData *dst, AudioData *src)

394 {

395 int ch, in_samples, in_leftover, consumed = 0, out_samples = 0;

396 int ret = AVERROR(EINVAL);

397 int nearest_neighbour = (c->compensation_distance == 0 &&

398 c->filter_length == 1 &&

399 c->phase_shift == 0);

400

401 in_samples = src ? src->nb_samples : 0;

402 in_leftover = c->buffer->nb_samples;

403

404 /* add input samples to the internal buffer */

405 if (src) {

406 ret = ff_audio_data_combine(c->buffer, in_leftover, src, 0, in_samples);

407 if (ret < 0)

408 return ret;

409 } else if (in_leftover <= c->final_padding_samples) {

410 /* no remaining samples to flush */

411 return 0;

412 }

413

414 if (!c->initial_padding_filled) {

415 int bps = av_get_bytes_per_sample(c->avr->internal_sample_fmt);

416 int i;

417

418 if (src && c->buffer->nb_samples < 2 * c->padding_size)

419 return 0;

420

421 for (i = 0; i < c->padding_size; i++)

422 for (ch = 0; ch < c->buffer->channels; ch++) {

423 if (c->buffer->nb_samples > 2 * c->padding_size - i) {

424 memcpy(c->buffer->data[ch] + bps * i,

425 c->buffer->data[ch] + bps * (2 * c->padding_size - i), bps);

426 } else {

427 memset(c->buffer->data[ch] + bps * i, 0, bps);

428 }

429 }

430 c->initial_padding_filled = 1;

431 }

432

433 if (!src && !c->final_padding_filled) {

434 int bps = av_get_bytes_per_sample(c->avr->internal_sample_fmt);

435 int i;

436

437 ret = ff_audio_data_realloc(c->buffer, in_samples + c->padding_size);

438 if (ret < 0) {

439 av_log(c->avr, AV_LOG_ERROR, "Error reallocating resampling buffer\n");

440 return AVERROR(ENOMEM);

441 }

442

443 for (i = 0; i < c->padding_size; i++)

444 for (ch = 0; ch < c->buffer->channels; ch++) {

445 if (in_leftover > i) {

446 memcpy(c->buffer->data[ch] + bps * (in_leftover + i),

447 c->buffer->data[ch] + bps * (in_leftover - i - 1),

448 bps);

449 } else {

450 memset(c->buffer->data[ch] + bps * (in_leftover + i),

451 0, bps);

452 }

453 }

454 c->buffer->nb_samples += c->padding_size;

455 c->final_padding_samples = c->padding_size;

456 c->final_padding_filled = 1;

457 }

458

459

460 /* calculate output size and reallocate output buffer if needed */

461 /* TODO: try to calculate this without the dummy resample() run */

462 if (!dst->read_only && dst->allow_realloc) {

463 out_samples = resample(c, NULL, NULL, NULL, c->buffer->nb_samples,

464 INT_MAX, 0, nearest_neighbour);

465 ret = ff_audio_data_realloc(dst, out_samples);

466 if (ret < 0) {

467 av_log(c->avr, AV_LOG_ERROR, "error reallocating output\n");

468 return ret;

469 }

470 }

471

472 /* resample each channel plane */

473 for (ch = 0; ch < c->buffer->channels; ch++) {

474 out_samples = resample(c, (void *)dst->data[ch],

475 (const void *)c->buffer->data[ch], &consumed,

476 c->buffer->nb_samples, dst->allocated_samples,

477 ch + 1 == c->buffer->channels, nearest_neighbour);

478 }

479 if (out_samples < 0) {

480 av_log(c->avr, AV_LOG_ERROR, "error during resampling\n");

481 return out_samples;

482 }

483

484 /* drain consumed samples from the internal buffer */

485 ff_audio_data_drain(c->buffer, consumed);

486 c->initial_padding_samples = FFMAX(c->initial_padding_samples - consumed, 0);

487

488 av_dlog(c->avr, "resampled %d in + %d leftover to %d out + %d leftover\n",

489 in_samples, in_leftover, out_samples, c->buffer->nb_samples);

490

491 dst->nb_samples = out_samples;

492 return 0;

493 }

494

495 int avresample_get_delay(AVAudioResampleContext *avr)

496 {

497 ResampleContext *c = avr->resample;

498

499 if (!avr->resample_needed || !avr->resample)

500 return 0;

501

502 return FFMAX(c->buffer->nb_samples - c->padding_size, 0);

503 }

Generated on Sun Mar 8 2015 02:34:59 for FFmpeg by doxygen 1.8.2