Start using resource handler to manage different streams

This commit is contained in:
jfmcarreira committed 2021-09-06 22:43:21 +01:00
1 parent 463e1a58b9
commit bf5235352b
14 files changed
+466 -129

No files matched your search

+1
View File
@@ -144,3 +144,4 @@ doc/
# CLang
compile_commands.json
build_release/*
+1
View File
@@ -43,6 +43,7 @@ SET(Calyp_App_SRCS
MdiSubWindow.cpp
SubWindowAbstract.cpp
# Module Video
ResourceHandle.cpp
VideoHandle.cpp
VideoSubWindow.cpp
ViewArea.cpp
+5
View File
@@ -33,6 +33,7 @@
#include <QDropEvent>
#include <QSignalMapper>
#include <QtDebug>
#include <memory>
#include "AboutDialog.h"
#include "ModulesHandle.h"
@@ -58,6 +59,8 @@ MainWindow::MainWindow()
m_pDBusAdaptor = new DBusAppAdaptor( this );
#endif
m_appResourceHandle = std::make_unique<ResourceHandle>();
m_pcWindowHandle = new SubWindowHandle( this );
m_appModuleVideo = new VideoHandle( this, m_pcWindowHandle );
@@ -196,6 +199,8 @@ void MainWindow::loadFile( QString fileName, CalypFileInfo* pStreamInfo )
return;
}
videoSubWindow = new VideoSubWindow( VideoSubWindow::VIDEO_STREAM_SUBWINDOW ); // createSubWindow();
videoSubWindow->setResourceManaget( m_appResourceHandle.get() );
if( !pStreamInfo )
{
int idx = findCalypStreamInfo( m_aRecentFileStreamInfo, fileName );
+6 -4
View File
@@ -36,16 +36,17 @@
#ifndef __MAINWINDOW_H__
#define __MAINWINDOW_H__
#include <QMainWindow>
#include <QString>
#include <QVector>
#include "CommonDefs.h"
#include "VideoSubWindow.h"
#include "config.h"
#ifdef USE_QTDBUS
#include "DBusAppAdaptor.h"
#endif
#include <QMainWindow>
#include <QString>
#include <QVector>
#include "ResourceHandle.h"
class QCloseEvent;
class QDragEnterEvent;
@@ -158,6 +159,7 @@ private:
* Quality
* Modules
*/
std::unique_ptr<ResourceHandle> m_appResourceHandle;
VideoHandle* m_appModuleVideo;
QualityHandle* m_appModuleQuality;
ModulesHandle* m_appModuleExtensions;
+130
View File
@@ -0,0 +1,130 @@
/* This file is a part of Calyp project
* Copyright (C) 2014-2021 by Joao Carreira (jfmcarreira@gmail.com)
* Luis Lucas (luisfrlucas@gmail.com)
* Joao Santos (joaompssantos@gmail.com)
*
* 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.
*/
/**
* \file ResourceHandle.cpp
* \brief Handle resources
*/
#include "ResourceHandle.h"
#include <QCoreApplication>
#include <QEvent>
#include <QFileInfo>
#include <QMutex>
#include <QThread>
#include <memory>
#include <optional>
ResourceWorker::ResourceWorker( std::shared_ptr<CalypStream> stream )
{
m_pcStream = stream;
}
void ResourceWorker::stop()
{
m_bStop = true;
wait();
}
void ResourceWorker::run()
{
while( !m_bStop )
{
m_pcStream->readNextFrameFillRGBBuffer();
while( !m_bStop && !m_pcStream->hasWritingSlot() )
; // Keep
}
}
ResourceHandle::ResourceHandle()
{
}
auto ResourceHandle::addResource() -> CalypStream*
{
auto newStreamResource = std::make_shared<CalypStream>();
auto newStreamResourceWorker = std::make_unique<ResourceWorker>( newStreamResource );
CalypStream* ptr = newStreamResource.get();
m_apcStreamResourcesList.push_back( newStreamResource );
m_apcStreamResourcesWorkersList.push_back( std::move( newStreamResourceWorker ) );
return ptr;
}
auto ResourceHandle::getResource( CalypStream* ptr ) -> CalypStream*
{
if( ptr != nullptr )
{
for( auto& resource_ptr : m_apcStreamResourcesList )
{
if( resource_ptr.get() == ptr )
return resource_ptr.get();
}
}
return addResource();
}
void ResourceHandle::removeResource( CalypStream* ptr )
{
std::optional<std::size_t> posToRemove;
for( std::size_t i = 0; i < m_apcStreamResourcesList.size(); i++ )
{
if( m_apcStreamResourcesList[i].get() == ptr )
{
posToRemove = i;
break;
}
}
if( !posToRemove.has_value() )
{
assert( false );
return;
}
// Remove worker first
m_apcStreamResourcesWorkersList[*posToRemove]->stop();
m_apcStreamResourcesWorkersList.erase( m_apcStreamResourcesWorkersList.begin() + *posToRemove );
// Then the underlying stream
m_apcStreamResourcesList.erase( m_apcStreamResourcesList.begin() + *posToRemove );
}
void ResourceHandle::startResourceWorker( CalypStream* ptr )
{
std::optional<std::size_t> position;
for( std::size_t i = 0; i < m_apcStreamResourcesList.size(); i++ )
{
if( m_apcStreamResourcesList[i].get() == ptr )
{
position = i;
break;
}
}
if( !position.has_value() )
{
assert( false );
return;
}
m_apcStreamResourcesWorkersList[*position]->setObjectName(
"RW-" +
QFileInfo( QString::fromStdString( m_apcStreamResourcesList[*position]->getFileName() ) ).completeBaseName() );
m_apcStreamResourcesWorkersList[*position]->start();
}
+64
View File
@@ -0,0 +1,64 @@
/* This file is a part of Calyp project
* Copyright (C) 2014-2021 by Joao Carreira (jfmcarreira@gmail.com)
* Luis Lucas (luisfrlucas@gmail.com)
*
* 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.
*/
/**
* \file ResourceHandle.h
* \brief Handle multiple sub-windows
*/
#ifndef __RESOURCEHANDLE_H__
#define __RESOURCEHANDLE_H__
#include <QThread>
#include <QVector>
#include "CommonDefs.h"
#include "lib/CalypStream.h"
class ResourceWorker : public QThread
{
private:
std::shared_ptr<CalypStream> m_pcStream;
bool m_bStop{ false };
public:
ResourceWorker( std::shared_ptr<CalypStream> stream );
void stop();
void run();
};
class ResourceHandle
{
public:
ResourceHandle();
~ResourceHandle() = default;
auto getResource( CalypStream* ptr ) -> CalypStream*;
void removeResource( CalypStream* ptr );
void startResourceWorker( CalypStream* ptr );
private:
auto addResource() -> CalypStream*;
private:
std::vector<std::shared_ptr<CalypStream>> m_apcStreamResourcesList;
std::vector<std::unique_ptr<ResourceWorker>> m_apcStreamResourcesWorkersList;
};
#endif // __RESOURCEHANDLE_H__
+43 -14
View File
@@ -32,9 +32,11 @@
#include "ConfigureFormatDialog.h"
#include "ModulesHandle.h"
#include "QtConcurrent/qtconcurrentrun.h"
#include "ResourceHandle.h"
#include "SubWindowAbstract.h"
//#define QT_NO_CONCURRENT
//#define USE_CALYPSTREAM_RETRIEVE
/**
* \brief Functions to control data stream from stream information
@@ -146,6 +148,7 @@ protected:
VideoSubWindow::VideoSubWindow( enum VideoSubWindowCategories category, QWidget* parent )
: SubWindowAbstract( parent, SubWindowAbstract::VIDEO_SUBWINDOW | category )
, m_pcResourceManager( nullptr )
, m_bWindowBusy( false )
, m_pCurrStream( NULL )
, m_pcCurrFrame( NULL )
@@ -196,12 +199,10 @@ VideoSubWindow::VideoSubWindow( enum VideoSubWindowCategories category, QWidget*
VideoSubWindow::~VideoSubWindow()
{
m_pcCurrFrame = NULL;
disableModule();
delete m_cViewArea;
m_pcResourceManager->removeResource( m_pCurrStream );
//delete m_cViewArea;
delete m_pcUpdateTimer;
if( m_pCurrStream )
delete m_pCurrStream;
}
/**
@@ -319,6 +320,8 @@ void VideoSubWindow::refreshSubWindow()
bool VideoSubWindow::loadFile( QString cFilename, bool bForceDialog )
{
assert( m_pcResourceManager != nullptr );
ConfigureFormatDialog formatDialog( this );
unsigned int Width = 0, Height = 0, BitsPel = 8, FrameRate = 30;
int Endianness = CLP_LITTLE_ENDIAN;
@@ -327,11 +330,9 @@ bool VideoSubWindow::loadFile( QString cFilename, bool bForceDialog )
if( m_pCurrStream )
m_pCurrStream->getFormat( Width, Height, InputFormat, BitsPel, Endianness, FrameRate );
else
m_pCurrStream = m_pcResourceManager->getResource( nullptr );
if( !m_pCurrStream )
{
m_pCurrStream = new CalypStream;
}
bool bConfig = true;
if( !bForceDialog )
{
@@ -383,6 +384,10 @@ bool VideoSubWindow::loadFile( QString cFilename, bool bForceDialog )
var.setValue<unsigned int>( BitsPel );
appSettings.setValue( "VideoSubWindow/LastBitsPerPixel", var );
#ifdef USE_CALYPSTREAM_RETRIEVE
m_pcResourceManager->startResourceWorker( m_pCurrStream );
#endif
QApplication::restoreOverrideCursor();
refreshFrame();
@@ -397,10 +402,9 @@ bool VideoSubWindow::loadFile( QString cFilename, bool bForceDialog )
bool VideoSubWindow::loadFile( CalypFileInfo* streamInfo )
{
if( !m_pCurrStream )
{
m_pCurrStream = new CalypStream;
}
assert( m_pcResourceManager != nullptr );
m_pCurrStream = m_pcResourceManager->getResource( m_pCurrStream );
if( !m_pCurrStream->open( streamInfo->m_cFilename.toStdString(), streamInfo->m_uiWidth, streamInfo->m_uiHeight,
streamInfo->m_iPelFormat, streamInfo->m_uiBitsPelPixel, streamInfo->m_iEndianness,
@@ -411,6 +415,10 @@ bool VideoSubWindow::loadFile( CalypFileInfo* streamInfo )
m_sStreamInfo = *streamInfo;
#ifdef USE_CALYPSTREAM_RETRIEVE
m_pcResourceManager->startResourceWorker( m_pCurrStream );
#endif
QApplication::restoreOverrideCursor();
refreshFrame();
@@ -723,11 +731,15 @@ void VideoSubWindow::setCurrFrame( CalypFrame* pcCurrFrame )
void VideoSubWindow::refreshFrameOperation()
{
bool bSetFrame = false;
if( m_pCurrStream )
if( m_pcCurrStreamFrame != nullptr )
{
m_pcCurrFrame = m_pcCurrStreamFrame.get();
}
else if( m_pCurrStream )
{
m_pcCurrFrame = m_pCurrStream->getCurrFrame();
bSetFrame = m_pcCurrFrame ? true : false;
}
bSetFrame = m_pcCurrFrame ? true : false;
if( m_pcCurrentDisplayModule )
{
m_bWindowBusy = true;
@@ -761,6 +773,13 @@ void VideoSubWindow::refreshFrame( bool bThreaded )
bool VideoSubWindow::goToNextFrame( bool bThreaded )
{
#ifdef USE_CALYPSTREAM_RETRIEVE
m_pcCurrStreamFrame = m_pCurrStream->retrieveNextFrame();
if( m_pcCurrStreamFrame == nullptr )
return true;
refreshFrame();
return false;
#else
#ifndef QT_NO_CONCURRENT
m_cRefreshResult.waitForFinished();
m_cReadResult.waitForFinished();
@@ -783,6 +802,7 @@ bool VideoSubWindow::goToNextFrame( bool bThreaded )
}
}
return bEndOfSeq;
#endif
}
bool VideoSubWindow::save( QString filename )
@@ -867,6 +887,7 @@ void VideoSubWindow::pause()
void VideoSubWindow::seekAbsoluteEvent( unsigned int new_frame_num )
{
m_pcCurrStreamFrame = nullptr;
if( m_pCurrStream )
if( m_pCurrStream->seekInput( new_frame_num ) )
refreshFrame();
@@ -883,7 +904,15 @@ void VideoSubWindow::seekRelativeEvent( bool bIsFoward )
}
else
{
m_pcCurrStreamFrame = nullptr;
bRefresh = m_pCurrStream->seekInputRelative( bIsFoward );
#ifdef USE_CALYPSTREAM_RETRIEVE
if( bRefresh )
{
m_pcCurrStreamFrame = m_pCurrStream->retrieveNextFrame();
bRefresh &= m_pcCurrStreamFrame != nullptr;
}
#endif
}
}
if( bRefresh )
+6
View File
@@ -41,6 +41,7 @@ class QScrollArea;
class VideoInformation;
class VideoSubWindow;
class ResourceHandle;
class CalypAppModuleIf;
typedef struct
@@ -65,6 +66,8 @@ class VideoSubWindow : public SubWindowAbstract
Q_OBJECT
private:
ResourceHandle* m_pcResourceManager;
bool m_bWindowBusy;
QScrollArea* m_pcScrollArea;
@@ -80,6 +83,7 @@ private:
QString m_cStreamInformation;
CalypFileInfo m_sStreamInfo;
CalypStream* m_pCurrStream;
std::shared_ptr<CalypFrame> m_pcCurrStreamFrame;
CalypFrame* m_pcCurrFrame;
QRect m_cSelectedArea;
@@ -111,6 +115,8 @@ public:
VideoSubWindow( enum VideoSubWindowCategories category, QWidget* parent = 0 );
~VideoSubWindow();
void setResourceManaget( ResourceHandle* resourceManager ) { m_pcResourceManager = resourceManager; }
void updateVideoWindowInfo();
bool loadFile( QString cFilename, bool bForceDialog = false );
+2 -2
View File
@@ -73,7 +73,7 @@ void ViewArea::setImage( CalypFrame* pcFrame )
{
m_pcCurrFrame = pcFrame;
m_uiPixelHalfScale = 1 << ( m_pcCurrFrame->getBitsPel() - 1 );
m_pcCurrFrame->fillRGBBuffer();
pcFrame->fillRGBBuffer();
QImage qimg = QImage( m_pcCurrFrame->getRGBBuffer(), m_pcCurrFrame->getWidth(), m_pcCurrFrame->getHeight(),
QImage::Format_ARGB32 );
setImage( QPixmap::fromImage( qimg ) );
@@ -1091,6 +1091,6 @@ void ViewArea::updateMask( const QRect& rect )
break;
}
default: /* Do Nothing */
;
;
}
}
+1 -1
View File
@@ -150,7 +150,7 @@ private:
QPoint viewToWindow( const QPoint& pt ) const;
QRect viewToWindow( const QRect& rc ) const;
CalypFrame* m_pcCurrFrame;
const CalypFrame* m_pcCurrFrame;
ClpPel m_uiPixelHalfScale;
+1
View File
@@ -26,6 +26,7 @@
#ifndef __CALYPDEFS_H__
#define __CALYPDEFS_H__
#include <cstdint>
#include <iterator>
#include <memory>
#include <string>
+187 -91
View File
@@ -25,6 +25,9 @@
// Self
#include "CalypStream.h"
#include <cassert>
#include <iostream>
#include "CalypFrame.h"
#include "CalypStreamHandlerIf.h"
#include "LibMemory.h"
@@ -100,23 +103,29 @@ class CalypStreamBufferPrivate
{
private:
std::vector<CalypFrame> m_apcFrameBuffer;
unsigned int m_uiIndex;
std::int64_t m_iSize;
std::int64_t m_iReadIndex;
std::int64_t m_iWriteIndex;
public:
CalypStreamBufferPrivate( unsigned int size, unsigned int width, unsigned int height, int pelFormat, unsigned int bitsPixel, bool hasNegative )
CalypStreamBufferPrivate( std::size_t size, unsigned int width, unsigned int height, int pelFormat, unsigned int bitsPixel, bool hasNegative )
{
for( unsigned int i = 0; i < size; i++ )
m_apcFrameBuffer.reserve( size );
for( std::size_t i = 0; i < size; i++ )
{
m_apcFrameBuffer.push_back( CalypFrame{ width, height, pelFormat, bitsPixel, hasNegative } );
}
m_uiIndex = 0;
m_iSize = std::ssize( m_apcFrameBuffer );
m_iReadIndex = -1;
m_iWriteIndex = 0;
}
~CalypStreamBufferPrivate() = default;
void increase( unsigned int newSize )
void increase( std::size_t newSize )
{
for( unsigned int i = m_apcFrameBuffer.size(); i < newSize; i++ )
m_apcFrameBuffer.reserve( newSize );
for( std::size_t i = m_iSize; i < newSize; i++ )
{
m_apcFrameBuffer.push_back( CalypFrame{ m_apcFrameBuffer[0].getWidth(),
m_apcFrameBuffer[0].getHeight(),
@@ -124,30 +133,84 @@ public:
m_apcFrameBuffer[0].getBitsPel(),
m_apcFrameBuffer[0].getHasNegativeValues() } );
}
m_iSize = std::ssize( m_apcFrameBuffer );
}
void setIndex( std::int64_t i )
{
m_iWriteIndex = m_iReadIndex = i;
m_iWriteIndex = nextIndex( m_iWriteIndex );
}
void reset()
{
m_iReadIndex = -1;
m_iWriteIndex = 0;
}
void startRead()
{
assert( m_iWriteIndex >= 0 );
m_iReadIndex = 0;
}
unsigned int size() { return m_apcFrameBuffer.size(); }
void setIndex( unsigned int i ) { m_uiIndex = i; }
CalypFrame& frame( int i ) { return m_apcFrameBuffer.at( i ); }
CalypFrame& current() { return m_apcFrameBuffer.at( m_uiIndex ); }
CalypFrame& next() { return m_apcFrameBuffer.at( nextIndex() ); }
void setNextFrame() { m_uiIndex = nextIndex(); }
CalypFrame& currentRead()
{
assert( m_iReadIndex >= 0 && m_iReadIndex < m_iSize );
return m_apcFrameBuffer.at( m_iReadIndex );
}
const CalypFrame& ref() { return m_apcFrameBuffer.at( m_iWriteIndex ); }
CalypFrame& readOneFrame()
{
assert( m_iReadIndex >= 0 && m_iReadIndex < m_iSize );
CalypFrame& frameToRead = m_apcFrameBuffer.at( m_iReadIndex );
m_iReadIndex = nextIndex( m_iReadIndex );
return frameToRead;
}
CalypFrame& writeOneFrame()
{
assert( m_iReadIndex != m_iWriteIndex );
CalypFrame& frameToWrite = m_apcFrameBuffer.at( m_iWriteIndex );
m_iWriteIndex = nextIndex( m_iWriteIndex );
return frameToWrite;
}
bool hasWritingSlot()
{
if( m_iWriteIndex != m_iReadIndex )
return true;
return false;
}
std::shared_ptr<CalypFrame> retrieveFrame()
{
auto ptr = std::make_shared<CalypFrame>( std::move( m_apcFrameBuffer[m_iReadIndex] ) );
m_apcFrameBuffer[m_iReadIndex] = CalypFrame{ ptr->getWidth(),
ptr->getHeight(),
ptr->getPelFormat(),
ptr->getBitsPel(),
ptr->getHasNegativeValues() };
m_iReadIndex = nextIndex( m_iReadIndex );
return ptr;
}
private:
inline int nextIndex() { return m_uiIndex + 1 >= m_apcFrameBuffer.size() ? 0 : m_uiIndex + 1; }
inline int prevIndex() { return m_uiIndex - 1 < 0 ? m_apcFrameBuffer.size() - 1 : m_uiIndex - 1; }
inline int nextIndex( std::int64_t curr ) { return curr + 1 >= m_iSize ? 0 : curr + 1; }
};
class CalypStream::CalypStreamPrivate
{
public:
std::mutex mutex;
bool isInit;
bool isInput;
CalypStreamHandlerIf* handler;
CreateStreamHandlerFn pfctCreateHandler;
CalypStreamBufferPrivate* frameBuffer;
std::unique_ptr<CalypStreamBufferPrivate> frameBuffer;
ClpString cFilename;
long long int iCurrFrameNum;
@@ -164,10 +227,12 @@ public:
iCurrFrameNum = -1;
cFilename = "";
}
~CalypStreamPrivate()
{
close();
}
void close()
{
if( !isInit )
@@ -178,12 +243,26 @@ public:
handler->closeHandler();
handler->Delete();
}
if( frameBuffer )
delete frameBuffer;
bLoadAll = false;
isInit = false;
}
bool readFrame( CalypFrame& frame )
{
if( !isInit || !isInput || handler->m_uiCurrFrameFileIdx >= handler->m_uiTotalNumberFrames )
return false;
if( bLoadAll )
return true;
if( !handler->read( frame ) )
{
throw CalypFailure( "CalypStream", "Cannot read frame from stream" );
return false;
}
return true;
}
};
std::vector<ClpString> CalypStreamFormat::getExts()
@@ -332,10 +411,11 @@ bool CalypStream::open( ClpString filename, unsigned int width, unsigned int hei
}
// Keep past, current and future frames
std::size_t bufferSize = d->isInput ? 4 : 1;
try
{
d->frameBuffer = new CalypStreamBufferPrivate( d->isInput ? 3 : 1, d->handler->m_uiWidth, d->handler->m_uiHeight,
d->handler->m_iPixelFormat, d->handler->m_uiBitsPerPixel, hasNegative );
d->frameBuffer = std::make_unique<CalypStreamBufferPrivate>( bufferSize, d->handler->m_uiWidth, d->handler->m_uiHeight,
d->handler->m_iPixelFormat, d->handler->m_uiBitsPerPixel, hasNegative );
}
catch( CalypFailure& e )
{
@@ -344,7 +424,7 @@ bool CalypStream::open( ClpString filename, unsigned int width, unsigned int hei
return d->isInit;
}
d->handler->m_uiNBytesPerFrame = d->frameBuffer->current().getBytesPerFrame();
d->handler->m_uiNBytesPerFrame = d->frameBuffer->ref().getBytesPerFrame();
// Some handlers need to know how long is a frame to get frame number
d->handler->calculateFrameNumber();
@@ -356,7 +436,7 @@ bool CalypStream::open( ClpString filename, unsigned int width, unsigned int hei
return d->isInit;
}
if( !d->handler->configureBuffer( d->frameBuffer->current() ) )
if( !d->handler->configureBuffer( d->frameBuffer->ref() ) )
{
close();
throw CalypFailure( "CalypStream", "Cannot allocated buffers" );
@@ -380,9 +460,9 @@ bool CalypStream::reload()
throw CalypFailure( "CalypStream", "Cannot open stream " + d->cFilename + " with the " +
ClpString( d->handler->m_pchHandlerName ) + " handler" );
}
d->handler->m_uiNBytesPerFrame = d->frameBuffer->current().getBytesPerFrame();
d->handler->m_uiNBytesPerFrame = d->frameBuffer->ref().getBytesPerFrame();
d->handler->calculateFrameNumber();
d->handler->configureBuffer( d->frameBuffer->current() );
d->handler->configureBuffer( d->frameBuffer->ref() );
if( d->handler->m_uiWidth <= 0 || d->handler->m_uiHeight <= 0 || d->handler->m_iPixelFormat < 0 ||
d->handler->m_uiBitsPerPixel == 0 || d->handler->m_uiTotalNumberFrames == 0 )
@@ -467,6 +547,10 @@ void CalypStream::getFormat( unsigned int& rWidth, unsigned int& rHeight, int& r
}
}
/**
* @brief Read operations
*/
void CalypStream::loadAll()
{
if( d->bLoadAll || !d->isInput )
@@ -483,33 +567,89 @@ void CalypStream::loadAll()
}
seekInput( 0 );
for( unsigned int i = 2; i < d->frameBuffer->size(); i++ )
for( unsigned int i = 2; i < d->handler->m_uiTotalNumberFrames; i++ )
{
readFrame( d->frameBuffer->frame( i ) );
d->readFrame( d->frameBuffer->frame( i ) );
}
d->bLoadAll = true;
d->iCurrFrameNum = 0;
}
bool CalypStream::readFrame( CalypFrame& frame )
CalypFrame* CalypStream::getCurrFrame( CalypFrame* pyuv_image )
{
if( !d->isInit || !d->isInput || d->handler->m_uiCurrFrameFileIdx >= d->handler->m_uiTotalNumberFrames )
return false;
if( d->bLoadAll )
return true;
if( !d->handler->read( frame ) )
{
throw CalypFailure( "CalypStream", "Cannot read frame from stream" );
return false;
}
return true;
if( pyuv_image == NULL )
pyuv_image = new CalypFrame( d->frameBuffer->currentRead() );
else
pyuv_image->copyFrom( d->frameBuffer->currentRead() );
return pyuv_image;
}
CalypFrame* CalypStream::getCurrFrame()
{
return &d->frameBuffer->currentRead();
}
auto CalypStream::getNextFrame() -> CalypFrame&
{
CalypFrame& frameToTead = d->frameBuffer->readOneFrame();
d->readFrame( d->frameBuffer->writeOneFrame() );
return frameToTead;
}
auto CalypStream::retrieveNextFrame() -> std::shared_ptr<CalypFrame>
{
const std::lock_guard<std::mutex> lock( d->mutex );
if( d->iCurrFrameNum + 1 < (long)( d->handler->m_uiTotalNumberFrames ) )
{
d->iCurrFrameNum++;
return d->frameBuffer->retrieveFrame();
}
return nullptr;
}
bool CalypStream::setNextFrame()
{
bool bEndOfSeq = false;
if( d->iCurrFrameNum + 1 < (long)( d->handler->m_uiTotalNumberFrames ) )
{
d->frameBuffer->readOneFrame();
d->iCurrFrameNum++;
}
else
{
bEndOfSeq = true;
}
return bEndOfSeq;
}
void CalypStream::readNextFrame()
{
d->readFrame( d->frameBuffer->writeOneFrame() );
}
void CalypStream::readNextFrameFillRGBBuffer()
{
const std::lock_guard<std::mutex> lock( d->mutex );
CalypFrame& frameToWrite = d->frameBuffer->writeOneFrame();
d->readFrame( frameToWrite );
frameToWrite.fillRGBBuffer();
return;
}
auto CalypStream::hasWritingSlot() -> bool
{
return d->frameBuffer->hasWritingSlot();
}
/**
* @brief Write operations
*/
void CalypStream::writeFrame()
{
writeFrame( d->frameBuffer->current() );
writeFrame( *getCurrFrame() );
}
void CalypStream::writeFrame( const CalypFrame& pcFrame )
@@ -523,7 +663,7 @@ void CalypStream::writeFrame( const CalypFrame& pcFrame )
bool CalypStream::saveFrame( const ClpString& filename )
{
return saveFrame( filename, d->frameBuffer->current() );
return saveFrame( filename, *getCurrFrame() );
}
bool CalypStream::saveFrame( const ClpString& filename, const CalypFrame& saveFrame )
@@ -539,53 +679,9 @@ bool CalypStream::saveFrame( const ClpString& filename, const CalypFrame& saveFr
return true;
}
bool CalypStream::setNextFrame()
{
bool bEndOfSeq = false;
if( d->iCurrFrameNum + 1 < (long)( d->handler->m_uiTotalNumberFrames ) )
{
d->frameBuffer->setNextFrame();
d->iCurrFrameNum++;
}
else
{
bEndOfSeq = true;
}
return bEndOfSeq;
}
void CalypStream::readNextFrame()
{
readFrame( d->frameBuffer->next() );
}
void CalypStream::readNextFrameFillRGBBuffer()
{
readNextFrame();
d->frameBuffer->next().fillRGBBuffer();
return;
}
CalypFrame* CalypStream::getCurrFrame( CalypFrame* pyuv_image )
{
if( pyuv_image == NULL )
pyuv_image = new CalypFrame( d->frameBuffer->current() );
else
pyuv_image->copyFrom( d->frameBuffer->current() );
return pyuv_image;
}
CalypFrame* CalypStream::getCurrFrame()
{
return &d->frameBuffer->current();
}
const CalypFrame& CalypStream::getCurrFrameConst() const
{
return d->frameBuffer->current();
}
/**
* @brief Seek operations
*/
bool CalypStream::seekInputRelative( bool bIsFoward )
{
if( !d->isInit || !d->isInput )
@@ -595,7 +691,7 @@ bool CalypStream::seekInputRelative( bool bIsFoward )
if( bIsFoward )
{
bRet = !setNextFrame();
readFrame( d->frameBuffer->next() );
d->readFrame( d->frameBuffer->writeOneFrame() );
}
else
{
@@ -623,10 +719,10 @@ bool CalypStream::seekInput( unsigned long new_frame_num )
throw CalypFailure( "CalypStream", "Cannot seek file into desired position" );
}
d->frameBuffer->setIndex( 0 );
readFrame( d->frameBuffer->current() );
d->frameBuffer->reset();
d->readFrame( d->frameBuffer->writeOneFrame() );
if( d->handler->m_uiTotalNumberFrames > 1 )
readFrame( d->frameBuffer->next() );
d->readFrame( d->frameBuffer->writeOneFrame() );
d->frameBuffer->startRead();
return true;
}
+16 -13
View File
@@ -26,11 +26,12 @@
#ifndef __CALYPSTREAM_H__
#define __CALYPSTREAM_H__
#include <memory>
#include <vector>
#include "CalypDefs.h"
#include "CalypFrame.h"
class CalypFrame;
class CalypStreamHandlerIf;
typedef CalypStreamHandlerIf* ( *CreateStreamHandlerFn )( void );
@@ -96,27 +97,29 @@ public:
void loadAll();
CalypFrame* getCurrFrame( CalypFrame* );
CalypFrame* getCurrFrame();
// continuous read using smart ptrs
auto retrieveNextFrame() -> std::shared_ptr<CalypFrame>;
// continuous read control
auto getNextFrame() -> CalypFrame&;
bool setNextFrame();
void readNextFrame();
void readNextFrameFillRGBBuffer();
auto hasWritingSlot() -> bool;
void writeFrame();
void writeFrame( const CalypFrame& pcFrame );
bool saveFrame( const ClpString& filename );
static bool saveFrame( const ClpString& filename, const CalypFrame& saveFrame );
CalypFrame* getCurrFrame( CalypFrame* );
// continuous read control
bool setNextFrame();
void readNextFrame();
void readNextFrameFillRGBBuffer();
CalypFrame* getCurrFrame();
const CalypFrame& getCurrFrameConst() const;
bool seekInputRelative( bool bIsFoward );
bool seekInput( unsigned long new_frame_num );
private:
bool readFrame( CalypFrame& frame );
private:
class CalypStreamPrivate;
std::unique_ptr<CalypStreamPrivate> d;
+3 -4
View File
@@ -246,7 +246,7 @@ int CalypTools::Open( int argc, char* argv[] )
if( Opts().hasOpt( "output" ) )
m_pcOutputFileNames.push_back( m_strOutput );
CalypFrame* pcInputFrame = m_apcInputStreams[0]->getCurrFrame();
const CalypFrame* pcInputFrame = m_apcInputStreams[0]->getCurrFrame();
CalypStream* pcOutputStream = new CalypStream;
try
{
@@ -479,7 +479,7 @@ int CalypTools::RateReductionOperation()
if( ( frame % m_iRateReductionFactor ) == 0 )
{
log( CLP_LOG_INFO, "Writing", frame );
m_apcOutputStreams[0]->writeFrame( m_apcInputStreams[0]->getCurrFrameConst() );
m_apcOutputStreams[0]->writeFrame( *m_apcInputStreams[0]->getCurrFrame() );
}
abEOF = m_apcInputStreams[0]->setNextFrame();
if( !abEOF )
@@ -692,7 +692,6 @@ int CalypTools::ListStatistics()
{
log( CLP_LOG_RESULT, "\n\x1B[35mCalyp Statistics:\x1B[0m\n\n" );
CalypFrame* currFrame;
bool abEOF;
unsigned min[MAX_NUMBER_CHANNELS], max[MAX_NUMBER_CHANNELS];
@@ -706,7 +705,7 @@ int CalypTools::ListStatistics()
{
log( CLP_LOG_RESULT, "\x1B[34m Frame: %d\x1B[0m\n", frame );
currFrame = m_apcInputStreams[input]->getCurrFrame();
auto currFrame = m_apcInputStreams[input]->getCurrFrame();
abEOF = m_apcInputStreams[input]->setNextFrame();
if( !abEOF )
{