Mer info här:
It doesn't look like this is just a set of filters, though; this looks like a new drawing API. That means that theoretically, this could also be used to re-implement Quartz in a fully-hardware-accelerated manner, rather than the limited form currently used in Quartz Extreme.
Well, there are a few different things at work here. First, Apple did indeed announce Quartz 2D Extreme, which is the hardware acceleration you mention (text, lines, image copies, etc. all hardware accelerated). The way it works is quite impressive actually.
CoreImage is really quite a piece of work. Probably the most impressive thing I've seen out of Apple (on a technical basis) in years. There are a number of facets to it, it isn't *just* about filters. It provides a nice hardware accelerated image API. This in itself would be a good thing.
However they way they chose to implement it allows for incredible flexibility.
Your average application will benefit from hardware accelerated UI drawing (assuming they don't use QuickDraw) without doing anything at all.
More savvy applications that manipulate images in various ways can benefit by having available to them a nice set of useful image manipulation tools: common things like rotation, scaling, blurring, sharpening... all hardware accelerated.
Even more specialized applications can have their own image manipulation kernels that do specific things to images. You write them in a C-like language, and CoreImage compiles them for your video card (or uses its native runtime if your video card doesn't support these things).
But it gets better: string a few filters together, and a code-path optimized filter is created for them, dynamically and automatically.
The geek factor is high, as is the usefulness in the real world. It offers performance and convenience of such magnitude that I'd be surprised if developers don't pick up on it quickly. The downside is that cross platform products like Photoshop, Premier, etc
People who don't know what they're talking about should STFU and stop confusing everyone who really wants to know this shit.
1) Motion does Not Use CoreImage or CoreVideo (currently). There's a lot of speculation here at the WWDC that the trade was the other way around: This tech was developed for Motion and then someone decided to put it in the OS. I feel fine saying this despite NDA because it's mostly speculation.
2) The software-fallback that CoreImage uses requires a separate drawing context (a SoftwareContext vs. Hardware). This means that it must be done manually, and that apps can choose to disallow non-realtime performance.
3) You can, indeed, dump output from CoreImage to either a screen or a bitmapContext. I didn't have a chance to ask about CoreVideo.
4) Quartz2D has been accelerated. It DOES REQUIRE some modification by application developers who use custom views, but not much. After modification, general UI speedup is 2x. Processor utilization goes way down.
5) Virtually everyone is in the same boat (including major developers like Adobe and Macromedia, and Apple itself): Adapting older technologies (like Quicktime and Final Cut Pro) to use this new stuff. It's going to take them a while, too. Same with CoreData.
6) The post above this one is INCORRECT. Quartz 2D Extreme in fact has an incredibly _small_ speedup for text rendering (close to 12x for normal on-screen amounts, much lower than simple shapes and whatnot. THIS IS DIFFERENT than the speedup for a typical Bezier path, but it's unclear why and I don't feel comfortable saying much more.
7) IMPORTANT: The optimizations made for the graphics pipeline in Quartz 2D will benefit ALL users, not just people with good graphics cards. Speedup will be smaller, but it definitely not be a speed-down.
8) TONS of effort has gone in to making sure that the various edge cases (tons of windows, tons of text, blah blah blah) are handled adequately. Your machine will NOT grind to a halt like some shitty 3D game when it has too much to do.
9) The CoreImage and CoreVideo frameworks are open and absolutely _incredible_. The way that the JITC works for the OpenGL shader language is such that you can actually go into the bundles and _see_ all the OGLSL programs that ship with CoreImage. Very Very Very cool shit.
So stop bitching, people. This is amazing shit, way the hell better than anything we had before. No one will be left behind, no one will be unhappy, and everything will be faster. Truly amazing stuff.
Även lite historik
First, there was Quartz 2D, which was a heavily modified version of the NeXT OS's Postscript renderer.
Drawing a window in Quartz 2D (OS X 10.0/10.1):
• Each view in the window (an element like a button, text box, picture, etc) is drawn into a hidden buffer (done on the CPU).
• This back buffer is copied to the area of the window visible on the screen (done on the GPU, using traditional 2D acceleration).
• Transparent elements of the window (drop shadows etc) are composited (blended) with other windows onscreen (done on the CPU, since traditional 2D acceleration cannot handle this, it just moves pixels around).
This was slow because the CPU still had a ton of work to do, and inefficient because the GPU had a ton of power that was not being used. So, Apple came up with Quartz Extreme.
Drawing a window in Quartz Extreme (OS X 10.2 and 10.3):
• Each view in the window (an element like a button, text box, picture, etc) is drawn into a hidden buffer (done on the CPU).
• The back buffer is uploaded to the video card as a texture. The back buffers of all visible windows are also stored as textures. (Done on GPU, if that wasn't obvious).
• All the windows are rendered with OpenGL by applying the textures to flat polygons. Transparent elements of the windows are handled automatically by hardware blending (done on GPU).
This was much better, since it removed a lot of grunt work from the CPU, and allowed the windowing system to do fun stuff like transparent OpenGL contexts, Expose, and the FUS spinning cube. But it's not as good as it could be. In Tiger, the last piece of the puzzle will be converted:
Drawing a window in Quartz 2D Extreme (10.4+):
• Each view in the window is rendered into an offscreen OpenGL context (done on the GPU). The CPU no longer has to do any rasterizing, which is something it's not very good at in the first place.
• The offscreen contexts are all converted to textures (this is done on the GPU, and much faster than uploading back buffers from main memory as Quartz Extreme did).
• The screen is rendered on the GPU.
The entire render pipeline is now on the GPU, so the CPU is freed up for everything else. That Apple was able to shove all this into the graphics system without breaking any existing apps is due to the multilayered, object-oriented design of Quartz from the beginning.
