@Override
    public void updateSourceParam(AudioSource src, AudioParam param) {
        checkDead();
        synchronized (threadLock) {
            if (audioDisabled) {
                return;
            }

            int channel = src.getChannel();
            // Parameter updates only make sense if the source is associated with a channel
            // and hasn't been stopped (which would set channel to -1).
            if (channel < 0) {
                // This can happen due to race conditions if a source stops playing
                // right as a parameter update is requested from another thread.
                if (logger.isLoggable(Level.FINE)) {
                    logger.log(Level.FINE, "Ignoring parameter update for source {0} as it's not validly associated with channel {1}.",
                            new Object[]{src, channel});
                }
                return;
            }

            int sourceId = channels[channel];

            switch (param) {
                case Position:
                    if (src.isPositional()) {
                        Vector3f pos = src.getPosition();
                        al.alSource3f(sourceId, AL_POSITION, pos.x, pos.y, pos.z);
                    }
                    break;

                case Velocity:
                    if (src.isPositional()) {
                        Vector3f vel = src.getVelocity();
                        al.alSource3f(sourceId, AL_VELOCITY, vel.x, vel.y, vel.z);
                    }
                    break;

                case MaxDistance:
                    if (src.isPositional()) {
                        al.alSourcef(sourceId, AL_MAX_DISTANCE, src.getMaxDistance());
                    }
                    break;

                case RefDistance:
                    if (src.isPositional()) {
                        al.alSourcef(sourceId, AL_REFERENCE_DISTANCE, src.getRefDistance());
                    }
                    break;

                case IsPositional:
                    applySourcePositionalState(sourceId, src);
                    break;

                case Direction:
                    if (src.isDirectional()) {
                        Vector3f dir = src.getDirection();
                        al.alSource3f(sourceId, AL_DIRECTION, dir.x, dir.y, dir.z);
                    }
                    break;

                case InnerAngle:
                    if (src.isDirectional()) {
                        al.alSourcef(sourceId, AL_CONE_INNER_ANGLE, src.getInnerAngle());
                    }
                    break;

                case OuterAngle:
                    if (src.isDirectional()) {
                        al.alSourcef(sourceId, AL_CONE_OUTER_ANGLE, src.getOuterAngle());
                    }
                    break;

                case IsDirectional:
                    applySourceDirectionalState(sourceId, src);
                    break;

                case DryFilter:
                    applySourceDryFilter(sourceId, src);
                    break;

                case ReverbFilter:
                    if (src.isPositional()) {
                        applySourceReverbFilter(sourceId, src);
                    }
                    break;

                case ReverbEnabled:
                    if (supportEfx && src.isPositional()) {
                        if (!src.isReverbEnabled()) {
                            al.alSource3i(sourceId, EFX.AL_AUXILIARY_SEND_FILTER, 0, 0, EFX.AL_FILTER_NULL);
                        } else {
                            applySourceReverbFilter(sourceId, src);
                        }
                    }
                    break;

                case Looping:
                    applySourceLooping(sourceId, src, false);
                    break;

                case Volume:
                    al.alSourcef(sourceId, AL_GAIN, src.getVolume());
                    break;

                case Pitch:
                    al.alSourcef(sourceId, AL_PITCH, src.getPitch());
                    break;

                default:
                    logger.log(Level.WARNING, "Unhandled source parameter update: {0}", param);
                    break;
            }
        }
    }
Updates a specific parameter for an audio source on its assigned channel.
@param src The audio source.
@param param The parameter to update.
jme3-core/src/main/java/com/jme3/audio/openal/ALAudioRenderer.java