Memory leaks while doing memcpy

Question

I'm trying to write an utility dealing with ffmpeg. Once i need to copy image plane from one pointer to another. From AVPicture structure to my own. Here is some sources.

My own frame structe. Memory allocated in constructor, deallocated in destructor

template <class DataType>
struct Frame
{
    DataType* data; //!< Pointer to image data
    int f_type; //!< Type of color space (ex. RGB, HSV, YUV)
    int timestamp; //!< Like ID of frame. Time of this frame in the video file
    int height; //!< Height of frame
    int width; //!< Width of frame

    Frame(int _height, int _width, int _f_type=0):
        height(_height),width(_width),f_type(_f_type)
    {
        data = new DataType[_width*_height*3];
    }

    ~Frame()
    {
        delete[] data;
    }
};

Here is the main loop performing conversion. If the line with memcpy is commented, there are no memory leaks at all. But if I uncomment it, the memory leak are present.

for(int i = begin; i < end; i++)
{
    AVPicture pict;
    avpicture_alloc(&pict, PIX_FMT_BGR24, _width, _height);
    std::shared_ptr<Frame<char>> frame(new Frame<char>(_height, _width, (int)PIX_FMT_BGR24));

    sws_scale(ctx, frame_list[i]->data, frame_list[i]->linesize, 0, frame_list[i]->height, pict.data, pict.linesize);

    memcpy(frame->data,pict.data[0],_width*_height*3);

    //temp_to_add->push_back(std::shared_ptr<Frame<char>>(frame));

    avpicture_free(&pict);
}

I've been trying lot of things such as: allocating memory via malloc and deallocating via free, copying memory from pict to frame by hands (in for loop), using std::copy and avpicture_layout that is ffmpeg helper function. Nothing helps. So the question: do I forget about something important?

I will be grateful for every answer.

Answer 1

Are you sure that it's a leak, and not just the fact you've faulted in memory?

If you call malloc() or new, the language will give you access to the memory. The OS (in the case of a virtual memory OS such as Windows, Linux or MacOS X), however, won't actually make the pages part of your task's working set until you try to do something with that memory.

If you think you're leaking because the memcpy() caused the process size to increase in Windows' process explorer, that's a bad conclusion. Even if you free() or delete the object, the process size will not necessarily decrease.

Try these two test cases as an example. Both clearly have zero leaks.

// test 1
int main()
{
    volatile int *data = (volatile int *)malloc( (1 << 24) * sizeof(int) );
    free((void *)data);

    // Spin until killed, so we're visible in the process explorer as long as needed
    while (1)
        ;
}

and

// test 2
int main()
{
    volatile int *data = (volatile int *)malloc( (1 << 24) * sizeof(int) );
    int i;

    for (i = 0; i < (1 << 24); i++)
        data[i] = i;

    free((void *)data);

    // Spin until killed, so we're visible in the process explorer as long as needed
    while (1)
        ;
}

I suspect the second one will show a much larger memory foot print in the process explorer. It should be over 64MB.

The difference between the two programs is that the second one actually wrote to the memory it allocated, and therefore forced the OS to actually make the pages available to the task. Once the task owns the pages, it usually won't give them back to the OS.

(If it does happen to in the above example, try a smaller size such as (1 << 18) or something. Sometimes malloc does get clever here, but often it does not.)

Answer 2

Your class can easily leak memory on copy construction or assignment. You should provide an explicit copy constructor and assignment operator (at least forbidden as private):

private:
    Frame(const Frame<T>& rhs);
    Frame<T>& operator=(const Frame<T>& rhs);