Show
Ignore:
Timestamp:
03/21/12 18:36:20 (2 years ago)
Author:
robert
Message:

Ran script to remove trailing spaces and tabs

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/src/osgPlugins/quicktime/QTImportExport.cpp

    r12292 r13041  
    2121    public: 
    2222        QTImportExportException(int err, const std::string& msg) : std::exception(), _err(err), _msg(msg) {} 
    23          
     23 
    2424        virtual const char* what() { return _msg.c_str(); } 
    2525        int getErrorCode() { return _err; } 
    26          
     26 
    2727        virtual ~QTImportExportException() throw () {} 
    28          
     28 
    2929    private: 
    3030        int _err; 
     
    3232}; 
    3333 
    34 QuicktimeImportExport::QuicktimeImportExport()  
    35 :    _error(0),  
     34QuicktimeImportExport::QuicktimeImportExport() 
     35:    _error(0), 
    3636    _lastError("") 
    3737{ 
     
    4343// ---------------------------------------------------------------------------------------------------------- 
    4444 
    45 void QuicktimeImportExport::flipImage(unsigned char* pixels, int bytesPerPixel, unsigned int width, unsigned height)  
     45void QuicktimeImportExport::flipImage(unsigned char* pixels, int bytesPerPixel, unsigned int width, unsigned height) 
    4646{ 
    4747    // Flip the image 
     
    7070    unsigned char *srcp = buffer; 
    7171    unsigned int i, j; 
    72      
     72 
    7373    int roffset, goffset, boffset, aoffset; 
    7474    aoffset = -1; 
    7575    int sourceStep; 
    76      
     76 
    7777    switch (bytesPerPixel) { 
    7878        case 1: 
     
    9393            boffset = 0; 
    9494            break; 
    95              
    96     } 
    97                      
    98     for (i = 0; i < height; ++i )  
     95 
     96    } 
     97 
     98    for (i = 0; i < height; ++i ) 
    9999    { 
    100         for (j = 0; j < width; ++j )  
     100        for (j = 0; j < width; ++j ) 
    101101        { 
    102102            dstp[0] = (aoffset < 0) ? 0 : srcp[aoffset]; 
     
    106106            srcp+=sourceStep; 
    107107            dstp+=4; 
    108              
    109         } 
    110     } 
    111      
     108 
     109        } 
     110    } 
     111 
    112112    flipImage(pixels, bytesPerPixel, width, height); 
    113113    return pixels; 
     
    121121// ---------------------------------------------------------------------------------------------------------- 
    122122 
    123 unsigned char* QuicktimeImportExport::prepareBufferForQuicktime(unsigned char* buffer, GLenum pixelFormat, int bytesPerPixel, unsigned int width, unsigned int height)  
     123unsigned char* QuicktimeImportExport::prepareBufferForQuicktime(unsigned char* buffer, GLenum pixelFormat, int bytesPerPixel, unsigned int width, unsigned int height) 
    124124{ 
    125125    unsigned char *pixels = new unsigned char [height * width * 4]; 
     
    127127    unsigned char *srcp = buffer; 
    128128    unsigned int i, j; 
    129      
     129 
    130130    int roffset, goffset, boffset, aoffset; 
    131131    aoffset = -1; 
    132132    int sourceStep; 
    133      
     133 
    134134    switch (bytesPerPixel) { 
    135135        case 1: 
     
    152152                    boffset = 2; 
    153153                    break; 
    154                  
     154 
    155155                case GL_BGRA: 
    156156                    aoffset = 0; 
     
    161161            } 
    162162    } 
    163                      
    164              
    165     for (i = 0; i < height; ++i )  
     163 
     164 
     165    for (i = 0; i < height; ++i ) 
    166166    { 
    167         for (j = 0; j < width; ++j )  
     167        for (j = 0; j < width; ++j ) 
    168168        { 
    169169            dstp[0] = (aoffset < 0) ? 0 : srcp[aoffset]; 
     
    173173            srcp+=sourceStep; 
    174174            dstp+=4; 
    175              
    176         } 
    177     } 
    178      
     175 
     176        } 
     177    } 
     178 
    179179    flipImage(pixels, 4, width, height); 
    180      
     180 
    181181    return pixels; 
    182182 
     
    187187// ---------------------------------------------------------------------------------------------------------- 
    188188 
    189 osg::Image* QuicktimeImportExport::readFromStream(std::istream & inStream, const std::string& fileTypeHint, long sizeHint)  
     189osg::Image* QuicktimeImportExport::readFromStream(std::istream & inStream, const std::string& fileTypeHint, long sizeHint) 
    190190{ 
    191191    char* content = NULL; 
    192192    long length = 0; 
    193      if (sizeHint != 0)  
     193     if (sizeHint != 0) 
    194194    { 
    195195        length = sizeHint; 
     
    197197        inStream.read (content,length); 
    198198    } 
    199     else  
     199    else 
    200200    { 
    201201        int readBytes(0), newBytes(0); 
    202          
     202 
    203203        char buffer[10240]; 
    204          
     204 
    205205        while (!inStream.eof()) { 
    206206            inStream.read(buffer, 10240); 
     
    208208            if (newBytes > 0) { 
    209209                char* newcontent = new char[readBytes + newBytes]; 
    210              
     210 
    211211                if (readBytes > 0) 
    212212                    memcpy(newcontent, content, readBytes); 
    213                  
     213 
    214214                memcpy(&newcontent[readBytes], &buffer, newBytes); 
    215215                readBytes += newBytes; 
     
    220220        length = readBytes; 
    221221    } 
    222      
     222 
    223223    osg::Image* img = doImport(reinterpret_cast<unsigned char*>(content), length, fileTypeHint); 
    224      
     224 
    225225    if (content) delete[] content; 
    226226    return img; 
    227227 } 
    228   
    229   
     228 
     229 
    230230Handle getPtrDataRef(unsigned char *data, unsigned int size, const std::string &filename) 
    231231{ 
     
    236236     ComponentInstance dataRefHandler; 
    237237     unsigned char pstr[255]; 
    238   
     238 
    239239     ptrDataRefRec.data = data; 
    240240     ptrDataRefRec.dataLength = size; 
    241   
     241 
    242242     /*err = */PtrToHand(&ptrDataRefRec, &dataRef, sizeof(PointerDataRefRecord)); 
    243   
     243 
    244244     // Open a Data Handler for the Data Reference 
    245245     /*err = */OpenADataHandler(dataRef, PointerDataHandlerSubType, NULL, 
    246246         (OSType)0, NULL, kDataHCanRead, &dataRefHandler); 
    247   
     247 
    248248     // Convert From CString in filename to a PascalString in pstr 
    249249     if (filename.length() > 255) { 
     
    253253     } 
    254254     CopyCStringToPascal(filename.c_str(), pstr); 
    255   
     255 
    256256    // Add filename extension 
    257257     /*err = */PtrToHand(pstr, &fileNameHandle, filename.length() + 1); 
     
    259259         kDataRefExtensionFileName); 
    260260     DisposeHandle(fileNameHandle); 
    261   
     261 
    262262     // Release old handler which does not have the extensions 
    263263     DisposeHandle(dataRef); 
    264   
     264 
    265265     // Grab the SAFE_NEW version of the data ref from the data handler 
    266266     /*err = */ DataHGetDataRef(dataRefHandler, &dataRef); 
    267       
     267 
    268268     CloseComponent(dataRefHandler); 
    269       
     269 
    270270     return dataRef; 
    271271} 
     
    285285    unsigned int xsize, ysize; 
    286286    unsigned char* imageData = 0; 
    287      
     287 
    288288    // Data Handle for file data ( & load data from file ) 
    289289    Handle dataRef = getPtrDataRef(data, sizeData, fileTypeHint); 
    290      
     290 
    291291    try { 
    292292        OSErr err = noErr; 
    293          
     293 
    294294        // GraphicsImporter - Get Importer for our filetype 
    295295        GetGraphicsImporterForDataRef(dataRef, 'ptr ', &gicomp); 
     
    299299        if (err != noErr) { 
    300300            throw QTImportExportException(err, "GraphicsImportGetNaturalBounds failed"); 
    301              
     301 
    302302        } 
    303303        xsize = (unsigned int)(rectImage.right - rectImage.left); 
     
    312312        // ImageDescription - Get Bit Depth 
    313313        HLock(reinterpret_cast<char **>(desc)); 
    314          
     314 
    315315 
    316316        // GWorld - Pixel Format stuff 
     
    348348            throw QTImportExportException(0, "GetGWorldPixMap failed"); 
    349349        } 
    350          
    351             
     350 
     351 
    352352        //*** Draw GWorld into our Memory Texture! 
    353353        GraphicsImportDraw(gicomp); 
    354   
     354 
    355355        // Clean up 
    356356        UnlockPixels(GetGWorldPixMap(gworld)); 
     
    360360        DisposeHandle(reinterpret_cast<char **>(desc)); 
    361361        DisposeHandle(dataRef); 
    362     }  
    363     catch (QTImportExportException& e)  
     362    } 
     363    catch (QTImportExportException& e) 
    364364    { 
    365365        setError(e.what()); 
    366          
     366 
    367367        if (gworld) { 
    368368            UnlockPixels(GetGWorldPixMap(gworld)); 
     
    372372        if (gicomp) 
    373373            CloseComponent(gicomp); 
    374         if (desc)  
     374        if (desc) 
    375375            DisposeHandle(reinterpret_cast<char **>(desc)); 
    376          
    377         if (imageData)  
     376 
     377        if (imageData) 
    378378            delete[] imageData; 
    379379        if (dataRef) 
    380380            DisposeHandle(dataRef); 
    381              
     381 
    382382        return NULL; 
    383383    } 
    384      
    385  
    386      
     384 
     385 
     386 
    387387    unsigned int bytesPerPixel = depth / 8; 
    388388    unsigned int glpixelFormat; 
     
    400400            break; 
    401401    } 
    402      
     402 
    403403    unsigned char* swizzled = pepareBufferForOSG(imageData, bytesPerPixel, xsize, ysize); 
    404      
     404 
    405405    delete[] imageData; 
    406   
     406 
    407407    osg::Image* image = new osg::Image(); 
    408408    image->setFileName(fileTypeHint.c_str()); 
     
    413413        swizzled, 
    414414        osg::Image::USE_NEW_DELETE ); 
    415      
    416   
     415 
     416 
    417417    return image; 
    418418} 
    419419 
    420420 
    421  void QuicktimeImportExport::writeToStream(std::ostream& outStream, osg::Image* image, const std::string& fileTypeHint)  
     421 void QuicktimeImportExport::writeToStream(std::ostream& outStream, osg::Image* image, const std::string& fileTypeHint) 
    422422 { 
    423423 
     
    439439    } 
    440440 
    441      
     441 
    442442    std::map<std::string, OSType>::iterator cur = extmap.find(ext); 
    443      
     443 
    444444    // can not handle this type of file, perhaps a movie? 
    445445    if (cur == extmap.end()) 
    446446        return; 
    447      
     447 
    448448    unsigned int numBytes = image->computeNumComponents(image->getPixelFormat()); 
    449449    unsigned char* pixels = prepareBufferForQuicktime( 
    450450        image->data(), 
    451         image->getPixelFormat(),  
     451        image->getPixelFormat(), 
    452452        numBytes, 
    453453        image->s(), 
    454454        image->t() 
    455455    ); 
    456      
    457          
     456 
     457 
    458458    OSType desiredType = cur->second; 
    459459    GraphicsExportComponent geComp = NULL; 
     
    465465        OSErr err = OpenADefaultComponent(GraphicsExporterComponentType, desiredType, &geComp); 
    466466        Rect bounds = {0,0, image->t(), image->s()}; 
    467          
     467 
    468468        err = QTNewGWorldFromPtr(&gw, k32ARGBPixelFormat, &bounds, 0,0,0, pixels, image->s()*4); 
    469469        if (err != noErr) { 
    470470            throw QTImportExportException(err,  "could not create gworld for type " + ext); 
    471471        } 
    472          
     472 
    473473        err = GraphicsExportSetInputGWorld(geComp, gw); 
    474474        if (err != noErr) { 
    475475            throw QTImportExportException(err, "could not set input gworld for type " + ext); 
    476476        } 
    477          
     477 
    478478        err = GraphicsExportSetOutputHandle( geComp, dataHandle); 
    479479        if (err != noErr) { 
    480480            throw QTImportExportException(err, "could not set output file for type " + ext); 
    481         }  
    482          
     481        } 
     482 
    483483        // Set the compression quality (needed for JPEG, not necessarily for other formats) 
    484484        if (desiredType == kQTFileTypeJPEG) { 
     
    488488            } 
    489489        } 
    490          
     490 
    491491        if(4 == numBytes) 
    492492        { 
     
    494494        } 
    495495        // else k24RGBPixelFormat??? 
    496          
     496 
    497497        // do the export 
    498498        err = GraphicsExportDoExport(geComp, NULL); 
    499499        if (err != noErr) { 
    500500            throw QTImportExportException(err, "could not do the export for type " + ext); 
    501         }  
    502          
     501        } 
     502 
    503503        if (geComp != NULL) 
    504504            CloseComponent(geComp); 
    505              
     505 
    506506        if (gw) DisposeGWorld (gw); 
    507507        if (pixels) free(pixels); 
    508          
     508 
    509509        outStream.write(*dataHandle, GetHandleSize(dataHandle)); 
    510510        DisposeHandle(dataHandle); 
    511511    } 
    512      
    513      
    514     catch (QTImportExportException& e)  
     512 
     513 
     514    catch (QTImportExportException& e) 
    515515    { 
    516516        setError(e.what()); 
    517          
    518         if (geComp != NULL) CloseComponent(geComp);       
     517 
     518        if (geComp != NULL) CloseComponent(geComp); 
    519519        if (gw != NULL) DisposeGWorld (gw); 
    520520        if (pixels) free(pixels); 
    521          
     521 
    522522        DisposeHandle(dataHandle); 
    523523