code: func (handle *MemifPacketHandle) ReadPacketData() (data []byte, ci gopacket.CaptureInfo, err error) {
  	handle.readMu.Lock()
  	defer handle.readMu.Unlock()
  
  	if handle.stop {
  		err = io.EOF
  		return
  	}
  
  	queueLen := len(handle.packetQueue)
  
  	if queueLen == 0 {
  		packets, burstErr := handle.memif.RxBurst(handle.queueId, handle.rxCount)
  		packetsLen := len(packets)
  
  		if burstErr != nil {
  			err = burstErr
  			return
  		}
  
  		if packetsLen == 0 {
  			err = io.EOF
  			return
  		}
  
  		handle.packetQueue = make([]*memoizedPacket, packetsLen)
  
  		for i, packet := range packets {
  			packetLen := len(packet)
  
  			handle.packetQueue[i] = &memoizedPacket{
  				data: []byte(packet),
  				ci: gopacket.CaptureInfo{
  					Timestamp:     time.Now(),
  					CaptureLength: packetLen,
  					Length:        packetLen,
  				},
  			}
  		}
  	}
  
  	packet := handle.packetQueue[0]
  	handle.packetQueue = handle.packetQueue[1:]
  	data = packet.data
  	ci = packet.ci
  
  	return
  }
docs: // Reads packet data from memif in bursts, based on previously configured rxCount parameterer. Then caches the
  // resulting packets and returns them 1 by 1 from this method until queue is empty then tries to call new rx burst
  // to read more data. If no data is returned, io.EOF error is thrown and caller should stop reading.