PCB of a d-link dir x 1860
Driver on


Pulsarhttp://freedesktop.org/software program/pulseaudio/planet/atom.xml2020-12-18T06:00:09+00:00Planet/2.0 +http://www.planetplanet.orgd-link dir x-1860 – a mediatek ax boardtag:https://lunarius.fe80.eu/weblog,2020-12-13:openwrt-d-link-x-1860-mt7915-ax.html2020-12-13T01:23:00+00:00

  • CPU mediatek 7621AT – a ramips based mostly cpu with 2 cores
  • RAM: winbond w632… (too small to learn 😉
  • flash: 128 MByte NAND winbond w29n01hvsinf
  • wifi: ax with a mt7915dan (2T2R 2.Four Ghz, 2T2R 5Ghz) + mt7975dn

PCB of a d-link dir x 1860Alexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:00The way to get well a supermicro board with a damaged bios firmwaretag:https://lunarius.fe80.eu/weblog,2020-04-26:supermicro-recover-broken-flash.html2020-04-26T21:42:00+00:00

I used to be requested to have a look on a supermicro server which has been broken by an firmware replace.
It was an Supermicro X10DRW-IT. The firmware replace was tried by USB storage, however in some way failed.

After powering the system, it went like this:

  • On with all followers for five sec
  • Off for five sec
  • On with all followers for five sec
  • [..]

Nonetheless it appears the IPMI continues to be booting by means of and will not be disconnected from the facility because the remaining
mainboard does, however the IPMI does not settle for any bios replace anymore.

As preparation I learn up on the coreboot assist for the Supermicro X10SLM+-F [0]

The bios chip is hidden beneath the raid controller should you’ve one.

Supermicro mainboard. Source: Supermicro X10DRW-i/X10DRW-iT USER’S MANUAL Revision 1.2b

First I’ve taken a glance on the BIOS flash. To learn the bios flash out, I’ve used a raspberry pi Three with a SOIC-Eight clip utilizing the SPI bus.

Required instruments:

  • raspberry pi with raspian (apt-get set up flashrom)
  • some wire cables to the SOIC8 take a look at clip
  • a SOIC-Eight take a look at clip (both a budget ones from aliexpress or the costly, top quality pomona 5250 [1]).

How you need to join the SPI SOIC chip is described in [2].
Pin 1 of the SPI chip is the place the small gap is on the.

Make sure you Disconnect each energy provides from the mainboard.

sudo flashrom -p linux_spi:dev=/dev/spidev0.0,spispeed=1000 -r bios
sudo flashrom -p linux_spi:dev=/dev/spidev0.0,spispeed=1000 -r bios2

sha256sum bios bios2
# make sure the checksum is equal, to make sure you learn actual issues.

strings -n 16 bios
# attempt to get some strings out of it, make sure you not solely learn 0xffff or 0x0000.

Subsequent I downloaded the supermicro bios replace. Right here you could find:

tree .

├── DOS
│   ├── CHOICE.SMC
│   ├── FDT.smc
│   ├── FLASH.BAT
│   ├── Readme for X10 AMI BIOS-DOS+UEFI.txt
│   └── X10DRW9.B22
└── UEFI
    ├── Readme for X10 AMI BIOS-DOS+UEFI.txt
    ├── X10DRW9.B22
    ├── afuefi.smc
    ├── fdt.smc
    └── flash.nsh

ls -al X10DRW9.B22
-rw------- 1 lynxis customers 16777216 Nov 22 16:07  X10DRW9.B22

Sound good, it is measurement is precise 16 MB, the identical measurement because the bios flash. file additionally inform me what it’s.

file X10DRW9.B22

X10DRW9.B22: Intel serial flash for PCH ROM

Nice we discovered a firmware picture with ifd (intel firmware descriptor).
Now I’ve regarded on the BIOS backup we learn with the raspberry pi.

I used hexdump -C bios to see if the tip comprises loads of 1s (or 0xffff in hex). Why?
As a result of if you wish to write a SPI flash, you cannot simply write to it like a tough drive.
SPI flash chips are organised in blocks. A block is often 64 kbyte.
A single bit on a flash chip can solely be written to a 0. If you wish to write a single bit with a 1
the place a Zero was earlier than (0 -> 1), you have to erase the entire block, not solely the tackle.
An erase blocked is filled with 1.
To seek out out, if we’ve got a half written flash, we will attempt to look on the tip of the flash if there are loads of 1s (or 0xffffffff).

hexdump -C is displaying it fairly good

00c2ee20  4d 50 44 54 00 01 00 00  10 00 00 00 00 00 10 00  |MPDT............|
00c2ee30  ff ff ff ff ff ff ff ff  ff ff ff ff ff ff ff ff  |................|

This implies, it solely written as much as 0x00c2ee30 (12.2 MB).
Now we will look into the downloaded picture, if it appears similiar. Perhaps right here begins configuration information.
However no, it is lacking some information right here.

Subsequent job is to flash the bios part. Bios part? The intel firmware description comprises part. Similiar to a partition format on a
laborious drive. On this platform there are Three totally different sections

00000000:00000fff fd
00400000:00ffffff bios
00011000:003fffff me
  • fd stands for firmware descriptor
  • bios stands for the x86 firmware or UEFI
  • me for the administration engine (additionally known as on servers "Server Platform Providers")

To flash solely the partition you both have to make use of a current flashrom model (a minimum of 1.0) otherwise you’ve to extract the format file utilizing
the ifdtool (from coreboot). You too can use the final code snipped as format.

flashrom -p linux_spi:dev=/dev/spidev0.0,spispeed=1000 -l format -i bios -w X10DRW9.B22

It verifies it after writing to it. However nonetheless it does not work. My subsequent thought was possibly the IPMI flash received broken as properly. The SPI flash
of the IPMI is shut by. So let’s take a look. I used to be fortunate to even have a SOIC-16 take a look at clip obtainable. I did the identical process on the
IPMI flash. Nonetheless the flashrom in raspian was too previous. The flash chip wasn’t identified to this model flashrom. I needed to compile it myself.

sudo apt set up git build-essential
git clone https://overview.coreboot.org/flashrom.git
cd flashrom
./flashrom -p linux_spi:dev=/dev/spidev0.0,spispeed=1000 -r ipmi

However it appears good thus far. Working binwalk on it exhibits us

binwalk ipmi

103328        0x193A0         CRC32 polynomial desk, little endian
1048576       0x100000        JFFS2 filesystem, little endian
4194304       0x400000        CramFS filesystem, little endian, measurement: 15216640, model 2, sorted_dirs, CRC 0xB1031FF3, version 0, 8613 blocks, 1099 information
20971520      0x1400000       uImage header, header measurement: 64 bytes, header CRC: 0x3F1E0DA5, created: 2019-11-15 08:36:11, picture measurement: 1537512 bytes, Knowledge Deal with: 0x40008000, Entry Level: 0x40008000, information CRC: 0x310498CA, OS: Linux, CPU: ARM, picture sort: OS Kernel Picture, compression sort: gzip, picture title: "21400000"
20971584      0x1400040       gzip compressed information, most compression, has authentic file title: "linux.bin", from Unix, final modified: 2019-11-15 07:25:15
24117248      0x1700000       CramFS filesystem, little endian, measurement: 7458816, model 2, sorted_dirs, CRC 0xF5B9463B, version 0, 3108 blocks, 466 information

Seems to be additionally good, nevertheless I need to make sure, it is the tremendous. I did first a backup, second overwritten with a file from the IPMI firmware replace.

Nonetheless no change.

So what’s unsuitable right here? Is the facility administration controller broken? The facility provide are controller digital by way of I2C. Perhaps it is in some way
telling me one thing is unsuitable?

I used to be fortunate, I did not had a i2c sniffer round, in any other case I’d have digged into it.
I almost gave it up, earlier than I came upon, that the backup file did not labored with ifdtool. I exported the format utilizing the firmware replace file, and never with the backup file.
Normally firmware updates don’t contact the ifd. It appears server boards are totally different. So the backup did not contained an ifd. It wasn’t solely broken in the long run, additionally to start with. Unsure if this can be a security function of the
replace. It would guarantee at the start of an replace the partial flash would not be acknowledged as a working picture. It is not a very good factor booting a half working picture.

I flashed the bios firmware replace picture and the board is again. To make sure, I flashed the ipmi backup on the SPI chip.

TLDR; So the quick solution to get well a partial bios, do a backup first! Then flash the complete picture. At the least for this technology it really works.

Observe: Relying in your particular {hardware} setup (cable size, take a look at clip) you’ll be able to enhance or lower the spispeed. spispeed=10000 => 10 MHz ought to
be nonetheless okay. You will discover the unsuitable spispeed if the studying or flashing fails.

[0] https://doc.coreboot.org/mainboard/supermicro/x10slm-f.html

[1] https://www.pomonaelectronics.com/merchandise/test-clips/soic-clip-8-pin

[2] https://github.com/bibanon/Coreboot-ThinkPads/wiki/{Hardware}-Flashing-with-Raspberry-Pi

Alexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:00My free software program contribution in December 2019tag:https://lunarius.fe80.eu/weblog,2020-01-13:monthly-2019-12.html2020-01-13T00:24:00+00:00

Similiar to lolamby’ common put up on his free software program contribution, I need to begin a similiar put up.

The large chunk of the December I ready along with the GSM workforce the celluar community on the 36c3 (36. Chaos Communication Congress).
Yearly we’re constructing our personal celluar community utilizing free software program venture osmocom & open5gs. Osmocom is a neighborhood venture round cell communication. We used osmocom to run our core community (CN) of our 2G and 3G community.
Open5gs is our LTE CN, which was interconnected to the osmocom CN.
Here’s a overview, each buble is an personal daemon.

The 36c3 was a pleasant testing floor. We needed to lengthen a few the providers (e.g. osmomsc, osmogsup2dia, osmohnbgw). Whereas the occasion we
additionally wish to benefit from the congress, so that is our excuse to not upstream our patches proper a away. Nonetheless we push our branches as it’s to
https://git.osmocom.org. Upstreaming might be extra seen in January.

Alexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:00Joe the pleasant espresso makertag:https://lunarius.fe80.eu/weblog,2020-01-13:joe-friendly-coffe-maker.html2020-01-13T00:23:00+00:00

Final week I visited thomasdotwtf from eventphone who has a jura espresso machine.
We took one night to look into it, how straightforward it’s, to make use of a generic BLE system like a raspberry pi to manage it.
He has a Jura Z8 Automated Espresso Machine which helps an IOS/Android app by way of Bluetooh LE.

Jura launched (a minimum of) two totally different apps to manage it.

  • pl.mkssystems.juracoffee.family (Jura Espresso)
  • ch.toptronic.joe (J.O.E.)

Each apps helps ordering, altering properties of a espresso (e.g. how a lot water do you need to have or how a lot espresso needs to be in
mkssystems.pl appears to went out-of-service, however the web archive nonetheless have an previous model
they usually present loads of espresso machine associated merchandise. In addition to a small blue system [1].

That is the BlueFrog a bluetooth dongle to manage Jura espresso machines.

What are you able to do with the Apps?

  • Configure your Espresso
  • Produce a Espresso
  • Statistics
  • Firmware updates

How we regarded into?

  • bluetooth packettrace: We used the android btsnoop.log to retrieve a packet hint which we loaded into wireshark.
  • decompiled with totally different instruments the .apk
  • loaded the supply code into android studio

What we came upon?

The J.O.E. software is utilizing XML information to be configured for the totally different espresso machines.
The XML defines merchandise (e.g. a espresso, a inexperienced tea, …), there are properties (e.g. how a lot espresso needs to be produced), statistics and
settings. The article quantity defines the XML file for use.

A firmware course of together with the replace urls and the brand new firmware.

We tried to seek out the identical instructions which ought to work on the RS232/serial within the bluetooth packet hint, however there wasn’t any.
After trying additional within the code, we discovered so much UUIDs for traits together with a human readable title.
We found additionally an "encryption" methodology which makes use of 2x hardcoded keys as properly an extra enter of Eight bit from the BLE advertisment.
The encryption appear to be a static key.

Within the BLE advertisment, there are manufactoring information.
In our case, the manufactoring information comprises 27 bytes. If 16 bit might be used, it is little endian.

manufactoring information as hex (27 byte):
aa 05 06 03 d73a yyyy xxxx 5836 4435 01 c0 00 00 00 00 00 00 00 00 00 00 00

aa: key
05: BlueFrog Main Model
06: BlueFrog Minor Model
03: unused (possibly Patch Model?)
d73a: article quantity (the precise sort of the machine)
yyyy: machine quantity
xxxx: serial quantity
5836: manufacturing date (Feb. 2017)
4435: manufacturing date UHCI (does UHCI means the bluefrog?) (Okt. 2016)
01: unused
c0: bitmask, outline supported options

The manufacturing dates may be decoded and in addition validated utilizing the applying the place it is proven within the connection fragment:

days: (i & 31)
month: ((i & 480) >> 5)
yr: ((i & 65024) >> 9) + 1990;

What to do subsequent?

Write a decrypt perform which may parse pcap information and exhibits the message
or write a dissector (lua) for wireshark with decryption perform.

Learn the way to map the XML information into instructions in the direction of the BlueFrog.

Bluetooth Interface

The nice factor of BLE is, it is standarzied within the communication.
BLE makes use of Bluetooth Attribute Protocol to speak.
The Bluetooth Attribute Protocol makes use of providers and traits.
A service is an object which may maintain a number of traits. A attribute can assist a number of of the next operations
learn, write, notification, indication.
Each service has a UUID as properly a attribute has a UUID. The Bluetooth Attribute Protocol has it is personal strategies to find avaiable
providers and characterics. For extra data please take a better look into Bluetooth Low Power.

As a common BLE system, the BlueFrog annouce itself on the BLE.

> hcitool lescan
LE Scan ...
C9:26:E8:4B:72:02 TT214H BlueFrog

> HCI Occasion: LE Meta Occasion (0x3e) plen 43                    #8 [hci0] 8.466202
      LE Promoting Report (0x02)
        Num reviews: 1
        Occasion sort: Scan response - SCAN_RSP (0x04)
        Deal with sort: Random (0x01)
        Deal with: C9:26:E8:4B:72:02 (Static)
        Knowledge size: 31
        Firm: Ingenieur-Systemgruppe Zahn GmbH (171)
        Knowledge: aa050603d73a080402005836443501c00000000000000000000000
        RSSI: -78 dBm (0xb2)

And additional extra we will additionally search for the providers and traits by way of the gatttool.

> gatttool -b C9:26:E8:4B:72:02 --services -t random

attr deal with = 0x0001, finish grp deal with = 0x0007 uuid: 00001800-0000-1000-8000-00805f9b34fb
attr deal with = 0x0008, finish grp deal with = 0x0008 uuid: 00001801-0000-1000-8000-00805f9b34fb
attr deal with = 0x0009, finish grp deal with = 0x0033 uuid: 5a401523-ab2e-2548-c435-08c300000710
attr deal with = 0x0034, finish grp deal with = 0x003a uuid: 5a401623-ab2e-2548-c435-08c300000710
attr deal with = 0x003b, finish grp deal with = 0xffff uuid: 00001530-1212-efde-1523-785feabcd123
> gatttool -b C9:26:E8:4B:72:02 --characteristics -t random

deal with = 0x0002, char properties = 0x0a, char worth deal with = 0x0003, uuid = 00002a00-0000-1000-8000-00805f9b34fb
deal with = 0x0004, char properties = 0x02, char worth deal with = 0x0005, uuid = 00002a01-0000-1000-8000-00805f9b34fb
deal with = 0x0006, char properties = 0x02, char worth deal with = 0x0007, uuid = 00002a04-0000-1000-8000-00805f9b34fb
deal with = 0x000a, char properties = 0x02, char worth deal with = 0x000b, uuid = 5a401524-ab2e-2548-c435-08c300000710
deal with = 0x000d, char properties = 0x08, char worth deal with = 0x000e, uuid = 5a401525-ab2e-2548-c435-08c300000710
deal with = 0x0010, char properties = 0x08, char worth deal with = 0x0011, uuid = 5a401529-ab2e-2548-c435-08c300000710
deal with = 0x0013, char properties = 0x08, char worth deal with = 0x0014, uuid = 5a401528-ab2e-2548-c435-08c300000710
deal with = 0x0016, char properties = 0x0a, char worth deal with = 0x0017, uuid = 5a401530-ab2e-2548-c435-08c300000710
deal with = 0x0019, char properties = 0x02, char worth deal with = 0x001a, uuid = 5a401527-ab2e-2548-c435-08c300000710
deal with = 0x001c, char properties = 0x02, char worth deal with = 0x001d, uuid = 5a401531-ab2e-2548-c435-08c300000710
deal with = 0x001f, char properties = 0x0a, char worth deal with = 0x0020, uuid = 5a401532-ab2e-2548-c435-08c300000710
deal with = 0x0022, char properties = 0x0a, char worth deal with = 0x0023, uuid = 5a401535-ab2e-2548-c435-08c300000710
deal with = 0x0025, char properties = 0x0a, char worth deal with = 0x0026, uuid = 5a401533-ab2e-2548-c435-08c300000710
deal with = 0x0028, char properties = 0x02, char worth deal with = 0x0029, uuid = 5a401534-ab2e-2548-c435-08c300000710
deal with = 0x002b, char properties = 0x02, char worth deal with = 0x002c, uuid = 5a401536-ab2e-2548-c435-08c300000710
deal with = 0x002e, char properties = 0x02, char worth deal with = 0x002f, uuid = 5a401537-ab2e-2548-c435-08c300000710
deal with = 0x0031, char properties = 0x02, char worth deal with = 0x0032, uuid = 5a401538-ab2e-2548-c435-08c300000710
deal with = 0x0035, char properties = 0x02, char worth deal with = 0x0036, uuid = 5a401624-ab2e-2548-c435-08c300000710
deal with = 0x0038, char properties = 0x08, char worth deal with = 0x0039, uuid = 5a401625-ab2e-2548-c435-08c300000710
deal with = 0x003c, char properties = 0x04, char worth deal with = 0x003d, uuid = 00001532-1212-efde-1523-785feabcd123
deal with = 0x003e, char properties = 0x18, char worth deal with = 0x003f, uuid = 00001531-1212-efde-1523-785feabcd123

Bluetooth Providers and Traits

service desk
begin finish uuid title  
0x0001 0x0007 0x1800 Generic Entry Profile  
0x0008 0x0008 0x1801 Generic Attribute Profile  
0x0009 0x0033 5a401523-ab2e-2548-c435-08c300000710    
0x0034 0x003a 5a401623-ab2e-2548-c435-08c300000710    
0X003b 0xffff 00001530-1212-efde-1523-785feabcd123    
Generic Entry Profile (GAP) 0x0001 .. 0x0007
deal with worth deal with properties uuid description
0x0002 0x0003 RW (0xa) 00002a00-0000-1000-8000-00805f9b34fb  
0x0004 0x0005 R (0x2) 00002a01-0000-1000-8000-00805f9b34fb  
0x0006 0x0007 R (0x2) 00002a04-0000-1000-8000-00805f9b34fb  
5a401523-ab2e-2548-c435-08c300000710 0x0009 .. 0x0033a
deal with worth deal with properties uuid description
0x000a 0x000b R (0x2) 5a401524-ab2e-2548-c435-08c300000710 Machine Standing
0x000d 0x000e W (0x8) 5a401525-ab2e-2548-c435-08c300000710 Product Begin
0x0010 0x0011 W (0x8) 5a401529-ab2e-2548-c435-08c300000710 Service Management
0x0013 0x0014 W (0x8) 5a401528-ab2e-2548-c435-08c300000710 Replace Product Progress
0x0016 0x0017 RW (0xa) 5a401530-ab2e-2548-c435-08c300000710 Product Progress
0x0019 0x001a R (0x2) 5a401527-ab2e-2548-c435-08c300000710 About
0x001c 0x001d R (0x2) 5a401531-ab2e-2548-c435-08c300000710  
0x001f 0x0020 RW (0xa) 5a401532-ab2e-2548-c435-08c300000710  
0x0022 0x0023 RW (0xa) 5a401535-ab2e-2548-c435-08c300000710  
0x0025 0x0026 RW (0xa) 5a401533-ab2e-2548-c435-08c300000710 Statistics command
0x0028 0x0029 R (0x2) 5a401534-ab2e-2548-c435-08c300000710 Statistics information
0x002b 0x002c R (0x2) 5a401536-ab2e-2548-c435-08c300000710  
0x002e 0x002f R (0x2) 5a401537-ab2e-2548-c435-08c300000710  
0x0031 0x0032 R (0x2) 5a401538-ab2e-2548-c435-08c300000710 Service Management Response
5a401623-ab2e-2548-c435-08c300000710 0x0034 .. 0x003a
deal with worth deal with properties uuid description
0x0035 0x0036 R (0x2) 5a401624-ab2e-2548-c435-08c300000710  
0x0038 0x0039 W (0x8) 5a401625-ab2e-2548-c435-08c300000710  
Nordic DFU 00001530-1212-efde-1523-785feabcd123 0x003b .. 0xffff
deal with worth deal with properties uuid description
0x003c 0x003d W- (0x4) 00001532-1212-efde-1523-785feabcd123 Nordic DFU_PACKET_CHARACTERISTI
0x003e 0x003f W N (0x18) 00001531-1212-efde-1523-785feabcd123 Nordic DFU_CONTROL_POINT_CHARACTERISTIC
  • R means learn
  • W imply write with response
  • W- means write with out response
  • N means notification

Extra sources

  • [1] https://www.thomas-electronic-online-shop.de/JURA-Good-Join
  • [2] https://discussion board.fhem.de/index.php?subject=76957.0
  • [3] https://neighborhood.home-assistant.io/t/control-your-jura-coffee-machine/26604
  • [4] https://gitlab.com/Blueforcer/HA2JURA/snippets/1674496
  • [5] https://github.com/hn/jura-coffee-machine
  • [6] https://infocenter.nordicsemi.com/index.jsp?subject=%2Fcom.nordic.infocenter.sdk5.v15.3.0percent2Flib_dfu_transport_ble.html

Alexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:00TP-Hyperlink TL-WR841v14tag:https://lunarius.fe80.eu/weblog,2019-03-28:photos-tplink-tl-wr841v14.html2019-03-28T12:37:00+00:00

  • ramips mt7628nn
  • Four MB flash
  • 32 MB Reminiscence

TP-Link 841v14Alexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:00MirageOS retreat March 2019tag:https://lunarius.fe80.eu/weblog,2019-03-18:mirageos-2019.html2019-03-18T11:34:00+00:00

I joined the MirageOS retreat in March 2019. It is an 1 week occasion in Marrakech, Marocco.
It is an actual good home within the previous metropolis of Marrakech, the medina. The occasion itself does not
have a lot construction than a morning assembly and generally talks within the night.

MirageOS is unikernel written in OCaml. MirageOS can run ontop of many backends, e.g. Unix course of or xen, kvm, bhyve.
This retreat I took care of the Web uplink. We had a sluggish and leaky 4MBit ADSL line from Marocco Telecom which we used as backup, whereas utilizing LTE as major uplink. We used first imwi as supplier. However imwi adjustments the IPs quites typically and the implementation in OpenWrt uqmi doesn’t comply with the IP adjustments, which resulted in a stale LTE connection. Imwi can also be filtering all UDP DNS queries, besides these going to their very own servers. We then switched to Orange as supplier, as a result of somebody had a card obtainable. Orange was quick sufficient, fairly steady 5MBit up&down. We consumed roughly 20 GB a day. This introduced us the good day by day ritual, a stroll to a small and good cell store within the medina.
1 GB price 10 Dh (1 Euro).
Our router, an APU2, runs OpenWrt, however we disabled DNS & DHCP and ran these providers on a seperate APU utilizing MirageOS.

Even I am not such acquainted with OCaml and practical languages, I attempted to repair a bug within the DHCP Server implementation PR#97.
It labored for me, nevertheless after deploying it, it turned out, it solely labored for me, I broke it for everyone else ;). This motivated me to start out
trying on TTCN-3, a ETSI language to check community protocols. Later along with Hannes, we mounted the DHCP for actual. Including some TTCN-Three exams and create a easy base continues to be on my TODO. One other very nice OCaml service on aspect was a learn-ocaml occasion. An interactive educating net software for rookies and advances OCaml programmers together with an annotate OCaml compiler. Sadly there is no such thing as a occasion within the web but, because the tasks shouldn’t be prepared for launch.

Whereas there I additionally labored so much on reproducible builds for OpenWrt. I mounted 2 packages. All OpenWrt base packages are 100 % reproducible.
Due to Daniel Golle, OpenWrt pictures may be cryptographically signed. This signature should be eliminated earlier than searching for variations, that is additionally carried out
within the reproducible builds setup for OpenWrt. 100% of ar71xx pictures are reproducible and 98% of ramips. The remaining 2% are additionally signature issues, however these signatures are within the center as an alternative of the tip of the picture. I additionally discovered the time to combine my bundle index parser into reproducible builds. It is a lot simpler to only parse two packages listing, than trying on the all bundle information to find out if they’re reproducible or not. The bundle index information additionally comprise metadata of the packages which it inserts into the reproducible builds database.

Some folks from the QubesOS tasks joined the retreat. For instance there’s a MirageOS firewall which replaces the QubesOS personal one. There may be additionally a Pong sport, which may run as QubesOS-vm. Due to the QubesOS folks for his or her assistance on my issues with disposable vms.

Moreover I introduced a beaglebone black with me to analyze bugs reported for that platform. Whereas it, I came upon the final launch of OpenWrt (18.06.2) does not work on this board (fs: squashfs), whereas grasp works. I additionally mounted builds points with u-boot in OpenWrt for the beaglebone black when utilizing a contemporary toolchain.

Since we used LTE as uplink, we wished to understand how a lot of our information quantity was consumed. OpenWrt might need statistics, however these are saved solely in reminiscence and never saved wherever. I did not regarded for any OpenWrt packages which fixes this downside, as a result of the supplier (Orange) is supporting a USSD code to retrieve the remaining quantity.

What’s USSD? USSD stands for Unstructured Supplementary Service Knowledge. It is used on cell phones to retrieve steadiness, your cellphone quantity, your IMEI, [..]. Most individuals have used them. Take your cellphone, open the cellphone software and name *#06#, it is going to return your cellphone distinctive identifier (IMEI). Whereas SMS is a store-and-forward scheme, like e-mail. USSD is actual time message protocol, similiar to a TCP connection. The united states codes are easy, do a request, get a response. Performed. However Orange applied a menu by way of USSD. So the united states session will appear to be: Request, Response, Select Your Menu, Response, Go Again, Select totally different Level.
I’ve began writing USSD assist for libqmi. Easy USSD codes may be requested and decoded, however not menus with person enter.

And the largest downside is: OpenWrt does not assist USSD in any respect. Not even the easy ones.

Alexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:00upowerd failstag:https://lunarius.fe80.eu/weblog,2018-06-14:upowerd-fails-users.html2018-06-14T13:01:00+00:00

Generally, once I’m in a roundabout way round or I forgot to place the powersupply into my laptop computer.
My laptop computer runs into the essential energy motion. As a result of I am utilizing upowerd, my machine
attempt to does this:

  • HibernateSuspend (fails)
  • Hibernate (fails)
  • PowerOff

Nice! My machine shuts down, in the course of doing one thing. It might take 2 minutes to get a powersupply,
however too late!!

However there is likely to be an answer for this: Droop.
My machine can survive greater than 1 hour in droop with this low battery.

It might assist me NOT loosing my present unsaved work.

After trying into the upowerd, it is only a 1 line code change to permit this.
It isn’t a very good default, however there are individuals who like to make use of this.

However .. upowerd does not like. They not even need to permit the person to take this feature. Indepentent that
I agree, this should not be the default.
We’re discussing this subject for years. With none answer. Upowerd need to determine what customers ought to do with there laptop computer and what not.

Dialogue Bugtracker

The way to resolve it?

Alexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:00Convert a flashdump to sysupgrade (ar71xx)tag:https://lunarius.fe80.eu/weblog,2017-08-18:convert-flashdump-to-sysupgrade-ar71xx.html2017-08-18T01:42:00+00:00

Occasionally you might want to take a look at issues with the previous picture.
However how do you take a look at factor when the unique construct atmosphere is misplaced
and also you need to take a look at sysuprade in opposition to this previous launch (really 12.09).

First you have to create a flashdump of the firmware paritition.

# grep firmware /proc/mtd
mtd5: 003d0000 00010000 "firmware"

# ssh root@ dd if=/dev/mtd5 > /tmp/firmware_backup

Afterwards you should use binwalk to get the precise offsets of the totally different
components inside.

# binwalk /tmp/firmware_backup
512           0x200           LZMA compressed information, properties: 0x6D, dictionary measurement: 8388608 bytes, uncompressed measurement: 2813832 bytes
930352        0xE3230         Squashfs filesystem, little endian, model 4.0, compression:xz, measurement: 2194094 bytes, 728 inodes, blocksize: 262144 bytes, created: 2014-03-05 14:58:48
3145728       0x300000        JFFS2 filesystem, huge endian

So sysupgrade pictures for ar71xx continues to be utilizing the (previous) format of

|jffs2   |

Whereas a sysupgrade picture comprises for these platforms:

|KERNEL      |
|squashfs    |
|jffs2-dummy |

So we are going to split-off the jffs2 Half and substitute it with jffs2.

# dd if=/tmp/firwmare_backup bs=3145728 depend=1 of=/tmp/sysupgrade.img

Subsequent we add this jffs2-dummy by utilizing the identical instrument LEDE is utilizing it:

# /house/lynxis/lede/staging_dir/host/bin/padjffs2 /tmp/sysupgrade.img 64

The 64 means the padding measurement in kb. It is necessary to decide on the best one, however for many units that is 64okay a minimum of for ar71xx.

ssh root@ dd if=/dev/mtd5 > /tmp/firmware_backup
binwalk /tmp/firmware_backup
dd if=/tmp/firwmare_backup bs=3145728 depend=1 of=/tmp/sysupgrade.img
/house/lynxis/lede/staging_dir/host/bin/padjffs2 /tmp/sysupgrade.img 64

Alexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:00coreboot assist in lenovo x1 carbon gen1tag:https://lunarius.fe80.eu/weblog,2017-08-11:coreboot-x1-carbon-gen1.html2017-08-11T11:37:00+00:00

A pal gave me the his x1 carbon gen1 a while in the past.
The x1 carbon is little bit totally different from different Thinkpad as a result of it is a mixture
of a Thinkpad and a Ultrabook.

  • It has a Trackpoint (and even Trackpoint buttons).
  • It has soldered reminiscence (solely Elpida reminiscence is assist atm).
  • It has Full-HD. (missed that on x2xx).

Wanting beneath the hood. The x1 carbon gen1 look very seemingly as x230.

x1 carbon left side
x1 carbon right sideAlexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:00mksquashfstag:https://lunarius.fe80.eu/weblog,2017-01-13:mksquash-dot-graph.html2017-01-13T22:42:00+00:00

A graphic can describe a factor greater than 1000 phrases.
That is how mksquashfs 4.Three works.

How squashfs tools.

mksquashfs supply

Alexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:00Write patches for LEDEtag:https://lunarius.fe80.eu/weblog,2016-10-01:lede-write-kernel-patches.html2016-10-01T21:42:00+00:00

This howto will get your by means of a LEDE to create your individual kernel patch utilizing
the LEDE infrastructure. It is based mostly on LEDE reboot-1279-gc769c1b.

LEDE has already loads of patches. They’re all utilized on one tree.
We’ll create a brand new patch for lantiq.
To get began, let see how LEDE arrange the patches.
To start with we have a look on /goal/linux/*

All of those folders symbolize a structure goal, besides generic.
The generic goal is utilized by all targets.

To proceed, we have to know which kernel model your goal structure is operating on.
That is written down into goal/linux/lantiq/Makefile.

We’re operating a 4.4.Y kernel. The Y is written down into /embrace/kernel-version.mk. We’ll
use .15.

Okay. Now let’s have a look at. When LEDE is making ready the kernel construct listing, it seek for an identical patch

  1. obtain the kernel 4.4.x (x from /embrace/kernel-version.mk)
  2. unpack the kernel beneath /build_dir/target-../linux-lantiq/linux-4.4.15
  3. apply generic patches
  4. apply lantiq patches
  5. create .config

However which is the best patches listing? It use the next make snippet from /embrace/kernel.mk

That means it is going to use /patches-4.Four if exists or if not attempt to use /patches.

Now we all know how patches are utilized to the linux kernel tree.
We might go into the listing, create a brand new patches listing and use quilt

Or we use the quilt goal for that.

make goal/linux/clear -> to scrub up the previous listing.
Now make goal/linux/put together QUILT=1 will unpack the supply, copy all current patches into ./patches
and use quilt to use.

With quilt you’ll be able to transfer forwards and backwards between patches, aswell as modifying these.
cd ./build_dir/target-mips_34kc+dsp_uClibc-
to change into the linux listing.

  1. quilt push -a to use all patches from LEDE.
  2. quilt new platform/999-mymodification.patch so as to add a brand new patch
  3. quilt add internet/l2tp/l2tp_core.c to trace this file.
  4. Name your editor to switch this file.
  5. With quilt refresh it provides your modifcation to the patch platform/999-mymodification.patch.

Your modification is beneath ./build_dir/../linux-4.4.15/patches/platform/.
With make goal/linux/refresh it is going to refresh all patches and replica them to the proper folder beneath goal/linux/*/patches.

Alexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:00Discover particular GPIOstag:https://lunarius.fe80.eu/weblog,2016-05-26:lede-find-ar71xx-special-gpios.html2016-05-26T15:42:00+00:00

The TP-Hyperlink CPE510, a pleasant out of doors system, received a foul rx behaviour when utilizing it with LEDE.
I need to give a brief overview how one can debug these issues. It might additionally show you how to discovering issues when going through
ath9k pci playing cards.

To get right down to the system. The CPE510 based mostly on a AR9344 SoC. The built-in wi-fi half is
supported by the ath9k driver. To get extra data concerning the AR9344 you need to have a look into
the general public obtainable datasheet. (google for ar9344 datasheet 😉

The AR9344 helps utilizing GPIOs for particular functions it is known as a GPIO perform. If the perform is
enabled, the gpio is internally routed to the particular goal. Now the easy half comes
if you realize which register to look into, simply look into it.

After studying the pages 52/53 of the datasheet, it is clear that it could route every part sign to each gpio.
Keep in mind the desk, as a result of it explains what worth means what it is routed to the gpio.
We advise LNA are lacking as a result of the receiving a part of the CPE510 is dangerous. So the worth 46 and 47 are the necessary ones,
46 LNA Chain 0, 47 LNA Chain 1. LNA stands for low noice amplifier.

Now we all know how the GPIOs works, let’s discover the register controlling the GPIO perform. The GPIO part begin at 130, however the attention-grabbing half
is the GPIO IO Perform Zero register at tackle 0x1804002c. It provide you with Eight bit to explain it is perform, if it is 0x0 no perform is chosen and the
GPIO is used as regular output. So should you write 46 into the bit 0-7 you set the GPIO to grow to be the LNA Chain Zero sign. Each GPIO from
GPIO0 to GPIO19 can configured utilizing these register.

We all know what registers are attention-grabbing (0x1804002c – 0x1804003c).
We all know which values are attention-grabbing (decimal 46 and decimal 47).

However how can we learn out these worth from a operating system?
First reply I hear is JTAG, however JTAG is not straightforward to archive and tougher to make use of on ar71xx, as a result of the bootloader
often deactivate JTAG as one of many first instructions.

However we will ask the kernel. /dev/mem is kind of usefull for that. It is a direct solution to the reminiscence, very harmful, but in addition helpful ;).
The simplest solution to interface with /dev/mem is the easy utility known as devmem or devmem2.
To compile a suitable devmem2 you need to use the GPL sources of the firmware, however you can too
obtain the binary from right here [1].

Copy devmem2 to /tmp by way of scp and begin studying the values.
As a result of mips is a 32bit structure we’ve got to learn the register

Again to our LNA worth. 46 and 47. In hex are these 0x2E and 0x2F. We now have to look
for these values aligned to 8bit.

# ./devmem2 0x1804002c
/dev/mem opened.
Reminiscence mapped at tackle 0x2aaae000.
Worth at tackle 0x1804002C (0x2aaae02c): 0x0
# ./devmem2 0x18040030
/dev/mem opened.
Reminiscence mapped at tackle 0x2aaae000.
Worth at tackle 0x18040030 (0x2aaae030): 0xB0A0900
# ./devmem2 0x18040034
/dev/mem opened.
Reminiscence mapped at tackle 0x2aaae000.
Worth at tackle 0x18040034 (0x2aaae034): 0x2D180000
# ./devmem2 0x18040038
/dev/mem opened.
Reminiscence mapped at tackle 0x2aaae000.
Worth at tackle 0x18040038 (0x2aaae038): 0x2C
# ./devmem2 0x1804003c
/dev/mem opened.
Reminiscence mapped at tackle 0x2aaae000.
Worth at tackle 0x1804003C (0x2aaae03c): 0x2F2E0000

Discovered it in 0x1804003C. LNA Zero is GPIO 18 and LNA1 is GPIO 19.

[1] https://lunarius.fe80.eu/weblog/information/lede/devmem2

Alexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:00Bisecting coreboot with LAVAtag:https://lunarius.fe80.eu/weblog,2016-03-04:coreboot-bisect-lava.html2016-03-04T22:42:00+00:00

Since very long time in the past I used to be impressed of the options of LAVA (Linaro Automated Validation).
Lava was developed by Linaro to do computerized take a look at on actual {hardware}. It is written in python and based mostly on so much small daemons and one django software.
It is scheduling submitted exams on {hardware} relying on the rights and availability.
Establishing an personal occasion is not so laborious, there’s an video howto. However Lava is altering it is fundamental system mannequin to pipeline units to make it extra versatile as a result of the previous system mannequin was fairly restricted.
Our occasion is obtainable beneath https://lava.coreboot.org. Atm. there is just one system (x60) and we’re searching for assist so as to add extra units.

coreboot is beneath heavy improvement round 200 commits a month. Someday breaks, most time as a result of someone refactored code and made it easier.
There are a lot of units supported by coreboot, however commits aren’t examined on each {hardware}. Which implies it broke on some {hardware}. And right here the bisect loop begins.

Lava is the right place to do bisecting. You’ll be able to submit a Testjob by way of commandline, monitor Job and wait till it is carried out. Lava itself takes cares {that a} job does not take to lengthy.
To interrupt down the duty into smaller peaces:

  • checkout a revision
  • compile coreboot
  • copy artefact someplace the place Lava can entry it (http-server)
  • submit a lava testjob
  • lava deploys your picture and do some exams

git-bisect does the binary seek for the damaged revision, checks out the following commit which must be examined.
However someone have to inform git-bisect if this can be a good or dangerous revision. Otherwise you use git bisect run.
git bisect run a small script and makes use of the return code to know if this can be a good or dangerous revision. There may be additionally a 3rd command skip, to skip the revision if the compilation fails.
git-bisect would do the complete bisect job, however to make use of lava, it wants a Lava Check Job.
Below https://github.com/lynxis/coreboot-lava-bisect is my x60 bisect script along with a Lava Check Job for the x60. It solely checks if coreboot is booting. However you may need to take a look at one thing else. Is the cdrom is displaying up? Is the wifi card correctly detected? Checkout the lava documentation for extra details about how one can write a Lava Testjob or a Lava Check.

To speak with Lava on the shell you might want to have lava-tool operating in your workstation. See https://validation.linaro.org/static/docs/overview.html

With lava-tool submit-job $URL job.yml you’ll be able to submit a job and get the JobId.
And verify the standing of your job with lava-tool job-status $URL $JOBID. Relying on the job-status
the script should set the exit code. My bisect script for coreboot is https://github.com/lynxis/coreboot-lava-bisect

cd coreboot
# CPU make -j$CPU
export CPU=4
# your login person title for the lava.coreboot.org
# you can too use LAVAURL="https://$LAVAUSER@lava.coreboot.fe80.eu/RPC2"
export LAVAUSER=lynxis
# utilized by lava to obtain the coreboot.rom
export COREBOOTURL=https://fe80.eu/bisect/coreboot.rom
# used as a goal by *scp*
export COREBOOT_SCP_URL=lynxis@fe80.eu:/var/www/bisect/coreboot.rom
git bisect begin
git bisect dangerous <REV>
git bisect good <REV>
git bisect run /path/to/this/dir/bisect.sh

Alexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:0013 methods to PulseAudiohttp://voices.canonical.com/david.henningsson/?p=3382016-02-04T12:51:07+00:00

All roads result in Rome, however PulseAudio shouldn’t be far behind! In truth, how the PulseAudio shopper library determines how one can strive to hook up with the PulseAudio server has at least 13 totally different steps. Right here they’re, in precedence order:

1) As an software developer, you’ll be able to specify a server string in your name to pa_context_connect. If you happen to try this, that’s the server string used, nothing else.

