Record sound

Record sound
You are encouraged to solve this task according to the task description, using any language you may know.

Record a monophonic 16-bit PCM sound into either memory space, a file or array.

(This task neglects to specify the sample rate, and whether to use signed samples. The programs in this page might use signed 16-bit or unsigned 16-bit samples, at 8000 Hz, 44100 Hz, or any other sample rate. Therefore, these programs might not record sound in the same format.)

AutoHotkey

name := "sample"
waitsec := 5
Tooltip Recording %name%.wav
MCI_SendString("close all wait")
MCI_SendString("open new type waveaudio alias " . name)
MCI_SendString("set " . name . " time format ms wait")
;MCI_SendString("set " . name . " bitspersample 16 wait")
;MCI_SendString("set " . name . " channels 1 wait")
;MCI_SendString("set " . name . " samplespersec 16000 wait")
;MCI_SendString("set " . name . " alignment 1 wait")
;MCI_SendString("set " . name . " bytespersec 8000 wait")
MCI_SendString("record " . name)
Sleep waitsec*1000
MCI_SendString("stop " . name . " wait")
MCI_SendString("save " . name . " """ . name . ".wav""")
Tooltip Finished ... Playing
MCI_SendString("delete " . name)
MCI_SendString("close " . name . " wait")
MCI_SendString("open """ . name . ".wav"" type waveaudio alias " . name)
MCI_SendString("play " . name . " wait")
MCI_SendString("close " . name . " wait")
Tooltip
Return

MCI_SendString(p_lpszCommand,ByRef r_lpszReturnString="",p_hwndCallback=0) {
	VarSetCapacity(r_lpszReturnString,512,0)
	Return DllCall("winmm.dll\mciSendString" . (A_IsUnicode ? "W":"A")
		,"Str",p_lpszCommand						;-- lpszCommand
		,"Str",r_lpszReturnString					;-- lpszReturnString
		,"UInt",512									;-- cchReturn
		,A_PtrSize ? "Ptr":"UInt",p_hwndCallback	;-- hwndCallback
		,"Cdecl Int")								;-- Return type
}
; For more intuitive functions, see the MCI library by jballi.
; doc: http://www.autohotkey.net/~jballi/MCI/v1.1/MCI.html
; download: http://www.autohotkey.net/~jballi/MCI/v1.1/MCI.ahk

BBC BASIC

Works with: BBC BASIC for Windows

      wavfile$ = @dir$ + "capture.wav"
      bitspersample% = 16
      channels% = 2
      samplespersec% = 44100
 
      alignment% = bitspersample% * channels% / 8
      bytespersec% = alignment% * samplespersec%
 
      params$ = " bitspersample " + STR$(bitspersample%) + \
      \         " channels " + STR$(channels%) + \
      \         " alignment " + STR$(alignment%) + \
      \         " samplespersec " + STR$(samplespersec%) + \
      \         " bytespersec " + STR$(bytespersec%)
 
      SYS "mciSendString", "close all", 0, 0, 0
      SYS "mciSendString", "open new type waveaudio alias capture", 0, 0, 0
      SYS "mciSendString", "set capture" + params$, 0, 0, 0 TO res%
      IF res% ERROR 100, "Couldn't set capture parameters: " + STR$(res% AND &FFFF)
 
      PRINT "Press SPACE to start recording..."
      REPEAT UNTIL INKEY(1) = 32
 
      SYS "mciSendString", "record capture", 0, 0, 0 TO res%
      IF res% ERROR 100, "Couldn't start audio capture: " + STR$(res% AND &FFFF)
 
      PRINT "Recording, press SPACE to stop..."
      REPEAT UNTIL INKEY(1) = 32
 
      SYS "mciSendString", "stop capture", 0, 0, 0
      SYS "mciSendString", "save capture " + wavfile$, 0, 0, 0 TO res%
      IF res% ERROR 100, "Couldn't save to WAV file: " + STR$(res% AND &FFFF)
 
      SYS "mciSendString", "delete capture", 0, 0, 0
      SYS "mciSendString", "close capture", 0, 0, 0
 
      PRINT "Captured audio is stored in " wavfile$

C

Read/write raw device /dev/dsp. On Linux you need access to said device, meaning probably you should be in audio user group.

#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>

