System for emulating graphics operations

• US 8,044,963 B2
• Filed: 10/15/2010
• Issued: 10/25/2011
• Est. Priority Date: 04/16/2004
• Status: Expired due to Term

• Current Assignee: Apple Inc.
• Original Assignee: Apple Inc.
• Inventors: Harper, John
• Primary Examiner(s): Wu; Xiao
• Assistant Examiner(s): McDowell, Jr.; Maurice L
• Application Number:
  US12/905,359
• Publication Number:
  US 20110074821A1
• Time in Patent Office: 375 Days
• Field of Search: 345/502
• US Class Current: 345/502
• CPC Class Codes: G06T 1/20 Processor architectures; Processor configuration, e.g. pipelining

Abstract

Disclosed is a system for producing images including emulation techniques using multiple processors. The system provides for emulation of graphics processing resources such that a central processing unit may provide graphics support. Disclosed embodiments include emulation of selected graphics calls as well as emulation of a programmable graphics processor for compatibility with systems having no compatible GPU.

Claims

1. A method of creating an image in a computer system, the method comprising:

receiving, by a first process executing from a memory in a first computer system, a request to render a polygon, the request associated with a graphics processing unit (GPU) program representing the polygon;

converting the GPU program into a central processing unit (CPU) program;

dividing the CPU program into two or more portions, at least one portion representing a section of the polygon;

selecting the at least one portion for rendering;

selecting a first scan line in the at least one portion for rendering, the first scan line comprising a plurality of pixels;

rendering, by a CPU, at least a portion of the scan line in increments of L pixels; and

interpolating, by the CPU, texture values for at least some of the pixels,

wherein the GPU program is represented as a plurality of nodes and a plurality of links, and wherein each of the plurality of nodes represents a programmable GPU fragment program and each of the plurality of links represents an intermediary result and storage necessary to hold the intermediary result.

2. The method of claim 1 wherein the GPU program is further represented as a graph comprising the plurality of nodes and the plurality of links.

3. The method of claim 2 wherein the graph is optimized before the act of converting.

4. The method of claim 3 wherein the act of optimizing comprises the act of performing a global intersection of a domain of definition (DOD) and a region of interest (ROI).

5. The method of claim 3 wherein the act of optimizing comprises combining fragment programs.

6. The method of claim 5 further comprising the act of checking a cache memory to determine if a combined fragment program may be retrieved from a memory.

7. The method of claim 3 wherein the act of optimizing comprises attempting to combine fragment programs.

8. The method of claim 1 wherein the CPU program comprises a unrolled version of a main loop program, for which a single execution of the unrolled version of the main loop program expresses N iterations of the main loop program.

9. The method of claim 8 wherein the main loop processes L number of pixels by running the main loop program L/N times.

10. The method of claim 9 wherein the CPU program comprises a routine for processing one pixel, the processing analogous to that done in the main loop, and the method further comprising running the routine for processing one pixel a number of times to process any pixels in the first scan line not yet processed.

11. The method of claim 9 wherein the CPU program performs independent texture lookups for each group of L pixels before rendering any of the L pixels.

12. The method of claim 9 wherein the CPU program performs independent texture lookups for all of the pixels in the at least one portion before rendering any pixels in the at least one portion.

13. The method of claim 9 wherein function calls are placed in the CPU program for each dependent texture reference, the function calls performing a texture lookup during the act of rendering.

14. The method of claim 8 wherein a second scan line in the at least one portion has a number of pixels S that is E pixels greater than the greatest multiple of L that is less than S, the method further comprising:

executing, by the CPU, the main loop on successive groups of L pixels until there are E pixels left to process; and

adjusting a variable in the main loop to cause the main loop to run R number of times, wherein the act of running the main loop R times processes the E pixels left to process.

15. The method of claim 14 further comprising executing the adjusted main loop.

16. The method of claim 8 wherein the CPU program comprises a routine for processing a second scan line from the at least one portion one pixel at a time, the processing analogous to that done in the main loop, the second scan line having a number of pixels S that is E pixels greater than the greatest multiple of L that is less than S, the method further comprising:

running, by the CPU, the code in the main loop on successive groups of L pixels in the second scan line until there are E pixels left to process; and

running the routine for processing one pixel E times, once for each of the E remaining pixels in the second scan line.

17. The method of claim 1 where the section comprises a slab.

18. The method of claim 1 where the section comprises one or more triangles.

19. The method of claim 1 further comprising:

selecting a second portion representing a second section of the polygon; and

rendering the second portion by a second CPU.

20. The method of claim 1 further comprising:

selecting a second scan line in the at least one portion; and

rendering, by a second CPU, at least a portion of the second scan line in increments of L number of pixels.

21. A non-transitory computer-readable medium having computer executable instructions stored thereon for performing the method recited in claim 1.

22. A method of creating a result image, the method comprising:

receiving a request to render a result image;

creating an object in a memory representing the result image, the object comprising one or more programmable graphics processing unit (GPU) fragment programs for applying at least one filter to at least one image; and

executing, by a central processing unit (CPU) emulating a programmable GPU, the object to render the result image,

wherein the object is represented as a plurality of nodes and a plurality of links, and wherein each of the plurality of nodes represents a programmable GPU fragment program and each of the plurality of links represents an intermediary result and storage necessary to hold the intermediary result.

23. The method of claim 22 wherein the at least one filter comprises a high-level filter.

24. The method of claim 22 wherein the object comprises a high-level graph.

25. The method of claim 22 wherein the object comprises a low level graph.

26. The method of claim 22 wherein the act of executing is performed by a virtual machine.

27. The method of claim 26 wherein the virtual machine comprises a byte-code virtual machine.

28. A non-transitory computer-readable medium having computer executable instructions stored thereon for performing the method recited in claim 22.