docs: async def _handle_rtp_packet(self, packet: RtpPacket, arrival_time_ms: int):
          """
          Handle an incoming RTP packet.
          """
          self.__log_debug('< %s', packet)
  
          # feed bitrate estimator
          if self.__remote_bitrate_estimator is not None:
              if packet.extensions.abs_send_time is not None:
                  remb = self.__remote_bitrate_estimator.add(
                      abs_send_time=packet.extensions.abs_send_time,
                      arrival_time_ms=arrival_time_ms,
                      payload_size=len(packet.payload) + packet.padding_size,
                      ssrc=packet.ssrc,
                  )
                  if self.__rtcp_ssrc is not None and remb is not None:
                      # send Receiver Estimated Maximum Bitrate feedback
                      rtcp_packet = RtcpPsfbPacket(
                          fmt=RTCP_PSFB_APP, ssrc=self.__rtcp_ssrc, media_ssrc=0)
                      rtcp_packet.fci = pack_remb_fci(*remb)
                      await self._send_rtcp(rtcp_packet)
  
          # keep track of sources
          self.__active_ssrc[packet.ssrc] = clock.current_datetime()
  
          # check the codec is known
          codec = self.__codecs.get(packet.payload_type)
          if codec is None:
              self.__log_debug('x RTP packet with unknown payload type %d', packet.payload_type)
              return
  
          # feed RTCP statistics
          if packet.ssrc not in self.__remote_streams:
              self.__remote_streams[packet.ssrc] = StreamStatistics(codec.clockRate)
          self.__remote_streams[packet.ssrc].add(packet)
  
          # unwrap retransmission packet
          if is_rtx(codec):
              original_ssrc = self.__rtx_ssrc.get(packet.ssrc)
              if original_ssrc is None:
                  self.__log_debug('x RTX packet from unknown SSRC %d', packet.ssrc)
                  return
  
              if len(packet.payload) < 2:
                  return
  
              codec = self.__codecs[codec.parameters['apt']]
              packet = unwrap_rtx(packet,
                                  payload_type=codec.payloadType,
                                  ssrc=original_ssrc)
  
          # send NACKs for any missing any packets
          if self.__nack_generator is not None and self.__nack_generator.add(packet):
              await self._send_rtcp_nack(packet.ssrc, sorted(self.__nack_generator.missing))
  
          # parse codec-specific information
          try:
              if packet.payload:
                  packet._data = depayload(codec, packet.payload)
              else:
                  packet._data = b''
          except ValueError as exc:
              self.__log_debug('x RTP payload parsing failed: %s', exc)
              return
  
          # try to re-assemble encoded frame
          encoded_frame = self.__jitter_buffer.add(packet)
  
          # if we have a complete encoded frame, decode it
          if encoded_frame is not None and self.__decoder_thread:
              encoded_frame.timestamp = self.__timestamp_mapper.map(encoded_frame.timestamp)
              self.__decoder_queue.put((codec, encoded_frame))