न्यूरोमांसर का उलटा। भाग 4: ध्वनि, एनीमेशन, हफमैन, जीथूब

नमस्ते, जैसा कि आप पहले ही समझ चुके हैं, यह रिवर्स इंजीनियरिंग और न्यूरोमेंट के पोर्टिंग के मेरे इतिहास का एक सिलसिला है।

न्यूरोमांसर का उलटा। भाग 1: स्प्राइट्स
न्यूरोमांसर का उलटा। भाग 2: रेंडर फ़ॉन्ट
न्यूरोमांसर का उलटा। भाग 3: समाप्त प्रतिपादन, खेल बना

आज, दो अच्छी खबर के साथ शुरू करते हैं:

• सबसे पहले, मैं अब और अकेला नहीं हूं - viiri उपयोगकर्ता परियोजना में पहले ही शामिल हो चुका है और पहले ही एक महत्वपूर्ण योगदान दे चुका है;
• दूसरी बात, अब हमारे पास गीथब पर एक खुला भंडार है।

सामान्य तौर पर, चीजें बहुत अच्छी तरह से चल रही हैं, और शायद जल्द ही हमें कम से कम कुछ खेलने योग्य निर्माण मिलेगा। और कटौती के तहत, हमेशा की तरह, आइए इस बारे में बात करें कि फिलहाल क्या और कैसे हासिल किया गया है।

वह ध्वनि से निपटने लगा। काश, खेल संसाधनों के बीच ऑडियो के समान कुछ भी नहीं था, और जब से मुझे पता नहीं था कि संगीत एमएस-डॉस में कैसे काम करता है, यह बेहद स्पष्ट नहीं था कि कहां से शुरू किया जाए। सभी प्रकार के साउंडब्लैस्टर एस के बारे में थोड़ा पढ़ने के बाद, सबसे अच्छा मैं कुछ परिचित हस्ताक्षर देखने की उम्मीद में असंतुष्ट कोड को स्क्रॉल करने के लिए आया हूं। और जो कोई चाहता है, वह आम तौर पर पाता है, भले ही वह क्या देख रहा था ( इडा द्वारा टिप्पणी की गई):

sub_20416: ... mov ax, [si+8] out 42h, al ; 8253-5 (AT: 8254.2). mov al, ah out 42h, al ; Timer 8253-5 (AT: 8254.2). mov bx, [si+0Ah] and bl, 3 in al, 61h ; PC/XT PPI port B bits: ; 0: Tmr 2 gate ═╦═► OR 03H=spkr ON ; 1: Tmr 2 data ═╝ AND 0fcH=spkr OFF ; 3: 1=read high switches ; 4: 0=enable RAM parity checking ; 5: 0=enable I/O channel check ; 6: 0=hold keyboard clock low ; 7: 0=enable kbrd and al, 0FCh or al, bl out 61h, al ; PC/XT PPI port B bits: ; 0: Tmr 2 gate ═╦═► OR 03H=spkr ON ; 1: Tmr 2 data ═╝ AND 0fcH=spkr OFF ; 3: 1=read high switches ; 4: 0=enable RAM parity checking ; 5: 0=enable I/O channel check ; 6: 0=hold keyboard clock low ; 7: 0=enable kbrd 

इस टाइमर er२५३-५ के माध्यम से जाने के बाद , मैं एक लेख पर आया जो समझने के लिए पहली कुंजी बन गया कि क्या हो रहा था। नीचे मैं समझाने की कोशिश करूंगा कि क्या है।

इसलिए, सस्ती साउंड कार्ड के आगमन से पहले, आईबीएम-पीसी के युग में, सबसे आम ध्वनि पुनरुत्पादन उपकरण तथाकथित पीसी स्पीकर था , जिसे "बीपर" के रूप में भी जाना जाता था। यह डिवाइस मदरबोर्ड से जुड़े एक नियमित स्पीकर से अधिक नहीं है, ज्यादातर मामलों में, चार-पिन कनेक्टर के माध्यम से। बीपर, विचार के अनुसार, दो-स्तरीय आयताकार नाड़ी (दो वोल्टेज स्तर, आमतौर पर 0V और + 5V के अनुरूप) को पुन: पेश करना संभव बनाता है और इसे पीपीआई (प्रोग्रामेबल पेरिफेरियल इंटरफ़ेस) नियंत्रक के 61 वें बंदरगाह के माध्यम से नियंत्रित किया गया था। विशेष रूप से, पोर्ट पर भेजे गए मान के पहले दो बिट्स "स्पीकर" को नियंत्रित करने के लिए जिम्मेदार हैं ( in al, 61h और out 61h, al in al, 61h लाइनों पर टिप्पणी देखें)।

