DIRECTORY
Commander USING [CommandProc, Register],
CommandTool USING [ArgumentVector, Failed, Parse],
Jukebox USING [Handle, Tune, bytesPerChirp, RunArray, FindJukebox, OpenJukebox, CloseJukebox, OpenTune, CloseTune, LengthRange, EnergyRange, RunArrayRange, RunComponent, MissingChirp, Error, singlePktLength],
TuneAccess USING [ByteBlock, userHeaderLength, ReadTuneHeader, ByteSequence, ReadRunArray, ReadChirpSamples, GetCreateDate, GetWriteDate, GetReadDate],
Rope USING [ROPE, Fetch, Length],
IO USING [STREAM, UnsafeBlock, UnsafePutBlock, PutChar, Close],
FS USING [StreamOpen, Error],
Convert USING [IntFromRope],
TuneArchive USING [TuneInformation, ChirpContents, TuneInformationHeader, ChirpContentsRecord, chirpContentsBytes, tuneInformationBytes, PrintArchiveInfo],
BasicTime USING [Now, TimeNotKnown];

OldTunesImpl: CEDAR PROGRAM
IMPORTS Commander, CommandTool, Jukebox, TuneAccess, Rope, IO, FS, Convert, BasicTime, TuneArchive =
BEGIN

ArchiveTune: PROC [jukeboxName: Rope.ROPE, tuneID: INT, toFile: Rope.ROPE] RETURNS [tuneInformation: TuneArchive.TuneInformation, internalJukeboxName: Rope.ROPE] = TRUSTED {
stream: IO.STREAM _ NIL;
jukebox: Jukebox.Handle _ NIL;
tune: Jukebox.Tune _ NIL;
weOpened: BOOLEAN _ FALSE; -- all declared here for catch phrase use
{
ENABLE UNWIND =>
{  IF stream # NIL THEN IO.Close[stream];
IF tune # NIL THEN Jukebox.CloseTune[jukebox, tune];
IF jukebox # NIL AND weOpened THEN jukebox _ Jukebox.CloseJukebox[jukebox];
};

tuneInformation _ NEW[TuneArchive.TuneInformationHeader];
{ -- just so as to be able to do an assignment before all the declarations
byteBlock: TuneAccess.ByteBlock _ NEW[TuneAccess.ByteSequence[MAX [TuneAccess.userHeaderLength, Jukebox.bytesPerChirp]]];
chirpContents: TuneArchive.ChirpContents _ NEW[TuneArchive.ChirpContentsRecord];
runArray: REF Jukebox.RunArray _ NEW[Jukebox.RunArray];

unsafeOfTuneInformation: IO.UnsafeBlock _ [LOOPHOLE[tuneInformation], 0, TuneArchive.tuneInformationBytes];
byteBlockPointer: LONG POINTER _ LOOPHOLE[byteBlock];
unsafeOfByteBlock: IO.UnsafeBlock _ [byteBlockPointer + SIZE[TuneAccess.ByteSequence[0]]]; -- yetch
unsafeOfChirpContents: IO.UnsafeBlock _ [LOOPHOLE[chirpContents], 0, TuneArchive.chirpContentsBytes];
unsafeOfRunArray: IO.UnsafeBlock _ [LOOPHOLE[runArray]];

jukebox _ Jukebox.FindJukebox[jukeboxName];
IF jukebox = NIL THEN 
{  jukebox _ Jukebox.OpenJukebox[jukeboxName];
weOpened _ TRUE
};

stream _ FS.StreamOpen[toFile, $create];

tune _ Jukebox.OpenTune[self: jukebox, tuneId: tuneID, write: FALSE];

internalJukeboxName _ BuildTuneInformation[jukebox, tune, tuneInformation];
IO.UnsafePutBlock[stream, unsafeOfTuneInformation];

FOR i: INT IN [0..tuneInformation.jukeboxNameLength) DO IO.PutChar[stream, internalJukeboxName.Fetch[i]] ENDLOOP;

byteBlock _ TuneAccess.ReadTuneHeader[jukebox, tune, TuneAccess.userHeaderLength, byteBlock];
unsafeOfByteBlock.count _ TuneAccess.userHeaderLength;
IO.UnsafePutBlock[stream, unsafeOfByteBlock];

FOR j: INT IN [0..tuneInformation.sizeInChirps) DO
BuildChirpRecord[jukebox, tune, j, chirpContents, runArray, byteBlock];
IO.UnsafePutBlock[stream, unsafeOfChirpContents];
unsafeOfRunArray.count _ chirpContents.runArrayLength*2;
IO.UnsafePutBlock[stream, unsafeOfRunArray];
unsafeOfByteBlock.count _ chirpContents.sampleBytes;
IO.UnsafePutBlock[stream, unsafeOfByteBlock]
ENDLOOP;

IO.Close[stream];
Jukebox.CloseTune[jukebox, tune];
IF weOpened THEN jukebox _ Jukebox.CloseJukebox[jukebox]
}}};
 
