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

2
00:00:00,494 --> 00:00:13,350
>> [GIOCO MUSICA]

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

4
00:00:14,080 --> 00:00:17,550
Sono Rob e speriamo che
questa soluzione consente di mettere

5
00:00:17,550 --> 00:00:19,600
sulla strada della ripresa.

6
00:00:19,600 --> 00:00:22,700
Quindi cerchiamo di iniziare.

7
00:00:22,700 --> 00:00:25,660
>> Vediamo che subito siamo
solo per assicurarsi che siamo

8
00:00:25,660 --> 00:00:27,170
Uso di Ripristino correttamente.

9
00:00:27,170 --> 00:00:31,490
Quindi, l'utilizzo dovrebbe essere solo qualcosa
come barra dot recuperare.

10
00:00:31,490 --> 00:00:35,500
>> Ora stiamo andando ad aprire l'atteso
Scheda dot file raw.

11
00:00:35,500 --> 00:00:39,740
Vediamo qui che stiamo usando la
costante il nome del file di sottolineatura raw,

12
00:00:39,740 --> 00:00:44,200
che qui abbiamo hash
definita come carta dot crudo.

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

14
00:00:45,030 --> 00:00:48,210
>> Quindi dobbiamo fare in modo che tale
aperto con successo perché se

15
00:00:48,210 --> 00:00:51,150
non ha, allora dovremmo avvertire l'utente.

16
00:00:51,150 --> 00:00:56,770
Ma supponendo che lo ha fatto, ora siamo
andando a dichiarare un buffer di dimensioni JPEG

17
00:00:56,770 --> 00:00:58,170
file di lunghezza del nome.

18
00:00:58,170 --> 00:01:02,060
Quindi questo sarà il buffer che
stiamo andando a sprintf in.

19
00:01:02,060 --> 00:01:04,360
>> Così che cosa è un file JPEG lunghezza del nome?

20
00:01:04,360 --> 00:01:08,490
Quassù, vediamo che si tratta di
hash definito come otto.

21
00:01:08,490 --> 00:01:10,670
Allora perché otto?

22
00:01:10,670 --> 00:01:15,150
Beh un dato file verrà denominato
qualcosa come zero zero zero.

23
00:01:15,150 --> 00:01:19,460
JPG e quindi abbiamo bisogno di un backslash zero.

24
00:01:19,460 --> 00:01:22,720
Quindi abbiamo bisogno di un buffer che può
memorizzare otto caratteri.

25
00:01:22,720 --> 00:01:25,190
Ora stiamo andando ad avere un contatore che è
andando a tenere traccia della

26
00:01:25,190 --> 00:01:27,780
numero JPEG abbiamo trovato.

27
00:01:27,780 --> 00:01:31,590
>> E, infine, stiamo andando ad avere un
File JPEG che inizialmente è nullo

28
00:01:31,590 --> 00:01:35,920
che sta per essere attualmente
aprire il file che stiamo scrivendo a.

29
00:01:35,920 --> 00:01:37,540
Ora stiamo andando ad avere
un buffer aggiuntivo.

30
00:01:37,540 --> 00:01:41,350
Questo non è la stessa della nostra sprintf
buffer in cui la memoria è quello

31
00:01:41,350 --> 00:01:45,020
che stiamo leggendo nei dati
dalla scheda dot crudo.

32
00:01:45,020 --> 00:01:48,900
>> Così il buffer sarà di
caratteri senza segno, che è possibile

33
00:01:48,900 --> 00:01:53,560
fondamentalmente solo noi trattare byte, ed è
andando ad essere di dimensioni dimensione del blocco

34
00:01:53,560 --> 00:01:57,950
dove, come vi diciamo,
dimensione del blocco è di 512.

35
00:01:57,950 --> 00:02:03,070
Quindi JPEG si può trattare tutto
come blocchi di 512 byte.

36
00:02:03,070 --> 00:02:05,890
>> Ora stiamo andando a ciclo
per tutto il file.

37
00:02:05,890 --> 00:02:12,980
Stiamo andando a f di leggere nella nostra tampone
un singolo volte byte di dimensione del blocco da

38
00:02:12,980 --> 00:02:14,710
la scheda dot file raw.

39
00:02:14,710 --> 00:02:16,630
Ora, che cosa fa f legge di ritorno?

40
00:02:16,630 --> 00:02:20,050
Restituisce il numero di elementi
che si leggeva correttamente.

41
00:02:20,050 --> 00:02:27,310
Quindi, se è riuscito a leggere 512 byte, quindi
vogliamo vedere se questo è stato un

42
00:02:27,310 --> 00:02:29,700
JPEG o scrivere in un file JPEG.

43
00:02:29,700 --> 00:02:34,450
E se non ha restituito 512 byte,
allora o il file è finito in

44
00:02:34,450 --> 00:02:37,870
qual caso faremo uscire dalla y
loop, o ci sono alcuni tipo di errore

45
00:02:37,870 --> 00:02:40,300
nel qual caso ci sarà anche rompere su
il ciclo y, ma ci vorrà riferire

