Recently in Photoshop Category

We tried to be semantically agnostic in the original design of the Pixel Bender language. We'd seen other languages go down rabbit holes of over-specification around what parameters really meant, locking them into archaic and insufficient implementations or clumsy hierarchies of meanings. We didn't want to limit Pixel Bender developers into what we could conceive at the time of the invention of the language.

We were being a bit too idealistic :). It is completely true that the community of Pixel Bender developers continues to blow our minds at what they accomplish with the language and we never would have anticipated half the stuff that you guys are using Pixel Bender for. However, having some generally useful semantic meanings for Pixel Bender parameters would definitely help those who design general user interfaces for Pixel Bender filters.

One smart thing we did (if I do say myself) was to allow parameter and kernel metadata to be extensible. It provided developers like After Effects and Picnik a way to add custom metadata to Pixel Bender that specified semantics or actual UI controls for Pixel Bender kernels and graphs. The picnik metadata and the After Effects metadata are different though. I started to get concerned that by not having something around this that we could end up with many different Pixel Bender semantic metadata mechanisms floating around. To that end, I created the proposal below and started floating it around Adobe and some of the sites that are heavy users of Pixel Bender.

In this design, I tried to follow some general rules:

• Pixel Bender is not only a way to write image and video filters for Adobe applications, but also a way for you to host 3rd party filters in your Flash-based applications. Any guidelines we create need to be implemented by us, but also by any independent Flash developers creating apps that use Pixel Bender kernels. To that end, I tried to keep the design relatively simple so that it wouldn't be too difficult to implement in Flash.


• This proposal adds semantic metadata, but avoids specifying specific user interface controls. Rather than specifying a slider as an editor for a parameter, I think it makes more sense to say that the parameter is a percentage and allow someone designing a UI to make a good percentage editor. We are definitely thinking about how to specify custom editor UIs for Pixel Bender filters, but this proposal does not approach that.


• The proposal is not a complete answer for all Pixel Bender filters. I'm trying to get the most universal semantics represented. The most generally useful, as opposed to trying to give the complete solution. If you have an application that is uses Pixel Bender kernels for something that makes sense to augment the metadata you can still choose to do so.


• The proposal represents guidelines, not requirements. As a developer consuming Pixel Bender kernels, you can choose to enumerate the metadata as described in the proposal or not. The suggested metadata is metadata. It is not required. The goal is that if you wish to take advantage of it when it is present, that you can provide a more compelling user interface to your users because you understand the intent of a parameter, not just its type.
  

There are a couple open questions in the proposal that I'd like feedback on. They are called out pretty clearly. I'd really like your feedback on this proposal. I hope to issue the final version soon. Reply to this post or in the Pixel Bender forums on Adobe Labs. If you decide to post a reply on your own blog, please post a link to your post here or in the forum. Right now trackbacks are off so I won't know about it otherwise. You can also tweet a reply to the Pixel Bender twitter account (if you can fit it in 140 characters :) ).

Pixel Bender Metadata Hinting for User Interface Guidelines public proposal.pdf

The newest version of the Pixel Bender Toolkit has been released on Adobe Labs. This is pre-release 6, but it is also version 1.5. This new version includes the ability to edit, compile and run Pixel Bender Graphs (supported in Photoshop and After Effects). It also has a number of bug fixes, specifically in areas around PBJ generation.

You can get it from the Pixel Bender Technology area on Adobe Labs, and please let us know about any issues or suggestions for the next release in our forums, our Adobe Group or on twitter.

NVidia is really jazzed about the way that Pixel Bender shows off their GPUs in After Effects and in the Photoshop Pixel Bender plug-in. So much so that they've decided to hold a contest to see what Pixel Bender filters you guys can think up!

There are some really sweet prizes including an Alienware Area-51 PC and NVidia cards ('natch). I know I've seen some pretty killer stuff that you guys have been posting to your blogs and to the Pixel Bender Exchange. Now is your chance to really show off!

Here is the info from the press release:
NVIDIA Hosts Adobe Pixel Bender Creation Contest
NVIDIA and Adobe are joining forces to encourage artists and developers to write Adobe Pixel Bender™ Kernels for Adobe Creative Suite 4. The first place winner will receive an Alienware Area-51 Personal Computer. Category winners will receive a NVIDIA Quadro CX graphics card. The categories are coolest Pixel Bender kernel, most useful Pixel Bender kernel in the Adobe Photoshop® workflow, and most technically compelling.

Pixel Bender is a technology created by Adobe that enables a new way of enhancing and adding functionality to Photoshop and other Adobe applications like Adobe Flash and Adobe After Effects. The Adobe Pixel Bender technology delivers a common image and video processing infrastructure which provides automatic runtime optimization on heterogeneous hardware. You can use the Pixel Bender kernel language to implement image processing algorithms (filters or effects) in a hardware-independent manner without having to work with each application’s plug-in SDK. The Pixel Bender graph language is an XML-based language for combining individual pixel-processing operations (kernels) into more complex Pixel Bender filters. The most recent version of the Pixel Bender plug-in (1.1) for Photoshop CS4 was recently released by Adobe and is accelerated by the graphic processing unit (GPU).
More information on Pixel Bender can be found here.

The contest runs from January 1, 2009 to January 31, 2009.

Contest details here

Pixel Bender Demo from Kerry Garrison on Vimeo.

He gets the name wrong a few times, but it is a nice video anyway :)

