+ 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
+ {
+ p += chunk_size;
+ }
+ }
+
+ if ( *data_start == 0 ) // can't have no data!
+ {
+ DefaultLogSink().Error("No data chunk found, file contains no essence\n");
+ return RESULT_RAW_FORMAT;
+ }
+
+ return RESULT_OK;
+}
+
+//------------------------------------------------------------------------------------------
+// conversion algorithms from http://www.borg.com/~jglatt/tech/aiff.htm
+
+//
+void
+Rat_to_extended(ASDCP::Rational rate, byte_t* buf)
+{
+ memset(buf, 0, 10);
+ ui32_t value = (ui32_t)ceil(rate.Quotient());
+ ui32_t exp = value;
+ exp >>= 1;
+ ui8_t i = 0;
+
+ for ( ; i < 32; i++ )
+ {
+ exp >>= 1;
+ if ( ! exp )
+ break;
+ }
+
+ *(buf+1) = i;
+
+ for ( i = 32; i != 0 ; i-- )
+ {
+ if ( value & 0x80000000 )
+ break;
+ value <<= 1;
+ }
+
+ *(ui32_t*)(buf+2) = KM_i32_BE(value);
+}
+
+//
+ASDCP::Rational
+extended_to_Rat(const byte_t* buf)
+{
+ ui32_t last = 0;
+ ui32_t mantissa = KM_i32_BE(*(ui32_t*)(buf+2));
+
+ byte_t exp = 30 - *(buf+1);
+
+ while ( exp-- )
+ {
+ last = mantissa;
+ mantissa >>= 1;
+ }
+
+ if ( last & 0x00000001 )
+ mantissa++;
+
+ return ASDCP::Rational(mantissa, 1);
+}
+
+//
+void
+ASDCP::AIFF::SimpleAIFFHeader::FillADesc(ASDCP::PCM::AudioDescriptor& ADesc, ASDCP::Rational PictureRate) const
+{
+ ADesc.EditRate = PictureRate;
+
+ ADesc.ChannelCount = numChannels;
+ ADesc.AudioSamplingRate = extended_to_Rat(sampleRate);
+ ADesc.QuantizationBits = sampleSize;
+ ADesc.BlockAlign = sampleSize / 8;
+ 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 Kumu::FileReader& InFile, ui32_t* data_start)
+{
+ ui32_t read_count = 0;
+ ui32_t local_data_start = 0;
+ ASDCP::PCM::FrameBuffer TmpBuffer(Wav::MaxWavHeader);
+
+ if ( data_start == 0 )
+ data_start = &local_data_start;
+
+ Result_t result = InFile.Read(TmpBuffer.Data(), TmpBuffer.Capacity(), &read_count);
+
+ if ( ASDCP_SUCCESS(result) )
+ result = ReadFromBuffer(TmpBuffer.RoData(), read_count, data_start);
+
+ return result;
+}
+
+//
+ASDCP::Result_t
+ASDCP::AIFF::SimpleAIFFHeader::ReadFromBuffer(const byte_t* buf, ui32_t buf_len, ui32_t* data_start)
+{
+ if ( buf_len < 32 )
+ return RESULT_SMALLBUF;
+
+ *data_start = 0;
+ const byte_t* p = buf;
+ const byte_t* end_p = p + buf_len;
+
+ fourcc test_FORM(p); p += 4;
+ if ( test_FORM != FCC_FORM )
+ {
+ // DefaultLogSink().Debug("File does not begin with FORM header\n");
+ return RESULT_RAW_FORMAT;
+ }
+
+ ui32_t RIFF_len = KM_i32_BE(*(ui32_t*)p); p += 4;
+
+ fourcc test_AIFF(p); p += 4;
+ if ( test_AIFF != FCC_AIFF )
+ {
+ DefaultLogSink().Debug("File does not contain an AIFF header\n");
+ return RESULT_RAW_FORMAT;
+ }
+
+ fourcc test_fcc;
+
+ while ( p < end_p )
+ {
+ test_fcc = fourcc(p); p += 4;
+ ui32_t chunk_size = KM_i32_BE(*(ui32_t*)p); p += 4;
+
+ if ( test_fcc == FCC_COMM )
+ {
+ 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;
+ }
+ else if ( test_fcc == FCC_SSND )
+ {
+ if ( 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 = KM_i32_BE(*(ui32_t*)p); p += 4;
+ p += 4; // blockSize;
+
+ data_len = chunk_size - 8;
+ *data_start = (p - buf) + offset;
+ break;