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

2
00:00:00,494 --> 00:00:13,350
>> [MUSIC SPIEL]

3
00:00:13,350 --> 00:00:14,080
>> ROB BOWDEN: Hallo.

4
00:00:14,080 --> 00:00:17,550
Ich bin Rob, und hoffen wir, dass
Diese Lösung hilft, setzen Sie

5
00:00:17,550 --> 00:00:19,600
auf dem Weg der Besserung.

6
00:00:19,600 --> 00:00:22,700
Also lasst uns loslegen.

7
00:00:22,700 --> 00:00:25,660
>> Wir sehen, dass wir sofort
nur um sicherzugehen, dass wir

8
00:00:25,660 --> 00:00:27,170
Verwendung ordnungsgemäß wiederherstellen.

9
00:00:27,170 --> 00:00:31,490
So ist die Nutzung sollte nur etwas sein
wie Punktstrich erholen.

10
00:00:31,490 --> 00:00:35,500
>> Jetzt werden wir öffnen die erwartete
Karte dot RAW-Datei.

11
00:00:35,500 --> 00:00:39,740
Wir sehen hier, dass wir mit Hilfe der
konstant Roh Strich Dateiname,

12
00:00:39,740 --> 00:00:44,200
die bis hier haben wir Hash
definiert als Karte dot roh.

13
00:00:44,200 --> 00:00:45,030
OK.

14
00:00:45,030 --> 00:00:48,210
>> Also müssen wir dafür sorgen, dass die
erfolgreich geöffnet, denn wenn es

15
00:00:48,210 --> 00:00:51,150
nicht, dann sollten wir den Benutzer zu warnen.

16
00:00:51,150 --> 00:00:56,770
Aber davon aus, dass es tat, jetzt sind wir
gehen, um einen Puffer der Größe JPEG erklären

17
00:00:56,770 --> 00:00:58,170
Länge des Dateinamens.

18
00:00:58,170 --> 00:01:02,060
Also, das wird der Puffer sein, dass
wir werden in sprintf.

19
00:01:02,060 --> 00:01:04,360
>> Also, was ist JPEG-Dateinamenslänge?

20
00:01:04,360 --> 00:01:08,490
Hier oben, sehen wir, dass es
Hash definiert als acht.

21
00:01:08,490 --> 00:01:10,670
Warum also acht?

22
00:01:10,670 --> 00:01:15,150
Nun, eine bestimmte Datei benannt werden
so etwas wie Null Null Null.

23
00:01:15,150 --> 00:01:19,460
JPG und dann müssen wir einen Backslash Null.

24
00:01:19,460 --> 00:01:22,720
Also brauchen wir einen Puffer, der kann
speichern acht Zeichen.

25
00:01:22,720 --> 00:01:25,190
Jetzt werden wir einen Zähler, ist zu haben
gehen, um den Überblick über die zu halten

26
00:01:25,190 --> 00:01:27,780
Anzahl JPEGs wir gefunden haben.

27
00:01:27,780 --> 00:01:31,590
>> Und schließlich werden wir haben ein
JPEG-Datei, die zunächst null ist

28
00:01:31,590 --> 00:01:35,920
die gehen, um die aktuell sein
Datei öffnen, die wir zu schreiben.

29
00:01:35,920 --> 00:01:37,540
Jetzt sind wir zu haben,
ein zusätzlicher Puffer.

30
00:01:37,540 --> 00:01:41,350
Dies ist nicht der gleiche wie unsere sprintf
Puffer, in dem dieser Puffer ist derjenige

31
00:01:41,350 --> 00:01:45,020
dass wir in der Daten lesen sind
von der Karte dot roh.

32
00:01:45,020 --> 00:01:48,900
>> So wird der Puffer gehen, um sein
unsigned chars, die Sie

33
00:01:48,900 --> 00:01:53,560
im Grunde nur behandeln uns Bytes, und es ist
gehen, um der Größe der Blockgröße sein

34
00:01:53,560 --> 00:01:57,950
wo, wie wir sagen Ihnen,
Blockgröße ist 512.

