Attachment #3703 for bug #20899

View | Details | Raw Unified | Return to bug 20899
Collapse All | Expand All




}


static int
calcNeeded(lame_global_flags* gfp)
{
    int mf_needed;
    /* some sanity checks */
#if ENCDELAY < MDCTDELAY
# error ENCDELAY is less than MDCTDELAY, see encoder.h
#endif
#if FFTOFFSET > BLKSIZE
# error FFTOFFSET is greater than BLKSIZE, see encoder.h
#endif

    mf_needed = BLKSIZE + gfp->framesize - FFTOFFSET; /* amount needed for FFT */
    /*mf_needed = Max(mf_needed, 286 + 576 * (1 + gfc->mode_gr)); */
    mf_needed = Max(mf_needed, 512 + gfp->framesize - 32);

    assert(MFSIZE >= mf_needed);
    
    return mf_needed;
}

/*
 * THE MAIN LAME ENCODING INTERFACE
 * mt 3/00

        }
    }

    mf_needed = calcNeeded(gfp);
    /* some sanity checks */
#if ENCDELAY < MDCTDELAY
# error ENCDELAY is less than MDCTDELAY, see encoder.h
#endif
#if FFTOFFSET > BLKSIZE
# error FFTOFFSET is greater than BLKSIZE, see encoder.h
#endif

    mf_needed = BLKSIZE + gfp->framesize - FFTOFFSET; /* amount needed for FFT */
    /*mf_needed = Max(mf_needed, 286 + 576 * (1 + gfc->mode_gr)); */
    mf_needed = Max(mf_needed, 512 + gfp->framesize - 32);

    assert(MFSIZE >= mf_needed);

    mfbuf[0] = gfc->mfbuf[0];
    mfbuf[1] = gfc->mfbuf[1];

        /* update mfbuf[] counters */
        gfc->mf_size += n_out;
        assert(gfc->mf_size <= MFSIZE);

        /* lame_encode_flush may have set gfc->mf_sample_to_encode to 0
         * so we have to reinitialize it here when that happened.
         */
        if (gfc->mf_samples_to_encode < 1) {
            gfc->mf_samples_to_encode = ENCDELAY + POSTDELAY;
        }
        gfc->mf_samples_to_encode += n_out;




    /* we always add POSTDELAY=288 padding to make sure granule with real
     * data can be complety decoded (because of 50% overlap with next granule */
    int     end_padding;
    int     pad_out_samples;
    int     frames_left;
    int     samples_to_encode = gfc->mf_samples_to_encode - POSTDELAY+288;
    int     mf_needed = calcNeeded(gfp);

    /* Was flush already called? */
    if (gfc->mf_samples_to_encode < 1) {
        return 0;
    }
    memset(buffer, 0, sizeof(buffer));
    mp3count = 0;

    if (gfp->in_samplerate != gfp->out_samplerate) {
        /* delay due to resampling; needs to be fixed, if resampling code gets changed */
        samples_to_encode += 16.*gfp->out_samplerate/gfp->in_samplerate;
    }
    end_padding = gfp->framesize - (samples_to_encode % gfp->framesize);
    gfp->encoder_padding = end_padding;

    frames_left = (samples_to_encode + end_padding) / gfp->framesize;

    /* send in a frame of 0 padding until all internal sample buffers are flushed */
    while (frames_left > 0 && imp3 >= 0) {
        int bunch = mf_needed-gfc->mf_size;
        int frame_num = gfp->frameNum;
        
        bunch *= gfp->in_samplerate;
        bunch /= gfp->out_samplerate;
        if (bunch > 1152) bunch = 1152;
        if (bunch < 1) bunch = 1;

        mp3buffer_size_remaining = mp3buffer_size - mp3count;


        if (mp3buffer_size == 0)
            mp3buffer_size_remaining = 0;

        imp3 = lame_encode_buffer(gfp, buffer[0], buffer[1], bunch,
         * are flushed
         */
        imp3 = lame_encode_buffer(gfp, buffer[0], buffer[1], 32,
                                  mp3buffer, mp3buffer_size_remaining);
        
        if (frame_num != gfp->frameNum) {
            --frames_left;
        }
        if (imp3 < 0) {
            /* some type of fatal error */
            return imp3;
        }
        mp3buffer += imp3;
        mp3count += imp3;
        frames_left -= (frame_num != gfp->frameNum) ? 1 : 0;
    }
    /* Set gfc->mf_samples_to_encode to 0, so we may detect
     * and break loops calling it more than once in a row.
     */
    gfc->mf_samples_to_encode = 0;

    if (imp3 < 0) {
        /* some type of fatal error */
        return imp3;
    }

    mp3buffer_size_remaining = mp3buffer_size - mp3count;
    /* if user specifed buffer size = 0, dont check size */
    if (mp3buffer_size == 0)

        }
        mp3count += imp3;
    }
    gfp->encoder_padding = end_padding;
