X-Git-Url: https://git.decadent.org.uk/gitweb/?p=videolink.git;a=blobdiff_plain;f=webdvd.cpp;h=43f54c7021a703b8be936cb8280548239dfee6f0;hp=4d951ee9120f5502b0bec78b4aedcc92e2c16012;hb=c13714f6498df33e02635421354f5fb88a60eb3d;hpb=8d0ade32b10e040e462b244332afad1a0961d25b diff --git a/webdvd.cpp b/webdvd.cpp index 4d951ee..43f54c7 100644 --- a/webdvd.cpp +++ b/webdvd.cpp @@ -1,7 +1,8 @@ -// Copyright 2005 Ben Hutchings . +// Copyright 2005-6 Ben Hutchings . // See the file "COPYING" for licence details. #include +#include #include #include #include @@ -9,12 +10,16 @@ #include #include #include +#include #include #include -#include + +#include #include +#include +#include #include #include @@ -24,6 +29,7 @@ #include #include #include +#include #include #include #include @@ -36,19 +42,25 @@ #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 "generate_dvd.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 "xml_utils.hpp" #include "xpcom_support.hpp" using xpcom_support::check; @@ -104,6 +116,7 @@ namespace { rectangle result; + // Start with this element's bounding box nsCOMPtr box; check(ns_doc->GetBoxObjectFor(elem, getter_AddRefs(box))); int width, height; @@ -114,7 +127,8 @@ namespace result.right = result.left + width; result.bottom = result.top + height; - for (ChildIterator it = ChildIterator(elem), end; it != end; ++it) + // Merge bounding boxes of all child elements + for (child_iterator it = child_iterator(elem), end; it != end; ++it) { nsCOMPtr child_node(*it); PRUint16 child_type; @@ -130,159 +144,219 @@ namespace return result; } - class WebDvdWindow : public Gtk::Window + + class webdvd_window : public Gtk::Window { public: - WebDvdWindow(int width, int height); - void add_page(const std::string & uri); + webdvd_window( + const video::frame_params & frame_params, + const std::string & main_page_uri, + const std::string & output_dir); private: - 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_dvdauthor_file(); - enum ResourceType { page_resource, video_resource }; - typedef std::pair ResourceEntry; - int width_, height_; - BrowserWidget browser_widget_; + video::frame_params frame_params_; + std::string output_dir_; + browser_widget browser_widget_; nsCOMPtr stylesheet_; + + dvd_contents contents_; + typedef std::map resource_map_type; + resource_map_type resource_map_; + std::queue page_queue_; - std::map resource_map_; - std::vector > page_links_; - std::vector video_paths_; - bool loading_; + bool pending_window_update_; int pending_req_count_; - struct link_state; - std::auto_ptr link_state_; + bool have_tweaked_page_; + std::auto_ptr background_temp_; + struct page_state; + std::auto_ptr page_state_; }; - WebDvdWindow::WebDvdWindow(int width, int height) - : width_(width), height_(height), + webdvd_window::webdvd_window( + const video::frame_params & frame_params, + const std::string & main_page_uri, + const std::string & output_dir) + : frame_params_(frame_params), + output_dir_(output_dir), stylesheet_(load_css("file://" WEBDVD_LIB_DIR "/webdvd.css")), - loading_(false), - pending_req_count_(0) + pending_window_update_(false), + pending_req_count_(0), + have_tweaked_page_(false) { - set_default_size(width, height); + set_size_request(frame_params_.width, frame_params_.height); + set_resizable(false); + 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_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 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); - if (!loading_) - load_next_page(); + 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 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 path(Glib::filename_from_uri(uri, hostname)); + // FIXME: Should check the hostname + + vob_list list; + + // Store a reference to a linked VOB file, or the contents + // of a linked VOB list file. + if (path.compare(path.size() - 4, 4, ".vob") == 0) + { + if (!Glib::file_test(path, Glib::FILE_TEST_IS_REGULAR)) + throw std::runtime_error( + path + " is missing or not a regular file"); + vob_ref ref; + ref.file = path; + list.push_back(ref); + } + else + { + assert(path.compare(path.size() - 8, 8, ".voblist") == 0); + read_vob_list(path).swap(list); + } + + contents_.titles.resize(contents_.titles.size() + 1); + contents_.titles.back().swap(list); + return next_title; } } - void WebDvdWindow::load_next_page() + void webdvd_window::load_next_page() { - loading_ = true; - 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); 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) { - enum { - process_nothing, - process_new_page, - process_current_link - } action = process_nothing; +# 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) ++pending_req_count_; + if (flags & GTK_MOZ_EMBED_FLAG_STOP) { assert(pending_req_count_ != 0); --pending_req_count_; } - if (pending_req_count_ == 0 && link_state_.get()) - action = process_current_link; } - if (flags & GTK_MOZ_EMBED_FLAG_STOP - && flags & GTK_MOZ_EMBED_FLAG_IS_WINDOW) - action = process_new_page; + if (flags & GTK_MOZ_EMBED_FLAG_IS_DOCUMENT + && flags & GTK_MOZ_EMBED_FLAG_START) + { + pending_window_update_ = true; + have_tweaked_page_ = false; + } - if (action != process_nothing) + if (flags & GTK_MOZ_EMBED_FLAG_IS_WINDOW + && flags & GTK_MOZ_EMBED_FLAG_STOP) { - assert(loading_ && !page_queue_.empty()); - assert(pending_req_count_ == 0); + // Check whether the load was successful, ignoring this + // pseudo-error. + if (status != NS_IMAGELIB_ERROR_LOAD_ABORTED) + check(status); + + pending_window_update_ = false; + } + if (!browser_is_busy()) + { try { - // Check whether the load was successful, ignoring this - // pseudo-error. - if (status != NS_IMAGELIB_ERROR_LOAD_ABORTED) - check(status); - - nsCOMPtr browser( - browser_widget_.get_browser()); - nsCOMPtr doc_shell(do_GetInterface(browser)); - assert(doc_shell); - nsCOMPtr pres_shell; - check(doc_shell->GetPresShell(getter_AddRefs(pres_shell))); - nsCOMPtr pres_context; - check(doc_shell->GetPresContext( - getter_AddRefs(pres_context))); - nsCOMPtr dom_window; - check(browser->GetContentDOMWindow( - getter_AddRefs(dom_window))); - - if (action == process_new_page) - { - apply_style_sheet(stylesheet_, pres_shell); - save_screenshot(); - } - process_links(pres_shell, pres_context, dom_window); - if (!link_state_.get()) - { - page_queue_.pop(); - if (page_queue_.empty()) - { - generate_dvdauthor_file(); - Gtk::Main::quit(); - } - else - load_next_page(); - } + if (!process_page()) + Gtk::Main::quit(); } catch (std::exception & e) { @@ -293,38 +367,131 @@ namespace 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(); + } } } - void WebDvdWindow::save_screenshot() + bool webdvd_window::process_page() + { + assert(!page_queue_.empty()); + + nsCOMPtr browser(browser_widget_.get_browser()); + nsCOMPtr doc_shell(do_GetInterface(browser)); + assert(doc_shell); + nsCOMPtr pres_shell; + check(doc_shell->GetPresShell(getter_AddRefs(pres_shell))); + nsCOMPtr pres_context; + check(doc_shell->GetPresContext(getter_AddRefs(pres_context))); + nsCOMPtr dom_window; + check(browser->GetContentDOMWindow(getter_AddRefs(dom_window))); + + // If we haven't done so already, apply the stylesheet and + // disable scrollbars. + if (!have_tweaked_page_) + { + apply_style_sheet(stylesheet_, pres_shell); + + // This actually only needs to be done once. + nsCOMPtr 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; + } + + // 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 menu, save a + // screenshot of its normal appearance. + if (!page_state_.get()) + save_screenshot(); + + // Start or continue processing links. + process_links(pres_shell, pres_context, dom_window); + + // If we've finished work on the links, move on to the + // next page, if any, or else generate the DVD filesystem. + if (!page_state_.get()) + { + page_queue_.pop(); + if (page_queue_.empty()) + { + generate_dvd(contents_, output_dir_); + return false; + } + else + { + load_next_page(); + } + } + } + + return true; + } + + void webdvd_window::save_screenshot() { - char filename[25]; - std::sprintf(filename, "page_%06d_back.png", page_links_.size()); Glib::RefPtr window(get_window()); assert(window); window->process_updates(true); - std::cout << "saving " << filename << std::endl; + + background_temp_.reset(new temp_file("webdvd-back-")); + background_temp_->close(); + std::cout << "saving " << background_temp_->get_name() << std::endl; Gdk::Pixbuf::create(Glib::RefPtr(window), window->get_colormap(), - 0, 0, 0, 0, width_, height_) - ->save(filename, "png"); + 0, 0, 0, 0, + frame_params_.width, frame_params_.height) + ->save(background_temp_->get_name(), "png"); } - struct WebDvdWindow::link_state + struct webdvd_window::page_state { + page_state(nsIDOMDocument * doc, int width, int height) + : diff_pixbuf(Gdk::Pixbuf::create( + Gdk::COLORSPACE_RGB, + true, 8, // has_alpha, bits_per_sample + width, height)), + spumux_temp("webdvd-spumux-"), + links_temp("webdvd-links-"), + link_num(0), + links_it(doc), + link_changing(false) + { + spumux_temp.close(); + links_temp.close(); + } + Glib::RefPtr diff_pixbuf; + temp_file spumux_temp; std::ofstream spumux_file; - int link_num; - LinkIterator links_it, links_end; + temp_file links_temp; + + unsigned link_num; + link_iterator links_it, links_end; rectangle link_rect; bool link_changing; Glib::RefPtr norm_pixbuf; }; - void WebDvdWindow::process_links(nsIPresShell * pres_shell, + void webdvd_window::process_links(nsIPresShell * pres_shell, nsIPresContext * pres_context, nsIDOMWindow * dom_window) { @@ -347,37 +514,27 @@ namespace check(doc_view->GetDefaultView(getter_AddRefs(view))); // Set up or recover our iteration state. - std::auto_ptr state(link_state_); + std::auto_ptr state(page_state_); if (!state.get()) { - state.reset(new link_state); - - state->diff_pixbuf = Gdk::Pixbuf::create(Gdk::COLORSPACE_RGB, - true, // has_alpha - 8, // bits_per_sample - width_, height_); - - char spumux_filename[20]; - std::sprintf(spumux_filename, - "page_%06d.spumux", page_links_.size()); - state->spumux_file.open(spumux_filename); + state.reset( + new page_state( + basic_doc, frame_params_.width, frame_params_.height)); + + state->spumux_file.open(state->spumux_temp.get_name().c_str()); state->spumux_file << "\n" " \n" " \n"; - - state->link_num = 0; - state->links_it = LinkIterator(basic_doc); - state->link_changing = false; + " highlight='" << state->links_temp.get_name() << "'\n" + " select='" << state->links_temp.get_name() << "'>\n"; } - - rectangle window_rect = { 0, 0, width_, height_ }; + + rectangle window_rect = { + 0, 0, frame_params_.width, frame_params_.height + }; + + unsigned menu_num = resource_map_[page_queue_.front()].index; for (/* no initialisation */; state->links_it != state->links_end; @@ -385,19 +542,24 @@ namespace { nsCOMPtr node(*state->links_it); - // Find the link URI. + // Find the link URI and separate any fragment from it. nsCOMPtr link(do_QueryInterface(node)); assert(link); - nsCOMPtr uri; - check(link->GetHrefURI(getter_AddRefs(uri))); - std::string uri_string; + nsCOMPtr 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) @@ -412,44 +574,58 @@ namespace 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 page\n"; - std::cerr << "Ignoring link to " << uri_string << "\n"; + << " buttons can be placed on a menu\n"; + std::cerr << "Ignoring link to " << uri_and_fragment + << "\n"; continue; } + state->spumux_file << + " \n"; + preview_mode = true; + argi += 1; + } + else if (std::strcmp(argv[argi], "--video-std") == 0) + { + if (argi + 1 == argc) + { + std::cerr << "Missing argument to --video-std\n"; + print_usage(std::cerr, argv[0]); + return EXIT_FAILURE; + } + frame_params = lookup_frame_params(argv[argi + 1]); + argi += 2; + } + else + { + argi += 1; } - - file << " \n"; } - file << - " \n" - " \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) + std::auto_ptr fb; + if (!preview_mode) { - file << - " \n" - // Generate a dummy menu so that the menu button on the - // remote control will work. - " \n" - " \n" - " 
 jump vmgm menu;