BuildTuneInformation: PROC [jukebox: Jukebox.Handle, tune: Jukebox.Tune, info: TuneArchive.TuneInformation]  RETURNS [internalJukeboxName: Rope.ROPE] = {
info.jukeboxNameLength _ jukebox.jukeboxName.Length;
TRUSTED {info.tuneNumber _ tune.tuneId};
info.createDate _ TuneAccess.GetCreateDate[tune];
info.writeDate _ TuneAccess.GetWriteDate[tune];
info.readDate _ TuneAccess.GetReadDate[tune];
info.archiveDate _ BasicTime.Now[];
TRUSTED {info.sizeInChirps _ tune.size};
RETURN [jukebox.jukeboxName]
};


OldRunArray: TYPE = REF ARRAY Jukebox.RunArrayRange OF CARDINAL;

BuildChirpRecord: PROC [jukebox: Jukebox.Handle, tune: Jukebox.Tune, chirpNumber: INT, chirpContents: TuneArchive.ChirpContents, runArray: REF Jukebox.RunArray, byteBlock: TuneAccess.ByteBlock] = {
ENABLE Jukebox.MissingChirp =>
{ chirpContents.ambientLevel _ 0;
chirpContents.runArrayLength _ 1;
chirpContents.sampleBytes _ 0; 
TRUSTED {runArray[0] _ [silence[Jukebox.bytesPerChirp]]};
GOTO Return
};
usefulArrayLength: Jukebox.RunArrayRange _ 0;
usefulSamples: Jukebox.LengthRange _ 0;
accountedSamples: Jukebox.LengthRange _ 0;

thisLength: Jukebox.LengthRange;
newElementsUsed: Jukebox.LengthRange;
silence: BOOLEAN; 

oldRunArray: OldRunArray;
loopHoledOldRunArray: REF Jukebox.RunArray;
oldRunArrayPosition: Jukebox.RunArrayRange _ 0;

loopHoledOldRunArray _ TuneAccess.ReadRunArray[jukebox, tune, chirpNumber, NIL];
TRUSTED {oldRunArray _ LOOPHOLE[loopHoledOldRunArray]};

WHILE accountedSamples<Jukebox.bytesPerChirp DO
[thisLength, newElementsUsed, silence] _ InterpretOldRunArrayElement[oldRunArray, runArray, usefulArrayLength, oldRunArrayPosition];
IF ~silence THEN usefulSamples _ usefulSamples + thisLength;
accountedSamples _ accountedSamples + thisLength;
usefulArrayLength _ usefulArrayLength + newElementsUsed;
oldRunArrayPosition _ oldRunArrayPosition + 1
ENDLOOP;

IF accountedSamples # Jukebox.bytesPerChirp THEN 
{  elementAdded: BOOLEAN;
samplesDiscarded: BOOLEAN;
[elementAdded: elementAdded, samplesDiscarded: samplesDiscarded] _ FrigLastElement[runArray, usefulArrayLength, accountedSamples - Jukebox.bytesPerChirp];
IF elementAdded THEN usefulArrayLength _ usefulArrayLength + 1;
IF samplesDiscarded THEN usefulSamples _ usefulSamples - (accountedSamples - Jukebox.bytesPerChirp)
};

chirpContents.runArrayLength _ usefulArrayLength;
chirpContents.sampleBytes _ usefulSamples;
chirpContents.ambientLevel _ FIRST[Jukebox.EnergyRange];
byteBlock _ TuneAccess.ReadChirpSamples[jukebox, tune, chirpNumber, usefulSamples, byteBlock]

EXITS
Return => RETURN
};

