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

2
00:00:00,996 --> 00:00:12,470
>> [ಸಂಗೀತ]

3
00:00:12,470 --> 00:00:13,210
>> ರಾಬ್ ಬೌಡೆನ್: ಹಾಯ್.

4
00:00:13,210 --> 00:00:16,870
ನಾನು ರಾಬ್ ಮನುಷ್ಯ ಮತ್ತು ಅವಕಾಶ ಗಾತ್ರ
ಈ ಸಮಸ್ಯೆಯನ್ನು ಅಪ್.

5
00:00:16,870 --> 00:00:20,990
ಆದ್ದರಿಂದ ನಾವು copy.c ಆರಂಭವಾಗಬೇಕು ನೀನು
ಒಂದು ಟೆಂಪ್ಲೇಟ್, ಆದರೆ ನಾವು ಎಂದು ನೀನು

6
00:00:20,990 --> 00:00:23,340
ಕೆಲವು ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡುವ.

7
00:00:23,340 --> 00:00:27,570
>> ಈಗ ನಾವು ತಕ್ಷಣ ಮಾಡುತ್ತಿದ್ದೀಯ ನೋಡಿ ಒಂದು
ನಾವು ಇನ್ನು ಮುಂದೆ ತಪಾಸಣೆ ಮಾಡುತ್ತಿರುವ ಅಲ್ಲಿ ಬದಲಾಯಿಸಲು

8
00:00:27,570 --> 00:00:31,560
ನಮ್ಮ rxc ಈಗ 3 ಸಮನಾಗಿರಬೇಕು, ಆದರೆ ಇಲ್ಲ
ನಾವು ಆರ್ಸಿ ತಪಾಸಣೆ ಮಾಡುತ್ತಿರುವ 4 ಸಮನಾಗಿರಬೇಕು ಮಾಡುವುದಿಲ್ಲ.

9
00:00:31,560 --> 00:00:34,670
ನಾವು ರಲ್ಲಿ, ಸೇರಿಸಲು ಬಯಸುವ
ಕಡತ ಮತ್ತು ಔಟ್ ಕಡತಗಳನ್ನು ಜೊತೆಗೆ

10
00:00:34,670 --> 00:00:39,550
ಈ ಏರಲಿದೆ ಇದು ವಾದಗಳು, ಎಫ್
ನಾವು ಅಳೆಯುವುದು ನೀವು ಮೂಲಕ ಅಂಶವಾಗಿದೆ.

11
00:00:39,550 --> 00:00:45,430
>> ನಾವು ಭಾವಿಸುತ್ತೇವೆ ಆದ್ದರಿಂದ ಒಮ್ಮೆ, ನಾವು ಬಯಸುವ
ಸ್ಟ್ರಿಂಗ್ ಪರಿವರ್ತಿಸಲು ರು ಸ್ಕ್ಯಾನ್ F ಬಳಸಲು

12
00:00:45,430 --> 00:00:49,030
ಒಂದು ಫ್ಲೋಟ್ argv1.

13
00:00:49,030 --> 00:00:51,330
ನಾವು ಶೇಖರಿಸಿಡಲು ನೀನು
ಆ ಅಂಶ.

14
00:00:51,330 --> 00:00:55,180
ಈ ಹೆಚ್ಚುವರಿ ಪಾತ್ರ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಇದೆ
ನಾವು ವಾಸ್ತವವಾಗಿ ಪ್ರವೇಶಿಸುವ ಎಂದು

15
00:00:55,180 --> 00:00:59,200
1.4 ಎಬಿಸಿ ರೀತಿಯ
ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ.

16
00:00:59,200 --> 00:01:02,960
>> ಈಗ ನಾವು ಕೆಲವು ಅಲಿಯಾಸ್ ರಚಿಸಲು ನೀನು
RV2 ಮತ್ತು RV3 ಏಕೆಂದರೆ

17
00:01:02,960 --> 00:01:04,310
ಬಹಳ ಉಪಯುಕ್ತ ಹೆಸರುಗಳು.

18
00:01:04,310 --> 00:01:07,660
ನಾವು, ಬದಲಿಗೆ, ಕರೆಯಲು ನೀನು
ಅವುಗಳನ್ನು ಕಡತದಲ್ಲಿ ಮತ್ತು ಕಡತ.

