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
>> ROB 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
那麼，為什麼8？

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
我們發現數量JPEG文件。

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
所以，JPEG文件，你可以把一切
為512字節的塊。

36
00:02:03,070 --> 00:02:05,890
>> 現在，我們要循環
在整個文件。

37
00:02:05,890 --> 00:02:12,980
我們打算到f讀入我們的緩衝區
從單個字節的塊大小倍

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
所以，如果是我們的緩衝區的JPEG頭。

51
00:02:56,430 --> 00:02:58,460
現在，它是什麼JPEG頭在做什麼？

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
頭3等於這個或這
不變，所有這些常數是

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
所以這個功能只是將
返回true，如果此緩衝區代表

60
00:03:27,300 --> 00:03:31,750
一個新的JPEG開始
否則為false。

61
00:03:31,750 --> 00:03:32,520
>> 確定。

62
00:03:32,520 --> 00:03:38,490
因此，如果這確實代表了一種新的JPEG，
那麼我們首先要檢查，看是否

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
好極第一張JPEG我們
找到我們不會已經有

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
>> 但以後每JPEG格式的
我們打開，我們要關閉

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
和整數，我們要插入
成字符串是麻木的JPEG

79
00:04:33,760 --> 00:04:36,380
回收的，這是最初為零。

80
00:04:36,380 --> 00:04:39,950
因此，第一個文件打開是怎麼回事
是零零零點JPEG格式。

81
00:04:39,950 --> 00:04:43,330
然後我們遞增它使
我們打開下一個文件將是零零

82
00:04:43,330 --> 00:04:46,830
一個點的JPEG，我們會增加它
再這樣它會是零零2點

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
我們可以在F打開該文件進行寫操作。

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
在這裡，我們看到了我們要去
寫入到JPEG。

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文件等於null，當我們
目前有一個開放的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
直到最後，這架F閱讀
返回零這意味著

111
00:06:20,990 --> 00:06:23,280
該文件被完成。

112
00:06:23,280 --> 00:06:28,490
>> 所以，現在的讀卡結束了，我們
看到我們要去F關閉

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
>> 但是，為什麼我們需要檢查是否為null？

119
00:06:47,720 --> 00:06:53,130
好吧，如果卡點生沒
有它在一個單一的JPEG？

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
>> 現在在這裡，正如我以前說過，我們可以
已經打破了，Ÿ循環或者如果

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
>> 最後，我們將f關閉我們的原始文件，
我們的卡點原料，以表明

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
>> [音樂播放]