Queue management for setting storage in performing image processing tasks

Abstract

A device for image processing includes: one or more memories configured to store one or more image frames; and processing circuitry coupled to the one or more memories and configured to perform image processing tasks, wherein to perform the image processing tasks, the processing circuitry is configured to: manage a first queue and a second queue, wherein the first queue is configured to store Input / Output (IO) settings and the second queue is configured to store Image Quality (IQ) settings; for each processed image frame, determine whether at least one of the IO settings or the IQ settings have changed; and in response to determining that at least one of the IO settings or the IQ settings have changed, update at least one of the IO settings or the IQ settings for the corresponding image frame in at least one of the first queue or the second queue.

Description

QUEUE MANAGEMENT FOR SETTING STORAGE IN PERFORMING IMAGE PROCESSING TASKSTECHNICAL FIELD

[0001] The disclosure relates to image processing.BACKGROUND

[0002] XR stands for “Extended Reality, ” which is an umbrella term encompassing Virtual Reality (VR) , Augmented Reality (AR) , and Mixed Reality (MR) . These technologies blend the physical and digital worlds, offering immersive experiences. Single-lens cameras may be used within XR devices for tracking purposes. These cameras may capture depth information or visual data to understand the environment surrounding a user and position within it.SUMMARY

[0003] In general, this disclosure describes techniques for improving performance of lite node that is designed to offload image processing tasks from the main central processing unit (CPU) . The lite node may be a specialized hardware component in some examples, and may be referred to as a Lite node. However, the techniques are not limited to hardware nodes.

[0004] In the context of XR devices, a Lite node may be specifically tailored for mono tracking cameras. The Lite node's efficiency may be based on the minimal or nonexistent Image Signal Processor (ISP) pipeline processing. Typically, ISP pipelines may handle a variety of image adjustments, such as color correction, noise reduction, and exposure control. By bypassing these computationally intensive tasks, the Lite node may significantly reduce the processing load.

[0005] In an aspect, the CPU may then focus on tasks like tracking algorithms, rendering, and user interface management. In one example, with less image processing overhead, the CPU may operate at a lower utilization rate, leading to better overall system responsiveness. In an aspect, Image Quality (IQ) execution operations refer to the computational tasks performed on raw image data to enhance quality of the image data. Reducing these operations may involve streamlining the image processing pipeline, removing unnecessary steps or simplifying existing ones. Fewer calculations may mean less work for the CPU. Less processing may require less energy.

[0006] In an aspect, faster image processing may lead to shorter delays in displaying the image. CPU load refers to the amount of work imposed on the central processing unit. Reducing CPU load may involve optimizing software and hardware to minimize the computational burden. As a result, the CPU may handle other tasks efficiently. Lower CPU usage may lead to less power consumption.

[0007] In some examples, the Lite node may use high-precision arithmetic for accurate color processing and image adjustments. In this manner, to support a variety of image quality enhancements, the Lite node may be designed to accommodate multiple IQ (Image Quality) modules. The present disclosure describes "request-less" techniques that aim to further optimize the Lite node by potentially eliminating even the minimal ISP processing and associated control overhead. The request-less techniques may more easily handle increasing camera counts and frame rates without significant performance degradation. Reduced CPU utilization may lead to lower power consumption, especially for battery-powered devices. In addition, the disclosed techniques may improve the performance and memory efficiency of the HW node by optimizing IQ register setting updates. Instead of executing IQ modules for every frame, a threshold may be introduced. IQ modules may only be executed if the input data exceeds the specified threshold, indicating a significant change requiring image enhancement.

[0008] In one example, the disclosure describes a device for image processing, the device comprising: one or more memories configured to store one or more image frames; and processing circuitry coupled to the one or more memories and configured to perform image processing tasks, wherein to perform the image processing tasks, the processing circuitry is configured to: manage a first queue and a second queue, wherein the first queue is configured to store Input / Output (IO) settings and the second queue is configured to store Image Quality (IQ) settings, wherein the IO settings comprise one or more settings that control interactions of the device with an external environment and wherein the IQ settings comprise one or more settings that fine-tune one or more image quality parameters of the device; for each processed image frame, determine whether at least one of the IO settings or the IQ settings have changed; and in response to determining that at least one of the IO settings or the IQ settings have changed, update at least one of the IO settings or the IQ settings for the corresponding image frame in at least one of the first queue or the second queue.

[0009] In one example, the disclosure describes a method for image processing by an image processing device, the method comprising: managing a first queue and a second  queue, wherein the first queue is configured to store Input / Output (IO) settings and the second queue is configured to store Image Quality (IQ) settings, wherein the IO settings comprise one or more settings that control interactions of the image processing device with an external environment and wherein the IQ settings comprise one or more settings that fine-tune one or more image quality parameters of the image processing device; for each processed image frame, determining whether at least one of the IO settings or the IQ settings have changed; and in response to determining that at least one of the IO settings or the IQ settings have changed, updating at least one of the IO settings or the IQ settings for the corresponding image frame in at least one of the first queue or the second queue.

[0010] In one example, the disclosure describes non-transitory computer-readable storage media having instructions encoded thereon, the instructions configured to cause processing circuitry to: manage a first queue and a second queue, wherein the first queue is configured to store Input / Output (IO) settings and the second queue is configured to store Image Quality (IQ) settings, wherein the IO settings comprise one or more settings that control interactions of an image processing device with an external environment and wherein the IQ settings comprise one or more settings that fine-tune one or more image quality parameters of the image processing device; for each processed image frame, determine whether at least one of the IO settings or the IQ settings have changed; and in response to determining that at least one of the IO settings or the IQ settings have changed, update at least one of the IO settings or the IQ settings for the corresponding image frame in at least one of the first queue or the second queue.

[0011] The details of one or more examples are set forth in the accompanying drawings and the description below. Other features, objects, and advantages will be apparent from the description, drawings, and claims.BRIEF DESCRIPTION OF DRAWINGS

[0012] FIG. 1 is a block diagram of a device configured to perform one or more of the example techniques described in this disclosure.

[0013] FIG. 2 is a diagram illustrating “request-less” techniques for a Lite node, in accordance with the techniques of this disclosure.

[0014] FIG. 3 is a diagram illustrating implementation of new ProcessIO and ProcessIQ setting functions of the Lite node, in accordance with the techniques of this disclosure.

[0015] FIG. 4 is a conceptual diagram illustrating role of a driver in managing queues, in accordance with the techniques of this disclosure.

[0016] FIG. 5 is a conceptual diagram that outlines a typical ISP pipeline architecture that is organized into Lite nodes, in accordance with the techniques of this disclosure.

[0017] FIG. 6 is a flowchart illustrating a high level ISP pipeline data flow, in accordance with the techniques of this disclosure.

[0018] FIG. 7 is a flowchart illustrating generation of IQ setting, in accordance with the techniques of this disclosure.

