create custom RTCRtpSender, i need overwrite _run_rtp for stream frame and ignore when frame is None

[JesusZerpa]

Hello everyone, I am continuing my video streaming project, currently I have managed to remove the buffer that I am using in an opencv application and send it to the track of the aiortc library by creating my own object that I inherit from MediaStreamTrack, everything is great, but I find myself with the problem that for reasons of my implementation there are times when the frame will arrive in None to the track and this breaks in the decoding stage of the RTCRtpSender in the _run_rtp method, doing some exploration in the library I managed the part of the code exactly the _next_encoded_frame method with a try except and the implementation worked as I needed it to, but this is something I did just for testing, I would like to override the _run_rtp method of the RTCRtpSender or handle in some correct way that part of the code that I need, the The problem I have encountered is that the traceivers and other parts of the code are made as private methods or attributes for which I cannot make the adaptation I need.

The code that works for me looks like this

async def _run_rtp(self, codec: RTCRtpCodecParameters) -> None:
        self.__log_debug("- RTP started")
        self.__rtp_started.set()

        sequence_number = random16()
        timestamp_origin = random32()
        try:
            while True:
                if not self.__track:
                    await asyncio.sleep(0.02)
                    continue
                try:
                    enc_frame = await self._next_encoded_frame(codec)
                    timestamp = uint32_add(timestamp_origin, enc_frame.timestamp)

                    for i, payload in enumerate(enc_frame.payloads):
                        packet = RtpPacket(
                            payload_type=codec.payloadType,
                            sequence_number=sequence_number,
                            timestamp=timestamp,
                        )
                        packet.ssrc = self._ssrc
                        packet.payload = payload
                        packet.marker = (i == len(enc_frame.payloads) - 1) and 1 or 0

                        # set header extensions
                        packet.extensions.abs_send_time = (
                            clock.current_ntp_time() >> 14
                        ) & 0x00FFFFFF
                        packet.extensions.mid = self.__mid
                        if enc_frame.audio_level is not None:
                            packet.extensions.audio_level = (False, -enc_frame.audio_level)

                        # send packet
                        self.__log_debug("> %s", packet)
                        self.__rtp_history[
                            packet.sequence_number % RTP_HISTORY_SIZE
                        ] = packet
                        packet_bytes = packet.serialize(self.__rtp_header_extensions_map)
                        await self.transport._send_rtp(packet_bytes)

                        self.__ntp_timestamp = clock.current_ntp_time()
                        self.__rtp_timestamp = packet.timestamp
                        self.__octet_count += len(payload)
                        self.__packet_count += 1
                        sequence_number = uint16_add(sequence_number, 1)
                except:
                    pass
        except (asyncio.CancelledError, ConnectionError, MediaStreamError) as e:
            print("ERROR MANEJADO 1")
            print(e,type(e))
            pass
        except Exception as e:
            # we *need* to set __rtp_exited, otherwise RTCRtpSender.stop() will hang,
            # so issue a warning if we hit an unexpected exception
            self.__log_warning(traceback.format_exc())
            print("ERROR MANEJADO 2")
            print(traceback.format_exc())
        # stop track
        if self.__track:
            print("############# FINALIZANDO2")
            #self.__track.stop()
            #self.__track = None

        self.__log_debug("- RTP finished")
        self.__rtp_exited.set()

and originally it is like this

async def _run_rtp(self, codec: RTCRtpCodecParameters) -> None:
        self.__log_debug("- RTP started")
        self.__rtp_started.set()

        sequence_number = random16()
        timestamp_origin = random32()
        try:
            while True:
                if not self.__track:
                    await asyncio.sleep(0.02)
                    continue

                enc_frame = await self._next_encoded_frame(codec)
                timestamp = uint32_add(timestamp_origin, enc_frame.timestamp)

                for i, payload in enumerate(enc_frame.payloads):
                    packet = RtpPacket(
                        payload_type=codec.payloadType,
                        sequence_number=sequence_number,
                        timestamp=timestamp,
                    )
                    packet.ssrc = self._ssrc
                    packet.payload = payload
                    packet.marker = (i == len(enc_frame.payloads) - 1) and 1 or 0

                    # set header extensions
                    packet.extensions.abs_send_time = (
                        clock.current_ntp_time() >> 14
                    ) & 0x00FFFFFF
                    packet.extensions.mid = self.__mid
                    if enc_frame.audio_level is not None:
                        packet.extensions.audio_level = (False, -enc_frame.audio_level)

                    # send packet
                    self.__log_debug("> %s", packet)
                    self.__rtp_history[
                        packet.sequence_number % RTP_HISTORY_SIZE
                    ] = packet
                    packet_bytes = packet.serialize(self.__rtp_header_extensions_map)
                    await self.transport._send_rtp(packet_bytes)

                    self.__ntp_timestamp = clock.current_ntp_time()
                    self.__rtp_timestamp = packet.timestamp
                    self.__octet_count += len(payload)
                    self.__packet_count += 1
                    sequence_number = uint16_add(sequence_number, 1)
        except (asyncio.CancelledError, ConnectionError, MediaStreamError):
            pass
        except Exception:
            # we *need* to set __rtp_exited, otherwise RTCRtpSender.stop() will hang,
            # so issue a warning if we hit an unexpected exception
            self.__log_warning(traceback.format_exc())

        # stop track
        if self.__track:
            self.__track.stop()
            self.__track = None

        self.__log_debug("- RTP finished")
        self.__rtp_exited.set()

my custom track looks like this

class VideoTransformTrack(VideoStreamTrack):
    """
    A video stream track that transforms frames from an another track.
    """

    kind = "video"

    def __init__(self):
        super().__init__()  # don't forget this!
        self.kind = "video"
        self._queue=asyncio.Queue()
        self._start = None
    async def recv(self):
        from server.sockets import queue
       
        pts, time_base = await self.next_timestamp()
  
 
        ret=False

        try:
            ret,_frame=queue.get(False)
        except Exception as e:
            print(">>>>>>> ",e)
        if ret:
            #frame = await self.track.recv()
            new_frame = VideoFrame.from_ndarray(_frame, format="bgr24")
            await self._queue.put(new_frame)
            
            new_frame.pts = pts
            new_frame.time_base = time_base

            return new_frame