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

2
00:00:00,996 --> 00:00:12,470
>> [Música tocando]

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

4
00:00:13,210 --> 00:00:16,870
Estou Rob e vamos tamanho
se este problema.

5
00:00:16,870 --> 00:00:20,990
Então, vamos começar com copy.c como
um modelo, mas nós vamos estar

6
00:00:20,990 --> 00:00:23,340
fazer algumas mudanças.

7
00:00:23,340 --> 00:00:27,570
>> Agora vemos que estamos a fazer imediatamente um
alterar o local onde nós já não estamos verificando

8
00:00:27,570 --> 00:00:31,560
para o nosso RXC não é igual 3, mas agora
estamos verificando rc não é igual 4.

9
00:00:31,560 --> 00:00:34,670
Desde que nós também queremos incluir, em
Além dos em arquivo e fora arquivos

10
00:00:34,670 --> 00:00:39,550
argumentos, f, que vai ser esta
fator pelo qual estamos escalando.

11
00:00:39,550 --> 00:00:45,430
>> Assim, uma vez temos a certeza de que, nós queremos
usar s varredura f para converter a string

12
00:00:45,430 --> 00:00:49,030
argv1 a uma bóia.

13
00:00:49,030 --> 00:00:51,330
E nós estamos indo para armazenar
que no fator.

14
00:00:51,330 --> 00:00:55,180
Este personagem adicional é ter certeza
que não estamos realmente entrando

15
00:00:55,180 --> 00:00:59,200
algo como 1,4 ABC
na linha de comando.

16
00:00:59,200 --> 00:01:02,960
>> Agora vamos criar alguns aliases
desde RV2 e não são RV3

17
00:01:02,960 --> 00:01:04,310
nomes muito útil.

18
00:01:04,310 --> 00:01:07,660
Estamos, ao contrário, vai chamar
los em arquivo e sair do arquivo.

19
00:01:07,660 --> 00:01:11,580
Agora vamos ter certeza de que
nossa taxa era realmente válido.

20
00:01:11,580 --> 00:01:16,330
Assim, se o factor é menos do que ou igual a
zero ou superior a 100, em seguida, conforme

21
00:01:16,330 --> 00:01:19,660
a especificação, devemos rejeitar
esse fator.

22
00:01:19,660 --> 00:01:23,890
>> Quando temos a certeza que é bom, agora podemos
abra o arquivo de n, e nós temos que fazer

23
00:01:23,890 --> 00:01:25,950
Certifique-se de que foi aberto com sucesso.

24
00:01:25,950 --> 00:01:28,630
Se isso não aconteceu, que irá retornar nulo.

25
00:01:28,630 --> 00:01:30,390
Nós vamos abrir o arquivo para fora.

26
00:01:30,390 --> 00:01:33,420
E mais uma vez, queremos verifique
certeza que é aberto com êxito.

27
00:01:33,420 --> 00:01:37,270
E se ele não abrir com êxito, em seguida,
também precisamos ter a certeza de fechar

28
00:01:37,270 --> 00:01:40,870
o arquivo n que originalmente com sucesso
aberto, ou então temos um

29
00:01:40,870 --> 00:01:42,600
vazamento de memória.

30
00:01:42,600 --> 00:01:46,350
>> Então, agora vamos ler no bitmap
cabeçalho do arquivo e informações de bitmap

31
00:01:46,350 --> 00:01:48,890
cabeçalho do arquivo n.

32
00:01:48,890 --> 00:01:52,360
Nós vamos ter certeza de que o
arquivo n foi um bitmap válido.

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

34
00:01:52,640 --> 00:01:55,100
>> Então agora nós vamos começar
fazer algumas mudanças.

35
00:01:55,100 --> 00:01:58,840
Então porque nós vamos estar mudando
coisas, primeiro quero lembrar o

36
00:01:58,840 --> 00:02:01,510
velho largura do arquivo n.

37
00:02:01,510 --> 00:02:05,160
Queremos lembrar o velho preenchimento de
o ficheiro n, usando o mesmo cálculo

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

39
00:02:06,990 --> 00:02:09,840
>> E agora nós vamos mudar
a informação bitmap cabeçalho.

