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

2
00:00:00,494 --> 00:00:13,350
>> [Música tocando]

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

4
00:00:14,080 --> 00:00:17,550
Estou Rob, e imos esperar que
esta solución axuda a colocar-lo

5
00:00:17,550 --> 00:00:19,600
no camiño para a recuperación.

6
00:00:19,600 --> 00:00:22,700
Entón, imos comezar.

7
00:00:22,700 --> 00:00:25,660
>> Vemos que estamos inmediatamente
só para ter seguro de que estamos

8
00:00:25,660 --> 00:00:27,170
Solicitar utilizando correctamente.

9
00:00:27,170 --> 00:00:31,490
Así, o uso debe ser só algo
como barra dot recuperar.

10
00:00:31,490 --> 00:00:35,500
>> Agora imos abrir esperado
tarxeta de punto ficheiro raw.

11
00:00:35,500 --> 00:00:39,740
Vemos aquí que estamos usando a
constante nome do ficheiro subliñado cru,

12
00:00:39,740 --> 00:00:44,200
que ata aquí temos de hash
definido como tarxeta de punto cru.

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

14
00:00:45,030 --> 00:00:48,210
>> Por iso, necesitamos ter seguro de que iso
aberto correctamente porque se

15
00:00:48,210 --> 00:00:51,150
non, entón temos que avisar o usuario.

16
00:00:51,150 --> 00:00:56,770
Pero supoñendo que fixo, agora estamos
vai declarar un buffer de tamaño JPEG

17
00:00:56,770 --> 00:00:58,170
ficheiro longo do nome.

18
00:00:58,170 --> 00:01:02,060
Polo tanto, este será o tapón que
imos en sprintf.

19
00:01:02,060 --> 00:01:04,360
>> Entón o que é JPEG arquivo lonxitude do nome?

20
00:01:04,360 --> 00:01:08,490
Ata aquí, vemos que é
botar axusta oito.

21
00:01:08,490 --> 00:01:10,670
Entón, por oito anos?

22
00:01:10,670 --> 00:01:15,150
Ben un determinado arquivo será nomeado
algo así como cero cero cero.

23
00:01:15,150 --> 00:01:19,460
JPG e entón necesitamos unha barra invertida cero.

24
00:01:19,460 --> 00:01:22,720
Entón necesitamos un buffer que pode
almacenar oito caracteres.

25
00:01:22,720 --> 00:01:25,190
Agora imos ter un contador que se
vai seguir o

26
00:01:25,190 --> 00:01:27,780
JPEGs número que atopamos.

27
00:01:27,780 --> 00:01:31,590
>> E, finalmente, imos ter un
Ficheiro JPEG que é inicialmente nula

28
00:01:31,590 --> 00:01:35,920
cal será o momento
ficheiro aberto que estamos escribindo.

29
00:01:35,920 --> 00:01:37,540
Agora imos ter
un tapón adicional.

30
00:01:37,540 --> 00:01:41,350
Este non é o mesmo que o noso sprintf
buffer onde ese buffer é aquel

31
00:01:41,350 --> 00:01:45,020
que estamos lendo nos datos
da tarxeta de punto cru.

32
00:01:45,020 --> 00:01:48,900
>> Así, o tapón será de
caracteres non asinados, que pode

33
00:01:48,900 --> 00:01:53,560
basicamente só nos tratan bytes, e é
será do tamaño do tamaño do bloque

34
00:01:53,560 --> 00:01:57,950
onde, como lle digo,
tamaño do bloque é 512.

35
00:01:57,950 --> 00:02:03,070
Entón JPEGs pode tratar de todo
como bloques de 512 bytes.

36
00:02:03,070 --> 00:02:05,890
>> Agora imos facer un loop
sobre o arquivo enteiro.

37
00:02:05,890 --> 00:02:12,980
Imos f ler na nosa memoria intermedia
un único byte veces tamaño do bloque de

38
00:02:12,980 --> 00:02:14,710
a tarxeta de punto ficheiro raw.

39
00:02:14,710 --> 00:02:16,630
Agora, o que f ler volver?

40
00:02:16,630 --> 00:02:20,050
El retorna o número de elementos
que trata con éxito.

41
00:02:20,050 --> 00:02:27,310
Entón, se conseguiu ler 512 bytes, logo
queremos ver se este era un

42
00:02:27,310 --> 00:02:29,700
JPEG ou gravalo nun ficheiro JPEG.

43
00:02:29,700 --> 00:02:34,450
E se non volver 512 bytes,
a continuación, o ficheiro terminou en

44
00:02:34,450 --> 00:02:37,870
caso en que nós imos saír do y
loop, ou se hai algún tipo de erro

45
00:02:37,870 --> 00:02:40,300
caso en que tamén vai saír da
o loop y, pero imos querer denunciar

46
00:02:40,300 --> 00:02:41,990
que algo deu errado.

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

