int main(const int argc, const char **argv){
initstdio();
if(argc<2){
fprintf(stderr,
"codeiq124 in.bmp >out.txt\n"
"codeiq124 io.bmp <in.txt\n"
);
return -1;
}
int pixels=0,count=0,color,last;
if(isatty(fileno(stdin))){ //decode
struct stat st;
int x,y;
FILE *in=fopen(argv[1],"rb");
if(!in){
fprintf(stderr,"cannot open %s\n",argv[2]);
return 1;
}
fstat(fileno(in),&st);
void *imgbuf=malloc(st.st_size);
fread(imgbuf,1,st.st_size,in);
fclose(in);
bmp_image gif;
bmp_bitmap_callback_vt vt={
bitmap_create,
bitmap_destroy,
bitmap_set_suspendable,
bitmap_get_buffer,
bitmap_get_bpp
};
bmp_create(&gif,&vt);
if(bmp_analyse(&gif, st.st_size, imgbuf)||bmp_decode(&gif)){fprintf(stderr,"decode error\n");bmp_finalise(&gif);free(imgbuf);return 1;}
free(imgbuf);
for(y=0;y<gif.height;y++){
for(x=0;x<gif.width;x++){
u32 coor=y*gif.width+x;
u8 b=((((u32*)gif.bitmap)[coor]&0xff0000)>>16)&0xff;
u8 g=((((u32*)gif.bitmap)[coor]&0x00ff00)>>8)&0xff;
u8 r=((((u32*)gif.bitmap)[coor]&0x0000ff)>>0)&0xff;
u8 mes=((r&7)<<5)|((g&3)<<3)|((b&7)<<0);
if(!mes)break;
putchar(mes);
}
}
bmp_finalise(&gif);
}else{ //encode
int main(const int argc, const char **argv){
initstdio();
#else
int zlibrawstdio2(const int argc, const char **argv){
#endif
char mode,level;
if(argc<2)goto argerror;
mode=argv[1][0],level=argv[1][1];
if(!mode)goto argerror;
if(mode=='-')mode=argv[1][1],level=argv[1][2];
if(mode!='e'&&mode!='c'&&mode!='d')goto argerror;
if(isatty(fileno(stdin))&&isatty(fileno(stdout)))goto argerror;
return mode=='d'?_decompress(stdin,stdout):_compress(stdin,stdout,level?level-'0':9);
argerror:
fprintf(stderr,"zlibrawstdio2 e/d < in > out\nYou can also use -e,-c,-d.\n");
if(!lzmaOpen7z())fprintf(stderr,"\nNote: 7-zip is AVAILABLE.\n"),lzmaClose7z();
else fprintf(stderr,"\nNote: 7-zip is NOT available.\n");
return -1;
}
PyThreadState *
Py_NewInterpreter(void)
{
PyInterpreterState *interp;
PyThreadState *tstate, *save_tstate;
PyObject *bimod, *sysmod;
if (!initialized)
Py_FatalError("Py_NewInterpreter: call Py_Initialize first");
#ifdef WITH_THREAD
/* Issue #10915, #15751: The GIL API doesn't work with multiple
interpreters: disable PyGILState_Check(). */
_PyGILState_check_enabled = 0;
#endif
interp = PyInterpreterState_New();
if (interp == NULL)
return NULL;
tstate = PyThreadState_New(interp);
if (tstate == NULL) {
PyInterpreterState_Delete(interp);
return NULL;
}
save_tstate = PyThreadState_Swap(tstate);
/* XXX The following is lax in error checking */
interp->modules = PyDict_New();
bimod = _PyImport_FindBuiltin("builtins");
if (bimod != NULL) {
interp->builtins = PyModule_GetDict(bimod);
if (interp->builtins == NULL)
goto handle_error;
Py_INCREF(interp->builtins);
}
/* initialize builtin exceptions */
_PyExc_Init(bimod);
sysmod = _PyImport_FindBuiltin("sys");
if (bimod != NULL && sysmod != NULL) {
PyObject *pstderr;
interp->sysdict = PyModule_GetDict(sysmod);
if (interp->sysdict == NULL)
goto handle_error;
Py_INCREF(interp->sysdict);
PySys_SetPath(Py_GetPath());
PyDict_SetItemString(interp->sysdict, "modules",
interp->modules);
/* Set up a preliminary stderr printer until we have enough
infrastructure for the io module in place. */
pstderr = PyFile_NewStdPrinter(fileno(stderr));
if (pstderr == NULL)
Py_FatalError("Py_Initialize: can't set preliminary stderr");
_PySys_SetObjectId(&PyId_stderr, pstderr);
PySys_SetObject("__stderr__", pstderr);
Py_DECREF(pstderr);
_PyImportHooks_Init();
import_init(interp, sysmod);
if (initfsencoding(interp) < 0)
goto handle_error;
if (initstdio() < 0)
Py_FatalError(
"Py_Initialize: can't initialize sys standard streams");
initmain(interp);
if (!Py_NoSiteFlag)
initsite();
}
if (!PyErr_Occurred())
return tstate;
handle_error:
/* Oops, it didn't work. Undo it all. */
PyErr_PrintEx(0);
PyThreadState_Clear(tstate);
PyThreadState_Swap(save_tstate);
PyThreadState_Delete(tstate);
PyInterpreterState_Delete(interp);
return NULL;
}
void
_Py_InitializeEx_Private(int install_sigs, int install_importlib)
{
PyInterpreterState *interp;
PyThreadState *tstate;
PyObject *bimod, *sysmod, *pstderr;
char *p;
extern void _Py_ReadyTypes(void);
if (initialized)
return;
initialized = 1;
_Py_Finalizing = NULL;
#if defined(HAVE_LANGINFO_H) && defined(HAVE_SETLOCALE)
/* Set up the LC_CTYPE locale, so we can obtain
the locale's charset without having to switch
locales. */
setlocale(LC_CTYPE, "");
#endif
if ((p = Py_GETENV("PYTHONDEBUG")) && *p != '\0')
Py_DebugFlag = add_flag(Py_DebugFlag, p);
if ((p = Py_GETENV("PYTHONVERBOSE")) && *p != '\0')
Py_VerboseFlag = add_flag(Py_VerboseFlag, p);
if ((p = Py_GETENV("PYTHONOPTIMIZE")) && *p != '\0')
Py_OptimizeFlag = add_flag(Py_OptimizeFlag, p);
if ((p = Py_GETENV("PYTHONDONTWRITEBYTECODE")) && *p != '\0')
Py_DontWriteBytecodeFlag = add_flag(Py_DontWriteBytecodeFlag, p);
/* The variable is only tested for existence here; _PyRandom_Init will
check its value further. */
if ((p = Py_GETENV("PYTHONHASHSEED")) && *p != '\0')
Py_HashRandomizationFlag = add_flag(Py_HashRandomizationFlag, p);
_PyRandom_Init();
interp = PyInterpreterState_New();
if (interp == NULL)
Py_FatalError("Py_Initialize: can't make first interpreter");
tstate = PyThreadState_New(interp);
if (tstate == NULL)
Py_FatalError("Py_Initialize: can't make first thread");
(void) PyThreadState_Swap(tstate);
#ifdef WITH_THREAD
/* We can't call _PyEval_FiniThreads() in Py_FinalizeEx because
destroying the GIL might fail when it is being referenced from
another running thread (see issue #9901).
Instead we destroy the previously created GIL here, which ensures
that we can call Py_Initialize / Py_FinalizeEx multiple times. */
_PyEval_FiniThreads();
/* Auto-thread-state API */
_PyGILState_Init(interp, tstate);
#endif /* WITH_THREAD */
_Py_ReadyTypes();
if (!_PyFrame_Init())
Py_FatalError("Py_Initialize: can't init frames");
if (!_PyLong_Init())
Py_FatalError("Py_Initialize: can't init longs");
if (!PyByteArray_Init())
Py_FatalError("Py_Initialize: can't init bytearray");
if (!_PyFloat_Init())
Py_FatalError("Py_Initialize: can't init float");
interp->modules = PyDict_New();
if (interp->modules == NULL)
Py_FatalError("Py_Initialize: can't make modules dictionary");
/* Init Unicode implementation; relies on the codec registry */
if (_PyUnicode_Init() < 0)
Py_FatalError("Py_Initialize: can't initialize unicode");
if (_PyStructSequence_Init() < 0)
Py_FatalError("Py_Initialize: can't initialize structseq");
bimod = _PyBuiltin_Init();
if (bimod == NULL)
Py_FatalError("Py_Initialize: can't initialize builtins modules");
_PyImport_FixupBuiltin(bimod, "builtins");
interp->builtins = PyModule_GetDict(bimod);
if (interp->builtins == NULL)
Py_FatalError("Py_Initialize: can't initialize builtins dict");
Py_INCREF(interp->builtins);
/* initialize builtin exceptions */
_PyExc_Init(bimod);
sysmod = _PySys_Init();
if (sysmod == NULL)
Py_FatalError("Py_Initialize: can't initialize sys");
interp->sysdict = PyModule_GetDict(sysmod);
if (interp->sysdict == NULL)
Py_FatalError("Py_Initialize: can't initialize sys dict");
Py_INCREF(interp->sysdict);
_PyImport_FixupBuiltin(sysmod, "sys");
PySys_SetPath(Py_GetPath());
PyDict_SetItemString(interp->sysdict, "modules",
interp->modules);
/* Set up a preliminary stderr printer until we have enough
infrastructure for the io module in place. */
pstderr = PyFile_NewStdPrinter(fileno(stderr));
if (pstderr == NULL)
Py_FatalError("Py_Initialize: can't set preliminary stderr");
_PySys_SetObjectId(&PyId_stderr, pstderr);
PySys_SetObject("__stderr__", pstderr);
Py_DECREF(pstderr);
_PyImport_Init();
_PyImportHooks_Init();
/* Initialize _warnings. */
_PyWarnings_Init();
if (!install_importlib)
return;
if (_PyTime_Init() < 0)
Py_FatalError("Py_Initialize: can't initialize time");
import_init(interp, sysmod);
/* initialize the faulthandler module */
if (_PyFaulthandler_Init())
Py_FatalError("Py_Initialize: can't initialize faulthandler");
if (initfsencoding(interp) < 0)
Py_FatalError("Py_Initialize: unable to load the file system codec");
if (install_sigs)
initsigs(); /* Signal handling stuff, including initintr() */
if (_PyTraceMalloc_Init() < 0)
Py_FatalError("Py_Initialize: can't initialize tracemalloc");
initmain(interp); /* Module __main__ */
if (initstdio() < 0)
Py_FatalError(
"Py_Initialize: can't initialize sys standard streams");
/* Initialize warnings. */
if (PySys_HasWarnOptions()) {
PyObject *warnings_module = PyImport_ImportModule("warnings");
if (warnings_module == NULL) {
fprintf(stderr, "'import warnings' failed; traceback:\n");
PyErr_Print();
}
Py_XDECREF(warnings_module);
}
if (!Py_NoSiteFlag)
initsite(); /* Module site */
}
int main(const int argc, const char **argv){
initstdio();
#else
int _7ciso(const int argc, const char **argv){
#endif
int cmode=0,mode=0;
int zlib=0,sevenzip=0,zopfli=0,miniz=0,slz=0,libdeflate=0;
int threshold=100;
poptContext optCon;
int optc;
struct poptOption optionsTable[] = {
//{ "longname", "shortname", argInfo, *arg, int val, description, argment description}
{ "stdout", 'c', POPT_ARG_NONE, &cmode, 0, "stdout (currently ignored)", NULL },
{ "zlib", 'z', POPT_ARG_INT|POPT_ARGFLAG_OPTIONAL, NULL, 'z', "1-9 (default 6) zlib", "level" },
{ "miniz", 'm', POPT_ARG_INT|POPT_ARGFLAG_OPTIONAL, NULL, 'm', "1-2 (default 1) miniz", "level" },
{ "slz", 's', POPT_ARG_INT|POPT_ARGFLAG_OPTIONAL, NULL, 's', "1-1 (default 1) slz", "level" },
{ "libdeflate", 'l', POPT_ARG_INT|POPT_ARGFLAG_OPTIONAL, NULL, 'l', "1-12 (default 6) libdeflate", "level" },
{ "7zip", 'S', POPT_ARG_INT|POPT_ARGFLAG_OPTIONAL, NULL, 'S', "1-9 (default 2) 7zip", "level" },
{ "zopfli", 'Z', POPT_ARG_INT, &zopfli, 0, "zopfli", "numiterations" },
{ "threshold", 't', POPT_ARG_INT, &threshold, 0, "compression threshold (in %, 10-100)", "threshold" },
{ "decompress", 'd', POPT_ARG_NONE, &mode, 0, "decompress", NULL },
POPT_AUTOHELP,
POPT_TABLEEND,
};
optCon = poptGetContext(argv[0], argc, argv, optionsTable, 0);
poptSetOtherOptionHelp(optCon, "{-z9 dec.iso enc.cso} or {-cd <enc.cso >dec.iso}");
for(;(optc=poptGetNextOpt(optCon))>=0;){
switch(optc){
case 'z':{
char *arg=poptGetOptArg(optCon);
if(arg)zlib=strtol(arg,NULL,10),free(arg);
else zlib=6;
break;
}
case 'm':{
char *arg=poptGetOptArg(optCon);
if(arg)miniz=strtol(arg,NULL,10),free(arg);
else miniz=1;
break;
}
case 's':{
char *arg=poptGetOptArg(optCon);
if(arg)slz=strtol(arg,NULL,10),free(arg);
else slz=1;
break;
}
case 'l':{
char *arg=poptGetOptArg(optCon);
if(arg)libdeflate=strtol(arg,NULL,10),free(arg);
else libdeflate=1;
break;
}
case 'S':{
char *arg=poptGetOptArg(optCon);
if(arg)sevenzip=strtol(arg,NULL,10),free(arg);
else sevenzip=2;
break;
}
}
}
int level_sum=zlib+sevenzip+zopfli+miniz+slz+libdeflate;
if(
optc<-1 ||
(!mode&&!zlib&&!sevenzip&&!zopfli&&!miniz&&!slz&&!libdeflate) ||
(mode&&(zlib||sevenzip||zopfli||miniz||slz||libdeflate)) ||
(!mode&&(level_sum==zlib)+(level_sum==sevenzip)+(level_sum==zopfli)+(level_sum==miniz)+(level_sum==slz)+(level_sum==libdeflate)!=1)
){
poptPrintHelp(optCon, stderr, 0);
poptFreeContext(optCon);
if(!lzmaOpen7z())fprintf(stderr,"\nNote: 7-zip is AVAILABLE.\n"),lzmaClose7z();
else fprintf(stderr,"\nNote: 7-zip is NOT available.\n");
return 1;
}
if(mode){
if(isatty(fileno(stdin))||isatty(fileno(stdout)))
{poptPrintHelp(optCon, stderr, 0);poptFreeContext(optCon);return -1;}
poptFreeContext(optCon);
//lzmaOpen7z();
int ret=_decompress(stdin,stdout);
//lzmaClose7z();
return ret;
}else{
if(threshold<10)threshold=10;
if(threshold>100)threshold=100;
const char *fname=poptGetArg(optCon);
if(!fname){poptPrintHelp(optCon, stderr, 0);poptFreeContext(optCon);return -1;}
FILE *in=fopen(fname,"rb");
if(!in){fprintf(stderr,"failed to open %s\n",fname);poptFreeContext(optCon);return 2;}
fname=poptGetArg(optCon);
if(!fname){poptPrintHelp(optCon, stderr, 0);poptFreeContext(optCon);return -1;}
FILE *out=fopen(fname,"wb");
if(!out){fclose(in);fprintf(stderr,"failed to open %s\n",fname);poptFreeContext(optCon);return 2;}
poptFreeContext(optCon);
fprintf(stderr,"compression level = %d ",level_sum);
int ret=0;
if(zlib){
fprintf(stderr,"(zlib)\n");
ret=_compress(in,out,zlib,DEFLATE_ZLIB,threshold);
}else if(sevenzip){
fprintf(stderr,"(7zip)\n");
if(lzmaOpen7z()){
fprintf(stderr,"7-zip is NOT available.\n");
return -1;
}
ret=_compress(in,out,sevenzip,DEFLATE_7ZIP,threshold);
lzmaClose7z();
}else if(zopfli){
fprintf(stderr,"(zopfli)\n");
ret=_compress(in,out,zopfli,DEFLATE_ZOPFLI,threshold);
}else if(miniz){
fprintf(stderr,"(miniz)\n");
ret=_compress(in,out,miniz,DEFLATE_MINIZ,threshold);
}else if(slz){
fprintf(stderr,"(slz)\n");
ret=_compress(in,out,slz,DEFLATE_SLZ,threshold);
}else if(libdeflate){
fprintf(stderr,"(libdeflate)\n");
ret=_compress(in,out,libdeflate,DEFLATE_LIBDEFLATE,threshold);
}
fclose(in),fclose(out);
return ret;
}
}
