mjpeg.c

mpeg4 video codec mpeg4 video codec

        return -1;
    }
    quant_matrix = s->quant_matrixes[quant_index];
    val = val * quant_matrix[0] + s->last_dc[component];
    s->last_dc[component] = val;
    block[0] = val;
    /* AC coefs */
    ac_vlc = &s->vlcs[1][ac_index];
    i = 1;
    for(;;) {
	code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);

        if (code < 0) {
            dprintf("error ac\n");
            return -1;
        }
        /* EOB */
        if (code == 0)
            break;
        if (code == 0xf0) {
            i += 16;
        } else {
            level = get_xbits(&s->gb, code & 0xf);
            i += code >> 4;
            if (i >= 64) {
                dprintf("error count: %d\n", i);
                return -1;
            }
            j = s->scantable.permutated[i];
            block[j] = level * quant_matrix[j];
            i++;
            if (i >= 64)
                break;
        }
    }
    return 0;
}

static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
    int i, mb_x, mb_y;
    //uint16_t buffer[32768][4];
            int left[3], top[3], topleft[3];
            const int linesize= s->linesize[0];
            const int mask= (1<<s->bits)-1;
            
    if((unsigned)s->mb_width > 32768) //dynamic alloc
        return -1;
    
            for(i=0; i<3; i++){
                s->RGBbuffer[0][i]= 1 << (s->bits + point_transform - 1);
            }
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
        const int modified_predictor= mb_y ? predictor : 1;
        uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);

                if (s->interlaced && s->bottom_field)
                    ptr += linesize >> 1;

                for(i=0; i<3; i++){
                    top[i]= left[i]= topleft[i]= s->RGBbuffer[0][i];
                }
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
                    if (s->restart_interval && !s->restart_count)
                        s->restart_count = s->restart_interval;

                    for(i=0;i<3;i++) {
                        int pred;

                        topleft[i]= top[i];
                        top[i]= s->RGBbuffer[mb_x][i];

                        PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
                        
                        left[i]= 
                s->RGBbuffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
                    }

                    if (s->restart_interval && !--s->restart_count) {
                        align_get_bits(&s->gb);
                        skip_bits(&s->gb, 16); /* skip RSTn */
                    }
                }

                if(s->rct){
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
                        ptr[4*mb_x+1] = s->RGBbuffer[mb_x][0] - ((s->RGBbuffer[mb_x][1] + s->RGBbuffer[mb_x][2] - 0x200)>>2);
                        ptr[4*mb_x+0] = s->RGBbuffer[mb_x][1] + ptr[4*mb_x+1];
                        ptr[4*mb_x+2] = s->RGBbuffer[mb_x][2] + ptr[4*mb_x+1];
                    }
                }else if(s->pegasus_rct){
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
                        ptr[4*mb_x+1] = s->RGBbuffer[mb_x][0] - ((s->RGBbuffer[mb_x][1] + s->RGBbuffer[mb_x][2])>>2);
                        ptr[4*mb_x+0] = s->RGBbuffer[mb_x][1] + ptr[4*mb_x+1];
                        ptr[4*mb_x+2] = s->RGBbuffer[mb_x][2] + ptr[4*mb_x+1];
                    }
                }else{
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
                        ptr[4*mb_x+0] = s->RGBbuffer[mb_x][0];
                        ptr[4*mb_x+1] = s->RGBbuffer[mb_x][1];
                        ptr[4*mb_x+2] = s->RGBbuffer[mb_x][2];
                    }
                }
            }
    return 0;
}

