vorbis_mode_info.c

linux下的一款播放器

    }
}


static int 
vorbis_staticbook_unpack(oggpack_buffer *opb)
{
    long i,j;
    int dim, entries;
    int maptype;

    /* make sure alignment is correct */
    if (oggpack_read(opb,24) != 0x564342)
        goto _eofout;

    /* first the basic parameters */
    dim = oggpack_read(opb, 16);
    entries = oggpack_read(opb,24);

    if (entries == -1)
        goto _eofout;

    /* codeword ordering.... length ordered or unordered? */
    switch((int)oggpack_read(opb, 1)) {
    case 0:
    {
        /* unordered */

        /* allocated but unused entries? */
        if(oggpack_read(opb, 1))
        {
            /* yes, unused entries */
            for(i = 0; i < entries; i++)
            {
                if(oggpack_read(opb, 1))
                {
                    long num = oggpack_read(opb,5);
                    if (num == -1)
                        goto _eofout;
                }
            }
        }
        else
        {
            /* all entries used; no tagging */
            for(i = 0; i < entries; i++)
            {
                long num = oggpack_read(opb,5);
                if (num == -1)
                    goto _eofout;
            }
        }
    
    }break;
    case 1:
    {
        /* ordered */
        long length = oggpack_read(opb,5) + 1;

        for(i = 0; i < entries;)
        {
            long num = oggpack_read(opb, ilog(entries - i));
            if (num == -1)
                goto _eofout;
            for(j = 0; j < num && i < entries; j++, i++)
                ;
        }
    }
    break;
    default:
        /* EOF */
        return(-1);
    }
  
    /* Do we have a mapping to unpack? */
    maptype = oggpack_read(opb,4);
    switch(maptype){
    case 0:
        /* no mapping */
        break;
    case 1: case 2:
    {        
        /* implicitly populated value mapping */
        /* explicitly populated value mapping */

        int q_min       = oggpack_read(opb,32);
        int q_delta     = oggpack_read(opb,32);
        int q_quant     = oggpack_read(opb,4) + 1;
        int q_sequencep = oggpack_read(opb,1);

        {
            int quantvals=0;
            int tmp = -1;

            switch(maptype){
            case 1:
                quantvals = _book_maptype1_quantvals(entries, dim);
                break;
            case 2:
                quantvals = entries * dim;
                break;
            }
      
            /* quantized values */
            for(i = 0; i < quantvals; i++)
                tmp = oggpack_read(opb, q_quant);
      
            if (quantvals && tmp == -1)
                goto _eofout;
        }
    }break;
    default:
        goto _errout;
    }

    /* all set */
    return(0);
  
 _errout:
 _eofout:
    return(-1); 
}


/* all of the real encoding details are here.  The modes, books,
   everything */
static int 
_vorbis_unpack_books(vorbis_mode_info* vmi, oggpack_buffer *opb)
{
    int i;
    /* codebooks */
    int books = oggpack_read(opb,8) + 1;
    int floors, residues, maps;

    for(i = 0;i < books; i++)
    {
        if(vorbis_staticbook_unpack(opb))
            goto err_out;
    }

    /* time backend settings; hooks are unused */
    {
        int times = oggpack_read(opb,6) + 1;
        for(i = 0; i < times; i++)
        {
            int test = oggpack_read(opb,16);
            if (test < 0 || test >= VI_TIMEB)
                goto err_out;
        }
    }

    /* floor backend settings */
    floors = oggpack_read(opb,6) + 1;

    for(i = 0; i < floors; i++)
    {
        int floor_type = oggpack_read(opb,16);

        if (floor_type < 0 || floor_type >= VI_FLOORB)
            goto err_out;

        if (!_floor_P[floor_type](opb, books))
            goto err_out;
    }

    /* residue backend settings */
    residues = oggpack_read(opb,6) + 1;

    for(i = 0; i < residues; i++)
    {
        int residue_type = oggpack_read(opb,16);

        if(residue_type < 0 || residue_type >= VI_RESB)
            goto err_out;

        if(!_residue_P[residue_type](opb, books))
           goto err_out;
    }

    /* map backend settings */
    maps = oggpack_read(opb,6) + 1;

    for(i = 0; i < maps; i++)
    {
        int map_type = oggpack_read(opb,16);

        if(map_type < 0 || map_type >= VI_MAPB)
            goto err_out;

        if(!_mapping_P[map_type](opb, vmi->channels,
                                 floors, residues))
            goto err_out;
    }
  
    /* mode settings */

    vmi->modecount = oggpack_read(opb,6) + 1;
    vmi->modebits = ilog2(vmi->modecount);
    vmi->blockflags = malloc(vmi->modecount);

    if (vmi->blockflags)
    {
        for(i = 0; i < vmi->modecount; i++)
        {
            int windowtype, transformtype, mapping;

            vmi->blockflags[i] = (char)oggpack_read(opb,1);
            windowtype    = oggpack_read(opb,16);
            transformtype = oggpack_read(opb,16);
            mapping       = oggpack_read(opb,8);

            if (windowtype >= VI_WINDOWB)
                goto err_out;

            if (transformtype >= VI_WINDOWB)
                goto err_out;

            if (mapping >= maps)
                goto err_out;
        }
    }
  
    if (oggpack_read(opb, 1) != 1)
        goto err_out; /* top level EOP check */

    return 1;
 err_out:

    return 0;
}

