It may not display this or other websites correctly. You should upgrade or use an alternative browser. Resource icon Low latency, high performance x options for for most streaming services Youtube, Facebook, Author lehuan Creation date Sep 19, Tags latency low latency performance x x options. Overview Discussion. psnr, ssim and fastdecode aren't recommended for Youtube streaming. Choose one of them to use. For low latency and normal latency, turn on DVR may add a few seconds to your latency.

png Reactions: eebene , DSalt , python. san and 1 other person. Author lehuan Views 57, First release Sep 19, Last update Sep 19, Rating 0.

Join the discussion. More resources from lehuan Resource icon. Here is the guide. Share this resource Reddit Pinterest Tumblr WhatsApp Email Share Link. This function replaces a page in the pagecache with a new one. On success it acquires the pagecache reference for the new page and drops it for the old page.

Both the old and new pages must be locked. This function does not add the new page to the LRU, the caller must do that. This function is used to add a page to the pagecache.

It must be locked. This function does not add the page to the LRU. The caller must do that. Add an arbitrary waiter to the wait queue for the nominated page. In rare cases of index wrap-around, 0 will be returned.

If there is a page cache page, it is returned with an increased refcount. If there is a page cache page, it is returned locked and with an increased refcount. We update index to index the next page for the traversal. Read into the page cache. If a page already exists, and PageUptodate is not set, try to fill the page and wait for it to become unlocked. This function does all the work needed for actually writing data to a file. It does all basic checks, removes SUID from the file, updates modification times and calls proper subroutines depending on whether we do direct IO or a standard buffered write.

A caller has to handle it. Otherwise return zero. Same comments apply. As this is called only for pages that do not currently exist, we do not need to flush old virtual caches or the TLB. This only makes sense for IO mappings, and it makes no sense for cow mappings. What this means is that any page you have now, may, in a former life, have been mapped into kernel virtual address by the vmap layer and so there might be some CPUs with TLB entries still referencing that page additional to the regular kernel mapping.

After it returns, we can be sure that none of the pages we have control over will have any aliases from the vmap layer. You could see failures in the end. Please use this function for short-lived objects. a pointer to the address that has been mapped, or NULL on failure.

This function does NOT do any cache flushing. release memory allocated by vmalloc. If addr is NULL, no operation is performed. release virtual mapping obtained by vmap. Free the virtually contiguous memory area starting at addr , which was created from the page array passed to vmap.

Allocate enough pages to cover size from the page level allocator and map them into contiguous kernel virtual space. The memory allocated is set to zero. The resulting memory area is 32bit addressable and zeroed so it can be mapped to userspace without leaking data. This function reserves a range of kernel address space, and allocates pagetables to map that range. No actual mappings are created. For each zone, the number of pages is calculated as:. It returns -1 if no node is found.

If called for a node with no available memory, a warning is printed and the start and end PFNs will be 0. This function should be called after node map is populated and sorted. It calculates the maximum power of two alignment which can distinguish all the nodes. If the nodes are shifted by MiB, MiB. Note that if only the last node is shifted, 1GiB is enough and this function will indicate so.

If the maximum PFN between two adjacent zones match, it is assumed that the zone is empty. It is also assumed that a zone starts where the previous one ended. In the DMA zone, a significant percentage may be consumed by kernel image and other unfreeable allocations which can skew the watermarks badly. This function may optionally be used to account for unfreeable pages in the first zone e.

The effect will be lower watermarks and smaller per-cpu batchsize. Returns zero on success or negative error code. Free all reserved elements in pool and pool itself. this function creates and allocates a guaranteed size, preallocated memory pool. This function might sleep. This function may sleep. from IRQ contexts while this function executes. Note that due to preallocation, this function never fails when called from process contexts. it might fail if called from an IRQ context.

The actual size of blocks allocated may be larger than requested because of alignment. This is useful for devices which have addressing restrictions on individual DMA transfers, such as not crossing boundaries of 4KBytes.

Caller guarantees that no more memory from the pool is in use, and that nothing will try to use the pool after this call. This returns the kernel virtual address of a currently unused block, and reports its dma address through the handle. Caller promises neither device nor driver will again touch this block unless it is first re-allocated. DMA pool created with this function is automatically destroyed on driver detach. Processes which are dirtying memory should call in here once for each page which was newly dirtied.

