*/
/*! \file AS_02_PCM.cpp
- \version $Id: AS_02_PCM.cpp,v 1.16 2015/10/07 16:41:23 jhurst Exp $
+ \version $Id: AS_02_PCM.cpp,v 1.16 2015/10/07 16:41:23 jhurst Exp $
\brief AS-02 library, PCM essence reader and writer implementation
*/
{
DefaultLogSink().Error("Essence wrapper key is not WAVEssenceClip: %s\n", entry->name);
}
-
+
return RESULT_AS02_FORMAT;
}
//
ASDCP::Result_t
AS_02::PCM::MXFReader::h__Reader::ReadFrame(ui32_t FrameNum, ASDCP::PCM::FrameBuffer& FrameBuf,
- ASDCP::AESDecContext* Ctx, ASDCP::HMACContext* HMAC)
+ ASDCP::AESDecContext*, ASDCP::HMACContext*)
{
if ( ! m_File.IsOpen() )
{
ASDCP::MXF::WaveAudioDescriptor *m_WaveAudioDescriptor;
byte_t m_EssenceUL[SMPTE_UL_LENGTH];
ui32_t m_BytesPerSample;
-
+
h__Writer(const Dictionary& d) : AS_02::h__AS02WriterClip(d), m_WaveAudioDescriptor(0), m_BytesPerSample(0)
{
memset(m_EssenceUL, 0, SMPTE_UL_LENGTH);
//
// end AS_02_PCM.cpp
//
-
//
ASDCP::Result_t
ASDCP::JP2K_PDesc_to_MD(const JP2K::PictureDescriptor& PDesc,
- const ASDCP::Dictionary& dict,
+ const ASDCP::Dictionary&,
ASDCP::MXF::GenericPictureEssenceDescriptor& EssenceDescriptor,
ASDCP::MXF::JPEG2000PictureSubDescriptor& EssenceSubDescriptor)
{
//
Kumu::Result_t
-Kumu::ReadFileIntoObject(const std::string& Filename, Kumu::IArchive& Object, ui32_t max_size)
+Kumu::ReadFileIntoObject(const std::string& Filename, Kumu::IArchive& Object, ui32_t)
{
ByteString Buffer;
ui32_t file_size = static_cast<ui32_t>(FileSize(Filename));
//
Result_t
-Kumu::ReadFileIntoBuffer(const std::string& Filename, Kumu::ByteString& Buffer, ui32_t max_size)
+Kumu::ReadFileIntoBuffer(const std::string& Filename, Kumu::ByteString& Buffer, ui32_t)
{
ui32_t file_size = FileSize(Filename);
Result_t result = Buffer.Capacity(file_size);
//
bool
-Kumu::XMLElement::ParseString(const char* document, ui32_t doc_len)
+Kumu::XMLElement::ParseString(const char*, ui32_t)
{
DefaultLogSink().Error("Kumu compiled without XML parser support.\n");
return false;
}
bool
-Kumu::XMLElement::ParseFirstFromString(const char* document, ui32_t doc_len)
+Kumu::XMLElement::ParseFirstFromString(const char*, ui32_t)
{
DefaultLogSink().Error("Kumu compiled without XML parser support.\n");
return false;
~StreamParams() {}
//
- Result_t Sequence(VESParser*, const byte_t* b, ui32_t s)
+ Result_t Sequence(VESParser*, const byte_t* b, ui32_t)
{
Result_t result = m_State.Goto_SEQ();
}
//
- Result_t Extension(VESParser*, const byte_t* b, ui32_t s)
+ Result_t Extension(VESParser*, const byte_t* b, ui32_t)
{
Result_t result = m_State.Goto_EXT();
m_State.Reset();
}
- Result_t Sequence(VESParser*, const byte_t* b, ui32_t s)
+ Result_t Sequence(VESParser*, const byte_t*, ui32_t s)
{
if ( m_State.Test_SLICE() )
{
return m_State.Test_SLICE() ? RESULT_OK : RESULT_FAIL;
}
- Result_t Extension(VESParser*, const byte_t* b, ui32_t s)
+ Result_t Extension(VESParser*, const byte_t*, ui32_t s)
{
m_FrameSize += s;
return m_State.Goto_EXT();
return m_State.Goto_GOP();
}
- Result_t Data(VESParser*, const byte_t* b, i32_t s)
+ Result_t Data(VESParser*, const byte_t*, i32_t s)
{
m_FrameSize += s;
return RESULT_OK;
return result;
}
- void Dump(FILE* stream = 0, ui32_t depth = 0) {
+ void Dump(FILE* stream = 0, ui32_t = 0) {
char identbuf[IdentBufferLen];
if ( stream == 0 )
}
//
- void Dump(FILE* stream = 0, ui32_t depth = 0)
+ void Dump(FILE* stream = 0, ui32_t = 0)
{
char identbuf[IdentBufferLen];
}
//
- void get_PictureEssenceCoding(FILE* stream = 0)
+ void get_PictureEssenceCoding(FILE* = 0)
{
const Dictionary& Dict = DefaultCompositeDict();
MXF::RGBAEssenceDescriptor *descriptor = 0;
//
void
- calc_Bitrate(FILE* stream = 0)
+ calc_Bitrate(FILE* = 0)
{
MXF::OPAtomIndexFooter& footer = m_Reader.OPAtomIndexFooter();
ui64_t total_frame_bytes = 0, last_stream_offset = 0;
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+*/
/*! \file h__02_Writer.cpp
\version $Id: h__02_Writer.cpp,v 1.14 2015/10/09 23:41:11 jhurst Exp $
\brief MXF file writer base class
assert(m_Dict);
ASDCP::FrameBuffer index_body_buffer;
ui32_t index_body_size = m_PacketList->m_List.size() * MaxIndexSegmentSize; // segment-count * max-segment-size
- Result_t result = index_body_buffer.Capacity(index_body_size);
+ Result_t result = index_body_buffer.Capacity(index_body_size);
ui64_t start_position = 0;
if ( m_CurrentSegment != 0 )
m_StreamOffset, FrameBuf, EssenceUL, Ctx, HMAC);
if ( KM_SUCCESS(result) )
- {
+ {
IndexTableSegment::IndexEntry Entry;
Entry.StreamOffset = this_stream_offset;
m_IndexWriter.PushIndexEntry(Entry);
assert(m_Dict);
ASDCP::FrameBuffer index_body_buffer;
ui32_t index_body_size = MaxIndexSegmentSize; // segment-count * max-segment-size
- Result_t result = index_body_buffer.Capacity(index_body_size);
+ Result_t result = index_body_buffer.Capacity(index_body_size);
m_CurrentSegment = new IndexTableSegment(m_Dict);
assert(m_CurrentSegment);
//
Result_t
-AS_02::h__AS02WriterClip::StartClip(const byte_t* EssenceUL, AESEncContext* Ctx, HMACContext* HMAC)
+AS_02::h__AS02WriterClip::StartClip(const byte_t* EssenceUL, AESEncContext* Ctx, HMACContext*)
{
if ( Ctx != 0 )
{
result = m_File.Seek(current_position);
m_ClipStart = 0;
}
-
+
return result;
}
// standard method of writing a plaintext or encrypted frame
Result_t
-ASDCP::Write_EKLV_Packet(Kumu::FileWriter& File, const ASDCP::Dictionary& Dict, const MXF::OP1aHeader& HeaderPart,
+ASDCP::Write_EKLV_Packet(Kumu::FileWriter& File, const ASDCP::Dictionary& Dict, const MXF::OP1aHeader&,
const ASDCP::WriterInfo& Info, ASDCP::FrameBuffer& CtFrameBuf, ui32_t& FramesWritten,
ui64_t & StreamOffset, const ASDCP::FrameBuffer& FrameBuf, const byte_t* EssenceUL,
AESEncContext* Ctx, HMACContext* HMAC)