FFmpeg: libswresample/swresample.c Source File

197 av_log(s, AV_LOG_ERROR, "Requested sample format %s is not supported internally, S16/S32/FLT/DBL is supported\n", av_get_sample_fmt_name(s->int_sample_fmt));

198 return AVERROR(EINVAL);

199 }

200

201 set_audiodata_fmt(&s-> in, s-> in_sample_fmt);

202 set_audiodata_fmt(&s->out, s->out_sample_fmt);

203

204 if (s->firstpts_in_samples != AV_NOPTS_VALUE) {

205 if (!s->async && s->min_compensation >= FLT_MAX/2)

206 s->async = 1;

207 s->firstpts =

208 s->outpts = s->firstpts_in_samples * s->out_sample_rate;

209 } else

210 s->firstpts = AV_NOPTS_VALUE;

211

212 if (s->async) {

213 if (s->min_compensation >= FLT_MAX/2)

214 s->min_compensation = 0.001;

215 if (s->async > 1.0001) {

216 s->max_soft_compensation = s->async / (double) s->in_sample_rate;

217 }

218 }

219

220 if (s->out_sample_rate!=s->in_sample_rate || (s->flags & SWR_FLAG_RESAMPLE)){

221 s->resample = s->resampler->init(s->resample, s->out_sample_rate, s->in_sample_rate, s->filter_size, s->phase_shift, s->linear_interp, s->cutoff, s->int_sample_fmt, s->filter_type, s->kaiser_beta, s->precision, s->cheby);

222 }else

223 s->resampler->free(&s->resample);

224 if( s->int_sample_fmt != AV_SAMPLE_FMT_S16P

225 && s->int_sample_fmt != AV_SAMPLE_FMT_S32P

226 && s->int_sample_fmt != AV_SAMPLE_FMT_FLTP

227 && s->int_sample_fmt != AV_SAMPLE_FMT_DBLP

228 && s->resample){

229 av_log(s, AV_LOG_ERROR, "Resampling only supported with internal s16/s32/flt/dbl\n");

230 return -1;

231 }

232

233 #define RSC 1 //FIXME finetune

234 if(!s-> in.ch_count)

235 s-> in.ch_count= av_get_channel_layout_nb_channels(s-> in_ch_layout);

236 if(!s->used_ch_count)

237 s->used_ch_count= s->in.ch_count;

238 if(!s->out.ch_count)

239 s->out.ch_count= av_get_channel_layout_nb_channels(s->out_ch_layout);

240

241 if(!s-> in.ch_count){

242 av_assert0(!s->in_ch_layout);

243 av_log(s, AV_LOG_ERROR, "Input channel count and layout are unset\n");

244 return -1;

245 }

246

247 if ((!s->out_ch_layout || !s->in_ch_layout) && s->used_ch_count != s->out.ch_count && !s->rematrix_custom) {

248 char l1[1024], l2[1024];

249 av_get_channel_layout_string(l1, sizeof(l1), s-> in.ch_count, s-> in_ch_layout);

250 av_get_channel_layout_string(l2, sizeof(l2), s->out.ch_count, s->out_ch_layout);

251 av_log(s, AV_LOG_ERROR, "Rematrix is needed between %s and %s "

252 "but there is not enough information to do it\n", l1, l2);

253 return -1;

254 }

255

256 av_assert0(s->used_ch_count);

257 av_assert0(s->out.ch_count);

258 s->resample_first= RSC*s->out.ch_count/s->in.ch_count - RSC < s->out_sample_rate/(float)s-> in_sample_rate - 1.0;

259

260 s->in_buffer= s->in;

261 s->silence = s->in;

262 s->drop_temp= s->out;

263

264 if(!s->resample && !s->rematrix && !s->channel_map && !s->dither.method){

265 s->full_convert = swri_audio_convert_alloc(s->out_sample_fmt,

266 s-> in_sample_fmt, s-> in.ch_count, NULL, 0);

267 return 0;

268 }

269

270 s->in_convert = swri_audio_convert_alloc(s->int_sample_fmt,

271 s-> in_sample_fmt, s->used_ch_count, s->channel_map, 0);

272 s->out_convert= swri_audio_convert_alloc(s->out_sample_fmt,

273 s->int_sample_fmt, s->out.ch_count, NULL, 0);

274

275 if (!s->in_convert || !s->out_convert)

276 return AVERROR(ENOMEM);

277

278 s->postin= s->in;

279 s->preout= s->out;

