QObject(parent)

, loaded(false)

, _renderer(0)

, _audio(0)

, audio_dec(0)

, video_dec(0)

, audio_thread(0)

, video_thread(0)

, event_filter(0)

, video_capture(0)

, mSpeed(1.0)

, ao_enable(true)

{

mpVOSet = new OutputSet(this);

mpAOSet = new OutputSet(this);

qDebug("%s", aboutQtAV_PlainText().toUtf8().constData());

/*

* call stop() before the window(_renderer) closed to stop the waitcondition

* If close the _renderer widget, the the _renderer may destroy before waking up.

*/

connect(qApp, SIGNAL(aboutToQuit()), SLOT(stop()));

clock = new AVClock(AVClock::AudioClock);

//clock->setClockType(AVClock::ExternalClock);

demuxer.setClock(clock);

connect(&demuxer, SIGNAL(started()), clock, SLOT(start()));

demuxer_thread = new AVDemuxThread(this);

demuxer_thread->setDemuxer(&demuxer);

setPlayerEventFilter(new EventFilter(this));

video_capture = new VideoCapture(this);

{

if (!renderer) {

qWarning("add a null renderer!");

return;

}

renderer->setStatistics(&mStatistics);

QObject *voo = renderer->widget();

if (voo) {

//TODO: how to delete filter if no parent?

//the filtering object must be in the same thread as this object.

if (renderer->widget())

voo->installEventFilter(new VideoOutputEventFilter(renderer));

}

mpVOSet->addOutput(renderer);

{

qDebug(">>>>>>>>>>%s", __FUNCTION__);

#if V1_2

if (_renderer && r) {

VideoRenderer::OutAspectRatioMode oar = _renderer->outAspectRatioMode();

r->setOutAspectRatioMode(oar);

if (oar == VideoRenderer::CustomAspectRation) {

r->setOutAspectRatio(_renderer->outAspectRatio());

}

}

setAVOutput(_renderer, r, video_thread);

if (_renderer) {

qDebug("resizeRenderer after setRenderer");

_renderer->resizeRenderer(_renderer->rendererSize()); //IMPORTANT: the swscaler will resize

}

#else

VideoRenderer *vo = renderer();

if (vo && r) {

VideoRenderer::OutAspectRatioMode oar = vo->outAspectRatioMode();

//r->resizeRenderer(vo->rendererSize());

r->setOutAspectRatioMode(oar);

if (oar == VideoRenderer::CustomAspectRation) {

r->setOutAspectRatio(vo->outAspectRatio());

}

}

if (r) {

r->resizeRenderer(r->rendererSize()); //IMPORTANT: the swscaler will resize

}

r->setStatistics(&mStatistics);

clearVideoRenderers();

addVideoRenderer(r);

#endif //V1_2

{

QList<VideoRenderer*> vos;

vos.reserve(mpVOSet->outputs().size());

foreach (AVOutput *out, mpVOSet->outputs()) {

vos.append(static_cast<VideoRenderer*>(out));

}

return vos;

{

qDebug(">>>>>>>>>>%s", __FUNCTION__);

setAVOutput(_audio, ao, audio_thread);

{

Out *old = pOut;

bool delete_old = false;

if (pOut == pNew) {

qDebug("output not changed: %p", pOut);

if (thread && thread->output() == pNew) {//avthread already set that output

qDebug("avthread already set that output");

return;

}

} else {

pOut = pNew;

delete_old = true;

}

if (!thread) {

qDebug("avthread not ready. can not set output.");

//no avthread, we can delete it safely

//AVOutput must be allocated in heap. Just like QObject's children.

if (delete_old) {

delete old;

old = 0;

}

return;

}

//FIXME: what if isPaused()==false but pause(true) in another thread?

bool need_lock = isPlaying() && !thread->isPaused();

if (need_lock)

thread->lock();

qDebug("set AVThread output");

thread->setOutput(pOut);

if (pOut) {

pOut->setStatistics(&mStatistics);

if (need_lock)

thread->unlock(); //??why here?

}

//now the old avoutput is not used by avthread, we can delete it safely

//AVOutput must be allocated in heap. Just like QObject's children.

if (delete_old) {

delete old;

old = 0;

}

{

if (_audio)

_audio->setMute(mute);

{

if (speed == mSpeed)

return;

mSpeed = speed;

//TODO: check clock type?

if (_audio && _audio->isAvailable()) {

qDebug("set speed %.2f", mSpeed);

_audio->setSpeed(mSpeed);

} else {

masterClock()->setSpeed(mSpeed);

}

emit speedChanged(mSpeed);

{

if (event_filter) {

qApp->removeEventFilter(event_filter);

delete event_filter;

}

event_filter = obj; //the default event filter's parent is this, so AVPlayer will try to delete event_filter

if (obj) {

qApp->installEventFilter(event_filter);

}

{

if (!FilterManager::instance().registerAudioFilter(filter, this)) {

return false;

}

if (!audio_thread)

return false; //install later when avthread created

return audio_thread->installFilter(filter);

{

if (!FilterManager::instance().registerVideoFilter(filter, this)) {

return false;

}

if (!video_thread)

return false; //install later when avthread created

return video_thread->installFilter(filter);

{

if (!FilterManager::instance().unregisterFilter(filter)) {

qWarning("unregister filter %p failed", filter);

return false;

}

/*

* TODO: send FilterUninstallTask(this, filter){this.mFilters.remove} to

* active player's AVThread

*

*/

class UninstallFilterTask : public QRunnable {

public:

UninstallFilterTask(AVThread *thread, Filter *filter):

QRunnable()

, mpThread(thread)

, mpFilter(filter)

{

setAutoDelete(true);

}

virtual void run() {

mpThread->uninstallFilter(mpFilter, false);

//QMetaObject::invokeMethod(FilterManager::instance(), "onUninstallInTargetDone", Qt::AutoConnection, Q_ARG(Filter*, filter));

FilterManager::instance().emitOnUninstallInTargetDone(mpFilter);

}

private:

AVThread *mpThread;

Filter *mpFilter;

};

AVThread *avthread = video_thread;

if (!avthread || !avthread->filters().contains(filter)) {

avthread = audio_thread;

}

if (!avthread || !avthread->filters().contains(filter)) {

return false;

}

avthread->scheduleTask(new UninstallFilterTask(avthread, filter));

return true;

{

this->path = path;

loaded = false; //

//qApp->activeWindow()->setWindowTitle(path); //crash on linux

{

if (!video_capture || !video_thread)

return false;

bool pause_old = isPaused();

if (!video_capture->isAsync())

pause(true);

QString cap_name = QFileInfo(path).completeBaseName();

//FIXME: pts is not correct because of multi-thread

double pts = video_thread->currentPts();

video_capture->setCaptureName(cap_name + "_" + QString::number(pts, 'f', 3));

video_capture->request();

if (!video_capture->isAsync())

pause(pause_old);

return true;

{

setFile(path);

play();

return true;//isPlaying();

{

return (demuxer_thread &&demuxer_thread->isRunning())

|| (audio_thread && audio_thread->isRunning())

|| (video_thread && video_thread->isRunning());

{

//pause thread. check pause state?

demuxer_thread->pause(p);

if (audio_thread)

audio_thread->pause(p);

if (video_thread)

video_thread->pause(p);

clock->pause(p);

emit paused(p);

{

return (demuxer_thread && demuxer_thread->isPaused())

|| (audio_thread && audio_thread->isPaused())

|| (video_thread && video_thread->isPaused());

{

setFile(path);

return load();

{

loaded = false;

if (path.isEmpty()) {

qDebug("No file to play...");

return loaded;

}

qDebug("loading: %s ...", path.toUtf8().constData());

if (!demuxer.loadFile(path)) {

return loaded;

}

loaded = true;

demuxer.dump();

formatCtx = demuxer.formatContext();

aCodecCtx = demuxer.audioCodecContext();

vCodecCtx = demuxer.videoCodecContext();

setupAudioThread();

setupVideoThread();

return loaded;

{

if (isPlaying())

stop();

/*

* avoid load mutiple times when replaying the same seekable file

* TODO: force load unseekable stream? avio.seekable. currently you

* must setFile() agian to reload an unseekable stream

*/

//FIXME: seek(0) for audio without video crashes, why?

//TODO: no eof if replay by seek(0)

if (true || !isLoaded() || !vCodecCtx) { //if (!isLoaded() && !load())

if (!load()) {

mStatistics.reset();

return;

} else {

initStatistics();

}

} else {

qDebug("seek(0)");

demuxer.seek(0); //FIXME: now assume it is seekable. for unseekable, setFile() again

}

Q_ASSERT(clock != 0);

clock->reset();

if (vCodecCtx && video_thread) {

qDebug("Starting video thread...");

video_thread->start();

}

if (aCodecCtx && audio_thread) {

qDebug("Starting audio thread...");

audio_thread->start();

}

demuxer_thread->start();

//blockSignals(false);

emit started();

{

if (!isPlaying())

return;

qDebug("AVPlayer::stop");

//blockSignals(true); //TODO: move emit stopped() before it. or connect avthread.finished() to tryEmitStop() {if (!called_by_stop) emit}

struct avthreads_t {

AVThread *thread;

const char *name;

} threads[] = {

{ audio_thread, "audio thread" },

{ video_thread, "video thread" },

{ 0, 0 }

};

for (int i = 0; threads[i].name; ++i) {

AVThread *thread = threads[i].thread;

if (!thread)

continue;

if (thread->isRunning()) {

qDebug("stopping %s...", threads[i].name);

//avoid emit stopped multiple times. AVThread.stopped() connects to AVDemuxThread.stopped().

thread->blockSignals(true);

thread->stop();

if (!thread->wait(1000)) {

qWarning("Timeout waiting for %s stopped. Terminate it.", threads[i].name);

thread->terminate();

}

thread->blockSignals(false);

}

}

//stop demux thread after avthread is better. otherwise demux thread may be terminated when waiting for avthread ?

if (demuxer_thread->isRunning()) {

qDebug("stopping demux thread...");

demuxer_thread->stop();

//wait for finish then we can safely set the vars, e.g. a/v decoders

if (!demuxer_thread->wait(1000)) {

qWarning("Timeout waiting for demux thread stopped. Terminate it.");

demuxer_thread->terminate(); //Terminate() causes the wait condition destroyed without waking up

}

}

qDebug("all threads [a|v|d] stopped...");

emit stopped();

{

if (!isPlaying()) {

play();

}

demuxer_thread->pause(false);

clock->pause(false);

if (audio_thread)

audio_thread->nextAndPause();

if (video_thread)

video_thread->nextAndPause();

clock->pause(true);

demuxer_thread->pause(true);

{

if (!demuxer_thread->isRunning())

return;

demuxer_thread->seek(pos);

{

if (!demuxer_thread->isRunning())

return;

demuxer_thread->seekForward();

qDebug("seek %f%%", clock->value()/duration()*100.0);

{

if (!demuxer_thread->isRunning())

return;

demuxer_thread->seekBackward();

qDebug("seek %f%%", clock->value()/duration()*100.0);

{

mStatistics.reset();

mStatistics.url = path;

mStatistics.bit_rate = formatCtx->bit_rate;

mStatistics.format = formatCtx->iformat->name;

//AV_TIME_BASE_Q: msvc error C2143

mStatistics.start_time = QTime(0, 0, 0).addMSecs(int((qreal)formatCtx->start_time/(qreal)AV_TIME_BASE*1000.0));

mStatistics.duration = QTime(0, 0, 0).addMSecs(int((qreal)formatCtx->duration/(qreal)AV_TIME_BASE*1000.0));

struct common_statistics_t {

int stream_idx;

AVCodecContext *ctx;

Statistics::Common *st;

const char *name;

} common_statistics[] = {

{ demuxer.audioStream(), aCodecCtx, &mStatistics.audio, "audio"},

{ demuxer.videoStream(), vCodecCtx, &mStatistics.video, "video"},

{ 0, 0, 0, 0}

};

for (int i = 0; common_statistics[i].name; ++i) {

common_statistics_t cs = common_statistics[i];

if (cs.stream_idx < 0)

continue;

AVStream *stream = formatCtx->streams[cs.stream_idx];

qDebug("stream: %p, duration=%lld (%d ms==%f), time_base=%f", stream, stream->duration, int(qreal(stream->duration)*av_q2d(stream->time_base)*1000.0)

, duration(), av_q2d(stream->time_base));

cs.st->available = true;

cs.st->codec = cs.ctx->codec->name;

cs.st->codec_long = cs.ctx->codec->long_name;

cs.st->total_time = QTime(0, 0, 0).addMSecs(int(qreal(stream->duration)*av_q2d(stream->time_base)*1000.0));

cs.st->start_time = QTime(0, 0, 0).addMSecs(int(qreal(stream->start_time)*av_q2d(stream->time_base)*1000.0));

//FIXME: which 1 should we choose? avg_frame_rate may be nan, r_frame_rate may be wrong(guessed value)

qDebug("codec: %s(%s)", qPrintable(cs.st->codec), qPrintable(cs.st->codec_long));

if (stream->avg_frame_rate.num) //avg_frame_rate.num,den may be 0

cs.st->fps_guess = av_q2d(stream->avg_frame_rate);

else

cs.st->fps_guess = av_q2d(stream->r_frame_rate);

cs.st->fps = cs.st->fps_guess;

cs.st->bit_rate = cs.ctx->bit_rate; //formatCtx

cs.st->avg_frame_rate = av_q2d(stream->avg_frame_rate);

cs.st->frames = stream->nb_frames;

//qDebug("time: %f~%f, nb_frames=%lld", cs.st->start_time, cs.st->total_time, stream->nb_frames); //why crash on mac? av_q2d({0,0})?

qDebug("%s fps: r_frame_rate=%f avg_frame_rate=%f", cs.name, av_q2d(stream->r_frame_rate), av_q2d(stream->avg_frame_rate));

}

if (demuxer.audioStream() >= 0) {

mStatistics.audio_only.block_align = aCodecCtx->block_align;

mStatistics.audio_only.channels = aCodecCtx->channels;

char cl[128]; //

av_get_channel_layout_string(cl, sizeof(cl), -1, aCodecCtx->channel_layout); //TODO: ff version

mStatistics.audio_only.channel_layout = cl;

mStatistics.audio_only.sample_fmt = av_get_sample_fmt_name(aCodecCtx->sample_fmt);

mStatistics.audio_only.frame_number = aCodecCtx->frame_number;

mStatistics.audio_only.frame_size = aCodecCtx->frame_size;

mStatistics.audio_only.sample_rate = aCodecCtx->sample_rate;

}

if (demuxer.videoStream() >= 0) {

mStatistics.video.frames = formatCtx->streams[demuxer.videoStream()]->nb_frames;

mStatistics.video_only.coded_height = vCodecCtx->coded_height;

mStatistics.video_only.coded_width = vCodecCtx->coded_width;

mStatistics.video_only.gop_size = vCodecCtx->gop_size;

mStatistics.video_only.pix_fmt = av_get_pix_fmt_name(vCodecCtx->pix_fmt);

mStatistics.video_only.height = vCodecCtx->height;

mStatistics.video_only.width = vCodecCtx->width;

}

{

if (aCodecCtx) {

qDebug("has audio");

//TODO: setAudioOutput() like vo

if (!_audio && ao_enable) {

qDebug("new audio output");

#if QTAV_HAVE(OPENAL)

_audio = new AOOpenAL();

#elif QTAV_HAVE(PORTAUDIO)

_audio = new AOPortAudio();

#endif

}

if (!_audio) {

masterClock()->setClockType(AVClock::ExternalClock);

//return;

} else {

_audio->audioFormat().setSampleFormat(AudioFormat::SampleFormat_Float);

_audio->audioFormat().setSampleRate(aCodecCtx->sample_rate);

// 5, 6, 7 may not play

if (aCodecCtx->channels > 2)

_audio->audioFormat().setChannelLayoutFFmpeg(AV_CH_LAYOUT_STEREO);

else

_audio->audioFormat().setChannels(aCodecCtx->channels);

if (!_audio->open()) {

//return; //audio not ready

}

}

if (!audio_dec) {

audio_dec = new AudioDecoder();

}

qDebug("setCodecContext");

audio_dec->setCodecContext(aCodecCtx);

if (_audio)

audio_dec->resampler()->setOutAudioFormat(_audio->audioFormat());

audio_dec->resampler()->inAudioFormat().setSampleFormatFFmpeg(aCodecCtx->sample_fmt);

audio_dec->resampler()->inAudioFormat().setSampleRate(aCodecCtx->sample_rate);

audio_dec->resampler()->inAudioFormat().setChannels(aCodecCtx->channels);

audio_dec->resampler()->inAudioFormat().setChannelLayoutFFmpeg(aCodecCtx->channel_layout);

audio_dec->prepare();

if (!audio_thread) {

qDebug("new audio thread");

audio_thread = new AudioThread(this);

audio_thread->setClock(clock);

audio_thread->setDecoder(audio_dec);

audio_thread->setStatistics(&mStatistics);

qDebug("demux thread setAudioThread");

demuxer_thread->setAudioThread(audio_thread);

//reconnect if disconnected

QList<Filter*> filters = FilterManager::instance().audioFilters(this);

//TODO: isEmpty()==false but size() == 0 in debug mode, it's a Qt bug? we can not just foreach without check empty in debug mode

if (filters.size() > 0) {

foreach (Filter *filter, filters) {

audio_thread->installFilter(filter);

}

}

}

setAudioOutput(_audio);

/*if has video, connect video's only to avoid emitting stopped() mulltiple times

*otherwise connect audio's. but if video exists previously and now is null.

*audio thread will not change. so connection should be here

*/

if (!vCodecCtx) {

disconnect(audio_thread, SIGNAL(finished()), this, SIGNAL(stopped()));

connect(audio_thread, SIGNAL(finished()), this, SIGNAL(stopped()), Qt::DirectConnection);

}

int queue_min = 0.61803*qMax<qreal>(24.0, mStatistics.video.fps);

int queue_max = int(1.61803*(qreal)queue_min); //about 1 second

audio_thread->packetQueue()->setThreshold(queue_min);

audio_thread->packetQueue()->setCapacity(queue_max);

} else {

//set 0 before delete because demux thread will use the address

//TODO: use avthread** ?

demuxer_thread->setAudioThread(0);

if (audio_thread) {

qDebug("release audio thread.");

delete audio_thread;

audio_thread = 0; //shared ptr?

}

if (audio_dec) {

delete audio_dec;

audio_dec = 0;

}

//DO NOT delete AVOutput. it is setted by user

}

{

if (vCodecCtx) {

if (!video_dec) {

video_dec = VideoDecoderFactory::create(VideoDecoderId_FFmpeg);

}

video_dec->setCodecContext(vCodecCtx);

video_dec->prepare();

if (!video_thread) {

video_thread = new VideoThread(this);

video_thread->setClock(clock);

video_thread->setDecoder(video_dec);

video_thread->setStatistics(&mStatistics);

video_thread->setVideoCapture(video_capture);

video_thread->setOutputSet(mpVOSet);

demuxer_thread->setVideoThread(video_thread);

//reconnect if disconnected

connect(video_thread, SIGNAL(finished()), this, SIGNAL(stopped()), Qt::DirectConnection);

QList<Filter*> filters = FilterManager::instance().videoFilters(this);

if (filters.size() > 0) {

foreach (Filter *filter, filters) {

video_thread->installFilter(filter);

}

}

}

#if V1_2

setRenderer(_renderer);

#endif

int queue_min = 0.61803*qMax<qreal>(24.0, mStatistics.video.fps);

int queue_max = int(1.61803*(qreal)queue_min); //about 1 second

video_thread->packetQueue()->setThreshold(queue_min);

video_thread->packetQueue()->setCapacity(queue_max);

} else {

demuxer_thread->setVideoThread(0); //set 0 before delete. ptr is used in demux thread when set 0

if (video_thread) {

qDebug("release video thread.");

delete video_thread;

video_thread = 0;//shared ptr?

}

if (video_dec) { //TODO: should the decoder managed by avthread?

delete video_dec;

video_dec = 0;

}

//DO NOT delete AVOutput. it is setted by user

}

{

Q_UNUSED(thread);

Q_UNUSED(ctx);