樂橙a2x用硬碟存儲

1. 樂橙TP7-AD2C支持onvif協議嗎

可以的，支持ONVIF協議，可以接入第三方硬碟錄像機，支持SD卡、雲存儲、硬碟錄像機三種存儲方式，滿意請採納並點贊噢

2. 樂橙攝像頭怎麼格式化內存卡

方法如下：
1、將內存卡插入讀卡器內，並插上主機的USB插口，等會就會在出現可移動磁碟。
2、然後打開「我的電腦」或「計算機」就可以看到讀卡器的磁碟了——那就是內存卡，右鍵單擊那個磁碟在彈出的右鍵菜單中選「格式化」之後會彈出一個窗口，在其中勾選上「快速格式化」後點開始就可以了。
(2)樂橙a2x用硬碟存儲擴展閱讀：
儲存卡格式化：儲存卡格式化（FORMAT）是指對其初始化工作。格式化是電子產品對相配套存儲介質的一種空間分配，在分配的同時，也起到了數據保護功能。格式化之後，會佔用一定的空間，可以理解為是一個個格子所佔用的空間。
詳細介紹
儲存卡格式化就是對其初始化工作，同其他存儲器硬碟、磁碟一樣必須格式化才能使用。格式化就是為磁碟做初始化的工作，簡單說，就是把一張空白的盤劃分成一個個小區域並編號，供計算機儲存，讀取數據。格式化這一概念原只應用於電腦硬碟，隨著電子產品不斷發展，很多存儲器都用到了「格式化」這一名詞，狹義的理解，就等於數據清零，刪掉存儲器內的所有數據，並將存儲器恢復到初始狀態。
硬碟必須先經過分區才能使用，磁碟經過分區之後，下一個步驟就是要對硬碟進行高級格式化（FORMAT）的工作，硬碟都必須格式化才能使用。
對手機卡的格式化可以選擇在插入讀卡器，在電腦上格式化，也可以在插入手機里，用手機里的程序進行格式化。對於這兩種方法，一般選擇後者較好，因為可以保證格式化後的文件系統可以被手機正常識別。格式化之後，會佔用一定的空間，可以理解為是一個個格子所佔用的空間。例如1G的MP3隻有800多MB。
格式化是電子產品對相配套存儲介質的一種空間分配，在分配的同時，也起到了數據保護功能。格式化也有很多種形式，根據格式後每個空間的大小大致可以分為，低格，高格。低格後的儲存卡容量相對較大，但存儲速度較慢，高格後的存儲空間減少的多一些，速度快，同時安全性要高。

3. 2020-12-02 硬碟如何存儲文件

系統中所有內容是以文件（文件夾是特殊的文件）存在的，而文件分為屬性（元信息）和內容兩部分，磁碟一部分被操作系統虛擬為塊用來存儲數據，同時也分出一部分虛擬為Inode用來存儲文件屬性，這樣磁碟就分為塊區和inode區。

扇區：磁碟存儲數據的最小物理單元，每個扇區很小512位元組左右。
讀取數據：OS要想讀取磁碟數據，首先讓磁頭徑向尋道（最慢），然後旋轉磁碟（較快），使磁頭到達目標扇區，開始讀取數據。

磁碟塊：OS日常工作中，一個扇區的512位元組數據很小，不足以支撐絕大部分工作場景，所以需要頻繁讀取單個扇區，而磁碟讀取數據速度相對CPU處理太慢了，所以讀磁碟時一次就多拿出幾個扇區（臨近的，無需耗費額外時間）的數據，於是在OS層面邏輯虛擬出磁碟塊（簇）的概念，一個磁碟塊一般對應8個連續扇區（也可4、16個等，由OS決定），這樣OS層面就使用磁碟塊作為最小數據存儲單元。
這樣的好處當然是更高效，缺點則是會？

