ctcsound module

result = ctcsound.csound_initialize(flags)

version = cs.version()
# Returns: 7000 for version 7.0.0

sample_rate = cs.sr()
# Returns: float (e.g., 44100.0)

control_rate = cs.kr()
# Returns: float (e.g., 4410.0)

vector_size = cs.ksmps()
# Returns: int (e.g., 64)

num_channels = cs.channels(is_input=False)

zero_db = cs.get_0dBFS()
# Returns: float (typically 1.0)

a4_freq = cs.A4()
# Returns: float (typically 440.0)

samples = cs.current_time_samples()
# Returns: int

size = cs.size_of_MYFLT()
# Returns: int (typically 8 for double)

result = cs.set_option("-odac")

params = ctcsound.CsoundParams()
cs.params(params)
print(params.sr_override)

cs.set_debug(True)

cs.set_message_level(0)  # No messages

result = cs.compile_("myfile.csd")
# Or with multiple arguments:
result = cs.compile_("csound", "-odac", "myfile.csd")

orc = '''
sr = 44100
ksmps = 64
instr 1
  out oscili(0.5, 440)
endin
'''
result = cs.compile_orc(orc, async_=False)

code = 'i1 = 2 + 2\nreturn i1'
result = cs.eval_code(code)
# Returns: 4.0

# From file:
cs.compile_csd("myfile.csd", mode=0, async_=False)

# From string:
csd_text = "<CsoundSynthesizer>...</CsoundSynthesizer>"
cs.compile_csd(csd_text, mode=1, async_=False)

result = cs.start()

while cs.perform_ksmps() == 0:
    # Process audio...
    pass

cs.reset()

result = cs.run_utility("sndinfo", ["soundfile.wav"])

import numpy as np

input_buffer = cs.spin()
# Shape: (ksmps * nchnls_i,)

output_buffer = cs.spout()
# Shape: (ksmps * nchnls,)

cs.set_host_audio_IO()

cs.set_RT_audio_module("portaudio")

cs.set_control_channel("frequency", 440.0)

value, err = cs.control_channel("frequency")
if err is None:
    print(f"Frequency: {value}")

import numpy as np

samples = np.zeros(cs.ksmps(), dtype=ctcsound.MYFLT)
cs.set_audio_channel("audioIn", samples)

samples = np.zeros(cs.ksmps(), dtype=ctcsound.MYFLT)
cs.audio_channel("audioOut", samples)

cs.set_string_channel("filename", "sample.wav")

filename = cs.string_channel("filename")

ptr, err = cs.channel_ptr("myChannel", 
    ctcsound.CSOUND_CONTROL_CHANNEL | ctcsound.CSOUND_INPUT_CHANNEL)

if err == "":
    # Use pointer...
    pass

channels, err = cs.list_channels()
if channels:
    for i in range(len(channels)):
        info = channels[i]
        print(f"{info.name}: {info.type}")
    cs.delete_channel_list(channels)

cs.lock_channel("myChannel")
# Access channel data...
cs.unlock_channel("myChannel")

import numpy as np

# Note event: i1 0 1 440
params = np.array([1, 0, 1, 440], dtype=ctcsound.MYFLT)
cs.event(ctcsound.CS_INSTR_EVENT, params, async_=False)

cs.event_string("i 1 0 1 440", async_=False)

# Multiple events:
cs.event_string("i 1 0 1 440\ni 1 1 1 550", async_=False)

num = cs.instr_number("MyInstrument")
# Returns: int or -1 if not found

table_data = cs.table(1)
if table_data is not None:
    print(f"Table 1 length: {len(table_data)}")

length = cs.table_length(1)
# Returns: -1 if table doesn't exist

args = cs.tableArgs(1)
if args is not None:
    print(f"GEN number: {args[0]}")

cs.message("Frequency: {}", 440.0)
# Or old-style:
cs.message("Frequency: %f", 440.0)

cs.create_message_buffer(to_stdout=True)

# Later, read messages:
while cs.message_cnt() > 0:
    msg = cs.first_message()
    attr = cs.first_message_attr()
    print(msg)
    cs.pop_first_message()

cs.destroy_message_buffer()

devices = cs.audio_dev_list(is_output=True)
for dev in devices:
    print(f"{dev['device_name']}: {dev['max_nchnls']} channels")

devices = cs.midi_dev_list(is_output=False)
for dev in devices:
    print(f"{dev['device_name']} ({dev['midi_module']})")

time = cs.score_time()

pending = cs.is_score_pending()

cs.set_score_pending(False)  # Mute score

cs.rewind_score()

pt.play()

pt.pause()

pt.toggle_pause()

pt.stop()

if pt.is_running():
    print("Still playing...")

status = pt.status()
# 0 = playing, positive = ended, negative = error

result = pt.join()
# Returns: positive if ended normally, negative on error

import numpy as np

pfields = np.array([1, 0, 1, 440], dtype=ctcsound.MYFLT)
pt.score_event(absp2mode=0, opcod='i', pFields=pfields)

pt.input_message("i 1 0 1 440")

pt.record("output.wav", samplebits=16, numbufs=4)

pt.stop_record()

c_str = ctcsound.cstring("hello")

py_str = ctcsound.pstring(c_str)

c_ch = ctcsound.cchar('i')