示例#1
0
文件: appl.c 项目: hajuuk/R7000
static int applopen(struct vol *vol, u_char creator[ 4 ], int flags, int mode)
{
    char	*dtf, *adt, *adts;

    if ( sa.sdt_fd != -1 ) {
        if ( !(flags & ( O_RDWR | O_WRONLY )) &&
                memcmp( sa.sdt_creator, creator, sizeof( CreatorType )) == 0 &&
                sa.sdt_vid == vol->v_vid ) {
            return( AFP_OK );
        }
        close( sa.sdt_fd );
        sa.sdt_fd = -1;
    }

    dtf = dtfile( vol, creator, ".appl" );

    if (( sa.sdt_fd = open( dtf, flags, ad_mode( dtf, mode ))) < 0 ) {
        if ( errno == ENOENT && ( flags & O_CREAT )) {
            if (( adts = strrchr( dtf, '/' )) == NULL ) {
                return( AFPERR_PARAM );
            }
            *adts = '\0';
            if (( adt = strrchr( dtf, '/' )) == NULL ) {
                return( AFPERR_PARAM );
            }
            *adt = '\0';
            (void) ad_mkdir( dtf, DIRBITS | 0777 );
            *adt = '/';
            (void) ad_mkdir( dtf, DIRBITS | 0777 );
            *adts = '/';

            if (( sa.sdt_fd = open( dtf, flags, ad_mode( dtf, mode ))) < 0 ) {
                return( AFPERR_PARAM );
            }
        } else {
            return( AFPERR_PARAM );
        }
    }
    memcpy( sa.sdt_creator, creator, sizeof( CreatorType ));
    sa.sdt_vid = vol->v_vid;
    sa.sdt_index = 0;
    return( AFP_OK );
}
示例#2
0
char GPUOctree::load(const char *filename)
{
	release();
	try 
    { 
// read indirection
		std::string idrname = filename;
		idrname += ".idr";
        InputFile idrfile(idrname.c_str()); 
		const FloatAttribute *sizeattr = idrfile.header().findTypedAttribute <FloatAttribute> ("root_size");
		m_rootSize = sizeattr->value();
		
		const V3fAttribute *centerattr = idrfile.header().findTypedAttribute <V3fAttribute> ("root_center");
		Imath::V3f center = centerattr->value();
		
		m_rootCenter.x = center[0];
		m_rootCenter.y = center[1];
		m_rootCenter.z = center[2];
		
		Imath::Box2i dw = idrfile.header().dataWindow();
		
		int width  = dw.max.x - dw.min.x + 1;
		int height = dw.max.y - dw.min.y + 1; 
		
		half *idr_r = new half[width*height];
		half *idr_g = new half[width*height];
		half *idr_b = new half[width*height];
		half *idr_a = new half[width*height];
	
		FrameBuffer idrframeBuffer; 
		idrframeBuffer.insert ("R",                                  
							Slice (HALF,                         
								   (char *) idr_r, 
								   sizeof (*idr_r) * 1,    
								   sizeof (*idr_r) * (width),
								   1, 1,                          
								   0.0));
		idrframeBuffer.insert ("G",                                  
							Slice (HALF,                         
								   (char *) idr_g, 
								   sizeof (*idr_g) * 1,    
								   sizeof (*idr_g) * (width),
								   1, 1,                          
								   0.0));
		idrframeBuffer.insert ("B",                                  
							Slice (HALF,                         
								   (char *) idr_b, 
								   sizeof (*idr_b) * 1,    
								   sizeof (*idr_b) * (width),
								   1, 1,                          
								   0.0));
		idrframeBuffer.insert ("A",                                  
							Slice (HALF,                         
								   (char *) idr_a, 
								   sizeof (*idr_a) * 1,    
								   sizeof (*idr_a) * (width),
								   1, 1,                          
								   0.0));
								   
		idrfile.setFrameBuffer (idrframeBuffer); 
		idrfile.readPixels (dw.min.y, dw.max.y);
		
		m_idr = new short[INDIRECTIONPOOLSIZE*4];

		for(int i=0; i<INDIRECTIONPOOLSIZE; i++) {
			m_idr[i*4] = idr_r[i];
			m_idr[i*4+1] = idr_g[i];
			m_idr[i*4+2] = idr_b[i];
			m_idr[i*4+3] = idr_a[i];
		}
		
		/*for(int j=0; j<INDIRECTIONPOOLWIDTH; j++) {
		for(int i=0; i<INDIRECTIONPOOLWIDTH; i++) {
			m_idr[(j*INDIRECTIONPOOLWIDTH+i)*4] = i;
			m_idr[(j*INDIRECTIONPOOLWIDTH+i)*4+1] = j;
			m_idr[(j*INDIRECTIONPOOLWIDTH+i)*4+2] = 0;
			m_idr[(j*INDIRECTIONPOOLWIDTH+i)*4+3] = i;
		}
		}*/
		
		delete[] idr_r;
		delete[] idr_g;
		delete[] idr_b;
		delete[] idr_a;
// read data

		std::string dtname = filename;
		dtname += ".exr";
        InputFile dtfile(dtname.c_str());
		
		dw = dtfile.header().dataWindow();
		
		width  = dw.max.x - dw.min.x + 1;
		height = dw.max.y - dw.min.y + 1; 
		
		half *dt_r = new half[DATAPOOLSIZE];
		half *dt_g = new half[DATAPOOLSIZE];
		half *dt_b = new half[DATAPOOLSIZE];
		half *dt_a = new half[DATAPOOLSIZE];
	
		FrameBuffer dtframeBuffer; 
		dtframeBuffer.insert ("R",                                  
							Slice (HALF,                         
								   (char *) dt_r, 
								   sizeof (*dt_r) * 1,    
								   sizeof (*dt_r) * (DATAPOOLWIDTH),
								   1, 1,                          
								   0.0));
		dtframeBuffer.insert ("G",                                  
							Slice (HALF,                         
								   (char *) dt_g, 
								   sizeof (*dt_g) * 1,    
								   sizeof (*dt_g) * (DATAPOOLWIDTH),
								   1, 1,                          
								   0.0));
		dtframeBuffer.insert ("B",                                  
							Slice (HALF,                         
								   (char *) dt_b, 
								   sizeof (*dt_b) * 1,    
								   sizeof (*dt_b) * (DATAPOOLWIDTH),
								   1, 1,                          
								   0.0));
		dtframeBuffer.insert ("A",                                  
							Slice (HALF,                         
								   (char *) dt_a, 
								   sizeof (*dt_a) * 1,    
								   sizeof (*dt_a) * (DATAPOOLWIDTH),
								   1, 1,                          
								   0.0));
								   
		dtfile.setFrameBuffer (dtframeBuffer); 
		dtfile.readPixels (dw.min.y, dw.max.y);
		
		m_dt = new float[DATAPOOLSIZE*4];

		for(int i=0; i<DATAPOOLSIZE; i++) {
			m_dt[i*4] = dt_r[i];
			m_dt[i*4+1] = dt_g[i];
			m_dt[i*4+2] = dt_b[i];
			m_dt[i*4+3] = dt_a[i];
		}
		
		delete[] dt_r;
		delete[] dt_g;
		delete[] dt_b;
		delete[] dt_a;
    } 
    catch (const std::exception &exc) 
    { 
		return 0;
	}
	
	//MGlobal::displayInfo(MString("dens first; ")+m_dt_r[0]);
	return 1;
}