diff --git a/camera/Camera.cpp b/camera/Camera.cpp
index 7efc6d7..743fbb2 100644
--- a/camera/Camera.cpp
+++ b/camera/Camera.cpp
@@ -359,6 +359,9 @@
     }
     if (listener != NULL) {
         listener->postDataTimestamp(timestamp, msgType, dataPtr);
+    } else {
+        LOGW("No listener was set. Drop a recording frame.");
+        releaseRecordingFrame(dataPtr);
     }
 }
 
diff --git a/include/media/mediametadataretriever.h b/include/media/mediametadataretriever.h
index dbbcc49..ddc07f6 100644
--- a/include/media/mediametadataretriever.h
+++ b/include/media/mediametadataretriever.h
@@ -56,6 +56,7 @@
     METADATA_KEY_MIMETYPE        = 22,
     METADATA_KEY_DISC_NUMBER     = 23,
     METADATA_KEY_ALBUMARTIST     = 24,
+    METADATA_KEY_COMPILATION     = 25,
     // Add more here...
 };
 
diff --git a/include/media/stagefright/AudioSource.h b/include/media/stagefright/AudioSource.h
index a5cec78..d484d60 100644
--- a/include/media/stagefright/AudioSource.h
+++ b/include/media/stagefright/AudioSource.h
@@ -54,11 +54,11 @@
 
         // After the initial mute, we raise the volume linearly
         // over kAutoRampDurationUs.
-        kAutoRampDurationUs = 300000,
+        kAutoRampDurationUs = 700000,
 
         // This is the initial mute duration to suppress
         // the video recording signal tone
-        kAutoRampStartUs = 700000,
+        kAutoRampStartUs = 1000000,
       };
 
     AudioRecord *mRecord;
diff --git a/include/media/stagefright/MetaData.h b/include/media/stagefright/MetaData.h
index a69d9af..ea2fa52 100644
--- a/include/media/stagefright/MetaData.h
+++ b/include/media/stagefright/MetaData.h
@@ -75,6 +75,7 @@
     kKeyDiscNumber        = 'dnum',  // cstring
     kKeyDate              = 'date',  // cstring
     kKeyWriter            = 'writ',  // cstring
+    kKeyCompilation       = 'cpil',  // cstring
     kKeyTimeScale         = 'tmsl',  // int32_t
 
     // video profile and level
diff --git a/include/media/stagefright/OMXCodec.h b/include/media/stagefright/OMXCodec.h
index fed6761..8274dfb 100644
--- a/include/media/stagefright/OMXCodec.h
+++ b/include/media/stagefright/OMXCodec.h
@@ -60,8 +60,6 @@
 
     virtual status_t pause();
 
-    void on_message(const omx_message &msg);
-
     // from MediaBufferObserver
     virtual void signalBufferReturned(MediaBuffer *buffer);
 
@@ -69,6 +67,13 @@
     virtual ~OMXCodec();
 
 private:
+
+    // Make sure mLock is accessible to OMXCodecObserver
+    friend class OMXCodecObserver;
+
+    // Call this with mLock hold
+    void on_message(const omx_message &msg);
+
     enum State {
         DEAD,
         LOADED,
diff --git a/media/libmedia/AudioSystem.cpp b/media/libmedia/AudioSystem.cpp
index 7e3b743..9c2a8ba 100644
--- a/media/libmedia/AudioSystem.cpp
+++ b/media/libmedia/AudioSystem.cpp
@@ -763,7 +763,8 @@
     if ((popCount(device) == 1 ) &&
         (device & (AudioSystem::DEVICE_OUT_BLUETOOTH_SCO |
                    AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET |
-                   AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT))) {
+                   AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT |
+                   AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET))) {
         return true;
     } else {
         return false;
diff --git a/media/libmedia/Visualizer.cpp b/media/libmedia/Visualizer.cpp
index 68f2e9b..a660429 100644
--- a/media/libmedia/Visualizer.cpp
+++ b/media/libmedia/Visualizer.cpp
@@ -209,8 +209,8 @@
     int32_t nonzero = 0;
 
     for (uint32_t i = 0; i < mCaptureSize; i += 2) {
-        workspace[i >> 1] = (waveform[i] ^ 0x80) << 23;
-        workspace[i >> 1] |= (waveform[i + 1] ^ 0x80) << 7;
+        workspace[i >> 1] =
+                ((waveform[i] ^ 0x80) << 24) | ((waveform[i + 1] ^ 0x80) << 8);
         nonzero |= workspace[i >> 1];
     }
 
@@ -219,8 +219,8 @@
     }
 
     for (uint32_t i = 0; i < mCaptureSize; i += 2) {
-        fft[i] = workspace[i >> 1] >> 23;
-        fft[i + 1] = workspace[i >> 1] >> 7;
+        fft[i] = workspace[i >> 1] >> 24;
+        fft[i + 1] = workspace[i >> 1] >> 8;
     }
 
     return NO_ERROR;
diff --git a/media/libmediaplayerservice/StagefrightRecorder.cpp b/media/libmediaplayerservice/StagefrightRecorder.cpp
index 553648d..3261fe6 100644
--- a/media/libmediaplayerservice/StagefrightRecorder.cpp
+++ b/media/libmediaplayerservice/StagefrightRecorder.cpp
@@ -361,6 +361,9 @@
         return BAD_VALUE;
     }
 
+    if (timeUs <= 15 * 1000000LL) {
+        LOGW("Target duration (%lld us) too short to be respected", timeUs);
+    }
     mMaxFileDurationUs = timeUs;
     return OK;
 }
@@ -371,6 +374,11 @@
         LOGE("Max file size is too small: %lld bytes", bytes);
         return BAD_VALUE;
     }
+
+    if (bytes <= 100 * 1024) {
+        LOGW("Target file size (%lld bytes) is too small to be respected", bytes);
+    }
+
     mMaxFileSizeBytes = bytes;
     return OK;
 }
diff --git a/media/libstagefright/AwesomePlayer.cpp b/media/libstagefright/AwesomePlayer.cpp
index 0bc4062..50c5f3e 100644
--- a/media/libstagefright/AwesomePlayer.cpp
+++ b/media/libstagefright/AwesomePlayer.cpp
@@ -82,6 +82,10 @@
         : mTarget(target) {
     }
 
