/* *  Copyright (c) 2010 The VP8 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 <stdlib.h>#include <stdio.h>#include <string.h>#include <limits.h>#include <assert.h> #include "math.h"#include "common.h"#include "ratectrl.h"#include "entropymode.h"#include "vpx_mem/vpx_mem.h"#include "systemdependent.h"#include "encodemv.h"  #define MIN_BPB_FACTOR          0.01#define MAX_BPB_FACTOR          50 extern const MB_PREDICTION_MODE vp8_mode_order[MAX_MODES];extern const MV_REFERENCE_FRAME vp8_ref_frame_order[MAX_MODES];   #ifdef MODE_STATSextern int y_modes[5];extern int uv_modes[4];extern int b_modes[10]; extern int inter_y_modes[10];extern int inter_uv_modes[4];extern int inter_b_modes[10];#endif // Bits Per MB at different Q (Multiplied by 512)#define BPER_MB_NORMBITS    9 const int vp8_bits_per_mb[2][QINDEX_RANGE] ={    // (Updated 19 March 08) Baseline estimate of INTRA-frame Bits Per MB at each Q:    {        674781, 606845, 553905, 524293, 500428, 452540, 435379, 414719,        390970, 371082, 359416, 341807, 336957, 317263, 303724, 298402,        285688, 275237, 268455, 262560, 256038, 248734, 241087, 237615,        229247, 225211, 219112, 213920, 211559, 202714, 198482, 193401,        187866, 183453, 179212, 175965, 171852, 167235, 163972, 160560,        156032, 154349, 151390, 148725, 145708, 142311, 139981, 137700,        134084, 131863, 129746, 128498, 126077, 123461, 121290, 117782,        114883, 112332, 108410, 105685, 103434, 101192,  98587,  95959,        94059,  92017,  89970,  87936,  86142,  84801,  82736,  81106,        79668,  78135,  76641,  75103,  73943,  72693,  71401,  70098,        69165,  67901,  67170,  65987,  64923,  63534,  62378,  61302,        59921,  58941,  57844,  56782,  55960,  54973,  54257,  53454,        52230,  50938,  49962,  49190,  48288,  47270,  46738,  46037,        45020,  44027,  43216,  42287,  41594,  40702,  40081,  39414,        38282,  37627,  36987,  36375,  35808,  35236,  34710,  34162,        33659,  33327,  32751,  32384,  31936,  31461,  30982,  30582,    },     // (Updated 19 March 08) Baseline estimate of INTER-frame Bits Per MB at each Q:    {        497401, 426316, 372064, 352732, 335763, 283921, 273848, 253321,        233181, 217727, 210030, 196685, 194836, 178396, 167753, 164116,        154119, 146929, 142254, 138488, 133591, 127741, 123166, 120226,        114188, 111756, 107882, 104749, 102522,  96451,  94424,  90905,        87286,  84931,  82111,  80534,  77610,  74700,  73037,  70715,        68006,  67235,  65374,  64009,  62134,  60180,  59105,  57691,        55509,  54512,  53318,  52693,  51194,  49840,  48944,  46980,        45668,  44177,  42348,  40994,  39859,  38889,  37717,  36391,        35482,  34622,  33795,  32756,  32002,  31492,  30573,  29737,        29152,  28514,  27941,  27356,  26859,  26329,  25874,  25364,        24957,  24510,  24290,  23689,  23380,  22845,  22481,  22066,        21587,  21219,  20880,  20452,  20260,  19926,  19661,  19334,        18915,  18391,  18046,  17833,  17441,  17105,  16888,  16729,        16383,  16023,  15706,  15442,  15222,  14938,  14673,  14452,        14005,  13807,  13611,  13447,  13223,  13102,  12963,  12801,        12627,  12534,  12356,  12228,  12056,  11907,  11746,  11643,    }}; const int vp8_kf_boost_qadjustment[QINDEX_RANGE] ={    128, 129, 130, 131, 132, 133, 134, 135,    136, 137, 138, 139, 140, 141, 142, 143,    144, 145, 146, 147, 148, 149, 150, 151,    152, 153, 154, 155, 156, 157, 158, 159,    160, 161, 162, 163, 164, 165, 166, 167,    168, 169, 170, 171, 172, 173, 174, 175,    176, 177, 178, 179, 180, 181, 182, 183,    184, 185, 186, 187, 188, 189, 190, 191,    192, 193, 194, 195, 196, 197, 198, 199,    200, 200, 201, 201, 202, 203, 203, 203,    204, 204, 205, 205, 206, 206, 207, 207,    208, 208, 209, 209, 210, 210, 211, 211,    212, 212, 213, 213, 214, 214, 215, 215,    216, 216, 217, 217, 218, 218, 219, 219,    220, 220, 220, 220, 220, 220, 220, 220,    220, 220, 220, 220, 220, 220, 220, 220,}; //#define GFQ_ADJUSTMENT (Q+100)#define GFQ_ADJUSTMENT vp8_gf_boost_qadjustment[Q]const int vp8_gf_boost_qadjustment[QINDEX_RANGE] ={    80, 82, 84, 86, 88, 90, 92, 94,    96, 97, 98, 99, 100, 101, 102, 103,    104, 105, 106, 107, 108, 109, 110, 111,    112, 113, 114, 115, 116, 117, 118, 119,    120, 121, 122, 123, 124, 125, 126, 127,    128, 129, 130, 131, 132, 133, 134, 135,    136, 137, 138, 139, 140, 141, 142, 143,    144, 145, 146, 147, 148, 149, 150, 151,    152, 153, 154, 155, 156, 157, 158, 159,    160, 161, 162, 163, 164, 165, 166, 167,    168, 169, 170, 171, 172, 173, 174, 175,    176, 177, 178, 179, 180, 181, 182, 183,    184, 184, 185, 185, 186, 186, 187, 187,    188, 188, 189, 189, 190, 190, 191, 191,    192, 192, 193, 193, 194, 194, 194, 194,    195, 195, 196, 196, 197, 197, 198, 198}; /*const int vp8_gf_boost_qadjustment[QINDEX_RANGE] ={    100,101,102,103,104,105,105,106,    106,107,107,108,109,109,110,111,    112,113,114,115,116,117,118,119,    120,121,122,123,124,125,126,127,    128,129,130,131,132,133,134,135,    136,137,138,139,140,141,142,143,    144,145,146,147,148,149,150,151,    152,153,154,155,156,157,158,159,    160,161,162,163,164,165,166,167,    168,169,170,170,171,171,172,172,    173,173,173,174,174,174,175,175,    175,176,176,176,177,177,177,177,    178,178,179,179,180,180,181,181,    182,182,183,183,184,184,185,185,    186,186,187,187,188,188,189,189,    190,190,191,191,192,192,193,193,};*/ const int vp8_kf_gf_boost_qlimits[QINDEX_RANGE] ={    150, 155, 160, 165, 170, 175, 180, 185,    190, 195, 200, 205, 210, 215, 220, 225,    230, 235, 240, 245, 250, 255, 260, 265,    270, 275, 280, 285, 290, 295, 300, 305,    310, 320, 330, 340, 350, 360, 370, 380,    390, 400, 410, 420, 430, 440, 450, 460,    470, 480, 490, 500, 510, 520, 530, 540,    550, 560, 570, 580, 590, 600, 600, 600,    600, 600, 600, 600, 600, 600, 600, 600,    600, 600, 600, 600, 600, 600, 600, 600,    600, 600, 600, 600, 600, 600, 600, 600,    600, 600, 600, 600, 600, 600, 600, 600,    600, 600, 600, 600, 600, 600, 600, 600,    600, 600, 600, 600, 600, 600, 600, 600,    600, 600, 600, 600, 600, 600, 600, 600,    600, 600, 600, 600, 600, 600, 600, 600,}; // % adjustment to target kf size based on seperation from previous frameconst int vp8_kf_boost_seperationt_adjustment[16] ={    30,   40,   50,   55,   60,   65,   70,   75,    80,   85,   90,   95,  100,  100,  100,  100,};  const int vp8_gf_adjust_table[101] ={    100,    115, 130, 145, 160, 175, 190, 200, 210, 220, 230,    240, 260, 270, 280, 290, 300, 310, 320, 330, 340,    350, 360, 370, 380, 390, 400, 400, 400, 400, 400,    400, 400, 400, 400, 400, 400, 400, 400, 400, 400,    400, 400, 400, 400, 400, 400, 400, 400, 400, 400,    400, 400, 400, 400, 400, 400, 400, 400, 400, 400,    400, 400, 400, 400, 400, 400, 400, 400, 400, 400,    400, 400, 400, 400, 400, 400, 400, 400, 400, 400,    400, 400, 400, 400, 400, 400, 400, 400, 400, 400,    400, 400, 400, 400, 400, 400, 400, 400, 400, 400,}; const int vp8_gf_intra_useage_adjustment[20] ={    125, 120, 115, 110, 105, 100,  95,  85,  80,  75,    70,  65,  60,  55,  50,  50,  50,  50,  50,  50,}; const int vp8_gf_interval_table[101] ={    7,    7, 7, 7, 7, 7, 7, 7, 7, 7, 7,    7, 7, 7, 7, 7, 7, 7, 7, 7, 7,    7, 7, 7, 7, 7, 7, 7, 7, 7, 7,    8, 8, 8, 8, 8, 8, 8, 8, 8, 8,    8, 8, 8, 8, 8, 8, 8, 8, 8, 8,    9, 9, 9, 9, 9, 9, 9, 9, 9, 9,    9, 9, 9, 9, 9, 9, 9, 9, 9, 9,    10, 10, 10, 10, 10, 10, 10, 10, 10, 10,    10, 10, 10, 10, 10, 10, 10, 10, 10, 10,    11, 11, 11, 11, 11, 11, 11, 11, 11, 11,}; static const unsigned int prior_key_frame_weight[KEY_FRAME_CONTEXT] = { 1, 2, 3, 4, 5 };  void vp8_save_coding_context(VP8_COMP *cpi){    CODING_CONTEXT *const cc = & cpi->coding_context;     // Stores a snapshot of key state variables which can subsequently be    // restored with a call to vp8_restore_coding_context. These functions are    // intended for use in a re-code loop in vp8_compress_frame where the    // quantizer value is adjusted between loop iterations.     cc->frames_since_key          = cpi->frames_since_key;    cc->filter_level             = cpi->common.filter_level;    cc->frames_till_gf_update_due   = cpi->frames_till_gf_update_due;    cc->frames_since_golden       = cpi->common.frames_since_golden;     vp8_copy(cc->mvc,      cpi->common.fc.mvc);    vp8_copy(cc->mvcosts,  cpi->mb.mvcosts);     vp8_copy(cc->kf_ymode_prob,   cpi->common.kf_ymode_prob);    vp8_copy(cc->ymode_prob,   cpi->common.fc.ymode_prob);    vp8_copy(cc->kf_uv_mode_prob,  cpi->common.kf_uv_mode_prob);    vp8_copy(cc->uv_mode_prob,  cpi->common.fc.uv_mode_prob);     vp8_copy(cc->ymode_count, cpi->ymode_count);    vp8_copy(cc->uv_mode_count, cpi->uv_mode_count);      // Stats#ifdef MODE_STATS    vp8_copy(cc->y_modes,       y_modes);    vp8_copy(cc->uv_modes,      uv_modes);    vp8_copy(cc->b_modes,       b_modes);    vp8_copy(cc->inter_y_modes,  inter_y_modes);    vp8_copy(cc->inter_uv_modes, inter_uv_modes);    vp8_copy(cc->inter_b_modes,  inter_b_modes);#endif     cc->this_frame_percent_intra = cpi->this_frame_percent_intra;}  void vp8_restore_coding_context(VP8_COMP *cpi){    CODING_CONTEXT *const cc = & cpi->coding_context;     // Restore key state variables to the snapshot state stored in the    // previous call to vp8_save_coding_context.     cpi->frames_since_key         =   cc->frames_since_key;    cpi->common.filter_level     =   cc->filter_level;    cpi->frames_till_gf_update_due  =   cc->frames_till_gf_update_due;    cpi->common.frames_since_golden       =   cc->frames_since_golden;     vp8_copy(cpi->common.fc.mvc, cc->mvc);     vp8_copy(cpi->mb.mvcosts, cc->mvcosts);     vp8_copy(cpi->common.kf_ymode_prob,   cc->kf_ymode_prob);    vp8_copy(cpi->common.fc.ymode_prob,   cc->ymode_prob);    vp8_copy(cpi->common.kf_uv_mode_prob,  cc->kf_uv_mode_prob);    vp8_copy(cpi->common.fc.uv_mode_prob,  cc->uv_mode_prob);     vp8_copy(cpi->ymode_count, cc->ymode_count);    vp8_copy(cpi->uv_mode_count, cc->uv_mode_count);     // Stats#ifdef MODE_STATS    vp8_copy(y_modes, cc->y_modes);    vp8_copy(uv_modes, cc->uv_modes);    vp8_copy(b_modes, cc->b_modes);    vp8_copy(inter_y_modes, cc->inter_y_modes);    vp8_copy(inter_uv_modes, cc->inter_uv_modes);    vp8_copy(inter_b_modes, cc->inter_b_modes);#endif      cpi->this_frame_percent_intra = cc->this_frame_percent_intra;}  void vp8_setup_key_frame(VP8_COMP *cpi){    // Setup for Key frame:     vp8_default_coef_probs(& cpi->common);    vp8_kf_default_bmode_probs(cpi->common.kf_bmode_prob);     vpx_memcpy(cpi->common.fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context));    {        int flag[2] = {1, 1};        vp8_build_component_cost_table(cpi->mb.mvcost, cpi->mb.mvsadcost, (const MV_CONTEXT *) cpi->common.fc.mvc, flag);    }     vpx_memset(cpi->common.fc.pre_mvc, 0, sizeof(cpi->common.fc.pre_mvc));  //initialize pre_mvc to all zero.     //cpi->common.filter_level = 0;      // Reset every key frame.    cpi->common.filter_level = cpi->common.base_qindex * 3 / 8 ;     // Provisional interval before next GF    if (cpi->auto_gold)        //cpi->frames_till_gf_update_due = DEFAULT_GF_INTERVAL;        cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;    else        cpi->frames_till_gf_update_due = cpi->goldfreq;     cpi->common.refresh_golden_frame = TRUE;} void vp8_calc_auto_iframe_target_size(VP8_COMP *cpi){    // boost defaults to half second    int kf_boost;     // Clear down mmx registers to allow floating point in what follows    vp8_clear_system_state();  //__asm emms;     if (cpi->oxcf.fixed_q >= 0)    {        vp8_calc_iframe_target_size(cpi);        return;    }     if (cpi->pass == 2)    {        cpi->this_frame_target = cpi->per_frame_bandwidth;      // New Two pass RC    }    else    {        // Boost depends somewhat on frame rate        kf_boost = (int)(2 * cpi->output_frame_rate - 16);         // adjustment up based on q        kf_boost = kf_boost * vp8_kf_boost_qadjustment[cpi->ni_av_qi] / 100;         // frame separation adjustment ( down)        if (cpi->frames_since_key  < cpi->output_frame_rate / 2)            kf_boost = (int)(kf_boost * cpi->frames_since_key / (cpi->output_frame_rate / 2));         if (kf_boost < 16)            kf_boost = 16;         // Reset the active worst quality to the baseline value for key frames.        cpi->active_worst_quality = cpi->worst_quality;         cpi->this_frame_target = ((16 + kf_boost)  * cpi->per_frame_bandwidth) >> 4;    }      // Should the next frame be an altref frame    if (cpi->pass != 2)    {        // For now Alt ref is not allowed except in 2 pass modes.        cpi->source_alt_ref_pending = FALSE;         /*if ( cpi->oxcf.fixed_q == -1)        {            if ( cpi->oxcf.play_alternate && ( (cpi->last_boost/2) > (100+(AF_THRESH*cpi->frames_till_gf_update_due)) ) )                cpi->source_alt_ref_pending = TRUE;            else                cpi->source_alt_ref_pending = FALSE;        }*/    }     if (0)    {        FILE *f;         f = fopen("kf_boost.stt", "a");        //fprintf(f, " %8d %10d %10d %10d %10d %10d %10d\n",        //  cpi->common.current_video_frame,  cpi->target_bandwidth, cpi->frames_to_key, kf_boost_qadjustment[cpi->ni_av_qi], cpi->kf_boost, (cpi->this_frame_target *100 / cpi->per_frame_bandwidth), cpi->this_frame_target );         fprintf(f, " %8u %10d %10d %10d\n",                cpi->common.current_video_frame,  cpi->gfu_boost, cpi->baseline_gf_interval, cpi->source_alt_ref_pending);         fclose(f);    }} //  Do the best we can to define the parameteres for the next GF based on what information we have available.static void calc_gf_params(VP8_COMP *cpi){    int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;    int Boost = 0;     int gf_frame_useage = 0;      // Golden frame useage since last GF    int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME]  +                  cpi->recent_ref_frame_usage[LAST_FRAME]   +                  cpi->recent_ref_frame_usage[GOLDEN_FRAME] +                  cpi->recent_ref_frame_usage[ALTREF_FRAME];     int pct_gf_active = (100 * cpi->common.gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols);     // Reset the last boost indicator    //cpi->last_boost = 100;     if (tot_mbs)        gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] + cpi->recent_ref_frame_usage[ALTREF_FRAME]) * 100 / tot_mbs;     if (pct_gf_active > gf_frame_useage)        gf_frame_useage = pct_gf_active;     // Not two pass    if (cpi->pass != 2)    {        // Single Pass lagged mode: TBD        if (FALSE)        {        }         // Single Pass compression: Has to use current and historical data        else        {#if 0            // Experimental code            int index = cpi->one_pass_frame_index;            int frames_to_scan = (cpi->max_gf_interval <= MAX_LAG_BUFFERS) ? cpi->max_gf_interval : MAX_LAG_BUFFERS;             /*            // *************** Experimental code - incomplete            double decay_val = 1.0;            double IIAccumulator = 0.0;            double last_iiaccumulator = 0.0;            double IIRatio;             cpi->one_pass_frame_index = cpi->common.current_video_frame%MAX_LAG_BUFFERS;             for ( i = 0; i < (frames_to_scan - 1); i++ )            {                if ( index < 0 )                    index = MAX_LAG_BUFFERS;                index --;                 if ( cpi->one_pass_frame_stats[index].frame_coded_error > 0.0 )                {                    IIRatio = cpi->one_pass_frame_stats[index].frame_intra_error / cpi->one_pass_frame_stats[index].frame_coded_error;                     if ( IIRatio > 30.0 )                        IIRatio = 30.0;                }                else                    IIRatio = 30.0;                 IIAccumulator += IIRatio * decay_val;                 decay_val = decay_val * cpi->one_pass_frame_stats[index].frame_pcnt_inter;                 if (    (i > MIN_GF_INTERVAL) &&                        ((IIAccumulator - last_iiaccumulator) < 2.0) )                {                    break;                }                last_iiaccumulator = IIAccumulator;            }             Boost = IIAccumulator*100.0/16.0;            cpi->baseline_gf_interval = i;             */#else             /*************************************************************/            // OLD code             // Adjust boost based upon ambient Q            Boost = GFQ_ADJUSTMENT;             // Adjust based upon most recently measure intra useage            Boost = Boost * vp8_gf_intra_useage_adjustment[(cpi->this_frame_percent_intra < 15) ? cpi->this_frame_percent_intra : 14] / 100;             // Adjust gf boost based upon GF usage since last GF            Boost = Boost * vp8_gf_adjust_table[gf_frame_useage] / 100;#endif        }         // golden frame boost without recode loop often goes awry.  be safe by keeping numbers down.        if (!cpi->sf.recode_loop)        {            if (cpi->compressor_speed == 2)                Boost = Boost / 2;        }

Lines 1–500 of 1555. Load more