:return AudioPortBuilder
2135
def generate_builder(self, json, audio_port):
        
        if 'effect' in json[audio_port]:
            return Lv2AudioPortBuilder(self.pedalboard)
        else:
            return SystemAudioPortBuilder(self.system_effect)
185587
def _get_support_sound_mode(self):
        
        if self._receiver_type == AVR_X_2016.type:
            return self._get_support_sound_mode_avr_2016()
        else:
            return self._get_support_sound_mode_avr()
718233
def available_backends():
    """"""

    # Standard-library WAV and AIFF readers.
    from . import rawread
    result = [rawread.RawAudioFile]

    # Core Audio.
    if _ca_available():
        from . import macca
        result.append(macca.ExtAudioFile)

    # GStreamer.
    if _gst_available():
        from . import gstdec
        result.append(gstdec.GstAudioFile)

    # MAD.
    if _mad_available():
        from . import maddec
        result.append(maddec.MadAudioFile)

    # FFmpeg.
    if ffdec.available():
        result.append(ffdec.FFmpegAudioFile)

    return result
590515
def audio_outputs(self):
        
        return self.client.get_ports(is_audio=True, is_physical=True, is_output=True)
1010370
def isAudio(self):
        
        val=False
        if self.__dict__['codec_type']:
            if str(self.__dict__['codec_type']) == 'audio':
                val=True
        return val
1052620
def _get_audio_filter_cmd(self):
        
        all_filters = []
        output_labels = []

        for audio_stream in self.streams['audio'].values():
            if self.ffmpeg_normalize.normalization_type == 'ebu':
                stream_filter = audio_stream.get_second_pass_opts_ebu()
            else:
                stream_filter = audio_stream.get_second_pass_opts_peakrms()
            input_label = '[0:{}]'.format(audio_stream.stream_id)
            output_label = '[norm{}]'.format(audio_stream.stream_id)
            output_labels.append(output_label)
            all_filters.append(input_label + stream_filter + output_label)

        filter_complex_cmd = ';'.join(all_filters)

        return filter_complex_cmd, output_labels
1345851
public static function getAudioList() {
        if (self::$_audio) {
            return self::$_audio;
        }

        self::$_audio = self::_getList('audio');

        return self::$_audio;
    }
566828
def _wrap_stream_read(self, stream):
        
        import pyaudio
        if getattr(stream.read, '__func__', None) is pyaudio.Stream.read:
            stream.read = lambda x: pyaudio.Stream.read(stream, x // 2, False)
1178461
def libvlc_audio_set_volume(p_mi, i_volume):
    '''
    '''
    f = _Cfunctions.get('libvlc_audio_set_volume', None) or \
        _Cfunction('libvlc_audio_set_volume', ((1,), (1,),), None,
                    ctypes.c_int, MediaPlayer, ctypes.c_int)
    return f(p_mi, i_volume)
1289607
function LGAudioMixer() {
        //default
        this.properties = {
            gain1: 0.5,
            gain2: 0.5
        };

        this.audionode = LGAudio.getAudioContext().createGain();

        this.audionode1 = LGAudio.getAudioContext().createGain();
        this.audionode1.gain.value = this.properties.gain1;
        this.audionode2 = LGAudio.getAudioContext().createGain();
        this.audionode2.gain.value = this.properties.gain2;

        this.audionode1.connect(this.audionode);
        this.audionode2.connect(this.audionode);

        this.addInput("in1", "audio");
        this.addInput("in1 gain", "number");
        this.addInput("in2", "audio");
        this.addInput("in2 gain", "number");

        this.addOutput("out", "audio");
    }
993317
function toArrayBuffer (audioBuffer, format) {
	if (!isNormalized(format)) format = normalize(format)

	var data

	//convert to arraybuffer
	if (audioBuffer._data) data = audioBuffer._data.buffer;

	else {
		var floatArray = audioBuffer.getChannelData(0).constructor;
		data = new floatArray(audioBuffer.length * audioBuffer.numberOfChannels);

		for (var channel = 0; channel < audioBuffer.numberOfChannels; channel++) {
			data.set(audioBuffer.getChannelData(channel), channel * audioBuffer.length);
		}
	}

	var arrayFormat = fromTypedArray(audioBuffer.getChannelData(0))

	var buffer = convert(data, {
		float: true,
		channels: audioBuffer.numberOfChannels,
		sampleRate: audioBuffer.sampleRate,
		interleaved: false,
		bitDepth: arrayFormat.bitDepth
	}, format)

	return buffer
}
850096
def _load_audio_file(self):
        
        self._step_begin(u"load audio file")
        # NOTE file_format=None forces conversion to
        #      PCM16 mono WAVE with default sample rate
        audio_file = AudioFile(
            file_path=self.task.audio_file_path_absolute,
            file_format=None,
            rconf=self.rconf,
            logger=self.logger
        )
        audio_file.read_samples_from_file()
        self._step_end()
        return audio_file
301974
async def send_audio(self, url, user, options=None):
        
        tasks = [interface.send_audio(user, url, options) for _, interface in self.interfaces.items()]
        return [body for body in await asyncio.gather(*tasks)]
649788
def as_ipywidget(self):
        
        from IPython.display import Audio

        return Audio(data=self.y, rate=self.sr)
738547
def midi_inputs(self):
        
        return self.client.get_ports(is_midi=True, is_physical=True, is_input=True)
247348
def libvlc_audio_get_delay(p_mi):
    '''
    '''
    f = _Cfunctions.get('libvlc_audio_get_delay', None) or \
        _Cfunction('libvlc_audio_get_delay', ((1,),), None,
                    ctypes.c_int64, MediaPlayer)
    return f(p_mi)
168676
function ( source ) {
      var _this = this;
      this.path = source ? source.src : this.path;

      this.isLoaded = false;
      this.progress = 0;

      !window.soundManager && !smLoading && loadSM.call( this );

      if ( window.soundManager ) {
        this.audio = soundManager.createSound({
          id       : 'dancer' + Math.random() + '',
          url      : this.path,
          stream   : true,
          autoPlay : false,
          autoLoad : true,
          whileplaying : function () {
            _this.update();
          },
          whileloading : function () {
            _this.progress = this.bytesLoaded / this.bytesTotal;
          },
          onload   : function () {
            _this.fft = new FFT( SAMPLE_SIZE, SAMPLE_RATE );
            _this.signal = new Float32Array( SAMPLE_SIZE );
            _this.waveform = new Float32Array( SAMPLE_SIZE );
            _this.isLoaded = true;
            _this.progress = 1;
            _this.dancer.trigger( 'loaded' );
          }
        });
        this.dancer.audio = this.audio;
      }

      // Returns audio if SM already loaded -- otherwise,
      // sets dancer instance's audio property after load
      return this.audio;
    }