/home/maxime/Projets/Mixxx/1.10/mixxx/src/soundmanagerutil.cpp

Go to the documentation of this file.

/***************************************************************************
 *                                                                         *
 *   This program 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.                                   *
 *                                                                         *
 ***************************************************************************/

#include <QtCore>
#include "soundmanagerutil.h"

ChannelGroup::ChannelGroup(unsigned char channelBase, unsigned char channels)
  : m_channelBase(channelBase)
  , m_channels(channels) {
}

unsigned char ChannelGroup::getChannelBase() const {
    return m_channelBase;
}

unsigned char ChannelGroup::getChannelCount() const {
    return m_channels;
}

bool ChannelGroup::operator==(const ChannelGroup &other) const {
    return m_channelBase == other.m_channelBase
        && m_channels == other.m_channels;
}

bool ChannelGroup::clashesWith(const ChannelGroup &other) const {
    if (m_channels == 0 || other.m_channels == 0) {
        return false; // can't clash if there are no channels in use
    }
    return (m_channelBase > other.m_channelBase
        && m_channelBase < other.m_channelBase + other.m_channels)
        ||
        (other.m_channelBase > m_channelBase
        && other.m_channelBase < m_channelBase + m_channels)
        || m_channelBase == other.m_channelBase;
}

unsigned int ChannelGroup::getHash() const {
    return 0 | (m_channels << 8) | m_channelBase;
}

AudioPath::AudioPath(unsigned char channelBase, unsigned char channels)
    : m_channelGroup(channelBase, channels) {
}

AudioPathType AudioPath::getType() const {
    return m_type;
}

ChannelGroup AudioPath::getChannelGroup() const {
    return m_channelGroup;
}

unsigned char AudioPath::getIndex() const {
    return m_index;
}

bool AudioPath::operator==(const AudioPath &other) const {
    return m_type == other.m_type
        && m_index == other.m_index;
}

unsigned int AudioPath::getHash() const {
    return 0 | (m_type << 8) | m_index;
}

bool AudioPath::channelsClash(const AudioPath &other) const {
    return m_channelGroup.clashesWith(other.m_channelGroup);
}

QString AudioPath::getString() const {
    if (isIndexed(getType())) {
        return QString("%1 %2")
            .arg(getTrStringFromType(getType())).arg(m_index + 1);
    }
    return getTrStringFromType(getType());
}

QString AudioPath::getStringFromType(AudioPathType type) {
    switch (type) {
    case INVALID:
        // this shouldn't happen but g++ complains if I don't
        // handle this -- bkgood
        return QString::fromAscii("Invalid");
    case MASTER:
        return QString::fromAscii("Master");
    case HEADPHONES:
        return QString::fromAscii("Headphones");
    case DECK:
        return QString::fromAscii("Deck");
    case VINYLCONTROL:
        return QString::fromAscii("Vinyl Control");
    case MICROPHONE:
        return QString::fromAscii("Microphone");
    case EXTPASSTHROUGH:
        return QString::fromAscii("Passthrough");
    }
    return QString::fromAscii("Unknown path type %1").arg(type);
}

QString AudioPath::getTrStringFromType(AudioPathType type) {
    switch (type) {
    case INVALID:
        // this shouldn't happen but g++ complains if I don't
        // handle this -- bkgood
        return QString(QObject::tr("Invalid"));
    case MASTER:
        return QString(QObject::tr("Master"));
    case HEADPHONES:
        return QString(QObject::tr("Headphones"));
    case DECK:
        return QString(QObject::tr("Deck"));
    case VINYLCONTROL:
        return QString(QObject::tr("Vinyl Control"));
    case MICROPHONE:
        return QString(QObject::tr("Microphone"));
    case EXTPASSTHROUGH:
        return QString(QObject::tr("Passthrough"));
    }
    return QString(QObject::tr("Unknown path type %1")).arg(type);
}

AudioPathType AudioPath::getTypeFromString(QString string) {
    string = string.toLower();
    if (string == AudioPath::getStringFromType(AudioPath::MASTER).toLower()) {
        return AudioPath::MASTER;
    } else if (string == AudioPath::getStringFromType(AudioPath::HEADPHONES).toLower()) {
        return AudioPath::HEADPHONES;
    } else if (string == AudioPath::getStringFromType(AudioPath::DECK).toLower()) {
        return AudioPath::DECK;
    } else if (string == AudioPath::getStringFromType(AudioPath::VINYLCONTROL).toLower()) {
        return AudioPath::VINYLCONTROL;
    } else if (string == AudioPath::getStringFromType(AudioPath::MICROPHONE).toLower()) {
        return AudioPath::MICROPHONE;
    } else if (string == AudioPath::getStringFromType(AudioPath::EXTPASSTHROUGH).toLower()) {
        return AudioPath::EXTPASSTHROUGH;
    } else {
        return AudioPath::INVALID;
    }
}

