DIRECTORY
Jukebox USING [Handle, WindowOrigin, Error, Tune, Info, FindClientSpace, magicTuneHeader, RunArrayRange, RunComponent, bytesPerChirp, pagesPerChirp, FindChirp, singlePktLength, MissingChirp, LengthRange, EnergyRange, RunData, EOF, RunArray, bytesPerMS], 
VM USING [Allocate, Interval, AddressForPageNumber, Free],
File USING [wordsPerPage],
FS USING [Read, Write],
PrincOps USING [ByteBltBlock],
PrincOpsUtils USING [ByteBlt],
TuneAccess;

TuneAccessImpl: CEDAR PROGRAM IMPORTS Jukebox, VM, FS, PrincOpsUtils EXPORTS TuneAccess SHARES Jukebox =
BEGIN OPEN TuneAccess;

NextTuneNumber: PUBLIC PROC [jukebox: Jukebox.Handle, currentTuneID: INT _ -1] RETURNS [tuneID: INT] = TRUSTED {
headerWindow: Jukebox.WindowOrigin;
space: VM.Interval _ VM.Allocate[count: 1];
tuneFirstDiskHeaderPage: Jukebox.Tune _ LOOPHOLE[VM.AddressForPageNumber[page: space.page]];-- name is a reminder only to use those parts which reside on disk and no more than the first page thereof
tuneFound: BOOLEAN _ FALSE;
tuneHWM: INT;

IF currentTuneID < -1 THEN currentTuneID _ -1;
IF jukebox.hdr = NIL THEN ERROR Jukebox.Error[reason: NoJukebox, rope: "Jukebox not open"];
[tuneHWM: tuneHWM] _ Jukebox.Info[jukebox];

DO 
currentTuneID _ currentTuneID + 1; 
IF currentTuneID > tuneHWM THEN EXIT;
headerWindow.file _ jukebox.window.file;
headerWindow.base _ jukebox.firstDesPageNumber + 2*currentTuneID;
FS.Read[file: headerWindow.file, from: headerWindow.base, nPages: space.count, to: VM.AddressForPageNumber[space.page]];
tuneFound _ tuneFirstDiskHeaderPage.state = inUse;
IF tuneFound THEN EXIT
ENDLOOP;

VM.Free[space];
RETURN [IF tuneFound THEN currentTuneID ELSE -1]
};

ReadTuneHeader: PUBLIC PROC [jukebox: Jukebox.Handle, tune: Jukebox.Tune, nBytes: CARDINAL _ userHeaderLength, block: ByteBlock _ NIL] RETURNS [ByteBlock] = TRUSTED {
headerFileWindow: Jukebox.WindowOrigin;
headerVMWindow: VM.Interval;
byteBltBlockOfVMWindow: PrincOps.ByteBltBlock;
pointerToSequence: LONG POINTER;
byteBltBlockOfSequence: PrincOps.ByteBltBlock;
bytesBlted: INT;

IF nBytes>userHeaderLength THEN nBytes _ userHeaderLength;
IF jukebox.hdr = NIL THEN ERROR Jukebox.Error[reason: NoJukebox, rope: "Jukebox not open"];
IF tune.magic # Jukebox.magicTuneHeader THEN ERROR Jukebox.Error[BadTunePointer, "Corrupt tune or tune pointer"];
IF block = NIL OR block.max<nBytes THEN block _ NEW[ByteSequence[nBytes]];
block.length _ 0; -- until otherwise shown

headerFileWindow _ Jukebox.FindClientSpace[jukebox, tune.tuneId];
headerVMWindow _ VM.Allocate[count: 1];
byteBltBlockOfVMWindow _ [LOOPHOLE[VM.AddressForPageNumber[headerVMWindow.page]],  0, nBytes];
pointerToSequence _ LOOPHOLE[block]; -- this rather grotty code points us beyond the 
pointerToSequence _ pointerToSequence + SIZE[ByteSequence[0]]; -- sequence header, to where
byteBltBlockOfSequence _ [pointerToSequence, 0, nBytes]; -- the elements should be

FS.Read[file: headerFileWindow.file, from: headerFileWindow.base, nPages: 1, to: VM.AddressForPageNumber[headerVMWindow.page]];
bytesBlted _ PrincOpsUtils.ByteBlt[from: byteBltBlockOfVMWindow, to: byteBltBlockOfSequence];
VM.Free[headerVMWindow];

IF bytesBlted # nBytes THEN ERROR ELSE block.length _ nBytes;
RETURN [block]
};


