DIRECTORY
BasicTime USING [earliestGMT, Now, Period],
BluejayUtils USING [DescribeTune, DescribeInterval],
BluejayUtilsRpcControl USING [ImportInterface, UnimportInterface],
Convert USING [IntFromRope, RopeFromInt],
FinchSmarts USING [CurrentFinchState, FinchState, GetProcs, Procs, RecordReason],
FS USING [ComponentPositions, ExpandName],
IO USING [card, GetCard, GetInt, int, PutFR, RIS, rope, STREAM],
LoganBerryStub USING [AttributeType, AttributeValue, Entry, Error, ErrorCode, Open, OpenDB, ReadEntry, WriteEntry],
LupineRuntime USING [BindingError],
Rope USING [Cat, Concat, ROPE, Substr],
Thrush USING [EncryptionKey, IntervalSpecs, Tune, VoiceInterval],
UserProfile USING [Token],
UserCredentials USING [CredentialsChangeProc, Get, RegisterForChange],
VoiceUtils USING [Problem, RnameToRspec],
VoiceRope;

VoiceRopeImpl: CEDAR PROGRAM  -- Should this be a monitor?
IMPORTS BasicTime, BluejayUtils, BluejayUtilsRpcControl, Convert, FinchSmarts, FS, IO, LupineRuntime, Rope, UserCredentials, UserProfile, VoiceUtils, LoganBerry: LoganBerryStub
EXPORTS VoiceRope
~ BEGIN
OPEN VoiceRope;

ROPE: TYPE ~ Rope.ROPE;
STREAM: TYPE ~ IO.STREAM;

defaultHandle: Handle_NIL;

Open: PUBLIC PROC[voiceRopeDBName: Rope.ROPE _ NIL, voiceRopeDBInstance: Rope.ROPE _ NIL, localName: Rope.ROPE _ NIL, Complain: PROC[complaint: Rope.ROPE]_NIL]  RETURNS [handle: Handle] = {
server: Rope.ROPE _ UserProfile.Token["ThrushClientServerInstance", "Strowger.Lark"];
vdbHandle: VoiceDBHandle;
ec: LoganBerry.ErrorCode;
expl: ROPE;
IF Complain = NIL THEN Complain _ FinchProblem;
IF voiceRopeDBInstance = NIL THEN voiceRopeDBInstance _ server;
IF voiceRopeDBName = NIL THEN 
voiceRopeDBName _ Rope.Cat["///", VoiceUtils.RnameToRspec[server].simpleName, "/VoiceRopeDB"];
[vdbHandle, ec, expl] _ VoiceRopeDB.Open[voiceRopeDBName];
IF ec#NIL THEN Complain[expl]; -- Trouble opening; success of future calls in doubt
ImportBluejay[instance];
handle _ NEW[HandleRec _ [vdbHandle: vdbHandle, Complain: Complain]];
};

FinchProblem: PROC[complaint: Rope.ROPE] = { VoiceUtils.Problem[complaint, $Finch]; };

StartFinch: PROC[handle: Handle, complain: BOOL_TRUE]
RETURNS [state: FinchSmarts.FinchState] = {
RW: PROC[c: Rope.ROPE] = {
IF ~complain THEN RETURN;
handle.Complain[complaint: c];
};
SELECT (state _ FinchSmarts.CurrentFinchState[]) FROM
unknown => RW["Sorry, Finch needs to be loaded and started.\n"];
stopped => RW["Sorry, Finch needs to be connected to telephone server.\nUse \"Finch\" command.\n"];
running => NULL;
ENDCASE => ERROR;
handle.procs _ IF state=unknown THEN NIL ELSE FinchSmarts.GetProcs[];
};

ValidateHandle: PROC[oldHandle: Handle] RETURNS [handle: Handle] = {
handle _ oldHandle;
IF handle=NIL THEN {
IF defaultHandle=NIL THEN defaultHandle _ Open[];
handle _ defaultHandle;
};
};