inode：用於存儲文件的元信息（除名稱外的所有屬性，名稱存在文件夾的內容中）
Inode number is also known as index number. An inode is a unique number assigned to files and directories while it is created. The inode number will be unique to entire filesystem.

Disk inodes contain the following information:

Owner identifier
Type of file (regular, directory, character or block device)
Access permissions
Times and dates
· file creation time

· last file access time

· last inode modification time

Number of links to the file
Array of pointers to data blocks on disk
File size (in bytes, sometimes also in blocks)

文件：
上文提及文件屬性存在磁碟inode區的inode（每個都有編號）內，而內容存儲在塊區的塊中。

文件夾：
作為特殊文件，其組織文件及目錄，屬性也是存在inode內，而存儲的內容是一個包含多個{ 文件名:對應inode Id} 的列表，內容亦存在塊區的塊中。

這樣在OS中查看一個文件（比如/etc/fstab）的內容，大概是：
首先OS獲取到根目錄的inodeId >在inode區中讀取到其屬性（某項是內容所在塊）>在塊區讀取到根目錄內容>在內容中找到名為/etc對應發inodeId>/etc在inode區的屬性>讀取到塊中/etc的內容（包含/etc/fstab對應inodeId）>/etc/fstab Inode Id > 在inode區讀取到/etc/fstab屬性 >/etc/fstab塊。

可能有誤，望指點。

Within each file system, the mapping from names to blocks is handled through a structure called an i-node. There's a pool of these things near the "bottom" (lowest-numbered blocks) of each file system (the very lowest ones are used for housekeeping and labeling purposes we won't describe here). Each i-node describes one file. File data blocks (including directories) live above the i-nodes (in higher-numbered blocks).

