1
00:00:00,000 --> 00:00:00,494

2
00:00:00,494 --> 00:00:13,350
>> [संगीत खेल]

3
00:00:13,350 --> 00:00:14,080
>> आरओबी BOWDEN: हाय.

4
00:00:14,080 --> 00:00:17,550
मैं रोब हूँ, और चलो आशा है कि
इस समाधान तुम डाल में मदद करता है

5
00:00:17,550 --> 00:00:19,600
वसूली के लिए सड़क पर.

6
00:00:19,600 --> 00:00:22,700
तो चलो शुरू हो जाओ.

7
00:00:22,700 --> 00:00:25,660
>> हम तुरंत हम कर रहे हैं कि देखने
अभी हम कर रहे हैं कि सुनिश्चित करने के लिए

8
00:00:25,660 --> 00:00:27,170
सही ढंग से वसूल लेंगे उपयोग कर.

9
00:00:27,170 --> 00:00:31,490
तो उपयोग में अभी कुछ होना चाहिए
डॉट स्लैश को ठीक तरह.

10
00:00:31,490 --> 00:00:35,500
>> अब हम उम्मीद खोलने के लिए जा रहे हैं
कार्ड कच्चे फ़ाइल डॉट.

11
00:00:35,500 --> 00:00:39,740
हम प्रयोग कर रहे हैं कि यहाँ देख
लगातार कच्चे अंडरस्कोर फ़ाइल नाम,

12
00:00:39,740 --> 00:00:44,200
हम हैश है यहाँ जो
कार्ड कच्चे डॉट के रूप में परिभाषित किया.

13
00:00:44,200 --> 00:00:45,030
ठीक है.

14
00:00:45,030 --> 00:00:48,210
>> इसलिए हम यह सुनिश्चित करने की जरूरत है कि
सफलतापूर्वक खोला क्योंकि अगर यह

15
00:00:48,210 --> 00:00:51,150
, तो हम उपयोगकर्ता को सचेत करना चाहिए नहीं था.

16
00:00:51,150 --> 00:00:56,770
लेकिन यह किया है यह सोचते हैं कि हम अब कर रहे हैं
आकार JPEG के एक बफर घोषित करने के लिए जा रहा

17
00:00:56,770 --> 00:00:58,170
नाम लंबाई फ़ाइल.

18
00:00:58,170 --> 00:01:02,060
तो इस बफर होने जा रहा है कि
हम में sprintf जा रहे हैं.

19
00:01:02,060 --> 00:01:04,360
>> तो JPEG फ़ाइल नाम की लंबाई क्या है?

20
00:01:04,360 --> 00:01:08,490
यहाँ तक, हम यह देखते हैं कि
आठ के रूप में परिभाषित हैश.

21
00:01:08,490 --> 00:01:10,670
तो क्यों आठ?

22
00:01:10,670 --> 00:01:15,150
खैर किसी दिए गए फ़ाइल नाम दिया जाएगा
शून्य शून्य शून्य की तरह कुछ.

23
00:01:15,150 --> 00:01:19,460
JPG और फिर हम एक बैकस्लैश शून्य की जरूरत है.

24
00:01:19,460 --> 00:01:22,720
तो हम कर सकते हैं कि एक बफर की जरूरत
आठ वर्ण की दुकान.

25
00:01:22,720 --> 00:01:25,190
अब हम है कि एक काउंटर है जा रहे हैं
का ट्रैक रखने के लिए जा रहा

26
00:01:25,190 --> 00:01:27,780
संख्या JPEGs हमने पाया.

27
00:01:27,780 --> 00:01:31,590
>> और अंत में, हम करने के लिए जा रहे हैं एक
शुरू में शून्य है जो JPEG फ़ाइल

28
00:01:31,590 --> 00:01:35,920
वर्तमान में होने जा रहा है जो
हम करने के लिए लिख रहे हैं कि खुला फाइल.

