projects / asdcplib.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
*** empty log message ***
[asdcplib.git] / src / Wav.cpp
diff --git a/src/Wav.cpp b/src/Wav.cpp
index ce64a78c634ab4985242d2f0f9f37af14a58a850..27a57d83207e77812b95e7da636c6c42aa72f70e 100755 (executable)
--- a/src/Wav.cpp
+++ b/src/Wav.cpp
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2005-2006, John Hurst
+Copyright (c) 2005-2009, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -30,8 +30,9 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "Wav.h"
-#include "hex_utils.h"
 #include <assert.h>
+#include <KM_log.h>
+using Kumu::DefaultLogSink;
 
 
 const ui32_t SimpleWavHeaderLength = 46;
@@ -43,8 +44,8 @@ ASDCP::Wav::SimpleWaveHeader::SimpleWaveHeader(ASDCP::PCM::AudioDescriptor& ADes
   nchannels = ADesc.ChannelCount;
   bitspersample = ADesc.QuantizationBits;
   samplespersec = (ui32_t)ceil(ADesc.AudioSamplingRate.Quotient());
-  avgbps = samplespersec * nchannels * ((bitspersample + 7) / 8);
-  blockalign = nchannels * ((bitspersample + 7) / 8);
+  blockalign = nchannels * (bitspersample / 8);
+  avgbps = samplespersec * blockalign;
   cbsize = 0;    
   data_len = ASDCP::PCM::CalcFrameBufferSize(ADesc) * ADesc.ContainerDuration;
 }
@@ -64,12 +65,13 @@ ASDCP::Wav::SimpleWaveHeader::FillADesc(ASDCP::PCM::AudioDescriptor& ADesc, ASDC
   ADesc.QuantizationBits = bitspersample;
   ui32_t FrameBufferSize = ASDCP::PCM::CalcFrameBufferSize(ADesc);
   ADesc.ContainerDuration = data_len / FrameBufferSize;
+  ADesc.ChannelFormat = PCM::CF_NONE;
 }
 
 
 //
 ASDCP::Result_t
-ASDCP::Wav::SimpleWaveHeader::WriteToFile(ASDCP::FileWriter& OutFile) const
+ASDCP::Wav::SimpleWaveHeader::WriteToFile(Kumu::FileWriter& OutFile) const
 {
   ui32_t write_count;
   byte_t tmp_header[SimpleWavHeaderLength];
@@ -87,26 +89,26 @@ ASDCP::Wav::SimpleWaveHeader::WriteToFile(ASDCP::FileWriter& OutFile) const
   ui32_t RIFF_len = data_len + SimpleWavHeaderLength - 8;
 
   memcpy(p, &FCC_RIFF, sizeof(fourcc)); p += 4;
-  *((ui32_t*)p) = ASDCP_i32_LE(RIFF_len); p += 4;
+  *((ui32_t*)p) = KM_i32_LE(RIFF_len); p += 4;
   memcpy(p, &FCC_WAVE, sizeof(fourcc)); p += 4;
   memcpy(p, &FCC_fmt_, sizeof(fourcc)); p += 4;
-  *((ui32_t*)p) = ASDCP_i32_LE(fmt_len); p += 4;
-  *((ui16_t*)p) = ASDCP_i16_LE(format); p += 2;
-  *((ui16_t*)p) = ASDCP_i16_LE(nchannels); p += 2;
-  *((ui32_t*)p) = ASDCP_i32_LE(samplespersec); p += 4;
-  *((ui32_t*)p) = ASDCP_i32_LE(avgbps); p += 4;
-  *((ui16_t*)p) = ASDCP_i16_LE(blockalign); p += 2;
-  *((ui16_t*)p) = ASDCP_i16_LE(bitspersample); p += 2;
-  *((ui16_t*)p) = ASDCP_i16_LE(cbsize); p += 2;
+  *((ui32_t*)p) = KM_i32_LE(fmt_len); p += 4;
+  *((ui16_t*)p) = KM_i16_LE(format); p += 2;
+  *((ui16_t*)p) = KM_i16_LE(nchannels); p += 2;
+  *((ui32_t*)p) = KM_i32_LE(samplespersec); p += 4;
+  *((ui32_t*)p) = KM_i32_LE(avgbps); p += 4;
+  *((ui16_t*)p) = KM_i16_LE(blockalign); p += 2;
+  *((ui16_t*)p) = KM_i16_LE(bitspersample); p += 2;
+  *((ui16_t*)p) = KM_i16_LE(cbsize); p += 2;
   memcpy(p, &FCC_data, sizeof(fourcc)); p += 4;
-  *((ui32_t*)p) = ASDCP_i32_LE(data_len); p += 4;
+  *((ui32_t*)p) = KM_i32_LE(data_len); p += 4;
 
   return OutFile.Write(tmp_header, SimpleWavHeaderLength, &write_count);
 }
 
 //
 ASDCP::Result_t
