1 files changed, 646 insertions, 580 deletions

diff --git a/src/stable/myriad.cpp b/src/stable/myriad.cpp
index 86f651e..53250c2 100644
--- a/src/stable/myriad.cpp
+++ b/src/stable/myriad.cpp
@@ -1,24 +1,25 @@
-/*
- * Copyright (C) 2007-2023 Xagasoft, All rights reserved.
- *
- * This file is part of the libbu++ library and is released under the
- * terms of the license contained in the file LICENSE.
- */
-
-#include "bu/config.h"
 #include "bu/myriad.h"
-#include "bu/stream.h"
 #include "bu/myriadstream.h"
+
+#include "bu/membuf.h"
 #include "bu/mutexlocker.h"
-#include <stdio.h>
+#include "bu/util.h"
 
 #include "bu/sio.h"
-using Bu::sio;
-using Bu::Fmt;
 
 #define Myriad_MAGIC_CODE       ((unsigned char *)"\x0a\xd3\xfa\x84")
 
-#define TRACE( x ) Bu::println("%1:%2: %3: %4 - %5").arg(__FILE__).arg( __LINE__ ).arg(__PRETTY_FUNCTION__).arg(sStore.getLocation()).arg(x)
+#define MyriadRead( target, size ) if( rBacking.read( target, size ) < size ) \
+{ \
+    throw Bu::MyriadException( Bu::MyriadException::invalidFormat, \
+        "Insufficient data reading myriad data from backing stream."); \
+} (void)0
+
+#define ReqRead( stream, target, size ) if( stream.read( target, size ) < size ) \
+{ \
+    throw Bu::MyriadException( Bu::MyriadException::invalidFormat, \
+        "Insufficient data reading from myriad stream."); \
+} (void)0
 
 namespace Bu
 {
@@ -28,779 +29,844 @@ namespace Bu
     }
 }
 
-Bu::Myriad::Myriad( Bu::Stream &sStore, int iBlockSize, int iPreallocate ) :
-    sStore( sStore ),
+Bu::Myriad::Myriad( Bu::Stream &rBacking, int iBlockSize,
+        int iPreallocateBlocks ) :
+    rBacking( rBacking ),
     iBlockSize( iBlockSize ),
-    iBlocks( 0 ),
-    iUsed( 0 ),
-    bHeaderChanged( false )
+    iBlockCount( 0 ),
+    bIsNewStream( true ),
+    bStructureChanged( false ),
+    iLastUsedIndex( -1 )
 {
-    try
+    if( !rBacking.isSeekable() )
     {
-        initialize();
+        throw Bu::MyriadException( Bu::MyriadException::invalidBackingStream,
+                "Myriad backing stream must be random access (seekable).");
     }
-    catch( Bu::MyriadException &e )
+    if( rBacking.getSize() == 0 )
     {
-        if( e.getErrorCode() == MyriadException::emptyStream )
-        {
-            initialize( iBlockSize, iPreallocate );
-        }
-        else
-        {
-            throw;
-        }
+        createMyriad( iBlockSize, iPreallocateBlocks );
+    }
+    else
+    {
+        loadMyriad();
     }
 }
 
 Bu::Myriad::~Myriad()
 {
-    mActiveBlocks.lock();
-    TRACE("mActiveBlocks locked.");
-    if( !hActiveBlocks.isEmpty() )
-    {
-        sio << "Bu::Myriad::~Myriad(): Error: There are "
-            << hActiveBlocks.getSize() << " unsynced blocks!" << sio.nl;
-    }
-    TRACE("mActiveBlocks unlocking...");
-    mActiveBlocks.unlock();
-    sync();
+    writeHeader();
+}
+
+Bu::MyriadStream Bu::Myriad::create( Bu::Myriad::Mode eMode,
+        int32_t iPreallocateBytes )
+{
+    Bu::MutexLocker l( mAccess );
 
-    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    Stream *pStream = new Stream( *this, ++iLastUsedIndex, 0 );
+    int iBlocks = std::max(1, blkDiv( iPreallocateBytes, iBlockSize ));
+    for( int j = 0; j < iBlocks; j++ )
     {
-        delete *i;
+        pStream->aBlocks.append( __allocateBlock() );
     }
+    mhStream.lock();
+    hStream.insert( pStream->iStream, pStream );
+    mhStream.unlock();
+    bStructureChanged = true;
+
+    return Bu::MyriadStream( *this, pStream, eMode&ReadWrite );
 }
 
-void Bu::Myriad::sync()
+Bu::MyriadStream Bu::Myriad::open( Bu::Myriad::StreamId iStream,
+        Bu::Myriad::Mode eMode )
 {
-    updateHeader();
-
-    mActiveBlocks.lock();
-    TRACE("mActiveBlocks locked.");
-    for( BlockHash::iterator i = hActiveBlocks.begin(); i; i++ )
+    Stream *pStream = NULL;
+    Bu::MutexLocker l( mhStream );
+    if( (eMode&Create) )
     {
-        if( (*i)->bChanged )
+        if( hStream.has( iStream ) )
+        {
+            if( (eMode&Exclusive) )
+            {
+                throw Bu::MyriadException( MyriadException::noSuchStream,
+                    "Stream exists.");
+            }
+        }
+        else
         {
-            syncBlock( *i );
+            Bu::MutexLocker l( mAccess );
+            if( iStream >= iLastUsedIndex )
+            {
+                iLastUsedIndex = iStream;
+            }
+            pStream = new Stream( *this, iStream, 0 );
+            pStream->aBlocks.append( __allocateBlock() );
+            hStream.insert( pStream->iStream, pStream );
+            bStructureChanged = true;
         }
     }
-    TRACE("mActiveBlocks unlocked...");
-    mActiveBlocks.unlock();
-}
-
-void Bu::Myriad::initialize()
-{
-    MutexLocker mLock( mHeader );
-    TRACE("mHeader locked.");
-    lFreeBlocks.clear();
-    sStore.setPosEnd( 0 );
-    Bu::size iSize = sStore.tell();
-    sStore.setPos( 0 );
-
-    unsigned char buf[4];
-    if( sStore.read( buf, 4 ) < 4 )
+    if( !hStream.has( iStream ) )
     {
-        TRACE("mHeader unlocked...");
-        throw MyriadException( MyriadException::emptyStream,
-                "Input stream appears to be empty.");
+        throw Bu::MyriadException( MyriadException::noSuchStream,
+            "No such stream.");
     }
-    if( memcmp( buf, Myriad_MAGIC_CODE, 4 ) )
     {
-        TRACE("mHeader unlocked...");
-        throw MyriadException( MyriadException::invalidFormat,
-            "Stream does not appear to be a valid Myriad format.");
+        Bu::MutexLocker l2( mBacking );
+        if( (eMode&Write) && !rBacking.isWritable() )
+        {
+            throw Bu::MyriadException( MyriadException::badMode,
+                "Backing stream does not support writing.");
+        }
     }
-    sStore.read( buf, 2 );
-    if( buf[0] != 1 )
+    if( pStream == NULL )
     {
-        TRACE("mHeader unlocked...");
-        throw MyriadException( MyriadException::badVersion,
-            "We can only handle version 1 for now.");
+        pStream = hStream.get( iStream );
     }
-    if( buf[1] != 32 )
+    if( (eMode&Truncate) )
     {
-        TRACE("mHeader unlocked...");
-        throw MyriadException( MyriadException::invalidWordSize,
-            "We can only handle 32-bit words at the moment.");
+        pStream->setSize( 0 );
     }
-    sStore.read( &iBlockSize, 4 );
-    int iStreams;
-    sStore.read( &iStreams, 4 );
-
-    iBlocks = iSize/iBlockSize;
-    //sio << "Myriad: iSize=" << iSize << ", iBlockSize=" << iBlockSize
-    //  << ", iBlocks=" << iBlocks << ", iStreams=" << iStreams << sio.nl;
+    return Bu::MyriadStream( *this, pStream, eMode );
+}
 