40
00:02:09,840 --> 00:02:13,630
E assim estamos multiplicando a largura
ea altura pelo fator desde

41
00:02:13,630 --> 00:02:15,750
que é o que estamos escalando por.

42
00:02:15,750 --> 00:02:18,420
Vamos determinar a
novo preenchimento do arquivo,

43
00:02:18,420 --> 00:02:21,140
utilizando a nova largura.

44
00:02:21,140 --> 00:02:27,330
E vamos para determinar o novo
tamanho da imagem usando o número de

45
00:02:27,330 --> 00:02:31,610
bytes de uma única linha, que vai
ser o número de pixels em que a linha

46
00:02:31,610 --> 00:02:35,960
vezes o tamanho de um pixel mais o
número de bytes de preenchimento no final

47
00:02:35,960 --> 00:02:40,310
dessa linha, e multiplicando por isso
pelo número de linhas que temos.

48
00:02:40,310 --> 00:02:43,800
Então esse é o número de bytes
temos em nossos dados de imagem.

49
00:02:43,800 --> 00:02:48,190
>> Bf.Bfsize agora vai ser o número
de bytes à nossa imagem beta mais

50
00:02:48,190 --> 00:02:49,350
o tamanho dos nossos cabeçalhos.

51
00:02:49,350 --> 00:02:53,910
Assim, além de tamanho de cabeçalho do arquivo bitmap
eo tamanho das informações bitmap cabeçalho.

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

53
00:02:54,510 --> 00:02:56,440
Então é isso para os nossos cabeçalhos.

54
00:02:56,440 --> 00:02:59,030
Podemos escrever a cabeça de arquivo e
informações do cabeçalho para o nosso fora

55
00:02:59,030 --> 00:03:01,590
arquivo, e estamos bem.

56
00:03:01,590 --> 00:03:03,800
>> Agora é hora de começar a realmente
escrever o pixel

57
00:03:03,800 --> 00:03:05,120
dados para o arquivo de saída.

58
00:03:05,120 --> 00:03:10,460
Vamos declarar um buffer de tamanho
largura velho RGB triplica, e estamos

59
00:03:10,460 --> 00:03:13,790
vai declarar uma variável chamada
dormentes de linha, que é que vamos

60
00:03:13,790 --> 00:03:15,640
inicialmente definido igual a 1 negativo.

61
00:03:15,640 --> 00:03:19,090
Vamos ver o que nós vamos estar usando
que, a fim de acompanhar o que

62
00:03:19,090 --> 00:03:22,640
linha que atualmente carregado
para este buffer.

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

64
00:03:23,290 --> 00:03:28,750
>> Então, agora, ao contrário da edição standard,
em vez de iteração sobre a em

65
00:03:28,750 --> 00:03:32,900
arquivo, vamos iterar sobre cada
linha do arquivo para fora e descobrir

66
00:03:32,900 --> 00:03:38,130
qual linha no arquivo em que queremos
colocar nesta linha no arquivo de fora.

67
00:03:38,130 --> 00:03:44,930
Então iteração sobre todas as linhas da saída
arquivo usando a nova altura, estamos em primeiro lugar

68
00:03:44,930 --> 00:03:48,890
vai determinar a linha na antiga
arquivo que vamos usar, o que estamos

69
00:03:48,890 --> 00:03:53,560
vai fazer, tendo esta corrente
linha dividido pelo fator.

70
00:03:53,560 --> 00:03:58,000
Então, isso vai nos dar a linha
no antigo arquivo que nós queremos.

71
00:03:58,000 --> 00:04:03,310
>> Portanto, agora se linha dormente não é igual a y de idade,
nós vamos ter que ler a linha

72
00:04:03,310 --> 00:04:05,940
que queremos para o nosso tampão linha cur.

73
00:04:05,940 --> 00:04:07,700
Então, como vamos fazer isso?

74
00:04:07,700 --> 00:04:11,650
Primeiro, vamos descobrir a
posição que começa nessa linha no

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

76
00:04:13,100 --> 00:04:18,630
Assim que a posição será
passado todos os nossos cabeçalhos e

77
00:04:18,630 --> 00:04:21,589
Agora últimos velhas linhas y.

