libvpx: Pull from upstream

source/libvpx/vp8/encoder/onyx_if.c

 /*
  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 
 #include "vpx_config.h"
 #include "./vpx_scale_rtcd.h"
 #include "./vpx_dsp_rtcd.h"
 #include "./vp8_rtcd.h"
 #include "vp8/common/onyxc_int.h"
 #include "vp8/common/blockd.h"
 #include "onyx_int.h"
 #include "vp8/common/systemdependent.h"
-#include "quantize.h"
+#include "vp8/encoder/quantize.h"
 #include "vp8/common/alloccommon.h"
 #include "mcomp.h"
 #include "firstpass.h"
 #include "vpx/internal/vpx_psnr.h"
 #include "vpx_scale/vpx_scale.h"
 #include "vp8/common/extend.h"
 #include "ratectrl.h"
 #include "vp8/common/quant_common.h"
 #include "segmentation.h"
 #if CONFIG_POSTPROC
@@ skipping 36 matching lines @@
 int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest);
 
 extern void vp8_temporal_filter_prepare_c(VP8_COMP *cpi, int distance);
 
 static void set_default_lf_deltas(VP8_COMP *cpi);
 
 extern const int vp8_gf_interval_table[101];
 
 #if CONFIG_INTERNAL_STATS
 #include "math.h"
-
-extern double vp8_calc_ssim
-(
-    YV12_BUFFER_CONFIG *source,
-    YV12_BUFFER_CONFIG *dest,
-    int lumamask,
-    double *weight
-);
-
-
-extern double vp8_calc_ssimg
-(
-    YV12_BUFFER_CONFIG *source,
-    YV12_BUFFER_CONFIG *dest,
-    double *ssim_y,
-    double *ssim_u,
-    double *ssim_v
-);
-
-
+#include "vpx_dsp/ssim.h"
 #endif
 
 
 #ifdef OUTPUT_YUV_SRC
 FILE *yuv_file;
 #endif
 #ifdef OUTPUT_YUV_DENOISED
 FILE *yuv_denoised_file;
 #endif
 
@@ skipping 421 matching lines @@
  * abs_delta = SEGMENT_ABSDATA (use the absolute values given).
  *
  */
 static void set_segment_data(VP8_COMP *cpi, signed char *feature_data, unsigned char abs_delta)
 {
     cpi->mb.e_mbd.mb_segement_abs_delta = abs_delta;
     memcpy(cpi->segment_feature_data, feature_data, sizeof(cpi->segment_feature_data));
 }
 
 