जैसा कि मैंने कहा (थोड़े अलग शब्दों में), हमारे स्पीकर दो अवस्थाओं में हो सकते हैं - "इन" और "आउट" ( "कम" - "हाई" , "ऑफ" - "ऑन" , "ऑफ" - "ऑन" ) आप चाहें के रूप में)। एक आवेग बनाने के लिए, वर्तमान स्थिति को विपरीत में बदलना आवश्यक है और, कुछ समय बाद, वापस। यह पोर्ट 61 के पहले बिट (स्क्रैच से गिनती) में हेरफेर करके सीधे किया जा सकता है, उदाहरण के लिए, इस तरह:

 PULSE: in al, 61h ;    and al, 11111100b ;    ... or al, 00000010b ;     ... ; ,        0 out 61h, al ;    61-  mov cx, 100 ;   DELAY: loop DELAY ;    in al, 61h ;    and al, 11111100b ;     out 61h, al ;    61-  

इस कोड को निष्पादित करने का परिणाम इस प्रकार होगा:

  loop DELAY +5V +----------------------+ ! ! 0V ---+ +-------------------------- or al, 00000010b and al, 11111100b out 61h, al out 61h, al 

विलंब के साथ PULSE को दोहराते हुए, हमें एक आयताकार संकेत मिलता है:

  mov dx, 100 ;  100  PULSE: ... mov cx, 100 WAIT: loop WAIT dec dx jnz PULSE PULSE +5V +---------+ +---------+ +---------+ ! ! ! ! ! ! 0V ---+ +---------+ +---------+ +--- loop WAIT 

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

यहां गेम प्रोग्रामेबल थ्री-चैनल टाइमर - इंटेल 8253 आता है , जिसमें से दूसरा चैनल (शून्य से शुरू) बीपर से जुड़ा हुआ है। यह टाइमर इंटेल 8254 घड़ी से एक संकेत प्राप्त करता है, 1193180 दालों को प्रति सेकंड (~ 1.193 मेगाहर्ट्ज) भेजता है, और एक विशिष्ट संख्या में दालों के बाद एक विशिष्ट प्रतिक्रिया के लिए प्रोग्राम किया जा सकता है। इन प्रतिक्रियाओं में से एक वक्ता को एक वर्ग पल्स भेज रहा है। दूसरे शब्दों में, 8253 समायोज्य आवृत्ति के आयताकार संकेत के जनरेटर के रूप में काम कर सकता है, इससे स्पीकर पर विभिन्न ध्वनि प्रभावों को संश्लेषित करना अपेक्षाकृत आसान हो जाता है। और यहाँ आपको इसके लिए क्या चाहिए:

1. आयताकार सिग्नल जनरेशन मोड में टाइमर का दूसरा चैनल सेट करें। ऐसा करने के लिए, एक विशेष सिंगल-बाइट मान को पोर्ट 43 ( 8253 मोड / कमांड रजिस्टर ) पर लिखें। मेरे मामले में, यह 10110110B (अधिक विवरण यहां ):

 Bits Usage 6 and 7 Select channel : 1 0 = Channel 2 4 and 5 Access mode : 1 1 = Access mode: lobyte/hibyte 1 to 3 Operating mode : 0 1 1 = Mode 3 (square wave generator) 0 BCD/Binary mode: 0 = 16-bit binary 

1. दूसरे चैनल पर वांछित आवृत्ति सेट करें। ऐसा करने के लिए, बाइट-बाय-बिट, सबसे कम उम्र से, हम 42 वें पोर्ट ( 8253 चैनल 2 डेटा पोर्ट ) को 1193180 / freq बराबर मूल्य पर 1193180 / freq , जहां 1193180 / freq में आवश्यक आवृत्ति मूल्य है।

   
   

2. स्पीकर को टाइमर से दाल प्राप्त करने की अनुमति दें। ऐसा करने के लिए, एकता के लिए पोर्ट 61 ( PPI ) में मान के पहले दो बिट सेट करें। तथ्य यह है कि यदि शून्य बिट 1 पर सेट है, तो पहले "स्विच" के रूप में व्याख्या की जाती है:

   
   

 Bit 0 Effect ----------------------------------------------------------------- 0 The state of the speaker will follow bit 1 of port 61h 1 The speaker will be connected to PIT channel 2, bit 1 is used as switch ie 0 = not connected, 1 = connected. 

