SuperCollider में मॉड्यूलेशन पोज़िशन को रोककर अगले ट्रिगर पर उल्टी दिशा में फिर से कैसे चलाएँ

मॉड्यूलेशन को दो जुड़ी हुई क्रियाओं के रूप में देखें: एक पोज़िशन किसी चक्र में आगे बढ़ती है, और एक मैपिंग उस पोज़िशन को किसी उपयोगी पैरामीटर मान में बदलती है। यहाँ पोज़िशन शून्य से एक की ओर बढ़ती है, और मैपिंग उसे ऑसिलेटर फ़्रीक्वेंसी में बदलती है।

SuperCollider का Phasor पोज़िशन देता है। उसका rate आर्ग्युमेंट हर सैंपल का इन्क्रीमेंट तय करता है; इसके बजाय उसका ट्रिगर इनपुट पोज़िशन को resetPos पर पहुँचा देता है। ये अलग-अलग नियंत्रण हैं, इसलिए दिशा बदलने के लिए इस्तेमाल होने वाले ट्रिगर को पोज़िशन रीसेट नहीं करनी चाहिए। Phasor दस्तावेज़

यह कार्यान्वयन एक आंतरिक स्तर को बनाए रखता है और उसमें रेट जोड़ता है। इस व्यवहार के अनुसार, शून्य रेट स्तर को स्थिर रखती है, जबकि ऋणात्मक रेट उसे नीचे ले जाती है। नीचे दिया गया पैच इसे सीधे लागू करता है और विराम के दौरान जनरेटर की स्थिति बनाए रखता है। SuperCollider 3.14.0 TriggerUGens.cpp कार्यान्वयन

ध्वनि जोड़ने से पहले इवेंट क्रम तय करें। इस पैच में गति तुरंत आगे की दिशा में शुरू होती है। उसके बाद आने वाला हर ट्रिगर एक अवस्था आगे बढ़ाता है:

प्राप्त ट्रिगर	अवस्था	दिशा गुणक
0	आगे बढ़ें	+1
1	मौजूदा पोज़िशन पर रुकें	0
2	पीछे की ओर फिर शुरू करें	−1
3	मौजूदा पोज़िशन पर रुकें	0
4	आगे की ओर फिर शुरू करें	+1

यह चार-अवस्थाओं वाला चक्र दोनों रुकी हुई अवस्थाओं को अलग रखता है: एक के बाद पीछे की गति शुरू होती है, और दूसरी के बाद आगे की गति। इससे दिशा बदलने के लिए किसी अतिरिक्त बटन की ज़रूरत के बिना जेस्चर बार-बार पूर्वानुमेय रूप से दोहराया जा सकता है।

PulseCount तब गिनती बढ़ाता है जब उसका इनपुट गैर-धनात्मक से धनात्मक होता है। गिनती का चार से मॉड्यूलो लेने पर 0–3 के दोहराए जाने वाले इंडेक्स मिलते हैं। फिर Select [1, 0, -1, 0] से संबंधित गुणक चुनता है। PulseCount और Select की दस्तावेज़ित भूमिकाएँ यही हैं।

काम करने वाले ऑडियो आउटपुट के साथ स्थानीय SuperCollider इंस्टॉलेशन इस्तेमाल करें; यह उदाहरण 3.14.0 के दस्तावेज़ों पर आधारित है। इसमें अंतर्निहित यूनिट जनरेटर इस्तेमाल होते हैं और ध्वनि खुद बनाई जाती है, इसलिए सैंपल फ़ाइलों या एक्सटेंशन की ज़रूरत नहीं है। पूरा ब्लॉक एक बार चलाएँ और तैयार होने का संदेश आने तक प्रतीक्षा करें।

waitForBoot ज़रूरत पड़ने पर सर्वर शुरू करता है। सिंथ बनाने से पहले उसकी परिभाषा भेजी जाती है, और s.sync सर्वर के बाकी कार्य पूरे होने तक प्रतीक्षा करता है। Server दस्तावेज़ और SynthDef दस्तावेज़ देखें।