280 s->midbuf= s->in;

281

282 if(s->channel_map){

283 s->postin.ch_count=

284 s->midbuf.ch_count= s->used_ch_count;

285 if(s->resample)

286 s->in_buffer.ch_count= s->used_ch_count;

287 }

288 if(!s->resample_first){

289 s->midbuf.ch_count= s->out.ch_count;

290 if(s->resample)

291 s->in_buffer.ch_count = s->out.ch_count;

292 }

293

294 set_audiodata_fmt(&s->postin, s->int_sample_fmt);

295 set_audiodata_fmt(&s->midbuf, s->int_sample_fmt);

296 set_audiodata_fmt(&s->preout, s->int_sample_fmt);

297

298 if(s->resample){

299 set_audiodata_fmt(&s->in_buffer, s->int_sample_fmt);

300 }

301

302 if ((ret = swri_dither_init(s, s->out_sample_fmt, s->int_sample_fmt)) < 0)

303 return ret;

304

305 if(s->rematrix || s->dither.method)

306 return swri_rematrix_init(s);

307

308 return 0;

309 }

310

311 int swri_realloc_audio(AudioData *a, int count){

312 int i, countb;

313 AudioData old;

314

315 if(count < 0 || count > INT_MAX/2/a->bps/a->ch_count)

316 return AVERROR(EINVAL);

317

318 if(a->count >= count)

319 return 0;

320

321 count*=2;

322

323 countb= FFALIGN(count*a->bps, ALIGN);

324 old= *a;

325

326 av_assert0(a->bps);

327 av_assert0(a->ch_count);

328

329 a->data= av_mallocz(countb*a->ch_count);

330 if(!a->data)

331 return AVERROR(ENOMEM);

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

333 a->ch[i]= a->data + i*(a->planar ? countb : a->bps);

334 if(a->planar) memcpy(a->ch[i], old.ch[i], a->count*a->bps);

335 }

336 if(!a->planar) memcpy(a->ch[0], old.ch[0], a->count*a->ch_count*a->bps);

337 av_freep(&old.data);

338 a->count= count;

339

340 return 1;

341 }

342

343 static void copy(AudioData *out, AudioData *in,

344 int count){

345 av_assert0(out->planar == in->planar);

346 av_assert0(out->bps == in->bps);

347 av_assert0(out->ch_count == in->ch_count);

348 if(out->planar){

349 int ch;

350 for(ch=0; ch<out->ch_count; ch++)

351 memcpy(out->ch[ch], in->ch[ch], count*out->bps);

352 }else

353 memcpy(out->ch[0], in->ch[0], count*out->ch_count*out->bps);

354 }

355

356 static void fill_audiodata(AudioData *out, uint8_t *in_arg [SWR_CH_MAX]){

357 int i;

358 if(!in_arg){

359 memset(out->ch, 0, sizeof(out->ch));

360 }else if(out->planar){

361 for(i=0; i<out->ch_count; i++)

362 out->ch[i]= in_arg[i];

363 }else{

364 for(i=0; i<out->ch_count; i++)

365 out->ch[i]= in_arg[0] + i*out->bps;

366 }

367 }

368

369 static void reversefill_audiodata(AudioData *out, uint8_t *in_arg [SWR_CH_MAX]){

370 int i;

371 if(out->planar){

372 for(i=0; i<out->ch_count; i++)

373 in_arg[i]= out->ch[i];

374 }else{

375 in_arg[0]= out->ch[0];

376 }

377 }

378

379 /**

380 *

381 * out may be equal in.

382 */

383 static void buf_set(AudioData *out, AudioData *in, int count){

384 int ch;

385 if(in->planar){

386 for(ch=0; ch<out->ch_count; ch++)

387 out->ch[ch]= in->ch[ch] + count*out->bps;

388 }else{

389 for(ch=out->ch_count-1; ch>=0; ch--)

390 out->ch[ch]= in->ch[0] + (ch + count*out->ch_count) * out->bps;

391 }

392 }

393

394 /**

395 *

396 * @return number of samples output per channel

397 */