Record:  PUBLIC PROC[handle: Handle _ NIL] RETURNS [voiceRope: VoiceRope] = {
ENABLE LoganBerry.Error => { handle.Complain[explanation]; CONTINUE; };
interval: Thrush.VoiceInterval;
key: Thrush.EncryptionKey;
reason: FinchSmarts.RecordReason;
tune: Thrush.Tune;
handle _ ValidateHandle[handle];
IF StartFinch[handle]#running THEN RETURN;
[reason, tune, interval,  key] _ handle.procs.recordTune[queueIt: TRUE];
IF reason#ok THEN RETURN;
IF interval.length = -1 THEN
interval.length _ BluejayUtils.DescribeTune[tune].size * 8000;
voiceRope _ NEW[VoiceRopeInterval];
[voiceRope.ropeID, voiceRope.length] _ VoiceRopeDB.Write[handle: handle.vdbHandle, struct: SimpleTuneList[tune, interval, key]];
};


Play: PUBLIC PROC[handle: Handle_NIL, voiceRope: VoiceRope, queueIt: BOOL_TRUE, failOK: BOOL_FALSE, wait: BOOL_FALSE] = {
ENABLE LoganBerry.Error => { handle.Complain[explanation]; CONTINUE; };
tune: Thrush.Tune;
interval: Thrush.VoiceInterval;
key: Thrush.EncryptionKey;
struct: TuneList;
handle _ ValidateHandle[handle];
IF StartFinch[handle]#running THEN RETURN;
struct _ ReadVoiceRope[handle.vdbHandle, voiceRope].struct;
IF struct=NIL THEN { handle.Complain["No such voice rope to play."]; RETURN;};
UNTIL struct=NIL DO
[tune, interval, key, struct] _ NextTuneOnList[struct];
[]_handle.procs.playbackTune[tune: tune, interval: interval, key: key, queueIt: queueIt, failOK: failOK, wait: wait];
ENDLOOP;
};

Stop: PUBLIC PROC[handle: Handle _ NIL] = {
ENABLE UNWIND => NULL;
handle _ ValidateHandle[handle];
IF StartFinch[handle, FALSE]#running THEN RETURN;
handle.procs.stopTune[];
};


Retain: PUBLIC PROC [
handle: Handle _ NIL,
voiceRope: VoiceRope, 
refID: Rope.ROPE,
refIDType: Rope.ROPE
] ~ {
handle _ ValidateHandle[handle];
};

Forget: PUBLIC PROC [
handle: Handle _ NIL,
refID: Rope.ROPE,
refIDType: Rope.ROPE
] ~ {
handle _ ValidateHandle[handle];
};
Cat: PUBLIC PROC [handle: Handle _ NIL, vr1, vr2, vr3, vr4, vr5: VoiceRope _ NIL] RETURNS [new: VoiceRope] ~ {
struct: TuneList;
IF vr1 = NIL THEN RETURN[NIL];
handle _ ValidateHandle[handle];
struct _ ReadVoiceRope[handle.vdbHandle, vr1].struct;
IF vr2 # NIL THEN
struct _ CatEntries[struct, ReadVoiceRope[handle.vdbHandle, vr2].struct];
IF vr3 # NIL THEN
struct _ CatEntries[struct, ReadVoiceRope[handle.vdbHandle, vr3].struct];
IF vr4 # NIL THEN
struct _ CatEntries[struct, ReadVoiceRope[handle.vdbHandle, vr4].struct];
IF vr5 # NIL THEN
struct _ CatEntries[struct, ReadVoiceRope[handle.vdbHandle, vr5].struct];
new _ WriteVoiceRope[handle.vdbHandle, struct];
};
Substr: PUBLIC PROC [handle: Handle _ NIL, vr: VoiceRope, start: INT _ 0, len: INT _ LAST[INT]] RETURNS [new: VoiceRope] ~ {
struct: TuneList;
handle _ ValidateHandle[handle];
struct _ ReadVoiceRope[handle.vdbHandle, vr].struct;
IF struct=NIL THEN { handle.Complain["No such voice rope."]; RETURN[NIL];};
struct _ TuneListInterval[struct, start, len];
new _ WriteVoiceRope[handle.vdbHandle, struct];
};
Replace: PUBLIC PROC [handle: Handle _ NIL, vr: VoiceRope, start: INT _ 0, len: INT _ LAST[INT], with: VoiceRope _ NIL] RETURNS [new: VoiceRope] ~ {
base, struct: TuneList;
handle _ ValidateHandle[handle];
base _ ReadVoiceRope[handle.vdbHandle, vr].struct;
IF base=NIL THEN { handle.Complain["No such voice rope."]; RETURN[NIL];};
struct _ TuneListInterval[CopyEntry[base], 0, start];
struct _ CatEntries[struct, ReadVoiceRope[handle.vdbHandle, with].struct];
struct _ CatEntries[struct, TuneListInterval[base, start+len]];
new _ WriteVoiceRope[handle.vdbHandle, struct];
};
Length: PUBLIC PROC [handle: Handle _ NIL, vr: VoiceRope] RETURNS [len: INT] ~ {
header: LoganBerry.Entry;
value: LoganBerry.AttributeValue;
handle _ ValidateHandle[handle];
header _ ReadVoiceRope[handle.vdbHandle, vr].header;
IF header = NIL THEN  { handle.Complain["No such voice rope."]; RETURN[0];};
value _ GetAttributeValue[entry: header, type: $Length];
len _ Convert.IntFromRope[value];
};
DescribeRope: PUBLIC PROC [handle: Handle _ NIL, vr: VoiceRope, minSilence: INT _ -1] RETURNS [noise: IntervalSpecs] ~ {
struct: TuneList;
tuneSpec: Thrush.IntervalSpecs;
tune: Thrush.Tune;
interval: Thrush.VoiceInterval;
noiseEnd: IntervalSpecs _ NIL;  -- last item on current list of noise intervals
samples: INT _ 0;
handle _ ValidateHandle[handle];
struct _ ReadVoiceRope[handle.vdbHandle, vr].struct;
UNTIL struct=NIL DO
[tune: tune, interval: interval, rest: struct] _ NextTuneOnList[struct];
tuneSpec _ BluejayUtils.DescribeInterval[targetTune: tune, targetInterval: interval, minSilence: minSilence].intervals;
UNTIL tuneSpec = NIL DO
IF noiseEnd = NIL THEN {
noise _ LIST[[start: samples + tuneSpec.first.interval.start - interval.start, length: tuneSpec.first.interval.length]];
noiseEnd _ noise;
}
ELSE {
noiseEnd.rest _ LIST[[start: samples + tuneSpec.first.interval.start - interval.start, length: tuneSpec.first.interval.length]];
noiseEnd _ noiseEnd.rest;
};
tuneSpec _ tuneSpec.rest;
ENDLOOP;
samples _ samples + interval.length;
ENDLOOP;
};

