From 3d76d583e1bdca56ad53dc2fc78bc28f94f59caf Mon Sep 17 00:00:00 2001
From: Thomas Goyne <plorkyeran@aegisub.org>
Date: Sun, 23 Mar 2014 09:01:25 -0700
Subject: [PATCH] Use stdint types in MatroskaParser

---
 src/MatroskaParser.c | 250 +++++++++++++++++++++----------------------
 src/MatroskaParser.h |  67 ++++++------
 src/mkv_wrap.cpp     |  14 +--
 3 files changed, 162 insertions(+), 169 deletions(-)

diff --git a/src/MatroskaParser.c b/src/MatroskaParser.c
index 6942423dc..83f00f77c 100644
--- a/src/MatroskaParser.c
+++ b/src/MatroskaParser.c
@@ -111,9 +111,9 @@ static void  mystrlcpy(char *dst,const char *src,unsigned size) {
 }
 
 struct Cue {
-  ulonglong	Time;
-  ulonglong	Position;
-  ulonglong	Block;
+  uint64_t	Time;
+  uint64_t	Position;
+  uint64_t	Block;
   unsigned char	Track;
 };
 
@@ -121,9 +121,9 @@ struct QueueEntry {
   struct QueueEntry *next;
   unsigned int	    Length;
 
-  ulonglong	    Start;
-  ulonglong	    End;
-  ulonglong	    Position;
+  uint64_t	    Start;
+  uint64_t	    End;
+  uint64_t	    Position;
 
   unsigned int	    flags;
 };
