DIRECTORY
BasicTime USING [GetClockPulses, MicrosecondsToPulses, Pulses, PulsesToMicroseconds ],
Menus USING [MenuProc ],
MessageWindow USING [Append, Blink ],
Process USING [Detach, MsecToTicks, Priority, priorityRealTime, SetPriority, SetTimeout, Ticks ],
Rope USING [Length, ROPE ],
TiogaOps USING [CancelSelection, FirstChild, GetRope, GetSelection, SelectionGrain, SelectPoint, SetSelection, ViewerDoc ],
TiogaOpsDefs USING [Location, Ref, SelectionGrain ],
TiogaVoicePrivate USING [ AgeAllViewers, PlayBackRequestState, PlaySelection, ReColorViewer, RecordingInProgress, SelectionsAfterRedraw, SetTiogaViewerParams, SetVoiceLooks, SetVoiceViewerEditStatus, SoundList, soundRopeCharLength, soundRopeCharsPerSecond, thrushHandle, VoiceViewerInfo ],
ViewerClasses USING [Viewer ],
ViewerOps USING [FetchProp ],
VoiceRope USING [Length, NB, NewRequestID, nullRequestID, PlayNB, RequestID, VoiceRope, VoiceRopeInterval ]
;

VoicePlaybackImpl: CEDAR MONITOR
IMPORTS BasicTime, MessageWindow, Process, Rope, TiogaOps, TiogaVoicePrivate, ViewerOps, VoiceRope EXPORTS TiogaVoicePrivate = {
PlayBackRequestList: TYPE = LIST OF PlayBackRequest;

playBackState: RECORD [
running: BOOLEAN _ FALSE, -- is there currently a forked instance of PlayBackProcess ?
queue: PlayBackRequestList _ NIL,
nextTime: BasicTime.Pulses,  -- time to wake up playBackProcess next
abort: BOOLEAN _ FALSE -- set when a 'stop voice playback' button is hit - playBackProcess will destroy itself next time it wakes up
];

abortCleared: CONDITION; -- signalled by PlayBackProcess when it has acted on an abort 

PlayBackRequest: TYPE = REF PlayBackRequestRec;
PlayBackRequestRec: TYPE = RECORD[
requestID: VoiceRope.RequestID _ VoiceRope.nullRequestID,
state: TiogaVoicePrivate.PlayBackRequestState _ waiting,
expectFinishedReport: BOOLEAN _ TRUE, -- if FALSE, then this entry was edited after it was queued, so go on to the next entry automatically.  See RedrawViewer.
display: BOOLEAN _ TRUE, -- if not set then there is no displaying to be done
viewer: ViewerClasses.Viewer _ NIL,
node: TiogaOpsDefs.Ref, -- the text node is assumed to contain of rope of characters in the
start: INT _ 0, -- range [start..end]: this is not checked by PlayBackProcess
end: INT _ 0, -- except that if display=FALSE then viewer, node are unused and these
currentPos: INT _ -1, -- integers are used only for counting
startTime: BasicTime.Pulses _ 0, -- when playback was started
timeRemnant: INT _ 0 -- (end-start+1) represents the duration of the rope section in 'whole characters' rounded down: this is the rounding error in voice samples (OBSOLETE)
];

 
cuePriority: Process.Priority = Process.priorityRealTime;
aVeryLongTime: BasicTime.Pulses = BasicTime.MicrosecondsToPulses[300000000];
oneSoundCharTime: BasicTime.Pulses = BasicTime.MicrosecondsToPulses[1000000/TiogaVoicePrivate.soundRopeCharsPerSecond];
waitForReportTime: BasicTime.Pulses = BasicTime.MicrosecondsToPulses[100000000];  -- 100 sec

PlayBackProcess: PROC = {
moreToDo: BOOLEAN;
nextWakeUp: BasicTime.Pulses;

Process.SetPriority[cuePriority]; 
[moreToDo, nextWakeUp] _ PlayBackNext[];

WHILE moreToDo DO
now: BasicTime.Pulses _ BasicTime.GetClockPulses[];
IF nextWakeUp - now < aVeryLongTime THEN { -- so as to cope properly with wrap-around
timeout: Process.Ticks _ Process.MsecToTicks[BasicTime.PulsesToMicroseconds[ nextWakeUp-now]/1000];
TRUSTED { Process.SetTimeout[@playBackCue, timeout]; };
Wait[];
};
[moreToDo, nextWakeUp] _ PlayBackNext[];
ENDLOOP;
};

playBackCue: CONDITION;

Wait: ENTRY PROC [] RETURNS [] ~ {
WAIT playBackCue;
};

PlayBackNext: ENTRY PROC RETURNS [moreToDo: BOOLEAN _ TRUE, nextWakeUp: BasicTime.Pulses] = {
currRequest: PlayBackRequest _ playBackState.queue.first;

IF playBackState.abort THEN {
RemoveCue[currRequest];
playBackState.queue _ NIL;
playBackState.running _ FALSE;
playBackState.abort _ FALSE;
TiogaVoicePrivate.SetVoiceViewerEditStatus[currRequest.viewer];
BROADCAST abortCleared;
RETURN [moreToDo: FALSE, nextWakeUp: 0] -- the latter only to satisfy the compiler
};

WHILE currRequest.state = done OR 
(NOT currRequest.expectFinishedReport AND currRequest.currentPos>currRequest.end) DO
prevRequest: PlayBackRequest;
RemoveCue[currRequest];
TiogaVoicePrivate.SetVoiceViewerEditStatus[currRequest.viewer];
playBackState.queue _ playBackState.queue.rest;
IF playBackState.queue = NIL THEN {
playBackState.running _ FALSE;
RETURN[moreToDo: FALSE, nextWakeUp: 0];
};
prevRequest _ currRequest;
currRequest _ playBackState.queue.first;
IF NOT prevRequest.expectFinishedReport THEN
IF currRequest.start > currRequest.end THEN currRequest.state _ done
ELSE {currRequest.startTime _ BasicTime.GetClockPulses[]; currRequest.state _ busy};
ENDLOOP;

IF currRequest.state = busy AND (currRequest.display OR NOT currRequest.expectFinishedReport) THEN {
currRequest.currentPos _ currRequest.currentPos + 1;
IF currRequest.display THEN {
IF currRequest.currentPos-2 >= currRequest.start THEN
TiogaVoicePrivate.SetVoiceLooks[currRequest.node, currRequest.currentPos-2, 1, "v"];
IF currRequest.currentPos <= currRequest.end THEN
TiogaVoicePrivate.SetVoiceLooks[currRequest.node, currRequest.currentPos, 1, "w"];
};
playBackState.nextTime _ currRequest.startTime +
(currRequest.currentPos-currRequest.start+1)*oneSoundCharTime;
}
ELSE playBackState.nextTime _ playBackState.nextTime + waitForReportTime;
RETURN[moreToDo: TRUE, nextWakeUp: playBackState.nextTime]
}; 

RemoveCue: INTERNAL PROC [request: PlayBackRequest] ~ {
IF NOT request.display THEN RETURN;
IF request.start <= request.currentPos AND request.currentPos-1 <= request.end THEN
TiogaVoicePrivate.SetVoiceLooks[request.node, request.currentPos-1, 2, "v"];
};

QueuePlayBackCue: ENTRY PROC [request: PlayBackRequest] = {
WHILE playBackState.running AND playBackState.abort DO WAIT abortCleared ENDLOOP;
IF playBackState.running 
THEN AppendRequest[request]
ELSE {
playBackState.queue _ CONS[request, NIL];
playBackState.nextTime _ BasicTime.GetClockPulses[];
playBackState.running _ TRUE;
TRUSTED {Process.Detach[FORK PlayBackProcess[]]};
};
};

AppendRequest: INTERNAL PROC [request: PlayBackRequest] = {
hangOffPoint: LIST OF PlayBackRequest _ playBackState.queue;
oneElementList: LIST OF PlayBackRequest _ CONS[request, NIL];
WHILE hangOffPoint.rest # NIL DO hangOffPoint _ hangOffPoint.rest ENDLOOP;
hangOffPoint.rest _ oneElementList
};

AbortCues: INTERNAL PROC = { IF playBackState.running THEN playBackState.abort _ TRUE };
PlayBackMenuProc: PUBLIC Menus.MenuProc = {
IF TiogaVoicePrivate.RecordingInProgress[] THEN
{  MessageWindow.Append["Stop recording before trying to play back", TRUE];
MessageWindow.Blink[];
RETURN
}; 

IF mouseButton = blue -- i.e. right
THEN PlayWholeSlab[NARROW[parent, ViewerClasses.Viewer]]
ELSE
{  viewer: ViewerClasses.Viewer;
start, end: TiogaOpsDefs.Location;
[viewer: viewer, start: start, end: end] _ TiogaOps.GetSelection[];

IF viewer = NIL THEN  -- no selection
PlayWholeSlab[NARROW[parent, ViewerClasses.Viewer]]
ELSE
{  IF ViewerOps.FetchProp[viewer, $voiceViewerInfo] # NIL 
THEN
{  IF start.node # end.node THEN ERROR; -- voice viewers only have one display node !!!!
TiogaOps.SelectPoint[viewer, start]; -- leave caret at left of playback selection
PlaySlabSection[viewer, start.node, start.where, end.where] 
}
ELSE TiogaVoicePrivate.PlaySelection[]
}
}
};

PlaySlabSection: PUBLIC PROC [viewer: ViewerClasses.Viewer, node: TiogaOpsDefs.Ref, from, to: INT] = {
nb: VoiceRope.NB;
viewerInfo: TiogaVoicePrivate.VoiceViewerInfo _ NARROW[ViewerOps.FetchProp[viewer, $voiceViewerInfo], TiogaVoicePrivate.VoiceViewerInfo];
newRequest: PlayBackRequest;
IF viewerInfo = NIL THEN RETURN; -- somebody's buggering around with the selection
IF node # TiogaOps.FirstChild[TiogaOps.ViewerDoc[viewer]] THEN ERROR;
newRequest _ NEW[PlayBackRequestRec _ [requestID: VoiceRope.NewRequestID[], viewer: viewer, node: node, start: from, end: to, currentPos: from-1]];

QueuePlayBackCue[newRequest];
[nb: nb] _ VoiceRope.PlayNB[handle: TiogaVoicePrivate.thrushHandle,
voiceRope: NEW [VoiceRope.VoiceRopeInterval _ [viewerInfo.ropeInterval.ropeID, from*TiogaVoicePrivate.soundRopeCharLength,
(to-from)*TiogaVoicePrivate.soundRopeCharLength]],
requestID: newRequest.requestID, clientData: $TiogaVoice];
IF nb # $success THEN SetPlayBackState[newRequest.requestID, done];
};

PlayWholeSlab: PUBLIC PROC [viewer: ViewerClasses.Viewer] = {
viewerInfo: TiogaVoicePrivate.VoiceViewerInfo _ NARROW[ViewerOps.FetchProp[viewer, $voiceViewerInfo], TiogaVoicePrivate.VoiceViewerInfo];
IF viewerInfo = NIL THEN
MessageWindow.Append["Not a voice window or no selection", TRUE]
ELSE {
nb: VoiceRope.NB;
node: TiogaOpsDefs.Ref _ TiogaOps.FirstChild[TiogaOps.ViewerDoc[viewer]];
nodeLength: INT _ TiogaOps.GetRope[node].Length;
newRequest: PlayBackRequest _ NEW[PlayBackRequestRec _ [requestID: VoiceRope.NewRequestID[], viewer: viewer, node: node, end: nodeLength-1, timeRemnant: viewerInfo.remnant]]; 

QueuePlayBackCue[newRequest];
[nb: nb] _ VoiceRope.PlayNB[handle: TiogaVoicePrivate.thrushHandle,
voiceRope: NEW [VoiceRope.VoiceRopeInterval _ viewerInfo.ropeInterval],
requestID: newRequest.requestID, clientData: $TiogaVoice];
IF nb # $success THEN SetPlayBackState[newRequest.requestID, done];
}
};

PlayRopeWithoutCue: PUBLIC PROC [voiceID: Rope.ROPE] = {
nb: VoiceRope.NB;
fullRope: VoiceRope.VoiceRope _ NEW [VoiceRope.VoiceRopeInterval  _ [voiceID, 0, 0]];
newRequest: PlayBackRequest;
fullRope.length _ VoiceRope.Length[handle: TiogaVoicePrivate.thrushHandle, vr: fullRope];
IF fullRope.length = 0 THEN RETURN;
IF fullRope.length = -1 THEN
{  MessageWindow.Append["non-existant voice utterance(s) found in selection", TRUE];
RETURN
};

newRequest _ NEW [PlayBackRequestRec _ [requestID: VoiceRope.NewRequestID[], display: FALSE, end: fullRope.length/TiogaVoicePrivate.soundRopeCharLength, timeRemnant: fullRope.length MOD TiogaVoicePrivate.soundRopeCharLength]];
QueuePlayBackCue[newRequest];
[nb: nb] _ VoiceRope.PlayNB[handle: TiogaVoicePrivate.thrushHandle, voiceRope: fullRope,
requestID: newRequest.requestID, clientData: $TiogaVoice];
IF nb # $success THEN SetPlayBackState[newRequest.requestID, done];
};

PlayBackInProgress: PUBLIC PROC RETURNS [BOOLEAN] = { RETURN [playBackState.running AND ~playBackState.abort] }; -- only a hint: a new playback request may be queued up and waiting for the abort to clear before becoming the new playBackState.queue 

CancelPlayBack: PUBLIC ENTRY PROC = { AbortCues[] };

GetCurrentPlayBackPos: PUBLIC PROC RETURNS [display: BOOLEAN_FALSE, viewer: ViewerClasses.Viewer_NIL, currentPos: INT_-1] = {
IF playBackState.queue#NIL THEN {
currRequest: PlayBackRequest _ playBackState.queue.first;
IF currRequest.state=busy THEN 
RETURN[currRequest.display, currRequest.viewer, currRequest.currentPos];
};
};

