this audio interface is actually kinda nice

Added: 2026-05-13

[00:00:00]Yo yo yo. What's up? What's up? What's up everybody? Welcome back. Uh today we are on day two of trying to work with Pipewire to do audio output on Linux. Um so the context here is I moved around a month ago. My doorbell calls my cell phone. Uh I went for a jog and ate [ __ ] on the concrete. And you know my my my phone also wanted to know what the concrete tastes like, right? which means that the screen shatters, it doesn't turn on. Uhoh, I can't answer my door anymore. That pisses me off, right? I don't think that my life should be tied to this like losable, breakable little thing that I carry with me all the time.

[00:00:41]I just don't like it, right? And so I want my doorbell to call my door or my computer, you know, like a normal human being. A normal human being answers the door by clicking a button on the computer, right?

[00:00:54]Um, and so to facilitate this, we are writing our own voice over IP soft phone. Um, because I think they all suck and I also want one for other purposes anyways. And also, it's funny. Okay, it's just funny to do this. Um, and one of the things that you need to do if you are putting a phone inside your computer is you need to be able to send and receive audio, right? You need to be able to hear what the person is saying to you and say things back to them. Um, and so that enter this project, right?

[00:01:20]Um, Linux audio is like kind of funky.

[00:01:24]We're going to skim the details really quick, but it's basically like there's a driver. The driver um has an exclusive interface, right? So like one person can do sound output to each device. You know, my computer might have many devices. When I like plug in my headphones to the front of the computer, it's going to want to switch from using the speakers to the front port, which means that like those are two maybe different devices, but like in my head, they all act as like one sound output thing, right? So what they'll you what what Linux distros will typically do is they will throw a like sound server on top of the driver interface. Um that that sound server has changed many times in the like 20 years I've used Linux. I think when I first started it was using something called like ESD um and then it switched to Pipewire and now I'm using Pulse Audio. All of these have like backwards compatible interfaces in some way. Um but in my mind I'm like okay if my computer is running pipe wire I should try to talk to pipewire. There are other ways of doing this but let's say let's just see how hard is it talk to pipe wire. The other benefit of us making like a pipewire library is that um for the Wayland compositor that we are also working on um we need to be able to do video streams which like OBS the way OBS is getting this stuff is um also through pipe wire. So writing a little pipewire abstraction is like not the end of the world. Um, so last stream we were looking at this pipewire audio source playback example. Um, we wasted a whole bunch of time on like dynamic library loading because my argument here is that um, I don't want to like link pipewire because other people's Linux machines might not be running pipewire and obviously nobody else is going to run this program, but my own Linux machine might also in the future not run pipewire, right? So like the ability to detect at runtime which sound server is available and like fail gracefully in the case where pipe wire isn't installed but you have als you know like that seems like a reasonable goal. So we wasted a bunch of time on like dynamic library loading. Um and we got to the point where uh we can get into the audio loop.

[00:03:42]Right? So here he's calling some callback to fill some audio buffer. Um but we never populated that audio buffer with anything. Um, and so the goal for today is to like finish going through this example and then try to maybe migrate there's so there's actually a version of this thing that runs within like our event loop which is nice. So like try to migrate to that then maybe we try to find some sort of sane playback stream interface. I don't know what that is yet. Um, but we'll see. Um, so the example seems to say uh initialize me some main loop. This is an audio thing and you know it's music.

[00:04:18]Maybe we change this name later, but we're doing some sort of audio playback.

[00:04:22]Um, we create some plain old data for some reason. I don't really know what this does yet. Uh, but somewhere we say, hey, I would like to have two channel floatingoint output at 44K.

[00:04:34]Um, then I don't know what this does, but we're like creating some params structure here. What is does this get used here? Here we say I don't know. I don't know what this does yet, but here we're saying like make me a stream of audio. And here is some flags associated with that thing.

[00:04:52]And then run. And then on run, it calls this function. And this function is supposed to fill the thing with audio.

[00:05:02]And so step one is fill the thing with audio.

[00:05:06]So let's do some sort of sine wave. And what do they do in their example? Um, they say, "Sir, please give me an audio buffer."

[00:05:17]They say, "Hey, what the [ __ ] is is there a buffer here?

[00:05:24]I don't Okay, we're going to have to take a look at this, but okay. So, let let's start with just implementing this part. We're like, sir, I would like one of your buffers, please."

[00:05:33]So this is like a con b is uh okay we need to like get our user data as our whatever the [ __ ] we call it. We have a data. User data is now called data. What a bad name for this. Uh but we need to pointer cast the user data that they give us as a void pointer back to the thing that we have down here that we've made that we've said please when you call this function give it to me like this [ __ ] Here we I guess at this point it's fine. I mean you storing the like dynamic library link in here is like a little silly but it's not the end of the world. And in here we're going to want this pw stream dqbuffer but this is not a thing that we've generated a binding for yet.

[00:06:19]Uh but we can just copy paste this name into this file and then we will have it.

[00:06:29]Uh so we call this this guy is just data stream like this and then we say uh const B is what they want.

[00:06:44]We don't know what this means yet. If B is null return and maybe we should log but [ __ ] them.

[00:06:56]And we need to align this thing as well.

[00:06:59]Classic.

[00:07:01]Classic.

[00:07:03]He's like, "This thing doesn't exist."

[00:07:05]But I put it in there.

[00:07:14]Did I not?

[00:07:17]Did we [ __ ] this thing up in some way?

[00:07:24]Did I forget to save Huh? We've got some sort of cash problem here cuz I bet you if I rebuild that thing will show up.

[00:07:42]Yeah. Okay. We we we added we have a bug in here somewhere. He's not correctly noticing when the input Oh, because this thing needs to be add uh input file input that comes from B path.

[00:07:57]function list otherwise he doesn't know uh he doesn't know to track that file and watch for modifications. Oops.

[00:08:11]Uh actually maybe add file arg add file arg that's what I was looking for.

[00:08:23]Does that work? There we go.

[00:08:26]Cool. We're so [ __ ] back.

[00:08:31]All right, cool. So, we have a buffer and then can we look at like what the [ __ ] this thing is?

[00:08:42]Uh, strruct pw buffer. So he's got a buffer.

[00:08:55]He's got some user data.

[00:08:58]He's got some size.

[00:09:06]Buffer is one of these and he has many datas and many metadatas.

[00:09:17]Okay. What is our data size?

[00:09:30]Uh, why is this not all completing?

[00:09:36]That's a little annoying.

