1
00:00:00,000 --> 00:00:00,996

2
00:00:00,996 --> 00:00:12,470
>> [संगीत खेल]

3
00:00:12,470 --> 00:00:13,210
>> आरओबी BOWDEN: हाय.

4
00:00:13,210 --> 00:00:16,870
मैं रोब हूँ और जाने के आकार
इस समस्या को.

5
00:00:16,870 --> 00:00:20,990
इसलिए हम के रूप में copy.c के साथ शुरू करने जा रहे हैं
एक टेम्पलेट, लेकिन हम होने जा रहे हैं

6
00:00:20,990 --> 00:00:23,340
काफी कुछ बदलाव करने.

7
00:00:23,340 --> 00:00:27,570
>> अब हम तुरंत बना रहे हैं देखते हैं एक
हम अब जाँच कर रहे हैं, जहां बदल

8
00:00:27,570 --> 00:00:31,560
हमारे RXC अब 3 बराबर नहीं है, लेकिन के लिए
हम आर सी जाँच कर रहे हैं 4 बराबर नहीं है.

9
00:00:31,560 --> 00:00:34,670
हम भी में, शामिल करने के लिए चाहते हैं
फ़ाइल में और बाहर फ़ाइलों के अतिरिक्त

10
00:00:34,670 --> 00:00:39,550
इस होने जा रहा है जो तर्क, च
हम स्केलिंग रहे हैं जिसके द्वारा कारक.

11
00:00:39,550 --> 00:00:45,430
>> हम इस बात पर यकीन कर रहे हैं तो एक बार, हम चाहते हैं
स्ट्रिंग में कनवर्ट करने के स्कैन का उपयोग च

12
00:00:45,430 --> 00:00:49,030
एक नाव के लिए argv1.

13
00:00:49,030 --> 00:00:51,330
और हम स्टोर करने के लिए जा रहे हैं
उस में कारक.

14
00:00:51,330 --> 00:00:55,180
इस अतिरिक्त चरित्र यकीन कर रहा है
हम वास्तव में नहीं प्रवेश कर रहे हैं कि

15
00:00:55,180 --> 00:00:59,200
1.4 एबीसी की तरह कुछ
कमांड लाइन पर.

16
00:00:59,200 --> 00:01:02,960
>> अब हम कुछ फर्जी नाम बनाने के लिए जा रहे हैं
RV2 और RV3 नहीं हैं

17
00:01:02,960 --> 00:01:04,310
बहुत उपयोगी नामों.

18
00:01:04,310 --> 00:01:07,660
हम इसके बजाय, कॉल करने के लिए जा रहे हैं
उन्हें फाइल में और फाइल बाहर.

19
00:01:07,660 --> 00:01:11,580
अब हमें यकीन है कि बनाने के लिए जा रहे हैं
हमारे कारक वास्तव में वैध था.

20
00:01:11,580 --> 00:01:16,330
तो पहलू से भी कम या बराबर है अगर
शून्य या अधिक से अधिक 100 से अधिक है, तो के रूप में प्रति

21
00:01:16,330 --> 00:01:19,660
कल्पना, हम अस्वीकार करना चाहिए
उस पहलू.

22
00:01:19,660 --> 00:01:23,890
>> हम सुनिश्चित कर रहे हैं जब यह अब हम कर सकते हैं, अच्छा है
n फ़ाइल खोलने, और हमें करना है

23
00:01:23,890 --> 00:01:25,950
यह सफलतापूर्वक खोला गया है सुनिश्चित करें.

24
00:01:25,950 --> 00:01:28,630
यह नहीं किया है, कि अशक्त वापसी करेंगे.

25
00:01:28,630 --> 00:01:30,390
हम बाहर फ़ाइल को खोलने के लिए जा रहे हैं.

26
00:01:30,390 --> 00:01:33,420
और फिर, हम करने के लिए जाँच करना चाहते हैं
यकीन है कि इसे सफलतापूर्वक खोला है.

27
00:01:33,420 --> 00:01:37,270
और इसे सफलतापूर्वक तो, नहीं खुला है तो
हम भी बंद करने के लिए सुनिश्चित करने की आवश्यकता

28
00:01:37,270 --> 00:01:40,870
n फाइल जो मूल रूप से सफलतापूर्वक
खोला, वरना हमारे पास एक