-    int iHeaderSize = 14 + 8 + 4;
-    int iHeaderBlocks = 0; //blkDiv( iHeaderSize+4, iBlockSize );
+Bu::Myriad::StreamId Bu::Myriad::allocate()
+{
+    Bu::MutexLocker l( mAccess );
 
-    while( iHeaderSize > iHeaderBlocks*iBlockSize )
-    {
-        iHeaderBlocks = blkDiv( iHeaderSize+4, iBlockSize );
-        iHeaderSize = 14 + 8 + 4*iHeaderBlocks;
-    }
+    Stream *pStream = new Stream( *this, ++iLastUsedIndex, 0 );
+    mhStream.lock();
+    hStream.insert( pStream->iStream, pStream );
+    mhStream.unlock();
+    bStructureChanged = true;
 
-    //sio << "Myriad: iHeaderSize=" << iHeaderSize
-    //  << ", iHeaderBlocks=" << iHeaderBlocks << sio.nl;
+    return pStream->iStream;
+}
 
-    Stream *pFakeHdr = new Stream;
-    pFakeHdr->iId = 0;
-    pFakeHdr->iSize = iHeaderSize;
-    for( int j = 0; j < iHeaderBlocks; j++ )
+void Bu::Myriad::erase( Bu::Myriad::StreamId iStream )
+{
+    // For now, let's prevent you from erasing a stream if it's open.
+    Bu::MutexLocker l( mhStream );
+    if( !hStream.has( iStream ) )
     {
-        pFakeHdr->aBlocks.append( j );
+        throw Bu::MyriadException( Bu::MyriadException::noSuchStream,
+                "No such stream exists.");
     }
-
-//  sio << "Blocks: " << iBlocks << " (size = " << iSize << "/" << iBlockSize
-//      << ")" << sio.nl;
-    Bu::BitString bsBlockUsed( iBlocks, false );
-    bsBlockUsed.clear();
-
-//  bool bCanSkip = false; // Can skip around, post initial header stream i/o
-    MyriadStream *pIn = new MyriadStream( *this, pFakeHdr );
-    pIn->setPos( sStore.tell() );
-    for( int j = 0; j < iStreams; j++ )
+    Stream *pStream = hStream.get( iStream );
     {
-        aStreams.append( new Stream() );
-        Stream &s = *aStreams[j];
-        pIn->read( &s.iId, 4 );
-        pIn->read( &s.iSize, 4 );
-        int iSBlocks = blkDiv(s.iSize, iBlockSize);
-    //  sio << "Myriad: - Stream::iId=" << s.iId
-    //      << ", Stream::iSize=" << s.iSize
-    //      << ", Stream::aBlocks=" << iSBlocks
-    //      << ", pIn->tell()=" << pIn->tell() << sio.nl;
-        for( int k = 0; k < iSBlocks; k++ )
+        Bu::MutexLocker sl( pStream->mAccess );
+        if( pStream->iOpenCount > 0 )
         {
-            int iBId;
-            pIn->read( &iBId, 4 );
-    //      sio << "Myriad:   - iBId=" << iBId
-    //          << ", iStartPos=" << iBId*iBlockSize
-    //          << ", pIn->tell()=" << pIn->tell() << sio.nl;
-            s.aBlocks.append( iBId );
-            bsBlockUsed.setBit( iBId );
-            iUsed++;
-            if( (j == 0 && k == iHeaderBlocks-1) )
-            {
-    //          sio << "Myriad:   - End of prepartition, unlocking skipping."
-    //              << sio.nl;
-//              bCanSkip = true;
-                MyriadStream *pTmp = new MyriadStream( *this, aStreams[0] );
-    //          sio << "Myriad    - Position = " << pIn->tell() << sio.nl;
-                pTmp->setPos( pIn->tell() );
-                delete pIn;
-                delete pFakeHdr;
-                pIn = pTmp;
-            }
+            throw Bu::MyriadException( Bu::MyriadException::streamOpen,
+                    "Cannot currently erase a stream while it is open.");
         }
-    }
-    delete pIn;
 
-    for( int j = 0; j < iBlocks; j++ )
-    {
-        if( bsBlockUsed.getBit( j ) == false )
+        for( Bu::Array<int32_t>::iterator i = pStream->aBlocks.begin(); i; i++ )
         {
-//          sio << "Preinitialized block " << j << " is free." << sio.nl;
-            lFreeBlocks.append( j );
+            releaseBlock( *i, false );
         }
+        pStream->aBlocks.clear();
+        hStream.erase( iStream );
     }
-//  sio << "Myriad: Blocks used: " << bsBlockUsed.toString() << sio.nl;
-    TRACE("mHeader unlocked...");
+    delete pStream;
 }
 
-void Bu::Myriad::initialize( int iBlockSize, int iPreAllocate )
+void Bu::Myriad::setSize( Bu::Myriad::StreamId iStream,
+        int32_t iNewSize )
 {
-    MutexLocker mLock( mHeader );
-    TRACE("mHeader locked.");
-    lFreeBlocks.clear();
-
-    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    Stream *pStream;
     {
-        delete *i;
-    }
-    aStreams.clear();
-    iUsed = 0;
-
-    int iHeaderSize = 14 + 8 + 4;
-    int iHeaderBlocks = 0; //blkDiv( iHeaderSize+4, iBlockSize );
-    char cBuf = 1;
-    int iBuf = 0;
-    
-    Stream *pStr = new Stream;
-    pStr->iId = 0;
-
-    while( iHeaderSize > iHeaderBlocks*iBlockSize )
-    {
-        iHeaderBlocks = blkDiv( iHeaderSize+4, iBlockSize );
-        iHeaderSize = 14 + 8 + 4*iHeaderBlocks;
+        Bu::MutexLocker l( mhStream );
+        pStream = hStream.get( iStream );
     }
+    pStream->setSize( iNewSize );
+}
 
-    iPreAllocate += iHeaderBlocks;
+int32_t Bu::Myriad::getSize( StreamId iStream ) const
+{
+    Bu::MutexLocker l( mhStream );
+    return hStream.get( iStream )->getSize();
+}
 