[00:09:38]That's a little annoying. But we can specify the type here to help it out a little bit.

[00:09:48]It's like something like this, right?

[00:09:57]Uh I guess here that means that we can do or else return like this and then we have this thing.

[00:10:08]Cool.

[00:10:13]And then uh buff Whoa, I'm lost again.

[00:10:26]DQ buffer return. Right. So, we look at this buffer.

[00:10:33]Can we do a little like dot question mark on this? Yes. Then maybe not. Okay.

[00:10:39]Then we want to look at end datas.

[00:10:41]That's what we were trying to do.

[00:10:52]Uh, oopsies.

[00:11:00]Why is this only getting called once?

[00:11:02]Oh, because we dqed the buffer. So, he is only getting called once because we actually have to send the thing back out now. So, let's do that as well.

[00:11:23]PW stream cube buffer which we need to get the uh okay I don't know we'll figure it out and he wants the data stream and the buffer.

[00:11:48]Okay, nice.

[00:11:53]Okay, so he is check he's null checking the buffer data.

[00:12:03]So if buffer data uh data I think we can check if buffer end datas is equal to zero is less than one maybe we we give up and then we say like now we can look at data zero.

[00:12:26]Okay. And how do we know the length of the data?

[00:12:32]This thing is a strruct spa data which has what a max size of data like what max size over stride.

[00:12:46]Oh sure. So this is the stride of one sample. So this is the size of the the buffer in bytes and then this is the number of frames that we can push in which he may have requested some amount of frames as well. What is that be requested?

[00:13:09]Okay, can we look at the documentation for that? Because I want to know what this means for playback streams. this field the suggested amount of data provide. This will be the amount of frames required by the resampler. This is only suggested though. So he might be asking for something that's basically less than the amount of data we can fill in maybe to prevent like over buffering, right? You kind of want like the data to come in now. So I guess that makes sense.

[00:13:36]Uh so we can kind of say uh like data available frames is data.

[00:13:49]Can we convert this into a slice? I think we can right out like data buffer. We need to find better names for all these things but it's fine. We have data dot.

[00:14:03]Wait, am I high?

[00:14:05]Oh, we've used data twice. Damn it. BD BD dot max size.

[00:14:16]So, this is going to be um [ __ ] So we kind of want to like look at the data from zero to this, right? This we've turned this thing into a slice now out slice bytes and then we want this to be like as a slice of floats, right? So we're going to like do out slice bytes and do like a stood mam slice bytes as slice of f32 because we're asking for floatingoint samples. Seems reasonable.

[00:14:56]And then we're going to say uh requested is uh I'm just going to I know this like I think that first time chat being like speak in a different language is just instabban, right? That's instab.

[00:15:13]Uh so we'll say frames like fill frames I guess is going to be This should be a F32. I don't know why he doesn't like this over number of samples. Do we is number of is like number of channels hardcoded?

[00:15:38]What do they do?

[00:15:40]Yeah, they do. Uh over channels.

[00:15:47]So, we'll kind of do that as well. We'll say we have two and then somewhere we use this below. So we'll say here num channels and then I guess we just kind of put some sine wave in there, right?

[00:16:08]Uh, so I guess we do uh four zero to fill frames, we generate more of a sine wave, right? And put that into the outs slice. So we want to look at like out slice um I times dumb channels. So probably like 4 0 to num channels. We want to put this sine wave in there and we kind of want to do this is equal to sample.

[00:16:56]Right? And so here we just need the data to put in here now. Right? And is that it?

[00:17:05]Oh, let's see. In Phil 32, they just put they just put data into this pointer, which or a pointer is the data pointer. So, I think that's what we've done. And then they populate this stuff.

[00:17:29]So for us this is uh BD oopsies and what are they doing here?

[00:17:47]So I guess this datas thing it's got data but then like chunks will point into this data I guess so this is like hey in this data where is this stuff right so we're saying hey I don't know why it's like that I would like to look at the documentation of chunk here valid chunk of memory but like What a confusing API. I don't really understand why, but I mean, we'll trust them, but like it I don't I don't It doesn't This isn't like a I don't know why you would ever want like multiple chunks here or something, but that's okay. Okay. sample is going to be some sign related to our accumulator, right? And so if we want to do like 440 htz and we are sample rate uh so like wave 440 htz wave sampled at four what is it 44 441,000 uh 4 44,000 44.1,000 right so I guess that means uh I don't No, I don't know.

[00:19:46]We'll draw to right. We're sampling at each of these points.

[00:19:57]So we need to convert the sample index into a point on this timeline and then call call sign on it. Right?

[00:20:13]So the natural period of a sine wave in radians is 2 pi.

[00:20:19]So we need 2 pi to happen every four 2 pi.

[00:20:26]We want this to be equal to 1 over 440 of a second which is the same as how many samples?

[00:20:37]Yeah. Yeah. So you have like some samples n samples when you want n samples to be 2 pi.

[00:20:47]So you do sample index times we do our like grade 12 chemistry stoeometry. So we have uh idx is in sample times 2 pi over uh what we called n here n samples.

[00:21:15]So this converts to radians. But then we we need n samples here which is uh however many samples fits into one 440th of a second which has got to be something along the lines of like 44 1 0 0 over 440, right?

[00:21:35]It's some linear division. And we want something that's big, right? We want a number bigger than one. So it's got to be this way.

[00:21:47]samples per 440.

[00:21:52]Num is sample rate over 440.

[00:22:03]Um this might not divide nicely.

[00:22:07]So this is a floatingoint number probably, right? And so how do we how do we handle that?

[00:22:18]I guess we are okay with just not being 440 htz.

[00:22:22]Just output the wrong frequency.

[00:22:26]Oh, sorry. You're saying if we do the wrong calculation. Yeah. Yeah. It'll be fine because if you do something too high or too low, it just like won't do it. You know what I mean? It'll be fine.

[00:22:36]Um, we'll just say ish, you want floats for sign, just use floats. Uh, that's a good point.

[00:22:50]That's a good point.

[00:22:54]Um, okay. So then act, this is going to represent the frame index.

[00:23:05]Um, so we're going to do like data act plus equals i over sample rate, right? So this is like the index of a sample.

[00:23:24]Yeah, that makes sense, I think.

[00:23:29]Um, yeah, I think that makes sense.

[00:23:35]Uh but then this thing has to be so we have act times 2 pi over samples per 440.

[00:23:58]That's what we wrote down.

[00:24:04]And then this is wrong. This should just be one over sample rate.

