Commit a bunch of portability fixes (64- vs. 32-bit types).

11 files changed, 38 insertions, 18 deletions

diff --git a/src/AS_DCP_JP2K.cpp b/src/AS_DCP_JP2K.cpp
index bd0bc33..39dceed 100755
--- a/src/AS_DCP_JP2K.cpp
+++ b/src/AS_DCP_JP2K.cpp
@@ -160,7 +160,8 @@ lh__Reader::MD_to_JP2K_PDesc(JP2K::PictureDescriptor& PDesc)
   MXF::RGBAEssenceDescriptor* PDescObj = (MXF::RGBAEssenceDescriptor*)m_EssenceDescriptor;
 
   PDesc.EditRate           = m_EditRate;
-  PDesc.ContainerDuration  = PDescObj->ContainerDuration;
+  assert(PDescObj->ContainerDuration <= 0xFFFFFFFFL);
+  PDesc.ContainerDuration  = (ui32_t) PDescObj->ContainerDuration;
   PDesc.StoredWidth        = PDescObj->StoredWidth;
   PDesc.StoredHeight       = PDescObj->StoredHeight;
   PDesc.AspectRatio        = PDescObj->AspectRatio;
diff --git a/src/AS_DCP_MPEG2.cpp b/src/AS_DCP_MPEG2.cpp
index 48d1c2d..bd2709e 100755
--- a/src/AS_DCP_MPEG2.cpp
+++ b/src/AS_DCP_MPEG2.cpp
@@ -46,7 +46,8 @@ MD_to_MPEG2_VDesc(MXF::MPEG2VideoDescriptor* VDescObj, MPEG2::VideoDescriptor& V
   VDesc.SampleRate             = VDescObj->SampleRate;
   VDesc.EditRate               = VDescObj->SampleRate;
   VDesc.FrameRate              = VDescObj->SampleRate.Numerator;
-  VDesc.ContainerDuration      = VDescObj->ContainerDuration;
+  assert(VDescObj->ContainerDuration <= 0xFFFFFFFFL);
+  VDesc.ContainerDuration      = (ui32_t) VDescObj->ContainerDuration;
 
   VDesc.FrameLayout            = VDescObj->FrameLayout;
   VDesc.StoredWidth            = VDescObj->StoredWidth;
@@ -492,7 +493,7 @@ ASDCP::MPEG2::MXFWriter::h__Writer::WriteFrame(const FrameBuffer& FrameBuf, AESE
 
   // update the index manager
   Entry.TemporalOffset = - FrameBuf.TemporalOffset();
-  Entry.KeyFrameOffset = - m_GOPOffset;
+  Entry.KeyFrameOffset = 0 - m_GOPOffset;
   Entry.Flags = Flags;
   /*
   fprintf(stderr, "to: %4hd   ko: %4hd   c1: %4hd   c2: %4hd   fl: 0x%02x\n",
diff --git a/src/AS_DCP_PCM.cpp b/src/AS_DCP_PCM.cpp
index 1db626c..faf42f1 100755
--- a/src/AS_DCP_PCM.cpp
+++ b/src/AS_DCP_PCM.cpp
@@ -67,6 +67,7 @@ MD_to_PCM_ADesc(MXF::WaveAudioDescriptor* ADescObj, PCM::AudioDescriptor& ADesc)
   ADesc.BlockAlign = ADescObj->BlockAlign;
   ADesc.AvgBps = ADescObj->AvgBps;
   ADesc.LinkedTrackID = ADescObj->LinkedTrackID;
+  assert(ADescObj->ContainerDuration <= 0xFFFFFFFFL);
   ADesc.ContainerDuration = ADescObj->ContainerDuration;
   return RESULT_OK;
 }
diff --git a/src/AS_DCP_TimedText.cpp b/src/AS_DCP_TimedText.cpp
index 158679d..73341a5 100644
--- a/src/AS_DCP_TimedText.cpp
+++ b/src/AS_DCP_TimedText.cpp
@@ -127,7 +127,8 @@ ASDCP::TimedText::MXFReader::h__Reader::MD_to_TimedText_TDesc(TimedText::TimedTe
   MXF::TimedTextDescriptor* TDescObj = (MXF::TimedTextDescriptor*)m_EssenceDescriptor;
 
   TDesc.EditRate = TDescObj->SampleRate;
-  TDesc.ContainerDuration = TDescObj->ContainerDuration;
+  assert(TDescObj->ContainerDuration <= 0xFFFFFFFFL);
+  TDesc.ContainerDuration = (ui32_t) TDescObj->ContainerDuration;
   memcpy(TDesc.AssetID, TDescObj->ResourceID.Value(), UUIDlen);
   TDesc.NamespaceName = TDescObj->NamespaceURI;
   TDesc.EncodingName = TDescObj->UCSEncoding;
diff --git a/src/JP2K_Sequence_Parser.cpp b/src/JP2K_Sequence_Parser.cpp
index cd93583..1d4e791 100755
--- a/src/JP2K_Sequence_Parser.cpp
+++ b/src/JP2K_Sequence_Parser.cpp
@@ -144,7 +144,10 @@ ASDCP::JP2K::SequenceParser::h__SequenceParser::OpenRead(const char* filename)
 	result = RESULT_NOT_FOUND;
 
       if ( ASDCP_SUCCESS(result) )
-	result = TmpBuffer.Capacity(file_size);
+	{
+	  assert(file_size <= 0xFFFFFFFFL);
+	  result = TmpBuffer.Capacity((ui32_t) file_size);
+	}
 
       if ( ASDCP_SUCCESS(result) )
 	result = Parser.OpenReadFrame((*m_CurrentFile).c_str(), TmpBuffer);
diff --git a/src/KLV.cpp b/src/KLV.cpp
index 21aae24..29a1c81 100755
--- a/src/KLV.cpp
+++ b/src/KLV.cpp
@@ -88,7 +88,8 @@ ASDCP::KLVPacket::InitFromBuffer(const byte_t* buf, ui32_t buf_len)
   if ( ! Kumu::read_BER(buf + SMPTE_UL_LENGTH, &tmp_size) )
        return RESULT_FAIL;
 
-  m_ValueLength = tmp_size;
+  assert (tmp_size <= 0xFFFFFFFFL);
+  m_ValueLength = (ui32_t) tmp_size;
   m_KLLength = SMPTE_UL_LENGTH + Kumu::BER_length(buf + SMPTE_UL_LENGTH);
   m_KeyStart = buf;
   m_ValueStart = buf + m_KLLength;
@@ -208,7 +209,8 @@ ASDCP::KLVFilePacket::InitFromFile(const Kumu::FileReader& Reader)
   ui32_t remainder = 0;
   ui32_t ber_len = Kumu::BER_length(tmp_data + SMPTE_UL_LENGTH);
   m_KLLength = SMPTE_UL_LENGTH + ber_len;
-  m_ValueLength = tmp_size;
+  assert(tmp_size <= 0xFFFFFFFFL);
+  m_ValueLength = (ui32_t) tmp_size;
   ui32_t packet_length = m_ValueLength + m_KLLength;
 
   result = m_Buffer.Capacity(packet_length);
diff --git a/src/KM_util.cpp b/src/KM_util.cpp
index d1e82e1..0f8976a 100755
--- a/src/KM_util.cpp
+++ b/src/KM_util.cpp
@@ -931,7 +931,7 @@ Kumu::Timestamp::DecodeString(const char* datestr)
 	    return false;
 
 	  else 
-	    AddHours( (datestr[19] == '-' ? (-TZ_hh) : TZ_hh));
+	    AddHours( (datestr[19] == '-' ? (0 - TZ_hh) : TZ_hh));
 	}
     }
 
diff --git a/src/MPEG2_Parser.cpp b/src/MPEG2_Parser.cpp
index 8b5592e..f7e6dce 100755
--- a/src/MPEG2_Parser.cpp
+++ b/src/MPEG2_Parser.cpp
@@ -435,7 +435,8 @@ ASDCP::MPEG2::Parser::h__Parser::OpenRead(const char* filename)
 
   if ( ASDCP_SUCCESS(result) )
     {
-      m_ParamsDelegate.m_VDesc.ContainerDuration = m_FileReader.Size() / 65536; // a gross approximation
+      ui64_t tmp = m_FileReader.Size() / 65536; // a gross approximation
+      m_ParamsDelegate.m_VDesc.ContainerDuration = (ui32_t) tmp;
       m_Parser.SetDelegate(&m_ParserDelegate);
       m_FileReader.Seek(0);
     }
diff --git a/src/MXF.cpp b/src/MXF.cpp
index f2756ab..bf99e3e 100755
--- a/src/MXF.cpp
+++ b/src/MXF.cpp
@@ -711,7 +711,8 @@ ASDCP::MXF::OPAtomHeader::InitFromFile(const Kumu::FileReader& Reader)
   if ( HeaderByteCount < 1024 )
     DefaultLogSink().Warn("Improbably small HeaderByteCount value: %u\n", HeaderByteCount);
 
-  result = m_Buffer.Capacity(HeaderByteCount);
+  assert (HeaderByteCount <= 0xFFFFFFFFL);
+  result = m_Buffer.Capacity((ui32_t) HeaderByteCount);
 
   if ( ASDCP_SUCCESS(result) )
     {
@@ -841,7 +842,8 @@ ASDCP::MXF::OPAtomHeader::WriteToFile(Kumu::FileWriter& Writer, ui32_t HeaderSiz
 
   ASDCP::FrameBuffer HeaderBuffer;
   HeaderByteCount = HeaderSize - ArchiveSize();
-  Result_t result = HeaderBuffer.Capacity(HeaderByteCount); 
+  assert (HeaderByteCount <= 0xFFFFFFFFL);
+  Result_t result = HeaderBuffer.Capacity((ui32_t) HeaderByteCount); 
   m_Preface->m_Lookup = &m_Primer;
 
   std::list<InterchangeObject*>::iterator pl_i = m_PacketList->m_List.begin();
@@ -955,7 +957,10 @@ ASDCP::MXF::OPAtomIndexFooter::InitFromFile(const Kumu::FileReader& Reader)
   ui32_t read_count;
 
   if ( ASDCP_SUCCESS(result) )
-    result = m_Buffer.Capacity(IndexByteCount);
+    {
+      assert (IndexByteCount <= 0xFFFFFFFFL);
+      result = m_Buffer.Capacity((ui32_t) IndexByteCount);
+    }
 
   if ( ASDCP_SUCCESS(result) )
     result = Reader.Read(m_Buffer.Data(), m_Buffer.Capacity(), &read_count);
@@ -1096,7 +1101,9 @@ ASDCP::MXF::OPAtomIndexFooter::Lookup(ui32_t frame_num, IndexTableSegment::Index
 	  else if ( (ui64_t)frame_num >= start_pos
 		    && (ui64_t)frame_num < (start_pos + Segment->IndexDuration) )
 	    {
-	      Entry = Segment->IndexEntryArray[frame_num-start_pos];
+	      ui64_t tmp = frame_num - start_pos;
+	      assert(tmp <= 0xFFFFFFFFL);
+	      Entry = Segment->IndexEntryArray[(ui32_t) tmp];
 	      return RESULT_OK;
 	    }
 	}
diff --git a/src/Wav.cpp b/src/Wav.cpp
index 2cfd73f..9fb2423 100755
--- a/src/Wav.cpp
+++ b/src/Wav.cpp
@@ -265,7 +265,7 @@ ASDCP::AIFF::SimpleAIFFHeader::FillADesc(ASDCP::PCM::AudioDescriptor& ADesc, ASD
   ADesc.AudioSamplingRate = extended_to_Rat(sampleRate);
   ADesc.QuantizationBits = sampleSize;
   ADesc.BlockAlign = sampleSize / 8;
-  ADesc.AvgBps = ADesc.BlockAlign * ADesc.AudioSamplingRate.Quotient();
+  ADesc.AvgBps = (ui32_t) (ADesc.BlockAlign * ADesc.AudioSamplingRate.Quotient());
   ui32_t FrameBufferSize = ASDCP::PCM::CalcFrameBufferSize(ADesc);
   ADesc.ContainerDuration = data_len / FrameBufferSize;
 }
diff --git a/src/h__Reader.cpp b/src/h__Reader.cpp
index 8d844f3..d329e60 100755
--- a/src/h__Reader.cpp
+++ b/src/h__Reader.cpp
@@ -224,9 +224,11 @@ ASDCP::h__Reader::ReadEKLVPacket(ui32_t FrameNum, ui32_t SequenceNum, ASDCP::Fra
 	}
 
       // read encrypted triplet value into internal buffer
-      m_CtFrameBuf.Capacity(PacketLength);
+      assert(PacketLength <= 0xFFFFFFFFL);
+      m_CtFrameBuf.Capacity((ui32_t) PacketLength);
       ui32_t read_count;
-      result = m_File.Read(m_CtFrameBuf.Data(), PacketLength, &read_count);
+      result = m_File.Read(m_CtFrameBuf.Data(), (ui32_t) PacketLength,
+			   &read_count);
 
       if ( ASDCP_FAILURE(result) )
 	return result;
@@ -237,7 +239,7 @@ ASDCP::h__Reader::ReadEKLVPacket(ui32_t FrameNum, ui32_t SequenceNum, ASDCP::Fra
           return RESULT_FORMAT;
         }
 
-      m_CtFrameBuf.Size(PacketLength);
+      m_CtFrameBuf.Size((ui32_t) PacketLength);
 
       // should be const but mxflib::ReadBER is not
       byte_t* ess_p = m_CtFrameBuf.Data();
@@ -357,7 +359,8 @@ ASDCP::h__Reader::ReadEKLVPacket(ui32_t FrameNum, ui32_t SequenceNum, ASDCP::Fra
 
       // read the data into the supplied buffer
       ui32_t read_count;
-      result = m_File.Read(FrameBuf.Data(), PacketLength, &read_count);
+      assert(PacketLength <= 0xFFFFFFFFL);
+      result = m_File.Read(FrameBuf.Data(), (ui32_t) PacketLength, &read_count);
 	  
       if ( ASDCP_FAILURE(result) )
 	return result;