/*
 * GraphicsDriver.cpp
 * Copyright 1999-2000 Y.Takagi. All Rights Reserved.
 */

#include <algorithm>
#include <cstdio>
#include <cstdarg>

#include <Alert.h>
#include <Bitmap.h>
#include <Debug.h>
#include <Message.h>
#include <PrintJob.h>
#include <Region.h>
#include <TextControl.h>
#include <TextControl.h>
#include <StopWatch.h>
#include <View.h>
#include <Directory.h>
#include <File.h>

#include "GraphicsDriver.h"
#include "PrintProcess.h"
#include "JobData.h"
#include "PrinterData.h"
#include "PrinterCap.h"
#include "Preview.h"
#include "Transport.h"
#include "ValidRect.h"
#include "DbgMsg.h"


using namespace std;


// Measure printJob() time. Either true or false.
#define MEASURE_PRINT_JOB_TIME false


GraphicsDriver::GraphicsDriver(BMessage* message, PrinterData* printerData,
        const PrinterCap* printerCap)
        :
        fMessage(message),
        fView(NULL),
        fBitmap(NULL),
        fRotatedBitmap(NULL),
        fTransport(NULL),
        fOrgJobData(NULL),
        fRealJobData(NULL),
        fPrinterData(printerData),
        fPrinterCap(printerCap),
        fSpoolMetaData(NULL),
        fPageWidth(0),
        fPageHeight(0),
        fBandWidth(0),
        fBandHeight(0),
        fPixelDepth(0),
        fBandCount(0),
        fInternalCopies(0),
        fPageCount(0),
        fStatusWindow(NULL)
{
}


GraphicsDriver::~GraphicsDriver()
{
}


static BRect
RotateRect(BRect rect)
{
        BRect rotated(rect.top, rect.left, rect.bottom, rect.right);
        return rotated;
}


bool
GraphicsDriver::_SetupData(BFile* spoolFile)
{
        if (fOrgJobData != NULL) {
                // already initialized
                return true;
        }

        print_file_header pfh;
        spoolFile->Seek(0, SEEK_SET);
        spoolFile->Read(&pfh, sizeof(pfh));

        DBGMSG(("print_file_header::version = 0x%x\n",  pfh.version));
        DBGMSG(("print_file_header::page_count = %d\n", pfh.page_count));
        DBGMSG(("print_file_header::first_page = 0x%x\n", (int)pfh.first_page));

        if (pfh.page_count <= 0) {
                // nothing to print
                return false;
        }

        fPageCount = (uint32) pfh.page_count;
        BMessage *msg = new BMessage();
        msg->Unflatten(spoolFile);
        fOrgJobData = new JobData(msg, fPrinterCap, JobData::kJobSettings);
        DUMP_BMESSAGE(msg);
        delete msg;

        fRealJobData = new JobData(*fOrgJobData);

        switch (fOrgJobData->GetNup()) {
        case 2:
        case 8:
        case 32:
        case 128:
                fRealJobData->SetPrintableRect(
                        RotateRect(fOrgJobData->GetPrintableRect()));
                fRealJobData->SetScaledPrintableRect(
                        RotateRect(fOrgJobData->GetScaledPrintableRect()));
                fRealJobData->SetPhysicalRect(
                        RotateRect(fOrgJobData->GetPhysicalRect()));
                fRealJobData->SetScaledPhysicalRect(
                        RotateRect(fOrgJobData->GetScaledPhysicalRect()));

                if (JobData::kPortrait == fOrgJobData->GetOrientation())
                        fRealJobData->SetOrientation(JobData::kLandscape);
                else
                        fRealJobData->SetOrientation(JobData::kPortrait);
                break;
        }

        if (fOrgJobData->GetCollate() && fPageCount > 1) {
                fRealJobData->SetCopies(1);
                fInternalCopies = fOrgJobData->GetCopies();
        } else {
                fInternalCopies = 1;
        }

        fSpoolMetaData = new SpoolMetaData(spoolFile);
        return true;
}


void
GraphicsDriver::_CleanupData()
{
        delete fRealJobData;
        delete fOrgJobData;
        delete fSpoolMetaData;
        fRealJobData   = NULL;
        fOrgJobData    = NULL;
        fSpoolMetaData = NULL;
}