398 static int resample(SwrContext *s, AudioData *out_param, int out_count,

399 const AudioData * in_param, int in_count){

400 AudioData in, out, tmp;

401 int ret_sum=0;

402 int border=0;

403 int padless = ARCH_X86 && s->engine == SWR_ENGINE_SWR ? 7 : 0;

404

405 av_assert1(s->in_buffer.ch_count == in_param->ch_count);

406 av_assert1(s->in_buffer.planar == in_param->planar);

407 av_assert1(s->in_buffer.fmt == in_param->fmt);

408

409 tmp=out=*out_param;

410 in = *in_param;

411

412 border = s->resampler->invert_initial_buffer(s->resample, &s->in_buffer,

413 &in, in_count, &s->in_buffer_index, &s->in_buffer_count);

414 if (border == INT_MAX) return 0;

415 else if (border < 0) return border;

416 else if (border) { buf_set(&in, &in, border); in_count -= border; s->resample_in_constraint = 0; }

417

418 do{

419 int ret, size, consumed;

420 if(!s->resample_in_constraint && s->in_buffer_count){

421 buf_set(&tmp, &s->in_buffer, s->in_buffer_index);

422 ret= s->resampler->multiple_resample(s->resample, &out, out_count, &tmp, s->in_buffer_count, &consumed);

423 out_count -= ret;

424 ret_sum += ret;

425 buf_set(&out, &out, ret);

426 s->in_buffer_count -= consumed;

427 s->in_buffer_index += consumed;

428

429 if(!in_count)

430 break;

431 if(s->in_buffer_count <= border){

432 buf_set(&in, &in, -s->in_buffer_count);

433 in_count += s->in_buffer_count;

434 s->in_buffer_count=0;

435 s->in_buffer_index=0;

436 border = 0;

437 }

438 }

439

440 if((s->flushed || in_count > padless) && !s->in_buffer_count){

441 s->in_buffer_index=0;

442 ret= s->resampler->multiple_resample(s->resample, &out, out_count, &in, FFMAX(in_count-padless, 0), &consumed);

443 out_count -= ret;

444 ret_sum += ret;

445 buf_set(&out, &out, ret);

446 in_count -= consumed;

447 buf_set(&in, &in, consumed);

448 }

449

450 //TODO is this check sane considering the advanced copy avoidance below

451 size= s->in_buffer_index + s->in_buffer_count + in_count;

452 if( size > s->in_buffer.count

453 && s->in_buffer_count + in_count <= s->in_buffer_index){

454 buf_set(&tmp, &s->in_buffer, s->in_buffer_index);

455 copy(&s->in_buffer, &tmp, s->in_buffer_count);

456 s->in_buffer_index=0;

457 }else

458 if((ret=swri_realloc_audio(&s->in_buffer, size)) < 0)

459 return ret;

460

461 if(in_count){

462 int count= in_count;

463 if(s->in_buffer_count && s->in_buffer_count+2 < count && out_count) count= s->in_buffer_count+2;

464

465 buf_set(&tmp, &s->in_buffer, s->in_buffer_index + s->in_buffer_count);

466 copy(&tmp, &in, /*in_*/count);

467 s->in_buffer_count += count;

468 in_count -= count;

469 border += count;

470 buf_set(&in, &in, count);

471 s->resample_in_constraint= 0;

472 if(s->in_buffer_count != count || in_count)

473 continue;

474 if (padless) {

475 padless = 0;

476 continue;

477 }

478 }

479 break;

480 }while(1);

481

482 s->resample_in_constraint= !!out_count;

483

484 return ret_sum;

485 }

486

