audiofile.h

Go to the documentation of this file.

 
#pragma once
 
#include <promeki/core/namespace.h>
#include <promeki/core/sharedptr.h>
#include <promeki/core/string.h>
#include <promeki/core/error.h>
#include <promeki/proav/audio.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class IODevice;
 
class AudioFile {
        public:
                using Ptr = SharedPtr<AudioFile>;
 
                enum Operation {
                        InvalidOperation = 0, 
                        Reader,               
                        Writer                
                };
 
                class Impl {
                        PROMEKI_SHARED(Impl)
                        public:
                                Impl(Operation op) : _operation(op) {}
 
                                virtual ~Impl();
 
                                bool isValid() const {
                                        return _operation != InvalidOperation;
                                }
 
                                Operation operation() const {
                                        return _operation;
                                }
 
                                const String &filename() const {
                                        return _filename;
                                }
 
                                void setFilename(const String &val) {
                                        _filename = val;
                                        return;
                                }
 
                                AudioDesc desc() const {
                                        return _desc;
                                }
 
                                void setDesc(const AudioDesc &val) {
                                        _desc = val;
                                        return;
                                }
 
                                IODevice *device() const {
                                        return _device;
                                }
 
                                void setDevice(IODevice *dev) {
                                        _device = dev;
                                        _ownsDevice = false;
                                        return;
                                }
 
                                const String &formatHint() const {
                                        return _formatHint;
                                }
 
                                void setFormatHint(const String &val) {
                                        _formatHint = val;
                                        return;
                                }
 
                                virtual Error open();
 
                                virtual void close();
 
                                virtual Error read(Audio &audio, size_t maxSamples);
 
                                virtual Error write(const Audio &audio);
 
                                virtual Error seekToSample(size_t sample);
 
                                virtual size_t sampleCount() const;
 
                        protected:
                                Operation       _operation;
                                String          _filename;
                                AudioDesc       _desc;
                                IODevice       *_device = nullptr;
                                bool            _ownsDevice = false;
                                String          _formatHint;
                };
 
                static AudioFile createForOperation(Operation op, const String &filename);
 
                static Result<AudioFile> createForOperation(Operation op, IODevice *device, const String &formatHint = "");
 
                static AudioFile createReader(const String &filename) { return createForOperation(Reader, filename); }
 
                static AudioFile createWriter(const String &filename) { return createForOperation(Writer, filename); }
 
                AudioFile() : d(SharedPtr<Impl>::create(InvalidOperation)) {};
 
                AudioFile(Impl *impl) : d(SharedPtr<Impl>::takeOwnership(impl)) {};
 
                bool isValid() const { return d->isValid(); }
 
                Operation operation() const { return d->operation(); }
 
                const String &filename() const { return d->filename(); }
 
                void setFilename(const String &val) { d.modify()->setFilename(val); return; }
 
                AudioDesc desc() const { return d->desc(); }
 
                void setDesc(const AudioDesc &val) { d.modify()->setDesc(val); return; }
 
                IODevice *device() const { return d->device(); }
 
                Error open() { return d.modify()->open(); }
 
                void close() { d.modify()->close(); return; }
 
                Error read(Audio &audio, size_t maxSamples) { return d.modify()->read(audio, maxSamples); }
 
                Error write(const Audio &audio) { return d.modify()->write(audio); }
 
                Error seekToSample(size_t sample) { return d.modify()->seekToSample(sample); }
 
                size_t sampleCount() const { return d->sampleCount(); }
 
        private:
                SharedPtr<Impl> d;
};
 
PROMEKI_NAMESPACE_END