utility/bmpblk_util.c - mirrors/cros/chromiumos/platform/vboot_reference - Git at Google

 // 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.

 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <lzma.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>

 #include "bmpblk_util.h"
 #include "eficompress.h"
 #include "vboot_api.h"

 // Returns pointer to buffer containing entire file, sets length.
 static void *read_entire_file(const char *filename, size_t *length) {
   int fd;
   struct stat sbuf;
   void *ptr;

   *length = 0;                          // just in case

   if (0 != stat(filename, &sbuf)) {
     fprintf(stderr, "Unable to stat %s: %s\n", filename, strerror(errno));
     return 0;
   }

   if (!sbuf.st_size) {
     fprintf(stderr, "File %s is empty\n", filename);
     return 0;
   }

   fd = open(filename, O_RDONLY);
   if (fd < 0) {
     fprintf(stderr, "Unable to open %s: %s\n", filename, strerror(errno));
     return 0;
   }

   ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
   if (MAP_FAILED == ptr) {
     fprintf(stderr, "Unable to mmap %s: %s\n", filename, strerror(errno));
     close(fd);
     return 0;
   }

   *length = sbuf.st_size;

   close(fd);

   return ptr;
 }


 // Reclaims buffer from read_entire_file().
 static void discard_file(void *ptr, size_t length) {
   munmap(ptr, length);
 }

 //////////////////////////////////////////////////////////////////////////////

 static int require_dir(const char *dirname) {
   struct stat sbuf;

   if (0 == stat(dirname, &sbuf)) {
     // Something's there. Is it a directory?
     if (S_ISDIR(sbuf.st_mode)) {
       return 0;
     }
     fprintf(stderr, "%s already exists and is not a directory\n", dirname);
     return 1;
   }

   // dirname doesn't exist. Try to create it.
   if (ENOENT == errno) {
     if (0 != mkdir(dirname, 0777)) {
       fprintf(stderr, "Unable to create directory %s: %s\n",
               dirname, strerror(errno));
       return 1;
     }
     return 0;
   }

   fprintf(stderr, "Unable to stat %s: %s\n", dirname, strerror(errno));
   return 1;
 }


 static void *do_efi_decompress(ImageInfo *img) {
   void *ibuf;
   void *sbuf;
   void *obuf;
   uint32_t isize;
   uint32_t ssize;
   uint32_t osize;
   EFI_STATUS r;

   ibuf = (void*)(img + 1);
   isize = img->compressed_size;

   r = EfiGetInfo(ibuf, isize, &osize, &ssize);
   if (EFI_SUCCESS != r) {
     fprintf(stderr, "EfiGetInfo() failed with code %d\n",
             r);
     return 0;
   }

   sbuf = malloc(ssize);
   if (!sbuf) {
     fprintf(stderr, "Can't allocate %d bytes: %s\n",
             ssize,
             strerror(errno));
     return 0;
   }

   obuf = malloc(osize);
   if (!obuf) {
     fprintf(stderr, "Can't allocate %d bytes: %s\n",
             osize,
             strerror(errno));
     free(sbuf);
     return 0;
   }

   r = EfiDecompress(ibuf, isize, obuf, osize, sbuf, ssize);
   if (r != EFI_SUCCESS) {
     fprintf(stderr, "EfiDecompress failed with code %d\n", r);
     free(obuf);
     free(sbuf);
     return 0;
   }

   free(sbuf);
   return obuf;
 }


 static void *do_lzma_decompress(ImageInfo *img) {
   void *ibuf;
   void *obuf;
   uint32_t isize;
   uint32_t osize;
   lzma_stream stream = LZMA_STREAM_INIT;
   lzma_ret result;

   ibuf = (void*)(img + 1);
   isize = img->compressed_size;
   osize = img->original_size;
   obuf = malloc(osize);
   if (!obuf) {
     fprintf(stderr, "Can't allocate %d bytes: %s\n",
             osize,
             strerror(errno));
     return 0;
   }

   result = lzma_auto_decoder(&stream, -1, 0);
   if (result != LZMA_OK) {
     fprintf(stderr, "Unable to initialize auto decoder (error: %d)!\n",
             result);
     free(obuf);
     return 0;
   }

   stream.next_in = ibuf;
   stream.avail_in = isize;
   stream.next_out = obuf;
   stream.avail_out = osize;
   result = lzma_code(&stream, LZMA_FINISH);
   if (result != LZMA_STREAM_END) {
     fprintf(stderr, "Unalbe to decode data (error: %d)!\n", result);
     free(obuf);
     return 0;
   }
   lzma_end(&stream);
   return obuf;
 }


 // Show what's inside. If todir is NULL, just print. Otherwise unpack.
 int dump_bmpblock(const char *infile, int show_as_yaml,
                   const char *todir, int overwrite) {
   void *ptr, *data_ptr;
   size_t length = 0;
   BmpBlockHeader *hdr;
   ImageInfo *img;
   ScreenLayout *scr;
   int loc_num;
   int screen_num;
   int i;
   int offset;
   int free_data;
   char image_name[80];
   char full_path_name[PATH_MAX];
   int yfd, bfd;
   FILE *yfp = stdout;
   FILE *bfp = stdout;

   ptr = (void *)read_entire_file(infile, &length);
   if (!ptr)
     return 1;

   if (length < sizeof(BmpBlockHeader)) {
     fprintf(stderr, "File %s is too small to be a BMPBLOCK\n", infile);
     discard_file(ptr, length);
     return 1;
   }

   if (0 != memcmp(ptr, BMPBLOCK_SIGNATURE, BMPBLOCK_SIGNATURE_SIZE)) {
     fprintf(stderr, "File %s is not a BMPBLOCK\n", infile);
     discard_file(ptr, length);
     return 1;
   }

   if (todir) {
     // Unpacking everything. Create the output directory if needed.
     if (0 != require_dir(todir)) {
       discard_file(ptr, length);
       return 1;
     }

     // Open yaml output.
     show_as_yaml = 1;

     sprintf(full_path_name, "%s/%s", todir, "config.yaml");
     yfd = open(full_path_name,
                O_WRONLY | O_CREAT | O_TRUNC | (overwrite ? 0 : O_EXCL),
                0666);
     if (yfd < 0) {
       fprintf(stderr, "Unable to open %s: %s\n", full_path_name,
               strerror(errno));
       discard_file(ptr, length);
       return 1;
     }

     yfp = fdopen(yfd, "wb");
     if (!yfp) {
       fprintf(stderr, "Unable to fdopen %s: %s\n", full_path_name,
               strerror(errno));
       close(yfd);
       discard_file(ptr, length);
       return 1;
     }
   }

   hdr = (BmpBlockHeader *)ptr;

   if (!show_as_yaml) {
     printf("%s:\n", infile);
     printf("  version %d.%d\n", hdr->major_version, hdr->minor_version);
     printf("  %d screens\n", hdr->number_of_screenlayouts);
     printf("  %d localizations\n", hdr->number_of_localizations);
     printf("  %d discrete images\n", hdr->number_of_imageinfos);
     discard_file(ptr, length);
     return 0;
   }

   // Write out yaml
   fprintf(yfp, "bmpblock: %d.%d\n", hdr->major_version, hdr->minor_version);
   offset = sizeof(BmpBlockHeader) +
     (sizeof(ScreenLayout) *
      hdr->number_of_localizations *
      hdr->number_of_screenlayouts);
   // FIXME(chromium-os:12134): The bmbblock structure allows each image to be
   // compressed differently, but we haven't provided a way for the yaml file to
   // specify that. Additionally, we allow the yaml file to specify a default
   // compression scheme for all images, but only if that line appears in the
   // yaml file before any images. Accordingly, we'll just check the first image
   // to see if it has any compression, and if it does, we'll write that out as
   // the default. When this bug is fixed, we should just write each image's
   // compression setting separately.
   img = (ImageInfo *)(ptr + offset);
   if (img->compression)
     fprintf(yfp, "compression: %d\n", img->compression);
   fprintf(yfp, "images:\n");
   for(i=0; i<hdr->number_of_imageinfos; i++) {
     img = (ImageInfo *)(ptr + offset);
     if (img->compressed_size) {
       sprintf(image_name, "img_%08x.bmp", offset);
       if (img->tag == TAG_HWID) {
         fprintf(yfp, "  %s: %s  # %dx%d  %d/%d  tag=%d fmt=%d\n",
                 RENDER_HWID, image_name,
                 img->width, img->height,
                 img->compressed_size, img->original_size,
                 img->tag, img->format);
       } else if (img->tag == TAG_HWID_RTOL) {
         fprintf(yfp, "  %s: %s  # %dx%d  %d/%d  tag=%d fmt=%d\n",
                 RENDER_HWID_RTOL, image_name,
                 img->width, img->height,
                 img->compressed_size, img->original_size,
                 img->tag, img->format);
       } else {
         fprintf(yfp, "  img_%08x: %s  # %dx%d  %d/%d  tag=%d fmt=%d\n",
                 offset, image_name,
                 img->width, img->height,
                 img->compressed_size, img->original_size,
                 img->tag, img->format);
       }
       if (todir) {
         sprintf(full_path_name, "%s/%s", todir, image_name);
         bfd = open(full_path_name,
                    O_WRONLY | O_CREAT | O_TRUNC | (overwrite ? 0 : O_EXCL),
                    0666);
         if (bfd < 0) {
           fprintf(stderr, "Unable to open %s: %s\n", full_path_name,
                   strerror(errno));
           fclose(yfp);
           discard_file(ptr, length);
           return 1;
         }
         bfp = fdopen(bfd, "wb");
         if (!bfp) {
           fprintf(stderr, "Unable to fdopen %s: %s\n", full_path_name,
                   strerror(errno));
           close(bfd);
           fclose(yfp);
           discard_file(ptr, length);
           return 1;
         }
         switch(img->compression) {
         case COMPRESS_NONE:
           data_ptr = ptr + offset + sizeof(ImageInfo);
           free_data = 0;
           break;
         case COMPRESS_EFIv1:
           data_ptr = do_efi_decompress(img);
           if (!data_ptr) {
             fclose(bfp);
             fclose(yfp);
             discard_file(ptr, length);
             return 1;
           }
           free_data = 1;
           break;
         case COMPRESS_LZMA1:
           data_ptr = do_lzma_decompress(img);
           if (!data_ptr) {
             fclose(bfp);
             fclose(yfp);
             discard_file(ptr, length);
             return 1;
           }
           free_data = 1;
           break;
         default:
           fprintf(stderr, "Unsupported compression method encountered.\n");
           fclose(bfp);
           fclose(yfp);
           discard_file(ptr, length);
           return 1;
         }
         if (1 != fwrite(data_ptr, img->original_size, 1, bfp)) {
           fprintf(stderr, "Unable to write %s: %s\n", full_path_name,
                   strerror(errno));
           fclose(bfp);
           fclose(yfp);
           discard_file(ptr, length);
           return 1;
         }
         fclose(bfp);
         if (free_data)
           free(data_ptr);
       }
     }
     offset += sizeof(ImageInfo);
     offset += img->compressed_size;
     // 4-byte aligned
     if ((offset & 3) > 0)
       offset = (offset & ~3) + 4;
   }
   fprintf(yfp, "screens:\n");
   for(loc_num = 0;
       loc_num < hdr->number_of_localizations;
       loc_num++) {
     for(screen_num = 0;
         screen_num < hdr->number_of_screenlayouts;
         screen_num++) {
       fprintf(yfp, "  scr_%d_%d:\n", loc_num, screen_num);
       i = loc_num * hdr->number_of_screenlayouts + screen_num;
       offset = sizeof(BmpBlockHeader) + i * sizeof(ScreenLayout);
       scr = (ScreenLayout *)(ptr + offset);
       for(i=0; i<MAX_IMAGE_IN_LAYOUT; i++) {
         if (scr->images[i].image_info_offset) {
           ImageInfo *iptr =
             (ImageInfo *)(ptr + scr->images[i].image_info_offset);
           if (iptr->tag == TAG_HWID) {
             fprintf(yfp, "    - [%d, %d, %s] # tag=%d fmt=%d c=%d %d/%d\n",
                     scr->images[i].x, scr->images[i].y,
                     RENDER_HWID, iptr->tag, iptr->format, iptr->compression,
                     iptr->compressed_size, iptr->original_size);
           } else if (iptr->tag == TAG_HWID_RTOL) {
             fprintf(yfp, "    - [%d, %d, %s] # tag=%d fmt=%d c=%d %d/%d\n",
                     scr->images[i].x, scr->images[i].y,
                     RENDER_HWID_RTOL, iptr->tag,
                     iptr->format, iptr->compression,
                     iptr->compressed_size, iptr->original_size);
           } else {
             fprintf(yfp, "    - [%d, %d, img_%08x]"
                     " # tag=%d fmt=%d c=%d %d/%d\n",
                     scr->images[i].x, scr->images[i].y,
                     scr->images[i].image_info_offset,
                     iptr->tag, iptr->format, iptr->compression,
                     iptr->compressed_size, iptr->original_size);
           }
         }
       }
     }
   }
   fprintf(yfp, "localizations:\n");
   for(loc_num = 0;
       loc_num < hdr->number_of_localizations;
       loc_num++) {
     fprintf(yfp, "  - [");
     for(screen_num = 0;
         screen_num < hdr->number_of_screenlayouts;
         screen_num++) {
       fprintf(yfp, " scr_%d_%d", loc_num, screen_num);
       if (screen_num != hdr->number_of_screenlayouts - 1)
         fprintf(yfp, ",");
     }
     fprintf(yfp, " ]\n");
   }

   if (hdr->locale_string_offset) {
     char *loc_ptr = (char *)ptr + hdr->locale_string_offset;
     char c;
     fprintf(yfp, "locale_index:\n");
     while ((c = *loc_ptr) != '\0') {
       fprintf(yfp, "  - ");
       do {
         fputc(c, yfp);
         loc_ptr++;
       } while((c = *loc_ptr) != '\0');
       loc_ptr++;
       fputc('\n', yfp);
     }
   }

   if (todir)
     fclose(yfp);

   discard_file(ptr, length);

   return 0;
 }
	// 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.

	#include <errno.h>
	#include <fcntl.h>
	#include <limits.h>
	#include <lzma.h>
	#include <stdint.h>
	#include <stdlib.h>
	#include <stdio.h>
	#include <string.h>
	#include <sys/mman.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <unistd.h>

	#include "bmpblk_util.h"
	#include "eficompress.h"
	#include "vboot_api.h"

	// Returns pointer to buffer containing entire file, sets length.
	static void read_entire_file(const char filename, size_t *length) {
	int fd;
	struct stat sbuf;
	void *ptr;

	*length = 0; // just in case

	if (0 != stat(filename, &sbuf)) {
	fprintf(stderr, "Unable to stat %s: %s\n", filename, strerror(errno));
	return 0;
	}

	if (!sbuf.st_size) {
	fprintf(stderr, "File %s is empty\n", filename);
	return 0;
	}

	fd = open(filename, O_RDONLY);
	if (fd < 0) {
	fprintf(stderr, "Unable to open %s: %s\n", filename, strerror(errno));
	return 0;
	}

	ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
	if (MAP_FAILED == ptr) {
	fprintf(stderr, "Unable to mmap %s: %s\n", filename, strerror(errno));
	close(fd);
	return 0;
	}

	*length = sbuf.st_size;

	close(fd);

	return ptr;
	}


	// Reclaims buffer from read_entire_file().
	static void discard_file(void *ptr, size_t length) {
	munmap(ptr, length);
	}

	//////////////////////////////////////////////////////////////////////////////

	static int require_dir(const char *dirname) {
	struct stat sbuf;

	if (0 == stat(dirname, &sbuf)) {
	// Something's there. Is it a directory?
	if (S_ISDIR(sbuf.st_mode)) {
	return 0;
	}
	fprintf(stderr, "%s already exists and is not a directory\n", dirname);
	return 1;
	}

	// dirname doesn't exist. Try to create it.
	if (ENOENT == errno) {
	if (0 != mkdir(dirname, 0777)) {
	fprintf(stderr, "Unable to create directory %s: %s\n",
	dirname, strerror(errno));
	return 1;
	}
	return 0;
	}

	fprintf(stderr, "Unable to stat %s: %s\n", dirname, strerror(errno));
	return 1;
	}



	static void do_efi_decompress(ImageInfo img) {
	void *ibuf;
	void *sbuf;
	void *obuf;
	uint32_t isize;
	uint32_t ssize;
	uint32_t osize;
	EFI_STATUS r;

	ibuf = (void*)(img + 1);
	isize = img->compressed_size;

	r = EfiGetInfo(ibuf, isize, &osize, &ssize);
	if (EFI_SUCCESS != r) {
	fprintf(stderr, "EfiGetInfo() failed with code %d\n",
	r);
	return 0;
	}

	sbuf = malloc(ssize);
	if (!sbuf) {
	fprintf(stderr, "Can't allocate %d bytes: %s\n",
	ssize,
	strerror(errno));
	return 0;
	}

	obuf = malloc(osize);
	if (!obuf) {
	fprintf(stderr, "Can't allocate %d bytes: %s\n",
	osize,
	strerror(errno));
	free(sbuf);
	return 0;
	}

	r = EfiDecompress(ibuf, isize, obuf, osize, sbuf, ssize);
	if (r != EFI_SUCCESS) {
	fprintf(stderr, "EfiDecompress failed with code %d\n", r);
	free(obuf);
	free(sbuf);
	return 0;
	}

	free(sbuf);
	return obuf;
	}



	static void do_lzma_decompress(ImageInfo img) {
	void *ibuf;
	void *obuf;
	uint32_t isize;
	uint32_t osize;
	lzma_stream stream = LZMA_STREAM_INIT;
	lzma_ret result;

	ibuf = (void*)(img + 1);
	isize = img->compressed_size;
	osize = img->original_size;
	obuf = malloc(osize);
	if (!obuf) {
	fprintf(stderr, "Can't allocate %d bytes: %s\n",
	osize,
	strerror(errno));
	return 0;
	}

	result = lzma_auto_decoder(&stream, -1, 0);
	if (result != LZMA_OK) {
	fprintf(stderr, "Unable to initialize auto decoder (error: %d)!\n",
	result);
	free(obuf);
	return 0;
	}

	stream.next_in = ibuf;
	stream.avail_in = isize;
	stream.next_out = obuf;
	stream.avail_out = osize;
	result = lzma_code(&stream, LZMA_FINISH);
	if (result != LZMA_STREAM_END) {
	fprintf(stderr, "Unalbe to decode data (error: %d)!\n", result);
	free(obuf);
	return 0;
	}
	lzma_end(&stream);
	return obuf;
	}



	// Show what's inside. If todir is NULL, just print. Otherwise unpack.
	int dump_bmpblock(const char *infile, int show_as_yaml,
	const char *todir, int overwrite) {
	void ptr, data_ptr;
	size_t length = 0;
	BmpBlockHeader *hdr;
	ImageInfo *img;
	ScreenLayout *scr;
	int loc_num;
	int screen_num;
	int i;
	int offset;
	int free_data;
	char image_name[80];
	char full_path_name[PATH_MAX];
	int yfd, bfd;
	FILE *yfp = stdout;
	FILE *bfp = stdout;

	ptr = (void *)read_entire_file(infile, &length);
	if (!ptr)
	return 1;

	if (length < sizeof(BmpBlockHeader)) {
	fprintf(stderr, "File %s is too small to be a BMPBLOCK\n", infile);
	discard_file(ptr, length);
	return 1;
	}

	if (0 != memcmp(ptr, BMPBLOCK_SIGNATURE, BMPBLOCK_SIGNATURE_SIZE)) {
	fprintf(stderr, "File %s is not a BMPBLOCK\n", infile);
	discard_file(ptr, length);
	return 1;
	}

	if (todir) {
	// Unpacking everything. Create the output directory if needed.
	if (0 != require_dir(todir)) {
	discard_file(ptr, length);
	return 1;
	}

	// Open yaml output.
	show_as_yaml = 1;

	sprintf(full_path_name, "%s/%s", todir, "config.yaml");
	yfd = open(full_path_name,
	O_WRONLY \| O_CREAT \| O_TRUNC \| (overwrite ? 0 : O_EXCL),
	0666);
	if (yfd < 0) {
	fprintf(stderr, "Unable to open %s: %s\n", full_path_name,
	strerror(errno));
	discard_file(ptr, length);
	return 1;
	}

	yfp = fdopen(yfd, "wb");
	if (!yfp) {
	fprintf(stderr, "Unable to fdopen %s: %s\n", full_path_name,
	strerror(errno));
	close(yfd);
	discard_file(ptr, length);
	return 1;
	}
	}

	hdr = (BmpBlockHeader *)ptr;

	if (!show_as_yaml) {
	printf("%s:\n", infile);
	printf(" version %d.%d\n", hdr->major_version, hdr->minor_version);
	printf(" %d screens\n", hdr->number_of_screenlayouts);
	printf(" %d localizations\n", hdr->number_of_localizations);
	printf(" %d discrete images\n", hdr->number_of_imageinfos);
	discard_file(ptr, length);
	return 0;
	}

	// Write out yaml
	fprintf(yfp, "bmpblock: %d.%d\n", hdr->major_version, hdr->minor_version);
	offset = sizeof(BmpBlockHeader) +
	(sizeof(ScreenLayout) *
	hdr->number_of_localizations *
	hdr->number_of_screenlayouts);
	// FIXME(chromium-os:12134): The bmbblock structure allows each image to be
	// compressed differently, but we haven't provided a way for the yaml file to
	// specify that. Additionally, we allow the yaml file to specify a default
	// compression scheme for all images, but only if that line appears in the
	// yaml file before any images. Accordingly, we'll just check the first image
	// to see if it has any compression, and if it does, we'll write that out as
	// the default. When this bug is fixed, we should just write each image's
	// compression setting separately.
	img = (ImageInfo *)(ptr + offset);
	if (img->compression)
	fprintf(yfp, "compression: %d\n", img->compression);
	fprintf(yfp, "images:\n");
	for(i=0; i<hdr->number_of_imageinfos; i++) {
	img = (ImageInfo *)(ptr + offset);
	if (img->compressed_size) {
	sprintf(image_name, "img_%08x.bmp", offset);
	if (img->tag == TAG_HWID) {
	fprintf(yfp, " %s: %s # %dx%d %d/%d tag=%d fmt=%d\n",
	RENDER_HWID, image_name,
	img->width, img->height,
	img->compressed_size, img->original_size,
	img->tag, img->format);
	} else if (img->tag == TAG_HWID_RTOL) {
	fprintf(yfp, " %s: %s # %dx%d %d/%d tag=%d fmt=%d\n",
	RENDER_HWID_RTOL, image_name,
	img->width, img->height,
	img->compressed_size, img->original_size,
	img->tag, img->format);
	} else {
	fprintf(yfp, " img_%08x: %s # %dx%d %d/%d tag=%d fmt=%d\n",
	offset, image_name,
	img->width, img->height,
	img->compressed_size, img->original_size,
	img->tag, img->format);
	}
	if (todir) {
	sprintf(full_path_name, "%s/%s", todir, image_name);
	bfd = open(full_path_name,
	O_WRONLY \| O_CREAT \| O_TRUNC \| (overwrite ? 0 : O_EXCL),
	0666);
	if (bfd < 0) {
	fprintf(stderr, "Unable to open %s: %s\n", full_path_name,
	strerror(errno));
	fclose(yfp);
	discard_file(ptr, length);
	return 1;
	}
	bfp = fdopen(bfd, "wb");
	if (!bfp) {
	fprintf(stderr, "Unable to fdopen %s: %s\n", full_path_name,
	strerror(errno));
	close(bfd);
	fclose(yfp);
	discard_file(ptr, length);
	return 1;
	}
	switch(img->compression) {
	case COMPRESS_NONE:
	data_ptr = ptr + offset + sizeof(ImageInfo);
	free_data = 0;
	break;
	case COMPRESS_EFIv1:
	data_ptr = do_efi_decompress(img);
	if (!data_ptr) {
	fclose(bfp);
	fclose(yfp);
	discard_file(ptr, length);
	return 1;
	}
	free_data = 1;
	break;
	case COMPRESS_LZMA1:
	data_ptr = do_lzma_decompress(img);
	if (!data_ptr) {
	fclose(bfp);
	fclose(yfp);
	discard_file(ptr, length);
	return 1;
	}
	free_data = 1;
	break;
	default:
	fprintf(stderr, "Unsupported compression method encountered.\n");
	fclose(bfp);
	fclose(yfp);
	discard_file(ptr, length);
	return 1;
	}
	if (1 != fwrite(data_ptr, img->original_size, 1, bfp)) {
	fprintf(stderr, "Unable to write %s: %s\n", full_path_name,
	strerror(errno));
	fclose(bfp);
	fclose(yfp);
	discard_file(ptr, length);
	return 1;
	}
	fclose(bfp);
	if (free_data)
	free(data_ptr);
	}
	}
	offset += sizeof(ImageInfo);
	offset += img->compressed_size;
	// 4-byte aligned
	if ((offset & 3) > 0)
	offset = (offset & ~3) + 4;
	}
	fprintf(yfp, "screens:\n");
	for(loc_num = 0;
	loc_num < hdr->number_of_localizations;
	loc_num++) {
	for(screen_num = 0;
	screen_num < hdr->number_of_screenlayouts;
	screen_num++) {
	fprintf(yfp, " scr_%d_%d:\n", loc_num, screen_num);
	i = loc_num * hdr->number_of_screenlayouts + screen_num;
	offset = sizeof(BmpBlockHeader) + i * sizeof(ScreenLayout);
	scr = (ScreenLayout *)(ptr + offset);
	for(i=0; i<MAX_IMAGE_IN_LAYOUT; i++) {
	if (scr->images[i].image_info_offset) {
	ImageInfo *iptr =
	(ImageInfo *)(ptr + scr->images[i].image_info_offset);
	if (iptr->tag == TAG_HWID) {
	fprintf(yfp, " - [%d, %d, %s] # tag=%d fmt=%d c=%d %d/%d\n",
	scr->images[i].x, scr->images[i].y,
	RENDER_HWID, iptr->tag, iptr->format, iptr->compression,
	iptr->compressed_size, iptr->original_size);
	} else if (iptr->tag == TAG_HWID_RTOL) {
	fprintf(yfp, " - [%d, %d, %s] # tag=%d fmt=%d c=%d %d/%d\n",
	scr->images[i].x, scr->images[i].y,
	RENDER_HWID_RTOL, iptr->tag,
	iptr->format, iptr->compression,
	iptr->compressed_size, iptr->original_size);
	} else {
	fprintf(yfp, " - [%d, %d, img_%08x]"
	" # tag=%d fmt=%d c=%d %d/%d\n",
	scr->images[i].x, scr->images[i].y,
	scr->images[i].image_info_offset,
	iptr->tag, iptr->format, iptr->compression,
	iptr->compressed_size, iptr->original_size);
	}
	}
	}
	}
	}
	fprintf(yfp, "localizations:\n");
	for(loc_num = 0;
	loc_num < hdr->number_of_localizations;
	loc_num++) {
	fprintf(yfp, " - [");
	for(screen_num = 0;
	screen_num < hdr->number_of_screenlayouts;
	screen_num++) {
	fprintf(yfp, " scr_%d_%d", loc_num, screen_num);
	if (screen_num != hdr->number_of_screenlayouts - 1)
	fprintf(yfp, ",");
	}
	fprintf(yfp, " ]\n");
	}

	if (hdr->locale_string_offset) {
	char loc_ptr = (char )ptr + hdr->locale_string_offset;
	char c;
	fprintf(yfp, "locale_index:\n");
	while ((c = *loc_ptr) != '\0') {
	fprintf(yfp, " - ");
	do {
	fputc(c, yfp);
	loc_ptr++;
	} while((c = *loc_ptr) != '\0');
	loc_ptr++;
	fputc('\n', yfp);
	}
	}

	if (todir)
	fclose(yfp);

	discard_file(ptr, length);

	return 0;
	}