{"id":98845,"date":"2018-05-28T07:00:00","date_gmt":"2018-05-28T21:00:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/oldnewthing\/?p=98845"},"modified":"2019-03-13T00:44:26","modified_gmt":"2019-03-13T07:44:26","slug":"20180528-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20180528-00\/?p=98845","title":{"rendered":"How are BitBlt<\/CODE> raster opcodes calculated?"},"content":{"rendered":"

Commenter R P asks what the low-order 16 bits of the BitBlt<\/code> raster opcodes mean<\/a>. <\/p>\n

The documentation explains<\/a> that the high-order 16 bits of the raster opcode are the zero-extended 8-bit value that represents the result of the raster operation given the 8 combinations of three binary inputs (pattern, source, and destination). This is the easy part to understand. <\/p>\n

The documentation also says that the low-order 16 bits are an operation code, but gives no information as to how the operation code is determined. <\/p>\n

Okay, let’s dig through the history. <\/p>\n

Initially, the BitBlt<\/code> raster opcodes were only 16-bit values, consisting of the operation codes. The higher-order 16 bits were added later because it turns out that people preferred table lookups to parsing operation codes. <\/p>\n

Okay, that’s enough beating around the bush. How do I parse the operation codes? <\/p>\n

The operation code is interpreted as follows: <\/p>\n\n\n\n
15<\/th>\n14<\/th>\n13<\/th>\n12<\/th>\n11<\/th>\n10<\/th>\n 9<\/th>\n 8<\/th>\n 7<\/th>\n 6<\/th>\n 5<\/th>\n 4<\/th>\n 3<\/th>\n 2<\/th>\n 1<\/th>\n 0<\/th>\n<\/tr>\n
op5<\/td>\nop4<\/td>\nop3<\/td>\nop2<\/td>\nop1<\/td>\nop6<\/td>\ntemplate<\/td>\nbias<\/td>\n<\/tr>\n<\/table>\n

Operations 1 through 5 select one of the following logical operations: <\/p>\n\n\n\n\n\n\n
Value<\/th>\nOperation<\/th>\nAbbreviation<\/th>\n<\/tr>\n
0<\/td>\nnot<\/td>\nn<\/td>\n<\/tr>\n
1<\/td>\nexclusive or<\/td>\nx<\/td>\n<\/tr>\n
2<\/td>\nor<\/td>\no<\/td>\n<\/tr>\n
3<\/td>\nand<\/td>\na<\/td>\n<\/tr>\n<\/table>\n

Operation 6 encodes an optional final not<\/i> operation. <\/p>\n\n\n\n\n
Value<\/th>\nOperation<\/th>\nAbbreviation<\/th>\n<\/tr>\n
0<\/td>\nno operation<\/td>\n <\/td>\n<\/tr>\n
1<\/td>\nnot<\/td>\nn<\/td>\n<\/tr>\n<\/table>\n

The operations imply the number of input parameters required. Each binary operation pops two arguments off the stack and pushes the result back onto the stack, for a net reduction of one. The unary not<\/i> operation pops one argument off the stack and pushes the result back onto the stack, for no net change. And when we’re finished, we want one final result on the stack. Therefore, the number of items that need to be placed onto the stack is one more than the number of binary operations. <\/p>\n

The template and bias tell you what those parameters are. First, the template selects one of the following sequences of elements. <\/p>\n\n\n\n\n\n\n\n\n\n\n
Value<\/th>\nTemplate<\/th>\n<\/tr>\n
0<\/td>\nSPDD<\/td>\n<\/tr>\n
1<\/td>\nSPD<\/td>\n<\/tr>\n
2<\/td>\nSDP<\/td>\n<\/tr>\n
3<\/td>\n(not used)<\/td>\n<\/tr>\n
4<\/td>\n(not used)<\/td>\n<\/tr>\n
5<\/td>\nSSP*DS<\/td>\n<\/tr>\n
6<\/td>\nSSP*PDS<\/td>\n<\/tr>\n
7<\/td>\nSSD*PDS<\/td>\n<\/tr>\n<\/table>\n

Two of the templates are not currently used and are reserved for future expansion. <\/p>\n

The bias specifies how many initial template elements to ignore. After that, take the template elements until you have consumed one more than the number of binary operations. Also take the asterisk, if you encounter one. And if you run out of template elements, then start over from the beginning. <\/p>\n

Okay, now we put all the pieces together. <\/p>\n