luma | Luma is a lightweight , flexible CSS framework | Theme library

But I get an error saying the borrowed value does not live long enough.

Well yes, your typing of Target implies nothing about scoping, so as far as the Rust typesystem is concerned, the closure could just fly into space unbouded by time (e.g. add_listener could pass it to a separate thread), therefore outlive trigger_mutation, which means a does not live long enough.

There are two ways to resolve this issue:

Use Arc/Rc with interior mutability (resp. Mutex and RefCell) in order to relax the lifetime of a: Arc version[0], Rc version, this is probably the simplest, and the least restrictive on Target, though it comes at a runtime cost.

Alternatively you can "scope" Target to tell Rust that it doesn't escape, therefore everything's perfectly kosher. I'm not sure it's the best way (hopefully somebody else can contribute that information) but bounding the FnMuts on a lifetime will allow rustc to reason about this: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=e67a4ab0faa8cc5d01c75293623c9fb4

This is basically free at runtime, but it means Target can't really escape its function.

So the former is probably what you want, the latter seems not super-useful for an events / notification system, but YMMV.

[0] an Atomic* would also work for the Arc version and be a bit easier & cheaper than a mutex, though it probably isn't very relevant for a test case.

Please take a look at the details of the ImageProxy.PlaneProxy class; they planes are not just packed image data. They may have both row and pixel stride.

Row stride is padding between two adjacent rows of image data. Pixel stride is padding between two adjacent pixels.

Also, planes 1 and 2 in a YUV_420_888 image have half the pixel count of plane 0; the reason you're getting the same size is likely because of pixel stride being 2.

For some resolutions, the stride may be equal to width (usually the processing hardware has some constraint like the row stride has to be a multiple of 16 or 32 bytes), but it may not for all.

Like so:

The CRC calculation must be done reflected. (Clue in note on Table 9: "NOTE – CRC0 is the MSB of error detection codes.")

This C routine checks the CRCs in your example correctly:

The compiler's suggestion about "constraining the associated type ::Associated to Concrete" means that you need to request a concrete type for the associated type directly in the trait bound. This is done with the Trait syntax - e.g. to constrain I to an iterator that produces strings, you'd write I: Iterator. In the case of find_dark_pixels you'd request the Pixel associated type to be Luma as follows:

Since Camera-View 1.0.0-alpha16, createSurfaceProvider() has been renamed to getSurfaceProvider()

Use:

Change

I don't have an SH1106 to test with and I have never used the luma library, so there may be a much simpler way of doing what you want. If so, maybe someone will kindly ping me and I'll delete this answer.

I have used PIL quite a lot, so I looked in here around line 28:

Okay, I figured it out--part user error, part Apple bug. I was thinking of the vImage_Buffer's width and height wrong. For example, the output buffer I specified as 4*image_width, and 8 bits per pixel, when it should have been simply image_width and 32 bits per pixel--same amount of memory but sending the wrong message to the APIs. The literal '8' on that line blinded me from remembering what that slot was, I guess. A lesson I must have learned many times--name your magic numbers.

Anyway, now the bug part. Making the input and output buffers correct with regards to width, height, pixel depth fixed all the calls to the low level vImageConvert_420Yp8_Cb8_Cr8ToARGB8888 and friends. For example in the planar YCC case, your Cb and Cr buffers would naturally have half the width and half the height of the Yp plane. However, in the vImageConvert_AnyToAny cases these buffers caused the calls to fail and bail--saying silly things like I needed my Cb plane to have the same dimensions as my Yp plane even for 4:2:0. This appears to be a bug in some preflighting done by Apple before calling the lower level code that does the work .

I worked around the vImageConvert_AnyToAny bug by simply making input buffers that were too big and only filling Cb and Cr data in the top-left quadrant. The data were found there during the conversion just fine. I made these too-big buffers with vImageBuffer_Init() where Apple allocated the too-big malloc that goes to waste. I didn't try making the vImage_Buffer's by hand--lying about the size and allocating just the memory I need. This may work, or perhaps Apple will crawl off into the weeds trusting the width and height. If you hand make one, you better tell the truth about the rowBytes however.

I'm going to leave this answer for a bit before marking it correct, hoping someone at Apple sees this and fixes the bug and perhaps gets inspired to improve the documentation for those of us stumbling about.