....

int flag_bsf = 1;

....

void
parse(GArray<GUTF8String> &argv)
{
.....

else if (argv[i] == "-bsf")
{
   if (++i >= argc)
      G_THROW( ERR_MSG("fi_c44.no_bsf_arg") );

   if (flag_bsf > 1)
      G_THROW( ERR_MSG("fi_c44.duplicate_bsf") );

   char *ptr;

   flag_bsf = strtol(argv[i], &ptr, 10);

   if (*ptr || flag_bsf<2 || flag_bsf>12)
      G_THROW( ERR_MSG("fi_c44.illegal_bsf") );
}
...
}

////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
//
//  WinDjView functions section
//
//	Copyright (C) 2004-2009 Andrew Zhezherun
//

struct VersionInfo
{
	VersionInfo();

	bool bNT, b2kPlus, bXPPlus, bVistaPlus;
};
static VersionInfo theVersionInfo;

VersionInfo::VersionInfo()
	: bNT(false), b2kPlus(false), bXPPlus(false), bVistaPlus(false)
{
	OSVERSIONINFO vi;
	vi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
	if (::GetVersionEx(&vi))
	{
		bNT = (vi.dwPlatformId == VER_PLATFORM_WIN32_NT);
		if (bNT)
		{
			b2kPlus = (vi.dwMajorVersion >= 5);
			bXPPlus = (vi.dwMajorVersion > 5 || vi.dwMajorVersion == 5 && vi.dwMinorVersion >= 1);
			bVistaPlus = (vi.dwMajorVersion >= 6);
		}
	}
}

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

bool IsWinXPOrLater()
{
	return theVersionInfo.bXPPlus;
}

int ReadUTF8Character(const char* str, int& nBytes)
{
	const unsigned char* s = reinterpret_cast<const unsigned char*>(str);
	unsigned char c = s[0];

	if (c < 0x80)
	{
		nBytes = 1;
		return c;
	}
	else if (c < 0xC2)
	{
		return -1;
	}
	else if (c < 0xE0)
	{
		if (s[1] == 0 || (s[1] ^ 0x80) >= 0x40)
			return -1;
		nBytes = 2;
		return ((s[0] & 0x1F) << 6) + (s[1] ^ 0x80);
	}
	else if (c < 0xF0)
	{
		if (s[1] == 0 || s[2] == 0 || (s[1] ^ 0x80) >= 0x40
				|| (s[2] ^ 0x80) >= 0x40 || (c == 0xE0 && s[1] < 0xA0))
			return -1;
		nBytes = 3;
		return ((s[0] & 0xF) << 12) + ((s[1] ^ 0x80) << 6) + (s[2] ^ 0x80);
	}
	else if (c < 0xF5)
	{
		if (s[1] == 0 || s[2] == 0 || s[3] == 0 || (s[1] ^ 0x80) >= 0x40
				|| (s[2] ^ 0x80) >= 0x40 || (s[3] ^ 0x80) >= 0x40
				|| (c == 0xF0 && s[1] < 0x90) || (c == 0xF4 && s[1] > 0x8F))
			return -1;
		nBytes = 4;
		return ((s[0] & 0x07) << 18) + ((s[1] ^ 0x80) << 12) + ((s[2] ^ 0x80) << 6)
				+ (s[3] ^ 0x80);
	}
	else
		return -1;
}

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

bool IsValidUTF8(const char* pszText)
{
	const char* s = pszText;
	while (*s != 0)
	{
		int nBytes = 0;
		if (ReadUTF8Character(s, nBytes) < 0)
			return false;
		s += nBytes;
	}

	return true;
}

