C++ AudioChunk::start方法代码示例

void Splicer::pull(AudioChunk &chunk)
{
	Uint32 left = chunk.length(), chans = chunk.format().channels;

	Sint32 *data[PG_MAX_CHANNELS];
	for (Uint32 i = 0; i < chans; ++i) data[i] = chunk.start(i);

	//Query exhausted each loop to refresh the value of "current".
	while (!exhausted())
	{
		//Pull data from next stream
		AudioChunk sub(chunk.scratch(), output, data, left, chunk.sync);
		current->pull(sub);

		//Partial advance
		if (current->exhausted())
		{
			Uint32 cut = sub.cutoff();
			for (Uint32 i = 0; i < chans; ++i) data[i] += cut;
			left -= cut;
			current = NULL;
			if (left) continue;
		}
		return;
	}

	//The Splicer is exhausted!
	chunk.cutoff(data[0] - chunk.start(0));
}

			virtual void pull(AudioChunk &chunk)
			{
				if (!chunk.length())   return;
				if (!valid || finished) {chunk.silence(); return;}

				int samples, have = 0, need = chunk.length();

				//Create pointers to 16-bit data
				short *d16[PG_MAX_CHANNELS];
				for (Uint32 i = 0; i < chunk.format().channels; ++i)
					d16[i] = (short*) chunk.start(i);

				while (true)
				{
					samples = stb_vorbis_get_samples_short(ogg,
						chunk.format().channels, d16, (need-have));

					if (samples < 0)
					{
						finished = true;
						//cout << " VORBIS ERROR" << endl;
						break;
					}
					if (samples == 0)
					{
						//File's end
						if (loop)
						{
							stb_vorbis_seek_start(ogg);
							continue;
						}
						else
						{
							finished = true;
							break;
						}
					}

					for (Uint32 i=0; i < chunk.format().channels; ++i)
						d16[i] += samples;
					have += samples;
					//if (have > need) cout << "VORBIS OVERDRAW" << endl;

					//std::cout << "OGG pull: " << have << "/" << need << std::endl;

					if (have >= need) break;
				}

				//Cutoff marker if necessary
				if (have < need) chunk.cutoff(have);

				//Upsample data to 24-bit Sint32s
				for (Uint32 i=0; i < chunk.format().channels; ++i)
				{
					Sint32 *start = chunk.start(i), *op = start + have;
					short *ip = d16[i];
					while (op!=start) {*(--op) = 256 * Sint32(*(--ip));}
				}
			}

		virtual void pull(AudioChunk &chunk)
		{
			//This is possible at startup; race conditions are bad.
			if (!back) chunk.silence();

			//Shorthand.
			Uint32 frame = back->mikeFrame, length = back->mikeLength;
			const Sint32 *data = back->mikeData;

			//How much information is available?
			if (readFrame != frame) {readFrame = frame; prog = 0;}
			Uint32 want = chunk.length(), get = std::min(length-prog, want);

			//Read what we can from the buffer
			std::memcpy((void*)chunk.start(0), (const void*)(data+prog), 4*get);
			prog += get;

			//Fill your cup too full and it will spill...
			if (get < want)
				std::memset((void*)(chunk.start(0)+get), 0, 4*(want-get));
		}

void Bandpass::pull(AudioChunk &chunk,
	const Bandpass_Node &a, const Bandpass_Node &b)
{
	//Pull source data
	source.pull(chunk);

	//Calculate RC multipliers
	float
		al = RCCONV / ((a.low<=0.0f)?40000.0f:a.low),
		ah = RCCONV / ((a.high<=0.0f)?10.0f:a.high),
		bl = RCCONV / ((b.low<=0.0f)?40000.0f:b.low),
		bh = RCCONV / ((b.high<=0.0f)?10.0f:b.high);
	float lpRC = al, hpRC = ah,
		lpM = pow(bl/al, 1.0f / float(chunk.length())),
		hpM = pow(bh/ah, 1.0f / float(chunk.length())),
		lpA, hpA, samp,
		dt = 1.0f / float(chunk.format().rate);

	//Apply effect!
	Uint32 chan = source.format().channels;

	for (Uint32 i = 0; i < chan; ++i)
	{
		Sint32 *pos = chunk.start(i), *end = chunk.end(i);
		float &lpPc = lpP[i], &hpDc = hpD[i];
		while (pos < end)
		{
			//Interpolate settings
			lpA = dt   / (lpRC + dt); lpRC *= lpM;
			hpA = hpRC / (hpRC + dt); hpRC *= hpM;

			//Get samples
			samp = float(*pos);

			//Lowpass
			samp = lpPc + lpA * (samp-lpPc);
			lpPc = samp;

			//Highpass (confusing but correct)
			samp = hpA * (samp+hpDc);
			hpDc = samp - lpPc;

			//Set samples
			*pos = Sint32(samp);
			++pos;
		}
	}
}

void Oscillator::pull(AudioChunk &chunk, const State &a, const State &b)
{
	//Phase goes from -1 to 1.  Wierd?  Maybe.
	while (phase >= 1.0f) phase -= 2.0f;
	while (phase < -1.0f) phase += 2.0f;

	Sint32 samp;
	float v, x, sq;

	float step = (b.freq / output.rate) * 2.0f,
		amp = b.amp * 16777215.0f,
		ph = phase;

	Sint32 *i = chunk.start(0), *e = chunk.end(0);
	switch (type)
	{
	case SINE:
		while (i != e)
		{
			//Simple sine wave
			samp = amp*sin(PI * ph);
			ph += step;
			*i = samp; ++i;
			ph -= 2.0f*int(ph*.5f); //Restrict to [-1, 1]
		}
		break;

	case SQUARE:
		while (i != e)
		{
			samp = amp * ((ph>=0.0f) ? 1.0f : -1.0f);
			ph += step;
			*i = samp; ++i;
			ph -= 2.0f*int(ph*.5f); //Restrict to [-1, 1]
		}
		break;

	case TRIANGLE:
		while (i != e)
		{
			samp = amp * (2.0f*std::abs(ph) - 1.0f);
			ph += step;
			*i = samp; ++i;
			ph -= 2.0f*int(ph*.5f); //Restrict to [-1, 1]
		}
		break;

	case SAWTOOTH:
		while (i != e)
		{
			samp = amp * ph;
			ph += step;
			*i = samp; ++i;
			ph -= 2.0f*int(ph*.5f); //Restrict to [-1, 1]
		}
		break;

	case KLAXON:
	default:
	{
		const float PISQ = PI*PI;
		while (i != e)
		{
			//Sine wave approximation gone wrong
			sq = PISQ*ph*ph; x = PI*ph*amp;
			v = x * 1.02394347; //Makes the endpoints line up
			x *= sq; v -= x/6.0f;
			x *= sq; v += x/120.0f;
			x *= sq; v -= x/5040.0f;
			samp = x;
			ph += step;
			*i = samp; ++i;

			ph -= 2.0f*int(ph*.5f); //Restrict to [-1, 1]
		}
	}
		break;
	}

	phase = ph;

	//Copy signal into all other channels
	for (Uint32 c = chunk.channels()-1; c > 0; --c)
	{
		std::memcpy(chunk.start(c), chunk.start(0), 4*chunk.length());
	}
}