29
00:01:35,920 --> 00:01:37,540
अब हम जा रहे हैं
एक अतिरिक्त बफर.

30
00:01:37,540 --> 00:01:41,350
यह हमारे sprintf के रूप में ही नहीं है
इस बफर से एक है जहां बफर

31
00:01:41,350 --> 00:01:45,020
हम डेटा में पढ़ रहे हैं कि
कार्ड कच्चे डॉट से.

32
00:01:45,020 --> 00:01:48,900
>> तो बफर का होने जा रहा है
अहस्ताक्षरित घर का काम, जो आप कर सकते हैं

33
00:01:48,900 --> 00:01:53,560
मूल रूप से बस हमें बाइट्स का इलाज है, और यह बात है
आकार ब्लॉक आकार का होने जा रहा

34
00:01:53,560 --> 00:01:57,950
जहां, हम आपको बता के रूप में,
ब्लॉक आकार 512 है.

35
00:01:57,950 --> 00:02:03,070
इसलिए JPEGs आप सब कुछ का इलाज कर सकते हैं
512 बाइट्स के ब्लॉक के रूप में.

36
00:02:03,070 --> 00:02:05,890
>> अब हम पाश के लिए जा रहे हैं
पूरे फाइल के ऊपर.

37
00:02:05,890 --> 00:02:12,980
हम च हमारे बफर में पढ़ने के लिए जा रहे हैं
एक बाइट ब्लॉक आकार टाइम्स से

38
00:02:12,980 --> 00:02:14,710
कार्ड कच्चे फ़ाइल डॉट.

39
00:02:14,710 --> 00:02:16,630
अब F लौटने क्या पढ़ा है?

40
00:02:16,630 --> 00:02:20,050
यह आइटम्स की संख्या देता है
इसे सफलतापूर्वक पढ़ा कि.

41
00:02:20,050 --> 00:02:27,310
यह तो, 512 बाइट्स पढ़ने के लिए प्रबंधित तो अगर
हम इस एक था कि क्या देखना चाहते हैं

42
00:02:27,310 --> 00:02:29,700
JPEG या यह एक JPEG फ़ाइल के लिए लिखते हैं.

43
00:02:29,700 --> 00:02:34,450
और यह 512 बाइट्स वापस नहीं किया, तो
फिर फ़ाइल या तो समाप्त हो गया है

44
00:02:34,450 --> 00:02:37,870
हम y के बाहर तोड़ दूँगा जो मामले
पाश, या त्रुटि के कुछ प्रकार के होते हैं

45
00:02:37,870 --> 00:02:40,300
हम भी बाहर तोड़ दूँगा, जो मामले में
Y पाश, लेकिन हम रिपोर्ट करने के लिए चाहता हूँ

46
00:02:40,300 --> 00:02:41,990
कि कुछ गलत हो गया.

47
00:02:41,990 --> 00:02:42,290
>> ठीक है.

48
00:02:42,290 --> 00:02:47,630
इसलिए हम सफलतापूर्वक पढ़ा यह सोचते हैं कि
512 बाइट्स में, हम पहली बार जाँच करना चाहते हैं

49
00:02:47,630 --> 00:02:53,070
बनाने के लिए कि इन बाइट्स कि हम
बस में पढ़ा एक JPEG शुरू करते हैं.

50
00:02:53,070 --> 00:02:56,430
इसलिए अगर हमारे बफर के जेपीईजी हेडर है.

51
00:02:56,430 --> 00:02:58,460
अब जेपीईजी हेडर यह क्या कर रहा है?

52
00:02:58,460 --> 00:03:00,120
के लग रहे हैं.

53
00:03:00,120 --> 00:03:05,270
>> यहाँ तक, हम इस समारोह है कि देखना
एक बैल लौटने, और उस बैल -

54
00:03:05,270 --> 00:03:08,820
अच्छी तरह से यहाँ, हम देखने के लिए जाँच कर रहे हैं
हैडर शून्य यह निरंतर बराबर होती है और