-    //sio << "Myriad: iHeaderSize=" << iHeaderSize << ", iBlockSize="
-    //  << iBlockSize << ", iHeaderBlocks=" << iHeaderBlocks << sio.nl;
-    
-//  bsBlockUsed.setSize( iPreAllocate, true );
-    iUsed++;
+bool Bu::Myriad::exists( StreamId iStream ) const
+{
+    Bu::MutexLocker l( mhStream );
+    return hStream.has( iStream );
+}
 
-    char *pBlock = new char[iBlockSize];
-    memset( pBlock, 0, iBlockSize );
-    for( int j = 0; j < iPreAllocate; j++ )
-    {
-        sStore.write( pBlock, iBlockSize );
-    }
-    delete[] (char *)pBlock;
+Bu::String Bu::Myriad::getLocation() const
+{
+    Bu::MutexLocker l( mAccess );
+    Bu::MutexLocker l2( mBacking );
+    return Bu::String("myriad(%1,%2):%3")
+        .arg( 1 ).arg( iBlockSize ).arg( rBacking.getLocation() );
+}
 
-    sStore.setPos( 0 );
+int32_t Bu::Myriad::getBlockSize() const
+{
+    Bu::MutexLocker l( mAccess );
+    return iBlockSize;
+}
 
-    // Magic number
-    sStore.write( Myriad_MAGIC_CODE, 4 );
+int32_t Bu::Myriad::getTotalBlocks() const
+{
+    Bu::MutexLocker l( mAccess );
+    return iBlockCount;
+}
 
-    // Version (0)
-    sStore.write( &cBuf, 1 );
+int32_t Bu::Myriad::getUsedBlocks() const
+{
+    Bu::MutexLocker l( mAccess );
+    return iBlockCount-lFreeBlocks.getSize();
+}
 
-    // Bits per int
-    cBuf = 32;
-    sStore.write( &cBuf, 1 );
+int32_t Bu::Myriad::getFreeBlocks() const
+{
+    Bu::MutexLocker l( mAccess );
+    return lFreeBlocks.getSize();
+}
 
-    // The size of each block
-    sStore.write( &iBlockSize, 4 );
+int32_t Bu::Myriad::getTotalStreams() const
+{
+    Bu::MutexLocker l( mhStream );
+    return hStream.getSize();
+}
 
-    iBuf = 1;
-    // The number of streams
-    sStore.write( &iBuf, 4 );
-    
-    // Stream header
-    iBuf = 0;
-    sStore.write( &iBuf, 4 );
-    sStore.write( &iHeaderSize, 4 );
-    for( iBuf = 0; iBuf < iHeaderBlocks; iBuf++ )
+int32_t Bu::Myriad::getTotalUsedBytes() const
+{
+    Bu::MutexLocker l( mhStream );
+    int32_t iTotal = 0;
+    for( StreamHash::const_iterator i = hStream.begin(); i; i++ )
     {
-        sStore.write( &iBuf, 4 );
+        iTotal += i.getValue()->getSize();
     }
 
-    this->iBlockSize = iBlockSize;
-    this->iBlocks = iPreAllocate;
-    
-    pStr->iSize = sStore.tell();
-//  sio << "Myriad: Actual end of header stream = " << pStr->iSize << sio.nl;
+    return iTotal;
+}
 
-    pStr->iSize = iHeaderSize;
-    for( int j = 0; j < iHeaderBlocks; j++ )
+int32_t Bu::Myriad::getTotalUnusedBytes(int32_t iAssumeBlockSize ) const
+{
+    if( iAssumeBlockSize < 0 )
     {
-//      sio << "Started block " << j << " is header." << sio.nl;
-        pStr->aBlocks.append( j );
-//      bsBlockUsed.setBit( j );
-        iUsed++;
+        iAssumeBlockSize = getBlockSize();
     }
-    for( int j = iHeaderBlocks; j < this->iBlocks; j++ )
+    int32_t iTotal = 0;
     {
-//      sio << "Started block " << j << " is free." << sio.nl;
-        lFreeBlocks.append( j );
+        Bu::MutexLocker l( mhStream );
+        for( StreamHash::const_iterator i = hStream.begin(); i; i++ )
+        {
+            if( (i.getValue()->getSize()%iAssumeBlockSize) > 0 )
+                iTotal += iBlockSize-(i.getValue()->getSize()%iAssumeBlockSize);
+        }
     }
 
-    aStreams.append( pStr );
+    {
+        Bu::MutexLocker l( mAccess );
+        iTotal += lFreeBlocks.getSize()*iBlockSize;
+    }
 
-    //sio << bsBlockUsed.toString() << " - " << pStr->aBlocks << sio.nl;
+    return iTotal;
+}
 
-    bHeaderChanged = true;
-    //hStreams.insert( 0, BlockArray( 0 ) );
-    TRACE("mHeader unlocked...");
+Bu::Myriad::StreamIdList Bu::Myriad::getStreamList() const
+{
+    mhStream.lock();
+    StreamIdList lIds = hStream.getKeys();
+    mhStream.unlock();
+    lIds.sort();
+    if( lIds.first() == 0 )
+    {
+        lIds.eraseFirst();
+    }
+    return lIds;
 }
 
-void Bu::Myriad::updateHeader()
+Bu::BitString Bu::Myriad::buildBlockUseMap() const
 {
-    MutexLocker mLock( mHeader );
-    TRACE("mHeader locked.");
+    Bu::MutexLocker l( mAccess );
+    Bu::BitString bsMap( iBlockCount );
+    bsMap.fill();
+    for( IndexList::const_iterator i = lFreeBlocks.begin(); i; i++ )
+    {
+        bsMap.setBit( *i, false );
+    }
+    return bsMap;
+}
 
-    if( bHeaderChanged == false )
+Bu::Myriad::StreamIdArray Bu::Myriad::buildBlockMap() const
+{
+    Bu::MutexLocker l( mAccess );
+    StreamIdArray bm( iBlockCount );
+    for( int j = 0; j < iBlockCount; j++ )
     {
-        TRACE("mHeader unlocked...");
-        return;
+        bm.append( -1 );
     }
-    if( !sStore.canWrite() )
+    Bu::MutexLocker l2( mhStream );
+    for( StreamHash::const_iterator iStream = hStream.begin();
+         iStream; iStream++ )
     {
-        TRACE("mHeader unlocked...");
-        return;
+        int32_t iId = iStream.getKey();
+        Stream *pStream = iStream.getValue();
+        for( Bu::Array<int32_t>::const_iterator iBlock =
+             pStream->aBlocks.begin(); iBlock; iBlock++ )
+        {
+            bm[*iBlock] = iId;
+        }
     }
+    return bm;
+}
 
-    char cBuf;
-    int iBuf;
+void Bu::Myriad::sync()
+{
+    writeHeader();
+}
 
