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

diff --git a/src/AS_DCP_JP2K.cpp b/src/AS_DCP_JP2K.cpp
index bd0bc33a307b08044763d93f3eed8a7f3cf653a6..39dceedd72b4e681f93bdfe39f8108911e0dc62d 100755 (executable)
--- 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 48d1c2d0caef40e2b819700cdeb08a45740f2cb7..bd2709e3344eae1f6a6c6d78e4cf57fd255baf22 100755 (executable)
--- 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 1db626c68a4384b38bea3ed6bb0e52ed158aead9..faf42f1fea9b5e5866d5c902dd398071a679d0cb 100755 (executable)
--- 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 158679dd5f0e0ed0e39cd183069f820a262be83a..73341a5fc3a309afc35b1d4343c001f40d35cb4b 100644 (file)
--- 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 cd9358353221b82763ff2bcd35d74e22bd73f26a..1d4e7911d9c40788192473268d9bc7801d3711bb 100755 (executable)
--- 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 21aae248852f184717a757215c96a92d367bbffd..29a1c81639db14d3a600a98ed88db586203f4093 100755 (executable)
--- 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 d1e82e100f082838cb52fb35d0982d99cad49366..0f8976a159a8ad9cb58a40034b3903d75af5572b 100755 (executable)
--- 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 8b5592e008c1d16a5c48a3ad3764ab1c74765d13..f7e6dce94afc489a3731b3f32fc081939343afb4 100755 (executable)
--- 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 f2756abd62ca336c28b186f78cb5d549354db58a..bf99e3e522271ebc4bc9dd4538fcfe92a98fe586 100755 (executable)
--- 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 2cfd73fd3b4035648198e83cca10cfd75bfea1fd..9fb2423884978ca60ed28c9d342b4484fef3d594 100755 (executable)
--- 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 8d844f30490cca2d2c100ecba87d95b04c9d138a..d329e603bc474bed6023f9a4da15c4060b39fe4c 100755 (executable)
--- 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;