AudioDriftFixer Class Reference

#include <decklink_drift_fix.hpp>

Collaboration diagram for AudioDriftFixer:

Public Member Functions
void	enable ()
double	get_buffer_avg ()
	Get the average sample count per channel.
double	scale_buffer_delta (int delta)
	This function will check the buffer delta and will return a delta in the sample rate that is required in order to offset the delta. This is scaled between the class members of min_hz and max_hz. The delta also has a max and min for the scaling which are defined by the min_buffer and the max_buffer. This ensures that very large deltas cannot cause large jumps in the resample rate that are audible (and that small deltas) do not create a resampling rate that is too small to have impact on the buffer.
void	set_max_hz (uint32_t max_hz)
	Set the max hz object.
void	set_min_hz (uint32_t min_hz)
	Set the min hz object.
void	set_root (module *root)
	Set the root object.
void	set_target_buffer (uint32_t target_buffer)
	Set the target buffer object.
void	update (uint32_t buffered_count, uint32_t sample_frame_count, uint32_t sampleFramesWritten)

Private Attributes
DecklinkAudioSummary	audio_summary {}
MovingAverage	average_buffer_samples = 250
MovingAverage	average_delta = 25
long long	dst_frame_rate_set = 0
bool	m_enabled = false
struct module *	m_root = nullptr
uint32_t	max_avg = 3650
uint32_t	max_buffer = 600
uint32_t	max_hz = MAX_RESAMPLE_DELTA_DEFAULT
uint32_t	min_avg = 1800
uint32_t	min_buffer = 100
uint32_t	min_hz = MIN_RESAMPLE_DELTA_DEFAULT
uint32_t	neg_jitter = 5
uint32_t	pos_jitter = 5
uint32_t	previous_buffer = 0
uint32_t	target_buffer_fill = TARGET_BUFFER_DEFAULT

Static Private Attributes
static constexpr unsigned long	BASE = (1U<<8U)
static const uint32_t	NEG_JITTER_DEFAULT = 600
static const uint32_t	POS_JITTER_DEFAULT = 600

Detailed Description

Todo

• handle network losses
• handle underruns
• what about jitter - while computing the dst sample rate, the sampling interval (m_total) must be "long"

Definition at line 308 of file decklink_drift_fix.hpp.

Member Function Documentation

enable()

void AudioDriftFixer::enable ( )

inline

Definition at line 310 of file decklink_drift_fix.hpp.

                      {
                m_enabled = true;
                if (commandline_params.find("resampler") == commandline_params.end()) {
                        LOG(LOG_LEVEL_INFO) << MOD_NAME << "Using SoxR resampler by default when DecKlink audio drift fixer is enabled.\n";
                        commandline_params["resampler"] = "soxr";
                }
        }

References commandline_params, LOG, LOG_LEVEL_INFO, m_enabled, and MOD_NAME.

Referenced by settings_init().

get_buffer_avg()

double AudioDriftFixer::get_buffer_avg ( )

inline

Get the average sample count per channel.

Returns

double The average of the buffer over the last X frames

Definition at line 358 of file decklink_drift_fix.hpp.

                                {
                return this->average_buffer_samples.avg();
        }

References average_buffer_samples, and MovingAverage::avg().

Referenced by update().

Here is the call graph for this function:

scale_buffer_delta()

double AudioDriftFixer::scale_buffer_delta ( int delta )

inline

This function will check the buffer delta and will return a delta in the sample rate that is required in order to offset the delta. This is scaled between the class members of min_hz and max_hz. The delta also has a max and min for the scaling which are defined by the min_buffer and the max_buffer. This ensures that very large deltas cannot cause large jumps in the resample rate that are audible (and that small deltas) do not create a resampling rate that is too small to have impact on the buffer.

Parameters

delta

The delta between the average buffer size and the target buffer size to calculate a resample delta to offset the difference.

Returns

double A resample delta that can be added or subtracted from the original resample rate to move the average buffer size to the target buffer size.