487 static int swr_convert_internal(struct SwrContext *s, AudioData *out, int out_count,

488 AudioData *in , int in_count){

489 AudioData *postin, *midbuf, *preout;

490 int ret /*, in_max*/;

491 AudioData preout_tmp, midbuf_tmp;

492

493 if(s->full_convert){

494 av_assert0(!s->resample);

495 swri_audio_convert(s->full_convert, out, in, in_count);

496 return out_count;

497 }

498

499 // in_max= out_count*(int64_t)s->in_sample_rate / s->out_sample_rate + resample_filter_taps;

500 // in_count= FFMIN(in_count, in_in + 2 - s->hist_buffer_count);

501

502 if((ret=swri_realloc_audio(&s->postin, in_count))<0)

503 return ret;

504 if(s->resample_first){

505 av_assert0(s->midbuf.ch_count == s->used_ch_count);

506 if((ret=swri_realloc_audio(&s->midbuf, out_count))<0)

507 return ret;

508 }else{

509 av_assert0(s->midbuf.ch_count == s->out.ch_count);

510 if((ret=swri_realloc_audio(&s->midbuf, in_count))<0)

511 return ret;

512 }

513 if((ret=swri_realloc_audio(&s->preout, out_count))<0)

514 return ret;

515

516 postin= &s->postin;

517

518 midbuf_tmp= s->midbuf;

519 midbuf= &midbuf_tmp;

520 preout_tmp= s->preout;

521 preout= &preout_tmp;

522

523 if(s->int_sample_fmt == s-> in_sample_fmt && s->in.planar && !s->channel_map)

524 postin= in;

525

526 if(s->resample_first ? !s->resample : !s->rematrix)

527 midbuf= postin;

528

529 if(s->resample_first ? !s->rematrix : !s->resample)

530 preout= midbuf;

531

532 if(s->int_sample_fmt == s->out_sample_fmt && s->out.planar

533 && !(s->out_sample_fmt==AV_SAMPLE_FMT_S32P && (s->dither.output_sample_bits&31))){

534 if(preout==in){

535 out_count= FFMIN(out_count, in_count); //TODO check at the end if this is needed or redundant

536 av_assert0(s->in.planar); //we only support planar internally so it has to be, we support copying non planar though

537 copy(out, in, out_count);

538 return out_count;

539 }

540 else if(preout==postin) preout= midbuf= postin= out;

541 else if(preout==midbuf) preout= midbuf= out;

542 else preout= out;

543 }

544

545 if(in != postin){

546 swri_audio_convert(s->in_convert, postin, in, in_count);

547 }

548

549 if(s->resample_first){

550 if(postin != midbuf)

551 out_count= resample(s, midbuf, out_count, postin, in_count);

552 if(midbuf != preout)

553 swri_rematrix(s, preout, midbuf, out_count, preout==out);

554 }else{

555 if(postin != midbuf)

556 swri_rematrix(s, midbuf, postin, in_count, midbuf==out);

557 if(midbuf != preout)

558 out_count= resample(s, preout, out_count, midbuf, in_count);

559 }

560

561 if(preout != out && out_count){

562 AudioData *conv_src = preout;

563 if(s->dither.method){

564 int ch;

565 int dither_count= FFMAX(out_count, 1<<16);

566

567 if (preout == in) {

568 conv_src = &s->dither.temp;

569 if((ret=swri_realloc_audio(&s->dither.temp, dither_count))<0)

570 return ret;

571 }

572

573 if((ret=swri_realloc_audio(&s->dither.noise, dither_count))<0)

574 return ret;

575 if(ret)

576 for(ch=0; ch<s->dither.noise.ch_count; ch++)

577 swri_get_dither(s, s->dither.noise.ch[ch], s->dither.noise.count, 12345678913579<<ch, s->dither.noise.fmt);

578 av_assert0(s->dither.noise.ch_count == preout->ch_count);

579

580 if(s->dither.noise_pos + out_count > s->dither.noise.count)

581 s->dither.noise_pos = 0;

582

583 if (s->dither.method < SWR_DITHER_NS){

584 if (s->mix_2_1_simd) {

585 int len1= out_count&~15;

586 int off = len1 * preout->bps;

587

588 if(len1)

589 for(ch=0; ch<preout->ch_count; ch++)

590 s->mix_2_1_simd(conv_src->ch[ch], preout->ch[ch], s->dither.noise.ch[ch] + s->dither.noise.bps * s->dither.noise_pos, s->native_simd_one, 0, 0, len1);

591 if(out_count != len1)

592 for(ch=0; ch<preout->ch_count; ch++)

593 s->mix_2_1_f(conv_src->ch[ch] + off, preout->ch[ch] + off, s->dither.noise.ch[ch] + s->dither.noise.bps * s->dither.noise_pos + off + len1, s->native_one, 0, 0, out_count - len1);

594 } else {

595 for(ch=0; ch<preout->ch_count; ch++)

596 s->mix_2_1_f(conv_src->ch[ch], preout->ch[ch], s->dither.noise.ch[ch] + s->dither.noise.bps * s->dither.noise_pos, s->native_one, 0, 0, out_count);

597 }

598 } else {

599 switch(s->int_sample_fmt) {

600 case AV_SAMPLE_FMT_S16P :swri_noise_shaping_int16(s, conv_src, preout, &s->dither.noise, out_count); break;

601 case AV_SAMPLE_FMT_S32P :swri_noise_shaping_int32(s, conv_src, preout, &s->dither.noise, out_count); break;

602 case AV_SAMPLE_FMT_FLTP :swri_noise_shaping_float(s, conv_src, preout, &s->dither.noise, out_count); break;

603 case AV_SAMPLE_FMT_DBLP :swri_noise_shaping_double(s,conv_src, preout, &s->dither.noise, out_count); break;

604 }

605 }

606 s->dither.noise_pos += out_count;

607 }

608 //FIXME packed doesn't need more than 1 chan here!

609 swri_audio_convert(s->out_convert, out, conv_src, out_count);

610 }

611 return out_count;

612 }