परिणामस्वरूप, हमारे पास निम्न चित्र है:

  mov al, 10110110b out 43h, al ;   mov ax, 02E9Bh ; 1193180 / 100 = ~0x2E9B out 42h, al ;      mov al, ah out 42h, al ;      in al, 61h ;    or al, 00000011b ;      1 out 61h, al ;   ... ;       ~100  in al, 61h and al, 11111100b out 61h, al ;   

और यह वही कोड है जिसे मैंने बहुत शुरुआत में उद्धृत किया था (आरंभीकरण को छोड़कर, लेकिन मैंने इसे किसी अन्य फ़ंक्शन में पाया): si + 8 पर एक आवृत्ति विभक्त है जिसे पोर्ट 42 में भेजा गया है, और si + 0Ah - पोर्ट 61 में स्पीकर की स्थिति ( "ऑन" - "ऑफ" ) दर्ज की गई।

प्लेबैक तंत्र सरल और सीधा है, लेकिन फिर आपको समय के साथ निपटना था। पास के कोड का अध्ययन करने के बाद, मैंने देखा कि उसी फ़ंक्शन में जिसमें टाइमर आरंभीकृत किया गया है ( sub_2037A , फिर init_8253 ), आठवें व्यवधान हैंडलर को sub_20416 फ़ंक्शन (इसके बाद - play_sample ) से बदल दिया जाता है। यह जल्द ही स्पष्ट हो गया कि यह रुकावट प्रति सेकंड लगभग 18.2 बार उत्पन्न होती है और सिस्टम समय को अपडेट करने का कार्य करती है। इस रुकावट के हैंडलर को बदलना एक सामान्य अभ्यास है यदि आपको प्रति सेकंड 18 बार कुछ कार्रवाई करने की आवश्यकता है (वास्तव में, मूल हैंडलर को हुक के अंदर भी बुलाया जाना चाहिए, अन्यथा सिस्टम समय बंद हो जाएगा)। इसके आधार पर, यह पता चलता है कि अगली आवृत्ति जनरेटर से प्रत्येक (1 / 18.2) * 1000 ~ 55 का शुल्क लिया जाता है।

योजना यह थी:

• play_sample फ़ंक्शन में एक ब्रेकपॉइंट play_sample , उस पंक्ति पर जहां अगला आवृत्ति विभक्त निकाला जाता है;
• सूत्र के अनुसार आवृत्ति की गणना करें freq = 1193180 / divisor ;
• कुछ प्रकार के ऑडियो एडिटर में वर्ग फ़्रीक फ़्रीक्वेंसी सिग्नल उत्पन्न करें (मैंने एडोब ऑडिशन का उपयोग किया);
• कम से कम 3 सेकंड जमा होने तक पहले तीन चरणों को दोहराएं।

इसलिए मुझे मुख्य मेनू से माधुर्य की शुरुआत मिली, लेकिन आवश्यकता से कुछ समय 10 धीमी गति से खेल रहा था। फिर मैंने "नमूना" की अवधि को 55 एमएस से घटाकर 5 एमएस कर दिया - यह बहुत बेहतर हो गया, लेकिन अभी भी ऐसा नहीं है। जब तक मुझे यह लेख नहीं मिला, समय मुद्दा खुला रहा। यह पता चला कि आठवां अवरोध उसी 8253 को खिलाकर उत्पन्न होता है, जिसका शून्य चैनल इंटरप्ट कंट्रोलर ( पीआईसी ) से जुड़ा होता है। जब मशीन बूट करती है, तो BIOS ~ 18.2 हर्ट्ज की आवृत्ति के साथ दालों को उत्पन्न करने के लिए चैनल शून्य सेट करता है (अर्थात, एक बाधा हर ~ 54.9 एमएस उत्पन्न होती है)। हालांकि, शून्य चैनल को फिर से शुरू किया जा सकता है ताकि यह एक उच्च आवृत्ति के साथ दालों को उत्पन्न करता है, इसके लिए, दूसरे चैनल के साथ सादृश्य द्वारा, आपको 1193180 / freq बराबर मूल्य को 40 वें पोर्ट पर लिखने की आवश्यकता है, जहां Hertz में freq आवश्यक आवृत्ति मान है। यह init_8253 फ़ंक्शन में होता है, बस शुरू में मैंने इस पर ध्यान नहीं दिया:

 init_8253: ... mov al, 0B6h ; 10110110b out 43h, al ; Timer 8253-5 (AT: 8254.2). mov ax, 13B1h out 40h, al ; Timer 8253-5 (AT: 8254.2). mov al, ah out 40h, al ; Timer 8253-5 (AT: 8254.2). 