29
00:01:40,870 --> 00:01:42,600
स्मृति रिसाव.

30
00:01:42,600 --> 00:01:46,350
>> तो अब हम बिटमैप में पढ़ने के लिए जा रहे हैं
फ़ाइल शीर्षक और बिटमैप जानकारी

31
00:01:46,350 --> 00:01:48,890
n फाइल से हैडर.

32
00:01:48,890 --> 00:01:52,360
हमें यकीन है कि बनाने के लिए जा रहे हैं
n फाइल एक वैध बिटमैप था.

33
00:01:52,360 --> 00:01:52,640
ठीक है.

34
00:01:52,640 --> 00:01:55,100
>> तो अब हम शुरू करने जा रहे हैं
कुछ परिवर्तन करना.

35
00:01:55,100 --> 00:01:58,840
हम बदल रहा हो जा रहे हैं तो इसलिए कि
बातें, हम पहले याद रखना चाहते हैं

36
00:01:58,840 --> 00:02:01,510
n फाइल की पुरानी चौड़ाई.

37
00:02:01,510 --> 00:02:05,160
हम पुरानी गद्दी की याद करना चाहते
एक ही गणना का उपयोग n फाइल

38
00:02:05,160 --> 00:02:06,990
copy.c. से

39
00:02:06,990 --> 00:02:09,840
>> और अब हम बदलने के लिए जा रहे हैं
बिटमैप जानकारी हैडर.

40
00:02:09,840 --> 00:02:13,630
और इसलिए हम चौड़ाई दोनों बढ़ रहे हैं
और जब से पहलू से ऊंचाई

41
00:02:13,630 --> 00:02:15,750
कि हम ने स्केलिंग रहे हैं.

42
00:02:15,750 --> 00:02:18,420
हम निर्धारित करने के लिए जा रहे हैं
फ़ाइल द्वारा की नई गद्दी

43
00:02:18,420 --> 00:02:21,140
नई चौड़ाई का उपयोग कर.

44
00:02:21,140 --> 00:02:27,330
और हम नए निर्धारित करने के लिए जा रहे हैं
संख्या का उपयोग कर छवि का आकार

45
00:02:27,330 --> 00:02:31,610
जा रहा है जो एक ही पंक्ति में बाइट्स
उस पंक्ति में बॉलीवुड की संख्या हो

46
00:02:31,610 --> 00:02:35,960
बार एक पिक्सेल का आकार प्लस
अंत में गद्दी के बाइट्स की संख्या

47
00:02:35,960 --> 00:02:40,310
उस पंक्ति की, और कहा कि सभी गुणा
हमारे पास जो पंक्तियों की संख्या से.

48
00:02:40,310 --> 00:02:43,800
इसलिए कि बाइट्स की संख्या है
हम हमारी छवि डेटा में है.

49
00:02:43,800 --> 00:02:48,190
>> Bf.Bfsize अब संख्या होने जा रहा है
के बारे में हमारी छवि बीटा में बाइट्स प्लस

50
00:02:48,190 --> 00:02:49,350
हमारे हेडर के आकार.

51
00:02:49,350 --> 00:02:53,910
बिटमैप फ़ाइल शीर्षक से तो अधिक आकार
और बिटमैप जानकारी हेडर के आकार.

52
00:02:53,910 --> 00:02:54,510
ठीक है.

53
00:02:54,510 --> 00:02:56,440
इसलिए कि हमारे हेडर के लिए है.

54
00:02:56,440 --> 00:02:59,030
हम फाइल सिर लिखने के लिए और कर सकते हैं
हमारे बाहर करने की जानकारी हैडर

55
00:02:59,030 --> 00:03:01,590
फ़ाइल, और हम अच्छा कर रहे हैं.

56
00:03:01,590 --> 00:03:03,800
>> अब यह वास्तव में शुरू करने के लिए समय है
पिक्सेल लेखन

57
00:03:03,800 --> 00:03:05,120
बाहर फाइल करने के लिए डेटा.

58
00:03:05,120 --> 00:03:10,460
हम आकार की एक बफर की घोषणा करने जा रहे हैं
पुराने चौड़ाई आरजीबी triples, और हम कर रहे हैं

