frame_enc.c | Explore in Territory

// Copyright 2011 Google Inc. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the COPYING 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.
// -----------------------------------------------------------------------------
//
//   frame coding and analysis
//
// Author: Skal ([email protected])

#include <string.h>
#include <math.h>

#include "src/enc/cost_enc.h"
#include "src/enc/vp8i_enc.h"
#include "src/dsp/dsp.h"
#include "src/webp/format_constants.h"  // RIFF constants

#define SEGMENT_VISU …
#define DEBUG_SEARCH …

//------------------------------------------------------------------------------
// multi-pass convergence

#define HEADER_SIZE_ESTIMATE …
#define DQ_LIMIT …
// we allow 2k of extra head-room in PARTITION0 limit.
#define PARTITION0_SIZE_LIMIT …

static float Clamp(float v, float min, float max) { … }

PassStats;

static int InitPassStats(const VP8Encoder* const enc, PassStats* const s) { … }

static float ComputeNextQ(PassStats* const s) { … }

//------------------------------------------------------------------------------
// Tables for level coding

const uint8_t VP8Cat3[] = …;
const uint8_t VP8Cat4[] = …;
const uint8_t VP8Cat5[] = …;
const uint8_t VP8Cat6[] = …;

//------------------------------------------------------------------------------
// Reset the statistics about: number of skips, token proba, level cost,...

static void ResetStats(VP8Encoder* const enc) { … }

//------------------------------------------------------------------------------
// Skip decision probability

#define SKIP_PROBA_THRESHOLD …

static int CalcSkipProba(uint64_t nb, uint64_t total) { … }

// Returns the bit-cost for coding the skip probability.
static int FinalizeSkipProba(VP8Encoder* const enc) { … }

// Collect statistics and deduce probabilities for next coding pass.
// Return the total bit-cost for coding the probability updates.
static int CalcTokenProba(int nb, int total) { … }

// Cost of coding 'nb' 1's and 'total-nb' 0's using 'proba' probability.
static int BranchCost(int nb, int total, int proba) { … }

static void ResetTokenStats(VP8Encoder* const enc) { … }

static int FinalizeTokenProbas(VP8EncProba* const proba) { … }

//------------------------------------------------------------------------------
// Finalize Segment probability based on the coding tree

static int GetProba(int a, int b) { … }

static void ResetSegments(VP8Encoder* const enc) { … }

static void SetSegmentProbas(VP8Encoder* const enc) { … }

//------------------------------------------------------------------------------
// Coefficient coding

static int PutCoeffs(VP8BitWriter* const bw, int ctx, const VP8Residual* res) { … }

static void CodeResiduals(VP8BitWriter* const bw, VP8EncIterator* const it,
                          const VP8ModeScore* const rd) { … }

// Same as CodeResiduals, but doesn't actually write anything.
// Instead, it just records the event distribution.
static void RecordResiduals(VP8EncIterator* const it,
                            const VP8ModeScore* const rd) { … }

//------------------------------------------------------------------------------
// Token buffer

#if !defined(DISABLE_TOKEN_BUFFER)

static int RecordTokens(VP8EncIterator* const it, const VP8ModeScore* const rd,
                        VP8TBuffer* const tokens) { … }

#endif    // !DISABLE_TOKEN_BUFFER

//------------------------------------------------------------------------------
// ExtraInfo map / Debug function

#if !defined(WEBP_DISABLE_STATS)

#if SEGMENT_VISU
static void SetBlock(uint8_t* p, int value, int size) {
  int y;
  for (y = 0; y < size; ++y) {
    memset(p, value, size);
    p += BPS;
  }
}
#endif

static void ResetSSE(VP8Encoder* const enc) { … }

static void StoreSSE(const VP8EncIterator* const it) { … }

static void StoreSideInfo(const VP8EncIterator* const it) { … }

static void ResetSideInfo(const VP8EncIterator* const it) { … }
#else  // defined(WEBP_DISABLE_STATS)
static void ResetSSE(VP8Encoder* const enc) {
  (void)enc;
}
static void StoreSideInfo(const VP8EncIterator* const it) {
  VP8Encoder* const enc = it->enc_;
  WebPPicture* const pic = enc->pic_;
  if (pic->extra_info != NULL) {
    if (it->x_ == 0 && it->y_ == 0) {   // only do it once, at start
      memset(pic->extra_info, 0,
             enc->mb_w_ * enc->mb_h_ * sizeof(*pic->extra_info));
    }
  }
}

static void ResetSideInfo(const VP8EncIterator* const it) {
  (void)it;
}
#endif  // !defined(WEBP_DISABLE_STATS)

static double GetPSNR(uint64_t mse, uint64_t size) { … }

//------------------------------------------------------------------------------
//  StatLoop(): only collect statistics (number of skips, token usage, ...).
//  This is used for deciding optimal probabilities. It also modifies the
//  quantizer value if some target (size, PSNR) was specified.

static void SetLoopParams(VP8Encoder* const enc, float q) { … }

static uint64_t OneStatPass(VP8Encoder* const enc, VP8RDLevel rd_opt,
                            int nb_mbs, int percent_delta,
                            PassStats* const s) { … }

static int StatLoop(VP8Encoder* const enc) { … }

//------------------------------------------------------------------------------
// Main loops
//

static const uint8_t kAverageBytesPerMB[8] = …;

static int PreLoopInitialize(VP8Encoder* const enc) { … }

static int PostLoopFinalize(VP8EncIterator* const it, int ok) { … }

//------------------------------------------------------------------------------
//  VP8EncLoop(): does the final bitstream coding.

static void ResetAfterSkip(VP8EncIterator* const it) { … }

int VP8EncLoop(VP8Encoder* const enc) { … }

//------------------------------------------------------------------------------
// Single pass using Token Buffer.

#if !defined(DISABLE_TOKEN_BUFFER)

#define MIN_COUNT …

int VP8EncTokenLoop(VP8Encoder* const enc) { … }

#else

int VP8EncTokenLoop(VP8Encoder* const enc) {
  (void)enc;
  return 0;   // we shouldn't be here.
}

#endif    // DISABLE_TOKEN_BUFFER

//------------------------------------------------------------------------------
godot/thirdparty/libwebp/src/enc/frame_enc.c
