silent a lot of MSVC compiler warnings

there are still a couple type of warning left, which are related to
double constants assigned to float type. As those would be addressed
by the conversion of transforms into integer version. This commit
has left those un-dealt with.

Change-Id: I48fd9b489c0c27ad6b543f4177423419f929f2bb

diff --git a/vp9/common/blockd.h b/vp9/common/blockd.h
index 0b1fd46..65e1e99 100644 (file)
--- a/vp9/common/blockd.h
+++ b/vp9/common/blockd.h
@@ -483,7 +483,7 @@ static TX_TYPE get_tx_type_16x16(const MACROBLOCKD *xd, const BLOCKD *b) {
 
 static TX_TYPE get_tx_type(const MACROBLOCKD *xd, const BLOCKD *b) {
   TX_TYPE tx_type = DCT_DCT;
-  int ib = (b - xd->block);
+  int ib = (int)(b - xd->block);
   if (ib >= 16)
     return tx_type;
   if (xd->mode_info_context->mbmi.txfm_size == TX_16X16) {

diff --git a/vp9/common/quant_common.c b/vp9/common/quant_common.c
index 8c3f427..720b271 100644 (file)
--- a/vp9/common/quant_common.c
+++ b/vp9/common/quant_common.c
@@ -30,9 +30,9 @@ void vp9_init_quant_tables() {
     last_val = current_val;
 
     ac_val = ac_qlookup[i];
-    dc_qlookup[i] = (0.000000305 * ac_val * ac_val * ac_val) +
-                    (-0.00065 * ac_val * ac_val) +
-                    (0.9 * ac_val) + 0.5;
+    dc_qlookup[i] = (int)((0.000000305 * ac_val * ac_val * ac_val) +
+                          (-0.00065 * ac_val * ac_val) +
+                          (0.9 * ac_val) + 0.5);
     if (dc_qlookup[i] < ACDC_MIN)
       dc_qlookup[i] = ACDC_MIN;
   }

diff --git a/vp9/decoder/dboolhuff.h b/vp9/decoder/dboolhuff.h
index 285d2a9..d46d81b 100644 (file)
--- a/vp9/decoder/dboolhuff.h
+++ b/vp9/decoder/dboolhuff.h
@@ -56,7 +56,7 @@ int vp9_inv_recenter_nonneg(int v, int m);
   { \
     int shift = VP9_BD_VALUE_SIZE - 8 - ((_count) + 8); \
     int loop_end, x; \
-    size_t bits_left = ((_bufend)-(_bufptr))*CHAR_BIT; \
+    int bits_left = (int)(((_bufend)-(_bufptr))*CHAR_BIT); \
     \
     x = shift + CHAR_BIT - bits_left; \
     loop_end = 0; \

diff --git a/vp9/decoder/decodemv.c b/vp9/decoder/decodemv.c
index c4ff898..a299b5d 100644 (file)
--- a/vp9/decoder/decodemv.c
+++ b/vp9/decoder/decodemv.c
@@ -654,7 +654,7 @@ static void read_mb_modes_mv(VP9D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
   const int mis = pbi->common.mode_info_stride;
   MACROBLOCKD *const xd  = &pbi->mb;
 
-  int_mv *const mv = &mbmi->mv;
+  int_mv *const mv = &mbmi->mv[0];
   int mb_to_left_edge;
   int mb_to_right_edge;
   int mb_to_top_edge;
@@ -1172,7 +1172,7 @@ static void read_mb_modes_mv(VP9D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
   }
 }
 
-void vp9_decode_mode_mvs_init(VP9D_COMP *pbi, BOOL_DECODER* const bc) {
+void vp9_decode_mode_mvs_init(VP9D_COMP* const pbi, BOOL_DECODER* const bc) {
   VP9_COMMON *cm = &pbi->common;
 
   vpx_memset(cm->mbskip_pred_probs, 0, sizeof(cm->mbskip_pred_probs));
@@ -1184,8 +1184,8 @@ void vp9_decode_mode_mvs_init(VP9D_COMP *pbi, BOOL_DECODER* const bc) {
 
   mb_mode_mv_init(pbi, bc);
 }
-void vp9_decode_mb_mode_mv(VP9D_COMP *pbi,
-                           MACROBLOCKD *xd,
+void vp9_decode_mb_mode_mv(VP9D_COMP* const pbi,
+                           MACROBLOCKD* const xd,
                            int mb_row,
                            int mb_col,
                            BOOL_DECODER* const bc) {

diff --git a/vp9/decoder/decodframe.c b/vp9/decoder/decodframe.c
index 9c25afb..60bf7ba 100644 (file)
--- a/vp9/decoder/decodframe.c
+++ b/vp9/decoder/decodframe.c
@@ -729,7 +729,8 @@ static void setup_token_decoder(VP9D_COMP *pbi,
                        "%d length", 1);
   }
 
-  if (vp9_start_decode(bool_decoder, partition, partition_size))
+  if (vp9_start_decode(bool_decoder,
+                       partition, (unsigned int)partition_size))
     vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                        "Failed to allocate bool decoder %d", 1);
 }
@@ -986,7 +987,8 @@ int vp9_decode_frame(VP9D_COMP *pbi) {
 
   init_frame(pbi);
 
-  if (vp9_start_decode(&header_bc, data, first_partition_length_in_bytes))
+  if (vp9_start_decode(&header_bc, data,
+                       (unsigned int)first_partition_length_in_bytes))
     vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                        "Failed to allocate bool decoder 0");
   if (pc->frame_type == KEY_FRAME) {

diff --git a/vp9/decoder/detokenize.c b/vp9/decoder/detokenize.c
index 62511f0..68f2c28 100644 (file)
--- a/vp9/decoder/detokenize.c
+++ b/vp9/decoder/detokenize.c
@@ -98,7 +98,7 @@ DECLARE_ALIGNED(16, static const int, coef_bands_x_16x16[256]) = {
 static const unsigned char cat6_prob[14] =
 { 254, 254, 252, 249, 243, 230, 196, 177, 153, 140, 133, 130, 129, 0 };
 
-void vp9_reset_mb_tokens_context(MACROBLOCKD *xd) {
+void vp9_reset_mb_tokens_context(MACROBLOCKD* const xd) {
   /* Clear entropy contexts for Y2 blocks */
   if ((xd->mode_info_context->mbmi.mode != B_PRED &&
       xd->mode_info_context->mbmi.mode != I8X8_PRED &&
@@ -414,7 +414,8 @@ SKIP_START:
   return c;
 }
 
-int vp9_decode_mb_tokens_16x16(VP9D_COMP *pbi, MACROBLOCKD *xd,
+int vp9_decode_mb_tokens_16x16(VP9D_COMP* const pbi,
+                               MACROBLOCKD* const xd,
                                BOOL_DECODER* const bc) {
   ENTROPY_CONTEXT* const A = (ENTROPY_CONTEXT *)xd->above_context;
   ENTROPY_CONTEXT* const L = (ENTROPY_CONTEXT *)xd->left_context;
@@ -477,7 +478,8 @@ int vp9_decode_mb_tokens_16x16(VP9D_COMP *pbi, MACROBLOCKD *xd,
   return eobtotal;
 }
 
-int vp9_decode_mb_tokens_8x8(VP9D_COMP *pbi, MACROBLOCKD *xd,
+int vp9_decode_mb_tokens_8x8(VP9D_COMP* const pbi,
+                             MACROBLOCKD* const xd,
                              BOOL_DECODER* const bc) {
   ENTROPY_CONTEXT *const A = (ENTROPY_CONTEXT *)xd->above_context;
   ENTROPY_CONTEXT *const L = (ENTROPY_CONTEXT *)xd->left_context;
@@ -571,7 +573,8 @@ int vp9_decode_mb_tokens_8x8(VP9D_COMP *pbi, MACROBLOCKD *xd,
 }
 
 
-int vp9_decode_mb_tokens(VP9D_COMP *dx, MACROBLOCKD *xd,
+int vp9_decode_mb_tokens(VP9D_COMP* const dx,
+                         MACROBLOCKD* const xd,
                          BOOL_DECODER* const bc) {
   ENTROPY_CONTEXT *const A = (ENTROPY_CONTEXT *)xd->above_context;
   ENTROPY_CONTEXT *const L = (ENTROPY_CONTEXT *)xd->left_context;

diff --git a/vp9/encoder/bitstream.c b/vp9/encoder/bitstream.c
index 7474344..f6046dc 100644 (file)
--- a/vp9/encoder/bitstream.c
+++ b/vp9/encoder/bitstream.c
@@ -218,7 +218,6 @@ static void update_switchable_interp_probs(VP9_COMP *cpi,
 static void update_refpred_stats(VP9_COMP *cpi) {
   VP9_COMMON *const cm = &cpi->common;
   int i;
-  int tot_count;
   vp9_prob new_pred_probs[PREDICTION_PROBS];
   int old_cost, new_cost;
 
@@ -884,7 +883,6 @@ static void update_ref_probs(VP9_COMP *const cpi) {
 }
 
 static void pack_inter_mode_mvs(VP9_COMP *const cpi, vp9_writer *const bc) {
-  int i;
   VP9_COMMON *const pc = &cpi->common;
   const nmv_context *nmvc = &pc->fc.nmvc;
   MACROBLOCK *x = &cpi->mb;

diff --git a/vp9/encoder/encodeframe.c b/vp9/encoder/encodeframe.c
index 22fcc6b..94fa2f2 100644 (file)
--- a/vp9/encoder/encodeframe.c
+++ b/vp9/encoder/encodeframe.c
@@ -1390,7 +1390,7 @@ static void encode_frame_internal(VP9_COMP *cpi) {
         x->src.v_buffer += 16 * x->src.uv_stride - 8 * offset;
       }
 
-      cpi->tok_count = tp - cpi->tok;
+      cpi->tok_count = (unsigned int)(tp - cpi->tok);
     }
 
     vpx_usec_timer_mark(&emr_timer);
@@ -1578,7 +1578,7 @@ void vp9_encode_frame(VP9_COMP *cpi) {
     encode_frame_internal(cpi);
 
     for (i = 0; i < NB_PREDICTION_TYPES; ++i) {
-      const int diff = cpi->rd_comp_pred_diff[i] / cpi->common.MBs;
+      const int diff = (int)(cpi->rd_comp_pred_diff[i] / cpi->common.MBs);
       cpi->rd_prediction_type_threshes[frame_type][i] += diff;
       cpi->rd_prediction_type_threshes[frame_type][i] >>= 1;
     }
@@ -1588,7 +1588,7 @@ void vp9_encode_frame(VP9_COMP *cpi) {
       int diff;
       if (i == TX_MODE_SELECT)
         pd -= RDCOST(cpi->mb.rdmult, cpi->mb.rddiv, 2048 * (TX_SIZE_MAX - 1), 0);
-      diff = pd / cpi->common.MBs;
+      diff = (int)(pd / cpi->common.MBs);
       cpi->rd_tx_select_threshes[frame_type][i] += diff;
       cpi->rd_tx_select_threshes[frame_type][i] /= 2;
     }

diff --git a/vp9/encoder/encodemv.c b/vp9/encoder/encodemv.c
index 0483d81..a9431bd 100644 (file)
--- a/vp9/encoder/encodemv.c
+++ b/vp9/encoder/encodemv.c
@@ -168,7 +168,7 @@ static int update_nmv_savings(const unsigned int ct[2],
   if (cur_b - mod_b - cost > 0) {
     return cur_b - mod_b - cost;
   } else {
-    return -vp9_cost_zero(upd_p);
+    return 0 - vp9_cost_zero(upd_p);
   }
 }
 

diff --git a/vp9/encoder/encodemv.h b/vp9/encoder/encodemv.h
index f19613d..a35fabf 100644 (file)
--- a/vp9/encoder/encodemv.h
+++ b/vp9/encoder/encodemv.h
@@ -18,11 +18,11 @@ void vp9_write_nmvprobs(VP9_COMP* const, int usehp, vp9_writer* const);
 void vp9_encode_nmv(vp9_writer* const w, const MV* const mv,
                     const MV* const ref, const nmv_context* const mvctx);
 void vp9_encode_nmv_fp(vp9_writer* const w, const MV* const mv,
-                       const MV* const ref, const nmv_context *mvctx,
+                       const MV* const ref, const nmv_context* const mvctx,
                        int usehp);
 void vp9_build_nmv_cost_table(int *mvjoint,
                               int *mvcost[2],
-                              const nmv_context *mvctx,
+                              const nmv_context* const mvctx,
                               int usehp,
                               int mvc_flag_v,
                               int mvc_flag_h);

diff --git a/vp9/encoder/firstpass.c b/vp9/encoder/firstpass.c
index b57ce74..0238232 100644 (file)
--- a/vp9/encoder/firstpass.c
+++ b/vp9/encoder/firstpass.c
@@ -696,9 +696,9 @@ void vp9_first_pass(VP9_COMP *cpi) {
     FIRSTPASS_STATS fps;
 
     fps.frame      = cm->current_video_frame;
-    fps.intra_error = intra_error >> 8;
-    fps.coded_error = coded_error >> 8;
-    fps.sr_coded_error = sr_coded_error >> 8;
+    fps.intra_error = (double)(intra_error >> 8);
+    fps.coded_error = (double)(coded_error >> 8);
+    fps.sr_coded_error = (double)(sr_coded_error >> 8);
     weight = simple_weight(cpi->Source);
 
 
@@ -738,8 +738,8 @@ void vp9_first_pass(VP9_COMP *cpi) {
 
     // TODO:  handle the case when duration is set to 0, or something less
     // than the full time between subsequent cpi->source_time_stamp s  .
-    fps.duration = cpi->source->ts_end
-                   - cpi->source->ts_start;
+    fps.duration = (double)(cpi->source->ts_end
+                            - cpi->source->ts_start);
 
     // don't want to do output stats with a stack variable!
     memcpy(cpi->twopass.this_frame_stats,
@@ -901,7 +901,7 @@ static int estimate_max_q(VP9_COMP *cpi,
   double err_per_mb = section_err / num_mbs;
   double err_correction_factor;
   double speed_correction = 1.0;
-  int overhead_bits_per_mb;
+  double overhead_bits_per_mb;
 
   if (section_target_bandwitdh <= 0)
     return cpi->twopass.maxq_max_limit;          // Highest value allowed
@@ -976,7 +976,7 @@ static int estimate_max_q(VP9_COMP *cpi,
       err_correction_factor = 5.0;
 
     bits_per_mb_at_this_q =
-      vp9_bits_per_mb(INTER_FRAME, Q) + overhead_bits_per_mb;
+      vp9_bits_per_mb(INTER_FRAME, Q) + (int)overhead_bits_per_mb;
 
     bits_per_mb_at_this_q = (int)(.5 + err_correction_factor *
                                   (double)bits_per_mb_at_this_q);
@@ -1003,7 +1003,7 @@ static int estimate_max_q(VP9_COMP *cpi,
   // Give average a chance to settle though.
   // PGW TODO.. This code is broken for the extended Q range
   if ((cpi->ni_frames >
-       ((unsigned int)cpi->twopass.total_stats->count >> 8)) &&
+       ((int)cpi->twopass.total_stats->count >> 8)) &&
       (cpi->ni_frames > 150)) {
     adjust_maxq_qrange(cpi);
   }
@@ -1029,7 +1029,7 @@ static int estimate_cq(VP9_COMP *cpi,
   double speed_correction = 1.0;
   double clip_iiratio;
   double clip_iifactor;
-  int overhead_bits_per_mb;
+  double overhead_bits_per_mb;
 
 
   target_norm_bits_per_mb = (section_target_bandwitdh < (1 << 20))
@@ -1082,7 +1082,7 @@ static int estimate_cq(VP9_COMP *cpi,
       err_correction_factor = 5.0;
 
     bits_per_mb_at_this_q =
-      vp9_bits_per_mb(INTER_FRAME, Q) + overhead_bits_per_mb;
+      vp9_bits_per_mb(INTER_FRAME, Q) + (int)overhead_bits_per_mb;
 
     bits_per_mb_at_this_q = (int)(.5 + err_correction_factor *
                                   (double)bits_per_mb_at_this_q);
@@ -1417,7 +1417,7 @@ static int calc_arf_boost(
                     calc_frame_boost(cpi, &this_frame, this_frame_mv_in_out));
   }
 
-  *f_boost = boost_score;
+  *f_boost = (int)boost_score;
 
   // Reset for backward looking loop
   boost_score = 0.0;
@@ -1455,7 +1455,7 @@ static int calc_arf_boost(
                     calc_frame_boost(cpi, &this_frame, this_frame_mv_in_out));
 
   }
-  *b_boost = boost_score;
+  *b_boost = (int)boost_score;
 
   arf_boost = (*f_boost + *b_boost);
   if (arf_boost < ((b_frames + f_frames) * 20))
@@ -1477,8 +1477,8 @@ static void configure_arnr_filter(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
   // Note: this_frame->frame has been updated in the loop
   // so it now points at the ARF frame.
   half_gf_int = cpi->baseline_gf_interval >> 1;
-  frames_after_arf = cpi->twopass.total_stats->count -
-                     this_frame->frame - 1;
+  frames_after_arf = (int)(cpi->twopass.total_stats->count -
+                           this_frame->frame - 1);
 
   switch (cpi->oxcf.arnr_type) {
     case 1: // Backward filter
@@ -1701,7 +1701,7 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
       (cpi->twopass.kf_group_error_left > 0)) {
     cpi->twopass.gf_group_bits =
       (int)((double)cpi->twopass.kf_group_bits *
-            (gf_group_err / (double)cpi->twopass.kf_group_error_left));
+            (gf_group_err / cpi->twopass.kf_group_error_left));
   } else
     cpi->twopass.gf_group_bits = 0;
 
@@ -1767,7 +1767,7 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
       alt_gf_grp_bits =
         (double)cpi->twopass.kf_group_bits  *
         (mod_frame_err * (double)cpi->baseline_gf_interval) /
-        DOUBLE_DIVIDE_CHECK((double)cpi->twopass.kf_group_error_left);
+        DOUBLE_DIVIDE_CHECK(cpi->twopass.kf_group_error_left);
 
       alt_gf_bits = (int)((double)boost * (alt_gf_grp_bits /
                                            (double)allocation_chunks));
@@ -1783,7 +1783,7 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
       int alt_gf_bits =
         (int)((double)cpi->twopass.kf_group_bits *
               mod_frame_err /
-              DOUBLE_DIVIDE_CHECK((double)cpi->twopass.kf_group_error_left));
+              DOUBLE_DIVIDE_CHECK(cpi->twopass.kf_group_error_left));
 
       if (alt_gf_bits > gf_bits) {
         gf_bits = alt_gf_bits;
@@ -1806,7 +1806,7 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
 
   {
     // Adjust KF group bits and error remainin
-    cpi->twopass.kf_group_error_left -= gf_group_err;
+    cpi->twopass.kf_group_error_left -= (int64_t)gf_group_err;
     cpi->twopass.kf_group_bits -= cpi->twopass.gf_group_bits;
 
     if (cpi->twopass.kf_group_bits < 0)
@@ -1817,9 +1817,10 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
     // of the group (except in Key frame case where this has already
     // happened)
     if (!cpi->source_alt_ref_pending && cpi->common.frame_type != KEY_FRAME)
-      cpi->twopass.gf_group_error_left = gf_group_err - gf_first_frame_err;
+      cpi->twopass.gf_group_error_left = (int64_t)(gf_group_err
+                                                   - gf_first_frame_err);
     else
-      cpi->twopass.gf_group_error_left = gf_group_err;
+      cpi->twopass.gf_group_error_left = (int64_t)gf_group_err;
 
     cpi->twopass.gf_group_bits -= cpi->twopass.gf_bits - cpi->min_frame_bandwidth;
 
@@ -1839,8 +1840,8 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
         pct_extra = (boost - 100) / 50;
         pct_extra = (pct_extra > 20) ? 20 : pct_extra;
 
-        cpi->twopass.alt_extra_bits =
-          (cpi->twopass.gf_group_bits * pct_extra) / 100;
+        cpi->twopass.alt_extra_bits = (int)
+          ((cpi->twopass.gf_group_bits * pct_extra) / 100);
         cpi->twopass.gf_group_bits -= cpi->twopass.alt_extra_bits;
         cpi->twopass.alt_extra_bits /=
           ((cpi->baseline_gf_interval - 1) >> 1);
@@ -1863,9 +1864,9 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
 
     avg_stats(&sectionstats);
 
-    cpi->twopass.section_intra_rating =
-      sectionstats.intra_error /
-      DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
+    cpi->twopass.section_intra_rating = (int)
+      (sectionstats.intra_error /
+      DOUBLE_DIVIDE_CHECK(sectionstats.coded_error));
 
     reset_fpf_position(cpi, start_pos);
   }
@@ -1898,10 +1899,11 @@ static void assign_std_frame_bits(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
       target_frame_size = max_bits;
 
     if (target_frame_size > cpi->twopass.gf_group_bits)
-      target_frame_size = cpi->twopass.gf_group_bits;
+      target_frame_size = (int)cpi->twopass.gf_group_bits;
   }
 
-  cpi->twopass.gf_group_error_left -= modified_err;                                               // Adjust error remaining
+  // Adjust error remaining
+  cpi->twopass.gf_group_error_left -= (int64_t)modified_err;
   cpi->twopass.gf_group_bits -= target_frame_size;                                                // Adjust bits remaining
 
   if (cpi->twopass.gf_group_bits < 0)
@@ -2010,25 +2012,26 @@ void vp9_second_pass(VP9_COMP *cpi) {
   }
 
   // Keep a globally available copy of this and the next frame's iiratio.
-  cpi->twopass.this_iiratio = this_frame_intra_error /
-                              DOUBLE_DIVIDE_CHECK(this_frame_coded_error);
+  cpi->twopass.this_iiratio = (int)(this_frame_intra_error /
+                              DOUBLE_DIVIDE_CHECK(this_frame_coded_error));
   {
     FIRSTPASS_STATS next_frame;
     if (lookup_next_frame_stats(cpi, &next_frame) != EOF) {
-      cpi->twopass.next_iiratio = next_frame.intra_error /
-                                  DOUBLE_DIVIDE_CHECK(next_frame.coded_error);
+      cpi->twopass.next_iiratio = (int)(next_frame.intra_error /
+                                  DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
     }
   }
 
   // Set nominal per second bandwidth for this frame
-  cpi->target_bandwidth = cpi->per_frame_bandwidth * cpi->output_frame_rate;
+  cpi->target_bandwidth = (int)(cpi->per_frame_bandwidth
+                                * cpi->output_frame_rate);
   if (cpi->target_bandwidth < 0)
     cpi->target_bandwidth = 0;
 
 
   // Account for mv, mode and other overheads.
-  overhead_bits = estimate_modemvcost(
-                    cpi, cpi->twopass.total_left_stats);
+  overhead_bits = (int)estimate_modemvcost(
+                        cpi, cpi->twopass.total_left_stats);
 
   // Special case code for first frame.
   if (cpi->common.current_video_frame == 0) {
@@ -2418,9 +2421,9 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
 
     avg_stats(&sectionstats);
 
-    cpi->twopass.section_intra_rating =
-      sectionstats.intra_error
-      / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
+    cpi->twopass.section_intra_rating = (int)
+      (sectionstats.intra_error
+      / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error));
   }
 
   // Reset the first pass file position
@@ -2428,7 +2431,7 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
 
   // Work out how many bits to allocate for the key frame itself
   if (1) {
-    int kf_boost = boost_score;
+    int kf_boost = (int)boost_score;
     int allocation_chunks;
     int alt_kf_bits;
 
@@ -2510,10 +2513,14 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
     }
 
     cpi->twopass.kf_group_bits -= cpi->twopass.kf_bits;
-    cpi->twopass.kf_bits += cpi->min_frame_bandwidth;                                          // Add in the minimum frame allowance
-
-    cpi->per_frame_bandwidth = cpi->twopass.kf_bits;                                           // Peer frame bit target for this frame
-    cpi->target_bandwidth = cpi->twopass.kf_bits * cpi->output_frame_rate;                      // Convert to a per second bitrate
+    // Add in the minimum frame allowance
+    cpi->twopass.kf_bits += cpi->min_frame_bandwidth;
+
+    // Peer frame bit target for this frame
+    cpi->per_frame_bandwidth = cpi->twopass.kf_bits;
+    // Convert to a per second bitrate
+    cpi->target_bandwidth = (int)(cpi->twopass.kf_bits *
+                                  cpi->output_frame_rate);
   }
 
   // Note the total error score of the kf group minus the key frame itself

diff --git a/vp9/encoder/lookahead.c b/vp9/encoder/lookahead.c
index ca0b4cd..c10fecd 100644 (file)
--- a/vp9/encoder/lookahead.c
+++ b/vp9/encoder/lookahead.c
@@ -43,7 +43,7 @@ void
 vp9_lookahead_destroy(struct lookahead_ctx *ctx) {
   if (ctx) {
     if (ctx->buf) {
-      int i;
+      unsigned int i;
 
       for (i = 0; i < ctx->max_sz; i++)
         vp8_yv12_de_alloc_frame_buffer(&ctx->buf[i].img);
@@ -59,7 +59,6 @@ vp9_lookahead_init(unsigned int width,
                    unsigned int height,
                    unsigned int depth) {
   struct lookahead_ctx *ctx = NULL;
-  int i;
 
   /* Clamp the lookahead queue depth */
   if (depth < 1)
@@ -74,6 +73,7 @@ vp9_lookahead_init(unsigned int width,
   /* Allocate the lookahead structures */
   ctx = calloc(1, sizeof(*ctx));
   if (ctx) {
+    unsigned int i;
     ctx->max_sz = depth;
     ctx->buf = calloc(depth, sizeof(*ctx->buf));
     if (!ctx->buf)
@@ -175,9 +175,9 @@ vp9_lookahead_peek(struct lookahead_ctx *ctx,
   struct lookahead_entry *buf = NULL;
 
   assert(index < ctx->max_sz);
-  if (index < ctx->sz) {
+  if (index < (int)ctx->sz) {
     index += ctx->read_idx;
-    if (index >= ctx->max_sz)
+    if (index >= (int)ctx->max_sz)
       index -= ctx->max_sz;
     buf = ctx->buf + index;
   }

diff --git a/vp9/encoder/mbgraph.c b/vp9/encoder/mbgraph.c
index 301826e..e750616 100644 (file)
--- a/vp9/encoder/mbgraph.c
+++ b/vp9/encoder/mbgraph.c
@@ -139,7 +139,7 @@ static int do_16x16_motion_search
 
   // If the current best reference mv is not centred on 0,0 then do a 0,0 based search as well
   if (ref_mv->as_int) {
-    int tmp_err;
+    unsigned int tmp_err;
     int_mv zero_ref_mv, tmp_mv;
 
     zero_ref_mv.as_int = 0;
@@ -202,7 +202,7 @@ static int find_best_16x16_intra
   MACROBLOCK   *const x  = &cpi->mb;
   MACROBLOCKD *const xd = &x->e_mbd;
   MB_PREDICTION_MODE best_mode = -1, mode;
-  int best_err = INT_MAX;
+  unsigned int best_err = INT_MAX;
 
   // calculate SATD for each intra prediction mode;
   // we're intentionally not doing 4x4, we just want a rough estimate
@@ -449,7 +449,7 @@ void vp9_update_mbgraph_stats
   // being a GF - so exit if we don't look ahead beyond that
   if (n_frames <= cpi->frames_till_gf_update_due)
     return;
-  if (n_frames > cpi->common.frames_till_alt_ref_frame)
+  if (n_frames > (int)cpi->common.frames_till_alt_ref_frame)
     n_frames = cpi->common.frames_till_alt_ref_frame;
   if (n_frames > MAX_LAG_BUFFERS)
     n_frames = MAX_LAG_BUFFERS;

diff --git a/vp9/encoder/mcomp.c b/vp9/encoder/mcomp.c
index 60ec49c..50e7cde 100644 (file)
--- a/vp9/encoder/mcomp.c
+++ b/vp9/encoder/mcomp.c
@@ -1380,7 +1380,7 @@ int vp9_diamond_search_sadx4(MACROBLOCK *x, BLOCK *b, BLOCKD *d,
   int tot_steps;
   int_mv this_mv;
 
-  int bestsad = INT_MAX;
+  unsigned int bestsad = INT_MAX;
   int best_site = 0;
   int last_site = 0;
 
@@ -1674,7 +1674,7 @@ int vp9_full_search_sadx3(MACROBLOCK *x, BLOCK *b, BLOCKD *d, int_mv *ref_mv,
   unsigned char *bestaddress;
   int_mv *best_mv = &d->bmi.as_mv.first;
   int_mv this_mv;
-  int bestsad = INT_MAX;
+  unsigned int bestsad = INT_MAX;
   int r, c;
 
   unsigned char *check_here;
@@ -1802,7 +1802,7 @@ int vp9_full_search_sadx8(MACROBLOCK *x, BLOCK *b, BLOCKD *d, int_mv *ref_mv,
   unsigned char *bestaddress;
   int_mv *best_mv = &d->bmi.as_mv.first;
   int_mv this_mv;
-  int bestsad = INT_MAX;
+  unsigned int bestsad = INT_MAX;
   int r, c;
 
   unsigned char *check_here;

diff --git a/vp9/encoder/onyx_if.c b/vp9/encoder/onyx_if.c
index 02a3b05..e655bbb 100644 (file)
--- a/vp9/encoder/onyx_if.c
+++ b/vp9/encoder/onyx_if.c
@@ -244,14 +244,14 @@ static void init_base_skip_probs(void) {
       skip_prob = 255;
     base_skip_false_prob[i][1] = skip_prob;
 
-    skip_prob = t * 0.75;
+    skip_prob = t * 3 / 4;
     if (skip_prob < 1)
       skip_prob = 1;
     else if (skip_prob > 255)
       skip_prob = 255;
     base_skip_false_prob[i][2] = skip_prob;
 
-    skip_prob = t * 1.25;
+    skip_prob = t * 5 / 4;
     if (skip_prob < 1)
       skip_prob = 1;
     else if (skip_prob > 255)
@@ -1400,7 +1400,7 @@ rescale(int val, int num, int denom) {
   int64_t llden = denom;
   int64_t llval = val;
 
-  return llval * llnum / llden;
+  return (int)(llval * llnum / llden);
 }
 
 
@@ -1912,7 +1912,7 @@ VP9_PTR vp9_create_compressor(VP9_CONFIG *oxcf) {
     vp9_init_first_pass(cpi);
   } else if (cpi->pass == 2) {
     size_t packet_sz = sizeof(FIRSTPASS_STATS);
-    int packets = oxcf->two_pass_stats_in.sz / packet_sz;
+    int packets = (int)(oxcf->two_pass_stats_in.sz / packet_sz);
 
     cpi->twopass.stats_in_start = oxcf->two_pass_stats_in.buf;
     cpi->twopass.stats_in = cpi->twopass.stats_in_start;
@@ -2338,7 +2338,7 @@ static void generate_psnr_packet(VP9_COMP *cpi) {
 
   for (i = 0; i < 4; i++)
     pkt.data.psnr.psnr[i] = vp9_mse2psnr(pkt.data.psnr.samples[i], 255.0,
-                                         pkt.data.psnr.sse[i]);
+                                         (double)pkt.data.psnr.sse[i]);
 
   vpx_codec_pkt_list_add(cpi->output_pkt_list, &pkt);
 }
@@ -2904,7 +2904,9 @@ static void encode_frame_to_data_rate
   // pass function that sets the target bandwidth so must set it here
   if (cpi->common.refresh_alt_ref_frame) {
     cpi->per_frame_bandwidth = cpi->twopass.gf_bits;                           // Per frame bit target for the alt ref frame
-    cpi->target_bandwidth = cpi->twopass.gf_bits * cpi->output_frame_rate;      // per second target bitrate
+    // per second target bitrate
+    cpi->target_bandwidth = (int)(cpi->twopass.gf_bits *
+                                  cpi->output_frame_rate);
   }
 
   // Default turn off buffer to buffer copying
@@ -4106,7 +4108,7 @@ int vp9_get_compressed_data(VP9_PTR ptr, unsigned int *frame_flags,
                       - cpi->last_time_stamp_seen;
       // do a step update if the duration changes by 10%
       if (last_duration)
-        step = ((this_duration - last_duration) * 10 / last_duration);
+        step = (int)((this_duration - last_duration) * 10 / last_duration);
     }
 
     if (this_duration) {
@@ -4119,7 +4121,8 @@ int vp9_get_compressed_data(VP9_PTR ptr, unsigned int *frame_flags,
          * frame rate. If we haven't seen 1 second yet, then average
          * over the whole interval seen.
          */
-        interval = cpi->source->ts_end - cpi->first_time_stamp_ever;
+        interval = (double)(cpi->source->ts_end
+                            - cpi->first_time_stamp_ever);
         if (interval > 10000000.0)
           interval = 10000000;
 
@@ -4221,17 +4224,17 @@ int vp9_get_compressed_data(VP9_PTR ptr, unsigned int *frame_flags,
         int y_samples = orig->y_height * orig->y_width;
         int uv_samples = orig->uv_height * orig->uv_width;
         int t_samples = y_samples + 2 * uv_samples;
-        int64_t sq_error;
+        double sq_error;
 
-        ye = calc_plane_error(orig->y_buffer, orig->y_stride,
+        ye = (double)calc_plane_error(orig->y_buffer, orig->y_stride,
                               recon->y_buffer, recon->y_stride, orig->y_width,
                               orig->y_height);
 
-        ue = calc_plane_error(orig->u_buffer, orig->uv_stride,
+        ue = (double)calc_plane_error(orig->u_buffer, orig->uv_stride,
                               recon->u_buffer, recon->uv_stride, orig->uv_width,
                               orig->uv_height);
 
-        ve = calc_plane_error(orig->v_buffer, orig->uv_stride,
+        ve = (double)calc_plane_error(orig->v_buffer, orig->uv_stride,
                               recon->v_buffer, recon->uv_stride, orig->uv_width,
                               orig->uv_height);
 
@@ -4252,15 +4255,15 @@ int vp9_get_compressed_data(VP9_PTR ptr, unsigned int *frame_flags,
 #endif
           vp9_clear_system_state();
 
-          ye = calc_plane_error(orig->y_buffer, orig->y_stride,
+          ye = (double)calc_plane_error(orig->y_buffer, orig->y_stride,
                                 pp->y_buffer, pp->y_stride, orig->y_width,
                                 orig->y_height);
 
-          ue = calc_plane_error(orig->u_buffer, orig->uv_stride,
+          ue = (double)calc_plane_error(orig->u_buffer, orig->uv_stride,
                                 pp->u_buffer, pp->uv_stride, orig->uv_width,
                                 orig->uv_height);
 
-          ve = calc_plane_error(orig->v_buffer, orig->uv_stride,
+          ve = (double)calc_plane_error(orig->v_buffer, orig->uv_stride,
                                 pp->v_buffer, pp->uv_stride, orig->uv_width,
                                 orig->uv_height);
 

diff --git a/vp9/encoder/onyx_int.h b/vp9/encoder/onyx_int.h
index 97917d6..3297552 100644 (file)
--- a/vp9/encoder/onyx_int.h
+++ b/vp9/encoder/onyx_int.h
@@ -665,7 +665,8 @@ typedef struct VP9_COMP {
     int maxq_min_limit;
     int static_scene_max_gf_interval;
     int kf_bits;
-    int gf_group_error_left;           // Remaining error from uncoded frames in a gf group. Two pass use only
+    // Remaining error from uncoded frames in a gf group. Two pass use only
+    int64_t gf_group_error_left;
 
     // Projected total bits available for a key frame group of frames
     int64_t kf_group_bits;
@@ -673,8 +674,10 @@ typedef struct VP9_COMP {
     // Error score of frames still to be coded in kf group
     int64_t kf_group_error_left;
 
-    int gf_group_bits;                // Projected Bits available for a group of frames including 1 GF or ARF
-    int gf_bits;                     // Bits for the golden frame or ARF - 2 pass only
+    // Projected Bits available for a group of frames including 1 GF or ARF
+    int64_t gf_group_bits;
+    // Bits for the golden frame or ARF - 2 pass only
+    int gf_bits;
     int alt_extra_bits;
 
     int sr_update_lag;

diff --git a/vp9/encoder/ratectrl.c b/vp9/encoder/ratectrl.c
index 62a940d..2838e26 100644 (file)
--- a/vp9/encoder/ratectrl.c
+++ b/vp9/encoder/ratectrl.c
@@ -311,8 +311,8 @@ static void calc_iframe_target_size(VP9_COMP *cpi) {
   target = cpi->per_frame_bandwidth;
 
   if (cpi->oxcf.rc_max_intra_bitrate_pct) {
-    unsigned int max_rate = cpi->per_frame_bandwidth
-                            * cpi->oxcf.rc_max_intra_bitrate_pct / 100;
+    int max_rate = cpi->per_frame_bandwidth
+                 * cpi->oxcf.rc_max_intra_bitrate_pct / 100;
 
     if (target > max_rate)
       target = max_rate;

diff --git a/vp9/encoder/rdopt.c b/vp9/encoder/rdopt.c
index 71b8a2e..24e84da 100644 (file)
--- a/vp9/encoder/rdopt.c
+++ b/vp9/encoder/rdopt.c
@@ -557,7 +557,7 @@ static int cost_coeffs(MACROBLOCK *mb, BLOCKD *b, PLANE_TYPE type,
       default_eob = 64;
       if (type == PLANE_TYPE_Y_WITH_DC) {
         BLOCKD *bb;
-        int ib = (b - xd->block);
+        int ib = (int)(b - xd->block);
         if (ib < 16) {
           ib = (ib & 8) + ((ib & 4) >> 1);
           bb = xd->block + ib;
@@ -1516,7 +1516,7 @@ static int64_t rd_pick_intra8x8mby_modes(VP9_COMP *cpi, MACROBLOCK *mb,
 #endif
   }
   *Rate = cost;
-  *rate_y += tot_rate_y;
+  *rate_y = tot_rate_y;
   *Distortion = distortion;
   return RDCOST(mb->rdmult, mb->rddiv, cost, distortion);
 }
@@ -2704,7 +2704,7 @@ static int rd_pick_best_mbsegmentation(VP9_COMP *cpi, MACROBLOCK *x,
   if (mbmi->second_ref_frame)
     x->partition_info->bmi[15].second_mv.as_int = bsi.second_mvs[15].as_int;
 
-  return bsi.segment_rd;
+  return (int)(bsi.segment_rd);
 }
 
 /* Order arr in increasing order, original position stored in idx */
@@ -3390,7 +3390,7 @@ static int64_t handle_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
 #endif
     }
 
-    if (sse < threshold) {
+    if ((int)sse < threshold) {
       unsigned int q2dc = xd->block[24].dequant[0];
       /* If there is no codeable 2nd order dc
        or a very small uniform pixel change change */
@@ -3873,7 +3873,7 @@ static void rd_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
                                            second_ref, best_yrd, mdcounts,
                                            &rate, &rate_y, &distortion,
                                            &skippable,
-                                           this_rd_thresh, seg_mvs,
+                                           (int)this_rd_thresh, seg_mvs,
                                            txfm_cache);
       rate2 += rate;
       distortion2 += distortion;
@@ -4205,11 +4205,12 @@ static void rd_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
   }
 
 end:
-  store_coding_context(x, &x->mb_context[xd->mb_index], best_mode_index, &best_partition,
-                       &frame_best_ref_mv[xd->mode_info_context->mbmi.ref_frame],
-                       &frame_best_ref_mv[xd->mode_info_context->mbmi.second_ref_frame],
-                       best_pred_diff[0], best_pred_diff[1], best_pred_diff[2],
-                       best_txfm_diff);
+  store_coding_context(x, &x->mb_context[xd->mb_index],
+    best_mode_index, &best_partition,
+    &frame_best_ref_mv[xd->mode_info_context->mbmi.ref_frame],
+    &frame_best_ref_mv[xd->mode_info_context->mbmi.second_ref_frame],
+    (int)best_pred_diff[0], (int)best_pred_diff[1], (int)best_pred_diff[2],
+    best_txfm_diff);
 }
 
 #if CONFIG_SUPERBLOCKS

diff --git a/vp9/vp9_cx_iface.c b/vp9/vp9_cx_iface.c
index 1572920..1333cc1 100644 (file)
--- a/vp9/vp9_cx_iface.c
+++ b/vp9/vp9_cx_iface.c
@@ -174,7 +174,7 @@ static vpx_codec_err_t validate_config(vpx_codec_alg_priv_t      *ctx,
 
   if (cfg->g_pass == VPX_RC_LAST_PASS) {
     size_t           packet_sz = sizeof(FIRSTPASS_STATS);
-    int              n_packets = cfg->rc_twopass_stats_in.sz / packet_sz;
+    int              n_packets = (int)(cfg->rc_twopass_stats_in.sz / packet_sz);
     FIRSTPASS_STATS *stats;
 
     if (!cfg->rc_twopass_stats_in.buf)
@@ -691,9 +691,9 @@ static vpx_codec_err_t vp8e_encode(vpx_codec_alg_priv_t  *ctx,
         pkt.data.frame.pts =
           (dst_time_stamp * ctx->cfg.g_timebase.den + round)
           / ctx->cfg.g_timebase.num / 10000000;
-        pkt.data.frame.duration =
-          (delta * ctx->cfg.g_timebase.den + round)
-          / ctx->cfg.g_timebase.num / 10000000;
+        pkt.data.frame.duration = (unsigned long)
+          ((delta * ctx->cfg.g_timebase.den + round)
+          / ctx->cfg.g_timebase.num / 10000000);
         pkt.data.frame.flags = lib_flags << 16;
 
         if (lib_flags & FRAMEFLAGS_KEY)

diff --git a/vpx_ports/x86.h b/vpx_ports/x86.h
index 5aeaf9d..cac8053 100644 (file)
--- a/vpx_ports/x86.h
+++ b/vpx_ports/x86.h
@@ -127,20 +127,6 @@ vpx_cpu_t vpx_x86_vendor(void);
 unsigned __int64 __rdtsc(void);
 #pragma intrinsic(__rdtsc)
 #endif
-static unsigned int
-x86_readtsc(void) {
-#if defined(__GNUC__) && __GNUC__
-  unsigned int tsc;
-  __asm__ __volatile__("rdtsc\n\t":"=a"(tsc):);
-  return tsc;
-#else
-#if ARCH_X86_64
-  return __rdtsc();
-#else
-  __asm  rdtsc;
-#endif
-#endif
-}
 
 
 #if defined(__GNUC__) && __GNUC__