46
00:02:40,300 --> 00:02:41,990
che qualcosa è andato storto.

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

48
00:02:42,290 --> 00:02:47,630
Quindi, supponendo che siamo riusciti a leggere
in 512 byte, vogliamo primo controllo

49
00:02:47,630 --> 00:02:53,070
per fare che questi byte che
basta leggere in iniziare un JPEG.

50
00:02:53,070 --> 00:02:56,430
Quindi, se è JPEG intestazione della nostra buffer.

51
00:02:56,430 --> 00:02:58,460
Ora che cosa sta facendo JPEG intestazione?

52
00:02:58,460 --> 00:03:00,120
Diamo un'occhiata.

53
00:03:00,120 --> 00:03:05,270
>> Quassù, vediamo che questa funzione è
restituzione di un toro, e che toro -

54
00:03:05,270 --> 00:03:08,820
bene qui, stiamo verificando se
intestazione uguale a zero questa costante e

55
00:03:08,820 --> 00:03:11,880
intestazione uno uguale a questa costante e
intestazione due è uguale a questa costante,

56
00:03:11,880 --> 00:03:15,640
intestazione tre è uguale questo o questo
costante dove tutte queste costanti sono

57
00:03:15,640 --> 00:03:20,340
proprio hash definito qui e sono
esattamente quello che vi abbiamo detto nelle specifiche

58
00:03:20,340 --> 00:03:22,700
che un JPEG inizia con.

59
00:03:22,700 --> 00:03:27,300
E quindi questa funzione è solo andare a
return true se questo buffer rappresenta

60
00:03:27,300 --> 00:03:31,750
l'inizio di un nuovo JPEG
e false altrimenti.

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

62
00:03:32,520 --> 00:03:38,490
Quindi, se questo non rappresenta un nuovo JPEG,
allora per prima cosa vogliamo verificare se

63
00:03:38,490 --> 00:03:42,030
File JPEG non è uguale a null,
nel qual caso noi chiudiamo.

64
00:03:42,030 --> 00:03:44,940
E allora perché abbiamo bisogno di verificare
per vedere se non è nullo?

65
00:03:44,940 --> 00:03:48,980
Beh, la prima JPEG che
trovare non avremo già

66
00:03:48,980 --> 00:03:50,440
un file JPEG aperto.

67
00:03:50,440 --> 00:03:55,580
E così, se cerchiamo di chiudere quella, poi
non stiamo facendo qualcosa di giusto.

68
00:03:55,580 --> 00:03:59,090
>> Ma ogni successivo JPEG
apriamo, vogliamo chiudere

69
00:03:59,090 --> 00:04:00,710
il file precedente.

70
00:04:00,710 --> 00:04:04,630
Così ora stiamo andando a utilizzare sprintf come noi
detto prima dove stiamo usando l'

71
00:04:04,630 --> 00:04:06,280
nome file del buffer JPEG.

72
00:04:06,280 --> 00:04:09,870
E abbiamo intenzione di utilizzare il file JPEG
nome di formato come il nostro format.

73
00:04:09,870 --> 00:04:12,030
E che cos'è?

74
00:04:12,030 --> 00:04:18,450
Quassù, vediamo che è pari a zero per cento
3D.JPEG dove lo zero tre soli

75
00:04:18,450 --> 00:04:22,089
dice che useremo tre numeri interi
per questo riempito con zeri.

76
00:04:22,089 --> 00:04:27,470
Quindi questo è come ci arriveremo zero zero
one.JPEG e lo zero 10.JPEG e così via.

77
00:04:27,470 --> 00:04:29,060
>> Stiamo per usare sprintf.

78
00:04:29,060 --> 00:04:33,760
E il numero intero che stiamo inserendo
nella stringa è JPEG intorpidite

79
00:04:33,760 --> 00:04:36,380
recuperato, che è inizialmente zero.

80
00:04:36,380 --> 00:04:39,950
Così il primo file aperto che sta succedendo
essere zero zero zero virgola JPEG.

81
00:04:39,950 --> 00:04:43,330
E poi stiamo incrementando così la
file successivo apriamo sarà zero zero

82
00:04:43,330 --> 00:04:46,830
un punto JPEG e faremo incrementiamo che
di nuovo così sarà zero zero due punti

83
00:04:46,830 --> 00:04:49,100
JPEG e così via.

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

85
00:04:49,850 --> 00:04:53,210
Così ora all'interno del file JPEG
nome, abbiamo il nome del

86
00:04:53,210 --> 00:04:54,990
file che vogliamo.

87
00:04:54,990 --> 00:04:58,640
Possiamo f aprire il file per la scrittura.

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

89
00:04:59,170 --> 00:05:02,820
E ancora una volta, dobbiamo controllare per
Assicurarsi che il file correttamente

90
00:05:02,820 --> 00:05:08,460
aperto dal se non ha, quindi
c'era qualche errore.