[0019] FIG. 8 is a flowchart illustrating updates of IQ register settings, in accordance with the techniques of this disclosure.

[0020] FIG. 9 is a flowchart illustrating the conditions under which an IQ module may need to be executed and the steps involved in its execution, in accordance with the techniques of this disclosure.

[0021] FIG. 10 is a flowchart illustrating an example method of operation.DETAILED DESCRIPTION

[0022] In digital photography and imaging, a Lite node may be a hardware component or processing unit designed for lightweight tasks. Lite node may be specifically used in mono tracking cameras. ISP pipeline processing in Lite nodes may be relatively straightforward. The ISP pipeline processing in Lite nodes may be optimized for basic image processing tasks, which may be sufficient for the purpose of mono tracking camera.

[0023] Despite the simple ISP pipeline processing, camera performance may be important. Low CPU utilization and minimal capture latency may be useful for smooth tracking and an immersive XR experience.

[0024] At least some of XR devices may have at least four mono cameras operating at a combined processing speed of 90 picoseconds. This high-speed processing may be necessary to handle the demands of real-time tracking. Furthermore, Original Equipment Manufacturer (OEM) requirements may necessitate a large number of tracking cameras operating at high frame rates (FPS) to achieve accurate and responsive tracking in XR applications.

[0025] An ISP pipeline is a series of processing stages that transform raw image data from an image sensor into a visually appealing and usable digital image. ISP pipeline  may be important for capturing high-quality images, especially in performance-sensitive applications like XR and IoT.

[0026] In accordance with one or more examples described in this disclosure, basic ISP pipeline may include the following stages. An image sensor may capture raw image data in the form of an analog signal. The analog signal may be converted into a digital format for processing. A Black Level Correction (BLC) unit may remove fixed pattern noise caused by the sensor. A gain control unit may adjust image brightness by amplifying or attenuating the signal. A Lens Shading Correction (LSC) unit may compensate for uneven light sensitivity across the image sensor. A Color Correction Matrix (CCM) may adjust color accuracy. A white balance unit may correct color casts due to different lighting conditions. A noise reduction unit may reduce image noise. A sharpening unit may enhance image details. A gamma correction unit may adjust image contrast for display.

[0027] A well-designed Lite node may be important for optimizing the ISP pipeline for performance-sensitive applications. For example, parallel processing may divide the ISP pipeline into parallel processing stages to maximize throughput. The Lite node may minimize data movement between stages and overlap computations to reduce latency. The Lite node may offload computationally intensive tasks like noise reduction and sharpening to dedicated hardware accelerators. The Lite node may allow dynamic adjustment of pipeline stages and parameters to adapt to different image conditions and performance requirements. The Lite node may be optimized for low power consumption, especially for battery-powered devices like IoT devices.

[0028] For high resolution and high quality images, the ISP pipeline may need to handle larger amounts of data and perform more complex processing. Some considerations may include but are not limited to: high-speed interfaces, wide data paths and advanced noise reduction. In some cases, the ISP pipeline may use high-speed interfaces to transfer image data efficiently between the image sensor and the ISP.

[0029] In some examples, the Lite node may use high-precision arithmetic for accurate color processing and image adjustments. In this manner, to support a variety of image quality enhancements, the Lite node may be designed to include multiple IQ modules. The present disclosure describes "request-less" techniques that may further optimize the Lite node by eliminating even the minimal ISP processing and associated control overhead. The request-less techniques that eliminate per frame requests may more easily handle increasing camera counts and frame rates without significant performance  degradation. Reduced CPU utilization may lead to lower power consumption, especially for battery-powered devices. In addition, the disclosed techniques may improve the performance and memory efficiency of the Lite node by optimizing IQ (Image Quality) register setting updates. Instead of executing IQ modules for every frame, a threshold may be introduced. IQ modules may only be executed if the input data exceeds the specified threshold, indicating a significant change requiring image enhancement.

[0030] FIG. 1 is a block diagram of a device configured to perform one or more of the example techniques described in this disclosure. Examples of computing device 100 include an XR device, an IOT device, a computer (e.g., personal computer, a desktop computer, or a laptop computer) , a mobile device such as a tablet computer, a wireless communication device (such as, e.g., a mobile telephone, a cellular telephone, a satellite telephone, and / or a mobile telephone handset) , a landline telephone for teleconferencing, an Internet telephone, a handheld device such as a portable video game device or a personal digital assistant (PDA) . Additional examples of computing device 100 include a personal music player, a video player, a display device, a camera, a television, a set-top box, a broadcast receiver device, a server, an intermediate network device, a mainframe computer or any other type of device that processes and / or displays graphical data.

[0031] As illustrated in the example of FIG. 1, computing device 100 includes image sensor 102, a camera processor 104, a Lite node 105, a central processing unit (CPU) 106, a graphical processing unit (GPU) 108, user interface 112, memory controller 114 that provides access to system memory 120, and display processor 116 that outputs signals that cause graphical data to be displayed on display 118. In FIG. 1, camera processor 104 is coupled to buffer 110. In one or more examples, buffer 110 may be dedicated buffer memory for camera processor 104. That is, buffer 110 may not be available to other components for storage. In some examples, buffer 110 may not be needed, and may be part of system memory 120.

[0032] In some examples, buffer 110 may be part of camera processor 104, and may be dedicated memory of camera processor 104. In some examples, buffer 110, when located within camera processor 104, may be dedicated for storing one or more images.

[0033] Although FIG. 1 illustrates image sensor 102 as part of the same device that includes camera processor 104, Lite node 105, CPU 106, and GPU 108, the techniques described in this disclosure are not so limited. In some examples, camera processor 104, Lite node 105, CPU 106, and GPU 108 and many of the various other components  illustrated in FIG. 1 may be on a different device (e.g., a processing device) than image sensor 102.

[0034] Also, although the various components are illustrated as separate components, in some examples the components may be combined to form a system on chip (SoC) . As an example, camera processor 104, Lite node 105, CPU 106, GPU 108, and display processor 116 may be formed on a common integrated circuit (IC) chip. In some examples, one or more of camera processor 104, Lite node 105, CPU 106, GPU 108, and display processor 116 may be in separate IC chips. Various other permutations and combinations are possible, and the techniques should not be considered limited to the example illustrated in FIG. 1. The various components illustrated in FIG. 1 (whether formed on one device or different devices) may be formed as at least one of fixed-function or programmable circuitry such as in one or more microprocessors, application specific integrated circuits (ASICs) , field programmable gate arrays (FPGAs) , digital signal processors (DSPs) , or other equivalent integrated or discrete logic circuitry.

