docs: def __demodulate_data(self, data):
          """
          Demodulates received IQ data and adds demodulated bits to messages
          :param data:
          :return:
          """
          if len(data) == 0:
              return
  
          power_spectrum = data.real ** 2 + data.imag ** 2
          is_above_noise = np.sqrt(np.mean(power_spectrum)) > self.signal.noise_threshold
  
          if self.adaptive_noise and not is_above_noise:
              self.signal.noise_threshold = 0.9 * self.signal.noise_threshold + 0.1 * np.sqrt(np.max(power_spectrum))
  
          if is_above_noise:
              self.__add_to_buffer(data)
              self.pause_length = 0
              if not self.__buffer_is_full():
                  return
          else:
              self.pause_length += len(data)
              if self.pause_length < 10 * self.signal.bit_len:
                  self.__add_to_buffer(data)
                  if not self.__buffer_is_full():
                      return
  
          if self.__current_buffer_index == 0:
              return
  
          # clear cache and start a new message
          self.signal._fulldata = self.__buffer[0:self.__current_buffer_index]
          self.__clear_buffer()
          self.signal._qad = None
  
          bit_len = self.signal.bit_len
          if self.automatic_center:
              self.signal.qad_center = AutoInterpretation.detect_center(self.signal.qad, max_size=150*self.signal.bit_len)
  
          ppseq = grab_pulse_lens(self.signal.qad, self.signal.qad_center,
                                  self.signal.tolerance, self.signal.modulation_type, self.signal.bit_len)
  
          bit_data, pauses, bit_sample_pos = self._ppseq_to_bits(ppseq, bit_len, write_bit_sample_pos=False)
  
          for bits, pause in zip(bit_data, pauses):
              message = Message(bits, pause, bit_len=bit_len, message_type=self.default_message_type,
                                decoder=self.decoder)
              self.messages.append(message)
              self.message_sniffed.emit(len(self.messages) - 1)