void
GraphicsDriver::_SetupBitmap()
{
        fPixelDepth = color_space2pixel_depth(fOrgJobData->GetSurfaceType());

        fPageWidth  = (fRealJobData->GetPhysicalRect().IntegerWidth()
                * fOrgJobData->GetXres() + 71) / 72;
        fPageHeight = (fRealJobData->GetPhysicalRect().IntegerHeight()
                * fOrgJobData->GetYres() + 71) / 72;

        fBitmap = NULL;
        fRotatedBitmap = NULL;
        BRect rect;

        for (fBandCount = 1; fBandCount < 256; fBandCount++) {
                if (_NeedRotateBitmapBand()) {
                        fBandWidth  = (fPageWidth + fBandCount - 1) / fBandCount;
                        fBandHeight = fPageHeight;
                } else {
                        fBandWidth  = fPageWidth;
                        fBandHeight = (fPageHeight + fBandCount - 1) / fBandCount;
                }

                rect.Set(0, 0, fBandWidth - 1, fBandHeight - 1);
                fBitmap = new(std::nothrow) BBitmap(rect, fOrgJobData->GetSurfaceType(),
                        true);
                if (fBitmap == NULL || fBitmap->InitCheck() != B_OK) {
                        delete fBitmap;
                        fBitmap = NULL;
                        // Try with smaller bands
                        continue;
                }

                if (_NeedRotateBitmapBand()) {
                        BRect rotatedRect(0, 0, rect.bottom, rect.right);
                        delete fRotatedBitmap;
                        fRotatedBitmap = new(std::nothrow) BBitmap(rotatedRect,
                                fOrgJobData->GetSurfaceType(), false);
                        if (fRotatedBitmap == NULL || fRotatedBitmap->InitCheck() != B_OK) {
                                delete fBitmap;
                                fBitmap = NULL;
                                delete fRotatedBitmap;
                                fRotatedBitmap = NULL;

                                // Try with smaller bands
                                continue;
                        }
                }

                // If we get here, all needed allocations have succeeded, we can safely
                // go ahead.
                break;
        };

        if (fBitmap == NULL) {
                debugger("Failed to allocate bitmaps for print rasterization");
                return;
        }

        fView = new BView(rect, "", B_FOLLOW_ALL, B_WILL_DRAW);
        fBitmap->AddChild(fView);

        DBGMSG(("****************\n"));
        DBGMSG(("page_width  = %d\n", fPageWidth));
        DBGMSG(("page_height = %d\n", fPageHeight));
        DBGMSG(("band_count  = %d\n", fBandCount));
        DBGMSG(("band_height = %d\n", fBandHeight));
        DBGMSG(("****************\n"));
}


void
GraphicsDriver::_CleanupBitmap()
{
        delete fBitmap;
        fBitmap = NULL;
        fView   = NULL;

        delete fRotatedBitmap;
        fRotatedBitmap = NULL;
}


BPoint
GraphicsDriver::GetScale(int32 nup, BRect physicalRect, float scaling)
{
        float width;
        float height;
        BPoint scale;

        scale.x = scale.y = 1.0f;

        switch (nup) {
        case 1:
                scale.x = scale.y = 1.0f;
                break;
        case 2: /* 1x2 or 2x1 */
                width  = physicalRect.Width();
                height = physicalRect.Height();
                if (width < height) {   // portrait
                        scale.x = height / 2.0f / width;
                        scale.y = width / height;
                } else {        // landscape
                        scale.x = height / width;
                        scale.y = width / 2.0f / height;
                }
                break;
        case 8: /* 2x4 or 4x2 */
                width  = physicalRect.Width();
                height = physicalRect.Height();
                if (width < height) {
                        scale.x = height / 4.0f / width;
                        scale.y = width / height / 2.0f;
                } else {
                        scale.x = height / width / 2.0f;
                        scale.y = width / 4.0f / height;
                }
                break;
        case 32:        /* 4x8 or 8x4 */
                width  = physicalRect.Width();
                height = physicalRect.Height();
                if (width < height) {
                        scale.x = height / 8.0f / width;
                        scale.y = width / height / 4.0f;
                } else {
                        scale.x = height / width / 4.0f;
                        scale.y = width / 8.0f / height;
                }
                break;
        case 4:         /* 2x2 */
                scale.x = scale.y = 1.0f / 2.0f;
                break;
        case 9:         /* 3x3 */
                scale.x = scale.y = 1.0f / 3.0f;
                break;
        case 16:        /* 4x4 */
                scale.x = scale.y = 1.0f / 4.0f;
                break;
        case 25:        /* 5x5 */
                scale.x = scale.y = 1.0f / 5.0f;
                break;
        case 36:        /* 6x6 */
                scale.x = scale.y = 1.0f / 6.0f;
                break;
        case 49:        /* 7x7 */
                scale.x = scale.y = 1.0f / 7.0f;
                break;
        case 64:        /* 8x8 */
                scale.x = scale.y = 1.0f / 8.0f;
                break;
        case 81:        /* 9x9 */
                scale.x = scale.y = 1.0f / 9.0f;
                break;
        case 100:       /* 10x10 */
                scale.x = scale.y = 1.0f / 10.0f;
                break;
        case 121:       /* 11x11 */
                scale.x = scale.y = 1.0f / 11.0f;
                break;
        }

        scale.x = scale.x * scaling / 100.0;
        scale.y = scale.y * scaling / 100.0;

        return scale;
}


