How does sound work on linux?

Added: 2026-05-12

[00:00:00]Yo, what's up? What's up? What's up, everybody? Welcome back. Today, I want to look at Linux audio.

[00:00:08]Uh the context is I am working on a virtual phone so that I can answer my door because I ate [ __ ] on the concrete.

[00:00:16]My phone broke. I mean, that's not why, but it's like a nice little convenient excuse where I was like, "I don't like that the doorbell to my apartment calls my cell phone. I want it to call my computer. My computer needs a phone on it."

[00:00:29]Um and to be able to I need to play back audio, right? So the guy at the door can be like, "Hey, Mick, it's me." And then I can be like, "Oh, okay." And then I hit the button and he comes in, right?

[00:00:36]Um and so one of the questions or one of the things we have to do there is we have to play the audio. And um we've kind of like looked at this a couple times in the past like but using libraries. Like, I think we used mini audio last time that kind of handled this for us. Um but I have a question of like, what even is Linux audio playback, right?

[00:00:59]Like, if I had to imagine, like I guess like my computer sits here, right? Computer. I've got a desktop like a [ __ ] old person, right? I'm back from the before the days of everyone using their cell phones and laptops everything. I have a desktop and a desk.

[00:01:13]It's hype. Um but in here, there's like a 3.5 mm jack, right? And then that goes like to my speakers or to my headphones, right?

[00:01:20]And I believe that like the most simple implementation of a speaker is you have like a little coil on like a membrane, I think. So you have like, you know, you have like the little cone with like some like plastic in here or some [ __ ] And then I think there's like a magnet maybe here.

[00:01:41]Maybe. And then there's like a coil somewhere. And by taking the analog signal that's coming on this cable and just like shoving that through the coil, you introduce like magnetic fields that push or pull to the magnet at the back, and then that will like wiggle the membrane, which will push air into your eardrums and wiggle your eardrums. I think, right? So, there there's some somewhere in the system, like we have some analog signal that comes out of this thing, right? That's at the very base level, like that's the piece of information we have, right? Um [snorts] this thing is probably connected to a PCI card. I don't know. I'm making I'm making a lot of this up. I'm making a lot of this up, right? But this is probably connected to some PCI card.

[00:02:27]Maybe it's not like a physical PCI card in the system, but it's probably on the PCI bus, at least, right?

[00:02:34]Um which probably goes to the CPU, and then this you know, the Linux kernel probably has some sort of driver that takes like some sort of stream of bits and puts them either like on the hardware, maybe maybe the hardware has like some like physical chunk of memory that you put the stream of bits on, and then it has like a a digital-to-analog converter that turns that into this signal. Maybe maybe it's like in RAM, RAM, and since like RAM is visible from the PCI bus, maybe it talks to each other like this. Not sure, right?

[00:03:09]But somewhere we must be like putting audio data into a buffer, and presumably there's like a piece of hardware that's just like ripping through that buffer and putting the stuff on it into the audio, right? And and you can kind of like imagine this case from like I don't know if you guys on the next ever like swap out so bad that your computer becomes like completely unresponsive, but when when I like compile too much at once, I start to hear like a second of playback of my song over and over. It goes like bump bump bump bump, and then I start like right? So, like I can imagine that as like there is some audio buffer that hardware is like ripping through and if that thing is not updated, then it just plays back whatever is in the buffer, right?

[00:03:58]So, that this is like again, I'm making everything up right now, but that's like my imagination about how that works, right? So, if I were to like design this interface, I would would imagine that there's probably some like kernel handle somewhere, dev sound or something, right? Sound out.

[00:04:19]Right? And maybe you like mmap this thing in some way and then your your user space application can just like put audio in there.

[00:04:28]That'd be my guess. I would guess, however, this might not be true. Um if I were to implement this, I would make it so that this is like an exclusive handle for the whole system, right? And so then if you want to do like audio muxing, I think that that's like a complicated problem, right? Because like the only way you can take two audio signals and like play them both at once is to just add them up. But then like you get into a point where you start like clipping, right? Where you can't add signals together anymore. So, I think like the idea of muxing gets like kind of difficult and you have to like prioritize things or like compress everything down so that like the peak ranges don't go out of like go crazy.

[00:05:04]You probably want like applications to be able to route into each other and volume adjustment and all that. So, like all of that seems like very user spacey to me, right? Like I can imagine you might want to switch out your implementation of how you mux audio. And so, probably there's someone in user space that has like a daemon somewhere and everyone talks to this guy and he would populate this like device handle.

[00:05:29]That's how I would do it. I don't know if that's true, right?

[00:05:34]Because you can also imagine a world where like maybe hardware muxing exists, right? Where like you maybe the hardware itself has like the ability to take several channels and has an integrated muxer in there and then you don't have to actually do the servicing on the CPU and like that's faster for some reason.

[00:05:49]So maybe there's something there where maybe you have like sound out 0 1 2 3 and then like the user space daemon would like pick which ones that it wants to use for which purposes, maybe, right?

[00:06:00]I don't know.

[00:06:01]Um but the the goal for today is to figure it out, right? So um what I have right now is yesterday I set up an Alpine virtual machine because I believe that on my system audio is more complicated from than like a simple case, right? So Alpine's like the dumb [ __ ] version of Linux that you can use that like does nothing for you, you know? It's like my go-to like I want nothing but like give me the bare bones.

[00:06:25]And in here I've installed this program called speaker-test. And when I play it you guys hear you know? Um and so what I think our entry point is we can figure out what this we can like S trace this program, figure out what it does, um how it's putting audio in the audio buffers. Um I've got this virtual machine set up so that we can actually like run GDB on the kernel, which is going to be nice. It'll help us like step through and figure out where the data is going.

[00:06:55]Um and then maybe we figure out like how to hand roll playback, maybe we look at what speaker-test is doing. I I know that like I'm pretty sure I did like a quick S trace to speaker-test on my host system and it was like talking to this thing called pipewire.

[00:07:09]Oh yeah, words I've heard before.

[00:07:12]Um in in the context of Linux audio, right? So I have I kind of just made up a bunch of stuff, right? Um but words I've heard in Linux in the past 20 years. OSS, also JACK, PulseAudio, pipewire. These are all like things related to sound. I don't know what any of them are, right?

[00:07:29]>> [laughter] >> But if you look up also, which is the thing I've heard most, um oopsies, also sound, maybe.

[00:07:41]He says in here on Linux sound servers like sound IO, pipewire, jack, and pipewire, and high level APIs work on top of also, right? So, at the very least, it makes sense that I've seen also in the kernel as well, I think. So, the idea that like also is kind of like the base layer audio thing, and that somebody else manages stuff on top, that kind of makes sense.

[00:08:10]Um so, I'm kind of hoping that in this Alpine VM I have some like bare bones also set up. Speaker test hopefully is just doing whatever the base also thing is we can figure out what what it does.

[00:08:21]That's the plan.

[00:08:22]That's the plan.

[00:08:24]Um so, let's do a little bit of uh initial speaker test.

[00:08:33]Right? Let's just kind of see what this thing does. And let's um reduce the volume of this thing because it's like ruining my [ __ ] brain.

[00:08:43]Okay.

[00:08:44]Uh but let's run estrus on this thing.

[00:08:48]Estrus not found.

[00:08:49]That makes sense. What was I expecting?

[00:08:54]Okay.

[00:08:55]So, we are seeing at very least like while there's some spam happening, right? But the spam is we're seeing some sound drive sound driver maybe sound driver uh call PCM I believe that's like uh PCM I I I I think that that's like pulse mod No, that's PWM. I don't know what PCM is.

[00:09:20]Um but this is IO control, and he's like syncing with the hardware every once in a while. So, I guess he's probably saying like, "Hey, there's stuff for you to do."

[00:09:26]Um and maybe these pointers are pointers to audio.

[00:09:32]Maybe, not sure. Right? He's reading this thing every once in a while, and he's kind of waiting on some file descriptor three, which is different than four.

[00:09:44]Um who this must be like probably this is probably the signal for when there's more data that we have to push in. I don't know.

[00:09:53]I don't know.

[00:09:54]Uh but I'd also like to look maybe more at the beginning of this.

[00:10:00]Uh right? Like let's see let's see like how this guy starts up.

[00:10:07]Um so he opens this thing libasound.

[00:10:13]Uh so there's that.

[00:10:16]And he like maps some some this is probably mapping shared libraries into his process space. Eventually he's he's writing to standard out, right? He's saying, "Hey, this is some stuff that I'm doing."

[00:10:29]Um he looks at a configuration file at user share also.

[00:10:36]So there's some some some stuff in there.

[00:10:39]Um and here it looks like he's basically taking the data that's in also.conf and printing its configuration so or reading its configuration, right?

[00:10:52]So he's saying like, "What is in this thing?" and he's seeing some pieces of like overall config, right?

[00:10:57]Eventually he's looking at libasound again.

[00:11:02]All right. Uh some more also configuration stuff. So there is also user share also, var lib also, etc. also. These are all places where information about the sound system seem to live.

[00:11:17]Um blah blah blah, right? A lot more also configuration snooping. I'm really more interested in where he starts actually like doing some audio IO, right?

[00:11:32]Um So, we see a new file here. Oh, this is HDA Intel. Okay, so there's some sort of sound card that might be HDA Intel. I've heard those letters before. Probably high definition audio on Intel CPUs. That'd be my guess for what that is.

[00:11:54]Um Okay.

[00:11:57]Where do we see some actual Oh, yeah, here we go. Here we go. So, we have dev sound.

[00:12:05]dev sound seems to be our entry point, right? And we see control and a load, maybe audio load.

[00:12:17]He's also saying here that none of these things exist, right? These are all you know it. But eventually he's going to find something.

[00:12:23]Maybe he tries all of these things and then falls back on some shared library otherwise.

[00:12:31]I would love to take a peek to see if those exist.

[00:12:36]Uh So, the VM I think is port mapped like this.

[00:12:42]Okay, so control C0 should have worked.

[00:12:48]Uh control C0.

[00:12:52]Ah, okay. So, he did manage to open that at some point here.

[00:12:57]Control C0. And then they have they also have a What was the other thing? A dev It was dev a something? A load, right?

[00:13:11]A load. So, does that ever manage to open successfully?

[00:13:16]No.

[00:13:18]So, it looks like he like tries Looks like a load is maybe like an alias for that thing where you know, typically you have it under dev sound, but maybe this is like an equivalent file that was older for like older versions of the kernel. Who knows?

[00:13:32]Who knows? Okay.

[00:13:33]But, we do have control C0.

[00:13:38]Who he does instantly close. You are correct about that. Am I going up or down right now? Control C0.

[00:13:46]But, does he ever not instantly close him?

[00:13:50]Here.

