void simple_envelope::process(unsigned int buf_size, sample &in, sample &CV, bool smooth)
{
  // a bit of a crap filter to smooth clicks
  static float SMOOTH = 0.999;
  static float ONEMINUS_SMOOTH = 1-SMOOTH;
  float one_over_decay=1/m_decay;
  float temp=0;

  if (m_t==-1000)
    {
      in.zero();
      CV.zero();
      m_current=0;
      return;
    }

  for (unsigned int n=0; n<buf_size; n++)
    {
      // if we are in the delay (before really being triggered)
      if (m_t<0)
	{
	  in[n]*=m_current;
	  CV[n]=m_current;
	}
      else // in the envelope
	{
	  // if we are in the envelope...
	  if (m_t<m_decay)
	    {
	      // in the decay
	      temp=(1-m_t*one_over_decay)*m_volume;
	      if (!feq(temp,m_current,0.01) && smooth)
		{
		  // only filter if necc
		  temp=(temp*ONEMINUS_SMOOTH+m_current*SMOOTH);
		}
	      in[n]*=temp;
	      CV[n]=temp;
	      m_current=temp;
	    }
	  else
	    {
	      in[n]*=0;
	      CV[n]=0;
	      m_current=0;

	      // we've run off the end
	      m_t=-1000;
	    }
	}

      m_t+=m_sample_time;
    }
}

void sample :: append(const sample& s) {
	if (!assertWarning(rate() == s.rate(), "append failed: different rates") ||
		!assertWarning(channels() == s.channels(),
			"append failed: different channel counts"))
		return;
	audioSample* snd = new audioSample[audioSize() + s.audioSize()];
	memcpy(snd, data, bytes());
	memcpy(snd + audioSize(), s.data, s.bytes());
	delete[] data;
	data = snd;
	info.length += s.length();
} // append()

void sample :: paste(const sample& clip, int start, bool replaceFlag) {
	if (!assertWarning(rate() == clip.rate(),"paste failed: different rates") ||
		!assertWarning(channels() == clip.channels(),
			"paste failed: different channel counts"))
		return;
	int limit = clip.length();
	if (start + limit > length())
		limit = length() - start;
	if (replaceFlag)
		memcpy(data+start*channels(), clip.data,
				limit * channels() * sizeof(audioSample));
	else
		for (int i = 0; i < limit * channels(); i++, start++)
			data[start] = audioLimit(clip.data[i] + data[start]);
} // paste()

int sample :: diff(const sample& t) const {
	if (!assertWarning(rate() == t.rate(),"diff: sample rates") ||
		!assertWarning(length() == t.length(),"diff: different lengths") ||
		!assertWarning(channels() == t.channels(), "diff: channel counts"))
		return 1;
	int diffs = 0;
	for (int i=0; (i<audioSize()) && (diffs<10); i++)
		if (data[i] != t.data[i]) {
			if (parameters->debug("sample", "basic"))
				cerr << "Data differs at " << i << " of " << audioSize() <<endl;
			diffs++;
		}
	if (parameters->debug("sample", "basic") && !diffs)
		cerr << "No diffs" << endl;
	return diffs;
} // diffs()

    sample transition(sample& init_sample) {
        this->sample_stepsize();

        this->seed(init_sample.cont_params());

        this->hamiltonian_.sample_p(this->z_, this->rand_int_);
        this->hamiltonian_.init(this->z_);

        ps_point z_init(this->z_);

        double H0 = this->hamiltonian_.H(this->z_);

        for (int i = 0; i < L_; ++i)
            this->integrator_.evolve(this->z_, this->hamiltonian_,
                                     this->epsilon_);

        double h = this->hamiltonian_.H(this->z_);
        if (boost::math::isnan(h)) h = std::numeric_limits<double>::infinity();

        double acceptProb = std::exp(H0 - h);

        if (acceptProb < 1 && this->rand_uniform_() > acceptProb)
            this->z_.ps_point::operator=(z_init);

        acceptProb = acceptProb > 1 ? 1 : acceptProb;

        return sample(this->z_.q, - this->hamiltonian_.V(this->z_), acceptProb);
    }

