1
00:00:00,000 --> 00:00:00,494

2
00:00:00,494 --> 00:00:13,350
>> [ಸಂಗೀತ]

3
00:00:13,350 --> 00:00:14,080
>> ರಾಬ್ ಬೌಡೆನ್: ಹಾಯ್.

4
00:00:14,080 --> 00:00:17,550
ನಾನು ರಾಬ್ ಮನುಷ್ಯ, ಮತ್ತು ನ ಭಾವಿಸುತ್ತೇವೆ ಎಂದು
ಈ ಪರಿಹಾರ ನೀವು ಪುಟ್ ಸಹಾಯ

5
00:00:17,550 --> 00:00:19,600
ಚೇತರಿಕೆಯ ಹಾದಿ.

6
00:00:19,600 --> 00:00:22,700
ಆದ್ದರಿಂದ ಅವರ ಪ್ರಾರಂಭಿಸಲು ಅವಕಾಶ.

7
00:00:22,700 --> 00:00:25,660
>> ನಾವು ತಕ್ಷಣ ನಾವು ಎಂಬುದನ್ನು ನೋಡಿ
ಕೇವಲ ನಾವು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ

8
00:00:25,660 --> 00:00:27,170
ಸರಿಯಾಗಿ ಕೊಡು ಉಪಯೋಗಿಸುವಾಗ.

9
00:00:27,170 --> 00:00:31,490
ಆದ್ದರಿಂದ ಬಳಕೆ ಏನೋ ಇರಬೇಕು
ಡಾಟ್ ಕತ್ತರಿಸಿ ಚೇತರಿಸಿಕೊಳ್ಳಲು ಹಾಗೆ.

10
00:00:31,490 --> 00:00:35,500
>> ಈಗ ನಾವು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ ತೆರೆಯಲು ನೀನು
ಕಾರ್ಡ್ ಕಚ್ಚಾ ಕಡತ ಡಾಟ್.

11
00:00:35,500 --> 00:00:39,740
ನಾವು ಬಳಸುತ್ತಿರುವ ಎಂದು ಇಲ್ಲಿ ನೋಡಿ
ನಿರಂತರ ಕಚ್ಚಾ ಅಂಡರ್ಸ್ಕೋರ್ ಫೈಲ್ ಹೆಸರು,

12
00:00:39,740 --> 00:00:44,200
ನಾವು ಹ್ಯಾಶ್ ಹೊಂದಿವೆ ಇಲ್ಲಿ ಇದು
ಕಾರ್ಡ್ ಕಚ್ಚಾ ಡಾಟ್ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ.

13
00:00:44,200 --> 00:00:45,030
ಸರಿ.

14
00:00:45,030 --> 00:00:48,210
>> ನಾವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಅಗತ್ಯವಿರುವ
ಯಶಸ್ವಿಯಾಗಿ ಆರಂಭವಾಯಿತು ಏಕೆಂದರೆ

15
00:00:48,210 --> 00:00:51,150
ಆಗ ಬಳಕೆದಾರ ಎಚ್ಚರಿಕೆ ಬೇಕು ಮಾಡಲಿಲ್ಲ.

16
00:00:51,150 --> 00:00:56,770
ಆದರೆ ಅದನ್ನು ಮಾಡಿದರು ಎಂದು ಊಹಿಸಿಕೊಂಡು, ನಾವು ಈಗ
ಗಾತ್ರ, JPEG ಒಂದು ಬಫರ್ ಘೋಷಿಸಲು ವಿಶೇಷವೇನು

17
00:00:56,770 --> 00:00:58,170
ಹೆಸರು ಉದ್ದ ಫೈಲ್.

18
00:00:58,170 --> 00:01:02,060
ಆದ್ದರಿಂದ ಈ ಬಫರ್ ಏರಲಿದೆ ಎಂದು
ನಾವು ಒಳಗೆ sprintf ನೀನು.

19
00:01:02,060 --> 00:01:04,360
>> ಆದ್ದರಿಂದ JPEG ಫೈಲ್ ಹೆಸರು ಉದ್ದ ಏನು?

20
00:01:04,360 --> 00:01:08,490
ಇಲ್ಲಿ, ನಾವು ಎಂದು ನೋಡಿ
ಎಂಟು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಹ್ಯಾಶ್.

