JNG ग्राफिक प्रारूप - यह कितना उपयोगी है, यह कैसे काम करता है, कैसे कन्वर्ट करें, देखें और डाउनलोड करें

तस्वीर में एक बहुत ही उपयुक्त नाम के साथ एक तुर्की स्नाइपर राइफल दिखाई देता है - जेएनजी। लेख, आपने अनुमान लगाया कि यह जेएनजी ग्राफिक प्रारूप के बारे में होगा, न कि हथियारों के बारे में। इस प्रारूप से संबंधित विषय पहले ही हब पर फ़्लिकर कर चुके हैं; हालाँकि, कई नहीं थे, और कुछ, दुर्भाग्य से, बाद में लेखकों द्वारा हटा दिए गए थे। इस तथ्य के बावजूद कि जेएनजी एक बहुत लोकप्रिय प्रारूप नहीं है और एमएनजी प्रारूप पर आधारित है, जिसे, जाहिर है, मृत जन्म माना जा सकता है, जेएनजी के पास एक बहुत अच्छी संपत्ति है - यह एक उच्च स्तर की हानिपूर्ण ग्राफिक्स संपीड़न प्लस एक अल्फा चैनल की शुरुआत है।
संक्षेप में, JNG MNG प्रारूप का सबसेट है (हालांकि, हेडर में अपने स्वयं के मार्कर के साथ, जो इन दोनों स्वरूपों को अलग करने की अनुमति देता है)। रंग डेटा जेपीईजी प्रारूप में सहेजा जाता है, लेकिन अल्फा को दो विकल्पों में से एक में संग्रहीत किया जा सकता है - या तो जेपीईजी का उपयोग करके संपीड़ित किया जाता है, ग्रेस्केल में चित्र की तरह, या पीएनजी में उसी का उपयोग कर - दोषरहित संपीड़न।
जेएनजी कहां काम आ सकता है? मेरे लिए, यह मोबाइल गेम में बनावट एटलस के भंडारण के लिए सबसे उपयुक्त था। एक छोटा उदाहरण - गेम से सेट किए गए मूल ग्राफिक्स का वजन 57 मेगाबाइट था, सभी पीएनजी को जिंज के साथ बदलने के बाद - ग्राफिक्स सेट का वजन 15 मेगाबाइट से शुरू हुआ। मोबाइल गेम के लिए एक अच्छी जीत। मैं अन्य क्षेत्रों के लिए खोज करने के लिए पाठक पर छोड़ देता हूं, जहां jng लागू किया जा सकता है, लेकिन मैं वर्णन करूंगा कि कैसे देखना है, कैसे बनाना है, और कैसे लोड करना है (C / C ++ कोड के उदाहरण के साथ) JNG चित्र, साथ ही साथ इसकी संरचना के बारे में थोड़ा सिद्धांत भी।

JNG तस्वीरें कैसे देखें?

