static int opus_repacketizer_cat_impl(OpusRepacketizer *rp, const unsigned char *data, opus_int32 len, int self_delimited)
{
unsigned char tmp_toc;
int curr_nb_frames,ret;
/* Set of check ToC */
if (len<1) return OPUS_INVALID_PACKET;
if (rp->nb_frames == 0)
{
rp->toc = data[0];
rp->framesize = opus_packet_get_samples_per_frame(data, 8000);
} else if ((rp->toc&0xFC) != (data[0]&0xFC))
{
/*fprintf(stderr, "toc mismatch: 0x%x vs 0x%x\n", rp->toc, data[0]);*/
return OPUS_INVALID_PACKET;
}
curr_nb_frames = opus_packet_get_nb_frames(data, len);
if(curr_nb_frames<1) return OPUS_INVALID_PACKET;
/* Check the 120 ms maximum packet size */
if ((curr_nb_frames+rp->nb_frames)*rp->framesize > 960)
{
return OPUS_INVALID_PACKET;
}
ret=opus_packet_parse_impl(data, len, self_delimited, &tmp_toc, &rp->frames[rp->nb_frames], &rp->len[rp->nb_frames], NULL, NULL);
if(ret<1)return ret;
rp->nb_frames += curr_nb_frames;
return OPUS_OK;
}
void AudioOutputSpeech::addFrameToBuffer(const QByteArray &qbaPacket, unsigned int iSeq) {
QMutexLocker lock(&qmJitter);
if (qbaPacket.size() < 2)
return;
PacketDataStream pds(qbaPacket);
// skip flags
pds.next();
int samples = 0;
if (umtType == MessageHandler::UDPVoiceOpus) {
int size;
pds >> size;
size &= 0x1fff;
const QByteArray &qba = pds.dataBlock(size);
const unsigned char *packet = reinterpret_cast<const unsigned char*>(qba.constData());
#ifdef USE_OPUS
int frames = opus_packet_get_nb_frames(packet, size);
samples = frames * opus_packet_get_samples_per_frame(packet, SAMPLE_RATE);
#else
return;
#endif
// We can't handle frames which are not a multiple of 10ms.
Q_ASSERT(samples % iFrameSize == 0);
} else {
AM_UINT CAudioCodecOpus::decode(AM_U8 *input, AM_UINT inDataSize,
AM_U8 *output, AM_UINT *outDataSize)
{
int totalFrames = opus_packet_get_nb_frames(input, inDataSize);
int totalSamples = (totalFrames > 0) ?
totalFrames * opus_packet_get_samples_per_frame(input, 48000) : -1;
AM_UINT ret = (AM_UINT)-1;
if (AM_LIKELY((totalSamples >= 120) && (totalSamples <= 120*48))) {
*outDataSize = 0;
while (totalSamples > 0) {
int decodedSample = opus_decode(mDecoder, (const unsigned char*)input,
(opus_int32)inDataSize,
(((opus_int16*)output) + *outDataSize),
120*48, 0);
if (AM_LIKELY(decodedSample > 0)) {
totalSamples -= decodedSample;
*outDataSize += decodedSample * sizeof(AM_U16) * 2;
} else {
ret = (AM_UINT)-1;
break;
}
}
if (AM_LIKELY(totalSamples == 0)) {
ret = inDataSize;
}
}
return ret;
}
JNIEXPORT jint JNICALL
Java_org_jitsi_impl_neomedia_codec_audio_opus_Opus_packet_1get_1nb_1frames
(JNIEnv *env, jclass clazz, jbyteArray packet, jint offset, jint length)
{
int ret;
if (packet)
{
jbyte *packet_ = (*env)->GetPrimitiveArrayCritical(env, packet, NULL);
if (packet_)
{
ret
= opus_packet_get_nb_frames(
(unsigned char *) (packet_ + offset),
length);
(*env)->ReleasePrimitiveArrayCritical(
env,
packet, packet_, JNI_ABORT);
}
else
ret = OPUS_ALLOC_FAIL;
}
else
ret = OPUS_BAD_ARG;
return ret;
}
/*****************************************************************************
* DecodePacket: decodes a Opus packet.
*****************************************************************************/
static block_t *DecodePacket( decoder_t *p_dec, ogg_packet *p_oggpacket,
int i_nb_samples, int i_end_trim )
{
decoder_sys_t *p_sys = p_dec->p_sys;
if( !p_oggpacket->bytes )
return NULL;
int spp;
spp=opus_packet_get_nb_frames(p_oggpacket->packet,p_oggpacket->bytes);
if(spp>0)spp*=opus_packet_get_samples_per_frame(p_oggpacket->packet,48000);
if(spp<120||spp>120*48)return NULL;
block_t *p_aout_buffer=decoder_NewAudioBuffer( p_dec, spp );
if ( !p_aout_buffer )
{
msg_Err(p_dec, "Oops: No new buffer was returned!");
return NULL;
}
spp=opus_multistream_decode_float(p_sys->p_st, p_oggpacket->packet,
p_oggpacket->bytes, (float *)p_aout_buffer->p_buffer, spp, 0);
if( spp < 0 || i_nb_samples <= 0 || i_end_trim >= i_nb_samples)
{
block_Release(p_aout_buffer);
if( spp < 0 )
msg_Err( p_dec, "Error: corrupted stream?" );
return NULL;
}
p_aout_buffer->i_buffer = (i_nb_samples - i_end_trim) *
p_sys->header.channels * sizeof(float);
if( spp > i_nb_samples )
{
memmove(p_aout_buffer->p_buffer,
p_aout_buffer->p_buffer
+ (spp - i_nb_samples)*p_sys->header.channels*sizeof(float),
(i_nb_samples - i_end_trim)*p_sys->header.channels*sizeof(float));
}
i_nb_samples -= i_end_trim;
#ifndef OPUS_SET_GAIN
if(p_sys->header.gain!=0)
{
float gain = pow(10., p_sys->header.gain/5120.);
float *buf =(float *)p_aout_buffer->p_buffer;
int i;
for( i = 0; i < i_nb_samples*p_sys->header.channels; i++)
buf[i] *= gain;
}
#endif
p_aout_buffer->i_nb_samples = i_nb_samples;
p_aout_buffer->i_pts = date_Get( &p_sys->end_date );
p_aout_buffer->i_length = date_Increment( &p_sys->end_date, i_nb_samples )
- p_aout_buffer->i_pts;
return p_aout_buffer;
}
// Helper method to return the change in granule position due to an Opus packet
// (as distinct from the number of samples in the packet, which depends on the
// decoder rate). It should work with a multistream Opus file, and continue to
// work should we ever allow the decoder to decode at a rate other than 48 kHz.
// It even works before we've created the actual Opus decoder.
static int GetOpusDeltaGP(ogg_packet* packet)
{
int nframes;
nframes = opus_packet_get_nb_frames(packet->packet, packet->bytes);
if (nframes > 0) {
return nframes*opus_packet_get_samples_per_frame(packet->packet, 48000);
}
NS_WARNING("Invalid Opus packet.");
return nframes;
}
virtual bool Transcode(const void * fromPtr,
unsigned & fromLen,
void * toPtr,
unsigned & toLen,
unsigned & flags)
{
opus_int32 result = opus_encode(m_encoder,
(const opus_int16 *)fromPtr, fromLen/m_channels/2,
(unsigned char *)toPtr, toLen);
if (result < 0) {
PTRACE(1, MY_CODEC_LOG, "Encoder error " << result << ' ' << opus_strerror(result));
return false;
}
toLen = result;
fromLen = opus_packet_get_samples_per_frame((const unsigned char *)toPtr, m_sampleRate) *
opus_packet_get_nb_frames((const unsigned char *)toPtr, toLen) * m_channels * 2;
return true;
}
int WebRtcOpus_DurationEst(OpusDecInst* inst,
const uint8_t* payload,
int payload_length_bytes)
{
int frames, samples;
frames = opus_packet_get_nb_frames(payload, payload_length_bytes);
if (frames < 0) {
/* Invalid payload data. */
return 0;
}
samples = frames * opus_packet_get_samples_per_frame(payload, 48000);
if (samples < 120 || samples > 5760) {
/* Invalid payload duration. */
return 0;
}
/* Compensate for the down-sampling from 48 kHz to 32 kHz.
* This should be removed when the resampling in WebRtcOpus_Decode is
* removed. */
samples = samples * 2 / 3;
return samples;
}
void MumbleClient::createVoicePacket(unsigned char *encoded_audio, int packet_size)
{
int type = 0;
if(_settings->_use_codec2)
type |= (5 << 5);
else
type |= (4 << 5);
int data_size = 1024;
char data[data_size];
data[0] = static_cast<unsigned char>(type);
PacketDataStream pds(data + 1, data_size-1);
int nr_of_frames = opus_packet_get_nb_frames(encoded_audio,packet_size);
// sequence?
pds << _sequence_number;
int real_packet_size = packet_size;
_sequence_number +=nr_of_frames;
//packet_size |= 1 << 13;
pds << packet_size;
char *audio_packet = reinterpret_cast<char*>(encoded_audio);
pds.append(audio_packet,real_packet_size);
unsigned char *bin_data = reinterpret_cast<unsigned char*>(data);
if(_settings->_mumble_tcp) // TCP tunnel
{
this->sendMessage(bin_data,1,pds.size()+1);
}
else // Use UDP
{
this->sendUDPMessage(bin_data,pds.size()+1);
}
}
/**
* Output debug information regarding the state of a single Opus packet
*/
void DebugFrameInfoInternal(const uint8* PacketData, uint32 PacketLength, uint32 SampleRate, bool bEncode)
{
int32 NumFrames = opus_packet_get_nb_frames(PacketData, PacketLength);
if (NumFrames == OPUS_BAD_ARG || NumFrames == OPUS_INVALID_PACKET)
{
UE_LOG(LogVoice, Warning, TEXT("opus_packet_get_nb_frames: Invalid voice packet data!"));
}
int32 NumSamples = opus_packet_get_nb_samples(PacketData, PacketLength, SampleRate);
if (NumSamples == OPUS_BAD_ARG || NumSamples == OPUS_INVALID_PACKET)
{
UE_LOG(LogVoice, Warning, TEXT("opus_packet_get_nb_samples: Invalid voice packet data!"));
}
int32 NumSamplesPerFrame = opus_packet_get_samples_per_frame(PacketData, SampleRate);
int32 Bandwidth = opus_packet_get_bandwidth(PacketData);
const TCHAR* BandwidthStr = NULL;
switch (Bandwidth)
{
case OPUS_BANDWIDTH_NARROWBAND: // Narrowband (4kHz bandpass)
BandwidthStr = TEXT("NB");
break;
case OPUS_BANDWIDTH_MEDIUMBAND: // Mediumband (6kHz bandpass)
BandwidthStr = TEXT("MB");
break;
case OPUS_BANDWIDTH_WIDEBAND: // Wideband (8kHz bandpass)
BandwidthStr = TEXT("WB");
break;
case OPUS_BANDWIDTH_SUPERWIDEBAND: // Superwideband (12kHz bandpass)
BandwidthStr = TEXT("SWB");
break;
case OPUS_BANDWIDTH_FULLBAND: // Fullband (20kHz bandpass)
BandwidthStr = TEXT("FB");
break;
case OPUS_INVALID_PACKET:
default:
BandwidthStr = TEXT("Invalid");
break;
}
/*
* 0
* 0 1 2 3 4 5 6 7
* +-+-+-+-+-+-+-+-+
* | config |s| c |
* +-+-+-+-+-+-+-+-+
*/
uint8 TOC;
// (max 48 x 2.5ms frames in a packet = 120ms)
const uint8* frames[48];
int16 size[48];
int32 payload_offset = 0;
int32 NumFramesParsed = opus_packet_parse(PacketData, PacketLength, &TOC, frames, size, &payload_offset);
// Frame Encoding see http://tools.ietf.org/html/rfc6716#section-3.1
int32 TOCEncoding = (TOC & 0xf8) >> 3;
// Number of channels
bool TOCStereo = (TOC & 0x4) != 0 ? true : false;
// Number of frames and their configuration
// 0: 1 frame in the packet
// 1: 2 frames in the packet, each with equal compressed size
// 2: 2 frames in the packet, with different compressed sizes
// 3: an arbitrary number of frames in the packet
int32 TOCMode = TOC & 0x3;
if (bEncode)
{
UE_LOG(LogVoiceEncode, Verbose, TEXT("PacketLength: %d NumFrames: %d NumSamples: %d Bandwidth: %s Encoding: %d Stereo: %d FrameDesc: %d"),
PacketLength, NumFrames, NumSamples, BandwidthStr, TOCEncoding, TOCStereo, TOCMode);
}
else
{
UE_LOG(LogVoiceDecode, Verbose, TEXT("PacketLength: %d NumFrames: %d NumSamples: %d Bandwidth: %s Encoding: %d Stereo: %d FrameDesc: %d"),
PacketLength, NumFrames, NumSamples, BandwidthStr, TOCEncoding, TOCStereo, TOCMode);
}
}
static pj_status_t opus_codec_decode(pjmedia_codec *codec,
const struct pjmedia_frame *input,
unsigned output_buf_len,
struct pjmedia_frame *output) {
int ret = 0;
struct opus_private *opus;
int frm_cnt, out_size;
unsigned pkt_info, frm_info;
PJ_ASSERT_RETURN(codec && input && output_buf_len && output, PJ_EINVAL);
opus = (struct opus_private *)codec->codec_data;
frm_cnt = opus_packet_get_nb_frames(input->buf, input->size);
pkt_info = input->bit_info & 0xFFFFFF00;
frm_info = input->bit_info & 0xF;
if (opus->pkt_info != pkt_info || input->bit_info == 0) {
opus->pkt_info = pkt_info;
opus->dec_buf_sample_per_frame =
opus_packet_get_samples_per_frame(input->buf, opus->externalFs);
/* We need to decode all the frames in the packet. */
opus->dec_buf_size = opus_decode(
opus->psDec, (const unsigned char *)input->buf, (opus_int32)input->size,
opus->dec_buf, opus->dec_buf_max_size, 0 /* decode FEC */);
if (opus->dec_buf_size <= 0) {
PJ_LOG(3, (THIS_FILE, "Failed to decode frame (err=%d)",
opus->dec_buf_size));
opus->dec_buf_size = 0;
} else {
opus->dec_buf_size = opus->dec_buf_size * opus->pcm_bytes_per_sample;
}
}
/* We have this packet decoded now (either was previously in the buffer or was
* just added to buffer). */
if (opus->dec_buf_size == 0) {
/* The decoding was a failure. */
output->size = 0;
} else {
unsigned frm_size =
opus->dec_buf_sample_per_frame * opus->pcm_bytes_per_sample;
#if _TRACE_OPUS
PJ_LOG(4, (THIS_FILE, "Decode : copy from big buffer %d to %d",
output_buf_len, frm_size));
#endif
if (output_buf_len < frm_size) {
return PJ_ETOOSMALL;
}
/* Copy the decoded frame from the buffer. */
pj_memcpy(output->buf,
((opus_int16 *)opus->dec_buf) + (frm_info * frm_size), frm_size);
output->size = frm_size;
}
if (output->size == 0) {
output->type = PJMEDIA_TYPE_NONE;
output->buf = NULL;
return PJMEDIA_CODEC_EFAILED;
}
output->type = PJMEDIA_TYPE_AUDIO;
output->timestamp = input->timestamp;
#if _TRACE_OPUS
PJ_LOG(4, (THIS_FILE, "Decoded %d to %d with max %d", input->size,
output->size, output_buf_len));
#endif
return PJ_SUCCESS;
}
int main(int argc, char **argv)
{
int c;
int option_index = 0;
char *inFile, *outFile;
FILE *fin, *fout=NULL, *frange=NULL;
float *output;
int frame_size=0;
OpusMSDecoder *st=NULL;
opus_int64 packet_count=0;
int total_links=0;
int stream_init = 0;
int quiet = 0;
ogg_int64_t page_granule=0;
ogg_int64_t link_out=0;
struct option long_options[] =
{
{"help", no_argument, NULL, 0},
{"quiet", no_argument, NULL, 0},
{"version", no_argument, NULL, 0},
{"version-short", no_argument, NULL, 0},
{"rate", required_argument, NULL, 0},
{"gain", required_argument, NULL, 0},
{"no-dither", no_argument, NULL, 0},
{"packet-loss", required_argument, NULL, 0},
{"save-range", required_argument, NULL, 0},
{0, 0, 0, 0}
};
ogg_sync_state oy;
ogg_page og;
ogg_packet op;
ogg_stream_state os;
int close_in=0;
int eos=0;
ogg_int64_t audio_size=0;
double last_coded_seconds=0;
float loss_percent=-1;
float manual_gain=0;
int channels=-1;
int mapping_family;
int rate=0;
int wav_format=0;
int preskip=0;
int gran_offset=0;
int has_opus_stream=0;
ogg_int32_t opus_serialno;
int dither=1;
shapestate shapemem;
SpeexResamplerState *resampler=NULL;
float gain=1;
int streams=0;
size_t last_spin=0;
#ifdef WIN_UNICODE
int argc_utf8;
char **argv_utf8;
#endif
if(query_cpu_support()){
fprintf(stderr,"\n\n** WARNING: This program with compiled with SSE%s\n",query_cpu_support()>1?"2":"");
fprintf(stderr," but this CPU claims to lack these instructions. **\n\n");
}
#ifdef WIN_UNICODE
(void)argc;
(void)argv;
init_console_utf8();
init_commandline_arguments_utf8(&argc_utf8, &argv_utf8);
#endif
output=0;
shapemem.a_buf=0;
shapemem.b_buf=0;
shapemem.mute=960;
shapemem.fs=0;
/*Process options*/
while(1)
{
c = getopt_long (argc_utf8, argv_utf8, "hV",
long_options, &option_index);
if (c==-1)
break;
switch(c)
{
case 0:
if (strcmp(long_options[option_index].name,"help")==0)
{
usage();
quit(0);
} else if (strcmp(long_options[option_index].name,"quiet")==0)
{
quiet = 1;
} else if (strcmp(long_options[option_index].name,"version")==0)
{
version();
quit(0);
} else if (strcmp(long_options[option_index].name,"version-short")==0)
{
version_short();
quit(0);
} else if (strcmp(long_options[option_index].name,"no-dither")==0)
{
dither=0;
} else if (strcmp(long_options[option_index].name,"rate")==0)
{
rate=atoi (optarg);
} else if (strcmp(long_options[option_index].name,"gain")==0)
{
manual_gain=atof (optarg);
}else if(strcmp(long_options[option_index].name,"save-range")==0){
frange=fopen_utf8(optarg,"w");
if(frange==NULL){
perror(optarg);
fprintf(stderr,"Could not open save-range file: %s\n",optarg);
fprintf(stderr,"Must provide a writable file name.\n");
quit(1);
}
} else if (strcmp(long_options[option_index].name,"packet-loss")==0)
{
loss_percent = atof(optarg);
}
break;
case 'h':
usage();
quit(0);
break;
case 'V':
version();
quit(0);
break;
case '?':
usage();
quit(1);
break;
}
}
if (argc_utf8-optind!=2 && argc_utf8-optind!=1)
{
usage();
quit(1);
}
inFile=argv_utf8[optind];
/*Output to a file or playback?*/
if (argc_utf8-optind==2){
/*If we're outputting to a file, should we apply a wav header?*/
int i;
char *ext;
outFile=argv_utf8[optind+1];
ext=".wav";
i=strlen(outFile)-4;
wav_format=i>=0;
while(wav_format&&ext&&outFile[i]) {
wav_format&=tolower(outFile[i++])==*ext++;
}
}else {
outFile="";
wav_format=0;
/*If playing to audio out, default the rate to 48000
instead of the original rate. The original rate is
only important for minimizing surprise about the rate
of output files and preserving length, which aren't
relevant for playback. Many audio devices sound
better at 48kHz and not resampling also saves CPU.*/
if(rate==0)rate=48000;
}
/*Open input file*/
if (strcmp(inFile, "-")==0)
{
#if defined WIN32 || defined _WIN32
_setmode(_fileno(stdin), _O_BINARY);
#endif
fin=stdin;
}
else
{
fin = fopen_utf8(inFile, "rb");
if (!fin)
{
perror(inFile);
quit(1);
}
close_in=1;
}
/* .opus files use the Ogg container to provide framing and timekeeping.
* http://tools.ietf.org/html/draft-terriberry-oggopus
* The easiest way to decode the Ogg container is to use libogg, so
* thats what we do here.
* Using libogg is fairly straight forward-- you take your stream of bytes
* and feed them to ogg_sync_ and it periodically returns Ogg pages, you
* check if the pages belong to the stream you're decoding then you give
* them to libogg and it gives you packets. You decode the packets. The
* pages also provide timing information.*/
ogg_sync_init(&oy);
/*Main decoding loop*/
while (1)
{
char *data;
int i, nb_read;
/*Get the ogg buffer for writing*/
data = ogg_sync_buffer(&oy, 200);
/*Read bitstream from input file*/
nb_read = fread(data, sizeof(char), 200, fin);
ogg_sync_wrote(&oy, nb_read);
/*Loop for all complete pages we got (most likely only one)*/
while (ogg_sync_pageout(&oy, &og)==1)
{
if (stream_init == 0) {
ogg_stream_init(&os, ogg_page_serialno(&og));
stream_init = 1;
}
if (ogg_page_serialno(&og) != os.serialno) {
/* so all streams are read. */
ogg_stream_reset_serialno(&os, ogg_page_serialno(&og));
}
/*Add page to the bitstream*/
ogg_stream_pagein(&os, &og);
page_granule = ogg_page_granulepos(&og);
/*Extract all available packets*/
while (ogg_stream_packetout(&os, &op) == 1)
{
/*OggOpus streams are identified by a magic string in the initial
stream header.*/
if (op.b_o_s && op.bytes>=8 && !memcmp(op.packet, "OpusHead", 8)) {
if(!has_opus_stream)
{
opus_serialno = os.serialno;
has_opus_stream = 1;
link_out = 0;
packet_count = 0;
eos = 0;
total_links++;
} else {
fprintf(stderr,"Warning: ignoring opus stream %" I64FORMAT "\n",(long long)os.serialno);
}
}
if (!has_opus_stream || os.serialno != opus_serialno)
break;
/*If first packet in a logical stream, process the Opus header*/
if (packet_count==0)
{
st = process_header(&op, &rate, &mapping_family, &channels, &preskip, &gain, manual_gain, &streams, wav_format, quiet);
if (!st)
quit(1);
/*Remember how many samples at the front we were told to skip
so that we can adjust the timestamp counting.*/
gran_offset=preskip;
/*Setup the memory for the dithered output*/
if(!shapemem.a_buf)
{
shapemem.a_buf=calloc(channels,sizeof(float)*4);
shapemem.b_buf=calloc(channels,sizeof(float)*4);
shapemem.fs=rate;
}
if(!output)output=malloc(sizeof(float)*MAX_FRAME_SIZE*channels);
/*Normal players should just play at 48000 or their maximum rate,
as described in the OggOpus spec. But for commandline tools
like opusdec it can be desirable to exactly preserve the original
sampling rate and duration, so we have a resampler here.*/
if (rate != 48000)
{
int err;
resampler = speex_resampler_init(channels, 48000, rate, 5, &err);
if (err!=0)
fprintf(stderr, "resampler error: %s\n", speex_resampler_strerror(err));
speex_resampler_skip_zeros(resampler);
}
if(!fout)fout=out_file_open(outFile, &wav_format, rate, mapping_family, &channels);
} else if (packet_count==1)
{
if (!quiet)
print_comments((char*)op.packet, op.bytes);
} else {
int ret;
opus_int64 maxout;
opus_int64 outsamp;
int lost=0;
if (loss_percent>0 && 100*((float)rand())/RAND_MAX<loss_percent)
lost=1;
/*End of stream condition*/
if (op.e_o_s && os.serialno == opus_serialno)eos=1; /* don't care for anything except opus eos */
/*Are we simulating loss for this packet?*/
if (!lost){
/*Decode Opus packet*/
ret = opus_multistream_decode_float(st, (unsigned char*)op.packet, op.bytes, output, MAX_FRAME_SIZE, 0);
} else {
/*Extract the original duration.
Normally you wouldn't have it for a lost packet, but normally the
transports used on lossy channels will effectively tell you.
This avoids opusdec squaking when the decoded samples and
granpos mismatches.*/
opus_int32 lost_size;
lost_size = MAX_FRAME_SIZE;
if(op.bytes>0){
opus_int32 spp;
spp=opus_packet_get_nb_frames(op.packet,op.bytes);
if(spp>0){
spp*=opus_packet_get_samples_per_frame(op.packet,48000/*decoding_rate*/);
if(spp>0)lost_size=spp;
}
}
/*Invoke packet loss concealment.*/
ret = opus_multistream_decode_float(st, NULL, 0, output, lost_size, 0);
}
if(!quiet){
/*Display a progress spinner while decoding.*/
static const char spinner[]="|/-\\";
double coded_seconds = (double)audio_size/(channels*rate*sizeof(short));
if(coded_seconds>=last_coded_seconds+1){
fprintf(stderr,"\r[%c] %02d:%02d:%02d", spinner[last_spin&3],
(int)(coded_seconds/3600),(int)(coded_seconds/60)%60,
(int)(coded_seconds)%60);
fflush(stderr);
last_spin++;
last_coded_seconds=coded_seconds;
}
}
/*If the decoder returned less than zero, we have an error.*/
if (ret<0)
{
fprintf (stderr, "Decoding error: %s\n", opus_strerror(ret));
break;
}
frame_size = ret;
/*If we're collecting --save-range debugging data, collect it now.*/
if(frange!=NULL){
OpusDecoder *od;
opus_uint32 rngs[256];
for(i=0;i<streams;i++){
ret=opus_multistream_decoder_ctl(st,OPUS_MULTISTREAM_GET_DECODER_STATE(i,&od));
ret=opus_decoder_ctl(od,OPUS_GET_FINAL_RANGE(&rngs[i]));
}
save_range(frange,frame_size*(48000/48000/*decoding_rate*/),op.packet,op.bytes,
rngs,streams);
}
/*Apply header gain, if we're not using an opus library new
enough to do this internally.*/
if (gain!=0){
for (i=0;i<frame_size*channels;i++)
output[i] *= gain;
}
/*This handles making sure that our output duration respects
the final end-trim by not letting the output sample count
get ahead of the granpos indicated value.*/
maxout=((page_granule-gran_offset)*rate/48000)-link_out;
outsamp=audio_write(output, channels, frame_size, fout, resampler, &preskip, dither?&shapemem:0, strlen(outFile)!=0,0>maxout?0:maxout);
link_out+=outsamp;
audio_size+=sizeof(short)*outsamp*channels;
}
packet_count++;
}
/*We're done, drain the resampler if we were using it.*/
if(eos && resampler)
{
float *zeros;
int drain;
zeros=(float *)calloc(100*channels,sizeof(float));
drain = speex_resampler_get_input_latency(resampler);
do {
opus_int64 outsamp;
int tmp = drain;
if (tmp > 100)
tmp = 100;
outsamp=audio_write(zeros, channels, tmp, fout, resampler, NULL, &shapemem, strlen(outFile)!=0, ((page_granule-gran_offset)*rate/48000)-link_out);
link_out+=outsamp;
audio_size+=sizeof(short)*outsamp*channels;
drain -= tmp;
} while (drain>0);
free(zeros);
speex_resampler_destroy(resampler);
resampler=NULL;
}
if(eos)
{
has_opus_stream=0;
if(st)opus_multistream_decoder_destroy(st);
st=NULL;
}
}
if (feof(fin)) {
if(!quiet) {
fprintf(stderr, "\rDecoding complete. \n");
fflush(stderr);
}
break;
}
}
/*If we were writing wav, go set the duration.*/
if (strlen(outFile)!=0 && fout && wav_format>=0 && audio_size<0x7FFFFFFF)
{
if (fseek(fout,4,SEEK_SET)==0)
{
int tmp;
tmp = le_int(audio_size+20+wav_format);
if(fwrite(&tmp,4,1,fout)!=1)fprintf(stderr,"Error writing end length.\n");
if (fseek(fout,16+wav_format,SEEK_CUR)==0)
{
tmp = le_int(audio_size);
if(fwrite(&tmp,4,1,fout)!=1)fprintf(stderr,"Error writing header length.\n");
} else
{
fprintf (stderr, "First seek worked, second didn't\n");
}
} else {
fprintf (stderr, "Cannot seek on wave file, size will be incorrect\n");
}
}
/*Did we make it to the end without recovering ANY opus logical streams?*/
if(!total_links)fprintf (stderr, "This doesn't look like a Opus file\n");
if (stream_init)
ogg_stream_clear(&os);
ogg_sync_clear(&oy);
#if defined WIN32 || defined _WIN32
if (strlen(outFile)==0)
WIN_Audio_close ();
#endif
if(shapemem.a_buf)free(shapemem.a_buf);
if(shapemem.b_buf)free(shapemem.b_buf);
if(output)free(output);
if(frange)fclose(frange);
if (close_in)
fclose(fin);
if (fout != NULL)
fclose(fout);
#ifdef WIN_UNICODE
free_commandline_arguments_utf8(&argc_utf8, &argv_utf8);
uninit_console_utf8();
#endif
return 0;
}