-static void segmentation_test_function(VP8_COMP *cpi)
-{
-    unsigned char *seg_map;
-    signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
-
-    // Create a temporary map for segmentation data.
-    CHECK_MEM_ERROR(seg_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
-
-    // Set the segmentation Map
-    set_segmentation_map(cpi, seg_map);
-
-    // Activate segmentation.
-    enable_segmentation(cpi);
-
-    // Set up the quant segment data
-    feature_data[MB_LVL_ALT_Q][0] = 0;
-    feature_data[MB_LVL_ALT_Q][1] = 4;
-    feature_data[MB_LVL_ALT_Q][2] = 0;
-    feature_data[MB_LVL_ALT_Q][3] = 0;
-    // Set up the loop segment data
-    feature_data[MB_LVL_ALT_LF][0] = 0;
-    feature_data[MB_LVL_ALT_LF][1] = 0;
-    feature_data[MB_LVL_ALT_LF][2] = 0;
-    feature_data[MB_LVL_ALT_LF][3] = 0;
-
-    // Initialise the feature data structure
-    // SEGMENT_DELTADATA    0, SEGMENT_ABSDATA      1
-    set_segment_data(cpi, &feature_data[0][0], SEGMENT_DELTADATA);
-
-    // Delete sementation map
-    vpx_free(seg_map);
-
-    seg_map = 0;
-}
-
 /* A simple function to cyclically refresh the background at a lower Q */
 static void cyclic_background_refresh(VP8_COMP *cpi, int Q, int lf_adjustment)
 {
     unsigned char *seg_map = cpi->segmentation_map;
     signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
     int i;
     int block_count = cpi->cyclic_refresh_mode_max_mbs_perframe;
     int mbs_in_frame = cpi->common.mb_rows * cpi->common.mb_cols;
 
     cpi->cyclic_refresh_q = Q / 2;
@@ skipping 342 matching lines @@
     cpi->mode_check_freq[THR_NEW3]   = speed_map(Speed,
                                                  mode_check_freq_map_new2);
     cpi->mode_check_freq[THR_SPLIT1] = speed_map(Speed,
                                                  mode_check_freq_map_split1);
     cpi->mode_check_freq[THR_SPLIT2] =
     cpi->mode_check_freq[THR_SPLIT3] = speed_map(Speed,
                                                  mode_check_freq_map_split2);
     Speed = cpi->Speed;
     switch (Mode)
     {
-#if !(CONFIG_REALTIME_ONLY)
+#if !CONFIG_REALTIME_ONLY
     case 0: /* best quality mode */
         sf->first_step = 0;
         sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
         break;
     case 1:
     case 3:
         if (Speed > 0)
         {
             /* Disable coefficient optimization above speed 0 */
             sf->optimize_coefficients = 0;
@@ skipping 1131 matching lines @@
     yuv_denoised_file = fopen("denoised.yuv", "ab");
 #endif
 
 #if 0
     framepsnr = fopen("framepsnr.stt", "a");
     kf_list = fopen("kf_list.stt", "w");
 #endif
 
     cpi->output_pkt_list = oxcf->output_pkt_list;
 
-#if !(CONFIG_REALTIME_ONLY)
+#if !CONFIG_REALTIME_ONLY
 
     if (cpi->pass == 1)
     {
         vp8_init_first_pass(cpi);
     }
     else if (cpi->pass == 2)
     {
         size_t packet_sz = sizeof(FIRSTPASS_STATS);
         int packets = (int)(oxcf->two_pass_stats_in.sz / packet_sz);
 
@@ skipping 141 matching lines @@
 
 void vp8_remove_compressor(VP8_COMP **ptr)
 {
     VP8_COMP *cpi = *ptr;
 
     if (!cpi)
         return;
 
     if (cpi && (cpi->common.current_video_frame > 0))
     {
-#if !(CONFIG_REALTIME_ONLY)
+#if !CONFIG_REALTIME_ONLY
 
         if (cpi->pass == 2)
         {
             vp8_end_second_pass(cpi);
         }
 
 #endif
 
 #ifdef VP8_ENTROPY_STATS
         print_context_counters();
@@ skipping 770 matching lines @@
 
             if (cpi->prob_gf_coded < 10)
                 cpi->prob_gf_coded = 10;
         }
         if (!cpi->source_alt_ref_active)
             cpi->prob_gf_coded = 255;
     }
 }
 
 
+#if !CONFIG_REALTIME_ONLY
 /* 1 = key, 0 = inter */
 static int decide_key_frame(VP8_COMP *cpi)
 {
     VP8_COMMON *cm = &cpi->common;
 
     int code_key_frame = 0;
 
     cpi->kf_boost = 0;
 
     if (cpi->Speed > 11)
@@ skipping 47 matching lines @@
               (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra + 10))))
     {
         if (!cm->refresh_golden_frame)
             code_key_frame = 1;
     }
 
     return code_key_frame;
 
 }
 
-#if !(CONFIG_REALTIME_ONLY)
 static void Pass1Encode(VP8_COMP *cpi, unsigned long *size, unsigned char *dest, unsigned int *frame_flags)
 {
     (void) size;
     (void) dest;
     (void) frame_flags;
     vp8_set_quantizer(cpi, 26);
 
     vp8_first_pass(cpi);
 }
 #endif
@@ skipping 25 matching lines @@
     yframe = fopen(filename, "wb");
 
     for (i = 0; i < frame->uv_height; i++)
         fwrite(frame->v_buffer + i * frame->uv_stride, frame->uv_width, 1, yframe);
 
     fclose(yframe);
 }
 #endif
 /* return of 0 means drop frame */
 
