1
00:00:00,000 --> 00:00:09,780
>> [ಸಂಗೀತ]

2
00:00:09,780 --> 00:00:11,150
>> ZAMYLA ಚಾನ್: ಚೇತರಿಸಿಕೊಳ್ಳಲು ನ ನಿಭಾಯಿಸಲು ಲೆಟ್.

3
00:00:11,150 --> 00:00:14,030
ಕೊಡು ಬಹುಶಃ ನನ್ನ ನೆಚ್ಚಿನ pset,
ಮತ್ತು ಮುಖ್ಯವಾಗಿ ನಾನು ಭಾವಿಸುತ್ತೇನೆ ಏಕೆಂದರೆ

4
00:00:14,030 --> 00:00:15,650
ನಿಜವಾಗಿಯೂ ತಂಪಾದ.

5
00:00:15,650 --> 00:00:19,040
ಮೂಲಭೂತವಾಗಿ, ನೀವು ಒಂದು ಮೆಮೊರಿ ನೀಡಿದ ನೀವು
ಕಾರ್ಡ್ ಕಡತ ಇದರಲ್ಲಿ

6
00:00:19,040 --> 00:00:20,900
ಚಿತ್ರಗಳನ್ನು ಅಳಿಸಲಾಗಿದೆ.

7
00:00:20,900 --> 00:00:23,650
ಆದರೆ ಏನು ನೀನು
ಅವುಗಳನ್ನು ಎಲ್ಲಾ ಕೊಡು.

8
00:00:23,650 --> 00:00:24,250
>> ಸರಿ.

9
00:00:24,250 --> 00:00:28,230
ಆದ್ದರಿಂದ ಬಹುಶಃ ಇದು ನಿಜವಾಗಿಯೂ ಅದ್ಭುತ ಇಲ್ಲಿದೆ, ಆದರೆ
ನೀವು ಏಕೆಂದರೆ, ಸ್ವಲ್ಪ ಬೆದರಿಸುವ

10
00:00:28,230 --> 00:00:32,430
ಖಾಲಿ ಸಿ ಕಡತ ನೀಡಿದ
ನೀವು ಸೈನ್ ಭರ್ತಿ ಮಾಡಬೇಕು

11
00:00:32,430 --> 00:00:36,250
ಸರಿ, ಆದ್ದರಿಂದ ಅವರ ಈ ಮುರಿಯಲು ಅವಕಾಶ
ನಿರ್ವಹಣಾ ಭಾಗಗಳಾಗಿ.

12
00:00:36,250 --> 00:00:38,160
ನೀವು ತೆರೆಯಲು ಬಯಸುವಿರಿ
ಮೆಮೊರಿ ಕಾರ್ಡ್ ಕಡತ.

13
00:00:38,160 --> 00:00:39,900
ಸಾಕಷ್ಟು ಸರಳವಾಗಿದೆ ತೋರುತ್ತದೆ.

14
00:00:39,900 --> 00:00:43,030
ನಂತರ, ಆರಂಭದಲ್ಲಿ ಕಾಣಬಹುದು
ಒಂದು JPG ಚಿತ್ರ.

15
00:00:43,030 --> 00:00:46,740
ಈ ಮೆಮೊರಿ ಎಲ್ಲ ಫೈಲ್ಗಳನ್ನು
ಕಾರ್ಡ್ ಕೆಲಸ JPGS ಹೋಗುವ.

16
00:00:46,740 --> 00:00:50,840
ನಂತರ, ಒಮ್ಮೆ ನೀವು, ಆರಂಭದಲ್ಲಿ ಕಾಣಬಹುದು
ನೀವು, ಹೊಸ JPG ತೆರೆಯಲು ನೀನು

17
00:00:50,840 --> 00:00:57,610
, ಹಾಗೆ, ಒಂದು JPG ರಚಿಸಲು, ಮತ್ತು 512 ಬರೆಯಲು ಇದೆ
ಹೊಸ JPG ತನಕ ಸಮಯದಲ್ಲಿ ಬೈಟ್

18
00:00:57,610 --> 00:01:02,930
ಕಂಡು, ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಒಮ್ಮೆ
ನೀವು ಕಡತದ ಕೊನೆಯಲ್ಲಿ ಪತ್ತೆ.

19
00:01:02,930 --> 00:01:06,400
>> ಆದ್ದರಿಂದ ಮೊದಲ ಕ್ರಮಗಳನ್ನು ಮೊದಲ ತೆರೆಯುವುದು
ಮೆಮೊರಿ ಕಾರ್ಡ್ ಕಡತ.

20
00:01:06,400 --> 00:01:09,850
ಆದರೆ ನೀವು ಈಗಾಗಲೇ ಈ ಗೊತ್ತಿಲ್ಲ, ಮತ್ತು ಇಲ್ಲ
ವಿಶೇಷವೇನು ಒಂದು ಕಡತ ನಾನು / ಒ ಕಾರ್ಯ

21
00:01:09,850 --> 00:01:12,030
ಬಹಳ ಉಪಯುಕ್ತ ಸಾಬೀತು.

22
00:01:12,030 --> 00:01:12,820
ಸರಿ.

23
00:01:12,820 --> 00:01:14,760
ಆದ್ದರಿಂದ ಕೆಲಸ JPGS ಯಾವುವು?

24
00:01:14,760 --> 00:01:16,330
ನಾವು ಆರಂಭದಲ್ಲಿ ಬೇಕಾಗುತ್ತದೆ.