78
00:04:21,589 --> 00:04:23,880
>> E assim, quantos bytes
estão em uma única linha?

79
00:04:23,880 --> 00:04:28,740
Mais uma vez, o tamanho do RGB vezes triplas velho
largura mais estofo de idade, de modo que é o

80
00:04:28,740 --> 00:04:30,640
o número de bytes em uma única linha.

81
00:04:30,640 --> 00:04:33,680
E nós queremos pular últimos antigas linhas y.

82
00:04:33,680 --> 00:04:37,580
Então, nós estamos indo para f buscar e estamos
usando buscar pronto para começar a partir do

83
00:04:37,580 --> 00:04:39,100
início de um arquivo.

84
00:04:39,100 --> 00:04:42,740
Vamos f procuram esta posição
no arquivo, colocando-nos na

85
00:04:42,740 --> 00:04:46,500
início da linha que queremos
para ler em nosso buffer.

86
00:04:46,500 --> 00:04:48,510
>> Vamos definir linha
entorpecido igual a y de idade.

87
00:04:48,510 --> 00:04:53,080
Portanto, agora se volta ao início e queremos
usar esta mesma linha em nosso arquivo para fora,

88
00:04:53,080 --> 00:04:55,970
então nós não vamos ler
-o novamente desnecessariamente.

89
00:04:55,970 --> 00:04:59,310
Então, realmente, a linha é entorpecido
apenas uma otimização.

90
00:04:59,310 --> 00:05:05,500
>> Finalmente, vamos ler na
linha atual do antigo largura RGB triplica

91
00:05:05,500 --> 00:05:08,040
que queremos a partir do arquivo original.

92
00:05:08,040 --> 00:05:12,270
Então agora cur linha contém os pixels de
o arquivo original que queremos

93
00:05:12,270 --> 00:05:14,200
escrever para o arquivo para fora.

94
00:05:14,200 --> 00:05:18,960
Então, agora, assim como acima, em vez de
iteração sobre o arquivo antigo, precisamos

95
00:05:18,960 --> 00:05:22,560
-lo para interagir sobre os novos arquivos linhas.

96
00:05:22,560 --> 00:05:27,450
Bem, aqui, em vez de iteração sobre todos
dos velhos pixels que na linha cur,

97
00:05:27,450 --> 00:05:31,210
queremos iterar sobre todas as
pixels em nosso novo arquivo neste

98
00:05:31,210 --> 00:05:32,480
especial linha.

99
00:05:32,480 --> 00:05:34,140
>> Por que quer fazer isso?

100
00:05:34,140 --> 00:05:38,960
Porque vemos aqui que não estamos
na verdade, necessariamente usando todo o

101
00:05:38,960 --> 00:05:41,020
pixels no arquivo original.

102
00:05:41,020 --> 00:05:46,630
Porque se nós estamos encolhendo, poderíamos
realmente querem ignorar os pixels.

103
00:05:46,630 --> 00:05:48,090
E vemos que isso -

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

105
00:05:49,690 --> 00:05:55,620
espelha-se aqui, onde nós dizemos y
dividido pelo fator de descobrir que

106
00:05:55,620 --> 00:06:02,480
a antiga linha y-th corresponde a
a linha y-th neste novo arquivo.

107
00:06:02,480 --> 00:06:05,880
>> Agora vamos escrever todos
esses pixels da linha antiga

108
00:06:05,880 --> 00:06:07,440
em nossa nova linha.

109
00:06:07,440 --> 00:06:10,890
Uma vez que tenhamos feito isso, precisamos apenas
colocar o preenchimento, no final de nossa linha

110
00:06:10,890 --> 00:06:15,540
e vamos loop de volta e continuar por
todas as linhas em nosso arquivo novo.

111
00:06:15,540 --> 00:06:19,390
No final, é preciso fechar o nosso velho
arquivo, feche o nosso novo arquivo e retorno

112
00:06:19,390 --> 00:06:21,540
zero, porque tudo correu bem.

113
00:06:21,540 --> 00:06:24,220
>> Meu nome é Rob e esta foi Recesso.

114
00:06:24,220 --> 00:06:29,184
>> [Música tocando]