[00:13:52]Here he's opened him and he's leaving him open forever. And he starts issuing some ioctls on this thing, right? He's asking for some information.

[00:14:02]He's reading something.

[00:14:06]He's getting a version. And then I think that we're in the spam now.

[00:14:11]Yeah, easy. We're in We're in spam.

[00:14:14]All right.

[00:14:17]Cool.

[00:14:18]Cool. Cool. Cool. Cool. Cool.

[00:14:20]So, we have kind of two paths of investigation here. One is opening up the Linux kernel and trying to look at what the devsound interface is.

[00:14:33]The other is looking at the speaker test source code.

[00:14:37]Let's see if there's any like kernel docs on on devsound. I think that might be interesting.

[00:14:47]Uh and then we can work our way up. I think starting at the bottom and then going up is easier in my brain than kind of going top-down.

[00:14:55]So, we're going to do uh you know, kernel docs maybe {question mark} So, let's go to Linux. I have Linux 61826 cloned, which is the exact same version that's in the Alpine repos. And I have compiled this thing in a way where speaker test works when I swap this kernel in. And I've also set up some I'm jump to definition stuff. So, I have like nice navigation features ready to go.

[00:15:27]Um but, let's just look for dev sound.

[00:15:29]Maybe let's go to docs and look for dev sound first.

[00:15:34]Uh looks like there's a sound folder in here.

[00:15:40]Kernel API.

[00:15:42]Also driver API. All right.

[00:15:46]So, there is PCM API, where we have sound core PCM.

[00:15:56]Okay.

[00:15:57]Then, there's control stuff.

[00:16:01]Uh let's maybe look at it was there a cards, codecs, designs, HD audio, kernel API.

[00:16:12]Also driver API writing. Okay. So, maybe they're kind of just telling us to go look at like individual [ __ ] source files, right? That's what kind of what they're trying to tell us.

[00:16:21]This is called for a system on a chip stuff.

[00:16:25]Uh nothing super interesting in here that I'm seeing that's like automatic jumping out at me as like clear docs.

[00:16:35]Uh it was saying Wait, what what was it?

[00:16:37]It was like PCM core was in there. He told us to go look at a file.

[00:16:41]I don't know.

[00:16:43]I don't know. Where was that?

[00:16:47]Um kernel API also driver. So, this Oh, kernel API might be like internal kernel API, not external kernel API.

[00:16:57]So, maybe What does this say? Also configuration.

[00:17:04]This is like about how you build the kernel for this thing to work.

[00:17:11]Um all right.

[00:17:14]Let's go back to trying to find PCM stuff. Sound core PCM.

[00:17:24]All right.

[00:17:26]>> [snorts] >> Um Who like PCM at? Who calls this?

[00:17:31]PCM next.

[00:17:32]Who calls this?

[00:17:35]Ooh, wait, we have a bunch of ioctls that we called. Can we look at those?

[00:17:39]Like when we're feeding audio data?

[00:17:42]Let's look for uh sound PCM HW sync.

[00:17:52]Wow, what the [ __ ] That doesn't exist.

[00:17:54]Oh, PCM ioctl HW sync. My bad.

[00:18:01]Let's see Okay, so we are in some sort of PCM native thing. I think it's time to Google what PCM is.

[00:18:08]What does this mean?

[00:18:12]Um pulse code modulation.

[00:18:17]So it's very similar to pulse width modulation, which I've heard is PWM, I would assume.

[00:18:23]Uh what does it mean?

[00:18:29]What does it mean?

[00:18:35]Is there like a picture?

[00:18:36]Is this the picture? Sampling for 4-bit LPCM.

[00:18:42]Oh, are we literally just like sampling at a time?

[00:18:46]PCM is fancy speak for a bunch of equally spaced apple thing. Yeah, that does look like what this picture is saying.

[00:18:51]Also about GitHub might also be interesting to look at. I agree. I agree. Okay, but we like like I do let's look at what this HW sync thing is. Like what does this mean?

[00:19:06]What does it mean?

[00:19:11]Uh is sub stream like the arguments?

[00:19:17]Arg. So, when we saw some pointer come in with this thing, right?

[00:19:23]I guess HW sync does not have an arg, but we saw the arg in the cons here a lot, right? We saw HW sync on some pointer.

[00:19:32]Which is a little confusing.

[00:19:34]Cuz here it looks like he's not using it.

[00:19:41]Uh, but you know, whatever.

[00:19:45]And then what's Okay, but this looks like What are we doing here? Do PCM HW sync check and update PCM state.

[00:19:55]Okay.

[00:19:57]Okay. Yeah, yeah, yeah, yeah, yeah, yeah. So, here we're seeing some sort of like I'm maybe currently running and I need to update my hardware pointer to whatever thing you passed in, maybe.

[00:20:11]Right? Maybe something like that. So, so that makes sense. That does make sense as like this is the command that we're using to update the audio data.

[00:20:23]I would imagine. Let's look at um I octal LM read as well.

[00:20:30]Uh, was it I octal LM read, right?

[00:20:36]Like what is this thing doing?

[00:20:37]What is this thing doing?

[00:20:42]Um, he is Um, maybe getting like audio input, but I don't know why speaker test would have to do that. Also, watch has a good topology page.

[00:21:00]Fine.

[00:21:04]Fine. We'll go to their [ __ ] website.

[00:21:08]You're saying somewhere in here they have a topology?

[00:21:14]Is there no search? Top search.

[00:21:20]Nice.

[00:21:22]Nice.

[00:21:23]All right.

[00:21:26]So, the kernel does what?

[00:21:34]Uh load the topology binary file from user space. What the [ __ ] is a topology?

[00:21:42]Uh load their mixers. Wow, this is too advanced. Too advanced. Too advanced. I don't even know what this means yet.

[00:21:48]We'll come back here.

[00:21:49]But this is like a way to upload like blobs that tell you how you're supposed to like route all of your [ __ ] it looks like.

[00:21:59]Too fancy.

[00:22:01]Too fancy. Too fancy. All right, we'll come back. We'll come back.

[00:22:06]Um let's let's look at the speaker test source code.

[00:22:11]Let's look at the speaker speaker test source code. I think it is time.

[00:22:17]Cuz I am lost as [ __ ] looking at the kernel right now. And so maybe some uh some extra context will help us. This comes from also to utils here. Can we just clone this [ __ ] Can we just clone this [ __ ] Um speaker test.

[00:22:44]Okay, so somewhere presumably he is trying to generate some white noise, right? By just like ripping dev random into some [ __ ] So where is his like main loop?

[00:23:02]He opens this thing, he sets some hardware params.

[00:23:09]And then this seems to be the main loop.

[00:23:15]Okay, right loop here is probably the main thing and are we pink noise? Which which type of test are we?

[00:23:31]Speaker test.

[00:23:35]Um.

[00:23:45]Speaker test pink.

[00:23:48]So that makes that sounds like the white noise that we heard before. And if I do Yeah, okay. So pink pink is what we are initially testing.

[00:23:58]But it doesn't really matter, right?

[00:24:00]Like Uh wait, where were we?

[00:24:07]Yeah.

[00:24:08]Right, like if we're using a sine wave, it can be do this do this, whatever.

[00:24:11]This is But like what's interesting here is we're like doing some sort of frame generation and writing buffer. Now, where is this right loop used? He just does this forever, right? He's just in main ripping this [ __ ] He's calling right buffer all time.

[00:24:36]But it sound seems like maybe sound PCM drain or sound PCM prepare might be like a way for you to block on this thing.

[00:24:50]No, cuz this This Hold on. Is Is this thing called in a loop externally?

[00:25:02]Yes, four and loops. And then when we run speaker test we see time per period is the is the log that we're looking for for like every once in a while this thing happens. That's kind of like the outer loop.

[00:25:21]Top Oopsies, wrong thing.

[00:25:25]Time per period. Okay. So this is the outer loop that we're seeing and then he goes into right loop which is doing He's like populating the buffer for like 1 second at a time or something.

[00:25:42]So I guess an a question to ask is is this running like fast and then this is slow?

[00:25:55]Or it must be, right? Unless we're let's see the implementation of right buffer.

[00:26:03]Right, it doesn't Oh, I guess this could block.

[00:26:07]This could block.

[00:26:09]Okay, let's look that thing up. Where Where is this? Sound PCM right I.

[00:26:14]This seems to be some sort of library function probably coming from a sound lib would be my guess. I think drain and block Yeah, but it does You're right though, like 1 second sounds like a long time. So he's either populating 1 second of audio up front and then waiting or the sound right is blocking in some way.

[00:26:36]Sounds like a lot of make buffer contents followed by flush. Yeah, I do agree. I do agree like this does sound likely.

[00:26:45]But if buffer size is greater than n times period size is the only time he does this.

[00:26:55]So, I'm not sure. I'm not sure.

[00:26:58]Uh let's look at Let's see if we can find some docs for like this function.

[00:27:03]Like who who even owns this?

[00:27:06]Also project, the PCM interface.

[00:27:10]All right.

[00:27:14]Um write interleaved frames to PCM.

[00:27:18]If the blocking behavior is such that it is running, then the routine waits until all frames are put to the playback ring buffer. Aha. Aha. Okay.

[00:27:26]Okay.

[00:27:28]So, I guess we have some sort of also library, right? I mean, we saw that in the S trace that there was some sort of like libasound thing. Um but I would be curious to know like what this does.

[00:27:46]So, maybe we take a little peek-sees at the uh libasound source, right? Cuz I assume that's what it's going to be coming from? Like Can Is there like an example in here?

[00:27:59]Like what What is this? Also lib.

[00:28:02]Like what is this?

[00:28:06]Let's take a Let's pull this thing. See what that guy's up to.

[00:28:11]What does this guy up to?

[00:28:16]Uh Does this guy have like examples?

[00:28:24]Maybe not. Unlucky.

[00:28:27]Unlucky. But maybe we can see where this like sound PCM write I is going.

[00:28:35]You know, what's this guy up to?

[00:28:41]Can we Okay, wait.

[00:28:46]We're close.

[00:28:49]None of these look like the definition, but maybe it's like some sort of like macro [ __ ] It's always some sort of macro [ __ ] Right? Like here they're defining the function.

[00:28:58]But like Oh, it's in the include, of course. My bad.

[00:29:10]Oh, here we go.

[00:29:12]There isn't examples, but not on the doc site.

[00:29:16]Examples yet here.

[00:29:18]Test PCM, okay.

[00:29:22]Okay.

[00:29:24]Oh, here we go. Beautiful. This is like speed This is going to be like very similar to the speaker test thing, right?

[00:29:29]He is initializing some hardware params, some software params.

[00:29:39]He's choosing a bunch of options for these things.

[00:29:46]>> [snorts] >> Uh I don't know what the [ __ ] this means.