19
00:01:07,660 --> 00:01:11,580
ಈಗ ನಾವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ನೀನು
ನಮ್ಮ ಅಂಶ ವಾಸ್ತವವಾಗಿ ತರ್ಕಬದ್ಧವಾಗಿಸುವ.

20
00:01:11,580 --> 00:01:16,330
ಆದ್ದರಿಂದ ಅಂಶ ಕಡಿಮೆ ಅಥವಾ ಸಮಾನ ವೇಳೆ
ಶೂನ್ಯ ಅಥವಾ ಹೆಚ್ಚಿನ 100 ಹೆಚ್ಚು, ನಂತರ ಪ್ರತಿ

21
00:01:16,330 --> 00:01:19,660
ವಿಶೇಷ, ನಾವು ತಿರಸ್ಕರಿಸಲು ಮಾಡಬೇಕು
ಆ ಅಂಶವನ್ನು.

22
00:01:19,660 --> 00:01:23,890
>> ನಾವು ಖಚಿತವಾಗಿ ಇರುವಾಗ ಈಗ ನಾವು, ಒಳ್ಳೆಯದು
ಎನ್ ಕಡತವನ್ನು ತೆರೆಯಲು, ಮತ್ತು ನಾವು ಮಾಡಬೇಕು

23
00:01:23,890 --> 00:01:25,950
ಇದು ಯಶಸ್ವಿಯಾಗಿ ತೆರೆಯಲಾಯಿತು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

24
00:01:25,950 --> 00:01:28,630
ಇದು ಮಾಡದಿದ್ದರೆ, ಆ ಶೂನ್ಯ ಹಿಂತಿರುಗುವುದು.

25
00:01:28,630 --> 00:01:30,390
ನಾವು ಕಡತವನ್ನು ತೆರೆಯಲು ನೀನು.

26
00:01:30,390 --> 00:01:33,420
ಮತ್ತೆ, ನಾವು ಮಾಡಲು ಚೆಕ್ ಬಯಸುವ
ಖಚಿತವಾಗಿ ಇದು ಯಶಸ್ವಿಯಾಗಿ ಆರಂಭವಾಯಿತು.

27
00:01:33,420 --> 00:01:37,270
ಇದು ಯಶಸ್ವಿಯಾಗಿ ನಂತರ, ತೆರೆದ ಮಾಡದಿದ್ದಲ್ಲಿ
ನಾವು ಮುಚ್ಚಲು ಮರೆಯಬೇಡಿ ಅಗತ್ಯವಿದೆ

28
00:01:37,270 --> 00:01:40,870
ಎನ್ ಕಡತ ಇದು ಮೂಲತಃ ಯಶಸ್ವಿಯಾಗಿ
ತೆರೆಯಿತು, ಅಥವಾ ಬೇರೆ ನಾವು ಒಂದು

29
00:01:40,870 --> 00:01:42,600
ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ.

30
00:01:42,600 --> 00:01:46,350
>> ಈಗ ನಾವು ಬಿಟ್ಮ್ಯಾಪ್ ಓದಲು ನೀನು
ಕಡತ ಹೆಡರ್ ಮತ್ತು ಬಿಟ್ಮ್ಯಾಪ್ ಮಾಹಿತಿಯನ್ನು

31
00:01:46,350 --> 00:01:48,890
ಎನ್ ಕಡತ ಹೆಡರ್.

32
00:01:48,890 --> 00:01:52,360
ನಾವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ನೀನು
ಎನ್ ಫೈಲ್ ಮಾನ್ಯ ಬಿಟ್ಮ್ಯಾಪ್ ಆಗಿತ್ತು.

33
00:01:52,360 --> 00:01:52,640
ಸರಿ.

34
00:01:52,640 --> 00:01:55,100
>> ಈಗ ನಾವು ಆರಂಭಿಸಲು ನೀನು
ಕೆಲವು ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡುವ.