@@ -147,7 +147,7 @@ struct MatroskaFile {
 
   // internal buffering
   char	      inbuf[IBSZ];
-  ulonglong   bufbase; // file offset of the first byte in buffer
+  uint64_t   bufbase; // file offset of the first byte in buffer
   int	      bufpos; // current read position in buffer
   int	      buflen; // valid bytes in buffer
 
@@ -156,15 +156,15 @@ struct MatroskaFile {
   jmp_buf     jb;
 
   // pointers to key elements
-  ulonglong   pSegment;
-  ulonglong   pSeekHead;
-  ulonglong   pSegmentInfo;
-  ulonglong   pCluster;
-  ulonglong   pTracks;
-  ulonglong   pCues;
-  ulonglong   pAttachments;
-  ulonglong   pChapters;
-  ulonglong   pTags;
+  uint64_t   pSegment;
+  uint64_t   pSeekHead;
+  uint64_t   pSegmentInfo;
+  uint64_t   pCluster;
+  uint64_t   pTracks;
+  uint64_t   pCues;
+  uint64_t   pAttachments;
+  uint64_t   pChapters;
+  uint64_t   pTags;
 
   // flags for key elements
   struct {
@@ -178,7 +178,7 @@ struct MatroskaFile {
   } seen;
 
   // file info
-  ulonglong   firstTimecode;
+  uint64_t   firstTimecode;
 
   // SegmentInfo
   struct SegmentInfo  Seg;
@@ -192,10 +192,10 @@ struct MatroskaFile {
   unsigned int	    nQBlocks,nQBlocksSize;
   struct QueueEntry **QBlocks;
   struct Queue	    *Queues;
-  ulonglong	    readPosition;
+  uint64_t	    readPosition;
   unsigned int	    trackMask;
-  ulonglong	    pSegmentTop;  // offset of next byte after the segment
-  ulonglong	    tcCluster;    // current cluster timecode
+  uint64_t	    pSegmentTop;  // offset of next byte after the segment
+  uint64_t	    tcCluster;    // current cluster timecode
 
   // Cues
   unsigned int	    nCues,nCuesSize;
@@ -227,7 +227,7 @@ static void   myvsnprintf_string(char **pdest,char *de,const char *str) {
 
 static void   myvsnprintf_uint_impl(char **pdest,char *de,int width,int zero,
 				    int neg,unsigned base,int letter,
-				    int ms,ulonglong val)
+				    int ms,uint64_t val)
 {
   char	*dest = *pdest;
   char	tmp[21]; /* enough for 64 bit ints */
@@ -275,14 +275,14 @@ static void   myvsnprintf_uint_impl(char **pdest,char *de,int width,int zero,
 
 static void   myvsnprintf_uint(char **pdest,char *de,int width,int zero,
 			       int neg,unsigned base,int letter,
-			       ulonglong val)
+			       uint64_t val)
 {
   myvsnprintf_uint_impl(pdest,de,width,zero,neg,base,letter,0,val);
 }
 
 static void   myvsnprintf_int(char **pdest,char *de,int width,int zero,
 			      int neg,unsigned base,int letter,
-			      longlong val)
+			      int64_t val)
 {
   if (val < 0)
     myvsnprintf_uint_impl(pdest,de,width,zero,neg,base,letter,1,-val);
@@ -348,7 +348,7 @@ static void   myvsnprintf(char *dest,unsigned dsize,const char *fmt,va_list ap)
 		myvsnprintf_int(&dest,de,width,zero,neg,10,'a',va_arg(ap,long));
 		break;
 	      case 2:
-		myvsnprintf_int(&dest,de,width,zero,neg,10,'a',va_arg(ap,longlong));
+		myvsnprintf_int(&dest,de,width,zero,neg,10,'a',va_arg(ap,int64_t));
 		break;
 	    }
 	    break;
@@ -361,7 +361,7 @@ static void   myvsnprintf(char *dest,unsigned dsize,const char *fmt,va_list ap)
 		myvsnprintf_uint(&dest,de,width,zero,neg,10,'a',va_arg(ap,unsigned long));
 		break;
 	      case 2:
-		myvsnprintf_uint(&dest,de,width,zero,neg,10,'a',va_arg(ap,ulonglong));
+		myvsnprintf_uint(&dest,de,width,zero,neg,10,'a',va_arg(ap,uint64_t));
 		break;
 	    }
 	    break;
@@ -374,7 +374,7 @@ static void   myvsnprintf(char *dest,unsigned dsize,const char *fmt,va_list ap)
 		myvsnprintf_uint(&dest,de,width,zero,neg,16,'a',va_arg(ap,unsigned long));
 		break;
 	      case 2:
-		myvsnprintf_uint(&dest,de,width,zero,neg,16,'a',va_arg(ap,ulonglong));
+		myvsnprintf_uint(&dest,de,width,zero,neg,16,'a',va_arg(ap,uint64_t));
 		break;
 	    }
 	    break;
@@ -387,7 +387,7 @@ static void   myvsnprintf(char *dest,unsigned dsize,const char *fmt,va_list ap)
 		myvsnprintf_uint(&dest,de,width,zero,neg,16,'A',va_arg(ap,unsigned long));
 		break;
 	      case 2:
-		myvsnprintf_uint(&dest,de,width,zero,neg,16,'A',va_arg(ap,ulonglong));
+		myvsnprintf_uint(&dest,de,width,zero,neg,16,'A',va_arg(ap,uint64_t));
 		break;
 	    }
 	    break;
@@ -537,7 +537,7 @@ static inline int readch(MatroskaFile *mf) {
   return mf->bufpos < mf->buflen ? (unsigned char)(mf->inbuf[mf->bufpos++]) : nextbuf(mf);
 }
 
-static inline ulonglong	filepos(MatroskaFile *mf) {
+static inline uint64_t	filepos(MatroskaFile *mf) {
   return mf->bufbase + mf->bufpos;
 }
 
@@ -566,7 +566,7 @@ static void   readbytes(MatroskaFile *mf,void *buffer,int len) {
   }
 }
 
-static void   skipbytes(MatroskaFile *mf,ulonglong len) {
+static void   skipbytes(MatroskaFile *mf,uint64_t len) {
   unsigned int	    nb = mf->buflen - mf->bufpos;
 
   if (nb > len)
@@ -583,7 +583,7 @@ static void   skipbytes(MatroskaFile *mf,ulonglong len) {
   }
 }
 
-static void seek(MatroskaFile *mf,ulonglong pos) {
+static void seek(MatroskaFile *mf,uint64_t pos) {
   // see if pos is inside buffer
   if (pos>=mf->bufbase && pos<mf->bufbase+mf->buflen)
     mf->bufpos = (unsigned)(pos - mf->bufbase);
@@ -599,14 +599,14 @@ static void seek(MatroskaFile *mf,ulonglong pos) {
 static inline MKFLOAT	mkfi(int i) {
 #ifdef MATROSKA_INTEGER_ONLY
   MKFLOAT  f;
-  f.v = (longlong)i << 32;
+  f.v = (int64_t)i << 32;
   return f;
 #else
   return i;
 #endif
 }
 
-static inline longlong mul3(MKFLOAT scale,longlong tc) {
+static inline int64_t mul3(MKFLOAT scale,int64_t tc) {
 #ifdef MATROSKA_INTEGER_ONLY
   //             x1 x0
   //             y1 y0
@@ -620,7 +620,7 @@ static inline longlong mul3(MKFLOAT scale,longlong tc) {
   //
   //    r = ((x0*y0) >> 32) + (x1*y0) + (x0*y1) + ((x1*y1) << 32)
   unsigned    x0,x1,y0,y1;
-  ulonglong   p;
+  uint64_t   p;
   char	      sign = 0;
 
   if (scale.v < 0)
@@ -629,18 +629,18 @@ static inline longlong mul3(MKFLOAT scale,longlong tc) {
     sign = !sign, tc = -tc;
 
   x0 = (unsigned)scale.v;
-  x1 = (unsigned)((ulonglong)scale.v >> 32);
+  x1 = (unsigned)((uint64_t)scale.v >> 32);
   y0 = (unsigned)tc;
-  y1 = (unsigned)((ulonglong)tc >> 32);
+  y1 = (unsigned)((uint64_t)tc >> 32);
 
-  p = (ulonglong)x0*y0 >> 32;
-  p += (ulonglong)x0*y1;
-  p += (ulonglong)x1*y0;
-  p += (ulonglong)(x1*y1) << 32;
+  p = (uint64_t)x0*y0 >> 32;
+  p += (uint64_t)x0*y1;
+  p += (uint64_t)x1*y0;
+  p += (uint64_t)(x1*y1) << 32;
 
   return p;
 #else
-  return (longlong)(scale * tc);
+  return (int64_t)(scale * tc);
 #endif
 }
 
@@ -684,9 +684,9 @@ fail:
   return 0; // NOT REACHED
 }
 
-static ulonglong readVLUIntImp(MatroskaFile *mf,int *mask) {
+static uint64_t readVLUIntImp(MatroskaFile *mf,int *mask) {
   int		c,d,m;
-  ulonglong	v = 0;
+  uint64_t	v = 0;
 
   c = readch(mf);
   if (c == EOF)
@@ -700,7 +700,7 @@ static ulonglong readVLUIntImp(MatroskaFile *mf,int *mask) {
       c &= 0x7f >> m;
       if (mask)
 	*mask = m;
-      return v | ((ulonglong)c << m*8);
+      return v | ((uint64_t)c << m*8);
     }
     d = readch(mf);
     if (d == EOF)
@@ -710,13 +710,13 @@ static ulonglong readVLUIntImp(MatroskaFile *mf,int *mask) {
   // NOT REACHED
 }
 
-static inline ulonglong	readVLUInt(MatroskaFile *mf) {
+static inline uint64_t	readVLUInt(MatroskaFile *mf) {
   return readVLUIntImp(mf,NULL);
 }
 
-static ulonglong	readSize(MatroskaFile *mf) {
+static uint64_t	readSize(MatroskaFile *mf) {
   int	    m;
-  ulonglong v = readVLUIntImp(mf,&m);
+  uint64_t v = readVLUIntImp(mf,&m);
 
   // see if it's unspecified
   if (v == (MAXU64 >> (57-m*7)))
@@ -725,20 +725,20 @@ static ulonglong	readSize(MatroskaFile *mf) {
   return v;
 }
 
-static inline longlong	readVLSInt(MatroskaFile *mf) {
-  static longlong bias[8] = { (ONE<<6)-1, (ONE<<13)-1, (ONE<<20)-1, (ONE<<27)-1,
+static inline int64_t	readVLSInt(MatroskaFile *mf) {
+  static int64_t bias[8] = { (ONE<<6)-1, (ONE<<13)-1, (ONE<<20)-1, (ONE<<27)-1,
 			      (ONE<<34)-1, (ONE<<41)-1, (ONE<<48)-1, (ONE<<55)-1 };
 
   int	    m;
-  longlong  v = readVLUIntImp(mf,&m);
+  int64_t  v = readVLUIntImp(mf,&m);
 
   return v - bias[m];
 }
 
-static ulonglong  readUInt(MatroskaFile *mf,unsigned int len) {
+static uint64_t  readUInt(MatroskaFile *mf,unsigned int len) {
   int		c;
   unsigned int	m = len;
-  ulonglong	v = 0;
+  uint64_t	v = 0;
 
   if (len==0)
     return v;
@@ -755,8 +755,8 @@ static ulonglong  readUInt(MatroskaFile *mf,unsigned int len) {
   return v;
 }
 
-static inline longlong	readSInt(MatroskaFile *mf,unsigned int len) {
-  longlong	v = readUInt(mf,(unsigned)len);
+static inline int64_t	readSInt(MatroskaFile *mf,unsigned int len) {
+  int64_t	v = readUInt(mf,(unsigned)len);
   int		s = 64 - (len<<3);
   return (v << s) >> s;
 }
@@ -768,7 +768,7 @@ static MKFLOAT readFloat(MatroskaFile *mf,unsigned int len) {
 #else
   union {
     unsigned int  ui;
-    ulonglong	  ull;
+    uint64_t	  ull;
     float	  f;
     double	  d;
   } u;
@@ -804,7 +804,7 @@ shift:
 	f.v = f.v << shift;
     }
   } else if (len == 8) {
-    ulonglong  ui = readUInt(mf,(unsigned)len);
+    uint64_t  ui = readUInt(mf,(unsigned)len);
     f.v = (ui & LL(0xfffffffffffff)) | LL(0x10000000000000);
     if (ui & 0x80000000)
       f.v = -f.v;
@@ -837,7 +837,7 @@ shift:
 #endif
 }
 
-static void readString(MatroskaFile *mf,ulonglong len,char *buffer,int buflen) {
+static void readString(MatroskaFile *mf,uint64_t len,char *buffer,int buflen) {
   unsigned int	  nread;
 
   if (buflen<1)
@@ -857,7 +857,7 @@ static void readString(MatroskaFile *mf,ulonglong len,char *buffer,int buflen) {
   buffer[nread] = '\0';
 }
 
-static void readLangCC(MatroskaFile *mf, ulonglong len, char lcc[4]) {
+static void readLangCC(MatroskaFile *mf, uint64_t len, char lcc[4]) {
   unsigned  todo = len > 3 ? 3 : (int)len;
 
   lcc[0] = lcc[1] = lcc[2] = lcc[3] = 0;
@@ -869,10 +869,10 @@ static void readLangCC(MatroskaFile *mf, ulonglong len, char lcc[4]) {
 // file parser
 #define	FOREACH(f,tl) \
   { \
-    ulonglong	tmplen = (tl); \
+    uint64_t	tmplen = (tl); \
     { \
-      ulonglong   start = filepos(f); \
-      ulonglong   cur,len; \
+      uint64_t   start = filepos(f); \
+      uint64_t   cur,len; \
       int	      id; \
       for (;;) { \
 	cur = filepos(mf); \
@@ -922,8 +922,8 @@ static int  IsWritingApp(MatroskaFile *mf,const char *str) {
   return !*str;
 }
 */
-static void parseEBML(MatroskaFile *mf,ulonglong toplen) {
-  ulonglong v;
+static void parseEBML(MatroskaFile *mf,uint64_t toplen) {
+  uint64_t v;
   char	    buf[32];
 
   FOREACH(mf,toplen)
@@ -961,9 +961,9 @@ static void parseEBML(MatroskaFile *mf,ulonglong toplen) {
   ENDFOR(mf);
 }
 
-static void parseSeekEntry(MatroskaFile *mf,ulonglong toplen) {
+static void parseSeekEntry(MatroskaFile *mf,uint64_t toplen) {
   int	    seekid = 0;
-  ulonglong pos = (ulonglong)-1;
+  uint64_t pos = (uint64_t)-1;
 
   FOREACH(mf,toplen)
     case 0x53ab: // SeekID
@@ -976,7 +976,7 @@ static void parseSeekEntry(MatroskaFile *mf,ulonglong toplen) {
       break;
   ENDFOR(mf);
 
-  if (pos == (ulonglong)-1)
+  if (pos == (uint64_t)-1)
     errorjmp(mf,"Invalid element position in parseSeekEntry");
 
   pos += mf->pSegment;
@@ -1011,7 +1011,7 @@ static void parseSeekEntry(MatroskaFile *mf,ulonglong toplen) {
   }
 }
 
-static void parseSeekHead(MatroskaFile *mf,ulonglong toplen) {
+static void parseSeekHead(MatroskaFile *mf,uint64_t toplen) {
   FOREACH(mf,toplen)
     case 0x4dbb:
       parseSeekEntry(mf,len);
@@ -1019,7 +1019,7 @@ static void parseSeekHead(MatroskaFile *mf,ulonglong toplen) {
   ENDFOR(mf);
 }
 
-static void parseSegmentInfo(MatroskaFile *mf,ulonglong toplen) {
+static void parseSegmentInfo(MatroskaFile *mf,uint64_t toplen) {
   MKFLOAT     duration = mkfi(0);
 
   if (mf->seen.SegmentInfo) {
@@ -1081,8 +1081,8 @@ static void parseSegmentInfo(MatroskaFile *mf,ulonglong toplen) {
   mf->Seg.Duration = mul3(duration,mf->Seg.TimecodeScale);
 }
 
-static void parseFirstCluster(MatroskaFile *mf,ulonglong toplen) {
-  ulonglong end = filepos(mf) + toplen;
+static void parseFirstCluster(MatroskaFile *mf,uint64_t toplen) {
+  uint64_t end = filepos(mf) + toplen;
 
   mf->seen.Cluster = 1;
   mf->firstTimecode = 0;
@@ -1110,8 +1110,8 @@ static void parseFirstCluster(MatroskaFile *mf,ulonglong toplen) {
   ENDFOR(mf);
 }
 
-static void parseVideoInfo(MatroskaFile *mf,ulonglong toplen,struct TrackInfo *ti) {
-  ulonglong v;
+static void parseVideoInfo(MatroskaFile *mf,uint64_t toplen,struct TrackInfo *ti) {
+  uint64_t v;
   char	    dW = 0, dH = 0;
 
   FOREACH(mf,toplen)
@@ -1199,8 +1199,8 @@ static void parseVideoInfo(MatroskaFile *mf,ulonglong toplen,struct TrackInfo *t
   ENDFOR(mf);
 }
 
-static void parseAudioInfo(MatroskaFile *mf,ulonglong toplen,struct TrackInfo *ti) {
-  ulonglong   v;
+static void parseAudioInfo(MatroskaFile *mf,uint64_t toplen,struct TrackInfo *ti) {
+  uint64_t   v;
 
   FOREACH(mf,toplen)
     case 0xb5: // SamplingFrequency
@@ -1248,9 +1248,9 @@ static void CopyStr(char **src,char **dst) {
   *dst += l;
 }
 
-static void parseTrackEntry(MatroskaFile *mf,ulonglong toplen) {
+static void parseTrackEntry(MatroskaFile *mf,uint64_t toplen) {
   struct TrackInfo  t,*tp,**tpp;
-  ulonglong	    v;
+  uint64_t	    v;
   char		    *cp = NULL, *cs = NULL;
   size_t	    cplen = 0, cslen = 0, cpadd = 0;
   unsigned	    CompScope, num_comp = 0;
@@ -1512,7 +1512,7 @@ static void parseTrackEntry(MatroskaFile *mf,ulonglong toplen) {
   *tpp = tp;
 }
 
-static void parseTracks(MatroskaFile *mf,ulonglong toplen) {
+static void parseTracks(MatroskaFile *mf,uint64_t toplen) {
   mf->seen.Tracks = 1;
   FOREACH(mf,toplen)
     case 0xae: // TrackEntry
@@ -1521,7 +1521,7 @@ static void parseTracks(MatroskaFile *mf,ulonglong toplen) {
   ENDFOR(mf);
 }
 
-static void addCue(MatroskaFile *mf,ulonglong pos,ulonglong timecode) {
+static void addCue(MatroskaFile *mf,uint64_t pos,uint64_t timecode) {
   struct Cue  *cc = AGET(mf,Cues);
   cc->Time = timecode;
   cc->Position = pos;
@@ -1532,7 +1532,7 @@ static void addCue(MatroskaFile *mf,ulonglong pos,ulonglong timecode) {
 static void fixupCues(MatroskaFile *mf) {
   // adjust cues, shift cues if file does not start at 0
   unsigned  i;
-  longlong  adjust = mf->firstTimecode * mf->Seg.TimecodeScale;
+  int64_t  adjust = mf->firstTimecode * mf->Seg.TimecodeScale;
 
   for (i=0;i<mf->nCues;++i) {
     mf->Cues[i].Time *= mf->Seg.TimecodeScale;
@@ -1540,9 +1540,9 @@ static void fixupCues(MatroskaFile *mf) {
   }
 }
 
-static void parseCues(MatroskaFile *mf,ulonglong toplen) {
+static void parseCues(MatroskaFile *mf,uint64_t toplen) {
   jmp_buf     jb;
-  ulonglong   v;
+  uint64_t   v;
   struct Cue  cc;
   unsigned    i,j,k;
 
@@ -1625,7 +1625,7 @@ static void parseCues(MatroskaFile *mf,ulonglong toplen) {
 	}
 }
 
-static void parseAttachment(MatroskaFile *mf,ulonglong toplen) {
+static void parseAttachment(MatroskaFile *mf,uint64_t toplen) {
   struct Attachment a,*pa;
 
   memset(&a,0,sizeof(a));
@@ -1663,7 +1663,7 @@ static void parseAttachment(MatroskaFile *mf,ulonglong toplen) {
     pa->MimeType = mystrdup(mf->cache,a.MimeType);
 }
 
-static void parseAttachments(MatroskaFile *mf,ulonglong toplen) {
+static void parseAttachments(MatroskaFile *mf,uint64_t toplen) {
   mf->seen.Attachments = 1;
 
   FOREACH(mf,toplen)
@@ -1673,7 +1673,7 @@ static void parseAttachments(MatroskaFile *mf,ulonglong toplen) {
   ENDFOR(mf);
 }
 
-static void parseChapter(MatroskaFile *mf,ulonglong toplen,struct Chapter *parent) {
+static void parseChapter(MatroskaFile *mf,uint64_t toplen,struct Chapter *parent) {
   struct ChapterDisplay	*disp;
   struct ChapterProcess	*proc;
   struct ChapterCommand	*cmd;
@@ -1708,7 +1708,7 @@ static void parseChapter(MatroskaFile *mf,ulonglong toplen,struct Chapter *paren
     case 0x8f: // ChapterTrack
       FOREACH(mf,len)
 	case 0x89: // ChapterTrackNumber
-	  *(ulonglong*)(ASGET(mf,ch,Tracks)) = readUInt(mf,(unsigned)len);
+	  *(uint64_t*)(ASGET(mf,ch,Tracks)) = readUInt(mf,(unsigned)len);
 	  break;
       ENDFOR(mf);
       break;
@@ -1816,7 +1816,7 @@ static void parseChapter(MatroskaFile *mf,ulonglong toplen,struct Chapter *paren
   ARELEASE(mf,ch,Children);
 }
 
-static void parseChapters(MatroskaFile *mf,ulonglong toplen) {
+static void parseChapters(MatroskaFile *mf,uint64_t toplen) {
   struct Chapter  *ch;
 
   mf->seen.Chapters = 1;
@@ -1846,7 +1846,7 @@ static void parseChapters(MatroskaFile *mf,ulonglong toplen) {
   ENDFOR(mf);
 }
 
-static void parseTags(MatroskaFile *mf,ulonglong toplen) {
+static void parseTags(MatroskaFile *mf,uint64_t toplen) {
   struct Tag  *tag;
   struct Target *target;
   struct SimpleTag *st;
@@ -1920,7 +1920,7 @@ static void parseTags(MatroskaFile *mf,ulonglong toplen) {
 }
 
 static void parseContainer(MatroskaFile *mf) {
-  ulonglong len;
+  uint64_t len;
   int	    id = readID(mf);
   if (id==EOF)
     errorjmp(mf,"Unexpected EOF in parseContainer");
@@ -1952,7 +1952,7 @@ static void parseContainer(MatroskaFile *mf) {
   }
 }
 
-static void parseContainerPos(MatroskaFile *mf,ulonglong pos) {
+static void parseContainerPos(MatroskaFile *mf,uint64_t pos) {
   seek(mf,pos);
   parseContainer(mf);
 }
@@ -1985,8 +1985,8 @@ static void parsePointers(MatroskaFile *mf) {
   memcpy(&mf->jb,&jb,sizeof(jb));
 }
 
-static void parseSegment(MatroskaFile *mf,ulonglong toplen) {
-  ulonglong   nextpos;
+static void parseSegment(MatroskaFile *mf,uint64_t toplen) {
+  uint64_t   nextpos;
   unsigned    nSeekHeads = 0, dontstop = 0;
   jmp_buf     jb;
 
@@ -2064,8 +2064,8 @@ static void parseSegment(MatroskaFile *mf,ulonglong toplen) {
   parsePointers(mf);
 }
 
-static void parseBlockAdditions(MatroskaFile *mf, ulonglong toplen, ulonglong timecode, unsigned track) {
-  ulonglong	add_id = 1, add_pos, add_len;
+static void parseBlockAdditions(MatroskaFile *mf, uint64_t toplen, uint64_t timecode, unsigned track) {
+  uint64_t	add_id = 1, add_pos, add_len;
   unsigned char	have_add;
 
   FOREACH(mf, toplen)
@@ -2096,10 +2096,10 @@ static void parseBlockAdditions(MatroskaFile *mf, ulonglong toplen, ulonglong ti
   ENDFOR(mf);
 }
 
-static void parseBlockGroup(MatroskaFile *mf,ulonglong toplen,ulonglong timecode, int blockex) {
-  ulonglong	v;
-  ulonglong	duration = 0;
-  ulonglong	dpos;
+static void parseBlockGroup(MatroskaFile *mf,uint64_t toplen,uint64_t timecode, int blockex) {
+  uint64_t	v;
+  uint64_t	duration = 0;
+  uint64_t	dpos;
   struct QueueEntry *qe,*qf = NULL;
   unsigned char	have_duration = 0, have_block = 0;
   unsigned char	gap = 0;
@@ -2253,7 +2253,7 @@ out:
     errorjmp(mf,"Found a BlockGroup without Block");
 
   if (nframes > 1) {
-    ulonglong defd = mf->Tracks[tracknum]->DefaultDuration;
+    uint64_t defd = mf->Tracks[tracknum]->DefaultDuration;
     v = qf->Start;
 
     if (have_duration) {
@@ -2319,8 +2319,8 @@ static void EmptyQueues(MatroskaFile *mf) {
 }
 
 static int  readMoreBlocks(MatroskaFile *mf) {
-  ulonglong		toplen, cstop;
-  longlong		cp;
+  uint64_t		toplen, cstop;
+  int64_t		cp;
   int			cid, ret = 0;
   jmp_buf		jb;
   volatile unsigned	retries = 0;
@@ -2346,7 +2346,7 @@ static int  readMoreBlocks(MatroskaFile *mf) {
 
       cp = mf->cache->scan(mf->cache,filepos(mf),0x1f43b675); // cluster
 
-      if (cp < 0 || (ulonglong)cp >= mf->pSegmentTop)
+      if (cp < 0 || (uint64_t)cp >= mf->pSegmentTop)
 	goto ex;
 
       seek(mf,cp);
@@ -2476,10 +2476,10 @@ static int  fillQueues(MatroskaFile *mf,unsigned int mask) {
 
 static void reindex(MatroskaFile *mf) {
   jmp_buf     jb;
-  ulonglong   pos = mf->pCluster;
-  ulonglong   step = 10*1024*1024;
-  ulonglong   size, tc, isize;
-  longlong    next_cluster;
+  uint64_t   pos = mf->pCluster;
+  uint64_t   step = 10*1024*1024;
+  uint64_t   size, tc, isize;
+  int64_t    next_cluster;
   int	      id, have_tc, bad;
   struct Cue  *cue;
 
@@ -2510,7 +2510,7 @@ static void reindex(MatroskaFile *mf) {
 
     // find next cluster header
     next_cluster = mf->cache->scan(mf->cache,pos,0x1f43b675); // cluster
-    if (next_cluster < 0 || (ulonglong)next_cluster >= mf->pSegmentTop)
+    if (next_cluster < 0 || (uint64_t)next_cluster >= mf->pSegmentTop)
       break;
 
     pos = next_cluster + 4; // prevent endless loops
@@ -2533,7 +2533,7 @@ static void reindex(MatroskaFile *mf) {
     have_tc = 0;
     size += filepos(mf);
 
-    while (filepos(mf) < (ulonglong)next_cluster + 1024) {
+    while (filepos(mf) < (uint64_t)next_cluster + 1024) {
       id = readID(mf);
       if (id == EOF)
 	break;
@@ -2591,7 +2591,7 @@ static void reindex(MatroskaFile *mf) {
   memcpy(&mf->jb,&jb,sizeof(jb));
 }
 
-static void fixupChapter(ulonglong adj, struct Chapter *ch) {
+static void fixupChapter(uint64_t adj, struct Chapter *ch) {
   unsigned i;
 
   if (ch->Start != 0)
@@ -2603,8 +2603,8 @@ static void fixupChapter(ulonglong adj, struct Chapter *ch) {
     fixupChapter(adj,&ch->Children[i]);
 }
 
-static longlong	findLastTimecode(MatroskaFile *mf) {
-  ulonglong   nd = 0;
+static int64_t	findLastTimecode(MatroskaFile *mf) {
+  uint64_t   nd = 0;
   unsigned    n,vtrack;
 
   if (mf->nTracks == 0)
@@ -2633,7 +2633,7 @@ ok:
   do
     while (mf->Queues[vtrack].head)
     {
-      ulonglong   tc = mf->Queues[vtrack].head->flags & FRAME_UNKNOWN_END ?
+      uint64_t   tc = mf->Queues[vtrack].head->flags & FRAME_UNKNOWN_END ?
 			  mf->Queues[vtrack].head->Start : mf->Queues[vtrack].head->End;
       if (nd < tc)
 	nd = tc;
@@ -2656,7 +2656,7 @@ ok:
 }
 
 static void parseFile(MatroskaFile *mf) {
-  ulonglong len = filepos(mf), adjust;
+  uint64_t len = filepos(mf), adjust;
   unsigned  i;
   int	    id = readID(mf);
   int	    m;
@@ -2694,7 +2694,7 @@ segment:
   if (len == MAXU64) {
     mf->pSegmentTop = MAXU64;
     if (mf->cache->getfilesize) {
-      longlong seglen = mf->cache->getfilesize(mf->cache);
+      int64_t seglen = mf->cache->getfilesize(mf->cache);
       if (seglen > 0)
 	mf->pSegmentTop = seglen;
     }
@@ -2726,7 +2726,7 @@ segment:
 
   // try to detect real duration
   if (!(mf->flags & MKVF_AVOID_SEEKS)) {
-    longlong nd = findLastTimecode(mf);
+    int64_t nd = findLastTimecode(mf);
     if (nd > 0)
       mf->Seg.Duration = nd;
   }
@@ -2760,7 +2760,7 @@ static void DeleteChapter(MatroskaFile *mf,struct Chapter *ch) {
 ///////////////////////////////////////////////////////////////////////////
 // public interface
 MatroskaFile  *mkv_OpenEx(InputStream *io,
-			  ulonglong base,
+			  uint64_t base,
 			  unsigned flags,
 			  char *err_msg,unsigned msgsize)
 {
@@ -2877,16 +2877,16 @@ void	      mkv_GetTags(MatroskaFile *mf,Tag **tag,unsigned *count) {
   *count = mf->nTags;
 }
 
-ulonglong     mkv_GetSegmentTop(MatroskaFile *mf) {
+uint64_t     mkv_GetSegmentTop(MatroskaFile *mf) {
   return mf->pSegmentTop;
 }
 
 #define	IS_DELTA(f) (!((f)->flags & FRAME_KF) || ((f)->flags & FRAME_UNKNOWN_START))
 
-void  mkv_Seek(MatroskaFile *mf,ulonglong timecode,unsigned flags) {
+void  mkv_Seek(MatroskaFile *mf,uint64_t timecode,unsigned flags) {
   int		i,j,m,ret;
   unsigned	n,z,mask;
-  ulonglong	m_kftime[MAX_TRACKS];
+  uint64_t	m_kftime[MAX_TRACKS];
   unsigned char	m_seendf[MAX_TRACKS];
 
   if (mf->flags & MKVF_AVOID_SEEKS)
@@ -3031,7 +3031,7 @@ again:;
 
 void  mkv_SkipToKeyframe(MatroskaFile *mf) {
   unsigned  n,wait;
-  ulonglong ht;
+  uint64_t ht;
 
   if (setjmp(mf->jb)!=0)
     return;
@@ -3074,16 +3074,16 @@ void  mkv_SkipToKeyframe(MatroskaFile *mf) {
   } while (wait);
 }
 
-ulonglong mkv_GetLowestQTimecode(MatroskaFile *mf) {
+uint64_t mkv_GetLowestQTimecode(MatroskaFile *mf) {
   unsigned  n,seen;
-  ulonglong t;
+  uint64_t t;
 
   // find the lowest queued timecode
   for (n=seen=0,t=0;n<mf->nTracks;++n)
     if (mf->Queues[n].head && (!seen || t > mf->Queues[n].head->Start))
       t = mf->Queues[n].head->Start, seen=1;
 
-  return seen ? t : (ulonglong)LL(-1);
+  return seen ? t : (uint64_t)LL(-1);
 }
 
 int	      mkv_TruncFloat(MKFLOAT f) {
@@ -3111,8 +3111,8 @@ void	      mkv_SetTrackMask(MatroskaFile *mf,unsigned int mask) {
 
 int	      mkv_ReadFrame(MatroskaFile *mf,
 			    unsigned int mask,unsigned int *track,
-			    ulonglong *StartTime,ulonglong *EndTime,
-			    ulonglong *FilePos,unsigned int *FrameSize,
+			    uint64_t *StartTime,uint64_t *EndTime,
+			    uint64_t *FilePos,unsigned int *FrameSize,
 			    unsigned int *FrameFlags)
 {
   unsigned int	    i,j;
@@ -3167,7 +3167,7 @@ struct CompressedStream {
   z_stream	  zs;
 
   /* current compressed frame */
-  ulonglong	  frame_pos;
+  uint64_t	  frame_pos;
   unsigned	  frame_size;
   char		  frame_buffer[2048];
 
@@ -3237,7 +3237,7 @@ void		  cs_Destroy(/* in */ CompressedStream *cs) {
 /* advance to the next frame in matroska stream, you need to pass values returned
  * by mkv_ReadFrame */
 void		  cs_NextFrame(/* in */ CompressedStream *cs,
-			       /* in */ ulonglong pos,
+			       /* in */ uint64_t pos,
 			       /* in */ unsigned size)
 {
   cs->zs.avail_in = 0;
diff --git a/src/MatroskaParser.h b/src/MatroskaParser.h
index 3b0d90592..4d3d66347 100644
--- a/src/MatroskaParser.h
+++ b/src/MatroskaParser.h
@@ -27,6 +27,8 @@
  *
  */
 
+#include <stdint.h>
+
 #ifndef MATROSKA_PARSER_H
 #define	MATROSKA_PARSER_H
 
@@ -57,19 +59,10 @@
 extern "C" {
 #endif
 
-/* 64-bit integers */
-#ifdef _WIN32_WCE
-typedef signed __int64	    longlong;
-typedef unsigned __int64    ulonglong;
-#else
-typedef signed long long    longlong;
-typedef unsigned long long  ulonglong;
-#endif
-
 /* MKFLOATing point */
 #ifdef MATROSKA_INTEGER_ONLY
 typedef struct {
-  longlong	v;
+  int64_t	v;
 } MKFLOAT;
 #else
 typedef	double	MKFLOAT;
@@ -78,9 +71,9 @@ typedef	double	MKFLOAT;
 /* generic I/O */
 struct InputStream {
   /* read bytes from stream */
-  int	      (*read)(struct InputStream *cc,ulonglong pos,void *buffer,int count);
+  int	      (*read)(struct InputStream *cc,uint64_t pos,void *buffer,int count);
   /* scan for a four byte signature, bytes must be nonzero */
-  longlong    (*scan)(struct InputStream *cc,ulonglong start,unsigned signature);
+  int64_t    (*scan)(struct InputStream *cc,uint64_t start,unsigned signature);
   /* get cache size, this is used to cap readahead */
   unsigned    (*getcachesize)(struct InputStream *cc);
   /* fetch last error message */
@@ -90,9 +83,9 @@ struct InputStream {
   void	      *(*memrealloc)(struct InputStream *cc,void *mem,size_t newsize);
   void	      (*memfree)(struct InputStream *cc,void *mem);
   /* zero return causes parser to abort open */
-  int	      (*progress)(struct InputStream *cc,ulonglong cur,ulonglong max);
+  int	      (*progress)(struct InputStream *cc,uint64_t cur,uint64_t max);
   /* get file size, optional, can be NULL or return -1 if filesize is unknown */
-  longlong    (*getfilesize)(struct InputStream *cc);
+  int64_t    (*getfilesize)(struct InputStream *cc);
 };
 
 typedef struct InputStream InputStream;
@@ -115,10 +108,10 @@ struct TrackInfo {
   unsigned char	  Number;
   unsigned char	  Type;
   unsigned char	  TrackOverlay;
-  ulonglong	  UID;
-  ulonglong	  MinCache;
-  ulonglong	  MaxCache;
-  ulonglong	  DefaultDuration;
+  uint64_t	  UID;
+  uint64_t	  MinCache;
+  uint64_t	  MaxCache;
+  uint64_t	  DefaultDuration;
   MKFLOAT	  TimecodeScale;
   void		  *CodecPrivate;
   unsigned	  CodecPrivateSize;
@@ -174,18 +167,18 @@ struct SegmentInfo {
   char			*Title;
   char			*MuxingApp;
   char			*WritingApp;
-  ulonglong		TimecodeScale;
-  ulonglong		Duration;
-  longlong		DateUTC;
+  uint64_t		TimecodeScale;
+  uint64_t		Duration;
+  int64_t		DateUTC;
   char			DateUTCValid;
 };
 
 typedef struct SegmentInfo SegmentInfo;
 
 struct Attachment {
-  ulonglong		Position;
-  ulonglong		Length;
-  ulonglong		UID;
+  uint64_t		Position;
+  uint64_t		Length;
+  uint64_t		UID;
   char			*Name;
   char			*Description;
   char			*MimeType;
@@ -214,12 +207,12 @@ struct ChapterProcess {
 };
 
 struct Chapter {
-  ulonglong		UID;
-  ulonglong		Start;
-  ulonglong		End;
+  uint64_t		UID;
+  uint64_t		Start;
+  uint64_t		End;
 
   unsigned		nTracks,nTracksSize;
-  ulonglong		*Tracks;
+  uint64_t		*Tracks;
   unsigned		nDisplay,nDisplaySize;
   struct ChapterDisplay	*Display;
   unsigned		nChildren,nChildrenSize;
@@ -244,7 +237,7 @@ typedef struct Chapter	Chapter;
 #define	TARGET_ATTACHMENT 2
 #define	TARGET_EDITION	  3
 struct Target {
-  ulonglong	    UID;
+  uint64_t	    UID;
   unsigned	    Type;
 };
 
@@ -275,7 +268,7 @@ X MatroskaFile  *mkv_Open(/* in */ InputStream *io,
 #define	MKVF_AVOID_SEEKS    1 /* use sequential reading only */
 
 X MatroskaFile  *mkv_OpenEx(/* in */  InputStream *io,
-			  /* in */  ulonglong base,
+			  /* in */  uint64_t base,
 			  /* in */  unsigned flags,
 			  /* out */ char *err_msg,
 			  /* in */  unsigned msgsize);
@@ -306,7 +299,7 @@ X void	      mkv_GetTags(/* in */  MatroskaFile *mf,
 			  /* out */ Tag **tag,
 			  /* out */ unsigned *count);
 
-X ulonglong   mkv_GetSegmentTop(MatroskaFile *mf);
+X uint64_t   mkv_GetSegmentTop(MatroskaFile *mf);
 
 /* Seek to specified timecode,
  * if timecode is past end of file,
@@ -317,12 +310,12 @@ X ulonglong   mkv_GetSegmentTop(MatroskaFile *mf);
 #define	MKVF_SEEK_TO_PREV_KEYFRAME_STRICT   2
 
 X void	      mkv_Seek(/* in */ MatroskaFile *mf,
-		       /* in */	ulonglong timecode /* in ns */,
+		       /* in */	uint64_t timecode /* in ns */,
 		       /* in */ unsigned flags);
 
 X void	      mkv_SkipToKeyframe(MatroskaFile *mf);
 
-X ulonglong   mkv_GetLowestQTimecode(MatroskaFile *mf);
+X uint64_t   mkv_GetLowestQTimecode(MatroskaFile *mf);
 
 X int	      mkv_TruncFloat(MKFLOAT f);
 
@@ -353,9 +346,9 @@ X void	      mkv_SetTrackMask(/* in */ MatroskaFile *mf,/* in */ unsigned int ma
 X int	      mkv_ReadFrame(/* in */  MatroskaFile *mf,
 			    /* in */  unsigned int mask,
 			    /* out */ unsigned int *track,
-			    /* out */ ulonglong *StartTime /* in ns */,
-			    /* out */ ulonglong *EndTime /* in ns */,
-			    /* out */ ulonglong *FilePos /* in bytes from start of file */,
+			    /* out */ uint64_t *StartTime /* in ns */,
+			    /* out */ uint64_t *EndTime /* in ns */,
+			    /* out */ uint64_t *FilePos /* in bytes from start of file */,
 			    /* out */ unsigned int *FrameSize /* in bytes */,
 			    /* out */ unsigned int *FrameFlags);
 
@@ -374,7 +367,7 @@ X void		  cs_Destroy(/* in */ CompressedStream *cs);
 /* advance to the next frame in matroska stream, you need to pass values returned
  * by mkv_ReadFrame */
 X void		  cs_NextFrame(/* in */ CompressedStream *cs,
-			       /* in */ ulonglong pos,
+			       /* in */ uint64_t pos,
 			       /* in */ unsigned size);
 
 /* read and decode more data from current frame, return number of bytes decoded,
diff --git a/src/mkv_wrap.cpp b/src/mkv_wrap.cpp
index 7819a55a2..05b1051a6 100644
--- a/src/mkv_wrap.cpp
+++ b/src/mkv_wrap.cpp
@@ -62,7 +62,7 @@ struct MkvStdIO final : InputStream {
 	agi::read_file_mapping file;
 	std::string error;
 
-	static int Read(InputStream *st, ulonglong pos, void *buffer, int count) {
+	static int Read(InputStream *st, uint64_t pos, void *buffer, int count) {
 		auto *self = static_cast<MkvStdIO*>(st);
 		if (pos == self->file.size())
 			return 0;
@@ -78,7 +78,7 @@ struct MkvStdIO final : InputStream {
 		return count;
 	}
 
-	static longlong Scan(InputStream *st, ulonglong start, unsigned signature) {
+	static int64_t Scan(InputStream *st, uint64_t start, unsigned signature) {
 		auto *self = static_cast<MkvStdIO*>(st);
 		try {
 			unsigned cmp = 0;
@@ -96,7 +96,7 @@ struct MkvStdIO final : InputStream {
 		return -1;
 	}
 
-	static longlong Size(InputStream *st) {
+	static int64_t Size(InputStream *st) {
 		return static_cast<MkvStdIO*>(st)->file.size();
 	}
 
@@ -108,7 +108,7 @@ struct MkvStdIO final : InputStream {
 		memalloc = [](InputStream *, size_t size) { return malloc(size); };
 		memrealloc = [](InputStream *, void *mem, size_t size) { return realloc(mem, size); };
 		memfree = [](InputStream *, void *mem) { free(mem); };
-		progress = [](InputStream *, ulonglong, ulonglong) { return 1; };
+		progress = [](InputStream *, uint64_t, uint64_t) { return 1; };
 		getfilesize = &MkvStdIO::Size;
 	}
 };
@@ -117,7 +117,7 @@ static void read_subtitles(agi::ProgressSink *ps, MatroskaFile *file, MkvStdIO *
 	std::vector<std::pair<int, std::string>> subList;
 
 	// Load blocks
-	ulonglong startTime, endTime, filePos;
+	uint64_t startTime, endTime, filePos;
 	unsigned int rt, frameSize, frameFlags;
 
 	while (mkv_ReadFrame(file, 0, &rt, &startTime, &endTime, &filePos, &frameSize, &frameFlags) == 0) {
@@ -128,7 +128,7 @@ static void read_subtitles(agi::ProgressSink *ps, MatroskaFile *file, MkvStdIO *
 		const auto readBufEnd = readBuf + frameSize;
 
 		// Get start and end times
-		longlong timecodeScaleLow = 1000000;
+		int64_t timecodeScaleLow = 1000000;
 		AssTime subStart = startTime / timecodeScaleLow;
 		AssTime subEnd = endTime / timecodeScaleLow;
 
@@ -243,7 +243,7 @@ void MatroskaWrapper::GetSubtitles(agi::fs::path const& filename, AssFile *targe
 
 	// Read timecode scale
 	auto segInfo = mkv_GetFileInfo(file);
-	longlong timecodeScale = mkv_TruncFloat(trackInfo->TimecodeScale) * segInfo->TimecodeScale;
+	int64_t timecodeScale = mkv_TruncFloat(trackInfo->TimecodeScale) * segInfo->TimecodeScale;
 
 	// Progress bar
 	auto totalTime = double(segInfo->Duration) / timecodeScale;