48
00:02:42,290 --> 00:02:47,630
Así, supoñendo que lemos correctamente
en 512 bytes, queremos primeiro cheque

49
00:02:47,630 --> 00:02:53,070
para facer que estes bytes que
acabo de ler en comezar un JPEG.

50
00:02:53,070 --> 00:02:56,430
Entón, se é cabeceira JPEG do noso buffer.

51
00:02:56,430 --> 00:02:58,460
Agora, o que é cabeceira JPEG facendo?

52
00:02:58,460 --> 00:03:00,120
Imos dar un ollo.

53
00:03:00,120 --> 00:03:05,270
>> Ata aquí, vemos que esta función é
volvendo un touro, e aquel touro -

54
00:03:05,270 --> 00:03:08,820
ben aquí, estamos comprobando se
cabeceira de cero é igual a este constante e

55
00:03:08,820 --> 00:03:11,880
cabeceira un é igual a esta constante e
cabeceira dous é igual a esta constante,

56
00:03:11,880 --> 00:03:15,640
cabeceira de tres é igual a este ou esta
constante, onde todos estes son constantes

57
00:03:15,640 --> 00:03:20,340
só botar definido aquí e son
exactamente o que contámosvos na especificación

58
00:03:20,340 --> 00:03:22,700
que comeza cun formato JPEG.

59
00:03:22,700 --> 00:03:27,300
E así, esta función só vai
return true si este tapón representa

60
00:03:27,300 --> 00:03:31,750
o inicio dun novo JPEG
e falso en caso contrario.

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

62
00:03:32,520 --> 00:03:38,490
Entón, se isto non representa un novo JPEG,
entón primeiro quero comprobar a ver se

63
00:03:38,490 --> 00:03:42,030
Ficheiro JPEG non é igual a cero,
caso en que o pechar.

64
00:03:42,030 --> 00:03:44,940
E así, por que necesitamos comprobar
a ver se non é nulo?

65
00:03:44,940 --> 00:03:48,980
Ben, o primeiro JPEG que
atopar non imos xa ten

66
00:03:48,980 --> 00:03:50,440
un arquivo JPEG aberto.

67
00:03:50,440 --> 00:03:55,580
E así, se tentar pechar iso, entón
nós non estamos facendo algo certo.

68
00:03:55,580 --> 00:03:59,090
>> Pero cada JPEG posterior que
abrirmos, queremos pechar

69
00:03:59,090 --> 00:04:00,710
o arquivo anterior.

70
00:04:00,710 --> 00:04:04,630
Entón agora nós imos usar sprintf coma nós
dixen antes, onde estamos a través da

71
00:04:04,630 --> 00:04:06,280
nome do ficheiro JPEG tapón.

72
00:04:06,280 --> 00:04:09,870
E nós imos usar ficheiro JPEG
formato de nome como o noso formato.

73
00:04:09,870 --> 00:04:12,030
E o que é iso?

74
00:04:12,030 --> 00:04:18,450
Ata aquí, vemos que é cero por cento
3D.JPEG onde a tres cero só

75
00:04:18,450 --> 00:04:22,089
di que usaremos tres enteiros
a este Explique ceros.

76
00:04:22,089 --> 00:04:27,470
Entón é así que nós imos chegar cero cero
one.JPEG e de cero 10.JPEG e así por diante.

77
00:04:27,470 --> 00:04:29,060
>> Nós imos utilizar sprintf.

78
00:04:29,060 --> 00:04:33,760
E o enteiro que estamos inserindo
na secuencia é JPEGs dormentes

79
00:04:33,760 --> 00:04:36,380
recuperado, o cal é inicialmente cero.

80
00:04:36,380 --> 00:04:39,950
Así, o primeiro ficheiro aberto vai
para ser cero cero cero punto JPEG.

81
00:04:39,950 --> 00:04:43,330
E despois imos incrementa-lo de xeito que o
seguinte abrimos será cero cero

82
00:04:43,330 --> 00:04:46,830
un punto JPEG e imos incrementa-lo
novo polo que vai ser cero cero dous punto

83
00:04:46,830 --> 00:04:49,100
JPEG e así por diante.

84
00:04:49,100 --> 00:04:49,850
>> Todo ben.

85
00:04:49,850 --> 00:04:53,210
Entón, agora o interior de arquivo JPEG
nomear, temos o nome do

86
00:04:53,210 --> 00:04:54,990
arquivo que queremos.

87
00:04:54,990 --> 00:04:58,640
Podemos f abrir este ficheiro para a escrita.

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

89
00:04:59,170 --> 00:05:02,820
E unha vez máis, hai que comprobar a se
Asegúrese de que o ficheiro correctamente

90
00:05:02,820 --> 00:05:08,460
aberto, xa que se non o fixo, a continuación,
houbo algún erro.