static int 
_vorbis_unpack_info(vorbis_mode_info* vmi, oggpack_buffer *opb)
{
    int version, rate, bitrate_upper, bitrate_nominal, bitrate_lower;

    if(!vmi)
        return 0;

    version = oggpack_read(opb,32);
    if(version != 0)
        return 0;

    vmi->channels = oggpack_read(opb,8);
    rate = oggpack_read(opb,32);

    bitrate_upper = oggpack_read(opb,32);
    bitrate_nominal = oggpack_read(opb,32);
    bitrate_lower = oggpack_read(opb,32);

    vmi->blocksizes[0] = 1 << oggpack_read(opb,4);
    vmi->blocksizes[1] = 1 << oggpack_read(opb,4);
  
    if (rate < 1)
        goto err_out;

    if (vmi->channels < 1)
        goto err_out;
    
    if (vmi->blocksizes[0] < 8)
        goto err_out; 

    if (vmi->blocksizes[1] < vmi->blocksizes[0])
        goto err_out;
  
    if (oggpack_read(opb,1) != 1)
        goto err_out; /* EOP check */

    return 1;

 err_out:
  return 0;
}

void vorbis_mode_info_init(vorbis_mode_info* vmi)
{
    if (vmi)
    {
        memset(vmi, 0, sizeof(vorbis_mode_info));
    }
}

void vorbis_mode_info_clear(vorbis_mode_info* vmi)
{
    if (vmi)
    {
        if (vmi->blockflags)
        {
            free(vmi->blockflags);
        }
        memset(vmi, 0, sizeof(vorbis_mode_info));
    }
}

int vorbis_mode_info_headerin(vorbis_mode_info* vmi, ogg_packet* op)
{
    int ret = 0;
    oggpack_buffer opb;
  
    if (vmi && op)
    {
        char buffer[6];
        int packtype;

        oggpack_readinit(&opb,op->packet,op->bytes);

        packtype = oggpack_read(&opb,8);
        memset(buffer,0,6);
        _v_readstring(&opb,buffer,6);

        if (!memcmp(buffer,"vorbis",6))
        {
            if (0x01 == packtype)
            {
                ret = _vorbis_unpack_info(vmi, &opb);
            }
            else if (0x03 == packtype)
            {
                ret = 1;
            }
            else if (0x05 == packtype)
            {
                ret = _vorbis_unpack_books(vmi, &opb);
            }
        }
    }
    
    return ret;
}

int vorbis_mode_info_getblocksize(vorbis_mode_info* vmi, ogg_packet* op)
{
    int ret = 0;

    if (vmi && op)
    {
        if (vmi->modebits)
        {
            oggpack_buffer  opb;
            oggpack_readinit(&opb, op->packet, op->bytes);
            
            if(oggpack_read(&opb,1) == 0)
            {
                int mode = oggpack_read(&opb, vmi->modebits);
                
                if ((mode >= 0) && (mode < vmi->modecount))
                {
                    ret = vmi->blocksizes[vmi->blockflags[mode]];
                }
            }
        }
        else if (vmi->modecount)
        {
            ret = vmi->blocksizes[0];
        }
    }

    return ret;
}

int vorbis_mode_info_copy(vorbis_mode_info* dest, 
                          const vorbis_mode_info* src)
{
    int ret = 0;

    if (dest && src && src->modecount && src->blockflags)
    {
        vorbis_mode_info_clear(dest);

        *dest = *src;
        dest->blockflags = malloc(src->modecount);
        
        if (dest->blockflags)
        {
            memcpy(dest->blockflags, src->blockflags, src->modecount);
            ret = 1;
        }
        else
        {
            vorbis_mode_info_clear(dest);
        }
    }

    return ret;
}