Every i-node contains a list of the disk block numbers in the file it describes. (Actually this is a half-truth, only correct for small files, but the rest of the details aren't important here.) Note that the i-node does not contain the name of the file.

Names of files live in directory structures. A directory structure just maps names to i-node numbers. This is why, in Unix, a file can have multiple true names (or hard links); they're just multiple directory entries that happen to point to the same i-node.

refer: https://unix.stackexchange.com/questions/432655/why-does-using-indirect-pointers-in-inodes-not-incur-the-same-amount-of-space

less:by direct list blocks in node?.
large :by two-level indirect block
larger : multi-level indirect block.

The original hierarchy of the inodes levels works roughly like this:

You can store one or a few block numbers directly in the inode. This means you use a few bytes more for the inode, but for small files, you don't have to allocate a complete block, which is mostly empty.

The next level is one indirection: You allocate a block to store the block pointers. Only the address of this indirect block is stored in the inode. This doesn't use somehow "less space", and most filesystems, even early ones, worked like that (have a pointer near the inode/filename which points to a block, which stores the block numbers of the file).

But what do you do when the space in this block runs out? You have to allocate another block, but where do you store the reference to this block? You could just add those references to the inode, but to store largers files, the inode would get large. And you want small inodes, so as many as possible inodes can fit into a single block (less disk access to read more inodes).

So you use a two-level indirect block: You just add one pointer to the inode, then you have a whole block to store pointers to indirect blocks, and the indirect blocks store the block address of the file itself.

And so on, you can add higher-level indirect blocks, or stop at some stage, until you reach the maximal size of a file possible with the structure you want.

So the point is not "use up less space in total", but "use a scheme that uses blocks efficiently for the expected distribution a files wrt. to size, i.e. many small files, some larger files, and very few huge files".

Page tables on the other hand work very differently.

Edit

To answer the questions in the comment:

Data blocks are of fixed sizes (originally 512 bytes, IIRC), which is a multiple of the block size of the underlying harddisks. So data block size can't "decrease".

As I tried to describe above, the whole point of having the inodes not use up too much space is to make inode access faster (or, alternatively, make caching inodes use up less memory - back then when the unix file system with inodes was invented, computers had a lot less memory than today). It's not about somehow saving space in total. As you say yourself, everything has to be stored somewhere, and if it doesn't use up space at location X, it will use up space at location Y.

Just adding a variable number of block pointers to the inode is not practical, because the inode must take up a fixed amount of space - you want to use the inode number to calculate the block address and the offset inside the block where the inode information is stored. You can't do that if every inode has a different size. So there must be some form of indirection.

Page tables work differently because hardware implements them differently - that's just how it is. The hierarchy has a fixed depth, always the same (though sometimes configurable. And while reading a block from disk is slow, that doesn't matter for page tables. So the design issues are completely different.

http://www.cems.uwe.ac.uk/~irjohnso/coursenotes/lrc/internals/filestore/fs3.htm

Assuming, for the purposes of illustration, that each disk data block is 1024 bytes in size, then these ten data block pointers will allow files to be created that are up to 10 Kb in size. As you can see, for the large majority of files it should be possible to access the data with nothing more than a direct lookup required to find the data block that contains any particular data byte.

With this scheme, once a file has grown to 10 Kb, there are only three block pointers in the inode left to use, whatever the eventual size of the file. Obviously, some new arrangement must be found so that the three remaining block pointers will suffice for any realistic file size, while at the same time not degrading the data access time too much.

This goal is achieved by using the idea of indirect block pointers. Specifically, when an 11th data block needs to be allocated to the file, the 11th inode block pointer is used, but instead of pointing to the block which will contain the data, the 11th pointer is a single indirect pointer which points to a data block filled with a list of direct block pointers. In our example, if we assume that a data block number is a 32-bit value, then a list of 256 of them will fit into the single indirect block. This list will point directly to the data blocks for the next 256 Kb of our file. This means that with 11 block pointers in the inode, files of up to 266 Kb (10 + 256) can be created. True, it takes a little longer to access the data beyond the first 10 Kb in the file, but it takes only one extra disk block read to find the position on the disk of the required data.

For files bigger than 266 Kb the double indirect (12th) inode block pointer is used. This is the same idea as the previous inode pointer except that the double indirect pointer points to a list of pointers in a data block, each of which is itself a single indirect block pointer which points to a list of 256 direct block pointers. This means that the 12th inode block pointer gives access to the next 65536 Kb (256x256) of data in our file.

By now, you should be able to spot the pattern and see that when the file grows bigger than 64 Mb (actually 65802 Kb), the inode's 13th data block pointer will be used, but this time as a triple indirect pointer, which will give access to a staggering 16 Gb (256x256x256 Kb) of extra file space. A single file bigger than 16Gb sounds huge. However, even though the calculation we have just done suggests that this file size is possible with the inode layout as given, in fact there are other factors which limit the maximum size of a file to a smaller value than this. For example, the size of a file, in bytes, is stored separately in its inode in a field of type unsigned long. This is a 32-bit number which limits the size of a file to 4 Gb, so that 13 data block pointers in an inode really are enough.

10.4. How a file gets looked up
Now we can look at the file system from the top down. When you open a file (such as, say, /home/esr/WWW/ldp/fundamentals.xml) here is what happens:

Your kernel starts at the root of your Unix file system (in the root partition). It looks for a directory there called 『home』. Usually 『home』 is a mount point to a large user partition elsewhere, so it will go there. In the top-level directory structure of that user partition, it will look for a entry called 『esr』 and extract an i-node number. It will go to that i-node, notice that its associated file data blocks are a directory structure, and look up 『WWW』. Extracting that i-node, it will go to the corresponding subdirectory and look up 『ldp』. That will take it to yet another directory i-node. Opening that one, it will find an i-node number for 『fundamentals.xml』. That i-node is not a directory, but instead holds the list of disk blocks associated with the file.

The surface area of your disk, where it stores data, is divided up something like a dartboard — into circular tracks which are then pie-sliced into sectors. Because tracks near the outer edge have more area than those close to the spindle at the center of the disk, the outer tracks have more sector slices in them than the inner ones. Each sector (or disk block ) has the same size, which under modern Unixes is generally 1 binary K (1024 8-bit bytes). Each disk block has a unique address or disk block number .

Unix divides the disk into disk partitions . Each partition is a continuous span of blocks that's used separately from any other partition, either as a file system or as swap space. The original reasons for partitions had to do with crash recovery in a world of much slower and more error-prone disks; the boundaries between them rece the fraction of your disk likely to become inaccessible or corrupted by a random bad spot on the disk. Nowadays, it's more important that partitions can be declared read-only (preventing an intruder from modifying critical system files) or shared over a network through various means we won't discuss here. The lowest-numbered partition on a disk is often treated specially, as a boot partition where you can put a kernel to be booted.

Each partition is either swap space (used to implement virtual memory ) or a file system used to hold files. Swap-space partitions are just treated as a linear sequence of blocks. File systems, on the other hand, need a way to map file names to sequences of disk blocks. Because files grow, shrink, and change over time, a file's data blocks will not be a linear sequence but may be scattered all over its partition (from wherever the operating system can find a free block when it needs one). This scattering effect is called fragmentation .

Within each file system, the mapping from names to blocks is handled through a structure called an i-node . There's a pool of these things near the "bottom" (lowest-numbered blocks) of each file system (the very lowest ones are used for housekeeping and labeling purposes we won't describe here). Each i-node describes one file. File data blocks (including directories) live above the i-nodes (in higher-numbered blocks).