[00:24:14]Yeah. And then maybe this kind of works.

[00:24:18]What is our stride here?

[00:24:20]Two times size like numbum channels times size of float.

[00:24:29]This seems like kind of like it might work.

[00:24:35]This seems like it could work.

[00:24:44]Uh this thing we want to cast. Oh, we have a out slice U8 pointer is a pointer to U8 which is an int cast of BD data.

[00:24:59]But like why are we doing this when we could just take this as a float pointer which means here oh because max size is in bytes but that's fine. So then we can do uh we can do out slice pointer out slices out slice pointer uh zero to fill frames times no channels.

[00:25:42]Yeah, that seems right.

[00:25:47]That seems it right is Oh, outs slice len is not there. [ __ ] So outs slice len was going to be uh data bd max size over size of f32 something like that which is like now just the same thing as that's fine.

[00:26:25]which yeah, which is just the same thing as stride. So then we do divide by stride here, which is what they end up doing. Okay, what's matter now? Comp time float and comp time int nonzero remainder one uh Do we just need to convert this to a float?

[00:26:58]Yes. Okay.

[00:27:02]Thank you, Dr. Zule, for the sinewave picture.

[00:27:08]Okay. I don't hear [ __ ] I don't hear [ __ ] Can we print I mean, that does look relatively sine wavy.

[00:27:44]Um, I guess it's possible that it's like out of range.

[00:27:50]Okay, let's stop printing for a second.

[00:27:54]And I want to see if like does my sound bar even know this thing exists.

[00:28:08]It does think it's playing audio.

[00:28:11]You guys can't see it behind my camera, huh?

[00:28:16]But like, it does think something's happening here.

[00:28:22]You know what I mean? It's just I'm not hearing it.

[00:28:25]So, not sure what's going on there.

[00:28:30]Uh, maybe we are doing the math wrong.

[00:28:34]Maybe we are doing the math wrong.

[00:28:37]Too low frequency. Yeah. Or too high.

[00:28:40]Um, do I do like have I [ __ ] this up?

[00:28:49]So this guy uh let's say that we're like this buffer or this we are asking for this many frames and this is fill frames.

[00:29:11]And then uh can we do something like write down uh we'll say we we'll say like con start was data act and then we'll say advanced this many cycles or samples, I guess we'll say.

[00:29:53]And that's a bug, right?

[00:29:58]Yeah. This should just be plus one.

[00:30:05]Yep.

[00:30:06]Yep. the I [ __ ] up. I was accounting for the like sample rate multiple times.

[00:30:12]Okay, so that made a noise, but I don't know if you guys can hear it.

[00:30:16]It's quite loud. Just full warning.

[00:30:20]Let's actually uh before I send it to you guys, let's divide this by uh divide by two.

[00:30:30]Okay, which of these many things in this graph is making this noise?

[00:30:44]It's playing into my speakers, so I should be able to find it.

[00:30:48]Where are my speakers?

[00:30:53]Here.

[00:30:56]There you go. Take that, [ __ ] But it's working. It's working.

[00:31:11]All right. Audio playback working fine.

[00:31:14]Yep. That's 440. Sure is.

[00:31:19]Morse code pitch. Yeah, dude. That's some Morse code [ __ ] if I've ever heard it.

[00:31:24]Um, all right. So, now the question is is how do we like hook this up to like our application?

[00:31:34]Right. We've kind of been working off like a pipe wire main loop, but like we like to do singlethreaded [ __ ] because we're too stupid to use threads and we like to use like an event loop and last stream we thought that wasn't possible but googling off stream I found it and then a YouTube comment also found it. There is this thing called like pw. There's some sort of like get file descriptor.

[00:32:03]Get fd or something. PW pipewire pd or something.

[00:32:12]Uh maybe it's in here.

[00:32:17]Spa get fd. Uh I feel like it was like called like pw loop or something.

[00:32:30]I feel like there was pwl loop iterate and pwl loop getfd. This is the one. So there's an example here in g main where they're hooking up pipe wire to the a gibb event loop. We're not a gibb event loop, but we are an event loop. Is ft short for it's for file descriptor. File descriptor.

[00:32:51]So here instead of running the PW main loop um can you do main threaded audio without thread being unstable? Never tried. I don't know. But if not, we can do the same thing. But like I just want it to be we can like stick a second event loop in a second thread. There's no reason we can't do that. But I just don't like the idea of forcing that them forcing us to use their event loop, you know?

[00:33:16]Um so how do we make one of these loops?

[00:33:19]So what are we doing right now? First of all, let's do a little get status get add-it commit-m smile.

[00:33:26]Uh, we are calling pwm main loop new and which is giving us a main loop, right? Probably we don't want that. We want a pw loop instead. So, I think that we can just call pw loop new instead.

[00:33:44]We'll see.

[00:33:51]Uh, PW loop new. And this guy's going to be like, "Sir, I would like a PW loop, please."

[00:34:02]And we need to restart the LSP because he doesn't know about that thing.

[00:34:09]And that's not even good enough. So, we need to full quit. Everyone who says type LSP restart every time I do this, you're wrong.

[00:34:19]Um okay.

[00:34:22]So now we just have a loop directly I think and then instead of doing pwm main loop run we should say I have my own event loop sir var loop is stud io loop please uh chain which needs to the ability to chain events needs to stash those events somewhere. So we do chain buff is 100 U size. It doesn't really matter. We're not using this yet, but we might later. And we want to register with that event loop.

[00:34:57]Hello. Oh, we can write try probably. We want to register with our event loop.

[00:35:02]This thing. So we say try loop register handle is a probably how are the get fd or something, right?

[00:35:19]Um, PW loop get update this thing.

[00:35:34]Um, so DB.PW loop get FD with our loop.

[00:35:42]Uh, we want to probably pull. Do we want to pull on read or write? Can we look at the API docs for this thing?

[00:35:49]Cool. Sick API docs. Do you guys think we pull on read or write? Probably read, right?

[00:35:57]And probably not on write. That would be my guess.

[00:36:03]This is my guess for what they want.

[00:36:07]Okay. And then can we do a while true cone event is our event loop uh poll forever.

[00:36:24]Uh if uh I guess or else continue here we're expecting to get this event and this event only. So we're going to assert event is zero.

[00:36:36]And then what do they do in the example uh they attach it to the pipe the uh their gibb event loop in a callback which is this thing dwl loop iterate and then that's it. So, we kind of just do this.