There has been a lot of confusion around Pixel Bender and GPUs in CS4. Admittedly, some of it was caused by me :). I wanted to do a clarifying post about GPU, Pixel Bender, and multi-core and how apps in CS4 do different things.

One thing I wanted to correct is the assumption that GPU = FASTER. I've seen this misconception a lot, and I think it is confusing some people. The chips on graphics cards (GPUs) are extremely efficient processors capable of doing lots of math in parallel and have the benefits of fast local memory with a super fast connection to the processor. This makes them ideal for the kinds of things that Pixel Bender does. However, this super-efficient processor is connected to the main computer processor by a not-so-fast connection, the bus. Moving data on and off of the GPU is expensive relative to doing things on the GPU directly. What this means is that if you want to do something on the CPU with some data then do something on the GPU and then use the output of the GPU on the CPU again, it might be more expensive than having just done the whole thing on the CPU in the first place. The overhead of the bus transfers can overwhelm the benefits of the fast GPU computation. The busses are getting faster, and when things will work better in one place vs. another is very different from machine to machine. There are a ton of other details I'm glossing over. I'm just trying to make a central point here: that the GPU is not always faster than the CPU.

Pixel Bender is designed to run very efficiently on the GPU, but that design also allows it to execute extremely efficiently on a multi-core CPU. In Flash Player 10, Pixel Bender does not run on the GPU, it does run multi-threaded and executes really fast, especially on multi-core and multi-processor chips (see Tinic's post for more info). The Flash team really has done an outstanding job with their JITter and their multi-threading and Pixel Bender runs pretty darn fast on every machine I've tried (from a lowly single core based laptop to an 8-core Penryn MacPro).

In After Effects CS4, all the OpenGL effects including the new Cartoon Effect, Turbulent Noise, and Bilateral Blur effects are written in Pixel Bender and can run on the GPU or CPU. When don't they run on the GPU? When you have a non-GPU effect following them in the effects chain on the layer. In those cases, it isn't clear if you would have a performance gain by running on the GPU. Cartoon is the exception. The algorithm is complex enough that AE assumes it is always faster on the GPU. All 3rd party Pixel Bender filters run multi-threaded on the CPU. This was an architectural decision.

In the Photoshop plug-in, Pixel Bender filters always run on the GPU if you have a graphics card that is supported by CS4. In other cases, the filters run multi-core. The new canvas rotate-pan-and-zoom and the gigantor image support are all done using the GPU. John Nack has lots of details on his blog. One thing I wanted to correct about Photoshop CS4: it is not using CUDA. Not sure how this rumour got out there, but it isn't true. Not that we aren't fans of CUDA, we just aren't shipping anything that uses it in CS4.

There are other apps in CS4 with GPU support, but I wanted to keep this post to the ones that support Pixel Bender, just to clear up the confusion.

Oh, it is sooo nice to be able to use the letters CS4! Finally, I can let the cat out of the bag on some of the stuff that the Adobe Image Foundation team has been working on since CS3 shipped.

First, I'll cover the stuff that you might already know because we'd announced it before yesterday:

• Flash 10 supports Pixel Bender bytecode for custom effects, blends, and number crunching. It runs very efficiently multi-threaded thanks to Tinic. You can export Pixel Bender bytecode from the Pixel Bender Toolkit.


• We will be shipping a free extension for Photoshop CS4 soon that will let you run Pixel Bender filters as well. John Nack demoed this at Photoshop World and blogged about it. These effects run on your computer's Graphics card for super fast performance if you have a card that supports them (most do).

• After Effects CS4 supports Pixel Bender filters natively. The existing GPU-accelerated filters are Pixel Bender based and AE CS4 will also automatically load any 3rd party Pixel Bender filters that are put into a known directory.


• The 1.0 version of the Pixel Bender Toolkit will be available to be installed as part of the After Effects and Flash Authoring CS4 installs.

• In addition to Pixel Bender Kernels (pbk) and Pixel Bender Bytecode (pbj), there is another Pixel Bender format. Pixel Bender Graphs (pbg). Pixel Bender Graphs are supported directly in After Effects CS4 and the Photoshop Pixel Bender extension. Pixel Bender Graph is an xml-based format that allows you to combine a network of Pixel Bender Kernels into a single effect for WAAAY more powerful filters. We'll be posting a new version of the toolkit soon that supports the editing of these graphs and we'll also be posting a specification for them soon on Adobe labs.


• We're adding another tool to the Pixel Bender authoring arsenal. There have been a bunch of 3rd party developers who want to create tools that generate Pixel Bender. To make it easier for them, we'll be releasing a command-line utility that will allow you to compile a Pixel Bender Kernel file into a Pixel Bender Bytecode file. The work on this is complete. Look for this on labs very soon.

Got questions? Ask in the comments or on the Pixel Bender forum...

At the Photoshop World conference last week, Johnny Loiacono and John Nack demoed some new Photoshop coolness. If you missed it there is a video of it at The Creative Suite Podcast. Especially cool was the prominent use of some of the technology from the Adobe Image Foundation team.

The sweet super-fast scrolling and zooming was built on top of Adobe Image Foundation technology by the Photoshop team. In the video, it starts at 16:40.

Johnny and John also showed Pixel Bender filters running in Photoshop for the first time ever. That is at 32:10. This is something that we've been working on for a long time and it was great to see it get such a massive roll out.

Expect more news from me about Pixel Bender and Photoshop soon...