RtpAudioStream::RtpAudioStream(QObject *parent, _rtp_stream_info *rtp_stream) :
QObject(parent),
decoders_hash_(rtp_decoder_hash_table_new()),
global_start_rel_time_(0.0),
start_abs_offset_(0.0),
start_rel_time_(0.0),
stop_rel_time_(0.0),
audio_out_rate_(0),
audio_resampler_(0),
audio_output_(0),
max_sample_val_(1),
color_(0),
jitter_buffer_size_(50),
timing_mode_(RtpAudioStream::JitterBuffer)
{
copy_address(&src_addr_, &rtp_stream->src_addr);
src_port_ = rtp_stream->src_port;
copy_address(&dst_addr_, &rtp_stream->dest_addr);
dst_port_ = rtp_stream->dest_port;
ssrc_ = rtp_stream->ssrc;
// We keep visual samples in memory. Make fewer of them.
visual_resampler_ = speex_resampler_init(1, default_audio_sample_rate_,
visual_sample_rate_, SPEEX_RESAMPLER_QUALITY_MIN, NULL);
speex_resampler_skip_zeros(visual_resampler_);
QString tempname = QString("%1/wireshark_rtp_stream").arg(QDir::tempPath());
tempfile_ = new QTemporaryFile(tempname, this);
tempfile_->open();
// RTP_STREAM_DEBUG("Writing to %s", tempname.toUtf8().constData());
}
size_t
AudioNodeExternalInputStream::GetTrackMapEntry(const StreamBuffer::Track& aTrack,
GraphTime aFrom)
{
AudioSegment* segment = aTrack.Get<AudioSegment>();
// Check the map for an existing entry corresponding to the input track.
for (size_t i = 0; i < mTrackMap.Length(); ++i) {
TrackMapEntry* map = &mTrackMap[i];
if (map->mTrackID == aTrack.GetID()) {
return i;
}
}
// Determine channel count by finding the first entry with non-silent data.
AudioSegment::ChunkIterator ci(*segment);
while (!ci.IsEnded() && ci->IsNull()) {
ci.Next();
}
if (ci.IsEnded()) {
// The track is entirely silence so far, we can ignore it for now.
return nsTArray<TrackMapEntry>::NoIndex;
}
// Create a speex resampler with the same sample rate and number of channels
// as the track.
SpeexResamplerState* resampler = nullptr;
size_t channelCount = std::min((*ci).mChannelData.Length(),
WebAudioUtils::MaxChannelCount);
if (aTrack.GetRate() != mSampleRate) {
resampler = speex_resampler_init(channelCount,
aTrack.GetRate(), mSampleRate, SPEEX_RESAMPLER_QUALITY_DEFAULT, nullptr);
speex_resampler_skip_zeros(resampler);
}
TrackMapEntry* map = mTrackMap.AppendElement();
map->mEndOfConsumedInputTicks = 0;
map->mEndOfLastInputIntervalInInputStream = -1;
map->mEndOfLastInputIntervalInOutputStream = -1;
map->mSamplesPassedToResampler =
TimeToTicksRoundUp(aTrack.GetRate(), GraphTimeToStreamTime(aFrom));
map->mResampler = resampler;
map->mResamplerChannelCount = channelCount;
map->mTrackID = aTrack.GetID();
return mTrackMap.Length() - 1;
}
bool AudioResampler::Open(FILE* file) {
if (wrapped_decoder->Open(file)) {
wrapped_decoder->GetFormat(input_rate, input_format, nr_of_channels);
//determine if the input format is supported by the resampler
switch (input_format) {
case Format::F32: output_format = input_format; break;
#ifdef HAVE_LIBSPEEXDSP
case Format::S16: output_format = input_format; break;
#endif
default: output_format = Format::F32; break;
}
//Set input format to output_format if possible
wrapped_decoder->SetFormat(input_rate, output_format, nr_of_channels);
//Reread format to get new values
wrapped_decoder->GetFormat(input_rate, input_format, nr_of_channels);
output_rate = input_rate;
#if defined(HAVE_LIBSPEEXDSP)
conversion_state = speex_resampler_init(nr_of_channels, input_rate, output_rate, sampling_quality, &lasterror);
conversion_data.ratio_num = input_rate;
conversion_data.ratio_denom = output_rate;
speex_resampler_skip_zeros(conversion_state);
#elif defined(HAVE_LIBSAMPLERATE)
conversion_state = src_new(sampling_quality, nr_of_channels, &lasterror);
#endif
//Init the conversion data structure
conversion_data.input_frames = 0;
conversion_data.input_frames_used = 0;
finished = false;
if (conversion_state)
return true;
}
conversion_state = nullptr;
return false;
}
void
MediaDecodeTask::Decode()
{
MOZ_ASSERT(!mThreadPool == NS_IsMainThread(),
"We should be on the main thread only if we don't have a thread pool");
mBufferDecoder->BeginDecoding(NS_GetCurrentThread());
// Tell the decoder reader that we are not going to play the data directly,
// and that we should not reject files with more channels than the audio
// bakend support.
mDecoderReader->SetIgnoreAudioOutputFormat();
mDecoderReader->OnDecodeThreadStart();
MediaInfo mediaInfo;
nsAutoPtr<MetadataTags> tags;
nsresult rv = mDecoderReader->ReadMetadata(&mediaInfo, getter_Transfers(tags));
if (NS_FAILED(rv)) {
ReportFailureOnMainThread(WebAudioDecodeJob::InvalidContent);
return;
}
if (!mDecoderReader->HasAudio()) {
ReportFailureOnMainThread(WebAudioDecodeJob::NoAudio);
return;
}
while (mDecoderReader->DecodeAudioData()) {
// consume all of the buffer
continue;
}
mDecoderReader->OnDecodeThreadFinish();
MediaQueue<AudioData>& audioQueue = mDecoderReader->AudioQueue();
uint32_t frameCount = audioQueue.FrameCount();
uint32_t channelCount = mediaInfo.mAudio.mChannels;
uint32_t sampleRate = mediaInfo.mAudio.mRate;
if (!frameCount || !channelCount || !sampleRate) {
ReportFailureOnMainThread(WebAudioDecodeJob::InvalidContent);
return;
}
const uint32_t destSampleRate = mDecodeJob.mContext->SampleRate();
AutoResampler resampler;
uint32_t resampledFrames = frameCount;
if (sampleRate != destSampleRate) {
resampledFrames = static_cast<uint32_t>(
static_cast<uint64_t>(destSampleRate) *
static_cast<uint64_t>(frameCount) /
static_cast<uint64_t>(sampleRate)
);
resampler = speex_resampler_init(channelCount,
sampleRate,
destSampleRate,
SPEEX_RESAMPLER_QUALITY_DEFAULT, nullptr);
speex_resampler_skip_zeros(resampler);
resampledFrames += speex_resampler_get_output_latency(resampler);
}
// Allocate the channel buffers. Note that if we end up resampling, we may
// write fewer bytes than mResampledFrames to the output buffer, in which
// case mWriteIndex will tell us how many valid samples we have.
static const fallible_t fallible = fallible_t();
bool memoryAllocationSuccess = true;
if (!mDecodeJob.mChannelBuffers.SetLength(channelCount)) {
memoryAllocationSuccess = false;
} else {
for (uint32_t i = 0; i < channelCount; ++i) {
mDecodeJob.mChannelBuffers[i] = new(fallible) float[resampledFrames];
if (!mDecodeJob.mChannelBuffers[i]) {
memoryAllocationSuccess = false;
break;
}
}
}
if (!memoryAllocationSuccess) {
ReportFailureOnMainThread(WebAudioDecodeJob::UnknownError);
return;
}
nsAutoPtr<AudioData> audioData;
while ((audioData = audioQueue.PopFront())) {
audioData->EnsureAudioBuffer(); // could lead to a copy :(
AudioDataValue* bufferData = static_cast<AudioDataValue*>
(audioData->mAudioBuffer->Data());
if (sampleRate != destSampleRate) {
const uint32_t maxOutSamples = resampledFrames - mDecodeJob.mWriteIndex;
for (uint32_t i = 0; i < audioData->mChannels; ++i) {
uint32_t inSamples = audioData->mFrames;
uint32_t outSamples = maxOutSamples;
WebAudioUtils::SpeexResamplerProcess(
resampler, i, &bufferData[i * audioData->mFrames], &inSamples,
mDecodeJob.mChannelBuffers[i] + mDecodeJob.mWriteIndex,
&outSamples);
if (i == audioData->mChannels - 1) {
mDecodeJob.mWriteIndex += outSamples;
MOZ_ASSERT(mDecodeJob.mWriteIndex <= resampledFrames);
MOZ_ASSERT(inSamples == audioData->mFrames);
}
}
} else {
for (uint32_t i = 0; i < audioData->mChannels; ++i) {
ConvertAudioSamples(&bufferData[i * audioData->mFrames],
mDecodeJob.mChannelBuffers[i] + mDecodeJob.mWriteIndex,
audioData->mFrames);
if (i == audioData->mChannels - 1) {
mDecodeJob.mWriteIndex += audioData->mFrames;
}
}
}
}
if (sampleRate != destSampleRate) {
uint32_t inputLatency = speex_resampler_get_input_latency(resampler);
const uint32_t maxOutSamples = resampledFrames - mDecodeJob.mWriteIndex;
for (uint32_t i = 0; i < channelCount; ++i) {
uint32_t inSamples = inputLatency;
uint32_t outSamples = maxOutSamples;
WebAudioUtils::SpeexResamplerProcess(
resampler, i, (AudioDataValue*)nullptr, &inSamples,
mDecodeJob.mChannelBuffers[i] + mDecodeJob.mWriteIndex,
&outSamples);
if (i == channelCount - 1) {
mDecodeJob.mWriteIndex += outSamples;
MOZ_ASSERT(mDecodeJob.mWriteIndex <= resampledFrames);
MOZ_ASSERT(inSamples == inputLatency);
}
}
}
mPhase = PhaseEnum::AllocateBuffer;
RunNextPhase();
}
void
MediaDecodeTask::FinishDecode()
{
mDecoderReader->Shutdown();
uint32_t frameCount = mAudioQueue.FrameCount();
uint32_t channelCount = mMediaInfo.mAudio.mChannels;
uint32_t sampleRate = mMediaInfo.mAudio.mRate;
if (!frameCount || !channelCount || !sampleRate) {
ReportFailureOnMainThread(WebAudioDecodeJob::InvalidContent);
return;
}
const uint32_t destSampleRate = mDecodeJob.mContext->SampleRate();
AutoResampler resampler;
uint32_t resampledFrames = frameCount;
if (sampleRate != destSampleRate) {
resampledFrames = static_cast<uint32_t>(
static_cast<uint64_t>(destSampleRate) *
static_cast<uint64_t>(frameCount) /
static_cast<uint64_t>(sampleRate)
);
resampler = speex_resampler_init(channelCount,
sampleRate,
destSampleRate,
SPEEX_RESAMPLER_QUALITY_DEFAULT, nullptr);
speex_resampler_skip_zeros(resampler);
resampledFrames += speex_resampler_get_output_latency(resampler);
}
// Allocate the channel buffers. Note that if we end up resampling, we may
// write fewer bytes than mResampledFrames to the output buffer, in which
// case mWriteIndex will tell us how many valid samples we have.
mDecodeJob.mBuffer = ThreadSharedFloatArrayBufferList::
Create(channelCount, resampledFrames, fallible);
if (!mDecodeJob.mBuffer) {
ReportFailureOnMainThread(WebAudioDecodeJob::UnknownError);
return;
}
RefPtr<MediaData> mediaData;
while ((mediaData = mAudioQueue.PopFront())) {
RefPtr<AudioData> audioData = mediaData->As<AudioData>();
audioData->EnsureAudioBuffer(); // could lead to a copy :(
AudioDataValue* bufferData = static_cast<AudioDataValue*>
(audioData->mAudioBuffer->Data());
if (sampleRate != destSampleRate) {
const uint32_t maxOutSamples = resampledFrames - mDecodeJob.mWriteIndex;
for (uint32_t i = 0; i < audioData->mChannels; ++i) {
uint32_t inSamples = audioData->mFrames;
uint32_t outSamples = maxOutSamples;
float* outData =
mDecodeJob.mBuffer->GetDataForWrite(i) + mDecodeJob.mWriteIndex;
WebAudioUtils::SpeexResamplerProcess(
resampler, i, &bufferData[i * audioData->mFrames], &inSamples,
outData, &outSamples);
if (i == audioData->mChannels - 1) {
mDecodeJob.mWriteIndex += outSamples;
MOZ_ASSERT(mDecodeJob.mWriteIndex <= resampledFrames);
MOZ_ASSERT(inSamples == audioData->mFrames);
}
}
} else {
for (uint32_t i = 0; i < audioData->mChannels; ++i) {
float* outData =
mDecodeJob.mBuffer->GetDataForWrite(i) + mDecodeJob.mWriteIndex;
ConvertAudioSamples(&bufferData[i * audioData->mFrames],
outData, audioData->mFrames);
if (i == audioData->mChannels - 1) {
mDecodeJob.mWriteIndex += audioData->mFrames;
}
}
}
}
if (sampleRate != destSampleRate) {
uint32_t inputLatency = speex_resampler_get_input_latency(resampler);
const uint32_t maxOutSamples = resampledFrames - mDecodeJob.mWriteIndex;
for (uint32_t i = 0; i < channelCount; ++i) {
uint32_t inSamples = inputLatency;
uint32_t outSamples = maxOutSamples;
float* outData =
mDecodeJob.mBuffer->GetDataForWrite(i) + mDecodeJob.mWriteIndex;
WebAudioUtils::SpeexResamplerProcess(
resampler, i, (AudioDataValue*)nullptr, &inSamples,
outData, &outSamples);
if (i == channelCount - 1) {
mDecodeJob.mWriteIndex += outSamples;
MOZ_ASSERT(mDecodeJob.mWriteIndex <= resampledFrames);
MOZ_ASSERT(inSamples == inputLatency);
}
}
}
mPhase = PhaseEnum::AllocateBuffer;
NS_DispatchToMainThread(this);
}
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;
}
void RtpAudioStream::decode()
{
if (rtp_packets_.size() < 1) return;
// gtk/rtp_player.c:decode_rtp_stream
// XXX This is more messy than it should be.
gsize resample_buff_len = 0x1000;
SAMPLE *resample_buff = (SAMPLE *) g_malloc(resample_buff_len);
spx_uint32_t cur_in_rate = 0, visual_out_rate = 0;
char *write_buff = NULL;
qint64 write_bytes = 0;
unsigned channels = 0;
unsigned sample_rate = 0;
int last_sequence = 0;
double rtp_time_prev = 0.0;
double arrive_time_prev = 0.0;
double pack_period = 0.0;
double start_time = 0.0;
double start_rtp_time = 0.0;
guint32 start_timestamp = 0;
size_t decoded_bytes_prev = 0;
for (int cur_packet = 0; cur_packet < rtp_packets_.size(); cur_packet++) {
SAMPLE *decode_buff = NULL;
// XXX The GTK+ UI updates a progress bar here.
rtp_packet_t *rtp_packet = rtp_packets_[cur_packet];
stop_rel_time_ = start_rel_time_ + rtp_packet->arrive_offset;
speex_resampler_get_rate(visual_resampler_, &cur_in_rate, &visual_out_rate);
QString payload_name;
if (rtp_packet->info->info_payload_type_str) {
payload_name = rtp_packet->info->info_payload_type_str;
} else {
payload_name = try_val_to_str_ext(rtp_packet->info->info_payload_type, &rtp_payload_type_short_vals_ext);
}
if (!payload_name.isEmpty()) {
payload_names_ << payload_name;
}
if (cur_packet < 1) { // First packet
start_timestamp = rtp_packet->info->info_timestamp;
start_rtp_time = 0;
rtp_time_prev = 0;
last_sequence = rtp_packet->info->info_seq_num - 1;
}
size_t decoded_bytes = decode_rtp_packet(rtp_packet, &decode_buff, decoders_hash_, &channels, &sample_rate);
if (decoded_bytes == 0 || sample_rate == 0) {
// We didn't decode anything. Clean up and prep for the next packet.
last_sequence = rtp_packet->info->info_seq_num;
g_free(decode_buff);
continue;
}
if (audio_out_rate_ == 0) { // First non-zero wins
audio_out_rate_ = sample_rate;
RTP_STREAM_DEBUG("Audio sample rate is %u", audio_out_rate_);
// Prepend silence to match our sibling streams.
tempfile_->seek(0);
int prepend_samples = (start_rel_time_ - global_start_rel_time_) * audio_out_rate_;
if (prepend_samples > 0) {
writeSilence(prepend_samples);
}
}
if (rtp_packet->info->info_seq_num != last_sequence+1) {
out_of_seq_timestamps_.append(stop_rel_time_);
}
last_sequence = rtp_packet->info->info_seq_num;
double rtp_time = (double)(rtp_packet->info->info_timestamp-start_timestamp)/sample_rate - start_rtp_time;
double arrive_time;
if (timing_mode_ == RtpTimestamp) {
arrive_time = rtp_time;
} else {
arrive_time = rtp_packet->arrive_offset - start_time;
}
double diff = qAbs(arrive_time - rtp_time);
if (diff*1000 > jitter_buffer_size_ && timing_mode_ != Uninterrupted) {
// rtp_player.c:628
jitter_drop_timestamps_.append(stop_rel_time_);
RTP_STREAM_DEBUG("Packet drop by jitter buffer exceeded %f > %d", diff*1000, jitter_buffer_size_);
/* if there was a silence period (more than two packetization period) resync the source */
if ((rtp_time - rtp_time_prev) > pack_period*2) {
int silence_samples;
RTP_STREAM_DEBUG("Resync...");
silence_samples = (int)((arrive_time - arrive_time_prev)*sample_rate - decoded_bytes_prev / sample_bytes_);
/* Fix for bug 4119/5902: don't insert too many silence frames.
* XXX - is there a better thing to do here?
*/
silence_samples = qMin(silence_samples, max_silence_samples_);
writeSilence(silence_samples);
silence_timestamps_.append(stop_rel_time_);
decoded_bytes_prev = 0;
/* defined start_timestmp to avoid overflow in timestamp. TODO: handle the timestamp correctly */
/* XXX: if timestamps (RTP) are missing/ignored try use packet arrive time only (see also "rtp_time") */
start_timestamp = rtp_packet->info->info_timestamp;
start_rtp_time = 0;
start_time = rtp_packet->arrive_offset;
rtp_time_prev = 0;
}
} else {
// rtp_player.c:664
/* Add silence if it is necessary */
int silence_samples;
if (timing_mode_ == Uninterrupted) {
silence_samples = 0;
} else {
silence_samples = (int)((rtp_time - rtp_time_prev)*sample_rate - decoded_bytes_prev / sample_bytes_);
}
if (silence_samples != 0) {
wrong_timestamp_timestamps_.append(stop_rel_time_);
}
if (silence_samples > 0) {
/* Fix for bug 4119/5902: don't insert too many silence frames.
* XXX - is there a better thing to do here?
*/
silence_samples = qMin(silence_samples, max_silence_samples_);
writeSilence(silence_samples);
silence_timestamps_.append(stop_rel_time_);
}
// XXX rtp_player.c:696 adds audio here.
rtp_time_prev = rtp_time;
pack_period = (double) decoded_bytes / sample_bytes_ / sample_rate;
decoded_bytes_prev = decoded_bytes;
arrive_time_prev = arrive_time;
}
// Write samples to our file.
write_buff = (char *) decode_buff;
write_bytes = decoded_bytes;
if (audio_out_rate_ != sample_rate) {
// Resample the audio to match our previous output rate.
if (!audio_resampler_) {
audio_resampler_ = speex_resampler_init(1, sample_rate, audio_out_rate_, 10, NULL);
speex_resampler_skip_zeros(audio_resampler_);
RTP_STREAM_DEBUG("Started resampling from %u to (out) %u Hz.", sample_rate, audio_out_rate_);
} else {
spx_uint32_t audio_out_rate;
speex_resampler_get_rate(audio_resampler_, &cur_in_rate, &audio_out_rate);
// Adjust rates if needed.
if (sample_rate != cur_in_rate) {
speex_resampler_set_rate(audio_resampler_, sample_rate, audio_out_rate);
speex_resampler_set_rate(visual_resampler_, sample_rate, visual_out_rate);
RTP_STREAM_DEBUG("Changed input rate from %u to %u Hz. Out is %u.", cur_in_rate, sample_rate, audio_out_rate_);
}
}
spx_uint32_t in_len = (spx_uint32_t)rtp_packet->info->info_payload_len;
spx_uint32_t out_len = (audio_out_rate_ * (spx_uint32_t)rtp_packet->info->info_payload_len / sample_rate) + (audio_out_rate_ % sample_rate != 0);
if (out_len * sample_bytes_ > resample_buff_len) {
while ((out_len * sample_bytes_ > resample_buff_len))
resample_buff_len *= 2;
resample_buff = (SAMPLE *) g_realloc(resample_buff, resample_buff_len);
}
speex_resampler_process_int(audio_resampler_, 0, decode_buff, &in_len, resample_buff, &out_len);
write_buff = (char *) decode_buff;
write_bytes = out_len * sample_bytes_;
}
// Write the decoded, possibly-resampled audio to our temp file.
tempfile_->write(write_buff, write_bytes);
// Collect our visual samples.
spx_uint32_t in_len = (spx_uint32_t)rtp_packet->info->info_payload_len;
spx_uint32_t out_len = (visual_out_rate * in_len / sample_rate) + (visual_out_rate % sample_rate != 0);
if (out_len * sample_bytes_ > resample_buff_len) {
while ((out_len * sample_bytes_ > resample_buff_len))
resample_buff_len *= 2;
resample_buff = (SAMPLE *) g_realloc(resample_buff, resample_buff_len);
}
speex_resampler_process_int(visual_resampler_, 0, decode_buff, &in_len, resample_buff, &out_len);
for (unsigned i = 0; i < out_len; i++) {
packet_timestamps_[stop_rel_time_ + (double) i / visual_out_rate] = rtp_packet->frame_num;
if (qAbs(resample_buff[i]) > max_sample_val_) max_sample_val_ = qAbs(resample_buff[i]);
visual_samples_.append(resample_buff[i]);
}
// Finally, write the resampled audio to our temp file and clean up.
g_free(decode_buff);
}
g_free(resample_buff);
}