+    virtual status_t initCheck() const {
+        return OK;
+    }
+
     virtual void render(MediaBuffer *buffer) {
         void *id;
         if (buffer->meta_data()->findPointer(kKeyBufferID, &id)) {
@@ -105,14 +109,19 @@
             size_t displayWidth, size_t displayHeight,
             size_t decodedWidth, size_t decodedHeight,
             int32_t rotationDegrees)
-        : mTarget(NULL),
+        : mInitCheck(NO_INIT),
+          mTarget(NULL),
           mLibHandle(NULL) {
-            init(previewOnly, componentName,
+            mInitCheck = init(previewOnly, componentName,
                  colorFormat, surface, displayWidth,
                  displayHeight, decodedWidth, decodedHeight,
                  rotationDegrees);
     }
 
+    virtual status_t initCheck() const {
+        return mInitCheck;
+    }
+
     virtual void render(MediaBuffer *buffer) {
         render((const uint8_t *)buffer->data() + buffer->range_offset(),
                buffer->range_length());
@@ -134,10 +143,11 @@
     }
 
 private:
+    status_t mInitCheck;
     VideoRenderer *mTarget;
     void *mLibHandle;
 
-    void init(
+    status_t init(
             bool previewOnly,
             const char *componentName,
             OMX_COLOR_FORMATTYPE colorFormat,
@@ -150,7 +160,7 @@
     AwesomeLocalRenderer &operator=(const AwesomeLocalRenderer &);;
 };
 
-void AwesomeLocalRenderer::init(
+status_t AwesomeLocalRenderer::init(
         bool previewOnly,
         const char *componentName,
         OMX_COLOR_FORMATTYPE colorFormat,
@@ -215,11 +225,15 @@
         }
     }
 
-    if (mTarget == NULL) {
-        mTarget = new SoftwareRenderer(
-                colorFormat, surface, displayWidth, displayHeight,
-                decodedWidth, decodedHeight, rotationDegrees);
+    if (mTarget != NULL) {
+        return OK;
     }
+
+    mTarget = new SoftwareRenderer(
+            colorFormat, surface, displayWidth, displayHeight,
+            decodedWidth, decodedHeight, rotationDegrees);
+
+    return ((SoftwareRenderer *)mTarget)->initCheck();
 }
 
 AwesomePlayer::AwesomePlayer()
@@ -830,53 +844,64 @@
     return OK;
 }
 
-void AwesomePlayer::initRenderer_l() {
-    if (mISurface != NULL) {
-        sp<MetaData> meta = mVideoSource->getFormat();
-
-        int32_t format;
-        const char *component;
-        int32_t decodedWidth, decodedHeight;
-        CHECK(meta->findInt32(kKeyColorFormat, &format));
-        CHECK(meta->findCString(kKeyDecoderComponent, &component));
-        CHECK(meta->findInt32(kKeyWidth, &decodedWidth));
-        CHECK(meta->findInt32(kKeyHeight, &decodedHeight));
-
-        int32_t rotationDegrees;
-        if (!mVideoTrack->getFormat()->findInt32(
-                    kKeyRotation, &rotationDegrees)) {
-            rotationDegrees = 0;
-        }
-
-        mVideoRenderer.clear();
-
-        // Must ensure that mVideoRenderer's destructor is actually executed
-        // before creating a new one.
-        IPCThreadState::self()->flushCommands();
-
-        if (!strncmp("OMX.", component, 4)) {
-            // Our OMX codecs allocate buffers on the media_server side
-            // therefore they require a remote IOMXRenderer that knows how
-            // to display them.
-            mVideoRenderer = new AwesomeRemoteRenderer(
-                mClient.interface()->createRenderer(
-                        mISurface, component,
-                        (OMX_COLOR_FORMATTYPE)format,
-                        decodedWidth, decodedHeight,
-                        mVideoWidth, mVideoHeight,
-                        rotationDegrees));
-        } else {
-            // Other decoders are instantiated locally and as a consequence
-            // allocate their buffers in local address space.
-            mVideoRenderer = new AwesomeLocalRenderer(
-                false,  // previewOnly
-                component,
-                (OMX_COLOR_FORMATTYPE)format,
-                mISurface,
-                mVideoWidth, mVideoHeight,
-                decodedWidth, decodedHeight, rotationDegrees);
-        }
+status_t AwesomePlayer::initRenderer_l() {
+    if (mISurface == NULL) {
+        return OK;
     }
+
+    sp<MetaData> meta = mVideoSource->getFormat();
+
+    int32_t format;
+    const char *component;
+    int32_t decodedWidth, decodedHeight;
+    CHECK(meta->findInt32(kKeyColorFormat, &format));
+    CHECK(meta->findCString(kKeyDecoderComponent, &component));
+    CHECK(meta->findInt32(kKeyWidth, &decodedWidth));
+    CHECK(meta->findInt32(kKeyHeight, &decodedHeight));
+
+    int32_t rotationDegrees;
+    if (!mVideoTrack->getFormat()->findInt32(
+                kKeyRotation, &rotationDegrees)) {
+        rotationDegrees = 0;
+    }
+
+    mVideoRenderer.clear();
+
+    // Must ensure that mVideoRenderer's destructor is actually executed
+    // before creating a new one.
+    IPCThreadState::self()->flushCommands();
+
+    if (!strncmp("OMX.", component, 4)) {
+        // Our OMX codecs allocate buffers on the media_server side
+        // therefore they require a remote IOMXRenderer that knows how
+        // to display them.
+
+        sp<IOMXRenderer> native =
+            mClient.interface()->createRenderer(
+                    mISurface, component,
+                    (OMX_COLOR_FORMATTYPE)format,
+                    decodedWidth, decodedHeight,
+                    mVideoWidth, mVideoHeight,
+                    rotationDegrees);
+
+        if (native == NULL) {
+            return NO_INIT;
+        }
+
+        mVideoRenderer = new AwesomeRemoteRenderer(native);
+    } else {
+        // Other decoders are instantiated locally and as a consequence
+        // allocate their buffers in local address space.
+        mVideoRenderer = new AwesomeLocalRenderer(
+            false,  // previewOnly
+            component,
+            (OMX_COLOR_FORMATTYPE)format,
+            mISurface,
+            mVideoWidth, mVideoHeight,
+            decodedWidth, decodedHeight, rotationDegrees);
+    }
+
+    return mVideoRenderer->initCheck();
 }
 
 status_t AwesomePlayer::pause() {
@@ -1217,9 +1242,16 @@
 
                     if (mVideoRenderer != NULL) {
                         mVideoRendererIsPreview = false;
-                        initRenderer_l();
+                        err = initRenderer_l();
+
+                        if (err == OK) {
+                            continue;
+                        }
+
+                        // fall through
+                    } else {
+                        continue;
                     }
-                    continue;
                 }
 
                 // So video playback is complete, but we may still have
@@ -1256,6 +1288,7 @@
         mVideoTimeUs = timeUs;
     }
 
+    bool wasSeeking = mSeeking;
     finishSeekIfNecessary(timeUs);
 
     TimeSource *ts = (mFlags & AUDIO_AT_EOS) ? &mSystemTimeSource : mTimeSource;
@@ -1283,6 +1316,11 @@
 
     int64_t latenessUs = nowUs - timeUs;
 
+    if (wasSeeking) {
+        // Let's display the first frame after seeking right away.
+        latenessUs = 0;
+    }
+
     if (mRTPSession != NULL) {
         // We'll completely ignore timestamps for gtalk videochat
         // and we'll play incoming video as fast as we get it.
@@ -1310,7 +1348,15 @@
     if (mVideoRendererIsPreview || mVideoRenderer == NULL) {
         mVideoRendererIsPreview = false;
 
-        initRenderer_l();
+        status_t err = initRenderer_l();
+
+        if (err != OK) {
+            finishSeekIfNecessary(-1);
+
+            mFlags |= VIDEO_AT_EOS;
+            postStreamDoneEvent_l(err);
+            return;
+        }
     }
 
     if (mVideoRenderer != NULL) {
diff --git a/media/libstagefright/MP3Extractor.cpp b/media/libstagefright/MP3Extractor.cpp
index 82c0426..b15c720 100644
--- a/media/libstagefright/MP3Extractor.cpp
+++ b/media/libstagefright/MP3Extractor.cpp
@@ -743,6 +743,7 @@
         { kKeyAuthor, "TXT", "TEXT" },
         { kKeyCDTrackNumber, "TRK", "TRCK" },
         { kKeyDiscNumber, "TPA", "TPOS" },
+        { kKeyCompilation, "TCP", "TCMP" },
     };
     static const size_t kNumMapEntries = sizeof(kMap) / sizeof(kMap[0]);
 
diff --git a/media/libstagefright/MPEG4Extractor.cpp b/media/libstagefright/MPEG4Extractor.cpp
index 03682e2..5497322 100644
--- a/media/libstagefright/MPEG4Extractor.cpp
+++ b/media/libstagefright/MPEG4Extractor.cpp
@@ -1379,6 +1379,17 @@
             metadataKey = kKeyGenre;
             break;
         }
+        case FOURCC('c', 'p', 'i', 'l'):
+        {
+            if (size == 9 && flags == 21) {
+                char tmp[16];
+                sprintf(tmp, "%d",
+                        (int)buffer[size - 1]);
+
+                mFileMetaData->setCString(kKeyCompilation, tmp);
+            }
+            break;
+        }
         case FOURCC('t', 'r', 'k', 'n'):
         {
             if (size == 16 && flags == 0) {
diff --git a/media/libstagefright/MPEG4Writer.cpp b/media/libstagefright/MPEG4Writer.cpp
index cbb1604..7eb7d46 100644
--- a/media/libstagefright/MPEG4Writer.cpp
+++ b/media/libstagefright/MPEG4Writer.cpp
@@ -863,7 +863,10 @@
         nTotalBytesEstimate += (*it)->getEstimatedTrackSizeBytes();
     }
 
-    return (nTotalBytesEstimate >= mMaxFileSizeLimitBytes);
+    // Be conservative in the estimate: do not exceed 95% of
+    // the target file limit. For small target file size limit, though,
+    // this will not help.
+    return (nTotalBytesEstimate >= (95 * mMaxFileSizeLimitBytes) / 100);
 }
 
 bool MPEG4Writer::exceedsFileDurationLimit() {
diff --git a/media/libstagefright/NuHTTPDataSource.cpp b/media/libstagefright/NuHTTPDataSource.cpp
index 2743b2f..04cca47 100644
--- a/media/libstagefright/NuHTTPDataSource.cpp
+++ b/media/libstagefright/NuHTTPDataSource.cpp
@@ -67,7 +67,9 @@
       mPort(0),
       mOffset(0),
       mContentLength(0),
-      mContentLengthValid(false) {
+      mContentLengthValid(false),
+      mHasChunkedTransferEncoding(false),
+      mChunkDataBytesLeft(0) {
 }
 
 NuHTTPDataSource::~NuHTTPDataSource() {
@@ -184,6 +186,30 @@
             return ERROR_IO;
         }
 
+        mHasChunkedTransferEncoding = false;
+
+        {
+            string value;
+            if (mHTTP.find_header_value("Transfer-Encoding", &value)
+                    || mHTTP.find_header_value("Transfer-encoding", &value)) {
+                // We don't currently support any transfer encodings but
+                // chunked.
+
+                if (!strcasecmp(value.c_str(), "chunked")) {
+                    LOGI("Chunked transfer encoding applied.");
+                    mHasChunkedTransferEncoding = true;
+                    mChunkDataBytesLeft = 0;
+                } else {
+                    mState = DISCONNECTED;
+                    mHTTP.disconnect();
+
+                    LOGE("We don't support '%s' transfer encoding.", value.c_str());
+
+                    return ERROR_UNSUPPORTED;
+                }
+            }
+        }
+
         applyTimeoutResponse();
 
         if (offset == 0) {
@@ -193,8 +219,17 @@
                     && ParseSingleUnsignedLong(value.c_str(), &x)) {
                 mContentLength = (off_t)x;
                 mContentLengthValid = true;
+            } else {
+                LOGW("Server did not give us the content length!");
             }
         } else {
+            if (httpStatus != 206 /* Partial Content */) {
+                // We requested a range but the server didn't support that.
+                LOGE("We requested a range but the server didn't "
+                     "support that.");
+                return ERROR_UNSUPPORTED;
+            }
+
             string value;
             unsigned long x;
             if (mHTTP.find_header_value(string("Content-Range"), &value)) {
@@ -222,6 +257,71 @@
     return mState == CONNECTED ? OK : NO_INIT;
 }
 
+ssize_t NuHTTPDataSource::internalRead(void *data, size_t size) {
+    if (!mHasChunkedTransferEncoding) {
+        return mHTTP.receive(data, size);
+    }
+
+    if (mChunkDataBytesLeft < 0) {
+        return 0;
+    } else if (mChunkDataBytesLeft == 0) {
+        char line[1024];
+        status_t err = mHTTP.receive_line(line, sizeof(line));
+
+        if (err != OK) {
+            return err;
+        }
+
+        LOGV("line = '%s'", line);
+
+        char *end;
+        unsigned long n = strtoul(line, &end, 16);
+
+        if (end == line || (*end != ';' && *end != '\0')) {
+            LOGE("malformed HTTP chunk '%s'", line);
+            return ERROR_MALFORMED;
+        }
+
+        mChunkDataBytesLeft = n;
+        LOGV("chunk data size = %lu", n);
+
+        if (mChunkDataBytesLeft == 0) {
+            mChunkDataBytesLeft = -1;
+            return 0;
+        }
+
+        // fall through
+    }
+
+    if (size > (size_t)mChunkDataBytesLeft) {
+        size = mChunkDataBytesLeft;
+    }
+
+    ssize_t n = mHTTP.receive(data, size);
+
+    if (n < 0) {
+        return n;
+    }
+
+    mChunkDataBytesLeft -= (size_t)n;
+
+    if (mChunkDataBytesLeft == 0) {
+        char line[1024];
+        status_t err = mHTTP.receive_line(line, sizeof(line));
+
+        if (err != OK) {
+            return err;
+        }
+
+        if (line[0] != '\0') {
+            LOGE("missing HTTP chunk terminator.");
+            return ERROR_MALFORMED;
+        }
+    }
+
+    return n;
+}
+
 ssize_t NuHTTPDataSource::readAt(off_t offset, void *data, size_t size) {
     LOGV("readAt offset %ld, size %d", offset, size);
 
@@ -250,7 +350,7 @@
     size_t numBytesRead = 0;
     while (numBytesRead < size) {
         ssize_t n =
-            mHTTP.receive((uint8_t *)data + numBytesRead, size - numBytesRead);
+            internalRead((uint8_t *)data + numBytesRead, size - numBytesRead);
 
         if (n < 0) {
             return n;
diff --git a/media/libstagefright/OMXCodec.cpp b/media/libstagefright/OMXCodec.cpp
index 980da77..b5d00bf 100644
--- a/media/libstagefright/OMXCodec.cpp
+++ b/media/libstagefright/OMXCodec.cpp
@@ -234,7 +234,9 @@
         sp<OMXCodec> codec = mTarget.promote();
 
         if (codec.get() != NULL) {
+            Mutex::Autolock autoLock(codec->mLock);
             codec->on_message(msg);
+            codec.clear();
         }
     }
 
@@ -1672,8 +1674,6 @@
 }
 
 void OMXCodec::on_message(const omx_message &msg) {
-    Mutex::Autolock autoLock(mLock);
-
     switch (msg.type) {
         case omx_message::EVENT:
         {
diff --git a/media/libstagefright/OggExtractor.cpp b/media/libstagefright/OggExtractor.cpp
index 43938b2..0368fb7 100644
--- a/media/libstagefright/OggExtractor.cpp
+++ b/media/libstagefright/OggExtractor.cpp
@@ -660,6 +660,9 @@
     } kMap[] = {
         { "TITLE", kKeyTitle },
         { "ARTIST", kKeyArtist },
+        { "ALBUMARTIST", kKeyAlbumArtist },
+        { "ALBUM ARTIST", kKeyAlbumArtist },
+        { "COMPILATION", kKeyCompilation },
         { "ALBUM", kKeyAlbum },
         { "COMPOSER", kKeyComposer },
         { "GENRE", kKeyGenre },
diff --git a/media/libstagefright/StagefrightMediaScanner.cpp b/media/libstagefright/StagefrightMediaScanner.cpp
index 8426ee7..8580cc4 100644
--- a/media/libstagefright/StagefrightMediaScanner.cpp
+++ b/media/libstagefright/StagefrightMediaScanner.cpp
@@ -156,6 +156,7 @@
             { "year", METADATA_KEY_YEAR },
             { "duration", METADATA_KEY_DURATION },
             { "writer", METADATA_KEY_WRITER },
+            { "compilation", METADATA_KEY_COMPILATION },
         };
         static const size_t kNumEntries = sizeof(kKeyMap) / sizeof(kKeyMap[0]);
 
diff --git a/media/libstagefright/StagefrightMetadataRetriever.cpp b/media/libstagefright/StagefrightMetadataRetriever.cpp
index 9b2dec9..ac208cd 100644
--- a/media/libstagefright/StagefrightMetadataRetriever.cpp
+++ b/media/libstagefright/StagefrightMetadataRetriever.cpp
@@ -355,6 +355,7 @@
         { kKeyTitle, METADATA_KEY_TITLE },
         { kKeyYear, METADATA_KEY_YEAR },
         { kKeyWriter, METADATA_KEY_WRITER },
+        { kKeyCompilation, METADATA_KEY_COMPILATION },
     };
     static const size_t kNumMapEntries = sizeof(kMap) / sizeof(kMap[0]);
 
diff --git a/media/libstagefright/colorconversion/SoftwareRenderer.cpp b/media/libstagefright/colorconversion/SoftwareRenderer.cpp
index 86ad85b..93ec79d 100644
--- a/media/libstagefright/colorconversion/SoftwareRenderer.cpp
+++ b/media/libstagefright/colorconversion/SoftwareRenderer.cpp
@@ -32,7 +32,8 @@
         size_t displayWidth, size_t displayHeight,
         size_t decodedWidth, size_t decodedHeight,
         int32_t rotationDegrees)
-    : mColorFormat(colorFormat),
+    : mInitCheck(NO_INIT),
+      mColorFormat(colorFormat),
       mConverter(colorFormat, OMX_COLOR_Format16bitRGB565),
       mISurface(surface),
       mDisplayWidth(displayWidth),
@@ -74,15 +75,28 @@
             mMemoryHeap);
 
     status_t err = mISurface->registerBuffers(bufferHeap);
-    CHECK_EQ(err, OK);
+
+    if (err != OK) {
+        LOGW("ISurface failed to register buffers (0x%08x)", err);
+    }
+
+    mInitCheck = err;
 }
 
 SoftwareRenderer::~SoftwareRenderer() {
     mISurface->unregisterBuffers();
 }
 
+status_t SoftwareRenderer::initCheck() const {
+    return mInitCheck;
+}
+
 void SoftwareRenderer::render(
         const void *data, size_t size, void *platformPrivate) {
+    if (mInitCheck != OK) {
+        return;
+    }
+
     size_t offset = mIndex * mFrameSize;
     void *dst = (uint8_t *)mMemoryHeap->getBase() + offset;
 
diff --git a/media/libstagefright/httplive/LiveSource.cpp b/media/libstagefright/httplive/LiveSource.cpp
index 4124571..29c7b04 100644
--- a/media/libstagefright/httplive/LiveSource.cpp
+++ b/media/libstagefright/httplive/LiveSource.cpp
@@ -318,20 +318,41 @@
     status_t err = source->getSize(&size);
 
     if (err != OK) {
-        return err;
+        size = 65536;
     }
 
     sp<ABuffer> buffer = new ABuffer(size);
-    size_t offset = 0;
-    while (offset < (size_t)size) {
-        ssize_t n = source->readAt(
-                offset, buffer->data() + offset, size - offset);
+    buffer->setRange(0, 0);
 
-        if (n <= 0) {
-            return ERROR_IO;
+    for (;;) {
+        size_t bufferRemaining = buffer->capacity() - buffer->size();
+
+        if (bufferRemaining == 0) {
+            bufferRemaining = 32768;
+
+            LOGV("increasing download buffer to %d bytes",
+                 buffer->size() + bufferRemaining);
+
+            sp<ABuffer> copy = new ABuffer(buffer->size() + bufferRemaining);
+            memcpy(copy->data(), buffer->data(), buffer->size());
+            copy->setRange(0, buffer->size());
+
+            buffer = copy;
         }
 
-        offset += n;
+        ssize_t n = source->readAt(
+                buffer->size(), buffer->data() + buffer->size(),
+                bufferRemaining);
+
+        if (n < 0) {
+            return err;
+        }
+
+        if (n == 0) {
+            break;
+        }
+
+        buffer->setRange(0, buffer->size() + (size_t)n);
     }
 
     *out = buffer;
diff --git a/media/libstagefright/include/AwesomePlayer.h b/media/libstagefright/include/AwesomePlayer.h
index 4526bf1..e352928 100644
--- a/media/libstagefright/include/AwesomePlayer.h
+++ b/media/libstagefright/include/AwesomePlayer.h
@@ -48,6 +48,7 @@
 struct AwesomeRenderer : public RefBase {
     AwesomeRenderer() {}
 
+    virtual status_t initCheck() const = 0;
     virtual void render(MediaBuffer *buffer) = 0;
 
 private:
@@ -232,7 +233,7 @@
     void partial_reset_l();
     status_t seekTo_l(int64_t timeUs);
     status_t pause_l(bool at_eos = false);
-    void initRenderer_l();
+    status_t initRenderer_l();
     void seekAudioIfNecessary_l();
 
     void cancelPlayerEvents(bool keepBufferingGoing = false);
diff --git a/media/libstagefright/include/HTTPStream.h b/media/libstagefright/include/HTTPStream.h
index 35b0865..793798f 100644
--- a/media/libstagefright/include/HTTPStream.h
+++ b/media/libstagefright/include/HTTPStream.h
@@ -55,6 +55,10 @@
     // Pass a negative value to disable the timeout.
     void setReceiveTimeout(int seconds);
 
+    // Receive a line of data terminated by CRLF, line will be '\0' terminated
+    // _excluding_ the termianting CRLF.
+    status_t receive_line(char *line, size_t size);
+
 private:
     enum State {
         READY,
@@ -68,10 +72,6 @@
 
     KeyedVector<string, string> mHeaders;
 
-    // Receive a line of data terminated by CRLF, line will be '\0' terminated
-    // _excluding_ the termianting CRLF.
-    status_t receive_line(char *line, size_t size);
-
     HTTPStream(const HTTPStream &);
     HTTPStream &operator=(const HTTPStream &);
 };
diff --git a/media/libstagefright/include/NuHTTPDataSource.h b/media/libstagefright/include/NuHTTPDataSource.h
index 8593a91..3c88cc2 100644
--- a/media/libstagefright/include/NuHTTPDataSource.h
+++ b/media/libstagefright/include/NuHTTPDataSource.h
@@ -49,6 +49,11 @@
     off_t mOffset;
     off_t mContentLength;
     bool mContentLengthValid;
+    bool mHasChunkedTransferEncoding;
+
+    // The number of data bytes in the current chunk before any subsequent
+    // chunk header (or -1 if no more chunks).
+    ssize_t mChunkDataBytesLeft;
 
     status_t connect(
             const char *uri, const String8 &headers, off_t offset);
@@ -58,6 +63,9 @@
             const String8 &headers,
             off_t offset);
 
+    // Read up to "size" bytes of data, respect transfer encoding.
+    ssize_t internalRead(void *data, size_t size);
+
     void applyTimeoutResponse();
 
     static void MakeFullHeaders(
diff --git a/media/libstagefright/include/SoftwareRenderer.h b/media/libstagefright/include/SoftwareRenderer.h
index 25c9df7..89d7cc4 100644
--- a/media/libstagefright/include/SoftwareRenderer.h
+++ b/media/libstagefright/include/SoftwareRenderer.h
@@ -38,10 +38,13 @@
 
     virtual ~SoftwareRenderer();
 
+    status_t initCheck() const;
+
     virtual void render(
             const void *data, size_t size, void *platformPrivate);
 
 private:
+    status_t mInitCheck;
     OMX_COLOR_FORMATTYPE mColorFormat;
     ColorConverter mConverter;
     sp<ISurface> mISurface;
diff --git a/media/libstagefright/matroska/MatroskaExtractor.cpp b/media/libstagefright/matroska/MatroskaExtractor.cpp
index 7c7d69e..1661130 100644
--- a/media/libstagefright/matroska/MatroskaExtractor.cpp
+++ b/media/libstagefright/matroska/MatroskaExtractor.cpp
@@ -22,13 +22,15 @@
 
 #include "mkvparser.hpp"
 
+#include <media/stagefright/foundation/ADebug.h>
+#include <media/stagefright/foundation/hexdump.h>
 #include <media/stagefright/DataSource.h>
 #include <media/stagefright/MediaBuffer.h>
-#include <media/stagefright/MediaDebug.h>
 #include <media/stagefright/MediaDefs.h>
 #include <media/stagefright/MediaErrors.h>
 #include <media/stagefright/MediaSource.h>
 #include <media/stagefright/MetaData.h>
+#include <media/stagefright/Utils.h>
 #include <utils/String8.h>
 
 namespace android {
@@ -81,46 +83,6 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#include <ctype.h>
-static void hexdump(const void *_data, size_t size) {
-    const uint8_t *data = (const uint8_t *)_data;
-    size_t offset = 0;
-    while (offset < size) {
-        printf("0x%04x  ", offset);
-
-        size_t n = size - offset;
-        if (n > 16) {
-            n = 16;
-        }
-
-        for (size_t i = 0; i < 16; ++i) {
-            if (i == 8) {
-                printf(" ");
-            }
-
-            if (offset + i < size) {
-                printf("%02x ", data[offset + i]);
-            } else {
-                printf("   ");
-            }
-        }
-
-        printf(" ");
-
-        for (size_t i = 0; i < n; ++i) {
-            if (isprint(data[offset + i])) {
-                printf("%c", data[offset + i]);
-            } else {
-                printf(".");
-            }
-        }
-
-        printf("\n");
-
-        offset += 16;
-    }
-}
-
 struct BlockIterator {
     BlockIterator(mkvparser::Segment *segment, unsigned long trackNum);
 
@@ -156,6 +118,9 @@
     virtual status_t read(
             MediaBuffer **buffer, const ReadOptions *options);
 
+protected:
+    virtual ~MatroskaSource();
+
 private:
     enum Type {
         AVC,
@@ -167,9 +132,15 @@
     size_t mTrackIndex;
     Type mType;
     BlockIterator mBlockIter;
+    size_t mNALSizeLen;  // for type AVC
+
+    List<MediaBuffer *> mPendingFrames;
 
     status_t advance();
 
+    status_t readBlock();
+    void clearPendingFrames();
+
     MatroskaSource(const MatroskaSource &);
     MatroskaSource &operator=(const MatroskaSource &);
 };
@@ -180,18 +151,35 @@
       mTrackIndex(index),
       mType(OTHER),
       mBlockIter(mExtractor->mSegment,
-                 mExtractor->mTracks.itemAt(index).mTrackNum) {
+                 mExtractor->mTracks.itemAt(index).mTrackNum),
+      mNALSizeLen(0) {
+    sp<MetaData> meta = mExtractor->mTracks.itemAt(index).mMeta;
+
     const char *mime;
-    CHECK(mExtractor->mTracks.itemAt(index).mMeta->
-            findCString(kKeyMIMEType, &mime));
+    CHECK(meta->findCString(kKeyMIMEType, &mime));
 
     if (!strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_AVC)) {
         mType = AVC;
+
+        uint32_t dummy;
+        const uint8_t *avcc;
+        size_t avccSize;
+        CHECK(meta->findData(
+                    kKeyAVCC, &dummy, (const void **)&avcc, &avccSize));
+
+        CHECK_GE(avccSize, 5u);
+
+        mNALSizeLen = 1 + (avcc[4] & 3);
+        LOGV("mNALSizeLen = %d", mNALSizeLen);
     } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AAC)) {
         mType = AAC;
     }
 }
 
+MatroskaSource::~MatroskaSource() {
+    clearPendingFrames();
+}
+
 status_t MatroskaSource::start(MetaData *params) {
     mBlockIter.reset();
 
@@ -199,6 +187,8 @@
 }
 
 status_t MatroskaSource::stop() {
+    clearPendingFrames();
+
     return OK;
 }
 
@@ -252,7 +242,7 @@
 }
 
 void BlockIterator::seek(int64_t seekTimeUs) {
-    mCluster = mSegment->GetCluster(seekTimeUs * 1000ll);
+    mCluster = mSegment->FindCluster(seekTimeUs * 1000ll);
     mBlockEntry = mCluster != NULL ? mCluster->GetFirst() : NULL;
 
     while (!eos() && block()->GetTrackNumber() != mTrackNum) {
@@ -276,6 +266,218 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
+static unsigned U24_AT(const uint8_t *ptr) {
+    return ptr[0] << 16 | ptr[1] << 8 | ptr[2];
+}
+
+static size_t clz(uint8_t x) {
+    size_t numLeadingZeroes = 0;
+
+    while (!(x & 0x80)) {
+        ++numLeadingZeroes;
+        x = x << 1;
+    }
+
+    return numLeadingZeroes;
+}
+
+void MatroskaSource::clearPendingFrames() {
+    while (!mPendingFrames.empty()) {
+        MediaBuffer *frame = *mPendingFrames.begin();
+        mPendingFrames.erase(mPendingFrames.begin());
+
+        frame->release();
+        frame = NULL;
+    }
+}
+
+#define BAIL(err) \
+    do {                        \
+        if (bigbuf) {           \
+            bigbuf->release();  \
+            bigbuf = NULL;      \
+        }                       \
+                                \
+        return err;             \
+    } while (0)
+
+status_t MatroskaSource::readBlock() {
+    CHECK(mPendingFrames.empty());
+
+    if (mBlockIter.eos()) {
+        return ERROR_END_OF_STREAM;
+    }
+
+    const mkvparser::Block *block = mBlockIter.block();
+
+    size_t size = block->GetSize();
+    int64_t timeUs = mBlockIter.blockTimeUs();
+    int32_t isSync = block->IsKey();
+
+    MediaBuffer *bigbuf = new MediaBuffer(size);
+
+    long res = block->Read(
+            mExtractor->mReader, (unsigned char *)bigbuf->data());
+
+    if (res != 0) {
+        bigbuf->release();
+        bigbuf = NULL;
+
+        return ERROR_END_OF_STREAM;
+    }
+
+    mBlockIter.advance();
+
+    bigbuf->meta_data()->setInt64(kKeyTime, timeUs);
+    bigbuf->meta_data()->setInt32(kKeyIsSyncFrame, isSync);
+
+    unsigned lacing = (block->Flags() >> 1) & 3;
+
+    if (lacing == 0) {
+        mPendingFrames.push_back(bigbuf);
+        return OK;
+    }
+
+    LOGV("lacing = %u, size = %d", lacing, size);
+
+    const uint8_t *data = (const uint8_t *)bigbuf->data();
+    // hexdump(data, size);
+
+    if (size == 0) {
+        BAIL(ERROR_MALFORMED);
+    }
+
+    unsigned numFrames = (unsigned)data[0] + 1;
+    ++data;
+    --size;
+
+    Vector<uint64_t> frameSizes;
+
+    switch (lacing) {
+        case 1:  // Xiph
+        {
+            for (size_t i = 0; i < numFrames - 1; ++i) {
+                size_t frameSize = 0;
+                uint8_t byte;
+                do {
+                    if (size == 0) {
+                        BAIL(ERROR_MALFORMED);
+                    }
+                    byte = data[0];
+                    ++data;
+                    --size;
+
+                    frameSize += byte;
+                } while (byte == 0xff);
+
+                frameSizes.push(frameSize);
+            }
+
+            break;
+        }
+
+        case 2:  // fixed-size
+        {
+            if ((size % numFrames) != 0) {
+                BAIL(ERROR_MALFORMED);
+            }
+
+            size_t frameSize = size / numFrames;
+            for (size_t i = 0; i < numFrames - 1; ++i) {
+                frameSizes.push(frameSize);
+            }
+
+            break;
+        }
+
+        case 3:  // EBML
+        {
+            uint64_t lastFrameSize = 0;
+            for (size_t i = 0; i < numFrames - 1; ++i) {
+                uint8_t byte;
+
+                if (size == 0) {
+                    BAIL(ERROR_MALFORMED);
+                }
+                byte = data[0];
+                ++data;
+                --size;
+
+                size_t numLeadingZeroes = clz(byte);
+
+                uint64_t frameSize = byte & ~(0x80 >> numLeadingZeroes);
+                for (size_t j = 0; j < numLeadingZeroes; ++j) {
+                    if (size == 0) {
+                        BAIL(ERROR_MALFORMED);
+                    }
+
+                    frameSize = frameSize << 8;
+                    frameSize |= data[0];
+                    ++data;
+                    --size;
+                }
+
+                if (i == 0) {
+                    frameSizes.push(frameSize);
+                } else {
+                    size_t shift =
+                        7 - numLeadingZeroes + 8 * numLeadingZeroes;
+
+                    int64_t delta =
+                        (int64_t)frameSize - (1ll << (shift - 1)) + 1;
+
+                    frameSize = lastFrameSize + delta;
+
+                    frameSizes.push(frameSize);
+                }
+
+                lastFrameSize = frameSize;
+            }
+            break;
+        }
+
+        default:
+            TRESPASS();
+    }
+
+#if 0
+    AString out;
+    for (size_t i = 0; i < frameSizes.size(); ++i) {
+        if (i > 0) {
+            out.append(", ");
+        }
+        out.append(StringPrintf("%llu", frameSizes.itemAt(i)));
+    }
+    LOGV("sizes = [%s]", out.c_str());
+#endif
+
+    for (size_t i = 0; i < frameSizes.size(); ++i) {
+        uint64_t frameSize = frameSizes.itemAt(i);
+
+        if (size < frameSize) {
+            BAIL(ERROR_MALFORMED);
+        }
+
+        MediaBuffer *mbuf = new MediaBuffer(frameSize);
+        mbuf->meta_data()->setInt64(kKeyTime, timeUs);
+        mbuf->meta_data()->setInt32(kKeyIsSyncFrame, isSync);
+        memcpy(mbuf->data(), data, frameSize);
+        mPendingFrames.push_back(mbuf);
+
+        data += frameSize;
+        size -= frameSize;
+    }
+
+    size_t offset = bigbuf->range_length() - size;
+    bigbuf->set_range(offset, size);
+
+    mPendingFrames.push_back(bigbuf);
+
+    return OK;
+}
+
+#undef BAIL
+
 status_t MatroskaSource::read(
         MediaBuffer **out, const ReadOptions *options) {
     *out = NULL;
@@ -283,60 +485,95 @@
     int64_t seekTimeUs;
     ReadOptions::SeekMode mode;
     if (options && options->getSeekTo(&seekTimeUs, &mode)) {
+        clearPendingFrames();
         mBlockIter.seek(seekTimeUs);
     }
 
-    if (mBlockIter.eos()) {
-        return ERROR_END_OF_STREAM;
-    }
+again:
+    while (mPendingFrames.empty()) {
+        status_t err = readBlock();
 
-    const mkvparser::Block *block = mBlockIter.block();
-    size_t size = block->GetSize();
-    int64_t timeUs = mBlockIter.blockTimeUs();
+        if (err != OK) {
+            clearPendingFrames();
 
-    MediaBuffer *buffer = new MediaBuffer(size + 2);
-    buffer->meta_data()->setInt64(kKeyTime, timeUs);
-    buffer->meta_data()->setInt32(kKeyIsSyncFrame, block->IsKey());
-
-    long res = block->Read(
-            mExtractor->mReader, (unsigned char *)buffer->data() + 2);
-
-    if (res != 0) {
-        return ERROR_END_OF_STREAM;
-    }
-
-    buffer->set_range(2, size);
-
-    if (mType == AVC) {
-        CHECK(size >= 2);
-
-        uint8_t *data = (uint8_t *)buffer->data();
-
-        unsigned NALsize = data[2] << 8 | data[3];
-        CHECK_EQ(size, NALsize + 2);
-
-        memcpy(data, "\x00\x00\x00\x01", 4);
-        buffer->set_range(0, size + 2);
-    } else if (mType == AAC) {
-        // There's strange junk at the beginning...
-
-        const uint8_t *data = (const uint8_t *)buffer->data() + 2;
-        size_t offset = 0;
-        while (offset < size && data[offset] != 0x21) {
-            ++offset;
+            return err;
         }
-        buffer->set_range(2 + offset, size - offset);
     }
 
+    MediaBuffer *frame = *mPendingFrames.begin();
+    mPendingFrames.erase(mPendingFrames.begin());
+
+    size_t size = frame->range_length();
+
+    if (mType != AVC) {
+        *out = frame;
+
+        return OK;
+    }
+
+    if (size < mNALSizeLen) {
+        frame->release();
+        frame = NULL;
+
+        return ERROR_MALFORMED;
+    }
+
+    // In the case of AVC content, each NAL unit is prefixed by
+    // mNALSizeLen bytes of length. We want to prefix the data with
+    // a four-byte 0x00000001 startcode instead of the length prefix.
+    // mNALSizeLen ranges from 1 through 4 bytes, so add an extra
+    // 3 bytes of padding to the buffer start.
+    static const size_t kPadding = 3;
+
+    MediaBuffer *buffer = new MediaBuffer(size + kPadding);
+
+    int64_t timeUs;
+    CHECK(frame->meta_data()->findInt64(kKeyTime, &timeUs));
+    int32_t isSync;
+    CHECK(frame->meta_data()->findInt32(kKeyIsSyncFrame, &isSync));
+
+    buffer->meta_data()->setInt64(kKeyTime, timeUs);
+    buffer->meta_data()->setInt32(kKeyIsSyncFrame, isSync);
+
+    memcpy((uint8_t *)buffer->data() + kPadding,
+           (const uint8_t *)frame->data() + frame->range_offset(),
+           size);
+
+    buffer->set_range(kPadding, size);
+
+    frame->release();
+    frame = NULL;
+
+    uint8_t *data = (uint8_t *)buffer->data();
+
+    size_t NALsize;
+    switch (mNALSizeLen) {
+        case 1: NALsize = data[kPadding]; break;
+        case 2: NALsize = U16_AT(&data[kPadding]); break;
+        case 3: NALsize = U24_AT(&data[kPadding]); break;
+        case 4: NALsize = U32_AT(&data[kPadding]); break;
+        default:
+            TRESPASS();
+    }
+
+    if (size < NALsize + mNALSizeLen) {
+        buffer->release();
+        buffer = NULL;
+
+        return ERROR_MALFORMED;
+    }
+
+    if (size > NALsize + mNALSizeLen) {
+        LOGW("discarding %d bytes of data.", size - NALsize - mNALSizeLen);
+    }
+
+    // actual data starts at &data[kPadding + mNALSizeLen]
+
+    memcpy(&data[mNALSizeLen - 1], "\x00\x00\x00\x01", 4);
+    buffer->set_range(mNALSizeLen - 1, NALsize + 4);
+
     *out = buffer;
 
-#if 0
-    hexdump((const uint8_t *)buffer->data() + buffer->range_offset(),
-            buffer->range_length());
-#endif
-
-    mBlockIter.advance();
-
     return OK;
 }
 
@@ -476,7 +713,7 @@
 
         size_t codecPrivateSize;
         const unsigned char *codecPrivate =
-            track->GetCodecPrivate(&codecPrivateSize);
+            track->GetCodecPrivate(codecPrivateSize);
 
         enum { VIDEO_TRACK = 1, AUDIO_TRACK = 2 };
 
diff --git a/media/libstagefright/matroska/mkvparser.cpp b/media/libstagefright/matroska/mkvparser.cpp
index 4e51004..7448d96 100644
--- a/media/libstagefright/matroska/mkvparser.cpp
+++ b/media/libstagefright/matroska/mkvparser.cpp
@@ -1,3103 +1,4514 @@
-#include "mkvparser.hpp"
-#include <cassert>
-#include <cstring>
-
-mkvparser::IMkvReader::~IMkvReader()
-{
-}
-
-long long mkvparser::ReadUInt(IMkvReader* pReader, long long pos, long& len)
-{
-    assert(pReader);
-    assert(pos >= 0);
-    
-    long long total, available;
-
-    long hr = pReader->Length(&total, &available);
-    assert(hr >= 0);
-    assert(pos < available);
-    assert((available - pos) >= 1);  //assume here max u-int len is 8
-    
-    unsigned char b;
-
-    hr = pReader->Read(pos, 1, &b);
-    if (hr < 0)
-        return hr;
-        
-    assert(hr == 0L);
-    
-    if (b & 0x80)       //1000 0000
-    {
-        len = 1;
-        b &= 0x7F;      //0111 1111
-    }        
-    else if (b & 0x40)  //0100 0000
-    {
-        len = 2;
-        b &= 0x3F;      //0011 1111
-    }
-    else if (b & 0x20)  //0010 0000
-    {
-        len = 3;
-        b &= 0x1F;      //0001 1111
-    }
-    else if (b & 0x10)  //0001 0000
-    {
-        len = 4;
-        b &= 0x0F;      //0000 1111
-    }
-    else if (b & 0x08)  //0000 1000
-    {
-        len = 5;
-        b &= 0x07;      //0000 0111
-    }
-    else if (b & 0x04)  //0000 0100
-    {
-        len = 6;
-        b &= 0x03;      //0000 0011
-    }
-    else if (b & 0x02)  //0000 0010
-    {
-        len = 7;
-        b &= 0x01;      //0000 0001
-    }
-    else 
-    {
-        assert(b & 0x01);  //0000 0001
-        len = 8;
-        b = 0;             //0000 0000
-    }
-    
-    assert((available - pos) >= len);
-    
-    long long result = b;
-    ++pos;
-    for (long i = 1; i < len; ++i)
-    {
-        hr = pReader->Read(pos, 1, &b);
-        
-        if (hr < 0)
-            return hr;
-            
-        assert(hr == 0L);
-        
-        result <<= 8;
-        result |= b;
-        
-        ++pos;
-    }
-    
-    return result;
-}
-    
-    
-long long mkvparser::GetUIntLength(
-    IMkvReader* pReader,
-    long long pos, 
-    long& len)
-{
-    assert(pReader);
-    assert(pos >= 0);
-    
-    long long total, available;
-
-    long hr = pReader->Length(&total, &available);
-    assert(hr >= 0);
-    assert(available <= total);
-    
-    if (pos >= available)
-        return pos;  //too few bytes available
-    
-    unsigned char b;
-    
-    hr = pReader->Read(pos, 1, &b);
-    
-    if (hr < 0)
-        return hr;
-
-    assert(hr == 0L);
-    
-    if (b == 0)  //we can't handle u-int values larger than 8 bytes
-        return E_FILE_FORMAT_INVALID;
-    
-    unsigned char m = 0x80;
-    len = 1;
-    
-    while (!(b & m))
-    {
-        m >>= 1;
-        ++len;
-    }
-    
-    return 0;  //success
-}
-
-
-long long mkvparser::SyncReadUInt(
-    IMkvReader* pReader,
-    long long pos, 
-    long long stop,
-    long& len)
-{
-    assert(pReader);
-
-    if (pos >= stop)
-        return E_FILE_FORMAT_INVALID;
-    
-    unsigned char b;
-    
-    long hr = pReader->Read(pos, 1, &b);
-    
-    if (hr < 0)
-        return hr;
-        
-    if (hr != 0L)
-        return E_BUFFER_NOT_FULL;
-
-    if (b == 0)  //we can't handle u-int values larger than 8 bytes
-        return E_FILE_FORMAT_INVALID;
-    
-    unsigned char m = 0x80;
-    len = 1;
-        
-    while (!(b & m))
-    {
-        m >>= 1;
-        ++len;
-    }
-    
-    if ((pos + len) > stop)
-        return E_FILE_FORMAT_INVALID;
-        
-    long long result = b & (~m);
-    ++pos;
-    
-    for (int i = 1; i < len; ++i)
-    {
-        hr = pReader->Read(pos, 1, &b);
-        
-        if (hr < 0)
-            return hr;
-           
-        if (hr != 0L)
-            return E_BUFFER_NOT_FULL;
-            
-        result <<= 8;
-        result |= b;
-        
-        ++pos;
-    }
-    
-    return result;
-}
-
-
-long long mkvparser::UnserializeUInt(
-    IMkvReader* pReader, 
-    long long pos,
-    long long size)
-{
-    assert(pReader);
-    assert(pos >= 0);
-    assert(size > 0);
-    assert(size <= 8);
-    
-    long long result = 0;
-    
-    for (long long i = 0; i < size; ++i)
-    {
-        unsigned char b;
-        
-        const long hr = pReader->Read(pos, 1, &b);
-        
-        if (hr < 0)      
-            return hr;
-        result <<= 8;
-        result |= b;
-        
-        ++pos;
-    }
-    
-    return result;
-}
-
-
-float mkvparser::Unserialize4Float(
-    IMkvReader* pReader, 
-    long long pos)
-{
-    assert(pReader);
-    assert(pos >= 0);
-    
-    long long total, available;
-    
-    long hr = pReader->Length(&total, &available);
-    assert(hr >= 0);
-    assert(available <= total);
-    assert((pos + 4) <= available);
-    
-    float result;
-    
-    unsigned char* const p = (unsigned char*)&result;
-    unsigned char* q = p + 4;
-    
-    for (;;)
-    {
-        hr = pReader->Read(pos, 1, --q);
-        assert(hr == 0L);
-        
-        if (q == p)
-            break;
-            
-        ++pos;
-    }
-    
-    return result;
-}
-
-
-double mkvparser::Unserialize8Double(
-    IMkvReader* pReader, 
-    long long pos)
-{
-    assert(pReader);
-    assert(pos >= 0);
-    
-    double result;
-    
-    unsigned char* const p = (unsigned char*)&result;
-    unsigned char* q = p + 8;
-    
-    for (;;)
-    {
-        const long hr = pReader->Read(pos, 1, --q);
-        assert(hr == 0L);
-        
-        if (q == p)
-            break;
-            
-        ++pos;
-    }
-    
-    return result;
-}
-
-signed char mkvparser::Unserialize1SInt(
-    IMkvReader* pReader,
-    long long pos)
-{
-    assert(pReader);
-    assert(pos >= 0);
- 
-    long long total, available;
-
-    long hr = pReader->Length(&total, &available);
-    assert(hr == 0);   
-    assert(available <= total);
-    assert(pos < available);
-
-    signed char result;
-
-    hr = pReader->Read(pos, 1, (unsigned char*)&result);
-    assert(hr == 0);
-
-    return result;
-}
-
-short mkvparser::Unserialize2SInt(
-    IMkvReader* pReader, 
-    long long pos)
-{
-    assert(pReader);
-    assert(pos >= 0);
-    
-    long long total, available;
-    
-    long hr = pReader->Length(&total, &available);
-    assert(hr >= 0);
-    assert(available <= total);
-    assert((pos + 2) <= available);
-    
-    short result;
-    
-    unsigned char* const p = (unsigned char*)&result;
-    unsigned char* q = p + 2;
-    
-    for (;;)
-    {
-        hr = pReader->Read(pos, 1, --q);
-        assert(hr == 0L);
-        
-        if (q == p)
-            break;
-            
-        ++pos;
-    }
-    
-    return result;
-}
-
-
-bool mkvparser::Match(
-    IMkvReader* pReader,
-    long long& pos,
-    unsigned long id_,
-    long long& val)
-
-{
-    assert(pReader);
-    assert(pos >= 0);
-    
-    long long total, available;
-
-    long hr = pReader->Length(&total, &available);
-    assert(hr >= 0);
-    assert(available <= total);
-    
-    long len;
-
-    const long long id = ReadUInt(pReader, pos, len);
-    assert(id >= 0);
-    assert(len > 0);
-    assert(len <= 8);
-    assert((pos + len) <= available);
-    
-    if ((unsigned long)id != id_)
-        return false;
-        
-    pos += len;  //consume id
-    
-    const long long size = ReadUInt(pReader, pos, len);
-    assert(size >= 0);
-    assert(size <= 8);
-    assert(len > 0);
-    assert(len <= 8);
-    assert((pos + len) <= available);
-    
-    pos += len;  //consume length of size of payload
-    
-    val = UnserializeUInt(pReader, pos, size);
-    assert(val >= 0);
-    
-    pos += size;  //consume size of payload
-    
-    return true;
-}
-
-bool mkvparser::Match(
-    IMkvReader* pReader,
-    long long& pos,
-    unsigned long id_,
-    char*& val)
-{
-    assert(pReader);
-    assert(pos >= 0);
-    
-    long long total, available;
-
-    long hr = pReader->Length(&total, &available);
-    assert(hr >= 0);
-    assert(available <= total);
-    
-    long len;
-
-    const long long id = ReadUInt(pReader, pos, len);
-    assert(id >= 0);
-    assert(len > 0);
-    assert(len <= 8);
-    assert((pos + len) <= available);
-    
-    if ((unsigned long)id != id_)
-        return false;
-    
-    pos += len;  //consume id
-    
-    const long long size_ = ReadUInt(pReader, pos, len);
-    assert(size_ >= 0);
-    assert(len > 0);
-    assert(len <= 8);
-    assert((pos + len) <= available);
-    
-    pos += len;  //consume length of size of payload
-    assert((pos + size_) <= available);
-
-    const size_t size = static_cast<size_t>(size_);    
-    val = new char[size+1];
-
-    for (size_t i = 0; i < size; ++i)
-    {
-        char c;
-
-        hr = pReader->Read(pos + i, 1, (unsigned char*)&c);
-        assert(hr == 0L);
-            
-        val[i] = c;
-   
-        if (c == '\0')
-            break;     
-   
-    }
-
-    val[size] = '\0';
-    pos += size_;  //consume size of payload
-    
-    return true;
-}
-
-#if 0
-bool mkvparser::Match(
-    IMkvReader* pReader,
-    long long& pos,
-    unsigned long id,
-    wchar_t*& val)
-{
-    char* str;
-    
-    if (!Match(pReader, pos, id, str))
-        return false;
-
-    const size_t size = mbstowcs(NULL, str, 0);
-       
-    if (size == 0) 
-        val = NULL;
-    else 
-    { 
-        val = new wchar_t[size+1];
-        mbstowcs(val, str, size);
-        val[size] = L'\0';
-    }
-
-    delete[] str;
-    return true;    
-}
-#endif
-
-
-bool mkvparser::Match(
-    IMkvReader* pReader,
-    long long& pos,
-    unsigned long id_,
-    unsigned char*& val,
-    size_t *optionalSize)
-{
-    assert(pReader);
-    assert(pos >= 0);
-    
-    long long total, available;
-
-    long hr = pReader->Length(&total, &available);
-    assert(hr >= 0);
-    assert(available <= total);
-    
-    long len;
-    const long long id = ReadUInt(pReader, pos, len);
-    assert(id >= 0);
-    assert(len > 0);
-    assert(len <= 8);
-    assert((pos + len) <= available);
-    
-    if ((unsigned long)id != id_)
-        return false;
-        
-    pos += len;  //consume id
-    
-    const long long size_ = ReadUInt(pReader, pos, len);
-    assert(size_ >= 0);
-    assert(len > 0);
-    assert(len <= 8);
-    assert((pos + len) <= available);
-    
-    pos += len;  //consume length of size of payload
-    assert((pos + size_) <= available);
-
-    const size_t size = static_cast<size_t>(size_);    
-    val = new unsigned char[size];
- 
-    if (optionalSize) {
-        *optionalSize = size;
-    }
-
-    for (size_t i = 0; i < size; ++i)
-    {
-        unsigned char b;
-
-        hr = pReader->Read(pos + i, 1, &b);
-        assert(hr == 0L);
-
-        val[i] = b; 
-    }
-    
-    pos += size_;  //consume size of payload    
-    return true;
-}
-
-
-bool mkvparser::Match(
-    IMkvReader* pReader,
-    long long& pos,
-    unsigned long id_,
-    double& val)
-{
-    assert(pReader);
-    assert(pos >= 0);
-    
-    long long total, available;
-
-    long hr = pReader->Length(&total, &available);
-    assert(hr >= 0);
-    assert(available <= total);
-    long idlen;
-    const long long id = ReadUInt(pReader, pos, idlen);
-    assert(id >= 0);  //TODO
-    
-    if ((unsigned long)id != id_)
-        return false;
-
-    long sizelen;
-    const long long size = ReadUInt(pReader, pos + idlen, sizelen);
-
-    switch (size)
-    {	
-        case 4:
-        case 8:
-            break;
-        default:
-            return false;
-    }
-
-    pos += idlen + sizelen;  //consume id and size fields
-    assert((pos + size) <= available);
-
-    if (size == 4)
-        val = Unserialize4Float(pReader, pos);
-    else
-    {
-        assert(size == 8);
-        val = Unserialize8Double(pReader, pos);
-    }
-    
-    pos += size;  //consume size of payload
-    
-    return true;
-}
-
-
-bool mkvparser::Match(
-    IMkvReader* pReader,
-    long long& pos,
-    unsigned long id_,
-    short& val)
-{
-    assert(pReader);
-    assert(pos >= 0);
-    
-    long long total, available;
-
-    long hr = pReader->Length(&total, &available);
-    assert(hr >= 0);
-    assert(available <= total);
-    
-    long len;
-    const long long id = ReadUInt(pReader, pos, len);
-    assert(id >= 0);
-    assert((pos + len) <= available);
-    
-    if ((unsigned long)id != id_)
-        return false;
-        
-    pos += len;  //consume id
-    
-    const long long size = ReadUInt(pReader, pos, len);
-    assert(size <= 2);
-    assert((pos + len) <= available);
-   
-    pos += len;  //consume length of size of payload
-    assert((pos + size) <= available);
-
-    //TODO:
-    // Generalize this to work for any size signed int
-    if (size == 1)
-        val = Unserialize1SInt(pReader, pos);
-    else 
-        val = Unserialize2SInt(pReader, pos);
-        
-    pos += size;  //consume size of payload
-    
-    return true;
-}
-
-
-namespace mkvparser
-{
-
-EBMLHeader::EBMLHeader():
-    m_docType(NULL)
-{
-}
-
-EBMLHeader::~EBMLHeader()
-{
-    delete[] m_docType;
-}
-
-long long EBMLHeader::Parse(
-    IMkvReader* pReader,
-    long long& pos)
-{
-    assert(pReader);
-    
-    long long total, available;
-    
-    long hr = pReader->Length(&total, &available);
-    
-    if (hr < 0) 
-        return hr;
-    
-    pos = 0;    
-    long long end = (1024 < available)? 1024: available;    
-
-    for (;;)
-    {    
-        unsigned char b = 0;
-    
-        while (pos < end)
-        {
-            hr = pReader->Read(pos, 1, &b);
-           
-            if (hr < 0)
-                return hr;
-            
-            if (b == 0x1A)
-                break;
-                
-            ++pos;
-        }
-    
-        if (b != 0x1A)
-        {
-            if ((pos >= 1024) ||
-                (available >= total) || 
-                ((total - available) < 5))
-                  return -1;
-                
-            return available + 5;  //5 = 4-byte ID + 1st byte of size
-        }
-    
-        if ((total - pos) < 5)
-            return E_FILE_FORMAT_INVALID;
-            
-        if ((available - pos) < 5)
-            return pos + 5;  //try again later
-
-        long len;            
-
-        const long long result = ReadUInt(pReader, pos, len);
-        
-        if (result < 0)  //error
-            return result;
-            
-        if (result == 0x0A45DFA3)  //ReadId masks-off length indicator bits
-        {
-            assert(len == 4);
-            pos += len;
-            break;
-        }
-
-        ++pos;  //throw away just the 0x1A byte, and try again
-    }
-        
-    long len;
-    long long result = GetUIntLength(pReader, pos, len);
-    
-    if (result < 0)  //error
-        return result;
-        
-    if (result > 0)  //need more data
-        return result;
-        
-    assert(len > 0);
-    assert(len <= 8);
-    
-    if ((total -  pos) < len)
-        return E_FILE_FORMAT_INVALID;
-    if ((available - pos) < len)
-        return pos + len;  //try again later
-        
-    result = ReadUInt(pReader, pos, len);
-    
-    if (result < 0)  //error
-        return result;
-        
-    pos += len;  //consume u-int
-    
-    if ((total - pos) < result)
-        return E_FILE_FORMAT_INVALID;
-
-    if ((available - pos) < result)
-        return pos + result;
-        
-    end = pos + result;
-    
-    m_version = 1;
-    m_readVersion = 1;
-    m_maxIdLength = 4;
-    m_maxSizeLength = 8;
-    m_docTypeVersion = 1;
-    m_docTypeReadVersion = 1;
-
-    while (pos < end)
-    {
-        if (Match(pReader, pos, 0x0286, m_version))   
-            ;
-        else if (Match(pReader, pos, 0x02F7, m_readVersion))        
-            ;
-        else if (Match(pReader, pos, 0x02F2, m_maxIdLength))        
-            ;
-        else if (Match(pReader, pos, 0x02F3, m_maxSizeLength))      
-            ;
-        else if (Match(pReader, pos, 0x0282, m_docType))            
-            ; 
-        else if (Match(pReader, pos, 0x0287, m_docTypeVersion))     
-            ;
-        else if (Match(pReader, pos, 0x0285, m_docTypeReadVersion)) 
-            ;
-        else
-        {
-            result = ReadUInt(pReader, pos, len);
-            assert(result > 0);
-            assert(len > 0);
-            assert(len <= 8);
-        
-            pos += len;
-            assert(pos < end);
-            
-            result = ReadUInt(pReader, pos, len);
-            assert(result >= 0);
-            assert(len > 0);
-            assert(len <= 8);
-            
-            pos += len + result;
-            assert(pos <= end);
-        }
-    }
-    
-    assert(pos == end);
-        
-    return 0;    
-}
-
-
-Segment::Segment(
-    IMkvReader* pReader,
-    long long start,
-    long long size) :
-    m_pReader(pReader),
-    m_start(start),
-    m_size(size),
-    m_pos(start),
-    m_pInfo(NULL),
-    m_pTracks(NULL),
-    m_clusterCount(0)
-    //m_clusterNumber(0)
-{
-}
-
-
-Segment::~Segment()
-{
-    Cluster** i = m_clusters;
-    Cluster** j = m_clusters + m_clusterCount;
-
-    while (i != j)
-    {
-        Cluster* p = *i++;
-        assert(p);		
-        delete p;
-    } 
-    
-    delete[] m_clusters;
-       
-    delete m_pTracks;
-    delete m_pInfo;
-}
-
-
-long long Segment::CreateInstance(
-    IMkvReader* pReader,
-    long long pos,
-    Segment*& pSegment)
-{
-    assert(pReader);
-    assert(pos >= 0);
-    
-    pSegment = NULL;
-    
-    long long total, available;
-    
-    long hr = pReader->Length(&total, &available);
-    assert(hr >= 0);
-    assert(available <= total);
-    
-    //I would assume that in practice this loop would execute
-    //exactly once, but we allow for other elements (e.g. Void)
-    //to immediately follow the EBML header.  This is fine for
-    //the source filter case (since the entire file is available),
-    //but in the splitter case over a network we should probably
-    //just give up early.  We could for example decide only to
-    //execute this loop a maximum of, say, 10 times.
-    
-    while (pos < total)
-    {    
-        //Read ID
-        
-        long len;
-        long long result = GetUIntLength(pReader, pos, len);
-        
-        if (result)  //error, or too few available bytes
-            return result;
-            
-        if ((pos + len) > total)
-            return E_FILE_FORMAT_INVALID;
-            
-        if ((pos + len) > available)
-            return pos + len;
-
-        //TODO: if we liberalize the behavior of ReadUInt, we can
-        //probably eliminate having to use GetUIntLength here.
-        const long long id = ReadUInt(pReader, pos, len);
-        
-        if (id < 0)  //error
-            return id;
-            
-        pos += len;  //consume ID
-        
-        //Read Size
-        
-        result = GetUIntLength(pReader, pos, len);
-        
-        if (result)  //error, or too few available bytes
-            return result;
-            
-        if ((pos + len) > total)
-            return E_FILE_FORMAT_INVALID;
-            
-        if ((pos + len) > available)
-            return pos + len;
-
-        //TODO: if we liberalize the behavior of ReadUInt, we can
-        //probably eliminate having to use GetUIntLength here.
-        const long long size = ReadUInt(pReader, pos, len);
-        
-        if (size < 0)
-            return size;
-            
-        pos += len;  //consume length of size of element
-        
-        //Pos now points to start of payload
-        
-        if ((pos + size) > total)
-            return E_FILE_FORMAT_INVALID;
-        
-        if (id == 0x08538067)  //Segment ID
-        {
-            pSegment = new  Segment(pReader, pos, size); 
-            assert(pSegment);  //TODO   
-
-            return 0;    //success
-        }
-        
-        pos += size;  //consume payload
-    }
-    
-    assert(pos == total);
-    
-    pSegment = new Segment(pReader, pos, 0); 
-    assert(pSegment);  //TODO   
-
-    return 0;  //success (sort of)
-}
-
-
-long long Segment::ParseHeaders()
-{
-    //Outermost (level 0) segment object has been constructed, 
-    //and pos designates start of payload.  We need to find the
-    //inner (level 1) elements.
-    long long total, available;
-    
-    long hr = m_pReader->Length(&total, &available);
-    assert(hr >= 0);
-    assert(available <= total);
-    
-    const long long stop = m_start + m_size;
-    assert(stop <= total);
-    assert(m_pos <= stop);
-    
-    bool bQuit = false;
-    while ((m_pos < stop) && !bQuit)
-    {
-        long long pos = m_pos;
-        
-        long len;
-        long long result = GetUIntLength(m_pReader, pos, len);
-        
-        if (result)  //error, or too few available bytes
-            return result;
-            
-        if ((pos + len) > stop)
-            return E_FILE_FORMAT_INVALID;
-            
-        if ((pos + len) > available)
-            return pos + len;
-            
-        const long long idpos = pos;
-        const long long id = ReadUInt(m_pReader, idpos, len);
-        
-        if (id < 0)  //error
-            return id;
-            
-        pos += len;  //consume ID
-        
-        //Read Size
-        result = GetUIntLength(m_pReader, pos, len);
-        
-        if (result)  //error, or too few available bytes
-            return result;
-            
-        if ((pos + len) > stop)
-            return E_FILE_FORMAT_INVALID;
-            
-        if ((pos + len) > available)
-            return pos + len;
-
-        const long long size = ReadUInt(m_pReader, pos, len);
-        
-        if (size < 0)
-            return size;
-            
-        pos += len;  //consume length of size of element
-        
-        //Pos now points to start of payload
-        
-        if ((pos + size) > stop)
-            return E_FILE_FORMAT_INVALID;
-            
-        //We read EBML elements either in total or nothing at all.
-            
-        if ((pos + size) > available)
-            return pos + size;
-        
-        if (id == 0x0549A966)  //Segment Info ID
-        {
-            assert(m_pInfo == NULL);
-            m_pInfo = new  SegmentInfo(this, pos, size);
-            assert(m_pInfo);  //TODO
-            
-            if (m_pTracks)
-                bQuit = true;
-        }
-        else if (id == 0x0654AE6B)  //Tracks ID
-        {
-            assert(m_pTracks == NULL);
-            m_pTracks = new  Tracks(this, pos, size);
-            assert(m_pTracks);  //TODO
-            
-            if (m_pInfo)
-                bQuit = true;
-        }
-        else if (id == 0x0F43B675)  //Cluster ID
-        {
-#if 0
-            if (m_pInfo == NULL)  //TODO: liberalize
-                ;  
-            else if (m_pTracks == NULL)
-                ;
-            else
-                //ParseCluster(idpos, pos, size);            
-                Cluster::Parse(this, m_clusters, pos, size);
-#endif
-            bQuit = true;
-        }
-        
-        m_pos = pos + size;  //consume payload
-    }
-    
-    assert(m_pos <= stop);
-    
-    return 0;  //success
-}
-
-
-long Segment::ParseCluster(Cluster*& pCluster, long long& pos_) const
-{
-    pCluster = NULL;
-    pos_ = -1;
-    
-    const long long stop = m_start + m_size;
-    assert(m_pos <= stop);
-    
-    long long pos = m_pos;
-    long long off = -1;
-   
- 
-    while (pos < stop)
-    {
-        long len;
-        const long long idpos = pos;
-        
-        const long long id = SyncReadUInt(m_pReader, pos, stop, len);
-        
-        if (id < 0)  //error
-            return static_cast<long>(id);
-            
-        if (id == 0)
-            return E_FILE_FORMAT_INVALID;
-            
-        pos += len;  //consume id        
-        assert(pos < stop);
-
-        const long long size = SyncReadUInt(m_pReader, pos, stop, len);
-        
-        if (size < 0)  //error
-            return static_cast<long>(size);
-            
-        pos += len;  //consume size
-        assert(pos <= stop);
-            
-        if (size == 0)  //weird
-            continue;
-            
-        //pos now points to start of payload
-            
-        pos += size;  //consume payload
-        assert(pos <= stop);
-
-        if (off >= 0)
-        {
-            pos_ = idpos;
-            break;
-        }
-
-        if (id == 0x0F43B675)  //Cluster ID
-            off = idpos - m_start;
-    }
-    
-    Segment* const this_ = const_cast<Segment*>(this);
-    const size_t idx = m_clusterCount;
-    
-    if (pos >= stop)
-    {
-        pos_ = stop;
-        
-#if 0        
-        if (off < 0)
-        {
-            pCluster = Cluster::CreateEndOfStream(this_, idx);
-            return 1L;
-        }
-#else
-        if (off < 0)
-            return 1L;
-#endif
-                
-        //Reading 0 bytes at pos might work too -- it would depend 
-        //on how the reader is implemented.
-        
-        unsigned char b;
-
-        const long hr = m_pReader->Read(pos - 1, 1, &b);
-        
-        if (hr < 0)
-            return hr;
-            
-        if (hr != 0L)
-            return E_BUFFER_NOT_FULL;
-    }
-    
-    assert(off >= 0);
-    assert(pos_ >= m_start);
-    assert(pos_ <= stop);
-
-    pCluster = Cluster::Parse(this_, idx, off);
-    return 0L;
-}
-
-
-bool Segment::AddCluster(Cluster* pCluster, long long pos)
-{
-    assert(pos >= m_start);
-    
-    const long long stop = m_start + m_size;
-    assert(pos <= stop);
-
-    if (pCluster)    
-        m_clusters[pos] = pCluster;
-        
-    m_pos = pos;  //m_pos >= stop is now we know we have all clusters
-    
-    return (pos >= stop);
-}
-
-
-long Segment::Load()
-{
-    //Outermost (level 0) segment object has been constructed, 
-    //and pos designates start of payload.  We need to find the
-    //inner (level 1) elements.
-    const long long stop = m_start + m_size;
-#ifdef _DEBUG
-    {
-        long long total, available;
-        
-        long hr = m_pReader->Length(&total, &available);
-        assert(hr >= 0);
-        assert(available >= total);
-        assert(stop <= total);
-    }
-#endif
-    long long index = m_pos;
-    
-    m_clusterCount = 0;
-
-    while (index < stop)
-    {
-        long len = 0;
-
-        long long result = GetUIntLength(m_pReader, index, len);
-       
-        if (result < 0)  //error
-            return static_cast<long>(result);
-            
-        if ((index + len) > stop)
-            return E_FILE_FORMAT_INVALID;
-            
-        const long long idpos = index;
-        const long long id = ReadUInt(m_pReader, idpos, len);
-        
-        if (id < 0)  //error
-            return static_cast<long>(id);
-            
-        index += len;  //consume ID
-        
-        //Read Size
-        result = GetUIntLength(m_pReader, index, len);
-        
-        if (result < 0)  //error
-            return static_cast<long>(result);
-            
-        if ((index + len) > stop)
-            return E_FILE_FORMAT_INVALID;
-            
-        const long long size = ReadUInt(m_pReader, index, len);
-        
-        if (size < 0)  //error
-            return static_cast<long>(size);
-            
-        index += len;  //consume length of size of element
- 
-        if (id == 0x0F43B675) // Cluster ID 
-            break;
-	
-        if (id == 0x014D9B74) // SeekHead ID 
-        {
-            ParseSeekHead(index, size, NULL); 
-            break;
-        }
-        index += size;
-    }
-        
-    if (m_clusterCount == 0)
-        return -1L;
-
-    while (m_pos < stop)
-    {
-        long long pos = m_pos;
-        
-        long len;
-
-        long long result = GetUIntLength(m_pReader, pos, len);
-        
-        if (result < 0)  //error
-            return static_cast<long>(result);
-            
-        if ((pos + len) > stop)
-            return E_FILE_FORMAT_INVALID;
-            
-        const long long idpos = pos;
-        const long long id = ReadUInt(m_pReader, idpos, len);
-        
-        if (id < 0)  //error
-            return static_cast<long>(id);
-            
-        pos += len;  //consume ID
-        
-        //Read Size
-        result = GetUIntLength(m_pReader, pos, len);
-        
-        if (result < 0)  //error
-            return static_cast<long>(result);
-            
-        if ((pos + len) > stop)
-	        return E_FILE_FORMAT_INVALID;
-            
-        const long long size = ReadUInt(m_pReader, pos, len);
-       
-        if (size < 0)  //error
-            return static_cast<long>(size);
-            
-        pos += len;  //consume length of size of element
-        
-        //Pos now points to start of payload
-        
-        if ((pos + size) > stop)
-            return E_FILE_FORMAT_INVALID;
-            
-        if (id == 0x0F43B675)  //Cluster ID
-            break;
-
-        if (id == 0x014D9B74)  //SeekHead ID
-        {
-            m_clusters = new Cluster*[m_clusterCount];   
-            size_t index = 0;
-            
-            ParseSeekHead(pos, size, &index);            
-            assert(index == m_clusterCount);
-        }            
-        else if (id == 0x0549A966)  //Segment Info ID
-        {
-            assert(m_pInfo == NULL);
-            m_pInfo = new  SegmentInfo(this, pos, size);
-            assert(m_pInfo);  //TODO
-        }
-        else if (id == 0x0654AE6B)  //Tracks ID
-        {
-            assert(m_pTracks == NULL);
-            m_pTracks = new Tracks(this, pos, size);
-            assert(m_pTracks);  //TODO
-        }
-
-        m_pos = pos + size;  //consume payload
-    }
-    
-    assert(m_clusters);
-    
-    //TODO: see notes above.  This check is here (temporarily) to ensure
-    //that the first seekhead has entries for the clusters (because that's
-    //when they're loaded).  In case we are given a file that lists the
-    //clusters in a second seekhead, the worst thing that happens is that
-    //we treat this as an invalid file (which is better then simply
-    //asserting somewhere).  But that's only a work-around.  What we need
-    //to do is be able to handle having multiple seekheads, and having
-    //clusters listed somewhere besides the first seekhead.
-    //    
-    //if (m_clusters == NULL)
-    //    return E_FILE_FORMAT_INVALID;
-        
-    //NOTE: we stop parsing when we reach the first cluster, under the
-    //assumption all clusters are named in some SeekHead.  Clusters
-    //will have been (pre)loaded, so we indicate that we have all clusters
-    //by adjusting the parse position:
-    m_pos = stop;  //means "we have all clusters"
-
-    return 0L;
-}
-
-
-void Segment::ParseSeekHead(long long start, long long size_, size_t* pIndex)
-{
-    long long pos = start;
-    const long long stop = start + size_;
-    while (pos < stop)
-    {
-        long len;
-        
-        const long long id = ReadUInt(m_pReader, pos, len);
-        assert(id >= 0);  //TODO
-        assert((pos + len) <= stop);
-        
-        pos += len;  //consume ID
-        
-        const long long size = ReadUInt(m_pReader, pos, len);
-        assert(size >= 0);
-        assert((pos + len) <= stop);
-        
-        pos += len;  //consume Size field
-        assert((pos + size) <= stop);
-
-        if (id == 0x0DBB)  //SeekEntry ID
-            ParseSeekEntry(pos, size, pIndex);
-        
-        pos += size;  //consume payload
-        assert(pos <= stop);
-    }
-    
-    assert(pos == stop);
-}
-
-
-void Segment::ParseSecondarySeekHead(long long off, size_t* pIndex)
-{
-    assert(off >= 0);
-    assert(off < m_size);
-
-    long long pos = m_start + off;
-    const long long stop = m_start + m_size;
-    
-    long len;
-
-    long long result = GetUIntLength(m_pReader, pos, len);
-    assert(result == 0);
-    assert((pos + len) <= stop);
-    
-    const long long idpos = pos;
-
-    const long long id = ReadUInt(m_pReader, idpos, len);
-    assert(id == 0x014D9B74);  //SeekHead ID
-    
-    pos += len;  //consume ID
-    assert(pos < stop);
-    
-    //Read Size
-    
-    result = GetUIntLength(m_pReader, pos, len);
-    assert(result == 0);
-    assert((pos + len) <= stop);
-    
-    const long long size = ReadUInt(m_pReader, pos, len);
-    assert(size >= 0);
-    
-    pos += len;  //consume length of size of element
-    assert((pos + size) <= stop);
-    
-    //Pos now points to start of payload
-    
-    ParseSeekHead(pos, size, pIndex);
-}
-
-
-void Segment::ParseSeekEntry(long long start, long long size_, size_t* pIndex)
-{
-    long long pos = start;
-
-    const long long stop = start + size_;
-    
-    long len;
-    
-    const long long seekIdId = ReadUInt(m_pReader, pos, len);
-    //seekIdId;
-    assert(seekIdId == 0x13AB);  //SeekID ID
-    assert((pos + len) <= stop);
-    
-    pos += len;  //consume id
-
-    const long long seekIdSize = ReadUInt(m_pReader, pos, len);
-    assert(seekIdSize >= 0);
-    assert((pos + len) <= stop);
-    
-    pos += len;  //consume size
-    
-    const long long seekId = ReadUInt(m_pReader, pos, len);  //payload
-    assert(seekId >= 0);
-    assert(len == seekIdSize);
-    assert((pos + len) <= stop);
-    
-    pos += seekIdSize;  //consume payload
-    
-    const long long seekPosId = ReadUInt(m_pReader, pos, len);
-    //seekPosId;
-    assert(seekPosId == 0x13AC);  //SeekPos ID
-    assert((pos + len) <= stop);
-    
-    pos += len;  //consume id
-    
-    const long long seekPosSize = ReadUInt(m_pReader, pos, len);
-    assert(seekPosSize >= 0);
-    assert((pos + len) <= stop);
-
-    pos += len;  //consume size
-    assert((pos + seekPosSize) <= stop);
-        
-    const long long seekOff = UnserializeUInt(m_pReader, pos, seekPosSize);
-    assert(seekOff >= 0);
-    assert(seekOff < m_size);
-    
-    pos += seekPosSize;  //consume payload
-    assert(pos == stop);
-    
-    const long long seekPos = m_start + seekOff;
-    assert(seekPos < (m_start + m_size));
-   
-    if (seekId == 0x0F43B675)  //cluster id
-    {       
-        if (pIndex == NULL)
-            ++m_clusterCount; 
-        else
-        {
-            assert(m_clusters);
-            assert(m_clusterCount > 0);
-            
-            size_t& index = *pIndex;
-            assert(index < m_clusterCount);
-            
-            Cluster*& pCluster = m_clusters[index];
-            
-            pCluster = Cluster::Parse(this, index, seekOff);
-            assert(pCluster);  //TODO
-            
-            ++index;
-        }
-    }
-    else if (seekId == 0x014D9B74)  //SeekHead ID
-    {
-        ParseSecondarySeekHead(seekOff, pIndex);
-    }
-}
-
-
-long long Segment::Unparsed() const
-{
-    const long long stop = m_start + m_size;
-
-    const long long result = stop - m_pos;
-    assert(result >= 0);
-    
-    return result;
-}
-
-
-#if 0  //NOTE: too inefficient
-long long Segment::Load(long long time_ns)
-{
-    if (Unparsed() <= 0)
-        return 0;
-    
-    while (m_clusters.empty())
-    {
-        const long long result = Parse();
-        
-        if (result)  //error, or not enough bytes available
-            return result;
-            
-        if (Unparsed() <= 0)
-            return 0;
-    }
-    
-    while (m_clusters.back()->GetTime() < time_ns)
-    {
-        const long long result = Parse();
-        
-        if (result)  //error, or not enough bytes available
-            return result;
-            
-        if (Unparsed() <= 0)
-            return 0;
-    }        
-
-    return 0;        
-}
-#endif
-
-
-Cluster* Segment::GetFirst()
-{
-    if ((m_clusters == NULL) || (m_clusterCount <= 0))
-       return &m_eos;
-
-    Cluster* const pCluster = m_clusters[0];
-    assert(pCluster);
-        
-    return pCluster;
-}
-
-
-Cluster* Segment::GetLast()
-{
-    if ((m_clusters == NULL) || (m_clusterCount <= 0))
-        return &m_eos;
-
-    const size_t idx = m_clusterCount - 1;    
-    Cluster* const pCluster = m_clusters[idx];
-    assert(pCluster);
-        
-    return pCluster;
-}
-
-
-unsigned long Segment::GetCount() const
-{
-    //TODO: m_clusterCount should not be long long.
-    return static_cast<unsigned long>(m_clusterCount);
-}
-
-
-Cluster* Segment::GetNext(const Cluster* pCurr)
-{
-    assert(pCurr);
-    assert(pCurr != &m_eos);
-    assert(m_clusters);
-    assert(m_clusterCount > 0);
-
-    size_t idx =  pCurr->m_index;
-    assert(idx < m_clusterCount);
-    assert(pCurr == m_clusters[idx]);
-    
-    idx++;
-    
-    if (idx >= m_clusterCount) 
-        return &m_eos;
-        
-    Cluster* const pNext = m_clusters[idx];
-    assert(pNext);
-    
-    return pNext;
-}
-
-
-Cluster* Segment::GetCluster(long long time_ns)
-{
-    if ((m_clusters == NULL) || (m_clusterCount <= 0))
-        return &m_eos;
-        
-    {
-        Cluster* const pCluster = m_clusters[0];
-        assert(pCluster);
-        assert(pCluster->m_index == 0);
-        
-        if (time_ns <= pCluster->GetTime())
-            return pCluster;
-    }
-    
-    //Binary search of cluster array
-       
-    size_t i = 0;
-    size_t j = m_clusterCount;
-    
-    while (i < j)
-    {
-        //INVARIANT:
-        //[0, i) <= time_ns
-        //[i, j) ?
-        //[j, m_clusterCount)  > time_ns
-        
-        const size_t k = i + (j - i) / 2;
-        assert(k < m_clusterCount);
-
-        Cluster* const pCluster = m_clusters[k];
-        assert(pCluster);
-        assert(pCluster->m_index == k);
-        
-        const long long t = pCluster->GetTime();
-        
-        if (t <= time_ns)
-            i = k + 1;
-        else
-            j = k;
-            
-        assert(i <= j);
-    }
-    
-    assert(i == j);
-    assert(i > 0);
-    assert(i <= m_clusterCount);
-    
-    const size_t k = i - 1;
-    
-    Cluster* const pCluster = m_clusters[k];
-    assert(pCluster);
-    assert(pCluster->m_index == k);
-    assert(pCluster->GetTime() <= time_ns);
-    
-    return pCluster;
-}
-
-
-Tracks* Segment::GetTracks() const
-{
-    return m_pTracks;
-}
-
-
-const SegmentInfo* const Segment::GetInfo() const
-{
-    return m_pInfo;
-}
-
-
-long long Segment::GetDuration() const
-{
-    assert(m_pInfo);
-    return m_pInfo->GetDuration();
-}
-
-
-SegmentInfo::SegmentInfo(Segment* pSegment, long long start, long long size_) :
-    m_pSegment(pSegment),
-    m_start(start),
-    m_size(size_),
-    m_pMuxingAppAsUTF8(NULL),
-    m_pWritingAppAsUTF8(NULL),
-    m_pTitleAsUTF8(NULL)
-{
-    IMkvReader* const pReader = m_pSegment->m_pReader;
-   
-    long long pos = start;
-    const long long stop = start + size_;
-    
-    m_timecodeScale = 1000000;
-    m_duration = 0;
-    
-    
-    while (pos < stop)
-    {
-        if (Match(pReader, pos, 0x0AD7B1, m_timecodeScale))
-            assert(m_timecodeScale > 0);
-
-        else if (Match(pReader, pos, 0x0489, m_duration))
-            assert(m_duration >= 0);
-
-        else if (Match(pReader, pos, 0x0D80, m_pMuxingAppAsUTF8))   //[4D][80] 
-            assert(m_pMuxingAppAsUTF8);
-
-        else if (Match(pReader, pos, 0x1741, m_pWritingAppAsUTF8))  //[57][41]
-            assert(m_pWritingAppAsUTF8);
-            
-        else if (Match(pReader, pos, 0x3BA9, m_pTitleAsUTF8))        //[7B][A9]
-            assert(m_pTitleAsUTF8);
-
-        else
-        {
-            long len;
-            
-            const long long id = ReadUInt(pReader, pos, len);
-            //id;
-            assert(id >= 0);
-            assert((pos + len) <= stop);
-            
-            pos += len;  //consume id
-            assert((stop - pos) > 0);
-            
-            const long long size = ReadUInt(pReader, pos, len);
-            assert(size >= 0);
-            assert((pos + len) <= stop);
-            
-            pos += len + size;  //consume size and payload
-            assert(pos <= stop);
-        }
-    }
-    
-    assert(pos == stop);
-}
-
-SegmentInfo::~SegmentInfo()
-{
-    if (m_pMuxingAppAsUTF8)
-    {
-        delete[] m_pMuxingAppAsUTF8;
-        m_pMuxingAppAsUTF8 = NULL;
-    }
-
-    if (m_pWritingAppAsUTF8)
-    {
-        delete[] m_pWritingAppAsUTF8;
-        m_pWritingAppAsUTF8 = NULL;
-    }
-   
-    if (m_pTitleAsUTF8)
-    {
-        delete[] m_pTitleAsUTF8;
-        m_pTitleAsUTF8 = NULL;
-    }
-}
-
-long long SegmentInfo::GetTimeCodeScale() const
-{
-    return m_timecodeScale;
-}
-
-
-long long SegmentInfo::GetDuration() const
-{
-    assert(m_duration >= 0);    
-    assert(m_timecodeScale >= 1);
-    
-    const double dd = double(m_duration) * double(m_timecodeScale);
-    const long long d = static_cast<long long>(dd);
-    
-    return d;
-}
-
-const char* SegmentInfo::GetMuxingAppAsUTF8() const
-{
-    return m_pMuxingAppAsUTF8;
-}
-
-const char* SegmentInfo::GetWritingAppAsUTF8() const
-{
-    return m_pWritingAppAsUTF8;
-}
-
-const char* SegmentInfo::GetTitleAsUTF8() const
-{
-    return m_pTitleAsUTF8;
-}
-
-Track::Track(Segment* pSegment, const Info& i) :
-    m_pSegment(pSegment),
-    m_info(i)
-{
-}
-
-Track::~Track()
-{
-    Info& info = const_cast<Info&>(m_info);
-    info.Clear();
-}
-
-Track::Info::Info():
-    type(-1),
-    number(-1),
-    uid(-1),
-    nameAsUTF8(NULL),
-    codecId(NULL),
-    codecPrivate(NULL),
-    codecPrivateSize(0),
-    codecNameAsUTF8(NULL)
-{
-}
-
-void Track::Info::Clear() 
-{
-    delete[] nameAsUTF8;
-    nameAsUTF8 = NULL;
-
-    delete[] codecId;
-    codecId = NULL;
-
-    delete[] codecPrivate;
-    codecPrivate = NULL;
-
-    delete[] codecNameAsUTF8;
-    codecNameAsUTF8 = NULL;
-}
-
-const BlockEntry* Track::GetEOS() const
-{
-    return &m_eos;
-}
-
-long long Track::GetType() const
-{
-    const unsigned long result = static_cast<unsigned long>(m_info.type);
-    return result;
-}
-
-unsigned long Track::GetNumber() const
-{
-    assert(m_info.number >= 0);
-    const unsigned long result = static_cast<unsigned long>(m_info.number);
-    return result;
-}
-
-const char* Track::GetNameAsUTF8() const
-{
-    return m_info.nameAsUTF8;
-}
-
-const char* Track::GetCodecNameAsUTF8() const
-{  
-    return m_info.codecNameAsUTF8;
-}
-
-
-const char* Track::GetCodecId() const
-{
-    return m_info.codecId;
-}
-
-
-const unsigned char* Track::GetCodecPrivate(size_t *optionalSize) const
-{
-    if (optionalSize) {
-        *optionalSize = m_info.codecPrivateSize;
-    }
-    return m_info.codecPrivate;
-}
-
-
-long Track::GetFirst(const BlockEntry*& pBlockEntry) const
-{
-    Cluster* const pCluster = m_pSegment->GetFirst();
-    
-    //If Segment::GetFirst returns NULL, then this must be a network 
-    //download, and we haven't loaded any clusters yet.  In this case,
-    //returning NULL from Track::GetFirst means the same thing.
-
-    if ((pCluster == NULL) || pCluster->EOS())
-    {
-        pBlockEntry = NULL;
-        return E_BUFFER_NOT_FULL;  //return 1L instead?
-    }
-        
-    pBlockEntry = pCluster->GetFirst();
-    
-    while (pBlockEntry)
-    {
-        const Block* const pBlock = pBlockEntry->GetBlock();
-        assert(pBlock);
-        
-        if (pBlock->GetTrackNumber() == (unsigned long)m_info.number)
-            return 0L;
-            
-        pBlockEntry = pCluster->GetNext(pBlockEntry);
-    }
-    
-    //NOTE: if we get here, it means that we didn't find a block with
-    //a matching track number.  We interpret that as an error (which
-    //might be too conservative).
-
-    pBlockEntry = GetEOS();  //so we can return a non-NULL value
-    return 1L;
-}
-
-
-long Track::GetNext(const BlockEntry* pCurrEntry, const BlockEntry*& pNextEntry) const
-{
-    assert(pCurrEntry);
-    assert(!pCurrEntry->EOS());  //?
-    assert(pCurrEntry->GetBlock()->GetTrackNumber() == (unsigned long)m_info.number);    
-    
-    const Cluster* const pCurrCluster = pCurrEntry->GetCluster();
-    assert(pCurrCluster);
-    assert(!pCurrCluster->EOS());
-    
-    pNextEntry = pCurrCluster->GetNext(pCurrEntry);
-            
-    while (pNextEntry)
-    {    
-        const Block* const pNextBlock = pNextEntry->GetBlock();
-        assert(pNextBlock);
-    
-        if (pNextBlock->GetTrackNumber() == (unsigned long)m_info.number)
-            return 0L;
-            
-        pNextEntry = pCurrCluster->GetNext(pNextEntry);
-    }
-
-    Segment* pSegment = pCurrCluster->m_pSegment;    
-    Cluster* const pNextCluster = pSegment->GetNext(pCurrCluster);
-    
-    if ((pNextCluster == NULL) || pNextCluster->EOS())
-    {
-        if (pSegment->Unparsed() <= 0)   //all clusters have been loaded
-        {
-            pNextEntry = GetEOS();
-            return 1L;
-        }
-        
-        pNextEntry = NULL;
-        return E_BUFFER_NOT_FULL;
-    }
-        
-    pNextEntry = pNextCluster->GetFirst();
-    
-    while (pNextEntry)
-    {
-        const Block* const pNextBlock = pNextEntry->GetBlock();
-        assert(pNextBlock);
-        
-        if (pNextBlock->GetTrackNumber() == (unsigned long)m_info.number)
-            return 0L;
-            
-        pNextEntry = pNextCluster->GetNext(pNextEntry);
-    }
-    
-    //TODO: what has happened here is that we did not find a block
-    //with a matching track number on the next cluster.  It might
-    //be the case that some cluster beyond the next cluster 
-    //contains a block having a matching track number, but for
-    //now we terminate the search immediately.  We do this so that
-    //we don't end up searching the entire file looking for the
-    //next block.  Another possibility is to try searching for the next
-    //block in a small, fixed number of clusters (intead searching
-    //just the next one), or to terminate the search when when the
-    //there is a large gap in time, or large gap in file position.  It
-    //might very well be the case that the approach we use here is
-    //unnecessarily conservative.
-    
-    //TODO: again, here's a case where we need to return the special
-    //EOS block.  Or something.  It's OK if pNext is NULL, because
-    //we only need it to set the stop time of the media sample.
-    //(The start time is determined from pCurr, which is non-NULL
-    //and non-EOS.)  The problem is when we set pCurr=pNext; when
-    //pCurr has the value NULL we interpret that to mean that we
-    //haven't fully initialized pCurr and we attempt to set it to
-    //point to the first block for this track.  But that's not what
-    //we want at all; we want the next call to PopulateSample to
-    //return end-of-stream, not (re)start from the beginning.
-    //
-    //One work-around is to send EOS immediately.  We would send 
-    //the EOS the next pass anyway, so maybe it's no great loss.  The 
-    //only problem is that if this the stream really does end one
-    //cluster early (relative to other tracks), or the last frame
-    //happens to be a keyframe ("CanSeekToEnd").
-    //
-    //The problem is that we need a way to mark as stream as
-    //"at end of stream" without actually being at end of stream.
-    //We need to give pCurr some value that means "you've reached EOS".
-    //We can't synthesize the special EOS Cluster immediately
-    //(when we first open the file, say), because we use the existance
-    //of that special cluster value to mean that we've read all of 
-    //the clusters (this is a network download, so we can't know apriori
-    //how many we have).
-    //
-    //Or, we could return E_FAIL, and set another bit in the stream
-    //object itself, to indicate that it should send EOS earlier
-    //than when (pCurr=pStop).
-    //
-    //Or, probably the best solution, when we actually load the 
-    //blocks into a cluster: if we notice that there's no block
-    //for a track, we synthesize a nonce EOS block for that track.
-    //That way we always have something to return.  But that will
-    //only work for sequential scan???
-
-    //pNext = NULL;    
-    //return E_FAIL;
-    pNextEntry = GetEOS();
-    return 1L;
-}
-
-
-Track::EOSBlock::EOSBlock()
-{
-}
-
-
-bool Track::EOSBlock::EOS() const
-{
-    return true;
-}
-
-
-Cluster* Track::EOSBlock::GetCluster() const
-{
-    return NULL;
-}
-
-
-size_t Track::EOSBlock::GetIndex() const
-{
-    return 0;
-}
-
-
-const Block* Track::EOSBlock::GetBlock() const
-{
-    return NULL;
-}
-
-
-bool Track::EOSBlock::IsBFrame() const
-{
-    return false;
-}
-
-
-VideoTrack::VideoTrack(Segment* pSegment, const Info& i) :
-    Track(pSegment, i),
-    m_width(-1),
-    m_height(-1),
-    m_rate(-1)
-{
-    assert(i.type == 1);
-    assert(i.number > 0);
-    
-    IMkvReader* const pReader = pSegment->m_pReader;
-    
-    const Settings& s = i.settings;
-    assert(s.start >= 0);
-    assert(s.size >= 0);
-    
-    long long pos = s.start;
-    assert(pos >= 0);
-    
-    const long long stop = pos + s.size;
-    
-    while (pos < stop)
-    {
-#ifdef _DEBUG
-        long len;
-        const long long id = ReadUInt(pReader, pos, len);
-        assert(id >= 0);  //TODO: handle error case
-        assert((pos + len) <= stop);
-#endif
-        if (Match(pReader, pos, 0x30, m_width))         
-            ;
-        else if (Match(pReader, pos, 0x3A, m_height))   
-            ;
-        else if (Match(pReader, pos, 0x0383E3, m_rate)) 
-            ;
-        else
-        {
-            long len;
-            const long long id = ReadUInt(pReader, pos, len);
-            assert(id >= 0);  //TODO: handle error case
-            assert((pos + len) <= stop);
-        
-            pos += len;  //consume id
-            
-            const long long size = ReadUInt(pReader, pos, len);
-            assert(size >= 0);  //TODO: handle error case
-            assert((pos + len) <= stop);
-            
-            pos += len;  //consume length of size
-            assert((pos + size) <= stop);
-            
-            //pos now designates start of payload
-            
-            pos += size;  //consume payload
-            assert(pos <= stop);
-        }
-    }
-    
-    return;
-}
-
-
-bool VideoTrack::VetEntry(const BlockEntry* pBlockEntry) const
-{
-    assert(pBlockEntry);
-    
-    const Block* const pBlock = pBlockEntry->GetBlock();
-    assert(pBlock);    
-    assert(pBlock->GetTrackNumber() == (unsigned long)m_info.number);
-    
-    return pBlock->IsKey();
-}
-
-
-
-long long VideoTrack::GetWidth() const
-{
-    return m_width;
-}
-
-
-long long VideoTrack::GetHeight() const
-{
-    return m_height;
-}
-
-
-double VideoTrack::GetFrameRate() const
-{
-    return m_rate;
-}
-
-
-AudioTrack::AudioTrack(Segment* pSegment, const Info& i) :
-    Track(pSegment, i)
-{
-    assert(i.type == 2);
-    assert(i.number > 0);
-
-    IMkvReader* const pReader = pSegment->m_pReader;
-    
-    const Settings& s = i.settings;
-    assert(s.start >= 0);
-    assert(s.size >= 0);
-    
-    long long pos = s.start;
-    assert(pos >= 0);
-    
-    const long long stop = pos + s.size;
-    
-    while (pos < stop)
-    {
-#ifdef _DEBUG
-        long len;
-        const long long id = ReadUInt(pReader, pos, len);
-        assert(id >= 0);  //TODO: handle error case
-        assert((pos + len) <= stop);
-#endif
-        if (Match(pReader, pos, 0x35, m_rate))            
-            ;
-        else if (Match(pReader, pos, 0x1F, m_channels))   
-            ;
-        else if (Match(pReader, pos, 0x2264, m_bitDepth))  
-            ;            
-        else
-        {
-            long len;
-            const long long id = ReadUInt(pReader, pos, len);
-            assert(id >= 0);  //TODO: handle error case
-            assert((pos + len) <= stop);
-        
-            pos += len;  //consume id
-            
-            const long long size = ReadUInt(pReader, pos, len);
-            assert(size >= 0);  //TODO: handle error case
-            assert((pos + len) <= stop);
-            
-            pos += len;  //consume length of size
-            assert((pos + size) <= stop);
-            
-            //pos now designates start of payload
-            
-            pos += size;  //consume payload
-            assert(pos <= stop);
-        }
-    }
-
-    return;
-}
-
-bool AudioTrack::VetEntry(const BlockEntry* pBlockEntry) const
-{
-    assert(pBlockEntry);
-    
-    const Block* const pBlock = pBlockEntry->GetBlock();
-    assert(pBlock);
-    assert(pBlock->GetTrackNumber() == (unsigned long)m_info.number);
-
-    return true;
-}
-
-
-double AudioTrack::GetSamplingRate() const
-{
-    return m_rate;
-}
-
-
-long long AudioTrack::GetChannels() const
-{
-    return m_channels;
-}
-
-long long AudioTrack::GetBitDepth() const
-{
-    return m_bitDepth;
-}
-
-Tracks::Tracks(Segment* pSegment, long long start, long long size_) :
-    m_pSegment(pSegment),
-    m_start(start),
-    m_size(size_),
-    m_trackEntries(NULL),
-    m_trackEntriesEnd(NULL)
-{
-    long long stop = m_start + m_size;
-    IMkvReader* const pReader = m_pSegment->m_pReader;
-    
-    long long pos1 = m_start;
-    int count = 0;
-    
-    while (pos1 < stop)
-    {
-        long len;
-        const long long id = ReadUInt(pReader, pos1, len);
-        assert(id >= 0);
-        assert((pos1 + len) <= stop);
-        
-        pos1 += len;  //consume id
-        
-        const long long size = ReadUInt(pReader, pos1, len);
-        assert(size >= 0);
-        assert((pos1 + len) <= stop);
-        
-        pos1 += len;  //consume length of size
-        
-        //pos now desinates start of element
-        if (id == 0x2E)  //TrackEntry ID
-            ++count;
-            
-        pos1 += size;  //consume payload
-        assert(pos1 <= stop);
-    }    
-
-    if (count <= 0)
-        return;
-
-    m_trackEntries = new Track*[count];
-    m_trackEntriesEnd = m_trackEntries;
-
-    long long pos = m_start;
-
-    while (pos < stop)
-    {
-        long len;
-        const long long id = ReadUInt(pReader, pos, len);
-        assert(id >= 0);
-        assert((pos + len) <= stop);
-        
-        pos += len;  //consume id
-        
-        const long long size1 = ReadUInt(pReader, pos, len);
-        assert(size1 >= 0);
-        assert((pos + len) <= stop);
-        
-        pos += len;  //consume length of size
-        
-        //pos now desinates start of element
-        
-        if (id == 0x2E)  //TrackEntry ID
-            ParseTrackEntry(pos, size1, *m_trackEntriesEnd++);
-            
-        pos += size1;  //consume payload
-        assert(pos <= stop);
-    }    
-}
-
-unsigned long Tracks::GetTracksCount() const
-{
-    const ptrdiff_t result = m_trackEntriesEnd - m_trackEntries;
-    assert(result >= 0);
-    
-    return static_cast<unsigned long>(result);
-}
-
-
-void Tracks::ParseTrackEntry(
-    long long start,
-    long long size,
-    Track*& pTrack)
-{
-    IMkvReader* const pReader = m_pSegment->m_pReader;
-    
-    long long pos = start;
-    const long long stop = start + size;
-
-    Track::Info i;
-    
-    Track::Settings videoSettings;
-    videoSettings.start = -1;
-    
-    Track::Settings audioSettings;
-    audioSettings.start = -1;
-    
-    while (pos < stop)
-    {
-#ifdef _DEBUG
-        long len;
-        const long long id = ReadUInt(pReader, pos, len);
-        len;
-        id;
-#endif
-        if (Match(pReader, pos, 0x57, i.number))
-            assert(i.number > 0);
-
-        else if (Match(pReader, pos, 0x33C5, i.uid))           
-            ;  
-
-        else if (Match(pReader, pos, 0x03, i.type))            
-            ;  
-
-        else if (Match(pReader, pos, 0x136E, i.nameAsUTF8))          
-            assert(i.nameAsUTF8);  
-
-        else if (Match(pReader, pos, 0x06, i.codecId))         
-            ;  
-
-        else if (Match(pReader, pos, 0x23A2, i.codecPrivate, &i.codecPrivateSize))  
-            ;  
-
-        else if (Match(pReader, pos, 0x058688, i.codecNameAsUTF8))   
-            assert(i.codecNameAsUTF8);  
-
-        else
-        {
-            long len;
-            
-            const long long id = ReadUInt(pReader, pos, len);
-            assert(id >= 0);  //TODO: handle error case
-            assert((pos + len) <= stop);
-            
-            pos += len;  //consume id
-            
-            const long long size = ReadUInt(pReader, pos, len);
-            assert(size >= 0);  //TODO: handle error case
-            assert((pos + len) <= stop);
-            
-            pos += len;  //consume length of size
-            const long long start = pos;
-            
-            pos += size;  //consume payload
-            assert(pos <= stop);
-            
-            if (id == 0x60)
-            {
-                videoSettings.start = start;
-                videoSettings.size = size;
-            }
-            else if (id == 0x61)
-            {
-                audioSettings.start = start;
-                audioSettings.size = size;
-            }
-        }
-    }
-    
-    assert(pos == stop);
-    //TODO: propertly vet info.number, to ensure both its existence,
-    //and that it is unique among all tracks.
-    assert(i.number > 0);
-
-    //TODO: vet settings, to ensure that video settings (0x60)
-    //were specified when type = 1, and that audio settings (0x61)
-    //were specified when type = 2.    
-    if (i.type == 1)  //video
-    {
-        assert(audioSettings.start < 0);
-        assert(videoSettings.start >= 0);
-        
-        i.settings = videoSettings;
-        
-        VideoTrack* const t = new VideoTrack(m_pSegment, i);
-        assert(t);  //TODO
-        pTrack = t;    
-    }
-    else if (i.type == 2)  //audio
-    {
-        assert(videoSettings.start < 0);
-        assert(audioSettings.start >= 0);
-        
-        i.settings = audioSettings;
-        
-        AudioTrack* const t = new  AudioTrack(m_pSegment, i);
-        assert(t);  //TODO
-        pTrack = t;  
-    }
-    else
-    {
-        // for now we do not support other track types yet.
-        // TODO: support other track types
-        i.Clear();
-  
-        pTrack = NULL;
-    }
-    
-    return;
-}
-
-
-Tracks::~Tracks()
-{
-    Track** i = m_trackEntries;
-    Track** const j = m_trackEntriesEnd;
-    
-    while (i != j)
-    {
-        Track* pTrack = *i++;
-        delete pTrack;
-        pTrack = NULL;    
-    }
-
-    delete[] m_trackEntries;
-}
-
-
-Track* Tracks::GetTrackByNumber(unsigned long tn) const
-{
-    Track** i = m_trackEntries;
-    Track** const j = m_trackEntriesEnd;
-
-    while (i != j)
-    {
-        Track* const pTrack = *i++;
-       
-        if (pTrack == NULL)
-            continue;
-
-        if (tn == pTrack->GetNumber())
-            return pTrack;
-    }
-
-    return NULL;  //not found
-}
-
-
-Track* Tracks::GetTrackByIndex(unsigned long idx) const
-{
-    const ptrdiff_t count = m_trackEntriesEnd - m_trackEntries;
-       
-    if (idx >= static_cast<unsigned long>(count))
-         return NULL;
-
-    return m_trackEntries[idx];
-}
-
-
-void Cluster::Load()
-{
-    assert(m_pSegment);
-    
-    if (m_start > 0)
-    {
-        assert(m_size > 0);
-        assert(m_timecode >= 0);
-        return;
-    }
-    
-    assert(m_size == 0);
-    assert(m_timecode < 0);
-    
-    IMkvReader* const pReader = m_pSegment->m_pReader;
-
-    const long long off = -m_start;  //relative to segment
-    long long pos = m_pSegment->m_start + off;  //absolute
-    
-    long len;
-
-    const long long id_ = ReadUInt(pReader, pos, len);
-    assert(id_ >= 0);
-    assert(id_ == 0x0F43B675);  //Cluster ID
-    
-    pos += len;  //consume id
-    
-    const long long size_ = ReadUInt(pReader, pos, len);
-    assert(size_ >= 0);
-    
-    pos += len;  //consume size
-    
-    m_start = pos;
-    m_size = size_;
-    
-    const long long stop = m_start + size_;
-    
-    long long timecode = -1;
-    
-    while (pos < stop)
-    {
-        if (Match(pReader, pos, 0x67, timecode))
-            break;            
-        else
-        {
-            const long long id = ReadUInt(pReader, pos, len);
-            assert(id >= 0);  //TODO
-            assert((pos + len) <= stop);
-            
-            pos += len;  //consume id
-            
-            const long long size = ReadUInt(pReader, pos, len);
-            assert(size >= 0);  //TODO
-            assert((pos + len) <= stop);
-            
-            pos += len;  //consume size
-            
-            if (id == 0x20)  //BlockGroup ID
-                break;
-                
-            if (id == 0x23)  //SimpleBlock ID
-                break;
-
-            pos += size;  //consume payload
-            assert(pos <= stop);
-        }
-    }
-    
-    assert(pos <= stop);
-    assert(timecode >= 0);
-    
-    m_timecode = timecode;
-}
-
-
-Cluster* Cluster::Parse(
-    Segment* pSegment,
-    size_t idx,
-    long long off)
-{
-    assert(pSegment);
-    assert(off >= 0);
-    assert(off < pSegment->m_size);
-    Cluster* const pCluster = new Cluster(pSegment, idx, -off);
-    assert(pCluster);
-    
-    return pCluster;
-}
-
-
-Cluster::Cluster() :
-    m_pSegment(NULL),
-    m_index(0),
-    m_start(0),
-    m_size(0),
-    m_timecode(0),
-    m_pEntries(NULL),
-    m_entriesCount(0)
-{
-}
-
-Cluster::Cluster(
-    Segment* pSegment,
-    size_t idx,
-    long long off) :
-    m_pSegment(pSegment),
-    m_index(idx),
-    m_start(off),
-    m_size(0),
-    m_timecode(-1),
-    m_pEntries(NULL),
-    m_entriesCount(0)
-{
-}
-
-
-Cluster::~Cluster()
-{
-#if 0
-    while (!m_pEntries.empty())
-    {
-        BlockEntry* pBlockEntry = m_pEntries.front();
-        assert(pBlockEntry);
-        
-        m_pEntries.pop_front();
-        delete pBlockEntry;
-    }
-#else
-    BlockEntry** i = m_pEntries;
-    BlockEntry** const j = m_pEntries + m_entriesCount;
-    while (i != j)
-    {
-         BlockEntry* p = *i++;
-   
-         assert(p);
-         delete p;
-    }
- 
-    delete[] m_pEntries;
-#endif
-
-}
-
-bool Cluster::EOS() const
-{
-    return (m_pSegment == 0);
-}
-
-
-void Cluster::LoadBlockEntries()
-{
-    if (m_pEntries)
-        return;
-
-    Load();    
-    assert(m_timecode >= 0);
-    assert(m_start > 0);
-    assert(m_size > 0);
-    
-    IMkvReader* const pReader = m_pSegment->m_pReader;
-    
-    long long pos = m_start;
-    const long long stop = m_start + m_size;
-    long long timecode = -1;
-   
-    long long idx = pos;
-
-    m_entriesCount = 0;
-    
-    while (idx < stop)
-    {
-        if (Match(pReader, idx, 0x67, timecode))
-            assert(timecode == m_timecode);
-        else 
-        {
-            long len;
-            
-            const long long id = ReadUInt(pReader, idx, len);
-            assert(id >= 0);  //TODO
-            assert((idx + len) <= stop);
-            
-            idx += len;  //consume id
-            
-            const long long size = ReadUInt(pReader, idx, len);
-            assert(size >= 0);  //TODO
-            assert((idx + len) <= stop);
-            
-            idx += len;  //consume size
-            
-            if (id == 0x20)  //BlockGroup ID
-                ++m_entriesCount;
-            else if (id == 0x23)  //SimpleBlock ID
-                ++m_entriesCount;
-
-            idx += size;  //consume payload
-
-            assert(idx <= stop);
-        }  
-    }
-
-    if (m_entriesCount == 0)
-        return;
-     
-    m_pEntries = new BlockEntry*[m_entriesCount];
-    size_t index = 0;
-    
-    while (pos < stop)
-    {
-        if (Match(pReader, pos, 0x67, timecode))
-            assert(timecode == m_timecode);
-        else
-        {
-            long len;
-            const long long id = ReadUInt(pReader, pos, len);
-            assert(id >= 0);  //TODO
-            assert((pos + len) <= stop);
-            
-            pos += len;  //consume id
-            
-            const long long size = ReadUInt(pReader, pos, len);
-            assert(size >= 0);  //TODO
-            assert((pos + len) <= stop);
-            
-            pos += len;  //consume size
-            
-            if (id == 0x20)  //BlockGroup ID
-                ParseBlockGroup(pos, size, index++);
-            else if (id == 0x23)  //SimpleBlock ID
-                ParseSimpleBlock(pos, size, index++);
-
-            pos += size;  //consume payload
-            assert(pos <= stop);
-        }
-    }
-    
-    assert(pos == stop);
-    assert(timecode >= 0);
-    assert(index == m_entriesCount);
-}
-
-
-
-long long Cluster::GetTimeCode()
-{
-    Load();
-    return m_timecode;
-}
-
-
-long long Cluster::GetTime()
-{
-    const long long tc = GetTimeCode();
-    assert(tc >= 0);
-    
-    const SegmentInfo* const pInfo = m_pSegment->GetInfo();
-    assert(pInfo);
-    
-    const long long scale = pInfo->GetTimeCodeScale();
-    assert(scale >= 1);
-    
-    const long long t = m_timecode * scale;
-
-    return t;
-}
-
-
-void Cluster::ParseBlockGroup(long long start, long long size, size_t index)
-{
-    assert(m_pEntries);
-    assert(m_entriesCount);
-    assert(index < m_entriesCount);
-    
-    BlockGroup* const pGroup = new BlockGroup(this, index, start, size);
-    assert(pGroup);  //TODO
-        
-    m_pEntries[index] = pGroup;
-}
-
-
-
-void Cluster::ParseSimpleBlock(long long start, long long size, size_t index)
-{
-    assert(m_pEntries);
-    assert(m_entriesCount);
-    assert(index < m_entriesCount);
-
-    SimpleBlock* const pSimpleBlock = new SimpleBlock(this, index, start, size);
-    assert(pSimpleBlock);  //TODO
-        
-    m_pEntries[index] = pSimpleBlock;
-}
-
-
-const BlockEntry* Cluster::GetFirst()
-{
-    LoadBlockEntries();
-    
-    return m_pEntries[0];
-}
-
-        
-const BlockEntry* Cluster::GetLast()
-{ 
-    if (m_entriesCount == 0)
-        return m_pEntries[0];
-    
-    return m_pEntries[m_entriesCount-1];
-}
-
-        
-const BlockEntry* Cluster::GetNext(const BlockEntry* pEntry) const
-{
-    assert(pEntry);
-    
-    size_t idx = pEntry->GetIndex();
-    
-    ++idx;
-
-    if (idx == m_entriesCount) 
-      return NULL;
-
-    return m_pEntries[idx];
-
-}
-
-
-const BlockEntry* Cluster::GetEntry(const Track* pTrack)
-{
-
-    assert(pTrack);
-    
-    if (m_pSegment == NULL)  //EOS
-        return pTrack->GetEOS();
-    
-    LoadBlockEntries();
-    
-    BlockEntry* i = *m_pEntries;
-    BlockEntry* j = *m_pEntries + m_entriesCount;
-    while (i != j)
-    {
-        BlockEntry* pEntry = i;
-        i++;
-        assert(pEntry);
-        assert(!pEntry->EOS());
-        
-        const Block* const pBlock = pEntry->GetBlock();
-        assert(pBlock);
-        
-        if (pBlock->GetTrackNumber() != pTrack->GetNumber())
-            continue;
-
-        if (pTrack->VetEntry(pEntry))
-            return pEntry;
-    }
-    
-    return pTrack->GetEOS();  //no satisfactory block found
-}
-
-
-BlockEntry::BlockEntry()
-{
-}
-
-
-BlockEntry::~BlockEntry()
-{
-}
-
-
-
-SimpleBlock::SimpleBlock(
-    Cluster* pCluster, 
-    size_t idx, 
-    long long start, 
-    long long size) :
-    m_pCluster(pCluster),
-    m_index(idx),
-    m_block(start, size, pCluster->m_pSegment->m_pReader)
-{
-}
-
-
-bool SimpleBlock::EOS() const
-{
-    return false;
-}
-
-
-Cluster* SimpleBlock::GetCluster() const
-{
-    return m_pCluster;
-}
-
-
-size_t SimpleBlock::GetIndex() const
-{
-    return m_index;
-}
-
-
-const Block* SimpleBlock::GetBlock() const
-{
-    return &m_block;
-}
-
-
-bool SimpleBlock::IsBFrame() const
-{
-    return false;
-}
-
-
-BlockGroup::BlockGroup(
-    Cluster* pCluster, 
-    size_t idx, 
-    long long start, 
-    long long size_) :
-    m_pCluster(pCluster),
-    m_index(idx),
-    m_prevTimeCode(0),
-    m_nextTimeCode(0),
-    m_pBlock(NULL)  //TODO: accept multiple blocks within a block group
-{
-    IMkvReader* const pReader = m_pCluster->m_pSegment->m_pReader;
-    
-    long long pos = start;
-    const long long stop = start + size_;
- 
-    bool bSimpleBlock = false;
-    
-    while (pos < stop)
-    {
-        short t;
-    
-        if (Match(pReader, pos, 0x7B, t))
-        {    
-            if (t < 0)
-                m_prevTimeCode = t;
-            else if (t > 0)
-                m_nextTimeCode = t;
-            else
-                assert(false);
-        }
-        else
-        {
-            long len;
-            const long long id = ReadUInt(pReader, pos, len);
-            assert(id >= 0);  //TODO
-            assert((pos + len) <= stop);
-            
-            pos += len;  //consume ID
-            
-            const long long size = ReadUInt(pReader, pos, len);
-            assert(size >= 0);  //TODO
-            assert((pos + len) <= stop);
-            
-            pos += len;  //consume size
-            
-            switch (id)
-            {
-                case 0x23:  //SimpleBlock ID
-                    bSimpleBlock = true;
-                    //YES, FALL THROUGH TO NEXT CASE
-
-                case 0x21:  //Block ID
-                    ParseBlock(pos, size);                    
-                    break;
-                    
-                default:
-                    break;
-            }
-                
-            pos += size;  //consume payload
-            assert(pos <= stop);
-        }
-    }
-    
-    assert(pos == stop);
-    assert(m_pBlock);
-    
-    if (!bSimpleBlock)
-        m_pBlock->SetKey(m_prevTimeCode >= 0);
-}
-
-
-BlockGroup::~BlockGroup()
-{
-    delete m_pBlock;
-}
-
-
-void BlockGroup::ParseBlock(long long start, long long size)
-{   
-    IMkvReader* const pReader = m_pCluster->m_pSegment->m_pReader;
-    
-    Block* const pBlock = new Block(start, size, pReader);
-    assert(pBlock);  //TODO
-
-    //TODO: the Matroska spec says you have multiple blocks within the 
-    //same block group, with blocks ranked by priority (the flag bits).
-    //I haven't ever seen such a file (mkvmux certainly doesn't make
-    //one), so until then I'll just assume block groups contain a single
-    //block.
-#if 0    
-    m_blocks.push_back(pBlock);
-#else
-    assert(m_pBlock == NULL);
-    m_pBlock = pBlock;
-#endif
-
-#if 0
-    Track* const pTrack = pBlock->GetTrack();
-    assert(pTrack);
-    
-    pTrack->Insert(pBlock);
-#endif
-}
-
-
-bool BlockGroup::EOS() const
-{
-    return false;
-}
-
-
-Cluster* BlockGroup::GetCluster() const
-{
-    return m_pCluster;
-}
-
-
-size_t BlockGroup::GetIndex() const
-{
-    return m_index;
-}
-
-
-const Block* BlockGroup::GetBlock() const
-{
-    return m_pBlock;
-}
-
-
-short BlockGroup::GetPrevTimeCode() const
-{
-    return m_prevTimeCode;
-}
-
-
-short BlockGroup::GetNextTimeCode() const
-{
-    return m_nextTimeCode;
-}    
-
-
-bool BlockGroup::IsBFrame() const
-{
-    return (m_nextTimeCode > 0);
-}
-
-
-
-Block::Block(long long start, long long size_, IMkvReader* pReader) :
-    m_start(start),
-    m_size(size_)
-{
-    long long pos = start;
-    const long long stop = start + size_;
-
-    long len;
-    
-    m_track = ReadUInt(pReader, pos, len);
-    assert(m_track > 0);
-    assert((pos + len) <= stop);
-    
-    pos += len;  //consume track number
-    assert((stop - pos) >= 2);
-    
-    m_timecode = Unserialize2SInt(pReader, pos);
-
-    pos += 2;
-    assert((stop - pos) >= 1);
-    
-    const long hr = pReader->Read(pos, 1, &m_flags);
-    assert(hr == 0L);
-
-    ++pos;
-    assert(pos <= stop);
-    
-    m_frameOff = pos;
-    
-    const long long frame_size = stop - pos;
-
-    assert(frame_size <= 2147483647L);
-    
-    m_frameSize = static_cast<long>(frame_size);
-}
-
-
-long long Block::GetTimeCode(Cluster* pCluster) const
-{
-    assert(pCluster);
-    
-    const long long tc0 = pCluster->GetTimeCode();
-    assert(tc0 >= 0);
-    
-    const long long tc = tc0 + static_cast<long long>(m_timecode);
-    assert(tc >= 0);
-    
-    return tc;  //unscaled timecode units
-}
-
-
-long long Block::GetTime(Cluster* pCluster) const
-{
-    assert(pCluster);
-    
-    const long long tc = GetTimeCode(pCluster);
-    
-    const Segment* const pSegment = pCluster->m_pSegment;
-    const SegmentInfo* const pInfo = pSegment->GetInfo();
-    assert(pInfo);
-    
-    const long long scale = pInfo->GetTimeCodeScale();
-    assert(scale >= 1);
-    
-    const long long ns = tc * scale;
-
-    return ns;
-}
-
-
-unsigned long Block::GetTrackNumber() const
-{
-    assert(m_track > 0);
-    
-    return static_cast<unsigned long>(m_track);
-}
-
-
-bool Block::IsKey() const
-{
-    return ((m_flags & static_cast<unsigned char>(1 << 7)) != 0);
-}
-
-
-void Block::SetKey(bool bKey)
-{
-    if (bKey)
-        m_flags |= static_cast<unsigned char>(1 << 7);
-    else
-        m_flags &= 0x7F;
-}
-
-
-long Block::GetSize() const
-{
-    return m_frameSize;
-}
-
-
-long Block::Read(IMkvReader* pReader, unsigned char* buf) const
-{
-
-    assert(pReader);
-    assert(buf);
-    
-    const long hr = pReader->Read(m_frameOff, m_frameSize, buf);
-    
-    return hr;
-}
-
-
-}  //end namespace mkvparser
+// Copyright (c) 2010 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+
+#include "mkvparser.hpp"
+#include <cassert>
+#include <cstring>
+#include <new>
+//#include <windows.h>
+//#include "odbgstream.hpp"
+//using std::endl;
+
+mkvparser::IMkvReader::~IMkvReader()
+{
+}
+
+
+void mkvparser::GetVersion(int& major, int& minor, int& build, int& revision)
+{
+    major = 1;
+    minor = 0;
+    build = 0;
+    revision = 4;
+}
+
+
+long long mkvparser::ReadUInt(IMkvReader* pReader, long long pos, long& len)
+{
+    assert(pReader);
+    assert(pos >= 0);
+
+    long long total, available;
+
+    long hr = pReader->Length(&total, &available);
+    assert(hr >= 0);
+    assert(pos < available);
+    assert((available - pos) >= 1);  //assume here max u-int len is 8
+
+    unsigned char b;
+
+    hr = pReader->Read(pos, 1, &b);
+    if (hr < 0)
+        return hr;
+
+    assert(hr == 0L);
+
+    if (b & 0x80)       //1000 0000
+    {
+        len = 1;
+        b &= 0x7F;      //0111 1111
+    }
+    else if (b & 0x40)  //0100 0000
+    {
+        len = 2;
+        b &= 0x3F;      //0011 1111
+    }
+    else if (b & 0x20)  //0010 0000
+    {
+        len = 3;
+        b &= 0x1F;      //0001 1111
+    }
+    else if (b & 0x10)  //0001 0000
+    {
+        len = 4;
+        b &= 0x0F;      //0000 1111
+    }
+    else if (b & 0x08)  //0000 1000
+    {
+        len = 5;
+        b &= 0x07;      //0000 0111
+    }
+    else if (b & 0x04)  //0000 0100
+    {
+        len = 6;
+        b &= 0x03;      //0000 0011
+    }
+    else if (b & 0x02)  //0000 0010
+    {
+        len = 7;
+        b &= 0x01;      //0000 0001
+    }
+    else
+    {
+        assert(b & 0x01);  //0000 0001
+        len = 8;
+        b = 0;             //0000 0000
+    }
+
+    assert((available - pos) >= len);
+
+    long long result = b;
+    ++pos;
+    for (long i = 1; i < len; ++i)
+    {
+        hr = pReader->Read(pos, 1, &b);
+
+        if (hr < 0)
+            return hr;
+
+        assert(hr == 0L);
+
+        result <<= 8;
+        result |= b;
+
+        ++pos;
+    }
+
+    return result;
+}
+
+
+long long mkvparser::GetUIntLength(
+    IMkvReader* pReader,
+    long long pos,
+    long& len)
+{
+    assert(pReader);
+    assert(pos >= 0);
+
+    long long total, available;
+
+    long hr = pReader->Length(&total, &available);
+    assert(hr >= 0);
+    assert(available <= total);
+
+    if (pos >= available)
+        return pos;  //too few bytes available
+
+    unsigned char b;
+
+    hr = pReader->Read(pos, 1, &b);
+
+    if (hr < 0)
+        return hr;
+
+    assert(hr == 0L);
+
+    if (b == 0)  //we can't handle u-int values larger than 8 bytes
+        return E_FILE_FORMAT_INVALID;
+
+    unsigned char m = 0x80;
+    len = 1;
+
+    while (!(b & m))
+    {
+        m >>= 1;
+        ++len;
+    }
+
+    return 0;  //success
+}
+
+
+long long mkvparser::SyncReadUInt(
+    IMkvReader* pReader,
+    long long pos,
+    long long stop,
+    long& len)
+{
+    assert(pReader);
+
+    if (pos >= stop)
+        return E_FILE_FORMAT_INVALID;
+
+    unsigned char b;
+
+    long hr = pReader->Read(pos, 1, &b);
+
+    if (hr < 0)
+        return hr;
+
+    if (hr != 0L)
+        return E_BUFFER_NOT_FULL;
+
+    if (b == 0)  //we can't handle u-int values larger than 8 bytes
+        return E_FILE_FORMAT_INVALID;
+
+    unsigned char m = 0x80;
+    len = 1;
+
+    while (!(b & m))
+    {
+        m >>= 1;
+        ++len;
+    }
+
+    if ((pos + len) > stop)
+        return E_FILE_FORMAT_INVALID;
+
+    long long result = b & (~m);
+    ++pos;
+
+    for (int i = 1; i < len; ++i)
+    {
+        hr = pReader->Read(pos, 1, &b);
+
+        if (hr < 0)
+            return hr;
+
+        if (hr != 0L)
+            return E_BUFFER_NOT_FULL;
+
+        result <<= 8;
+        result |= b;
+
+        ++pos;
+    }
+
+    return result;
+}
+
+
+long long mkvparser::UnserializeUInt(
+    IMkvReader* pReader,
+    long long pos,
+    long long size)
+{
+    assert(pReader);
+    assert(pos >= 0);
+    assert(size > 0);
+    assert(size <= 8);
+
+    long long result = 0;
+
+    for (long long i = 0; i < size; ++i)
+    {
+        unsigned char b;
+
+        const long hr = pReader->Read(pos, 1, &b);
+
+        if (hr < 0)
+            return hr;
+        result <<= 8;
+        result |= b;
+
+        ++pos;
+    }
+
+    return result;
+}
+
+
+float mkvparser::Unserialize4Float(
+    IMkvReader* pReader,
+    long long pos)
+{
+    assert(pReader);
+    assert(pos >= 0);
+
+    long long total, available;
+
+    long hr = pReader->Length(&total, &available);
+    assert(hr >= 0);
+    assert(available <= total);
+    assert((pos + 4) <= available);
+
+    float result;
+
+    unsigned char* const p = (unsigned char*)&result;
+    unsigned char* q = p + 4;
+
+    for (;;)
+    {
+        hr = pReader->Read(pos, 1, --q);
+        assert(hr == 0L);
+
+        if (q == p)
+            break;
+
+        ++pos;
+    }
+
+    return result;
+}
+
+
+double mkvparser::Unserialize8Double(
+    IMkvReader* pReader,
+    long long pos)
+{
+    assert(pReader);
+    assert(pos >= 0);
+
+    double result;
+
+    unsigned char* const p = (unsigned char*)&result;
+    unsigned char* q = p + 8;
+
+    for (;;)
+    {
+        const long hr = pReader->Read(pos, 1, --q);
+        assert(hr == 0L);
+
+        if (q == p)
+            break;
+
+        ++pos;
+    }
+
+    return result;
+}
+
+signed char mkvparser::Unserialize1SInt(
+    IMkvReader* pReader,
+    long long pos)
+{
+    assert(pReader);
+    assert(pos >= 0);
+
+    long long total, available;
+
+    long hr = pReader->Length(&total, &available);
+    assert(hr == 0);
+    assert(available <= total);
+    assert(pos < available);
+
+    signed char result;
+
+    hr = pReader->Read(pos, 1, (unsigned char*)&result);
+    assert(hr == 0);
+
+    return result;
+}
+
+short mkvparser::Unserialize2SInt(
+    IMkvReader* pReader,
+    long long pos)
+{
+    assert(pReader);
+    assert(pos >= 0);
+
+    long long total, available;
+
+    long hr = pReader->Length(&total, &available);
+    assert(hr >= 0);
+    assert(available <= total);
+    assert((pos + 2) <= available);
+
+    short result;
+
+    unsigned char* const p = (unsigned char*)&result;
+    unsigned char* q = p + 2;
+
+    for (;;)
+    {
+        hr = pReader->Read(pos, 1, --q);
+        assert(hr == 0L);
+
+        if (q == p)
+            break;
+
+        ++pos;
+    }
+
+    return result;
+}
+
+
+bool mkvparser::Match(
+    IMkvReader* pReader,
+    long long& pos,
+    unsigned long id_,
+    long long& val)
+
+{
+    assert(pReader);
+    assert(pos >= 0);
+
+    long long total, available;
+
+    long hr = pReader->Length(&total, &available);
+    assert(hr >= 0);
+    assert(available <= total);
+
+    long len;
+
+    const long long id = ReadUInt(pReader, pos, len);
+    assert(id >= 0);
+    assert(len > 0);
+    assert(len <= 8);
+    assert((pos + len) <= available);
+
+    if ((unsigned long)id != id_)
+        return false;
+
+    pos += len;  //consume id
+
+    const long long size = ReadUInt(pReader, pos, len);
+    assert(size >= 0);
+    assert(size <= 8);
+    assert(len > 0);
+    assert(len <= 8);
+    assert((pos + len) <= available);
+
+    pos += len;  //consume length of size of payload
+
+    val = UnserializeUInt(pReader, pos, size);
+    assert(val >= 0);
+
+    pos += size;  //consume size of payload
+
+    return true;
+}
+
+bool mkvparser::Match(
+    IMkvReader* pReader,
+    long long& pos,
+    unsigned long id_,
+    char*& val)
+{
+    assert(pReader);
+    assert(pos >= 0);
+
+    long long total, available;
+
+    long hr = pReader->Length(&total, &available);
+    assert(hr >= 0);
+    assert(available <= total);
+
+    long len;
+
+    const long long id = ReadUInt(pReader, pos, len);
+    assert(id >= 0);
+    assert(len > 0);
+    assert(len <= 8);
+    assert((pos + len) <= available);
+
+    if ((unsigned long)id != id_)
+        return false;
+
+    pos += len;  //consume id
+
+    const long long size_ = ReadUInt(pReader, pos, len);
+    assert(size_ >= 0);
+    assert(len > 0);
+    assert(len <= 8);
+    assert((pos + len) <= available);
+
+    pos += len;  //consume length of size of payload
+    assert((pos + size_) <= available);
+
+    const size_t size = static_cast<size_t>(size_);
+    val = new char[size+1];
+
+    for (size_t i = 0; i < size; ++i)
+    {
+        char c;
+
+        hr = pReader->Read(pos + i, 1, (unsigned char*)&c);
+        assert(hr == 0L);
+
+        val[i] = c;
+
+        if (c == '\0')
+            break;
+
+    }
+
+    val[size] = '\0';
+    pos += size_;  //consume size of payload
+
+    return true;
+}
+
+bool mkvparser::Match(
+    IMkvReader* pReader,
+    long long& pos,
+    unsigned long id_,
+    unsigned char*& buf,
+    size_t& buflen)
+{
+    assert(pReader);
+    assert(pos >= 0);
+
+    long long total, available;
+
+    long hr = pReader->Length(&total, &available);
+    assert(hr >= 0);
+    assert(available <= total);
+
+    long len;
+    const long long id = ReadUInt(pReader, pos, len);
+    assert(id >= 0);
+    assert(len > 0);
+    assert(len <= 8);
+    assert((pos + len) <= available);
+
+    if ((unsigned long)id != id_)
+        return false;
+
+    pos += len;  //consume id
+
+    const long long size_ = ReadUInt(pReader, pos, len);
+    assert(size_ >= 0);
+    assert(len > 0);
+    assert(len <= 8);
+    assert((pos + len) <= available);
+
+    pos += len;  //consume length of size of payload
+    assert((pos + size_) <= available);
+
+    const long buflen_ = static_cast<long>(size_);
+
+    buf = new (std::nothrow) unsigned char[buflen_];
+    assert(buf);  //TODO
+
+    hr = pReader->Read(pos, buflen_, buf);
+    assert(hr == 0L);
+
+    buflen = buflen_;
+
+    pos += size_;  //consume size of payload
+    return true;
+}
+
+
+bool mkvparser::Match(
+    IMkvReader* pReader,
+    long long& pos,
+    unsigned long id_,
+    double& val)
+{
+    assert(pReader);
+    assert(pos >= 0);
+
+    long long total, available;
+
+    long hr = pReader->Length(&total, &available);
+    assert(hr >= 0);
+    assert(available <= total);
+    long idlen;
+    const long long id = ReadUInt(pReader, pos, idlen);
+    assert(id >= 0);  //TODO
+
+    if ((unsigned long)id != id_)
+        return false;
+
+    long sizelen;
+    const long long size = ReadUInt(pReader, pos + idlen, sizelen);
+
+    switch (size)
+    {
+        case 4:
+        case 8:
+            break;
+        default:
+            return false;
+    }
+
+    pos += idlen + sizelen;  //consume id and size fields
+    assert((pos + size) <= available);
+
+    if (size == 4)
+        val = Unserialize4Float(pReader, pos);
+    else
+    {
+        assert(size == 8);
+        val = Unserialize8Double(pReader, pos);
+    }
+
+    pos += size;  //consume size of payload
+
+    return true;
+}
+
+
+bool mkvparser::Match(
+    IMkvReader* pReader,
+    long long& pos,
+    unsigned long id_,
+    short& val)
+{
+    assert(pReader);
+    assert(pos >= 0);
+
+    long long total, available;
+
+    long hr = pReader->Length(&total, &available);
+    assert(hr >= 0);
+    assert(available <= total);
+
+    long len;
+    const long long id = ReadUInt(pReader, pos, len);
+    assert(id >= 0);
+    assert((pos + len) <= available);
+
+    if ((unsigned long)id != id_)
+        return false;
+
+    pos += len;  //consume id
+
+    const long long size = ReadUInt(pReader, pos, len);
+    assert(size <= 2);
+    assert((pos + len) <= available);
+
+    pos += len;  //consume length of size of payload
+    assert((pos + size) <= available);
+
+    //TODO:
+    // Generalize this to work for any size signed int
+    if (size == 1)
+        val = Unserialize1SInt(pReader, pos);
+    else
+        val = Unserialize2SInt(pReader, pos);
+
+    pos += size;  //consume size of payload
+
+    return true;
+}
+
+
+namespace mkvparser
+{
+
+EBMLHeader::EBMLHeader():
+    m_docType(NULL)
+{
+}
+
+EBMLHeader::~EBMLHeader()
+{
+    delete[] m_docType;
+}
+
+long long EBMLHeader::Parse(
+    IMkvReader* pReader,
+    long long& pos)
+{
+    assert(pReader);
+
+    long long total, available;
+
+    long hr = pReader->Length(&total, &available);
+
+    if (hr < 0)
+        return hr;
+
+    pos = 0;
+    long long end = (1024 < available)? 1024: available;
+
+    for (;;)
+    {
+        unsigned char b = 0;
+
+        while (pos < end)
+        {
+            hr = pReader->Read(pos, 1, &b);
+
+            if (hr < 0)
+                return hr;
+
+            if (b == 0x1A)
+                break;
+
+            ++pos;
+        }
+
+        if (b != 0x1A)
+        {
+            if ((pos >= 1024) ||
+                (available >= total) ||
+                ((total - available) < 5))
+                  return -1;
+
+            return available + 5;  //5 = 4-byte ID + 1st byte of size
+        }
+
+        if ((total - pos) < 5)
+            return E_FILE_FORMAT_INVALID;
+
+        if ((available - pos) < 5)
+            return pos + 5;  //try again later
+
+        long len;
+
+        const long long result = ReadUInt(pReader, pos, len);
+
+        if (result < 0)  //error
+            return result;
+
+        if (result == 0x0A45DFA3)  //ReadId masks-off length indicator bits
+        {
+            assert(len == 4);
+            pos += len;
+            break;
+        }
+
+        ++pos;  //throw away just the 0x1A byte, and try again
+    }
+
+    long len;
+    long long result = GetUIntLength(pReader, pos, len);
+
+    if (result < 0)  //error
+        return result;
+
+    if (result > 0)  //need more data
+        return result;
+
+    assert(len > 0);
+    assert(len <= 8);
+
+    if ((total -  pos) < len)
+        return E_FILE_FORMAT_INVALID;
+    if ((available - pos) < len)
+        return pos + len;  //try again later
+
+    result = ReadUInt(pReader, pos, len);
+
+    if (result < 0)  //error
+        return result;
+
+    pos += len;  //consume u-int
+
+    if ((total - pos) < result)
+        return E_FILE_FORMAT_INVALID;
+
+    if ((available - pos) < result)
+        return pos + result;
+
+    end = pos + result;
+
+    m_version = 1;
+    m_readVersion = 1;
+    m_maxIdLength = 4;
+    m_maxSizeLength = 8;
+    m_docTypeVersion = 1;
+    m_docTypeReadVersion = 1;
+
+    while (pos < end)
+    {
+        if (Match(pReader, pos, 0x0286, m_version))
+            ;
+        else if (Match(pReader, pos, 0x02F7, m_readVersion))
+            ;
+        else if (Match(pReader, pos, 0x02F2, m_maxIdLength))
+            ;
+        else if (Match(pReader, pos, 0x02F3, m_maxSizeLength))
+            ;
+        else if (Match(pReader, pos, 0x0282, m_docType))
+            ;
+        else if (Match(pReader, pos, 0x0287, m_docTypeVersion))
+            ;
+        else if (Match(pReader, pos, 0x0285, m_docTypeReadVersion))
+            ;
+        else
+        {
+            result = ReadUInt(pReader, pos, len);
+            assert(result > 0);
+            assert(len > 0);
+            assert(len <= 8);
+
+            pos += len;
+            assert(pos < end);
+
+            result = ReadUInt(pReader, pos, len);
+            assert(result >= 0);
+            assert(len > 0);
+            assert(len <= 8);
+
+            pos += len + result;
+            assert(pos <= end);
+        }
+    }
+
+    assert(pos == end);
+
+    return 0;
+}
+
+
+Segment::Segment(
+    IMkvReader* pReader,
+    long long start,
+    long long size) :
+    m_pReader(pReader),
+    m_start(start),
+    m_size(size),
+    m_pos(start),
+    m_pInfo(NULL),
+    m_pTracks(NULL),
+    m_pCues(NULL),
+    m_clusters(NULL),
+    m_clusterCount(0),
+    m_clusterPreloadCount(0),
+    m_clusterSize(0)
+{
+}
+
+
+Segment::~Segment()
+{
+    const long count = m_clusterCount + m_clusterPreloadCount;
+
+    Cluster** i = m_clusters;
+    Cluster** j = m_clusters + count;
+
+    while (i != j)
+    {
+        Cluster* const p = *i++;
+        assert(p);
+
+        delete p;
+    }
+
+    delete[] m_clusters;
+
+    delete m_pTracks;
+    delete m_pInfo;
+    delete m_pCues;
+}
+
+
+long long Segment::CreateInstance(
+    IMkvReader* pReader,
+    long long pos,
+    Segment*& pSegment)
+{
+    assert(pReader);
+    assert(pos >= 0);
+
+    pSegment = NULL;
+
+    long long total, available;
+
+    long hr = pReader->Length(&total, &available);
+    assert(hr >= 0);
+    assert(available <= total);
+
+    //I would assume that in practice this loop would execute
+    //exactly once, but we allow for other elements (e.g. Void)
+    //to immediately follow the EBML header.  This is fine for
+    //the source filter case (since the entire file is available),
+    //but in the splitter case over a network we should probably
+    //just give up early.  We could for example decide only to
+    //execute this loop a maximum of, say, 10 times.
+
+    while (pos < total)
+    {
+        //Read ID
+
+        long len;
+        long long result = GetUIntLength(pReader, pos, len);
+
+        if (result)  //error, or too few available bytes
+            return result;
+
+        if ((pos + len) > total)
+            return E_FILE_FORMAT_INVALID;
+
+        if ((pos + len) > available)
+            return pos + len;
+
+        //TODO: if we liberalize the behavior of ReadUInt, we can
+        //probably eliminate having to use GetUIntLength here.
+        const long long id = ReadUInt(pReader, pos, len);
+
+        if (id < 0)  //error
+            return id;
+
+        pos += len;  //consume ID
+
+        //Read Size
+
+        result = GetUIntLength(pReader, pos, len);
+
+        if (result)  //error, or too few available bytes
+            return result;
+
+        if ((pos + len) > total)
+            return E_FILE_FORMAT_INVALID;
+
+        if ((pos + len) > available)
+            return pos + len;
+
+        //TODO: if we liberalize the behavior of ReadUInt, we can
+        //probably eliminate having to use GetUIntLength here.
+        const long long size = ReadUInt(pReader, pos, len);
+
+        if (size < 0)
+            return size;
+
+        pos += len;  //consume length of size of element
+
+        //Pos now points to start of payload
+
+        if ((pos + size) > total)
+            return E_FILE_FORMAT_INVALID;
+
+        if (id == 0x08538067)  //Segment ID
+        {
+            pSegment = new  Segment(pReader, pos, size);
+            assert(pSegment);  //TODO
+
+            return 0;    //success
+        }
+
+        pos += size;  //consume payload
+    }
+
+    assert(pos == total);
+
+    pSegment = new Segment(pReader, pos, 0);
+    assert(pSegment);  //TODO
+
+    return 0;  //success (sort of)
+}
+
+
+long long Segment::ParseHeaders()
+{
+    //Outermost (level 0) segment object has been constructed,
+    //and pos designates start of payload.  We need to find the
+    //inner (level 1) elements.
+    long long total, available;
+
+    long hr = m_pReader->Length(&total, &available);
+    assert(hr >= 0);
+    assert(available <= total);
+
+    const long long stop = m_start + m_size;
+    assert(stop <= total);
+    assert(m_pos <= stop);
+
+    bool bQuit = false;
+
+    while ((m_pos < stop) && !bQuit)
+    {
+        long long pos = m_pos;
+
+        long len;
+        long long result = GetUIntLength(m_pReader, pos, len);
+
+        if (result)  //error, or too few available bytes
+            return result;
+
+        if ((pos + len) > stop)
+            return E_FILE_FORMAT_INVALID;
+
+        if ((pos + len) > available)
+            return pos + len;
+
+        const long long idpos = pos;
+        const long long id = ReadUInt(m_pReader, idpos, len);
+
+        if (id < 0)  //error
+            return id;
+
+        pos += len;  //consume ID
+
+        //Read Size
+        result = GetUIntLength(m_pReader, pos, len);
+
+        if (result)  //error, or too few available bytes
+            return result;
+
+        if ((pos + len) > stop)
+            return E_FILE_FORMAT_INVALID;
+
+        if ((pos + len) > available)
+            return pos + len;
+
+        const long long size = ReadUInt(m_pReader, pos, len);
+
+        if (size < 0)
+            return size;
+
+        pos += len;  //consume length of size of element
+
+        //Pos now points to start of payload
+
+        if ((pos + size) > stop)
+            return E_FILE_FORMAT_INVALID;
+
+        //We read EBML elements either in total or nothing at all.
+
+        if ((pos + size) > available)
+            return pos + size;
+
+        if (id == 0x0549A966)  //Segment Info ID
+        {
+            assert(m_pInfo == NULL);
+
+            m_pInfo = new SegmentInfo(this, pos, size);
+            assert(m_pInfo);  //TODO
+        }
+        else if (id == 0x0654AE6B)  //Tracks ID
+        {
+            assert(m_pTracks == NULL);
+
+            m_pTracks = new Tracks(this, pos, size);
+            assert(m_pTracks);  //TODO
+        }
+        else if (id == 0x0C53BB6B)  //Cues ID
+        {
+            if (m_pCues == NULL)
+            {
+                m_pCues = new Cues(this, pos, size);
+                assert(m_pCues);  //TODO
+            }
+        }
+        else if (id == 0x014D9B74)  //SeekHead ID
+        {
+            ParseSeekHead(pos, size);
+        }
+        else if (id == 0x0F43B675)  //Cluster ID
+        {
+            bQuit = true;
+        }
+
+        if (!bQuit)
+            m_pos = pos + size;  //consume payload
+    }
+
+    assert(m_pos <= stop);
+
+    if (m_pInfo == NULL)  //TODO: liberalize this behavior
+        return E_FILE_FORMAT_INVALID;
+
+    if (m_pTracks == NULL)
+        return E_FILE_FORMAT_INVALID;
+
+    return 0;  //success
+}
+
+
+#if 0
+long Segment::ParseCluster(Cluster*& pCluster, long long& pos_) const
+{
+    pCluster = NULL;
+    pos_ = -1;
+
+    const long long stop = m_start + m_size;
+    assert(m_pos <= stop);
+
+    long long pos = m_pos;
+    long long off = -1;
+
+    while (pos < stop)
+    {
+        long len;
+        const long long idpos = pos;
+
+        const long long id = SyncReadUInt(m_pReader, pos, stop, len);
+
+        if (id < 0)  //error
+            return static_cast<long>(id);
+
+        if (id == 0)
+            return E_FILE_FORMAT_INVALID;
+
+        pos += len;  //consume id
+        assert(pos < stop);
+
+        const long long size = SyncReadUInt(m_pReader, pos, stop, len);
+
+        if (size < 0)  //error
+            return static_cast<long>(size);
+
+        pos += len;  //consume size
+        assert(pos <= stop);
+
+        if (size == 0)  //weird
+            continue;
+
+        //pos now points to start of payload
+
+        pos += size;  //consume payload
+        assert(pos <= stop);
+
+        if (id == 0x0F43B675)  //Cluster ID
+        {
+            off = idpos - m_start;  // >= 0 means we found a cluster
+            break;
+        }
+    }
+
+    assert(pos <= stop);
+
+    //Indicate to caller how much of file has been consumed. This is
+    //used later in AddCluster to adjust the current parse position
+    //(the value cached in the segment object itself) to the
+    //file position value just past the cluster we parsed.
+
+    if (off < 0)  //we did not found any more clusters
+    {
+        pos_ = stop;  //pos_ >= 0 here means EOF (cluster is NULL)
+        return 0;     //TODO: confirm this return value
+    }
+
+    //We found a cluster.  Now read something, to ensure that it is
+    //fully loaded in the network cache.
+
+    if (pos >= stop)  //we parsed the entire segment
+    {
+        //We did find a cluster, but it was very last element in the segment.
+        //Our preference is that the loop above runs 1 1/2 times:
+        //the first pass finds the cluster, and the second pass
+        //finds the element the follows the cluster.  In this case, however,
+        //we reached the end of the file without finding another element,
+        //so we didn't actually read anything yet associated with "end of the
+        //cluster".  And we must perform an actual read, in order
+        //to guarantee that all of the data that belongs to this
+        //cluster has been loaded into the network cache.  So instead
+        //of reading the next element that follows the cluster, we
+        //read the last byte of the cluster (which is also the last
+        //byte in the file).
+
+        //Read the last byte of the file. (Reading 0 bytes at pos
+        //might work too -- it would depend on how the reader is
+        //implemented.  Here we take the more conservative approach,
+        //since this makes fewer assumptions about the network
+        //reader abstraction.)
+
+        unsigned char b;
+
+        const int result = m_pReader->Read(pos - 1, 1, &b);
+        assert(result == 0);
+
+        pos_ = stop;
+    }
+    else
+    {
+        long len;
+        const long long idpos = pos;
+
+        const long long id = SyncReadUInt(m_pReader, pos, stop, len);
+
+        if (id < 0)  //error
+            return static_cast<long>(id);
+
+        if (id == 0)
+            return E_BUFFER_NOT_FULL;
+
+        pos += len;  //consume id
+        assert(pos < stop);
+
+        const long long size = SyncReadUInt(m_pReader, pos, stop, len);
+
+        if (size < 0)  //error
+            return static_cast<long>(size);
+
+        pos_ = idpos;
+    }
+
+    //We found a cluster, and it has been completely loaded into the
+    //network cache.  (We can guarantee this because we actually read
+    //the EBML tag that follows the cluster, or, if we reached EOF,
+    //because we actually read the last byte of the cluster).
+
+    Segment* const this_ = const_cast<Segment*>(this);
+
+    pCluster = Cluster::Parse(this_, m_clusterCount, off);
+    assert(pCluster);
+    assert(pCluster->m_index == m_clusterCount);
+
+    return 0;
+}
+
+
+bool Segment::AddCluster(Cluster* pCluster, long long pos)
+{
+    assert(pos >= m_start);
+
+    const long long stop = m_start + m_size;
+    assert(pos <= stop);
+
+    if (pCluster)
+    {
+        AppendCluster(pCluster);
+        assert(m_clusters);
+        assert(m_clusterSize > pCluster->m_index);
+        assert(m_clusters[pCluster->m_index] == pCluster);
+    }
+
+    m_pos = pos;  //m_pos >= stop is now we know we have all clusters
+
+    return (pos >= stop);
+}
+#endif
+
+
+long Segment::LoadCluster()
+{
+    const long long stop = m_start + m_size;
+
+    while (m_pos < stop)
+    {
+        long long pos = m_pos;
+
+        long len;
+
+        long long result = GetUIntLength(m_pReader, pos, len);
+
+        if (result < 0)  //error
+            return static_cast<long>(result);
+
+        if ((pos + len) > stop)
+            return E_FILE_FORMAT_INVALID;
+
+        const long long idpos = pos;
+        const long long id = ReadUInt(m_pReader, idpos, len);
+
+        if (id < 0)  //error
+            return static_cast<long>(id);
+
+        pos += len;  //consume ID
+
+        //Read Size
+        result = GetUIntLength(m_pReader, pos, len);
+
+        if (result < 0)  //error
+            return static_cast<long>(result);
+
+        if ((pos + len) > stop)
+            return E_FILE_FORMAT_INVALID;
+
+        const long long size = ReadUInt(m_pReader, pos, len);
+
+        if (size < 0)  //error
+            return static_cast<long>(size);
+
+        pos += len;  //consume length of size of element
+
+        if (size == 0)  //weird
+        {
+            m_pos = pos;
+            continue;
+        }
+
+        //Pos now points to start of payload
+
+        if ((pos + size) > stop)
+            return E_FILE_FORMAT_INVALID;
+
+        if (id == 0x0C53BB6B)  //Cues ID
+        {
+            if (m_pCues == NULL)
+            {
+                m_pCues = new Cues(this, pos, size);
+                assert(m_pCues);  //TODO
+            }
+
+            m_pos = pos + size;  //consume payload
+            continue;
+        }
+
+        if (id != 0x0F43B675)  //Cluster ID
+        {
+            m_pos = pos + size;  //consume payload
+            continue;
+        }
+
+        const long idx = m_clusterCount;
+        const long long idoff = idpos - m_start;
+
+        if (m_clusterPreloadCount > 0)
+        {
+            assert(idx < m_clusterSize);
+
+            Cluster* const pCluster = m_clusters[idx];
+            assert(pCluster);
+            assert(pCluster->m_index < 0);
+
+            const long long off_ = pCluster->m_pos;
+            assert(off_);
+
+            const long long off = off_ * ((off_ >= 0) ? 1 : -1);
+            assert(idoff <= off);
+
+            if (idoff == off)  //cluster has been preloaded already
+            {
+                pCluster->m_index = idx;
+                ++m_clusterCount;
+                --m_clusterPreloadCount;
+
+                m_pos = pos + size;  //consume payload
+                break;
+            }
+        }
+
+        Cluster* const pCluster = Cluster::Parse(this, idx, idoff);
+        assert(pCluster);
+        assert(pCluster->m_index == idx);
+
+        AppendCluster(pCluster);
+        assert(m_clusters);
+        assert(idx < m_clusterSize);
+        assert(m_clusters[idx] == pCluster);
+
+        m_pos = pos + size;  //consume payload
+        break;
+    }
+
+    assert(m_pos <= stop);
+    return 0;
+}
+
+
+void Segment::AppendCluster(Cluster* pCluster)
+{
+    assert(pCluster);
+    assert(pCluster->m_index >= 0);
+
+    const long count = m_clusterCount + m_clusterPreloadCount;
+
+    long& size = m_clusterSize;
+    assert(size >= count);
+
+    const long idx = pCluster->m_index;
+    assert(idx == m_clusterCount);
+
+    if (count >= size)
+    {
+        long n;
+
+        if (size > 0)
+            n = 2 * size;
+        else if (m_pInfo == 0)
+            n = 2048;
+        else
+        {
+            const long long ns = m_pInfo->GetDuration();
+
+            if (ns <= 0)
+                n = 2048;
+            else
+            {
+                const long long sec = (ns + 999999999LL) / 1000000000LL;
+                n = static_cast<long>(sec);
+            }
+        }
+
+        Cluster** const qq = new Cluster*[n];
+        Cluster** q = qq;
+
+        Cluster** p = m_clusters;
+        Cluster** const pp = p + count;
+
+        while (p != pp)
+            *q++ = *p++;
+
+        delete[] m_clusters;
+
+        m_clusters = qq;
+        size = n;
+    }
+
+    if (m_clusterPreloadCount > 0)
+    {
+        assert(m_clusters);
+
+        Cluster** const p = m_clusters + m_clusterCount;
+        assert(*p);
+        assert((*p)->m_index < 0);
+
+        Cluster** q = p + m_clusterPreloadCount;
+        assert(q < (m_clusters + size));
+
+        for (;;)
+        {
+            Cluster** const qq = q - 1;
+            assert((*qq)->m_index < 0);
+
+            *q = *qq;
+            q = qq;
+
+            if (q == p)
+                break;
+        }
+    }
+
+    m_clusters[idx] = pCluster;
+    ++m_clusterCount;
+}
+
+
+void Segment::PreloadCluster(Cluster* pCluster, ptrdiff_t idx)
+{
+    assert(pCluster);
+    assert(pCluster->m_index < 0);
+    assert(idx >= m_clusterCount);
+
+    const long count = m_clusterCount + m_clusterPreloadCount;
+
+    long& size = m_clusterSize;
+    assert(size >= count);
+
+    if (count >= size)
+    {
+        long n;
+
+        if (size > 0)
+            n = 2 * size;
+        else if (m_pInfo == 0)
+            n = 2048;
+        else
+        {
+            const long long ns = m_pInfo->GetDuration();
+
+            if (ns <= 0)
+                n = 2048;
+            else
+            {
+                const long long sec = (ns + 999999999LL) / 1000000000LL;
+                n = static_cast<long>(sec);
+            }
+        }
+
+        Cluster** const qq = new Cluster*[n];
+        Cluster** q = qq;
+
+        Cluster** p = m_clusters;
+        Cluster** const pp = p + count;
+
+        while (p != pp)
+            *q++ = *p++;
+
+        delete[] m_clusters;
+
+        m_clusters = qq;
+        size = n;
+    }
+
+    assert(m_clusters);
+
+    Cluster** const p = m_clusters + idx;
+
+    Cluster** q = m_clusters + count;
+    assert(q >= p);
+    assert(q < (m_clusters + size));
+
+    while (q > p)
+    {
+        Cluster** const qq = q - 1;
+        assert((*qq)->m_index < 0);
+
+        *q = *qq;
+        q = qq;
+    }
+
+    m_clusters[idx] = pCluster;
+    ++m_clusterPreloadCount;
+}
+
+
+long Segment::Load()
+{
+    assert(m_clusters == NULL);
+    assert(m_clusterSize == 0);
+    assert(m_clusterCount == 0);
+
+    //Outermost (level 0) segment object has been constructed,
+    //and pos designates start of payload.  We need to find the
+    //inner (level 1) elements.
+    const long long stop = m_start + m_size;
+
+#ifdef _DEBUG  //TODO: this is really Microsoft-specific
+    {
+        long long total, available;
+
+        long hr = m_pReader->Length(&total, &available);
+        assert(hr >= 0);
+        assert(available >= total);
+        assert(stop <= total);
+    }
+#endif
+
+    while (m_pos < stop)
+    {
+        long long pos = m_pos;
+
+        long len;
+
+        long long result = GetUIntLength(m_pReader, pos, len);
+
+        if (result < 0)  //error
+            return static_cast<long>(result);
+
+        if ((pos + len) > stop)
+            return E_FILE_FORMAT_INVALID;
+
+        const long long idpos = pos;
+        const long long id = ReadUInt(m_pReader, idpos, len);
+
+        if (id < 0)  //error
+            return static_cast<long>(id);
+
+        pos += len;  //consume ID
+
+        //Read Size
+        result = GetUIntLength(m_pReader, pos, len);
+
+        if (result < 0)  //error
+            return static_cast<long>(result);
+
+        if ((pos + len) > stop)
+            return E_FILE_FORMAT_INVALID;
+
+        const long long size = ReadUInt(m_pReader, pos, len);
+
+        if (size < 0)  //error
+            return static_cast<long>(size);
+
+        pos += len;  //consume length of size of element
+
+        //Pos now points to start of payload
+
+        if ((pos + size) > stop)
+            return E_FILE_FORMAT_INVALID;
+
+        if (id == 0x0F43B675)  //Cluster ID
+        {
+            const long idx = m_clusterCount;
+            const long long off = idpos - m_start;
+
+            Cluster* const pCluster = Cluster::Parse(this, idx, off);
+            assert(pCluster);
+            assert(pCluster->m_index == idx);
+
+            AppendCluster(pCluster);
+            assert(m_clusters);
+            assert(m_clusterSize > idx);
+            assert(m_clusters[idx] == pCluster);
+        }
+        else if (id == 0x0C53BB6B)  //Cues ID
+        {
+            assert(m_pCues == NULL);
+
+            m_pCues = new Cues(this, pos, size);
+            assert(m_pCues);  //TODO
+        }
+        else if (id == 0x0549A966)  //SegmentInfo ID
+        {
+            assert(m_pInfo == NULL);
+
+            m_pInfo = new  SegmentInfo(this, pos, size);
+            assert(m_pInfo);
+        }
+        else if (id == 0x0654AE6B)  //Tracks ID
+        {
+            assert(m_pTracks == NULL);
+
+            m_pTracks = new Tracks(this, pos, size);
+            assert(m_pTracks);  //TODO
+        }
+
+        m_pos = pos + size;  //consume payload
+    }
+
+    assert(m_pos >= stop);
+
+    if (m_pInfo == NULL)
+        return E_FILE_FORMAT_INVALID;  //TODO: ignore this case?
+
+    if (m_pTracks == NULL)
+        return E_FILE_FORMAT_INVALID;
+
+    if (m_clusters == NULL)  //TODO: ignore this case?
+        return E_FILE_FORMAT_INVALID;
+
+    //TODO: decide whether we require Cues element
+    //if (m_pCues == NULL)
+    //   return E_FILE_FORMAT_INVALID;
+
+    return 0;
+}
+
+
+void Segment::ParseSeekHead(long long start, long long size_)
+{
+    long long pos = start;
+    const long long stop = start + size_;
+
+    while (pos < stop)
+    {
+        long len;
+
+        const long long id = ReadUInt(m_pReader, pos, len);
+        assert(id >= 0);  //TODO
+        assert((pos + len) <= stop);
+
+        pos += len;  //consume ID
+
+        const long long size = ReadUInt(m_pReader, pos, len);
+        assert(size >= 0);
+        assert((pos + len) <= stop);
+
+        pos += len;  //consume Size field
+        assert((pos + size) <= stop);
+
+        if (id == 0x0DBB)  //SeekEntry ID
+            ParseSeekEntry(pos, size);
+
+        pos += size;  //consume payload
+        assert(pos <= stop);
+    }
+
+    assert(pos == stop);
+}
+
+
+void Segment::ParseCues(long long off)
+{
+    if (m_pCues)
+        return;
+
+    //odbgstream os;
+    //os << "Segment::ParseCues (begin)" << endl;
+
+    long long pos = m_start + off;
+    const long long stop = m_start + m_size;
+
+    long len;
+
+    long long result = GetUIntLength(m_pReader, pos, len);
+    assert(result == 0);
+    assert((pos + len) <= stop);
+
+    const long long idpos = pos;
+
+    const long long id = ReadUInt(m_pReader, idpos, len);
+    assert(id == 0x0C53BB6B);  //Cues ID
+
+    pos += len;  //consume ID
+    assert(pos < stop);
+
+    //Read Size
+
+    result = GetUIntLength(m_pReader, pos, len);
+    assert(result == 0);
+    assert((pos + len) <= stop);
+
+    const long long size = ReadUInt(m_pReader, pos, len);
+    assert(size >= 0);
+
+    pos += len;  //consume length of size of element
+    assert((pos + size) <= stop);
+
+    //Pos now points to start of payload
+
+    m_pCues = new Cues(this, pos, size);
+    assert(m_pCues);  //TODO
+
+    //os << "Segment::ParseCues (end)" << endl;
+}
+
+
+void Segment::ParseSeekEntry(
+   long long start,
+   long long size_)
+{
+    long long pos = start;
+
+    const long long stop = start + size_;
+
+    long len;
+
+    const long long seekIdId = ReadUInt(m_pReader, pos, len);
+    //seekIdId;
+    assert(seekIdId == 0x13AB);  //SeekID ID
+    assert((pos + len) <= stop);
+
+    pos += len;  //consume id
+
+    const long long seekIdSize = ReadUInt(m_pReader, pos, len);
+    assert(seekIdSize >= 0);
+    assert((pos + len) <= stop);
+
+    pos += len;  //consume size
+
+    const long long seekId = ReadUInt(m_pReader, pos, len);  //payload
+    assert(seekId >= 0);
+    assert(len == seekIdSize);
+    assert((pos + len) <= stop);
+
+    pos += seekIdSize;  //consume payload
+
+    const long long seekPosId = ReadUInt(m_pReader, pos, len);
+    //seekPosId;
+    assert(seekPosId == 0x13AC);  //SeekPos ID
+    assert((pos + len) <= stop);
+
+    pos += len;  //consume id
+
+    const long long seekPosSize = ReadUInt(m_pReader, pos, len);
+    assert(seekPosSize >= 0);
+    assert((pos + len) <= stop);
+
+    pos += len;  //consume size
+    assert((pos + seekPosSize) <= stop);
+
+    const long long seekOff = UnserializeUInt(m_pReader, pos, seekPosSize);
+    assert(seekOff >= 0);
+    assert(seekOff < m_size);
+
+    pos += seekPosSize;  //consume payload
+    assert(pos == stop);
+
+    const long long seekPos = m_start + seekOff;
+    assert(seekPos < (m_start + m_size));
+
+    if (seekId == 0x0C53BB6B)  //Cues ID
+        ParseCues(seekOff);
+}
+
+
+Cues::Cues(Segment* pSegment, long long start_, long long size_) :
+    m_pSegment(pSegment),
+    m_start(start_),
+    m_size(size_),
+    m_cue_points(NULL),
+    m_count(0),
+    m_preload_count(0),
+    m_pos(start_)
+{
+}
+
+
+Cues::~Cues()
+{
+    const size_t n = m_count + m_preload_count;
+
+    CuePoint** p = m_cue_points;
+    CuePoint** const q = p + n;
+
+    while (p != q)
+    {
+        CuePoint* const pCP = *p++;
+        assert(pCP);
+
+        delete pCP;
+    }
+
+    delete[] m_cue_points;
+}
+
+
+void Cues::Init() const
+{
+    if (m_cue_points)
+        return;
+
+    assert(m_count == 0);
+    assert(m_preload_count == 0);
+
+    IMkvReader* const pReader = m_pSegment->m_pReader;
+
+    const long long stop = m_start + m_size;
+    long long pos = m_start;
+
+    size_t cue_points_size = 0;
+
+    while (pos < stop)
+    {
+        const long long idpos = pos;
+
+        long len;
+
+        const long long id = ReadUInt(pReader, pos, len);
+        assert(id >= 0);  //TODO
+        assert((pos + len) <= stop);
+
+        pos += len;  //consume ID
+
+        const long long size = ReadUInt(pReader, pos, len);
+        assert(size >= 0);
+        assert((pos + len) <= stop);
+
+        pos += len;  //consume Size field
+        assert((pos + size) <= stop);
+
+        if (id == 0x3B)  //CuePoint ID
+            PreloadCuePoint(cue_points_size, idpos);
+
+        pos += size;  //consume payload
+        assert(pos <= stop);
+    }
+}
+
+
+void Cues::PreloadCuePoint(
+    size_t& cue_points_size,
+    long long pos) const
+{
+    assert(m_count == 0);
+
+    if (m_preload_count >= cue_points_size)
+    {
+        size_t n;
+
+        if (cue_points_size > 0)
+            n = static_cast<size_t>(2 * cue_points_size);
+        else
+        {
+            const SegmentInfo* const pInfo = m_pSegment->GetInfo();
+
+            if (pInfo == NULL)
+                n = 2048;
+            else
+            {
+                const long long ns = pInfo->GetDuration();
+
+                if (ns <= 0)
+                    n = 2048;
+                else
+                {
+                    const long long sec = (ns + 999999999LL) / 1000000000LL;
+                    n = static_cast<size_t>(sec);
+                }
+            }
+        }
+
+        CuePoint** const qq = new CuePoint*[n];
+        CuePoint** q = qq;  //beginning of target
+
+        CuePoint** p = m_cue_points;                //beginning of source
+        CuePoint** const pp = p + m_preload_count;  //end of source
+
+        while (p != pp)
+            *q++ = *p++;
+
+        delete[] m_cue_points;
+
+        m_cue_points = qq;
+        cue_points_size = n;
+    }
+
+    CuePoint* const pCP = new CuePoint(m_preload_count, pos);
+    m_cue_points[m_preload_count++] = pCP;
+}
+
+
+bool Cues::LoadCuePoint() const
+{
+    //odbgstream os;
+    //os << "Cues::LoadCuePoint" << endl;
+
+    const long long stop = m_start + m_size;
+
+    if (m_pos >= stop)
+        return false;  //nothing else to do
+
+    Init();
+
+    IMkvReader* const pReader = m_pSegment->m_pReader;
+
+    while (m_pos < stop)
+    {
+        const long long idpos = m_pos;
+
+        long len;
+
+        const long long id = ReadUInt(pReader, m_pos, len);
+        assert(id >= 0);  //TODO
+        assert((m_pos + len) <= stop);
+
+        m_pos += len;  //consume ID
+
+        const long long size = ReadUInt(pReader, m_pos, len);
+        assert(size >= 0);
+        assert((m_pos + len) <= stop);
+
+        m_pos += len;  //consume Size field
+        assert((m_pos + size) <= stop);
+
+        if (id != 0x3B)  //CuePoint ID
+        {
+            m_pos += size;  //consume payload
+            assert(m_pos <= stop);
+
+            continue;
+        }
+
+        assert(m_preload_count > 0);
+
+        CuePoint* const pCP = m_cue_points[m_count];
+        assert(pCP);
+        assert((pCP->GetTimeCode() >= 0) || (-pCP->GetTimeCode() == idpos));
+
+        pCP->Load(pReader);
+        ++m_count;
+        --m_preload_count;
+
+        m_pos += size;  //consume payload
+        assert(m_pos <= stop);
+
+        break;
+    }
+
+    return (m_pos < stop);
+}
+
+
+bool Cues::Find(
+    long long time_ns,
+    const Track* pTrack,
+    const CuePoint*& pCP,
+    const CuePoint::TrackPosition*& pTP) const
+{
+    assert(time_ns >= 0);
+    assert(pTrack);
+
+    LoadCuePoint();
+
+    assert(m_cue_points);
+    assert(m_count > 0);
+
+    CuePoint** const ii = m_cue_points;
+    CuePoint** i = ii;
+
+    CuePoint** const jj = ii + m_count + m_preload_count;
+    CuePoint** j = jj;
+
+    pCP = *i;
+    assert(pCP);
+
+    if (time_ns <= pCP->GetTime(m_pSegment))
+    {
+        pTP = pCP->Find(pTrack);
+        return (pTP != NULL);
+    }
+
+    IMkvReader* const pReader = m_pSegment->m_pReader;
+
+    while (i < j)
+    {
+        //INVARIANT:
+        //[ii, i) <= time_ns
+        //[i, j)  ?
+        //[j, jj) > time_ns
+
+        CuePoint** const k = i + (j - i) / 2;
+        assert(k < jj);
+
+        CuePoint* const pCP = *k;
+        assert(pCP);
+
+        pCP->Load(pReader);
+
+        const long long t = pCP->GetTime(m_pSegment);
+
+        if (t <= time_ns)
+            i = k + 1;
+        else
+            j = k;
+
+        assert(i <= j);
+    }
+
+    assert(i == j);
+    assert(i <= jj);
+    assert(i > ii);
+
+    pCP = *--i;
+    assert(pCP);
+    assert(pCP->GetTime(m_pSegment) <= time_ns);
+
+    //TODO: here and elsewhere, it's probably not correct to search
+    //for the cue point with this time, and then search for a matching
+    //track.  In principle, the matching track could be on some earlier
+    //cue point, and with our current algorithm, we'd miss it.  To make
+    //this bullet-proof, we'd need to create a secondary structure,
+    //with a list of cue points that apply to a track, and then search
+    //that track-based structure for a matching cue point.
+
+    pTP = pCP->Find(pTrack);
+    return (pTP != NULL);
+}
+
+
+#if 0
+bool Cues::FindNext(
+    long long time_ns,
+    const Track* pTrack,
+    const CuePoint*& pCP,
+    const CuePoint::TrackPosition*& pTP) const
+{
+    pCP = 0;
+    pTP = 0;
+
+    if (m_count == 0)
+        return false;
+
+    assert(m_cue_points);
+
+    const CuePoint* const* const ii = m_cue_points;
+    const CuePoint* const* i = ii;
+
+    const CuePoint* const* const jj = ii + m_count;
+    const CuePoint* const* j = jj;
+
+    while (i < j)
+    {
+        //INVARIANT:
+        //[ii, i) <= time_ns
+        //[i, j)  ?
+        //[j, jj) > time_ns
+
+        const CuePoint* const* const k = i + (j - i) / 2;
+        assert(k < jj);
+
+        pCP = *k;
+        assert(pCP);
+
+        const long long t = pCP->GetTime(m_pSegment);
+
+        if (t <= time_ns)
+            i = k + 1;
+        else
+            j = k;
+
+        assert(i <= j);
+    }
+
+    assert(i == j);
+    assert(i <= jj);
+
+    if (i >= jj)  //time_ns is greater than max cue point
+        return false;
+
+    pCP = *i;
+    assert(pCP);
+    assert(pCP->GetTime(m_pSegment) > time_ns);
+
+    pTP = pCP->Find(pTrack);
+    return (pTP != NULL);
+}
+#endif
+
+
+const CuePoint* Cues::GetFirst() const
+{
+    LoadCuePoint();  //init cues
+
+    const size_t count = m_count + m_preload_count;
+
+    if (count == 0)  //weird
+        return NULL;
+
+    CuePoint* const* const pp = m_cue_points;
+    assert(pp);
+
+    CuePoint* const pCP = pp[0];
+    assert(pCP);
+    assert(pCP->GetTimeCode() >= 0);
+
+    return pCP;
+}
+
+
+const CuePoint* Cues::GetLast() const
+{
+    LoadCuePoint();  //init cues
+
+    const size_t count = m_count + m_preload_count;
+
+    if (count == 0)  //weird
+        return NULL;
+
+    const size_t index = count - 1;
+
+    CuePoint* const* const pp = m_cue_points;
+    assert(pp);
+
+    CuePoint* const pCP = pp[index];
+    assert(pCP);
+
+    pCP->Load(m_pSegment->m_pReader);
+    assert(pCP->GetTimeCode() >= 0);
+
+    return pCP;
+}
+
+
+const CuePoint* Cues::GetNext(const CuePoint* pCurr) const
+{
+    if (pCurr == NULL)
+        return NULL;
+
+    assert(pCurr->GetTimeCode() >= 0);
+    assert(m_cue_points);
+    assert(m_count >= 1);
+
+    const size_t count = m_count + m_preload_count;
+
+    size_t index = pCurr->m_index;
+    assert(index < count);
+
+    CuePoint* const* const pp = m_cue_points;
+    assert(pp);
+    assert(pp[index] == pCurr);
+
+    ++index;
+
+    if (index >= count)
+        return NULL;
+
+    CuePoint* const pNext = pp[index];
+    assert(pNext);
+
+    pNext->Load(m_pSegment->m_pReader);
+
+    return pNext;
+}
+
+
+const BlockEntry* Cues::GetBlock(
+    const CuePoint* pCP,
+    const CuePoint::TrackPosition* pTP) const
+{
+    if (pCP == NULL)
+        return NULL;
+
+    if (pTP == NULL)
+        return NULL;
+
+    return m_pSegment->GetBlock(*pCP, *pTP);
+}
+
+
+const BlockEntry* Segment::GetBlock(
+    const CuePoint& cp,
+    const CuePoint::TrackPosition& tp)
+{
+    Cluster** const ii = m_clusters;
+    Cluster** i = ii;
+
+    const long count = m_clusterCount + m_clusterPreloadCount;
+
+    Cluster** const jj = ii + count;
+    Cluster** j = jj;
+
+    while (i < j)
+    {
+        //INVARIANT:
+        //[ii, i) < pTP->m_pos
+        //[i, j) ?
+        //[j, jj)  > pTP->m_pos
+
+        Cluster** const k = i + (j - i) / 2;
+        assert(k < jj);
+
+        Cluster* const pCluster = *k;
+        assert(pCluster);
+
+        const long long pos_ = pCluster->m_pos;
+        assert(pos_);
+
+        const long long pos = pos_ * ((pos_ < 0) ? -1 : 1);
+
+        if (pos < tp.m_pos)
+            i = k + 1;
+        else if (pos > tp.m_pos)
+            j = k;
+        else
+            return pCluster->GetEntry(cp, tp);
+    }
+
+    assert(i == j);
+
+    Cluster* const pCluster = Cluster::Parse(this, -1, tp.m_pos);
+    const ptrdiff_t idx = i - m_clusters;
+
+    PreloadCluster(pCluster, idx);
+    assert(m_clusters);
+    assert(m_clusterPreloadCount > 0);
+    assert(m_clusters[idx] == pCluster);
+
+    return pCluster->GetEntry(cp, tp);
+}
+
+
+
+CuePoint::CuePoint(size_t idx, long long pos) :
+    m_index(idx),
+    m_timecode(-1 * pos),
+    m_track_positions(NULL),
+    m_track_positions_count(0)
+{
+    assert(pos > 0);
+}
+
+
+CuePoint::~CuePoint()
+{
+    delete[] m_track_positions;
+}
+
+
+void CuePoint::Load(IMkvReader* pReader)
+{
+    //odbgstream os;
+    //os << "CuePoint::Load(begin): timecode=" << m_timecode << endl;
+
+    if (m_timecode >= 0)  //already loaded
+        return;
+
+    assert(m_track_positions == NULL);
+    assert(m_track_positions_count == 0);
+
+    long long pos_ = -m_timecode;
+
+    long long stop;
+
+    {
+        long len;
+
+        const long long id = ReadUInt(pReader, pos_, len);
+        assert(id == 0x3B);  //CuePoint ID
+        //assert((pos + len) <= stop);
+
+        pos_ += len;  //consume ID
+
+        const long long size = ReadUInt(pReader, pos_, len);
+        assert(size >= 0);
+        //assert((pos + len) <= stop);
+
+        pos_ += len;  //consume Size field
+        //assert((pos + size) <= stop);
+
+        //pos_ now points to start of payload
+
+        stop = pos_ + size;
+    }
+
+    long long pos = pos_;
+
+    //First count number of track positions
+
+    while (pos < stop)
+    {
+        long len;
+
+        const long long id = ReadUInt(pReader, pos, len);
+        assert(id >= 0);  //TODO
+        assert((pos + len) <= stop);
+
+        pos += len;  //consume ID
+
+        const long long size = ReadUInt(pReader, pos, len);
+        assert(size >= 0);
+        assert((pos + len) <= stop);
+
+        pos += len;  //consume Size field
+        assert((pos + size) <= stop);
+
+        if (id == 0x33)  //CueTime ID
+            m_timecode = UnserializeUInt(pReader, pos, size);
+
+        else if (id == 0x37) //CueTrackPosition(s) ID
+            ++m_track_positions_count;
+
+        pos += size;  //consume payload
+        assert(pos <= stop);
+    }
+
+    assert(m_timecode >= 0);
+    assert(m_track_positions_count > 0);
+
+    //os << "CuePoint::Load(cont'd): idpos=" << idpos
+    //   << " timecode=" << m_timecode
+    //   << endl;
+
+    m_track_positions = new TrackPosition[m_track_positions_count];
+
+    //Now parse track positions
+
+    TrackPosition* p = m_track_positions;
+    pos = pos_;
+
+    while (pos < stop)
+    {
+        long len;
+
+        const long long id = ReadUInt(pReader, pos, len);
+        assert(id >= 0);  //TODO
+        assert((pos + len) <= stop);
+
+        pos += len;  //consume ID
+
+        const long long size = ReadUInt(pReader, pos, len);
+        assert(size >= 0);
+        assert((pos + len) <= stop);
+
+        pos += len;  //consume Size field
+        assert((pos + size) <= stop);
+
+        if (id == 0x37) //CueTrackPosition(s) ID
+        {
+            TrackPosition& tp = *p++;
+            tp.Parse(pReader, pos, size);
+        }
+
+        pos += size;  //consume payload
+        assert(pos <= stop);
+    }
+
+    assert(size_t(p - m_track_positions) == m_track_positions_count);
+}
+
+
+
+void CuePoint::TrackPosition::Parse(
+    IMkvReader* pReader,
+    long long start_,
+    long long size_)
+{
+    const long long stop = start_ + size_;
+    long long pos = start_;
+
+    m_track = -1;
+    m_pos = -1;
+    m_block = 1;  //default
+
+    while (pos < stop)
+    {
+        long len;
+
+        const long long id = ReadUInt(pReader, pos, len);
+        assert(id >= 0);  //TODO
+        assert((pos + len) <= stop);
+
+        pos += len;  //consume ID
+
+        const long long size = ReadUInt(pReader, pos, len);
+        assert(size >= 0);
+        assert((pos + len) <= stop);
+
+        pos += len;  //consume Size field
+        assert((pos + size) <= stop);
+
+        if (id == 0x77)  //CueTrack ID
+            m_track = UnserializeUInt(pReader, pos, size);
+
+        else if (id == 0x71)  //CueClusterPos ID
+            m_pos = UnserializeUInt(pReader, pos, size);
+
+        else if (id == 0x1378)  //CueBlockNumber
+            m_block = UnserializeUInt(pReader, pos, size);
+
+        pos += size;  //consume payload
+        assert(pos <= stop);
+    }
+
+    assert(m_pos >= 0);
+    //assert(m_track > 0);
+    //assert(m_block > 0);
+}
+
+
+const CuePoint::TrackPosition* CuePoint::Find(const Track* pTrack) const
+{
+    assert(pTrack);
+
+    const long long n = pTrack->GetNumber();
+
+    const TrackPosition* i = m_track_positions;
+    const TrackPosition* const j = i + m_track_positions_count;
+
+    while (i != j)
+    {
+        const TrackPosition& p = *i++;
+
+        if (p.m_track == n)
+            return &p;
+    }
+
+    return NULL;  //no matching track number found
+}
+
+
+long long CuePoint::GetTimeCode() const
+{
+    return m_timecode;
+}
+
+long long CuePoint::GetTime(Segment* pSegment) const
+{
+    assert(pSegment);
+    assert(m_timecode >= 0);
+
+    const SegmentInfo* const pInfo = pSegment->GetInfo();
+    assert(pInfo);
+
+    const long long scale = pInfo->GetTimeCodeScale();
+    assert(scale >= 1);
+
+    const long long time = scale * m_timecode;
+
+    return time;
+}
+
+
+long long Segment::Unparsed() const
+{
+    const long long stop = m_start + m_size;
+
+    const long long result = stop - m_pos;
+    assert(result >= 0);
+
+    return result;
+}
+
+
+Cluster* Segment::GetFirst()
+{
+    if ((m_clusters == NULL) || (m_clusterCount <= 0))
+       return &m_eos;
+
+    Cluster* const pCluster = m_clusters[0];
+    assert(pCluster);
+
+    return pCluster;
+}
+
+
+Cluster* Segment::GetLast()
+{
+    if ((m_clusters == NULL) || (m_clusterCount <= 0))
+        return &m_eos;
+
+    const long idx = m_clusterCount - 1;
+
+    Cluster* const pCluster = m_clusters[idx];
+    assert(pCluster);
+
+    return pCluster;
+}
+
+
+unsigned long Segment::GetCount() const
+{
+    return m_clusterCount;
+}
+
+
+Cluster* Segment::GetNext(const Cluster* pCurr)
+{
+    assert(pCurr);
+    assert(pCurr != &m_eos);
+    assert(m_clusters);
+
+    long idx =  pCurr->m_index;
+
+    if (idx >= 0)
+    {
+        assert(m_clusterCount > 0);
+        assert(idx < m_clusterCount);
+        assert(pCurr == m_clusters[idx]);
+
+        ++idx;
+
+        if (idx >= m_clusterCount)
+            return &m_eos;  //caller will LoadCluster as desired
+
+        Cluster* const pNext = m_clusters[idx];
+        assert(pNext);
+        assert(pNext->m_index >= 0);
+        assert(pNext->m_index == idx);
+
+        return pNext;
+    }
+
+    assert(m_clusterPreloadCount > 0);
+
+    const long long off_ = pCurr->m_pos;
+    const long long off = off_ * ((off_ < 0) ? -1 : 1);
+
+    long long pos = m_start + off;
+    const long long stop = m_start + m_size;  //end of segment
+
+    {
+        long len;
+
+        long long result = GetUIntLength(m_pReader, pos, len);
+        assert(result == 0);  //TODO
+        assert((pos + len) <= stop);  //TODO
+
+        const long long id = ReadUInt(m_pReader, pos, len);
+        assert(id == 0x0F43B675);  //Cluster ID   //TODO
+
+        pos += len;  //consume ID
+
+        //Read Size
+        result = GetUIntLength(m_pReader, pos, len);
+        assert(result == 0);  //TODO
+        assert((pos + len) <= stop);  //TODO
+
+        const long long size = ReadUInt(m_pReader, pos, len);
+        assert(size > 0);  //TODO
+        assert((pCurr->m_size <= 0) || (pCurr->m_size == size));
+
+        pos += len;  //consume length of size of element
+        assert((pos + size) <= stop);  //TODO
+
+        //Pos now points to start of payload
+
+        pos += size;  //consume payload
+    }
+
+    long long off_next = 0;
+
+    while (pos < stop)
+    {
+        long len;
+
+        long long result = GetUIntLength(m_pReader, pos, len);
+        assert(result == 0);  //TODO
+        assert((pos + len) <= stop);  //TODO
+
+        const long long idpos = pos;  //pos of next (potential) cluster
+
+        const long long id = ReadUInt(m_pReader, idpos, len);
+        assert(id > 0);  //TODO
+
+        pos += len;  //consume ID
+
+        //Read Size
+        result = GetUIntLength(m_pReader, pos, len);
+        assert(result == 0);  //TODO
+        assert((pos + len) <= stop);  //TODO
+
+        const long long size = ReadUInt(m_pReader, pos, len);
+        assert(size >= 0);  //TODO
+
+        pos += len;  //consume length of size of element
+        assert((pos + size) <= stop);  //TODO
+
+        //Pos now points to start of payload
+
+        if (size == 0)  //weird
+            continue;
+
+        if (id == 0x0F43B675)  //Cluster ID
+        {
+            off_next = idpos - m_start;
+            break;
+        }
+
+        pos += size;  //consume payload
+    }
+
+    if (off_next <= 0)
+        return 0;
+
+    Cluster** const ii = m_clusters + m_clusterCount;
+    Cluster** i = ii;
+
+    Cluster** const jj = ii + m_clusterPreloadCount;
+    Cluster** j = jj;
+
+    while (i < j)
+    {
+        //INVARIANT:
+        //[0, i) < pos_next
+        //[i, j) ?
+        //[j, jj)  > pos_next
+
+        Cluster** const k = i + (j - i) / 2;
+        assert(k < jj);
+
+        Cluster* const pNext = *k;
+        assert(pNext);
+        assert(pNext->m_index < 0);
+
+        const long long pos_ = pNext->m_pos;
+        assert(pos_);
+
+        pos = pos_ * ((pos_ < 0) ? -1 : 1);
+
+        if (pos < off_next)
+            i = k + 1;
+        else if (pos > off_next)
+            j = k;
+        else
+            return pNext;
+    }
+
+    assert(i == j);
+
+    Cluster* const pNext = Cluster::Parse(this, -1, off_next);
+    const ptrdiff_t idx_next = i - m_clusters;  //insertion position
+
+    PreloadCluster(pNext, idx_next);
+    assert(m_clusters);
+    assert(idx_next < m_clusterSize);
+    assert(m_clusters[idx_next] == pNext);
+
+    return pNext;
+}
+
+
+Cluster* Segment::FindCluster(long long time_ns)
+{
+    if ((m_clusters == NULL) || (m_clusterCount <= 0))
+        return &m_eos;
+
+    {
+        Cluster* const pCluster = m_clusters[0];
+        assert(pCluster);
+        assert(pCluster->m_index == 0);
+
+        if (time_ns <= pCluster->GetTime())
+            return pCluster;
+    }
+
+    //Binary search of cluster array
+
+    long i = 0;
+    long j = m_clusterCount;
+
+    while (i < j)
+    {
+        //INVARIANT:
+        //[0, i) <= time_ns
+        //[i, j) ?
+        //[j, m_clusterCount)  > time_ns
+
+        const long k = i + (j - i) / 2;
+        assert(k < m_clusterCount);
+
+        Cluster* const pCluster = m_clusters[k];
+        assert(pCluster);
+        assert(pCluster->m_index == k);
+
+        const long long t = pCluster->GetTime();
+
+        if (t <= time_ns)
+            i = k + 1;
+        else
+            j = k;
+
+        assert(i <= j);
+    }
+
+    assert(i == j);
+    assert(i > 0);
+    assert(i <= m_clusterCount);
+
+    const long k = i - 1;
+
+    Cluster* const pCluster = m_clusters[k];
+    assert(pCluster);
+    assert(pCluster->m_index == k);
+    assert(pCluster->GetTime() <= time_ns);
+
+    return pCluster;
+}
+
+
+const BlockEntry* Segment::Seek(
+    long long time_ns,
+    const Track* pTrack)
+{
+    assert(pTrack);
+
+    if ((m_clusters == NULL) || (m_clusterCount <= 0))
+        return pTrack->GetEOS();
+
+    Cluster** const i = m_clusters;
+    assert(i);
+
+    {
+        Cluster* const pCluster = *i;
+        assert(pCluster);
+        assert(pCluster->m_index == 0);  //m_clusterCount > 0
+        assert(pCluster->m_pSegment == this);
+
+        if (time_ns <= pCluster->GetTime())
+            return pCluster->GetEntry(pTrack);
+    }
+
+    Cluster** const j = i + m_clusterCount;
+
+    if (pTrack->GetType() == 2)  //audio
+    {
+        //TODO: we could decide to use cues for this, as we do for video.
+        //But we only use it for video because looking around for a keyframe
+        //can get expensive.  Audio doesn't require anything special so a
+        //straight cluster search is good enough (we assume).
+
+        Cluster** lo = i;
+        Cluster** hi = j;
+
+        while (lo < hi)
+        {
+            //INVARIANT:
+            //[i, lo) <= time_ns
+            //[lo, hi) ?
+            //[hi, j)  > time_ns
+
+            Cluster** const mid = lo + (hi - lo) / 2;
+            assert(mid < hi);
+
+            Cluster* const pCluster = *mid;
+            assert(pCluster);
+            assert(pCluster->m_index == long(mid - m_clusters));
+            assert(pCluster->m_pSegment == this);
+
+            const long long t = pCluster->GetTime();
+
+            if (t <= time_ns)
+                lo = mid + 1;
+            else
+                hi = mid;
+
+            assert(lo <= hi);
+        }
+
+        assert(lo == hi);
+        assert(lo > i);
+        assert(lo <= j);
+
+        Cluster* const pCluster = *--lo;
+        assert(pCluster);
+        assert(pCluster->GetTime() <= time_ns);
+
+        return pCluster->GetEntry(pTrack);
+    }
+
+    assert(pTrack->GetType() == 1);  //video
+
+    Cluster** lo = i;
+    Cluster** hi = j;
+
+    while (lo < hi)
+    {
+        //INVARIANT:
+        //[i, lo) <= time_ns
+        //[lo, hi) ?
+        //[hi, j)  > time_ns
+
+        Cluster** const mid = lo + (hi - lo) / 2;
+        assert(mid < hi);
+
+        Cluster* const pCluster = *mid;
+        assert(pCluster);
+
+        const long long t = pCluster->GetTime();
+
+        if (t <= time_ns)
+            lo = mid + 1;
+        else
+            hi = mid;
+
+        assert(lo <= hi);
+    }
+
+    assert(lo == hi);
+    assert(lo > i);
+    assert(lo <= j);
+
+    Cluster* pCluster = *--lo;
+    assert(pCluster);
+    assert(pCluster->GetTime() <= time_ns);
+
+    {
+        const BlockEntry* const pBlockEntry = pCluster->GetEntry(pTrack);
+        assert(pBlockEntry);
+
+        if (!pBlockEntry->EOS())  //found a keyframe
+        {
+            const Block* const pBlock = pBlockEntry->GetBlock();
+            assert(pBlock);
+
+            //TODO: this isn't necessarily the keyframe we want,
+            //since there might another keyframe on this same
+            //cluster with a greater timecode that but that is
+            //still less than the requested time.  For now we
+            //simply return the first keyframe we find.
+
+            if (pBlock->GetTime(pCluster) <= time_ns)
+                return pBlockEntry;
+        }
+    }
+
+    const VideoTrack* const pVideo = static_cast<const VideoTrack*>(pTrack);
+
+    while (lo != i)
+    {
+        pCluster = *--lo;
+        assert(pCluster);
+        assert(pCluster->GetTime() <= time_ns);
+
+        const BlockEntry* const pBlockEntry = pCluster->GetMaxKey(pVideo);
+        assert(pBlockEntry);
+
+        if (!pBlockEntry->EOS())
+            return pBlockEntry;
+    }
+
+    //weird: we're on the first cluster, but no keyframe found
+    //should never happen but we must return something anyway
+
+    return pTrack->GetEOS();
+}
+
+
+#if 0
+bool Segment::SearchCues(
+    long long time_ns,
+    Track* pTrack,
+    Cluster*& pCluster,
+    const BlockEntry*& pBlockEntry,
+    const CuePoint*& pCP,
+    const CuePoint::TrackPosition*& pTP)
+{
+    if (pTrack->GetType() != 1)  //not video
+        return false;  //TODO: for now, just handle video stream
+
+    if (m_pCues == NULL)
+        return false;
+
+    if (!m_pCues->Find(time_ns, pTrack, pCP, pTP))
+        return false;  //weird
+
+    assert(pCP);
+    assert(pTP);
+    assert(pTP->m_track == pTrack->GetNumber());
+
+    //We have the cue point and track position we want,
+    //so we now need to search for the cluster having
+    //the indicated position.
+
+    return GetCluster(pCP, pTP, pCluster, pBlockEntry);
+}
+#endif
+
+
+Tracks* Segment::GetTracks() const
+{
+    return m_pTracks;
+}
+
+
+const SegmentInfo* Segment::GetInfo() const
+{
+    return m_pInfo;
+}
+
+
+const Cues* Segment::GetCues() const
+{
+    return m_pCues;
+}
+
+
+long long Segment::GetDuration() const
+{
+    assert(m_pInfo);
+    return m_pInfo->GetDuration();
+}
+
+
+SegmentInfo::SegmentInfo(Segment* pSegment, long long start, long long size_) :
+    m_pSegment(pSegment),
+    m_start(start),
+    m_size(size_),
+    m_pMuxingAppAsUTF8(NULL),
+    m_pWritingAppAsUTF8(NULL),
+    m_pTitleAsUTF8(NULL)
+{
+    IMkvReader* const pReader = m_pSegment->m_pReader;
+
+    long long pos = start;
+    const long long stop = start + size_;
+
+    m_timecodeScale = 1000000;
+    m_duration = -1;
+
+    while (pos < stop)
+    {
+        if (Match(pReader, pos, 0x0AD7B1, m_timecodeScale))
+            assert(m_timecodeScale > 0);
+
+        else if (Match(pReader, pos, 0x0489, m_duration))
+            assert(m_duration >= 0);
+
+        else if (Match(pReader, pos, 0x0D80, m_pMuxingAppAsUTF8))   //[4D][80]
+            assert(m_pMuxingAppAsUTF8);
+
+        else if (Match(pReader, pos, 0x1741, m_pWritingAppAsUTF8))  //[57][41]
+            assert(m_pWritingAppAsUTF8);
+
+        else if (Match(pReader, pos, 0x3BA9, m_pTitleAsUTF8))       //[7B][A9]
+            assert(m_pTitleAsUTF8);
+
+        else
+        {
+            long len;
+
+            const long long id = ReadUInt(pReader, pos, len);
+            //id;
+            assert(id >= 0);
+            assert((pos + len) <= stop);
+
+            pos += len;  //consume id
+            assert((stop - pos) > 0);
+
+            const long long size = ReadUInt(pReader, pos, len);
+            assert(size >= 0);
+            assert((pos + len) <= stop);
+
+            pos += len + size;  //consume size and payload
+            assert(pos <= stop);
+        }
+    }
+
+    assert(pos == stop);
+}
+
+SegmentInfo::~SegmentInfo()
+{
+    if (m_pMuxingAppAsUTF8)
+    {
+        delete[] m_pMuxingAppAsUTF8;
+        m_pMuxingAppAsUTF8 = NULL;
+    }
+
+    if (m_pWritingAppAsUTF8)
+    {
+        delete[] m_pWritingAppAsUTF8;
+        m_pWritingAppAsUTF8 = NULL;
+    }
+
+    if (m_pTitleAsUTF8)
+    {
+        delete[] m_pTitleAsUTF8;
+        m_pTitleAsUTF8 = NULL;
+    }
+}
+
+long long SegmentInfo::GetTimeCodeScale() const
+{
+    return m_timecodeScale;
+}
+
+
+long long SegmentInfo::GetDuration() const
+{
+    if (m_duration < 0)
+        return -1;
+
+    assert(m_timecodeScale >= 1);
+
+    const double dd = double(m_duration) * double(m_timecodeScale);
+    const long long d = static_cast<long long>(dd);
+
+    return d;
+}
+
+const char* SegmentInfo::GetMuxingAppAsUTF8() const
+{
+    return m_pMuxingAppAsUTF8;
+}
+
+
+const char* SegmentInfo::GetWritingAppAsUTF8() const
+{
+    return m_pWritingAppAsUTF8;
+}
+
+const char* SegmentInfo::GetTitleAsUTF8() const
+{
+    return m_pTitleAsUTF8;
+}
+
+Track::Track(Segment* pSegment, const Info& i) :
+    m_pSegment(pSegment),
+    m_info(i)
+{
+}
+
+Track::~Track()
+{
+    Info& info = const_cast<Info&>(m_info);
+    info.Clear();
+}
+
+Track::Info::Info():
+    type(-1),
+    number(-1),
+    uid(-1),
+    nameAsUTF8(NULL),
+    codecId(NULL),
+    codecPrivate(NULL),
+    codecPrivateSize(0),
+    codecNameAsUTF8(NULL)
+{
+}
+
+
+void Track::Info::Clear()
+{
+    delete[] nameAsUTF8;
+    nameAsUTF8 = NULL;
+
+    delete[] codecId;
+    codecId = NULL;
+
+    delete[] codecPrivate;
+    codecPrivate = NULL;
+
+    codecPrivateSize = 0;
+
+    delete[] codecNameAsUTF8;
+    codecNameAsUTF8 = NULL;
+}
+
+const BlockEntry* Track::GetEOS() const
+{
+    return &m_eos;
+}
+
+long long Track::GetType() const
+{
+    return m_info.type;
+}
+
+long long Track::GetNumber() const
+{
+    return m_info.number;
+}
+
+const char* Track::GetNameAsUTF8() const
+{
+    return m_info.nameAsUTF8;
+}
+
+const char* Track::GetCodecNameAsUTF8() const
+{
+    return m_info.codecNameAsUTF8;
+}
+
+
+const char* Track::GetCodecId() const
+{
+    return m_info.codecId;
+}
+
+const unsigned char* Track::GetCodecPrivate(size_t& size) const
+{
+    size = m_info.codecPrivateSize;
+    return m_info.codecPrivate;
+}
+
+
+long Track::GetFirst(const BlockEntry*& pBlockEntry) const
+{
+    Cluster* pCluster = m_pSegment->GetFirst();
+
+    //If Segment::GetFirst returns NULL, then this must be a network
+    //download, and we haven't loaded any clusters yet.  In this case,
+    //returning NULL from Track::GetFirst means the same thing.
+
+    for (int i = 0; i < 100; ++i)  //arbitrary upper bound
+    {
+        if (pCluster == NULL)
+        {
+            pBlockEntry = GetEOS();
+            return 1;
+        }
+
+        if (pCluster->EOS())
+        {
+            if (m_pSegment->Unparsed() <= 0)  //all clusters have been loaded
+            {
+                pBlockEntry = GetEOS();
+                return 1;
+            }
+
+            pBlockEntry = 0;
+            return E_BUFFER_NOT_FULL;
+        }
+
+        pBlockEntry = pCluster->GetFirst();
+
+        while (pBlockEntry)
+        {
+            const Block* const pBlock = pBlockEntry->GetBlock();
+            assert(pBlock);
+
+            if (pBlock->GetTrackNumber() == m_info.number)
+                return 0;
+
+            pBlockEntry = pCluster->GetNext(pBlockEntry);
+        }
+
+        pCluster = m_pSegment->GetNext(pCluster);
+    }
+
+    //NOTE: if we get here, it means that we didn't find a block with
+    //a matching track number.  We interpret that as an error (which
+    //might be too conservative).
+
+    pBlockEntry = GetEOS();  //so we can return a non-NULL value
+    return 1;
+}
+
+
+long Track::GetNext(
+    const BlockEntry* pCurrEntry,
+    const BlockEntry*& pNextEntry) const
+{
+    assert(pCurrEntry);
+    assert(!pCurrEntry->EOS());  //?
+
+    const Block* const pCurrBlock = pCurrEntry->GetBlock();
+    assert(pCurrBlock->GetTrackNumber() == m_info.number);
+
+    Cluster* pCluster = pCurrEntry->GetCluster();
+    assert(pCluster);
+    assert(!pCluster->EOS());
+
+    pNextEntry = pCluster->GetNext(pCurrEntry);
+
+    for (int i = 0; i < 100; ++i)  //arbitrary upper bound to search
+    {
+        while (pNextEntry)
+        {
+            const Block* const pNextBlock = pNextEntry->GetBlock();
+            assert(pNextBlock);
+
+            if (pNextBlock->GetTrackNumber() == m_info.number)
+                return 0;
+
+            pNextEntry = pCluster->GetNext(pNextEntry);
+        }
+
+        pCluster = m_pSegment->GetNext(pCluster);
+
+        if (pCluster == NULL)
+        {
+            pNextEntry = GetEOS();
+            return 1;
+        }
+
+        if (pCluster->EOS())
+        {
+            if (m_pSegment->Unparsed() <= 0)   //all clusters have been loaded
+            {
+                pNextEntry = GetEOS();
+                return 1;
+            }
+
+            //TODO: there is a potential O(n^2) problem here: we tell the
+            //caller to (pre)load another cluster, which he does, but then he
+            //calls GetNext again, which repeats the same search.  This is
+            //a pathological case, since the only way it can happen is if
+            //there exists a long sequence of clusters none of which contain a
+            // block from this track.  One way around this problem is for the
+            //caller to be smarter when he loads another cluster: don't call
+            //us back until you have a cluster that contains a block from this
+            //track. (Of course, that's not cheap either, since our caller
+            //would have to scan the each cluster as it's loaded, so that
+            //would just push back the problem.)
+
+            pNextEntry = NULL;
+            return E_BUFFER_NOT_FULL;
+        }
+
+        pNextEntry = pCluster->GetFirst();
+    }
+
+    //NOTE: if we get here, it means that we didn't find a block with
+    //a matching track number after lots of searching, so we give
+    //up trying.
+
+    pNextEntry = GetEOS();  //so we can return a non-NULL value
+    return 1;
+}
+
+
+Track::EOSBlock::EOSBlock()
+{
+}
+
+
+bool Track::EOSBlock::EOS() const
+{
+    return true;
+}
+
+
+Cluster* Track::EOSBlock::GetCluster() const
+{
+    return NULL;
+}
+
+
+size_t Track::EOSBlock::GetIndex() const
+{
+    return 0;
+}
+
+
+const Block* Track::EOSBlock::GetBlock() const
+{
+    return NULL;
+}
+
+
+bool Track::EOSBlock::IsBFrame() const
+{
+    return false;
+}
+
+
+VideoTrack::VideoTrack(Segment* pSegment, const Info& i) :
+    Track(pSegment, i),
+    m_width(-1),
+    m_height(-1),
+    m_rate(-1)
+{
+    assert(i.type == 1);
+    assert(i.number > 0);
+
+    IMkvReader* const pReader = pSegment->m_pReader;
+
+    const Settings& s = i.settings;
+    assert(s.start >= 0);
+    assert(s.size >= 0);
+
+    long long pos = s.start;
+    assert(pos >= 0);
+
+    const long long stop = pos + s.size;
+
+    while (pos < stop)
+    {
+#ifdef _DEBUG
+        long len;
+        const long long id = ReadUInt(pReader, pos, len);
+        assert(id >= 0);  //TODO: handle error case
+        assert((pos + len) <= stop);
+#endif
+        if (Match(pReader, pos, 0x30, m_width))
+            ;
+        else if (Match(pReader, pos, 0x3A, m_height))
+            ;
+        else if (Match(pReader, pos, 0x0383E3, m_rate))
+            ;
+        else
+        {
+            long len;
+            const long long id = ReadUInt(pReader, pos, len);
+            assert(id >= 0);  //TODO: handle error case
+            assert((pos + len) <= stop);
+
+            pos += len;  //consume id
+
+            const long long size = ReadUInt(pReader, pos, len);
+            assert(size >= 0);  //TODO: handle error case
+            assert((pos + len) <= stop);
+
+            pos += len;  //consume length of size
+            assert((pos + size) <= stop);
+
+            //pos now designates start of payload
+
+            pos += size;  //consume payload
+            assert(pos <= stop);
+        }
+    }
+
+    return;
+}
+
+
+bool VideoTrack::VetEntry(const BlockEntry* pBlockEntry) const
+{
+    assert(pBlockEntry);
+
+    const Block* const pBlock = pBlockEntry->GetBlock();
+    assert(pBlock);
+    assert(pBlock->GetTrackNumber() == m_info.number);
+
+    return pBlock->IsKey();
+}
+
+
+long long VideoTrack::GetWidth() const
+{
+    return m_width;
+}
+
+
+long long VideoTrack::GetHeight() const
+{
+    return m_height;
+}
+
+
+double VideoTrack::GetFrameRate() const
+{
+    return m_rate;
+}
+
+
+AudioTrack::AudioTrack(Segment* pSegment, const Info& i) :
+    Track(pSegment, i),
+    m_rate(0.0),
+    m_channels(0),
+    m_bitDepth(-1)
+{
+    assert(i.type == 2);
+    assert(i.number > 0);
+
+    IMkvReader* const pReader = pSegment->m_pReader;
+
+    const Settings& s = i.settings;
+    assert(s.start >= 0);
+    assert(s.size >= 0);
+
+    long long pos = s.start;
+    assert(pos >= 0);
+
+    const long long stop = pos + s.size;
+
+    while (pos < stop)
+    {
+#ifdef _DEBUG
+        long len;
+        const long long id = ReadUInt(pReader, pos, len);
+        assert(id >= 0);  //TODO: handle error case
+        assert((pos + len) <= stop);
+#endif
+        if (Match(pReader, pos, 0x35, m_rate))
+            ;
+        else if (Match(pReader, pos, 0x1F, m_channels))
+            ;
+        else if (Match(pReader, pos, 0x2264, m_bitDepth))
+            ;
+        else
+        {
+            long len;
+            const long long id = ReadUInt(pReader, pos, len);
+            assert(id >= 0);  //TODO: handle error case
+            assert((pos + len) <= stop);
+
+            pos += len;  //consume id
+
+            const long long size = ReadUInt(pReader, pos, len);
+            assert(size >= 0);  //TODO: handle error case
+            assert((pos + len) <= stop);
+
+            pos += len;  //consume length of size
+            assert((pos + size) <= stop);
+
+            //pos now designates start of payload
+
+            pos += size;  //consume payload
+            assert(pos <= stop);
+        }
+    }
+
+    return;
+}
+
+
+bool AudioTrack::VetEntry(const BlockEntry* pBlockEntry) const
+{
+    assert(pBlockEntry);
+
+    const Block* const pBlock = pBlockEntry->GetBlock();
+    assert(pBlock);
+    assert(pBlock->GetTrackNumber() == m_info.number);
+
+    return true;
+}
+
+
+double AudioTrack::GetSamplingRate() const
+{
+    return m_rate;
+}
+
+
+long long AudioTrack::GetChannels() const
+{
+    return m_channels;
+}
+
+long long AudioTrack::GetBitDepth() const
+{
+    return m_bitDepth;
+}
+
+Tracks::Tracks(Segment* pSegment, long long start, long long size_) :
+    m_pSegment(pSegment),
+    m_start(start),
+    m_size(size_),
+    m_trackEntries(NULL),
+    m_trackEntriesEnd(NULL)
+{
+    long long stop = m_start + m_size;
+    IMkvReader* const pReader = m_pSegment->m_pReader;
+
+    long long pos1 = m_start;
+    int count = 0;
+
+    while (pos1 < stop)
+    {
+        long len;
+        const long long id = ReadUInt(pReader, pos1, len);
+        assert(id >= 0);
+        assert((pos1 + len) <= stop);
+
+        pos1 += len;  //consume id
+
+        const long long size = ReadUInt(pReader, pos1, len);
+        assert(size >= 0);
+        assert((pos1 + len) <= stop);
+
+        pos1 += len;  //consume length of size
+
+        //pos now desinates start of element
+        if (id == 0x2E)  //TrackEntry ID
+            ++count;
+
+        pos1 += size;  //consume payload
+        assert(pos1 <= stop);
+    }
+
+    if (count <= 0)
+        return;
+
+    m_trackEntries = new Track*[count];
+    m_trackEntriesEnd = m_trackEntries;
+
+    long long pos = m_start;
+
+    while (pos < stop)
+    {
+        long len;
+        const long long id = ReadUInt(pReader, pos, len);
+        assert(id >= 0);
+        assert((pos + len) <= stop);
+
+        pos += len;  //consume id
+
+        const long long size1 = ReadUInt(pReader, pos, len);
+        assert(size1 >= 0);
+        assert((pos + len) <= stop);
+
+        pos += len;  //consume length of size
+
+        //pos now desinates start of element
+
+        if (id == 0x2E)  //TrackEntry ID
+            ParseTrackEntry(pos, size1, *m_trackEntriesEnd++);
+
+        pos += size1;  //consume payload
+        assert(pos <= stop);
+    }
+}
+
+
+unsigned long Tracks::GetTracksCount() const
+{
+    const ptrdiff_t result = m_trackEntriesEnd - m_trackEntries;
+    assert(result >= 0);
+
+    return static_cast<unsigned long>(result);
+}
+
+
+void Tracks::ParseTrackEntry(
+    long long start,
+    long long size,
+    Track*& pTrack)
+{
+    IMkvReader* const pReader = m_pSegment->m_pReader;
+
+    long long pos = start;
+    const long long stop = start + size;
+
+    Track::Info i;
+
+    Track::Settings videoSettings;
+    videoSettings.start = -1;
+
+    Track::Settings audioSettings;
+    audioSettings.start = -1;
+
+    while (pos < stop)
+    {
+#ifdef _DEBUG
+        long len;
+        const long long id = ReadUInt(pReader, pos, len);
+        len;
+        id;
+#endif
+        if (Match(pReader, pos, 0x57, i.number))
+            assert(i.number > 0);
+        else if (Match(pReader, pos, 0x33C5, i.uid))
+            ;
+        else if (Match(pReader, pos, 0x03, i.type))
+            ;
+        else if (Match(pReader, pos, 0x136E, i.nameAsUTF8))
+            assert(i.nameAsUTF8);
+        else if (Match(pReader, pos, 0x06, i.codecId))
+            ;
+        else if (Match(pReader,
+                       pos,
+                       0x23A2,
+                       i.codecPrivate,
+                       i.codecPrivateSize))
+            ;
+        else if (Match(pReader, pos, 0x058688, i.codecNameAsUTF8))
+            assert(i.codecNameAsUTF8);
+        else
+        {
+            long len;
+
+            const long long id = ReadUInt(pReader, pos, len);
+            assert(id >= 0);  //TODO: handle error case
+            assert((pos + len) <= stop);
+
+            pos += len;  //consume id
+
+            const long long size = ReadUInt(pReader, pos, len);
+            assert(size >= 0);  //TODO: handle error case
+            assert((pos + len) <= stop);
+
+            pos += len;  //consume length of size
+            const long long start = pos;
+
+            pos += size;  //consume payload
+            assert(pos <= stop);
+
+            if (id == 0x60)
+            {
+                videoSettings.start = start;
+                videoSettings.size = size;
+            }
+            else if (id == 0x61)
+            {
+                audioSettings.start = start;
+                audioSettings.size = size;
+            }
+        }
+    }
+
+    assert(pos == stop);
+    //TODO: propertly vet info.number, to ensure both its existence,
+    //and that it is unique among all tracks.
+    assert(i.number > 0);
+
+    //TODO: vet settings, to ensure that video settings (0x60)
+    //were specified when type = 1, and that audio settings (0x61)
+    //were specified when type = 2.
+    if (i.type == 1)  //video
+    {
+        assert(audioSettings.start < 0);
+        assert(videoSettings.start >= 0);
+
+        i.settings = videoSettings;
+
+        VideoTrack* const t = new VideoTrack(m_pSegment, i);
+        assert(t);  //TODO
+        pTrack = t;
+    }
+    else if (i.type == 2)  //audio
+    {
+        assert(videoSettings.start < 0);
+        assert(audioSettings.start >= 0);
+
+        i.settings = audioSettings;
+
+        AudioTrack* const t = new  AudioTrack(m_pSegment, i);
+        assert(t);  //TODO
+        pTrack = t;
+    }
+    else
+    {
+        // for now we do not support other track types yet.
+        // TODO: support other track types
+        i.Clear();
+
+        pTrack = NULL;
+    }
+
+    return;
+}
+
+
+Tracks::~Tracks()
+{
+    Track** i = m_trackEntries;
+    Track** const j = m_trackEntriesEnd;
+
+    while (i != j)
+    {
+        Track* const pTrack = *i++;
+        delete pTrack;
+    }
+
+    delete[] m_trackEntries;
+}
+
+
+Track* Tracks::GetTrackByNumber(unsigned long tn_) const
+{
+    const long long tn = tn_;
+
+    Track** i = m_trackEntries;
+    Track** const j = m_trackEntriesEnd;
+
+    while (i != j)
+    {
+        Track* const pTrack = *i++;
+
+        if (pTrack == NULL)
+            continue;
+
+        if (tn == pTrack->GetNumber())
+            return pTrack;
+    }
+
+    return NULL;  //not found
+}
+
+
+Track* Tracks::GetTrackByIndex(unsigned long idx) const
+{
+    const ptrdiff_t count = m_trackEntriesEnd - m_trackEntries;
+
+    if (idx >= static_cast<unsigned long>(count))
+         return NULL;
+
+    return m_trackEntries[idx];
+}
+
+
+void Cluster::Load()
+{
+    assert(m_pSegment);
+    assert(m_pos);
+    assert(m_size);
+
+    if (m_pos > 0)  //loaded
+    {
+        assert(m_size > 0);
+        assert(m_timecode >= 0);
+        return;
+    }
+
+    assert(m_pos < 0);  //not loaded yet
+    assert(m_size < 0);
+    assert(m_timecode < 0);
+
+    IMkvReader* const pReader = m_pSegment->m_pReader;
+
+    m_pos *= -1;                                  //relative to segment
+    long long pos = m_pSegment->m_start + m_pos;  //absolute
+
+    long len;
+
+    const long long id_ = ReadUInt(pReader, pos, len);
+    assert(id_ >= 0);
+    assert(id_ == 0x0F43B675);  //Cluster ID
+
+    pos += len;  //consume id
+
+    const long long size_ = ReadUInt(pReader, pos, len);
+    assert(size_ >= 0);
+
+    pos += len;  //consume size
+
+    m_size = size_;
+    const long long stop = pos + size_;
+
+    long long timecode = -1;
+
+    while (pos < stop)
+    {
+        if (Match(pReader, pos, 0x67, timecode))
+            break;
+        else
+        {
+            const long long id = ReadUInt(pReader, pos, len);
+            assert(id >= 0);  //TODO
+            assert((pos + len) <= stop);
+
+            pos += len;  //consume id
+
+            const long long size = ReadUInt(pReader, pos, len);
+            assert(size >= 0);  //TODO
+            assert((pos + len) <= stop);
+
+            pos += len;  //consume size
+
+            if (id == 0x20)  //BlockGroup ID
+                break;
+
+            if (id == 0x23)  //SimpleBlock ID
+                break;
+
+            pos += size;  //consume payload
+            assert(pos <= stop);
+        }
+    }
+
+    assert(pos <= stop);
+    assert(timecode >= 0);
+
+    m_timecode = timecode;
+}
+
+
+Cluster* Cluster::Parse(
+    Segment* pSegment,
+    long idx,
+    long long off)
+{
+    assert(pSegment);
+    assert(off >= 0);
+    assert(off < pSegment->m_size);
+
+    Cluster* const pCluster = new Cluster(pSegment, idx, -off);
+    assert(pCluster);
+
+    return pCluster;
+}
+
+
+Cluster::Cluster() :
+    m_pSegment(NULL),
+    m_index(0),
+    m_pos(0),
+    m_size(0),
+    m_timecode(0),
+    m_entries(NULL),
+    m_entriesCount(0)
+{
+}
+
+
+Cluster::Cluster(
+    Segment* pSegment,
+    long idx,
+    long long off) :
+    m_pSegment(pSegment),
+    m_index(idx),
+    m_pos(off),
+    m_size(-1),
+    m_timecode(-1),
+    m_entries(NULL),
+    m_entriesCount(0)
+{
+}
+
+
+Cluster::~Cluster()
+{
+    BlockEntry** i = m_entries;
+    BlockEntry** const j = m_entries + m_entriesCount;
+
+    while (i != j)
+    {
+         BlockEntry* p = *i++;
+         assert(p);
+
+         delete p;
+    }
+
+    delete[] m_entries;
+}
+
+
+bool Cluster::EOS() const
+{
+    return (m_pSegment == NULL);
+}
+
+
+void Cluster::LoadBlockEntries()
+{
+    if (m_entries)
+        return;
+
+    assert(m_pSegment);
+    assert(m_pos);
+    assert(m_size);
+    assert(m_entriesCount == 0);
+
+    IMkvReader* const pReader = m_pSegment->m_pReader;
+
+    if (m_pos < 0)
+        m_pos *= -1;  //relative to segment
+
+    long long pos = m_pSegment->m_start + m_pos;  //absolute
+
+    {
+        long len;
+
+        const long long id = ReadUInt(pReader, pos, len);
+        id;
+        assert(id >= 0);
+        assert(id == 0x0F43B675);  //Cluster ID
+
+        pos += len;  //consume id
+
+        const long long size = ReadUInt(pReader, pos, len);
+        assert(size > 0);
+
+        pos += len;  //consume size
+
+        //pos now points to start of payload
+
+        if (m_size >= 0)
+            assert(size == m_size);
+        else
+            m_size = size;
+    }
+
+    const long long stop = pos + m_size;
+    long long timecode = -1;  //of cluster itself
+
+    //First count the number of entries
+
+    long long idx = pos;  //points to start of payload
+    m_entriesCount = 0;
+
+    while (idx < stop)
+    {
+        if (Match(pReader, idx, 0x67, timecode))
+        {
+            if (m_timecode >= 0)
+                assert(timecode == m_timecode);
+            else
+                m_timecode = timecode;
+        }
+        else
+        {
+            long len;
+
+            const long long id = ReadUInt(pReader, idx, len);
+            assert(id >= 0);  //TODO
+            assert((idx + len) <= stop);
+
+            idx += len;  //consume id
+
+            const long long size = ReadUInt(pReader, idx, len);
+            assert(size >= 0);  //TODO
+            assert((idx + len) <= stop);
+
+            idx += len;  //consume size
+
+            if (id == 0x20)  //BlockGroup ID
+                ++m_entriesCount;
+            else if (id == 0x23)  //SimpleBlock ID
+                ++m_entriesCount;
+
+            idx += size;  //consume payload
+            assert(idx <= stop);
+        }
+    }
+
+    assert(idx == stop);
+    assert(m_timecode >= 0);
+
+    if (m_entriesCount == 0)  //TODO: handle empty clusters
+        return;
+
+    m_entries = new BlockEntry*[m_entriesCount];
+    size_t index = 0;
+
+    while (pos < stop)
+    {
+        if (Match(pReader, pos, 0x67, timecode))
+            assert(timecode == m_timecode);
+        else
+        {
+            long len;
+            const long long id = ReadUInt(pReader, pos, len);
+            assert(id >= 0);  //TODO
+            assert((pos + len) <= stop);
+
+            pos += len;  //consume id
+
+            const long long size = ReadUInt(pReader, pos, len);
+            assert(size >= 0);  //TODO
+            assert((pos + len) <= stop);
+
+            pos += len;  //consume size
+
+            if (id == 0x20)  //BlockGroup ID
+                ParseBlockGroup(pos, size, index++);
+            else if (id == 0x23)  //SimpleBlock ID
+                ParseSimpleBlock(pos, size, index++);
+
+            pos += size;  //consume payload
+            assert(pos <= stop);
+        }
+    }
+
+    assert(pos == stop);
+    assert(timecode >= 0);
+    assert(index == m_entriesCount);
+}
+
+
+
+long long Cluster::GetTimeCode()
+{
+    Load();
+    return m_timecode;
+}
+
+
+long long Cluster::GetTime()
+{
+    const long long tc = GetTimeCode();
+    assert(tc >= 0);
+
+    const SegmentInfo* const pInfo = m_pSegment->GetInfo();
+    assert(pInfo);
+
+    const long long scale = pInfo->GetTimeCodeScale();
+    assert(scale >= 1);
+
+    const long long t = m_timecode * scale;
+
+    return t;
+}
+
+
+long long Cluster::GetFirstTime()
+{
+    const BlockEntry* const pEntry = GetFirst();
+
+    if (pEntry == NULL)  //empty cluster
+        return GetTime();
+
+    const Block* const pBlock = pEntry->GetBlock();
+    assert(pBlock);
+
+    return pBlock->GetTime(this);
+}
+
+
+long long Cluster::GetLastTime()
+{
+    const BlockEntry* const pEntry = GetLast();
+
+    if (pEntry == NULL)  //empty cluster
+        return GetTime();
+
+    const Block* const pBlock = pEntry->GetBlock();
+    assert(pBlock);
+
+    return pBlock->GetTime(this);
+}
+
+
+void Cluster::ParseBlockGroup(long long start, long long size, size_t index)
+{
+    assert(m_entries);
+    assert(m_entriesCount);
+    assert(index < m_entriesCount);
+
+    BlockGroup* const pGroup =
+        new (std::nothrow) BlockGroup(this, index, start, size);
+    assert(pGroup);  //TODO
+
+    m_entries[index] = pGroup;
+}
+
+
+
+void Cluster::ParseSimpleBlock(long long start, long long size, size_t index)
+{
+    assert(m_entries);
+    assert(m_entriesCount);
+    assert(index < m_entriesCount);
+
+    SimpleBlock* const pSimpleBlock =
+        new (std::nothrow) SimpleBlock(this, index, start, size);
+    assert(pSimpleBlock);  //TODO
+
+    m_entries[index] = pSimpleBlock;
+}
+
+
+const BlockEntry* Cluster::GetFirst()
+{
+    LoadBlockEntries();
+    //assert(m_entries);
+    //assert(m_entriesCount >= 1);
+
+    if ((m_entries == NULL) || (m_entriesCount == 0))
+        return NULL;
+
+    const BlockEntry* const pFirst = m_entries[0];
+    assert(pFirst);
+
+    return pFirst;
+}
+
+
+const BlockEntry* Cluster::GetLast()
+{
+    LoadBlockEntries();
+    //assert(m_entries);
+    //assert(m_entriesCount >= 1);
+
+    if ((m_entries == NULL) || (m_entriesCount == 0))
+        return NULL;
+
+    const size_t idx = m_entriesCount - 1;
+
+    const BlockEntry* const pLast = m_entries[idx];
+    assert(pLast);
+
+    return pLast;
+}
+
+
+const BlockEntry* Cluster::GetNext(const BlockEntry* pEntry) const
+{
+    assert(pEntry);
+    assert(m_entries);
+    assert(m_entriesCount);
+
+    size_t idx = pEntry->GetIndex();
+    assert(idx < m_entriesCount);
+    assert(m_entries[idx] == pEntry);
+
+    ++idx;
+
+    if (idx >= m_entriesCount)
+      return NULL;
+
+    return m_entries[idx];
+}
+
+
+const BlockEntry* Cluster::GetEntry(const Track* pTrack)
+{
+    assert(pTrack);
+
+    if (m_pSegment == NULL)  //EOS
+        return pTrack->GetEOS();
+
+    LoadBlockEntries();
+
+    if ((m_entries == NULL) || (m_entriesCount == 0))
+        return NULL;
+
+    BlockEntry** i = m_entries;
+    assert(i);
+
+    BlockEntry** const j = i + m_entriesCount;
+
+    while (i != j)
+    {
+        const BlockEntry* const pEntry = *i++;
+        assert(pEntry);
+        assert(!pEntry->EOS());
+
+        const Block* const pBlock = pEntry->GetBlock();
+        assert(pBlock);
+
+        if (pBlock->GetTrackNumber() != pTrack->GetNumber())
+            continue;
+
+        if (pTrack->VetEntry(pEntry))
+            return pEntry;
+    }
+
+    return pTrack->GetEOS();  //no satisfactory block found
+}
+
+
+const BlockEntry*
+Cluster::GetEntry(
+    const CuePoint& cp,
+    const CuePoint::TrackPosition& tp)
+{
+    assert(m_pSegment);
+
+    LoadBlockEntries();
+
+    if (m_entries == NULL)
+        return NULL;
+
+    const long long count = m_entriesCount;
+
+    if (count <= 0)
+        return NULL;
+
+    const long long tc = cp.GetTimeCode();
+
+    if ((tp.m_block > 0) && (tp.m_block <= count))
+    {
+        const size_t block = static_cast<size_t>(tp.m_block);
+        const size_t index = block - 1;
+
+        const BlockEntry* const pEntry = m_entries[index];
+        assert(pEntry);
+        assert(!pEntry->EOS());
+
+        const Block* const pBlock = pEntry->GetBlock();
+        assert(pBlock);
+
+        if ((pBlock->GetTrackNumber() == tp.m_track) &&
+            (pBlock->GetTimeCode(this) == tc))
+        {
+            return pEntry;
+        }
+    }
+
+    const BlockEntry* const* i = m_entries;
+    const BlockEntry* const* const j = i + count;
+
+    while (i != j)
+    {
+        const BlockEntry* const pEntry = *i++;
+        assert(pEntry);
+        assert(!pEntry->EOS());
+
+        const Block* const pBlock = pEntry->GetBlock();
+        assert(pBlock);
+
+        if (pBlock->GetTrackNumber() != tp.m_track)
+            continue;
+
+        const long long tc_ = pBlock->GetTimeCode(this);
+
+        if (tc_ < tc)
+            continue;
+
+        if (tc_ > tc)
+            return NULL;
+
+        const Tracks* const pTracks = m_pSegment->GetTracks();
+        assert(pTracks);
+
+        const long tn = static_cast<long>(tp.m_track);
+        const Track* const pTrack = pTracks->GetTrackByNumber(tn);
+
+        if (pTrack == NULL)
+            return NULL;
+
+        const long long type = pTrack->GetType();
+
+        if (type == 2)  //audio
+            return pEntry;
+
+        if (type != 1)  //not video
+            return NULL;
+
+        if (!pBlock->IsKey())
+            return NULL;
+
+        return pEntry;
+    }
+
+    return NULL;
+}
+
+
+const BlockEntry* Cluster::GetMaxKey(const VideoTrack* pTrack)
+{
+    assert(pTrack);
+
+    if (m_pSegment == NULL)  //EOS
+        return pTrack->GetEOS();
+
+    LoadBlockEntries();
+    //assert(m_entries);
+
+    BlockEntry** i = m_entries + m_entriesCount;
+    BlockEntry** const j = m_entries;
+
+    while (i != j)
+    {
+        const BlockEntry* const pEntry = *--i;
+        assert(pEntry);
+        assert(!pEntry->EOS());
+
+        const Block* const pBlock = pEntry->GetBlock();
+        assert(pBlock);
+
+        if (pBlock->GetTrackNumber() != pTrack->GetNumber())
+            continue;
+
+        if (pBlock->IsKey())
+            return pEntry;
+    }
+
+    return pTrack->GetEOS();  //no satisfactory block found
+}
+
+
+
+BlockEntry::BlockEntry()
+{
+}
+
+
+BlockEntry::~BlockEntry()
+{
+}
+
+
+SimpleBlock::SimpleBlock(
+    Cluster* pCluster,
+    size_t idx,
+    long long start,
+    long long size) :
+    m_pCluster(pCluster),
+    m_index(idx),
+    m_block(start, size, pCluster->m_pSegment->m_pReader)
+{
+}
+
+
+bool SimpleBlock::EOS() const
+{
+    return false;
+}
+
+
+Cluster* SimpleBlock::GetCluster() const
+{
+    return m_pCluster;
+}
+
+
+size_t SimpleBlock::GetIndex() const
+{
+    return m_index;
+}
+
+
+const Block* SimpleBlock::GetBlock() const
+{
+    return &m_block;
+}
+
+
+bool SimpleBlock::IsBFrame() const
+{
+    return false;
+}
+
+
+BlockGroup::BlockGroup(
+    Cluster* pCluster,
+    size_t idx,
+    long long start,
+    long long size_) :
+    m_pCluster(pCluster),
+    m_index(idx),
+    m_prevTimeCode(0),
+    m_nextTimeCode(0),
+    m_pBlock(NULL)  //TODO: accept multiple blocks within a block group
+{
+    IMkvReader* const pReader = m_pCluster->m_pSegment->m_pReader;
+
+    long long pos = start;
+    const long long stop = start + size_;
+
+    bool bSimpleBlock = false;
+    bool bReferenceBlock = false;
+
+    while (pos < stop)
+    {
+        short t;
+
+        if (Match(pReader, pos, 0x7B, t))
+        {
+            if (t < 0)
+                m_prevTimeCode = t;
+            else if (t > 0)
+                m_nextTimeCode = t;
+            else
+                assert(false);
+
+            bReferenceBlock = true;
+        }
+        else
+        {
+            long len;
+            const long long id = ReadUInt(pReader, pos, len);
+            assert(id >= 0);  //TODO
+            assert((pos + len) <= stop);
+
+            pos += len;  //consume ID
+
+            const long long size = ReadUInt(pReader, pos, len);
+            assert(size >= 0);  //TODO
+            assert((pos + len) <= stop);
+
+            pos += len;  //consume size
+
+            switch (id)
+            {
+                case 0x23:  //SimpleBlock ID
+                    bSimpleBlock = true;
+                    //YES, FALL THROUGH TO NEXT CASE
+
+                case 0x21:  //Block ID
+                    ParseBlock(pos, size);
+                    break;
+
+                default:
+                    break;
+            }
+
+            pos += size;  //consume payload
+            assert(pos <= stop);
+        }
+    }
+
+    assert(pos == stop);
+    assert(m_pBlock);
+
+    if (!bSimpleBlock)
+        m_pBlock->SetKey(!bReferenceBlock);
+}
+
+
+BlockGroup::~BlockGroup()
+{
+    delete m_pBlock;
+}
+
+
+void BlockGroup::ParseBlock(long long start, long long size)
+{
+    IMkvReader* const pReader = m_pCluster->m_pSegment->m_pReader;
+
+    Block* const pBlock = new Block(start, size, pReader);
+    assert(pBlock);  //TODO
+
+    //TODO: the Matroska spec says you have multiple blocks within the
+    //same block group, with blocks ranked by priority (the flag bits).
+
+    assert(m_pBlock == NULL);
+    m_pBlock = pBlock;
+}
+
+
+bool BlockGroup::EOS() const
+{
+    return false;
+}
+
+
+Cluster* BlockGroup::GetCluster() const
+{
+    return m_pCluster;
+}
+
+
+size_t BlockGroup::GetIndex() const
+{
+    return m_index;
+}
+
+
+const Block* BlockGroup::GetBlock() const
+{
+    return m_pBlock;
+}
+
+
+short BlockGroup::GetPrevTimeCode() const
+{
+    return m_prevTimeCode;
+}
+
+
+short BlockGroup::GetNextTimeCode() const
+{
+    return m_nextTimeCode;
+}
+
+
+bool BlockGroup::IsBFrame() const
+{
+    return (m_nextTimeCode > 0);
+}
+
+
+
+Block::Block(long long start, long long size_, IMkvReader* pReader) :
+    m_start(start),
+    m_size(size_)
+{
+    long long pos = start;
+    const long long stop = start + size_;
+
+    long len;
+
+    m_track = ReadUInt(pReader, pos, len);
+    assert(m_track > 0);
+    assert((pos + len) <= stop);
+
+    pos += len;  //consume track number
+    assert((stop - pos) >= 2);
+
+    m_timecode = Unserialize2SInt(pReader, pos);
+
+    pos += 2;
+    assert((stop - pos) >= 1);
+
+    const long hr = pReader->Read(pos, 1, &m_flags);
+    assert(hr == 0L);
+
+    ++pos;
+    assert(pos <= stop);
+
+    m_frameOff = pos;
+
+    const long long frame_size = stop - pos;
+
+    assert(frame_size <= 2147483647L);
+
+    m_frameSize = static_cast<long>(frame_size);
+}
+
+
+long long Block::GetTimeCode(Cluster* pCluster) const
+{
+    assert(pCluster);
+
+    const long long tc0 = pCluster->GetTimeCode();
+    assert(tc0 >= 0);
+
+    const long long tc = tc0 + static_cast<long long>(m_timecode);
+    assert(tc >= 0);
+
+    return tc;  //unscaled timecode units
+}
+
+
+long long Block::GetTime(Cluster* pCluster) const
+{
+    assert(pCluster);
+
+    const long long tc = GetTimeCode(pCluster);
+
+    const Segment* const pSegment = pCluster->m_pSegment;
+    const SegmentInfo* const pInfo = pSegment->GetInfo();
+    assert(pInfo);
+
+    const long long scale = pInfo->GetTimeCodeScale();
+    assert(scale >= 1);
+
+    const long long ns = tc * scale;
+
+    return ns;
+}
+
+
+long long Block::GetTrackNumber() const
+{
+    return m_track;
+}
+
+
+bool Block::IsKey() const
+{
+    return ((m_flags & static_cast<unsigned char>(1 << 7)) != 0);
+}
+
+unsigned char Block::Flags() const {
+    return m_flags;
+}
+
+void Block::SetKey(bool bKey)
+{
+    if (bKey)
+        m_flags |= static_cast<unsigned char>(1 << 7);
+    else
+        m_flags &= 0x7F;
+}
+
+
+long long Block::GetOffset() const
+{
+  return m_frameOff;
+}
+
+
+long Block::GetSize() const
+{
+    return m_frameSize;
+}
+
+
+long Block::Read(IMkvReader* pReader, unsigned char* buf) const
+{
+
+    assert(pReader);
+    assert(buf);
+
+    const long hr = pReader->Read(m_frameOff, m_frameSize, buf);
+
+    return hr;
+}
+
+
+}  //end namespace mkvparser
diff --git a/media/libstagefright/matroska/mkvparser.hpp b/media/libstagefright/matroska/mkvparser.hpp
index 4d311b4..f7d8948 100644
--- a/media/libstagefright/matroska/mkvparser.hpp
+++ b/media/libstagefright/matroska/mkvparser.hpp
@@ -1,428 +1,556 @@
-#ifndef MKVPARSER_HPP
-#define MKVPARSER_HPP
-
-#include <cstdlib>
-#include <cstdio>
-
-namespace mkvparser
-{
-
-const int E_FILE_FORMAT_INVALID = -2;
-const int E_BUFFER_NOT_FULL = -3;
-
-class IMkvReader
-{
-public:
-    virtual int Read(long long position, long length, unsigned char* buffer) = 0;
-    virtual int Length(long long* total, long long* available) = 0; 	
-protected:
-    virtual ~IMkvReader();
-};
-
-long long GetUIntLength(IMkvReader*, long long, long&);
-long long ReadUInt(IMkvReader*, long long, long&);
-long long SyncReadUInt(IMkvReader*, long long pos, long long stop, long&);
-long long UnserializeUInt(IMkvReader*, long long pos, long long size);
-float Unserialize4Float(IMkvReader*, long long);
-double Unserialize8Double(IMkvReader*, long long);
-short Unserialize2SInt(IMkvReader*, long long);
-signed char Unserialize1SInt(IMkvReader*, long long);
-bool Match(IMkvReader*, long long&, unsigned long, long long&);
-bool Match(IMkvReader*, long long&, unsigned long, char*&);
-bool Match(IMkvReader*, long long&, unsigned long,unsigned char*&,
-           size_t *optionalSize = NULL);
-bool Match(IMkvReader*, long long&, unsigned long, double&);
-bool Match(IMkvReader*, long long&, unsigned long, short&);
-
-
-struct EBMLHeader
-{
-    EBMLHeader();
-    ~EBMLHeader();  
-    long long m_version;
-    long long m_readVersion;
-    long long m_maxIdLength;
-    long long m_maxSizeLength;
-    char* m_docType;
-    long long m_docTypeVersion;
-    long long m_docTypeReadVersion;
-    
-    long long Parse(IMkvReader*, long long&);
-};
-
-
-class Segment;
-class Track;
-class Cluster;
-
-class Block
-{
-    Block(const Block&);
-    Block& operator=(const Block&);
-
-public:
-    const long long m_start;
-    const long long m_size;
-    
-    Block(long long start, long long size, IMkvReader*);
-    
-    unsigned long GetTrackNumber() const;
-    
-    long long GetTimeCode(Cluster*) const;  //absolute, but not scaled
-    long long GetTime(Cluster*) const;      //absolute, and scaled (nanosecond units)
-    bool IsKey() const;
-    void SetKey(bool);
-
-    long GetSize() const;
-    long Read(IMkvReader*, unsigned char*) const;
-    
-private:
-    long long m_track;   //Track::Number()
-    short m_timecode;  //relative to cluster
-    unsigned char m_flags;
-    long long m_frameOff;
-    long m_frameSize;    
-
-};
-
-
-class BlockEntry
-{
-    BlockEntry(const BlockEntry&);
-    BlockEntry& operator=(const BlockEntry&);
-    
-public:
-    virtual ~BlockEntry();
-    virtual bool EOS() const = 0;
-    virtual Cluster* GetCluster() const = 0;
-    virtual size_t GetIndex() const = 0;
-    virtual const Block* GetBlock() const = 0;
-    virtual bool IsBFrame() const = 0;
-    
-protected:
-    BlockEntry();
-
-};
-
-
-class SimpleBlock : public BlockEntry
-{
-    SimpleBlock(const SimpleBlock&);
-    SimpleBlock& operator=(const SimpleBlock&);
-
-public:
-    SimpleBlock(Cluster*, size_t, long long start, long long size);
-
-    bool EOS() const;
-    Cluster* GetCluster() const; 
-    size_t GetIndex() const;
-    const Block* GetBlock() const;
-    bool IsBFrame() const;
-
-protected:
-    Cluster* const m_pCluster;
-    const size_t m_index;
-    Block m_block;
-    
-};
-
-
-class BlockGroup : public BlockEntry
-{
-    BlockGroup(const BlockGroup&);
-    BlockGroup& operator=(const BlockGroup&);
-
-public:
-    BlockGroup(Cluster*, size_t, long long, long long);
-    ~BlockGroup();
-    
-    bool EOS() const;
-    Cluster* GetCluster() const; 
-    size_t GetIndex() const;
-    const Block* GetBlock() const;
-    bool IsBFrame() const;
-    
-    short GetPrevTimeCode() const;  //relative to block's time
-    short GetNextTimeCode() const;  //as above
-    
-protected:
-    Cluster* const m_pCluster;
-    const size_t m_index;
-    
-private:
-    BlockGroup(Cluster*, size_t, unsigned long);
-    void ParseBlock(long long start, long long size);
-
-    short m_prevTimeCode;
-    short m_nextTimeCode;
-    
-    //TODO: the Matroska spec says you can have multiple blocks within the 
-    //same block group, with blocks ranked by priority (the flag bits).
-    //For now we just cache a single block.
-#if 0
-    typedef std::deque<Block*> blocks_t;
-    blocks_t m_blocks;  //In practice should contain only a single element.
-#else
-    Block* m_pBlock;
-#endif
-    
-};
-
-
-class Track
-{
-    Track(const Track&);
-    Track& operator=(const Track&);
-
-public:    
-    Segment* const m_pSegment;
-    virtual ~Track();
-    
-    long long GetType() const; 
-    unsigned long GetNumber() const;
-    const char* GetNameAsUTF8() const;
-    const char* GetCodecNameAsUTF8() const;
-    const char* GetCodecId() const;
-    const unsigned char* GetCodecPrivate(
-            size_t *optionalSize = NULL) const;
-    
-    const BlockEntry* GetEOS() const;
-    
-    struct Settings 
-    {
-        long long start;
-        long long size;
-    };
-    
-    struct Info
-    {
-        long long type;
-        long long number;
-        long long uid;
-        char* nameAsUTF8;
-        char* codecId;
-        unsigned char* codecPrivate;
-        size_t codecPrivateSize;
-        char* codecNameAsUTF8;
-        Settings settings;
-        Info();
-        void Clear();
-    };
-    
-    long GetFirst(const BlockEntry*&) const;
-    long GetNext(const BlockEntry* pCurr, const BlockEntry*& pNext) const;
-    virtual bool VetEntry(const BlockEntry*) const = 0;
-        
-protected:
-    Track(Segment*, const Info&);        
-    const Info m_info;
-
-    class EOSBlock : public BlockEntry
-    {
-    public:
-        EOSBlock();
-
-        bool EOS() const;    
-        Cluster* GetCluster() const;
-        size_t GetIndex() const;
-        const Block* GetBlock() const;
-        bool IsBFrame() const;
-    };
-    
-    EOSBlock m_eos;
-    
-};
-
-
-class VideoTrack : public Track
-{
-    VideoTrack(const VideoTrack&);
-    VideoTrack& operator=(const VideoTrack&);
-    
-public:
-    VideoTrack(Segment*, const Info&);    
-    long long GetWidth() const;
-    long long GetHeight() const;
-    double GetFrameRate() const;
-    
-    bool VetEntry(const BlockEntry*) const;
-
-private:
-    long long m_width;
-    long long m_height;
-    double m_rate;
-    
-};
-
-
-class AudioTrack : public Track
-{
-    AudioTrack(const AudioTrack&);
-    AudioTrack& operator=(const AudioTrack&);
-
-public:
-    AudioTrack(Segment*, const Info&);    
-    double GetSamplingRate() const;
-    long long GetChannels() const;
-    long long GetBitDepth() const;    
-    bool VetEntry(const BlockEntry*) const;
-
-private:
-    double m_rate;
-    long long m_channels;
-    long long m_bitDepth;
-};
-
-
-class Tracks
-{
-    Tracks(const Tracks&);
-    Tracks& operator=(const Tracks&);
-
-public:
-    Segment* const m_pSegment;
-    const long long m_start;
-    const long long m_size;
-    
-    Tracks(Segment*, long long start, long long size);
-    virtual ~Tracks();
-
-    Track* GetTrackByNumber(unsigned long tn) const;
-    Track* GetTrackByIndex(unsigned long idx) const;
-    
-private:
-    Track** m_trackEntries; 
-    Track** m_trackEntriesEnd;
-
-    void ParseTrackEntry(long long, long long, Track*&);
-    
-public:
-    unsigned long GetTracksCount() const;
-};
-
-
-class SegmentInfo
-{
-    SegmentInfo(const SegmentInfo&);
-    SegmentInfo& operator=(const SegmentInfo&);
-    
-public:
-    Segment* const m_pSegment;
-    const long long m_start;
-    const long long m_size;
-    
-    SegmentInfo(Segment*, long long start, long long size);
-    ~SegmentInfo();
-    long long GetTimeCodeScale() const;
-    long long GetDuration() const;  //scaled
-    const char* GetMuxingAppAsUTF8() const;
-    const char* GetWritingAppAsUTF8() const;
-    const char* GetTitleAsUTF8() const;
-    
-private:
-    long long m_timecodeScale;
-    double m_duration;
-    char* m_pMuxingAppAsUTF8;
-    char* m_pWritingAppAsUTF8;
-    char* m_pTitleAsUTF8;
-};
-
-
-class Cluster
-{
-    Cluster(const Cluster&);
-    Cluster& operator=(const Cluster&);
-
-public:
-    Segment* const m_pSegment;
-    const size_t m_index;
-    
-public:    
-    static Cluster* Parse(Segment*, size_t, long long off);
-
-    Cluster();  //EndOfStream
-    ~Cluster();
-    
-    bool EOS() const;
-    
-    long long GetTimeCode();  //absolute, but not scaled
-    long long GetTime();      //absolute, and scaled (nanosecond units)
-
-    const BlockEntry* GetFirst();
-    const BlockEntry* GetLast();
-    const BlockEntry* GetNext(const BlockEntry*) const;    
-    const BlockEntry* GetEntry(const Track*);
-protected:    
-    Cluster(Segment*, size_t, long long off);
-    
-private:
-    long long m_start;
-    long long m_size;    
-    long long m_timecode;
-    BlockEntry** m_pEntries;
-    size_t m_entriesCount;
-   
-    void Load();
-    void LoadBlockEntries();
-    void ParseBlockGroup(long long, long long, size_t);
-    void ParseSimpleBlock(long long, long long, size_t);
-    
-};
-
-
-class Segment
-{
-    Segment(const Segment&);
-    Segment& operator=(const Segment&);
-
-private:
-    Segment(IMkvReader*, long long pos, long long size);
-
-public:
-    IMkvReader* const m_pReader;
-    const long long m_start;  //posn of segment payload
-    const long long m_size;   //size of segment payload
-    Cluster m_eos;  //TODO: make private?
-    
-    static long long CreateInstance(IMkvReader*, long long, Segment*&);
-    ~Segment();
-
-    //for big-bang loading (source filter)
-    long Load();
-
-    //for incremental loading (splitter)    
-    long long Unparsed() const;
-    long long ParseHeaders();
-    long ParseCluster(Cluster*&, long long& newpos) const;
-    bool AddCluster(Cluster*, long long);
-
-    Tracks* GetTracks() const;    
-    const SegmentInfo* const GetInfo() const;
-    long long GetDuration() const;
-    
-    //NOTE: this turned out to be too inefficient.
-    //long long Load(long long time_nanoseconds);
-
-    Cluster* GetFirst();
-    Cluster* GetLast();
-    unsigned long GetCount() const;
-    
-    Cluster* GetNext(const Cluster*);
-    Cluster* GetCluster(long long time_nanoseconds);
-    
-private:
-    long long m_pos;  //absolute file posn; what has been consumed so far    
-    SegmentInfo* m_pInfo;
-    Tracks* m_pTracks;    
-    Cluster** m_clusters;
-    size_t m_clusterCount;
-
-    void ParseSeekHead(long long pos, long long size, size_t*);
-    void ParseSeekEntry(long long pos, long long size, size_t*);
-    void ParseSecondarySeekHead(long long off, size_t*);
-};
-
-
-}  //end namespace mkvparser
-
-#endif  //MKVPARSER_HPP
+// Copyright (c) 2010 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+
+#ifndef MKVPARSER_HPP
+#define MKVPARSER_HPP
+
+#include <cstdlib>
+#include <cstdio>
+
+namespace mkvparser
+{
+
+const int E_FILE_FORMAT_INVALID = -2;
+const int E_BUFFER_NOT_FULL = -3;
+
+class IMkvReader
+{
+public:
+    virtual int Read(long long pos, long len, unsigned char* buf) = 0;
+    virtual int Length(long long* total, long long* available) = 0;
+protected:
+    virtual ~IMkvReader();
+};
+
+long long GetUIntLength(IMkvReader*, long long, long&);
+long long ReadUInt(IMkvReader*, long long, long&);
+long long SyncReadUInt(IMkvReader*, long long pos, long long stop, long&);
+long long UnserializeUInt(IMkvReader*, long long pos, long long size);
+float Unserialize4Float(IMkvReader*, long long);
+double Unserialize8Double(IMkvReader*, long long);
+short Unserialize2SInt(IMkvReader*, long long);
+signed char Unserialize1SInt(IMkvReader*, long long);
+bool Match(IMkvReader*, long long&, unsigned long, long long&);
+bool Match(IMkvReader*, long long&, unsigned long, char*&);
+bool Match(IMkvReader*, long long&, unsigned long,unsigned char*&, size_t&);
+bool Match(IMkvReader*, long long&, unsigned long, double&);
+bool Match(IMkvReader*, long long&, unsigned long, short&);
+
+void GetVersion(int& major, int& minor, int& build, int& revision);
+
+struct EBMLHeader
+{
+    EBMLHeader();
+    ~EBMLHeader();
+    long long m_version;
+    long long m_readVersion;
+    long long m_maxIdLength;
+    long long m_maxSizeLength;
+    char* m_docType;
+    long long m_docTypeVersion;
+    long long m_docTypeReadVersion;
+
+    long long Parse(IMkvReader*, long long&);
+};
+
+
+class Segment;
+class Track;
+class Cluster;
+
+class Block
+{
+    Block(const Block&);
+    Block& operator=(const Block&);
+
+public:
+    const long long m_start;
+    const long long m_size;
+
+    Block(long long start, long long size, IMkvReader*);
+
+    long long GetTrackNumber() const;
+    long long GetTimeCode(Cluster*) const;  //absolute, but not scaled
+    long long GetTime(Cluster*) const;      //absolute, and scaled (ns units)
+    bool IsKey() const;
+    void SetKey(bool);
+
+    unsigned char Flags() const;
+
+    long long GetOffset() const;
+    long GetSize() const;
+    long Read(IMkvReader*, unsigned char*) const;
+
+private:
+    long long m_track;   //Track::Number()
+    short m_timecode;  //relative to cluster
+    unsigned char m_flags;
+    long long m_frameOff;
+    long m_frameSize;
+
+};
+
+
+class BlockEntry
+{
+    BlockEntry(const BlockEntry&);
+    BlockEntry& operator=(const BlockEntry&);
+
+public:
+    virtual ~BlockEntry();
+    virtual bool EOS() const = 0;
+    virtual Cluster* GetCluster() const = 0;
+    virtual size_t GetIndex() const = 0;
+    virtual const Block* GetBlock() const = 0;
+    virtual bool IsBFrame() const = 0;
+
+protected:
+    BlockEntry();
+
+};
+
+
+class SimpleBlock : public BlockEntry
+{
+    SimpleBlock(const SimpleBlock&);
+    SimpleBlock& operator=(const SimpleBlock&);
+
+public:
+    SimpleBlock(Cluster*, size_t, long long start, long long size);
+
+    bool EOS() const;
+    Cluster* GetCluster() const;
+    size_t GetIndex() const;
+    const Block* GetBlock() const;
+    bool IsBFrame() const;
+
+protected:
+    Cluster* const m_pCluster;
+    const size_t m_index;
+    Block m_block;
+
+};
+
+
+class BlockGroup : public BlockEntry
+{
+    BlockGroup(const BlockGroup&);
+    BlockGroup& operator=(const BlockGroup&);
+
+public:
+    BlockGroup(Cluster*, size_t, long long, long long);
+    ~BlockGroup();
+
+    bool EOS() const;
+    Cluster* GetCluster() const;
+    size_t GetIndex() const;
+    const Block* GetBlock() const;
+    bool IsBFrame() const;
+
+    short GetPrevTimeCode() const;  //relative to block's time
+    short GetNextTimeCode() const;  //as above
+
+protected:
+    Cluster* const m_pCluster;
+    const size_t m_index;
+
+private:
+    BlockGroup(Cluster*, size_t, unsigned long);
+    void ParseBlock(long long start, long long size);
+
+    short m_prevTimeCode;
+    short m_nextTimeCode;
+
+    //TODO: the Matroska spec says you can have multiple blocks within the
+    //same block group, with blocks ranked by priority (the flag bits).
+    //For now we just cache a single block.
+#if 0
+    typedef std::deque<Block*> blocks_t;
+    blocks_t m_blocks;  //In practice should contain only a single element.
+#else
+    Block* m_pBlock;
+#endif
+
+};
+
+
+class Track
+{
+    Track(const Track&);
+    Track& operator=(const Track&);
+
+public:
+    Segment* const m_pSegment;
+    virtual ~Track();
+
+    long long GetType() const;
+    long long GetNumber() const;
+    const char* GetNameAsUTF8() const;
+    const char* GetCodecNameAsUTF8() const;
+    const char* GetCodecId() const;
+    const unsigned char* GetCodecPrivate(size_t&) const;
+
+    const BlockEntry* GetEOS() const;
+
+    struct Settings
+    {
+        long long start;
+        long long size;
+    };
+
+    struct Info
+    {
+        long long type;
+        long long number;
+        long long uid;
+        char* nameAsUTF8;
+        char* codecId;
+        unsigned char* codecPrivate;
+        size_t codecPrivateSize;
+        char* codecNameAsUTF8;
+        Settings settings;
+        Info();
+        void Clear();
+    };
+
+    long GetFirst(const BlockEntry*&) const;
+    long GetNext(const BlockEntry* pCurr, const BlockEntry*& pNext) const;
+    virtual bool VetEntry(const BlockEntry*) const = 0;
+
+protected:
+    Track(Segment*, const Info&);
+    const Info m_info;
+
+    class EOSBlock : public BlockEntry
+    {
+    public:
+        EOSBlock();
+
+        bool EOS() const;
+        Cluster* GetCluster() const;
+        size_t GetIndex() const;
+        const Block* GetBlock() const;
+        bool IsBFrame() const;
+    };
+
+    EOSBlock m_eos;
+
+};
+
+
+class VideoTrack : public Track
+{
+    VideoTrack(const VideoTrack&);
+    VideoTrack& operator=(const VideoTrack&);
+
+public:
+    VideoTrack(Segment*, const Info&);
+    long long GetWidth() const;
+    long long GetHeight() const;
+    double GetFrameRate() const;
+
+    bool VetEntry(const BlockEntry*) const;
+
+private:
+    long long m_width;
+    long long m_height;
+    double m_rate;
+
+};
+
+
+class AudioTrack : public Track
+{
+    AudioTrack(const AudioTrack&);
+    AudioTrack& operator=(const AudioTrack&);
+
+public:
+    AudioTrack(Segment*, const Info&);
+    double GetSamplingRate() const;
+    long long GetChannels() const;
+    long long GetBitDepth() const;
+    bool VetEntry(const BlockEntry*) const;
+
+private:
+    double m_rate;
+    long long m_channels;
+    long long m_bitDepth;
+};
+
+
+class Tracks
+{
+    Tracks(const Tracks&);
+    Tracks& operator=(const Tracks&);
+
+public:
+    Segment* const m_pSegment;
+    const long long m_start;
+    const long long m_size;
+
+    Tracks(Segment*, long long start, long long size);
+    virtual ~Tracks();
+
+    Track* GetTrackByNumber(unsigned long tn) const;
+    Track* GetTrackByIndex(unsigned long idx) const;
+
+private:
+    Track** m_trackEntries;
+    Track** m_trackEntriesEnd;
+
+    void ParseTrackEntry(long long, long long, Track*&);
+
+public:
+    unsigned long GetTracksCount() const;
+};
+
+
+class SegmentInfo
+{
+    SegmentInfo(const SegmentInfo&);
+    SegmentInfo& operator=(const SegmentInfo&);
+
+public:
+    Segment* const m_pSegment;
+    const long long m_start;
+    const long long m_size;
+
+    SegmentInfo(Segment*, long long start, long long size);
+    ~SegmentInfo();
+    long long GetTimeCodeScale() const;
+    long long GetDuration() const;  //scaled
+    const char* GetMuxingAppAsUTF8() const;
+    const char* GetWritingAppAsUTF8() const;
+    const char* GetTitleAsUTF8() const;
+
+private:
+    long long m_timecodeScale;
+    double m_duration;
+    char* m_pMuxingAppAsUTF8;
+    char* m_pWritingAppAsUTF8;
+    char* m_pTitleAsUTF8;
+};
+
+class Cues;
+class CuePoint
+{
+    friend class Cues;
+
+    CuePoint(size_t, long long);
+    ~CuePoint();
+
+    CuePoint(const CuePoint&);
+    CuePoint& operator=(const CuePoint&);
+
+public:
+    void Load(IMkvReader*);
+
+    long long GetTimeCode() const;      //absolute but unscaled
+    long long GetTime(Segment*) const;  //absolute and scaled (ns units)
+
+    struct TrackPosition
+    {
+        long long m_track;
+        long long m_pos;  //of cluster
+        long long m_block;
+        //codec_state  //defaults to 0
+        //reference = clusters containing req'd referenced blocks
+        //  reftime = timecode of the referenced block
+
+        void Parse(IMkvReader*, long long, long long);
+    };
+
+    const TrackPosition* Find(const Track*) const;
+
+private:
+    const size_t m_index;
+    long long m_timecode;
+    TrackPosition* m_track_positions;
+    size_t m_track_positions_count;
+
+};
+
+
+class Cues
+{
+    friend class Segment;
+
+    Cues(Segment*, long long start, long long size);
+    ~Cues();
+
+    Cues(const Cues&);
+    Cues& operator=(const Cues&);
+
+public:
+    Segment* const m_pSegment;
+    const long long m_start;
+    const long long m_size;
+
+    bool Find(  //lower bound of time_ns
+        long long time_ns,
+        const Track*,
+        const CuePoint*&,
+        const CuePoint::TrackPosition*&) const;
+
+#if 0
+    bool FindNext(  //upper_bound of time_ns
+        long long time_ns,
+        const Track*,
+        const CuePoint*&,
+        const CuePoint::TrackPosition*&) const;
+#endif
+
+    const CuePoint* GetFirst() const;
+    const CuePoint* GetLast() const;
+
+    const CuePoint* GetNext(const CuePoint*) const;
+
+    const BlockEntry* GetBlock(
+                        const CuePoint*,
+                        const CuePoint::TrackPosition*) const;
+
+private:
+    void Init() const;
+    bool LoadCuePoint() const;
+    void PreloadCuePoint(size_t&, long long) const;
+
+    mutable CuePoint** m_cue_points;
+    mutable size_t m_count;
+    mutable size_t m_preload_count;
+    mutable long long m_pos;
+
+};
+
+
+class Cluster
+{
+    Cluster(const Cluster&);
+    Cluster& operator=(const Cluster&);
+
+public:
+    Segment* const m_pSegment;
+
+public:
+    static Cluster* Parse(Segment*, long, long long off);
+
+    Cluster();  //EndOfStream
+    ~Cluster();
+
+    bool EOS() const;
+
+    long long GetTimeCode();   //absolute, but not scaled
+    long long GetTime();       //absolute, and scaled (nanosecond units)
+    long long GetFirstTime();  //time (ns) of first (earliest) block
+    long long GetLastTime();   //time (ns) of last (latest) block
+
+    const BlockEntry* GetFirst();
+    const BlockEntry* GetLast();
+    const BlockEntry* GetNext(const BlockEntry*) const;
+    const BlockEntry* GetEntry(const Track*);
+    const BlockEntry* GetEntry(
+        const CuePoint&,
+        const CuePoint::TrackPosition&);
+    const BlockEntry* GetMaxKey(const VideoTrack*);
+
+protected:
+    Cluster(Segment*, long, long long off);
+
+public:
+    //TODO: these should all be private, with public selector functions
+    long m_index;
+    long long m_pos;
+    long long m_size;
+
+private:
+    long long m_timecode;
+    BlockEntry** m_entries;
+    size_t m_entriesCount;
+
+    void Load();
+    void LoadBlockEntries();
+    void ParseBlockGroup(long long, long long, size_t);
+    void ParseSimpleBlock(long long, long long, size_t);
+
+};
+
+
+class Segment
+{
+    friend class Cues;
+
+    Segment(const Segment&);
+    Segment& operator=(const Segment&);
+
+private:
+    Segment(IMkvReader*, long long pos, long long size);
+
+public:
+    IMkvReader* const m_pReader;
+    const long long m_start;  //posn of segment payload
+    const long long m_size;   //size of segment payload
+    Cluster m_eos;  //TODO: make private?
+
+    static long long CreateInstance(IMkvReader*, long long, Segment*&);
+    ~Segment();
+
+    long Load();  //loads headers and all clusters
+
+    //for incremental loading (splitter)
+    long long Unparsed() const;
+    long long ParseHeaders();  //stops when first cluster is found
+    long LoadCluster();        //loads one cluster
+
+#if 0
+    //This pair parses one cluster, but only changes the state of the
+    //segment object when the cluster is actually added to the index.
+    long ParseCluster(Cluster*&, long long& newpos) const;
+    bool AddCluster(Cluster*, long long);
+#endif
+
+    Tracks* GetTracks() const;
+    const SegmentInfo* GetInfo() const;
+    const Cues* GetCues() const;
+
+    long long GetDuration() const;
+
+    unsigned long GetCount() const;
+    Cluster* GetFirst();
+    Cluster* GetLast();
+    Cluster* GetNext(const Cluster*);
+
+    Cluster* FindCluster(long long time_nanoseconds);
+    const BlockEntry* Seek(long long time_nanoseconds, const Track*);
+
+private:
+
+    long long m_pos;  //absolute file posn; what has been consumed so far
+    SegmentInfo* m_pInfo;
+    Tracks* m_pTracks;
+    Cues* m_pCues;
+    Cluster** m_clusters;
+    long m_clusterCount;         //number of entries for which m_index >= 0
+    long m_clusterPreloadCount;  //number of entries for which m_index < 0
+    long m_clusterSize;          //array size
+
+    void AppendCluster(Cluster*);
+    void PreloadCluster(Cluster*, ptrdiff_t);
+
+    void ParseSeekHead(long long pos, long long size);
+    void ParseSeekEntry(long long pos, long long size);
+    void ParseCues(long long);
+
+    const BlockEntry* GetBlock(
+        const CuePoint&,
+        const CuePoint::TrackPosition&);
+
+};
+
+
+}  //end namespace mkvparser
+
+#endif  //MKVPARSER_HPP
diff --git a/media/libstagefright/omx/OMX.cpp b/media/libstagefright/omx/OMX.cpp
index 63af26a..2ba63f7 100644
--- a/media/libstagefright/omx/OMX.cpp
+++ b/media/libstagefright/omx/OMX.cpp
@@ -89,6 +89,9 @@
         mQueueChanged.signal();
     }
 
+    // Don't call join on myself
+    CHECK(mThread != pthread_self());
+
     void *dummy;
     pthread_join(mThread, &dummy);
 }
@@ -249,9 +252,12 @@
 
     status_t err = instance->freeNode(mMaster);
 
-    index = mDispatchers.indexOfKey(node);
-    CHECK(index >= 0);
-    mDispatchers.removeItemsAt(index);
+    {
+        Mutex::Autolock autoLock(mLock);
+        index = mDispatchers.indexOfKey(node);
+        CHECK(index >= 0);
+        mDispatchers.removeItemsAt(index);
+    }
 
     return err;
 }
@@ -525,6 +531,13 @@
                 surface,
                 displayWidth, displayHeight,
                 encodedWidth, encodedHeight);
+
+        if (((SoftwareRenderer *)impl)->initCheck() != OK) {
+            delete impl;
+            impl = NULL;
+
+            return NULL;
+        }
     }
 
     return new OMXRenderer(impl);
diff --git a/media/libstagefright/rtsp/AMPEG4AudioAssembler.cpp b/media/libstagefright/rtsp/AMPEG4AudioAssembler.cpp
index b0d2c64..bbde516 100644
--- a/media/libstagefright/rtsp/AMPEG4AudioAssembler.cpp
+++ b/media/libstagefright/rtsp/AMPEG4AudioAssembler.cpp
@@ -18,18 +18,381 @@
 
 #include "ARTPSource.h"
 
+#include <media/stagefright/foundation/hexdump.h>
+#include <media/stagefright/foundation/ABitReader.h>
 #include <media/stagefright/foundation/ABuffer.h>
 #include <media/stagefright/foundation/ADebug.h>
 #include <media/stagefright/foundation/AMessage.h>
+#include <media/stagefright/MediaErrors.h>
+
+#include <ctype.h>
 
 namespace android {
 
-AMPEG4AudioAssembler::AMPEG4AudioAssembler(const sp<AMessage> &notify)
+static bool GetAttribute(const char *s, const char *key, AString *value) {
+    value->clear();
+
+    size_t keyLen = strlen(key);
+
+    for (;;) {
+        while (isspace(*s)) {
+            ++s;
+        }
+
+        const char *colonPos = strchr(s, ';');
+
+        size_t len =
+            (colonPos == NULL) ? strlen(s) : colonPos - s;
+
+        if (len >= keyLen + 1 && s[keyLen] == '=' && !strncmp(s, key, keyLen)) {
+            value->setTo(&s[keyLen + 1], len - keyLen - 1);
+            return true;
+        }
+
+        if (colonPos == NULL) {
+            return false;
+        }
+
+        s = colonPos + 1;
+    }
+}
+
+static sp<ABuffer> decodeHex(const AString &s) {
+    if ((s.size() % 2) != 0) {
+        return NULL;
+    }
+
+    size_t outLen = s.size() / 2;
+    sp<ABuffer> buffer = new ABuffer(outLen);
+    uint8_t *out = buffer->data();
+
+    uint8_t accum = 0;
+    for (size_t i = 0; i < s.size(); ++i) {
+        char c = s.c_str()[i];
+        unsigned value;
+        if (c >= '0' && c <= '9') {
+            value = c - '0';
+        } else if (c >= 'a' && c <= 'f') {
+            value = c - 'a' + 10;
+        } else if (c >= 'A' && c <= 'F') {
+            value = c - 'A' + 10;
+        } else {
+            return NULL;
+        }
+
+        accum = (accum << 4) | value;
+
+        if (i & 1) {
+            *out++ = accum;
+
+            accum = 0;
+        }
+    }
+
+    return buffer;
+}
+
+static status_t parseAudioObjectType(
+        ABitReader *bits, unsigned *audioObjectType) {
+    *audioObjectType = bits->getBits(5);
+    if ((*audioObjectType) == 31) {
+        *audioObjectType = 32 + bits->getBits(6);
+    }
+
+    return OK;
+}
+
+static status_t parseGASpecificConfig(
+        ABitReader *bits,
+        unsigned audioObjectType, unsigned channelConfiguration) {
+    unsigned frameLengthFlag = bits->getBits(1);
+    unsigned dependsOnCoreCoder = bits->getBits(1);
+    if (dependsOnCoreCoder) {
+        /* unsigned coreCoderDelay = */bits->getBits(1);
+    }
+    unsigned extensionFlag = bits->getBits(1);
+
+    if (!channelConfiguration) {
+        // program_config_element
+        return ERROR_UNSUPPORTED;  // XXX to be implemented
+    }
+
+    if (audioObjectType == 6 || audioObjectType == 20) {
+        /* unsigned layerNr = */bits->getBits(3);
+    }
+
+    if (extensionFlag) {
+        if (audioObjectType == 22) {
+            /* unsigned numOfSubFrame = */bits->getBits(5);
+            /* unsigned layerLength = */bits->getBits(11);
+        } else if (audioObjectType == 17 || audioObjectType == 19
+                || audioObjectType == 20 || audioObjectType == 23) {
+            /* unsigned aacSectionDataResilienceFlag = */bits->getBits(1);
+            /* unsigned aacScalefactorDataResilienceFlag = */bits->getBits(1);
+            /* unsigned aacSpectralDataResilienceFlag = */bits->getBits(1);
+        }
+
+        unsigned extensionFlag3 = bits->getBits(1);
+        CHECK_EQ(extensionFlag3, 0u);  // TBD in version 3
+    }
+
+    return OK;
+}
+
+static status_t parseAudioSpecificConfig(ABitReader *bits) {
+    unsigned audioObjectType;
+    CHECK_EQ(parseAudioObjectType(bits, &audioObjectType), (status_t)OK);
+
+    unsigned samplingFreqIndex = bits->getBits(4);
+    if (samplingFreqIndex == 0x0f) {
+        /* unsigned samplingFrequency = */bits->getBits(24);
+    }
+
+    unsigned channelConfiguration = bits->getBits(4);
+
+    unsigned extensionAudioObjectType = 0;
+    unsigned sbrPresent = 0;
+
+    if (audioObjectType == 5) {
+        extensionAudioObjectType = audioObjectType;
+        sbrPresent = 1;
+        unsigned extensionSamplingFreqIndex = bits->getBits(4);
+        if (extensionSamplingFreqIndex == 0x0f) {
+            /* unsigned extensionSamplingFrequency = */bits->getBits(24);
+        }
+        CHECK_EQ(parseAudioObjectType(bits, &audioObjectType), (status_t)OK);
+    }
+
+    CHECK((audioObjectType >= 1 && audioObjectType <= 4)
+        || (audioObjectType >= 6 && audioObjectType <= 7)
+        || audioObjectType == 17
+        || (audioObjectType >= 19 && audioObjectType <= 23));
+
+    CHECK_EQ(parseGASpecificConfig(
+                bits, audioObjectType, channelConfiguration), (status_t)OK);
+
+    if (audioObjectType == 17
+            || (audioObjectType >= 19 && audioObjectType <= 27)) {
+        unsigned epConfig = bits->getBits(2);
+        if (epConfig == 2 || epConfig == 3) {
+            // ErrorProtectionSpecificConfig
+            return ERROR_UNSUPPORTED;  // XXX to be implemented
+
+            if (epConfig == 3) {
+                unsigned directMapping = bits->getBits(1);
+                CHECK_EQ(directMapping, 1u);
+            }
+        }
+    }
+
+#if 0
+    // This is not supported here as the upper layers did not explicitly
+    // signal the length of AudioSpecificConfig.
+
+    if (extensionAudioObjectType != 5 && bits->numBitsLeft() >= 16) {
+        unsigned syncExtensionType = bits->getBits(11);
+        if (syncExtensionType == 0x2b7) {
+            CHECK_EQ(parseAudioObjectType(bits, &extensionAudioObjectType),
+                     (status_t)OK);
+
+            sbrPresent = bits->getBits(1);
+
+            if (sbrPresent == 1) {
+                unsigned extensionSamplingFreqIndex = bits->getBits(4);
+                if (extensionSamplingFreqIndex == 0x0f) {
+                    /* unsigned extensionSamplingFrequency = */bits->getBits(24);
+                }
+            }
+        }
+    }
+#endif
+
+    return OK;
+}
+
+static status_t parseStreamMuxConfig(
+        ABitReader *bits,
+        unsigned *numSubFrames,
+        unsigned *frameLengthType,
+        bool *otherDataPresent,
+        unsigned *otherDataLenBits) {
+    unsigned audioMuxVersion = bits->getBits(1);
+
+    unsigned audioMuxVersionA = 0;
+    if (audioMuxVersion == 1) {
+        audioMuxVersionA = bits->getBits(1);
+    }
+
+    CHECK_EQ(audioMuxVersionA, 0u);  // otherwise future spec
+
+    if (audioMuxVersion != 0) {
+        return ERROR_UNSUPPORTED;  // XXX to be implemented;
+    }
+    CHECK_EQ(audioMuxVersion, 0u);  // XXX to be implemented
+
+    unsigned allStreamsSameTimeFraming = bits->getBits(1);
+    CHECK_EQ(allStreamsSameTimeFraming, 1u);  // There's only one stream.
+
+    *numSubFrames = bits->getBits(6);
+    unsigned numProgram = bits->getBits(4);
+    CHECK_EQ(numProgram, 0u);  // disabled in RTP LATM
+
+    unsigned numLayer = bits->getBits(3);
+    CHECK_EQ(numLayer, 0u);  // disabled in RTP LATM
+
+    if (audioMuxVersion == 0) {
+        // AudioSpecificConfig
+        CHECK_EQ(parseAudioSpecificConfig(bits), (status_t)OK);
+    } else {
+        TRESPASS();  // XXX to be implemented
+    }
+
+    *frameLengthType = bits->getBits(3);
+    switch (*frameLengthType) {
+        case 0:
+        {
+            /* unsigned bufferFullness = */bits->getBits(8);
+
+            // The "coreFrameOffset" does not apply since there's only
+            // a single layer.
+            break;
+        }
+
+        case 1:
+        {
+            /* unsigned frameLength = */bits->getBits(9);
+            break;
+        }
+
+        case 3:
+        case 4:
+        case 5:
+        {
+            /* unsigned CELPframeLengthTableIndex = */bits->getBits(6);
+            break;
+        }
+
+        case 6:
+        case 7:
+        {
+            /* unsigned HVXCframeLengthTableIndex = */bits->getBits(1);
+            break;
+        }
+
+        default:
+            break;
+    }
+
+    *otherDataPresent = bits->getBits(1);
+    *otherDataLenBits = 0;
+    if (*otherDataPresent) {
+        if (audioMuxVersion == 1) {
+            TRESPASS();  // XXX to be implemented
+        } else {
+            *otherDataLenBits = 0;
+
+            unsigned otherDataLenEsc;
+            do {
+                (*otherDataLenBits) <<= 8;
+                otherDataLenEsc = bits->getBits(1);
+                unsigned otherDataLenTmp = bits->getBits(8);
+                (*otherDataLenBits) += otherDataLenTmp;
+            } while (otherDataLenEsc);
+        }
+    }
+
+    unsigned crcCheckPresent = bits->getBits(1);
+    if (crcCheckPresent) {
+        /* unsigned crcCheckSum = */bits->getBits(8);
+    }
+
+    return OK;
+}
+
+sp<ABuffer> AMPEG4AudioAssembler::removeLATMFraming(const sp<ABuffer> &buffer) {
+    CHECK(!mMuxConfigPresent);  // XXX to be implemented
+
+    sp<ABuffer> out = new ABuffer(buffer->size());
+    out->setRange(0, 0);
+
+    size_t offset = 0;
+    uint8_t *ptr = buffer->data();
+
+    for (size_t i = 0; i <= mNumSubFrames; ++i) {
+        // parse PayloadLengthInfo
+
+        unsigned payloadLength = 0;
+
+        switch (mFrameLengthType) {
+            case 0:
+            {
+                unsigned muxSlotLengthBytes = 0;
+                unsigned tmp;
+                do {
+                    CHECK_LT(offset, buffer->size());
+                    tmp = ptr[offset++];
+                    muxSlotLengthBytes += tmp;
+                } while (tmp == 0xff);
+
+                payloadLength = muxSlotLengthBytes;
+                break;
+            }
+
+            default:
+                TRESPASS();  // XXX to be implemented
+                break;
+        }
+
+        CHECK_LE(offset + payloadLength, buffer->size());
+
+        memcpy(out->data() + out->size(), &ptr[offset], payloadLength);
+        out->setRange(0, out->size() + payloadLength);
+
+        offset += payloadLength;
+
+        if (mOtherDataPresent) {
+            // We want to stay byte-aligned.
+
+            CHECK((mOtherDataLenBits % 8) == 0);
+            CHECK_LE(offset + (mOtherDataLenBits / 8), buffer->size());
+            offset += mOtherDataLenBits / 8;
+        }
+    }
+
+    CHECK_EQ(offset, buffer->size());
+
+    return out;
+}
+
+AMPEG4AudioAssembler::AMPEG4AudioAssembler(
+        const sp<AMessage> &notify, const AString &params)
     : mNotifyMsg(notify),
+      mMuxConfigPresent(false),
       mAccessUnitRTPTime(0),
       mNextExpectedSeqNoValid(false),
       mNextExpectedSeqNo(0),
       mAccessUnitDamaged(false) {
+    AString val;
+    if (!GetAttribute(params.c_str(), "cpresent", &val)) {
+        mMuxConfigPresent = true;
+    } else if (val == "0") {
+        mMuxConfigPresent = false;
+    } else {
+        CHECK(val == "1");
+        mMuxConfigPresent = true;
+    }
+
+    CHECK(GetAttribute(params.c_str(), "config", &val));
+
+    sp<ABuffer> config = decodeHex(val);
+    CHECK(config != NULL);
+
+    ABitReader bits(config->data(), config->size());
+    status_t err = parseStreamMuxConfig(
+            &bits, &mNumSubFrames, &mFrameLengthType,
+            &mOtherDataPresent, &mOtherDataLenBits);
+
+    CHECK_EQ(err, (status_t)NO_ERROR);
 }
 
 AMPEG4AudioAssembler::~AMPEG4AudioAssembler() {
@@ -108,13 +471,7 @@
     while (it != mPackets.end()) {
         const sp<ABuffer> &unit = *it;
 
-        size_t n = 0;
-        while (unit->data()[n] == 0xff) {
-            ++n;
-        }
-        ++n;
-
-        totalSize += unit->size() - n;
+        totalSize += unit->size();
         ++it;
     }
 
@@ -124,20 +481,13 @@
     while (it != mPackets.end()) {
         const sp<ABuffer> &unit = *it;
 
-        size_t n = 0;
-        while (unit->data()[n] == 0xff) {
-            ++n;
-        }
-        ++n;
-
         memcpy((uint8_t *)accessUnit->data() + offset,
-               unit->data() + n, unit->size() - n);
-
-        offset += unit->size() - n;
+               unit->data(), unit->size());
 
         ++it;
     }
 
+    accessUnit = removeLATMFraming(accessUnit);
     CopyTimes(accessUnit, *mPackets.begin());
 
 #if 0
diff --git a/media/libstagefright/rtsp/AMPEG4AudioAssembler.h b/media/libstagefright/rtsp/AMPEG4AudioAssembler.h
index bf9f204..9cef94c 100644
--- a/media/libstagefright/rtsp/AMPEG4AudioAssembler.h
+++ b/media/libstagefright/rtsp/AMPEG4AudioAssembler.h
@@ -27,9 +27,11 @@
 namespace android {
 
 struct AMessage;
+struct AString;
 
 struct AMPEG4AudioAssembler : public ARTPAssembler {
-    AMPEG4AudioAssembler(const sp<AMessage> &notify);
+    AMPEG4AudioAssembler(
+            const sp<AMessage> &notify, const AString &params);
 
 protected:
     virtual ~AMPEG4AudioAssembler();
@@ -40,6 +42,13 @@
 
 private:
     sp<AMessage> mNotifyMsg;
+
+    bool mMuxConfigPresent;
+    unsigned mNumSubFrames;
+    unsigned mFrameLengthType;
+    bool mOtherDataPresent;
+    unsigned mOtherDataLenBits;
+
     uint32_t mAccessUnitRTPTime;
     bool mNextExpectedSeqNoValid;
     uint32_t mNextExpectedSeqNo;
@@ -49,6 +58,8 @@
     AssemblyStatus addPacket(const sp<ARTPSource> &source);
     void submitAccessUnit();
 
+    sp<ABuffer> removeLATMFraming(const sp<ABuffer> &buffer);
+
     DISALLOW_EVIL_CONSTRUCTORS(AMPEG4AudioAssembler);
 };
 
diff --git a/media/libstagefright/rtsp/ARTPSource.cpp b/media/libstagefright/rtsp/ARTPSource.cpp
index 2518264..5aae4e7 100644
--- a/media/libstagefright/rtsp/ARTPSource.cpp
+++ b/media/libstagefright/rtsp/ARTPSource.cpp
@@ -57,7 +57,7 @@
         mAssembler = new AAVCAssembler(notify);
         mIssueFIRRequests = true;
     } else if (!strncmp(desc.c_str(), "MP4A-LATM/", 10)) {
-        mAssembler = new AMPEG4AudioAssembler(notify);
+        mAssembler = new AMPEG4AudioAssembler(notify, params);
     } else if (!strncmp(desc.c_str(), "H263-1998/", 10)
             || !strncmp(desc.c_str(), "H263-2000/", 10)) {
         mAssembler = new AH263Assembler(notify);
diff --git a/media/libstagefright/rtsp/ARTSPConnection.cpp b/media/libstagefright/rtsp/ARTSPConnection.cpp
index f928c06..e936923 100644
--- a/media/libstagefright/rtsp/ARTSPConnection.cpp
+++ b/media/libstagefright/rtsp/ARTSPConnection.cpp
@@ -23,11 +23,13 @@
 #include <media/stagefright/foundation/ABuffer.h>
 #include <media/stagefright/foundation/ADebug.h>
 #include <media/stagefright/foundation/AMessage.h>
+#include <media/stagefright/foundation/base64.h>
 #include <media/stagefright/MediaErrors.h>
 
 #include <arpa/inet.h>
 #include <fcntl.h>
 #include <netdb.h>
+#include <openssl/md5.h>
 #include <sys/socket.h>
 
 namespace android {
@@ -37,6 +39,7 @@
 
 ARTSPConnection::ARTSPConnection()
     : mState(DISCONNECTED),
+      mAuthType(NONE),
       mSocket(-1),
       mConnectionID(0),
       mNextCSeq(0),
@@ -114,10 +117,13 @@
 
 // static
 bool ARTSPConnection::ParseURL(
-        const char *url, AString *host, unsigned *port, AString *path) {
+        const char *url, AString *host, unsigned *port, AString *path,
+        AString *user, AString *pass) {
     host->clear();
     *port = 0;
     path->clear();
+    user->clear();
+    pass->clear();
 
     if (strncasecmp("rtsp://", url, 7)) {
         return false;
@@ -133,6 +139,24 @@
         path->setTo(slashPos);
     }
 
+    ssize_t atPos = host->find("@");
+
+    if (atPos >= 0) {
+        // Split of user:pass@ from hostname.
+
+        AString userPass(*host, 0, atPos);
+        host->erase(0, atPos + 1);
+
+        ssize_t colonPos = userPass.find(":");
+
+        if (colonPos < 0) {
+            *user = userPass;
+        } else {
+            user->setTo(userPass, 0, colonPos);
+            pass->setTo(userPass, colonPos + 1, userPass.size() - colonPos - 1);
+        }
+    }
+
     const char *colonPos = strchr(host->c_str(), ':');
 
     if (colonPos != NULL) {
@@ -187,7 +211,12 @@
 
     AString host, path;
     unsigned port;
-    if (!ParseURL(url.c_str(), &host, &port, &path)) {
+    if (!ParseURL(url.c_str(), &host, &port, &path, &mUser, &mPass)
+            || (mUser.size() > 0 && mPass.size() == 0)) {
+        // If we have a user name but no password we have to give up
+        // right here, since we currently have no way of asking the user
+        // for this information.
+
         LOGE("Malformed rtsp url %s", url.c_str());
 
         reply->setInt32("result", ERROR_MALFORMED);
@@ -197,6 +226,10 @@
         return;
     }
 
+    if (mUser.size() > 0) {
+        LOGV("user = '%s', pass = '%s'", mUser.c_str(), mPass.c_str());
+    }
+
     struct hostent *ent = gethostbyname(host.c_str());
     if (ent == NULL) {
         LOGE("Unknown host %s", host.c_str());
@@ -262,6 +295,11 @@
     reply->setInt32("result", OK);
     mState = DISCONNECTED;
 
+    mUser.clear();
+    mPass.clear();
+    mAuthType = NONE;
+    mNonce.clear();
+
     reply->post();
 }
 
@@ -335,6 +373,12 @@
     AString request;
     CHECK(msg->findString("request", &request));
 
+    // Just in case we need to re-issue the request with proper authentication
+    // later, stash it away.
+    reply->setString("original-request", request.c_str(), request.size());
+
+    addAuthentication(&request);
+
     // Find the boundary between headers and the body.
     ssize_t i = request.find("\r\n\r\n");
     CHECK_GE(i, 0);
@@ -347,7 +391,7 @@
 
     request.insert(cseqHeader, i + 2);
 
-    LOGV("%s", request.c_str());
+    LOGV("request: '%s'", request.c_str());
 
     size_t numBytesSent = 0;
     while (numBytesSent < request.size()) {
@@ -612,6 +656,30 @@
         }
     }
 
+    if (response->mStatusCode == 401) {
+        if (mAuthType == NONE && mUser.size() > 0
+                && parseAuthMethod(response)) {
+            ssize_t i;
+            CHECK_EQ((status_t)OK, findPendingRequest(response, &i));
+            CHECK_GE(i, 0);
+
+            sp<AMessage> reply = mPendingRequests.valueAt(i);
+            mPendingRequests.removeItemsAt(i);
+
+            AString request;
+            CHECK(reply->findString("original-request", &request));
+
+            sp<AMessage> msg = new AMessage(kWhatSendRequest, id());
+            msg->setMessage("reply", reply);
+            msg->setString("request", request.c_str(), request.size());
+
+            LOGI("re-sending request with authentication headers...");
+            onSendRequest(msg);
+
+            return true;
+        }
+    }
+
     return notifyResponseListener(response);
 }
 
@@ -628,26 +696,47 @@
     return true;
 }
 
-bool ARTSPConnection::notifyResponseListener(
-        const sp<ARTSPResponse> &response) {
+status_t ARTSPConnection::findPendingRequest(
+        const sp<ARTSPResponse> &response, ssize_t *index) const {
+    *index = 0;
+
     ssize_t i = response->mHeaders.indexOfKey("cseq");
 
     if (i < 0) {
-        return true;
+        // This is an unsolicited server->client message.
+        return OK;
     }
 
     AString value = response->mHeaders.valueAt(i);
 
     unsigned long cseq;
     if (!ParseSingleUnsignedLong(value.c_str(), &cseq)) {
-        return false;
+        return ERROR_MALFORMED;
     }
 
     i = mPendingRequests.indexOfKey(cseq);
 
     if (i < 0) {
-        // Unsolicited response?
-        TRESPASS();
+        return -ENOENT;
+    }
+
+    *index = i;
+
+    return OK;
+}
+
+bool ARTSPConnection::notifyResponseListener(
+        const sp<ARTSPResponse> &response) {
+    ssize_t i;
+    status_t err = findPendingRequest(response, &i);
+
+    if (err == OK && i < 0) {
+        // An unsolicited server response is not a problem.
+        return true;
+    }
+
+    if (err != OK) {
+        return false;
     }
 
     sp<AMessage> reply = mPendingRequests.valueAt(i);
@@ -660,4 +749,160 @@
     return true;
 }
 
+bool ARTSPConnection::parseAuthMethod(const sp<ARTSPResponse> &response) {
+    ssize_t i = response->mHeaders.indexOfKey("www-authenticate");
+
+    if (i < 0) {
+        return false;
+    }
+
+    AString value = response->mHeaders.valueAt(i);
+
+    if (!strncmp(value.c_str(), "Basic", 5)) {
+        mAuthType = BASIC;
+    } else {
+#if !defined(HAVE_ANDROID_OS)
+        // We don't have access to the MD5 implementation on the simulator,
+        // so we won't support digest authentication.
+        return false;
+#endif
+
+        CHECK(!strncmp(value.c_str(), "Digest", 6));
+        mAuthType = DIGEST;
+
+        i = value.find("nonce=");
+        CHECK_GE(i, 0);
+        CHECK_EQ(value.c_str()[i + 6], '\"');
+        ssize_t j = value.find("\"", i + 7);
+        CHECK_GE(j, 0);
+
+        mNonce.setTo(value, i + 7, j - i - 7);
+    }
+
+    return true;
+}
+
+#if defined(HAVE_ANDROID_OS)
+static void H(const AString &s, AString *out) {
+    out->clear();
+
+    MD5_CTX m;
+    MD5_Init(&m);
+    MD5_Update(&m, s.c_str(), s.size());
+
+    uint8_t key[16];
+    MD5_Final(key, &m);
+
+    for (size_t i = 0; i < 16; ++i) {
+        char nibble = key[i] >> 4;
+        if (nibble <= 9) {
+            nibble += '0';
+        } else {
+            nibble += 'a' - 10;
+        }
+        out->append(&nibble, 1);
+
+        nibble = key[i] & 0x0f;
+        if (nibble <= 9) {
+            nibble += '0';
+        } else {
+            nibble += 'a' - 10;
+        }
+        out->append(&nibble, 1);
+    }
+}
+#endif
+
+static void GetMethodAndURL(
+        const AString &request, AString *method, AString *url) {
+    ssize_t space1 = request.find(" ");
+    CHECK_GE(space1, 0);
+
+    ssize_t space2 = request.find(" ", space1 + 1);
+    CHECK_GE(space2, 0);
+
+    method->setTo(request, 0, space1);
+    url->setTo(request, space1 + 1, space2 - space1);
+}
+
+void ARTSPConnection::addAuthentication(AString *request) {
+    if (mAuthType == NONE) {
+        return;
+    }
+
+    // Find the boundary between headers and the body.
+    ssize_t i = request->find("\r\n\r\n");
+    CHECK_GE(i, 0);
+
+    if (mAuthType == BASIC) {
+        AString tmp;
+        tmp.append(mUser);
+        tmp.append(":");
+        tmp.append(mPass);
+
+        AString out;
+        encodeBase64(tmp.c_str(), tmp.size(), &out);
+
+        AString fragment;
+        fragment.append("Authorization: Basic ");
+        fragment.append(out);
+        fragment.append("\r\n");
+
+        request->insert(fragment, i + 2);
+
+        return;
+    }
+
+#if defined(HAVE_ANDROID_OS)
+    CHECK_EQ((int)mAuthType, (int)DIGEST);
+
+    AString method, url;
+    GetMethodAndURL(*request, &method, &url);
+
+    AString A1;
+    A1.append(mUser);
+    A1.append(":");
+    A1.append("Streaming Server");
+    A1.append(":");
+    A1.append(mPass);
+
+    AString A2;
+    A2.append(method);
+    A2.append(":");
+    A2.append(url);
+
+    AString HA1, HA2;
+    H(A1, &HA1);
+    H(A2, &HA2);
+
+    AString tmp;
+    tmp.append(HA1);
+    tmp.append(":");
+    tmp.append(mNonce);
+    tmp.append(":");
+    tmp.append(HA2);
+
+    AString digest;
+    H(tmp, &digest);
+
+    AString fragment;
+    fragment.append("Authorization: Digest ");
+    fragment.append("nonce=\"");
+    fragment.append(mNonce);
+    fragment.append("\", ");
+    fragment.append("username=\"");
+    fragment.append(mUser);
+    fragment.append("\", ");
+    fragment.append("uri=\"");
+    fragment.append(url);
+    fragment.append("\", ");
+    fragment.append("response=\"");
+    fragment.append(digest);
+    fragment.append("\"");
+    fragment.append("\r\n");
+
+    request->insert(fragment, i + 2);
+#endif
+}
+
 }  // namespace android
diff --git a/media/libstagefright/rtsp/ARTSPConnection.h b/media/libstagefright/rtsp/ARTSPConnection.h
index 96e0d5b..19be2a6 100644
--- a/media/libstagefright/rtsp/ARTSPConnection.h
+++ b/media/libstagefright/rtsp/ARTSPConnection.h
@@ -42,6 +42,10 @@
 
     void observeBinaryData(const sp<AMessage> &reply);
 
+    static bool ParseURL(
+            const char *url, AString *host, unsigned *port, AString *path,
+            AString *user, AString *pass);
+
 protected:
     virtual ~ARTSPConnection();
     virtual void onMessageReceived(const sp<AMessage> &msg);
@@ -62,9 +66,18 @@
         kWhatObserveBinaryData  = 'obin',
     };
 
+    enum AuthType {
+        NONE,
+        BASIC,
+        DIGEST
+    };
+
     static const int64_t kSelectTimeoutUs;
 
     State mState;
+    AString mUser, mPass;
+    AuthType mAuthType;
+    AString mNonce;
     int mSocket;
     int32_t mConnectionID;
     int32_t mNextCSeq;
@@ -90,8 +103,11 @@
     sp<ABuffer> receiveBinaryData();
     bool notifyResponseListener(const sp<ARTSPResponse> &response);
 
-    static bool ParseURL(
-            const char *url, AString *host, unsigned *port, AString *path);
+    bool parseAuthMethod(const sp<ARTSPResponse> &response);
+    void addAuthentication(AString *request);
+
+    status_t findPendingRequest(
+            const sp<ARTSPResponse> &response, ssize_t *index) const;
 
     static bool ParseSingleUnsignedLong(
             const char *from, unsigned long *x);
diff --git a/media/libstagefright/rtsp/ASessionDescription.cpp b/media/libstagefright/rtsp/ASessionDescription.cpp
index 612caff..77917b3 100644
--- a/media/libstagefright/rtsp/ASessionDescription.cpp
+++ b/media/libstagefright/rtsp/ASessionDescription.cpp
@@ -53,21 +53,30 @@
     mFormats.push(AString("[root]"));
 
     AString desc((const char *)data, size);
-    LOGI("%s", desc.c_str());
 
     size_t i = 0;
     for (;;) {
-        ssize_t eolPos = desc.find("\r\n", i);
+        ssize_t eolPos = desc.find("\n", i);
+
         if (eolPos < 0) {
             break;
         }
 
-        AString line(desc, i, eolPos - i);
+        AString line;
+        if ((size_t)eolPos > i && desc.c_str()[eolPos - 1] == '\r') {
+            // We accept both '\n' and '\r\n' line endings, if it's
+            // the latter, strip the '\r' as well.
+            line.setTo(desc, i, eolPos - i - 1);
+        } else {
+            line.setTo(desc, i, eolPos - i);
+        }
 
         if (line.size() < 2 || line.c_str()[1] != '=') {
             return false;
         }
 
+        LOGI("%s", line.c_str());
+
         switch (line.c_str()[0]) {
             case 'v':
             {
@@ -141,7 +150,7 @@
             }
         }
 
-        i = eolPos + 2;
+        i = eolPos + 1;
     }
 
     return true;
@@ -245,7 +254,7 @@
         return false;
     }
 
-    if (value == "npt=now-") {
+    if (value == "npt=now-" || value == "npt=0-") {
         return false;
     }
 
@@ -256,15 +265,17 @@
     const char *s = value.c_str() + 4;
     char *end;
     double from = strtod(s, &end);
-    CHECK_GT(end, s);
-    CHECK_EQ(*end, '-');
+
+    if (end == s || *end != '-') {
+        return false;
+    }
 
     s = end + 1;
     double to = strtod(s, &end);
-    CHECK_GT(end, s);
-    CHECK_EQ(*end, '\0');
 
-    CHECK_GE(to, from);
+    if (end == s || *end != '\0' || to < from) {
+        return false;
+    }
 
     *durationUs = (int64_t)((to - from) * 1E6);
 
diff --git a/media/libstagefright/rtsp/Android.mk b/media/libstagefright/rtsp/Android.mk
index 081ae32..0bbadc1 100644
--- a/media/libstagefright/rtsp/Android.mk
+++ b/media/libstagefright/rtsp/Android.mk
@@ -23,6 +23,7 @@
 	$(JNI_H_INCLUDE) \
 	$(TOP)/frameworks/base/include/media/stagefright/openmax \
         $(TOP)/frameworks/base/media/libstagefright/include \
+        $(TOP)/external/openssl/include
 
 LOCAL_MODULE:= libstagefright_rtsp
 
diff --git a/media/libstagefright/rtsp/MyHandler.h b/media/libstagefright/rtsp/MyHandler.h
index 6943608..9bb8c46 100644
--- a/media/libstagefright/rtsp/MyHandler.h
+++ b/media/libstagefright/rtsp/MyHandler.h
@@ -96,6 +96,7 @@
           mNetLooper(new ALooper),
           mConn(new ARTSPConnection),
           mRTPConn(new ARTPConnection),
+          mOriginalSessionURL(url),
           mSessionURL(url),
           mSetupTracksSuccessful(false),
           mSeekPending(false),
@@ -113,6 +114,23 @@
         mNetLooper->start(false /* runOnCallingThread */,
                           false /* canCallJava */,
                           PRIORITY_HIGHEST);
+
+        // Strip any authentication info from the session url, we don't
+        // want to transmit user/pass in cleartext.
+        AString host, path, user, pass;
+        unsigned port;
+        if (ARTSPConnection::ParseURL(
+                    mSessionURL.c_str(), &host, &port, &path, &user, &pass)
+                && user.size() > 0) {
+            mSessionURL.clear();
+            mSessionURL.append("rtsp://");
+            mSessionURL.append(host);
+            mSessionURL.append(":");
+            mSessionURL.append(StringPrintf("%u", port));
+            mSessionURL.append(path);
+
+            LOGI("rewritten session url: '%s'", mSessionURL.c_str());
+        }
     }
 
     void connect(const sp<AMessage> &doneMsg) {
@@ -126,7 +144,7 @@
         mConn->observeBinaryData(notify);
 
         sp<AMessage> reply = new AMessage('conn', id());
-        mConn->connect(mSessionURL.c_str(), reply);
+        mConn->connect(mOriginalSessionURL.c_str(), reply);
     }
 
     void disconnect(const sp<AMessage> &doneMsg) {
@@ -312,7 +330,7 @@
                 int32_t reconnect;
                 if (msg->findInt32("reconnect", &reconnect) && reconnect) {
                     sp<AMessage> reply = new AMessage('conn', id());
-                    mConn->connect(mSessionURL.c_str(), reply);
+                    mConn->connect(mOriginalSessionURL.c_str(), reply);
                 } else {
                     (new AMessage('quit', id()))->post();
                 }
@@ -922,7 +940,7 @@
         CHECK(GetAttribute(range.c_str(), "npt", &val));
         float npt1, npt2;
 
-        if (val == "now-") {
+        if (val == "now-" || val == "0-") {
             // This is a live stream and therefore not seekable.
             return;
         } else {
@@ -992,6 +1010,7 @@
     sp<ARTSPConnection> mConn;
     sp<ARTPConnection> mRTPConn;
     sp<ASessionDescription> mSessionDesc;
+    AString mOriginalSessionURL;  // This one still has user:pass@
     AString mSessionURL;
     AString mBaseURL;
     AString mSessionID;
diff --git a/services/audioflinger/AudioPolicyManagerBase.cpp b/services/audioflinger/AudioPolicyManagerBase.cpp
index 425ca31..8d16ab4 100644
--- a/services/audioflinger/AudioPolicyManagerBase.cpp
+++ b/services/audioflinger/AudioPolicyManagerBase.cpp
@@ -81,12 +81,6 @@
                     LOGV("setDeviceConnectionState() BT SCO  device, address %s", device_address);
                     // keep track of SCO device address
                     mScoDeviceAddress = String8(device_address, MAX_DEVICE_ADDRESS_LEN);
-#ifdef WITH_A2DP
-                    if (mA2dpOutput != 0 &&
-                        mPhoneState != AudioSystem::MODE_NORMAL) {
-                        mpClientInterface->suspendOutput(mA2dpOutput);
-                    }
-#endif
                 }
             }
             break;
@@ -115,12 +109,6 @@
             {
                 if (AudioSystem::isBluetoothScoDevice(device)) {
                     mScoDeviceAddress = "";
-#ifdef WITH_A2DP
-                    if (mA2dpOutput != 0 &&
-                        mPhoneState != AudioSystem::MODE_NORMAL) {
-                        mpClientInterface->restoreOutput(mA2dpOutput);
-                    }
-#endif
                 }
             }
             } break;
@@ -138,6 +126,7 @@
         if (state == AudioSystem::DEVICE_STATE_UNAVAILABLE && AudioSystem::isA2dpDevice(device)) {
             closeA2dpOutputs();
         }
+        checkA2dpSuspend();
 #endif
         updateDeviceForStrategy();
         setOutputDevice(mHardwareOutput, newDevice);
@@ -275,14 +264,7 @@
     newDevice = getNewDevice(mHardwareOutput, false);
 #ifdef WITH_A2DP
     checkOutputForAllStrategies();
-    // suspend A2DP output if a SCO device is present.
-    if (mA2dpOutput != 0 && mScoDeviceAddress != "") {
-        if (oldState == AudioSystem::MODE_NORMAL) {
-            mpClientInterface->suspendOutput(mA2dpOutput);
-        } else if (state == AudioSystem::MODE_NORMAL) {
-            mpClientInterface->restoreOutput(mA2dpOutput);
-        }
-    }
+    checkA2dpSuspend();
 #endif
     updateDeviceForStrategy();
 
@@ -387,6 +369,7 @@
     uint32_t newDevice = getNewDevice(mHardwareOutput, false);
 #ifdef WITH_A2DP
     checkOutputForAllStrategies();
+    checkA2dpSuspend();
 #endif
     updateDeviceForStrategy();
     setOutputDevice(mHardwareOutput, newDevice);
@@ -1017,8 +1000,10 @@
 #ifdef AUDIO_POLICY_TEST
     Thread(false),
 #endif //AUDIO_POLICY_TEST
-    mPhoneState(AudioSystem::MODE_NORMAL), mRingerMode(0), mMusicStopTime(0),
-    mLimitRingtoneVolume(false), mTotalEffectsCpuLoad(0), mTotalEffectsMemory(0)
+    mPhoneState(AudioSystem::MODE_NORMAL), mRingerMode(0),
+    mMusicStopTime(0), mLimitRingtoneVolume(false), mLastVoiceVolume(-1.0f),
+    mTotalEffectsCpuLoad(0), mTotalEffectsMemory(0),
+    mA2dpSuspended(false)
 {
     mpClientInterface = clientInterface;
 
@@ -1314,17 +1299,6 @@
     }
     AudioOutputDescriptor *hwOutputDesc = mOutputs.valueFor(mHardwareOutput);
 
-    if (mScoDeviceAddress != "") {
-        // It is normal to suspend twice if we are both in call,
-        // and have the hardware audio output routed to BT SCO
-        if (mPhoneState != AudioSystem::MODE_NORMAL) {
-            mpClientInterface->suspendOutput(mA2dpOutput);
-        }
-        if (AudioSystem::isBluetoothScoDevice((AudioSystem::audio_devices)hwOutputDesc->device())) {
-            mpClientInterface->suspendOutput(mA2dpOutput);
-        }
-    }
-
     if (!a2dpUsedForSonification()) {
         // mute music on A2DP output if a notification or ringtone is playing
         uint32_t refCount = hwOutputDesc->strategyRefCount(STRATEGY_SONIFICATION);
@@ -1332,6 +1306,9 @@
             setStrategyMute(STRATEGY_MEDIA, true, mA2dpOutput);
         }
     }
+
+    mA2dpSuspended = false;
+
     return NO_ERROR;
 }
 
@@ -1361,6 +1338,7 @@
         }
     }
     mA2dpDeviceAddress = "";
+    mA2dpSuspended = false;
     return NO_ERROR;
 }
 
@@ -1458,6 +1436,48 @@
     checkOutputForStrategy(STRATEGY_DTMF);
 }
 