BPoint
GraphicsDriver::GetOffset(int32 nup, int index,
        JobData::Orientation orientation, const BPoint* scale,
        BRect scaledPhysicalRect, BRect scaledPrintableRect,
        BRect physicalRect)
{
        BPoint offset;
        offset.x = 0;
        offset.y = 0;

        float width  = scaledPhysicalRect.Width();
        float height = scaledPhysicalRect.Height();

        switch (nup) {
        case 1:
                break;
        case 2:
                if (index == 1) {
                        if (JobData::kPortrait == orientation) {
                                offset.x = width;
                        } else {
                                offset.y = height;
                        }
                }
                break;
        case 8:
                if (JobData::kPortrait == orientation) {
                        offset.x = width  * (index / 2);
                        offset.y = height * (index % 2);
                } else {
                        offset.x = width  * (index % 2);
                        offset.y = height * (index / 2);
                }
                break;
        case 32:
                if (JobData::kPortrait == orientation) {
                        offset.x = width  * (index / 4);
                        offset.y = height * (index % 4);
                } else {
                        offset.x = width  * (index % 4);
                        offset.y = height * (index / 4);
                }
                break;
        case 4:
                offset.x = width  * (index / 2);
                offset.y = height * (index % 2);
                break;
        case 9:
                offset.x = width  * (index / 3);
                offset.y = height * (index % 3);
                break;
        case 16:
                offset.x = width  * (index / 4);
                offset.y = height * (index % 4);
                break;
        case 25:
                offset.x = width  * (index / 5);
                offset.y = height * (index % 5);
                break;
        case 36:
                offset.x = width  * (index / 6);
                offset.y = height * (index % 6);
                break;
        case 49:
                offset.x = width  * (index / 7);
                offset.y = height * (index % 7);
                break;
        case 64:
                offset.x = width  * (index / 8);
                offset.y = height * (index % 8);
                break;
        case 81:
                offset.x = width  * (index / 9);
                offset.y = height * (index % 9);
                break;
        case 100:
                offset.x = width  * (index / 10);
                offset.y = height * (index % 10);
                break;
        case 121:
                offset.x = width  * (index / 11);
                offset.y = height * (index % 11);
                break;
        }

        // adjust margin
        offset.x += scaledPrintableRect.left - physicalRect.left;
        offset.y += scaledPrintableRect.top - physicalRect.top;

        float real_scale = min(scale->x, scale->y);
        if (real_scale != scale->x)
                offset.x *= scale->x / real_scale;
        else
                offset.y *= scale->y / real_scale;

        return offset;
}