InterpretOldRunArrayElement: PROC [oldRunArray: OldRunArray, newRunArray: REF Jukebox.RunArray, usefulArrayLength: Jukebox.RunArrayRange, oldRunArrayPosition: Jukebox.RunArrayRange] RETURNS [thisLength: Jukebox.LengthRange, newElementsUsed: Jukebox.LengthRange, silence: BOOLEAN] = {
IF (oldRunArrayPosition MOD 2) = 0 
THEN -- silence
{  IF usefulArrayLength # 0 AND newRunArray[usefulArrayLength-1].elementType = silence
THEN -- last thing added to newRunArray was silence, so just add more silence
{  -- this works okay for case of run length = 0
TRUSTED 
{
newRunArray[usefulArrayLength-1] _  [silence[NARROW[newRunArray[usefulArrayLength-1], Jukebox.RunComponent[silence]].length + oldRunArray[oldRunArrayPosition]]]
}; -- got that ??
thisLength _ oldRunArray[oldRunArrayPosition];
newElementsUsed _ 0;
silence _ TRUE
}
ELSE -- last thing in run wasn't silence, or this is beginning of run
{  IF oldRunArray[oldRunArrayPosition] = 0
THEN -- special case for run length = 0: just no change !!
{  thisLength _ 0;
newElementsUsed _ 0;
silence _ TRUE
}
ELSE
{  
TRUSTED {newRunArray[usefulArrayLength] _ [silence[oldRunArray[oldRunArrayPosition]]]};
thisLength _ oldRunArray[oldRunArrayPosition];
newElementsUsed _ 1; 
silence _ TRUE
}
}
}

ELSE -- sound
{ samplesToDispose: Jukebox.LengthRange _ oldRunArray[oldRunArrayPosition];
silence _ FALSE;
thisLength _ samplesToDispose;
newElementsUsed _ 0;

WHILE samplesToDispose>0 DO
IF samplesToDispose >= Jukebox.singlePktLength
THEN
{  
TRUSTED
{  
newRunArray[usefulArrayLength+newElementsUsed] _ [singlePkt[LAST[Jukebox.EnergyRange]]]
};
samplesToDispose _ samplesToDispose - Jukebox.singlePktLength;
newElementsUsed _ newElementsUsed + 1
}
ELSE 
{
TRUSTED
{
newRunArray[usefulArrayLength+newElementsUsed] _ [soundEnergy[LAST[Jukebox.EnergyRange]]];
newRunArray[usefulArrayLength+newElementsUsed+1] _ [soundLength[samplesToDispose]]
};
samplesToDispose _ 0;
newElementsUsed _ newElementsUsed + 2
}
ENDLOOP
}
};

FrigLastElement: PROC [runArray: REF Jukebox.RunArray, usefulArrayLength: Jukebox.EnergyRange, samplesToLose: Jukebox.LengthRange] RETURNS [samplesDiscarded: BOOLEAN _ TRUE, elementAdded: BOOLEAN _ FALSE] =  TRUSTED {
WITH curr: runArray[usefulArrayLength] SELECT FROM
silence => 
{  curr.length _ curr.length - (samplesToLose);
samplesDiscarded _ FALSE
};
soundLength =>
  curr.length _ curr.length - (samplesToLose);
singlePkt => -- requires that we make a new element
{  runArray[usefulArrayLength] _ [soundEnergy[LAST[Jukebox.EnergyRange]]];
runArray[usefulArrayLength+1] _ [soundLength[Jukebox.singlePktLength - samplesToLose]];
elementAdded _ TRUE 
};
ENDCASE => ERROR
};