21
00:01:08,490 --> 00:01:10,670
ಆದ್ದರಿಂದ ಎಂಟು?

22
00:01:10,670 --> 00:01:15,150
ಅಲ್ಲದೆ ಒಂದು ನಿರ್ದಿಷ್ಟ ಕಡತ ಹೆಸರಿನ
ಶೂನ್ಯ ಶೂನ್ಯ ಶೂನ್ಯ ರೀತಿಯ.

23
00:01:15,150 --> 00:01:19,460
JPG ಮತ್ತು ನಂತರ ನಾವು ಒಂದು backslash ಶೂನ್ಯ ಅಗತ್ಯವಿದೆ.

24
00:01:19,460 --> 00:01:22,720
ಆದ್ದರಿಂದ ನಾವು ಮಾಡಬಹುದು ಒಂದು ಬಫರ್ ಅಗತ್ಯವಿದೆ
ಎಂಟು ಅಕ್ಷರಗಳು ಶೇಖರಿಸಿಡಲು.

25
00:01:22,720 --> 00:01:25,190
ಈಗ ನಾವು ಒಂದು ಕೌಂಟರ್ ಮಾಡಲಿಕ್ಕೆ
ಟ್ರ್ಯಾಕ್ ಹೋಗುವ

26
00:01:25,190 --> 00:01:27,780
ಸಂಖ್ಯೆ JPEGs, ನಾವು ಕಂಡುಬಂದಿಲ್ಲ.

27
00:01:27,780 --> 00:01:31,590
>> ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾವು ಹೊಂದಿರುವ ನೀನು ಒಂದು
ಆರಂಭದಲ್ಲಿ ಶೂನ್ಯ ಇದು JPEG ಫೈಲ್

28
00:01:31,590 --> 00:01:35,920
ಪ್ರಸ್ತುತ ಏರಲಿದೆ ಇದು
ನಾವು ಬರೆಯುತ್ತಿದ್ದೇವೆ ಎಂದು ತೆರೆದ ಕಡತ.

29
00:01:35,920 --> 00:01:37,540
ಈಗ ನಾವು ನೀನು
ಹೆಚ್ಚುವರಿ ಬಫರ್.

30
00:01:37,540 --> 00:01:41,350
ಈ ನಮ್ಮ sprintf ಅದೇ ಅಲ್ಲ
ಈ ಬಫರ್ ಒಂದು ಅಲ್ಲಿ ಬಫರ್

31
00:01:41,350 --> 00:01:45,020
ನಾವು ಡೇಟಾವನ್ನು ಓದುವ ನೀವು
ಕಾರ್ಡ್ ಕಚ್ಚಾ ಡಾಟ್ ನಿಂದ.

32
00:01:45,020 --> 00:01:48,900
>> ಆದ್ದರಿಂದ ಬಫರ್ ಏರಲಿದೆ
ರುಜುಮಾಡದ ಅಕ್ಷರಗಳು, ನೀವು ಇದರಲ್ಲಿ

33
00:01:48,900 --> 00:01:53,560
ಮೂಲತಃ ಕೇವಲ ನಮಗೆ ಬೈಟ್ಗಳು ಚಿಕಿತ್ಸೆ, ಮತ್ತು ಇದು
ಗಾತ್ರ ಬ್ಲಾಕ್ ಗಾತ್ರದ ಏರಲಿದೆ

34
00:01:53,560 --> 00:01:57,950
ಅಲ್ಲಿ, ನಾವು ನೀವು ಹೇಳಲು,
ಖಂಡ ಗಾತ್ರ 512 ಆಗಿದೆ.

35
00:01:57,950 --> 00:02:03,070
ಆದ್ದರಿಂದ JPEGs, ನೀವು ಎಲ್ಲವನ್ನೂ ಚಿಕಿತ್ಸೆ
512 ಬೈಟ್ಗಳು ಬ್ಲಾಕ್ಗಳಾಗಿ.

36
00:02:03,070 --> 00:02:05,890
>> ಈಗ ನಾವು ಲೂಪ್ ನೀನು
ಸಂಪೂರ್ಣ ಫೈಲ್ ಮೇಲೆ.