[0035] The various units illustrated in FIG. 1 communicate with each other using bus 122. Bus 122 may be any of a variety of bus structures, such as a third generation bus (e.g., a HyperTransport bus or an InfiniBand bus) , a second generation bus (e.g., an Advanced Graphics Port bus, a Peripheral Component Interconnect (PCI) Express bus, or an Advanced eXtensible Interface (AXI) bus) or another type of bus or device interconnect. It should be noted that the specific configuration of buses and communication interfaces between the different components shown in FIG. 1 is merely exemplary, and other configurations of computing devices and / or other image processing systems with the same or different components may be used to implement the techniques of this disclosure.

[0036] Camera processor 104 may be external to computing device 100; however, it may be possible for camera processor 104 to be internal to computing device 100, as illustrated. For instance, in some examples, image sensor 102 and camera processor 104 may form a pluggable camera for a desktop or laptop computer, and Lite node 105, CPU 106, GPU 108, and the various other components may be part of the desktop or laptop computer. For ease of description, the examples are described with respect to the configuration illustrated in FIG. 1.

[0037] Image sensor 102 includes a plurality of sensor elements (e.g., photodiodes) arranged in 2x2 grid. The sensor elements may be CMOS (Complementary Metal-Oxide-Semiconductor) sensor elements. Each sensor element generates an electrical  signal based on a luminance of the light incident to the sensor element. With filtering, such as Bayer filtering, the electrical signals generated by each of the sensor element indicate the luminance of a particular color.

[0038] For instance, the output from image sensor 102 may comprise samples associated with different colors (e.g., red, green, blue samples) . Based on the particular filtering that is used, each of the colors may be sub-sampled relative to the number of sensor elements.

[0039] Camera processor 104 is configured to receive electrical signals as sensor signals from respective sensor elements of image sensor 102 and process the electrical signals to generate pixel data of an image. As one example, camera processor 104 may upsample the red color samples to generate red samples of a red color frame, upsample the green color samples to generate green color samples of a green color frame, and upsample the blue color samples to generate blue color samples of a blue color frame. The upsampling may be optional, but for purposes of illustration only the examples are described with respect to a plurality of color frames (e.g., red, green, and blue color frames) having the same resolution as an image. In examples where upsampling is not performed, there may be other techniques to address the difference in resolution between the image and the color frames.

[0040] The pixels of the image may be a combination of the samples from each of the color frames. For instance, the top-left pixel of the image may be a combination of the top-left samples of the red color frame, the green color frame, and blue color frame, the pixel immediately to the right of the top-left pixel of the image may be a combination of the samples immediately to the right of the top-left samples of the red color frame, the green color frame, and the blue color frame, and so forth. Accordingly, the pixels of the image are based on color values of samples in each color frame of a plurality of color frames of the image, where each color frame is associated with a different color.

[0041] In some examples, camera processor 104 may be configured as a single-input-multiple-data (SIMD) architecture. Camera processor 104 may perform the same operations on electrical signals received from each of the sensor elements of image sensor 102. Each lane of the SIMD architecture may include an image pipeline. The image pipeline includes hardwire circuitry and / or programmable circuitry (e.g., at least one of fixed-function or programmable circuitry) to process the output of the sensors to generate pixel values for pixels.

[0042] In one or more examples, processing circuitry of image sensor 102 may include respective trans-impedance amplifiers (TIAs) to convert the electrical signals (e.g., current) to a voltage and respective analog-to-digital converters (ADCs) that convert the analog voltage output into a digital value. The electrical signal outputted by each sensor element indicates the luminance (e.g., light intensity) of a red, green, or blue component. These examples described with respect to processing circuitry of image sensor 102 may be part of camera processor 104, in some examples.

[0043] Camera processor 104 may also perform noise reduction and image sharpening, as additional examples of imaging pipeline. Camera processor 104 outputs the resulting images (e.g., pixel values for each of the image pixels) to system memory 120 via memory controller 114.

[0044] CPU 106 may comprise a general-purpose or a special-purpose processor that controls operation of computing device 100. A user may provide input to computing device 100 to cause CPU 106 to execute one or more software applications. The user may provide input to computing device 100 via one or more input devices (not shown) such as a keyboard, a mouse, a microphone, a touch pad or another input device that is coupled to computing device 100 via user interface 112.

[0045] One example of the software application is a camera application. CPU 106 executes the camera application, and in response, the camera application causes CPU 106 to generate content that display 118 outputs. For instance, display 118 may output information such as light intensity, whether flash is enabled, and other such information. The user of computing device 100 may interface with display 118 to configure the manner in which the images are generated (e.g., with or without flash, focus settings, exposure settings, and other parameters) . The camera application also causes CPU 106 to instruct camera processor 104 to process the images captured by image sensor 102 in the user-defined manner.

[0046] GPU 108 may generate graphical information that provides the user information about the image frames to be captured. For instance, GPU 108 may generate a graphic that indicates whether flash is enabled, generate boxes around identified faces, etc.

[0047] Memory controller 114 facilitates the transfer of data going into and out of system memory 120. For example, memory controller 114 may receive memory read and write commands, and service such commands with respect to memory 120 in order to provide memory services for the components in computing device 100. Memory controller 114 is communicatively coupled to system memory 120. Although memory  controller 114 is illustrated in the example of computing device 100 of FIG. 1 as being a processing circuit that is separate from both CPU 106 and system memory 120, in other examples, some or all of the functionality of memory controller 114 may be implemented on one or both of CPU 106 and system memory 120.

[0048] System memory 120 may store program modules and / or instructions and / or data that are accessible by camera processor 104, CPU 106, and GPU 108. For example, system memory 120 may store user applications (e.g., instructions for the camera application) , resulting images from camera processor 104, etc. System memory 120 may additionally store information for use by and / or generated by other components of computing device 100. For example, system memory 120 may act as a device memory for camera processor 104. System memory 120 may include one or more volatile or non-volatile memories or storage devices, such as, for example, random access memory (RAM) , static RAM (SRAM) , dynamic RAM (DRAM) , read-only memory (ROM) , erasable programmable ROM (EPROM) , electrically erasable programmable ROM (EEPROM) , flash memory, a magnetic data media or an optical storage media.

[0049] In some aspects, system memory 120 may include instructions that cause camera processor 104, Lite node 105, CPU 106, GPU 108, and display processor 116 to perform the functions ascribed to these components in this disclosure. Accordingly, system memory 120 may be a computer-readable storage medium having instructions stored thereon that, when executed, cause one or more processors (e.g., camera processor 104, Lite node 105, CPU 106, GPU 108, and display processor 116) to perform various functions.

[0050] In some examples, system memory 120 is a non-transitory storage medium. The term “non-transitory” indicates that the storage medium is not embodied in a carrier wave or a propagated signal. However, the term “non-transitory” should not be interpreted to mean that system memory 120 is non-movable or that its contents are static. As one example, system memory 120 may be removed from computing device 100, and moved to another device. As another example, memory, substantially similar to system memory 120, may be inserted into computing device 100. In certain examples, a non-transitory storage medium may store data that can, over time, change (e.g., in RAM) .

