FFmpeg: libswresample/swresample.c Source File

223 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));

224 return AVERROR(EINVAL);

225 }

226

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

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

229

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

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

232 s->async = 1;

233 s->firstpts =

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

235 } else

236 s->firstpts = AV_NOPTS_VALUE;

237

238 if (s->async) {

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

240 s->min_compensation = 0.001;

241 if (s->async > 1.0001) {

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

243 }

244 }

245

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

247 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);

248 }else

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

250 if( s->int_sample_fmt != AV_SAMPLE_FMT_S16P

251 && s->int_sample_fmt != AV_SAMPLE_FMT_S32P

252 && s->int_sample_fmt != AV_SAMPLE_FMT_FLTP

253 && s->int_sample_fmt != AV_SAMPLE_FMT_DBLP

254 && s->resample){

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

256 return -1;

257 }

258

259 #define RSC 1 //FIXME finetune

260 if(!s-> in.ch_count)

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

262 if(!s->used_ch_count)

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

264 if(!s->out.ch_count)

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

266

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

268 av_assert0(!s->in_ch_layout);

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

270 return -1;

271 }

272

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

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

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

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

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

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

279 return -1;

280 }

281

282 av_assert0(s->used_ch_count);

283 av_assert0(s->out.ch_count);

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

285

286 s->in_buffer= s->in;

287 s->silence = s->in;

288 s->drop_temp= s->out;

289

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

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

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

293 return 0;

294 }

295

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

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

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

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

300

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

302 return AVERROR(ENOMEM);

303

304 s->postin= s->in;

305 s->preout= s->out;

306 s->midbuf= s->in;

307

308 if(s->channel_map){

309 s->postin.ch_count=

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

311 if(s->resample)

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

313 }

314 if(!s->resample_first){

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

316 if(s->resample)

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

318 }

319

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

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

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

323

324 if(s->resample){

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

326 }

327

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

329 return ret;

330

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

332 return swri_rematrix_init(s);

333

334 return 0;

335 }

336

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

338 int i, countb;

339 AudioData old;

340

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

342 return AVERROR(EINVAL);

343

344 if(a->count >= count)

345 return 0;

346

347 count*=2;

348

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

350 old= *a;

351

352 av_assert0(a->bps);

353 av_assert0(a->ch_count);

354

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

356 if(!a->data)

357 return AVERROR(ENOMEM);

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

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

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

361 }

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

363 av_freep(&old.data);

364 a->count= count;

365

366 return 1;

367 }

368

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

370 int count){

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

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

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

374 if(out->planar){

375 int ch;

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

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

378 }else

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

380 }

381

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

383 int i;

384 if(!in_arg){

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

386 }else if(out->planar){

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

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

389 }else{

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

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

392 }

393 }

394

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

396 int i;

397 if(out->planar){

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

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

400 }else{

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

402 }

403 }

404

405 /**

406 *

407 * out may be equal in.

408 */

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

410 int ch;

411 if(in->planar){

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

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

414 }else{

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

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

417 }

418 }

419

420 /**

421 *

422 * @return number of samples output per channel

423 */

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

425 const AudioData * in_param, int in_count){

426 AudioData in, out, tmp;

427 int ret_sum=0;

428 int border=0;

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

430

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

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

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

434

435 tmp=out=*out_param;

436 in = *in_param;

437

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

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

440 if (border == INT_MAX) {

441 return 0;

442 } else if (border < 0) {

443 return border;

444 } else if (border) {

445 buf_set(&in, &in, border);

446 in_count -= border;

447 s->resample_in_constraint = 0;

448 }

449

450 do{

451 int ret, size, consumed;

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

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

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

455 out_count -= ret;

456 ret_sum += ret;

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

458 s->in_buffer_count -= consumed;

459 s->in_buffer_index += consumed;

460

461 if(!in_count)

462 break;

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

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

465 in_count += s->in_buffer_count;

466 s->in_buffer_count=0;

467 s->in_buffer_index=0;

468 border = 0;

469 }

470 }

471

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

473 s->in_buffer_index=0;

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

475 out_count -= ret;

476 ret_sum += ret;

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

478 in_count -= consumed;

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

480 }

481

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

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

484 if( size > s->in_buffer.count

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

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

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

488 s->in_buffer_index=0;

489 }else

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

491 return ret;

492

493 if(in_count){

494 int count= in_count;

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

496

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

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

499 s->in_buffer_count += count;

500 in_count -= count;

501 border += count;

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

503 s->resample_in_constraint= 0;

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

505 continue;

506 if (padless) {

507 padless = 0;

508 continue;

509 }

510 }

511 break;

512 }while(1);

513

514 s->resample_in_constraint= !!out_count;

515

516 return ret_sum;

517 }

518

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

520 AudioData *in , int in_count){

521 AudioData *postin, *midbuf, *preout;

522 int ret /*, in_max*/;

523 AudioData preout_tmp, midbuf_tmp;

524

525 if(s->full_convert){

526 av_assert0(!s->resample);

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

528 return out_count;

529 }

530

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

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

533

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

535 return ret;

536 if(s->resample_first){

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

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

539 return ret;

540 }else{

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

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

543 return ret;

544 }

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

546 return ret;

547

548 postin= &s->postin;

549

550 midbuf_tmp= s->midbuf;

551 midbuf= &midbuf_tmp;

552 preout_tmp= s->preout;

553 preout= &preout_tmp;

554

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

556 postin= in;

557

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

559 midbuf= postin;

560

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

562 preout= midbuf;

563

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

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

566 if(preout==in){

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

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

569 copy(out, in, out_count);

570 return out_count;

571 }

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

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

574 else preout= out;

575 }

