~ubuntu-branches/ubuntu/utopic/ardour3/utopic

std::cerr << "assigning to filter index " << index << " (size = " << p*2 << ")" << " value " << phaseScratch[i] << " from scratch index " << i << std::endl;

612

#endif

613

Filter[ index++ ] = phaseScratch[ i ];

614

}

615

}

616

else

617

{

618

for( int i = 0; i < p; i ++)

619

{

620

Filter[ i ] = 1;

621

}

622

}

623

624

delete [] phaseScratch;

625

}

626

627

int TempoTrack::phaseMM(double *DF, double *weighting, unsigned int winLength, double period)

628

{

629

int alignment = 0;

630

int p = (int)MathUtilities::round( period );

631

632

double temp = 0.0;

633

634

double* y = new double[ winLength ];

635

double* align = new double[ p ];

636

637

for( int i = 0; i < winLength; i++ )

638

{

639

y[ i ] = (double)( -i + winLength )/(double)winLength;

640

y[ i ] = pow(y [i ],2.0); // raise to power 2.

641

}

642

643

for( int o = 0; o < p; o++ )

644

{

645

temp = 0.0;

646

for(int i = 1 + (o - 1); i< winLength; i += (p + 1))

647

{

648

temp = temp + DF[ i ] * y[ i ];

649

}

650

align[ o ] = temp * weighting[ o ];

651

}

652

653

654

double valTemp = 0.0;

655

for(int i = 0; i < p; i++)

656

{

657

if( align[ i ] > valTemp )

658

{

659

valTemp = align[ i ];

660

alignment = i;

661

}

662

}

663

664

delete [] y;

665

delete [] align;

666

667

return alignment;

668

}

669

670

int TempoTrack::beatPredict(unsigned int FSP0, double alignment, double period, unsigned int step )

671

{

672

int beat = 0;

673

674

int p = (int)MathUtilities::round( period );

675

int align = (int)MathUtilities::round( alignment );

676

int FSP = (int)MathUtilities::round( FSP0 );

677

678

int FEP = FSP + ( step );

679

680

beat = FSP + align;

681

682

m_beats.push_back( beat );

683

684

while( beat + p < FEP )

685

{

686

beat += p;

687

688

m_beats.push_back( beat );

689

}

690

691

return beat;

692

}

693

694

695

696

vector<int> TempoTrack::process( vector <double> DF,

697

vector <double> *tempoReturn )

698

