FFmpeg: libswresample/resample.c Source File

FFmpeg

[フレーム]

libswresample

resample.c

Go to the documentation of this file.

1 /*

2 * audio resampling

5 *

6 * This file is part of FFmpeg.

7 *

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

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

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

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

12 *

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

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

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

16 * Lesser General Public License for more details.

17 *

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

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

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

21 */

23 /**

24 * @file

25 * audio resampling

26 * @author Michael Niedermayer <michaelni@gmx.at>

27 */

29 #include "libavutil/avassert.h"

30 #include "libavutil/mem.h"

31 #include "resample.h"

33 /**

34 * builds a polyphase filterbank.

35 * @param factor resampling factor

36 * @param scale wanted sum of coefficients for each filter

37 * @param filter_type filter type

38 * @param kaiser_beta kaiser window beta

39 * @return 0 on success, negative on error

40 */

41 static int build_filter(ResampleContext *c, void *filter, double factor, int tap_count, int alloc, int phase_count, int scale,

42 int filter_type, double kaiser_beta){

43 int ph, i;

44 int ph_nb = phase_count % 2 ? phase_count : phase_count / 2 + 1;

45 double x, y, w, t, s;

46 double *tab = av_malloc_array(tap_count+1, sizeof(*tab));

47 double *sin_lut = av_malloc_array(ph_nb, sizeof(*sin_lut));

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

49 double norm = 0;

50 int ret = AVERROR(ENOMEM);

52 if (!tab || !sin_lut)

53 goto fail;

55 av_assert0(tap_count == 1 || tap_count % 2 == 0);

57 /* if upsampling, only need to interpolate, no filter */

58 if (factor > 1.0)

59 factor = 1.0;

61 if (factor == 1.0) {

62 for (ph = 0; ph < ph_nb; ph++)

63 sin_lut[ph] = sin(M_PI * ph / phase_count) * (center & 1 ? 1 : -1);

64 }

65 for(ph = 0; ph < ph_nb; ph++) {

66 s = sin_lut[ph];

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

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

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

70 else if (factor == 1.0)

71 y = s / x;

72 else

73 y = sin(x) / x;

74 switch(filter_type){

75 case SWR_FILTER_TYPE_CUBIC:{

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

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

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

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

80 break;}

81 case SWR_FILTER_TYPE_BLACKMAN_NUTTALL:

82 w = 2.0*x / (factor*tap_count);

83 t = -cos(w);

84 y *= 0.3635819 - 0.4891775 * t + 0.1365995 * (2*t*t-1) - 0.0106411 * (4*t*t*t - 3*t);

85 break;

86 case SWR_FILTER_TYPE_KAISER:

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

88 y *= av_bessel_i0(kaiser_beta*sqrt(FFMAX(1-w*w, 0)));

89 break;

90 default:

91 av_assert0(0);

92 }

94 tab[i] = y;

95 s = -s;

96 if (!ph)

97 norm += y;

98 }

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

101 switch(c->format){

102 case AV_SAMPLE_FMT_S16P:

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

104 ((int16_t*)filter)[ph * alloc + i] = av_clip_int16(lrintf(tab[i] * scale / norm));

105 if (phase_count % 2) break;

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

107 ((int16_t*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((int16_t*)filter)[ph * alloc + i];

108 break;

109 case AV_SAMPLE_FMT_S32P:

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

111 ((int32_t*)filter)[ph * alloc + i] = av_clipl_int32(llrint(tab[i] * scale / norm));

112 if (phase_count % 2) break;

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

114 ((int32_t*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((int32_t*)filter)[ph * alloc + i];

115 break;

116 case AV_SAMPLE_FMT_FLTP:

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

118 ((float*)filter)[ph * alloc + i] = tab[i] * scale / norm;

119 if (phase_count % 2) break;

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

121 ((float*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((float*)filter)[ph * alloc + i];

122 break;

123 case AV_SAMPLE_FMT_DBLP:

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

125 ((double*)filter)[ph * alloc + i] = tab[i] * scale / norm;

126 if (phase_count % 2) break;

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

128 ((double*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((double*)filter)[ph * alloc + i];

129 break;

130 }

131 }

132 #if 0

133 {

134 #define LEN 1024

135 int j,k;

136 double sine[LEN + tap_count];

137 double filtered[LEN];

138 double maxff=-2, minff=2, maxsf=-2, minsf=2;

139 for(i=0; i<LEN; i++){

140 double ss=0, sf=0, ff=0;

141 for(j=0; j<LEN+tap_count; j++)

142 sine[j]= cos(i*j*M_PI/LEN);

143 for(j=0; j<LEN; j++){

144 double sum=0;

145 ph=0;

146 for(k=0; k<tap_count; k++)

147 sum += filter[ph * tap_count + k] * sine[k+j];

148 filtered[j]= sum / (1<<FILTER_SHIFT);

149 ss+= sine[j + center] * sine[j + center];

150 ff+= filtered[j] * filtered[j];

151 sf+= sine[j + center] * filtered[j];

152 }

153 ss= sqrt(2*ss/LEN);

154 ff= sqrt(2*ff/LEN);

155 sf= 2*sf/LEN;

156 maxff= FFMAX(maxff, ff);

157 minff= FFMIN(minff, ff);

158 maxsf= FFMAX(maxsf, sf);

159 minsf= FFMIN(minsf, sf);

160 if(i%11==0){

161 av_log(NULL, AV_LOG_ERROR, "i:%4d ss:%f ff:%13.6e-%13.6e sf:%13.6e-%13.6e\n", i, ss, maxff, minff, maxsf, minsf);

162 minff=minsf= 2;

163 maxff=maxsf= -2;

164 }

165 }

166 }

167 #endif

168

169 ret = 0;

170 fail:

171 av_free(tab);

172 av_free(sin_lut);

173 return ret;

174 }

175

176 static void resample_free(ResampleContext **cc){

177 ResampleContext *c = *cc;

178 if(!c)

179 return;

180 av_freep(&c->filter_bank);

181 av_freep(cc);

182 }

183

184 static ResampleContext *resample_init(ResampleContext *c, int out_rate, int in_rate, int filter_size, int phase_shift, int linear,

185 double cutoff0, enum AVSampleFormat format, enum SwrFilterType filter_type, double kaiser_beta,

186 double precision, int cheby, int exact_rational)

187 {

188 double cutoff = cutoff0? cutoff0 : 0.97;

189 double factor= FFMIN(out_rate * cutoff / in_rate, 1.0);

190 int phase_count= 1<<phase_shift;

191 int phase_count_compensation = phase_count;

192 int filter_length = FFMAX((int)ceil(filter_size/factor), 1);

193

194 if (filter_length > 1)

195 filter_length = FFALIGN(filter_length, 2);

196

197 if (exact_rational) {

198 int phase_count_exact, phase_count_exact_den;

199

200 av_reduce(&phase_count_exact, &phase_count_exact_den, out_rate, in_rate, INT_MAX);

201 if (phase_count_exact <= phase_count) {

202 phase_count_compensation = phase_count_exact * (phase_count / phase_count_exact);

203 phase_count = phase_count_exact;

204 }

205 }

206

207 if (!c || c->phase_count != phase_count || c->linear!=linear || c->factor != factor

208 || c->filter_length != filter_length || c->format != format

209 || c->filter_type != filter_type || c->kaiser_beta != kaiser_beta) {

210 resample_free(&c);

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

212 if (!c)

213 return NULL;

214

215 c->format= format;

216

217 c->felem_size= av_get_bytes_per_sample(c->format);

218

219 switch(c->format){

220 case AV_SAMPLE_FMT_S16P:

221 c->filter_shift = 15;

222 break;

223 case AV_SAMPLE_FMT_S32P:

224 c->filter_shift = 30;

225 break;

226 case AV_SAMPLE_FMT_FLTP:

227 case AV_SAMPLE_FMT_DBLP:

228 c->filter_shift = 0;

229 break;

230 default:

231 av_log(NULL, AV_LOG_ERROR, "Unsupported sample format\n");

232 av_assert0(0);

233 }

234

235 if (filter_size/factor > INT32_MAX/256) {

236 av_log(NULL, AV_LOG_ERROR, "Filter length too large\n");

237 goto error;

238 }

239

240 c->phase_count = phase_count;

241 c->linear = linear;

242 c->factor = factor;

243 c->filter_length = filter_length;

244 c->filter_alloc = FFALIGN(c->filter_length, 8);

245 c->filter_bank = av_calloc(c->filter_alloc, (phase_count+1)*c->felem_size);

246 c->filter_type = filter_type;

247 c->kaiser_beta = kaiser_beta;

248 c->phase_count_compensation = phase_count_compensation;

249 if (!c->filter_bank)

250 goto error;

251 if (build_filter(c, (void*)c->filter_bank, factor, c->filter_length, c->filter_alloc, phase_count, 1<<c->filter_shift, filter_type, kaiser_beta))

252 goto error;

253 memcpy(c->filter_bank + (c->filter_alloc*phase_count+1)*c->felem_size, c->filter_bank, (c->filter_alloc-1)*c->felem_size);

254 memcpy(c->filter_bank + (c->filter_alloc*phase_count )*c->felem_size, c->filter_bank + (c->filter_alloc - 1)*c->felem_size, c->felem_size);

255 }

256

257 c->compensation_distance= 0;

258 if(!av_reduce(&c->src_incr, &c->dst_incr, out_rate, in_rate * (int64_t)phase_count, INT32_MAX/2))

259 goto error;

260 while (c->dst_incr < (1<<20) && c->src_incr < (1<<20)) {

261 c->dst_incr *= 2;

262 c->src_incr *= 2;

263 }

264 c->ideal_dst_incr = c->dst_incr;

265 c->dst_incr_div = c->dst_incr / c->src_incr;

266 c->dst_incr_mod = c->dst_incr % c->src_incr;

267

268 c->index= -phase_count*((c->filter_length-1)/2);

269 c->frac= 0;

270

271 swri_resample_dsp_init(c);

272

273 return c;

274 error:

275 av_freep(&c->filter_bank);

276 av_free(c);

277 return NULL;

278 }

279

280 static int rebuild_filter_bank_with_compensation(ResampleContext *c)

281 {

282 uint8_t *new_filter_bank;

283 int new_src_incr, new_dst_incr;

284 int phase_count = c->phase_count_compensation;

285 int ret;

286

287 if (phase_count == c->phase_count)

288 return 0;

289

290 av_assert0(!c->frac && !c->dst_incr_mod);

291

292 new_filter_bank = av_calloc(c->filter_alloc, (phase_count + 1) * c->felem_size);

293 if (!new_filter_bank)

294 return AVERROR(ENOMEM);

295

296 ret = build_filter(c, new_filter_bank, c->factor, c->filter_length, c->filter_alloc,

297 phase_count, 1 << c->filter_shift, c->filter_type, c->kaiser_beta);

298 if (ret < 0) {

299 av_freep(&new_filter_bank);

300 return ret;

301 }

302 memcpy(new_filter_bank + (c->filter_alloc*phase_count+1)*c->felem_size, new_filter_bank, (c->filter_alloc-1)*c->felem_size);

303 memcpy(new_filter_bank + (c->filter_alloc*phase_count )*c->felem_size, new_filter_bank + (c->filter_alloc - 1)*c->felem_size, c->felem_size);

304

305 if (!av_reduce(&new_src_incr, &new_dst_incr, c->src_incr,

306 c->dst_incr * (int64_t)(phase_count/c->phase_count), INT32_MAX/2))

307 {

308 av_freep(&new_filter_bank);

309 return AVERROR(EINVAL);

310 }

311

312 c->src_incr = new_src_incr;

313 c->dst_incr = new_dst_incr;

314 while (c->dst_incr < (1<<20) && c->src_incr < (1<<20)) {

315 c->dst_incr *= 2;

316 c->src_incr *= 2;

317 }

318 c->ideal_dst_incr = c->dst_incr;

319 c->dst_incr_div = c->dst_incr / c->src_incr;

320 c->dst_incr_mod = c->dst_incr % c->src_incr;

321 c->index *= phase_count / c->phase_count;

322 c->phase_count = phase_count;

323 av_freep(&c->filter_bank);

324 c->filter_bank = new_filter_bank;

325 return 0;

326 }

327

328 static int set_compensation(ResampleContext *c, int sample_delta, int compensation_distance){

329 int ret;

330

331 if (compensation_distance && sample_delta) {

332 ret = rebuild_filter_bank_with_compensation(c);

333 if (ret < 0)

334 return ret;

335 }

336

337 c->compensation_distance= compensation_distance;

338 if (compensation_distance)

339 c->dst_incr = c->ideal_dst_incr - c->ideal_dst_incr * (int64_t)sample_delta / compensation_distance;

340 else

341 c->dst_incr = c->ideal_dst_incr;

342

343 c->dst_incr_div = c->dst_incr / c->src_incr;

344 c->dst_incr_mod = c->dst_incr % c->src_incr;

345

346 return 0;

347 }

348

349 static int multiple_resample(ResampleContext *c, AudioData *dst, int dst_size, AudioData *src, int src_size, int *consumed){

350 int i;

351 int64_t max_src_size = (INT64_MAX/2 / c->phase_count) / c->src_incr;

352

353 if (c->compensation_distance)

354 dst_size = FFMIN(dst_size, c->compensation_distance);

355 src_size = FFMIN(src_size, max_src_size);

356

357 *consumed = 0;

358

359 if (c->filter_length == 1 && c->phase_count == 1) {

360 int64_t index2= (1LL<<32)*c->frac/c->src_incr + (1LL<<32)*c->index + 1;

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

362 int new_size = (src_size * (int64_t)c->src_incr - c->frac + c->dst_incr - 1) / c->dst_incr;

363

364 dst_size = FFMAX(FFMIN(dst_size, new_size), 0);

365 if (dst_size > 0) {

366 for (i = 0; i < dst->ch_count; i++) {

367 c->dsp.resample_one(dst->ch[i], src->ch[i], dst_size, index2, incr);

368 if (i+1 == dst->ch_count) {

369 c->index += dst_size * c->dst_incr_div;

370 c->index += (c->frac + dst_size * (int64_t)c->dst_incr_mod) / c->src_incr;

371 av_assert2(c->index >= 0);

372 *consumed = c->index;

373 c->frac = (c->frac + dst_size * (int64_t)c->dst_incr_mod) % c->src_incr;

374 c->index = 0;

375 }

376 }

377 }

378 } else {

379 int64_t end_index = (1LL + src_size - c->filter_length) * c->phase_count;

380 int64_t delta_frac = (end_index - c->index) * c->src_incr - c->frac;

381 int delta_n = (delta_frac + c->dst_incr - 1) / c->dst_incr;

382 int (*resample_func)(struct ResampleContext *c, void *dst,

383 const void *src, int n, int update_ctx);

384

385 dst_size = FFMAX(FFMIN(dst_size, delta_n), 0);

386 if (dst_size > 0) {

387 /* resample_linear and resample_common should have same behavior

388 * when frac and dst_incr_mod are zero */

389 resample_func = (c->linear && (c->frac || c->dst_incr_mod)) ?

390 c->dsp.resample_linear : c->dsp.resample_common;

391 for (i = 0; i < dst->ch_count; i++)

392 *consumed = resample_func(c, dst->ch[i], src->ch[i], dst_size, i+1 == dst->ch_count);

393 }

394 }

395

396 if (c->compensation_distance) {

397 c->compensation_distance -= dst_size;

398 if (!c->compensation_distance) {

399 c->dst_incr = c->ideal_dst_incr;

400 c->dst_incr_div = c->dst_incr / c->src_incr;

401 c->dst_incr_mod = c->dst_incr % c->src_incr;

402 }

403 }

404

405 return dst_size;

406 }

407

408 static int64_t get_delay(struct SwrContext *s, int64_t base){

409 ResampleContext *c = s->resample;

410 int64_t num = s->in_buffer_count - (c->filter_length-1)/2;

411 num *= c->phase_count;

412 num -= c->index;

413 num *= c->src_incr;

414 num -= c->frac;

415 return av_rescale(num, base, s->in_sample_rate*(int64_t)c->src_incr * c->phase_count);

416 }

417

418 static int64_t get_out_samples(struct SwrContext *s, int in_samples) {

419 ResampleContext *c = s->resample;

420 // The + 2 are added to allow implementations to be slightly inaccurate, they should not be needed currently.

421 // They also make it easier to proof that changes and optimizations do not

422 // break the upper bound.

423 int64_t num = s->in_buffer_count + 2LL + in_samples;

424 num *= c->phase_count;

425 num -= c->index;

426 num = av_rescale_rnd(num, s->out_sample_rate, ((int64_t)s->in_sample_rate) * c->phase_count, AV_ROUND_UP) + 2;

427

428 if (c->compensation_distance) {

429 if (num > INT_MAX)

430 return AVERROR(EINVAL);

431

432 num = FFMAX(num, (num * c->ideal_dst_incr - 1) / c->dst_incr + 1);

433 }

434 return num;

435 }

436

437 static int resample_flush(struct SwrContext *s) {

438 ResampleContext *c = s->resample;

439 AudioData *a= &s->in_buffer;

440 int i, j, ret;

441 int reflection = (FFMIN(s->in_buffer_count, c->filter_length) + 1) / 2;

442

443 if((ret = swri_realloc_audio(a, s->in_buffer_index + s->in_buffer_count + reflection)) < 0)

444 return ret;

445 av_assert0(a->planar);

446 for(i=0; i<a->ch_count; i++){

447 for(j=0; j<reflection; j++){

448 memcpy(a->ch[i] + (s->in_buffer_index+s->in_buffer_count+j )*a->bps,

449 a->ch[i] + (s->in_buffer_index+s->in_buffer_count-j-1)*a->bps, a->bps);

450 }

451 }

452 s->in_buffer_count += reflection;

453 return 0;

454 }

455

456 // in fact the whole handle multiple ridiculously small buffers might need more thinking...

457 static int invert_initial_buffer(ResampleContext *c, AudioData *dst, const AudioData *src,

458 int in_count, int *out_idx, int *out_sz)

459 {

460 int n, ch, num = FFMIN(in_count + *out_sz, c->filter_length + 1), res;

461

462 if (c->index >= 0)

463 return 0;

464

465 if ((res = swri_realloc_audio(dst, c->filter_length * 2 + 1)) < 0)

466 return res;

467

468 // copy

469 for (n = *out_sz; n < num; n++) {

470 for (ch = 0; ch < src->ch_count; ch++) {

471 memcpy(dst->ch[ch] + ((c->filter_length + n) * c->felem_size),

472 src->ch[ch] + ((n - *out_sz) * c->felem_size), c->felem_size);

473 }

474 }

475

476 // if not enough data is in, return and wait for more

477 if (num < c->filter_length + 1) {

478 *out_sz = num;

479 *out_idx = c->filter_length;

480 return INT_MAX;

481 }

482

483 // else invert

484 for (n = 1; n <= c->filter_length; n++) {

485 for (ch = 0; ch < src->ch_count; ch++) {

486 memcpy(dst->ch[ch] + ((c->filter_length - n) * c->felem_size),

487 dst->ch[ch] + ((c->filter_length + n) * c->felem_size),

488 c->felem_size);

489 }

490 }

491

492 res = num - *out_sz;

493 *out_idx = c->filter_length;

494 while (c->index < 0) {

495 --*out_idx;

496 c->index += c->phase_count;

497 }

498 *out_sz = FFMAX(*out_sz + c->filter_length,

499 1 + c->filter_length * 2) - *out_idx;

500

501 return FFMAX(res, 0);

502 }

503

504 const struct Resampler swri_resampler = {

505 .init = resample_init,

506 .free = resample_free,

507 .multiple_resample = multiple_resample,

508 .flush = resample_flush,

509 .set_compensation = set_compensation,

510 .get_delay = get_delay,

511 .invert_initial_buffer = invert_initial_buffer,

512 .get_out_samples = get_out_samples,

513 };

error

static void error(const char *err)

Definition: target_bsf_fuzzer.c:32

AV_ROUND_UP

@ AV_ROUND_UP

Round toward +infinity.

Definition: mathematics.h:134

AV_SAMPLE_FMT_FLTP

@ AV_SAMPLE_FMT_FLTP

float, planar

Definition: samplefmt.h:66

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

swri_resampler

const struct Resampler swri_resampler

Definition: resample.c:504

resample_free

static void resample_free(ResampleContext **cc)

Definition: resample.c:176

av_bessel_i0

double av_bessel_i0(double x)

0th order modified bessel function of the first kind.

Definition: mathematics.c:257

int64_t

long long int64_t

Definition: coverity.c:34

static int FUNC() ph(CodedBitstreamContext *ctx, RWContext *rw, H266RawPH *current)

Definition: cbs_h266_syntax_template.c:3037

uint8_t w

Definition: llviddspenc.c:38

kaiser_beta

static float kaiser_beta(float att, float tr_bw)

Definition: asrc_sinc.c:125

AV_SAMPLE_FMT_S32P

@ AV_SAMPLE_FMT_S32P

signed 32 bits, planar

Definition: samplefmt.h:65

linear

static int linear(InterplayACMContext *s, unsigned ind, unsigned col)

Definition: interplayacm.c:135

LEN

#define LEN

base

uint8_t base

Definition: vp3data.h:128

filter

void(* filter)(uint8_t *src, int stride, int qscale)

Definition: h263dsp.c:29

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

AudioData

Definition: swresample_internal.h:45

SWR_FILTER_TYPE_BLACKMAN_NUTTALL

@ SWR_FILTER_TYPE_BLACKMAN_NUTTALL

Blackman Nuttall windowed sinc.

Definition: swresample.h:175

ResampleContext::filter_length

int filter_length

Definition: resample.h:33

fail

#define fail()

Definition: checkasm.h:207

swri_realloc_audio

int swri_realloc_audio(AudioData *a, int count)

Definition: swresample.c:400

tab

static const struct twinvq_data tab

Definition: twinvq_data.h:10345

SWR_FILTER_TYPE_KAISER

@ SWR_FILTER_TYPE_KAISER

Kaiser windowed sinc.

Definition: swresample.h:176

#define ss(width, name, subs,...)

Definition: cbs_vp9.c:202

av_reduce

int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)

Reduce a fraction.

Definition: rational.c:35

avassert.h

ceil

static __device__ float ceil(float a)

Definition: cuda_runtime.h:176

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

#define s(width, name)

Definition: cbs_vp9.c:198

ResampleContext

Definition: resample.h:30

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:41

SwrContext

The libswresample context.

Definition: swresample_internal.h:95

if(ret)

Definition: filter_design.txt:179

fabs

static __device__ float fabs(float a)

Definition: cuda_runtime.h:182

av_clip_int16

#define av_clip_int16

Definition: common.h:115

NULL

#define NULL

Definition: coverity.c:32

format

New swscale design to change SwsGraph is what coordinates multiple passes These can include cascaded scaling error diffusion and so on Or we could have separate passes for the vertical and horizontal scaling In between each SwsPass lies a fully allocated image buffer Graph passes may have different levels of e g we can have a single threaded error diffusion pass following a multi threaded scaling pass SwsGraph is internally recreated whenever the image format

Definition: swscale-v2.txt:14

SwrFilterType

Resampling Filter Types.

Definition: swresample.h:173

get_delay

static int64_t get_delay(struct SwrContext *s, int64_t base)

Definition: resample.c:408

double

Definition: af_crystalizer.c:132

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

av_rescale_rnd

int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)

Rescale a 64-bit integer with specified rounding.

Definition: mathematics.c:58

av_clipl_int32

#define av_clipl_int32

Definition: common.h:118

dst

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:87

SWR_FILTER_TYPE_CUBIC

@ SWR_FILTER_TYPE_CUBIC

Cubic.

Definition: swresample.h:174

The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a

Definition: undefined.txt:41

rebuild_filter_bank_with_compensation

static int rebuild_filter_bank_with_compensation(ResampleContext *c)

Definition: resample.c:280

Resampler

Definition: swresample_internal.h:81

M_PI

#define M_PI

Definition: mathematics.h:67

AV_SAMPLE_FMT_S16P

@ AV_SAMPLE_FMT_S16P

signed 16 bits, planar

Definition: samplefmt.h:64

av_assert2

#define av_assert2(cond)

assert() equivalent, that does lie in speed critical code.

Definition: avassert.h:68

lrintf

#define lrintf(x)

Definition: libm_mips.h:72

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

av_get_bytes_per_sample

int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)

Return number of bytes per sample.

Definition: samplefmt.c:108

av_malloc_array

#define av_malloc_array(a, b)

Definition: tableprint_vlc.h:32

Resampler::init

resample_init_func init

Definition: swresample_internal.h:82

AVSampleFormat

Audio sample formats.

Definition: samplefmt.h:55

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

invert_initial_buffer

static int invert_initial_buffer(ResampleContext *c, AudioData *dst, const AudioData *src, int in_count, int *out_idx, int *out_sz)

Definition: resample.c:457

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...

Definition: mem.c:256

av_rescale

int64_t av_rescale(int64_t a, int64_t b, int64_t c)

Rescale a 64-bit integer with rounding to nearest.

Definition: mathematics.c:129

av_calloc

void * av_calloc(size_t nmemb, size_t size)

Definition: mem.c:264

resample.h

ret

Definition: filter_design.txt:187

get_out_samples

static int64_t get_out_samples(struct SwrContext *s, int in_samples)

Definition: resample.c:418

set_compensation

static int set_compensation(ResampleContext *c, int sample_delta, int compensation_distance)

Definition: resample.c:328

AV_SAMPLE_FMT_DBLP

@ AV_SAMPLE_FMT_DBLP

double, planar

Definition: samplefmt.h:67

factor

static const int factor[16]

Definition: vf_pp7.c:80

swri_resample_dsp_init

void swri_resample_dsp_init(ResampleContext *c)

Definition: resample_dsp.c:46

build_filter

static int build_filter(ResampleContext *c, void *filter, double factor, int tap_count, int alloc, int phase_count, int scale, int filter_type, double kaiser_beta)

builds a polyphase filterbank.

Definition: resample.c:41

resample_flush

static int resample_flush(struct SwrContext *s)

Definition: resample.c:437

mem.h

multiple_resample

static int multiple_resample(ResampleContext *c, AudioData *dst, int dst_size, AudioData *src, int src_size, int *consumed)

Definition: resample.c:349

llrint

#define llrint(x)

Definition: libm.h:396

av_free

#define av_free(p)

Definition: tableprint_vlc.h:34

scale

static void scale(int *out, const int *in, const int w, const int h, const int shift)

Definition: intra.c:273

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:78

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

int32_t

Definition: audioconvert.c:56

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

resample_init

static ResampleContext * resample_init(ResampleContext *c, int out_rate, int in_rate, int filter_size, int phase_shift, int linear, double cutoff0, enum AVSampleFormat format, enum SwrFilterType filter_type, double kaiser_beta, double precision, int cheby, int exact_rational)

Definition: resample.c:184

src

#define src

Definition: vp8dsp.c:248

Generated on Wed Nov 19 2025 19:23:29 for FFmpeg by doxygen 1.8.17