X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fpi_controller.cc;h=2ecfe730d8cd117cffa2737d0aada32750dcd8f1;hb=6be56d78b199452e5dba726f2d7aaab2777d2b49;hp=5aee7f23011933568b7f58fdb8126707bc0ba54c;hpb=c17b4a30a51f891a8f6dd080969532c5562f493e;p=ardour.git diff --git a/libs/ardour/pi_controller.cc b/libs/ardour/pi_controller.cc index 5aee7f2301..2ecfe730d8 100644 --- a/libs/ardour/pi_controller.cc +++ b/libs/ardour/pi_controller.cc @@ -42,10 +42,11 @@ PIController::PIController (double resample_factor, int fir_size) } // These values could be configurable - catch_factor = 100000; - catch_factor2 = 10000; - pclamp = 15.0; + catch_factor = 20000; + catch_factor2 = 4000; + pclamp = 150.0; controlquant = 10000.0; + fir_empty = false; } PIController::~PIController () @@ -55,12 +56,22 @@ PIController::~PIController () } double -PIController::get_ratio (int fill_level) +PIController::get_ratio (int fill_level, int period_size) { double offset = fill_level; + double this_catch_factor = catch_factor; + double this_catch_factor2 = catch_factor2 * 4096.0/(double)period_size; + // Save offset. - offset_array[(offset_differential_index++) % smooth_size] = offset; + if( fir_empty ) { + for (int i = 0; i < smooth_size; i++) { + offset_array[i] = offset; + } + fir_empty = false; + } else { + offset_array[(offset_differential_index++) % smooth_size] = offset; + } // Build the mean of the windowed offset array basically fir lowpassing. smooth_offset = 0.0; @@ -72,24 +83,29 @@ PIController::get_ratio (int fill_level) // This is the integral of the smoothed_offset offset_integral += smooth_offset; + std::cerr << smooth_offset << " "; // Clamp offset : the smooth offset still contains unwanted noise which would go straigth onto the resample coeff. // It only used in the P component and the I component is used for the fine tuning anyways. + if (fabs(smooth_offset) < pclamp) smooth_offset = 0.0; + smooth_offset += (static_resample_factor - resample_mean) * this_catch_factor; + // Ok, now this is the PI controller. // u(t) = K * (e(t) + 1/T \int e(t') dt') // Kp = 1/catch_factor and T = catch_factor2 Ki = Kp/T current_resample_factor - = static_resample_factor - smooth_offset / catch_factor - offset_integral / catch_factor / catch_factor2; + = static_resample_factor - smooth_offset / this_catch_factor - offset_integral / this_catch_factor / this_catch_factor2; // Now quantize this value around resample_mean, so that the noise which is in the integral component doesnt hurt. current_resample_factor = floor((current_resample_factor - resample_mean) * controlquant + 0.5) / controlquant + resample_mean; // Calculate resample_mean so we can init ourselves to saner values. // resample_mean = 0.9999 * resample_mean + 0.0001 * current_resample_factor; - resample_mean = 0.9 * resample_mean + 0.1 * current_resample_factor; + resample_mean = (1.0-0.01) * resample_mean + 0.01 * current_resample_factor; + std::cerr << fill_level << " " << smooth_offset << " " << offset_integral << " " << current_resample_factor << " " << resample_mean << "\n"; return current_resample_factor; } @@ -105,4 +121,111 @@ PIController::out_of_bounds() for (i = 0; i < smooth_size; i++) { offset_array[i] = 0.0; } + fir_empty = false; +} + + +PIChaser::PIChaser() { + pic = new PIController( 1.0, 16 ); + array_index = 0; + for( int i=0; ireset(1.0); +} +PIChaser::~PIChaser() { + delete pic; +} + +double +PIChaser::get_ratio(framepos_t chasetime_measured, framepos_t chasetime, framepos_t slavetime_measured, framepos_t slavetime, bool in_control, int period_size ) { + + feed_estimator( chasetime_measured, chasetime ); + std::cerr << (double)chasetime_measured/48000.0 << " " << chasetime << " " << slavetime << " "; + double crude = get_estimate(); + double fine; + framepos_t massaged_chasetime = chasetime + (framepos_t)( (double)(slavetime_measured - chasetime_measured) * crude ); + + fine = pic->get_ratio (slavetime - massaged_chasetime, period_size); + if (in_control) { + if (fabs(fine-crude) > crude*speed_threshold) { + std::cout << "reset to " << crude << " fine = " << fine << "\n"; + pic->reset( crude ); + speed = crude; + } else { + speed = fine; + } + + if (abs(chasetime-slavetime) > pos_threshold) { + pic->reset( crude ); + speed = crude; + want_locate_val = chasetime; + std::cout << "we are off by " << chasetime-slavetime << " want_locate:" << chasetime << "\n"; + } else { + want_locate_val = 0; + } + } else { + std::cout << "not in control..." << crude << "\n"; + speed = crude; + pic->reset( crude ); + } + + return speed; +} + +void +PIChaser::feed_estimator (framepos_t realtime, framepos_t chasetime ) { + array_index += 1; + realtime_stamps [ array_index%ESTIMATOR_SIZE ] = realtime; + chasetime_stamps[ array_index%ESTIMATOR_SIZE ] = chasetime; +} + +double +PIChaser::get_estimate() { + double est = 0; + int num=0; + int i; + framepos_t n1_realtime; + framepos_t n1_chasetime; + for( i=(array_index + 1); i<=(array_index + ESTIMATOR_SIZE); i++ ) { + if( realtime_stamps[(i)%ESTIMATOR_SIZE] ) { + n1_realtime = realtime_stamps[(i)%ESTIMATOR_SIZE]; + n1_chasetime = chasetime_stamps[(i)%ESTIMATOR_SIZE]; + i+=1; + break; + } + } + + for( ; i<=(array_index + ESTIMATOR_SIZE); i++ ) { + if( realtime_stamps[(i)%ESTIMATOR_SIZE] ) { + if( (realtime_stamps[(i)%ESTIMATOR_SIZE] - n1_realtime) > 200 ) { + framepos_t n_realtime = realtime_stamps[(i)%ESTIMATOR_SIZE]; + framepos_t n_chasetime = chasetime_stamps[(i)%ESTIMATOR_SIZE]; + est += ((double)( n_chasetime - n1_chasetime )) + / ((double)( n_realtime - n1_realtime )); + n1_realtime = n_realtime; + n1_chasetime = n_chasetime; + num += 1; + } + } + } + + if(num) + return est/(double)num; + else + return 0.0; }