2) If the PULSE_SERVER atmosphere variable is about, that’s the server string used, and nothing else.

3) Subsequent, it goes to X to verify if there’s an x11 property named PULSE_SERVER. If there’s, that’s the server string, nothing else. (There may be additionally a PulseAudio module known as module-x11-publish that units this property. It’s loaded by the start-pulseaudio-x11 script.)

4) It additionally checks shopper.conf, if such a file is discovered, for the default-server key. If that’s current, that’s the server string.

So, if not one of the 4 strategies above offers any consequence, a number of gadgets might be merged and tried so as.

First up is making an attempt to hook up with a user-level PulseAudio, which suggests discovering the best path the place the UNIX socket exists. That in flip has a number of steps, in precedence order:

5) If the PULSE_RUNTIME_PATH atmosphere variable is about, that’s the trail.

6) In any other case, if the XDG_RUNTIME_DIR atmosphere variable is about, the trail is the “pulse” subdirectory beneath the listing laid out in XDG_RUNTIME_DIR.

7) If not, and the “.pulse” listing exists within the present person’s house listing, that’s the trail. (That is for historic causes – a number of years in the past PulseAudio switched from “.pulse” to utilizing XDG compliant directories, however ignoring “.pulse” would throw away some settings on improve.)

8) Failing that, if XDG_CONFIG_HOME atmosphere variable is about, the trail is the “pulse” subdirectory to the listing laid out in XDG_CONFIG_HOME.

9) Nonetheless no path? Then fall again to utilizing the “.config/pulse” subdirectory beneath the present person’s house listing.

Okay, so possibly we will connect with the UNIX socket inside that user-level PulseAudio path. But when it doesn’t work, there are nonetheless a number of extra issues to strive:

10) Utilizing a path of a system-level PulseAudio server. This listing is /var/run/pulse on Ubuntu (and possibly most different distributions), or /usr/native/var/run/pulse in case you compiled PulseAudio from supply your self.

11) By checking shopper.conf for the important thing “auto-connect-localhost”. In that case, additionally strive connecting to tcp4:…

12) …and tcp6:[::1], too. After all we can not go away IPv6-only programs behind.

13) Because the final straw of hope, the library checks shopper.conf for the important thing “auto-connect-display”. If it’s set, it checks the DISPLAY atmosphere variable, and if it finds a hostname (i e, one thing earlier than the “:”), then that host might be tried too.

To summarise, first the shopper library checks for a server string in step 1-4, if there’s none, it makes a server string – out of 1 merchandise from steps 5-9, after which as much as 4 extra gadgets from steps 10-13.

And that’s all. If you happen to ever need to customise the way you connect with a PulseAudio server, you will have a smorgasbord of choices to select from!

David Henningssonhttp://voices.canonical.com/david.henningssonPulseAudio – A greater sounding worldhttp://voices.canonical.com/david.henningsson/class/pulseaudio/feed/2016-03-22T12:00:05+00:00Audio Units and Configurationhttp://arunraghavan.internet/?p=17342016-01-12T09:54:58+00:00

This one’s going to be a little bit of an extended put up. You may need to seize a cup of espresso earlier than you bounce in!

Over the previous few years, I’ve spent a while getting PulseAudio up and operating on a number of Android-based telephones. There was the preliminary Galaxy Nexus port, a proof-of-concept port of Firefox OS (git) to make use of PulseAudio as an alternative of AudioFlinger on a Nexus 4, and most just lately, a port of Firefox OS to make use of PulseAudio on the primary gen Moto G and final yr’s Sony Xperia Z3 Compact (git).

The method thus far has been largely handbook and painstaking, and I’ve been making an attempt to make that simpler. However earlier than I speak concerning the how of that, let’s see how all this works within the first place.

The Drawback

If in case you have managed to get by with out having to dig into this darkish pit, the porting course of may be one thing of an train in masochism. Extra so should you’re in my footwear and don’t have entry to any of the documentation for the audio {hardware}. {Hardware} distributors and OEMs normally don’t share these specs except beneath NDA, which is difficult to arrange as somebody simply hacking on these things as an experiment or for enjoyable of their spare time.

Broadly, the duty entails how the units is about up on Android, after which replicating that course of utilizing the usual ALSA library, which is what PulseAudio makes use of (this works as a result of each the Android and generic Linux userspace speak to the identical ALSA-based kernel audio drivers).

Android’s configuration

First, you have a look at the Android audio HAL code for the system you’re porting, and the corresponding mixer paths XML configuration. Between the 2 of those, you get an outline of how one can configure the {hardware} to play again audio in numerous use instances (music, tones, voice calls), and how one can route the audio (headphones, headset, audio system, Bluetooth).

Snippet from mixer paths XMLSnippet from mixer paths XML

On this instance, there’s one path that describes how one can arrange the {hardware} for “deep buffer playback” (used for music, the place you’ll be able to buffer a bunch of knowledge and let the CPU fall asleep). The subsequent path, “speaker”, tells us how one can arrange the routing to play audio out of the speaker.

These strings aren’t well-defined, so totally different {hardware} makes use of totally different path names and mixtures to arrange the {hardware}. The XML configuration additionally does not inform us a lot of issues, comparable to what format the {hardware} helps or what ALSA system to make use of. All of this data is embedded within the audio HAL code.

Configuring with ALSA

Subsequent, you might want to translate this configuration into one thing PulseAudio will perceive1. The popular methodology for that is ALSA’s UCM, which describes how one can arrange the {hardware} for every use case it helps, and how one can configure the routing in every of these use instances.

Snippet from UCMSnippet from UCM

It is a snippet from the “hi-fi” use case, which is the UCM use case roughly equivalent to “deep buffer playback” within the earlier part. Inside that, we’re trying on the “speaker system” and you’ll see the identical mixer controls as within the earlier XML file are toggled. This file does have some extra data — for instance, this snippet specifies what ALSA system needs to be used to toggle mixer controls (“hw:apq8064tablasnd”).

Doing the Porting

Usually, I begin with the “hi-fi” use case — what you’ll usually use for music playback (and will seemingly use for tones and comparable to properly). Getting the “cellphone” use case working is normally way more painful. Along with establishing the audio {hardware} just like th “hi-fi use case, it entails speaking to the modem, for which there isn’t a regular methodology throughout Android units. To complicate issues, the modem firmware may be extraordinarily delicate to the order/timing of setup, typically with no technique of debugging (a.okay.a. enjoyable instances!).

When there’s a new Android model, I want to have a look at all of the adjustments within the HAL and the XML file, redo the interpretation to UCM, after which take a look at every part once more.

That is clearly repetitive work, and I do know I’m not the one one having to do it. {Hardware} distributors typically face the identical problem when supporting the identical units on a number of platforms — Android’s HAL normally makes use of the XML config I confirmed above, ChromeOS’s CrAS and PulseAudio use ALSA UCM, Intel makes use of the parameter framework with its personal XML format.

Introducing xml2ucm

With this background, once I began trying on the Z3 Compact port final yr, I made a decision to put in writing a instrument to make this and future ports simpler. That instrument is creatively named xml2ucm2.

As we noticed, the ALSA UCM configuration comprises extra data than the XML file. It comprises an outline of the playback and mixer units to make use of, in addition to some details about configuration (channel depend, primarily). This data is normally hardcoded within the audio HAL on Android.

To cope with this, I launched a small configuration file that gives the extra data required to carry out the interpretation. The thought is that you just write this configuration as soon as, and may kind of carry out the interpretation robotically. If the HAL or the XML file adjustments, it needs to be straightforward to implement that as a change within the configuration and simply regenerate the UCM information.

Example xml2ucm configurationInstance xml2ucm configuration

This instance exhibits how the Android XML like within the snippet above may be transformed to the corresponding UCM configuration. As soon as I had the code carried out, porting all of the hi-fi bits on the Xperia Z3 Compact took about 30 minutes. The outcomes of this can be found as a extra full instance: the mixer paths XML, the config XML, and the generated UCM.

What’s subsequent

One huge lacking piece right here is voice calls. I spent a while making an attempt to get voice calls engaged on the 2 telephones I had obtainable to me (the Moto G and the Z3 Compact), however that is fairly difficult with out entry to {hardware} documentation and I ran out of spare time to commit to the issue. It might be good to have an entire working instance for a tool, although.

There are different configuration mechanisms on the market — notably Intel’s parameter framework. It might be attention-grabbing so as to add assist for that as properly. Ideally, the code might be prolonged to construct an entire mannequin of the audio routing/configuration, and generate any of the configuration that’s supported.

I’d like this instrument to be typically helpful, so be at liberty to put up feedback and options on Github or simply get in contact.