37
00:02:05,890 --> 00:02:12,980
ನಾವು ಎಫ್ ನಮ್ಮ ಬಫರ್ ಒಳಗೆ ಓದಲು ನೀನು
ಒಂದು ಬೈಟ್ ಬ್ಲಾಕ್ ಗಾತ್ರ ಕಾಲದಿಂದಲೂ

38
00:02:12,980 --> 00:02:14,710
ಕಾರ್ಡ್ ಕಚ್ಚಾ ಕಡತ ಡಾಟ್.

39
00:02:14,710 --> 00:02:16,630
ಈಗ F ಮರಳಲು ಏನು ಓದಲು ಇಲ್ಲ?

40
00:02:16,630 --> 00:02:20,050
ಇದು ಐಟಂಗಳನ್ನು ಸಂಖ್ಯೆ ಹಿಂದಿರುಗಿಸುತ್ತದೆ
ಇದು ಯಶಸ್ವಿಯಾಗಿ ಓದಲು.

41
00:02:20,050 --> 00:02:27,310
ಇದು ನಂತರ, 512 ಬೈಟ್ಗಳು ಓದಲು ನಿರ್ವಹಿಸುತ್ತಿದ್ದ ವೇಳೆ
ನಾವು ಈ ಒಂದು ಎಂದು ನೋಡಲು ಬಯಸುವ

42
00:02:27,310 --> 00:02:29,700
JPEG ಅಥವಾ ಇದು ಒಂದು JPEG ಕಡತವನ್ನು ಬರೆಯಲು.

43
00:02:29,700 --> 00:02:34,450
ಮತ್ತು ಇದು 512 ಬೈಟ್ಗಳು ಹಿಂತಿರುಗಿಸಿಲ್ಲ ವೇಳೆ,
ನಂತರ ಕಡತ ಎರಡೂ ಕೊನೆಗೊಂಡಿದೆ

44
00:02:34,450 --> 00:02:37,870
ನಾವು ವೈ ಭೇದಿಸಿ ಮಾಡುತ್ತೇವೆ ಸಂದರ್ಭದಲ್ಲಿ
ಲೂಪ್, ಅಥವಾ ದೋಷ ಕೆಲವು ರೀತಿಯ ಇವೆ

45
00:02:37,870 --> 00:02:40,300
ನಾವು ಔಟ್ ಮುರಿಯಲು ಮಾಡುತ್ತೇವೆ ಸಂದರ್ಭದಲ್ಲಿ
ವೈ ಲೂಪ್, ಆದರೆ ನಾವು ವರದಿ ಬಯಸುವಿರಿ

46
00:02:40,300 --> 00:02:41,990
ಎಂದು ಏನೋ ತಪ್ಪಾಗಿದೆ.

47
00:02:41,990 --> 00:02:42,290
>> ಸರಿ.

48
00:02:42,290 --> 00:02:47,630
ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಓದುವ ಊಹಿಸಿಕೊಂಡು
512 ಬೈಟ್ಗಳು, ನಾವು ಮೊದಲ ಚೆಕ್ ಬಯಸುವ

49
00:02:47,630 --> 00:02:53,070
ಮಾಡಲು ಈ ಬೈಟ್ಗಳು ನಾವು
ಕೇವಲ ಓದಲು ಒಂದು JPEG ಆರಂಭಿಸಲು.

50
00:02:53,070 --> 00:02:56,430
ಆದ್ದರಿಂದ ನಮ್ಮ ಬಫರ್, JPEG ಹೆಡರ್.

51
00:02:56,430 --> 00:02:58,460
ಈಗ, JPEG ಹೆಡರ್ ಇದು ಏನು?

52
00:02:58,460 --> 00:03:00,120
ನೋಡೋಣ.

53
00:03:00,120 --> 00:03:05,270
>> ಇಲ್ಲಿ, ನಾವು ಈ ಕಾರ್ಯವನ್ನು ನೋಡಿ
ಬುಲ್ ಹಿಂದಿರುಗಿದ, ಮತ್ತು ಬುಲ್ -

