public virtual int synth_1to1_mono_ptr <X>(
MPGLib.mpstr_tag mp,
float[] @in,
int inPos,
X[] @out,
MPGLib.ProcessedBytes p,
Decode.Factory <X> tFactory)
{
return(outerInstance.decode.synth_1to1_mono(mp, @in, inPos, @out, p, tFactory));
}
public virtual int synth_1to1_ptr(
MPGLib.mpstr_tag mp,
float[] @in,
int inPos,
int i,
T[] @out,
MPGLib.ProcessedBytes p,
Decode.Factory <T> tFactory)
{
return(outerInstance.decode.synth_1to1_unclipped(mp, @in, inPos, i, @out, p, tFactory));
}
public virtual int decode <X>(
mpstr_tag mp,
byte[] @in,
int bufferPos,
int isize,
X[] @out,
int osize,
ProcessedBytes done,
Decode.Factory <X> tFactory)
{
return(outerInstance.interf.decodeMP3(mp, @in, bufferPos, isize, @out, osize, done, tFactory));
}
internal ISynthAnonymousInnerClass(
Interface outerInstance,
MPGLib.mpstr_tag mp,
byte[] @in,
T[] @out,
Decode.Factory <T> tFactory)
{
this.outerInstance = outerInstance;
this.mp = mp;
this.@in = @in;
this.@out = @out;
this.tFactory = tFactory;
}
internal virtual int do_layer1 <T>(
MPGLib.mpstr_tag mp,
T[] pcm_sample,
MPGLib.ProcessedBytes pcm_point,
Decode.Factory <T> tFactory)
{
var clip = 0;
var balloc = new int[2 * MPG123.SBLIMIT];
var scale_index = new int[2 * MPG123.SBLIMIT];
var fraction = Arrays.ReturnRectangularArray <float>(2, MPG123.SBLIMIT);
var fr = mp.fr;
int i, stereo = fr.stereo;
var single = fr.single;
fr.jsbound = fr.mode == MPG123.MPG_MD_JOINT_STEREO ? (fr.mode_ext << 2) + 4 : 32;
if (stereo == 1 || single == 3)
{
single = 0;
}
I_step_one(mp, balloc, scale_index, fr);
for (i = 0; i < MPG123.SCALE_BLOCK; i++)
{
I_step_two(mp, fraction, balloc, scale_index, fr);
if (single >= 0)
{
clip += decode.synth_1to1_mono(mp, fraction[single], 0, pcm_sample, pcm_point, tFactory);
}
else
{
var p1 = new MPGLib.ProcessedBytes();
p1.pb = pcm_point.pb;
clip += decode.synth_1to1(mp, fraction[0], 0, 0, pcm_sample, p1, tFactory);
clip += decode.synth_1to1(mp, fraction[1], 0, 1, pcm_sample, pcm_point, tFactory);
}
}
return(clip);
}
internal virtual int decodeMP3 <T>(
MPGLib.mpstr_tag mp,
byte[] @in,
int bufferPos,
int isize,
T[] @out,
int osize,
MPGLib.ProcessedBytes done,
Decode.Factory <T> tFactory)
{
if (osize < 2304)
{
Console.WriteLine("hip: Insufficient memory for decoding buffer %d\n", osize);
return(MPGLib.MP3_ERR);
}
/* passing pointers to the functions which clip the samples */
ISynth synth = new ISynthAnonymousInnerClass <T>(this, mp, @in, @out, tFactory);
return(decodeMP3_clipchoice(mp, @in, bufferPos, isize, @out, done, synth, tFactory));
}
internal virtual int decodeMP3 <T>(
MPGLib.mpstr_tag mp,
byte[] @in,
int bufferPos,
int isize,
T[] @out,
int osize,
MPGLib.ProcessedBytes done,
Decode.Factory <T> tFactory,
bool seek)
{
if (osize < 2304)
{
return(MPGLib.MP3_ERR);
}
/* passing pointers to the functions which clip the samples */
ISynth <T> synth = new ISynthAnonymousInnerClass <T>(this, mp, @in, @out, tFactory);
return(decodeMP3_clipchoice(mp, @in, bufferPos, isize, @out, done, synth, tFactory, seek));
}
internal virtual int decodeMP3_unclipped <T>(
MPGLib.mpstr_tag mp,
byte[] @in,
int bufferPos,
int isize,
T[] @out,
int osize,
MPGLib.ProcessedBytes done,
Decode.Factory <T> tFactory)
{
/* we forbid input with more than 1152 samples per channel for output in unclipped mode */
if (osize < 1152 * 2)
{
Console.WriteLine("hip: out space too small for unclipped mode\n");
return(MPGLib.MP3_ERR);
}
ISynth synth = new ISynthAnonymousInnerClass2 <T>(this, mp, @in, @out, tFactory);
/* passing pointers to the functions which don't clip the samples */
return(decodeMP3_clipchoice(mp, @in, bufferPos, isize, @out, done, synth, tFactory));
}
/*
* For lame_decode: return code
* -1 error
* 0 ok, but need more data before outputing any samples
* n number of samples output. either 576 or 1152 depending on MP3 file.
*/
private int decode1_headersB_clipchoice <T>(
mpstr_tag pmp,
byte[] buffer,
int bufferPos,
int len,
T[] pcm_l,
int pcm_lPos,
T[] pcm_r,
int pcm_rPos,
MP3Data mp3data,
Enc enc,
T[] p,
int psize,
IDecoder decodeMP3_ptr,
Decode.Factory <T> tFactory)
{
int processed_samples; // processed samples per channel
int ret;
mp3data.header_parsed = false;
var pb = new ProcessedBytes();
ret = decodeMP3_ptr.decode(pmp, buffer, bufferPos, len, p, psize, pb, tFactory);
processed_samples = pb.pb;
/* three cases:
* 1. headers parsed, but data not complete
* pmp.header_parsed==1
* pmp.framesize=0
* pmp.fsizeold=size of last frame, or 0 if this is first frame
*
* 2. headers, data parsed, but ancillary data not complete
* pmp.header_parsed==1
* pmp.framesize=size of frame
* pmp.fsizeold=size of last frame, or 0 if this is first frame
*
* 3. frame fully decoded:
* pmp.header_parsed==0
* pmp.framesize=0
* pmp.fsizeold=size of frame (which is now the last frame)
*
*/
if (pmp.header_parsed || pmp.fsizeold > 0 || pmp.framesize > 0)
{
mp3data.header_parsed = true;
mp3data.stereo = pmp.fr.stereo;
mp3data.samplerate = Common.freqs[pmp.fr.sampling_frequency];
mp3data.mode = pmp.fr.mode;
mp3data.mode_ext = pmp.fr.mode_ext;
mp3data.framesize = smpls[pmp.fr.lsf][pmp.fr.lay];
/* free format, we need the entire frame before we can determine
* the bitrate. If we haven't gotten the entire frame, bitrate=0 */
if (pmp.fsizeold > 0) // works for free format and fixed, no overrun, temporal results are < 400.e6
{
mp3data.bitrate =
(int)(8 * (4 + pmp.fsizeold) * mp3data.samplerate / (1000 * mp3data.framesize) + 0.5);
}
else if (pmp.framesize > 0)
{
mp3data.bitrate =
(int)(8 * (4 + pmp.framesize) * mp3data.samplerate / (1000 * mp3data.framesize) + 0.5);
}
else
{
mp3data.bitrate = Common.tabsel_123[pmp.fr.lsf][pmp.fr.lay - 1][pmp.fr.bitrate_index];
}
if (pmp.num_frames > 0)
{
/* Xing VBR header found and num_frames was set */
mp3data.totalframes = pmp.num_frames;
mp3data.nsamp = mp3data.framesize * pmp.num_frames;
enc.enc_delay = pmp.enc_delay;
enc.enc_padding = pmp.enc_padding;
}
}
switch (ret)
{
case MP3_OK:
switch (pmp.fr.stereo)
{
case 1:
COPY_MONO(pcm_l, pcm_lPos, processed_samples, p);
break;
case 2:
processed_samples = processed_samples >> 1;
COPY_STEREO(pcm_l, pcm_lPos, pcm_r, pcm_rPos, processed_samples, p);
break;
default:
processed_samples = -1;
Debug.Assert(false);
break;
}
break;
case MP3_NEED_MORE:
processed_samples = 0;
break;
case MP3_ERR:
processed_samples = -1;
break;
default:
processed_samples = -1;
Debug.Assert(false);
break;
}
/*fprintf(stderr,"ok, more, err: %i %i %i\n", MP3_OK, MP3_NEED_MORE, MP3_ERR ); */
/*fprintf(stderr,"ret = %i out=%i\n", ret, processed_samples ); */
return(processed_samples);
}
internal virtual int decodeMP3_clipchoice <T>(
MPGLib.mpstr_tag mp,
byte[] @in,
int inPos,
int isize,
T[] @out,
MPGLib.ProcessedBytes done,
ISynth synth,
Decode.Factory <T> tFactory)
{
int i, iret, bits, bytes;
if (@in != null && isize != 0 && addbuf(mp, @in, inPos, isize) == null)
{
return(MPGLib.MP3_ERR);
}
/* First decode header */
if (!mp.header_parsed)
{
if (mp.fsizeold == -1 || mp.sync_bitstream != 0)
{
int vbrbytes;
mp.sync_bitstream = 0;
/* This is the very first call. sync with anything */
/* bytes= number of bytes before header */
bytes = sync_buffer(mp, false);
/* now look for Xing VBR header */
if (mp.bsize >= bytes + XING_HEADER_SIZE)
{
vbrbytes = check_vbr_header(mp, bytes);
}
else
{
return(MPGLib.MP3_NEED_MORE);
}
if (mp.vbr_header)
{
/* do we have enough data to parse entire Xing header? */
if (bytes + vbrbytes > mp.bsize)
{
return(MPGLib.MP3_NEED_MORE);
}
/* read in Xing header. Buffer data in case it
* is used by a non zero main_data_begin for the next
* frame, but otherwise dont decode Xing header */
// #ifdef HIP_DEBUG
// fprintf(stderr, "hip: found xing header, skipping %i bytes\n", vbrbytes + bytes);
// #endif
for (i = 0; i < vbrbytes + bytes; ++i)
{
read_buf_byte(mp);
}
/* now we need to find another syncword */
/* just return and make user send in more data */
return(MPGLib.MP3_NEED_MORE);
}
}
else
{
/* match channels, samplerate, etc, when syncing */
bytes = sync_buffer(mp, true);
}
/* buffer now synchronized */
if (bytes < 0)
{
return(MPGLib.MP3_NEED_MORE);
}
if (bytes > 0)
{
/* there were some extra bytes in front of header.
* bitstream problem, but we are now resynced
* should try to buffer previous data in case new
* frame has nonzero main_data_begin, but we need
* to make sure we do not overflow buffer
*/
int size;
Console.WriteLine("hip: bitstream problem, resyncing skipping %d bytes...\n", bytes);
mp.old_free_format = false;
/* FIXME: correct ??? */
mp.sync_bitstream = 1;
/* skip some bytes, buffer the rest */
size = mp.wordpointerPos - 512;
if (size > MPG123.MAXFRAMESIZE)
{
/* wordpointer buffer is trashed. probably cant recover, but try anyway */
Console.WriteLine(
"hip: wordpointer trashed. size=%i (%i) bytes=%i \n",
size,
MPG123.MAXFRAMESIZE,
bytes);
size = 0;
mp.wordpointer = mp.bsspace[mp.bsnum];
mp.wordpointerPos = 512;
}
/* buffer contains 'size' data right now
* we want to add 'bytes' worth of data, but do not
* exceed MAXFRAMESIZE, so we through away 'i' bytes */
i = size + bytes - MPG123.MAXFRAMESIZE;
for (; i > 0; --i)
{
--bytes;
read_buf_byte(mp);
}
copy_mp(mp, bytes, mp.wordpointer, mp.wordpointerPos);
mp.fsizeold += bytes;
}
read_head(mp);
common.decode_header(mp.fr, mp.header);
mp.header_parsed = true;
mp.framesize = mp.fr.framesize;
mp.free_format = mp.framesize == 0;
if (mp.fr.lsf != 0)
{
mp.ssize = mp.fr.stereo == 1 ? 9 : 17;
}
else
{
mp.ssize = mp.fr.stereo == 1 ? 17 : 32;
}
if (mp.fr.error_protection)
{
mp.ssize += 2;
}
mp.bsnum = 1 - mp.bsnum; // toggle buffer
mp.wordpointer = mp.bsspace[mp.bsnum];
mp.wordpointerPos = 512;
mp.bitindex = 0;
/* for very first header, never parse rest of data */
if (mp.fsizeold == -1)
{
return(MPGLib.MP3_NEED_MORE);
}
} // end of header parsing block
/* now decode side information */
if (!mp.side_parsed)
{
/* Layer 3 only */
if (mp.fr.lay == 3)
{
if (mp.bsize < mp.ssize)
{
return(MPGLib.MP3_NEED_MORE);
}
copy_mp(mp, mp.ssize, mp.wordpointer, mp.wordpointerPos);
if (mp.fr.error_protection)
{
common.getbits(mp, 16);
}
bits = layer3.do_layer3_sideinfo(mp);
/* bits = actual number of bits needed to parse this frame */
/* can be negative, if all bits needed are in the reservoir */
if (bits < 0)
{
bits = 0;
}
/* read just as many bytes as necessary before decoding */
mp.dsize = (bits + 7) / 8;
// #ifdef HIP_DEBUG
// fprintf(stderr,
// "hip: %d bits needed to parse layer III frame, number of bytes to read before decoding dsize = %d\n",
// bits, mp.dsize);
// #endif
/* this will force mpglib to read entire frame before decoding */
/* mp.dsize= mp.framesize - mp.ssize; */
}
else
{
/* Layers 1 and 2 */
/* check if there is enough input data */
if (mp.fr.framesize > mp.bsize)
{
return(MPGLib.MP3_NEED_MORE);
}
/* takes care that the right amount of data is copied into wordpointer */
mp.dsize = mp.fr.framesize;
mp.ssize = 0;
}
mp.side_parsed = true;
}
/* now decode main data */
iret = MPGLib.MP3_NEED_MORE;
if (!mp.data_parsed)
{
if (mp.dsize > mp.bsize)
{
return(MPGLib.MP3_NEED_MORE);
}
copy_mp(mp, mp.dsize, mp.wordpointer, mp.wordpointerPos);
done.pb = 0;
/*do_layer3(&mp.fr,(unsigned char *) out,done); */
switch (mp.fr.lay)
{
case 1:
if (mp.fr.error_protection)
{
common.getbits(mp, 16);
}
layer1.do_layer1(mp, @out, done, tFactory);
break;
case 2:
if (mp.fr.error_protection)
{
common.getbits(mp, 16);
}
layer2.do_layer2(mp, @out, done, synth, tFactory);
break;
case 3:
layer3.do_layer3(mp, @out, done, synth, tFactory);
break;
default:
Console.WriteLine("hip: invalid layer %d\n", mp.fr.lay);
break;
}
mp.wordpointer = mp.bsspace[mp.bsnum];
mp.wordpointerPos = 512 + mp.ssize + mp.dsize;
mp.data_parsed = true;
iret = MPGLib.MP3_OK;
}
/* remaining bits are ancillary data, or reservoir for next frame
* If free format, scan stream looking for next frame to determine
* mp.framesize */
if (mp.free_format)
{
if (mp.old_free_format)
{
/* free format. bitrate must not vary */
mp.framesize = mp.fsizeold_nopadding + mp.fr.padding;
}
else
{
bytes = sync_buffer(mp, true);
if (bytes < 0)
{
return(iret);
}
mp.framesize = bytes + mp.ssize + mp.dsize;
mp.fsizeold_nopadding = mp.framesize - mp.fr.padding;
/*
* fprintf(stderr,"hip: freeformat bitstream: estimated bitrate=%ikbs \n",
* 8*(4+mp.framesize)*freqs[mp.fr.sampling_frequency]/
* (1000*576*(2-mp.fr.lsf)));
*/
}
}
/* buffer the ancillary data and reservoir for next frame */
bytes = mp.framesize - (mp.ssize + mp.dsize);
if (bytes > mp.bsize)
{
return(iret);
}
if (bytes > 0)
{
int size;
copy_mp(mp, bytes, mp.wordpointer, mp.wordpointerPos);
mp.wordpointerPos += bytes;
size = mp.wordpointerPos - 512;
if (size > MPG123.MAXFRAMESIZE)
{
Console.WriteLine("hip: fatal error. MAXFRAMESIZE not large enough.\n");
}
}
/* the above frame is completely parsed. start looking for next frame */
mp.fsizeold = mp.framesize;
mp.old_free_format = mp.free_format;
mp.framesize = 0;
mp.header_parsed = false;
mp.side_parsed = false;
mp.data_parsed = false;
return(iret);
}