35
00:01:57,950 --> 00:02:03,070
So JPEGs kann man alles behandeln
als Blöcke von 512 Bytes.

36
00:02:03,070 --> 00:02:05,890
>> Jetzt sind wir in einer Schleife gehen
über die gesamte Datei.

37
00:02:05,890 --> 00:02:12,980
Wir werden in unsere f Puffer gelesen
ein einziges Byte Blockgröße Zeiten von

38
00:02:12,980 --> 00:02:14,710
die Karte dot RAW-Datei.

39
00:02:14,710 --> 00:02:16,630
Nun, was bedeutet f lesen zurückkehren?

40
00:02:16,630 --> 00:02:20,050
Sie gibt die Anzahl der Elemente
dass es erfolgreich gelesen.

41
00:02:20,050 --> 00:02:27,310
Also, wenn es gelungen, 512 Bytes zu lesen, dann
wir sehen, ob das eine wollen

42
00:02:27,310 --> 00:02:29,700
JPEG oder schreiben Sie es auf eine JPEG-Datei.

43
00:02:29,700 --> 00:02:34,450
Und wenn es hat 512 Byte nicht zurück,
dann entweder die Datei im zu Ende ist

44
00:02:34,450 --> 00:02:37,870
welcher Fall werden wir aus der y brechen
Schleife, oder gibt es eine Art von Fehler

45
00:02:37,870 --> 00:02:40,300
in diesem Fall werden wir auch durchbrechen
die y-Schleife, aber wollen wir zu berichten,

46
00:02:40,300 --> 00:02:41,990
dass etwas schief gelaufen ist.

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

48
00:02:42,290 --> 00:02:47,630
Also unter der Annahme, dass wir erfolgreich gelesen
in 512 Bytes, wir wollen erste Prüfung

49
00:02:47,630 --> 00:02:53,070
zu machen, dass diese Bytes, die wir
lesen Sie einfach in eine JPEG beginnen.

50
00:02:53,070 --> 00:02:56,430
Also, wenn JPEG-Header ist der Puffer.

51
00:02:56,430 --> 00:02:58,460
Nun, was ist JPEG-Header zu tun?

52
00:02:58,460 --> 00:03:00,120
Lassen Sie uns.

53
00:03:00,120 --> 00:03:05,270
>> Hier oben, sehen wir, dass diese Funktion
Rückkehr einen Stier, Stier, und dass -

54
00:03:05,270 --> 00:03:08,820
gut hier, wir überprüfen, ob
Header gleich Null ist und diese Konstante

55
00:03:08,820 --> 00:03:11,880
Kopf eins gleich diese Konstante und
Kopf zwei ist diese Konstante,

56
00:03:11,880 --> 00:03:15,640
Kopf drei gleich diese oder diese
konstant, wo alle diese Konstanten

57
00:03:15,640 --> 00:03:20,340
nur Hash hier definiert und sind
genau das, was wir Ihnen in der Spezifikation erzählt

58
00:03:20,340 --> 00:03:22,700
dass ein JPEG beginnt mit.

59
00:03:22,700 --> 00:03:27,300
Und so wird diese Funktion nur gehen, um
return true, wenn dieser Puffer darstellt

60
00:03:27,300 --> 00:03:31,750
der Beginn einer neuen JPEG
und ansonsten false.

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

62
00:03:32,520 --> 00:03:38,490
Also, wenn dies tut repräsentieren eine neue JPEG,
dann wollen wir, um zu prüfen, ob

63
00:03:38,490 --> 00:03:42,030
JPEG-Datei ist nicht gleich null,
in diesem Fall werden wir schließen.

64
00:03:42,030 --> 00:03:44,940
Und warum brauchen wir, um zu überprüfen
zu sehen, wenn es nicht null?

65
00:03:44,940 --> 00:03:48,980
Nun, die erste, die wir JPEG
finden wir nicht bereits

66
00:03:48,980 --> 00:03:50,440
eine offene JPEG-Datei.

67
00:03:50,440 --> 00:03:55,580
Und so, wenn wir versuchen, das zu schließen, dann
wir nicht etwas ganz richtig machen.