35
00:01:55,100 --> 00:01:58,840
ನಾವು ಬದಲಾವಣೆ ನೀನು ಆದ್ದರಿಂದ ಏಕೆಂದರೆ
ವಿಷಯಗಳನ್ನು, ನಾವು ಮೊದಲ ನೆನಪಿಡುವ ಬಯಸುವ

36
00:01:58,840 --> 00:02:01,510
ಎನ್ ಫೈಲ್ ಹಳೆಯ ಅಗಲ.

37
00:02:01,510 --> 00:02:05,160
ನಾವು ಹಳೆಯ ಪ್ಯಾಡಿಂಗ್ ನೆನಪಿಡುವ ಬಯಸುವ
ಅದೇ ಲೆಕ್ಕ ಬಳಸಿ ಎನ್ ಫೈಲ್

38
00:02:05,160 --> 00:02:06,990
copy.c. ನಿಂದ

39
00:02:06,990 --> 00:02:09,840
>> ಈಗ ನಾವು ಬದಲಾಯಿಸಲು ನೀನು
ಬಿಟ್ಮ್ಯಾಪ್ ಮಾಹಿತಿಯನ್ನು ಹೆಡರ್.

40
00:02:09,840 --> 00:02:13,630
ಆದ್ದರಿಂದ ನಾವು ಅಗಲ ಎರಡೂ ಗುಣಿಸಿದಾಗ ಮಾಡುತ್ತಿದ್ದೇವೆ
ಮತ್ತು ನಂತರ ಅಂಶದಿಂದ ಎತ್ತರ

41
00:02:13,630 --> 00:02:15,750
ನಾವು ಸ್ಕೇಲಿಂಗ್ ಇಲ್ಲಿದೆ.

42
00:02:15,750 --> 00:02:18,420
ನಾವು ನಿರ್ಧರಿಸಲು ನೀನು
ಕಡತ ಮೂಲಕ ಹೊಸ ಪ್ಯಾಡಿಂಗ್

43
00:02:18,420 --> 00:02:21,140
ಹೊಸ ಅಗಲ ಬಳಸಿ.

44
00:02:21,140 --> 00:02:27,330
ಮತ್ತು ನಾವು ಹೊಸ ನಿರ್ಧರಿಸಲು ನೀನು
ಸಂಖ್ಯೆಯ ಬಳಸಿ ಚಿತ್ರದ ಗಾತ್ರ

45
00:02:27,330 --> 00:02:31,610
ಹೋಗುವ ಇದು ಒಂದು ಸಾಲು ಬೈಟ್ಗಳು
ಆ ಸಾಲು ಪಿಕ್ಸೆಲ್ಗಳ ಸಂಖ್ಯೆ

46
00:02:31,610 --> 00:02:35,960
ಬಾರಿ ಪಿಕ್ಸೆಲ್ ಗಾತ್ರದ ಜೊತೆಗೆ
ಕೊನೆಯಲ್ಲಿ ಪ್ಯಾಡಿಂಗ್ ಬೈಟ್ಗಳು ಸಂಖ್ಯೆ

47
00:02:35,960 --> 00:02:40,310
ಎಂದು ಸಾಲು, ಮತ್ತು ಎಲ್ಲಾ ಗುಣಿಸಿದಾಗ
ನಾವು ಹೊಂದಿರುವ ಸಾಲುಗಳ ಸಂಖ್ಯೆ ಮೂಲಕ.

48
00:02:40,310 --> 00:02:43,800
ಆದ್ದರಿಂದ ಬೈಟ್ಗಳು ಸಂಖ್ಯೆಯನ್ನು ಇಲ್ಲಿದೆ
ನಾವು ನಮ್ಮ ಚಿತ್ರ ದಶಮಾಂಶ ಹೊಂದಿವೆ.

49
00:02:43,800 --> 00:02:48,190
>> Bf.Bfsize ಈಗ ಸಂಖ್ಯೆ ಏರಲಿದೆ
ನಮ್ಮ ಚಿತ್ರ ಬೀಟಾ ಬೈಟ್ಗಳು ಜೊತೆಗೆ

50
00:02:48,190 --> 00:02:49,350
ನಮ್ಮ ಹೆಡರ್ ಗಾತ್ರ.

