void Upsampler::test()
{
//
// Make some audio data
//
int sampleRate = 48000;
FrequencySweepAudioSource generator;
AudioSampleBuffer sourceBuffer(1, sampleRate * 2);
AudioSourceChannelInfo asi(&sourceBuffer, 0, sourceBuffer.getNumSamples());
generator.prepareToPlay(sourceBuffer.getNumSamples(), sampleRate);
generator.getNextAudioBlock(asi);
generator.releaseResources();
//
// Create the upsampler
//
int const upsampleFactor = 4;
Upsampler upsampler(sampleRate, sampleRate * upsampleFactor, 2.0);
HeapBlock<double> upsamplerInputBuffer, upsamplerOutputBuffer;
int upsamplerOutputBufferSamples = sourceBuffer.getNumSamples() * upsampleFactor * 2;
upsamplerInputBuffer.allocate(sourceBuffer.getNumSamples(), true);
upsamplerOutputBuffer.allocate(upsamplerOutputBufferSamples, true);
//
// Convert data to doubles
//
const float* source = sourceBuffer.getReadPointer(0);
for (int i = 0; i < sourceBuffer.getNumSamples(); ++i)
{
upsamplerInputBuffer[i] = source[i];
}
//
// Upsample
//
int upsampledCount = upsampler.upsample( upsamplerInputBuffer,
upsamplerOutputBuffer,
sourceBuffer.getNumSamples(),
upsamplerOutputBufferSamples);
//
// Convert upsampled data to float
//
AudioSampleBuffer finalBuffer(1, upsamplerOutputBufferSamples);
float *destination = finalBuffer.getWritePointer(0);
for (int i = 0; i < upsampledCount; ++i)
{
destination[i] = (float)upsamplerOutputBuffer[i];
}
WriteWaveFile("upsample.wav", sampleRate * upsampleFactor, &finalBuffer, upsamplerOutputBufferSamples);
}
/*
* decode une MCU pixmap RGB en lisant les MCU frequentielles correspondantes
* (de chaque composante) dans le fichier JPEG
*/
void get_RGB_MCU(uint32_t *RGB_MCU, FILE *f, scan_desc_t *scan, image_t *im,
uint16_t RI, uint8_t MCU_size[2], uint8_t QT[2][_BSIZE])
{
uint8_t *YCbCr_MCU[3] = {NULL,NULL,NULL};
for (uint32_t i = 0; i < im->nb_comp;i++) {
uint32_t nb_block = im->comp[i].echV * im->comp[i].echH;
printbody2(" Composante %u : %u bloc(s) a lire\n",
im->comp[i].ic,nb_block);
uint8_t tab_bck[_BSIZE * nb_block];
for (uint32_t j = 0; j < nb_block; j++) {
printbody2(" ├── Bloc %u :\n",j+1);
uint8_t bck[_BSIZE];
get_pixmap_block(bck,f,scan,i,im,RI,QT);
/* ajout du block dans le tableau pour sur-echant. */
for (uint32_t k = 0; k < _BSIZE; k++) {
tab_bck[_BSIZE * j + k] = bck[k];
}
}
/* sur-echantillonnage */
printbody2(" └── Upsampler...\n");
uint8_t h_factor = (MCU_size[0] / 8) / im->comp[i].echH;
uint8_t v_factor = (MCU_size[1] / 8) / im->comp[i].echV;
YCbCr_MCU[i] = calloc(MCU_size[0] * MCU_size[1],
sizeof(uint8_t *));
upsampler(tab_bck,YCbCr_MCU[i],h_factor,v_factor,MCU_size[0]/8,
MCU_size[1]/8);
}
/* conversion YCbCr vers ARGB */
printbody2(" => Conversion vers RGB...\n");
if (im->nb_comp == 3) {
YCbCr_to_ARGB(YCbCr_MCU,RGB_MCU,MCU_size[0]/8,MCU_size[1]/8);
} else if (im->nb_comp == 1) {
for (uint32_t k = 0; k < MCU_size[0]*MCU_size[1]; k++) {
RGB_MCU[k] = YCbCr_MCU[0][k]*(1+256+65536);
}
}
for (uint32_t i = 0; i < im->nb_comp;i++) {
free(YCbCr_MCU[i]);
}
}
/*
* decode une MCU pixmap RGB en lisant les MCU frequentielles correspondantes
* (de chaque composante) dans le fichier JPEG
*/
void change_RGB_MCU(uint32_t *in_RGB_MCU, uint32_t *out_RGB_MCU, image_t *im,
uint8_t MCU_size[2], uint8_t quality)
{
/* conversion ARGB vers YCbCr */
printbody2(" => Conversion vers YCbCr...\n");
uint8_t *YCbCr_MCU[3] = {NULL,NULL,NULL};
for (uint32_t i = 0; i < im->nb_comp; i++) {
YCbCr_MCU[i] = calloc(MCU_size[0] * MCU_size[1],
sizeof(uint8_t *));
}
ARGB_to_YCbCr(in_RGB_MCU,YCbCr_MCU,MCU_size[0]/8,MCU_size[1]/8);
for (uint32_t i = 0; i < im->nb_comp; i++) {
uint32_t nb_block = im->comp[i].echV * im->comp[i].echH;
printbody2(" Composante %u : %u bloc(s) a creer\n",
im->comp[i].ic,nb_block);
/* sous-echantillonnage */
printbody2(" ├── downsampler...\n");
uint8_t tab_bck[_BSIZE * nb_block];
uint8_t tab_bck2[_BSIZE * nb_block];
uint8_t h_factor = (MCU_size[0] / 8) / im->comp[i].echH;
uint8_t v_factor = (MCU_size[1] / 8) / im->comp[i].echV;
downsampler(YCbCr_MCU[i],tab_bck,h_factor,v_factor,MCU_size[0]/8,
MCU_size[1]/8);
for (uint32_t j = 0; j < nb_block; j++) {
printbody2(" ├── Bloc %u :\n",j+1);
/* extraction du bloc */
uint8_t bck[_BSIZE];
for (uint32_t k = 0; k < _BSIZE; k++) {
bck[k] = tab_bck[_BSIZE * j + k];
}
/* ENCODAGE / DECODAGE du bloc */
uint8_t bck2[_BSIZE];
change_pixmap_block(bck,bck2);
/* remplacement du bloc */
for (uint32_t k = 0; k < _BSIZE; k++) {
tab_bck2[_BSIZE * j + k] = bck2[k];
}
}
/* sur-echantillonnage */
printbody2(" └── Upsampler...\n");
YCbCr_MCU[i] = calloc(MCU_size[0] * MCU_size[1],
sizeof(uint8_t *));
upsampler(tab_bck2,YCbCr_MCU[i],h_factor,v_factor,MCU_size[0]/8,
MCU_size[1]/8);
}
/* conversion YCbCr vers ARGB */
printbody2(" => Conversion vers RGB...\n");
YCbCr_to_ARGB(YCbCr_MCU,out_RGB_MCU,MCU_size[0]/8,MCU_size[1]/8);
for (uint32_t i = 0; i < im->nb_comp; i++) {
free(YCbCr_MCU[i]);
}
}
bool Worker::operator() (const Tractography::Streamline<>& in, Tractography::Streamline<>& out) const
{
out.clear();
out.index = in.index;
out.weight = in.weight;
if (!thresholds (in)) {
// Want to test thresholds before wasting time on upsampling; but if -inverse is set,
// still need to apply both the upsampler and downsampler before writing to output
if (inverse) {
std::vector< Point<float> > tck (in);
upsampler (tck);
downsampler (tck);
tck.swap (out);
}
return true;
}
// Upsample track before mapping to ROIs
std::vector< Point<float> > tck (in);
upsampler (tck);
// Assign to ROIs
if (properties.include.size() || properties.exclude.size()) {
include_visited.assign (properties.include.size(), false);
for (std::vector< Point<float> >::const_iterator p = tck.begin(); p != tck.end(); ++p) {
properties.include.contains (*p, include_visited);
if (properties.exclude.contains (*p)) {
if (inverse) {
downsampler (tck);
tck.swap (out);
}
return true;
}
}
// Make sure all of the include regions were visited
for (std::vector<bool>::const_iterator i = include_visited.begin(); i != include_visited.end(); ++i) {
if (!*i) {
if (inverse) {
downsampler (tck);
tck.swap (out);
}
return true;
}
}
}
if (properties.mask.size()) {
// Split tck into separate tracks based on the mask
std::vector< std::vector< Point<float> > > cropped_tracks;
std::vector< Point<float> > temp;
for (std::vector< Point<float> >::const_iterator p = tck.begin(); p != tck.end(); ++p) {
const bool contains = properties.mask.contains (*p);
if (contains == inverse) {
if (temp.size() >= 2)
cropped_tracks.push_back (temp);
temp.clear();
} else {
temp.push_back (*p);
}
}
if (temp.size() >= 2)
cropped_tracks.push_back (temp);
if (cropped_tracks.empty())
return true;
// Apply downsampler independently to each
for (std::vector< std::vector< Point<float> > >::iterator i = cropped_tracks.begin(); i != cropped_tracks.end(); ++i)
downsampler (*i);
if (cropped_tracks.size() == 1) {
cropped_tracks[0].swap (out);
return true;
}
// Stitch back together in preparation for sending down queue as a single track
out.push_back (Point<float>());
for (std::vector< std::vector< Point<float> > >::const_iterator i = cropped_tracks.begin(); i != cropped_tracks.end(); ++i) {
for (std::vector< Point<float> >::const_iterator p = i->begin(); p != i->end(); ++p)
out.push_back (*p);
out.push_back (Point<float>());
}
out.push_back (Point<float>());
return true;
} else {
if (!inverse) {
downsampler (tck);
tck.swap (out);
}
return true;
}
}