void distort(sample &buf, float amount) {
  if (amount>=0.99) amount = 0.99;

  float k=2*amount/(1-amount);

  for(unsigned int i=0; i<buf.get_length(); i++)
    {
      buf[i]=((1+k)*buf[i]/(1+k*fabs(buf[i])))*(1-amount);
    }
}

void moving_distort(sample &buf, const sample &amount)
{
  for(unsigned int i=0; i<buf.get_length(); i++)
    {
      float a =fabs(amount[i]);
      if (a>0.99) a = 0.99;
      float k=2*a/(1-a);

      buf[i]=((1+k)*buf[i]/(1+k*fabs(buf[i])))*(1-a);
    }
}

void moving_hard_clip(sample &buf, const sample &level)
{
  for(unsigned int i=0; i<buf.get_length(); i++)
    {
      float l=fabs(level[i]);
      if (feq(l,0,0.0001)) l=0.0001;
      if (buf[i]>l) buf[i]=l;
      if (buf[i]<-l) buf[i]=-l;
      buf[i]*=1/l;
    }
}

void hard_clip(sample &buf, float level)
{
  if (feq(level,0,0.0001)) level==0.0001;

  for(unsigned int i=0; i<buf.get_length(); i++)
    {
      if (buf[i]>level) buf[i]=level;
      if (buf[i]<-level) buf[i]=-level;
      buf[i]*=1/level;
    }
}

void test_sample_is_empty(const sample &sam, bool is_empty)
{
    assert(sam.empty() == is_empty);
    cout << " Testing empty() of: " << sam;
    if(is_empty){
        cout << " is true";
    } else {
        cout << " is false";
    }
    cout << endl;
    
}

        void connection::notify_listeners(const sample& sample)
        {
            switch(sample.getType())
            {
            case sample_type::new_frame:
                notify_listeners_about_new_frame();
                break;

            case sample_type::allocation:
                notify_listeners_about_allocation(sample);
                break;
            }
        }

void crush(sample &buf, float freq, float bits) {
  float step = pow((float)0.5,(float)bits);
  float phasor = 1;
  float last = 0;

  for(unsigned int i=0; i<buf.get_length(); i++) {
      phasor = phasor + freq;
      if (phasor >= 1.0) {
          phasor = phasor - 1.0;
          last = step * floor( buf[i]/step + 0.5 );
	}
      buf[i] = last;
    }
}

sample operator-(sample a, sample b)
{
    return sample{a.value() - b.value()};
}

sample sample::operator*(sample other) const
{
    sample result;
    result.value_ = value() * other.value(); // can't overflow
    return result;
}

//Sample Tests
void test_sample_size(const sample &sam, uint size)
{
    vector<double> data(sam.get_data());
    assert(data.size() == size);
    cout << " Testing size() of: " << sam << " is " << size << "(" << data.size() << ")" << endl;
}

sample interpolate(sample a, sample weight, sample b)
{
    return sample{(1 - weight.value()) * a.value() + weight.value() * b.value()};
}

void test_sample_max(const sample &sam, double max)
{
    double epsilon = 0.0001;
    assert(abs(sam.maximum() - max) < epsilon);
    cout << " Testing maximum() of: " << sam << " is " << max << "(" << sam.maximum() << ")" << endl;
}

static color32::byte to_byte(sample s) noexcept
{
    return static_cast<color32::byte>(color32::BYTE_MAX * s.value());
}

 sample transition(sample& init_sample) {
   this->seed(init_sample.cont_params(), init_sample.disc_params());
   return sample(this->_z.q, this->_z.r, - this->_hamiltonian.V(this->_z), 0);
 }

void test_sample_midrange(const sample &sam, double midrange)
{
    double epsilon = 0.0001;
    assert(abs(sam.midrange() - midrange) < epsilon);
    cout << " Testing midrange() of: " << sam << " is " << midrange << "(" << sam.midrange() << ")" << endl;
}