This function scans the page range from start to end inclusive and tags all pages that have DIRTY tag set with a special TOWRITE tag. This mechanism is used to avoid livelocking of writeback by a process steadily creating new dirty pages in the file thus it is important for this function to be quick so that it can tag pages faster than a dirtying process can create them. This is desirable behaviour for memory-cleaning writeback, but it is INCORRECT for data-integrity system calls such as fsync.

To avoid livelocks when other process dirties new pages , we first tag pages which should be written back with TOWRITE tag and only then start writing them. For data-integrity sync we have to be careful so that we do not miss some pages e.

The rule we follow is that TOWRITE tag can be cleared only by the process clearing the DIRTY tag and submitting the page for IO. walk the list of dirty pages of the given address space and writepage all of them. This function determines if the given page is related to a backing device that requires page contents to be held stable during writeback. If so, then it will wait for any pending writeback to complete. Truncate takes two passes - the first pass is nonblocking.

It will not block on page locks and it will not block on writeback. The second pass will wait. This is to prevent as much IO as possible in the affected region. The first pass will remove most pages, so the search cost of the second pass is low. We pass down the cache-hot hint to the page freeing code. Even if the mapping is large, it is probably the case that the final pages are the most recently touched, and freeing happens in ascending file offset order. Filesystems have to use this in the.

It will not invalidate pages which are dirty, locked, under writeback or mapped into pagetables. This function should typically be called before the filesystem releases resources associated with the freed range eg.

deallocates blocks. This way, pagecache will always stay logically coherent with on-disk format, and the filesystem would not have to deal with situations such as writepage being called for a page that has already had its underlying blocks deallocated. xfs uses a different lock and before all filesystem specific block truncation has been performed. Set up the sequence range to use for the ipc identifier range limited below IPCMNI then initialise the ids idr.

Returns the locked pointer to the ipc structure if found or NULL otherwise. If key is found ipc points to the owning ipc structure. The permissions object is initialised and the first free entry is set up and the id assigned is returned. On failure the entry is not locked and a negative err-code is returned. rwsem as a writer and the spinlock for this ID are held before this function is called, and remain locked on the exit.

Allocate memory from the appropriate pools and return a pointer to it. NULL is returned if the allocation fails. Returns the pointer to the object or NULL upon failure. Turn the kernel object in into a set of permissions descriptions for returning to userspace out. Turn the new style permissions object in into a compatibility object and store it into the out pointer. It must be called without any lock held and:.

The cmd value is turned from an encoding command and version into just the command code. Return true if fifo is initialized, otherwise false.

Assumes the fifo was 0 before. It should be only called when the fifo is exclusived locked or when it is secured that no other thread is accessing the fifo. The numer of elements will be rounded-up to a power of 2. Return 0 if no error, otherwise an error code. This macro copies the given value into the fifo.

It returns 0 if the fifo was full. Otherwise it returns the number processed elements. This macro reads the data from the fifo. It returns 0 if the fifo was empty. This reads the data from the fifo without removing it from the fifo. This macro copies the given values buffer into the fifo and returns the number of copied elements. This macro fills a scatterlist for DMA input. It returns the number entries in the scatterlist array.

This macro finish a DMA IN operation. The in counter will be updated by the len parameter. No error checking will be done. This macro fills a scatterlist for DMA output which at most len bytes to transfer. A zero means there is no space available and the scatterlist is not filled.

This macro finish a DMA OUT operation. The out counter will be updated by the len parameter. This macro get the data from the fifo and return the numbers of elements copied.

The data is not removed from the fifo. Relay interface support is designed to provide an efficient mechanism for tools and facilities to relay large amounts of data from kernel space to user space. This has the effect of erasing all data from all channel buffers and restarting the channel in its initial state.

The buffers are not freed, so any mappings are still in effect. Returns channel pointer if successful, NULL otherwise. Creates a channel buffer for each cpu using the sizes and attributes specified.

For example, this is useful for perfomring early tracing in kernel, before VFS is up and then exposing the early results once the dentry is available. Performs sub-buffer-switch tasks such as invoking callbacks, updating padding counts, waking up readers, etc.

Load a module using the user mode module loader. Note that a successful module load does not mean the module did not then unload and exit on an error of its own.

Callers must check that the service they requested is now available not blindly invoke it. The init function is used to customize the helper process prior to exec. A non-zero return code causes the process to error out, exit, and return the failure to the calling process. This can be used for freeing the argv and envp. Runs a user-space application.

The application is started asynchronously if wait is not set, and runs as a child of system workqueues. it runs with full root capabilities and optimized affinity. This function waits for any pending hard IRQ handlers for this interrupt to complete before returning.

