diff --git a/app/SConscript b/app/SConscript
index b423923f..3266c5e8 100644
--- a/app/SConscript
+++ b/app/SConscript
@@ -104,6 +104,20 @@ if platform.system() != 'Windows':
                         ],
         )
 
+avprofiles = env.Program(
+        'avoptions',
+        Glob( 'optionChecker/*.cpp' ),
+        LIBS = [
+                sAvTranscoder,
+                'avutil',
+                'avformat',
+                'avcodec'
+                ],
+        CXXFLAGS = [
+                '-std=c++0x'
+                ],
+        )
+
 env.Depends( avmeta, sAvTranscoder )
 env.Depends( audioRewrapper, sAvTranscoder )
 
diff --git a/app/avInfo/avInfo.cpp b/app/avInfo/avInfo.cpp
index e8829bba..909c84f3 100644
--- a/app/avInfo/avInfo.cpp
+++ b/app/avInfo/avInfo.cpp
@@ -1,12 +1,22 @@
 #include <iostream>
-#include <iomanip>
 
 #include <AvTranscoder/Description.hpp>
 
 int main( int argc, char** argv )
 {
 	// std::cout << "avinfo" << std::endl;
-	std::vector<std::string> inputExtension  = getInputExtensions();
-	std::vector<std::string> outputExtension = getOutputExtensions();
+	std::vector<std::string> inputExtension  = avtranscoder::getInputExtensions();
+	std::vector<std::string> outputExtension = avtranscoder::getOutputExtensions();
+	
+	std::cout << "----- inputExtension -----" << std::endl;
+	std::cout << "nb inputExtension: " << inputExtension.size() << std::endl;
+	for( std::vector<std::string>::iterator it = inputExtension.begin(); it != inputExtension.end(); ++it )
+		std::cout << *it << std::endl;
+	
+	std::cout << "----- outputExtension -----" << std::endl;
+	std::cout << "nb outputExtension: " << outputExtension.size() << std::endl;
+	for( std::vector<std::string>::iterator it = outputExtension.begin(); it != outputExtension.end(); ++it )
+		std::cout << *it << std::endl;
+	
 	return 0;
 }