-    //for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-    //{
-    //  sio << "Myriad: Stream " << Fmt(4) << (*i)->iId << ": " << (*i)->aBlocks << sio.nl;
-    //}
+bool Bu::Myriad::loadMyriad()
+{
+    //Bu::println("Load myriad!");
+    char sMagicCode[4];
+    rBacking.setPos( 0 );
+    MyriadRead( sMagicCode, 4 );
+    if( memcmp( sMagicCode, Myriad_MAGIC_CODE, 4 ) )
+    {
+        throw Bu::MyriadException( Bu::MyriadException::invalidFormat,
+                "Backing stream does not seem to be a Myriad structure.");
+    }
+    uint8_t uVer;
+    uint8_t uBitsPerInt;
+    MyriadRead( &uVer, 1 );
+    if( uVer != 1 )
+    {
+        throw Bu::MyriadException( Bu::MyriadException::invalidFormat,
+                "Only version 1 myriad structures are supported.");
+    }
+    MyriadRead( &uBitsPerInt, 1 );
+    if( uBitsPerInt != 32 )
+    {
+        throw Bu::MyriadException( Bu::MyriadException::invalidFormat,
+                "Only 32 bits per int are supported at this time.");
+    }
+    MyriadRead( &iBlockSize, 4 );
 
-    // Compute the new size of the header.
-    int iHeaderSize = 14 + 8*aStreams.getSize();
-//  sio << "Myriad: updateHeader: aStreams.getSize() = " << aStreams.getSize()
-//      << sio.nl;
-    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    iBlockCount = rBacking.getSize()/iBlockSize;
+    if( (rBacking.getSize()%iBlockSize) != 0 )
     {
-        iHeaderSize += 4*(*i)->aBlocks.getSize();
-//      sio << "Myriad: updateHeader: (*i)->aBlocks.getSize() = "
-//          << (*i)->aBlocks.getSize() << sio.nl;
+        throw Bu::MyriadException( Bu::MyriadException::invalidFormat,
+                "Backing stream is not cleanly divisibly by the block size.");
     }
-    int iNewBlocks = blkDiv( iHeaderSize, iBlockSize );
-    while( iNewBlocks > aStreams[0]->aBlocks.getSize() )
+
+    Bu::Hash<int32_t,bool> hUnusedBlocks;
+    for( int32_t j = 0; j < iBlockCount; j++ )
     {
-        int iBlock = findEmptyBlock();
-//      sio << "Myriad: updateHeader: Appending block " << iBlock
-//          << " to header." << sio.nl;
-        aStreams[0]->aBlocks.append( iBlock );
-//      bsBlockUsed.setBit( iBlock );
-        iUsed++;
-        iHeaderSize += 4;
-        iNewBlocks = blkDiv( iHeaderSize, iBlockSize );
+        hUnusedBlocks.insert( j, true );
     }
-    aStreams[0]->iSize = iHeaderSize;
-//  sio << "Myriad: updateHeader: iHeaderSize=" << iHeaderSize
-//      << ", iNewBlocks=" << iNewBlocks << ", curBlocks="
-//      << aStreams[0]->aBlocks.getSize() << sio.nl;
 
-    MyriadStream sHdr( *this, aStreams[0] );
-    sHdr.write( Myriad_MAGIC_CODE, 4 );
+    int iStreamCount;
+    MyriadRead( &iStreamCount, 4 );
+
+    //
+    // Read stream data -- Bootstrap the zero stream
+    //
+    StreamId iStream;
+    MyriadRead( &iStream, 4 );
+    if( iStream != 0 )
+    {
+        throw Bu::MyriadException( Bu::MyriadException::invalidFormat,
+                "The first stream defined must be the header/zero stream.");
+    }
+    iLastUsedIndex = iStream;
+    int32_t iHeaderStreamBytes;
+    MyriadRead( &iHeaderStreamBytes, 4 );
 
-    // Version (1)
-    cBuf = 1;
-    sHdr.write( &cBuf, 1 );
+    Stream *pHeaderStream = new Stream( *this, iStream, iHeaderStreamBytes );
+    hStream.insert( iStream, pHeaderStream );
+    int iHeaderStreamBlocks = blkDiv(iHeaderStreamBytes, iBlockSize );
+    MyriadStream sHeader( *this, pHeaderStream, Read );
 
-    // Bits per int
-    cBuf = 32;
-    sHdr.write( &cBuf, 1 );
+    // We need to read enough so that we can gurantee that we're within a block
+    // that we have read the index to, plus one index.
+    for( int32_t j = 0; j < iHeaderStreamBlocks; j++ )
+    {
+        int32_t iBlockIndex;
+        MyriadRead( &iBlockIndex, 4 );
+        hUnusedBlocks.erase( iBlockIndex );
+        pHeaderStream->aBlocks.append( iBlockIndex );
+        if( rBacking.tell()+4 <= (j+1)*iBlockSize )
+            break;
+    }
 
-    // The size of each block
-    sHdr.write( &iBlockSize, 4 );
+    // Bootstrap now using the header stream to read the rest of the data.
+    sHeader.setPos( rBacking.tell() );
+    while( pHeaderStream->aBlocks.getSize() < iHeaderStreamBlocks )
+    {
+        int32_t iBlockIndex;
+        ReqRead( sHeader, &iBlockIndex, 4 );
+        hUnusedBlocks.erase( iBlockIndex );
+        pHeaderStream->aBlocks.append( iBlockIndex );
+    }
 
-    iBuf = aStreams.getSize();
-    // The number of streams
-    sHdr.write( &iBuf, 4 );
-    
-    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    // Ok, now we can read the rest of the header in.
+    for( int j = 1; j < iStreamCount; j++ )
     {
-        sHdr.write( &(*i)->iId, 4 );
-        sHdr.write( &(*i)->iSize, 4 );
-        int iUsedBlocks = blkDiv( (*i)->iSize, iBlockSize );
-//      for( BlockArray::iterator j = (*i)->aBlocks.begin(); j; j++ )
-        for( int j = 0; j < iUsedBlocks; j++ )
+        int32_t iStreamBytes;
+        ReqRead( sHeader, &iStream, 4 );
+        ReqRead( sHeader, &iStreamBytes, 4 );
+        Stream *pStream = new Stream( *this, iStream, iStreamBytes );
+        int32_t iBlocks = blkDiv(iStreamBytes, iBlockSize );
+        for( int k = 0; k < iBlocks; k++ )
         {
-            sHdr.write( &(*i)->aBlocks[j], 4 );
+            int32_t iBlockIndex;
+            ReqRead( sHeader, &iBlockIndex, 4 );
+            hUnusedBlocks.erase( iBlockIndex );
+            pStream->aBlocks.append( iBlockIndex );
         }
+        hStream.insert( iStream, pStream );
+        if( iLastUsedIndex < iStream )
+            iLastUsedIndex = iStream;
     }
+
+    lFreeBlocks = hUnusedBlocks.getKeys();
+    //Bu::println("Free blocks: %1").arg( lFreeBlocks.getSize() );
     
-    bHeaderChanged = false;
-    TRACE("mHeader unlocked...");
+    bIsNewStream = false;
+
+    return true;
 }
 
