static int read_line(int fd, char **line, char **lin)
{
int ret;
char buf[BUFF_SIZE + 1];
char *tmp;
while ((ret = read(fd, buf, BUFF_SIZE)))
{
if (ret < 0)
return (-1);
buf[ret] = '\0';
if ((tmp = ft_strchr(buf, '\n')))
{
*tmp = '\0';
if (!(*line = ft_strjoin(*lin, buf)) ||
!(tmp = ft_strdup(tmp + 1)))
return (-1);
free(*lin);
*lin = tmp;
return (1);
}
if (!(tmp = ft_strjoin(*lin, buf)))
return (-1);
free(*lin);
*lin = tmp;
}
return (end_of_file(*line, *lin));
}
int get_next_line(int const fd, char **line)
{
char *buff;
int i;
char *inter;
static char *save_line;
int save;
inter = ((save_line) ? ft_strdup(save_line) : ft_strnew(BUFF_SIZE));
while (inter && (!ft_strchr(inter, '\n')))
{
if ((buff = ft_strnew(BUFF_SIZE)))
{
if ((save = read(fd, buff, BUFF_SIZE)) > 0)
inter = ft_strjoin(inter, buff);
else if (save == 0)
return (end_of_file(line, inter, save_line));
else
return (-1);
free(buff);
}
}
malloc_line(line, inter);
i = ft_strlen_len(inter);
save_line = ft_strsub(inter, i + 1, (ft_strlen(inter) - i));
free(inter);
return (1);
}
void modp::input(istream& s,const Zp_Data& ZpD,bool human)
{
if (s.peek() == EOF)
{ if (s.tellg() == 0)
{ cout << "IO problem. Empty file?" << endl;
throw file_error();
}
throw end_of_file("modp");
}
if (human)
{ bigint te;
s >> te;
to_modp(*this,te,ZpD);
}
else
{ s.read((char*) x,ZpD.t*sizeof(mp_limb_t)); }
bool FeMedia::onGetData( Chunk &data )
{
int offset=0;
data.samples = NULL;
data.sampleCount = 0;
if ( (!m_audio) || end_of_file() )
return false;
while ( offset < m_audio->codec_ctx->sample_rate )
{
AVPacket *packet = m_audio->pop_packet();
while (( packet == NULL ) && ( !end_of_file() ))
{
read_packet();
packet = m_audio->pop_packet();
}
if ( packet == NULL )
{
m_audio->at_end=true;
if ( offset > 0 )
return true;
return false;
}
#if (LIBAVCODEC_VERSION_INT < AV_VERSION_INT( 53, 25, 0 ))
{
sf::Lock l( m_audio->buffer_mutex );
int bsize = MAX_AUDIO_FRAME_SIZE;
if ( avcodec_decode_audio3(
m_audio->codec_ctx,
(m_audio->buffer + offset),
&bsize, packet) < 0 )
{
std::cerr << "Error decoding audio." << std::endl;
FeBaseStream::free_packet( packet );
return false;
}
else
{
offset += bsize / sizeof( sf::Int16 );
data.sampleCount += bsize / sizeof(sf::Int16);
data.samples = m_audio->buffer;
}
}
#else
#if (LIBAVCODEC_VERSION_INT >= AV_VERSION_INT( 55, 45, 0 ))
AVFrame *frame = av_frame_alloc();
m_audio->codec_ctx->refcounted_frames = 1;
#else
AVFrame *frame = avcodec_alloc_frame();
#endif
//
// TODO: avcodec_decode_audio4() can return multiple frames per packet depending on the codec.
// We don't deal with this appropriately...
//
int got_frame( 0 );
int len = avcodec_decode_audio4( m_audio->codec_ctx, frame, &got_frame, packet );
if ( len < 0 )
{
#ifdef FE_DEBUG
char buff[256];
av_strerror( len, buff, 256 );
std::cerr << "Error decoding audio: " << buff << std::endl;
#endif
}
if ( got_frame )
{
int data_size = av_samples_get_buffer_size(
NULL,
m_audio->codec_ctx->channels,
frame->nb_samples,
m_audio->codec_ctx->sample_fmt, 1);
#ifdef DO_RESAMPLE
if ( m_audio->codec_ctx->sample_fmt == AV_SAMPLE_FMT_S16 )
#endif
{
sf::Lock l( m_audio->buffer_mutex );
memcpy( (m_audio->buffer + offset), frame->data[0], data_size );
offset += data_size / sizeof( sf::Int16 );
data.sampleCount += data_size / sizeof(sf::Int16);
data.samples = m_audio->buffer;
}
#ifdef DO_RESAMPLE
else
{
sf::Lock l( m_audio->buffer_mutex );
if ( !m_audio->resample_ctx )
{
m_audio->resample_ctx = resample_alloc();
if ( !m_audio->resample_ctx )
{
std::cerr << "Error allocating audio format converter." << std::endl;
FeBaseStream::free_packet( packet );
FeBaseStream::free_frame( frame );
return false;
}
int64_t channel_layout = frame->channel_layout;
if ( !channel_layout )
{
channel_layout = av_get_default_channel_layout(
m_audio->codec_ctx->channels );
}
av_opt_set_int( m_audio->resample_ctx, "in_channel_layout", channel_layout, 0 );
av_opt_set_int( m_audio->resample_ctx, "in_sample_fmt", frame->format, 0 );
av_opt_set_int( m_audio->resample_ctx, "in_sample_rate", frame->sample_rate, 0 );
av_opt_set_int( m_audio->resample_ctx, "out_channel_layout", channel_layout, 0 );
av_opt_set_int( m_audio->resample_ctx, "out_sample_fmt", AV_SAMPLE_FMT_S16, 0 );
av_opt_set_int( m_audio->resample_ctx, "out_sample_rate", frame->sample_rate, 0 );
#ifdef FE_DEBUG
std::cout << "Initializing resampler: in_sample_fmt="
<< av_get_sample_fmt_name( (AVSampleFormat)frame->format )
<< ", in_sample_rate=" << frame->sample_rate
<< ", out_sample_fmt=" << av_get_sample_fmt_name( AV_SAMPLE_FMT_S16 )
<< ", out_sample_rate=" << frame->sample_rate << std::endl;
#endif
if ( resample_init( m_audio->resample_ctx ) < 0 )
{
std::cerr << "Error initializing audio format converter, input format="
<< av_get_sample_fmt_name( (AVSampleFormat)frame->format )
<< ", input sample rate=" << frame->sample_rate << std::endl;
FeBaseStream::free_packet( packet );
FeBaseStream::free_frame( frame );
resample_free( &m_audio->resample_ctx );
m_audio->resample_ctx = NULL;
return false;
}
}
if ( m_audio->resample_ctx )
{
int out_linesize;
av_samples_get_buffer_size(
&out_linesize,
m_audio->codec_ctx->channels,
frame->nb_samples,
AV_SAMPLE_FMT_S16, 0 );
uint8_t *tmp_ptr = (uint8_t *)(m_audio->buffer + offset);
#ifdef USE_SWRESAMPLE
int out_samples = swr_convert(
m_audio->resample_ctx,
&tmp_ptr,
frame->nb_samples,
(const uint8_t **)frame->data,
frame->nb_samples );
#else // USE_AVRESAMPLE
int out_samples = avresample_convert(
m_audio->resample_ctx,
&tmp_ptr,
out_linesize,
frame->nb_samples,
frame->data,
frame->linesize[0],
frame->nb_samples );
#endif
if ( out_samples < 0 )
{
std::cerr << "Error performing audio conversion." << std::endl;
FeBaseStream::free_packet( packet );
FeBaseStream::free_frame( frame );
break;
}
offset += out_samples * m_audio->codec_ctx->channels;
data.sampleCount += out_samples * m_audio->codec_ctx->channels;
data.samples = m_audio->buffer;
}
}
#endif
}
FeBaseStream::free_frame( frame );
#endif
FeBaseStream::free_packet( packet );
}
return true;
}
