/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 1993-2001 by Sun Microsystems, Inc. * All rights reserved. */ #include <AudioExtent.h> #include <AudioList.h> #include <AudioDebug.h> // class AudioList methods // class AudioListEntry Constructor AudioList::AudioListEntry:: AudioListEntry( Audio* obj): // audio object to point to aptr(0), next(0), prev(0) { // A NULL object is only valid in dummy entries, such as list heads newptr(obj); } // class AudioListEntry Destructor AudioList::AudioListEntry:: ~AudioListEntry() { newptr(0); if (next != 0) { next->prev = prev; } if (prev != 0) { prev->next = next; } } // Set a new extent pointer in an AudioListEntry void AudioList::AudioListEntry:: newptr( Audio* newa) // new object { if (aptr != 0) aptr->Dereference(); aptr = newa; if (aptr != 0) aptr->Reference(); } // Link object into list // Link in a new AudioListEntry void AudioList::AudioListEntry:: link( AudioListEntry* after) // link after this one { // Link object into list prev = after; next = after->next; after->next = this; if (next != 0) next->prev = this; } // Split an AudioListEntry at the specified offset void AudioList::AudioListEntry:: split( Double pos) // split offset { AudioExtent* e1; AudioExtent* e2; AudioListEntry* newp; // Create two extents referencing this object e1 = new AudioExtent(aptr, 0., pos); e2 = new AudioExtent(aptr, pos, AUDIO_UNKNOWN_TIME); // Set the current entry to the first extent and append the second newptr(e1); newp = new AudioListEntry(e2); newp->link(this); } // class AudioList Constructor AudioList:: AudioList( const char *local_name): // name string Audio(local_name), head(0) { } // class AudioList Destructor AudioList:: ~AudioList() { // Delete all entries in the list while (first() != 0) delete first(); } // Get the first entry in the list AudioList::AudioListEntry* AudioList:: first() const { return (head.next); } // Get the extent and offset corresponding to a given position // Return FALSE if no extents in list or position is beyond eof Boolean AudioList:: getposition( Double& pos, // target position (updated) AudioListEntry*& ep) const // returned extent pointer { Double length; // Position must be specified if (Undefined(pos)) return (FALSE); // Get the first extent in the list ep = first(); while (ep != 0) { // Get length of extent length = ep->aptr->GetLength(); if (Undefined(length)) { // Can't determine sizes beyond this return (TRUE); } // If the remaining offset is inside the current extent if (length > pos) return (TRUE); // Move on to the next extent pos -= length; ep = ep->next; } return (FALSE); } // Get the total length of the audio list Double AudioList:: GetLength() const { AudioListEntry* ep; Double sum; Double x; for (sum = 0., ep = first(); ep != 0; ep = ep->next) { // Accumulate times for each extent // Indeterminate extents screw up the calculation x = ep->aptr->GetLength(); if (Undefined(x)) return (x); sum += x; } return (sum); } // Construct a name for the list char *AudioList:: GetName() const { // XXX - construct a better name return (Audio::GetName()); } // Get the audio header for the current read position AudioHdr AudioList:: GetHeader() { return (GetHeader(ReadPosition())); } // Get the audio header for the given position AudioHdr AudioList:: GetHeader( Double pos) // position { AudioListEntry* ep; // Get the extent pointer for the given position if (!getposition(pos, ep)) { AudioHdr h; if (pos != 0.) { PrintMsg(_MGET_( "AudioHdr:GetHeader()...position is beyond eof"), Warning); return (h); } if ((ep = first()) != 0) return (ep->aptr->GetHeader()); return (h); } // Get the header for the proper offset in the extent return (ep->aptr->GetDHeader(pos)); } // Copy data from list into specified buffer. // No data format translation takes place. // The object's read position is not updated. // // Since list could contain extents of differing encodings, // clients should always use GetHeader() in combination with ReadData() AudioError AudioList:: ReadData( void* buf, // destination buffer address size_t& len, // buffer size (updated) Double& pos) // start position (updated) { AudioListEntry* ep; size_t cnt; Double off; Double newpos; AudioError err; // Save buffer size cnt = len; // Position must be valid if (Undefined(pos) || (pos < 0.) || ((int)cnt < 0)) return (RaiseError(AUDIO_ERR_BADARG)); // Loop until data is returned or error // XXX - THIS IS WRONG! THE HEADER COULD CHANGE! do { // Get the extent/offset for read position; clear return count len = 0; off = pos; if (!getposition(off, ep)) { err = AUDIO_EOF; err.sys = AUDIO_COPY_INPUT_EOF; return (err); } // Save the offset and read some data newpos = off; len = cnt; err = ep->aptr->ReadData(buf, len, newpos); // If no eof on this list entry, or no more data, we're done if ((err != AUDIO_EOF) || (err.sys != AUDIO_COPY_INPUT_EOF) || (ep->next == 0)) { break; } // Advance to next list entry // XXX - Is this problemmatic, too? pos += ep->aptr->GetLength() - off; } while (TRUE); // Update the byte count and position pos += (newpos - off); // XXX - recalculate? return (err); } // Write to AudioList is (currently) prohibited AudioError AudioList:: WriteData( void*, // destination buffer address size_t& len, // buffer size (updated) Double&) // start position (updated) { len = 0; return (RaiseError(AUDIO_ERR_NOEFFECT)); } // Insert an entry at the start AudioError AudioList:: Insert( Audio* obj) // object to insert { Double pos; // insertion offset, in seconds return (Insert(obj, pos = 0.)); } // Insert an entry at a specified position AudioError AudioList:: Insert( Audio* obj, // object to insert Double pos) // insertion offset, in seconds { AudioListEntry *ep; AudioListEntry *prev; // Find the insertion point if (first() == 0) { prev = &head; // this is the first extent } else { if (!getposition(pos, prev)) { if (pos == 0.) { // Append extent to end of list return (Append(obj)); } else { return (RaiseError(AUDIO_ERR_BADARG)); } } else if (pos != 0.) { // The insertion is in an extent, split it in two prev->split(pos); } else { // Insert before the current position prev = prev->prev; } } // Create object and link into list ep = new AudioListEntry(obj); ep->link(prev); return (AUDIO_SUCCESS); } // Append an entry to a list AudioError AudioList:: Append( Audio* obj) // object to append { AudioListEntry *ep; AudioListEntry *prev; // Find the last extent in the list for (prev = &head; prev->next != 0; prev = prev->next) continue; // Create object and link into list ep = new AudioListEntry(obj); ep->link(prev); return (AUDIO_SUCCESS); } // Copy routine for lists AudioError AudioList:: AsyncCopy( Audio* to, // audio object to copy to Double& frompos, // input pos (updated) Double& topos, // output pos (updated) Double& limit) // amt to copy (updated) { AudioListEntry* ep; Double svlim; Double newpos; Double off; AudioError err; svlim = limit; // Loop until data is returned or error // XXX - THIS IS WRONG! THE HEADER COULD CHANGE! do { // Get the extent and offset for the read position off = frompos; if (!getposition(off, ep)) { // nothing written, limit should reflect this limit = 0.0; err = AUDIO_EOF; err.sys = AUDIO_COPY_INPUT_EOF; return (err); } // Save the offset and do a copy newpos = off; limit = svlim; err = ep->aptr->AsyncCopy(to, newpos, topos, limit); // If no eof on this list entry, or no more data, we're done if ((err != AUDIO_EOF) || (err.sys != AUDIO_COPY_INPUT_EOF) || (ep->next == 0)) { break; } // Advance to next list entry // XXX - Is this problemmatic, too? frompos += ep->aptr->GetLength() - off; } while (TRUE); // Update the byte count and position frompos += (newpos - off); // XXX - recalculate? return (err); }
