Audio::CodecRegistry Class Reference

#include <CodecRegistry.h>

Inheritance diagram for Audio::CodecRegistry:

Public Member Functions
	CodecRegistry () throw ()
	~CodecRegistry ()
void	add (Codec *codec, int priority=0) throw ()
void	remove (Codec *codec) throw ()
Codec *	findByName (const std::string &name) const throw (CodecNotFoundException)
Codec *	findByFile (const std::string &path, VSFileSystem::VSFileType type=VSFileSystem::UnknownFile) const throw (CodecNotFoundException)
Stream *	open (const std::string &path, VSFileSystem::VSFileType type=VSFileSystem::UnknownFile) const throw (Exception)

Additional Inherited Members
Static Public Member Functions inherited from Singleton< CodecRegistry >
static CodecRegistry *	getSingleton ()
Protected Member Functions inherited from Singleton< CodecRegistry >
	~Singleton ()
Static Protected Member Functions inherited from Singleton< CodecRegistry >
static void	initializeSingleton ()
static void	deinitializeSingleton ()
Static Protected Attributes inherited from Singleton< CodecRegistry >
static CodecRegistry *	_singletonInstance

Detailed Description

Codec registry class.

Remarks

Use it to manage codec implementations.

It handles codec factories and manages resolving file-to-codec associations.

See Also

Codec

Definition at line 30 of file CodecRegistry.h.

Constructor & Destructor Documentation

Audio::CodecRegistry::CodecRegistry	(	)
throw	(
	)

Construct an empty registry

Remarks

End-users of the class shouldn't be using this. Singletons need it

Definition at line 16 of file CodecRegistry.cpp.

    {
    }

Audio::CodecRegistry::~CodecRegistry

(

)

Definition at line 20 of file CodecRegistry.cpp.

    {
        nameCodec.clear();
        universalCodecs.clear();
        extensionCodecs.clear();
        
        for (CodecPriority::const_iterator it = codecPriority.begin(); it != codecPriority.end(); ++it)
            delete it->first;
        codecPriority.clear();
    }

Member Function Documentation

void Audio::CodecRegistry::add	(	Codec *	codec,
		int	priority = 0
	)
throw	(
	)

Add a codec to the registry

Remarks

You may add a codec multiple times if you wish. The class guarantees that any further call will be a no-op. Previos priority will still apply.

Parameters

codec

The codec to be added to the registry.

Definition at line 31 of file CodecRegistry.cpp.

Referenced by Audio::CodecRegistration::CodecRegistration().

    {
        if (codecPriority.find(codec) == codecPriority.end()) {
            codecPriority[codec] = priority;
            nameCodec[codec->getName()] = codec;
            
            std::cout << "Registering codec " << codec->getName().c_str();
            
            const Codec::Extensions *ext = codec->getExtensions();
            if (ext) {
                for (Codec::Extensions::const_iterator it = ext->begin(); it != ext->end(); ++it) {
                    std::cout << " " << it->c_str();
                    extensionCodecs[*it].insert(codec);
                }
            } else {
                std::cout << " as universal";
                universalCodecs.insert(codec);
            }
            
            std::cout << "." << std::endl;
        } else {
            std::cout << "Codec " << codec->getName().c_str() << " already registered" << std::endl;
        }
    }

Codec * Audio::CodecRegistry::findByFile	(	const std::string &	path,
		VSFileSystem::VSFileType	type = VSFileSystem::UnknownFile
	)		const
throw	(	CodecNotFoundException
	)

Find a codec that can handle the file.

Returns

A codec instance that can handle the specified file (ie: canHandle() returns true). It will never return null.

Remarks

If there's more than one codec that can handle the file, the one with the higher priority will be returned. Notice that it can't be assured that the codec will be able to open the file, so be prepared to handle failures further down the road.

Instead of returning null, if a codec of such characteristics cannot be found,

an CodecNotFound exception is risen.

Definition at line 102 of file CodecRegistry.cpp.

    {
        std::vector<Codec*> candidates;
        
        // NOTE: we'll assume that if they are including the specified extension, they'll return
        //      true if asked if they can handle the file with !canOpen.
        size_t sep = path.find_last_of('.');
        if (sep != std::string::npos && (sep+1) < path.length()) {
            ExtensionCodecs::const_iterator eit = extensionCodecs.find(
                path.substr(sep+1, std::string::npos));
            if (eit != extensionCodecs.end())
                for (CodecSet::const_iterator esit=eit->second.begin(); esit != eit->second.end(); ++esit) 
                    candidates.push_back(*esit);
        }
        
        for (CodecSet::const_iterator uit = universalCodecs.begin(); uit != universalCodecs.end(); ++uit)
            if ((*uit)->canHandle(path, false, type))
                candidates.push_back(*uit);
        
        // Now we'll sort candidates by priority, and return the first codec that can actually handle the file.
        if (candidates.begin() != candidates.end()) {
            std::sort(
                candidates.begin(), 
                candidates.end(), 
                MappedComparator<CodecPriority,Codec*>(codecPriority));

            // Why do we need an explicit cast *to* const?
            // See http://www.mpi-inf.mpg.de/~hitoshi/otherprojects/tips/cpp-memo.shtml
            for (std::vector<Codec*>::const_reverse_iterator it = candidates.rbegin();
                    it != reinterpret_cast<const std::vector<Codec*> &>(candidates).rend(); ++it)
                if ((*it)->canHandle(path, true, type))
                    return *it;
        }
    
        // No candidate is able to handle this one!
        throw CodecNotFoundException(
            std::string("No registered codec can handle the file \"") + path + "\"");
    }

Codec * Audio::CodecRegistry::findByName	(	const std::string &	name)		const
throw	(	CodecNotFoundException
	)

Find a codec by its name

Returns

A codec instance named by the specified name, never null.

Remarks

If there's more than one codec with the same name, any one of them is returned. Not even necessarily the same each time. So avoid adding conflicting codecs.

Instead of returning null, if a codec of such characteristics cannot be found,

a CodecNotFound exception is risen.

Definition at line 71 of file CodecRegistry.cpp.

    {
        NameCodec::const_iterator it = nameCodec.find(name);
        if (it != nameCodec.end())
            return it->second; else
            throw CodecNotFoundException(
                std::string("No codec with name \"") + name + "\" has been registered");
    }

Stream * Audio::CodecRegistry::open	(	const std::string &	path,
		VSFileSystem::VSFileType	type = VSFileSystem::UnknownFile
	)		const
throw	(	Exception
	)

Open the specified file with a suitable codec.

See Also

findByFile

Definition at line 141 of file CodecRegistry.cpp.

References Audio::Codec::open().

    {
        Codec *codec = findByFile(path, type);
        return codec->open(path, type);
    }

void Audio::CodecRegistry::remove	(	Codec *	codec)
throw	(
	)

Remove a codec from the registry

Remarks

If the codec had already been removed, this is a no-op.

Parameters

codec

The codec to be removed from the registry.

Definition at line 56 of file CodecRegistry.cpp.

    {
        if (codecPriority.find(codec) != codecPriority.end()) {
            codecPriority.erase(codec);
            nameCodec.erase(codec->getName());
            const Codec::Extensions *ext = codec->getExtensions();
            if (ext) {
                for (Codec::Extensions::const_iterator it = ext->begin(); it != ext->end(); ++it) 
                    extensionCodecs[*it].erase(codec);
            } else {
                universalCodecs.erase(codec);
            }
        }
    }

---

The documentation for this class was generated from the following files:

• src/audio/CodecRegistry.h
• src/audio/CodecRegistry.cpp