-int Bu::Myriad::createStream( int iPreAllocate )
+void Bu::Myriad::createMyriad( int32_t iBlockSize, int32_t iPreallocateBlocks )
 {
-    MutexLocker mLock( mHeader );
-    TRACE("mHeader locked.");
+    if( iBlockSize < 8 )
+    {
+        throw Bu::MyriadException( Bu::MyriadException::invalidParameter,
+                "iBlockSize cannot be below 8");
+    }
+    if( rBacking.getSize() )
+    {
+        throw Bu::MyriadException( Bu::MyriadException::invalidFormat,
+                "Backing stream contains data, but not a myriad structure.");
+    }
+
+    // Start with the bytes for the file header and initial stream header
+    int iHeaderStreamBytes
+        = 14 // Base header
+        + 8; // Stream header
+             
+    // Pick the block count that matches our current estimate for the header
+    // plus one block index.
+    int iHeaderStreamBlocks = blkDiv(iHeaderStreamBytes+4, iBlockSize );
 
-    Stream *pStr = new Stream();
-    pStr->iId = aStreams.last()->iId+1;
-    //sio << "Myriad: New stream id=" << pStr->iId << ", iPreAllocate="
-    //  << iPreAllocate << sio.nl;
-    pStr->iSize = 0;
-    aStreams.append( pStr );
+    //Bu::println("Initial estimate: %1 bytes / %2 cur blocks, %3 computed blocks (%4 target bytes).").arg( iHeaderStreamBytes+(iHeaderStreamBlocks*4) ).arg( iHeaderStreamBlocks ).arg( blkDiv((iHeaderStreamBytes+(iHeaderStreamBlocks*4)), iBlockSize) ).arg( iHeaderStreamBlocks*iBlockSize );
+    while( iHeaderStreamBytes+(iHeaderStreamBlocks*4)
+           > iHeaderStreamBlocks*iBlockSize )
+    {
+        iHeaderStreamBlocks = blkDiv((iHeaderStreamBytes+((iHeaderStreamBlocks+1)*4)), iBlockSize);
+        if( iHeaderStreamBlocks > 100 )
+            break;
+        //Bu::println("      Adjustment: %1 bytes / %2 cur blocks, %3 computed blocks (%4 target bytes).").arg( iHeaderStreamBytes+(iHeaderStreamBlocks*4) ).arg( iHeaderStreamBlocks ).arg( blkDiv((iHeaderStreamBytes+(iHeaderStreamBlocks*4)), iBlockSize) ).arg( iHeaderStreamBlocks*iBlockSize );
+    }
 
-    for( int j = 0; j < iPreAllocate; j++ )
+    if( iPreallocateBlocks < iHeaderStreamBlocks )
     {
-        int iFreeBlock = findEmptyBlock();
-//      sio << "Myriad: Adding block " << iFreeBlock << sio.nl;
-        pStr->aBlocks.append( iFreeBlock );
-//      bsBlockUsed.setBit( iFreeBlock );
-        iUsed++;
+        iPreallocateBlocks = iHeaderStreamBlocks;
     }
+    rBacking.setSize( iBlockSize*iPreallocateBlocks );
 
-    bHeaderChanged = true;
+    //
+    // Write Myriad header
+    //
+    uint8_t uVer = 1;
+    uint8_t uBpi = 32;
+    int32_t iStreamCount = 1;
+    rBacking.setPos( 0 );
+    rBacking.write( Myriad_MAGIC_CODE, 4 );
+    rBacking.write( &uVer, 1 );
+    rBacking.write( &uBpi, 1 );
+    rBacking.write( &iBlockSize, 4 );
+    rBacking.write( &iStreamCount, 4 );
 
-    TRACE("mHeader unlocked...");
-    return pStr->iId;
-}
+    Stream *pHeadStream = new Stream( *this, 0, Bu::Myriad::ReadWrite );
+    //
+    // Write stream header
+    //
+    uint32_t uStreamId = 0;
+    uint32_t uStreamSize = iHeaderStreamBytes+iHeaderStreamBlocks*4;
+    rBacking.write( &uStreamId, 4 );
+    rBacking.write( &uStreamSize, 4 );
+    for( int iBlockIndex = 0; iBlockIndex < iHeaderStreamBlocks; iBlockIndex++ )
+    {
+        rBacking.write( &iBlockIndex, 4 );
+        pHeadStream->aBlocks.append( iBlockIndex );
+    }
+    rBacking.flush();
 
-int Bu::Myriad::createStreamWithId( int iId, int iPreAllocate )
-{
-    MutexLocker mLock( mHeader );
-    TRACE("mHeader locked.");
+    hStream.insert( pHeadStream->iStream, pHeadStream );
 
-    try
+    for( int32_t j = iHeaderStreamBlocks; j < iPreallocateBlocks; j++ )
     {
-        findStream( iId );
-        TRACE("mHeader unlocked...");
-        throw MyriadException( MyriadException::streamExists,
-            "There is already a stream with the given id.");
+        lFreeBlocks.append( j );
     }
-    catch( MyriadException &e )
+    iLastUsedIndex = 0;
+    iBlockCount = iPreallocateBlocks;
+}
+
+void Bu::Myriad::writeHeader()
+{
+    Bu::MutexLocker l( mAccess );
+    if( !rBacking.isWritable() )
+        return;
+    //Bu::println("Writing stream breakdown:");
+    Bu::MemBuf mbHeader;
     {
-        Stream *pStr = new Stream();
-        pStr->iId = iId;
-        //sio << "Myriad: New stream id=" << pStr->iId << ", iPreAllocate="
-        //  << iPreAllocate << sio.nl;
-        pStr->iSize = 0;
-        if( aStreams.last()->iId < iId )
-        {
-            aStreams.append( pStr );
-        }
-        else
+        Bu::MutexLocker l2( mhStream );
+
+        int32_t iHdrStreamSize = __calcHeaderSize();
+        // Maybe just do stream surgery here.
         {
-            for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+            Stream *psHeader = hStream.get( 0 );
+            Bu::MutexLocker l2( psHeader->mAccess );
+            int iNewBlocks = Bu::blkDiv( iHdrStreamSize, iBlockSize );
+            if( iHdrStreamSize < psHeader->iSize )
             {
-                if( (*i)->iId > iId )
+                while( psHeader->aBlocks.getSize() > iNewBlocks )
                 {
-                    aStreams.insert( i, pStr );
-                    break;
+                    __releaseBlock( psHeader->aBlocks.last(), false );
+                    psHeader->aBlocks.eraseLast();
                 }
             }
+            else if( iHdrStreamSize > psHeader->iSize )
+            {
+                while( psHeader->aBlocks.getSize() < iNewBlocks )
+                {
+                    psHeader->aBlocks.append( __allocateBlock() );
+                }
+            }
+            psHeader->iSize = iHdrStreamSize;
         }
 
-        for( int j = 0; j < iPreAllocate; j++ )
+        //Bu::println("Computed header size: %1 bytes. Ver=%2, Bpi=%3, BlockSize=%4").arg( iHdrStreamSize ).arg( 1 ).arg( 32 ).arg( iBlockSize );
+        
+        uint8_t uVer = 1;
+        uint8_t uBpi = 32;
+        int32_t iStreamCount = hStream.getSize();
+
+        mbHeader.write( Myriad_MAGIC_CODE, 4 );
+        mbHeader.write( &uVer, 1 );
+        mbHeader.write( &uBpi, 1 );
+        mbHeader.write( &iBlockSize, 4 );
+        mbHeader.write( &iStreamCount, 4 );
+        StreamHash::KeyList lStreamId = hStream.getKeys();
+        lStreamId.sort();
+        if( lStreamId.first() != 0 )
+        {
+            throw Bu::MyriadException( Bu::MyriadException::invalidFormat,
+                    "There doesn't appear to be a zero (header) stream.");
+        }
+        for( StreamHash::KeyList::iterator i = lStreamId.begin(); i; i++ )
         {
-            int iFreeBlock = findEmptyBlock();
-    //      sio << "Myriad: Adding block " << iFreeBlock << sio.nl;
-            pStr->aBlocks.append( iFreeBlock );
-//          bsBlockUsed.setBit( iFreeBlock );
-            iUsed++;
+            uint32_t uStreamId = *i;
+            Stream *pStream = hStream.get( uStreamId );
+            uint32_t uStreamSize = pStream->getSize();
+            mbHeader.write( &uStreamId, 4 );
+            mbHeader.write( &uStreamSize, 4 );
+            int32_t iBlocks = Bu::blkDiv( uStreamSize, (uint32_t)iBlockSize );
+            Bu::Array<int32_t> aBlocks = pStream->getBlockList();
+            
+            //Bu::println("  Stream %1 is %2 bytes %3 blocks (%4 blocks computed)").arg( *i ).arg( uStreamSize ).arg( aBlocks.getSize() ).arg( Bu::blkDiv( (int)uStreamSize, (int)iBlockSize ) );
+
+//            for( Bu::Array<int32_t>::iterator i = aBlocks.begin(); i; i++ )
+            for( int j = 0; j < iBlocks; j++ )
+            {
+                mbHeader.write( &aBlocks[j], 4 );
+            }
         }
 
-        bHeaderChanged = true;
 
-        TRACE("mHeader unlocked...");
-        return pStr->iId;
     }
-    TRACE("mHeader unlocked...");
-}
 