////////////////////////////////////////////////////////////////////////////////////////////
//
// Convert GUTF8String to ASCII string:
//
// returns the lenght of the converted string
//
int MakeString(const GUTF8String& text, char* strResult)
{
	if (text.length() == 0)
		return 0;
	
	// Prepare Unicode text
	LPWSTR pszUnicodeText = NULL;
	int nResult = 0;
	
	// Bookmarks or annotations may not be encoded in UTF-8
	// (when file was created by old software)
	// Treat input string as non-UTF8 if it is not well-formed
	DWORD dwFlags = 0;
	
	// Only Windows XP supports checking for invalid characters in UTF8 encoding
	// inside MultiByteToWideChar function
	if (IsWinXPOrLater())
	{
		dwFlags |= MB_ERR_INVALID_CHARS;
	}
	
	// Make our own check anyway
	if (!IsValidUTF8(text))
	{
		strcpy(strResult,text);
		
		printf("%s\n","Not valid UTF8");
		
		return 0;
	}
	
	int nSize = ::MultiByteToWideChar(CP_UTF8, dwFlags, (LPCSTR)text, -1, NULL, 0);	
	
	if (nSize != 0)
	{
		pszUnicodeText = new WCHAR[nSize];
		nResult = ::MultiByteToWideChar(CP_UTF8, dwFlags, (LPCSTR)text, -1, pszUnicodeText, nSize);
	}
	
	if (nResult != 0)
	{
#ifdef _UNICODE
		// something may be implemented here (if needed)
		
		//strResult = pszUnicodeText;
#else
		// Prepare ANSI text
		nSize = ::WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK | WC_DISCARDNS,
			pszUnicodeText, -1, NULL, 0, NULL, NULL);
		if (nSize == 0)
		{
			delete[] pszUnicodeText;
			
			return 0;
		}
		
		if (nSize > MAX_PATH)
		{
			delete[] pszUnicodeText;			
			
			printf("Filepath is longer than %d symbols\n", MAX_PATH);
			
			return 0;
		}
		
		::WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK | WC_DISCARDNS,
			pszUnicodeText, -1, strResult, nSize+1, NULL, NULL);
		
#endif
	}
	else
	{		
		strcpy(strResult,text);
	}
	
	delete[] pszUnicodeText;
	
	return strlen(strResult);
}

//  End of the WinDjView functions section
//
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

// FreeImage routines:

////////////////////////////////////////////////////////////////////////////////
/**
FreeImage error handler
@param fif Format / Plugin responsible for the error 
@param message Error message
*/
void FreeImageErrorHandler(FREE_IMAGE_FORMAT fif, const char *message) {
	printf("\n*** "); 
	printf("%s Format\n", FreeImage_GetFormatFromFIF(fif));
	printf(message);
	printf(" ***\n");
}

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

/** Generic image loader

  @param lpszPathName Pointer to the full file name
  @param flag Optional load flag constant
  @return Returns the loaded dib if successful, returns NULL otherwise
*/

FIBITMAP* GenericLoader(const char* lpszPathName, int flag)
{	
	FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;
	// check the file signature and deduce its format
	// (the second argument is currently not used by FreeImage)
	
	fif = FreeImage_GetFileType(lpszPathName, 0);
	
	FIBITMAP* dib;
	
	if(fif == FIF_UNKNOWN)
	{
		// no signature ?
		// try to guess the file format from the file extension
		fif = FreeImage_GetFIFFromFilename(lpszPathName);
	}
	
	// check that the plugin has reading capabilities ...
	if((fif != FIF_UNKNOWN) && FreeImage_FIFSupportsReading(fif))
	{
		// ok, let's load the file
		dib = FreeImage_Load(fif, lpszPathName, flag);
		
		// unless a bad file format, we are done !
		if (!dib)
		{
			printf("%s%s%s\n","File \"", lpszPathName, "\" not found.");
			return NULL;
		}
	}	
	
	return dib;
}

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
//
// Main function:
//