[00:37:14]Uh, but they said something about down here about having to enter and leave when you enter the event loop. It looks kind of like this only has to be called one time. So it looks like we can do like PW loop enter here and defer loop leave here at like the very top level. That's how cuz this main loop runs forever, right?

[00:37:38]So it sounds like you can kind of do this and then maybe that's it.

[00:37:47]It seems kind of like that's it.

[00:37:50]Uh, we do need to have PW loop enter and leave.

[00:38:03]Just ignore this for now.

[00:38:05]Holy [ __ ] it works. Holy [ __ ] [ __ ] That's so much better. I wish this was how their default example worked because that's so much [ __ ] better, man.

[00:38:15]That's so much better because now we have like complete control, right? So now if we wanted to do something like also on the same thread every once in a while print the word hello once a second or even just print the state of the accumulator in data we can do that right so we can say give me a vio timer service uh looks like he wants a general purpose allocator uh looks like we don't have one huh Uh, stood he s allocator for now. We'll figure this out later.

[00:38:56]We'll figure this out later. He wants some sort of GPA. Is that a bug? Why does he want a GPA using ST priority Q? I see he's got our event loop and he's got a service ID. So here we'll say one. We are going to switch on the event. If we get zero, it's time to do this thing because we said that's zero. And if we see one, it's time to handle our timer.

[00:39:32]And we can say um timer let's add a thing that happens um in 1 second and that thing is going to be call back ID2. We usually give these things names but that's okay.

[00:39:56]And so like ID2 is the part that does the logging every time our timer expires.

[00:40:04]Hello. So we say like hello and then we reue this thing.

[00:40:10]So the timer fires and then we re we reue it.

[00:40:17]Can I I think I have to remove and readit which is funny. This is a bad API.

[00:40:28]Yeah, this seems kind of like a bug.

[00:40:33]We should have like a rearm function on this thing, but that's okay.

[00:40:41]That's fine for now. This is just an example.

[00:40:53]Uh that's okay. This is just an example.

[00:41:15]Okay. So now We see on the same thread, hello printed once a second while the audio is going.

[00:41:23]So that's pretty sick.

[00:41:26]Pretty sick. Maybe add a timer type one choppers repeat. Yeah, there's some there's some bug. I I think rearm is fine cuz like really it should be the responsibility of like if the timer fired somebody like asked like somebody has to handle that. So, I think it's fine for them to have to choose whether or not they rearm the timer, but like just having to like reallocate a handle is silly, but that's fine. Doesn't really matter. Doesn't really matter.

[00:41:56]So, that's pretty straightforward. And now that means that we can start doing whatever the [ __ ] we want without worrying about like mutexes or anything, right? So what we want to do is we want to find some API that like hides everything that we have here somewhere else, right? So like I guess the question is like how are we going to use this thing, right? In the context of like an RTP stream, which is what we're going to be doing for our telephone, right? We are going to have some sort of like UDP listener, right? who is going to be getting packets from RTP from from somewhere else, right? From someone else. Every once in a while he's going to get a packet and presumably he wants to like feed those packets into a buffer.

[00:42:49]On the other side of things, we have every at some interval who knows what this like pwl loop iterate is going to call this call back and ask for data, right? So somewhere else, oh my god, can we do like somewhere else? We have uh pwitter.

[00:43:17]So he is going to be like pulling data from the wherever this puts it, right? I guess.

[00:43:24]So this could be some sort of like in terms of like API ideally we have some sort of like pipewire service over here who like basically hides all of this stuff and in maybe we as the RDP service he like asks him for like a stream and so he gets like a handle doggy. Oh, there she goes.

[00:44:04]Um, yep. So this guy holds like a stream and when UDP stuff happens and he gives him some data, he like uses this handle to fill a buffer somewhere and then the on the like on process callback on process will like pull data from here, Right.

[00:44:40]Okay.

[00:44:42]So, what about our case where we're generating like a sine wave sign?

[00:44:49]I guess here somewhere we're going to have some sort of like fixed length buffer where we're willing to generate into the future if we want to fulfill the same interface. So, we can say like we'll generate like you know 300 milliseconds of buffer, right?

[00:45:06]So like this like on process I guess we'll like consume some amount of this buffer and then he will either he says hey I consumed some data so you can fill more or we like fire this on a timer like Because like in the in the RDP case in the RDB case, the the addition of data to the stream is completely external, right? It has nothing to do with the pipe surf. The pipe surface just pulls it if it's available.

[00:45:50]So like for in in the case where we're generating and filling like you kind of want him to say back to him and say like, "Hey bud, there's data available."

[00:45:59]But like in reality in the real world doing it like the the trigger is external.

[00:46:09]So I think that having a callback API in here is just like over complicating it.

[00:46:14]I think that for our purposes we can just do this. We can like refill the buffer on a timer as long as the timer is like small enough that the buffer won't run out.

[00:46:27]Right? So, if we buffer like 400 milliseconds of audio and fire the fire the timer every 10 milliseconds, like what are the chances that we run out?

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

[00:46:38]Let's try that. And if it feels like [ __ ] it feels like [ __ ] Yeah.

[00:46:46]So, maybe it's like PW service.

[00:46:55]key needs to hold all of the stuff that lives in main right now. This data structure is like completely application specific. So I think we like mostly ignore that for now.

[00:47:10]This guy is going to hold the dynamic loaded libraries for these things.

[00:47:21]He's going to hold the event loop.

[00:47:33]Is it a pointer or what?

[00:47:36]Yeah, it's a player.

[00:47:39]He's going to hold this thing.

[00:47:52]And I guess the the streams he might have like many streams, right?

[00:48:02]But maybe maybe the stream is owned by the person who calls into him to like ask for a new one. So maybe he doesn't have to hold that.

[00:48:15]Okay, then we'll just start like writing stuff, I guess, and see what happens.

[00:48:19]Just like push some of this in here.

[00:48:30]Uh, I guess he also has like P PW lib, which is a stood dime lib and spa lib.

[00:48:42]Boom.

[00:48:49]Boom.

[00:48:54]Boom.

[00:49:07]Okay, cool.

[00:49:12]We initialize pipe wire for sure.

[00:49:19]We create the loop.

[00:49:27]We probably have to there's probably some like error defer pwd in it.

[00:49:36]There's probably some all like equivalent here.

[00:49:40]Uh there's probably some clean up here as well.

[00:49:48]Then what is going on with this properties?

[00:49:52]This properties thing is like a specific stream, right? So this stuff comes later, right? We're going to have some sort of like well let's let's finish this function first.

[00:50:02]Loop is loop just take all these things copy paste them.