25
00:01:16,330 --> 00:01:21,310
ಅಲ್ಲದೆ, ಕೆಲಸ JPGS, ಕೇವಲ ಸ್ವಲ್ಪ ನಕ್ಷೆಗಳು ಹಾಗೆ,
ಬೈಟ್ಗಳು ಕೇವಲ ಸರಣಿಗಳು ಇವೆ.

26
00:01:21,310 --> 00:01:30,660
ಅದೃಷ್ಟವಶಾತ್, ಪ್ರತಿ JPG ಎರಡೂ ಆರಂಭವಾಗುತ್ತದೆ
0xff, 0xd8, 0xff, 0xe0, ಒಂದು ಅನುಕ್ರಮ

27
00:01:30,660 --> 00:01:33,610
ಬೈಟ್ಗಳು, ಅಥವಾ ಮತ್ತೊಂದು
ಬೈಟ್ಗಳು ಅನುಕ್ರಮ.

28
00:01:33,610 --> 00:01:37,250
>> ಆದ್ದರಿಂದ ಆ ನಾಲ್ಕು ಬೈಟ್ಗಳು ಸೂಚಿಸುತ್ತದೆ
ಒಂದು JPG ಆರಂಭದಲ್ಲಿ.

29
00:01:37,250 --> 00:01:40,780
ಆ ಎರಡು ಸಂಯೋಜನೆಗಳನ್ನು ಬೇರೆ ಯಾವುದೇ
ನಾಲ್ಕು ಬೈಟ್ಗಳು.

30
00:01:40,780 --> 00:01:44,840
ಅದೃಷ್ಟವೆಂದರೆ ನಮಗೆ, ಮತ್ತೊಂದು ವಾಸ್ತವವಾಗಿ ನಾವು
ಲಾಭ ಎಂದು ಪ್ರತಿ

31
00:01:44,840 --> 00:01:48,550
JPG ಪಕ್ಕ ಬಲಭಾಗದ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ
ಮೆಮೊರಿ ಕಾರ್ಡ್.

32
00:01:48,550 --> 00:01:52,210
ನಾನು ರಚನೆ ನಿರೂಪಿಸಲಾಗಿದೆ ಬಂದಿದೆ
ಸಂಕೇತಗಳಲ್ಲಿ ಈ ಮೇಲೆ ಮೆಮೊರಿ ಕಾರ್ಡ್

33
00:01:52,210 --> 00:01:53,310
ಇಲ್ಲಿ ಸ್ಲೈಡ್.

34
00:01:53,310 --> 00:01:59,270
ಇಲ್ಲಿ ಪ್ರತಿ ಚದರ, ಪ್ರತಿ ಆಯಾತ,
512 ಬೈಟ್ಗಳು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಮತ್ತು ಇದು ಆರಂಭವಾಗುತ್ತದೆ

35
00:01:59,270 --> 00:02:01,750
ನಾವು ಬಾರದ ಒಂದು ಬೂದು
ನಿಜವಾಗಿಯೂ ಒಂದು JPG ಹೊಂದಿವೆ.

36
00:02:01,750 --> 00:02:05,700
>> ಆದರೆ ಆಗ ನಾವು ಅಂತಿಮವಾಗಿ ಹಿಟ್
ನಕ್ಷತ್ರ ಹೊಂದಿರುವ ಒಂದು ಖಂಡ.

37
00:02:05,700 --> 00:02:10,940
ಅರ್ಥ ಮೊದಲ ನಾಲ್ಕು ಬೈಟ್ಗಳು ಔಟ್
ಆ 512 ಆ ಎರಡು ಒಂದು

38
00:02:10,940 --> 00:02:13,230
ಒಂದು JPG ಸರಣಿಗಳನ್ನು ಆರಂಭಿಸಿ.

39
00:02:13,230 --> 00:02:17,340
ಮತ್ತು ನಾವು ಒಮ್ಮೆ ಅಲ್ಲಿಂದ ಹೋಗಿ ನಂತರ, ಮತ್ತು
ಒಂದು JPG ಮುಂದಿನ ಒಂದು ಆರಂಭವಾಗುತ್ತದೆ, ಕೊನೆಗೊಳ್ಳುತ್ತದೆ.

40
00:02:17,340 --> 00:02:20,990
ನಾವು ಯಾವುದೇ ಹೆಚ್ಚು ಇಲ್ಲ
ನಡುವೆ ಬೂದು ಜಾಗವನ್ನು.

41
00:02:20,990 --> 00:02:25,550
>> ಆದರೆ ಹೇಗೆ ನಾವು ವಾಸ್ತವವಾಗಿ ಈ ಓದಲು, ಮತ್ತು ಇಲ್ಲ
ನಾವು ಮಾಡಬಹುದು ಆದ್ದರಿಂದ 512 ಬೈಟ್ಗಳು ಓದಲು

42
00:02:25,550 --> 00:02:27,500
ಹೋಲಿಕೆ ಮೊದಲ ಸ್ಥಾನ?

43
00:02:27,500 --> 00:02:33,470
ಅಲ್ಲದೆ, ಮತ್ತೆ fread ಹೋಗಿ ಅವಕಾಶ ಇದು
ಹೊಂದಿರುವ struct ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

44
00:02:33,470 --> 00:02:34,470
ನೀವು ಓದುವ ನೀವು ಬೈಟ್ಗಳು.

