MainWorkflow.cpp 9.22 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
/*****************************************************************************
 * MainWorkflow.cpp : Will query all of the track workflows to render the final
 *                    image
 *****************************************************************************
 * Copyright (C) 2008-2009 the VLMC team
 *
 * Authors: Hugo Beauzee-Luyssen <hugo@vlmc.org>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
 *****************************************************************************/

#include <QtDebug>

#include "MainWorkflow.h"

28
unsigned char*  MainWorkflow::blackOutput = NULL;
29
MainWorkflow*   MainWorkflow::m_instance = NULL;
30

31
MainWorkflow::MainWorkflow( int trackCount ) :
32
        m_length( 0 ),
33 34
        m_trackCount( trackCount ),
        m_renderStarted( false )
35
{
36 37 38 39 40 41
    Q_ASSERT_X( MainWorkflow::m_instance == NULL,
                "MainWorkflow constructor", "Can't have more than one MainWorkflow instance" );
    m_instance = this;

    MainWorkflow::blackOutput = new unsigned char[VIDEOHEIGHT * VIDEOWIDTH * 3];
    memset( MainWorkflow::blackOutput, 0, VIDEOHEIGHT * VIDEOWIDTH * 3 );
42 43 44 45 46 47

    m_tracks = new Toggleable<TrackWorkflow*>[trackCount];
    for (int i = 0; i < trackCount; ++i)
    {
        m_tracks[i].setPtr( new TrackWorkflow( i ) );
        connect( m_tracks[i], SIGNAL( trackEndReached( unsigned int ) ), this, SLOT( trackEndReached(unsigned int) ) );
48
        connect( m_tracks[i], SIGNAL( trackPaused() ), this, SLOT( trackPaused() ) );
49
        connect( m_tracks[i], SIGNAL( renderCompleted( unsigned int ) ), this,  SLOT( tracksRenderCompleted( unsigned int ) ), Qt::QueuedConnection );
50
    }
51
    m_renderStartedLock = new QReadWriteLock;
52
    m_renderMutex = new QMutex;
53 54 55
    m_highestTrackNumberMutex = new QMutex;
    m_synchroneRenderWaitCondition = new QWaitCondition;
    m_synchroneRenderWaitConditionMutex = new QMutex;
56 57 58 59
}

MainWorkflow::~MainWorkflow()
{
60 61
    stop();

62 63 64 65
    delete m_synchroneRenderWaitConditionMutex;
    delete m_synchroneRenderWaitCondition;
    delete m_highestTrackNumberMutex;
    delete m_renderMutex;
66 67 68 69 70
    delete m_renderStartedLock;
    for (unsigned int i = 0; i < m_trackCount; ++i)
        delete m_tracks[i];
    delete[] m_tracks;
    delete[] blackOutput;
71 72
}

73
void    MainWorkflow::addClip( Clip* clip, unsigned int trackId, qint64 start )
74
{
75
    Q_ASSERT_X( trackId < m_trackCount, "MainWorkflow::addClip",
76 77
                "The specified trackId isn't valid, for it's higher than the number of tracks");

78 79 80
    //if the track is deactivated, we need to reactivate it :
    if ( m_tracks[trackId].deactivated() == true )
        m_tracks[trackId].activate();
81
    m_tracks[trackId]->addClip( clip, start );
82 83
    if ( m_tracks[trackId]->getLength() > m_length )
        m_length = m_tracks[trackId]->getLength();
84
}
85

86
void            MainWorkflow::computeLength()
87
{
88 89 90 91 92 93 94 95
    qint64      maxLength = 0;

    for ( unsigned int i = 0; i < m_trackCount; ++i )
    {
        if ( m_tracks[i]->getLength() > maxLength )
            maxLength = m_tracks[i]->getLength();
    }
    m_length = maxLength;
96 97
}

98 99 100 101 102 103 104 105 106 107
void    MainWorkflow::startRender()
{
    m_renderStarted = true;
    m_currentFrame = 0;
    emit frameChanged( 0 );
    for ( unsigned int i = 0; i < m_trackCount; ++i )
        m_tracks[i].activate();
    computeLength();
}

108
void                MainWorkflow::getOutput()
109
{
110
    QReadLocker     lock( m_renderStartedLock );
111
    QMutexLocker    lock2( m_renderMutex );
112

113 114 115 116 117 118
    {
        QMutexLocker    lockHighestTrackNumber( m_highestTrackNumberMutex );
        m_highestTrackNumber = 0;
    }
    m_nbTracksToRender = 0;
    m_synchroneRenderingBuffer = NULL;
119
    if ( m_renderStarted == true )
120
    {
121
        for ( unsigned int i = 0; i < m_trackCount; ++i )
122
        {
123 124
            if ( m_tracks[i].activated() == false )
                continue ;
125

126
            if ( m_tracks[i]->getOutput( m_currentFrame ) != false )
127 128
            {
                m_nbTracksToRender.fetchAndAddAcquire( 1 );
129
                break ;
130
            }
131
        }
132
        nextFrame();
133
    }
134
}
135

136 137
void        MainWorkflow::pause()
{
138 139
    QMutexLocker    lock( m_renderMutex );

140
    m_nbTracksToPause = 0;
141 142 143
    for ( unsigned int i = 0; i < m_trackCount; ++i )
    {
        if ( m_tracks[i].activated() == true )
144 145
        {
            m_nbTracksToPause.fetchAndAddAcquire( 1 );
146
            m_tracks[i]->pause();
147
        }
148 149 150
    }
}