SetPlayBackState: PUBLIC ENTRY PROC [reqID: VoiceRope.RequestID, newState: TiogaVoicePrivate.PlayBackRequestState] = {
FOR playQ: PlayBackRequestList _ playBackState.queue, playQ.rest WHILE playQ#NIL DO
IF playQ.first.requestID = reqID THEN {
playQ.first.state _ newState;  -- worry about busyi after donei ?
IF newState=busy THEN playQ.first.startTime _ BasicTime.GetClockPulses[];
IF playQ#playBackState.queue THEN 
FOR pQ: PlayBackRequestList _ playBackState.queue, pQ.rest WHILE pQ#playQ DO
pQ.first.state _ done; -- must have missed the report
ENDLOOP;
BROADCAST playBackCue;
RETURN;
};
ENDLOOP;
};

RemoveViewerReferences: PUBLIC ENTRY PROC [viewer: ViewerClasses.Viewer] RETURNS [okay: BOOLEAN _ TRUE] = {
IF playBackState.queue = NIL THEN RETURN;
IF playBackState.queue.first.display AND playBackState.queue.first.viewer = viewer THEN RETURN [FALSE];
FOR l: LIST OF PlayBackRequest _ playBackState.queue.rest, l.rest WHILE l # NIL DO
IF l.first.viewer = viewer THEN l.first.display _ FALSE
ENDLOOP
};