[00:29:51]Oh, probably he is outputting the thing he's hearing to standard out and you have to pipe it into something.

[00:29:58]Maybe.

[00:30:00]A bunch of like initialization stuff.

[00:30:04]And then he has transfer loop here.

[00:30:08]What the [ __ ] What is transfer method?

[00:30:15]Oh, here.

[00:30:16]Sure.

[00:30:18]I see. So, it's giving us all sorts of ways that we can access this data, right? We can write write and poll. We might have some sort of like async like notifications that the buffer's run out. I don't know what the difference between direct and non-direct are. Looks like direct means mmap here.

[00:30:37]Right? Anything Anything that has the word direct in it has the word mmap here. So, direct probably means I have the map the memory of the audio buffer mapped directly into my process space versus the other one is probably doing some sort of like write call somewhere, right? This sound PCM right I here versus in the direct version They They use mmap here, but it's like who cares, right?

[00:31:09]Okay.

[00:31:12]V map is nice because you don't have to worry about buffers. It just says how many samples are available to write.

[00:31:16]Interesting.

[00:31:17]Interesting.

[00:31:19]Driver memory gets mapped as in Yeah, maybe. Okay. Well, it seems like the core of everything here is again like in the right and poll loop, we have sound PCM right I in a sync callback with sound PCM right I. I think let's not worry about the mmap case yet cuz I think that'll make things like more complicated. Let's just start with trying to figure out what the [ __ ] sound PCM right I does cuz I think I think that that seems to be the core of everything.

[00:31:51]Which we saw in here somewhere.

[00:31:53]All right.

[00:31:55]So, this guy Is he doing anything? Hello?

[00:32:05]Am I high? Right here if I'm wave frames to PCM Yeah, we read that already.

[00:32:10]Oh, here. Sorry. This is the actually interesting part.

[00:32:17]Is this defined here? Okay. Uh who is calling some sort of V table um based off of this interface?

[00:32:27]Okay.

[00:32:29]So, there's some sort of like indirection going on here. I presume I stands for integer. Yeah, I also would presume that, right? Like I16s buff like I16 or I8 samples probably 16.

[00:32:43]Um okay.

[00:32:45]So, who implements right eye?

[00:32:50]Um okay. So, I would assume that the interesting thing here would either be PCM file or PCM hardware. Hardware sounds the most interesting, right?

[00:33:06]If we were just to like look at the names of these files, right? Shared memory, metered, like M mapped, some sort of like shared plugin, D mix, some sort of like mixing.

[00:33:18]Hardware's got to be.

[00:33:20]Hardware's got to be the interesting one, right?

[00:33:24]Who is calling right eye frames, which is not what we were seeing in speaker test, by the way.

[00:33:31]Right?

[00:33:34]So, that's kind of interesting. I guess we know from the S trace that we're getting lots of hardware six, which maybe is a result of him using the M mapped mode, right? Like if we were to look for HW sync in here, we have this function.

[00:33:57]Who it gets access through some HW sync V table, right?

[00:34:04]So, can we look at like are there docs for that? Sound PCM HW sync in PCM.c maybe?

[00:34:16]Here. Okay, synchronize stream position with hardware.

[00:34:19]Notice this function does not update the actual read write pointer for applications.

[00:34:25]This function the function PCM available update have to be called for any M map begin commit operation.

[00:34:31]Okay. Can we like force this thing to use a stupider mode? You know what I mean?

[00:34:38]It sounds like this function is deprecated. I mean, I'm sure it does the same thing, right?

[00:34:46]I'm sure this thing is going to HW sync under the hood eventually, right? Surely.

[00:34:59]Oh, maybe not.

[00:35:03]Well, yeah, it does look like it does something else, huh? Interesting.

[00:35:14]Interesting.

[00:35:17]Um okay, let's I would love to get this PCM test compiled.

[00:35:23]And then we can force it into the simpler mode, and then we can S trace that and try to get more information that way, right?

[00:35:32]Oh, oops, this is a lib a sound I think is what we're looking at right now. No, also lib?

[00:35:39]I don't know.

[00:35:41]That's what we're looking at right now.

[00:35:43]Uh yeah, can we like how the [ __ ] do we compile this?

[00:35:48]Uh like I I presume Nix built this at some point.

[00:35:59]At some point, right?

[00:36:01]Where they had uh probably in here there's like what? Also lib?

[00:36:08]Cool.

[00:36:10]Cool.

[00:36:12]With import Nix packages, uh packages, make shell, and then there is like I think it's inputs from to copy the configuration for another guy.

[00:36:26]Yeah.

[00:36:30]So, we're like just literally copy everything. And then, while we're here, can we also do like uh give me some clang tools.

[00:36:41]Maybe some GDB, maybe PCM min C seems a lot easier.

[00:36:58]This does seem easier. I agree.

[00:37:01]Sure. I think either are fine in terms of like what I'm trying to understand, but yeah, let's let's do that.

[00:37:09]Um so, presumably, we need to do like a Looks like an auto tools project. No configure file generated yet. So, I think How do you do this? You do like Oh, [ __ ] AC local.

[00:37:24]Oh my god.

[00:37:26]Uh auto tools.

[00:37:29]Uh AC local, automake.

[00:37:41]I don't remember how to do this. It's been a minute.

[00:37:43]./configure.sh make, but I don't think that there is a configure here yet.

[00:37:48]Auto reconf is definitely the thing I'm I remember typing.

[00:37:54]Which doesn't seem to exist.

[00:37:57]autoconf God damn it, dude.

[00:38:03]God damn it.

[00:38:10]All right.

[00:38:12]configure Well, [ __ ] me, I guess. AUTO RECONF ERROR.

[00:38:18]OH, USUALLY, this thing is already done for you if you pull like an actual release package.

[00:38:24]Awesome lib.

[00:38:31]Uh usually the tarballs have the like configure stuff already Oh, wait, get compiled. You're right. That is worth looking at.

[00:38:40]This bad interpreter, great, cuz I'm a [ __ ] NYX.

[00:38:50][ __ ] me. [ __ ] me, I guess.

[00:38:53]All right. All right. All right. All right. All right.

[00:38:57]Sometimes awesome lib releases.

[00:39:03]You trying to rebuild the lib awesome go? I don't know. I'm just trying to like I've got a project. I want to compile some code in it. I [laughter] haven't really thought that far.

[00:39:14]CD speaker doesn't make This speaker test isn't from here. I would like speaker test isn't the one I'm trying to work on, but like sure.

[00:39:20]Like I'm looking at source. I wanted to look at pcmmin.c.

[00:39:26]The extra small demo.

[00:39:31]Um great.

[00:39:34]Cool. Cool. Cool. Cool. Cool. Cool.

[00:39:36]Cool. Cool. Cool. Cool. Cool.

[00:39:39]Their website's down.

[00:39:43]Um all right.

[00:39:45]GCC No, I mean maybe.

[00:39:48]But like I think that it would it's not unreasonable to try to like build their software with their build system, right?

[00:39:55]I don't think that's like unreasonable.

[00:39:58]Like cuz like if you just stop just like typing commands, right? Like if you look in here, like they're clearly like expecting that I am like part of this project, right? I don't think that it's like guaranteed that if I do this Right? Like you know?

[00:40:18]Use he's not he he's not that simple, right?

[00:40:23]It's not that simple. A sound wave isn't even in here.

[00:40:28]Um so, I think that it's reasonable to like build the project. I don't think that's crazy.

[00:40:33]I don't [snorts] think that's crazy.

[00:40:35]Uh [ __ ] finally. Uh okay.

[00:40:38]Also lib is the thing I'm trying to download, right?

[00:40:47]Uh probably like up here.

[00:40:50]And how maybe this thing has the already configured scripts thing done. I don't know. Let's see.

[00:41:01]Hello?

[00:41:02]There we go.

[00:41:04]Nice.

[00:41:05]He's already got the stuff that we need.

[00:41:09]Perfect.

[00:41:10]Configure.

[00:41:13]Much better.

[00:41:16]Much better. There, see? Now he generated that thing.

[00:41:20]Uh so, then can we like make help?

[00:41:24]Make file. Does he have like tests?

[00:41:28]Or what was the folder? Test.

[00:41:33]Oh, test has no make file. Beautiful.

[00:41:38]Uh do we have PCM in in here somewhere?

[00:41:45]Uh yeah, it does look like it. Make PCM in.

[00:41:49]Uh looks like we might have to build this guy first.

[00:41:58]Give him a sec. He's thinking. Thinking hard. Perfect.

[00:42:02]Tests.

[00:42:04]Are we happy? Beautiful.

[00:42:07]Perfect.

[00:42:09]Um unfortunately, this is not the environment that I want to be in. I want to be in my VM.

[00:42:15]But maybe we can do a little Like is this thing like dynamic link?

[00:42:21]No, so we should be able to do like an SCP PCM in uh into root at localhost.

[00:42:32]Maybe?

[00:42:35][ __ ] I guess we maybe need to build it in the VM.

[00:42:40]I'll get Uh I guess I copy the tarball over.

[00:42:45][ __ ] my life.

[00:42:48][ __ ] my life. Uh SCP also lib into uh root at localhost.

[00:43:04]Colon is root. Colon is the home directory of whoever you were talking to, which is {slash} root on this system, I think.

[00:43:11]Uh tar xf also lib.

[00:43:16]Beautiful.

[00:43:17]Can I build this?

[00:43:19]I [laughter] don't know.

[00:43:22]Uh APK add GCC G++ I think you need like lib C dev.

[00:43:30]I don't know, man.

[00:43:33]Probably need make.

[00:43:36]>> [laughter] >> I don't know what's happening.

[00:43:41]I don't know what's happening.

[00:43:42]I just remember Alpine being a little bit of a pain in the ass here.

[00:43:46]Uh hi future me. Hello.

[00:43:48]>> [laughter] >> See happy now? Configure.

[00:43:55]Uh something went wrong.

[00:43:58]Uh make. Yeah, uh APK add make.

[00:44:03]All right, let's try that again.

[00:44:04]Configure.

[00:44:06]Beautiful.

[00:44:08]Uh he's missing this thing. Oh, I remember seeing this as well. You need to like add Linux headers maybe.

[00:44:15]Okay, closer. Closer.

[00:44:18]Closer.

[00:44:19]Closer.

[00:44:20]It's building in the VM. Pipe test make PCM test make PCM in.

[00:44:28]P- PCM in.

[00:44:30]Oh, let's [ __ ] go.

[00:44:32]We [ __ ] got it. We Okay, so now we can actually trace this.

[00:44:37]And take a look at that thing.

[00:44:45]Okay.

[00:44:47]So, what is this guy doing in his spam lib? It's the same thing.

[00:44:52]It's the same thing. He is doing the same HW sync spam.

[00:44:58]So, can we make PCM What was the other one? The like more configurable one? Make PCM.