WriteTuneHeader: PUBLIC PROC [jukebox: Jukebox.Handle, tune: Jukebox.Tune, block: ByteBlock, nBytes: CARDINAL _ userHeaderLength] = TRUSTED {
headerFileWindow: Jukebox.WindowOrigin;
headerVMWindow: VM.Interval;
byteBltBlockOfVMWindow: PrincOps.ByteBltBlock;
pointerToSequence: LONG POINTER;
byteBltBlockOfSequence: PrincOps.ByteBltBlock;
bytesBlted: INT;

nBytes _ MIN[nBytes, userHeaderLength, block.length]; 
IF jukebox.hdr = NIL THEN ERROR Jukebox.Error[reason: NoJukebox, rope: "Jukebox not open"];
IF tune.magic # Jukebox.magicTuneHeader THEN ERROR Jukebox.Error[BadTunePointer, "Corrupt tune or tune pointer"];
headerFileWindow _ Jukebox.FindClientSpace[jukebox, tune.tuneId];
headerVMWindow _ VM.Allocate[count: 1];
byteBltBlockOfVMWindow _ [LOOPHOLE[VM.AddressForPageNumber[headerVMWindow.page]],  0, nBytes];
pointerToSequence _ LOOPHOLE[block]; -- this rather grotty code points us beyond the 
pointerToSequence _ pointerToSequence + SIZE[ByteSequence[0]]; -- sequence header, to where
byteBltBlockOfSequence _ [pointerToSequence, 0, nBytes]; -- the elements should be

FS.Read[file: headerFileWindow.file, from: headerFileWindow.base, nPages: 1, to: VM.AddressForPageNumber[headerVMWindow.page]];
bytesBlted _ PrincOpsUtils.ByteBlt[from: byteBltBlockOfSequence, to: byteBltBlockOfVMWindow];
IF bytesBlted # nBytes 
THEN {VM.Free[headerVMWindow]; ERROR}
ELSE
{ 	
FS.Write[file: headerFileWindow.file, to: headerFileWindow.base, nPages: 1, from:
VM.AddressForPageNumber[headerVMWindow.page]];
VM.Free[headerVMWindow]
}
};
ReadRunArray: PUBLIC PROC [jukebox: Jukebox.Handle, tune: Jukebox.Tune, chirpNumber: INT, runArray: REF Jukebox.RunArray _ NIL] RETURNS [REF Jukebox.RunArray] = TRUSTED {
runArrayFileWindow: Jukebox.WindowOrigin;
runArrayVMWindow: VM.Interval;
byteBltBlockOfVMWindow: PrincOps.ByteBltBlock;
byteBltBlockOfResult: PrincOps.ByteBltBlock;
bytesBlted: INT;

pageOffsetInChirp: INT =  Jukebox.bytesPerChirp/(File.wordsPerPage*2);
byteOffsetInPage: INT =  Jukebox.bytesPerChirp MOD (File.wordsPerPage*2);
runDataPages: INT = Jukebox.pagesPerChirp - pageOffsetInChirp;
runArrayBytes: INT = (LAST[Jukebox.RunArrayRange] - FIRST[Jukebox.RunArrayRange] + 1)*2;

IF runArray = NIL THEN runArray _ NEW[ARRAY Jukebox.RunArrayRange OF Jukebox.RunComponent];
runArrayFileWindow _ Jukebox.FindChirp[self: jukebox, tune: tune, chirp: chirpNumber, signalMissingChirp: TRUE, signalEOF: TRUE];
runArrayFileWindow.base _ runArrayFileWindow.base + pageOffsetInChirp;

runArrayVMWindow _ VM.Allocate[count: runDataPages];
byteBltBlockOfVMWindow _ [LOOPHOLE[VM.AddressForPageNumber[runArrayVMWindow.page]],  byteOffsetInPage, byteOffsetInPage + runArrayBytes];
byteBltBlockOfResult _ [LOOPHOLE[runArray], 0, runArrayBytes];

FS.Read[file: runArrayFileWindow.file, from: runArrayFileWindow.base, nPages: runDataPages, to: VM.AddressForPageNumber[runArrayVMWindow.page]];
bytesBlted _ PrincOpsUtils.ByteBlt[from: byteBltBlockOfVMWindow, to: byteBltBlockOfResult];
VM.Free[runArrayVMWindow];

IF bytesBlted # runArrayBytes THEN ERROR;
RETURN [runArray];
};

