From a technical standpoint, colors are 32 bits of information ordered as AAAAAAAARRRRRRRRGGGGGGGGBBBBBBBB where the A's contain the alpha value, the R's are the red value, G's are green, and B's are blue. Each component is 8 bits (a number between 0 and 255). These values can be manipulated with  bit shifting .

1. int bits = 5; //set this to whatever you want
2. int mask;
3. switch(bits){
4.   case 1:
5.     mask = 0x01;
6.     break;
7.   case 2:
8.     mask = 0x03;
9.     break;
10.   case 3:
11.     mask = 0x07;
12.     break;
13.   case 4:
14.     mask = 0x0F;
15.     break;
16.   case 5:
17.     mask = 0x1F;
18.     break;
19.   case 6:
20.     mask = 0x3F;
21.     break;
22.   case 7:
23.     mask = 0x7F;
24.     break;
25.   case 8:
26.     mask = 0xFF;
27. }
28. 
    
29. //actually, this is pretty redundant, but I show it for clarity
30. // more effective would be to simply change the above masks to
31. // 0x01010101, 0x03030303, 0x07070707, ..., 0xFFFFFFFF
32. mask += (mask<<8) + (mask<<16) + (mask<<24);

1. for (int i = 0; i < pixels.length; ++i){
2.   pixels[i] = pixels[i] & mask;
3. }

1. int pskip = 4;
2. // your stuff
3. 
   
4. void setup(){
5.   // your stuff
6.   loadPixels(); // sets up the pixel array
7. }
8. 
   
9. void draw(){
10.   // do all the things you want to do with opencv here, then add:
11.   opencv.loadPixels();
12.   for (int i = 0; i < width; i += pskip){
13.     for (int j = 0; j < height; j += pskip){
14.       for (int k = 0; k < pskip; ++k){
15.         for (int l = 0; l < pskip; ++l){
16.           pixels[i+k + (j+l)*width] = opencv.pixels[i + j*width] & mask;
17.         }
18.       }
19.     }
20.   }
21. 
    
22.   updatePixels(); 
23. }

I tried something like your masking code and it works nicely but it doesn't seem to ever reach full brightness (value 255). I had used the /=255 to *=256 trick in my older code to get around this problem (it seemed like having a value of 256 was not a problem somehow). How would you increase the brightness on this while still keeping pure black (value 0)?

1. pixels[i+j*width+k+l*width] = (pixels[i+j*width]&bitMask)+((pixels[i+j*width]>>bitsPerChannel)&(~bitMask));

1. int bitsPerChannel = 3;
2. int pixelSkipper = 4;
3. int bitMask;
4. 
   
5. import hypermedia.video.*;
6. OpenCV opencv;
7. 
   
8. void setup() {
9.   size(640, 480, P2D);
10.   opencv = new OpenCV(this);
11.   opencv.capture(width, height);
12.   bitMask = 0x100-(0x1<<0x8-bitsPerChannel);
13.   bitMask += (bitMask<<0x8)+(bitMask<<0x10);
14. }
15. 
    
16. void draw() {
17.   loadPixels();
18.   opencv.read();
19.   set(0, 0, opencv.image());
20. 
    
21.   int p;
22.   if (bitsPerPixel >= 4){
23.     for (int i = 0; i < width; i += pixelSkipper) {
24.       for (int j = 0; j < height; j += pixelSkipper) {
25.         p = (pixels[i+j*width]&bitMask)+((pixels[i+j*width]>>bitsPerChannel)&(~bitMask));
26.         for (int k = 0; k < pixelSkipper; k++) {
27.             Arrays.fill(pixels, i+(j+k)*width, i + pixelSkipper + (j+k)*width, p);
28.           }
29.         }
30.       }
31.     }
32.   } else if (bitsPerPixel == 3){
33.     for (int i = 0; i < width; i += pixelSkipper) {
34.       for (int j = 0; j < height; j += pixelSkipper) {
35.         p = ((pixels[i+j*width]&bitMask) >> 5) * 0x24 + (((pixels[i+j*width]&bitMask) >> 7) & 0x010101);
36.         for (int k = 0; k < pixelSkipper; k++) {
37.             Arrays.fill(pixels, i+(j+k)*width, i + pixelSkipper + (j+k)*width, p);
38.           }
39.         }
40.       }
41.     }
42.   } else if (bitsPerPixel == 2){
43.     for (int i = 0; i < width; i += pixelSkipper) {
44.       for (int j = 0; j < height; j += pixelSkipper) {
45.         p = ((pixels[i+j*width]&bitMask) >> 6) * 0x55;
46.         for (int k = 0; k < pixelSkipper; k++) {
47.             Arrays.fill(pixels, i+(j+k)*width, i + pixelSkipper + (j+k)*width, p);
48.           }
49.         }
50.       }
51.     }
52.   } else if (bitsPerPixel == 1){
53.     for (int i = 0; i < width; i += pixelSkipper) {
54.       for (int j = 0; j < height; j += pixelSkipper) {
55.         p = ((pixels[i+j*width]&bitMask) >> 7) * 0xFF;
56.         for (int k = 0; k < pixelSkipper; k++) {
57.             Arrays.fill(pixels, i+(j+k)*width, i + pixelSkipper + (j+k)*width, p);
58.           }
59.         }
60.       }
61.     }
62.   }
63.   updatePixels();
64. }