[00:45:06]Right, we should be able to see in uh here we should be able to configure this thing to run in like a different mode, right? Like I want to see the [ __ ] right and poll loop or something.

[00:45:24]Like one of the ones that's using like a different mode of doing this [ __ ] Uh so, how do we do that? Is it transfer method?

[00:45:34]Yes.

[00:45:36]PCM {dash} M right.

[00:45:40]Okay, cool.

[00:45:41]Then can we actually trace this?

[00:45:51]Okay.

[00:45:59]Hold on, let's let it run for a little longer. One Mississippi, two Mississippi, three Mississippi, four Mississippi.

[00:46:09]It's a lot of the same, right? A lot of the same underlying spam of HW sync, which just doesn't line up with the code that we've seen, right?

[00:46:19]Cuz the code that we were looking at was calling I can't remember. I can't remember.

[00:46:38]Hold on. Hold.

[00:46:48]Uh Bum bum.

[00:46:54]I guess here.

[00:46:59]Wait, where's the implementation of the function? Here.

[00:47:02]Right, he was calling right I.

[00:47:12]Which we were assuming was going to PCM hardware, but I guess that might not be true.

[00:47:18]Right? Might not be true.

[00:47:22]And now that we have this thing compiling, we can actually just edit this [ __ ] Um Drive him.

[00:47:31]Uh this is going to be a little annoying in the VM, but whatever. C source source hardware Wait, what is it? Was source PCM?

[00:47:46]And then PCM hardware.

[00:47:49]Can we confirm if our right like this right I potentially is being called?

[00:47:59]Hi, I'm writing PCM hardware. Right, it might be the case that this is not happening.

[00:48:07]Might be the case.

[00:48:09]Um, so can we just do a little make and test and make PCM and run this thing again?

[00:48:21]Yeah.

[00:48:24]Okay.

[00:48:26]So that's a cool that's a good clue.

[00:48:29]That's a good clue. Then who do we think that it might be?

[00:48:36]Who else could it be?

[00:48:39]I guess there was a bunch of like opening of that config file that we were seeing at the beginning. Maybe let's look at it look at that thing. ETC also conf nothing.

[00:48:50]User share also also conf, right? Like can we Maybe there's something here.

[00:49:01]Or maybe that that prints of debug info.

[00:49:03]We didn't actually read anything.

[00:49:08]Okay.

[00:49:09]Using transfer method right playback device is plug HW, okay? Plug HW.

[00:49:18]Uh Okay.

[00:49:25]So maybe in like the default configuration plug HW sounds like we saw like a PCM plug, right? Plugin?

[00:49:36]Right, we did see plug PCM plugin was a thing we saw. So maybe that's where this is going.

[00:49:49]Maybe.

[00:49:58]>> Uh print f Hi Mick, I'm writing plugin.

[00:50:05]Plug plugin backslash n, perfect.

[00:50:09]>> [laughter] [snorts] >> Okay.

[00:50:17]So, CD test make PCM.

[00:50:20]And then can we do PCM?

[00:50:23]Aha!

[00:50:24]Aha!

[00:50:26]I see, I see.

[00:50:29]So, this is going to some plugin. So, so the even in like the brain dead simple case, it gets way more complicated.

[00:50:40]Right? So, also the like also user space library is dispatching to some plugin, but the plugin is a hardware plugin.

[00:50:51]Right? Is that what I'm seeing? Is that what I'm seeing? How the [ __ ] does this thing get initialized? That's the next question.

[00:50:59]So, like PCM plugins.

[00:51:04]Plugins extend functionality and features of PCM devices. The plugins take care of various sample conversions, sample copy among blah blah blah. Ah, okay. So, we we saw something about like We saw plug HW, right?

[00:51:27]This looks like like a This looks like a definition for what the plug HW can be, right? It's saying like, "Hey, you can be a card, a dev, a sub dev. You can be a PCM card or a card." It doesn't look like this is like an instantiation of that thing, you know what I mean?

[00:51:46]You know what I mean?

[00:51:49]So we keep I'm interested to know like where this is get coming from. Can we look at the S trace again? Oopsies. Uh So like where does he determine that plug HW is the thing that he wants to do?

[00:52:08]I think that is a piece of information. And then also like does that does that involve some form of like shared object that's hooked in or or it does it not? I don't know.

[00:52:24]Here he's doing a bunch of like looking at file descriptor three here. What is file descriptor three?

[00:52:32]We're looking for like an equals three on the right here. So he's looking at this. User share also also.conf, which is just the thing that we just opened, right?

[00:52:39]Oh, then there's also Well, here he's already decided that he's plug HW.

[00:52:48]Okay.

[00:52:49]Um let's just do some grepping for like or like scan this top of the file.

[00:52:54]PCM plugin extends functionality. Slave plugin P specified directly with a string or the definition can be entered inside a compound configuration node.

[00:53:05]Okay.

[00:53:11]So just double checking, there's no A sound. There's no also.conf in ETC, so it's got to be looking at user share.

[00:53:20]What else is in here? Also Okay.

[00:53:25]There's a lot of configurations in here as well.

[00:53:36]Maybe we got confused and we should have been looking at the defaults a little bit more closely.

[00:53:44]Uh plug HW, right? So, maybe these defaults are the important thing to look at.

[00:53:53]Maybe.

[00:53:58]I'm so confused about where these where these variables are coming from.

[00:54:01]I'm so confused about this.

[00:54:08]Oopsies. Uh user share also.

[00:54:19]So, like is this thing getting defined somewhere? Like or is it in my environment?

[00:54:31]Is it like passed in? Who knows?

[00:54:38]Who knows?

[00:54:42]Env grep also.

[00:54:44]Env grep card. No, okay.

[00:54:48]Um why not pipewire 2007 card? Because we're try we need to start at the bottom before building our way up.

[00:54:55]Right? Like pipewire, according to the also Wikipedia page, is built above also. So, if we're trying to understand the full stack, we got to we got to scope the problem first.

[00:55:08]Um interesting.

[00:55:10]Interesting.

[00:55:13]Maybe the trick here is to look at PCM in and maybe try to figure out how he is constructing his V table in these guys, right?

[00:55:29]Right? Yeah.

[00:55:31]Sound PCM open. Let's look in there.

[00:55:36]Um Looks like he's looking over some UCM device. I don't know what that means.

[00:55:45]And trying to match like config names.

[00:55:53]Okay, so the name is coming in as device.

[00:55:57]Where he's using default, right? So he is iterating all Oh, if is device, sound is UCM device. What does this do?

[00:56:14]Oh, okay. This will just be false.

[00:56:17]So here, they're like config update ref.

[00:56:24]What's this do?

[00:56:26]What the [ __ ] does this thing do?

[00:56:31]Oh, he's just he's just incrementing the the reference count.

[00:56:37]To this pointer.

[00:56:40]And then once the reference count is opened, then he's populating the stuff with this thing.

[00:56:46]Gotcha.

[00:56:50]So the name here is default. So he's searching for the config definition through like the list of all config of all configs.

[00:56:59]And presumably he then starts like I don't know.

[00:57:11]I don't know.

[00:57:14]Okay. Uh let's go up a level. Maybe we're looking in the wrong spot.

[00:57:22]Opens a piece of hardware. I mean, he's got like at this point he's got all resolved stuff, right? So I guess what is the return here?

[00:57:30]He is returning PCMP. This is what he's trying to do, right?

[00:57:42]So, who initializes this guy?

[00:57:44]Open no update or open conf. Okay, sure.

[00:57:47]So, we go to open conf.

[00:57:49]We got this pointer that's the uplet.

[00:57:52]Jesus [ __ ] Oh my lord.

[00:58:01]So, he's like got some dynamically linked libraries that he might that he loads these things from.

[00:58:08]Okay, which presumably are like in like user lib.

[00:58:16]No.

[00:58:19]Uh well, we can probably look at the S trace again to see who he's opening.

[00:58:27]Maybe.

[00:58:29]No deal open.

[00:58:34]Okay, interesting.

[00:58:37]Interesting.

[00:58:41]Do we see anything like.so in here?

[00:58:44]Just lib a sound.

[00:58:49]Okay.

[00:58:52]So, that's confusing.

[00:58:58]Maybe maybe we're in the other path.

[00:59:09]Open no update, maybe.

[00:59:14]Uh wait, no. This is already the function we were in.

[00:59:19]So, it has to this is where it initially end ends up going eventually.

[00:59:27]Um I guess we could just start like adding logs.

[00:59:38]That's not crazy. Sound config for each.

[00:59:44]Oh my god.

[00:59:49]Is he sound PCM blank open?

[01:00:00]And oh, okay, then there's built-in PCMs. Here we go. Here we go.

[01:00:07]And so this thing might not be an actual PCM module. It might be built-in.

[01:00:16]Maybe. There's also lib asound module things in here.

[01:00:24]lib asound star We don't see any modules.

[01:00:29]So it's probably all built-in somewhere.

[01:00:32]So where what are these built-in PCMs? AHA!

[01:00:37]AHA! OKAY.

[01:00:41]Now plug HW is not a thing in here. It's not. But but maybe we can get some extra information.

[01:00:58]Okay. We're we're we're chipping away at it.

[01:01:05]Um uh okay.

[01:01:11]Lots of defaults in here.

[01:01:17]I don't understand how the plug HW thing is going. Hey, what's up, guys? Thanks for the raid. What's up? What's up?

[01:01:22]What's up?

[01:01:24]We are slowly chipping away at trying to understand when I try to play sound on Linux what happen? What happen?

[01:01:34]We are poking and prodding the also library to figure out like there's some mapping somewhere of like I have some bits and bytes and I want to put them on my card and we're trying to figure out where where does that go? How does it get to the driver?

[01:01:55]And from there, where does it go? That's what we're trying to figure out.

[01:01:59]We have found some examples where we have some you know some test that basically just rips right PCM data in a loop and then we're trying to figure out where the [ __ ] does that go under the hood. It goes into some V table. The V table has initialized with some plug HW interface and we're trying to understand like why and how and where does that go etc. etc. Um so hope you guys had fun over at S17N stream.

[01:02:30]Um hope you had a good time over there.

[01:02:32]And we're just going to keep going.

[01:02:35]Um okay.

[01:02:37]So we are presuming that in sound PCM open he is somehow determining that he wants to open the plug HW interface. That's what we're deciding in sound PCM open cough.

[01:02:55]So I guess we can just start like ripping some logs in here and see what happens, right? Like at least we can look for the open name.

[01:03:05]Let's do that. Let's just print the open name. Do we do we do GCC? Is it right?

[01:03:08]Have we compiled in debug mode? I don't even know.

[01:03:14]Uh maybe like verbose equals one make Uh can I like touch a file and see how it's getting compiled?

