diff --git a/app/VideoSubWindow.cpp b/app/VideoSubWindow.cpp
index e6ce92a..0553271 100644
--- a/app/VideoSubWindow.cpp
+++ b/app/VideoSubWindow.cpp
@@ -413,6 +413,9 @@ Void VideoSubWindow::updateVideoWindowInfo()
   if( m_pcCurrFrame )
   {
     QString m_cPelFmtName = QString::fromStdString( m_pcCurrFrame->getPelFmtName() );
+    if( m_pCurrStream )
+      if( !m_pCurrStream->isNative() )
+        m_cPelFmtName += "*";
     m_cStreamInformation += " | " + m_cPelFmtName;
   }
   //#endif
diff --git a/lib/PlaYUVerDefs.h b/lib/PlaYUVerDefs.h
index 507b1a1..213469d 100644
--- a/lib/PlaYUVerDefs.h
+++ b/lib/PlaYUVerDefs.h
@@ -30,10 +30,6 @@
 #include <string>
 #include <vector>
 
-// ====================================================================================================================
-// Basic type redefinition
-// ====================================================================================================================
-
 typedef void Void;
 typedef bool Bool;
 
@@ -49,52 +45,23 @@ typedef float Float;
 typedef unsigned char UInt8;
 typedef unsigned int UInt16;
 
-typedef std::string String;
+typedef UShort Pel;  ///< 16-bit pixel type
+typedef UChar Byte;
 
-// ====================================================================================================================
-// 64-bit integer type
-// ====================================================================================================================
+typedef std::string String;
 
 #ifdef _MSC_VER
 typedef __int64 Int64;
-
 #if _MSC_VER <= 1200     // MS VC6
 typedef __int64 UInt64;  // MS VC6 does not support unsigned __int64 to double conversion
 #else
 typedef unsigned __int64 UInt64;
 #endif
-
 #else
-
 typedef long long Int64;
 typedef unsigned long long UInt64;
-
 #endif
 