InterpretRunArrayElement: PUBLIC PROC [runArray: REF Jukebox.RunArray, currArrayIndex: Jukebox.RunArrayRange] RETURNS [length: Jukebox.LengthRange, energy: Jukebox.EnergyRange, skipNextArrayElement: BOOLEAN _ FALSE, silence: BOOLEAN _ FALSE]  = {
 WITH currEl: runArray[currArrayIndex] SELECT FROM
silence =>
{	length _ currEl.length;
energy _ 0;
silence _ TRUE
};
singlePkt =>
{	length _ Jukebox.singlePktLength;
energy _ currEl.energy
};
soundEnergy =>
{	energy _ currEl.energy;
length _ NARROW[runArray[currArrayIndex+1], Jukebox.RunComponent[soundLength]].length;
skipNextArrayElement _ TRUE
};
ENDCASE => ERROR;
};

GetEnergyProfile: PUBLIC PROC [jukebox: Jukebox.Handle, tune: Jukebox.Tune, chirpNumber: INT, energyBlock: EnergyBlock _ NIL, divisions: INT _ Jukebox.bytesPerChirp/Jukebox.singlePktLength, signalMissingChirp: BOOLEAN _ FALSE] RETURNS [EnergyBlock] = {
ENABLE Jukebox.MissingChirp =>
{ IF signalMissingChirp THEN REJECT ELSE
{ FOR i: NAT IN [0..energyBlock.length) DO  energyBlock[i] _ 0 ENDLOOP;
GOTO ReturnEnergyBlock
}
};

runArray: REF ARRAY Jukebox.RunArrayRange OF Jukebox.RunComponent;
endOfLastDivision: Jukebox.LengthRange;
divisionSize: INT;
currDivision: INT _ 0;
endOfCurrDivision: Jukebox.LengthRange;
endOfCurrRunElement: Jukebox.LengthRange _ 0;
energyOfCurrRunElement: Jukebox.EnergyRange;
currRunArrayIndex: Jukebox.RunArrayRange _ 0;
samplesAccountedFor: Jukebox.LengthRange _ 0;
samplesBeingAccounted: Jukebox.LengthRange;
energyAccumulator: INT _ 0;

NextRunElement: PROC RETURNS [energyOfCurrRunElement: Jukebox.EnergyRange] = INLINE {
length: Jukebox.LengthRange;
dualElementRepresentation: BOOLEAN;
[length: length, energy: energyOfCurrRunElement, skipNextArrayElement: dualElementRepresentation] _ InterpretRunArrayElement[runArray,  currRunArrayIndex];
currRunArrayIndex _ currRunArrayIndex + (IF dualElementRepresentation THEN 2 ELSE 1);
endOfCurrRunElement _ endOfCurrRunElement + length
};

IF divisions < 1 OR divisions>Jukebox.bytesPerChirp THEN ERROR;
divisionSize _ Jukebox.bytesPerChirp/divisions;
endOfLastDivision _ divisionSize*divisions;
endOfCurrDivision _ divisionSize;

IF energyBlock = NIL OR energyBlock.max<divisions THEN energyBlock _ NEW[EnergySequence[divisions]];
energyBlock.length _ divisions;

runArray _ ReadRunArray[jukebox: jukebox, tune: tune, chirpNumber: chirpNumber, runArray: NIL];

WHILE endOfCurrDivision <= endOfLastDivision DO
WHILE samplesAccountedFor < endOfCurrDivision DO
IF samplesAccountedFor >= endOfCurrRunElement 
THEN energyOfCurrRunElement _ NextRunElement[];
samplesBeingAccounted _ MIN[endOfCurrRunElement, endOfCurrDivision] - samplesAccountedFor;
energyAccumulator _ energyAccumulator + INT[samplesBeingAccounted]*INT[energyOfCurrRunElement];
samplesAccountedFor _ samplesAccountedFor + samplesBeingAccounted
ENDLOOP;

energyBlock[currDivision] _ energyAccumulator/INT[divisionSize];
energyAccumulator _ 0;
currDivision _ currDivision + 1;
IF endOfCurrDivision = Jukebox.bytesPerChirp THEN EXIT ELSE endOfCurrDivision _ endOfCurrDivision + divisionSize
ENDLOOP;

RETURN[energyBlock];
 
EXITS -- for handling MissingChirp error
ReturnEnergyBlock => RETURN[energyBlock]
};

