ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाएं: भाग 3: ग्राफिक्स

इस भाग में, हम "असंभव" करने की कोशिश करेंगे: हम सीखेंगे कि ऑपरेटिंग सिस्टम के बिना ग्राफिक डिस्प्ले का उपयोग कैसे करें। वास्तव में, यह एक आसान काम नहीं है, खासकर जब 32-बिट संरक्षित मोड में काम कर रहा है, और खासकर यदि आप 320x200x8 के बजाय सभ्य स्क्रीन रिज़ॉल्यूशन का उपयोग करना चाहते हैं। लेकिन पहले चीजें पहले: अगर हम ग्राफिक्स चाहते हैं, तो हमें वीडियो कार्ड के साथ काम करने की आवश्यकता है।

आधुनिक ग्राफिक्स कार्ड व्यावहारिक रूप से पूर्ण-शक्ति वाले कंप्यूटर हैं जो मुख्य लोगों से नीच नहीं हैं: यहां वे एमपीईजी 2 को 1080p के रूप में डिकोड करते हैं, 3 डी ग्राफिक्स और शेड्स के लिए समर्थन, सीयूडीएए जैसी प्रौद्योगिकियां, और बहुत कुछ। यह सब बहुत जटिल लगता है। दूसरी ओर, वीडियो कार्ड एक और पीसीआई उपकरण हैं, जो बाकी के समान हैं। हमने इस डिवाइस को डिवाइस क्लास नंबर 0x03 (क्लास_नाम = ग्राफिक्स एडेप्टर) के साथ पिछले लेख में "पाया"। किसी भी उपकरण की तरह, आप I / O पोर्ट या MMIO मेमोरी क्षेत्रों का उपयोग करके वीडियो कार्ड के साथ काम कर सकते हैं, और वीडियो कार्ड स्वयं DMA का उपयोग कर सकते हैं और मुख्य प्रोसेसर के साथ बातचीत करने के लिए बाधित कर सकते हैं। यदि हम वीडियो कार्ड के लिए उपलब्ध इनपुट-आउटपुट पोर्ट की सीमा को देखते हैं, तो हम देखेंगे कि कुल मिलाकर 50 से कम बाइट्स इसे आवंटित किए जाते हैं - इतनी विशाल कार्यक्षमता को देखते हुए नहीं कि आधुनिक वीडियो कार्ड के पास है।



वीजीए मानक के अनुसार, आउटपुट कार्ड पोर्ट की दो श्रेणियों का उपयोग वीडियो कार्ड के साथ काम करने के लिए किया जाएगा: 0x03B0-0x03BB और 0x3C0-0x3DF । इन श्रेणियों के अलावा, मुख्य मेमोरी में प्रदर्शित वीडियो मेमोरी ( 0xA0000-0xBFFFF ) की एक श्रृंखला भी है।


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

दुर्भाग्य से, एक बात है: वीजीए एक पुराना मानक है और इसे आधुनिक मानकों, स्क्रीन रिज़ॉल्यूशन द्वारा एक छोटे से सरल ग्राफिक डिस्प्ले का उपयोग करने के लिए डिज़ाइन किया गया है। मानक दर्जनों विभिन्न ग्राफिक और टेक्स्ट मोड (आप यहां सब कुछ देख सकते हैं) के एक जोड़े को परिभाषित करता है, जिनमें से सबसे "शांत" हैं: 256 रंगों के लिए 320x200 और 16 रंगों के लिए 640x480। इसके अलावा, मानक में पैलेट के साथ काम करने के लिए केवल मोड स्विचिंग फ़ंक्शन और फ़ंक्शन शामिल हैं। लेकिन सामान्य स्क्रीन रिज़ॉल्यूशन कहां हैं: 1920x1080 24 बिट्स, अच्छी तरह से, या कम से कम 800x600 24 बिट्स? MPEG2 ग्राफिक्स के लिए समर्थन कहां है? 3 डी ग्राफिक्स कहां है? वीजीए मानक नहीं है। ग्राफिक्स मोड के बारे में, आप अभी भी कह सकते हैं कि वे SVGA मानक का हिस्सा हैं, जिसके साथ BIOS VBE एक्सटेंशन के माध्यम से काम किया जाता है, जिस पर बाद में चर्चा की जाएगी। और 3 डी, MPEG2, CUDA और अन्य फैशनेबल चिप्स प्रत्येक वीडियो कार्ड निर्माता द्वारा अपने तरीके से समर्थित हैं। VGA मानक में 640x480 का अधिकतम स्क्रीन रिज़ॉल्यूशन, पुराने डिस्प्ले की गणना के अलावा, वीडियो मेमोरी के आकार के कारण है: केवल 128 किलोबाइट (उच्च रिज़ॉल्यूशन के साथ काम करने के लिए बहुत अधिक स्थान की आवश्यकता होती है: 1920x1080 24bit - यह 6Mb से अधिक है)। तो आपके पास वीडियो मेमोरी का एक बड़ा क्षेत्र होना चाहिए, और आधुनिक वीडियो कार्ड में यह क्षेत्र है:


उपरोक्त श्रेणियों में से एक का उपयोग रैखिक फ्रेम बफर (LFB) के रूप में किया जाता है - वीडियो मेमोरी भी। पते की दूसरी श्रेणी का उपयोग सैकड़ों रजिस्टरों और बिट फ़ील्ड को प्रदर्शित करने के लिए किया जाता है जो वीडियो कार्ड को कॉन्फ़िगर करने के लिए उपयोग किए जाते हैं। इसके अलावा, रजिस्टरों का सेट और उनके साथ काम करने के तरीके न केवल वीडियो कार्ड के प्रत्येक निर्माता के लिए अद्वितीय हैं - वे श्रृंखला और समान निर्माता के दोनों मॉडल के बीच महत्वपूर्ण रूप से भिन्न हो सकते हैं, और यह सब CUDA, MPEG2, 3D, ... के संचालन को सुनिश्चित करने के लिए आवश्यक है ... सभी ग्राफ़िक के स्रोत लिनक्स ड्राइवर 8 मेगाबाइट से अधिक पर कब्जा कर लेते हैं:


और यहाँ निर्माताओं में से एक के लिए वीडियो कार्ड ड्राइवर का एक उदाहरण है:



बाकी में और भी अधिक कोड हैं। और यह लिनक्स में अतिरिक्त पुस्तकालयों के बिना है, जो ड्राइवरों में उपयोग किए जाते हैं।

तो, 3 डी या स्ट्रीमिंग वीडियो के लिए समर्थन प्रदान करने के लिए, आपको बहुत काम करने की आवश्यकता है। जैसा कि कहा जाता है: यदि आपके पास इसे खर्च करने के लिए एक और जीवन है, तो ...

हालांकि, इस लेख में हम एक सभ्य ग्राफिक्स मोड को चालू करने और उसमें कुछ सुंदर बनाने पर ध्यान केंद्रित करेंगे: उदाहरण के लिए, एक भग्न। आइए देखें कि यह कितना सरल है।

शुरू करने के लिए, सभ्य ग्राफिक्स मोड SVGA मानक हैं और VBE BIOS एक्सटेंशन (VESA BIOS एक्सटेंशन) के माध्यम से शामिल करने के लिए उपलब्ध हैं। VBE एक BIOS एक्सटेंशन है जिसका कोड स्वयं वीडियो कार्ड पर स्थित है और आपको इसके साथ काम करने की अनुमति देता है। VBE एक्सटेंशन मानक में कई कार्य शामिल हैं जिनका आप उपयोग कर सकते हैं:
1. ग्राफिक्स डिवाइस के बारे में जानकारी प्राप्त करना। VESA समर्थित है, वीडियो कार्ड पर वीडियो मेमोरी की मात्रा आदि।
2. मोड नंबर द्वारा इसके बारे में जानकारी प्राप्त करना: स्क्रीन रिज़ॉल्यूशन, एलएफबी को सूचक और बिट।
3. इसकी संख्या से वीडियो मोड चालू करें।
4. बैंक नंबर द्वारा वीडियो मोड के लिए बैंक चालू करना, उनके बारे में नीचे।
5. पैलेट को नियंत्रित करने सहित अन्य कार्य, जो 8-बिट मोड के लिए आवश्यक है।

पूर्ण विनिर्देशों यहाँ पाया जा सकता है । हम संक्षेप में बताएंगे कि हमें किसके साथ काम करना है।

वीडियो कार्ड द्वारा समर्थित सभी मोड 0x000 से 0x1FF तक क्रमबद्ध हैं। सभी संख्याएं व्यस्त नहीं हैं और 0x100 के बाद सभी संख्याएं मानक में सटीक स्क्रीन रिज़ॉल्यूशन मान नहीं हैं: इस प्रकार, आवश्यक स्क्रीन रिज़ॉल्यूशन द्वारा, संख्या को अभी भी खोजने की आवश्यकता है। 0x100 तक के मोड नंबर VGA मानक द्वारा परिभाषित किए गए हैं और पूरी तरह से इसके अनुरूप हैं। LFB - रैखिक फ्रेम बफर, यह बड़ी स्क्रीन रिज़ॉल्यूशन के लिए डिज़ाइन की गई वीडियो मेमोरी का एक क्षेत्र है (आमतौर पर यह रैम के बाहर स्थित है, लेकिन 4 जीबी तक)।

LFB के बिना, मानक वीडियो मेमोरी क्षेत्र 0xA0000 से 0xC0000 तक सभी ग्राफिक मोड के साथ काम करने के लिए उपयोग किया जाता है। इस स्थिति में, "बैंकों" मोड का उपयोग किया जाएगा। संपूर्ण स्क्रीन को गिने हिस्सों (बैंकों) में विभाजित किया गया है और प्रत्येक क्षण में, वीडियो मेमोरी क्षेत्र ऐसे भागों में से एक को इंगित करता है। यही है, इससे पहले कि आप स्क्रीन पर एक पिक्सेल ड्रा करें, आपको बैंक नंबर सेट करना होगा, फिर वीडियो मेमोरी का जिक्र करते हुए एक पिक्सेल ड्रा करना होगा। इस प्रकार, प्रदर्शन पर विभिन्न क्षेत्रों के साथ काम करने के लिए एक ही मेमोरी क्षेत्र का पुन: उपयोग किया जा सकता है।



