I am using QTGstreamer in my application to play media files of .webm & .flv formats. The movies of length 5-10 secs play in a loop continuously.
I have observed huge memory leak while playing these small movies. Instead if I play a long (approx 1 hour) movie, the leak is almost negligible.
Please suggest some solution.
Below is the source code

[MAIN.CPP]

    #include "mediaapp.h"
    #include <QtGui/QApplication>
    #include <QGst/init.h>
     
    int main (int argc, char *argv [] )
    {
    QApplication app ( argc, argv );
    QGst :: init ( &argc, &argv );
     
    MediaApp media;
    media .show();
    media .openFile ("file://XYZ.webm");
    return app .exec();
    }


[MEDIAAPP.H]

    #ifndef MEDIAAPP_H_
    #define MEDIAAPP_H_
     
    #include <QtGui/QWidget>
    #include <QtGui/QStyle>
    #include <QtCore/QTimer>
     
    class Player;
    class QBoxLayout;
    class QTimer;
     
    class MediaApp : public QWidget
    {
    Q_OBJECT
    public:
    MediaApp(QWidget *parent = 0);
    ~MediaApp();
    void openFile(const QString & fileName);
     
     
     
    private Q_SLOTS:
    void onStateChanged();
     
    private:
    void createUI(QBoxLayout *appLayout);
    Player *m_player;
    };



[MEDIAAPP.CPP]

    #include "mediaapp.h"
    #include "player.h"
    #include <QtGui/QBoxLayout>
     
    MediaApp::MediaApp (QWidget *parent)
    : QWidget (parent)
    {
    //create the player
    m_player = new Player (this);
    connect (m_player, SIGNAL ( stateChanged() ), this, SLOT( onStateChanged() ) );
     
    //create the UI
    QVBoxLayout *appLayout = new QVBoxLayout;
    appLayout ->setContentsMargins (0, 0, 0, 0);
    appLayout ->addWidget (m_player);
     
    setLayout (appLayout);
    setWindowFlags (Qt::FramelessWindowHint);/* enable this for frameless window */
    }
     
    MediaApp::~MediaApp()
    {
    delete m_player;
    }
     
    void MediaApp::openFile(const QString & fileName)
    {
    m_player->stop();
    m_player->setUri(fileName);
    m_player->play();
    }



[PLAYER.H]

    #ifndef PLAYER_H_
    #define PLAYER_H_
     
    #include <QtCore/QTimer>
    #include <QtCore/QTime>
    #include <QGst/Pipeline>
    #include <QGst/Ui/VideoWidget>
     
    class Player : public QGst :: Ui :: VideoWidget
    {
    Q_OBJECT
    public:
    Player(QWidget *parent = 0);
    ~Player();
     
    void setUri(const QString & uri);
    QGst :: State state() const;
     
    public Q_SLOTS:
    void play();
     
    Q_SIGNALS:
    void positionChanged();
    void stateChanged();
     
    private:
    void onBusMessage(const QGst :: MessagePtr & message);
    void handlePipelineStateChange(const QGst :: StateChangedMessagePtr & scm);
     
    QGst :: PipelinePtr m_pipeline;
    QTimer m_positionTimer;
    };
     
    #endif /* PLAYER_H_ */



[PLAYER.CPP]

    #include "player.h"
    #include <QtCore/QDir>
    #include <QtCore/QUrl>
    #include <QGlib/Connect>
    #include <QGlib/Error>
    #include <QGst/Pipeline>
    #include <QGst/ElementFactory>
    #include <QGst/Bus>
    #include <QGst/Message>
    #include <QGst/Query>
    #include <QGst/ClockTime>
    #include <QGst/Event>
    #include <QGst/StreamVolume>
     
    Player::Player(QWidget *parent)
    : QGst :: Ui :: VideoWidget(parent)
    {
    //this timer is used to tell the ui to change its position slider & label
    //every 100 ms, but only when the pipeline is playing
    // connect ( &m_positionTimer, SIGNAL ( timeout () ), this, SIGNAL ( positionChanged () ) );
    }
     
    Player :: ~Player ()
    {
    if (m_pipeline) {
    m_pipeline ->setState (QGst :: StateNull );
    stopPipelineWatch ();
    }
    }
     
    void Player :: setUri (const QString & uri)
    {
    QString realUri = uri;
    //if uri is not a real uri, assume it is a file path
    if (realUri.indexOf("://") < 0) {
    realUri = QUrl :: fromLocalFile (realUri) .toEncoded();
    }
     
     
    if ( !m_pipeline )
    {
    m_pipeline = QGst :: ElementFactory :: make ("playbin2") .dynamicCast <QGst::Pipeline>();
    if (m_pipeline)
    {
    //let the video widget watch the pipeline for new video sinks
    watchPipeline (m_pipeline);
    //watch the bus for messages
    QGst :: BusPtr bus = m_pipeline ->bus();
    bus ->addSignalWatch();
    QGlib :: connect (bus, "message", this, &Player :: onBusMessage);
    }
    else
    {
    qCritical() << "Failed to create the pipeline";
    }
    }
     
    if (m_pipeline)
    {
    m_pipeline- >setProperty ("uri", realUri);
    }
    }
     
     
    QGst :: State Player :: state() const
    {
    return m_pipeline ? m_pipeline->currentState() : QGst :: StateNull;
    }
     
    void Player :: play()
    {
    if (m_pipeline)
    {
    m_pipeline ->setState(QGst :: StatePlaying);
    }
    }
     
    void Player::onBusMessage(const QGst::MessagePtr & message)
    {
    switch ( message->type()) {
    case QGst :: MessageEos : //End of stream. We reached the end of the file.
    {
    if (m_pipeline)
    {
    m_pipeline->setState(QGst::StateNull);
    m_pipeline->setState(QGst::StatePlaying);
    }
    }
    break;
    default:
    break;
    }
    }