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

2
00:00:00,494 --> 00:00:13,350
>> [REPRODUCCIÓN DE MÚSICA]

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

4
00:00:14,080 --> 00:00:17,550
Estoy Rob, y esperemos que
esta solución le ayuda a poner

5
00:00:17,550 --> 00:00:19,600
en el camino hacia la recuperación.

6
00:00:19,600 --> 00:00:22,700
Así que vamos a empezar.

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

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

9
00:00:27,170 --> 00:00:31,490
Así que el uso debe ser sólo algo
como slash dot recuperarse.

10
00:00:31,490 --> 00:00:35,500
>> Ahora vamos a abrir el esperado
tarjeta dot archivo RAW.

11
00:00:35,500 --> 00:00:39,740
Vemos aquí que estamos usando la
constante nombre de archivo subrayado prima,

12
00:00:39,740 --> 00:00:44,200
que aquí tenemos de hash
definida como la tarjeta del punto prima.

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

14
00:00:45,030 --> 00:00:48,210
>> Así que tenemos que asegurarnos de que ese
abierto con éxito, porque si

15
00:00:48,210 --> 00:00:51,150
No, debemos advertir al usuario.

16
00:00:51,150 --> 00:00:56,770
Pero suponiendo que así fuera, ahora estamos
va a declarar un buffer de tamaño JPEG

17
00:00:56,770 --> 00:00:58,170
presentar la longitud del nombre.

18
00:00:58,170 --> 00:01:02,060
Así que esto va a ser el búfer que
vamos a sprintf en.

19
00:01:02,060 --> 00:01:04,360
>> Entonces, ¿cuál es la longitud del nombre del archivo JPEG?

20
00:01:04,360 --> 00:01:08,490
Hasta aquí, vemos que se trata de
el hash definida como ocho.

21
00:01:08,490 --> 00:01:10,670
Entonces, ¿por ocho?

22
00:01:10,670 --> 00:01:15,150
Bueno un archivo determinado será nombrado
algo así como cero cero cero.

23
00:01:15,150 --> 00:01:19,460
JPG y luego necesitamos una barra invertida cero.

24
00:01:19,460 --> 00:01:22,720
Así que necesitamos un búfer que puede
almacenar ocho caracteres.

25
00:01:22,720 --> 00:01:25,190
Ahora vamos a tener un contador que es
va a realizar un seguimiento de la

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

27
00:01:27,780 --> 00:01:31,590
>> Y, por último, vamos a tener un
Archivo JPEG que inicialmente es nula

28
00:01:31,590 --> 00:01:35,920
que va a ser el momento
archivo abierto que estamos escribiendo a.

29
00:01:35,920 --> 00:01:37,540
Ahora vamos a tener
un tampón adicional.

30
00:01:37,540 --> 00:01:41,350
Este no es el mismo que nuestra sprintf
buffer donde este tampón es el uno

31
00:01:41,350 --> 00:01:45,020
que estamos leyendo en los datos
de la tarjeta del punto de crudo.

32
00:01:45,020 --> 00:01:48,900
>> Así el tampón va a ser de
caracteres sin signo, que se puede

33
00:01:48,900 --> 00:01:53,560
básicamente sólo nos tratan bytes, y es
va a ser de tamaño tamaño de bloque

34
00:01:53,560 --> 00:01:57,950
donde, como les decimos,
tamaño del bloque es de 512.

35
00:01:57,950 --> 00:02:03,070
Así que los archivos JPEG se puede tratar todo
como bloques de 512 bytes.

36
00:02:03,070 --> 00:02:05,890
>> Ahora vamos a bucle
sobre todo el archivo.

37
00:02:05,890 --> 00:02:12,980
Vamos a leer f en nuestro buffer
un solo momento de bytes de tamaño de bloque de

38
00:02:12,980 --> 00:02:14,710
la tarjeta dot archivo RAW.

39
00:02:14,710 --> 00:02:16,630
Ahora, ¿qué f leer regresar?

40
00:02:16,630 --> 00:02:20,050
Devuelve el número de elementos
que leyó correctamente.

41
00:02:20,050 --> 00:02:27,310
Así que si se las arregló para leer 512 bytes, a continuación,
queremos ver si se trataba de un

42
00:02:27,310 --> 00:02:29,700
JPEG o escribir en un archivo JPEG.

43
00:02:29,700 --> 00:02:34,450
Y si no ha devuelto 512 bytes,
entonces o bien el archivo ha terminado en

44
00:02:34,450 --> 00:02:37,870
cuyo caso vamos a salir de la y
lazo, o si hay algún tipo de error

45
00:02:37,870 --> 00:02:40,300
en cuyo caso también vamos a salir de
el bucle y, pero también vamos a querer informar

46
00:02:40,300 --> 00:02:41,990
que algo salió mal.

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

