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
Так почему восемь?

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
Мы собираемся е читать в нашей буфера
а одиночные раз размер блока от

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
>> ОК.

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
>> ОК.

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 и мы будем увеличивать его
снова так что это будет ноль ноль два точка

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
И вот, мы видим, что мы собираемся
для записи в формате JPEG.

93
00:05:16,390 --> 00:05:20,980
Но мы сначала должны эту проверку в котором говорится,
если файл JPEG не равен NULL.

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
ОК.

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
не равен NULL.

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
>> [Музыка играет]