*** MUS171 #10 02 03
@0000 There's one sonic aspect of sampling that I didn't stop and explain as well as I wanted to explain last time.
es:@0000
@0015 So, I want to go back and ... just do it harder.
es:@0015
And that is the business about, if you have a looping sampler, there are two regimes in which you can hear the thing: One is where you have @0030 the sampler playing back, either looped or not looped but at least slowly enough that you hear individual starts and stops as events. ...
es:@0030
And that would mean perhaps playing fewer than 30 different things a second. So, here the example would be. .. @0045 Whoops, that's not a good example. [audio tone]
es:@0045
Miller: So, now you just hear one of the dude's phonemes six times a second. Right? This by the way, is a copy -- annotated and then partly de-annotated -- @0060 of one of the patches that I made last class. And this is up on the Web.
es:@0060
And my purpose in making the patch was to show you how to add the "envelope generator shaping" to a phasor. @0075 But now what I want to do is -- continuing to look at the phasor-driven sampler, because it's the more appropriate way to look at this --
es:@0075
to compare again what happens at low and high frequencies of phasor. What happens at low frequencies is kind of @0090 exactly what you would expect, which is ... [audio tone]
es:@0090
Miller: You hear stuff at a certain number of times per second, and furthermore ... OK, so what's happening here is this 34 @0105 is the beginning place. Oh, it's in 100s of samples, which means 441 of these make a second. ...
es:@0105
@0120 [interruption]
es:@0120
... @0135 Back to normal. All right. So, what's happening is we're looking at this array, and we're looking, starting at whatever 34 corresponds to here.
es:@0135
@0150 And then we are sliding forward 78 of them. ( ... Is that me shaking? How is that happening? Student: Maybe it's just an earthquake.
es:@0150
Miller: I think we were having a nice little earthquake. @0165 We just invented a new kind of seismograph. Maybe I'm wrong; maybe it's something totally anodyne.)
es:@0165
OK. So this 78 is now being multiplied by the phasor, so the phasor is going from 0 @0180 to one, and now we're making the phasor have a range, which, in 100s, anyway, starts at 34 and goes to 34 plus 78. So, this is the amount of sample you hear each time. So that ...[audio tone]
es:@0180
Miller: Once you've got the units right, anyway. If this @0195 thing times this thing equals 1, you've got the straight-ahead transposition, that is to say, the original pitch. And what would that be? Actually, let me change the unit so that it's easier to think about. I'm going to make this be units of 441, so that these are hundredths of a second.
es:@0195
@0210 And now this'll be something like nine, and this'll be something like 20. [audio tone]
es:@0210
Miller: Yeah, there we go. So now what's happening @0225 is this is .17 seconds, because 441 samples is 0.01 seconds at our sample rate. And this .17, that times 6, if you multiply it out
es:@0225
@0240 in your head, turns out to be very close to 1.
es:@0240
Actually, one-sixth is, as you all know, 0.1666, so we'll do this: And now we'll get the original transposition. This number in hundredths, @0255 that is to say, 0.1666 repeating, times six is 1. And now if I choose some other pair of numbers which also multiplies out to 1, such as make that five and make that 20 hundredths ...[audio tone]
es:@0255
Miller: Then I've changed @0270 the speed at which the thing's happening but I haven't changed pitch that you hear, or the transposition that you hear, of the sample. OK. Is it clear why this is working? So, the transposition that you're hearing
es:@0270
@0285 is proportional both to this number. [audio tone] ...
es:@0285
Miller: ... and also this number. OK. Next thing about that is this: This is @0300 what you hear these numbers are below about 30. That is to say, the number of things you can hear as happening as discrete events. So even if I push this to 20 and drop this to five. ..
es:@0300
@0315 Whoops![audio tone] ... And find a good place ... You hear the event as a repeating thing but if I push this past about 30 you won't anymore. I don't know 30. It's iffy. But of course, this is a very particular
es:@0315
@0330 spiky part of the sample. If I get somewhere else in the sample. .. [audio tone]
es:@0330
Miller: It becomes very hard to hear that as a sequence of things and easy to hear as just a continuum. If I push this higher, then at some point your perception @0345 of this as having a pitch becomes more important than your perception of it as number of times per second.
es:@0345
This is just acoustics, if you do anything repeatedly fast enough it becomes a pitch. @0360 For instance, if I want to use this Western-style musically we'd want a MIDI to frequency converter. ...
es:@0360
@0375 make another number box ... Then I can say, "Well, play that for me at play it at middle C, please." Which is 261 Hertz and now we've got middle C. [audio tone]
es:@0375
Miller: I could check it on the piano @0390 if I cared. Oh yeah, let's go down an octave. That's a little too harsh. Oh. Why does that sound so ugly?
es:@0390
@0405 There's something going on here that I don't understand.
es:@0405
That should be a smoother sound than that, but we'll go for it for now. If I ever find my mistake I'll tell you. So, at this point, we're playing five milliseconds @0420 of sample at a time. But we're transposing up a quite a bit because we're playing 130 of these per second.
es:@0420
So really, this should last something under @0435 one millisecond. Should last about .7 milliseconds, I think. Oh, this will sound better now, maybe. Yeah, there we go. [audio tone]
es:@0435
Miller: All right. Then, we have the sample as before: @0450 [audio tone]
es:@0450
Miller: Those are timbres taken from the voice. In fact, I could even try to move this continuously, except I'm going to get in trouble. @0465 You'll see. [audio tone] Miller: It's a little ugly because you hear it click every time this thing changes discontinuously. [audio tone]
es:@0465
Miller: So, let's go find "soft." OK. @0480 And now, when you heard it coursing over the sample, then you heard the timbres or the vowel and consonants
es:@0480
@0495 of the original sample going by. So, right now, you can sort of believe that this thing. [audio tone] Miller: Is the "O, " the short O of soft. Right?
es:@0495
That's of course, assuming I'm playing everything at the correct speed. In other words, I've made this and this @0510 multiply to approximately one. I didn't check that it was exactly. Oh, I could. I could! Nah, let's not ... I could take this and divide 1000 by it, and put that there. Actually, that would be a good thing to do because I'm going to have to do it later.
es:@0510
@0525 So, to do that, we're going to divide something, but we're not going to divide it by 100. We want to divide 100 by it. And, that's the thing I haven't shown you how to do yet. But, it's not hard. So, what you want to do
es:@0525
@0540 is you want to take 100. Control-alt-2. Sorry, 100. We're going to take 100 divided by this, right? Because it's in hundreds of samples.
es:@0540
@0555 We're going to take this and put it here. But then, we're going to have to bang the 100. And so, we need our old friend trigger to make the thing get banged at the appropriate time. So now we say, "Trigger, bang, float."
es:@0555
@0570 Let's make this be reasonable. OK. And now, I'll show you. Oh,, rather than show it to you, I'm just going to use it. And, you'll see.
es:@0570
@0585 So now, I'll say, "48 again, please." And, dada. It computed the exact value, which was 100 divided by this, which is the number of 100ths of a second, which would be the period if this is the frequency.
es:@0585
@0600 This would be a good place to stop for questions. Student: Can you explain the abbreviation? <<"t b f">>
es:@0600
Miller: Oh. OK. So, this is abbreviation for @0615 "trigger bang float". And, what trigger does is two things. It formats messages for you --
es:@0615
So, there's a floating point message coming in. And, what we want coming out is a bang here to send this 100, @0630 and then actually, before that a floating point number, which is whatever we sent in.
es:@0630
So, this divide needs to receive 100 here. And then, it needs to receive this 130.8 here. But, @0645 the divide divides when it receives this number <<at the left inlet>>. And so, it needs to receive this number <<at the left inlet>> after it has already gotten that one <<at the right inlet>> -- so that it will do the division correctly. Sorry, there are two questions. You first? Student: So what's the purpose of the bang?
es:@0645
Miller: @0660 Well, the bang is simply to get this 100 to send out, because if this 100 doesn't get sent out, this thing will never divide. Student: So there's a bang and a float?
es:@0660
Miller: It sends the float, and @0675 then it sends a bang, which sends this 100. Student: And that's going to be top down, or?
es:@0675
Miller: Uh, let's see. This is going to be 100 over this floating point number. @0690 Let me see if I can make this into a more synthetic example. Let's make a copy of this.
es:@0690
@0705 So a number comes in, number comes out. And whatever I put in, what comes out should be 100 divided by this number. OK, so how do I do that?
es:@0705
The number goes in, and I ask it first to put the @0720 number in -- OK, this is the divider. So what I need to do with the divider is first put five in here <<right inlet>> and then put 100 in there <<left inlet>>, so the thing will do 100 divided by five. All right?
es:@0720
Yeah ... lots of questions, let's see, I don't even know @0735 who to ask. OK. Student: So, the float, how do you know it goes in first?
es:@0735
Miller: Oh, trigger is defined to put its outputs out in right-to-left order. In general, objects that have multiple outlets @0750 that spit out messages at the same time (another example would be unpack) always do it from right to left order, so that you know what order they're coming into a subsequent box in.
es:@0750
@0765 This order doesn't mean that time is passing. All this happens in one instant of time, or to put it a different way, between two audio samples, but the same two. In other words, it happens in a moment that isn't
es:@0765
@0780 allocated any time of its own.
es:@0780
And yet it has an order, because you have to have this thing go in the correct order, otherwise you could never program. OK. ... Pd is not a programming language, and @0795 this is asking Pd to do a programming language-ish thing, which it can do. But obviously, if you just had BASIC or C or something like that, you could do this particular thing a lot easier. You just say, "100 divided by f, " or whatever it is.
es:@0795
@0810 But since we're in a graphical programming language, it's great for doing things like bashing signals around like that. And it's a little clunky for doing things like saying, "100 over f." This is the easiest way I know how to do that.
es:@0810
@0825 There are others. Other questions about that? .... Yeah? Student: So, for when you're changing the range for the plus value, so if you wanted to. ... Not put this object value back to this top half.
es:@0825
Miller: @0840 This value, OK. Student: Yeah. You just have to unpack or on the line? Or if you wanted not to click? Miller: Wanted not to click. In other words. .. Oh, you mean, if I wanted these things to be their values when the patch shows up?
es:@0840
Student: @0855 Yeah, like cycle through that 60 times or so. .. Miller: Oh, I see. Yeah. So right now I haven't done anything to automate that. I've just left it as a number box. But in fact, that could be messages coming in from some other place if I wanted to.
es:@0855
@0870 And then I could use the number box to override it, or I could just have it be what it is. But it's easiest, just for the purposes of showing the patch, it's easiest to have everything just be controlled by hand. Yeah?
es:@0870
Student: @0885 Now if you put more floats in there? And you put a metronome in there? Can you create a loop to sequence things? Miller: Sure. Well, OK, sure, there would be some work to do, because. ..
es:@0885
@0900 If for instance, I had a bunch of numbers in a message, like that. ... If I sent those to this, for instance,
es:@0900
@0915 this number would become 1. And then it would become 3 and then it would become 5 and then it would become 7. And 7 would win. If I wanted it to do those things and have it be 1, then 3 at a later moment in time, and then 5 and then 7, which would be more like a sequence. ..
es:@0915
@0930 Then the easiest way to do that would be to store those numbers in a table or an array, and then read them out of the array using a metronome. ... Yeah? Student: So, outlets send from right to left, but inside a message box left to right?
es:@0930
Miller: Ooh! @0945 Yeah; outlets are right to left. Things inside a message box are left to right or in order that they are as text. Student: Oh. OK.
es:@0945
Miller: Yeah, that's confusing, isn't it? It never @0960 occurred to me to think about those two things in the same thought. ... Yeah? Student: Can we depend on everything other than the trigger having regular order from the outlets?
es:@0960
Miller: @0975 Well, what you can't do, or what you can't depend on, is this: ... I might have shown you this already.
es:@0975
@0990 I can't remember ... I'm going to take this number and just square by multiplying it by itself, and I'll do it that way.
es:@0990
This doesn't work because @1005 this multiplier got these two values all right, but it got this value first and that value afterward, and as a result it did the wrong multiply. So, to make that guaranteed
es:@1005
@1020 you would put a trigger in to make sure everything happened in the order that you wanted. In other words, you would say .... Oh, I'll keep the wrong one and the right one. You would say ...
es:@1020
... @1035 "trigger float float" . And now we know that
es:@1035
@1050 this float will come first <<right outlet>> and this float will come second <<left outlet>>. And then it will do my squaring job right, whereas here it didn't. Student: So not objects other than trigger are right to left though, like unpack?
es:@1050
Miller: @1065 Yes. If the outlets are all, what's the right word? Well, an example of something that doesn't do that is "route" because it doesn't ever put something out
es:@1065
@1080 more than one outlet as a result of a single message.
es:@1080
But things that do put out more than one thing as a result of a single message, such as "trigger" or "unpack" -- or "notein" if you're doing MIDI ... @1095 I don't have a lot of other examples here. ... those are all arranged from right to left. That's simply because right to left is appropriate for inlets because it's best to get things left last. ... Yeah?
es:@1095
Student: @1110 Would it be one multiply by a parameter and then add, would you have to make that separation?
es:@1110
Miller: Yeah. @1125 It gets ugly. What's a good example of that? Yeah. I have a good example, but it's too complicated and
es:@1125
@1140 I'd have to explain it. If you want to do A + (B * C) for instance.
es:@1140
OK, so you put B and C into the multiplier and then you have A and you want to put it into an adder. Then you have to decide OK, do I want that number to change every time I change any of A, B, or C or @1155 do I want it to change only when C changes or so on like that?
es:@1155
You could want it either way. For instance, if you're playing a MIDI keyboard and you want to transpose, when you change the transposition you don't want it to replay the note. That just means you want @1170 the next note you play to have the new transposition. So, in that case it would be appropriate not to recalculate the pitches of all the notes because you changed the transposition. Maybe.
es:@1170
But in other situations, you actually want the output to change when @1185 any of the inputs change so it's always correct according to the last inputs. Those are just two different situations. So, you can get Pd to do it one way or the other. The way to get it always to follow what you do is
es:@1185
@1200 to use triggers everywhere that you need to in order to make sure that everybody's leftmost inlet gets whacked last and then everything will stay up to date.
es:@1200
That was a little abstract, but we'll hit examples of that I think later on, @1215 I think, in the quarter -- especially if I go back and show you pitch to MIDI conversion in general. Any other questions? That was useful because
es:@1215
@1230 I think there were a bunch of things I wasn't saying that I should have been saying which that helped clear up. OK. ...
es:@1230
@1245 So, now what we have is I've got this number here and I'm computing 100 divided by it to put here. So now, I can do this kind of thing. [audio tone]
es:@1245
Miller: It's not @1260 perfectly smooth, but it's now figuring out what I have to put here to put timbre. In order to get the sample to play back at the recorded speed, regardless of how many times per second I'm asking it to play back.
es:@1260
@1275 So, the faster I ask it to play back, the less of it I can play back each time if I'm trying to constrain the speed. Now the other thing to mention about this is that ...[audio tone]
es:@1275
Miller: @1290 Now we've got a nice pitch and now we could just go and change this segment size without changing the number of times per second and then we get this kind of thing.
es:@1290
@1305 Notice there are clicks in the sound. That's because when I change this discontinuously or when I change this according to the mouse it changes the thing I'm multiplying the phasor by, so it causes the read into the table here to move discontinuously, which is a click.
es:@1305
@1320 So if I want to do this correctly I'd have to use a line object to de-click this. Nonetheless, I now have my first nice timbre whammy-bar that you can use to make wonderful computer music. Right.
es:@1320
In other words, this is the first example, @1335 (except for that attempt that I made to explain FM, which I shouldn't have ever done ...) This is the first example of a situation where you can change a control and it will actually make an audible change to the timbre of the sound.
es:@1335
Which, of course, is what computer music was supposed to be about back in the day. @1350 There will be many more examples of this, because eventually you will be able to make filters and frequency modulation -- once I get that straightened out -- and other things like that.
es:@1350
Right now, the reason this is happening, I can actually show you using this table. @1365 So, just for emphasis sake. .. [audio tone]
es:@1365
Miller: If we go down to a frequency where you can actually hear the things then what @1380 I'm doing is actually changing the size of the sample we're playing, which is changing the transposition. But then if you make that happen at an audible rate then
es:@1380
@1395 we're changing the transposition again, but it doesn't change the pitch that you hear. [audio tone]
es:@1395
Miller: ... Because the pitch that you hear is now no longer the pitch of the original sample. But it is the new pitch from just being imposed on it by the fact that I'm reading it at a fast rate. @1410 And that is in fact a continuum. [audio tone]
es:@1410
Miller: So for instance you can say ...[tones] @1425 And now I have a continuous way of moving back and forth between pitchy sounds and sampled sounds. [audio tone]
es:@1425
Miller: And that a lot of people heard for the first time when @1440 Fatboy Slim did that song "The Rockafeller Skank" -- That was this. Miller: OK, questions about that? Student: Was he actually using Pd? Miller: No. [audience laughter]
es:@1440
Miller: @1455 But he wasn't using Supercollider either -- He was using commercial stuff. All right. [audio tone]
es:@1455
Miller: @1470 So now, this, which becomes a transposition when we do it slow, is a timbre-change when you do it fast. [audio tone]
es:@1470
Miller: @1485 And another way of seeing that is to take this thing and graph it. Which is what I now propose to do by using these graphs over here. So I'm going to keep the phasor and instead of graphing the envelope, which is what this graph is here to do earlier ...
es:@1485
I just want to graph the output of @1500 the tabread~ object. Oh yuck! --- Oh, I see. I've got this thing so high that the graphing doesn't look good. So let's change the properties here.
es:@1500
@1515 I had 44 -- that's a tenth of a second.
es:@1515
I'm going to need like a 50th of a second. So let's make this a thousand. <<"Size" in the Array Properties of Array "scope">> That's actually @1530 a 44.1th of a second.
es:@1530
And let's see. Will this work? Still looks, oh whoops! I didn't do that quite right, I need to change this too <<"X range in the Canvas Properties>>. ... @1545 Oh, and this! <<"Size" in the Array Properties of Array "scope2">> Sorry -- I've got two arrays in there <<"scope""scope2">> which is why I got confused.
es:@1545
So OK now what we see is there's a nice phasor and it's going at 48 times a second. @1560 And each time it goes you see the same waveform, which is in fact the waveform which is stolen from the original recording.
es:@1560
And now if I ask it to graph again, you'll see that it's in a different place, because I don't know @1575 how to make the graph start right when the thing wraps around.
es:@1575
... That's for later ... But you can see that it's the same waveform. Now if I say, "OK, do that but make this number larger. In other words, make there be more of the sample." Actually, let's have there be less of the sample first. @1590 I'll drop it to one.
es:@1590
Then when I graph it, you'll see that there was just less waveform stuffed into there. ... Is this clear? @1605 Now you can do wonderful things because, what would happen if you just stuck a sinusoid in here?
es:@1605
Actually, that would be a useful thing to be able to do, so let's do it. So now what we're going to do is we're going to say, "tabwrite~" @1620 and I give the name of the thing, Table "t2.03a" ...
es:@1620
Now I'm just going take a nice sinusoid, @1635 maybe 110 Hertz, so it won't be too different from the sound of the dude's voice. And I don't want it to be quite that loud because I don't have a good volume control,
es:@1635
@1650 so I'm going to protect us by multiplying this by some smallish number.
es:@1650
And now we need a button to make this thing happen. @1665 Wait two seconds ... And sinusoid! -- although you can't really see it as such. And now here: <<in the graph>> Sinusoid!
es:@1665
Except, of course, the sinusoid has a discontinuity every time we restart the sample. @1680 And now the bigger a chunk I read hear of the sample, the more cycles of the sinusoid have to slap into the same amount of time.
es:@1680
If you can imagine what that sounds like, @1695 it's got this period, so the pitch of it isn't changing, but you can tell by looking at it that it's got a lot of stuff at this frequency and maybe not a whole lot of stuff at fundamental. So now if we listen to it. .. [audio tone]
es:@1695
Miller: @1710 We've made ourselves a nice little formant. ... Is that clear?
es:@1710
Student:@1725 Are those pops because of that repeating ... ?
es:@1725
Miller: Yeah, the pops happen whenever I change this. @1740 And what that does is that changes the amount I'm multiplying this phasor by. If I happened to do that right when the phasor was at 0, it wouldn't make a discontinuous change. Student: So you're re-ranging?
es:@1740
Miller: As it is, it gets up to a half or something like that, @1755 and then suddenly it re-ranges, and that pushes it off to a different value.
es:@1755
I'll show you things about that later ... after I've stuffed all these more fundamental ideas into your heads. @1770 The object you want is "sample and hold" because you want to sample this number only when the phasor changes value.
es:@1770
@1785 But, of course, the thing that I had originally was not a sinusoid, it was the man's voice. Then you get
es:@1785
@1800 this look and this sound: [audio tone]
es:@1800
Miller: And, of course, different @1815 parts of the sound file different things, but they all have the same basic behavior. All right. ... So that is basically
es:@1815
@1830 a thing about sampling that everyone can use. ... Questions about this before I go on to other things?
es:@1830
What I want to do now is go back to polyphony and voice management, which I started talking about last time, but @1845 about which there is much more to say. Yeah. Everyone's tired of this topic anyway. ... Yeah? Student: Are you going to put these patches online?
es:@1845
Miller: Oh Sure. Yeah, this one is going to be patch ... I have to change the order@1860 of these because I didn't plan very well .. But all the patches up until last time are up on the web. It takes me a day or two, but I eventually get around to putting good comments on that actually mean something, when I'm putting them up.
es:@1860
@1875 Yeah -- this is a good trick. OK. So now I have several matters to go over.
es:@1875
First off, @1890 here's the example of a multiple-voice sampler: [audio tone]
es:@1890
That was the thing I showed you guys last time. Right? The basic deal was, the new objects you needed were ... @1905 First off, just the notion of having a so-called abstraction.
es:@1905
That's to say, being able to put a Pd patch inside a box, which would, in fact, be a sub-window. And "route", @1920 which is this object, which takes a message in with any number of numbers and looks at the first numbers and, depending on what it is, puts it out one of the several outputs.
es:@1920
Since there are eight arguments here there's nine outputs because there's one for @1935 if it didn't match anything. (That way you can gang several route objects together.) Although here I happen to know that this number will always be 0 to seven because I have this "mod 8" here.
es:@1935
@1950 This is an example of polyphonic voice allocation and there are other examples of things that you can do with polyphonic voice allocation -- which I will actually show you by taking you through some pre-existing patches.
es:@1950
@1965 -- a slight departure from the custom. So, this right now is just a copy of what there was last time. The first thing I want to mention before I go ripping through the pre-existing examples
es:@1965
@1980 is a thing about abstractions I haven't told you about, which is this:
es:@1980
Here's another abstraction. Get in edit mode ... You can do something like. .. @1995 Well, I have an abstraction, which I moved into this directory beforehand, called "output~". This is interesting because it's not just an abstraction that has a patch inside it,
es:@1995
@2010 but it also has controls, which it printed on its "faceplate", if you like. So, this is a technique for being able to make things like modular synthesizers give you -- which are modules with audio inputs and outputs, but which also have controls like knobs.
es:@2010
@2025 So, I'm just going to tell you now that this thing exists and how you can deal with it. First off, it's just an object like any other, so I can retype this and it would become some other kind of object. But this is a particular
es:@2025
@2040 kind of abstraction, which does this for us.
es:@2040
If you want to see inside it, it is not good enough to click on it because clicking on it means doing that kind of thing<<changing the value in the number-box>>. @2055 Oh yeah, by the way, this is an output level in decibels and you would use this if you wanted to have a patch whose output level you could control on the fly, which is a good thing to be able to do.
es:@2055
@2070 The other thing about this is, of course you might want to be able to see what's inside it, but clicking on it doesn't do that because clicking on it does that kind of stuff. So instead, you control click or right click depending on what kind of mouse you have
es:@2070
@2085 and say "Open." Then you will see the contents of the thing as an abstraction.
es:@2085
Then it's nothing much more than what you've seen already except there are some tricks here that I haven't told you about yet @2100 which I hope to tell you about today. Then closing it's the same as it always is. You just close it. All right. This has a name. It's called a "graph on parent" abstraction -- the reason being that
es:@2100
@2115 it shows a certain portion of its GUI objects, its controls, on its own surface as an object.
es:@2115
You can learn how to make these and so on. @2130 Well, OK ... You would say... "Properties" . <<Canvas Properties>> Notice here it says "Graph-On-Parent"? You have to click that and then that turns your abstraction into one of these things, but then there are things you might want to set that I have to explain in detail later.
es:@2130
@2145 I'm telling you that because I'm going to take you through some patches that are going to use this and I want you to know about this thing's existence. If you want to use this you have to get this thing and copy it into your own directory.
es:@2145
I'll throw it up on the website, but it is also on all of your computers because it's @2160 actually in Pd, in the help patches. And that is in fact, where we're heading next. I've been studiously avoiding the help patches because I've been building everything from scratch, but by the time we're getting into voice-banking stuff,
es:@2160
@2175 some of the examples maybe are better just looked at and described than they are built up from scratch, because ...
es:@2175
... you have to do several things at once and get them all working together. So, I'm just going to close this and open @2190 some other patches that do other things. ...
es:@2190
So, in Pd, if you say, "Help, " one of the things you can get is this:"Browser". And the browser has @2205 far too much stuff in it, but if you go looking for "Pure Data" ... -- Oh, by the way, if you have Pd Extended this really has a lot of stuff. Right now it merely has a bunch of useless stuff. "Pure Data" .."audio examples/" -- Oh right, there's a manual. This has a bunch of
es:@2205
@2220 HTML stuff, which is very telegraphic and, what's the right word? "Short". "control examples" -- later."audio examples" -- which are examples about
es:@2220
@2235 how to do synthesis, processing, and analysis of sounds. --
es:@2235
These examples correspond to the textbook, which I haven't been referring to very religiously, but we're now somewhere in chapter four of the textbook, talking about voice allocation. @2250 The A's are all chapter one, the B's chapter 2 and so on like that.
es:@2250
And so, all of this stuff, if you want to see more description of what it's about and how it works and why, look in the book in chapter four @2265 and the book actually talks about all of these patches in some detail. The things I wanted to show you were, for instance. ..."additive synthesis". <<D07.additive.pd>>
es:@2265
@2280 Here's the reason I showed you output is because we're now going to be starting to use output to set the. ... [bell tone] Miller: Volumes of things. Notice these values are in decibels, which means 100 is full-blast and 75 is likely to be quiet. [bell tones]
es:@2280
Miller: @2295 So typically I put these close to 100. [bell tones]
es:@2295
Miller: This means nothing to people who weren't in the computer-music scene in the sixties and seventies, and then it means a lot because this is one of the classical @2310 computer-music designs done by Jean-Claude Risset at Bell Laboratories in Murray Hill back in the day when people were first doing things with computers. And what it is. .. let's see if I can make it sound better. [bell tones]
es:@2310
Miller: @2325 It's called a Risset Bell. And it's just Jean-Claude Risset having found some parameters somewhere that make a nice. .. [bell tones] Miller: ...bell sound, that can do that kind of stuff, or this kind of stuff, [bell tones]
es:@2325
Miller: @2340 Or of course, this kind of stuff. [bell tones] Miller: Actually, better yet. .. [bell tones]
es:@2340
Miller: Ta-da. It's not rocket science. @2355 What it is .. the old term for this was "additive synthesis." It's a synthesis technique that you all know because all you do is add up oscillators. And the oscillators in the examples
es:@2355
@2370 I've shown you have all been tuned to multiples of a fundamental frequency so that they all fuse into a harmonic sound. In this case it's additive synthesis in the sense that it's a bunch of sinusoidal oscillators being added together, but the oscillators are imitating the modes of vibration
es:@2370
@2385 of a bell. Although, I don't know if this corresponds to a real bell. ...[bell tones] Miller: ...or something fanciful. [bell tones]
es:@2385
Miller: And, the controls that you get are going to correspond exactly @2400 to the controls you saw in the sampler example last time, which is, you get to control pitch and duration.
es:@2400
Differences between this and the previous example -- There are going to be a couple of differences when you get into the voices, but @2415 there's a huge conceptual difference: Which is that this isn't a polyphonic instrument.
es:@2415
It only plays one note. But there's still voices, adding up @2430 to that one note. And the voices are, instead of making different notes, making different partials which added up into a single note.
es:@2430
It's polyphony in one way of thinking, because it's realized like a @2445 polyphonic instrument. But psychologically, it's monophonic. So it's showing the use of voicing and abstractions, in a non voice-allocating way.
es:@2445
A key difference between this and the previous example is @2460 there's no route object. In the previous example, you decided every time you asked to play a note, which of the voices was going to play it. Here, all the voices play every single note. ... Yeah? Student: And those voices are the partial voices?
es:@2460
Miller: Yes, right. So now I have to show you @2475 what's in there. Student: So do we'll look inside the patch?
es:@2475
Miller: Yeah. Next thing is, notice that I'm feeding the thing arguments. I'll tell you what the arguments mean in a moment when I show you what's inside it. But @2490 when you have an abstraction -- which is to say an object which is a separate patch being written into a window --
es:@2490
Usually, not quite always, but in most situations -- You're going to want to throw in arguments to specialize it to do one thing @2505 or another. For instance in this case, each of these partials has to know which partial it is, so they don't all decide to play the first partial together. They each have to play different partials. So each one of them has to know which partial it is.
es:@2505
@2520 And to do that, you have to pass each one arguments that disambiguate them. That tell them how they are going to be specialized. All right?
es:@2520
Other huge difference @2535 and a small related difference to the huge difference: There aren't wires going into these things and inlets. So the mechanism for getting messages inside here is not inlets, it's "send" and "receive".
es:@2535
... For the simple reason that, @2550 and here's the small conceptual difference, frequency and duration and trigger are being sent separately in this design. I thought, at the time, this was actually a simplifying this, although I don't know now whether I think it's more simple or more complicated.
es:@2550
@2565 So in this particular design you give it any pitch and any duration you want and then you say, "OK go ahead" and then it does it for you.
es:@2565
You could now take a packed pair @2580 of "pitch and duration" and make it act like the previous one if you used an unpack and a trigger in order to send messages in the right order to duration and frequency and trigger.
es:@2580
@2595 So, what's going to happen inside here is each one of these things is going to have a receive frequency and a receive duration, which will tell it the global frequency and duration of the tone, and then it's going to have another receive for trigger, which will set the thing off.
es:@2595
@2610 Now, just to hearken back to Music 170 for a moment: This is imitating how a bell actually vibrates.
es:@2610
@2625 One way, maybe the best way, of thinking how a metallic object would vibrate is you strike it and in striking it you activate the modes of vibration the thing has. Those are functions of the shape and construction of the object itself,
es:@2625
@2640 not of how you whacked it. They don't move. But the modes each have a frequency and a time constant. The frequency is how fast the mode vibrates and the time constant is how fast it's damped:
es:@2640
whether it vibrates forever, @2655 which it would do if it had no damping at all, or whether it dies out very, very quickly. So what's happening here is we're pretending there's a metal object that has 11 modes in it, each of which has a
es:@2655
@2670 different frequency and a different damping.
es:@2670
But then there are global frequency and duration (which is damping), controls that are multiplied by each one's individual frequency and damping factor. @2685 Now, to go look inside "partial", which I've been putting off: Here's how you do a partial. This is being done in gory detail in the most
es:@2685
@2700 carefully explained, boring, pedagogical possible way. Let's see. I can do this.
es:@2700
@2715 I haven't told you this and probably shouldn't tell you this now, but
es:@2715
@2730 line~ generates line segments and if you want a line segment to feel like an exponential just raise it to the fourth power.
es:@2730
Then instead of going down like this in time <<straight line>> it goes down like this in time <<a curve which falls rapidly and then more slowly>>. @2745 Then it's not exactly an exponential, but it's pretty good. What that means exactly is explained in chapter 4 <<pp 92-93>> of the book, so you can look it up if you don't believe me. But the signal processing aspect of this is being done here.
es:@2745
@2760 What you see is an oscillator and a line~.
es:@2760
I'm raising the line~ to the fourth power so it will go down more @2775 exponentially than just a line segment would. Then I'm multiplying it by the oscillator then I'm introducing a new object, "throw~", which I'll not dwell on right now.
es:@2775
@2790 I didn't even tell you about send~ ... This is a way of avoiding having an outlet by asking a Pd to set up a "summing bus." In other words, what's happening is somewhere there's a "catch~ sum",
es:@2790
@2805 which is automatically going to get the sum of all these signals.
es:@2805
It's a good thing, but it's not a thing that you absolutely need to know right now, so I'm going to not dwell on it but just sort of say that's what's happening. This is like dac~. @2820 In fact, it could be dac~ except that I wanted to be able to use the "output" thing I showed you earlier. So, instead of just putting the dac right here I put a "throw~" and it all collects in this "catch~" and then it goes to this output object
es:@2820
@2835 where I'm controlling the amplitude for output. All right. Student: Can you play them all at the same time?
es:@2835
Miller: Actually, it's so I can control the volumes of them all in parallel. ... @2850 this is controlling globally
es:@2850
@2865 the amplitude of the thing by virtue of the fact that each one of these partials, using the "throw~" object, has added itself at full strength to this "catch~", which then is going to be sent
es:@2865
@2880 to the "output~" which will control its amplitude. So that's controlling all the amplitudes in parallel. Yeah? Student: So it's like a send and receive for multiple things going to the send box?
es:@2880
Miller: Right. So send and receive work for messages. There's a send~ and a receive~ for signals, but in audio signal land @2895 the situation's a little bit more complicated. Because it would not be clear what to do if you had a bunch of sends and a bunch of receives. In message land, you just send all the sends to all the receives. Student: So like a patch bay?
es:@2895
Miller: Yeah. It is exactly like the patch bay. So here what's happening is @2910 all of the throws are throwing to the single catch. There's a fan-in thing, which is a summing bus, which is done by throw~ and catch~. And there's also a fan-out mechanism, which is accomplished by send~ and receive~, which I haven't shown you. ... Yeah. Student: So you can sequence them as well, going into the catch?
es:@2910
Miller: @2925 No. It's like cables. So they're happening in parallel.
es:@2925
Miller: Right. So sequence. .. yeah. Only messages can be sequenced. Signals can't really be sequenced; they're all happening all the time -- @2940 which is one of the good reasons to have messages around. OK. Now the partial, is showing off ...
es:@2940
@2955 the arguments to this partial were these numbers:" 1, 1, 0.56, and 0". Those numbers are
es:@2955
@2970 what showed up here. ...
es:@2970
... Oh, there. So these numbers 1, 1, 0.56, 0, @2985 which are customizing this particular partial, are displayed here. <<in the title bar of the subpatch window>> And they are expanded by $1. Where did $1 go? Here. .. No, sorry. That was wrong.
es:@2985
@3000 I don't see $1 yet ... Here! In object boxes if you put a"$" sign, it is the argument you got called with as an abstraction.
es:@3000
And here there @3015 is one of the half dozen truly hard to understand things about Pd. Because dollar signs are also available inside message boxes, except that they have a different function
es:@3015
@3030 inside message boxes than they do inside objects.
es:@3030
This is all for a good reason because conceptually it is all very simple, even though it looks completely arbitrary and stupid. @3045 So, what I want to do is show you ... Just to help confuse you now, I'm going to show you message boxes with dollar signs inside.
es:@3045
So, "1 2 3" -- We all know what this will do. Let's see I'll put a number in. @3060 And I'll print it out. And then, no matter what I put in, the print out says, "Hi, I was 1, 2, and 3." All right. You can't even
es:@3060
@3075 see that this was getting repeated. Oh, I'll hit alt again. Alt, alt, alt. OK. Now suppose I want these numbers to vary as a function of this <<the number box connected to the message inlet>>. I can say, for instance $1. << 1 $1 3 >>.
es:@3075
@3090 And $1 means, give me the value that was the number that came in this message box.
es:@3090
I haven't shown you this because it was possible to do this already with pack. So, @3105 the easy way of getting this effect -- I had to do it once before when I had to do it in order to make triples of those numbers that went to the voices of the polyphonic sampler, two days ago.
es:@3105
Right? So this is another @3120 function of dollar signs. You can put a dollar sign inside a message and it will insert the number that you put in, as part of the message. And the 1 here, the $1, is which of these numbers it is.
es:@3120
If for instance, @3135 I gave it a packed message ... Let's see this example. Now $1 is 45.
es:@3135
@3150 That and $2 is 78. Those of you who have programmed shell scripts in either Macintosh-land or Linux, this is
es:@3150
@3165 exactly the same argument expansion that holds in Shell scripts. Also, I think perl may look this way, I'm not sure about that. The computer scientists have a name for this type of expansion, but I forget what it is. ... Yeah? Student: Can you add another inlet to the message box?
es:@3165
Miller: @3180 No. You could in Max, but here you actually have to use a pack object. ... So for instance, here's another perfectly good way
es:@3180
@3195 to make a message that has a bunch of variables in it. And now actually, at this point, I could now do this. And now I could set $2
es:@3195
@3210 this way, and $1 this way. OK. Since you have already seen pack this is not something that you need.
es:@3210
You will need it later perhaps, because @3225 certain things like. .. Oh right -- tables: If you want to tell a table what size it is, you say "resize" and then you give it a number. If you want that number to be a variable, then you have to say "re-size $1" inside a message box.
es:@3225
That's the only way to generate that kind of message. @3240 So this is a more general facility than pack. And as a result, it runs a little slower than pack too, so it's not necessarily the right way to do things in every case.
es:@3240
Now I told you that because I'm trying to confuse so that you will later on be enlightened. @3255 The confusing thing is this. If you put $1 inside a message box, or"$anything" inside a message box, it means the incoming message that's making me now send the message, right?
es:@3255
Because message boxes take messages in @3270 and then send messages out. Object boxes, what you put in an object box, is a message. It's a message whereby Pd makes the object and that message can have dollar-sign arguments in it, too, but those dollar sign arguments
es:@3270
@3285 are the arguments to the patch because the patch is running the message to make the object. ... Yeah? Student: Can you send object names that are variables inside? Create?
es:@3285
Miller: @3300 Yeah, if you really want to. For instance, "apply + 5",
es:@3300
@3315 if you're a list person. Well, let's make a nice thing called "apply". -- You don't want to do this. -- Apply is now going to say,
es:@3315
@3330 " $1, $2" ." Oh, come on, let me type in there.
es:@3330
All right. Then I'll make an inlet and an outlet just for fun. @3345 Pd hates me for doing this. It has no idea what $1 means in an object box like this. But now if I retype this I now have a nice little "plus five" thing.
es:@3345
@3360 OK, Go find a use for that ... Oh, does it actually work?
es:@3360
I don't think I've done this in a decade, so. @3375 It works. Yeah, don't do it. It's stupid. ... Oh yeah, dollar signs can either be numbers or they can be symbols. "Symbols", which means strings, things that aren't numbers like file names
es:@3375
@3390 or names of objects like "+".
es:@3390
Those are different kinds of data. For the most part I've only been using numbers except in the very rare occasions where I've had to specify a file name, like voice.wav. @3405 I'm doing that on purpose. I'm trying not to get any deeper into the soup of language complexity than one absolutely has to, to do computer music. So this is message boxes
es:@3405
@3420 and that apply example, was object boxes, but it was object boxes in such an abstruse example that I don't want to talk about anymore.
es:@3420
Oh, almost saving there, which is bad. Don't want to put it there. @3435 Let's just not save this. This is better explained somewhere else probably.
es:@3435
That was all to say this ... Next it's time to say, @3450 "What do these things mean?" This thing, this thing, that thing, and that thing. Well, this is a relative amplitude. This is a relative duration,
es:@3450
@3465 this is a relative frequency, and this is a de-tune, which is to say a frequency offset, a frequency that's added to it.
es:@3465
So we're talking about individual sinusoids, which are imitating individual modes at the sound of the bell. @3480 So each mode might have a different amplitude.
es:@3480
That's actually not acoustically correct because the amplitude would depend on how you struck the thing, but we're just pretending now. So each one is given its own amplitude, its own @3495 time constant, its own damping, which, in this example, just because Risset did it this way, is realized simply by changing the overall duration of the amount of time it rings.
es:@3495
The correct thing to do, acoustically, would be to have it be @3510 a dying exponential and to have it go on forever, but that's not practical, so we just give each partial a duration.
es:@3510
So ... first argument is amplitude, second argument is duration, third argument is frequency. @3525 Now I have to tell you something else. All these things, well not all these things, but the duration and the frequency are also controlled globally by the controls in the outer patch, which was here.
es:@3525
Miller: @3540 So there's a pitch and a duration. Those are things, which once they've gotten to the right units, will have to be multiplied by the relative frequencies
es:@3540
@3555 in order to figure out the real frequency to give the partial.
es:@3555
So this partial, which has a relative frequency of 0.56, what that really means is that it's 0.56 times the @3570 global frequency that I asked the bell to be. So that when I change this frequency the frequencies of all the partials change in parallel. [audio tone]
es:@3570
Miller: @3585 So how do we do that? What that means is we're going to have to take this thing which is being sent and multiply it by this number and that will become the frequency that we send the oscillator. Except I didn't tell you another thing.
es:@3585
@3600 You get a de-tune in here, which is after you multiply this factor by the global frequency then add an offset so that the partials can be paired
es:@3600
@3615 in beating combinations. This is all just history.
es:@3615
You can read this in books like the book by Charles Dodge. <<Computer Music: Synthesis, Composition, and Performance, ISBN 0-02-864682-7>> Here are 2 partials @3630 that have the same relative frequency, but one of them has an offset of nothing and the other has an offset of 1 Hertz. So, after they compute their base frequencies, this one adds 1 Hertz to itself so that it will beat with this one once per second, according to another principle
es:@3630
@3645 you saw in Music 170. So how do you do that?
es:@3645
What that means is that the oscillator that's inside here will get a frequency, in fact, which is 0.56 times @3660 this frequency plus this offset. So is that true? So, here we are: Every time we get a trigger we re-compute the frequency. Oh, by the way, the thing is designed
es:@3660
@3675 so that you hit the trigger and then you can start mousing away at the frequency -- And it doesn't change the frequency of the bell while it's ringing. Which, you know, is one possible way you could design the instrument. It's the way the original instrument worked, so maybe it's a good way for us to do it.
es:@3675
OK, so @3690 this is $1, this is $2, this is $3, and this is $4. Those are the arguments that we've got as a sub-object, as an abstraction. So $3 is a. ..
es:@3690
@3705 $3 will come out. .. OK, this, we're just going to store $3, and then when this thing gives us a bang, we will read $3. Oh, this is one voice that I'm triggering now, not the whole bell. [audio tone]
es:@3705
Miller: @3720 And $3 will come out here, it's 0.56, and it's going to get multiplied by a value, which is "receive frequency", <<r frequency>> which got sent from the main patch.
es:@3720
And then we're going to add $4, which is 0, which is the de-tuning. @3735 And that is the frequency for the oscillator. And all that stuff got done as messages, you can see the thin traces, and then the oscillator then is the first thing in this chain that makes an audio signal.
es:@3735
@3750 That's the easy part. Well, it's the easy part -- it does have two variables controlling it as opposed to one, but it's easy in the sense that now you just feed it as the frequency of the oscillator.
es:@3750
The amplitude control, @3765 as you know, things have to get turned on and then turned off, and so the amplitude control has more pussy-footing around setting the amplitude. So I'll show you that next. That's this: ... So the amplitude is
es:@3765
@3780 being controlled by line~.
es:@3780
Now, the amplitude ... There are two things that are being told us that are relevant to the amplitude: One is the first argument of the abstraction, this one here, is the relative amplitude of this voice. @3795 And the other is the length of time, the relative duration of the voice, because to know how to do an envelope generator you're going to have to know how high to make it, which is the amplitude that you're going to reach, and then you have to know how long to make it.
es:@3795
@3810 Here's the line~ that's going to do it, and by the way, I raised the line~ to the fourth power, I didn't say how -- But if you take a signal and square it,
es:@3810
@3825 then you get the signal to the second power.
es:@3825
And then if you take that thing and square it, then you get the signal to the fourth power. And why fourth power, not squared? Just so the thing will really hug 0 and go up like that, because that resembles more @3840 the exponential curve that this thing would really be doing in real life.
es:@3840
It's just hand-waving. There is no deep psycho-acoustical truth to this that I know of. OK. So what we have to do is configure or confect @3855 two messages to line~. This is a little bit like what we had to do for the sampler, except in the opposite order. You have to turn it on and then we have to turn it off. In the sampler actually, we had to do three things. We had to mute and then turn it on, and then turn it off. So this is simpler than the sampler in terms of
es:@3855
@3870 the sequence of the operations that has to take place.
es:@3870
OK. So the attack portion over here is: Look up $1 which is our amplitude. -- The attack portion is just going to go up to the amplitude and do it in five milliseconds, come what may. @3885 Why five milliseconds? It's a fast attack but it's not quite a clipped attack. ... Yeah? Student: What is happening to the dollar sign going in there?
es:@3885
Miller: The dollar sign? OK. So the dollar sign tells the float to substitute one of these arguments @3900 to the abstraction. Student: I mean it's in there trying to get a number? Miller: Yeah. So $1 gets this one, $2 gets that one, $3 gets that one and so on. Student: It's a "positional argument." Miller: It's a "positional argument." That's the correct word for it.
es:@3900
Student: @3915 OK. A positional parameter?
es:@3915
Miller: A "positional parameter" ? I'm not sure. OK. So this one, when it's built -- this is going to be float 1. And when it gets a bang, out is going to come the number 1. @3930 So this is just going to be 1. We're going to multiply by 0.1 to save our ears. Everything is going to get multiplied by 0.1 in parallel. And then because we are going to raise this to the fourth power ...
es:@3930
... We should probably take the fourth @3945 root of this, so when it gets raised by the fourth power, it's the right number. So to take a fourth root, you take a square root twice. And then here, I didn't have to do this; I should have done this. I think in the current context anyway
es:@3945
@3960 "pack 0 5", which would then take this value and would replace 0 with it and then pack a 5 which would be the number of milliseconds the line would ramp to that value in.
es:@3960
But instead, @3975 because I had just spent pages in the book describing this $1 madness, at this point it seemed appropriate to put dollar signs in messages. And so this is, "Make a message whose value is this number
es:@3975
@3990 and then 5." And here it is again -- the distinction between objects and messages and dollar signs:
es:@3990
Dollar sign inside an object means "in the context of when the patch is created, you have to build this thing." And so the dollar sign is evaluated @4005 when the patch is created. And it's created with these arguments. Dollar sign here <<in a message box>> is in the context of the message that it is sent, which is the thing which causes to send a message itself.
es:@4005
@4020 So this is in the "run-time context" if you like, and this is in the "build-time context", or something like that. ... Yeah.
es:@4020
Student: Why do you need @4035 the trigger there when one of the bang has gone through?
es:@4035
Miller: You don't. The only reason that trigger's there is to make this thing a little prettier. Oh, it's psychological. It's to group these two things. @4050 But, in fact, it has no function because you're quite right, this delay would ensure this thing happens after this thing anyway. OK. If only this existed and not that then
es:@4050
@4065 you would get this: [audio tone] Miller: The attack shape of the envelope and no decay shape. [audio tone] I'm going to do this to make it shut up. ...
es:@4065
Miller: As it is, you do that and then you decay @4080 and decaying is actually easier than attacking. It is ... We wait five milliseconds because the attack took five milliseconds. We wait for the line~ to get up to its apex and then we start the decay portion of the envelope,
es:@4080
@4095 which is: Look up the duration. -- OK, so the attack is five milliseconds regardless of the duration. -- The decay, now, we know what the target is, it's going to go down to 0 so it'll shut up. But what we don't
es:@4095
@4110 know yet is how long it's going to take in order to get there.
es:@4110
That, we have to now compute. So we're going to make a message again, but whereas the message in this case had a constant time but a variable amount that it went up. @4125 In this case it has a constant that it goes down to, which is 0, but a variable amount of time to do it in.
es:@4125
How do you compute that? Well, after five milliseconds when it's time to start doing this, @4140 pick up the value $2, which is this value. (It's 1 here, but it will be different numbers for the different partials.) Multiply it by the global duration. That was sent to us
es:@4140
@4155 there. Student: Was it 800?
es:@4155
Miller: Yeah, it's 800. So this duration is 800. But this is now 1, so this is going to be 1 times 800, which is 800 again, so this will be the message 0 800. @4170 So that means this thing should last eight tenths of a second. [audio tone]
es:@4170
Hard to tell because it dies out inaudibly. Now if I get another one out, @4185 this one, this one will be higher and lower. [audio tones] There's a longish one. Here's a short-ish one with a higher pitch and a shorter decay. [audio tone]
es:@4185
That's because @4200 here, the arguments are ... we're louder.
es:@4200
We're a relative loudness of 1.46, relative duration only a quarter as long. @4215 So this thing lasts 1 quarter as long as the other one did. Then the frequency is 2 as opposed to this frequency, which was 0.56, so it's almost two octaves up. ....
es:@4215
Student: @4230 Decays can multiply by the total duration message, I'm still confused about that $1. I understand that $2, that's the parameter, but partials, the second one, what's coming out of that?
es:@4230
Miller: @4245 So what goes in here is $2. $2 here is 0.25, so it's going to multiply 0.25 by 800, which is duration, so it will get
es:@4245
@4260 200 here. So this will become the message 0 200. Student: And the other one is computed?
es:@4260
Miller: The other one here. ... I don't know what the amplitude is, but it would be that number 5. So this @4275 is 0 200 and blah 5 -- something 5. All right. So if you hear all these things together. [audio tone] ...
es:@4275
Miller: @4290 You get beautiful computer music. [audio tone]
es:@4290
Miller: There's some psycho-acoustics there, too. @4305 You can pick this up; this was in the help browser,
es:@4305
@4320 "D07.additive.pd" This is the first example in the Pd examples, I think, of something that does multiple voices and there are two others of note here that I want to show you, that I will get to next time.
es:@4320
@4335 Oh, homework. The homework is just what you've heard done. Do I have the patch that does it? I can't remember. ...a
es:@4335
@4350
es:@4350
@4365 Missed it ... Close that. This is wrong. [audio tone]
es:@4365
@4380 Oh, there it is: [audio tone] Miller: Isn't that its own antithesis? [audio tone]
es:@4380
Miller: So you all know how to do this because it's nothing but a looping sampler, @4395 you're just going to have to figure out how to get it the appropriate original pitch, but last a lot longer than it would have lasted. And envelope it so it doesn't sound buzzy.
es:@4395
@4410 So, it's a straightforward application of what I've been showing you the past couple of days.
es:@4410