// See the file "COPYING" for licence details.
#include <cassert>
+#include <cstring>
#include <exception>
#include <fstream>
#include <iomanip>
#include <string>
#include <stdlib.h>
-#include <unistd.h>
#include <boost/shared_ptr.hpp>
#include <nsIContent.h>
#include <nsIDocShell.h>
#include <nsIDOMAbstractView.h>
+#include <nsIDOMBarProp.h>
#include <nsIDOMDocumentEvent.h>
#include <nsIDOMDocumentView.h>
#include <nsIDOMElement.h>
#include <nsIInterfaceRequestorUtils.h>
#include <nsIURI.h> // required before nsILink.h
#include <nsILink.h>
+#include <nsIPrefBranch.h>
+#include <nsIPrefService.h>
#include <nsIPresContext.h>
#include <nsIPresShell.h>
+#include <nsIServiceManagerUtils.h>
#include <nsIWebBrowser.h>
#include <nsString.h>
-#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;
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<nsIDOMNode> child_node(*it);
PRUint16 child_type;
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_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;
+ };
+
+ 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)
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_default_size(frame_params_.width, frame_params_.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_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)
}
}
- 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.
pending_window_update_ = false;
}
- if (pending_req_count_ == 0 && !pending_window_update_)
+ if (!browser_is_busy())
{
try
{
}
}
- bool WebDvdWindow::process_page()
+ bool webdvd_window::process_page()
{
assert(!page_queue_.empty());
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);
page_queue_.pop();
if (page_queue_.empty())
{
- generate_dvd();
+ generate_dvd(contents_, output_dir_);
return false;
}
else
return true;
}
- void WebDvdWindow::save_screenshot()
+ void webdvd_window::save_screenshot()
{
Glib::RefPtr<Gdk::Window> window(get_window());
assert(window);
->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(
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)
{
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)
{
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));
<< " 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);
// 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;
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);
// 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()
" | 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
&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();
// 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";
}
" </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"
" </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"
{
const char * argv[] = {
"dvdauthor",
- "-o", output_dir_.c_str(),
+ "-o", output_dir.c_str(),
"-x", temp.get_name().c_str(),
0
};
}
}
- 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);
" [--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)
{
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;
}
}
- 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)
{
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)
projects / videolink.git / blobdiff