45
00:02:34,470 --> 00:02:36,570
ಆದ್ದರಿಂದ ನೀವು ಹಾಕಲು ನೀನು
ಹಾಗಾದರೆ ಆ -

46
00:02:36,570 --> 00:02:42,192
ಗಾತ್ರ, ಸಂಖ್ಯೆ, ಮತ್ತು ನಂತರ inpointer
ನೀವು ಓದುವ ನೀವು ಎಂದು.

47
00:02:42,192 --> 00:02:49,900
ಈಗ, ನಾವು ಒಂದು ಸಮಯದಲ್ಲಿ 512 ಓದಲು ಬಯಸುವ, ಮತ್ತು
ನಾವು ಒಂದು ಬಫರ್ ಈ ಶೇಖರಿಸಿಡಲು ಬಯಸುವ

48
00:02:49,900 --> 00:02:50,700
ನಾನು ಕರೆ ಪಡೆಯಲಿದ್ದೇನೆ.

49
00:02:50,700 --> 00:02:54,100
>> ಮೂಲತಃ, ನಾವು ಹಿಡಿಯಲು ನೀನು
ಆ 512 ಬೈಟ್ಗಳು ಮೇಲೆ ಮತ್ತು ಹಾಗೆ

50
00:02:54,100 --> 00:02:55,500
ಇದು ಕೆಲಸಗಳನ್ನು, ಬಲ?

51
00:02:55,500 --> 00:02:58,260
ನಾವು ಎರಡೂ ಮೊದಲ ಹೋಲಿಸಲು ನೀನು
ನಾಲ್ಕು ಬೈಟ್ಗಳು, ಅಥವಾ ನಾವು ನೀನು

52
00:02:58,260 --> 00:02:59,830
ಸರಿ, ಇದು ಓದಲು?

53
00:02:59,830 --> 00:03:05,050
ಆದ್ದರಿಂದ ದಶಮಾಂಶ ಪಾಯಿಂಟರ್ ನಂತರ ತಿನ್ನುವೆ
ನಿಮ್ಮ ಬಫರ್ ಬಳಸಲ್ಪಡುತ್ತದೆ, ಮತ್ತು

54
00:03:05,050 --> 00:03:07,745
inpointer, ಚೆನ್ನಾಗಿ, ಕೇವಲ ವಿಶೇಷವೇನು
ನಿಮ್ಮ ಮೆಮೊರಿ ಕಾರ್ಡ್ ಎಂದು.

55
00:03:07,745 --> 00:03:09,500
>> ನಮ್ಮ ಮೆಮೊರಿ ಕಾರ್ಡ್ ರೂಪರೇಖೆ ಮರಳಿ.

56
00:03:09,500 --> 00:03:14,690
ನಾವು ಒಂದು ಸಮಯದಲ್ಲಿ 512 ಬೈಟ್ಗಳು ಓದಲು ನೀನು,
ಪ್ರತಿ 512 ಬೈಟ್ ಬ್ಲಾಕ್ ಸಂಗ್ರಹಿಸುವ

57
00:03:14,690 --> 00:03:19,190
ಒಂದು ಬಫರ್ ಒಳಗೆ, ಹಿಡುವಳಿ ಆ ಮೇಲೆ
ನಾವು ವರೆಗೆ, ಆ 512 ಬೈಟ್ಗಳು ಬಫರ್

58
00:03:19,190 --> 00:03:22,000
ನಿಖರವಾಗಿ ಏನು ಮಾಡಲು.

59
00:03:22,000 --> 00:03:25,960
ಆದ್ದರಿಂದ ಆರಂಭದಲ್ಲಿ ಏನು ಇಲ್ಲ, ಆದ್ದರಿಂದ
ನಾವು, ಬಫರ್ ಓದಲು ಹೋಲಿಸಿ, ಮತ್ತು ಮಾಡುತ್ತೇವೆ

60
00:03:25,960 --> 00:03:28,160
ನಾವು ಏನನ್ನೂ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ.

61
00:03:28,160 --> 00:03:32,030
ನಂತರ, ನಾವು ಅಂತಿಮವಾಗಿ ಒಂದು ನಕ್ಷತ್ರದ ಹೊಡೆಯಲು
ನಾವು ಮಾಡಿದ, ಅಂದರೆ ನಿರ್ಬಂಧಿಸಲು

62
00:03:32,030 --> 00:03:33,630
ನಮ್ಮ ಮೊದಲ JPG ಕಂಡುಬಂದಿಲ್ಲ.

63
00:03:33,630 --> 00:03:36,560
ಆದ್ದರಿಂದ ಬಫರ್ ಈಗ ಹಿಡಿದಿಡಲು
ಎಂದು JPG ರಿಂದ ಬೈಟ್ಗಳು.

64
00:03:36,560 --> 00:03:40,220
>> ಅವರು ಆರ್ 512 ಬೈಟ್ಗಳು, ಏಕೆಂದರೆ ಮುಂದಿನ ಬಾರಿ
ಅಲ್ಲ ನಕ್ಷತ್ರ ಬ್ಲಾಕ್, ಸಹ

65
00:03:40,220 --> 00:03:41,740
ಎಂದು JPG ಭಾಗವಾಗಿ.