48
00:02:42,290 --> 00:02:47,630
Así que suponiendo que leemos con éxito
en 512 bytes, queremos primer cheque

49
00:02:47,630 --> 00:02:53,070
para hacer que estos bytes que nos
acabo de leer en comenzar un JPEG.

50
00:02:53,070 --> 00:02:56,430
Así que si es encabezado JPEG de nuestro buffer.

51
00:02:56,430 --> 00:02:58,460
Ahora lo que está haciendo cabecera JPEG?

52
00:02:58,460 --> 00:03:00,120
Echemos un vistazo.

53
00:03:00,120 --> 00:03:05,270
>> Hasta aquí, vemos que esta función es
devolver un toro, y el toro -

54
00:03:05,270 --> 00:03:08,820
bien aquí, estamos comprobando si
encabezado de cero es igual a esta constante y

55
00:03:08,820 --> 00:03:11,880
cabecera de uno es igual a esta constante y
encabezado dos es igual a esta constante,

56
00:03:11,880 --> 00:03:15,640
cabecera de tres es igual a esto o esto
constante donde todas estas constantes son

57
00:03:15,640 --> 00:03:20,340
sólo el hash definido aquí y son
exactamente lo que usted dice en la especificación

58
00:03:20,340 --> 00:03:22,700
que comienza con un archivo JPEG.

59
00:03:22,700 --> 00:03:27,300
Y por lo que esta función es sólo va a
return true si este buffer representa

60
00:03:27,300 --> 00:03:31,750
el inicio de un nuevo JPEG
y false en caso contrario.

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

62
00:03:32,520 --> 00:03:38,490
Así que si esto sí representa un nuevo JPEG,
entonces primero vamos a comprobar para ver si

63
00:03:38,490 --> 00:03:42,030
Archivo JPEG no es igual a null,
en cuyo caso lo cerramos.

64
00:03:42,030 --> 00:03:44,940
Y entonces ¿por qué tenemos que comprobar
para ver si no es nulo?

65
00:03:44,940 --> 00:03:48,980
Bueno, la primera JPEG que
no vamos a encontrar ya tienen

66
00:03:48,980 --> 00:03:50,440
un archivo JPEG abierto.

67
00:03:50,440 --> 00:03:55,580
Y así, si intentamos cerrar eso, entonces
no estamos haciendo algo muy bien.

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

69
00:03:59,090 --> 00:04:00,710
el archivo anterior.

70
00:04:00,710 --> 00:04:04,630
Así que ahora vamos a utilizar sprintf como nosotros
dicho antes en el que estamos utilizando la

71
00:04:04,630 --> 00:04:06,280
Nombre del archivo de búfer JPEG.

72
00:04:06,280 --> 00:04:09,870
Y vamos a usar el archivo JPEG
nombrar formato que nuestro formato.

73
00:04:09,870 --> 00:04:12,030
¿Y qué es eso?

74
00:04:12,030 --> 00:04:18,450
Hasta aquí, vemos que es cero por ciento
3D.JPEG donde el tres cero sólo

75
00:04:18,450 --> 00:04:22,089
dice que vamos a utilizar tres enteros
para este rellenado con ceros.

76
00:04:22,089 --> 00:04:27,470
Así que así es como vamos a llegar a cero cero
one.JPEG y cero 10.jpeg y así sucesivamente.

77
00:04:27,470 --> 00:04:29,060
>> Vamos a utilizar sprintf.

78
00:04:29,060 --> 00:04:33,760
Y el entero que estamos insertando
en la cadena es JPEG entumecidos

79
00:04:33,760 --> 00:04:36,380
recuperado, que es originalmente cero.

80
00:04:36,380 --> 00:04:39,950
Así que el primer archivo abierto que está pasando
que es cero cero punto cero JPEG.

81
00:04:39,950 --> 00:04:43,330
Y entonces estamos incrementando así la
fichero siguiente abrimos será cero cero

82
00:04:43,330 --> 00:04:46,830
un punto JPEG y estaremos incrementamos
de nuevo, así que va a ser cero cero dos puntos

83
00:04:46,830 --> 00:04:49,100
JPEG y así sucesivamente.

84
00:04:49,100 --> 00:04:49,850
>> Está bien.

85
00:04:49,850 --> 00:04:53,210
Así que ahora el interior del archivo JPEG
nombre, tenemos el nombre de la

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

87
00:04:54,990 --> 00:04:58,640
Podemos f abrir ese archivo para escritura.

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

89
00:04:59,170 --> 00:05:02,820
Y una vez más, tenemos que comprobar para asegurarse
Asegúrese de que el archivo correctamente

90
00:05:02,820 --> 00:05:08,460
abierto ya que si no lo hizo, entonces
hubo algún error.

91
00:05:08,460 --> 00:05:13,100
>> Así que ahora que hemos llegado más allá de la
Es esta una parte JPEG.