ImportBluejay: PROC[instance: ROPE] = {
TRUSTED {
BluejayUtilsRpcControl.UnimportInterface[!LupineRuntime.BindingError => CONTINUE];
};
BluejayUtilsRpcControl.ImportInterface[["BluejayUtils.Lark", instance]];
};
CatEntries: PROC [e1, e2: LoganBerry.Entry] RETURNS [LoganBerry.Entry] ~ {
ptr: LoganBerry.Entry _ e1;
IF ptr = NIL THEN RETURN[e2];
UNTIL ptr.rest = NIL DO
ptr _ ptr.rest;
ENDLOOP;
ptr.rest _ e2;
RETURN[e1];
};

CopyEntry: PROC [entry: LoganBerry.Entry] RETURNS [LoganBerry.Entry] ~ {
new, end: LoganBerry.Entry;
IF entry = NIL THEN RETURN[NIL];
new _ LIST[entry.first];
end _ new;
FOR e: LoganBerry.Entry _ entry.rest, e.rest WHILE e # NIL DO
end.rest _ LIST[e.first];
end _ end.rest;
ENDLOOP;
RETURN[new];
};

GetAttributeValue: PROC [entry: LoganBerry.Entry, type: LoganBerry.AttributeType] RETURNS [LoganBerry.AttributeValue] ~ {
FOR e: LoganBerry.Entry _ entry, e.rest WHILE e # NIL DO
IF e.first.type = type THEN
RETURN[e.first.value];
ENDLOOP;
RETURN[NIL];
};
END.
<VoiceRopeImpl.mesa
Copyright c 1986 by Xerox Corporation.  All rights reserved.
Doug Terry, June 3, 1986 5:07:08 pm PDT

Operations for manipulating recorded voice.

This should probably be separated into different modules: PlayRecordImpl, VoiceRopeImpl, VoiceInterestImpl.  For the moment I just want to get something on which a voice editing tool can be built.  ... Doug