{

699

m_dataLength = DF.size();

700

701

m_lockedTempo = 0.0;

702

703

double period = 0.0;

704

int stepFlag = 0;

705

int constFlag = 0;

706

int FSP = 0;

707

int tsig = 0;

708

int lastBeat = 0;

709

710

vector <double> causalDF;

711

712

causalDF = DF;

713

714

//Prepare Causal Extension DFData

715

unsigned int DFCLength = m_dataLength + m_winLength;

716

717

for( unsigned int j = 0; j < m_winLength; j++ )

718

{

719

causalDF.push_back( 0 );

720

}

721

722

723

double* RW = new double[ m_lagLength ];

724

for( unsigned int clear = 0; clear < m_lagLength; clear++){ RW[ clear ] = 0.0;}

725

726

double* GW = new double[ m_lagLength ];

727

for(unsigned int clear = 0; clear < m_lagLength; clear++){ GW[ clear ] = 0.0;}

728

729

double* PW = new double[ m_lagLength ];

730

for(unsigned clear = 0; clear < m_lagLength; clear++){ PW[ clear ] = 0.0;}

731

732

m_DFFramer.setSource( &causalDF[0], m_dataLength );

733

734

unsigned int TTFrames = m_DFFramer.getMaxNoFrames();

735

736

#ifdef DEBUG_TEMPO_TRACK

737

std::cerr << "TTFrames = " << TTFrames << std::endl;

738

#endif

739

740

double* periodP = new double[ TTFrames ];

741

for(unsigned clear = 0; clear < TTFrames; clear++){ periodP[ clear ] = 0.0;}

742

743

double* periodG = new double[ TTFrames ];

744

for(unsigned clear = 0; clear < TTFrames; clear++){ periodG[ clear ] = 0.0;}

745

746

double* alignment = new double[ TTFrames ];

747

for(unsigned clear = 0; clear < TTFrames; clear++){ alignment[ clear ] = 0.0;}

748

749

m_beats.clear();

750

751

createCombFilter( RW, m_lagLength, 0, 0 );

752

753

int TTLoopIndex = 0;

754

755

for( unsigned int i = 0; i < TTFrames; i++ )

756

{

757

m_DFFramer.getFrame( m_rawDFFrame );

758

759

m_DFConditioning->process( m_rawDFFrame, m_smoothDFFrame );

760

761

m_correlator.doAutoUnBiased( m_smoothDFFrame, m_frameACF, m_winLength );

762

763

periodP[ TTLoopIndex ] = tempoMM( m_frameACF, RW, 0 );

764

765

if( GW[ 0 ] != 0 )

766

{

767

periodG[ TTLoopIndex ] = tempoMM( m_frameACF, GW, tsig );

768

}

769

else

770

{

771

periodG[ TTLoopIndex ] = 0.0;

772

}

773

774

stepDetect( periodP, periodG, TTLoopIndex, &stepFlag );

775

776

if( stepFlag == 1)

777

{

778

constDetect( periodP, TTLoopIndex, &constFlag );

779

stepFlag = 0;

780

}

781

else

782

{

783

stepFlag -= 1;

784

}

785

786

if( stepFlag < 0 )

787

{

788

stepFlag = 0;

789

}

790

791

if( constFlag != 0)

792

{

793

tsig = findMeter( m_frameACF, m_winLength, periodP[ TTLoopIndex ] );

794

795

createCombFilter( GW, m_lagLength, tsig, periodP[ TTLoopIndex ] );

796

797

periodG[ TTLoopIndex ] = tempoMM( m_frameACF, GW, tsig );

798

799

period = periodG[ TTLoopIndex ];

800

801

#ifdef DEBUG_TEMPO_TRACK

802

std::cerr << "TempoTrack::process: constFlag == " << constFlag << ", TTLoopIndex = " << TTLoopIndex << ", period from periodG = " << period << std::endl;

803

#endif

804

805

createPhaseExtractor( PW, m_winLength, period, FSP, 0 );

806

807

constFlag = 0;

808

809

}

810

else

811

{

812

if( GW[ 0 ] != 0 )

813

{

814

period = periodG[ TTLoopIndex ];

815

816

#ifdef DEBUG_TEMPO_TRACK

817

std::cerr << "TempoTrack::process: GW[0] == " << GW[0] << ", TTLoopIndex = " << TTLoopIndex << ", period from periodG = " << period << std::endl;

818

#endif

819

820

if (period > 10000) {

821

std::cerr << "TempoTrack::process: WARNING! Highly implausible period value " << period << "!" << std::endl;

822

std::cerr << "periodG contains (of " << TTFrames << " frames): " << std::endl;

823

for (int i = 0; i < TTLoopIndex + 3 && i < TTFrames; ++i) {

824

std::cerr << i << " -> " << periodG[i] << std::endl;

825

}

826

std::cerr << "periodP contains (of " << TTFrames << " frames): " << std::endl;

827

for (int i = 0; i < TTLoopIndex + 3 && i < TTFrames; ++i) {

828

std::cerr << i << " -> " << periodP[i] << std::endl;

829

}

830

period = 5168 / 120;

831

}

832

833

createPhaseExtractor( PW, m_winLength, period, FSP, lastBeat );

834

835

}

836

else

837

{

838

period = periodP[ TTLoopIndex ];

839

840

#ifdef DEBUG_TEMPO_TRACK

841

std::cerr << "TempoTrack::process: GW[0] == " << GW[0] << ", TTLoopIndex = " << TTLoopIndex << ", period from periodP = " << period << std::endl;

842

#endif

843

844

createPhaseExtractor( PW, m_winLength, period, FSP, 0 );

845

}

846

}

847

848

alignment[ TTLoopIndex ] = phaseMM( m_rawDFFrame, PW, m_winLength, period );

849

850

lastBeat = beatPredict(FSP, alignment[ TTLoopIndex ], period, m_lagLength );

851

852

FSP += (m_lagLength);

853

854

if (tempoReturn) tempoReturn->push_back(m_lockedTempo);

855

856

TTLoopIndex++;

857

}

858

859

860

delete [] periodP;

861

delete [] periodG;

862

delete [] alignment;

863

864

delete [] RW;

865

delete [] GW;

866

delete [] PW;

867

868

return m_beats;

869

}

Older »