void volume_file_info::calcMinMax(unsigned int var, unsigned int time) const
{
thread_info ti(BOOST_CURRENT_FUNCTION);
volume vol;
const uint64 maxdim = 128; //read in 128^3 chunks
for(unsigned int off_z = 0; off_z < ZDim(); off_z+=maxdim)
for(unsigned int off_y = 0; off_y < YDim(); off_y+=maxdim)
for(unsigned int off_x = 0; off_x < XDim(); off_x+=maxdim)
{
dimension read_dim(std::min(XDim()-off_x,maxdim),
std::min(YDim()-off_y,maxdim),
std::min(ZDim()-off_z,maxdim));
readVolumeFile(vol,filename(),var,time,
off_x,off_y,off_z,read_dim);
if(off_x==0 && off_y==0 && off_z==0)
{
_data._min[var][time] = vol.min();
_data._max[var][time] = vol.max();
}
else
{
if(_data._min[var][time] > vol.min())
_data._min[var][time] = vol.min();
if(_data._max[var][time] < vol.max())
_data._max[var][time] = vol.max();
}
}
_data._minIsSet[var][time] = true;
_data._maxIsSet[var][time] = true;
}
int load_MPA(media_entry *p)
{
int ret;
long int tag_dim;
int n,RowIndex, ColIndex;
int BitrateMatrix[16][5] = {
{0, 0, 0, 0, 0 },
{32000, 32000, 32000, 32000, 8000 },
{64000, 48000, 40000, 48000, 16000 },
{96000, 56000, 48000, 56000, 24000 },
{128000,64000, 56000, 64000, 32000 },
{160000,80000, 64000, 80000, 40000 },
{192000,96000, 80000, 96000, 48000 },
{224000,112000,96000, 112000,56000 },
{256000,128000,112000,128000,64000 },
{288000,160000,128000,144000,80000 },
{320000,192000,160000,160000,96000 },
{352000,224000,192000,176000,112000},
{384000,256000,224000,192000,128000},
{416000,320000,256000,224000,144000},
{448000,384000,320000,256000,160000},
{0, 0, 0, 0, 0 }
};
fnc_log(FNC_LOG_DEBUG, "loading MPA...\n");
if ( (ret=mediaopen(p)) < 0)
return ret;
p->buff_size=0;
if ( (p->buff_size = read(p->fd, p->buff_data, 4)) != 4) return ERR_PARSE;
// shawill: look if ID3 tag is present
if (!memcmp(p->buff_data, "ID3", 3)) { // ID3 tag present
n = read_dim(p->fd, &tag_dim); // shawill: one day we will look also at this function
printf("%ld\n",tag_dim);
p->description.flags|=MED_ID3;
p->description.tag_dim=tag_dim;
lseek(p->fd,tag_dim,SEEK_CUR);
if ( (p->buff_size = read(p->fd, p->buff_data, 4)) != 4) return ERR_PARSE;
}
//fstat(p->fd, &fdstat);
//if ( !S_ISFIFO(fdstat.st_mode) ) {
mediaclose(p);
// close(p->fd);
p->buff_size = 4;
//}
if (! ((p->buff_data[0]==0xff) && ((p->buff_data[1] & 0xe0)==0xe0))) return ERR_PARSE;
switch (p->buff_data[1] & 0x1e) { /* Mpeg version and Level */
case 18: ColIndex = 4; break; /* Mpeg-2 L3 */
case 20: ColIndex = 4; break; /* Mpeg-2 L2 */
case 22: ColIndex = 3; break; /* Mpeg-2 L1 */
case 26: ColIndex = 2; break; /* Mpeg-1 L3 */
case 28: ColIndex = 1; break; /* Mpeg-1 L2 */
case 30: ColIndex = 0; break; /* Mpeg-1 L1 */
default: {
return ERR_PARSE;
}
}
RowIndex = (p->buff_data[2] & 0xf0) / 16;
p->description.bitrate = BitrateMatrix[RowIndex][ColIndex];
p->description.flags|=MED_BITRATE;
if (p->buff_data[1] & 0x08) { /* Mpeg-1 */
switch (p->buff_data[2] & 0x0c) {
case 0x00: p->description.sample_rate=44100; break;
case 0x04: p->description.sample_rate=48000; break;
case 0x08: p->description.sample_rate=32000; break;
default: {
return ERR_PARSE;
}
}
} else { /* Mpeg-2 */
// switch (sync3 & 0x0c) {
switch (p->buff_data[2] & 0x0c) {
case 0x00: p->description.sample_rate=22050; break;
case 0x04: p->description.sample_rate=24000; break;
case 0x08: p->description.sample_rate=16000; break;
default: {
return ERR_PARSE;
}
}
}
p->description.flags|=MED_SAMPLE_RATE;
if ((p->buff_data[1] & 0x06) == 6)
p->description.frame_len = 384;
else
p->description.frame_len = 1152;
p->description.flags|=MED_FRAME_LEN;
p->description.pkt_len=(double)p->description.frame_len/(double)p->description.sample_rate*1000;
p->description.delta_mtime=p->description.pkt_len;
p->description.flags|=MED_PKT_LEN;
return ERR_NOERROR;
}
r8
_MINVAL0__S(
DopeVectorType *array,
DopeVectorType *dim,
DopeVectorType *mask)
{
char * array_p, * array_b ;
char * dim_p, * dim_b ;
char * mask_p, * mask_b ;
size_t src_extent [MAX_NARY_DIMS] ;
size_t counter [MAX_NARY_DIMS] ;
size_t src_offset [MAX_NARY_DIMS] ;
size_t src_stride [MAX_NARY_DIMS] ;
size_t src_size ;
size_t msk_stride [MAX_NARY_DIMS] ;
size_t msk_offset [MAX_NARY_DIMS] ;
int32_t ddim ;
uint32_t src_rank ;
uint32_t res_rank ;
uint32_t jrank ;
size_t j,k,i ;
size_t typ_sz;
size_t msk_typ_sz;
r8 accum ;
r8 const initv = HUGE_REAL8_F90 ;
size_t a_size,a_stride;
size_t m_stride ;
r8 temp,new ;
if (mask == NULL) { /* is third arg mask or dim? */
if (dim != NULL) {
if (GET_DV_LOGICAL_FROM_DESC(dim)) {
mask = (DopeVectorType *) dim ;
dim = NULL;
}
}
}
if (dim != NULL) {
ddim = read_dim(dim);
} else
ddim = 0 ;
array_b = (char *) GET_ADDRESS_FROM_DESC(array) ;
src_rank = GET_RANK_FROM_DESC(array) - 1;
typ_sz = GET_ELEMENT_SZ_FROM_DESC(array);
src_size = read_source_desc(array, src_extent, src_stride, src_offset, ddim);
for (i = 0 ; i <= src_rank ; i ++)
counter[i] = 0 ;
if (mask != NULL) {
msk_typ_sz = GET_ELEMENT_SZ_FROM_DESC(mask);
mask_b = (char *) GET_ADDRESS_FROM_DESC(mask) + OFFSET_TO_TF_BYTE(msk_typ_sz) ;
if (GET_RANK_FROM_DESC(mask) == 0) {
if (*mask_b) {
mask = NULL;
} else {
src_size = 0;
for (j = 0 ; j <= src_rank ; j ++) {
msk_stride[j] = 0 ;
msk_offset[j] = 0 ;
}
}
} else {
get_offset_and_stride(mask, src_extent, msk_stride, msk_offset, ddim);
}
}
accum = initv ;
if (src_size == 0 ) {
return accum;
}
array_p = array_b ;
if (mask == NULL) {
{
size_t *p1 = NULL;
size_t *p2 = NULL;
size_t p3 = 0;
src_rank = find_contig_axes(src_extent, src_stride, src_offset, src_rank, typ_sz, p1,p2,p3) ;
}
a_size = src_extent[0] ;
a_stride = src_stride[0] ;
while (counter[src_rank] < src_extent[src_rank] ) {
for ( i = 0 ; i < a_size ; i ++ ) {
if (*(r8 *)array_p < accum ) {
accum = * (r8 *)array_p ;
}
array_p += a_stride ;
}
counter[0] = a_size ;
j = 0 ;
while ((counter[j] == src_extent[j]) && (j < src_rank)) {
array_p += src_offset[j] ;
counter[j+1]++ ;
counter[j] = 0 ;
j ++ ;
}
}
} else {
{
size_t *p1 = NULL;
size_t *p2 = NULL;
size_t p3 = 0;
p1 = msk_stride ;
p2 = msk_offset ;
p3 = msk_typ_sz ;
src_rank = find_contig_axes(src_extent, src_stride, src_offset, src_rank, typ_sz, p1,p2,p3) ;
}
a_size = src_extent[0] ;
a_stride = src_stride[0] ;
m_stride = msk_stride[0] ;
mask_p = mask_b ;
while (counter[src_rank] < src_extent[src_rank] ) {
for ( i = 0 ; i < a_size ; i ++ ) {
if (*mask_p) {
if (*(r8 *)array_p < accum ) {
accum = * (r8 *)array_p ;
}
}
array_p += a_stride ;
mask_p += m_stride ;
}
counter[0] = a_size ;
j = 0 ;
while ((counter[j] == src_extent[j]) && (j < src_rank)) {
array_p += src_offset[j] ;
mask_p += msk_offset[j] ;
counter[j+1]++ ;
counter[j] = 0 ;
j ++ ;
}
}
}
return accum ;
}