-int Bu::Myriad::findEmptyBlock()
-{
-    bHeaderChanged = true;
-
-    if( lFreeBlocks.isEmpty() )
-    {
-        sStore.setSize( (iBlocks+1)*(Bu::size)iBlockSize );
-        return iBlocks++;
-    }
-    else
-    {
-        return lFreeBlocks.dequeue();
-    }
+    Bu::MyriadStream sHeader( *this, hStream.get( 0 ), Bu::Myriad::Write );
+    sHeader.write( mbHeader.getString() );
+    bStructureChanged = false;
 }
 
-void Bu::Myriad::deleteStream( int iId )
+int32_t Bu::Myriad::__calcHeaderSize()
 {
-    MutexLocker mLock( mHeader );
-    TRACE("mHeader locked.");
+    int32_t iHdrSize = 4+1+1+4+4;
 
-    if( iId < 0 )
+    StreamHash::KeyList lStreamId = hStream.getKeys();
+    lStreamId.sort();
+    if( lStreamId.first() != 0 )
     {
-        TRACE("mHeader unlocked...");
-        throw MyriadException( MyriadException::invalidStreamId,
-                "Invalid stream id.");
+        throw Bu::MyriadException( Bu::MyriadException::invalidFormat,
+                "There doesn't appear to be a zero (header) stream.");
     }
-    if( iId == 0 )
+    for( StreamHash::KeyList::iterator i = lStreamId.begin(); i; i++ )
     {
-        TRACE("mHeader unlocked...");
-        throw MyriadException( MyriadException::protectedStream,
-                "You cannot delete stream zero, it is protected.");
-    }
-    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-    {
-        if( (*i)->iId == iId )
+        iHdrSize += 4+4;
+        int32_t iStreamSize = hStream.get( *i )->getSize();
+        if( (*i) != 0 )
         {
-            Stream *pStream = *i;
-            for( BlockArray::iterator j = pStream->aBlocks.begin(); j; j++ )
-            {
-                lFreeBlocks.append( *j );
-//              bsBlockUsed.setBit( *j, false );
-                iUsed--;
-            }
-            aStreams.erase( i );
-            bHeaderChanged = true;
-            delete pStream;
-            TRACE("mHeader unlocked...");
-            return;
+            iHdrSize += Bu::blkDiv( iStreamSize, iBlockSize )*4;
         }
     }
-    TRACE("mHeader unlocked...");
-}
 
-Bu::Array<int> Bu::Myriad::getStreamIds()
-{
-    MutexLocker mLock( mHeader );
-    TRACE("mHeader locked.");
+    //Bu::println("HeaderCalc:");
+    //Bu::println("  Base (no header stream): %1").arg( iHdrSize );
+    int32_t iNewSize = iHdrSize;
+    int32_t iOldSize;
 
-    Bu::Array<int> aRet( aStreams.getSize() );
-    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-    {
-        aRet.append( (*i)->iId );
-    }
+    do {
+        iOldSize = iNewSize;
+        iNewSize = iHdrSize + Bu::blkDiv(iNewSize, iBlockSize)*4;
+        //Bu::println("  Recomp: %1").arg( iNewSize );
+    } while( iOldSize != iNewSize );
 
-    TRACE("mHeader unlocked...");
-    return aRet;
+    return iNewSize;
 }
 
-int Bu::Myriad::getStreamSize( int iId )
+int32_t Bu::Myriad::allocateBlock()
 {
-    MutexLocker mLock( mHeader );
-    TRACE("mHeader locked.");
-
-    TRACE("mHeader unlocked...");
-    return findStream( iId )->iSize;
+    Bu::MutexLocker l( mAccess );
+    return __allocateBlock();
 }
 
-bool Bu::Myriad::hasStream( int iId )
+int32_t Bu::Myriad::__allocateBlock()
 {
-    MutexLocker mLock( mHeader );
-    TRACE("mHeader locked.");
-
-    try
+    bStructureChanged = true;
+    if( lFreeBlocks.isEmpty() )
     {
-        findStream( iId );
-        TRACE("mHeader unlocked...");
-        return true;
-    }catch(...)
+        // Increase the size of the backing stream
+        int32_t iIndex = iBlockCount++;
+        rBacking.setSize( iBlockCount*iBlockSize );
+        return iIndex;
+    }
+    else
     {
-        TRACE("mHeader unlocked...");
-        return false;
+        // Provide an existing free block.
+        return lFreeBlocks.peekPop();
     }
 }
 
-Bu::MyriadStream Bu::Myriad::openStream( int iId )
+void Bu::Myriad::releaseBlock( int32_t iBlockId, bool bBlank )
 {
-    MutexLocker mLock( mHeader );
-    TRACE("mHeader locked.");
-
-    TRACE("mHeader unlocked...");
-    //sio << "Myriad:  Request to open stream: " << iId << sio.nl;
-    return MyriadStream( *this, findStream( iId ) );
+    Bu::MutexLocker l( mAccess );
+    __releaseBlock( iBlockId, bBlank );
 }
 
-int Bu::Myriad::getNumStreams()
+void Bu::Myriad::__releaseBlock( int32_t iBlockId, bool bBlank )
 {
-    MutexLocker mLock( mHeader );
-    TRACE("mHeader locked.");
-
-    TRACE("mHeader unlocked...");
-    return aStreams.getSize();
+    bStructureChanged = true;
+    lFreeBlocks.append( iBlockId );
+    if( bBlank )
+    {
+        blankBlock( iBlockId );
+    }
 }
 