void * record(size_t bytes)
{
	int fd;
	if (-1 == (fd = open("/dev/dsp", O_RDONLY))) return 0;
	void *a = malloc(bytes);
	read(fd, a, bytes);
	close(fd);
	return a;
}

int play(void *buf, size_t len)
{
	int fd;
	if (-1 == (fd = open("/dev/dsp", O_WRONLY))) return 0;
	write(fd, buf, len);
	close(fd);
	return 1;
}

int main()
{
	void *p = record(65536);
	play(p, 65536);
	return 0;
}

C++

Uses Windows MCI

#include <iostream>
#include <string>
#include <windows.h>
#include <mmsystem.h>

#pragma comment ( lib, "winmm.lib" )
using namespace std;

class recorder
{
public:
    void start()
    {
	paused = rec = false; action = "IDLE";
	while( true )
	{
	    cout << endl << "==" << action << "==" << endl << endl;
	    cout << "1) Record" << endl << "2) Play" << endl << "3) Pause" << endl << "4) Stop" << endl << "5) Quit" << endl;
	    char c; cin >> c;
	    if( c > '0' && c < '6' )
	    {
		switch( c )
		{
		    case '1': record(); break;
		    case '2': play();   break;
		    case '3': pause();  break;
		    case '4': stop();   break;
		    case '5': stop();   return;
		}
	    }
	}
    }
private:
    void record()
    {
	if( mciExecute( "open new type waveaudio alias my_sound") )
	{ 
	    mciExecute( "record my_sound" ); 
	    action = "RECORDING"; rec = true; 
	}
    }
    void play()
    {
	if( paused )
	    mciExecute( "play my_sound" );
	else
	    if( mciExecute( "open tmp.wav alias my_sound" ) )
		mciExecute( "play my_sound" );

	action = "PLAYING";
	paused = false;
    }
    void pause()
    {
	if( rec ) return;
	mciExecute( "pause my_sound" );
	paused = true; action = "PAUSED";
    }
    void stop()
    {
	if( rec )
	{
	    mciExecute( "stop my_sound" );
	    mciExecute( "save my_sound tmp.wav" );
	    mciExecute( "close my_sound" );
	    action = "IDLE"; rec = false;
	}
	else
	{
	    mciExecute( "stop my_sound" );
	    mciExecute( "close my_sound" );
	    action = "IDLE";
	}
    }
    bool mciExecute( string cmd )
    {
	if( mciSendString( cmd.c_str(), NULL, 0, NULL ) )
	{
	    cout << "Can't do this: " << cmd << endl;
	    return false;
	}
	return true;
    }

    bool paused, rec;
    string action;
};

int main( int argc, char* argv[] )
{
    recorder r; r.start();
    return 0;
}

ChucK

// chuck this with other shreds to record to file
// example> chuck foo.ck bar.ck rec 

// arguments: rec:<filename>

// get name
me.arg(0) => string filename;
if( filename.length() == 0 ) "foo.wav" => filename;

// pull samples from the dac
dac => Gain g => WvOut w => blackhole;
// this is the output file name
filename => w.wavFilename;
<<<"writing to file:", "'" + w.filename() + "'">>>;
// any gain you want for the output
.5 => g.gain;

// temporary workaround to automatically close file on remove-shred
null @=> w;

// infinite time loop...
// ctrl-c will stop it, or modify to desired duration
while( true ) 1::second => now;

Common Lisp

Translation of: C

