diff --git a/test/encode/h264encode.c b/test/encode/h264encode.c
index a9b0887..c39dcd1 100644
--- a/test/encode/h264encode.c
+++ b/test/encode/h264encode.c
@@ -70,30 +70,38 @@
 #define BITSTREAM_ALLOCATE_STEPPING     4096
 
 
-#define SRC_SURFACE_NUM 16 /* 16 surfaces for source YUV */
-#define REF_SURFACE_NUM 16 /* 16 surfaces for reference */
+#define SURFACE_NUM 16 /* 16 surfaces for source YUV */
+#define SURFACE_NUM 16 /* 16 surfaces for reference */
 static  VADisplay va_dpy;
 static  VAProfile h264_profile;
 static  VAConfigAttrib attrib[VAConfigAttribTypeMax];
 static  VAConfigAttrib config_attrib[VAConfigAttribTypeMax];
 static  int config_attrib_num = 0;
-static  VASurfaceID src_surface[SRC_SURFACE_NUM];
-static  VABufferID coded_buf[SRC_SURFACE_NUM];
-static  VASurfaceID ref_surface[REF_SURFACE_NUM];
+static  VASurfaceID src_surface[SURFACE_NUM];
+static  VABufferID  coded_buf[SURFACE_NUM];
+static  VASurfaceID ref_surface[SURFACE_NUM];
 static  VAConfigID config_id;
 static  VAContextID context_id;
 static  VAEncSequenceParameterBufferH264 seq_param;
 static  VAEncPictureParameterBufferH264 pic_param;
 static  VAEncSliceParameterBufferH264 slice_param;
-static  VAPictureH264 LLastCurrPic={picture_id:VA_INVALID_SURFACE}, LastCurrPic={picture_id:VA_INVALID_SURFACE}, CurrentCurrPic; /* One reference for P and two for B */
+static  VAPictureH264 CurrentCurrPic;
+static  VAPictureH264 ReferenceFrames[16], RefPicList0_P[32], RefPicList0_B[32], RefPicList1_B[32];
 
+static  unsigned int MaxFrameNum = (2<<16);
+static  unsigned int MaxPicOrderCntLsb = (2<<8);
+static  unsigned int Log2MaxFrameNum = 16;
+static  unsigned int Log2MaxPicOrderCntLsb = 8;
+
+static  unsigned int num_ref_frames = 2;
+static  unsigned int numShortTerm = 0;
 static  int constraint_set_flag = 0;
 static  int h264_packedheader = 0; /* support pack header? */
-static  int h264_maxref = 3;
+static  int h264_maxref = (1<<16|1);
 static  char *coded_fn = NULL, *srcyuv_fn = NULL, *recyuv_fn = NULL;
 static  FILE *coded_fp = NULL, *srcyuv_fp = NULL, *recyuv_fp = NULL;
 static  unsigned long long srcyuv_frames = 0;
-static  unsigned int srcyuv_fourcc = VA_FOURCC_NV12;
+static  int srcyuv_fourcc = VA_FOURCC_NV12;
 
 static  int frame_width = 176;
 static  int frame_height = 144;
@@ -102,17 +110,19 @@
 static  unsigned int frame_coded = 0;
 static  unsigned int frame_bitrate = 0;
 static  unsigned int frame_slices = 1;
+static  double frame_size = 0;
 static  int initial_qp = 28;
 static  int minimal_qp = 0;
 static  int intra_period = 30;
 static  int intra_idr_period = 60;
 static  int ip_period = 1;
 static  int rc_mode = VA_RC_VBR;
-static  int slice_refoverride = 1; /* use VAEncSliceParameterBufferH264:RefPicList0/1 */
 static  unsigned long long current_frame_encoding = 0;
 static  unsigned long long current_frame_display = 0;
+static  unsigned long long current_IDR_display = 0;
 static  int current_frame_num = 0;
 static  int current_frame_type;