[0051] Camera processor 104, Lite node 105, CPU 106, and GPU 108 may store image data, and the like in respective buffers that are allocated within system memory 120. Display processor 116 may retrieve the data from system memory 120 and configure  display 118 to display the image represented by the generated image data. In some examples, display processor 116 may include a digital-to-analog converter (DAC) that is configured to convert the digital values retrieved from system memory 120 into an analog signal consumable by display 118. In other examples, display processor 116 may pass the digital values directly to display 118 for processing.

[0052] Display 118 may include a monitor, a television, a projection device, a liquid crystal display (LCD) , a plasma display panel, a light emitting diode (LED) array, or another type of display unit. Display 118 may be integrated within computing device 100. For instance, display 118 may be a screen of a mobile telephone handset or a tablet computer. Alternatively, display 118 may be a stand-alone device coupled to computing device 100 via a wired or wireless communications link. For instance, display 118 may be a computer monitor or flat panel display connected to a personal computer via a cable or wireless link.

[0053] To support a variety of image quality enhancements, the Lite node 105 may be designed to include multiple IQ modules. For example, the Lite node 105 may have a modular architecture that allows for easy integration of new IQ modules. The disclosed techniques may provide mechanisms to configure the Lite node 105 to enable different combinations of IQ modules. The Lite node 105 may ensure efficient data sharing between IQ modules to minimize redundant processing.

[0054] Low latency may be important for real-time applications like XR. Some strategies for achieving low latency may include but are not limited to: pipeline optimization, hardware acceleration, efficient data transfer, and real-time processing. In some examples, the Lite node 105 may be designed to support real-time image processing with minimal delay.

[0055] XR and similar emerging markets are characterized by rapid advancements in hardware capabilities, particularly in camera technology. Increasing camera counts and frame rates are driving up computational demands, outpacing the capabilities of traditional software architectures.

[0056] Lite node 105, with minimal ISP processing, may be already optimized for efficiency. However, even with minimal processing, traditional software architectures still impose overhead due to per-frame control and settings synchronization.

[0057] The present disclosure describes "request-less" techniques that may further optimize the Lite node 105 by eliminating even the minimal pipeline processing and associated control overhead. For example, the Lite node 105 may operate as a high- speed image capture device, bypassing the need for constant software intervention. Eliminating software overhead may reduce the time between image capture and availability for processing, resulting in lower capture latency. The request-less techniques may more easily handle increasing camera counts and frame rates without significant performance degradation.

[0058] An example role of Lite node 105 may be to handle image capture and potentially some basic image processing tasks. The Lite node 105 may request configuration for input / output operations (IO) . This may include specifying the target buffer address where image data will be stored, along with image format and size information. A driver may fulfill this request by allocating the output buffer and providing necessary details back to the userspace (e.g., application or operating system) .

[0059] The processing of Lite node 105 for each frame may be taking too long, negatively affecting overall camera performance. This issue may manifest in higher CPU utilization and increased capture latency. The Lite node 105 may primarily perform minimal pipeline functions. This minimal ISP processing does not necessitate per-frame control or frequent synchronization of settings.

[0060] In some examples, processing circuitry (e.g., of camera processor 104, display processor 116, some other processor, or any combination of circuitry) may reduce per-frame overhead by eliminating the need for repeated buffer allocation and configuration requests. The disclosed technique may streamline the interaction between the Lite node 105 and the driver 202 (shown in FIG. 2) , focusing on efficiency and reducing overhead. The disclosed techniques may reduce the frequency of setting updates, thereby improving performance. By reusing setting buffers, the overall memory footprint of the Lite node 105 may be decreased.

[0061] In one or more examples, a device may include one or more memories configured to store one or more image frames; and processing circuitry coupled to the one or more memories and configured to perform image processing tasks, wherein to perform the image processing tasks, the processing circuitry is configured to: manage a first queue and a second queue, wherein the first queue is configured to store Input / Output (IO) settings and the second queue is configured to store Image Quality (IQ) settings, wherein the IO settings comprise one or more settings that control interactions of the device with an external environment and wherein the IQ settings comprise one or more settings that fine-tune one or more image quality parameters of the device; for each processed image frame, determine whether at least one of the IO  settings or the IQ settings have changed; and in response to determining that at least one of the IO settings or the IQ settings have changed, update at least one of the IO settings or the IQ settings for the corresponding image frame in at least one of the first queue or the second queue.

[0062] FIG. 2 illustrates “request-less” techniques for a Lite node 105, in accordance with the techniques of this disclosure. As described in more detail below, the example techniques may streamline the interaction between the Lite node 105 and the driver 202, focusing on efficiency and reducing overhead. Instead of requesting a target buffer 204 for each frame, the Lite node 105 may pass an entire queue of target buffers 204 to the driver 202 upfront.

[0063] In an aspect, the driver 202, which may be executed by CPU 106, may manage a corresponding queue of result buffers. As one example, the disclosed techniques may reduce per-frame overhead by eliminating the need for repeated buffer allocation and configuration requests.

[0064] The Lite node 105 may gain access to a shared pool of request settings. The Lite node 105 may generate settings 206 based on these requests and may provide settings 206 to the driver 202. The disclosed techniques may reduce the frequency of setting updates, optimizing performance by minimizing communication overhead. By using ProcessIO and ProcessIQsetting, the Lite node 105 may become more autonomous. The Lite node 105 may process multiple frames without constant interaction with the driver 202, thereby reducing CPU load and latency. The role of the driver 202 may shift to managing buffer queues and applying IQ settings.

[0065] In other words, eliminating per-frame requests may significantly decrease CPU load. Fewer interactions between the Lite node 105 and the driver 202, executed by CPU 106, may lead to reduced latency. Batching operations (like buffer allocation and setting updates) may improve overall throughput.

[0066] The ConfigIO queue (shown in FIG. 3) may be essentially a staging area for input / output data. For each frame, the driver 202 may retrieve the necessary IO information from the queue. The IO information may include, but is not limited to, details about the target buffer 204, image format, and size.

[0067] When the firmware 208 signals that target buffer 204 is ready, the driver 202 may return the result buffer to the Lite node 105. This buffer management may ensure a continuous flow of image data. In the example, the IQsetting queue 312 (shown in FIG. 3) may act as a repository for image quality settings. The driver 202 may store IQ  settings 206 received from the Lite node's 105 IQ modules 210 in this queue. In other words, the driver 202 may apply the IQsettings 206 to the firmware 208, adjusting image processing parameters accordingly. In the example of FIG. 2, the driver 202 may act as an intermediary between the Lite node 105 and the firmware 208, managing data flow and configuration. By maintaining these queues, the driver 202 may efficiently handle multiple frames and IQ settings, improving overall system performance. Separating IO and IQ setting management may improve code modularity and maintainability.

[0068] By batching operations and reducing per-frame overhead, the driver 202 may optimize performance. The queue-based approach may accommodate varying frame rates and IQ setting changes.

