DIRECTORY FS USING [Read, Write], IO USING [int, PutFR, STREAM], Jukebox USING [bytesPerChirp, CloseTune, CreateTune, EOF, Error, FindChirp, MissingChirp, OpenTune, TuneSize], Process USING [Detach, Priority, priorityNormal, SetPriority], Rope USING [ROPE], VM USING [AddressForPageNumber], VoiceStream; VoiceStreamServer: MONITOR LOCKS Lock IMPORTS FS, IO, Jukebox, Process, VM, VoiceStream EXPORTS VoiceStream SHARES VoiceStream = BEGIN OPEN VoiceStream; Foo: SIGNAL = CODE; debugRuns: BOOL _ FALSE; serverPriority: Process.Priority _ Process.priorityNormal; getServerBuffer: ENTRY PROC RETURNS [handle: Handle] = { ENABLE UNWIND => NULL; buffer: REF Buffer; WHILE TRUE DO handle _ VSList; WHILE handle # NIL DO IF (handle.errorRope = NIL) THEN { IF (handle.firstServerBuffer # NIL) THEN { buffer _ handle.firstServerBuffer; handle.firstServerBuffer _ buffer.next; buffer.next _ handle.firstIdleBuffer; handle.firstIdleBuffer _ buffer; RETURN [handle]; } ELSE IF (handle.piece # NIL) THEN { IF handle.firstClientBuffer = NIL THEN RETURN [handle]; IF (NOT handle.piece.flush AND (handle.piece.nBytes > 0) AND (handle.firstIdleBuffer # NIL)) THEN RETURN [handle]; }; }; handle _ handle.next; ENDLOOP; BROADCAST closeCondition; WAIT serverCondition; ENDLOOP; }; giveClientBuffer: ENTRY PROC [handle: Handle] = { ENABLE UNWIND => NULL; buffer, b2: REF Buffer; buffer _ handle.firstIdleBuffer; handle.firstIdleBuffer _ buffer.next; buffer.next _ NIL; IF handle.firstClientBuffer = NIL THEN { handle.firstClientBuffer _ buffer; NOTIFY handle.newPiece; } ELSE { b2 _ handle.firstClientBuffer; WHILE b2.next # NIL DO b2 _ b2.next ENDLOOP; b2.next _ buffer; }; BROADCAST client; }; setError: PUBLIC ENTRY PROC [handle: Handle, rope: Rope.ROPE, code: ErrorCode] = { ENABLE UNWIND => NULL; handle.errorRope _ rope; handle.errorCode _ code; BROADCAST client; BROADCAST waitCondition; }; getPiece: ENTRY PROC [handle: Handle] RETURNS [REF Piece] = { ENABLE UNWIND => NULL; p: REF Piece; WHILE TRUE DO p _ handle.piece; IF p = NIL THEN RETURN [NIL]; IF p.flush THEN p.nBytes _ 0; IF p.nBytes > 0 THEN RETURN [p]; IF (handle.firstClientBuffer # NIL) OR (handle.firstServerBuffer # NIL) THEN RETURN [NIL]; IF p.tune # NIL THEN { p _ p.next; IF p # NIL THEN IF p.tuneId = handle.piece.tuneId THEN { p.tune _ handle.piece.tune; handle.piece.tune _ NIL; }; }; IF handle.piece.tune # NIL THEN Jukebox.CloseTune[handle.jukebox, handle.piece.tune]; handle.piece _ handle.piece.next; IF handle.piece = NIL THEN BROADCAST client; ENDLOOP; RETURN [NIL]; }; server: PROC [] = { handle: Handle; buffer: REF Buffer; ourSize: INT; skipLeading: INT; piece: REF Piece; noChirp: BOOLEAN; Process.SetPriority[serverPriority]; WHILE TRUE DO ENABLE { Jukebox.Error => { setError[handle: handle, code: BadPiece, rope: IO.PutFR["Piece for tune id %d starting at byte %d can't be accessed.", IO.int[piece.tuneId], IO.int[piece.firstByte]]]; CONTINUE; }; Jukebox.EOF => { piece.nBytes _ 0; CONTINUE; }; ANY => { setError[handle: handle, code: Bug, rope: "Unknown error in voice stream demon."]; REJECT; }; }; handle _ getServerBuffer[]; buffer _ handle.firstIdleBuffer; IF buffer.toJukebox AND buffer.valid THEN { buffer.valid _ FALSE; buffer.window _ Jukebox.FindChirp[self: handle.jukebox, tune: handle.piece.tune, chirp: buffer.chirp, signalMissingChirp: FALSE, signalEOF: FALSE]; IF buffer.bytesAccountedFor < Jukebox.bytesPerChirp THEN { IF (buffer.runIndex MOD 2) # 0 THEN { IF buffer.runData.runArray[buffer.runIndex] = 0 THEN buffer.runIndex _ buffer.runIndex - 1 ELSE { buffer.runIndex _ buffer.runIndex + 1; buffer.runData.runArray[buffer.runIndex] _ 0; }; }; buffer.runData.runArray[buffer.runIndex] _ buffer.runData.runArray[buffer.runIndex] + (Jukebox.bytesPerChirp - buffer.bytesAccountedFor); }; CheckRunData[buffer]; FS.Write[file: buffer.window.file, to: buffer.window.base, nPages: buffer.chirpSpace.count, from: VM.AddressForPageNumber[buffer.chirpSpace.page]]; }; piece _ getPiece[handle]; IF piece = NIL THEN LOOP; buffer.keyIndex _ piece.keyIndex; IF (piece.tune = NIL) THEN { IF (piece.create) THEN piece.tune _ Jukebox.CreateTune[self: handle.jukebox, tuneId: piece.tuneId] ELSE piece.tune _ Jukebox.OpenTune[self: handle.jukebox, tuneId: piece.tuneId, write: NOT piece.playback]; }; IF piece.firstByte < 0 THEN piece.firstByte _ Jukebox.TuneSize[piece.tune] * Jukebox.bytesPerChirp; buffer.chirp _ piece.firstByte / Jukebox.bytesPerChirp; skipLeading _ piece.firstByte MOD Jukebox.bytesPerChirp; buffer.bytesAccountedFor _ skipLeading; ourSize _ Jukebox.bytesPerChirp - skipLeading; IF piece.nBytes < ourSize THEN { IF piece.playback THEN ourSize _ piece.nBytes ELSE piece.nBytes _ ourSize; IF piece.playback THEN buffer.bytesAccountedFor _ Jukebox.bytesPerChirp - ourSize; }; piece.nBytes _ piece.nBytes - ourSize; piece.firstByte _ piece.firstByte + ourSize; buffer.runIndex _ 0; IF (ourSize # Jukebox.bytesPerChirp) OR piece.playback THEN { noChirp _ FALSE; buffer.window _ Jukebox.FindChirp[self: handle.jukebox, tune: piece.tune, chirp: buffer.chirp, signalEOF: piece.playback, signalMissingChirp: TRUE ! Jukebox.MissingChirp => {noChirp _ TRUE; CONTINUE}]; IF noChirp THEN { IF piece.playback THEN { buffer.block.startIndex _ 0; buffer.block.stopIndexPlusOne _ 0; buffer.runData.runArray[0] _ ourSize; buffer.runData.packetSize _ 0; } ELSE { -- build a fake chirp with the right structure buffer.block.startIndex _ 0; buffer.block.stopIndexPlusOne _ ourSize; buffer.runData.runArray[0] _ skipLeading; buffer.runData.packetSize _ 0; }; } ELSE { FS.Read[file: buffer.window.file, from: buffer.window.base, nPages: buffer.chirpSpace.count, to: VM.AddressForPageNumber[buffer.chirpSpace.page]]; IF skipLeading > 0 THEN { runSize: CARDINAL; silenceRunType: BOOL; buffer.block.startIndex _ 0; DO runSize _ buffer.runData.runArray[buffer.runIndex]; silenceRunType _ (buffer.runIndex MOD 2) = 0; IF skipLeading >= runSize THEN { skipLeading _ skipLeading - runSize; IF NOT silenceRunType THEN buffer.block.startIndex _ buffer.block.startIndex + runSize; buffer.runIndex _ buffer.runIndex + 1; } ELSE { -- last run IF NOT silenceRunType THEN buffer.block.startIndex _ buffer.block.startIndex + skipLeading; buffer.runData.runArray[buffer.runIndex] _ runSize - skipLeading; EXIT; }; ENDLOOP; buffer.block.stopIndexPlusOne _ buffer.block.startIndex + ourSize; } ELSE { buffer.block.startIndex _ 0; buffer.block.stopIndexPlusOne _ ourSize; }; }; } ELSE { -- whole chirp is involved and it is record buffer.block.startIndex _ 0; buffer.block.stopIndexPlusOne _ ourSize; buffer.runData.runArray[0] _ 0; buffer.runData.packetSize _ 0; }; buffer.toJukebox _ NOT piece.playback; giveClientBuffer[handle]; ENDLOOP; }; PrivRunDataObject: PRIVATE TYPE = RECORD [ runArray: ARRAY [0..95) OF CARDINAL, packetSize: CARDINAL ]; CheckRunData: PROC [buffer: REF VoiceStream.Buffer] = { mrd: LONG POINTER TO PrivRunDataObject _ LOOPHOLE[buffer.runData]; total: CARDINAL _ 0; run: CARDINAL; FOR ri: NAT IN [0..95) DO run _ mrd.runArray[ri]; IF run > Jukebox.bytesPerChirp THEN { mrd.runArray[ri] _ Jukebox.bytesPerChirp - total; IF debugRuns THEN SIGNAL Foo; EXIT; }; total _ total + run; IF total > Jukebox.bytesPerChirp THEN { mrd.runArray[ri] _ run - (total - Jukebox.bytesPerChirp); IF debugRuns THEN SIGNAL Foo; EXIT; }; IF total = Jukebox.bytesPerChirp THEN EXIT; ENDLOOP; }; StartServer: PUBLIC PROC [stream: IO.STREAM] = { ioStream _ stream; }; Init: PROC = { p: PROCESS; p _ FORK server[]; Process.Detach[p]; }; Init[]; END. 1983, Stewart, run-encoded chirps December 27, 1983 1:56 pm, Stewart, Cedar 5 File: VoiceStreamServer.mesa This file contains part of the implementation of voicestreams. The routines in this file implement the voicestream server, a background process that transfers information between disk and buffers in voicestreams. Last Edited by: Ousterhout, March 8, 1983 11:39 am compile Last Edited by: Stewart, January 3, 1984 11:47 am This is a monitor procedure used by the server to wait for work to do. For the server to have work to do, there must not be any errors associated with the stream. Furthermore, either there must be a buffer waiting for the server, or there must be an idle buffer and there must be a valid piece waiting for the server. If there is a server buffer waiting, this routine transfers the frontmost server buffer to the front of the idle list, from which position the server will process it. Note: it doesn't make any difference how the buffers on the idle list are ordered. Notify anybody trying to close a stream that we've done all the work we can, and are waiting. This procedure just records error information in a voice stream and wakes up waiting clients. This is made a separate procedure because exclusive access is needed on the voice stream, which the server doesn't have. This procedure is called only by the server. It is made a separate procedure in order to guarantee exclusive access to the voice stream information. Because of the high overheads in opening and closing tunes, we check the next piece and if it's the same tune, then don't bother closing the current one. NIL is returned if either there are no pieces left, or if all the space of the frontmost piece is allocated to buffers but the buffers haven't been processed completely. This means we can't buffer ahead across pieces, but the alternative results in messy synchronization problems. This procedure is responsible for buffering ahead and behind the client processes. Be VERY careful with this code. The procedure runs unmonitored, so that other processes can be getting and putting voice data while we do disk operations. However, you must be extremely careful to make sure that the processes don't get in each others' way. On EOF, just discard the rest of the current piece. IO.PutRope[ioStream, "Unknown error in voice stream demon.\n"]; If this buffer is to be written, and the buffer is valid, then write it out. make sure that no partial chirps are recorded! fill the rest of the chirp with silence IO.PutF[ioStream, "Wrote chirp %d to disk.\n", IO.int[buffer.chirp]]; Collect information for the next buffer's worth of voice. First of all, find a piece that isn't empty. ioStream.PutF["Number of bytes left: %d\n", IO.int[piece.nBytes]]; Set up the encryption key index (copy over from piece). Make sure that the tune is open. Figure out which chirp this is. Figure out which portion of the chirp we'll actually use. Trim the tail if needed disallow a recording that ends in the middle of a chirp Account for the part of the piece in this chirp. Read in the chirp, if necessary. Note: we don't look up the disk location until its time to actually transfer information. This way, the jukebox routines won't allocate the space until it's actually needed. Also, for playback we substitute a homemade all zero chirp if there isn't a chirp on the disk. Construct a chirp with a single run of silence Read in the whole chirp, including its runData The value of skipLeading is the amount to chase down the runData skip the whole run Not all of this is needed, since some might be silence, but we don't know how much and don't want to spend the time analyzing the runData. IO.PutF[ioStream, "Read chirp %d from disk.\n", IO.int[buffer.chirp]]; This record represents the extra space in each chirp, after the end of recorded voice. This procedure simply forks the stream buffer server and initializes shared state. Ê ˜Jšœ™JšœC™CJšœD™DJšœ>™>Jšœ ™ J˜Jšœ:™:Jšœ1™1J˜šÏk ˜ Jšœœ˜Jšœœœ˜Jšœœ(œ6˜nJšœœ1˜>Jšœœœ˜Jšœœ˜ J˜ J˜—Jšœœœ˜%Jšœœœœ ˜1Jšœ ˜šœ˜J˜—Jšœœ ˜Jšœœœ˜Jšœ œœ˜J˜:J˜šœœœœ˜8J˜Jšœ6™6Jšœ9™9Jšœ@™@Jšœ>™>Jšœ>™>JšœB™BJšœ9™9Jšœ:™:Jšœ8™8Jšœ™J˜Jšœœœ˜J˜Jšœœ˜J˜šœœ˜ J˜šœ œ˜šœœœ˜"šœœœ˜*J˜"J˜'J˜%J˜ Jšœ ˜Jšœ˜—š˜šœœœ˜Jšœœœœ ˜7šœœ˜Jšœ˜Jšœœ˜#Jšœœ ˜—Jšœ ˜ ——Jšœ˜—J˜Jšœ˜J˜—Jšœ;™;Jšœ!™!J˜Jš œ˜Jšœ˜Jšœ˜—Jšœ˜J˜—J˜šœœœ˜1Jšœœœ˜J˜Jšœ œ˜J˜J˜ J˜%Jšœœ˜Jšœ˜!šœ˜Jšœ"˜"Jšœ˜J˜—šœ˜J˜Jšœ œœœ˜,J˜Jšœ˜—Jš œ˜Jšœ˜J˜—š œ œœœœ˜RJ˜Jšœ8™8Jšœ=™=Jšœ9™9Jšœ&™&J˜Jšœœœ˜J˜J˜Jš œ˜Jš œ˜Jšœ˜J˜—J˜Jš œ œœœœ ˜=˜Jšœ,™,J˜Jšœ?™?JšœF™FJšœA™AJšœA™AJšœG™GJšœD™DJšœ>™>Jšœ<™