54
00:03:05,270 --> 00:03:08,820
ಇಲ್ಲಿ, ನಾವು ನೋಡಲು ತಪಾಸಣೆ ಬಳಸುತ್ತಿದ್ದರೆ
ಹೆಡರ್ ಶೂನ್ಯ ಈ ನಿರಂತರ ಸಮನಾಗಿರುತ್ತದೆ ಮತ್ತು

55
00:03:08,820 --> 00:03:11,880
ಹೆಡರ್ ಒಂದು ಈ ನಿರಂತರ ಸಮನಾಗಿರುತ್ತದೆ ಮತ್ತು
ಹೆಡರ್ ಎರಡು, ಈ ನಿರಂತರ ಸಮನಾಗಿರುತ್ತದೆ

56
00:03:11,880 --> 00:03:15,640
ಹೆಡರ್ ಮೂರು ಈ ಅಥವಾ ಈ ಸಮನಾಗಿರುತ್ತದೆ
ಈ ಎಲ್ಲಾ ಸ್ಥಿರ ಅಲ್ಲಿ ನಿರಂತರ

57
00:03:15,640 --> 00:03:20,340
ಕೇವಲ ಇಲ್ಲಿಯೇ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಹ್ಯಾಶ್ ಮತ್ತು
ನಾವು ವಿಶೇಷ ನೀವು ಹೇಳಿದ ನಿಖರವಾಗಿ

58
00:03:20,340 --> 00:03:22,700
ಒಂದು JPEG ಆರಂಭವಾಗುತ್ತದೆ.

59
00:03:22,700 --> 00:03:27,300
ಆದ್ದರಿಂದ ಈ ಕಾರ್ಯ ಕೇವಲ ಹೋಗುತ್ತದೆ
ಈ ಬಫರ್ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ನಿಜವಾದ ಹಿಂತಿರುಗಿ

60
00:03:27,300 --> 00:03:31,750
ಒಂದು ಹೊಸ JPEG ಆರಂಭದಲ್ಲಿ
ಮತ್ತು ತಪ್ಪು ಇಲ್ಲದಿದ್ದರೆ.

61
00:03:31,750 --> 00:03:32,520
>> ಸರಿ.

62
00:03:32,520 --> 00:03:38,490
ಈ ಹೊಸ JPEG ನೀಡಬಲ್ಲದು ಹಾಗಾಗಿ,
ನಂತರ ನಾವು ಮೊದಲ ಪರೀಕ್ಷಿಸಿ ಬಯಸಿದರೆ

63
00:03:38,490 --> 00:03:42,030
JPEG ಫೈಲ್ ಶೂನ್ಯ ಸಮಾನವಾಗಿರುವುದಿಲ್ಲ
ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಅದನ್ನು ಮುಚ್ಚಿ.

64
00:03:42,030 --> 00:03:44,940
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಪರಿಶೀಲಿಸಿ ಬೇಕು
ಇದು ಶೂನ್ಯ ಅಲ್ಲ ನೋಡಿ? ಗೆ

65
00:03:44,940 --> 00:03:48,980
ಚೆನ್ನಾಗಿ ಕಂಡುಕೊಂಡ JPEG ನಾವು
ನಾವು ಈಗಾಗಲೇ ಬೀರುವುದಿಲ್ಲ ಹೇಗೆ

66
00:03:48,980 --> 00:03:50,440
ಮುಕ್ತ JPEG ಫೈಲ್.

67
00:03:50,440 --> 00:03:55,580
ಆದ್ದರಿಂದ, ನಾವು ನಂತರ, ಆ ಮುಚ್ಚಲು ಪ್ರಯತ್ನಿಸಿದರೆ
ನಾವು ಸಾಕಷ್ಟು ಬಲ ಏನೋ ಏನು ಇಲ್ಲ.

68
00:03:55,580 --> 00:03:59,090
>> ಆದರೆ ಪ್ರತಿ ನಂತರದ, JPEG ಎಂದು
ನಾವು ತೆರೆಯಲು, ನಾವು ಮುಚ್ಚಲು ಬಯಸುವ

69
00:03:59,090 --> 00:04:00,710
ಹಿಂದಿನ ಕಡತ.