Every i-node contains a list of the disk block numbers in the file it describes. (Actually this is a half-truth, only correct for small files, but the rest of the details aren't important here.) Note that the i-node does not contain the name of the file.

Names of files live in directory structures . A directory structure just maps names to i-node numbers. This is why, in Unix, a file can have multiple true names (or hard links ); they're just multiple directory entries that happen to point to the same i-node.

In the simplest case, your entire Unix file system lives in just one disk partition. While you'll see this arrangement on some small personal Unix systems, it's unusual. More typical is for it to be spread across several disk partitions, possibly on different physical disks. So, for example, your system may have one small partition where the kernel lives, a slightly larger one where OS utilities live, and a much bigger one where user home directories live.

The only partition you'll have access to immediately after system boot is your root partition , which is (almost always) the one you booted from. It holds the root directory of the file system, the top node from which everything else hangs.

The other partitions in the system have to be attached to this root in order for your entire, multiple-partition file system to be accessible. About midway through the boot process, your Unix will make these non-root partitions accessible. It will mount each one onto a directory on the root partition.

For example, if you have a Unix directory called <tt class="filename">/usr</tt>, it is probably a mount point to a partition that contains many programs installed with your Unix but not required ring initial boot.

4. 樂橙監控是否後台能儲存

你好，樂橙監控後台是可以儲存的。
因為監控設備當中手機回看的內容，是使用硬碟的儲存系統進行查看的，一般來說，監控的內容都會被記錄到內存卡的優盤當中，手機則是能夠在存儲卡當中進行查看。
以1TB的硬碟綁定4個樂橙TP7的錄制時間為例，一個攝像頭的使用天數=總硬碟的存儲大小÷每個攝像頭每天所需要的存儲大小。
一個硬碟的大小是1TB,1TB=1024GB，所以一個攝像頭的使用天數就是1×1024 ÷10.546875≈97天。

5. 樂橙硬碟錄像機後面A/B是什麼插座

有的硬碟錄像機後面標有A/B的接線端子一般是485接線端子，目的是為了控制帶雲台的攝像機，A是表示接485+，B是接485—。
樂橙硬碟錄像機是一款定位於個人私有數據備份、共享和存儲的家用網路存儲設備，樂橙硬碟錄像機提供基於Android操作系統的TB級存儲能力，支持4K高清HDMI視頻輸出、Hi-F（High-Fidelity）級音效輸出、手機端APP遠程管理及數據訪問、查看及遠程下載錄像和圖片等功能。設備連接遠程IPC後，可實現實時監視、錄像回放、報警事件推送等，為家庭安全提供全方位保障。

6. 樂橙A22E怎麼內存卡保存的視頻就幾分鍾

樂橙A22E怎麼內存卡保存的視頻保持時間短是因為內存太小
存儲大小指的是你購買的硬碟錄像機或者是SD卡的內存大小。硬碟錄像機，一般最大能放8塊硬碟，若是一個硬碟容量是1TB，這樣硬碟錄像機的容量就是8TB，1TB=1024GB，也就是有8192GB的容量；SD卡平時很常見，有64GB、128GB、256GB等等內存大小。

7. 樂橙監控,手機回看是通過硬碟的存儲嗎

你好！監控設備手機回看的內容，是通過硬碟的儲存系統查看的，通常監控內容都會錄入儲存在內存卡優盤里邊，手機可以從存儲卡里邊查看。

8. 樂橙錄像機買的時候沒有硬碟,可以自己裝個硬碟嗎

以在沒有硬碟的情況下設置的，我確定
你調試的時候接個屏就能看了，把參數設置好保存就行。用的時候再裝上硬碟
還有，很不懂你說「想要無硬碟的狀況下設置好。怕壞了」-----機器不會
你接的攝像頭控制點多不？不多的話可以直接接顯示來看啦~
不過既然你已經有硬碟錄像機就可以直接接顯示器（監視器）看啦，一般都可以支持的呢~因為他是分兩路，一路直接給顯示器，一路直接錄像，而且你可以分別設置顯示碼流和存儲碼流~
不會壞的啦！
放心！不需要。如果有遠程監控需求的話，要安裝客戶端軟體（硬碟錄像機帶該軟體），在區域網內也可以通過ie瀏覽器直接登錄硬碟錄像機的ip地址實現行程監控。
樂橙怎麼連硬碟錄像機。部分型號的樂橙是不支持連接硬碟錄像機（NVR）的，請仔細核對自己的樂橙是否支持！
工具/原料
more
無線路由器，網線，大華硬碟錄像機（NVR）
方法/步驟
1/4分步閱讀
安裝一個路由器，並發射出足夠強的WIFI信號覆蓋到攝像頭安裝處。（如果需要遠程查看，就將路由器接入外網即可，其他操作不變）

2/4
用網線連接路由器和硬碟錄像機，路由器和硬碟錄像機上都是連接LAN口。

3/4
樂橙再連接路由器發射出來的WIFI信號。

4/4
現在就可以在硬碟錄像機上檢索攝像頭了。如果不能自動激活或是添加不上，就需要手機也連接上WIFI，手動激活配置好樂橙，然後再到硬碟錄像機上手動添加樂橙到硬碟錄像機上。

注意事項
部分型號的樂橙是不支持連接硬碟錄像機的，請核對自己的樂橙型號。

9. 樂橙不開通雲存儲可以用嗎

能。
需要的安全級別不高，可以不開通雲存儲，同時連接硬碟機也不用雲空間。
雲存儲是一種網上在線存儲的模式，即把數據存放在通常由第三方託管的多台虛擬伺服器，而非專屬的伺服器上。

10. 樂橙攝像頭連接錄像機硬碟，儲存在那裡，是sd卡還是錄像機硬碟里！

如果攝像頭同時連接錄像機還裝了SD卡，那麼錄像機和sd卡都會有存錄像，循環周期不同而已，樂橙攝像頭不裝sd卡，遠程會提示無sd卡，也就是看不了錄像，但本地錄像機上是可以看的。 可能不是所有型號吧，但大多數都是這樣。海康的沒這種問題，大華的軟體沒海康的強大，遠程延遲太高了，還各種問題。。。