comparison flac.c @ 1816:fa7d0134f9f0 libavcodec

simplify only change context if frame header is error-free, as some fields may not be stored in the frame header and so a single damaged frame-header may trash them

1815:2152760d08ad

  8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
  0, 0, 0, 0 }; 

static int sample_size_table[] = 
{ 0, 8, 12, 0, 16, 20, 24, 0 };

static const uint8_t table_crc8[256] = {
    0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15,
    0x38, 0x3f, 0x36, 0x31, 0x24, 0x23, 0x2a, 0x2d,
    0x70, 0x77, 0x7e, 0x79, 0x6c, 0x6b, 0x62, 0x65,

    {
        s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize);
    }

    s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
//    s->bitstream= av_realloc(s->bitstream, s->max_framesize);
}

static void metadata_streaminfo(FLACContext *s)
{
    /* mandatory streaminfo */

        else
        {
//            av_log(s->avctx, AV_LOG_DEBUG, "rice coded partition k=%d\n", tmp);
            for (; i < samples; i++, sample++){
                s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
                if(get_bits_count(&s->gb) > s->gb.size_in_bits){
                    av_log(s->avctx, AV_LOG_ERROR, "fucking FLAC\n");
                    return -1;
                }
            }
        }
        i= 0;
    }

}

static int decode_frame(FLACContext *s)
{
    int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
    
    blocksize_code = get_bits(&s->gb, 4);

    sample_rate_code = get_bits(&s->gb, 4);
    
    assignment = get_bits(&s->gb, 4); /* channel assignment */
    if (assignment < 8)
    {
        s->decorrelation = INDEPENDENT;
        if (s->channels != assignment+1)
            av_log(s->avctx, AV_LOG_DEBUG, "channel number and number of assigned channels differ!\n");
//        av_log(s->avctx, AV_LOG_DEBUG, "channels: %d\n", assignment+1);
    }
    else if (assignment < 11)
    {
        s->decorrelation= LEFT_SIDE + assignment - 8;
    }
    else
    {
        av_log(s->avctx, AV_LOG_DEBUG, "unsupported channel assignment\n");
        return -1;
    }

    if ((assignment >= 8) && (s->channels != 2))
    {
        return -1;
    }
        
    sample_size_code = get_bits(&s->gb, 3);
    if (sample_size_code != 0)
        s->bps = sample_size_table[sample_size_code];

    if ((sample_size_code == 3) || (sample_size_code == 7))
    {
        av_log(s->avctx, AV_LOG_DEBUG, "invalid sample size code (%d)\n", sample_size_code);
        return -1;
    }

    if (get_bits1(&s->gb))
    {
        av_log(s->avctx, AV_LOG_DEBUG, "broken stream, invalid padding\n");
//        return -1;
    }
    
    if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
        (s->min_blocksize != s->max_blocksize)){
        if(get_utf8(&s->gb) < 0){
            av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
            return -1;
        }
    }else{
        if(get_utf8(&s->gb) < 0){
            av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
            return -1;
        }
    }

    if (blocksize_code == 0)
        s->blocksize = s->min_blocksize;
    else if (blocksize_code == 1)
        s->blocksize = 192;
    else if (blocksize_code <= 5)
        s->blocksize = 576 << (blocksize_code - 2);
    else if (blocksize_code == 6)
        s->blocksize = get_bits(&s->gb, 8)+1;
    else if (blocksize_code == 7)
        s->blocksize = get_bits(&s->gb, 16)+1;
    else if (blocksize_code >= 8)
        s->blocksize = 256 << (blocksize_code - 8);

    if(s->blocksize > s->max_blocksize){
        av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", s->blocksize, s->max_blocksize);
        return -1;
    }

    if (sample_rate_code == 0){
        //Streaminfo
    }else if ((sample_rate_code > 3) && (sample_rate_code < 12))
        s->samplerate = sample_rate_table[sample_rate_code];
    else if (sample_rate_code == 12)
                s->samplerate = get_bits(&s->gb, 8) * 1000;
    else if (sample_rate_code == 13)
                s->samplerate = get_bits(&s->gb, 16);
    else if (sample_rate_code == 14)
                s->samplerate = get_bits(&s->gb, 16) * 10;
    else{
        av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
        return -1;
    }

    crc8= get_crc8(s->gb.buffer, get_bits_count(&s->gb)/8);
    if(crc8){
        av_log(s->avctx, AV_LOG_ERROR, "header crc missmatch crc=%2X\n", crc8);
        return -1;
    }