ArchiveOldTune: Commander.CommandProc = {
ENABLE
{FS.Error => IF error.group = bug THEN REJECT ELSE {msg _ error.explanation; GOTO Quit};

Jukebox.Error => {msg _ rope; GOTO Quit};

BasicTime.TimeNotKnown => {msg _ "Unable to determine current time: aborting archive"; GOTO Quit}
};

argv: CommandTool.ArgumentVector 
_ CommandTool.Parse[cmd ! CommandTool.Failed => {msg _ errorMsg; GOTO Quit}];

tuneInformation: TuneArchive.TuneInformation;
internalJukeboxName: Rope.ROPE;

IF argv.argc # 4 THEN 
RETURN [$Failure, "Usage: ArchiveTune jukeboxName tuneNumber fileName"];

[tuneInformation, internalJukeboxName] _ ArchiveTune[jukeboxName: argv[1], tuneID: Convert.IntFromRope[argv[2]], toFile: argv[3]];
TuneArchive.PrintArchiveInfo[out: cmd.out, archiveFileName: argv[3], tuneInformation: tuneInformation, archivedJukeboxName: internalJukeboxName]

EXITS
Quit =>  RETURN [$Failure, msg]
};





Commander.Register[key: "ArchiveOldTune", proc: ArchiveOldTune, doc: "ArchiveOldTune jukeboxName tuneNumber fileName - archive and convert a tune from an old-style [= Pre-Ades] jukebox as an FS file"];


END.
ΈFile: OldTunesImpl.mesa
command to archive a tune from an old style jukebox, converting it into the new standard archive format, so that it can be restored into a new style jukebox
see routine BuildChirpRecord for documentation of differences in tunes
Ades, March 6, 1986 3:25:19 pm PST
Swinehart, February 24, 1986 1:08:21 pm PST

these variables and the RETURN parameters are used to retrieve data from the jukebox: internalJukeboxName is the name for the jukebox that is actually stored in the jukebox when open, as opposed to the parameter passed to Jukebox.OpenJukebox
these are the arguments corresponding to the above for IO.UnsafePutBlock: in cases where it is not given above (thus defaulting to 0), before a call to IO.UnsafePutBlock the block's count field should be set appropriately (in bytes)
build up the tuneInformation, mainly by reading the tune and return the jukebox name as a string
routine BuildChirpRecord distinguishes the old format from the new: the run array of an old tune was just an array [0..Jukebox.RunArrayRange] of 16 bit integers: even ones represent silence and odd ones sound. No energy or ambient values were stored, so we will convert them to max energy and min ambient noise.

we need the following type to make things clear:
This record is the same length and in the same position within the chirp as a new style RunArray so that we'll pick it up using TuneAccess.ReadRunArray and then LOOPHOLE it			
build up chirpContents, also fill runArray and byteBlock appropriately

