Use sys::basename instead of PBD::basename_nosuffix in Session::import_audiofile
[ardour.git] / libs / ardour / coreaudiosource.cc
index f0fcac14e2fa312d61ece028c32dc9d19724b8f3..703225e502eaa953eee5c5d40a9afe9f828c1796 100644 (file)
 
 #include <pbd/error.h>
 #include <ardour/coreaudiosource.h>
+#include <ardour/utils.h>
+
+#include <appleutility/CAAudioFile.h>
+#include <appleutility/CAStreamBasicDescription.h>
 
 #include "i18n.h"
 
 using namespace ARDOUR;
 using namespace PBD;
 
-CoreAudioSource::CoreAudioSource (const XMLNode& node)
-       : AudioFileSource (node)
+CoreAudioSource::CoreAudioSource (Session& s, const XMLNode& node)
+       : AudioFileSource (s, node)
 {
-       init (_name);
-       
-       AudioSourceCreated (this); /* EMIT SIGNAL */
+       init ();
 }
 
-CoreAudioSource::CoreAudioSource (const string& idstr, Flag flags)
-       : AudioFileSource(idstr, flags)
+CoreAudioSource::CoreAudioSource (Session& s, const string& path, int chn, Flag flags)
+       /* files created this way are never writable or removable */
+       : AudioFileSource (s, path, Flag (flags & ~(Writable|Removable|RemovableIfEmpty|RemoveAtDestroy)))
 {
-       init (idstr);
-
-       AudioSourceCreated (this); /* EMIT SIGNAL */
+       _channel = chn;
+       init ();
 }
 
 void 
