Enable EFIv1 compression in bmpbklk_utility.

utility/bmpblk_utility.cc

 // Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Utility for manipulating firmware screen block (BMPBLOCK) in GBB.
 //
 
 #include "bmpblk_utility.h"
 
 #include <assert.h>
 #include <errno.h>
 #include <getopt.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <yaml.h>
 
+extern "C" {
+#include "eficompress.h"
+}
+
+
 /* BMP header, used to validate image requirements
  * See http://en.wikipedia.org/wiki/BMP_file_format
  */
 typedef struct {
   uint8_t         CharB;                // must be 'B'
   uint8_t         CharM;                // must be 'M'
   uint32_t        Size;
   uint16_t        Reserved[2];
   uint32_t        ImageOffset;
   uint32_t        HeaderSize;
@@ skipping 31 matching lines @@
 BmpBlockUtil::~BmpBlockUtil() {
 }
 
 void BmpBlockUtil::initialize() {
   config_.config_filename.clear();
   memset(&config_.header, '\0', BMPBLOCK_SIGNATURE_SIZE);
   config_.images_map.clear();
   config_.screens_map.clear();
   config_.localizations.clear();
   bmpblock_.clear();
+  set_compression_ = false;
+  compression_ = COMPRESS_NONE;
+}
+
+void BmpBlockUtil::force_compression(uint32_t compression) {
+  compression_ = compression;
+  set_compression_ = true;
 }
 
 void BmpBlockUtil::load_from_config(const char *filename) {
   load_yaml_config(filename);
   fill_bmpblock_header();
   load_all_image_files();
   fill_all_image_infos();
 }
 
 void BmpBlockUtil::load_yaml_config(const char *filename) {
@@ skipping 205 matching lines @@
   }
 }
 
 void BmpBlockUtil::load_all_image_files() {
   for (StrImageConfigMap::iterator it = config_.images_map.begin();
        it != config_.images_map.end();
        ++it) {
     const string &content = read_image_file(it->second.filename.c_str());
     it->second.raw_content = content;
     it->second.data.original_size = content.size();
-    /* Use no compression as default */
-    it->second.data.compression = COMPRESS_NONE;
-    it->second.compressed_content = content;
-    it->second.data.compressed_size = content.size();
+    switch(compression_) {
+    case COMPRESS_NONE:
+      it->second.data.compression = compression_;
+      it->second.compressed_content = content;
+      it->second.data.compressed_size = content.size();
+      break;
+    case COMPRESS_EFIv1:
+      {
+        // The content will always compress smaller (so sez the docs).
+        uint32_t tmpsize = content.size();
+        uint8_t *tmpbuf = (uint8_t *)malloc(tmpsize);
+        // The size of the compressed content is also returned.
+        if (EFI_SUCCESS != EfiCompress((uint8_t *)content.c_str(), tmpsize,
+                                       tmpbuf, &tmpsize)) {
+          error("Unable to compress!\n");
+        }
+        it->second.data.compression = compression_;
+        it->second.compressed_content.assign((const char *)tmpbuf, tmpsize);
+        it->second.data.compressed_size = tmpsize;
+        free(tmpbuf);
+      }
+      break;
+    default:
+      error("Unsupported compression method attempted.\n");
+    }
   }
 }
 
 const string BmpBlockUtil::read_image_file(const char *filename) {
   string content;
   vector<char> buffer;
 
   FILE *fp = fopen(filename, "rb");
   if (!fp) {
     perror(filename);
@@ skipping 93 matching lines @@
         config_.localizations[i].size());
   }
   config_.header.number_of_imageinfos = config_.images_map.size();
 }
 
 void BmpBlockUtil::pack_bmpblock() {
   bmpblock_.clear();
 
   /* Compute the ImageInfo offsets from start of BMPBLOCK. */
   uint32_t current_offset = sizeof(BmpBlockHeader) +
-                            sizeof(ScreenLayout) * config_.images_map.size();
+                            sizeof(ScreenLayout) * config_.screens_map.size();
   for (StrImageConfigMap::iterator it = config_.images_map.begin();
        it != config_.images_map.end();
        ++it) {
     it->second.offset = current_offset;
     current_offset += sizeof(ImageInfo) + it->second.data.compressed_size;
     /* Make it 4-byte aligned. */
     if ((current_offset & 3) > 0) {
       current_offset = (current_offset & ~3) + 4;
     }
   }
@@ skipping 77 matching lines @@
     "  %s [-z NUM] -c YAML BMPBLOCK\n"
     "\n"
     "    -z NUM  = compression algorithm to use\n"
     "              0 = none\n"
     "              1 = EFIv1\n"
     "              2 = TBD\n"
     "\n", prog_name);
   printf(
     "To display the contents of a BMPBLOCK:\n"
     "\n"
-    "  %s BMPBLOCK\n"
+    "  %s [-y] BMPBLOCK\n"
+    "\n"
+    "    -y  = display as yaml\n"
     "\n", prog_name);
   printf(
     "To unpack a BMPBLOCK file:\n"
     "\n"
     "  %s -x [-d DIR] [-f] BMPBLOCK\n"
     "\n"
     "    -d DIR  = directory to use (default '.')\n"
     "    -f      = force overwriting existing files\n"
     "\n", prog_name);
   exit(1);
 }
 
 ///////////////////////////////////////////////////////////////////////
 // main
 
 int main(int argc, char *argv[]) {
 
   const char *prog_name = strrchr(argv[0], '/');
   if (prog_name)
     prog_name++;
   else
     prog_name = argv[0];
 
-  int force = 0, extract_mode = 0;
+  int overwrite = 0, extract_mode = 0;
   int compression = 0;
+  int set_compression = 0;
   const char *config_fn = 0, *bmpblock_fn = 0, *extract_dir = ".";
+  int show_as_yaml = 0;
 
   int opt;
   opterr = 0;                           // quiet
   int errorcnt = 0;
   char *e = 0;
-  while ((opt = getopt(argc, argv, ":c:xz:fd:")) != -1) {
+  while ((opt = getopt(argc, argv, ":c:xz:fd:y")) != -1) {
     switch (opt) {
     case 'c':
       config_fn = optarg;
       break;
     case 'x':
       extract_mode = 1;
       break;
+    case 'y':
+      show_as_yaml = 1;
+      break;
     case 'z':
       compression = (int)strtoul(optarg, &e, 0);
       if (!*optarg || (e && *e)) {
         fprintf(stderr, "%s: invalid argument to -%c: \"%s\"\n",
                 prog_name, opt, optarg);
         errorcnt++;
       }
       if (compression >= MAX_COMPRESS) {
         fprintf(stderr, "%s: compression type must be less than %d\n",
-                prog_name, compression);
+                prog_name, MAX_COMPRESS);
         errorcnt++;
       }
+      set_compression = 1;
       break;
     case 'f':
-      force = 1;
+      overwrite = 1;
       break;
     case 'd':
       extract_dir= optarg;
       break;
     case ':':
       fprintf(stderr, "%s: missing argument to -%c\n",
               prog_name, optopt);
       errorcnt++;
       break;
     default:
@@ skipping 12 matching lines @@
     fprintf(stderr, "%s: missing BMPBLOCK name\n", prog_name);
     errorcnt++;
   }
 
   if (errorcnt)
     usagehelp_exit(prog_name);
 
   BmpBlockUtil util;
 
   if (config_fn) {
-    printf("compression is %d\n", compression);
+    if (set_compression)
+      util.force_compression(compression);
     util.load_from_config(config_fn);
     util.pack_bmpblock();
     util.write_to_bmpblock(bmpblock_fn);
-    printf("The BMPBLOCK is sucessfully created in: %s.\n",
-           bmpblock_fn);
   }
 
   else if (extract_mode) {
-    return extract_bmpblock(bmpblock_fn, extract_dir, force);
-    printf("extract parts from %s into %s %s overwriting\n",
-           bmpblock_fn, extract_dir, force ? "with" : "without");
-    /* TODO(waihong): Implement the list mode. */
-    error("Extract mode hasn't been implemented yet.\n");
-  }
-
-  else {
-    return display_bmpblock(bmpblock_fn);
-    printf("display content of %s\n", bmpblock_fn);
-    /* TODO(waihong): Implement the list mode. */
-    error("List mode hasn't been implemented yet.\n");
+    return dump_bmpblock(bmpblock_fn, 1, extract_dir, overwrite);
+  } else {
+    return dump_bmpblock(bmpblock_fn, show_as_yaml, 0, 0);
   }
 
   return 0;
 }
 
 #endif  // WITH_UTIL_MAIN