audiotestpattern.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <cstdint>
 
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/error.h>
#include <promeki/audiolevel.h>
#include <promeki/audiodesc.h>
#include <promeki/pcmaudiopayload.h>
#include <promeki/enumlist.h>
#include <promeki/enums.h>
#include <promeki/list.h>
#include <promeki/map.h>
#include <promeki/audiodataencoder.h>
#include <promeki/ltcencoder.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class AudioGen;
class Timecode;
 
class AudioTestPattern {
        public:
                using UPtr = UniquePtr<AudioTestPattern>;
 
                AudioTestPattern(const AudioDesc &desc);
 
                ~AudioTestPattern();
 
                AudioTestPattern(const AudioTestPattern &) = delete;
                AudioTestPattern &operator=(const AudioTestPattern &) = delete;
 
                const AudioDesc &desc() const { return _desc; }
 
                const EnumList &channelModes() const { return _channelModes; }
 
                void setChannelModes(const EnumList &modes) { _channelModes = modes; }
 
                double toneFrequency() const { return _toneFreq; }
 
                void setToneFrequency(double freq) { _toneFreq = freq; }
 
                AudioLevel toneLevel() const { return _toneLevel; }
 
                void setToneLevel(AudioLevel level) { _toneLevel = level; }
 
                AudioLevel ltcLevel() const { return _ltcLevel; }
 
                void setLtcLevel(AudioLevel level) { _ltcLevel = level; }
 
                double channelIdBaseFreq() const { return _chanIdBaseFreq; }
 
                void setChannelIdBaseFreq(double hz) { _chanIdBaseFreq = hz; }
 
                double channelIdStepFreq() const { return _chanIdStepFreq; }
 
                void setChannelIdStepFreq(double hz) { _chanIdStepFreq = hz; }
 
                double chirpStartFreq() const { return _chirpStartFreq; }
 
                void setChirpStartFreq(double hz) { _chirpStartFreq = hz; }
 
                double chirpEndFreq() const { return _chirpEndFreq; }
 
                void setChirpEndFreq(double hz) { _chirpEndFreq = hz; }
 
                double chirpDurationSec() const { return _chirpDurationSec; }
 
                void setChirpDurationSec(double sec) { _chirpDurationSec = sec; }
 
                double dualToneFreq1() const { return _dualToneFreq1; }
 
                void setDualToneFreq1(double hz) { _dualToneFreq1 = hz; }
 
                double dualToneFreq2() const { return _dualToneFreq2; }
 
                void setDualToneFreq2(double hz) { _dualToneFreq2 = hz; }
 
                double dualToneRatio() const { return _dualToneRatio; }
 
                void setDualToneRatio(double ratio) { _dualToneRatio = ratio; }
 
                double sweepStartFreq() const { return _sweepStartFreq; }
 
                void setSweepStartFreq(double hz) { _sweepStartFreq = hz; }
 
                double sweepEndFreq() const { return _sweepEndFreq; }
 
                void setSweepEndFreq(double hz) { _sweepEndFreq = hz; }
 
                double sweepDurationSec() const { return _sweepDurationSec; }
 
                void setSweepDurationSec(double sec) { _sweepDurationSec = sec; }
 
                double polarityPulseHz() const { return _polarityPulseHz; }
 
                void setPolarityPulseHz(double hz) { _polarityPulseHz = hz; }
 
                double polarityPulseWidthSec() const { return _polarityPulseWidthSec; }
 
                void setPolarityPulseWidthSec(double sec) { _polarityPulseWidthSec = sec; }
 
                const List<double> &steppedToneFreqs() const { return _steppedToneFreqs; }
 
                void setSteppedToneFreqs(const List<double> &freqs) { _steppedToneFreqs = freqs; }
 
                double steppedToneStepSec() const { return _steppedToneStepSec; }
 
                void setSteppedToneStepSec(double sec) { _steppedToneStepSec = sec; }
 
                AudioLevel dialnormLevel() const { return _dialnormLevel; }
 
                void setDialnormLevel(AudioLevel level) { _dialnormLevel = level; }
 
                double noiseBufferSeconds() const { return _noiseBufferSeconds; }
 
                void setNoiseBufferSeconds(double sec) { _noiseBufferSeconds = sec; }
 
                uint32_t noiseSeed() const { return _noiseSeed; }
 
