cvpersistence.cpp.svn-base

来自「非结构化路识别」· SVN-BASE 代码 · 共 2,051 行 · 第 1/5 页

                char c = '\0';
                const char* dtp = dt;

                for( ;; )
                {
                    if( --n <= 0 )
                    {
                        if( !dtp[0] )
                            break;
                        n = 1;
                        if( isdigit(dtp[0]))
                        {
                            if( !isdigit(dtp[1]))
                            {
                                n = dtp[0] - '0';
                                dtp++;
                            }
                            else
                            {
                                int dl = 0;
                                if( sscanf( dtp, "%d%n", &n, &dl ) <= 0 )
                                    CV_ERROR(CV_StsBadArg,
                                            "Invalid data type specification");
                                dtp += dl;
                            }
                            if( n == 0 )
                                CV_ERROR(CV_StsBadArg,
                                        "Invalid data type specification");
                        }
                        c = *dtp++;
                    }

                    switch( c )
                    {
                    case 'u':
                    case 'c':
                        *buffer++ = *(char*)(data + k);
                        k++;
                        break;
                    case 's':
                        {
                            int val;
                            k = (k + sizeof(short) - 1) & -(int)sizeof(short);
                            val = *(short*)(data + k);
                            k += sizeof(short);
                            buffer[0] = (char)(val >> 8);
                            buffer[1] = (char)val;
                            buffer += 2;
                        }
                        break;
                    case 'i':
                    case 'f':
                        {
                            int val;
                            k = (k + sizeof(int) - 1) & -(int)sizeof(int);
                            val = *(int*)(data + k);
                            k += sizeof(int);
                            buffer[0] = (char)(val >> 24);
                            buffer[1] = (char)(val >> 16);
                            buffer[2] = (char)(val >> 8);
                            buffer[3] = (char)val;
                            buffer += 4;
                        }
                        break;
                    case 'd':
                        {
                            int hi, lo;
                            k = (k + sizeof(double) - 1) & -(int)sizeof(double);
                            hi = (int)(*(uint64*)(data+k) >> 32);
                            lo = (int)(*(uint64*)(data+k));
                            k += sizeof(double);
                            buffer[0] = (char)(hi >> 24);
                            buffer[1] = (char)(hi >> 16);
                            buffer[2] = (char)(hi >> 8);
                            buffer[3] = (char)hi;
                            buffer[4] = (char)(lo >> 24);
                            buffer[5] = (char)(lo >> 16);
                            buffer[6] = (char)(lo >> 8);
                            buffer[7] = (char)lo;
                            buffer += 8;
                        }
                        break;
                    case 'p':
                        {
                            /* just skip it */
                            k = (k + sizeof(void*) - 1) & -(int)sizeof(void*);
                            k += sizeof(void*);
                        }
                        break;
                    case 'r':
                        {
                            unsigned val;
                            k = (k + sizeof(void*) - 1) & -(int)sizeof(void*);
                            val = (unsigned)(unsigned long)(*(void**)(data+k));
                            buffer[0] = (char)(val >> 24);
                            buffer[1] = (char)(val >> 16);
                            buffer[2] = (char)(val >> 8);
                            buffer[3] = (char)val;
                            k += sizeof(void*);
                            buffer += 4;
                        }
                        break;
                    default:
                        CV_ERROR( CV_StsBadArg, "Unknown format specifier" );
                    }

                    if( buffer >= buffer_end )
                    {
                        storage->base64_buffer = buffer;
                        icvWriteBase64Block( storage, 0 );
                        buffer = storage->base64_buffer;
                    }
                }
            }
        }

        storage->base64_buffer = buffer;
    }
    else
    {
        CV_ERROR( CV_StsUnsupportedFormat, "Unsupported encoding format" );
    }

    __END__;
}


