UIImage + Effects for iOS 7 Blur Effect Slowing App Down - 450MB?

Question

This is how I blur a UIImage called artworkImage using UIImage+Effects to get the iOS 7 blur effect:

-(void)viewDidAppear:(BOOL)animated{

    MPMediaItem *currentItem = [self.musicPlayer nowPlayingItem];

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0ul), ^(void) {
        @autoreleasepool {

            MPMediaItemArtwork *artwork = [currentItem valueForProperty: MPMediaItemPropertyArtwork];
            UIImage *artworkImage = [artwork imageWithSize: CGSizeMake (618, 618)];

            artworkImage = [artworkImage applyDarkEffect];

            dispatch_async(dispatch_get_main_queue(), ^{

                [backgroundImageView setImage:artworkImage];

                UIGraphicsEndImageContext();
            });
        }
    });
}

My app is really slow so I researched how to find out why, and I came across Instruments, which showed me this:

So I researched some more how to solve this, and came across dispatch_async, so I put the actual blurring into the background and updating the UI in the front. It's still terribly slow.

This UIImage called artworkImage updates every time the music player skips song. I apply the iOS 7 blur effect from Apple's sample projects, called UIImage+Effects.h, to this UIImage.

Please advise me on what to do - I've searched countless threads which all say use autorelease, which I can't of course use with ARC.

Any help would be much appreciated, thanks.

Answer 1

What's most likely happening here is that you're building up a series of UIImages from the above processing, causing your application to eventually exhaust memory and crash.

Apple's UIImage+Effects category does blurring CPU-side using a series of box blurs. It's not the fastest process in the world. In addition to that, creating a UIImage can be slow, as is setting a UIImage to a UIImageView for display. Almost all of that is done on the CPU, rather than the GPU.

Therefore, if you trigger the above method every time you update a UI element, you will be dispatching a series of blocks first to the default background queue, then asynchronously to the main queue. The latter is most likely where your memory buildup is occurring, since every block there will retain the objects within it. If your processing and UIImageView updating takes longer than the interval at which the above method is triggered, you will build up blocks in your dispatch queues and each of those blocks will have UIImages within them. This will quickly cause memory buildup and a crash.

There are two ways to approach this. First, you could use dispatch semaphores to make sure that only one block is every running on your background queues. I describe a process that I use for this here. This would prevent the memory accumulation, but might not help with your blurring speed.

For that, you could look at an alternative to the blurring category Apple provides. My open source GPUImage framework has a GPU-accelerated blur that replicates Apple's default effect. If you need the darker variant of that, I talk a bit about how to modify that for this here. Going to and from UIImages is still slow, but by piping the blur through to a GPUImageView instead of a UIImageView, you'll at least replace the latter half of the slow processing you have here. Filtering directly to a GPUImageView for display keeps all of that on the GPU.

Answer 2

i'm using Stackblur

https://github.com/tomsoft1/StackBluriOS

very easy to use, and good optimisation.