59
00:03:10,460 --> 00:03:13,790
कहा जाता है एक चर घोषित करने के लिए जा रहा
हम करने जा रहे है जो पंक्ति सुन्न,

60
00:03:13,790 --> 00:03:15,640
शुरू में नकारात्मक 1 के बराबर निर्धारित किया है.

61
00:03:15,640 --> 00:03:19,090
हम हम प्रयोग करने जा रहे हैं कि देख लेंगे
कि क्या का ट्रैक रखने के लिए

62
00:03:19,090 --> 00:03:22,640
हम वर्तमान में लोड किया है पंक्ति
इस बफर में.

63
00:03:22,640 --> 00:03:23,290
ठीक है.

64
00:03:23,290 --> 00:03:28,750
>> तो अब, मानक संस्करण के विपरीत
बजाय में कम से अधिक पुनरावृति की

65
00:03:28,750 --> 00:03:32,900
फ़ाइल, हम प्रत्येक पर पुनरावृति करने जा रहे हैं
बाहर फ़ाइल में पंक्ति और यह पता लगाने

66
00:03:32,900 --> 00:03:38,130
हम चाहते हैं में फ़ाइल में जो पंक्ति
बाहर फ़ाइल में इस पंक्ति में जगह है.

67
00:03:38,130 --> 00:03:44,930
तो बाहर के सभी पंक्तियों पर iterating
नई ऊंचाई का उपयोग कर फ़ाइल, हम पहली बार कर रहे हैं

68
00:03:44,930 --> 00:03:48,890
पुराने में पंक्ति निर्धारित करने के लिए जा रहा
हम हम कर रहे हैं, जो प्रयोग करने जा रहे हैं फ़ाइल

69
00:03:48,890 --> 00:03:53,560
इस मौजूदा लेकर क्या करने जा
पंक्ति पहलू से विभाजित.

70
00:03:53,560 --> 00:03:58,000
इसलिए कि हमें पंक्ति देने के लिए जा रहा है
हम चाहते हैं कि पुरानी फाइल में.

71
00:03:58,000 --> 00:04:03,310
>> तो अब अगर पंक्ति सुन्न बराबर नहीं पुराने Y करता है,
हम पंक्ति को पढ़ने के लिए किया जा रहे हैं

72
00:04:03,310 --> 00:04:05,940
हम अपने मौजूदा पंक्ति बफर में चाहते हैं.

73
00:04:05,940 --> 00:04:07,700
तो कैसे हम ऐसा करने जा रहे हैं?

74
00:04:07,700 --> 00:04:11,650
सबसे पहले, हम यह पता लगाने के लिए जा रहे हैं
में उस पंक्ति शुरू होता है कि स्थिति

75
00:04:11,650 --> 00:04:13,100
मूल फाइल.

76
00:04:13,100 --> 00:04:18,630
तो उस स्थिति होने जा रहा है
हमारे हेडर के सभी और अतीत

77
00:04:18,630 --> 00:04:21,589
अब अतीत पुराने Y पंक्तियों.

78
00:04:21,589 --> 00:04:23,880
>> और तो कितने बाइट्स
एक ही पंक्ति में रहे हैं?

79
00:04:23,880 --> 00:04:28,740
फिर, ट्रिपल बार आरजीबी का आकार पुरानी
चौड़ाई प्लस पुरानी गद्दी, तो वह है

80
00:04:28,740 --> 00:04:30,640
एक ही पंक्ति में बाइट्स की संख्या.

81
00:04:30,640 --> 00:04:33,680
और हम पिछले पुराने Y पंक्तियों को छोड़ना चाहते हैं.

82
00:04:33,680 --> 00:04:37,580
इसलिए हम च की तलाश में जा रहे हैं और हम कर रहे हैं
से शुरू करने के लिए सेट की तलाश का उपयोग

83
00:04:37,580 --> 00:04:39,100
एक फ़ाइल की शुरुआत.

84
00:04:39,100 --> 00:04:42,740
हम इस स्थिति को तलाश च जा रहे हैं
फाइल में, पर हमें डाल

85
00:04:42,740 --> 00:04:46,500
हम चाहते हैं पंक्ति की शुरुआत
हमारे बफर में पढ़ने के लिए.