int
main(int argc, char **argv)
{
	setlocale(LC_ALL,"");
	djvu_programname(argv[0]);
	GArray<GUTF8String> dargv(0,argc-1);
	for(int i=0;i<argc;++i)
		dargv[i]=GNativeString(argv[i]);
	G_TRY
    {
		// Parse arguments
		parse(dargv);
		
		FreeImage_SetOutputMessage(FreeImageErrorHandler);
		
		char strResult[MAX_PATH] = {0};
		
		MakeString(g().pnmurl.UTF8Filename(), strResult);
		
		// load a file into a universal FIBITMAP memory structure:
		
		FIBITMAP *dib;
		
		if (flag_bsf>1)
		{		
			FIBITMAP *dib_tmp = GenericLoader(strResult, 0);
			
			unsigned width  = FreeImage_GetWidth(dib_tmp);
			
			unsigned height = FreeImage_GetHeight(dib_tmp);
			
			dib = FreeImage_Rescale(dib_tmp, (int)((width+(flag_bsf-1))/flag_bsf), 
				(int)((height+(flag_bsf-1))/flag_bsf), FILTER_BICUBIC);
			
			FreeImage_Unload(dib_tmp);
		}	
		
		else
			
			dib = GenericLoader(LPCSTR(strResult), 0);
		
		if (FreeImage_GetImageType(dib) != FIT_BITMAP)
		{
			printf("Non-FIT_BITMAP images are not supported.\n");
			
			FreeImage_Unload(dib);
			
			return -2;
		}
		
		if (!(FreeImage_GetBPP(dib) == 24) &&
			
			!((FreeImage_GetBPP(dib) == 8) && (FreeImage_GetColorType(dib) != FIC_PALETTE)))
		{
			printf("Only 24-bit color or 8-bit greyscale images are supported.\n");
			
			FreeImage_Unload(dib);
			
			return -3;
		}
		
		// Load images		
		unsigned w = FreeImage_GetWidth(dib); // FIBITMAP width in pixels		
		unsigned h = FreeImage_GetHeight(dib); // FIBITMAP height in pixels		
		
		// Returns the width of the bitmap in bytes, rounded to the next 32-bit boundary,
		// also known as "pitch" or "stride" or "scan width".
		unsigned pitch = FreeImage_GetPitch(dib);
		
		BYTE* bits = (BYTE*)FreeImage_GetBits(dib); // the pointer to the 1 pixel
		// in the 1 pixel row (in FIBITMAP)		
		BYTE* lines;
		
		unsigned bpp = FreeImage_GetBPP(dib); // bitdepth, 24 - for color, 8 - for greyscale
		
		unsigned btpp = bpp/8;
		
		GP<IW44Image> iw;
		
		//Just create a GPixmap of size w*h 		
		GP<GPixmap> gipm = GPixmap::create(h,w);
		
		//and fill it with the RGB data:
		unsigned i,j;
		
		for (j=0;j<h;j++)
		{ 
			GPixel *row = (*gipm)[j]; 
			
			lines = bits + j * pitch;
			
			for (i=0; i<w; i++)
			{ 
				GPixel p; 
				
				if (btpp == 3) // color 24 bit
				{
					p.r = lines[FI_RGBA_RED]; // red byte
					p.g = lines[FI_RGBA_GREEN]; // green byte
					p.b = lines[FI_RGBA_BLUE]; // blue byte
					
					row[i] = p;
					
					lines += btpp;
					
				}
				else if (btpp == 1) // greyscale 8 bit
				{
					p.r = lines[i]; // red byte
					p.g = lines[i]; // green byte
					p.b = lines[i]; // blue byte
					
					row[i] = p;
				}
			}
		}
		
		GPixmap &ipm=*gipm;
		
		int bm_size = w*h*btpp;
		
		// Change percent specification into size specification
		if (flag_size && flag_percent)
			for (int i=0; i<argc_size; i++)
				argv_size[i] = (argv_size[i]*bm_size)/ 100;
			
			flag_percent = 0;
			
			iw = IW44Image::create_encode(ipm, getmask(w,h), arg_crcbmode);
			
			// Perform compression PM44 or BM44 as required
			if (iw)
			{
				g().iw4url.deletefile();
				GP<IFFByteStream> iff =
					IFFByteStream::create(ByteStream::create(g().iw4url,"wb"));
				if (flag_crcbdelay >= 0)
					iw->parm_crcbdelay(flag_crcbdelay);
				if (flag_dbfrac > 0)
					iw->parm_dbfrac((float)flag_dbfrac);
				int nchunk = resolve_quality(w*h);
				// Create djvu file
				create_photo_djvu_file(*iw, w, h, *iff, nchunk, g().parms);
			}
			
			FreeImage_Unload(dib);
    }
	G_CATCH(ex)
    {
		ex.perror();
		exit(1);
    }
	G_ENDCATCH;
	return 0;
}

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

        row[i] = p;

        lines += btpp;
    }
   else if (btpp == 1) // greyscale 8 bit
    {
        p.r = lines[i]; // red byte
        p.g = lines[i]; // green byte
        p.b = lines[i]; // blue byte

        row[i] = p;
    }
}