(defun record (n)
  (with-open-file (in "/dev/dsp" :element-type '(unsigned-byte 8))
    (loop repeat n collect (read-byte in))
    )
  )
(defun play (byte-list)
  (with-open-file (out "/dev/dsp" :direction :output :element-type '(unsigned-byte 8) :if-exists :append)
    (mapcar (lambda (b) (write-byte b out)) byte-list)
    )
  )
(play (record 65536))

Diego

This function returns a {wav} variable recorded from a thing in the mist. It understands that the found thing has a microphone, so will have microphone knowledge. If the caller does not have microphone knowledge, the callee will train the caller on first request.

begin_funct({wav}, Record sound);
    set_decision(linger);
    find_thing()_first()_microphone()_bitrate(16)_tech(PCM)_samplerate(signed16, unsigned16)_rangefrom(8000, Hz)_rangeto(44100, Hz)_export(.wav)
        ? with_found()_microphone()_label(mic);
        : err_funct[]_err(Sorry, no one has a microphone!);
          exit_funct[];
    ;
    with_microphone[mic]_record()_durat({secs}, 30)_var(recording);
    [Record sound]_ret([recording]);
    reset_decision();
end_funct[];

// Record a monophonic 16-bit PCM sound into memory space:
exec_funct(Record sound)_var(PCMRecording)_me();         // The variable 'PCMRecording' is the sound in memory space

// Record a monophonic 16-bit PCM sound into a file or array:
exec_funct(Record sound)_file(foo.wav)_me();         // The file 'foo.wav' is the sound in a file

This is the instruction version, where the thing keeps the recording.

begin_instruct(Record sound);
    set_decision(linger);
    find_thing()_first()_microphone()_bitrate(16)_tech(PCM)_samplerate(signed16, unsigned16)_rangefrom(8000, Hz)_rangeto(44100, Hz)_export(.wav)
        ? with_found()_label(recorder)_microphone()_label(mic);
        : err_instruct[]_err(Sorry, no one has a microphone!);
          exit_instruct[];
    ;
    with_microphone[mic]_record()_durat({secs}, 30)_var(recording);
    reset_decision();
end_instruct[];

// Record a monophonic 16-bit PCM sound into memory space:
exec_instruct(Record sound)_me();
with_thing[recorder]_microphone[mic]_var[recording]_var(PCMRecording);  // The variable 'PCMRecording' is the sound in memory space

// Record a monophonic 16-bit PCM sound into a file or array:
exec_instruct(Record sound)_me();
with_thing[recorder]_microphone[mic]_var[recording]_file(foo.wav)_me();         // The file 'foo.wav' is the sound in a file

FreeBASIC

#define PI 4 * Atn(1)

' Constants for the audio format
Dim Shared As Integer SAMPLE_RATE = 44100
Dim Shared As Integer BITS_PER_SAMPLE = 16
Dim Shared As Integer NUM_CHANNELS = 1

' Generates a sine wave
Sub generateSineWave(buffer() As Short, frequency As Double)
    Dim As Double increment = 2.0 * PI * frequency / SAMPLE_RATE
    Dim As Double x = 0.0
    For i As Integer = 0 To Ubound(buffer)
        buffer(i) = (Sin(x) * 32767.0)
        x += increment
    Next i
End Sub

' Write the header of the .wav file
Sub writeWaveHeader(file As Integer, numSamples As Integer)
    ' Write the RIFF header
    Print #file, "RIFF";
    Put #file, , numSamples * 2 + 36  ' File size
    Print #file, "WAVE";
    
    Dim As Integer SB = 16, FA = 1
    ' Write the fmt sub-block
    Print #file, "fmt ";
    Put #file, , SB                 ' Size of the fmt sub-block
    Put #file, , FA                 ' Audio format (1 = PCM)
    Put #file, , NUM_CHANNELS       ' Number of channels
    Put #file, , SAMPLE_RATE        ' Sample rate
    Put #file, , SAMPLE_RATE * NUM_CHANNELS * BITS_PER_SAMPLE / 8   ' Byte rate
    Put #file, , NUM_CHANNELS * BITS_PER_SAMPLE / 8   ' Alineación de bloques
    Put #file, , BITS_PER_SAMPLE    ' Bits per sample
    
    ' Write the data sub-block
    Print #file, "data";
    Put #file, , numSamples * 2     ' Data size
End Sub

Dim As Integer file = Freefile
Open "output.wav" For Binary As #file

' Generates a 440 Hz sine wave for 5 seconds
Dim As Integer numSamples = SAMPLE_RATE * 5
Dim As Short buffer(numSamples - 1)
generateSineWave(buffer(), 440.0)

' Write the .wav file
writeWaveHeader(file, numSamples)
Put #file, , buffer()

Close #file

Go

Works with: Ubuntu 16.04

As Go does not have any audio support in its standard library, this invokes the 'arecord' command-line utility to record sound from the internal microphone (assuming there's no other audio input device present) and saves it to a monophonic, signed 16-bit .wav file. It then plays it back using the 'aplay' utility.

The file name, sampling rate and duration can all be set by the user.

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
    "os/exec"
    "strconv"
)

func check(err error) {
    if err != nil {
        log.Fatal(err)
    }
}

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    name := ""
    for name == "" {
        fmt.Print("Enter output file name (without extension) : ")
        scanner.Scan()
        name = scanner.Text()
        check(scanner.Err())
    }
    name += ".wav"

    rate := 0
    for rate < 2000 || rate > 192000 {
        fmt.Print("Enter sampling rate in Hz (2000 to 192000) : ")
        scanner.Scan()
        input := scanner.Text()
        check(scanner.Err())
        rate, _ = strconv.Atoi(input)
    }
    rateS := strconv.Itoa(rate)

    dur := 0.0
    for dur < 5 || dur > 30 {
        fmt.Print("Enter duration in seconds (5 to 30)        : ")
        scanner.Scan()
        input := scanner.Text()
        check(scanner.Err())
        dur, _ = strconv.ParseFloat(input, 64)
    }
    durS := strconv.FormatFloat(dur, 'f', -1, 64)

    fmt.Println("OK, start speaking now...")
    // Default arguments: -c 1, -t wav. Note only signed 16 bit format supported.
    args := []string{"-r", rateS, "-f", "S16_LE", "-d", durS, name}
    cmd := exec.Command("arecord", args...)
    err := cmd.Run()
    check(err)

    fmt.Printf("'%s' created on disk and will now be played back...\n", name)
    cmd = exec.Command("aplay", name)
    err = cmd.Run()
    check(err)
    fmt.Println("Play-back completed.")
}

GUISS

Here we activate the Microsoft Windows '95 Sound Recorder:

Start,Programs,Accessories,Sound Recorder,Button:Record

Java

Java can record sound without external libraries.

import java.io.IOException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.io.File;

import javax.sound.sampled.AudioFileFormat.*;

public final class SoundRecorder {

    public static void main(String[] args) {
    	SoundRecorder recorder = new SoundRecorder();
        
        ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
        scheduler.schedule( () -> recorder.finish(), 10, TimeUnit.SECONDS);
        scheduler.shutdown(); 

        recorder.start();
    }   
 
    private void start() {
        try {
            AudioFormat format = createAudioFormat();
            DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);
 
            if ( ! AudioSystem.isLineSupported(info) ) {
                System.out.println("Data line format is not supported");
                Runtime.getRuntime().exit(0);
            }            
            
            line = (TargetDataLine) AudioSystem.getLine(info);
            line.open(format);
            line.start(); 
            
            System.out.println("Starting to capture and record audio");
            AudioInputStream audioInputStream = new AudioInputStream(line); 
            AudioSystem.write(audioInputStream, audioFileType, wavFile);             
            
        } catch (LineUnavailableException | IOException exception) {
            exception.printStackTrace(System.err);
        }
    }

    private AudioFormat createAudioFormat() {
        final float sampleRate = 16_000.0F;
        final int sampleSizeInBits = 16;
        final int channels = 1;
        final boolean signed = true;
        final boolean bigEndian = true;
        // Monophonic 16-bit PCM audio format
        return new AudioFormat(sampleRate, sampleSizeInBits, channels, signed, bigEndian);
    }

    private void finish() {
        line.stop();
        line.close(); 
        System.out.println("Finished capturing and recording audio");
    }
    
    private TargetDataLine line;
    
    private final File wavFile = new File("SoundRecorder.wav"); 
    private final AudioFileFormat.Type audioFileType = AudioFileFormat.Type.WAVE;    
    
}

