Handle an incoming RTP packet.

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))