static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
    int i, mb_x, mb_y;
    const int nb_components=3;

    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
                    if (s->restart_interval && !s->restart_count)
                        s->restart_count = s->restart_interval;

                    if(mb_x==0 || mb_y==0 || s->interlaced){
                        for(i=0;i<nb_components;i++) {
                            uint8_t *ptr;
                    int n, h, v, x, y, c, j, linesize;
                    n = s->nb_blocks[i];
                    c = s->comp_index[i];
                    h = s->h_scount[i];
                    v = s->v_scount[i];
                            x = 0;
                            y = 0;
                            linesize= s->linesize[c];
                            
                            for(j=0; j<n; j++) {
                                int pred;

                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
                                if(y==0 && mb_y==0){
                                    if(x==0 && mb_x==0){
                                        pred= 128 << point_transform;
                                    }else{
                                        pred= ptr[-1];
                                    }
                                }else{
                                    if(x==0 && mb_x==0){
                                        pred= ptr[-linesize];
                                    }else{
                                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
                                    }
                                }
                                
                                if (s->interlaced && s->bottom_field)
                                    ptr += linesize >> 1;
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);

                                if (++x == h) {
                                    x = 0;
                                    y++;
                                }
                            }
                        }
                    }else{
            for(i=0;i<nb_components;i++) {
                uint8_t *ptr;
                    int n, h, v, x, y, c, j, linesize;
                    n = s->nb_blocks[i];
                    c = s->comp_index[i];
                    h = s->h_scount[i];
                    v = s->v_scount[i];
                x = 0;
                y = 0;
                            linesize= s->linesize[c];
                            
                            for(j=0; j<n; j++) {
                                int pred;

                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
                                PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
                                if (++x == h) {
                                    x = 0;
                                    y++;
                                }
                            }
                        }
                    }
                    if (s->restart_interval && !--s->restart_count) {
                        align_get_bits(&s->gb);
                        skip_bits(&s->gb, 16); /* skip RSTn */
                    }
                }
            }
    return 0;
        }

static int mjpeg_decode_scan(MJpegDecodeContext *s){
    int i, mb_x, mb_y;
    const int nb_components=3;

    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
		if (s->restart_interval && !s->restart_count)
		    s->restart_count = s->restart_interval;

            for(i=0;i<nb_components;i++) {
                uint8_t *ptr;
                int n, h, v, x, y, c, j;
                n = s->nb_blocks[i];
                c = s->comp_index[i];
                h = s->h_scount[i];
                v = s->v_scount[i];
                x = 0;
                y = 0;
                for(j=0;j<n;j++) {
                    memset(s->block, 0, sizeof(s->block));
                    if (decode_block(s, s->block, i, 
                                     s->dc_index[i], s->ac_index[i], 
                                     s->quant_index[c]) < 0) {
                        dprintf("error y=%d x=%d\n", mb_y, mb_x);
                        return -1;
                    }
//		    dprintf("mb: %d %d processed\n", mb_y, mb_x);
                    ptr = s->picture.data[c] + 
                        (((s->linesize[c] * (v * mb_y + y) * 8) + 
                        (h * mb_x + x) * 8) >> s->avctx->lowres);
                    if (s->interlaced && s->bottom_field)
                        ptr += s->linesize[c] >> 1;
//av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d \n", mb_x, mb_y, x, y, c, s->bottom_field, (v * mb_y + y) * 8, (h * mb_x + x) * 8);
                    s->idct_put(ptr, s->linesize[c], s->block);
                    if (++x == h) {
                        x = 0;
                        y++;
                    }
                }
            }
	    /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
            if (s->restart_interval && (s->restart_interval < 1350) &&
		!--s->restart_count) {
                align_get_bits(&s->gb);
                skip_bits(&s->gb, 16); /* skip RSTn */
                for (i=0; i<nb_components; i++) /* reset dc */
                    s->last_dc[i] = 1024;
            }
        }
    }
    return 0;
            }

