#include "hb.h"
#include "hbffmpeg.h"
-
-//#include "libavcodec/audioconvert.h"
-#include "../contrib/ffmpeg/libavcodec/audioconvert.h"
+#include "downmix.h"
+#include "libavcodec/audioconvert.h"
static int decavcodecInit( hb_work_object_t *, hb_job_t * );
static int decavcodecWork( hb_work_object_t *, hb_buffer_t **, hb_buffer_t ** );
pts_heap_t pts_heap;
void* buffer;
struct SwsContext *sws_context; // if we have to rescale or convert color space
+ hb_downmix_t *downmix;
+ hb_sample_t *downmix_buffer;
};
+static void decodeAudio( hb_audio_t * audio, hb_work_private_t *pv, uint8_t *data, int size );
+static hb_buffer_t *link_buf_list( hb_work_private_t *pv );
+
+
static int64_t heap_pop( pts_heap_t *heap )
{
int64_t result;
w->private_data = pv;
pv->job = job;
+ pv->list = hb_list_init();
int codec_id = w->codec_param;
/*XXX*/
pv->context = avcodec_alloc_context();
hb_avcodec_open( pv->context, codec );
+ if ( w->audio != NULL &&
+ hb_need_downmix( w->audio->config.in.channel_layout,
+ w->audio->config.out.mixdown) )
+ {
+ pv->downmix = hb_downmix_init(w->audio->config.in.channel_layout,
+ w->audio->config.out.mixdown);
+ hb_downmix_set_chan_map( pv->downmix, &hb_smpte_chan_map, &hb_qt_chan_map );
+ }
+
return 0;
}
}
if ( pv->buffer )
{
- free( pv->buffer );
+ av_free( pv->buffer );
pv->buffer = NULL;
}
+ if ( pv->downmix )
+ {
+ hb_downmix_close( &(pv->downmix) );
+ }
+ if ( pv->downmix_buffer )
+ {
+ free( pv->downmix_buffer );
+ pv->downmix_buffer = NULL;
+ }
free( pv );
w->private_data = NULL;
}
hb_buffer_t ** buf_out )
{
hb_work_private_t * pv = w->private_data;
- hb_buffer_t * in = *buf_in, * buf, * last = NULL;
- int pos, len, out_size, i, uncompressed_len;
- short buffer[AVCODEC_MAX_AUDIO_FRAME_SIZE];
- uint64_t cur;
- unsigned char *parser_output_buffer;
- int parser_output_buffer_len;
+ hb_buffer_t * in = *buf_in;
- if ( (*buf_in)->size <= 0 )
+ if ( in->size <= 0 )
{
/* EOF on input stream - send it downstream & say that we're done */
- *buf_out = *buf_in;
+ *buf_out = in;
*buf_in = NULL;
return HB_WORK_DONE;
}
return HB_WORK_OK;
}
- cur = ( in->start < 0 )? pv->pts_next : in->start;
+ // if the packet has a timestamp use it
+ if ( in->start != -1 )
+ {
+ pv->pts_next = in->start;
+ }
- pos = 0;
- while( pos < in->size )
+ int pos, len;
+ for ( pos = 0; pos < in->size; pos += len )
{
- len = av_parser_parse( pv->parser, pv->context,
- &parser_output_buffer, &parser_output_buffer_len,
- in->data + pos, in->size - pos, cur, cur );
- out_size = 0;
- uncompressed_len = 0;
- if (parser_output_buffer_len)
+ uint8_t *parser_output_buffer;
+ int parser_output_buffer_len;
+ int64_t cur = pv->pts_next;
+
+ if ( pv->parser != NULL )
{
- out_size = sizeof(buffer);
- uncompressed_len = avcodec_decode_audio2( pv->context, buffer,
- &out_size,
- parser_output_buffer,
- parser_output_buffer_len );
+ len = av_parser_parse2( pv->parser, pv->context,
+ &parser_output_buffer, &parser_output_buffer_len,
+ in->data + pos, in->size - pos, cur, cur, AV_NOPTS_VALUE );
}
- if( out_size )
+ else
{
- short * s16;
- float * fl32;
-
- buf = hb_buffer_init( 2 * out_size );
-
- int sample_size_in_bytes = 2; // Default to 2 bytes
- switch (pv->context->sample_fmt)
- {
- case SAMPLE_FMT_S16:
- sample_size_in_bytes = 2;
- break;
- /* We should handle other formats here - but that needs additional format conversion work below */
- /* For now we'll just report the error and try to carry on */
- default:
- hb_log("decavcodecWork - Unknown Sample Format from avcodec_decode_audio (%d) !", pv->context->sample_fmt);
- break;
- }
-
- buf->start = cur;
- buf->stop = cur + 90000 * ( out_size / (sample_size_in_bytes * pv->context->channels) ) /
- pv->context->sample_rate;
- cur = buf->stop;
-
- s16 = buffer;
- fl32 = (float *) buf->data;
- for( i = 0; i < out_size / 2; i++ )
- {
- fl32[i] = s16[i];
- }
-
- if( last )
- {
- last = last->next = buf;
- }
- else
+ parser_output_buffer = in->data;
+ len = parser_output_buffer_len = in->size;
+ }
+ if (parser_output_buffer_len)
+ {
+ // set the duration on every frame since the stream format can
+ // change (it shouldn't but there's no way to guarantee it).
+ // duration is a scaling factor to go from #bytes in the decoded
+ // frame to frame time (in 90KHz mpeg ticks). 'channels' converts
+ // total samples to per-channel samples. 'sample_rate' converts
+ // per-channel samples to seconds per sample and the 90000
+ // is mpeg ticks per second.
+ if ( pv->context->sample_rate && pv->context->channels )
{
- *buf_out = last = buf;
+ pv->duration = 90000. /
+ (double)( pv->context->sample_rate * pv->context->channels );
}
+ decodeAudio( w->audio, pv, parser_output_buffer, parser_output_buffer_len );
}
-
- pos += len;
}
-
- pv->pts_next = cur;
-
+ *buf_out = link_buf_list( pv );
return HB_WORK_OK;
}
return 0;
}
-static const int chan2layout[] = {
- HB_INPUT_CH_LAYOUT_MONO, // We should allow no audio really.
- HB_INPUT_CH_LAYOUT_MONO,
- HB_INPUT_CH_LAYOUT_STEREO,
- HB_INPUT_CH_LAYOUT_2F1R,
- HB_INPUT_CH_LAYOUT_2F2R,
- HB_INPUT_CH_LAYOUT_3F2R,
- HB_INPUT_CH_LAYOUT_4F2R,
- HB_INPUT_CH_LAYOUT_STEREO,
- HB_INPUT_CH_LAYOUT_STEREO,
-};
-
static int decavcodecBSInfo( hb_work_object_t *w, const hb_buffer_t *buf,
hb_work_info_t *info )
{
AVCodecParserContext *parser = av_parser_init( codec->id );
AVCodecContext *context = avcodec_alloc_context();
hb_avcodec_open( context, codec );
-#ifdef SYS_CYGWIN
- uint8_t *buffer = memalign(16, AVCODEC_MAX_AUDIO_FRAME_SIZE);
-#else
- uint8_t *buffer = malloc( AVCODEC_MAX_AUDIO_FRAME_SIZE );
-#endif
+ uint8_t *buffer = av_malloc( AVCODEC_MAX_AUDIO_FRAME_SIZE );
int out_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
unsigned char *pbuffer;
- int pos = 0, pbuffer_size;
+ int pos, pbuffer_size;
- while ( pos < buf->size )
+ while ( buf && !ret )
{
- int len = av_parser_parse( parser, context, &pbuffer, &pbuffer_size,
- buf->data + pos, buf->size - pos,
- buf->start, buf->start );
- pos += len;
- if ( pbuffer_size > 0 )
+ pos = 0;
+ while ( pos < buf->size )
{
- len = avcodec_decode_audio2( context, (int16_t*)buffer, &out_size,
- pbuffer, pbuffer_size );
- if ( len > 0 && context->sample_rate > 0 )
+ int len;
+
+ if (parser != NULL )
+ {
+ len = av_parser_parse2( parser, context, &pbuffer,
+ &pbuffer_size, buf->data + pos,
+ buf->size - pos, buf->start,
+ buf->start, AV_NOPTS_VALUE );
+ }
+ else
+ {
+ pbuffer = buf->data;
+ len = pbuffer_size = buf->size;
+ }
+ pos += len;
+ if ( pbuffer_size > 0 )
{
- info->bitrate = context->bit_rate;
- info->rate = context->sample_rate;
- info->rate_base = 1;
- info->channel_layout = chan2layout[context->channels & 7];
- ret = 1;
- break;
+ AVPacket avp;
+ av_init_packet( &avp );
+ avp.data = pbuffer;
+ avp.size = pbuffer_size;
+
+ len = avcodec_decode_audio3( context, (int16_t*)buffer,
+ &out_size, &avp );
+ if ( len > 0 && context->sample_rate > 0 )
+ {
+ info->bitrate = context->bit_rate;
+ info->rate = context->sample_rate;
+ info->rate_base = 1;
+ info->channel_layout =
+ hb_ff_layout_xlat(context->channel_layout,
+ context->channels);
+ ret = 1;
+ break;
+ }
}
}
+ buf = buf->next;
}
- free( buffer );
- av_parser_close( parser );
+
+ av_free( buffer );
+ if ( parser != NULL )
+ av_parser_close( parser );
hb_avcodec_close( context );
return ret;
}
return avcodec_default_get_buffer( context, frame );
}
+static int reget_frame_buf( AVCodecContext *context, AVFrame *frame )
+{
+ hb_work_private_t *pv = context->opaque;
+ frame->pts = pv->pts;
+ pv->pts = -1;
+ return avcodec_default_reget_buffer( context, frame );
+}
+
static void log_chapter( hb_work_private_t *pv, int chap_num, int64_t pts )
{
- hb_chapter_t *c = hb_list_item( pv->job->title->list_chapter, chap_num - 1 );
+ hb_chapter_t *c;
+
+ if ( !pv->job )
+ return;
+
+ c = hb_list_item( pv->job->title->list_chapter, chap_num - 1 );
if ( c && c->title )
{
- hb_log( "%s: \"%s\" (%d) at frame %u time %lld",
+ hb_log( "%s: \"%s\" (%d) at frame %u time %"PRId64,
pv->context->codec->name, c->title, chap_num, pv->nframes, pts );
}
else
{
- hb_log( "%s: Chapter %d at frame %u time %lld",
+ hb_log( "%s: Chapter %d at frame %u time %"PRId64,
pv->context->codec->name, chap_num, pv->nframes, pts );
}
}
}
}
-static int decodeFrame( hb_work_private_t *pv, uint8_t *data, int size )
+/*
+ * Decodes a video frame from the specified raw packet data ('data', 'size', 'sequence').
+ * The output of this function is stored in 'pv->list', which contains a list
+ * of zero or more decoded packets.
+ *
+ * The returned packets are guaranteed to have their timestamps in the correct order,
+ * even if the original packets decoded by libavcodec have misordered timestamps,
+ * due to the use of 'packed B-frames'.
+ *
+ * Internally the set of decoded packets may be buffered in 'pv->delayq'
+ * until enough packets have been decoded so that the timestamps can be
+ * correctly rewritten, if this is necessary.
+ */
+static int decodeFrame( hb_work_private_t *pv, uint8_t *data, int size, int sequence )
{
- int got_picture;
+ int got_picture, oldlevel = 0;
AVFrame frame;
+ AVPacket avp;
- if ( avcodec_decode_video( pv->context, &frame, &got_picture, data, size ) < 0 )
+ if ( global_verbosity_level <= 1 )
+ {
+ oldlevel = av_log_get_level();
+ av_log_set_level( AV_LOG_QUIET );
+ }
+
+ av_init_packet( &avp );
+ avp.data = data;
+ avp.size = size;
+ if ( avcodec_decode_video2( pv->context, &frame, &got_picture, &avp ) < 0 )
{
++pv->decode_errors;
}
+ if ( global_verbosity_level <= 1 )
+ {
+ av_log_set_level( oldlevel );
+ }
if( got_picture )
{
// ffmpeg makes it hard to attach a pts to a frame. if the MPEG ES
{
frame_dur += frame.repeat_pict * frame_dur * 0.5;
}
+ // XXX Unlike every other video decoder, the Raw decoder doesn't
+ // use the standard buffer allocation routines so we never
+ // get to put a PTS in the frame. Do it now.
+ if ( pv->context->codec_id == CODEC_ID_RAWVIDEO )
+ {
+ frame.pts = pv->pts;
+ pv->pts = -1;
+ }
// If there was no pts for this frame, assume constant frame rate
// video & estimate the next frame time from the last & duration.
double pts = frame.pts;
{
buf = copy_frame( pv, &frame );
buf->start = pts;
+ buf->sequence = sequence;
+ if ( pv->new_chap && buf->start >= pv->chap_time )
+ {
+ buf->new_chap = pv->new_chap;
+ pv->new_chap = 0;
+ pv->chap_time = 0;
+ log_chapter( pv, buf->new_chap, buf->start );
+ }
+ else if ( pv->nframes == 0 && pv->job )
+ {
+ log_chapter( pv, pv->job->chapter_start, buf->start );
+ }
hb_list_add( pv->list, buf );
++pv->nframes;
return got_picture;
pv->chap_time = 0;
log_chapter( pv, buf->new_chap, buf->start );
}
- else if ( pv->nframes == 0 )
+ else if ( pv->nframes == 0 && pv->job )
{
log_chapter( pv, pv->job->chapter_start, buf->start );
}
}
// add the new frame to the delayq & push its timestamp on the heap
- pv->delayq[slot] = copy_frame( pv, &frame );
+ buf = copy_frame( pv, &frame );
+ buf->sequence = sequence;
+ pv->delayq[slot] = buf;
heap_push( &pv->pts_heap, pts );
++pv->nframes;
return got_picture;
}
-static void decodeVideo( hb_work_private_t *pv, uint8_t *data, int size,
+static void decodeVideo( hb_work_private_t *pv, uint8_t *data, int size, int sequence,
int64_t pts, int64_t dts )
{
/*
do {
uint8_t *pout;
int pout_len;
- int len = av_parser_parse( pv->parser, pv->context, &pout, &pout_len,
- data + pos, size - pos, pts, dts );
+ int len = av_parser_parse2( pv->parser, pv->context, &pout, &pout_len,
+ data + pos, size - pos, pts, dts, AV_NOPTS_VALUE );
pos += len;
if ( pout_len > 0 )
{
pv->pts = pv->parser->pts;
- decodeFrame( pv, pout, pout_len );
+ decodeFrame( pv, pout, pout_len, sequence );
}
} while ( pos < size );
/* the stuff above flushed the parser, now flush the decoder */
if ( size <= 0 )
{
- while ( decodeFrame( pv, NULL, 0 ) )
+ while ( decodeFrame( pv, NULL, 0, sequence ) )
{
}
flushDelayQueue( pv );
}
}
+/*
+ * Removes all packets from 'pv->list', links them together into
+ * a linked-list, and returns the first packet in the list.
+ */
static hb_buffer_t *link_buf_list( hb_work_private_t *pv )
{
hb_buffer_t *head = hb_list_item( pv->list, 0 );
/* we have to wrap ffmpeg's get_buffer to be able to set the pts (?!) */
pv->context->opaque = pv;
pv->context->get_buffer = get_frame_buf;
+ pv->context->reget_buffer = reget_frame_buf;
return 0;
}
/* if we got an empty buffer signaling end-of-stream send it downstream */
if ( in->size == 0 )
{
- decodeVideo( pv, in->data, in->size, pts, dts );
+ decodeVideo( pv, in->data, in->size, in->sequence, pts, dts );
hb_list_add( pv->list, in );
*buf_out = link_buf_list( pv );
return HB_WORK_DONE;
pv->new_chap = in->new_chap;
pv->chap_time = pts >= 0? pts : pv->pts_next;
}
- decodeVideo( pv, in->data, in->size, pts, dts );
+ decodeVideo( pv, in->data, in->size, in->sequence, pts, dts );
hb_buffer_close( &in );
*buf_out = link_buf_list( pv );
return HB_WORK_OK;
info->rate = 27000000;
info->rate_base = (int64_t)context->time_base.num * 27000000LL /
context->time_base.den;
+ if ( context->ticks_per_frame > 1 )
+ {
+ // for ffmpeg 0.5 & later, the H.264 & MPEG-2 time base is
+ // field rate rather than frame rate so convert back to frames.
+ info->rate_base *= context->ticks_per_frame;
+ }
- /* Sometimes there's no pixel aspect set in the source. In that case,
- assume a 1:1 PAR. Otherwise, preserve the source PAR. */
- info->pixel_aspect_width = context->sample_aspect_ratio.num ?
- context->sample_aspect_ratio.num : 1;
- info->pixel_aspect_height = context->sample_aspect_ratio.den ?
- context->sample_aspect_ratio.den : 1;
-
+ info->pixel_aspect_width = context->sample_aspect_ratio.num;
+ info->pixel_aspect_height = context->sample_aspect_ratio.den;
+
+ /* Sometimes there's no pixel aspect set in the source ffmpeg context
+ * which appears to come from the video stream. In that case,
+ * try the pixel aspect in AVStream (which appears to come from
+ * the container). Else assume a 1:1 PAR. */
+ if ( info->pixel_aspect_width == 0 ||
+ info->pixel_aspect_height == 0 )
+ {
+ // There will not be an ffmpeg stream if the file is TS
+ AVStream *st = hb_ffmpeg_avstream( w->codec_param );
+ info->pixel_aspect_width = st && st->sample_aspect_ratio.num ?
+ st->sample_aspect_ratio.num : 1;
+ info->pixel_aspect_height = st && st->sample_aspect_ratio.den ?
+ st->sample_aspect_ratio.den : 1;
+ }
/* ffmpeg returns the Pixel Aspect Ratio (PAR). Handbrake wants the
* Display Aspect Ratio so we convert by scaling by the Storage
* Aspect Ratio (w/h). We do the calc in floating point to get the
// Because the time bases are so screwed up, we only take values
// in the range 8fps - 64fps.
AVRational tb;
- if ( st->time_base.num * 64 > st->time_base.den &&
- st->time_base.den > st->time_base.num * 8 )
+ if ( st->avg_frame_rate.den * 64 > st->avg_frame_rate.num &&
+ st->avg_frame_rate.num > st->avg_frame_rate.den * 8 )
+ {
+ tb.num = st->avg_frame_rate.den;
+ tb.den = st->avg_frame_rate.num;
+ }
+ else if ( st->time_base.num * 64 > st->time_base.den &&
+ st->time_base.den > st->time_base.num * 8 )
{
tb = st->time_base;
}
// we have to wrap ffmpeg's get_buffer to be able to set the pts (?!)
pv->context->opaque = pv;
pv->context->get_buffer = get_frame_buf;
+ pv->context->reget_buffer = reget_frame_buf;
// avi, mkv and possibly mp4 containers can contain the M$ VFW packed
// b-frames abortion that messes up frame ordering and timestamps.
pv->list = hb_list_init();
pv->pts_next = -1;
pv->pts = -1;
+
+ if ( w->audio != NULL &&
+ hb_need_downmix( w->audio->config.in.channel_layout,
+ w->audio->config.out.mixdown) )
+ {
+ pv->downmix = hb_downmix_init(w->audio->config.in.channel_layout,
+ w->audio->config.out.mixdown);
+ hb_downmix_set_chan_map( pv->downmix, &hb_smpte_chan_map, &hb_qt_chan_map );
+ }
+
return 0;
}
hb_buffer_t ** buf_out )
{
hb_work_private_t *pv = w->private_data;
- if ( ! pv->context )
- {
- init_ffmpeg_context( w );
- }
hb_buffer_t *in = *buf_in;
*buf_in = NULL;
if ( in->size == 0 )
{
/* flush any frames left in the decoder */
- while ( decodeFrame( pv, NULL, 0 ) )
+ while ( pv->context && decodeFrame( pv, NULL, 0, in->sequence ) )
{
}
flushDelayQueue( pv );
return HB_WORK_DONE;
}
+ if ( ! pv->context )
+ {
+ init_ffmpeg_context( w );
+ }
+
int64_t pts = in->start;
if( pts >= 0 )
{
pv->chap_time = pts >= 0? pts : pv->pts_next;
}
prepare_ffmpeg_buffer( in );
- decodeFrame( pv, in->data, in->size );
+ decodeFrame( pv, in->data, in->size, in->sequence );
hb_buffer_close( &in );
*buf_out = link_buf_list( pv );
return HB_WORK_OK;
return 0;
}
-static void decodeAudio( hb_work_private_t *pv, uint8_t *data, int size )
+static void decodeAudio( hb_audio_t * audio, hb_work_private_t *pv, uint8_t *data, int size )
{
AVCodecContext *context = pv->context;
int pos = 0;
+ int loop_limit = 256;
while ( pos < size )
{
int16_t *buffer = pv->buffer;
if ( buffer == NULL )
{
- // XXX ffmpeg bug workaround
- // malloc a buffer for the audio decode. On an x86, ffmpeg
- // uses mmx/sse instructions on this buffer without checking
- // that it's 16 byte aligned and this will cause an abort if
- // the buffer is allocated on our stack. Rather than doing
- // complicated, machine dependent alignment here we use the
- // fact that malloc returns an aligned pointer on most architectures.
-
- #ifdef SYS_CYGWIN
- // Cygwin's malloc doesn't appear to return 16-byte aligned memory so use memalign instead.
- pv->buffer = memalign(16, AVCODEC_MAX_AUDIO_FRAME_SIZE);
- #else
- pv->buffer = malloc( AVCODEC_MAX_AUDIO_FRAME_SIZE );
- #endif
-
+ pv->buffer = av_malloc( AVCODEC_MAX_AUDIO_FRAME_SIZE );
buffer = pv->buffer;
}
+
+ AVPacket avp;
+ av_init_packet( &avp );
+ avp.data = data + pos;
+ avp.size = size - pos;
+
int out_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
- int len = avcodec_decode_audio2( context, buffer, &out_size,
- data + pos, size - pos );
- if ( len <= 0 )
+ int nsamples;
+ int len = avcodec_decode_audio3( context, buffer, &out_size, &avp );
+ if ( len < 0 )
{
return;
}
+ if ( len == 0 )
+ {
+ if ( !(loop_limit--) )
+ return;
+ }
+ else
+ loop_limit = 256;
+
pos += len;
if( out_size > 0 )
{
context->sample_fmt, 1,
NULL, 0 );
// get output buffer size (in 2-byte samples) then malloc a buffer
- out_size = ( out_size * 2 ) / isamp;
- buffer = malloc( out_size );
+ nsamples = out_size / isamp;
+ buffer = av_malloc( nsamples * 2 );
// we're doing straight sample format conversion which behaves as if
// there were only one channel.
const int istride[6] = { isamp };
const int ostride[6] = { 2 };
- av_audio_convert( ctx, obuf, ostride, ibuf, istride, out_size >> 1 );
+ av_audio_convert( ctx, obuf, ostride, ibuf, istride, nsamples );
av_audio_convert_free( ctx );
}
- hb_buffer_t *buf = hb_buffer_init( 2 * out_size );
+ else
+ {
+ nsamples = out_size / 2;
+ }
+
+ hb_buffer_t * buf;
- // convert from bytes to total samples
- out_size >>= 1;
+ if ( pv->downmix )
+ {
+ pv->downmix_buffer = realloc(pv->downmix_buffer, nsamples * sizeof(hb_sample_t));
+
+ int i;
+ for( i = 0; i < nsamples; ++i )
+ {
+ pv->downmix_buffer[i] = buffer[i];
+ }
+
+ int n_ch_samples = nsamples / context->channels;
+ int channels = HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(audio->config.out.mixdown);
+
+ buf = hb_buffer_init( n_ch_samples * channels * sizeof(float) );
+ hb_sample_t *samples = (hb_sample_t *)buf->data;
+ hb_downmix(pv->downmix, samples, pv->downmix_buffer, n_ch_samples);
+ }
+ else
+ {
+ buf = hb_buffer_init( nsamples * sizeof(float) );
+ float *fl32 = (float *)buf->data;
+ int i;
+ for( i = 0; i < nsamples; ++i )
+ {
+ fl32[i] = buffer[i];
+ }
+ int n_ch_samples = nsamples / context->channels;
+ hb_layout_remap( &hb_smpte_chan_map, &hb_qt_chan_map,
+ audio->config.in.channel_layout,
+ fl32, n_ch_samples );
+ }
double pts = pv->pts_next;
buf->start = pts;
- pts += out_size * pv->duration;
+ pts += nsamples * pv->duration;
buf->stop = pts;
pv->pts_next = pts;
- float *fl32 = (float *)buf->data;
- int i;
- for( i = 0; i < out_size; ++i )
- {
- fl32[i] = buffer[i];
- }
hb_list_add( pv->list, buf );
// if we allocated a buffer for sample format conversion, free it
if ( buffer != pv->buffer )
{
- free( buffer );
+ av_free( buffer );
}
}
}
pv->pts_next = in->start;
}
prepare_ffmpeg_buffer( in );
- decodeAudio( pv, in->data, in->size );
+ decodeAudio( w->audio, pv, in->data, in->size );
*buf_out = link_buf_list( pv );
return HB_WORK_OK;
OSDN Git Service