LFB का उपयोग करना सरल और तेज है, क्योंकि आपको कुछ भी स्विच करने की आवश्यकता नहीं है, और संपूर्ण प्रदर्शन पूरे LFB में प्रदर्शित होता है। LFB में वीडियो मेमोरी को रैखिक तरीके से व्यवस्थित किया जाता है: पिक्सेल की गिनती स्क्रीन के ऊपरी बाएं कोने से लाइन द्वारा शुरू होती है। प्रत्येक पिक्सेल को वर्तमान ग्राफिक्स मोड की बिटनेस के आधार पर एक, दो, तीन या चार बाइट्स द्वारा दर्शाया जाता है। बाइट्स को एक पंक्ति में व्यवस्थित किया जाता है और पिक्सेल रंग को इनकोड किया जाता है। सबसे सरल और सबसे सभ्य मोड 32-बिट और 24-बिट (तीन और चार बाइट) हैं। इन मोड्स में, प्रत्येक कलर चैनल (रेड, ग्रीन, ब्लू) को 1 बाइट द्वारा दर्शाया गया है। 32-बिट मोड में, एक और बाइट आरक्षित है और इसका उपयोग नहीं किया जाता है (हम कह सकते हैं कि इसका उपयोग संरेखण के लिए किया जाता है)। LFB के साथ एक और विशेषता: मानक के अनुसार, मोड संख्या में LFB को सक्षम करने के लिए, आपको एक और बिट सेट करने की आवश्यकता है: mode_number | 0x4000।



इस प्रकार, फ़ंक्शन नंबर 2 (उपरोक्त सूची में) का उपयोग करके, आप LFB के साथ मोड नंबर पा सकते हैं और फ़ंक्शन नंबर 3 का उपयोग करके इसे सक्षम कर सकते हैं। फिर आप LFB बफर में वांछित ऑफसेट पर RGB मानों के साथ बाइट्स लिखकर स्क्रीन पर आकर्षित कर सकते हैं।
अब तक, सब कुछ आशाजनक लग रहा है, लेकिन VBE एक BIOS एक्सटेंशन है और यह एक विशिष्ट BIOS फ़ंक्शन (हमारे मामले में 10h) में रियल-मोड प्रोसेसिंग के लिए 16-बिट कोड है। यह पता चला है कि आपको परिचित 32-बिट संरक्षित मोड से VBE (16 बिट रियल मोड) का उपयोग करने की आवश्यकता है, जो हमने पिछले लेख में प्राप्त किया था। ऐसा करने के तीन तरीके हैं:
1. रियल मोड में स्विच करें, आवश्यक क्रियाएं करें, संरक्षित मोड पर वापस लौटें। प्रोसेसर की स्थिति को बचाने के लिए मोड के बीच संक्रमण कार्यों को लिखना आवश्यक है, और सामान्य स्थिति में, व्यवधानों को भी सही ढंग से संसाधित किया जाना चाहिए।
2. संरक्षित मोड से 16-बिट इंटरफ़ेस के माध्यम से VBE एक्सटेंशन का उपयोग करें। ऐसा करने के लिए, आपको डिस्क्रिप्टर तालिकाओं को कॉन्फ़िगर करने, कॉल गेट बनाने, 16-बिट कोड संकलित करने और VBE मानक के अनुसार एक और अतिरिक्त संरचना कॉन्फ़िगर करने की आवश्यकता है। इसके अलावा, बहुत सुविधाजनक नहीं है, इसके अलावा, सभी वीडियो कार्ड इस विस्तार का समर्थन नहीं करते हैं।
3. 16-बिट रियल मोड एमुलेटर का उपयोग करें जो संरक्षित मोड में काम करता है। इस एमुलेटर की एकमात्र सीमा यह है कि वीडियो कार्ड के लिए स्वयं ही बाधित हैंडलर लिखना मुश्किल होगा, लेकिन हमें इसकी आवश्यकता नहीं है, क्योंकि VBE के सभी फ़ंक्शन वीडियो कार्ड इंटरप्ट का उपयोग नहीं करते हैं।

तीसरी विधि सबसे आसान लगती है, क्योंकि आप तैयार x86emu एमुलेटर (सरल और अच्छी तरह से पोर्टेबल) ले सकते हैं और इसका उपयोग VBE फ़ंक्शन को कॉल करने के लिए कर सकते हैं।
बेशक, हमें काम करना होगा, लेकिन हम अपेक्षाकृत कम संख्या में कार्यों के लिए एक कार्यक्रम बना सकते हैं, जो किसी भी आधुनिक वीडियो कार्ड पर, ऑपरेटिंग सिस्टम के बिना , ग्राफिक्स मोड को चालू कर सकते हैं और एक भग्न खींच सकते हैं। अब तक बिना शेड्स और 3 डी लेकिन, ग्राफिक्स के बिना।

! महत्वपूर्ण! : लेख के पहले भाग से सभी 6 चरणों को सफलतापूर्वक पूरा करने के बाद ही सभी कार्यों को सफलतापूर्वक पूरा किया जा सकता है "ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाएं"

हमारी योजना:

1. कुछ सामान्य फ़ंक्शंस जोड़ें जो हमें x86emu और भग्न ड्राइंग के लिए आवश्यक हैं।
2. पोर्ट x86emu।
3. VBE के साथ काम करने के लिए कुछ कार्य लिखें।
4. एक फ्रैक्टल ड्राइंग फ़ंक्शन लिखें।
5. सभी गठबंधन और चलाते हैं।

चलिए शुरू करते हैं।

चरण 1. हम मानक कार्यों के साथ सामान्य पूरक हैं।

सबसे पहले, आपको 64-बिट संख्याओं के साथ काम करने के लिए कई फ़ंक्शन जोड़ने की आवश्यकता है। जीसीसी को उन्हें x86emu संकलन करने की आवश्यकता होगी।

1. निम्न फ़ाइलों को आम फ़ोल्डर में जोड़ें: udivdi3.c , umoddi3.c , moddi3.c , qdivrem.c , divdi3.c । आप उन्हें यहां ले जा सकते हैं।