[01:03:30]Uh maybe V equals one.

[01:03:37]Oh, there we go. I saw a compile command somewhere.

[01:03:41]I see dash G dash O two. So, we're building with optimizations, but it should be GDP-able.

[01:03:49]It should.

[01:03:51]You're not interested in kernel interface? I am eventually. I want to see how it gets the kernel interface so we can figure out what [ __ ] like what do we expect what what do we even think is supposed to happen from a user space side? Because when I was looking at the kernel space side, I was lost, right? So, I'm hoping to gain some context here.

[01:04:10]So, if we're just like uh what like function are we in that we're like that is of interest to us?

[01:04:17]This is sound PCM open conf.

[01:04:23]All right.

[01:04:27]Uh make PCM man.

[01:04:31]And then we want to do like a GCC PCM man and we want to Oh.

[01:04:36]GCC PCM man GDB, sorry, PCM man. I'm an idiot.

[01:04:41]And can we break at B PCM.c line 2612?

[01:04:50]Unlucky.

[01:04:51]Are they stripped? They're probably [ __ ] stripped, right? Can we Probably there's like some config flag that we're supposed to do to like end up in debug?

[01:05:03]Enable debug symbols.

[01:05:11]I [ __ ] don't know how auto tools works, man.

[01:05:18]Like GDB PCM man, can I break on a function here?

[01:05:26]B sound open PCM Wait. Not in executable format? What the [ __ ] are we talking about?

[01:05:42]What do you mean?

[01:05:45]Does GDB need like some sort of like extra [ __ ] to work properly?

[01:05:52]Hold on.

[01:05:54]Uh touch test C uh vim test C it main What?

[01:06:03]Return zero.

[01:06:06]Uh GCC test test GG GDB I don't know dash 00 test.c or something. Like can I run B main? Yeah, I mean that's fine.

[01:06:25]file test file not found. Of course not.

[01:06:31]PA add file file test. This is a 64-bit executable. We go back to also live test.

[01:06:42]Uh file PCM in What is this thing?

[01:06:46]Oh.

[01:06:48]The [ __ ] What?

[01:06:51]Hello?

[01:06:55]>> [laughter] >> Okay.

[01:06:58]What [ __ ] [ __ ] auto tools?

[01:07:02][ __ ] auto tools. Who knows what the [ __ ] is going on here?

[01:07:05]Where are we going to break? Sound PCM.

[01:07:10]Open cough.

[01:07:13]Maybe on shared library. Let's just see.

[01:07:15][ __ ] run it. Kill me. [ __ ] me.

[01:07:18]Backtrace. We do Oh, I mean this is a static.

[01:07:24][ __ ] Can we like BPCM.seed?

[01:07:27]Like what if we do this?

[01:07:29]What line were we looking for? Open name.

[01:07:34]2612 No, yeah. Okay. Well, [ __ ] me, I guess.

[01:07:40]Maybe in here like RMPCM in and can we do like a make PCM min v equals one verbose equals one?

[01:07:52]We do see some dash Gs in there.

[01:08:00]He is using a sound.so.

[01:08:05]So, what if we like force GDB to load that?

[01:08:09]How do you do like a GDB load shared object?

[01:08:17]Did enable debug not work? I thought that it was on.

[01:08:23]We double double check.

[01:08:29]We can double check.

[01:08:31]On recognize options.

[01:08:41]Yeah, I mean that's I don't even On recognize options, but also this isn't what we want, right? He's like I want some of [ __ ] asserts.

[01:08:49]Can we like Dude, auto tools [ __ ] debug symbols GDB. Like can somebody just [ __ ] tell me what I'm supposed to do?

[01:09:01]Oh my god.

[01:09:04]C flags {dash} G GDB. Are you [ __ ] kidding me? Is that really what I'm supposed to do? Like, how do I set the optimization level?

[01:09:11]Cuz he's like shoving in an O2 in there, right?

[01:09:17]C flags. I see. Okay. Well, [ __ ] me.

[01:09:24]Uh {dash} G GDB O zero.

[01:09:29]Well, [ __ ] me.

[01:09:31][ __ ] me, man.

[01:09:33]Why is everything so [ __ ] hard?

[01:09:36]Do I do it Do I do C flags on configure here?

[01:09:47]Okay, what a [ __ ] sick interface.

[01:09:49]Yeah, just [ __ ] re- throw some random [ __ ] environment variables in there.

[01:09:53][ __ ] it. [ __ ] it.

[01:09:56]Kill me.

[01:09:57]>> [laughter] >> I'm not mad. I'm not mad.

[01:10:12]Make PCM, man. What is it?

[01:10:16]V equals one verbose equals one. Do we see some like We see some GGB O zero.

[01:10:21]Okay.

[01:10:23]And then we run this and maybe now we can break point at the [ __ ] function we want, which is PCM.c 2612.

[01:10:34]And then we're going to get a future library to load it. [ __ ] B PCM.c 2612. Of course not because probably the shared object is stripped, right?

[01:10:47]Right? Probably.

[01:10:50]So, how can we [ __ ] build with like a static library to make my life easier?

[01:10:59]>> Shared. Enable shared. No.

[01:11:05]This is a fun a fun way to spend my time. Make clean.

[01:11:11]Make. Try again.

[01:11:14]You type PCM. I'll say [ __ ] Fine.

[01:11:19]I'm a [ __ ] idiot, okay? I'm a [ __ ] idiot.

[01:11:25]No, I didn't. Don't [clears throat] Don't [ __ ] Oh, PCM.OC was the file I'm looking for, by the way.

[01:11:31]So, I think that's right.

[01:11:36]Oh, okay. Now PCM in is not a not a script, by the way. So, I don't know.

[01:11:46]Oh, let's [ __ ] go.

[01:11:49]Okay, that function just never That function just never We're just never get here. We just never [ __ ] get here.

[01:11:54]Bsound PCM open conf.

[01:11:57]Run. Yes. Okay.

[01:12:00]Let's just [ __ ] spam steps. Go.

[01:12:04]Okay. What the [ __ ] happened?

[01:12:09]We got to open funk.

[01:12:12]Can we break there 2615?

[01:12:19]Sound PCM empty open. Great.

[01:12:26]Okay, so he's going through a lot of these, I guess.

[01:12:32]And I guess Is this in a big ass loop?

[01:12:41]Is this in a big ass [ __ ] loop? Are we recursing? What the [ __ ] is going on?

[01:12:48]We're in sound PCM empty open, which I feel like I don't want to be.

[01:13:00]Huh.

[01:13:04]Interesting.

[01:13:05]This is not what Okay, I just want to know how the [ __ ] he decides that he's in plug HW, right? That's That's how This is all we're looking for is like how does he decide where he is? Oh, wait, okay.

[01:13:19]So, what we're going through some sort of chain here, right? We're like we start at empty, then we end back in A sim, and then we end back in plug, and we end up in PCM.

[01:13:34]That's kind of funny.

[01:13:38]And then we end up in soft ball?

[01:13:42]And we end up in D mix?

[01:13:45]What is this?

[01:13:49]WHAT [laughter] THE [ __ ] IS HAPPENING?

[01:13:51]WHY?

[01:13:54]All right, well, this is not helpful.

[01:14:02]Uh let's maybe try to after we do all this [ __ ] uh can we like just look at maybe PCM in?

[01:14:17]Can we just break point at here? Like just right [ __ ] here.

[01:14:27]Sound PCM open. Run. Finish.

[01:14:31]P handle.

[01:14:34]P star handle.

[01:14:38]Um okay.

[01:14:42]Does this give us any information?

[01:14:45]Name equals default.

[01:14:51]Name equals default. Right, so somewhere the default config has told us this is what we want. But how? But why?

[01:15:00]But why?

[01:15:04]Oh my lord.

[01:15:09]Oh my [ __ ] god.

[01:15:14]Can I So is he Here he is going What does our [ __ ] backtrace look like?

[01:15:24]What are we looking at? Right, so he's in like each of these open functions is calling open named slave for some reason, right?

[01:15:37]But all of these have the name default.

[01:15:42]Is there like default configuration like something [ __ ] insane?

[01:15:50]Okay, let's let's try to figure out where is this Why Why Where is this open funk coming from, right? That's probably the question.

[01:16:02]Right, like this is coming from here somewhere open name.

[01:16:07]Where he is iterating each configuration.

[01:16:21]And is I like Where is I coming from? I is just an iterator type.

[01:16:30]Like why isn't it just recursing over and over again into the same [ __ ] thing?

[01:16:36]I would like to look at this. This is 2555.

[01:16:49]Uh Hold on.

[01:16:57]That never gets hit.

[01:17:02]Hold on.

[01:17:04]Hold on.

[01:17:08]Oh, which means that we're probably here, right? 2589 Aha, okay. So, what is buff here?

[01:17:17]Sterling stir, what is stir?

[01:17:22]Config get string.

[01:17:32]Okay.

[01:17:34]Uh so, Uh okay, so he's looking for PCM type somewhere.

[01:17:41]And then the open funk is sound PCM PCM PCM type. So, if we go back to our A sound conf, maybe?

[01:17:52]Also conf?

[01:17:59]Uh he is iterating over something.

[01:18:10]Uh Mhm.

[01:18:20]Yeah, okay.

[01:18:22]Okay, we're going back. We're going back.

[01:18:24]User share A also also conf.

[01:18:29]Empty. Empty doesn't live in here at all.

[01:18:38]Dude, I'm going to [ __ ] lose my mind.

[01:18:43]I'm going to lose it. Like, what is happening? Sound config search.

[01:18:51]I guess he's looking What is comp here?

[01:18:57]PCM comp. So, this is coming We're we're kind of like down a couple layers, right?

[01:19:05]Like, he is looking for definitions of PCM.

[01:19:16]And then, within PCM configurations, he's looking for type.

[01:19:27]I think.

[01:19:30]Oh, wait. Wait. Wait. Wait. Wait. Wait.

[01:19:32]Wait. Wait. Wait. Wait. Wait. Wait.

[01:19:33]Wait. Wait. Wait.

[01:19:39]In PCM, ah, maybe?

[01:19:45]Wait. Is this it?

[01:19:49]Aha!

[01:19:52]I think we found it. So, in this user share also PCM, he has a default configuration where he's like, I am the empty type, and I below me have a plug type. And then, we look at plug.

[01:20:19]Uh, maybe his type is hardware.

[01:20:27]Slave PCM.

[01:20:31]This is probably where plug HW is coming from.

[01:20:39]And then I don't really understand what any of this means yet, but this seems to be where this is coming from.

[01:20:52]Okay.

[01:20:54]Plug type hardware below.

[01:20:58]We found it. We found it. Now, what the [ __ ] does it mean?

[01:21:02]>> [laughter] >> Right, what the [ __ ] does it mean?

