Why when I add any audio in the game the visual slows down?

Everything works wonderfully until I try to add any sort of audio source in any way to the scene. As soon as I do so, if I try to move the visual while I'm moving the player, the visual slows down a lot and I can't manage to understand why. If I move the visual while the player is not moving the visual fluidity is not effected though. Maybe there's something wrong in the code? This is the player controller script.

 using UnityEngine;
 using System.Collections;
 using System.Collections.Generic;
 [AddComponentMenu("Camera-Control/Smooth Mouse Look")]
 public class PlayerController : MonoBehaviour {
  
     public enum RotationAxes { MouseXAndY = 0, MouseX = 1, MouseY = 2 }
     public RotationAxes axes = RotationAxes.MouseXAndY;
     public float sensitivityX = 15F;
     public float sensitivityY = 15F;
     public float minimumX = -360F;
     public float maximumX = 360F;
     public float minimumY = -60F;
     public float maximumY = 60F;
     float rotationX = 0F;
     float rotationY = 0F;
     private List<float> rotArrayX = new List<float>();
     float rotAverageX = 0F;
     private List<float> rotArrayY = new List<float>();
     float rotAverageY = 0F;
     public float frameCounter = 20;
     Quaternion originalRotation;
 
 
     bool isGrounded;
     public LayerMask groundMask;
     public float groundDistance = 0.4f;
     public Transform groundCheck;
     Vector3 velocity;
     public float speed = 5f;
     public float gravity = -9.81f;
     public CharacterController controller;
 
 
 
     float addY;
     void Update ()
     {
 
         Move();
         if (axes == RotationAxes.MouseXAndY)
         {
             //Resets the average rotation
             rotAverageY = 0f;
             rotAverageX = 0f;
 
             addY = Input.GetAxis("Mouse Y") * sensitivityY;
             //Gets rotational input from the mouse
             rotationY += addY;
             rotationX += Input.GetAxis("Mouse X") * sensitivityX;
        
             if(rotationY >= maximumY || rotationY <= minimumY) rotationY-=addY;
             //Adds the rotation values to their relative array
             rotArrayY.Add(rotationY);
             rotArrayX.Add(rotationX);
        
             //If the arrays length is bigger or equal to the value of frameCounter remove the first value in the array
             if (rotArrayY.Count >= frameCounter) {
                 rotArrayY.RemoveAt(0);
             }
             if (rotArrayX.Count >= frameCounter) {
                 rotArrayX.RemoveAt(0);
             }
        
             //Adding up all the rotational input values from each array
             for(int j = 0; j < rotArrayY.Count; j++) {
                 rotAverageY += rotArrayY[j];
             }
             for(int i = 0; i < rotArrayX.Count; i++) {
                 rotAverageX += rotArrayX[i];
             }
        
             //Standard maths to find the average
             rotAverageY /= rotArrayY.Count;
             rotAverageX /= rotArrayX.Count;
        
             if(rotAverageY <= minimumY ) rotAverageY = minimumY;
             else if (rotAverageY >= maximumY) rotAverageY = maximumY;
 
             //Clamp the rotation average to be within a specific value range
             rotAverageY = ClampAngle (rotAverageY, minimumY, maximumY);
             rotAverageX = ClampAngle (rotAverageX, minimumX, maximumX);
 
             Debug.Log("RotAverageY = " + rotAverageY);
 
        
             //Get the rotation you will be at next as a Quaternion
             Quaternion yQuaternion = Quaternion.AngleAxis (rotAverageY, Vector3.left);
             Quaternion xQuaternion = Quaternion.AngleAxis (rotAverageX, Vector3.up);
        
             //Rotate
             transform.localRotation = originalRotation * xQuaternion * yQuaternion;
         }
         else if (axes == RotationAxes.MouseX)
         {        
             rotAverageX = 0f;
             rotationX += Input.GetAxis("Mouse X") * sensitivityX;
             rotArrayX.Add(rotationX);
             if (rotArrayX.Count >= frameCounter) {
                 rotArrayX.RemoveAt(0);
             }
             for(int i = 0; i < rotArrayX.Count; i++) {
                 rotAverageX += rotArrayX[i];
             }
             rotAverageX /= rotArrayX.Count;
             rotAverageX = ClampAngle (rotAverageX, minimumX, maximumX);
             Quaternion xQuaternion = Quaternion.AngleAxis (rotAverageX, Vector3.up);
             transform.localRotation = originalRotation * xQuaternion;        
         }
         else
         {        
             rotAverageY = 0f;
             rotationY += Input.GetAxis("Mouse Y") * sensitivityY;
             rotArrayY.Add(rotationY);
             if (rotArrayY.Count >= frameCounter) {
                 rotArrayY.RemoveAt(0);
             }
             for(int j = 0; j < rotArrayY.Count; j++) {
                 rotAverageY += rotArrayY[j];
             }
             rotAverageY /= rotArrayY.Count;
             // if(rotAverageY <= minimumY || rotAverageY >= maximumY) rotAverageY = 0;
             rotAverageY = ClampAngle (rotAverageY, minimumY, maximumY);
             // Debug.Log("RotAverageY = " + rotAverageY);
             Quaternion yQuaternion = Quaternion.AngleAxis (rotAverageY, Vector3.left);
             transform.localRotation = originalRotation * yQuaternion;
         }
     }
     void Start ()
     {    
 
         Cursor.lockState = CursorLockMode.Locked;
 
         Rigidbody rb = GetComponent<Rigidbody>();
         if (rb)
             rb.freezeRotation = true;
         originalRotation = transform.localRotation;
     }
     public static float ClampAngle (float angle, float min, float max)
     {
         angle = angle % 360;
         if ((angle >= -360F) && (angle <= 360F)) {
             if (angle < -360F) {
                 angle += 360F;
             }
             if (angle > 360F) {
                 angle -= 360F;
             }        
         }
         return Mathf.Clamp (angle, min, max);
     }
 
     void Move(){
 
         isGrounded = Physics.CheckSphere(groundCheck.position, groundDistance, groundMask);
 
         if(isGrounded && velocity.y < 0) velocity.y = -2f;
 
         float x = Input.GetAxis("Horizontal") * speed * Time.deltaTime;
         float z = Input.GetAxis("Vertical") * speed * Time.deltaTime;
 
         Vector3 move = transform.right * x + transform.forward * z;
         move.y=0;
         controller.Move(move);
 
         velocity.y+= gravity * Time.deltaTime;
         controller.Move(velocity * Time.deltaTime);
 
 
 
     }
 
 
 }
 

Thank you in advance!