-// ====================================================================================================================
-// Type definition
-// ====================================================================================================================
-
-typedef UShort Pel;  ///< 16-bit pixel type
-typedef UChar Byte;
-
-// ====================================================================================================================
-// Limits definition
-// ====================================================================================================================
-
-// #define MAX_UINT                    0xFFFFFFFFU ///< max. value of unsigned
-// 32-bit integer
-// #define MAX_INT                     2147483647  ///< max. value of signed
-// 32-bit integer
-// #define MAX_INT64                   0x7FFFFFFFFFFFFFFFLL  ///< max. value of
-// signed 64-bit integer
-// #define MAX_DOUBLE                  1.7e+308    ///< max. value of
-// double-type value
-
-// ====================================================================================================================
-// PlaYUVer definitions
-// ====================================================================================================================
-
 enum LOG_LEVEL
 {
   LOG_INFO = 1,
diff --git a/lib/PlaYUVerOptions.cpp b/lib/PlaYUVerOptions.cpp
index 0c09b48..069784d 100644
--- a/lib/PlaYUVerOptions.cpp
+++ b/lib/PlaYUVerOptions.cpp
@@ -214,19 +214,15 @@ template PlaYUVerOptions& PlaYUVerOptions::operator()( const String& name, std::
 template PlaYUVerOptions& PlaYUVerOptions::operator()( const String& name, std::vector<String>& storage,
                                                        const String& desc );
 
-/**
- * Add option described by name to the parent Options list,
- *   with desc as an optional help description
- * instead of storing the value somewhere, a function of type
- * FunctionOption::Func is called.  It is upto this function to correctly
- * handle evaluating the option's value.
- */
-// PlaYUVerOptions& PlaYUVerOptions::operator()( const String& name,
-// FunctionOption::Func *func, const String& desc )
-// {
-//   addOption( new FunctionOption( name, parent, func, desc ) );
-//   return *this;
-// }
+PlaYUVerOptions::Option::Option()
+    : opt( 0 ) {}
+
+PlaYUVerOptions::Option::~Option()
+{
+  if( opt )
+    delete opt;
+}
+
 PlaYUVerOptions::PlaYUVerOptions( const String& name )
 {
   m_cOptionGroupName = name;
diff --git a/lib/PlaYUVerOptions.h b/lib/PlaYUVerOptions.h
index 8de2857..bd7bf1b 100644
--- a/lib/PlaYUVerOptions.h
+++ b/lib/PlaYUVerOptions.h
@@ -69,18 +69,12 @@ class PlaYUVerOptions
 public:
   struct Option
   {
-    Option()
-        : opt( 0 ) {}
-    ~Option()
-    {
-      if( opt )
-        delete opt;
-    }
+    Option();
+    ~Option();
     std::list<String> opt_long;
     std::list<String> opt_short;
     OptionBase* opt;
   };
-
   typedef std::list<Option*> OptionsList;
 
   PlaYUVerOptions( const String& name = "" );
@@ -119,19 +113,7 @@ public:
   template <typename T>
   PlaYUVerOptions& operator()( const String& name, T& storage, const String& desc );
 
-  /**
-   * Add option described by name to the parent Options list,
-   *   with desc as an optional help description
-   * instead of storing the value somewhere, a function of type
-   * OptionFunc::Func is called.  It is upto this function to correctly
-   * handle evaluating the option's value.
-   */
-  //   PlaYUVerOptions&
-  //   operator()( const String& name, OptionFunc::Func *func, const String&
-  //   desc );
-
   Bool checkListingOpts();
-  //Void listModules();
 
 private:
   typedef std::map<String, OptionsList> OptionMap;
diff --git a/lib/PlaYUVerStream.cpp b/lib/PlaYUVerStream.cpp
index 3f40d24..1d9747c 100644
--- a/lib/PlaYUVerStream.cpp
+++ b/lib/PlaYUVerStream.cpp
@@ -86,6 +86,33 @@ private:
   inline Int prevIndex() { return m_uiIndex - 1 < 0 ? m_apcFrameBuffer.size() - 1 : m_uiIndex - 1; }
 };
 
+class PlaYUVerStreamPrivate
+{
+public:
+  Bool isInit;
+  Bool isInput;
+
+  PlaYUVerStreamHandlerIf* handler;
+  CreateStreamHandlerFn pfctCreateHandler;
+
+  PlaYUVerStreamBufferPrivate* frameBuffer;
+
+  String cFilename;
+  Int64 iCurrFrameNum;
+  Bool bLoadAll;
+
+  PlaYUVerStreamPrivate()
+  {
+    isInit = false;
+    pfctCreateHandler = NULL;
+    handler = NULL;
+    isInput = true;
+    bLoadAll = false;
+    iCurrFrameNum = -1;
+    cFilename = "";
+  }
+};
+
 std::vector<PlaYUVerSupportedFormat> PlaYUVerStream::supportedReadFormats()
 {
   INI_REGIST_PLAYUVER_SUPPORTED_FMT;
@@ -186,14 +213,8 @@ CreateStreamHandlerFn PlaYUVerStream::findStreamHandler( String strFilename, boo
 }
 
 PlaYUVerStream::PlaYUVerStream()
+    : d( new PlaYUVerStreamPrivate )
 {
-  m_bInit = false;
-  m_pfctCreateHandler = NULL;
-  m_pcHandler = NULL;
-  m_bIsInput = true;
-  m_bLoadAll = false;
-  m_iCurrFrameNum = -1;
-  m_cFilename = "";
 }
 
 PlaYUVerStream::~PlaYUVerStream()
@@ -203,11 +224,11 @@ PlaYUVerStream::~PlaYUVerStream()
 
 String PlaYUVerStream::getFormatName()
 {
-  return !m_pcHandler ? "" : m_pcHandler->getFormatName();
+  return !d->handler ? "" : d->handler->getFormatName();
 }
 String PlaYUVerStream::getCodecName()
 {
-  return !m_pcHandler ? "" : m_pcHandler->getCodecName();
+  return !d->handler ? "" : d->handler->getCodecName();
 }
 
 Bool PlaYUVerStream::open( String filename, String resolution, String input_format_name, UInt bitsPel, Int endianness,
@@ -239,174 +260,178 @@ Bool PlaYUVerStream::open( String filename, String resolution, String input_form
 Bool PlaYUVerStream::open( String filename, UInt width, UInt height, Int input_format, UInt bitsPel, Int endianness,
                            UInt frame_rate, Bool bInput )
 {
-  if( m_bInit )
+  if( d->isInit )
   {
     close();
   }
-  m_bInit = false;
-  m_bIsInput = bInput;
+  d->isInit = false;
+  d->isInput = bInput;
 
-  m_pfctCreateHandler = PlaYUVerStream::findStreamHandler( filename, m_bIsInput );
-  if( !m_pfctCreateHandler )
+  d->pfctCreateHandler = PlaYUVerStream::findStreamHandler( filename, d->isInput );
+  if( !d->pfctCreateHandler )
   {
     throw PlaYUVerFailure( "PlaYUVerStream", "Invalid handler" );
   }
 
-  m_pcHandler = m_pfctCreateHandler();
+  d->handler = d->pfctCreateHandler();
 
-  if( !m_pcHandler )
+  if( !d->handler )
   {
     throw PlaYUVerFailure( "PlaYUVerStream", "Cannot create handler" );
   }
 
-  m_cFilename = filename;
+  d->cFilename = filename;
 
-  m_pcHandler->m_cFilename = filename;
-  m_pcHandler->m_uiWidth = width;
-  m_pcHandler->m_uiHeight = height;
-  m_pcHandler->m_iPixelFormat = input_format;
-  m_pcHandler->m_uiBitsPerPixel = bitsPel;
-  m_pcHandler->m_iEndianness = endianness;
-  m_pcHandler->m_dFrameRate = frame_rate;
+  d->handler->m_cFilename = filename;
+  d->handler->m_uiWidth = width;
+  d->handler->m_uiHeight = height;
+  d->handler->m_iPixelFormat = input_format;
+  d->handler->m_uiBitsPerPixel = bitsPel;
+  d->handler->m_iEndianness = endianness;
+  d->handler->m_dFrameRate = frame_rate;
 
-  if( !m_pcHandler->openHandler( m_cFilename, m_bIsInput ) )
+  if( !d->handler->openHandler( d->cFilename, d->isInput ) )
   {
     close();
-    return m_bInit;
+    return d->isInit;
   }
 
-  if( m_pcHandler->m_uiWidth <= 0 || m_pcHandler->m_uiHeight <= 0 || m_pcHandler->m_iPixelFormat < 0 )
+  if( d->handler->m_uiWidth <= 0 || d->handler->m_uiHeight <= 0 || d->handler->m_iPixelFormat < 0 )
   {
     close();
     throw PlaYUVerFailure( "PlaYUVerStream", "Incorrect configuration: width, height or pixel format" );
-    return m_bInit;
+    return d->isInit;
   }
 
   // Keep past, current and future frames
   try
   {
-    m_frameBuffer =
-        new PlaYUVerStreamBufferPrivate( m_bIsInput ? 3 : 1, m_pcHandler->m_uiWidth, m_pcHandler->m_uiHeight,
-                                         m_pcHandler->m_iPixelFormat, m_pcHandler->m_uiBitsPerPixel );
+    d->frameBuffer = new PlaYUVerStreamBufferPrivate( d->isInput ? 3 : 1, d->handler->m_uiWidth, d->handler->m_uiHeight,
+                                                      d->handler->m_iPixelFormat, d->handler->m_uiBitsPerPixel );
   }
   catch( PlaYUVerFailure& e )
   {
     close();
     throw PlaYUVerFailure( "PlaYUVerStream", "Cannot allocated frame buffer" );
-    return m_bInit;
+    return d->isInit;
   }
 
-  m_pcHandler->m_uiNBytesPerFrame = m_frameBuffer->current()->getBytesPerFrame();
+  d->handler->m_uiNBytesPerFrame = d->frameBuffer->current()->getBytesPerFrame();
 
   // Some handlers need to know how long is a frame to get frame number
-  m_pcHandler->calculateFrameNumber();
+  d->handler->calculateFrameNumber();
 
-  if( m_bIsInput && m_pcHandler->m_uiTotalNumberFrames == 0 )
+  if( d->isInput && d->handler->m_uiTotalNumberFrames == 0 )
   {
     close();
     throw PlaYUVerFailure( "PlaYUVerStream", "Incorrect configuration: less than one frame" );
-    return m_bInit;
+    return d->isInit;
   }
 
-  if( !m_pcHandler->configureBuffer( m_frameBuffer->current() ) )
+  if( !d->handler->configureBuffer( d->frameBuffer->current() ) )
   {
     close();
     throw PlaYUVerFailure( "PlaYUVerStream", "Cannot allocated buffers" );
-    return m_bInit;
+    return d->isInit;
   }
 
-  m_iCurrFrameNum = -1;
-  m_bInit = true;
+  d->iCurrFrameNum = -1;
+  d->isInit = true;
 
   seekInput( 0 );
 
-  m_bInit = true;
-  return m_bInit;
+  d->isInit = true;
+  return d->isInit;
 }
 
 Bool PlaYUVerStream::reload()
 {
-  m_pcHandler->closeHandler();
-  if( !m_pcHandler->openHandler( m_cFilename, m_bIsInput ) )
+  d->handler->closeHandler();
+  if( !d->handler->openHandler( d->cFilename, d->isInput ) )
   {
-    throw PlaYUVerFailure( "PlaYUVerStream", "Cannot open stream " + m_cFilename + " with the " +
-                                                 String( m_pcHandler->m_pchHandlerName ) + " handler" );
+    throw PlaYUVerFailure( "PlaYUVerStream", "Cannot open stream " + d->cFilename + " with the " +
+                                                 String( d->handler->m_pchHandlerName ) + " handler" );
   }
-  m_pcHandler->m_uiNBytesPerFrame = m_frameBuffer->current()->getBytesPerFrame();
-  m_pcHandler->calculateFrameNumber();
-  m_pcHandler->configureBuffer( m_frameBuffer->current() );
+  d->handler->m_uiNBytesPerFrame = d->frameBuffer->current()->getBytesPerFrame();
+  d->handler->calculateFrameNumber();
+  d->handler->configureBuffer( d->frameBuffer->current() );
 
-  if( m_pcHandler->m_uiWidth <= 0 || m_pcHandler->m_uiHeight <= 0 || m_pcHandler->m_iPixelFormat < 0 ||
-      m_pcHandler->m_uiBitsPerPixel == 0 || m_pcHandler->m_uiTotalNumberFrames == 0 )
+  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 )
   {
     return false;
   }
-  if( UInt( m_iCurrFrameNum ) >= m_pcHandler->m_uiTotalNumberFrames )
+  if( UInt( d->iCurrFrameNum ) >= d->handler->m_uiTotalNumberFrames )
   {
-    m_iCurrFrameNum = 0;
+    d->iCurrFrameNum = 0;
   }
-  Int currFrameNum = m_iCurrFrameNum;
-  m_iCurrFrameNum = -1;
+  Int currFrameNum = d->iCurrFrameNum;
+  d->iCurrFrameNum = -1;
   seekInput( currFrameNum );
   return true;
 }
 
 Void PlaYUVerStream::close()
 {
-  if( !m_bInit )
+  if( !d->isInit )
     return;
 
-  m_pcHandler->closeHandler();
-  m_pcHandler->Delete();
+  d->handler->closeHandler();
+  d->handler->Delete();
 
-  delete m_frameBuffer;
+  delete d->frameBuffer;
 
-  m_bLoadAll = false;
-  m_bInit = false;
+  d->bLoadAll = false;
+  d->isInit = false;
 }
 
 String PlaYUVerStream::getFileName()
 {
-  return m_cFilename;
+  return d->cFilename;
+}
+
+Bool PlaYUVerStream::isNative()
+{
+  return d->handler->m_bNative;
 }
 
 UInt PlaYUVerStream::getFrameNum()
 {
-  return m_pcHandler->m_uiTotalNumberFrames;
+  return d->handler->m_uiTotalNumberFrames;
 }
 UInt PlaYUVerStream::getWidth() const
 {
-  return m_pcHandler->m_uiWidth;
+  return d->handler->m_uiWidth;
 }
 UInt PlaYUVerStream::getHeight() const
 {
-  return m_pcHandler->m_uiHeight;
+  return d->handler->m_uiHeight;
 }
 Int PlaYUVerStream::getEndianess() const
 {
-  return m_pcHandler->m_iEndianness;
+  return d->handler->m_iEndianness;
 }
 Double PlaYUVerStream::getFrameRate()
 {
-  return m_pcHandler->m_dFrameRate;
+  return d->handler->m_dFrameRate;
 }
 
 Int PlaYUVerStream::getCurrFrameNum()
 {
-  return m_iCurrFrameNum;
+  return d->iCurrFrameNum;
 }
 
 Void PlaYUVerStream::getFormat( UInt& rWidth, UInt& rHeight, Int& rInputFormat, UInt& rBitsPerPel, Int& rEndianness,
                                 UInt& rFrameRate )
 {
-  if( m_bInit )
+  if( d->isInit )
   {
-    rWidth = m_pcHandler->m_uiWidth;
-    rHeight = m_pcHandler->m_uiHeight;
-    rInputFormat = m_pcHandler->m_iPixelFormat;
-    rBitsPerPel = m_pcHandler->m_uiBitsPerPixel;
-    rEndianness = m_pcHandler->m_iEndianness;
-    rFrameRate = m_pcHandler->m_dFrameRate;
+    rWidth = d->handler->m_uiWidth;
+    rHeight = d->handler->m_uiHeight;
+    rInputFormat = d->handler->m_iPixelFormat;
+    rBitsPerPel = d->handler->m_uiBitsPerPixel;
+    rEndianness = d->handler->m_iEndianness;
+    rFrameRate = d->handler->m_dFrameRate;
   }
   else
   {
@@ -421,12 +446,12 @@ Void PlaYUVerStream::getFormat( UInt& rWidth, UInt& rHeight, Int& rInputFormat,
 
 Void PlaYUVerStream::loadAll()
 {
-  if( m_bLoadAll || !m_bIsInput )
+  if( d->bLoadAll || !d->isInput )
     return;
 
   try
   {
-    m_frameBuffer->increase( m_pcHandler->m_uiTotalNumberFrames );
+    d->frameBuffer->increase( d->handler->m_uiTotalNumberFrames );
   }
   catch( PlaYUVerFailure& e )
   {
@@ -435,12 +460,12 @@ Void PlaYUVerStream::loadAll()
   }
 
   seekInput( 0 );
-  for( UInt i = 2; i < m_frameBuffer->size(); i++ )
+  for( UInt i = 2; i < d->frameBuffer->size(); i++ )
   {
-    readFrame( m_frameBuffer->frame( i ) );
+    readFrame( d->frameBuffer->frame( i ) );
   }
-  m_bLoadAll = true;
-  m_iCurrFrameNum = 0;
+  d->bLoadAll = true;
+  d->iCurrFrameNum = 0;
 }
 
 Void PlaYUVerStream::getDuration( Int* duration_array )
@@ -468,13 +493,13 @@ Void PlaYUVerStream::getDuration( Int* duration_array )
 
 Bool PlaYUVerStream::readFrame( PlaYUVerFrame* frame )
 {
-  if( !m_bInit || !m_bIsInput || m_pcHandler->m_uiCurrFrameFileIdx >= m_pcHandler->m_uiTotalNumberFrames )
+  if( !d->isInit || !d->isInput || d->handler->m_uiCurrFrameFileIdx >= d->handler->m_uiTotalNumberFrames )
     return false;
 
-  if( m_bLoadAll )
+  if( d->bLoadAll )
     return true;
 
-  if( !m_pcHandler->read( frame ) )
+  if( !d->handler->read( frame ) )
   {
     throw PlaYUVerFailure( "PlaYUVerStream", "Cannot read frame from stream" );
     return false;
@@ -484,12 +509,12 @@ Bool PlaYUVerStream::readFrame( PlaYUVerFrame* frame )
 
 Void PlaYUVerStream::writeFrame()
 {
-  writeFrame( m_frameBuffer->current() );
+  writeFrame( d->frameBuffer->current() );
 }
 
 Void PlaYUVerStream::writeFrame( PlaYUVerFrame* pcFrame )
 {
-  if( !m_pcHandler->write( pcFrame ) )
+  if( !d->handler->write( pcFrame ) )
   {
     throw PlaYUVerFailure( "PlaYUVerStream", "Cannot write frame into the stream" );
   }
@@ -498,7 +523,7 @@ Void PlaYUVerStream::writeFrame( PlaYUVerFrame* pcFrame )
 
 Bool PlaYUVerStream::saveFrame( const String& filename )
 {
-  return saveFrame( filename, m_frameBuffer->current() );
+  return saveFrame( filename, d->frameBuffer->current() );
 }
 
 Bool PlaYUVerStream::saveFrame( const String& filename, PlaYUVerFrame* saveFrame )
@@ -518,10 +543,10 @@ Bool PlaYUVerStream::setNextFrame()
 {
   Bool bEndOfSeq = false;
 
-  if( m_iCurrFrameNum + 1 < Int64( m_pcHandler->m_uiTotalNumberFrames ) )
+  if( d->iCurrFrameNum + 1 < Int64( d->handler->m_uiTotalNumberFrames ) )
   {
-    m_frameBuffer->setNextFrame();
-    m_iCurrFrameNum++;
+    d->frameBuffer->setNextFrame();
+    d->iCurrFrameNum++;
   }
   else
   {
@@ -532,44 +557,44 @@ Bool PlaYUVerStream::setNextFrame()
 
 Void PlaYUVerStream::readNextFrame()
 {
-  readFrame( m_frameBuffer->next() );
+  readFrame( d->frameBuffer->next() );
 }
 
 Void PlaYUVerStream::readNextFrameFillRGBBuffer()
 {
   readNextFrame();
-  m_frameBuffer->next()->fillRGBBuffer();
+  d->frameBuffer->next()->fillRGBBuffer();
   return;
 }
 
 PlaYUVerFrame* PlaYUVerStream::getCurrFrame( PlaYUVerFrame* pyuv_image )
 {
   if( pyuv_image == NULL )
-    pyuv_image = new PlaYUVerFrame( m_frameBuffer->current() );
+    pyuv_image = new PlaYUVerFrame( d->frameBuffer->current() );
   else
-    pyuv_image->copyFrom( m_frameBuffer->current() );
+    pyuv_image->copyFrom( d->frameBuffer->current() );
   return pyuv_image;
 }
 
 PlaYUVerFrame* PlaYUVerStream::getCurrFrame()
 {
-  return m_frameBuffer->current();
+  return d->frameBuffer->current();
 }
 
 Bool PlaYUVerStream::seekInputRelative( Bool bIsFoward )
 {
-  if( !m_bInit || !m_bIsInput )
+  if( !d->isInit || !d->isInput )
     return false;
 
   Bool bRet = false;
   if( bIsFoward )
   {
     bRet = !setNextFrame();
-    readFrame( m_frameBuffer->next() );
+    readFrame( d->frameBuffer->next() );
   }
   else
   {
-    UInt64 newFrameNum = m_iCurrFrameNum - 1;
+    UInt64 newFrameNum = d->iCurrFrameNum - 1;
     bRet = seekInput( newFrameNum );
   }
   return bRet;
@@ -577,26 +602,26 @@ Bool PlaYUVerStream::seekInputRelative( Bool bIsFoward )
 
 Bool PlaYUVerStream::seekInput( UInt64 new_frame_num )
 {
-  if( !m_bInit || new_frame_num >= m_pcHandler->m_uiTotalNumberFrames || Int64( new_frame_num ) == m_iCurrFrameNum )
+  if( !d->isInit || new_frame_num >= d->handler->m_uiTotalNumberFrames || Int64( new_frame_num ) == d->iCurrFrameNum )
     return false;
 
-  m_iCurrFrameNum = new_frame_num;
+  d->iCurrFrameNum = new_frame_num;
 
-  if( m_bLoadAll )
+  if( d->bLoadAll )
   {
-    m_frameBuffer->setIndex( m_iCurrFrameNum );
+    d->frameBuffer->setIndex( d->iCurrFrameNum );
     return true;
   }
 
-  if( !m_pcHandler->seek( m_iCurrFrameNum ) )
+  if( !d->handler->seek( d->iCurrFrameNum ) )
   {
     throw PlaYUVerFailure( "PlaYUVerStream", "Cannot seek file into desired position" );
   }
 
-  m_frameBuffer->setIndex( 0 );
-  readFrame( m_frameBuffer->current() );
-  if( m_pcHandler->m_uiTotalNumberFrames > 1 )
-    readFrame( m_frameBuffer->next() );
+  d->frameBuffer->setIndex( 0 );
+  readFrame( d->frameBuffer->current() );
+  if( d->handler->m_uiTotalNumberFrames > 1 )
+    readFrame( d->frameBuffer->next() );
 
   return true;
 }
diff --git a/lib/PlaYUVerStream.h b/lib/PlaYUVerStream.h
index 68d22ba..662a181 100644
--- a/lib/PlaYUVerStream.h
+++ b/lib/PlaYUVerStream.h
@@ -28,15 +28,8 @@
 #include "PlaYUVerDefs.h"
 
 class PlaYUVerFrame;
+class PlaYUVerStreamPrivate;
 class PlaYUVerStreamHandlerIf;
-class PlaYUVerStreamBufferPrivate;
-
-typedef struct
-{
-  String shortName;
-  UInt uiWidth;
-  UInt uiHeight;
-} PlaYUVerStdResolution;
 
 typedef PlaYUVerStreamHandlerIf* ( *CreateStreamHandlerFn )( void );
 
@@ -47,9 +40,15 @@ typedef struct
   std::vector<String> getExts();
   String formatPattern;
   CreateStreamHandlerFn formatFct;
-
 } PlaYUVerSupportedFormat;
 
+typedef struct
+{
+  String shortName;
+  UInt uiWidth;
+  UInt uiHeight;
+} PlaYUVerStdResolution;
+
 /**
  * \class PlaYUVerStream
  * \ingroup  PlaYUVerLib PlaYUVerLib_Stream
@@ -87,6 +86,7 @@ public:
   Bool reload();
   Void close();
 
+  Bool isNative();
   String getFileName();
   UInt getFrameNum();
   UInt getWidth() const;
@@ -116,24 +116,13 @@ public:
   Bool seekInputRelative( Bool bIsFoward );
   Bool seekInput( UInt64 new_frame_num );
 
-  Bool isInit() { return m_bInit; }
   Void getDuration( Int* duration_array );
 
 private:
   Bool readFrame( PlaYUVerFrame* frame );
 
 private:
-  Bool m_bInit;
-  CreateStreamHandlerFn m_pfctCreateHandler;
-  PlaYUVerStreamHandlerIf* m_pcHandler;
-
-  Bool m_bIsInput;
-  String m_cFilename;
-  Int64 m_iCurrFrameNum;
-
-  Bool m_bLoadAll;
-
-  PlaYUVerStreamBufferPrivate* m_frameBuffer;
+  PlaYUVerStreamPrivate* d;
 };
 
 #endif  // __PLAYUVERSTREAM_H__
diff --git a/lib/PlaYUVerStreamHandlerIf.h b/lib/PlaYUVerStreamHandlerIf.h
index 4b94d61..6bc8798 100644
--- a/lib/PlaYUVerStreamHandlerIf.h
+++ b/lib/PlaYUVerStreamHandlerIf.h
@@ -72,6 +72,7 @@ class PlaYUVerStreamHandlerIf
 public:
   PlaYUVerStreamHandlerIf()
       : m_bIsInput( true )
+      , m_bNative( true )
       , m_uiCurrFrameFileIdx( 0 )
       , m_uiWidth( 0 )
       , m_uiHeight( 0 )
@@ -105,6 +106,7 @@ protected:
   String m_strFormatName;
   String m_strCodecName;
   Bool m_bIsInput;
+  Bool m_bNative;
   UInt64 m_uiCurrFrameFileIdx;
   String m_cFilename;
   UInt m_uiWidth;
diff --git a/lib/StreamHandlerLibav.cpp b/lib/StreamHandlerLibav.cpp
index 5eb2cca..8c49580 100644
--- a/lib/StreamHandlerLibav.cpp
+++ b/lib/StreamHandlerLibav.cpp
@@ -43,6 +43,7 @@ std::vector<PlaYUVerSupportedFormat> StreamHandlerLibav::supportedReadFormats()
   REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, "Joint Photographic Experts Group", "jpg,jpeg" );
   REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, "Windows Bitmap", "bmp" );
   REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, "Tagged Image File Format", "tiff" );
+  REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, " Graphics Interchange Format", "gif" );
   REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, "Audio video interleaved", "avi" );
   REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, "Windows media video", "wmv" );
   REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, "MPEG-4", "mp4" );
@@ -174,7 +175,6 @@ Bool StreamHandlerLibav::openHandler( String strFilename, Bool bInput )
   /**
 	 * Auxiliar conversation to re-use similar pixfmt
 	 */
-  m_bRequiresConvertion = false;
   Int auxPixFmt = m_ffPixFmt;
   switch( m_ffPixFmt )
   {
@@ -211,7 +211,7 @@ Bool StreamHandlerLibav::openHandler( String strFilename, Bool bInput )
   {
     Int newPelFmt = PlaYUVerFrame::findPixelFormat( "YUV444p" );
     m_iPixelFormat = newPelFmt;
-    m_bRequiresConvertion = true;
+    m_bNative = false;
     //throw PlaYUVerFailure( "StreamHandlerLibav", "Cannot open file using FFmpeg libs - unsupported pixel format" );
     //return false;
   }
@@ -250,7 +250,7 @@ Bool StreamHandlerLibav::openHandler( String strFilename, Bool bInput )
     return false;
   }
 
-  if( m_bRequiresConvertion )
+  if( !m_bNative )
   {
     AVPixelFormat newAvFmt = AVPixelFormat( g_PlaYUVerPixFmtDescriptorsMap.at( m_iPixelFormat ).ffmpegPelFormat );
 
@@ -388,7 +388,7 @@ Bool StreamHandlerLibav::read( PlaYUVerFrame* pcFrame )
   if( bGotFrame )
   {
     AVFrame* decFrame = m_cFrame;
-    if( m_bRequiresConvertion )
+    if( !m_bNative )
     {
       sws_scale( m_ScalerCtx, (const uint8_t* const*)decFrame->data, decFrame->linesize, 0,
                  decFrame->height, (uint8_t* const*)m_cConvertedFrame->data, m_cConvertedFrame->linesize );
diff --git a/lib/StreamHandlerLibav.h b/lib/StreamHandlerLibav.h
index 54347a4..215d6bf 100644
--- a/lib/StreamHandlerLibav.h
+++ b/lib/StreamHandlerLibav.h
@@ -93,7 +93,6 @@ private:
   UInt64 m_uiSecs;
   UInt64 m_uiMicroSec;
 
-  Bool m_bRequiresConvertion;
   AVFrame* m_cConvertedFrame;
 };