Julia

using PortAudio, LibSndFile

stream = PortAudioStream("Microphone (USB Microphone)", 1, 0) # 44100 samples/sec
buf = read(stream, 441000)
save("recorded10sec.wav", buf)

Kotlin

Translation of: Scala

// version 1.1.3

import java.io.File
import javax.sound.sampled.*

const val RECORD_TIME = 20000L // twenty seconds say

fun main(args: Array<String>) {
    val wavFile = File("RecordAudio.wav")
    val fileType = AudioFileFormat.Type.WAVE
    val format = AudioFormat(16000.0f, 16, 2, true, true)
    val info = DataLine.Info(TargetDataLine::class.java, format)
    val line = AudioSystem.getLine(info) as TargetDataLine

    // Creates a new thread that waits for 'RECORD_TIME' before stopping
    Thread(object: Runnable {
        override fun run() {
            try {
                Thread.sleep(RECORD_TIME)
            }
            catch (ie: InterruptedException) {
                println(ie.message)
            }
            finally {
                line.stop()
                line.close()
            }
            println("Finished")
         }
    }).start()

    // Captures the sound and saves it in a WAV file             
    try {
        if (AudioSystem.isLineSupported(info)) {
            line.open(format)
            line.start()
            println("Recording started")
            AudioSystem.write(AudioInputStream(line), fileType, wavFile)
        }
        else println("Line not supported")
    }
    catch (lue: LineUnavailableException) {
        println(lue.message)
    }
}

