jfmcarreira/calyp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Refactor Playuver into Calyp

Browse Source 
commit 1fd9cf34f06ba2a156919b5c9b73c31d4c6c6257
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Mon Mar 12 18:06:39 2018 +0000

    Remove code style

commit 165588840126a7ab35b32e5be47f00c613829ef3
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Mon Mar 12 18:06:25 2018 +0000

    Update Mainpage.dox

commit 5b1a2773c48697346c7b0b64519b81a5aecc0150
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Mon Feb 19 03:46:24 2018 +0000

    Re-add CalypPixel.cpp but keep include with frame class

commit 2343be49ff4906c3171d2df7791e3cf34494eb21
Author: Joao Santos <joaompssantos@gmail.com>
Date:   Sun Feb 18 21:06:57 2018 +0000

    Fixed several things:
    - Removed unused define
    - Added: #include <cassert> to MainWindow.cpp
    - Fixed compilation issue when USE_FFMPEG is OFF on CalypStream.cpp

commit 8d1d64bac828a6bcdfa6af977a5d17d0792acb69
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Thu Feb 15 02:14:13 2018 +0000

    Fix several things:
    - Fix examples
    - Improve code formatting script
    - Change generated cmake config file

commit ea1d0265f1e9300f76fd3f0c8ca03d110ec13eaa
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Thu Feb 15 01:28:50 2018 +0000

    Fix dump of the module list: remove the use of char arrays

commit b4d19dda169715113a74713ca62d05f5a18fd0b5
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Wed Feb 14 23:20:56 2018 +0000

    Increase linesize of tools help

commit 8b3eab54e376863276b0d7e032f9e1de8aaf90e5
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Wed Feb 14 23:20:35 2018 +0000

    Fix CalypPixel

commit 1c6ba03c379518acf5fc6f1fdf328ca740a8851d
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Wed Feb 14 22:24:10 2018 +0000

    Enums CalypPixelFormats and CalypColorSpace are now class independent

commit 5dcc35e1716a70095e1720b01823c2e3a3980576
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Wed Feb 14 02:04:31 2018 +0000

    Change functions input and return types

commit 5514e3e24f9b428d5db71156561b2d8b6f61dd23
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Wed Feb 14 02:04:31 2018 +0000

    Change functions input and return types

commit fae7a9a91e1899e7a2833c634221f970d44b8fb6
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Wed Feb 14 01:39:14 2018 +0000

    Replace custom types with std ones

commit 0c3b62b8ea01903e213d9e8dd73a5b49c7c8c36e
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Wed Feb 14 00:37:18 2018 +0000

    Refactoring entries with Playuver name with Calyp
    Replace number of frames and add CLP tag into public definitions

commit e8cd8d7a219446513a5dda2c183dd892ec25a6f1
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Sat Feb 10 14:42:15 2018 +0000

    Fix min opencv version and missing ffmpeg module

commit 1233598af8ac15c88fa84569942cc6f865325452
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Sat Feb 10 03:10:12 2018 +0000

    Change version to 0.999.0 untill finishing refactoring

commit 1fe0cac8f0e70f352bf6c63b8cb2e06ab43fb633
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Sat Feb 10 00:21:47 2018 +0000

    Change project library

commit 44e9d330bc63b8b8a1687a14ff0be05af0bf2eb5
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Fri Feb 9 01:42:58 2018 +0000

    Change doxygen files and upload new ico

commit 0d6f3408a2682cfac1533a57a2f1b4e2cc1f0f29
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Thu Feb 8 21:25:31 2018 +0000

    Fix logos - different when it is icon or the full logo

commit 9f3561acd4b51c7de5f21d63d7e8f2b43c253148
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Thu Feb 8 01:25:39 2018 +0000

    fix install files

commit 832154e3e40f17a863898a77c929a6c6850ffded
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Thu Feb 8 01:21:23 2018 +0000

    rename calip to calyp

commit 341b32bfcc0133fdbceea9b8390d59190e495b79
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Thu Feb 8 00:58:29 2018 +0000

    Refactor lib, modules and tools

commit b4b988cf80052fdcfe0e1f9099d5435ef7945584
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Thu Feb 8 00:02:33 2018 +0000

    Refactor classes and filename in app

