Monday, July 4. 2005why KDEMM?Trackbacks
Trackback specific URI for this entry
No Trackbacks
Comments
Display comments as
(Linear | Threaded)
[*]KDEMM does not target pro-audio development, because we cannot guarantee the performance of the backend the user will choose and because the API should be simple (though still powerfull for media player developers). [*]The most critical part of looking at speed is when you're calling play/pause/stop, because that's the only point where KDEMM could really be the guilty one making the whole thing take longer. But if the backend is written in a way that the flow graph/pipelines are set up before play is called the first time, the overhead will not be noticable. [*]The decoding, and processing speed (and CPU usage) is unchanged by using KDEMM because all KDEMM does, is to provide a different API to setting up the flow graph/pipelines of the media framework. [*]link time? I guess you don't mean the linking after compiling but the time it takes for the app to link in all the shared libs on startup... So at least on startup it should be faster than using a media framework directly because it only needs to load the kdemm lib. But at some point the application initializes KDEMM and at this point the backend is loaded. This of course results in an overall longer linking time, but if the app takes care to first create and show the GUI and then initialize KDEMM the user will not notice at all. [/list:o] I can see the point of a very thin layer, encapsulating multiple engines for system sound, ktts pass through, but it doesn't make any sense, if any extra functionality produces even the slightest overhead. I don't get your point. What is a pain about aRts/aKode? Using it as a developer? Using it as a KDE user? Where is the pain? How do crash reports tell you that users hate "it"? Yes, when it crashes I don't go like 'Yay, one more!', but at least for most people aRts just works (and aKode even more so). [quote]When you intend doing something similar, what's the guarantee it doesn't lead to the same mess like aRts?[/quote] Where did I say that I intend to write another media framework? Where did I say that I want to create a big complicated middleware/CORBA redesign? I'm defining a rather simple multimedia API... I can guarantee, that KDE people will be able to understand and work with the KDEMM code. And that is a major advantage compared to the aRts codebase that intentionally didn't have a Qt dependency and had it's own multimedia enabled CORBA implementation. This will surely lead to more people being able to maintain KDEMM than there were to maintain aRts. [quote]I can see the point of a very thin layer, encapsulating multiple engines for system sound, ktts pass through, but it doesn't make any sense, if any extra functionality produces even the slightest overhead.[/quote] Again I cannot follow what you want to tell me. I have the feeling you did not quite grasp the scope of what KDEMM is about... concerning overhead: please be more specific. I have no idea what in the world you might have been thinking about when you wrote this. 1 - Using gst directly is the faster way to do it 2 - Using a thin wrapper is slower both in call time and link time (yeah I mean dlopen) 3 - Can a general API show all the power of the back end? If not, then (some) developers will go directly to the backend 4 - Is it really a need? 5 - Users can change the backend 6 - KDE does not stick to one engine 7 - Using gst would make it the de-facto standard It's not faster for application developers. Quite the contrary. Using a media framework is considerably harder than using Qt/KDE only. Especially when all you're used to is the Qt object model and then have to use a glib API. Yes, you can fix that by using gst-qt bindings. But there we have our additional layer again... [quote]2 - Using a thin wrapper is slower both in call time and link time (yeah I mean dlopen)[/quote] It might be measurable when profiling the code. But the important question is: will the user notice? In the end, I think, what is possible is that, while using a few more CPU cycles, the user experience is not changed (if it's changed, then to the better, because the application developer has more time to concentrate on the GUI as if he'd be using gst directly). [quote]3 - Can a general API show all the power of the back end? If not, then (some) developers will go directly to the backend[/quote] It could, but that's not the goal of KDEMM. The API was designed by collecting use cases. So the API should reflect what the developer wants to get done and not what the media framework provides. If there are any KDE developers (not developing a pro-audio application) looking at the API and it's not good enough for them, then KDEMM is not good enough, yet. For "special purpose media framwork usage" [quote]4 - Is it really a need?[/quote] Not in a way that it opens a lot of new features that we couldn't have without it. But, like I said in the original blog entry: [quote="myself"]Why do we see so few applications with multimedia capabilities in KDE? I believe it's because it's not clear what API/library to use, and hard to understand how to use them. The entry barrier to using multimedia in your application is very high. Providing an API that is similar in style to what KDE developers are used to and limited in scope, so that it doesn't take a few days of studying the concepts, will solve those two problems. Ideally a KDE developer would only need to look over the API and already start to grasp how this thing will work.[/quote] [quote]5 - Users can change the backend 6 - KDE does not stick to one engine[/quote] Yay. I like that. [quote]7 - Using gst would make it the de-facto standard[/quote] Yes, probably. And a long time ago GNOME using aRts would have made aRts the de-facto standard... But gst is not the only thing out there. It's good and will very likely be the default backend for KDEMM, but I'm not convinced that it is the best there can ever be - for everybody and every use case. [quote]Using a media framework is considerably harder than using Qt/KDE only. Especially when all you're used to is the Qt object model and then have to use a glib API. Yes, you can fix that by using gst-qt bindings. But there we have our additional layer again...[/quote] Qt/KDE programing is lovely and easy. Many devs may not add MM if it's not familiar with the API. And I'd not like to touch glib semantic with my own hands But pleeeeease, make it fast PD: Slower is slower, may be not (user) noticeable but it continue to be slower PD2: Paranoid about speed? yes, since I saw e17 There's no reason to make KDEMM sluggish. Though actually if your using x86-64 it isn't possible to install Helix Player or Real Player which is required to actually play anything. We'd still be interested in the error you got though. Xine (no matter what xine frontend) used to immediately crash for me on my x86-64 proc as well. However it just randomly started working, no idea what the issue was. mplayer can't be a backend since it doesn't have a library. Regarding the rest of this thread, I don't really see how an API would really introduce much latency at all. That's all I'll put in this message to make it less confusing. Actually both use GStreamer directly at this point. That's probably also what Christian meant when he said [quote="Christian Loose"]something very similar to KDEMM[/quote] and that's also what I was talking about in my original post. If you are, may I ask why you think I am wasting my time? But, again I don't see why you would think that KDEMM applies for "going overboard". I value every helpfull comment, but as long as you cannot state what it is that makes KDEMM "go overboard" there's nothing to discuss. And, btw, if done right, abstraction comes with advantages. The goal then is to have those advantages outweigh the disadvantages. Talk of: A wrapper would be too bloated / have too much latency, etc strike me as a bit strange... It's a bloody thin wrapper!!! In the context of the broader KDE desktop (or any other modern desktop) this should definitely be doable in a way that isn't too punitive. I mean really, this is KDE- Everything is pluggable on a global scale. The one exception to this has been multimedia-- and KDE has reaped the rewards. Pretty much any KDE media app you'd want to use has implemented it's own 'choose your back end scheme' or chose some other back end that isn't ARTS. This is fine but it represents a fair bit of duplicated effort I'm sure... Seeing app developers running screaming away from ARTS and all doing it their own way should be a big neon sign that says, "Problem!"... This means that KDE users have to set up their preferred back-end for every media app they use, and this is a pain for non-technical users. Heck, even on my lone desktop system with 4 user accounts (x3 or 4 programs) this is a pain... and I think KDEMM would address this problem... Oh, did I mention I'd be able to banish ARTS I'll also throw in that gstreamer seems to give a lot problems compared to xine. Just doesn't seem to be as mature. So I wonder why the buzz always seems to center around gstreamer. Anyways, I think a KDEMM api is a great idea. I'm from the Show-Me State, so I'll reserve judgement until there's something to see. I think the idea of KDEMM is very good because of this. All the KDE multimedia apps uses KDEMM, so you just try with "library" works better in your system (gstreamer, akode, mplayer, xine, arts?), and when you set KDEMM up and you can play sound well, you have all the multimedia apps working at the same time. Isn't that an advantage? I would say it is. IMO make aRts and KDEMM a single, unified system with all the bells and whistles you can imagine. I might even write an aRts backend for KDEMM... So please, if GStreamer can handle this stuff at all, then use it. Otherwise, pick the best, and lead with it, rather than treading water and holding up everyone else. And obviously multiple backends increase maintaince cost. Whether or not you have multiple backends, its really just good sense to have an abstract layer between the actual backend implementation and client code. Like, if KDE were to pick gstreamer without an abstract API that would mean KDE devs would have to learn GLib programming. And every time gstreamer broke ABI, KDE would as well. Etc. And there are a handful of good reasons to develop multiple backends. Like NMM isn't for everyone but it does add features not found in other backends and the Windows port could use the Microsoft API's. But if KDE develops a gstreamer backend, it really dosen't make any sense to have a xine backend... |
Calendar
QuicksearchCategoriesBlog Administration |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||