Canon EDSDK.EdsGetImage error EDS_ERR_NOT_SUPPORTED when reading CR2 file

I'm trying to read a CR2 file using the Canon EDSDKv0309W. I didn't found an example for this SDK version so I looked at several examples from older versions and created the code below. But I always get EDS_ERR_NOT_SUPPORTED in line EDSDK.EdsGetImage(..).

Using a 32Bit compilation under .Net4.6.1 I can read the correct with and height from images taken with EOS500D and M100. But I don't get the image. So my assumption is I get a wrong pointer from EdsCreateMemoryStream. But I don't see what is wrong and how to debug this. Any help will be appreciated.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using EDSDKLib;
using System.Drawing;
using System.Drawing.Imaging;

namespace CR2Reader
{
class Program
{

    static Bitmap GetImage(IntPtr img_stream, EDSDK.EdsImageSource imageSource)
    {
        IntPtr stream = IntPtr.Zero;
        IntPtr img_ref = IntPtr.Zero;
        IntPtr streamPointer = IntPtr.Zero;
        EDSDK.EdsImageInfo imageInfo;
        uint error = 0;

        try
        {
            //create reference and get image info
            error = EDSDK.EdsCreateImageRef(img_stream, out img_ref);
            if (error == 0)
            {
                error = EDSDK.EdsGetImageInfo(img_ref, imageSource, out imageInfo);
                if (error == 0)
                {
                    EDSDK.EdsSize outputSize = new EDSDK.EdsSize();
                    outputSize.width = imageInfo.EffectiveRect.width;
                    outputSize.height = imageInfo.EffectiveRect.height;
                    //calculate amount of data
                    int datalength = outputSize.height * outputSize.width * (int)imageInfo.NumOfComponents * (int)(imageInfo.ComponentDepth / 8);
                    //create buffer that stores the image
                    error = EDSDK.EdsCreateMemoryStream((ulong)datalength, out stream);
                    if (error == 0)
                    {
                        //load image into the buffer
                        error = EDSDK.EdsGetImage(img_ref, imageSource, EDSDK.EdsTargetImageType.RGB16, imageInfo.EffectiveRect, outputSize, stream);
                        if (error == 0)
                        {
                            //make BGR from RGB (System.Drawing (i.e. GDI+) uses BGR)
                            byte[] buffer = new byte[datalength];

                            unsafe
                            {
                                System.Runtime.InteropServices.Marshal.Copy(stream, buffer, 0, datalength);
                                byte tmp;
                                fixed (byte* pix = buffer)
                                {
                                    for (int i = 0; i < datalength; i += 3)
                                    {
                                        tmp = pix[i];        //Save B value
                                        pix[i] = pix[i + 2]; //Set B value with R value
                                        pix[i + 2] = tmp;    //Set R value with B value
                                    }
                                }
                            }

                            //Get pointer to stream
                            error = EDSDK.EdsGetPointer(stream, out streamPointer);
                            if (error == 0)
                            {
                                //Create bitmap with the data in the buffer
                                return new Bitmap(outputSize.width, outputSize.height, datalength, PixelFormat.Format24bppRgb, streamPointer);
                            }
                        }
                    }
                }
            }
            return null;
        }
        finally
        {
            //Release all data
            if (img_ref != IntPtr.Zero) error = EDSDK.EdsRelease(img_ref);
            if (stream != IntPtr.Zero) error = EDSDK.EdsRelease(stream);
        }
    }

   static Bitmap ReadCR2Image(string fileName)
    {
        IntPtr outStream = new IntPtr();

        uint error = EDSDK.EdsInitializeSDK();

        error += EDSDK.EdsCreateFileStream(fileName,
                     EDSDK.EdsFileCreateDisposition.OpenExisting,
                     EDSDK.EdsAccess.Read,
                     out outStream);
        Bitmap bmp = null;
        if (error == 0)
        {
            bmp = GetImage(outStream, EDSDK.EdsImageSource.FullView);
        }
        if (outStream != IntPtr.Zero)
        {
            error = EDSDK.EdsRelease(outStream);
        }
        EDSDK.EdsTerminateSDK();
        return bmp;
    }


    static void Main(string[] args)
    {
        Bitmap bmp = ReadCR2Image("IMG_3113.CR2");
    }
}
}

Solution

You are using the wrong EdsImageSource type. Since you are loading a RAW image you also have to use EdsImageSource.RAWFullView. EdsImageSource.FullView would be appropriate for e.g. a JPG or TIFF.

Once you change that, everything should work just fine.

Edit: just saw you are using RGB16 as target but the rest of the code assumes normal 8bit RGB. You'll have to change a whole bunch of stuff to get that working correctly. I'd advise you to use RGB unless you really need 16bit.

Edit 2: Looks like the library is a bit out of that in that regard (I should really update it). In any case, you can always check the header files of the SDK for up-to-date values. Here's the current definition for EdsImageSource:

enum EdsImageSource
{
    FullView = 0,
    Thumbnail,
    Preview,
    RAWThumbnail,
    RAWFullView,
}

As for changes required for 16bit:

datalength is incorrect
you're using byte instead of ushort to set the pixels
you create the Bitmap with PixelFormat.Format24bppRgb
then there's another thing where Bitmap doesn't fully support 16Bit. See this article for some in-depth information.

Depending on what you need to do it's probably better to either use the raw pixel data directly as you get it from the SDK or use a different graphics library (e.g. WPF, SkiaSharp, ImageSharp, etc.)