p.s. Thanks exit to Abhinav for all of the Haskell assist!

  1. One other strategy, which the Ubuntu Telephone and Jolla SailfishOS of us take, is to only use the Android HAL straight from PulseAudio to arrange and use the {hardware}. This is sensible to rapidly allow any arbitrary system (as a result of the HAL offers a hardware-independent interface to take action). In the long run, I want to allow utilizing UCM and alsa-lib straight because it offers us extra management, and permits us to make use of such options as PulseAudio’s dynamic latency adjustment if the {hardware} permits it. ↩

  2. You might need seen that the instrument is written in Haskell. Whereas that is decidedly not a preferred alternative of language, it did make for a comparatively straightforward implementation and offers a number of benefits. The unlucky price is that most individuals will discover it laborious to leap in and begin contributing. If in case you have a function request or bug repair however are having hassle translating it into code, please do file a bug, and I’d pleased to assist! ↩

Arun Raghavanhttp://arunraghavan.internetpulseaudio – Arun RaghavanOpen supply hackerhttp://arunraghavan.internet/tag/pulseaudio/feed/2016-05-20T05:00:07+00:00A Fast Replacehttp://arunraghavan.internet/?p=16652016-01-04T09:58:53+00:00

Comfortable 2016 everybody!

Whereas I did point out some time again (virtually two years in the past, wow) that I used to be taking a break, I realised just lately that I hadn’t posted an replace from once I began once more.

For the final yr and a half, I’ve been offering freelance consulting round PulseAudio, GStreamer, and numerous different straight and tangentially associated tasks. There’s a quick listing of the form of work I’ve been concerned in.

If you happen to’re searching for assist with PulseAudio, GStreamer, multimedia middleware or the rest you may’ve come throughout on this weblog, do get in contact!

Arun Raghavanhttp://arunraghavan.internetpulseaudio – Arun RaghavanOpen supply hackerhttp://arunraghavan.internet/tag/pulseaudio/feed/2016-05-20T05:00:07+00:002.1 encompass sound assisthttp://voices.canonical.com/david.henningsson/?p=3302015-12-15T12:53:29+00:00

2.1 encompass sound is (by a really unscientific measure) the third hottest encompass speaker setup, after 5.1 and seven.1. But, ALSA and PulseAudio has since a very long time again supported extra uncommon setups comparable to 4.0, 4.1 however not 2.1. It took till 2015 to get all items within the stack prepared for two.1 as properly.

The issue

So what made including 2.1 encompass tougher than different setups? Properly, at the beginning, as a result of ALSA used to have a hard and fast mapping of channels. The primary six channels have been determined to be:

1. Entrance Left
2. Entrance Proper
3. Rear Left
4. Rear Proper
5. Entrance Middle
6. LFE / Subwoofer

Thus, a 4 channel stream would default to the primary 4, which might then be a 4.Zero stream, and a 3 channel stream would default to the primary three. The one solution to ship a 2.1 channel stream would then be to ship a six channel stream with three channels being silence.

This was not adequate, as a result of some playing cards, together with laptops with inside subwoofers, would solely assist streaming 4 channels most.

(So as to add additional confusion, it appeared some playing cards wished the subwoofer sign on the third channel of 4, and others wished the identical sign on the fourth channel of 4 as an alternative.)

ALSA channel map API

The primary a part of the answer was a brand new alsa-lib API for channel mapping, permitting drivers to promote what channel maps they assist, and alsa-lib to show this data to packages (see snd_pcm_query_chmaps, snd_pcm_get_chmap and snd_pcm_set_chmap).

The second step was for the alsa-lib route plugin to utilize this data. With that, alsa-lib might itself decide whether or not the {hardware} was 5.1 or 2.1, and alter the variety of channels robotically.

PulseAudio bass / treble filter

With the alsa-lib additions, simply including one other channel map was straightforward.
Nonetheless, there was one other downside to cope with. When listening to stereo materials, we want the low frequencies, and solely these, to be performed again from the subwoofer. These frequencies must also be faraway from the opposite channels. In some instances, the {hardware} would have a built-in filter to do that for us, so then it was only a matter of setting enable-lfe-remixing in daemon.conf. In different instances, this wanted to be carried out in software program.

Subsequently, we’ve built-in a crossover filter into PulseAudio. You’ll be able to configure it by setting lfe-crossover-freq in daemon.conf.

The {hardware}

If in case you have a laptop computer with an inside subwoofer, likelihood is that it – with all these adjustments to the stack – nonetheless doesn’t work. As a result of the HDA normal (which is what your laptop computer very seemingly makes use of for analog audio), doesn’t have a lot of a channel mapping normal both! So distributors may determine to do issues in a different way, which signifies that each single {hardware} mannequin may want a patch within the kernel.

If you happen to don’t have an inside subwoofer, however a separate exterior one, you may be capable to use hdajackretask to reconfigure your headphone jack to an “Inside Speaker (LFE)” as an alternative. However the draw back of that, is that you just then can’t use the jack as a headphone jack…

Do I’ve it?

In Ubuntu, it’s been working because the 15.04 launch (vivid). If you happen to’re not operating Ubuntu, you want alsa-lib 1.0.28, PulseAudio 7, and a kernel from, say, mid 2014 or later.


Takashi Iwai wrote the channel mapping API, and in addition supplied assist and fixes for the alsa-lib route plugin work.

The crossover filter code was imported from CRAS (however after refactoring and cleanup, there was not a lot left of that code).

Hui Wang helped me write and take a look at the PulseAudio implementation.

PulseAudio upstream builders, particularly Alexander Patrakov, did an intensive overview of the PulseAudio patch set.

David Henningssonhttp://voices.canonical.com/david.henningssonPulseAudio – A greater sounding worldhttp://voices.canonical.com/david.henningsson/class/pulseaudio/feed/2016-03-22T12:00:05+00:00PulseAudio 7.1 is outhttp://arunraghavan.internet/?p=15952015-10-30T13:31:51+00:00

We simply rolled out a minor bugfix launch. Fast changelog:

  • Repair a crasher when utilizing srbchannel
  • Repair a construct system typo that brought about symlinks to show up in /
  • Make Xonar playing cards work higher
  • Different minor bug fixes and enhancements

Extra particulars on the mailing listing.

Due to everybody who contributed with bug reviews and testing. What isn’t typically seen is that loads of this occurs behind the scenes downstream on distribution bug trackers, IRC, and so forth.

Arun Raghavanhttp://arunraghavan.internetpulseaudio – Arun RaghavanOpen supply hackerhttp://arunraghavan.internet/tag/pulseaudio/feed/2016-05-20T05:00:07+00:00PSA: Breaking webrtc-audio-processing APIhttp://arunraghavan.internet/?p=15862015-10-28T17:35:41+00:00

I do know it’s been ages, however I’m now engaged on updating the webrtc-audio-processing library. You may keep in mind this because the code that we break up off from the webrtc.org code to make use of within the PulseAudio echo cancellation module.

That is principally simply the AudioProcessing module, bundled as a standalone library in order that we will use the implausible AEC, AGC, and noise suppression implementation from that code base. For packaging simplicity, I made a replica of the required code, and wrote an autotools-based construct system round that.

Now since I final copied the code, the library API has modified a bit — nothing drastic, just some minor cleanups and eliminated API. This wouldn’t usually be an enormous deal since this code isn’t really revealed as exterior API — it’s largely embedded within the Chromium and Firefox bushes, in all probability different tasks too.

Since we’re exposing a replica of this code as a standalone library, which means that there are two choices — we might (a) simply break the API, and all dependent code must be up to date to have the ability to use the brand new model, or (b) write a small wrapper to attempt to keep backwards compatibility.

I’m inclined to only break API and launch a brand new model of the library which isn’t backwards suitable. My rationale for that is that I’d wish to preserve the code as shut to what’s upstream as attainable, and over time it might grow to be painful to keep up a bunch of backwards-compatibility code.

A nicer answer could be to work with upstream to make it attainable to construct the AudioProcessing module as a standalone library. Whereas the parents upstream appeared amenable to the thought when this got here up a number of years in the past, no one has stepped as much as really do the work for this. In the intervening time, a lot of attention-grabbing options have been added to the module, and it could be good to tug this in to make use of in PulseAudio and every other tasks utilizing this code (extra about this in a follow-up put up).

So should you’re utilizing webrtc-audio-processing, be warned that the following launch will in all probability break API, and also you’ll have to replace your code. I’ll attempt to publish a fast replace information when releasing the code, however if you wish to have a look at the present API, check out the present audio_processing.h.

p.s.: If you happen to do use webrtc-audio-processing as a dependency, I’d love to listen to about it. So far as I do know, PulseAudio is the one person of this library for the time being.

Arun Raghavanhttp://arunraghavan.internetpulseaudio – Arun RaghavanOpen supply hackerhttp://arunraghavan.internet/tag/pulseaudio/feed/2016-05-20T05:00:07+00:00GUADEC 2015http://arunraghavan.internet/?p=15822015-08-21T06:21:27+00:00

This one’s a bit late, for causes that’ll be clear sufficient later on this put up. I had the pleased alternative to go to GUADEC in Gothenburg this yr (after lacking the final two, sadly). It was a fantastic, well-organised occasion, and I felt super-charged once more, assembly all of the folks making GNOME higher daily.

GUADEC picnic @ GothenbergGUADEC picnic @ Gothenberg

I introduced a standing replace of what we’ve been as much as within the PulseAudio world previously few years. Amazingly, all of the movies are up already, so you’ll be able to meet up with something that you just might need missed right here.

We additionally had a gathering of PulseAudio builders which and a lot of attention-grabbing subjects of debate got here up (I’ll attempt to summarise my notes in a separate put up).

A bunch of different attention-grabbing discussions occurred within the hallways, and I’ll write about that if my investigations take me some place attention-grabbing.

Now the draw back — I ended up lacking the BoF a part of GUADEC, and the entire GStreamer hackfest in Montpellier after. Because it occurs, I contracted dengue and I’m nonetheless recovering from this. Fortuitously it was the lesser (non-haemorrhagic) model with none problems, so now it’s only a matter of resting until I’ve recuperated utterly.

However, the primary a part of the journey was nice, and I’d wish to thank the GNOME Basis for sponsoring my journey and keep, with out which I’d have missed out on all of the GUADEC enjoyable this yr.

Sponsored by GNOME!Sponsored by GNOME!Arun Raghavanhttp://arunraghavan.internetpulseaudio – Arun RaghavanOpen supply hackerhttp://arunraghavan.internet/tag/pulseaudio/feed/2016-05-20T05:00:07+00:00GNOME Asia 2015http://arunraghavan.internet/?p=15722015-05-20T08:08:10+00:00

I used to be in Depok, Indonesia final week to talk at GNOME Asia 2015. It was a fantastic expertise — the organisers did a implausible job and as a bonus, the venue was extremely fairly!

View from our roomView from our room

My speak was concerning the GNOME audio stack, and my authentic intention was to speak a bit concerning the APIs, how one can use them, and the way to decide on which to make use of. After the primary day, although, I felt like a extra high-level view of the items could be extra helpful to the viewers, so I adjusted the main target a bit. My slides are up right here.

Nirbheek and I then spent a few days taking place to Yogyakarta to cycle round, go to some temples, and sip some tremendous hipster espresso.

All in all, it was every week properly spent. I’d wish to thank the GNOME Basis for serving to me get to the convention!

Sponsored by GNOME!Sponsored by GNOME!Arun Raghavanhttp://arunraghavan.internetpulseaudio – Arun RaghavanOpen supply hackerhttp://arunraghavan.internet/tag/pulseaudio/feed/2016-05-20T05:00:07+00:00T40 ec solderingtag:https://lunarius.fe80.eu/weblog,2015-04-12:coreboot-t40-ec-soldering.html2015-04-12T10:34:00+00:00

Some mates give me their previous {hardware} to assist me on my subsequent venture: Create an open supply
embedded controller firmware for Lenovo Thinkpads. My goal platform are all Lenovo Thinkpads
utilizing a Renesas/Hitachi H8S as EC. These chips constructed into Thinkpads from very previous one to new fashions just like the X230.

So what may be higher that utilizing a really previous laptop computer like a T40 to solder and do {hardware} mods?
Step one is flashing the chip unbiased from the Working System operating on the {hardware}.
Why that? As a result of the EC controls sure energy regulators and deal with turning the mainboard
on. A damaged EC would assist you to flip your Laptop computer on. The H8S helps totally different boot modes.
It might probably boot regular advance boot. The boot mode is
a particular mode for creating and flashing. It obtain their firmware over regular UART and execute it.
The H8S defines it boot mode over 2 pins – MD0 and MD1 – additionally named mode0 and mode1.
After trying on the schematics (which is obtainable on the web) we have to solder the UART pin RX, TX,
MD1, GND. MD0 is not required, as a result of it is already set to 0. I soldered the take a look at pin TP1, TP10 (I2C).
/RES was soldered too, as a result of I miscounted the pins. /RES lies beside of MD1. However it may be helpful later.
I coloured the pins on the underside image.

colour pin
Purple MD1
Orange GND
Blue /RES
Inexperienced RX
Yellow TX

T40 top. F2161B is EC.
T40 bottom. Yellow RX, Green TX, Blue /RES, Red MD1, Orange GND
How it looks. MD1 is missing here.

The soldered picture is lacking MD1.

Alexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:003com/HP Repair LACP Error ‘The port shouldn’t be configured correctly.’tag:https://lunarius.fe80.eu/weblog,2015-03-31:network-fix-3com-hp-lacp-error.html2015-03-30T23:23:00+00:00

I received the duty to setup LACP witch an not so new 3com siwtch on one aspect and a Debian Jessie + OpenVSwitch on the opposite. Often not a so huge downside. Simply be mindful, 3com was purchased by HP and continues to be utilizing 3com software program of their newer merchandise.
It is even attainable to replace an 3com swap with HP firmware should you’re fortunate to know which HP product matches your HP swap.
Again to the duty: setup LACP. I’ve carried out every part talked about within the handbook:
Test all ports are the identical media sort
All ports should be configured in the identical means
* have the identical LACP precedence

Every part appears be okay. The documentation additionally say that each one Ports will free their particular person port conifiguration when added.
On the swap aspect I can see the swap is displaying my Linux Field as port accomplice, however nonetheless the hyperlink group is not going into
‘Energetic’ state. Nonetheless displaying ‘The port shouldn’t be configured correctly.’.
An replace shouldn’t be a possibility from distant, to a lot service depends upon this swap.
Let’s take a better look on the VLAN configuration. The LACP group is not configured but for any VLAN. However the ports nonetheless
have an previous configuration with tagged VLAN and is in hybrid mode? Why? It has a PVID configured, however not an untagged
vlan asigned. Seems to be unusual.

Go to VLAN -> Modify Port: Choose each LACP ports in addition to the LACP group and set them into Trunk mode with none VLAN.
Now the LACP modified to lively. Perhaps this modified in newer HP firmware variations.

Alexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:00PulseAudio buffers and protocolhttp://voices.canonical.com/david.henningsson/?p=3222014-11-21T15:36:40+00:00

It is a technical put up about PulseAudio internals and the upcoming protocol enhancements within the upcoming PulseAudio 6.Zero launch.

PulseAudio reminiscence copies and buffering

PulseAudio is claimed to have a “zero-copy” structure. So let’s have a look at what copies and buffers are concerned in a typical playback state of affairs.

Shopper aspect

When PulseAudio server and shopper runs as the identical person, PulseAudio allows shared reminiscence (SHM) for audio information. (In different instances, SHM is disabled for safety causes.) Functions can use pa_stream_begin_write to get a pointer straight into the SHM buffer. When utilizing pa_stream_write or by means of the ALSA plugin, there might be one reminiscence copy into the SHM.

Server resampling and remapping

On the server aspect, the server may have to convert the stream right into a format that matches the {hardware} (and potential different streams that is likely to be operating concurrently). This step is skipped if deemed pointless.

First, the samples are transformed to both signed 16 bit or float 32 bit (primarily relying on resampler necessities).
In case resampling is critical, we make use of exterior resampler libraries for this, the default being speex.
Second, if remapping is critical, e g if the enter is mono and the output is stereo, that’s carried out as properly. Lastly, the samples are transformed to a format that the {hardware} helps.

So, in worst case, there is likely to be as much as 4 totally different buffers concerned right here (first: after changing to “work format”, second: after resampling, third: after remapping, fourth: after changing to {hardware} supported format), and in finest case, this step is solely skipped.

Mixing and {hardware} output

PulseAudio’s inbuilt mixer multiplies every channel of every stream with a quantity issue and writes the consequence to the {hardware}. In case the {hardware} helps mmap (reminiscence mapping), we write the combination consequence straight into the DMA buffers.


The perfect we will do is one copy in complete, from the SHM buffer straight into the DMA {hardware} buffer. I hope this clears up any confusion about what PulseAudio’s marketed “zero copy” capabilities means in observe.

Nonetheless, reminiscence copies shouldn’t be the one factor you need to keep away from to get good efficiency, which brings us to the following level:

Protocol enhancements in 6.0

PulseAudio does fairly properly CPU clever for top latency hundreds (e g music playback), however a bit worse for low latency hundreds (e g VOIP, gaming). Or to place it one other means, PulseAudio has a low per pattern price, however there’s nonetheless some optimisation that may be carried out per packet.

For each playback packet, there are three messages despatched: from server to shopper saying “I want extra information”, from shopper to server saying “right here’s some information, I put it in SHM, at this tackle”, after which a 3rd from server to shopper saying “thanks, I’ve no extra use for this SHM information, please reclaim the reminiscence”. The third message shouldn’t be despatched till the audio has really been performed again.
For each message, it means syscalls to put in writing, learn, and ballot a unix socket. This overhead turned out to be vital sufficient to attempt to enhance.

So as an alternative of placing simply the audio information into SHM, as of 6.Zero we additionally put the messages into two SHM ringbuffers, one in every course. For signalling we use eventfds. (There may be additionally an optimisation layer on high of the eventfd that tries to keep away from writing to the eventfd in case nobody is at present ready.) This isn’t a lot for saving reminiscence copies however to save lots of syscalls.

From my very own unscientific benchmarks (i e, operating “high”), this protects us ~10% – 25% of CPU energy in low latency use instances, half of that being on the shopper aspect.

David Henningssonhttp://voices.canonical.com/david.henningssonPulseAudio – A greater sounding worldhttp://voices.canonical.com/david.henningsson/class/pulseaudio/feed/2016-03-22T12:00:05+00:00Notes from the PulseAudio Mini Summit 2014http://arunraghavan.internet/?p=15412014-11-04T16:49:23+00:00

The third week of October was fairly action-packed, with an entire bunch of conferences taking place in Düsseldorf. The Linux audio developer neighborhood in addition to the PulseAudio builders every had an entire day of discussions associated to a variety of subjects. I’ll be summarising the occasions of the PulseAudio mini summit day right here. The dialogue was break up into two components, the primary half of the day with simply the present core builders and the latter half with members of the neighborhood collaborating as properly.

I’d wish to thank the Linux Basis for sparing us a room to hold out these discussions — it’s implausible that we’re capable of colocate such conferences with a bunch of different conferences, making it a lot simpler than it could in any other case be for all of us to converge to a single place, hash out concepts, and customarily have a very good time in actual life as properly!

Incontrovertible proof that all our users are happyComfortable faces — incontrovertible proof that everybody loves PulseAudio!

With an entire day of discussions, that is clearly going to be an extended put up, so that you may need to seize a espresso now. 🙂

Launch plan

We now have a number of blockers for six.0, and a few pending patches to merge (primarily HSP assist). As soon as that is carried out, we will proceed to our normal freeze → launch candidate → steady course of.

Construct simplification for BlueZ HFP/HSP backends

For simplifying packaging, it could be good to have the ability to construct all of the obtainable BlueZ module backends in a single shot. There wasn’t a lot opposition to this concept, and David (Henningsson) stated he may have a look at this. (as I replace this earlier than posting, he already has)

srbchannel plans

We briefly mentioned plans across the just lately launched shared ringbuffer channel code for communication between PulseAudio shoppers and the server. We talked concerning the efficiency advantages, and future plans comparable to direct communication between the shopper and server-side I/O threads.

Routing framework patches

Tanu (Kaskinen) has a long-standing set of patches so as to add a generic routing framework to PulseAudio, developed by notably Jaska Uimonen, Janos Kovacs, and different members of the Tizen IVI workforce. This work provides a set of recent ideas that we’ve not been solely comfy merging into the core. To unblock these patches, it was agreed that doing this work in a module and utilizing a protocol extension API could be extra useful. (Tanu later did a demo of the CLI extensions which were made for the brand new routing ideas)


As a consequence of the dialogue across the routing framework, David talked about that he’d wish to take ahead Colin’s precedence listing work in the meanwhile. Based mostly on our discussions, it regarded like it could be attainable to increase module-device-manager to make it port conscious and get the sort performance we would like (the power to have a priority-order listing of units). David was to look into this.

Module writing infrastructure

Relatedly, we mentioned the necessity to export the PA inside headers to permit externally constructed modules. We agreed that this is able to be okay to have if it was made abundantly clear that this API would have completely no stability ensures, and is usually meant to simplify packaging for specialised distributions.

Which led us to the opposite little bit of infrastructure required to put in writing modules extra simply — making our protocol extension mechanism extra generic. Presently, we’ve got a static listing of protocol extensions in our core. Altering this requires exposing our pa_tagstruct construction as public API, which we haven’t carried out. If we don’t need to try this, then we might expose a generic “throw this blob throughout the protocol” mechanism and go away it to the module/library to deal with marshalling/unmarshalling.

Resampler high quality analysis

Alexander shared a lot of his findings about resampler high quality on PulseAudio, vs. these discovered on Home windows and Mac OS. Some questions have been requested about different parameters, comparable to relative CPU consumption, and many others. There was additionally some dialogue on how one can attempt to carry this work to a conclusion, however no clear reply emerged.

It was additionally agreed on the premise of this work that assist for libsamplerate and ffmpeg might be phased out after deprecation.

Addition of a “hi-fi” mode

The dialogue got here round to the potential of having a mode the place (if the {hardware} helps it), PulseAudio simply performs out samples with out resampling, conversion, and many others. This has been introduced up previously for “audiophile” use instances the place the cardboard helps 88.2/96 kHZ and better pattern charges.

No objections have been raised to having such a mode — I’d wish to take this up at some stage in time.

LFE channel module

Alexander has some code for filtering low frequencies for the LFE channel, at present as a digital sink, that might finally be built-in into the core.


David raised a query concerning the present standing of rtkit and whether or not it must exist, and if that’s the case, the place. Lennart introduced up the truth that rtkit at present doesn’t work on systemd+cgroups based mostly setups (I don’t appear to have why in my notes, and I don’t recall off the highest of my head).

The conclusion of the dialogue was that some alternate coverage methodology for deciding RT privileges, probably inside systemd, could be wanted, however for now rtkit needs to be used (and glued!)


Discussions got here up about the potential of utilizing kdbus and/or memfd for the PulseAudio transport. That is attention-grabbing to me, there doesn’t appear to be an instantly clear profit over our SHM mechanism by way of efficiency, and a few work to guage how this might be used, and what the profit could be, must be carried out.

ALSA controls spanning a number of outputs

David has now submitted patches for controls that have an effect on a number of outputs (comparable to
“Headphone+LO”). These are at present being mentioned.

Audio teams

Tanu wish to add code to assist accumulating audio streams into “audio teams” to use collective coverage to them. I’m supposed to assist overview this, and Colin talked about that module-stream-restore already makes use of comparable ideas.

Stream and system objects

Tanu proposed the addition of recent objects to symbolize streams and objects. There didn’t appear to be consensus on including these, however there was settlement of a transparent have to consolidate frequent code from sink-input/source-output and sink/supply implementations. The thought was that having a typical mother or father object for every pair is likely to be a method to do that. I volunteered to assist with this if somebody’s taking it up.

Filter sinks

Alexander brough up the necessity for a filter API in PulseAudio, and that is one thing I actually wish to have. I’m presupposed to sketch out an API (although implementing that is non-trivial and can seemingly take time).

Dynamic PCM for HDMI

David plans to see if we will use profile availability to assist decide when an HDMI system is definitely obtainable.

Browser volumes

The usability of flat-volumes for browser use instances (the place the quantity of streams may be managed programmatically) was mentioned, and my patch to permit non-obligatory opt-out by a stream from collaborating in flat volumes got here up. Tanu and I are to proceed the dialogue already on the mailing listing to give you an answer for this.

Dealing with dangerous rewinding code

Alexander raised issues concerning the high quality of rewinding code in a few of our filter modules. The settlement was that we would have liked higher documentation on dealing with rewinds, together with how one can explicitly not permit rewinds in a sink. The instance digital sink/supply code additionally must be adjusted accordingly.

BlueZ native backend

Wim Taymans’ work on including again HSP assist to PulseAudio got here up. Because the assembly, I’ve reviewed and merged this code with the change we would like. Chatting with Luiz Augusto von Dentz from the BlueZ aspect, one thing we must also be capable to add again is for PulseAudio to behave as an HSP headset (utilizing the identical strategy as for HSP gateway assist).

Containers and PA

Takashi Iwai raised a query about what a great way to run PA in a container was. The suggestion was {that a} tunnel sink would seemingly be one of the best strategy.

