@@ -1077,6 +1077,8 @@ HAVE_LIST="

     isatty

     kbhit

     ldbrx

+    libdc1394_1

+    libdc1394_2

     llrint

     llrintf

     local_aligned_16

@@ -2914,7 +2916,6 @@ check_mathfunc truncf

 enabled avisynth   && require2 vfw32 "windows.h vfw.h" AVIFileInit -lavifil32

 enabled libcelt    && require libcelt celt/celt.h celt_decode -lcelt0

 enabled frei0r     && { check_header frei0r.h || die "ERROR: frei0r.h header not found"; }

-enabled libdc1394  && require_pkg_config libdc1394-2 dc1394/dc1394.h dc1394_new

 enabled libdirac   && require_pkg_config dirac                          \

     "libdirac_decoder/dirac_parser.h libdirac_encoder/dirac_encoder.h"  \

     "dirac_decoder_init dirac_encoder_init"

@@ -2946,6 +2947,15 @@ enabled libxavs    && require  libxavs xavs.h xavs_encoder_encode -lxavs

 enabled libxvid    && require  libxvid xvid.h xvid_global -lxvidcore

 enabled mlib       && require  mediaLib mlib_types.h mlib_VectorSub_S16_U8_Mod -lmlib

+# libdc1394 check

+if enabled libdc1394; then

+    { check_lib dc1394/dc1394.h dc1394_new -ldc1394 -lraw1394 &&

+        enable libdc1394_2; } ||

+    { check_lib libdc1394/dc1394_control.h dc1394_create_handle -ldc1394_control -lraw1394 &&

+        enable libdc1394_1; } ||

+    die "ERROR: No version of libdc1394 found "

+fi

+

 SDL_CONFIG="${cross_prefix}sdl-config"

 if check_pkg_config sdl SDL_version.h SDL_Linked_Version; then

     check_cpp_condition SDL.h "(SDL_MAJOR_VERSION<<16 | SDL_MINOR_VERSION<<8 | SDL_PATCHLEVEL) >= 0x010201" $sdl_cflags &&

@@ -1242,7 +1242,7 @@ static void do_video_out(AVFormatContext *s,

             }

         }

         sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,

-                  0, ost->resample_height, ost->resample_frame.data, ost->resample_frame.linesize);

+              0, ost->resample_height, final_picture->data, final_picture->linesize);

     }

 #endif

@@ -3723,7 +3723,6 @@ static void new_audio_stream(AVFormatContext *oc, int file_idx)

 static void new_data_stream(AVFormatContext *oc, int file_idx)

 {

     AVStream *st;

-    AVOutputStream *ost av_unused;

     AVCodec *codec=NULL;

     AVCodecContext *data_enc;

@@ -3732,7 +3731,7 @@ static void new_data_stream(AVFormatContext *oc, int file_idx)

         fprintf(stderr, "Could not alloc stream\n");

         ffmpeg_exit(1);

     }

-    ost = new_output_stream(oc, file_idx);

+    new_output_stream(oc, file_idx);

     data_enc = st->codec;

     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);

     if (!data_stream_copy) {

@@ -1760,7 +1760,7 @@ static int http_parse_request(HTTPContext *c)

                 }

             }

-#ifdef DEBUG_WMP

+#ifdef DEBUG

             http_log("\nGot request:\n%s\n", c->buffer);

 #endif

@@ -1790,7 +1790,7 @@ static int http_parse_request(HTTPContext *c)

         return 0;

     }

-#ifdef DEBUG_WMP

+#ifdef DEBUG

     if (strcmp(stream->filename + strlen(stream->filename) - 4, ".asf") == 0)

         http_log("\nGot request:\n%s\n", c->buffer);

 #endif

@@ -312,7 +312,7 @@ static void encode_window_bands_info(AACEncContext *s, SingleChannelElement *sce

                                      int win, int group_len, const float lambda)

 {

     BandCodingPath path[120][12];

-    int w, swb, cb, start, start2, size;

+    int w, swb, cb, start, size;

     int i, j;

     const int max_sfb  = sce->ics.max_sfb;

     const int run_bits = sce->ics.num_windows == 1 ? 5 : 3;

@@ -330,7 +330,6 @@ static void encode_window_bands_info(AACEncContext *s, SingleChannelElement *sce

         path[0][cb].run      = 0;

     }

     for (swb = 0; swb < max_sfb; swb++) {

-        start2 = start;

         size = sce->ics.swb_sizes[swb];

         if (sce->zeroes[win*16 + swb]) {

             for (cb = 0; cb < 12; cb++) {

@@ -414,7 +413,7 @@ static void codebook_trellis_rate(AACEncContext *s, SingleChannelElement *sce,

                                   int win, int group_len, const float lambda)

 {

     BandCodingPath path[120][12];

-    int w, swb, cb, start, start2, size;

+    int w, swb, cb, start, size;

     int i, j;

     const int max_sfb  = sce->ics.max_sfb;

     const int run_bits = sce->ics.num_windows == 1 ? 5 : 3;

@@ -432,7 +431,6 @@ static void codebook_trellis_rate(AACEncContext *s, SingleChannelElement *sce,

         path[0][cb].run      = 0;

     }

     for (swb = 0; swb < max_sfb; swb++) {

-        start2 = start;

         size = sce->ics.swb_sizes[swb];

         if (sce->zeroes[win*16 + swb]) {

             for (cb = 0; cb < 12; cb++) {

@@ -1007,12 +1005,11 @@ static void search_for_quantizers_fast(AVCodecContext *avctx, AACEncContext *s,

                                        SingleChannelElement *sce,

                                        const float lambda)

 {

-    int start = 0, i, w, w2, g;

+    int i, w, w2, g;

     int minq = 255;

     memset(sce->sf_idx, 0, sizeof(sce->sf_idx));

     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

-        start = w*128;

         for (g = 0; g < sce->ics.num_swb; g++) {

             for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {

                 FFPsyBand *band = &s->psy.psy_bands[s->cur_channel*PSY_MAX_BANDS+(w+w2)*16+g];

@@ -30,6 +30,7 @@

  * add temporal noise shaping

  ***********************************/

+#include "libavutil/opt.h"

 #include "avcodec.h"

 #include "put_bits.h"

 #include "dsputil.h"

@@ -489,7 +490,7 @@ static int aac_encode_frame(AVCodecContext *avctx,

     AACEncContext *s = avctx->priv_data;

     int16_t *samples = s->samples, *samples2, *la;

     ChannelElement *cpe;

-    int i, ch, w, chans, tag, start_ch;

+    int i, ch, w, g, chans, tag, start_ch;

     const uint8_t *chan_map = aac_chan_configs[avctx->channels-1];

     int chan_el_counter[4];

     FFPsyWindowInfo windows[AAC_MAX_CHANNELS];

@@ -587,8 +588,16 @@ static int aac_encode_frame(AVCodecContext *avctx,

                 }

             }

             s->cur_channel = start_ch;

-            if (cpe->common_window && s->coder->search_for_ms)

-                s->coder->search_for_ms(s, cpe, s->lambda);

+            if (s->options.stereo_mode && cpe->common_window) {

+                if (s->options.stereo_mode > 0) {

+                    IndividualChannelStream *ics = &cpe->ch[0].ics;

+                    for (w = 0; w < ics->num_windows; w += ics->group_len[w])

+                        for (g = 0;  g < ics->num_swb; g++)

+                            cpe->ms_mask[w*16+g] = 1;

+                } else if (s->coder->search_for_ms) {

+                    s->coder->search_for_ms(s, cpe, s->lambda);

+                }

+            }

             adjust_frame_information(s, cpe, chans);

             if (chans == 2) {

                 put_bits(&s->pb, 1, cpe->common_window);

@@ -645,6 +654,22 @@ static av_cold int aac_encode_end(AVCodecContext *avctx)

     return 0;

 }

+#define AACENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM

+static const AVOption aacenc_options[] = {

+    {"stereo_mode", "Stereo coding method", offsetof(AACEncContext, options.stereo_mode), FF_OPT_TYPE_INT, {.dbl = 0}, -1, 1, AACENC_FLAGS, "stereo_mode"},

+        {"auto",     "Selected by the Encoder", 0, FF_OPT_TYPE_CONST, {.dbl = -1 }, INT_MIN, INT_MAX, AACENC_FLAGS, "stereo_mode"},

+        {"ms_off",   "Disable Mid/Side coding", 0, FF_OPT_TYPE_CONST, {.dbl =  0 }, INT_MIN, INT_MAX, AACENC_FLAGS, "stereo_mode"},

+        {"ms_force", "Force Mid/Side for the whole frame if possible", 0, FF_OPT_TYPE_CONST, {.dbl =  1 }, INT_MIN, INT_MAX, AACENC_FLAGS, "stereo_mode"},

+    {NULL}

+};

+

+static const AVClass aacenc_class = {

+    "AAC encoder",

+    av_default_item_name,

+    aacenc_options,

+    LIBAVUTIL_VERSION_INT,

+};

+

 AVCodec ff_aac_encoder = {

     "aac",

     AVMEDIA_TYPE_AUDIO,

@@ -656,4 +681,5 @@ AVCodec ff_aac_encoder = {

     .capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY | CODEC_CAP_EXPERIMENTAL,

     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},

     .long_name = NULL_IF_CONFIG_SMALL("Advanced Audio Coding"),

+    .priv_class = &aacenc_class,

 };

@@ -30,6 +30,10 @@

 #include "psymodel.h"

+typedef struct AACEncOptions {

+    int stereo_mode;

+} AACEncOptions;

+

 struct AACEncContext;

 typedef struct AACCoefficientsEncoder {

@@ -48,6 +52,8 @@ extern AACCoefficientsEncoder ff_aac_coders[];

  * AAC encoder context

  */

 typedef struct AACEncContext {

+    AVClass *av_class;

+    AACEncOptions options;                       ///< encoding options

     PutBitContext pb;

     FFTContext mdct1024;                         ///< long (1024 samples) frame transform context

     FFTContext mdct128;                          ///< short (128 samples) frame transform context

@@ -66,7 +66,6 @@

 #define SUBBAND_SIZE    20

 #define MAX_SUBPACKETS   5

-//#define COOKDEBUG

 typedef struct {

     int *now;

@@ -166,38 +165,6 @@ typedef struct cook {

 static float     pow2tab[127];

 static float rootpow2tab[127];

-/* debug functions */

-

-#ifdef COOKDEBUG

-static void dump_float_table(float* table, int size, int delimiter) {

-    int i=0;

-    av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);

-    for (i=0 ; i<size ; i++) {

-        av_log(NULL, AV_LOG_ERROR, "%5.1f, ", table[i]);

-        if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);

-    }

-}

-

-static void dump_int_table(int* table, int size, int delimiter) {

-    int i=0;

-    av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);

-    for (i=0 ; i<size ; i++) {

-        av_log(NULL, AV_LOG_ERROR, "%d, ", table[i]);

-        if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);

-    }

-}

-

-static void dump_short_table(short* table, int size, int delimiter) {

-    int i=0;

-    av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);

-    for (i=0 ; i<size ; i++) {

-        av_log(NULL, AV_LOG_ERROR, "%d, ", table[i]);

-        if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);

-    }

-}

-

-#endif

-

 /*************** init functions ***************/

 /* table generator */

@@ -1037,7 +1004,7 @@ static int cook_decode_frame(AVCodecContext *avctx,

     return avctx->block_align;

 }

-#ifdef COOKDEBUG

+#ifdef DEBUG

 static void dump_cook_context(COOKContext *q)

 {

     //int i=0;

@@ -1055,7 +1022,6 @@ static void dump_cook_context(COOKContext *q)

     PRINT("samples_per_channel",q->subpacket[0].samples_per_channel);

     PRINT("samples_per_frame",q->subpacket[0].samples_per_frame);

     PRINT("subbands",q->subpacket[0].subbands);

-    PRINT("random_state",q->random_state);

     PRINT("js_subband_start",q->subpacket[0].js_subband_start);

     PRINT("log2_numvector_size",q->subpacket[0].log2_numvector_size);

     PRINT("numvector_size",q->subpacket[0].numvector_size);

@@ -1280,7 +1246,7 @@ static av_cold int cook_decode_init(AVCodecContext *avctx)

     else

         avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;

-#ifdef COOKDEBUG

+#ifdef DEBUG

     dump_cook_context(q);

 #endif

     return 0;

@@ -1535,8 +1535,6 @@ static void dca_exss_parse_header(DCAContext *s)

 {

     int ss_index;

     int blownup;

-    int header_size av_unused;

-    int hd_size av_unused;

     int num_audiop = 1;

     int num_assets = 1;

     int active_ss_mask[8];

@@ -1549,8 +1547,8 @@ static void dca_exss_parse_header(DCAContext *s)

     ss_index = get_bits(&s->gb, 2);

     blownup = get_bits1(&s->gb);

-    header_size = get_bits(&s->gb, 8 + 4 * blownup) + 1;

-    hd_size = get_bits_long(&s->gb, 16 + 4 * blownup) + 1;

+    skip_bits(&s->gb, 8 + 4 * blownup); // header_size

+    skip_bits(&s->gb, 16 + 4 * blownup); // hd_size

     s->static_fields = get_bits1(&s->gb);

     if (s->static_fields) {

@@ -245,11 +245,11 @@ static int parse_source_parameters(AVCodecContext *avctx, GetBitContext *gb,

 int ff_dirac_parse_sequence_header(AVCodecContext *avctx, GetBitContext *gb,

                                    dirac_source_params *source)

 {

-    unsigned version_major, version_minor av_unused;

+    unsigned version_major;

     unsigned video_format, picture_coding_mode;

     version_major  = svq3_get_ue_golomb(gb);

-    version_minor  = svq3_get_ue_golomb(gb);

+    svq3_get_ue_golomb(gb); /* version_minor */

     avctx->profile = svq3_get_ue_golomb(gb);

     avctx->level   = svq3_get_ue_golomb(gb);

     video_format   = svq3_get_ue_golomb(gb);

@@ -32,6 +32,7 @@

 #include "mpegvideo.h"

 #include "h264.h"

 #include "rectangle.h"

+#include "thread.h"

 /*

  * H264 redefines mb_intra so it is not mistakely used (its uninitialized in h264)

@@ -436,8 +437,7 @@ int score_sum=0;

                     int best_score=256*256*256*64;

                     int best_pred=0;

                     const int mot_index= (mb_x + mb_y*mot_stride) * mot_step;

-                    int prev_x= s->current_picture.motion_val[0][mot_index][0];

-                    int prev_y= s->current_picture.motion_val[0][mot_index][1];

+                    int prev_x, prev_y, prev_ref;

                     if((mb_x^mb_y^pass)&1) continue;

@@ -535,10 +535,26 @@ skip_mean_and_median:

                     /* zero MV */

                     pred_count++;

+                    if (!fixed[mb_xy] && 0) {

+                        if (s->avctx->codec_id == CODEC_ID_H264) {

+                            // FIXME

+                        } else {

+                            ff_thread_await_progress((AVFrame *) s->last_picture_ptr,

+                                                     mb_y, 0);

+                        }

+                        prev_x = s->last_picture.motion_val[0][mot_index][0];

+                        prev_y = s->last_picture.motion_val[0][mot_index][1];

+                        prev_ref = s->last_picture.ref_index[0][4*mb_xy];

+                    } else {

+                        prev_x = s->current_picture.motion_val[0][mot_index][0];

+                        prev_y = s->current_picture.motion_val[0][mot_index][1];

+                        prev_ref = s->current_picture.ref_index[0][4*mb_xy];

+                    }

+

                     /* last MV */

-                    mv_predictor[pred_count][0]= s->current_picture.motion_val[0][mot_index][0];

-                    mv_predictor[pred_count][1]= s->current_picture.motion_val[0][mot_index][1];

-                    ref         [pred_count]   = s->current_picture.ref_index[0][4*mb_xy];

+                    mv_predictor[pred_count][0]= prev_x;

+                    mv_predictor[pred_count][1]= prev_y;

+                    ref         [pred_count]   = prev_ref;

                     pred_count++;

                     s->mv_dir = MV_DIR_FORWARD;

@@ -670,6 +686,12 @@ static int is_intra_more_likely(MpegEncContext *s){

                 uint8_t *mb_ptr     = s->current_picture.data[0] + mb_x*16 + mb_y*16*s->linesize;

                 uint8_t *last_mb_ptr= s->last_picture.data   [0] + mb_x*16 + mb_y*16*s->linesize;

+                if (s->avctx->codec_id == CODEC_ID_H264) {

+                    // FIXME

+                } else {

+                    ff_thread_await_progress((AVFrame *) s->last_picture_ptr,

+                                             mb_y, 0);

+                }

                 is_intra_likely += s->dsp.sad[0](NULL, last_mb_ptr, mb_ptr                    , s->linesize, 16);

                 // FIXME need await_progress() here

                 is_intra_likely -= s->dsp.sad[0](NULL, last_mb_ptr, last_mb_ptr+s->linesize*16, s->linesize, 16);

@@ -690,6 +712,7 @@ void ff_er_frame_start(MpegEncContext *s){

     memset(s->error_status_table, MV_ERROR|AC_ERROR|DC_ERROR|VP_START|AC_END|DC_END|MV_END, s->mb_stride*s->mb_height*sizeof(uint8_t));

     s->error_count= 3*s->mb_num;

+    s->error_occurred = 0;

 }

 /**

@@ -729,7 +752,10 @@ void ff_er_add_slice(MpegEncContext *s, int startx, int starty, int endx, int en

         s->error_count -= end_i - start_i + 1;

     }

-    if(status & (AC_ERROR|DC_ERROR|MV_ERROR)) s->error_count= INT_MAX;

+    if(status & (AC_ERROR|DC_ERROR|MV_ERROR)) {

+        s->error_occurred = 1;

+        s->error_count= INT_MAX;

+    }

     if(mask == ~0x7F){

         memset(&s->error_status_table[start_xy], 0, (end_xy - start_xy) * sizeof(uint8_t));

@@ -1009,7 +1035,12 @@ void ff_er_frame_end(MpegEncContext *s){

                     int time_pp= s->pp_time;

                     int time_pb= s->pb_time;

-                    // FIXME await_progress here

+                    if (s->avctx->codec_id == CODEC_ID_H264) {

+                        //FIXME

+                    } else {

+                        ff_thread_await_progress((AVFrame *) s->next_picture_ptr,

+                                                 mb_y, 0);

+                    }

                     s->mv[0][0][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp;

                     s->mv[0][0][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp;

                     s->mv[1][0][0] = s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;

@@ -656,8 +656,11 @@ retry:

             if(s->slice_height==0 || s->mb_x!=0 || (s->mb_y%s->slice_height)!=0 || get_bits_count(&s->gb) > s->gb.size_in_bits)

                 break;

         }else{

+            int prev_x=s->mb_x, prev_y=s->mb_y;

             if(ff_h263_resync(s)<0)

                 break;

+            if (prev_y * s->mb_width + prev_x < s->mb_y * s->mb_width + s->mb_x)

+                s->error_occurred = 1;

         }

         if(s->msmpeg4_version<4 && s->h263_pred)

@@ -246,6 +246,141 @@ static int ff_h264_decode_rbsp_trailing(H264Context *h, const uint8_t *src){

     return 0;

 }

+static inline int get_lowest_part_list_y(H264Context *h, Picture *pic, int n, int height,

+                                 int y_offset, int list){

+    int raw_my= h->mv_cache[list][ scan8[n] ][1];

+    int filter_height= (raw_my&3) ? 2 : 0;

+    int full_my= (raw_my>>2) + y_offset;

+    int top = full_my - filter_height, bottom = full_my + height + filter_height;

+

+    return FFMAX(abs(top), bottom);

+}

+

+static inline void get_lowest_part_y(H264Context *h, int refs[2][48], int n, int height,

+                               int y_offset, int list0, int list1, int *nrefs){

+    MpegEncContext * const s = &h->s;

+    int my;

+

+    y_offset += 16*(s->mb_y >> MB_FIELD);

+

+    if(list0){

+        int ref_n = h->ref_cache[0][ scan8[n] ];

+        Picture *ref= &h->ref_list[0][ref_n];

+

+        // Error resilience puts the current picture in the ref list.

+        // Don't try to wait on these as it will cause a deadlock.

+        // Fields can wait on each other, though.

+        if(ref->thread_opaque != s->current_picture.thread_opaque ||

+           (ref->reference&3) != s->picture_structure) {

+            my = get_lowest_part_list_y(h, ref, n, height, y_offset, 0);

+            if (refs[0][ref_n] < 0) nrefs[0] += 1;

+            refs[0][ref_n] = FFMAX(refs[0][ref_n], my);

+        }

+    }

+

+    if(list1){

+        int ref_n = h->ref_cache[1][ scan8[n] ];

+        Picture *ref= &h->ref_list[1][ref_n];

+

+        if(ref->thread_opaque != s->current_picture.thread_opaque ||

+           (ref->reference&3) != s->picture_structure) {

+            my = get_lowest_part_list_y(h, ref, n, height, y_offset, 1);

+            if (refs[1][ref_n] < 0) nrefs[1] += 1;

+            refs[1][ref_n] = FFMAX(refs[1][ref_n], my);

+        }

+    }

+}

+

+/**

+ * Wait until all reference frames are available for MC operations.

+ *

+ * @param h the H264 context

+ */

+static void await_references(H264Context *h){

+    MpegEncContext * const s = &h->s;

+    const int mb_xy= h->mb_xy;

+    const int mb_type= s->current_picture.mb_type[mb_xy];

+    int refs[2][48];

+    int nrefs[2] = {0};

+    int ref, list;

+

+    memset(refs, -1, sizeof(refs));

+

+    if(IS_16X16(mb_type)){

+        get_lowest_part_y(h, refs, 0, 16, 0,

+                  IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);

+    }else if(IS_16X8(mb_type)){

+        get_lowest_part_y(h, refs, 0, 8, 0,

+                  IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);

+        get_lowest_part_y(h, refs, 8, 8, 8,

+                  IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1), nrefs);

+    }else if(IS_8X16(mb_type)){

+        get_lowest_part_y(h, refs, 0, 16, 0,

+                  IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);

+        get_lowest_part_y(h, refs, 4, 16, 0,

+                  IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1), nrefs);

+    }else{

+        int i;

+

+        assert(IS_8X8(mb_type));

+

+        for(i=0; i<4; i++){

+            const int sub_mb_type= h->sub_mb_type[i];

+            const int n= 4*i;

+            int y_offset= (i&2)<<2;

+

+            if(IS_SUB_8X8(sub_mb_type)){

+                get_lowest_part_y(h, refs, n  , 8, y_offset,

+                          IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);

+            }else if(IS_SUB_8X4(sub_mb_type)){

+                get_lowest_part_y(h, refs, n  , 4, y_offset,

+                          IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);

+                get_lowest_part_y(h, refs, n+2, 4, y_offset+4,

+                          IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);

+            }else if(IS_SUB_4X8(sub_mb_type)){

+                get_lowest_part_y(h, refs, n  , 8, y_offset,

+                          IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);

+                get_lowest_part_y(h, refs, n+1, 8, y_offset,

+                          IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);

+            }else{

+                int j;

+                assert(IS_SUB_4X4(sub_mb_type));

+                for(j=0; j<4; j++){

+                    int sub_y_offset= y_offset + 2*(j&2);

+                    get_lowest_part_y(h, refs, n+j, 4, sub_y_offset,

+                              IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);

+                }

+            }

+        }

+    }

+

+    for(list=h->list_count-1; list>=0; list--){

+        for(ref=0; ref<48 && nrefs[list]; ref++){

+            int row = refs[list][ref];

+            if(row >= 0){

+                Picture *ref_pic = &h->ref_list[list][ref];

+                int ref_field = ref_pic->reference - 1;

+                int ref_field_picture = ref_pic->field_picture;

+                int pic_height = 16*s->mb_height >> ref_field_picture;

+

+                row <<= MB_MBAFF;

+                nrefs[list]--;

+

+                if(!FIELD_PICTURE && ref_field_picture){ // frame referencing two fields

+                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN((row >> 1) - !(row&1), pic_height-1), 1);

+                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN((row >> 1)           , pic_height-1), 0);

+                }else if(FIELD_PICTURE && !ref_field_picture){ // field referencing one field of a frame

+                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row*2 + ref_field    , pic_height-1), 0);

+                }else if(FIELD_PICTURE){

+                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row, pic_height-1), ref_field);

+                }else{

+                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row, pic_height-1), 0);

+                }

+            }

+        }

+    }

+}

+

 #if 0

 /**

  * DCT transforms the 16 dc values.

@@ -315,6 +450,7 @@ static void chroma_dc_dct_c(DCTELEM *block){

 static void free_tables(H264Context *h, int free_rbsp){

     int i;

     H264Context *hx;

+

     av_freep(&h->intra4x4_pred_mode);

     av_freep(&h->chroma_pred_mode_table);

     av_freep(&h->cbp_table);

@@ -611,6 +747,7 @@ av_cold int ff_h264_decode_init(AVCodecContext *avctx){

     return 0;

 }

+

 #define IN_RANGE(a, b, size) (((a) >= (b)) && ((a) < ((b)+(size))))

 static void copy_picture_range(Picture **to, Picture **from, int count, MpegEncContext *new_base, MpegEncContext *old_base)

 {

@@ -711,7 +848,8 @@ static int decode_update_thread_context(AVCodecContext *dst, const AVCodecContex

     copy_fields(h, h1, poc_lsb, redundant_pic_count);

     //reference lists

-    copy_fields(h, h1, ref_count, intra_gb);

+    copy_fields(h, h1, ref_count, list_count);

+    copy_fields(h, h1, ref_list,  intra_gb);

     copy_fields(h, h1, short_ref, cabac_init_idc);

     copy_picture_range(h->short_ref,   h1->short_ref,   32, s, s1);

@@ -738,6 +876,7 @@ int ff_h264_frame_start(H264Context *h){

     MpegEncContext * const s = &h->s;

     int i;

     const int pixel_shift = h->pixel_shift;

+    int thread_count = (s->avctx->active_thread_type & FF_THREAD_SLICE) ? s->avctx->thread_count : 1;

     if(MPV_frame_start(s, s->avctx) < 0)

         return -1;

@@ -766,7 +905,7 @@ int ff_h264_frame_start(H264Context *h){

     /* can't be in alloc_tables because linesize isn't known there.

      * FIXME: redo bipred weight to not require extra buffer? */

-    for(i = 0; i < s->avctx->thread_count; i++)

+    for(i = 0; i < thread_count; i++)

         if(h->thread_context[i] && !h->thread_context[i]->s.obmc_scratchpad)

             h->thread_context[i]->s.obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize);

@@ -2910,12 +3049,6 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){

     int nal_index;

     h->max_contexts = (HAVE_THREADS && (s->avctx->active_thread_type&FF_THREAD_SLICE)) ? avctx->thread_count : 1;

-#if 0

-    int i;

-    for(i=0; i<50; i++){

-        av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]);

-    }

-#endif

     if(!(s->flags2 & CODEC_FLAG2_CHUNKS)){

         h->current_slice = 0;

         if (!s->first_field)

@@ -3491,8 +3624,7 @@ AVCodec ff_h264_decoder = {

     ff_h264_decode_end,

     decode_frame,

     /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_DELAY |

-        CODEC_CAP_FRAME_THREADS |

-        CODEC_CAP_SLICE_THREADS,

+        CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,

     .flush= flush_dpb,

     .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),

     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),

@@ -629,7 +629,7 @@ static int decode_band(IVI5DecContext *ctx, int plane_num,

         FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);

     }

-#if IVI_DEBUG

+#ifdef DEBUG

     if (band->checksum_present) {

         uint16_t chksum = ivi_calc_band_checksum(band);

         if (chksum != band->checksum) {

@@ -46,14 +46,6 @@

 #define PALETTE_COUNT 256

-/* debugging support */

-#define DEBUG_INTERPLAY 0

-#if DEBUG_INTERPLAY

-#define debug_interplay(x,...) av_log(NULL, AV_LOG_DEBUG, x, __VA_ARGS__)

-#else

-static inline void debug_interplay(const char *format, ...) { }

-#endif

-

 typedef struct IpvideoContext {

     AVCodecContext *avctx;

@@ -141,7 +133,7 @@ static int ipvideo_decode_block_opcode_0x2(IpvideoContext *s)

         y =   8 + ((B - 56) / 29);

     }

-    debug_interplay ("    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);

+    av_dlog(NULL, "    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);

     return copy_from(s, &s->second_last_frame, x, y);

 }

@@ -169,7 +161,7 @@ static int ipvideo_decode_block_opcode_0x3(IpvideoContext *s)

         y = -(  8 + ((B - 56) / 29));

     }

-    debug_interplay ("    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);

+    av_dlog(NULL, "    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);

     return copy_from(s, &s->current_frame, x, y);

 }

@@ -192,7 +184,7 @@ static int ipvideo_decode_block_opcode_0x4(IpvideoContext *s)

     x = -8 + BL;

     y = -8 + BH;

-    debug_interplay ("    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);

+    av_dlog(NULL, "    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);

     return copy_from(s, &s->last_frame, x, y);

 }

@@ -207,7 +199,7 @@ static int ipvideo_decode_block_opcode_0x5(IpvideoContext *s)

     x = *s->stream_ptr++;

     y = *s->stream_ptr++;

-    debug_interplay ("    motion bytes = %d, %d\n", x, y);

+    av_dlog(NULL, "    motion bytes = %d, %d\n", x, y);

     return copy_from(s, &s->last_frame, x, y);

 }

@@ -588,7 +580,7 @@ static int ipvideo_decode_block_opcode_0x6_16(IpvideoContext *s)

     x = *s->stream_ptr++;

     y = *s->stream_ptr++;

-    debug_interplay ("    motion bytes = %d, %d\n", x, y);

+    av_dlog(NULL, "    motion bytes = %d, %d\n", x, y);

     return copy_from(s, &s->second_last_frame, x, y);

 }

@@ -965,7 +957,7 @@ static void ipvideo_decode_opcodes(IpvideoContext *s)

     static int frame = 0;

     GetBitContext gb;

-    debug_interplay("------------------ frame %d\n", frame);

+    av_dlog(NULL, "------------------ frame %d\n", frame);

     frame++;

     if (!s->is_16bpp) {

@@ -991,8 +983,8 @@ static void ipvideo_decode_opcodes(IpvideoContext *s)

         for (x = 0; x < s->avctx->width; x += 8) {

             opcode = get_bits(&gb, 4);

-            debug_interplay("  block @ (%3d, %3d): encoding 0x%X, data ptr @ %p\n",

-                            x, y, opcode, s->stream_ptr);

+            av_dlog(NULL, "  block @ (%3d, %3d): encoding 0x%X, data ptr @ %p\n",

+                    x, y, opcode, s->stream_ptr);

             if (!s->is_16bpp) {

                 s->pixel_ptr = s->current_frame.data[0] + x

@@ -152,7 +152,7 @@ int ff_h263_decode_mba(MpegEncContext *s)

  */

 static int h263_decode_gob_header(MpegEncContext *s)

 {

-    unsigned int val, gfid, gob_number;

+    unsigned int val, gob_number;

     int left;

     /* Check for GOB Start Code */

@@ -183,12 +183,12 @@ static int h263_decode_gob_header(MpegEncContext *s)

         s->qscale = get_bits(&s->gb, 5); /* SQUANT */

         if(get_bits1(&s->gb)==0)

             return -1;

-        gfid = get_bits(&s->gb, 2); /* GFID */

+        skip_bits(&s->gb, 2); /* GFID */

     }else{

         gob_number = get_bits(&s->gb, 5); /* GN */

         s->mb_x= 0;

         s->mb_y= s->gob_index* gob_number;

-        gfid = get_bits(&s->gb, 2); /* GFID */

+        skip_bits(&s->gb, 2); /* GFID */

         s->qscale = get_bits(&s->gb, 5); /* GQUANT */

     }

@@ -418,8 +418,8 @@ int ff_ivi_decode_blocks(GetBitContext *gb, IVIBandDesc *band, IVITile *tile)

                         break;

                     pos = band->scan[scan_pos];

-                    if (IVI_DEBUG && !val)

-                        av_log(NULL, AV_LOG_ERROR, "Val = 0 encountered!\n");

+                    if (!val)

+                        av_dlog(NULL, "Val = 0 encountered!\n");

                     q = (base_tab[pos] * quant) >> 9;

                     if (q > 1)

@@ -563,7 +563,7 @@ void ff_ivi_process_empty_tile(AVCodecContext *avctx, IVIBandDesc *band,

 }

-#if IVI_DEBUG

+#ifdef DEBUG

 uint16_t ivi_calc_band_checksum (IVIBandDesc *band)

 {

     int         x, y;

@@ -33,8 +33,6 @@

 #include "get_bits.h"

 #include <stdint.h>

-#define IVI_DEBUG 0

-

 #define IVI_VLC_BITS 13 ///< max number of bits of the ivi's huffman codes

 /**

@@ -340,7 +338,6 @@ void ff_ivi_process_empty_tile(AVCodecContext *avctx, IVIBandDesc *band,

  */

 void ff_ivi_output_plane(IVIPlaneDesc *plane, uint8_t *dst, int dst_pitch);

-#if IVI_DEBUG

 /**

  *  Calculate band checksum from band data.

  */

@@ -350,6 +347,5 @@ uint16_t ivi_calc_band_checksum (IVIBandDesc *band);

  *  Verify that band data lies in range.

  */

 int ivi_check_band (IVIBandDesc *band, const uint8_t *ref, int pitch);

-#endif

 #endif /* AVCODEC_IVI_COMMON_H */

@@ -1670,7 +1670,7 @@ static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)

         *s->current_picture_ptr->pan_scan= s1->pan_scan;

-        if (HAVE_PTHREADS && avctx->active_thread_type&FF_THREAD_FRAME)

+        if (HAVE_PTHREADS && (avctx->active_thread_type & FF_THREAD_FRAME))

             ff_thread_finish_setup(avctx);

     }else{ //second field

             int i;

@@ -2004,7 +2004,7 @@ static int slice_end(AVCodecContext *avctx, AVFrame *pict)

             *pict= *(AVFrame*)s->current_picture_ptr;

             ff_print_debug_info(s, pict);

         } else {

-            if (avctx->active_thread_type&FF_THREAD_FRAME)

+            if (avctx->active_thread_type & FF_THREAD_FRAME)

                 s->picture_number++;

             /* latency of 1 frame for I- and P-frames */

             /* XXX: use another variable than picture_number */

@@ -2179,14 +2179,13 @@ static void mpeg_decode_gop(AVCodecContext *avctx,

     Mpeg1Context *s1 = avctx->priv_data;

     MpegEncContext *s = &s1->mpeg_enc_ctx;

-    int drop_frame_flag;

     int time_code_hours, time_code_minutes;

     int time_code_seconds, time_code_pictures;

     int broken_link;

     init_get_bits(&s->gb, buf, buf_size*8);

-    drop_frame_flag = get_bits1(&s->gb);

+    skip_bits1(&s->gb); /* drop_frame_flag */

     time_code_hours=get_bits(&s->gb,5);

     time_code_minutes = get_bits(&s->gb,6);

@@ -2340,7 +2339,7 @@ static int decode_chunks(AVCodecContext *avctx,

         buf_ptr = ff_find_start_code(buf_ptr,buf_end, &start_code);

         if (start_code > 0x1ff){

             if(s2->pict_type != AV_PICTURE_TYPE_B || avctx->skip_frame <= AVDISCARD_DEFAULT){

-                if(HAVE_THREADS && avctx->active_thread_type&FF_THREAD_SLICE){

+                if(HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE)){

                     int i;

                     assert(avctx->thread_count > 1);

@@ -2509,7 +2508,7 @@ static int decode_chunks(AVCodecContext *avctx,

                     break;

                 }

-                if(HAVE_THREADS && avctx->active_thread_type&FF_THREAD_SLICE){

+                if(HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE)){

                     int threshold= (s2->mb_height*s->slice_count + avctx->thread_count/2) / avctx->thread_count;

                     assert(avctx->thread_count > 1);

                     if(threshold <= mb_y){

@@ -761,10 +761,9 @@ void ff_mpeg1_encode_init(MpegEncContext *s)

                 if(mv==0) len= ff_mpeg12_mbMotionVectorTable[0][1];

                 else{

-                    int val, bit_size, range, code;

+                    int val, bit_size, code;