Sound.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
 * SPDX-FileCopyrightText: 2006-2010 RobotCub Consortium
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef YARP_SIG_SOUND_H
#define YARP_SIG_SOUND_H
 
#include <yarp/os/Portable.h>
#include <yarp/conf/numeric.h>
#include <yarp/sig/api.h>
#include <vector>
#include <string>
 
namespace yarp {
namespace sig {
 
class YARP_sig_API Sound : public yarp::os::Portable
{
public:
    typedef short int audio_sample;
 
    Sound(size_t bytesPerSample = 2);
 
    Sound(const Sound& alt);
 
    virtual ~Sound();
 
    const Sound& operator=(const Sound& alt);
 
    bool operator==(const Sound& alt) const;
 
    Sound& operator+=(const Sound& alt);
 
    Sound subSound(size_t first_sample, size_t last_sample);
 
    void resize(size_t samples, size_t channels = 1);
 
    audio_sample get(size_t sample, size_t channel = 0) const;
 
    void set(audio_sample value, size_t sample, size_t channel = 0);
 
    audio_sample getSafe(size_t sample, size_t channel = 0) const {
        if (isSample(sample,channel)) {
            return get(sample,channel);
        }
        return 0;
    }
 
    void setSafe(audio_sample value, size_t sample, size_t channel = 0);
 
    bool isSample(size_t sample, size_t channel = 0) const;
 
    void clear();
 
    void normalizeChannel(size_t channel);
 
    void normalize();
 
    void amplifyChannel(size_t channel, double gain);
 
    void amplify(double gain);
 
    void findPeakInChannel(size_t channelId, size_t& sampleId, audio_sample& sampleValue) const;
 
    void findPeak(size_t& channelId, size_t& sampleId, audio_sample& sampleValue) const;
 
    inline double sample2timestamp( size_t sampleid) const {return static_cast<double>(sampleid / m_frequency);}
 
    inline size_t timestamp2sample( double time) const { return static_cast<size_t>(time * m_frequency);}
 
    bool clearChannel(size_t channel);
 
    int getFrequency() const;
 
    void setFrequency(int freq);
 
    size_t getBytesPerSample() const;
 
    size_t getSamples() const;
 
    double getDuration() const;
 
    size_t getChannels() const;
 
    Sound extractChannelAsSound(size_t channel_id) const;
 
    std::vector<std::reference_wrapper<audio_sample>> getChannel(size_t channel_id);
 
    bool replaceChannel(size_t id, Sound channel);
 
    std::vector<std::reference_wrapper<audio_sample>> getInterleavedAudioRawData() const;
 
    std::vector<std::reference_wrapper<audio_sample>> getNonInterleavedAudioRawData() const;
 
    std::string toString() const;
 
private:
    unsigned char *getRawData() const;
 
    size_t getRawDataSize() const;
 
public:
    bool read(yarp::os::ConnectionReader& connection) override;
 
    bool write(yarp::os::ConnectionWriter& connection) const override;
 
private:
    void init(size_t bytesPerSample);
    void synchronize();
 
    void *implementation;
    size_t m_samples;
    size_t m_channels;
    size_t m_bytesPerSample;
    int    m_frequency;
};
 
} // namespace sig
} // namespace yarp
 
#endif // YARP_SIG_SOUND_H