51
00:02:49,350 --> 00:02:53,910
ಬಿಟ್ಮ್ಯಾಪ್ ಕಡತ ಹೆಡರ್ ಆದ್ದರಿಂದ ಪ್ಲಸ್ ಗಾತ್ರ
ಮತ್ತು ಬಿಟ್ಮ್ಯಾಪ್ ಮಾಹಿತಿಯನ್ನು ಹೆಡರ್ ಗಾತ್ರ.

52
00:02:53,910 --> 00:02:54,510
ಸರಿ.

53
00:02:54,510 --> 00:02:56,440
ಆದ್ದರಿಂದ ನಮ್ಮ ಹೆಡರ್ ಅದು.

54
00:02:56,440 --> 00:02:59,030
ನಾವು ಫೈಲ್ ತಲೆ ಬರೆಯಲು ಮತ್ತು ಮಾಡಬಹುದು
ನಮ್ಮ ಔಟ್ ಮಾಹಿತಿಯನ್ನು ಹೆಡರ್

55
00:02:59,030 --> 00:03:01,590
ಫೈಲ್, ಮತ್ತು ನಾವು ಉತ್ತಮ ಆರ್.

56
00:03:01,590 --> 00:03:03,800
>> ಈಗ ಇದು ವಾಸ್ತವವಾಗಿ ಆರಂಭಿಸಲು ಸಮಯ
ಪಿಕ್ಸೆಲ್ ಬರೆಯಲು

57
00:03:03,800 --> 00:03:05,120
ಔಟ್ ಕಡತ ದತ್ತಾಂಶವನ್ನು.

58
00:03:05,120 --> 00:03:10,460
ನಾವು ಗಾತ್ರದ ಬಫರ್ ಘೋಷಿಸಲು ನೀನು
ಹಳೆಯ ಅಗಲ RGB ಮೂರು, ಮತ್ತು ನಾವು

59
00:03:10,460 --> 00:03:13,790
ಎಂಬ ಮಾರ್ಪಡಿಸಬಹುದಾದ ಘೋಷಿಸಲು ವಿಶೇಷವೇನು
ನಾವು ನೀನು ಇದು ಸಾಲು ನಿಶ್ಚೇಷ್ಟಿತ

60
00:03:13,790 --> 00:03:15,640
ಆರಂಭದಲ್ಲಿ ಋಣಾತ್ಮಕ 1 ಸಮಾನವಾಗಿರುತ್ತದೆ ಸೆಟ್.

61
00:03:15,640 --> 00:03:19,090
ನಾವು ಬಳಸುತ್ತಿರುವ ನೀನು ಎಂದು ನೋಡುತ್ತಾರೆ
ಎಂದು ಏನು ಜಾಡನ್ನು ಸಲುವಾಗಿ

62
00:03:19,090 --> 00:03:22,640
ನಾವು ಪ್ರಸ್ತುತ ಲೋಡ್ ಸಾಲು
ಈ ಬಫರ್ ಒಳಗೆ.

63
00:03:22,640 --> 00:03:23,290
ಸರಿ.

64
00:03:23,290 --> 00:03:28,750
>> ಈಗ, ಪ್ರಮಾಣಿತ ಆವೃತ್ತಿ ಭಿನ್ನವಾಗಿ
ಬದಲಿಗೆ ನಲ್ಲಿ ಮೇಲೆ iterating

65
00:03:28,750 --> 00:03:32,900
ಕಡತ, ನಾವು ಪ್ರತಿ ಮೇಲೆ ತಿರುಗಿ ನೀನು
ಔಟ್ ಕಡತದಲ್ಲಿ ಸಾಲು ಮತ್ತು ಲೆಕ್ಕಾಚಾರ

66
00:03:32,900 --> 00:03:38,130
ನಾವು ಬಯಸುವ ರಲ್ಲಿ ಕಡತದಲ್ಲಿ ಇದು ಸಾಲು
ಔಟ್ ಕಡತದಲ್ಲಿ ಈ ಸಾಲಾಗಿ ಇರಿಸಿ.