91
00:05:08,460 --> 00:05:13,100
>> Polo tanto, agora temos obtido tras a
iso é unha parte JPEG.

92
00:05:13,100 --> 00:05:16,390
E aquí vemos que imos
para escribir para o JPEG.

93
00:05:16,390 --> 00:05:20,980
Pero primeiro temos esa verificación, que di
se o ficheiro JPEG non é igual a cero.

94
00:05:20,980 --> 00:05:22,490
Por que necesitamos diso?

95
00:05:22,490 --> 00:05:28,020
Ben ficheiro JPEG é igual a cero cando
ten actualmente un JPEG aberto.

96
00:05:28,020 --> 00:05:31,870
>> E si tarxeta punto comeza materias
con unha morea de bytes que

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

98
00:05:33,510 --> 00:05:36,240
Entón nós imos querer
saltar sobre eses bytes.

99
00:05:36,240 --> 00:05:39,600
Se non temos esa verificación, entón estamos
vai escribir a un pechado

100
00:05:39,600 --> 00:05:45,540
presentar os primeiros 512 bytes de
a tarxeta que non é bo.

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

102
00:05:46,030 --> 00:05:51,330
>> Así, supoñendo que temos un arquivo aberto, logo
imos escribir para o ficheiro

103
00:05:51,330 --> 00:05:53,290
512 bytes que dispoñemos no noso buffer.

104
00:05:53,290 --> 00:05:57,390
E estamos unha vez máis para facer a comprobación
Asegúrese de que os 512 bytes correctamente

105
00:05:57,390 --> 00:06:01,140
foron escritas, porque se non fosen
escrita correctamente, entón algo

106
00:06:01,140 --> 00:06:02,080
deu errado.

107
00:06:02,080 --> 00:06:06,540
Imos pechar os arquivos, imprimir que
algo deu mal, e retorno.

108
00:06:06,540 --> 00:06:10,940
Asumindo que todo vai ben,
imos seguir pechando o looping

109
00:06:10,940 --> 00:06:15,060
ficheiro antigo, abrindo o novo ficheiro, a escrita
datos para o novo ficheiro, e así

110
00:06:15,060 --> 00:06:20,990
ata que, finalmente, este f ler
retorna cero, o que significa

111
00:06:20,990 --> 00:06:23,280
que o arquivo está feito.

112
00:06:23,280 --> 00:06:28,490
>> Polo tanto, agora que a lectura da tarxeta é máis, nós
ver que nós imos pechar a f

113
00:06:28,490 --> 00:06:33,250
último arquivo que tiñamos aberto, pero
estamos comprobando se o ficheiro JPEG

114
00:06:33,250 --> 00:06:34,900
non é igual a cero.

115
00:06:34,900 --> 00:06:39,520
Así, o próximo f ten sentido porque, como
estamos abrindo arquivos, estamos pechando

116
00:06:39,520 --> 00:06:43,870
o ficheiro anterior, pero o último
ficheiro que abrimos nunca está pechada.

117
00:06:43,870 --> 00:06:45,580
Entón, iso é o que este fai.

118
00:06:45,580 --> 00:06:47,720
>> Pero por que hai que comprobar a null?

119
00:06:47,720 --> 00:06:53,130
Ben, o que se a tarxeta de punto prima non
ter un único JPEG dentro del?

120
00:06:53,130 --> 00:06:56,640
Neste caso, teriamos
nunca abriu un arquivo.

121
00:06:56,640 --> 00:07:00,230
E se nunca abrir un arquivo, debemos
non tentar pechar este ficheiro.

122
00:07:00,230 --> 00:07:03,000
Entón é iso que esta verificación está facendo.

123
00:07:03,000 --> 00:07:07,880
>> Agora aquí, como dixen antes, poderíamos
eclodiram que y lazo ou se

124
00:07:07,880 --> 00:07:13,520
a tarxeta teña rematado, ou se existen
algún erro de lectura da tarxeta.

125
00:07:13,520 --> 00:07:16,680
Polo tanto, esta é a verificación para ver se había
un erro de lectura da tarxeta, en

126
00:07:16,680 --> 00:07:19,400
caso en que, imos dicir que non
foi un erro ao ler.

127
00:07:19,400 --> 00:07:22,130
Non queremos que o usuario a pensar
todo foi correctamente.

128
00:07:22,130 --> 00:07:24,750
E nós imos voltar un para o erro.

129
00:07:24,750 --> 00:07:29,580
>> Finalmente, imos f pechar noso arquivo raw,
nosa tarxeta de punto cru, para indicar que

130
00:07:29,580 --> 00:07:34,070
todo foi ben e retorno
cero e é iso.

131
00:07:34,070 --> 00:07:36,130
>> O meu nome é Rob e esta foi Recover.

132
00:07:36,130 --> 00:07:42,102
>> [Música tocando]