Definition at line 375 of file decklink_drift_fix.hpp.

                                             {
                // Get a positive delta so that the scale can be calculated properly
                delta = abs(delta);
                // Check the boundaries for the scaling calculation
                if((uint32_t)delta > this->max_buffer) {
                        delta = this->max_buffer;
                }
                else if ((uint32_t)delta < this->min_buffer) {
                        delta = this->min_buffer;
                }
                return (((this->max_hz - this->min_hz) * (delta - this->min_buffer)) / (this->max_buffer - this->min_buffer)) + this->min_hz;
        }

References abs(), max_buffer, max_hz, min_buffer, and min_hz.

Referenced by update().

Here is the call graph for this function:

set_max_hz()

void AudioDriftFixer::set_max_hz ( uint32_t max_hz )

inline

Set the max hz object.

Parameters

max_hz

The maximum hz delta that can be applied to fix the drift

Definition at line 322 of file decklink_drift_fix.hpp.

                                         {
                this->max_hz = max_hz;
        }

References max_hz.

Referenced by settings_init().

set_min_hz()

void AudioDriftFixer::set_min_hz ( uint32_t min_hz )

inline

Set the min hz object.

Parameters

min_hz

The minimum hz delta that can be applied to fix the drift

Definition at line 331 of file decklink_drift_fix.hpp.

                                         {
                this->min_hz = min_hz;
        }

References min_hz.

Referenced by settings_init().

set_root()

void AudioDriftFixer::set_root ( module * root )

inline

Set the root object.

Parameters

root	The root module

Definition at line 349 of file decklink_drift_fix.hpp.

                                    {
                m_root = root;
        }

References m_root.

Referenced by display_decklink_init().

set_target_buffer()

void AudioDriftFixer::set_target_buffer ( uint32_t target_buffer )

inline

Set the target buffer object.

Parameters

target_buffer

The target buffer of samples per channel

Definition at line 340 of file decklink_drift_fix.hpp.

                                                       {
                this->target_buffer_fill = target_buffer;
        }

References target_buffer_fill.

Referenced by settings_init().

update()

void AudioDriftFixer::update ( uint32_t buffered_count, uint32_t sample_frame_count, uint32_t sampleFramesWritten )

inline

Return values

flag	if the audio frame should be written