\n" - " \n" - " \n" - " \n" - " \n" - // Record calling page/menu. - " 
 g12 = g1;
\n" - // FIXME: Should XML-escape the path - " \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. - " if (g1 eq g12) g1 = g1 + " << link_mult - << "; call menu; \n" - " \n" - " \n" - " \n"; + // 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 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); } - file << - "\n"; - } + // Initialise Gtk + Gtk::Main kit(argc, argv); - void generate_page_dispatch(std::ostream & file, int indent, - int first_page, int last_page) - { - if (first_page == 1 && last_page == 1) + // Complete option parsing with Gtk's options out of the way. + argi = 1; + while (argi != argc) { - // 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. + if (std::strcmp(argv[argi], "--") == 0) + { + argi += 1; + break; + } + else if (std::strcmp(argv[argi], "--preview") == 0) + { + argi += 1; + } + else if (std::strcmp(argv[argi], "--video-std") == 0) + { + argi += 2; + } + else if (argv[argi][0] == '-') + { + std::cerr << "Invalid option: " << argv[argi] << "\n"; + print_usage(std::cerr, argv[0]); + return EXIT_FAILURE; + } + else + { + break; + } } - else if (first_page == 1 && last_page == 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)) { - // 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"; + print_usage(std::cerr, argv[0]); + return EXIT_FAILURE; } - else if (first_page == last_page) + if (std::strstr(argv[argi], "://")) { - file << std::setw(indent) << "" - << "jump menu " << first_page << ";\n"; + // It appears to be an absolute URL, so use it as-is. + menu_url = argv[argi]; } 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); + // 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); } - } - -} // namespace + if (!preview_mode) + output_dir = argv[argi + 1]; -int main(int argc, char ** argv) -{ - // Get dimensions - int width = video::pal_oscan_width, height = video::pal_oscan_height; - for (int i = 1; i < argc - 1; ++i) - if (std::strcmp(argv[i], "-geometry") == 0) - { - std::sscanf(argv[i + 1], "%dx%d", &width, &height); - break; - } - // A depth of 24 results in 8 bits each for RGB components, which - // translates into "enough" bits for YUV components. - const int depth = 24; - - try - { - // Spawn Xvfb and set env variables so that Xlib will use it - FrameBuffer fb(width, height, depth); - setenv("XAUTHORITY", fb.get_x_authority().c_str(), true); - setenv("DISPLAY", fb.get_x_display().c_str(), true); - - // Initialise Gtk and Mozilla - Gtk::Main kit(argc, argv); - BrowserWidget::init(); + // Initialise Mozilla + browser_widget::initialiser browser_init; + set_browser_preferences(); - WebDvdWindow window(width, height); - for (int argi = 1; argi < argc; ++argi) - window.add_page(argv[argi]); - if (argc < 2) - window.add_page("about:"); + // Run the browser/converter + webdvd_window window(frame_params, menu_url, output_dir); Gtk::Main::run(window); } catch (std::exception & e)