RPC USING [CallFailed, CallFailure, ImportFailed],
Intervoice operations (record and play)
The following routines were adapted from RecordPlayImpl.mesa
If voiceRopeDBName, voiceRopeDBInstance, or localName is omitted, a default based on the user profile choice of Thrush Server is invented.  If Complain is omitted, VoiceUtils.Problem[...$Finch] is used.
Should arrange to load Finch if not loaded, start it if not started.
At present, does neither, tells caller what's what, and complains if asked to.
Records a voice rope, registers it , and returns its ID.  A NIL return value indicates that something went wrong.
Nothing much can be done about it; just tell the user.  Should eventually log for system administrator's benefit.
-- no BeepTune until we store SysNoises in the new voice database
Play[handle: handle, refID: "BeepTune", refIDType: "SysNoises", failOK: TRUE];
May need to call Bluejay to get actual length; note the size returned is in chirps so must multiply by 8000 to get samples
Currently, the Play routine can only play a voice rope given its ID; the refID and refIDType fields are missing.  How to manage system noises, like Beeps and intolerably cute rollback tunes, in the context of voice ropes needs to be resolved.
Play a specified voice rope.  The boolean arguments are interpreted as follows:
queueIt => play after all other record/playback requests are satisfied.
failOK => playing is optional; leave connection open if tune doesn't exist.
wait => wait until things appear to be started properly, or have failed.
Sender and Walnut Message viewer STOP buttons
Voice Interests
Voice interests and the garbage collection of voice ropes is not yet implemented.
Existence of refID retains interest in voiceFileID until corresponding Forget.
Creator is assumed to be logged-in user.
Remove refID from database, eliminating its interest in any voiceFileID's
Creator is assumed to be logged-in user.
Editing operations
Concatenates together the non-NIL voice ropes to produce a new voice rope.

Creates a new voice rope that is a substring of an existing voice rope.

Creates a new voice rope in which the given interval of the voice rope "vr" is replaced by the voice rope "with".

Returns the actual length of the voice rope.  This operation ignores the start and length values specified in the voice rope.  Thus, vr.start _ 0; vr.length _ Length[handle, vr] will restore a voice rope to its full contents.

Information about voice ropes

Fetch: PUBLIC PROC [handle: Handle _ NIL, vr: VoiceRope, index: INT] RETURNS [VoiceSample];
ENABLE {
RPC.ImportFailed => NULL;
};
Miscellaneous
Concatenates the two lists together (destructive to the first).
Copies one list to another.

Doug Terry, March 18, 1986 10:16:33 am PST
created.
Κ
¬˜
codeš
œ™Kšœ
Οm
œ1™<Kš
œ'™'—K™K™+K™K™Ξ
K™š
Οk	˜	Kšœ
žœ˜+Kšœ
žœ"˜4Jšœžœ&˜BKšœžœ˜)Jšœžœ@˜QKšœžœ"˜*Kšœžœ#žœžœ˜@Kšœžœ_˜sJšœžœ˜#Kšœžœ
žœ˜'Jšžœ
žœ)™2Jšœžœ5˜AJšœžœ	˜Kšœžœ1˜FKšœžœ˜)Kš
œ
˜
—K˜KšΠbl
œžœ
žœΟc˜:Jšžœ©
˜°
Kšžœ
˜šœž˜Kšžœ˜K˜Kšžœžœžœ
˜Kšžœžœžœ
žœ
˜K˜Jšœžœ
˜—
head™'Kšœ) ™<J˜šΟnœžœ
žœžœžœžœžœžœžœžœžœžœžœ˜½
Jš
œΚ
™Κ
Jšœ
žœD˜UJ˜Jš
œ˜Jšœžœ
˜Jšžœžœ
žœ˜/Jšžœžœ
žœ˜?šžœžœ
žœ
˜Jš
œ^˜^—Jš
œ:˜:Jšžœžœ
žœ 4˜SJš
œ˜Jšœ	žœ9˜EJ˜J˜—š‘œžœžœ/˜VJ˜—š‘
œžœžœ
žœ
˜5Jšžœ$˜+J™DJ™Nšžœžœ	žœ˜Jšžœžœ
žœ
˜Jš
œ˜J˜—šžœ+ž˜5Jšœžœ3˜@JšœžœV˜cJšœžœ
˜Jšžœžœ
˜—Jš	œžœžœ
žœ
žœ˜EJ˜J˜—š‘œžœžœ˜DJ˜šžœžœ
žœ˜Jšžœžœ
žœ˜1Jš
œ˜J˜—J˜J˜—š
‘œžœ
žœžœžœ˜MJ™qšžœ5žœ˜GJ™q—Jš
œ˜J˜J˜!J˜J˜ Jšžœžœ
žœ
˜*Jš
œA™AJšœHžœ™NJšœBžœ˜HJšžœžœ
žœ
˜Jš
œz™zšžœž˜Jš
œ>˜>—Kšœžœ˜#Jš
œ€
˜€
Jš
œ˜—J˜Jš
œς
™ς
J˜š‘œžœ
žœžœ!žœ
žœ
žœ
žœžœ
žœ˜yš
œO™OJšœ <™GJšœ
 A™KJšœ ?œ
