1 /* $Id: decavcodec.c,v 1.6 2005/03/06 04:08:54 titer Exp $
3 This file is part of the HandBrake source code.
4 Homepage: <http://handbrake.fr/>.
5 It may be used under the terms of the GNU General Public License. */
7 /* This module is Handbrake's interface to the ffmpeg decoder library
8 (libavcodec & small parts of libavformat). It contains four Handbrake
11 decavcodec connects HB to an ffmpeg audio decoder
12 decavcodecv connects HB to an ffmpeg video decoder
14 (Two different routines are needed because the ffmpeg library
15 has different decoder calling conventions for audio & video.
16 The audio decoder should have had its name changed to "decavcodeca"
17 but I got lazy.) These work objects are self-contained & follow all
18 of HB's conventions for a decoder module. They can be used like
19 any other HB decoder (deca52, decmpeg2, etc.).
21 decavcodecai "internal" (incestuous?) version of decavcodec
22 decavcodecvi "internal" (incestuous?) version of decavcodecv
24 These routine are functionally equivalent to the routines above but
25 can only be used by the ffmpeg-based stream reader in libhb/stream.c.
26 The reason they exist is because the ffmpeg library leaves some of
27 the information needed by the decoder in the AVStream (the data
28 structure used by the stream reader) and we need to retrieve it
29 to successfully decode frames. But in HB the reader and decoder
30 modules are in completely separate threads and nothing goes between
31 them but hb_buffers containing frames to be decoded. I.e., there's
32 no easy way for the ffmpeg stream reader to pass a pointer to its
33 AVStream over to the ffmpeg video or audio decoder. So the *i work
34 objects use a private back door to the stream reader to get access
35 to the AVStream (routines hb_ffmpeg_avstream and hb_ffmpeg_context)
36 and the codec_param passed to these work objects is the key to this
37 back door (it's basically an index that allows the correct AVStream
40 The normal & *i objects share a lot of code (the basic frame decoding
41 and bitstream info code is factored out into subroutines that can be
42 called by either) but the top level routines of the *i objects
43 (decavcodecviWork, decavcodecviInfo, etc.) are different because:
44 1) they *have* to use the AVCodecContext that's contained in the
45 reader's AVStream rather than just allocating & using their own,
46 2) the Info routines have access to stuff kept in the AVStream in addition
47 to stuff kept in the AVCodecContext. This shouldn't be necessary but
48 crucial information like video frame rate that should be in the
49 AVCodecContext is either missing or wrong in the version of ffmpeg
50 we're currently using.
52 A consequence of the above is that the non-i work objects *can't* use
53 information from the AVStream because there isn't one - they get their
54 data from either the dvd reader or the mpeg reader, not the ffmpeg stream
55 reader. That means that they have to make up for deficiencies in the
56 AVCodecContext info by using stuff kept in the HB "title" struct. It
57 also means that ffmpeg codecs that randomly scatter state needed by
58 the decoder across both the AVCodecContext & the AVStream (e.g., the
59 VC1 decoder) can't easily be used by the HB mpeg stream reader.
64 #include "libavcodec/avcodec.h"
65 #include "libavformat/avformat.h"
67 static int decavcodecInit( hb_work_object_t *, hb_job_t * );
68 static int decavcodecWork( hb_work_object_t *, hb_buffer_t **, hb_buffer_t ** );
69 static void decavcodecClose( hb_work_object_t * );
70 static int decavcodecInfo( hb_work_object_t *, hb_work_info_t * );
71 static int decavcodecBSInfo( hb_work_object_t *, const hb_buffer_t *, hb_work_info_t * );
73 hb_work_object_t hb_decavcodec =
76 "MPGA decoder (libavcodec)",
86 // there are nheap items on the heap indexed 1..nheap (i.e., top of
87 // heap is 1). The 0th slot is unused - a marker is put there to check
88 // for overwrite errs.
89 int64_t h[HEAP_SIZE+1];
93 struct hb_work_private_s
96 AVCodecContext *context;
97 AVCodecParserContext *parser;
99 double duration; // frame duration (for video)
100 double pts_next; // next pts we expect to generate
101 int64_t pts; // (video) pts passing from parser to decoder
102 int64_t chap_time; // time of next chap mark (if new_chap != 0)
106 uint32_t decode_errors;
107 hb_buffer_t* delayq[HEAP_SIZE];
112 static int64_t heap_pop( pts_heap_t *heap )
116 if ( heap->nheap <= 0 )
121 // return the top of the heap then put the bottom element on top,
122 // decrease the heap size by one & rebalence the heap.
125 int64_t v = heap->h[heap->nheap--];
127 int child = parent << 1;
128 while ( child <= heap->nheap )
130 // find the smallest of the two children of parent
131 if (child < heap->nheap && heap->h[child] > heap->h[child+1] )
134 if (v <= heap->h[child])
135 // new item is smaller than either child so it's the new parent.
138 // smallest child is smaller than new item so move it up then
139 // check its children.
140 int64_t hp = heap->h[child];
141 heap->h[parent] = hp;
149 static void heap_push( pts_heap_t *heap, int64_t v )
151 if ( heap->nheap < HEAP_SIZE )
156 // stick the new value on the bottom of the heap then bubble it
157 // up to its correct spot.
158 int child = heap->nheap;
160 int parent = child >> 1;
161 if (heap->h[parent] <= v)
164 int64_t hp = heap->h[parent];
172 /***********************************************************************
173 * hb_work_decavcodec_init
174 ***********************************************************************
176 **********************************************************************/
177 static int decavcodecInit( hb_work_object_t * w, hb_job_t * job )
181 hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
182 w->private_data = pv;
186 int codec_id = w->codec_param;
189 codec_id = CODEC_ID_MP2;
190 codec = avcodec_find_decoder( codec_id );
191 pv->parser = av_parser_init( codec_id );
193 pv->context = avcodec_alloc_context();
194 avcodec_open( pv->context, codec );
199 /***********************************************************************
201 ***********************************************************************
203 **********************************************************************/
204 static void decavcodecClose( hb_work_object_t * w )
206 hb_work_private_t * pv = w->private_data;
210 if ( pv->job && pv->context && pv->context->codec )
212 hb_log( "%s-decoder done: %u frames, %u decoder errors, %u drops",
213 pv->context->codec->name, pv->nframes, pv->decode_errors,
218 av_parser_close(pv->parser);
220 if ( pv->context && pv->context->codec )
222 avcodec_close( pv->context );
226 hb_list_close( &pv->list );
234 w->private_data = NULL;
238 /***********************************************************************
240 ***********************************************************************
242 **********************************************************************/
243 static int decavcodecWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
244 hb_buffer_t ** buf_out )
246 hb_work_private_t * pv = w->private_data;
247 hb_buffer_t * in = *buf_in, * buf, * last = NULL;
248 int pos, len, out_size, i, uncompressed_len;
249 short buffer[AVCODEC_MAX_AUDIO_FRAME_SIZE];
251 unsigned char *parser_output_buffer;
252 int parser_output_buffer_len;
254 if ( (*buf_in)->size <= 0 )
256 /* EOF on input stream - send it downstream & say that we're done */
264 cur = ( in->start < 0 )? pv->pts_next : in->start;
267 while( pos < in->size )
269 len = av_parser_parse( pv->parser, pv->context,
270 &parser_output_buffer, &parser_output_buffer_len,
271 in->data + pos, in->size - pos, cur, cur );
273 uncompressed_len = 0;
274 if (parser_output_buffer_len)
276 out_size = sizeof(buffer);
277 uncompressed_len = avcodec_decode_audio2( pv->context, buffer,
279 parser_output_buffer,
280 parser_output_buffer_len );
287 buf = hb_buffer_init( 2 * out_size );
289 int sample_size_in_bytes = 2; // Default to 2 bytes
290 switch (pv->context->sample_fmt)
293 sample_size_in_bytes = 2;
295 /* We should handle other formats here - but that needs additional format conversion work below */
296 /* For now we'll just report the error and try to carry on */
298 hb_log("decavcodecWork - Unknown Sample Format from avcodec_decode_audio (%d) !", pv->context->sample_fmt);
303 buf->stop = cur + 90000 * ( out_size / (sample_size_in_bytes * pv->context->channels) ) /
304 pv->context->sample_rate;
308 fl32 = (float *) buf->data;
309 for( i = 0; i < out_size / 2; i++ )
316 last = last->next = buf;
320 *buf_out = last = buf;
332 static int decavcodecInfo( hb_work_object_t *w, hb_work_info_t *info )
334 hb_work_private_t *pv = w->private_data;
336 memset( info, 0, sizeof(*info) );
338 if ( pv && pv->context )
340 AVCodecContext *context = pv->context;
341 info->bitrate = context->bit_rate;
342 info->rate = context->time_base.num;
343 info->rate_base = context->time_base.den;
344 info->profile = context->profile;
345 info->level = context->level;
351 static int decavcodecBSInfo( hb_work_object_t *w, const hb_buffer_t *buf,
352 hb_work_info_t *info )
354 hb_work_private_t *pv = w->private_data;
356 memset( info, 0, sizeof(*info) );
358 if ( pv && pv->context )
360 return decavcodecInfo( w, info );
363 // We should parse the bitstream to find its parameters but for right
364 // now we just return dummy values if there's a codec that will handle it.
365 AVCodec *codec = avcodec_find_decoder( w->codec_param? w->codec_param :
369 static char codec_name[64];
371 info->name = strncpy( codec_name, codec->name, sizeof(codec_name)-1 );
372 info->bitrate = 384000;
375 info->channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
381 /* -------------------------------------------------------------
382 * General purpose video decoder using libavcodec
385 static uint8_t *copy_plane( uint8_t *dst, uint8_t* src, int dstride, int sstride,
388 if ( dstride == sstride )
390 memcpy( dst, src, dstride * h );
391 return dst + dstride * h;
393 int lbytes = dstride <= sstride? dstride : sstride;
396 memcpy( dst, src, lbytes );
403 /* Note: assumes frame format is PIX_FMT_YUV420P */
404 static hb_buffer_t *copy_frame( AVCodecContext *context, AVFrame *frame )
406 int w = context->width, h = context->height;
407 hb_buffer_t *buf = hb_buffer_init( w * h * 3 / 2 );
408 uint8_t *dst = buf->data;
410 dst = copy_plane( dst, frame->data[0], w, frame->linesize[0], h );
412 dst = copy_plane( dst, frame->data[1], w, frame->linesize[1], h );
413 dst = copy_plane( dst, frame->data[2], w, frame->linesize[2], h );
418 static int get_frame_buf( AVCodecContext *context, AVFrame *frame )
420 hb_work_private_t *pv = context->opaque;
421 frame->pts = pv->pts;
423 return avcodec_default_get_buffer( context, frame );
426 static void log_chapter( hb_work_private_t *pv, int chap_num, int64_t pts )
428 hb_chapter_t *c = hb_list_item( pv->job->title->list_chapter, chap_num - 1 );
431 hb_log( "%s: \"%s\" (%d) at frame %u time %lld",
432 pv->context->codec->name, c->title, chap_num, pv->nframes, pts );
436 hb_log( "%s: Chapter %d at frame %u time %lld",
437 pv->context->codec->name, chap_num, pv->nframes, pts );
441 static void flushDelayQueue( hb_work_private_t *pv )
444 int slot = pv->nframes & (HEAP_SIZE-1);
446 // flush all the video packets left on our timestamp-reordering delay q
447 while ( ( buf = pv->delayq[slot] ) != NULL )
449 buf->start = heap_pop( &pv->pts_heap );
450 hb_list_add( pv->list, buf );
451 pv->delayq[slot] = NULL;
452 slot = ( slot + 1 ) & (HEAP_SIZE-1);
456 static int decodeFrame( hb_work_private_t *pv, uint8_t *data, int size )
461 if ( avcodec_decode_video( pv->context, &frame, &got_picture, data, size ) < 0 )
467 // ffmpeg makes it hard to attach a pts to a frame. if the MPEG ES
468 // packet had a pts we handed it to av_parser_parse (if the packet had
469 // no pts we set it to -1 but before the parse we can't distinguish between
470 // the start of a video frame with no pts & an intermediate packet of
471 // some frame which never has a pts). we hope that when parse returns
472 // the frame to us the pts we originally handed it will be in parser->pts.
473 // we put this pts into pv->pts so that when a avcodec_decode_video
474 // finally gets around to allocating an AVFrame to hold the decoded
475 // frame we can stuff that pts into the frame. if all of these relays
476 // worked at this point frame.pts should hold the frame's pts from the
477 // original data stream or -1 if it didn't have one. in the latter case
478 // we generate the next pts in sequence for it.
479 double frame_dur = pv->duration;
480 if ( frame_dur <= 0 )
482 frame_dur = 90000. * (double)pv->context->time_base.num /
483 (double)pv->context->time_base.den;
484 pv->duration = frame_dur;
486 if ( frame.repeat_pict )
488 frame_dur += frame.repeat_pict * frame_dur * 0.5;
490 // If there was no pts for this frame, assume constant frame rate
491 // video & estimate the next frame time from the last & duration.
492 double pts = frame.pts;
497 pv->pts_next = pts + frame_dur;
501 // if we're doing a scan we don't worry about timestamp reordering
504 buf = copy_frame( pv->context, &frame );
506 hb_list_add( pv->list, buf );
511 // XXX This following probably addresses a libavcodec bug but I don't
512 // see an easy fix so we workaround it here.
514 // The M$ 'packed B-frames' atrocity results in decoded frames with
515 // the wrong timestamp. E.g., if there are 2 b-frames the timestamps
516 // we see here will be "2 3 1 5 6 4 ..." instead of "1 2 3 4 5 6".
517 // The frames are actually delivered in the right order but with
518 // the wrong timestamp. To get the correct timestamp attached to
519 // each frame we have a delay queue (longer than the max number of
520 // b-frames) & a sorting heap for the timestamps. As each frame
521 // comes out of the decoder the oldest frame in the queue is removed
522 // and associated with the smallest timestamp. Then the new frame is
523 // added to the queue & its timestamp is pushed on the heap.
524 // This does nothing if the timestamps are correct (i.e., the video
525 // uses a codec that Micro$oft hasn't broken yet) but the frames
526 // get timestamped correctly even when M$ has munged them.
528 // remove the oldest picture from the frame queue (if any) &
529 // give it the smallest timestamp from our heap. The queue size
530 // is a power of two so we get the slot of the oldest by masking
531 // the frame count & this will become the slot of the newest
532 // once we've removed & processed the oldest.
533 int slot = pv->nframes & (HEAP_SIZE-1);
534 if ( ( buf = pv->delayq[slot] ) != NULL )
536 buf->start = heap_pop( &pv->pts_heap );
538 if ( pv->new_chap && buf->start >= pv->chap_time )
540 buf->new_chap = pv->new_chap;
543 log_chapter( pv, buf->new_chap, buf->start );
545 else if ( pv->nframes == 0 )
547 log_chapter( pv, pv->job->chapter_start, buf->start );
549 hb_list_add( pv->list, buf );
552 // add the new frame to the delayq & push its timestamp on the heap
553 pv->delayq[slot] = copy_frame( pv->context, &frame );
554 heap_push( &pv->pts_heap, pts );
562 static void decodeVideo( hb_work_private_t *pv, uint8_t *data, int size,
563 int64_t pts, int64_t dts )
566 * The following loop is a do..while because we need to handle both
567 * data & the flush at the end (signaled by size=0). At the end there's
568 * generally a frame in the parser & one or more frames in the decoder
569 * (depending on the bframes setting).
575 int len = av_parser_parse( pv->parser, pv->context, &pout, &pout_len,
576 data + pos, size - pos, pts, dts );
581 pv->pts = pv->parser->pts;
582 decodeFrame( pv, pout, pout_len );
584 } while ( pos < size );
586 /* the stuff above flushed the parser, now flush the decoder */
589 while ( decodeFrame( pv, NULL, 0 ) )
592 flushDelayQueue( pv );
596 static hb_buffer_t *link_buf_list( hb_work_private_t *pv )
598 hb_buffer_t *head = hb_list_item( pv->list, 0 );
602 hb_list_rem( pv->list, head );
604 hb_buffer_t *last = head, *buf;
606 while ( ( buf = hb_list_item( pv->list, 0 ) ) != NULL )
608 hb_list_rem( pv->list, buf );
617 static int decavcodecvInit( hb_work_object_t * w, hb_job_t * job )
620 hb_work_private_t *pv = calloc( 1, sizeof( hb_work_private_t ) );
621 w->private_data = pv;
623 pv->list = hb_list_init();
625 int codec_id = w->codec_param;
626 pv->parser = av_parser_init( codec_id );
627 pv->context = avcodec_alloc_context2( CODEC_TYPE_VIDEO );
629 /* we have to wrap ffmpeg's get_buffer to be able to set the pts (?!) */
630 pv->context->opaque = pv;
631 pv->context->get_buffer = get_frame_buf;
633 AVCodec *codec = avcodec_find_decoder( codec_id );
635 // we can't call the avstream funcs but the read_header func in the
636 // AVInputFormat may set up some state in the AVContext. In particular
637 // vc1t_read_header allocates 'extradata' to deal with header issues
638 // related to Microsoft's bizarre engineering notions. We alloc a chunk
639 // of space to make vc1 work then associate the codec with the context.
640 pv->context->extradata_size = 32;
641 pv->context->extradata = av_malloc(pv->context->extradata_size);
642 avcodec_open( pv->context, codec );
647 static int decavcodecvWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
648 hb_buffer_t ** buf_out )
650 hb_work_private_t *pv = w->private_data;
651 hb_buffer_t *in = *buf_in;
652 int64_t pts = AV_NOPTS_VALUE;
657 /* if we got an empty buffer signaling end-of-stream send it downstream */
660 decodeVideo( pv, in->data, in->size, pts, dts );
661 hb_list_add( pv->list, in );
662 *buf_out = link_buf_list( pv );
669 dts = in->renderOffset;
673 pv->new_chap = in->new_chap;
674 pv->chap_time = pts >= 0? pts : pv->pts_next;
676 decodeVideo( pv, in->data, in->size, pts, dts );
677 hb_buffer_close( &in );
678 *buf_out = link_buf_list( pv );
682 static int decavcodecvInfo( hb_work_object_t *w, hb_work_info_t *info )
684 hb_work_private_t *pv = w->private_data;
686 memset( info, 0, sizeof(*info) );
688 if ( pv && pv->context )
690 AVCodecContext *context = pv->context;
691 info->bitrate = context->bit_rate;
692 info->width = context->width;
693 info->height = context->height;
695 /* ffmpeg gives the frame rate in frames per second while HB wants
696 * it in units of the 27MHz MPEG clock. */
697 info->rate = 27000000;
698 info->rate_base = (int64_t)context->time_base.num * 27000000LL /
699 context->time_base.den;
701 /* Sometimes there's no pixel aspect set in the source. In that case,
702 assume a 1:1 PAR. Otherwise, preserve the source PAR. */
703 info->pixel_aspect_width = context->sample_aspect_ratio.num ?
704 context->sample_aspect_ratio.num : 1;
705 info->pixel_aspect_height = context->sample_aspect_ratio.den ?
706 context->sample_aspect_ratio.den : 1;
708 /* ffmpeg returns the Pixel Aspect Ratio (PAR). Handbrake wants the
709 * Display Aspect Ratio so we convert by scaling by the Storage
710 * Aspect Ratio (w/h). We do the calc in floating point to get the
712 info->aspect = (double)info->pixel_aspect_width *
713 (double)context->width /
714 (double)info->pixel_aspect_height /
715 (double)context->height;
717 info->profile = context->profile;
718 info->level = context->level;
719 info->name = context->codec->name;
725 static int decavcodecvBSInfo( hb_work_object_t *w, const hb_buffer_t *buf,
726 hb_work_info_t *info )
731 hb_work_object_t hb_decavcodecv =
734 "Video decoder (libavcodec)",
743 // This is a special decoder for ffmpeg streams. The ffmpeg stream reader
744 // includes a parser and passes information from the parser to the decoder
745 // via a codec context kept in the AVStream of the reader's AVFormatContext.
746 // We *have* to use that codec context to decode the stream or we'll get
747 // garbage. ffmpeg_title_scan put a cookie that can be used to get to that
748 // codec context in our codec_param.
750 // this routine gets the appropriate context pointer from the ffmpeg
751 // stream reader. it can't be called until we get the first buffer because
752 // we can't guarantee that reader will be called before the our init
753 // routine and if our init is called first we'll get a pointer to the
754 // old scan stream (which has already been closed).
755 static void init_ffmpeg_context( hb_work_object_t *w )
757 hb_work_private_t *pv = w->private_data;
758 pv->context = hb_ffmpeg_context( w->codec_param );
760 // during scan the decoder gets closed & reopened which will
761 // close the codec so reopen it if it's not there
762 if ( ! pv->context->codec )
764 AVCodec *codec = avcodec_find_decoder( pv->context->codec_id );
765 avcodec_open( pv->context, codec );
767 // set up our best guess at the frame duration.
768 // the frame rate in the codec is usually bogus but it's sometimes
770 AVStream *st = hb_ffmpeg_avstream( w->codec_param );
772 if ( st->nb_frames && st->duration )
774 // compute the average frame duration from the total number
775 // of frames & the total duration.
776 pv->duration = ( (double)st->duration * (double)st->time_base.num ) /
777 ( (double)st->nb_frames * (double)st->time_base.den );
781 // XXX We don't have a frame count or duration so try to use the
782 // far less reliable time base info in the stream.
783 // Because the time bases are so screwed up, we only take values
784 // in the range 8fps - 64fps.
786 if ( st->time_base.num * 64 > st->time_base.den &&
787 st->time_base.den > st->time_base.num * 8 )
791 else if ( st->r_frame_rate.den * 64 > st->r_frame_rate.num &&
792 st->r_frame_rate.num > st->r_frame_rate.den * 8 )
794 tb.num = st->r_frame_rate.den;
795 tb.den = st->r_frame_rate.num;
799 tb.num = 1001; /*XXX*/
800 tb.den = 24000; /*XXX*/
802 pv->duration = (double)tb.num / (double)tb.den;
804 pv->duration *= 90000.;
806 // we have to wrap ffmpeg's get_buffer to be able to set the pts (?!)
807 pv->context->opaque = pv;
808 pv->context->get_buffer = get_frame_buf;
811 static void prepare_ffmpeg_buffer( hb_buffer_t * in )
813 // ffmpeg requires an extra 8 bytes of zero at the end of the buffer and
814 // will seg fault in odd, data dependent ways if it's not there. (my guess
815 // is this is a case of a local performance optimization creating a global
816 // performance degradation since all the time wasted by extraneous data
817 // copies & memory zeroing has to be huge compared to the minor reduction
818 // in inner-loop instructions this affords - modern cpus bottleneck on
819 // memory bandwidth not instruction bandwidth).
820 if ( in->size + FF_INPUT_BUFFER_PADDING_SIZE > in->alloc )
822 // have to realloc to add the padding
823 hb_buffer_realloc( in, in->size + FF_INPUT_BUFFER_PADDING_SIZE );
825 memset( in->data + in->size, 0, FF_INPUT_BUFFER_PADDING_SIZE );
828 static int decavcodecviInit( hb_work_object_t * w, hb_job_t * job )
831 hb_work_private_t *pv = calloc( 1, sizeof( hb_work_private_t ) );
832 w->private_data = pv;
834 pv->list = hb_list_init();
840 static int decavcodecviWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
841 hb_buffer_t ** buf_out )
843 hb_work_private_t *pv = w->private_data;
846 init_ffmpeg_context( w );
848 hb_buffer_t *in = *buf_in;
851 /* if we got an empty buffer signaling end-of-stream send it downstream */
854 /* flush any frames left in the decoder */
855 while ( decodeFrame( pv, NULL, 0 ) )
858 flushDelayQueue( pv );
859 hb_list_add( pv->list, in );
860 *buf_out = link_buf_list( pv );
864 int64_t pts = in->start;
867 // use the first timestamp as our 'next expected' pts
868 if ( pv->pts_next < 0 )
877 pv->new_chap = in->new_chap;
878 pv->chap_time = pts >= 0? pts : pv->pts_next;
880 prepare_ffmpeg_buffer( in );
881 decodeFrame( pv, in->data, in->size );
882 hb_buffer_close( &in );
883 *buf_out = link_buf_list( pv );
887 static int decavcodecviInfo( hb_work_object_t *w, hb_work_info_t *info )
889 if ( decavcodecvInfo( w, info ) )
891 hb_work_private_t *pv = w->private_data;
894 init_ffmpeg_context( w );
896 // we have the frame duration in units of the 90KHz pts clock but
897 // need it in units of the 27MHz MPEG clock. */
898 info->rate = 27000000;
899 info->rate_base = pv->duration * 300.;
905 static void decodeAudio( hb_work_private_t *pv, uint8_t *data, int size )
907 AVCodecContext *context = pv->context;
912 int16_t *buffer = pv->buffer;
913 if ( buffer == NULL )
915 // XXX ffmpeg bug workaround
916 // malloc a buffer for the audio decode. On an x86, ffmpeg
917 // uses mmx/sse instructions on this buffer without checking
918 // that it's 16 byte aligned and this will cause an abort if
919 // the buffer is allocated on our stack. Rather than doing
920 // complicated, machine dependent alignment here we use the
921 // fact that malloc returns an aligned pointer on most architectures.
922 pv->buffer = malloc( AVCODEC_MAX_AUDIO_FRAME_SIZE );
925 int out_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
926 int len = avcodec_decode_audio2( context, buffer, &out_size,
927 data + pos, size - pos );
935 hb_buffer_t *buf = hb_buffer_init( 2 * out_size );
937 // convert from bytes to total samples
940 double pts = pv->pts_next;
942 pts += out_size * pv->duration;
946 float *fl32 = (float *)buf->data;
948 for( i = 0; i < out_size; ++i )
952 hb_list_add( pv->list, buf );
957 static int decavcodecaiWork( hb_work_object_t *w, hb_buffer_t **buf_in,
958 hb_buffer_t **buf_out )
960 if ( (*buf_in)->size <= 0 )
962 /* EOF on input stream - send it downstream & say that we're done */
968 hb_work_private_t *pv = w->private_data;
971 init_ffmpeg_context( w );
972 // duration is a scaling factor to go from #bytes in the decoded
973 // frame to frame time (in 90KHz mpeg ticks). 'channels' converts
974 // total samples to per-channel samples. 'sample_rate' converts
975 // per-channel samples to seconds per sample and the 90000
976 // is mpeg ticks per second.
977 pv->duration = 90000. /
978 (double)( pv->context->sample_rate * pv->context->channels );
980 hb_buffer_t *in = *buf_in;
982 // if the packet has a timestamp use it if we don't have a timestamp yet
983 // or if there's been a timing discontinuity of more than 100ms.
984 if ( in->start >= 0 &&
985 ( pv->pts_next < 0 || ( in->start - pv->pts_next ) > 90*100 ) )
987 pv->pts_next = in->start;
989 prepare_ffmpeg_buffer( in );
990 decodeAudio( pv, in->data, in->size );
991 *buf_out = link_buf_list( pv );
996 hb_work_object_t hb_decavcodecvi =
999 "Video decoder (ffmpeg streams)",
1007 hb_work_object_t hb_decavcodecai =
1010 "Audio decoder (ffmpeg streams)",