コード例 #1
0
ファイル: audio.cpp プロジェクト: rlankenau/firestr
 //simple low pass filter 
 void reduce_noise(u::bytes& s, size_t len)
 {
     REQUIRE_EQUAL(s.size() % 2, 0);
     auto ss = reinterpret_cast<short*>(s.data());
     len /= 2;
     for(size_t i = 1; i < len; i++)
         ss[i] = (0.333 * ss[i]) + ((1 - 0.333) * ss[i-1]) + 0.5;
 }
コード例 #2
0
ファイル: audio.cpp プロジェクト: rlankenau/firestr
            //decimate sound to SAMPLE_RATE, using averaging
            void decimate(const u::bytes& s, u::bytes& d, size_t channels, size_t skip) 
            {
                REQUIRE_FALSE(s.empty());
                REQUIRE_EQUAL(s.size() % 2, 0);

                //get sizes
                auto dz = (s.size() / skip);
                auto nz = d.size() + dz;

                //add padding
                if(nz % 2 == 1) nz += 1;
                CHECK_EQUAL(nz % 2, 0);

                //resize dest
                const auto odz = d.size();
                d.resize(nz);

                //cast to short arrays
                auto ss = reinterpret_cast<const short*>(s.data());
                const auto sz = s.size() / 2;
                auto sd = reinterpret_cast<short*>(d.data());
                const auto sdz = nz / 2;

                int accum = 0;
                size_t c = 1;
                size_t si = 0;
                auto di = odz / 2;

                for(;si < sz; si+=channels)
                {
                    accum += static_cast<int>(ss[si]);
                    if(c == skip)
                    {
                        accum /= c;
                        sd[di] = accum;
                        di++;

                        accum = 0;
                        c = 1;
                        continue;
                    }
                    c++;
                }

                //repeat last value if we have padding
                si = sz-1;
                while(di < sdz)
                {
                    sd[di] = ss[si];
                    di++;
                }

                CHECK_EQUAL(di, sdz);
            }
コード例 #3
0
ファイル: audio.cpp プロジェクト: rlankenau/firestr
            u::bytes microphone::encode(const u::bytes& b)
            {
                REQUIRE(_opus);
                REQUIRE_FALSE(b.empty());

                return _opus->encode({b}).data;
            }
コード例 #4
0
ファイル: audio.cpp プロジェクト: japesinator/firestr
            void speaker::play(const u::bytes& d)
            {
                INVARIANT(_o);
                if(_mute) return;
                if(d.empty()) return;

                const u::bytes* data = &d;
                u::bytes dec;
                if(_t == codec_type::opus) 
                {
                    dec = decode(d);
                    data = &dec;
                }

                CHECK(data);

                //repeat to match speaker sample rate
                u::bytes r;
                inflate(*data, r, _channels, _rep);

                if(_d) 
                {
                    _d->write(r.data(), r.size());
                    if(_o->state() == QAudio::SuspendedState)
                    {
                        _o->reset();
                        _o->resume();
                    }
                }
                else
                {
                    _d = _o->start();
                    _d->write(r.data(), r.size());
                }
            }
コード例 #5
0
ファイル: security.cpp プロジェクト: mempko/firestr
        u::bytes private_key::sign(const u::bytes& b) const
        {
            INVARIANT(_k);
            u::mutex_scoped_lock l(BOTAN_MUTEX);

            init_rng();
            CHECK(RNG);

            b::PK_Signer s{*_k, EMSA_SCHEME};
            auto r = s.sign_message(reinterpret_cast<const unsigned char*>(b.data()), b.size(), *RNG); 

            ENSURE_EQUAL(r.size(), SIGNATURE_SIZE);
            return u::bytes {std::begin(r), std::end(r)};
        }
コード例 #6
0
ファイル: security.cpp プロジェクト: mempko/firestr
        u::bytes public_key::encrypt(const u::bytes& b) const
        {
            INVARIANT(_k);
            INVARIANT_FALSE(_ks.empty());
            u::mutex_scoped_lock l(BOTAN_MUTEX);

            init_rng();
            CHECK(RNG);

            std::stringstream rs;

            b::PK_Encryptor_EME e{*_k, EME_SCHEME};

            size_t advance = 0;
            while(advance < b.size())
            {
                size_t size = std::min(e.maximum_input_size(), b.size()-advance);
                auto c = e.encrypt(reinterpret_cast<const unsigned char*>(b.data())+advance, size, *RNG);
                u::bytes bs{std::begin(c), std::end(c)};
                rs << bs;
                advance+=size;
            }
            return u::to_bytes(rs.str());
        }
コード例 #7
0
ファイル: audio.cpp プロジェクト: rlankenau/firestr
            void inflate(const u::bytes& s, u::bytes& d, size_t channels, size_t rep)
            {
                REQUIRE_EQUAL(s.size() % 2, 0);

                rep*=channels;
                d.resize(s.size() * rep);

                auto ss = reinterpret_cast<const short*>(s.data());
                auto sz = s.size() / 2;
                auto sd = reinterpret_cast<short*>(d.data());

                size_t di = 0;
                for(size_t si = 0; si < sz; si++)
                    for(size_t p = 0; p < rep; p++, di++)
                        sd[di] = ss[si];
            }