(
s = Server.default;
s.waitForBoot({
    SynthDef(\pauseReverseMod, {
        |out = 0, t_step = 0, cycleSeconds = 8, amp = 0.08|
        var state, direction, increment, phase, frequency, sound;

        state = PulseCount.kr(t_step) % 4;
        direction = Select.kr(state, [1, 0, -1, 0]);

        // A full 0..1 traversal takes cycleSeconds seconds.
        increment = direction * SampleDur.ir
            / cycleSeconds.max(0.01);

        // State-changing triggers never reset this phase.
        phase = Phasor.ar(
            trig: 0,
            rate: increment,
            start: 0,
            end: 1,
            resetPos: 0
        );

        frequency = LinExp.ar(phase, 0, 1, 220, 880);
        sound = SinOsc.ar(frequency, 0, amp);
        Out.ar(out, sound ! 2);

        Poll.kr(Impulse.kr(2), state, "state");
        Poll.kr(Impulse.kr(2), A2K.kr(phase), "phase");
    }).add;

    s.sync;
    ~pauseReverseSynth = Synth(\pauseReverseMod);
    "Ready: evaluate ~pauseReverseSynth.set(\\t_step, 1);".postln;
});
)

इन्क्रीमेंट, दिशा को सैंपल अवधि से गुणा करके और चक्र अवधि से भाग देकर मिलता है। SampleDur सर्वर की सैंपल रेट का व्युत्क्रम देता है, इसलिए आठ सेकंड की सेटिंग किसी खास सैंपल रेट को नहीं मानती। SampleDur दस्तावेज़

पिच मैपिंग 220–880 Hz तक जाती है। LinExp लीनियर इनपुट रेंज को एक्सपोनेंशियल आउटपुट रेंज में बदलता है; उसके गंतव्य के दोनों सिरों के मान शून्येतर होने चाहिए और उनका चिह्न एक जैसा होना चाहिए। यहाँ दोनों सिरे यह शर्त पूरी करते हैं। LinExp दस्तावेज़

मैंने प्राप्त दस्तावेज़ों के आधार पर SuperCollider उदाहरण की जाँच की। शोध परिवेश में SuperCollider रनटाइम उपलब्ध नहीं था, इसलिए मैंने इस पैच को चलाया या सुनकर जाँचा नहीं। एक अलग नियतात्मक अंकगणितीय जाँच ने दिशा क्रम और शून्य-इन्क्रीमेंट से रुकने वाले व्यवहार की पुष्टि की।

तैयार होने का संदेश आने के बाद पिच को लगभग दो सेकंड तक ऊपर जाने दें। फिर यह इंटरैक्शन कमांड एक बार चलाएँ:

~pauseReverseSynth.set(\t_step, 1);

अवस्था 1 होनी चाहिए, और प्रिंट होने वाला फ़ेज़ एक ही मान पर स्थिर हो जाना चाहिए। थोड़ी देर रुकें, फिर वही कमांड दोबारा चलाएँ। अवस्था 2 होनी चाहिए, और फ़ेज़ रुकी हुई पोज़िशन से नीचे घटनी चाहिए। तीसरी बार चलाने पर नीचे जाता स्वीप रुकता है; चौथी बार चलाने पर वह फिर आगे बढ़ता है।

t_ प्रीफ़िक्स t_step को ट्रिगर नियंत्रण बनाता है। इसे सेट करने पर कंट्रोल-रेट इम्पल्स बनता है, जिससे सामान्य अंतराल पर कमांड दोहराते समय हर बार अलग से शून्य भेजने की ज़रूरत नहीं होती। SynthDef ट्रिगर-नियंत्रण दस्तावेज़

समझाने के लिए एक गणना: आठ सेकंड का चक्र प्रति सेकंड अपनी रेंज का 0.125 आगे बढ़ता है। इसलिए दो सेकंड बाद रोकने पर यह लगभग 0.25 पर रुकेगा। किसी भी विराम के बाद, एक सेकंड पीछे जाने पर यह लगभग 0.125 पर पहुँच जाएगा। ये गणना से निकले अपेक्षित मान हैं; कमांड चलाने का वास्तविक समय रुकने की असली पोज़िशन तय करता है।

समाप्त करने के लिए, क्लीनअप कमांड चलाएँ:

~pauseReverseSynth.free;

मुख्य जाँच के लिए प्रिंट होने वाले फ़ेज़ का उपयोग करें। आगे की गति में इसे बढ़ना चाहिए; रुकी हुई दोनों अवस्थाओं में स्थिर रहना चाहिए; और पीछे की गति में चक्र की सीमा तक घटते जाना चाहिए।

