docs: def process_track_online(self, track, frame_size=400, hop_size=160,
                               start=0, end=float('inf'), utterance=None, corpus=None,
                               chunk_size=1, buffer_size=5760000):
          """
          Process the track in **online** mode, chunk by chunk.
          The processed chunks are yielded one after another.
  
          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.
              start (float): The point within the track in seconds to start processing from.
              end (float): The point within the trac 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.
              chunk_size (int): Number of frames to process per chunk.
              buffer_size (int): Number of samples to load into memory at once.
                                 The exact number of loaded samples depends
                                 on the type of track.
                                 It can be of block-size higher,
                                 where the block-size is typically 1024 or 4096.
  
          Returns:
              Generator: A generator that yield processed chunks.
          """
  
          current_frame = 0
          frames = []
  
          duration = None
          sr = track.sampling_rate
  
          if end != float('inf'):
              duration = end - start
  
          # Process chunks that are within end bounds
          for frame, is_last in track.read_frames(frame_size,
                                                  hop_size,
                                                  offset=start,
                                                  duration=duration,
                                                  buffer_size=buffer_size):
  
              frames.append(frame)
  
              if len(frames) == chunk_size:
                  processed = self.process_frames(np.array(frames), sr, current_frame,
                                                  last=is_last, utterance=utterance, corpus=corpus)
                  if processed is not None:
                      yield processed
                  current_frame += chunk_size
                  frames = frames[chunk_size:]
  
          # Process overlapping chunks with zero frames at the end
          if len(frames) > 0:
              processed = self.process_frames(np.array(frames), sr, current_frame,
                                              last=True, utterance=utterance, corpus=corpus)
              yield processed