+#define current_slot (current_frame_display % SURFACE_NUM)
 
 /* thread to save coded data/upload source YUV */
 struct storage_task_t {
@@ -123,12 +133,12 @@
 static  struct storage_task_t *storage_task_header = NULL, *storage_task_tail = NULL;
 #define SRC_SURFACE_IN_ENCODING 0
 #define SRC_SURFACE_IN_STORAGE  1
-static  int srcsurface_status[SRC_SURFACE_NUM];
+static  int srcsurface_status[SURFACE_NUM];
 static  int encode_syncmode = 0;
 static  pthread_mutex_t encode_mutex = PTHREAD_MUTEX_INITIALIZER;
 static  pthread_cond_t  encode_cond = PTHREAD_COND_INITIALIZER;
 static  pthread_t encode_thread;
-
+    
 /* for performance profiling */
 static unsigned int UploadPictureTicks=0;
 static unsigned int BeginPictureTicks=0;
@@ -601,7 +611,7 @@
 {
     switch (fourcc) {
     case VA_FOURCC_NV12:
-        return "NONE";
+        return "NV12";
     case VA_FOURCC_IYUV:
         return "IYUV";
     case VA_FOURCC_YV12:
@@ -670,7 +680,7 @@
     else if (!strncmp(str, "VBR_CONSTRAINED", 15))
         rc_mode = VA_RC_VBR_CONSTRAINED;
     else {
-        printf("Unknow RC mode\n");
+        printf("Unknown RC mode\n");
         rc_mode = -1;
     }
     return rc_mode;
@@ -691,7 +701,6 @@
     printf("   --initialqp <number>\n");
     printf("   --minqp <number>\n");
     printf("   --rcmode <NONE|CBR|VBR|VCM|CQP|VBR_CONTRAINED>\n");
-    printf("   --refoverride: use VAEncSliceParameterBufferH264 to override reference frames\n");
     printf("   --syncmode: sequentially upload source, encoding, save result, no multi-thread\n");
     printf("   --srcyuv <filename> load YUV from a file\n");
     printf("   --fourcc <NV12|IYUV|I420|YV12> source YUV fourcc\n");
@@ -710,7 +719,6 @@
         {"idr_period", required_argument, NULL, 5 },
         {"ip_period", required_argument, NULL, 6 },
         {"rcmode", required_argument, NULL, 7 },
-        {"refoverride",  required_argument, NULL, 8 },
         {"srcyuv", required_argument, NULL, 9 },
         {"fourcc", required_argument, NULL, 10 },
         {"syncmode", no_argument, NULL, 11 },
@@ -759,9 +767,6 @@
                 exit(1);
             }
             break;
-        case 8:
-            slice_refoverride = atoi(optarg);
-            break;
         case 9:
             srcyuv_fn = strdup(optarg);
             break;
@@ -795,10 +800,9 @@
         exit(0);        
     }
 
-    if (frame_bitrate == 0) {
+    if (frame_bitrate == 0)
         frame_bitrate = frame_width * frame_height * 12 * frame_rate / 50;
-        printf("Set bitrate to %dbps\n", frame_bitrate);
-    }
+        
     /* open source file */
     if (srcyuv_fn) {
         srcyuv_fp = fopen(srcyuv_fn,"r");
@@ -1031,7 +1035,7 @@
     /* create source surfaces */
     va_status = vaCreateSurfaces(va_dpy,
                                  VA_RT_FORMAT_YUV420, frame_width, frame_height,
-                                 &src_surface[0], SRC_SURFACE_NUM,
+                                 &src_surface[0], SURFACE_NUM,
                                  NULL, 0);
     CHECK_VASTATUS(va_status, "vaCreateSurfaces");
 
@@ -1039,27 +1043,27 @@
     va_status = vaCreateSurfaces(
             va_dpy,
             VA_RT_FORMAT_YUV420, frame_width, frame_height,
-            &ref_surface[0], h264_maxref,
+            &ref_surface[0], SURFACE_NUM,
             NULL, 0
             );
     CHECK_VASTATUS(va_status, "vaCreateSurfaces");
 
-    tmp_surfaceid = calloc(SRC_SURFACE_NUM + h264_maxref, sizeof(VASurfaceID));
-    memcpy(tmp_surfaceid, src_surface, SRC_SURFACE_NUM * sizeof(VASurfaceID));
-    memcpy(tmp_surfaceid + SRC_SURFACE_NUM, ref_surface, h264_maxref * sizeof(VASurfaceID));
+    tmp_surfaceid = calloc(2 * SURFACE_NUM, sizeof(VASurfaceID));
+    memcpy(tmp_surfaceid, src_surface, SURFACE_NUM * sizeof(VASurfaceID));
+    memcpy(tmp_surfaceid + SURFACE_NUM, ref_surface, SURFACE_NUM * sizeof(VASurfaceID));
     
     /* Create a context for this encode pipe */
     va_status = vaCreateContext(va_dpy, config_id,
                                 frame_width, frame_height,
                                 VA_PROGRESSIVE,
-                                tmp_surfaceid, SRC_SURFACE_NUM + h264_maxref,
+                                tmp_surfaceid, 2 * SURFACE_NUM,
                                 &context_id);
     CHECK_VASTATUS(va_status, "vaCreateContext");
     free(tmp_surfaceid);
 
     codedbuf_size = (frame_width * frame_height * 400) / (16*16);
 
-    for (i = 0; i < SRC_SURFACE_NUM; i++) {
+    for (i = 0; i < SURFACE_NUM; i++) {
         /* create coded buffer once for all
          * other VA buffers which won't be used again after vaRenderPicture.
          * so APP can always vaCreateBuffer for every frame
@@ -1074,6 +1078,117 @@
     return 0;
 }
 
+
+
+#define partition(ref, field, key, ascending)   \
+    while (i <= j) {                            \
+        if (ascending) {                        \
+            while (ref[i].field < key)          \
+                i++;                            \
+            while (ref[j].field > key)          \
+                j--;                            \
+        } else {                                \
+            while (ref[i].field > key)          \
+                i++;                            \
+            while (ref[j].field < key)          \
+                j--;                            \
+        }                                       \
+        if (i <= j) {                           \
+            tmp = ref[i];                       \
+            ref[i] = ref[j];                    \
+            ref[j] = tmp;                       \
+            i++;                                \
+            j--;                                \
+        }                                       \
+    }                                           \
+
+static void sort_one(VAPictureH264 ref[], int left, int right,
+                     int ascending, int frame_idx)
+{
+    int i = left, j = right;
+    unsigned int key;
+    VAPictureH264 tmp;
+
+    if (frame_idx) {
+        key = ref[(left + right) / 2].frame_idx;
+        partition(ref, frame_idx, key, ascending);
+    } else {
+        key = ref[(left + right) / 2].TopFieldOrderCnt;
+        partition(ref, TopFieldOrderCnt, key, ascending);
+    }
+    
+    /* recursion */
+    if (left < j)
+        sort_one(ref, left, j, ascending, frame_idx);
+    
+    if (i < right)
+        sort_one(ref, i, right, ascending, frame_idx);
+}
+
+static void sort_two(VAPictureH264 ref[], int left, int right, int key, int frame_idx,
+                       int divide_ascending, int list0_ascending, int list1_ascending)
+{
+    int i = left, j = right;
+    VAPictureH264 tmp;
+
+    if (frame_idx) {
+        partition(ref, frame_idx, key, divide_ascending);
+    } else {
+        partition(ref, TopFieldOrderCnt, key, divide_ascending);
+    }
+    
+
+    sort_one(ref, left, i-1, list0_ascending, frame_idx);
+    sort_one(ref, j+1, right, list1_ascending, frame_idx);
+}
+
+static int update_ReferenceFrames(void)
+{
+    int i;
+    
+    if (current_frame_type == FRAME_B)
+        return 0;
+
+    CurrentCurrPic.flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE;
+    numShortTerm++;
+    if (numShortTerm > num_ref_frames)
+        numShortTerm = num_ref_frames;
+    for (i=numShortTerm-1; i>0; i--)
+        ReferenceFrames[i] = ReferenceFrames[i-1];
+    ReferenceFrames[0] = CurrentCurrPic;
+    
+    if (current_frame_type != FRAME_B)
+        current_frame_num++;
+    if (current_frame_num > MaxFrameNum)
+        current_frame_num = 0;
+    
+    return 0;
+}
+
+
+static int update_RefPicList(void)
+{
+    unsigned int current_poc = CurrentCurrPic.TopFieldOrderCnt;
+    
+    if (current_frame_type == FRAME_P) {
+        memcpy(RefPicList0_P, ReferenceFrames, numShortTerm * sizeof(VAPictureH264));
+        sort_one(RefPicList0_P, 0, numShortTerm-1, 0, 1);
+    }
+    
+    if (current_frame_type == FRAME_B) {
+        memcpy(RefPicList0_B, ReferenceFrames, numShortTerm * sizeof(VAPictureH264));
+        sort_two(RefPicList0_B, 0, numShortTerm-1, current_poc, 0,
+                 1, 0, 1);
+
+        memcpy(RefPicList1_B, ReferenceFrames, numShortTerm * sizeof(VAPictureH264));
+        sort_two(RefPicList1_B, 0, numShortTerm-1, current_poc, 0,
+                 0, 1, 0);
+    }
+    
+    return 0;
+}
+
+
 static int render_sequence(void)
 {
     VABufferID seq_param_buf, rc_param_buf, render_id[2];
@@ -1090,11 +1205,12 @@
     seq_param.intra_idr_period = intra_idr_period;
     seq_param.ip_period = ip_period;
 
-    seq_param.max_num_ref_frames = h264_maxref;
+    seq_param.max_num_ref_frames = num_ref_frames;
     seq_param.seq_fields.bits.frame_mbs_only_flag = 1;
     seq_param.time_scale = 900;
     seq_param.num_units_in_tick = 15; /* Tc = num_units_in_tick / time_sacle */
-    seq_param.seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 = 2;
+    seq_param.seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 = Log2MaxPicOrderCntLsb - 4;
+    seq_param.seq_fields.bits.log2_max_frame_num_minus4 = Log2MaxFrameNum - 4;;
     seq_param.seq_fields.bits.frame_mbs_only_flag = 1;
     
     va_status = vaCreateBuffer(va_dpy, context_id,
@@ -1127,61 +1243,66 @@
     return 0;
 }
 
+static int calc_poc(unsigned int pic_order_cnt_lsb)
+{
+    static int PicOrderCntMsb_ref = 0, pic_order_cnt_lsb_ref = 0;
+    int prevPicOrderCntMsb, prevPicOrderCntLsb;
+    int PicOrderCntMsb, TopFieldOrderCnt;
+    
+    if (current_frame_type == FRAME_IDR)
+        prevPicOrderCntMsb = prevPicOrderCntLsb = 0;
+    else {
+        prevPicOrderCntMsb = PicOrderCntMsb_ref;
+        prevPicOrderCntLsb = pic_order_cnt_lsb_ref;
+    }
+    
+    if ((pic_order_cnt_lsb < prevPicOrderCntLsb) &&
+        ((prevPicOrderCntLsb - pic_order_cnt_lsb) >= (MaxPicOrderCntLsb / 2)))
+        PicOrderCntMsb = prevPicOrderCntMsb + MaxPicOrderCntLsb;
+    else if ((pic_order_cnt_lsb > prevPicOrderCntLsb) &&
+             ((pic_order_cnt_lsb - prevPicOrderCntLsb) > (MaxPicOrderCntLsb / 2)))
+        PicOrderCntMsb = prevPicOrderCntMsb - MaxPicOrderCntLsb;
+    else
+        PicOrderCntMsb = prevPicOrderCntMsb;
+    
+    TopFieldOrderCnt = PicOrderCntMsb + pic_order_cnt_lsb;
+
+    if (current_frame_type != FRAME_B) {
+        PicOrderCntMsb_ref = PicOrderCntMsb;
+        pic_order_cnt_lsb_ref = pic_order_cnt_lsb;
+    }
+    
+    return TopFieldOrderCnt;
+}
+
 static int render_picture(void)
 {
     VABufferID pic_param_buf;
     VAStatus va_status;
     int i = 0;
 
-    /* use frame_num as reference frame index */
-    pic_param.CurrPic.picture_id = ref_surface[current_frame_num % h264_maxref];
-    //pic_param.CurrPic.frame_idx = current_frame_num % h264_maxref;
+    pic_param.CurrPic.picture_id = ref_surface[current_slot];
+    pic_param.CurrPic.frame_idx = current_frame_num;
     pic_param.CurrPic.flags = 0;
-    pic_param.CurrPic.TopFieldOrderCnt = 2 * current_frame_display;
-    pic_param.CurrPic.BottomFieldOrderCnt = 0;
-    if (current_frame_type != FRAME_B)
-        CurrentCurrPic = pic_param.CurrPic; /* save it */
+    pic_param.CurrPic.TopFieldOrderCnt = calc_poc((current_frame_display - current_IDR_display) % MaxPicOrderCntLsb);
+    pic_param.CurrPic.BottomFieldOrderCnt = pic_param.CurrPic.TopFieldOrderCnt;
+    CurrentCurrPic = pic_param.CurrPic;
 
-    if (slice_refoverride) {
-        /* always setup all reference frame into encoder */
-        for (i = 0; i < h264_maxref; i++) {
-            pic_param.ReferenceFrames[i].picture_id = ref_surface[i];
-            pic_param.ReferenceFrames[i].frame_idx = i;
-            pic_param.ReferenceFrames[i].flags = 0;
-            if (pic_param.CurrPic.picture_id == pic_param.ReferenceFrames[i].picture_id) {
-                pic_param.ReferenceFrames[i].TopFieldOrderCnt = 2 * current_frame_encoding;
-                //pic_param.ReferenceFrames[i].picture_id = VA_INVALID_SURFACE;
-                //pic_param.ReferenceFrames[i].flags = VA_PICTURE_H264_INVALID;
-            }
-            pic_param.ReferenceFrames[i].BottomFieldOrderCnt = 0;
-        }
-    } else  {
-        if (current_frame_type == FRAME_I || current_frame_type == FRAME_IDR)
-            i = 0;
-        else if (current_frame_type == FRAME_P) {
-            pic_param.ReferenceFrames[0] = LastCurrPic;
-            pic_param.ReferenceFrames[0].flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE;
-            i = 1;
-            //#if 0
-            if (LLastCurrPic.picture_id == VA_INVALID_SURFACE)
-                pic_param.ReferenceFrames[1] = LastCurrPic;
-            else
-                pic_param.ReferenceFrames[1] = LLastCurrPic;
-            pic_param.ReferenceFrames[1].flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE;
-            i = 2;
-            //#endif
+    if (getenv("TO_DEL")) { /* set RefPicList into ReferenceFrames */
+        update_RefPicList(); /* calc RefPicList */
+        memset(pic_param.ReferenceFrames, 0xff, 16 * sizeof(VAPictureH264)); /* invalid all */
+        if (current_frame_type == FRAME_P) {
+            pic_param.ReferenceFrames[0] = RefPicList0_P[0];
         } else if (current_frame_type == FRAME_B) {
-            pic_param.ReferenceFrames[0] = LLastCurrPic;
-            pic_param.ReferenceFrames[0].flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE;
-            pic_param.ReferenceFrames[1] = LastCurrPic;
-            pic_param.ReferenceFrames[1].flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE;
-            i = 2;
+            pic_param.ReferenceFrames[0] = RefPicList0_B[0];
+            pic_param.ReferenceFrames[1] = RefPicList1_B[0];
         }
-    }
-    
-    for (; i < REF_SURFACE_NUM; i++) {
-        pic_param.ReferenceFrames[i].picture_id = VA_INVALID_SURFACE;
-        pic_param.ReferenceFrames[i].flags = VA_PICTURE_H264_INVALID;
+    } else {
+        memcpy(pic_param.ReferenceFrames, ReferenceFrames, numShortTerm*sizeof(VAPictureH264));
+        for (i = numShortTerm; i < SURFACE_NUM; i++) {
+            pic_param.ReferenceFrames[i].picture_id = VA_INVALID_SURFACE;
+            pic_param.ReferenceFrames[i].flags = VA_PICTURE_H264_INVALID;
+        }
     }
     
     pic_param.pic_fields.bits.idr_pic_flag = (current_frame_type == FRAME_IDR);
@@ -1189,9 +1310,7 @@
     pic_param.pic_fields.bits.entropy_coding_mode_flag = 1;
     pic_param.pic_fields.bits.deblocking_filter_control_present_flag = 1;
     pic_param.frame_num = current_frame_num;
-    if (current_frame_type != FRAME_B)
-        current_frame_num++;
-    pic_param.coded_buf = coded_buf[current_frame_display % SRC_SURFACE_NUM];
+    pic_param.coded_buf = coded_buf[current_slot];
     pic_param.last_picture = (current_frame_encoding == frame_count);
     pic_param.pic_init_qp = initial_qp;
 
@@ -1385,38 +1504,43 @@
     VABufferID slice_param_buf;
     VAStatus va_status;
     int i;
+
+    update_RefPicList();
     
     /* one frame, one slice */
     slice_param.macroblock_address = 0;
     slice_param.num_macroblocks = frame_width*frame_height/(16*16); /* Measured by MB */
     slice_param.slice_type = (current_frame_type == FRAME_IDR)?2:current_frame_type;
+    if (current_frame_type == FRAME_I || current_frame_type == FRAME_IDR) {
+        ;
+    } else if (current_frame_type == FRAME_P) {
+        int refpiclist0_max = h264_maxref & 0xffff;
+        memcpy(slice_param.RefPicList0, RefPicList0_P, refpiclist0_max*sizeof(VAPictureH264));
 
-    for (i = 0; i < 32; i++) {
-        slice_param.RefPicList0[i].picture_id = VA_INVALID_SURFACE;
-        slice_param.RefPicList0[i].flags = VA_PICTURE_H264_INVALID;
-        slice_param.RefPicList1[i].picture_id = VA_INVALID_SURFACE;
-        slice_param.RefPicList1[i].flags = VA_PICTURE_H264_INVALID;
-    }
+        for (i = refpiclist0_max; i < 32; i++) {
+            slice_param.RefPicList0[i].picture_id = VA_INVALID_SURFACE;
+            slice_param.RefPicList0[i].flags = VA_PICTURE_H264_INVALID;
+        }
+    } else if (current_frame_type == FRAME_B) {
+        int refpiclist0_max = h264_maxref & 0xffff;
+        int refpiclist1_max = (h264_maxref >> 16) & 0xffff;
 
-    /* cause issue on some implementation if slice_refoverride = 1 */
-    //slice_param.num_ref_idx_active_override_flag = 1;
-    if (slice_refoverride) {
-        /* set the real reference frame */
-        if (current_frame_type == FRAME_I || current_frame_type == FRAME_IDR) {
-            ;
-        } else if (current_frame_type == FRAME_P) {
-            slice_param.RefPicList0[0] = LastCurrPic;
-            slice_param.RefPicList0[0].flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE;
-        } else if (current_frame_type == FRAME_B) {
-            slice_param.RefPicList0[0] = LLastCurrPic;
-            slice_param.RefPicList0[0].flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE;
-            slice_param.RefPicList1[0] = LastCurrPic;
-            slice_param.RefPicList1[0].flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE;
+        memcpy(slice_param.RefPicList0, RefPicList0_B, refpiclist0_max*sizeof(VAPictureH264));
+        for (i = refpiclist0_max; i < 32; i++) {
+            slice_param.RefPicList0[i].picture_id = VA_INVALID_SURFACE;
+            slice_param.RefPicList0[i].flags = VA_PICTURE_H264_INVALID;
+        }
+
+        memcpy(slice_param.RefPicList1, RefPicList1_B, refpiclist1_max*sizeof(VAPictureH264));
+        for (i = refpiclist1_max; i < 32; i++) {
+            slice_param.RefPicList1[i].picture_id = VA_INVALID_SURFACE;
+            slice_param.RefPicList1[i].flags = VA_PICTURE_H264_INVALID;
         }
     }
+
     slice_param.slice_alpha_c0_offset_div2 = 2;
     slice_param.slice_beta_offset_div2 = 2;
-    slice_param.pic_order_cnt_lsb = current_frame_display % 64;
+    slice_param.pic_order_cnt_lsb = current_frame_display % MaxPicOrderCntLsb;
     
     va_status = vaCreateBuffer(va_dpy,context_id,VAEncSliceParameterBufferType,
                                sizeof(slice_param),1,&slice_param,&slice_param_buf);
@@ -1429,25 +1553,13 @@
 }
 
 
-static int update_reflist(void)
-{
-    if (current_frame_type == FRAME_B)
-        return 0;
-
-    LLastCurrPic = LastCurrPic;
-    LastCurrPic = CurrentCurrPic;
-
-    return 0;
-}
-
-
 static int upload_source_YUV_once_for_all()
 {
     int box_width=8;
     int row_shift=0;
     int i;
 
-    for (i = 0; i < SRC_SURFACE_NUM; i++) {
+    for (i = 0; i < SURFACE_NUM; i++) {
         printf("\rLoading data into surface %d.....", i);
         upload_surface(va_dpy, src_surface[i], box_width, row_shift, 0);
 
@@ -1463,8 +1575,8 @@
 static int load_surface(VASurfaceID surface_id, unsigned long long display_order)
 {
     VAImage surface_image;
-    unsigned char *surface_p=NULL, *Y_start=NULL, *U_start=NULL,*V_start=NULL;
-    int Y_pitch=0, U_pitch=0, row, V_pitch;
+    unsigned char *surface_p=NULL, *Y_start=NULL, *U_start=NULL,*V_start=NULL, *uv_ptr;
+    int Y_pitch=0, U_pitch=0, row, V_pitch, uv_size;
     VAStatus va_status;
 
     if (srcyuv_fp == NULL)
@@ -1513,7 +1625,7 @@
     }
 
     /* copy Y plane */
-    for (row=0;row<surface_image.height;row++) {
+    for (row=0;row<frame_height;row++) {
         unsigned char *Y_row = Y_start + row * Y_pitch;
         (void)fread(Y_row, 1, surface_image.width, srcyuv_fp);
     }
@@ -1524,30 +1636,42 @@
     fseek(srcyuv_fp,
           display_order * frame_width * frame_height * 1.5 + frame_width * frame_height,
           SEEK_SET);
+
+    uv_size = 2 * (frame_width/2) * (frame_height/2);
+    uv_ptr = malloc(uv_size);
+    fread(uv_ptr, uv_size, 1, srcyuv_fp);
     
-    for (row =0; row < surface_image.height/2; row++) {
+    for (row =0; row < frame_height/2; row++) {
         unsigned char *U_row = U_start + row * U_pitch;
-        //unsigned char *V_row = V_start + row * V_pitch;
+        unsigned char *u_ptr, *v_ptr;
+        int j;
         switch (surface_image.format.fourcc) {
         case VA_FOURCC_NV12:
-            if (srcyuv_fourcc == VA_FOURCC_NV12)
-                (void)fread(U_row, 1, surface_image.width, srcyuv_fp);
-            else if (srcyuv_fourcc == VA_FOURCC_IYUV) {
-                /* tbd */
+            if (srcyuv_fourcc == VA_FOURCC_NV12) {
+                memcpy(U_row, uv_ptr + row * frame_width, frame_width);
+                break;
+            } else if (srcyuv_fourcc == VA_FOURCC_IYUV) {
+                u_ptr = uv_ptr + row * (frame_width/2);
+                v_ptr = uv_ptr + (frame_width/2) * (frame_height/2) + row * (frame_width/2);
+            } else if (srcyuv_fourcc == VA_FOURCC_YV12) {
+                v_ptr = uv_ptr + row * (frame_height/2);
+                u_ptr = uv_ptr + (frame_width/2) * (frame_height/2) + row * (frame_width/2);
+            }
+            for(j = 0; j < frame_width/2; j++) {
+                U_row[2*j] = u_ptr[j];
+                U_row[2*j+1] = v_ptr[j];
             }
             break;
+        case VA_FOURCC_IYUV:
         case VA_FOURCC_YV12:
-            /* tbd */
-            break;
         case VA_FOURCC_YUY2:
-            // see above. it is set with Y update.
-            break;
         default:
             printf("unsupported fourcc in load_surface\n");
             assert(0);
         }
     }
-        
+    free(uv_ptr);
+    
     vaUnmapBuffer(va_dpy,surface_image.buf);
 
     vaDestroyImage(va_dpy,surface_image.image_id);
@@ -1562,13 +1686,15 @@
     VAStatus va_status;
     unsigned int coded_size = 0;
 
-    va_status = vaMapBuffer(va_dpy,coded_buf[display_order % SRC_SURFACE_NUM],(void **)(&buf_list));
+    va_status = vaMapBuffer(va_dpy,coded_buf[display_order % SURFACE_NUM],(void **)(&buf_list));
     CHECK_VASTATUS(va_status,"vaMapBuffer");
     while (buf_list != NULL) {
         coded_size += fwrite(buf_list->buf, 1, buf_list->size, coded_fp);
         buf_list = (VACodedBufferSegment *) buf_list->next;
+
+        frame_size += coded_size;
     }
-    vaUnmapBuffer(va_dpy,coded_buf[display_order % SRC_SURFACE_NUM]);
+    vaUnmapBuffer(va_dpy,coded_buf[display_order % SURFACE_NUM]);
 
     printf("\r      "); /* return back to startpoint */
     switch (encode_order % 4) {
@@ -1636,7 +1762,7 @@
         storage_task_tail = tmp;
     }
 
-    srcsurface_status[display_order % SRC_SURFACE_NUM] = SRC_SURFACE_IN_STORAGE;
+    srcsurface_status[display_order % SURFACE_NUM] = SRC_SURFACE_IN_STORAGE;
     pthread_cond_signal(&encode_cond);
     
     pthread_mutex_unlock(&encode_mutex);
@@ -1644,13 +1770,13 @@
     return 0;
 }
 
-static void storage_task(unsigned long long display_order, unsigned long encode_order)
+static void storage_task(unsigned long long display_order, unsigned long long encode_order)
 {
     unsigned int tmp;
     VAStatus va_status;
     
     tmp = GetTickCount();
-    va_status = vaSyncSurface(va_dpy, src_surface[display_order % SRC_SURFACE_NUM]);
+    va_status = vaSyncSurface(va_dpy, src_surface[display_order % SURFACE_NUM]);
     CHECK_VASTATUS(va_status,"vaSyncSurface");
     SyncPictureTicks += GetTickCount() - tmp;
     tmp = GetTickCount();
@@ -1661,11 +1787,11 @@
     /* reload a new frame data */
     tmp = GetTickCount();
     if (srcyuv_fp != NULL)
-        load_surface(src_surface[display_order % SRC_SURFACE_NUM], display_order + SRC_SURFACE_NUM);
+        load_surface(src_surface[display_order % SURFACE_NUM], display_order + SURFACE_NUM);
     UploadPictureTicks += GetTickCount() - tmp;
 
     pthread_mutex_lock(&encode_mutex);
-    srcsurface_status[display_order % SRC_SURFACE_NUM] = SRC_SURFACE_IN_ENCODING;
+    srcsurface_status[display_order % SURFACE_NUM] = SRC_SURFACE_IN_ENCODING;
     pthread_mutex_unlock(&encode_mutex);
 }
 
@@ -1705,7 +1831,7 @@
     /* upload RAW YUV data into all surfaces */
     tmp = GetTickCount();
     if (srcyuv_fp != NULL) {
-        for (i = 0; i < SRC_SURFACE_NUM; i++)
+        for (i = 0; i < SURFACE_NUM; i++)
             load_surface(src_surface[i], i);
     } else
         upload_source_YUV_once_for_all();
@@ -1724,17 +1850,20 @@
     for (current_frame_encoding = 0; current_frame_encoding < frame_count; current_frame_encoding++) {
         encoding2display_order(current_frame_encoding, intra_period, intra_idr_period, ip_period,
                                &current_frame_display, &current_frame_type);
-
+        if (current_frame_type == FRAME_IDR) {
+            numShortTerm = 0;
+            current_frame_num = 0;
+            current_IDR_display = current_frame_display;
+        }
         /* check if the source frame is ready */
-        while (srcsurface_status[current_frame_display % SRC_SURFACE_NUM] != SRC_SURFACE_IN_ENCODING);
-
+        while (srcsurface_status[current_slot] != SRC_SURFACE_IN_ENCODING);
         tmp = GetTickCount();
-        va_status = vaBeginPicture(va_dpy, context_id, src_surface[current_frame_display % SRC_SURFACE_NUM]);
+        va_status = vaBeginPicture(va_dpy, context_id, src_surface[current_slot]);
         CHECK_VASTATUS(va_status,"vaBeginPicture");
         BeginPictureTicks += GetTickCount() - tmp;
         
         tmp = GetTickCount();
-        if (current_frame_encoding  == 0) {
+        if (current_frame_type == FRAME_IDR) {
             render_sequence();
             render_picture();            
             if (h264_packedheader) {
@@ -1766,11 +1895,10 @@
 
         /* how to process skipped frames
            surface_status = (VASurfaceStatus) 0;
-           va_status = vaQuerySurfaceStatus(va_dpy, src_surface[i%SRC_SURFACE_NUM],&surface_status);
+           va_status = vaQuerySurfaceStatus(va_dpy, src_surface[i%SURFACE_NUM],&surface_status);
            frame_skipped = (surface_status & VASurfaceSkipped);
         */
-
-        update_reflist();        
+        update_ReferenceFrames();        
     }
 
     if (encode_syncmode == 0) {
@@ -1786,10 +1914,10 @@
 {
     int i;
     
-    vaDestroySurfaces(va_dpy,&src_surface[0],SRC_SURFACE_NUM);
-    vaDestroySurfaces(va_dpy,&ref_surface[0],h264_maxref);
+    vaDestroySurfaces(va_dpy,&src_surface[0],SURFACE_NUM);
+    vaDestroySurfaces(va_dpy,&ref_surface[0],SURFACE_NUM);
 
-    for (i = 0; i < SRC_SURFACE_NUM; i++)
+    for (i = 0; i < SURFACE_NUM; i++)
         vaDestroyBuffer(va_dpy,coded_buf[i]);
     
     vaDestroyContext(va_dpy,context_id);
@@ -1822,13 +1950,13 @@
     printf("INPUT: IpPeriod     : %d\n", ip_period);
     printf("INPUT: Initial QP   : %d\n", initial_qp);
     printf("INPUT: Min QP       : %d\n", minimal_qp);
-    printf("INPUT: Source YUV   : %s", srcyuv_fn?"FILE":"AUTO generated");
+    printf("INPUT: Source YUV   : %s", srcyuv_fp?"FILE":"AUTO generated");
     if (srcyuv_fp) 
         printf(":%s (fourcc %s)\n", srcyuv_fn, fourcc_to_string(srcyuv_fourcc));
     else
         printf("\n");
     printf("INPUT: Coded Clip   : %s\n", coded_fn);
-    if (srcyuv_fp == NULL)
+    if (recyuv_fp == NULL)
         printf("INPUT: Rec   Clip   : %s\n", "Not save reconstructed frame");
     else
         printf("INPUT: Rec   Clip   : Save reconstructed frame into %s (fourcc %s)\n", recyuv_fn,
@@ -1843,15 +1971,17 @@
 static int print_performance(unsigned int PictureCount)
 {
     unsigned int others = 0;
+    double total_size = frame_width * frame_height * 1.5 * frame_count;
 
     others = TotalTicks - UploadPictureTicks - BeginPictureTicks
         - RenderPictureTicks - EndPictureTicks - SyncPictureTicks - SavePictureTicks;
-    
+
     printf("\n\n");
 
     printf("PERFORMANCE:   Frame Rate           : %.2f fps (%d frames, %d ms (%.2f ms per frame))\n",
            (double) 1000*PictureCount / TotalTicks, PictureCount,
            TotalTicks, ((double)  TotalTicks) / (double) PictureCount);
+    printf("PERFORMANCE:   Compression ratio    : %d:1\n", (unsigned int)(total_size / frame_size));
 
     printf("PERFORMANCE:     UploadPicture      : %d ms (%.2f, %.2f%% percent)\n",
            (int) UploadPictureTicks, ((double)  UploadPictureTicks) / (double) PictureCount,
@@ -1871,11 +2001,13 @@
     printf("PERFORMANCE:     SavePicture        : %d ms (%.2f, %.2f%% percent)\n",
            (int) SavePictureTicks, ((double)  SavePictureTicks) / (double) PictureCount,
            SavePictureTicks/(double) TotalTicks/0.01);
-
     printf("PERFORMANCE:     Others             : %d ms (%.2f, %.2f%% percent)\n",
            (int) others, ((double) others) / (double) PictureCount,
            others/(double) TotalTicks/0.01);
-    
+
+    if (encode_syncmode == 0)
+        printf("(Multithread enabled, the profiling is only for reference)\n");
+        
     return 0;
 }
 
diff --git a/test/loadsurface.h b/test/loadsurface.h
old mode 100644
new mode 100755
index 6f7bce2..0755572
--- a/test/loadsurface.h
+++ b/test/loadsurface.h
@@ -210,7 +210,7 @@
         }
     }
 
-    if (getenv("AUTO_NOUV"))
+    if (getenv("AUTO_UV") == 0)
         return 0;
 
     if (getenv("AUTO_ALPHA"))
diff --git a/test/putsurface/putsurface_common.c b/test/putsurface/putsurface_common.c
old mode 100644
new mode 100755
diff --git a/va/Android.mk b/va/Android.mk
index 241f599..e4da966 100755
--- a/va/Android.mk
+++ b/va/Android.mk
@@ -63,11 +63,10 @@
 	va.h \
 	va_version.h \
 	va_dec_jpeg.h \
+	va_dec_vp8.h \
 	va_enc.h \
 	va_enc_h264.h \
 	va_enc_vp8.h \
-	va_dec_vp8.h \
-	va_dec_jpeg.h \
 	va_backend.h \
 	va_drmcommon.h \
 	va_vpp.h \
diff --git a/va/Makefile.am b/va/Makefile.am
index a0de1f9..9a3cd2f 100644
--- a/va/Makefile.am
+++ b/va/Makefile.am
@@ -47,9 +47,9 @@
 	va_dec_jpeg.h		\
 	va_dec_vp8.h		\
 	va_drmcommon.h		\
-	va_dummy.h		\
 	va_enc.h		\
 	va_enc_h264.h		\
+	va_enc_vp8.h		\
 	va_enc_mpeg2.h		\
 	va_tpi.h		\
 	va_version.h		\
diff --git a/va/android/Makefile.am b/va/android/Makefile.am
deleted file mode 100644
index 8e532ac..0000000
--- a/va/android/Makefile.am
+++ /dev/null
@@ -1,32 +0,0 @@
-# Copyright (c) 2007 Intel Corporation. All Rights Reserved.
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sub license, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-# 
-# The above copyright notice and this permission notice (including the
-# next paragraph) shall be included in all copies or substantial portions
-# of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
-# IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
-# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-AM_CFLAGS = -DLINUX -I$(top_srcdir)/va -I$(top_srcdir)/va/x11 $(DRM_CFLAGS)
-
-noinst_LTLIBRARIES = libva_dummy.la	
-
-libva_dummy_la_LIBADD = $(LIBVA_LIBS) -ldl -ludev
-
-libva_dummyincludedir = ${includedir}/va
-
-libva_dummy_la_SOURCES = va_dummy.c drmtest.c
-
diff --git a/va/glx/va_glx_impl.c b/va/glx/va_glx_impl.c
index aacefc8..4307001 100644
--- a/va/glx/va_glx_impl.c
+++ b/va/glx/va_glx_impl.c
@@ -151,12 +151,12 @@
     dlerror();
     get_proc_func = (GLXGetProcAddressProc)
         dlsym(RTLD_DEFAULT, "glXGetProcAddress");
-    if (!dlerror())
+    if (!dlerror() && get_proc_func)
         return get_proc_func;
 
     get_proc_func = (GLXGetProcAddressProc)
         dlsym(RTLD_DEFAULT, "glXGetProcAddressARB");
-    if (!dlerror())
+    if (!dlerror() && get_proc_func)
         return get_proc_func;
 
     return get_proc_address_default;
diff --git a/va/va.c b/va/va.c
index 58d4e19..919b498 100755
--- a/va/va.c
+++ b/va/va.c
@@ -458,23 +458,29 @@
     va_infoMessage("VA-API version %s\n", VA_VERSION_S);
 
     vaStatus = va_getDriverName(dpy, &driver_name);
-    va_infoMessage("va_getDriverName() returns %d, driver_name is %s.\n", vaStatus, driver_name);
+    va_infoMessage("va_getDriverName() returns %d\n", vaStatus);
 
     driver_name_env = getenv("LIBVA_DRIVER_NAME");
-    if (driver_name_env && geteuid() == getuid()) {
+    if ((VA_STATUS_SUCCESS == vaStatus) &&
+        driver_name_env && (geteuid() == getuid())) {
         /* Don't allow setuid apps to use LIBVA_DRIVER_NAME */
+        if (driver_name) /* memory is allocated in va_getDriverName */
+            free(driver_name);
+        
         driver_name = strdup(driver_name_env);
         vaStatus = VA_STATUS_SUCCESS;
         va_infoMessage("User requested driver '%s'\n", driver_name);
     }
 
-    if (VA_STATUS_SUCCESS == vaStatus) {
+    if ((VA_STATUS_SUCCESS == vaStatus) && (driver_name != NULL)) {
         vaStatus = va_openDriver(dpy, driver_name);
-        va_infoMessage("va_openDriver() returns %d.\n", vaStatus);
+        va_infoMessage("va_openDriver() returns %d\n", vaStatus);
 
         *major_version = VA_MAJOR_VERSION;
         *minor_version = VA_MINOR_VERSION;
-    }
+    } else
+        va_errorMessage("va_getDriverName() failed with %s,driver_name=%s\n",
+                        vaErrorStr(vaStatus), driver_name);
 
     if (driver_name)
         free(driver_name);
@@ -635,7 +641,7 @@
   vaStatus = ctx->vtable->vaCreateConfig ( ctx, profile, entrypoint, attrib_list, num_attribs, config_id );
 
   /* record the current entrypoint for further trace/fool determination */
-  VA_TRACE_FUNC(va_TraceCreateConfig, dpy, profile, entrypoint, attrib_list, num_attribs, config_id);
+  VA_TRACE_LOG(va_TraceCreateConfig, dpy, profile, entrypoint, attrib_list, num_attribs, config_id);
   VA_FOOL_FUNC(va_FoolCreateConfig, dpy, profile, entrypoint, attrib_list, num_attribs, config_id);
   
   return vaStatus;
@@ -766,7 +772,7 @@
                                       flag, render_targets, num_render_targets, context );
 
   /* keep current encode/decode resoluton */
-  VA_TRACE_FUNC(va_TraceCreateContext, dpy, config_id, picture_width, picture_height, flag, render_targets, num_render_targets, context);
+  VA_TRACE_LOG(va_TraceCreateContext, dpy, config_id, picture_width, picture_height, flag, render_targets, num_render_targets, context);
 
   return vaStatus;
 }
@@ -910,7 +916,7 @@
   CHECK_DISPLAY(dpy);
   ctx = CTX(dpy);
 
-  VA_TRACE_FUNC(va_TraceBeginPicture, dpy, context, render_target);
+  VA_TRACE_LOG(va_TraceBeginPicture, dpy, context, render_target);
   VA_FOOL_RETURN();
   
   va_status = ctx->vtable->vaBeginPicture( ctx, context, render_target );
diff --git a/va/va.h b/va/va.h
index 7f697b7..1d664ee 100755
--- a/va/va.h
+++ b/va/va.h
@@ -911,6 +911,7 @@
     VAEncPackedHeaderDataBufferType     = 26,
     VAEncMiscParameterBufferType	= 27,
     VAEncMacroblockParameterBufferType	= 28,
+    VAEncMacroblockMapBufferType        = 29,
 /* Following are video processing buffer types */
     /**
      * \brief Video processing pipeline parameter buffer.
diff --git a/va/va_dec_jpeg.h b/va/va_dec_jpeg.h
index 091a072..9936692 100644
--- a/va/va_dec_jpeg.h
+++ b/va/va_dec_jpeg.h
@@ -70,22 +70,7 @@
     }                   components[255];
     /** \brief Number of components in frame (Nf). */
     unsigned char       num_components;
-
-    /** \brief Sample precision (P). */
-    unsigned char       sample_precision;
-
-    /** @name Cropping (JPEG-2000) */
-    /**@{*/
-    unsigned char   frame_cropping_flag;
-    unsigned short  frame_crop_left_offset;
-    unsigned short  frame_crop_right_offset;
-    unsigned short  frame_crop_top_offset;
-    unsigned short  frame_crop_bottom_offset;
-    /**@}*/
-
-    /** \brief Rotation (JPEG-2000). See \c VA_ROTATION_xxx. */
-    unsigned int        rotation;
-} VAPictureParameterBufferJPEGBaseline, VAPictureParameterBufferJPEG;
+} VAPictureParameterBufferJPEGBaseline;
 
 /**
  * \brief Quantization table for JPEG decoding.
@@ -104,7 +89,7 @@
     unsigned char       load_quantiser_table[4];
     /** \brief Quanziation tables indexed by table identifier (Tqi). */
     unsigned char       quantiser_table[4][64];
-} VAIQMatrixBufferJPEGBaseline, VAIQMatrixParameterBufferJPEG;
+} VAIQMatrixBufferJPEGBaseline;
 
 /**
  * \brief Huffman table for JPEG decoding.
@@ -140,7 +125,7 @@
         unsigned char   pad[2];
         /**@}*/
     }                   huffman_table[2];
-} VAHuffmanTableBufferJPEGBaseline, VAHuffmanTableParameterBufferJPEG;
+} VAHuffmanTableBufferJPEGBaseline;
 
 /**
  * \brief Slice parameter for JPEG decoding.
@@ -180,7 +165,7 @@
     unsigned short      restart_interval;
     /** \brief Number of MCUs in a scan. */
     unsigned int        num_mcus;
-} VASliceParameterBufferJPEGBaseline, VASliceParameterBufferJPEG;
+} VASliceParameterBufferJPEGBaseline;
 
 /**@}*/
 
diff --git a/va/va_dec_vp8.h b/va/va_dec_vp8.h
index 0a16edd..a3526f7 100644
--- a/va/va_dec_vp8.h
+++ b/va/va_dec_vp8.h
@@ -154,6 +154,7 @@
     unsigned char mv_probs[2][19];
 
     VABoolCoderContextVPX bool_coder_ctx;
+
 } VAPictureParameterBufferVP8;
 
 /**
@@ -186,12 +187,6 @@
     /* Partitions */
     unsigned char num_of_partitions;
     unsigned int partition_size[9];
-    /*
-     * slice data buffer of VASliceDataBufferType is used to send the
-     * partition data. This field specifies the offset to the first byte of
-     * partition data in the buffer.
-     */
-    unsigned int partition_data_offset;
 } VASliceParameterBufferVP8;
 
 /**
diff --git a/va/va_enc_vp8.h b/va/va_enc_vp8.h
index 80011d2..31dfe3e 100644
--- a/va/va_enc_vp8.h
+++ b/va/va_enc_vp8.h
@@ -65,6 +65,7 @@
     /* keyframe maximum interval */
     unsigned int kf_max_dist;
 
+
     /* RC related fields. RC modes are set with VAConfigAttribRateControl */
     /* For VP8, CBR implies HRD conformance and VBR implies no HRD conformance */
 
@@ -85,11 +86,22 @@
     /* HRD buffer optimal fullness */
     unsigned int hrd_buf_optimal_fullness;
 
+    /* up to 3 modes are honored, quality (1), normal (2) and performance (3) */
+    unsigned char target_usage;
+    /* only valid for avbr mode */
+    unsigned int user_max_frame_size;
+    /**
+     * min number of frames for bit rate to converge. 
+     * value should be >= 100. used for avbr mode 
+     */
+    unsigned int avbr_convergence;
+
     /* reference and reconstructed frame buffers*/
     VASurfaceID reference_frames[4];
 
 } VAEncSequenceParameterBufferVP8;
 
+
 /**
  * \brief VP8 Encoding Picture Parameter Buffer Structure
  *
@@ -100,36 +112,203 @@
 {
     /* surface to store reconstructed frame  */
     VASurfaceID reconstructed_frame;
+
     /* buffer to store coded data */
     VABufferID coded_buf;
-    /* equivalent to VP8E_SET_CPUUSED */
-    unsigned int cpu_used;
 
     union {
         struct {
-	    /* force this frame to be a keyframe */
-            unsigned int force_kf		: 1;
+            /* force this frame to be a keyframe */
+            unsigned int force_kf                       : 1;
 	    /* don't reference the last frame */
-            unsigned int no_ref_last		: 1;
+            unsigned int no_ref_last                    : 1;
 	    /* don't reference the golden frame */
-            unsigned int no_ref_gf		: 1;
+            unsigned int no_ref_gf                      : 1;
 	    /* don't reference the alternate reference frame */
-            unsigned int no_ref_arf		: 1;
-	    /*  0: bicubic, 1: bilinear, other: none */
-            unsigned int recon_filter_type       :2;
-	    /*  only invalid if recon_filter_type set to bilinear.
-             *   0: no loop fitler, 1: simple loop filter */
-            unsigned int loop_filter_type           :1;
-	    /* 1: enable, 0: disabled */
-            unsigned int auto_partitions            :1;
-	    /* number of token partitions */
-            unsigned int num_token_partitions :2;
+            unsigned int no_ref_arf                     : 1;
+            /*  0: bicubic, 1: bilinear, other: none */
+            unsigned int recon_filter_type              : 2;
+            /*  0: no loop fitler, 1: simple loop filter */
+            unsigned int loop_filter_type               : 2;
+            /* 0: disabled, 1: normal, 2: simple */
+            unsigned int auto_partitions                : 1;
+            /* number of token partitions */
+            unsigned int num_token_partitions           : 2;
+
+            /** 
+             * The following fields correspond to the same VP8 syntax elements 
+             * in the frame header.
+             */
+	    /**
+             * 0: clamping of reconstruction pixels is disabled,
+             * 1: clamping enabled.
+             */
+            unsigned int clamping_type                  : 1;
+            /* indicate segmentation is enabled for the current frame. */
+            unsigned int segmentation_enabled           : 1;
+            /**
+             * Determines if the MB segmentation map is updated in the current 
+             * frame.
+             */
+            unsigned int update_mb_segmentation_map     : 1;
+            /**
+             * Indicates if the segment feature data is updated in the current 
+             * frame.
+             */
+            unsigned int update_segment_feature_data    : 1;
+            /**
+             * indicates if the MB level loop filter adjustment is enabled for 
+             * the current frame (0 off, 1 on).  
+             */
+	    unsigned int loop_filter_adj_enable         : 1;
+            /**
+             * Determines whether updated token probabilities are used only for 
+             * this frame or until further update. 
+             * It may be used by application to enable error resilient mode. 
+             * In this mode probability updates are allowed only at Key Frames.
+             */
+            unsigned int refresh_entropy_probs          : 1;
+            /**
+             * Determines if the current decoded frame refreshes the golden frame.
+             */
+            unsigned int refresh_golden_frame           : 1;
+            /** 
+             * Determines if the current decoded frame refreshes the alternate 
+             * reference frame.
+             */
+            unsigned int refresh_alternate_frame        : 1;
+            /**
+             * Determines if the current decoded frame refreshes the last frame 
+             * reference buffer.
+             */
+            unsigned int refresh_last                   : 1;
+            /**
+             * Determines if the golden reference is replaced by another reference.
+             */
+            unsigned int copy_buffer_to_golden          : 2;
+            /**
+             * Determines if the alternate reference is replaced by another reference.
+             */
+            unsigned int copy_buffer_to_alternate       : 2;
+            /** 
+             * Controls the sign of motion vectors when the golden frame is referenced.  
+             */
+            unsigned int sign_bias_golden               : 1;
+            /**
+             * Controls the sign of motion vectors when the alternate frame is 
+             * referenced. 
+             */
+	    unsigned int sign_bias_alternate            : 1;
+            /**
+             * Enables or disables the skipping of macroblocks containing no 
+             * non-zero coefficients. 
+             */
+	    unsigned int mb_no_coeff_skip               : 1;
+            /** 
+             * Enforces unconditional per-MB loop filter delta update setting frame 
+             * header flags mode_ref_lf_delta_update, all mb_mode_delta_update_flag[4], 
+             * and all ref_frame_delta_update_flag[4] to 1. 
+	     * Since loop filter deltas are not automatically refreshed to default 
+             * values at key frames, dropped frame with delta update may prevent 
+             * correct decoding from the next key frame. 
+	     * Encoder application is advised to set this flag to 1 at key frames.
+	     */
+            unsigned int forced_lf_adjustment           : 1;
+	    unsigned int reserved                       : 4;
         } bits;
         unsigned int value;
     } pic_flags;
 
+    /* quality setting, equivalent to VP8E_SET_CPUUSED */
+    unsigned int quality_setting;
+
+    /**
+     * Contains a list of 4 loop filter level values (updated value if applicable)
+     * controlling the deblocking filter strength. Each entry represents a segment.
+     * When segmentation is disabled, use entry 0. 
+     * When loop_filter_level is 0, loop filter shall be disabled. 
+     */
+    char loop_filter_level[4];
+
+    /** 
+     * Contains a list of 4 delta values for reference frame based MB-level 
+     * loop filter adjustment.  
+     * If no update, then set to 0.
+     */
+    char ref_lf_delta[4];
+
+    /**
+     * Contains a list of 4 delta values for coding mode based MB-level loop
+     * filter adjustment.  
+     * If no update, then set to 0. 
+     */
+    char mode_lf_delta[4];
+	
+    /**
+     * Controls the deblocking filter sensitivity. 
+     * Corresponds to the same VP8 syntax element in frame header.
+     */
+    unsigned char sharpness_level;
+	
+    /** 
+     * Application supplied maximum clamp value for Qindex used in quantization.  
+     * Qindex will not be allowed to exceed this value.  
+     * It has a valid range [0..127] inclusive.  
+     */
+    unsigned char clamp_qindex_high;
+	
+    /**
+     * Application supplied minimum clamp value for Qindex used in quantization.  
+     * Qindex will not be allowed to be lower than this value.  
+     * It has a valid range [0..127] inclusive.  
+     * Condition clamp_qindex_low <= clamp_qindex_high must be guaranteed, 
+     * otherwise they are ignored. 
+     */
+    unsigned char clamp_qindex_low;
+	
 } VAEncPictureParameterBufferVP8;
 
+
+/**
+ * \brief VP8 MB Segmentation ID Buffer
+ *
+ * application provides buffer containing the initial segmentation id for each 
+ * MB, in raster scan order. Rate control may reassign it.
+ * For an 640x480 video, the buffer has 1200 entries. 
+ * the value of each entry should be in the range [0..3], inclusive.
+ * If segmentation is not enabled, application does not need to provide it. 
+ */
+typedef struct _VAEncMBMapBufferVP8
+{
+    /** 
+     * number of MBs in the frame.
+     * It is also the number of entries of mb_segment_id[];
+     */
+    unsigned int num_mbs;
+    /**
+     * per MB Segmentation ID Buffer
+     */
+    unsigned char *mb_segment_id;
+} VAEncMBMapBufferVP8;
+
+
+/**
+ * \brief VP8 Quantization Matrix Buffer Structure
+ *
+ * Contains quantization indices for yac(0),ydc(1),y2dc(2),y2ac(3),uvdc(4),
+ * uvac(5) for each segment (0-3). When segmentation is disabled, only  
+ * quantization_index[0][] will be used. This structure is sent once per frame.
+ */
+typedef struct _VAQMatrixBufferVP8
+{
+    /* 
+     * array first dimensional is segment and 2nd dimensional is Q index
+     */
+    unsigned short quantization_index[4][6];
+} VAQMatrixBufferVP8;
+
+
+
 /**@}*/
 
 #ifdef __cplusplus
diff --git a/va/va_trace.c b/va/va_trace.c
index 3e02824..2d390bc 100755
--- a/va/va_trace.c
+++ b/va/va_trace.c
@@ -817,13 +817,6 @@
         va_TraceMsg(idx,"\t\t[%d] v_sampling_factor = %u\n", i, p->components[i].v_sampling_factor);
         va_TraceMsg(idx,"\t\t[%d] quantiser_table_selector = %u\n", i, p->components[i].quantiser_table_selector);
     }
-    va_TraceMsg(idx,"\tsample_precision = %u\n", p->sample_precision);
-    va_TraceMsg(idx,"\tframe_cropping_flag = %u\n", p->frame_cropping_flag);
-    va_TraceMsg(idx,"\tframe_crop_left_offset = %u\n", p->frame_crop_left_offset);
-    va_TraceMsg(idx,"\tframe_crop_right_offset = %u\n", p->frame_crop_right_offset);
-    va_TraceMsg(idx,"\tframe_crop_top_offset = %u\n", p->frame_crop_top_offset);
-    va_TraceMsg(idx,"\tframe_crop_bottom_offset = %u\n", p->frame_crop_bottom_offset);
-    va_TraceMsg(idx,"\trotation = %u\n", p->rotation);
 }
 
 static void va_TraceVAIQMatrixBufferJPEG(
@@ -1065,7 +1058,7 @@
     va_TraceMsg(idx, "VAEncPictureParameterBufferMPEG4\n");
     va_TraceMsg(idx, "\treference_picture = 0x%08x\n", p->reference_picture);
     va_TraceMsg(idx, "\treconstructed_picture = 0x%08x\n", p->reconstructed_picture);
-    va_TraceMsg(idx, "\tcoded_buf = %08x\n", p->coded_buf);
+    va_TraceMsg(idx, "\tcoded_buf = 0x%08x\n", p->coded_buf);
     va_TraceMsg(idx, "\tpicture_width = %d\n", p->picture_width);
     va_TraceMsg(idx, "\tpicture_height = %d\n", p->picture_height);
     va_TraceMsg(idx, "\tmodulo_time_base = %d\n", p->modulo_time_base);
@@ -1144,17 +1137,19 @@
     va_TraceMsg(idx, "\tCurrPic.TopFieldOrderCnt = %d\n", p->CurrPic.TopFieldOrderCnt);
     va_TraceMsg(idx, "\tCurrPic.BottomFieldOrderCnt = %d\n", p->CurrPic.BottomFieldOrderCnt);
 
-    va_TraceMsg(idx, "\tReferenceFrames (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx:\n");
+    va_TraceMsg(idx, "\tReferenceFrames (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx-flags:\n");
     for (i = 0; i < 16; i++)
     {
-        if (p->ReferenceFrames[i].flags != VA_PICTURE_H264_INVALID) {
-            va_TraceMsg(idx, "\t\t%d-%d-0x%08x-%d\n",
+        if ((p->ReferenceFrames[i].picture_id != VA_INVALID_SURFACE) &&
+            ((p->ReferenceFrames[i].flags & VA_PICTURE_H264_INVALID) == 0)) {
+            va_TraceMsg(idx, "\t\t%08d-%08d-0x%08x-%08d-0x%08x\n",
                         p->ReferenceFrames[i].TopFieldOrderCnt,
                         p->ReferenceFrames[i].BottomFieldOrderCnt,
                         p->ReferenceFrames[i].picture_id,
-                        p->ReferenceFrames[i].frame_idx);
+                        p->ReferenceFrames[i].frame_idx,
+                        p->ReferenceFrames[i].flags);
         } else
-            va_TraceMsg(idx, "\t\tinv-inv-inv-inv\n");
+            va_TraceMsg(idx, "\t\tinv-inv-inv-inv-inv\n");
     }
     va_TraceMsg(idx, "\n");
     
@@ -1229,13 +1224,13 @@
     if (p->slice_type == 0 || p->slice_type == 1) {
         va_TraceMsg(idx, "\tRefPicList0 =");
         for (i = 0; (i < p->num_ref_idx_l0_active_minus1 + 1 && i < 32); i++) {
-            va_TraceMsg(idx, "%d-%d-0x%08x-%d\n", p->RefPicList0[i].TopFieldOrderCnt, p->RefPicList0[i].BottomFieldOrderCnt, p->RefPicList0[i].picture_id, p->RefPicList0[i].frame_idx);
+            va_TraceMsg(idx, "%08d-%08d-0x%08x-%08d-0x%08x\n", p->RefPicList0[i].TopFieldOrderCnt, p->RefPicList0[i].BottomFieldOrderCnt, p->RefPicList0[i].picture_id, p->RefPicList0[i].frame_idx,  p->RefPicList0[i].flags);
         }
         if (p->slice_type == 1) {
             va_TraceMsg(idx, "\tRefPicList1 =");
             for (i = 0; (i < p->num_ref_idx_l1_active_minus1 + 1 && i < 32); i++)
             {
-                va_TraceMsg(idx, "%d-%d-0x%08x-%d\n", p->RefPicList1[i].TopFieldOrderCnt, p->RefPicList1[i].BottomFieldOrderCnt, p->RefPicList1[i].picture_id, p->RefPicList1[i].frame_idx);
+                va_TraceMsg(idx, "%08d-%08d-0x%08x-%08d-0x%08x\n", p->RefPicList1[i].TopFieldOrderCnt, p->RefPicList1[i].BottomFieldOrderCnt, p->RefPicList1[i].picture_id, p->RefPicList1[i].frame_idx, p->RefPicList1[i].flags);
             }
         }
     }
@@ -1407,17 +1402,20 @@
     va_TraceMsg(idx, "\tCurrPic.flags = %d\n", p->CurrPic.flags);
     va_TraceMsg(idx, "\tCurrPic.TopFieldOrderCnt = %d\n", p->CurrPic.TopFieldOrderCnt);
     va_TraceMsg(idx, "\tCurrPic.BottomFieldOrderCnt = %d\n", p->CurrPic.BottomFieldOrderCnt);
-    va_TraceMsg(idx, "\tReferenceFrames (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx:\n");
+    va_TraceMsg(idx, "\tReferenceFrames (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx-flags):\n");
     for (i = 0; i < 16; i++)
     {
-        if (p->ReferenceFrames[i].flags != VA_PICTURE_H264_INVALID) {
-            va_TraceMsg(idx, "\t\t%d-%d-0x%08x-%d\n",
+        if ((p->ReferenceFrames[i].picture_id != VA_INVALID_SURFACE) &&
+            ((p->ReferenceFrames[i].flags & VA_PICTURE_H264_INVALID) == 0)) {
+            va_TraceMsg(idx, "\t\t%08d-%08d-0x%08x-%08d-0x%08x\n",
                         p->ReferenceFrames[i].TopFieldOrderCnt,
                         p->ReferenceFrames[i].BottomFieldOrderCnt,
                         p->ReferenceFrames[i].picture_id,
-                        p->ReferenceFrames[i].frame_idx);
+                        p->ReferenceFrames[i].frame_idx,
+                        p->ReferenceFrames[i].flags
+                        );
         } else
-            va_TraceMsg(idx, "\t\tinv-inv-inv-inv\n");
+            va_TraceMsg(idx, "\t\tinv-inv-inv-inv-inv\n");
     }
     va_TraceMsg(idx, "\tcoded_buf = %08x\n", p->coded_buf);
     va_TraceMsg(idx, "\tpic_parameter_set_id = %d\n", p->pic_parameter_set_id);
@@ -1506,19 +1504,38 @@
     va_TraceMsg(idx, "\tslice_beta_offset_div2 = %d\n", p->slice_beta_offset_div2);
 
     if (p->slice_type == 0 || p->slice_type == 1) {
-        va_TraceMsg(idx, "\tRefPicList0 =");
-        for (i = 0; i < p->num_ref_idx_l0_active_minus1 + 1 && i < 32; i++) {
-            va_TraceMsg(idx, "%d-%d-0x%08x-%d\n", p->RefPicList0[i].TopFieldOrderCnt, p->RefPicList0[i].BottomFieldOrderCnt, p->RefPicList0[i].picture_id, p->RefPicList0[i].frame_idx);
-        }
-        if (p->slice_type == 1) {
-            va_TraceMsg(idx, "\tRefPicList1 =");
-            for (i = 0; i < p->num_ref_idx_l1_active_minus1 + 1 && i < 32; i++)
-            {
-                va_TraceMsg(idx, "%d-%d-0x%08x-%d\n", p->RefPicList1[i].TopFieldOrderCnt, p->RefPicList1[i].BottomFieldOrderCnt, p->RefPicList1[i].picture_id, p->RefPicList1[i].frame_idx);
-            }
+        va_TraceMsg(idx, "\tRefPicList0 (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx-flags):\n");
+        for (i = 0; i < 32; i++) {
+            if ((p->RefPicList0[i].picture_id != VA_INVALID_SURFACE) &&
+                ((p->RefPicList0[i].flags & VA_PICTURE_H264_INVALID) == 0))
+                va_TraceMsg(idx, "\t\t%08d-%08d-0x%08x-%08d-0x%08x\n",
+                            p->RefPicList0[i].TopFieldOrderCnt,
+                            p->RefPicList0[i].BottomFieldOrderCnt,
+                            p->RefPicList0[i].picture_id,
+                            p->RefPicList0[i].frame_idx,
+                            p->RefPicList0[i].flags);
+            else
+                break;
         }
     }
-
+    
+    if (p->slice_type == 1) {
+        va_TraceMsg(idx, "\tRefPicList1 (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx-flags):\n");
+        for (i = 0; i < 32; i++) {
+            if ((p->RefPicList1[i].picture_id != VA_INVALID_SURFACE) &&
+                ((p->RefPicList1[i].flags & VA_PICTURE_H264_INVALID) == 0))
+                va_TraceMsg(idx, "\t\t%08d-%08d-0x%08x-%08d-0x%08d\n",
+                            p->RefPicList1[i].TopFieldOrderCnt,
+                            p->RefPicList1[i].BottomFieldOrderCnt,
+                            p->RefPicList1[i].picture_id,
+                            p->RefPicList1[i].frame_idx,
+                            p->RefPicList1[i].flags
+                            );
+            else
+                break;
+        }
+    }
+    
     va_TraceMsg(idx, "\tluma_log2_weight_denom = %d\n", p->luma_log2_weight_denom);
     va_TraceMsg(idx, "\tchroma_log2_weight_denom = %d\n", p->chroma_log2_weight_denom);
     va_TraceMsg(idx, "\tluma_weight_l0_flag = %d\n", p->luma_weight_l0_flag);
diff --git a/va/va_trace.h b/va/va_trace.h
index 6803c28..f7af9b5 100755
--- a/va/va_trace.h
+++ b/va/va_trace.h
@@ -43,17 +43,13 @@
                                        VA_TRACE_FLAG_SURFACE_ENCODE | \
                                        VA_TRACE_FLAG_SURFACE_JPEG)
 
-#define VA_TRACE_FUNC(trace_func,...)           \
-    if (trace_flag) {                           \
-        trace_func(__VA_ARGS__);                \
-    }
 #define VA_TRACE_LOG(trace_func,...)            \
-    if (trace_flag & VA_TRACE_FLAG_LOG) {            \
+    if (trace_flag & VA_TRACE_FLAG_LOG) {       \
         trace_func(__VA_ARGS__);                \
     }
-#define VA_TRACE_SURFACE(trace_func,...)        \
-    if (trace_flag & (VA_TRACE_FLAG_SURFACE | VA_TRACE_FLAG_CODEDBUF)) {  \
-        trace_func(__VA_ARGS__);                \
+#define VA_TRACE_SURFACE(trace_func,...)                                \
+    if (trace_flag & (VA_TRACE_FLAG_SURFACE | VA_TRACE_FLAG_CODEDBUF)) { \
+        trace_func(__VA_ARGS__);                                        \
     }
 
 void va_TraceInit(VADisplay dpy);
diff --git a/va/va_vpp.h b/va/va_vpp.h
index e985bba..55ab978 100644
--- a/va/va_vpp.h
+++ b/va/va_vpp.h
@@ -251,9 +251,6 @@
     VAProcFilterColorStandard,
     /** \brief Frame rate conversion. */
     VAProcFilterFrameRateConversion,
-    VAProcFilterColorEnhancement,
-    VAProcFilterProcAmp,
-    VAProcFilterComposition,
     /** \brief Skin Tone Enhancement. */
     VAProcFilterSkinToneEnhancement,
     /** \brief Total Color Correction. */
@@ -682,13 +679,11 @@
  * if this is not set then assumes top field first.
  */
 #define VA_DEINTERLACING_BOTTOM_FIELD_FIRST	0x0001
-#define VA_DEINTERLACING_INPUT_BOTTOM_FIELD_FIRST VA_DEINTERLACING_BOTTOM_FIELD_FIRST
 /** 
  * \brief Bottom field used in deinterlacing. 
  * if this is not set then assumes top field is used.
  */
 #define VA_DEINTERLACING_BOTTOM_FIELD		0x0002
-#define VA_DEINTERLACING_BOB_BOTTOM_FIELD       VA_DEINTERLACING_BOTTOM_FIELD
 /** 
  * \brief A single field is stored in the input frame. 
  * if this is not set then assumes the frame contains two interleaved fields.
@@ -841,15 +836,6 @@
     VAProcColorStandardType     type;
 } VAProcFilterCapColorStandard;
 
-/** \brief Capabilities specification for the amplifier filter. */
-typedef struct _VAProcFilterCapProcAmp
-{
-    VAProcFilterValueRange brightness_range;
-    VAProcFilterValueRange contrast_range;
-    VAProcFilterValueRange saturation_range;
-    VAProcFilterValueRange hue_range;
-} VAProcFilterCapProcAmp;
-
 /**
  * \brief Queries video processing filters.
  *
diff --git a/va/x11/dri2_util.c b/va/x11/dri2_util.c
index 0a2ac45..3d490d0 100644
--- a/va/x11/dri2_util.c
+++ b/va/x11/dri2_util.c
@@ -192,7 +192,7 @@
 
 
     if (!VA_DRI2Connect(ctx->native_dpy, RootWindow(ctx->native_dpy, ctx->x11_screen),
-                     driver_name, &device_name))
+                     driver_name, &device_name) || !device_name)
         goto err_out;
 
     dri_state->base.fd = open(device_name, O_RDWR);
@@ -216,8 +216,7 @@
     dri_state->close = dri2Close;
     gsDRI2SwapAvailable = (minor >= 2);
 
-    if (device_name)
-        Xfree(device_name);
+    Xfree(device_name);
 
     return True;
 
diff --git a/va/x11/va_fglrx.c b/va/x11/va_fglrx.c
index 77149cb..a437bce 100644
--- a/va/x11/va_fglrx.c
+++ b/va/x11/va_fglrx.c
@@ -153,27 +153,27 @@
     dlerror();
     ADL_Main_Control_Create = (ADL_MAIN_CONTROL_CREATE)
         dlsym(libadl_handle,"ADL_Main_Control_Create");
-    if (dlerror())
+    if (dlerror() || !ADL_Main_Control_Create)
         goto end;
 
     ADL_Main_Control_Destroy = (ADL_MAIN_CONTROL_DESTROY)
         dlsym(libadl_handle,"ADL_Main_Control_Destroy");
-    if (dlerror())
+    if (dlerror() || !ADL_Main_Control_Destroy)
         goto end;
 
     ADL_Adapter_NumberOfAdapters_Get = (ADL_ADAPTER_NUMBEROFADAPTERS_GET)
         dlsym(libadl_handle,"ADL_Adapter_NumberOfAdapters_Get");
-    if (dlerror())
+    if (dlerror() || !ADL_Adapter_NumberOfAdapters_Get)
         goto end;
 
     ADL_Adapter_AdapterInfo_Get = (ADL_ADAPTER_ADAPTERINFO_GET)
         dlsym(libadl_handle,"ADL_Adapter_AdapterInfo_Get");
-    if (dlerror())
+    if (dlerror() || !ADL_Adapter_AdapterInfo_Get)
         goto end;
 
     ADL_Adapter_XScreenInfo_Get = (ADL_ADAPTER_XSCREENINFO_GET)
         dlsym(libadl_handle,"ADL_Adapter_XScreenInfo_Get");
-    if (dlerror())
+    if (dlerror() || !ADL_Adapter_XScreenInfo_Get)
         goto end;
 
     if (ADL_Main_Control_Create(ADL_Main_Memory_Alloc, 1) != ADL_OK)
diff --git a/va/x11/va_x11.c b/va/x11/va_x11.c
index dfb9d07..c78bd8a 100644
--- a/va/x11/va_x11.c
+++ b/va/x11/va_x11.c
@@ -256,9 +256,9 @@
   CHECK_DISPLAY(dpy);
   ctx = CTX(dpy);
   
-  VA_TRACE_FUNC(va_TracePutSurface, dpy, surface, (void *)draw, srcx, srcy, srcw, srch,
-                destx, desty, destw, desth,
-           cliprects, number_cliprects, flags );
+  VA_TRACE_LOG(va_TracePutSurface, dpy, surface, (void *)draw, srcx, srcy, srcw, srch,
+               destx, desty, destw, desth,
+               cliprects, number_cliprects, flags );
   
   return ctx->vtable->vaPutSurface( ctx, surface, (void *)draw, srcx, srcy, srcw, srch,
                                    destx, desty, destw, desth,