[UCI-Devel] Choosing Codecs

[<al...@fo...>]

Ok, I promised I'd discuss this in a bit more detail, so here's a start..

One of the things UCI was always intended to address was to make it easy for
applications to determine what codecs are available on a given system, and
choose the appropriate one to use for a given task.

In many cases this is easy..  "I need to decode a FooFormat stream, Ah, there's
a FooFormat codec, I'll use that".  The tricky bit comes when there are
multiple codecs able to handle the same format installed on the same system at
the same time (for example, XviD, FFMPEG, DivX, etc).

Obviously, ideally, the user would choose what codec they prefer for a given
application (and the plan is to provide a fair number of options for specifying
exactly this in UCI configuration files, and through the application itself if
it can provide such services) but there are many situations (particularly when
decoding streams) where it may not be possible (or desirable from the user's
perspective) to require that this be specified manually, so we also need some
(preferably reasonably good) way to choose the best default in such cases.

The big question:  How to choose between multiple codecs with the same
capabilities?

I've had a few ideas along these lines, but I'm really not happy yet with what
I've managed to come up with.. I'm hoping folks out there will have some ideas
I haven't thought of.

The most obvious way to decide things is based on what degree the given codec
supports all of the features/capabilities of a given format specification ("I
support 80% of the MPEG4 spec", etc).  This is pretty easy and obvious, but
what happens if multiple codecs support roughly the same feature set (as is
currently the case with various MPEG4 offerings, for example)?

The way I see it, there are a few different qualities which may be more or less
important to various applications (such as speed, quality, etc), which a
program may wish to choose based upon.  Certain qualities such as "image
quality" can be fairly objectively quantified, but even this may vary depending
on the parameters used (and may not vary the same way for different codecs).
Other qualities such as "speed" are almost impossible to get real objective (or
at least useful) numbers for, particularly across different codebases running
on different platforms..

This gets even more complicated, of course, when we get into the prospect of
transparently converting raw formats between apps and codecs to allow them to
communicate.  This results in additional "derived formats" to various codecs'
offerings, the qualities of which will be based both on what the codec's native
format offers, and any additional latency/quality-loss introduced by the
interim conversion done inside the UCI library (which means to report useful
numbers, the UCI library needs to know, for example, how the speed hit
introduced by the UCI-internal conversions compares to the over all speed of
the codec being used (and thus how much it changes any such numbers reported to
the app).  It's easy enough to just say "derived formats are less preferable
than native ones", but this may not always be the case..

So, thoughts?  suggestions?  Is it actually even possible to do this stuff
properly?  I really wanna hear what you guys think about all this..

-alex