static int
icvReadRawData( CvFileStorage* storage, const char* dt,
                int format, void* _data, int count )
{
    int result = 0;
    const char* data = (const char*)_data;
    const char* buffer = storage->buffer;

    CV_FUNCNAME( "icvReadRawData" );

    __BEGIN__;

    int i = 0, k = 0;
    int pl;
    char* endptr = 0;

    if( !dt || (pl = strlen(dt)) == 0 )
        EXIT; // invalid format specification

    if( format == ICV_FORMAT_TEXT )
    {
        if( pl == 1 || (pl == 2 && isdigit(dt[0])) )
        {
            if( pl == 2 )
                count *= dt[0] - '0';

            switch( dt[pl-1] )
            {
            case 'u':
                for( i = 0; i < count; i++ )
                {
                    ((uchar*)data)[i] = (uchar)icv_strtol( buffer, &endptr, 10 );
                    if( endptr == buffer )
                        EXIT;
                    buffer = endptr;
                }
                break;

            case 'c':
                for( i = 0; i < count; i++ )
                {
                    ((char*)data)[i] = (char)icv_strtol( buffer, &endptr, 10 );
                    if( endptr == buffer )
                        EXIT;
                    buffer = endptr;
                }
                break;

            case 's':
                for( i = 0; i < count; i++ )
                {
                    ((short*)data)[i] = (short)icv_strtol( buffer, &endptr, 10 );
                    if( endptr == buffer )
                        EXIT;
                    buffer = endptr;
                }
                break;

            case 'i':
                for( i = 0; i < count; i++ )
                {
                    ((int*)data)[i] = (int)icv_strtol( buffer, &endptr, 10 );
                    if( endptr == buffer )
                        EXIT;
                    buffer = endptr;
                }
                break;

            case 'f':
                for( i = 0; i < count; i++ )
                {
                    ((float*)data)[i] = (float)icv_strtod( buffer, &endptr );
                    if( endptr == buffer )
                        EXIT;
                    buffer = endptr;
                }
                break;

            case 'd':
                for( i = 0; i < count; i++ )
                {
                    ((double*)data)[i] = (double)icv_strtod( buffer, &endptr );
                    if( endptr == buffer )
                        EXIT;
                    buffer = endptr;
                }
                break;

            default:
                EXIT;
            }
        }
        else
        {
            for( i = 0; i < count; i++ )
            {
                int n = 0;
                char c = '\0';
                const char* dtp = dt;

                for( ;; )
                {
                    int dl = 0;

                    if( --n <= 0 )
                    {
                        if( !dtp[0] )
                            break;
                        n = 1;
                        if( isdigit(dtp[0]))
                        {
                            if( !isdigit(dtp[1]))
                            {
                                n = dtp[0] - '0';
                                dtp++;
                            }
                            else
                            {
                                if( sscanf( dtp, "%d%n", &n, &dl ) <= 0 )
                                    CV_ERROR(CV_StsBadArg,
                                            "Invalid data type specification");
                                dtp += dl;
                                dl = 0;
                            }
                            if( n == 0 )
                                CV_ERROR(CV_StsBadArg,
                                        "Invalid data type specification");
                        }
                        c = *dtp++;
                    }

                    switch( c )
                    {
                    case 'u':
                        *(uchar*)(data+k) = (uchar)icv_strtol( buffer, &endptr, 10 );
                        if( endptr == buffer )
                            EXIT;
                        buffer = endptr;
                        k++;
                        break;
                    case 'c':
                        *(char*)(data+k) = (char)icv_strtol( buffer, &endptr, 10 );
                        if( endptr == buffer )
                            EXIT;
                        buffer = endptr;
                        k++;
                        break;
                    case 's':
                        k = (k + sizeof(short) - 1) & -(int)sizeof(short);
                        *(short*)(data+k) = (short)icv_strtol( buffer, &endptr, 10 );
                        if( endptr == buffer )
                            EXIT;
                        buffer = endptr;
                        k += sizeof(short);
                        break;
                    case 'i':
                        k = (k + sizeof(int) - 1) & -(int)sizeof(int);
                        *(int*)(data+k) = (int)icv_strtol( buffer, &endptr, 10 );
                        if( endptr == buffer )
                            EXIT;
                        buffer = endptr;
                        k += sizeof(int);
                        break;
                    case 'f':
                        k = (k + sizeof(float) - 1) & -(int)sizeof(float);
                        *(float*)(data+k) = (float)icv_strtod( buffer, &endptr );
                        if( endptr == buffer )
                            EXIT;
                        buffer = endptr;
                        k += sizeof(float);
                        break;
                    case 'd':
                        k = (k + sizeof(double) - 1) & -(int)sizeof(double);
                        *(double*)(data+k) = (double)icv_strtod( buffer, &endptr );
                        if( endptr == buffer )
                            EXIT;
                        buffer = endptr;
                        k += sizeof(double);
                        break;
                    case 'p':
                        k = (k + sizeof(void*) - 1) & -(int)sizeof(void*);
                        *(void**)(data+k) = 0;
                        k += sizeof(void*);
                        break;
                    case 'r':
                        k = (k + sizeof(void*) - 1) & -(int)sizeof(void*);
                        *(unsigned*)(data+k) = (unsigned)icv_strtol( buffer, &endptr, 10 );
                        if( endptr == buffer )
                            EXIT;
                        buffer = endptr;
                        k += sizeof(void*);
                        break;
                    default:
                        EXIT;
                    }
                }
            }
        }
    }
    else if( format == ICV_FORMAT_BINARY )
    {
        uchar* buffer = (uchar*)storage->base64_buffer;
        uchar* buffer_end = (uchar*)storage->base64_buffer_read;

        assert( sizeof(float) == sizeof(int) &&
                sizeof(float) == 4 &&
                sizeof(double) == 8 );

        if( pl == 1 )
        {
            i = 0;

            for( ;; )
            {
                switch( dt[0] )
                {
                case 'u':
                case 'c':
                    while( i < count )
                    {
                        if( buffer >= buffer_end )
                            break;
                        ((uchar*)data)[i++] = *buffer++;
                    }
                    break;
                case 's':
                    while( i < count )
                    {
                        if( buffer + 1 >= buffer_end )
                            break;
                        ((short*)data)[i++] = (short)((buffer[0] << 8) + buffer[1]);
                        buffer += 2;
                    }
                    break;
                case 'i':
                case 'f':
                    while( i < count )
                    {
                        if( buffer + 3 >= buffer_end )
                            break;
                        ((int*)data)[i++] = (buffer[0] << 24) + (buffer[1] << 16) +
                                            (buffer[2] << 8) + buffer[3];
                        buffer += 4;
                    }
                    break;
                case 'd':
                    while( i < count )
                    {
                        unsigned lo, hi;
                        if( buffer + 7 >= buffer_end )
                            break;
                        hi = (buffer[0] << 24) + (buffer[1] << 16) +
                             (buffer[2] << 8) + buffer[3];
                        lo = (buffer[4] << 24) + (buffer[5] << 16) +
                             (buffer[6] << 8) + buffer[7];
                        ((uint64*)data)[i++] = ((uint64)hi << 32) + lo;
                        buffer += 8;
                    }
                    break;
                default:
                    EXIT;
                }

                if( i < count )
                {
                    int len = buffer_end - buffer;
                    storage->base64_buffer = (char*)buffer;
                    if( !icvReadBase64Block( storage ))
                        EXIT;
                    buffer = (uchar*)storage->base64_buffer;
                    buffer_end = (uchar*)storage->base64_buffer_read;
                    if( len >= buffer_end - buffer )
                        EXIT;
                }
                else
                    break;
            }
        }
        else
        {
            for( i = 0; i < count; i++ )
            {
                int n = 0;
                char c = '\0';