diff --git a/app/optionChecker/optionChecker.cpp b/app/optionChecker/optionChecker.cpp
new file mode 100644
index 00000000..1aefbb78
--- /dev/null
+++ b/app/optionChecker/optionChecker.cpp
@@ -0,0 +1,86 @@
+#include <AvTranscoder/OptionLoader.hpp>
+#include <AvTranscoder/Option.hpp>
+
+#include <string>
+#include <iostream>
+#include <utility> //pair
+
+int optionChecker( const std::string& inputfilename )
+{	
+	avtranscoder::OptionLoader optionLoader;
+	optionLoader.loadOptions( 0, 0 );
+	
+	// display Options
+	for( auto option : optionLoader.getOptions() )
+	{
+		std::cout << std::left;
+		std::cout << "****************************" << std::endl;
+		std::cout << "Name: " << option.getName() << std::endl;
+		std::cout << "Unit : " << option.getUnit() << std::endl;
+		std::cout << "Help: " << option.getHelp() << std::endl;
+		std::cout << "Type: " << option.getType() << std::endl;
+		
+		// get default value
+		
+		if( option.getType() == avtranscoder::TypeInt )
+		{
+			std::cout << "DefaultValue: " << option.getDefaultValueInt() << std::endl;
+		}
+		else if( option.getType() == avtranscoder::TypeBool )
+		{
+			std::cout << "DefaultValue: " << option.getDefaultValueBool() << std::endl;
+		}
+		else if( option.getType() == avtranscoder::TypeDouble )
+		{
+			std::cout << "DefaultValue: " << option.getDefaultValueDouble() << std::endl;
+		}
+		else if( option.getType() == avtranscoder::TypeRatio )
+		{
+			std::cout << "DefaultValue: " << option.getDefaultValueRatio().first << ", " << option.getDefaultValueRatio().second << std::endl;
+		}
+		else if( option.getType() == avtranscoder::TypeString )
+		{
+			std::cout << "DefaultValue: " << option.getDefaultValueString() << std::endl;
+		}
+		else if( option.getType() == avtranscoder::TypeChoice )
+		{
+			std::cout << "Nb choices: " << option.getNbChilds() << std::endl;
+			std::cout << "Default choice index: " << option.getDefaultChildIndex() << std::endl;
+			for(size_t i = 0; i < option.getNbChilds(); ++i )
+				std::cout << "Choice " << i << ": " << 
+					option.getChild( i ).getName() << " // " << 
+					option.getChild( i ).getHelp() << std::endl;
+		}
+		else if( option.getType() == avtranscoder::TypeGroup )
+		{
+			std::cout << "Nb choices: " << option.getNbChilds() << std::endl;
+			for(size_t i = 0; i < option.getNbChilds(); ++i )
+				std::cout << "Element " << i << ": " << 
+					option.getChild( i ).getName() << " // " <<
+					option.getChild( i ).getDefaultValueBool() << std::endl;
+		}
+	}
+}
+
+int main( int argc, char** argv )
+{
+	if( argc <= 1 )
+	{
+		std::cout << "audiorewrapper require a media filename" << std::endl;
+		std::cout << "example: audioWrap file.ext" << std::endl;
+		return( -1 );
+	}
+
+	std::cout << "start ..." << std::endl;
+
+	try
+	{
+		optionChecker( argv[1] );
+	}
+	catch( std::exception &e )
+	{
+		std::cout << "[ERROR] " << e.what() << std::endl;
+	}
+	
+	std::cout << "end ..." << std::endl;
+}
diff --git a/src/AvTranscoder/Description.hpp b/src/AvTranscoder/Description.hpp
index 73d80b1b..4e964e2f 100644
--- a/src/AvTranscoder/Description.hpp
+++ b/src/AvTranscoder/Description.hpp
@@ -11,6 +11,10 @@ extern "C" {
 
 #include <vector>
 #include <cstring>
+#include <algorithm> //sort, unique
+
+namespace avtranscoder
+{
 
 std::vector<size_t> getVersion()
 {
@@ -33,8 +37,19 @@ std::vector<std::string> getInputExtensions()
 	{
 		if( iFormat->extensions != NULL )
 		{
-			char* ext = const_cast<char*>( iFormat->extensions );
-
+			// parse extensions
+			std::string exts = std::string( iFormat->extensions );
+			char* ext = strtok( const_cast<char*>( exts.c_str() ), "," );
+			while( ext != NULL )
+			{
+				extensions.push_back( std::string( ext ) );
+				ext = strtok( NULL, "," );
+			}
+			
+			// parse name (name's format defines (in general) extensions )
+			// don't need to do it in recent LibAV/FFMpeg versions
+			exts = std::string( iFormat->name );
+			ext = strtok( const_cast<char*>( exts.c_str() ), "," );
 			while( ext != NULL )
 			{
 				extensions.push_back( std::string( ext ) );
@@ -42,17 +57,54 @@ std::vector<std::string> getInputExtensions()
 			}
 		}
 	}
+	// sort
+	std::sort( extensions.begin(), extensions.end() ); 
+	// suppress duplicates
+	std::vector<std::string>::iterator last = std::unique( extensions.begin(), extensions.end() );
+	extensions.erase( last, extensions.end() );
+	
 	return extensions;
 }
 
 std::vector<std::string> getOutputExtensions()
 {
+	av_register_all();
 	std::vector<std::string> extensions;
+	AVOutputFormat* oFormat = NULL;
 
+	while( ( oFormat = av_oformat_next( oFormat ) ) )
+	{
+		if( oFormat->extensions != NULL )
+		{			
+			// parse extensions
+			std::string exts = std::string( oFormat->extensions );
+			char* ext = strtok( const_cast<char*>( exts.c_str() ), "," );
+			while( ext != NULL )
+			{
+				extensions.push_back( std::string( ext ) );
+				ext = strtok( NULL, "," );
+			}
+			
+			// parse name (name's format defines (in general) extensions )
+			// don't need to do it in recent LibAV/FFMpeg versions
+			exts = std::string( oFormat->name );
+			ext = strtok( const_cast<char*>( exts.c_str() ), "," );
+			while( ext != NULL )
+			{
+				extensions.push_back( std::string( ext ) );
+				ext = strtok( NULL, "," );
+			}
+		}
+	}
+	// sort
+	std::sort( extensions.begin(), extensions.end() ); 
+	// suppress duplicates
+	std::vector<std::string>::iterator last = std::unique( extensions.begin(), extensions.end() );
+	extensions.erase( last, extensions.end() );
+	
 	return extensions;
 }
 
-
+}
 
 #endif
-
diff --git a/src/AvTranscoder/InputStream.hpp b/src/AvTranscoder/InputStream.hpp
index ba220303..8393e750 100644
--- a/src/AvTranscoder/InputStream.hpp
+++ b/src/AvTranscoder/InputStream.hpp
@@ -11,10 +11,9 @@ namespace avtranscoder
 class InputStream
 {
 public:
-	InputStream( )
-	{}
+	InputStream() {}
 
-	virtual ~InputStream(){};
+	virtual ~InputStream() {};
 
 	virtual size_t getStreamIndex() const = 0;
 
diff --git a/src/AvTranscoder/InputStreamAudio.hpp b/src/AvTranscoder/InputStreamAudio.hpp
index eec97ba6..10aebb31 100644
--- a/src/AvTranscoder/InputStreamAudio.hpp
+++ b/src/AvTranscoder/InputStreamAudio.hpp
@@ -24,9 +24,6 @@ class AvExport InputStreamAudio
 	AVFrame*           m_frame;
 
 	int                m_selectedStream;
-
-private:
-
 };
 
 }