                void setNoiseSeed(uint32_t seed) { _noiseSeed = seed; }
 
                Error configure();
 
                SharedPtr<PcmAudioPayload, true, PcmAudioPayload> createPayload(size_t          samples,
                                                                                const Timecode &tc) const;
 
                SharedPtr<PcmAudioPayload, true, PcmAudioPayload> createPayload(size_t samples) const {
                        return createPayload(samples, Timecode());
                }
 
                uint8_t pcmMarkerStreamId() const { return _pcmMarkerStreamId; }
 
                void setPcmMarkerStreamId(uint8_t streamId) { _pcmMarkerStreamId = streamId; }
 
                uint64_t pcmMarkerFrameNumber() const { return _pcmMarkerCounter; }
 
                void setPcmMarkerFrameNumber(uint64_t fn) { _pcmMarkerCounter = fn; }
 
                static double channelIdFrequency(size_t channelIndex, double baseFreq, double stepFreq) {
                        return baseFreq + static_cast<double>(channelIndex) * stepFreq;
                }
 
                static constexpr double kSrcProbeFrequencyHz = 997.0;
 
                static constexpr uint8_t kDefaultPcmMarkerStreamId = 0;
 
                static constexpr uint64_t kPcmMarkerFrameMask = 0x0000ffffffffffffULL;
 
                static const List<double> kDefaultSteppedToneFreqs;
 
                static constexpr double kEbuLineupFreqHz = 1000.0;
 
                static constexpr double kEbuLineupOnSec = 3.0;
 
                static constexpr double kEbuLineupCycleSec = 5.0;
 
                static constexpr double kBlitsFreqHz = 1000.0;
 
                static constexpr double kBlitsSegmentSec = 1.0;
 
                static constexpr size_t kIec60958StatusBits = 192;
 
                static constexpr size_t kIec60958SamplesPerBit = 4;
 
        private:
                AudioDesc  _desc;
                EnumList   _channelModes;
                double     _toneFreq = 1000.0;
                AudioLevel _toneLevel = AudioLevel::fromDbfs(-20.0);
                AudioLevel _ltcLevel = AudioLevel::fromDbfs(-20.0);
                double     _chanIdBaseFreq = 1000.0;
                double     _chanIdStepFreq = 100.0;
 
                double _chirpStartFreq = 20.0;
                double _chirpEndFreq = 20000.0;
                double _chirpDurationSec = 1.0;
 
                double _dualToneFreq1 = 60.0;
                double _dualToneFreq2 = 7000.0;
                double _dualToneRatio = 0.25;
 
                double _sweepStartFreq = 20.0;
                double _sweepEndFreq = 20000.0;
                double _sweepDurationSec = 1.0;
 
                double _polarityPulseHz = 1.0;
                double _polarityPulseWidthSec = 0.001;
 
                List<double> _steppedToneFreqs;
                double       _steppedToneStepSec = 1.0;
 
                AudioLevel _dialnormLevel = AudioLevel::fromDbfs(-24.0);
 
                double   _noiseBufferSeconds = 10.0;
                uint32_t _noiseSeed = 0x505244A4u; // 'PRDA' — TPG test seed
 
                // Per-channel generators built in configure().  A nullptr
                // entry means the channel is silenced (either because
                // the mode list is shorter than the channel count, or
                // because it carries a mode that does not need a
                // persistent generator — e.g. LTC / AvSync / noise /
                // chirp / PCM marker, which are synthesized per-call).
                mutable List<AudioGen *> _chanGens;
                LtcEncoder::UPtr         _ltcEncoder;
 
                // AvSync tone burst cache: built lazily per requested
                // sample count so the cadenced rates (29.97, 59.94)
                // which alternate between two sizes don't thrash the
                // cache.  Each entry is a one-shot mono tone burst
                // (phase reset to zero so every marker frame is
                // byte-identical).
                mutable Map<size_t, List<float>> _avSyncToneCache;
 
                // Cached noise buffers.  One-dimensional arrays of
                // samples that the per-channel noise dispatch indexes
                // with a per-channel offset so different WhiteNoise /
                // PinkNoise channels stay decorrelated while sharing
                // the same underlying samples.  Generated at most once
                // per configure() call; empty until a noise channel
                // requests them.
                List<float> _whiteNoiseBuffer;
                List<float> _pinkNoiseBuffer;
 
