/* static */
void
OutputView::SetInitialFormat(const int32 &width, const int32 &height,
const color_space &colorSpace, const int32 &fieldRate,
media_format &initialFormat)
{
memset(&initialFormat, 0, sizeof(media_format));
initialFormat.type = B_MEDIA_RAW_VIDEO;
initialFormat.u.raw_video.display.line_width = width;
initialFormat.u.raw_video.display.line_count = height;
initialFormat.u.raw_video.last_active = initialFormat.u.raw_video.display.line_count - 1;
size_t pixelChunk;
size_t rowAlign;
size_t pixelPerChunk;
get_pixel_size_for(colorSpace, &pixelChunk, &rowAlign, &pixelPerChunk);
initialFormat.u.raw_video.display.bytes_per_row = width * rowAlign;
initialFormat.u.raw_video.display.format = colorSpace;
initialFormat.u.raw_video.interlace = 1;
// TODO: Calculate this in some way
initialFormat.u.raw_video.field_rate = fieldRate; //Frames per second
initialFormat.u.raw_video.pixel_width_aspect = 1; // square pixels
initialFormat.u.raw_video.pixel_height_aspect = 1;
}
media_format
Controller::_ComputeMediaFormat(const int32 &width, const int32 &height,
const color_space &colorSpace, const int32 &fieldRate)
{
media_format initialFormat;
memset(&initialFormat, 0, sizeof(media_format));
initialFormat.type = B_MEDIA_RAW_VIDEO;
initialFormat.u.raw_video.display.line_width = width;
initialFormat.u.raw_video.display.line_count = height;
initialFormat.u.raw_video.last_active = initialFormat.u.raw_video.display.line_count - 1;
size_t pixelChunk;
size_t rowAlign;
size_t pixelPerChunk;
status_t status;
status = get_pixel_size_for(colorSpace, &pixelChunk,
&rowAlign, &pixelPerChunk);
if (status != B_OK)
throw status;
initialFormat.u.raw_video.display.bytes_per_row = width * rowAlign;
initialFormat.u.raw_video.display.format = colorSpace;
initialFormat.u.raw_video.interlace = 1;
initialFormat.u.raw_video.field_rate = fieldRate; // Frames per second, overwritten later
initialFormat.u.raw_video.pixel_width_aspect = 1; // square pixels
initialFormat.u.raw_video.pixel_height_aspect = 1;
return initialFormat;
}
status_t
dp_get_pixel_size_for(color_space space, size_t *pixelChunk,
size_t *rowAlignment, size_t *pixelsPerChunk)
{
status_t result = get_pixel_size_for(space, pixelChunk, NULL,
pixelsPerChunk);
if ((space == B_RGB32) || (space == B_RGBA32) || (space == B_RGB32_BIG)
|| (space == B_RGBA32_BIG)) {
*pixelChunk = 3;
}
return result;
}
bool
PictureTest::IsSame(BBitmap *bitmap1, BBitmap *bitmap2, BString &reason)
{
if (bitmap1->ColorSpace() != bitmap2->ColorSpace()) {
reason = "ColorSpace() differs";
return false;
}
if (bitmap1->BitsLength() != bitmap2->BitsLength()) {
reason = "BitsLength() differs";
return false;
}
size_t rowAlignment;
size_t pixelChunk;
size_t pixelsPerChunk;
if (get_pixel_size_for(bitmap1->ColorSpace(), &pixelChunk, &rowAlignment,
&pixelsPerChunk) != B_OK) {
reason = "get_pixel_size_for() not supported for this color space";
return false;
}
if (pixelsPerChunk != 1) {
reason = "Unsupported color_space; IsSame(...) supports 1 pixels per chunk only";
return false;
}
int32 bpp = (int32)pixelChunk;
uint8* row1 = (uint8*)bitmap1->Bits();
uint8* row2 = (uint8*)bitmap2->Bits();
int32 bpr = bitmap1->BytesPerRow();
int32 width = bitmap1->Bounds().IntegerWidth() + 1;
int32 height = bitmap1->Bounds().IntegerHeight() + 1;
for (int y = 0; y < height; y ++, row1 += bpr, row2 += bpr) {
uint8* pixel1 = row1;
uint8* pixel2 = row2;
for (int x = 0; x < width; x ++, pixel1 += bpp, pixel2 += bpp) {
if (memcmp(pixel1, pixel2, bpp) != 0) {
setMismatchReason(x, y, pixel1, pixel2, bpp, reason);
return false;
}
}
}
reason = "";
return true;
}
void
MesaSoftwareRenderer::_ClearFront(gl_context* ctx)
{
CALLED();
MesaSoftwareRenderer* mr = (MesaSoftwareRenderer*)ctx->DriverCtx;
BGLView* bglview = mr->GLView();
assert(bglview);
BBitmap* bitmap = mr->fBitmap;
assert(bitmap);
GLuint* start = (GLuint*)bitmap->Bits();
size_t pixelSize = 0;
get_pixel_size_for(bitmap->ColorSpace(), &pixelSize, NULL, NULL);
const GLuint* clearPixelPtr = (const GLuint*)mr->fClearColor;
const GLuint clearPixel = B_LENDIAN_TO_HOST_INT32(*clearPixelPtr);
int x = ctx->DrawBuffer->_Xmin;
int y = ctx->DrawBuffer->_Ymin;
uint32 width = ctx->DrawBuffer->_Xmax - x;
uint32 height = ctx->DrawBuffer->_Ymax - y;
GLboolean all = (width == ctx->DrawBuffer->Width
&& height == ctx->DrawBuffer->Height);
if (all) {
const int numPixels = mr->fWidth * mr->fHeight;
if (clearPixel == 0) {
memset(start, 0, numPixels * pixelSize);
} else {
for (int i = 0; i < numPixels; i++) {
start[i] = clearPixel;
}
}
} else {
// XXX untested
start += y * mr->fWidth + x;
for (uint32 i = 0; i < height; i++) {
for (uint32 j = 0; j < width; j++) {
start[j] = clearPixel;
}
start += mr->fWidth;
}
}
}