// print the specified pages on a physical page
bool
GraphicsDriver::_PrintPage(PageDataList* pages)
{
        BPoint offset;
        offset.x = 0.0f;
        offset.y = 0.0f;

        if (pages == NULL) {
                return true;
        }

        do {
                // clear the physical page
                fView->SetScale(1.0);
                fView->SetHighColor(255, 255, 255);
                fView->ConstrainClippingRegion(NULL);
                fView->FillRect(fView->Bounds());

                BPoint scale = GetScale(fOrgJobData->GetNup(),
                        fOrgJobData->GetPhysicalRect(), fOrgJobData->GetScaling());
                float real_scale = min(scale.x, scale.y) * fOrgJobData->GetXres()
                        / 72.0f;
                fView->SetScale(real_scale);
                float x = offset.x / real_scale;
                float y = offset.y / real_scale;
                int page_index = 0;

                for (PageDataList::iterator it = pages->begin(); it != pages->end();
                        it++) {
                        BPoint left_top(GetOffset(fOrgJobData->GetNup(), page_index++,
                                fOrgJobData->GetOrientation(), &scale,
                                fOrgJobData->GetScaledPhysicalRect(),
                                fOrgJobData->GetScaledPrintableRect(),
                                fOrgJobData->GetPhysicalRect()));

                        left_top.x -= x;
                        left_top.y -= y;

                        BRect clip(fOrgJobData->GetScaledPrintableRect());
                        clip.OffsetTo(left_top);

                        BRegion *region = new BRegion();
                        region->Set(clip);
                        fView->ConstrainClippingRegion(region);
                        delete region;

                        if ((*it)->startEnum()) {
                                bool more;
                                do {
                                        PictureData     *picture_data;
                                        more = (*it)->enumObject(&picture_data);
                                        BPoint real_offset = left_top + picture_data->point;
                                        fView->DrawPicture(picture_data->picture, real_offset);
                                        fView->Sync();
                                        delete picture_data;
                                } while (more);
                        }
                }

                if (!_PrintBand(fBitmap, &offset))
                        return false;

        } while (offset.x >= 0.0f && offset.y >= 0.0f);

        return true;
}


bool
GraphicsDriver::_PrintBand(BBitmap* band, BPoint* offset)
{
        if (!_NeedRotateBitmapBand())
                return NextBand(band, offset);

        _RotateInto(fRotatedBitmap, band);

        BPoint rotatedOffset(offset->y, offset->x);
        bool success = NextBand(fRotatedBitmap, &rotatedOffset);
        offset->x = rotatedOffset.y;
        offset->y = rotatedOffset.x;

        return success;
}


void
GraphicsDriver::_RotateInto(BBitmap* target, const BBitmap* source)
{
        ASSERT(target->ColorSpace() == B_RGB32);
        ASSERT(source->ColorSpace() == B_RGB32);
        ASSERT(target->Bounds().IntegerWidth() == source->Bounds().IntegerHeight());
        ASSERT(target->Bounds().IntegerHeight() == source->Bounds().IntegerWidth());

        const int32 width = source->Bounds().IntegerWidth() + 1;
        const int32 height = source->Bounds().IntegerHeight() + 1;

        const int32 sourceBPR = source->BytesPerRow();
        const int32 targetBPR = target->BytesPerRow();

        const uint8_t* sourceBits =
                reinterpret_cast<const uint8_t*>(source->Bits());
        uint8_t* targetBits = static_cast<uint8_t*>(target->Bits());

        for (int32 y = 0; y < height; y ++) {
                for (int32 x = 0; x < width; x ++) {
                        const uint32_t* sourcePixel =
                                reinterpret_cast<const uint32_t*>(sourceBits + sourceBPR * y
                                        + sizeof(uint32_t) * x);

                        int32 targetX = (height - y - 1);
                        int32 targetY = x;
                        uint32_t* targetPixel =
                                reinterpret_cast<uint32_t*>(targetBits + targetBPR * targetY
                                        + sizeof(uint32_t) * targetX);
                        *targetPixel = *sourcePixel;
                }
        }
}

bool
GraphicsDriver::_CollectPages(SpoolData* spoolData, PageDataList* pages)
{
        // collect the pages to be printed on the physical page
        PageData *page_data;
        int nup = fOrgJobData->GetNup();
        bool more;
        do {
                more = spoolData->enumObject(&page_data);
                if (pages != NULL)
                        pages->push_back(page_data);
        } while (more && --nup);

        return more;
}


bool
GraphicsDriver::_SkipPages(SpoolData* spoolData)
{
        return _CollectPages(spoolData, NULL);
}