ReadChirpSamples: PUBLIC PROC [jukebox: Jukebox.Handle, tune: Jukebox.Tune, chirpNumber: INT, nBytes: CARDINAL _ Jukebox.bytesPerChirp, block: ByteBlock _ NIL] RETURNS [ByteBlock] = TRUSTED {
sampleFileWindow: Jukebox.WindowOrigin;
sampleVMWindow: VM.Interval;
byteBltBlockOfVMWindow: PrincOps.ByteBltBlock;
pointerToSequence: LONG POINTER;
byteBltBlockOfSequence: PrincOps.ByteBltBlock;
bytesBlted: INT;
filePagesToRead: INT;

IF nBytes>Jukebox.bytesPerChirp THEN nBytes _ Jukebox.bytesPerChirp;
filePagesToRead _ (nBytes+(File.wordsPerPage*2)-1)/(File.wordsPerPage*2);

IF block = NIL OR block.max<nBytes THEN block _ NEW[ByteSequence[nBytes]];
block.length _ 0; -- until otherwise shown

sampleFileWindow _ Jukebox.FindChirp[self: jukebox, tune: tune, chirp: chirpNumber, signalMissingChirp: TRUE, signalEOF: TRUE];

sampleVMWindow _ VM.Allocate[count: filePagesToRead];
byteBltBlockOfVMWindow _ [LOOPHOLE[VM.AddressForPageNumber[sampleVMWindow.page]],  0, nBytes];
pointerToSequence _ LOOPHOLE[block]; -- this rather grotty code points us beyond the 
pointerToSequence _ pointerToSequence + SIZE[ByteSequence[0]]; -- sequence header, to where
byteBltBlockOfSequence _ [pointerToSequence, 0, nBytes]; -- the elements should be

FS.Read[file: sampleFileWindow.file, from: sampleFileWindow.base, nPages: filePagesToRead, to: VM.AddressForPageNumber[sampleVMWindow.page]];
bytesBlted _ PrincOpsUtils.ByteBlt[from: byteBltBlockOfVMWindow, to: byteBltBlockOfSequence];
VM.Free[sampleVMWindow];

IF bytesBlted # nBytes THEN ERROR ELSE block.length _ nBytes;
RETURN [block]
};

ChirpFormat: TYPE = REF ChirpFormatRecord;

ChirpFormatRecord: TYPE = RECORD
[ elementsPlus1: Jukebox.RunArrayRange, 
array: ARRAY Jukebox.RunArrayRange OF RECORD
[  length: Jukebox.LengthRange, -- length of this lump
storedBase: Jukebox.LengthRange, -- where in the chirp it is stored
trueBase:  Jukebox.LengthRange, -- the correct position in time that it represents
silence: BOOLEAN
]
];