68
00:03:55,580 --> 00:03:59,090
>> Aber jede weitere JPEG dass
wir öffnen, zu schließen, wollen wir

69
00:03:59,090 --> 00:04:00,710
die vorherige Datei.

70
00:04:00,710 --> 00:04:04,630
So, jetzt werden wir sprintf wie wir
gesagt, wo wir mit dem

71
00:04:04,630 --> 00:04:06,280
Puffer JPEG Dateinamen.

72
00:04:06,280 --> 00:04:09,870
Und wir werden in JPEG-Datei verwenden
nennen Format wie unser Format.

73
00:04:09,870 --> 00:04:12,030
Und was ist das?

74
00:04:12,030 --> 00:04:18,450
Hier oben, sehen wir, dass es Null Prozent
3D.jpeg, wo die Null nur drei

75
00:04:18,450 --> 00:04:22,089
sagt, dass wir drei ganze Zahlen verwenden
dafür aufgefüllt mit Nullen.

76
00:04:22,089 --> 00:04:27,470
Das ist also, wie wir null null bekommen
one.JPEG und Null 10.JPEG und so weiter.

77
00:04:27,470 --> 00:04:29,060
>> Wir werden sprintf.

78
00:04:29,060 --> 00:04:33,760
Und die ganze Zahl, die wir Einsetzen
in der String taub JPEGs

79
00:04:33,760 --> 00:04:36,380
gewonnen, welche ursprünglich Null ist.

80
00:04:36,380 --> 00:04:39,950
Also die erste Datei geöffnet wird
Null Null Null Punkt JPEG.

81
00:04:39,950 --> 00:04:43,330
Und dann sind wir es so das Erhöhen
nächste Datei öffnen wir Null Null sein

82
00:04:43,330 --> 00:04:46,830
ein Punkt JPEG und wir werden es erhöhen
wieder so werden es null null zwei Punkt sein

83
00:04:46,830 --> 00:04:49,100
JPEG und so weiter.

84
00:04:49,100 --> 00:04:49,850
>> Gut.

85
00:04:49,850 --> 00:04:53,210
So, jetzt das Innere der JPEG-Datei
zu nennen, haben wir die Namen der

86
00:04:53,210 --> 00:04:54,990
-Datei, die wir wollen.

87
00:04:54,990 --> 00:04:58,640
Wir können f öffnen Sie diese Datei zum Schreiben.

88
00:04:58,640 --> 00:04:59,170
OK.

89
00:04:59,170 --> 00:05:02,820
Und wieder einmal müssen wir überprüfen, um
sicher, dass die Datei erfolgreich

90
00:05:02,820 --> 00:05:08,460
da geöffnet, wenn es nicht tat, dann
es gab einige Fehler.

91
00:05:08,460 --> 00:05:13,100
>> So, jetzt haben wir die Vergangenheit bekommen haben
dies ist ein Teil JPEG.

92
00:05:13,100 --> 00:05:16,390
Und hier sehen wir, wir gehen
auf die JPEG schreiben.

93
00:05:16,390 --> 00:05:20,980
Aber wir müssen zuerst dieses Kontroll, die besagt,
JPEG-Datei, wenn nicht gleich null.

94
00:05:20,980 --> 00:05:22,490
Warum brauchen wir das?

95
00:05:22,490 --> 00:05:28,020
Nun JPEG-Datei ist gleich null, wenn wir
Aktuell haben eine offene JPEG.

96
00:05:28,020 --> 00:05:31,870
>> Was ist, wenn Karte dot Roh beginnt
mit einem Bündel von Bytes, die

97
00:05:31,870 --> 00:05:33,510
keine JPEG darstellen?

98
00:05:33,510 --> 00:05:36,240
Dann werden wir zu wollen
Überspringen dieser Bytes.

99
00:05:36,240 --> 00:05:39,600
Wenn wir nicht dieses Kontroll, dann sind wir
gehen, um zu einer ungeöffneten schreiben

100
00:05:39,600 --> 00:05:45,540
Datei die ersten 512 Bytes der
die Karte, die nicht gut ist.

101
00:05:45,540 --> 00:05:46,030
OK.

