diff --git a/common/hdr_util.h b/common/hdr_util.h
index fce055b..f05be1d 100644
--- a/common/hdr_util.h
+++ b/common/hdr_util.h
@@ -12,14 +12,14 @@
 
 #include "../mkvmuxer.hpp"
 
+namespace libwebm {
+
 namespace mkvparser {
 struct Colour;
 struct MasteringMetadata;
 struct PrimaryChromaticity;
 }  // namespace mkvparser
 
-namespace libwebm {
-
 // Utility types and functions for working with the Colour element and its
 // children. Copiers return true upon success. Presence functions return true
 // when the specified element is present.
diff --git a/mkvmuxer.cpp b/mkvmuxer.cpp
index 27f2f08..f31e553 100644
--- a/mkvmuxer.cpp
+++ b/mkvmuxer.cpp
@@ -29,6 +29,7 @@
 #pragma warning(disable : 4996)
 #endif
 
+namespace libwebm {
 namespace mkvmuxer {
 
 const float MasteringMetadata::kValueNotPresent = FLT_MAX;
@@ -121,7 +122,7 @@ bool WriteEbmlHeader(IMkvWriter* writer) {
 }
 
 bool ChunkedCopy(mkvparser::IMkvReader* source, mkvmuxer::IMkvWriter* dst,
-                 mkvmuxer::int64 start, int64 size) {
+                 int64 start, int64 size) {
   // TODO(vigneshv): Check if this is a reasonable value.
   const uint32 kBufSize = 2048;
   uint8* buf = new uint8[kBufSize];
@@ -3595,3 +3596,4 @@ bool Segment::WriteFramesLessThan(uint64 timestamp) {
 }
 
 }  // namespace mkvmuxer
+}  // namespace libwebm
diff --git a/mkvmuxer.hpp b/mkvmuxer.hpp
index 9a79225..b449d00 100644
--- a/mkvmuxer.hpp
+++ b/mkvmuxer.hpp
@@ -17,9 +17,11 @@
 // For a description of the WebM elements see
 // http://www.webmproject.org/code/specs/container/.
 
+namespace libwebm {
+
 namespace mkvparser {
 class IMkvReader;
-}  // end namespace
+}  // namespace mkvparser
 
 namespace mkvmuxer {
 
@@ -1610,6 +1612,7 @@ class Segment {
   LIBWEBM_DISALLOW_COPY_AND_ASSIGN(Segment);
 };
 
-}  // end namespace mkvmuxer
+}  // namespace mkvmuxer
+}  // namespace libwebm
 
 #endif  // MKVMUXER_HPP
diff --git a/mkvmuxertypes.hpp b/mkvmuxertypes.hpp
index d0fc9fe..d91dd06 100644
--- a/mkvmuxertypes.hpp
+++ b/mkvmuxertypes.hpp
@@ -16,8 +16,10 @@
   TypeName(const TypeName&);                       \
   void operator=(const TypeName&)
 
-namespace mkvmuxer {
+namespace libwebm {
 
+// TODO(tomfinegan): These types are no longer necessary: drop these, and use
+// cstdint/stdint.h types.
 typedef unsigned char uint8;
 typedef short int16;
 typedef int int32;
@@ -25,6 +27,6 @@ typedef unsigned int uint32;
 typedef long long int64;
 typedef unsigned long long uint64;
 
-}  // end namespace mkvmuxer
+}  // namespace libwebm
 
 #endif  // MKVMUXERTYPES_HPP
diff --git a/mkvmuxerutil.cpp b/mkvmuxerutil.cpp
index 4dc0567..b4fc282 100644
--- a/mkvmuxerutil.cpp
+++ b/mkvmuxerutil.cpp
@@ -29,6 +29,7 @@
 #pragma warning(disable : 4996)
 #endif
 
+namespace libwebm {
 namespace mkvmuxer {
 
 namespace {
@@ -592,9 +593,7 @@ void GetVersion(int32* major, int32* minor, int32* build, int32* revision) {
   *revision = 0;
 }
 
-}  // namespace mkvmuxer
-
-mkvmuxer::uint64 mkvmuxer::MakeUID(unsigned int* seed) {
+uint64 MakeUID(unsigned int* seed) {
   uint64 uid = 0;
 
 #ifdef __MINGW32__
@@ -628,3 +627,6 @@ mkvmuxer::uint64 mkvmuxer::MakeUID(unsigned int* seed) {
 
   return uid;
 }
+
+}  // namespace mkvmuxer
+}  // namespace libwebm
\ No newline at end of file
diff --git a/mkvmuxerutil.hpp b/mkvmuxerutil.hpp
index bf2214a..cadc097 100644
--- a/mkvmuxerutil.hpp
+++ b/mkvmuxerutil.hpp
@@ -11,6 +11,7 @@
 
 #include "mkvmuxertypes.hpp"
 
+namespace libwebm {
 namespace mkvmuxer {
 class Cluster;
 class Frame;
@@ -78,6 +79,7 @@ void GetVersion(int32* major, int32* minor, int32* build, int32* revision);
 // the random-number generator (see POSIX rand_r() for semantics).
 uint64 MakeUID(unsigned int* seed);
 
-}  // end namespace mkvmuxer
+}  // namespace mkvmuxer
+}  // namespace libwebm
 
 #endif  // MKVMUXERUTIL_HPP
diff --git a/mkvparser.cpp b/mkvparser.cpp
index d038e7a..b32c062 100644
--- a/mkvparser.cpp
+++ b/mkvparser.cpp
@@ -28,6 +28,7 @@
 #pragma warning(disable : 4996)
 #endif
 
+namespace libwebm {
 namespace mkvparser {
 const double MasteringMetadata::kValueNotPresent = DBL_MAX;
 const long long Colour::kValueNotPresent = LLONG_MAX;
@@ -550,8 +551,7 @@ long long EBMLHeader::Parse(IMkvReader* pReader, long long& pos) {
   if (ebml_id == E_BUFFER_NOT_FULL)
     return E_BUFFER_NOT_FULL;
 
-  // TODO(tomfinegan): Move Matroska ID constants into a common namespace.
-  if (len != 4 || ebml_id != mkvmuxer::kMkvEBML)
+  if (len != 4 || ebml_id != kMkvEBML)
     return E_FILE_FORMAT_INVALID;
 
   // Move read pos forward to the EBML header size field.
@@ -605,27 +605,27 @@ long long EBMLHeader::Parse(IMkvReader* pReader, long long& pos) {
     if (size == 0)
       return E_FILE_FORMAT_INVALID;
 
-    if (id == mkvmuxer::kMkvEBMLVersion) {
+    if (id == kMkvEBMLVersion) {
       m_version = UnserializeUInt(pReader, pos, size);
 
       if (m_version <= 0)
         return E_FILE_FORMAT_INVALID;
-    } else if (id == mkvmuxer::kMkvEBMLReadVersion) {
+    } else if (id == kMkvEBMLReadVersion) {
       m_readVersion = UnserializeUInt(pReader, pos, size);
 
       if (m_readVersion <= 0)
         return E_FILE_FORMAT_INVALID;
-    } else if (id == mkvmuxer::kMkvEBMLMaxIDLength) {
+    } else if (id == kMkvEBMLMaxIDLength) {
       m_maxIdLength = UnserializeUInt(pReader, pos, size);
 
       if (m_maxIdLength <= 0)
         return E_FILE_FORMAT_INVALID;
-    } else if (id == mkvmuxer::kMkvEBMLMaxSizeLength) {
+    } else if (id == kMkvEBMLMaxSizeLength) {
       m_maxSizeLength = UnserializeUInt(pReader, pos, size);
 
       if (m_maxSizeLength <= 0)
         return E_FILE_FORMAT_INVALID;
-    } else if (id == mkvmuxer::kMkvDocType) {
+    } else if (id == kMkvDocType) {
       if (m_docType)
         return E_FILE_FORMAT_INVALID;
 
@@ -633,12 +633,12 @@ long long EBMLHeader::Parse(IMkvReader* pReader, long long& pos) {
 
       if (status)  // error
         return status;
-    } else if (id == mkvmuxer::kMkvDocTypeVersion) {
+    } else if (id == kMkvDocTypeVersion) {
       m_docTypeVersion = UnserializeUInt(pReader, pos, size);
 
       if (m_docTypeVersion <= 0)
         return E_FILE_FORMAT_INVALID;
-    } else if (id == mkvmuxer::kMkvDocTypeReadVersion) {
+    } else if (id == kMkvDocTypeReadVersion) {
       m_docTypeReadVersion = UnserializeUInt(pReader, pos, size);
 
       if (m_docTypeReadVersion <= 0)
@@ -792,7 +792,7 @@ long long Segment::CreateInstance(IMkvReader* pReader, long long pos,
     // Handle "unknown size" for live streaming of webm files.
     const long long unknown_size = (1LL << (7 * len)) - 1;
 
-    if (id == mkvmuxer::kMkvSegment) {
+    if (id == kMkvSegment) {
       if (size == unknown_size)
         size = -1;
 
@@ -884,7 +884,7 @@ long long Segment::ParseHeaders() {
     if (id < 0)
       return E_FILE_FORMAT_INVALID;
 
-    if (id == mkvmuxer::kMkvCluster)
+    if (id == kMkvCluster)
       break;
 
     pos += len;  // consume ID
@@ -936,7 +936,7 @@ long long Segment::ParseHeaders() {
     if ((pos + size) > available)
       return pos + size;
 
-    if (id == mkvmuxer::kMkvInfo) {
+    if (id == kMkvInfo) {
       if (m_pInfo)
         return E_FILE_FORMAT_INVALID;
 
@@ -950,7 +950,7 @@ long long Segment::ParseHeaders() {
 
       if (status)
         return status;
-    } else if (id == mkvmuxer::kMkvTracks) {
+    } else if (id == kMkvTracks) {
       if (m_pTracks)
         return E_FILE_FORMAT_INVALID;
 
@@ -964,7 +964,7 @@ long long Segment::ParseHeaders() {
 
       if (status)
         return status;
-    } else if (id == mkvmuxer::kMkvCues) {
+    } else if (id == kMkvCues) {
       if (m_pCues == NULL) {
         m_pCues = new (std::nothrow)
             Cues(this, pos, size, element_start, element_size);
@@ -972,7 +972,7 @@ long long Segment::ParseHeaders() {
         if (m_pCues == NULL)
           return -1;
       }
-    } else if (id == mkvmuxer::kMkvSeekHead) {
+    } else if (id == kMkvSeekHead) {
       if (m_pSeekHead == NULL) {
         m_pSeekHead = new (std::nothrow)
             SeekHead(this, pos, size, element_start, element_size);
@@ -985,7 +985,7 @@ long long Segment::ParseHeaders() {
         if (status)
           return status;
       }
-    } else if (id == mkvmuxer::kMkvChapters) {
+    } else if (id == kMkvChapters) {
       if (m_pChapters == NULL) {
         m_pChapters = new (std::nothrow)
             Chapters(this, pos, size, element_start, element_size);
@@ -998,7 +998,7 @@ long long Segment::ParseHeaders() {
         if (status)
           return status;
       }
-    } else if (id == mkvmuxer::kMkvTags) {
+    } else if (id == kMkvTags) {
       if (m_pTags == NULL) {
         m_pTags = new (std::nothrow)
             Tags(this, pos, size, element_start, element_size);
@@ -1137,7 +1137,7 @@ long Segment::DoLoadCluster(long long& pos, long& len) {
       return E_FILE_FORMAT_INVALID;
     }
 
-    if (id == mkvmuxer::kMkvCues) {
+    if (id == kMkvCues) {
       if (size == unknown_size) {
         // Cues element of unknown size: Not supported.
         return E_FILE_FORMAT_INVALID;
@@ -1155,7 +1155,7 @@ long Segment::DoLoadCluster(long long& pos, long& len) {
       continue;
     }
 
-    if (id != mkvmuxer::kMkvCluster) {
+    if (id != kMkvCluster) {
       // Besides the Segment, Libwebm allows only cluster elements of unknown
       // size. Fail the parse upon encountering a non-cluster element reporting
       // unknown size.
@@ -1518,9 +1518,9 @@ long SeekHead::Parse() {
     if (status < 0)  // error
       return status;
 
-    if (id == mkvmuxer::kMkvSeek)
+    if (id == kMkvSeek)
       ++entry_count;
-    else if (id == mkvmuxer::kMkvVoid)
+    else if (id == kMkvVoid)
       ++void_element_count;
 
     pos += size;  // consume payload
@@ -1559,14 +1559,14 @@ long SeekHead::Parse() {
     if (status < 0)  // error
       return status;
 
-    if (id == mkvmuxer::kMkvSeek) {
+    if (id == kMkvSeek) {
       if (ParseEntry(pReader, pos, size, pEntry)) {
         Entry& e = *pEntry++;
 
         e.element_start = idpos;
         e.element_size = (pos + size) - idpos;
       }
-    } else if (id == mkvmuxer::kMkvVoid) {
+    } else if (id == kMkvVoid) {
       VoidElement& e = *pVoidElement++;
 
       e.element_start = idpos;
@@ -1670,7 +1670,7 @@ long Segment::ParseCues(long long off, long long& pos, long& len) {
 
   const long long id = ReadID(m_pReader, idpos, len);
 
-  if (id != mkvmuxer::kMkvCues)
+  if (id != kMkvCues)
     return E_FILE_FORMAT_INVALID;
 
   pos += len;  // consume ID
@@ -1752,7 +1752,7 @@ bool SeekHead::ParseEntry(IMkvReader* pReader, long long start, long long size_,
   if (seekIdId < 0)
     return false;
 
-  if (seekIdId != mkvmuxer::kMkvSeekID)
+  if (seekIdId != kMkvSeekID)
     return false;
 
   if ((pos + len) > stop)
@@ -1796,7 +1796,7 @@ bool SeekHead::ParseEntry(IMkvReader* pReader, long long start, long long size_,
 
   const long long seekPosId = ReadID(pReader, pos, len);
 
-  if (seekPosId != mkvmuxer::kMkvSeekPosition)
+  if (seekPosId != kMkvSeekPosition)
     return false;
 
   if ((pos + len) > stop)
@@ -1906,7 +1906,7 @@ bool Cues::Init() const {
       return false;
     }
 
-    if (id == mkvmuxer::kMkvCuePoint) {
+    if (id == kMkvCuePoint) {
       if (!PreloadCuePoint(cue_points_size, idpos))
         return false;
     }
@@ -1981,7 +1981,7 @@ bool Cues::LoadCuePoint() const {
     if ((m_pos + size) > stop)
       return false;
 
-    if (id != mkvmuxer::kMkvCuePoint) {
+    if (id != kMkvCuePoint) {
       m_pos += size;  // consume payload
       if (m_pos > stop)
         return false;
@@ -2292,7 +2292,7 @@ bool CuePoint::Load(IMkvReader* pReader) {
     long len;
 
     const long long id = ReadID(pReader, pos_, len);
-    if (id != mkvmuxer::kMkvCuePoint)
+    if (id != kMkvCuePoint)
       return false;
 
     pos_ += len;  // consume ID
@@ -2332,10 +2332,10 @@ bool CuePoint::Load(IMkvReader* pReader) {
       return false;
     }
 
-    if (id == mkvmuxer::kMkvCueTime)
+    if (id == kMkvCueTime)
       m_timecode = UnserializeUInt(pReader, pos, size);
 
-    else if (id == mkvmuxer::kMkvCueTrackPositions)
+    else if (id == kMkvCueTrackPositions)
       ++m_track_positions_count;
 
     pos += size;  // consume payload
@@ -2374,7 +2374,7 @@ bool CuePoint::Load(IMkvReader* pReader) {
     pos += len;  // consume Size field
     assert((pos + size) <= stop);
 
-    if (id == mkvmuxer::kMkvCueTrackPositions) {
+    if (id == kMkvCueTrackPositions) {
       TrackPosition& tp = *p++;
       if (!tp.Parse(pReader, pos, size)) {
         return false;
@@ -2423,11 +2423,11 @@ bool CuePoint::TrackPosition::Parse(IMkvReader* pReader, long long start_,
       return false;
     }
 
-    if (id == mkvmuxer::kMkvCueTrack)
+    if (id == kMkvCueTrack)
       m_track = UnserializeUInt(pReader, pos, size);
-    else if (id == mkvmuxer::kMkvCueClusterPosition)
+    else if (id == kMkvCueClusterPosition)
       m_pos = UnserializeUInt(pReader, pos, size);
-    else if (id == mkvmuxer::kMkvCueBlockNumber)
+    else if (id == kMkvCueBlockNumber)
       m_block = UnserializeUInt(pReader, pos, size);
 
     pos += size;  // consume payload
@@ -2561,7 +2561,7 @@ const Cluster* Segment::GetNext(const Cluster* pCurr) {
       return NULL;
 
     const long long id = ReadID(m_pReader, pos, len);
-    if (id != mkvmuxer::kMkvCluster)
+    if (id != kMkvCluster)
       return NULL;
 
     pos += len;  // consume ID
@@ -2618,7 +2618,7 @@ const Cluster* Segment::GetNext(const Cluster* pCurr) {
     if (size == 0)  // weird
       continue;
 
-    if (id == mkvmuxer::kMkvCluster) {
+    if (id == kMkvCluster) {
       const long long off_next_ = idpos - m_start;
 
       long long pos_;
@@ -2768,7 +2768,7 @@ long Segment::ParseNext(const Cluster* pCurr, const Cluster*& pResult,
 
     const long long id = ReadUInt(m_pReader, pos, len);
 
-    if (id != mkvmuxer::kMkvCluster)
+    if (id != kMkvCluster)
       return -1;
 
     pos += len;  // consume ID
@@ -2933,7 +2933,7 @@ long Segment::DoParseNext(const Cluster*& pResult, long long& pos, long& len) {
       return E_FILE_FORMAT_INVALID;
     }
 
-    if (id == mkvmuxer::kMkvCues) {
+    if (id == kMkvCues) {
       if (size == unknown_size)
         return E_FILE_FORMAT_INVALID;
 
@@ -2959,7 +2959,7 @@ long Segment::DoParseNext(const Cluster*& pResult, long long& pos, long& len) {
       continue;
     }
 
-    if (id != mkvmuxer::kMkvCluster) {  // not a Cluster ID
+    if (id != kMkvCluster) {  // not a Cluster ID
       if (size == unknown_size)
         return E_FILE_FORMAT_INVALID;
 
@@ -3097,7 +3097,7 @@ long Segment::DoParseNext(const Cluster*& pResult, long long& pos, long& len) {
       // that we have exhausted the sub-element's inside the cluster
       // whose ID we parsed earlier.
 
-      if (id == mkvmuxer::kMkvCluster || id == mkvmuxer::kMkvCues)
+      if (id == kMkvCluster || id == kMkvCues)
         break;
 
       pos += len;  // consume ID (of sub-element)
@@ -3265,7 +3265,7 @@ long Chapters::Parse() {
     if (size == 0)  // weird
       continue;
 
-    if (id == mkvmuxer::kMkvEditionEntry) {
+    if (id == kMkvEditionEntry) {
       status = ParseEdition(pos, size);
 
       if (status < 0)  // error
@@ -3381,7 +3381,7 @@ long Chapters::Edition::Parse(IMkvReader* pReader, long long pos,
     if (size == 0)
       continue;
 
-    if (id == mkvmuxer::kMkvChapterAtom) {
+    if (id == kMkvChapterAtom) {
       status = ParseAtom(pReader, pos, size);
 
       if (status < 0)  // error
@@ -3514,17 +3514,17 @@ long Chapters::Atom::Parse(IMkvReader* pReader, long long pos, long long size) {
     if (size == 0)  // 0 length payload, skip.
       continue;
 
-    if (id == mkvmuxer::kMkvChapterDisplay) {
+    if (id == kMkvChapterDisplay) {
       status = ParseDisplay(pReader, pos, size);
 
       if (status < 0)  // error
         return status;
-    } else if (id == mkvmuxer::kMkvChapterStringUID) {
+    } else if (id == kMkvChapterStringUID) {
       status = UnserializeString(pReader, pos, size, m_string_uid);
 
       if (status < 0)  // error
         return status;
-    } else if (id == mkvmuxer::kMkvChapterUID) {
+    } else if (id == kMkvChapterUID) {
       long long val;
       status = UnserializeInt(pReader, pos, size, val);
 
@@ -3532,14 +3532,14 @@ long Chapters::Atom::Parse(IMkvReader* pReader, long long pos, long long size) {
         return status;
 
       m_uid = static_cast<unsigned long long>(val);
-    } else if (id == mkvmuxer::kMkvChapterTimeStart) {
+    } else if (id == kMkvChapterTimeStart) {
       const long long val = UnserializeUInt(pReader, pos, size);
 
       if (val < 0)  // error
         return static_cast<long>(val);
 
       m_start_timecode = val;
-    } else if (id == mkvmuxer::kMkvChapterTimeEnd) {
+    } else if (id == kMkvChapterTimeEnd) {
       const long long val = UnserializeUInt(pReader, pos, size);
 
       if (val < 0)  // error
@@ -3667,17 +3667,17 @@ long Chapters::Display::Parse(IMkvReader* pReader, long long pos,
     if (size == 0)  // No payload.
       continue;
 
-    if (id == mkvmuxer::kMkvChapString) {
+    if (id == kMkvChapString) {
       status = UnserializeString(pReader, pos, size, m_string);
 
       if (status)
         return status;
-    } else if (id == mkvmuxer::kMkvChapLanguage) {
+    } else if (id == kMkvChapLanguage) {
       status = UnserializeString(pReader, pos, size, m_language);
 
       if (status)
         return status;
-    } else if (id == mkvmuxer::kMkvChapCountry) {
+    } else if (id == kMkvChapCountry) {
       status = UnserializeString(pReader, pos, size, m_country);
 
       if (status)
@@ -3730,7 +3730,7 @@ long Tags::Parse() {
     if (size == 0)  // 0 length tag, read another
       continue;
 
-    if (id == mkvmuxer::kMkvTag) {
+    if (id == kMkvTag) {
       status = ParseTag(pos, size);
 
       if (status < 0)
@@ -3846,7 +3846,7 @@ long Tags::Tag::Parse(IMkvReader* pReader, long long pos, long long size) {
     if (size == 0)  // 0 length tag, read another
       continue;
 
-    if (id == mkvmuxer::kMkvSimpleTag) {
+    if (id == kMkvSimpleTag) {
       status = ParseSimpleTag(pReader, pos, size);
 
       if (status < 0)
@@ -3937,12 +3937,12 @@ long Tags::SimpleTag::Parse(IMkvReader* pReader, long long pos,
     if (size == 0)  // weird
       continue;
 
-    if (id == mkvmuxer::kMkvTagName) {
+    if (id == kMkvTagName) {
       status = UnserializeString(pReader, pos, size, m_tag_name);
 
       if (status)
         return status;
-    } else if (id == mkvmuxer::kMkvTagString) {
+    } else if (id == kMkvTagString) {
       status = UnserializeString(pReader, pos, size, m_tag_string);
 
       if (status)
@@ -4002,12 +4002,12 @@ long SegmentInfo::Parse() {
     if (status < 0)  // error
       return status;
 
-    if (id == mkvmuxer::kMkvTimecodeScale) {
+    if (id == kMkvTimecodeScale) {
       m_timecodeScale = UnserializeUInt(pReader, pos, size);
 
       if (m_timecodeScale <= 0)
         return E_FILE_FORMAT_INVALID;
-    } else if (id == mkvmuxer::kMkvDuration) {
+    } else if (id == kMkvDuration) {
       const long status = UnserializeFloat(pReader, pos, size, m_duration);
 
       if (status < 0)
@@ -4015,19 +4015,19 @@ long SegmentInfo::Parse() {
 
       if (m_duration < 0)
         return E_FILE_FORMAT_INVALID;
-    } else if (id == mkvmuxer::kMkvMuxingApp) {
+    } else if (id == kMkvMuxingApp) {
       const long status =
           UnserializeString(pReader, pos, size, m_pMuxingAppAsUTF8);
 
       if (status)
         return status;
-    } else if (id == mkvmuxer::kMkvWritingApp) {
+    } else if (id == kMkvWritingApp) {
       const long status =
           UnserializeString(pReader, pos, size, m_pWritingAppAsUTF8);
 
       if (status)
         return status;
-    } else if (id == mkvmuxer::kMkvTitle) {
+    } else if (id == kMkvTitle) {
       const long status = UnserializeString(pReader, pos, size, m_pTitleAsUTF8);
 
       if (status)
@@ -4182,7 +4182,7 @@ long ContentEncoding::ParseContentEncAESSettingsEntry(
     if (status < 0)  // error
       return status;
 
-    if (id == mkvmuxer::kMkvAESSettingsCipherMode) {
+    if (id == kMkvAESSettingsCipherMode) {
       aes->cipher_mode = UnserializeUInt(pReader, pos, size);
       if (aes->cipher_mode != 1)
         return E_FILE_FORMAT_INVALID;
@@ -4213,10 +4213,10 @@ long ContentEncoding::ParseContentEncodingEntry(long long start, long long size,
     if (status < 0)  // error
       return status;
 
-    if (id == mkvmuxer::kMkvContentCompression)
+    if (id == kMkvContentCompression)
       ++compression_count;
 
-    if (id == mkvmuxer::kMkvContentEncryption)
+    if (id == kMkvContentEncryption)
       ++encryption_count;
 
     pos += size;  // consume payload
@@ -4252,15 +4252,15 @@ long ContentEncoding::ParseContentEncodingEntry(long long start, long long size,
     if (status < 0)  // error
       return status;
 
-    if (id == mkvmuxer::kMkvContentEncodingOrder) {
+    if (id == kMkvContentEncodingOrder) {
       encoding_order_ = UnserializeUInt(pReader, pos, size);
-    } else if (id == mkvmuxer::kMkvContentEncodingScope) {
+    } else if (id == kMkvContentEncodingScope) {
       encoding_scope_ = UnserializeUInt(pReader, pos, size);
       if (encoding_scope_ < 1)
         return -1;
-    } else if (id == mkvmuxer::kMkvContentEncodingType) {
+    } else if (id == kMkvContentEncodingType) {
       encoding_type_ = UnserializeUInt(pReader, pos, size);
-    } else if (id == mkvmuxer::kMkvContentCompression) {
+    } else if (id == kMkvContentCompression) {
       ContentCompression* const compression =
           new (std::nothrow) ContentCompression();
       if (!compression)
@@ -4272,7 +4272,7 @@ long ContentEncoding::ParseContentEncodingEntry(long long start, long long size,
         return status;
       }
       *compression_entries_end_++ = compression;
-    } else if (id == mkvmuxer::kMkvContentEncryption) {
+    } else if (id == kMkvContentEncryption) {
       ContentEncryption* const encryption =
           new (std::nothrow) ContentEncryption();
       if (!encryption)
@@ -4313,13 +4313,13 @@ long ContentEncoding::ParseCompressionEntry(long long start, long long size,
     if (status < 0)  // error
       return status;
 
-    if (id == mkvmuxer::kMkvContentCompAlgo) {
+    if (id == kMkvContentCompAlgo) {
       long long algo = UnserializeUInt(pReader, pos, size);
       if (algo < 0)
         return E_FILE_FORMAT_INVALID;
       compression->algo = algo;
       valid = true;
-    } else if (id == mkvmuxer::kMkvContentCompSettings) {
+    } else if (id == kMkvContentCompSettings) {
       if (size <= 0)
         return E_FILE_FORMAT_INVALID;
 
@@ -4366,11 +4366,11 @@ long ContentEncoding::ParseEncryptionEntry(long long start, long long size,
     if (status < 0)  // error
       return status;
 
-    if (id == mkvmuxer::kMkvContentEncAlgo) {
+    if (id == kMkvContentEncAlgo) {
       encryption->algo = UnserializeUInt(pReader, pos, size);
       if (encryption->algo != 5)
         return E_FILE_FORMAT_INVALID;
-    } else if (id == mkvmuxer::kMkvContentEncKeyID) {
+    } else if (id == kMkvContentEncKeyID) {
       delete[] encryption->key_id;
       encryption->key_id = NULL;
       encryption->key_id_len = 0;
@@ -4392,7 +4392,7 @@ long ContentEncoding::ParseEncryptionEntry(long long start, long long size,
 
       encryption->key_id = buf;
       encryption->key_id_len = buflen;
-    } else if (id == mkvmuxer::kMkvContentSignature) {
+    } else if (id == kMkvContentSignature) {
       delete[] encryption->signature;
       encryption->signature = NULL;
       encryption->signature_len = 0;
@@ -4414,7 +4414,7 @@ long ContentEncoding::ParseEncryptionEntry(long long start, long long size,
 
       encryption->signature = buf;
       encryption->signature_len = buflen;
-    } else if (id == mkvmuxer::kMkvContentSigKeyID) {
+    } else if (id == kMkvContentSigKeyID) {
       delete[] encryption->sig_key_id;
       encryption->sig_key_id = NULL;
       encryption->sig_key_id_len = 0;
@@ -4436,11 +4436,11 @@ long ContentEncoding::ParseEncryptionEntry(long long start, long long size,
 
       encryption->sig_key_id = buf;
       encryption->sig_key_id_len = buflen;
-    } else if (id == mkvmuxer::kMkvContentSigAlgo) {
+    } else if (id == kMkvContentSigAlgo) {
       encryption->sig_algo = UnserializeUInt(pReader, pos, size);
-    } else if (id == mkvmuxer::kMkvContentSigHashAlgo) {
+    } else if (id == kMkvContentSigHashAlgo) {
       encryption->sig_hash_algo = UnserializeUInt(pReader, pos, size);
-    } else if (id == mkvmuxer::kMkvContentEncAESSettings) {
+    } else if (id == kMkvContentEncAESSettings) {
       const long status = ParseContentEncAESSettingsEntry(
           pos, size, pReader, &encryption->aes_settings);
       if (status)
@@ -4927,7 +4927,7 @@ long Track::ParseContentEncodingsEntry(long long start, long long size) {
       return status;
 
     // pos now designates start of element
-    if (id == mkvmuxer::kMkvContentEncoding)
+    if (id == kMkvContentEncoding)
       ++count;
 
     pos += size;  // consume payload
@@ -4952,7 +4952,7 @@ long Track::ParseContentEncodingsEntry(long long start, long long size) {
       return status;
 
     // pos now designates start of element
-    if (id == mkvmuxer::kMkvContentEncoding) {
+    if (id == kMkvContentEncoding) {
       ContentEncoding* const content_encoding =
           new (std::nothrow) ContentEncoding();
       if (!content_encoding)
@@ -5034,14 +5034,14 @@ bool MasteringMetadata::Parse(IMkvReader* reader, long long mm_start,
     if (status < 0)
       return false;
 
-    if (child_id == mkvmuxer::kMkvLuminanceMax) {
+    if (child_id == kMkvLuminanceMax) {
       const long long value_parse_status =
           UnserializeFloat(reader, read_pos, child_size, mm_ptr->luminance_max);
       if (value_parse_status < 0 || mm_ptr->luminance_max < 0.0 ||
           mm_ptr->luminance_max > 9999.99) {
         return false;
       }
-    } else if (child_id == mkvmuxer::kMkvLuminanceMin) {
+    } else if (child_id == kMkvLuminanceMin) {
       const long long value_parse_status =
           UnserializeFloat(reader, read_pos, child_size, mm_ptr->luminance_min);
       if (value_parse_status < 0 || mm_ptr->luminance_min < 0.0 ||
@@ -5052,24 +5052,24 @@ bool MasteringMetadata::Parse(IMkvReader* reader, long long mm_start,
       bool is_x = false;
       PrimaryChromaticity** chromaticity;
       switch (child_id) {
-        case mkvmuxer::kMkvPrimaryRChromaticityX:
-        case mkvmuxer::kMkvPrimaryRChromaticityY:
-          is_x = child_id == mkvmuxer::kMkvPrimaryRChromaticityX;
+        case kMkvPrimaryRChromaticityX:
+        case kMkvPrimaryRChromaticityY:
+          is_x = child_id == kMkvPrimaryRChromaticityX;
           chromaticity = &mm_ptr->r;
           break;
-        case mkvmuxer::kMkvPrimaryGChromaticityX:
-        case mkvmuxer::kMkvPrimaryGChromaticityY:
-          is_x = child_id == mkvmuxer::kMkvPrimaryGChromaticityX;
+        case kMkvPrimaryGChromaticityX:
+        case kMkvPrimaryGChromaticityY:
+          is_x = child_id == kMkvPrimaryGChromaticityX;
           chromaticity = &mm_ptr->g;
           break;
-        case mkvmuxer::kMkvPrimaryBChromaticityX:
-        case mkvmuxer::kMkvPrimaryBChromaticityY:
-          is_x = child_id == mkvmuxer::kMkvPrimaryBChromaticityX;
+        case kMkvPrimaryBChromaticityX:
+        case kMkvPrimaryBChromaticityY:
+          is_x = child_id == kMkvPrimaryBChromaticityX;
           chromaticity = &mm_ptr->b;
           break;
-        case mkvmuxer::kMkvWhitePointChromaticityX:
-        case mkvmuxer::kMkvWhitePointChromaticityY:
-          is_x = child_id == mkvmuxer::kMkvWhitePointChromaticityX;
+        case kMkvWhitePointChromaticityX:
+        case kMkvWhitePointChromaticityY:
+          is_x = child_id == kMkvWhitePointChromaticityX;
           chromaticity = &mm_ptr->white_point;
           break;
         default:
@@ -5111,68 +5111,68 @@ bool Colour::Parse(IMkvReader* reader, long long colour_start,
     if (status < 0)
       return false;
 
-    if (child_id == mkvmuxer::kMkvMatrixCoefficients) {
+    if (child_id == kMkvMatrixCoefficients) {
       colour_ptr->matrix_coefficients =
           UnserializeUInt(reader, read_pos, child_size);
       if (colour_ptr->matrix_coefficients < 0)
         return false;
-    } else if (child_id == mkvmuxer::kMkvBitsPerChannel) {
+    } else if (child_id == kMkvBitsPerChannel) {
       colour_ptr->bits_per_channel =
           UnserializeUInt(reader, read_pos, child_size);
       if (colour_ptr->bits_per_channel < 0)
         return false;
-    } else if (child_id == mkvmuxer::kMkvChromaSubsamplingHorz) {
+    } else if (child_id == kMkvChromaSubsamplingHorz) {
       colour_ptr->chroma_subsampling_horz =
           UnserializeUInt(reader, read_pos, child_size);
       if (colour_ptr->chroma_subsampling_horz < 0)
         return false;
-    } else if (child_id == mkvmuxer::kMkvChromaSubsamplingVert) {
+    } else if (child_id == kMkvChromaSubsamplingVert) {
       colour_ptr->chroma_subsampling_vert =
           UnserializeUInt(reader, read_pos, child_size);
       if (colour_ptr->chroma_subsampling_vert < 0)
         return false;
-    } else if (child_id == mkvmuxer::kMkvCbSubsamplingHorz) {
+    } else if (child_id == kMkvCbSubsamplingHorz) {
       colour_ptr->cb_subsampling_horz =
           UnserializeUInt(reader, read_pos, child_size);
       if (colour_ptr->cb_subsampling_horz < 0)
         return false;
-    } else if (child_id == mkvmuxer::kMkvCbSubsamplingVert) {
+    } else if (child_id == kMkvCbSubsamplingVert) {
       colour_ptr->cb_subsampling_vert =
           UnserializeUInt(reader, read_pos, child_size);
       if (colour_ptr->cb_subsampling_vert < 0)
         return false;
-    } else if (child_id == mkvmuxer::kMkvChromaSitingHorz) {
+    } else if (child_id == kMkvChromaSitingHorz) {
       colour_ptr->chroma_siting_horz =
           UnserializeUInt(reader, read_pos, child_size);
       if (colour_ptr->chroma_siting_horz < 0)
         return false;
-    } else if (child_id == mkvmuxer::kMkvChromaSitingVert) {
+    } else if (child_id == kMkvChromaSitingVert) {
       colour_ptr->chroma_siting_vert =
           UnserializeUInt(reader, read_pos, child_size);
       if (colour_ptr->chroma_siting_vert < 0)
         return false;
-    } else if (child_id == mkvmuxer::kMkvRange) {
+    } else if (child_id == kMkvRange) {
       colour_ptr->range = UnserializeUInt(reader, read_pos, child_size);
       if (colour_ptr->range < 0)
         return false;
-    } else if (child_id == mkvmuxer::kMkvTransferCharacteristics) {
+    } else if (child_id == kMkvTransferCharacteristics) {
       colour_ptr->transfer_characteristics =
           UnserializeUInt(reader, read_pos, child_size);
       if (colour_ptr->transfer_characteristics < 0)
         return false;
-    } else if (child_id == mkvmuxer::kMkvPrimaries) {
+    } else if (child_id == kMkvPrimaries) {
       colour_ptr->primaries = UnserializeUInt(reader, read_pos, child_size);
       if (colour_ptr->primaries < 0)
         return false;
-    } else if (child_id == mkvmuxer::kMkvMaxCLL) {
+    } else if (child_id == kMkvMaxCLL) {
       colour_ptr->max_cll = UnserializeUInt(reader, read_pos, child_size);
       if (colour_ptr->max_cll < 0)
         return false;
-    } else if (child_id == mkvmuxer::kMkvMaxFALL) {
+    } else if (child_id == kMkvMaxFALL) {
       colour_ptr->max_fall = UnserializeUInt(reader, read_pos, child_size);
       if (colour_ptr->max_fall < 0)
         return false;
-    } else if (child_id == mkvmuxer::kMkvMasteringMetadata) {
+    } else if (child_id == kMkvMasteringMetadata) {
       if (!MasteringMetadata::Parse(reader, read_pos, child_size,
                                     &colour_ptr->mastering_metadata))
         return false;
@@ -5233,37 +5233,37 @@ long VideoTrack::Parse(Segment* pSegment, const Info& info,
     if (status < 0)  // error
       return status;
 
-    if (id == mkvmuxer::kMkvPixelWidth) {
+    if (id == kMkvPixelWidth) {
       width = UnserializeUInt(pReader, pos, size);
 
       if (width <= 0)
         return E_FILE_FORMAT_INVALID;
-    } else if (id == mkvmuxer::kMkvPixelHeight) {
+    } else if (id == kMkvPixelHeight) {
       height = UnserializeUInt(pReader, pos, size);
 
       if (height <= 0)
         return E_FILE_FORMAT_INVALID;
-    } else if (id == mkvmuxer::kMkvDisplayWidth) {
+    } else if (id == kMkvDisplayWidth) {
       display_width = UnserializeUInt(pReader, pos, size);
 
       if (display_width <= 0)
         return E_FILE_FORMAT_INVALID;
-    } else if (id == mkvmuxer::kMkvDisplayHeight) {
+    } else if (id == kMkvDisplayHeight) {
       display_height = UnserializeUInt(pReader, pos, size);
 
       if (display_height <= 0)
         return E_FILE_FORMAT_INVALID;
-    } else if (id == mkvmuxer::kMkvDisplayUnit) {
+    } else if (id == kMkvDisplayUnit) {
       display_unit = UnserializeUInt(pReader, pos, size);
 
       if (display_unit < 0)
         return E_FILE_FORMAT_INVALID;
-    } else if (id == mkvmuxer::kMkvStereoMode) {
+    } else if (id == kMkvStereoMode) {
       stereo_mode = UnserializeUInt(pReader, pos, size);
 
       if (stereo_mode < 0)
         return E_FILE_FORMAT_INVALID;
-    } else if (id == mkvmuxer::kMkvFrameRate) {
+    } else if (id == kMkvFrameRate) {
       const long status = UnserializeFloat(pReader, pos, size, rate);
 
       if (status < 0)
@@ -5271,7 +5271,7 @@ long VideoTrack::Parse(Segment* pSegment, const Info& info,
 
       if (rate <= 0)
         return E_FILE_FORMAT_INVALID;
-    } else if (id == mkvmuxer::kMkvColour) {
+    } else if (id == kMkvColour) {
       if (!Colour::Parse(pReader, pos, size, &colour))
         return E_FILE_FORMAT_INVALID;
     }
@@ -5459,7 +5459,7 @@ long AudioTrack::Parse(Segment* pSegment, const Info& info,
     if (status < 0)  // error
       return status;
 
-    if (id == mkvmuxer::kMkvSamplingFrequency) {
+    if (id == kMkvSamplingFrequency) {
       status = UnserializeFloat(pReader, pos, size, rate);
 
       if (status < 0)
@@ -5467,12 +5467,12 @@ long AudioTrack::Parse(Segment* pSegment, const Info& info,
 
       if (rate <= 0)
         return E_FILE_FORMAT_INVALID;
-    } else if (id == mkvmuxer::kMkvChannels) {
+    } else if (id == kMkvChannels) {
       channels = UnserializeUInt(pReader, pos, size);
 
       if (channels <= 0)
         return E_FILE_FORMAT_INVALID;
-    } else if (id == mkvmuxer::kMkvBitDepth) {
+    } else if (id == kMkvBitDepth) {
       bit_depth = UnserializeUInt(pReader, pos, size);
 
       if (bit_depth <= 0)
@@ -5545,7 +5545,7 @@ long Tracks::Parse() {
     if (size == 0)  // weird
       continue;
 
-    if (id == mkvmuxer::kMkvTrackEntry)
+    if (id == kMkvTrackEntry)
       ++count;
 
     pos += size;  // consume payload
@@ -5587,7 +5587,7 @@ long Tracks::Parse() {
 
     const long long element_size = payload_stop - element_start;
 
-    if (id == mkvmuxer::kMkvTrackEntry) {
+    if (id == kMkvTrackEntry) {
       Track*& pTrack = *m_trackEntriesEnd;
       pTrack = NULL;
 
@@ -5663,16 +5663,16 @@ long Tracks::ParseTrackEntry(long long track_start, long long track_size,
 
     const long long start = pos;
 
-    if (id == mkvmuxer::kMkvVideo) {
+    if (id == kMkvVideo) {
       v.start = start;
       v.size = size;
-    } else if (id == mkvmuxer::kMkvAudio) {
+    } else if (id == kMkvAudio) {
       a.start = start;
       a.size = size;
-    } else if (id == mkvmuxer::kMkvContentEncodings) {
+    } else if (id == kMkvContentEncodings) {
       e.start = start;
       e.size = size;
-    } else if (id == mkvmuxer::kMkvTrackUID) {
+    } else if (id == kMkvTrackUID) {
       if (size > 8)
         return E_FILE_FORMAT_INVALID;
 
@@ -5694,49 +5694,49 @@ long Tracks::ParseTrackEntry(long long track_start, long long track_size,
 
         ++pos_;
       }
-    } else if (id == mkvmuxer::kMkvTrackNumber) {
+    } else if (id == kMkvTrackNumber) {
       const long long num = UnserializeUInt(pReader, pos, size);
 
       if ((num <= 0) || (num > 127))
         return E_FILE_FORMAT_INVALID;
 
       info.number = static_cast<long>(num);
-    } else if (id == mkvmuxer::kMkvTrackType) {
+    } else if (id == kMkvTrackType) {
       const long long type = UnserializeUInt(pReader, pos, size);
 
       if ((type <= 0) || (type > 254))
         return E_FILE_FORMAT_INVALID;
 
       info.type = static_cast<long>(type);
-    } else if (id == mkvmuxer::kMkvName) {
+    } else if (id == kMkvName) {
       const long status =
           UnserializeString(pReader, pos, size, info.nameAsUTF8);
 
       if (status)
         return status;
-    } else if (id == mkvmuxer::kMkvLanguage) {
+    } else if (id == kMkvLanguage) {
       const long status = UnserializeString(pReader, pos, size, info.language);
 
       if (status)
         return status;
-    } else if (id == mkvmuxer::kMkvDefaultDuration) {
+    } else if (id == kMkvDefaultDuration) {
       const long long duration = UnserializeUInt(pReader, pos, size);
 
       if (duration < 0)
         return E_FILE_FORMAT_INVALID;
 
       info.defaultDuration = static_cast<unsigned long long>(duration);
-    } else if (id == mkvmuxer::kMkvCodecID) {
+    } else if (id == kMkvCodecID) {
       const long status = UnserializeString(pReader, pos, size, info.codecId);
 
       if (status)
         return status;
-    } else if (id == mkvmuxer::kMkvFlagLacing) {
+    } else if (id == kMkvFlagLacing) {
       lacing = UnserializeUInt(pReader, pos, size);
 
       if ((lacing < 0) || (lacing > 1))
         return E_FILE_FORMAT_INVALID;
-    } else if (id == mkvmuxer::kMkvCodecPrivate) {
+    } else if (id == kMkvCodecPrivate) {
       delete[] info.codecPrivate;
       info.codecPrivate = NULL;
       info.codecPrivateSize = 0;
@@ -5759,15 +5759,15 @@ long Tracks::ParseTrackEntry(long long track_start, long long track_size,
         info.codecPrivate = buf;
         info.codecPrivateSize = buflen;
       }
-    } else if (id == mkvmuxer::kMkvCodecName) {
+    } else if (id == kMkvCodecName) {
       const long status =
           UnserializeString(pReader, pos, size, info.codecNameAsUTF8);
 
       if (status)
         return status;
-    } else if (id == mkvmuxer::kMkvCodecDelay) {
+    } else if (id == kMkvCodecDelay) {
       info.codecDelay = UnserializeUInt(pReader, pos, size);
-    } else if (id == mkvmuxer::kMkvSeekPreRoll) {
+    } else if (id == kMkvSeekPreRoll) {
       info.seekPreRoll = UnserializeUInt(pReader, pos, size);
     }
 
@@ -5950,7 +5950,7 @@ long Cluster::Load(long long& pos, long& len) const {
   if (id_ < 0)  // error
     return static_cast<long>(id_);
 
-  if (id_ != mkvmuxer::kMkvCluster)
+  if (id_ != kMkvCluster)
     return E_FILE_FORMAT_INVALID;
 
   pos += len;  // consume id
@@ -6032,10 +6032,10 @@ long Cluster::Load(long long& pos, long& len) const {
     // that we have exhausted the sub-element's inside the cluster
     // whose ID we parsed earlier.
 
-    if (id == mkvmuxer::kMkvCluster)
+    if (id == kMkvCluster)
       break;
 
-    if (id == mkvmuxer::kMkvCues)
+    if (id == kMkvCues)
       break;
 
     pos += len;  // consume ID field
@@ -6084,7 +6084,7 @@ long Cluster::Load(long long& pos, long& len) const {
     if ((cluster_stop >= 0) && ((pos + size) > cluster_stop))
       return E_FILE_FORMAT_INVALID;
 
-    if (id == mkvmuxer::kMkvTimecode) {
+    if (id == kMkvTimecode) {
       len = static_cast<long>(size);
 
       if ((pos + size) > avail)
@@ -6099,10 +6099,10 @@ long Cluster::Load(long long& pos, long& len) const {
 
       if (bBlock)
         break;
-    } else if (id == mkvmuxer::kMkvBlockGroup) {
+    } else if (id == kMkvBlockGroup) {
       bBlock = true;
       break;
-    } else if (id == mkvmuxer::kMkvSimpleBlock) {
+    } else if (id == kMkvSimpleBlock) {
       bBlock = true;
       break;
     }
@@ -6200,7 +6200,7 @@ long Cluster::Parse(long long& pos, long& len) const {
     // that we have exhausted the sub-element's inside the cluster
     // whose ID we parsed earlier.
 
-    if ((id == mkvmuxer::kMkvCluster) || (id == mkvmuxer::kMkvCues)) {
+    if ((id == kMkvCluster) || (id == kMkvCues)) {
       if (m_element_size < 0)
         m_element_size = pos - m_element_start;
 
@@ -6255,7 +6255,7 @@ long Cluster::Parse(long long& pos, long& len) const {
 
     if (cluster_stop >= 0) {
       if (block_stop > cluster_stop) {
-        if (id == mkvmuxer::kMkvBlockGroup || id == mkvmuxer::kMkvSimpleBlock) {
+        if (id == kMkvBlockGroup || id == kMkvSimpleBlock) {
           return E_FILE_FORMAT_INVALID;
         }
 
@@ -6273,10 +6273,10 @@ long Cluster::Parse(long long& pos, long& len) const {
 
     Cluster* const this_ = const_cast<Cluster*>(this);
 
-    if (id == mkvmuxer::kMkvBlockGroup)
+    if (id == kMkvBlockGroup)
       return this_->ParseBlockGroup(size, pos, len);
 
-    if (id == mkvmuxer::kMkvSimpleBlock)
+    if (id == kMkvSimpleBlock)
       return this_->ParseSimpleBlock(size, pos, len);
 
     pos += size;  // consume payload
@@ -6407,7 +6407,7 @@ long Cluster::ParseSimpleBlock(long long block_size, long long& pos,
     return E_BUFFER_NOT_FULL;
   }
 
-  status = CreateBlock(mkvmuxer::kMkvSimpleBlock, block_start, block_size,
+  status = CreateBlock(kMkvSimpleBlock, block_start, block_size,
                        0);  // DiscardPadding
 
   if (status != 0)
@@ -6517,14 +6517,14 @@ long Cluster::ParseBlockGroup(long long payload_size, long long& pos,
     if (size == unknown_size)
       return E_FILE_FORMAT_INVALID;
 
-    if (id == mkvmuxer::kMkvDiscardPadding) {
+    if (id == kMkvDiscardPadding) {
       status = UnserializeInt(pReader, pos, size, discard_padding);
 
       if (status < 0)  // error
         return status;
     }
 
-    if (id != mkvmuxer::kMkvBlock) {
+    if (id != kMkvBlock) {
       pos += size;  // consume sub-part of block group
 
       if (pos > payload_stop)
@@ -6617,8 +6617,8 @@ long Cluster::ParseBlockGroup(long long payload_size, long long& pos,
   if (pos != payload_stop)
     return E_FILE_FORMAT_INVALID;
 
-  status = CreateBlock(mkvmuxer::kMkvBlockGroup, payload_start, payload_size,
-                       discard_padding);
+  status =
+      CreateBlock(kMkvBlockGroup, payload_start, payload_size, discard_padding);
   if (status != 0)
     return status;
 
@@ -6783,7 +6783,7 @@ long Cluster::HasBlockEntries(
     if (id < 0)  // error
       return static_cast<long>(id);
 
-    if (id != mkvmuxer::kMkvCluster)
+    if (id != kMkvCluster)
       return E_PARSE_FAILED;
 
     pos += len;  // consume Cluster ID field
@@ -6871,10 +6871,10 @@ long Cluster::HasBlockEntries(
     // that we have exhausted the sub-element's inside the cluster
     // whose ID we parsed earlier.
 
-    if (id == mkvmuxer::kMkvCluster)
+    if (id == kMkvCluster)
       return 0;  // no entries found
 
-    if (id == mkvmuxer::kMkvCues)
+    if (id == kMkvCues)
       return 0;  // no entries found
 
     pos += len;  // consume id field
@@ -6926,10 +6926,10 @@ long Cluster::HasBlockEntries(
     if ((cluster_stop >= 0) && ((pos + size) > cluster_stop))
       return E_FILE_FORMAT_INVALID;
 
-    if (id == mkvmuxer::kMkvBlockGroup)
+    if (id == kMkvBlockGroup)
       return 1;  // have at least one entry
 
-    if (id == mkvmuxer::kMkvSimpleBlock)
+    if (id == kMkvSimpleBlock)
       return 1;  // have at least one entry
 
     pos += size;  // consume payload
@@ -7004,7 +7004,7 @@ long long Cluster::GetLastTime() const {
 long Cluster::CreateBlock(long long id,
                           long long pos,  // absolute pos of payload
                           long long size, long long discard_padding) {
-  if (id != mkvmuxer::kMkvBlockGroup && id != mkvmuxer::kMkvSimpleBlock)
+  if (id != kMkvBlockGroup && id != kMkvSimpleBlock)
     return E_PARSE_FAILED;
 
   if (m_entries_count < 0) {  // haven't parsed anything yet
@@ -7044,7 +7044,7 @@ long Cluster::CreateBlock(long long id,
     }
   }
 
-  if (id == mkvmuxer::kMkvBlockGroup)
+  if (id == kMkvBlockGroup)
     return CreateBlockGroup(pos, size, discard_padding);
   else
     return CreateSimpleBlock(pos, size);
@@ -7089,12 +7089,12 @@ long Cluster::CreateBlockGroup(long long start_offset, long long size,
 
     pos += len;  // consume size
 
-    if (id == mkvmuxer::kMkvBlock) {
+    if (id == kMkvBlock) {
       if (bpos < 0) {  // Block ID
         bpos = pos;
         bsize = size;
       }
-    } else if (id == mkvmuxer::kMkvBlockDuration) {
+    } else if (id == kMkvBlockDuration) {
       if (size > 8)
         return E_FILE_FORMAT_INVALID;
 
@@ -7102,7 +7102,7 @@ long Cluster::CreateBlockGroup(long long start_offset, long long size,
 
       if (duration < 0)
         return E_FILE_FORMAT_INVALID;
-    } else if (id == mkvmuxer::kMkvReferenceBlock) {
+    } else if (id == kMkvReferenceBlock) {
       if (size > 8 || size <= 0)
         return E_FILE_FORMAT_INVALID;
       const long size_ = static_cast<long>(size);
@@ -7938,4 +7938,5 @@ long Block::Frame::Read(IMkvReader* pReader, unsigned char* buf) const {
 
 long long Block::GetDiscardPadding() const { return m_discard_padding; }
 
-}  // end namespace mkvparser
+}  // namespace mkvparser
+}  // namespace libwebm
diff --git a/mkvparser.hpp b/mkvparser.hpp
index b04baa6..05eae50 100644
--- a/mkvparser.hpp
+++ b/mkvparser.hpp
@@ -11,6 +11,7 @@
 
 #include <cstddef>
 
+namespace libwebm {
 namespace mkvparser {
 
 const int E_PARSE_FAILED = -1;
@@ -1101,9 +1102,10 @@ class Segment {
   const BlockEntry* GetBlock(const CuePoint&, const CuePoint::TrackPosition&);
 };
 
-}  // end namespace mkvparser
+}  // namespace mkvparser
+}  // namespace libwebm
 
-inline long mkvparser::Segment::LoadCluster() {
+inline long libwebm::mkvparser::Segment::LoadCluster() {
   long long pos;
   long size;
 
diff --git a/mkvreader.cpp b/mkvreader.cpp
index eaf9e0a..124fd73 100644
--- a/mkvreader.cpp
+++ b/mkvreader.cpp
@@ -10,6 +10,7 @@
 
 #include <cassert>
 
+namespace libwebm {
 namespace mkvparser {
 
 MkvReader::MkvReader() : m_file(NULL), reader_owns_file_(true) {}
@@ -129,4 +130,5 @@ int MkvReader::Read(long long offset, long len, unsigned char* buffer) {
   return 0;  // success
 }
 
-}  // end namespace mkvparser
+}  // namespace mkvparser
+}  // namespace libwebm
diff --git a/mkvreader.hpp b/mkvreader.hpp
index 82ebad5..feb66a2 100644
--- a/mkvreader.hpp
+++ b/mkvreader.hpp
@@ -12,6 +12,7 @@
 #include "mkvparser.hpp"
 #include <cstdio>
 
+namespace libwebm {
 namespace mkvparser {
 
 class MkvReader : public IMkvReader {
@@ -40,6 +41,7 @@ class MkvReader : public IMkvReader {
   bool reader_owns_file_;
 };
 
-}  // end namespace mkvparser
+}  // namespace mkvparser
+}  // namespace libwebm
 
 #endif  // MKVREADER_HPP
diff --git a/mkvwriter.cpp b/mkvwriter.cpp
index 0ca35ea..47061da 100644
--- a/mkvwriter.cpp
+++ b/mkvwriter.cpp
@@ -12,6 +12,7 @@
 #include <share.h>  // for _SH_DENYWR
 #endif
 
+namespace libwebm {
 namespace mkvmuxer {
 
 MkvWriter::MkvWriter() : file_(NULL), writer_owns_file_(true) {}
@@ -86,3 +87,4 @@ bool MkvWriter::Seekable() const { return true; }
 void MkvWriter::ElementStartNotify(uint64, int64) {}
 
 }  // namespace mkvmuxer
+}  // namespace libwebm
diff --git a/mkvwriter.hpp b/mkvwriter.hpp
index 684560c..9ab68ae 100644
--- a/mkvwriter.hpp
+++ b/mkvwriter.hpp
@@ -14,6 +14,7 @@
 #include "mkvmuxer.hpp"
 #include "mkvmuxertypes.hpp"
 
+namespace libwebm {
 namespace mkvmuxer {
 
 // Default implementation of the IMkvWriter interface on Windows.
@@ -46,6 +47,7 @@ class MkvWriter : public IMkvWriter {
   LIBWEBM_DISALLOW_COPY_AND_ASSIGN(MkvWriter);
 };
 
-}  // end namespace mkvmuxer
+}  // namespace mkvmuxer
+}  // namespace libwebm
 
 #endif  // MKVWRITER_HPP
diff --git a/sample.cpp b/sample.cpp
index 7b9b691..bb814bf 100644
--- a/sample.cpp
+++ b/sample.cpp
@@ -44,15 +44,15 @@ const wchar_t* utf8towcs(const char* str) {
   return val;
 }
 
-bool InputHasCues(const mkvparser::Segment* const segment) {
-  const mkvparser::Cues* const cues = segment->GetCues();
+bool InputHasCues(const libwebm::mkvparser::Segment* const segment) {
+  const libwebm::mkvparser::Cues* const cues = segment->GetCues();
   if (cues == NULL)
     return false;
 
   while (!cues->DoneParsing())
     cues->LoadCuePoint();
 
-  const mkvparser::CuePoint* const cue_point = cues->GetFirst();
+  const libwebm::mkvparser::CuePoint* const cue_point = cues->GetFirst();
   if (cue_point == NULL)
     return false;
 
@@ -60,11 +60,11 @@ bool InputHasCues(const mkvparser::Segment* const segment) {
 }
 
 bool MasteringMetadataValuePresent(double value) {
-  return value != mkvparser::MasteringMetadata::kValueNotPresent;
+  return value != libwebm::mkvparser::MasteringMetadata::kValueNotPresent;
 }
 
 bool ColourValuePresent(long long value) {
-  return value != mkvparser::Colour::kValueNotPresent;
+  return value != libwebm::mkvparser::Colour::kValueNotPresent;
 }
 }  // namespace
 
@@ -77,9 +77,7 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  using namespace mkvparser;
-
-  MkvReader reader;
+  libwebm::mkvparser::MkvReader reader;
 
   if (reader.Open(argv[1])) {
     printf("\n Filename is invalid or error while opening.\n");
@@ -88,12 +86,12 @@ int main(int argc, char* argv[]) {
 
   int maj, min, build, rev;
 
-  GetVersion(maj, min, build, rev);
+  libwebm::mkvparser::GetVersion(maj, min, build, rev);
   printf("\t\t libmkv verison: %d.%d.%d.%d\n", maj, min, build, rev);
 
   long long pos = 0;
 
-  EBMLHeader ebmlHeader;
+  libwebm::mkvparser::EBMLHeader ebmlHeader;
 
   long long ret = ebmlHeader.Parse(&reader, pos);
   if (ret < 0) {
@@ -108,7 +106,7 @@ int main(int argc, char* argv[]) {
   printf("\t\tDoc Type\t\t: %s\n", ebmlHeader.m_docType);
   printf("\t\tPos\t\t\t: %lld\n", pos);
 
-  typedef mkvparser::Segment seg_t;
+  typedef libwebm::mkvparser::Segment seg_t;
   seg_t* pSegment_;
 
   ret = seg_t::CreateInstance(&reader, pos, pSegment_);
@@ -125,7 +123,8 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  const SegmentInfo* const pSegmentInfo = pSegment->GetInfo();
+  const libwebm::mkvparser::SegmentInfo* const pSegmentInfo =
+      pSegment->GetInfo();
   if (pSegmentInfo == NULL) {
     printf("\n Segment::GetInfo() failed.");
     return -1;
@@ -178,7 +177,7 @@ int main(int argc, char* argv[]) {
   // size of segment payload
   printf("\t\tSize(Segment)\t\t: %lld\n", pSegment->m_size);
 
-  const mkvparser::Tracks* pTracks = pSegment->GetTracks();
+  const libwebm::mkvparser::Tracks* pTracks = pSegment->GetTracks();
 
   unsigned long track_num = 0;
   const unsigned long num_tracks = pTracks->GetTracksCount();
@@ -186,7 +185,8 @@ int main(int argc, char* argv[]) {
   printf("\n\t\t\t   Track Info\n");
 
   while (track_num != num_tracks) {
-    const Track* const pTrack = pTracks->GetTrackByIndex(track_num++);
+    const libwebm::mkvparser::Track* const pTrack =
+        pTracks->GetTrackByIndex(track_num++);
 
     if (pTrack == NULL)
       continue;
@@ -224,9 +224,9 @@ int main(int argc, char* argv[]) {
       delete[] pCodecName;
     }
 
-    if (trackType == mkvparser::Track::kVideo) {
-      const VideoTrack* const pVideoTrack =
-          static_cast<const VideoTrack*>(pTrack);
+    if (trackType == libwebm::mkvparser::Track::kVideo) {
+      const libwebm::mkvparser::VideoTrack* const pVideoTrack =
+          static_cast<const libwebm::mkvparser::VideoTrack*>(pTrack);
 
       const long long width = pVideoTrack->GetWidth();
       printf("\t\tVideo Width\t\t: %lld\n", width);
@@ -237,7 +237,7 @@ int main(int argc, char* argv[]) {
       const double rate = pVideoTrack->GetFrameRate();
       printf("\t\tVideo Rate\t\t: %f\n", rate);
 
-      const mkvparser::Colour* const colour = pVideoTrack->GetColour();
+      const libwebm::mkvparser::Colour* const colour = pVideoTrack->GetColour();
       if (colour) {
         printf("\t\tVideo Colour:\n");
         if (ColourValuePresent(colour->matrix_coefficients))
@@ -273,7 +273,7 @@ int main(int argc, char* argv[]) {
         if (ColourValuePresent(colour->max_fall))
           printf("\t\t\tMaxFALL: %lld\n", colour->max_fall);
         if (colour->mastering_metadata) {
-          const mkvparser::MasteringMetadata* const mm =
+          const libwebm::mkvparser::MasteringMetadata* const mm =
               colour->mastering_metadata;
           printf("\t\t\tMastering Metadata:\n");
           if (MasteringMetadataValuePresent(mm->luminance_max))
@@ -302,9 +302,9 @@ int main(int argc, char* argv[]) {
       }
     }
 
-    if (trackType == mkvparser::Track::kAudio) {
-      const AudioTrack* const pAudioTrack =
-          static_cast<const AudioTrack*>(pTrack);
+    if (trackType == libwebm::mkvparser::Track::kAudio) {
+      const libwebm::mkvparser::AudioTrack* const pAudioTrack =
+          static_cast<const libwebm::mkvparser::AudioTrack*>(pTrack);
 
       const long long channels = pAudioTrack->GetChannels();
       printf("\t\tAudio Channels\t\t: %lld\n", channels);
@@ -333,7 +333,7 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  const mkvparser::Cluster* pCluster = pSegment->GetFirst();
+  const libwebm::mkvparser::Cluster* pCluster = pSegment->GetFirst();
 
   while ((pCluster != NULL) && !pCluster->EOS()) {
     const long long timeCode = pCluster->GetTimeCode();
@@ -342,7 +342,7 @@ int main(int argc, char* argv[]) {
     const long long time_ns = pCluster->GetTime();
     printf("\t\tCluster Time (ns)\t: %lld\n", time_ns);
 
-    const BlockEntry* pBlockEntry;
+    const libwebm::mkvparser::BlockEntry* pBlockEntry;
 
     long status = pCluster->GetFirst(pBlockEntry);
 
@@ -354,10 +354,11 @@ int main(int argc, char* argv[]) {
     }
 
     while ((pBlockEntry != NULL) && !pBlockEntry->EOS()) {
-      const Block* const pBlock = pBlockEntry->GetBlock();
+      const libwebm::mkvparser::Block* const pBlock = pBlockEntry->GetBlock();
       const long long trackNum = pBlock->GetTrackNumber();
       const unsigned long tn = static_cast<unsigned long>(trackNum);
-      const Track* const pTrack = pTracks->GetTrackByNumber(tn);
+      const libwebm::mkvparser::Track* const pTrack =
+          pTracks->GetTrackByNumber(tn);
 
       if (pTrack == NULL)
         printf("\t\t\tBlock\t\t:UNKNOWN TRACK TYPE\n");
@@ -368,11 +369,12 @@ int main(int argc, char* argv[]) {
         const long long discard_padding = pBlock->GetDiscardPadding();
 
         printf("\t\t\tBlock\t\t:%s,%s,%15lld,%lld\n",
-               (trackType == mkvparser::Track::kVideo) ? "V" : "A",
+               (trackType == libwebm::mkvparser::Track::kVideo) ? "V" : "A",
                pBlock->IsKey() ? "I" : "P", time_ns, discard_padding);
 
         for (int i = 0; i < frameCount; ++i) {
-          const Block::Frame& theFrame = pBlock->GetFrame(i);
+          const libwebm::mkvparser::Block::Frame& theFrame =
+              pBlock->GetFrame(i);
           const long size = theFrame.len;
           const long long offset = theFrame.pos;
           printf("\t\t\t %15ld,%15llx\n", size, offset);
@@ -393,21 +395,22 @@ int main(int argc, char* argv[]) {
 
   if (InputHasCues(pSegment.get())) {
     // Walk them.
-    const mkvparser::Cues* const cues = pSegment->GetCues();
-    const mkvparser::CuePoint* cue = cues->GetFirst();
+    const libwebm::mkvparser::Cues* const cues = pSegment->GetCues();
+    const libwebm::mkvparser::CuePoint* cue = cues->GetFirst();
     int cue_point_num = 1;
 
     printf("\t\tCues\n");
     do {
       for (track_num = 0; track_num < num_tracks; ++track_num) {
-        const mkvparser::Track* const track =
+        const libwebm::mkvparser::Track* const track =
             pTracks->GetTrackByIndex(track_num);
-        const mkvparser::CuePoint::TrackPosition* const track_pos =
+        const libwebm::mkvparser::CuePoint::TrackPosition* const track_pos =
             cue->Find(track);
 
         if (track_pos != NULL) {
           const char track_type =
-              (track->GetType() == mkvparser::Track::kVideo) ? 'V' : 'A';
+              (track->GetType() == libwebm::mkvparser::Track::kVideo) ? 'V' :
+                                                                        'A';
           printf(
               "\t\t\tCue Point %4d Track %3lu(%c) Time %14lld "
               "Block %4lld Pos %8llx\n",
@@ -422,14 +425,14 @@ int main(int argc, char* argv[]) {
     } while (cue != NULL);
   }
 
-  const mkvparser::Tags* const tags = pSegment->GetTags();
+  const libwebm::mkvparser::Tags* const tags = pSegment->GetTags();
   if (tags && tags->GetTagCount() > 0) {
     printf("\t\tTags\n");
     for (int i = 0; i < tags->GetTagCount(); ++i) {
-      const mkvparser::Tags::Tag* const tag = tags->GetTag(i);
+      const libwebm::mkvparser::Tags::Tag* const tag = tags->GetTag(i);
       printf("\t\t\tTag\n");
       for (int j = 0; j < tag->GetSimpleTagCount(); j++) {
-        const mkvparser::Tags::SimpleTag* const simple_tag =
+        const libwebm::mkvparser::Tags::SimpleTag* const simple_tag =
             tag->GetSimpleTag(j);
         printf("\t\t\t\tSimple Tag \"%s\" Value \"%s\"\n",
                simple_tag->GetTagName(), simple_tag->GetTagString());
diff --git a/sample_muxer.cpp b/sample_muxer.cpp
index ef26bf4..9326efa 100644
--- a/sample_muxer.cpp
+++ b/sample_muxer.cpp
@@ -28,9 +28,6 @@
 
 #include "sample_muxer_metadata.h"
 
-using mkvmuxer::int64;
-using mkvmuxer::uint64;
-
 #ifdef _MSC_VER
 // Disable MSVC warnings that suggest making code non-portable.
 #pragma warning(disable : 4996)
@@ -82,14 +79,14 @@ void Usage() {
 
 struct MetadataFile {
   const char* name;
-  SampleMuxerMetadata::Kind kind;
+  libwebm::SampleMuxerMetadata::Kind kind;
 };
 
 typedef std::list<MetadataFile> metadata_files_t;
 
 // Cache the WebVTT filenames specified as command-line args.
 bool LoadMetadataFiles(const metadata_files_t& files,
-                       SampleMuxerMetadata* metadata) {
+                       libwebm::SampleMuxerMetadata* metadata) {
   typedef metadata_files_t::const_iterator iter_t;
 
   iter_t i = files.begin();
@@ -112,14 +109,14 @@ int ParseArgWebVTT(char* argv[], int* argv_index, int argc_check,
   enum { kCount = 5 };
   struct Arg {
     const char* name;
-    SampleMuxerMetadata::Kind kind;
+    libwebm::SampleMuxerMetadata::Kind kind;
   };
   const Arg args[kCount] = {
-      {"-webvtt-subtitles", SampleMuxerMetadata::kSubtitles},
-      {"-webvtt-captions", SampleMuxerMetadata::kCaptions},
-      {"-webvtt-descriptions", SampleMuxerMetadata::kDescriptions},
-      {"-webvtt-metadata", SampleMuxerMetadata::kMetadata},
-      {"-webvtt-chapters", SampleMuxerMetadata::kChapters}};
+      {"-webvtt-subtitles", libwebm::SampleMuxerMetadata::kSubtitles},
+      {"-webvtt-captions", libwebm::SampleMuxerMetadata::kCaptions},
+      {"-webvtt-descriptions", libwebm::SampleMuxerMetadata::kDescriptions},
+      {"-webvtt-metadata", libwebm::SampleMuxerMetadata::kMetadata},
+      {"-webvtt-chapters", libwebm::SampleMuxerMetadata::kChapters}};
 
   for (int idx = 0; idx < kCount; ++idx) {
     const Arg& arg = args[idx];
@@ -159,8 +156,8 @@ int main(int argc, char* argv[]) {
   bool cues_before_clusters = false;
   bool cues_on_video_track = true;
   bool cues_on_audio_track = false;
-  uint64 max_cluster_duration = 0;
-  uint64 max_cluster_size = 0;
+  libwebm::uint64 max_cluster_duration = 0;
+  libwebm::uint64 max_cluster_size = 0;
   bool switch_tracks = false;
   int audio_track_number = 0;  // 0 tells muxer to decide.
   int video_track_number = 0;  // 0 tells muxer to decide.
@@ -170,9 +167,9 @@ int main(int argc, char* argv[]) {
 
   bool output_cues_block_number = true;
 
-  uint64 display_width = 0;
-  uint64 display_height = 0;
-  uint64 stereo_mode = 0;
+  libwebm::uint64 display_width = 0;
+  libwebm::uint64 display_height = 0;
+  libwebm::uint64 stereo_mode = 0;
 
   metadata_files_t metadata_files;
 
@@ -207,7 +204,8 @@ int main(int argc, char* argv[]) {
         cues_on_video_track = false;
     } else if (!strcmp("-max_cluster_duration", argv[i]) && i < argc_check) {
       const double seconds = strtod(argv[++i], &end);
-      max_cluster_duration = static_cast<uint64>(seconds * 1000000000.0);
+      max_cluster_duration =
+          static_cast<libwebm::uint64>(seconds * 1000000000.0);
     } else if (!strcmp("-max_cluster_size", argv[i]) && i < argc_check) {
       max_cluster_size = strtol(argv[++i], &end, 10);
     } else if (!strcmp("-switch_tracks", argv[i]) && i < argc_check) {
@@ -243,7 +241,7 @@ int main(int argc, char* argv[]) {
   }
 
   // Get parser header info
-  mkvparser::MkvReader reader;
+  libwebm::mkvparser::MkvReader reader;
 
   if (reader.Open(input)) {
     printf("\n Filename is invalid or error while opening.\n");
@@ -251,28 +249,31 @@ int main(int argc, char* argv[]) {
   }
 
   long long pos = 0;
-  mkvparser::EBMLHeader ebml_header;
+  libwebm::mkvparser::EBMLHeader ebml_header;
   long long ret = ebml_header.Parse(&reader, pos);
   if (ret) {
     printf("\n EBMLHeader::Parse() failed.");
     return EXIT_FAILURE;
   }
 
-  mkvparser::Segment* parser_segment_;
-  ret = mkvparser::Segment::CreateInstance(&reader, pos, parser_segment_);
+  libwebm::mkvparser::Segment* parser_segment_;
+  ret = libwebm::mkvparser::Segment::CreateInstance(&reader, pos,
+                                                    parser_segment_);
   if (ret) {
     printf("\n Segment::CreateInstance() failed.");
     return EXIT_FAILURE;
   }
 
-  const std::auto_ptr<mkvparser::Segment> parser_segment(parser_segment_);
+  const std::auto_ptr<libwebm::mkvparser::Segment> parser_segment(
+      parser_segment_);
   ret = parser_segment->Load();
   if (ret < 0) {
     printf("\n Segment::Load() failed.");
     return EXIT_FAILURE;
   }
 
-  const mkvparser::SegmentInfo* const segment_info = parser_segment->GetInfo();
+  const libwebm::mkvparser::SegmentInfo* const segment_info =
+      parser_segment->GetInfo();
   if (segment_info == NULL) {
     printf("\n Segment::GetInfo() failed.");
     return EXIT_FAILURE;
@@ -280,7 +281,7 @@ int main(int argc, char* argv[]) {
   const long long timeCodeScale = segment_info->GetTimeCodeScale();
 
   // Set muxer header info
-  mkvmuxer::MkvWriter writer;
+  libwebm::mkvmuxer::MkvWriter writer;
 
   const std::string temp_file = libwebm::GetTempFileName();
   if (!writer.Open(cues_before_clusters ? temp_file.c_str() : output)) {
@@ -289,7 +290,7 @@ int main(int argc, char* argv[]) {
   }
 
   // Set Segment element attributes
-  mkvmuxer::Segment muxer_segment;
+  libwebm::mkvmuxer::Segment muxer_segment;
 
   if (!muxer_segment.Init(&writer)) {
     printf("\n Could not initialize muxer segment!\n");
@@ -297,9 +298,9 @@ int main(int argc, char* argv[]) {
   }
 
   if (live_mode)
-    muxer_segment.set_mode(mkvmuxer::Segment::kLive);
+    muxer_segment.set_mode(libwebm::mkvmuxer::Segment::kLive);
   else
-    muxer_segment.set_mode(mkvmuxer::Segment::kFile);
+    muxer_segment.set_mode(libwebm::mkvmuxer::Segment::kFile);
 
   if (chunking)
     muxer_segment.SetChunking(true, chunk_name);
@@ -311,18 +312,18 @@ int main(int argc, char* argv[]) {
   muxer_segment.OutputCues(output_cues);
 
   // Set SegmentInfo element attributes
-  mkvmuxer::SegmentInfo* const info = muxer_segment.GetSegmentInfo();
+  libwebm::mkvmuxer::SegmentInfo* const info = muxer_segment.GetSegmentInfo();
   info->set_timecode_scale(timeCodeScale);
   info->set_writing_app("sample_muxer");
 
-  const mkvparser::Tags* const tags = parser_segment->GetTags();
+  const libwebm::mkvparser::Tags* const tags = parser_segment->GetTags();
   if (copy_tags && tags) {
     for (int i = 0; i < tags->GetTagCount(); i++) {
-      const mkvparser::Tags::Tag* const tag = tags->GetTag(i);
-      mkvmuxer::Tag* muxer_tag = muxer_segment.AddTag();
+      const libwebm::mkvparser::Tags::Tag* const tag = tags->GetTag(i);
+      libwebm::mkvmuxer::Tag* muxer_tag = muxer_segment.AddTag();
 
       for (int j = 0; j < tag->GetSimpleTagCount(); j++) {
-        const mkvparser::Tags::SimpleTag* const simple_tag =
+        const libwebm::mkvparser::Tags::SimpleTag* const simple_tag =
             tag->GetSimpleTag(j);
         muxer_tag->add_simple_tag(simple_tag->GetTagName(),
                                   simple_tag->GetTagString());
@@ -331,20 +332,20 @@ int main(int argc, char* argv[]) {
   }
 
   // Set Tracks element attributes
-  const mkvparser::Tracks* const parser_tracks = parser_segment->GetTracks();
+  const libwebm::mkvparser::Tracks* const parser_tracks =
+      parser_segment->GetTracks();
   unsigned long i = 0;
-  uint64 vid_track = 0;  // no track added
-  uint64 aud_track = 0;  // no track added
+  libwebm::uint64 vid_track = 0;  // no track added
+  libwebm::uint64 aud_track = 0;  // no track added
 
-  using mkvparser::Track;
+  using libwebm::mkvparser::Track;
 
   while (i != parser_tracks->GetTracksCount()) {
     int track_num = i++;
     if (switch_tracks)
       track_num = i % parser_tracks->GetTracksCount();
 
-    const mkvparser::Track* const parser_track =
-        parser_tracks->GetTrackByIndex(track_num);
+    const Track* const parser_track = parser_tracks->GetTrackByIndex(track_num);
 
     if (parser_track == NULL)
       continue;
@@ -356,8 +357,8 @@ int main(int argc, char* argv[]) {
 
     if (track_type == Track::kVideo && output_video) {
       // Get the video track from the parser
-      const mkvparser::VideoTrack* const pVideoTrack =
-          static_cast<const mkvparser::VideoTrack*>(parser_track);
+      const libwebm::mkvparser::VideoTrack* const pVideoTrack =
+          static_cast<const libwebm::mkvparser::VideoTrack*>(parser_track);
       const long long width = pVideoTrack->GetWidth();
       const long long height = pVideoTrack->GetHeight();
 
@@ -370,15 +371,16 @@ int main(int argc, char* argv[]) {
         return EXIT_FAILURE;
       }
 
-      mkvmuxer::VideoTrack* const video = static_cast<mkvmuxer::VideoTrack*>(
-          muxer_segment.GetTrackByNumber(vid_track));
+      libwebm::mkvmuxer::VideoTrack* const video =
+          static_cast<libwebm::mkvmuxer::VideoTrack*>(
+              muxer_segment.GetTrackByNumber(vid_track));
       if (!video) {
         printf("\n Could not get video track.\n");
         return EXIT_FAILURE;
       }
 
       if (pVideoTrack->GetColour()) {
-        mkvmuxer::Colour muxer_colour;
+        libwebm::mkvmuxer::Colour muxer_colour;
         if (!libwebm::CopyColour(*pVideoTrack->GetColour(), &muxer_colour))
           return EXIT_FAILURE;
         if (!video->SetColour(muxer_colour))
@@ -403,8 +405,8 @@ int main(int argc, char* argv[]) {
       }
     } else if (track_type == Track::kAudio && output_audio) {
       // Get the audio track from the parser
-      const mkvparser::AudioTrack* const pAudioTrack =
-          static_cast<const mkvparser::AudioTrack*>(parser_track);
+      const libwebm::mkvparser::AudioTrack* const pAudioTrack =
+          static_cast<const libwebm::mkvparser::AudioTrack*>(parser_track);
       const long long channels = pAudioTrack->GetChannels();
       const double sample_rate = pAudioTrack->GetSamplingRate();
 
@@ -417,8 +419,9 @@ int main(int argc, char* argv[]) {
         return EXIT_FAILURE;
       }
 
-      mkvmuxer::AudioTrack* const audio = static_cast<mkvmuxer::AudioTrack*>(
-          muxer_segment.GetTrackByNumber(aud_track));
+      libwebm::mkvmuxer::AudioTrack* const audio =
+          static_cast<libwebm::mkvmuxer::AudioTrack*>(
+              muxer_segment.GetTrackByNumber(aud_track));
       if (!audio) {
         printf("\n Could not get audio track.\n");
         return EXIT_FAILURE;
@@ -455,7 +458,7 @@ int main(int argc, char* argv[]) {
   // add a track to the output file corresponding to each metadata
   // input file.
 
-  SampleMuxerMetadata metadata;
+  libwebm::SampleMuxerMetadata metadata;
 
   if (!metadata.Init(&muxer_segment)) {
     printf("\n Could not initialize metadata cache.\n");
@@ -469,7 +472,7 @@ int main(int argc, char* argv[]) {
     return EXIT_FAILURE;
 
   // Set Cues element attributes
-  mkvmuxer::Cues* const cues = muxer_segment.GetCues();
+  libwebm::mkvmuxer::Cues* const cues = muxer_segment.GetCues();
   cues->set_output_block_number(output_cues_block_number);
   if (cues_on_video_track && vid_track)
     muxer_segment.CuesTrack(vid_track);
@@ -480,10 +483,10 @@ int main(int argc, char* argv[]) {
   unsigned char* data = NULL;
   int data_len = 0;
 
-  const mkvparser::Cluster* cluster = parser_segment->GetFirst();
+  const libwebm::mkvparser::Cluster* cluster = parser_segment->GetFirst();
 
   while ((cluster != NULL) && !cluster->EOS()) {
-    const mkvparser::BlockEntry* block_entry;
+    const libwebm::mkvparser::BlockEntry* block_entry;
 
     long status = cluster->GetFirst(block_entry);
 
@@ -493,9 +496,9 @@ int main(int argc, char* argv[]) {
     }
 
     while ((block_entry != NULL) && !block_entry->EOS()) {
-      const mkvparser::Block* const block = block_entry->GetBlock();
+      const libwebm::mkvparser::Block* const block = block_entry->GetBlock();
       const long long trackNum = block->GetTrackNumber();
-      const mkvparser::Track* const parser_track =
+      const libwebm::mkvparser::Track* const parser_track =
           parser_tracks->GetTrackByNumber(static_cast<unsigned long>(trackNum));
 
       // When |parser_track| is NULL, it means that the track number in the
@@ -518,7 +521,7 @@ int main(int argc, char* argv[]) {
         const int frame_count = block->GetFrameCount();
 
         for (int i = 0; i < frame_count; ++i) {
-          const mkvparser::Block::Frame& frame = block->GetFrame(i);
+          const libwebm::mkvparser::Block::Frame& frame = block->GetFrame(i);
 
           if (frame.len > data_len) {
             delete[] data;
@@ -531,7 +534,7 @@ int main(int argc, char* argv[]) {
           if (frame.Read(&reader, data))
             return EXIT_FAILURE;
 
-          mkvmuxer::Frame muxer_frame;
+          libwebm::mkvmuxer::Frame muxer_frame;
           if (!muxer_frame.Init(data, frame.len))
             return EXIT_FAILURE;
           muxer_frame.set_track_number(track_type == Track::kAudio ? aud_track :
diff --git a/sample_muxer_metadata.cc b/sample_muxer_metadata.cc
index c5a5b0f..92fc3ff 100644
--- a/sample_muxer_metadata.cc
+++ b/sample_muxer_metadata.cc
@@ -17,6 +17,8 @@
 #include "mkvmuxer.hpp"
 #include "vttreader.h"
 
+namespace libwebm {
+
 SampleMuxerMetadata::SampleMuxerMetadata() : segment_(NULL) {}
 
 bool SampleMuxerMetadata::Init(mkvmuxer::Segment* segment) {
@@ -31,7 +33,7 @@ bool SampleMuxerMetadata::Load(const char* file, Kind kind) {
   if (kind == kChapters)
     return LoadChapters(file);
 
-  mkvmuxer::uint64 track_num;
+  uint64 track_num;
 
   if (!AddTrack(kind, &track_num)) {
     printf("Unable to add track for WebVTT file \"%s\"\n", file);
@@ -56,7 +58,7 @@ bool SampleMuxerMetadata::AddChapters() {
   return true;
 }
 
-bool SampleMuxerMetadata::Write(mkvmuxer::int64 time_ns) {
+bool SampleMuxerMetadata::Write(int64 time_ns) {
   typedef cues_set_t::iterator iter_t;
 
   iter_t i = cues_set_.begin();
@@ -172,8 +174,8 @@ bool SampleMuxerMetadata::AddChapter(const cue_t& cue) {
   const time_ms_t stop_time_ms = cue.stop_time.presentation();
 
   enum { kNsPerMs = 1000000 };
-  const mkvmuxer::uint64 start_time_ns = start_time_ms * kNsPerMs;
-  const mkvmuxer::uint64 stop_time_ns = stop_time_ms * kNsPerMs;
+  const uint64 start_time_ns = start_time_ms * kNsPerMs;
+  const uint64 stop_time_ns = stop_time_ms * kNsPerMs;
 
   chapter->set_time(*segment_, start_time_ns, stop_time_ns);
 
@@ -201,7 +203,7 @@ bool SampleMuxerMetadata::AddChapter(const cue_t& cue) {
   return true;
 }
 
-bool SampleMuxerMetadata::AddTrack(Kind kind, mkvmuxer::uint64* track_num) {
+bool SampleMuxerMetadata::AddTrack(Kind kind, uint64* track_num) {
   *track_num = 0;
 
   // Track number value 0 means "let muxer choose track number"
@@ -250,7 +252,7 @@ bool SampleMuxerMetadata::AddTrack(Kind kind, mkvmuxer::uint64* track_num) {
 }
 
 bool SampleMuxerMetadata::Parse(const char* file, Kind /* kind */,
-                                mkvmuxer::uint64 track_num) {
+                                uint64 track_num) {
   libwebvtt::VttReader r;
   int e = r.Open(file);
 
@@ -359,26 +361,26 @@ void SampleMuxerMetadata::WriteCuePayload(const cue_t::payload_t& payload,
 
 bool SampleMuxerMetadata::SortableCue::Write(mkvmuxer::Segment* segment) const {
   // Cue start time expressed in milliseconds
-  const mkvmuxer::int64 start_ms = cue.start_time.presentation();
+  const int64 start_ms = cue.start_time.presentation();
 
   // Cue start time expressed in nanoseconds (MKV time)
-  const mkvmuxer::int64 start_ns = start_ms * 1000000;
+  const int64 start_ns = start_ms * 1000000;
 
   // Cue stop time expressed in milliseconds
-  const mkvmuxer::int64 stop_ms = cue.stop_time.presentation();
+  const int64 stop_ms = cue.stop_time.presentation();
 
   // Cue stop time expressed in nanonseconds
-  const mkvmuxer::int64 stop_ns = stop_ms * 1000000;
+  const int64 stop_ns = stop_ms * 1000000;
 
   // Metadata blocks always specify the block duration.
-  const mkvmuxer::int64 duration_ns = stop_ns - start_ns;
+  const int64 duration_ns = stop_ns - start_ns;
 
   std::string frame;
   MakeFrame(cue, &frame);
 
-  typedef const mkvmuxer::uint8* data_t;
+  typedef const uint8* data_t;
   const data_t buf = reinterpret_cast<data_t>(frame.data());
-  const mkvmuxer::uint64 len = frame.length();
+  const uint64 len = frame.length();
 
   mkvmuxer::Frame muxer_frame;
   if (!muxer_frame.Init(buf, len))
@@ -389,3 +391,5 @@ bool SampleMuxerMetadata::SortableCue::Write(mkvmuxer::Segment* segment) const {
   muxer_frame.set_is_key(true);  // All metadata frames are keyframes.
   return segment->AddGenericFrame(&muxer_frame);
 }
+
+}  // namespace libwebm
diff --git a/sample_muxer_metadata.h b/sample_muxer_metadata.h
index fbeab1c..379338a 100644
--- a/sample_muxer_metadata.h
+++ b/sample_muxer_metadata.h
@@ -16,6 +16,8 @@
 #include "mkvmuxertypes.hpp"
 #include "webvttparser.h"
 
+namespace libwebm {
+
 namespace mkvmuxer {
 class Chapter;
 class Frame;
@@ -43,19 +45,19 @@ class SampleMuxerMetadata {
   // Write any WebVTT cues whose time is less or equal to |time_ns| as
   // a metadata block in its corresponding track.  If |time_ns| is
   // negative, write all remaining cues. Returns false on error.
-  bool Write(mkvmuxer::int64 time_ns);
+  bool Write(int64 time_ns);
 
  private:
   typedef libwebvtt::Cue cue_t;
 
   // Used to sort cues as they are loaded.
   struct SortableCue {
-    bool operator>(mkvmuxer::int64 time_ns) const {
+    bool operator>(int64 time_ns) const {
       // Cue start time expressed in milliseconds
-      const mkvmuxer::int64 start_ms = cue.start_time.presentation();
+      const int64 start_ms = cue.start_time.presentation();
 
       // Cue start time expressed in nanoseconds (MKV time)
-      const mkvmuxer::int64 start_ns = start_ms * 1000000;
+      const int64 start_ns = start_ms * 1000000;
 
       return (start_ns > time_ns);
     }
@@ -74,7 +76,7 @@ class SampleMuxerMetadata {
     // error.
     bool Write(mkvmuxer::Segment* segment) const;
 
-    mkvmuxer::uint64 track_num;
+    uint64 track_num;
     cue_t cue;
   };
 
@@ -97,12 +99,12 @@ class SampleMuxerMetadata {
   // Add a metadata track to the segment having the indicated |kind|,
   // returning the |track_num| that has been chosen for this track.
   // Returns false on error.
-  bool AddTrack(Kind kind, mkvmuxer::uint64* track_num);
+  bool AddTrack(Kind kind, uint64* track_num);
 
   // Parse the WebVTT |file| having the indicated |kind| and
   // |track_num|, adding each parsed cue to cues set.  Returns false
   // on error.
-  bool Parse(const char* file, Kind kind, mkvmuxer::uint64 track_num);
+  bool Parse(const char* file, Kind kind, uint64 track_num);
 
   // Converts a WebVTT cue to a Matroska metadata block.
   static void MakeFrame(const cue_t& cue, std::string* frame);
@@ -133,4 +135,6 @@ class SampleMuxerMetadata {
   SampleMuxerMetadata& operator=(const SampleMuxerMetadata&);
 };
 
+}  // namespace libwebm
+
 #endif  // SAMPLE_MUXER_METADATA_H_  // NOLINT
diff --git a/testing/muxer_tests.cc b/testing/muxer_tests.cc
index 10b0448..f702da1 100644
--- a/testing/muxer_tests.cc
+++ b/testing/muxer_tests.cc
@@ -14,8 +14,8 @@
 #include <ostream>
 #include <string>
 
-#include "gtest/gtest.h"
 #include "gtest/gtest-message.h"
+#include "gtest/gtest.h"
 
 #include "mkvmuxer.hpp"
 #include "mkvmuxertypes.hpp"
@@ -31,14 +31,14 @@
 #pragma warning(disable : 4996)
 #endif
 
-using ::mkvmuxer::AudioTrack;
-using ::mkvmuxer::Chapter;
-using ::mkvmuxer::Frame;
-using ::mkvmuxer::MkvWriter;
-using ::mkvmuxer::Segment;
-using ::mkvmuxer::SegmentInfo;
-using ::mkvmuxer::Track;
-using ::mkvmuxer::VideoTrack;
+using libwebm::mkvmuxer::AudioTrack;
+using libwebm::mkvmuxer::Chapter;
+using libwebm::mkvmuxer::Frame;
+using libwebm::mkvmuxer::MkvWriter;
+using libwebm::mkvmuxer::Segment;
+using libwebm::mkvmuxer::SegmentInfo;
+using libwebm::mkvmuxer::Track;
+using libwebm::mkvmuxer::VideoTrack;
 
 namespace libwebm {
 namespace test {
@@ -123,8 +123,7 @@ TEST_F(MuxerTest, SegmentInfo) {
   info->set_duration(2.345);
   EXPECT_STREQ(kAppString, info->muxing_app());
   EXPECT_STREQ(kAppString, info->writing_app());
-  EXPECT_EQ(static_cast<mkvmuxer::uint64>(kTimeCodeScale),
-            info->timecode_scale());
+  EXPECT_EQ(static_cast<uint64>(kTimeCodeScale), info->timecode_scale());
   EXPECT_DOUBLE_EQ(2.345, info->duration());
   AddVideoTrack();
 
@@ -142,19 +141,19 @@ TEST_F(MuxerTest, AddTracks) {
   VideoTrack* const video =
       dynamic_cast<VideoTrack*>(segment_.GetTrackByNumber(kVideoTrackNumber));
   ASSERT_TRUE(video != NULL);
-  EXPECT_EQ(static_cast<mkvmuxer::uint64>(kWidth), video->width());
-  EXPECT_EQ(static_cast<mkvmuxer::uint64>(kHeight), video->height());
+  EXPECT_EQ(static_cast<uint64>(kWidth), video->width());
+  EXPECT_EQ(static_cast<uint64>(kHeight), video->height());
   video->set_name(kTrackName);
   video->set_display_width(kWidth - 10);
   video->set_display_height(kHeight - 10);
   video->set_frame_rate(0.5);
   EXPECT_STREQ(kTrackName, video->name());
-  const mkvmuxer::uint64 kDisplayWidth = kWidth - 10;
+  const uint64 kDisplayWidth = kWidth - 10;
   EXPECT_EQ(kDisplayWidth, video->display_width());
-  const mkvmuxer::uint64 kDisplayHeight = kHeight - 10;
+  const uint64 kDisplayHeight = kHeight - 10;
   EXPECT_EQ(kDisplayHeight, video->display_height());
   EXPECT_DOUBLE_EQ(0.5, video->frame_rate());
-  EXPECT_EQ(static_cast<mkvmuxer::uint64>(kVideoTrackNumber), video->uid());
+  EXPECT_EQ(static_cast<uint64>(kVideoTrackNumber), video->uid());
 
   // Add an Audio Track
   const int aud_track =
@@ -163,14 +162,14 @@ TEST_F(MuxerTest, AddTracks) {
   AudioTrack* const audio =
       dynamic_cast<AudioTrack*>(segment_.GetTrackByNumber(aud_track));
   EXPECT_EQ(kSampleRate, audio->sample_rate());
-  EXPECT_EQ(static_cast<mkvmuxer::uint64>(kChannels), audio->channels());
+  EXPECT_EQ(static_cast<uint64>(kChannels), audio->channels());
   ASSERT_TRUE(audio != NULL);
   audio->set_name(kTrackName);
   audio->set_bit_depth(kBitDepth);
   audio->set_uid(kAudioTrackNumber);
   EXPECT_STREQ(kTrackName, audio->name());
-  EXPECT_EQ(static_cast<mkvmuxer::uint64>(kBitDepth), audio->bit_depth());
-  EXPECT_EQ(static_cast<mkvmuxer::uint64>(kAudioTrackNumber), audio->uid());
+  EXPECT_EQ(static_cast<uint64>(kBitDepth), audio->bit_depth());
+  EXPECT_EQ(static_cast<uint64>(kAudioTrackNumber), audio->uid());
 
   AddDummyFrameAndFinalize(kVideoTrackNumber);
   CloseWriter();
@@ -488,7 +487,7 @@ TEST_F(MuxerTest, CuesBeforeClusters) {
 TEST_F(MuxerTest, MaxClusterSize) {
   EXPECT_TRUE(SegmentInit(false));
   AddVideoTrack();
-  const mkvmuxer::uint64 kMaxClusterSize = 20;
+  const uint64 kMaxClusterSize = 20;
   segment_.set_max_cluster_size(kMaxClusterSize);
   EXPECT_EQ(kMaxClusterSize, segment_.max_cluster_size());
   EXPECT_TRUE(segment_.AddFrame(dummy_data_, 1, kVideoTrackNumber, 0, false));
@@ -513,7 +512,7 @@ TEST_F(MuxerTest, MaxClusterSize) {
 TEST_F(MuxerTest, MaxClusterDuration) {
   EXPECT_TRUE(SegmentInit(false));
   AddVideoTrack();
-  const mkvmuxer::uint64 kMaxClusterDuration = 4000000;
+  const uint64 kMaxClusterDuration = 4000000;
   segment_.set_max_cluster_duration(kMaxClusterDuration);
 
   EXPECT_EQ(kMaxClusterDuration, segment_.max_cluster_duration());
@@ -538,9 +537,9 @@ TEST_F(MuxerTest, MaxClusterDuration) {
 }
 
 TEST_F(MuxerTest, SetCuesTrackNumber) {
-  const mkvmuxer::uint64 kTrackNumber = 10;
+  const uint64 kTrackNumber = 10;
   EXPECT_TRUE(SegmentInit(true));
-  const mkvmuxer::uint64 vid_track =
+  const uint64 vid_track =
       segment_.AddVideoTrack(kWidth, kHeight, kTrackNumber);
   EXPECT_EQ(kTrackNumber, vid_track);
   segment_.GetTrackByNumber(vid_track)->set_uid(kVideoTrackNumber);
diff --git a/testing/parser_tests.cc b/testing/parser_tests.cc
index 2f9ad5a..a4c4839 100644
--- a/testing/parser_tests.cc
+++ b/testing/parser_tests.cc
@@ -19,19 +19,19 @@
 
 #include "testing/test_util.h"
 
-using ::mkvparser::AudioTrack;
-using ::mkvparser::Block;
-using ::mkvparser::BlockEntry;
-using ::mkvparser::BlockGroup;
-using ::mkvparser::Cluster;
-using ::mkvparser::CuePoint;
-using ::mkvparser::Cues;
-using ::mkvparser::MkvReader;
-using ::mkvparser::Segment;
-using ::mkvparser::SegmentInfo;
-using ::mkvparser::Track;
-using ::mkvparser::Tracks;
-using ::mkvparser::VideoTrack;
+using libwebm::mkvparser::AudioTrack;
+using libwebm::mkvparser::Block;
+using libwebm::mkvparser::BlockEntry;
+using libwebm::mkvparser::BlockGroup;
+using libwebm::mkvparser::Cluster;
+using libwebm::mkvparser::CuePoint;
+using libwebm::mkvparser::Cues;
+using libwebm::mkvparser::MkvReader;
+using libwebm::mkvparser::Segment;
+using libwebm::mkvparser::SegmentInfo;
+using libwebm::mkvparser::Track;
+using libwebm::mkvparser::Tracks;
+using libwebm::mkvparser::VideoTrack;
 
 namespace libwebm {
 namespace test {
diff --git a/vttdemux.cc b/vttdemux.cc
index e31b56d..56ddacf 100644
--- a/vttdemux.cc
+++ b/vttdemux.cc
@@ -6,8 +6,8 @@
 // in the file PATENTS.  All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 
-#include <cstdlib>
 #include <cstdio>
+#include <cstdlib>
 #include <cstring>
 #include <map>
 #include <memory>
@@ -25,6 +25,7 @@
 
 using std::string;
 
+namespace libwebm {
 namespace vttdemux {
 
 typedef long long mkvtime_t;  // NOLINT
@@ -221,56 +222,6 @@ bool WriteCueTime(FILE* f, mkvtime_t time_ns);
 bool WriteCuePayload(FILE* f, FrameParser* parser);
 }  // namespace vttdemux
 
-int main(int argc, const char* argv[]) {
-  if (argc != 2) {
-    printf("usage: vttdemux <webmfile>\n");
-    return EXIT_SUCCESS;
-  }
-
-  const char* const filename = argv[1];
-  mkvparser::MkvReader reader;
-
-  int e = reader.Open(filename);
-
-  if (e) {  // error
-    printf("unable to open file\n");
-    return EXIT_FAILURE;
-  }
-
-  vttdemux::mkvpos_t pos;
-
-  if (!vttdemux::ParseHeader(&reader, &pos))
-    return EXIT_FAILURE;
-
-  vttdemux::segment_ptr_t segment_ptr;
-
-  if (!vttdemux::ParseSegment(&reader, pos, &segment_ptr))
-    return EXIT_FAILURE;
-
-  vttdemux::metadata_map_t metadata_map;
-
-  BuildMap(segment_ptr.get(), &metadata_map);
-
-  if (metadata_map.empty()) {
-    printf("no WebVTT metadata found\n");
-    return EXIT_FAILURE;
-  }
-
-  if (!OpenFiles(&metadata_map, filename)) {
-    CloseFiles(&metadata_map);  // nothing to flush, so not strictly necessary
-    return EXIT_FAILURE;
-  }
-
-  if (!WriteFiles(metadata_map, segment_ptr.get())) {
-    CloseFiles(&metadata_map);  // might as well flush what we do have
-    return EXIT_FAILURE;
-  }
-
-  CloseFiles(&metadata_map);
-
-  return EXIT_SUCCESS;
-}
-
 namespace vttdemux {
 
 FrameParser::FrameParser(const mkvparser::BlockGroup* block_group)
@@ -1000,3 +951,55 @@ bool vttdemux::WriteCuePayload(FILE* f, FrameParser* parser) {
 
   return true;
 }
+
+}  // namespace libwebm
+
+int main(int argc, const char* argv[]) {
+  if (argc != 2) {
+    printf("usage: vttdemux <webmfile>\n");
+    return EXIT_SUCCESS;
+  }
+
+  const char* const filename = argv[1];
+  libwebm::mkvparser::MkvReader reader;
+
+  int e = reader.Open(filename);
+
+  if (e) {  // error
+    printf("unable to open file\n");
+    return EXIT_FAILURE;
+  }
+
+  libwebm::vttdemux::mkvpos_t pos;
+
+  if (!libwebm::vttdemux::ParseHeader(&reader, &pos))
+    return EXIT_FAILURE;
+
+  libwebm::vttdemux::segment_ptr_t segment_ptr;
+
+  if (!libwebm::vttdemux::ParseSegment(&reader, pos, &segment_ptr))
+    return EXIT_FAILURE;
+
+  libwebm::vttdemux::metadata_map_t metadata_map;
+
+  BuildMap(segment_ptr.get(), &metadata_map);
+
+  if (metadata_map.empty()) {
+    printf("no WebVTT metadata found\n");
+    return EXIT_FAILURE;
+  }
+
+  if (!OpenFiles(&metadata_map, filename)) {
+    CloseFiles(&metadata_map);  // nothing to flush, so not strictly necessary
+    return EXIT_FAILURE;
+  }
+
+  if (!WriteFiles(metadata_map, segment_ptr.get())) {
+    CloseFiles(&metadata_map);  // might as well flush what we do have
+    return EXIT_FAILURE;
+  }
+
+  CloseFiles(&metadata_map);
+
+  return EXIT_SUCCESS;
+}
\ No newline at end of file
diff --git a/webmids.hpp b/webmids.hpp
index b36c1cf..4b124a8 100644
--- a/webmids.hpp
+++ b/webmids.hpp
@@ -9,7 +9,7 @@
 #ifndef WEBMIDS_HPP
 #define WEBMIDS_HPP
 
-namespace mkvmuxer {
+namespace libwebm {
 
 enum MkvId {
   kMkvEBML = 0x1A45DFA3,
@@ -179,6 +179,6 @@ enum MkvId {
   kMkvTagString = 0x4487
 };
 
-}  // end namespace mkvmuxer
+}  // namespace libwebm
 
 #endif  // WEBMIDS_HPP