static int mjpeg_decode_sos(MJpegDecodeContext *s)
{
    int len, nb_components, i, h, v, predictor, point_transform;
    int vmax, hmax, index, id;
    const int block_size= s->lossless ? 1 : 8;
    int ilv;

    /* XXX: verify len field validity */
    len = get_bits(&s->gb, 16);
    nb_components = get_bits(&s->gb, 8);
    if (len != 6+2*nb_components)
    {
	dprintf("decode_sos: invalid len (%d)\n", len);
	return -1;
    }
    /* XXX: only interleaved scan accepted */
    if (nb_components != s->nb_components)
    {
	dprintf("decode_sos: components(%d) mismatch\n", nb_components);
        return -1;
    }
    vmax = 0;
    hmax = 0;
    for(i=0;i<nb_components;i++) {
        id = get_bits(&s->gb, 8) - 1;
	dprintf("component: %d\n", id);
        /* find component index */
        for(index=0;index<s->nb_components;index++)
            if (id == s->component_id[index])
                break;
        if (index == s->nb_components)
	{
	    dprintf("decode_sos: index(%d) out of components\n", index);
            return -1;
	}

        s->comp_index[i] = index;

        s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
        s->h_scount[i] = s->h_count[index];
        s->v_scount[i] = s->v_count[index];

        s->dc_index[i] = get_bits(&s->gb, 4);
        s->ac_index[i] = get_bits(&s->gb, 4);

	if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
	    s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
	    goto out_of_range;
#if 0 //buggy
	switch(s->start_code)
	{
	    case SOF0:
		if (dc_index[i] > 1 || ac_index[i] > 1)
		    goto out_of_range;
		break;
	    case SOF1:
	    case SOF2:
		if (dc_index[i] > 3 || ac_index[i] > 3)
		    goto out_of_range;
		break;
	    case SOF3:
		if (dc_index[i] > 3 || ac_index[i] != 0)
		    goto out_of_range;
		break;	
	}
#endif
        }

    predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
    ilv= get_bits(&s->gb, 8);    /* JPEG Se / JPEG-LS ILV */
    skip_bits(&s->gb, 4); /* Ah */
    point_transform= get_bits(&s->gb, 4); /* Al */

    for(i=0;i<nb_components;i++) 
        s->last_dc[i] = 1024;

    if (nb_components > 1) {
        /* interleaved stream */
        s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
        s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
    } else {
        h = s->h_max / s->h_scount[s->comp_index[0]];
        v = s->v_max / s->v_scount[s->comp_index[0]];
        s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
        s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
        s->nb_blocks[0] = 1;
        s->h_scount[0] = 1;
        s->v_scount[0] = 1;
    }

    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
        av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d %s\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "",
               predictor, point_transform, ilv, s->bits,
               s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));

    
    /* mjpeg-b can have padding bytes between sos and image data, skip them */
    for (i = s->mjpb_skiptosod; i > 0; i--)
        skip_bits(&s->gb, 8);

    if(s->lossless){
        if(s->ls){
//            for(){
        }else{
            if(s->rgb){
                if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
                    return -1;
            }else{
                if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
                    return -1;
            }
        }
    }else{
        if(mjpeg_decode_scan(s) < 0)
            return -1;
  }
    emms_c();
    return 0;
 out_of_range:
    dprintf("decode_sos: ac/dc index out of range\n");
    return -1;
}

static int mjpeg_decode_dri(MJpegDecodeContext *s)
{
    if (get_bits(&s->gb, 16) != 4)
	return -1;
    s->restart_interval = get_bits(&s->gb, 16);
    s->restart_count = 0;
    dprintf("restart interval: %d\n", s->restart_interval);

    return 0;
}

static int mjpeg_decode_app(MJpegDecodeContext *s)
{
    int len, id;

    len = get_bits(&s->gb, 16);
    if (len < 5)
	return -1;
    if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
        return -1;

    id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
    id = be2me_32(id);
    len -= 6;

    if(s->avctx->debug & FF_DEBUG_STARTCODE){
        av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id); 
    }
    
    /* buggy AVID, it puts EOI only at every 10th frame */
    /* also this fourcc is used by non-avid files too, it holds some
       informations, but it's always present in AVID creates files */
    if (id == ff_get_fourcc("AVI1"))
    {
	/* structure:
	    4bytes	AVI1
	    1bytes	polarity
	    1bytes	always zero
	    4bytes	field_size
	    4bytes	field_size_less_padding
	*/
    	s->buggy_avid = 1;
//	if (s->first_picture)
//	    printf("mjpeg: workarounding buggy AVID\n");
	s->interlace_polarity = get_bits(&s->gb, 8);
#if 0
	skip_bits(&s->gb, 8);
	skip_bits(&s->gb, 32);