we need to be careful as zero length silences and sounds may occur in this record
this gets executed if the last run element brought the total over Jukebox.bytesPerChirp, so we have to discard some 
Κ	
˜š
œ™J™œ
JšœΟnœ*™FIcode™"K™+—J™š
Οk	˜	Jšœ
žœ˜(Jšœžœ!˜2JšœžœΓ
˜Π
Jšœžœ‡
˜—
Jšœžœžœ˜!Jšžœ
žœžœ/˜?Jšžœ
žœ˜Jšœžœ˜J˜›
Jšœ
žœ˜$J˜—Jšœžœ
ž˜Jšžœ4žœžœ#˜dJš
ž˜J˜šœžœžœ
žœžœžœJžœžœ˜­
Jšœžœ
žœžœ
˜Jšœžœ
˜Jšœžœ
˜Jšœ
žœžœΟc)˜D—š
œ
˜
šžœ
žœ˜š	œžœ
žœ
žœ
žœ˜)Jšžœžœ
žœ"˜4Jšžœžœ
žœ
žœ)˜K—Jš
œ˜—J˜Jš
œρ
™ρ
Jšœžœ$˜9JšœŸH˜JJšœ"žœžœ8˜yJšœ+žœ"˜PJšœ
žœžœ˜7J˜Jšœ7žœ_žœN™θ
Jšœžœžœ8˜kJšœžœ
žœžœ˜5Jšœžœ#žœŸ˜cJšœžœžœ4˜eJšœžœžœ˜8J˜Jš
œ+˜+Jšžœžœ
žœ
˜š
œ.˜.Jšœž˜—Jš
œ˜J˜Jšœ	žœ˜(J˜Jšœ>žœ˜EJ˜Jš
œK˜KJšžœ1˜3J˜Jšžœžœ
žœ(žœ
žœ/žœ
˜qJ˜Jš
œ]˜]Jš
œ6˜6Jšžœ+˜-J˜šžœžœ
žœ#ž˜2Jš
œG˜GJšžœ/˜1Jš
œ8˜8Jšžœ*˜,Jš
œ4˜4Jšžœ*˜,—Jšžœ
˜J˜Jšžœ˜Jš
œ!˜!Jšžœ
žœ(˜8—˜Jš
œ
˜
—šœžœSžœžœ˜™
Jš
œ`™`Jš
œ4˜4Jšžœ!˜(Jš
œ1˜1Jš
œ/˜/Jš
œ-˜-J˜#Jšžœ!˜(Jšžœ˜—J˜J˜
JšœœŸ™·J™J™0Jšœ
žœžœ
žœžœ
žœ
˜@š
œ―
™―
J˜—šœžœ<žœ6žœ7˜Ε
Jš
œF™FJšžœ˜š
œ!˜!Jš
œ!˜!Jš
œ˜Jšžœ2˜9Jšžœ˜—J˜J™Jš
œ-˜-Jš
œ'˜'Jš
œ*˜*J˜Jš
œ ˜ Jš
œ%˜%Jšœ	žœ˜J˜J˜Jšœžœ˜+Jš
œ/˜/J˜JšœKžœ˜PJšžœžœ˜7J˜šžœ(ž˜/Jš
œ„
˜„
Jšžœ
žœ,˜<Jš
œ1˜1Jš
œ8˜8Jš
œ-˜-—Jšžœ
˜J˜Jšžœ*žœ
˜1šœž˜Jšœžœ
˜Jš
œš
˜š
Jšžœžœ+˜?JšžœžœK˜c—˜J˜—Jš
œ1˜1Jš
œ*˜*Jšœžœ˜8Jš
œ]˜]J˜—š
ž˜Jšœ
ž˜—J˜J˜š
œžœ)žœižœRžœ˜›J™QJšžœžœ˜#Jšžœ
Ÿ
˜šœžœžœ7˜VJšžœ
ŸœŸ&˜MšœŸ-˜0Jšžœ
˜š
œ
˜
Jšœ-žœm˜ 
—JšœŸ˜Jš
œ.˜.Jš
œ˜Jšœ
ž˜—J˜
Jšžœ
Ÿ@˜Ešœžœ%˜*Jšžœ
Ÿ5˜:š
œ˜Jš
œ˜Jšœ
ž˜—J˜
Jš
ž˜š
œ˜JšžœP˜WJš
œ.˜.Jš
œ˜Jšœ
ž˜—J˜
—J˜
—J˜
—˜Jšžœ
Ÿ˜
š
œK˜KJšœ
žœ
˜Jš
œ˜Jš
œ˜J˜šžœž˜Jšžœ,˜.Jš
ž˜š
œ˜Jš
ž˜š
œ˜Jšœ<žœ˜W—Jš
œ˜Jš
œ>˜>Jš
œ%˜%—J˜
Jšžœ
˜˜
Jš
ž˜š
œ
˜
Jšœ>žœ˜ZJš
œR˜R—Jš
œ˜Jš
œ˜Jš
œ%˜%——J˜
Jš
ž˜—J˜
—˜J˜—šœžœnžœžœžœžœžœžœ˜Ω
J™tJšžœ#žœ
ž˜2š
œ˜š
œ/˜/Jšœž˜—Jš
œ˜—Jš
œ˜Jš
œ.˜.šœ
Ÿ&˜3šœ.žœ˜JJš
œW˜WJšœžœ
˜—Jš
œ˜—Jšžœž˜—š
œ˜J˜J˜—šΟbœ˜)Jš
ž˜Jš
œ
žœ
žœžœ
žœ
žœžœ˜XJ˜Jšœžœ˜)J˜JšœWžœ˜aJ˜J˜Jšœcžœ˜oJ˜Jš
œ-˜-Jšœžœ
˜J˜šžœžœJ˜_J˜—Jš
œ‚
˜‚
š
œ
˜
J˜——š
ž˜Jšœ	ž˜—Jš
œ˜J˜J˜š
œ
˜
J˜Jš
œΙ
˜Ι
J˜J˜—Jšžœ
˜—…—&,5ξ