Liberty BASIC

LB can easily send a MCI string to the OS, or extra routines eg SOX, so a minimal solution could be

run "sndrec32.exe"

A more direct way is..

    print "Starting 5 sec. recording..."
    r$ =mciSendString$( "open new type waveaudio alias capture")
    r$ =mciSendString$( "set capture time format ms bitspersample 16")
    r$ =mciSendString$( "set capture channels 1 samplespersec 8000")
    r$ =mciSendString$( "set capture alignment 1 bytespersec 8000")
    r$ =mciSendString$( "record capture")
    timer 5000, [on]
    wait
  [on]
    timer 0
    print "     .... now stopping the recording."
    r$ =mciSendString$( "stop capture")
    r$ =mciSendString$( "save capture " +chr$( 34) +"sample.wav" +chr$( 34))
    r$ =mciSendString$( "close capture")    
    print "Done recording."
    r$=mciSendString$( "open " +q$ +"sample.wav" +q$ +" type waveaudio alias sfx")
    r$=mciSendString$( "play sfx wait")
    r$=mciSendString$( "close sfx")
    print "Done playing back."
    end

function mciSendString$( s$)
    print s$
    buffer$ =space$( 1024) +chr$( 0)
    calldll #winmm, "mciSendStringA", s$ as ptr, buffer$ as ptr, 1028 as long, 0 as long, r as long
    buffer$ =left$( buffer$, instr( buffer$, chr$( 0)) -1)
    if r >0 then
        mciSendString$ ="error"
        print "returned "; mciSendString$
    else
        mciSendString$ =""'buffer$
        print "OK"
    end if
end function

LiveCode

This example sets some aspects of a sound recording individually and also shows use of the sound input dialog where a user can conveniently set them as well, either may be used.

command makeRecording
    set the dontUseQT to false -- on windows use true
    set the recordFormat to "wave" -- can be wav,aiff, au
    set the recordRate to 44.1 -- sample at 44100 Hz
    set the recordSampleSize to 16  --default is 8 bit
    ask file "Save recording as" 
    if it is not empty then
        answer record --show sound input dialog with presets above
        record sound file it  -- actual record command
        wait 10 seconds
        stop recording 
    end if
end makeRecording

Mathematica/Wolfram Language

SystemDialogInput["RecordSound"]

Nim

Translation of: Go

This code is for Linux systems and uses “arecord” and “aplay”. Previous code which used “/dev/dsp” no longer works on modern OS. This code is a direct translation from Go version, but uses integers instead of floats for duration.

import osproc, strutils

var name = ""
while name.len == 0:
  stdout.write "Enter output file name (without extension): "
  name = stdin.readLine().strip()
name.add ".wav"

var rate = 0
while rate notin 2000..19_200:
  stdout.write "Enter sampling rate in Hz (2000 to 192000): "
  try: rate = parseInt(stdin.readLine().strip())
  except ValueError: discard

var duration = 0
while duration notin 5..30:
  stdout.write "Enter duration in seconds (5 to 30): "
  try: duration = parseInt(stdin.readLine().strip())
  except ValueError: discard

echo "OK, start speaking now..."
# Default arguments: -c 1, -t wav. Note that only signed 16 bit format is supported.
let args = ["-r", $rate, "-f", "S16_LE", "-d", $duration, name]
echo execProcess("arecord", args = args, options = {poStdErrToStdOut, poUsePath})

echo "'$1' created on disk and will now be played back..." % name
echo execProcess("aplay", args = [name], options = {poStdErrToStdOut, poUsePath})
echo "Playback completed"

OCaml

Translation of: C

#load "unix.cma"
 
let record bytes =
  let buf = String.make bytes '\000' in
  let ic = open_in "/dev/dsp" in
  let chunk = 4096 in
  for i = 0 to pred (bytes / chunk) do
    ignore (input ic buf (i * chunk) chunk)
  done;
  close_in ic;
  (buf)
 
let play buf len =
  let oc = open_out "/dev/dsp" in
  output_string oc buf;
  close_out oc
 
let () =
  let bytes = 65536 in
  let p = record bytes in
  play p bytes

