internal int opus_multistream_encode_native <T>
(
opus_copy_channel_in_func <T> copy_channel_in,
T[] pcm,
int pcm_ptr,
int analysis_frame_size,
byte[] data,
int data_ptr,
int max_data_bytes,
int lsb_depth,
Downmix.downmix_func <T> downmix,
int float_api
)
{
int Fs;
int s;
int encoder_ptr;
int tot_size;
short[] buf;
int[] bandSMR;
byte[] tmp_data = new byte[MS_FRAME_TMP];
OpusRepacketizer rp = new OpusRepacketizer();
int vbr;
CeltMode celt_mode;
int[] bitrates = new int[256];
int[] bandLogE = new int[42];
int[] mem = null;
int[] preemph_mem = null;
int frame_size;
int rate_sum;
int smallest_packet;
if (this.surround != 0)
{
preemph_mem = this.preemph_mem;
mem = this.window_mem;
}
encoder_ptr = 0;
Fs = this.encoders[encoder_ptr].SampleRate;
vbr = this.encoders[encoder_ptr].UseVBR ? 1 : 0;
celt_mode = this.encoders[encoder_ptr].GetCeltMode();
{
int delay_compensation;
int channels;
channels = this.layout.nb_streams + this.layout.nb_coupled_streams;
delay_compensation = this.encoders[encoder_ptr].Lookahead;
delay_compensation -= Fs / 400;
frame_size = CodecHelpers.compute_frame_size(pcm, pcm_ptr, analysis_frame_size,
this.variable_duration, channels, Fs, this.bitrate_bps,
delay_compensation, downmix, this.subframe_mem, this.encoders[encoder_ptr].analysis.enabled);
}
if (400 * frame_size < Fs)
{
return(OpusError.OPUS_BAD_ARG);
}
/* Validate frame_size before using it to allocate stack space.
* This mirrors the checks in opus_encode[_float](). */
if (400 * frame_size != Fs && 200 * frame_size != Fs &&
100 * frame_size != Fs && 50 * frame_size != Fs &&
25 * frame_size != Fs && 50 * frame_size != 3 * Fs)
{
return(OpusError.OPUS_BAD_ARG);
}
/* Smallest packet the encoder can produce. */
smallest_packet = this.layout.nb_streams * 2 - 1;
if (max_data_bytes < smallest_packet)
{
return(OpusError.OPUS_BUFFER_TOO_SMALL);
}
buf = new short[2 * frame_size];
bandSMR = new int[21 * this.layout.nb_channels];
if (this.surround != 0)
{
surround_analysis(celt_mode, pcm, pcm_ptr, bandSMR, mem, preemph_mem, frame_size, 120, this.layout.nb_channels, Fs, copy_channel_in);
}
/* Compute bitrate allocation between streams (this could be a lot better) */
rate_sum = surround_rate_allocation(bitrates, frame_size);
if (vbr == 0)
{
if (this.bitrate_bps == OpusConstants.OPUS_AUTO)
{
max_data_bytes = Inlines.IMIN(max_data_bytes, 3 * rate_sum / (3 * 8 * Fs / frame_size));
}
else if (this.bitrate_bps != OpusConstants.OPUS_BITRATE_MAX)
{
max_data_bytes = Inlines.IMIN(max_data_bytes, Inlines.IMAX(smallest_packet,
3 * this.bitrate_bps / (3 * 8 * Fs / frame_size)));
}
}
for (s = 0; s < this.layout.nb_streams; s++)
{
OpusEncoder enc = this.encoders[encoder_ptr];
encoder_ptr += 1;
enc.Bitrate = (bitrates[s]);
if (this.surround != 0)
{
int equiv_rate;
equiv_rate = this.bitrate_bps;
if (frame_size * 50 < Fs)
{
equiv_rate -= 60 * (Fs / frame_size - 50) * this.layout.nb_channels;
}
if (equiv_rate > 10000 * this.layout.nb_channels)
{
enc.Bandwidth = (OpusBandwidth.OPUS_BANDWIDTH_FULLBAND);
}
else if (equiv_rate > 7000 * this.layout.nb_channels)
{
enc.Bandwidth = (OpusBandwidth.OPUS_BANDWIDTH_SUPERWIDEBAND);
}
else if (equiv_rate > 5000 * this.layout.nb_channels)
{
enc.Bandwidth = (OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND);
}
else
{
enc.Bandwidth = (OpusBandwidth.OPUS_BANDWIDTH_NARROWBAND);
}
if (s < this.layout.nb_coupled_streams)
{
/* To preserve the spatial image, force stereo CELT on coupled streams */
enc.ForceMode = (OpusMode.MODE_CELT_ONLY);
enc.ForceChannels = (2);
}
}
}
encoder_ptr = 0;
/* Counting ToC */
tot_size = 0;
for (s = 0; s < this.layout.nb_streams; s++)
{
OpusEncoder enc;
int len;
int curr_max;
int c1, c2;
rp.Reset();
enc = this.encoders[encoder_ptr];
if (s < this.layout.nb_coupled_streams)
{
int i;
int left, right;
left = OpusMultistream.get_left_channel(this.layout, s, -1);
right = OpusMultistream.get_right_channel(this.layout, s, -1);
copy_channel_in(buf, 0, 2,
pcm, pcm_ptr, this.layout.nb_channels, left, frame_size);
copy_channel_in(buf, 1, 2,
pcm, pcm_ptr, this.layout.nb_channels, right, frame_size);
encoder_ptr += 1;
if (this.surround != 0)
{
for (i = 0; i < 21; i++)
{
bandLogE[i] = bandSMR[21 * left + i];
bandLogE[21 + i] = bandSMR[21 * right + i];
}
}
c1 = left;
c2 = right;
}
else
{
int i;
int chan = OpusMultistream.get_mono_channel(this.layout, s, -1);
copy_channel_in(buf, 0, 1,
pcm, pcm_ptr, this.layout.nb_channels, chan, frame_size);
encoder_ptr += 1;
if (this.surround != 0)
{
for (i = 0; i < 21; i++)
{
bandLogE[i] = bandSMR[21 * chan + i];
}
}
c1 = chan;
c2 = -1;
}
if (this.surround != 0)
{
enc.SetEnergyMask(bandLogE);
}
/* number of bytes left (+Toc) */
curr_max = max_data_bytes - tot_size;
/* Reserve one byte for the last stream and two for the others */
curr_max -= Inlines.IMAX(0, 2 * (this.layout.nb_streams - s - 1) - 1);
curr_max = Inlines.IMIN(curr_max, MS_FRAME_TMP);
/* Repacketizer will add one or two bytes for self-delimited frames */
if (s != this.layout.nb_streams - 1)
{
curr_max -= curr_max > 253 ? 2 : 1;
}
if (vbr == 0 && s == this.layout.nb_streams - 1)
{
enc.Bitrate = (curr_max * (8 * Fs / frame_size));
}
len = enc.opus_encode_native(buf, 0, frame_size, tmp_data, 0, curr_max, lsb_depth,
pcm, pcm_ptr, analysis_frame_size, c1, c2, this.layout.nb_channels, downmix, float_api);
if (len < 0)
{
return(len);
}
/* We need to use the repacketizer to add the self-delimiting lengths
* while taking into account the fact that the encoder can now return
* more than one frame at a time (e.g. 60 ms CELT-only) */
rp.AddPacket(tmp_data, 0, len);
len = rp.opus_repacketizer_out_range_impl(0, rp.GetNumFrames(),
data, data_ptr, max_data_bytes - tot_size, (s != this.layout.nb_streams - 1) ? 1 : 0, (vbr == 0 && s == this.layout.nb_streams - 1) ? 1 : 0);
data_ptr += len;
tot_size += len;
}
return(tot_size);
}