docs: def iter_wave_values(self):
          """
          yield frame numer + volume value from the WAVE file
          """
          typecode = self.get_typecode(self.samplewidth)
  
          if log.level >= 5:
              if self.cfg.AVG_COUNT > 1:
                  # merge samples -> log output in iter_avg_wave_values
                  tlm = None
              else:
                  tlm = TextLevelMeter(self.max_value, 79)
  
          # Use only a read size which is a quare divider of the samplewidth
          # Otherwise array.array will raise: ValueError: string length not a multiple of item size
          divider = int(round(float(WAVE_READ_SIZE) / self.samplewidth))
          read_size = self.samplewidth * divider
          if read_size != WAVE_READ_SIZE:
              log.info("Real use wave read size: %i Bytes" % read_size)
  
          get_wave_block_func = functools.partial(self.wavefile.readframes, read_size)
          skip_count = 0
  
          manually_audioop_bias = self.samplewidth == 1 and audioop is None
  
          for frames in iter(get_wave_block_func, ""):
  
              if self.samplewidth == 1:
                  if audioop is None:
                      log.warning("use audioop.bias() work-a-round for missing audioop.")
                  else:
                      # 8 bit samples are unsigned, see:
                      # http://docs.python.org/2/library/audioop.html#audioop.lin2lin
                      frames = audioop.bias(frames, 1, 128)
  
              try:
                  values = array.array(typecode, frames)
              except ValueError, err:
                  # e.g.:
                  #     ValueError: string length not a multiple of item size
                  # Work-a-round: Skip the last frames of this block
                  frame_count = len(frames)
                  divider = int(math.floor(float(frame_count) / self.samplewidth))
                  new_count = self.samplewidth * divider
                  frames = frames[:new_count] # skip frames
                  log.error(
                      "Can't make array from %s frames: Value error: %s (Skip %i and use %i frames)" % (
                          frame_count, err, frame_count - new_count, len(frames)
                  ))
                  values = array.array(typecode, frames)
  
              for value in values:
                  self.wave_pos += 1 # Absolute position in the frame stream
  
                  if manually_audioop_bias:
                      # audioop.bias can't be used.
                      # See: http://hg.python.org/cpython/file/482590320549/Modules/audioop.c#l957
                      value = value % 0xff - 128
  
  #                 if abs(value) < self.min_volume:
  # #                     log.log(5, "Ignore to lower amplitude")
  #                     skip_count += 1
  #                     continue
  
                  yield (self.wave_pos, value)
  
          log.info("Skip %i samples that are lower than %i" % (
              skip_count, self.min_volume
          ))
          log.info("Last readed Frame is: %s" % self.pformat_pos())