576

577 if(in != postin){

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

579 }

580

581 if(s->resample_first){

582 if(postin != midbuf)

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

584 if(midbuf != preout)

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

586 }else{

587 if(postin != midbuf)

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

589 if(midbuf != preout)

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

591 }

592

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

594 AudioData *conv_src = preout;

595 if(s->dither.method){

596 int ch;

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

598

599 if (preout == in) {

600 conv_src = &s->dither.temp;

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

602 return ret;

603 }

604

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

606 return ret;

607 if(ret)

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

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

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

611

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

613 s->dither.noise_pos = 0;

614

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

616 if (s->mix_2_1_simd) {

617 int len1= out_count&~15;

618 int off = len1 * preout->bps;

619

620 if(len1)

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

622 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);

623 if(out_count != len1)

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

625 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);

626 } else {

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

628 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);

629 }

630 } else {

631 switch(s->int_sample_fmt) {

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

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

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

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

636 }

637 }

638 s->dither.noise_pos += out_count;

639 }

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

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

642 }

643 return out_count;

644 }

645

646 int swr_is_initialized(struct SwrContext *s) {

647 return !!s->in_buffer.ch_count;

648 }

649

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

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

652 AudioData * in= &s->in;

653 AudioData *out= &s->out;

654

655 if (!swr_is_initialized(s)) {

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

657 return AVERROR(EINVAL);

658 }

659

660 while(s->drop_output > 0){

661 int ret;

662 uint8_t *tmp_arg[SWR_CH_MAX];

663 #define MAX_DROP_STEP 16384

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

665 return ret;

666

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

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

669 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

670 s->drop_output *= -1;

671 in_count = 0;

672 if(ret>0) {

673 s->drop_output -= ret;

674 if (!s->drop_output && !out_arg)

675 return 0;

676 continue;

677 }

678

679 av_assert0(s->drop_output);

680 return 0;

681 }

682

683 if(!in_arg){

684 if(s->resample){

685 if (!s->flushed)

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

687 s->resample_in_constraint = 0;

688 s->flushed = 1;

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

690 return 0;

691 }

692 }else

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

694

695 fill_audiodata(out, out_arg);

696

697 if(s->resample){

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

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

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

701 return ret;

702 }else{

703 AudioData tmp= *in;

704 int ret2=0;

705 int ret, size;

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

707 if(size){

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

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

710 if(ret<0)

711 return ret;

712 ret2= ret;

713 s->in_buffer_count -= ret;

714 s->in_buffer_index += ret;

715 buf_set(out, out, ret);

716 out_count -= ret;

717 if(!s->in_buffer_count)

718 s->in_buffer_index = 0;

719 }

720

721 if(in_count){

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

723

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

725 if( size > s->in_buffer.count

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

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

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

729 s->in_buffer_index=0;

730 }else

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

732 return ret;

733 }

734

735 if(out_count){

736 size = FFMIN(in_count, out_count);

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

738 if(ret<0)

739 return ret;

740 buf_set(in, in, ret);

741 in_count -= ret;

742 ret2 += ret;

743 }

744 if(in_count){

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

746 copy(&tmp, in, in_count);

747 s->in_buffer_count += in_count;

748 }

749 }

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

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

752 return ret2;

753 }

754 }

755

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

757 const uint8_t *tmp_arg[SWR_CH_MAX];

758 s->drop_output += count;

759

760 if(s->drop_output <= 0)

761 return 0;

762

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

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

765 }

766

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

768 int ret, i;

769 uint8_t *tmp_arg[SWR_CH_MAX];

770

771 if(count <= 0)

772 return 0;

773

774 #define MAX_SILENCE_STEP 16384

775 while (count > MAX_SILENCE_STEP) {

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

777 return ret;

778 count -= MAX_SILENCE_STEP;

779 }

780

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

782 return ret;

783

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

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

786 } else

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

788

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

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

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

792 return ret;

793 }

794

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

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

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

798 }else{

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

800 }

801 }

802

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

804 int ret;

805

806 if (!s || compensation_distance < 0)

807 return AVERROR(EINVAL);

808 if (!compensation_distance && sample_delta)

809 return AVERROR(EINVAL);

810 if (!s->resample) {

811 s->flags |= SWR_FLAG_RESAMPLE;

812 ret = swr_init(s);

813 if (ret < 0)

814 return ret;

815 }

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

817 return AVERROR(EINVAL);

818 }else{

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

820 }

821 }

822

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

824 if(pts == INT64_MIN)

825 return s->outpts;

826

827 if (s->firstpts == AV_NOPTS_VALUE)

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

829

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

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

832 } else {

833 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;

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

835

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

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

838 int ret;

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

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

841 if(ret<0){

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

843 }

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

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

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

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

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

849 swr_set_compensation(s, comp, duration);

850 }

851 }

852

853 return s->outpts;

854 }

855 }

Generated on Sun Mar 8 2015 02:35:15 for FFmpeg by doxygen 1.8.2