70
00:04:00,710 --> 00:04:04,630
ಈಗ ನಾವು ಎಂದು sprintf ಬಳಸಲು ನೀನು
ನಾವು ಬಳಸುತ್ತಿರುವ ಅಲ್ಲಿ ಮೊದಲು ಹೇಳಿದರು

71
00:04:04,630 --> 00:04:06,280
ಬಫರ್ JPEG ಫೈಲ್ ಹೆಸರು.

72
00:04:06,280 --> 00:04:09,870
ನಾವು JPEG ಫೈಲ್ ಬಳಸಲು ನೀನು
ನಮ್ಮ ಸ್ವರೂಪವಾಗಿ ರೂಪದಲ್ಲಿ ಹೆಸರಿಸಲು.

73
00:04:09,870 --> 00:04:12,030
ಮತ್ತು ಏನು?

74
00:04:12,030 --> 00:04:18,450
ಇಲ್ಲಿ, ನಾವು ಶೇಕಡಾ ಶೂನ್ಯ ಎಂದು ನೋಡಿ
3D.JPEG ಅಲ್ಲಿ ಶೂನ್ಯ ಮೂರು ಕೇವಲ

75
00:04:18,450 --> 00:04:22,089
ನಾವು ಮೂರು ಪೂರ್ಣಾಂಕಗಳ ಬಳಸಿ ಎಂದು ಹೇಳುತ್ತಾರೆ
ಈ ಸೊನ್ನೆಗಳೊಂದಿಗೆ ಪೂರ್ವಪ್ರತ್ಯಯ.

76
00:04:22,089 --> 00:04:27,470
ಈ ನಾವು ಶೂನ್ಯ ಶೂನ್ಯ ಪಡೆಯುತ್ತೀರಿ ಹೇಗೆ
ಹೀಗೆ one.JPEG ಮತ್ತು ಶೂನ್ಯ 10.JPEG ಮತ್ತು.

77
00:04:27,470 --> 00:04:29,060
>> ನಾವು sprintf ಬಳಸಲು ನೀನು.

78
00:04:29,060 --> 00:04:33,760
ನಾವು ತೂರಿಸುವ ಪೂರ್ಣಾಂಕ
ಸ್ಟ್ರಿಂಗ್ ನಿಶ್ಚೇಷ್ಟಿತ JPEGs ಆಗಿದೆ ಒಳಗೆ

79
00:04:33,760 --> 00:04:36,380
ಮೂಲತಃ ಶೂನ್ಯ ಇದು ಚೇತರಿಸಿಕೊಂಡ.

80
00:04:36,380 --> 00:04:39,950
ಆದ್ದರಿಂದ ಮೊದಲ ಕಡತ ಹೋಗುತ್ತದೆ ತೆರೆಯಿತು
ಶೂನ್ಯ ಶೂನ್ಯ ಶೂನ್ಯ ಡಾಟ್, JPEG ಎಂದು.

81
00:04:39,950 --> 00:04:43,330
ನಂತರ ನಾವು ಆದ್ದರಿಂದ ಏರಿಕೆಯ ಮಾಡುತ್ತಿದ್ದೇವೆ
ನಾವು ತೆರೆಯಲು ಮುಂದಿನ ಕಡತ ಶೂನ್ಯ ಶೂನ್ಯ ಇರುತ್ತದೆ

82
00:04:43,330 --> 00:04:46,830
ಒಂದು ಡಾಟ್ JPEG ಮತ್ತು ನಾವು ಇದನ್ನು ಹೆಚ್ಚಿಸಲು ಮಾಡುತ್ತೇವೆ
ಮತ್ತೆ ಆದ್ದರಿಂದ ಶೂನ್ಯ ಶೂನ್ಯ ಎರಡು ಡಾಟ್ ಮಾಡುತ್ತೇವೆ

83
00:04:46,830 --> 00:04:49,100
ಹೀಗೆ JPEG ಮತ್ತು.

84
00:04:49,100 --> 00:04:49,850
>> ಸರಿ.

85
00:04:49,850 --> 00:04:53,210
ಈಗ JPEG ಫೈಲ್ ಒಳಗೆ
ಹೆಸರಿಸಲು, ನಾವು ಹೆಸರನ್ನು ಹೊಂದಿವೆ