मूल्य 13B1h अनुवाद आवृत्ति में किया जाता है: 1193180 / 13B1h ~ 236.7 , फिर हमें लगभग (1 / 236.7) * 1000 ~ 4.2 प्रति "नमूना" मिलता है। पहेली विकसित हुई है।

फिर गेम को साउंडट्रैक निकालने वाले फ़ंक्शन को लागू करने के लिए प्रौद्योगिकी की बात है। लेकिन यहां एक बात है, 42 वें बंदरगाह में दर्ज आवृत्ति डिवाइडर के मूल्यों को स्पष्ट रूप से संग्रहीत नहीं किया गया है। वे कुछ मुश्किल एल्गोरिथ्म, इनपुट डेटा और कार्य क्षेत्र की गणना करते हैं, जो सीधे गेम की निष्पादन योग्य फ़ाइल (सातवें खंड में, इडा के अनुसार) में झूठ बोलते हैं। इसके अलावा, सुविधाओं में, ट्रैक के अंत का कोई संकेत नहीं है, जब खेलने के लिए अधिक कुछ नहीं है, एल्गोरिथ्म असीम रूप से स्पीकर की एक शून्य स्थिति पैदा करता है। लेकिन मैं परेशान नहीं हुआ और जैसा कि डिकम्प्रेसन एल्गोरिथ्म ( पहला भाग ) के मामले में, मैंने सिर्फ 64-बिट असेंबलर को प्लेबैक के लिए ट्रैक सेट करने का कार्य और अगली आवृत्ति प्राप्त करने के लिए एल्गोरिथ्म (और मैंने पूरी तरह से सातवां खंड लिया) में चित्रित किया है।

और इसने काम किया। उसके बाद, मैंने चयनित ट्रैक ( पीसीएम, 44100 हर्ट्ज, 8 बिट, मोनो ; के लिए साउंडट्रैक पीढ़ी के कार्यों को कार्यान्वित किया; डोसबॉक्स में स्पीकर एमुलेटर में उपयोग किए जाने वाले जनरेटर की तरह कुछ किया)। मैंने मौन के एक सरल काउंटर के साथ अंत के संकेत के साथ समस्या को हल किया: एक दूसरे को गिना - हम एल्गोरिथ्म को पूरा करते हैं। WAV हेडर में परिणामी ट्रैक को लपेटने और फ़ाइल में परिणाम सहेजने के बाद, मुझे मुख्य मेनू से बिल्कुल ट्रैक मिला। और 13 और ट्रैक जो आप नीचे सुन सकते हैं [या संसाधन दर्शक में, जिसमें अब एक अंतर्निहित खिलाड़ी और किसी भी ट्रैक को बचाने की क्षमता है। WAV] :

[मुद्दे का अध्ययन करते हुए, मैंने अधिक उन्नत "बीपर" तकनीकों के बारे में सीखा, जैसे कि खराब-गुणवत्ता वाले पीसीएम ध्वनि प्रजनन के लिए पल्स-चौड़ाई मॉडुलन का उपयोग करना। इस लेख के अंत में, मैं उन सामग्रियों की एक सूची प्रदान करूँगा जिनसे आप और अधिक सीख सकते हैं।]

दूसरे भाग में , जब विभिन्न संसाधन स्वरूपों पर विचार किया गया था, मैंने सुझाव दिया कि .ANH फ़ाइलों में स्थान पृष्ठभूमि के लिए एनिमेशन हैं (अर्थात, .PIC में संग्रहीत छवियों के लिए)। [ऐसा है।] ध्वनि के साथ समाप्त होने के बाद, मैंने इसे जांचने का फैसला किया। विशुद्ध रूप से इस धारणा पर कि एनीमेशन को सीधे मेमोरी में संग्रहित पृष्ठभूमि छवि पर लागू किया जाता है ( वीडियो मेमोरी में नहीं, बल्कि स्प्राइट चेन में ), मैंने एनीमेशन लागू करने से पहले क्रमशः इस मेमोरी को डंप करने का निर्णय लिया (देखो जहां कर्सर शीर्ष पर इंगित करता है) पत्र स्ट्रिंग 'S'):

 3DE6:0E26 03 B4 44 B3 ... ;   3DE6:0E26 03 BC CC B3 ... ;   

