1
00:00:00,000 --> 00:00:00,996

2
00:00:00,996 --> 00:00:12,470
>> [REPRODUCCIÓN DE MÚSICA]

3
00:00:12,470 --> 00:00:13,210
>> ROB BOWDEN: Hi.

4
00:00:13,210 --> 00:00:16,870
Soy Rob y dejé de tamaño
este problema.

5
00:00:16,870 --> 00:00:20,990
Así que vamos a empezar con copy.c como
una plantilla, pero nosotros vamos a ser

6
00:00:20,990 --> 00:00:23,340
hacer bastantes cambios.

7
00:00:23,340 --> 00:00:27,570
>> Ahora vemos que estamos haciendo de inmediato una
cambiar el que ya no estamos comprobando

8
00:00:27,570 --> 00:00:31,560
para nuestra RXC no es igual a 3, pero ahora
estamos comprobando rc no es igual a 4.

9
00:00:31,560 --> 00:00:34,670
Dado que también queremos incluir, en
Además de los archivos de entrada y salida de archivos

10
00:00:34,670 --> 00:00:39,550
argumentos, f que va a ser esto
factor por el cual estamos escalar.

11
00:00:39,550 --> 00:00:45,430
>> Así que una vez que estemos seguros de que queremos
utilizar s exploración f para convertir la cadena

12
00:00:45,430 --> 00:00:49,030
argv1 a un flotador.

13
00:00:49,030 --> 00:00:51,330
Y vamos a almacenar
que en el factor.

14
00:00:51,330 --> 00:00:55,180
Este carácter adicional es asegurarse
que no estamos realmente entrando

15
00:00:55,180 --> 00:00:59,200
algo así como 1.4 ABC
en la línea de comandos.

16
00:00:59,200 --> 00:01:02,960
>> Ahora vamos a crear algunos alias
desde RV2 y RV3 no son

17
00:01:02,960 --> 00:01:04,310
muy útiles nombres.

18
00:01:04,310 --> 00:01:07,660
Estamos, en cambio, va a llamar
ellos en el archivo y salir del archivo.

19
00:01:07,660 --> 00:01:11,580
Ahora vamos a asegurarnos de que
nuestro factor era realmente válida.

20
00:01:11,580 --> 00:01:16,330
Así que si el factor es menor que o igual a
cero o mayor que 100, a continuación, como por

21
00:01:16,330 --> 00:01:19,660
la especificación, se debe rechazar
ese factor.

22
00:01:19,660 --> 00:01:23,890
>> Cuando estamos seguros de que es bueno, ahora podemos
abrir el archivo n, y tenemos que hacer

23
00:01:23,890 --> 00:01:25,950
asegurarse de que se abrió con éxito.

24
00:01:25,950 --> 00:01:28,630
Si no lo hiciera, que devolverá NULL.

25
00:01:28,630 --> 00:01:30,390
Vamos a abrir el archivo de salida.

26
00:01:30,390 --> 00:01:33,420
Y una vez más, queremos comprobar para asegurarse
seguro de que ha abierto con éxito.

27
00:01:33,420 --> 00:01:37,270
Y si no se abre correctamente, a continuación,
también tenemos que asegúrese de cerrar

28
00:01:37,270 --> 00:01:40,870
el archivo n que en un principio con éxito
abierto, o de lo contrario tendrá un

29
00:01:40,870 --> 00:01:42,600
pérdida de memoria.

30
00:01:42,600 --> 00:01:46,350
>> Así que ahora vamos a leer en el mapa de bits
encabezado del archivo y la información de mapa de bits

31
00:01:46,350 --> 00:01:48,890
Remate de cabeza de el archivo n.

32
00:01:48,890 --> 00:01:52,360
Vamos a asegurarnos de que el
archivo n era un mapa de bits válido.

33
00:01:52,360 --> 00:01:52,640
Aceptar.

34
00:01:52,640 --> 00:01:55,100
>> Así que ahora vamos a empezar
hacer algunos cambios.

35
00:01:55,100 --> 00:01:58,840
Así pues vamos a estar cambiando
cosas, lo primero que quieren recordar el

36
00:01:58,840 --> 00:02:01,510
ancho antigua del archivo n.

37
00:02:01,510 --> 00:02:05,160
Queremos recordar el viejo acolchado de
el archivo n utilizando el mismo cálculo

38
00:02:05,160 --> 00:02:06,990
desde copy.c.