[00:50:10]Uh put a dot find the colon put equals paste co change. Boom boom boom. All right.

[00:50:19]Uh okay, easy. So then we have like make like make stream make audio stream new like new audio stream returns a audio stream.

[00:50:44]I don't know. We're we're spitballing.

[00:50:46]We're spitballing.

[00:50:50]For now, we will assume that we have like a hard-coded sample rate and number of channels and stuff because I don't want to deal with that. But it looks like this guy is going to hold one of these.

[00:51:06]Okay.

[00:51:07]And he is going to be like, "Hit me with that shit." Surely.

[00:51:15]I don't know.

[00:51:19]Okay. Uh, we need our event loop or our hype wire loop in here and we need some properties.

[00:51:30]Do these properties have to be freed?

[00:51:34]How do they do it in their example?

[00:51:37]In their example, when can we get rid of those properties?

[00:51:54]I don't see any freeing of this thing, but like surely, right?

[00:52:02]Like surely maybe they get owned by the stream and so the stream deinitializes them automatically.

[00:52:13]Seems like it, right? Can we look at the documentation here for props? Ownership is taken. Yeah. So, we don't have to worry about that unless this fails. So, like uh fix me if pw stream new fails can it? We need to free props.

[00:52:34]Do we?

[00:52:37]It can fail. So like this does not say what happens if this returns null, right? If this returns null, I would hope that it frees events. But like we should just say say uh if stream returns null, does props get freed?

[00:53:02]I hope so. Smile. Okay.

[00:53:07]Uh data data data data data that's got a pro I assume that that data is going to be like us.

[00:53:18]It's got to be like we said that we were going to push data into some buffer somewhere, right?

[00:53:27]So the data here is ideally that like buffer, you know what I mean?

[00:53:37]Which means that like we want this at the very least to have a stable address. So we could maybe do like an object pool here of stream buffer. I'm spitballing. We're we're feeling it out, right? And then this guy can have like uh stream buffer index or something. I don't know. We'll see.

[00:54:06]You want the answer for the pipe? Yeah, I'll figure it out later. Why not doing the fix me now? Because I'm trying to figure out other stuff first. Like, how do I say this? I I like to work like um you know how like sculptors or like artists work where you do like blocking first, right? You start with like a big rock and you're trying to turn it into a person, right? You don't like do the guy's nostrils and like facial hair right away, right? you kind of like get the rough shape of his head and then get like the rough shape of his body and then like once you have like the rough shape you kind of like go into more detail in each point. I find that for myself working that way in code is easier. Right? Once I find the shape of the of the thing, then I can go into the details. Like now that I know the shape, this part goes here. This part goes here. But like until I have the overall shape, focusing on stuff like this is like kind of a waste of time because I don't I don't know if it's going to live here. You know what I mean? Until I know the shape, there's no point. So that that's kind of that's how I work. So, it's just I put a note here so I don't forget, but like it's important to like take a look at this at some point.

[00:55:18]Um, cuz like this is going to require some research, you know what I mean? And I just don't want to do that right now.

[00:55:26]Um, so the data for this thing ideally we have like um I don't know yet.

[00:55:39]This might be inline.

[00:55:44]I don't know like how many samples is reasonable here. Should this be dynamically allocated? I don't know.

[00:55:56]So, for now, I pro I mean it it probably should be.

[00:56:03]I It probably should be.

[00:56:06]Maybe this guy takes the buffer in.

[00:56:10]Maybe the buffer is owned by whoever creates this thing. And so then this guy can just hold the buff and then he can have like his like re his uh like read index and write index.

[00:56:31]And this is just turning into a circular buffer which we already have a type for.

[00:56:42]Nice.

[00:56:44]Nice. Nice. Nice. Nice. Nice. Okay.

[00:56:48]So, does that mean does he even have to hold this now? Yes, we need cuz we need to hold the read and write pointer somewhere. Can I tell you about the pipe wire API? Sure. If you have the answer, sure, I'll take it. Although I'm going to want to double check myself later.

[00:57:04]Uh, okay. So, we're gonna have like stream buffer is allocate like acquire this thing which we're going to need some sort of allocation for.

[00:57:25]Uh, okay.

[00:57:29]And then this thing gives me. So here we can just do like SB val here and then I think that's fine, right? So then we can just return SB index is something and stream is stream.

[00:58:06]That seems fine.

[00:58:11]Uh if you create a stream, you can ask for it to allocate extra bytes that you use. So if you need to hold a pointer to some stream then a pointer some user data you can hold the stream pointer and use the extra data me owned by the pipe bar for client use.

[00:58:24]Uh oh I thought you were trying to tell me if the stream I thought you were just telling me telling me if props gets freed.

[00:58:30]Um oh you saying that allocations can fail and that's why return null.

[00:58:37]Ah whatever. Ah I don't care.

[00:58:43]We'll figure it out.

[00:58:45]Uh okay, we need to initialize this thing.

[00:58:54]So items is the buffer.

[00:58:56]Head is zero, tail is zero.

[00:59:00]Okay, cool cool cool cool cool cool cool cool.

[00:59:08]So now our on process we need like on process two and we'll say stream events two calls on process two or something while we sort all of this out.

[00:59:31]So on process two literally just has one of these. Let's do let's do a proper like stream buffer is this.

[00:59:42]He's just a circular buffer of floats.

[00:59:48]Okay. And this guy is going to do something very similar to this but except he's literally just going to pull from the buffer. Right. So instead of doing some generation here he is fill frames is now limited by three things. Right? There is the amount of data in the buffer we have. There is the amount of data available for writing and then there's the like number of requested frames. It's like a triple triple min instead of a double min now.

[01:00:18]Um the data that cames into the stream buffer.

[01:00:22]Boom. Okay. Uh oh.

[01:00:27]Problem problem.

[01:00:33]This data needs to be able to call gen like pipewire functions. Is there anything else that he was using data for the accumulator which we don't care about?

[01:00:47]Okay, here's what we're going to do.

[01:00:50]Here is what we're going to do.

[01:00:53]These are globals.

[01:00:54]Suck a [ __ ] Suck a [ __ ] These are globals.

[01:01:10]And you'll somebody says, "Excuse me, sir, you can't write globals." And I tell you, shove it up your [ __ ] I can do what I want.

[01:01:20]You'll revert within 30 minutes. Ah!

[01:01:26]Ah!

[01:01:30]You can't stop me.

[01:01:34]You can't stop me.

