def __init__(self):
    """Create a new AudioPCM instance."""
    super(AudioPCM, self).__init__()
    self._audio_fp = None
    self._channels = list()

def set(self, other):
    """Set from another AudioPCM() instance.

        It can be set either with an audio file pointer, or a list of
        channels or both.

        :param other: (AudioPCM) the other AudioPCM to set

        """
    self._audio_fp = other.get_audiofp()
    self._channels = other.get_channels()

def get_channels(self):
    """Return the list of uploaded channels.

        :return: (list) channels

        """
    return self._channels

def get_audiofp(self):
    """Return the audio file pointer.

        :return: audio file pointer

        """
    return self._audio_fp

def remove_channel(self, channel):
    """Remove a channel from the list of uploaded channels.

        :param channel: (Channel) the channel to remove

        """
    self._channels.remove(channel)

def pop_channel(self, idx):
    """Pop a channel at the position given from the list of uploaded channels.

        :param idx: (int) the index of the channel to remove

        """
    idx = int(idx)
    self._channels.pop(idx)

def insert_channel(self, idx, channel):
    """Insert a channel at the position given in the list of uploaded channels.

        :param idx: (int) the index where the channel has to be inserted
        :param channel: (Channel) the channel to insert

        """
    idx = int(idx)
    self._channels.insert(idx, channel)

def get_channel(self, idx):
    """Get an uploaded channel.

        :param idx: (int) the index of the channel to return
        :returns: (Channel)

        """
    idx = int(idx)
    return self._channels[idx]

def append_channel(self, channel):
    """Append a channel to the list of uploaded channels.

        :param channel: (Channel) the channel to append
        :return: index of the channel

        """
    self._channels.append(channel)
    return len(self._channels) - 1

def extract_channel(self, index=0):
    """Extract a channel from the Audio File Pointer.

        Append the channel into the list of channels.

        Frames are stored into a Channel() instance.
        Index of the channel in the audio file:
        0 = 1st channel (left); 1 = 2nd channel (right); 2 = 3rd channel...

        :param index: (int) The index of the channel to extract
        :return: the index of the Channel() in the list

        """
    if self._audio_fp is None:
        raise AudioError
    index = int(index)
    if index < 0:
        raise ChannelIndexError(index)
    nc = self.get_nchannels()
    self.seek(0)
    data = self.read_frames(self.get_nframes())
    if nc == 0:
        raise AudioDataError
    if index + 1 > nc:
        raise ChannelIndexError(index)
    if nc == 1:
        channel = Channel(self.get_framerate(), self.get_sampwidth(), data)
        return self.append_channel(channel)
    frames = b''
    sw = self.get_sampwidth()
    for i in range(index * sw, len(data), nc * sw):
        frames += data[i:i + sw]
    channel = Channel(self.get_framerate(), self.get_sampwidth(), frames)
    return self.append_channel(channel)

def extract_channels(self):
    """Extract all channels from the Audio File Pointer.

        Append the extracted channels to the list of channels.

        """
    if self._audio_fp is None:
        raise AudioError
    nc = self.get_nchannels()
    sw = self.get_sampwidth()
    self.seek(0)
    data = self.read_frames(self.get_nframes())
    if nc == 0:
        raise AudioDataError
    for index in range(nc):
        frames = b''
        for i in range(index * sw, len(data), nc * sw):
            frames = frames + data[i:i + sw]
        channel = Channel(self.get_framerate(), self.get_sampwidth(), frames)
        self.append_channel(channel)

def read(self):
    """Read all frames of the audio file.

        :return: (str) frames

        """
    return self.read_frames(self.get_nframes())

def read_frames(self, nframes):
    """Read n frames from the audio file.

        :param nframes: (int) the number of frames to read
        :return: (str) frames

        """
    if self._audio_fp is None:
        raise AudioError
    return self._audio_fp.readframes(nframes)

def read_samples(self, nframes):
    """Read the samples from the audio file.

        :param nframes: (int) the number of frames to read
        :return: (list of list) list of samples of each channel

        """
    if self._audio_fp is None:
        raise AudioError
    nframes = int(nframes)
    return AudioConverter().unpack_data(self.read_frames(nframes), self.get_sampwidth(), self.get_nchannels())