RedrawViewer: PUBLIC ENTRY PROC [viewer: ViewerClasses.Viewer, newContents: Rope.ROPE, unchangedHead, deleteChars, insertChars: INT, timeRemnant: INT, age: BOOLEAN, selectionsAfterRedraw: TiogaVoicePrivate.SelectionsAfterRedraw] RETURNS [newNode: TiogaOpsDefs.Ref] = {

pViewer, sViewer: ViewerClasses.Viewer;
pStart, pEnd, sStart, sEnd: TiogaOpsDefs.Location;
pLevel, sLevel: TiogaOpsDefs.SelectionGrain;
pCaretBefore, sCaretBefore, pPendingDelete, sPendingDelete: BOOLEAN;

[viewer: pViewer, start: pStart, end: pEnd, level: pLevel, caretBefore: pCaretBefore, pendingDelete: pPendingDelete] _ TiogaOps.GetSelection[primary];
[viewer: sViewer, start: sStart, end: sEnd, level: sLevel, caretBefore: sCaretBefore, pendingDelete: sPendingDelete] _ TiogaOps.GetSelection[secondary];

newNode _ TiogaVoicePrivate.SetTiogaViewerParams[viewer, newContents];

SELECT selectionsAfterRedraw FROM
unAltered =>  -- if the selected character have been edited then we'll try to keep the selection on the same bits of voice
{  lastCharInNode: INT _ (TiogaOps.GetRope[newNode]).Length - 1;
IF pViewer = viewer THEN
{  IF pStart.node # pEnd.node THEN TiogaOps.CancelSelection[primary]
ELSE
{  pStart.node _ pEnd.node _ newNode;
IF pStart.where >= unchangedHead THEN pStart.where _ pStart.where - deleteChars + insertChars;
IF pEnd.where >= unchangedHead THEN pEnd.where _ pEnd.where - deleteChars + insertChars;
IF pStart.where > lastCharInNode THEN pStart.where _ lastCharInNode;
IF pEnd.where > lastCharInNode THEN pEnd.where _ lastCharInNode;
TiogaOps.SetSelection[viewer: pViewer, start: pStart, end: pEnd, level: pLevel, caretBefore: pCaretBefore, pendingDelete: pPendingDelete, which: primary]
}
};
IF sViewer = viewer THEN
{  IF sStart.node # sEnd.node THEN TiogaOps.CancelSelection[secondary]
ELSE
{  sStart.node _ sEnd.node _ newNode;
IF sStart.where >= unchangedHead THEN sStart.where _ sStart.where - deleteChars + insertChars;
IF sEnd.where >= unchangedHead THEN sEnd.where _ sEnd.where - deleteChars + insertChars;
IF sStart.where > lastCharInNode THEN sStart.where _ lastCharInNode;
IF sEnd.where > lastCharInNode THEN sEnd.where _ lastCharInNode;
TiogaOps.SetSelection[viewer: sViewer, start: sStart, end: sEnd, level: sLevel, caretBefore: sCaretBefore, pendingDelete: sPendingDelete, which: secondary]
}
}
};
deSelected =>
{  IF pViewer = viewer THEN TiogaOps.CancelSelection[primary];
IF sViewer = viewer THEN TiogaOps.CancelSelection[secondary]
};
primaryOnInsert =>
{  nodeLength: INT _ (TiogaOps.GetRope[newNode]).Length;
IF sViewer = viewer THEN TiogaOps.CancelSelection[secondary];
IF nodeLength = 0 THEN TiogaOps.CancelSelection[primary] -- in case the viewer is empty 
ELSE
{  pViewer _ viewer;
pStart.node _ pEnd.node _ newNode;
IF insertChars = 0 
THEN -- leave a point selection
{  pStart.where _ pEnd.where _ (IF unchangedHead > nodeLength THEN nodeLength ELSE unchangedHead);
pLevel _ point
}
ELSE
{  pStart.where _ unchangedHead;
pEnd.where _ unchangedHead + insertChars -1;
pLevel _ char
};
pCaretBefore _ pPendingDelete _ FALSE;
TiogaOps.SetSelection[viewer: pViewer, start: pStart, end: pEnd, level: pLevel, caretBefore: pCaretBefore, pendingDelete: pPendingDelete, which: primary]
}
}; 
ENDCASE => ERROR;
IF age AND insertChars # 0 THEN TiogaVoicePrivate.AgeAllViewers[viewer] ELSE TiogaVoicePrivate.ReColorViewer[viewer];
IF playBackState.queue # NIL THEN FOR p: LIST OF PlayBackRequest _ playBackState.queue, p.rest WHILE p.rest # NIL DO
currRequest: PlayBackRequest _ p.rest.first;
IF currRequest.display AND currRequest.viewer = viewer THEN
{  currRequest.node _ newNode; -- I've just changed it under your feet!! [okay - monitored]
IF currRequest.end >= unchangedHead -- if not, unaffected by the edit
THEN 
{  newRequests: LIST OF PlayBackRequest _ p.rest.rest;

IF currRequest.end >= unchangedHead + deleteChars THEN -- non-empty third part
{  start: INT _ MAX[ unchangedHead + deleteChars, currRequest.start ] 
+ (insertChars - deleteChars);
end: INT _ currRequest.end + (insertChars - deleteChars);
newRequests _ CONS[ NEW[ PlayBackRequestRec _ [requestID: currRequest.requestID, state: waiting, expectFinishedReport: TRUE, display: TRUE, viewer: viewer, node: newNode, start: start, end: end, currentPos: start-1, timeRemnant: timeRemnant]], newRequests]
};

IF currRequest.start < unchangedHead + deleteChars THEN -- non-empty second part [since request cannot lie entirely in first part - see two IFs back]
{  start: INT _ MAX[unchangedHead, currRequest.start]; 
end: INT _ MIN [unchangedHead + deleteChars - 1, currRequest.end];
newRequests _ CONS[ NEW[ PlayBackRequestRec _ [requestID: currRequest.requestID, state: waiting, expectFinishedReport: FALSE, display: FALSE, start: start, end: end, currentPos: start-1, timeRemnant: 0]], newRequests]
};

IF currRequest.start < unchangedHead THEN -- non-empty first part
{  start: INT _ currRequest.start;
end: INT _ MIN [unchangedHead - 1, currRequest.end];
newRequests _ CONS[ NEW[ PlayBackRequestRec _ [requestID: currRequest.requestID, state: waiting, expectFinishedReport: FALSE, display: TRUE, viewer: viewer, node: newNode, start: start, end: end, currentPos: start-1, timeRemnant: 0]], newRequests]
};

p.rest _ newRequests
}
}
ENDLOOP;


IF playBackState.queue # NIL THEN {
currRequest: PlayBackRequest _ playBackState.queue.first;
currentPosFound: BOOLEAN _ FALSE;
IF currRequest.display AND currRequest.viewer = viewer THEN {
newRequests: LIST OF PlayBackRequest _ playBackState.queue.rest;
currRequest.node _ newNode;
IF currRequest.end >= unchangedHead THEN {
IF currRequest.end >= unchangedHead + deleteChars THEN {
start: INT _ MAX[ unchangedHead + deleteChars, currRequest.start ] 
+ (insertChars - deleteChars);
end: INT _ currRequest.end + (insertChars - deleteChars);
currentPos: INT _ MAX [ start-1, currRequest.currentPos + (insertChars - deleteChars) ]; 
newRequests _ CONS[ NEW[ PlayBackRequestRec _ [requestID: currRequest.requestID, state: waiting, expectFinishedReport: TRUE, display: TRUE, viewer: viewer, node: newNode, start: start, end: end, currentPos: currentPos, timeRemnant: timeRemnant]], newRequests];
IF currentPos # start-1 THEN
currentPosFound _ TRUE;
};

IF (~currentPosFound) AND currRequest.start < unchangedHead + deleteChars THEN {
start: INT _ MAX[unchangedHead, currRequest.start]; 
end: INT _ MIN [unchangedHead + deleteChars - 1, currRequest.end];
currentPos: INT _ MAX [ start-1, currRequest.currentPos]; -- no need to put in a MIN clause since otherwise currentPosFound=TRUE and we'd never have got here
newRequests _ CONS[ NEW[ PlayBackRequestRec _ [requestID: currRequest.requestID, state: waiting, expectFinishedReport: FALSE, display: FALSE, viewer: viewer, node: newNode, start: start, end: end, currentPos: currentPos, timeRemnant: 0]], newRequests];
IF currentPos # start-1 THEN
currentPosFound _ TRUE;
};

IF (~currentPosFound) AND currRequest.start < unchangedHead THEN {
start: INT _ currRequest.start;
end: INT _ MIN [unchangedHead - 1, currRequest.end];
currentPos: INT _ currRequest.currentPos;
newRequests _ CONS[ NEW[ PlayBackRequestRec _ [requestID: currRequest.requestID, state: currRequest.state, expectFinishedReport: FALSE, display: TRUE, viewer: viewer, node: newNode, start: start, end: end, currentPos: currentPos, timeRemnant: 0]], newRequests]
};
newRequests.first.state _ currRequest.state;
newRequests.first.startTime _ currRequest.startTime;
playBackState.queue _ newRequests;
currRequest _ playBackState.queue.first;
};

IF currRequest.display AND currRequest.currentPos>=currRequest.start THEN {
start: INT _ MAX[currRequest.start, currRequest.currentPos-1];
len: INT _ MIN[currRequest.end, currRequest.currentPos] - start;
TiogaVoicePrivate.SetVoiceLooks[node: currRequest.node, start: start, len: len, looks: "w"];
}
}
}
};

}.