ReadFormattedSamples: PUBLIC PROC [jukebox: Jukebox.Handle, tune: Jukebox.Tune, chirpNumber: INT, block: ByteBlock _ NIL, encryptedSilence: EncryptedSilence _ NIL, signalMissingChirp: BOOLEAN _ FALSE] RETURNS [ByteBlock] = {
ENABLE Jukebox.MissingChirp =>
{ IF signalMissingChirp THEN REJECT ELSE
{  sampleNumber, silenceNumber: INT _ 0;
WHILE sampleNumber < Jukebox.bytesPerChirp DO
block[sampleNumber] _ encryptedSilence[silenceNumber];
sampleNumber _ sampleNumber + 1;
silenceNumber _ (silenceNumber + 1) MOD Jukebox.bytesPerMS
ENDLOOP;
GOTO Quit
}
};

runArray: REF Jukebox.RunArray;
chirpFormat: ChirpFormat _ NEW[ChirpFormatRecord];
samplesAccounted: Jukebox.LengthRange _ 0;
newLength: Jukebox.LengthRange;
skipNextArrayElement, currentlySilence: BOOLEAN;
currArrayIndex: Jukebox.RunArrayRange _ 0;
validSamples: Jukebox.LengthRange;

IF block = NIL OR block.max<Jukebox.bytesPerChirp THEN block _ NEW[ByteSequence[Jukebox.bytesPerChirp]];
IF encryptedSilence = NIL THEN encryptedSilence _ NEW[EncryptedSilenceArray _ ALL[0]];

runArray _ ReadRunArray[jukebox, tune, chirpNumber, NIL];
chirpFormat.elementsPlus1 _ 0;
chirpFormat.array[0].length _ 0; -- set up the first element as sound, length 0
chirpFormat.array[0].storedBase _ 0;
chirpFormat.array[0].trueBase _ 0;
chirpFormat.array[0].silence _ FALSE;
WHILE samplesAccounted < Jukebox.bytesPerChirp DO
[length: newLength, skipNextArrayElement: skipNextArrayElement, silence: currentlySilence] _ InterpretRunArrayElement[runArray, currArrayIndex];
samplesAccounted _ samplesAccounted + newLength;
currArrayIndex _ currArrayIndex + (IF skipNextArrayElement THEN 2 ELSE 1);

IF chirpFormat.array[chirpFormat.elementsPlus1].silence # currentlySilence THEN 
{  chirpFormat.elementsPlus1 _ chirpFormat.elementsPlus1 + 1;
chirpFormat.array[chirpFormat.elementsPlus1].length _ 0;
chirpFormat.array[chirpFormat.elementsPlus1].storedBase _ chirpFormat.array[chirpFormat.elementsPlus1-1].storedBase + (IF currentlySilence THEN chirpFormat.array[chirpFormat.elementsPlus1-1].length ELSE 0); -- think about it!!
chirpFormat.array[chirpFormat.elementsPlus1].trueBase _ chirpFormat.array[chirpFormat.elementsPlus1-1].trueBase + chirpFormat.array[chirpFormat.elementsPlus1-1].length;
chirpFormat.array[chirpFormat.elementsPlus1].silence _ currentlySilence
};

chirpFormat.array[chirpFormat.elementsPlus1].length _ chirpFormat.array[chirpFormat.elementsPlus1].length + newLength
ENDLOOP;

validSamples _ chirpFormat.array[chirpFormat.elementsPlus1].storedBase + (IF ~chirpFormat.array[chirpFormat.elementsPlus1].silence THEN chirpFormat.array[chirpFormat.elementsPlus1].length ELSE 0);
block _ ReadChirpSamples[jukebox, tune, chirpNumber, validSamples, block];
FOR el: Jukebox.RunArrayRange DECREASING IN [0..chirpFormat.elementsPlus1] DO
IF chirpFormat.array[el].silence
THEN -- okay to do this loop forwards as it doesn't involve any copies
{  currSample: Jukebox.LengthRange _ chirpFormat.array[el].trueBase;
lastSamplePlus1: Jukebox.LengthRange _ currSample + chirpFormat.array[el].length;
silenceNumber: INT _ 0;
WHILE currSample < lastSamplePlus1 DO
block[currSample] _ encryptedSilence[silenceNumber];
currSample _ currSample + 1;
silenceNumber _ (silenceNumber + 1) MOD Jukebox.bytesPerMS
ENDLOOP;
IF silenceNumber # 0 THEN ERROR; -- silence/sound runs must be multiples of 8!!!!
}
ELSE
{  IF (chirpFormat.array[el].length MOD 8) # 0 THEN ERROR;
IF ~(chirpFormat.array[el].trueBase = chirpFormat.array[el].storedBase OR chirpFormat.array[el].length = 0) 
THEN WimpFakeReverseByteBlt[block: block, from: chirpFormat.array[el].storedBase, to: chirpFormat.array[el].trueBase, nBytes: chirpFormat.array[el].length]
}
ENDLOOP;

block.length _ Jukebox.bytesPerChirp;
RETURN[block]
EXITS
Quit =>
{  block.length _ Jukebox.bytesPerChirp;
RETURN[block]
}
};
WimpFakeReverseByteBlt: PROC [block: ByteBlock, from: Jukebox.LengthRange, to: Jukebox.LengthRange, nBytes: Jukebox.LengthRange] = INLINE {
destCounter: INT _ to + nBytes - 1;
FOR sourceCounter: INT DECREASING IN [from..from+nBytes) DO
block[destCounter] _ block[sourceCounter];
destCounter _ destCounter - 1
ENDLOOP
};
ReadAmbientLevel: PUBLIC PROC [jukebox: Jukebox.Handle, tune: Jukebox.Tune, chirpNumber: INT] RETURNS [ambientLevel: Jukebox.EnergyRange] = TRUSTED {
runDataFileWindow: Jukebox.WindowOrigin;
runDataVMWindow: VM.Interval;
runData: Jukebox.RunData;

pageOffsetInChirp: INT = Jukebox.bytesPerChirp/(File.wordsPerPage*2);
byteOffsetInPage: INT = Jukebox.bytesPerChirp MOD (File.wordsPerPage*2);
runDataPages: INT = Jukebox.pagesPerChirp - pageOffsetInChirp;

runDataFileWindow _ Jukebox.FindChirp[self: jukebox, tune: tune, chirp: chirpNumber, signalMissingChirp: TRUE, signalEOF: TRUE];
runDataFileWindow.base _ runDataFileWindow.base + pageOffsetInChirp;

runDataVMWindow _ VM.Allocate[count: 1];
runData _ VM.AddressForPageNumber[runDataVMWindow.page] + (byteOffsetInPage/2);

FS.Read[file: runDataFileWindow.file, from: runDataFileWindow.base, nPages: runDataPages, to: VM.AddressForPageNumber[runDataVMWindow.page]];

ambientLevel _ runData.ambientLevel;
VM.Free[runDataVMWindow]
};
WriteAmbientLevel: PUBLIC PROC [jukebox: Jukebox.Handle, tune: Jukebox.Tune, ambientLevel: Jukebox.EnergyRange, fromChirp: INT, toChirp: INT] = TRUSTED {
runDataFileWindow: Jukebox.WindowOrigin;
runDataVMWindow: VM.Interval;
runData: Jukebox.RunData;

pageOffsetInChirp: INT = Jukebox.bytesPerChirp/(File.wordsPerPage*2);
byteOffsetInPage: INT = Jukebox.bytesPerChirp MOD (File.wordsPerPage*2);
runDataPages: INT = Jukebox.pagesPerChirp - pageOffsetInChirp;

IF fromChirp < 0 THEN ERROR;
IF toChirp = -1 THEN toChirp _ tune.size - 1;
IF toChirp < fromChirp THEN toChirp _ fromChirp;
IF toChirp >= tune.size THEN  ERROR Jukebox.EOF[];

runDataVMWindow _ VM.Allocate[count: 1];
runData _ VM.AddressForPageNumber[runDataVMWindow.page] + (byteOffsetInPage/2);
FOR chirp: INT IN [fromChirp..toChirp] DO
ENABLE
Jukebox.MissingChirp => LOOP;

runDataFileWindow _ Jukebox.FindChirp[self: jukebox, tune: tune, chirp: chirp, signalMissingChirp: TRUE, signalEOF: TRUE];
runDataFileWindow.base _ runDataFileWindow.base + pageOffsetInChirp;

FS.Read[file: runDataFileWindow.file, from: runDataFileWindow.base, nPages: runDataPages, to: VM.AddressForPageNumber[runDataVMWindow.page]];
runData.ambientLevel _ ambientLevel;
FS.Write[file: runDataFileWindow.file, to: runDataFileWindow.base, nPages: runDataPages, from: VM.AddressForPageNumber[runDataVMWindow.page]]
ENDLOOP;

VM.Free[runDataVMWindow]
};
END.