Phix

Translation of: BBC_BASIC

Translation of: C

Translation of: Go

--
-- demo\rosetta\Record_sound.exw
-- =============================
--
without js -- (file i/o)
constant wavfile = "capture.wav",
         bitspersample = 16,
         channels = 2,
         samplespersec = 44100,
         alignment = bitspersample * channels / 8,
         bytespersec = alignment * samplespersec,
         params = sprintf(" bitspersample %d channels %d alignment %d samplespersec %d bytespersec %d",
                           {bitspersample,   channels,   alignment,   samplespersec,   bytespersec}),
         error_size = 2048
atom winmm = NULL, xmciSendString, pError

procedure mciSendString(string msg)
    if winmm=NULL then
         winmm = open_dll("winmm.dll")
         xmciSendString = define_c_func(winmm,"mciSendStringA",
            {C_PTR,     --  LPCTSTR lpszCommand
             C_PTR,     --  LPTSTR lpszReturnString
             C_INT,     --  UINT cchReturn
             C_PTR},    --  HANDLE hwndCallback
            C_INT)      -- MCIERROR
         pError = allocate(error_size)
    end if
    atom res = c_func(xmciSendString,{msg,pError,error_size,NULL})
    if res!=0 then crash("error %0x: %s",{res,peek_string(pError)}) end if
end procedure

include get.e   -- get_bytes()

function record(integer bytes)
    integer fn = open("/dev/dsp","rb")
    if fn=-1 then return "" end if
    string res = get_bytes(fn,bytes)
    close(fn)
    return res
end function
 
procedure play(string buf)
    if length(buf) then
        integer fn = open("/dev/dsp","wb")
        if fn!=-1 then
            puts(fn,buf)
            close(fn)
        end if
    end if
end procedure

if platform()=WINDOWS then
    mciSendString("close all")
    mciSendString("open new type waveaudio alias capture")
    mciSendString("set capture" & params)

    puts(1,"Press SPACE to start recording...")
    while wait_key()!=' ' do end while
 
    mciSendString("record capture")
    puts(1,"Recording, press SPACE to stop...")
    while wait_key()!=' ' do end while
 
    mciSendString("stop capture")
    mciSendString("save capture " & wavfile)
    mciSendString("delete capture")
    mciSendString("close capture")
 
    puts(1,"Captured audio is stored in "&wavfile)
elsif platform()=LINUX then
    -- warning: untested
    play(record(65536))
--  -- alternative, from Go (ditto)
--  string name = "test.wav",
--         rate = "2000", -- (2000..192000 Hz)
--         durn = "5" -- (5 to 30 seconds)
--  printf(1,"OK, start speaking now...\n")
--  -- Default arguments: -c 1, -t wav. Note only signed 16 bit format supported.
--  string cmd = sprintf("arecord -r %s -f S16_LE -d %s %s", {rate,durn,name})
--  {} = system_exec(cmd)
--  printf(1,"'%s' created on disk and will now be played back...\n", {name})
--  {} = system_exec("aplay "&name)
--  printf(1,"Play-back completed.\n")
end if

PicoLisp

(in '(rec -q -c1 -tu16 - trim 0 2)  # Record 2 seconds
   (make
      (while (rd 2)
         (link @) ) ) )

Output:

-> (16767 19071 17279 ... 5503 9343 14719)  # 96000 numbers

Python

import pyaudio

chunk = 1024
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 44100

p = pyaudio.PyAudio()

stream = p.open(format = FORMAT,
                channels = CHANNELS,
                rate = RATE,
                input = True,
                frames_per_buffer = chunk)

data = stream.read(chunk)
print [ord(i) for i in data]

Racket

Translation of: C