39
00:02:06,990 --> 00:02:09,840
>> Y ahora vamos a cambiar
la cabecera de información de mapa de bits.

40
00:02:09,840 --> 00:02:13,630
Y por lo que estamos multiplicando tanto el ancho
y la altura por el factor desde

41
00:02:13,630 --> 00:02:15,750
eso es lo que estamos por ampliar.

42
00:02:15,750 --> 00:02:18,420
Vamos a determinar la
nuevo material de relleno del expediente por

43
00:02:18,420 --> 00:02:21,140
utilizando la nueva anchura.

44
00:02:21,140 --> 00:02:27,330
Y vamos a determinar el nuevo
El tamaño de la imagen utilizando el número de

45
00:02:27,330 --> 00:02:31,610
bytes en una única fila que se va a
ser el número de píxeles en esa fila

46
00:02:31,610 --> 00:02:35,960
veces el tamaño de un píxel, más la
número de bytes de relleno al final

47
00:02:35,960 --> 00:02:40,310
de esa fila y multiplicar todo lo que
por el número de filas que tenemos.

48
00:02:40,310 --> 00:02:43,800
Así que ese es el número de bytes
que tenemos en nuestros datos de imagen.

49
00:02:43,800 --> 00:02:48,190
>> Bf.Bfsize ahora va a ser el número
de bytes en nuestra beta imagen más

50
00:02:48,190 --> 00:02:49,350
el tamaño de nuestros cabeceras.

51
00:02:49,350 --> 00:02:53,910
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.

52
00:02:53,910 --> 00:02:54,510
Aceptar.

53
00:02:54,510 --> 00:02:56,440
Así que eso es todo por nuestras cabeceras.

54
00:02:56,440 --> 00:02:59,030
Podemos escribir la cabecera del archivo y
información de la cabecera de nuestra salida

55
00:02:59,030 --> 00:03:01,590
archivo, y estamos bien.

56
00:03:01,590 --> 00:03:03,800
>> Ahora es el momento para realmente empezar
escribir el píxel

57
00:03:03,800 --> 00:03:05,120
los datos en el archivo de salida.

58
00:03:05,120 --> 00:03:10,460
Vamos a declarar un buffer de tamaño
vieja ancho RGB triplica, y estamos

59
00:03:10,460 --> 00:03:13,790
va a declarar una variable llamada
fila adormecida, que es que vamos a

60
00:03:13,790 --> 00:03:15,640
establecido inicialmente igual a la negativa 1.

61
00:03:15,640 --> 00:03:19,090
Vamos a ver que vamos a estar usando
que con el fin de hacer un seguimiento de lo que

62
00:03:19,090 --> 00:03:22,640
fila que hemos cargado en ese momento
en este tampón.

63
00:03:22,640 --> 00:03:23,290
Aceptar.

64
00:03:23,290 --> 00:03:28,750
>> Así que ahora a diferencia de la edición estándar,
en lugar de recorrer en iteración en la en

65
00:03:28,750 --> 00:03:32,900
archivo, vamos a iterar sobre cada
fila en el archivo y averiguar

66
00:03:32,900 --> 00:03:38,130
qué fila en el archivo en que queremos
colocar en esta fila en el archivo de salida.

67
00:03:38,130 --> 00:03:44,930
Así iteración en todas las filas de la salida
archivo usando la nueva altura, somos los primeros

68
00:03:44,930 --> 00:03:48,890
va a determinar la fila en la antigua
archivamos que vamos a utilizar, lo que estamos

69
00:03:48,890 --> 00:03:53,560
vamos a hacer mediante la adopción de esta corriente
fila dividido por el factor.

70
00:03:53,560 --> 00:03:58,000
Así que eso nos va a dar la fila
en el archivo antiguo que queremos.

71
00:03:58,000 --> 00:04:03,310
>> Así que ahora si la fila entumecida no es igual edad y,
vamos a tener que leer la fila

72
00:04:03,310 --> 00:04:05,940
que queremos en nuestro buffer fila actual.

73
00:04:05,940 --> 00:04:07,700
Entonces, ¿cómo vamos a hacer eso?

74
00:04:07,700 --> 00:04:11,650
En primer lugar, vamos a averiguar la
posición que comienza esa fila en el

75
00:04:11,650 --> 00:04:13,100
archivo original.

76
00:04:13,100 --> 00:04:18,630
Así que esa posición va a ser
más allá de todas nuestras cabeceras y