If you use this function while holding a resource the IRQ handler may need you will deadlock. It does not take associated threaded handlers into account. Do not use this for shutdown scenarios where you must be sure that all parts hardirq and threaded handler have completed. This function waits for any pending IRQ handlers for this interrupt to complete before returning.

Disable the selected interrupt line. Disables and Enables are nested. Enables and Disables are nested. If you use this function while holding a resource the hard IRQ handler may need you will deadlock. When used to optimistically disable an interrupt from atomic context the return value must be checked.

If this matches the last disable, processing of interrupts on this IRQ line is re-enabled. Enables and disables must match, just as they match for non-wakeup mode support. Remove an interrupt handler.

The handler is removed and if the interrupt line is no longer in use by any driver it is disabled. On a shared IRQ the caller must ensure the interrupt is disabled on the card it drives before calling this function.

The function does not return until any executing interrupts for this IRQ have completed. This call allocates interrupt resources and enables the interrupt line and IRQ handling. From the point this call is made your handler function may be invoked. Since your handler function must clear any interrupt the board raises, you must take care both to initialise your hardware and to set up the interrupt handler in the right order. handler is still called in hard interrupt context and has to check whether the interrupt originates from the device.

This split handler design is necessary to support shared interrupts. Normally the address of the device data structure is used as the cookie. Since the handler receives this value it makes sense to use it. It selects either a hardirq or threaded handling method depending on the context. On failure, it returns a negative value. Must be called from a non migratable context. Returns the enable state of a per cpu interrupt on the current cpu.

Remove a percpu interrupt handler. The handler is removed, but the interrupt line is not disabled. This must be done on each CPU before calling this function. This call allocates interrupt resources and enables the interrupt on the local CPU. This call snapshots the internal irqchip state of an interrupt, returning into state the bit corresponding to stage which. This function should be called with preemption disabled if the interrupt controller has per-cpu registers.

This call sets the internal irqchip state of an interrupt, depending on the value of which. The resource will be relocated if the new size cannot be reallocated in the current location. If a conflict happens, and the conflicting resources entirely fit within the range of the new resource, then the new resource is inserted and the conflicting resources become children of the new resource. Insert a resource into the resource tree, possibly expanding it in order to make it encompass any conflicting resources.

This interface is intended for memory hot-delete. The requested region is released from a currently busy memory resource. The requested region must either match exactly or fit into a single busy resource entry. In the latter case, the remaining resource is adjusted accordingly. Existing children of the busy memory resource must be immutable in the request.

The resource will be reallocated with a new size if it was already allocated. Given an existing resource, change its start and size to match the arguments. Existing children of the resource are assumed to be immutable. There is usually no need to release resources requested by this function explicitly since that will be taken care of when the device is unbound from its driver.

When a conflict is detected between any existing resources and the newly requested resource, an error message will be printed. If PAT is available, this does nothing. If PAT is unavailable, it attempts to add a WC MTRR covering size bytes starting at base and logs an error if this fails.

Each LSM must pass this method before registering its own operations to avoid security registration races. This method may also be used to check if your LSM is currently loaded during kernel initialization. This function returns a pointer to a dentry if it succeeds. If securityfs is not enabled in the kernel, the value -ENODEV is returned.

This function is required to be called in order for the file to be removed. No automatic cleanup of files will happen when a module is removed; you are responsible here. Obtain an audit buffer. If the task ctx is a task that is currently in a syscall, then the syscall is marked as auditable and an audit record will be written at syscall exit. If there is no associated task, then task context ctx should be NULL. May be called in any context.

It may be called in any context. Filter on the task information and allocate a per-task audit context if necessary.

Doing so turns on system call auditing for the specified task. Fill in audit context at syscall entry. This only happens if the audit context was created when the task was created and the state or filters demand the audit context be built.

Tear down after system call. In call cases, free the names stored from getname. If not, return NULL. Add a name to the list of audit names for this context. c: getname. Simply check if the proc already has the caps given by the file and if not store the priv escalation info for later auditing at the end of the syscall. If a process ends with a core dump, something fishy is going on and we should record the event for investigation.

It takes the name of the file where accounting records should be written. If the filename is NULL, accounting will be shutdown.

The block layer may perform asynchronous callback activity on a queue, such as calling the unplug function after a timeout. This function does not cancel any asynchronous activity arising out of elevator or throttling code. In bypass mode, only the dispatch FIFO queue of q is used. This function makes q enter bypass mode and drains all requests which were throttled or issued before.