+void AudioPolicyManagerBase::checkA2dpSuspend()
+{
+    // suspend A2DP output if:
+    //      (NOT already suspended) &&
+    //      ((SCO device is connected &&
+    //       (forced usage for communication || for record is SCO))) ||
+    //      (phone state is ringing || in call)
+    //
+    // restore A2DP output if:
+    //      (Already suspended) &&
+    //      ((SCO device is NOT connected ||
+    //       (forced usage NOT for communication && NOT for record is SCO))) &&
+    //      (phone state is NOT ringing && NOT in call)
+    //
+    if (mA2dpOutput == 0) {
+        return;
+    }
+
+    if (mA2dpSuspended) {
+        if (((mScoDeviceAddress == "") ||
+             ((mForceUse[AudioSystem::FOR_COMMUNICATION] != AudioSystem::FORCE_BT_SCO) &&
+              (mForceUse[AudioSystem::FOR_RECORD] != AudioSystem::FORCE_BT_SCO))) &&
+             ((mPhoneState != AudioSystem::MODE_IN_CALL) &&
+              (mPhoneState != AudioSystem::MODE_RINGTONE))) {
+
+            mpClientInterface->restoreOutput(mA2dpOutput);
+            mA2dpSuspended = false;
+        }
+    } else {
+        if (((mScoDeviceAddress != "") &&
+             ((mForceUse[AudioSystem::FOR_COMMUNICATION] == AudioSystem::FORCE_BT_SCO) ||
+              (mForceUse[AudioSystem::FOR_RECORD] == AudioSystem::FORCE_BT_SCO))) ||
+             ((mPhoneState == AudioSystem::MODE_IN_CALL) ||
+              (mPhoneState == AudioSystem::MODE_RINGTONE))) {
+
+            mpClientInterface->suspendOutput(mA2dpOutput);
+            mA2dpSuspended = true;
+        }
+    }
+}
+
+
 #endif
 
 uint32_t AudioPolicyManagerBase::getNewDevice(audio_io_handle_t output, bool fromCache)