[01:01:42]Okay, I guess it makes sense for these to these to be nullable and then we can kind of use that as a flag, right? If pwl lib is null, then we open this thing. We just never close it and then we initialize the global this thing.

[01:02:08]Don't stop me now. I'm having such a good time having a fall. Yeah. Yeah. We You can't stop. No stopping me.

[01:02:16]This feels fine.

[01:02:18]This feels fine. If it's not fine, then like you know, get [ __ ] me later. But ah then there now this guy can just use the dynamic thing here.

[01:02:44]And then he doesn't need any extra information. No. Great.

[01:02:48]Oh, he needs a stream ID.

[01:02:53]Okay. Well, then that means uh that this thing here needs to be an audio stream, not a stream buffer, which is fine. This is now going to return a audio stream handle.

[01:03:21]uh just so that we don't forget.

[01:03:25]And this thing now holds the stream buffer directly.

[01:03:33]Yep.

[01:03:37]Ass.

[01:03:47]Yep.

[01:03:49]I guess we can just do this after, right? We make the stream uh fix me error defer close on acquire. I don't know how to do that yet.

[01:04:03]Okay.

[01:04:05]Oh no, we how [ __ ] backwards.

[01:04:09]You need to get the pointer to the thing to add it to the stream. You need to get the pointer to itself in to do this.

[01:04:16]That's funny.

[01:04:21]Uh, so here there's a fix me. I guess this aner self pool release handle.

[01:04:35]Um, props doesn't need to be freed because if the stream is no, it means that it was never created. But here we called properties new, which I assume is some sort of dynamic allocation. I could be wrong there. So, I would imagine that there's like some sort of like symmetric PW properties for you or something, but I don't know.

[01:04:52]I don't know. I'm making stuff up.

[01:04:58]Okay, that seems like kind of fine. So then on process two, he gets a he gets a PW service audio stream.

[01:05:09]And now here we have ass here.

[01:05:14]And then here we have ass stream. Now we have a buffer. Beautiful. We figured out how much stuff we want.

[01:05:27]Aren't we missing some sort of min here?

[01:05:31]Yeah, we should be doing like uh max out frames is here.

[01:05:37]Uh max in frames is like circular buffer count. We have uh con requested frames.

[01:05:55]I guess this is like over two probably.

[01:06:00]um requested frames is be requested and then we're saying like uh fill frames is the minimum of max in frames, max out frames and the minimum of that and requested.

[01:06:20]Beautiful.

[01:06:25]Cool.

[01:06:29]Circular buffer writes SB. Well, it was stream buffer before, but SB for circular buffer is pretty funny. That wasn't intentional, but I like that.

[01:06:43]Um, okay.

[01:06:46]So, now in we're not using this like data accumulator thing. We're literally just going like for each frame like pop the frame.

[01:06:59]Right. I think and this is uh crash if we hit this because there the calculation here should prevent us from ever popping more than is in the buffer.

[01:07:19]Okay.

[01:07:22]And then we're like ask B.

[01:07:27]All right.

[01:07:32]Cool.

[01:07:34]Okay. So now we want to do something where we create the service.

[01:07:44]Uhhuh.

[01:07:47]We also need the service function on our service. Huh? That calls like uh Oh, we also probably want to enter the uh the main loop, right? When you do enter main loop, maybe that has to happen late.

[01:08:04]Like in their example they were like in gain like you kind I think they you want to do this as close to the main loop entering as possible. So maybe we need this. Unfortunately, this service needs an enter leave, which is like a new concept for us, but whatever loop start.

[01:08:33]I don't see a way around it.

[01:08:40]Did I Oh, maybe I didn't restart this thing yet. That's funny.

[01:08:47]And yeah. All right. We'll just do it like that. It's fine. And then we have service.

[01:09:02]And that means that like the init function wants to take in the uh event loop as well as the service ID.

[01:09:17]so that he can just register himself the loop directly.

[01:09:21]I think that's fine.

[01:09:28]and he'll just say like before I'm done, let's just do a quick little loop register here.

[01:09:42]Given our PW loop, beautiful and v ID is our service ID. Beautiful.

[01:09:55]And now did we write our service function? We did not, but it's just whatever was in here. PW8.

[01:10:03]Fix me. LOL check error.

[01:10:09]Uh, but there we go. We're looking we're looking a little bit like something. So now when we construct our service, we have this um we say this guy takes in the loop now the event loop and event zero which we were claiming. All of this is going away now.

[01:10:33]This comes first.

[01:10:36]We bleeping and blooping yet. We're getting close. We definitely made some noises at a point.

[01:10:42]This stuff is all dead now, I believe.

[01:10:48]What was this builder for? I guess this is dead.

[01:10:54]Nice. No, it was down here for the raw audio build down here.

[01:11:01]Oh, we didn't. We've missed a bunch of code down here. All of this has to be added to the stream when we create it.

[01:11:12]All of this goes here.

[01:11:19]Uh, and probably just like in general, there's probably some cleanups to do here.

[01:11:28]Uh, just like fix me. Everything below this point has not been checked for cleanup.

[01:11:40]We'll deal with that later.

[01:11:44]Okay. So, we're like, scrap all of this stuff and we're like, oh, did we do a pwnet yet? We did.

[01:11:55]So, here we're like, make me a new audio stream. And here is my sample buff.

[01:12:04]And let's just make it like a meg of uh you of floating points, right? So here we can do like maybe a meg is a lot 500k.

[01:12:24]500k. So this is over four because uh floating point.

[01:12:32]Okay.

[01:12:34]Cool. So we have our stream here.

[01:12:41]Here we do a service loop start and loop end because unfortunately we think we need that.

[01:12:52]We want to do that kind of as close to the loop as possible.

[01:12:57]Beautiful. This is now uh this should be pw not called service.

[01:13:02]That's a stupid name for this.

[01:13:08]And now what we're missing is the part of this whole thing that like um populates the buffer, right?

[01:13:20]Um oh, we can't call this either. We should call this a PW service. Maybe pipewire service.

[01:13:30]Okay. So, let's say on a timer, let's do every uh Okay. So, if we have, let's do a little math. 52* 104 over 4.

[01:13:45]Uh that is 131,000 out of 41,000 or 44.

[01:13:56]We have around three seconds of audio here around right. So doing servicing the buffer once per second should be fine as long as servicing once per second doesn't cost so much that we miss more. You know what I mean? So maybe we do every 200 milliseconds we service we we add some stuff to the buffer, right?