[0069] In this case, rather than performing configIO and generating IQ settings for every frame, the Lite node 105 may perform these actions only when necessary.

[0070] In an aspect, the IO data for OutputPort1 212 and OutputPort2 214 remains constant for most frames. Thus, the Lite node 105 only needs to send configIO information when there is an actual change in output configuration. The Lite node 105 does not require per-frame IQ settings control or synchronization. This implies that the IQ settings 206 are relatively static or change infrequently.

[0071] By minimizing unnecessary configIO and IQ setting updates, the Lite node 105 may reduce computational load and communication overhead.

[0072] In an aspect, this optimization may lead to better camera performance, such as lower CPU utilization and reduced latency.

[0073] For instance, lower computational activity may contribute to lower power consumption.

[0074] FIG. 3 is a diagram illustrating implementation of new ProcessIO and ProcessIQ setting functions of the Lite node 105, in accordance with the techniques of this disclosure. The ProcessIO function 302 may run only once during the initialization phase of a system. Each output port may be assigned a dedicated IO queue 304, 306 managed by the driver 202. Accordingly, the driver 202 may take full ownership of the IO queues 304, 306, handling buffer allocation, management, and returning processed images to the UMD (User Mode Driver) . In an aspect, the ProcessIQsetting function 308 may be invoked only when there is a change in the request settings.

[0075] As one non-limiting example, unlike the conventional technique, there is no need for per-frame IQ setting updates.

[0076] Also, once ProcessIO 302 and ProcessIQsetting 308 are completed, the UMD 310 may operate independently, solely focused on receiving processed images from the driver 202. By minimizing the frequency of ProcessIO 302 and ProcessIQsetting 308 calls, overall system overhead may be significantly reduced. Furthermore, fewer function calls and data transfers may lead to better camera performance, including lower CPU utilization and reduced latency. The role of UMD 310 may be streamlined, focusing solely on image processing and output.

[0077] FIG. 4 is a conceptual diagram illustrating role of a driver in managing queues, in accordance with the techniques of this disclosure. The driver 202 may serve as a central coordinator, managing queues 304, 306, 312.

[0078] The ConfigIO queue may store configuration information for input and output operations. In an aspect, the ConfigIO queue may include a separate queue 304, 306 for each output port. IQ setting queue 312 may hold image quality settings to be applied to the firmware 208.

[0079] For each frame, the driver 202 may follow the following steps. First, the driver 202 may retrieve the necessary configIO data from the ConfigIO queue (e.g. OutputPort 1 queue 304, OutputPort 2 queue 306, etc. ) . Second, the driver 202 may apply the corresponding IQ settings from the IQ setting queue 312 to the firmware 208. The firmware 208 may process the image based on the provided configuration and settings. Once the firmware 208 completes processing, the firmware 208 may signal the driver 202.

[0080] After the firmware 208 indicates that a buffer 204 is ready, the driver 202 may notify the Lite node 105.

[0081] For instance, this notification may be a simple interrupt or a more complex message, depending on the architecture of a system. The driver 202 may efficiently manage both the ConfigIO and IQsetting queues. The driver 202 may transfer configuration and setting data to the firmware 208. In an aspect, the driver 202 may ensure proper synchronization between the Lite node 105, the driver 202, and the firmware 208.

[0082] Also, the driver 202 may implement robust error handling mechanisms to address potential issues.

[0083] Advantageously, the disclosed techniques may separate the responsibilities of Lite node 105 from the lower-level hardware interactions. In addition, the disclosed techniques may allow for dynamic changes in configuration and settings. As yet another  advantage, the disclosed techniques may optimize performance by batching operations or using predictive algorithms.

[0084] In addition to problems described above, the traditional ISP hardware pipeline architecture, composed of multiple HW nodes, each containing various IQ modules, may face significant performance challenges. Typically, every frame may necessitate the execution of all HW nodes and their respective IQ modules, leading to substantial computational overhead. The time-consuming nature of IQ module execution may become a performance bottleneck, impacting frame rate and image quality.

[0085] OEMs often face a dilemma: enabling more IQ modules for enhanced image quality may result in frame drops or unstable frame rates. In one non-limiting example, the sequential nature of the pipeline, where each HW node processes the image before passing it to the next, may limit parallelism.

[0086] Some IQ modules may be computationally intensive, contributing to processing delays. Hardware limitations, such as memory bandwidth and processing power, may restrict the number of concurrently running IQ modules. The performance impact may manifest in lower frame rates, increased latency, and decreased responsiveness. To maintain acceptable frame rates, OEMs may be forced to disable certain IQ modules, compromising image quality. These performance issues may negatively impact the user experience, especially in applications demanding high frame rates and image quality (e.g., XR, gaming) .

[0087] The execution of IQ modules within an ISP pipeline may necessitate additional memory overhead. Each IQ module typically requires a buffer to store its configuration settings, intermediate results, and output data. The cumulative memory consumption of these buffers may be substantial, especially for complex IQ modules or high-resolution images. For resource-constrained devices like XR and IoT, the memory overhead associated with IQ modules may be an important factor. The execution time of IQ modules may directly impact overall pipeline latency. Complex IQ modules may introduce significant processing delays, affecting frame rate and responsiveness. When multiple IQ modules are executed sequentially, the cumulative latency may become a major performance bottleneck. Increased latency may negatively impact the user experience, particularly in applications requiring real-time processing (e.g., gaming, augmented reality) . The need to balance image quality with memory usage may create a challenging trade-off. The impact of IQ module latency on overall system performance  may be important. Excessive memory access and complex computations may increase power consumption.

[0088] FIG. 5 is a conceptual diagram that outlines a typical ISP pipeline architecture that is organized into Lite nodes 105, in accordance with the techniques of this disclosure. Each Lite node 105 may contain multiple Image Quality (IQ) modules 210 responsible for enhancing the image. Every frame that passes through the pipeline may require executing all IQ modules 210 within each Lite node 105. This per-frame execution of numerous IQ modules 210 may be computationally intensive, negatively impacting overall performance. Each IQ module 210 may require memory allocation for storing its configuration settings and potentially intermediate results. This per-frame memory allocation for IQ module 210 execution may add up, leading to increased memory consumption.

[0089] FIG. 5 also outlines the typical steps involved in executing IQ (Image Quality) processing. One or more new setting buffers may be allocated in memory to store IQ settings 206. IQ settings 206 may be generated for each IQ module 210 and may be filled into the corresponding setting buffers. The generated IQ setting buffers may be sent to the firmware 208 for execution.

[0090] Allocating new setting buffers for each frame may be wasteful, as many IQ modules 210 might reuse the same settings across multiple frames. Frequent allocations and deallocations may lead to memory fragmentation, reducing overall system performance. Generating IQ settings 206 for every frame, even when settings remain unchanged, imposes unnecessary computational costs. This overhead may significantly impact the overall frame rate and system responsiveness. Even if an IQ module 210 is disabled, its settings may still need to be generated and sent to the firmware 208 due to the shared firmware module architecture. Such inefficient handling of disabled IQ modules 210 may lead to wasted computational resources and memory usage.