2. आगे आपको शामिल करने के लिए एक और quad.h फ़ाइल जोड़ने की आवश्यकता है। इसे www.openbsd.org/cgi-bin/cvsweb/src/lib/libc/quad से भी लिया जा सकता है। इसे लाइनों को बदलने की आवश्यकता है:

#include <sys/types.h> #if !defined(_KERNEL) && !defined(_STANDALONE) #include <limits.h> #else #include <sys/limits.h> #endif 

प्रति पंक्ति:

 #include “types.h” 

3. अब, newlib लाइब्रेरी डाउनलोड करें। इसे दूसरे फ़ंक्शन के लिए आवश्यक होगा। लाइब्रेरी के स्रोतों से आपको फ़ाइल newlib-2.0.0 \ newlib \ libm \ math \ s_floor.c को आम फ़ोल्डर में कॉपी करना होगा। इसमें हम लाइन को प्रतिस्थापित करते हैं:

 #include "fdlibm.h" 

प्रति पंक्ति:

 #include "types.h" 

4. अभी भी setjmp / longjmp कार्यों को जोड़ने की आवश्यकता है X86emu एमुलेटर त्रुटियों को संभालने के लिए इन कार्यों का उपयोग करता है। इन कार्यों का कार्यान्वयन नीचे दिया गया है, यह newlib से कार्यान्वयन के आधार पर बनाया गया था, लेकिन थोड़ा सरल है। फ़ंक्शन आपको प्रोसेसर की स्थिति को बचाने और फिर इसे पुनर्स्थापित करने की अनुमति देता है। सी ++ अपवादों के मैनुअल कार्यान्वयन के लिए अनिवार्य रूप से समान है। इन फ़ंक्शंस के लिए हमारे कोड में दिखाई देने के लिए, आपको setjmp.s फ़ाइल को सामान्य रूप से निम्न सामग्रियों (साधारण कोडांतरक के साथ) में बनाना होगा:

  .globl setjmp setjmp: movl 4(%esp),%ecx movl 4(%ebp), %edx movl %edx, 0(%ecx) movl %ebx, 4(%ecx) addl $4,%ebp movl %ebp, 8(%ecx) subl $4,%ebp movl (%ebp),%edx movl %edx,12(%ecx) movl %esi,16(%ecx) movl %edi,20(%ecx) movl %eax,24(%ecx) xorl %eax,%eax ret .globl longjmp longjmp: movl 4(%esp),%edx movl 8(%esp),%eax movl 0(%edx),%ecx movl 4(%edx),%ebx movl 8(%edx),%esp movl 12(%edx),%ebp movl 16(%edx),%esi movl 20(%edx),%edi testl %eax,%eax jnz 1f incl %eax 1: movl %ecx,0(%esp) ret 

कोडांतरक कोड केवल एक विशिष्ट क्रम में रजिस्टरों को बचाता है, और फिर उन्हें पुनर्स्थापित करता है।
5. अब आपको सी। के लिए कार्यों की घोषणा करने की आवश्यकता है। ऐसा करने के लिए, निम्नलिखित सामग्री के साथ शामिल करने के लिए setjmp.h फ़ाइल बनाएं:

 #ifndef _SETJMP_H_ #define _SETJMP_H_ #define _JBLEN 10 typedef long jmp_buf[_JBLEN]; #ifdef __cplusplus extern "C" { #endif int setjmp (jmp_buf); void longjmp (jmp_buf, int); #ifdef __cplusplus } #endif #endif 

6. आवश्यक कार्यों का एक और महत्वपूर्ण सेट स्ट्रिंग्स और मेमोरी (मेमसेट, स्ट्रलेन, आदि) के साथ काम करने के कार्य हैं। इन कार्यों को बिट्विसर से तैयार किया जा सकता है, इसलिए आपको इस हाइपरविजर के स्रोत कोड को डाउनलोड करना होगा। इन स्रोतों से, फ़ाइल को सामान्य रूप से अयस्क \ string.s में कॉपी करें। इसमें हम लाइन को प्रतिस्थापित करते हैं:

 .include "longmode.h" 

प्रति पंक्ति:
एल

 ongmode = 0 

7. इसके बाद, आपको bitvisor से शामिल करने के लिए \ core \ string.h फ़ाइल को कॉपी करना होगा। इसमें, लाइन को प्रतिस्थापित करें:

 #include <core/types.h> 

प्रति पंक्ति:

 #include "types.h" 

8. आपको जो आखिरी चीज चाहिए वह है इनपुट / आउटपुट पोर्ट के साथ काम करना। ऐसा करने के लिए, शामिल निर्देशिका में io.h फ़ाइल जोड़ें, जो कि परिवर्तन के बिना एक ही बिट्विसर परियोजना से ली जा सकती है (परियोजना स्रोत में यह शामिल \ io.h में स्थित है)।
9. कॉपी की जाने वाली हर चीज के लिए, निम्न प्रकार की सामग्री को शामिल करें :

 #ifndef _TYPES_H #define _TYPES_H #define NULL 0 typedef unsigned int size_t; typedef unsigned long ulong; typedef unsigned long u32; typedef unsigned short u16; typedef unsigned char u8; typedef unsigned long long uint64_t; typedef unsigned long long u_int64_t; typedef unsigned long uint32_t; typedef unsigned long u_int32_t; typedef unsigned short uint16_t; typedef unsigned short u_int16_t; typedef unsigned char uint8_t; typedef unsigned char u_int8_t; typedef long __int32_t; typedef unsigned long __uint32_t; typedef unsigned long long u_quad_t; /* quads */ typedef long long quad_t; typedef quad_t * qaddr_t; typedef unsigned long u_int; typedef unsigned long uint; typedef long long int64_t; typedef long int32_t; typedef short int16_t; typedef char int8_t; #define _QUAD_HIGHWORD 1 #define _QUAD_LOWWORD 0 #define __BEGIN_DECLS #define __END_DECLS #define __dead #define __far #define __HI(x) *(1+(int*)&x) #define __LO(x) *(int*)&x #define __P(a) a #define CHAR_BIT 8 /* max # of bits in a "char" */ #define EXTRACT_WORDS(i0, i1, x) \ i0 = __HI(x); \ i1 = __LO(x); #define INSERT_WORDS(x, i0, i1) \ __HI(x) = i0; \ __LO(x) = i1; #define _BEGIN_STD_C #define _END_STD_C #define _EXFUN(a,b) ab #endif 

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

