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 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)
103 int new_chap; // output chapter mark pending
106 uint32_t decode_errors;
107 int brokenByMicrosoft; // video stream may contain packed b-frames
108 hb_buffer_t* delayq[HEAP_SIZE];
111 struct SwsContext *sws_context; // if we have to rescale or convert color space
112 hb_downmix_t *downmix;
113 hb_sample_t *downmix_buffer;
116 static void decodeAudio( hb_audio_t * audio, hb_work_private_t *pv, uint8_t *data, int size );
117 static hb_buffer_t *link_buf_list( hb_work_private_t *pv );
120 static int64_t heap_pop( pts_heap_t *heap )
124 if ( heap->nheap <= 0 )
129 // return the top of the heap then put the bottom element on top,
130 // decrease the heap size by one & rebalence the heap.
133 int64_t v = heap->h[heap->nheap--];
135 int child = parent << 1;
136 while ( child <= heap->nheap )
138 // find the smallest of the two children of parent
139 if (child < heap->nheap && heap->h[child] > heap->h[child+1] )
142 if (v <= heap->h[child])
143 // new item is smaller than either child so it's the new parent.
146 // smallest child is smaller than new item so move it up then
147 // check its children.
148 int64_t hp = heap->h[child];
149 heap->h[parent] = hp;
157 static void heap_push( pts_heap_t *heap, int64_t v )
159 if ( heap->nheap < HEAP_SIZE )
164 // stick the new value on the bottom of the heap then bubble it
165 // up to its correct spot.
166 int child = heap->nheap;
168 int parent = child >> 1;
169 if (heap->h[parent] <= v)
172 int64_t hp = heap->h[parent];
180 /***********************************************************************
181 * hb_work_decavcodec_init
182 ***********************************************************************
184 **********************************************************************/
185 static int decavcodecInit( hb_work_object_t * w, hb_job_t * job )
189 hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
190 w->private_data = pv;
193 pv->list = hb_list_init();
195 int codec_id = w->codec_param;
198 codec_id = CODEC_ID_MP2;
200 codec = avcodec_find_decoder( codec_id );
201 pv->parser = av_parser_init( codec_id );
203 pv->context = avcodec_alloc_context();
204 hb_avcodec_open( pv->context, codec );
206 if ( w->audio != NULL &&
207 hb_need_downmix( w->audio->config.in.channel_layout,
208 w->audio->config.out.mixdown) )
210 pv->downmix = hb_downmix_init(w->audio->config.in.channel_layout,
211 w->audio->config.out.mixdown);
212 hb_downmix_set_chan_map( pv->downmix, &hb_smpte_chan_map, &hb_qt_chan_map );
213 if ( w->audio->config.out.codec == HB_ACODEC_LAME )
214 hb_downmix_adjust_level( pv->downmix );
220 /***********************************************************************
222 ***********************************************************************
224 **********************************************************************/
225 static void decavcodecClose( hb_work_object_t * w )
227 hb_work_private_t * pv = w->private_data;
231 if ( pv->job && pv->context && pv->context->codec )
233 hb_log( "%s-decoder done: %u frames, %u decoder errors, %u drops",
234 pv->context->codec->name, pv->nframes, pv->decode_errors,
237 if ( pv->sws_context )
239 sws_freeContext( pv->sws_context );
243 av_parser_close(pv->parser);
245 if ( pv->context && pv->context->codec )
247 hb_avcodec_close( pv->context );
251 hb_list_close( &pv->list );
255 av_free( pv->buffer );
260 hb_downmix_close( &(pv->downmix) );
262 if ( pv->downmix_buffer )
264 free( pv->downmix_buffer );
265 pv->downmix_buffer = NULL;
268 w->private_data = NULL;
272 /***********************************************************************
274 ***********************************************************************
276 **********************************************************************/
277 static int decavcodecWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
278 hb_buffer_t ** buf_out )
280 hb_work_private_t * pv = w->private_data;
281 hb_buffer_t * in = *buf_in;
285 /* EOF on input stream - send it downstream & say that we're done */
293 if ( in->start < -1 && pv->pts_next <= 0 )
295 // discard buffers that start before video time 0
299 // if the packet has a timestamp use it
300 if ( in->start != -1 )
302 pv->pts_next = in->start;
306 for ( pos = 0; pos < in->size; pos += len )
308 uint8_t *parser_output_buffer;
309 int parser_output_buffer_len;
310 int64_t cur = pv->pts_next;
312 if ( pv->parser != NULL )
314 len = av_parser_parse2( pv->parser, pv->context,
315 &parser_output_buffer, &parser_output_buffer_len,
316 in->data + pos, in->size - pos, cur, cur, AV_NOPTS_VALUE );
320 parser_output_buffer = in->data;
321 len = parser_output_buffer_len = in->size;
323 if (parser_output_buffer_len)
325 // set the duration on every frame since the stream format can
326 // change (it shouldn't but there's no way to guarantee it).
327 // duration is a scaling factor to go from #bytes in the decoded
328 // frame to frame time (in 90KHz mpeg ticks). 'channels' converts
329 // total samples to per-channel samples. 'sample_rate' converts
330 // per-channel samples to seconds per sample and the 90000
331 // is mpeg ticks per second.
332 if ( pv->context->sample_rate && pv->context->channels )
334 pv->duration = 90000. /
335 (double)( pv->context->sample_rate * pv->context->channels );
337 decodeAudio( w->audio, pv, parser_output_buffer, parser_output_buffer_len );
340 *buf_out = link_buf_list( pv );
344 static int decavcodecInfo( hb_work_object_t *w, hb_work_info_t *info )
346 hb_work_private_t *pv = w->private_data;
348 memset( info, 0, sizeof(*info) );
350 if ( pv && pv->context )
352 AVCodecContext *context = pv->context;
353 info->bitrate = context->bit_rate;
354 info->rate = context->time_base.num;
355 info->rate_base = context->time_base.den;
356 info->profile = context->profile;
357 info->level = context->level;
363 static int decavcodecBSInfo( hb_work_object_t *w, const hb_buffer_t *buf,
364 hb_work_info_t *info )
366 hb_work_private_t *pv = w->private_data;
369 memset( info, 0, sizeof(*info) );
371 if ( pv && pv->context )
373 return decavcodecInfo( w, info );
376 // We should parse the bitstream to find its parameters but for right
377 // now we just return dummy values if there's a codec that will handle it.
378 AVCodec *codec = avcodec_find_decoder( w->codec_param? w->codec_param :
382 // there's no ffmpeg codec for this audio type - give up
386 static char codec_name[64];
387 info->name = strncpy( codec_name, codec->name, sizeof(codec_name)-1 );
389 AVCodecParserContext *parser = av_parser_init( codec->id );
390 AVCodecContext *context = avcodec_alloc_context();
391 hb_avcodec_open( context, codec );
392 uint8_t *buffer = av_malloc( AVCODEC_MAX_AUDIO_FRAME_SIZE );
393 int out_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
394 unsigned char *pbuffer;
395 int pos, pbuffer_size;
397 while ( buf && !ret )
400 while ( pos < buf->size )
406 len = av_parser_parse2( parser, context, &pbuffer,
407 &pbuffer_size, buf->data + pos,
408 buf->size - pos, buf->start,
409 buf->start, AV_NOPTS_VALUE );
414 len = pbuffer_size = buf->size;
417 if ( pbuffer_size > 0 )
420 av_init_packet( &avp );
422 avp.size = pbuffer_size;
424 len = avcodec_decode_audio3( context, (int16_t*)buffer,
426 if ( len > 0 && context->sample_rate > 0 )
428 info->bitrate = context->bit_rate;
429 info->rate = context->sample_rate;
431 info->channel_layout =
432 hb_ff_layout_xlat(context->channel_layout,
443 if ( parser != NULL )
444 av_parser_close( parser );
445 hb_avcodec_close( context );
449 /* -------------------------------------------------------------
450 * General purpose video decoder using libavcodec
453 static uint8_t *copy_plane( uint8_t *dst, uint8_t* src, int dstride, int sstride,
456 if ( dstride == sstride )
458 memcpy( dst, src, dstride * h );
459 return dst + dstride * h;
461 int lbytes = dstride <= sstride? dstride : sstride;
464 memcpy( dst, src, lbytes );
471 // copy one video frame into an HB buf. If the frame isn't in our color space
472 // or at least one of its dimensions is odd, use sws_scale to convert/rescale it.
473 // Otherwise just copy the bits.
474 static hb_buffer_t *copy_frame( hb_work_private_t *pv, AVFrame *frame )
476 AVCodecContext *context = pv->context;
480 // if the dimensions are odd, drop the lsb since h264 requires that
481 // both width and height be even.
482 w = ( context->width >> 1 ) << 1;
483 h = ( context->height >> 1 ) << 1;
487 w = pv->job->title->width;
488 h = pv->job->title->height;
490 hb_buffer_t *buf = hb_video_buffer_init( w, h );
491 uint8_t *dst = buf->data;
493 if ( context->pix_fmt != PIX_FMT_YUV420P || w != context->width ||
494 h != context->height )
496 // have to convert to our internal color space and/or rescale
498 avpicture_fill( &dstpic, dst, PIX_FMT_YUV420P, w, h );
500 if ( ! pv->sws_context )
502 pv->sws_context = sws_getContext( context->width, context->height, context->pix_fmt,
503 w, h, PIX_FMT_YUV420P,
504 SWS_LANCZOS|SWS_ACCURATE_RND,
507 sws_scale( pv->sws_context, frame->data, frame->linesize, 0, h,
508 dstpic.data, dstpic.linesize );
512 dst = copy_plane( dst, frame->data[0], w, frame->linesize[0], h );
513 w = (w + 1) >> 1; h = (h + 1) >> 1;
514 dst = copy_plane( dst, frame->data[1], w, frame->linesize[1], h );
515 dst = copy_plane( dst, frame->data[2], w, frame->linesize[2], h );
520 static int get_frame_buf( AVCodecContext *context, AVFrame *frame )
522 hb_work_private_t *pv = context->opaque;
523 frame->pts = pv->pts;
525 return avcodec_default_get_buffer( context, frame );
528 static int reget_frame_buf( AVCodecContext *context, AVFrame *frame )
530 hb_work_private_t *pv = context->opaque;
531 frame->pts = pv->pts;
533 return avcodec_default_reget_buffer( context, frame );
536 static void log_chapter( hb_work_private_t *pv, int chap_num, int64_t pts )
538 hb_chapter_t *c = hb_list_item( pv->job->title->list_chapter, chap_num - 1 );
541 hb_log( "%s: \"%s\" (%d) at frame %u time %"PRId64,
542 pv->context->codec->name, c->title, chap_num, pv->nframes, pts );
546 hb_log( "%s: Chapter %d at frame %u time %"PRId64,
547 pv->context->codec->name, chap_num, pv->nframes, pts );
551 static void flushDelayQueue( hb_work_private_t *pv )
554 int slot = pv->nframes & (HEAP_SIZE-1);
556 // flush all the video packets left on our timestamp-reordering delay q
557 while ( ( buf = pv->delayq[slot] ) != NULL )
559 buf->start = heap_pop( &pv->pts_heap );
560 hb_list_add( pv->list, buf );
561 pv->delayq[slot] = NULL;
562 slot = ( slot + 1 ) & (HEAP_SIZE-1);
566 static int decodeFrame( hb_work_private_t *pv, uint8_t *data, int size )
568 int got_picture, oldlevel = 0;
572 if ( global_verbosity_level <= 1 )
574 oldlevel = av_log_get_level();
575 av_log_set_level( AV_LOG_QUIET );
578 av_init_packet( &avp );
581 if ( avcodec_decode_video2( pv->context, &frame, &got_picture, &avp ) < 0 )
585 if ( global_verbosity_level <= 1 )
587 av_log_set_level( oldlevel );
591 // ffmpeg makes it hard to attach a pts to a frame. if the MPEG ES
592 // packet had a pts we handed it to av_parser_parse (if the packet had
593 // no pts we set it to -1 but before the parse we can't distinguish between
594 // the start of a video frame with no pts & an intermediate packet of
595 // some frame which never has a pts). we hope that when parse returns
596 // the frame to us the pts we originally handed it will be in parser->pts.
597 // we put this pts into pv->pts so that when a avcodec_decode_video
598 // finally gets around to allocating an AVFrame to hold the decoded
599 // frame we can stuff that pts into the frame. if all of these relays
600 // worked at this point frame.pts should hold the frame's pts from the
601 // original data stream or -1 if it didn't have one. in the latter case
602 // we generate the next pts in sequence for it.
603 double frame_dur = pv->duration;
604 if ( frame_dur <= 0 )
606 frame_dur = 90000. * (double)pv->context->time_base.num /
607 (double)pv->context->time_base.den;
608 pv->duration = frame_dur;
610 if ( frame.repeat_pict )
612 frame_dur += frame.repeat_pict * frame_dur * 0.5;
614 // XXX Unlike every other video decoder, the Raw decoder doesn't
615 // use the standard buffer allocation routines so we never
616 // get to put a PTS in the frame. Do it now.
617 if ( pv->context->codec_id == CODEC_ID_RAWVIDEO )
622 // If there was no pts for this frame, assume constant frame rate
623 // video & estimate the next frame time from the last & duration.
624 double pts = frame.pts;
629 pv->pts_next = pts + frame_dur;
633 // if we're doing a scan or this content couldn't have been broken
634 // by Microsoft we don't worry about timestamp reordering
635 if ( ! pv->job || ! pv->brokenByMicrosoft )
637 buf = copy_frame( pv, &frame );
639 hb_list_add( pv->list, buf );
644 // XXX This following probably addresses a libavcodec bug but I don't
645 // see an easy fix so we workaround it here.
647 // The M$ 'packed B-frames' atrocity results in decoded frames with
648 // the wrong timestamp. E.g., if there are 2 b-frames the timestamps
649 // we see here will be "2 3 1 5 6 4 ..." instead of "1 2 3 4 5 6".
650 // The frames are actually delivered in the right order but with
651 // the wrong timestamp. To get the correct timestamp attached to
652 // each frame we have a delay queue (longer than the max number of
653 // b-frames) & a sorting heap for the timestamps. As each frame
654 // comes out of the decoder the oldest frame in the queue is removed
655 // and associated with the smallest timestamp. Then the new frame is
656 // added to the queue & its timestamp is pushed on the heap.
657 // This does nothing if the timestamps are correct (i.e., the video
658 // uses a codec that Micro$oft hasn't broken yet) but the frames
659 // get timestamped correctly even when M$ has munged them.
661 // remove the oldest picture from the frame queue (if any) &
662 // give it the smallest timestamp from our heap. The queue size
663 // is a power of two so we get the slot of the oldest by masking
664 // the frame count & this will become the slot of the newest
665 // once we've removed & processed the oldest.
666 int slot = pv->nframes & (HEAP_SIZE-1);
667 if ( ( buf = pv->delayq[slot] ) != NULL )
669 buf->start = heap_pop( &pv->pts_heap );
671 if ( pv->new_chap && buf->start >= pv->chap_time )
673 buf->new_chap = pv->new_chap;
676 log_chapter( pv, buf->new_chap, buf->start );
678 else if ( pv->nframes == 0 )
680 log_chapter( pv, pv->job->chapter_start, buf->start );
682 hb_list_add( pv->list, buf );
685 // add the new frame to the delayq & push its timestamp on the heap
686 pv->delayq[slot] = copy_frame( pv, &frame );
687 heap_push( &pv->pts_heap, pts );
695 static void decodeVideo( hb_work_private_t *pv, uint8_t *data, int size,
696 int64_t pts, int64_t dts )
699 * The following loop is a do..while because we need to handle both
700 * data & the flush at the end (signaled by size=0). At the end there's
701 * generally a frame in the parser & one or more frames in the decoder
702 * (depending on the bframes setting).
708 int len = av_parser_parse2( pv->parser, pv->context, &pout, &pout_len,
709 data + pos, size - pos, pts, dts, AV_NOPTS_VALUE );
714 pv->pts = pv->parser->pts;
715 decodeFrame( pv, pout, pout_len );
717 } while ( pos < size );
719 /* the stuff above flushed the parser, now flush the decoder */
722 while ( decodeFrame( pv, NULL, 0 ) )
725 flushDelayQueue( pv );
729 static hb_buffer_t *link_buf_list( hb_work_private_t *pv )
731 hb_buffer_t *head = hb_list_item( pv->list, 0 );
735 hb_list_rem( pv->list, head );
737 hb_buffer_t *last = head, *buf;
739 while ( ( buf = hb_list_item( pv->list, 0 ) ) != NULL )
741 hb_list_rem( pv->list, buf );
750 static int decavcodecvInit( hb_work_object_t * w, hb_job_t * job )
753 hb_work_private_t *pv = calloc( 1, sizeof( hb_work_private_t ) );
754 w->private_data = pv;
756 pv->list = hb_list_init();
758 int codec_id = w->codec_param;
759 pv->parser = av_parser_init( codec_id );
760 pv->context = avcodec_alloc_context2( CODEC_TYPE_VIDEO );
762 /* we have to wrap ffmpeg's get_buffer to be able to set the pts (?!) */
763 pv->context->opaque = pv;
764 pv->context->get_buffer = get_frame_buf;
765 pv->context->reget_buffer = reget_frame_buf;
770 static int next_hdr( hb_buffer_t *in, int offset )
772 uint8_t *dat = in->data;
773 uint16_t last2 = 0xffff;
774 for ( ; in->size - offset > 1; ++offset )
776 if ( last2 == 0 && dat[offset] == 0x01 )
777 // found an mpeg start code
780 last2 = ( last2 << 8 ) | dat[offset];
786 static int find_hdr( hb_buffer_t *in, int offset, uint8_t hdr_type )
788 if ( in->size - offset < 4 )
789 // not enough room for an mpeg start code
792 for ( ; ( offset = next_hdr( in, offset ) ) >= 0; ++offset )
794 if ( in->data[offset+3] == hdr_type )
801 static int setup_extradata( hb_work_object_t *w, hb_buffer_t *in )
803 hb_work_private_t *pv = w->private_data;
805 // we can't call the avstream funcs but the read_header func in the
806 // AVInputFormat may set up some state in the AVContext. In particular
807 // vc1t_read_header allocates 'extradata' to deal with header issues
808 // related to Microsoft's bizarre engineering notions. We alloc a chunk
809 // of space to make vc1 work then associate the codec with the context.
810 if ( w->codec_param != CODEC_ID_VC1 )
812 // we haven't been inflicted with M$ - allocate a little space as
813 // a marker and return success.
814 pv->context->extradata_size = 16;
815 pv->context->extradata = av_malloc(pv->context->extradata_size);
819 // find the start and and of the sequence header
821 if ( ( shdr = find_hdr( in, 0, 0x0f ) ) < 0 )
823 // didn't find start of seq hdr
826 if ( ( shdr_end = next_hdr( in, shdr + 4 ) ) < 0 )
832 // find the start and and of the entry point header
834 if ( ( ehdr = find_hdr( in, 0, 0x0e ) ) < 0 )
836 // didn't find start of entry point hdr
839 if ( ( ehdr_end = next_hdr( in, ehdr + 4 ) ) < 0 )
845 // found both headers - allocate an extradata big enough to hold both
846 // then copy them into it.
847 pv->context->extradata_size = shdr_end + ehdr_end;
848 pv->context->extradata = av_malloc(pv->context->extradata_size + 8);
849 memcpy( pv->context->extradata, in->data + shdr, shdr_end );
850 memcpy( pv->context->extradata + shdr_end, in->data + ehdr, ehdr_end );
851 memset( pv->context->extradata + shdr_end + ehdr_end, 0, 8);
855 static int decavcodecvWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
856 hb_buffer_t ** buf_out )
858 hb_work_private_t *pv = w->private_data;
859 hb_buffer_t *in = *buf_in;
860 int64_t pts = AV_NOPTS_VALUE;
865 /* if we got an empty buffer signaling end-of-stream send it downstream */
868 decodeVideo( pv, in->data, in->size, pts, dts );
869 hb_list_add( pv->list, in );
870 *buf_out = link_buf_list( pv );
874 // if this is the first frame open the codec (we have to wait for the
875 // first frame because of M$ VC1 braindamage).
876 if ( pv->context->extradata_size == 0 )
878 if ( setup_extradata( w, in ) )
880 // we didn't find the headers needed to set up extradata.
881 // the codec will abort if we open it so just free the buf
882 // and hope we eventually get the info we need.
883 hb_buffer_close( &in );
886 AVCodec *codec = avcodec_find_decoder( w->codec_param );
887 // There's a mis-feature in ffmpeg that causes the context to be
888 // incorrectly initialized the 1st time avcodec_open is called.
889 // If you close it and open a 2nd time, it finishes the job.
890 hb_avcodec_open( pv->context, codec );
891 hb_avcodec_close( pv->context );
892 hb_avcodec_open( pv->context, codec );
898 dts = in->renderOffset;
902 pv->new_chap = in->new_chap;
903 pv->chap_time = pts >= 0? pts : pv->pts_next;
905 decodeVideo( pv, in->data, in->size, pts, dts );
906 hb_buffer_close( &in );
907 *buf_out = link_buf_list( pv );
911 static int decavcodecvInfo( hb_work_object_t *w, hb_work_info_t *info )
913 hb_work_private_t *pv = w->private_data;
915 memset( info, 0, sizeof(*info) );
917 if ( pv && pv->context )
919 AVCodecContext *context = pv->context;
920 info->bitrate = context->bit_rate;
921 info->width = context->width;
922 info->height = context->height;
924 /* ffmpeg gives the frame rate in frames per second while HB wants
925 * it in units of the 27MHz MPEG clock. */
926 info->rate = 27000000;
927 info->rate_base = (int64_t)context->time_base.num * 27000000LL /
928 context->time_base.den;
929 if ( context->ticks_per_frame > 1 )
931 // for ffmpeg 0.5 & later, the H.264 & MPEG-2 time base is
932 // field rate rather than frame rate so convert back to frames.
933 info->rate_base *= context->ticks_per_frame;
936 info->pixel_aspect_width = context->sample_aspect_ratio.num;
937 info->pixel_aspect_height = context->sample_aspect_ratio.den;
939 /* Sometimes there's no pixel aspect set in the source ffmpeg context
940 * which appears to come from the video stream. In that case,
941 * try the pixel aspect in AVStream (which appears to come from
942 * the container). Else assume a 1:1 PAR. */
943 if ( info->pixel_aspect_width == 0 ||
944 info->pixel_aspect_height == 0 )
946 AVStream *st = hb_ffmpeg_avstream( w->codec_param );
947 info->pixel_aspect_width = st->sample_aspect_ratio.num ?
948 st->sample_aspect_ratio.num : 1;
949 info->pixel_aspect_height = st->sample_aspect_ratio.den ?
950 st->sample_aspect_ratio.den : 1;
952 /* ffmpeg returns the Pixel Aspect Ratio (PAR). Handbrake wants the
953 * Display Aspect Ratio so we convert by scaling by the Storage
954 * Aspect Ratio (w/h). We do the calc in floating point to get the
956 info->aspect = (double)info->pixel_aspect_width *
957 (double)context->width /
958 (double)info->pixel_aspect_height /
959 (double)context->height;
961 info->profile = context->profile;
962 info->level = context->level;
963 info->name = context->codec->name;
969 static int decavcodecvBSInfo( hb_work_object_t *w, const hb_buffer_t *buf,
970 hb_work_info_t *info )
975 hb_work_object_t hb_decavcodecv =
978 "Video decoder (libavcodec)",
987 // This is a special decoder for ffmpeg streams. The ffmpeg stream reader
988 // includes a parser and passes information from the parser to the decoder
989 // via a codec context kept in the AVStream of the reader's AVFormatContext.
990 // We *have* to use that codec context to decode the stream or we'll get
991 // garbage. ffmpeg_title_scan put a cookie that can be used to get to that
992 // codec context in our codec_param.
994 // this routine gets the appropriate context pointer from the ffmpeg
995 // stream reader. it can't be called until we get the first buffer because
996 // we can't guarantee that reader will be called before the our init
997 // routine and if our init is called first we'll get a pointer to the
998 // old scan stream (which has already been closed).
999 static void init_ffmpeg_context( hb_work_object_t *w )
1001 hb_work_private_t *pv = w->private_data;
1002 pv->context = hb_ffmpeg_context( w->codec_param );
1004 // during scan the decoder gets closed & reopened which will
1005 // close the codec so reopen it if it's not there
1006 if ( ! pv->context->codec )
1008 AVCodec *codec = avcodec_find_decoder( pv->context->codec_id );
1009 hb_avcodec_open( pv->context, codec );
1011 // set up our best guess at the frame duration.
1012 // the frame rate in the codec is usually bogus but it's sometimes
1013 // ok in the stream.
1014 AVStream *st = hb_ffmpeg_avstream( w->codec_param );
1016 if ( st->nb_frames && st->duration )
1018 // compute the average frame duration from the total number
1019 // of frames & the total duration.
1020 pv->duration = ( (double)st->duration * (double)st->time_base.num ) /
1021 ( (double)st->nb_frames * (double)st->time_base.den );
1025 // XXX We don't have a frame count or duration so try to use the
1026 // far less reliable time base info in the stream.
1027 // Because the time bases are so screwed up, we only take values
1028 // in the range 8fps - 64fps.
1030 if ( st->avg_frame_rate.den * 64 > st->avg_frame_rate.num &&
1031 st->avg_frame_rate.num > st->avg_frame_rate.den * 8 )
1033 tb.num = st->avg_frame_rate.den;
1034 tb.den = st->avg_frame_rate.num;
1036 else if ( st->time_base.num * 64 > st->time_base.den &&
1037 st->time_base.den > st->time_base.num * 8 )
1041 else if ( st->r_frame_rate.den * 64 > st->r_frame_rate.num &&
1042 st->r_frame_rate.num > st->r_frame_rate.den * 8 )
1044 tb.num = st->r_frame_rate.den;
1045 tb.den = st->r_frame_rate.num;
1049 tb.num = 1001; /*XXX*/
1050 tb.den = 24000; /*XXX*/
1052 pv->duration = (double)tb.num / (double)tb.den;
1054 pv->duration *= 90000.;
1056 // we have to wrap ffmpeg's get_buffer to be able to set the pts (?!)
1057 pv->context->opaque = pv;
1058 pv->context->get_buffer = get_frame_buf;
1059 pv->context->reget_buffer = reget_frame_buf;
1061 // avi, mkv and possibly mp4 containers can contain the M$ VFW packed
1062 // b-frames abortion that messes up frame ordering and timestamps.
1063 // XXX ffmpeg knows which streams are broken but doesn't expose the
1064 // info externally. We should patch ffmpeg to add a flag to the
1065 // codec context for this but until then we mark all ffmpeg streams
1067 pv->brokenByMicrosoft = 1;
1070 static void prepare_ffmpeg_buffer( hb_buffer_t * in )
1072 // ffmpeg requires an extra 8 bytes of zero at the end of the buffer and
1073 // will seg fault in odd, data dependent ways if it's not there. (my guess
1074 // is this is a case of a local performance optimization creating a global
1075 // performance degradation since all the time wasted by extraneous data
1076 // copies & memory zeroing has to be huge compared to the minor reduction
1077 // in inner-loop instructions this affords - modern cpus bottleneck on
1078 // memory bandwidth not instruction bandwidth).
1079 if ( in->size + FF_INPUT_BUFFER_PADDING_SIZE > in->alloc )
1081 // have to realloc to add the padding
1082 hb_buffer_realloc( in, in->size + FF_INPUT_BUFFER_PADDING_SIZE );
1084 memset( in->data + in->size, 0, FF_INPUT_BUFFER_PADDING_SIZE );
1087 static int decavcodecviInit( hb_work_object_t * w, hb_job_t * job )
1090 hb_work_private_t *pv = calloc( 1, sizeof( hb_work_private_t ) );
1091 w->private_data = pv;
1093 pv->list = hb_list_init();
1097 if ( w->audio != NULL &&
1098 hb_need_downmix( w->audio->config.in.channel_layout,
1099 w->audio->config.out.mixdown) )
1101 pv->downmix = hb_downmix_init(w->audio->config.in.channel_layout,
1102 w->audio->config.out.mixdown);
1103 hb_downmix_set_chan_map( pv->downmix, &hb_smpte_chan_map, &hb_qt_chan_map );
1104 if ( w->audio->config.out.codec == HB_ACODEC_LAME )
1105 hb_downmix_adjust_level( pv->downmix );
1111 static int decavcodecviWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
1112 hb_buffer_t ** buf_out )
1114 hb_work_private_t *pv = w->private_data;
1115 hb_buffer_t *in = *buf_in;
1118 /* if we got an empty buffer signaling end-of-stream send it downstream */
1119 if ( in->size == 0 )
1121 /* flush any frames left in the decoder */
1122 while ( pv->context && decodeFrame( pv, NULL, 0 ) )
1125 flushDelayQueue( pv );
1126 hb_list_add( pv->list, in );
1127 *buf_out = link_buf_list( pv );
1128 return HB_WORK_DONE;
1131 if ( ! pv->context )
1133 init_ffmpeg_context( w );
1136 int64_t pts = in->start;
1139 // use the first timestamp as our 'next expected' pts
1140 if ( pv->pts_next < 0 )
1149 pv->new_chap = in->new_chap;
1150 pv->chap_time = pts >= 0? pts : pv->pts_next;
1152 prepare_ffmpeg_buffer( in );
1153 decodeFrame( pv, in->data, in->size );
1154 hb_buffer_close( &in );
1155 *buf_out = link_buf_list( pv );
1159 static int decavcodecviInfo( hb_work_object_t *w, hb_work_info_t *info )
1161 if ( decavcodecvInfo( w, info ) )
1163 hb_work_private_t *pv = w->private_data;
1164 if ( ! pv->context )
1166 init_ffmpeg_context( w );
1168 // we have the frame duration in units of the 90KHz pts clock but
1169 // need it in units of the 27MHz MPEG clock. */
1170 info->rate = 27000000;
1171 info->rate_base = pv->duration * 300.;
1177 static void decodeAudio( hb_audio_t * audio, hb_work_private_t *pv, uint8_t *data, int size )
1179 AVCodecContext *context = pv->context;
1181 int loop_limit = 256;
1183 while ( pos < size )
1185 int16_t *buffer = pv->buffer;
1186 if ( buffer == NULL )
1188 pv->buffer = av_malloc( AVCODEC_MAX_AUDIO_FRAME_SIZE );
1189 buffer = pv->buffer;
1193 av_init_packet( &avp );
1194 avp.data = data + pos;
1195 avp.size = size - pos;
1197 int out_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
1199 int len = avcodec_decode_audio3( context, buffer, &out_size, &avp );
1206 if ( !(loop_limit--) )
1215 // We require signed 16-bit ints for the output format. If
1216 // we got something different convert it.
1217 if ( context->sample_fmt != SAMPLE_FMT_S16 )
1219 // Note: av_audio_convert seems to be a work-in-progress but
1220 // looks like it will eventually handle general audio
1221 // mixdowns which would allow us much more flexibility
1222 // in handling multichannel audio in HB. If we were doing
1223 // anything more complicated than a one-for-one format
1224 // conversion we'd probably want to cache the converter
1225 // context in the pv.
1226 int isamp = av_get_bits_per_sample_format( context->sample_fmt ) / 8;
1227 AVAudioConvert *ctx = av_audio_convert_alloc( SAMPLE_FMT_S16, 1,
1228 context->sample_fmt, 1,
1230 // get output buffer size (in 2-byte samples) then malloc a buffer
1231 nsamples = out_size / isamp;
1232 buffer = av_malloc( nsamples * 2 );
1234 // we're doing straight sample format conversion which behaves as if
1235 // there were only one channel.
1236 const void * const ibuf[6] = { pv->buffer };
1237 void * const obuf[6] = { buffer };
1238 const int istride[6] = { isamp };
1239 const int ostride[6] = { 2 };
1241 av_audio_convert( ctx, obuf, ostride, ibuf, istride, nsamples );
1242 av_audio_convert_free( ctx );
1246 nsamples = out_size / 2;
1253 pv->downmix_buffer = realloc(pv->downmix_buffer, nsamples * sizeof(hb_sample_t));
1256 for( i = 0; i < nsamples; ++i )
1258 pv->downmix_buffer[i] = buffer[i];
1261 int n_ch_samples = nsamples / context->channels;
1262 int channels = HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(audio->config.out.mixdown);
1264 buf = hb_buffer_init( n_ch_samples * channels * sizeof(float) );
1265 hb_sample_t *samples = (hb_sample_t *)buf->data;
1266 hb_downmix(pv->downmix, samples, pv->downmix_buffer, n_ch_samples);
1270 buf = hb_buffer_init( nsamples * sizeof(float) );
1271 float *fl32 = (float *)buf->data;
1273 for( i = 0; i < nsamples; ++i )
1275 fl32[i] = buffer[i];
1277 int n_ch_samples = nsamples / context->channels;
1278 hb_layout_remap( &hb_smpte_chan_map, &hb_qt_chan_map,
1279 audio->config.in.channel_layout,
1280 fl32, n_ch_samples );
1283 double pts = pv->pts_next;
1285 pts += nsamples * pv->duration;
1289 hb_list_add( pv->list, buf );
1291 // if we allocated a buffer for sample format conversion, free it
1292 if ( buffer != pv->buffer )
1300 static int decavcodecaiWork( hb_work_object_t *w, hb_buffer_t **buf_in,
1301 hb_buffer_t **buf_out )
1303 if ( (*buf_in)->size <= 0 )
1305 /* EOF on input stream - send it downstream & say that we're done */
1308 return HB_WORK_DONE;
1311 hb_work_private_t *pv = w->private_data;
1313 if ( (*buf_in)->start < -1 && pv->pts_next <= 0 )
1315 // discard buffers that start before video time 0
1320 if ( ! pv->context )
1322 init_ffmpeg_context( w );
1323 // duration is a scaling factor to go from #bytes in the decoded
1324 // frame to frame time (in 90KHz mpeg ticks). 'channels' converts
1325 // total samples to per-channel samples. 'sample_rate' converts
1326 // per-channel samples to seconds per sample and the 90000
1327 // is mpeg ticks per second.
1328 pv->duration = 90000. /
1329 (double)( pv->context->sample_rate * pv->context->channels );
1331 hb_buffer_t *in = *buf_in;
1333 // if the packet has a timestamp use it if we don't have a timestamp yet
1334 // or if there's been a timing discontinuity of more than 100ms.
1335 if ( in->start >= 0 &&
1336 ( pv->pts_next < 0 || ( in->start - pv->pts_next ) > 90*100 ) )
1338 pv->pts_next = in->start;
1340 prepare_ffmpeg_buffer( in );
1341 decodeAudio( w->audio, pv, in->data, in->size );
1342 *buf_out = link_buf_list( pv );
1347 hb_work_object_t hb_decavcodecvi =
1350 "Video decoder (ffmpeg streams)",
1358 hb_work_object_t hb_decavcodecai =
1361 "Audio decoder (ffmpeg streams)",