[0091] When operating in high-quality or high frame rate (HFR) modes, enabling additional IQ modules 210 to enhance image quality may significantly increase the computational burden on the CPU. This increased load may lead to: heavy CPU utilization, unstable performance, and large processing delays. The CPU may become overworked as it processes the data from multiple IQ modules 210. Fluctuations in CPU load may result in inconsistent frame rates, leading to a stuttering or choppy visual experience. Increased CPU load may introduce noticeable delays between image capture and display, impacting responsiveness. Some IQ modules 210 may require complex  algorithms that are computationally intensive. Moving data between different IQ modules 210 and the CPU 106 may introduce latency. The CPU 106 may have limitations in terms of processing power and memory bandwidth. Unstable performance and increased latency may negatively impact the user experience, especially in applications like gaming or video conferencing. To maintain acceptable performance, OEMs may be forced to disable certain IQ modules 210, compromising image quality. Higher CPU utilization may lead to increased power consumption, which may be important for battery-powered devices.

[0092] The disclosed techniques may improve the performance and memory efficiency of the Lite node 105 by optimizing IQ register setting updates. Instead of executing IQ modules 210 for every frame, a threshold may be introduced. IQ modules 210 may only be executed if the input data exceeds the specified threshold, indicating a significant change requiring image enhancement. To conserve memory, the disclosed techniques propose reusing setting buffers from previous frames. If the IQ settings 206 remain unchanged or the corresponding IQ module 210 is disabled, the existing buffers may be reused, avoiding unnecessary memory allocations. The IQ settings 206 may be updated only when necessary, based on the threshold and the changes in input data. The disclosed techniques may reduce the frequency of setting updates, thereby improving performance. By reusing setting buffers, the overall memory footprint of the Lite node 105 may be decreased. The reduced frequency of IQ module 210 execution and setting updates may lead to lower CPU utilization and faster processing. The threshold-based technique may help to avoid unnecessary computations and data transfers.

[0093] FIG. 6 is a flowchart illustrating a high level ISP pipeline data flow, in accordance with the techniques of this disclosure. In some examples, processing circuitry (e.g., of camera processor 104, display processor 116, some other processor, or any combination of circuitry) may be configured to perform ISP pipeline. The processing circuitry may send a message to a corresponding Lite node 105 (602) . The Lite node 105 may loop for each IQ module 210 (604) . Next, the Lite node 105 may generate IQ setting 206 (606) . Finally, the Lite node 105 may send the generated IQ setting 206 to firmware 208 (608) .

[0094] FIG. 7 is a flowchart illustrating generation of IQ setting, in accordance with the techniques of this disclosure. For each IQ module (702) , the processing circuitry may check the IQ trigger (704) . If the IQ trigger is equal to the previous trigger based on a threshold (706, yes branch) , the processing circuitry may reuse the setting buffer of a  previous frame (708) . Otherwise (706, no branch) , the processing circuitry may allocate a new setting buffer (710) . Next, the processing circuitry may calculate new settings and may fill the setting buffer (712) . Finally, the processing circuitry may send the settings to the firmware 208. The conventional techniques always allocate a new setting buffer for each IQ module 210, while the disclosed techniques may reuse the previous buffer if the trigger has not changed significantly. Both techniques calculate new settings, but the techniques illustrated in FIG. 7 may reuse the settings of the previous frame if the trigger is stable. By reusing setting buffers, the techniques illustrated in FIG. 7 may potentially reduce memory usage, especially if the IQ triggers remain relatively stable. Reusing calculations could lead to faster processing, although this would depend on the complexity of the calculations.

[0095] FIG. 8 is a flowchart illustrating updates of IQ register settings, in accordance with the techniques of this disclosure. The processing circuitry may begin at the "HwNode Execute" block (802) , which may be the starting point for the overall system. On a first frame, all IQ modules may be executed to gather all IQ data points (804) . This data may include, but is not limited to, IQ enable / tuning region and IQ trigger information. Next, the processing circuitry may proceed to check if IQ execution is required (806) . If IQ execution is needed (block 806, yes branch) , the processing circuitry may determine if an existing setting buffer may be reused (808) . If the buffer cannot be reused (block 808, no branch) , the processing circuitry may obtain a new one (812) by entering the "IQExecution" block 810. IQ settings may be generated based on the available data (814) . The generated IQ settings may be written to the setting buffer (816) . If the buffer can be reused (block 808, yes branch) , the processing circuitry may reuse setting buffer (818) and may skip execution of block 810. Next, after reusing the setting buffer or upon completing execution of block 810 (if a new setting buffer was obtained) , the processing circuitry may apply the IQ settings to the firmware (820) .

[0096] FIG. 9 is a flowchart illustrating the conditions under which an IQ module may need to be executed and the steps involved in its execution, in accordance with the techniques of this disclosure. The processing circuitry may begin IQ execution (902) with the initial check to determine if the IQ module is enabled (904) . If IQ is not enabled (block 904, no branch) , the process may stop, and IQ does not need to execute (910) . If IQ is enabled (block 904, yes branch) , the processing circuitry may check if there is a single tuning region (906) . If it is a single tuning region (block 906, yes branch) , IQ does not need to execute (910) , and the process may stop. If it is not a single  tuning region (block 906, no branch) , the processing circuitry may check if there is a change in the IQ trigger based on a predefined threshold (908) . If there is no change (block 908, no branch) , IQ does not need to execute (910) , and the process may stop. If there is a change in the IQ trigger (block 908, yes branch) , IQ may need to execute (912) . The processing circuitry may check if the existing IQ setting buffer may be reused (914) . If the buffer cannot be reused (block 914, yes branch) , a new IQ setting buffer may be obtained, and IQ settings may be updated (916) . If the buffer can be reused (918) , the existing IQ settings may be sent to the firmware without modification (920) . In essence, this process illustrated in FIG. 9 may ensure that IQ modules are executed only when necessary based on specific conditions. The processing circuitry may optimize the process by reusing setting buffers when possible to improve efficiency.

[0097] FIG. 10 is a flowchart illustrating an example method of operation. For ease of illustration, the example techniques are described with respect to processing circuitry and one or more memories. Example of the processing circuitry includes one or combination of processors illustrated in FIG. 1. Example of the one or more memories includes buffer 110 and / or system memory 120. For instance, the one or more memories may be configured to store one or more image frames.

[0098] The processing circuitry may be configured to perform image processing tasks.