[01:21:09]So, we are expecting this guy I guess based off that configuration to have some sort of slave in here.

[01:21:25]Okay, and so when we do like righty here or like sound was it plug HW?

[01:21:37]Where am I?

[01:21:40]High mic We had a log for high mic in here somewhere, but it's it was not in here. [ __ ] Plug.c PCM plug.c This feels like where we were. And then he's got like a V table somewhere, right?

[01:22:01]Right, cuz we had like right eye somewhere.

[01:22:09]But does PCM plug not have right eye?

[01:22:17]That's interesting.

[01:22:20]Right? There's IO plug, but I don't know if that's the same thing.

[01:22:31]>> Okay.

[01:22:33]We're getting We're getting closer.

[01:22:36]We're getting closer.

[01:22:40]Plug is plug in. It does That's seems likely.

[01:22:51]Cuz I think we did see PCM plug in with that right function, right? Is that where we were before?

[01:22:58]I don't remember.

[01:23:02]I don't remember.

[01:23:04]Um CD source uh PCM PCM plug in right I. Yeah, okay.

[01:23:14]This is where we were. So, then presumably Like [snorts] this guy has to flush down to his children, right?

[01:23:33]Somehow?

[01:23:35]So, in the like example he does a bunch of right eyes.

[01:23:49]For I 0 to 16.

[01:23:57]He [snorts] Can we run the thing again and look at the output?

[01:24:12]A lot He's just doing 16 rights, right?

[01:24:21]Okay.

[01:24:25]So then are we missing the piece where he does a flush underneath? No, right? He's just He's literally just calling right eye.

[01:24:37]And that's it.

[01:24:43]Oopsies.

[01:24:48]Which calls areas from buffer and right here. So maybe this is the interesting part. Sound PCM right areas. Must be.

[01:24:58]Which is sound one PCM right areas.

[01:25:05]Hello.

[01:25:09]Where is this defined?

[01:25:11]Oh, here.

[01:25:13]Maybe.

[01:25:14]Maybe.

[01:25:19]So what if this guy?

[01:25:22]Like Oh, he's calling maybe hardware sync.

[01:25:28]And maybe that in the plugin version ends up like pushing down to the underlying guy.

[01:25:37]Maybe. We're really guessing here.

[01:25:43]Yes. So he hardware syncs the slave after.

[01:25:48]I see.

[01:25:50]I see.

[01:25:56]Which means that these buffers must be like pulled from somewhere.

[01:26:02]I would Can we like just not do the plugin part?

[01:26:06]Can we just like change our configuration to not do this?

[01:26:13]What if we did that?

[01:26:14]Right? What if we did um Vim user Okay, let's go to user share.

[01:26:25]Also PCM.

[01:26:30]And copy defaults like default back.

[01:26:35]And can we change this guy to like [ __ ] like just take this part out?

[01:26:54]You know what I mean? Is that a thing we can do? Just take it out?

[01:26:59]And then does that make make us use the right the the more obvious right function?

[01:27:09]No.

[01:27:11]But maybe this is not using the right uh uh configuration.

[01:27:35]Here it is.

[01:27:40]I think.

[01:27:45]Huh.

[01:27:48]Can you please explain what you're trying to achieve? Not really, cuz I don't really know. I'm just trying to understand how the [ __ ] audio works, man.

[01:27:56]How the [ __ ] does the audio work? That's about the extent of it.

[01:28:06]But we don't understand. We don't know anything.

[01:28:09]We don't know anything yet.

[01:28:14]Um, okay. So, there's also like some sort of chaining to like a mix or something.

[01:28:21]Oy, oy, oy.

[01:28:24]Like, I'm assuming that somewhere in this chain we have like somehow mapped the memory from the audio buffer on hardware in the kernel driver somewhere, right? Like, we have to.

[01:28:40]We have to have.

[01:28:43]But, it's hard to find where that is.

[01:28:49]You know what I mean?

[01:28:50]This is freaking hard.

[01:28:59]Like, maybe in here?

[01:29:03]There's like prepare, start, hardware refined, software params.

[01:29:11]Like, this mmap, probably, right?

[01:29:20]He's asking on file descriptor four, where file descriptor four is this PCM handle.

[01:29:32]Right? It looks like he's got a PCM handle. He's mmapping that thing.

[01:29:39]And then, presumably, dumping [ __ ] Okay, can we like Uh great.

[01:29:53]Cool. Love that.

[01:29:58]Who calls mmap?

[01:30:08]And know, like a server in here.

[01:30:14]Oh, okay. Wait. This looks I guess we can look for like M map null, right? Cuz that's the thing that we saw.

[01:30:28]This looks promising.

[01:30:37]Uh We see 40 on the M map.

[01:30:49]Sound dirt.

[01:30:52]Sound RV [ __ ] Can I paste?

[01:31:03]God damn it. Please. Please. Okay, copy.

[01:31:06]Paste.

[01:31:11]Data is zero.

[01:31:18]That's not used anywhere.

[01:31:21]Why?

[01:31:24]Why?

[01:31:31]Hmm.

[01:31:34]Hmm.

[01:31:43]Oh, wait.

[01:31:45]How did I end up in A sound? Oh, yeah, we're good. Okay, M map null.

[01:31:56]Like Yeah, seems wrong here.

[01:32:07]Right, like searching for this string gives us nothing.

[01:32:12]So, maybe we're looking at the wrong M map call.

[01:32:23]I guess we could just log them all.

[01:32:27]I guess we could.

[01:32:28]Since we're so [ __ ] lost.

[01:32:34]Where is this? This is in PCM M map.

[01:32:48]Uh print f hi Mick, I'm area M mapping.

[01:32:59]Uh we're looking for maybe this one in PCM hardware.

[01:33:09]Print f hi Mick status data. I don't know, man. We're just trying to get some feel for anything.

[01:33:20]Hi Mick control data.

[01:33:24]Uh then can we do a little make and test and make PC make PCM in Do any of these?

[01:33:39]Hi Mick status data. Hi Mick control data. Hi Mick I'm area mapping. It's actually hitting all of them.

[01:33:47]>> [laughter] >> All of them.

[01:33:51]Okay.

[01:33:54]And And we can actually S trace this, which should give us a little bit more of a clue of um Yeah, like here we're saying hi Mick, I'm area mapping, followed by the thing that we were saying.

[01:34:13]And then presumably, like this is where the actual data is being written. That's what I would assume, right? Cuz we're in plug hardware or in the hardware thing, we're mapping the area.

[01:34:30]Okay.

[01:34:37]Wait, wait, wait, wait, wait, wait, wait.

[01:34:45]Where did I write I'm area mapping?

[01:34:48]It's got to be here, right? Uh M map null.

[01:34:57]PCM M map.

[01:34:59]Great.

[01:35:06]So, this guy is like he's he another [ __ ] V table?

[01:35:14]Like like who is this? What is this function What is this file?

[01:35:19]Maybe this is used everywhere?

[01:35:29]Like >> [laughter] >> sound PCM M map. Like who uses this?

[01:35:39]Plug-in.

[01:35:45]Direct params local.

[01:35:48]A server.

[01:35:53]Jeez, Christ.

[01:35:57]I guess we could break point there and backtrace and see.

[01:36:01]Let's do that.

[01:36:02]Let's do that.

[01:36:06]B sound PCM M map. Run.

[01:36:10]Continue.

[01:36:11]Okay, so it was that one. Run.

[01:36:13]Backtrace. Who's call Jesus [ __ ] Holy [ __ ] [ __ ] Holy [ __ ] And map is just for mapping PCM to a buffer at the place where I assume that's true, right?

[01:36:23]I agree. I think that's what's happening, but it's like we have to prove it, right? We're trying to We are trying to understand the like entire audio pipeline, right?

[01:36:34]And so if we can't even find where he's mapping the audio data, like how are we supposed to know what is happening, right? And like here we're seeing that like as part of like opening, we're seeing like a nesting of like six different plugins here, right? So we're going from like Like I don't even know.

[01:37:01]I would love to write a more concise ALSA config so that we can like have less [ __ ] between us and the hardware, right? I think that this is where some of the confusion is coming from is that there is just so much stuff happening and I'm just trying to get like to the smallest thing so I can understand like at the very base level, what is it doing?

[01:37:34]Because like already here, like Like how do I say this?

[01:37:49]Uh like when we come down into the part where he does the M map, wherever the [ __ ] that is. I guess we should slap next level. I think we could like hit the we could uh break at 3:44.

[01:38:08]Like I you M map.

[01:38:13]Like you know what I mean? Like that's Where is this is like we're at so much like levels of indirection.

[01:38:20]You know what I mean?

[01:38:22]And I it's so hard to track down like what the hell is it?

[01:38:30]>> [laughter] >> Simply ALSA app is just set up the PCM format and you read I read I. That's it.

[01:38:35]BUT LIKE >> [laughter] >> IT'S BUT LIKE WHAT IS IT DOING? YOU KNOW? Like I understand. I understand, right? Obviously I can read I can read I can read this.

[01:38:49]Right? This is a simple function This is a simple program, right? But this is not what I'm I'm not trying to ask like how do I run a program that writes some noise? I'm trying to ask like what the [ __ ] is this doing?

[01:39:02]Right? Like I'm not sure if I CAN HAVE YOU TRIED PIPEWIRE. WE NEED TO BUILD OUR WAY UP THERE. We have to build our way up I like I'm so How do I say this?

[01:39:14]>> [laughter] >> I don't even understand what problem ALSA solves versus PipeWire versus JACK versus like I don't understand what any of things that these things are doing.

[01:39:29]Like why do I need all of this complexity for put pack put bytes in audio buffer? Right?

[01:39:40]I'm missing something and that's why I want to like look under the hood and see what it's doing. Cuz once we understand like what also provides and what these things are doing, then maybe we'll get a better feel for like why are we building PipeWire on top of these things? And like why like what is also what is PipeWire? And if like also has all these plugins and stuff, why don't I just write an also application instead of a PipeWire application? Like what is the difference between those two things? Why should I choose one over the other? Like I think that just understanding Cuz like how do I say it? LIKE THE CONCEPT IS SIMPLE, RIGHT? Take bytes, put on wire.

[01:40:21]But like there's a reason that all of these things are in the middle.

[01:40:25]And so I'm trying to understand that.

[01:40:27]And to understand that we have to understand what they're doing.

[01:40:30]And maybe there is like a much simpler way.

[01:40:35]But like I like doing it this way.

[01:40:41]>> [laughter] >> I don't know. We'll see.

[01:40:46]Um okay.

[01:40:49]Yeah, I think I think the easiest form the the the easiest thing to do here is like cut out all of the middle men.

[01:40:58]Right? So I wonder if there's like like also also conf simplest also conf.

[01:41:08]Like you know what I mean?

