code: def read_frame(self):
          
          # _scur = self._file.tell()
          _temp = self._read_unpack(4, lilendian=True, quiet=True)
          if _temp is None:
              raise EOFError
  
          _tsss = _temp
          _tsus = self._read_unpack(4, lilendian=True)
          _ilen = self._read_unpack(4, lilendian=True)
          _olen = self._read_unpack(4, lilendian=True)
  
          if self._nsec:
              _epch = _tsss + _tsus / 1000000000
          else:
              _epch = _tsss + _tsus / 1000000
          _time = datetime.datetime.fromtimestamp(_epch)
  
          frame = dict(
              frame_info=dict(
                  ts_sec=_tsss,
                  ts_usec=_tsus,
                  incl_len=_ilen,
                  orig_len=_olen,
              ),
              time=_time,
              number=self._fnum,
              time_epoch=_epch,
              len=_ilen,
              cap_len=_olen,
          )
  
          # load packet data
          length = frame['len']
          bytes_ = self._file.read(length)
  
          # record file pointer
          if self._mpkt and self._mpfp:
              # print(self._fnum, 'ready')
              self._mpfp.put(self._file.tell())
              self._mpkt.pool += 1
  
          # make BytesIO from frame packet data
          frame['packet'] = bytes_
          self._file = io.BytesIO(bytes_)
          # frame['packet'] = self._read_packet(header=0, payload=length, discard=True)
  
          return self._decode_next_layer(frame, length)
docs: Read each block after global header.
  
          Structure of record/package header (C):
              typedef struct pcaprec_hdr_s {
                  guint32 ts_sec;     /* timestamp seconds */
                  guint32 ts_usec;    /* timestamp microseconds */
                  guint32 incl_len;   /* number of octets of packet saved in file */
                  guint32 orig_len;   /* actual length of packet */
              } pcaprec_hdr_t;