[0099] The processing circuitry may manage a first queue and a second queue, wherein the first queue is configured to store Input / Output (IO) settings and the second queue is configured to store Image Quality (IQ) settings (1002) . As used herein, the term “IO settings” refers to settings that control the interaction of the camera with an external environment. Examples of IO settings include, but are not limited to, exposure control, white balance, autofocus, data transfer, triggering, etc. As used herein, the term “IQ settings” refers to settings that fine-tune the image quality parameters of the camera. Examples of IQ settings include, but are not limited to, noise reduction, color correction, lens distortion correction, sharpness, contrast, etc. FIG. 4 is a conceptual diagram illustrating role of a driver in managing queues, in accordance with the techniques of this disclosure. The driver 202 may serve as a central coordinator, managing queues 304, 306, 312.

[0100] The processing circuitry may, for each processed image frame, determine whether at least one of the IO settings or the IQ settings have changed (1004) . As one example, if the IQ settings 206 remain unchanged or the corresponding IQ module 210  is disabled, the existing buffers may be reused, avoiding unnecessary memory allocations. The IQ settings 206 may be updated only when necessary, based on the threshold and the changes in input data.

[0101] The processing circuitry, in response to determining that at least one of the IO settings or the IQ settings have changed, may update at least one of the IO settings or the IQ settings for the corresponding image frame in at least one of the first queue or the second queue (1006) . As one non-limiting example, unlike the conventional technique, there is no need for per-frame IQ setting updates.

[0102] The following describes one or more examples in accordance with the techniques described in this disclosure.

[0103] Clause 1. A device for image processing, the device comprising: one or more memories configured to store one or more image frames; and processing circuitry coupled to the one or more memories and configured to perform image processing tasks, wherein to perform the image processing tasks, the processing circuitry is configured to: manage a first queue and a second queue, wherein the first queue is configured to store Input / Output (IO) settings and the second queue is configured to store Image Quality (IQ) settings, wherein the IO settings comprise one or more settings that control interactions of the device with an external environment and wherein the IQ settings comprise one or more settings that fine-tune one or more image quality parameters of the device; for each processed image frame, determine whether at least one of the IO settings or the IQ settings have changed; and in response to determining that at least one of the IO settings or the IQ settings have changed, update at least one of the IO settings or the IQ settings for the corresponding image frame in at least one of the first queue or the second queue.

[0104] Clause 2. The device of clause 1, wherein the image processing tasks include one or more of: converting an analog signal into a digital signal, adjusting image brightness, adjusting color accuracy, adjusting image noise, and adjusting image contrast.

[0105] Clause 3. The device of clause 2, wherein the processing circuitry configured to update at least one of the IO settings or the IQ settings is further configured to: generate one or more IO settings or generate one or more IQ settings based on one or more received requests.

[0106] Clause 4. The device of clause 1, wherein the processing circuitry is further configured to execute a driver, and wherein to manage the first queue and the second  queue, the processing circuitry is configured to maintain the first queue and the second queue based on execution of the driver.

[0107] Clause 5. The device of clause 1, wherein the processing circuitry is configured to execute one or more Image Quality (IQ) modules.

[0108] Clause 6. The device of clause 5, wherein the processing circuitry is configured to determine whether a predefined IQ trigger for the one or more IQ modules has changed based on a predefined threshold.

[0109] Clause 7. The device of clause 6, wherein the processing circuitry configured to execute the one or more IQ modules in response to determining that the predefined IQ trigger has changed.

[0110] Clause 8. The device of clause 5, wherein the processing circuit is further configured to determine whether a pre-existing buffer is available for reuse during execution of the one or more IQ modules.

[0111] Clause 9. The device of clause 1, wherein the device comprises an extended reality (XR) device.

[0112] Clause 10. A method for image processing by an image processing device, the method comprising: managing a first queue and a second queue, wherein the first queue is configured to store Input / Output (IO) settings and the second queue is configured to store Image Quality (IQ) settings, wherein the IO settings comprise one or more settings that control interactions of the image processing device with an external environment and wherein the IQ settings comprise one or more settings that fine-tune one or more image quality parameters of the image processing device; for each processed image frame, determining whether at least one of the IO settings or the IQ settings have changed; and in response to determining that at least one of the IO settings or the IQ settings have changed, updating at least one of the IO settings or the IQ settings for the corresponding image frame in at least one of the first queue or the second queue.

[0113] Clause 11. The method of clause 10, wherein the image processing device is configured to perform one or more image processing tasks and wherein the image processing tasks include one or more of: converting an analog signal into a digital signal, adjusting image brightness, adjusting color accuracy, adjusting image noise, and adjusting image contrast.

[0114] Clause 12. The method of clause 11, wherein updating at least one of the IO settings or the IQ settings further comprises: generating one or more IO settings or generating one or more IQ settings based on one or more received requests.

[0115] Clause 13. The method of clause 10, wherein the image processing device is further configured to execute a driver, and wherein to manage the first queue and the second queue, the image processing device is configured to maintain the first queue and the second queue based on execution of the driver.

[0116] Clause 14. The method of clause 10, wherein the image processing device is configured to execute one or more Image Quality (IQ) modules.

[0117] Clause 15. The method of clause 14, wherein the image processing device is configured to determine whether a predefined IQ trigger for the one or more IQ modules has changed based on a predefined threshold.

[0118] Clause 16. The method of clause 15, wherein the image processing device is further configured to execute the one or more IQ modules in response to determining that the predefined IQ trigger has changed.

[0119] Clause 17. The method of clause 14, wherein the image processing device is further configured to determine whether a pre-existing buffer is available for reuse during execution of the one or more IQ modules.

[0120] Clause 18. The method of clause 10, wherein the image processing device comprises an extended reality (XR) device.

[0121] Clause 19. Non-transitory computer-readable storage media having instructions encoded thereon, the instructions configured to cause processing circuitry to:manage a first queue and a second queue, wherein the first queue is configured to store Input / Output (IO) settings and the second queue is configured to store Image Quality (IQ) settings, wherein the IO settings comprise one or more settings that control interactions of an image processing device with an external environment and wherein the IQ settings comprise one or more settings that fine-tune one or more image quality parameters of the image processing device; for each processed image frame, determine whether at least one of the IO settings or the IQ settings have changed; and in response to determining that at least one of the IO settings or the IQ settings have changed, update at least one of the IO settings or the IQ settings for the corresponding image frame in at least one of the first queue or the second queue.

[0122] Clause 20. The non-transitory computer-readable storage media of clause 19, wherein the processing circuitry is configured to perform one or more image processing  tasks and wherein the image processing tasks include one or more of: converting an analog signal into a digital signal, adjusting image brightness, adjusting color accuracy, adjusting image noise, and adjusting image contrast.

[0123] In one or more examples, the functions described may be implemented in hardware, software, firmware, or any combination thereof. If implemented in software, the functions may be stored on or transmitted over, as one or more instructions or code, a computer-readable medium and executed by a hardware-based processing unit. Computer-readable media may include computer-readable storage media, which corresponds to a tangible medium such as data storage media. In this manner, computer-readable media generally may correspond to tangible computer-readable storage media which is non-transitory. Data storage media may be any available media that can be accessed by one or more computers or one or more processors to retrieve instructions, code and / or data structures for implementation of the techniques described in this disclosure. A computer program product may include a computer-readable medium.