™H—Jšžœ5žœ˜GJ˜J˜J˜J˜J˜ Jšžœžœ
žœ
˜*Jš
œ;˜;Jš
žœžœ
žœ
žœ.žœ˜Nšžœžœ
ž˜Kš
œ7˜7Jš
œu˜uKšžœ
˜—J˜J˜—š‘œžœ
žœžœ˜+Jšœ!Οbœ™-Jšžœ
žœžœ
˜J˜ Jšžœžœ
žœ
žœ
˜1Jš
œ˜Jš
œ˜J˜——™K™QK˜š‘œžœ
žœ˜K™NK™(Kšœžœ
˜Jš
œ˜Jšœžœ
˜Jšœž˜Jš
œ˜J˜ Jš
œ˜J˜—š‘œžœ
žœ˜K™IK™(Kšœžœ
˜Jšœžœ
˜Jšœž˜Jš
œ˜J˜ Jš
œ˜——™š‘œžœ
žœžœ'žœžœ˜nK™JKš
œ˜Kš
žœžœ
žœ
žœ
žœ˜J˜ Kš
œ5˜5šžœžœ
ž˜Kš
œI˜I—šžœžœ
ž˜Kš
œI˜I—šžœžœ
ž˜Kš
œI˜I—šžœžœ
ž˜Kš
œI˜I—Kš
œ/˜/K˜K™—š‘œžœ
žœžœžœžœžœ
žœžœ˜|K™GKš
œ˜J˜ Kš
œ4˜4Jš
žœžœ
žœ+žœ
žœ˜KKš
œ.˜.Kš
œ/˜/K˜K™—š‘œžœ
žœžœžœžœžœ
žœžœžœ˜”
K™qJš
œ˜J˜ Kš
œ2˜2Jš
žœžœ
žœ+žœ
žœ˜IKš
œ5˜5Kš
œJ˜JKš
œ?˜?Kš
œ/˜/K˜K™—š‘œžœ
žœžœžœžœ˜PK™α
Kš
œ˜Jš
œ!˜!J˜ Kš
œ4˜4Kšžœ
žœ
žœ,žœ˜LKš
œ8˜8Kš
œ!˜!K˜K™——™š
‘œžœžœžœžœ˜xJ˜Jš
œ˜J˜J˜Jšœžœ /˜OJšœ	žœ˜J˜ Jš
œ4˜4šžœžœ
ž˜Kš
œH˜HJš
œw˜wšžœžœ
ž˜šžœžœ
žœ˜Jšœžœl˜xJš
œ˜J˜
—šžœ˜Jšœžœl˜€
Jš
œ˜J˜—Jš
œ˜Jšžœ
˜—K˜$Kšžœ
˜—K˜—K™Kš‘œžœ.žœžœ™[K˜š‘
œžœžœ˜'šžœ
ž
™Jšžœžœ
™J™—šžœ˜	JšœHžœ˜RJš
œ˜—Jš
œH˜HJ˜——™
š‘
œžœžœ˜JK™?Kš
œ˜Kšžœžœ
žœ
žœ˜šžœžœ
ž˜Kš
œ˜Kšžœ
˜—Kš
œ˜Kšžœ˜K˜K˜—š‘	œžœžœ˜HK™Kš
œ˜Kš
žœ	žœ
žœ
žœ
žœ˜ Kšœžœ˜K˜
šžœ*žœžœ
ž˜=Kšœžœ
˜K˜Kšžœ
˜—Kšžœ˜K˜K˜—š‘œžœ;žœ ˜yšžœ%žœžœ
ž˜8šžœž˜Kšžœ˜—Kšžœ
˜—Kšžœ
žœ˜K˜K™——Kšžœ
˜™*Kš
Οr™——…—""9