66
00:03:41,740 --> 00:03:47,630
ಮತ್ತು ಕೆಲಸ JPGS ಅಲ್ಲಿಂದ ನಿರಂತರವಾಗಿವೆ
ಮೇಲೆ ನಾವು ಮುಂದಿನ JPG ಹಿಟ್ ರವರೆಗೆ, ರಲ್ಲಿ.

67
00:03:47,630 --> 00:03:51,880
ತದನಂತರ ಬಫರ್ ನಂತರ ಹೊಂದಿದೆ
512 ಎಂದು JPG ಫಾರ್ ಬೈಟ್ಗಳು, ಮತ್ತು

68
00:03:51,880 --> 00:03:53,580
ಹೀಗೆ, ಇತ್ಯಾದಿ.

69
00:03:53,580 --> 00:03:54,250
ಸರಿ.

70
00:03:54,250 --> 00:03:58,980
>> ನೀವು ಮೊದಲ ನಕ್ಷತ್ರ ಹಿಟ್ ಆದ್ದರಿಂದ ಒಮ್ಮೆ
ಬ್ಲಾಕ್, ಮೊದಲ jpg, ಹೇಗೆ ನೀವು

71
00:03:58,980 --> 00:04:01,910
ವಾಸ್ತವವಾಗಿ, ಚೆನ್ನಾಗಿ, ಅದನ್ನು ತೆರೆಯಲು?

72
00:04:01,910 --> 00:04:04,990
ನ ಹೊಸ JPG ಮಾಡೋಣ.

73
00:04:04,990 --> 00:04:08,846
ಒಂದು JPG ಫಾರ್ ಕಡತದ ಹೋಗುವ
ಸ್ವರೂಪದಲ್ಲಿರಬೇಕು, ಸಂಖ್ಯೆ, ಸಂಖ್ಯೆ,

74
00:04:08,846 --> 00:04:13,830
number.jpg, ಎಂದು ಅವರು ಹೆಸರಿಸಲಾಗಿದೆ ಮಾಡುತ್ತಿದ್ದೇವೆ
ಅವರು ಕಂಡು ಯಾವ ಕ್ರಮದಲ್ಲಿ,

75
00:04:13,830 --> 00:04:14,780
0 ಪ್ರಾರಂಭವಾಗುವ.

76
00:04:14,780 --> 00:04:19,890
>> ಆದ್ದರಿಂದ ಮೊದಲ JPG ನೀವು
ಹೇಗೆ 000.jpg ಮಾಡಲಾಗುತ್ತದೆ.

77
00:04:19,890 --> 00:04:26,560
ಆದ್ದರಿಂದ, ಬಹುಶಃ ಒಳ್ಳೆಯದು ಕಾಪಾಡುವುದು
ನೀವು ಇದುವರೆಗೆ ಕಂಡು ಬಂದಿದೆ ಎಷ್ಟು ಕೆಲಸ JPGS.

78
00:04:26,560 --> 00:04:27,610
ಆದ್ದರಿಂದ ಫೈಲ್ ಹೆಸರು ಇಲ್ಲಿದೆ.

79
00:04:27,610 --> 00:04:29,660
ಆದರೆ ಹೇಗೆ ನೀವು ವಾಸ್ತವವಾಗಿ ಎಂದು ಮಾಡುತ್ತವೆಯಾದರೂ?

80
00:04:29,660 --> 00:04:34,310
ಹಾಗೆಯೇ, ನಾವು ಬಳಸಲು ನೀನು ಒಂದು
ಕಾರ್ಯ sprintf ಎಂಬ.

81
00:04:34,310 --> 00:04:38,260
Printf ಗೆ ಹೋಲುವ ಸ್ವಲ್ಪ, ಅಲ್ಲಿ
ನೀವು, ತಂತಿ ಫಾರ್ placeholders ಬಳಸಬಹುದು

82
00:04:38,260 --> 00:04:42,420
ಈ ಸಂದರ್ಭದಲ್ಲಿ ಹೊರತುಪಡಿಸಿ, sprintf ಮುದ್ರಿಸಿ
ಪ್ರಸ್ತುತ ಫೈಲ್ ಔಟ್

83
00:04:42,420 --> 00:04:45,550
ಕೋಶವನ್ನು ಅಲ್ಲ ಟರ್ಮಿನಲ್.

84
00:04:45,550 --> 00:04:46,120
>> ಸರಿ.

85
00:04:46,120 --> 00:04:49,950
ಇಲ್ಲಿ ನಾವು ಶೀರ್ಷಿಕೆ ಹೊಂದಿರುವ ನೋಡಿ,
ಸಂಗ್ರಹಿಸುತ್ತದೆ ಚಾರ್ ರಚನೆಯ

86
00:04:49,950 --> 00:04:55,120
ಪರಿಣಾಮಕ ಸ್ಟ್ರಿಂಗ್, ಮತ್ತು ನಾವು ಹಾದು
ಒಂದು ನಿಜವಾದ ಸ್ಟ್ರಿಂಗ್ ಶೀರ್ಷಿಕೆ

87
00:04:55,120 --> 00:04:58,720
ಪ್ಲೇಸ್ಹೋಲ್ಡರ್, ಕೇವಲ ನಾವು ಮಾಡಿದ ಇಷ್ಟ
printf ಜೊತೆಗೆ ಕಲಿತರು.

88
00:04:58,720 --> 00:05:05,530
ಆದರೆ ನಾನು ಇಲ್ಲಿ ಹೊಂದಿರುವ ಈ ಕೋಡ್
2.jpg ಅಲ್ಲದ 002.jpg ನೀಡುತ್ತದೆ.

