Support Your Friendly Neighborhood FLOSS Charities

Post Syndicated from Bradley M. Kuhn original

I don’t think we talk enough in the FLOSS community about the importance of individual support of FLOSS-related charitable organizations.
On a
recent podcast episode, Karen and I discuss
with Stormy Peters how
important it is for geeks — who may well often give lots of code
to many FLOSS projects — also should consider giving a little bit
of financial funding to FLOSS organizations as well.

Of course, it’s essential that people give their time to the charities
and the causes that they care about. In the FLOSS world, we typically
do that by giving code or documentation to our favorite FLOSS project.
I think that’s led us all into the classic “I gave at the
office” feeling. Indeed, I know that I too have fallen into this
rut at times myself.

I suppose I could easily claim that, more than most people, I’ve given
enough at the office. Working at various non-profit organizations since
the 1990s, I’ve always made substantially less in salary than I would in
the for-profit industry for similar work. I also have always
volunteered my time in addition to my weekly work schedule. For
example, I currently get paid for my 40 hour/week job at the SFLC, but I
also donate about 20 hours of work for
the Software
Freedom Conservancy
each week.

Still, I don’t believe that this is enough. There
are many,
many FLOSS non-profits
that deserve support — more than I have time to give. Meanwhile, very small
amounts of money, aggregated over many people giving, makes a world of
difference in a number of ways to these organizations.

Non-profits that are funded by a broad base of supporters are much more
stable and have greater longevity than other types of non-profits that
are funded primarily by corporate donations. This is because one donor
or even a few disappearing is not disaster. Also, through these donations, organizations
build a constituency of supporters that truly represent the people
that the non-profit seeks to serve.

Traditionally (with a few notable exceptions), non-profits in the FLOSS
world have relied primarily on corporate donations. I generally think
this is not ideal for a community that wishes to be fully represented by
the non-profits that embody the projects we care about. We want these
projects to represent the interest of developers and users, not
necessarily the for-profit corporate interests. Plus, we want the
organizations to survive even when companies stop supporting FLOSS or
just simply go out of business.

If we all contribute, it doesn’t take that much for each individual to
be a part of making a real difference. I believe that if each person
who has benefited seriously from FLOSS gave $200/year, we’d make a
substantial change and a wonderful positive impact on the non-profit
organizations that shepherd and keep these FLOSS projects alive. I’m
not suggesting giving to any specific organization: just to take
$200/year and divide in the way you think is best across 2-4 different
FLOSS non-profits that sponsor project you personally care about or
benefit from.

Think about it: $200/year breaks down to $16/month. For me (and likely
for most people in a major city), $16/month means one fewer dinner at a
restaurant each month. Can’t we all eat at home one more time per
month, and share that savings to help FLOSS non-profits?

If you are looking for a list of non-profits that could use your
Foundations Directory
is a good place to start. FWIW, in addition
to my volunteer work
with Conservancy,
here’s the list of non-profits that I’m supporting with a total of $200
this year (in
alphabetical order): The Free
Software Foundation
, The Parrot
and The
Twisted Project
. Which ones will you give to this year?

Fork Well: It Could Be The Last, Best Hope for Community

Post Syndicated from Bradley M. Kuhn original

I have faced with much trepidation the news of Oracle’s looming purchase
of Sun. Oracle has never shown any interest in community development,
particularly in the database area. They are the largest proprietary
database vendor on the planet, and they probably have very simple plans
for MySQL: kill it.

That’s why I read with relief
post by Monty (co-founder of the MySQL project) this week
, wherein
Monty plans (and encourages others, too) to put their full force behind
a MySQL “fork” that will be centered outside of Oracle.

Monty is undoubtedly correct when he says I don’t think that anyone
can own an open source project; the projects are defined by the de-facto
project leaders and the developers that are working on the project.

and that [w]ith Oracle now owning MySQL, I think that the need for an
independent true Open Source entity for MySQL is even bigger than ever

I don’t find the root of this problem in that one company has sold
itself to another, pursuant to the the greater glory of the
Rules of Acquisition
. Instead, I think the error is that projects
inside Sun did not have a non-profit entity to shepherd them. When a
single for-profit company is in control of a project’s copyrights, its
trademarks, and employs nearly all its core developers, there is a gross
imbalance. The community around the project isn’t healthy, and can
easily be disrupted by the winds of corporate change, which blow in
service of the only goal of for-profit existence: higher profits.