बिल्कुल वही जो मैंने उम्मीद की थी - गहरे लाल रंग (0x4) को बदलकर चमकदार लाल (0xC) कर दिया गया। अब आप पते पर मान बदलने के लिए ब्रेकपॉइंट सेट करने का प्रयास कर सकते हैं, उदाहरण के लिए, 3DE6:0E28 और, यदि आप भाग्यशाली हैं, तो एक रिवर्स ट्रेस का संचालन करें। [मैं भाग्यशाली था।] ब्रेकपॉइंट ने मुझे एक पंक्ति में ले जाया, जो सीधे दिए गए पते पर मूल्य बदलता है: xor es:[bx], al । परिवेश की जांच करने के बाद, मैंने आसानी से मुख्य स्तर के लूप से इस बिंदु पर कॉल की एक श्रृंखला बनाई: sub_1231E (xor es:[bx], al) <- sub_12222 <- sub_105F6 <- sub_1038F ( ) ।

मैं इस बारे में विवरण में नहीं जाऊंगा कि मैंने एनीमेशन प्रक्रिया को कैसे उलट दिया। यह एक काफी नियमित और व्यवस्थित कार्य है, लेकिन बहुत मुश्किल नहीं है यदि सीमाओं को स्पष्ट रूप से चित्रित किया गया है (प्राप्त बैकट्रैक ये सीमाएं हैं)। लेकिन मैं मदद नहीं कर सकता लेकिन अंत में क्या हुआ, इसके बारे में बात करता हूं।

सबसे पहले .ANH प्रारूप के बारे में। वास्तव में, यह कंटेनरों का एक समूह है, और .ANH फ़ाइल का पहला शब्द अंदर कंटेनरों की संख्या है:

 typedef struct anh_hdr_t { uint16_t anh_entries; /* first entry hdr */ } anh_hdr_t; 

कंटेनर स्वयं पृष्ठभूमि तत्व का एक अलग से लिया गया एनीमेशन है। आप कंटेनर के लिए एक बाइट का चयन कर सकते हैं जिसमें इसकी बाइट का आकार और एनीमेशन में फ़्रेमों की संख्या है जो इसका प्रतिनिधित्व करता है। हेडर के आगे अगले फ्रेम की अवधि (देरी) और पहले फ्रेम के बाइट्स के सापेक्ष फ्रेम के बाइट्स के ऑफसेट के मान हैं। ऐसे जोड़े की संख्या स्पष्ट रूप से फ्रेम की संख्या के बराबर है:

 typedef struct anh_entry_hdr_t { uint16_t entry_size; uint16_t total_frames; /* anh_frame_data_t first_frame_data */ /* another frames data */ /* anh_frame_hdr first_frame_hdr */ /* another frames */ } anh_entry_hdr_t; typedef struct anh_frame_data_t { uint16_t frame_sleep; uint16_t frame_offset; } anh_frame_data_t; ... extern uint8_t *anh; anh_hdr_t *hdr = (anh_hdr_t*)anh; anh_entry_hdr_t *entry = (anh_entry_hdr_t*)(anh + sizeof(anh_hdr_t)); for (uint16_t u = 0; u < anh->anh_entries; u++) { uint8_t *p = (uint8_t*)entry; anh_frame_data_t *first_frame_data = (anh_frame_data_t*)(p + sizeof(anh_entry_hdr_t)); uint8_t *first_frame_bytes = p + (entry->total_frames * sizeof(anh_frame_data_t)); for (uint16_t k = 0; k < entry->total_frames; k++) { anh_frame_data_t *frame_data = first_frame_data + k; uint8_t *frame_bytes = first_frame_bytes + frame_data->frame_offset; ... } /* plus 2 bytes of padding */ p += (entry->entry_size + 2); entry = (anh_entry_hdr_t*)p; } 

एक अलग फ्रेम एक चार-बाइट हेडर से बना होता है, जिसमें इसकी रैखिक आयाम और पृष्ठभूमि छवि के सापेक्ष विस्थापन होता है, और एल्गोरिथ्म द्वारा एन्कोड किए गए फ्रेम पिक्सल पहले से ही रन लंबाई से मेरे परिचित हैं:

 typedef struct anh_frame_hdr { uint8_t bg_x_offt; uint8_t bg_y_offt; uint8_t frame_width; uint8_t frame_height; /* rle encoded frame bytes */ }; 

पृष्ठभूमि पर फ्रेम का "ओवरले" इस तरह दिख सकता है:

 extern uint8_t *level_bg; uint8_t frame_pix[8192]; anh_frame_hdr *hdr = (anh_frame_hdr*)frame_bytes; uint16_t frame_len = hdr->frame_width * hdr->frame_height; decode_rle(frame + sizeof(anh_frame_hdr), frame_len, frame_pix); /* 0xFB4E - some magic value, have no idea what is it */ uint16_t bg_offt = (hdr->bg_y_offt * 152) + hdr->bg_x_offt + 0xFB4E; uint16_t bg_skip = 152 - hdr->frame_width; uint8_t *p1 = frame_pix, *p2 = level_bg; for (uint16_t i = hdr->frame_height; i != 0; i--) { for (uint16_t j = hdr->frame_width; j != 0; j--) { *p2++ ^= *p1++; } p2 += bg_skip; } 