89
00:05:05,530 --> 00:05:09,920
ಹಾಗಾಗಿ ಕಂಡುಹಿಡಿಯಲು ನೀವು ಬಿಟ್ಟು ಮಾಡುತ್ತೇವೆ ಹೇಗೆ
ಮಾಡಲು ಪ್ಲೇಸ್ಹೋಲ್ಡರ್ ಮಾರ್ಪಡಿಸಲು

90
00:05:09,920 --> 00:05:11,920
ಸರಿಯಾದ ಹೆಸರು.

91
00:05:11,920 --> 00:05:12,610
>> ಸರಿ.

92
00:05:12,610 --> 00:05:17,390
ಆದ್ದರಿಂದ ಒಮ್ಮೆ ನೀವು ನಂತರ ನೀವು sprintf'd ಬಂದಿದೆ
ಇದು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಏಕೆಂದರೆ, ಆ ಕಡತವನ್ನು ತೆರೆಯಲು

93
00:05:17,390 --> 00:05:22,690
fopen ನಿಮ್ಮ ಕೋಶವನ್ನು ಬಳಸಿ
ಶೀರ್ಷಿಕೆ, ಮತ್ತು ನೀವು ಬಯಸುವ ನಂತರ ಯಾವುದೇ ಕ್ರಮದಲ್ಲಿ

94
00:05:22,690 --> 00:05:25,140
ಸೈನ್ ಕಡತವನ್ನು ತೆರೆಯಲು

95
00:05:25,140 --> 00:05:30,260
ಈಗ ನಾವು ಹೊಸ JPG ಕಡತ ತೆರೆಯಿತು ನೀವು,
ಈಗ ನಾವು ಒಂದು 512 ಬೈಟ್ಗಳು ಬರೆಯಬಹುದು

96
00:05:30,260 --> 00:05:33,320
ಹೊಸ JPG ತನಕ ಸಮಯ,.

97
00:05:33,320 --> 00:05:36,640
ಆದ್ದರಿಂದ ಮತ್ತೊಂದು ಅವಲೋಕಿಸೋಣ
ರಚಿಸುವಲ್ಲಿ ವಾಕ್ಯ ನಲ್ಲಿ.

98
00:05:36,640 --> 00:05:40,060
>> ನಾನು ಈ ಸ್ಲೈಡ್ ತೋರಿಸುವ ನುಡಿದರು ಗೊತ್ತು
ಬಹಳಷ್ಟು, ಆದರೆ ನಾನು ಖಚಿತವಾಗಿ ಮಾಡಲು ಬಯಸುವ

99
00:05:40,060 --> 00:05:43,530
ನೀವು ಹುಡುಗರಿಗೆ, ತುಂಬಾ ಗೊಂದಲಮಯ ಪಡೆಯಲು ಕಾರಣ
ನಾನು ತುಂಬಾ ಸುಲಭ ಎಂದು ಗೊತ್ತಿಲ್ಲ

100
00:05:43,530 --> 00:05:47,000
ಮೊದಲ ಮತ್ತು ಕೊನೆಯ ಅಪ್ ಮಿಶ್ರಣ
ವಾದ, ನಿರ್ದಿಷ್ಟವಾಗಿ.

101
00:05:47,000 --> 00:05:54,390
ಆದರೆ ನೀವು ಬರೆಯುವ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ
ಔಟ್ ಕಡತ ಚಿತ್ರಗಳನ್ನು ನಿಮ್ಮ ಬಫರ್.

102
00:05:54,390 --> 00:05:59,250
>> ಈಗ ನಿಮಗೆ ಹೇಗೆ ಬರಹ 512
ನೀವು ಮಾಡಿದ ನಿಮ್ಮ JPG ಕಡತ ಒಳಗೆ ಬೈಟ್ಗಳು

103
00:05:59,250 --> 00:06:03,230
ದಾಖಲಿಸಿದವರು, ಚೆನ್ನಾಗಿ, ನಾವು ನಿಲ್ಲಿಸಲು ಬಯಸುವ
ನಾವು ಕೊನೆಯಲ್ಲಿ ತಲುಪಿದ್ದೀರಿ ಪ್ರಕ್ರಿಯೆ ಒಮ್ಮೆ

104
00:06:03,230 --> 00:06:06,720
ನಮ್ಮ ಕಾರ್ಡ್, ಏಕೆಂದರೆ ಅಲ್ಲಿ ಸಾಧ್ಯವಿಲ್ಲ
ಕಾಣಬಹುದು ಯಾವುದೇ ಹೆಚ್ಚು ಚಿತ್ರಗಳು.

105
00:06:06,720 --> 00:06:10,760
ಆದ್ದರಿಂದ fread ಹಿಂತಿರುಗಿ ಅವಕಾಶ
ಮತ್ತೊಮ್ಮೆ, ನಾನು ಭರವಸೆ.

106
00:06:10,760 --> 00:06:15,600
fread ಗಾತ್ರದ ಎಷ್ಟು ಐಟಂಗಳನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ,
ಗಾತ್ರ, ಯಶಸ್ವಿಯಾಗಿ ಸಿದ್ಧವಿದೆ.

107
00:06:15,600 --> 00:06:19,440
ತಾತ್ತ್ವಿಕವಾಗಿ, ಈ ಏರಲಿದೆ ಏನೇ
ನೀವು ಬಲ, ಸಂಖ್ಯೆ ಹಾದು?