67
00:03:38,130 --> 00:03:44,930
ಆದ್ದರಿಂದ ಔಟ್ ಎಲ್ಲಾ ಸಾಲುಗಳನ್ನು ಮೇಲೆ iterating
ಹೊಸ ಎತ್ತರವನ್ನು ಬಳಸಿಕೊಂಡು ಫೈಲ್, ನಾವು ಮೊದಲ ಆರ್

68
00:03:44,930 --> 00:03:48,890
ಹಳೆಯ ಸಾಲು ನಿರ್ಧರಿಸಲು ಹೋಗುವ
ನಾವು ನೀವು ಇದು, ಬಳಸಲು ನೀನು ಫೈಲ್

69
00:03:48,890 --> 00:03:53,560
ಈ ಪ್ರಸ್ತುತ ಮೂಲಕ ಮಾಡಲು ಹೋಗಿ
ಸಾಲು ಅಂಶ ಭಾಗಿಸಿ.

70
00:03:53,560 --> 00:03:58,000
ಆದ್ದರಿಂದ ನಮಗೆ ಸತತವಾಗಿ ನೀಡಲು ವಿಶೇಷವೇನು
ನಾವು ಬಯಸುವ ಹಳೆಯ ಕಡತದಲ್ಲಿ.

71
00:03:58,000 --> 00:04:03,310
>> ಈಗ ವೇಳೆ ಸಾಲು ನಿಶ್ಚೇಷ್ಟಿತ ಸಮಾನರಲ್ಲ ಹಳೆಯ ವೈ ಮಾಡುತ್ತದೆ,
ನಾವು ಸತತವಾಗಿ ಓದಲು ಮಾಡಲಿಕ್ಕೆ

72
00:04:03,310 --> 00:04:05,940
ನಾವು ನಮ್ಮ ಸದ್ಯದ ಸಾಲು ಬಫರ್ ಒಳಗೆ ಬಯಸುವ.

73
00:04:05,940 --> 00:04:07,700
ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು ಏನು ಮಾಡೋಣ?

74
00:04:07,700 --> 00:04:11,650
ಮೊದಲ, ನಾವು ಲೆಕ್ಕಾಚಾರ ನೀನು
ಆ ಸಾಲು ಆರಂಭವಾಗುತ್ತದೆ ಆ ಸ್ಥಾನದಲ್ಲಿ

75
00:04:11,650 --> 00:04:13,100
ಮೂಲ ಕಡತ.

76
00:04:13,100 --> 00:04:18,630
ಆದ್ದರಿಂದ ಆ ಸ್ಥಾನಕ್ಕೆ ಏರಲಿದೆ
ನಮ್ಮ ಹೆಡರ್ ಎಲ್ಲಾ ಮತ್ತು ಕಳೆದ

77
00:04:18,630 --> 00:04:21,589
ಈಗ ಕಳೆದ ಹಳೆಯ ವೈ ಸಾಲುಗಳನ್ನು.

78
00:04:21,589 --> 00:04:23,880
>> ಆದ್ದರಿಂದ ಎಷ್ಟು ಬೈಟ್ಗಳು
ಒಂದೇ ಸಾಲಿನಲ್ಲಿ ಇವೆ?

79
00:04:23,880 --> 00:04:28,740
ಮತ್ತೆ, ಟ್ರಿಪಲ್ ಬಾರಿ RGB ಗಾತ್ರ ಹಳೆಯ
ಅಗಲ ಜೊತೆಗೆ ಹಳೆಯ ಪ್ಯಾಡಿಂಗ್, ಆ ನ

80
00:04:28,740 --> 00:04:30,640
ಒಂದೇ ಸಾಲಿನಲ್ಲಿ ಬೈಟ್ಗಳು ಸಂಖ್ಯೆ.

81
00:04:30,640 --> 00:04:33,680
ನಾವು ಕಳೆದ ಹಳೆಯ ವೈ ಸಾಲುಗಳನ್ನು ತೆರಳಿ ಬಯಸುವ.

82
00:04:33,680 --> 00:04:37,580
ನಾವು F ಹುಡುಕುವುದು ನೀನು ಮತ್ತು ನಾವು
ಆರಂಭಿಸಲು ಸೆಟ್ ಹುಡುಕುವುದು ಬಳಸಿ