def get_sampwidth(self):
    """Return the sample width of the Audio File Pointer.

        :return: (int) sample width of the audio file

        """
    if self._audio_fp is None:
        if len(self._channels) > 0:
            return self._channels[0].get_sampwidth()
        else:
            raise AudioDataError
    return self._audio_fp.getsampwidth()

def get_framerate(self):
    """Return the frame rate of the Audio File Pointer.

        :return: (int) frame rate of the audio file

        """
    if self._audio_fp is None:
        if len(self._channels) > 0:
            return self._channels[0].get_framerate()
        else:
            raise AudioDataError
    return self._audio_fp.getframerate()

def get_nframes(self):
    """Return the number of frames of the Audio File Pointer.

        :return: (int) number of frames of the audio file

        """
    if self._audio_fp is None:
        if len(self._channels) > 0:
            return self._channels[0].get_nframes()
        else:
            raise AudioDataError
    return self._audio_fp.getnframes()

def get_nchannels(self):
    """Return the number of channels of the Audio File Pointer.

        :return: (int) number of channels of the audio file

        """
    if self._audio_fp is None:
        if len(self._channels) > 0:
            return len(self._channels)
        else:
            raise AudioDataError
    return self._audio_fp.getnchannels()

def get_duration(self):
    """Return the duration of the Audio File Pointer.

        :return: (float) duration of the audio file (in seconds)

        """
    if self._audio_fp is None:
        if len(self._channels) > 0:
            return self._channels[0].get_duration()
        else:
            raise AudioDataError
    return float(self.get_nframes()) / float(self.get_framerate())

def rms(self):
    """Return the root-mean-square of the whole file.

        :return: (float) rms of the audio file

        """
    pos = self.tell()
    self.seek(0)
    a = AudioFrames(self.read_frames(self.get_nframes()), self.get_sampwidth(), self.get_nchannels())
    self.seek(pos)
    return a.rms()

def clipping_rate(self, factor):
    """Return the clipping rate of the frames.

        :param factor: (float) An interval to be more precise on clipping rate.
        It will consider that all frames outside the interval are clipped.
        Factor has to be between 0 and 1.
        :return: (float)

        """
    pos = self.tell()
    self.seek(0)
    a = AudioFrames(self.read_frames(self.get_nframes()), self.get_sampwidth())
    self.seek(pos)
    return a.clipping_rate(factor)

def seek(self, pos):
    """Fix the reader pointer position.

        :param pos: (int) the position to set.

        """
    if self._audio_fp is None:
        raise AudioError
    try:
        self._audio_fp.setpos(pos)
    except:
        raise Exception('pos {} not in range (0, {}).'.format(pos, self.get_nframes()))

def tell(self):
    """Get the reader pointer position.

        :return: (int) the current position

        """
    if self._audio_fp is None:
        raise AudioError
    return self._audio_fp.tell()

def rewind(self):
    """Set reader position at the beginning of the file."""
    if self._audio_fp is None:
        raise AudioError
    return self._audio_fp.rewind()

def verify_channels(self):
    """Check that the uploaded channels have the same parameters.

        Check the frame rate, sample width and number of frames.

        :return: (bool)

        """
    mixer = ChannelMixer()
    f = 1.0 / len(self._channels)
    for c in self._channels:
        mixer.append_channel(c, f)
    try:
        mixer.check_channels()
    except MixChannelError:
        return False
    return True

def open(self, filename):
    """Open an audio file."""
    name = self.__class__.__name__
    raise NotImplementedError('{:s} does not support open().'.format(name))

def save(self, filename):
    """Save an audio file."""
    name = self.__class__.__name__
    raise NotImplementedError('{:s} does not support save().'.format(name))

def save_fragments(self, filename):
    """Save a fragment of an audio file."""
    name = self.__class__.__name__
    raise NotImplementedError('{:s} does not support save_fragments().'.format(name))

def close(self):
    """Close the audio file."""
    if self._audio_fp is None:
        raise AudioError
    self._audio_fp.close()
    self._audio_fp = None

def __len__(self):
    return len(self._channels)

def __iter__(self):
    for x in self._channels:
        yield x

def __getitem__(self, i):
    return self._channels[i]