bool array_fuzzy_equal(const auto_array<T>& lhs, const auto_array<T>& rhs, T epsi)
{
uint32_t len = std::min(lhs.length(), rhs.length());
for (uint32_t i = 0; i < len; i++) {
if (fabs(lhs.at(i) - rhs.at(i)) > epsi) {
std::cout << "not fuzzy equal at index: " << i
<< " lhs: " << lhs.at(i) << " rhs: " << rhs.at(i)
<< " delta: " << fabs(lhs.at(i) - rhs.at(i))
<< " epsilon: "<< epsi << std::endl;
return false;
}
}
return true;
}
long
cubeb_resampler_speex::fill(void * input_buffer, void * output_buffer, long frames_needed)
{
// Use more input frames than strictly necessary, so in the worst case,
// we have leftover unresampled frames at the end, that we can use
// during the next iteration.
assert(frames_needed <= buffer_frame_count);
long before_resampling = frame_count_at_rate(frames_needed, resampling_ratio);
long frames_requested = before_resampling - leftover_frame_count;
// Copy the previous leftover frames to the front of the buffer.
size_t leftover_bytes = frames_to_bytes(stream_params, leftover_frame_count);
memcpy(resampling_src_buffer.get(), leftover_frames_buffer.get(), leftover_bytes);
uint8_t * buffer_start = resampling_src_buffer.get() + leftover_bytes;
long got = data_callback(stream, user_ptr, NULL, buffer_start, frames_requested);
assert(got <= frames_requested);
if (got < 0) {
return CUBEB_ERROR;
}
uint32_t in_frames = leftover_frame_count + got;
uint32_t out_frames = frames_needed;
uint32_t old_in_frames = in_frames;
if (stream_params.format == CUBEB_SAMPLE_FLOAT32NE) {
float * in_buffer = reinterpret_cast<float *>(resampling_src_buffer.get());
float * out_buffer = reinterpret_cast<float *>(output_buffer);
speex_resampler_process_interleaved_float(speex_resampler, in_buffer, &in_frames,
out_buffer, &out_frames);
} else {
short * in_buffer = reinterpret_cast<short *>(resampling_src_buffer.get());
short * out_buffer = reinterpret_cast<short *>(output_buffer);
speex_resampler_process_interleaved_int(speex_resampler, in_buffer, &in_frames,
out_buffer, &out_frames);
}
// Copy the leftover frames to buffer for the next time.
leftover_frame_count = old_in_frames - in_frames;
assert(leftover_frame_count <= leftover_frame_size);
size_t unresampled_bytes = frames_to_bytes(stream_params, leftover_frame_count);
uint8_t * leftover_frames_start = resampling_src_buffer.get();
leftover_frames_start += frames_to_bytes(stream_params, in_frames);
memcpy(leftover_frames_buffer.get(), leftover_frames_start, unresampled_bytes);
return out_frames;
}
auto_array(auto_array<T> & value)
: ptr(value.ptr), count(value.count)
{
value.release();
}
auto_array(auto_array& other) : ptr_(other.release()) {}
auto_array(auto_array &source)
: super(source)
{ source.invalidate(); }