#lang racket
(define (record n) (with-input-from-file "/dev/dsp" ( () (read-bytes n))))
(define (play bs)  (display-to-file bs "/dev/dsp" #:exists 'append))
(play (record 65536))

Raku

(formerly Perl 6) Slightly modified from an example provided with the Audio::PortAudio module distribution.

use Audio::PortAudio;
use Audio::Sndfile;

sub MAIN(Str $filename, Str :$source, Int :$buffer = 256) {
    my $pa = Audio::PortAudio.new;
    my $format = Audio::Sndfile::Info::Format::WAV +| Audio::Sndfile::Info::Subformat::PCM_16;
    my $out-file = Audio::Sndfile.new(:$filename, channels => 1, samplerate => 44100, :$format, :w);
    my $st;
    
    if $source.defined {
        my $index = 0;
        for $pa.devices -> $device {
            if $device.name eq $source {
                else {
                    my $la = $device.default-high-input-latency;
                    my $si = Audio::PortAudio::StreamParameters.new(device => $index,
                                                                    channel-count => 1,
                                                                    sample-format => Audio::PortAudio::StreamFormat::Float32,
                                                                    suggested-latency => ($la || 0.05e0 ));
                    $st = $pa.open-stream($si, Audio::PortAudio::StreamParameters, 44100, $buffer );
                    last;
                }

            }
            $index++;
        }
        die "Couldn't find a device for '$source'" if !$st.defined;
    }
    else {
        $st = $pa.open-default-stream(2,0, Audio::PortAudio::StreamFormat::Float32, 44100, $buffer);
    }
    $st.start;
    my $p = Promise.new;
    signal(SIGINT).act({
        say "stopping recording";
        $p.keep: "stopped";
        $out-file.close;
        $st.close;
        exit;
    });
    my Channel $write-channel = Channel.new;
    my $write-promise = start {
        react {
            whenever $write-channel -> $item {
                if $p.status ~~ Planned {
                    $out-file.write-float($item[0], $item[1]);
                    $out-file.sync;
                }
                else {
                    done;
                }
            }
        }
    };

    loop {
        if $p.status ~~ Planned {
            my $f = $buffer || $st.read-available;
            if $f > 0 {
                my $buff = $st.read($f,2, num32);
                $write-channel.send([$buff, $f]);
            }
        }
        else {
            last;
        }
    }

}

Scala

Library: Scala

import java.io.{File, IOException}
import javax.sound.sampled.{AudioFileFormat, AudioFormat, AudioInputStream}
import javax.sound.sampled.{AudioSystem, DataLine, LineUnavailableException, TargetDataLine}

object SoundRecorder extends App {
  // record duration, in milliseconds
  final val RECORD_TIME = 60000 // 1 minute

  // path and format of the wav file
  val (wavFile, fileType) = (new File("RecordAudio.wav"), AudioFileFormat.Type.WAVE)
  val format = new AudioFormat(/*sampleRate =*/ 16000f,
    /*sampleSizeInBits =*/ 16,
    /*channels =*/ 2,
    /*signed =*/ true,
    /*bigEndian =*/ true)

  val info = new DataLine.Info(classOf[TargetDataLine], format)
  val line: TargetDataLine = AudioSystem.getLine(info).asInstanceOf[TargetDataLine]

  // Entry to run the program

  // Creates a new thread that waits for a specified of time before stopping
  new Thread(new Runnable() {
    def run() {
      try {
        Thread.sleep(RECORD_TIME)
      } catch {
        case ex: InterruptedException => ex.printStackTrace()
      }
      finally {
        line.stop()
        line.close()
      }
      println("Finished")
    }
  }).start()

  //Captures the sound and record into a WAV file
  try {
    // checks if system supports the data line
    if (AudioSystem.isLineSupported(info)) {
      line.open(format)
      line.start() // start capturing
      println("Recording started")
      AudioSystem.write(new AudioInputStream(line), fileType, wavFile)
    } else println("Line not supported")
  } catch {
    case ex: LineUnavailableException => ex.printStackTrace()
    case ioe: IOException => ioe.printStackTrace()
  }
}

Tcl

Library: Snack

package require sound

# Helper to do a responsive wait
proc delay t {after $t {set ::doneDelay ok}; vwait ::doneDelay}

# Make an in-memory recording object
set recording [snack::sound -encoding "Lin16" -rate 44100 -channels 1]

# Set it doing the recording, wait for a second, and stop
$recording record -append true
delay 1000
$recording stop

# Convert the internal buffer to viewable numbers, and print them out
binary scan [$recording data -byteorder littleEndian] s* words
puts [join $words ", "]

# Destroy the recording object
$recording destroy

Wee Basic

print 1 "Recording..."
micrec
print 1 "Playing..."
micpla
end

Wren

Translation of: Go

The ability to call external processes such as arecord is expected to be added to Wren-cli in the next release. In the meantime, we embed the following Wren script in a C host to complete this task.

/* Record_sound.wren */

class C {
    foreign static getInput(maxSize)

    foreign static arecord(args)

    foreign static aplay(name)
}

var name = ""
while (name == "") {
    System.write("Enter output file name (without extension) : ")
    name = C.getInput(80)
}
name = name + ".wav"

var rate = 0
while (!rate || !rate.isInteger || rate < 2000 || rate > 192000) {
    System.write("Enter sampling rate in Hz (2000 to 192000) : ")
    rate = Num.fromString(C.getInput(6))
}
var rateS = rate.toString

var dur = 0
while (!dur || dur < 5 || dur > 30) {
    System.write("Enter duration in seconds (5 to 30)        : ")
    dur = Num.fromString(C.getInput(5))
}
var durS = dur.toString

System.print("\nOK, start speaking now...")
// Default arguments: -c 1, -t wav. Note only signed 16 bit format supported.
var args = ["-r", rateS, "-f", "S16_LE", "-d", durS, name]
C.arecord(args.join(" "))

System.print("\n'%(name)' created on disk and will now be played back...")
C.aplay(name)
System.print("\nPlay-back completed.")

We now embed this in the following C program, compile and run it.

#include <stdio.h>
#include <stdio_ext.h>
#include <stdlib.h>
#include <string.h>
#include "wren.h"

void C_getInput(WrenVM* vm) {
    int maxSize = (int)wrenGetSlotDouble(vm, 1) + 2;
    char input[maxSize];
    fgets(input, maxSize, stdin);
    __fpurge(stdin);
    input[strcspn(input, "\n")] = 0;
    wrenSetSlotString(vm, 0, (const char*)input);
}

void C_arecord(WrenVM* vm) {
    const char *args = wrenGetSlotString(vm, 1);
    char command[strlen(args) + 8];
    strcpy(command, "arecord ");
    strcat(command, args);
    system(command);
}

void C_aplay(WrenVM* vm) {
    const char *name = wrenGetSlotString(vm, 1);
    char command[strlen(name) + 6];
    strcpy(command, "aplay ");
    strcat(command, name);
    system(command);
}

WrenForeignMethodFn bindForeignMethod(
    WrenVM* vm,
    const char* module,
    const char* className,
    bool isStatic,
    const char* signature) {
    if (strcmp(module, "main") == 0) {
        if (strcmp(className, "C") == 0) {
            if (isStatic && strcmp(signature, "getInput(_)") == 0) return C_getInput;
            if (isStatic && strcmp(signature, "arecord(_)") == 0)  return C_arecord;
            if (isStatic && strcmp(signature, "aplay(_)") == 0)    return C_aplay;
        }
    }
    return NULL;
}

static void writeFn(WrenVM* vm, const char* text) {
    printf("%s", text);
}

void errorFn(WrenVM* vm, WrenErrorType errorType, const char* module, const int line, const char* msg) {
    switch (errorType) {
        case WREN_ERROR_COMPILE:
            printf("[%s line %d] [Error] %s\n", module, line, msg);
            break;
        case WREN_ERROR_STACK_TRACE:
            printf("[%s line %d] in %s\n", module, line, msg);
            break;
        case WREN_ERROR_RUNTIME:
            printf("[Runtime Error] %s\n", msg);
            break;
    }
}

char *readFile(const char *fileName) {
    FILE *f = fopen(fileName, "r");
    fseek(f, 0, SEEK_END);
    long fsize = ftell(f);
    rewind(f);
    char *script = malloc(fsize + 1);
    fread(script, 1, fsize, f);
    fclose(f);
    script[fsize] = 0;
    return script;
}

int main(int argc, char **argv) {
    WrenConfiguration config;
    wrenInitConfiguration(&config);
    config.writeFn = &writeFn;
    config.errorFn = &errorFn;
    config.bindForeignMethodFn = &bindForeignMethod;
    WrenVM* vm = wrenNewVM(&config);
    const char* module = "main";
    const char* fileName = "Record_sound.wren";
    char *script = readFile(fileName);
    WrenInterpretResult result = wrenInterpret(vm, module, script);
    switch (result) {
        case WREN_RESULT_COMPILE_ERROR:
            printf("Compile Error!\n");
            break;
        case WREN_RESULT_RUNTIME_ERROR:
            printf("Runtime Error!\n");
            break;
        case WREN_RESULT_SUCCESS:
            break;
    }
    wrenFreeVM(vm);
    free(script);
    return 0;
}