-int Bu::Myriad::getBlockSize()
+void Bu::Myriad::blankBlock( int32_t iBlockId )
 {
-    return iBlockSize;
+    Bu::MutexLocker l( mBacking );
+    rBacking.setPos( iBlockId*iBlockSize );
+    int32_t iChunk = std::min( iBlockSize, 4096 );
+    uint8_t *pChunk = new uint8_t[iChunk];
+    memset( pChunk, 0, iChunk );
+    int iLeft = iBlockSize;
+    while( iLeft > 0 )
+    {
+        int32_t iWrite = rBacking.write( pChunk, std::min( iChunk, iLeft ) );
+        iLeft -= iWrite;
+    }
+    delete[] pChunk;
 }
 
-int Bu::Myriad::getNumBlocks()
+void Bu::Myriad::openStream( StreamId id )
 {
-    return iBlocks;
+    Bu::MutexLocker l( mhStream );
+    hStream.get( id )->open();
 }
 
-int Bu::Myriad::getNumUsedBlocks()
+void Bu::Myriad::closeStream( StreamId id )
 {
-    return iUsed;
+    Bu::MutexLocker l( mhStream );
+    hStream.get( id )->close();
 }
 
-Bu::size Bu::Myriad::getTotalUsedBytes()
+int32_t Bu::Myriad::blockRead( int32_t iBlock, int32_t iStart,
+        void *pTarget, int32_t iSize )
 {
-    MutexLocker mLock( mHeader );
-    TRACE("mHeader locked.");
+    int32_t iUpperSize = iBlockSize - (iStart%iBlockSize);
+/*    Bu::println("Max read within block: %1 vs %2  (start=%3, blocksize=%4)")
+        .arg( iUpperSize ).arg( iSize )
+        .arg( iStart ).arg( iBlockSize );
+*/
+    int32_t iAmnt = std::min( iSize, iUpperSize );
+    Bu::MutexLocker l( mBacking );
+    rBacking.setPos( iBlockSize*iBlock + iStart );
 
-    Bu::size iTotalSize = 0;
-    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-    {
-        iTotalSize += (*i)->iSize;
-    }
-    TRACE("mHeader unlocked...");
-    return iTotalSize;
+    return rBacking.read( pTarget, iAmnt );
 }
 
-Bu::size Bu::Myriad::getTotalUnusedBytes()
+int32_t Bu::Myriad::blockWrite( int32_t iBlock, int32_t iStart,
+        const void *pTarget, int32_t iSize )
 {
-    MutexLocker mLock( mHeader );
-    TRACE("mHeader locked.");
+    int32_t iUpperSize = iBlockSize - (iStart%iBlockSize);
+/*    Bu::println("Max write within block: %1 vs %2  (start=%3, blocksize=%4)")
+        .arg( iUpperSize ).arg( iSize )
+        .arg( iStart ).arg( iBlockSize );
+*/
+    int32_t iAmnt = std::min( iSize, iUpperSize );
+    Bu::MutexLocker l( mBacking );
+    rBacking.setPos( iBlock*iBlockSize + iStart );
 
-    Bu::size iTotalSize = (iBlocks-iUsed)*iBlockSize;
-    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-    {
-        iTotalSize += iBlockSize - ((Bu::size)(*i)->iSize%iBlockSize);
-    }
-    TRACE("mHeader unlocked...");
-    return iTotalSize;
+    return rBacking.write( pTarget, iAmnt );
 }
 