यह .ANH प्रारूप है , लेकिन एक और संरचना है जो इसे सभी काम करती है:

 typedef struct bg_animation_control_table_t { uint16_t total_frames; uint8_t *first_frame_data; uint8_t *first_frame_bytes; uint16_t sleep; uint16_t curr_frame; } bg_animation_control_table_t; 

खेल में ही, इस तरह की कम से कम चार संरचनाओं की एक सरणी को विश्व स्तर पर घोषित किया गया है। अगली .ANH फ़ाइल को लोड करने के बाद, अंदर के एनिमेशन की संख्या भी एक वैश्विक चर में संग्रहीत की जाती है, और सरणी के तत्वों को इस प्रकार से आरंभ किया जाता है:

 extern uint8_t *anh; uint16_t g_anim_amount = 0; bg_animation_control_table_t g_anim_ctl[4]; ... anh_hdr_t *hdr = (anh_hdr_t*)anh; anh_entry_hdr_t *entry = (anh_entry_hdr_t*)(anh + sizeof(anh_hdr_t)); g_anim_amount = hdr->anh_entries; for (uint16_t u = 0; u < g_anim_amount; u++) { uint8_t *p = (uint8_t*)entry; g_anim_ctl[u].total_frames = entry->total_frames; g_anim_ctl[u].first_frame_data = p + sizeof(anh_entry_hdr_t); g_anim_ctl[u].first_frame_bytes = g_anim_ctl[u].first_frame_data + (entry->total_frames * sizeof(anh_frame_data_t)); g_anim_ctl[u].sleep = *(uint16_t*)(g_animation_control[u].first_frame_data); g_anim_ctl[u].curr_frame = 0; /* plus 2 bytes of padding */ p += (entry->entry_size + 2); entry = (anh_entry_hdr_t*)p; } 

अंत में, एनिमेशन लागू करें:

 for (uint16_t u = 0; u < g_anim_amount; u++) { bg_animation_control_table_t *anim = &g_anim_ctl[u]; if (anim->sleep-- == 0) { anh_frame_data_t *data = (anh_frame_data_t*)anim->first_frame_data + anim->curr_frame; /*    */ ... if (++anim->curr_frame == anim->total_frames) { anim->curr_frame = 0; data = (anh_frame_data_t*)anim->first_frame_data; } else { data++; } anim->sleep = data->frame_sleep; } } 

और हम निम्नलिखित प्राप्त करते हैं [आप संसाधन दर्शक में अधिक देख सकते हैं] :

R2.ANH.GIF

R6.ANH.GIF

अभी एनीमेशन के साथ कुछ मुद्दे हैं। पहला यह है कि मेरे कोड में मैं सभी उपलब्ध एनिमेशन खेलता हूं, लेकिन कुछ वैश्विक झंडे के लिए मूल चेक यह दर्शाता है कि अगले एक के माध्यम से स्क्रॉल करना है या नहीं। और दूसरा, इस तथ्य के कारण कि कुछ एनिमेशन स्क्रीन पर ऑब्जेक्ट जोड़ते हैं जो मूल रूप से वहां नहीं हैं। और चूंकि फ्रेम "झगड़े" पृष्ठभूमि पर है, तो एक चक्रीय स्क्रॉल के साथ, हर दूसरे सर्कल पर ऑब्जेक्ट बस गायब हो जाता है। यहाँ, उदाहरण के लिए, यह कैसे दिख सकता है:

R53.ANH.GIF

लेकिन अभी के लिए, इसे छोड़ दें जैसा कि यह है।

पहले भाग से अज्ञात विघटन एल्गोरिथ्म याद है? विकास से बमुश्किल जुड़ा होने के कारण, विरी ने न केवल यह निर्धारित किया कि यह किस प्रकार का एल्गोरिथ्म है, बल्कि डिकोडर का अपना संस्करण भी लिखा है, कोड बेस में असेंबलर के भयानक तीन-लाइन टुकड़े की जगह। इस संबंध में, मैंने विरी से काम पर एक लघु निबंध लिखने के लिए कहा। जो किया गया था, लेकिन इससे पहले कि मैं इसे दूं, कुछ शब्दों को सिद्धांत के बारे में कहा जाना चाहिए।

