GetPixelSpan is removed without any release note?

[burner-]

I just migrate my project form 0007beta to rc3. I dont find GetPixelSpan() any more. From git I only find references where devs speak about moving to GetPixelSpan() but not any mention of moving out from it. Any ideas why I dont find it any more?

[JimBobSquarePants]

Hi @burner-

GetPixelSpan() was replaced by TryGetPixelSpan(out Span<TPixel> pixels) in the RC1 release as part of #1109 where we introduced the ability to handle multi megapixel images via discontiguous buffers.

The method is documented in our API documentation

https://docs.sixlabors.com/api/ImageSharp/SixLabors.ImageSharp.Image-1.html#SixLabors_ImageSharp_Image_1_TryGetSinglePixelSpan_System_Span__0___

[antonfirsov]

Depending on use-case, #1258, and my #1258 (comment) might be also interesting/important.

[burner-]

Use-case is that image is always under 200kp so TryGetPixelSpan will probably work even with default settings at future. Thank you.
One more question to that topic. Is there way to get underlying pointer out? It will save us from one memory copy because another native library can do direct write to that pointer. Currently we make first memorymappedfile and use DangerousGetHandle() to get pointer out from it and then read that filespan to imagespan with memorymarshal. But I just wonder that can we get that pointer out directly from image without playing around that memorymappedfile?

[antonfirsov]

This depends on what are your plans with that pointer. Does it need to be persistent or a temporary? In other words: do you need to save it into a stateful object, or is it used as a method local to perform an operation then "forget" it?

Another question out of curiosity: why do you need a pointer? Why isn't a Span enough?

[burner-]

I like to use it as canvas for Libvlc. Check this https://github.com/mfkl/libvlcsharp-samples/blob/master/PreviewThumbnailExtractor/Program.cs
By my understanding it needs pointer. That marshal copy looks little odd because that lib uses pointer of pointer.

Currently I do like that but because I have only span I need use memorymappedfile first to get pointer and give it to vlc. vlc write that frame it it and then I get span what I give to imagesharp. Actually I dont even write bytes to file. My pipeline is memorymappedfile pointer -> vlc ->memorymappedfile span->imagesharp -> bytearray -> pixel reorder&bitwise transpose -> udp packet.
Reason why I use imagesharp in that pipeline is that vlc is not only image source so its good api for rest of pipeline and give possibility to resize and contrast correction.

[antonfirsov]

@burner- I don't really understand everything from what you described, but first impression is that you can probably optimize a lot. Not sure if they can fit your chain, but I'll give you a few suggestions (sorry if you already considered some of them and they are not applicable/useful for you):

1. If the reason to use memory mapped files, was only to get a pointer, you might consider using a managed array, and pinning it with the help of GCHandle.Alloc(array, GCHandleType.Pinned). The result handle will contain the pointer to the pinned array. You need to make sure to unpin it when you're done.

2. Read up a bit on how System.Memory primitives work. Very short summary:

• Span<T> represents a temporary stack-only reference to a memory region. You can temporarily pin it to get a pointer using the fixed (...) { } statement
• Memory<T> is persistent reference to a memory area that can be stored and saved. It can represent both managed, and unmanaged memory. It can be pinned to acquire a pointer.
• In case of unmanaged memory, IMemoryOwner<T> and MemoryManager<T> are responsible to represent the source of the memory.

If you are familiar with the basics, you have the following options:

2.1. To get a persistent (heapable) Memory<T> to the pixels of the image, you can use image.GetPixelMemoryGroup().Single()

2.2. Rather advanced stuff, but if you manage to understand IMemoryOwner<T> and MemoryManager<T> you can get rid of some unnecessary copies, and thread an unmanaged (eg. VLC) buffer as an Image<T>:

• Implement a custom MemoryManager like here that wraps your pointer so you can have a Memory<T> referencing it.
• Feed the Memory<T> to Image.WrapMemory(memory, width, height). The resulting Image<T> will not own the memory, but you can use it as a normal ImageSharp image, except that you are not allowed to apply processors changing the dimensions.