ÖVoicePlaybackImpl.mesa
Copyright Ó 1987 by Xerox Corporation.  All rights reserved.
Ades, September 24, 1986 5:11:21 pm PDT
Swinehart, April 10, 1987 9:38:59 am PDT
Polle Zellweger (PTZ) July 27, 1987 1:43:57 pm PDT


Routines replay sounds, plus all the guff to move a cue along a slab display
see TiogaVoicePrivate.mesa for the raison d'etre of this module

when placed in the playback queue, a request should have currentPos=start-1
requests with end<start should not be queued!!!
 
when a PlayBackRequest is on the head of playBackState.queue and display=TRUE then the characters currentPos and currentPos-1 in the node currentlyhave looks w instead of v, provided in each case that  start<=characterPosition<=end 
the BasicTime ClockPulses wrap around every hour [roughly]. Since we use the clock to time intervals of 250ms, five minutes is indeed aVeryLongTime for the purposes of spotting wrap-around
try to keep this process up to time: however there is compensation for delay in each wake-up by looking at a real time clock; see below

The playBackQueue contains two different kinds of requests: 
normal requests are queued by some kind of playback initiation; they have an associated VoiceRope.Play and therefore will have $started and $finished reports. expectFinishedReport=TRUE.
edited requests are created by RedrawViewer in response to user edits in front of the playback cue after a playback request; they must be started and finished more manually. expectFinishedReport=FALSE.
request arose from editing after playback queued - need to start the next piece
endcase: currRequest.timeRemnant*(1000/Jukebox.bytesPerMS) handled by $finished report
either not started, not displaying, or done displaying: wait for a report to get going again
restores any w looks to v looks, using the invariant "currentPos-1 & currentPos are the only chars that can have w looks (although they may not)"
no need to worry about node boundaries; TextEdit.ChangeLooks prunes as needed

