>> [REPRODUCCIÓN DE MÚSICA]
>> ROB BOWDEN: Hi.
Estoy Rob, y esperemos que esta solución le ayuda a poner
en el camino hacia la recuperación.
Así que vamos a empezar.
>> Vemos que inmediatamente estamos sólo para asegurarse de que estamos
Recuperar utilizando correctamente.
Así que el uso debe ser sólo algo como slash dot recuperarse.
>> Ahora vamos a abrir el esperado tarjeta dot archivo RAW.
Vemos aquí que estamos usando la constante nombre de archivo subrayado prima,
que aquí tenemos de hash definida como la tarjeta del punto prima.
Aceptar.
>> Así que tenemos que asegurarnos de que ese abierto con éxito, porque si
No, debemos advertir al usuario.
Pero suponiendo que así fuera, ahora estamos va a declarar un buffer de tamaño JPEG
presentar la longitud del nombre.
Así que esto va a ser el búfer que vamos a sprintf en.
>> Entonces, ¿cuál es la longitud del nombre del archivo JPEG?
Hasta aquí, vemos que se trata de el hash definida como ocho.
Entonces, ¿por ocho?
Bueno un archivo determinado será nombrado algo así como cero cero cero.
JPG y luego necesitamos una barra invertida cero.
Así que necesitamos un búfer que puede almacenar ocho caracteres.
Ahora vamos a tener un contador que es va a realizar un seguimiento de la
JPEG número que encontramos.
>> Y, por último, vamos a tener un Archivo JPEG que inicialmente es nula
que va a ser el momento archivo abierto que estamos escribiendo a.
Ahora vamos a tener un tampón adicional.
Este no es el mismo que nuestra sprintf buffer donde este tampón es el uno
que estamos leyendo en los datos de la tarjeta del punto de crudo.
>> Así el tampón va a ser de caracteres sin signo, que se puede
básicamente sólo nos tratan bytes, y es va a ser de tamaño tamaño de bloque
donde, como les decimos, tamaño del bloque es de 512.
Así que los archivos JPEG se puede tratar todo como bloques de 512 bytes.
>> Ahora vamos a bucle sobre todo el archivo.
Vamos a leer f en nuestro buffer un solo momento de bytes de tamaño de bloque de
la tarjeta dot archivo RAW.
Ahora, ¿qué f leer regresar?
Devuelve el número de elementos que leyó correctamente.
Así que si se las arregló para leer 512 bytes, a continuación, queremos ver si se trataba de un
JPEG o escribir en un archivo JPEG.
Y si no ha devuelto 512 bytes, entonces o bien el archivo ha terminado en
cuyo caso vamos a salir de la y lazo, o si hay algún tipo de error
en cuyo caso también vamos a salir de el bucle y, pero también vamos a querer informar
que algo salió mal.
>> Aceptar.
Así que suponiendo que leemos con éxito en 512 bytes, queremos primer cheque
para hacer que estos bytes que nos acabo de leer en comenzar un JPEG.
Así que si es encabezado JPEG de nuestro buffer.
Ahora lo que está haciendo cabecera JPEG?
Echemos un vistazo.
>> Hasta aquí, vemos que esta función es devolver un toro, y el toro -
bien aquí, estamos comprobando si encabezado de cero es igual a esta constante y
cabecera de uno es igual a esta constante y encabezado dos es igual a esta constante,
cabecera de tres es igual a esto o esto constante donde todas estas constantes son
sólo el hash definido aquí y son exactamente lo que usted dice en la especificación
que comienza con un archivo JPEG.
Y por lo que esta función es sólo va a return true si este buffer representa
el inicio de un nuevo JPEG y false en caso contrario.
>> Aceptar.
Así que si esto sí representa un nuevo JPEG, entonces primero vamos a comprobar para ver si
Archivo JPEG no es igual a null, en cuyo caso lo cerramos.
Y entonces ¿por qué tenemos que comprobar para ver si no es nulo?
Bueno, la primera JPEG que no vamos a encontrar ya tienen
un archivo JPEG abierto.
Y así, si intentamos cerrar eso, entonces no estamos haciendo algo muy bien.
>> Pero cada JPEG posterior que abrimos, queremos cerrar
el archivo anterior.
Así que ahora vamos a utilizar sprintf como nosotros dicho antes en el que estamos utilizando la
Nombre del archivo de búfer JPEG.
Y vamos a usar el archivo JPEG nombrar formato que nuestro formato.
¿Y qué es eso?
Hasta aquí, vemos que es cero por ciento 3D.JPEG donde el tres cero sólo
dice que vamos a utilizar tres enteros para este rellenado con ceros.
Así que así es como vamos a llegar a cero cero one.JPEG y cero 10.jpeg y así sucesivamente.
>> Vamos a utilizar sprintf.
Y el entero que estamos insertando en la cadena es JPEG entumecidos
recuperado, que es originalmente cero.
Así que el primer archivo abierto que está pasando que es cero cero punto cero JPEG.
Y entonces estamos incrementando así la fichero siguiente abrimos será cero cero
un punto JPEG y estaremos incrementamos de nuevo, así que va a ser cero cero dos puntos
JPEG y así sucesivamente.
>> Está bien.
Así que ahora el interior del archivo JPEG nombre, tenemos el nombre de la
archivo que queremos.
Podemos f abrir ese archivo para escritura.
Aceptar.
Y una vez más, tenemos que comprobar para asegurarse Asegúrese de que el archivo correctamente
abierto ya que si no lo hizo, entonces hubo algún error.
>> Así que ahora que hemos llegado más allá de la Es esta una parte JPEG.
Y aquí, vemos que vamos escribir en el JPEG.
Pero primero tenemos este cheque que dice si el archivo JPEG no es igual a nulo.
¿Por qué necesitamos esto?
Bueno archivo JPEG es igual a null cuando nos Actualmente tener un JPEG abierto.
>> ¿Qué pasa si se inicia primas dot tarjeta con un montón de bytes que
no representan un JPEG?
Entonces vamos a querer saltar sobre esos bytes.
Si no tenemos esta comprobación, entonces estamos va a escribir en un abrir
presentar los primeros 512 bytes de la tarjeta que no es bueno.
Aceptar.
>> Así que asumiendo que tenemos un archivo abierto, entonces vamos a escribir en ese archivo de la
512 bytes que tenemos en nuestro buffer.
Y estamos comprobando una vez más para hacer asegurarse de que los 512 bytes con éxito
fueron escritos porque si no lo fueran escrito correctamente, entonces algo
que salió mal.
Cerraremos nuestros archivos, imprimir esa algo salió mal, y el retorno.
Suponiendo que todo va correctamente, vamos a seguir cerrando el bucle
viejo archivo, abrir el nuevo archivo, escritura los datos en el nuevo archivo, y así
hasta que por fin, este lee f devuelve cero, lo que significa
que el archivo se hace.
>> Así que ahora que la lectura de la tarjeta ha terminado, vemos que vamos a cerrar el f
último archivo que teníamos abierto, pero estamos comprobando si el archivo JPEG
no es igual a nulo.
Bueno, la f estrecha tiene sentido porque como estamos abriendo archivos, vamos a cerrar
el archivo anterior, pero el último archivo que abrimos nunca se cierra.
Así que eso es lo que está haciendo.
>> Pero ¿por qué tenemos que comprobar si hay nulo?
Bueno, ¿y si la tarjeta de puntos primas no ha tener una sola JPEG dentro de ella?
En ese caso, tendríamos que nunca abierto un archivo.
Y si nunca abrimos un archivo, debemos No intente cerrar ese archivo.
Así que eso es lo que este control está haciendo.
>> Ahora aquí, como he dicho antes, podríamos han estallado que y bucle o bien si
la tarjeta ha terminado o si hay algunos error de lectura de la tarjeta.
Así que esta es la comprobación para ver si había un error en la lectura de la tarjeta, en
cuyo caso, vamos a decir que hay fue un error de lectura.
No queremos que el usuario piense todo ha ido correctamente.
Y nos volvemos uno para el error.
>> Por último, vamos a f cerramos nuestro archivo RAW, nuestra tarjeta dot prima, para indicar que
todo ha ido bien y el retorno cero y eso es todo.
>> Mi nombre es Rob y esto era recuperar.
>> [REPRODUCCIÓN DE MÚSICA]