Can I have lower color bit depth in sample buffer than target framebuffer? I´m looking into uses of high amount of samples in multisampling. If I have an RGBA8 framebuffer and render to it using multisample with many samples, say 32, dithering on per-sample level should yield a reasonably accurate 8-bit color from the 32 samples in 4-bit color when resolved. The spec (4.5) seems a bit scary though (glBlitFrameBuffer): 


  If the read framebuffer is multisampled (its effective value of
  SAMPLE_BUFFERS is one) and the draw framebuffer is not (its value of SAMPLE_BUFFERS is 
  zero), the samples corresponding to each pixel location in the source are converted
  to a single sample before being written to the destination. filter is
  ignored. If the source formats are integer types or stencil values, a
  single sample’s value is selected for each pixel. If the source
  formats are ﬂoating-point or normalized types, the sample values for
  each pixel are resolved in an implementation-dependent manner. If the
  source formats are depth values, sample values are resolved in an
  implementation-dependent manner where the result will be between the
  minimum and maximum depth values in the pixel.


What does that even mean? 

Is there a way to do it in a cross implementation defined manner?
What does that even mean? 


It means that multisampling is resolved.

A multisample framebuffer contains multiple samples for each pixel. The combination of samples represents the color of that pixel. The process of converting from multiple samples to a single color is multisample resolving.

By blitting from a multisampled buffer to a non-multisampled buffer, you are telling OpenGL to resolve each pixel's worth of samples into a single sample. Typically, this is done by adding all the sample values up and dividing by the number of samples, but implementations can take weighted averages or something else, depending on the precise nature of each sample.

Generally speaking, it's best that you let the implementation do its job.


  Is there a way to do it in a cross implementation defined manner?


You can program your own resolution by rendering with a multisample texture to a non-multisampled texture. In the FS, you read each fragment's worth of pixels, doing whatever operation you would like to combine them.

But that's probably not going to be as fast as letting the hardware do the multisample resolve itself.