#if 0
    {
        int const ed = gfp->encoder_delay;

        MSGF(gfc, "encoder padding=%d\n", ep);
        MSGF(gfc, "sample count=%d (%g)\n", ns, gfp->in_samplerate*duration);
        MSGF(gfc, "duration=%g sec\n", duration);
        MSGF(gfc, "mf_size=%d\n",gfc->mf_size);
        MSGF(gfc, "mf_samples_to_encode=%d\n",gfc->mf_samples_to_encode);
    }
#endif
    return mp3count;

/* flush internal mp3 buffers, and free internal buffers         */
/*****************************************************************/
#if DEPRECATED_OR_OBSOLETE_CODE_REMOVED
/* OBSOLETE */
int CDECL
lame_encode_finish(lame_global_flags * gfp, unsigned char *mp3buffer, int mp3buffer_size);
#else
#endif

int
lame_encode_finish(lame_global_flags * gfp, unsigned char *mp3buffer, int mp3buffer_size)
{


    return ret;
}
#endif

/*****************************************************************/
/* write VBR Xing header, and ID3 version 1 tag, if asked for    */

Return to bug 20899

Lines 1472-1477 Link Here

(-)./libmp3lame/lame.c (-35 / +68 lines)
1472	}	1476	}
1473		1477
1474		1478
		1479	static int
		1480	calcNeeded(lame_global_flags* gfp)
		1481	{
		1482	int mf_needed;
		1483	/* some sanity checks */
		1484	#if ENCDELAY < MDCTDELAY
		1485	# error ENCDELAY is less than MDCTDELAY, see encoder.h
		1486	#endif
		1487	#if FFTOFFSET > BLKSIZE
		1488	# error FFTOFFSET is greater than BLKSIZE, see encoder.h
		1489	#endif
		1490
		1491	mf_needed = BLKSIZE + gfp->framesize - FFTOFFSET; /* amount needed for FFT */
		1492	/mf_needed = Max(mf_needed, 286 + 576 (1 + gfc->mode_gr)); */
		1493	mf_needed = Max(mf_needed, 512 + gfp->framesize - 32);
		1494
		1495	assert(MFSIZE >= mf_needed);
		1496
		1497	return mf_needed;
		1498	}
		1499
1475	/*	1500	/*
1476	* THE MAIN LAME ENCODING INTERFACE	1501	* THE MAIN LAME ENCODING INTERFACE
1477	* mt 3/00	1502	* mt 3/00
Lines 1555-1574 Link Here
1555	}	1580	}
1556	}	1581	}
1557		1582
1558		1583	mf_needed = calcNeeded(gfp);
1559	/* some sanity checks */
1560	#if ENCDELAY < MDCTDELAY
1561	# error ENCDELAY is less than MDCTDELAY, see encoder.h
1562	#endif
1563	#if FFTOFFSET > BLKSIZE
1564	# error FFTOFFSET is greater than BLKSIZE, see encoder.h
1565	#endif
1566
1567	mf_needed = BLKSIZE + gfp->framesize - FFTOFFSET; /* amount needed for FFT */
1568	/mf_needed = Max(mf_needed, 286 + 576 (1 + gfc->mode_gr)); */
1569	mf_needed = Max(mf_needed, 512 + gfp->framesize - 32);
1570
1571	assert(MFSIZE >= mf_needed);
1572		1584
1573	mfbuf[0] = gfc->mfbuf[0];	1585	mfbuf[0] = gfc->mfbuf[0];
1574	mfbuf[1] = gfc->mfbuf[1];	1586	mfbuf[1] = gfc->mfbuf[1];
Lines 1602-1607 Link Here
1602	/* update mfbuf[] counters */	1614	/* update mfbuf[] counters */
1603	gfc->mf_size += n_out;	1615	gfc->mf_size += n_out;
1604	assert(gfc->mf_size <= MFSIZE);	1616	assert(gfc->mf_size <= MFSIZE);
		1617
		1618	/* lame_encode_flush may have set gfc->mf_sample_to_encode to 0
		1619	* so we have to reinitialize it here when that happened.
		1620	*/
		1621	if (gfc->mf_samples_to_encode < 1) {
		1622	gfc->mf_samples_to_encode = ENCDELAY + POSTDELAY;
		1623	}