102
00:05:46,030 --> 00:05:51,330
>> Also vorausgesetzt wir eine offene Datei haben, dann
wir werden in diese Datei schreiben die

103
00:05:51,330 --> 00:05:53,290
512 Bytes, die in unserem Puffer zu haben.

104
00:05:53,290 --> 00:05:57,390
Und wir sind noch einmal überprüfen, um
sicher, dass die 512 Bytes erfolgreich

105
00:05:57,390 --> 00:06:01,140
geschrieben wurden, weil, wenn sie es nicht waren
erfolgreich geschrieben, dann ist etwas

106
00:06:01,140 --> 00:06:02,080
ging schief.

107
00:06:02,080 --> 00:06:06,540
Wir werden unsere Dateien zu schließen, drucken, dass
etwas schief gelaufen, und zurück.

108
00:06:06,540 --> 00:06:10,940
Unter der Annahme, alles richtig geht, dann
wir halten Looping Schließen der

109
00:06:10,940 --> 00:06:15,060
alte Datei, Öffnen Sie die neue Datei, Schreiben
Daten in die neue Datei usw.

110
00:06:15,060 --> 00:06:20,990
auf, bis schließlich diese f lesen
Null zurück, was bedeutet,

111
00:06:20,990 --> 00:06:23,280
dass die Datei erfolgt.

112
00:06:23,280 --> 00:06:28,490
>> So, jetzt, dass das Kartenlese ist vorbei, wir
sehen, dass wir gehen, um f schließen

113
00:06:28,490 --> 00:06:33,250
letzte Datei, die wir hatten offen, aber
wir überprüfen, ob JPEG-Datei

114
00:06:33,250 --> 00:06:34,900
nicht gleich null.

115
00:06:34,900 --> 00:06:39,520
Nun, die f in der Nähe macht Sinn, weil, wie
wir sind das Öffnen von Dateien, die wir schließen

116
00:06:39,520 --> 00:06:43,870
die vorherige Datei, aber die letzten
Datei, die wir geöffnet wird nie geschlossen.

117
00:06:43,870 --> 00:06:45,580
Also das ist, was dieser tut.

118
00:06:45,580 --> 00:06:47,720
>> Aber warum müssen wir für null überprüfen?

119
00:06:47,720 --> 00:06:53,130
Nun, was ist, wenn Karte dot roh nicht
eine einzelne JPEG innerhalb der IT?

120
00:06:53,130 --> 00:06:56,640
In diesem Fall hätten wir
noch nie eine Datei.

121
00:06:56,640 --> 00:07:00,230
Und wenn wir eine Datei öffnen nie, wir sollten
nicht versuchen, diese Datei zu schließen.

122
00:07:00,230 --> 00:07:03,000
Also das ist, was dieses Kontroll tut.

123
00:07:03,000 --> 00:07:07,880
>> Jetzt ist hier, wie ich schon sagte, wir konnten
haben, dass y-Schleife, wenn entweder gebrochen

124
00:07:07,880 --> 00:07:13,520
die Karte beendet ist, oder wenn es
einige Fehler beim Lesen von der Karte.

125
00:07:13,520 --> 00:07:16,680
Das ist also zu überprüfen, ob es
Fehler beim Lesen von der Karte, in

126
00:07:16,680 --> 00:07:19,400
wobei in diesem Fall, werden wir es sagen
war ein Fehler beim Lesen.

127
00:07:19,400 --> 00:07:22,130
Wir wollen nicht, dass der Benutzer zu denken,
alles verlief erfolgreich.

128
00:07:22,130 --> 00:07:24,750
Und wir werden eine für Fehler zurück.

129
00:07:24,750 --> 00:07:29,580
>> Schließlich werden wir schließen unsere f RAW-Datei,
unsere Karte dot roh, zu zeigen, dass

130
00:07:29,580 --> 00:07:34,070
alles ging gut und Rückkehr
Null und das ist es.

131
00:07:34,070 --> 00:07:36,130
>> Mein Name ist Rob und das war Wiederherstellen.

132
00:07:36,130 --> 00:07:42,102
>> [MUSIC SPIEL]