चरण 2. पोर्टिंग x86emu

X86emu FreeBSD का हिस्सा है, इसलिए आपको इसे वहां से प्राप्त करने और इसे थोड़ा परिष्कृत करने की आवश्यकता है। ऐसा करने के लिए, रूट में x86emu निर्देशिका बनाएं और http://svnweb.freebsd.org/base/vendor-sys/x86emu/dist/ से, निम्न फ़ाइलों को इस फ़ोल्डर में कॉपी करें: x86emu.c, x86emu.h, x86emu_regs.h, x86emu_util। सी ।

अब, आपको इन स्रोतों में कई बदलाव करने की आवश्यकता है:
1. x86emu \ x86emu.c फ़ाइल में, लाइनों को बदलें:

 #include <dev/x86emu/x86emu.h> #include <dev/x86emu/x86emu_regs.h> 

प्रति पंक्ति:

 #include "x86emu.h" #include "x86emu_regs.h" 

2. x86emu \ x86emu.h फ़ाइल में, लाइनों को बदलें:

 #include <sys/types.h> #include <sys/endian.h> #ifdef _KERNEL #include <sys/systm.h> #else #include <setjmp.h> #endif 

प्रति पंक्ति

 #include "types.h" #include "setjmp.h" 

3. x86emu \ x86emu_util.c फ़ाइल में, लाइनों को बदलें:

 #include <sys/param.h> #include <sys/endian.h> #include <dev/x86emu/x86emu.h> #include <dev/x86emu/x86emu_regs.h> 

प्रति पंक्ति:

 #include "x86emu.h" #include "x86emu_regs.h" #include "Io.h" #define htole16(x) ((uint16_t)(x)) #define htole32(x) ((uint32_t)(x)) #define letoh16(x) ((uint16_t)(x)) #define letoh32(x) ((uint32_t)(x)) 

4. इसके बाद, आपको x86emu_init_default फ़ंक्शन से पहले x86emu \ x86emu_util.c फ़ाइल में कई फ़ंक्शन जोड़ने की आवश्यकता है:

 static uint8_t x86emu_inb(struct x86emu *emu, uint16_t port) { uint8_t val = 0; in8(port, &val); return val; } static void x86emu_outb(struct x86emu *emu, uint16_t port, uint8_t data) { out8(port, data); } static uint16_t x86emu_inw(struct x86emu *emu, uint16_t port) { uint16_t val = 0; in16(port, &val); return val; } static void x86emu_outw(struct x86emu *emu, uint16_t port, uint16_t data) { out16(port, data); } static uint32_t x86emu_inl(struct x86emu *emu, uint16_t port) { uint32_t val = 0; in32(port, &val); return val; } static void x86emu_outl(struct x86emu *emu, uint16_t port, uint32_t data) { out32(port, data); } 

ये फ़ंक्शन इनपुट-आउटपुट पोर्ट तक पहुँचने के कार्यों पर आवरण होते हैं।

5. x86emu_init_default फ़ंक्शन में ही, निम्नलिखित परिभाषाएँ जोड़ें:

 emu->emu_inb = x86emu_inb; emu->emu_inw = x86emu_inw; emu->emu_inl = x86emu_inl; emu->emu_outb = x86emu_outb; emu->emu_outw = x86emu_outw; emu->emu_outl = x86emu_outl; 

चूंकि वीडियो कार्ड एक उपकरण है और VBE पहले परिभाषित कार्यों का उपयोग करके इनपुट / आउटपुट पोर्ट के माध्यम से इसके साथ काम करेगा, एमुलेटर को उनकी उपलब्धता के बारे में सूचित करने की आवश्यकता है।

चरण 3. BIOS के साथ काम करने के लिए सुविधाओं को जोड़ना।

अब आप V86 BIOS फ़ंक्शन का उपयोग x86emu के माध्यम से कर सकते हैं। यह कई कार्यों को करने के लिए बना हुआ है जो सीधे BIOS में एक अनुरोध करते हैं। ऐसा करने के लिए, निम्न सामग्री के साथ सामान्य फ़ोल्डर में bios.c फ़ाइल बनाएँ:

 #include "types.h" #include "bios.h" #include "x86emu.h" struct x86emu emulator; void VBE_BiosInit(void) { memset(&emulator, 0, sizeof(emulator)); x86emu_init_default(&emulator); emulator.mem_base = (char *)0; emulator.mem_size = BIOS_SIZE; } void VBE_BiosInterrupt( BIOS_REGS *p_regs, u8 num ) { memcpy(&(emulator.x86), p_regs, sizeof(BIOS_REGS)); x86emu_exec_intr(&emulator, num); memcpy(p_regs, &(emulator.x86), sizeof(BIOS_REGS)); } 