bool AudioPath::isIndexed(AudioPathType type) {
    switch (type) {
    case DECK:
    case VINYLCONTROL:
    case EXTPASSTHROUGH:
        return true;
    case MICROPHONE:
    default:
        break;
    }
    return false;
}

AudioPathType AudioPath::getTypeFromInt(int typeInt) {
    if (typeInt < 0 || typeInt >= AudioPath::INVALID) {
        return AudioPath::INVALID;
    }
    return static_cast<AudioPathType>(typeInt);
}

unsigned char AudioPath::channelsNeededForType(AudioPathType type) {
    switch (type) {
    case AudioPath::MICROPHONE:
        return 1;
    default:
        return 2;
    }
}

AudioOutput::AudioOutput(AudioPathType type /* = INVALID */,
        unsigned char channelBase /* = 0 */,
        unsigned char index /* = 0 */)
    : AudioPath(channelBase, AudioPath::channelsNeededForType(type)) {
    setType(type);
    if (isIndexed(type)) {
        m_index = index;
    } else {
        m_index = 0;
    }
}

QDomElement AudioOutput::toXML(QDomElement *element) const {
    element->setTagName("output");
    element->setAttribute("type", AudioPath::getStringFromType(m_type));
    element->setAttribute("index", m_index);
    element->setAttribute("channel", m_channelGroup.getChannelBase());
    return *element;
}

AudioOutput AudioOutput::fromXML(const QDomElement &xml) {
    AudioPathType type(AudioPath::getTypeFromString(xml.attribute("type")));
    unsigned int index(xml.attribute("index", "0").toUInt());
    unsigned int channel(xml.attribute("channel", "0").toUInt());
    return AudioOutput(type, channel, index);
}

//static
QList<AudioPathType> AudioOutput::getSupportedTypes() {
    QList<AudioPathType> types;
    types.append(MASTER);
    types.append(HEADPHONES);
    types.append(DECK);
    return types;
}

void AudioOutput::setType(AudioPathType type) {
    if (AudioOutput::getSupportedTypes().contains(type)) {
        m_type = type;
    } else {
        m_type = AudioPath::INVALID;
    }
}

AudioInput::AudioInput(AudioPathType type /* = INVALID */,
        unsigned char channelBase /* = 0 */,
        unsigned char index /* = 0 */)
  : AudioPath(channelBase, AudioPath::channelsNeededForType(type)) {
    setType(type);
    if (isIndexed(type)) {
        m_index = index;
    } else {
        m_index = 0;
    }
}

QDomElement AudioInput::toXML(QDomElement *element) const {
    element->setTagName("input");
    element->setAttribute("type", AudioPath::getStringFromType(m_type));
    element->setAttribute("index", m_index);
    element->setAttribute("channel", m_channelGroup.getChannelBase());
    return *element;
}

AudioInput AudioInput::fromXML(const QDomElement &xml) {
    AudioPathType type(AudioPath::getTypeFromString(xml.attribute("type")));
    unsigned int index(xml.attribute("index", "0").toUInt());
    unsigned int channel(xml.attribute("channel", "0").toUInt());
    return AudioInput(type, channel, index);
}

QList<AudioPathType> AudioInput::getSupportedTypes() {
    QList<AudioPathType> types;
#ifdef __VINYLCONTROL__
    // this disables vinyl control for all of the sound devices stuff
    // (prefs, etc), minimal ifdefs :) -- bkgood
    types.append(VINYLCONTROL);
#endif
    types.append(MICROPHONE);
    return types;
}

void AudioInput::setType(AudioPathType type) {
    if (AudioInput::getSupportedTypes().contains(type)) {
        m_type = type;
    } else {
        m_type = AudioPath::INVALID;
    }
}

unsigned int qHash(const ChannelGroup &group) {
    return group.getHash();
}

unsigned int qHash(const AudioOutput &output) {
    return output.getHash();
}

unsigned int qHash(const AudioInput &input) {
    return input.getHash();
}