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"
66 #include "libswscale/swscale.h"
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 double duration; // frame duration (for video)
101 double pts_next; // next pts we expect to generate
102 int64_t pts; // (video) pts passing from parser to decoder
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
115 static int64_t heap_pop( pts_heap_t *heap )
119 if ( heap->nheap <= 0 )
124 // return the top of the heap then put the bottom element on top,
125 // decrease the heap size by one & rebalence the heap.
128 int64_t v = heap->h[heap->nheap--];
130 int child = parent << 1;
131 while ( child <= heap->nheap )
133 // find the smallest of the two children of parent
134 if (child < heap->nheap && heap->h[child] > heap->h[child+1] )
137 if (v <= heap->h[child])
138 // new item is smaller than either child so it's the new parent.
141 // smallest child is smaller than new item so move it up then
142 // check its children.
143 int64_t hp = heap->h[child];
144 heap->h[parent] = hp;
152 static void heap_push( pts_heap_t *heap, int64_t v )
154 if ( heap->nheap < HEAP_SIZE )
159 // stick the new value on the bottom of the heap then bubble it
160 // up to its correct spot.
161 int child = heap->nheap;
163 int parent = child >> 1;
164 if (heap->h[parent] <= v)
167 int64_t hp = heap->h[parent];
175 /***********************************************************************
176 * hb_work_decavcodec_init
177 ***********************************************************************
179 **********************************************************************/
180 static int decavcodecInit( hb_work_object_t * w, hb_job_t * job )
184 hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
185 w->private_data = pv;
189 int codec_id = w->codec_param;
192 codec_id = CODEC_ID_MP2;
194 codec = avcodec_find_decoder( codec_id );
195 pv->parser = av_parser_init( codec_id );
197 pv->context = avcodec_alloc_context();
198 avcodec_open( pv->context, codec );
203 /***********************************************************************
205 ***********************************************************************
207 **********************************************************************/
208 static void decavcodecClose( hb_work_object_t * w )
210 hb_work_private_t * pv = w->private_data;
214 if ( pv->job && pv->context && pv->context->codec )
216 hb_log( "%s-decoder done: %u frames, %u decoder errors, %u drops",
217 pv->context->codec->name, pv->nframes, pv->decode_errors,
220 if ( pv->sws_context )
222 sws_freeContext( pv->sws_context );
226 av_parser_close(pv->parser);
228 if ( pv->context && pv->context->codec )
230 avcodec_close( pv->context );
234 hb_list_close( &pv->list );
242 w->private_data = NULL;
246 /***********************************************************************
248 ***********************************************************************
250 **********************************************************************/
251 static int decavcodecWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
252 hb_buffer_t ** buf_out )
254 hb_work_private_t * pv = w->private_data;
255 hb_buffer_t * in = *buf_in, * buf, * last = NULL;
256 int pos, len, out_size, i, uncompressed_len;
257 short buffer[AVCODEC_MAX_AUDIO_FRAME_SIZE];
259 unsigned char *parser_output_buffer;
260 int parser_output_buffer_len;
262 if ( (*buf_in)->size <= 0 )
264 /* EOF on input stream - send it downstream & say that we're done */
272 cur = ( in->start < 0 )? pv->pts_next : in->start;
275 while( pos < in->size )
277 len = av_parser_parse( pv->parser, pv->context,
278 &parser_output_buffer, &parser_output_buffer_len,
279 in->data + pos, in->size - pos, cur, cur );
281 uncompressed_len = 0;
282 if (parser_output_buffer_len)
284 out_size = sizeof(buffer);
285 uncompressed_len = avcodec_decode_audio2( pv->context, buffer,
287 parser_output_buffer,
288 parser_output_buffer_len );
295 buf = hb_buffer_init( 2 * out_size );
297 int sample_size_in_bytes = 2; // Default to 2 bytes
298 switch (pv->context->sample_fmt)
301 sample_size_in_bytes = 2;
303 /* We should handle other formats here - but that needs additional format conversion work below */
304 /* For now we'll just report the error and try to carry on */
306 hb_log("decavcodecWork - Unknown Sample Format from avcodec_decode_audio (%d) !", pv->context->sample_fmt);
311 buf->stop = cur + 90000 * ( out_size / (sample_size_in_bytes * pv->context->channels) ) /
312 pv->context->sample_rate;
316 fl32 = (float *) buf->data;
317 for( i = 0; i < out_size / 2; i++ )
324 last = last->next = buf;
328 *buf_out = last = buf;
340 static int decavcodecInfo( hb_work_object_t *w, hb_work_info_t *info )
342 hb_work_private_t *pv = w->private_data;
344 memset( info, 0, sizeof(*info) );
346 if ( pv && pv->context )
348 AVCodecContext *context = pv->context;
349 info->bitrate = context->bit_rate;
350 info->rate = context->time_base.num;
351 info->rate_base = context->time_base.den;
352 info->profile = context->profile;
353 info->level = context->level;
359 static int decavcodecBSInfo( hb_work_object_t *w, const hb_buffer_t *buf,
360 hb_work_info_t *info )
362 hb_work_private_t *pv = w->private_data;
364 memset( info, 0, sizeof(*info) );
366 if ( pv && pv->context )
368 return decavcodecInfo( w, info );
371 // We should parse the bitstream to find its parameters but for right
372 // now we just return dummy values if there's a codec that will handle it.
373 AVCodec *codec = avcodec_find_decoder( w->codec_param? w->codec_param :
377 static char codec_name[64];
379 info->name = strncpy( codec_name, codec->name, sizeof(codec_name)-1 );
380 info->bitrate = 384000;
383 info->channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
389 /* -------------------------------------------------------------
390 * General purpose video decoder using libavcodec
393 static uint8_t *copy_plane( uint8_t *dst, uint8_t* src, int dstride, int sstride,
396 if ( dstride == sstride )
398 memcpy( dst, src, dstride * h );
399 return dst + dstride * h;
401 int lbytes = dstride <= sstride? dstride : sstride;
404 memcpy( dst, src, lbytes );
411 // copy one video frame into an HB buf. If the frame isn't in our color space
412 // or at least one of its dimensions is odd, use sws_scale to convert/rescale it.
413 // Otherwise just copy the bits.
414 static hb_buffer_t *copy_frame( hb_work_private_t *pv, AVFrame *frame )
416 AVCodecContext *context = pv->context;
420 // if the dimensions are odd, drop the lsb since h264 requires that
421 // both width and height be even.
422 w = ( context->width >> 1 ) << 1;
423 h = ( context->height >> 1 ) << 1;
427 w = pv->job->title->width;
428 h = pv->job->title->height;
430 hb_buffer_t *buf = hb_video_buffer_init( w, h );
431 uint8_t *dst = buf->data;
433 if ( context->pix_fmt != PIX_FMT_YUV420P || w != context->width ||
434 h != context->height )
436 // have to convert to our internal color space and/or rescale
438 avpicture_fill( &dstpic, dst, PIX_FMT_YUV420P, w, h );
440 if ( ! pv->sws_context )
442 pv->sws_context = sws_getContext( context->width, context->height, context->pix_fmt,
443 w, h, PIX_FMT_YUV420P,
444 SWS_LANCZOS|SWS_ACCURATE_RND,
447 sws_scale( pv->sws_context, frame->data, frame->linesize, 0, h,
448 dstpic.data, dstpic.linesize );
452 dst = copy_plane( dst, frame->data[0], w, frame->linesize[0], h );
453 w = (w + 1) >> 1; h = (h + 1) >> 1;
454 dst = copy_plane( dst, frame->data[1], w, frame->linesize[1], h );
455 dst = copy_plane( dst, frame->data[2], w, frame->linesize[2], h );
460 static int get_frame_buf( AVCodecContext *context, AVFrame *frame )
462 hb_work_private_t *pv = context->opaque;
463 frame->pts = pv->pts;
465 return avcodec_default_get_buffer( context, frame );
468 static void log_chapter( hb_work_private_t *pv, int chap_num, int64_t pts )
470 hb_chapter_t *c = hb_list_item( pv->job->title->list_chapter, chap_num - 1 );
473 hb_log( "%s: \"%s\" (%d) at frame %u time %lld",
474 pv->context->codec->name, c->title, chap_num, pv->nframes, pts );
478 hb_log( "%s: Chapter %d at frame %u time %lld",
479 pv->context->codec->name, chap_num, pv->nframes, pts );
483 static void flushDelayQueue( hb_work_private_t *pv )
486 int slot = pv->nframes & (HEAP_SIZE-1);
488 // flush all the video packets left on our timestamp-reordering delay q
489 while ( ( buf = pv->delayq[slot] ) != NULL )
491 buf->start = heap_pop( &pv->pts_heap );
492 hb_list_add( pv->list, buf );
493 pv->delayq[slot] = NULL;
494 slot = ( slot + 1 ) & (HEAP_SIZE-1);
498 static int decodeFrame( hb_work_private_t *pv, uint8_t *data, int size )
503 if ( avcodec_decode_video( pv->context, &frame, &got_picture, data, size ) < 0 )
509 // ffmpeg makes it hard to attach a pts to a frame. if the MPEG ES
510 // packet had a pts we handed it to av_parser_parse (if the packet had
511 // no pts we set it to -1 but before the parse we can't distinguish between
512 // the start of a video frame with no pts & an intermediate packet of
513 // some frame which never has a pts). we hope that when parse returns
514 // the frame to us the pts we originally handed it will be in parser->pts.
515 // we put this pts into pv->pts so that when a avcodec_decode_video
516 // finally gets around to allocating an AVFrame to hold the decoded
517 // frame we can stuff that pts into the frame. if all of these relays
518 // worked at this point frame.pts should hold the frame's pts from the
519 // original data stream or -1 if it didn't have one. in the latter case
520 // we generate the next pts in sequence for it.
521 double frame_dur = pv->duration;
522 if ( frame_dur <= 0 )
524 frame_dur = 90000. * (double)pv->context->time_base.num /
525 (double)pv->context->time_base.den;
526 pv->duration = frame_dur;
528 if ( frame.repeat_pict )
530 frame_dur += frame.repeat_pict * frame_dur * 0.5;
532 // If there was no pts for this frame, assume constant frame rate
533 // video & estimate the next frame time from the last & duration.
534 double pts = frame.pts;
539 pv->pts_next = pts + frame_dur;
543 // if we're doing a scan or this content couldn't have been broken
544 // by Microsoft we don't worry about timestamp reordering
545 if ( ! pv->job || ! pv->brokenByMicrosoft )
547 buf = copy_frame( pv, &frame );
549 hb_list_add( pv->list, buf );
554 // XXX This following probably addresses a libavcodec bug but I don't
555 // see an easy fix so we workaround it here.
557 // The M$ 'packed B-frames' atrocity results in decoded frames with
558 // the wrong timestamp. E.g., if there are 2 b-frames the timestamps
559 // we see here will be "2 3 1 5 6 4 ..." instead of "1 2 3 4 5 6".
560 // The frames are actually delivered in the right order but with
561 // the wrong timestamp. To get the correct timestamp attached to
562 // each frame we have a delay queue (longer than the max number of
563 // b-frames) & a sorting heap for the timestamps. As each frame
564 // comes out of the decoder the oldest frame in the queue is removed
565 // and associated with the smallest timestamp. Then the new frame is
566 // added to the queue & its timestamp is pushed on the heap.
567 // This does nothing if the timestamps are correct (i.e., the video
568 // uses a codec that Micro$oft hasn't broken yet) but the frames
569 // get timestamped correctly even when M$ has munged them.
571 // remove the oldest picture from the frame queue (if any) &
572 // give it the smallest timestamp from our heap. The queue size
573 // is a power of two so we get the slot of the oldest by masking
574 // the frame count & this will become the slot of the newest
575 // once we've removed & processed the oldest.
576 int slot = pv->nframes & (HEAP_SIZE-1);
577 if ( ( buf = pv->delayq[slot] ) != NULL )
579 buf->start = heap_pop( &pv->pts_heap );
581 if ( pv->new_chap && buf->start >= pv->chap_time )
583 buf->new_chap = pv->new_chap;
586 log_chapter( pv, buf->new_chap, buf->start );
588 else if ( pv->nframes == 0 )
590 log_chapter( pv, pv->job->chapter_start, buf->start );
592 hb_list_add( pv->list, buf );
595 // add the new frame to the delayq & push its timestamp on the heap
596 pv->delayq[slot] = copy_frame( pv, &frame );
597 heap_push( &pv->pts_heap, pts );
605 static void decodeVideo( hb_work_private_t *pv, uint8_t *data, int size,
606 int64_t pts, int64_t dts )
609 * The following loop is a do..while because we need to handle both
610 * data & the flush at the end (signaled by size=0). At the end there's
611 * generally a frame in the parser & one or more frames in the decoder
612 * (depending on the bframes setting).
618 int len = av_parser_parse( pv->parser, pv->context, &pout, &pout_len,
619 data + pos, size - pos, pts, dts );
624 pv->pts = pv->parser->pts;
625 decodeFrame( pv, pout, pout_len );
627 } while ( pos < size );
629 /* the stuff above flushed the parser, now flush the decoder */
632 while ( decodeFrame( pv, NULL, 0 ) )
635 flushDelayQueue( pv );
639 static hb_buffer_t *link_buf_list( hb_work_private_t *pv )
641 hb_buffer_t *head = hb_list_item( pv->list, 0 );
645 hb_list_rem( pv->list, head );
647 hb_buffer_t *last = head, *buf;
649 while ( ( buf = hb_list_item( pv->list, 0 ) ) != NULL )
651 hb_list_rem( pv->list, buf );
660 static int decavcodecvInit( hb_work_object_t * w, hb_job_t * job )
663 hb_work_private_t *pv = calloc( 1, sizeof( hb_work_private_t ) );
664 w->private_data = pv;
666 pv->list = hb_list_init();
668 int codec_id = w->codec_param;
669 pv->parser = av_parser_init( codec_id );
670 pv->context = avcodec_alloc_context2( CODEC_TYPE_VIDEO );
672 /* we have to wrap ffmpeg's get_buffer to be able to set the pts (?!) */
673 pv->context->opaque = pv;
674 pv->context->get_buffer = get_frame_buf;
679 static int next_hdr( hb_buffer_t *in, int offset )
681 uint8_t *dat = in->data;
682 uint16_t last2 = 0xffff;
683 for ( ; in->size - offset > 1; ++offset )
685 if ( last2 == 0 && dat[offset] == 0x01 )
686 // found an mpeg start code
689 last2 = ( last2 << 8 ) | dat[offset];
695 static int find_hdr( hb_buffer_t *in, int offset, uint8_t hdr_type )
697 if ( in->size - offset < 4 )
698 // not enough room for an mpeg start code
701 for ( ; ( offset = next_hdr( in, offset ) ) >= 0; ++offset )
703 if ( in->data[offset+3] == hdr_type )
710 static int setup_extradata( hb_work_object_t *w, hb_buffer_t *in )
712 hb_work_private_t *pv = w->private_data;
714 // we can't call the avstream funcs but the read_header func in the
715 // AVInputFormat may set up some state in the AVContext. In particular
716 // vc1t_read_header allocates 'extradata' to deal with header issues
717 // related to Microsoft's bizarre engineering notions. We alloc a chunk
718 // of space to make vc1 work then associate the codec with the context.
719 if ( w->codec_param != CODEC_ID_VC1 )
721 // we haven't been inflicted with M$ - allocate a little space as
722 // a marker and return success.
723 pv->context->extradata_size = 16;
724 pv->context->extradata = av_malloc(pv->context->extradata_size);
728 // find the start and and of the sequence header
730 if ( ( shdr = find_hdr( in, 0, 0x0f ) ) < 0 )
732 // didn't find start of seq hdr
735 if ( ( shdr_end = next_hdr( in, shdr + 4 ) ) < 0 )
741 // find the start and and of the entry point header
743 if ( ( ehdr = find_hdr( in, 0, 0x0e ) ) < 0 )
745 // didn't find start of entry point hdr
748 if ( ( ehdr_end = next_hdr( in, ehdr + 4 ) ) < 0 )
754 // found both headers - allocate an extradata big enough to hold both
755 // then copy them into it.
756 pv->context->extradata_size = shdr_end + ehdr_end;
757 pv->context->extradata = av_malloc(pv->context->extradata_size + 8);
758 memcpy( pv->context->extradata, in->data + shdr, shdr_end );
759 memcpy( pv->context->extradata + shdr_end, in->data + ehdr, ehdr_end );
760 memset( pv->context->extradata + shdr_end + ehdr_end, 0, 8);
764 static int decavcodecvWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
765 hb_buffer_t ** buf_out )
767 hb_work_private_t *pv = w->private_data;
768 hb_buffer_t *in = *buf_in;
769 int64_t pts = AV_NOPTS_VALUE;
774 /* if we got an empty buffer signaling end-of-stream send it downstream */
777 decodeVideo( pv, in->data, in->size, pts, dts );
778 hb_list_add( pv->list, in );
779 *buf_out = link_buf_list( pv );
783 // if this is the first frame open the codec (we have to wait for the
784 // first frame because of M$ VC1 braindamage).
785 if ( pv->context->extradata_size == 0 )
787 if ( setup_extradata( w, in ) )
789 // we didn't find the headers needed to set up extradata.
790 // the codec will abort if we open it so just free the buf
791 // and hope we eventually get the info we need.
792 hb_buffer_close( &in );
795 AVCodec *codec = avcodec_find_decoder( w->codec_param );
796 // There's a mis-feature in ffmpeg that causes the context to be
797 // incorrectly initialized the 1st time avcodec_open is called.
798 // If you close it and open a 2nd time, it finishes the job.
799 avcodec_open( pv->context, codec );
800 avcodec_close( pv->context );
801 avcodec_open( pv->context, codec );
807 dts = in->renderOffset;
811 pv->new_chap = in->new_chap;
812 pv->chap_time = pts >= 0? pts : pv->pts_next;
814 decodeVideo( pv, in->data, in->size, pts, dts );
815 hb_buffer_close( &in );
816 *buf_out = link_buf_list( pv );
820 static int decavcodecvInfo( hb_work_object_t *w, hb_work_info_t *info )
822 hb_work_private_t *pv = w->private_data;
824 memset( info, 0, sizeof(*info) );
826 if ( pv && pv->context )
828 AVCodecContext *context = pv->context;
829 info->bitrate = context->bit_rate;
830 info->width = context->width;
831 info->height = context->height;
833 /* ffmpeg gives the frame rate in frames per second while HB wants
834 * it in units of the 27MHz MPEG clock. */
835 info->rate = 27000000;
836 info->rate_base = (int64_t)context->time_base.num * 27000000LL /
837 context->time_base.den;
839 /* Sometimes there's no pixel aspect set in the source. In that case,
840 assume a 1:1 PAR. Otherwise, preserve the source PAR. */
841 info->pixel_aspect_width = context->sample_aspect_ratio.num ?
842 context->sample_aspect_ratio.num : 1;
843 info->pixel_aspect_height = context->sample_aspect_ratio.den ?
844 context->sample_aspect_ratio.den : 1;
846 /* ffmpeg returns the Pixel Aspect Ratio (PAR). Handbrake wants the
847 * Display Aspect Ratio so we convert by scaling by the Storage
848 * Aspect Ratio (w/h). We do the calc in floating point to get the
850 info->aspect = (double)info->pixel_aspect_width *
851 (double)context->width /
852 (double)info->pixel_aspect_height /
853 (double)context->height;
855 info->profile = context->profile;
856 info->level = context->level;
857 info->name = context->codec->name;
863 static int decavcodecvBSInfo( hb_work_object_t *w, const hb_buffer_t *buf,
864 hb_work_info_t *info )
869 hb_work_object_t hb_decavcodecv =
872 "Video decoder (libavcodec)",
881 // This is a special decoder for ffmpeg streams. The ffmpeg stream reader
882 // includes a parser and passes information from the parser to the decoder
883 // via a codec context kept in the AVStream of the reader's AVFormatContext.
884 // We *have* to use that codec context to decode the stream or we'll get
885 // garbage. ffmpeg_title_scan put a cookie that can be used to get to that
886 // codec context in our codec_param.
888 // this routine gets the appropriate context pointer from the ffmpeg
889 // stream reader. it can't be called until we get the first buffer because
890 // we can't guarantee that reader will be called before the our init
891 // routine and if our init is called first we'll get a pointer to the
892 // old scan stream (which has already been closed).
893 static void init_ffmpeg_context( hb_work_object_t *w )
895 hb_work_private_t *pv = w->private_data;
896 pv->context = hb_ffmpeg_context( w->codec_param );
898 // during scan the decoder gets closed & reopened which will
899 // close the codec so reopen it if it's not there
900 if ( ! pv->context->codec )
902 AVCodec *codec = avcodec_find_decoder( pv->context->codec_id );
903 avcodec_open( pv->context, codec );
905 // set up our best guess at the frame duration.
906 // the frame rate in the codec is usually bogus but it's sometimes
908 AVStream *st = hb_ffmpeg_avstream( w->codec_param );
910 if ( st->nb_frames && st->duration )
912 // compute the average frame duration from the total number
913 // of frames & the total duration.
914 pv->duration = ( (double)st->duration * (double)st->time_base.num ) /
915 ( (double)st->nb_frames * (double)st->time_base.den );
919 // XXX We don't have a frame count or duration so try to use the
920 // far less reliable time base info in the stream.
921 // Because the time bases are so screwed up, we only take values
922 // in the range 8fps - 64fps.
924 if ( st->time_base.num * 64 > st->time_base.den &&
925 st->time_base.den > st->time_base.num * 8 )
929 else if ( st->r_frame_rate.den * 64 > st->r_frame_rate.num &&
930 st->r_frame_rate.num > st->r_frame_rate.den * 8 )
932 tb.num = st->r_frame_rate.den;
933 tb.den = st->r_frame_rate.num;
937 tb.num = 1001; /*XXX*/
938 tb.den = 24000; /*XXX*/
940 pv->duration = (double)tb.num / (double)tb.den;
942 pv->duration *= 90000.;
944 // we have to wrap ffmpeg's get_buffer to be able to set the pts (?!)
945 pv->context->opaque = pv;
946 pv->context->get_buffer = get_frame_buf;
948 // avi, mkv and possibly mp4 containers can contain the M$ VFW packed
949 // b-frames abortion that messes up frame ordering and timestamps.
950 // XXX ffmpeg knows which streams are broken but doesn't expose the
951 // info externally. We should patch ffmpeg to add a flag to the
952 // codec context for this but until then we mark all ffmpeg streams
954 pv->brokenByMicrosoft = 1;
957 static void prepare_ffmpeg_buffer( hb_buffer_t * in )
959 // ffmpeg requires an extra 8 bytes of zero at the end of the buffer and
960 // will seg fault in odd, data dependent ways if it's not there. (my guess
961 // is this is a case of a local performance optimization creating a global
962 // performance degradation since all the time wasted by extraneous data
963 // copies & memory zeroing has to be huge compared to the minor reduction
964 // in inner-loop instructions this affords - modern cpus bottleneck on
965 // memory bandwidth not instruction bandwidth).
966 if ( in->size + FF_INPUT_BUFFER_PADDING_SIZE > in->alloc )
968 // have to realloc to add the padding
969 hb_buffer_realloc( in, in->size + FF_INPUT_BUFFER_PADDING_SIZE );
971 memset( in->data + in->size, 0, FF_INPUT_BUFFER_PADDING_SIZE );
974 static int decavcodecviInit( hb_work_object_t * w, hb_job_t * job )
977 hb_work_private_t *pv = calloc( 1, sizeof( hb_work_private_t ) );
978 w->private_data = pv;
980 pv->list = hb_list_init();
986 static int decavcodecviWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
987 hb_buffer_t ** buf_out )
989 hb_work_private_t *pv = w->private_data;
992 init_ffmpeg_context( w );
994 hb_buffer_t *in = *buf_in;
997 /* if we got an empty buffer signaling end-of-stream send it downstream */
1000 /* flush any frames left in the decoder */
1001 while ( decodeFrame( pv, NULL, 0 ) )
1004 flushDelayQueue( pv );
1005 hb_list_add( pv->list, in );
1006 *buf_out = link_buf_list( pv );
1007 return HB_WORK_DONE;
1010 int64_t pts = in->start;
1013 // use the first timestamp as our 'next expected' pts
1014 if ( pv->pts_next < 0 )
1023 pv->new_chap = in->new_chap;
1024 pv->chap_time = pts >= 0? pts : pv->pts_next;
1026 prepare_ffmpeg_buffer( in );
1027 decodeFrame( pv, in->data, in->size );
1028 hb_buffer_close( &in );
1029 *buf_out = link_buf_list( pv );
1033 static int decavcodecviInfo( hb_work_object_t *w, hb_work_info_t *info )
1035 if ( decavcodecvInfo( w, info ) )
1037 hb_work_private_t *pv = w->private_data;
1038 if ( ! pv->context )
1040 init_ffmpeg_context( w );
1042 // we have the frame duration in units of the 90KHz pts clock but
1043 // need it in units of the 27MHz MPEG clock. */
1044 info->rate = 27000000;
1045 info->rate_base = pv->duration * 300.;
1051 static void decodeAudio( hb_work_private_t *pv, uint8_t *data, int size )
1053 AVCodecContext *context = pv->context;
1056 while ( pos < size )
1058 int16_t *buffer = pv->buffer;
1059 if ( buffer == NULL )
1061 // XXX ffmpeg bug workaround
1062 // malloc a buffer for the audio decode. On an x86, ffmpeg
1063 // uses mmx/sse instructions on this buffer without checking
1064 // that it's 16 byte aligned and this will cause an abort if
1065 // the buffer is allocated on our stack. Rather than doing
1066 // complicated, machine dependent alignment here we use the
1067 // fact that malloc returns an aligned pointer on most architectures.
1070 // Cygwin's malloc doesn't appear to return 16-byte aligned memory so use memalign instead.
1071 pv->buffer = memalign(16, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1073 pv->buffer = malloc( AVCODEC_MAX_AUDIO_FRAME_SIZE );
1076 buffer = pv->buffer;
1078 int out_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
1079 int len = avcodec_decode_audio2( context, buffer, &out_size,
1080 data + pos, size - pos );
1088 hb_buffer_t *buf = hb_buffer_init( 2 * out_size );
1090 // convert from bytes to total samples
1093 double pts = pv->pts_next;
1095 pts += out_size * pv->duration;
1099 float *fl32 = (float *)buf->data;
1101 for( i = 0; i < out_size; ++i )
1103 fl32[i] = buffer[i];
1105 hb_list_add( pv->list, buf );
1110 static int decavcodecaiWork( hb_work_object_t *w, hb_buffer_t **buf_in,
1111 hb_buffer_t **buf_out )
1113 if ( (*buf_in)->size <= 0 )
1115 /* EOF on input stream - send it downstream & say that we're done */
1118 return HB_WORK_DONE;
1121 hb_work_private_t *pv = w->private_data;
1122 if ( ! pv->context )
1124 init_ffmpeg_context( w );
1125 // duration is a scaling factor to go from #bytes in the decoded
1126 // frame to frame time (in 90KHz mpeg ticks). 'channels' converts
1127 // total samples to per-channel samples. 'sample_rate' converts
1128 // per-channel samples to seconds per sample and the 90000
1129 // is mpeg ticks per second.
1130 pv->duration = 90000. /
1131 (double)( pv->context->sample_rate * pv->context->channels );
1133 hb_buffer_t *in = *buf_in;
1135 // if the packet has a timestamp use it if we don't have a timestamp yet
1136 // or if there's been a timing discontinuity of more than 100ms.
1137 if ( in->start >= 0 &&
1138 ( pv->pts_next < 0 || ( in->start - pv->pts_next ) > 90*100 ) )
1140 pv->pts_next = in->start;
1142 prepare_ffmpeg_buffer( in );
1143 decodeAudio( pv, in->data, in->size );
1144 *buf_out = link_buf_list( pv );
1149 hb_work_object_t hb_decavcodecvi =
1152 "Video decoder (ffmpeg streams)",
1160 hb_work_object_t hb_decavcodecai =
1163 "Audio decoder (ffmpeg streams)",