और फ़ोल्डर में निम्नलिखित सामग्री के साथ bios.h फ़ाइल शामिल करें:

 #ifndef _BIOS_H #define _BIOS_H #define BIOS_SIZE 0x100000 #define BIOS_HIGH_BASE 0xC0000 #define BIOS_HIGH_SIZE (0x100000 - 0xC0000) #define BIOS_BDA_BASE 0x9fc00 #define BIOS_BDA_SIZE 0x400 #define VBE_BIOS_INFO_OFFSET 0x70000 #define VBE_BIOS_MODE_INFO_OFFSET 0x80000 typedef struct _BIOS_REGS { u16 CS; u16 DS; u16 ES; u16 FS; u16 GS; u16 SS; u32 EFLAGS; u32 EAX; u32 EBX; u32 ECX; u32 EDX; u32 ESP; u32 EBP; u32 ESI; u32 EDI; u32 EIP; } BIOS_REGS; void VBE_BiosInit(void); void VBE_BiosInterrupt( BIOS_REGS *p_regs, u8 num ); #endif 

इस प्रकार, हमने bios (VBE_BiosInit) के साथ काम को शुरू करने के लिए एक फ़ंक्शन को परिभाषित किया, जिसे काम की शुरुआत में कॉल करना होगा और bios (VBE_BiosInterrupt) को कॉल करने के लिए एक फ़ंक्शन की आवश्यकता होगी। उत्तरार्द्ध का नाम इस तथ्य से है कि यह इंट (व्यवधान) निर्देश के माध्यम से है कि BIOS फ़ंक्शन को रियल-मोड में कहा जाता है। इस फ़ंक्शन का उपयोग करके, आप मानक के अनुसार VBE फ़ंक्शन को कॉल कर सकते हैं। एक बाधा को कॉल करने के लिए, आपको प्रोसेसर की स्थिति के साथ संरचना को भरना होगा और एमुलेटर को कॉल करना होगा। एमुलेटर आईवीटी टेबल और BIOS कोड से ही कोड को डिकोड और अनुकरण करना शुरू कर देगा। प्रशिक्षक द्वारा निर्देश, एमुलेटर सभी आवश्यक int 10h हैंडलर कोड को निष्पादित करेगा। इस प्रक्रिया में, एमुलेटर इनपुट-आउटपुट पोर्ट के साथ काम करने के कार्यों को कॉल करेगा, जिसे हमने चरण 2 में पहले संकेत दिया था।

चरण 4. VBE के साथ काम करने के लिए फ़ंक्शंस जोड़ना।