91
00:05:08,460 --> 00:05:13,100
>> Così ora abbiamo ottenuto oltre il
questa è una parte JPEG.

92
00:05:13,100 --> 00:05:16,390
E qui, si vede che stiamo andando
di scrivere al JPEG.

93
00:05:16,390 --> 00:05:20,980
Ma dobbiamo prima questo controllo che dice
se il file JPEG non è uguale null.

94
00:05:20,980 --> 00:05:22,490
Perché abbiamo bisogno di questo?

95
00:05:22,490 --> 00:05:28,020
Beh file JPEG uguale nullo quando
attualmente hanno un JPEG aperto.

96
00:05:28,020 --> 00:05:31,870
>> Che se la scheda dot inizia prime
con un mazzo di byte che

97
00:05:31,870 --> 00:05:33,510
non rappresentano un JPEG?

98
00:05:33,510 --> 00:05:36,240
Poi andremo a voler
saltare quei byte.

99
00:05:36,240 --> 00:05:39,600
Se non abbiamo questo controllo, allora siamo
andando a scrivere in un aperto

100
00:05:39,600 --> 00:05:45,540
presentare i primi 512 byte di
la carta che non è buono.

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

102
00:05:46,030 --> 00:05:51,330
>> Quindi, supponendo che abbiamo un file aperto, quindi
andremo a scrivere quel file l'

103
00:05:51,330 --> 00:05:53,290
512 byte che abbiamo nel nostro buffer.

104
00:05:53,290 --> 00:05:57,390
E stiamo ancora una volta il controllo per assicurarsi
Assicurarsi che i 512 byte successo

105
00:05:57,390 --> 00:06:01,140
sono stati scritti perché se non fossero
scritto con successo, allora qualcosa

106
00:06:01,140 --> 00:06:02,080
è andato storto.

107
00:06:02,080 --> 00:06:06,540
Ci chiudiamo i nostri file, la stampa che
qualcosa è andato storto, e ritorno.

108
00:06:06,540 --> 00:06:10,940
Supponendo che tutto va bene, poi
terremo loop chiusura del

109
00:06:10,940 --> 00:06:15,060
vecchio file, l'apertura del nuovo file, la scrittura
dati al nuovo file, e così

110
00:06:15,060 --> 00:06:20,990
fino alla fine, questo f leggi
restituisce zero, che significa

111
00:06:20,990 --> 00:06:23,280
che il file è fatto.

112
00:06:23,280 --> 00:06:28,490
>> Quindi, ora che la lettura della carta è finita,
vediamo che stiamo andando a chiudere la f

113
00:06:28,490 --> 00:06:33,250
ultimo file che avevamo aperto, ma
stiamo controllando se il file JPEG

114
00:06:33,250 --> 00:06:34,900
non è uguale a null.

115
00:06:34,900 --> 00:06:39,520
Beh, la f vicino ha un senso, perché come
stiamo aprendo i file, stiamo chiudendo

116
00:06:39,520 --> 00:06:43,870
il file precedente, ma l'ultimo
il file che abbiamo aperto non viene mai chiusa.

117
00:06:43,870 --> 00:06:45,580
Ecco, questo è ciò che questo sta facendo.

118
00:06:45,580 --> 00:06:47,720
>> Ma perché abbiamo bisogno di controllare per nulla?

119
00:06:47,720 --> 00:06:53,130
Beh, cosa se la scheda dot prime non ha
avere un unico JPEG all'interno di esso?

120
00:06:53,130 --> 00:06:56,640
In quel caso, avremmo
mai aperto un file.

121
00:06:56,640 --> 00:07:00,230
E se non abbiamo mai aprire un file, dovremmo
Non tentare di chiudere quel file.

122
00:07:00,230 --> 00:07:03,000
Ecco, questo è ciò che questo controllo sta facendo.

123
00:07:03,000 --> 00:07:07,880
>> Ora qui, come ho detto prima, abbiamo potuto
hanno rotto che y ciclo o se

124
00:07:07,880 --> 00:07:13,520
la scheda è terminato o se vi sono
qualche errore di lettura dalla scheda.

125
00:07:13,520 --> 00:07:16,680
Quindi questo è il controllo per vedere se c'era
un errore di lettura dalla scheda, in

126
00:07:16,680 --> 00:07:19,400
qual caso, diremo lì
è stato un errore di lettura.

127
00:07:19,400 --> 00:07:22,130
Non vogliamo l'utente a pensare
tutto è andato con successo.

128
00:07:22,130 --> 00:07:24,750
E torneremo uno per errore.

129
00:07:24,750 --> 00:07:29,580
>> Infine, faremo f chiudiamo il nostro file raw,
la nostra carta dot crudo, per indicare che

130
00:07:29,580 --> 00:07:34,070
tutto è andato bene e ritorno
zero e il gioco è fatto.

131
00:07:34,070 --> 00:07:36,130
>> Il mio nome è Rob e questo era Recover.

132
00:07:36,130 --> 00:07:42,102
>> [GIOCO MUSICA]