//    dump_headers(s);

    /* subframes */
    for (i = 0; i < s->channels; i++)

1816:fa7d0134f9f0

  8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
  0, 0, 0, 0 }; 

static int sample_size_table[] = 
{ 0, 8, 12, 0, 16, 20, 24, 0 };

static int blocksize_table[] = {
     0,    192, 576<<0, 576<<1, 576<<2, 576<<3,      0,      0, 
256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7 
};

static const uint8_t table_crc8[256] = {
    0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15,
    0x38, 0x3f, 0x36, 0x31, 0x24, 0x23, 0x2a, 0x2d,
    0x70, 0x77, 0x7e, 0x79, 0x6c, 0x6b, 0x62, 0x65,

    {
        s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize);
    }

    s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
}

static void metadata_streaminfo(FLACContext *s)
{
    /* mandatory streaminfo */

        else
        {
//            av_log(s->avctx, AV_LOG_DEBUG, "rice coded partition k=%d\n", tmp);
            for (; i < samples; i++, sample++){
                s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
            }
        }
        i= 0;
    }

}

static int decode_frame(FLACContext *s)
{
    int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
    int decorrelation, bps, blocksize, samplerate;
    
    blocksize_code = get_bits(&s->gb, 4);

    sample_rate_code = get_bits(&s->gb, 4);
    
    assignment = get_bits(&s->gb, 4); /* channel assignment */
    if (assignment < 8 && s->channels == assignment+1)
        decorrelation = INDEPENDENT;
    else if (assignment >=8 && assignment < 11 && s->channels == 2)
        decorrelation = LEFT_SIDE + assignment - 8;
    else
    {
        av_log(s->avctx, AV_LOG_DEBUG, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels);
        return -1;
    }
        
    sample_size_code = get_bits(&s->gb, 3);
    if(sample_size_code == 0)
        bps= s->bps;
    else if((sample_size_code != 3) && (sample_size_code != 7))
        bps = sample_size_table[sample_size_code];
    else 
    {
        av_log(s->avctx, AV_LOG_DEBUG, "invalid sample size code (%d)\n", sample_size_code);
        return -1;
    }

    if (get_bits1(&s->gb))
    {
        av_log(s->avctx, AV_LOG_DEBUG, "broken stream, invalid padding\n");
        return -1;
    }
    
    if(get_utf8(&s->gb) < 0){
        av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
        return -1;
    }
#if 0    
    if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
        (s->min_blocksize != s->max_blocksize)){
    }else{
    }
#endif
    
    if (blocksize_code == 0)
        blocksize = s->min_blocksize;
    else if (blocksize_code == 6)
        blocksize = get_bits(&s->gb, 8)+1;
    else if (blocksize_code == 7)
        blocksize = get_bits(&s->gb, 16)+1;
    else 
        blocksize = blocksize_table[blocksize_code];

    if(blocksize > s->max_blocksize){
        av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize);
        return -1;
    }

    if (sample_rate_code == 0){
        samplerate= s->samplerate;
    }else if ((sample_rate_code > 3) && (sample_rate_code < 12))
        samplerate = sample_rate_table[sample_rate_code];
    else if (sample_rate_code == 12)
        samplerate = get_bits(&s->gb, 8) * 1000;
    else if (sample_rate_code == 13)
        samplerate = get_bits(&s->gb, 16);
    else if (sample_rate_code == 14)
        samplerate = get_bits(&s->gb, 16) * 10;
    else{
        av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
        return -1;
    }

    crc8= get_crc8(s->gb.buffer, get_bits_count(&s->gb)/8);
    if(crc8){
        av_log(s->avctx, AV_LOG_ERROR, "header crc missmatch crc=%2X\n", crc8);
        return -1;
    }
    
    s->blocksize    = blocksize;
    s->samplerate   = samplerate;
    s->bps          = bps;
    s->decorrelation= decorrelation;

//    dump_headers(s);

    /* subframes */
    for (i = 0; i < s->channels; i++)