                // Continuous-sweep cursor/phase for the Chirp
                // generator.  The cursor is the sample position inside
                // the current sweep period (wraps at
                // _chirpDurationSec * sampleRate).  The phase is the
                // running sin-argument; we accumulate it sample-by-
                // sample instead of recomputing it from the closed-
                // form integral so the waveform stays sample-exact
                // continuous across both chunk boundaries and period
                // wraps (the closed form resets to 0 at each period
                // wrap, which causes an audible click).
                mutable double _chirpSampleCursor = 0.0;
                mutable double _chirpPhase = 0.0;
 
                // Per-tone phase accumulators for the DualTone
                // generator.  Tracking these across create() calls is
                // the only way to avoid a once-per-chunk phase-reset
                // click; a 30 fps pipeline restarts the pattern 30
                // times a second otherwise, which is plainly audible.
                mutable double _dualTonePhase1 = 0.0;
                mutable double _dualTonePhase2 = 0.0;
 
                // Cumulative sample cursor for the cached noise
                // buffers.  Advanced once per create() call so
                // successive frames read from successive regions of
                // the buffer instead of re-reading the same slice —
                // otherwise the noise would modulate at the frame
                // rate and sound like a tone, not noise.  All noise
                // channels share this cursor, with a per-channel
                // offset layered on top so multiple noise channels
                // on the same stream stay decorrelated.
                mutable size_t _noiseSampleCursor = 0;
 
                // Stream ID stamped on every PcmMarker payload (top 8
                // bits of the encoded word).  Defaults to 0; the wrapper
                // (e.g. TpgMediaIO) overrides via setPcmMarkerStreamId.
                uint8_t _pcmMarkerStreamId = kDefaultPcmMarkerStreamId;
 
                // Running monotonic counter used as the 48-bit frame
                // number field of the PcmMarker payload.  Auto-
                // incremented on every create() call; an external
                // wrapper may overwrite via setPcmMarkerFrameNumber to
                // lock the audio marker to a video frame counter.
                mutable uint64_t _pcmMarkerCounter = 0;
 
                mutable double _sweepSampleCursor = 0.0;
                mutable double _sweepPhase = 0.0;
 
                mutable double _polarityCursor = 0.0;
 
                mutable double _steppedToneSampleCursor = 0.0;
                mutable double _steppedTonePhase = 0.0;
 
                mutable size_t _blitsSampleCursor = 0;
                mutable double _blitsPhase = 0.0;
 
                mutable size_t _ebuLineupSampleCursor = 0;
                mutable double _ebuLineupPhase = 0.0;
 
                mutable size_t _iec60958SampleCursor = 0;
 
                void               clearGenerators();
                AudioPattern       modeForChannel(size_t channelIndex) const;
                const List<float> &avSyncBurst(size_t samples) const;
 
                // Shared inner loop: writes @p samples samples per
                // channel of the configured pattern into @p out,
                // advancing all phase and cursor state.  Used by both
                // @ref create (Audio allocation) and @ref createPayload
                // (PcmAudioPayload allocation).
                void writePattern(float *out, size_t samples, const Timecode &tc) const;
                void buildWhiteNoiseBuffer();
                void buildPinkNoiseBuffer();
 
                void writeNoiseChannel(float *out, size_t channel, size_t channels, size_t samples,
                                       const List<float> &buffer) const;
                void writeChirpChannel(float *out, size_t channel, size_t channels, size_t samples) const;
                void writeDualToneChannel(float *out, size_t channel, size_t channels, size_t samples) const;
                void stampPcmMarkers(PcmAudioPayload &payload, uint64_t frameNumber) const;
                void writeSweepChannel(float *out, size_t channel, size_t channels, size_t samples) const;
                void writePolarityChannel(float *out, size_t channel, size_t channels, size_t samples) const;
                void writeSteppedToneChannel(float *out, size_t channel, size_t channels, size_t samples) const;
                void writeBlitsChannel(float *out, size_t channel, size_t channels, size_t totalChannels,
                                       size_t samples) const;
                void writeEbuLineupChannel(float *out, size_t channel, size_t channels, size_t samples) const;
                void writeDialnormChannel(float *out, size_t channel, size_t channels, size_t samples) const;
                void writeIec60958Channel(float *out, size_t channel, size_t channels, size_t samples) const;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV