X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fdecavcodec.c;h=09f15ecd839360f2cfc721bf440dfa815e63e413;hb=d7389faafa327bb1be3340c34c30f353a8f52960;hp=12c9802bb59d0492041f320101e5e310d976900c;hpb=d384725dbf227fe6222547f87dc9afca0afac7e4;p=handbrake-jp%2Fhandbrake-jp-git.git

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