X-Git-Url: https://git.decadent.org.uk/gitweb/?p=videolink.git;a=blobdiff_plain;f=webdvd.cpp;h=e80996874157ce339063dd7a5fd5ab30b42aaa4f;hp=58c849a7b69e09e77e56b06208513d5e9743ff98;hb=a80fac0c4fed899cd5f7503cf4080c30f611e341;hpb=1910b3ace0ccd527d3ee76b7c6050943dc75f4d1 diff --git a/webdvd.cpp b/webdvd.cpp index 58c849a..e809968 100644 --- a/webdvd.cpp +++ b/webdvd.cpp @@ -2,6 +2,7 @@ // See the file "COPYING" for licence details. #include +#include #include #include #include @@ -13,7 +14,6 @@ #include #include -#include #include @@ -29,6 +29,7 @@ #include #include #include +#include #include #include #include @@ -41,20 +42,23 @@ #include #include // required before nsILink.h #include +#include +#include #include #include +#include #include #include -#include "browserwidget.hpp" -#include "childiterator.hpp" +#include "browser_widget.hpp" +#include "child_iterator.hpp" #include "dvd.hpp" -#include "framebuffer.hpp" -#include "linkiterator.hpp" +#include "link_iterator.hpp" #include "pixbufs.hpp" -#include "stylesheets.hpp" +#include "style_sheets.hpp" #include "temp_file.hpp" #include "video.hpp" +#include "x_frame_buffer.hpp" #include "xpcom_support.hpp" using xpcom_support::check; @@ -122,7 +126,7 @@ namespace result.bottom = result.top + height; // Merge bounding boxes of all child elements - for (ChildIterator it = ChildIterator(elem), end; it != end; ++it) + for (child_iterator it = child_iterator(elem), end; it != end; ++it) { nsCOMPtr child_node(*it); PRUint16 child_type; @@ -138,45 +142,111 @@ namespace return result; } - class WebDvdWindow : public Gtk::Window + + std::string xml_escape(const std::string & str) + { + std::string result; + std::size_t begin = 0; + + for (;;) + { + std::size_t end = str.find_first_of("\"&'<>", begin); + result.append(str, begin, end - begin); + if (end == std::string::npos) + return result; + + const char * entity = NULL; + switch (str[end]) + { + case '"': entity = """; break; + case '&': entity = "&"; break; + case '\'': entity = "'"; break; + case '<': entity = "<"; break; + case '>': entity = ">"; break; + } + assert(entity); + result.append(entity); + + begin = end + 1; + } + } + + + struct dvd_contents + { + enum pgc_type { menu_pgc, title_pgc }; + typedef std::pair pgc_ref; + + struct menu + { + menu() + : vob_temp(new temp_file("webdvd-vob-")) + { + vob_temp->close(); + } + + boost::shared_ptr vob_temp; + std::vector entries; + }; + + struct title + { + explicit title(const std::string & vob_list) + : vob_list(vob_list) + {} + + std::string vob_list; + }; + + std::vector menus; + std::vector titles; + }; + + void generate_dvd(const dvd_contents & contents, + const std::string & output_dir); + + class webdvd_window : public Gtk::Window { public: - WebDvdWindow( + webdvd_window( const video::frame_params & frame_params, const std::string & main_page_uri, const std::string & output_dir); private: - void add_page(const std::string & uri); - void add_video(const std::string & uri); + 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(); - enum ResourceType { page_resource, video_resource }; - typedef std::pair<ResourceType, int> ResourceEntry; video::frame_params frame_params_; std::string output_dir_; - BrowserWidget browser_widget_; + browser_widget browser_widget_; nsCOMPtr<nsIStyleSheet> stylesheet_; + + dvd_contents contents_; + typedef std::map<std::string, dvd_contents::pgc_ref> resource_map_type; + resource_map_type resource_map_; + std::queue<std::string> page_queue_; - std::map<std::string, ResourceEntry> resource_map_; - std::vector<std::vector<std::string> > page_links_; - std::vector<std::string> video_paths_; bool pending_window_update_; int pending_req_count_; + bool have_tweaked_page_; std::auto_ptr<temp_file> background_temp_; struct page_state; std::auto_ptr<page_state> page_state_; - std::vector<boost::shared_ptr<temp_file> > page_temp_files_; }; - WebDvdWindow::WebDvdWindow( + webdvd_window::webdvd_window( const video::frame_params & frame_params, const std::string & main_page_uri, const std::string & output_dir) @@ -184,7 +254,8 @@ namespace output_dir_(output_dir), stylesheet_(load_css("file://" WEBDVD_LIB_DIR "/webdvd.css")), pending_window_update_(false), - pending_req_count_(0) + pending_req_count_(0), + have_tweaked_page_(false) { set_size_request(frame_params_.width, frame_params_.height); set_resizable(false); @@ -192,54 +263,126 @@ namespace add(browser_widget_); browser_widget_.show(); browser_widget_.signal_net_state().connect( - SigC::slot(*this, &WebDvdWindow::on_net_state_change)); + SigC::slot(*this, &webdvd_window::on_net_state_change)); - add_page(main_page_uri); + add_menu(main_page_uri); load_next_page(); } - void WebDvdWindow::add_page(const std::string & uri) + dvd_contents::pgc_ref webdvd_window::add_menu(const std::string & uri) { - if (resource_map_.insert( - std::make_pair(uri, ResourceEntry(page_resource, 0))) - .second) + dvd_contents::pgc_ref next_menu(dvd_contents::menu_pgc, + contents_.menus.size()); + std::pair<resource_map_type::iterator, bool> insert_result( + resource_map_.insert(std::make_pair(uri, next_menu))); + + if (!insert_result.second) + { + return insert_result.first->second; + } + else { page_queue_.push(uri); + contents_.menus.resize(contents_.menus.size() + 1); + return next_menu; } } - void WebDvdWindow::add_video(const std::string & uri) + dvd_contents::pgc_ref webdvd_window::add_title(const std::string & uri) { - if (resource_map_.insert( - std::make_pair(uri, ResourceEntry(video_resource, - video_paths_.size() + 1))) - .second) + dvd_contents::pgc_ref next_title(dvd_contents::title_pgc, + contents_.titles.size()); + std::pair<resource_map_type::iterator, bool> insert_result( + resource_map_.insert(std::make_pair(uri, next_title))); + + if (!insert_result.second) { - // FIXME: Should accept some slightly different URI prefixes - // (e.g. file://localhost/) and decode any URI-escaped - // characters in the path. - assert(uri.compare(0, 8, "file:///") == 0); - video_paths_.push_back(uri.substr(7)); + return insert_result.first->second; + } + else + { + Glib::ustring hostname; + std::string filename(Glib::filename_from_uri(uri, hostname)); + // FIXME: Should check the hostname + + std::string vob_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 (!Glib::file_test(filename, Glib::FILE_TEST_IS_REGULAR)) + throw std::runtime_error( + filename + " is missing or not a regular file"); + vob_list + .append("<vob file='") + .append(xml_escape(filename)) + .append("'/>\n"); + } + else + { + assert(filename.compare(filename.size() - 8, 8, ".voblist") + == 0); + // TODO: Validate the file contents + vob_list.assign(Glib::file_get_contents(filename)); + } + + contents_.titles.push_back(dvd_contents::title(vob_list)); + return next_title; } } - void WebDvdWindow::load_next_page() + void webdvd_window::load_next_page() { assert(!page_queue_.empty()); const std::string & uri = page_queue_.front(); std::cout << "loading " << uri << std::endl; - std::size_t page_count = page_links_.size(); - resource_map_[uri].second = ++page_count; - page_links_.resize(page_count); - - pending_window_update_ = true; browser_widget_.load_uri(uri); } - void WebDvdWindow::on_net_state_change(const char * uri, + void webdvd_window::on_net_state_change(const char * uri, gint flags, guint status) { +# ifdef DEBUG_ON_NET_STATE_CHANGE + std::cout << "webdvd_window::on_net_state_change("; + if (uri) + std::cout << '"' << uri << '"'; + else + std::cout << "NULL"; + std::cout << ", "; + { + gint flags_left = flags; + static const struct { + gint value; + const char * name; + } flag_names[] = { + { GTK_MOZ_EMBED_FLAG_START, "STATE_START" }, + { GTK_MOZ_EMBED_FLAG_REDIRECTING, "STATE_REDIRECTING" }, + { GTK_MOZ_EMBED_FLAG_TRANSFERRING, "STATE_TRANSFERRING" }, + { GTK_MOZ_EMBED_FLAG_NEGOTIATING, "STATE_NEGOTIATING" }, + { GTK_MOZ_EMBED_FLAG_STOP, "STATE_STOP" }, + { GTK_MOZ_EMBED_FLAG_IS_REQUEST, "STATE_IS_REQUEST" }, + { GTK_MOZ_EMBED_FLAG_IS_DOCUMENT, "STATE_IS_DOCUMENT" }, + { GTK_MOZ_EMBED_FLAG_IS_NETWORK, "STATE_IS_NETWORK" }, + { GTK_MOZ_EMBED_FLAG_IS_WINDOW, "STATE_IS_WINDOW" } + }; + for (int i = 0; i != sizeof(flag_names)/sizeof(flag_names[0]); ++i) + { + if (flags & flag_names[i].value) + { + std::cout << flag_names[i].name; + flags_left -= flag_names[i].value; + if (flags_left) + std::cout << " | "; + } + } + if (flags_left) + std::cout << "0x" << std::setbase(16) << flags_left; + } + std::cout << ", " << "0x" << std::setbase(16) << status << ")\n"; +# endif // DEBUG_ON_NET_STATE_CHANGE + if (flags & GTK_MOZ_EMBED_FLAG_IS_REQUEST) { if (flags & GTK_MOZ_EMBED_FLAG_START) @@ -252,8 +395,15 @@ namespace } } - if (flags & GTK_MOZ_EMBED_FLAG_STOP - && flags & GTK_MOZ_EMBED_FLAG_IS_WINDOW) + if (flags & GTK_MOZ_EMBED_FLAG_IS_DOCUMENT + && flags & GTK_MOZ_EMBED_FLAG_START) + { + pending_window_update_ = true; + have_tweaked_page_ = false; + } + + if (flags & GTK_MOZ_EMBED_FLAG_IS_WINDOW + && flags & GTK_MOZ_EMBED_FLAG_STOP) { // Check whether the load was successful, ignoring this // pseudo-error. @@ -263,7 +413,7 @@ namespace pending_window_update_ = false; } - if (pending_req_count_ == 0 && !pending_window_update_) + if (!browser_is_busy()) { try { @@ -282,7 +432,7 @@ namespace } } - bool WebDvdWindow::process_page() + bool webdvd_window::process_page() { assert(!page_queue_.empty()); @@ -296,22 +446,32 @@ namespace nsCOMPtr<nsIDOMWindow> dom_window; check(browser->GetContentDOMWindow(getter_AddRefs(dom_window))); - if (output_dir_.empty()) + // If we haven't done so already, apply the stylesheet and + // disable scrollbars. + if (!have_tweaked_page_) { - // In preview mode, just apply the stylesheet and let the - // user select links. apply_style_sheet(stylesheet_, pres_shell); + + // This actually only needs to be done once. + nsCOMPtr<nsIDOMBarProp> dom_bar_prop; + check(dom_window->GetScrollbars(getter_AddRefs(dom_bar_prop))); + check(dom_bar_prop->SetVisible(false)); + + have_tweaked_page_ = true; + + // Might need to wait a while for things to load or more + // likely for a re-layout. + if (browser_is_busy()) + return true; } - else + + // All further work should only be done if we're not in preview mode. + if (!output_dir_.empty()) { - // If we haven't already started work on this page, apply - // the stylesheet and save a screenshot of its normal - // appearance. + // If we haven't already started work on this menu, save a + // screenshot of its normal appearance. if (!page_state_.get()) - { - apply_style_sheet(stylesheet_, pres_shell); save_screenshot(); - } // Start or continue processing links. process_links(pres_shell, pres_context, dom_window); @@ -323,7 +483,7 @@ namespace page_queue_.pop(); if (page_queue_.empty()) { - generate_dvd(); + generate_dvd(contents_, output_dir_); return false; } else @@ -336,7 +496,7 @@ namespace return true; } - void WebDvdWindow::save_screenshot() + void webdvd_window::save_screenshot() { Glib::RefPtr<Gdk::Window> window(get_window()); assert(window); @@ -352,7 +512,7 @@ namespace ->save(background_temp_->get_name(), "png"); } - struct WebDvdWindow::page_state + struct webdvd_window::page_state { page_state(nsIDOMDocument * doc, int width, int height) : diff_pixbuf(Gdk::Pixbuf::create( @@ -377,14 +537,14 @@ namespace temp_file links_temp; int link_num; - LinkIterator links_it, links_end; + link_iterator links_it, links_end; rectangle link_rect; bool link_changing; Glib::RefPtr<Gdk::Pixbuf> norm_pixbuf; }; - void WebDvdWindow::process_links(nsIPresShell * pres_shell, + void webdvd_window::process_links(nsIPresShell * pres_shell, nsIPresContext * pres_context, nsIDOMWindow * dom_window) { @@ -427,6 +587,8 @@ namespace 0, 0, frame_params_.width, frame_params_.height }; + int menu_num = resource_map_[page_queue_.front()].second; + for (/* no initialisation */; state->links_it != state->links_end; ++state->links_it) @@ -470,19 +632,30 @@ namespace { if (state->link_num == dvd::menu_buttons_max) std::cerr << "No more than " << dvd::menu_buttons_max - << " buttons can be placed on a page\n"; + << " buttons can be placed on a menu\n"; std::cerr << "Ignoring link to " << uri_string << "\n"; continue; } + state->spumux_file << + " <button x0='" << state->link_rect.left << "'" + " y0='" << state->link_rect.top << "'" + " x1='" << state->link_rect.right - 1 << "'" + " y1='" << state->link_rect.bottom - 1 << "'/>\n"; + // Check whether this is a link to a video or a page then - // add it to the known resources if not already seen. + // 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; // 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) + if ((path.Length() > 4 + && std::strcmp(path.EndReading() - 4, ".vob") == 0) + || (path.Length() > 8 + && std::strcmp(path.EndReading() - 8, ".voblist") + == 0)) { PRBool is_file; check(uri->SchemeIs("file", &is_file)); @@ -492,12 +665,13 @@ namespace << " scheme\n"; continue; } - add_video(uri_sans_fragment); + dest_pgc = add_title(uri_sans_fragment); } else { - add_page(uri_sans_fragment); + dest_pgc = add_menu(uri_sans_fragment); } + contents_.menus[menu_num].entries.push_back(dest_pgc); nsCOMPtr<nsIContent> content(do_QueryInterface(node)); assert(content); @@ -546,7 +720,7 @@ namespace // 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; @@ -574,15 +748,6 @@ namespace state->link_rect.top, state->link_rect.right - state->link_rect.left, state->link_rect.bottom - state->link_rect.top); - - state->spumux_file << - " <button x0='" << state->link_rect.left << "'" - " y0='" << state->link_rect.top << "'" - " x1='" << state->link_rect.right - 1 << "'" - " y1='" << state->link_rect.bottom - 1 << "'/>\n"; - - // Add to the page's links, ignoring any fragment (for now). - page_links_.back().push_back(uri_sans_fragment); } quantise_rgba_pixbuf(state->diff_pixbuf, dvd::button_n_colours); @@ -601,8 +766,6 @@ namespace // TODO: if (!state->spumux_file) throw ... { - boost::shared_ptr<temp_file> vob_temp( - new temp_file("webdvd-vob-")); std::ostringstream command_stream; command_stream << "pngtopnm " << background_temp_->get_name() @@ -616,7 +779,8 @@ namespace " | mplex -v0 -f8 -o/dev/stdout /dev/stdin" " | spumux -v0 -mdvd ") << state->spumux_temp.get_name() - << " > " << vob_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 @@ -633,15 +797,11 @@ namespace &command_result); if (command_result != 0) throw std::runtime_error("spumux pipeline failed"); - - page_temp_files_.push_back(vob_temp); } } - void generate_page_dispatch(std::ostream &, int indent, - int first_page, int last_page); - - void WebDvdWindow::generate_dvd() + void generate_dvd(const dvd_contents & contents, + const std::string & output_dir) { temp_file temp("webdvd-dvdauthor-"); temp.close(); @@ -649,117 +809,131 @@ namespace // We generate code that uses registers in the following way: // - // g0: link destination (when jumping to menu 1), then scratch + // g0: scratch // g1: current location - // g2-g11: location history (g2 = most recent) - // g12: location that last linked to a video + // g12: location that last jumped 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. This is - // chosen for compatibility with the encoding of the s8 - // (button) register. + // 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 link_mult = dvd::reg_s8_button_mult; - static const int page_mask = link_mult - 1; - static const int link_mask = (1 << dvd::reg_bits) - link_mult; + 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; file << "<dvdauthor>\n" " <vmgm>\n" " <menus>\n"; - for (std::size_t page_num = 1; - page_num <= page_links_.size(); - ++page_num) + for (std::size_t menu_num = 0; + menu_num != contents.menus.size(); + ++menu_num) { - std::vector<std::string> & page_links = - page_links_[page_num - 1]; + const dvd_contents::menu & menu = contents.menus[menu_num]; - if (page_num == 1) + if (menu_num == 0) { - // This is the first page (root menu) which needs to - // include initialisation and dispatch code. - + // This is the first (title) menu, displayed when the + // disc is first played. file << " <pgc entry='title'>\n" " <pre>\n" - // Has the location been set yet? + // Initialise the current location if it is not set + // (all general registers are initially 0). " if (g1 eq 0)\n" - " {\n" - // Initialise the current location to first link on - // this page. - " g1 = " << 1 * link_mult + 1 << ";\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) & " << page_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 & " << page_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_page_dispatch(file, 12, 1, page_links_.size()); - file << - " }\n"; + " g1 = " << 1 + button_mult << ";\n"; } - else // page_num != 1 + else { file << " <pgc>\n" " <pre>\n"; } + // When a title finishes or the user presses the menu + // button, this always jumps to the titleset's root menu. + // We want to return the user to the last menu they used. + // So we arrange for each titleset's root menu to return + // to the vmgm title menu and then dispatch from there to + // whatever the correct menu is. We determine the correct + // menu by looking at the menu part of g1. + + file << " g0 = g1 & " << menu_mask << ";\n"; + + // There is a limit of 128 VM instructions in each PGC. + // Therefore in each menu's <pre> section we generate + // jumps to menus with numbers greater by 512, 256, 128, + // ..., 1 where (a) such a menu exists, (b) this menu + // number is divisible by twice that increment and (c) the + // correct menu is that or a later menu. Thus each menu + // has at most 10 such conditional jumps and is reachable + // by at most 10 jumps from the title menu. This chain of + // jumps might take too long on some players; this has yet + // to be investigated. + + for (std::size_t menu_incr = (menu_mask + 1) / 2; + menu_incr != 0; + menu_incr /= 2) + { + if (menu_num + menu_incr < contents.menus.size() + && (menu_num & (menu_incr * 2 - 1)) == 0) + { + file << + " if (g0 ge " << 1 + menu_num + menu_incr + << ")\n" + " jump menu " << 1 + menu_num + menu_incr + << ";\n"; + } + } + file << - // Clear link indicator and highlight the - // appropriate link/button. - " g0 = 0; s8 = g1 & " << link_mask << ";\n" + // Highlight the appropriate button. + " s8 = g1 & " << button_mask << ";\n" " </pre>\n" - " <vob file='" - << page_temp_files_[page_num - 1]->get_name() << "'/>\n"; + " <vob file='" << menu.vob_temp->get_name() << "'/>\n"; - for (std::size_t link_num = 1; - link_num <= page_links.size(); - ++link_num) + for (std::size_t button_num = 0; + button_num != menu.entries.size(); + ++button_num) { - file << - " <button>" - // Update current location. - " g1 = " << link_num * link_mult + page_num << ";"; - - // Jump to appropriate resource. - const ResourceEntry & resource_loc = - resource_map_[page_links[link_num - 1]]; - if (resource_loc.first == page_resource) - file << - " g0 = " << 1 * link_mult + resource_loc.second << ";" - " jump menu 1;"; - else if (resource_loc.first == video_resource) - file << " jump title " << resource_loc.second << ";"; + file << " <button> "; + + if (menu.entries[button_num].first == dvd_contents::menu_pgc) + { + int dest_menu_num = menu.entries[button_num].second; + + // Look for a button on the new menu that links + // back to this one. If there is one, set that to + // be the highlighted button; otherwise, use the + // first button. + const std::vector<dvd_contents::pgc_ref> & + dest_menu_entries = + contents.menus[dest_menu_num].entries; + dvd_contents::pgc_ref this_pgc( + dvd_contents::menu_pgc, menu_num); + std::size_t dest_button_num = dest_menu_entries.size(); + while (dest_button_num != 0 + && dest_menu_entries[--dest_button_num] != this_pgc) + ; + + file << "g1 = " + << (1 + dest_menu_num + + (1 + dest_button_num) * button_mult) + << "; jump menu " << 1 + dest_menu_num << ";"; + } + else + { + assert(menu.entries[button_num].first + == dvd_contents::title_pgc); + + file << "g1 = " + << 1 + menu_num + (1 + button_num) * button_mult + << "; jump title " + << 1 + menu.entries[button_num].second << ";"; + } file << " </button>\n"; } @@ -771,11 +945,12 @@ namespace " </menus>\n" " </vmgm>\n"; - // Generate a titleset for each video. This appears to make - // jumping to titles a whole lot simpler. - for (std::size_t video_num = 1; - video_num <= video_paths_.size(); - ++video_num) + // 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" @@ -788,16 +963,14 @@ namespace " </menus>\n" " <titles>\n" " <pgc>\n" - // Record calling page/menu. + // Record calling location. " <pre> g12 = g1; </pre>\n" - // FIXME: Should XML-escape the path - " <vob file='" << video_paths_[video_num - 1] - << "'/>\n" - // 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 + " << link_mult + << contents.titles[title_num].vob_list << + // If the menu location has not been changed during + // the title, set the location to be the following + // button in the menu. In any case, return to some + // menu. + " <post> if (g1 eq g12) g1 = g1 + " << button_mult << "; call menu; </post>\n" " </pgc>\n" " </titles>\n" @@ -812,7 +985,7 @@ namespace { const char * argv[] = { "dvdauthor", - "-o", output_dir_.c_str(), + "-o", output_dir.c_str(), "-x", temp.get_name().c_str(), 0 }; @@ -831,42 +1004,6 @@ namespace } } - void generate_page_dispatch(std::ostream & file, int indent, - int first_page, int last_page) - { - if (first_page == 1 && last_page == 1) - { - // The dispatch code is *on* page 1 so we must not dispatch to - // page 1 since that would cause an infinite loop. This case - // should be unreachable if there is more than one page due - // to the following case. - } - else if (first_page == 1 && last_page == 2) - { - // dvdauthor doesn't allow empty blocks or null statements so - // when selecting between pages 1 and 2 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 if (first_page == last_page) - { - file << std::setw(indent) << "" - << "jump menu " << first_page << ";\n"; - } - else - { - int middle = (first_page + last_page) / 2; - file << std::setw(indent) << "" << "if (g0 le " << middle << ")\n"; - generate_page_dispatch(file, indent + 2, first_page, middle); - file << std::setw(indent) << "" << "else\n"; - generate_page_dispatch(file, indent + 2, middle + 1, last_page); - } - } - const video::frame_params & lookup_frame_params(const char * str) { assert(str); @@ -897,6 +1034,39 @@ namespace " [--preview] menu-url [output-dir]\n"); } + void set_browser_preferences() + { + 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( + "fire_onload_after_image_background_loads", + true)); +# endif + + // 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 int main(int argc, char ** argv) @@ -905,8 +1075,10 @@ int main(int argc, char ** argv) { video::frame_params frame_params = video::pal_params; bool preview_mode = false; + std::string menu_url; + std::string output_dir; - // Do initial argument parsing. We have to do this before + // Do initial option parsing. We have to do this before // letting Gtk parse the arguments since we may need to spawn // Xvfb first. int argi = 1; @@ -943,22 +1115,23 @@ int main(int argc, char ** argv) } } - std::auto_ptr<FrameBuffer> fb; + std::auto_ptr<x_frame_buffer> fb; if (!preview_mode) { // Spawn Xvfb and set env variables so that Xlib will use it // Use 8 bits each for RGB components, which should translate into // "enough" bits for YUV components. - fb.reset(new FrameBuffer(frame_params.width, frame_params.height, - 3 * 8)); - setenv("XAUTHORITY", fb->get_x_authority().c_str(), true); - setenv("DISPLAY", fb->get_x_display().c_str(), true); + fb.reset(new x_frame_buffer(frame_params.width, + frame_params.height, + 3 * 8)); + setenv("XAUTHORITY", fb->get_authority().c_str(), true); + setenv("DISPLAY", fb->get_display().c_str(), true); } // Initialise Gtk Gtk::Main kit(argc, argv); - // Complete argument parsing with Gtk's options out of the way. + // Complete option parsing with Gtk's options out of the way. argi = 1; while (argi != argc) { @@ -986,18 +1159,36 @@ int main(int argc, char ** argv) break; } } - if (argc - argi != (preview_mode ? 1 : 2)) + + // Look for a starting URL or filename and (except in preview + // mode) an output directory after the options. + if (argc - argi != (preview_mode ? 1 : 2)) { print_usage(std::cerr, argv[0]); return EXIT_FAILURE; } + if (std::strstr(argv[argi], "://")) + { + // It appears to be an absolute URL, so use it as-is. + menu_url = argv[argi]; + } + else + { + // Assume it's a filename. Resolve it to an absolute URL. + std::string path(argv[argi]); + if (!Glib::path_is_absolute(path)) + path = Glib::build_filename(Glib::get_current_dir(), path); + menu_url = Glib::filename_to_uri(path); + } + if (!preview_mode) + output_dir = argv[argi + 1]; // Initialise Mozilla - BrowserWidget::init(); + browser_widget::initialiser browser_init; + set_browser_preferences(); - WebDvdWindow window(frame_params, - argv[argi], - preview_mode ? "" : argv[argi + 1]); + // Run the browser/converter + webdvd_window window(frame_params, menu_url, output_dir); Gtk::Main::run(window); } catch (std::exception & e)