I encourage Monty, as well as core developers of VirtualBox,
OpenOffice, OpenSolaris, Sun’s Java, and any other project that is
currently under the full control of Sun (or indeed any other for-profit
corporation) to think about this idea. Non-profits, particularly
501(c)(3)’s, are fundamentally different than for-profits. They exist
to serve a community or a constituency and the public good, never
profit. Therefore, the health of the codebase, the diversity of the
developer and user community, and the advancement of software freedom
can be the clear mission of a non-profit that houses a FLOSS project. A
non-profit ensures that while corporate funding comes and goes, the
mission of the project and its institutional embodiment stay stable.
For example, just like shareholders have a duty to fire a CEO when he
fails to make enough profit (i.e., the for-profit company is not
reaching its maximal goal), boards of directors and/or memberships of
non-profits must fire the President and/or Executive Director when they
fail to serve the community well. Instead of the “profit
motive”, 501(c)(3)’s have the “community motive”.

Yet, the challenge of focusing on such goals remains difficult for
projects that did not spawn from a community to start. GNU and Linux
were both started by individual developers that built strong communities
before there was any for-profit corporate interest in the software.
When a project started inside a company with profit in mind, shoehorning
community principles into the project can rarely succeed. I believe
that a community must usually evolve from the ashes of some incident
that wakes everyone up to realize the project will come to harm due to
strict adherence to the profit motive.

I should probably remind everyone that I’m not opposed to capitalism
per se. Indeed, I’ve often fought on the other side of this equation
when licenses (such as MySQL’s own very early pre-GPL license) permit
noncommercial use but prohibit commercial use. I believe that
commercial and non-commercial activity with the code should be
equally permitted in a non-discriminatory way. However, the center of
gravity for developers, where the copyrights and trademarks live, and
how core work on the codebase is funded are all orthogonal questions to
the question of the software’s license.

My experience has anecdotally taught me that FLOSS communities function
best when the following two things are true: (a) the codebase is held
neutrally, either in the hands of the individual developers who wrote
the code, or in a 501(c)(3) non-profit, and (b) not too many core
developers share the same employer. I believe that reaching that state
should be Job One of any for-profit seeking to build a FLOSS community.
Sadly, this type of community health is often at direct odds with
the traditional capitalist thinking of for-profit shareholders.
I’m thus not surprised when FLOSS community managers in for-profit
companies can only do so much. The rest is really up to the community
of developers to fork and demand that a non-profit or other neutral and
diverse developer-controlled management team exist. Attempts at this,
sadly, fail much more often than they succeed.

Monty’s post likely had more hope in it than this one. Monty didn’t
jump to my conclusion that Oracle will kill MySQL; Monty considers it
also possible that Oracle might sell MySQL or (and here’s the
possibility I really doubt) that Oracle will change into a
community-driven FLOSS company. I love Monty’s optimism in even
considering this possible. I honestly hope my pragmatism about this is
shown to be sheer pessimism. In the meantime, focusing on the MySQL
forks and pressuring Oracle to engage the FLOSS community in a genuine
way is the best strategy no matter what outcome you think is most

Update (on 17 May 2009):
Monty announced
an industry consortium
that will seek to be a neutral space for
MySQL development. I tend to prefer charitable non-profits to trade
associations, but better the latter than hoping for Oracle to do the
right thing.

All About Fragments

Post Syndicated from Lennart Poettering original

In my on-going series Writing
Better Audio Applications
for Linux, here’s another
installment: a little explanation how fragments/periods and buffer
sizes should be chosen when doing audio playback with traditional
audio APIs such as ALSA and OSS. This originates from some emails
I exchanged with the Ekiga folks
. In the last weeks I kept copying
this explanation to various other folks. I guess it would make sense
to post this on my blog here too to reach a wider audience. So here it
is, mostly unedited:

Yes. You shouldn't misuse the fragments logic of sound devices. It's
like this:

   The latency is defined by the buffer size.
   The wakeup interval is defined by the fragment size.

The buffer fill level will oscillate between 'full buffer' and 'full
buffer minus 1x fragment size minus OS scheduling latency'. Setting
smaller fragment sizes will increase the CPU load and decrease battery
time since you force the CPU to wake up more often. OTOH it increases
drop out safety, since you fill up playback buffer earlier. Choosing
the fragment size is hence something which you should do balancing out
your needs between power consumption and drop-out safety. With modern
processors and a good OS scheduler like the Linux one setting the
fragment size to anything other than half the buffer size does not
make much sense.