151 152
void        MainWorkflow::nextFrame()
{
153
//    qDebug() << "Going to the next frame";
154
    ++m_currentFrame;
155
    //FIXME: This is probably a bit much...
156 157 158 159 160 161
    emit frameChanged( m_currentFrame );
    emit positionChanged( (float)m_currentFrame / (float)m_length );
}

void        MainWorkflow::previousFrame()
{
162
//    qDebug() << "Going to the previous frame";
163
    --m_currentFrame;
164
    //FIXME: This is probably a bit much...
165 166 167 168
    emit frameChanged( m_currentFrame );
    emit positionChanged( (float)m_currentFrame / (float)m_length );
}

169 170
void        MainWorkflow::setPosition( float pos )
{
171 172
    if ( m_renderStarted == false )
        return ;
173 174 175 176 177
    //Since any track can be reactivated, we reactivate all of them, and let them
    //unable themself if required.
    for ( unsigned int i = 0; i < m_trackCount; ++i)
        m_tracks[i].activate();

chouquette's avatar
chouquette committed
178
    qint64  frame = static_cast<qint64>( (float)m_length * pos );
179 180
    m_currentFrame = frame;
    emit frameChanged( frame );
181
    cancelSynchronisation();
182
    //Do not emit a signal for the RenderWidget, since it's the one that triggered that call...
183 184 185 186 187 188
}

qint64      MainWorkflow::getLength() const
{
    return m_length;
}
189

190
void        MainWorkflow::trackEndReached( unsigned int trackId )
191
{
192 193 194 195 196 197 198
    m_tracks[trackId].deactivate();

    for ( unsigned int i = 0; i < m_trackCount; ++i)
    {
        if ( m_tracks[i].activated() == true )
            return ;
    }
199
    emit mainWorkflowEndReached();
200 201 202
    m_renderStarted = false;
    m_currentFrame = 0;
    emit frameChanged( 0 );
203
}
204 205 206 207 208

unsigned int    MainWorkflow::getTrackCount() const
{
    return m_trackCount;
}
209 210 211 212 213 214 215 216

void            MainWorkflow::stop()
{
    QWriteLocker    lock( m_renderStartedLock );

    m_renderStarted = false;
    for (unsigned int i = 0; i < m_trackCount; ++i)
    {
217 218
        if ( m_tracks[i].activated() == true )
            m_tracks[i]->stop();
219 220 221 222
    }
    m_currentFrame = 0;
    emit frameChanged( 0 );
}
223 224 225 226 227 228

MainWorkflow*   MainWorkflow::getInstance()
{
    Q_ASSERT( m_instance != NULL );
    return m_instance;
}
229

230 231 232 233 234 235 236 237 238
void            MainWorkflow::deleteInstance()
{
    if ( m_instance != NULL )
    {
        delete m_instance;
        m_instance = NULL;
    }
}

239
void           MainWorkflow::clipMoved( QUuid clipUuid, int oldTrack, int newTrack, qint64 startingFrame )
240
{
241 242 243 244 245 246
    Q_ASSERT( newTrack < m_trackCount && oldTrack < m_trackCount && oldTrack >= 0 && newTrack >= 0 );

    if ( oldTrack == newTrack )
    {
        //And now, just move the clip.
        m_tracks[newTrack]->moveClip( clipUuid, startingFrame );
247
        m_tracks[newTrack].activate();
248 249 250 251 252
    }
    else
    {
        Clip* clip = m_tracks[oldTrack]->removeClip( clipUuid );
        m_tracks[newTrack]->addClip( clip, startingFrame );
253 254
        m_tracks[oldTrack].activate();
        m_tracks[newTrack].activate();
255
    }
256
    computeLength();
257
}
258

259 260
void        MainWorkflow::trackPaused()
{
Hugo Beauzee-Luyssen's avatar
Hugo Beauzee-Luyssen committed
261
//    qDebug() << "Track pausing finished...";
262
    m_nbTracksToPause.fetchAndAddAcquire( -1 );
263
    if ( m_nbTracksToPause <= 0 )
264
    {
Hugo Beauzee-Luyssen's avatar
Hugo Beauzee-Luyssen committed
265
//        qDebug() << "\t\t...MainWorkflow is paused";
266 267 268
        emit mainWorkflowPaused();
    }
}
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303

void        MainWorkflow::tracksRenderCompleted( unsigned int trackId )
{
    m_nbTracksToRender.fetchAndAddAcquire( -1 );

    {
        QMutexLocker    lock( m_highestTrackNumberMutex );
        if ( m_highestTrackNumber <= trackId )
        {
            m_highestTrackNumber = trackId;
            m_synchroneRenderingBuffer = m_tracks[trackId]->getSynchroneOutput();
        }
    }
    //We check for minus or equal, since we can have 0 frame to compute,
    //therefore, m_nbTracksToRender will be equal to -1
    if ( m_nbTracksToRender <= 0 )
    {
        //Just a synchronisation barriere
        {
            QMutexLocker    lock( m_synchroneRenderWaitConditionMutex );
        }
        m_synchroneRenderWaitCondition->wakeAll();
    }
}

unsigned char*  MainWorkflow::getSynchroneOutput()
{
    m_synchroneRenderWaitConditionMutex->lock();
    getOutput();
    m_synchroneRenderWaitCondition->wait( m_synchroneRenderWaitConditionMutex );
    m_synchroneRenderWaitConditionMutex->unlock();
    if ( m_synchroneRenderingBuffer == NULL )
        return MainWorkflow::blackOutput;
    return m_synchroneRenderingBuffer;
}
304 305 306 307 308 309 310 311

void        MainWorkflow::cancelSynchronisation()
{
    {
        QMutexLocker    lock( m_synchroneRenderWaitConditionMutex );
    }
    m_synchroneRenderWaitCondition->wakeAll();
}