[01:14:20]And so here we'll do our accumulator that we're using for the sign stuff here. We shouldn't have deleted the code, but I think that it should be in here somewhere. Act where was the part where we were doing Oh, we have it on process. Perfect. The old version of on process exists. So we just here say every 200 milliseconds throw some more stuff in the accumulator.

[01:14:51]and rearm.

[01:15:01]Okay.

[01:15:12]And is that it?

[01:15:14]We have to do something with the sample.

[01:15:16]So for zero to num channels, we push the sample into our stream from this thing. So we have like PWS uh get stream buffer with the handle that we have for this stream.

[01:15:38]And we're going to go like try buff push no clobber of the sample or else return error out of room.

[01:15:52]I guess we'll say out of memory to reuse existing functions.

[01:15:57]And I think that should work.

[01:16:00]I think that should work.

[01:16:07]Uh, okay. We're missing some things.

[01:16:13]These things need to be optional dreferenced.

[01:16:16]This guy, these guys are no longer part of this API. We need our expansion allocator, which is just like a a normal Zigg allocator, but with some like metadata about like whether or not it supports free and the minimum size. So you can give it like the page allocator and say only allocate in 496 byt chunks and stuff like that. Um that's why this exists.

[01:16:43]Um we need our pool.

[01:16:48]So I guess we are kind of expecting to have somewhat less than four streams definitely less than 1024 streams. And we are expecting to come in with you know an initial allocator as well.

[01:17:04]So we still throw those in here.

[01:17:08]Okay.

[01:17:11]I'm sure there's more compiler errors here. We have uh we'll use the general purpose allocator and a general expansion allocator. You know, you can do whatever the [ __ ] you want, [ __ ] Um, this thing needs to be variable, I guess.

[01:17:31]Does it compile? We're here. This guy can fail. So, true.

[01:17:37]Uh, this is not self DPW. This is just DPW.

[01:17:41]Stream here is unhappy because I think this would be like or else return error make stream or something.

[01:17:52]What's this guy mad about?

[01:17:55]He needs the expansion allocator in case he needs to free. Okay, this guy's mad because we need to strong him.

[01:18:06]Get stream buffer buffer doesn't exist.

[01:18:14]Uh we'll which will turn a stream buffer which is like maybe a pointer to a stream buffer. He takes in the handle which is an audio stream handle. And here he's like uh return self pool get handle dot SP easy get stream buffer stream is mad because probably the definition of this thing didn't try uh expected optional type found void.

[01:18:47]Oh nice. This will already fail.

[01:18:49]Beautiful.

[01:18:53]Okay. Does it work?

[01:18:55]Zero frames.

[01:18:57]Did we forget to cue the buffer at the end?

[01:19:06]No.

[01:19:09]Uh, I guess it's one of these minimums is bad.

[01:19:15]Oh, we probably never populated the initial data.

[01:19:19]We probably need to populate this thing off rip. No, because he tries to populate after 200 milliseconds at least service. Uh push some dead.

[01:19:37]Okay, we are I do see that push from data showing up every once in a while.

[01:19:41]So, it should we are trying. Uh BRX, thank you for the prime or the resub tier one. Much appreciated. Much appreciated. So that's not good.

[01:19:58]Okay, let's um print just like the three numbers.

[01:20:06]Max out frames, max in frames, and requested frames. Which one of these is [ __ ] max in frames.

[01:20:19]So, the stream buffer is no good, but we're putting stuff in there.

[01:20:27]Oh, we're only pushing one sample while um buff count is less than buff items length.

[01:20:41]While we can, I guess it's more like um while true, we rip [ __ ] in here. We say push no clober. And then here we catch break.

[01:20:57]And then we only increment this thing if it worked.

[01:21:04]Close.

[01:21:11]It is crackling sometimes, which is interesting.

[01:21:23]I mean, it could be floating point error, right? Um, could be floating point error. Can we do accumulator as a u size and this is going to be as f32 or like float from int maybe? Yeah, let's do float from int.

[01:21:46]And let's try to keep this float small.

[01:21:48]So we're going to say act plus equals 1 and uh act is equal to act mod uh one cycle.

[01:21:59]You know what I mean?

[01:22:01]And then maybe that will fix the crackling. I don't know. There could be multiple reasons for it. So it is still crackling after some a little bit which is interesting.

[01:22:16]The fact that this is odd is concerning.

[01:22:20]I feel like it shouldn't ever be odd. So maybe the problem here is that the buffer is not a multiple of to I mean I think it would have to be um yeah the the pro this 941 is concerning you know what I mean so let's say um cost remaining is a buff items land minus this buff items count over two. We want to do this whole thing over two to make sure we can push two at a time.

[01:23:06]And then this is uh numbum samples for zero to num samples. We push twice and on the second one it we should crash if it doesn't work.

[01:23:24]Okay, that's not good.

[01:23:33]Pushing this many samples.

[01:23:41]What am I missing?

[01:23:48]Pushing zero samples.

[01:23:56]Oh, I'm an idiot.

[01:24:00]Uh, this needs to be here. This needs to be four up here.

[01:24:05]This needs to be not in a loop. I'm [ __ ] high in my [ __ ] mind.

[01:24:18]This is what I'm looking for. So, we push the first one. That one is allowed to fail. No, it's not. They're all failures now. We push it however many times for numbum channels. So, we pre-calculate the number of samples. We get this buffer up front because we don't need to [ __ ] get it every time.

[01:24:40]We calculate numbum samples here. We say for however many samples that we have room for in the buffer, we'll push that thing.

[01:24:47]There we go.

[01:24:51]Let's go.

[01:24:54]Let's go.

[01:24:57]So, this is really nice because now we have this like generic API, right? where the pipewire service all we have to do from his from like to use him is we initialize the service and we say we have an audio stream and completely independent of the ser the pipe service I will just populate as much as I can when I have data right so in the context of an RTP stream this would be triggered on UDP packet receive but for our case um how jittery realtime is the event loop that's a great We might have to fix that. It's using e.

[01:25:42]Um, but if it gets really bad, then we can just we can move like we can always move the audio thread into its own loop and add like a little bit of mutx locking on the buffering.

[01:25:56]It's not the end of the world if we choose to do that.

[01:26:00]But like I like this API, right? This API is very nice because especially with audio, you need to take your dead headlines. Yeah. Yeah. Understood.

[01:26:08]Understand. See if it clicks. I think the clicking is fixed.