bool
GraphicsDriver::_PrintDocument(SpoolData* spoolData)
{
        bool more;
        bool success;
        int page_index;
        int copy;
        int copies;

        more = true;
        success = true;
        page_index = 0;

        if (fPrinterCap->Supports(PrinterCap::kCopyCommand))
                // let the printer perform the copy operation
                copies = 1;
        else
                // send the page multiple times to the printer
                copies = fRealJobData->GetCopies();

        fStatusWindow -> SetPageCopies(copies);
                // inform fStatusWindow about number of copies

        // printing of even/odd numbered pages only is valid in simplex mode
        bool simplex = fRealJobData->GetPrintStyle() == JobData::kSimplex;

        if (spoolData->startEnum()) {
                do {
                        DBGMSG(("page index = %d\n", page_index));

                        if (simplex
                                && fRealJobData->GetPageSelection()
                                        == JobData::kEvenNumberedPages)
                                // skip odd numbered page
                                more = _SkipPages(spoolData);

                        if (!more)
                                // end reached
                                break;

                        PageDataList pages;
                        more = _CollectPages(spoolData, &pages);

                        if (more && simplex
                                && fRealJobData->GetPageSelection()
                                        == JobData::kOddNumberedPages)
                                // skip even numbered page
                                more = _SkipPages(spoolData);

                        // print each physical page "copies" of times
                        for (copy = 0; success && copy < copies; copy ++) {

                                // Update the status / cancel job
                                if (fStatusWindow->UpdateStatusBar(page_index, copy))
                                        return false;

                                success = StartPage(page_index);
                                if (!success)
                                        break;

                                // print the pages on the physical page
                                fView->Window()->Lock();
                                success = _PrintPage(&pages);
                                fView->Window()->Unlock();

                                if (success) {
                                        success = EndPage(page_index);
                                }
                        }

                        page_index++;
                } while (success && more);
        }

#ifndef USE_PREVIEW_FOR_DEBUG
        if (success
                && fPrinterCap->Supports(PrinterCap::kPrintStyle)
                && (fOrgJobData->GetPrintStyle() != JobData::kSimplex)
                && (((page_index + fOrgJobData->GetNup() - 1) / fOrgJobData->GetNup())
                        % 2)) {
                // append an empty page on the back side of the page in duplex or
                // booklet mode
                success =
                        StartPage(page_index) &&
                        _PrintPage(NULL) &&
                        EndPage(page_index);
        }
#endif

        return success;
}


const JobData*
GraphicsDriver::GetJobData(BFile* spoolFile)
{
        _SetupData(spoolFile);
        return fOrgJobData;
}


bool
GraphicsDriver::_PrintJob(BFile* spoolFile)
{
        bool success = true;
        if (!_SetupData(spoolFile)) {
                // silently exit if there is nothing to print
                return true;
        }

        fTransport = new Transport(fPrinterData);

        if (fTransport->CheckAbort()) {
                success = false;
        } else if (!fTransport->IsPrintToFileCanceled()) {
                BStopWatch stopWatch("printJob", !MEASURE_PRINT_JOB_TIME);
                _SetupBitmap();
                SpoolData spoolData(spoolFile, fPageCount, fOrgJobData->GetNup(),
                        fOrgJobData->GetReverse());
                success = StartDocument();
                if (success) {
                        fStatusWindow = new StatusWindow(
                                fRealJobData->GetPageSelection() == JobData::kOddNumberedPages,
                                fRealJobData->GetPageSelection() == JobData::kEvenNumberedPages,
                                fRealJobData->GetFirstPage(),
                                fPageCount,
                                fInternalCopies,fRealJobData->GetNup());

                        while (fInternalCopies--) {
                                success = _PrintDocument(&spoolData);
                                if (success == false) {
                                        break;
                                }
                        }
                        EndDocument(success);

                        fStatusWindow->Lock();
                        fStatusWindow->Quit();
                }
                _CleanupBitmap();
                _CleanupData();
        }

        if (success == false) {
                BAlert *alert;
                if (fTransport->CheckAbort())
                        alert = new BAlert("", fTransport->LastError().c_str(), "OK");
                else
                        alert = new BAlert("", "Printer not responding.", "OK");
                alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
                alert->Go();
        }

        delete fTransport;
        fTransport = NULL;

        return success;
}


BMessage*
GraphicsDriver::TakeJob(BFile* spoolFile)
{
        BMessage *msg;
        if (_PrintJob(spoolFile))
                msg = new BMessage('okok');
        else
                msg = new BMessage('baad');
        return msg;
}