55
00:03:08,820 --> 00:03:11,880
हैडर एक यह निरंतर बराबर होती है और
हैडर दो, यह निरंतर बराबर होती है

56
00:03:11,880 --> 00:03:15,640
हैडर तीन इस या इस के बराबर होती है
इन सभी स्थिरांक हैं जहां लगातार

57
00:03:15,640 --> 00:03:20,340
बस यहीं से परिभाषित हैश और हैं
हम कल्पना में तुमसे कहा था कि क्या वास्तव में

58
00:03:20,340 --> 00:03:22,700
एक JPEG के साथ शुरू होता है.

59
00:03:22,700 --> 00:03:27,300
और इसलिए इस समारोह में सिर्फ जा रहा है
इस बफर का प्रतिनिधित्व करता है अगर सच वापसी

60
00:03:27,300 --> 00:03:31,750
एक नए जेपीईजी की शुरुआत
और झूठी अन्यथा.

61
00:03:31,750 --> 00:03:32,520
>> ठीक है.

62
00:03:32,520 --> 00:03:38,490
यह एक नया जेपीईजी का प्रतिनिधित्व करता है तो अगर,
तो हम पहली बार देखने के लिए जाँच करना चाहते हैं

63
00:03:38,490 --> 00:03:42,030
JPEG फ़ाइल, अशक्त करने के बराबर नहीं है
जो मामले में हम इसे बंद कर दें.

64
00:03:42,030 --> 00:03:44,940
और तो क्यों हम जांच की जरूरत है
यह रिक्त नहीं है अगर देखा? को

65
00:03:44,940 --> 00:03:48,980
वैसे बहुत पहले जेपीईजी कि हम
हम पहले से ही नहीं मिलेगा

66
00:03:48,980 --> 00:03:50,440
एक खुला JPEG फ़ाइल.

67
00:03:50,440 --> 00:03:55,580
और हां, तो हम फिर, कि बंद करने की कोशिश
हम काफी कुछ सही नहीं कर रहे हैं.

68
00:03:55,580 --> 00:03:59,090
>> लेकिन हर बाद जेपीईजी कि
हम खोलने, हम बंद करना चाहते हैं

69
00:03:59,090 --> 00:04:00,710
पिछली फाईल.

70
00:04:00,710 --> 00:04:04,630
तो अब हम हम के रूप में sprintf का उपयोग करने के लिए जा रहे हैं
हम प्रयोग कर रहे हैं, जहां पहले कहा

71
00:04:04,630 --> 00:04:06,280
बफर JPEG फ़ाइल नाम.

72
00:04:06,280 --> 00:04:09,870
और हम JPEG फ़ाइल का उपयोग करने के लिए जा रहे हैं
हमारे प्रारूप के रूप में प्रारूप नाम है.

73
00:04:09,870 --> 00:04:12,030
और वह क्या है?

74
00:04:12,030 --> 00:04:18,450
यहाँ तक, हम यह प्रतिशत शून्य है कि देखना
3D.JPEG जहां शून्य तीन बस

75
00:04:18,450 --> 00:04:22,089
हम तीन पूर्णांकों का उपयोग करेंगे कहते हैं कि
इस के लिए शून्य के साथ मोटा.

76
00:04:22,089 --> 00:04:27,470
तो यह है कि हम शून्य शून्य मिलेगा कैसे है
इतने पर one.JPEG और शून्य 10.JPEG और.

77
00:04:27,470 --> 00:04:29,060
>> हम sprintf का उपयोग करने के लिए जा रहे हैं.

78
00:04:29,060 --> 00:04:33,760
और हम डालने रहे हैं कि पूर्णांक
स्ट्रिंग सुन्न JPEGs है में

79
00:04:33,760 --> 00:04:36,380
मूल रूप से शून्य है, जो बरामद किए.

80
00:04:36,380 --> 00:04:39,950
तो पहले फ़ाइल जा रहा है खोला
शून्य शून्य शून्य डॉट जेपीईजी हो.