-CoreAudioSource::init (const string& idstr)
+CoreAudioSource::init ()
 {
-       string::size_type pos;
-       string file;
-
        tmpbuf = 0;
        tmpbufsize = 0;
-       af = 0;
-       OSStatus err = noErr;
-
-       _name = idstr;
-
-       if ((pos = idstr.find_last_of (':')) == string::npos) {
-               channel = 0;
-               file = idstr;
-       } else {
-               channel = atoi (idstr.substr (pos+1).c_str());
-               file = idstr.substr (0, pos);
-       }
-
-       /* note that we temporarily truncated _id at the colon */
-       FSRef fsr;
-       err = FSPathMakeRef ((UInt8*)file.c_str(), &fsr, 0);
-       if (err != noErr) {
-               error << string_compose (_("Could not make reference to file: %1"), name()) << endmsg;
-               throw failed_constructor();
-       }
-
-       err = ExtAudioFileOpen (&fsr, &af);
-       if (err != noErr) {
-               error << string_compose (_("Could not open file: %1"), name()) << endmsg;
-               ExtAudioFileDispose (af);
-               throw failed_constructor();
-       }
 
-       AudioStreamBasicDescription file_asbd;
-       memset(&file_asbd, 0, sizeof(AudioStreamBasicDescription));
-       size_t asbd_size = sizeof(AudioStreamBasicDescription);
-       err = ExtAudioFileGetProperty(af,
-                       kExtAudioFileProperty_FileDataFormat, &asbd_size, &file_asbd);
-       if (err != noErr) {
-               error << string_compose (_("Could not get file data format for file: %1"), name()) << endmsg;
-               ExtAudioFileDispose (af);
-               throw failed_constructor();
-       }
-       n_channels = file_asbd.mChannelsPerFrame;
-
-       cerr << "number of channels: " << n_channels << endl;
+       cerr << "CoreAudioSource::init() " << name() << endl;
        
-       if (channel >= n_channels) {
-               error << string_compose(_("CoreAudioSource: file only contains %1 channels; %2 is invalid as a channel number"), n_channels, channel) << endmsg;
-               ExtAudioFileDispose (af);
-               throw failed_constructor();
-       }
+       /* note that we temporarily truncated _id at the colon */
+       try {
+               af.Open(_path.c_str());
 
-       int64_t ca_frames;
-       size_t prop_size = sizeof(int64_t);
+               CAStreamBasicDescription file_asbd (af.GetFileDataFormat());
+               n_channels = file_asbd.NumberChannels();
+               cerr << "number of channels: " << n_channels << endl;
+               
+               if (_channel >= n_channels) {
+                       error << string_compose("CoreAudioSource: file only contains %1 channels; %2 is invalid as a channel number (%3)", n_channels, _channel, name()) << endmsg;
+                       throw failed_constructor();
+               }
 
-       err = ExtAudioFileGetProperty(af, kExtAudioFileProperty_FileLengthFrames, &prop_size, &ca_frames);
-       if (err != noErr) {
-               error << string_compose (_("Could not get file length for file: %1"), name()) << endmsg;
-               ExtAudioFileDispose (af);
-               throw failed_constructor();
-       }
+               _length = af.GetNumberFrames();
 
-       _length = ca_frames;
-       _path = file;
-
-       AudioStreamBasicDescription client_asbd;
-       memset(&client_asbd, 0, sizeof(AudioStreamBasicDescription));
-       client_asbd.mSampleRate = file_asbd.mSampleRate;
-       client_asbd.mFormatID = kAudioFormatLinearPCM;
-       client_asbd.mFormatFlags = kLinearPCMFormatFlagIsFloat;
-       client_asbd.mBytesPerPacket = file_asbd.mChannelsPerFrame * 4;
-       client_asbd.mFramesPerPacket = 1;
-       client_asbd.mBytesPerFrame = client_asbd.mBytesPerPacket;
-       client_asbd.mChannelsPerFrame = file_asbd.mChannelsPerFrame;
-       client_asbd.mBitsPerChannel = 32;
-
-       err = ExtAudioFileSetProperty (af, kExtAudioFileProperty_ClientDataFormat, asbd_size, &client_asbd);
-       if (err != noErr) {
-               error << string_compose (_("Could not set client data format for file: %1"), name()) << endmsg;
-               ExtAudioFileDispose (af);
+               CAStreamBasicDescription client_asbd(file_asbd);
+               client_asbd.SetCanonical(client_asbd.NumberChannels(), false);
+               af.SetClientFormat (client_asbd);
+       } catch (CAXException& cax) {
+               error << string_compose ("CoreAudioSource: %1 (%2)", cax.mOperation, name()) << endmsg;
                throw failed_constructor ();
        }
-       
-       if (_build_peakfiles) {
-               if (initialize_peakfile (false, file)) {
-                       error << string_compose(_("initialize peakfile failed for file %1"), name()) << endmsg;
-                       ExtAudioFileDispose (af);
-                       throw failed_constructor ();
-               }
-       }
 }
 
 CoreAudioSource::~CoreAudioSource ()
 {
-       GoingAway (this); /* EMIT SIGNAL */
-
-       if (af) {
-               ExtAudioFileDispose (af);
-       }
+       cerr << "CoreAudioSource::~CoreAudioSource() " << name() << endl;
+       GoingAway (); /* EMIT SIGNAL */
 
        if (tmpbuf) {
                delete [] tmpbuf;
        }
+       
+       cerr << "deletion done" << endl;
 }
 
-jack_nframes_t
-CoreAudioSource::read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt) const
+nframes_t
+CoreAudioSource::read_unlocked (Sample *dst, nframes_t start, nframes_t cnt) const
 {
-       OSStatus err = noErr;
-
-       err = ExtAudioFileSeek(af, start);
-       if (err != noErr) {
-               error << string_compose(_("CoreAudioSource: could not seek to frame %1 within %2 (%3)"), start, _name.substr (1), err) << endmsg;
+       try {
+               af.Seek (start);
+       } catch (CAXException& cax) {
+               error << string_compose("CoreAudioSource: %1 to %2 (%3)", cax.mOperation, start, _name.substr (1)) << endmsg;
                return 0;
        }
 
        AudioBufferList abl;
        abl.mNumberBuffers = 1;
        abl.mBuffers[0].mNumberChannels = n_channels;
-       abl.mBuffers[0].mDataByteSize = cnt * sizeof(Sample);
-       abl.mBuffers[0].mData = dst;
 
+       UInt32 new_cnt = cnt;
        if (n_channels == 1) {
-               err = ExtAudioFileRead(af, (UInt32*) &cnt, &abl);
-               _read_data_count = cnt * sizeof(float);
-               return cnt;
+               abl.mBuffers[0].mDataByteSize = cnt * sizeof(Sample);
+               abl.mBuffers[0].mData = dst;
+               try {
+                       af.Read (new_cnt, &abl);
+               } catch (CAXException& cax) {
+                       error << string_compose("CoreAudioSource: %1 (%2)", cax.mOperation, _name);
+               }
+               _read_data_count = new_cnt * sizeof(float);
+               return new_cnt;
        }
 
-       uint32_t real_cnt = cnt * n_channels;
+       UInt32 real_cnt = cnt * n_channels;
 
        {
                Glib::Mutex::Lock lm (_tmpbuf_lock);
@@ -189,11 +130,17 @@ CoreAudioSource::read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_
                        tmpbuf = new float[tmpbufsize];
                }
 
-               abl.mBuffers[0].mDataByteSize = real_cnt * sizeof(Sample);
+               abl.mBuffers[0].mDataByteSize = tmpbufsize * sizeof(Sample);
                abl.mBuffers[0].mData = tmpbuf;
+
+               cerr << "channel: " << _channel << endl;
                
-               err = ExtAudioFileRead(af, (UInt32*) &real_cnt, &abl);
-               float *ptr = tmpbuf + channel;
+               try {
+                       af.Read (real_cnt, &abl);
+               } catch (CAXException& cax) {
+                       error << string_compose("CoreAudioSource: %1 (%2)", cax.mOperation, _name);
+               }
+               float *ptr = tmpbuf + _channel;
                real_cnt /= n_channels;
                
                /* stride through the interleaved data */
@@ -212,15 +159,12 @@ CoreAudioSource::read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_
 float
 CoreAudioSource::sample_rate() const
 {
-        AudioStreamBasicDescription client_asbd;
-        memset(&client_asbd, 0, sizeof(AudioStreamBasicDescription));
-
-       OSStatus err = noErr;
-       size_t asbd_size = sizeof(AudioStreamBasicDescription);
+       CAStreamBasicDescription client_asbd;
 
-        err = ExtAudioFileSetProperty (af, kExtAudioFileProperty_ClientDataFormat, asbd_size, &client_asbd);
-        if (err != noErr) {
-               error << string_compose(_("Could not detect samplerate for: %1"), name()) << endmsg;
+       try {
+               client_asbd = af.GetClientDataFormat ();
+       } catch (CAXException& cax) {
+               error << string_compose("CoreAudioSource: %1 (%2)", cax.mOperation, _name);
                return 0.0;
        }
 
@@ -228,8 +172,57 @@ CoreAudioSource::sample_rate() const
 }
 
 int
-CoreAudioSource::update_header (jack_nframes_t when, struct tm&, time_t)
+CoreAudioSource::update_header (nframes_t when, struct tm&, time_t)
 {
        return 0;
 }
 
+int
+CoreAudioSource::get_soundfile_info (string path, SoundFileInfo& _info, string& error_msg)
+{
+       FSRef ref; 
+       ExtAudioFileRef af = 0;
+       size_t size;
+       CFStringRef name;
+       int ret = -1;
+
+       if (FSPathMakeRef ((UInt8*)path.c_str(), &ref, 0) != noErr) {
+               goto out;
+       }
+       
+       if (ExtAudioFileOpen(&ref, &af) != noErr) {
+               goto out;
+       }
+       
+       AudioStreamBasicDescription absd;
+       memset(&absd, 0, sizeof(absd));
+       size = sizeof(AudioStreamBasicDescription);
+       if (ExtAudioFileGetProperty (af, kExtAudioFileProperty_FileDataFormat, &size, &absd) != noErr) {
+               goto out;
+       }
+       
+       _info.samplerate = absd.mSampleRate;
+       _info.channels   = absd.mChannelsPerFrame;
+
+       size = sizeof(_info.length);
+       if (ExtAudioFileGetProperty(af, kExtAudioFileProperty_FileLengthFrames, &size, &_info.length) != noErr) {
+               goto out;
+       }
+       
+       size = sizeof(CFStringRef);
+       if (AudioFormatGetProperty(kAudioFormatProperty_FormatName, sizeof(absd), &absd, &size, &name) != noErr) {
+               goto out;
+       }
+
+       _info.format_name = CFStringRefToStdString(name);
+
+       // XXX it would be nice to find a way to get this information if it exists
+
+       _info.timecode = 0;
+       ret = 0;
+       
+  out:
+       ExtAudioFileDispose (af);
+       return ret;
+       
+}