108
00:06:19,440 --> 00:06:24,140
ನೀವು ಸಂಖ್ಯೆ ಓದಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಏಕೆಂದರೆ
ಗಾತ್ರ, ಗಾತ್ರ ಅಂಶಗಳ.

109
00:06:24,140 --> 00:06:29,380
ಆದರೆ fread ಓದಲು ಸಾಧ್ಯವಿಲ್ಲ ವೇಳೆ
ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಅದು ಬರುತ್ತೇವೆ

110
00:06:29,380 --> 00:06:32,530
ಇದು ಯಶಸ್ವಿಯಾಗಿ ಓದಲು ಏನೇ ಸಂಖ್ಯೆ.

111
00:06:32,530 --> 00:06:36,310
>> ಈಗ, ಗಮನಿಸಬೇಕಾದ ಒಂದು ಮುಖ್ಯ ವಿಷಯ
ನೀವು ನಾನು / ಒ ಮತ್ತೊಂದು ಕಡತವನ್ನು ಬಳಸಿದಲ್ಲಿ

112
00:06:36,310 --> 00:06:43,860
fgetc ಹಾಗೆ ಕಾರ್ಯ, ಇದು ಬರುತ್ತೇವೆ
ಇದು ಯಶಸ್ವಿಯಾಗಿ ಓದಲು ಎಷ್ಟು ಐಟಂಗಳನ್ನು.

113
00:06:43,860 --> 00:06:48,000
ಏನು ಈ ಕಾರ್ಯವನ್ನು ಬಗ್ಗೆ ಉಪಯುಕ್ತ ಆಗಿದೆ
ನೀವು ಒಳಗೆ ಕಾರ್ಯಗಳನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ

114
00:06:48,000 --> 00:06:53,190
ಗುಣ, ಆದರೆ ಸ್ವತಃ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮಾಡುತ್ತೇವೆ
ಇದು ಆ ಪರಿಸ್ಥಿತಿ, ನಿರ್ಧರಿಸುವ

115
00:06:53,190 --> 00:06:54,340
ಕೇವಲ ನಿಜವಾಗಿಯೂ ಉಪಯುಕ್ತ.

116
00:06:54,340 --> 00:07:00,440
ಆದ್ದರಿಂದ ನೀವು ಈ ಪರಿಸ್ಥಿತಿಗಳು ಹೊಂದಿದ್ದರೆ, ಹೇಳುತ್ತಾರೆ,
ವೇಳೆ fread ಬಫರ್ ರ sizeof ನಾಯಿ, 2,

117
00:07:00,440 --> 00:07:04,870
ಪಾಯಿಂಟರ್, 1 ಸಮ ಸಮ ಎಂದು
ನಾನು ಓದಲು ಬಯಸುವ ಅರ್ಥ

118
00:07:04,870 --> 00:07:06,540
ಸಮಯದಲ್ಲಿ 2 ನಾಯಿಗಳು.

119
00:07:06,540 --> 00:07:13,490
ಆದರೆ fread ಬದಲಿಗೆ 2 1 ಹಿಂದಿರುಗಿಸುತ್ತದೆ
ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ ಎಂದು 2 ಇವೆ ಎಂದರ್ಥ

120
00:07:13,490 --> 00:07:16,480
ನಾಯಿಗಳು ನನ್ನ ಕಡತದಲ್ಲಿ ಬಿಟ್ಟು, ಆದರೆ 1.

121
00:07:16,480 --> 00:07:22,450
ಆದರೆ 2 ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಆಗ ನಾನು ಇನ್ನೂ
ನನ್ನ ಬಫರ್ ಒಳಗೆ ಆ 2 ನಾಯಿಗಳು.

122
00:07:22,450 --> 00:07:26,280
>> ಈಗ ನೀವು ಹೇಗೆ ಒಂದು ಅರ್ಥದಲ್ಲಿ ನೀಡುತ್ತದೆ
ಕಡತದ ಕೊನೆಯಲ್ಲಿ ಪರಿಶೀಲಿಸಿ, ಆದರೆ

123
00:07:26,280 --> 00:07:28,940
ಈಗ ತರ್ಕ ಮೂಲಕ ಹೋಗಲು ಅವಕಾಶ.

124
00:07:28,940 --> 00:07:32,460
ಹೇಗೆ ನಾವು ವಾಸ್ತವವಾಗಿ ಎಲ್ಲಾ ಪೀಸ್ ಇಲ್ಲ
ಒಟ್ಟಿಗೆ ಈ ಅಂಶಗಳನ್ನು?

125
00:07:32,460 --> 00:07:36,880
ನಾವು ನಮ್ಮ ಮೊದಲ JPG ಹಿಟ್ ಒಮ್ಮೆ ರಿಂದ
ನಾವು ಕೆಲಸ JPGS ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಎಂದು ಗೊತ್ತಿಲ್ಲ

126
00:07:36,880 --> 00:07:40,910
ನೇರ, ನಾವು ರವರೆಗೆ ಬರೆಯುವ ಪಡೆದುಕೊಳ್ಳುತ್ತೀರಿ
ನಾವು ಕಾರ್ಡ್ ಕಡತದ ಕೊನೆಯಲ್ಲಿ ತಲುಪಲು.