Definition at line 389 of file decklink_drift_fix.hpp.

                                                                                                        {
                if (!this->m_enabled) {
                        return;
                }
 
                audio_summary.record_audio_time_diff();
                audio_summary.calculate_missing(buffered_count, sample_frame_count);
                if (buffered_count == 0) {
                        audio_summary.increment_buffer_underflow();
                }
 
                // Add the amount currently in the buffer to the moving average, and calculate the delta between that and the previous amount
                // Store the previous buffer count so we can calculate this next frame.
                this->average_buffer_samples.add((double)buffered_count);
                this->average_delta.add((double)abs((int32_t)buffered_count - (int32_t)previous_buffer));
                this->previous_buffer = buffered_count;
                
                long long dst_frame_rate = 0;
                // Calculate the average
                uint32_t average_buffer_depth = (uint32_t)(this->average_buffer_samples.avg());
 
                int resample_hz = dst_frame_rate = (bmdAudioSampleRate48kHz) * BASE;
 
                // Check to see if our buffered samples has enough to calculate a good average
                if (this->average_buffer_samples.filled()) {
                        // @todo might be worth trying to make this more dynamic so that certain input values
                        // for different cards can be applied
                        // Check to see if we have a target amount of the buffer we'd like to fill
                        if(this->pos_jitter == 0) {                           
                                this->pos_jitter = AudioDriftFixer::POS_JITTER_DEFAULT;
                        }
                        if(this->neg_jitter == 0) {
                                this->neg_jitter = AudioDriftFixer::NEG_JITTER_DEFAULT;
                        }
 
                        // Check whether there needs to be any resampling                        
                        if (average_buffer_depth  > target_buffer_fill + this->pos_jitter)
                        {
                                // The buffer is too large, so we need to resample down to remove some frames
                                resample_hz = (int)this->scale_buffer_delta(average_buffer_depth - target_buffer_fill - this->pos_jitter);
                                dst_frame_rate = (bmdAudioSampleRate48kHz - resample_hz) * BASE;
                                this->audio_summary.increment_resample_low();
                        } else if(average_buffer_depth < target_buffer_fill - this->neg_jitter) {
                                 // The buffer is too small, so we need to resample up to generate some additional frames
                                resample_hz = (int)this->scale_buffer_delta(target_buffer_fill - average_buffer_depth - this->neg_jitter);
                                dst_frame_rate = (bmdAudioSampleRate48kHz + resample_hz) * BASE;
                                this->audio_summary.increment_resample_high();
                        } else {
                                dst_frame_rate = (bmdAudioSampleRate48kHz) * BASE;
                        }       
                }
 
                LOG(LOG_LEVEL_DEBUG) << MOD_NAME << " UPDATE playing speed " <<  average_buffer_depth << " vs " << buffered_count << " " << average_delta.avg() << " average_velocity " << resample_hz << " resample_hz\n";
 
                if (dst_frame_rate != 0 &&
                    dst_frame_rate != dst_frame_rate_set) {
                        auto *m = new msg_universal((std::string(MSG_UNIVERSAL_TAG_AUDIO_DECODER) + std::to_string(dst_frame_rate << ADEC_CH_RATE_SHIFT | BASE)).c_str());
                        LOG(LOG_LEVEL_DEBUG)
                            << MOD_NAME "Sending resample request "
                            << dst_frame_rate << "/" << BASE << "\n";
                        assert(m_root != nullptr);
                        auto *response = send_message_sync(m_root, "audio.receiver.decoder", reinterpret_cast<message *>(m), 100, SEND_MESSAGE_FLAG_NO_STORE);
                        if (!RESPONSE_SUCCESSFUL(response_get_status(response))) {
                                LOG(LOG_LEVEL_WARNING) << MOD_NAME "Unable to send resample message: " << response_get_text(response) << " (" << response_get_status(response) << ")\n";
                        } else {
                                dst_frame_rate_set = dst_frame_rate;
                        }
                        free_response(response);
                }
 
 
                if (sampleFramesWritten != sample_frame_count) {
                        audio_summary.increment_buffer_overflow();
                }
                audio_summary.increment_audio_frames_played();
                audio_summary.set_buffer_average(get_buffer_avg());
                audio_summary.report();
                audio_summary.mark_audio_time_end();
        }

References abs(), MovingAverage::add(), ADEC_CH_RATE_SHIFT, audio_summary, average_buffer_samples, average_delta, MovingAverage::avg(), BASE, DecklinkAudioSummary::calculate_missing(), dst_frame_rate_set, MovingAverage::filled(), free_response(), get_buffer_avg(), DecklinkAudioSummary::increment_audio_frames_played(), DecklinkAudioSummary::increment_buffer_overflow(), DecklinkAudioSummary::increment_buffer_underflow(), DecklinkAudioSummary::increment_resample_high(), DecklinkAudioSummary::increment_resample_low(), LOG, LOG_LEVEL_DEBUG, LOG_LEVEL_WARNING, m_enabled, m_root, DecklinkAudioSummary::mark_audio_time_end(), MOD_NAME, MSG_UNIVERSAL_TAG_AUDIO_DECODER, neg_jitter, NEG_JITTER_DEFAULT, pos_jitter, POS_JITTER_DEFAULT, previous_buffer, DecklinkAudioSummary::record_audio_time_diff(), DecklinkAudioSummary::report(), response_get_status(), response_get_text(), RESPONSE_SUCCESSFUL, scale_buffer_delta(), SEND_MESSAGE_FLAG_NO_STORE, send_message_sync(), DecklinkAudioSummary::set_buffer_average(), and target_buffer_fill.

