Hardware.H

Go to the documentation of this file.

/* Copyright 2000-2018 Matt Flax <flatmax@flatmax.org>
   This file is part of GTK+ IOStream class set

   GTK+ IOStream is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GTK+ IOStream is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You have received a copy of the GNU General Public License
   along with GTK+ IOStream
*/
#ifndef HARDWARE_H
#define HARDWARE_H

#include <ALSA/ALSA.H>

namespace ALSA {

        class Hardware : public PCM {
                snd_pcm_hw_params_t *hParams; 
        protected:

                int setHWParams() {
                        PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
                        return snd_pcm_hw_params(getPCM(), hParams);
                }

        public:
                int getHWParams() {
                        PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
                        return snd_pcm_hw_params_current(getPCM(), hParams);
                }

                int fillParams() {
                        PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
                        int ret=snd_pcm_hw_params_any(getPCM(), hParams);
                        if (ret<0)
                                ALSADebug().evaluateError(ret);
                        return ret;
                }

                int resetParams() {
                        return fillParams();
                }

                Hardware() {
                        hParams=NULL;
                        snd_pcm_hw_params_malloc(&hParams);
                        if (!hParams)
                                assert("Couldn't malloc HW params");
                }

                virtual ~Hardware() {
                        if (hParams)
                                snd_pcm_hw_params_free(hParams);
                        hParams=NULL;
                }

                void copyFrom(snd_pcm_hw_params_t *hParamsIn){
                        snd_pcm_hw_params_copy(hParams, hParamsIn);
                }

                int rateResample(unsigned int state) {
                        PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
                        return snd_pcm_hw_params_set_rate_resample(getPCM(), hParams, state);
                }

                int setAccess(snd_pcm_access_t access) {
                        PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
                        int ret=snd_pcm_hw_params_set_access(getPCM(), hParams, access);
                        if (ret<0)
                                return ALSADebug().evaluateError(ret);
                        return ret;
                }

                int getAccess(void){
                        snd_pcm_access_t access;
                        int ret=snd_pcm_hw_params_get_access(hParams, &access);
                        if (ret>=0)
                                ret=access;
                        return ret;
                }

                int setFormat(snd_pcm_format_t format) {
                        PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
                        int ret=snd_pcm_hw_params_set_format(getPCM(), hParams, format);
                        if (ret<0)
                                return ALSADebug().evaluateError(ret);
                        return ret;
                }

                int getFormat(snd_pcm_format_t &format){
                        return snd_pcm_hw_params_get_format(hParams, &format);
                }

                int getFormatPhysicalWidth(){
                        int ret=0;
                        snd_pcm_format_t format;
                        if ((ret=getFormat(format))<0)
                                return ret;
                        return snd_pcm_format_physical_width(format);
                }

                int setChannels(unsigned int cnt) {
                        PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
                        return snd_pcm_hw_params_set_channels(getPCM(), hParams, cnt);
                }

                int getChannels() {
                        unsigned int cnt;
                        int err=snd_pcm_hw_params_get_channels(hParams, &cnt);
                        if (err<0)
                                return err;
                        else
                                return cnt;
                }

                int getMaxChannels(){
                        PCM_NOT_OPEN_CHECK_NO_PRINT(getPCM(), int) // check pcm is open
                        unsigned int mCh;
                        int ret=snd_pcm_hw_params_get_channels_max(hParams, &mCh);
                        if (ret<0)
                                return ALSADebug().evaluateError(ret);
                        return mCh;
                }

                int setSampleRate(unsigned int rrate, int dir=0) {
                        PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
                        int ret=snd_pcm_hw_params_set_rate_near(getPCM(), hParams, &rrate, &dir);
                        if (ret<0)
                                return ALSADebug().evaluateError(ret);
                        return ret;
                }

                int getSampleRate(int dir=0) {
                        unsigned int rate;
                        int err=snd_pcm_hw_params_get_rate(hParams, &rate, &dir);
                        if (err<0)
                                return err;
                        else
                                return rate;
                }

                int getPeriodSize(snd_pcm_uframes_t *p, int *dir=NULL) {
                        return snd_pcm_hw_params_get_period_size(hParams, p, dir);
                }

                int getPeriodSize(int *dir=NULL) {
                        snd_pcm_uframes_t p;
                        return getPeriodSize(&p, dir);
                }

                int setPeriodSize(snd_pcm_uframes_t *p, int *dir=0) {
                        PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
                        return snd_pcm_hw_params_set_period_size_near(getPCM(), hParams, p, dir);
                }

                int setBufSize(snd_pcm_uframes_t bufSize) {
                        PCM_NOT_OPEN_CHECK(getPCM()) // check pcm is open
                        snd_pcm_uframes_t periodSize = bufSize * 2;

                        int err = snd_pcm_hw_params_set_buffer_size_near(getPCM(), hParams, &periodSize);
                        if (err < 0) {
                                printf("Unable to set buffer size %d %s \n",(int)(bufSize*2), snd_strerror(err));
                                return err;
                        }
                        periodSize /= 2;
                        if ((err = setPeriodSize(&periodSize)) < 0)
                                printf("Unable to set period size %d %s \n",(int)periodSize, snd_strerror(err));
                        return err;
                }

                const char *formatDescription(const snd_pcm_format_t format) const {
                        return snd_pcm_format_description(format);
                }

                const char *getDeviceName(){
                        PCM_NOT_OPEN_CHECK_STRING(getPCM()) // check pcm is open
                        return snd_pcm_name(getPCM());
                }

                int dumpHWParams(){
                        int ret=0;
                        if (!logEnabled())
                                return ret;
                        return snd_pcm_hw_params_dump(hParams, log);
                }
        };
}
#endif //HARDWARE_H