Frequent ALSA configuration

Based mostly on dialogue from the day prior to this on the Linux Audio mini-summit, I’m supposed to have a look at the potential of consolidating the assorted mixer configuration codecs we at present need to cope with (primarily UCM and its implementations, and Android’s XML format).

(due to Tanu, David and Peter for reviewing this)

Arun Raghavanhttp://arunraghavan.internetpulseaudio – Arun RaghavanOpen supply hackerhttp://arunraghavan.internet/tag/pulseaudio/feed/2016-05-20T05:00:07+00:00Very brief how one can get well a dockstartag:https://lunarius.fe80.eu/weblog,2014-06-09:openwrt-dockstar-jtag.html2014-06-09T20:42:00+00:00

There are lot of howtos written for this subject however most will not labored for me.
Irky’s howto is superb.
I am mirroring his information right here and summarise his howto.
If in case you have any query look into his article.

The dockstar is particular system, as a result of it doesn’t assist serial boot like different Marvel kirkwood units.
E.g. while you bricked a Seagate GoFlex you’ll be able to get well it with out jtag over serial boot.
What’s serial boot?
Get better with out jtag

This howto is for the Seagate Dockstar examined on archlinux with openocd 0.8!

You want solely a buspirate with a jtag firmware, no serial
is required right here.


  • Obtain buspirate.cfg dockstar.cfg uboot.j.kwb
  • change ttyUSB1 to your buspirate interface in buspirate.cfg
  • join buspirate to the dockstar Dockstar pinout Buspirate pinout
  • energy the dockstar
  • openocd -f dockstar.cfg
  • telnet localhost 4444
  • enter “halt” into telnet session however do not hit enter
  • press reset button and really shortly after press enter into telnet session
  • when openocd exhibits “goal halted in ARM state on account of debug-request, present mode: Supervisor” every part is nice
  • when openocd exhibits “goal halted in Thumb state on account of debug-request, present mode: Supervisor” repeat halt + reset process
  • telnet: sheevaplug_init
  • telnet: nand probe 0
  • telnet: nand erase Zero 0x0 0xa0000
  • telnet: nand write Zero uboot.j.kwb Zero oob_softecc_kw
  • wait ~15 minutes
  • openocd exhibits a hit message

Alexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:00Headset jacks on newer laptopshttp://voices.canonical.com/david.henningsson/?p=3062014-03-07T10:17:18+00:00

Headsets are available many kinds and shapes. And laptops include differing types of headset jacks – there’s the traditional variant of 1 3.5 mm headphone jack and one 3.5 mm mic jack, and the newer (frequent on smartphones) 3.5 mm headset jack which may do each. USB and Bluetooth headsets are additionally fairly frequent, however that’s exterior the scope for this text, which is about various kinds of 3.5 mm (1/Eight inch) jacks and the way we assist them in Ubuntu 14.04.

You’d suppose this is able to be easy to assist, and for the traditional (and nonetheless frequent) model of getting one headphone jack and one mic jack that’s largely true, however newer {hardware} are available a number of variants.

If we speak concerning the typical TRRS headset – for the headset itself there are two competing requirements, CTIA and OMTP. CTIA is the extra frequent variant, a minimum of within the US and Europe, but it surely signifies that we’ve got laptop computer jacks supporting solely one of many variants, or each by autodetecting which kind has been plugged in.

Talking of autodetection, {hardware} differs there as properly. Some computer systems can autodetect whether or not a headphone or a headset has been plugged in, whereas others cannot. Some computer systems even have a “mic in” mode, so they’d have just one jack, however you’ll be able to manually retask it to be a microphone enter.
Lastly, a number of netbooks have one 3.5 mm TRS jack the place you’ll be able to plug in both a headphone or a mic however not a headset.

So, how would you realize which form of headset jack(s) you will have in your system? Properly, I discovered essentially the most dependable supply is to really have a look at the small icon current subsequent to the jack. Does it appear to be a headphone (with out mic), headset (with mic) or a microphone? If there are two icons separated by a slash “/”, it means “both or”.

For the jacks the place the {hardware} can not autodetect what has been plugged in, the person wants to do that manually. In Ubuntu 14.04, we now have a dialog:
In earlier variations of Ubuntu, you would need to go to the sound settings dialog and ensure the proper enter and output have been chosen. So nonetheless solvable, just some extra clicks. (The dialog may additionally be current in some Ubuntu preinstalls operating Ubuntu 12.04.)

So in userspace, we needs to be all set. Now let’s discuss kernels and particular person units.

Fairly frequent with Dell machines manufactured within the final yr or so, is the model the place the {hardware} can’t distinguish between headphones and headsets. These machines have to be quirked within the kernel, which signifies that for each new mannequin, someone has to insert a row in a desk contained in the kernel. With out that quirk, the jack will work, however with headphones solely.
So in case your Dell machine is certainly one of these and never at present supporting headset microphones in Ubuntu 14.04, right here’s what you are able to do:

  • Test which codec you will have: We at present can allow this for ALC255, ALC283, ALC292 and ALC668. “grep -r Realtek /proc/asound/card*” could be the quickest solution to determine this out.
  • Strive it for your self: edit /and many others/modprobe.d/alsa-base.conf and add the road “choices snd-hda-intel mannequin=dell-headset-multi”. (A couple of as an alternative want “choices snd-hda-intel mannequin=dell-headset-dock”, but it surely’s not that frequent.) Reboot your laptop and take a look at.
  • No matter whether or not you handle to resolve this or not, be at liberty to file a bug utilizing the “ubuntu-bug audio” command. Please take away the workaround from the earlier step (and reboot) earlier than submitting the bug. This may assist others with the identical {hardware}, in addition to serving to us upstreaming your repair to future kernels in case the workaround was profitable. Please preserve separate machines in separate bugs because it helps us monitor when a selected {hardware} is mounted.

Notes for folks not operating Ubuntu

  • Kernel assist for many newer units appeared in 3.10. Extra quirks have been added to even newer kernels, however most of them are with CC to steady, so will hopefully seem in 3.10 as properly.
  • PulseAudio assist is current in 4.Zero and newer.
  • The “what did you plug in”-dialog is part of unity-settings-daemon. The code is free software program and obtainable right here.

David Henningssonhttp://voices.canonical.com/david.henningssonPulseAudio – A greater sounding worldhttp://voices.canonical.com/david.henningsson/class/pulseaudio/feed/2016-03-22T12:00:05+00:004 yearshttp://arunraghavan.internet/?p=14582014-02-02T14:34:50+00:00

4 years and what looks as if a lifetime in the past, I jumped aboard the ship Collabora Multimedia, and set sail for journey and lands unknown. We sailed by means of unusual new seas, to unique lands, defeated many monsters, and, I really feel, had some optimistic affect on the world round us. Final Friday, on my request, I received dropped again on the shore.

I’ve had an insanely enjoyable time at Collabora, working with absurdly gifted and devoted folks. However, I’ve come to the purpose the place I really feel like I want one thing of a break. I’m undecided what’s subsequent, aside from a month or two of relaxation and leisure — studying, biking, journey, and catching up with a few of the issues I’ve been promising to do if solely I had extra time. Sure, that features PulseAudio and GStreamer hacking as properly. 🙂

And there’ll be extra updates and weblog posts too!

Arun Raghavanhttp://arunraghavan.internetpulseaudio – Arun RaghavanOpen supply hackerhttp://arunraghavan.internet/tag/pulseaudio/feed/2016-05-20T05:00:07+00:00Utilizing jabber on jolla with an personal certificatestag:https://lunarius.fe80.eu/weblog,2014-01-12:jolla-jabber-certificate.html2014-01-12T22:42:00+00:00

The Sailfish xmpp shopper integrates good into your contacts, however does not work
with your individual jabber server as lengthy you’re utilizing self-signed certificates.
It is because SailfishOS even checks per default the server certificates, which is nice!
However there is no such thing as a GUI so as to add you personal CA or certificates, so you do not get any connection to an
server which makes use of an unknown certificates.
IMHO business Certificates Authority are damaged by design, however that is one other story :).
The same old reply for a working jabber is disable the certificates verify for
your xmpp. You’re disabling each function of ssl (which isn’t
a lot as lengthy over hundrets of CA are in your chain).
With checking you will have a bit bit extra
secury than nothing. As different you’ll be able to add the certificates to the telepathy chain.
The jabber shopper (telepathy-gabble) have an extra folder of certificates. telepathy
add certificates from /house/nemo/.config/telepathy/certs/ earlier than loading all certificates
from /and many others/pki/tls/certs/ca-bundle.crt. Simply put it into that folder.

# mkdir -p /house/nemo/.config/telepathy/certs/
# cp /house/nemo/Downloads/jabber-ca_or_cert.crt /house/nemo/.config/telepathy/certs/

I’ve re-added my jabber account to make the certificates work. :Perhaps a reboot will apply
your certificates as properly.

Alexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:00Epilogue: Fourier evaluation and testingtag:blogger.com,1999:blog-5277334794032322951.post-62880605531501323842013-10-10T16:49:15+00:00Hello.

It is time for the ultimate replace of my GSoC venture. The final a part of my GSoC was all about enhancing the resampler take a look at instances for PulseAudio. Since loads of DSP testing depends upon the Fourier transformation, I am going to attempt to clarify it briefly right here.

The Fourier remodel converts a periodic sign right into a sum of sines and cosines of various frequencies and phases. This fashion we will see the amplitude and frequency of the elemental sine waves that make out our sign.

Lets check out a 440Hz sine wave just like the one beneath.

~100 samples of a 440Hz sine wave

It is a easy sine wave with none increased harmonics so we do not count on to see a lot in our remodeled sign. The pattern format of our sine wave is 16-bit PCM. We will see that our amplitude is at about 50% (32768 could be loudest for 16-bit PCM and we’re at about 16000) or -6dB.

Beneath we will see the Fourier remodel of our sine wave.

We will clearly see a pleasant spike at 440Hz with an amplitude of -6dB. If our sine wave would include a elementary sine wave at 440Hz and the next harmonic at 880Hz we might see two spikes.

Now there are another spikes, albeit fairly small ones, which signifies that our authentic sine wave didn’t solely comprise a elementary wave at 440Hz. The opposite spikes are thought of to be noise. This fashion we will measure the sign to noise ratio (SNR). We check out the amplitude of our sign and the very best amplitude of an undesirable spike and divide them. Straightforward, is not it?

Lets take a last have a look at a remodeled sign. Beneath is the Fourier remodel of a logarithmic chirp (logarithmically swept sine wave) from 440Hz to 48kHz which was run by means of a resampler.

We will see that the beginning frequency is certainly round 440Hz however at about 20kHz our amplitude begins to fall off. This occurred as a result of our resampler was good sufficient to filter out frequencies above the audible stage (or frequencies which might be increased than half of the sampling frequency) to keep away from aliasing.

These take a look at and graphs at the moment are simply reproducible utilizing the brand new and glossy ‘resampler-quality-test’ which generates arbitrary sine or chirp indicators and runs them by means of the resampler (the consequence may be saved) and a fft.py script which plots the Fourier remodel of a WAVE file.

Some extra enhancements have been made to the already present resampler take a look at case however these aren’t so attention-grabbing.

That is all for this yr’s GSoC. It was a enjoyable and productive expertise. I need to take a second and thank my mentor for this yr, Peter Meerwald, for all the assistance and pleasant exchanges throughout the summer time, and my final yr’s mentor Tanu Kaskinen for a similar good remedy final yr.

Goodbye.poljar[email protected]http://poljar.blogspot.com/Summer season Of Weblogtag:blogger.com,1999:blog-52773347940323229512020-02-29T06:00:07+00:00hacking smartwatch 2tag:https://lunarius.fe80.eu/weblog,2013-09-12:smartwatch2-first-steps.html2013-09-12T21:42:00+00:00

The smartwatch 2 is sony’s new smartwatch. I received one from a hackerthon in Berlin, the place everyone
who attended received one from Sony. I favored to open it, however I am a litte bit scared broking it is waterproofness.
So I am going to await ifixit or different disassembly web site.
Nonetheless I am what’s inside and the way does it really works?

The software program aspect closely relying in your android cellphone. There are some functions operating
direct on the watch. Like alarm clock, settings, countdown.
Every part else is operating in your cellphone and utilizing it is show as canvas. Sure, you’re writing over bluetooth
right into a canvas.
When you’re clicking in your watch, the Sony Smartwatch app in your cellphone is sending an broadcast intent
which is beginning your app. However that could be a service within the background.
For extra data look into ligi’s github repo.

Now get into the firmware and {hardware}. As Sony already written for the smartwatch (1) you’ll be able to straightforward
entry the dfu bootloader. It is a dfu compatable bootloader.
As already described on Sony’s hacker documentation

  • Shutdown your smartwatch
  • Disconnect usb cable
  • solely join micro usb connector to smartwatch
  • you will have round 1sec for this: press the powerbutton, plug the opposite usb cable finish to the pc and launch the powerbutton

dfu-util -l will present you when it is linked.
You’ll be able to learn and write it. Let’s look into it.
dfu-util -l

Discovered DFU: [0fce:f0fa] devnum=0, cfg=1, intf=0, alt=0, title="@Inside Flash   /0x08000000/03*016Kg,01*016Kg,01*064Kg,07*128Kg,03*016Kg,01*016Kg,01*064Kg,07*128Kg"
Discovered DFU: [0fce:f0fa] devnum=0, cfg=1, intf=0, alt=1, title="@eMMC /0x00000000/01*512Mg"

I believe all firmware is positioned inside the first flash. It is the interior one. An eMMC is an soldered sdcard.
As a result of we’ve got the identical partition format twice, I believe that is used for OTA firmware replace. It is a frequent case
on embedded system. Double measurement your flash and break up it into 2 an identical components. I am going to title the primary half A and half B is the opposite half.
We’re booting half A, now an OTA replace comes, the firmware will write this into half B and inform the bootloader:
‘Strive the B partition however solely as soon as.’ Now the system will reboot and the bootloader boot half B. When the brand new firmware profitable booted it tells the bootloader ‘Boot everytime B now’. If the brand new firmware fails in B, the system must be reboot and falling again besides half A. This may be carried out by a {hardware} watchdog robotically.

I imagine on the emmc we’ll discover all extra icons and software title we put in over the android.
Keep in mind the smartwatch is simply a distant show with sensors. Nothing extra.

Let’s disassemble the firmware. Put your system into dfu mode.
dfu has additionally add capabilities. Add means from system to a file. Obtain is for firmware flashing.
Add the 2M flash right into a file.

dfu-util -a 0 -U /tmp/smartwatch_internal -s 0x08000000:2097152

Now let’s do a easy strings /tmp/smartwatch_internal.
As we all know from the settings menu we’ve got an STM32F42x, a Cortex M4.
Have a look at the filenames.

Technical Particulars:

sort: chip [interfaces] (detailed description)
CPU: STM32F4xx (STM32F-427 or 429)
RAM: 256okay
ROM/flash: 2M
eMMC: 512M? [connected over sdio] (possibly much less I might solely load 128M over dfu-util. May be additionally a edge in dfu-util)
BT: STLC2690 (low energy however solely BT 3.0. I guess low energy means not BT4.0 low energy. However it appears to has an personal cortex m3 + fw improve performance)
Accelerometer: bma250 [SPI (4-wire, 3-wire), i2c, 2 interrupt pins] (Bosch Sensoric)
Compass: ak8963 [SPI, I2C]  (actually? sony didn't uncovered it or is that this only a leftover from a debug board?)
NFC-tag: ntag203f [interupt pin for rf-activity] (solely a tag - the mcu solely is aware of if it received learn)
Contact: ttsp3 (i'm not certain if this is a Cypress TTSP with i2c)
LiIonController: Max17048 [i2c] (gas gauge and battery controller)
Gentle/AmbientSensor: Taos TSL2771 [I2C]
RTC: included CPU
Show: TC358763XBG [SPI (3,4 wire), SSI for display data; i2c, spi, pwm for control] (Show Controller)
Buzzer: GPIO wired

Many of the sensors and actors are already supported by linux kernel as a result of they’re inbuilt some (Sony) smartphones.
No I do not need run linux on it. However we’ve got already working driver which we will adapt for an alternate firmware.

Search or github’ seek for STM32F4xx_StdPeriph_Driver which is freely obtainable SDK.
I believe they do not written an entire firmware from scratch. Due to some strings I suppose it is a ‘uCos’ prolonged
to their wants.

Sony please present us with the proper wiring of the sensors and actors so we will construct our personal firmware?!

Alexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:00Ubuntu Contact audio stack for 13.10 launchhttp://voices.canonical.com/david.henningsson/?p=2952013-08-27T12:00:22+00:00

Up till now, we’ve been utilizing Android’s AudioFlinger for taking part in again and recording audio. Beginning with tomorrow’s picture, that’s now not true. As an alternative we’re speaking straight from PulseAudio to ALSA, or the Android audio HAL when crucial.

Briefly, right here’s how PulseAudio now works:

  • For regular playback and recording, PulseAudio talks on to alsa-lib, simply as on the desktop.
  • For detecting whether or not a headphone/headset is plugged in or not, PulseAudio now has code for studying that from the Android kernel, by means of the “swap” interface.
  • For regular mixer setup, we use ALSA UCM mixer information.
  • For establishing voice calls, we speak to the Android Audio HAL by means of a PulseAudio module.

This offers considerably of a compromise between options and porting effort: Through the use of the ALSA library at any time when we will, we will entry PulseAudio’s timer scheduling and dynamic latency options. Having the straightest path attainable for taking part in again music ought to assist effectivity (and in extension, battery life). At the least in idea – we haven’t really carried out measurements.

Utilizing the Audio HAL for every part mixer associated would have been optimum, but it surely seems that the audio HAL is simply too good: it refuses to arrange the mixer, except PCM information can also be despatched to it, which is what we wished to keep away from. So then we needed to arrange the mixer manually too. Nonetheless, we nonetheless couldn’t keep away from utilizing the Audio HAL altogether: when beginning and stopping voice calls, the Audio HAL talks to the modem and different elements within the kernel to route the voice name between the modem and the sound card. Therefore we ended up with this compromise strategy.

Present standing
On the time of this writing, that is working finest on Nexus 4. The Galaxy Nexus works for essentially the most half, apart from bug 1217072. I intend so as to add Nexus 7 assist shortly. If anybody needs to assist testing Nexus 10, let me know.

For porters: if you might want to do the identical

Sadly, this implies some extra work for porters, as a result of you might want to write UCM mixer information. What’s worse, UCM is missing good documentation. For that motive, I hesitated considerably earlier than deciding to really use UCM in any respect, but it surely’s the closest we’ve got to a regular for establishing mixers on embedded units proper now.

However to present you a two-minute crash course in UCM and the way it’s utilized in Ubuntu Contact – begin by taking a look in /usr/share/alsa/ucm/apq8064-tabla-snd-card/ listing. You’ll have to create an identical listing in your system. You’ll discover the best listing title should you look in /proc/asound/playing cards.

Second, have a look at apq8064-tabla-snd-card.conf. Rename and replica into your individual UCM listing. If you happen to’re making a pill picture (that may’t make voice calls), you’ll be able to take away the VoiceCall half (and the corresponding file).

Third, have a look at the HiFi file. That is the place all enjoyable occurs. Discover the system names, that are hardcoded into telepathy-ofono and have to match: “Speaker”, “Earpiece” and “Headphone” for playback, plus “Handset” and “Headset” for recording.

Fourth, should you want voice calls, additionally have a look at the VoiceCall file. Btw, the verb names “HiFi” and “VoiceCall” additionally have to match.) That is largely empty, as a result of the mixer setup is dealt with by the Audio HAL, however there’s a twist right here that took some time to get proper: For PulseAudio’s UCM to work, it must open a PCM system. Nonetheless, on the time the place UCM exams this, the voice name shouldn’t be but arrange. So, you may have to arrange the mixer just a bit, in order that the PCM can open. (On desktops, PCM can all the time open, no matter mixer state. This isn’t all the time true on embedded units, which might be utilizing ASoC.) It’s a bonus if you could find a PCM that truly performs again audio, as a result of then you may get notification sounds whereas on the cellphone.

And this concludes the 2 minute crash course – pleased porting!

(Facet be aware: Sorry if the permalink – or remark pages and many others – to this weblog leads you to a clean web page. I’ve reported the bug to the related workforce in Canonical, however on the time of this posting, they’re trying into it however haven’t but mounted it.)

David Henningssonhttp://voices.canonical.com/david.henningssonPulseAudio – A greater sounding worldhttp://voices.canonical.com/david.henningsson/class/pulseaudio/feed/2016-03-22T12:00:05+00:00Vol 2: Resampling strategiestag:blogger.com,1999:blog-5277334794032322951.post-78128265813182706122013-08-12T05:29:17+00:00Hello.
Time for an replace. This time I’ll speak a bit bit concerning the totally different resampling strategies and resampling basically. So lets begin with a fast introduction to resampling.

Beneath is a determine of a discrete time illustration of a 440Hz sine wave. The sine wave is sampled at a price (or sampling frequency) of 48kHz. Which means that roughly each 0.02ms a pattern of our sine wave is taken so for one second of sound 48000 samples are wanted.

440Hz sine wave sampled at 48kHz

Now if the clock in our sound card helps this frequency, we will simply feed it our sine wave and it’ll play it simply tremendous. If this isn’t the case, we might get pitch shifted output identical to when the playback pace on an previous tape recorder or turntable is elevated or decreased.

Conceptually, we might reconstruct our analog sign and pattern it at our new pattern price to acquire our desired discrete time illustration. However this isn’t a extremely sensible answer and we use pure mathematical options as an alternative. One in all them is linear interpolation. Proven beneath is our authentic sine wave resampled by way of linear interpolation to 96kHz which signifies that we now have twice as many samples than in our authentic sampled sine wave.

440Hz sine wave resampled to 96kHz

There are a lot of totally different resampling strategies and implementations. PulseAudio already helps fairly a number of. I added assist for some extra and examined their efficiency.

Listed below are the newly added strategies:

  • libswresample (lswr beneath)
  • libavresample (lavr beneath)
  • sox resampler (soxr beneath)

And listed here are the take a look at outcomes:

Efficiency utilizing signed 16-bit integers because the pattern format

These outcomes needs to be taken with a grain of salt as a result of the totally different resampling strategies don’t carry the identical high quality. Essentially the most attention-grabbing resampler right here appears to be soxr utilizing cubic interpolation.

Beneath is similar take a look at however this time utilizing floating level numbers because the pattern format:

Efficiency utilizing floating level numbers because the pattern format

Once more soxr right here appears to be essentially the most promising.

Which of those new resampling strategies will discover their means into the grasp tree of PulseAudio stays to be seen.

This ended up considerably longer than anticipated, however I hope it was attention-grabbing.

Thanks in your consideration!poljar[email protected]http://poljar.blogspot.com/Summer season Of Weblogtag:blogger.com,1999:blog-52773347940323229512020-02-29T06:00:07+00:00PulseAudio 4.Zero and Skypehttp://arunraghavan.internet/?p=14422013-08-02T16:10:26+00:00

It is a public service announcement for packagers and customers of Skype and PulseAudio 4.0.

In PulseAudio 4.0, we added some code to permit us to cope with computerized latency adjustment extra gracefully, notably for latency requests beneath ~80 ms. This uncovered a bug in Skype that breaks audio in attention-grabbing methods (no sound, uneven sound, playback occurs sooner than it ought to).

We’ve spoken to the Skype builders about this downside they usually have been investigating the issue. In the intervening time, we recommend that customers and packagers work round this downside in the meanwhile.

If you’re packaging Skype in your distribution, you might want to change the Exec line in your Skype .desktop file as follows:

Exec=env PULSE_LATENCY_MSEC=60 skype %U

If you’re a person, and your distribution doesn’t already carry this repair (as of a couple of week in the past, Ubuntu does, and as of ~1 hour from now, Gentoo will), you might want to launch Skype from the command line as follows:


If you happen to’re undecided should you’re hit however this bug, you’re in all probability not. 🙂

Arun Raghavanhttp://arunraghavan.internetpulseaudio – Arun RaghavanOpen supply hackerhttp://arunraghavan.internet/tag/pulseaudio/feed/2016-05-20T05:00:07+00:00first step on an extended journeytag:https://lunarius.fe80.eu/weblog,2013-07-18:pulseaudio-first-part.html2013-07-17T22:42:00+00:00

After studying some documentation and loads of code. A in some way working module
evolves. It helps easy module argument, it could connect with a distant server and
additionally performs audio.

However the issues beginning right here, as a result of threads are good and may damage you due to context.
For the primary model it’s good to listen to voices in my ears popping out of audio system over a community.
I applied an early model with loads of downsides:

  • no latency informations
  • threading points
  • no zerocopy

What I’ve carried out unsuitable was attaching libpulse on pulse server mainloop. Each context and stream callback was run by the mainloop in addition to learn operations. Not good factor. Solely pa_sink_render is working inside the I/O thread.
Zero copy for now’s damaged by libpulse, as a result of utilizing pa_stream_write and not using a free_callback will copy the samples into an inside buffer.

However for the primary model okay. Fixing my threading downside is straightforward transfer every part inside our thread.
What means create a mainloop for the libpulse. My first thought, that might not be laborious, as a result of epoll, a contemporary environment friendly choose substitute helps chaining. Simply chain or mix rt_poll with our libpulse mainloop.
Not a straightforward answer. Combining a mainloop ballot and a rt ballot is difficult, due to two lists of filedescriptors which cannot be easy appended. Each lists get generated every time ballot runs.

Stepping a step again and asking why ought to I exploit rt_poll? Is there one other answer which inserts way more the idea of utilizing a second mainloop?
A thread solely working as a mainloop must also work. The one job what the thread should take case is the pa_thread_mq.

Alexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:00how pulse module are structured?tag:https://lunarius.fe80.eu/weblog,2013-07-18:pulseaudio-how-modules-works.html2013-07-17T22:23:00+00:00

On my journey to a brand new module-tunnel I took a better look into different modules.
Pulseaudio received modules for occasion dealing with, received modules for os driver frameworks like alsa, oss, solaris.
Additionally there a drivers to speak over the native community. Beginning with mod-native-protocol-tcp to permit
distant pulseaudio connections, there’s additionally assist for esound, zeroconf, rtp or raop.
Modify sound stream samples can also be attainable, have a look into the filters.

To put in writing a {hardware} driver or community based mostly driver I’d suggest studying null-sink, raop-sink and esound-sink.

After trying round into a number of pulse modules. It’s clear that a lot of the module which act as a sink
have the next construction and close by the identical code beside from driver particular components.
void thread_func() {
/ laborious work /

int pa__init(pa_module*m) {
    /* parse + validate + copy module arguments */
    pa_modargs_new(m->argument, valid_modargs)

    /* init driver particular */

    /* setup an actual time ballot */
    u->rtpoll = pa_rtpoll_new();

    /* setup a message queue */
    pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll
    pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);

    /* create a thread */
    pa_thread_new("null-sink", thread_func, u)

    /* register sink */

int pa__done(pa_module*m) {
    /* deinit personal construction + free every part */

All sink modules have an actual time ballot operating in a seperated thread, typically additionally caled I/O thread. That is due to [http://www.freedesktop.org/wiki/Software/PulseAudio/Documentation/Developer/Threading/|the threading model]. In abstract it says “do not block the mainloop and do the laborious work inside the I/O loop.”
Again to our thread, is has to do the true work of our module. It is dequeuing information from
a sink buffer, mixing and adjusting volumes. This set of duties is called rendering. It’s carried out by pa_sink_render.

Syncronisation is finished by message queues between mainloop and I/O loop named pa_thread_mq which has 2 pa_asyncmsgq one enter queue for message to the thread and one output queue from thread to the mainloop.
rtpoll shouldn’t be as powerfull a mainloop is, however you’ll be able to register a minimum of a filehandler packed inside rt_poll_item. While you write a community protocol this might be your socket.

Alexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:00My gsoc venture pulseaudio mod-tunneltag:https://lunarius.fe80.eu/weblog,2013-07-17:pulseaudio-starting-blogging.html2013-07-17T21:42:00+00:00

After one month right here comes my first weblog put up about it.
My gsoc venture is creating a brand new mod-tunnel utilizing libpulse api.

You should utilize module-tunnel to attach your native pulseaudio to a distant pulseaudio.
That is fairly usefull, as a result of you’ll be able to stream over the community your audio from laptop computer to a devoted sound system
with actual audio system. With pavucontrol you’ll be able to transfer easy transfer a stream from native output system to the distant one.
Together with mod-zeroconf-discover and mod-zeroconf-publish it is going to computerized discover different pulseaudio servers and
connects to them.

What module-tunnel actually does is making a digital sound card in your native pulseaudio server. On the distant website
it creates a shopper as each different regular sound software like mplayer, vlc, […]

Why I am rewriting an entire module?’
Earlier than saying something about it, mod-tunnel appears to be a really previous module from the start.
However it has loads of draw back beside the nice one which it really works as lengthy you will have a steady connection to the distant server.

  • It cannot get well from any form of errors.
  • mod-tunnel doing all of the shopper protocol stack by itself as an alternative of utilizing the well-tested and well-written libpulse with callbacks and state machines.
  • including new options is troublesome due to it is easy construction

Alexander Couzenshttps://lunarius.fe80.eu/weblog/lynxariushttps://lunarius.fe80.eu/weblog/2020-12-13T06:00:08+00:00Vol 1. Refactoringtag:blogger.com,1999:blog-5277334794032322951.post-36272582761948976542013-07-14T18:09:45+00:00

Hello. Time for a fast replace about my Summer season of Code venture.
I’ll speak a bit about my first guidelines merchandise, refactoring the resampling code. Whereas refactoring is not fairly thrilling as implementing new options it’s a necessity to guarantee code maintainability.

So let’s check out the resampler interface and see what we will do. The interface consists of a pa_resampler construction which we create if we need to do some resampling. This construction holds all of our settings the resampler cares about, (pattern specs, totally different buffers) but in addition some particular information for various resampling implementations.
The attention-grabbing bits are proven bellow.

struct pa_resampler {
void (*impl_free)(pa_resampler *r);
void (*impl_update_rates)(pa_resampler *r);
void (*impl_resample)(pa_resampler *r, const pa_memchunk *in,
unsigned in_samples, pa_memchunk *out,
unsigned *out_samples);
void (*impl_reset)(pa_resampler *r);

struct { /* information particular to the trivial resampler */
unsigned o_counter;
unsigned i_counter;
} trivial;

struct { /* information particular to the height finder pseudo resampler */
unsigned o_counter;
unsigned i_counter;

float max_f[PA_CHANNELS_MAX];
int16_t max_i[PA_CHANNELS_MAX];

} peaks;

After the implementation particular perform pointers we will see a number of constructions holding implementation particular information. Because the resampler cannot swap implementations on the fly (with out destroying and recreating a resampler) solely certainly one of these constructions is used at a time.
There are six of these constructions contained within pa_resampler and a few of them have solely a single member which is kind of pointless.

Additional bellow of the file we see an enormous init_table containing the mapping between a resampling methodology (an enumeration) and its initialization perform.

static int (* const init_table[])(pa_resampler*r) = {
[PA_RESAMPLER_SRC_SINC_BEST_QUALITY] = libsamplerate_init,
[PA_RESAMPLER_SRC_SINC_FASTEST] = libsamplerate_init,
[PA_RESAMPLER_SRC_ZERO_ORDER_HOLD] = libsamplerate_init,
[PA_RESAMPLER_SRC_LINEAR] = libsamplerate_init,
[PA_RESAMPLER_TRIVIAL] = trivial_init,

As we will see there are fairly some duplicates right here. There are a complete of 32 entries whereas solely having 6 distinctive init features. There may be one other huge desk like this containing the implementation names, this desk does not comprise any duplicates however it could be good if we might group the implementation names into smaller implementation particular tables.

So with out additional ado right here is the primary code snippet with the suitable adjustments.

struct pa_resampler {
pa_resampler_implementation implementation;

All of the implementation particular information is now contained inside a single construction.
And right here is how the equal second code snippet appears like.

static pa_resampler_implementation *impl_table[] = {
[PA_RESAMPLER_SRC_SINC_FASTEST] = &libsamplerate_impl,
[PA_RESAMPLER_TRIVIAL] = &trivial_impl,
[PA_RESAMPLER_FFMPEG] = &ffmpeg_impl,
[PA_RESAMPLER_AUTO] = &auto_impl,
[PA_RESAMPLER_PEAKS] = &peaks_impl,

No extra duplicate entries right here.
And eventually right here is how the pa_resampler_implementation construction is outlined.

struct pa_resampler_implementation {
int (*init)(pa_resampler *r);
void (*free)(pa_resampler *r);
void (*update_rates)(pa_resampler *r);
void (*resample)(pa_resampler *r, const pa_memchunk *in,
unsigned in_samples, pa_memchunk *out,
unsigned *out_samples);
void (*reset)(pa_resampler *r);
void *information;
const char *names[PA_RESAMPLER_MAX_VARIANTS];

The implementation particular constructions are changed by a easy opaque information entry and the implementations init perform takes care of the allocating. The large names desk can also be now break up up and contained inside this construction.

These adjustments aren’t but merged upstream and a few of it could change if wanted. Additional particulars are on my github web page.
Thats it for now, subsequent time there needs to be a extra attention-grabbing subject. Thanks in your consideration and bye.

poljar[email protected]http://poljar.blogspot.com/Summer season Of Weblogtag:blogger.com,1999:blog-52773347940323229512020-02-29T06:00:07+00:00PulseAudio 4.Zero and extrahttp://arunraghavan.internet/?p=14332013-06-04T02:45:41+00:00

And we’re again … PulseAudio 4.Zero is out! There’s each a brief and super-detailed changelog within the launch notes. For the lazy, this launch brings a bunch of Bluetooth stability updates, higher low latency dealing with, efficiency enhancements, and an entire lot extra. 🙂

One attention-grabbing factor is that for this launch, we saved a parallel subsequent department open whereas grasp was frozen for stabilising and releasing. Consequently, we’re already properly on our solution to 5.Zero with 52 commits since 4.Zero already merged into grasp.

And at last, I’m excited to announce PulseAudio goes to be finishing up two nice tasks this summer time, as a part of the Google Summer season of Code! We’re going to have Alexander Couzens (lynxis) engaged on a rewrite of module-tunnel utilizing libpulse, mentored by Tanu Kaskinen. Along with this, Damir Jelić (poljar) engaged on enhancements to resampling, mentored by Peter Meerwald.

That’s simply a few of the issues to stay up for in coming months. I’ve received a number of extra issues I’d like to put in writing about, however I’ll save that for one more put up.

Arun Raghavanhttp://arunraghavan.internetpulseaudio – Arun RaghavanOpen supply hackerhttp://arunraghavan.internet/tag/pulseaudio/feed/2016-05-20T05:00:07+00:00Preludetag:blogger.com,1999:blog-5277334794032322951.post-28268529664160008662013-06-02T13:46:53+00:00Hi there and welcome to my new weblog.

This weblog ought to primarily function a small developer log over the period of this yr’s Google Summer season of Code. I am going to attempt to preserve it brief and technical.

This yr, like final yr, I am collaborating as a scholar for PulseAudio. My major job for this yr is to replace the resampling code.

So here is a listing of issues I’ve the privilege to work on over the summer time:

  • refactor and cleanup the resampling code
  • allow resampling with libavresample
  • allow resampling with libswresample
  • deprecate the ffmpeg resampling methodology
  • substitute libspeex with opus instruments
  • enhance resampling exams

What all of this precisely means might be defined another time.

That is all for now. Bye!
poljar[email protected]http://poljar.blogspot.com/Summer season Of Weblogtag:blogger.com,1999:blog-52773347940323229512020-02-29T06:00:07+00:00PulseAudio in GSoC 2013http://arunraghavan.internet/?p=14262013-04-11T11:34:48+00:00

That’s proper — PulseAudio might be collaborating within the Google Summer season of Code once more this yr! We had a fantastic set of scholars and tasks final yr, and also you’ve already seen some their work within the final launch.

There are some extra particulars on how one can get entangled on the mailing listing. We’re trying ahead to having one other set of good and enthusiastic new contributors this yr!

p.s.: Mentors and college students from organisations (GStreamer and BlueZ, for instance), do be at liberty to get in contact with us if in case you have concepts for tasks associated to PulseAudio that overlap with these different tasks.

Arun Raghavanhttp://arunraghavan.internetpulseaudio – Arun RaghavanOpen supply hackerhttp://arunraghavan.internet/tag/pulseaudio/feed/2016-05-20T05:00:07+00:00The Greatest Mythshttp://0pointer.de/weblog/tasks/the-biggest-myths.html2013-01-26T01:43:00+00:00

Since we first proposed systemd
for inclusion within the distributions it has been steadily mentioned in
many boards, mailing lists and conferences. In these discussions one
can typically hear sure myths about systemd, which might be repeated over and
over once more, however actually do not acquire any reality by fixed
repetition. Let’s take the time to debunk a number of of them:

  1. Fable: systemd is monolithic.

    If you happen to construct systemd with all configuration choices enabled you
    will construct 69 particular person binaries. These binaries all serve totally different
    duties, and are neatly separated for a lot of causes. For instance,
    we designed systemd with safety in thoughts, therefore most daemons run at
    minimal privileges (utilizing kernel capabilities, for instance) and are
    answerable for very particular duties solely, to attenuate their safety
    floor and affect. Additionally, systemd parallelizes the boot greater than any
    prior answer. This parallization occurs by operating extra processes
    in parallel. Thus it’s important that systemd is properly break up up into
    many binaries and thus processes. In truth, many of those
    binaries[1] are separated out so properly, that they’re very
    helpful exterior of systemd, too.

    A bundle involving 69 particular person binaries can hardly be known as
    monolithic. What’s totally different from prior options nevertheless,
    is that we ship extra elements in a single tarball, and keep them
    upstream in a single repository with a unified launch cycle.

  2. Fable: systemd is about pace.

    Sure, systemd is quick (A
    fairly full userspace boot-up in ~900ms, anybody?), however that is
    primarily only a side-effect of doing issues proper. In truth, we
    by no means actually sat down and optimized the final tiny little bit of efficiency
    out of systemd. As an alternative, we really steadily knowingly picked the
    barely slower code paths in an effort to preserve the code extra
    readable. This doesn’t suggest being quick was irrelevant for us, however
    decreasing systemd to its pace is actually fairly a false impression,
    since that’s actually not wherever close to the highest of our listing of

  3. Fable: systemd’s quick boot-up is irrelevant for

    That’s simply utterly not true. Many directors really are
    eager on lowered downtimes throughout upkeep home windows. In Excessive
    Availability setups it is kinda good if the failed machine comes again
    up actually quick. In cloud setups with numerous VMs or
    containers the value of sluggish boots multiplies with the variety of
    situations. Spending minutes of CPU and IO on actually sluggish boots of
    tons of of VMs or containers reduces your system’s density
    drastically, heck, it even prices you extra power. Gradual boots may be
    fairly financially costly. Then, quick booting of containers permits
    you to implement a logic comparable to socket
    activated containers, permitting you to drastically enhance the
    density of your cloud system.

    After all, in lots of server setups boot-up is certainly irrelevant, however
    systemd is meant to cowl the entire vary. And sure, I’m conscious
    that always it’s the server firmware that prices essentially the most time at
    boot-up, and the OS anyhow quick in comparison with that, however properly, systemd
    continues to be presupposed to cowl the entire vary (see above…), and no,
    not all servers have such dangerous firmware, and positively not VMs and
    containers, that are servers of a sort, too.[2]

  4. Fable: systemd is incompatible with shell scripts.

    That is solely bogus. We simply do not use them for the boot
    course of, as a result of we imagine they don’t seem to be one of the best instrument for that
    particular goal, however that does not imply systemd was incompatible with
    them. You’ll be able to simply run shell scripts as systemd providers, heck, you
    can run scripts written in any language as systemd providers,
    systemd does not care the slightest bit what’s inside your
    executable. Furthermore, we closely use shell scripts for our personal
    functions, for putting in, constructing, testing systemd. And you may stick
    your scripts within the early boot course of, use them for regular providers,
    you’ll be able to run them at newest shutdown, there are virtually no

  5. Fable: systemd is troublesome.

    This is also whole non-sense. A systemd platform is definitely a lot
    easier than conventional Linuxes as a result of it unifies
    system objects and their dependencies as systemd models. The
    configuration file language may be very easy, and redundant
    configuration information we removed. We offer uniform instruments for a lot
    of the configuration of the system. The system is far much less
    conglomerate than conventional Linuxes are. We even have fairly
    complete documentation (all linked
    from the homepage) about just about each element of systemd, and
    this not solely covers admin/user-facing interfaces, but in addition developer

    systemd actually comes with a studying curve. Every part
    does. Nonetheless, we wish to imagine that it’s really easier to
    perceive systemd than a Shell-based boot for most individuals. Stunned
    we are saying that? Properly, because it seems, Shell shouldn’t be a fairly language to
    be taught, it is syntax is arcane and sophisticated. systemd unit information are
    considerably simpler to grasp, they don’t expose a programming
    language, however are easy and declarative by nature. That every one stated, if
    you’re skilled in shell, then sure, adopting systemd will take a
    little bit of studying.

    To make studying straightforward we tried laborious to offer the utmost
    compatibility to earlier options. However not solely that, on many
    distributions you will discover that a few of the conventional instruments will now
    even inform you — whereas executing what you’re asking for — the way you
    might do it with the newer instruments as an alternative, in a probably nicer means.

    Anyway, the take-away might be that systemd might be as
    easy as such a system may be, and that we strive laborious to make it straightforward
    to be taught. However sure, if you realize sysvinit then adopting systemd will
    require a bit studying, however fairly frankly should you mastered sysvinit,
    then systemd needs to be straightforward for you.

  6. Fable: systemd shouldn’t be modular.

    Not true in any respect. At compile time you will have a lot of
    configure switches to pick out what you need to construct, and what
    not. And we
    doc how one can choose in much more element what you want,
    going past our configure switches.

    This modularity shouldn’t be completely in contrast to the one of many Linux kernel,
    the place you’ll be able to choose many options individually at compile time. If the
    kernel is modular sufficient for you then systemd needs to be fairly shut,

  7. Fable: systemd is just for desktops.

    That’s actually not true. With systemd we attempt to cowl fairly
    a lot the identical vary as Linux itself does. Whereas we take care of desktop
    makes use of, we additionally care just about the identical means for server makes use of, and
    embedded makes use of as properly. You’ll be able to wager that Purple Hat would not make it a
    core piece of RHEL7 if it wasn’t the most suitable choice for managing providers
    on servers.

    Individuals from quite a few firms work on systemd. Automobile manufactureres
    construct it into automobiles, Purple Hat makes use of it for a server working system, and
    GNOME makes use of lots of its interfaces for enhancing the desktop. You discover
    it in toys, in house telescopes, and in wind generators.

    Most options I most just lately labored on are in all probability related
    totally on servers, comparable to container
    assist, useful resource
    administration or the safety
    options. We cowl desktop programs fairly properly already, and there
    are variety of firms doing systemd improvement for embedded, some
    even supply consulting providers in it.

  8. Fable: systemd was created as results of the NIH syndrome.

    This isn’t true. Earlier than we started engaged on systemd we have been
    pushing for Canonical’s Upstart to be extensively adopted (and Fedora/RHEL
    used it too for some time). Nonetheless, we finally got here to the
    conclusion that its design was inherently flawed at its core (a minimum of
    in our eyes: most essentially, it leaves dependency administration to
    the admin/developer, as an alternative of fixing this tough downside in code),
    and if one thing’s unsuitable within the core you higher substitute it, fairly
    than repair it. This was hardly the one motive although, different issues that
    got here into play, such because the licensing/contribution settlement mess
    round it. NIH wasn’t one of many causes, although…[3]

  9. Fable: systemd is a freedesktop.org venture.

    Properly, systemd is actually hosted at fdo, however freedesktop.org is
    little else however a repository for code and documentation. Just about
    any coder can request a repository there and dump his stuff there (as
    lengthy because it’s considerably related for the infrastructure of free
    programs). There is not any cabal concerned, no “standardization” scheme, no
    venture vetting, nothing. It is only a good, free, dependable place to
    have your repository. In that regard it is a bit like SourceForge,
    github, kernel.org, simply not business and with out over-the-top
    necessities, and therefore a very good place to maintain our stuff.

    So sure, we host our stuff at fdo, however the implied assumption of
    this fantasy in that there was a gaggle of people that meet after which agree
    on how the longer term free programs appear to be, is solely bogus.

  10. Fable: systemd shouldn’t be UNIX.

    There is definitely some reality in that. systemd’s sources don’t
    comprise a single line of code originating from authentic UNIX. Nonetheless,
    we derive inspiration from UNIX, and thus there is a ton of UNIX in
    systemd. For instance, the UNIX concept of “every part is a file” finds
    reflection in that in systemd all providers are uncovered at runtime in a
    kernel file system, the cgroupfs. Then, one of many authentic
    options of UNIX was multi-seat assist, based mostly on built-in terminal
    assist. Textual content terminals are hardly the state-of-the-art the way you
    interface together with your laptop today nevertheless. With systemd we
    introduced native multi-seat
    assist again, however this time with full assist for immediately’s {hardware},
    overlaying graphics, mice, audio, webcams and extra, and all that absolutely
    computerized, hotplug-capable and with out configuration. In truth the
    design of systemd as a collection of built-in instruments that every have their
    particular person functions however when used collectively are extra than simply the sum
    of the components, that is just about on the core of UNIX philosophy. Then,
    the way in which our venture is dealt with (i.e. sustaining a lot of the core OS
    in a single git repository) is far nearer to the BSD mannequin (which is
    a real UNIX, in contrast to Linux) of doing issues (the place a lot of the core OS
    is saved in a single CVS/SVN repository) than issues on Linux ever
    have been.

    Finally, UNIX is one thing totally different for everyone. For us
    systemd maintainers it’s one thing we derive inspiration from. For
    others it’s a faith, and very like the opposite world religions there
    are totally different readings and understandings of it. Some outline UNIX
    based mostly on particular items of code heritage, others see it simply as a set
    of concepts, others as a set of instructions or APIs, and even others as a
    definition of behaviours. After all, it’s not possible to ever make all
    these folks pleased.

    Finally the query whether or not one thing is UNIX or not issues
    little or no. Being technically wonderful is hardly unique to
    UNIX. For us, UNIX is a significant affect (heck, the largest one), however
    we additionally produce other influences. Therefore in some areas systemd might be
    very UNIXy, and in others a bit bit much less.

  11. Fable: systemd is advanced.

    There is definitely some reality in that. Fashionable computer systems are advanced
    beasts, and the OS operating on it is going to therefore need to be advanced
    too. Nonetheless, systemd is actually no more advanced than prior
    implementations of the identical elements. A lot fairly, it is easier, and
    has much less redundancy (see above). Furthermore, constructing a easy OS based mostly
    on systemd will contain a lot fewer packages than a standard Linux
    did. Fewer packages makes it simpler to construct your system, removes
    interdependencies and of a lot of the totally different behaviour of each
    element concerned.

  12. Fable: systemd is bloated.

    Properly, bloated actually has many alternative definitions. However in
    most definitions systemd might be the alternative of bloat. Since
    systemd elements share a typical code base, they have a tendency to share a lot
    extra code for frequent code paths. Here is an instance: in a standard
    Linux setup, sysvinit, start-stop-daemon, inetd, cron, dbus, all
    applied a scheme to execute processes with numerous configuration
    choices in a sure, hopefully clear atmosphere. On systemd the code
    paths for all of this, for the configuration parsing, in addition to the
    precise execution is shared. This implies much less code, much less place for
    errors, much less reminiscence and cache stress, and is thus an excellent
    factor. And as a side-effect you really get a ton extra performance
    for it…

    As talked about above, systemd can also be fairly modular. You’ll be able to select
    at construct time which elements you want, and which you do not
    want. Individuals can therefore particularly select the extent of “bloat” they

    While you construct systemd, it solely requires three dependencies: glibc,
    libcap and dbus. That is it. It might probably make use of extra dependencies, however
    these are solely non-obligatory.

    So, yeah, whichever means you have a look at it, it is actually not

  13. Fable: systemd being Linux-only shouldn’t be good to the BSDs.

    Fully unsuitable. The BSD of us are just about bored with
    systemd. If systemd was transportable, this is able to change nothing, they
    nonetheless would not undertake it. And the identical is true for the opposite Unixes in
    the world. Solaris has SMF, BSD has their very own “rc” system, they usually
    all the time maintained it individually from Linux. The init system may be very
    near the core of the whole OS. And these different working programs
    therefore outline themselves amongst different issues by their core
    userspace. The belief that they’d undertake our core userspace if we
    simply made it transportable, is totally with none basis.

  14. Fable: systemd being Linux-only makes it not possible for Debian to undertake it as default.

    Debian helps non-Linux kernels of their distribution. systemd
    will not run on these. Is that an issue although, and may that hinder
    them to undertake system as default? Probably not. The parents who ported
    Debian to those different kernels have been prepared to speculate time in a large
    porting effort, they arrange take a look at and construct programs, and patched and
    constructed quite a few packages for his or her objective. The maintainance of each a
    systemd unit file and a traditional init script for the packaged providers
    is a negligable quantity of labor in comparison with that, particularly since
    these scripts most of the time exist already.

  15. Fable: systemd might be ported to different kernels if its maintainers simply wished to.

    That’s merely not true. Porting systemd to different kernel shouldn’t be
    possible. We simply use too many Linux-specific interfaces. For a number of
    one may discover replacements on different kernels, some options one may
    need to flip off, however for many that is nor actually attainable. Here is a
    small, very incomprehensive listing: cgroups, fanotify, umount2(),
    (together with notification), /dev/swaps (similar),
    udev, netlink,
    the construction of /sys, /proc/$PID/comm,
    /proc/$PID/cmdline, /proc/$PID/loginuid, /proc/$PID/stat,
    /proc/$PID/session, /proc/$PID/exe, /proc/$PID/fd, tmpfs, devtmpfs,
    capabilities, namespaces of every kind, numerous prctl()s, quite a few
    the mount() system name and its semantics, selinux, audit,
    inotify, statfs, O_DIRECTORY, O_NOATIME, /proc/$PID/root, waitid(),
    SCM_CREDENTIALS, SCM_RIGHTS, mkostemp(), /dev/enter, ...

    And no, should you have a look at this listing and select the few the place you’ll be able to
    consider apparent counterparts on different kernels, then suppose once more, and
    have a look at the others you did not choose, and the complexity of changing

  16. Fable: systemd shouldn’t be transportable for no motive.

    Non-sense! We use the Linux-specific performance as a result of we want
    it to implement what we would like. Linux has so many options that
    UNIX/POSIX did not have, and we need to empower the person with
    them. These options are extremely helpful, however provided that they’re
    really uncovered in a pleasant solution to the person, and that is what we do
    with systemd.

  17. Fable: systemd makes use of binary configuration information.

    No concept who got here up with this loopy fantasy, but it surely’s completely not
    true. systemd is configured just about completely by way of easy textual content
    information. A couple of settings you can too alter with the kernel command line
    and by way of atmosphere variables. There’s nothing binary in its
    configuration (not even XML). Simply plain, easy, easy-to-read textual content

  18. Fable: systemd is a function creep.

    Properly, systemd actually covers extra floor that it used to. It is
    not simply an init system anymore, however the fundamental userspace constructing
    block to construct an OS from, however we rigorously be certain that to maintain most of
    the options non-obligatory. You’ll be able to flip so much off at compile time, and
    much more at runtime. Thus you’ll be able to select freely how a lot function
    creeping you need.

  19. Fable: systemd forces you to do one thing.

    systemd shouldn’t be the mafia. It is Free Software program, you are able to do with it
    no matter you need, and that features not utilizing it. That is just about
    the alternative of “forcing”.

  20. Fable: systemd makes it not possible to run syslog.

    Not true, we rigorously made certain after we launched
    the journal that each one information can also be handed on to any syslog daemon
    operating. In truth, if one thing modified, then solely that syslog will get
    extra full information now than it received earlier than, since we now cowl early
    boot stuff in addition to STDOUT/STDERR of any system service.

  21. Fable: systemd is incompatible.

    We strive very laborious to offer the absolute best compatibility with
    sysvinit. In truth, the overwhelming majority of init scripts ought to work simply
    tremendous on systemd, unmodified. Nonetheless, there really are certainly a number of
    incompatibilities, however we attempt to doc
    these and clarify what to do about them. Finally each system
    that’s not really sysvinit itself could have a specific amount of
    incompatibilities with it because it won’t share the exect similar code

    It’s our objective to make sure that variations between the assorted
    distributions are saved at a minimal. Which means unit information normally
    work simply tremendous on a unique distribution than you wrote it on, which
    is an enormous enchancment over traditional init scripts that are very laborious to
    write in a means that they run on a number of Linux distributions, on account of
    quite a few incompatibilities between them.

  22. Fable: systemd shouldn’t be scriptable, due to its D-Bus use.

    Not true. Just about each single D-Bus interface systemd offers
    can also be obtainable in a command line instrument, for instance in systemctl,
    and suchlike. You’ll be able to simply name these instruments from shell scripts, they
    open up just about the whole API from the command line with
    easy-to-use instructions.

    That stated, D-Bus really has bindings for nearly any scripting
    language this world is aware of. Even from the shell you’ll be able to invoke
    arbitrary D-Bus strategies with dbus-send
    or gdbus. If
    something, this improves scriptability because of the good assist of D-Bus
    within the numerous scripting languages.

  23. Fable: systemd requires you to make use of some arcane configuration
    instruments as an alternative of permitting you to edit your configuration information

    Not true in any respect. We provide some configuration instruments, and utilizing them
    will get you a little bit of extra performance (for instance, command line
    completion for all settings!), however there is no want in any respect to make use of
    them. You’ll be able to all the time edit the information in query straight if you want,
    and that is absolutely supported. After all generally you might want to explicitly
    reload configuration of some daemon after modifying the configuration,
    however that is just about true for many UNIX providers.

  24. Fable: systemd is unstable and buggy.

    Actually not in line with our information. We now have been monitoring the
    Fedora bug tracker (and a few others) intently for an extended very long time. The
    variety of bugs may be very low for such a central element of the OS,
    particularly should you low cost the quite a few RFE bugs we monitor for the
    venture. We’re fairly good in maintaining systemd out of the listing of
    blocker bugs of the distribution. We now have a comparatively quick
    improvement cycle with largely incremental adjustments to maintain high quality and
    stability excessive.

  25. Fable: systemd shouldn’t be debuggable.

    False. Some folks attempt to suggest that the shell was a very good
    debugger. Properly, it is not actually. In systemd we give you precise
    debugging options as an alternative. For instance: interactive debugging,
    verbose tracing, the power to masks any element throughout boot, and
    extra. Additionally, we offer documentation
    for it.

    It is actually properly debuggable, we would have liked that for our personal
    improvement work, in spite of everything. However we’ll grant you one factor: it makes use of
    totally different debugging instruments, we imagine extra acceptable ones for the
    goal, although.

  26. Fable: systemd makes adjustments for the adjustments’ sake.

    Very a lot unfaithful. We just about completely have technical
    causes for the adjustments we make, and we clarify them within the numerous
    items of documentation, wiki pages, weblog articles, mailing listing
    bulletins. We strive laborious to keep away from making incompatible adjustments, and
    if we will we attempt to doc the why and the way intimately. And should you
    marvel about one thing, simply ask us!

  27. Fable: systemd is a Purple-Hat-only venture, is personal property
    of some smart-ass builders, who use it to push their views to the

    Not true. Presently, there are 16 hackers with commit powers to the
    systemd git tree. Of those 16 solely six are employed by Purple Hat. The 10
    others are of us from ArchLinux, from Debian, from Intel, even from
    Canonical, Mandriva, Pantheon and a lot of neighborhood of us with
    full commit rights. They usually steadily commit huge stuff, main
    adjustments. Then, there are 374 people with patches in our tree, and
    they too got here from a lot of totally different firms and backgrounds,
    and plenty of of these have means a couple of patch within the tree. The
    discussions about the place we need to take systemd are carried out within the open,
    on our IRC channel (#systemd on freenode, you’re all the time
    weclome), on our mailing
    listing, and on public hackfests (such
    as our subsequent one in Brno, you’re invited). We frequently attend
    numerous conferences, to gather suggestions, to clarify what we’re doing
    and why, like few others do. We keep blogs, have interaction in social
    networks (we really
    have some fairly attention-grabbing content material on Google+, and our Google+
    Group is fairly alive, too.), and take a look at actually laborious to clarify
    the why and the how how we do issues, and to hearken to suggestions and
    work out the place the present points are (for instance, from that
    suggestions we compiled this lists of typically heard myths about

    What most systemd contributors in all probability share is a tough concept how a
    good OS ought to appear to be, and the need to make it occur. Nonetheless,
    by the very nature of the venture being Open Supply, and rooted within the
    neighborhood systemd is simply what folks need it to be, and if it is not
    what they need then they will drive the course with patches and
    code, and if that is not possible, then there are quite a few different
    choices to make use of, too, systemd isn’t unique.

    One objective of systemd is to unify the dispersed Linux panorama a
    bit. We attempt to do away with lots of the extra pointless variations of
    the assorted distributions in numerous areas of the core OS. As a part of
    that we generally undertake schemes that have been beforehand utilized by just one
    of the distributions and push it to a stage the place it is the default of
    systemd, making an attempt to softly push everyone in the direction of the identical set of fundamental
    configuration. That is by no means unique although, distributions can
    proceed to deviate from that if they want, nevertheless, in the event that they end-up
    utilizing the well-supported default their work turns into a lot simpler and
    they may acquire a function or two. Now, because it seems, extra
    steadily than not we really adopted schemes that the place Debianisms,
    fairly than Fedoraisms/Redhatisms as finest supported scheme by
    systemd. For instance, programs operating systemd now typically retailer
    their hostname in /and many others/hostname, one thing that was once
    particular to Debian and now’s used throughout distributions.

    One factor we’ll grant you although, we generally may be
    smart-asses. We attempt to be ready at any time when we open our mouth, in
    order to have the ability to back-up with information what we declare. Which may make
    us seem as smart-asses.

    However basically, sure, a few of the extra influental contributors of
    systemd work for Purple Hat, however they’re within the minority, and systemd is
    a wholesome, open neighborhood with totally different pursuits, totally different
    backgrounds, simply unified by a number of tough concepts the place the journey ought to
    go, a neighborhood the place code and its design counts, and positively not
    firm affiliation.

  28. Fable: systemd does not assist /usr break up from the foundation listing.

    Non-sense. Since its beginnings systemd helps the
    --with-rootprefix= choice to its configure script
    which lets you inform systemd to neatly break up up the stuff wanted
    for early boot and the stuff wanted for afterward. All this logic is
    absolutely current and we preserve it up-to-date proper there in systemd’s construct

    After all, we nonetheless do not suppose that truly
    booting with /usr unavailable is a good suggestion, however we
    assist this simply tremendous in our construct system. This would possibly not repair the
    inherent issues of the scheme that you will encounter all throughout the
    board, however you’ll be able to’t blame that on systemd, as a result of in systemd we
    assist this simply tremendous.

  29. Fable: systemd does not permit your to interchange its elements.

    Not true, you’ll be able to flip off and substitute just about any a part of
    systemd, with only a few exceptions. And people exceptions (comparable to
    journald) typically assist you to run an alternate aspect by aspect to
    it, whereas cooperating properly with it.

  30. Fable: systemd’s use of D-Bus as an alternative of sockets makes it intransparent.

    This declare is already contradictory in itself: D-Bus makes use of sockets
    as transport, too. Therefore at any time when D-Bus is used to ship one thing
    round, a socket is used for that too. D-Bus is usually a standardized
    serialization of messages to ship over these sockets. If something this
    makes it extra clear, since this serialization is properly
    documented, understood and there are quite a few tracing instruments and
    language bindings for it. That is very a lot in contrast to the standard
    homegrown protocols the assorted traditional UNIX daemons use to
    talk regionally.

Hmm, did I write I simply wished to debunk a “few” myths? Perhaps these
have been greater than just some… Anyway, I hope I managed to clear up a
couple of misconceptions. Thanks in your time.


[1] For instance, systemd-detect-virt,
systemd-udevd are.

[2] Additionally, we are attempting to do our little half on possibly
making this higher. By exposing boot-time efficiency of the firmware
extra prominently in systemd’s boot output we hope to disgrace the
firmware writers to scrub up their stuff.

[3] And anyhow, guess which venture features a library “libnih” — Upstart or systemd?[4]

[4] Trace: it is not systemd!

Lennart Poetteringhttp://0pointer.de/weblogPID EINS!Lennart’s Webloghttp://colin.guthr.ie/mezcalero/2014-08-31T17:00:05+00:00PulseAudio 3.0http://arunraghavan.internet/?p=14122012-12-18T07:57:46+00:00

Yay, we simply launched PulseAudio 3.0! I’m not going to rehash the changelog that you could find within the launch announcement in addition to the longer launch notes.

I wish to thank the 36 contributors over the past 6 months who’ve made this launch what it’s and proceed to exhibit what a vibrant neighborhood we’ve got!

Arun Raghavanhttp://arunraghavan.internetpulseaudio – Arun RaghavanOpen supply hackerhttp://arunraghavan.internet/tag/pulseaudio/feed/2016-05-20T05:00:07+00:00PulseConf 2012: Reporthttp://arunraghavan.internet/?p=13802012-11-06T11:04:22+00:00

For these of you who missed my earlier updates, we just lately organised a PulseAudio miniconference in Copenhagen, Denmark final week. The organisation of all this was spearheaded by ALSA and PulseAudio hacker, David Henningsson. The nice of us organising the Ubuntu Developer Summit / Linaro Join have been type sufficient to permit us to colocate this occasion. A giant due to each of them for making this attainable!

The room where the first PulseAudio conference took placeThe room the place the primary PulseAudio convention passed off

The convention was attended by the 4 present lively PulseAudio builders: Colin Guthrie, Tanu Kaskinen, David Henningsson, and myself. We have been joined by long-time contributors Janos Kovacs and Jaska Uimonen from Intel, Luke Yelavich, Conor Curran and Michał Sawicz.

We began the convention at round 9:30 am on November 2nd, and really managed to maintain to the ultimate schedule(!), so I’m going to interrupt this report down into sub-topics for every merchandise which can hopefully make for simpler studying than an essay. I’ve additionally put up some pictures from the convention on the Google+ occasion.

Mission and Imaginative and prescient

We began off with a broad subject — what every of our private visions/objectives for the venture are. Curiously, two major themes emerged: having essentially the most seamless desktop person expertise attainable, and ensuring we’re well-suited to the embedded world.

Most of us expressed curiosity in ensuring that customers of varied desktops had a easy, hassle-free audio expertise. Within the superb case, they’d by no means want to seek out out what PulseAudio is!

Orthogonally, a lot of us are additionally very serious about making PulseAudio a powerful contender within the embedded house (cell phones, tablets, set high bins, automobiles, and so forth). Whereas we already discover PulseAudio being utilized in a few of these, there are areas the place we will do higher (extra in later subjects).

There was some reservation expressed about different, less-used options comparable to community playback being ignored due to this focus. The conclusion after some dialogue was that this is able to not be the case, as a lot of embedded use-cases do make use of those and different “fringe” options.

Growing patch bandwidth

Contributors to PulseAudio might be conscious that our patch queue has been rising for the previous few months on account of lack of developer time. We mentioned a number of methods to cope with this downside, essentially the most promising of which was a periodic triage assembly.

We might be establishing a rotating schedule the place every of us will organise a gathering each 2 weeks (the interval may change as we implement issues) the place we will go over excellent patches and hopefully clear backlog. Colin has agreed to arrange the primary of those.

Routing infrastructure

Subsequent on the agenda was a presentation by Janos Kovacs concerning the work they’ve been doing at Intel with enhancing the PulseAudio’s routing infrastructure. These are being constructed from the attitude of IVI programs (i.e., automobiles) which generally have pretty advanced use instances involving a number of concurrent units and customers. The slides for the speak might be put up right here shortly (edit: slides at the moment are obtainable).

The speak was mingled with a Q&A kind dialogue with Janos and Jaska. The primary merchandise of debate was consolidating Colin’s priority-based routing concepts into the proposed infrastructure. The broad considering was that the concepts have been broadly suitable and needs to be implementable within the new mannequin.

There was additionally some dialogue on merging the module-combine-sink performance into PulseAudio’s core, in an effort to make 1:N routing simpler. Some options utilizing te module-filter-* have been proposed. Additional dialogue will seemingly be required earlier than that is resolved.

The subsequent steps for this work are for Jaska and Janos to interrupt up the code into smaller logical bits in order that we will begin to overview the ideas and code intimately and work in the direction of finally merging as a lot as is sensible upstream.

Low latency

This session was taken up in opposition to the background of enhancing latency for video games on the desktop (though it does produce other functions). The indicated required latency for video games was given as 16 ms (equivalent to a body price of 60 fps). Quite a few concepts to cope with the issue have been introduced up.

Firstly, it was recommended that the maxlength buffer attribute when establishing streams might be used to sign a tough restrict on stream latency — the shopper indicators that it’s going to want an underrun, over a latency above maxlength.

One other long-standing merchandise was to analyze the reason for underruns as we decrease latency on the stream — David has already begun taking this up on the LKML.

Lastly, one other long-standing subject is the buffer attribute adjustment carried out throughout stream setup. This isn’t very well-suited to low-latency functions. David and I might be this in coming days.

Merging per-user and system modes

Tanu led the subject of discovering a solution to cope with use-cases comparable to mpd or multi-user programs, the place entry to the PulseAudio daemon of the lively person by one other person is likely to be desired. A number of options have been put ahead, although a particular conclusion was not reached, as additional thought is required.

Tanu’s suggestion was a break up between a per-user daemon to handle duties comparable to per-user configuration, and a system-wide daemon to handle the precise audio sources. The rationale being that the {hardware} itself is a typical useful resource and might be dealt with by a non-user-specific daemon occasion. This strategy has the benefit of getting a single entity in control of the {hardware}, which retains part of the implementation easier. The drawback is that we are going to both sacrifice safety (arbitrary customers can “eavesdrop” utilizing the machine’s mic), or safety infrastructure will have to be added to determine what customers are allowed what entry.

I recommended that since these are broadly fringe use-cases, we must always doc how customers can configure the system by hand for these functions, the crux of the argument being that our structure needs to be dictated by the principle use-cases, and never the ancillary ones. The drawback of this strategy is, after all, that configuration is more durable for the minority that needs multi-user entry to the {hardware}.

Colin recommended a mechanism for customers to have the ability to request entry from an “lively” PulseAudio daemon, which might set off approval by the corresponding “lively” person. The communication mechanism might be the D-Bus system bus between person daemons, and Ștefan Săftescu’s Google Summer season of Code work to permit desktop notifications to be triggered from PulseAudio might be used to get to request authorisation.

David recommended that we might use the per-user/system-wide break up, modified considerably to introduce the idea of a “system-wide” card. This may be a tool that’s configured as being obtainable to the entire system, and thus explicitly marked as not having any privateness ensures.

In each the above instances, dialogue continued about deciding how the entry management could be dealt with, and this stays open.

We might be persevering with to have a look at this downside till consensus emerges.

Bettering (laptop computer) encompass sound

The subsequent subject handled with the ability to cope with laptops with a built-in 2.1 channel arrange. The background of that is that there are a selection of laptops with stereo audio system and a subwoofer. These are normally used as stereo units with the subwoofer implicitly being fed information by the audio controller in some hardware-dependent means.

The potential for exposing this {hardware} extra precisely was mentioned. Some investigation is required to see how issues are at present uncovered for numerous {hardware} (my MacBook Professional exposes the subwoofer as a encompass management, for instance). We have to cope with accurately exposing the {hardware} on the ALSA layer, after which utilizing that accurately in PulseAudio profiles.

This led to a dialogue of how we might deal with profiles for these. Ideally, we might have a stereo profile with the {hardware} coping with upmixing, and a 2.1 profile that might be robotically triggered when a stream with an LFE channel was introduced. It is a common downside whereas coping with encompass output on HDMI as properly, and wishes additional thought because it complicates routing.


I gave a rousing speech about writing extra exams utilizing a few of the new enhancements to our testing framework. A lot cheering and acknowledgement ensued.

Ed.: some literary liberties might need been taken on this part

Unified cross-distribution ALSA configuration

I missed a big a part of this sadly, however the crux if the dialogue was round unifying cross-distribution sound configuration for individuals who want to disable PulseAudio.

Base volumes

The subsequent subject we took up was base volumes, and whether or not they’re helpful to most finish customers. For these unfamiliar with the idea, we generally see sinks/sources the place which assist quantity controls going to > 0dB (which is the no=attenuation level). We offer the utmost allowed acquire in ALSA as the utmost quantity, and counsel that UIs present a marker for the bottom quantity.

It was felt that this idea was irrelevant, and possibly complicated to most finish customers, and that we recommend that UIs don’t present this data any extra.

Relatedly, it was determined that having a per-port most quantity configuration could be helpful, in order to permit customers to cope with {hardware} the place the output may get too loud.

Units with dynamic capabilities (HDMI)

Our subsequent subject of debate was discovering a solution to cope with units comparable to these HDMI ports the place the capabilities of the system might change at run time (for instance, while you plug out a monitor and plug in a house theater receiver).

A couple of concepts to cope with this have been mentioned, and one of the best one appeared to be David’s proposal to all the time have a separate card for every HDMI system. The addition of dynamic profiles might then be exploited to solely make profiles obtainable when an precise system is plugged in (and conversely eliminated when the system is plugged out).

Splitting of configuration

It was recommended that we might break up our present configuration information into three classes: core, coverage and {hardware} adaptation. This was met with approval all-around, and the pre-existing skill to learn configuration from subdirectories might be reused.

One other function that was desired was the power to ship a number of configurations for various {hardware} variations with a single bundle and have the proper one chosen based mostly on the {hardware} being run on. We didn’t know of a regular, architecture-independent solution to decide {hardware} adaptation, so it was felt that step one towards fixing this downside could be to seek out or create such a mechanism. This might both then be used to arrange configuration accurately in early boot, or by PulseAudio for do runtime configuration choice.

Relatedly, shifting all distributed configuration to /usr/share/..., with overrides in /and many others/pulse/... and $HOME have been recommended.

Higher drain/underrun reporting

David volunteered to implement a per-sink-input timer for precisely figuring out when drain was accomplished, fairly than ready for the interval of the whole buffer as we at present do. Unsurprisingly, no objections have been raised to this answer to the long-standing subject.

In an identical vein, redefining the underflow occasion to imply an actual system underflow (fairly than the client-side buffer operating empty) was recommended. After some dialogue, we agreed {that a} separate occasion for system underruns would seemingly be higher.


We known as it a day at this level and dispersed beer-wards.

PulseConf HackersOur valiant attendees after a day of plotting the way forward for PulseAudio

Consumer expertise

David very kindly invited us to spend a day after the convention hacking at his home in Lund, Sweden, only a brief hop away from Copenhagen. We spent a short time within the morning speaking about one final merchandise on the agenda — serving to to construct a extra seamless person expertise. The thought was to determine some instruments to assist customers with issues rapidly converge on what downside they is likely to be going through (or assist builders do the identical). We regarded on the Ubuntu apport audio debugging instrument that David has written, and can attempt to undertake it for extra common use throughout distributions.


The remainder of the day was spent in additional discussions on subjects from the day prior to this, poring over code for some particular issues, and rolling out the primary launch candidate for the upcoming 3.Zero launch.

And lower!

I’m very pleased that this convention occurred, and am trying ahead to with the ability to do it once more subsequent yr. As you’ll be able to see from the size of this put up, there are lot of issues taking place on this a part of the stack, and much extra but to return. It was wonderful assembly all the man PulseAudio hackers, and my due to all of them for making it.

Lastly, I wouldn’t be sitting right here scripting this report with out assist from Collabora, who sponsored my journey to the convention, so it’s becoming that I finish this with a shout-out to them. 🙂

Arun Raghavanhttp://arunraghavan.internetpulseaudio – Arun RaghavanOpen supply hackerhttp://arunraghavan.internet/tag/pulseaudio/feed/2016-05-20T05:00:07+00:00grsec and PulseAudio (and Gentoo)http://arunraghavan.internet/?p=13662012-10-30T08:49:50+00:00

This downside appears to chunk a few of our hardened customers a few instances a yr, so thought I’d weblog about it. If you’re utilizing grsec and PulseAudio, you could not allow CONFIG_GRKERNSEC_SYSFS_RESTRICT in your kernel, else autodetection of your playing cards will fail.

PulseAudio’s module-udev-detect must entry /sys to find what playing cards can be found on the system, and that kernel possibility disallows this for anybody however root.

Arun Raghavanhttp://arunraghavan.internetpulseaudio – Arun RaghavanOpen supply hackerhttp://arunraghavan.internet/tag/pulseaudio/feed/2016-05-20T05:00:07+00:00PulseConf Schedulehttp://arunraghavan.internet/?p=13602012-10-29T12:45:47+00:00

David has now revealed a tentative schedule for the PulseAudio Mini-conference (I’m simply going to name it PulseConf — a lot simpler on the tongue).

For the lazy, these are a few of the subjects we’ll be overlaying:

  • Imaginative and prescient and mission — the place we’re and the place we need to be
  • Bettering our patch overview course of
  • Routing infrastructure
  • Bettering low latency behaviour
  • Revisiting system- and user-modes
  • Units with dynamic capabilities
  • Bettering encompass sound behaviour
  • Separating configuration for {hardware} adaptation
  • Higher drain/underrun reporting behaviour

Phew — and there are extra subjects that we in all probability won’t have time to cope with!

For these of you who can not attend, the Linaro Join of us (who’re graciously internet hosting us) are planning on operating Google+ Hangouts for his or her periods. Hopefully we must always be capable to do the identical for our proceedings. Watch this house for particulars!

p.s.: A giant thanks to my employer Collabora for sponsoring my journey to the convention.

Arun Raghavanhttp://arunraghavan.internetpulseaudio – Arun RaghavanOpen supply hackerhttp://arunraghavan.internet/tag/pulseaudio/feed/2016-05-20T05:00:07+00:00PulseConf!http://arunraghavan.internet/?p=13562012-10-04T08:41:01+00:00

For these of you who missed it, your pleasant neighbourhood PulseAudio hackers are converging on Copenhagen in a month to debate, plan and hack on the way forward for PulseAudio.

We’re doing this for the primary time, so I’m super-excited! David has posted particulars so if that is of curiosity to you, you need to undoubtedly be a part of us!

Arun Raghavanhttp://arunraghavan.internetpulseaudio – Arun RaghavanOpen supply hackerhttp://arunraghavan.internet/tag/pulseaudio/feed/2016-05-20T05:00:07+00:00Pulseaudio convention – lower than a month away!http://voices.canonical.com/david.henningsson/?p=1842012-10-04T08:32:45+00:00

The primary PulseAudio convention is approaching rapidly. It is a shoutout for individuals who is likely to be , however missed the mailinglist announcement.

The convention might be Friday 2nd November 2012, and colocated with Ubuntu Developer Summit and Linaro Join, in Bella Middle, Copenhagen.

There isn’t a attendance payment, however you’ll want a UDS or LC registration (that are additionally free) to have the ability to get into the convention space. (Observe: LC is likely to be the safer wager right here as UDS ends on Thursday)

There had been a number of subjects introduced up on the mailinglist, however we welcome anybody who wish to contribute to constructive discussions and assist to form the way forward for PulseAudio!

If you want to attend, how about you write an e-mail to the pulseaudio-discuss mailinglist with the subject(s) you need to convey up, and possibly a small presentation together with your background and pursuits? After all, should you largely need to hear in fairly than convey your individual subjects, that’s okay too!

David Henningssonhttp://voices.canonical.com/david.henningssonPulseAudio – A greater sounding worldhttp://voices.canonical.com/david.henningsson/class/pulseaudio/feed/2016-03-22T12:00:05+00:00Prime 5 unsuitable methods to repair your audiohttp://voices.canonical.com/david.henningsson/?p=1432012-07-13T15:49:25+00:00

The audio stack in Linux/Ubuntu evolves over time. What was once good recommendation shouldn’t be essentially good recommendation anymore. (That additionally means, that should you occur to learn this weblog put up in 2019 or one thing, don’t belief it!)
Listed below are some issues that folks strive, and generally they even repair the issue, however are sometimes dangerous in by hook or by crook. Or a minimum of, they’ve negative effects one wants to pay attention to. So – whereas there are legitimate exceptions, as a rule of thumb, don’t do the next:

5. Don’t add your person to the “audio” group

A person has entry to the audio card if that particular person is both logged in – each VT and GUI login counts, however not SSH logins, or if that person is within the “audio” group. Nonetheless, on the extent of entry we’re speaking about right here, just one person has entry at a time. So the everyday downside state of affairs goes like:

  • Consumer Homer has an audio subject, and tries to repair it by including himself to the audio group. This doesn’t assist to resolve the issue.
  • Homer discovers his audio is muted, and unmutes it. Comfortable to have his audio subject resolved, he forgets he’s nonetheless within the audio group, or doesn’t realise it results in issues.
  • Consumer Marge comes and needs to borrow the pc. Homer does a fast-user-switching so Marge can log in.
  • As a result of Homer is within the audio group, he has nonetheless entry to the audio system. If some software program, e g PulseAudio, has the audio system opened, it blocks entry to different software program making an attempt to make use of it.
  • Now Marge has an audio subject!

I’ve written an extended article concerning the audio group right here. Briefly, there are some usages for it, together with that additionally it is the usual group title for assigning realtime priorities when used along with JACK. However don’t go away a person within the audio group except you will have a very good motive.

4. Don’t strive totally different “mannequin” strings

A standard solution to attempt to get HDA Intel soundcards to work is to edit /and many others/modprobe.d/alsa-base.conf and add the next line:

choices snd-hda-intel mannequin=[something]

…the place [something] are values you discover in some file. Opposite to official documentation, that is normally out of date. Specifically, keep away from mannequin=generic – that’s virtually assured to present you hassle. In lots of instances, when making an attempt totally different fashions, one can find that you just may repair one factor however break one other.
In truth, there is just one mannequin to strive, and that’s mannequin=auto. In case your machine occur to be a type of quirked to make use of an older mannequin parser, altering to mannequin=auto can enhance the scenario.

As an alternative do:
It nonetheless occurs that BIOS/UEFI assigns the unsuitable values to pin nodes, which causes an output or enter to not work accurately. In that case, I like to recommend making an attempt to tweak this with hda-jack-retask.
In some instances, making an attempt totally different modules can really be okay – generally, these fashions level to light-weight fixups as an alternative of the sooner, extra heavyweight code that was utilized in earlier kernels. (On this context, I’ve to say that Takashi Iwai has carried out a implausible job of changing the older fashions to the newer auto-parser.)

3. Don’t improve ALSA drivers by following random weblog posts

I’ve seen far too many individuals reporting bugs on Launchpad the place they’ve been following some random weblog put up that tells you how one can improve ALSA, and are having audio points in consequence. These guides are of various high quality and sometimes come with out good uninstall directions, so you haven’t any solution to revert in case the improve didn’t resolve your downside, or broke one thing else.

First, one thing not everyone is conscious of: 95% of ALSA code is within the kernel, and follows the kernel’s launch cycle. That signifies that even when “/proc/asound/model” says one thing that was launched a yr or two in the past, don’t panic. It’s the kernel launch that tells you ways new your sound drivers are, so if in case you have a brand new kernel, and also you see an ALSA launch popping out, you’re unlikely to realize from an improve.

As an alternative do:
In some case you do have an previous kernel, and newer sound drivers may be value a strive. The Ubuntu Audio Developer’s workforce offers day by day snapshot drivers for HDA Intel playing cards. Information is obtainable right here and it additionally comes with correct uninstall directions.
Previously we’ve got additionally supplied drivers for different playing cards, however because of the upkeep required to maintain this up-to-date, together with that the overwhelming majority of individuals’s bugs concern HDA Intel anyway, this assist has been discontinued.

2. Don’t purge PulseAudio

First, PulseAudio itself isn’t good, a few of the bindings to PulseAudio aren’t good, and a few of the drivers aren’t good in the way in which PulseAudio needs to make use of it both. So there is likely to be legitimate causes to briefly transfer it out of your means, even when it could be higher to really repair the issue and submit a bug repair patch (should you’re able to doing so).
However don’t strive uninstalling the PulseAudio bundle, because it has far too many dependencies.

As an alternative do:
If you happen to simply want direct entry to your sound card, you’ll be able to run the “pasuspender” command. You’ll be able to both run “pasuspender” (in a terminal) to make PulseAudio keep away during the applying. Or should you suppose that’s easier, simply run “pasuspender bash” (in a terminal), begin your software by means of the menu/sprint/no matter you favor, and while you’re carried out, write “exit” within the terminal.
If you might want to cease the PulseAudio course of utterly, execute these instructions:

echo autospawn=no > ~/.pulse/shopper.conf
pulseaudio -k

If you happen to want PulseAudio again once more, take away ~/.pulse/shopper.conf, then attempt to begin an software that makes use of PulseAudio, and it ought to begin robotically.

Sudden negative effects:

  • The Gnome sound settings, the sound indicator and the quantity up/down keys depends on PulseAudio, so that they gained’t work when PulseAudio is off.
  • PulseAudio mixes audio, in order that signifies that just one software at a time can output audio if PulseAudio is disabled (and also you aren’t utilizing another sound server).
  • A number of functions have PulseAudio backends. A few of them will want reconfiguration to make use of ALSA straight, some will simply robotically redirect themselves, and a few gained’t work in any respect.
  • Bluetooth audio may not work with out PulseAudio.

1. Don’t substitute ALSA with OSS

OSS was the usual used earlier than ALSA got here alongside. Nowadays, ALSA is a lot better, each on the subject of {hardware} assist, and on the subject of how a lot software program that helps outputting sound to both sound system. OSS can also be solely unsupported, a minimum of by Ubuntu. As well as, I’m undecided precisely how one can get again to a working system after you’ve tried OSS…!

As an alternative do:
If you realize your downside is in ALSA, both drivers or userspace, attempt to monitor down and/or repair the bug, and speak to us about it. If you happen to’re operating Ubuntu, file a bug in opposition to the alsa-driver bundle. You too can contact the alsa-devel mailinglist. Whereas we gained’t assure responses because of the excessive quantity of bugs/visitors, we are sometimes capable of assist out.

Closing notes

Observe 1. HDA Intel playing cards are the built-in audio inputs and outputs in your motherboard (a minimum of should you purchased your laptop after ~2006 or so). HDMI and DisplayPort audio are additionally HDA Intel playing cards, however they’re coated in additional element right here.

Observe 2. I’ve had some issues with spammers posting spam feedback to my weblog put up. I don’t need to spend an excessive amount of time simply studying spam and marking it as such, so I’d shut for feedback in a comparatively brief interval. Sorry for the inconvenience.

David Henningssonhttp://voices.canonical.com/david.henningssonPulseAudio – A greater sounding worldhttp://voices.canonical.com/david.henningsson/class/pulseaudio/feed/2016-03-22T12:00:05+00:00Writing a easy PulseAudio module.tag:blogger.com,1999:blog-8870921695463486752.post-49086043500958515632012-06-15T02:07:48+00:00This put up will describe the (little) progress I’ve made within the first week of coding and can attempt to present a brief however clear introduction to writing PulseAudio modules. An identical article exists on the PulseAudio wiki web page, however I shall put up this nonetheless as the following articles might be based mostly on the code introduced right here. Lastly, earlier than checking the wiki web page or going by means of this text, it’s helpful to know how one can compile and run PulseAudio from git. Observe that, because the README file says, the configure script should be run with the CFLAGS="-ggdb3 -O0" LDFLAGS="-ggdb3" atmosphere variables, to have the ability to begin from the construct listing.

PulseAudio modules are required to have two features: pa__init(pa_module*m) and pa__done(pa_module*m), that are known as when the module is loaded and, respectively, unloaded (both by PulseAudio or as a result of it has completed no matter it was doing). Aside from  these features, PulseAudio recognises a number of others that present some details about the module (such because the creator or the outline). Nonetheless, these features aren’t typically applied straight, however fairly created by means of the next macros outlined in pulsecore/module.h:


pulsecore/module.h additionally comprises the pa_module struct definition, which is defined on the Module API wiki web page. One notably related area of the construction is the userdata area, as a result of it is the one solution to carry data from pa__init to pa__done. Because of this modules will typically outline a userdata struct that comprises all of the related module information, and that’s utilized by pa__done to free no matter reminiscence is allotted in pa__init. This struct can also be used to cross information to core hooks that deal with numerous occasions.

One other necessary area within the pa_module construction is the core area. This comprises a pa_core struct, which is outlined in pulsecore/core.h and is described on the Core API wiki web page. This area is especially related as a result of it’s used when creating hooks.

Creating and releasing hook slots is finished by means of two features outlined in pulsecore/hook-list.h:

pa_hook_slot* pa_hook_connect(pa_hook *hook, pa_hook_priority_t prio, pa_hook_cb_t cb, void *information);
void pa_hook_slot_free(pa_hook_slot *slot);

The core hook varieties are saved within the hooks array in pa_core, which is listed in line with the pa_core_hook enum outlined in pulsecore/core.h. For example, the hook that is known as after a card has been created is referred to by m->core->hooks[PA_CORE_HOOK_CARD_PUT].

pa_hook_priority_t is one other enum outlined in pulsecore/hook-list.h and may at present take the values PA_HOOK_EARLY, PA_HOOK_NORMAL or PA_HOOK_LATE. Nonetheless, these are simply integers and the decision may be adjusted to manage the order during which hooks are run (e.g. PA_HOOK_LATE+10 will run after PA_HOOK_LATE).

The pa_hook_cb_t is a perform pointer outlined in pulsecore/hook-list.h, with the next definition:

typedef pa_hook_result_t (*pa_hook_cb_t)(
        void *hook_data,
        void *call_data,
        void *slot_data);

and the final parameter is used for no matter person information must be handed from the module to the hook callback perform.

Placing all this collectively, the next module is ready to detect and log at any time when a brand new card is plugged in:

#embrace <config.h>

#embrace <pulse/proplist.h>
#embrace <pulse/xmalloc.h>

#embrace <pulsecore/card.h>
#embrace <pulsecore/core.h>
#embrace <pulsecore/log.h>
#embrace <pulsecore/module.h>

#embrace "module-desktop-notifications-symdef.h"

PA_MODULE_AUTHOR("Ștefan Săftescu");
PA_MODULE_DESCRIPTION("Integration with the Desktop Notifications specification.");

struct userdata {
    pa_hook_slot *card_put_slot;

static pa_hook_result_t card_put_cb(pa_core *c, pa_card *card, void* userdata) {
    pa_log_info("Card detected: %s.", pa_proplist_gets(card->proplist, PA_PROP_DEVICE_DESCRIPTION));
    return PA_HOOK_OK;

int pa__init(pa_module*m) {
    struct userdata *u;
    m->userdata = u = pa_xnew(struct userdata, 1);
    u->card_put_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_CARD_PUT], PA_HOOK_LATE, (pa_hook_cb_t) card_put_cb, u);
    return 0;

void pa__done(pa_module*m) {
    struct userdata *u;

    if (!(u = m->userdata))

    if (u->card_put_slot)


Nameless[email protected]http://brainyfeed.blogspot.com/search/label/pulseaudioBrainyfeedtag:blogger.com,1999:blog-88709216954634867522020-02-28T12:00:05+00:00Welcometag:blogger.com,1999:blog-8870921695463486752.post-19847633260417999232012-05-24T14:53:58+00:00Welcome to my weblog!

I’ve began this weblog to doc the progress on my Google Summer season of Code 2012 venture for PulseAudio, however I’ll hopefully preserve posting about different (kind of) attention-grabbing issues I am engaged on.

The venture goals to offer fundamental GUI integration and person suggestions for system discovery occasions, by means of the Desktop Notification specification. This can come as a PulseAudio module that may talk by means of D-Bus to the notification system supplied by the desktop atmosphere. The module might be subscribing to the server to obtain system discovery occasions and might be relaying that data to the person. If the person decides to take an motion with respect to that system, this might be communicated again to the module (by means of the D-Bus Desktop Notification API) and the module will change the server state accordingly. I’ve break up the event into the next duties:

  1. write a easy module to detect new units;
  2. add fundamental interplay with D-Bus by means of the Desktop Notification specification;
  3. implement person suggestions by means of DN;
  4. implement persistence of person settings by means of the PulseAudio database;
  5. enhance the person intreface, from a usability standpoint:
    • ought to the person set an entire system as default or sinks/sources;
    • ought to there be separate notifications for every of the sinks and sources of a tool;
    • what occurs if a person ignores the notification and many others.
  6. adapt the zeroconf module to combine with this module properly (e.g. add authentication immediate);
  7. examine different obtainable person suggestions/notification programs, comparable to Ubuntu’s, and lengthen the module to offer for these mechanisms as properly;
  8. make some changes to the prevailing GUIs (comparable to disabling quantity controls when pass-through mode is enabled).

I’ll begin coding in a couple of week and I’ll attempt to put up updates on my progress weekly. The posts won’t be aimed solely for individuals who have a very good understanding of PulseAudio; I’ll attempt to clarify what I uncover and be taught in order that others who would need to begin coding for PulseAudio can learn by means of the posts simply and perceive how every part works.

I am trying ahead to this summer time and to engaged on this venture!Nameless[email protected]http://brainyfeed.blogspot.com/search/label/pulseaudioBrainyfeedtag:blogger.com,1999:blog-88709216954634867522020-02-28T12:00:05+00:00The Magic Continueshttp://colin.guthr.ie/?p=4842012-05-23T19:54:52+00:00

Scorching on the heals of the superior PulseAudio 2.Zero launch, I’m very please to announce Mageia 2! It has been loads of very laborious work and I inadvertently ended up doing much more than I had initially meant however I can not complain – whereas it was loads of laborious work and a large time sink for the previous few months, I actually discovered a fantastic deal and really feel I’ve contributed to a fantastic person expertise.So what makes Mageia magic? Properly I wish to suppose it is as a result of we have got a fantastic bunch of individuals concerned – not solely that, we’ve got clear pointers about how the entire venture can by no means be owned by a company curiosity – it is a true neighborhood distro. If that is necessary to you, (and it needs to be!) then I encourage you to get entangled and assist us make it much more magic.

Not solely that, however whereas we’re a younger distro we include a wealthy historical past: Mandriva. Whereas the company aspect of Mandriva continues to be considerably struggling, the breadth of expertise our contributors have is far higher than our age would usually point out.

When it comes to expertise, I wish to suppose we’re a really ahead going through distro. We’re eager to undertake and contribute to the brand new “plumbing” layers being developed. Like just about each different distro on the market, we have seen the worth on this standardisation course of and wholeheartedly adopted the brand new pid 1, systemd. In contrast to some others, we have clearly said that whereas Mageia 2 helps each systemd and sysvinit, Mageia Three will focus solely on systemd. We don’t see worth in offering a half-hearted model of three totally different init programs and would a lot fairly go “all in” and supply a wonderful expertise with the one that appears the strongest and presents essentially the most compelling technical benefits. This can see us offering instruments to assist customers administer their programs higher and assist with bug reviews and fixes upstream too.

We additionally strongly assist our packagers and builders contributing straight upstream. Only recently the xsettings-kde venture was faraway from Mageia subversion and migrated into KDE git upstream such that different distros can contribute extra simply.

So for these causes and plenty of, many extra, I really feel we will proceed to make the magic occur!


When it comes to this launch particularly, there are such a lot of folks to thank. In no explicit order: Anne Nicolas, Thomas Backlund, Thierry Vignaud, Dexter Morgan, Pascal Terjan, Olivier Blin and plenty of others on the event aspect, the numerous superior of us within the QA workforce, these pesky bug reporters (some who have been completely superb and really understanding) and those that helped get the Art work and Advertising and marketing aspect of issues trying good and slick. I am sorry if I did not point out you by title above, however there actually are many, many beautiful folks concerned and to thank everybody individually would simply take too lengthy! Relaxation assured, you’re all superior! Additionally thanks need to additionally go to the nice of us concerned in upstream tasks. For me personally that is notably Lennart Poettering, Kay Sievers, Michal Schmidt and Tom Gundersen (and others)  from systemd and Harald Hoyer from dracut (most of complete are Redhat staff aside from Tom who’s an Arch contributor); Arun Raghavan, Tanu Kaskinen and David Henningsson from PulseAudio; to the KDE and GNOME tasks and their many, many contributors and to everybody else supporting using Free software program – do not be owned – personal it!!!

Share and Get pleasure from:
  • Digg
  • StumbleUpon
  • del.icio.us
  • Facebook
  • Yahoo! Buzz
  • Twitter
  • Google Bookmarks
  • Identi.ca
  • Slashdot

Colin Guthriehttp://colin.guthr.ieColin.Guthr.ie » pulseaudioIllegitimi non carborundumhttp://colin.guthr.ie/tag/pulseaudio/feed/2016-08-29T05:00:05+00:00Three audio bugs that want your {hardware} datahttp://voices.canonical.com/david.henningsson/?p=1042012-05-22T16:29:10+00:00

Are you:

  • Lacking audio system or inside mic in sound settings?
  • Seeing a S/PDIF system present up in your USB system?
  • Having no or extraordinarily low sound out of your inside microphone?

In that case, I’d want your assist to have the ability to repair it for you!

In Ubuntu 12.04 – and really seemingly, different current distribution releases as properly – there are a minimum of these three audio bugs that want handbook quirking for each machine. Which means that you submit your {hardware} data within the meta-bug, I’ll look in that data for some ID numbers and embrace them in a listing of units for which a selected workaround must be utilized. We will’t apply the workaround for each system, as that might doubtlessly trigger issues for different units.

So should you’re affected by one of many bugs I’m describing beneath, I might use your assist to verify they’re mounted for future releases of Ubuntu and ALSA/PulseAudio.

Lacking audio system or inside mic in sound settings

If you happen to’re affected by one of many following issues:

1) Within the sound settings dialog, while you plug your headphones into the designated 3.5 mm jack, there’s a “Headphones” system accurately proven, however while you unplug it, there is no such thing as a “Speaker” system proven, though you will have inside audio system in your laptop.

2) Within the sound settings dialog, while you plug your exterior microphone into the designated 3.5 mm jack, there’s a “Microphone” (or comparable) system accurately proven, however while you unplug it, there is no such thing as a “Inside Mic” system proven, though you will have an inside mic in your laptop.

Then you definitely is likely to be affected by bug 946232. Please look in that bug in your system in that listing, and if it’s not there, strive the workaround and if it’s working, add your alsa-info as recommended within the bug. Thanks!

S/PDIF system displaying up in your USB system

If in case you have a USB headset, or one other USB system that doesn’t have any S/PDIF output, however but generally there’s an additional system known as “Digital Output (S/PDIF)” for that system in Sound Preferences. In that case, you’re seemingly affected by bug 1002952. On the time of this writing there are additionally a number of units which might be on their solution to turning into mounted, if in case you have certainly one of these, please assist out with testing the proposed repository. There may be extra data in bug 1002952 about that.

Inverted Inside Mic

On this case, you will have an inside mic displaying up, but it surely appears to not work: it’s both utterly silent, or you’ll be able to probably choose a really small sound, with a lot background noise, though you will have set acquire to most.

There’s something you would strive. Set up the pavucontrol software, begin it and go to the “Enter Units” tab. Unlock the channels (click on the keylock icon), then mute the best channel whereas maintaining the left channel on the quantity you need.
If the interior mic is now working accurately, you will have an inverted inside mic, in order that your proper channel cancels out the left one. (Why the {hardware} is constructed that means is past me.)
This appears to be commonest on Acer Aspire laptops, however I’ve seen them on different laptops as properly, and fixing these are extra of a long run venture as they’re non-trivial kernel patches. Thus far I’ve created a patch for Thinkpad U300s. Anyway, I wish to monitor the remaining ones in bug 1002978, so please add your system there in line with the directions.

Final however not least – thanks upfront for serving to Ubuntu, in addition to the higher Linux ecosystem (I’ll ensure that the patches pushed into Ubuntu will get upstream as properly)!

David Henningssonhttp://voices.canonical.com/david.henningssonPulseAudio – A greater sounding worldhttp://voices.canonical.com/david.henningsson/class/pulseaudio/feed/2016-03-22T12:00:05+00:00I’m a Google Summer season Coder!http://zhengrong.wordpress.com/?p=52012-05-21T15:38:20+00:00

Horay! I take part on this yr’s Google Summer season of Code and I’ll be involvled in PulseAudio neighborhood to assist improve the logging and testing services.

Let me first introduce what’s GSoC (Google Summer season of Code), it’s a venture hosted by Google yearly to inspire college students to be engaged in open supply tasks. College students could have a significant summer time and be paid for his or her laborious coding work. 🙂

Then PulseAudio venture. If you happen to’re utilizing a contemporary Linux desktop, then likelihood is that you just’re already utilizing this software program. It’s the element which helps to combine all of the sounds from different functions after which output them into your audio system or headphones.

Lastly me 🙂 I’m a scholar from East China Regular College. Technically talking, I’m not majoring in laptop science, nor something associated to it. However I’m impressed by my mates and now I’m pleased to say that I might CODE! That is the good talent, that’s, I could make virtually something into actuality.

I’m so fortunate to be chosen into PulseAudio neighborhood. I’d like to thanks all of the builders on this neighborhood. My mentor Arun, and the maintainer Colin, and Tanu even had a full code overview on my proof of idea of round log buffering patch!

Properly, let me share some suggestions how you’ll be higher chosen in GSoC.

First, begin early! Early birds catches the worms. Annually’s schedule is kind of comparable, discover out final yr’s accepted tasks and see which one pursuits you most. This complete listing is kind of lengthy, so begin early to seek out out your pursuits!

Second, be concerned in the neighborhood. When you’ve discovered one venture, the very first thing you need to do is to be invovled in the neighborhood. Being concerned has totally different meanings, step one is after all to obtain the software program and have a strive, be a person! After which be a tester. Then, you could find out from its web site to see how one can setup your developement atmosphere. Join the mailing listing, and even hand around in its IRC channel.

Third, do your homework. Now it comes the laborious half. 🙂 After some exams and makes use of, you might marvel, “hey, this might be enhanced!” or “I’d this function in one other means!”. That’s a very good signal, this implies you will have your individual opinion on what the venture needs to be formed. Then begin small and write a easy demo to point out you’re ABLE to do that venture. In my software, I spent about one week to put in writing the round log buffer demo and it seems to be helpful of getting myself faimilar with its internals.

Now listed here are some phrases about this weblog. In line with the recommendation from Colin, I’m setting this weblog as much as primarily monitor my standing of this summer time venture. Nonetheless, probably this weblog would have extra technically contents afterward with extra engagement in open supply neighborhood. It’s a very good begin, isn’t it? 😀

Deng Zhengronghttp://zhengrong.wordpress.comzhengrong » PulseAudioFour out of 5 dentists suggest this WordPress.com websitehttp://zhengrong.wordpress.com/class/pulseaudio/feed/2015-01-13T18:00:10+00:00PulseAudio 2.0: Twice The Goodness!http://arunraghavan.internet/?p=13332012-05-12T10:50:34+00:00

That’s proper, it’s lastly out! Thanks exit to all our contributors for the nice work (there’s too many — see the shortlog!). The highlights of the discharge comply with. Head over to the announcement or launch notes for extra particulars.

  • Dynamic pattern price switching by Pierre-Louis Bossart: This makes PulseAudio much more energy environment friendly.

  • Jack detection by David Henningsson: Separate volumes in your laptop computer audio system and headphones, and extra stuff coming quickly.

  • Main echo canceller enhancements by me: Based mostly on the WebRTC.org audio processing library, we now do higher echo cancellation, take away the necessity to fiddle with the mic quantity knob and have mounted AEC between laptop computer audio system and a USB webcam mic.

  • A digital encompass module by Niels Ole Salscheider: Strive it out for some digital encompass sound shininess!

  • Help for Xen visitors by Giorgos Boutsiouki: Ought to make audio virtualisation in visitors extra environment friendly.

We don't always make a release, but when we do, it's awesome

Particular thanks from me to Collabora for giving me a while for upstream work.

Packages can be found on Gentoo, Arch, and possibly quickly on different distributions in the event that they’re not already there.

Arun Raghavanhttp://arunraghavan.internetpulseaudio – Arun RaghavanOpen supply hackerhttp://arunraghavan.internet/tag/pulseaudio/feed/2016-05-20T05:00:07+00:00pulseaudio: PulseAudio 2.Zero is out! Our tweets sound even higher now! http://t.co/S5DwpkIS (by Arun)http://twitter.com/pulseaudio/statuses/2009690046329118722012-05-11T15:21:59+00:00pulseaudio: PulseAudio 2.Zero is out! Our tweets sound even higher now! http://t.co/S5DwpkIS (by Arun)Twitterhttp://twitter.com/pulseaudioTwitter / pulseaudioTwitter updates from PulseAudio / pulseaudio.http://api.twitter.com/1/statuses/user_timeline.rss?screen_name=pulseaudio2013-06-11T17:00:03+00:00The Most Superior, Least-Marketed Fedora 17 Characteristichttp://0pointer.de/weblog/tasks/multi-seat.html2012-05-01T21:07:00+00:00

There’s one function Within the upcoming Fedora 17 launch that’s
immensly helpful however little or no identified, since its function web page
‘ckremoval’ doesn’t explicitly seek advice from it in its title: true
computerized multi-seat assist for Linux.

A multi-seat laptop is a system that provides not just one native
seat for a person, however a number of, on the similar time. A seat refers to a
mixture of a display, a set of enter units (comparable to mice and
keyboards), and possibly an audio card or webcam, as particular person native
office for a person. A multi-seat laptop can drive a complete class
room of seats with solely a fraction of the price in {hardware}, power,
administration and house: you solely have one PC, which normally has means
sufficient CPU energy to drive 10 or extra workplaces. (In truth, even a
Netbook has quick sufficient to drive a few seats!) Automated
refers to a completely robotically managed seat setup:
at any time when a brand new seat is plugged in a brand new login display instantly
seems — with none handbook configuration –, and when the seat is
unplugged all person periods on it are eliminated directly.

In Fedora 17 we added this performance to the low-level person and
system monitoring of systemd, changing the earlier ConsoleKit logic
that lacked assist for computerized multi-seat. With all the bottom work
carried out in systemd, udev and the opposite elements of our plumbing layer
the final remaining bits have been surprisingly straightforward so as to add.

Presently, the automated multi-seat logic works finest with the USB
multi-seat {hardware} from Plugable
you should purchase cheaply on Amazon
(US). These units require precisely zero configuration with the
new scheme applied in Fedora 17: simply plug them in at any time,
login screens pop up on them, and you’ve got your extra
seats. Alternatively you can too assemble your seat manually with a
few straightforward loginctl
connect instructions, from any form of {hardware} you might need mendacity
round. To get a full seat you want a number of graphics playing cards, keyboards
and mice: one set for every seat. (Afterward we’ll in all probability have a graphical
setup utility for added seats, however that is not a urgent subject we
imagine, because the plug-n-play multi-seat assist with the Plugable
units is so awesomely good.)

Plugable supplied us at no cost with {hardware} for testing
multi-seat. They’re additionally concerned with the upstream improvement of
the USB DisplayLink driver for Linux. On account of their optimistic
involvement with Linux we will solely suggest to purchase their
{hardware}. They’re good guys, and assist Free Software program the way in which all
{hardware} distributors ought to! (And in addition to that, their {hardware} can also be
properly put collectively. For instance, in distinction to most comparable distributors
they really assign correct vendor/product IDs to their USB {hardware}
in order that we will simply acknowledge their {hardware} when plugged in to set
up computerized seats.)

Presently, all this magic is simply applied within the GNOME stack
with the largest element getting up to date being the GNOME Show
Supervisor. On the Plugable USB {hardware} you get a full GNOME Shell
session with all the standard graphical gimmicks, the identical means as on any
different {hardware}. (Sure, GNOME Three works completely tremendous on easier graphics
playing cards comparable to these USB units!) If you’re hacking on a unique
desktop atmosphere, or on a unique show supervisor, please have a
have a look at the
multi-seat documentation we put collectively, and notably at
our brief piece about writing
show managers that are multi-seat succesful.

If you happen to work on a significant desktop atmosphere or show supervisor and
wish to implement multi-seat assist for it, however lack the
aforementioned Plugable {hardware}, we’d be capable to give you
the {hardware} at no cost. Please contact us straight, and we is likely to be
capable of ship you a tool. Observe that we do not have limitless units
obtainable, therefore we’ll in all probability not be capable to cross {hardware} to
everyone who asks, and we are going to cross the {hardware} ideally to folks
who work on well-known software program or in any other case have contributed good
code to the neighborhood already. Anyway, if unsure, ping us, and
clarify to us why you need to get the {hardware}, and we’ll contemplate you!
(Oh, and this not solely applies to show managers, should you hack on another
software program the place multi-seat consciousness could be actually helpful, then do not
hesitate and ping us!)

Phoronix has this
story about this new multi-seat assist which is kind of attention-grabbing and
full of images. Please take a look.

Plugable began a Pledge
drive to decrease the value of the Plugable USB multi-seat terminals
additional. It is full of images (and a video displaying all this in motion!), and makes use of the code we now make
obtainable in Fedora 17 as base. Please contemplate pledging a number of

Lately David Zeuthen added
multi-seat assist to udisks as properly. With this in place, a person
logged in on a selected seat can solely see the USB storage plugged into
his particular person seat, however doesn’t see any USB storage plugged into any
different native seat. With this in place we closed the final lacking little bit of
multi-seat assist in our desktop stack.

With this code in Fedora 17 we cowl the massive use instances of
multi-seat already: web cafes, class rooms and comparable
installations can present PC workplaces cheaply and simply with none
handbook configuration. Afterward we need to construct on this and make this
helpful for various makes use of too: for instance, the power to get a login
display as simply as plugging in a USB connector makes this not helpful
just for saving cash in setups for many individuals, but in addition in embedded
environments (contemplate monitoring/debugging screens made obtainable by way of
this hotplug logic) or servers (get trivially fast native entry to
your in any other case head-less server). To be actually helpful in these areas we
want yet one more factor although: the power to run a merely getty
(i.e. textual content login) on the seat, with out essentially involving a
graphical UI.

The well-known X successor Wayland already comes out of the field with multi-seat
assist based mostly on this logic.

Oh, and BTW, as Ubuntu seems to be “focussing” on “readability” within the
cloud” now ;-), and selected Upstart as an alternative of systemd, this function
will not be obtainable in Ubuntu any time quickly. That is (one element of) the
value Ubuntu has to pay for selecting to keep up it is personal (largely
legacy, comparable to ConsoleKit) plumbing stack.

Multi-seat has an extended historical past on Unix. Because the earliest days Unix
programs might be accessed by a number of native terminals on the similar
time. Since then native terminal assist (and therefore multi-seat)
steadily moved out of view in computing. The fewest machines these
days have a couple of seat, the idea of terminals survived virtually
completely within the context of PTYs (i.e. absolutely virtualized API
objects, disconnected from any actual {hardware} seat) and VCs (i.e. a
single virtualized native seat), however virtually not in every other means (properly,
server setups nonetheless use serial terminals for emergency distant entry,
however they virtually by no means have a couple of serial terminal). All what we
do in systemd is predicated on the concepts initially introduced ahead in
Unix; with systemd we now attempt to convey again a lot of the nice concepts
of Unix that because the previous instances have been misplaced on the roadside. For
instance, in true Unix model we already began to show the idea
of a service within the file system (in
/sys/fs/cgroup/systemd/system/), one thing the place on Linux the
(typically misunderstood) “every part is a file” mantra beforehand
fell brief. With computerized multi-seat assist we convey again assist
for terminals, however up to date with all of the options of immediately’s desktops:
plug and play, zero configuration, full graphics, and never restricted to
enter units and screens, however extending to every kind of units, such
as audio, webcams or USB reminiscence sticks.

Anyway, that is all for now; I would wish to thank everyone who was
concerned with making multi-seat work so properly and natively on the
Linux platform. You already know who you’re! Thanks a ton!

Lennart Poetteringhttp://0pointer.de/weblogPID EINS!Lennart’s Webloghttp://colin.guthr.ie/mezcalero/2014-08-31T17:00:05+00:00Androidifying your autotools construct the simple meanshttp://arunraghavan.internet/?p=13292012-05-01T19:48:15+00:00

Derek Foreman has lastly written up a pleasant weblog put up about his Androgenizer instrument, which we’ve used for porting PulseAudio, GStreamer, Wayland, Telepathy and most of their dependencies to Android.

If you happen to’ve received an autotools-based venture that you just’d wish to construct on Android, whether or not on the NDK or system-wide that is actually helpful.

Arun Raghavanhttp://arunraghavan.internetpulseaudio – Arun RaghavanOpen supply hackerhttp://arunraghavan.internet/tag/pulseaudio/feed/2016-05-20T05:00:07+00:00PulseAudio on Android: Half 2http://arunraghavan.internet/?p=13002012-04-30T10:35:27+00:00

A few of you may’ve seen that there was a bunch of labor taking place right here at Collabora on making cool open supply applied sciences comparable to GStreamer, Telepathy, Wayland and naturally, PulseAudio obtainable on Android.

Since my final weblog put up on this topic, I received a while to start out changing AudioFlinger (recap: that’s Android’s native audio subsystem) with PulseAudio (recap: that’s the superior Linux audio subsystem). This work may be damaged up into Three components: playback, seize, and coverage. The roles of playback and seize are apparent. For individuals who aren’t conscious of system internals, the coverage bits deal with audio routing, volumes, and different such issues. For instance, audio ought to play out of your headphones in the event that they’re plugged in, off Bluetooth should you’ve received a headset paired, or the audio system if nothing’s plugged in. Additionally, relying on the system, the output quantity may change based mostly on the present output path.

I began by fixing the playback downside first. I’ve received the primary 80% of this carried out (as everyone knows, the second 80% takes a minimum of as lengthy 😉 ). That is carried out by changing the native AudioTrack playback API with a easy wrapper that interprets into the libpulse PulseAudio shopper API. There’s bits of the API that appear to be hardly ever used(loops and markers, primarily), and I’ve not gotten round to these but. Fundamental playback works fairly properly, and right here’s a video displaying this. (Observe: this and the following video might be served with yummy HTML5 goodness should you enabled the YouTube HTML5 beta).

(if the video doesn’t seem, you’ll be able to watch it on YouTube)

Customers of PulseAudio might need noticed that this now frees us as much as do some pretty nifty issues. One such factor is getting distant playback at no cost. For a very long time now, there was assist for streaming audio between units operating PulseAudio. I wrote up a fast app to point out this engaged on the Galaxy Nexus as properly. Once more, seeing this working is much more spectacular than me describing it right here, so right here’s one other video:

(if the video doesn’t seem, you’ll be able to watch it on YouTube)

That is all clearly work in progress, however you could find the code for the AudioTrack wrapper as a patch for now. This might be a correctly built-in tree which you can simply pull and simply combine into your Android construct when it’s carried out. The PA Output Switcher app code can also be obtainable in a git repository.

I’m hoping to have the ability to proceed hacking on the seize and coverage bits. The latter, particularly, guarantees to be concerned, since there isn’t all the time a 1:1 mapping between AudioFlinger and PulseAudio ideas. Nothing insurmountable, although. 🙂 Watch this house for extra updates as I wade by means of the following bit.

Arun Raghavanhttp://arunraghavan.internetpulseaudio – Arun RaghavanOpen supply hackerhttp://arunraghavan.internet/tag/pulseaudio/feed/2016-05-20T05:00:07+00:00systemd Standing Replacehttp://0pointer.de/weblog/tasks/systemd-update-3.html2012-04-20T22:17:00+00:00

has been means too lengthy since my final standing replace on
systemd. Here is one other brief, incomprehensive standing replace on
what we labored on for systemd since

We now have been working laborious to show systemd into essentially the most viable set
of elements to construct working programs, home equipment and units from,
and make it your best option for servers, for desktops and for embedded
environments alike. I believe we’ve got a extremely convincing set of
options now, however we’re actively engaged on making it even

Here is a listing of some extra and a few much less attention-grabbing options, in
no explicit order:

  1. We added an computerized pager to systemctl (and associated instruments), comparable
    to how git has it.
  2. systemctl learnt a brand new swap --failed, to point out solely
    failed providers.
  3. You might now begin providers instantly, overrding all dependency
    logic by passing --ignore-dependencies to
    systemctl. That is largely a debugging instrument and nothing folks
    ought to use in actual life.
  4. Sending SIGKILL as last a part of the implicit shutdown
    logic of providers is now non-obligatory and could also be configured with the
    SendSIGKILL= possibility individually for every service.
  5. We break up off the Vala/Gtk instruments into its personal venture systemd-ui.
  6. systemd-tmpfiles learnt file globbing and creating FIFO
    particular information in addition to character and block system nodes, and
    symlinks. It is also able to relabelling sure directories at
    boot now (within the SELinux sense).
  7. Instantly earlier than shuttding dow we are going to now invoke all binaries
    present in /lib/systemd/system-shutdown/, which is beneficial for
    debugging late shutdown.
  8. You might now globally management the place STDOUT/STDERR of providers goes
    (except particular person service configuration overrides it).
  9. There is a new ConditionVirtualization= possibility, that makes
    systemd skip a selected service if a sure virtualization expertise
    is discovered or not discovered. Related, we now have a brand new choice to detect
    whether or not a sure safety expertise (comparable to SELinux) is obtainable,
    known as ConditionSecurity=. There’s additionally
    ConditionCapability= to verify whether or not a sure course of
    functionality is within the functionality bounding set of the system. There’s
    additionally a brand new ConditionFileIsExecutable=,
  10. The file system situation directives now assist globbing.
  11. Service situations might now be “triggering” and “obligatory”, that means that
    they could be a crucial requirement to carry for a service to start out, or
    merely one set off amongst many.
  12. At boot time we now print warnings if: /usr
    is on a split-off partition however not already mounted by an initrd;
    if /and many others/mtab shouldn’t be a symlink to /proc/mounts; CONFIG_CGROUPS
    shouldn’t be enabled within the kernel. We’ll additionally expose this as
    tainted flag on the bus.
  13. You might now boot the identical OS picture on a naked steel machine and in
    Linux namespace containers and can get a clear boot in each
    instances. That is extra sophisticated than it sounds since system administration
    with udev or write entry to /sys, /proc/sys or
    issues like /dev/kmsg shouldn’t be obtainable in a container. This
    makes systemd a first-class alternative for managing skinny container
    setups. That is all examined with systemd’s personal systemd-nspawn
    instrument however ought to work tremendous in LXC setups, too. Mainly this implies
    that you just wouldn’t have to regulate your OS manually to make it work in a
    container atmosphere, however will simply work out of the field. It additionally
    makes it simpler to transform actual programs into containers.
  14. We now robotically spawn gettys on HVC ttys when booting in VMs.
  15. We launched /and many others/machine-id as a generalization of
    D-Bus machine ID logic. See this
    weblog story for extra data. On stateless/read-only programs
    the machine ID is initialized randomly at boot. In virtualized
    environments it could be handed in from the machine supervisor (with qemu’s
    -uuid swap, or by way of the container
  16. The entire systemd-specific /and many others/fstab mount choices are
    now within the x-systemd-xyz format.
  17. To make it straightforward to seek out non-converted providers we are going to now
    implicitly prefix all LSB and SysV init script descriptions with the
    strings “LSB:” resp. “SYSV:“.
  18. We launched /run and made it a tough dependency of
    systemd. This listing is now extensively accepted and applied on all
    related Linux distributions.
  19. systemctl can now execute all its operations remotely too (-H swap).
  20. We now ship systemd-nspawn,
    a extremely highly effective instrument that can be utilized to start out containers for
    debugging, constructing and testing, very like chroot(1). It’s helpful to
    simply get a shell inside a construct tree, however is nice sufficient besides up a
    full system in it, too.
  21. If we question the person for a tough disk password at boot he might hit
    TAB to cover the asterisks we usually present for every key that’s
    entered, for additional paranoia.
  22. We do not allow udev-settle.service anymore, which is
    solely required for sure legacy software program that also hasn’t been
    up to date to comply with units coming and going cleanly.
  23. We now embrace a instrument that may plot boot pace graphs, just like
    bootchartd, known as systemd-analyze.
  24. At boot, we now initialize the kernel’s binfmt_misc logic with the info from /and many others/binfmt.d.
  25. systemctl now acknowledges whether it is run in a chroot()
    atmosphere and can work accordingly (i.e. apply adjustments to the tree
    it’s run in, as an alternative of speaking to the precise PID 1 for this). It additionally has a brand new --root= swap to work on an OS tree from exterior of it.
  26. There is a new unit dependency sort OnFailureIsolate= that
    permits coming into a unique goal at any time when a sure unit fails. For
    instance, that is attention-grabbing to enter emergency mode if file system
    checks of essential file programs failed.
  27. Socket models might now hear on Netlink sockets, particular information
    from /proc and POSIX message queues, too.
  28. There is a new IgnoreOnIsolate= flag which can be used to
    guarantee sure models are left untouched by isolation requests. There’s
    a brand new IgnoreOnSnapshot= flag which can be used to exclude
    sure models from snapshot models when they’re created.
  29. There’s now small mechanism providers for
    altering the native hostname and different host meta information, altering
    the system locale and console settings and the system
  30. We now restrict the aptitude bounding set for a lot of our
    inside providers by default.
  31. Plymouth might now be disabled globally with
    plymouth.allow=0 on the kernel command line.
  32. We now disallocate VTs when a getty completed operating (and
    optionally different instruments run on VTs). This provides additional safety because it
    clears up the scrollback buffer in order that subsequent customers can not get
    entry to a person’s session output.
  33. In socket models there at the moment are choices to manage the
    SO_PASSSEC socket choices.
  34. The obtain and ship buffers of socket models might now be set bigger
    than the default system settings if wanted by utilizing
  35. We now set the {hardware} timezone as one of many first issues in PID
    1, in an effort to keep away from time jumps throughout regular userspace operation, and
    to ensure smart instances on all generated logs. We additionally now not
    save the system clock to the RTC on shutdown, assuming that that is
    carried out by the clock management instrument when the person modifies the time, or
    robotically by the kernel if NTP is enabled.
  36. The SELinux listing received moved from /selinux to
  37. We added a small service systemd-logind that retains tracks
    of logged in customers and their periods. It creates management teams for
    them, implements the XDG_RUNTIME_DIR
    specification for them, maintains seats and system node ACLs and
    implements shutdown/idle inhibiting for shoppers. It auto-spawns gettys
    on all native VTs when the person switches to them (as an alternative of beginning
    six of them unconditionally), thus decreasing the useful resource foot print by
    default. It has a D-Bus interface in addition to a
    easy synchronous library interface. This mechanism obsoletes
    ConsoleKit which is now deprecated and may now not be used.
  38. There’s now full, computerized multi-seat assist, and that is
    enabled in GNOME 3.4. Simply by pluging in new seat {hardware} you get a
    new login display in your seat’s display.
  39. There may be now an possibility ControlGroupModify= to permit
    providers to alter the properties of their management teams dynamically,
    and one to make management teams persistent within the tree
    (ControlGroupPersistent=) in order that they are often created and
    maintained by exterior instruments.
  40. We now bounce again into the initrd in shutdown, in order that it could
    detach the foundation file system and the storage units backing it. This
    permits (for the primary time!) to reliably undo advanced storage setups
    on shutdown and go away them in a clear state.
  41. systemctl now helps presets, a means for distributions and
    directors to outline their very own insurance policies on whether or not providers ought to
    be enabled or disabled by default on bundle set up.
  42. systemctl now has high-level verbs for masking/unmasking
    models. There’s additionally a brand new command (systemctl list-unit-files)
    for figuring out the listing of all put in unit file information and whether or not
    they’re enabled or not.
  43. We now apply sysctl variables to every new community system, because it
    seems. This makes /and many others/sysctl.d suitable with hot-plug
    community units.
  44. There’s restricted profiling for SELinux start-up perfomance constructed
    into PID 1.
  45. There is a new swap PrivateNetwork=
    to show of any community entry for a selected service.
  46. Service models might now embrace configuration for management group
    parameters. A couple of (comparable to MemoryLimit=) are uncovered with
    high-level choices, and all others can be found by way of the generic
    ControlGroupAttribute= setting.
  47. There’s now the choice to mount sure cgroup controllers
    collectively at boot. We do that now for cpu and
    cpuacct by default.
  48. We added the
    journal and turned it on by default.
  49. All service output is now written to the Journal by default,
    regardless whether or not it’s despatched by way of syslog or just written to
    stdout/stderr. Each message streams find yourself in the identical location and
    are interleaved the way in which they need to. All log messages even from the
    kernel and from early boot find yourself within the journal. Now, no service
    output will get unnoticed and is saved and listed on the similar
  50. systemctl standing will now present the final 10 log traces for
    every service, straight from the journal.
  51. We now present the progress of fsck at boot on the console,
    once more. We additionally present the a lot liked colourful [ OK ] standing
    messages at boot once more, as identified from most SysV implementations.
  52. We merged udev into systemd.
  53. We applied and documented interfaces to container
    managers and initrds
    for passing execution information to systemd. We additionally applied and
    documented an
    interface for storage daemons which might be required to again the foundation file
  54. There are two new choices in service information to propagate reload requests between a number of models.
  55. systemd-cgls will not present kernel threads by default anymore, or present empty management teams.
  56. We added a brand new instrument systemd-cgtop that exhibits useful resource
    utilization of complete providers in a high(1) like fasion.
  57. systemd might now supervise providers in watchdog model. If enabled
    for a service the daemon daemon has to ping PID 1 in common intervals
    or is in any other case thought of failed (which could then end in
    restarting it, and even rebooting the machine, as configured). Additionally,
    PID 1 is able to pinging a {hardware} watchdog. Placing this
    collectively, the {hardware} watchdogs PID 1 and PID 1 then watchdogs
    particular providers. That is extremely helpful for high-availability servers
    in addition to embedded machines. Since watchdog {hardware} is noawadays
    constructed into all fashionable chipsets (together with desktop chipsets), this
    ought to hopefully assist to make this a extra extensively used
  58. We added assist for a brand new kernel command line possibility
    systemd.setenv= to set an atmosphere variable
  59. By default providers that are began by systemd could have SIGPIPE
    set to ignored. The Unix SIGPIPE logic is used to reliably implement
    shell pipelines and when left enabled in providers is normally only a
    supply of bugs and issues.
  60. You might now configure the speed limiting that’s utilized to
    restarts of particular providers. Beforehand the speed limiting parameters
    have been hard-coded (just like SysV).
  61. There’s now assist for loading the IMA integrity coverage into the
    kernel early in PID 1, just like how we already did it with the
    SELinux coverage.
  62. There’s now an official API to schedule and question scheduled shutdowns.
  63. We modified the license from GPL2+ to LGPL2.1+.
  64. We made systemd-detect-virt
    an official instrument within the instrument set. Since we already had code to detect
    sure VM and container environments we now added an official instrument
    for directors to utilize in shell scripts and suchlike.
  65. We documented quite a few
    interfaces systemd launched.

A lot of the stuff above is already obtainable in Fedora 15 and 16,
or might be made obtainable within the upcoming Fedora 17.

And that is it for now. There’s loads of different stuff within the git commits, however
most of it’s smaller and I’ll it thus spare you.

I would wish to thank everyone who contributed to systemd over the previous years.

Thanks in your curiosity!

Lennart Poetteringhttp://0pointer.de/weblogPID EINS!Lennart’s Webloghttp://colin.guthr.ie/mezcalero/2014-08-31T17:00:05+00:00

Leave a Reply

Your email address will not be published. Required fields are marked *