-ASDCP::Wav::SimpleWaveHeader::ReadFromFile(const ASDCP::FileReader& InFile, ui32_t* data_start)
+ASDCP::Wav::SimpleWaveHeader::ReadFromFile(const Kumu::FileReader& InFile, ui32_t* data_start)
 {
   ui32_t read_count = 0;
   ui32_t local_data_start = 0;
@@ -136,16 +138,16 @@ ASDCP::Wav::SimpleWaveHeader::ReadFromBuffer(const byte_t* buf, ui32_t buf_len,
   fourcc test_RIFF(p); p += 4;
   if ( test_RIFF != FCC_RIFF )
     {
-      DefaultLogSink().Error("File does not begin with RIFF header\n");      
+      //      DefaultLogSink().Debug("File does not begin with RIFF header\n");      
       return RESULT_RAW_FORMAT;
     }
 
-  ui32_t RIFF_len = ASDCP_i32_LE(*(ui32_t*)p); p += 4;
+  ui32_t RIFF_len = KM_i32_LE(*(ui32_t*)p); p += 4;
 
   fourcc test_WAVE(p); p += 4;
   if ( test_WAVE != FCC_WAVE )
     {
-      DefaultLogSink().Error("File does not contain a WAVE header\n");
+      DefaultLogSink().Debug("File does not contain a WAVE header\n");
       return RESULT_RAW_FORMAT;
     }
 
@@ -154,13 +156,13 @@ ASDCP::Wav::SimpleWaveHeader::ReadFromBuffer(const byte_t* buf, ui32_t buf_len,
   while ( p < end_p )
     {
       test_fcc = fourcc(p); p += 4;
-      ui32_t chunk_size = ASDCP_i32_LE(*(ui32_t*)p); p += 4;
+      ui32_t chunk_size = KM_i32_LE(*(ui32_t*)p); p += 4;
 
       if ( test_fcc == FCC_data )
        {
          if ( chunk_size > RIFF_len )
            {
-             DefaultLogSink().Error("Chunk size %lu larger than file: %lu\n", chunk_size, RIFF_len);
+             DefaultLogSink().Error("Chunk size %u larger than file: %u\n", chunk_size, RIFF_len);
              return RESULT_RAW_FORMAT;
            }
 
@@ -171,20 +173,20 @@ ASDCP::Wav::SimpleWaveHeader::ReadFromBuffer(const byte_t* buf, ui32_t buf_len,
 
       if ( test_fcc == FCC_fmt_ )
        {
-         ui16_t format = ASDCP_i16_LE(*(ui16_t*)p); p += 2;
+         ui16_t format = KM_i16_LE(*(ui16_t*)p); p += 2;
 
-         if ( format != 1 )
+         if ( format != WAVE_FORMAT_PCM && format != WAVE_FORMAT_EXTENSIBLE )
            {
-             DefaultLogSink().Error("Expecting uncompressed essence, got format type %hu\n", format);
+             DefaultLogSink().Error("Expecting uncompressed PCM data, got format type %hd\n", format);
              return RESULT_RAW_FORMAT;
            }
 
-         nchannels = ASDCP_i16_LE(*(ui16_t*)p); p += 2;
-         samplespersec = ASDCP_i32_LE(*(ui32_t*)p); p += 4;
-         avgbps = ASDCP_i32_LE(*(ui32_t*)p); p += 4;
-         blockalign = ASDCP_i16_LE(*(ui16_t*)p); p += 2;
-         bitspersample = ASDCP_i16_LE(*(ui16_t*)p); p += 2;
-         p += chunk_size - 16;
+         nchannels = KM_i16_LE(*(ui16_t*)p); p += 2;
+         samplespersec = KM_i32_LE(*(ui32_t*)p); p += 4;
+         avgbps = KM_i32_LE(*(ui32_t*)p); p += 4;
+         blockalign = KM_i16_LE(*(ui16_t*)p); p += 2;
+         bitspersample = KM_i16_LE(*(ui16_t*)p); p += 2;
+         p += chunk_size - 16; // 16 is the number of bytes read in this block
        }
       else
        {
@@ -230,7 +232,7 @@ Rat_to_extended(ASDCP::Rational rate, byte_t* buf)
        value <<= 1;
      }
 
-   *(ui32_t*)(buf+2) = ASDCP_i32_BE(value);
+   *(ui32_t*)(buf+2) = KM_i32_BE(value);
 }
 
 //
@@ -238,7 +240,7 @@ ASDCP::Rational
 extended_to_Rat(const byte_t* buf)
 {
   ui32_t last = 0;
-  ui32_t mantissa = ASDCP_i32_BE(*(ui32_t*)(buf+2));
+  ui32_t mantissa = KM_i32_BE(*(ui32_t*)(buf+2));
 
   byte_t exp = 30 - *(buf+1);
 
@@ -264,14 +266,15 @@ 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 * (ui32_t)ceil(ADesc.AudioSamplingRate.Quotient());
+  ADesc.AvgBps = (ui32_t) (ADesc.BlockAlign * ADesc.AudioSamplingRate.Quotient());
   ui32_t FrameBufferSize = ASDCP::PCM::CalcFrameBufferSize(ADesc);
   ADesc.ContainerDuration = data_len / FrameBufferSize;
+  ADesc.ChannelFormat = PCM::CF_NONE;
 }
 
 //
 ASDCP::Result_t
-ASDCP::AIFF::SimpleAIFFHeader::ReadFromFile(const ASDCP::FileReader& InFile, ui32_t* data_start)
+ASDCP::AIFF::SimpleAIFFHeader::ReadFromFile(const Kumu::FileReader& InFile, ui32_t* data_start)
 {
   ui32_t read_count = 0;
   ui32_t local_data_start = 0;
@@ -302,16 +305,16 @@ ASDCP::AIFF::SimpleAIFFHeader::ReadFromBuffer(const byte_t* buf, ui32_t buf_len,
   fourcc test_FORM(p); p += 4;
   if ( test_FORM != FCC_FORM )
     {
-      DefaultLogSink().Error("File does not begin with FORM header\n");
+      //      DefaultLogSink().Debug("File does not begin with FORM header\n");
       return RESULT_RAW_FORMAT;
     }
 
-  ui32_t RIFF_len = ASDCP_i32_BE(*(ui32_t*)p); p += 4;
+  ui32_t RIFF_len = KM_i32_BE(*(ui32_t*)p); p += 4;
 
   fourcc test_AIFF(p); p += 4;
   if ( test_AIFF != FCC_AIFF )
     {
-      DefaultLogSink().Error("File does not contain an AIFF header\n");
+      DefaultLogSink().Debug("File does not contain an AIFF header\n");
       return RESULT_RAW_FORMAT;
     }
 
@@ -320,13 +323,13 @@ ASDCP::AIFF::SimpleAIFFHeader::ReadFromBuffer(const byte_t* buf, ui32_t buf_len,
   while ( p < end_p )
     {
       test_fcc = fourcc(p); p += 4;
-      ui32_t chunk_size = ASDCP_i32_BE(*(ui32_t*)p); p += 4;
+      ui32_t chunk_size = KM_i32_BE(*(ui32_t*)p); p += 4;
 
       if ( test_fcc == FCC_COMM )
        {
-         numChannels = ASDCP_i16_BE(*(ui16_t*)p); p += 2;
-         numSampleFrames = ASDCP_i32_BE(*(ui32_t*)p); p += 4;
-         sampleSize = ASDCP_i16_BE(*(ui16_t*)p); p += 2;
+         numChannels = KM_i16_BE(*(ui16_t*)p); p += 2;
+         numSampleFrames = KM_i32_BE(*(ui32_t*)p); p += 4;
+         sampleSize = KM_i16_BE(*(ui16_t*)p); p += 2;
          memcpy(sampleRate, p, 10);
          p += 10;
        }
@@ -334,16 +337,15 @@ ASDCP::AIFF::SimpleAIFFHeader::ReadFromBuffer(const byte_t* buf, ui32_t buf_len,
        {
          if ( chunk_size > RIFF_len )
             {
-              DefaultLogSink().Error("Chunk size %lu larger than file: %lu\n", chunk_size, RIFF_len);
+              DefaultLogSink().Error("Chunk size %u larger than file: %u\n", chunk_size, RIFF_len);
               return RESULT_RAW_FORMAT;
             }
 
-         ui32_t offset = ASDCP_i32_BE(*(ui32_t*)p); p += 4;
+         ui32_t offset = KM_i32_BE(*(ui32_t*)p); p += 4;
          p += 4; // blockSize;
 
          data_len = chunk_size - 8;
          *data_start = (p - buf) + offset;
-         fprintf(stderr, "*data_start: %p\n", *data_start);
          break;
        }
       else
Unnamed repository; edit this file 'description' to name the repository.