81
00:04:39,950 --> 00:04:43,330
और फिर हम तो यह incrementing रहे
हम खोलने के अगले फाइल शून्य शून्य हो जाएगा

82
00:04:43,330 --> 00:04:46,830
एक डॉट JPEG और हम यह वेतन वृद्धि करेंगे
फिर तो यह शून्य शून्य दो डॉट रहूँगा

83
00:04:46,830 --> 00:04:49,100
इतने पर JPEG और.

84
00:04:49,100 --> 00:04:49,850
>> ठीक है.

85
00:04:49,850 --> 00:04:53,210
तो अब JPEG फ़ाइल के अंदर
नाम है, हम का नाम है

86
00:04:53,210 --> 00:04:54,990
हम चाहते हैं कि फ़ाइल.

87
00:04:54,990 --> 00:04:58,640
हम च लेखन के लिए उस फ़ाइल को खोल सकते हैं.

88
00:04:58,640 --> 00:04:59,170
ठीक है.

89
00:04:59,170 --> 00:05:02,820
और एक बार फिर, हम करने के लिए जांच की जरूरत
सुनिश्चित करें कि सफलतापूर्वक फ़ाइल

90
00:05:02,820 --> 00:05:08,460
यह नहीं, तो किया था, क्योंकि अगर खोला
कुछ त्रुटि थी.

91
00:05:08,460 --> 00:05:13,100
>> तो अब हम अतीत मिल गया है
इस एक JPEG हिस्सा है.

92
00:05:13,100 --> 00:05:16,390
और यहाँ, हम हम जा रहे हैं देखते हैं
जेपीईजी करने के लिए लिखने के लिए.

93
00:05:16,390 --> 00:05:20,980
लेकिन हम पहले कहते हैं जो इस जांच
JPEG फ़ाइल बराबर अशक्त नहीं करता है.

94
00:05:20,980 --> 00:05:22,490
हम क्यों कि जरूरत है?

95
00:05:22,490 --> 00:05:28,020
खैर JPEG फ़ाइल बातिल के बराबर होती है जब हम
फिलहाल एक खुला जेपीईजी है.

96
00:05:28,020 --> 00:05:31,870
>> क्या कार्ड डॉट कच्चे शुरू होता है
बाइट्स का एक गुच्छा के साथ कि

97
00:05:31,870 --> 00:05:33,510
एक JPEG का प्रतिनिधित्व नहीं करते?

98
00:05:33,510 --> 00:05:36,240
तो फिर हम करना चाहते करने जा रहे हैं
उन बाइट्स पर छोड़.

99
00:05:36,240 --> 00:05:39,600
हम यह जांच नहीं करते हैं, तो हम कर रहे हैं
एक बंद करने के लिए लिखने जा रहा

100
00:05:39,600 --> 00:05:45,540
के पहले 512 बाइट्स फ़ाइल
जो अच्छा नहीं है कार्ड.

101
00:05:45,540 --> 00:05:46,030
ठीक है.

102
00:05:46,030 --> 00:05:51,330
>> तो फिर, हम एक खुली फ़ाइल है संभालने
हम उस फ़ाइल को लिखने के लिए जा रहे हैं

103
00:05:51,330 --> 00:05:53,290
हम अपने बफर में है कि 512 बाइट्स.

104
00:05:53,290 --> 00:05:57,390
और हम एक बार फिर से बनाने के लिए जाँच कर रहे हैं
सुनिश्चित करें कि सफलतापूर्वक 512 बाइट्स

105
00:05:57,390 --> 00:06:01,140
यदि वे नहीं थे क्योंकि लिखा गया
सफलतापूर्वक लिखा, तो कुछ

106
00:06:01,140 --> 00:06:02,080
गलत हो गया था.

107
00:06:02,080 --> 00:06:06,540
हम चाहते हैं कि प्रिंट, हमारे फाइलें बंद कर देंगे
कुछ गलत हो गया था, और वापसी.