613

614 int swr_is_initialized(struct SwrContext *s) {

615 return !!s->in_buffer.ch_count;

616 }

617

618 int swr_convert(struct SwrContext *s, uint8_t *out_arg[SWR_CH_MAX], int out_count,

619 const uint8_t *in_arg [SWR_CH_MAX], int in_count){

620 AudioData * in= &s->in;

621 AudioData *out= &s->out;

622

623 if (!swr_is_initialized(s)) {

624 av_log(s, AV_LOG_ERROR, "Context has not been initialized\n");

625 return AVERROR(EINVAL);

626 }

627

628 while(s->drop_output > 0){

629 int ret;

630 uint8_t *tmp_arg[SWR_CH_MAX];

631 #define MAX_DROP_STEP 16384

632 if((ret=swri_realloc_audio(&s->drop_temp, FFMIN(s->drop_output, MAX_DROP_STEP)))<0)

633 return ret;

634

635 reversefill_audiodata(&s->drop_temp, tmp_arg);

636 s->drop_output *= -1; //FIXME find a less hackish solution

637 ret = swr_convert(s, tmp_arg, FFMIN(-s->drop_output, MAX_DROP_STEP), in_arg, in_count); //FIXME optimize but this is as good as never called so maybe it doesn't matter

638 s->drop_output *= -1;

639 in_count = 0;

640 if(ret>0) {

641 s->drop_output -= ret;

642 continue;

643 }

644

645 if(s->drop_output || !out_arg)

646 return 0;

647 }

648

649 if(!in_arg){

650 if(s->resample){

651 if (!s->flushed)

652 s->resampler->flush(s);

653 s->resample_in_constraint = 0;

654 s->flushed = 1;

655 }else if(!s->in_buffer_count){

656 return 0;

657 }

658 }else

659 fill_audiodata(in , (void*)in_arg);

660

661 fill_audiodata(out, out_arg);

662

663 if(s->resample){

664 int ret = swr_convert_internal(s, out, out_count, in, in_count);

665 if(ret>0 && !s->drop_output)

666 s->outpts += ret * (int64_t)s->in_sample_rate;

667 return ret;

668 }else{

669 AudioData tmp= *in;

670 int ret2=0;

671 int ret, size;

672 size = FFMIN(out_count, s->in_buffer_count);

673 if(size){

674 buf_set(&tmp, &s->in_buffer, s->in_buffer_index);

675 ret= swr_convert_internal(s, out, size, &tmp, size);

676 if(ret<0)

677 return ret;

678 ret2= ret;

679 s->in_buffer_count -= ret;

680 s->in_buffer_index += ret;

681 buf_set(out, out, ret);

682 out_count -= ret;

683 if(!s->in_buffer_count)

684 s->in_buffer_index = 0;

685 }

686

687 if(in_count){

688 size= s->in_buffer_index + s->in_buffer_count + in_count - out_count;

689

690 if(in_count > out_count) { //FIXME move after swr_convert_internal

691 if( size > s->in_buffer.count

692 && s->in_buffer_count + in_count - out_count <= s->in_buffer_index){

693 buf_set(&tmp, &s->in_buffer, s->in_buffer_index);

694 copy(&s->in_buffer, &tmp, s->in_buffer_count);

695 s->in_buffer_index=0;

696 }else

697 if((ret=swri_realloc_audio(&s->in_buffer, size)) < 0)

698 return ret;

699 }

700

701 if(out_count){

702 size = FFMIN(in_count, out_count);

703 ret= swr_convert_internal(s, out, size, in, size);

704 if(ret<0)

705 return ret;

706 buf_set(in, in, ret);

707 in_count -= ret;

708 ret2 += ret;

709 }

710 if(in_count){

711 buf_set(&tmp, &s->in_buffer, s->in_buffer_index + s->in_buffer_count);

712 copy(&tmp, in, in_count);

713 s->in_buffer_count += in_count;

714 }

715 }

716 if(ret2>0 && !s->drop_output)

717 s->outpts += ret2 * (int64_t)s->in_sample_rate;

718 return ret2;

719 }

720 }

721