The public procedures

general playback proc for all viewers: on a right click or if there is no primary selection, if the viewer is a voice viewer then play the whole of it otherwise do nothing; in other cases play all the voice represented in/by [for text/voice viewers] the current selection


Respond to playback progress reports from Finch/Thrush.
called in order to redraw an edited voice viewer, which may or may not be in the queue of viewers in which cues are appearing or are about to appear: newContents is the result of the edit as is timeRemnant, and the three INT arguments refer to the display prior to the edit
all voice viewers will be 'aged' by this call [see TiogaVoicePrivate for details] unless age=FALSE OR insertChars = 0
because the contents of the viewer are to be completely reset, any selections therein will be upset: how selections are to be affected must always be specified explicitly
these preserve the selection info for reasoning after the redraw
now attend to resetting selections:


process any instances of this viewer on the queue [not including the one at the head]
if this PlayBackRequest is part of something that has been edited, we need to split it into up to three sections: the first section is the unedited head of the slab, to be displayed. The second is the spliced out section, which is not to be displayed [but appears to keep the timing correct]. The third is the tail of the slab which is to be displayed: its position in the slab has in general moved. We will assemble these components in reverse order, simply because that's what CONS allows. newRequests was initialised to point to the list of entries beyond the element we are about to replace

**** this and the following section need changing so that the remnant goes in the last of the split parts, as opposed to the third part if it exists
link the new structure into the queue in place of the old one
now we have to go through all that guff again for the head of the queue, except that there is an additional complication: the head of the queue, if being played back, must have the playback looks put back into it. Also the head of the queue must be whichever of the three sections discussed above is currently being played back. Alas we must also remove any character looks corresponding to the cue before this redraw occurred
If not, unaffected by the edit [but still will need to put back the playback looks].
One advantage of going backward through these is that it's easy to stop when we find the one currently being played back.
link the new structure into the queue in place of the old head
now redraw the playback cue: beware - the head of the queue might now be a ~display entry
Swinehart, April 10, 1987 9:38:29 am PDT
Merged VoicePlayImpl and VoiceRecordImpl, from Ades. Fixed some nested ML problems resulting from merging two MONITORs.
changes to: AddVoiceProc, DictationMachine, AbortCues, CancelPlayBack
Polle Zellweger (PTZ) May 14, 1987 5:03:48 pm PDT
Trying to avoid intermittent viewer lockups. 
changes to: DIRECTORY, ChangeVoiceInputFocus, PlayBackNext, PlayBackMenuProc, RedrawViewer, IncrementRecordTimer, DoIt (local of SetPlayLooks), PlayBackNext, SetPlayLooks (new procedure)
Polle Zellweger (PTZ) May 15, 1987 7:04:36 pm PDT
Avoid using the Tioga primary selection to change looks when animating the gray square for voice play feedback; also when adding indication of new voice.  Intended as a general improvement and trying to avoid intermittent viewer lockups.
changes to: DIRECTORY, VoiceRecordPlayImpl, IncrementRecordTimer, NewRecordingMarker, DoIt (local of NewRecordingMarker), StopRecording, SetPlayLooks, DoIt (local of SetPlayLooks), PlayBackNext, RedrawViewer
Polle Zellweger (PTZ) May 22, 1987 4:51:43 pm PDT
Split back into VoicePlaybackImpl and VoiceRecordImpl: too many monitor lock difficulties to fix quickly.
Polle Zellweger (PTZ) May 27, 1987 11:24:52 am PDT
changes to: DIRECTORY, RedrawViewer(SetStyle was necessary after all - now done w/o selections)
Polle Zellweger (PTZ) May 28, 1987 4:32:22 pm PDT
New procedure to allow Marking the current playback spot directly.
changes to: GetCurrentPlayBackPos
Polle Zellweger (PTZ) June 8, 1987 6:45:18 pm PDT
Moved SetPlayLooks to VoiceViewersImpl.SetVoiceLooks; use new VoiceViewersImpl.SetTiogaViewerParams.
changes to: PlayBackNext, RedrawViewer
Polle Zellweger (PTZ) June 19, 1987 12:11:12 pm PDT
parameter change for SetVoiceLooks
changes to: PlayBackNext, RedrawViewer
Polle Zellweger (PTZ) July 20, 1987 5:12:15 pm PDT
Add Finch/Thrush error handling (disappearing conversations, etc) + voicerope monitoring.  Extensive changes to playback cue stuff; now done by following reports from Finch/Thrush rather than open-loop.
changes to: DIRECTORY, PlayBackRequestList, playBackState, abortCleared, PlayBackRequestRec, QueuePlayBackCue, AppendRequest, PlaySlabSection, PlayWholeSlab, PlayRopeWithoutCue, PlayBackProcess, PlayBackInProgress, GetCurrentPlayBackPos, SetPlayBackState, RemoveViewerReferences, RedrawViewer
Polle Zellweger (PTZ) July 27, 1987 1:43:58 pm PDT
changes to: PlaySlabSection, PlayWholeSlab, PlayRopeWithoutCue