Referenced by display_decklink_put_audio_frame().

Here is the call graph for this function:

Member Data Documentation

audio_summary

DecklinkAudioSummary AudioDriftFixer::audio_summary {}

private

Definition at line 496 of file decklink_drift_fix.hpp.

{};

Referenced by update().

average_buffer_samples

MovingAverage AudioDriftFixer::average_buffer_samples = 250

private

Definition at line 475 of file decklink_drift_fix.hpp.

Referenced by get_buffer_avg(), and update().

average_delta

MovingAverage AudioDriftFixer::average_delta = 25

private

Definition at line 476 of file decklink_drift_fix.hpp.

Referenced by update().

BASE

unsigned long AudioDriftFixer::BASE = (1U<<8U)

staticconstexprprivate

Definition at line 472 of file decklink_drift_fix.hpp.

Referenced by update().

dst_frame_rate_set

long long AudioDriftFixer::dst_frame_rate_set = 0

private

Definition at line 501 of file decklink_drift_fix.hpp.

Referenced by update().

m_enabled

bool AudioDriftFixer::m_enabled = false

private

Definition at line 470 of file decklink_drift_fix.hpp.

Referenced by enable(), and update().

m_root

struct module* AudioDriftFixer::m_root = nullptr

private

Definition at line 473 of file decklink_drift_fix.hpp.

Referenced by set_root(), and update().

max_avg

uint32_t AudioDriftFixer::max_avg = 3650

private

Definition at line 492 of file decklink_drift_fix.hpp.

max_buffer

uint32_t AudioDriftFixer::max_buffer = 600

private

Definition at line 486 of file decklink_drift_fix.hpp.

Referenced by scale_buffer_delta().

max_hz

uint32_t AudioDriftFixer::max_hz = MAX_RESAMPLE_DELTA_DEFAULT

private

Definition at line 483 of file decklink_drift_fix.hpp.

Referenced by scale_buffer_delta(), and set_max_hz().

min_avg

uint32_t AudioDriftFixer::min_avg = 1800

private

Definition at line 493 of file decklink_drift_fix.hpp.

min_buffer

uint32_t AudioDriftFixer::min_buffer = 100

private

Definition at line 485 of file decklink_drift_fix.hpp.

Referenced by scale_buffer_delta().

min_hz

uint32_t AudioDriftFixer::min_hz = MIN_RESAMPLE_DELTA_DEFAULT

private

Definition at line 482 of file decklink_drift_fix.hpp.

Referenced by scale_buffer_delta(), and set_min_hz().

neg_jitter

uint32_t AudioDriftFixer::neg_jitter = 5

private

Definition at line 489 of file decklink_drift_fix.hpp.

Referenced by update().

NEG_JITTER_DEFAULT

const uint32_t AudioDriftFixer::NEG_JITTER_DEFAULT = 600

staticprivate

Definition at line 499 of file decklink_drift_fix.hpp.

Referenced by update().

pos_jitter

uint32_t AudioDriftFixer::pos_jitter = 5

private

Definition at line 488 of file decklink_drift_fix.hpp.

Referenced by update().

POS_JITTER_DEFAULT

const uint32_t AudioDriftFixer::POS_JITTER_DEFAULT = 600

staticprivate

Definition at line 498 of file decklink_drift_fix.hpp.

Referenced by update().

previous_buffer

uint32_t AudioDriftFixer::previous_buffer = 0

private

Definition at line 479 of file decklink_drift_fix.hpp.

Referenced by update().

target_buffer_fill

uint32_t AudioDriftFixer::target_buffer_fill = TARGET_BUFFER_DEFAULT

private

Definition at line 478 of file decklink_drift_fix.hpp.

Referenced by set_target_buffer(), and update().

---

The documentation for this class was generated from the following file:

• src/video_display/decklink_drift_fix.hpp