[01:41:11]Is there is there a thing that we can Can we take Ooh, is there a man page?

[01:41:23]M- maybe.

[01:41:25]This is not No, also conf is a is a program. Great.

[01:41:29]Great.

[01:41:35]Um Hmm.

[01:41:45]Hum hum hum hum hum hum.

[01:41:49]You need to figure out what PCM versus what ADC to DAC is. I mean, I know what those are, I think. Right? There's like some like sampling of waveforms. You've got to take the thing and turn it into analog, take the thing or sample from analog, turn it into Usually, you take the digital thing, turn it into analog.

[01:42:04]You know, there's like complex ways of doing that and simple ways of doing that, right? You can do your little like resistor ladders for ADC.

[01:42:13]Whatever, right? It's like I don't really care that much about that part.

[01:42:16]I'm like assuming that there's like a piece of hardware at the bottom where there's like a you know, somehow the bytes on them on the piece of hardware are getting onto the wire and I'm like just trusting that they do that part right.

[01:42:31]I'm more interested in like the mechanism for how the bytes get into that hardware buffer.

[01:42:40]Anyways.

[01:42:42]Uh yeah.

[01:42:44]Maybe this is an ask the idiot angle.

[01:42:47]Maybe it's an ask the idiot angle. Um can you help me write an ALSA conf file that will make lib a sound like skip all the layers of indirection and just talk directly to the hardware.

[01:43:15]Uh I mean, well, look, that's looking right. That's looking pretty That's looking pretty in in the order of things that we're looking at that we want, right?

[01:43:27]That looks That's looking pretty like I mean, it the it mirrors what we've been seeing a little bit.

[01:43:35]He's saying slap that [ __ ] in etc sound.com.

[01:43:41]Or I mean, what is it like we can also check the S trace for what this guy has been looking for?

[01:43:52]Um so can we look at like A sound? That is one of the first things he checks.

[01:43:59]So it's not crazy.

[01:44:02]Let's see how likely it is that he's right.

[01:44:11]Uh okay.

[01:44:15]Sample format not available for playback. Oh, okay.

[01:44:20]Okay.

[01:44:26]So probably we are there's a layer in here that is trying to make it so that we like resample our inputs into the format that he's expecting.

[01:44:41]That's what I would assume.

[01:44:47]Right? So probably here there is like a specific uh there's a specific format that the hardware itself supports.

[01:45:01]And PCM min, the the little test app that we're using is saying I want U8 interleaved.

[01:45:14]I presume, right? Is this in Can we look at the G the back trace here?

[01:45:22]Uh [ __ ] Like I assume that we're getting past open, right?

[01:45:31]So we're like B PCM in 20 run.

[01:45:37]Uh-huh, yep, okay, then we're trying to set parameters and somewhere in here he's going to be pissed off because it doesn't work. That makes sense.

[01:45:48]Uh, so what is the log receiving?

[01:45:51]Sample format.

[01:45:57]So we want to break point in here somewhere, right?

[01:46:04]What is it? Sound piece of hardware param set.

[01:46:11]Got it.

[01:46:13]Uh, and we're probably looking for hardware, nice.

[01:46:20]Maybe not.

[01:46:29]Can we look for like maybe white space followed by this thing?

[01:46:35]I guess it's in here.

[01:46:38]And then he calls this guy.

[01:46:45]And I guess var is the interesting piece.

[01:46:50]I'm not sure. Maybe we just break point there and then step in.

[01:46:54]4389 And is this the one? Yes, okay, run.

[01:47:07]Continue, step.

[01:47:10]Step.

[01:47:12]Go in.

[01:47:13]Uh Okay, understood, understood, we go again. Continue.

[01:47:26]So, we want to break at uh wherever the [ __ ] that was. PCM params.c675.

[01:47:34]Uh Okay, we're going into sound mask set refine.

[01:47:44]Wait.

[01:47:46]Sound mask refine set.

[01:47:52]Like, what the [ __ ] is happening here?

[01:47:56]He is looking All right, so he's returning E and val, which I believe is the return code we're getting.

[01:48:03]Um if this is not supported. Great. This is helpful.

[01:48:12]This is helpful.

[01:48:14]What the [ __ ] is a sound mask D? Okay, maybe this is the interesting piece here.

[01:48:20]Maybe right here.

[01:48:33]For a set Wait, is this not the one that's broken?

[01:48:39]Sample format not available. Okay, hold on. Hold on. Hold on. Hold on. Hold on.

[01:48:52]So, what goes in here?

[01:48:58]What goes in here? Sound PCM hardware param set.

[01:49:04]Oh my god.

[01:49:07]I forget already. It was in PCM params.c?

[01:49:15]Uh set format. Jesus Christ, my brain is like melting. Melting, melting, melting.

[01:49:21]What's the log? What's the log?

[01:49:26]Sample format not available for playback. Sample format not available for playback.

[01:49:33]Okay.

[01:49:35]Uh, actually that's not what it says.

[01:49:37]For It says playback in all caps.

[01:49:46]So, it's more of this one.

[01:49:48]So, we're in here. Okay. Thank you.

[01:49:50]Thank God. Thank God.

[01:49:54]Just you Okay, I I don't think I don't think it's unreasonable.

[01:49:59]Like I get that you're trying to help, but like I want to find the source of truth in the code. I don't want to just do random [ __ ] You know what I mean?

[01:50:10]So, if you're saying 48k PCM 16 will be supported, you're probably right. I believe you, but I'm not going to like just randomly try that because like if I want to know I want to practice the uh, the action of like finding a thing in like looking at the problem and chipping away at it until I find a solution, right? Like I just like calling a friend and saying, "Hey, what's the answer?" is not like finding the answer. You know what I mean?

[01:50:43]The goal is like not even to get the answer, right? The goal is to like do the process.

[01:50:50]>> [laughter] >> If that makes sense.

[01:50:53]Okay, so there is some We have some format that we are trying to set here.

[01:51:03]This is some handle to some like PCM device.

[01:51:09]And are these the parameters that the system like that the system has given us.

[01:51:18]Right? So, we have like params here.

[01:51:20]We are sampling the parameters here probably.

[01:51:27]Right? Can we look at params? That might be interesting.

[01:51:40]So, params here is probably like an array of things.

[01:51:46]What is this? Sound hot PCM hardware params t.

[01:51:52]What is this thing?

[01:52:05]Okay, that's interesting. Where does that come from?

[01:52:13]Why I see.

[01:52:23]Is this a struct here?

[01:52:27]Aha.

[01:52:28]Here we are.

[01:52:30]Jesus Christ, everything's so difficult, man. Everything's so freaking hard.

[01:52:36]Um so, masks is probably what we're looking at, right? I think we saw something with the masks in there.

[01:52:42]Here we are saying that we want to look at this format.

[01:52:51]Sound PCM hardware Well, let's see where this is getting called. Right, I think we saw something with the masks, but let's let's double-check.

[01:53:09]>> Um Yeah, yeah, yeah. Right. So, so we had a thing where he's looking at the mask for this thing where presumably there is a like list of formats where each bit in the format mask defines like one specified format. And the hardware like gives that thing to us and we don't like it, right? So, probably if we looked at like um How do I say this? We want to look at M who has M bits 40000, right? And then we can also look at the the the value that we were trying to set in pcmtest.c wherever the uh pcmmin.c, sorry.

[01:54:07]So, we're trying to set format U8.

[01:54:12]So, like this thing is probably defined somewhere.

[01:54:21]Right? And so, if we think that this is bit 0 1 2 3 4 that or sorry, we we see four which is bit two.

[01:54:33]So, signed 16 big Indian or signed 16 little Indian, right? 0 1 2. That lines up with the two to the power of two is four. So, presumably the hardware has set this thing somewhere. So, can we then update our test to use that.

[01:55:03]Right? so it's this one.

[01:55:09]And we would hope that we get further now.

[01:55:17]Channels count not available for playback, right? So so that's really huge for us. Really huge. Um we found like we were correct about that.

[01:55:29]We were we were correct about that.

[01:55:32]Um so now can we look for PCM in.

[01:55:38]So presumably we just have to pick this right set of actions here.

[01:55:44]Right?

[01:55:47]So uh Hello, here we go. So like presumably two channels, right? What is this? Sound PCM set params?

[01:56:02]Channels like two? Probably.

[01:56:08]Make PCM in PCM in.

[01:56:13]Let's [ __ ] go.

[01:56:14]Let's [ __ ] go.

[01:56:17]Um so he made it past initialization now and he's like I don't know how to [ __ ] write to that address. A a bad address.

[01:56:26]Uh where is that?

[01:56:30]So I wonder if um I wonder if how do I say this?

[01:56:49]I wonder if a if speaker test works.

[01:56:53]Right? Like maybe maybe this PCM in thing is like too stupid.

[01:56:59]No speak Okay, speaker test.

[01:57:05]Okay.

[01:57:06]So when I run speaker test, I am hearing stuff now, which is good. And I think that speaker test is using the stupid version of this thing. So if we S trace this again, uh can we like do we get like a more sane Oh, let's [ __ ] go, baby.

[01:57:31]Let's [ __ ] go. So now now we have an actual more sane version of this thing that we can work with. We have the stupidest thing, right? No more of this like HW sync spam, but now we're seeing like an actual I octal that just puts frames on the device, which is all I was looking for this entire time, right? The past [ __ ] 2 hours, this is all I wanted was to find the code path that made us do just a simple [ __ ] write to [ __ ] driver. Write to [ __ ] driver. So thank [ __ ] god. So now we can look for this I octal in the kernel.

[01:58:08]Am I in the kernel right now? Where am I? Yes.

[01:58:13]Uh like is this compat maybe, right?

[01:58:26][ __ ] [ __ ] it. Oh, it doesn't [ __ ] matter. As I said, use correct PCM format. I WAS NEVER SAYING YOU WERE WRONG.

[01:58:34]I DON'T THINK IT'S LIKE I DON'T THINK it's like, "Wow, good job. You were right." Like you Oh god, I'm going to lose my mind. I'm going to lose my mind.

[01:58:42]Like I think it's I thought you were right.

[01:58:47]NO, [laughter] LIKE WE DON'T HAVE TO DO a I told you so. We are trying again.

[01:58:51]The goal is to find the answer ourselves. Right? It's like playing a puzzle game and you're like, I [ __ ] told you to put the put the block over here. It's like It's not the point.

[01:59:03]IT'S NOT THE POINT.

[01:59:04]OKAY.

[01:59:05]Um can we GDB the kernel now?

[01:59:08]Maybe.

[01:59:10]Maybe.

[01:59:12]Um let's kill the VM.

[01:59:14]Let's kill the VM. And uh try to run it with our custom kernels that we can GDB it.