-Bu::size Bu::Myriad::getTotalUnusedBytes( int iFakeBlockSize )
-{
-    MutexLocker mLock( mHeader );
-    TRACE("mHeader locked.");
+/////////
+// Bu::Myriad::Stream
+//
 
-    Bu::size iTotalSize = (iBlocks-iUsed)*iFakeBlockSize;
-    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-    {
-        iTotalSize += iFakeBlockSize - ((*i)->iSize%iFakeBlockSize);
-    }
-    TRACE("mHeader unlocked...");
-    return iTotalSize;
+Bu::Myriad::Stream::Stream( Bu::Myriad &rParent, Bu::Myriad::StreamId iStream,
+        int32_t iSize ) :
+    rParent( rParent ),
+    iStream( iStream ),
+    iSize( iSize ),
+    iOpenCount( 0 )
+{
 }
 
-Bu::Myriad::Stream *Bu::Myriad::findStream( int iId )
+Bu::Myriad::Stream::~Stream()
 {
-    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-    {
-        if( (*i)->iId == iId )
-            return *i;
-    }
-
-    throw MyriadException( MyriadException::noSuchStream,
-        "The requested stream doesn't exist and cannot be opened." );
-
-    return NULL;
 }
 
-Bu::Myriad::Block *Bu::Myriad::getBlock( int iBlock )
+int32_t Bu::Myriad::Stream::getSize() const
 {
-//  sio << "Myriad:  Reading block " << iBlock << ", bytes "
-//      << iBlockSize*iBlock << "-" << iBlockSize*(iBlock+1) << sio.nl;
-    Block *pBlock = new Block;
-    pBlock->pData = new char[iBlockSize];
-    sStore.setPos( iBlockSize * (Bu::size)iBlock );
-    sStore.read( pBlock->pData, iBlockSize );
-    pBlock->bChanged = false;
-    pBlock->iBlockIndex = iBlock;
-
-    mActiveBlocks.lock();
-    TRACE("mHeader locked.");
-    hActiveBlocks.insert( iBlock, pBlock );
-    TRACE("mHeader unlocked...");
-    mActiveBlocks.unlock();
+    Bu::MutexLocker l( mAccess );
+    return iSize;
+}
 
-    return pBlock;
+int32_t Bu::Myriad::Stream::getBlockSize() const
+{
+    Bu::MutexLocker l( mAccess );
+    return rParent.iBlockSize;
 }
 
-void Bu::Myriad::releaseBlock( Bu::Myriad::Block *pBlock )
+Bu::Myriad::StreamId Bu::Myriad::Stream::getStreamId() const
 {
-    if( pBlock == NULL )
-        return;
-//  sio << "Myriad:  Releasing block " << pBlock->iBlockIndex << sio.nl;
-    syncBlock( pBlock );
-    mActiveBlocks.lock();
-    TRACE("mHeader locked.");
-    hActiveBlocks.erase( pBlock->iBlockIndex );
-    TRACE("mHeader unlocked...");
-    mActiveBlocks.unlock();
+    return iStream;
+}
 
-    delete[] pBlock->pData;
-    delete pBlock;
+int32_t Bu::Myriad::Stream::getOpenCount() const
+{
+    Bu::MutexLocker l( mAccess );
+    return iOpenCount;
 }
 
-void Bu::Myriad::syncBlock( Block *pBlock )
+void Bu::Myriad::Stream::setSize( int32_t iNewSize )
 {
-    if( pBlock->bChanged )
+    // Two possible modes, shrink or grow.
+    Bu::MutexLocker l( mAccess );
+    int iNewBlocks = Bu::blkDiv( iNewSize, rParent.iBlockSize );
+    if( iNewSize < iSize )
     {
-//      sio << "Myriad:    - Block changed, writing back to stream." << sio.nl;
-        sStore.setPos( iBlockSize * (Bu::size)pBlock->iBlockIndex );
-        sStore.write( pBlock->pData, iBlockSize );
-        pBlock->bChanged = false;
+        // Shrink it
+        while( aBlocks.getSize() > iNewBlocks )
+        {
+            rParent.releaseBlock( aBlocks.last(), false );
+            aBlocks.eraseLast();
+        }
+        iSize = iNewSize;
+    }
+    else if( iNewSize > iSize )
+    {
+        // Grow it
+        while( aBlocks.getSize() < iNewBlocks )
+        {
+            aBlocks.append( rParent.allocateBlock() );
+        }
+        iSize = iNewSize;
     }
 }
 
-int Bu::Myriad::streamAddBlock( Stream *pStream )
+int32_t Bu::Myriad::Stream::read( int32_t iStart, void *pTarget,
+        int32_t iSize )
 {
-    MutexLocker mLock( mHeader );
-    TRACE("mHeader locked.");
+    int32_t iRead = 0;
+    Bu::MutexLocker l( mAccess );
 
-    int iBlock = findEmptyBlock();
-    pStream->aBlocks.append( iBlock );
-//  bsBlockUsed.setBit( iBlock );
-//  bHeaderChanged = true;
-    iUsed++;
-    TRACE("mHeader unlocked...");
-    return iBlock;
-}
-
-void Bu::Myriad::setStreamSize( Stream *pStream, long iSize )
-{
-    MutexLocker mLock( mHeader );
-    TRACE("mHeader locked.");
+    if( iStart >= this->iSize )
+        return 0;
 
-    if( pStream->iSize == iSize )
+    if( iStart+iSize >= this->iSize )
     {
-    TRACE("mHeader unlocked...");
-        return;
+        iSize = this->iSize-iStart;
     }
-    else if( pStream->iSize > iSize )
+
+    while( iSize > 0 )
     {
-        // Shrink
-        TRACE(Bu::String("Shrink stream %1 from %2 to %3").arg(pStream->iId).arg(pStream->iSize).arg(iSize).end() );
-        for( int iNewSize = pStream->aBlocks.getSize()*iBlockSize;
-             iNewSize-iBlockSize > iSize; iNewSize -= iBlockSize )
-        {
-//          if( bsBlockUsed.getBit( pStream->aBlocks.last() ) )
-                iUsed--;
-//          else
-//              sio << "Unused block used in stream? " << pStream->aBlocks.last() << sio.nl;
-            lFreeBlocks.enqueue( pStream->aBlocks.last() );
-//          bsBlockUsed.setBit( pStream->aBlocks.last(), false );
-            pStream->aBlocks.eraseLast();
-        }
-        pStream->iSize = iSize;
-        bHeaderChanged = true;
+        int32_t iBlock = aBlocks[iStart/rParent.iBlockSize];
+        int32_t iChunkRead = rParent.blockRead(
+                iBlock, iStart%rParent.iBlockSize, pTarget, iSize
+                );
+        if( iChunkRead == 0 )
+            break;
+        iRead += iChunkRead;
+        iStart += iChunkRead;
+        reinterpret_cast<ptrdiff_t &>(pTarget) += iChunkRead;
+        iSize -= iChunkRead;
     }
-    else
+
+    return iRead;
+}
+
+int32_t Bu::Myriad::Stream::write( int32_t iStart, const void *pTarget,
+        int32_t iSize )
+{
+    int32_t iWrite = 0;
+    Bu::MutexLocker l( mAccess );
+    while( iSize > 0 )
     {
-        // Grow
-        TRACE(Bu::String("Grow stream %1 from %2 to %3").arg(pStream->iId).arg(pStream->iSize).arg(iSize).end() );
-        for( int iNewSize = pStream->aBlocks.getSize()*iBlockSize;
-             iNewSize < iSize; iNewSize += iBlockSize )
+        int32_t iBlockIdx = iStart/rParent.iBlockSize;
+        while( iBlockIdx >= aBlocks.getSize() )
         {
-            //streamAddBlock( pStream );
-            int iBlock = findEmptyBlock();
-            pStream->aBlocks.append( iBlock );
-//          bsBlockUsed.setBit( iBlock );
-//          bHeaderChanged = true;
-            iUsed++;
+            aBlocks.append( rParent.allocateBlock() );
         }
-        pStream->iSize = iSize;
-        bHeaderChanged = true;
+        int32_t iBlock = aBlocks[iBlockIdx];
+        int32_t iChunkWrite = rParent.blockWrite(
+                iBlock, iStart%rParent.iBlockSize, pTarget, iSize
+                );
+        if( iChunkWrite == 0 )
+            break;
+        iWrite += iChunkWrite;
+        iStart += iChunkWrite;
+        reinterpret_cast<ptrdiff_t &>(pTarget) += iChunkWrite;
+        iSize -= iChunkWrite;
     }
-    TRACE("mHeader unlocked...");
+    if( this->iSize < iStart )
+        this->iSize = iStart;
+
+    return iWrite;
 }
 
-void Bu::Myriad::headerChanged()
+Bu::String Bu::Myriad::Stream::getLocation() const
 {
-    bHeaderChanged = true;
+    Bu::MutexLocker l( mAccess );
+    return Bu::String("%1:stream %2")\
+        .arg( rParent.getLocation() ).arg( iStream );
 }
 
-bool Bu::Myriad::isMyriad( Bu::Stream &sStore )
+Bu::Array<int32_t> Bu::Myriad::Stream::getBlockList() const
 {
-    uint8_t uTmp;
-
-    return isMyriad( sStore, uTmp );
+    Bu::MutexLocker l( mAccess );
+    return aBlocks.clone();
 }
 
-bool Bu::Myriad::isMyriad( Bu::Stream &sStore, uint8_t &uTmp )
+void Bu::Myriad::Stream::open()
 {
-    sStore.setPos( 0 );
-
-    unsigned char buf[4];
-    if( sStore.read( buf, 4 ) < 4 )
-        throw MyriadException( MyriadException::emptyStream,
-                "Input stream appears to be empty.");
-    sStore.read( &uTmp, 1 );
-    sStore.setPos( 0 );
-    if( memcmp( buf, Myriad_MAGIC_CODE, 4 ) )
-    {
-        return false;
-    }
-    return true;
+    Bu::MutexLocker l( mAccess );
+    iOpenCount++;
 }
 
-const Bu::BitString Bu::Myriad::getBlocksUsed() const
+bool Bu::Myriad::Stream::close()
 {
-    Bu::BitString bs( iBlocks, false );
-    for( int j = 0; j < iBlocks; j++ )
-        bs.setBit( j );
-    for( IndexList::const_iterator i = lFreeBlocks.begin(); i; i++ )
-        bs.setBit( *i, false );
-    return bs;
+    Bu::MutexLocker l( mAccess );
+    return (bool)(--iOpenCount);
 }