86
00:04:53,210 --> 00:04:54,990
ನಾವು ಬಯಸುವ ಕಡತ.

87
00:04:54,990 --> 00:04:58,640
ನಾವು ಎಫ್ ಬರವಣಿಗೆಗೆ ಆ ಕಡತವನ್ನು ತೆರೆಯಲು.

88
00:04:58,640 --> 00:04:59,170
ಸರಿ.

89
00:04:59,170 --> 00:05:02,820
ಮತ್ತೊಮ್ಮೆ, ನಾವು ಮಾಡಲು ಪರಿಶೀಲಿಸಬೇಕು
ಖಚಿತವಾಗಿ ಯಶಸ್ವಿಯಾಗಿ ಕಡತ

90
00:05:02,820 --> 00:05:08,460
ಇದು, ನಂತರ ಮಾಡಿದರೆ ರಿಂದ ತೆರೆಯಿತು
ಕೆಲವು ದೋಷವಿತ್ತು.

91
00:05:08,460 --> 00:05:13,100
>> ಈಗ ನಾವು ಕಳೆದ ನೆತ್ತಿಗೇರಿದೆ
ಈ ಒಂದು JPEG ಭಾಗವಾಗಿದೆ.

92
00:05:13,100 --> 00:05:16,390
ಮತ್ತು ಇಲ್ಲಿ, ನಾವು ನೀನು ನೋಡಿ
JPEG ಬರೆಯಲು.

93
00:05:16,390 --> 00:05:20,980
ಆದರೆ ನಾವು ಮೊದಲ ಹೇಳುತ್ತದೆ ಈ ಚೆಕ್ ಹೊಂದಿವೆ
JPEG ಫೈಲ್ ಸಮಾನ ಶೂನ್ಯ ಇದ್ದರೆ.

94
00:05:20,980 --> 00:05:22,490
ಏಕೆ ನಾವು ಬೇಕು?

95
00:05:22,490 --> 00:05:28,020
ಅಲ್ಲದೆ JPEG ಫೈಲ್ ಶೂನ್ಯ ಸಮನಾಗಿರುತ್ತದೆ ನಾವು
ಪ್ರಸ್ತುತ ಮುಕ್ತ, JPEG ಹೊಂದಿವೆ.

96
00:05:28,020 --> 00:05:31,870
>> ಏನು ಕಾರ್ಡ್ ಡಾಟ್ ಕಚ್ಚಾ ಆರಂಭಿಸಿದಲ್ಲಿ
ಬೈಟ್ಗಳು ಒಂದು ಗುಂಪೇ ಎಂದು

97
00:05:31,870 --> 00:05:33,510
ಒಂದು JPEG ಪ್ರತಿನಿಧಿಸುವುದಿಲ್ಲ?

98
00:05:33,510 --> 00:05:36,240
ನಂತರ ನಾವು ಬಯಸುವ ನೀನು
ಬೈಟ್ಗಳು ತೆರಳಿ.

99
00:05:36,240 --> 00:05:39,600
ನಾವು ಈ ಚೆಕ್ ಇಲ್ಲ ವೇಳೆ, ನಾವು ಕೋರುತ್ತೇವೆ
ಒಂದು ತೆರೆಯದ ಬರೆಯಲು ಹೋಗುವ

100
00:05:39,600 --> 00:05:45,540
ಮೊದಲ 512 ಬೈಟ್ಗಳು ಫೈಲ್
ಉತ್ತಮ ಇದು ಕಾರ್ಡ್.

101
00:05:45,540 --> 00:05:46,030
ಸರಿ.

102
00:05:46,030 --> 00:05:51,330
>> ಆದ್ದರಿಂದ, ನಾವು ಒಂದು ತೆರೆದ ಕಡತ ಭಾವಿಸಿಕೊಂಡು
ನಾವು ಕಡತವನ್ನು ಬರೆಯಲು ನೀನು

103
00:05:51,330 --> 00:05:53,290
ನಾವು ನಮ್ಮ ಬಫರ್ ಎಂದು 512 ಬೈಟ್ಗಳು.

