I am trying to use a custom AVIOContext to open a wav audio file buffer and read the duration along with other audio characteristics. The example code posted blow shows 2 methods of opening the same file. In the case where I call avformat_open_input with the audio.wav file saved on disk, I consistently get the correct duration. When I call avformat_open_input with the audio.wav file saved as a file buffer using a custom AVIOContext, I am not able to get a reasonable value for duration.

From the API documentation, I have tried 3 methods I can find for determining duration without luck. I have tried many different test files to verify the issue and the duration is either zero or a very large negative number. Are there any other methods of getting the duration of an audio stream or am I missing a step before trying to get the duration?

m_audioInfo->duration = static_cast<double>(pFormatContext->duration) / AV_TIME_BASE; m_audioInfo->duration = (pStream->duration / (1/av_q2d(pStream->time_base))); m_audioInfo->duration = pFormatContext->duration; Any help you can provide would be greatly appreciated. Thank you! Below is the code that I am using: #include "AsyncInspectionWorker.h" using namespace v8; using namespace std; const size_t EMPTY = 0; /* User defined data holder that will be passed to avio_alloc_context() */ struct buffer_in_data { uint8_t* ptr; size_t size; }; /* Function for reading the user defined buffer_in_data structure passed to avio_alloc_context() */ static int read_packet(void* opaque, uint8_t* buf, int buf_size) { struct buffer_in_data* bd = (struct buffer_in_data*)opaque; buf_size = FFMIN(buf_size, bd->size); memcpy(buf, bd->ptr, buf_size); bd->ptr += buf_size; bd->size -= buf_size; return buf_size; } AsyncInspectionWorker::AsyncInspectionWorker(string filename, Nan::Callback *callback) : Nan::AsyncWorker(callback) { m_filename = filename; m_buffer_in_size = EMPTY; } AsyncInspectionWorker::AsyncInspectionWorker(char* buffer, size_t bufferSize, Nan::Callback* callback) : Nan::AsyncWorker(callback) { m_buffer_in = buffer; m_buffer_in_size = bufferSize; } void AsyncInspectionWorker::Execute() { AVCodec* pCodec; AVStream* pStream = NULL; AVIOContext* avio_ctx = NULL; AVCodecContext* pCodecContext; AVCodecContext* pCodecContextOrig; AVFormatContext* pFormatContext = avformat_alloc_context(); struct buffer_in_data bd = { 0, 0}; if (m_buffer_in_size != EMPTY) { // This Buffer reading code based on ffmpeg project's doc/examples/avio_reading.c uint8_t* avio_ctx_buffer = NULL; size_t avio_ctx_buffer_size = 4096; bd.ptr = reinterpret_cast<uint8_t*>(m_buffer_in); bd.size = m_buffer_in_size; if (!(avio_ctx_buffer = static_cast<uint8_t*>(av_malloc(avio_ctx_buffer_size)))) { SetErrorMessage("Unable to allocate enough memory for processing"); return; } if (!(avio_ctx = avio_alloc_context(avio_ctx_buffer, avio_ctx_buffer_size, 0, &bd, &read_packet, NULL, NULL))) { SetErrorMessage("Unable to allocate enough memory for processing"); return; } pFormatContext->pb = avio_ctx; if (avformat_open_input(&pFormatContext, NULL, NULL, NULL) < 0) { SetErrorMessage("Unable to read Buffer data"); return; } } else { if (avformat_open_input(&pFormatContext, m_filename.c_str(), NULL, NULL) != 0) { SetErrorMessage("Unable to open file"); return; } } if (avformat_find_stream_info(pFormatContext, NULL) != 0) { SetErrorMessage("Unable to find stream info"); return; } for (unsigned int i = 0; i < pFormatContext->nb_streams; i++) { if (pFormatContext->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO) { pStream = pFormatContext->streams[i]; break; } } if (pStream == NULL) { SetErrorMessage("Unable to find audio stream"); return; } pCodecContextOrig = pStream->codec; pCodec = avcodec_find_decoder(pCodecContextOrig->codec_id); if (pCodec == NULL) { SetErrorMessage("Unsupported codec"); return; } pCodecContext = avcodec_alloc_context3(pCodec); if (avcodec_copy_context(pCodecContext, pCodecContextOrig) != 0) { SetErrorMessage("Unable to copy codec context"); return; } avcodec_open2(pCodecContext, pCodec, NULL); m_audioInfo = new AudioInfo(); //m_audioInfo->duration = static_cast<double>(pFormatContext->duration) / AV_TIME_BASE; //m_audioInfo->duration = (pStream->duration / (1/av_q2d(pStream->time_base))); m_audioInfo->duration = pFormatContext->duration; m_audioInfo->sample_rate = pCodecContext->sample_rate; m_audioInfo->channels = pCodecContext->channels; avcodec_close(pCodecContext); avcodec_close(pCodecContextOrig); avformat_close_input(&pFormatContext); pFormatContext = NULL; if (avio_ctx && avio_ctx != NULL) { av_freep(&avio_ctx->buffer); avio_context_free(&avio_ctx); } } void AsyncInspectionWorker::HandleOKCallback() { Nan::HandleScope scope; const int argc = 1; Local<Object> audioInfo = Nan::New<Object>(); if(m_audioInfo != NULL) { Nan::Set(audioInfo, Nan::New<String>("duration").ToLocalChecked(), Nan::New<Number>(m_audioInfo->duration)); Nan::Set(audioInfo, Nan::New<String>("sampleRate").ToLocalChecked(), Nan::New<Number>(m_audioInfo->sample_rate)); Nan::Set(audioInfo, Nan::New<String>("channels").ToLocalChecked(), Nan::New<Number>(m_audioInfo->channels)); //This inspection reports how the data will look after transcoding, everything is converted to 16 bit (2 bytes) Nan::Set(audioInfo, Nan::New<String>("bitRate").ToLocalChecked(), Nan::New<Number>(16)); Nan::Set(audioInfo, Nan::New<String>("sampleSize").ToLocalChecked(), Nan::New<Number>(2 * m_audioInfo->channels)); delete m_audioInfo; } Local<Value> argv[argc] = {audioInfo}; callback->Call(argc, argv); } void AsyncInspectionWorker::HandleErrorCallback() { Nan::HandleScope scope; const int argc = 1; Local<Object> returnObject = Nan::New<Object>(); Nan::Set(returnObject, Nan::New<String>("error").ToLocalChecked(), Nan::New<v8::String>(ErrorMessage()).ToLocalChecked()); Local<Value> argv[argc] = {returnObject}; callback->Call(argc, argv); }