uvgRTP: Memory leak using asynchronous receiving from multiple streams

Hello guys,

I am working with your library and try to push a lot of data from different processes to different ports, which works fine. But as soon as I am trying to receive the data in one process I get a memory leak. I think it has something to do with the size of the data I am pushing but the sender doesn’t seem to have problems sending the information, only the receiver process results in adding up a lot of memory until the ram is full. Below I attached the code which creates the problem, I compiled using “g++ -o <filePrefix> <filePrefix>_main.cpp -luvgrtp -lpthread -lcryptopp”. Most probably I am just using your library incorrectly…

Best regards

receiver_main.cpp:

#include <uvgrtp/lib.hh>
#include <thread>
#include <iostream>
#include <vector>

void receive_hook(void *arg, uvgrtp::frame::rtp_frame *frame)
{
    /* Now we own the frame. Here you could give the frame to the application
     * if f.ex "arg" was some application-specific pointer
     *
     * arg->copy_frame(frame) or whatever
     *
     * When we're done with the frame, it must be deallocated manually */
    memcpy(arg, frame->payload, frame->payload_len);
    std::cout << "payload: " << frame->payload << std::endl;
    (void)uvgrtp::frame::dealloc_frame(frame);
}

int main(void)
{
    /* See sending.cc for more details */
    uvgrtp::context ctx;

    /* See sending.cc for more details */
    uvgrtp::session *sess = ctx.create_session("127.0.0.1");

    /* See sending.cc for more details */
    // these implementations didn't work properly either...
    // std::vector<uvgrtp::media_stream*> media_streams;
    // uvgrtp::media_stream* media_streams[4];
    std::vector<char*> buffer;

    for (int i = 0; i < 4; ++i) {
        // these implementations didn't work properly either...
        // media_streams.push_back(sess->create_stream(51000+i+1, 9, RTP_FORMAT_H265, 0));
        // media_streams[i] = sess->create_stream(51000+i+1, 9, RTP_FORMAT_H265, 0);
        buffer.push_back(new char[200000]);
    }

    uvgrtp::media_stream* media_stream1 = sess->create_stream(51001, 9, RTP_FORMAT_H265, 0);
    uvgrtp::media_stream* media_stream2 = sess->create_stream(51002, 9, RTP_FORMAT_H265, 0);
    // some dummy streams which don't receive anything
    uvgrtp::media_stream* media_stream3 = sess->create_stream(51003, 9, RTP_FORMAT_H265, 0);
    uvgrtp::media_stream* media_stream4 = sess->create_stream(51004, 9, RTP_FORMAT_H265, 0);
    /* Receive hook can be installed and uvgRTP will call this hook when an RTP frame is received
     *
     * This is a non-blocking operation
     *
     * If necessary, receive hook can be given an argument and this argument is supplied to
     * the receive hook every time the hook is called. This argument could a pointer to application-
     * specfic object if the application needs to be called inside the hook
     *
     * If it's not needed, it should be set to nullptr */
    // these implementations didn't work properly either...
    // for (int i = 0; i < 4; ++i) {
    //     media_streams[i]->install_receive_hook((void*)buffer.at(i), receive_hook);
    // }
    media_stream1->install_receive_hook((void*)buffer.at(0), receive_hook);
    media_stream2->install_receive_hook((void*)buffer.at(1), receive_hook);
    media_stream3->install_receive_hook((void*)buffer.at(2), receive_hook);
    media_stream4->install_receive_hook((void*)buffer.at(3), receive_hook);
    
    while(true){}
    /* Session must be destroyed manually */
    ctx.destroy_session(sess);

    return 0;
}

sender1_main.cpp:

#include <uvgrtp/lib.hh>

#define PAYLOAD_MAXLEN 200000

int main(void)
{
    /* To use the library, one must create a global RTP context object */
    uvgrtp::context ctx;

    /* Each new IP address requires a separate RTP session */
    uvgrtp::session *sess = ctx.create_session("127.0.0.1");

    /* Each RTP session has one or more media streams. These media streams are bidirectional
     * and they require both source and destination ports for the connection. One must also
     * specify the media format for the stream and any configuration flags if needed.
     *
     * See configuration.cc for more details about configuration.
     *
     * First port is source port aka the port that we listen to and second port is the port
     * that remote listens to
     *
     * This same object is used for both sending and receiving media
     *
     * In this example, we have one media stream with the remote participant: H265 */
    uvgrtp::media_stream *hevc = sess->create_stream(51000, 51001, RTP_FORMAT_H265, RTP_NO_FLAGS);

    char* buffer = new char[PAYLOAD_MAXLEN];
    std::string blabla;
    for (int i = 0; i < 40000; ++i) {
        blabla.append("Brrr1");
    }
    memcpy(buffer, &blabla.front(), PAYLOAD_MAXLEN);

    while(true) {
        for (int i = 0; i < 10; ++i) {
            if (hevc->push_frame((uint8_t*)buffer, PAYLOAD_MAXLEN, RTP_NO_FLAGS) != RTP_OK)
                fprintf(stderr, "Failed to send RTP frame!");
        }
    }


    /* Session must be destroyed manually */
    delete[] buffer;
    ctx.destroy_session(sess);

    return 0;
}

sender2_main.cpp:

#include <uvgrtp/lib.hh>

#define PAYLOAD_MAXLEN 200000

int main(void)
{
    /* To use the library, one must create a global RTP context object */
    uvgrtp::context ctx;

    /* Each new IP address requires a separate RTP session */
    uvgrtp::session *sess = ctx.create_session("127.0.0.1");

    /* Each RTP session has one or more media streams. These media streams are bidirectional
     * and they require both source and destination ports for the connection. One must also
     * specify the media format for the stream and any configuration flags if needed.
     *
     * See configuration.cc for more details about configuration.
     *
     * First port is source port aka the port that we listen to and second port is the port
     * that remote listens to
     *
     * This same object is used for both sending and receiving media
     *
     * In this example, we have one media stream with the remote participant: H265 */
    uvgrtp::media_stream *hevc = sess->create_stream(51009, 51002, RTP_FORMAT_H265, RTP_NO_FLAGS);

    char* buffer = new char[PAYLOAD_MAXLEN];
    std::string blabla;
    for (int i = 0; i < 40000; ++i) {
        blabla.append("Brrr2");
    }
    memcpy(buffer, &blabla.front(), PAYLOAD_MAXLEN);

    while(true) {
        for (int i = 0; i < 10; ++i) {
            if (hevc->push_frame((uint8_t*)buffer, PAYLOAD_MAXLEN, RTP_NO_FLAGS) != RTP_OK)
                fprintf(stderr, "Failed to send RTP frame!");
        }
    }


    /* Session must be destroyed manually */
    delete[] buffer;
    ctx.destroy_session(sess);

    return 0;
}