@@ -1697,14 +1717,7 @@
         // wait for the PCM output buffers to empty before proceeding with the rest of the command
         usleep(outputDesc->mLatency*2*1000);
     }
-#ifdef WITH_A2DP
-    // suspend A2DP output if SCO device is selected
-    if (AudioSystem::isBluetoothScoDevice((AudioSystem::audio_devices)device)) {
-         if (mA2dpOutput != 0) {
-             mpClientInterface->suspendOutput(mA2dpOutput);
-         }
-    }
-#endif
+
     // do the routing
     AudioParameter param = AudioParameter();
     param.addInt(String8(AudioParameter::keyRouting), (int)device);
@@ -1712,15 +1725,6 @@
     // update stream volumes according to new device
     applyStreamVolumes(output, device, delayMs);
 
-#ifdef WITH_A2DP
-    // if disconnecting SCO device, restore A2DP output
-    if (AudioSystem::isBluetoothScoDevice((AudioSystem::audio_devices)prevDevice)) {
-         if (mA2dpOutput != 0) {
-             LOGV("restore A2DP output");
-             mpClientInterface->restoreOutput(mA2dpOutput);
-         }
-    }
-#endif
     // if changing from a combined headset + speaker route, unmute media streams
     if (output == mHardwareOutput && AudioSystem::popCount(prevDevice) == 2) {
         setStrategyMute(STRATEGY_MEDIA, false, output, delayMs);
@@ -1835,29 +1839,38 @@
     }
 
     float volume = computeVolume(stream, index, output, device);