अब सब कुछ VBE के साथ काम करने के लिए कई कार्य लिखने के लिए तैयार है। सबसे पहले, vbe.h फ़ाइल जोड़ें, जिसमें आवश्यक संरचनाओं की परिभाषाएं होंगी। इसे वर्चुअलबॉक्स कोड (http://www.virtualbox.org/svn/vbox/trunk/src/VBox/Devices/Graphics/BIOS/vbe.h) से लिया जा सकता है। इसमें लाइनें बदलें:

 #include "vgabios.h" #include <VBox/Hardware/VBoxVideoVBE.h> 

प्रति पंक्ति:

 #include "types.h" 

अब निम्नलिखित सामग्री के साथ आम फ़ोल्डर में vbe.c फ़ाइल बनाएँ:

 #include "types.h" #include "printf.h" #include "string.h" #include "bios.h" #include "vbe.h" ulong vbe_lfb_addr = 0; ulong vbe_selected_mode = 0; ulong vbe_bytes = 0; VbeInfoBlock *VBE_GetGeneralInfo() { BIOS_REGS regs; memset(®s, 0, sizeof(BIOS_REGS)); regs.ECX = 0; regs.EAX = 0x4f00; regs.ES = VBE_BIOS_INFO_OFFSET >> 4; regs.EDI = 0x0; VBE_BiosInterrupt(®s, 0x10); if (regs.EAX != 0x4f) return NULL; return (VbeInfoBlock *)(VBE_BIOS_INFO_OFFSET); } ModeInfoBlock *VBE_GetModeInfo( ulong mode ) { BIOS_REGS regs; memset(®s, 0, sizeof(BIOS_REGS)); regs.ECX = mode; regs.EAX = 0x4f01; regs.ES = VBE_BIOS_MODE_INFO_OFFSET >> 4; regs.EDI = 0x0; VBE_BiosInterrupt(®s, 0x10); if (regs.EAX != 0x4f) return NULL; return (ModeInfoBlock *)(VBE_BIOS_MODE_INFO_OFFSET); } int VBE_SetMode( ulong mode ) { BIOS_REGS regs; memset(®s, 0, sizeof(BIOS_REGS)); if (mode >= 0x100) { regs.EBX = mode; regs.EAX = 0x4f02; } else { regs.EAX = mode; } VBE_BiosInterrupt(®s, 0x10); return (regs.EAX == 0x4f); } int VBE_Setup(int w, int h) { uint32_t m = 0; printf("\nVBE: test started"); VBE_BiosInit(); memset((char *)VBE_BIOS_INFO_OFFSET, 0, sizeof(VbeInfoBlock)); memset((char *)VBE_BIOS_MODE_INFO_OFFSET, 0, sizeof(ModeInfoBlock)); VbeInfoBlock *p_info = VBE_GetGeneralInfo(); int vbe_support = (p_info != NULL); if (vbe_support == 0) { printf("\nVBE: not supported"); return 0; } vbe_support = (p_info->VbeVersion >= 0x200); vbe_support = vbe_support && (p_info->VbeSignature.SigChr[0] == 'V'); vbe_support = vbe_support && (p_info->VbeSignature.SigChr[1] == 'E'); vbe_support = vbe_support && (p_info->VbeSignature.SigChr[2] == 'S'); vbe_support = vbe_support && (p_info->VbeSignature.SigChr[3] == 'A'); if (vbe_support == 0) { printf("\nVBE: not supported"); return 0; } //Try to find mode int found = 0; for (m = 0x0; m < 0x200; m++) { ModeInfoBlock *p_m_info = VBE_GetModeInfo(m); if (p_m_info != NULL) { printf("\nVBE: %x %dx%dx%d at %x", m, p_m_info->XResolution, p_m_info->YResolution, p_m_info->BitsPerPixel, p_m_info->PhysBasePtr); if (p_m_info->PhysBasePtr != 0 && p_m_info->XResolution == w && p_m_info->YResolution == h && (p_m_info->BitsPerPixel == 24 || p_m_info->BitsPerPixel == 32)) { found = 1; vbe_selected_mode = m; vbe_lfb_addr = p_m_info->PhysBasePtr; vbe_bytes = p_m_info->BitsPerPixel / 8; printf("\nVBE: FOUND GOOD %dx%dx%d -> %x at %x", w, h, vbe_bytes, vbe_selected_mode, vbe_lfb_addr); } } } return found; } 

आइए इस फ़ाइल में घोषित कार्यों पर एक नज़र डालें:
• VBE_GetGeneralInfo । यह फ़ंक्शन वीडियो कार्ड पर VBE के लिए जाँच करता है। यह BIOS फ़ंक्शन का उपयोग करता है और विनिर्देश के अनुसार रिटर्न मान की जांच करता है।
• VBE_GetModeInfo । यह फ़ंक्शन वीडियो कार्ड को नंबर द्वारा मोड की जानकारी के लिए पूछता है। संरचना के रूप में इस मोड के बारे में जानकारी देता है। VBE_BiosInterrupt में दिए गए पैरामीटर VBE विनिर्देशन द्वारा निर्धारित किए जाते हैं।
• VBE_SetMode । यह फ़ंक्शन बस संख्या द्वारा वांछित मोड को चालू करता है। VBE_BiosInterrupt में दिए गए पैरामीटर VBE विनिर्देशन द्वारा निर्धारित किए जाते हैं।
• VBE_Setup । सबसे महत्वपूर्ण कार्य: यह सभी मोड्स से होकर गुजरता है और मापदंडों में निर्दिष्ट स्क्रीन रिज़ॉल्यूशन को संतुष्ट करता है। साथ ही, फ़ंक्शन केवल 24-बिट और 32-बिट और LFB समर्थन के साथ मोड की खोज करता है। खोजों के परिणामस्वरूप, वह तीन वैश्विक चर भर देती है:
o vbe_lfb_addr - LFB पता। स्क्रीन पर ड्राइंग के लिए डेटा में कटौती करना संभव है।
o vbe_selected_mode - चयनित मोड की संख्या ताकि इसे चालू किया जा सके।
o vbe_bytes - प्रति पिक्सेल बाइट्स की संख्या (3 या 4)।

सब कुछ ड्राइंग के लिए तैयार है।

चरण 5. एक भग्न ड्राइंग फ़ंक्शन जोड़ना।

मज़ा भाग के लिए हो रही है: एक भग्न ड्रा। हम जूलिया सेट पर एक भग्न आकर्षित करेंगे। इस अद्भुत लेख के लिए कोड को एक भग्न बनाने के लिए एक आधार के रूप में लिया गया था। एक भग्न को आकर्षित करने के लिए, आप मूल सामग्री में सूत्रों के साथ, निम्नलिखित सामग्री के साथ एक fractal.c फ़ाइल बना सकते हैं:

 #include "types.h" #include "printf.h" #include "string.h" int VBE_SetMode( ulong mode ); int VBE_Setup(int w, int h); double floor(double x); extern ulong vbe_lfb_addr; extern ulong vbe_selected_mode; extern ulong vbe_bytes; int HSVtoRGB(int _h, int _s, int _v) { double h = (double)_h / 255.0, s = (double)_s / 255.0, v = (double)_v / 255.0; double r = 0; double g = 0; double b = 0; if (s == 0) { r = v; g = v; b = v; } else { double varH = h * 6; double varI = floor(varH); double var1 = v * (1 - s); double var2 = v * (1 - (s * (varH - varI))); double var3 = v * (1 - (s * (1 - (varH - varI)))); if (varI == 0) { r = v; g = var3; b = var1; } else if (varI == 1) { r = var2; g = v; b = var1; } else if (varI == 2) { r = var1; g = v; b = var3; } else if (varI == 3) { r = var1; g = var2; b = v; } else if (varI == 4) { r = var3; g = var1; b = v; } else { r = v; g = var1; b = var2; } } return ((int)(r * 255) << 16) | ((int)(g * 255) << 8) | (int)(b * 255); } void DrawFractal(void) { int x = 0, y = 0, w= 800, h = 600; if (!VBE_Setup(w, h)) return; if (!VBE_SetMode(vbe_selected_mode | 0x4000)) return; double cRe, cIm; double newRe, newIm, oldRe, oldIm; double zoom = 1, moveX = 0, moveY = 0; int color; int maxIterations = 300; cRe = -0.7; cIm = 0.27015; for(x = 0; x < w; x++) for(y = 0; y < h; y++) { newRe = 1.5 * (x - w / 2) / (0.5 * zoom * w) + moveX; newIm = (y - h / 2) / (0.5 * zoom * h) + moveY; int i; for(i = 0; i < maxIterations; i++) { oldRe = newRe; oldIm = newIm; newRe = oldRe * oldRe - oldIm * oldIm + cRe; newIm = 2 * oldRe * oldIm + cIm; if((newRe * newRe + newIm * newIm) > 4) break; } color = HSVtoRGB(i % 256, 255, 255 * (i < maxIterations)); // Draw pixel *(int *)((char *)vbe_lfb_addr + y * w * vbe_bytes + x * vbe_bytes + 0) = color & 0xFFFFFF; } } 

आइए इस कोड का अधिक विस्तार से विश्लेषण करें। सबसे पहले, इस कोड में आवश्यक परिभाषाएँ हैं:

 int VBE_SetMode( ulong mode ); int VBE_Setup(int w, int h); double floor(double x); extern ulong vbe_lfb_addr; extern ulong vbe_selected_mode; extern ulong vbe_bytes; 

दूसरे, HSVtoRGB रंग रूपांतरण फ़ंक्शन को परिभाषित किया गया है । वह सब कुछ सुंदर दिखने के लिए आवश्यक है। इसका कार्यान्वयन यहाँ से लिया गया था ।

अंत में, सबसे महत्वपूर्ण फ्रैक्टल ड्रॉइंग फंक्शन ड्राफ्रैक्टल है । यह कई बिंदुओं पर ध्यान दिया जाना चाहिए:

1. सबसे पहले, यह स्क्रीन मापदंडों को परिभाषित करता है जिनका उपयोग मोड और ड्राइंग के लिए किया जाएगा:
int x = 0, y = 0, w = 800, h = 600;
आप इन कार्यों को अपने स्वाद में बदल सकते हैं।

2. फिर VBE कॉन्फ़िगर करें:

  if (!VBE_Setup(w, h)) return; 

3. फिर पाया ग्राफिक मोड चालू है:

  if (!VBE_SetMode(vbe_selected_mode | 0x4000)) return; 

4. अगला, एक भग्न खींचा जाता है। स्क्रीन पर एक बिंदु सेट करने के लिए, सही ऑफसेट की गणना करते समय, मेमोरी में संख्या का एक सरल रिकॉर्ड उपयोग किया जाता है:

 *(int *)((char *)vbe_lfb_addr + y * w * vbe_bytes + x * vbe_bytes + 0) = color & 0xFFFFFF; 

अब जब सब कुछ तैयार है, तो आपको इस फ़ंक्शन को मुख्य रूप से कॉल करने की आवश्यकता है, अन्यथा हम अपने काम के परिणाम नहीं देखेंगे। हम कर्नेल में परिवर्तन करते हैं।

 #include "printf.h" #include "screen.h" #include "types.h" void DrawFractal(void); void main() { clear_screen(); printf("\n>>> Hello World!\n"); DrawFractal(); } 

चरण 6. मेकफाइल को परिष्कृत करें और चलाएं

यह केवल मेकफाइल को अंतिम रूप देने के लिए बनी हुई है ताकि सब कुछ संकलित हो जाए। ऐसा करने के लिए, निम्नलिखित परिवर्तन करें:
1. अद्यतन OBJFILES:

 OBJFILES = \ loader.o \ common/printf.o \ common/screen.o \ common/bios.o \ common/vbe.o \ common/qdivrem.o \ common/udivdi3.o \ common/umoddi3.o \ common/divdi3.o \ common/moddi3.o \ common/setjmp.o \ common/string.o \ common/s_floor.o \ x86emu/x86emu.o \ x86emu/x86emu_util.o \ fractal.o \ kernel.o 

2. एक और निर्देशिका जोड़ें, ऐसा करने के लिए, लाइन में बदलाव करें:

 $(CC) -Ix86emu -Iinclude $(CFLAGS) -o $@ -c $< 

3. कोडांतरक को इकट्ठा करने के लिए एक लक्ष्य जोड़ें:

 .so: as -o $@ $< 

4. अब आप परियोजना का पुनर्निर्माण कर सकते हैं:

 make rebuild sudo make image 

5. यह सुनिश्चित करने के लिए प्रोजेक्ट चलाएं कि सब कुछ काम करता है:

 sudo qemu-system-i386 -hda hdd.img 

यदि सब कुछ सही ढंग से किया जाता है, तो हमें इस सुंदरता को देखना चाहिए:


जैसा कि लेख के पिछले भागों में, dd कमांड का उपयोग करके, आप hdd.img छवि को USB फ्लैश ड्राइव पर कॉपी कर सकते हैं और वास्तविक कंप्यूटर पर प्रोग्राम का परीक्षण कर सकते हैं।

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

श्रृंखला में निम्नलिखित लेखों के लिंक:
" कैसे एक ऑपरेटिंग सिस्टम के बिना एक कार्यक्रम चलाने के लिए: भाग 4. समानांतर कंप्यूटिंग "
" ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाएं: भाग 5. ओएस से BIOS तक पहुंचना
" ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाएं: भाग 6. FAT फाइल सिस्टम के साथ डिस्क के साथ काम करने के लिए समर्थन "