संसाधनों को संपीड़ित करने के लिए, न्यूरोमैंसर के डेवलपर्स ने हफ़मैन कोड का उपयोग किया। यह उपसर्ग कोड का उपयोग करके जानकारी एन्कोडिंग के पहले प्रभावी तरीकों में से एक है। कोडिंग सिद्धांत में, एक चर-लंबाई शब्द वाले कोड और जिन में कोई कोडवर्ड नहीं होता है, उन्हें दूसरे का उपसर्ग कहा जाता है। यही है, यदि शब्द "a" उपसर्ग कोड में शामिल है, तो "ab" शब्द कोड में मौजूद नहीं है। यह गुण आपको ऐसे कोड द्वारा एन्कोड किए गए संदेश को विशिष्ट रूप से तोड़ने की अनुमति देता है।

हफ़मैन एल्गोरिथ्म का विचार यह है कि, संदेश में एक निश्चित वर्णमाला के पात्रों की घटना की संभावना को जानते हुए, हम चर लंबाई के कोड के निर्माण की प्रक्रिया का वर्णन कर सकते हैं, जिसमें बिट्स की एक पूर्णांक संख्या शामिल है। घटना की उच्च संभावना वाले प्रतीकों को छोटे कोड सौंपे जाते हैं, और कम संभावना वाले प्रतीकों को, इसके विपरीत, लंबे समय तक वाले। सामान्य तौर पर, एन्कोडिंग प्रक्रिया को इष्टतम कोड ट्री बनाने के लिए कम किया जाता है और, इसके आधार पर, संदेश प्रतीक को संबंधित कोड में मैप किया जाता है। प्राप्त कोड की उपसर्ग संपत्ति आपको संपीड़ित संदेश को विशिष्ट रूप से डिकोड करने की अनुमति देती है।

Huffman.GIF

एल्गोरिथ्म में एक महत्वपूर्ण दोष है (वास्तव में, एक नहीं, लेकिन अब यह केवल एक महत्वपूर्ण है)। तथ्य यह है कि संपीड़ित संदेश की सामग्री को पुनर्प्राप्त करने के लिए, डिकोडर को एनकोडर द्वारा उपयोग किए जाने वाले वर्णों की घटना की आवृत्तियों की तालिका को जानना चाहिए। इस संबंध में, एन्कोडेड संदेश के साथ, या तो प्रायिकता तालिका या कोड ट्री स्वयं (गेम में उपयोग किया जाने वाला विकल्प) प्रेषित किया जाना चाहिए। अतिरिक्त डेटा का आकार अपेक्षाकृत बड़ा हो सकता है, और यह संपीड़न क्षमता को महत्वपूर्ण रूप से प्रभावित करता है।

आप इस से कैसे निपट सकते हैं, इसके बारे में कुछ और साथ ही साथ आपके डिकोडर और गेम में लागू होने वाले के बारे में कुछ बताता है: viiri :

यह उल्लेखनीय है कि पूरा खेल पूरी तरह से असेंबलर में लिखा गया था, इसलिए कोड में दिलचस्प समाधान, चाल और अनुकूलन शामिल हैं।

प्रक्रियाओं के अनुसार। sub_1ff94 ( build_code_table ) फ़ंक्शन को एक फ़ाइल से संपीड़ित हफ़मैन पेड़ को लोड करने के लिए आवश्यक है। एक स्थिर हफ़मैन (कभी-कभी गतिशील , और यह आवश्यकता उस पर लागू नहीं होती है) को डिकोड करने के लिए, संदेश के साथ मिलकर, एक कोड ट्री को प्रेषित किया जाना चाहिए, जो वास्तविक चरित्र कोड्स के लिए हफ़मैन कोड की मैपिंग है। यह पेड़ काफी बड़ा है और इसलिए इसे किसी भी तरह कुशलतापूर्वक संग्रहीत करना अच्छा होगा। सबसे सही तरीका कैनोनिकल कोड ( MOAR ) का उपयोग करना है। उनके गुणों के कारण, पेड़ को संग्रहित करने के लिए एक बहुत ही दिलचस्प और प्रभावी तरीका है ( पीकेजिप अभिलेखागार के अपस्फीति संपीड़न विधि के कार्यान्वयन में उपयोग किया जाता है)। लेकिन गेम में कैनोनिकल कोड का उपयोग नहीं किया जाता है, इसके बजाय एक सीधा ट्री ट्रैवर्सल किया जाता है और प्रत्येक वर्टेक्स बिट 0 के लिए आउटपुट स्ट्रीम को लिखा जाता है यदि नोड एक पत्ती नहीं है, या बिट 1 यदि नोड एक पत्ती है, और फिर अगले 8 बिट्स वर्ण कोड हैं साइट। जब डिकोडिंग किया जाता है, तो एक समान ट्री ट्रैवर्सल किया जाता है, जिसे हम गेम में देखते हैं। एक उदाहरण और कुछ स्पष्टीकरण है।

 build_code_table proc near call getbit ;     jb short loc_1FFA9 ;   ... shl dx, 1 inc bx call build_code_table ;  build_code_table    or dl, 1 call build_code_table ;  build_code_table    shr dx, 1 dec bx ret loc_1FFA9: call sub_1FFC2 ;      (8 ) ... ;     ret sub_1FF94 endp sub_1FFC2 proc near sub di, di mov ch, 8 loc_1FFC6: call getbit rcl di, 1 dec ch jnz short loc_1FFC6 retn sub_1FFC2 endp 