पैच प्रति सेकंड दो बार प्रिंट करता है, इसलिए डिस्प्ले हर सैंपल दिखाने के बजाय व्यवहार के नमूने दिखाता है। विराम के दौरान लगातार कई रीडिंग देखें, फिर दोबारा शुरू करने के बाद पीछे जाने वाली पहली रीडिंग की तुलना करें। Poll यूनिट जनरेटर के मानों की डीबगिंग के लिए है; सामान्य इस्तेमाल के लिए परिभाषा में बदलाव करते समय पोलिंग की दोनों पंक्तियाँ हटा दें। Poll दस्तावेज़

यह जाँच केवल सुनने से ज़्यादा जानकारी देती है। स्थिर ध्वनि से पता चलता है कि गंतव्य बदलना रुक गया, जबकि स्थिर फ़ेज़ रीडिंग पुष्टि करती है कि मूल पोज़िशन भी रुक गई। जाँच के दौरान मैपिंग स्थिर रखने से नतीजे को समझना आसान होता है।

फिर शुरू करते समय यह रीसेट हो जाता है। जाँचें कि इवेंट Phasor के ट्रिगर इनपुट तक तो नहीं पहुँच रहा। वह इनपुट पोज़िशन को स्पष्ट रूप से रीसेट करता है। इस पैच में वह शून्य पर रहता है, जबकि इवेंट केवल स्टेट काउंटर तक पहुँचते हैं। Phasor दस्तावेज़

एक छोर पर पहुँचने के बाद यह छलाँग लगाता है। यह उदाहरण जानबूझकर लूप होता है। कार्यान्वयन चरण को उसकी तय रेंज में लपेटता है, जिसमें उल्टी दिशा की गति भी शामिल है। जब पीछे की गति शून्य से आगे निकलती है, तो फ़ेज़ ऊपरी सीमा के पास लौट आता है और इस रैम्प मैपिंग से पिच में छलाँग आती है। विराम और दिशा बदलने की जाँच पहले उस सीमा से दूर करें। Phasor कार्यान्वयन

कई तेज़ कमांड से कई अवस्थाएँ नहीं बनतीं। काउंटर को अलग-अलग बढ़ते ट्रांज़िशन चाहिए। ट्रिगर नियंत्रण कंट्रोल रेट पर काम करते हैं, इसलिए यह न मानें कि एक कंट्रोल ब्लॉक के भीतर आने वाली कई कमांड अलग-अलग इवेंट बनेंगी। पहले जानबूझकर अंतराल देकर कमांड चलाएँ; सटीक समय वाले क्रम के लिए इवेंट स्रोत को अलग-अलग पल्स देने के हिसाब से बनाएँ। PulseCount दस्तावेज़, SynthDef दस्तावेज़

फ़ेज़ रुकी होने पर भी ध्वनि बदलती है। जाँचें कि आप गंतव्य मैपिंग या कोई दूसरा ध्वनि पैरामीटर भी तो नहीं बदल रहे। इस जाँच के लिए पिच के दोनों सिरों के मान स्थिर रखें और मॉड्यूलेशन की गति को अलग से देखने के लिए प्रिंट होने वाले फ़ेज़ का उपयोग करें।

पूरा जेस्चर है: आगे, रुकना, पीछे, रुकना, फिर आगे। जब यह क्रम सही तरह काम करे, तो स्टेट काउंटर और फ़ेज़ जनरेटर को दोबारा इस्तेमाल किए जा सकने वाले मॉड्यूलेशन स्रोत के रूप में रखें और अपनी ध्वनि के अनुसार गंतव्य मैपिंग बदलें।

• Phasor — SuperCollider 3.14.0 सहायता
• TriggerUGens.cpp — SuperCollider, Version-3.14.0
• PulseCount — SuperCollider 3.14.0 सहायता
• Select — SuperCollider 3.14.0 सहायता
• Server — SuperCollider 3.14.0 सहायता
• SynthDef — SuperCollider 3.14.0 सहायता
• SampleDur — SuperCollider 3.14.0 सहायता
• LinExp — SuperCollider 3.14.0 सहायता
• Poll — SuperCollider 3.14.0 सहायता