video_writer.cxx

#include "video_writer.h"
#include <cgv/base/register.h>
#include <cgv/utils/scan.h>
#include <vector>
 
using namespace cgv::base;
using namespace cgv::data;
using namespace cgv::utils;
 
namespace cgv {
    namespace media {
        namespace video {
 
 
bool abst_video_writer::scan_codecs(std::vector<std::string>&) const
{
    return false;
}
 
bool abst_video_writer::set_codec(const std::string&)
{
    return false;
}
 
std::string abst_video_writer::get_codec() const
{
    return "";
}
 
struct video_writer_listener : public cgv::base::base, public cgv::base::registration_listener
{
    static std::vector<abst_video_writer*>& ref_writers()
    {
        static std::vector<abst_video_writer*> writers;
        return writers;
    }
    std::string get_type_name() const 
    {
        return "video_writer_listener";
    }
    void register_object(base_ptr object, const std::string&)
    {
        abst_video_writer* rd = object->get_interface<abst_video_writer>();
        if (rd)
            ref_writers().push_back(rd);
    }
    void unregister_object(base_ptr object, const std::string&)
    {
        for (unsigned int i=0; i<ref_writers().size(); ++i) {
            if (object == ref_writers()[i]) {
                ref_writers().erase(ref_writers().begin()+i);
                ++i;
            }
        }
    }
};
 
const std::string& video_writer::get_supported_extensions(char sep)
{
    static std::string exts;
    exts.clear();
    std::vector<abst_video_writer*>& writers = video_writer_listener::ref_writers();
    for (unsigned int i=0; i<writers.size(); ++i) {
        if (!exts.empty())
            exts += ';';
        exts += writers[i]->get_supported_extensions();
    }
    if (sep != ';') 
        cgv::utils::replace(exts,';',sep);
    return exts;
}
 
std::string video_writer::construct_filter_string()
{
    std::string text = "Video Files (";
    std::string exts = "*.";
    text += get_supported_extensions(',');
    text += "):";
    exts += get_supported_extensions(',');
    replace(exts,",",";*.");
    return text+exts;
}
 
 
 
video_writer::video_writer(const std::string& file_extension)
{
    wr = 0;
    std::string ext = to_lower(file_extension);
    std::vector<abst_video_writer*>& writers = video_writer_listener::ref_writers();
    for (unsigned int i=0; i<writers.size(); ++i) {
        if (cgv::utils::is_element(ext, writers[i]->get_supported_extensions())) {
            wr = writers[i]->clone();
            return;
        }
    }
    last_error  = "no video writer found for extension: ";
    last_error += ext;
}
 
const std::string& video_writer::get_last_error() const
{
    if (!wr)
        return last_error;
    return wr->get_last_error();
}
 
std::string video_writer::get_type_name() const
{
    if (wr)
        return wr->get_type_name();
    return "cmv::video_writer";
}
 
bool video_writer::scan_codecs(std::vector<std::string>& codec_names) const
{
    if (wr)
        return wr->scan_codecs(codec_names);
    return false;
}
 
bool video_writer::set_codec(const std::string& codec_name)
{
    if (wr)
        return wr->set_codec(codec_name);
    return false;
}
 
std::string video_writer::get_codec() const
{
    if (wr)
        return wr->get_codec();
    return "";
}
 
std::string video_writer::get_property_declarations()
{
    if (wr)
        return wr->get_property_declarations();
    return cgv::base::base::get_property_declarations();
}
 
bool video_writer::set_void(const std::string& property, const std::string& type, const void* value)
{
    if (wr)
        return wr->set_void(property, type, value);
    return cgv::base::base::set_void(property, type, value);
}
bool video_writer::get_void(const std::string& property, const std::string& type, void* value)
{
    if (wr)
        return wr->get_void(property, type, value);
    return cgv::base::base::get_void(property, type, value);
}
 
bool video_writer::open(const std::string& file_name, const data_format& image_format, float fps, bool interactive)
{
    if (wr)
        return wr->open(file_name, image_format, fps, interactive);
    last_error = "no video writer available";
    return false;
}
bool video_writer::write_frame(const const_data_view& image_data)
{
    if (wr)
        return wr->write_frame(image_data);
    last_error = "no video writer available";
    return false;
}
 
bool video_writer::close()
{
    if (wr)
        return wr->close();
    last_error = "no video writer available";
    return false;
}
 
 
object_registration<video_writer_listener> video_writer_listener_registration("register video writer listener");
 
        }
    }
}