docs: def process_track(self, track, frame_size=400, hop_size=160, sr=None,
                        start=0, end=float('inf'), utterance=None, corpus=None):
          """
          Process the track in **offline** mode, in one go.
  
          Args:
              track (Track): The track to process.
              frame_size (int): The number of samples per frame.
              hop_size (int): The number of samples between two frames.
              sr (int): Use the given sampling rate. If ``None``,
                        uses the native sampling rate from the underlying data.
              start (float): The point within the track in seconds,
                             to start processing from.
              end (float): The point within the track in seconds,
                           to end processing.
              utterance (Utterance): The utterance that is associated with
                                     this track, if available.
              corpus (Corpus): The corpus this track is part of, if available.
  
          Returns:
              np.ndarray: The processed features.
          """
          frame_settings = units.FrameSettings(frame_size, hop_size)
  
          if end != float('inf'):
              samples = track.read_samples(sr=sr, offset=start, duration=end-start)
          else:
              samples = track.read_samples(sr=sr, offset=start)
  
          if sr is None:
              sr = track.sampling_rate
  
          if samples.size <= 0:
              raise ValueError('Track {} has no samples'.format(track.idx))
  
          # Pad with zeros to match frames
          num_frames = frame_settings.num_frames(samples.size)
          num_pad_samples = (num_frames - 1) * hop_size + frame_size
  
          if num_pad_samples > samples.size:
              samples = np.pad(samples, (0, num_pad_samples - samples.size), mode='constant', constant_values=0)
  
          # Get sampling-rate if not given
          sampling_rate = sr or utterance.sampling_rate
  
          frames = librosa.util.frame(samples, frame_length=frame_size, hop_length=hop_size).T
          return self.process_frames(frames, sampling_rate, 0, last=True, utterance=utterance, corpus=corpus)