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: Hi.

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
OK.

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
Така че това ще бъде най-буфер, който
ние ще Оферта номер в.

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
брой на 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
Това не е същото като нашия Оферта номер
буфер, където този буфер е този

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
Сега какво е прочетете върне?

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
който случай ние ще се измъкнат от ш
контур, или има някаква грешка

45
00:02:37,870 --> 00:02:40,300
като в този случай също така ние ще се измъкнат от
у линия, но ние ще искате да докладвате

46
00:02:40,300 --> 00:02:41,990
че нещо се е объркало.

47
00:02:41,990 --> 00:02:42,290
>> OK.

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
заглавна три е равно на това или това
постоянна, където всички тези константи са

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
началото на нов JPEG
и лъжа в противен случай.

61
00:03:31,750 --> 00:03:32,520
>> OK.

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
Така че сега ние ще използваме Оферта номер, тъй като ние
каза преди, когато сме с помощта на

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
>> Ние ще използваме Оферта номер.

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
Така че първият файл се отвори ще
да бъде нула нула нула точка JPEG.

81
00:04:39,950 --> 00:04:43,330
И след това ние сме го увеличаване, така че
следващия файл отворим ще бъде нула нула

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
OK.

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 файл се равнява на нула, когато ние
В момента има открита 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
OK.

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
Ами е края има смисъл, тъй като
ние сме отваряне на файлове, ние затваряме

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
Ами какво, ако картата точка сурово не направих
има един 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
>> И накрая, ще е затваряме суров файл,
ни карти Дот сурови, за да покаже, че

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
>> [За възпроизвеждане на музика]