void *ph_speexwb_dec_init(void *dummy)
{
return ph_speex_dec_init(speex_lib_get_mode(SPEEX_MODEID_WB));
}
void *ph_speexnb_enc_init(void *dummy)
{
return ph_speex_enc_init(speex_lib_get_mode(SPEEX_MODEID_NB));
}
int main(int argc, char **argv)
{
int nb_samples, total_samples=0, nb_encoded;
int c;
int option_index = 0;
char *inFile, *outFile;
FILE *fin, *fout;
short input[MAX_FRAME_SIZE];
spx_int32_t frame_size;
int quiet=0;
spx_int32_t vbr_enabled=0;
spx_int32_t vbr_max=0;
int abr_enabled=0;
spx_int32_t vad_enabled=0;
spx_int32_t dtx_enabled=0;
int nbBytes;
const SpeexMode *mode=NULL;
int modeID = -1;
void *st;
SpeexBits bits;
char cbits[MAX_FRAME_BYTES];
int with_skeleton = 0;
struct option long_options[] =
{
{"wideband", no_argument, NULL, 0},
{"ultra-wideband", no_argument, NULL, 0},
{"narrowband", no_argument, NULL, 0},
{"vbr", no_argument, NULL, 0},
{"vbr-max-bitrate", required_argument, NULL, 0},
{"abr", required_argument, NULL, 0},
{"vad", no_argument, NULL, 0},
{"dtx", no_argument, NULL, 0},
{"quality", required_argument, NULL, 0},
{"bitrate", required_argument, NULL, 0},
{"nframes", required_argument, NULL, 0},
{"comp", required_argument, NULL, 0},
#ifdef USE_SPEEXDSP
{"denoise", no_argument, NULL, 0},
{"agc", no_argument, NULL, 0},
#endif
{"no-highpass", no_argument, NULL, 0},
{"skeleton",no_argument,NULL, 0},
{"help", no_argument, NULL, 0},
{"quiet", no_argument, NULL, 0},
{"le", no_argument, NULL, 0},
{"be", no_argument, NULL, 0},
{"8bit", no_argument, NULL, 0},
{"16bit", no_argument, NULL, 0},
{"stereo", no_argument, NULL, 0},
{"rate", required_argument, NULL, 0},
{"version", no_argument, NULL, 0},
{"version-short", no_argument, NULL, 0},
{"comment", required_argument, NULL, 0},
{"author", required_argument, NULL, 0},
{"title", required_argument, NULL, 0},
{"print-rate", no_argument, NULL, 0},
{0, 0, 0, 0}
};
int print_bitrate=0;
spx_int32_t rate=0;
spx_int32_t size;
int chan=1;
int fmt=16;
spx_int32_t quality=-1;
float vbr_quality=-1;
int lsb=1;
ogg_stream_state os;
ogg_stream_state so; /* ogg stream for skeleton bitstream */
ogg_page og;
ogg_packet op;
int bytes_written=0, ret, result;
int id=-1;
SpeexHeader header;
int nframes=1;
spx_int32_t complexity=3;
const char* speex_version;
char vendor_string[64];
char *comments;
int comments_length;
int close_in=0, close_out=0;
int eos=0;
spx_int32_t bitrate=0;
double cumul_bits=0, enc_frames=0;
char first_bytes[12];
int wave_input=0;
spx_int32_t tmp;
#ifdef USE_SPEEXDSP
SpeexPreprocessState *preprocess = NULL;
int denoise_enabled=0, agc_enabled=0;
#endif
int highpass_enabled=1;
int output_rate=0;
spx_int32_t lookahead = 0;
speex_lib_ctl(SPEEX_LIB_GET_VERSION_STRING, (void*)&speex_version);
snprintf(vendor_string, sizeof(vendor_string), "Encoded with Speex %s", speex_version);
comment_init(&comments, &comments_length, vendor_string);
/*Process command-line options*/
while(1)
{
c = getopt_long (argc, argv, "nwuhvV",
long_options, &option_index);
if (c==-1)
break;
switch(c)
{
case 0:
if (strcmp(long_options[option_index].name,"narrowband")==0)
{
modeID = SPEEX_MODEID_NB;
} else if (strcmp(long_options[option_index].name,"wideband")==0)
{
modeID = SPEEX_MODEID_WB;
} else if (strcmp(long_options[option_index].name,"ultra-wideband")==0)
{
modeID = SPEEX_MODEID_UWB;
} else if (strcmp(long_options[option_index].name,"vbr")==0)
{
vbr_enabled=1;
} else if (strcmp(long_options[option_index].name,"vbr-max-bitrate")==0)
{
vbr_max=atoi(optarg);
if (vbr_max<1)
{
fprintf (stderr, "Invalid VBR max bit-rate value: %d\n", vbr_max);
exit(1);
}
} else if (strcmp(long_options[option_index].name,"abr")==0)
{
abr_enabled=atoi(optarg);
if (!abr_enabled)
{
fprintf (stderr, "Invalid ABR value: %d\n", abr_enabled);
exit(1);
}
} else if (strcmp(long_options[option_index].name,"vad")==0)
{
vad_enabled=1;
} else if (strcmp(long_options[option_index].name,"dtx")==0)
{
dtx_enabled=1;
} else if (strcmp(long_options[option_index].name,"quality")==0)
{
quality = atoi (optarg);
vbr_quality=atof(optarg);
} else if (strcmp(long_options[option_index].name,"bitrate")==0)
{
bitrate = atoi (optarg);
} else if (strcmp(long_options[option_index].name,"nframes")==0)
{
nframes = atoi (optarg);
if (nframes<1)
nframes=1;
if (nframes>10)
nframes=10;
} else if (strcmp(long_options[option_index].name,"comp")==0)
{
complexity = atoi (optarg);
#ifdef USE_SPEEXDSP
} else if (strcmp(long_options[option_index].name,"denoise")==0)
{
denoise_enabled=1;
} else if (strcmp(long_options[option_index].name,"agc")==0)
{
agc_enabled=1;
#endif
} else if (strcmp(long_options[option_index].name,"no-highpass")==0)
{
highpass_enabled=0;
} else if (strcmp(long_options[option_index].name,"skeleton")==0)
{
with_skeleton=1;
} else if (strcmp(long_options[option_index].name,"help")==0)
{
usage();
exit(0);
} else if (strcmp(long_options[option_index].name,"quiet")==0)
{
quiet = 1;
} else if (strcmp(long_options[option_index].name,"version")==0)
{
version();
exit(0);
} else if (strcmp(long_options[option_index].name,"version-short")==0)
{
version_short();
exit(0);
} else if (strcmp(long_options[option_index].name,"print-rate")==0)
{
output_rate=1;
} else if (strcmp(long_options[option_index].name,"le")==0)
{
lsb=1;
} else if (strcmp(long_options[option_index].name,"be")==0)
{
lsb=0;
} else if (strcmp(long_options[option_index].name,"8bit")==0)
{
fmt=8;
} else if (strcmp(long_options[option_index].name,"16bit")==0)
{
fmt=16;
} else if (strcmp(long_options[option_index].name,"stereo")==0)
{
chan=2;
} else if (strcmp(long_options[option_index].name,"rate")==0)
{
rate=atoi (optarg);
} else if (strcmp(long_options[option_index].name,"comment")==0)
{
if (!strchr(optarg, '='))
{
fprintf (stderr, "Invalid comment: %s\n", optarg);
fprintf (stderr, "Comments must be of the form name=value\n");
exit(1);
}
comment_add(&comments, &comments_length, NULL, optarg);
} else if (strcmp(long_options[option_index].name,"author")==0)
{
comment_add(&comments, &comments_length, "author=", optarg);
} else if (strcmp(long_options[option_index].name,"title")==0)
{
comment_add(&comments, &comments_length, "title=", optarg);
}
break;
case 'n':
modeID = SPEEX_MODEID_NB;
break;
case 'h':
usage();
exit(0);
break;
case 'v':
version();
exit(0);
break;
case 'V':
print_bitrate=1;
break;
case 'w':
modeID = SPEEX_MODEID_WB;
break;
case 'u':
modeID = SPEEX_MODEID_UWB;
break;
case '?':
usage();
exit(1);
break;
}
}
if (argc-optind!=2)
{
usage();
exit(1);
}
inFile=argv[optind];
outFile=argv[optind+1];
/*Initialize Ogg stream struct*/
srand(time(NULL));
if (ogg_stream_init(&os, rand())==-1)
{
fprintf(stderr,"Error: stream init failed\n");
exit(1);
}
if (with_skeleton && ogg_stream_init(&so, rand())==-1)
{
fprintf(stderr,"Error: stream init failed\n");
exit(1);
}
if (strcmp(inFile, "-")==0)
{
#if defined WIN32 || defined _WIN32
_setmode(_fileno(stdin), _O_BINARY);
#elif defined OS2
_fsetmode(stdin,"b");
#endif
fin=stdin;
}
else
{
fin = fopen(inFile, "rb");
if (!fin)
{
perror(inFile);
exit(1);
}
close_in=1;
}
{
if (fread(first_bytes, 1, 12, fin) != 12)
{
perror("short file");
exit(1);
}
if (strncmp(first_bytes,"RIFF",4)==0 || strncmp(first_bytes,"riff",4)==0)
{
if (read_wav_header(fin, &rate, &chan, &fmt, &size)==-1)
exit(1);
wave_input=1;
lsb=1; /* CHECK: exists big-endian .wav ?? */
}
}
if (modeID==-1 && !rate)
{
/* By default, use narrowband/8 kHz */
modeID = SPEEX_MODEID_NB;
rate=8000;
} else if (modeID!=-1 && rate)
{
mode = speex_lib_get_mode (modeID);
if (rate>48000)
{
fprintf (stderr, "Error: sampling rate too high: %d Hz, try down-sampling\n", rate);
exit(1);
} else if (rate>25000)
{
if (modeID != SPEEX_MODEID_UWB)
{
fprintf (stderr, "Warning: Trying to encode in %s at %d Hz. I'll do it but I suggest you try ultra-wideband instead\n", mode->modeName , rate);
}
} else if (rate>12500)
{
if (modeID != SPEEX_MODEID_WB)
{
fprintf (stderr, "Warning: Trying to encode in %s at %d Hz. I'll do it but I suggest you try wideband instead\n", mode->modeName , rate);
}
} else if (rate>=6000)
{
if (modeID != SPEEX_MODEID_NB)
{
fprintf (stderr, "Warning: Trying to encode in %s at %d Hz. I'll do it but I suggest you try narrowband instead\n", mode->modeName , rate);
}
} else {
fprintf (stderr, "Error: sampling rate too low: %d Hz\n", rate);
exit(1);
}
} else if (modeID==-1)
{
if (rate>48000)
{
fprintf (stderr, "Error: sampling rate too high: %d Hz, try down-sampling\n", rate);
exit(1);
} else if (rate>25000)
{
modeID = SPEEX_MODEID_UWB;
} else if (rate>12500)
{
modeID = SPEEX_MODEID_WB;
} else if (rate>=6000)
{
modeID = SPEEX_MODEID_NB;
} else {
fprintf (stderr, "Error: Sampling rate too low: %d Hz\n", rate);
exit(1);
}
} else if (!rate)
{
if (modeID == SPEEX_MODEID_NB)
rate=8000;
else if (modeID == SPEEX_MODEID_WB)
rate=16000;
else if (modeID == SPEEX_MODEID_UWB)
rate=32000;
}
if (!quiet)
if (rate!=8000 && rate!=16000 && rate!=32000)
fprintf (stderr, "Warning: Speex is only optimized for 8, 16 and 32 kHz. It will still work at %d Hz but your mileage may vary\n", rate);
if (!mode)
mode = speex_lib_get_mode (modeID);
speex_init_header(&header, rate, 1, mode);
header.frames_per_packet=nframes;
header.vbr=vbr_enabled;
header.nb_channels = chan;
{
char *st_string="mono";
if (chan==2)
st_string="stereo";
if (!quiet)
fprintf (stderr, "Encoding %d Hz audio using %s mode (%s)\n",
header.rate, mode->modeName, st_string);
}
/*fprintf (stderr, "Encoding %d Hz audio at %d bps using %s mode\n",
header.rate, mode->bitrate, mode->modeName);*/
/*Initialize Speex encoder*/
st = speex_encoder_init(mode);
if (strcmp(outFile,"-")==0)
{
#if defined WIN32 || defined _WIN32
_setmode(_fileno(stdout), _O_BINARY);
#endif
fout=stdout;
}
else
{
fout = fopen(outFile, "wb");
if (!fout)
{
perror(outFile);
exit(1);
}
close_out=1;
}
speex_encoder_ctl(st, SPEEX_GET_FRAME_SIZE, &frame_size);
speex_encoder_ctl(st, SPEEX_SET_COMPLEXITY, &complexity);
speex_encoder_ctl(st, SPEEX_SET_SAMPLING_RATE, &rate);
if (quality >= 0)
{
if (vbr_enabled)
{
if (vbr_max>0)
speex_encoder_ctl(st, SPEEX_SET_VBR_MAX_BITRATE, &vbr_max);
speex_encoder_ctl(st, SPEEX_SET_VBR_QUALITY, &vbr_quality);
}
else
speex_encoder_ctl(st, SPEEX_SET_QUALITY, &quality);
}
if (bitrate)
{
if (quality >= 0 && vbr_enabled)
fprintf (stderr, "Warning: --bitrate option is overriding --quality\n");
speex_encoder_ctl(st, SPEEX_SET_BITRATE, &bitrate);
}
if (vbr_enabled)
{
tmp=1;
speex_encoder_ctl(st, SPEEX_SET_VBR, &tmp);
} else if (vad_enabled)
{
tmp=1;
speex_encoder_ctl(st, SPEEX_SET_VAD, &tmp);
}
if (dtx_enabled)
speex_encoder_ctl(st, SPEEX_SET_DTX, &tmp);
if (dtx_enabled && !(vbr_enabled || abr_enabled || vad_enabled))
{
fprintf (stderr, "Warning: --dtx is useless without --vad, --vbr or --abr\n");
} else if ((vbr_enabled || abr_enabled) && (vad_enabled))
{
fprintf (stderr, "Warning: --vad is already implied by --vbr or --abr\n");
}
if (with_skeleton) {
fprintf (stderr, "Warning: Enabling skeleton output may cause some decoders to fail.\n");
}
if (abr_enabled)
{
speex_encoder_ctl(st, SPEEX_SET_ABR, &abr_enabled);
}
speex_encoder_ctl(st, SPEEX_SET_HIGHPASS, &highpass_enabled);
speex_encoder_ctl(st, SPEEX_GET_LOOKAHEAD, &lookahead);
#ifdef USE_SPEEXDSP
if (denoise_enabled || agc_enabled)
{
preprocess = speex_preprocess_state_init(frame_size, rate);
speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_DENOISE, &denoise_enabled);
speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_AGC, &agc_enabled);
lookahead += frame_size;
}
#endif
/* first packet should be the skeleton header. */
if (with_skeleton) {
add_fishead_packet(&so);
if ((ret = flush_ogg_stream_to_file(&so, fout))) {
fprintf (stderr,"Error: failed skeleton (fishead) header to output stream\n");
exit(1);
} else
bytes_written += ret;
}
/*Write header*/
{
int packet_size;
op.packet = (unsigned char *)speex_header_to_packet(&header, &packet_size);
op.bytes = packet_size;
op.b_o_s = 1;
op.e_o_s = 0;
op.granulepos = 0;
op.packetno = 0;
ogg_stream_packetin(&os, &op);
free(op.packet);
while((result = ogg_stream_flush(&os, &og)))
{
if(!result) break;
ret = oe_write_page(&og, fout);
if(ret != og.header_len + og.body_len)
{
fprintf (stderr,"Error: failed writing header to output stream\n");
exit(1);
}
else
bytes_written += ret;
}
op.packet = (unsigned char *)comments;
op.bytes = comments_length;
op.b_o_s = 0;
op.e_o_s = 0;
op.granulepos = 0;
op.packetno = 1;
ogg_stream_packetin(&os, &op);
}
/* fisbone packet should be write after all bos pages */
if (with_skeleton) {
add_fisbone_packet(&so, os.serialno, &header);
if ((ret = flush_ogg_stream_to_file(&so, fout))) {
fprintf (stderr,"Error: failed writing skeleton (fisbone )header to output stream\n");
exit(1);
} else
bytes_written += ret;
}
/* writing the rest of the speex header packets */
while((result = ogg_stream_flush(&os, &og)))
{
if(!result) break;
ret = oe_write_page(&og, fout);
if(ret != og.header_len + og.body_len)
{
fprintf (stderr,"Error: failed writing header to output stream\n");
exit(1);
}
else
bytes_written += ret;
}
free(comments);
/* write the skeleton eos packet */
if (with_skeleton) {
add_eos_packet_to_stream(&so);
if ((ret = flush_ogg_stream_to_file(&so, fout))) {
fprintf (stderr,"Error: failed writing skeleton header to output stream\n");
exit(1);
} else
bytes_written += ret;
}
speex_bits_init(&bits);
if (!wave_input)
{
nb_samples = read_samples(fin,frame_size,fmt,chan,lsb,input, first_bytes, NULL);
} else {
nb_samples = read_samples(fin,frame_size,fmt,chan,lsb,input, NULL, &size);
}
if (nb_samples==0)
eos=1;
total_samples += nb_samples;
nb_encoded = -lookahead;
/*Main encoding loop (one frame per iteration)*/
while (!eos || total_samples>nb_encoded)
{
id++;
/*Encode current frame*/
if (chan==2)
speex_encode_stereo_int(input, frame_size, &bits);
#ifdef USE_SPEEXDSP
if (preprocess)
speex_preprocess(preprocess, input, NULL);
#endif
speex_encode_int(st, input, &bits);
nb_encoded += frame_size;
if (print_bitrate) {
int tmp;
char ch=13;
speex_encoder_ctl(st, SPEEX_GET_BITRATE, &tmp);
fputc (ch, stderr);
cumul_bits += tmp;
enc_frames += 1;
if (!quiet)
{
if (vad_enabled || vbr_enabled || abr_enabled)
fprintf (stderr, "Bitrate is use: %d bps (average %d bps) ", tmp, (int)(cumul_bits/enc_frames));
else
fprintf (stderr, "Bitrate is use: %d bps ", tmp);
if (output_rate)
printf ("%d\n", tmp);
}
}
if (wave_input)
{
nb_samples = read_samples(fin,frame_size,fmt,chan,lsb,input, NULL, &size);
} else {
nb_samples = read_samples(fin,frame_size,fmt,chan,lsb,input, NULL, NULL);
}
if (nb_samples==0)
{
eos=1;
}
if (eos && total_samples<=nb_encoded)
op.e_o_s = 1;
else
op.e_o_s = 0;
total_samples += nb_samples;
if ((id+1)%nframes!=0)
continue;
speex_bits_insert_terminator(&bits);
nbBytes = speex_bits_write(&bits, cbits, MAX_FRAME_BYTES);
speex_bits_reset(&bits);
op.packet = (unsigned char *)cbits;
op.bytes = nbBytes;
op.b_o_s = 0;
/*Is this redundent?*/
if (eos && total_samples<=nb_encoded)
op.e_o_s = 1;
else
op.e_o_s = 0;
op.granulepos = (id+1)*frame_size-lookahead;
if (op.granulepos>total_samples)
op.granulepos = total_samples;
/*printf ("granulepos: %d %d %d %d %d %d\n", (int)op.granulepos, id, nframes, lookahead, 5, 6);*/
op.packetno = 2+id/nframes;
ogg_stream_packetin(&os, &op);
/*Write all new pages (most likely 0 or 1)*/
while (ogg_stream_pageout(&os,&og))
{
ret = oe_write_page(&og, fout);
if(ret != og.header_len + og.body_len)
{
fprintf (stderr,"Error: failed writing header to output stream\n");
exit(1);
}
else
bytes_written += ret;
}
}
if ((id+1)%nframes!=0)
{
while ((id+1)%nframes!=0)
{
id++;
speex_bits_pack(&bits, 15, 5);
}
nbBytes = speex_bits_write(&bits, cbits, MAX_FRAME_BYTES);
op.packet = (unsigned char *)cbits;
op.bytes = nbBytes;
op.b_o_s = 0;
op.e_o_s = 1;
op.granulepos = (id+1)*frame_size-lookahead;
if (op.granulepos>total_samples)
op.granulepos = total_samples;
op.packetno = 2+id/nframes;
ogg_stream_packetin(&os, &op);
}
/*Flush all pages left to be written*/
while (ogg_stream_flush(&os, &og))
{
ret = oe_write_page(&og, fout);
if(ret != og.header_len + og.body_len)
{
fprintf (stderr,"Error: failed writing header to output stream\n");
exit(1);
}
else
bytes_written += ret;
}
speex_encoder_destroy(st);
speex_bits_destroy(&bits);
ogg_stream_clear(&os);
if (close_in)
fclose(fin);
if (close_out)
fclose(fout);
return 0;
}
void CASpeexDecoder::InitializeCompressionSettings()
{
if (mCookie == NULL)
return;
if (mCompressionInitialized) {
memset(&mSpeexHeader, 0, sizeof(mSpeexHeader));
mSpeexStereoState.balance = 1.0;
mSpeexStereoState.e_ratio = 0.5;
mSpeexStereoState.smooth_left = 1.0;
mSpeexStereoState.smooth_right = 1.0;
if (mSpeexDecoderState != NULL) {
speex_decoder_destroy(mSpeexDecoderState);
mSpeexDecoderState = NULL;
}
}
mCompressionInitialized = false;
OggSerialNoAtom *atom = reinterpret_cast<OggSerialNoAtom*> (mCookie);
Byte *ptrheader = mCookie + EndianU32_BtoN(atom->size);
CookieAtomHeader *aheader = reinterpret_cast<CookieAtomHeader*> (ptrheader);
// scan quickly through the cookie, check types and packet sizes
if (EndianS32_BtoN(atom->type) != kCookieTypeOggSerialNo || static_cast<UInt32> (ptrheader - mCookie) > mCookieSize)
return;
ptrheader += EndianU32_BtoN(aheader->size);
if (EndianS32_BtoN(aheader->type) != kCookieTypeSpeexHeader || static_cast<UInt32> (ptrheader - mCookie) > mCookieSize)
return;
// we ignore the rest: comments and extra headers
// all OK, back to the first speex packet
aheader = reinterpret_cast<CookieAtomHeader*> (mCookie + EndianU32_BtoN(atom->size));
SpeexHeader *inheader = reinterpret_cast<SpeexHeader *> (&aheader->data[0]);
// TODO: convert, at some point, mSpeexHeader to a pointer?
mSpeexHeader.bitrate = EndianS32_LtoN(inheader->bitrate);
mSpeexHeader.extra_headers = EndianS32_LtoN(inheader->extra_headers);
mSpeexHeader.frame_size = EndianS32_LtoN(inheader->frame_size);
mSpeexHeader.frames_per_packet = EndianS32_LtoN(inheader->frames_per_packet);
mSpeexHeader.header_size = EndianS32_LtoN(inheader->header_size);
mSpeexHeader.mode = EndianS32_LtoN(inheader->mode);
mSpeexHeader.mode_bitstream_version = EndianS32_LtoN(inheader->mode_bitstream_version);
mSpeexHeader.nb_channels = EndianS32_LtoN(inheader->nb_channels);
mSpeexHeader.rate = EndianS32_LtoN(inheader->rate);
mSpeexHeader.reserved1 = EndianS32_LtoN(inheader->reserved1);
mSpeexHeader.reserved2 = EndianS32_LtoN(inheader->reserved2);
mSpeexHeader.speex_version_id = EndianS32_LtoN(inheader->speex_version_id);
mSpeexHeader.vbr = EndianS32_LtoN(inheader->vbr);
if (mSpeexHeader.mode >= SPEEX_NB_MODES)
CODEC_THROW(kAudioCodecUnsupportedFormatError);
//TODO: check bitstream version here
mSpeexDecoderState = speex_decoder_init(speex_lib_get_mode(mSpeexHeader.mode));
if (!mSpeexDecoderState)
CODEC_THROW(kAudioCodecUnsupportedFormatError);
//TODO: fix some of the header fields here
int enhzero = 0;
speex_decoder_ctl(mSpeexDecoderState, SPEEX_SET_ENH, &enhzero);
if (mSpeexHeader.nb_channels == 2)
{
SpeexCallback callback;
callback.callback_id = SPEEX_INBAND_STEREO;
callback.func = speex_std_stereo_request_handler;
callback.data = &mSpeexStereoState;
speex_decoder_ctl(mSpeexDecoderState, SPEEX_SET_HANDLER, &callback);
}
mCompressionInitialized = true;
}
static GstFlowReturn
gst_speex_dec_parse_header (GstSpeexDec * dec, GstBuffer * buf)
{
GstMapInfo map;
GstAudioInfo info;
static const GstAudioChannelPosition chan_pos[2][2] = {
{GST_AUDIO_CHANNEL_POSITION_MONO},
{GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}
};
/* get the header */
gst_buffer_map (buf, &map, GST_MAP_READ);
dec->header = speex_packet_to_header ((gchar *) map.data, map.size);
gst_buffer_unmap (buf, &map);
if (!dec->header)
goto no_header;
if (dec->header->mode >= SPEEX_NB_MODES || dec->header->mode < 0)
goto mode_too_old;
dec->mode = speex_lib_get_mode (dec->header->mode);
/* initialize the decoder */
dec->state = speex_decoder_init (dec->mode);
if (!dec->state)
goto init_failed;
speex_decoder_ctl (dec->state, SPEEX_SET_ENH, &dec->enh);
speex_decoder_ctl (dec->state, SPEEX_GET_FRAME_SIZE, &dec->frame_size);
if (dec->header->nb_channels != 1) {
dec->stereo = speex_stereo_state_init ();
dec->callback.callback_id = SPEEX_INBAND_STEREO;
dec->callback.func = speex_std_stereo_request_handler;
dec->callback.data = dec->stereo;
speex_decoder_ctl (dec->state, SPEEX_SET_HANDLER, &dec->callback);
}
speex_decoder_ctl (dec->state, SPEEX_SET_SAMPLING_RATE, &dec->header->rate);
dec->frame_duration = gst_util_uint64_scale_int (dec->frame_size,
GST_SECOND, dec->header->rate);
speex_bits_init (&dec->bits);
/* set caps */
gst_audio_info_init (&info);
gst_audio_info_set_format (&info,
GST_AUDIO_FORMAT_S16,
dec->header->rate,
dec->header->nb_channels, chan_pos[dec->header->nb_channels - 1]);
if (!gst_audio_decoder_set_output_format (GST_AUDIO_DECODER (dec), &info))
goto nego_failed;
return GST_FLOW_OK;
/* ERRORS */
no_header:
{
GST_ELEMENT_ERROR (GST_ELEMENT (dec), STREAM, DECODE,
(NULL), ("couldn't read header"));
return GST_FLOW_ERROR;
}
mode_too_old:
{
GST_ELEMENT_ERROR (GST_ELEMENT (dec), STREAM, DECODE,
(NULL),
("Mode number %d does not (yet/any longer) exist in this version",
dec->header->mode));
return GST_FLOW_ERROR;
}
init_failed:
{
GST_ELEMENT_ERROR (GST_ELEMENT (dec), STREAM, DECODE,
(NULL), ("couldn't initialize decoder"));
return GST_FLOW_ERROR;
}
nego_failed:
{
GST_ELEMENT_ERROR (GST_ELEMENT (dec), STREAM, DECODE,
(NULL), ("couldn't negotiate format"));
return GST_FLOW_NOT_NEGOTIATED;
}
}
AudioInput::AudioInput() {
speex_bits_init(&sbBits);
speex_bits_reset(&sbBits);
iFrames = 0;
iSampleRate = SAMPLE_RATE;
esEncState=speex_encoder_init(speex_lib_get_mode(SPEEX_MODEID_WB));
speex_encoder_ctl(esEncState,SPEEX_GET_FRAME_SIZE,&iFrameSize);
mumble_drft_init(&fftTable, iFrameSize);
iFrameCounter = 0;
iSilentFrames = 0;
iHoldFrames = 0;
iBestBin = 0;
int iArg=1;
float fArg=0.0;
speex_encoder_ctl(esEncState,SPEEX_SET_VBR, &iArg);
iArg = 0;
speex_encoder_ctl(esEncState,SPEEX_SET_VAD, &iArg);
speex_encoder_ctl(esEncState,SPEEX_SET_DTX, &iArg);
fArg = static_cast<float>(g.s.iQuality);
speex_encoder_ctl(esEncState,SPEEX_SET_VBR_QUALITY, &fArg);
speex_encoder_ctl(esEncState,SPEEX_GET_BITRATE, &iArg);
speex_encoder_ctl(esEncState, SPEEX_SET_VBR_MAX_BITRATE, &iArg);
iArg = 5;
speex_encoder_ctl(esEncState,SPEEX_SET_COMPLEXITY, &iArg);
bResetProcessor = true;
sppPreprocess = NULL;
sesEcho = NULL;
srsMic = srsEcho = NULL;
jb = jitter_buffer_init(10);
iJitterSeq = 1;
psMic = new short[iFrameSize];
psSpeaker = new short[iFrameSize];
psClean = new short[iFrameSize];
iEchoChannels = iMicChannels = 0;
iEchoFreq = iMicFreq = SAMPLE_RATE;
iEchoFilled = iMicFilled = 0;
eMicFormat = eEchoFormat = SampleFloat;
iMicSampleSize = iEchoSampleSize = 0;
bPreviousVoice = false;
pfMicInput = pfEchoInput = pfOutput = NULL;
iBitrate = 0;
dPeakMic = dPeakSignal = dPeakSpeaker = 0.0;
if (g.uiSession) {
setMaxBandwidth(g.iMaxBandwidth);
}
bRunning = false;
connect(this, SIGNAL(doMute()), g.mw->qaAudioMute, SLOT(trigger()), Qt::QueuedConnection);
}
int SpeexEncoder::Initialize(const char* filename, char* modeInput, int channels, int pcmRate)
{
char *comments;
int comments_length;
fprintf(stderr, "SpeexEncoder: Initialize\n");
SpeexHeader header;
fprintf(stderr, "modeInput: %s\n", modeInput);
if (modeInput != NULL){
if (strcmp(modeInput, "narrowband") == 0)
{
modeID = SPEEX_MODEID_NB;
}
else if (strcmp(modeInput, "wideband") == 0)
{
modeID = SPEEX_MODEID_WB;
}
else if (strcmp(modeInput, "ultra-wideband") == 0)
{
modeID = SPEEX_MODEID_UWB;
}
}
if (channels > 0){
chan = channels;
}
speex_lib_ctl(SPEEX_LIB_GET_VERSION_STRING, (void*)&speex_version);
snprintf(vendor_string, sizeof(vendor_string), "Encoded with Speex %s", speex_version);
comment_init(&comments, &comments_length, vendor_string);
comment_add(&comments, &comments_length, "TITLE=", "saa1");
comment_add(&comments, &comments_length, "AUTHOR=", "uptivity");
comment_add(&comments, &comments_length, "FORMATTYPE=", (char*)speex_version);
comment_add(&comments, &comments_length, "DURATION=", "00000");
/*Initialize Ogg stream struct*/
srand(time(NULL));
if (ogg_stream_init(&os, rand()) == -1)
{
fprintf(stderr, "Error: stream init failed\n");
exit(1);
}
rate = pcmRate;
if (modeID == -1 )
{
/* By default, use narrowband/8 kHz */
modeID = SPEEX_MODEID_NB;
if (pcmRate < 0){
rate = 8000;
}
}
if (pcmRate < 0){
if (modeID == SPEEX_MODEID_NB)
rate = 8000;
else if (modeID == SPEEX_MODEID_WB)
rate = 16000;
else if (modeID == SPEEX_MODEID_UWB)
rate = 32000;
}
if (!mode)
mode = speex_lib_get_mode(modeID);
speex_init_header(&header, rate, 1, mode);
header.frames_per_packet = 1;
header.vbr = 0;
header.nb_channels = chan;
{
char *st_string = "mono";
if (chan == 2)
st_string = "stereo";
fprintf(stderr, "Encoding %d Hz audio using %s mode (%s)\n",
header.rate, mode->modeName, st_string);
}
/*Initialize Speex encoder*/
st = speex_encoder_init(mode);
fout = fopen(filename, "wb");
if (!fout)
{
perror(filename);
exit(1);
}
speex_encoder_ctl(st, SPEEX_GET_FRAME_SIZE, &frame_size);
speex_encoder_ctl(st, SPEEX_SET_COMPLEXITY, &complexity);
speex_encoder_ctl(st, SPEEX_SET_SAMPLING_RATE, &rate);
if (quality >= 0)
{
speex_encoder_ctl(st, SPEEX_SET_QUALITY, &quality);
}
speex_encoder_ctl(st, SPEEX_GET_LOOKAHEAD, &lookahead);
/*Write header*/
{
int packet_size;
op.packet = (unsigned char *)speex_header_to_packet(&header, &packet_size);
op.bytes = packet_size;
op.b_o_s = 1;
op.e_o_s = 0;
op.granulepos = 0;
op.packetno = 0;
// submit the packet to the ogg streaming layer
ogg_stream_packetin(&os, &op);
free(op.packet);
while ((result = ogg_stream_flush(&os, &og)))
{
if (!result) break;
ret = oe_write_page(&og, fout);
if (ret != og.header_len + og.body_len)
{
fprintf(stderr, "Error: failed writing header to output stream\n");
exit(1);
}
else
bytes_written += ret;
}
op.packet = (unsigned char *)comments;
op.bytes = comments_length;
op.b_o_s = 0;
op.e_o_s = 0;
op.granulepos = 0;
op.packetno = 1;
ogg_stream_packetin(&os, &op);
durationIndex = bytes_written + os.header_fill + os.body_fill - 5;
}
/* writing the rest of the speex header packets */
while ((result = ogg_stream_flush(&os, &og)))
{
if (!result) break;
ret = oe_write_page(&og, fout);
if (ret != og.header_len + og.body_len)
{
fprintf(stderr, "Error: failed writing header to output stream\n");
exit(1);
}
else
bytes_written += ret;
}
free(comments);
speex_bits_init(&bits);
return 0;
}
static av_cold int libspeex_decode_init(AVCodecContext *avctx)
{
LibSpeexContext *s = avctx->priv_data;
const SpeexMode *mode;
// defaults in the case of a missing header
if (avctx->sample_rate <= 8000)
mode = &speex_nb_mode;
else if (avctx->sample_rate <= 16000)
mode = &speex_wb_mode;
else
mode = &speex_uwb_mode;
if (avctx->extradata_size >= 80)
s->header = speex_packet_to_header(avctx->extradata, avctx->extradata_size);
avctx->sample_fmt = AV_SAMPLE_FMT_S16;
if (s->header)
{
avctx->sample_rate = s->header->rate;
avctx->channels = s->header->nb_channels;
avctx->frame_size = s->frame_size = s->header->frame_size;
if (s->header->frames_per_packet)
avctx->frame_size *= s->header->frames_per_packet;
mode = speex_lib_get_mode(s->header->mode);
if (!mode)
{
av_log(avctx, AV_LOG_ERROR, "Unknown Speex mode %d", s->header->mode);
return -1;
}
}
else
av_log(avctx, AV_LOG_INFO, "Missing Speex header, assuming defaults.\n");
if (avctx->channels > 2)
{
av_log(avctx, AV_LOG_ERROR, "Only stereo and mono are supported.\n");
return -1;
}
speex_bits_init(&s->bits);
s->dec_state = speex_decoder_init(mode);
if (!s->dec_state)
{
av_log(avctx, AV_LOG_ERROR, "Error initializing libspeex decoder.\n");
return -1;
}
if (!s->header)
{
speex_decoder_ctl(s->dec_state, SPEEX_GET_FRAME_SIZE, &s->frame_size);
}
if (avctx->channels == 2)
{
SpeexCallback callback;
callback.callback_id = SPEEX_INBAND_STEREO;
callback.func = speex_std_stereo_request_handler;
callback.data = &s->stereo;
s->stereo = (SpeexStereoState)SPEEX_STEREO_STATE_INIT;
speex_decoder_ctl(s->dec_state, SPEEX_SET_HANDLER, &callback);
}
return 0;
}
void* universal_speex_init(const char* fmt, int isDecoder, int samplerate,
struct MppCodecFmtpInfoV1_2* pCodecInfo)
{
const SpeexMode *pSpeexMode;
if (pCodecInfo == NULL)
{
return NULL;
}
/* Fill general codec information */
pCodecInfo->signalingCodec = FALSE;
/* It could do PLC, but wrapper should be fixed to support it. */
pCodecInfo->packetLossConcealment = CODEC_PLC_INTERNAL;
/* It could do DTX+CNG, but wrapper should be fixed to support it. */
pCodecInfo->vadCng = CODEC_CNG_NONE;
/* Get Speex mode for given sample rate */
switch (samplerate)
{
case 8000:
pSpeexMode = speex_lib_get_mode(SPEEX_MODEID_NB);
break;
case 16000:
pSpeexMode = speex_lib_get_mode(SPEEX_MODEID_WB);
break;
case 32000:
pSpeexMode = speex_lib_get_mode(SPEEX_MODEID_UWB);
break;
default:
assert(!"Wrong Speex sampling rate setting!");
}
if (isDecoder)
{
int tmp;
struct speex_codec_data_decoder *pSpeexDec;
/* Preparing decoder */
pSpeexDec = (struct speex_codec_data_decoder *)malloc(sizeof(struct speex_codec_data_decoder));
if (!pSpeexDec)
{
return NULL;
}
pSpeexDec->mpDecoderState = NULL;
pSpeexDec->mNumSamplesPerFrame = 0;
/* Init decoder */
pSpeexDec->mpDecoderState = speex_decoder_init(pSpeexMode);
/* It makes the decoded speech deviate further from the original,
* but it sounds subjectively better.*/
tmp = 1;
speex_decoder_ctl(pSpeexDec->mpDecoderState,SPEEX_SET_ENH,&tmp);
/* Get number of samples in one frame */
speex_decoder_ctl(pSpeexDec->mpDecoderState,SPEEX_GET_FRAME_SIZE,&pSpeexDec->mNumSamplesPerFrame);
/* Get decoder lookahead */
speex_decoder_ctl(pSpeexDec->mpDecoderState,SPEEX_GET_LOOKAHEAD,&pCodecInfo->algorithmicDelay);
/* Fill codec information, specific to concrete Speex settings */
pCodecInfo->numSamplesPerFrame = pSpeexDec->mNumSamplesPerFrame;
switch (samplerate)
{
case 8000:
pCodecInfo->minBitrate = 3950;
pCodecInfo->maxBitrate = 24600;
pCodecInfo->minFrameBytes = (79/*bits/frame*/+7)/8;
pCodecInfo->maxFrameBytes = (492/*bits/frame*/+7)/8;
break;
case 16000:
pCodecInfo->minBitrate = 3950;
pCodecInfo->maxBitrate = 42200;
pCodecInfo->minFrameBytes = (79/*bits/frame*/+7)/8;
pCodecInfo->maxFrameBytes = (844/*bits/frame*/+7)/8;
break;
case 32000:
pCodecInfo->minBitrate = 5750;
pCodecInfo->maxBitrate = 44000;
pCodecInfo->minFrameBytes = (115/*bits/frame*/+7)/8;
pCodecInfo->maxFrameBytes = (880/*bits/frame*/+7)/8;
break;
}
return pSpeexDec;
}
else
{
struct speex_codec_data_encoder *pSpeexEnc;
int mode = getFmtpValueRange(fmt, "mode", -1, 2, 8);
pSpeexEnc = (struct speex_codec_data_encoder *)malloc(sizeof(struct speex_codec_data_encoder));
if (!pSpeexEnc)
{
return NULL;
}
pSpeexEnc->mpEncoderState = NULL;
pSpeexEnc->mDoVad = 0;
pSpeexEnc->mDoDtx = 0;
pSpeexEnc->mDoVbr = 0;
pSpeexEnc->mBufferLoad = 0;
pSpeexEnc->mDoPreprocess = FALSE;
pSpeexEnc->mpPreprocessState = NULL;
pSpeexEnc->mDoDenoise = 0;
pSpeexEnc->mDoAgc = 0;
pSpeexEnc->mMode = mode;
if (samplerate == 8000 && pSpeexEnc->mMode == 2)
{
pSpeexEnc->mDoPreprocess = TRUE;
}
/* Preparing encoder */
pSpeexEnc->mpEncoderState = speex_encoder_init(pSpeexMode);
/* Setting wanted mode */
if (pSpeexEnc->mMode > -1)
{
speex_encoder_ctl(pSpeexEnc->mpEncoderState, SPEEX_SET_MODE,&pSpeexEnc->mMode);
}
// Enable wanted extensions.
speex_encoder_ctl(pSpeexEnc->mpEncoderState, SPEEX_SET_VAD, &pSpeexEnc->mDoVad);
speex_encoder_ctl(pSpeexEnc->mpEncoderState, SPEEX_SET_DTX, &pSpeexEnc->mDoDtx);
speex_encoder_ctl(pSpeexEnc->mpEncoderState, SPEEX_SET_VBR, &pSpeexEnc->mDoVbr);
if(pSpeexEnc->mDoPreprocess)
{
pSpeexEnc->mpPreprocessState = speex_preprocess_state_init(160, samplerate);
speex_preprocess_ctl(pSpeexEnc->mpPreprocessState, SPEEX_PREPROCESS_SET_DENOISE,
&pSpeexEnc->mDoDenoise);
speex_preprocess_ctl(pSpeexEnc->mpPreprocessState, SPEEX_PREPROCESS_SET_AGC,
&pSpeexEnc->mDoAgc);
}
/* Get codec frame size */
speex_encoder_ctl(pSpeexEnc->mpEncoderState, SPEEX_GET_FRAME_SIZE, &pSpeexEnc->mNumSamplesPerFrame);
/* Get encoder lookahead */
speex_encoder_ctl(pSpeexEnc->mpEncoderState,SPEEX_GET_LOOKAHEAD,&pCodecInfo->algorithmicDelay);
/* Fill codec information, specific to concrete Speex settings */
pCodecInfo->numSamplesPerFrame = pSpeexEnc->mNumSamplesPerFrame;
if (mode > -1)
{
pCodecInfo->minFrameBytes = mode;
pCodecInfo->maxFrameBytes = mode;
}
else
{
switch (samplerate)
{
case 8000:
pCodecInfo->minFrameBytes = 8;
pCodecInfo->maxFrameBytes = 7;
speex_mode_query(pSpeexMode, SPEEX_SUBMODE_BITS_PER_FRAME, &pCodecInfo->minFrameBytes);
speex_mode_query(pSpeexMode, SPEEX_SUBMODE_BITS_PER_FRAME, &pCodecInfo->maxFrameBytes);
pCodecInfo->minFrameBytes = (pCodecInfo->minFrameBytes/*bits/frame*/+7)/8;
pCodecInfo->maxFrameBytes = (pCodecInfo->maxFrameBytes/*bits/frame*/+7)/8;
pCodecInfo->minBitrate = pCodecInfo->minFrameBytes*8/*bits/byte*/*50/*frames/sec*/;
pCodecInfo->maxBitrate = pCodecInfo->maxFrameBytes*8/*bits/byte*/*50/*frames/sec*/;
break;
/* case 16000:
case 32000:
pCodecInfo->minFrameBytes = 0;
pCodecInfo->maxFrameBytes = 10;
break;*/
case 16000:
pCodecInfo->minBitrate = 3950;
pCodecInfo->maxBitrate = 42200;
//pCodecInfo->numSamplesPerFrame = 16000;
pCodecInfo->minFrameBytes = (79/*bits/frame*/+7)/8;
pCodecInfo->maxFrameBytes = (844/*bits/frame*/+7)/8;
break;
case 32000:
pCodecInfo->minBitrate = 5750;
pCodecInfo->maxBitrate = 44000;
//pCodecInfo->numSamplesPerFrame = 32000;
pCodecInfo->minFrameBytes = (115/*bits/frame*/+7)/8;
pCodecInfo->maxFrameBytes = (880/*bits/frame*/+7)/8;
break;
}
}
return pSpeexEnc;
}
}
AudioOutputSpeech::AudioOutputSpeech(ClientUser *user, unsigned int freq, MessageHandler::UDPMessageType type) : AudioOutputUser(user->qsName) {
int err;
p = user;
umtType = type;
iMixerFreq = freq;
cCodec = NULL;
cdDecoder = NULL;
dsSpeex = NULL;
oCodec = NULL;
opusState = NULL;
bHasTerminator = false;
bStereo = false;
iSampleRate = SAMPLE_RATE;
iFrameSize = iSampleRate / 100;
iAudioBufferSize = iFrameSize;
if (umtType == MessageHandler::UDPVoiceOpus) {
#ifdef USE_OPUS
oCodec = g.oCodec;
if (oCodec) {
iAudioBufferSize *= 12;
opusState = oCodec->opus_decoder_create(iSampleRate, bStereo ? 2 : 1, NULL);
}
#endif
} else if (umtType == MessageHandler::UDPVoiceSpeex) {
speex_bits_init(&sbBits);
dsSpeex = speex_decoder_init(speex_lib_get_mode(SPEEX_MODEID_UWB));
int iArg=1;
speex_decoder_ctl(dsSpeex, SPEEX_SET_ENH, &iArg);
speex_decoder_ctl(dsSpeex, SPEEX_GET_FRAME_SIZE, &iFrameSize);
speex_decoder_ctl(dsSpeex, SPEEX_GET_SAMPLING_RATE, &iSampleRate);
iAudioBufferSize = iFrameSize;
}
iOutputSize = static_cast<unsigned int>(ceilf(static_cast<float>(iAudioBufferSize * iMixerFreq) / static_cast<float>(iSampleRate)));
if (bStereo) {
iAudioBufferSize *= 2;
iOutputSize *= 2;
}
srs = NULL;
fResamplerBuffer = NULL;
if (iMixerFreq != iSampleRate) {
srs = speex_resampler_init(bStereo ? 2 : 1, iSampleRate, iMixerFreq, 3, &err);
fResamplerBuffer = new float[iAudioBufferSize];
}
iBufferOffset = iBufferFilled = iLastConsume = 0;
bLastAlive = true;
iMissCount = 0;
iMissedFrames = 0;
ucFlags = 0xFF;
jbJitter = jitter_buffer_init(iFrameSize);
int margin = g.s.iJitterBufferSize * iFrameSize;
jitter_buffer_ctl(jbJitter, JITTER_BUFFER_SET_MARGIN, &margin);
fFadeIn = new float[iFrameSize];
fFadeOut = new float[iFrameSize];
float mul = static_cast<float>(M_PI / (2.0 * static_cast<double>(iFrameSize)));
for (unsigned int i=0;i<iFrameSize;++i)
fFadeIn[i] = fFadeOut[iFrameSize-i-1] = sinf(static_cast<float>(i) * mul);
}
static gboolean
gst_speex_enc_setup (GstSpeexEnc * enc)
{
switch (enc->mode) {
case GST_SPEEX_ENC_MODE_UWB:
GST_LOG_OBJECT (enc, "configuring for requested UWB mode");
enc->speex_mode = speex_lib_get_mode (SPEEX_MODEID_UWB);
break;
case GST_SPEEX_ENC_MODE_WB:
GST_LOG_OBJECT (enc, "configuring for requested WB mode");
enc->speex_mode = speex_lib_get_mode (SPEEX_MODEID_WB);
break;
case GST_SPEEX_ENC_MODE_NB:
GST_LOG_OBJECT (enc, "configuring for requested NB mode");
enc->speex_mode = speex_lib_get_mode (SPEEX_MODEID_NB);
break;
case GST_SPEEX_ENC_MODE_AUTO:
/* fall through */
GST_LOG_OBJECT (enc, "finding best mode");
default:
break;
}
if (enc->rate > 25000) {
if (enc->mode == GST_SPEEX_ENC_MODE_AUTO) {
GST_LOG_OBJECT (enc, "selected UWB mode for samplerate %d", enc->rate);
enc->speex_mode = speex_lib_get_mode (SPEEX_MODEID_UWB);
} else {
if (enc->speex_mode != speex_lib_get_mode (SPEEX_MODEID_UWB)) {
gst_speex_enc_set_last_msg (enc,
"Warning: suggest to use ultra wide band mode for this rate");
}
}
} else if (enc->rate > 12500) {
if (enc->mode == GST_SPEEX_ENC_MODE_AUTO) {
GST_LOG_OBJECT (enc, "selected WB mode for samplerate %d", enc->rate);
enc->speex_mode = speex_lib_get_mode (SPEEX_MODEID_WB);
} else {
if (enc->speex_mode != speex_lib_get_mode (SPEEX_MODEID_WB)) {
gst_speex_enc_set_last_msg (enc,
"Warning: suggest to use wide band mode for this rate");
}
}
} else {
if (enc->mode == GST_SPEEX_ENC_MODE_AUTO) {
GST_LOG_OBJECT (enc, "selected NB mode for samplerate %d", enc->rate);
enc->speex_mode = speex_lib_get_mode (SPEEX_MODEID_NB);
} else {
if (enc->speex_mode != speex_lib_get_mode (SPEEX_MODEID_NB)) {
gst_speex_enc_set_last_msg (enc,
"Warning: suggest to use narrow band mode for this rate");
}
}
}
if (enc->rate != 8000 && enc->rate != 16000 && enc->rate != 32000) {
gst_speex_enc_set_last_msg (enc,
"Warning: speex is optimized for 8, 16 and 32 KHz");
}
speex_init_header (&enc->header, enc->rate, 1, enc->speex_mode);
enc->header.frames_per_packet = enc->nframes;
enc->header.vbr = enc->vbr;
enc->header.nb_channels = enc->channels;
/*Initialize Speex encoder */
enc->state = speex_encoder_init (enc->speex_mode);
speex_encoder_ctl (enc->state, SPEEX_GET_FRAME_SIZE, &enc->frame_size);
speex_encoder_ctl (enc->state, SPEEX_SET_COMPLEXITY, &enc->complexity);
speex_encoder_ctl (enc->state, SPEEX_SET_SAMPLING_RATE, &enc->rate);
if (enc->vbr)
speex_encoder_ctl (enc->state, SPEEX_SET_VBR_QUALITY, &enc->quality);
else {
gint tmp = floor (enc->quality);
speex_encoder_ctl (enc->state, SPEEX_SET_QUALITY, &tmp);
}
if (enc->bitrate) {
if (enc->quality >= 0.0 && enc->vbr) {
gst_speex_enc_set_last_msg (enc,
"Warning: bitrate option is overriding quality");
}
speex_encoder_ctl (enc->state, SPEEX_SET_BITRATE, &enc->bitrate);
}
if (enc->vbr) {
gint tmp = 1;
speex_encoder_ctl (enc->state, SPEEX_SET_VBR, &tmp);
} else if (enc->vad) {
gint tmp = 1;
speex_encoder_ctl (enc->state, SPEEX_SET_VAD, &tmp);
}
if (enc->dtx) {
gint tmp = 1;
speex_encoder_ctl (enc->state, SPEEX_SET_DTX, &tmp);
}
if (enc->dtx && !(enc->vbr || enc->abr || enc->vad)) {
gst_speex_enc_set_last_msg (enc,
"Warning: dtx is useless without vad, vbr or abr");
} else if ((enc->vbr || enc->abr) && (enc->vad)) {
gst_speex_enc_set_last_msg (enc,
"Warning: vad is already implied by vbr or abr");
}
if (enc->abr) {
speex_encoder_ctl (enc->state, SPEEX_SET_ABR, &enc->abr);
}
speex_encoder_ctl (enc->state, SPEEX_GET_LOOKAHEAD, &enc->lookahead);
GST_LOG_OBJECT (enc, "we have frame size %d, lookahead %d", enc->frame_size,
enc->lookahead);
return TRUE;
}
AudioInput::AudioInput() {
adjustBandwidth(g.iMaxBandwidth, iAudioQuality, iAudioFrames);
g.iAudioBandwidth = getNetworkBandwidth(iAudioQuality, iAudioFrames);
if (preferCELT(iAudioQuality, iAudioFrames))
umtType = MessageHandler::UDPVoiceCELTAlpha;
else
umtType = MessageHandler::UDPVoiceSpeex;
cCodec = NULL;
ceEncoder = NULL;
if (umtType != MessageHandler::UDPVoiceSpeex) {
iSampleRate = SAMPLE_RATE;
iFrameSize = SAMPLE_RATE / 100;
esSpeex = NULL;
qWarning("AudioInput: %d bits/s, %d hz, %d sample CELT", iAudioQuality, iSampleRate, iFrameSize);
} else {
iAudioFrames /= 2;
speex_bits_init(&sbBits);
speex_bits_reset(&sbBits);
esSpeex = speex_encoder_init(speex_lib_get_mode(SPEEX_MODEID_UWB));
speex_encoder_ctl(esSpeex,SPEEX_GET_FRAME_SIZE,&iFrameSize);
speex_encoder_ctl(esSpeex,SPEEX_GET_SAMPLING_RATE,&iSampleRate);
int iArg=1;
speex_encoder_ctl(esSpeex,SPEEX_SET_VBR, &iArg);
iArg = 0;
speex_encoder_ctl(esSpeex,SPEEX_SET_VAD, &iArg);
speex_encoder_ctl(esSpeex,SPEEX_SET_DTX, &iArg);
float fArg=8.0;
speex_encoder_ctl(esSpeex,SPEEX_SET_VBR_QUALITY, &fArg);
iArg = iAudioQuality;
speex_encoder_ctl(esSpeex, SPEEX_SET_VBR_MAX_BITRATE, &iArg);
iArg = 5;
speex_encoder_ctl(esSpeex,SPEEX_SET_COMPLEXITY, &iArg);
qWarning("AudioInput: %d bits/s, %d hz, %d sample Speex-UWB", iAudioQuality, iSampleRate, iFrameSize);
}
iEchoFreq = iMicFreq = iSampleRate;
iFrameCounter = 0;
iSilentFrames = 0;
iHoldFrames = 0;
bResetProcessor = true;
bEchoMulti = false;
sppPreprocess = NULL;
sesEcho = NULL;
srsMic = srsEcho = NULL;
iJitterSeq = 0;
iMinBuffered = 1000;
psMic = new short[iFrameSize];
psClean = new short[iFrameSize];
psSpeaker = NULL;
iEchoChannels = iMicChannels = 0;
iEchoFilled = iMicFilled = 0;
eMicFormat = eEchoFormat = SampleFloat;
iMicSampleSize = iEchoSampleSize = 0;
bPreviousVoice = false;
pfMicInput = pfEchoInput = pfOutput = NULL;
iBitrate = 0;
dPeakSignal = dPeakSpeaker = dPeakMic = dPeakCleanMic = 0.0;
if (g.uiSession) {
setMaxBandwidth(g.iMaxBandwidth);
}
bRunning = true;
connect(this, SIGNAL(doDeaf()), g.mw->qaAudioDeaf, SLOT(trigger()), Qt::QueuedConnection);
}
void *AudioStreamPlaybackSpeex::process_header(ogg_packet *op, int *frame_size, int *rate, int *nframes, int *channels, int *extra_headers) {
void *st;
SpeexHeader *header;
int modeID;
SpeexCallback callback;
header = speex_packet_to_header((char*)op->packet, op->bytes);
if (!header)
{
OS::get_singleton()->printerr( "Cannot read header\n");
return NULL;
}
if (header->mode >= SPEEX_NB_MODES)
{
OS::get_singleton()->printerr( "Mode number %d does not (yet/any longer) exist in this version\n",
header->mode);
return NULL;
}
modeID = header->mode;
const SpeexMode *mode = speex_lib_get_mode (modeID);
if (header->speex_version_id > 1)
{
OS::get_singleton()->printerr( "This file was encoded with Speex bit-stream version %d, which I don't know how to decode\n", header->speex_version_id);
return NULL;
}
if (mode->bitstream_version < header->mode_bitstream_version)
{
OS::get_singleton()->printerr( "The file was encoded with a newer version of Speex. You need to upgrade in order to play it.\n");
return NULL;
}
if (mode->bitstream_version > header->mode_bitstream_version)
{
OS::get_singleton()->printerr( "The file was encoded with an older version of Speex. You would need to downgrade the version in order to play it.\n");
return NULL;
}
void* state = speex_decoder_init(mode);
if (!state)
{
OS::get_singleton()->printerr( "Decoder initialization failed.\n");
return NULL;
}
//speex_decoder_ctl(state, SPEEX_SET_ENH, &enh_enabled);
speex_decoder_ctl(state, SPEEX_GET_FRAME_SIZE, frame_size);
if (!*rate)
*rate = header->rate;
speex_decoder_ctl(state, SPEEX_SET_SAMPLING_RATE, rate);
*nframes = header->frames_per_packet;
*channels = header->nb_channels;
if (*channels!=1) {
OS::get_singleton()->printerr("Only MONO speex streams supported\n");
return NULL;
}
*extra_headers = header->extra_headers;
speex_free(header);
return state;
}
/*
* Initialize and register Speex codec factory to pjmedia endpoint.
*/
PJ_DEF(pj_status_t) pjmedia_codec_speex_init( pjmedia_endpt *endpt,
unsigned options,
int quality,
int complexity )
{
pjmedia_codec_mgr *codec_mgr;
unsigned i;
pj_status_t status;
if (spx_factory.pool != NULL) {
/* Already initialized. */
return PJ_SUCCESS;
}
/* Get defaults */
if (quality < 0) quality = PJMEDIA_CODEC_SPEEX_DEFAULT_QUALITY;
if (complexity < 0) complexity = PJMEDIA_CODEC_SPEEX_DEFAULT_COMPLEXITY;
/* Validate quality & complexity */
PJ_ASSERT_RETURN(quality >= 0 && quality <= 10, PJ_EINVAL);
PJ_ASSERT_RETURN(complexity >= 1 && complexity <= 10, PJ_EINVAL);
/* Create Speex codec factory. */
spx_factory.base.op = &spx_factory_op;
spx_factory.base.factory_data = NULL;
spx_factory.endpt = endpt;
spx_factory.pool = pjmedia_endpt_create_pool(endpt, "speex",
4000, 4000);
if (!spx_factory.pool)
return PJ_ENOMEM;
pj_list_init(&spx_factory.codec_list);
/* Create mutex. */
status = pj_mutex_create_simple(spx_factory.pool, "speex",
&spx_factory.mutex);
if (status != PJ_SUCCESS)
goto on_error;
/* Initialize default Speex parameter. */
spx_factory.speex_param[PARAM_NB].enabled =
((options & PJMEDIA_SPEEX_NO_NB) == 0);
spx_factory.speex_param[PARAM_NB].pt = PJMEDIA_RTP_PT_SPEEX_NB;
spx_factory.speex_param[PARAM_NB].mode = speex_lib_get_mode(SPEEX_MODEID_NB);
spx_factory.speex_param[PARAM_NB].clock_rate = 8000;
spx_factory.speex_param[PARAM_NB].quality = quality;
spx_factory.speex_param[PARAM_NB].complexity = complexity;
spx_factory.speex_param[PARAM_WB].enabled =
((options & PJMEDIA_SPEEX_NO_WB) == 0);
spx_factory.speex_param[PARAM_WB].pt = PJMEDIA_RTP_PT_SPEEX_WB;
spx_factory.speex_param[PARAM_WB].mode = speex_lib_get_mode(SPEEX_MODEID_WB);
spx_factory.speex_param[PARAM_WB].clock_rate = 16000;
spx_factory.speex_param[PARAM_WB].quality = quality;
spx_factory.speex_param[PARAM_WB].complexity = complexity;
spx_factory.speex_param[PARAM_UWB].enabled =
((options & PJMEDIA_SPEEX_NO_UWB) == 0);
spx_factory.speex_param[PARAM_UWB].pt = PJMEDIA_RTP_PT_SPEEX_UWB;
spx_factory.speex_param[PARAM_UWB].mode = speex_lib_get_mode(SPEEX_MODEID_UWB);
spx_factory.speex_param[PARAM_UWB].clock_rate = 32000;
spx_factory.speex_param[PARAM_UWB].quality = quality;
spx_factory.speex_param[PARAM_UWB].complexity = complexity;
/* Somehow quality <=4 is broken in linux. */
if (quality <= 4 && quality >= 0) {
PJ_LOG(5,(THIS_FILE, "Adjusting quality to 5 for uwb"));
spx_factory.speex_param[PARAM_UWB].quality = 5;
}
/* Get codec framesize and avg bitrate for each mode. */
for (i=0; i<PJ_ARRAY_SIZE(spx_factory.speex_param); ++i) {
status = get_speex_info(&spx_factory.speex_param[i]);
}
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
if (!codec_mgr) {
status = PJ_EINVALIDOP;
goto on_error;
}
/* Register codec factory to endpoint. */
status = pjmedia_codec_mgr_register_factory(codec_mgr,
&spx_factory.base);
if (status != PJ_SUCCESS)
goto on_error;
/* Done. */
return PJ_SUCCESS;
on_error:
pj_pool_release(spx_factory.pool);
spx_factory.pool = NULL;
return status;
}
bool SFB::Audio::OggSpeexDecoder::_Open(CFErrorRef *error)
{
// Initialize Ogg data struct
ogg_sync_init(&mOggSyncState);
// Get the ogg buffer for writing
char *data = ogg_sync_buffer(&mOggSyncState, READ_SIZE_BYTES);
// Read bitstream from input file
ssize_t bytesRead = (ssize_t)GetInputSource().Read(data, READ_SIZE_BYTES);
if(-1 == bytesRead) {
if(error) {
SFB::CFString description(CFCopyLocalizedString(CFSTR("The file “%@” could not be read."), ""));
SFB::CFString failureReason(CFCopyLocalizedString(CFSTR("Read error"), ""));
SFB::CFString recoverySuggestion(CFCopyLocalizedString(CFSTR("Unable to read from the input file."), ""));
*error = CreateErrorForURL(Decoder::ErrorDomain, Decoder::InputOutputError, description, mInputSource->GetURL(), failureReason, recoverySuggestion);
}
ogg_sync_destroy(&mOggSyncState);
return false;
}
// Tell the sync layer how many bytes were written to its internal buffer
int result = ogg_sync_wrote(&mOggSyncState, bytesRead);
if(-1 == result) {
if(error) {
SFB::CFString description(CFCopyLocalizedString(CFSTR("The file “%@” is not a valid Ogg file."), ""));
SFB::CFString failureReason(CFCopyLocalizedString(CFSTR("Not an Ogg file"), ""));
SFB::CFString recoverySuggestion(CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""));
*error = CreateErrorForURL(Decoder::ErrorDomain, Decoder::InputOutputError, description, mInputSource->GetURL(), failureReason, recoverySuggestion);
}
ogg_sync_destroy(&mOggSyncState);
return false;
}
// Turn the data we wrote into an ogg page
result = ogg_sync_pageout(&mOggSyncState, &mOggPage);
if(1 != result) {
if(error) {
SFB::CFString description(CFCopyLocalizedString(CFSTR("The file “%@” is not a valid Ogg file."), ""));
SFB::CFString failureReason(CFCopyLocalizedString(CFSTR("Not an Ogg file"), ""));
SFB::CFString recoverySuggestion(CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""));
*error = CreateErrorForURL(Decoder::ErrorDomain, Decoder::InputOutputError, description, mInputSource->GetURL(), failureReason, recoverySuggestion);
}
ogg_sync_destroy(&mOggSyncState);
return false;
}
// Initialize the stream and grab the serial number
ogg_stream_init(&mOggStreamState, ogg_page_serialno(&mOggPage));
// Get the first Ogg page
result = ogg_stream_pagein(&mOggStreamState, &mOggPage);
if(0 != result) {
if(error) {
SFB::CFString description(CFCopyLocalizedString(CFSTR("The file “%@” is not a valid Ogg file."), ""));
SFB::CFString failureReason(CFCopyLocalizedString(CFSTR("Not an Ogg file"), ""));
SFB::CFString recoverySuggestion(CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""));
*error = CreateErrorForURL(Decoder::ErrorDomain, Decoder::InputOutputError, description, mInputSource->GetURL(), failureReason, recoverySuggestion);
}
ogg_sync_destroy(&mOggSyncState);
return false;
}
// Get the first packet (should be the header) from the page
ogg_packet op;
result = ogg_stream_packetout(&mOggStreamState, &op);
if(1 != result) {
if(error) {
SFB::CFString description(CFCopyLocalizedString(CFSTR("The file “%@” is not a valid Ogg file."), ""));
SFB::CFString failureReason(CFCopyLocalizedString(CFSTR("Not an Ogg file"), ""));
SFB::CFString recoverySuggestion(CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""));
*error = CreateErrorForURL(Decoder::ErrorDomain, Decoder::InputOutputError, description, mInputSource->GetURL(), failureReason, recoverySuggestion);
}
ogg_sync_destroy(&mOggSyncState);
return false;
}
if(op.bytes >= 5 && !memcmp(op.packet, "Speex", 5))
mSpeexSerialNumber = mOggStreamState.serialno;
++mOggPacketCount;
// Convert the packet to the Speex header
SpeexHeader *header = speex_packet_to_header((char *)op.packet, (int)op.bytes);
if(nullptr == header) {
if(error) {
SFB::CFString description(CFCopyLocalizedString(CFSTR("The file “%@” is not a valid Ogg Speex file."), ""));
SFB::CFString failureReason(CFCopyLocalizedString(CFSTR("Not an Ogg Speex file"), ""));
SFB::CFString recoverySuggestion(CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""));
*error = CreateErrorForURL(Decoder::ErrorDomain, Decoder::FileFormatNotRecognizedError, description, mInputSource->GetURL(), failureReason, recoverySuggestion);
}
ogg_sync_destroy(&mOggSyncState);
return false;
}
else if(SPEEX_NB_MODES <= header->mode) {
if(error) {
SFB::CFString description(CFCopyLocalizedString(CFSTR("The Speex mode in the file “%@” is not supported."), ""));
SFB::CFString failureReason(CFCopyLocalizedString(CFSTR("Unsupported Ogg Speex file mode"), ""));
SFB::CFString recoverySuggestion(CFCopyLocalizedString(CFSTR("This file may have been encoded with a newer version of Speex."), ""));
*error = CreateErrorForURL(Decoder::ErrorDomain, Decoder::FileFormatNotSupportedError, description, mInputSource->GetURL(), failureReason, recoverySuggestion);
}
speex_header_free(header);
header = nullptr;
ogg_sync_destroy(&mOggSyncState);
return false;
}
const SpeexMode *mode = speex_lib_get_mode(header->mode);
if(mode->bitstream_version != header->mode_bitstream_version) {
if(error) {
SFB::CFString description(CFCopyLocalizedString(CFSTR("The Speex version in the file “%@” is not supported."), ""));
SFB::CFString failureReason(CFCopyLocalizedString(CFSTR("Unsupported Ogg Speex file version"), ""));
SFB::CFString recoverySuggestion(CFCopyLocalizedString(CFSTR("This file was encoded with a different version of Speex."), ""));
*error = CreateErrorForURL(Decoder::ErrorDomain, Decoder::FileFormatNotSupportedError, description, mInputSource->GetURL(), failureReason, recoverySuggestion);
}
speex_header_free(header);
header = nullptr;
ogg_sync_destroy(&mOggSyncState);
return false;
}
// Initialize the decoder
mSpeexDecoder = speex_decoder_init(mode);
if(nullptr== mSpeexDecoder) {
if(error) {
SFB::CFString description(CFCopyLocalizedString(CFSTR("Unable to initialize the Speex decoder."), ""));
SFB::CFString failureReason(CFCopyLocalizedString(CFSTR("Error initializing Speex decoder"), ""));
SFB::CFString recoverySuggestion(CFCopyLocalizedString(CFSTR("An unknown error occurred."), ""));
*error = CreateErrorForURL(Decoder::ErrorDomain, Decoder::InputOutputError, description, mInputSource->GetURL(), failureReason, recoverySuggestion);
}
speex_header_free(header);
header = nullptr;
ogg_sync_destroy(&mOggSyncState);
return false;
}
speex_decoder_ctl(mSpeexDecoder, SPEEX_SET_SAMPLING_RATE, &header->rate);
mSpeexFramesPerOggPacket = (0 == header->frames_per_packet ? 1 : header->frames_per_packet);
mExtraSpeexHeaderCount = (UInt32)header->extra_headers;
// Initialize the speex bit-packing data structure
speex_bits_init(&mSpeexBits);
// Initialize the stereo mode
mSpeexStereoState = speex_stereo_state_init();
if(2 == header->nb_channels) {
SpeexCallback callback;
callback.callback_id = SPEEX_INBAND_STEREO;
callback.func = speex_std_stereo_request_handler;
callback.data = mSpeexStereoState;
speex_decoder_ctl(mSpeexDecoder, SPEEX_SET_HANDLER, &callback);
}
// Canonical Core Audio format
mFormat.mFormatID = kAudioFormatLinearPCM;
mFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kAudioFormatFlagIsNonInterleaved;
mFormat.mBitsPerChannel = 8 * sizeof(float);
mFormat.mSampleRate = header->rate;
mFormat.mChannelsPerFrame = (UInt32)header->nb_channels;
mFormat.mBytesPerPacket = (mFormat.mBitsPerChannel / 8);
mFormat.mFramesPerPacket = 1;
mFormat.mBytesPerFrame = mFormat.mBytesPerPacket * mFormat.mFramesPerPacket;
mFormat.mReserved = 0;
// Set up the source format
mSourceFormat.mFormatID = 'SPEE';
mSourceFormat.mSampleRate = header->rate;
mSourceFormat.mChannelsPerFrame = (UInt32)header->nb_channels;
switch(header->nb_channels) {
case 1: mChannelLayout = ChannelLayout::ChannelLayoutWithTag(kAudioChannelLayoutTag_Mono); break;
case 2: mChannelLayout = ChannelLayout::ChannelLayoutWithTag(kAudioChannelLayoutTag_Stereo); break;
}
speex_header_free(header);
header = nullptr;
// Allocate the buffer list
spx_int32_t speexFrameSize = 0;
speex_decoder_ctl(mSpeexDecoder, SPEEX_GET_FRAME_SIZE, &speexFrameSize);
if(!mBufferList.Allocate(mFormat, (UInt32)speexFrameSize)) {
if(error)
*error = CFErrorCreate(kCFAllocatorDefault, kCFErrorDomainPOSIX, ENOMEM, nullptr);
speex_stereo_state_destroy(mSpeexStereoState);
mSpeexStereoState = nullptr;
speex_decoder_destroy(mSpeexDecoder);
mSpeexDecoder = nullptr;
speex_bits_destroy(&mSpeexBits);
ogg_sync_destroy(&mOggSyncState);
return false;
}
for(UInt32 i = 0; i < mBufferList->mNumberBuffers; ++i)
mBufferList->mBuffers[i].mDataByteSize = 0;
return true;
}
int test_enc(int argc, char **argv)
{
char *inFile, *outFile, *bitsFile;
FILE *fin, *fout, *fbits=NULL;
short in_short[FRAME_SIZE];
short out_short[FRAME_SIZE];
int snr_frames = 0;
char cbits[200];
int nbBits;
int i;
void *st;
void *dec;
SpeexBits bits;
spx_int32_t tmp;
int bitCount=0;
spx_int32_t skip_group_delay;
SpeexCallback callback;
st = speex_encoder_init(speex_lib_get_mode(SPEEX_MODEID_NB));
dec = speex_decoder_init(speex_lib_get_mode(SPEEX_MODEID_NB));
/* BEGIN: You probably don't need the following in a real application */
callback.callback_id = SPEEX_INBAND_CHAR;
callback.func = speex_std_char_handler;
callback.data = stderr;
speex_decoder_ctl(dec, SPEEX_SET_HANDLER, &callback);
callback.callback_id = SPEEX_INBAND_MODE_REQUEST;
callback.func = speex_std_mode_request_handler;
callback.data = st;
speex_decoder_ctl(dec, SPEEX_SET_HANDLER, &callback);
/* END of unnecessary stuff */
tmp=1;
speex_decoder_ctl(dec, SPEEX_SET_ENH, &tmp);
tmp=0;
speex_encoder_ctl(st, SPEEX_SET_VBR, &tmp);
tmp=8;
speex_encoder_ctl(st, SPEEX_SET_QUALITY, &tmp);
tmp=1;
speex_encoder_ctl(st, SPEEX_SET_COMPLEXITY, &tmp);
/* Turn this off if you want to measure SNR (on by default) */
tmp=1;
speex_encoder_ctl(st, SPEEX_SET_HIGHPASS, &tmp);
speex_decoder_ctl(dec, SPEEX_SET_HIGHPASS, &tmp);
speex_encoder_ctl(st, SPEEX_GET_LOOKAHEAD, &skip_group_delay);
speex_decoder_ctl(dec, SPEEX_GET_LOOKAHEAD, &tmp);
skip_group_delay += tmp;
if (argc != 4 && argc != 3)
{
fprintf (stderr, "Usage: encode [in file] [out file] [bits file]\nargc = %d", argc);
exit(1);
}
inFile = argv[1];
fin = fopen(inFile, "rb");
outFile = argv[2];
fout = fopen(outFile, "wb+");
if (argc==4)
{
bitsFile = argv[3];
fbits = fopen(bitsFile, "wb");
}
speex_bits_init(&bits);
while (!feof(fin))
{
fread(in_short, sizeof(short), FRAME_SIZE, fin);
if (feof(fin))
break;
speex_bits_reset(&bits);
speex_encode_int(st, in_short, &bits);
nbBits = speex_bits_write(&bits, cbits, 200);
bitCount+=bits.nbBits;
if (argc==4)
fwrite(cbits, 1, nbBits, fbits);
speex_bits_rewind(&bits);
speex_decode_int(dec, &bits, out_short);
speex_bits_reset(&bits);
fwrite(&out_short[skip_group_delay], sizeof(short), FRAME_SIZE-skip_group_delay, fout);
skip_group_delay = 0;
}
fprintf (stderr, "Total encoded size: %d bits\n", bitCount);
speex_encoder_destroy(st);
speex_decoder_destroy(dec);
speex_bits_destroy(&bits);
#ifndef DISABLE_FLOAT_API
{
float sigpow,errpow,snr, seg_snr=0;
sigpow = 0;
errpow = 0;
/* This code just computes SNR, so you don't need it either */
rewind(fin);
rewind(fout);
while ( FRAME_SIZE == fread(in_short, sizeof(short), FRAME_SIZE, fin)
&&
FRAME_SIZE == fread(out_short, sizeof(short), FRAME_SIZE,fout) )
{
float s=0, e=0;
for (i=0;i<FRAME_SIZE;++i) {
s += (float)in_short[i] * in_short[i];
e += ((float)in_short[i]-out_short[i]) * ((float)in_short[i]-out_short[i]);
}
seg_snr += 10*log10((s+160)/(e+160));
sigpow += s;
errpow += e;
snr_frames++;
}
snr = 10 * log10( sigpow / errpow );
seg_snr /= snr_frames;
fprintf(stderr,"SNR = %f\nsegmental SNR = %f\n",snr, seg_snr);
#ifdef FIXED_DEBUG
printf ("Total: %f MIPS\n", (float)(1e-6*50*spx_mips/snr_frames));
#endif
}
#endif
fclose(fin);
fclose(fout);
return 0;
}
long speex_create(unsigned int sample_rate,
const char* format_parameters,
amci_codec_fmt_info_t** format_description)
{
int speex_mode = 0, on=1, quality=0;
SpeexState* ss=NULL;
switch(sample_rate) {
case 8000:
speex_mode = SPEEX_MODEID_NB;
quality = 6;
break;
#if SYSTEM_SAMPLECLOCK_RATE >=16000
case 16000:
speex_mode = SPEEX_MODEID_WB;
quality = 8;
break;
#endif
#if SYSTEM_SAMPLECLOCK_RATE >=32000
case 32000:
speex_mode = SPEEX_MODEID_UWB;
quality = 8;
break;
#endif
default:
ERROR("Unsupported sample rate for Speex codec (%u)\n", sample_rate);
return 0;
}
ss = (SpeexState*)malloc(sizeof(SpeexState));
if (!ss) {
ERROR("Could not allocate SpeexState\n");
return 0;
}
/* Note that
1) SEMS ignore a=ptime: SDP parameter so we can choose the one we like
2) Multiple frames in a packet don't need to be byte-aligned
*/
ss->frames_per_packet = FRAMES_PER_PACKET;
/* decode the format parameters */
/* decode_format_parameters(format_parameters, ss); */
speex_bits_init(&ss->encoder.bits);
ss->encoder.state = speex_encoder_init(speex_lib_get_mode(speex_mode));
speex_encoder_ctl(ss->encoder.state, SPEEX_SET_QUALITY, &quality);
speex_bits_init(&ss->decoder.bits);
ss->decoder.state = speex_decoder_init(speex_lib_get_mode(speex_mode));
speex_decoder_ctl(ss->decoder.state, SPEEX_SET_ENH, &on);
ss->fmt_info[0].id = AMCI_FMT_FRAME_LENGTH;
ss->fmt_info[0].value = SPEEX_FRAME_MS * ss->frames_per_packet;
ss->frame_size = SPEEX_FRAME_MS * (sample_rate / 1000);
ss->fmt_info[1].id = AMCI_FMT_FRAME_SIZE;
ss->fmt_info[1].value = ss->frame_size * ss->frames_per_packet;
ss->fmt_info[2].id = 0;
*format_description = ss->fmt_info;
DBG("set AMCI_FMT_FRAME_LENGTH to %d\n", ss->fmt_info[0].value);
DBG("set AMCI_FMT_FRAME_SIZE to %d\n", ss->fmt_info[1].value);
DBG("SpeexState %p inserted with %d frames per packet,\n",
ss, ss->frames_per_packet);
return (long)ss;
}