[01:26:12]I'm pretty sure the clicking was like a complete result of us filling an uneven number of channels. I'm pretty sure like I think that like whatever buffer size we ended up picking was just somehow resulting in some [ __ ] You know what I mean? Once once I did like pre-calculated the size up front, it seems to be fine.

[01:26:36]Yeah. I mean, that's that's nice, right?

[01:26:38]So, if we're if we're playing if we're playing a file, I sort of heard clicking at the end. I haven't heard it.

[01:26:49]Oh, you know what? Sometimes uh the like the there's something where you guys sometimes hear stuttering and I don't which is like probably related to like this [ __ ] that's going on the like noise reduction [ __ ] that can that can like cause the problems. Uh but like I don't know I haven't heard anything so I it's fine from my end.

[01:27:17]Oh yeah, API very easy, right? Because for for a file for a file, we would choose to buffer however much data we would just probably again on a timer just consume data from the file until we run out of room in the circular buffer. For a streaming audio, we just push data as it comes in. And we just make sure that we size the buffer such that we can never get too far ahead that we run out of memory.

[01:27:48]for anything generated. We can just fill it on a timer as well.

[01:27:53]And I think that's kind of all the cases.

[01:27:58]Yeah, I'll take that. That this actually ended up being much nicer than I thought it would, right? Like if we look at Let's just delete all the code that's not being used right now. This is dead.

[01:28:08]This is dead.

[01:28:12]Based off of how I was feeling yesterday, I thought this was going to be way worse. But in terms of like actual amount of code, like initializing the dynamic library, it's not that bad. I hit him with the it works on my machine. Huh? No, but I mean you're seeing my machine. This isn't it works on my machine because it is working on the only machine.

[01:28:40]Um, this is a little bit nasty, this like generation of an audio stream. And eventually we're going to have to support like, you know, stream ops, like stream format in here, right? Because like depending on the RTP stream that comes in, we're going to have to do something there.

[01:29:00]Then we just have a buffer. The the processing loop is not that bad, too. I mean, there's like some confusion in here. We still don't really understand everything about this thing, right? Like why are there chunks in a buffer? Like there's a reason for it. I'm sure. I just don't know what it is. But like this is just copy pasted from the audio example. So it's like not that bad once it's hidden away.

[01:29:21]And then from like a user perspective is great. Like main it's like give me a service, give me a stream, I'm going to put some [ __ ] in the stream. And I presume that we have the option to have many streams, right? Can we actually do that?

[01:29:40]Let's make a second stream.

[01:29:46]And let's say that we will populate stream 2 at uh 880. Can we hear 880 htz?

[01:29:56]We can, right? I think we can.

[01:30:01]Uh so we're going to do the same thing.

[01:30:04]uh where maybe we scope this and we put into stream two just we'll copy the same [ __ ] but we'll just say uh samples per 880 and then I think actually technically the buffers are we need a second buffer as well huh Yes. 200 to 2 200,000. Yeah, that makes sense. We can hear to 20,000 14,000 if you're not 400. Yeah, because I guess I guess 880 would just be one octave above 440, which we can definitely hear, right? 440 is like which means 880 is like which we could probably hear fine.

[01:30:51]Um I guess we need act two as well.

[01:30:58]And then we kind of just scope this and do it twice. [ __ ] it for now. I just want to make sure that this works.

[01:31:08]Stream two here.

[01:31:10]Uh then we are doing samples per 880 which did we change that? We did. And then this is act two and act two here.

[01:31:33]Huh? Why don't I hear that?

[01:31:51]Oh, because I didn't do act two here.

[01:31:53]Oopsies.

[01:32:05]Hold on. I just want to make sure that like I can hear the 880.

[01:32:12]Why does that sound just like 440?

[01:32:15]Because I have samples per 440 here.

[01:32:18][ __ ] me.

[01:32:21]There we go. Nice. Okay, that's audible.

[01:32:23]So now, can we do two streams at once where we're playing two sine waves, an octave apart?

[01:32:38]Hell [ __ ] yeah, baby.

[01:32:45]That's pretty sick. Pretty sick. Yeah.

[01:32:49]So, so interface-wise, you can just spawn as many streams. Oh, hold on. I want to check also. Um, sorry. Let's just turn this down a little bit for you guys. Oops. Not mute it. I just want to see. Um, does it show up as two streams here?

[01:33:08]Yeah, it does. Interesting. Oh, I actually only turned it down for the stream, not for the recording. So, get [ __ ] Uh, VOD viewers.

[01:33:16]Um, was that both? I only hear 80. I see I hear both. I don't know if there's some sort of like [ __ ] noise reduction happening, but I was hearing both. So, it does show up as two streams, which is interesting. Um, so like there's a world that makes it seem like you kind of want to like mucks yourself. You know what I mean?

[01:33:40]There's something interesting. There might be like part of the uh part of how do I say this?

[01:33:51]part of Pipear's API might involve some like mxing stuff. It would it should because at the very least it's mxing between applications. So I would love for it to be able to m between one between like multiple input streams on my own application. I would love for that to work. Um, so there's probably something there where you're I don't know.

[01:34:17]Maybe you like ask it to not show it.

[01:34:19]Maybe maybe there's some API to create like a stream and then substreams off of that. We can like look for that a little bit. I mucks myself every day.

[01:34:30]Every day is a lot.

[01:34:33]That's a lot. But like, good on you, I guess.

[01:34:36]But What's wrong with mxing between apps? Go mx yourself. Thank you everybody. Never mx the streams. Thank you. Thank you.

[01:34:46]Thank you.

[01:34:48]So yeah, I think I'm happy with this for now. There's like details to be sorted, but I think this works. I was expecting it to be worse. So once we've kind of figured everything out, it's not that bad. Not that bad. All right, cool. Um, thanks for watching, guys. We're going to call it there. If you like what you saw, we stream most days. We aim for a 12:30 start. Try to end before 4. It is 3:10 right now. If you're watching live, these times are in Pacific time, which in BC is now always Pacific Daylight Time. We are never going back. Hell yeah. Um, was there anything else I wanted to say?

[01:35:28]Patreon, YouTube members, Twitch, pay on any of those. You support the stream, you get access to the happy hour VODs.

[01:35:33]Today's happy hour was about cleaning up some of this dynamic library stuff. So, we kind of generated like we wrote some code that will generate these str, you know, be attached to our build system and stuff. We were trying to figure out like, you know, how should that look like? If you want access to that, um, you know, pay in one of those spots, but otherwise, obviously, no pressure. You won't miss anything that important.

[01:35:56]Is that it? I think that's it. YouTube, peace out. Two raid.