Your [Ekiga's ptlib driver that is] ALSA output is configured
to set the the fragment size to the size of your codec audio
frames. And that's a bad idea. Because the codec frame size has not
been chosen based on power consumption or drop-out safety
reasoning. It has been chosen by the codec designers based on
different reasoning, such as latency.

You probably configured your backend this ways because the ALSA
library docs say that it is recommended to write to the sound card in
multiples of the fragment size. However deducing from this that you
hence should configure the fragment size to the codec frame size is

The best way to implement playback these days for ALSA is to write as
much as snd_pcm_avail() tells you to each time you wake up due to
POLLOUT on the sound card. If that is not a multiple of your codec
frame size then you need to buffer the the remainder of the decoded
data yourself in system memory.

The ALSA fragment size you should normally set as large as possible
given your latency constraints but that you have at least two
fragments in your buffer size.

I hope this explains a bit how frag_size/buffer_size should be
chosen. If you have questions, just ask.

(Oh, ALSA uses the term 'period' for what I call 'fragment'
above. It's synonymous)

TomTom/Microsoft: A Wake-Up Call for GPLv3 Migration

Post Syndicated from Bradley M. Kuhn original

There has been a lot of press coverage about the Microsoft/TomTom
settlement. Unfortunately, so far, I have seen no one speak directly
about the dangers that this deal could pose to software freedom, and
what our community should consider in its wake. Karen and I discussed
some of these
details on
our podcast
, but I thought it would be useful to have a blog post
about this issue as well.

Most settlement agreements are sealed. This means that we won’t ever
actually know what TomTom agreed to and whether or not it violates
GPLv2. The violation, if one exists, would likely be of GPLv2’s §
7. The problem has always been that it’s difficult to actually witness
a v2§7 violation occurring (due in large part to less than perfect
wording of that section). To find a violation v2§7, you have to
discover that there were conditions imposed on [TomTom] … that
contradict the conditions of [GPLv2]
. So, we won’t actually know if
this agreement violates GPLv2 unless we read the agreement itself, or if
we observe some behavior by Microsoft or TomTom that shows that the
agreement must be in violation.

To clarify the last statement, consider the hypothetical options. For
TomTom to have agreed to something GPLv2-compliant with Microsoft, the
agreement would have needed to either (a) not grant a patent license at
all (perhaps, for example, Microsoft conceded in the sealed agreement
that the patents aren’t actually enforceable on the GPLv2’d components),
or (b) give a patent license that was royalty-free and permitted all
GPLv2-protected activities by all recipients of patent-practicing
GPLv2’d code from TomTom, or downstream from TomTom.

It’s certainly possible Microsoft either capitulated regarding the
unenforceability (or irrelevancy) of its patents on the GPLv2’d software
in question, or granted some sort of license. We won’t know directly
without seeing the agreement, or by observing a later action by
Microsoft. If, for example, Microsoft later is observed enforcing the
FAT patent against a Linux distributor, one might successfully argue
that the user must have the right to practice those
Microsoft patents in the GPLv2 code, because otherwise, how was TomTom
able to distribute under GPLv2? (Note, BTW, that any
redistributor of Linux could make themselves downstream from TomTom,
since TomTom distributes source on their website.) If no such
permission existed, TomTom would then be caught in a violation —
at least in my (perhaps minority) reading of GPLv2.0

Many have argued that GPLv2 § 7 isn’t worded well enough to
verify this line of thinking. I and a few other key GPL thinkers
disagree, mainly because this reading is clearly the intent of GPLv2
when you read the Preamble. But, there are multiple interpretations of
GPLv2’s wording on this issue, and, the wording was written before the
drafters really knew exactly how patents would be used to hurt Free
Software. We’ll thus probably never really have complete certainty that
such patent deals violate GPLv2.

This TomTom/Microsoft deal (and indeed, probably dozens of others like
it whose existence is not public, because lawsuits aren’t involved)
almost surely plays into this interpretation ambiguity. Microsoft
likely convinced TomTom that the deal is GPLv2-compliant, and that’s why
there are so many statements in the press opining about its likely GPLv2
compliance. I, Jeremy Allison, and others might be in the minority in
our belief of the strength of GPLv2 § 7, but no one can disagree
with the intent of the section, as stated in the Preamble. Microsoft is
manipulating the interpretation disagreements to convince smaller
companies like Novell, TomTom, and probably others into believing that
these complicated patent licensing deals and/or covenants are
GPLv2-compliant. Since most of them are about the kernel named Linux,
and the Linux copyright holders are the only ones with power to enforce,
Microsoft is winning on this front.

Fortunately, the GPLv3 clarifies this issue, and improves the
situation. Therefore, this is a great moment in our community to
reflect on the importance of GPLv3 migration. The drafters of GPLv3, responding to the Microsoft/Novell deal,
considered carefully how to address these sorts of agreements.
Specifically, we have these two paragraphs in GPLv3:

If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.

A patent license is “discriminatory” if it does not include
within the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is in
the business of distributing software, under which you make payment to the
third party based on the extent of your activity of conveying the work,
and under which the third party grants, to any of the parties who would
receive the covered work from you, a discriminatory patent license (a) in
connection with copies of the covered work conveyed by you (or copies made
from those copies), or (b) primarily for and in connection with specific
products or compilations that contain the covered work, unless you entered
into that arrangement, or that patent license was granted, prior to 28
March 2007.

Were Linux under GPLv3 (but not GPLv2), these terms, particularly those
in the second paragraph, would clearly and unequivocally prohibit TomTom
from entering into any arrangement with Microsoft that doesn’t grant a
license to any Microsoft patent that reads on Linux. Indeed, even what
has been publicly said about this agreement seems to indicate strongly
that this deal would violate GPLv3. While the Novell/Microsoft deal was
grandfathered in (via the date above), this new agreement is not. Yet,
the most frustrating aspect of the press coverage of this deal is that
few have taken the opportunity to advocate for GPLv3 adoption by more
projects. I hope now that we’re a few weeks out from the coverage,
project leaders will begin again to consider adding this additional
patent protection for their users and redistributors.

Toward the goal of convincing GPLv2 users to switch to GPLv3, I should
explain a bit why special patent licensing deals like this are bad for
software freedom; it’s not completely obvious. To do so, we can look
specifically at what TomTom and Microsoft said in the press coverage of
their deal: The agreement protects TomTom’s customers under the
patents …, the companies said

TomTom Settle Patent Dispute
, Ina Fried).

Thus, according to Microsoft and TomTom, the agreement gives some sort
of “patent protection” to TomTom customers,
and presumably no one else. This means that if someone buys a
GNU/Linux-based TomTom product, they have greater protection from
Microsoft’s patents than if they don’t. It creates two unequal classes of
users: those who pay TomTom and those who don’t. The ones who don’t pay
TomTom will have to worry if they will be the next ones sued or attacked
in some other way by Microsoft over patent infringement.

Creating haves and have-nots in the software licensing space is
precisely what all versions of the GPL seek to prevent. This is why the
Preamble of GPLv2 said: any free program is threatened constantly by
software patents. We wish to avoid the danger that redistributors of a
free program will individually obtain patent licenses, in effect making
the program proprietary.

Further to this point, in
the Rationale
Document for the Third Discussion Draft of GPLv3
, a similar
argument is given in more detail:

The basic harm that such an agreement can do is to make the free
software subject to it effectively proprietary. This result occurs to the
extent that users feel compelled, by the threat of the patent, to get
their copies in this way. So far, the Microsoft/Novell deal does not seem
to have had this result, or at least not very much: users do not seem to
be choosing Novell for this reason. But we cannot take for granted that
such threats will always fail to harm the community. We take the threat
seriously, and we have decided to act to block such threats, and to reduce
their potential to do harm. Such deals also offer patent holders a crack
through which to split the community. Offering commercial users the chance
to buy limited promises of patent safety in effect invites each of them to
make a separate peace with patent aggressors, and abandon the rest of our
community to its fate.

It’s true that one can blissfully use, redistribute, sell and modify
some patent-covered software for years without ever facing a patent
enforcement action. But, particularly in situations where known patents
have been asserted, those without a patent license often live in fear of
copying, modifying and sharing code that exercises the teachings of the
patent. We saw this throughout the 1990s with RSA, and today most
commonly with audio and video codecs. Microsoft and other anti-Free
Software companies have enough patents to attack if we let them. The
first steps in stopping it are to (a) adopt GPLv3, LGPLv3 and AGPLv3
with the improved patent provisions, and (b) condemning GPLv2-only deals
that solve a patent problem for some users but leave the rest out in the
cold, and (c) pointing out that the purported certainty that such deals
are GPLv2-compliant is definitely in question.

Patents always remain a serious threat, and, while the protection under
GPLv2 has probably been underestimated, we cannot overestimate the
additional protection that GPLv3 gives us in this regard. Microsoft
clearly knows that the GPLv3 terms will kill their patent aggression
business model, and have therefore focused their attacks on
GPLv2-licensed code. Shouldn’t we start to flank them by making less
GPLv2 code available for these sorts of deals?

Finally, I would like to draw specific attention the fact that TomTom,
as a company, is not necessarily an ally of software freedom. They are
like most for-profit companies; they use FLOSS when it is convenient for
them, and give back when the licenses obligate them to do so, or when it
behooves them in some way. As a for-profit company, they made this deal
to please their shareholders, not the Free Software community. Admittedly, their use of the FLOSS in their
products was done legitimately (that
is, once
their GPLv2 non-compliance was corrected by Harald Welte in 2004
However, I do not think we should look upon TomTom as a particularly
helpful member of the community. Indeed, most of the patents that
Microsoft asserted against TomTom were on their proprietary components,
not their FLOSS ones. Thus, most of this dispute was a proprietary
software company arguing with another proprietary software company over
patents that read on proprietary software. Our community should tell
TomTom that if they want to join and support the FLOSS world, they
should release their software under a FLOSS license — including
software that they aren’t obligated to do so by the licenses. Wouldn’t it be quite interesting if TomTom’s mapping display software were available under, say, GPLv3?

(Added later): Even if TomTom fails to release their mapping applications as Free Software, our minimal demand should be a license to their patents for use in Free Software. Recall that TomTom countersued Microsoft, also alleging patent infringement on TomTom’s patents. TomTom has still yet to offer a public license on those patents for use by the Free Software community. If they are actually not hostile to software freedom, wouldn’t they allow us to at least practice the teachings of their patents in GPL’d software?

Andrew Tridgell pointed out that my verb tenses in my hypothetical example
made the text sound more broadly worded than I intended. I’ve thus
corrected the text in the hypothetical example to be clearer. Thanks for
the clarification, Tridge!

Neary on Copyright Assignment: Some Thoughts

Post Syndicated from Bradley M. Kuhn original

Dave Neary found me during
breakfast at the Linux Collaboration Summit this morning and mentioned
that he was being flamed for a blog post he made,
assignment and other barriers to entry
. Or, as some might title it
in a Computer Science academic tradition: Copyright Assignment
Considered Harmful
. I took a look at Dave’s post, and I
definitely think it’s worth reading and considering, regardless of
whether you agree with it or flame it. For my part, I think I agree
with most of his points.

One of the distinctions that Dave is making that some might miss is the
difference between non-profit, community-controlled copyright assignment
assignees and for-profit copyright assignees. He
Luis Villa
to make the point that companies, ultimately, aren’t the
best destinations as a final home of FLOSS copyrights. If copyright
assignment is looked only through the lens of a for-profit corporate
entity — with only the duty to its shareholders to determine its
future — then indeed it’s a dangerous situation for many of the
reasons that Dave raises.

I believe strongly that assigning copyright to a for-profit corporate
entity is usually problematic. As Dave points out, corporations aren’t
really community members proper of a Free Software community; rather,
their employees typically are. I have always felt that either
copyrights should be assigned to a transparently-run non-profit
501(c)(3) entity, or they should be held by individual contributors.
Indeed, the Samba project even has a
to accept absolutely no corporate copyrights in their codebase
, and
I would love to see more projects adopt that policy.

I trust 501(c)(3) non-profits more than for-profits not only because
I’ve spent most of my career in the former, and have enjoyed that time
more than my time at the latter. I trust non-profits more because their
charters and founding documents require a duty to a public-benefiting
mission and to a community. They are failing to act properly under
their charters if they put the needs of a for-profit entity ahead of the
needs of the community and the public. This is exactly the correct
alignment of incentives for a consolidation of FLOSS copyrights.

Some projects don’t like centralized copyright for various reasons.
While I do prefer it myself, I can understand this desire among
individuals to each keep their stake of control in the project. Thus, I
don’t object to projects that want each individual contributor to have
their own copyright. In this situation, the incentives are still
properly aligned, because individuals who helped make the project happen
have the legal control. While these individuals have
no required commitment to the public good like a non-profit,
they are members of a community and are much more
likely to put the community needs above the profit motive that controls
all for-profit entities.

When Dave says copyright assignment might be harmful, he seems to talk
primarily about for-profit corporate assignment. I agree with him on
that point. however, when he mentions that it’s unnecessary, I don’t
completely agree, but he raises well the points that I would raise as to
why it’s important.

However, in the middle of Dave’s post is the bigger concern that
deserves special mention. The important task is keeping a clear record
of the copyright provenance about where the work came from, and who
might have a copyright claim. Copyright assignment is a short-hand way
to do this in an organized and clear fashion. It’s a simple solution
with some overhead, and sometimes projects over the years have been
annoyed with (and even ridiculed) that overhead. However, the more
complex solutions have overhead, too. If you don’t do assignment, you
must keep careful track of every contributor, what their employer
agreements say, and whether they have the right to submit patches under
their own copyrights to the project. Some projects do this better than

Regardless, all of this is hard work. For years, I’ve seen it as a
personal task of mine to help develop systems and recommendations that
help make either process (assignment or good copyright record-keeping)
less burdensome. I haven’t worked on this task as much as I should
have, but I have not forgotten that it needs attention. I envision
integrated hooks and systems with revision control systems that help
with this. I think we eventually need something that makes it trivial
for hackers to implement and easy to maintain. I understand that the
last thing any Free Software hacker wants to do is sit and contemplate
the legal implications of contributions they’ve received. As such, all
of us who follow this issue hope to make it easier for projects to do
the work. In the meantime, I think discussion about this is good, and
I’m thankful for Dave to raising the issue again.

GNOME now esound-free

Post Syndicated from Lennart Poettering original

Andre Klapper just informed
me that GNOME is now officially esound-free: all modules have been ported over
to libcanberra
for event sounds or GStreamer/PulseAudio for everything else. It’s time to

It’s an end of an era. The oldest version of esound in GNOME CVS is 0.2.1,
commited on May 11th 1998. It has been shipped with every GNOME release since
1.0 back in 1999. (esound outside of GNOME dates even further back, probably
some time in the year 1997 or so). After almost 11 years in GNOME it’s all over now.
Oh, those were the good times.

If you maintain a module that is not part of GNOME that still uses
esound, hurry and update yours as well!

What YOU need to know about Practical Real-Time Programming

Post Syndicated from Lennart Poettering original

Eduardo Lima just added a couple
of more videos from one of the
best conferences in existence
to the
channel at Humbly as I am I’d like to ask everyone who
is interested in real-time and/or audio/video/animation programming to have a peek at this particular one.

That’s all.

Scale 7x Keynote Redux

Post Syndicated from Bradley M. Kuhn original

Many people have been commenting on and/or asking about my keynote,
When Software Is A Services, Is Only the “Network
Luddite” Free?
from Scale
in late February. There is finally a
downloadable H264/MPEG-4 AAC version (114MB) available
. There is also an audio recording of the same speech available from SCALE’s website. Finally, please
note that the keynote is substantially similar to my Plone
Conference Keynote, which was released as a podcast

There was also an article in Ars Technica that covered my keynote.

Device Reservation Spec

Post Syndicated from Lennart Poettering original

The JACK folks and I have agreed on a little specification for device
that allows clean hand-over of audio device access from
PulseAudio to JACK and back. The specification is generic enough to allow
locking/hand-over of other device types as well, not just audio cards. So, in
case someone needs to implement a similar kind of locking/handover for any kind of resource here’s some
prior art you can base your work on. Given that HAL is supposed to go away
pretty soon this might be an option for a replacement for HAL’s current device
locking. The logic is as simple as it can get. Whoever owns a certain service name on
the D-Bus session bus owns the device access. For further details, read the spec.

There’s even a reference
available, which both JACK2 and PulseAudio have now


The collective thoughts of the interwebz

By continuing to use the site, you agree to the use of cookies. more information

The cookie settings on this website are set to "allow cookies" to give you the best browsing experience possible. If you continue to use this website without changing your cookie settings or you click "Accept" below then you are consenting to this.