-    // do not set volume if the float value did not change
-    if (volume != mOutputs.valueFor(output)->mCurVolume[stream] || force) {
+    // We actually change the volume if:
+    // - the float value returned by computeVolume() changed
+    // - the force flag is set
+    if (volume != mOutputs.valueFor(output)->mCurVolume[stream] ||
+            force) {
         mOutputs.valueFor(output)->mCurVolume[stream] = volume;
         LOGV("setStreamVolume() for output %d stream %d, volume %f, delay %d", output, stream, volume, delayMs);
         if (stream == AudioSystem::VOICE_CALL ||
             stream == AudioSystem::DTMF ||
             stream == AudioSystem::BLUETOOTH_SCO) {
-            float voiceVolume = -1.0;
             // offset value to reflect actual hardware volume that never reaches 0
             // 1% corresponds roughly to first step in VOICE_CALL stream volume setting (see AudioService.java)
             volume = 0.01 + 0.99 * volume;
-            if (stream == AudioSystem::VOICE_CALL) {
-                voiceVolume = (float)index/(float)mStreams[stream].mIndexMax;
-            } else if (stream == AudioSystem::BLUETOOTH_SCO) {
-                voiceVolume = 1.0;
-            }
-            if (voiceVolume >= 0 && output == mHardwareOutput) {
-                mpClientInterface->setVoiceVolume(voiceVolume, delayMs);
-            }
         }
         mpClientInterface->setStreamVolume((AudioSystem::stream_type)stream, volume, output, delayMs);
     }
 
+    if (stream == AudioSystem::VOICE_CALL ||
+        stream == AudioSystem::BLUETOOTH_SCO) {
+        float voiceVolume;
+        // Force voice volume to max for bluetooth SCO as volume is managed by the headset
+        if (stream == AudioSystem::VOICE_CALL) {
+            voiceVolume = (float)index/(float)mStreams[stream].mIndexMax;
+        } else {
+            voiceVolume = 1.0;
+        }
+        if (voiceVolume != mLastVoiceVolume && output == mHardwareOutput) {
+            mpClientInterface->setVoiceVolume(voiceVolume, delayMs);
+            mLastVoiceVolume = voiceVolume;
+        }
+    }
+
     return NO_ERROR;
 }