104
00:05:53,290 --> 00:05:57,390
ನಾವು ಮತ್ತೊಮ್ಮೆ ಮಾಡಲು ತಪಾಸಣೆ ಮಾಡುತ್ತಿರುವ
ಖಚಿತವಾಗಿ ಯಶಸ್ವಿಯಾಗಿ 512 ಬೈಟ್ಗಳು

105
00:05:57,390 --> 00:06:01,140
ಅವರು ಇಲ್ಲದಿದ್ದರೆ ಏಕೆಂದರೆ ಬರೆಯಲಾಯಿತು
ಯಶಸ್ವಿಯಾಗಿ ಬರೆದ, ನಂತರ ಏನೋ

106
00:06:01,140 --> 00:06:02,080
ತಪ್ಪಾಗಿದೆ.

107
00:06:02,080 --> 00:06:06,540
ನಾವು ಮುದ್ರಿಸಲು ನಮ್ಮ ಕಡತಗಳನ್ನು ಮುಚ್ಚಿ ಮಾಡುತ್ತೇವೆ
ಏನೋ ತಪ್ಪಾಗಿದೆ, ಮತ್ತು ರಿಟರ್ನ್.

108
00:06:06,540 --> 00:06:10,940
ಭಾವಿಸಿಕೊಂಡು ಎಲ್ಲವೂ ನಂತರ, ಸರಿಯಾಗಿ ಹೋಗುತ್ತದೆ
ನಾವು ಮುಚ್ಚುವ ಲೂಪಿಂಗ್ ಇರಿಸಿಕೊಳ್ಳಲು ಮಾಡುತ್ತೇವೆ

109
00:06:10,940 --> 00:06:15,060
ಹಳೆಯ ಕಡತ, ಹೊಸ ಕಡತವನ್ನು ತೆರೆಯುವ, ಬರವಣಿಗೆ
ಆದ್ದರಿಂದ ಹೊಸ ಕಡತ ದತ್ತಾಂಶವನ್ನು ಮತ್ತು

110
00:06:15,060 --> 00:06:20,990
ಅಂತಿಮವಾಗಿ, ಈ F ಓದಲು ರವರೆಗೆ
ಶೂನ್ಯ ಮರಳುತ್ತದೆ ಸಾಧನವಾಗಿ

111
00:06:20,990 --> 00:06:23,280
ಕಡತ ಮಾಡಲಾಗುತ್ತದೆ ಎಂದು.

112
00:06:23,280 --> 00:06:28,490
>> ಈಗ ಕಾರ್ಡ್ ಓದುವ ಮೇಲೆ ಎಂದು, ನಾವು
ನಾವು ಎಫ್ ಮುಚ್ಚಿ ನೀನು ನೋಡಿ

113
00:06:28,490 --> 00:06:33,250
ನಾವು ಮುಕ್ತ ಹೊಂದಿತ್ತು, ಆದರೆ ಕಳೆದ ಫೈಲ್
ನಾವು ತಪಾಸಣೆ ಮಾಡುತ್ತಿರುವ ವೇಳೆ JPEG ಫೈಲ್

114
00:06:33,250 --> 00:06:34,900
ಸಮಾನ ಶೂನ್ಯ ಮಾಡುತ್ತದೆ.

115
00:06:34,900 --> 00:06:39,520
ಅಲ್ಲದೆ F ಹತ್ತಿರ ಏಕೆಂದರೆ ಅರ್ಥವಿಲ್ಲ
ನಾವು ಮುಚ್ಚಲು ನೀವು, ಕಡತಗಳನ್ನು ತೆರೆಯುವ ನೀವು

116
00:06:39,520 --> 00:06:43,870
ಹಿಂದಿನ ಕಡತ, ಆದರೆ ಅತ್ಯಂತ ಕೊನೆಯ
ನಾವು ತೆರೆಯಲ್ಪಟ್ಟ ಕಡತ ಮುಚ್ಚಲಾಗಿದೆ ಪಡೆಯುತ್ತದೆ ಎಂದಿಗೂ.

117
00:06:43,870 --> 00:06:45,580
ಆದ್ದರಿಂದ ಈ ಮಾಡುತ್ತಿರುವ ಇಲ್ಲಿದೆ.

