Remove libxvid codec (not working) and replace the default by its real name. Update...
[synfig.git] / synfig-core / src / tool / main.cpp
index 06d1488..c587496 100644 (file)
@@ -69,6 +69,42 @@ int verbosity=0;
 bool be_quiet=false;
 bool print_benchmarks=false;
 
+//! Allowed video codecs
+/*! \warning This variable is linked to allowed_video_codecs_description,
+ *  if you change this you must change the other acordingly.
+ *  \warning These codecs are linked to the filename extensions for
+ *  mod_ffmpeg. If you change this you must change the others acordingly.
+ */
+const char* allowed_video_codecs[] =
+{
+       "flv", "h263p", "huffyuv", "libtheora", "libx264",
+       "mjpeg", "mpeg1video", "mpeg2video", "mpeg4", "msmpeg4",
+       "msmpeg4v1", "msmpeg4v2", "wmv1", "wmv2", NULL
+};
+
+//! Allowed video codecs description.
+/*! \warning This variable is linked to allowed_video_codecs,
+ *  if you change this you must change the other acordingly.
+ */
+const char* allowed_video_codecs_description[] =
+{
+       "Flash Video (FLV) / Sorenson Spark / Sorenson H.263.",
+       "H.263+ / H.263-1998 / H.263 version 2.",
+       "Huffyuv / HuffYUV.",
+       "libtheora Theora.",
+       "libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10.",
+       "MJPEG (Motion JPEG).",
+       "raw MPEG-1 video.",
+       "raw MPEG-2 video.",
+       "MPEG-4 part 2. (XviD/DivX)",
+       "MPEG-4 part 2 Microsoft variant version 3.",
+       "MPEG-4 part 2 Microsoft variant version 1.",
+       "MPEG-4 part 2 Microsoft variant version 2.",
+       "Windows Media Video 7.",
+       "Windows Media Video 8.",
+       NULL
+};
+
 /* === T Y P E D E F S ===================================================== */
 
 typedef list<String> arg_list_t;
@@ -148,6 +184,7 @@ void display_help(bool full)
                display_help_option("--layer-info", "<layer>", _("Print out layer's description, parameter info, etc."));
                display_help_option("--layers", NULL, _("Print out the list of available layers"));
                display_help_option("--targets", NULL, _("Print out the list of available targets"));
+               display_help_option("--target-video-codecs", NULL, _("Print out the list of available target video codecs"));
                display_help_option("--importers", NULL, _("Print out the list of available importers"));
                display_help_option("--valuenodes", NULL, _("Print out the list of available ValueNodes"));
                display_help_option("--modules", NULL, _("Print out the list of loaded modules"));
@@ -166,11 +203,20 @@ void display_help(bool full)
        cerr << endl;
 }
 