commit 6b4ab728202531ad00db1e6299ee69a01f3594ba
Author: Joao Carreira <jfmcarreira@gmail.com>
Date:   Wed Feb 7 17:49:53 2018 +0000

    Refactor about dialog and background logo

commit d5c954d39fb89d735c4feddf62f529077840ab6c
Author: João Santos <joaompssantos@gmail.com>
Date:   Wed Feb 7 15:05:19 2018 +0000

    Added the misteriously missing new logo.

commit f40d81f765bfdd2dc89c0647cf5f4a80eef845c7
Author: João Santos <joaompssantos@gmail.com>
Date:   Wed Feb 7 14:45:08 2018 +0000

    Added new logo to resource folder.

commit 52dc6d60d6590995d32de33f8199e954e0a6e120
Author: João Santos <joaompssantos@gmail.com>
Date:   Wed Feb 7 14:41:13 2018 +0000

    Added new logo where it was previously forgotten.

commit 6d8e064c3154e5202f01b1b10ba6ab3637383ecd
Author: João Santos <joaompssantos@gmail.com>
Date:   Tue Feb 6 17:44:11 2018 +0000

    About window no longer resizable. Added new logo.
This commit is contained in:
jfmcarreira
2018-03-12 18:21:07 +00:00
parent 5a701c83e7
commit 0b429a0c34
157 changed files with 16532 additions and 17759 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tools/CalypTools.cpp
+589
View File
@@ -0,0 +1,589 @@
/* This file is a part of Calyp project
* Copyright (C) 2014-2018 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 CalypTools.cpp
* \brief Main definition of the CalypTools APp
*/
#include "CalypTools.h"
#include "config.h"
#include <climits>
#include <cstring>
#include "lib/CalypFrame.h"
#include "lib/CalypModuleIf.h"
#include "lib/CalypStream.h"
#include "modules/CalypModulesFactory.h"
CalypTools::CalypTools()
{
m_bVerbose = true;
m_uiOperation = INVALID_OPERATION;
m_uiNumberOfFrames = -1;
m_uiQualityMetric = -1;
m_pcCurrModuleIf = NULL;
}
CalypTools::~CalypTools()
{
for( unsigned int i = 0; i < m_apcInputStreams.size(); i++ )
{
m_apcInputStreams[i]->close();
}
for( unsigned int i = 0; i < m_apcOutputStreams.size(); i++ )
{
m_apcOutputStreams[i]->close();
}
}
#define GET_PARAM( X, i ) X[X.size() > i ? i : X.size() - 1]
int CalypTools::openInputs()
{
/**
* Create input streams
*/
if( Opts().hasOpt( "input" ) )
{
std::vector<ClpString> inputFileNames = m_apcInputs;
ClpString resolutionString( "" );
ClpString fmtString( "yuv420p" );
unsigned int uiBitPerPixel = 8;
unsigned int uiEndianness = 0;
CalypStream* pcStream;
for( unsigned int i = 0; i < inputFileNames.size() && i < MAX_NUMBER_INPUTS; i++ )
{
if( Opts().hasOpt( "size" ) )
{
resolutionString = GET_PARAM( m_strResolution, 0 );
}
if( Opts().hasOpt( "pel_fmt" ) )
{
fmtString = GET_PARAM( m_strPelFmt, i );
}
if( Opts().hasOpt( "bits_pel" ) )
{
uiBitPerPixel = GET_PARAM( m_uiBitsPerPixel, i );
}
if( Opts().hasOpt( "endianness" ) )
{
if( GET_PARAM( m_strEndianness, i ) == "big" )
{
uiEndianness = 0;
}
if( GET_PARAM( m_strEndianness, i ) == "little" )
{
uiEndianness = 1;
}
}
pcStream = new CalypStream;
try
{
if( !pcStream->open( inputFileNames[i], resolutionString, fmtString, uiBitPerPixel, uiEndianness, 1, true ) )
{
log( CLP_LOG_ERROR, "Cannot open input stream %s! ", inputFileNames[i].c_str() );
return 2;
}
m_apcInputStreams.push_back( pcStream );
}
catch( const char* msg )
{
log( CLP_LOG_ERROR, "Cannot open input stream %s with the following error: \n%s\n", inputFileNames[i].c_str(),
msg );
return 2;
}
}
}
m_uiNumberOfFrames = UINT_MAX;
if( Opts().hasOpt( "frames" ) )
{
m_uiNumberOfFrames = m_iFrames;
}
m_uiNumberOfComponents = UINT_MAX;
for( unsigned int i = 0; i < m_apcInputStreams.size(); i++ )
{
m_uiNumberOfFrames = std::min( m_uiNumberOfFrames, m_apcInputStreams[i]->getFrameNum() );
m_uiNumberOfComponents =
std::min( m_uiNumberOfComponents, m_apcInputStreams[i]->getCurrFrame()->getNumberChannels() );
}
return 0;
}
int CalypTools::Open( int argc, char* argv[] )
{
int iRet = 0;
if( ( iRet = parseToolsArgs( argc, argv ) ) > 0 )
{
return iRet;
}
if( openInputs() > 0 )
{
return 2;
}
if( Opts().hasOpt( "save" ) )
{
if( m_apcInputStreams.size() == 0 )
{
log( CLP_LOG_ERROR, "Invalid number of input streams! " );
return 2;
}
long long int currFrames = 0;
long long int numberOfFrames = LONG_MAX;
for( unsigned int i = 0; i < m_apcInputStreams.size(); i++ )
{
currFrames = m_apcInputStreams[i]->getFrameNum();
if( currFrames < numberOfFrames )
numberOfFrames = currFrames;
}
m_iFrameNum = m_iFrames;
if( !( m_iFrameNum >= 0 && m_iFrameNum < numberOfFrames ) )
{
log( CLP_LOG_ERROR, "Invalid frame number! Use --frame option " );
return 2;
}
if( Opts().hasOpt( "output" ) )
m_pcOutputFileNames.push_back( m_strOutput );
if( m_pcOutputFileNames.size() != m_apcInputStreams.size() )
{
log( CLP_LOG_ERROR, "Invalid number of outputs! Each input must have an "
"output filename. " );
return 2;
}
m_uiOperation = SAVE_OPERATION;
m_fpProcess = &CalypTools::SaveOperation;
log( CLP_LOG_INFO, "Calyp Save Frame\n" );
}
if( Opts().hasOpt( "rate-reduction" ) )
{
if( m_apcInputStreams.size() == 0 )
{
log( CLP_LOG_ERROR, "Invalid number of input streams! " );
return 2;
}
long long int currFrames = 0;
long long int numberOfFrames = LONG_MAX;
for( unsigned int i = 0; i < m_apcInputStreams.size(); i++ )
{
currFrames = m_apcInputStreams[i]->getFrameNum();
if( currFrames < numberOfFrames )
numberOfFrames = currFrames;
}
if( m_iRateReductionFactor <= 0 )
{
log( CLP_LOG_ERROR, "Invalid frame rate reduction value!" );
return 2;
}
if( Opts().hasOpt( "output" ) )
m_pcOutputFileNames.push_back( m_strOutput );
CalypFrame* pcInputFrame = m_apcInputStreams[0]->getCurrFrame();
CalypStream* pcOutputStream = new CalypStream;
try
{
pcOutputStream->open( m_pcOutputFileNames[0], pcInputFrame->getWidth(), pcInputFrame->getHeight(),
pcInputFrame->getPelFormat(), pcInputFrame->getBitsPel(), CLP_LITTLE_ENDIAN, 1,
false );
}
catch( const char* msg )
{
log( CLP_LOG_ERROR, "Cannot open input stream %s with the following error %s!\n", m_pcOutputFileNames[0].c_str(),
msg );
delete pcOutputStream;
pcOutputStream = NULL;
return 2;
}
m_apcOutputStreams.push_back( pcOutputStream );
if( m_apcOutputStreams.size() != m_apcInputStreams.size() )
{
log( CLP_LOG_ERROR, "Invalid number of outputs! Each input must have an "
"output filename. " );
return 2;
}
m_uiOperation = RATE_REDUCTION_OPERATION;
m_fpProcess = &CalypTools::RateReductionOperation;
log( CLP_LOG_INFO, "Calyp Frame Rate Reduction\n" );
}
/**
* Check Quality operation
*/
if( Opts().hasOpt( "quality" ) )
{
ClpString qualityMetric = m_strQualityMetric;
if( m_apcInputStreams.size() < 2 )
{
log( CLP_LOG_ERROR, "Invalid number of inputs! " );
return 2;
}
for( unsigned int i = 0; i < CalypFrame::supportedQualityMetricsList().size(); i++ )
{
if( clpLowercase( CalypFrame::supportedQualityMetricsList()[i] ) == clpLowercase( qualityMetric ) )
{
m_uiQualityMetric = i;
}
}
if( m_uiQualityMetric == -1 )
{
log( CLP_LOG_ERROR, "Invalid quality metric! " );
return 2;
}
m_uiOperation = QUALITY_OPERATION;
m_fpProcess = &CalypTools::QualityOperation;
log( CLP_LOG_INFO, "Calyp Quality\n" );
}
/**
* Check Module operation
*/
if( Opts().hasOpt( "module" ) )
{
ClpString moduleName = m_strModule;
CalypModulesFactoryMap& moduleFactoryMap = CalypModulesFactory::Get()->getMap();
CalypModulesFactoryMap::iterator it = moduleFactoryMap.begin();
for( unsigned int i = 0; it != moduleFactoryMap.end(); ++it, i++ )
{
if( strcmp( it->first, moduleName.c_str() ) == 0 )
{
m_pcCurrModuleIf = it->second();
break;
}
}
if( !m_pcCurrModuleIf )
{
log( CLP_LOG_ERROR, "Invalid module! " );
return 2;
}
if( m_apcInputStreams.size() != m_pcCurrModuleIf->m_uiNumberOfFrames )
{
log( CLP_LOG_ERROR, "Invalid number of inputs! " );
return 2;
}
m_pcCurrModuleIf->m_cModuleOptions.parse( argc, argv );
// Create Module
bool moduleCreated = false;
std::vector<CalypFrame*> apcFrameList;
for( unsigned int i = 0; i < m_pcCurrModuleIf->m_uiNumberOfFrames; i++ )
{
apcFrameList.push_back( m_apcInputStreams[i]->getCurrFrame() );
}
if( m_pcCurrModuleIf->m_iModuleAPI == CLP_MODULE_API_2 )
{
moduleCreated = m_pcCurrModuleIf->create( apcFrameList );
}
else if( m_pcCurrModuleIf->m_iModuleAPI == CLP_MODULE_API_1 )
{
m_pcCurrModuleIf->create( m_apcInputStreams[0]->getCurrFrame() );
moduleCreated = true;
}
if( !moduleCreated )
{
log( CLP_LOG_ERROR, "Module is not supported with the selected inputs! " );
return 2;
}
if( m_pcCurrModuleIf->m_iModuleType == CLP_FRAME_PROCESSING_MODULE )
{
// Check outputs
std::vector<ClpString> outputFileNames;
if( Opts().hasOpt( "output" ) )
outputFileNames.push_back( m_strOutput );
if( outputFileNames.size() == 1 )
{
CalypFrame* pcModFrame;
if( m_pcCurrModuleIf->m_iModuleAPI == CLP_MODULE_API_2 )
{
pcModFrame = m_pcCurrModuleIf->process( apcFrameList );
}
else
{
pcModFrame = applyFrameModule();
}
CalypStream* pcModStream = new CalypStream;
try
{
pcModStream->open( outputFileNames[0], pcModFrame->getWidth(), pcModFrame->getHeight(),
pcModFrame->getPelFormat(), pcModFrame->getBitsPel(), CLP_LITTLE_ENDIAN, 1, false );
}
catch( const char* msg )
{
log( CLP_LOG_ERROR, "Cannot open input stream %s with the following error %s!\n", outputFileNames[0].c_str(),
msg );
delete pcModStream;
pcModStream = NULL;
return 2;
}
m_apcOutputStreams.push_back( pcModStream );
}
else
{
log( CLP_LOG_ERROR, "One output is required! " );
return 2;
}
}
m_uiOperation = MODULE_OPERATION;
m_fpProcess = &CalypTools::ModuleOperation;
log( CLP_LOG_INFO, "Calyp Module\n" );
}
if( m_uiOperation == INVALID_OPERATION )
{
log( CLP_LOG_ERROR, "No operation was selected! " );
return 2;
}
return iRet;
}
int CalypTools::Process()
{
return ( this->*m_fpProcess )();
}
int CalypTools::Close()
{
// Finish
return 0;
}
int CalypTools::SaveOperation()
{
bool bRet = true;
for( unsigned int s = 0; s < m_apcInputStreams.size(); s++ )
{
bRet = m_apcInputStreams[s]->seekInput( m_iFrameNum );
if( bRet == false )
{
return 2;
}
m_apcInputStreams[s]->saveFrame( m_pcOutputFileNames[s] );
}
return 0;
}
int CalypTools::RateReductionOperation()
{
bool abEOF;
log( CLP_LOG_INFO, "\n Reducing frame rate by a factor of %d ... ", m_iRateReductionFactor );
for( unsigned int frame = 0; frame < m_uiNumberOfFrames; frame++ )
{
log( CLP_LOG_INFO, "\n Reading frame %d ... ", frame );
if( ( frame % m_iRateReductionFactor ) == 0 )
{
log( CLP_LOG_INFO, "Writing", frame );
m_apcOutputStreams[0]->writeFrame( m_apcInputStreams[0]->getCurrFrame() );
}
abEOF = m_apcInputStreams[0]->setNextFrame();
if( !abEOF )
{
m_apcInputStreams[0]->readNextFrame();
}
}
return 0;
}
int CalypTools::QualityOperation()
{
const char* pchQualityMetricName = CalypFrame::supportedQualityMetricsList()[m_uiQualityMetric].c_str();
CalypFrame* apcCurrFrame[MAX_NUMBER_INPUTS];
bool abEOF[MAX_NUMBER_INPUTS];
double adAverageQuality[MAX_NUMBER_INPUTS - 1][CalypPixel::getMaxNumberOfComponents()];
double dQuality;
ClpString metric_fmt = " ";
switch( m_uiQualityMetric )
{
case CalypFrame::PSNR_METRIC:
//"PSNR_0_0"
metric_fmt += " %6.3f ";
break;
case CalypFrame::SSIM_METRIC:
//"SSIM_0_0"
metric_fmt += " %6.4f ";
break;
case CalypFrame::MSE_METRIC:
//"MSE_0_0"
metric_fmt += "%7.2f";
break;
default:
metric_fmt += " %6.3f ";
}
metric_fmt += " ";
log( CLP_LOG_INFO, " Measuring Quality using %s ... \n", pchQualityMetricName );
log( CLP_LOG_INFO, "# Frame ", pchQualityMetricName );
for( unsigned int s = 1; s < m_apcInputStreams.size(); s++ )
{
for( unsigned int c = 0; c < m_uiNumberOfComponents; c++ )
{
log( CLP_LOG_INFO, "%s_%d_%d ", pchQualityMetricName, s, c );
}
log( CLP_LOG_INFO, " " );
}
log( CLP_LOG_INFO, "\n" );
for( unsigned int s = 0; s < m_apcInputStreams.size(); s++ )
{
abEOF[s] = false;
for( unsigned int c = 0; c < m_uiNumberOfComponents; c++ )
{
adAverageQuality[s][c] = 0;
}
}
for( unsigned int frame = 0; frame < m_uiNumberOfFrames; frame++ )
{
log( CLP_LOG_INFO, " %3d ", frame );
for( unsigned int s = 0; s < m_apcInputStreams.size(); s++ )
apcCurrFrame[s] = m_apcInputStreams[s]->getCurrFrame();
for( unsigned int s = 1; s < m_apcInputStreams.size(); s++ )
{
log( CLP_LOG_RESULT, " " );
for( unsigned int c = 0; c < m_uiNumberOfComponents; c++ )
{
dQuality = apcCurrFrame[s]->getQuality( m_uiQualityMetric, apcCurrFrame[0], c );
adAverageQuality[s - 1][c] = ( adAverageQuality[s - 1][c] * double( frame ) + dQuality ) / double( frame + 1 );
log( CLP_LOG_RESULT, metric_fmt.c_str(), dQuality );
}
log( CLP_LOG_RESULT, " " );
}
log( CLP_LOG_RESULT, "\n" );
for( unsigned int s = 0; s < m_apcInputStreams.size(); s++ )
{
abEOF[s] = m_apcInputStreams[s]->setNextFrame();
if( !abEOF[s] )
{
m_apcInputStreams[s]->readNextFrame();
}
}
}
log( CLP_LOG_INFO, "\n Mean Values: \n " );
for( unsigned int s = 0; s < m_apcInputStreams.size() - 1; s++ )
{
for( unsigned int c = 0; c < m_uiNumberOfComponents; c++ )
{
log( CLP_LOG_INFO, metric_fmt.c_str(), adAverageQuality[s][c] );
}
log( CLP_LOG_RESULT, " " );
}
log( CLP_LOG_INFO, "\n" );
return 0;
}
CalypFrame* CalypTools::applyFrameModule()
{
CalypFrame* pcProcessedFrame = NULL;
if( m_pcCurrModuleIf->m_iModuleType == CLP_FRAME_PROCESSING_MODULE )
{
pcProcessedFrame = m_pcCurrModuleIf->process( m_apcInputStreams[0]->getCurrFrame() );
}
return pcProcessedFrame;
}
int CalypTools::ModuleOperation()
{
std::vector<CalypFrame*> apcFrameList;
log( CLP_LOG_INFO, " Applying Module %s/%s ...\n", m_pcCurrModuleIf->m_pchModuleCategory,
m_pcCurrModuleIf->m_pchModuleName );
CalypFrame* pcProcessedFrame = NULL;
double dMeasurementResult = 0.0;
double dAveragedMeasurementResult = 0;
bool abEOF[MAX_NUMBER_INPUTS];
for( unsigned int s = 0; s < m_apcInputStreams.size(); s++ )
{
abEOF[s] = false;
}
for( unsigned int frame = 0; frame < m_uiNumberOfFrames; frame++ )
{
apcFrameList.clear();
for( unsigned int i = 0; i < m_pcCurrModuleIf->m_uiNumberOfFrames; i++ )
{
apcFrameList.push_back( m_apcInputStreams[i]->getCurrFrame() );
}
if( m_pcCurrModuleIf->m_iModuleType == CLP_FRAME_PROCESSING_MODULE )
{
if( m_pcCurrModuleIf->m_iModuleAPI == CLP_MODULE_API_2 )
{
pcProcessedFrame = m_pcCurrModuleIf->process( apcFrameList );
}
else
{
pcProcessedFrame = applyFrameModule();
}
m_apcOutputStreams[0]->writeFrame( pcProcessedFrame );
}
else if( m_pcCurrModuleIf->m_iModuleType == CLP_FRAME_MEASUREMENT_MODULE )
{
if( m_pcCurrModuleIf->m_iModuleAPI == CLP_MODULE_API_2 )
{
dMeasurementResult = m_pcCurrModuleIf->measure( apcFrameList );
}
else
{
dMeasurementResult = m_pcCurrModuleIf->measure( m_apcInputStreams[0]->getCurrFrame() );
}
log( CLP_LOG_INFO, " %3d", frame );
log( CLP_LOG_RESULT, " %8.3f \n", dMeasurementResult );
dAveragedMeasurementResult =
( dAveragedMeasurementResult * double( frame ) + dMeasurementResult ) / double( frame + 1 );
}
for( unsigned int s = 0; s < m_apcInputStreams.size(); s++ )
{
abEOF[s] = m_apcInputStreams[s]->setNextFrame();
if( !abEOF[s] )
{
m_apcInputStreams[s]->readNextFrame();
}
}
}
if( m_pcCurrModuleIf->m_iModuleType == CLP_FRAME_MEASUREMENT_MODULE )
{
log( CLP_LOG_INFO, "\n Mean Value: \n %8.3f\n", dAveragedMeasurementResult );
}
return 0;
}