Mark q DYING, drain all pending requests, mark q DEAD, destroy and put it. All future requests will be failed immediately with -ENODEV. The function rfn will be called when there are requests on the queue that need to be processed. If the device supports plugging, then rfn may not be called immediately when requests are available on the queue, but may be called at some time later instead. Plugged queues are generally unplugged when a buffer belonging to one of the requests on the queue is needed, or due to memory pressure.

rfn is not required, or even expected, to remove all requests off the queue, but only as many as it can handle at a time. If it does leave requests on the queue, it is responsible for arranging that the requests get dealt with eventually. The queue spin lock must be held while manipulating the requests on the request queue; this lock will be taken also from interrupt context, so irq disabling is needed for it.

The average IO queue length and utilisation statistics are maintained by observing the current state of the queue length and the amount of time it has been in this state for. This accounts immediately for all queue usage up to the current jiffies and restarts the counters again.

Dequeue req and start timeout timer on it. This hands off the request to the driver. If req has leftover, sets it up for the next range of segments.

This special helper function is only for request stacking drivers e. request-based dm so that they can handle partial completion. This function makes a request ready for complete resubmission or completion. The queue lock is held when calling this.

Check if underlying low-level drivers of a device are busy. Basically, this function is used only by request stacking drivers to stop dispatching requests to underlying devices when underlying devices are busy.

Initialize runtime-PM-related fields for q and start auto suspend for dev. This function takes care of setting up using auto suspend for the device, the autosuspend delay is set to -1 to make runtime suspend impossible until an updated value is either set by user or by driver. Drivers do not need to touch other autosuspend settings. This function will check if runtime suspend is allowed for the device by examining if there are any requests pending in the queue.

For the not allowed case, we mark last busy for the device so that runtime PM core will try to autosuspend it some time later. If the device is left runtime suspended during system suspend the resume hook typically resumes the device and corrects runtime status accordingly.

This prevents processing requests from the queue. It should be called before first request is added to the queue. Drain requests from q. If not, only ELVPRIV requests are drained. The caller is responsible for ensuring that no new requests which need to be drained are queued. Get a free request from q. This function may fail under memory pressure or if q is dead.

Returns true if merge was successful, otherwise false. Only check basic merging parameters without querying the elevator. rq may have been made based on weaker limitations of upper-level queues in request stacking drivers, and it may violate the limitation of q. Since the block layer and the underlying device driver trust rq after it is inserted to q , it should be checked against q before the insertion using this generic function.

Request stacking drivers like request-based dm may change the queue limits when retrying requests on other queues.

Those requests need to be checked against the new queue limits again during dispatch. Otherwise a kernel bounce buffer is used.

It is set by the disk driver. This function is used by stacking drivers like MD and DM to ensure that all component devices have compatible block sizes and alignments. The stacking function will attempt to combine the values and ensure proper alignment. Appending pad buffer to a request modifies the last entry of a scatter list such that it includes the pad buffer.

They have to have a real area of memory to transfer it into. The use case for this is ATAPI devices in DMA mode. What this API does is adjust the queue so that the buf is always appended silently to the scatterlist. Zero-fill a block range, either using hardware offload or by explicitly writing zeroes to the device.

Drop the reference count on bqt and frees it when the last reference is dropped. Returns the number of elements required in a scatterlist corresponding to the integrity metadata in a bio.

Map the integrity vectors in request into a scatterlist. The scatterlist must be big enough to hold all elements. This function can be used to check whether two gendisk devices have compatible integrity formats. Mangling twice gives the original value. The original ptbl is freed using RCU callback. Events blocking is counted and the actual unblocking happens after the matching number of unblocks are done.

When the block count reaches zero, it starts events polling if configured. Schedule immediate event checking on disk if not blocked. Events in mask are scheduled to be cleared from the driver. Disk events are synchronously checked and pending events in mask are cleared and returned. This ignores the block count. Look for partition partno from disk. If found, increment reference count and return it.

Find out which partition sector maps to on disk. This is primarily used for stats accounting. This function gets the structure containing partitioning information for the given device devt. do bdget by gendisk and partition number. Find partition partno from disk , do bdget on it.