118
00:06:45,580 --> 00:06:47,720
>> ಆದರೆ ಏಕೆ ಶೂನ್ಯ ಪರಿಶೀಲಿಸಲು ಅಗತ್ಯವಿದೆ?

119
00:06:47,720 --> 00:06:53,130
ಜೊತೆಗೆ ಯಾವ ವೇಳೆ ಕಾರ್ಡ್ ಡಾಟ್ ಕಚ್ಚಾ ಮಾಡಲಿಲ್ಲ
ಒಳಗೆ ಒಂದು JPEG ಹೊಂದಿವೆ?

120
00:06:53,130 --> 00:06:56,640
ಆ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಎಂದು
ಒಂದು ಕಡತ ತೆರೆಯಿತು ಎಂದಿಗೂ.

121
00:06:56,640 --> 00:07:00,230
ನಾವು ಒಂದು ಕಡತವನ್ನು ತೆರೆಯಲು ಎಂದಿಗೂ ವೇಳೆ, ನಾವು ಮಾಡಬೇಕಾದುದು
ಫೈಲ್ ಮುಚ್ಚಲು ಪ್ರಯತ್ನಿಸಿ.

122
00:07:00,230 --> 00:07:03,000
ಆದ್ದರಿಂದ ಈ ಚೆಕ್ ಮಾಡುತ್ತಿರುವ ಇಲ್ಲಿದೆ.

123
00:07:03,000 --> 00:07:07,880
>> ನಾನು ಮೊದಲೇ ಹೇಳಿದಂತೆ ಈಗ ಇಲ್ಲಿ, ನಾವು ಸಾಧ್ಯವೋ
ವೈ ಲೂಪ್ಅನ್ನು ವೇಳೆ ಭುಗಿಲೆದ್ದರೆ

124
00:07:07,880 --> 00:07:13,520
ಕಾರ್ಡ್ ಇವೆ ಕೊನೆಗೊಂಡಿತು ಅಥವಾ ಬಂದಿದೆ
ಕಾರ್ಡ್ ಓದುವ ಕೆಲವು ದೋಷ.

125
00:07:13,520 --> 00:07:16,680
ಆದ್ದರಿಂದ ಈ ಇಲ್ಲದಿದ್ದರೆ ನೋಡಲು ತಪಾಸಣೆ ಇದೆ
ರಲ್ಲಿ, ಕಾರ್ಡ್ ಓದುವ ದೋಷ

126
00:07:16,680 --> 00:07:19,400
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಅಲ್ಲಿ ಹೇಳುತ್ತೇನೆ
ದೋಷ ಓದುವಿಕೆ.

127
00:07:19,400 --> 00:07:22,130
ನಾವು ಬಳಕೆದಾರ ಭಾವಿಸುತ್ತೇನೆ ಬಯಸುವುದಿಲ್ಲ
ಎಲ್ಲವೂ ಯಶಸ್ವಿಯಾಗಿ ಹೋದರು.

128
00:07:22,130 --> 00:07:24,750
ನಾವು ದೋಷ ಒಂದು ಬರುತ್ತೇವೆ.

129
00:07:24,750 --> 00:07:29,580
>> ಅಂತಿಮವಾಗಿ, ನಾವು ಎಫ್ ನಮ್ಮ ಕಚ್ಚಾ ಫೈಲ್ ಮುಚ್ಚಿ ಮಾಡುತ್ತೇವೆ,
ನಮ್ಮ ಕಾರ್ಡ್ ಸೂಚಿಸಲು, ಕಚ್ಚಾ ಡಾಟ್

130
00:07:29,580 --> 00:07:34,070
ಎಲ್ಲವೂ ಚೆನ್ನಾಗಿ ಮತ್ತು ರಿಟರ್ನ್ ಹೋದರು
ಝೀರೋ ಮತ್ತು ಅದು ಇಲ್ಲಿದೆ.

131
00:07:34,070 --> 00:07:36,130
>> ನನ್ನ ಹೆಸರನ್ನು ರಾಬ್ ಮತ್ತು ಈ ಕೊಡು ಆಗಿತ್ತು.

132
00:07:36,130 --> 00:07:42,102
>> [ಸಂಗೀತ]