77
00:04:18,630 --> 00:04:21,589
Ahora pasados ​​filas antiguas y.

78
00:04:21,589 --> 00:04:23,880
>> Y así, la cantidad de bytes
se encuentran en una sola fila?

79
00:04:23,880 --> 00:04:28,740
Una vez más, el tamaño de RGB veces triples de edad
ancho, más viejo relleno, así que esa es la

80
00:04:28,740 --> 00:04:30,640
número de bytes en una sola fila.

81
00:04:30,640 --> 00:04:33,680
Y queremos saltar últimas filas antiguas y.

82
00:04:33,680 --> 00:04:37,580
Así que vamos a buscar f y estamos
utilizando busque conjunto a partir de la

83
00:04:37,580 --> 00:04:39,100
a partir de un archivo.

84
00:04:39,100 --> 00:04:42,740
Vamos a tratar de f esta posición
en el archivo, lo que nos sitúa en el

85
00:04:42,740 --> 00:04:46,500
a partir de la fila que queremos
leer en nuestro buffer.

86
00:04:46,500 --> 00:04:48,510
>> Vamos a establecer fila
numb igual edad y.

87
00:04:48,510 --> 00:04:53,080
Así que ahora si que volver bucle y queremos
utilizar esta misma fila en nuestro fichero a cabo,

88
00:04:53,080 --> 00:04:55,970
entonces no vamos a leer
en vez innecesariamente.

89
00:04:55,970 --> 00:04:59,310
Así que en realidad, la fila es insensible
sólo una optimización.

90
00:04:59,310 --> 00:05:05,500
>> Por último, vamos a leer en el
fila actual el antiguo ancho RGB triplica

91
00:05:05,500 --> 00:05:08,040
que queremos desde el archivo original.

92
00:05:08,040 --> 00:05:12,270
Así que ahora act fila contiene los píxeles de
el archivo original que queremos

93
00:05:12,270 --> 00:05:14,200
escribir en el archivo de salida.

94
00:05:14,200 --> 00:05:18,960
Así que ahora, al igual que antes, en lugar de
iteración en el archivo antiguo, necesitamos

95
00:05:18,960 --> 00:05:22,560
para iterar sobre las nuevas filas archivos.

96
00:05:22,560 --> 00:05:27,450
Pues aquí, en lugar de iterar sobre todos
de los viejos píxeles que en la fila actual,

97
00:05:27,450 --> 00:05:31,210
queremos iterar sobre todos los
píxeles en nuestro nuevo archivo en este

98
00:05:31,210 --> 00:05:32,480
en particular fila.

99
00:05:32,480 --> 00:05:34,140
>> ¿Por qué queremos hacer eso?

100
00:05:34,140 --> 00:05:38,960
Porque vemos aquí que no estamos
en realidad necesariamente el uso de todos los

101
00:05:38,960 --> 00:05:41,020
píxeles en el archivo original.

102
00:05:41,020 --> 00:05:46,630
Porque si estamos disminuyendo, podríamos
realmente quiera saltarse los píxeles.

103
00:05:46,630 --> 00:05:48,090
Y vemos que esto -

104
00:05:48,090 --> 00:05:49,690
x dividido por el factor -

105
00:05:49,690 --> 00:05:55,620
estrechamente refleja aquí donde decimos y
dividido por el factor de averiguar que

106
00:05:55,620 --> 00:06:02,480
la vieja fila-y th corresponde a
la fila-y XX en este nuevo archivo.

107
00:06:02,480 --> 00:06:05,880
>> Ahora vamos a escribir todos
estos píxeles de la fila edad

108
00:06:05,880 --> 00:06:07,440
en nuestra nueva fila.

109
00:06:07,440 --> 00:06:10,890
Una vez que hemos hecho esto, tenemos que sólo
poner el relleno al final de nuestra fila

110
00:06:10,890 --> 00:06:15,540
Y vamos a bucle y continuar durante
todas las filas en nuestro nuevo archivo.

111
00:06:15,540 --> 00:06:19,390
Al final, tenemos que cerrar nuestro viejo
presentar, cerrar nuestro nuevo archivo, y el retorno

112
00:06:19,390 --> 00:06:21,540
cero porque todo salió bien.

113
00:06:21,540 --> 00:06:24,220
>> Mi nombre es Rob y esto fue Recess.

114
00:06:24,220 --> 00:06:29,184
>> [REPRODUCCIÓN DE MÚSICA]