Re-implement previous {Read,Write}Frame API

1 files changed, 107 insertions, 73 deletions

diff --git a/src/AS_02_IAB.cpp b/src/AS_02_IAB.cpp
index c228a39..536efbd 100644
--- a/src/AS_02_IAB.cpp
+++ b/src/AS_02_IAB.cpp
@@ -213,14 +213,14 @@ AS_02::IAB::MXFWriter::OpenWrite(
 }
 
 Result_t
-AS_02::IAB::MXFWriter::WriteFrame(const ASDCP::FrameBuffer& frame) {
+AS_02::IAB::MXFWriter::WriteFrame(const ui8_t* frame, ui32_t sz) {
   /* are we running */
 
   if (this->m_State == ST_BEGIN) {
     return Kumu::RESULT_INIT;
   }
 
-  if (frame.Size() == 0) {
+  if (sz == 0) {
     DefaultLogSink().Error("The frame buffer size is zero.\n");
     return RESULT_PARAM;
   }
@@ -236,7 +236,7 @@ AS_02::IAB::MXFWriter::WriteFrame(const ASDCP::FrameBuffer& frame) {
 
   /* write the frame */
 
-  result = this->m_Writer->m_File.Write(frame.RoData(), frame.Size());
+  result = this->m_Writer->m_File.Write(frame, sz);
 
   if (result.Failure()) {
     this->Reset();
@@ -249,7 +249,7 @@ AS_02::IAB::MXFWriter::WriteFrame(const ASDCP::FrameBuffer& frame) {
 
   /* increment stream offset */
 
-  this->m_Writer->m_StreamOffset += frame.Size();
+  this->m_Writer->m_StreamOffset += sz;
 
   /* we are running now */
 
@@ -258,6 +258,10 @@ AS_02::IAB::MXFWriter::WriteFrame(const ASDCP::FrameBuffer& frame) {
   return result;
 }
 
+Result_t AS_02::IAB::MXFWriter::WriteFrame(const ASDCP::FrameBuffer& frame) {
+  return WriteFrame(frame.RoData(), frame.Size());
+}
+
 Result_t
 AS_02::IAB::MXFWriter::AddDmsGenericPartUtf8Text(const ASDCP::FrameBuffer& FrameBuf, ASDCP::AESEncContext* Ctx,
                           ASDCP::HMACContext* HMAC, const std::string& trackDescription, const std::string& dataDescription)
@@ -431,8 +435,6 @@ AS_02::IAB::MXFReader::OpenRead(const std::string& filename) {
 
     /* invalidate current frame */
 
-    this->m_CurrentFrameIndex = -1;
-
     /* we are ready */
 
     this->m_State = ST_READER_READY;
@@ -476,120 +478,152 @@ Result_t AS_02::IAB::MXFReader::GetFrameCount(ui32_t& frameCount) const {
   return Kumu::RESULT_OK;
 }
 
-Result_t
-AS_02::IAB::MXFReader::ReadFrame(ui32_t frame_number, ASDCP::FrameBuffer& frame) {
+/* Anonymous namespace with ReadFrame helpers */
+namespace {
+  bool checkFrameCapacity(ASDCP::FrameBuffer& frame, size_t size, bool reallocate_if_needed) {
 
-  /* are we already running */
-
-  if (this->m_State == ST_READER_BEGIN) {
-    return Kumu::RESULT_INIT;
+    if (frame.Capacity() < size) {
+      if (!reallocate_if_needed) {
+        return false;
+      }
+      Result_t result = frame.Capacity(size);
+      return result == RESULT_OK;
+    }
+    return true;
   }
 
-  Result_t result = RESULT_OK;
-
-  // look up frame index node
-  IndexTableSegment::IndexEntry index_entry;
+  Result_t
+  ReadFrameImpl(ui32_t frame_number, ASDCP::FrameBuffer& frame, ReaderState_t& reader_state, ASDCP::mem_ptr<AS_02::h__AS02Reader>& reader, bool reallocate_if_needed) {
 
-  result = this->m_Reader->m_IndexAccess.Lookup(frame_number, index_entry);
+    /* are we already running */
 
-  if (result.Failure()) {
-    DefaultLogSink().Error("Frame value out of range: %u\n", frame_number);
-    return result;
-  }
-
-  result = this->m_Reader->m_File->Seek(index_entry.StreamOffset);
-
-  if (result.Failure()) {
-    DefaultLogSink().Error("Cannot seek to stream offset: %u\n", index_entry.StreamOffset);
-    return result;
-  }
+    if (reader_state == ST_READER_BEGIN) {
+      return Kumu::RESULT_INIT;
+    }
 
-  /* read the preamble info */
+    Result_t result = RESULT_OK;
 
-  const int preambleTLLen = 5;
-  const int frameTLLen = 5;
+    // look up frame index node
+    IndexTableSegment::IndexEntry index_entry;
 
-  ui32_t buffer_offset = 0;
+    result = reader->m_IndexAccess.Lookup(frame_number, index_entry);
 
-  if (frame.Capacity() < preambleTLLen) {
-      return RESULT_SMALLBUF;
-  }
+    if (result.Failure()) {
+      DefaultLogSink().Error("Frame value out of range: %u\n", frame_number);
+      return result;
+    }
 
-  result = this->m_Reader->m_File->Read(&frame.Data()[buffer_offset], preambleTLLen);
+    result = reader->m_File->Seek(index_entry.StreamOffset);
 
-  if (result.Failure()) {
-    DefaultLogSink().Error("Error reading IA Frame preamble\n", index_entry.StreamOffset);
-    return result;
-  }
-
-  ui32_t preambleLen = ((ui32_t)frame.Data()[1 + buffer_offset] << 24) +
-    ((ui32_t)frame.Data()[2 + buffer_offset] << 16) +
-    ((ui32_t)frame.Data()[3 + buffer_offset] << 8) +
-    (ui32_t)frame.Data()[4 + buffer_offset];
+    if (result.Failure()) {
+      DefaultLogSink().Error("Cannot seek to stream offset: %u\n", index_entry.StreamOffset);
+      return result;
+    }
 
-  buffer_offset += preambleTLLen;
+    /* read the preamble info */
 
-  /* read the preamble*/
+    const int preambleTLLen = 5;
+    const int frameTLLen = 5;
 
-  if (preambleLen > 0) {
+    ui32_t buffer_offset = 0;
 
-    if (frame.Capacity() < preambleTLLen + preambleLen) {
-      return RESULT_SMALLBUF;
+    if (!checkFrameCapacity(frame, preambleTLLen, reallocate_if_needed)) {
+        return RESULT_SMALLBUF;
     }
 
-    result = this->m_Reader->m_File->Read(&frame.Data()[buffer_offset], preambleLen);
+    result = reader->m_File->Read(&frame.Data()[buffer_offset], preambleTLLen);
 
     if (result.Failure()) {
       DefaultLogSink().Error("Error reading IA Frame preamble\n", index_entry.StreamOffset);
       return result;
     }
 
-    buffer_offset += preambleLen;
+    ui32_t preambleLen = ((ui32_t)frame.Data()[1 + buffer_offset] << 24) +
+      ((ui32_t)frame.Data()[2 + buffer_offset] << 16) +
+      ((ui32_t)frame.Data()[3 + buffer_offset] << 8) +
+      (ui32_t)frame.Data()[4 + buffer_offset];
 
-  }
+    buffer_offset += preambleTLLen;
 
-  /* read the IA Frame info */
+    /* read the preamble*/
 
-  if (frame.Capacity() < preambleTLLen + preambleLen + frameTLLen) {
-    return RESULT_SMALLBUF;
-  }
+    if (preambleLen > 0) {
 
-  result = this->m_Reader->m_File->Read(&frame.Data()[buffer_offset], frameTLLen);
+      if (!checkFrameCapacity(frame, preambleTLLen + preambleLen, reallocate_if_needed)) {
+        return RESULT_SMALLBUF;
+      }
 
-  if (result.Failure()) {
-    DefaultLogSink().Error("Error reading IA Frame data\n", index_entry.StreamOffset);
-    return result;
-  }
+      result = reader->m_File->Read(&frame.Data()[buffer_offset], preambleLen);
 
-  ui32_t frameLen = ((ui32_t)frame.Data()[buffer_offset + 1] << 24) +
-    ((ui32_t)frame.Data()[buffer_offset + 2] << 16) +
-    ((ui32_t)frame.Data()[buffer_offset + 3] << 8) +
-    (ui32_t)frame.Data()[buffer_offset + 4];
+      if (result.Failure()) {
+        DefaultLogSink().Error("Error reading IA Frame preamble\n", index_entry.StreamOffset);
+        return result;
+      }
 
-  buffer_offset += frameTLLen;
+      buffer_offset += preambleLen;
 
-  /* read the IA Frame */
+    }
 
-  if (frameLen > 0) {
+    /* read the IA Frame info */
 
-    if (frame.Capacity() < preambleTLLen + preambleLen + frameTLLen + frameLen) {
+    if (!checkFrameCapacity(frame,  preambleTLLen + preambleLen + frameTLLen, reallocate_if_needed)) {
       return RESULT_SMALLBUF;
     }
-    frame.Size(preambleTLLen + preambleLen + frameTLLen + frameLen);
 
-    result = this->m_Reader->m_File->Read(&frame.Data()[buffer_offset], frameLen);
+    result = reader->m_File->Read(&frame.Data()[buffer_offset], frameTLLen);
 
     if (result.Failure()) {
       DefaultLogSink().Error("Error reading IA Frame data\n", index_entry.StreamOffset);
       return result;
     }
+
+    ui32_t frameLen = ((ui32_t)frame.Data()[buffer_offset + 1] << 24) +
+      ((ui32_t)frame.Data()[buffer_offset + 2] << 16) +
+      ((ui32_t)frame.Data()[buffer_offset + 3] << 8) +
+      (ui32_t)frame.Data()[buffer_offset + 4];
+
+    buffer_offset += frameTLLen;
+
+    /* read the IA Frame */
+
+    if (frameLen > 0) {
+
+      if (!checkFrameCapacity(frame, preambleTLLen + preambleLen + frameTLLen + frameLen, reallocate_if_needed)) {
+        return RESULT_SMALLBUF;
+      }
+      frame.Size(preambleTLLen + preambleLen + frameTLLen + frameLen);
+
+      result = reader->m_File->Read(&frame.Data()[buffer_offset], frameLen);
+
+      if (result.Failure()) {
+        DefaultLogSink().Error("Error reading IA Frame data\n", index_entry.StreamOffset);
+        return result;
+      }
+    }
+
+    reader_state = ST_READER_RUNNING;
+
+    return result;
   }
+} // namespace
 
-  this->m_State = ST_READER_RUNNING;
+Result_t AS_02::IAB::MXFReader::ReadFrame(ui32_t frame_number,
+                                          AS_02::IAB::MXFReader::Frame &frame) {
 
+  Result_t result = ReadFrameImpl(frame_number, this->m_FrameBuffer,
+                                  this->m_State, this->m_Reader, true);
+
+  frame = std::pair<size_t, const ui8_t *>(this->m_FrameBuffer.Size(),
+                                           this->m_FrameBuffer.Data());
   return result;
 }
 
+Result_t AS_02::IAB::MXFReader::ReadFrame(ui32_t frame_number,
+                                          ASDCP::FrameBuffer &frame) {
+  return ReadFrameImpl(frame_number, frame, this->m_State, this->m_Reader,
+                       false);
+}
+
 Result_t
 AS_02::IAB::MXFReader::ReadGenericStreamPartitionPayload(const ui32_t SID, ASDCP::FrameBuffer& frame_buf)
 {