diff --git a/src/AvTranscoder/Option.cpp b/src/AvTranscoder/Option.cpp
new file mode 100644
index 00000000..d73f0713
--- /dev/null
+++ b/src/AvTranscoder/Option.cpp
@@ -0,0 +1,92 @@
+#include "Option.hpp"
+
+namespace avtranscoder
+{
+
+Option::Option( const AVOption& avOption, OptionType type )
+	: m_avOption( avOption )
+	, m_type( type )
+	, m_options()
+	, m_defaultChildIndex( 0 )
+{
+	
+}
+
+OptionType Option::getTypeFromAVOption( const char* unit, AVOptionType avType )
+{
+	if( unit && avType == AV_OPT_TYPE_FLAGS )
+		return TypeGroup;
+	else if( unit && avType == AV_OPT_TYPE_INT )
+		return TypeChoice;
+	else if( unit && avType == AV_OPT_TYPE_CONST )
+		return TypeChild;
+	
+	switch( avType )
+	{
+		case AV_OPT_TYPE_FLAGS:
+		{
+			return TypeBool;
+		}
+		case AV_OPT_TYPE_INT:
+		case AV_OPT_TYPE_INT64:
+		{
+			return TypeInt;
+		}
+		case AV_OPT_TYPE_DOUBLE:
+		case AV_OPT_TYPE_FLOAT:
+		{
+			return TypeDouble;
+		}
+		case AV_OPT_TYPE_STRING:
+		case AV_OPT_TYPE_BINARY:
+		{
+			return TypeString;
+		}
+		case AV_OPT_TYPE_RATIONAL:
+		{
+			return TypeRatio;
+		}
+		default:
+		{
+			return TypeUnknown;
+		}
+	}
+	return TypeUnknown;
+}
+
+OptionType Option::getType() const
+{
+	return m_type;
+}
+
+bool Option::getDefaultValueBool() const
+{
+	return m_avOption.default_val.i64;
+}
+
+int Option::getDefaultValueInt() const
+{
+	return m_avOption.default_val.i64;
+}
+
+double Option::getDefaultValueDouble() const
+{
+	return m_avOption.default_val.dbl;
+}
+
+std::string Option::getDefaultValueString() const
+{
+	return std::string( m_avOption.default_val.str ? m_avOption.default_val.str : "" );
+}
+
+std::pair<int, int> Option::getDefaultValueRatio() const
+{
+	return std::pair<int, int>( m_avOption.default_val.q.num, m_avOption.default_val.q.den );
+}
+
+void Option::appendChild( const Option& child )
+{
+	m_options.push_back( child );
+}
+
+}
diff --git a/src/AvTranscoder/Option.hpp b/src/AvTranscoder/Option.hpp
new file mode 100644
index 00000000..376099c2
--- /dev/null
+++ b/src/AvTranscoder/Option.hpp
@@ -0,0 +1,90 @@
+#ifndef _AV_TRANSCODER_OPTION_HPP
+#define	_AV_TRANSCODER_OPTION_HPP
+
+extern "C" {
+#ifndef __STDC_CONSTANT_MACROS
+	#define __STDC_CONSTANT_MACROS
+#endif
+#include <libavutil/opt.h>
+}
+
+#include <vector>
+#include <string>
+#include <utility> //pair
+
+namespace avtranscoder
+{
+
+enum OptionType {
+	TypeBool,
+	TypeInt,
+	TypeDouble,
+	TypeString,
+	TypeRatio,
+	TypeChoice,
+	TypeGroup,
+	
+	TypeChild, // Option which brelongs to Choice or Group
+	TypeUnknown
+};
+
+/**
+ * @brief Wrapper of AVOption.
+ * Get its type to know what the option is about: Int, Double, Ratio, Choice...
+ * Parse its array of options to get the potential childs (Choice and Group).
+ */
+class Option
+{
+public:
+	static OptionType getTypeFromAVOption( const char* unit, AVOptionType avType );
+	
+public:
+	Option( const AVOption& avOption, OptionType type );
+	~Option() {}
+	
+	OptionType getType() const;
+	std::string getName() const { return std::string( m_avOption.name ? m_avOption.name : "" ); }
+	std::string getHelp() const { return std::string( m_avOption.help ? m_avOption.help : "" ); }
+	std::string getUnit() const { return std::string( m_avOption.unit ? m_avOption.unit : "" ); }
+	int getOffset() const { return m_avOption.offset; }
+	
+	// flags
+	int getFlags() const { return m_avOption.flags; }
+	bool isEncodingOpt() const { return m_avOption.flags & AV_OPT_FLAG_ENCODING_PARAM; }
+	bool isDecodingOpt() const { return m_avOption.flags & AV_OPT_FLAG_DECODING_PARAM; }
+	bool isAudioOpt() const { return m_avOption.flags & AV_OPT_FLAG_AUDIO_PARAM; }
+	bool isVideoOpt() const { return m_avOption.flags & AV_OPT_FLAG_VIDEO_PARAM; }
+	bool isSubtitleOpt() const { return m_avOption.flags & AV_OPT_FLAG_SUBTITLE_PARAM; }
+	
+	// default value
+	bool getDefaultValueBool() const;
+	int getDefaultValueInt() const;
+	double getDefaultValueDouble() const;
+	std::string getDefaultValueString() const;
+	std::pair<int, int> getDefaultValueRatio() const;
+	
+	// array of childs
+	bool hasChild() const { return ! m_options.empty(); }
+	const std::vector<Option>& getChilds() { return m_options; }
+	const Option& getChild( size_t index ) { return m_options.at( index ); }
+	size_t getNbChilds() const { return m_options.size(); }
+	int getDefaultChildIndex() const { return m_defaultChildIndex; }
+	
+	void setDefaultChildIndex( size_t index ) { m_defaultChildIndex = index; }
+	void appendChild( const Option& child );
+	
+private:
+	AVOption m_avOption;
+	OptionType m_type;
+	
+	/**
+	 * If the option corresponds to a Choice or a Group, it can contain childs,
+	 * which are also options.
+	 */
+	std::vector<Option> m_options;
+	size_t m_defaultChildIndex;
+};
+
+}
+
+#endif
diff --git a/src/AvTranscoder/OptionLoader.cpp b/src/AvTranscoder/OptionLoader.cpp
new file mode 100644
index 00000000..7a1c172d
--- /dev/null
+++ b/src/AvTranscoder/OptionLoader.cpp
@@ -0,0 +1,109 @@
+#include "OptionLoader.hpp"
+
+extern "C" {
+#ifndef __STDC_CONSTANT_MACROS
+	#define __STDC_CONSTANT_MACROS
+#endif
+#include <libavutil/opt.h>
+}
+
+#include <string>
+#include <map>
+#include <utility> //pair
+#include <exception>
+
+namespace avtranscoder
+{
+
+OptionLoader::OptionLoader()
+	: m_options()
+	, m_avFormatContext( NULL )
+	, m_avCodecContext( NULL )
+{
+	m_avFormatContext = avformat_alloc_context();
+	
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT( 53, 8, 0 )
+	m_avCodecContext = avcodec_alloc_context();
+	// deprecated in the same version
+	//m_avCodecContext = avcodec_alloc_context2( AVMEDIA_TYPE_UNKNOWN );
+#else
+	AVCodec* avCodec = NULL;
+	m_avCodecContext = avcodec_alloc_context3( avCodec );
+#endif
+}
+
+OptionLoader::~OptionLoader()
+{
+	avformat_free_context( m_avFormatContext );
+	avcodec_close( m_avCodecContext );
+}
+
+void OptionLoader::loadOptions( int req_flags, int rej_flags )
+{
+	std::map<std::string, int> optionUnitToIndex;
+	std::vector<Option> childOptions;
+	
+	const AVOption* avOption = NULL;
+	
+	// get ffmpeg / libav object on which we'll scan AVOption
+	void* av_class = NULL;
+	if( ( req_flags & AV_OPT_FLAG_VIDEO_PARAM ) == AV_OPT_FLAG_VIDEO_PARAM ||
+		( req_flags & AV_OPT_FLAG_AUDIO_PARAM ) == AV_OPT_FLAG_AUDIO_PARAM ||
+		( req_flags & AV_OPT_FLAG_METADATA ) == AV_OPT_FLAG_METADATA ||
+		( req_flags & AV_OPT_FLAG_FILTERING_PARAM ) == AV_OPT_FLAG_FILTERING_PARAM ||
+		( req_flags & AV_OPT_FLAG_SUBTITLE_PARAM ) == AV_OPT_FLAG_SUBTITLE_PARAM )
+	{
+		av_class = (void*)m_avCodecContext;
+	}
+	else
+	{
+		av_class = (void*)m_avFormatContext;
+	}
+	
+	// iterate on options
+	while( ( avOption = av_opt_next( av_class, avOption ) ) != NULL )
+	{	
+		if( !avOption || 
+			! avOption->name ||
+			( avOption->flags & req_flags ) != req_flags ||
+			( avOption->flags & rej_flags ) )
+		{
+			continue;
+		}
+
+		OptionType optionType = Option::getTypeFromAVOption( avOption->unit, avOption->type );
+
+		//std::cout << "The option is " << avOption->name << " of type : " << avOption->type << std::endl;
+
+		if( optionType == TypeChild )
+		{
+			childOptions.push_back( Option( *avOption, optionType ) );
+		}
+		else
+		{
+			m_options.push_back( Option( *avOption, optionType ) );
+			optionUnitToIndex.insert( 
+				std::pair<std::string, int>( 
+					std::string( avOption->unit ? avOption->unit : "" ), 
+					m_options.size() - 1 ) 
+				);
+		}
+	}
+
+	// iterate on childs option
+	for( std::vector<Option>::iterator it = childOptions.begin(); it != childOptions.end(); ++it )
+	{
+		int indexParentOption = optionUnitToIndex.at( it->getUnit() );
+		
+		m_options.at( indexParentOption ).appendChild( *it );
+		
+		// child of a Choice
+		if( m_options.at( indexParentOption ).getType() == TypeChoice )
+		{
+			if( it->getDefaultValueInt() == m_options.at( indexParentOption ).getDefaultValueInt() )
+				m_options.at( indexParentOption ).setDefaultChildIndex( m_options.at( indexParentOption ).getNbChilds() - 1 );
+		}
+	}
+}
+
+}
diff --git a/src/AvTranscoder/OptionLoader.hpp b/src/AvTranscoder/OptionLoader.hpp
new file mode 100644
index 00000000..2dead92b
--- /dev/null
+++ b/src/AvTranscoder/OptionLoader.hpp
@@ -0,0 +1,51 @@
+#ifndef _AV_TRANSCODER_OPTION_LOADER_HPP
+#define	_AV_TRANSCODER_OPTION_LOADER_HPP
+
+#include <AvTranscoder/Option.hpp>
+
+extern "C" {
+#ifndef __STDC_CONSTANT_MACROS
+	#define __STDC_CONSTANT_MACROS
+#endif
+	#include <libavcodec/avcodec.h>
+	#include <libavformat/avformat.h>
+}
+
+#include <vector>
+
+namespace avtranscoder
+{
+
+/**
+ * @brief Manage a list of Option.
+ * The list is filled by loading options from a libav / ffmpeg object.
+ */
+class OptionLoader 
+{
+public:
+	OptionLoader();
+	~OptionLoader();
+	
+	std::vector<Option>& getOptions() { return m_options; }
+	
+	const AVFormatContext* getFormatContext() const { return m_avFormatContext; }
+	const AVCodecContext* getCodecContext() const { return m_avCodecContext; }
+	
+	/**
+	 * @brief: load array of Option depending on the flags.
+     * @param req_flags
+     * @param rej_flags
+     */
+	void loadOptions( int req_flags, int rej_flags );
+	
+private:
+	std::vector<Option> m_options;
+	
+	AVFormatContext* m_avFormatContext;
+	AVCodecContext* m_avCodecContext;
+
+};
+
+}
+
+#endif
diff --git a/src/SConscript b/src/SConscript
index db147a3c..2def4d02 100644
--- a/src/SConscript
+++ b/src/SConscript
@@ -14,7 +14,7 @@ env.Append(
 
 sAvTranscoder = env.StaticLibrary(
     'sAvTranscoder',
-    Glob( 'AvTranscoder/*.cpp' ) + Glob( 'AvTranscoder/DatasStructures/*.cpp' ) ,
+    Glob( 'AvTranscoder/*.cpp' ) + Glob( 'AvTranscoder/DatasStructures/*.cpp' ),
     LIBS = [
         'libavutil',
         'libavcodec',
@@ -26,7 +26,7 @@ sAvTranscoder = env.StaticLibrary(
 
 SharedAvTranscoder = env.SharedLibrary(
     'AvTranscoder',
-    Glob( 'AvTranscoder/*.cpp' ) + Glob( 'AvTranscoder/DatasStructures/*.cpp' ) ,
+    Glob( 'AvTranscoder/*.cpp' ) + Glob( 'AvTranscoder/DatasStructures/*.cpp' ),
     LIBS = [
         'libavutil',
         'libavcodec',