�ʾ˜š
œ™Icode™<J™'K™(K™2K™—š
Ïk	˜	Kšœ
�œG˜VKšœ�œ
˜Jšœ�œ˜%Jšœ�œT˜aJšœ�œ
�œ˜Kšœ	�œm˜{Jšœ
�œ"˜4Jšœ�œŠ˜¡Jšœ�œ˜Jšœ
�œ˜Jšœ
�œ
�œP˜kJ˜
J˜—šÐlnœ�œ
�˜ Jš�œ\�œ˜€
—J™J™LKš
œ?™?K™Kšœ�œ�œ
�œ˜4K˜šœ�œ
˜Kšœ	�œ�œÏc<˜VKšœ�œ
˜!KšœŸ'˜DKšœ�œ�œ
Ÿm˜„
Kš
œ˜K˜—šœ�	œŸ>˜WK˜—Kšœ�œ�œ˜/šœ�œ�œ
˜"Kš
œ9˜9Kš
œ8˜8Kšœ�œŸy˜Ÿ
Kšœ	�œ�œŸ4˜MKšœ�œ
˜#KšœŸC˜[Kšœ�œŸ=˜MKšœ�œŸF˜TKšœ�œŸ&˜<Kšœ!Ÿ˜=Kšœ
�œŸ�
œ
Ÿœ
˜¬
K˜K˜Kš
œK™KKš
œ/™/Kš
œ
™
Kš
Ϗ
™è
Kš
œ
˜
—Kš
œ9˜9š
œL˜LKš
œ¼
™¼
—Kš
œw˜wKšœRŸ
˜\K˜šÏnœ�œ˜Kšœ
�œ
˜Kš
œ˜K˜Kš
œ"˜"Kš
œˆ
™ˆ
Kš
œ(˜(K˜š�œ
�˜Kš
œ3˜3š�œ"�œŸ*˜UKš
œc˜cJš�œ0˜7K˜K˜—Kš
œ(˜(Kš
�˜—K˜—K˜Kšœ
�	œ
˜K˜š œ�
œ�œ˜"Kš�œ
˜K˜—K˜š œ�œ
�œ
�œ�œ�œ#˜]™<Kš
œ¹
™¹
KšœIÏbœ{™É
—Kš
œ9˜9K˜š�œ�œ˜Kš
œ˜Kšœ�œ
˜Kšœ�œ
˜Kšœ�œ
˜Kš
œ?˜?Kš�	œ˜Kš�œ�œŸ*˜RK˜—K˜š	�œ�œ
�œ"�œ&�˜wKš
œ˜Kš
œ˜Kš
œ?˜?Kš
œ/˜/š�œ�œ
�œ˜#Kšœ�œ
˜Kš�œ�œ˜'Kš
œ˜—K˜Kš
œ(˜(š�œ
�œ"�˜,Kš
œO™OKš�œ$�œ˜DKš�œP˜T—Kš�œ
˜K˜—š�œ�œ�œ!�œ˜dKš
œ4˜4š�œ�œ˜š�œ/�˜5Kš
œT˜T—š�œ+�˜1Kš
œR˜RK˜——Kš
œo˜oKš
œV™VK˜
—š�œE˜IK™\—Kš�œ�œ%˜:Kš
œ˜K˜—š 	œ�
œ˜7Kš
œ‘
™‘
Kš�œ�˜#š�œ%�œ#�˜Sš
œL˜LK™M——K˜K˜—š œ�œ
�œ˜;Kš
�œ�œ�œ
�œ�œ
˜QKš�œ˜Kš�œ˜š�œ˜Kšœ�œ
�œ˜)Kš
œ4˜4Kšœ�œ
˜Jš�œ�œ˜1K˜—K˜K˜—š 
œ�œ
�œ˜;Jšœ�œ
�œ'˜<Jš	œ�œ
�œ�œ
�œ˜=Jš�œ�œ
�œ"�œ
˜JJ˜"J˜K˜—Kš 	œ�œ
�œ�œ�œ�œ˜XK™K™š œ�œ˜+K™�Kš�œ)�˜/šœE�œ˜KJ˜Jš
�˜—Jš
œ˜J˜Kš�œŸ
˜#Kš�œ�œ˜8Kš
�˜š
œ ˜ Kš
œ"˜"Kš
œC˜C—˜š�œ
�œ
�œŸ˜%Kšœ�œ˜3—Kš
�˜šœ�œ1�œ
˜:Kš
�˜šœ�œ�œ
�œŸ0˜XKšœ%Ÿ,˜QKš
œ<˜<—Kš
œ
˜
Kš�œ"˜&—K˜
—K˜
K˜K˜—š œ�œ
�œB�œ˜fKšœ�œ
˜Kšœ0�œS˜‰
Kš
œ˜Kš	�œ�œ
�œ
�œŸ1˜RKš�œ8�œ
�œ
˜EK™Kšœ
�œƒ
˜“
K˜Kš
œ˜š
œC˜CKšœ�œŸ
˜­
Kš
œ:˜:—Kš�œ�œ.˜CK˜K˜—š 
œ�œ
�œ#˜=Kšœ0�œS˜‰
š�œ�œ
�˜Kšœ;�œ
˜@—š�œ
˜Kšœ�œ
˜Kš
œI˜IJšœ�œ!˜0Kšœ�œŽ
˜¯
J˜Kš
œ˜š
œC˜CKšœ�œ9˜GKš
œ:˜:—Kš�œ�œ.˜CK˜
—K˜K˜—š œ�œ
�œ�œ˜8Kšœ�œ
˜Kšœ �œ2˜UKš
œ˜K™Kš
œY˜YKš�œ�œ
�œ
˜#Kš�œ�˜šœN�œ˜TJš
�˜—Jš
œ˜J˜Kšœ
�œF�œ[�œ)˜â
Kš
œ˜š
œX˜XKš
œ:˜:—Kš�œ�œ.˜CK˜K˜—š œ�œ
�œ
�œ�œ�œ�œŸ‡
˜ø
K˜—š œ�œ
�
œ˜4K˜—š œ�œ
�œ
�œ�œ
�œ�œ�œ˜}š�œ�œ
�œ˜!Kš
œ9˜9š�œ�œ
˜Kš�œB˜H—K˜—K˜K˜—š œ�œ
�œ
�œS˜vK™7š�œ>�œ�˜Sš�œ�
œ�œ˜'KšœŸÐcd
Ÿ¢
Ÿ˜AKš�œ�œ4˜Iš�œ�œ
˜"š�œ8�œ�˜LKšœŸ˜5Kš�œ
˜——Kš�	œ
˜Kš�œ
˜K˜—Kš�œ
˜—K˜K˜—š œ�œ
�œ
�œ �œ�œ�œ˜kKš�œ�œ
�œ
�œ
˜)Kš
�œ#�œ+�œ
�œ�œ˜gš�œ�œ
�œ4�œ�œ
�˜RKš�œ�œ�˜7—Kš
�˜Kš
œ˜K˜—š œ�œ
�œ
�œ2�œ+�œ�œ�œB�œ ˜ŒKš
œ‘™‘K™uK™ª
K˜K™@Kš
œ'˜'K˜2Kš
œ,˜,Kšœ<�œ
˜DK˜Kš
œ–
˜–
Kš
œ˜
˜˜
K˜KšœÏt
œ*˜FK˜K™#Kš�œ�˜!šœŸl˜zšœ�œ*˜@Kš�œ�˜šœ�œ�œ"˜DKš
�˜š
œ%˜%Kš�œ�œ9˜^Kš�œ�œ5˜XKš�œ�œ˜DKš�œ�œ˜@Kš
Ϫ
˜™
—K˜
—K˜Kš�œ�˜šœ�œ�œ$˜FKš
�˜š
œ%˜%Kš�œ�œ9˜^Kš�œ�œ5˜XKš�œ�œ˜DKš�œ�œ˜@Kš
œ›
˜›
—K˜
—K˜
—K˜—˜
šœ�œ�œ#˜>Kš�œ�œ$˜<—K˜—˜šœ�œ&˜8Kš�œ�œ%˜=Kš�œ�œ#Ÿ˜XKš
�˜š
œ˜Kš
œ"˜"Kš�œ˜Kš�œ
Ÿ˜šœ �œ�œ�œ˜bKš
œ˜—Kš
œ
˜
Kš
�˜š
œ ˜ Kš
œ,˜,Kš
œ
˜
—K˜Kšœ �œ
˜&Kš
Ϫ
˜™
—K˜
—Kš
œ˜—Kš�œ�œ
˜K™Kš�œ�œ�œ)�œ)˜uK™K™Uš�œ�œ
�œ
�œ�œ
�œ/�œ
�œ
�˜tKš
œ,˜,Kš�œ�œ�˜;šœŸ<˜[Kš�œ"Ÿ!˜EKš�œ
˜šœ�œ
�œ˜6Kš
œÒ™ÒK™K™”
K˜Kš�œ0�œ
Ÿ˜Nšœ
�œ�œR˜eKšœ�œ1˜9Kš	œ�œ�œ`�œ�œv˜€—K˜K˜Kš�œ1�œ
Ÿ]˜•
šœ
�œ�œ$˜7Kšœ�œ�œ4˜BKš	œ�œ�œ`�œ�œM˜Ù
—K˜K˜Kš�œ#�œ
Ÿ˜Ašœ
�œ˜"Kšœ�œ�œ&˜4Kš	œ�œ�œ`�œ�œl˜÷
—K˜K˜K™=Kš
œ˜—K˜
—K˜
—Kš�œ
˜K˜K™ªK˜š�œ�œ
�œ˜#Kš
œ9˜9Kšœ�œ�œ
˜!š�œ�œ�œ
˜=Kšœ
�œ
�œ,˜@Kš
œ˜š�œ"�œ
˜*Kš
œT™TKš
œy™yš�œ0�œ
˜8Kšœ�œ�œR˜bKšœ�œ1˜9Kšœ�œ�œD˜YKš	œ�œ�œ`�œ�œz˜„š�œ�˜Kšœ�œ
˜—K˜—K˜š�œ�œ1�œ
˜PKšœ�œ�œ$˜4Kšœ�œ�œ4˜BKšœ�œ�œ%Ÿc˜�
Kš	œ�œ�œ`�œ�œp˜ü
š�œ�˜Kšœ�œ
˜—K˜—K˜š�œ�œ#�œ
˜BKšœ�œ˜Kšœ�œ�œ&˜4Kšœ�œ˜)Kš	œ�œ�œj�œ�œo˜„K˜—Kš
œ,˜,Kš
œ4˜4K™>Kš
œ"˜"Kš
œ(˜(K˜—K˜K™Yš�œ�œ+�œ
˜KKšœ�œ�œ.˜>Kšœ�œ�œ2˜@Kš
œ\˜\K˜
—K˜
—K˜
—K˜K˜—J˜J˜™(K™wKšœÏr9™E—™1K™-Kšœ¤jœ¤œ™º
—™1K™í
Kšœ¤Nœ¤#œ¤™Ï
—™1K™i—™2Kšœ¤œ<™_—™1K™BKšœ¤™!—™1K™dKšœ¤™&—™3K™"Kšœ¤™&—™2K™Ê
Kšœ¤˜™¤—™2Kšœ¤2™>—K™—…—Lˆz