722 int swr_drop_output(struct SwrContext *s, int count){

723 s->drop_output += count;

724

725 if(s->drop_output <= 0)

726 return 0;

727

728 av_log(s, AV_LOG_VERBOSE, "discarding %d audio samples\n", count);

729 return swr_convert(s, NULL, s->drop_output, NULL, 0);

730 }

731

732 int swr_inject_silence(struct SwrContext *s, int count){

733 int ret, i;

734 uint8_t *tmp_arg[SWR_CH_MAX];

735

736 if(count <= 0)

737 return 0;

738

739 #define MAX_SILENCE_STEP 16384

740 while (count > MAX_SILENCE_STEP) {

741 if ((ret = swr_inject_silence(s, MAX_SILENCE_STEP)) < 0)

742 return ret;

743 count -= MAX_SILENCE_STEP;

744 }

745

746 if((ret=swri_realloc_audio(&s->silence, count))<0)

747 return ret;

748

749 if(s->silence.planar) for(i=0; i<s->silence.ch_count; i++) {

750 memset(s->silence.ch[i], s->silence.bps==1 ? 0x80 : 0, count*s->silence.bps);

751 } else

752 memset(s->silence.ch[0], s->silence.bps==1 ? 0x80 : 0, count*s->silence.bps*s->silence.ch_count);

753

754 reversefill_audiodata(&s->silence, tmp_arg);

755 av_log(s, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", count);

756 ret = swr_convert(s, NULL, 0, (const uint8_t**)tmp_arg, count);

757 return ret;

758 }

759

760 int64_t swr_get_delay(struct SwrContext *s, int64_t base){

761 if (s->resampler && s->resample){

762 return s->resampler->get_delay(s, base);

763 }else{

764 return (s->in_buffer_count*base + (s->in_sample_rate>>1))/ s->in_sample_rate;

765 }

766 }

767

768 int swr_set_compensation(struct SwrContext *s, int sample_delta, int compensation_distance){

769 int ret;

770

771 if (!s || compensation_distance < 0)

772 return AVERROR(EINVAL);

773 if (!compensation_distance && sample_delta)

774 return AVERROR(EINVAL);

775 if (!s->resample) {

776 s->flags |= SWR_FLAG_RESAMPLE;

777 ret = swr_init(s);

778 if (ret < 0)

779 return ret;

780 }

781 if (!s->resampler->set_compensation){

782 return AVERROR(EINVAL);

783 }else{

784 return s->resampler->set_compensation(s->resample, sample_delta, compensation_distance);

785 }

786 }

787

788 int64_t swr_next_pts(struct SwrContext *s, int64_t pts){

789 if(pts == INT64_MIN)

790 return s->outpts;

791

792 if (s->firstpts == AV_NOPTS_VALUE)

793 s->outpts = s->firstpts = pts;

794

795 if(s->min_compensation >= FLT_MAX) {

796 return (s->outpts = pts - swr_get_delay(s, s->in_sample_rate * (int64_t)s->out_sample_rate));

797 } else {

798 int64_t delta = pts - swr_get_delay(s, s->in_sample_rate * (int64_t)s->out_sample_rate) - s->outpts + s->drop_output*(int64_t)s->in_sample_rate;

799 double fdelta = delta /(double)(s->in_sample_rate * (int64_t)s->out_sample_rate);

800

801 if(fabs(fdelta) > s->min_compensation) {

802 if(s->outpts == s->firstpts || fabs(fdelta) > s->min_hard_compensation){

803 int ret;

804 if(delta > 0) ret = swr_inject_silence(s, delta / s->out_sample_rate);

805 else ret = swr_drop_output (s, -delta / s-> in_sample_rate);

806 if(ret<0){

807 av_log(s, AV_LOG_ERROR, "Failed to compensate for timestamp delta of %f\n", fdelta);

808 }

809 } else if(s->soft_compensation_duration && s->max_soft_compensation) {

810 int duration = s->out_sample_rate * s->soft_compensation_duration;

811 double max_soft_compensation = s->max_soft_compensation / (s->max_soft_compensation < 0 ? -s->in_sample_rate : 1);

812 int comp = av_clipf(fdelta, -max_soft_compensation, max_soft_compensation) * duration ;

813 av_log(s, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n", fdelta, comp, duration);

814 swr_set_compensation(s, comp, duration);

815 }

816 }

817

818 return s->outpts;

819 }

820 }

Generated on Sun Jul 20 2014 23:06:08 for FFmpeg by doxygen 1.8.2