+void display_target_video_codecs_help ()
+{
+       for (int i = 0; allowed_video_codecs[i] != NULL &&
+                                       allowed_video_codecs_description[i] != NULL; i++)
+               cout << " " << allowed_video_codecs[i] << ":   \t"
+                        << allowed_video_codecs_description[i]
+                        << endl;
+}
+
 int process_global_flags(arg_list_t &arg_list)
 {
-       arg_list_t::iterator iter;
+       arg_list_t::iterator iter, next;
 
-       for(iter=arg_list.begin();iter!=arg_list.end();iter++)
+       for(next=arg_list.begin(),iter=next++;iter!=arg_list.end();iter=next++)
        {
                if(*iter == "--")
                        return SYNFIGTOOL_OK;
@@ -230,7 +276,7 @@ int process_global_flags(arg_list_t &arg_list)
                {
                        Progress p(PACKAGE);
                        synfig::Main synfig_main(dirname(progname),&p);
-                       iter++;
+                       iter=next++;
                        if (iter==arg_list.end())
                        {
                                error("The `%s' flag requires a value.  Use --help for a list of options.", "--layer-info");
@@ -276,6 +322,13 @@ int process_global_flags(arg_list_t &arg_list)
                        return SYNFIGTOOL_HELP;
                }
 
+               if(*iter == "--target-video-codecs")
+               {
+                       display_target_video_codecs_help();
+
+                       return SYNFIGTOOL_HELP;
+               }
+
                if(*iter == "--valuenodes")
                {
                        Progress p(PACKAGE);
@@ -354,9 +407,9 @@ bool flag_requires_value(String flag)
 
 int extract_arg_cluster(arg_list_t &arg_list,arg_list_t &cluster)
 {
-       arg_list_t::iterator iter;
+       arg_list_t::iterator iter, next;
 
-       for(iter=arg_list.begin();iter!=arg_list.end();iter++)
+       for(next=arg_list.begin(),iter=next++;iter!=arg_list.end();iter=next++)
        {
                if(*iter->begin() != '-')
                {
@@ -368,7 +421,7 @@ int extract_arg_cluster(arg_list_t &arg_list,arg_list_t &cluster)
                {
                        cluster.push_back(*iter);
                        arg_list.erase(iter);
-                       iter++;
+                       iter=next++;
                        if (iter==arg_list.end())
                        {
                                error("The `%s' flag requires a value.  Use --help for a list of options.", cluster.back().c_str());
@@ -388,13 +441,15 @@ int extract_arg_cluster(arg_list_t &arg_list,arg_list_t &cluster)
  * \param arg_list Argument list from wich the parameter is extracted.
  * \param iter Iterator pointing to the argument list parameter to be
  * extracted.
+ * \param next Iterator pointing to the next argument.
  */
 string extract_parameter (arg_list_t& arg_list,
-                                                 arg_list_t::iterator& iter)
+                                                 arg_list_t::iterator& iter,
+                                                 arg_list_t::iterator& next)
 {
        string parameter;
        arg_list.erase(iter);
-       iter++;
+       iter = next++;
        parameter = *iter;
        arg_list.erase(iter);
        return parameter;
@@ -402,78 +457,78 @@ string extract_parameter (arg_list_t& arg_list,
 
 int extract_RendDesc(arg_list_t &arg_list,RendDesc &desc)
 {
-       arg_list_t::iterator iter;
+       arg_list_t::iterator iter, next;
        int w=0,h=0;
        float span=0;
-       for(iter=arg_list.begin(); iter!=arg_list.end(); iter++)
+       for(next=arg_list.begin(),iter=next++;iter!=arg_list.end();iter=next++)
        {
                if(*iter=="-w")
                {
-                       w = atoi(extract_parameter(arg_list, iter).c_str());
+                       w = atoi(extract_parameter(arg_list, iter, next).c_str());
                }
                else if(*iter=="-h")
                {
-                       h = atoi(extract_parameter(arg_list, iter).c_str());
+                       h = atoi(extract_parameter(arg_list, iter, next).c_str());
                }
                else if(*iter=="-a")
                {
             int a;
-                       a = atoi(extract_parameter(arg_list, iter).c_str());
+                       a = atoi(extract_parameter(arg_list, iter, next).c_str());
                        desc.set_antialias(a);
                        VERBOSE_OUT(1)<<strprintf(_("Antialiasing set to %d, (%d samples per pixel)"),a,a*a)<<endl;
                }
                else if(*iter=="-s")
                {
-                       span = atoi(extract_parameter(arg_list, iter).c_str());
+                       span = atoi(extract_parameter(arg_list, iter, next).c_str());
                        VERBOSE_OUT(1)<<strprintf(_("Span set to %d units"),span)<<endl;
                }
                else if(*iter=="--fps")
                {
-                       float fps = atof(extract_parameter(arg_list, iter).c_str());
+                       float fps = atof(extract_parameter(arg_list, iter, next).c_str());
                        desc.set_frame_rate(fps);
                        VERBOSE_OUT(1)<<strprintf(_("Frame rate set to %d frames per second"),fps)<<endl;
                }
                else if(*iter=="--dpi")
                {
-                       float dpi = atof(extract_parameter(arg_list, iter).c_str());
+                       float dpi = atof(extract_parameter(arg_list, iter, next).c_str());
                        float dots_per_meter=dpi*39.3700787402;
                        desc.set_x_res(dots_per_meter).set_y_res(dots_per_meter);
                        VERBOSE_OUT(1)<<strprintf(_("Physical resolution set to %f dpi"),dpi)<<endl;
                }
                else if(*iter=="--dpi-x")
                {
-                       float dpi = atof(extract_parameter(arg_list, iter).c_str());
+                       float dpi = atof(extract_parameter(arg_list, iter, next).c_str());
                        float dots_per_meter=dpi*39.3700787402;
                        desc.set_x_res(dots_per_meter);
                        VERBOSE_OUT(1)<<strprintf(_("Physical X resolution set to %f dpi"),dpi)<<endl;
                }
                else if(*iter=="--dpi-y")
                {
-                       float dpi = atof(extract_parameter(arg_list, iter).c_str());
+                       float dpi = atof(extract_parameter(arg_list, iter, next).c_str());
                        float dots_per_meter=dpi*39.3700787402;
                        desc.set_y_res(dots_per_meter);
                        VERBOSE_OUT(1)<<strprintf(_("Physical Y resolution set to %f dpi"),dpi)<<endl;
                }
                else if(*iter=="--start-time" || *iter=="--begin-time")
                {
-                       desc.set_time_start(Time(extract_parameter(arg_list, iter),
+                       desc.set_time_start(Time(extract_parameter(arg_list, iter, next),
                                                                desc.get_frame_rate()));
                }
                else if(*iter=="--end-time")
                {
-                       desc.set_time_end(Time(extract_parameter(arg_list, iter),
+                       desc.set_time_end(Time(extract_parameter(arg_list, iter, next),
                                                                   desc.get_frame_rate()));
                }
                else if(*iter=="--time")
                {
-                       desc.set_time(Time(extract_parameter(arg_list, iter),
+                       desc.set_time(Time(extract_parameter(arg_list, iter, next),
                                                           desc.get_frame_rate()));
                        VERBOSE_OUT(1)<<_("Rendering frame at ")<<desc.get_time_start().get_string(desc.get_frame_rate())<<endl;
                }
                else if(*iter=="-g")
                {
                        synfig::warning("Gamma argument is currently ignored");
-                       //desc.set_gamma(Gamma(atoi(extract_parameter(arg_list, iter).c_str())));
+                       //desc.set_gamma(Gamma(atoi(extract_parameter(arg_list, iter, next).c_str())));
                }
                else if (flag_requires_value(*iter))
                        iter++;
@@ -495,12 +550,12 @@ int extract_RendDesc(arg_list_t &arg_list,RendDesc &desc)
 
 int extract_quality(arg_list_t &arg_list,int &quality)
 {
-       arg_list_t::iterator iter;
-       for(iter=arg_list.begin(); iter!=arg_list.end(); iter++)
+       arg_list_t::iterator iter, next;
+       for(next=arg_list.begin(),iter=next++;iter!=arg_list.end();iter=next++)
        {
                if(*iter=="-Q")
                {
-                       quality = atoi(extract_parameter(arg_list, iter).c_str());
+                       quality = atoi(extract_parameter(arg_list, iter, next).c_str());
                        VERBOSE_OUT(1)<<strprintf(_("Quality set to %d"),quality)<<endl;
                }
                else if (flag_requires_value(*iter))
@@ -512,12 +567,12 @@ int extract_quality(arg_list_t &arg_list,int &quality)
 
 int extract_threads(arg_list_t &arg_list,int &threads)
 {
-       arg_list_t::iterator iter;
-       for(iter=arg_list.begin(); iter!=arg_list.end(); iter++)
+       arg_list_t::iterator iter, next;
+       for(next=arg_list.begin(),iter=next++;iter!=arg_list.end();iter=next++)
        {
                if(*iter=="-T")
                {
-                       threads = atoi(extract_parameter(arg_list, iter).c_str());
+                       threads = atoi(extract_parameter(arg_list, iter, next).c_str());
                        VERBOSE_OUT(1)<<strprintf(_("Threads set to %d"),threads)<<endl;
                }
                else if (flag_requires_value(*iter))
@@ -529,14 +584,15 @@ int extract_threads(arg_list_t &arg_list,int &threads)
 
 int extract_target(arg_list_t &arg_list,string &type)
 {
-       arg_list_t::iterator iter;
+       arg_list_t::iterator iter, next;
        type.clear();
 
-       for(iter=arg_list.begin(); iter!=arg_list.end(); iter++)
+       for(next=arg_list.begin(),iter=next++;iter!=arg_list.end();iter=next++)
        {
                if(*iter=="-t")
                {
-                       type = extract_parameter(arg_list, iter);
+                       type = extract_parameter(arg_list, iter, next);
+                       VERBOSE_OUT(1)<<strprintf(_("Target set to %s"), type.c_str())<<endl;
                }
                else if (flag_requires_value(*iter))
                        iter++;
@@ -548,38 +604,70 @@ int extract_target(arg_list_t &arg_list,string &type)
 int extract_target_params(arg_list_t& arg_list,
                                                  TargetParam& params)
 {
-       arg_list_t::iterator iter;
+       int ret;
+       ret = SYNFIGTOOL_OK;
+       // If -vc parameter is provided, -vb parameter is needed.
+       bool need_bitrate_parameter = false;
+       arg_list_t::iterator iter, next;
 
-       for(iter=arg_list.begin(); iter!=arg_list.end(); iter++)
+       for(next=arg_list.begin(),iter=next++;iter!=arg_list.end();iter=next++)
        {
                if(*iter=="-vc")
                {
                        // Target video codec
-                       params.video_codec = extract_parameter(arg_list, iter);
+                       params.video_codec = extract_parameter(arg_list, iter, next);
+
+                       // video_codec string to lowercase
+                       transform (params.video_codec.begin(),
+                                          params.video_codec.end(),
+                                          params.video_codec.begin(),
+                                          ::tolower);
+
+                       int local_ret;
+                       local_ret = SYNFIGTOOL_UNKNOWNARGUMENT;
+
+                       // Check if the given video codec is allowed.
+                       for (int i = 0; local_ret != SYNFIGTOOL_OK &&
+                                                       allowed_video_codecs[i] != NULL; i++)
+                               if (params.video_codec == allowed_video_codecs[i])
+                                       local_ret = SYNFIGTOOL_OK;
+
+                       ret = local_ret;
+
+                       if (ret == SYNFIGTOOL_OK)
+                       {
+                               VERBOSE_OUT(1)<<strprintf(_("Target video codec set to %s"), params.video_codec.c_str())<<endl;
+                               need_bitrate_parameter = true;
+                       }
                }
                else if(*iter=="-vb")
                {
+                       need_bitrate_parameter = false;
                        // Target bitrate
                        params.bitrate =
-                               atoi(extract_parameter(arg_list, iter).c_str());
+                               atoi(extract_parameter(arg_list, iter, next).c_str());
+                       VERBOSE_OUT(1)<<strprintf(_("Target bitrate set to %dk"),params.bitrate)<<endl;
                }
                else if (flag_requires_value(*iter))
                        iter++;
        }
 
-       return SYNFIGTOOL_OK;
+       if (need_bitrate_parameter)
+               ret = SYNFIGTOOL_MISSINGARGUMENT;
+
+       return ret;
 }
 
 int extract_append(arg_list_t &arg_list,string &filename)
 {
-       arg_list_t::iterator iter;
+       arg_list_t::iterator iter, next;
        filename.clear();
 
-       for(iter=arg_list.begin(); iter!=arg_list.end(); iter++)
+       for(next=arg_list.begin(),iter=next++;iter!=arg_list.end();iter=next++)
        {
                if(*iter=="--append")
                {
-                       filename = extract_parameter(arg_list, iter);
+                       filename = extract_parameter(arg_list, iter, next);
                }
                else if (flag_requires_value(*iter))
                        iter++;
@@ -590,15 +678,15 @@ int extract_append(arg_list_t &arg_list,string &filename)
 
 int extract_outfile(arg_list_t &arg_list,string &outfile)
 {
-       arg_list_t::iterator iter;
+       arg_list_t::iterator iter, next;
        int ret=SYNFIGTOOL_FILENOTFOUND;
        outfile.clear();
 
-       for(iter=arg_list.begin(); iter!=arg_list.end(); iter++)
+       for(next=arg_list.begin(),iter=next++;iter!=arg_list.end();iter=next++)
        {
                if(*iter=="-o")
                {
-                       outfile = extract_parameter(arg_list, iter);
+                       outfile = extract_parameter(arg_list, iter, next);
                        ret=SYNFIGTOOL_OK;
                }
                else if (flag_requires_value(*iter))
@@ -610,14 +698,14 @@ int extract_outfile(arg_list_t &arg_list,string &outfile)
 
 int extract_canvasid(arg_list_t &arg_list,string &canvasid)
 {
-       arg_list_t::iterator iter;
+       arg_list_t::iterator iter, next;
        //canvasid.clear();
 
-       for(iter=arg_list.begin(); iter!=arg_list.end(); iter++)
+       for(next=arg_list.begin(),iter=next++;iter!=arg_list.end();iter=next++)
        {
                if(*iter=="-c")
                {
-                       canvasid = extract_parameter(arg_list, iter);
+                       canvasid = extract_parameter(arg_list, iter, next);
                }
                else if (flag_requires_value(*iter))
                        iter++;
@@ -628,9 +716,10 @@ int extract_canvasid(arg_list_t &arg_list,string &canvasid)
 
 int extract_list_canvases(arg_list_t &arg_list,bool &list_canvases)
 {
-       arg_list_t::iterator iter;
+       arg_list_t::iterator iter, next;
 
-       for(iter=arg_list.begin(); iter!=arg_list.end(); iter++)
+       for(next=arg_list.begin(), iter = next++; iter!=arg_list.end();
+               iter = next++)
                if(*iter=="--list-canvases")
                {
                        list_canvases = true;
@@ -642,13 +731,13 @@ int extract_list_canvases(arg_list_t &arg_list,bool &list_canvases)
 
 void extract_canvas_info(arg_list_t &arg_list, Job &job)
 {
-       arg_list_t::iterator iter;
+       arg_list_t::iterator iter, next;
 
-       for(iter=arg_list.begin(); iter!=arg_list.end(); iter++)
+       for(next=arg_list.begin(),iter=next++;iter!=arg_list.end();iter=next++)
                if(*iter=="--canvas-info")
                {
                        job.canvas_info = true;
-                       String values(extract_parameter(arg_list, iter)), value;
+                       String values(extract_parameter(arg_list, iter, next)), value;
 
                        std::string::size_type pos;
                        while (!values.empty())
@@ -1083,7 +1172,27 @@ int main(int argc, char *argv[])
                        // Extract the extra parameters for the targets that
                        // need them.
                        if (target_name == "ffmpeg")
-                               extract_target_params(imageargs, target_parameters);
+                       {
+                               int status;
+                               status = extract_target_params(imageargs, target_parameters);
+                               if (status == SYNFIGTOOL_UNKNOWNARGUMENT)
+                               {
+                                       cerr << strprintf(_("Unknown target video codec: %s."),
+                                                                        target_parameters.video_codec.c_str())
+                                                << endl;
+                                       cerr << _("Available target video codecs are:")
+                                                << endl;
+                                       display_target_video_codecs_help();
+
+                                       return SYNFIGTOOL_UNKNOWNARGUMENT;
+                               }
+                               else if (status == SYNFIGTOOL_MISSINGARGUMENT)
+                               {
+                                       cerr << _("Missing argument: \"-vb\".") << endl;
+
+                                       return SYNFIGTOOL_MISSINGARGUMENT;
+                               }
+                       }
 
                        // If the target type is STILL not yet defined, then
                        // set it to a some sort of default