83
00:04:37,580 --> 00:04:39,100
ಒಂದು ಕಡತದ ಆರಂಭಿಸಿದೆ.

84
00:04:39,100 --> 00:04:42,740
ನಾವು ಈ ಸ್ಥಾನವನ್ನು ಹುಡುಕುವುದು F ನೀನು
ಕಡತದಲ್ಲಿ, ನಮಗೆ ಹಾಕುವ

85
00:04:42,740 --> 00:04:46,500
ನಾವು ಬಯಸುವ ಸಾಲಿನ ಆರಂಭಕ್ಕೆ
ನಮ್ಮ ಬಫರ್ ಒಳಗೆ ಓದಲು.

86
00:04:46,500 --> 00:04:48,510
>> ನಾವು ಸತತವಾಗಿ ಹೊರಟಿರುವೆ
ಹಳೆಯ ವೈ ಸಮಾನವಾಗಿರುತ್ತದೆ ನಿಶ್ಚೇಷ್ಟಿತ.

87
00:04:48,510 --> 00:04:53,080
ಈಗ ನಾವು ಲೂಪ್ ಬ್ಯಾಕ್ ಮತ್ತು ನಾವು ಬಯಸುವ
ನಮ್ಮ ಔಟ್ ಕಡತ ಇದೇ ಸಾಲು ಬಳಸಲು,

88
00:04:53,080 --> 00:04:55,970
ನಾವು ಓದಲು ಹೋಗುತ್ತಿಲ್ಲ
ಇದು ಮತ್ತೆ ಅನಗತ್ಯವಾಗಿ.

89
00:04:55,970 --> 00:04:59,310
ಹಾಗಾಗಿ ನಿಜವಾಗಿಯೂ ಸಾಲು ನಿಶ್ಚೇಷ್ಟಿತ
ಕೇವಲ ಒಂದು ಆಪ್ಟಿಮೈಸೇಶನ್.

90
00:04:59,310 --> 00:05:05,500
>> ಅಂತಿಮವಾಗಿ, ನಾವು ಒಳಗೆ ಓದಲು ನೀನು
ಪ್ರಸ್ತುತ ಸಾಲಿನ ಹಳೆಯ ಅಗಲ RGB ಮೂರು

91
00:05:05,500 --> 00:05:08,040
ನಾವು ಮೂಲ ಕಡತ ಬಯಸುವ.

92
00:05:08,040 --> 00:05:12,270
ಈಗ ಸದ್ಯದ ಸಾಲು ಚಿತ್ರಬಿಂದುಗಳು ಹೊಂದಿದೆ
ನಾವು ಬಯಸುವ ಮೂಲ ಫೈಲ್

93
00:05:12,270 --> 00:05:14,200
ಔಟ್ ಕಡತ ಆಗಿ ಬರೆಯಲು.

94
00:05:14,200 --> 00:05:18,960
ಈಗ, ಕೇವಲ ಮೇಲೆ ಇಷ್ಟ, ಬದಲಿಗೆ
ಹಳೆಯ ಕಡತ ಮೇಲೆ iterating, ನಾವು ಅಗತ್ಯವಿದೆ

95
00:05:18,960 --> 00:05:22,560
ಇದು ಹೊಸ ಕಡತಗಳನ್ನು ಸಾಲುಗಳ ಮೇಲೆ ತಿರುಗಿ.

96
00:05:22,560 --> 00:05:27,450
ಅಲ್ಲದೆ ಇಲ್ಲಿ ಬದಲಿಗೆ ಮೇಲೆ iterating ಎಲ್ಲಾ
ಹಳೆಯ ಪಿಕ್ಸೆಲ್ಗಳ ಎಂದು ಸದ್ಯದ ಸತತವಾಗಿ,

97
00:05:27,450 --> 00:05:31,210
ನಾವು ಎಲ್ಲಾ ಮೇಲೆ ಮರಳಿ ಬಯಸುವ
ಈ ನಮ್ಮ ಹೊಸ ಕಡತದಲ್ಲಿ ಪಿಕ್ಸೆಲ್ಗಳು

98
00:05:31,210 --> 00:05:32,480
ನಿರ್ದಿಷ್ಟ ಸಾಲು.