dFILE: TuneAccessImpl.mesa
Ades, February 27, 1986 6:17:12 pm PST
   
This really ought not to be fully implemented in here: it ought to call a procedure FindHeaderSpace analogous to FindClientSpace in Jukebox. But FindClientSpace is not an entry procedure, so why bother?


after all the statutory checks, do we need to allocate space for the return block?



these constants make it clearer whence to pick up the run length data
each runArray element is machine dependent and two bytes long

no need to check if jukebox and tune specifications are okay, since FindChirp must do so
work out how many pages are needed to get all the data from disk -- it starts on the first byte of the chirp's first page
no need to check if jukebox and tune specifications are okay, since FindChirp must do so
internal working record used by ReadFormattedSamples for restructuring the samples in a chirp 
count of how many of the following are actually in use + 1
for efficiency this routine works out how the chirp divides into sound and silence, reads the samples straight from the jukebox into the return array and then ByteBlts maximally sized blocks, ingoring any lumps already in correct place. This is efficient in that the chirps usually have very few silence/sound transitions and many are 100% sound. Alas this needs a reverse byteblt operation, which is not implemented on Dorados although part of PrincOps. Since most chirps are entirely sound, writing a fake reverse byte blt isn't as bad a solution as it seems!

first allocate any blocks required, since ReadRunArray may well produce a signal of MissingChirp
now read the run array and from it build the ChirpFormat record
we now know amongst other things how many samples are stored on disk: read them and then use the chirpFormat to reposition them: it goes without saying that we need to work backwards through the chirpFormat list to avoid overwriting things incorrectly!




