Add zook's ZenUtils to SVN

git-svn-id: svn://svn.rockbox.org/rockbox/trunk@18010 a1c6a512-1295-4272-9138-f99709370657

1 files changed, 243 insertions, 0 deletions

diff --git a/utils/zenutils/source/firmware_extract/main.cpp b/utils/zenutils/source/firmware_extract/main.cpp
new file mode 100755
index 0000000..c677a91
--- /dev/null
+++ b/utils/zenutils/source/firmware_extract/main.cpp
@@ -0,0 +1,243 @@
+/* zenutils - Utilities for working with creative firmwares.

+ * Copyright 2007 (c) Rasmus Ry <rasmus.ry{at}gmail.com>

+ *

+ * This program is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

+ */

+

+#include <iostream>

+#include <ctime>

+#include <getpot/getpot.hpp>

+#include <utils.h>

+#include <firmware.h>

+

+

+static const char VERSION[] = "0.1";

+

+

+void print_version()

+{

+    std::cout

+        << "firmware_extract - Extracts files from a Creative firmware."

+        << std::endl

+        << "Version " << VERSION << std::endl

+        << "Copyright (c) 2007 Rasmus Ry" << std::endl;

+}

+

+void print_help()

+{

+    print_version();

+    std::cout

+        << "Usage: firmware_extract [command] [options]" << std::endl

+        << std::endl

+        << " Commands:" << std::endl

+        << "  -h,--help" << std::endl

+        << "      prints this message." << std::endl

+        << "  -f,--firmware [file]" << std::endl

+        << "      specifies the firmware arhive file name." << std::endl

+        << std::endl

+        << " Options:" << std::endl

+        << "  -V,--verbose" << std::endl

+        << "      prints verbose messages." << std::endl

+        << "  -p,--prefix [prefix]" << std::endl

+        << "      specifies a file name prefix for the extracted files." << std::endl

+        << std::endl

+        ;

+}

+

+

+struct save_entry_functor

+{

+    save_entry_functor(const std::string& fileprefix)

+        : _fileprefix(fileprefix) {}

+

+    bool operator()(const zen::firmware_entry& entry)

+    {

+        std::string filename = _fileprefix + entry.get_content_name();

+        std::ofstream ofs;

+        ofs.open(filename.c_str(), std::ios::binary);

+        if (!ofs)

+            false;

+

+        size_t off = entry.get_content_offset();

+        std::streamsize size = entry.get_bytes().size() - off;

+        ofs.write((const char*)&entry.get_bytes()[off], size);

+

+        return ofs.good();

+    }

+

+    const std::string& _fileprefix;

+}; //struct save_entry_functor

+

+struct print_entry_functor

+{

+    print_entry_functor(std::ostream& os, const std::string& fileprefix)

+        : _os(os), _fileprefix(fileprefix), num(0) {}

+

+    bool operator()(const zen::firmware_entry& entry)

+    {

+        std::string filename = _fileprefix + entry.get_content_name();

+        if (!num)

+            _os << "[./" << num++ << "]" << std::endl;

+        else

+            _os << "[../" << num++ << "]" << std::endl;

+        _os << "tag = " << entry.get_name() << std::endl;

+

+        if (entry.get_content_offset())

+            _os << "name = " << entry.get_content_name() << std::endl;

+

+        _os << "file = \'" << shared::double_quote(filename) << "\'"

+            << std::endl;

+

+        return _os.good();

+    }

+

+    std::ostream& _os;

+    const std::string& _fileprefix;

+    int num;

+}; //struct print_entry_functor

+

+

+int process_arguments(int argc, char* argv[])

+{

+    //--------------------------------------------------------------------

+    // Parse input variables.

+    //--------------------------------------------------------------------

+

+    GetPot cl(argc, argv);

+    if (cl.size() == 1 || cl.search(2, "-h", "--help"))

+    {

+        print_help();

+        return 1;

+    }

+

+    std::string firmwarename;

+    if (cl.search("-f") || cl.search("--firmware"))

+        firmwarename = cl.next("");

+    if (firmwarename.empty())

+    {

+        std::cerr << "Firmware archive must be specified." << std::endl;

+        return 2;

+    }

+

+    bool verbose = false;

+    if (cl.search("-V") || cl.search("--verbose"))

+        verbose = true;

+

+    std::string prefixname = shared::remove_extension(firmwarename) + "_";

+    if (cl.search("-p") || cl.search("--prefix"))

+        prefixname = cl.next(prefixname.c_str());

+

+

+    //--------------------------------------------------------------------

+    // Read the firmware archive.

+    //--------------------------------------------------------------------

+

+    if (verbose)

+        std::cout << "[*] Reading firmware archive..." << std::endl;

+

+    zen::firmware_archive archive(false);

+    std::ifstream ifs;

+    ifs.open(firmwarename.c_str(), std::ios::binary);

+    if (!ifs)

+    {

+        std::cerr << "Failed to open the firmware archive." << std::endl;

+        return 3;

+    }

+

+    if (!archive.read(ifs))

+    {

+        std::cerr << "Failed to read the firmware archive." << std::endl;

+        return 4;

+    }

+

+

+    //--------------------------------------------------------------------

+    // Generate a make file for the extracted firmware archive.

+    //--------------------------------------------------------------------

+

+    // Get make filename for the given input file.

+    std::string makefile = shared::replace_extension(firmwarename, ".mk");

+

+    if (verbose)

+        std::cout << "[*] Producing make file..." << std::endl;

+

+

+    // Produce make file for the given input file.

+    std::ofstream ofs;

+    ofs.open(makefile.c_str(), std::ios::binary);

+    if (!ofs)

+    {

+        std::cerr << "Failed to create firmware archive make file."

+                  << std::endl;

+        return 5;

+    }

+

+    time_t timeval = time(NULL);

+    ofs << "# Make file generated at: " << ctime(&timeval);

+    ofs << "endian = " << (archive.is_big_endian() ? "big" : "little")

+        << std::endl;

+    ofs << "signed = " << (archive.is_signed() ? "true" : "false")

+        << std::endl;

+

+    ofs << "[children]" << std::endl;

+    ofs << "count = " << archive.get_children().size() << std::endl;

+

+    std::for_each(archive.get_children().begin(),

+                  archive.get_children().end(),

+                  print_entry_functor(ofs, prefixname));

+

+    ofs << "[neighbours]" << std::endl;

+    ofs << "count = " << archive.get_neighbours().size() << std::endl;

+    std::for_each(archive.get_neighbours().begin(),

+                  archive.get_neighbours().end(),

+                  print_entry_functor(ofs, prefixname));

+

+

+    //--------------------------------------------------------------------

+    // Save firmware entries.

+    //--------------------------------------------------------------------

+

+    if (verbose)

+        std::cout << "[*] Saving firmware entries..." << std::endl;

+

+    std::for_each(archive.get_children().begin(),

+                  archive.get_children().end(),

+                  save_entry_functor(prefixname));

+

+    std::for_each(archive.get_neighbours().begin(),

+                  archive.get_neighbours().end(),

+                  save_entry_functor(prefixname));

+

+    return 0;

+}

+

+int main(int argc, char* argv[])

+{

+    try

+    {

+        return process_arguments(argc, argv);

+    }

+    catch (const std::exception& xcpt)

+    {

+        std::cerr << "Exception caught: " << xcpt.what() << std::endl;

+        return -1;

+    }

+    catch (...)

+    {

+        std::cerr << "Unknown exception caught." << std::endl;

+        return -2;

+    }

+    return -3;

+}