+#if !CONFIG_REALTIME_ONLY
 /* Function to test for conditions that indeicate we should loop
  * back and recode a frame.
  */
 static int recode_loop_test( VP8_COMP *cpi,
                               int high_limit, int low_limit,
                               int q, int maxq, int minq )
 {
     int force_recode = 0;
     VP8_COMMON *cm = &cpi->common;
 
@@ skipping 29 matching lines @@
                       (cpi->active_best_quality > cpi->oxcf.cq_level))
             {
                 force_recode = 1;
                 cpi->active_best_quality = cpi->oxcf.cq_level;
             }
         }
     }
 
     return force_recode;
 }
+#endif  // !CONFIG_REALTIME_ONLY
 
 static void update_reference_frames(VP8_COMP *cpi)
 {
     VP8_COMMON *cm = &cpi->common;
     YV12_BUFFER_CONFIG *yv12_fb = cm->yv12_fb;
 
     /* At this point the new frame has been encoded.
      * If any buffer copy / swapping is signaled it should be done here.
      */
 
@@ skipping 401 matching lines @@
     int Q;
     int frame_over_shoot_limit;
     int frame_under_shoot_limit;
 
     int Loop = 0;
     int loop_count;
 
     VP8_COMMON *cm = &cpi->common;
     int active_worst_qchanged = 0;
 
-#if !(CONFIG_REALTIME_ONLY)
+#if !CONFIG_REALTIME_ONLY
     int q_low;
     int q_high;
     int zbin_oq_high;
     int zbin_oq_low = 0;
     int top_index;
     int bottom_index;
     int overshoot_seen = 0;
     int undershoot_seen = 0;
 #endif
 
@@ skipping 18 matching lines @@
 
     if(cpi->force_next_frame_intra)
     {
         cm->frame_type = KEY_FRAME;  /* delayed intra frame */
         cpi->force_next_frame_intra = 0;
     }
 
     /* For an alt ref frame in 2 pass we skip the call to the second pass
      * function that sets the target bandwidth
      */
-#if !(CONFIG_REALTIME_ONLY)
+#if !CONFIG_REALTIME_ONLY
 
     if (cpi->pass == 2)
     {
         if (cpi->common.refresh_alt_ref_frame)
         {
             /* Per frame bit target for the alt ref frame */
             cpi->per_frame_bandwidth = cpi->twopass.gf_bits;
             /* per second target bitrate */
             cpi->target_bandwidth = (int)(cpi->twopass.gf_bits *
                                           cpi->output_framerate);
@@ skipping 488 matching lines @@
 
     if (cpi->active_best_quality < cpi->best_quality)
         cpi->active_best_quality = cpi->best_quality;
 
     if ( cpi->active_worst_quality < cpi->active_best_quality )
         cpi->active_worst_quality = cpi->active_best_quality;
 
     /* Determine initial Q to try */
     Q = vp8_regulate_q(cpi, cpi->this_frame_target);
 
-#if !(CONFIG_REALTIME_ONLY)
+#if !CONFIG_REALTIME_ONLY
 
     /* Set highest allowed value for Zbin over quant */
     if (cm->frame_type == KEY_FRAME)
         zbin_oq_high = 0;
     else if ((cpi->oxcf.number_of_layers == 1) && ((cm->refresh_alt_ref_frame ||
               (cm->refresh_golden_frame && !cpi->source_alt_ref_active))))
     {
           zbin_oq_high = 16;
     }
     else
         zbin_oq_high = ZBIN_OQ_MAX;
 #endif
 
     /* Setup background Q adjustment for error resilient mode.
      * For multi-layer encodes only enable this for the base layer.
     */
     if (cpi->cyclic_refresh_mode_enabled)
     {
       // Special case for screen_content_mode with golden frame updates.
       int disable_cr_gf = (cpi->oxcf.screen_content_mode == 2 &&
                            cm->refresh_golden_frame);
       if (cpi->current_layer == 0 && cpi->force_maxqp == 0 && !disable_cr_gf)
         cyclic_background_refresh(cpi, Q, 0);
       else
         disable_segmentation(cpi);
     }
 
     vp8_compute_frame_size_bounds(cpi, &frame_under_shoot_limit, &frame_over_shoot_limit);
 
-#if !(CONFIG_REALTIME_ONLY)
+#if !CONFIG_REALTIME_ONLY
     /* Limit Q range for the adaptive loop. */
     bottom_index = cpi->active_best_quality;
     top_index    = cpi->active_worst_quality;
     q_low  = cpi->active_best_quality;
     q_high = cpi->active_worst_quality;
 #endif
 
     vp8_save_coding_context(cpi);
 
     loop_count = 0;
@@ skipping 210 matching lines @@
 #endif
         vp8_clear_system_state();
 
         /* Test to see if the stats generated for this frame indicate that
          * we should have coded a key frame (assuming that we didn't)!
          */
 
         if (cpi->pass != 2 && cpi->oxcf.auto_key && cm->frame_type != KEY_FRAME
             && cpi->compressor_speed != 2)
         {
-#if !(CONFIG_REALTIME_ONLY)
+#if !CONFIG_REALTIME_ONLY
             if (decide_key_frame(cpi))
             {
                 /* Reset all our sizing numbers and recode */
                 cm->frame_type = KEY_FRAME;
 
                 vp8_pick_frame_size(cpi);
 
                 /* Clear the Alt reference frame active flag when we have
                  * a key frame
                  */
@@ skipping 35 matching lines @@
         {
             int over_size_percent = ((cpi->projected_frame_size - frame_over_shoot_limit) * 100) / frame_over_shoot_limit;
 
             /* If so is there any scope for relaxing it */
             while ((cpi->active_worst_quality < cpi->worst_quality) && (over_size_percent > 0))
             {
                 cpi->active_worst_quality++;
                 /* Assume 1 qstep = about 4% on frame size. */
                 over_size_percent = (int)(over_size_percent * 0.96);
             }
-#if !(CONFIG_REALTIME_ONLY)
+#if !CONFIG_REALTIME_ONLY
             top_index = cpi->active_worst_quality;
-#endif
+#endif  // !CONFIG_REALTIME_ONLY
             /* If we have updated the active max Q do not call
              * vp8_update_rate_correction_factors() this loop.
              */
             active_worst_qchanged = 1;
         }
         else
             active_worst_qchanged = 0;
 
-#if !(CONFIG_REALTIME_ONLY)
+#if !CONFIG_REALTIME_ONLY
         /* Special case handling for forced key frames */
         if ( (cm->frame_type == KEY_FRAME) && cpi->this_key_frame_forced )
         {
             int last_q = Q;
             int kf_err = vp8_calc_ss_err(cpi->Source,
                                          &cm->yv12_fb[cm->new_fb_idx]);
 
             /* The key frame is not good enough */
             if ( kf_err > ((cpi->ambient_err * 7) >> 3) )
             {
@@ skipping 717 matching lines @@
                cm->yv12_fb[cm->lst_fb_idx].frame_size, 1, recon_file);
         fclose(recon_file);
     }
 #endif
 
     /* DEBUG */
     /* vp8_write_yuv_frame("encoder_recon.yuv", cm->frame_to_show); */
 
 
 }
-#if !(CONFIG_REALTIME_ONLY)
+#if !CONFIG_REALTIME_ONLY
 static void Pass2Encode(VP8_COMP *cpi, unsigned long *size, unsigned char *dest, unsigned char * dest_end, unsigned int *frame_flags)
 {
 
     if (!cpi->common.refresh_alt_ref_frame)
         vp8_second_pass(cpi);
 
     encode_frame_to_data_rate(cpi, size, dest, dest_end, frame_flags);
     cpi->twopass.bits_left -= 8 * *size;
 
     if (!cpi->common.refresh_alt_ref_frame)
@@ skipping 63 matching lines @@
         vp8_clear_system_state();
         return VPX_CODEC_CORRUPT_FRAME;
     }
 
     cpi->common.error.setjmp = 1;
 
     vpx_usec_timer_start(&cmptimer);
 
     cpi->source = NULL;
 
-#if !(CONFIG_REALTIME_ONLY)
+#if !CONFIG_REALTIME_ONLY
     /* Should we code an alternate reference frame */
     if (cpi->oxcf.error_resilient_mode == 0 &&
         cpi->oxcf.play_alternate &&
         cpi->source_alt_ref_pending)
     {
         if ((cpi->source = vp8_lookahead_peek(cpi->lookahead,
                                               cpi->frames_till_gf_update_due,
                                               PEEK_FORWARD)))
         {
             cpi->alt_ref_source = cpi->source;
@@ skipping 47 matching lines @@
         *frame_flags = cpi->source->flags;
 
         if (cpi->pass == 1 && cm->current_video_frame > 0)
         {
             cpi->last_frame_unscaled_source = &cpi->last_source->img;
         }
     }
     else
     {
         *size = 0;
-#if !(CONFIG_REALTIME_ONLY)
+#if !CONFIG_REALTIME_ONLY
 
         if (flush && cpi->pass == 1 && !cpi->twopass.first_pass_done)
         {
             vp8_end_first_pass(cpi);    /* get last stats packet */
             cpi->twopass.first_pass_done = 1;
         }
 
 #endif
 
         return -1;
@@ skipping 172 matching lines @@
         {
             if(!cm->yv12_fb[i].flags)
             {
                 cm->new_fb_idx = i;
                 break;
             }
         }
 
         assert(i < NUM_YV12_BUFFERS );
     }
-#if !(CONFIG_REALTIME_ONLY)
+#if !CONFIG_REALTIME_ONLY
 
     if (cpi->pass == 1)
     {
         Pass1Encode(cpi, size, dest, frame_flags);
     }
     else if (cpi->pass == 2)
     {
         Pass2Encode(cpi, size, dest, dest_end, frame_flags);
     }
     else
@@ skipping 141 matching lines @@
 
                     cpi->totalp_y += vpx_sse_to_psnr(y_samples,
                                                      255.0, (double)ye);
                     cpi->totalp_u += vpx_sse_to_psnr(uv_samples,
                                                      255.0, (double)ue);
                     cpi->totalp_v += vpx_sse_to_psnr(uv_samples,
                                                      255.0, (double)ve);
                     cpi->total_sq_error2 += sq_error2;
                     cpi->totalp  += frame_psnr2;
 
-                    frame_ssim2 = vp8_calc_ssim(cpi->Source,
-                      &cm->post_proc_buffer, 1, &weight);
+                    frame_ssim2 = vpx_calc_ssim(cpi->Source,
+                      &cm->post_proc_buffer, &weight);
 
                     cpi->summed_quality += frame_ssim2 * weight;
                     cpi->summed_weights += weight;
 
                     if (cpi->oxcf.number_of_layers > 1)
                     {
                          unsigned int i;
 
                          for (i=cpi->current_layer;
                                        i<cpi->oxcf.number_of_layers; i++)
                          {
                              cpi->frames_in_layer[i]++;
 
                              cpi->bytes_in_layer[i] += *size;
                              cpi->sum_psnr[i]       += frame_psnr;
                              cpi->sum_psnr_p[i]     += frame_psnr2;
                              cpi->total_error2[i]   += sq_error;
                              cpi->total_error2_p[i] += sq_error2;
                              cpi->sum_ssim[i]       += frame_ssim2 * weight;
                              cpi->sum_weights[i]    += weight;
                          }
                     }
                 }
 #endif
             }
 
             if (cpi->b_calculate_ssimg)
             {
                 double y, u, v, frame_all;
-                frame_all =  vp8_calc_ssimg(cpi->Source, cm->frame_to_show,
+                frame_all = vpx_calc_ssimg(cpi->Source, cm->frame_to_show,
                     &y, &u, &v);
 
                 if (cpi->oxcf.number_of_layers > 1)
                 {
                     unsigned int i;
 
                     for (i=cpi->current_layer;
                          i<cpi->oxcf.number_of_layers; i++)
                     {
                         if (!cpi->b_calculate_psnr)
@@ skipping 216 matching lines @@
     }
 
     return Total;
 }
 
 
 int vp8_get_quantizer(VP8_COMP *cpi)
 {
     return cpi->common.base_qindex;
 }