these constants make it clearer whence to pick up the RunDataObject - which ends in the ambient level (a single 16 bit field)
the code below picks up the entire RunDataObject, even if it means reading more than one page to do so. This is so that the code wouldn't stop working if the run data were to stretch across more than one page, but does not impede efficiency since this is only a very remote possibility [a major implementation change] 
no need to check if jukebox and tune specifications are okay, since FindChirp must do so
the above line seems to blow up if byteOffsetInpage is odd: however I'm not going to test for it because (i) the entire jukebox blows up (ii) it would do so in the same way and this line would effectively still be correct (iii) no clown is going to make bytesPerChirp odd anyhow

all the comments from ReadAmbientlevel apply here too
error signalled here to avoid half the chirps becoming updated before it is signalled by Jukebox.FindChirp






Κ˜š
œ™J™&—Jš
œ™š
Οk	˜	JšœœΥ
œ˜ώ
Jšœ
œ2˜:Jšœœ˜Jšœ
œ˜Jšœ	œ˜Jšœœ˜Jš
œ˜—Jšœœ
œ
œ
œœœœ
˜hJšœ
œ˜J˜šΟnœœ
œ*œœ
œœ˜pJ™Κ
J™Jš
œ#˜#Jšœœœ˜+Jšœ(œ
œ)Οcj˜Ζ
Jšœœœ
˜Jšœ	œ
˜
J˜Jšœœ˜.Jšœœ
œ
œ<˜[Jš
œ+˜+J˜šœ
˜Jš
œ#˜#Jšœœ
œ
˜%J˜(Jš
œA˜AJšœQœ#˜xJš
œ2˜2Jšœœ
˜—šœ
˜J˜—Jšœ
˜Jšœœœœ˜0—J˜J˜šžœœ
œ7œ(œœœ˜¦
Jš
œ'˜'Jšœœ
˜Jš
œ.˜.Jšœœ
œ
˜ Jš
œ.˜.Jšœœ
˜J˜Jšœœ˜:Jšœœ
œ
œ<˜[Jšœ&œ
œ?˜qJ™J™RJš
œ	œ
œœ	œ˜JJšœŸ˜*J˜Jš
œA˜AJšœœ˜'Jšœœ
œ9˜^Jšœœ	Ÿ0˜UJšœ(œŸ˜[Jšœ9Ÿ˜RJ˜JšœOœ,˜Jš
œ]˜]Jšœ˜J˜Jšœœ
œ
œ˜=Jšœ˜—J˜J™š
žœœ
œIœœ˜
Jš
œ'˜'Jšœœ
˜Jš
œ.˜.Jšœœ
œ
˜ Jš
œ.˜.Jšœœ
˜J˜Jšœ	œ*˜6Jšœœ
œ
œ<˜[Jšœ&œ
œ?˜qJ™Jš
œA˜AJšœœ˜'Jšœœ
œ9˜^Jšœœ	Ÿ0˜UJšœ(œŸ˜[Jšœ9Ÿ˜RJ˜JšœOœ,˜Jš
œ]˜]Jšœ˜Jšœœœ
˜%Jš
˜š
œ˜JšœPœ,˜€
Jšœ˜—J˜
—˜J™—šžœœ
œ<œœœœœœ˜ͺ
Jš
œ)˜)Jšœœ
˜Jš
œ.˜.Jš
œ,˜,Jšœœ
˜J˜J™EJšœœ0˜FJšœœœ˜IJšœœ-˜>Jšœœœœ˜XJ™=J˜Jšœœ
œœ
œœ˜[J™J™XJšœjœ
œ˜
Jš
œF˜FJ˜Jšœœ˜4Jšœœ
œd˜‰
Jšœœ˜>—˜Jšœ^œ.˜
Jš
œ[˜[Jšœ˜—˜Jšœœ
œ
˜)Jšœ˜—J˜šžœœ
œœ:œRœœœœ˜φ
šœ
œ"œ
˜2š
œ
˜
š
œ˜Jš
œ˜Jšœ
˜—J˜—˜š
œ#˜#Jš
œ˜—J˜—˜š
œ˜Jšœ	œG˜VJšœ˜—J˜—Jšœœ
˜—J˜—šžœœ
œ<œœ
œFœœœ˜ό
Jšœ˜šœœœ
œ
˜(šœœœ
œœœ
˜GJšœ˜—J˜
—J˜—˜Jšœ
œ
œœ˜BJ˜'Jšœœ
˜Jšœœ˜J˜'J˜-J˜,J˜-J˜-J˜+Jšœœ˜J˜šžœœ
œ9˜UJš
œ˜Jšœœ
˜#Jš
œ›
˜›
Jšœ)œœœ˜UJ˜2—˜J˜—Jš	œ

œœ!œ
œ
˜?J˜/J˜+J˜"Jš
œœ
œœœ˜dJš
œ˜J˜JšœZœ˜_J˜šœ(˜/šœ)˜0Jšœ-œ+˜^Jšœœ?˜ZJ˜_J˜A—Jšœ
˜J˜J˜@J˜J˜ J˜p—Jšœ
˜J˜Jšœ˜Jš
œ
˜
Jšœ
Ÿ"˜(Jšœœ
˜(—J˜J˜šžœœ
œ<œ
œ-œœœ˜Ώ
Jš
œ'˜'Jšœœ
˜Jš
œ.˜.Jšœœ
œ
˜ Jš
œ.˜.Jšœœ
˜Jšœœ
˜J˜J™yJšœœ ˜DJš
œI˜IJ˜Jš
œ	œ
œœ	œ˜JJšœŸ˜*J˜J™XJšœhœ
œ˜J˜Jšœœ"˜5Jšœœ
œ9˜^Jšœœ	Ÿ0˜UJšœ(œŸ˜[Jšœ9Ÿ˜RJ˜Jšœ]œ,˜
Jš
œ]˜]Jšœ˜J˜Jšœœ
œ
œ˜=Jšœ˜—Jš
œ˜J˜Jš
œ^™^Jšœ
œœ˜*J˜Jšœœ	˜ ˜(J™:Jšœœ	˜,šœ Ÿ˜6Jšœ!Ÿ"˜CJšœ Ÿ2˜RJšœ	˜—J˜
—J˜J˜šžœœ<œœ'œœœœ˜ΰ
Jšœ˜šœœœ
œ
˜(šœ œ˜(šœ&˜-Jš
œ6˜6Jš
œ ˜ Jšœ$œ˜:—Jšœ
˜Jšœ˜	—J˜
—J˜J˜Jšœ
œ˜Jšœœ˜2J˜*J˜Jšœ(œ
˜0Jš
œ*˜*J˜"J˜J™±J™Jš
œ`™`Jš
œ	œ
œ!œ	œ&˜hJš
œœ
œœœ˜VJ˜J™?Jšœ4œ˜9J˜Jšœ!Ÿ.˜OJ˜$J˜"Jšœœ
˜%šœ*˜1Jš
œ
˜
Jš
œ0˜0Jšœ#œœœ˜JJ˜JšœIœ
˜P˜=J˜8Jšœwœœ7œ˜β
J˜¨
Jš
œG˜G—J˜J˜Jš
œu˜u—Jšœ˜	Jš
œό
™ό
J™JšœJœ7œ5œ˜Δ
Jš
œJ˜JJ™šœ
œ
œ ˜MJšœ˜ Jšœ
ŸA˜Fš
œD˜DJš
œQ˜QJšœœ˜šœ˜%Jš
œ4˜4Jš
œ˜Jšœ$œ˜:—Jšœ
˜Jšœœ
œŸ0˜Q—J˜
Jš
˜š	œœœœ
œ
˜:JšœEœ$œ—
˜ˆ—J˜
—Jšœ
˜J˜J˜%Jšœ˜
—Jš
˜š
œ˜š
œ(˜(Jšœ˜
—J˜
—Jš
œ˜J™šžœœgœ˜‹
Jšœ
œ˜#šœ8˜;Jš
œ*˜*Jš
œ˜—J˜—J˜J™šžœœ
œ<œœ'œ˜•
Jš
œ(˜(Jšœœ
˜Jš
œ˜J˜J™}J™ΎJšœœ/˜EJšœœœ˜HJšœœ-˜>J˜J™XJšœiœ
œ˜€
Jš
œD˜DJ˜Jšœœ˜(Jšœ
œC˜OJš
œ–™–J˜Jšœ\œ-˜
J˜Jš
œ$˜$Jšœ˜—˜J™—šžœœ
œ]œœœ˜™
Jš
œ5™5Jš
œ(˜(Jšœœ
˜Jš
œ˜J˜Jšœœ/˜EJšœœœ˜HJšœœ-˜>J˜Jšœœ
œ
˜Jšœœ˜-Jšœœ˜0Jšœœœ	œ˜2J™jJ˜Jšœœ˜(Jšœ
œC˜OJ™Jšœœ
œ˜)˜J˜J˜Jšœcœ
œ˜zJš
œD˜D—˜Jšœ\œ-˜
J˜$Jšœ]œ,˜
—Jšœ
˜J˜Jšœ˜—˜J™—J™Jšœ
˜˜Icode™—K™
—…—Eϊ`n