108
00:06:06,540 --> 00:06:10,940
मान लिया जाये कि सब कुछ तो सही ढंग से चला जाता है
हम समापन पाशन रखेंगे

109
00:06:10,940 --> 00:06:15,060
पुरानी फाइल, नई फ़ाइल खोलने, लेखन
इसलिए नई फ़ाइल के लिए डेटा, और

110
00:06:15,060 --> 00:06:20,990
अंत में, इस च पढ़ा जब तक पर
शून्य देता है जो साधन

111
00:06:20,990 --> 00:06:23,280
फ़ाइल किया है कि.

112
00:06:23,280 --> 00:06:28,490
>> तो अब कार्ड पढ़ने खत्म हो गया है कि, हम
हम एफ बंद करने के लिए जा रहे हैं कि देखने

113
00:06:28,490 --> 00:06:33,250
हम खुला था, लेकिन लगता है कि पिछले फ़ाइल
हम जाँच कर रहे हैं अगर JPEG फ़ाइल

114
00:06:33,250 --> 00:06:34,900
बराबर नहीं अशक्त करता है.

115
00:06:34,900 --> 00:06:39,520
खैर F करीब वजह के रूप में समझ में आता है
हम हम बंद कर रहे हैं, फाइल खोल रहे हैं

116
00:06:39,520 --> 00:06:43,870
पिछले फ़ाइल, लेकिन बहुत पिछले
हम खोला है कि फाइल को बंद कर दिया जाता है कभी नहीं.

117
00:06:43,870 --> 00:06:45,580
इसलिए कि यह क्या कर रहा है है.

118
00:06:45,580 --> 00:06:47,720
>> लेकिन क्यों हम अशक्त के लिए जांच की जरूरत है?

119
00:06:47,720 --> 00:06:53,130
खैर क्या हुआ अगर कार्ड डॉट कच्चे नहीं किया
इसके अंदर एक भी जेपीईजी है?

120
00:06:53,130 --> 00:06:56,640
उस मामले में, हम होगा
एक फाइल कभी नहीं खोला.

121
00:06:56,640 --> 00:07:00,230
हम एक फ़ाइल खोलने कभी नहीं और अगर, हम चाहिए
उस फ़ाइल को बंद करने का प्रयास नहीं.

122
00:07:00,230 --> 00:07:03,000
इसलिए कि यह चेक कर रहा है.

123
00:07:03,000 --> 00:07:07,880
>> जैसा मैंने पहले कहा अब यहाँ, हम कर सकते थे
कि y पाश या तो अगर बाहर तोड़ दिया है

124
00:07:07,880 --> 00:07:13,520
कार्ड अगर वहाँ समाप्त हो गया है या
कार्ड से पढ़ कुछ त्रुटि.

125
00:07:13,520 --> 00:07:16,680
तो यह था कि वहाँ देखने के लिए जाँच कर रहा है
में, कार्ड से पढ़ने में त्रुटि

126
00:07:16,680 --> 00:07:19,400
जो भी मामला है, हम वहाँ कहूँगा
एक त्रुटि पढ़ रहा था.

127
00:07:19,400 --> 00:07:22,130
हम उपयोगकर्ता लगता नहीं करना चाहती
सब कुछ सफलतापूर्वक चला गया.

128
00:07:22,130 --> 00:07:24,750
और हम त्रुटि के लिए एक वापस कर देंगे.

129
00:07:24,750 --> 00:07:29,580
>> अंत में, हम एफ हमारे कच्चे फाइल को बंद कर देंगे,
हमारे कार्ड संकेत मिलता है कि कच्चे डॉट

130
00:07:29,580 --> 00:07:34,070
सब कुछ ठीक है और वापसी के लिए चला गया
शून्य और यह बात है.

131
00:07:34,070 --> 00:07:36,130
>> मेरा नाम रोब है और इस पुनर्प्राप्त था.

132
00:07:36,130 --> 00:07:42,102
>> [संगीत खेल]