- XnView (http://www.xnview.com/) - प्लगइन स्थापित करने के बाद आपको JNG खोलने की अनुमति देता है।
- इरफानव्यू (http://www.irfanview.com/) - को भी प्लग-इन की आवश्यकता होती है (पैक में अन्य प्रारूपों के एक समूह के साथ आता है)।

जेएनजी प्रारूप में ग्राफिक्स कैसे बचाएं?

सबसे पहले, फ़ोटोशॉप के लिए एक प्लगइन है - download.fyxm.net/JNG-Format-8069.html । ऐसा लगता है कि वह विशेष रूप से विकसित नहीं हो रहा है, लेकिन फिर भी वह अपना काम करता है।
दूसरे, आप काफी प्रसिद्ध खुला स्रोत उपयोगिता का उपयोग कर सकते हैं - ImageMagic (http://www.imagemagick.org)
JNG प्रारूप के साथ काम करते हुए, मैंने एक साधारण कनवर्टर लिखा जो आपको png को jng में बदलने की अनुमति देता है - code.google.com/p/png2jng/downloads/list
(कनवर्टर विंडोज़ के लिए बनाया गया है, हालांकि, <tchar.h> से कार्यों के प्रतिस्थापन के बारे में थोड़ा छीलने के बाद इसे किसी अन्य प्लेटफॉर्म के लिए बनाया जा सकता है)।
मेरे कार्यक्रम के minuses की:
- मैंने 16 बिट पीएनजी / jng को समाप्त नहीं किया (मुझे ऐसी बिटनेस का समर्थन करने की आवश्यकता नहीं है);
- संपीड़न से पहले अल्फा चैनल डेटा फ़िल्टरिंग का उपयोग न करें। PNG फ़िल्टर के लिए संभावित रूप से जोड़ने का समर्थन अल्फा चैनल के संपीड़न की बेहतर डिग्री प्राप्त कर सकता है।

JNG लोड कैसे करें?

libmng

Libmng sourceforge.net/projects/libmng का उपयोग करें
पेशेवरों:
- यह काफी अच्छी तरह से मौजूद है;
- न केवल jng बल्कि एनिमेटेड mng लोड कर सकते हैं;
- mng / jng Pictures बनाने के लिए एक कोड भी है।
विपक्ष:
- बड़ी और भारी लाइब्रेरी
- ग्राफिक्स लोड करने के लिए एक बल्कि भ्रमित करने वाला एपीआई, जिसे एनीमेशन के लिए डिज़ाइन किया गया है;
- पंक्तियों में चित्र पढ़ने में असमर्थता;
- स्मृति से पर्याप्त रूप से ग्लूटोनस।
इसके अलावा libmng को jpeglib और zlib की आवश्यकता होती है।
यदि आप libmng का उपयोग करने का निर्णय लेते हैं - तो इसका उपयोग करने वाले ग्राफिक्स लोड करने पर एक छोटा सा उदाहरण है।
आप यहां उदाहरण के पूरे स्रोत कोड पा सकते हैं - code.google.com/p/png2jng/source/browse/trunk/jngdump/jngdump.cpp (png2jng के भाग के रूप में)
यहां मैं मुख्य बिंदुओं का वर्णन करूंगा।

पहला कदम लाइब्रेरी को इनिशियलाइज़ करना और आवश्यक न्यूनतम कॉलबैक सेट करना है।
छवि को लोड करने की सुविधा के लिए, मैंने ऐसी संरचना को परिभाषित किया, जिसे मैं उपयोगकर्ता पैरामीटर से कॉलबैक में जाता हूं:

struct mng_info { FILE* file;//    mng_uint32 width; mng_uint32 height; mng_uint32 timer; unsigned char* pixels; }; 

इसलिए - libmng को इनिशियलाइज़ करना

 /*        ,     mng_handle.          ,       .   – libmng   ,       ,         (  –  calloc,   memset   ). */ mng_handle hmng; mng_info mngInfo; mng_retcode retCode; hmng = mng_initialize(&mngInfo, mymngalloc, mymngfree, MNG_NULL); /*  */ /* */ Mng_setcb_errorproc(hmng, mymngerror); /*     .   ,     .*/ mng_setcb_openstream(hmng, mymngopenstream); /* */ mng_setcb_closestream(hmng, mymngclosestream); /* */ mng_setcb_readdata(hmng, mymngreadstream); /*  –         ,  ,     */ mng_setcb_processheader(hmng, mymngprocessheader); /*   libmng        */ mng_setcb_getcanvasline(hmng, mymnggetcanvasline); /*  .   ,        ,   .      – . */ mng_setcb_gettickcount(hmng, mymnggettickcount); /* .   ,      . */ mng_setcb_settimer(hmng, mymngsettimer); /*  libmng  ,      .        ,     getcanvasline ,       .*/ mng_setcb_refresh(hmng, mymngimagerefresh); 

कॉलबैक में से, मैं यहां केवल उन्हीं को दूंगा जो सबसे बड़ी रुचि रखते हैं

 /*   */ static mng_bool mymngreadstream(mng_handle mng, mng_ptr buffer, mng_uint32 size, mng_uint32 *bytesread) { mng_info *mymng = (mng_info*)mng_get_userdata(mng); *bytesread = fread(buffer, 1, size, mymng->file); return MNG_TRUE; } mng_bool mymngprocessheader (mng_handle hHandle, mng_uint32 iWidth, mng_uint32 iHeight) { mng_info* mngInfo = (mng_info*)mng_get_userdata (hHandle); /*   */ if (mng_set_canvasstyle (hHandle, MNG_CANVAS_RGBA8)) { /* */ return MNG_FALSE; } mngInfo->width = iWidth; mngInfo->height = iHeight; mngInfo->image = new unsigned char[iWidth * 4 * iHeight];//    return MNG_TRUE; } mng_ptr mymnggetcanvasline(mng_handle hHandle, mng_uint32 iLinenr) { mng_info* mngInfo = (mng_info*)mng_get_userdata (hHandle); /*    */ return mngInfo->image + mngInfo-> width * 4 * iLinenr; } 

छवि डाउनलोड करें।

 /*        .*/ /*        mng */ retCode = mng_read(hmng); /* –     JNG.         MNG*/ if(mng_get_sigtype (hmng) != mng_it_jng) { /* –   */ } 

अब हमें वास्तव में डिकोड किए गए पिक्सेल प्राप्त करने की आवश्यकता है।
अब तक, सब कुछ कुछ पुस्तकालयों जैसे कि libng या jpeglib की याद दिलाता है।
अगला मौलिक अंतर आता है, क्योंकि libmng मूल रूप से एनिमेटेड छवियों के लिए डिज़ाइन किया गया था।

 /*  mng_display_resume  libmng      */ retCode = mng_display(hmng); while((retCode == MNG_NEEDTIMERWAIT) && (mngInfo.timer <= 1)) { retCode = mng_display_resume(hmng); } /*   –     pixels   mng_info*/ 

वह सब कुछ है जो libmng द्वारा आवंटित संसाधनों को साफ करने के लिए है

 mng_cleanup(&hmng); 

खैर, हमारे धागे बंद करने के लिए मत भूलना, स्मृति को मुक्त करना, आदि।

जैसा कि आप देख सकते हैं, कुछ भी जटिल नहीं है। हालांकि, मेरे मामले में, libmng की एक विशेषता घातक हो गई, और मुझे साइकिल चलाने के लिए मजबूर कर दिया।
तथ्य यह है कि जब एक चित्र को डिकोड किया जाता है, तो libmng अपने अंदर चौड़ाई * bpp * ऊंचाई के बराबर बफर आवंटित करता है। खदान में, मुझे बनावट को 5548 में 5548x2048 लोड करना था। लिबमंग स्वयं इस प्रारूप का समर्थन नहीं करता है। यह पता चला है कि मुझे 2048 * 2048 * 4 बफर आवंटित करना था, इसे इसमें लोड करना था, और फिर इसे डबल-बाइट प्रारूप में स्थानांतरित करना था। यह 32 मेगाबाइट का ओवरहेड निकला (साथ ही छवि फ़ाइल का वजन भी, क्योंकि यह संग्रह से लिया गया है)! कुछ बिंदु पर, खेल बस स्मृति से बाहर चला गया। Libmng के बहुत ही उलझी हुई इंटर्नल के माध्यम से खुदाई करने पर, मुझे एहसास हुआ कि मैं इस समस्या को दूर नहीं कर सकता हूँ और एक तरफ देखने का फैसला किया है - और अगर मैं अपने आप को अपलोड नहीं कर सकता, बिना libmng की मदद के, खासकर जब से प्रारूप स्वयं विशेष रूप से डरावना नहीं दिखता, लेकिन हब पर एक लेख था (दुर्भाग्य से यह पहले ही हटा दिया गया था) जहां उन्होंने एक समान चाल की, लेकिन केवल ब्राउज़र में।

libjng

इसलिए मैंने libjng को जन्म दिया ( code.google.com/p/libjng ) - एक साधारण पुस्तकालय जो केवल यह जानता है कि jng कैसे लोड करना है। पुस्तकालय बहुत बड़ा शब्द है। वास्तव में, इसमें एक हेडर फ़ाइल और एक फ़ाइल शामिल है - सी में स्रोत।

पेशेवरों:
- एपीआई का उपयोग करना आसान;
- कॉम्पैक्ट - हेडर फ़ाइल के साथ स्रोत - 74 किलोबाइट (थोड़ा अधिक बाइनरी);
- आप बिट आकार को बदलने के बिना अल्फा चैनल डाउनलोड करने की अनुमति देता है (सुविधाजनक है जब आपको 5551 जैसे प्रारूपों में लोड करने की आवश्यकता होती है);
- और सबसे महत्वपूर्ण बात - आपको फ़ाइल लाइन को लाइन से डीकोड करने की अनुमति देता है, जैसे लिबपंज और जेपग्लिब;
- डेटा को डुप्लिकेट किए बिना, बफर से सीधे एक तस्वीर को डीकोड कर सकते हैं, और आप कॉलबैक स्थापित करके धाराओं से ब्लॉक उतार सकते हैं।
नुकसान:
- हम नहीं जानते कि प्रति चैनल 16 बिट्स में डेटा कैसे आउटपुट करें (हालांकि सिद्धांत रूप में, लोड jng जहां JPEG प्रति नमूना 12 बिट्स होगा, या अल्फा 16 बिट्स होगा - यह काम करना चाहिए)
- तीसरे पक्ष के पुस्तकालयों पर भी निर्भर है - जेपीग्लिब, ज़्लिब।

रिपॉजिटरी में लाइब्रेरी के साथ जगह में एक छोटा सा उदाहरण है जो आपको jga और डंप पिक्सेल को टैगा प्रारूप में लोड करने की अनुमति देता है (क्योंकि यह सबसे सरल ग्राफिक्स प्रारूप है)।

Libjng का उपयोग करने का एक संक्षिप्त उदाहरण (केस का उपयोग करें जब पूरी तस्वीर पहले से ही मेमोरी में लोड है)।

 /*  */ #include "jng_load.h" /*  –  */ void* my_jng_alloc(size_t size) { return malloc(size); } void my_jng_free(void* ptr) { free(ptr); } void my_jng_errorproc(jng_handle handle, int errorCode, unsigned long chunkName, unsigned long chunkSeq, const char* erorText) { printf("JNG error %d! chunk = %d, chunkSeq = %d, text = %s\r\n", errorCode, chunkName, chunkSeq, erorText); } /* imageSize –  ,    imageBuffer –     */ jng_handle handle; handle = jng_create_from_data(NULL, imageBuffer, imageSize, my_jng_alloc, my_jng_free, my_jng_errorproc, JNG_FLAG_CRC_CRITICAL);/*     crc    .*/ if(!handle) { /*    –    ,  .      errorproc */ } /*   .   , ,    .*/ if(!jng_read(handle)) { jng_cleanup(handle); /* */ } /*   */ imageWidth = jng_get_image_width(handle); imageHeight = jng_get_image_height(handle); /*  ,     */ jng_set_out_alpha_channel_bits(handle, JNG_OUT_BITS_8); jng_set_out_color_channel_bits(handle, JNG_OUT_BITS_8); jng_set_out_color_space(handle, JNG_RGB); jng_set_color_jpeg_src_type(handle, JNG_JPEG_SRC_DEFAULT);/*,       8  12  jpeg  – JNG     */ /*  –  ()  jpeg   png,   */ if(!jng_start_decode(handle)) { jng_cleanup(handle); /**/ } /*    */ colorBytesNum = jng_get_out_color_channel_bytes(handle); alphaBytesNum = jng_get_out_alpha_channel_bytes(handle); colorComponentsCount = jng_get_out_color_components_num(handle); if(!colorBytesNum || !colorComponentsCount) { jng_finish_decode(handle); jng_cleanup(handle); /*  ?!*/ } /*   bpp    , ..       * / pixelBytesNum = colorBytesNum * colorComponentsCount + alphaBytesNum; rowPitch = pixelBytesNum * imageWidth; pixelBufferSize = rowPitch * imageHeight;/*    */ /*   . ,  ,     5551       32       –      ,       .         .*/ pixelBuffer = (unsigned char*)malloc(pixelBufferSize); 

एक तस्वीर के लाइन-बाय-लाइन रीडिंग (वास्तव में लाइन-बाय-लाइन - ओवरहेड से चार या पांच बफ़र्स हैं जो रंग और अल्फा के लिए एक लाइन पकड़ सकते हैं)।

 unsigned char* imageLinePtr = (unsigned char*)pixelBuffer; for(currentLine = 0; currentLine < imageHeight; currentLine++) { if(!jng_read_scanline(handle, imageLinePtr)) { /*    */ readRes = -1; break; } imageLinePtr += rowPitch; } /* */ jng_finish_decode(handle); jng_cleanup(handle); /*That's All, Folks!*/ 

संक्षेप में, यह कैसे काम करता है।

MNG की तरह JNG प्रारूप में विखंडू (टुकड़े) का एक सेट होता है। प्रत्येक चंक में हेडर होता है - 4 बाइट्स - डेटा का आकार, 4 बाइट्स - पहचानकर्ता, वैकल्पिक डेटा और 4 बाइट्स के अंत में - crc। जैसा कि हम देखते हैं, इस तरह की संरचना को घटाना और पार्स करना एक प्राथमिक कार्य है।

हम इस तरह के विखंडू को अलग करना चाहते हैं:
JHDR - फाइल हेडर - चित्र का आकार, संपीड़न प्रारूप, बिट दर और बहुत कुछ बताता है;
JDAT - चित्र का रंगीन डेटा वाला एक हिस्सा। सामान्य जेपीईजी (यदि आप एक अलग फ़ाइल में हेक्स संपादक में इस ब्लॉक को इकट्ठा करते हैं, तो आप इसे पूरी तरह से किसी भी दर्शक में खोल सकते हैं);
JSEP - JDAT विखंडू को विभाजित करता है यदि उनमें एक ही समय में आठ और बारह बिट JPEG चित्र होते हैं (इस तरह की विखंडू के बीच केवल JSEP दिखाई दे सकते हैं, लेकिन कुछ अन्य डेटा नहीं);
जेडीए - अल्फा चैनल, जेपीईजी में संपीड़ित - सब कुछ जेडडीएटी के समान है, लेकिन ग्रे के रंगों में केवल एक, आठ-बिट जेपीईजी हो सकता है;
आईडीएटी एक अल्फा चैनल है, जिसे पीएनजी में पिक्सल की तरह ही पैक किया जाता है।
IEND - चित्र का अंत।

डेटा का रंग भाग और अल्फा चैनल दोनों को कई विखंडों में विभाजित किया जा सकता है। आपको बस क्रमिक रूप से उन्हें पढ़ने और डेटा को गोंद करने की आवश्यकता है।

Jpeg में डेटा के साथ सब कुछ सरल है - jpeglib को यहां कॉन्फ़िगर किया गया है और फिर हम jpeglib के माध्यम से लाइन द्वारा डेटा लाइन को डी-लाइन करेंगे। IDAT कुछ अधिक जटिल है। हम कब से उपवास नहीं करेंगे यह एक पूर्ण png नहीं है, लेकिन वास्तव में png से केवल एक हिस्सा है।
आईडीएटी में डेटा लाइन से लाइन है, यह zlib के साथ पैक किया गया है। लाइन एक बाइट मार्कर से शुरू होती है, जो फ़िल्टरिंग के प्रकार को इंगित करती है, और फिर स्वयं डेटा। इस प्रकार, डिकोडिंग इस तथ्य को उबालता है कि हम स्ट्रिंग (zlib inflate) को अनपैक करते हैं, पहले बाइट की जांच करते हैं, इसे फ़िल्टर करते हैं (यह एक बहुत बड़ा विषय है और जो परवाह करता है - मैं आपको pnglib के अंदर फ़ाइल pngrutil.c, फ़ंक्शन png_read_filter_row) में देखने की सलाह देता हूं, फिर एक बाइट में एक से अधिक पिक्सेल पैक किया जाता है - हम उन्हें अलग-अलग बाइट में अनपैक करते हैं और यदि आवश्यक हो, तो उन्हें बाइट या एक शब्द में विस्तारित करें।
कुछ फिल्टर को पिछली पंक्ति के डेटा की आवश्यकता होती है - इसलिए, ओवरहेड को दूसरी पंक्ति में जोड़ा जाता है। हालाँकि, फ़िल्टरिंग पिक्सेल पर नहीं बल्कि डेटा बाइट्स पर की जाती है, इसलिए यदि हमारे पास पिक्सेल प्रति आठ बिट्स से कम है, तो अनपैक करते समय ओवरहेड कम होगा।

सिम सब कुछ के लिए - मुझे आशा है कि पाठ आपके लिए रोचक और उपयोगी था। संक्षेप में, मैंने जेएनजी का उपयोग करने के न केवल लागू पक्ष को उजागर करने की कोशिश की, बल्कि जिज्ञासा के लिए सिद्धांत पर थोड़ा सा भी छुआ।