1605	gfc->mf_samples_to_encode += n_out;	1624	gfc->mf_samples_to_encode += n_out;
1606		1625
1607		1626
Lines 1926-1949 Link Here
1926		1945
1927	/* we always add POSTDELAY=288 padding to make sure granule with real	1946	/* we always add POSTDELAY=288 padding to make sure granule with real
1928	* data can be complety decoded (because of 50% overlap with next granule */	1947	* data can be complety decoded (because of 50% overlap with next granule */
1929	int end_padding = POSTDELAY;	1948	int end_padding;
1930	int pad_out_samples;
1931	int frames_left;	1949	int frames_left;
1932	int samples_to_encode = gfc->mf_samples_to_encode;	1950	int samples_to_encode = gfc->mf_samples_to_encode - POSTDELAY+288;
		1951	int mf_needed = calcNeeded(gfp);
1933		1952
		1953	/* Was flush already called? */
		1954	if (gfc->mf_samples_to_encode < 1) {
		1955	return 0;
		1956	}
1934	memset(buffer, 0, sizeof(buffer));	1957	memset(buffer, 0, sizeof(buffer));
1935	mp3count = 0;	1958	mp3count = 0;
1936		1959
1937	if (gfp->in_samplerate != gfp->out_samplerate) {	1960	if (gfp->in_samplerate != gfp->out_samplerate) {
1938	/* delay due to resampling; needs to be fixed, if resampling code gets changed */	1961	/* delay due to resampling; needs to be fixed, if resampling code gets changed */
1939	samples_to_encode += 16.*gfp->out_samplerate/gfp->in_samplerate;	1962	samples_to_encode += 16.*gfp->out_samplerate/gfp->in_samplerate;
1940	}	1963	}
1941	pad_out_samples = gfp->framesize - (samples_to_encode % gfp->framesize);	1964	end_padding = gfp->framesize - (samples_to_encode % gfp->framesize);
1942	end_padding += pad_out_samples;	1965	gfp->encoder_padding = end_padding;
1943		1966
1944	frames_left = (samples_to_encode + pad_out_samples) / gfp->framesize;	1967	frames_left = (samples_to_encode + end_padding) / gfp->framesize;
1945	while (frames_left > 0) {	1968
		1969	/* send in a frame of 0 padding until all internal sample buffers are flushed */
		1970	while (frames_left > 0 && imp3 >= 0) {
		1971	int bunch = mf_needed-gfc->mf_size;
1946	int frame_num = gfp->frameNum;	1972	int frame_num = gfp->frameNum;
		1973
		1974	bunch *= gfp->in_samplerate;
		1975	bunch /= gfp->out_samplerate;
		1976	if (bunch > 1152) bunch = 1152;
		1977	if (bunch < 1) bunch = 1;
1947		1978
1948	mp3buffer_size_remaining = mp3buffer_size - mp3count;	1979	mp3buffer_size_remaining = mp3buffer_size - mp3count;
1949		1980
Lines 1951-1972 Link Here
1951	if (mp3buffer_size == 0)	1982	if (mp3buffer_size == 0)
1952	mp3buffer_size_remaining = 0;	1983	mp3buffer_size_remaining = 0;
1953		1984
1954	/* send in a frame of 0 padding until all internal sample buffers	1985	imp3 = lame_encode_buffer(gfp, buffer[0], buffer[1], bunch,
1955	* are flushed
1956	*/
1957	imp3 = lame_encode_buffer(gfp, buffer[0], buffer[1], 32,
1958	mp3buffer, mp3buffer_size_remaining);	1986	mp3buffer, mp3buffer_size_remaining);
1959		1987
1960	if (frame_num != gfp->frameNum) {
1961	--frames_left;
1962	}
1963	if (imp3 < 0) {
1964	/* some type of fatal error */
1965	return imp3;
1966	}
1967	mp3buffer += imp3;	1988	mp3buffer += imp3;
1968	mp3count += imp3;	1989	mp3count += imp3;
		1990	frames_left -= (frame_num != gfp->frameNum) ? 1 : 0;
1969	}	1991	}
		1992	/* Set gfc->mf_samples_to_encode to 0, so we may detect
		1993	* and break loops calling it more than once in a row.
		1994	*/
		1995	gfc->mf_samples_to_encode = 0;
		1996
		1997	if (imp3 < 0) {
		1998	/* some type of fatal error */
		1999	return imp3;
		2000	}
		2001