[01:59:26]Uh so, what do we have here? Uh display GTK probably. Does this thing have our {dash} S {dash} S I believe is like a please turn on GDB and wait for me to connect before you do anything.

[01:59:45]And then I think we call run with kernel.

[01:59:50]Uh where are my arguments here?

[01:59:54]Run with kernel. We have a kernel compiled over here somewhere.

[01:59:59]We have a initramfs and we have a disk image.

[02:00:04]Okay. So, if I go in here now and I say like GDB VM Linux and GDB Oh, [ __ ] me.

[02:00:11][ __ ] you.

[02:00:14][ __ ] you. I need you to be installed.

[02:00:20]And target localhost 1234 I believe. Target remote localhost 1234 maybe.

[02:00:32]Perfect. And now we're hoping to look for It's either going to be in PCM native or PCM octal, right? So, can we just breakpoint in both these places?

[02:00:48]Uh [ __ ] Right I frame. So, it's going to be one of these.

[02:01:04]Wait. I octal right I frames. Am I crazy?

[02:01:10]Oh, this is only 32 version. Okay, then it's this one probably.

[02:01:13]Okay, click continue.

[02:01:15]Oh, I think uh I [ __ ] up.

[02:01:19]I need to disable KVM for this to work.

[02:01:22]No hardware accelerated virtualization, please. Only the stupid version of virtualization so that I can uh breakpoint.

[02:01:35]Uh so, what's the other one? It was over here somewhere.

[02:01:41]Boom.

[02:01:42]Run. Continue.

[02:01:44]Target remote localhost 1234. Continue.

[02:01:47]There we go. This guy's running.

[02:01:49]Eventually, we can SSH into him probably.

[02:01:58]I don't like that it looks like nothing is happening.

[02:02:01]This is not how this was working yesterday.

[02:02:06]Oh, I see. We just have serial set up.

[02:02:09]Can I SSH in?

[02:02:12]Can I SSH?

[02:02:15]No.

[02:02:17]Oh, because uh probably networking is down because my kernel is broken.

[02:02:22]But, can I do this? Oh, let's [ __ ] go, baby. Let's [ __ ] go. Okay.

[02:02:28]So, now we can just kind of start poking and prodding and seeing where this goes.

[02:02:33]Perfect.

[02:02:38]Okay, so where do we think this should go?

[02:02:43]This goes into this I octal sound PCM lib right probably is what we're looking for, which is owned by this guy who does sound PCM lib transfer.

[02:03:04]Who up these?

[02:03:10]Probably here is where he's defined.

[02:03:13]Yep.

[02:03:14]Who then presumably gets into some driver somewhere, right? Like what the [ __ ] is all this stuff?

[02:03:22]Uh also, am I in the environment that has like everything uh how do I say this? Like clang and stuff? Like why am I struggling to jump to definition?

[02:03:39]Yeah, I don't know why it's not a LSP info?

[02:03:48]Do I not have clang in here?

[02:03:51]Oh my god, I don't.

[02:03:55]All right, hold on. We need We need a proper setup. We got to be able to jump to def, man. And then maybe I didn't generate this the clang script as well.

[02:04:03]Uh scripts clang gen compile commands. All right, let's try this again.

[02:04:09]And I think my thing expects the compile commands to be in build because of how I used to structure my C++ projects.

[02:04:19]Sound X lib PCM lib Xfer. Okay, does it work now?

[02:04:26]Kind of.

[02:04:29]Yeah, okay. Close, but un- unfortunate.

[02:04:33]Still got to grep like [ __ ] plebs.

[02:04:36]Okay, but here we go. We got a bunch of colors now and we can jump around.

[02:04:40]So, what is this guy doing?

[02:04:48]We probably actually want to break point in here.

[02:04:54]And just see where he looks like he's going.

[02:05:01]So, where does it look like he is going?

[02:05:10]Where's the part where he actually jumps into some V table of like a hardware implementation?

[02:05:21]Uh, this looked promising maybe? Error equals writer?

[02:05:29]Yeah, I suspect that function called writer was the one, huh?

[02:05:37]So, there's going to be one of interleave copy or non-interleave copy.

[02:05:41]Which one did we get?

[02:05:47]Unknown.

[02:05:48]Okay, but let's let's uh break point there and run again.

[02:06:00]Okay, so we step into this.

[02:06:03]Interleave copy.

[02:06:10]All right, what does this do? Do transfer.

[02:06:13]Do transfer.

[02:06:15]Holy [ __ ] Transfer takes in some PCM transfer function. Okay.

[02:06:22]Can we look for that?

[02:06:23]What is the transfer function?

[02:06:26]Default write copy.

[02:06:28]Okay.

[02:06:30]What does that do?

[02:06:32]Get DMA pointer? Ah.

[02:06:36]So he's interesting.

[02:06:39]So like we actually don't end up in any driver specific code here at all. Right?

[02:06:47]Like presumably we end up in this like transfer function?

[02:07:04]Uh [ __ ] I got I got hit by an interrupt and that [ __ ] everything up.

[02:07:10]>> [laughter] >> But like presumably we end up here.

[02:07:18]Oh, wait. Why?

[02:07:21]Maybe it's in line so it doesn't get a nice little thing.

[02:07:27]What does get DMA pointer do though?

[02:07:29]Can we break here maybe? Yep.

[02:07:36]Uh well doesn't seem to be doing what I thought it would.

[02:07:47]D O B R break here.

[02:07:55]Where is the part step into the transfer?

[02:08:01]Why does stepping into this cause like a hardware interrupt?

[02:08:07]Every time like reliably.

[02:08:15]You know what I mean? Like Yeah, interesting.

[02:08:22]That's confusing.

[02:08:23]So there's something something strange happening there.

[02:08:27]But I think it seems like based off what I'm seeing here that it just has this stuff like DMA mapped already. Do I have like a P upstream runtime and then what does like get DMA pointer even do? He just calls like DMA area, right?

[02:08:53]Yeah.

[02:08:55]Interesting.

[02:08:57]Interesting.

[02:08:59]So like presumably somewhere uh somewhere like on initialization we've like set up some sort of like DMA memory area.

[02:09:21]Like there's got to be some sort of like assignment here somewhere.

[02:09:29]Somewhere. DMA area is equal to this.

[02:09:38]Yeah, yeah. So like in hardware params they allocate some areas and presumably somehow this makes it into the driver for this specific audio device, probably.

[02:09:57]Do you ever use layout source in GDB?

[02:09:58]How does it help you debug things easier? I'm like too stupid.

[02:10:01]>> [laughter] >> I just do it the dumb way.

[02:10:03]I do everything the dumb way.

[02:10:05]Yeah, yeah, yeah. So here yeah, you like have some sound card associated with this thing and then presumably you allocate in here according to the card somehow.

[02:10:23]Yeah, like send DMA Alec der pages.

[02:10:29]Yeah, interesting.

[02:10:31]Interesting. Okay, but like from like the kernel perspective though?

[02:10:37]Like I think that I've kind of poked it enough to feel like I have like a basic understanding here, right?

[02:10:45]So like to play noise in like the simplest case, simplest case, you have some like hardware specific driver who does a bunch of stuff, but like one of the things he does is exposes a way to like get direct memory to the hardware, maybe.

[02:11:18]Unclear, right? Maybe it's I mean it wouldn't be called DMA if it wasn't to some sort of physical buffer, right? So we can probably imagine there's some sort of like PCI mapped buffer somewhere.

[02:11:30]Then there's like kind of like the dev sound stuff.

[02:11:35]And in here, one of the ways that you can communicate with this guy is you can you can feed data into this thing with like some write I command, right? Who doesn't do anything hardware specific. He doesn't talk to the hardware at all, really. He just like puts data in this memory map buffer.

[02:11:57]Right? Then on like the the user space side, you've got lib a sound who like configures some sort of like complex ALSA pipeline based off of whatever is in like a sound.conf and friends, right?

[02:12:18]He like creates some pipeline, but that pipeline will eventually So, you you on him you call like right I here as well, right?

[02:12:29]Who I guess is like functionally supposed to be like a one-to-one mapping of this, but then this goes through some like pipeline of [ __ ] right?

[02:12:41]And then eventually gets into the hardware.

[02:12:45]Who will call this is call.

[02:12:49]Right?

[02:12:50]And so, I guess you would pro I would I would imagine that some of these plugins are meant to like work around the fact that like not all hardware is the same, right? We saw things like D mix that sounds really familiar in terms as like a way to like mix different streams together in user space, right? So, it sounds we also saw something about like a a sound server, right? So, it sounds like the initial guess of like how this thing is laid out is not entirely wrong, right? There is some sort of like user space plugin system that can do who knows what. We don't know yet.

[02:13:34]There is a piece of hardware that has some memory mapped buffer that you can shove stuff into.

[02:13:42]We don't know yet if there are multiple buffers or if the hardware supports multiple streams. We're probably going to have to look at the also documentation to try to figure out like there's got to be some way to query information about this thing, right? We must be able to ask it, "Hey, do you support X XYZ? What sample formats do you support? What What like how many streams do you have?

[02:14:03]How many channels do you have?" I imagine that that's in there somewhere.

[02:14:09]Um we have absolutely no idea yet how these like higher level sound servers tie into this thing, right? And why they exist.

[02:14:18]Does also have some limitation that doesn't let that like that they need to build on top of? Maybe? Maybe like writing these things is all like writing all the features that they want to do as also plugins doesn't work? Who [ __ ] knows?

[02:14:31]Who [ __ ] knows, right? So we will come back and we will look more tomorrow or the next day. Not sure.

[02:14:42]Um there is a lot more to dig into here.

[02:14:45]But at the very least we have some model of like the lowest level here.

[02:14:52]There's a [laughter] lot more to learn.

[02:14:54]Um thanks for watching. If you like what you saw, this is a bit of an odd stream, but you know, we do stuff like this all the time. Some sort of like low level you know, investigation or writing of things, right? We we could have just said, I need sound, let's use insert sound library, but instead we do this and that's like a common theme here. So if you like that, uh swing back by. We stream many days. I think sometimes we say most days. Sometimes it feels like we're doing like every other day right now, but we see we stream some amount of days consistently um at around 12:30 Pacific time to 4:00 you know, 3:00 or 4:00 Pacific time. It's around 3:00 now. So if you're watching live, you know, 2 and 1/2 hours ago to now or to like an hour from now is when you just got to see this. There's a YouTube where this will go up. If you're watching on YouTube, there's a Twitch, and then there's a Patreon, YouTube member, and Twitch. If you sub in any of those places, there are some more VODs that don't necessarily make it here.

[02:15:49]We're working on this like long-term project of a SIP or VoIP client. Um so some of the like clean up and testing and stuff is going up like that you know, some of that's going up there uh right now.

[02:16:02]I think that's it. YouTube, peace out.

[02:16:05]Twitch let's find someone to raid.