86
00:04:46,500 --> 00:04:48,510
>> हम पंक्ति सेट करने के लिए जा रहे हैं
पुराने y के बराबर सुन्न.

87
00:04:48,510 --> 00:04:53,080
तो अब अगर हम पाश वापस और हम चाहते हैं
हमारे बाहर फाइल में यह एक ही पंक्ति का उपयोग

88
00:04:53,080 --> 00:04:55,970
फिर हम पढ़ने के लिए नहीं जा रहे हैं
इसमें फिर से अनावश्यक.

89
00:04:55,970 --> 00:04:59,310
तो सच में, पंक्ति सुन्न है
सिर्फ एक अनुकूलन.

90
00:04:59,310 --> 00:05:05,500
>> अंत में, हम में पढ़ने के लिए जा रहे हैं
वर्तमान पंक्ति पुराने चौड़ाई आरजीबी ट्रिपल

91
00:05:05,500 --> 00:05:08,040
हम मूल फाइल से चाहते हैं.

92
00:05:08,040 --> 00:05:12,270
तो अब चालू पंक्ति से पिक्सेल शामिल
हम चाहते हैं कि मूल फाइल

93
00:05:12,270 --> 00:05:14,200
बाहर फाइल में लिखें.

94
00:05:14,200 --> 00:05:18,960
तो अब, सिर्फ ऊपर की तरह, के बजाय
पुरानी फाइल पर iterating, हम की जरूरत

95
00:05:18,960 --> 00:05:22,560
यह नई फ़ाइलें पंक्तियों पर पुनरावृति.

96
00:05:22,560 --> 00:05:27,450
वैसे यहाँ, बजाय पर iterating के सभी
पुराने पिक्सल की कि चालू पंक्ति में,

97
00:05:27,450 --> 00:05:31,210
हम में से सब से अधिक पुनरावृति करना चाहते हैं
इस में हमारी नई फ़ाइल में पिक्सल

98
00:05:31,210 --> 00:05:32,480
विशेष पंक्ति.

99
00:05:32,480 --> 00:05:34,140
>> हम ऐसा क्यों करना चाहते हैं?

100
00:05:34,140 --> 00:05:38,960
हम हम नहीं कर रहे हैं कि यहाँ देख क्योंकि
वास्तव में जरूरी है सभी का उपयोग

101
00:05:38,960 --> 00:05:41,020
मूल फाइल में पिक्सल.

102
00:05:41,020 --> 00:05:46,630
हम सिकुड़ रहे हैं, तो हम क्योंकि हो सकता है
वास्तव में, बॉलीवुड छोड़ना चाहते हैं.

103
00:05:46,630 --> 00:05:48,090
और हम हैं कि यह देखना -

104
00:05:48,090 --> 00:05:49,690
एक्स फैक्टर से विभाजित -

105
00:05:49,690 --> 00:05:55,620
हम y कहना जहां बारीकी यहाँ दर्पण
यह पता लगाने के लिए कारक द्वारा विभाजित कि

106
00:05:55,620 --> 00:06:02,480
पुराने Y-वीं पंक्ति से संबद्ध
इस नई फ़ाइल में Y-वीं पंक्ति.

107
00:06:02,480 --> 00:06:05,880
>> अब हम सभी लिखने जा रहे हैं
पुराने पंक्ति से इन पिक्सल

108
00:06:05,880 --> 00:06:07,440
हमारी नई पंक्ति में.

109
00:06:07,440 --> 00:06:10,890
हम चाहते हैं कि एक बार किया है, हम करने के लिए जरूरत है तो बस
हमारी पंक्ति के अंत में गद्दी डाल

110
00:06:10,890 --> 00:06:15,540
और हम वापस पाश हूँ और के लिए जारी रखने के लिए
हमारी नई फ़ाइल में पंक्तियों के सभी.

111
00:06:15,540 --> 00:06:19,390
अंत में, हम अपने पुराने को बंद करने की जरूरत है
, फ़ाइल हमारे नए फाइल बंद, और वापसी

112
00:06:19,390 --> 00:06:21,540
शून्य सब कुछ ठीक हो गया है.

113
00:06:21,540 --> 00:06:24,220
>> मेरा नाम रोब है और इस अवकाश था.

114
00:06:24,220 --> 00:06:29,184
>> [संगीत खेल]