Allocates a range of char device numbers. The major number will be chosen dynamically, and returned along with the first minor number in dev. Returns zero or a negative error code. It only helps to keep track of the different owners of devices. the name of the module here. This function will unregister a range of count device numbers, starting with from. The caller should normally be the one who allocated those numbers in the first place Unregister and destroy the cdev occupying the region described by major , baseminor and count.

A negative error code is returned on failure. This helper function correctly takes a reference to the parent device so the parent will not get released until all references to the cdev are released. This function should be used whenever the struct cdev and the struct device are members of the same structure whose lifetime is managed by the struct device. Callers must assume that userspace was able to open the cdev and can call cdev fops callbacks at any time, even if this function fails.

This guarantees that associated sysfs callbacks are not running or runnable, however any cdevs already open will remain and their fops will still be callable even after this function returns. The clock framework defines programming interfaces to support software management of the system clock tree. This framework is widely used with System-On-Chip SOC platforms to support power management and various devices which may need custom clock rates.

These struct clk instances may be used to manage for example a 96 MHz signal that is used to shift bits into and out of peripherals or busses, or otherwise trigger synchronous state machine transitions in system hardware.

On some systems this may be backed by hardware clock gating, where clocks are gated without being disabled in software. Sections of chips that are powered but not clocked may be able to retain their last state. This low power state is often called a retention mode.

This mode still incurs leakage currents, especially with finer circuit geometries, but for CMOS circuits power is mostly used by clocked state changes.

Power-aware drivers only enable their clocks when the device they manage is in active use. Some platforms support programmable clock generators. These can be used by external chips of various kinds, such as other CPUs, multimedia codecs, and devices with strict requirements for interface clocking.

An entry is created whenever code registers the first notifier on a particular clk. ProTip: debugging across notifier chains can be frustrating. Make sure that your notifier callback function prints a nice big warning in case of failure.

Shifts the phase of a clock signal by the specified degrees. Returns 0 on success, -EERROR otherwise. Returns true if the two struct clk pointers both point to the same hardware clock node. This undoes a previously prepared clock. The caller must balance the number of prepare and unprepare calls. The implementation uses dev and id to determine the clock consumer, and thereby the clock producer. obtain the current clock rate in Hz for a clock source.

This is only valid once the clock source has been enabled. In other words:. This function can be used in drivers that need to check that a clock can be the parent of another without actually changing the parent.

Returns true if parent is a possible parent for clk , false otherwise. The Linux Kernel 4. Docs » Core API Documentation » The Linux Kernel API View page source.

This is good for implementing stacks. This is useful for implementing queues. Description Each of the lists is a queue. type the type of the struct this is embedded in. Description Note, that list is expected to be not empty. Description Note that if the list is empty, it returns NULL.

head the head for your list. Description Continue to iterate over list of given type, continuing after the current position. Description Start to iterate over list of given type backwards, continuing after the current position. Description Iterate over list of given type, continuing from current position. Description Iterate backwards over list of given type, continuing from current position. Description Iterate over list of given type, continuing after current point, safe against removal of list entry.

Description Iterate over list of given type from current point, safe against removal of list entry. Description Iterate backwards over list of given type, safe against removal of list entry. Basic C Library Functions ¶ When writing drivers, you cannot in general use routines which are from the C Library. Please use kstrtoull instead.

To view this without leaving the command-line in Windows, use the following command assuming you installed it in the default folder :. This trick uses the command-line command more to show the file screen-by-screen.

Pressing spacebar will advance the output a screen at a time, and pressing enter will advance the output one line at a time. Here's the output of vlc -H of vlc From VideoLAN Wiki. See also: Command-line interface and Console interfaces. Categories : Command-line help Windows. Navigation menu Personal tools Log in. Namespaces Page Discussion. Views Read View source View history.

Development Developers Corner x development Join the project. VideoLAN wiki Main Page About VideoLAN VLC media player Recent changes Rules Sandbox. Tools What links here Related changes Special pages Printable version Permanent link Page information.

This page was last edited on 19 April , at Privacy policy About VideoLAN Wiki Disclaimers. VLC command-line help for Windows users about VLC media player. VLC command-line help , VLCx command-line help , VLCx command-line help , VLCx command-line help , VLCx command-line help.

Mask of supported hdmi deep color modes in YCbCr Not that not all removal functions will leave a node in unhashed state. This macro copies the given value into the fifo. Indicates whether the last read EDID was corrupt. Global implicit acquire context used by atomic drivers for legacy IOCTLs.

Categories:

• Binary Options
• Forex
• Binary Options online
• Forex Bitcoin
• Forex Brokers