99
00:05:32,480 --> 00:05:34,140
>> ಏಕೆ ನಾವು ಮಾಡಲು ಬಯಸುತ್ತೀರಿ?

100
00:05:34,140 --> 00:05:38,960
ನಾವು ಇಲ್ಲ ಎಂದು ಇಲ್ಲಿ ನೋಡಿ ಏಕೆಂದರೆ
ವಾಸ್ತವವಾಗಿ ಅಗತ್ಯವಾಗಿ ಎಲ್ಲಾ ಬಳಸಿಕೊಂಡು

101
00:05:38,960 --> 00:05:41,020
ಮೂಲ ಫೈಲ್ ಪಿಕ್ಸೆಲ್ಗಳು.

102
00:05:41,020 --> 00:05:46,630
ನಾವು ಕುಗ್ಗುತ್ತಿರುವ ಬಳಸುತ್ತಿದ್ದರೆ, ನಾವು ಏಕೆಂದರೆ
ವಾಸ್ತವವಾಗಿ ಪಿಕ್ಸೆಲ್ಗಳು ತೆರಳಿ ಬಯಸುವ.

103
00:05:46,630 --> 00:05:48,090
ಮತ್ತು ನಾವು ಈ ನೋಡಿ -

104
00:05:48,090 --> 00:05:49,690
X ಫ್ಯಾಕ್ಟರ್ ಭಾಗಿಸಿ -

105
00:05:49,690 --> 00:05:55,620
ನಾವು ವೈ ಹೇಳುತ್ತಾರೆ ಅಲ್ಲಿ ನಿಕಟವಾಗಿ ಇಲ್ಲಿ ಪ್ರತಿಬಿಂಬಿಸುತ್ತದೆ
ಲೆಕ್ಕಾಚಾರ ಅಂಶ ಭಾಗಿಸಿ ಎಂದು

106
00:05:55,620 --> 00:06:02,480
ಹಳೆಯ Y-ನೇ ಸಾಲಿನ ಅನುರೂಪವಾಗಿದೆ
ಈ ಹೊಸ ಕಡತ ವೈ ನೇ ಸಾಲಿನ.

107
00:06:02,480 --> 00:06:05,880
>> ಈಗ ನಾವು ಎಲ್ಲಾ ಬರೆಯಲು ನೀನು
ಹಳೆಯ ಸಾಲು ಈ ಪಿಕ್ಸೆಲ್ಗಳು

108
00:06:05,880 --> 00:06:07,440
ನಮ್ಮ ಹೊಸ ಸಾಲು.

109
00:06:07,440 --> 00:06:10,890
ನಾವು ಮಾಡಿದ ನಂತರ, ನಾವು ಅಗತ್ಯವಿರುವ
ನಮ್ಮ ಸಾಲು ಕೊನೆಯಲ್ಲಿ ಪ್ಯಾಡಿಂಗ್ ಪುಟ್

110
00:06:10,890 --> 00:06:15,540
ಮತ್ತು ನಾವು ಮತ್ತೆ ಲೂಪ್ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಮುಂದುವರೆಯಲು
ನಮ್ಮ ಹೊಸ ಕಡತ ಎಲ್ಲಾ ಸಾಲುಗಳನ್ನು.

111
00:06:15,540 --> 00:06:19,390
ಕೊನೆಯಲ್ಲಿ, ನಾವು ನಮ್ಮ ಹಳೆಯ ಮುಚ್ಚಲು ಅಗತ್ಯ
, ಫೈಲ್ ನಮ್ಮ ಹೊಸ ಕಡತ ಮುಚ್ಚಿ, ರಿಟರ್ನ್

112
00:06:19,390 --> 00:06:21,540
ಶೂನ್ಯ ಎಲ್ಲವನ್ನೂ ಉತ್ತಮ ಹೋದರು ಏಕೆಂದರೆ.

113
00:06:21,540 --> 00:06:24,220
>> ನನ್ನ ಹೆಸರನ್ನು ರಾಬ್ ಮತ್ತು ಈ ಮಧ್ಯಂತರ ಆಗಿತ್ತು.

114
00:06:24,220 --> 00:06:29,184
>> [ಸಂಗೀತ]