127
00:07:40,910 --> 00:07:43,950
ಆದರೆ ನಾವು ಬರೆಯಲು ಬಯಸುವುದಿಲ್ಲ
ಏನು ಅಲ್ಲಿಯವರೆಗೆ.

128
00:07:43,950 --> 00:07:48,710
ಆದ್ದರಿಂದ ನಾವು ಎಂಬುದನ್ನು ಕೇವಲ, ಮ್ಯಾಟರ್ಸ್
ಹೊಸ JPG ಆರಂಭದಲ್ಲಿ, ಆದರೆ ಎಂಬುದನ್ನು

129
00:07:48,710 --> 00:07:50,655
ನಾವು ಈಗಾಗಲೇ JPG ಅಥವಾ ಇಲ್ಲ ಕಂಡುಬಂದಿವೆ.

130
00:07:50,655 --> 00:07:55,390
>> ಇದು ಹೊಸ JPG ಆರಂಭದಲ್ಲಿ, ನಾವು ಮಾಡುತ್ತೇವೆ
ನಮ್ಮ ಪ್ರಸ್ತುತ JPG ಕಡತ ವೇಳೆ ಮುಚ್ಚಲು ಬಯಸುವ

131
00:07:55,390 --> 00:07:59,110
ನಾವು ಒಂದು ಮುಕ್ತ ಮತ್ತು ತೆರೆದ ಹೊಂದಿವೆ
ಒಳಗೆ ಬರೆಯಲು ಹೊಸ.

132
00:07:59,110 --> 00:08:03,340
ಇದು ಹೊಸ JPG ಆರಂಭದಲ್ಲಿ ಅಲ್ಲ,
ಆದರೂ, ನಾವು ಅದೇ JPG ಕಡತ ಇರಿಸಿಕೊಳ್ಳಲು ಮಾಡುತ್ತೇವೆ

133
00:08:03,340 --> 00:08:05,910
ತೆರೆಯಲು ಮತ್ತು ಒಳಗೆ ಬರೆಯಲು.

134
00:08:05,910 --> 00:08:10,100
ನಾವು ಯಾವುದೇ ಒಳಗೆ ನಮ್ಮ ಬಫರ್ ಬರೆಯಲು ಮಾಡುತ್ತೇವೆ
ನಾವು ತೆರೆದಿರುವ JPG ಕಡತ, ಒದಗಿಸಿದ

135
00:08:10,100 --> 00:08:12,120
ನಾವು ಸಹಜವಾಗಿ, ಒಂದು ಮುಕ್ತ ಹೊಂದಿವೆ.

136
00:08:12,120 --> 00:08:16,190
ನಾವು ನಮ್ಮ ಮೊದಲ JPG ಕಂಡುಬಂದಿಲ್ಲ ವೇಳೆ
ಇನ್ನೂ, ನಾವು ಏನು ಬರೆಯಬೇಡಿ.

137
00:08:16,190 --> 00:08:20,290
ಈ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ನೀವು ಮುಂದುವರಿಯುತ್ತವೆ
ಕಾರ್ಡ್ ಕಡತದ ಕೊನೆಯಲ್ಲಿ ತಲುಪಲು.

138
00:08:20,290 --> 00:08:23,410
>> ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನೀವು ಮಾಡಲು ಬಯಸುವಿರಿ
ನೀವು ಯಾವುದೇ fclose ಖಚಿತವಾಗಿ

139
00:08:23,410 --> 00:08:25,800
ನೀವು fopened ಎಂಬುದನ್ನು ಕಡತಗಳನ್ನು.

140
00:08:25,800 --> 00:08:28,360
ನೀವು ತೃಪ್ತಿ ನೀವು ಒಮ್ಮೆ
ಪರಿಕಲ್ಪನೆಗಳು, ಕೆಲವು ನೋಡೋಣ

141
00:08:28,360 --> 00:08:30,840
ನಾನು ಇಲ್ಲಿ ಒಳಗೊಂಡಿತ್ತು ಮಾಡಿದ ಇದು ಸೂಡೊಕೋಡ್ಗಳನ್ನು,.

142
00:08:30,840 --> 00:08:34,830
ಮೊದಲ, ನೀವು ಕಾರ್ಡ್ ಕಡತವನ್ನು ತೆರೆಯಲು ಬಯಸುವ,
ತದನಂತರ ಕೆಳಗಿನ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪುನರಾವರ್ತಿಸುವಂತೆ

143
00:08:34,830 --> 00:08:37,144
ನೀವು ತಲುಪಿದ್ದೀರಿ ರವರೆಗೆ
ಕಾರ್ಡ್ ಕೊನೆಯಲ್ಲಿ.

144
00:08:37,144 --> 00:08:40,880
ನೀವು 512 ಬೈಟ್ಗಳು ಓದಲು ಬಯಸುವ
ಒಂದು ಬಫರ್ ಒಳಗೆ.

145
00:08:40,880 --> 00:08:43,934
ಎಂದು ಬಫರ್ ಬಳಸಿಕೊಂಡು, ನೀವು ಪರಿಶೀಲಿಸಿ ಬಯಸುವಿರಿ
ನೀವು ಆರಂಭದಲ್ಲಿ ಎಂಬುದನ್ನು

146
00:08:43,934 --> 00:08:45,300
ಹೊಸ JPG ಅಥವಾ ಅಲ್ಲ.