getbit ( sub_1ffd0 ) इनपुट स्ट्रीम से थोड़ा सा पढ़ता है। उसके विश्लेषण से हमें यह निष्कर्ष निकालने की अनुमति मिलती है कि व्यक्तिगत बिट्स को 16-बिट ax रजिस्टर से निकाला जाता है, जिसका मान मेमोरी से lodsw इंस्ट्रक्शन द्वारा लोड किया जाता है, जो स्ट्रीम से दो बाइट्स को लोड करता है, लेकिन चूंकि इंटेल प्रोसेसर में थोड़ा-सा एंडियन बाइट ऑर्डर है, xchg आधे रजिस्टर को पुनर्व्यवस्थित किया। इसके अलावा, धारा में बिट्स का क्रम कुछ अतार्किक है - पहला कम से कम नहीं है, लेकिन सबसे महत्वपूर्ण बिट है। , shl , jb .

 getbit proc near or cl, cl jz short loc_1FFD9 dec cl shl ax, 1 retn loc_1FFD9: cmp si, 27B6h jz short loc_1FFE7 ;   lodsw xchg al, ah mov cl, 0Fh shl ax, 1 retn loc_1FFE7: call sub_202FC ;      lodsw xchg al, ah mov cl, 0Fh shl ax, 1 retn getbit endp 

viiri , :

 typedef struct node_t { uint8_t value; struct node_t *left, *right; } node_t; static uint8_t *g_src = NULL; static int getbits(int numbits) { ... } static uint32_t getl_le() { /*       4-    */ } static node_t* build_tree(void) { node_t *node = (node_t*)calloc(1, sizeof(node_t)); if (getbits(1)) { node->right = NULL; node->left = NULL; node->value = getbits(8); } else { node->right = build_tree(); node->left = build_tree(); node->value = 0; } return node; } int huffman_decompress(uint8_t *src, uint8_t *dst) { int length, i = 0; node_t *root, *node; g_src = src; length = getl_le(); node = root = build_tree(); while (i < length) { node = getbits(1) ? node->left : node->right; if (!node->left) { dst[i++] = node->value; node = root; } } ... } 

:

build_code_table . , , . , . , , , — ( huffman_decompress ).

? ! ! , . ( ): . , 3- , N , (3 — N) .

ABCD : A - 0b, B - 10b, C - 110b, D - 111b . ( ), , :

, . , , , 010b — . . , 'A' 0b , , . :

, 011010111b :

• : 011b ;
• , 011b (3) , A , ;
• 011b 1, , : 110b ;
• , 110b (6) , , ;
• , .

«» 8- . 256 . 8 . , , :

: — , . , . 4 — 32- .

, . .

, github . , , , - [ , README.md] .

, , 2015- :

• LibNeuroRoutines (, MASM) — , , . ( neuro_routines.h ) , . , :
  
  • ( huffman_decompression.c , decompression.c );
  • ( cp437.c );
  • ( dialog.c );
  • ( audio.c ).
• NeuromancerWin64 () — . . , «» , , . CSFML ( SFML C ).
• ResourceBrowser (C++) — . MFC -, .DAT -. :
  
  • BMP (8bpp) ( IMH , PIC );
  • ( ANH );
  • WAV (PCM, 44100Hz, 8bps, mono) ( SOUND ).

LibNeuroRoutines . LibNeuroRoutines CSFML ( ResourceBrowser SFML ).

64- Windows . , LibNeuroRoutines 64- MASM (Microsoft Macro Assembler) . — , 64- . , NASM FASM , , . VS 2015 — MASM .

, . C . , ( , MFC ).

, . - , .

. ? , . , . - , . , , , . ().

1. Make sound from the speaker using assembly
2. Programming the PC Speaker
3. PC Speaker
4. Programmable Interval Timer
5. Making C Sing
6. Beyond Beep-Boop: Mastering the PC Speaker