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