147
00:08:45,300 --> 00:08:48,400
ಮತ್ತು ಆ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರ ತಿನ್ನುವೆ
ನಿಮ್ಮ ಕಡತ ನಿರ್ವಹಣೆ ಪರಿಣಾಮ -

148
00:08:48,400 --> 00:08:51,940
ಇದು ನೀವು ಫೈಲ್ಗಳನ್ನು ತೆರೆಯಿರಿ, ಇದು
ಪದಗಳಿಗಿಂತ ನೀವು ಮುಚ್ಚಿ ಇಲ್ಲ.

149
00:08:51,940 --> 00:08:55,220
>> ನಂತರ, ನೀವು ಈಗಾಗಲೇ ಒಂದು JPG ಕಂಡು?

150
00:08:55,220 --> 00:08:57,740
ನೀವು ಹೇಗೆ ಕೀಪಿಂಗ್ ಮಾಡಲಾಗಿದೆ
ಎಂದು ಜಾಡನ್ನು?

151
00:08:57,740 --> 00:09:01,735
ನಂತರ, ಆ ಅವಲಂಬಿಸಿ, ನೀವು ಎರಡೂ ಮಾಡುತ್ತೇವೆ
ಪ್ರಸ್ತುತ JPG ಒಳಗೆ ಬರೆಯಲು ನೀವು

152
00:09:01,735 --> 00:09:07,090
ಎಲ್ಲಾ ಇದನ್ನು ಬರೆಯಲು ಮುಕ್ತ, ಅಥವಾ ಹೊಂದಿದ್ದರೆ,
ನೀವು ಇನ್ನೂ ಒಂದು JPG ಕಂಡುಬಂದಿಲ್ಲ ಏಕೆಂದರೆ.

153
00:09:07,090 --> 00:09:10,870
ಅಂತಿಮವಾಗಿ, ಒಮ್ಮೆ ನೀವು ಕೊನೆಯಲ್ಲಿ ತಲುಪಿದ್ದೀರಿ
ಕಡತ, ನೀವು ಯಾವುದೇ ಮುಚ್ಚಿ ಬಯಸುವಿರಿ

154
00:09:10,870 --> 00:09:12,590
ನೀವು ತೆರೆದಿರುವ ಕಡತಗಳನ್ನು ಉಳಿದ.

155
00:09:12,590 --> 00:09:14,590
ನಾವು ಇಲ್ಲಿ ಅಚ್ಚುಕಟ್ಟಾದ ಬಯಸುತ್ತೇನೆ.

156
00:09:14,590 --> 00:09:18,790
>> ಮತ್ತು, ನೀವು ಎಲ್ಲಾ ಚೇತರಿಸಿಕೊಂಡ ಬಂದಿದೆ
ಮೆಮೊರಿ ಕಾಣೆಯಾಗಿದೆ ಕಡತಗಳನ್ನು

157
00:09:18,790 --> 00:09:21,620
ಸಾಕಷ್ಟು ಅದ್ಭುತ ಸಾಧನೆಯನ್ನು ಇದು ಕಾರ್ಡ್,.

158
00:09:21,620 --> 00:09:23,430
ಆದ್ದರಿಂದ ಹಿಂದೆ ನೀವೇ ಪ್ಯಾಟ್.

159
00:09:23,430 --> 00:09:27,560
ಆದರೆ, ಒಂದು ಹೆಚ್ಚಿನ ಅಂಶ ಇಲ್ಲ
ಸ್ಪರ್ಧೆಯಲ್ಲಿ ಇದು pset,.

160
00:09:27,560 --> 00:09:30,920
ನೀವು ಕಾಣುವಿರಿ ಚಿತ್ರಗಳನ್ನು ಎಲ್ಲಾ
ನೀವು ಚೇತರಿಸಿಕೊಂಡರು ನೀವು ವಾಸ್ತವವಾಗಿ

161
00:09:30,920 --> 00:09:32,820
CS50 ನ ಸಿಬ್ಬಂದಿ ಚಿತ್ರಗಳನ್ನು.

162
00:09:32,820 --> 00:09:38,500
ಆದ್ದರಿಂದ ನೀವು ಆವರಣದಲ್ಲಿ ಅಥವಾ ಎಲ್ಲೋ ಇಂತಹ
ಬಳಿ, ನಂತರ ನೀವು ಚಿತ್ರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು

163
00:09:38,500 --> 00:09:42,600
ಸಿಬ್ಬಂದಿ, ಮತ್ತು ಹೊಂದಿದೆ ಎಂದು ವಿಭಾಗ
ಸಿಬ್ಬಂದಿ ಹೆಚ್ಚಿನ ಚಿತ್ರಗಳನ್ನು

164
00:09:42,600 --> 00:09:46,940
ತಮ್ಮ ಚೇತರಿಸಿಕೊಂಡ ಕಡತಗಳನ್ನು ತಿನ್ನುವೆ
ಒಂದು ಅಸಾಮಾನ್ಯವಾದ ಬಹುಮಾನ.

165
00:09:46,940 --> 00:09:50,650
ಎಂದು, ನಂತರ ನೀವು ಮುಕ್ತಾಯಗೊಂಡ
ಚೇತರಿಸಿಕೊಳ್ಳಲು pset.

166
00:09:50,650 --> 00:09:53,600
ನನ್ನ ಹೆಸರು Zamyla ಹೊಂದಿದೆ, ಮತ್ತು ಈ CS50 ಹೊಂದಿದೆ.

167
00:09:53,600 --> 00:10:01,835