bool
GraphicsDriver::StartDocument()
{
        return true;
}


bool
GraphicsDriver::StartPage(int)
{
        return true;
}


bool
GraphicsDriver::NextBand(BBitmap*, BPoint*)
{
        return true;
}


bool
GraphicsDriver::EndPage(int)
{
        return true;
}


bool
GraphicsDriver::EndDocument(bool)
{
        return true;
}


void
GraphicsDriver::WriteSpoolData(const void* buffer, size_t size)
{
        if (fTransport == NULL)
                return;
        fTransport->Write(buffer, size);
}


void
GraphicsDriver::WriteSpoolString(const char* format, ...)
{
        if (fTransport == NULL)
                return;

        char buffer[256];
        va_list ap;
        va_start(ap, format);
        vsprintf(buffer, format, ap);
        fTransport->Write(buffer, strlen(buffer));
        va_end(ap);
}


void
GraphicsDriver::WriteSpoolChar(char c)
{
        if (fTransport == NULL)
                return;

        fTransport->Write(&c, 1);
}


void
GraphicsDriver::ReadSpoolData(void* buffer, size_t size)
{
        if (fTransport == NULL)
                return;
        fTransport->Read(buffer, size);
}


int
GraphicsDriver::ReadSpoolChar()
{
        if (fTransport == NULL)
                return -1;

        char c;
        fTransport->Read(&c, 1);
        return c;
}


bool
GraphicsDriver::_NeedRotateBitmapBand() const
{
        return JobData::kLandscape == fRealJobData->GetOrientation()
                && !fPrinterCap->Supports(PrinterCap::kCanRotatePageInLandscape);
}


void
GraphicsDriver::_ConvertRGB32ToRGB24(const void* src, void* dst, int width) {
        uint8* d = (uint8*)dst;
        const rgb_color* s = static_cast<const rgb_color*>(src);
        for (int i = width; i > 0; i --) {
                *d ++ = s->red;
                *d ++ = s->green;
                *d ++ = s->blue;
                s++;
        }
}


void
GraphicsDriver::_ConvertCMAP8ToRGB24(const void* src, void* dst, int width) {
        uint8* d = (uint8*)dst;
        const uint8* s = static_cast<const uint8*>(src);
        const color_map* cmap = system_colors();
        for (int i = width; i > 0; i --) {
                const rgb_color* rgb = &cmap->color_list[*s];
                *d ++ = rgb->red;
                *d ++ = rgb->green;
                *d ++ = rgb->blue;
                s ++;
        }
}


void
GraphicsDriver::ConvertToRGB24(const void* src, void* dst, int width,
        color_space cs) {
        if (cs == B_RGB32)
                _ConvertRGB32ToRGB24(src, dst, width);
        else if (cs == B_CMAP8)
                _ConvertCMAP8ToRGB24(src, dst, width);
        else {
                DBGMSG(("color_space %d not supported", cs));
        }
}


uint8
GraphicsDriver::_ConvertToGray(uint8 r, uint8 g, uint8 b) {
        if (r == g && g == b)
                return r;
        else
                return (r * 3 + g * 6 + b) / 10;
}


void
GraphicsDriver::_ConvertRGB32ToGray(const void* src, void* dst, int width) {
        uint8* d = (uint8*)dst;
        const rgb_color* s = static_cast<const rgb_color*>(src);
        for (int i = width; i > 0; i--, s++, d++)
                *d = _ConvertToGray(s->red, s->green, s->blue);
}


void
GraphicsDriver::_ConvertCMAP8ToGray(const void* src, void* dst, int width) {
        uint8* d = (uint8*)dst;
        const uint8* s = static_cast<const uint8*>(src);
        const color_map* cmap = system_colors();
        for (int i = width; i > 0; i--, s++, d++) {
                const rgb_color* rgb = &cmap->color_list[*s];
                *d = _ConvertToGray(rgb->red, rgb->green, rgb->blue);
        }
}


void
GraphicsDriver::ConvertToGray(const void* src, void* dst, int width,
        color_space cs) {
        if (cs == B_RGB32)
                _ConvertRGB32ToGray(src, dst, width);
        else if (cs == B_CMAP8)
                _ConvertCMAP8ToGray(src, dst, width);
        else {
                DBGMSG(("color_space %d not supported", cs));
        }
}