[0124] By way of example, and not limitation, such computer-readable storage media can comprise RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage, or other magnetic storage devices, flash memory, or any other medium that can be used to store desired program code in the form of instructions or data structures and that can be accessed by a computer. It should be understood that computer-readable storage media and data storage media do not include carrier waves, signals, or other transient media, but are instead directed to non-transient, tangible storage media. Disk and disc, as used herein, includes compact disc (CD) , laser disc, optical disc, digital versatile disc (DVD) , floppy disk and Blu-ray disc, where disks usually reproduce data magnetically, while discs reproduce data optically with lasers. Combinations of the above should also be included within the scope of computer-readable media.

[0125] Instructions may be executed by one or more processors, such as one or more digital signal processors (DSPs) , general purpose microprocessors, application specific integrated circuits (ASICs) , field programmable logic arrays (FPGAs) , or other equivalent integrated or discrete logic circuitry. Accordingly, the term “processor, ” as used herein may refer to any of the foregoing structure or any other structure suitable for implementation of the techniques described herein. In addition, in some aspects, the functionality described herein may be provided within dedicated hardware and / or software modules configured for encoding and decoding, or incorporated in a combined  codec. Also, the techniques could be fully implemented in one or more circuits or logic elements.

[0126] The techniques of this disclosure may be implemented in a wide variety of devices or apparatuses, including a wireless handset, an integrated circuit (IC) or a set of ICs (e.g., a chip set) . Various components, modules, or units are described in this disclosure to emphasize functional aspects of devices configured to perform the disclosed techniques, but do not necessarily require realization by different hardware units. Rather, as described above, various units may be combined in a codec hardware unit or provided by a collection of interoperative hardware units, including one or more processors as described above, in conjunction with suitable software and / or firmware.

[0127] Various examples have been described. These and other examples are within the scope of the following claims.

Claims

1.A device for image processing, the device comprising:one or more memories configured to store one or more image frames; andprocessing circuitry coupled to the one or more memories and configured to perform image processing tasks, wherein to perform the image processing tasks, the processing circuitry is configured to:manage a first queue and a second queue, wherein the first queue is configured to store Input / Output (IO) settings and the second queue is configured to store Image Quality (IQ) settings, wherein the IO settings comprise one or more settings that control interactions of the device with an external environment and wherein the IQ settings comprise one or more settings that fine-tune one or more image quality parameters of the device;for each processed image frame, determine whether at least one of the IO settings or the IQ settings have changed; andin response to determining that at least one of the IO settings or the IQ settings have changed, update at least one of the IO settings or the IQ settings for the corresponding image frame in at least one of the first queue or the second queue.2.The device of claim 1, wherein the image processing tasks include one or more of:converting an analog signal into a digital signal, adjusting image brightness, adjusting color accuracy, adjusting image noise, and adjusting image contrast.3.The device of claim 2, wherein the processing circuitry configured to update at least one of the IO settings or the IQ settings is further configured to:generate one or more IO settings or generate one or more IQ settings based on one or more received requests.4.The device of claim 1, wherein the processing circuitry is further configured to execute a driver, and wherein to manage the first queue and the second queue, the processing circuitry is configured to maintain the first queue and the second queue based on execution of the driver.5.The device of claim 1, wherein the processing circuitry is configured to execute one or more Image Quality (IQ) modules.6.The device of claim 5, wherein the processing circuitry is configured to determine whether a predefined IQ trigger for the one or more IQ modules has changed based on a predefined threshold.7.The device of claim 6, wherein the processing circuitry configured to execute the one or more IQ modules in response to determining that the predefined IQ trigger has changed.8.The device of claim 5, wherein the processing circuit is further configured to determine whether a pre-existing buffer is available for reuse during execution of the one or more IQ modules.9.The device of claim 1, wherein the device comprises an extended reality (XR) device.10.A method for image processing by an image processing device, the method comprising:managing a first queue and a second queue, wherein the first queue is configured to store Input / Output (IO) settings and the second queue is configured to store Image Quality (IQ) settings, wherein the IO settings comprise one or more settings that control interactions of the image processing device with an external environment and wherein the IQ settings comprise one or more settings that fine-tune one or more image quality parameters of the image processing device;for each processed image frame, determining whether at least one of the IO settings or the IQ settings have changed; andin response to determining that at least one of the IO settings or the IQ settings have changed, updating at least one of the IO settings or the IQ settings for the corresponding image frame in at least one of the first queue or the second queue.11.The method of claim 10, wherein the image processing device is configured to perform one or more image processing tasks and wherein the image processing tasks include one or more of: converting an analog signal into a digital signal, adjusting image brightness, adjusting color accuracy, adjusting image noise, and adjusting image contrast.12.The method of claim 11, wherein updating at least one of the IO settings or the IQ settings further comprises:generating one or more IO settings or generating one or more IQ settings based on one or more received requests.13.The method of claim 10, wherein the image processing device is further configured to execute a driver, and wherein to manage the first queue and the second queue, the image processing device is configured to maintain the first queue and the second queue based on execution of the driver.14.The method of claim 10, wherein the image processing device is configured to execute one or more Image Quality (IQ) modules.15.The method of claim 14, wherein the image processing device is configured to determine whether a predefined IQ trigger for the one or more IQ modules has changed based on a predefined threshold.16.The method of claim 15, wherein the image processing device is further configured to execute the one or more IQ modules in response to determining that the predefined IQ trigger has changed.17.The method of claim 14, wherein the image processing device is further configured to determine whether a pre-existing buffer is available for reuse during execution of the one or more IQ modules.18.The method of claim 10, wherein the image processing device comprises an extended reality (XR) device.19.Non-transitory computer-readable storage media having instructions encoded thereon, the instructions configured to cause processing circuitry to:manage a first queue and a second queue, wherein the first queue is configured to store Input / Output (IO) settings and the second queue is configured to store Image Quality (IQ) settings, wherein the IO settings comprise one or more settings that control interactions of an image processing device with an external environment and wherein the IQ settings comprise one or more settings that fine-tune one or more image quality parameters of the image processing device;for each processed image frame, determine whether at least one of the IO settings or the IQ settings have changed; andin response to determining that at least one of the IO settings or the IQ settings have changed, update at least one of the IO settings or the IQ settings for the corresponding image frame in at least one of the first queue or the second queue.20.The non-transitory computer-readable storage media of claim 19, wherein the processing circuitry is configured to perform one or more image processing tasks and wherein the image processing tasks include one or more of: converting an analog signal into a digital signal, adjusting image brightness, adjusting color accuracy, adjusting image noise, and adjusting image contrast.

Images