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.
65 #include "libavcodec/audioconvert.h"
67 static void flushDelayQueue( hb_work_private_t *pv );
68 static int decavcodecInit( hb_work_object_t *, hb_job_t * );
69 static int decavcodecWork( hb_work_object_t *, hb_buffer_t **, hb_buffer_t ** );
70 static void decavcodecClose( hb_work_object_t * );
71 static int decavcodecInfo( hb_work_object_t *, hb_work_info_t * );
72 static int decavcodecBSInfo( hb_work_object_t *, const hb_buffer_t *, hb_work_info_t * );
74 hb_work_object_t hb_decavcodec =
77 "MPGA decoder (libavcodec)",
87 // there are nheap items on the heap indexed 1..nheap (i.e., top of
88 // heap is 1). The 0th slot is unused - a marker is put there to check
89 // for overwrite errs.
90 int64_t h[HEAP_SIZE+1];
94 struct hb_work_private_s
97 AVCodecContext *context;
98 AVCodecParserContext *parser;
100 hb_list_t *ff_audio_list;
101 double duration; // frame duration (for video)
102 double pts_next; // next pts we expect to generate
103 int64_t chap_time; // time of next chap mark (if new_chap != 0)
104 int new_chap; // output chapter mark pending
107 uint32_t decode_errors;
108 int brokenByMicrosoft; // video stream may contain packed b-frames
109 hb_buffer_t* delayq[HEAP_SIZE];
112 struct SwsContext *sws_context; // if we have to rescale or convert color space
113 hb_downmix_t *downmix;
114 hb_sample_t *downmix_buffer;
116 hb_chan_map_t *out_map;
119 static void decodeAudio( hb_audio_t * audio, hb_work_private_t *pv, uint8_t *data, int size, int64_t pts );
120 static hb_buffer_t *link_buf_list( hb_work_private_t *pv );
123 static int64_t heap_pop( pts_heap_t *heap )
127 if ( heap->nheap <= 0 )
132 // return the top of the heap then put the bottom element on top,
133 // decrease the heap size by one & rebalence the heap.
136 int64_t v = heap->h[heap->nheap--];
138 int child = parent << 1;
139 while ( child <= heap->nheap )
141 // find the smallest of the two children of parent
142 if (child < heap->nheap && heap->h[child] > heap->h[child+1] )
145 if (v <= heap->h[child])
146 // new item is smaller than either child so it's the new parent.
149 // smallest child is smaller than new item so move it up then
150 // check its children.
151 int64_t hp = heap->h[child];
152 heap->h[parent] = hp;
160 static void heap_push( pts_heap_t *heap, int64_t v )
162 if ( heap->nheap < HEAP_SIZE )
167 // stick the new value on the bottom of the heap then bubble it
168 // up to its correct spot.
169 int child = heap->nheap;
171 int parent = child >> 1;
172 if (heap->h[parent] <= v)
175 int64_t hp = heap->h[parent];
183 /***********************************************************************
184 * hb_work_decavcodec_init
185 ***********************************************************************
187 **********************************************************************/
188 static int decavcodecInit( hb_work_object_t * w, hb_job_t * job )
193 hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
194 w->private_data = pv;
197 pv->list = hb_list_init();
199 int codec_id = w->codec_param;
202 codec_id = CODEC_ID_MP2;
204 codec = avcodec_find_decoder( codec_id );
205 pv->parser = av_parser_init( codec_id );
207 pv->context = avcodec_alloc_context();
208 hb_avcodec_open( pv->context, codec );
210 if ( w->audio != NULL )
212 if ( w->audio->config.out.codec == HB_ACODEC_AC3 )
214 // ffmpegs audio encoder expect an smpte chan map as input.
215 // So we need to map the decoders output to smpte.
216 pv->out_map = &hb_smpte_chan_map;
220 pv->out_map = &hb_qt_chan_map;
222 if ( hb_need_downmix( w->audio->config.in.channel_layout,
223 w->audio->config.out.mixdown) )
225 pv->downmix = hb_downmix_init(w->audio->config.in.channel_layout,
226 w->audio->config.out.mixdown);
227 hb_downmix_set_chan_map( pv->downmix, &hb_smpte_chan_map, pv->out_map );
230 pv->ff_audio_list = hb_list_init();
231 for ( i = 0; i < hb_list_count( w->audio->priv.ff_audio_list ); i++ )
233 hb_work_private_t * ff_pv = calloc( 1, sizeof( hb_work_private_t ) );
234 hb_list_add( pv->ff_audio_list, ff_pv );
236 hb_audio_t *audio = hb_list_item( w->audio->priv.ff_audio_list, i );
238 ff_pv->list = hb_list_init();
241 if ( audio->config.out.codec == HB_ACODEC_AC3 )
243 // ffmpegs audio encoder expect an smpte chan map as input.
244 // So we need to map the decoders output to smpte.
245 ff_pv->out_map = &hb_smpte_chan_map;
249 ff_pv->out_map = &hb_qt_chan_map;
251 if ( hb_need_downmix( audio->config.in.channel_layout,
252 audio->config.out.mixdown) )
254 ff_pv->downmix = hb_downmix_init(audio->config.in.channel_layout,
255 audio->config.out.mixdown);
256 hb_downmix_set_chan_map( ff_pv->downmix, &hb_smpte_chan_map, ff_pv->out_map );
264 /***********************************************************************
266 ***********************************************************************
268 **********************************************************************/
269 static void closePrivData( hb_work_private_t ** ppv )
271 hb_work_private_t * pv = *ppv;
275 flushDelayQueue( pv );
277 if ( pv->job && pv->context && pv->context->codec )
279 hb_log( "%s-decoder done: %u frames, %u decoder errors, %u drops",
280 pv->context->codec->name, pv->nframes, pv->decode_errors,
283 if ( pv->sws_context )
285 sws_freeContext( pv->sws_context );
289 av_parser_close(pv->parser);
291 if ( pv->context && pv->context->codec )
293 hb_avcodec_close( pv->context );
297 hb_list_empty( &pv->list );
301 av_free( pv->buffer );
306 hb_downmix_close( &(pv->downmix) );
308 if ( pv->downmix_buffer )
310 free( pv->downmix_buffer );
311 pv->downmix_buffer = NULL;
318 static void decavcodecClose( hb_work_object_t * w )
320 hb_work_private_t * pv = w->private_data;
324 if ( pv->ff_audio_list != NULL )
326 hb_work_private_t * ff_pv;
327 while ( ( ff_pv = hb_list_item( pv->list, 0 ) ) != NULL )
329 hb_list_rem( pv->ff_audio_list, ff_pv );
330 closePrivData( &ff_pv );
333 closePrivData( &pv );
334 w->private_data = NULL;
338 static void writeAudioEof( hb_work_object_t * w )
340 hb_work_private_t * pv = w->private_data;
341 hb_audio_t * audio = w->audio;
345 for ( i = 0; i < hb_list_count( audio->priv.ff_audio_list ); i++ )
347 hb_audio_t *ff_audio = hb_list_item( audio->priv.ff_audio_list, i );
348 hb_work_private_t *ff_pv = hb_list_item( pv->ff_audio_list, i );
351 buf = hb_buffer_init( 0 );
356 if ( hb_fifo_full_wait( ff_audio->priv.fifo_raw ) )
358 hb_fifo_push( ff_audio->priv.fifo_raw, buf );
365 // w->done == true while waiting
366 hb_buffer_close( &buf );
374 static void writeAudioFifos( hb_work_object_t * w )
376 hb_work_private_t * pv = w->private_data;
377 hb_audio_t * audio = w->audio;
381 for ( i = 0; i < hb_list_count( audio->priv.ff_audio_list ); i++ )
383 hb_audio_t *ff_audio = hb_list_item( audio->priv.ff_audio_list, i );
384 hb_work_private_t *ff_pv = hb_list_item( pv->ff_audio_list, i );
387 buf = link_buf_list( ff_pv );
392 if ( hb_fifo_full_wait( ff_audio->priv.fifo_raw ) )
394 hb_fifo_push( ff_audio->priv.fifo_raw, buf );
401 // w->done == true while waiting
402 hb_buffer_close( &buf );
410 /***********************************************************************
412 ***********************************************************************
414 **********************************************************************/
415 static int decavcodecWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
416 hb_buffer_t ** buf_out )
418 hb_work_private_t * pv = w->private_data;
419 hb_buffer_t * in = *buf_in;
423 /* EOF on input stream - send it downstream & say that we're done */
432 if ( in->start < -1 && pv->pts_next <= 0 )
434 // discard buffers that start before video time 0
439 for ( pos = 0; pos < in->size; pos += len )
441 uint8_t *parser_output_buffer;
442 int parser_output_buffer_len;
443 int64_t cur = pv->pts_next;
445 if ( in->start != -1 )
450 if ( pv->parser != NULL )
452 len = av_parser_parse2( pv->parser, pv->context,
453 &parser_output_buffer, &parser_output_buffer_len,
454 in->data + pos, in->size - pos, cur, cur, 0 );
455 cur = pv->parser->pts;
459 parser_output_buffer = in->data;
460 len = parser_output_buffer_len = in->size;
462 if (parser_output_buffer_len)
464 // set the duration on every frame since the stream format can
465 // change (it shouldn't but there's no way to guarantee it).
466 // duration is a scaling factor to go from #bytes in the decoded
467 // frame to frame time (in 90KHz mpeg ticks). 'channels' converts
468 // total samples to per-channel samples. 'sample_rate' converts
469 // per-channel samples to seconds per sample and the 90000
470 // is mpeg ticks per second.
471 if ( pv->context->sample_rate && pv->context->channels )
473 pv->duration = 90000. /
474 (double)( pv->context->sample_rate * pv->context->channels );
476 decodeAudio( w->audio, pv, parser_output_buffer, parser_output_buffer_len, cur );
479 writeAudioFifos( w );
480 *buf_out = link_buf_list( pv );
484 static int decavcodecInfo( hb_work_object_t *w, hb_work_info_t *info )
486 hb_work_private_t *pv = w->private_data;
488 memset( info, 0, sizeof(*info) );
490 if ( pv && pv->context )
492 AVCodecContext *context = pv->context;
493 info->bitrate = context->bit_rate;
494 info->rate = context->time_base.num;
495 info->rate_base = context->time_base.den;
496 info->profile = context->profile;
497 info->level = context->level;
503 static int decavcodecBSInfo( hb_work_object_t *w, const hb_buffer_t *buf,
504 hb_work_info_t *info )
506 hb_work_private_t *pv = w->private_data;
509 memset( info, 0, sizeof(*info) );
511 if ( pv && pv->context )
513 return decavcodecInfo( w, info );
516 // We should parse the bitstream to find its parameters but for right
517 // now we just return dummy values if there's a codec that will handle it.
518 AVCodec *codec = avcodec_find_decoder( w->codec_param? w->codec_param :
522 // there's no ffmpeg codec for this audio type - give up
526 static char codec_name[64];
527 info->name = strncpy( codec_name, codec->name, sizeof(codec_name)-1 );
529 AVCodecParserContext *parser = av_parser_init( codec->id );
530 AVCodecContext *context = avcodec_alloc_context();
531 hb_avcodec_open( context, codec );
532 uint8_t *buffer = av_malloc( AVCODEC_MAX_AUDIO_FRAME_SIZE );
533 int out_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
534 unsigned char *pbuffer;
535 int pos, pbuffer_size;
537 while ( buf && !ret )
540 while ( pos < buf->size )
546 len = av_parser_parse2( parser, context, &pbuffer,
547 &pbuffer_size, buf->data + pos,
548 buf->size - pos, buf->start,
554 len = pbuffer_size = buf->size;
557 if ( pbuffer_size > 0 )
560 av_init_packet( &avp );
562 avp.size = pbuffer_size;
564 len = avcodec_decode_audio3( context, (int16_t*)buffer,
566 if ( len > 0 && context->sample_rate > 0 )
568 info->bitrate = context->bit_rate;
569 info->rate = context->sample_rate;
571 info->channel_layout =
572 hb_ff_layout_xlat(context->channel_layout,
583 if ( parser != NULL )
584 av_parser_close( parser );
585 hb_avcodec_close( context );
589 /* -------------------------------------------------------------
590 * General purpose video decoder using libavcodec
593 static uint8_t *copy_plane( uint8_t *dst, uint8_t* src, int dstride, int sstride,
596 if ( dstride == sstride )
598 memcpy( dst, src, dstride * h );
599 return dst + dstride * h;
601 int lbytes = dstride <= sstride? dstride : sstride;
604 memcpy( dst, src, lbytes );
611 // copy one video frame into an HB buf. If the frame isn't in our color space
612 // or at least one of its dimensions is odd, use sws_scale to convert/rescale it.
613 // Otherwise just copy the bits.
614 static hb_buffer_t *copy_frame( hb_work_private_t *pv, AVFrame *frame )
616 AVCodecContext *context = pv->context;
620 // if the dimensions are odd, drop the lsb since h264 requires that
621 // both width and height be even.
622 w = ( context->width >> 1 ) << 1;
623 h = ( context->height >> 1 ) << 1;
627 w = pv->job->title->width;
628 h = pv->job->title->height;
630 hb_buffer_t *buf = hb_video_buffer_init( w, h );
631 uint8_t *dst = buf->data;
633 if ( context->pix_fmt != PIX_FMT_YUV420P || w != context->width ||
634 h != context->height )
636 // have to convert to our internal color space and/or rescale
638 avpicture_fill( &dstpic, dst, PIX_FMT_YUV420P, w, h );
640 if ( ! pv->sws_context )
642 pv->sws_context = hb_sws_get_context( context->width, context->height, context->pix_fmt,
643 w, h, PIX_FMT_YUV420P,
644 SWS_LANCZOS|SWS_ACCURATE_RND);
646 sws_scale( pv->sws_context, frame->data, frame->linesize, 0, h,
647 dstpic.data, dstpic.linesize );
651 dst = copy_plane( dst, frame->data[0], w, frame->linesize[0], h );
652 w = (w + 1) >> 1; h = (h + 1) >> 1;
653 dst = copy_plane( dst, frame->data[1], w, frame->linesize[1], h );
654 dst = copy_plane( dst, frame->data[2], w, frame->linesize[2], h );
659 static int get_frame_buf( AVCodecContext *context, AVFrame *frame )
661 return avcodec_default_get_buffer( context, frame );
664 static int reget_frame_buf( AVCodecContext *context, AVFrame *frame )
666 return avcodec_default_reget_buffer( context, frame );
669 static void log_chapter( hb_work_private_t *pv, int chap_num, int64_t pts )
676 c = hb_list_item( pv->job->title->list_chapter, chap_num - 1 );
679 hb_log( "%s: \"%s\" (%d) at frame %u time %"PRId64,
680 pv->context->codec->name, c->title, chap_num, pv->nframes, pts );
684 hb_log( "%s: Chapter %d at frame %u time %"PRId64,
685 pv->context->codec->name, chap_num, pv->nframes, pts );
689 static void flushDelayQueue( hb_work_private_t *pv )
692 int slot = pv->nframes & (HEAP_SIZE-1);
694 // flush all the video packets left on our timestamp-reordering delay q
695 while ( ( buf = pv->delayq[slot] ) != NULL )
697 buf->start = heap_pop( &pv->pts_heap );
698 hb_list_add( pv->list, buf );
699 pv->delayq[slot] = NULL;
700 slot = ( slot + 1 ) & (HEAP_SIZE-1);
704 #define TOP_FIRST PIC_FLAG_TOP_FIELD_FIRST
705 #define PROGRESSIVE PIC_FLAG_PROGRESSIVE_FRAME
706 #define REPEAT_FIRST PIC_FLAG_REPEAT_FIRST_FIELD
714 static void checkCadence( int * cadence, uint16_t flags, int64_t start )
716 /* Rotate the cadence tracking. */
718 for(i=11; i > 0; i--)
720 cadence[i] = cadence[i-1];
723 if ( !(flags & PROGRESSIVE) && !(flags & TOP_FIRST) )
725 /* Not progressive, not top first...
726 That means it's probably bottom
727 first, 2 fields displayed.
729 //hb_log("MPEG2 Flag: Bottom field first, 2 fields displayed.");
732 else if ( !(flags & PROGRESSIVE) && (flags & TOP_FIRST) )
734 /* Not progressive, top is first,
735 Two fields displayed.
737 //hb_log("MPEG2 Flag: Top field first, 2 fields displayed.");
740 else if ( (flags & PROGRESSIVE) && !(flags & TOP_FIRST) && !( flags & REPEAT_FIRST ) )
742 /* Progressive, but noting else.
743 That means Bottom first,
746 //hb_log("MPEG2 Flag: Progressive. Bottom field first, 2 fields displayed.");
747 cadence[0] = BT_PROG;
749 else if ( (flags & PROGRESSIVE) && !(flags & TOP_FIRST) && ( flags & REPEAT_FIRST ) )
751 /* Progressive, and repeat. .
752 That means Bottom first,
755 //hb_log("MPEG2 Flag: Progressive repeat. Bottom field first, 3 fields displayed.");
756 cadence[0] = BTB_PROG;
758 else if ( (flags & PROGRESSIVE) && (flags & TOP_FIRST) && !( flags & REPEAT_FIRST ) )
760 /* Progressive, top first.
761 That means top first,
764 //hb_log("MPEG2 Flag: Progressive. Top field first, 2 fields displayed.");
765 cadence[0] = TB_PROG;
767 else if ( (flags & PROGRESSIVE) && (flags & TOP_FIRST) && ( flags & REPEAT_FIRST ) )
769 /* Progressive, top, repeat.
770 That means top first,
773 //hb_log("MPEG2 Flag: Progressive repeat. Top field first, 3 fields displayed.");
774 cadence[0] = TBT_PROG;
777 if ( (cadence[2] <= TB) && (cadence[1] <= TB) && (cadence[0] > TB) && (cadence[11]) )
778 hb_log("%fs: Video -> Film", (float)start / 90000);
779 if ( (cadence[2] > TB) && (cadence[1] <= TB) && (cadence[0] <= TB) && (cadence[11]) )
780 hb_log("%fs: Film -> Video", (float)start / 90000);
784 * Decodes a video frame from the specified raw packet data
785 * ('data', 'size', 'sequence').
786 * The output of this function is stored in 'pv->list', which contains a list
787 * of zero or more decoded packets.
789 * The returned packets are guaranteed to have their timestamps in the correct
790 * order, even if the original packets decoded by libavcodec have misordered
791 * timestamps, due to the use of 'packed B-frames'.
793 * Internally the set of decoded packets may be buffered in 'pv->delayq'
794 * until enough packets have been decoded so that the timestamps can be
795 * correctly rewritten, if this is necessary.
797 static int decodeFrame( hb_work_private_t *pv, uint8_t *data, int size, int sequence, int64_t pts, int64_t dts )
799 int got_picture, oldlevel = 0;
803 if ( global_verbosity_level <= 1 )
805 oldlevel = av_log_get_level();
806 av_log_set_level( AV_LOG_QUIET );
809 av_init_packet( &avp );
814 if ( avcodec_decode_video2( pv->context, &frame, &got_picture, &avp ) < 0 )
818 if ( global_verbosity_level <= 1 )
820 av_log_set_level( oldlevel );
826 // ffmpeg makes it hard to attach a pts to a frame. if the MPEG ES
827 // packet had a pts we handed it to av_parser_parse (if the packet had
828 // no pts we set it to AV_NOPTS_VALUE, but before the parse we can't
829 // distinguish between the start of a video frame with no pts & an
830 // intermediate packet of some frame which never has a pts). we hope
831 // that when parse returns the frame to us the pts we originally
832 // handed it will be in parser->pts. we put this pts into avp.pts so
833 // that when avcodec_decode_video finally gets around to allocating an
834 // AVFrame to hold the decoded frame, avcodec_default_get_buffer can
835 // stuff that pts into the it. if all of these relays worked at this
836 // point frame.pts should hold the frame's pts from the original data
837 // stream or AV_NOPTS_VALUE if it didn't have one. in the latter case
838 // we generate the next pts in sequence for it.
839 double frame_dur = pv->duration;
840 if ( frame_dur <= 0 )
842 frame_dur = 90000. * (double)pv->context->time_base.num /
843 (double)pv->context->time_base.den;
844 pv->duration = frame_dur;
846 if ( pv->context->ticks_per_frame > 1 )
850 if ( frame.repeat_pict )
852 frame_dur += frame.repeat_pict * pv->duration;
855 // If there was no pts for this frame, assume constant frame rate
856 // video & estimate the next frame time from the last & duration.
858 if (frame.pkt_pts == AV_NOPTS_VALUE)
866 pv->pts_next = pts + frame_dur;
868 if ( frame.top_field_first )
870 flags |= PIC_FLAG_TOP_FIELD_FIRST;
872 if ( !frame.interlaced_frame )
874 flags |= PIC_FLAG_PROGRESSIVE_FRAME;
876 if ( frame.repeat_pict )
878 flags |= PIC_FLAG_REPEAT_FIRST_FIELD;
883 // if we're doing a scan or this content couldn't have been broken
884 // by Microsoft we don't worry about timestamp reordering
885 if ( ! pv->job || ! pv->brokenByMicrosoft )
887 buf = copy_frame( pv, &frame );
889 buf->sequence = sequence;
891 if ( pv->new_chap && buf->start >= pv->chap_time )
893 buf->new_chap = pv->new_chap;
896 log_chapter( pv, buf->new_chap, buf->start );
898 else if ( pv->nframes == 0 && pv->job )
900 log_chapter( pv, pv->job->chapter_start, buf->start );
902 checkCadence( pv->cadence, buf->flags, buf->start );
903 hb_list_add( pv->list, buf );
908 // XXX This following probably addresses a libavcodec bug but I don't
909 // see an easy fix so we workaround it here.
911 // The M$ 'packed B-frames' atrocity results in decoded frames with
912 // the wrong timestamp. E.g., if there are 2 b-frames the timestamps
913 // we see here will be "2 3 1 5 6 4 ..." instead of "1 2 3 4 5 6".
914 // The frames are actually delivered in the right order but with
915 // the wrong timestamp. To get the correct timestamp attached to
916 // each frame we have a delay queue (longer than the max number of
917 // b-frames) & a sorting heap for the timestamps. As each frame
918 // comes out of the decoder the oldest frame in the queue is removed
919 // and associated with the smallest timestamp. Then the new frame is
920 // added to the queue & its timestamp is pushed on the heap.
921 // This does nothing if the timestamps are correct (i.e., the video
922 // uses a codec that Micro$oft hasn't broken yet) but the frames
923 // get timestamped correctly even when M$ has munged them.
925 // remove the oldest picture from the frame queue (if any) &
926 // give it the smallest timestamp from our heap. The queue size
927 // is a power of two so we get the slot of the oldest by masking
928 // the frame count & this will become the slot of the newest
929 // once we've removed & processed the oldest.
930 int slot = pv->nframes & (HEAP_SIZE-1);
931 if ( ( buf = pv->delayq[slot] ) != NULL )
933 buf->start = heap_pop( &pv->pts_heap );
935 if ( pv->new_chap && buf->start >= pv->chap_time )
937 buf->new_chap = pv->new_chap;
940 log_chapter( pv, buf->new_chap, buf->start );
942 else if ( pv->nframes == 0 && pv->job )
944 log_chapter( pv, pv->job->chapter_start, buf->start );
946 checkCadence( pv->cadence, buf->flags, buf->start );
947 hb_list_add( pv->list, buf );
950 // add the new frame to the delayq & push its timestamp on the heap
951 buf = copy_frame( pv, &frame );
952 buf->sequence = sequence;
954 pv->delayq[slot] = buf;
955 heap_push( &pv->pts_heap, pts );
963 static void decodeVideo( hb_work_private_t *pv, uint8_t *data, int size, int sequence, int64_t pts, int64_t dts )
966 * The following loop is a do..while because we need to handle both
967 * data & the flush at the end (signaled by size=0). At the end there's
968 * generally a frame in the parser & one or more frames in the decoder
969 * (depending on the bframes setting).
975 int len = av_parser_parse2( pv->parser, pv->context, &pout, &pout_len,
976 data + pos, size - pos, pts, dts, 0 );
981 decodeFrame( pv, pout, pout_len, sequence, pv->parser->pts, pv->parser->dts );
983 } while ( pos < size );
985 /* the stuff above flushed the parser, now flush the decoder */
988 while ( decodeFrame( pv, NULL, 0, sequence, AV_NOPTS_VALUE, AV_NOPTS_VALUE ) )
991 flushDelayQueue( pv );
996 * Removes all packets from 'pv->list', links them together into
997 * a linked-list, and returns the first packet in the list.
999 static hb_buffer_t *link_buf_list( hb_work_private_t *pv )
1001 hb_buffer_t *head = hb_list_item( pv->list, 0 );
1005 hb_list_rem( pv->list, head );
1007 hb_buffer_t *last = head, *buf;
1009 while ( ( buf = hb_list_item( pv->list, 0 ) ) != NULL )
1011 hb_list_rem( pv->list, buf );
1020 static int decavcodecvInit( hb_work_object_t * w, hb_job_t * job )
1023 hb_work_private_t *pv = calloc( 1, sizeof( hb_work_private_t ) );
1024 w->private_data = pv;
1026 pv->list = hb_list_init();
1028 int codec_id = w->codec_param;
1029 pv->parser = av_parser_init( codec_id );
1030 pv->context = avcodec_alloc_context2( CODEC_TYPE_VIDEO );
1032 /* we have to wrap ffmpeg's get_buffer to be able to set the pts (?!) */
1033 pv->context->opaque = pv;
1034 pv->context->get_buffer = get_frame_buf;
1035 pv->context->reget_buffer = reget_frame_buf;
1040 static int next_hdr( hb_buffer_t *in, int offset )
1042 uint8_t *dat = in->data;
1043 uint16_t last2 = 0xffff;
1044 for ( ; in->size - offset > 1; ++offset )
1046 if ( last2 == 0 && dat[offset] == 0x01 )
1047 // found an mpeg start code
1050 last2 = ( last2 << 8 ) | dat[offset];
1056 static int find_hdr( hb_buffer_t *in, int offset, uint8_t hdr_type )
1058 if ( in->size - offset < 4 )
1059 // not enough room for an mpeg start code
1062 for ( ; ( offset = next_hdr( in, offset ) ) >= 0; ++offset )
1064 if ( in->data[offset+3] == hdr_type )
1071 static int setup_extradata( hb_work_object_t *w, hb_buffer_t *in )
1073 hb_work_private_t *pv = w->private_data;
1075 // we can't call the avstream funcs but the read_header func in the
1076 // AVInputFormat may set up some state in the AVContext. In particular
1077 // vc1t_read_header allocates 'extradata' to deal with header issues
1078 // related to Microsoft's bizarre engineering notions. We alloc a chunk
1079 // of space to make vc1 work then associate the codec with the context.
1080 if ( w->codec_param != CODEC_ID_VC1 )
1082 // we haven't been inflicted with M$ - allocate a little space as
1083 // a marker and return success.
1084 pv->context->extradata_size = 0;
1085 pv->context->extradata = av_malloc(pv->context->extradata_size);
1089 // find the start and and of the sequence header
1091 if ( ( shdr = find_hdr( in, 0, 0x0f ) ) < 0 )
1093 // didn't find start of seq hdr
1096 if ( ( shdr_end = next_hdr( in, shdr + 4 ) ) < 0 )
1098 shdr_end = in->size;
1102 // find the start and and of the entry point header
1104 if ( ( ehdr = find_hdr( in, 0, 0x0e ) ) < 0 )
1106 // didn't find start of entry point hdr
1109 if ( ( ehdr_end = next_hdr( in, ehdr + 4 ) ) < 0 )
1111 ehdr_end = in->size;
1115 // found both headers - allocate an extradata big enough to hold both
1116 // then copy them into it.
1117 pv->context->extradata_size = shdr_end + ehdr_end;
1118 pv->context->extradata = av_malloc(pv->context->extradata_size + 8);
1119 memcpy( pv->context->extradata, in->data + shdr, shdr_end );
1120 memcpy( pv->context->extradata + shdr_end, in->data + ehdr, ehdr_end );
1121 memset( pv->context->extradata + shdr_end + ehdr_end, 0, 8);
1125 static int decavcodecvWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
1126 hb_buffer_t ** buf_out )
1128 hb_work_private_t *pv = w->private_data;
1129 hb_buffer_t *in = *buf_in;
1130 int64_t pts = AV_NOPTS_VALUE;
1135 /* if we got an empty buffer signaling end-of-stream send it downstream */
1136 if ( in->size == 0 )
1138 if ( pv->context->codec != NULL )
1140 decodeVideo( pv, in->data, in->size, in->sequence, pts, dts );
1142 hb_list_add( pv->list, in );
1143 *buf_out = link_buf_list( pv );
1144 return HB_WORK_DONE;
1147 // if this is the first frame open the codec (we have to wait for the
1148 // first frame because of M$ VC1 braindamage).
1149 if ( pv->context->extradata == NULL )
1151 if ( setup_extradata( w, in ) )
1153 // we didn't find the headers needed to set up extradata.
1154 // the codec will abort if we open it so just free the buf
1155 // and hope we eventually get the info we need.
1156 hb_buffer_close( &in );
1159 AVCodec *codec = avcodec_find_decoder( w->codec_param );
1160 // There's a mis-feature in ffmpeg that causes the context to be
1161 // incorrectly initialized the 1st time avcodec_open is called.
1162 // If you close it and open a 2nd time, it finishes the job.
1163 hb_avcodec_open( pv->context, codec );
1164 hb_avcodec_close( pv->context );
1165 hb_avcodec_open( pv->context, codec );
1168 if( in->start >= 0 )
1171 dts = in->renderOffset;
1175 pv->new_chap = in->new_chap;
1176 pv->chap_time = pts >= 0? pts : pv->pts_next;
1178 decodeVideo( pv, in->data, in->size, in->sequence, pts, dts );
1179 hb_buffer_close( &in );
1180 *buf_out = link_buf_list( pv );
1184 static int decavcodecvInfo( hb_work_object_t *w, hb_work_info_t *info )
1186 hb_work_private_t *pv = w->private_data;
1188 memset( info, 0, sizeof(*info) );
1190 if ( pv && pv->context )
1192 AVCodecContext *context = pv->context;
1193 info->bitrate = context->bit_rate;
1194 info->width = context->width;
1195 info->height = context->height;
1197 /* ffmpeg gives the frame rate in frames per second while HB wants
1198 * it in units of the 27MHz MPEG clock. */
1199 info->rate = 27000000;
1200 info->rate_base = (int64_t)context->time_base.num * 27000000LL /
1201 context->time_base.den;
1202 if ( context->ticks_per_frame > 1 )
1204 // for ffmpeg 0.5 & later, the H.264 & MPEG-2 time base is
1205 // field rate rather than frame rate so convert back to frames.
1206 info->rate_base *= context->ticks_per_frame;
1209 info->pixel_aspect_width = context->sample_aspect_ratio.num;
1210 info->pixel_aspect_height = context->sample_aspect_ratio.den;
1212 /* Sometimes there's no pixel aspect set in the source ffmpeg context
1213 * which appears to come from the video stream. In that case,
1214 * try the pixel aspect in AVStream (which appears to come from
1215 * the container). Else assume a 1:1 PAR. */
1216 if ( info->pixel_aspect_width == 0 ||
1217 info->pixel_aspect_height == 0 )
1219 // There will not be an ffmpeg stream if the file is TS
1220 AVStream *st = hb_ffmpeg_avstream( w->codec_param );
1221 info->pixel_aspect_width = st && st->sample_aspect_ratio.num ?
1222 st->sample_aspect_ratio.num : 1;
1223 info->pixel_aspect_height = st && st->sample_aspect_ratio.den ?
1224 st->sample_aspect_ratio.den : 1;
1226 /* ffmpeg returns the Pixel Aspect Ratio (PAR). Handbrake wants the
1227 * Display Aspect Ratio so we convert by scaling by the Storage
1228 * Aspect Ratio (w/h). We do the calc in floating point to get the
1229 * rounding right. */
1230 info->aspect = (double)info->pixel_aspect_width *
1231 (double)context->width /
1232 (double)info->pixel_aspect_height /
1233 (double)context->height;
1235 info->profile = context->profile;
1236 info->level = context->level;
1237 info->name = context->codec->name;
1243 static int decavcodecvBSInfo( hb_work_object_t *w, const hb_buffer_t *buf,
1244 hb_work_info_t *info )
1249 hb_work_object_t hb_decavcodecv =
1252 "Video decoder (libavcodec)",
1261 // This is a special decoder for ffmpeg streams. The ffmpeg stream reader
1262 // includes a parser and passes information from the parser to the decoder
1263 // via a codec context kept in the AVStream of the reader's AVFormatContext.
1264 // We *have* to use that codec context to decode the stream or we'll get
1265 // garbage. ffmpeg_title_scan put a cookie that can be used to get to that
1266 // codec context in our codec_param.
1268 // this routine gets the appropriate context pointer from the ffmpeg
1269 // stream reader. it can't be called until we get the first buffer because
1270 // we can't guarantee that reader will be called before the our init
1271 // routine and if our init is called first we'll get a pointer to the
1272 // old scan stream (which has already been closed).
1273 static void init_ffmpeg_context( hb_work_object_t *w )
1275 hb_work_private_t *pv = w->private_data;
1276 pv->context = hb_ffmpeg_context( w->codec_param );
1278 // during scan the decoder gets closed & reopened which will
1279 // close the codec so reopen it if it's not there
1280 if ( ! pv->context->codec )
1282 AVCodec *codec = avcodec_find_decoder( pv->context->codec_id );
1283 hb_avcodec_open( pv->context, codec );
1285 // set up our best guess at the frame duration.
1286 // the frame rate in the codec is usually bogus but it's sometimes
1287 // ok in the stream.
1288 AVStream *st = hb_ffmpeg_avstream( w->codec_param );
1290 if ( st->nb_frames && st->duration )
1292 // compute the average frame duration from the total number
1293 // of frames & the total duration.
1294 pv->duration = ( (double)st->duration * (double)st->time_base.num ) /
1295 ( (double)st->nb_frames * (double)st->time_base.den );
1299 // XXX We don't have a frame count or duration so try to use the
1300 // far less reliable time base info in the stream.
1301 // Because the time bases are so screwed up, we only take values
1302 // in the range 8fps - 64fps.
1304 if ( st->avg_frame_rate.den * 64L > st->avg_frame_rate.num &&
1305 st->avg_frame_rate.num > st->avg_frame_rate.den * 8L )
1307 tb.num = st->avg_frame_rate.den;
1308 tb.den = st->avg_frame_rate.num;
1310 else if ( st->time_base.num * 64L > st->time_base.den &&
1311 st->time_base.den > st->time_base.num * 8L )
1315 else if ( st->r_frame_rate.den * 64L > st->r_frame_rate.num &&
1316 st->r_frame_rate.num > st->r_frame_rate.den * 8L )
1318 tb.num = st->r_frame_rate.den;
1319 tb.den = st->r_frame_rate.num;
1323 tb.num = 1001; /*XXX*/
1324 tb.den = 24000; /*XXX*/
1326 pv->duration = (double)tb.num / (double)tb.den;
1328 pv->duration *= 90000.;
1330 // we have to wrap ffmpeg's get_buffer to be able to set the pts (?!)
1331 pv->context->opaque = pv;
1332 pv->context->get_buffer = get_frame_buf;
1333 pv->context->reget_buffer = reget_frame_buf;
1335 // avi, mkv and possibly mp4 containers can contain the M$ VFW packed
1336 // b-frames abortion that messes up frame ordering and timestamps.
1337 // XXX ffmpeg knows which streams are broken but doesn't expose the
1338 // info externally. We should patch ffmpeg to add a flag to the
1339 // codec context for this but until then we mark all ffmpeg streams
1341 pv->brokenByMicrosoft = 1;
1344 static void prepare_ffmpeg_buffer( hb_buffer_t * in )
1346 // ffmpeg requires an extra 8 bytes of zero at the end of the buffer and
1347 // will seg fault in odd, data dependent ways if it's not there. (my guess
1348 // is this is a case of a local performance optimization creating a global
1349 // performance degradation since all the time wasted by extraneous data
1350 // copies & memory zeroing has to be huge compared to the minor reduction
1351 // in inner-loop instructions this affords - modern cpus bottleneck on
1352 // memory bandwidth not instruction bandwidth).
1353 if ( in->size + FF_INPUT_BUFFER_PADDING_SIZE > in->alloc )
1355 // have to realloc to add the padding
1356 hb_buffer_realloc( in, in->size + FF_INPUT_BUFFER_PADDING_SIZE );
1358 memset( in->data + in->size, 0, FF_INPUT_BUFFER_PADDING_SIZE );
1361 static int decavcodecviInit( hb_work_object_t * w, hb_job_t * job )
1364 hb_work_private_t *pv = calloc( 1, sizeof( hb_work_private_t ) );
1366 w->private_data = pv;
1368 pv->list = hb_list_init();
1371 if ( w->audio != NULL )
1373 if ( w->audio->config.out.codec == HB_ACODEC_AC3 )
1375 // ffmpegs audio encoder expect an smpte chan map as input.
1376 // So we need to map the decoders output to smpte.
1377 pv->out_map = &hb_smpte_chan_map;
1381 pv->out_map = &hb_qt_chan_map;
1383 if ( hb_need_downmix( w->audio->config.in.channel_layout,
1384 w->audio->config.out.mixdown) )
1386 pv->downmix = hb_downmix_init(w->audio->config.in.channel_layout,
1387 w->audio->config.out.mixdown);
1388 hb_downmix_set_chan_map( pv->downmix, &hb_smpte_chan_map, pv->out_map );
1391 pv->ff_audio_list = hb_list_init();
1392 for ( i = 0; i < hb_list_count( w->audio->priv.ff_audio_list ); i++ )
1394 hb_work_private_t * ff_pv = calloc( 1, sizeof( hb_work_private_t ) );
1395 hb_list_add( pv->ff_audio_list, ff_pv );
1397 hb_audio_t *audio = hb_list_item( w->audio->priv.ff_audio_list, i );
1399 ff_pv->list = hb_list_init();
1401 ff_pv->pts_next = -1;
1403 if ( audio->config.out.codec == HB_ACODEC_AC3 )
1405 // ffmpegs audio encoder expect an smpte chan map as input.
1406 // So we need to map the decoders output to smpte.
1407 ff_pv->out_map = &hb_smpte_chan_map;
1411 ff_pv->out_map = &hb_qt_chan_map;
1413 if ( hb_need_downmix( audio->config.in.channel_layout,
1414 audio->config.out.mixdown) )
1416 ff_pv->downmix = hb_downmix_init(audio->config.in.channel_layout,
1417 audio->config.out.mixdown);
1418 hb_downmix_set_chan_map( ff_pv->downmix, &hb_smpte_chan_map, ff_pv->out_map );
1426 static int decavcodecviWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
1427 hb_buffer_t ** buf_out )
1429 hb_work_private_t *pv = w->private_data;
1430 hb_buffer_t *in = *buf_in;
1433 /* if we got an empty buffer signaling end-of-stream send it downstream */
1434 if ( in->size == 0 )
1436 /* flush any frames left in the decoder */
1437 while ( pv->context && decodeFrame( pv, NULL, 0, in->sequence, AV_NOPTS_VALUE, AV_NOPTS_VALUE ) )
1440 flushDelayQueue( pv );
1441 hb_list_add( pv->list, in );
1442 *buf_out = link_buf_list( pv );
1443 return HB_WORK_DONE;
1446 if ( ! pv->context )
1448 init_ffmpeg_context( w );
1451 int64_t pts = in->start;
1454 // use the first timestamp as our 'next expected' pts
1455 if ( pv->pts_next < 0 )
1463 pv->new_chap = in->new_chap;
1464 pv->chap_time = pts >= 0? pts : pv->pts_next;
1466 prepare_ffmpeg_buffer( in );
1467 decodeFrame( pv, in->data, in->size, in->sequence, in->start, in->renderOffset );
1468 hb_buffer_close( &in );
1469 *buf_out = link_buf_list( pv );
1473 static int decavcodecviInfo( hb_work_object_t *w, hb_work_info_t *info )
1475 if ( decavcodecvInfo( w, info ) )
1477 hb_work_private_t *pv = w->private_data;
1478 if ( ! pv->context )
1480 init_ffmpeg_context( w );
1482 // we have the frame duration in units of the 90KHz pts clock but
1483 // need it in units of the 27MHz MPEG clock. */
1484 info->rate = 27000000;
1485 info->rate_base = pv->duration * 300.;
1491 static hb_buffer_t * downmixAudio(
1493 hb_work_private_t *pv,
1498 hb_buffer_t * buf = NULL;
1502 pv->downmix_buffer = realloc(pv->downmix_buffer, nsamples * sizeof(hb_sample_t));
1505 for( i = 0; i < nsamples; ++i )
1507 pv->downmix_buffer[i] = buffer[i];
1510 int n_ch_samples = nsamples / channels;
1511 int out_channels = HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(audio->config.out.mixdown);
1513 buf = hb_buffer_init( n_ch_samples * out_channels * sizeof(float) );
1514 hb_sample_t *samples = (hb_sample_t *)buf->data;
1515 hb_downmix(pv->downmix, samples, pv->downmix_buffer, n_ch_samples);
1519 buf = hb_buffer_init( nsamples * sizeof(float) );
1520 float *fl32 = (float *)buf->data;
1522 for( i = 0; i < nsamples; ++i )
1524 fl32[i] = buffer[i];
1526 int n_ch_samples = nsamples / channels;
1527 hb_layout_remap( &hb_smpte_chan_map, pv->out_map,
1528 audio->config.in.channel_layout,
1529 fl32, n_ch_samples );
1535 static void decodeAudio( hb_audio_t * audio, hb_work_private_t *pv, uint8_t *data, int size, int64_t pts )
1537 AVCodecContext *context = pv->context;
1539 int loop_limit = 256;
1541 while ( pos < size )
1543 int16_t *buffer = pv->buffer;
1544 if ( buffer == NULL )
1546 pv->buffer = av_malloc( AVCODEC_MAX_AUDIO_FRAME_SIZE );
1547 buffer = pv->buffer;
1551 av_init_packet( &avp );
1552 avp.data = data + pos;
1553 avp.size = size - pos;
1555 avp.dts = AV_NOPTS_VALUE;
1557 int out_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
1559 int len = avcodec_decode_audio3( context, buffer, &out_size, &avp );
1566 if ( !(loop_limit--) )
1575 // We require signed 16-bit ints for the output format. If
1576 // we got something different convert it.
1577 if ( context->sample_fmt != SAMPLE_FMT_S16 )
1579 // Note: av_audio_convert seems to be a work-in-progress but
1580 // looks like it will eventually handle general audio
1581 // mixdowns which would allow us much more flexibility
1582 // in handling multichannel audio in HB. If we were doing
1583 // anything more complicated than a one-for-one format
1584 // conversion we'd probably want to cache the converter
1585 // context in the pv.
1586 int isamp = av_get_bits_per_sample_fmt( context->sample_fmt ) / 8;
1587 AVAudioConvert *ctx = av_audio_convert_alloc( SAMPLE_FMT_S16, 1,
1588 context->sample_fmt, 1,
1590 // get output buffer size (in 2-byte samples) then malloc a buffer
1591 nsamples = out_size / isamp;
1592 buffer = av_malloc( nsamples * 2 );
1594 // we're doing straight sample format conversion which behaves as if
1595 // there were only one channel.
1596 const void * const ibuf[6] = { pv->buffer };
1597 void * const obuf[6] = { buffer };
1598 const int istride[6] = { isamp };
1599 const int ostride[6] = { 2 };
1601 av_audio_convert( ctx, obuf, ostride, ibuf, istride, nsamples );
1602 av_audio_convert_free( ctx );
1606 nsamples = out_size / 2;
1609 if ( pts == AV_NOPTS_VALUE )
1615 double pts_next = pts + nsamples * pv->duration;
1616 buf = downmixAudio( audio, pv, buffer, context->channels, nsamples );
1620 buf->stop = pts_next;
1621 hb_list_add( pv->list, buf );
1625 for ( i = 0; i < hb_list_count( audio->priv.ff_audio_list ); i++ )
1627 hb_audio_t *ff_audio = hb_list_item( audio->priv.ff_audio_list, i );
1628 hb_work_private_t *ff_pv = hb_list_item( pv->ff_audio_list, i );
1631 buf = downmixAudio( ff_audio, ff_pv, buffer, context->channels, nsamples );
1635 buf->stop = pts_next;
1636 hb_list_add( ff_pv->list, buf );
1640 pv->pts_next = pts_next;
1642 // if we allocated a buffer for sample format conversion, free it
1643 if ( buffer != pv->buffer )
1651 static int decavcodecaiWork( hb_work_object_t *w, hb_buffer_t **buf_in,
1652 hb_buffer_t **buf_out )
1654 if ( (*buf_in)->size <= 0 )
1656 /* EOF on input stream - send it downstream & say that we're done */
1660 return HB_WORK_DONE;
1663 hb_work_private_t *pv = w->private_data;
1665 if ( (*buf_in)->start < -1 && pv->pts_next <= 0 )
1667 // discard buffers that start before video time 0
1672 if ( ! pv->context )
1674 init_ffmpeg_context( w );
1675 // duration is a scaling factor to go from #bytes in the decoded
1676 // frame to frame time (in 90KHz mpeg ticks). 'channels' converts
1677 // total samples to per-channel samples. 'sample_rate' converts
1678 // per-channel samples to seconds per sample and the 90000
1679 // is mpeg ticks per second.
1680 pv->duration = 90000. /
1681 (double)( pv->context->sample_rate * pv->context->channels );
1683 hb_buffer_t *in = *buf_in;
1685 // if the packet has a timestamp use it if we don't have a timestamp yet
1686 // or if there's been a timing discontinuity of more than 100ms.
1687 if ( in->start >= 0 &&
1688 ( pv->pts_next < 0 || ( in->start - pv->pts_next ) > 90*100 ) )
1690 pv->pts_next = in->start;
1692 prepare_ffmpeg_buffer( in );
1693 decodeAudio( w->audio, pv, in->data, in->size, pv->pts_next );
1694 writeAudioFifos( w );
1695 *buf_out = link_buf_list( pv );
1700 hb_work_object_t hb_decavcodecvi =
1703 "Video decoder (ffmpeg streams)",
1711 hb_work_object_t hb_decavcodecai =
1714 "Audio decoder (ffmpeg streams)",