>> [REPRODUCCIÓN DE MÚSICA]
>> ROB BOWDEN: Hi.
Soy Rob y dejé de tamaño este problema.
Así que vamos a empezar con copy.c como una plantilla, pero nosotros vamos a ser
hacer bastantes cambios.
>> Ahora vemos que estamos haciendo de inmediato una cambiar el que ya no estamos comprobando
para nuestra RXC no es igual a 3, pero ahora estamos comprobando rc no es igual a 4.
Dado que también queremos incluir, en Además de los archivos de entrada y salida de archivos
argumentos, f que va a ser esto factor por el cual estamos escalar.
>> Así que una vez que estemos seguros de que queremos utilizar s exploración f para convertir la cadena
argv1 a un flotador.
Y vamos a almacenar que en el factor.
Este carácter adicional es asegurarse que no estamos realmente entrando
algo así como 1.4 ABC en la línea de comandos.
>> Ahora vamos a crear algunos alias desde RV2 y RV3 no son
muy útiles nombres.
Estamos, en cambio, va a llamar ellos en el archivo y salir del archivo.
Ahora vamos a asegurarnos de que nuestro factor era realmente válida.
Así que si el factor es menor que o igual a cero o mayor que 100, a continuación, como por
la especificación, se debe rechazar ese factor.
>> Cuando estamos seguros de que es bueno, ahora podemos abrir el archivo n, y tenemos que hacer
asegurarse de que se abrió con éxito.
Si no lo hiciera, que devolverá NULL.
Vamos a abrir el archivo de salida.
Y una vez más, queremos comprobar para asegurarse seguro de que ha abierto con éxito.
Y si no se abre correctamente, a continuación, también tenemos que asegúrese de cerrar
el archivo n que en un principio con éxito abierto, o de lo contrario tendrá un
pérdida de memoria.
>> Así que ahora vamos a leer en el mapa de bits encabezado del archivo y la información de mapa de bits
Remate de cabeza de el archivo n.
Vamos a asegurarnos de que el archivo n era un mapa de bits válido.
Aceptar.
>> Así que ahora vamos a empezar hacer algunos cambios.
Así pues vamos a estar cambiando cosas, lo primero que quieren recordar el
ancho antigua del archivo n.
Queremos recordar el viejo acolchado de el archivo n utilizando el mismo cálculo
desde copy.c.
>> Y ahora vamos a cambiar la cabecera de información de mapa de bits.
Y por lo que estamos multiplicando tanto el ancho y la altura por el factor desde
eso es lo que estamos por ampliar.
Vamos a determinar la nuevo material de relleno del expediente por
utilizando la nueva anchura.
Y vamos a determinar el nuevo El tamaño de la imagen utilizando el número de
bytes en una única fila que se va a ser el número de píxeles en esa fila
veces el tamaño de un píxel, más la número de bytes de relleno al final
de esa fila y multiplicar todo lo que por el número de filas que tenemos.
Así que ese es el número de bytes que tenemos en nuestros datos de imagen.
>> Bf.Bfsize ahora va a ser el número de bytes en nuestra beta imagen más
el tamaño de nuestros cabeceras.
Así, más tamaño de encabezado de archivo de mapa de bits y el tamaño de la cabecera de información de mapa de bits.
Aceptar.
Así que eso es todo por nuestras cabeceras.
Podemos escribir la cabecera del archivo y información de la cabecera de nuestra salida
archivo, y estamos bien.
>> Ahora es el momento para realmente empezar escribir el píxel
los datos en el archivo de salida.
Vamos a declarar un buffer de tamaño vieja ancho RGB triplica, y estamos
va a declarar una variable llamada fila adormecida, que es que vamos a
establecido inicialmente igual a la negativa 1.
Vamos a ver que vamos a estar usando que con el fin de hacer un seguimiento de lo que
fila que hemos cargado en ese momento en este tampón.
Aceptar.
>> Así que ahora a diferencia de la edición estándar, en lugar de recorrer en iteración en la en
archivo, vamos a iterar sobre cada fila en el archivo y averiguar
qué fila en el archivo en que queremos colocar en esta fila en el archivo de salida.
Así iteración en todas las filas de la salida archivo usando la nueva altura, somos los primeros
va a determinar la fila en la antigua archivamos que vamos a utilizar, lo que estamos
vamos a hacer mediante la adopción de esta corriente fila dividido por el factor.
Así que eso nos va a dar la fila en el archivo antiguo que queremos.
>> Así que ahora si la fila entumecida no es igual edad y, vamos a tener que leer la fila
que queremos en nuestro buffer fila actual.
Entonces, ¿cómo vamos a hacer eso?
En primer lugar, vamos a averiguar la posición que comienza esa fila en el
archivo original.
Así que esa posición va a ser más allá de todas nuestras cabeceras y
Ahora pasados ​​filas antiguas y.
>> Y así, la cantidad de bytes se encuentran en una sola fila?
Una vez más, el tamaño de RGB veces triples de edad ancho, más viejo relleno, así que esa es la
número de bytes en una sola fila.
Y queremos saltar últimas filas antiguas y.
Así que vamos a buscar f y estamos utilizando busque conjunto a partir de la
a partir de un archivo.
Vamos a tratar de f esta posición en el archivo, lo que nos sitúa en el
a partir de la fila que queremos leer en nuestro buffer.
>> Vamos a establecer fila numb igual edad y.
Así que ahora si que volver bucle y queremos utilizar esta misma fila en nuestro fichero a cabo,
entonces no vamos a leer en vez innecesariamente.
Así que en realidad, la fila es insensible sólo una optimización.
>> Por último, vamos a leer en el fila actual el antiguo ancho RGB triplica
que queremos desde el archivo original.
Así que ahora act fila contiene los píxeles de el archivo original que queremos
escribir en el archivo de salida.
Así que ahora, al igual que antes, en lugar de iteración en el archivo antiguo, necesitamos
para iterar sobre las nuevas filas archivos.
Pues aquí, en lugar de iterar sobre todos de los viejos píxeles que en la fila actual,
queremos iterar sobre todos los píxeles en nuestro nuevo archivo en este
en particular fila.
>> ¿Por qué queremos hacer eso?
Porque vemos aquí que no estamos en realidad necesariamente el uso de todos los
píxeles en el archivo original.
Porque si estamos disminuyendo, podríamos realmente quiera saltarse los píxeles.
Y vemos que esto -
x dividido por el factor -
estrechamente refleja aquí donde decimos y dividido por el factor de averiguar que
la vieja fila-y th corresponde a la fila-y XX en este nuevo archivo.
>> Ahora vamos a escribir todos estos píxeles de la fila edad
en nuestra nueva fila.
Una vez que hemos hecho esto, tenemos que sólo poner el relleno al final de nuestra fila
Y vamos a bucle y continuar durante todas las filas en nuestro nuevo archivo.
Al final, tenemos que cerrar nuestro viejo presentar, cerrar nuestro nuevo archivo, y el retorno
cero porque todo salió bien.
>> Mi nombre es Rob y esto fue Recess.
>> [REPRODUCCIÓN DE MÚSICA]