1970	mp3buffer_size_remaining = mp3buffer_size - mp3count;	2002	mp3buffer_size_remaining = mp3buffer_size - mp3count;
1971	/* if user specifed buffer size = 0, dont check size */	2003	/* if user specifed buffer size = 0, dont check size */
1972	if (mp3buffer_size == 0)	2004	if (mp3buffer_size == 0)
Lines 1997-2003 Link Here
1997	}	2029	}
1998	mp3count += imp3;	2030	mp3count += imp3;
1999	}	2031	}
2000	gfp->encoder_padding = end_padding;
2001	#if 0	2032	#if 0
2002	{	2033	{
2003	int const ed = gfp->encoder_delay;	2034	int const ed = gfp->encoder_delay;
Lines 2011-2016 Link Here
2011	MSGF(gfc, "encoder padding=%d\n", ep);	2042	MSGF(gfc, "encoder padding=%d\n", ep);
2012	MSGF(gfc, "sample count=%d (%g)\n", ns, gfp->in_samplerate*duration);	2043	MSGF(gfc, "sample count=%d (%g)\n", ns, gfp->in_samplerate*duration);
2013	MSGF(gfc, "duration=%g sec\n", duration);	2044	MSGF(gfc, "duration=%g sec\n", duration);
		2045	MSGF(gfc, "mf_size=%d\n",gfc->mf_size);
		2046	MSGF(gfc, "mf_samples_to_encode=%d\n",gfc->mf_samples_to_encode);
2014	}	2047	}
2015	#endif	2048	#endif
2016	return mp3count;	2049	return mp3count;
Lines 2052-2058 Link Here
2052	/* flush internal mp3 buffers, and free internal buffers */	2085	/* flush internal mp3 buffers, and free internal buffers */
2053	/*****************************************************************/	2086	/*****************************************************************/
2054	#if DEPRECATED_OR_OBSOLETE_CODE_REMOVED	2087	#if DEPRECATED_OR_OBSOLETE_CODE_REMOVED
		2088	/* OBSOLETE */
		2089	int CDECL
		2090	lame_encode_finish(lame_global_flags * gfp, unsigned char *mp3buffer, int mp3buffer_size);
2055	#else	2091	#else
		2092	#endif
		2093
2056	int	2094	int
2057	lame_encode_finish(lame_global_flags * gfp, unsigned char *mp3buffer, int mp3buffer_size)	2095	lame_encode_finish(lame_global_flags * gfp, unsigned char *mp3buffer, int mp3buffer_size)
2058	{	2096	{
Lines 2062-2068 Link Here
2062		2100
2063	return ret;	2101	return ret;
2064	}	2102	}
2065	#endif
2066		2103
2067	/*****************************************************************/	2104	/*****************************************************************/
2068	/* write VBR Xing header, and ID3 version 1 tag, if asked for */	2105	/* write VBR Xing header, and ID3 version 1 tag, if asked for */