Question

This may well have come up before but the following code is taken from an MSDN example I am modifying. I want to know how I can iterate through the contents of the buffer which contains data about a bitmap and print out the colors. Each pixel is 4 bytes of data so I am assuming the R G B values account for 3 of these bytes, and possibly A is the 4th.

What is the correct C++ syntax for the pointer arithmetic required (ideally inside a loop) that will store the value pointed to during that iteration in to a local variable that I can use, eg. print to the console.

Many thanks

PS. Is this safe? Or is there a safer way to read the contents of an IMFMediaBuffer? I could not find an alternative.

Here is the code:

hr = pSample->ConvertToContiguousBuffer(&pBuffer); // this is the BitmapData
    // Converts a sample with multiple buffers into a sample with a single IMFMediaBuffer which we Lock in memory next...

    // IMFMediaBuffer represents a block of memory that contains media data

    hr = pBuffer->Lock(&pBitmapData, NULL, &cbBitmapData);  // pBuffer is IMFMediaBuffer
    /* Lock method gives the caller access to the memory in the buffer, for reading or writing:
    pBitmapData - receives a pointer to start of buffer
    NULL - receives the maximum amount of data that can be written to the buffer. This parameter can be NULL.
    cbBitmapData - receives the length of the valid data in the buffer, in bytes. This parameter can be NULL.
    */

Answer 1

I solved the problem myself and thought it best to add the answer here so that it formats correctly and maybe others will benefit from it. Basically in this situation we use 32 bits for the image data and what is great is that we are reading raw from memory so there is not yet a Bitmap header to skip because this is just raw color information.

NOTE: Across these 4 bytes we have (from bit 0 – 31) B G R A, which we can verify by using my code:

  int x = 0;

    while(x < cbBitmapData){

        Console::Write("B: {0}", (*(pBitmapData + x++)));
        Console::Write("\tG: {0}", (*(pBitmapData + x++)));
        Console::Write("\tR: {0}", (*(pBitmapData + x++)));
        Console::Write("\tA: {0}\n", (*(pBitmapData + x++)));
    }

From the output you will see that the A value is 0 for each pixel because there is no concept of transparency or depth here, which is what we expect.

Also to verify that all we have in the buffer is raw image data and no other data I used this calculation which you may also find of use:

Console::Write("no of pixels in buffer: {0} \nexpected no of pixels based on dimensions:{1}", (cbBitmapData/4), (m_format.imageWidthPels * m_format.imageHeightPels) );

Where we divide the value of cbBitmapData by 4 because it is a count of the bytes, and as aforementioned for each pixel we have a width of 4 bytes (32-bit DWORDS in actual fact because the length of a byte is not always strictly uniform across hardware apparently!?). We compare this to the image width multiplied by its height. They are equal and thus we have just pixel color information in the buffer.

Hope this helps someone.