← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to external/maccore/src/AudioUnit/ExtAudioFile.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
external/maccore/src/AudioUnit/ExtAudioFile.cs
1
1
//
2
2
// ExtAudioFile.cs: ExtAudioFile wrapper class
3
3
//
4
 
// Author:
 
4
// Authors:
5
5
//   AKIHIRO Uehara (u-akihiro@reinforce-lab.com)
 
6
//   Marek Safar (marek.safar@gmail.com)
6
7
//
7
8
// Copyright 2010 Reinforce Lab.
 
9
// Copyright 2012 Xamarin Inc.
8
10
//
9
11
// Permission is hereby granted, free of charge, to any person obtaining
10
12
// a copy of this software and associated documentation files (the
31
33
using System.Collections.Generic;
32
34
using System.Text;
33
35
using System.Runtime.InteropServices;
34
 
 
 
36
using MonoMac.CoreFoundation;
35
37
using MonoMac.AudioToolbox;
36
38
 
37
39
namespace MonoMac.AudioUnit
38
40
{
 
41
    public enum ExtAudioFileError
 
42
    {
 
43
        OK = 0,
 
44
        CodecUnavailableInputConsumed    = -66559,
 
45
        CodecUnavailableInputNotConsumed = -66560,
 
46
        InvalidProperty          = -66561,
 
47
        InvalidPropertySize      = -66562,
 
48
        NonPCMClientFormat       = -66563,
 
49
        InvalidChannelMap        = -66564,
 
50
        InvalidOperationOrder    = -66565,
 
51
        InvalidDataFormat        = -66566,
 
52
        MaxPacketSizeUnknown     = -66567,
 
53
        InvalidSeek              = -66568,
 
54
        AsyncWriteTooLarge       = -66569,
 
55
        AsyncWriteBufferOverflow = -66570,
 
56
 
 
57
        // Shared error codes
 
58
        NotOpenError                  = -38,
 
59
        EndOfFileError                = -39,
 
60
        PositionError                 = -40,
 
61
        FileNotFoundError             = -43
 
62
    }
 
63
 
39
64
    public class ExtAudioFile : IDisposable
40
65
    {
41
 
        #region Variables
42
 
        const int kAudioUnitSampleFractionBits = 24;
43
 
        readonly IntPtr _extAudioFile;
44
 
        #endregion
45
 
 
46
 
        #region Property        
47
 
        public long FileLengthFrames
48
 
        {
49
 
            get {
50
 
                long length = 0;
51
 
                uint size   = (uint)Marshal.SizeOf(typeof(long));
 
66
        IntPtr _extAudioFile;
 
67
 
 
68
        public uint? ClientMaxPacketSize {
 
69
            get {
 
70
                uint size = sizeof (uint);
 
71
                uint value;
 
72
                if (ExtAudioFileGetProperty (_extAudioFile, PropertyIDType.ClientMaxPacketSize, ref size, out value) != ExtAudioFileError.OK)
 
73
                    return null;
 
74
 
 
75
                return value;
 
76
            }
 
77
        }
 
78
 
 
79
        public uint? FileMaxPacketSize {
 
80
            get {
 
81
                uint size = sizeof (uint);
 
82
                uint value;
 
83
 
 
84
                if (ExtAudioFileGetProperty (_extAudioFile, PropertyIDType.FileMaxPacketSize, ref size, out value) != ExtAudioFileError.OK)
 
85
                    return null;
 
86
 
 
87
                return value;
 
88
            }
 
89
        }
 
90
 
 
91
 
 
92
        public IntPtr? AudioFile {
 
93
            get {
 
94
                uint size = (uint) Marshal.SizeOf (typeof (IntPtr));
 
95
                IntPtr value;
 
96
                if (ExtAudioFileGetProperty (_extAudioFile, PropertyIDType.AudioFile, ref size, out value) != ExtAudioFileError.OK)
 
97
                    return null;
 
98
 
 
99
                return value;
 
100
            }
 
101
        }
 
102
 
 
103
        public AudioConverter AudioConverter {
 
104
            get {
 
105
                uint size = sizeof (uint);
 
106
                IntPtr value;
 
107
 
 
108
                if (ExtAudioFileGetProperty (_extAudioFile, PropertyIDType.AudioConverter, ref size, out value) != ExtAudioFileError.OK)
 
109
                    return null;
 
110
 
 
111
                return new AudioConverter (value, false);
 
112
            }
 
113
        }
 
114
 
 
115
        public long FileLengthFrames {
 
116
            get {
 
117
                long length;
 
118
                uint size  =  sizeof (long);
52
119
                
53
 
                int err = ExtAudioFileGetProperty(_extAudioFile,
54
 
                    ExtAudioFilePropertyIDType.kExtAudioFileProperty_FileLengthFrames,
55
 
                    ref size, ref length);
 
120
                var err = ExtAudioFileGetProperty(_extAudioFile, PropertyIDType.FileLengthFrames, ref size, out length);
56
121
                if (err != 0)
57
122
                {
58
123
                    throw new InvalidOperationException(String.Format("Error code:{0}", err));
68
133
            {
69
134
                AudioStreamBasicDescription dc = new AudioStreamBasicDescription();
70
135
                uint size = (uint)Marshal.SizeOf(typeof(AudioStreamBasicDescription));
71
 
                int err = ExtAudioFileGetProperty(_extAudioFile,
72
 
                    ExtAudioFilePropertyIDType.kExtAudioFileProperty_FileDataFormat,
73
 
                    ref size, ref dc);
 
136
                int err = ExtAudioFileGetProperty(_extAudioFile, PropertyIDType.FileDataFormat, ref size, ref dc);
74
137
                if (err != 0)
75
138
                {
76
139
                    throw new InvalidOperationException(String.Format("Error code:{0}", err));
84
147
        {
85
148
            set
86
149
            {                
87
 
                int err = ExtAudioFileSetProperty(_extAudioFile,
88
 
                    ExtAudioFilePropertyIDType.kExtAudioFileProperty_ClientDataFormat,
 
150
                int err = ExtAudioFileSetProperty(_extAudioFile, PropertyIDType.ClientDataFormat,
89
151
                    (uint)Marshal.SizeOf(value), ref value);
90
152
                if (err != 0)
91
153
                {
93
155
                }
94
156
            }
95
157
        }           
96
 
        #endregion
97
158
 
98
 
        #region Constructor
99
159
        private ExtAudioFile(IntPtr ptr)
100
160
        {
101
161
            _extAudioFile = ptr;
102
162
        }
103
 
        #endregion
104
 
 
105
 
        #region Private methods
106
 
        #endregion
107
 
 
108
 
        #region Public methods        
109
 
        public static ExtAudioFile OpenUrl(MonoMac.CoreFoundation.CFUrl url)
110
 
        { 
111
 
            int err;
112
 
            IntPtr ptr = new IntPtr();
 
163
 
 
164
        ~ExtAudioFile ()
 
165
        {
 
166
            Dispose (false);
 
167
        }
 
168
 
 
169
        public static ExtAudioFile OpenUrl (CFUrl url)
 
170
        {
 
171
            if (url == null)
 
172
                throw new ArgumentNullException ("url");
 
173
 
 
174
            ExtAudioFileError err;
 
175
            IntPtr ptr;
113
176
            unsafe {                
114
177
                err = ExtAudioFileOpenUrl(url.Handle, (IntPtr)(&ptr));
115
178
            }            
124
187
            
125
188
            return new ExtAudioFile(ptr);
126
189
        }
127
 
        public static ExtAudioFile CreateWithUrl(MonoMac.CoreFoundation.CFUrl url,
 
190
 
 
191
        public static ExtAudioFile CreateWithUrl (CFUrl url,
128
192
            AudioFileType fileType, 
129
193
            AudioStreamBasicDescription inStreamDesc, 
130
194
            //AudioChannelLayout channelLayout, 
131
195
            AudioFileFlags flag)
132
196
        {             
 
197
            if (url == null)
 
198
                throw new ArgumentNullException ("url");
 
199
 
133
200
            int err;
134
201
            IntPtr ptr = new IntPtr();
135
202
            unsafe {                
147
214
            
148
215
            return new ExtAudioFile(ptr);         
149
216
        }
 
217
 
 
218
        public static ExtAudioFileError WrapAudioFileID (IntPtr audioFileID, bool forWriting, out ExtAudioFile outAudioFile)
 
219
        {
 
220
            IntPtr ptr;
 
221
            ExtAudioFileError res;
 
222
            unsafe {                
 
223
                res = ExtAudioFileWrapAudioFileID (audioFileID, forWriting, (IntPtr)(&ptr));
 
224
            }            
 
225
 
 
226
            if (res != ExtAudioFileError.OK) {
 
227
                outAudioFile = null;
 
228
                return res;
 
229
            }
 
230
 
 
231
            outAudioFile = new ExtAudioFile (ptr);
 
232
            return res;
 
233
        }
 
234
 
150
235
        public void Seek(long frameOffset)
151
236
        {
152
237
            int err = ExtAudioFileSeek(_extAudioFile, frameOffset);
167
252
            
168
253
            return frame;
169
254
        }
 
255
 
 
256
        [Obsolete ("Use overload with AudioBuffers")]
170
257
        public int Read(int numberFrames, AudioBufferList data)
171
 
        {            
 
258
        {
 
259
            if (data == null)
 
260
                throw new ArgumentNullException ("data");
 
261
 
172
262
            int err = ExtAudioFileRead(_extAudioFile, ref numberFrames, data);
173
263
            if (err != 0)
174
264
            {
177
267
 
178
268
            return numberFrames;
179
269
        }
 
270
 
 
271
        public uint Read (uint numberFrames, AudioBuffers audioBufferList, out ExtAudioFileError status)
 
272
        {
 
273
            if (audioBufferList == null)
 
274
                throw new ArgumentNullException ("audioBufferList");
 
275
 
 
276
            status = ExtAudioFileRead (_extAudioFile, ref numberFrames, (IntPtr) audioBufferList);
 
277
            return numberFrames;
 
278
        }
 
279
 
 
280
        [Obsolete ("Use overload with AudioBuffers")]
180
281
        public void WriteAsync(int numberFrames, AudioBufferList data)
181
282
        {
182
283
            int err = ExtAudioFileWriteAsync(_extAudioFile, numberFrames, data);
183
 
            if (err != 0)
184
 
                throw new ArgumentException(String.Format("Error code:{0}", err));            
185
 
        }         
186
 
        #endregion
187
 
 
188
 
        #region IDisposable メンバ
189
 
        public void Dispose()
190
 
        {
191
 
            ExtAudioFileDispose(_extAudioFile);            
192
 
        }
193
 
        #endregion
194
 
 
 
284
            
 
285
            if (err != 0) {
 
286
                throw new ArgumentException(String.Format("Error code:{0}", err));
 
287
            }        
 
288
        }
 
289
 
 
290
        public ExtAudioFileError WriteAsync (uint numberFrames, AudioBuffers audioBufferList)
 
291
        {
 
292
            if (audioBufferList == null)
 
293
                throw new ArgumentNullException ("audioBufferList");
 
294
 
 
295
            return ExtAudioFileWriteAsync (_extAudioFile, numberFrames, (IntPtr) audioBufferList);
 
296
        }
 
297
 
 
298
        public ExtAudioFileError Write (uint numberFrames, AudioBuffers audioBufferList)
 
299
        {
 
300
            if (audioBufferList == null)
 
301
                throw new ArgumentNullException ("audioBufferList");
 
302
 
 
303
            return ExtAudioFileWrite (_extAudioFile, numberFrames, (IntPtr) audioBufferList);
 
304
        }
 
305
 
 
306
        public ExtAudioFileError SynchronizeAudioConverter ()
 
307
        {
 
308
            IntPtr value = IntPtr.Zero;
 
309
            return ExtAudioFileSetProperty (_extAudioFile, PropertyIDType.ConverterConfig,
 
310
                Marshal.SizeOf (value), value);
 
311
        }
 
312
 
 
313
        public void Dispose ()
 
314
        {
 
315
            Dispose (true);
 
316
            GC.SuppressFinalize (this);
 
317
        }
 
318
 
 
319
        protected virtual void Dispose (bool disposing)
 
320
        {
 
321
            if (_extAudioFile != IntPtr.Zero){
 
322
                ExtAudioFileDispose (_extAudioFile);
 
323
                _extAudioFile = IntPtr.Zero;
 
324
            }
 
325
        }
195
326
 
196
327
        #region Interop
197
328
        [DllImport(MonoMac.Constants.AudioToolboxLibrary, EntryPoint = "ExtAudioFileOpenURL")]
198
 
        static extern int ExtAudioFileOpenUrl(IntPtr inUrl, IntPtr outExtAudioFile); // caution
199
 
 
 
329
        static extern ExtAudioFileError ExtAudioFileOpenUrl(IntPtr inUrl, IntPtr outExtAudioFile); // caution
 
330
 
 
331
        [DllImport (MonoMac.Constants.AudioToolboxLibrary)]
 
332
        static extern ExtAudioFileError ExtAudioFileWrapAudioFileID (IntPtr inFileID, bool inForWriting, IntPtr outExtAudioFile);    
 
333
 
 
334
        [Obsolete]
200
335
        [DllImport(MonoMac.Constants.AudioToolboxLibrary, EntryPoint = "ExtAudioFileRead")]
201
336
        static extern int ExtAudioFileRead(IntPtr  inExtAudioFile, ref int ioNumberFrames, AudioBufferList ioData);
202
337
 
 
338
        [DllImport(MonoMac.Constants.AudioToolboxLibrary)]
 
339
        static extern ExtAudioFileError ExtAudioFileRead (IntPtr inExtAudioFile, ref uint ioNumberFrames, IntPtr ioData);
 
340
 
 
341
        [DllImport(MonoMac.Constants.AudioToolboxLibrary)]
 
342
        static extern ExtAudioFileError ExtAudioFileWrite (IntPtr inExtAudioFile, uint inNumberFrames, IntPtr ioData);                 
 
343
 
 
344
        [Obsolete]
203
345
        [DllImport(MonoMac.Constants.AudioToolboxLibrary, EntryPoint = "ExtAudioFileWriteAsync")]
204
346
        static extern int ExtAudioFileWriteAsync(IntPtr inExtAudioFile, int inNumberFrames, AudioBufferList ioData);
205
347
 
 
348
        [DllImport(MonoMac.Constants.AudioToolboxLibrary)]
 
349
        static extern ExtAudioFileError ExtAudioFileWriteAsync(IntPtr inExtAudioFile, uint inNumberFrames, IntPtr ioData);
 
350
 
206
351
        [DllImport(MonoMac.Constants.AudioToolboxLibrary, EntryPoint = "ExtAudioFileDispose")]
207
352
        static extern int ExtAudioFileDispose(IntPtr inExtAudioFile);
208
353
 
223
368
        [DllImport(MonoMac.Constants.AudioToolboxLibrary, EntryPoint = "ExtAudioFileGetProperty")]
224
369
        static extern int ExtAudioFileGetProperty(
225
370
            IntPtr inExtAudioFile, 
226
 
            ExtAudioFilePropertyIDType inPropertyID,
227
 
            ref uint ioPropertyDataSize,
228
 
            IntPtr outPropertyData);
229
 
        
230
 
        [DllImport(MonoMac.Constants.AudioToolboxLibrary, EntryPoint = "ExtAudioFileGetProperty")]
231
 
        static extern int ExtAudioFileGetProperty(
232
 
            IntPtr inExtAudioFile,
233
 
            ExtAudioFilePropertyIDType inPropertyID,
234
 
            ref uint ioPropertyDataSize,
235
 
            ref AudioStreamBasicDescription outPropertyData);
236
 
        
237
 
 
238
 
        [DllImport(MonoMac.Constants.AudioToolboxLibrary, EntryPoint = "ExtAudioFileGetProperty")]
239
 
        static extern int ExtAudioFileGetProperty(
240
 
            IntPtr inExtAudioFile,
241
 
            ExtAudioFilePropertyIDType inPropertyID,
242
 
            ref uint ioPropertyDataSize,
243
 
            ref long outPropertyData);
244
 
 
245
 
        [DllImport(MonoMac.Constants.AudioToolboxLibrary, EntryPoint = "ExtAudioFileSetProperty")]
246
 
        static extern int ExtAudioFileSetProperty(
247
 
            IntPtr inExtAudioFile,
248
 
            ExtAudioFilePropertyIDType inPropertyID,
249
 
            uint ioPropertyDataSize,
250
 
            IntPtr outPropertyData);
251
 
 
252
 
        [DllImport(MonoMac.Constants.AudioToolboxLibrary, EntryPoint = "ExtAudioFileSetProperty")]
253
 
        static extern int ExtAudioFileSetProperty(
254
 
            IntPtr inExtAudioFile,
255
 
            ExtAudioFilePropertyIDType inPropertyID,
256
 
            uint ioPropertyDataSize,
257
 
            ref AudioStreamBasicDescription outPropertyData);
258
 
        
259
 
        enum ExtAudioFilePropertyIDType {                 
260
 
                kExtAudioFileProperty_FileDataFormat            = 0x66666d74, //'ffmt',   // AudioStreamBasicDescription
 
371
            PropertyIDType inPropertyID,
 
372
            ref uint ioPropertyDataSize,
 
373
            IntPtr outPropertyData);
 
374
        
 
375
        [DllImport(MonoMac.Constants.AudioToolboxLibrary, EntryPoint = "ExtAudioFileGetProperty")]
 
376
        static extern int ExtAudioFileGetProperty(
 
377
            IntPtr inExtAudioFile,
 
378
            PropertyIDType inPropertyID,
 
379
            ref uint ioPropertyDataSize,
 
380
            ref AudioStreamBasicDescription outPropertyData);
 
381
        
 
382
        [DllImport(MonoMac.Constants.AudioToolboxLibrary)]
 
383
        static extern ExtAudioFileError ExtAudioFileGetProperty (IntPtr inExtAudioFile, PropertyIDType inPropertyID, ref uint ioPropertyDataSize, out IntPtr outPropertyData);
 
384
 
 
385
        [DllImport(MonoMac.Constants.AudioToolboxLibrary)]
 
386
        static extern ExtAudioFileError ExtAudioFileGetProperty (IntPtr inExtAudioFile, PropertyIDType inPropertyID, ref uint ioPropertyDataSize, out long outPropertyData);
 
387
 
 
388
        [DllImport(MonoMac.Constants.AudioToolboxLibrary)]
 
389
        static extern ExtAudioFileError ExtAudioFileGetProperty (IntPtr inExtAudioFile, PropertyIDType inPropertyID, ref uint ioPropertyDataSize, out uint outPropertyData);
 
390
 
 
391
        [DllImport(MonoMac.Constants.AudioToolboxLibrary)]
 
392
        static extern ExtAudioFileError ExtAudioFileSetProperty (IntPtr inExtAudioFile, PropertyIDType inPropertyID, int ioPropertyDataSize, IntPtr outPropertyData);
 
393
 
 
394
        [DllImport(MonoMac.Constants.AudioToolboxLibrary, EntryPoint = "ExtAudioFileSetProperty")]
 
395
        static extern int ExtAudioFileSetProperty(
 
396
            IntPtr inExtAudioFile,
 
397
            PropertyIDType inPropertyID,
 
398
            uint ioPropertyDataSize,
 
399
            ref AudioStreamBasicDescription outPropertyData);
 
400
        
 
401
        enum PropertyIDType {                 
 
402
                FileDataFormat             = 0x66666d74,       // 'ffmt'
261
403
                //kExtAudioFileProperty_FileChannelLayout               = 'fclo',   // AudioChannelLayout
262
404
 
263
 
            kExtAudioFileProperty_ClientDataFormat = 0x63666d74, //'cfmt',   // AudioStreamBasicDescription
 
405
            ClientDataFormat = 0x63666d74, //'cfmt',   // AudioStreamBasicDescription
264
406
                //kExtAudioFileProperty_ClientChannelLayout     = 'cclo',   // AudioChannelLayout
265
 
                //kExtAudioFileProperty_CodecManufacturer               = 'cman',       // UInt32
 
407
                CodecManufacturer               = 0x636d616e,      // 'cman'
266
408
        
267
409
                // read-only:
268
 
                //kExtAudioFileProperty_AudioConverter          = 'acnv',       // AudioConverterRef
269
 
                //kExtAudioFileProperty_AudioFile                               = 'afil',       // AudioFileID
270
 
                //kExtAudioFileProperty_FileMaxPacketSize               = 'fmps',       // UInt32
271
 
                //kExtAudioFileProperty_ClientMaxPacketSize     = 'cmps',       // UInt32
272
 
                kExtAudioFileProperty_FileLengthFrames          = 0x2366726d,//'#frm',  // SInt64
 
410
            AudioConverter          = 0x61636e76,      // 'acnv'
 
411
                AudioFile                               = 0x6166696c,      // 'afil'
 
412
                FileMaxPacketSize               = 0x666d7073,      // 'fmps'
 
413
                ClientMaxPacketSize     = 0x636d7073,      // 'cmps'
 
414
                FileLengthFrames                = 0x2366726d,      // '#frm'
273
415
        
274
416
                // writable:
275
 
                //kExtAudioFileProperty_ConverterConfig         = 'accf',   // CFPropertyListRef
 
417
                ConverterConfig         = 0x61636366,      // 'accf'
276
418
                //kExtAudioFileProperty_IOBufferSizeBytes               = 'iobs',       // UInt32
277
419
                //kExtAudioFileProperty_IOBuffer                                = 'iobf',       // void *
278
420
                //kExtAudioFileProperty_PacketTable                     = 'xpti'        // AudioFilePacketTableInfo