92
00:05:13,100 --> 00:05:16,390
Y aquí, vemos que vamos
escribir en el JPEG.

93
00:05:16,390 --> 00:05:20,980
Pero primero tenemos este cheque que dice
si el archivo JPEG no es igual a nulo.

94
00:05:20,980 --> 00:05:22,490
¿Por qué necesitamos esto?

95
00:05:22,490 --> 00:05:28,020
Bueno archivo JPEG es igual a null cuando nos
Actualmente tener un JPEG abierto.

96
00:05:28,020 --> 00:05:31,870
>> ¿Qué pasa si se inicia primas dot tarjeta
con un montón de bytes que

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

98
00:05:33,510 --> 00:05:36,240
Entonces vamos a querer
saltar sobre esos bytes.

99
00:05:36,240 --> 00:05:39,600
Si no tenemos esta comprobación, entonces estamos
va a escribir en un abrir

100
00:05:39,600 --> 00:05:45,540
presentar los primeros 512 bytes de
la tarjeta que no es bueno.

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

102
00:05:46,030 --> 00:05:51,330
>> Así que asumiendo que tenemos un archivo abierto, entonces
vamos a escribir en ese archivo de la

103
00:05:51,330 --> 00:05:53,290
512 bytes que tenemos en nuestro buffer.

104
00:05:53,290 --> 00:05:57,390
Y estamos comprobando una vez más para hacer
asegurarse de que los 512 bytes con éxito

105
00:05:57,390 --> 00:06:01,140
fueron escritos porque si no lo fueran
escrito correctamente, entonces algo

106
00:06:01,140 --> 00:06:02,080
que salió mal.

107
00:06:02,080 --> 00:06:06,540
Cerraremos nuestros archivos, imprimir esa
algo salió mal, y el retorno.

108
00:06:06,540 --> 00:06:10,940
Suponiendo que todo va correctamente,
vamos a seguir cerrando el bucle

109
00:06:10,940 --> 00:06:15,060
viejo archivo, abrir el nuevo archivo, escritura
los datos en el nuevo archivo, y así

110
00:06:15,060 --> 00:06:20,990
hasta que por fin, este lee f
devuelve cero, lo que significa

111
00:06:20,990 --> 00:06:23,280
que el archivo se hace.

112
00:06:23,280 --> 00:06:28,490
>> Así que ahora que la lectura de la tarjeta ha terminado,
vemos que vamos a cerrar el f

113
00:06:28,490 --> 00:06:33,250
último archivo que teníamos abierto, pero
estamos comprobando si el archivo JPEG

114
00:06:33,250 --> 00:06:34,900
no es igual a nulo.

115
00:06:34,900 --> 00:06:39,520
Bueno, la f estrecha tiene sentido porque como
estamos abriendo archivos, vamos a cerrar

116
00:06:39,520 --> 00:06:43,870
el archivo anterior, pero el último
archivo que abrimos nunca se cierra.

117
00:06:43,870 --> 00:06:45,580
Así que eso es lo que está haciendo.

118
00:06:45,580 --> 00:06:47,720
>> Pero ¿por qué tenemos que comprobar si hay nulo?

119
00:06:47,720 --> 00:06:53,130
Bueno, ¿y si la tarjeta de puntos primas no ha
tener una sola JPEG dentro de ella?

120
00:06:53,130 --> 00:06:56,640
En ese caso, tendríamos que
nunca abierto un archivo.

121
00:06:56,640 --> 00:07:00,230
Y si nunca abrimos un archivo, debemos
No intente cerrar ese archivo.

122
00:07:00,230 --> 00:07:03,000
Así que eso es lo que este control está haciendo.

123
00:07:03,000 --> 00:07:07,880
>> Ahora aquí, como he dicho antes, podríamos
han estallado que y bucle o bien si

124
00:07:07,880 --> 00:07:13,520
la tarjeta ha terminado o si hay
algunos error de lectura de la tarjeta.

125
00:07:13,520 --> 00:07:16,680
Así que esta es la comprobación para ver si había
un error en la lectura de la tarjeta, en

126
00:07:16,680 --> 00:07:19,400
cuyo caso, vamos a decir que hay
fue un error de lectura.

127
00:07:19,400 --> 00:07:22,130
No queremos que el usuario piense
todo ha ido correctamente.

128
00:07:22,130 --> 00:07:24,750
Y nos volvemos uno para el error.

129
00:07:24,750 --> 00:07:29,580
>> Por último, vamos a f cerramos nuestro archivo RAW,
nuestra tarjeta dot prima, para indicar que

130
00:07:29,580 --> 00:07:34,070
todo ha ido bien y el retorno
cero y eso es todo.

131
00:07:34,070 --> 00:07:36,130
>> Mi nombre es Rob y esto era recuperar.

132
00:07:36,130 --> 00:07:42,102
>> [REPRODUCCIÓN DE MÚSICA]