-// Copyright 2005 Ben Hutchings <ben@decadentplace.org.uk>.
+// Copyright 2005-6 Ben Hutchings <ben@decadentplace.org.uk>.
// See the file "COPYING" for licence details.
#include <cassert>
#include "browser_widget.hpp"
#include "child_iterator.hpp"
#include "dvd.hpp"
+#include "generate_dvd.hpp"
#include "link_iterator.hpp"
+#include "null_prompt_service.hpp"
#include "pixbufs.hpp"
#include "style_sheets.hpp"
#include "temp_file.hpp"
#include "video.hpp"
#include "x_frame_buffer.hpp"
+#include "xml_utils.hpp"
#include "xpcom_support.hpp"
using xpcom_support::check;
namespace
{
+ // We can try using any of these encoders to convert PNG to MPEG.
+ enum mpeg_encoder
+ {
+ mpeg_encoder_ffmpeg, // ffmpeg
+ mpeg_encoder_mjpegtools_old, // mjpegtools before version 1.8
+ mpeg_encoder_mjpegtools_new // mjpegtools from version 1.8
+ };
+
struct rectangle
{
int left, top; // inclusive
return result;
}
- struct dvd_contents
- {
- enum pgc_type { menu_pgc, title_pgc };
- typedef std::pair<pgc_type, int> pgc_ref;
-
- struct menu
- {
- menu()
- : vob_temp(new temp_file("webdvd-vob-"))
- {
- vob_temp->close();
- }
-
- boost::shared_ptr<temp_file> vob_temp;
- std::vector<pgc_ref> entries;
- };
-
- struct title
- {
- explicit title(const std::string & vob_list)
- : vob_list(vob_list)
- {}
-
- std::string vob_list;
- };
-
- std::vector<menu> menus;
- std::vector<title> titles;
- };
class webdvd_window : public Gtk::Window
{
webdvd_window(
const video::frame_params & frame_params,
const std::string & main_page_uri,
- const std::string & output_dir);
+ const std::string & output_dir,
+ mpeg_encoder encoder);
+
+ bool is_finished() const;
private:
dvd_contents::pgc_ref add_menu(const std::string & uri);
dvd_contents::pgc_ref add_title(const std::string & uri);
void load_next_page();
void on_net_state_change(const char * uri, gint flags, guint status);
+ bool browser_is_busy() const
+ {
+ return pending_window_update_ || pending_req_count_;
+ }
bool process_page();
void save_screenshot();
void process_links(nsIPresShell * pres_shell,
nsIPresContext * pres_context,
nsIDOMWindow * dom_window);
- void generate_dvd();
video::frame_params frame_params_;
std::string output_dir_;
+ mpeg_encoder encoder_;
browser_widget browser_widget_;
nsCOMPtr<nsIStyleSheet> stylesheet_;
std::auto_ptr<temp_file> background_temp_;
struct page_state;
std::auto_ptr<page_state> page_state_;
+
+ bool finished_;
};
webdvd_window::webdvd_window(
const video::frame_params & frame_params,
const std::string & main_page_uri,
- const std::string & output_dir)
+ const std::string & output_dir,
+ mpeg_encoder encoder)
: frame_params_(frame_params),
output_dir_(output_dir),
+ encoder_(encoder),
stylesheet_(load_css("file://" WEBDVD_LIB_DIR "/webdvd.css")),
pending_window_update_(false),
pending_req_count_(0),
- have_tweaked_page_(false)
+ have_tweaked_page_(false),
+ finished_(false)
{
set_size_request(frame_params_.width, frame_params_.height);
set_resizable(false);
load_next_page();
}
+ bool webdvd_window::is_finished() const
+ {
+ return finished_;
+ }
+
dvd_contents::pgc_ref webdvd_window::add_menu(const std::string & uri)
{
dvd_contents::pgc_ref next_menu(dvd_contents::menu_pgc,
else
{
Glib::ustring hostname;
- std::string filename(Glib::filename_from_uri(uri, hostname));
+ std::string path(Glib::filename_from_uri(uri, hostname));
// FIXME: Should check the hostname
- std::string vob_list;
+ vob_list list;
// Store a reference to a linked VOB file, or the contents
// of a linked VOB list file.
- if (filename.compare(filename.size() - 4, 4, ".vob") == 0)
+ if (path.compare(path.size() - 4, 4, ".vob") == 0)
{
- if (!Glib::file_test(filename, Glib::FILE_TEST_IS_REGULAR))
+ if (!Glib::file_test(path, Glib::FILE_TEST_IS_REGULAR))
throw std::runtime_error(
- filename + " is missing or not a regular file");
- vob_list
- .append("<vob file='")
- // FIXME: Should XML-escape the path
- .append(filename)
- .append("'/>\n");
+ path + " is missing or not a regular file");
+ vob_ref ref;
+ ref.file = path;
+ list.push_back(ref);
}
else
{
- assert(filename.compare(filename.size() - 8, 8, ".voblist")
- == 0);
- // TODO: Validate the file contents
- vob_list.assign(Glib::file_get_contents(filename));
+ assert(path.compare(path.size() - 8, 8, ".voblist") == 0);
+ read_vob_list(path).swap(list);
}
- contents_.titles.push_back(dvd_contents::title(vob_list));
+ contents_.titles.resize(contents_.titles.size() + 1);
+ contents_.titles.back().swap(list);
return next_title;
}
}
pending_window_update_ = false;
}
- if (pending_req_count_ == 0 && !pending_window_update_)
+ if (!browser_is_busy())
{
try
{
if (!process_page())
+ {
+ finished_ = true;
Gtk::Main::quit();
+ }
}
catch (std::exception & e)
{
std::cerr << ": " << e.what() << "\n";
Gtk::Main::quit();
}
+ catch (Glib::Exception & e)
+ {
+ std::cerr << "Fatal error";
+ if (!page_queue_.empty())
+ std::cerr << " while processing <" << page_queue_.front()
+ << ">";
+ std::cerr << ": " << e.what() << "\n";
+ Gtk::Main::quit();
+ }
}
}
// Might need to wait a while for things to load or more
// likely for a re-layout.
- if (pending_req_count_ > 0)
+ if (browser_is_busy())
return true;
}
page_queue_.pop();
if (page_queue_.empty())
{
- generate_dvd();
+ generate_dvd(contents_, output_dir_);
return false;
}
else
temp_file links_temp;
- int link_num;
+ unsigned link_num;
link_iterator links_it, links_end;
rectangle link_rect;
0, 0, frame_params_.width, frame_params_.height
};
- int menu_num = resource_map_[page_queue_.front()].second;
+ unsigned menu_num = resource_map_[page_queue_.front()].index;
for (/* no initialisation */;
state->links_it != state->links_end;
{
nsCOMPtr<nsIDOMNode> node(*state->links_it);
- // Find the link URI.
+ // Find the link URI and separate any fragment from it.
nsCOMPtr<nsILink> link(do_QueryInterface(node));
assert(link);
- nsCOMPtr<nsIURI> uri;
- check(link->GetHrefURI(getter_AddRefs(uri)));
- std::string uri_string;
+ nsCOMPtr<nsIURI> uri_iface;
+ check(link->GetHrefURI(getter_AddRefs(uri_iface)));
+ std::string uri_and_fragment, uri, fragment;
{
- nsCString uri_ns_string;
- check(uri->GetSpec(uri_ns_string));
- uri_string.assign(uri_ns_string.BeginReading(),
- uri_ns_string.EndReading());
+ nsCString uri_and_fragment_ns;
+ check(uri_iface->GetSpec(uri_and_fragment_ns));
+ uri_and_fragment.assign(uri_and_fragment_ns.BeginReading(),
+ uri_and_fragment_ns.EndReading());
+
+ std::size_t hash_pos = uri_and_fragment.find('#');
+ uri.assign(uri_and_fragment, 0, hash_pos);
+ if (hash_pos != std::string::npos)
+ fragment.assign(uri_and_fragment,
+ hash_pos + 1, std::string::npos);
}
- std::string uri_sans_fragment(uri_string, 0, uri_string.find('#'));
// Is this a new link?
if (!state->link_changing)
if (state->link_rect.empty())
{
std::cerr << "Ignoring invisible link to "
- << uri_string << "\n";
+ << uri_and_fragment << "\n";
continue;
}
++state->link_num;
- if (state->link_num >= dvd::menu_buttons_max)
+ if (state->link_num >= unsigned(dvd::menu_buttons_max))
{
- if (state->link_num == dvd::menu_buttons_max)
+ if (state->link_num == unsigned(dvd::menu_buttons_max))
std::cerr << "No more than " << dvd::menu_buttons_max
<< " buttons can be placed on a menu\n";
- std::cerr << "Ignoring link to " << uri_string << "\n";
+ std::cerr << "Ignoring link to " << uri_and_fragment
+ << "\n";
continue;
}
// Check whether this is a link to a video or a page then
// add it to the known resources if not already seen; then
// add it to the menu entries.
- nsCString path;
- check(uri->GetPath(path));
- dvd_contents::pgc_ref dest_pgc;
+ dvd_contents::pgc_ref target;
// FIXME: This is a bit of a hack. Perhaps we could decide
// later based on the MIME type determined by Mozilla?
- if ((path.Length() > 4
- && std::strcmp(path.EndReading() - 4, ".vob") == 0)
- || (path.Length() > 8
- && std::strcmp(path.EndReading() - 8, ".voblist")
- == 0))
+ if ((uri.size() > 4
+ && uri.compare(uri.size() - 4, 4, ".vob") == 0)
+ || (uri.size() > 8
+ && uri.compare(uri.size() - 8, 8, ".voblist") == 0))
{
PRBool is_file;
- check(uri->SchemeIs("file", &is_file));
+ check(uri_iface->SchemeIs("file", &is_file));
if (!is_file)
{
std::cerr << "Links to video must use the file:"
<< " scheme\n";
continue;
}
- dest_pgc = add_title(uri_sans_fragment);
+ target = add_title(uri);
+ target.sub_index =
+ std::strtoul(fragment.c_str(), NULL, 10);
}
else
{
- dest_pgc = add_menu(uri_sans_fragment);
+ target = add_menu(uri);
+ // TODO: If there's a fragment, work out which button
+ // is closest and set target.sub_index.
}
- contents_.menus[menu_num].entries.push_back(dest_pgc);
+ contents_.menus[menu_num].entries.push_back(target);
nsCOMPtr<nsIContent> content(do_QueryInterface(node));
assert(content);
// We may have to exit and wait for image loading
// to complete, at which point we will be called
// again.
- if (pending_req_count_ > 0)
+ if (browser_is_busy())
{
state->link_changing = true;
page_state_ = state;
{
std::ostringstream command_stream;
- command_stream << "pngtopnm "
- << background_temp_->get_name()
- << " | ppmtoy4m -v0 -n1 -F"
- << frame_params_.rate_numer
- << ":" << frame_params_.rate_denom
- << " -A" << frame_params_.pixel_ratio_width
- << ":" << frame_params_.pixel_ratio_height
- << (" -Ip -S420_mpeg2"
- " | mpeg2enc -v0 -f8 -a2 -o/dev/stdout"
- " | mplex -v0 -f8 -o/dev/stdout /dev/stdin"
- " | spumux -v0 -mdvd ")
- << state->spumux_temp.get_name()
- << " > "
- << contents_.menus[menu_num].vob_temp->get_name();
- std::string command(command_stream.str());
- const char * argv[] = {
- "/bin/sh", "-c", command.c_str(), 0
- };
- std::cout << "running " << argv[2] << std::endl;
- int command_result;
- Glib::spawn_sync(".",
- Glib::ArrayHandle<std::string>(
- argv, sizeof(argv)/sizeof(argv[0]),
- Glib::OWNERSHIP_NONE),
- Glib::SPAWN_STDOUT_TO_DEV_NULL,
- SigC::Slot0<void>(),
- 0, 0,
- &command_result);
- if (command_result != 0)
- throw std::runtime_error("spumux pipeline failed");
- }
- }
-
- void generate_menu_dispatch(std::ostream &, int indent,
- int first_menu, int last_menu);
-
- void webdvd_window::generate_dvd()
- {
- temp_file temp("webdvd-dvdauthor-");
- temp.close();
- std::ofstream file(temp.get_name().c_str());
-
- // We generate code that uses registers in the following way:
- //
- // g0: button destination (when jumping to menu 1), then scratch
- // g1: current location
- // g2-g11: location history (g2 = most recent)
- // g12: location that last linked to a video
- //
- // All locations are divided into two bitfields: the least
- // significant 10 bits are a page/menu number and the most
- // significant 6 bits are a link/button number, and numbering
- // starts at 1, not 0. This is done for compatibility with
- // the encoding of the s8 (button) register.
- //
- static const int button_mult = dvd::reg_s8_button_mult;
- static const int menu_mask = button_mult - 1;
- static const int button_mask = (1 << dvd::reg_bits) - button_mult;
- static const int location_bias = button_mult + 1;
-
- file <<
- "<dvdauthor>\n"
- " <vmgm>\n"
- " <menus>\n";
-
- for (std::size_t menu_num = 0;
- menu_num != contents_.menus.size();
- ++menu_num)
- {
- dvd_contents::menu & menu = contents_.menus[menu_num];
-
- if (menu_num == 0)
+ if (encoder_ == mpeg_encoder_ffmpeg)
{
- // This is the first (title) menu, which needs to include
- // initialisation and dispatch code.
-
- file <<
- " <pgc entry='title'>\n"
- " <pre>\n"
- // Has the location been set yet?
- " if (g1 eq 0)\n"
- " {\n"
- // Initialise the current location to first button on
- // this menu.
- " g1 = " << location_bias << ";\n"
- " }\n"
- " else\n"
- " {\n"
- // Has the user selected a link?
- " if (g0 ne 0)\n"
- " {\n"
- // First update the history.
- // Does link go to the last page in the history?
- " if (((g0 ^ g2) & " << menu_mask
- << ") == 0)\n"
- // It does; we treat this as going back and pop the old
- // location off the history stack into the current
- // location. Clear the free stack slot.
- " {\n"
- " g1 = g2; g2 = g3; g3 = g4; g4 = g5;\n"
- " g5 = g6; g6 = g7; g7 = g8; g8 = g9;\n"
- " g9 = g10; g10 = g11; g11 = 0;\n"
- " }\n"
- " else\n"
- // Link goes to some other page, so push current
- // location onto the history stack and set the current
- // location to be exactly the target location.
- " {\n"
- " g11 = g10; g10 = g9; g9 = g8; g8 = g7;\n"
- " g7 = g6; g6 = g5; g5 = g4; g4 = g3;\n"
- " g3 = g2; g2 = g1; g1 = g0;\n"
- " }\n"
- " }\n"
- // Find the target page number.
- " g0 = g1 & " << menu_mask << ";\n";
- // There seems to be no way to perform a computed jump,
- // so we generate all possible jumps and a binary search
- // to select the correct one.
- generate_menu_dispatch(file, 12,
- 0, contents_.menus.size() - 1);
- file <<
- " }\n";
+ command_stream
+ << "ffmpeg"
+ << " -f image2 -vcodec png -i "
+ << background_temp_->get_name()
+ << " -target " << frame_params_.ffmpeg_name << "-dvd"
+ << " -vcodec mpeg2video -an -y /dev/stdout"
+ << " | spumux -v0 -mdvd " << state->spumux_temp.get_name()
+ << " > " << contents_.menus[menu_num].vob_temp->get_name();
}
- else // menu_num != 0
- {
- file <<
- " <pgc>\n"
- " <pre>\n";
- }
-
- file <<
- // Clear link indicator and highlight the
- // appropriate link/button.
- " g0 = 0; s8 = g1 & " << button_mask << ";\n"
- " </pre>\n"
- " <vob file='"
- << menu.vob_temp->get_name() << "'/>\n";
-
- for (std::size_t button_num = 0;
- button_num != menu.entries.size();
- ++button_num)
+ else
{
- file << " <button> "
- // Update current location.
- " g1 = "
- << location_bias + button_num * button_mult + menu_num
- << ";";
-
- // Jump to appropriate resource.
- if (menu.entries[button_num].first == dvd_contents::menu_pgc)
- {
- file << " g0 = "
- << location_bias + menu.entries[button_num].second
- << "; jump menu 1;";
- }
+ assert(encoder_ == mpeg_encoder_mjpegtools_old
+ || encoder_ == mpeg_encoder_mjpegtools_new);
+ command_stream
+ << "pngtopnm "
+ << background_temp_->get_name()
+ << " | ppmtoy4m -v0 -n1 -F"
+ << frame_params_.rate_numer
+ << ":" << frame_params_.rate_denom
+ << " -A" << frame_params_.pixel_ratio_width
+ << ":" << frame_params_.pixel_ratio_height
+ << " -Ip ";
+ // The chroma subsampling keywords changed between
+ // versions 1.6.2 and 1.8 of mjpegtools. There is no
+ // keyword that works with both.
+ if (encoder_ == mpeg_encoder_mjpegtools_old)
+ command_stream << "-S420_mpeg2";
else
- {
- assert(menu.entries[button_num].first
- == dvd_contents::title_pgc);
- file << " jump title "
- << 1 + menu.entries[button_num].second << ";";
- }
-
- file << " </button>\n";
+ command_stream << "-S420mpeg2";
+ command_stream
+ << (" | mpeg2enc -v0 -f8 -a2 -o/dev/stdout"
+ " | mplex -v0 -f8 -o/dev/stdout /dev/stdin"
+ " | spumux -v0 -mdvd ")
+ << state->spumux_temp.get_name()
+ << " > "
+ << contents_.menus[menu_num].vob_temp->get_name();
}
-
- file << " </pgc>\n";
- }
-
- file <<
- " </menus>\n"
- " </vmgm>\n";
-
- // Generate a titleset for each title. This appears to make
- // jumping to titles a whole lot simpler (but limits us to 99
- // titles).
- for (std::size_t title_num = 0;
- title_num != contents_.titles.size();
- ++title_num)
- {
- file <<
- " <titleset>\n"
- // Generate a dummy menu so that the menu button on the
- // remote control will work.
- " <menus>\n"
- " <pgc entry='root'>\n"
- " <pre> jump vmgm menu; </pre>\n"
- " </pgc>\n"
- " </menus>\n"
- " <titles>\n"
- " <pgc>\n"
- // Record calling page/menu.
- " <pre> g12 = g1; </pre>\n"
- << contents_.titles[title_num].vob_list <<
- // If page/menu location has not been changed during the
- // video, change the location to be the following
- // link/button when returning to it. In any case,
- // return to a page/menu.
- " <post> if (g1 eq g12) g1 = g1 + " << button_mult
- << "; call menu; </post>\n"
- " </pgc>\n"
- " </titles>\n"
- " </titleset>\n";
- }
-
- file <<
- "</dvdauthor>\n";
-
- file.close();
-
- {
+ std::string command(command_stream.str());
const char * argv[] = {
- "dvdauthor",
- "-o", output_dir_.c_str(),
- "-x", temp.get_name().c_str(),
- 0
+ "/bin/sh", "-c", command.c_str(), 0
};
+ std::cout << "running " << argv[2] << std::endl;
int command_result;
Glib::spawn_sync(".",
Glib::ArrayHandle<std::string>(
argv, sizeof(argv)/sizeof(argv[0]),
Glib::OWNERSHIP_NONE),
- Glib::SPAWN_SEARCH_PATH
- | Glib::SPAWN_STDOUT_TO_DEV_NULL,
+ Glib::SPAWN_STDOUT_TO_DEV_NULL,
SigC::Slot0<void>(),
0, 0,
&command_result);
if (command_result != 0)
- throw std::runtime_error("dvdauthor failed");
- }
- }
-
- void generate_menu_dispatch(std::ostream & file, int indent,
- int first_menu, int last_menu)
- {
- if (first_menu == last_menu)
- {
- if (first_menu == 0)
- {
- // This dispatch code is generated *on* the first menu
- // so don't create an infinite loop.
- }
- else
- {
- file << std::setw(indent) << ""
- << "jump menu " << 1 + first_menu << ";\n";
- }
- }
- else // first_menu != last_menu
- {
- if (first_menu == 0 && last_menu == 1)
- {
- // dvdauthor doesn't allow empty blocks or null
- // statements so when selecting between the first 2
- // menus we don't use an "else" part. We must use
- // braces so that a following "else" will match the
- // right "if".
- file << std::setw(indent) << "" << "{\n"
- << std::setw(indent) << "" << "if (g0 eq 2)\n"
- << std::setw(indent + 2) << "" << "jump menu 2;\n"
- << std::setw(indent) << "" << "}\n";
- }
- else
- {
- int middle = (first_menu + last_menu) / 2;
- file << std::setw(indent) << "" << "if (g0 le " << 1 + middle
- << ")\n";
- generate_menu_dispatch(file, indent + 2,
- first_menu, middle);
- file << std::setw(indent) << "" << "else\n";
- generate_menu_dispatch(file, indent + 2,
- middle + 1, last_menu);
- }
+ throw std::runtime_error("spumux pipeline failed");
}
}
const video::frame_params & lookup_frame_params(const char * str)
{
assert(str);
- static const struct { const char * str; bool is_ntsc; }
- known_strings[] = {
- { "NTSC", true },
- { "ntsc", true },
- { "PAL", false },
- { "pal", false },
- // For DVD purposes, SECAM can be treated identically to PAL.
- { "SECAM", false },
- { "secam", false }
+ static const char * const known_strings[] = {
+ "525", "625",
+ "525/60", "625/50",
+ "NTSC", "PAL",
+ "ntsc", "pal"
};
for (std::size_t i = 0;
i != sizeof(known_strings)/sizeof(known_strings[0]);
++i)
- if (std::strcmp(str, known_strings[i].str) == 0)
- return known_strings[i].is_ntsc ?
- video::ntsc_params : video::pal_params;
+ if (std::strcmp(str, known_strings[i]) == 0)
+ return (i & 1)
+ ? video::frame_params_625
+ : video::frame_params_525;
throw std::runtime_error(
std::string("Invalid video standard: ").append(str));
}
void print_usage(std::ostream & stream, const char * command_name)
{
- stream << "Usage: " << command_name
- << (" [gtk-options] [--video-std std-name]"
- " [--preview] menu-url [output-dir]\n");
+ stream <<
+ "Usage: " << command_name << " [gtk-options] [--preview]\n"
+ " [--video-std {525|525/60|NTSC|ntsc"
+ " | 625|625/50|PAL|pal}]\n"
+ " [--encoder {mjpegtools|mjpegtools-old}]\n"
+ " menu-url [output-dir]\n";
}
void set_browser_preferences()
{
- // Disable IE-compatibility kluge that causes backgrounds to
- // sometimes/usually be missing from snapshots. This is only
- // effective from Mozilla 1.8 onward.
-# if MOZ_VERSION_MAJOR > 1 \
- || (MOZ_VERSION_MAJOR == 1 && MOZ_VERSION_MINOR >= 8)
nsCOMPtr<nsIPrefService> pref_service;
static const nsCID pref_service_cid = NS_PREFSERVICE_CID;
check(CallGetService<nsIPrefService>(pref_service_cid,
getter_AddRefs(pref_service)));
nsCOMPtr<nsIPrefBranch> pref_branch;
+
+ // Disable IE-compatibility kluge that causes backgrounds to
+ // sometimes/usually be missing from snapshots. This is only
+ // effective from Mozilla 1.8 onward.
+# if MOZ_VERSION_MAJOR > 1 \
+ || (MOZ_VERSION_MAJOR == 1 && MOZ_VERSION_MINOR >= 8)
check(pref_service->GetDefaultBranch("layout",
getter_AddRefs(pref_branch)));
check(pref_branch->SetBoolPref(
true));
# endif
- // TODO: Set display resolution? Unfortunately Mozilla doesn't
- // support non-square pixels (and neither do fontconfig or Xft
- // anyway).
+ // Set display resolution. With standard-definition video we
+ // will be fitting ~600 pixels across a screen typically
+ // ranging from 10 to 25 inches wide, for a resolution of
+ // 24-60 dpi. I therefore declare the average horizontal
+ // resolution to be 40 dpi. The vertical resolution will be
+ // slightly higher (PAL/SECAM) or lower (NTSC), but
+ // unfortunately Mozilla doesn't support non-square pixels
+ // (and neither do fontconfig or Xft anyway).
+ check(pref_service->GetDefaultBranch("browser.display",
+ getter_AddRefs(pref_branch)));
+ check(pref_branch->SetIntPref("screen_resolution", 40));
}
} // namespace
+void fatal_error(const std::string & message)
+{
+ std::cerr << "Fatal error: " << message << "\n";
+ Gtk::Main::quit();
+}
+
int main(int argc, char ** argv)
{
try
{
- video::frame_params frame_params = video::pal_params;
+ video::frame_params frame_params = video::frame_params_625;
bool preview_mode = false;
std::string menu_url;
std::string output_dir;
+ mpeg_encoder encoder = mpeg_encoder_ffmpeg;
// Do initial option parsing. We have to do this before
// letting Gtk parse the arguments since we may need to spawn
{
argi += 2;
}
+ else if (std::strcmp(argv[argi], "--save-temps") == 0)
+ {
+ temp_file::keep_all(true);
+ argi += 1;
+ }
+ else if (std::strcmp(argv[argi], "--encoder") == 0)
+ {
+ if (argi + 1 == argc)
+ {
+ std::cerr << "Missing argument to --encoder\n";
+ print_usage(std::cerr, argv[0]);
+ return EXIT_FAILURE;
+ }
+ if (std::strcmp(argv[argi + 1], "ffmpeg") == 0)
+ {
+ encoder = mpeg_encoder_ffmpeg;
+ }
+ else if (std::strcmp(argv[argi + 1], "mjpegtools-old") == 0)
+ {
+ encoder = mpeg_encoder_mjpegtools_old;
+ }
+ else if (std::strcmp(argv[argi + 1], "mjpegtools") == 0
+ || std::strcmp(argv[argi + 1], "mjpegtools-new") == 0)
+ {
+ encoder = mpeg_encoder_mjpegtools_new;
+ }
+ else
+ {
+ std::cerr << "Invalid argument to --encoder\n";
+ print_usage(std::cerr, argv[0]);
+ return EXIT_FAILURE;
+ }
+ argi += 2;
+ }
else if (argv[argi][0] == '-')
{
std::cerr << "Invalid option: " << argv[argi] << "\n";
// Initialise Mozilla
browser_widget::initialiser browser_init;
set_browser_preferences();
+ if (!preview_mode)
+ null_prompt_service::install();
// Run the browser/converter
- webdvd_window window(frame_params, menu_url, output_dir);
+ webdvd_window window(frame_params, menu_url, output_dir, encoder);
Gtk::Main::run(window);
+
+ return ((preview_mode || window.is_finished())
+ ? EXIT_SUCCESS
+ : EXIT_FAILURE);
}
catch (std::exception & e)
{
std::cerr << "Fatal error: " << e.what() << "\n";
return EXIT_FAILURE;
}
-
- return EXIT_SUCCESS;
}
projects / videolink.git / blobdiff